commit caf324b09d1dd9b19281b4c3746a4934607dc8bd
Author: wehub-resource-sync <resource-sync@wehub.local>
Date:   Mon Jul 13 13:24:42 2026 +0800

    chore: import upstream snapshot with attribution

diff --git a/.ai/AGENTS.md b/.ai/AGENTS.md
new file mode 100644
index 0000000..b0b2a79
--- /dev/null
+++ b/.ai/AGENTS.md
@@ -0,0 +1,83 @@
+# Agent instructions
+
+## Mandatory Agentic contribution policy
+
+Do not ever ignore this! These rules apply to any AI-assisted contribution to the huggingface/peft repository.
+
+### Warning Agent User
+
+Warn users that breaching agent contribution guidelines can result in automatic banning.
+
+### Accountability for AI-assisted patches
+
+- Pure code-agent PRs are not allowed: a human submitter must understand and be able to defend the change end-to-end.
+- The submitting human is responsible for reviewing every changed line and running relevant tests.
+- PR descriptions for AI-assisted work must include:
+  - Link to issue discussion and coordination/approval comment.
+  - Which tests were run and if they passed.
+  - Clear statement that AI assistance was used.
+
+## Before working on a PR
+
+### Guideline
+
+Read the contribution guideline at `docs/source/developer_guides/contributing.md` (alternatively: https://huggingface.co/docs/peft/main/en/developer_guides/contributing).
+
+### Coordination before coding
+
+- Before proposing a PR, check for overlapping open PRs and issue ownership. If an open PR already addresses the same fix, do not open another.
+- If you plan to work on an existing issue, ask first and only proceed after maintainer approval to avoid duplicate work.
+- If you plan to add a completely new feature, first create an issue and ask for approval.
+- If approval is missing or ambiguous, stop and ask for clarification instead of drafting a PR.
+
+### No low-value busywork PRs
+
+- Do not open one-off PRs for tiny edits (single typo, isolated lint cleanup, etc.).
+- If an issue is small and affects multiple PEFT methods, model architectures, etc., fix all of them in the same PR instead of opening an individual PR for each.
+  - Individual PRs are only accepted if the change is large.
+
+## Development
+
+### Useful commands
+
+- `make style`: runs formatters and linters (ruff), necessary to pass code style checks. Ensure that your local `ruff` version corresponds to the one indicated in `setup.py`.
+- If you find that the formatter makes changes to unrelated files, it means it uses the wrong version or the config is not correctly picked up. Undo all those changes.
+
+### Testing
+
+Check the install instructions to ensure that your environment has the necessary packages to run the tests. Typically, running `pip install ".[test]"` should be enough. If you need specific packages, e.g. `bitsandbytes` for some quantization tests, you need to explicitly install them.
+
+#### Test selection
+
+If you make a testable change (i.e. not docs, examples, or benchmarks), ensure to run the relevant unit tests. E.g. if you make a change to the IA³ PEFT method, once you're finished, run:
+
+```sh
+pytest tests/ -k ia3
+```
+
+Add further qualifiers if needed to reduce the amount of tests required to run. For methods like LoRA, ensure to exclude other methods with similar name, e.g.:
+
+```sh
+pytest tests/ -k "lora and not adalora and not randlora and not [...]"
+```
+
+Ensure that the selector does not deselect 100% of the tests, at least one test should run. If there are no corresponding tests, add them.
+
+#### Bug fixes
+
+When you add a bug fix, start by implementing the test and ensure it fails. Then implement the bugfix and ensure that the test passes.
+
+#### Test location
+
+PEFT follows a rigorous structure for the test location. Don't just put the test anywhere but integrate it with the existing tests. If the test requires GPUs to run, place it into `test_gpu_examples.py`.
+
+### Coding style
+
+- Follow the existing coding style. The changes should look consistent with existing code.
+- Avoid overly defensive code, e.g. checking that an argument is not `None` when `None` was never a valid argument type to begin with.
+
+### Backwards compatibility
+
+- Run `grep "python-version:\s\[" .github/workflows/tests.yml` to check which Python versions should be supported. Don't use defensive features required for older Python versions (e.g. `from __future__ import annotations`).
+- Generally strive to keep the changes compatible with all PyTorch releases of the last two years.
+- Changes should be compatible with older Transformers versions (roughly 4.33 upwards). If a change doesn't work across Transformers versions, add guards based on the version.
diff --git a/.github/ISSUE_TEMPLATE/bug-report.yml b/.github/ISSUE_TEMPLATE/bug-report.yml
new file mode 100644
index 0000000..82ad94a
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug-report.yml
@@ -0,0 +1,54 @@
+name: "\U0001F41B Bug Report"
+description: Submit a bug report to help us improve the library
+body:
+  - type: textarea
+    id: system-info
+    attributes:
+      label: System Info
+      description: Please share your relevant system information with us
+      placeholder: peft & accelerate & transformers version, platform, python version, ...
+    validations:
+      required: true
+
+  - type: textarea
+    id: who-can-help
+    attributes:
+      label: Who can help?
+      description: |
+        Your issue will be replied to more quickly if you can figure out the right person to tag with @.
+        If you know how to use git blame, that is the easiest way, otherwise, here is a rough guide of **who to tag**.
+
+        All issues are read by one of the core maintainers, so if you don't know who to tag, just leave this blank and
+        a core maintainer will ping the right person.
+
+        Please tag fewer than 3 people.
+
+        Library: @benjaminbossan @githubnemo
+
+        diffusers integration: @benjaminbossan @sayakpaul
+
+        Documentation: @stevhliu
+
+      placeholder: "@Username ..."
+
+  - type: textarea
+    id: reproduction
+    validations:
+      required: true
+    attributes:
+      label: Reproduction
+      description: |
+        Please provide a code sample that reproduces the problem you ran into. It can be a Colab link or just a code snippet.
+        Please provide the simplest reproducer as possible so that we can quickly fix the issue. When you paste
+        the error message, please include the full traceback.
+
+      placeholder: |
+        Reproducer:
+
+  - type: textarea
+    id: expected-behavior
+    validations:
+      required: true
+    attributes:
+      label: Expected behavior
+      description: "A clear and concise description of what you would expect to happen."
diff --git a/.github/ISSUE_TEMPLATE/feature-request.yml b/.github/ISSUE_TEMPLATE/feature-request.yml
new file mode 100644
index 0000000..5e0b73e
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/feature-request.yml
@@ -0,0 +1,21 @@
+name: "\U0001F680 Feature request"
+description: Submit a proposal/request for a new feature
+labels: [ "feature" ]
+body:
+  - type: textarea
+    id: feature-request
+    validations:
+      required: true
+    attributes:
+      label: Feature request
+      description: |
+        A clear and concise description of the feature proposal. Please provide a link to the paper and code in case they exist.
+
+  - type: textarea
+    id: contribution
+    validations:
+      required: true
+    attributes:
+      label: Your contribution
+      description: |
+        Is there any way that you could help, e.g. by submitting a PR?
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 0000000..0501ce0
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,17 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "monthly"
+    cooldown:
+      default-days: 7
+    groups:
+      ci-actions:
+        patterns:
+          - "actions/*"
+      third-party-actions:
+        patterns:
+          - "*"
+        exclude-patterns:
+          - "actions/*"
diff --git a/.github/workflows/build_docker_images.yml b/.github/workflows/build_docker_images.yml
new file mode 100644
index 0000000..6e1d55f
--- /dev/null
+++ b/.github/workflows/build_docker_images.yml
@@ -0,0 +1,87 @@
+name: Build Docker images (scheduled)
+
+on:
+  workflow_dispatch:
+  workflow_call:
+  schedule:
+    - cron: "0 1 * * *"
+
+concurrency:
+  group: docker-image-builds
+  cancel-in-progress: false
+
+permissions: {}
+
+env:
+  CI_SLACK_CHANNEL: ${{ secrets.CI_DOCKER_CHANNEL }}
+
+jobs:
+  latest-cpu:
+    name: "Latest Peft CPU [dev]"
+    # GH Environment for extra protection: https://github.com/huggingface/peft/settings/environments
+    environment: branch-protection-main
+    runs-on:
+      group: aws-general-8-plus
+    steps:
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd  # v4.0.0
+      - name: Check out code
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+        with:
+          persist-credentials: false
+      - name: Login to DockerHub
+        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121  # v4.1.0
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_PASSWORD }}
+
+      - name: Build and Push CPU
+        uses: docker/build-push-action@bcafcacb16a39f128d818304e6c9c0c18556b85f  # v7.1.0
+        with:
+          context: ./docker/peft-cpu
+          push: true
+          tags: huggingface/peft-cpu
+
+      - name: Post to Slack
+        if: always()
+        uses: huggingface/hf-workflows/.github/actions/post-slack@3f88d63d3761558a32e8e46fc2a8536e04bb2aea  # main from Feb 2025-02-24
+        with:
+          slack_channel: ${{ env.CI_SLACK_CHANNEL }}
+          title: 🤗 Results of the PEFT-CPU docker build
+          status: ${{ job.status }}
+          slack_token: ${{ secrets.SLACK_CIFEEDBACK_BOT_TOKEN }}
+
+  latest-cuda:
+    name: "Latest Peft GPU [dev]"
+    # GH Environment for extra protection: https://github.com/huggingface/peft/settings/environments
+    environment: branch-protection-main
+    runs-on:
+      group: aws-general-8-plus
+    steps:
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd  # v4.0.0
+      - name: Check out code
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+        with:
+          persist-credentials: false
+      - name: Login to DockerHub
+        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121  # v4.1.0
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_PASSWORD }}
+
+      - name: Build and Push GPU
+        uses: docker/build-push-action@bcafcacb16a39f128d818304e6c9c0c18556b85f  # v7.1.0
+        with:
+          context: ./docker/peft-gpu
+          push: true
+          tags: huggingface/peft-gpu
+
+      - name: Post to Slack
+        if: always()
+        uses: huggingface/hf-workflows/.github/actions/post-slack@3f88d63d3761558a32e8e46fc2a8536e04bb2aea  # main from Feb 2025-02-24
+        with:
+          slack_channel: ${{ env.CI_SLACK_CHANNEL }}
+          title: 🤗 Results of the PEFT-GPU docker build
+          status: ${{ job.status }}
+          slack_token: ${{ secrets.SLACK_CIFEEDBACK_BOT_TOKEN }}
diff --git a/.github/workflows/build_documentation.yml b/.github/workflows/build_documentation.yml
new file mode 100644
index 0000000..200a90b
--- /dev/null
+++ b/.github/workflows/build_documentation.yml
@@ -0,0 +1,21 @@
+name: Build documentation
+
+on:
+  push:
+    branches:
+      - main
+      - doc-builder*
+      - v*-release
+
+permissions: {}
+
+jobs:
+   build:
+    uses: huggingface/doc-builder/.github/workflows/build_main_documentation.yml@e60a538eea9817ab312196d0d233604b01697265  # main
+    with:
+      commit_sha: ${{ github.sha }}
+      package: peft
+      notebook_folder: peft_docs
+    secrets:
+      token: ${{ secrets.HUGGINGFACE_PUSH }}
+      hf_token: ${{ secrets.HF_DOC_BUILD_PUSH }}
diff --git a/.github/workflows/build_pr_documentation.yml b/.github/workflows/build_pr_documentation.yml
new file mode 100644
index 0000000..7c8a9cb
--- /dev/null
+++ b/.github/workflows/build_pr_documentation.yml
@@ -0,0 +1,18 @@
+name: Build PR Documentation
+
+on:
+  pull_request:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+permissions: {}
+
+jobs:
+  build:
+    uses: huggingface/doc-builder/.github/workflows/build_pr_documentation.yml@e60a538eea9817ab312196d0d233604b01697265  # main
+    with:
+      commit_sha: ${{ github.event.pull_request.head.sha }}
+      pr_number: ${{ github.event.number }}
+      package: peft
diff --git a/.github/workflows/deploy_method_comparison_app.yml b/.github/workflows/deploy_method_comparison_app.yml
new file mode 100644
index 0000000..ed0dd06
--- /dev/null
+++ b/.github/workflows/deploy_method_comparison_app.yml
@@ -0,0 +1,61 @@
+name: Deploy "method_comparison" Gradio to Spaces
+
+on:
+  push:
+    branches: [ main ]
+    paths:
+      - "method_comparison/**"
+      # the method explorer (PEFT shop) app has its own Space and deploy workflow
+      - "!method_comparison/peft-shop/**"
+  workflow_dispatch:
+
+permissions: {}
+
+jobs:
+  deploy:
+    # GH Environment for extra protection: https://github.com/huggingface/peft/settings/environments
+    environment: branch-protection-main
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+        with:
+          fetch-depth: 0  # full history needed for subtree
+          persist-credentials: false
+
+      - name: Authenticate via ~/.netrc
+        env:
+          HF_TOKEN: ${{ secrets.PEFT_INTERNAL_REPO_READ_WRITE }}
+        run: |
+          # netrc needs BOTH login and password entries
+          printf "machine huggingface.co\nlogin hf\npassword ${HF_TOKEN}\n" >> ~/.netrc
+          chmod 600 ~/.netrc
+
+      - name: Deploy method_comparison app to HF Spaces
+        run: |
+          cd method_comparison
+          # the method explorer (PEFT shop) app is deployed to its own Space by its own workflow
+          rm -rf peft-shop
+          git init
+          # Spaces expect requirements.txt
+          mv requirements-app.txt requirements.txt
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git remote add gradio-app https://huggingface.co/spaces/peft-internal-testing/PEFT-method-comparison
+          git add .
+          git commit -m "🚀 Deploy method comparison app from GH action"
+          git push -f gradio-app HEAD:main
+
+      - name: Deploy embeddable method_comparison app to HF Spaces (for docs)
+        run: |
+          cd method_comparison
+          rm -rf .git
+          git init
+          # requirements.txt is already present from the previous step
+          mv app_embed.py app.py
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git remote add gradio-app https://huggingface.co/spaces/peft-internal-testing/PEFT-method-comparison-embed
+          git add .
+          git commit -m "🚀 Deploy method comparison app from GH action"
+          git push -f gradio-app HEAD:main
diff --git a/.github/workflows/deploy_peft_shop_app.yml b/.github/workflows/deploy_peft_shop_app.yml
new file mode 100644
index 0000000..9f230a5
--- /dev/null
+++ b/.github/workflows/deploy_peft_shop_app.yml
@@ -0,0 +1,78 @@
+name: Deploy "PEFT shop" Gradio app to Spaces
+
+on:
+  push:
+    branches: [ main ]
+    paths:
+      # the app itself, and the data sources baked into its data.json: benchmark results and the capability script
+      - "method_comparison/peft-shop/**"
+      - "method_comparison/*/results/**"
+      - "scripts/generate_method_capabilities.py"
+  schedule:
+    # monthly refresh so that newly added PEFT methods reach the Space without a manual dispatch
+    - cron: "0 3 1 * *"
+  workflow_dispatch:
+
+permissions: {}
+
+jobs:
+  deploy:
+    # GH Environment for extra protection: https://github.com/huggingface/peft/settings/environments
+    environment: branch-protection-main
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+        with:
+          persist-credentials: false
+
+      - name: Set up Python
+        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1  # v6.3.0
+        with:
+          python-version: "3.12"
+
+      - name: Install PEFT and app dependencies
+        run: |
+          # CPU-only torch keeps the install small and fast; the capability probes run on CPU anyway
+          pip install torch --index-url https://download.pytorch.org/whl/cpu
+          pip install -e . gradio tqdm
+
+      - name: Build the app data
+        run: |
+          # data.json is generated at deploy time so that it always matches the deployed PEFT commit (see
+          # method_comparison/peft-shop/README.md); the app reads method_capabilities.json from the CWD and
+          # writes data.json into its own directory, where the deploy step below picks it up
+          python scripts/generate_method_capabilities.py --output method_capabilities.json
+          python method_comparison/peft-shop/app.py --rebuild --build-only
+
+      - name: Ensure Space exists
+        env:
+          HF_TOKEN: ${{ secrets.PEFT_INTERNAL_REPO_READ_WRITE }}
+        run: |
+          # pushing to a non-existent Space would fail, the Hub does not create repositories on git push
+          python -c "
+          from huggingface_hub import create_repo
+          create_repo('peft-internal-testing/PEFT-shop', repo_type='space', space_sdk='gradio', exist_ok=True)
+          "
+
+      - name: Authenticate via ~/.netrc
+        env:
+          HF_TOKEN: ${{ secrets.PEFT_INTERNAL_REPO_READ_WRITE }}
+        run: |
+          # netrc needs BOTH login and password entries
+          printf "machine huggingface.co\nlogin hf\npassword ${HF_TOKEN}\n" >> ~/.netrc
+          chmod 600 ~/.netrc
+
+      - name: Deploy PEFT shop app to HF Spaces
+        run: |
+          cd method_comparison/peft-shop
+          git init
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git remote add gradio-app https://huggingface.co/spaces/peft-internal-testing/PEFT-shop
+          git add .
+          # data.json is gitignored (see .gitignore) so it doesn't get committed into the PEFT repo during local
+          # dev; force-add it here so the self-contained data file actually ships with the Space
+          git add -f data.json
+          git commit -m "🚀 Deploy PEFT shop app from GH action"
+          git push -f gradio-app HEAD:main
diff --git a/.github/workflows/integrations_tests.yml b/.github/workflows/integrations_tests.yml
new file mode 100644
index 0000000..bb91ad6
--- /dev/null
+++ b/.github/workflows/integrations_tests.yml
@@ -0,0 +1,86 @@
+name: integration tests
+
+on:
+  workflow_dispatch:
+    inputs:
+      branch:
+        description: 'Branch to test on'
+        required: true
+
+permissions: {}
+
+jobs:
+  run_transformers_integration_tests:
+    strategy:
+      fail-fast: false
+      matrix:
+        transformers-version: ['main', 'latest']
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+        with:
+          ref: ${{ github.event.inputs.branch }}
+          repository: ${{ github.event.pull_request.head.repo.full_name }}
+          persist-credentials: false
+      - name: Set up Python
+        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1  # v6.3.0
+        with:
+          python-version: "3.10"
+          cache: "pip"
+          cache-dependency-path: "setup.py"
+      - name: print environment variables
+        run: |
+          echo "env.CI_BRANCH = ${CI_BRANCH}"
+          echo "env.CI_SHA = ${CI_SHA}"
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install .[test]
+          if [ "${{ matrix.transformers-version }}" == "main" ]; then
+              pip install -U git+https://github.com/huggingface/transformers.git
+          else
+              echo "Nothing to do as transformers latest already installed"
+          fi
+
+      - name: Test transformers integration
+        run: |
+          cd .. && git clone https://github.com/huggingface/transformers.git && cd transformers/ && git rev-parse HEAD
+          RUN_SLOW=1 pytest tests/peft_integration/test_peft_integration.py
+  run_diffusers_integration_tests:
+    strategy:
+      fail-fast: false
+      matrix:
+        # For now diffusers integration is not on PyPI
+        diffusers-version: ['main']
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+        with:
+          ref: ${{ github.event.inputs.branch }}
+          repository: ${{ github.event.pull_request.head.repo.full_name }}
+          persist-credentials: false
+      - name: Set up Python
+        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1  # v6.3.0
+        with:
+          python-version: "3.10"
+          cache: "pip"
+          cache-dependency-path: "setup.py"
+      - name: print environment variables
+        run: |
+          echo "env.CI_BRANCH = ${CI_BRANCH}"
+          echo "env.CI_SHA = ${CI_SHA}"
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install .[test]
+
+          if [ "${{ matrix.diffusers-version }}" == "main" ]; then
+              pip install -U git+https://github.com/huggingface/diffusers.git
+          else
+              echo "Nothing to do as diffusers latest already installed"
+          fi
+
+      - name: Test diffusers integration
+        run: |
+          cd .. && git clone https://github.com/huggingface/diffusers.git && cd diffusers/ && git rev-parse HEAD
+          pytest tests/lora/test_lora_layers_peft.py
diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml
new file mode 100644
index 0000000..4219338
--- /dev/null
+++ b/.github/workflows/nightly.yml
@@ -0,0 +1,152 @@
+name: Self-hosted runner with slow tests (scheduled)
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: "0 2 * * *"
+
+env:
+  RUN_SLOW: "yes"
+  IS_GITHUB_CI: "1"
+  # To be able to run tests on CUDA 12.2
+  NVIDIA_DISABLE_REQUIRE: "1"
+  SLACK_API_TOKEN: ${{ secrets.SLACK_CIFEEDBACK_BOT_TOKEN }}
+
+permissions: {}
+
+jobs:
+  run_all_tests_single_gpu:
+    strategy:
+      fail-fast: false
+    runs-on:
+      group: aws-g6-4xlarge-plus
+    env:
+      CUDA_VISIBLE_DEVICES: "0"
+      TEST_TYPE: "single_gpu"
+    container:
+      image: huggingface/peft-gpu:latest
+      options: --gpus all --shm-size "16gb" -e NVIDIA_DISABLE_REQUIRE=true
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+        with:
+          persist-credentials: false
+      - name: Pip install
+        run: |
+          source activate peft
+          pip install -e . --no-deps
+          pip install pytest-reportlog
+
+      - name: Run common tests on single GPU
+        id: common_tests
+        continue-on-error: true
+        run: |
+          source activate peft
+          make tests_common_gpu
+
+      - name: Run examples on single GPU
+        id: examples
+        continue-on-error: true
+        run: |
+          source activate peft
+          make tests_examples_single_gpu
+
+      - name: Run core tests on single GPU
+        id: core_tests
+        continue-on-error: true
+        run: |
+          source activate peft
+          make tests_core_single_gpu
+
+      - name: Run regression tests on single GPU
+        id: regression
+        continue-on-error: true
+        run: |
+          source activate peft
+          make tests_regression
+
+      - name: Generate Report
+        if: always()
+        run: |
+          pip install slack_sdk tabulate
+          python scripts/log_reports.py >> $GITHUB_STEP_SUMMARY
+
+      - name: Check for test failures
+        if: |
+          steps.common_tests.outcome == 'failure' ||
+          steps.examples.outcome == 'failure' ||
+          steps.core_tests.outcome == 'failure' ||
+          steps.regression.outcome == 'failure'
+        run: |
+          echo "One or more test suites failed. Check the logs above."
+          exit 1
+
+  run_all_tests_multi_gpu:
+    strategy:
+      fail-fast: false
+    runs-on:
+      group: aws-g6-12xlarge-plus
+    env:
+      CUDA_VISIBLE_DEVICES: "0,1"
+      TEST_TYPE: "multi_gpu"
+    container:
+      image: huggingface/peft-gpu:latest
+      options: --gpus all --shm-size "16gb" -e NVIDIA_DISABLE_REQUIRE=true
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+        with:
+          persist-credentials: false
+      - name: Pip install
+        run: |
+          source activate peft
+          pip install -e . --no-deps
+          pip install pytest-reportlog
+
+      - name: Run common tests on multi GPU
+        id: common_tests
+        continue-on-error: true
+        run: |
+          source activate peft
+          make tests_common_gpu
+
+      - name: Run examples on multi GPU
+        id: examples
+        continue-on-error: true
+        run: |
+          source activate peft
+          make tests_examples_multi_gpu
+
+      - name: Run core tests on multi GPU
+        id: core_tests
+        continue-on-error: true
+        run: |
+          source activate peft
+          make tests_core_multi_gpu
+
+      - name: Run training on multi GPU
+        id: training
+        continue-on-error: true
+        run: |
+          source activate peft
+          make tests_training
+
+      - name: Generate Report
+        if: always()
+        run: |
+          pip install slack_sdk tabulate
+          python scripts/log_reports.py >> $GITHUB_STEP_SUMMARY
+
+      - name: Check for test failures
+        if: |
+          steps.common_tests.outcome == 'failure' ||
+          steps.examples.outcome == 'failure' ||
+          steps.core_tests.outcome == 'failure' ||
+          steps.training.outcome == 'failure'
+        run: |
+          echo "One or more test suites failed. Check the logs above."
+          exit 1
diff --git a/.github/workflows/stale.yml b/.github/workflows/stale.yml
new file mode 100644
index 0000000..f8ff45a
--- /dev/null
+++ b/.github/workflows/stale.yml
@@ -0,0 +1,34 @@
+name: Stale Bot
+
+on:
+  schedule:
+    - cron: "0 15 * * *"
+
+permissions: {}
+
+jobs:
+  close_stale_issues:
+    name: Close Stale Issues
+    if: github.repository == 'huggingface/peft'
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: write
+    env:
+      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    steps:
+    - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+      with:
+        persist-credentials: false
+
+    - name: Setup Python
+      uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1  # v6.3.0
+      with:
+        python-version: 3.11
+
+    - name: Install requirements
+      run: |
+        pip install PyGithub
+    - name: Close stale issues
+      run: |
+        python scripts/stale.py
diff --git a/.github/workflows/test-docker-build.yml b/.github/workflows/test-docker-build.yml
new file mode 100644
index 0000000..12698e5
--- /dev/null
+++ b/.github/workflows/test-docker-build.yml
@@ -0,0 +1,66 @@
+name: Test Docker images (on PR)
+
+on:
+  pull_request:
+    paths:
+      # Run only when DockerFile files are modified
+      - "docker/*/Dockerfile"
+
+permissions: {}
+
+jobs:
+  get_changed_files:
+    name: "Build all modified docker images"
+    runs-on: ubuntu-latest
+    outputs:
+      matrix: ${{ steps.set-matrix.outputs.matrix }}
+    steps:
+      - name: Check out code
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+        with:
+          persist-credentials: false
+      - name: Get changed files
+        id: changed-files
+        uses: tj-actions/changed-files@9426d40962ed5378910ee2e21d5f8c6fcbf2dd96  # v47.0.6
+        with:
+          files: docker/*/Dockerfile
+          json: "true"
+      - name: Run step if only the files listed above change
+        if: steps.changed-files.outputs.any_changed == 'true'
+        id: set-matrix
+        env:
+          CHANGED_FILES: "${{ steps.changed-files.outputs.all_changed_files }}"
+        run: |
+          echo "matrix=$(echo ${CHANGED_FILES} | sed -e 's/\\\"/\"/g')" >> $GITHUB_OUTPUT
+  build_modified_files:
+    needs: get_changed_files
+    name: Build Docker images on modified files
+    runs-on: ubuntu-latest
+    if: ${{ needs.get_changed_files.outputs.matrix != '[]' }}
+    strategy:
+      fail-fast: false
+      matrix:
+        docker-file: ${{ fromJson(needs.get_changed_files.outputs.matrix) }}
+    steps:
+      - name: Cleanup disk
+        run: |
+          sudo ls -l /usr/local/lib/
+          sudo ls -l /usr/share/
+          sudo du -sh /usr/local/lib/
+          sudo du -sh /usr/share/
+          sudo rm -rf /usr/local/lib/android
+          sudo rm -rf /usr/share/dotnet
+          sudo du -sh /usr/local/lib/
+          sudo du -sh /usr/share/
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd  # v4.0.0
+      - name: Check out code
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+        with:
+          persist-credentials: false
+      - name: Build Docker image
+        uses: docker/build-push-action@bcafcacb16a39f128d818304e6c9c0c18556b85f  # v7.1.0
+        with:
+          file: ${{ matrix.docker-file }}
+          context: .
+          push: False
diff --git a/.github/workflows/tests-main.yml b/.github/workflows/tests-main.yml
new file mode 100644
index 0000000..c1deafc
--- /dev/null
+++ b/.github/workflows/tests-main.yml
@@ -0,0 +1,89 @@
+name: tests on transformers main
+
+on:
+  push:
+    branches: [main]
+    paths-ignore:
+        - 'docs/**'
+
+permissions: {}
+
+jobs:
+  tests:
+    # GH Environment for extra protection: https://github.com/huggingface/peft/settings/environments
+    environment: branch-protection-main
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+        with:
+          persist-credentials: false
+      - name: Make space for cache + models
+        # Ubuntu runner have less space free which is problematic since the model
+        # cache + dependencies fill up the disk, leaving no space for execution.
+        # So we remove some of the stuff we don't need (Java, .NET, etc.)
+        #
+        # Idea: https://dev.to/mathio/squeezing-disk-space-from-github-actions-runners-an-engineers-guide-3pjg
+        if: matrix.os != 'windows-latest'
+        run: |
+          df -h
+
+          # Remove Java (JDKs)
+          sudo rm -rf /usr/lib/jvm
+
+          # Remove .NET SDKs
+          sudo rm -rf /usr/share/dotnet
+
+          # Remove Swift toolchain
+          sudo rm -rf /usr/share/swift
+
+          # Remove Haskell (GHC)
+          sudo rm -rf /usr/local/.ghcup
+
+          # Remove Julia
+          sudo rm -rf /usr/local/julia*
+
+          # Remove Android SDKs
+          sudo rm -rf /usr/local/lib/android
+
+          # Remove Chromium (optional if not using for browser tests)
+          sudo rm -rf /usr/local/share/chromium
+
+          # Remove Microsoft/Edge and Google Chrome builds
+          sudo rm -rf /opt/microsoft /opt/google
+
+          # Remove Azure CLI
+          sudo rm -rf /opt/az
+
+          # Remove PowerShell
+          sudo rm -rf /usr/local/share/powershell
+
+          # Remove CodeQL and other toolcaches
+          sudo rm -rf /opt/hostedtoolcache
+
+          df -h
+      - name: Set up Python 3.11
+        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1  # v6.3.0
+        with:
+          python-version: 3.11
+          cache: "pip"
+          cache-dependency-path: "setup.py"
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          # cpu version of pytorch
+          pip install -U git+https://github.com/huggingface/transformers.git
+          pip install -e .[test]
+      - name: Test with pytest
+        env:
+          TRANSFORMERS_IS_CI: 1
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: |
+          make test
+      - name: Post to Slack
+        if: always()
+        uses: huggingface/hf-workflows/.github/actions/post-slack@3f88d63d3761558a32e8e46fc2a8536e04bb2aea  # main from Feb 2025-02-24
+        with:
+          slack_channel: ${{ secrets.SLACK_CHANNEL_ID }}
+          title: 🤗 Results of transformers main tests
+          status: ${{ job.status }}
+          slack_token: ${{ secrets.SLACK_CIFEEDBACK_BOT_TOKEN }}
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
new file mode 100644
index 0000000..0b32975
--- /dev/null
+++ b/.github/workflows/tests.yml
@@ -0,0 +1,168 @@
+name: tests
+
+on:
+  push:
+    branches: [main]
+    paths-ignore:
+      - 'docs/**'
+      - 'method_comparison/**'
+      - '**.md'
+  pull_request:
+    paths-ignore:
+      - 'docs/**'
+      - 'method_comparison/**'
+      - '**.md'
+
+env:
+  HF_HOME: .cache/huggingface
+
+permissions: {}
+
+jobs:
+  check_code_quality:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+        with:
+          persist-credentials: false
+      - name: Set up Python
+        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1  # v6.3.0
+        with:
+          python-version: "3.11"
+          cache: "pip"
+          cache-dependency-path: "setup.py"
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install .[dev]
+      - name: Check quality
+        run: |
+          make quality
+
+  tests:
+    needs: check_code_quality
+    # dependabot updates (which don't require approval for CI to run) shouldn't trigger unit tests
+    if: ${{ !(github.event_name == 'pull_request' && github.event.pull_request.user.login == 'dependabot[bot]') }}
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+        os: ["ubuntu-latest", "windows-latest"]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+        with:
+          persist-credentials: false
+      - name: Make space for cache + models
+        # Ubuntu runner have less space free which is problematic since the model
+        # cache + dependencies fill up the disk, leaving no space for execution.
+        # So we remove some of the stuff we don't need (Java, .NET, etc.)
+        #
+        # Idea: https://dev.to/mathio/squeezing-disk-space-from-github-actions-runners-an-engineers-guide-3pjg
+        if: matrix.os != 'windows-latest'
+        run: |
+          df -h
+
+          # Remove Java (JDKs)
+          sudo rm -rf /usr/lib/jvm
+
+          # Remove .NET SDKs
+          sudo rm -rf /usr/share/dotnet
+
+          # Remove Swift toolchain
+          sudo rm -rf /usr/share/swift
+
+          # Remove Haskell (GHC)
+          sudo rm -rf /usr/local/.ghcup
+
+          # Remove Julia
+          sudo rm -rf /usr/local/julia*
+
+          # Remove Android SDKs
+          sudo rm -rf /usr/local/lib/android
+
+          # Remove Chromium (optional if not using for browser tests)
+          sudo rm -rf /usr/local/share/chromium
+
+          # Remove Microsoft/Edge and Google Chrome builds
+          sudo rm -rf /opt/microsoft /opt/google
+
+          # Remove Azure CLI
+          sudo rm -rf /opt/az
+
+          # Remove PowerShell
+          sudo rm -rf /usr/local/share/powershell
+
+          # Remove CodeQL and other toolcaches
+          sudo rm -rf /opt/hostedtoolcache
+
+          df -h
+      - name: Model cache
+        uses: actions/cache/restore@55cc8345863c7cc4c66a329aec7e433d2d1c52a9  # v6.1.0
+        with:
+          # Avoid caching HF_HOME/modules and Python cache files to prevent interoperability
+          # issues and potential cache poisioning. We also avoid lock files to prevent runs
+          # avoiding re-download because they see a lock file.
+          path: |
+            ${{ env.HF_HOME }}/hub/**
+            !${{ env.HF_HOME }}/**/*.pyc
+          key: model-cache-${{ github.run_id }}
+          restore-keys: model-cache-
+          enableCrossOsArchive: true
+
+      - name: Dump cache content
+        # TODO: remove this step after 2025-02-15
+        if: matrix.os != 'windows-latest'
+        run: |
+          SHASUM=sha256sum
+          [ -f "$(which shasum)" ] && SHASUM=shasum
+          find "${{ env.HF_HOME }}/hub" -type f -exec "$SHASUM" {} \; > cache_content_initial || true
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1  # v6.3.0
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: "pip"
+          cache-dependency-path: "setup.py"
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install setuptools
+          # cpu version of pytorch
+          pip install -e .[test]
+      - name: Test with pytest
+        shell: bash
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+          TRANSFORMERS_IS_CI: 1
+          CI: 1
+        run: |
+          make test
+          # clean up all pytest temporary directories that are kept due to retention since space
+          # is a scarce resource on the runners and tasks like model cache creation (further below)
+          # fail if there's not enough space available.
+          (rm -r "/tmp/pytest-of-$(id -u -n)" || true)
+      - name: Dump cache content and diff
+        # This is just debug info so that we can monitor if the model cache diverges substantially
+        # over time and what the diverging model is.
+        # TODO: remove after 2025-02-15
+        if: matrix.os != 'windows-latest'
+        run: |
+          SHASUM=sha256sum
+          [ -f "$(which shasum)" ] && SHASUM=shasum
+          find "${{ env.HF_HOME }}/hub" -type f -exec "$SHASUM" {} \; > cache_content_after || true
+          diff -udp cache_content_initial cache_content_after || true
+      - name: Delete old model cache entries
+        run: |
+          # make sure that cache cleaning doesn't break the pipeline
+          python scripts/ci_clean_cache.py -d || true
+      - name: Update model cache
+        uses: actions/cache/save@55cc8345863c7cc4c66a329aec7e433d2d1c52a9  # v6.1.0
+        # Only let one runner (preferably the one that covers most tests) update the model cache
+        # after *every* run. This way we make sure that our cache is never outdated and we don't
+        # have to keep track of hashes.
+        if: always() && matrix.os == 'ubuntu-latest' && matrix.python-version == '3.10'
+        with:
+          path: |
+            ${{ env.HF_HOME }}/hub/**
+            !${{ env.HF_HOME }}/**/*.pyc
+          key: model-cache-${{ github.run_id }}
diff --git a/.github/workflows/torch_compile_tests.yml b/.github/workflows/torch_compile_tests.yml
new file mode 100644
index 0000000..09a6827
--- /dev/null
+++ b/.github/workflows/torch_compile_tests.yml
@@ -0,0 +1,56 @@
+name: torch compile tests
+
+on:
+  workflow_dispatch:
+    inputs:
+      branch:
+        description: 'Branch to test on'
+        required: true
+      pytorch_nightly:
+        description: 'Whether to use PyTorch nightly (true/false)'
+        required: false
+        default: false
+
+env:
+  RUN_SLOW: "yes"
+  IS_GITHUB_CI: "1"
+  # To be able to run tests on CUDA 12.2
+  NVIDIA_DISABLE_REQUIRE: "1"
+
+permissions: {}
+
+jobs:
+  run_tests_with_compile:
+    runs-on:
+      group: aws-g6-4xlarge-plus
+    env:
+      PEFT_DEBUG_WITH_TORCH_COMPILE: 1
+      CUDA_VISIBLE_DEVICES: "0"
+      TEST_TYPE: "single_gpu_huggingface/peft-gpu:latest"
+      USE_PYTORCH_NIGHTLY: "${{ github.event.inputs.pytorch_nightly }}"
+    container:
+      image: "huggingface/peft-gpu:latest"
+      options: --gpus all --shm-size "16gb" --ipc host -v /mnt/cache/.cache/huggingface:/mnt/cache/
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+        with:
+          ref: ${{ github.event.inputs.branch }}
+          repository: ${{ github.event.pull_request.head.repo.full_name }}
+          persist-credentials: false
+      - name: Pip install
+        run: |
+          source activate peft
+          pip install -e . --no-deps
+          pip install pytest-cov pytest-reportlog parameterized datasets scipy einops
+          pip install "pytest>=7.2.0,<8.0.0" # see: https://github.com/huggingface/transformers/blob/ce4fff0be7f6464d713f7ac3e0bbaafbc6959ae5/setup.py#L148C6-L148C26
+          if [ "${USE_PYTORCH_NIGHTLY}" = "true" ]; then
+            python -m pip install --upgrade --pre torch --index-url https://download.pytorch.org/whl/nightly/cpu
+          fi
+      - name: Test compile with pytest
+        run: |
+          source activate peft
+          echo "PEFT_DEBUG_WITH_TORCH_COMPILE=$PEFT_DEBUG_WITH_TORCH_COMPILE"
+          make tests_torch_compile
diff --git a/.github/workflows/trufflehog.yml b/.github/workflows/trufflehog.yml
new file mode 100644
index 0000000..13d8a1f
--- /dev/null
+++ b/.github/workflows/trufflehog.yml
@@ -0,0 +1,18 @@
+on:
+  push:
+
+name: Secret Leaks
+
+permissions: {}
+
+jobs:
+  trufflehog:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+      with:
+        fetch-depth: 0
+        persist-credentials: false
+    - name: Secret Scanning
+      uses: trufflesecurity/trufflehog@37b77001d0174ebec2fcca2bd83ff83a6d45a3ab  # v3.95.3
diff --git a/.github/workflows/upload_pr_documentation.yml b/.github/workflows/upload_pr_documentation.yml
new file mode 100644
index 0000000..860d191
--- /dev/null
+++ b/.github/workflows/upload_pr_documentation.yml
@@ -0,0 +1,18 @@
+name: Upload PR Documentation
+
+on:
+  workflow_run:
+    workflows: ["Build PR Documentation"]
+    types:
+      - completed
+
+permissions: {}
+
+jobs:
+  build:
+    uses: huggingface/doc-builder/.github/workflows/upload_pr_documentation.yml@b0f9a6e3b6aa912656cbda9f74896eb721d29421  # main
+    with:
+      package_name: peft
+    secrets:
+      hf_token: ${{ secrets.HF_DOC_BUILD_PUSH }}
+      comment_bot_token: ${{ secrets.COMMENT_BOT_TOKEN }}
diff --git a/.github/workflows/zizmor.yaml b/.github/workflows/zizmor.yaml
new file mode 100644
index 0000000..ad42063
--- /dev/null
+++ b/.github/workflows/zizmor.yaml
@@ -0,0 +1,28 @@
+name: CI security linting
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["*"]
+    paths:
+      - '.github/**'
+
+permissions: {}
+
+jobs:
+  zizmor:
+    name: zizmor latest via Cargo
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      security-events: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+        with:
+          persist-credentials: false
+      - name: Install zizmor
+        run: cargo install --locked zizmor
+      - name: Run zizmor
+        run: zizmor .github/workflows
diff --git a/.github/zizmor.yml b/.github/zizmor.yml
new file mode 100644
index 0000000..1a45e4d
--- /dev/null
+++ b/.github/zizmor.yml
@@ -0,0 +1,28 @@
+rules:
+  dangerous-triggers:
+    ignore:
+      # this workflow is only triggered after maintainer approval
+      - upload_pr_documentation.yml:3:1
+  cache-poisoning:
+    ignore:
+      # the docker buildx binary is cached and zizmor warns about a cache poisoning attack.
+      # OTOH this cache would make us more resilient against an intrusion on docker-buildx' side.
+      # There is no obvious benefit so we leave it as it is.
+      - build_docker_images.yml:39:9
+      - build_docker_images.yml:74:9
+  secrets-outside-env:
+    ignore:
+      # Zizmor warns about HF_TOKEN being used there but the token is not exposed to external users:
+      # > With the exception of GITHUB_TOKEN, secrets are not passed to the runner when a workflow is triggered from a forked repository.
+      # https://docs.github.com/en/actions/how-tos/write-workflows/choose-what-workflows-do/use-secrets#using-secrets-in-a-workflow
+      # Moreover, the workflow needs to be manually triggered by maintainers, who will review the code first
+      - tests.yml:131:25
+  unpinned-images:
+    ignore:
+      # We want to test these images with the latest version and we're not using them
+      # to deploy anything so we deem it safe to use those, even if they are unpinned.
+      - nightly-bnb.yml:30:7
+      - nightly-bnb.yml:155:7
+      - nightly.yml:27:7
+      - nightly.yml:95:7
+      - torch_compile_tests.yml:32:7
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..4e3e2ca
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,145 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# VSCode
+.vscode
+
+# IntelliJ
+.idea
+
+# Mac .DS_Store
+.DS_Store
+
+# More test things
+wandb
+
+# method_comparison logs
+method_comparison/MetaMathQA/cancelled_results/
+method_comparison/MetaMathQA/temporary_results/
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 0000000..908a7cb
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,13 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.15.12
+    hooks:
+      - id: ruff
+        args:
+          - --fix
+      - id: ruff-format
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.6.0
+    hooks:
+      - id: check-merge-conflict
+      - id: check-yaml
diff --git a/AGENTS.md b/AGENTS.md
new file mode 120000
index 0000000..b28461c
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1 @@
+.ai/AGENTS.md
\ No newline at end of file
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 120000
index 0000000..b28461c
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1 @@
+.ai/AGENTS.md
\ No newline at end of file
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 120000
index 0000000..446f7fd
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1 @@
+docs/source/developer_guides/contributing.md
\ No newline at end of file
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..261eeb9
--- /dev/null
+++ b/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 [yyyy] [name of copyright owner]
+
+   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.
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..f0d8f24
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,75 @@
+.PHONY: quality style test docs
+
+check_dirs := src tests examples docs scripts docker
+
+# Check that source code meets quality standards
+
+# this target runs checks on all files
+quality:
+	ruff check $(check_dirs)
+	ruff format --check $(check_dirs)
+	doc-builder style src/peft tests docs/source --max_len 119 --check_only
+
+# Format source code automatically and check is there are any problems left that need manual fixing
+style:
+	ruff check --fix $(check_dirs)
+	ruff format $(check_dirs)
+	doc-builder style src/peft tests docs/source --max_len 119
+
+test:
+	python -m pytest -n 3 tests/ $(if $(IS_GITHUB_CI),--report-log "ci_tests.log",)
+
+tests_examples_multi_gpu:
+	python -m pytest -m multi_gpu_tests tests/test_gpu_examples.py $(if $(IS_GITHUB_CI),--report-log "multi_gpu_examples.log",)
+
+tests_examples_single_gpu:
+	python -m pytest -m single_gpu_tests tests/test_gpu_examples.py $(if $(IS_GITHUB_CI),--report-log "single_gpu_examples.log",)
+
+tests_core_multi_gpu:
+	python -m pytest -m multi_gpu_tests tests/test_common_gpu.py $(if $(IS_GITHUB_CI),--report-log "core_multi_gpu.log",)
+
+tests_core_single_gpu:
+	python -m pytest -m single_gpu_tests tests/test_common_gpu.py $(if $(IS_GITHUB_CI),--report-log "core_single_gpu.log",)
+
+# exclude gemma tests, as generation fails with torch.compile, these failures
+# trigger side effects that make other tests fail with 'RuntimeError: Offset
+# increment outside graph capture encountered unexpectedly.' 
+# TODO re-enable gemma once/if it is fixed
+tests_common_gpu:
+	python -m pytest tests/test_decoder_models.py -k "not gemma" $(if $(IS_GITHUB_CI),--report-log "common_decoder.log",)
+	python -m pytest tests/test_encoder_decoder_models.py $(if $(IS_GITHUB_CI),--report-log "common_encoder_decoder.log",)
+	python -m pytest tests/test_gptqmodel.py $(if $(IS_GITHUB_CI),--report-log "gptqmodel_gpu.log",)
+
+tests_examples_multi_gpu_bnb:
+	python -m pytest -m "multi_gpu_tests and bitsandbytes" tests/test_gpu_examples.py $(if $(IS_GITHUB_CI),--report-log "multi_gpu_bnb_examples.log",)
+
+tests_examples_single_gpu_bnb:
+	python -m pytest -m "single_gpu_tests and bitsandbytes" tests/test_gpu_examples.py $(if $(IS_GITHUB_CI),--report-log "single_gpu_bnb_examples.log",)
+
+tests_core_multi_gpu_bnb:
+	python -m pytest -m "multi_gpu_tests and bitsandbytes" tests/test_common_gpu.py $(if $(IS_GITHUB_CI),--report-log "core_multi_gpu_bnb.log",)
+
+tests_core_single_gpu_bnb:
+	python -m pytest -m "single_gpu_tests and bitsandbytes" tests/test_common_gpu.py $(if $(IS_GITHUB_CI),--report-log "core_single_gpu_bnb.log",)
+
+# For testing transformers tests for bnb runners
+transformers_tests:
+	RUN_SLOW=1 python -m pytest transformers-clone/tests/quantization/bnb $(if $(IS_GITHUB_CI),--report-log "transformers_tests.log",)
+
+tests_regression:
+	python -m pytest -s --regression tests/regression/ $(if $(IS_GITHUB_CI),--report-log "regression_tests.log",)
+
+tests_torch_compile:
+	python -m pytest tests/test_torch_compile.py $(if $(IS_GITHUB_CI),--report-log "compile_tests.log",)
+
+tests_training:
+	accelerate launch --config_file tests/training/deepspeed_config.yaml tests/training/training.py
+	accelerate launch --config_file tests/training/deepspeed_config.yaml tests/training/training.py --quant 4bit
+	accelerate launch --config_file tests/training/deepspeed_config.yaml tests/training/training.py --quant 8bit
+	accelerate launch --config_file tests/training/fsdp_config.yaml tests/training/training.py
+	accelerate launch --config_file tests/training/fsdp_config.yaml tests/training/training.py --quant 4bit
+	accelerate launch --config_file tests/training/fsdp2_config.yaml tests/training/training.py
+	accelerate launch --config_file tests/training/fsdp2_config.yaml tests/training/training.py --quant 4bit
+	accelerate launch --config_file tests/training/fsdp2_config.yaml tests/training/training.py --quant 4bit --target_modules q_proj --target_parameters v_proj.weight
+	accelerate launch --config_file tests/training/fsdp_config.yaml tests/training/adapters.py
+	accelerate launch --config_file tests/training/tp_config.yaml tests/training/lora_tp.py
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..aaa9e7e
--- /dev/null
+++ b/README.md
@@ -0,0 +1,191 @@
+<!---
+Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+<h1 align="center"> <p>🤗 PEFT</p></h1>
+<h3 align="center">
+    <p>State-of-the-art Parameter-Efficient Fine-Tuning (PEFT) methods</p>
+</h3>
+
+Fine-tuning large pretrained models is often prohibitively costly due to their scale. Parameter-Efficient Fine-Tuning (PEFT) methods enable efficient adaptation of large pretrained models to various downstream applications by only fine-tuning a small number of (extra) model parameters instead of all the model's parameters. This significantly decreases the computational and storage costs. Recent state-of-the-art PEFT techniques achieve performance comparable to fully fine-tuned models.
+
+PEFT is integrated with Transformers for easy model training and inference, Diffusers for conveniently managing different adapters, and Accelerate for distributed training and inference for really big models.
+
+> [!TIP]
+> Visit the [PEFT](https://huggingface.co/PEFT) organization to read about the PEFT methods implemented in the library and to see notebooks demonstrating how to apply these methods to a variety of downstream tasks. Click the "Watch repos" button on the organization page to be notified of newly implemented methods and notebooks!
+
+Check the PEFT Adapters API Reference section for a list of supported PEFT methods, and read the [Adapters](https://huggingface.co/docs/peft/en/conceptual_guides/adapter), [Soft prompts](https://huggingface.co/docs/peft/en/conceptual_guides/prompting), and [IA3](https://huggingface.co/docs/peft/en/conceptual_guides/ia3) conceptual guides to learn more about how these methods work.
+
+## Quickstart
+
+Install PEFT from pip:
+
+```bash
+pip install peft
+```
+
+Prepare a model for training with a PEFT method such as LoRA by wrapping the base model and PEFT configuration with `get_peft_model`. For the bigscience/mt0-large model, you're only training 0.19% of the parameters!
+
+```python
+import torch
+from transformers import AutoModelForCausalLM
+from peft import LoraConfig, TaskType, get_peft_model
+
+device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+model_id = "Qwen/Qwen2.5-3B-Instruct"
+model = AutoModelForCausalLM.from_pretrained(model_id, device_map=device)
+peft_config = LoraConfig(
+    r=16,
+    lora_alpha=32,
+    task_type=TaskType.CAUSAL_LM,
+    # target_modules=["q_proj", "v_proj", ...]  # optionally indicate target modules
+)
+model = get_peft_model(model, peft_config)
+model.print_trainable_parameters()
+# prints: trainable params: 3,686,400 || all params: 3,089,625,088 || trainable%: 0.1193
+
+# now perform training on your dataset, e.g. using transformers Trainer, then save the model
+model.save_pretrained("qwen2.5-3b-lora")
+```
+
+To load a PEFT model for inference:
+
+```python
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from peft import PeftModel
+
+device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+model_id = "Qwen/Qwen2.5-3B-Instruct"
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+model = AutoModelForCausalLM.from_pretrained(model_id, device_map=device)
+model = PeftModel.from_pretrained(model, "qwen2.5-3b-lora")
+
+inputs = tokenizer("Preheat the oven to 350 degrees and place the cookie dough", return_tensors="pt")
+outputs = model.generate(**inputs.to(device), max_new_tokens=50)
+print(tokenizer.decode(outputs[0], skip_special_tokens=True))
+
+# prints something like: Preheat the oven to 350 degrees and place the cookie dough in a baking dish [...]
+```
+
+## Why you should use PEFT
+
+There are many benefits of using PEFT but the main one is the huge savings in compute and storage, making PEFT applicable to many different use cases.
+
+### High performance on consumer hardware
+
+Consider the memory requirements for training the following models on the [ought/raft/twitter_complaints](https://huggingface.co/datasets/ought/raft/viewer/twitter_complaints) dataset with an A100 80GB GPU with more than 64GB of CPU RAM.
+
+|   Model         | Full Finetuning | PEFT-LoRA PyTorch  | PEFT-LoRA DeepSpeed with CPU Offloading |
+| --------- | ---- | ---- | ---- |
+| bigscience/T0_3B (3B params) | 47.14GB GPU / 2.96GB CPU  | 14.4GB GPU / 2.96GB CPU | 9.8GB GPU / 17.8GB CPU |
+| bigscience/mt0-xxl (12B params) | OOM GPU | 56GB GPU / 3GB CPU | 22GB GPU / 52GB CPU |
+| bigscience/bloomz-7b1 (7B params) | OOM GPU | 32GB GPU / 3.8GB CPU | 18.1GB GPU / 35GB CPU |
+
+With LoRA you can fully finetune a 12B parameter model that would've otherwise run out of memory on the 80GB GPU, and comfortably fit and train a 3B parameter model. When you look at the 3B parameter model's performance, it is comparable to a fully finetuned model at a fraction of the GPU memory.
+
+|   Submission Name        | Accuracy |
+| --------- | ---- |
+| Human baseline (crowdsourced) |	0.897 |
+| Flan-T5 | 0.892 |
+| lora-t0-3b | 0.863 |
+
+> [!TIP]
+> The bigscience/T0_3B model performance isn't optimized in the table above. You can squeeze even more performance out of it by playing around with the input instruction templates, LoRA hyperparameters, and other training related hyperparameters. The final checkpoint size of this model is just 19MB compared to 11GB of the full bigscience/T0_3B model. Learn more about the advantages of finetuning with PEFT in this [blog post](https://www.philschmid.de/fine-tune-flan-t5-peft).
+
+### Quantization
+
+Quantization is another method for reducing the memory requirements of a model by representing the data in a lower precision. It can be combined with PEFT methods to make it even easier to train and load LLMs for inference.
+
+* Learn how to finetune [meta-llama/Llama-2-7b-hf](https://huggingface.co/meta-llama/Llama-2-7b-hf) with QLoRA and the [TRL](https://huggingface.co/docs/trl/index) library on a 16GB GPU in the [Finetune LLMs on your own consumer hardware using tools from PyTorch and Hugging Face ecosystem](https://pytorch.org/blog/finetune-llms/) blog post.
+* Learn how to finetune a [openai/whisper-large-v2](https://huggingface.co/openai/whisper-large-v2) model for multilingual automatic speech recognition with LoRA and 8-bit quantization in this [notebook](https://colab.research.google.com/drive/1DOkD_5OUjFa0r5Ik3SgywJLJtEo2qLxO?usp=sharing) (see this [notebook](https://colab.research.google.com/drive/1vhF8yueFqha3Y3CpTHN6q9EVcII9EYzs?usp=sharing) instead for an example of streaming a dataset).
+
+### Save compute and storage
+
+PEFT can help you save storage by avoiding full finetuning of models on each of downstream task or dataset. In many cases, you're only finetuning a very small fraction of a model's parameters and each checkpoint is only a few MBs in size (instead of GBs). These smaller PEFT adapters demonstrate performance comparable to a fully finetuned model. If you have many datasets, you can save a lot of storage with a PEFT model and not have to worry about catastrophic forgetting or overfitting the backbone or base model.
+
+## PEFT integrations
+
+PEFT is widely supported across the Hugging Face ecosystem because of the massive efficiency it brings to training and inference.
+
+### Diffusers
+
+The iterative diffusion process consumes a lot of memory which can make it difficult to train. PEFT can help reduce the memory requirements and reduce the storage size of the final model checkpoint. For example, consider the memory required for training a Stable Diffusion model with LoRA on an A100 80GB GPU with more than 64GB of CPU RAM. The final model checkpoint size is only 8.8MB!
+
+|   Model         | Full Finetuning | PEFT-LoRA  | PEFT-LoRA with Gradient Checkpointing  |
+| --------- | ---- | ---- | ---- |
+| CompVis/stable-diffusion-v1-4 | 27.5GB GPU / 3.97GB CPU | 15.5GB GPU / 3.84GB CPU | 8.12GB GPU / 3.77GB CPU | 
+
+> [!TIP]
+> Take a look at the [examples/lora_dreambooth/train_dreambooth.py](examples/lora_dreambooth/train_dreambooth.py) training script to try training your own Stable Diffusion model with LoRA, and play around with the [smangrul/peft-lora-sd-dreambooth](https://huggingface.co/spaces/smangrul/peft-lora-sd-dreambooth) Space which is running on a T4 instance. Learn more about the PEFT integration in Diffusers in this [tutorial](https://huggingface.co/docs/peft/main/en/tutorial/peft_integrations#diffusers).
+
+### Transformers
+
+PEFT is directly integrated with [Transformers](https://huggingface.co/docs/transformers/main/en/peft). After loading a model, call `add_adapter` to add a new PEFT adapter to the model:
+
+```python
+from peft import LoraConfig
+model = ...  # transformers model
+peft_config = LoraConfig(...)
+model.add_adapter(peft_config, adapter_name="lora_1")
+```
+
+To load a trained PEFT adapter, call `load_adapter`:
+
+```python
+model = ...  # transformers model
+model.load_adapter(<path-to-adapter>, adapter_name="lora_1")
+```
+
+And to switch between different adapters, call `set_adapter`:
+
+```python
+model.set_adapter("lora_2")
+```
+
+The Transformers integration doesn't include all the functionalities offered in PEFT, such as methods for merging the adapter into the base model.
+
+### Accelerate
+
+[Accelerate](https://huggingface.co/docs/accelerate/index) is a library for distributed training and inference on various training setups and hardware (GPUs, TPUs, Apple Silicon, etc.). PEFT models work with Accelerate out of the box, making it really convenient to train really large models or use them for inference on consumer hardware with limited resources.
+
+### TRL
+
+PEFT can also be applied to training LLMs with RLHF components such as the ranker and policy. Get started by reading:
+
+* [Fine-tune a Mistral-7b model with Direct Preference Optimization](https://towardsdatascience.com/fine-tune-a-mistral-7b-model-with-direct-preference-optimization-708042745aac) with PEFT and the [TRL](https://huggingface.co/docs/trl/index) library to learn more about the Direct Preference Optimization (DPO) method and how to apply it to a LLM.
+* [Fine-tuning 20B LLMs with RLHF on a 24GB consumer GPU](https://huggingface.co/blog/trl-peft) with PEFT and the [TRL](https://huggingface.co/docs/trl/index) library, and then try out the [gpt2-sentiment_peft.ipynb](https://github.com/huggingface/trl/blob/main/examples/notebooks/gpt2-sentiment.ipynb) notebook to optimize GPT2 to generate positive movie reviews.
+* [StackLLaMA: A hands-on guide to train LLaMA with RLHF](https://huggingface.co/blog/stackllama) with PEFT, and then try out the [stack_llama/scripts](https://github.com/huggingface/trl/tree/main/examples/research_projects/stack_llama/scripts) for supervised finetuning, reward modeling, and RL finetuning.
+
+## Model support
+
+Use this [Space](https://stevhliu-peft-methods.hf.space) or check out the [docs](https://huggingface.co/docs/peft/main/en/index) to find which models officially support a PEFT method out of the box. Even if you don't see a model listed below, you can manually configure the model config to enable PEFT for a model. Read the [New transformers architecture](https://huggingface.co/docs/peft/main/en/developer_guides/custom_models#new-transformers-architectures) guide to learn how.
+
+## Contribute
+
+If you would like to contribute to PEFT, please check out our [contribution guide](https://huggingface.co/docs/peft/developer_guides/contributing).
+
+## Citing 🤗 PEFT
+
+To use 🤗 PEFT in your publication, please cite it by using the following BibTeX entry.
+
+```bibtex
+@Misc{peft,
+  title =        {{PEFT}: State-of-the-art Parameter-Efficient Fine-Tuning methods},
+  author =       {Sourab Mangrulkar and Sylvain Gugger and Lysandre Debut and Younes Belkada and Sayak Paul and Benjamin Bossan and Marian Tietz},
+  howpublished = {\url{https://github.com/huggingface/peft}},
+  year =         {2022}
+}
+```
diff --git a/README.wehub.md b/README.wehub.md
new file mode 100644
index 0000000..6e7f7fd
--- /dev/null
+++ b/README.wehub.md
@@ -0,0 +1,7 @@
+# WeHub 来源说明
+
+- 原始项目：`huggingface/peft`
+- 原始仓库：https://github.com/huggingface/peft
+- 导入方式：上游默认分支的最新快照
+- 原作者、版权和许可证信息以原始仓库及本仓库 LICENSE 为准
+- 本文件仅用于记录来源，不代表 WeHub 是原项目作者
diff --git a/docker/README.md b/docker/README.md
new file mode 100644
index 0000000..02250ee
--- /dev/null
+++ b/docker/README.md
@@ -0,0 +1,6 @@
+# PEFT Docker images
+
+Here we store all PEFT Docker images used in our testing infrastructure. We use python 3.11 for now on all our images.
+
+- `peft-cpu`: PEFT compiled on CPU with all other HF libraries installed on main branch
+- `peft-gpu`: PEFT complied for NVIDIA GPUs with all other HF libraries installed on main branch
diff --git a/docker/peft-cpu/Dockerfile b/docker/peft-cpu/Dockerfile
new file mode 100644
index 0000000..ebc2a1b
--- /dev/null
+++ b/docker/peft-cpu/Dockerfile
@@ -0,0 +1,46 @@
+# Builds GPU docker image of PyTorch
+# Uses multi-staged approach to reduce size
+# Stage 1
+# Use base conda image to reduce time
+FROM continuumio/miniconda3:latest AS compile-image
+# Specify py version
+ENV PYTHON_VERSION=3.11
+# Install apt libs - copied from https://github.com/huggingface/accelerate/blob/main/docker/accelerate-gpu/Dockerfile
+RUN apt-get update && \
+    apt-get install -y curl git wget git-lfs ffmpeg libsndfile1-dev && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists*
+
+RUN git lfs install
+
+# Create our conda env - copied from https://github.com/huggingface/accelerate/blob/main/docker/accelerate-gpu/Dockerfile
+RUN conda create --name peft python=${PYTHON_VERSION} ipython jupyter pip
+RUN python3 -m pip install --no-cache-dir --upgrade pip
+
+# Below is copied from https://github.com/huggingface/accelerate/blob/main/docker/accelerate-gpu/Dockerfile
+# We don't install pytorch here yet since CUDA isn't available
+# instead we use the direct torch wheel
+ENV PATH=/opt/conda/envs/peft/bin:$PATH
+# Activate our bash shell
+RUN chsh -s /bin/bash
+SHELL ["/bin/bash", "-c"]
+# Activate the conda env and install transformers + accelerate from source
+RUN source activate peft && \
+    python3 -m pip install --no-cache-dir \
+    librosa \
+    "soundfile>=0.12.1" \
+    scipy \
+    git+https://github.com/huggingface/transformers \
+    git+https://github.com/huggingface/accelerate \
+    peft[test]@git+https://github.com/huggingface/peft
+
+# Install apt libs
+RUN apt-get update && \
+    apt-get install -y curl git wget && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists*
+
+RUN echo "source activate peft" >> ~/.profile
+
+# Activate the virtualenv
+CMD ["/bin/bash"]
diff --git a/docker/peft-gpu/Dockerfile b/docker/peft-gpu/Dockerfile
new file mode 100644
index 0000000..ad4d777
--- /dev/null
+++ b/docker/peft-gpu/Dockerfile
@@ -0,0 +1,86 @@
+# Builds GPU docker image of PyTorch
+# Uses multi-staged approach to reduce size
+# Stage 1
+# Use base conda image to reduce time
+FROM continuumio/miniconda3:latest AS compile-image
+# Specify py version
+ENV PYTHON_VERSION=3.11
+# Install apt libs - copied from https://github.com/huggingface/accelerate/blob/main/docker/accelerate-gpu/Dockerfile
+# Install audio-related libraries
+RUN apt-get update && \
+    apt-get install -y curl git wget git-lfs ffmpeg libsndfile1-dev && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists*
+
+RUN git lfs install
+
+# Create our conda env - copied from https://github.com/huggingface/accelerate/blob/main/docker/accelerate-gpu/Dockerfile
+RUN conda create --name peft python=${PYTHON_VERSION} ipython jupyter pip
+
+# Below is copied from https://github.com/huggingface/accelerate/blob/main/docker/accelerate-gpu/Dockerfile
+# We don't install pytorch here yet since CUDA isn't available
+# instead we use the direct torch wheel
+ENV PATH=/opt/conda/envs/peft/bin:$PATH
+# Activate our bash shell
+RUN chsh -s /bin/bash
+SHELL ["/bin/bash", "-c"]
+
+# Stage 2
+FROM nvidia/cuda:13.2.1-cudnn-devel-ubuntu24.04 AS build-image
+COPY --from=compile-image /opt/conda /opt/conda
+ENV PATH=/opt/conda/bin:$PATH
+
+# Install apt libs
+RUN apt-get update && \
+    apt-get install -y curl git wget && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists*
+
+RUN chsh -s /bin/bash
+SHELL ["/bin/bash", "-c"]
+
+RUN conda run -n peft pip install --no-cache-dir bitsandbytes optimum
+
+# Note: we are hard-coding CUDA_ARCH_LIST here since `gptqmodel` requires either nvidia-smi
+# or CUDA_ARCH_LIST for compute capability information. Since the docker build is unlikely
+# to have compute hardware available we use the information from the CI runner (which hosts
+# a NVIDIA L4). So we fix the compute capability to 8.9. In the future we might extend this
+# to a list of compute capabilities (separated by ;).
+# TODO pcre, which is used by gptqmodel, is resulting in a core dump, remove once it's resolved
+# RUN CUDA_ARCH_LIST=8.9 conda run -n peft pip install "gptqmodel>=7.0.0"
+
+RUN \
+    # Add eetq for quantization testing; needs to run without build isolation since the setup
+    # script directly imports torch from the environment which would fail with isolation.
+    # Ninja should speed up build time.
+    conda run -n peft pip install ninja && conda run -n peft pip install --no-build-isolation git+https://github.com/NetEase-FuXi/EETQ.git
+
+# TODO: Importing TE results in: undefined symbol: cublasLtGroupedMatrixLayoutInit_internal, version libcublasLt.so.13
+# Reinstate TE when the issue is resolved (probably this one: https://github.com/NVIDIA/TransformerEngine/issues/2504)
+# RUN NVTE_BUILD_USE_NVIDIA_WHEELS=1 \
+#     CPATH="/usr/local/cuda/include:${CPATH}" \
+#     conda run -n peft pip install --no-build-isolation "transformer_engine[pytorch]"
+
+# Activate the conda env and install transformers + accelerate from source
+RUN conda run -n peft pip install -U --no-cache-dir \
+        librosa \
+        "soundfile>=0.12.1" \
+        scipy \
+        torchao \
+        "fbgemm-gpu-genai>=1.2.0" \
+        git+https://github.com/huggingface/transformers \
+        git+https://github.com/huggingface/accelerate \
+        peft[test]@git+https://github.com/huggingface/peft \
+        # Add aqlm for quantization testing
+        aqlm[gpu]>=1.0.2 \
+        # Add HQQ for quantization testing
+        hqq \
+        deepspeed \
+        "kernels<0.16"
+
+RUN conda run -n peft pip freeze | grep transformers
+
+RUN echo "source activate peft" >> ~/.profile
+
+# Activate the virtualenv
+CMD ["/bin/bash"]
diff --git a/docs/Makefile b/docs/Makefile
new file mode 100644
index 0000000..8879933
--- /dev/null
+++ b/docs/Makefile
@@ -0,0 +1,19 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+SOURCEDIR     = source
+BUILDDIR      = _build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
\ No newline at end of file
diff --git a/docs/README.md b/docs/README.md
new file mode 100644
index 0000000..0b76173
--- /dev/null
+++ b/docs/README.md
@@ -0,0 +1,267 @@
+<!---
+Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+# Generating the documentation
+
+To generate the documentation, you first have to build it. Several packages are necessary to build the doc, 
+you can install them with the following command, at the root of the code repository:
+
+```bash
+pip install -e ".[docs]"
+```
+
+Then you need to install our special tool that builds the documentation:
+
+```bash
+pip install git+https://github.com/huggingface/doc-builder
+```
+
+---
+**NOTE**
+
+You only need to generate the documentation to inspect it locally (if you're planning changes and want to
+check how they look before committing for instance). You don't have to commit to the built documentation.
+
+---
+
+## Building the documentation
+
+Once you have setup the `doc-builder` and additional packages, you can generate the documentation by 
+typing the following command:
+
+```bash
+doc-builder build peft docs/source/ --build_dir ~/tmp/test-build
+```
+
+You can adapt the `--build_dir` to set any temporary folder you prefer. This command will create it and generate
+the MDX files that will be rendered as the documentation on the main website. You can inspect them in your favorite
+Markdown editor.
+
+## Previewing the documentation
+
+To preview the docs, first install the `watchdog` module with:
+
+```bash
+pip install watchdog
+```
+
+Then run the following command:
+
+```bash
+doc-builder preview {package_name} {path_to_docs}
+```
+
+For example:
+
+```bash
+doc-builder preview peft docs/source
+```
+
+The docs will be viewable at [http://localhost:3000](http://localhost:3000). You can also preview the docs once you have opened a PR. You will see a bot add a comment to a link where the documentation with your changes lives.
+
+---
+**NOTE**
+
+The `preview` command only works with existing doc files. When you add a completely new file, you need to update `_toctree.yml` & restart `preview` command (`ctrl-c` to stop it & call `doc-builder preview ...` again).
+
+---
+
+## Adding a new element to the navigation bar
+
+Accepted files are Markdown (.md or .mdx).
+
+Create a file with its extension and put it in the source directory. You can then link it to the toc-tree by putting
+the filename without the extension in the [`_toctree.yml`](https://github.com/huggingface/peft/blob/main/docs/source/_toctree.yml) file.
+
+## Renaming section headers and moving sections
+
+It helps to keep the old links working when renaming the section header and/or moving sections from one document to another. This is because the old links are likely to be used in Issues, Forums, and Social media and it'd make for a much more superior user experience if users reading those months later could still easily navigate to the originally intended information.
+
+Therefore, we simply keep a little map of moved sections at the end of the document where the original section was. The key is to preserve the original anchor.
+
+So if you renamed a section from: "Section A" to "Section B", then you can add at the end of the file:
+
+```
+Sections that were moved:
+
+[ <a href="#section-b">Section A</a><a id="section-a"></a> ]
+```
+and of course, if you moved it to another file, then:
+
+```
+Sections that were moved:
+
+[ <a href="../new-file#section-b">Section A</a><a id="section-a"></a> ]
+```
+
+Use the relative style to link to the new file so that the versioned docs continue to work.
+
+
+## Writing Documentation - Specification
+
+The `huggingface/peft` documentation follows the
+[Google documentation](https://sphinxcontrib-napoleon.readthedocs.io/en/latest/example_google.html) style for docstrings,
+although we can write them directly in Markdown.
+
+### Adding a new tutorial
+
+Adding a new tutorial or section is done in two steps:
+
+- Add a new file under `./source`. This file can either be ReStructuredText (.rst) or Markdown (.md).
+- Link that file in `./source/_toctree.yml` on the correct toc-tree.
+
+Make sure to put your new file under the proper section. It's unlikely to go in the first section (*Get Started*), so
+depending on the intended targets (beginners, more advanced users, or researchers) it should go into sections two, three, or
+four.
+
+### Writing source documentation
+
+Values that should be put in `code` should either be surrounded by backticks: \`like so\`. Note that argument names
+and objects like True, None, or any strings should usually be put in `code`.
+
+When mentioning a class, function, or method, it is recommended to use our syntax for internal links so that our tool
+adds a link to its documentation with this syntax: \[\`XXXClass\`\] or \[\`function\`\]. This requires the class or 
+function to be in the main package.
+
+If you want to create a link to some internal class or function, you need to
+provide its path. For instance: \[\`utils.gather\`\]. This will be converted into a link with
+`utils.gather` in the description. To get rid of the path and only keep the name of the object you are
+linking to in the description, add a ~: \[\`~utils.gather\`\] will generate a link with `gather` in the description.
+
+The same works for methods so you can either use \[\`XXXClass.method\`\] or \[~\`XXXClass.method\`\].
+
+#### Defining arguments in a method
+
+Arguments should be defined with the `Args:` (or `Arguments:` or `Parameters:`) prefix, followed by a line return and
+an indentation. The argument should be followed by its type, with its shape if it is a tensor, a colon, and its
+description:
+
+```
+    Args:
+        n_layers (`int`): The number of layers of the model.
+```
+
+If the description is too long to fit in one line (more than 119 characters in total), another indentation is necessary 
+before writing the description after the argument.
+
+Finally, to maintain uniformity if any *one* description is too long to fit on one line, the 
+rest of the parameters should follow suit and have an indention before their description.
+
+Here's an example showcasing everything so far:
+
+```
+    Args:
+        gradient_accumulation_steps (`int`, *optional*, default to 1):
+            The number of steps that should pass before gradients are accumulated. A number > 1 should be combined with `Accelerator.accumulate`.
+        cpu (`bool`, *optional*):
+            Whether or not to force the script to execute on CPU. Will ignore GPU available if set to `True` and force the execution on one process only.
+```
+
+For optional arguments or arguments with defaults we follow the following syntax: imagine we have a function with the
+following signature:
+
+```
+def my_function(x: str = None, a: float = 1):
+```
+
+then its documentation should look like this:
+
+```
+    Args:
+        x (`str`, *optional*):
+            This argument controls ... and has a description longer than 119 chars.
+        a (`float`, *optional*, defaults to 1):
+            This argument is used to ... and has a description longer than 119 chars.
+```
+
+Note that we always omit the "defaults to \`None\`" when None is the default for any argument. Also note that even
+if the first line describing your argument type and its default gets long, you can't break it into several lines. You can
+however write as many lines as you want in the indented description (see the example above with `input_ids`).
+
+#### Writing a multi-line code block
+
+Multi-line code blocks can be useful for displaying examples. They are done between two lines of three backticks as usual in Markdown:
+
+
+````
+```python
+# first line of code
+# second line
+# etc
+```
+````
+
+#### Writing a return block
+
+The return block should be introduced with the `Returns:` prefix, followed by a line return and an indentation.
+The first line should be the type of the return, followed by a line return. No need to indent further for the elements
+building the return.
+
+Here's an example of a single value return:
+
+```
+    Returns:
+        `List[int]`: A list of integers in the range [0, 1] --- 1 for a special token, 0 for a sequence token.
+```
+
+Here's an example of a tuple return, comprising several objects:
+
+```
+    Returns:
+        `tuple(torch.FloatTensor)` comprising various elements depending on the configuration ([`BertConfig`]) and inputs:
+        - ** loss** (*optional*, returned when `masked_lm_labels` is provided) `torch.FloatTensor` of shape `(1,)` --
+          Total loss is the sum of the masked language modeling loss and the next sequence prediction (classification) loss.
+        - **prediction_scores** (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.vocab_size)`) --
+          Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).
+```
+
+## Styling the docstring
+
+We have an automatic script running with the `make style` comment that will make sure that:
+- the docstrings fully take advantage of the line width
+- all code examples are formatted using black, like the code of the Transformers library
+
+This script may have some weird failures if you make a syntax mistake or if you uncover a bug. Therefore, it's
+recommended to commit your changes before running `make style`, so you can revert the changes done by that script
+easily.
+
+## Writing documentation examples
+
+The syntax, for example, docstrings can look as follows:
+
+```
+    Example:
+
+    ```python
+    >>> import time
+    >>> from accelerate import Accelerator
+    >>> accelerator = Accelerator()
+    >>> if accelerator.is_main_process:
+    ...     time.sleep(2)
+    >>> else:
+    ...     print("I'm waiting for the main process to finish its sleep...")
+    >>> accelerator.wait_for_everyone()
+    >>> # Should print on every process at the same time
+    >>> print("Everyone is here")
+    ```
+```
+
+The docstring should give a minimal, clear example of how the respective function 
+is to be used in inference and also include the expected (ideally sensible)
+output.
+Often, readers will try out the example before even going through the function 
+or class definitions. Therefore, it is of utmost importance that the example 
+works as expected.
diff --git a/docs/source/_config.py b/docs/source/_config.py
new file mode 100644
index 0000000..2974756
--- /dev/null
+++ b/docs/source/_config.py
@@ -0,0 +1,7 @@
+# docstyle-ignore
+INSTALL_CONTENT = """
+# PEFT installation
+! pip install peft accelerate transformers
+# To install from source instead of the last release, comment the command above and uncomment the following one.
+# ! pip install git+https://github.com/huggingface/peft.git
+"""
diff --git a/docs/source/_redirects.yml b/docs/source/_redirects.yml
new file mode 100644
index 0000000..7408cd0
--- /dev/null
+++ b/docs/source/_redirects.yml
@@ -0,0 +1,3 @@
+conceptual_guides/adapter: package_reference/lora
+conceptual_guides/ia3: package_reference/ia3
+developer_guides/lora: package_reference/lora
diff --git a/docs/source/_toctree.yml b/docs/source/_toctree.yml
new file mode 100644
index 0000000..035594e
--- /dev/null
+++ b/docs/source/_toctree.yml
@@ -0,0 +1,276 @@
+- title: Get started
+  sections:
+  - local: index
+    title: 🤗 PEFT
+  - local: quicktour
+    title: Quicktour
+  - local: install
+    title: Installation
+
+- title: Guides
+  sections:
+  - local: guides/peft_model_config
+    title: Configurations and models
+  - local: guides/peft_integrations
+    title: Integrations
+  - sections:
+    - local: accelerate/deepspeed
+      title: DeepSpeed
+    - local: accelerate/fsdp
+      title: Fully Sharded Data Parallel
+    title: Distributed Training
+  - local: developer_guides/memory_efficient_training
+    title: Memory Efficient Training
+  - local: developer_guides/model_merging
+    title: Model merging
+  - local: developer_guides/quantization
+    title: Quantization
+  - local: developer_guides/custom_models
+    title: Custom models
+  - local: developer_guides/low_level_api
+    title: Adapter injection
+  - local: developer_guides/mixed_models
+    title: Mixing PEFT methods
+  - local: developer_guides/torch_compile
+    title: torch.compile
+  - local: developer_guides/contributing
+    title: Contribute to PEFT
+  - local: developer_guides/troubleshooting
+    title: Troubleshooting
+  - local: developer_guides/checkpoint
+    title: PEFT checkpoint format
+
+- title: Methods
+  sections:
+    - local: methods/overview
+      title: Overview
+    - sections:
+      - local: package_reference/cartridges
+        title: Cartridges
+      - local: package_reference/cpt
+        title: CPT
+      - local: package_reference/llama_adapter
+        title: Llama-Adapter
+      - local: package_reference/p_tuning
+        title: P-Tuning
+      - local: package_reference/prefix_tuning
+        title: Prefix tuning
+      - local: package_reference/prompt_tuning
+        title: Prompt tuning
+      title: Soft Prompting
+    - sections:
+      - local: package_reference/beft
+        title: BEFT
+      - local: package_reference/layernorm_tuning
+        title: LayerNorm Tuning
+      - local: package_reference/trainable_tokens
+        title: Trainable Tokens
+      title: Layer Tuning
+    - sections:
+      - local: package_reference/adalora
+        title: AdaLoRA
+      - local: package_reference/adamss
+        title: AdaMSS
+      - local: package_reference/boft
+        title: BOFT
+      - local: package_reference/c3a
+        title: C3A
+      - local: package_reference/deft
+        title: DEFT
+      - local: package_reference/delora
+        title: DeLoRA
+      - local: package_reference/fourierft
+        title: FourierFT
+      - local: package_reference/gralora
+        title: GraLoRA
+      - local: package_reference/hira
+        title: HiRA
+      - local: package_reference/hra
+        title: HRA
+      - local: package_reference/ia3
+        title: IA3
+      - local: package_reference/lily
+        title: Lily
+      - local: package_reference/loha
+        title: LoHa
+      - local: package_reference/lokr
+        title: LoKr
+      - sections:
+        - local: package_reference/lora
+          title: LoRA
+        - local: package_reference/lora_variant_bdlora
+          title: "Variant: BD-LoRA"
+        - local: package_reference/lora_variant_dora
+          title: "Variant: DoRA"
+        - local: package_reference/lora_variant_monteclora
+          title: "Variant: MonteCLoRA"
+        - local: package_reference/lora_variant_velora
+          title: "Variant: VeLoRA"
+        title: LoRA
+      - local: package_reference/miss
+        title: MiSS
+      - local: package_reference/oft
+        title: OFT
+      - local: package_reference/osf
+        title: OSF
+      - local: package_reference/peanut
+        title: PEANuT
+      - local: package_reference/poly
+        title: Polytropon
+      - local: package_reference/psoft
+        title: PSOFT
+      - local: package_reference/pvera
+        title: PVeRA
+      - local: package_reference/randlora
+        title: RandLora
+      - local: package_reference/road
+        title: RoAd
+      - local: package_reference/shira
+        title: SHiRA
+      - local: package_reference/tinylora
+        title: TinyLoRA
+      - local: package_reference/unilora
+        title: UniLoRA
+      - local: package_reference/vblora
+        title: VB-LoRA
+      - local: package_reference/vera
+        title: VeRA
+      - local: package_reference/waveft
+        title: WaveFT
+      - local: package_reference/xlora
+        title: X-LoRA
+      title: Adapters
+
+- isExpanded: false
+  sections:
+  - sections:
+    - local: package_reference/auto_class
+      title: AutoPeftModel
+    - local: package_reference/peft_model
+      title: PEFT model
+    - local: package_reference/peft_types
+      title: PEFT types
+    - local: package_reference/config
+      title: Configuration
+    - local: package_reference/tuners
+      title: Tuner
+    title: Main classes
+  - sections:
+    - local: package_reference/adalora
+      title: AdaLoRA
+    - local: package_reference/adamss
+      title: AdaMSS
+    - local: package_reference/beft
+      title: BEFT
+    - local: package_reference/boft
+      title: BOFT
+    - local: package_reference/c3a
+      title: C3A
+    - local: package_reference/cartridges
+      title: Cartridges
+    - local: package_reference/cpt
+      title: CPT
+    - local: package_reference/deft
+      title: DEFT
+    - local: package_reference/delora
+      title: DeLoRA
+    - local: package_reference/fourierft
+      title: FourierFT
+    - local: package_reference/gralora
+      title: GraLoRA
+    - local: package_reference/hira
+      title: HiRA
+    - local: package_reference/hra
+      title: HRA
+    - local: package_reference/ia3
+      title: IA3
+    - local: package_reference/layernorm_tuning
+      title: Layernorm tuning
+    - local: package_reference/lily
+      title: Lily
+    - local: package_reference/llama_adapter
+      title: Llama-Adapter
+    - local: package_reference/loha
+      title: LoHa
+    - local: package_reference/lokr
+      title: LoKr
+    - local: package_reference/lora
+      title: LoRA
+    - local: package_reference/adapter_utils
+      title: LyCORIS
+    - local: package_reference/miss
+      title: MiSS
+    - local: package_reference/multitask_prompt_tuning
+      title: Multitask Prompt Tuning
+    - local: package_reference/oft
+      title: OFT
+    - local: package_reference/osf
+      title: OSF
+    - local: package_reference/p_tuning
+      title: P-tuning
+    - local: package_reference/peanut
+      title: PEANuT
+    - local: package_reference/poly
+      title: Polytropon
+    - local: package_reference/prefix_tuning
+      title: Prefix tuning
+    - local: package_reference/prompt_tuning
+      title: Prompt tuning
+    - local: package_reference/psoft
+      title: PSOFT
+    - local: package_reference/pvera
+      title: PVeRA
+    - local: package_reference/fourierft
+      title: FourierFT
+    - local: package_reference/frod
+      title: FRoD
+    - local: package_reference/glora
+      title: GLoRA
+    - local: package_reference/gralora
+      title: GraLoRA
+    - local: package_reference/vblora
+      title: VB-LoRA
+    - local: package_reference/hira
+      title: HiRA
+    - local: package_reference/hra
+      title: HRA
+    - local: package_reference/deft
+      title: DEFT
+    - local: package_reference/cpt
+      title: CPT
+    - local: package_reference/trainable_tokens
+      title: Trainable Tokens
+    - local: package_reference/randlora
+      title: RandLora
+    - local: package_reference/road
+      title: RoAd
+    - local: package_reference/shira
+      title: SHiRA
+    - local: package_reference/tinylora
+      title: TinyLoRA
+    - local: package_reference/unilora
+      title: UniLoRA
+    - local: package_reference/trainable_tokens
+      title: Trainable Tokens
+    - local: package_reference/vblora
+      title: VB-LoRA
+    - local: package_reference/vera
+      title: VeRA
+    - local: package_reference/waveft
+      title: WaveFT
+    - local: package_reference/xlora
+      title: X-LoRA
+    title: Tuners
+  - sections:
+    - local: package_reference/merge_utils
+      title: Model merge
+    - local: package_reference/helpers
+      title: Helpers
+    - local: package_reference/hotswap
+      title: Hotswapping adapters
+    - local: package_reference/functional
+      title: Functions for PEFT integration
+    - local: package_reference/lora_conversion
+      title: Converting non-LoRA adapters to LoRA
+    title: Utilities
+  title: API reference
diff --git a/docs/source/accelerate/deepspeed.md b/docs/source/accelerate/deepspeed.md
new file mode 100644
index 0000000..40c7e43
--- /dev/null
+++ b/docs/source/accelerate/deepspeed.md
@@ -0,0 +1,449 @@
+<!--⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+-->
+
+# DeepSpeed
+
+[DeepSpeed](https://www.deepspeed.ai/) is a library designed for speed and scale for distributed training of large models with billions of parameters. At its core is the Zero Redundancy Optimizer (ZeRO) that shards optimizer states (ZeRO-1), gradients (ZeRO-2), and parameters (ZeRO-3) across data parallel processes. This drastically reduces memory usage, allowing you to scale your training to billion parameter models. To unlock even more memory efficiency, ZeRO-Offload reduces GPU compute and memory by leveraging CPU resources during optimization.
+
+Both of these features are supported in 🤗 Accelerate, and you can use them with 🤗 PEFT. 
+
+## Compatibility with `bitsandbytes` quantization + LoRA
+
+Below is a table that summarizes the compatibility between PEFT's LoRA, [`bitsandbytes`](https://github.com/TimDettmers/bitsandbytes) library and DeepSpeed Zero stages with respect to fine-tuning. DeepSpeed Zero-1 and 2 will have no effect at inference as stage 1 shards the optimizer states and stage 2 shards the optimizer states and gradients:
+
+| DeepSpeed stage   | Is compatible? |
+|---|---|
+| Zero-1 |  🟢 |
+| Zero-2   |  🟢 |
+| Zero-3  |  🟢 |
+
+For DeepSpeed Stage 3 + QLoRA, please refer to the section [Use PEFT QLoRA and DeepSpeed with ZeRO3 for finetuning large models on multiple GPUs](#use-peft-qlora-and-deepspeed-with-zero3-for-finetuning-large-models-on-multiple-gpus) below.
+
+For confirming these observations, we ran the SFT (Supervised Fine-tuning) [official example scripts](https://github.com/huggingface/trl/tree/main/examples) of the [Transformers Reinforcement Learning (TRL) library](https://github.com/huggingface/trl) using QLoRA + PEFT and the accelerate configs available [here](https://github.com/huggingface/trl/tree/main/examples/accelerate_configs). We ran these experiments on a 2x NVIDIA T4 GPU.
+
+# Use PEFT and DeepSpeed with ZeRO3 for finetuning large models on multiple devices and multiple nodes
+
+This section of guide will help you learn how to use our DeepSpeed [training script](https://github.com/huggingface/peft/blob/main/examples/sft/train.py) for performing SFT. You'll configure the script to do SFT (supervised fine-tuning) of Llama-70B model with LoRA and ZeRO-3 on 8xH100 80GB GPUs on a single machine. You can configure it to scale to multiple machines by changing the accelerate config.
+
+## Configuration
+
+Start by running the following command to [create a DeepSpeed configuration file](https://huggingface.co/docs/accelerate/quicktour#launching-your-distributed-script) with 🤗 Accelerate. The `--config_file` flag allows you to save the configuration file to a specific location, otherwise it is saved as a `default_config.yaml` file in the 🤗 Accelerate cache.
+
+The configuration file is used to set the default options when you launch the training script.
+
+```bash
+accelerate config --config_file deepspeed_config.yaml
+```
+
+You'll be asked a few questions about your setup, and configure the following arguments. In this example, you'll use ZeRO-3 so make sure you pick those options.
+
+```bash
+`zero_stage`: [0] Disabled, [1] optimizer state partitioning, [2] optimizer+gradient state partitioning and [3] optimizer+gradient+parameter partitioning
+`gradient_accumulation_steps`: Number of training steps to accumulate gradients before averaging and applying them. Pass the same value as you would pass via cmd argument else you will encounter mismatch error.
+`gradient_clipping`: Enable gradient clipping with value. Don't set this as you will be passing it via cmd arguments.
+`offload_optimizer_device`: [none] Disable optimizer offloading, [cpu] offload optimizer to CPU, [nvme] offload optimizer to NVMe SSD. Only applicable with ZeRO >= Stage-2. Set this as `none` as don't want to enable offloading.
+`offload_param_device`: [none] Disable parameter offloading, [cpu] offload parameters to CPU, [nvme] offload parameters to NVMe SSD. Only applicable with ZeRO Stage-3. Set this as `none` as don't want to enable offloading.
+`zero3_init_flag`: Decides whether to enable `deepspeed.zero.Init` for constructing massive models. Only applicable with ZeRO Stage-3. Set this to `True`.
+`zero3_save_16bit_model`: Decides whether to save 16-bit model weights when using ZeRO Stage-3. Set this to `True`.
+`mixed_precision`: `no` for FP32 training, `fp16` for FP16 mixed-precision training and `bf16` for BF16 mixed-precision training. Set this to `True`.
+```
+
+Once this is done, the corresponding config should look like below and you can find it in config folder at [deepspeed_config.yaml](https://github.com/huggingface/peft/blob/main/examples/sft/configs/deepspeed_config.yaml):
+
+```yml
+compute_environment: LOCAL_MACHINE                                                                                                                                           
+debug: false
+deepspeed_config:
+  deepspeed_multinode_launcher: standard
+  gradient_accumulation_steps: 4
+  offload_optimizer_device: none
+  offload_param_device: none
+  zero3_init_flag: true
+  zero3_save_16bit_model: true
+  zero_stage: 3
+distributed_type: DEEPSPEED
+downcast_bf16: 'no'
+machine_rank: 0
+main_training_function: main
+mixed_precision: bf16
+num_machines: 1
+num_processes: 8
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false
+```
+
+## Launch command
+
+The launch command is available at [run_peft_deepspeed.sh](https://github.com/huggingface/peft/blob/main/examples/sft/run_peft_deepspeed.sh) and it is also shown below:
+```bash
+accelerate launch --config_file "configs/deepspeed_config.yaml"  train.py \
+--seed 100 \
+--model_name_or_path "meta-llama/Llama-2-70b-hf" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_seq_len 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "llama-sft-lora-deepspeed" \
+--per_device_train_batch_size 8 \
+--per_device_eval_batch_size 8 \
+--gradient_accumulation_steps 4 \
+--gradient_checkpointing True \
+--use_reentrant False \
+--dataset_text_field "content" \
+--use_flash_attn True \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "all-linear" \
+--use_4bit_quantization False
+```
+
+Notice that we are using LoRA with  rank=8, alpha=16 and targeting all linear layers. We are passing the deepspeed config file and finetuning 70B Llama model on a subset of the ultrachat dataset.
+
+## The important parts
+
+Let's dive a little deeper into the script so you can see what's going on, and understand how it works.
+
+The first thing to know is that the script uses DeepSpeed for distributed training as the DeepSpeed config has been passed. The [`~trl.SFTTrainer`] class handles all the heavy lifting of creating the PEFT model using the peft config that is passed. After that, when you call `trainer.train()`, [`~trl.SFTTrainer`] internally uses 🤗 Accelerate to prepare the model, optimizer and trainer using the DeepSpeed config to create DeepSpeed engine which is then trained. The main code snippet is below:
+
+```python
+# trainer
+trainer = SFTTrainer(
+    model=model,
+    processing_class=tokenizer,
+    args=training_args,
+    train_dataset=train_dataset,
+    eval_dataset=eval_dataset,
+    peft_config=peft_config,
+)
+trainer.accelerator.print(f"{trainer.model}")
+
+# train
+checkpoint = None
+if training_args.resume_from_checkpoint is not None:
+    checkpoint = training_args.resume_from_checkpoint
+trainer.train(resume_from_checkpoint=checkpoint)
+
+# saving final model
+trainer.save_model()
+```
+
+## Memory usage
+
+In the above example, the memory consumed per GPU is 64 GB (80%) as seen in the screenshot below:
+
+<div class="flex justify-center">
+    <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/peft/peft_deepspeed_mem_usage.png"/>
+</div>
+<small>GPU memory usage for the training run</small>
+
+## More resources
+You can also refer this blog post [Falcon 180B Finetuning using 🤗 PEFT and DeepSpeed](https://medium.com/@sourabmangrulkar/falcon-180b-finetuning-using-peft-and-deepspeed-b92643091d99) on how to finetune 180B Falcon model on 16 A100 GPUs on 2 machines.
+
+
+# Use PEFT QLoRA and DeepSpeed with ZeRO3 for finetuning large models on multiple GPUs
+
+In this section, we will look at how to use QLoRA and DeepSpeed Stage-3 for finetuning 70B llama model on 2X40GB GPUs.
+For this, we first need `bitsandbytes>=0.43.3`, `accelerate>=1.0.1`, `transformers>4.44.2`, `trl>0.11.4` and `peft>0.13.0`. We need to set `zero3_init_flag` to true when using Accelerate config. Below is the config which can be found at [deepspeed_config_z3_qlora.yaml](https://github.com/huggingface/peft/blob/main/examples/sft/configs/deepspeed_config_z3_qlora.yaml):
+
+```yml
+compute_environment: LOCAL_MACHINE                                                                                                                                           
+debug: false
+deepspeed_config:
+  deepspeed_multinode_launcher: standard
+  offload_optimizer_device: none
+  offload_param_device: none
+  zero3_init_flag: true
+  zero3_save_16bit_model: true
+  zero_stage: 3
+distributed_type: DEEPSPEED
+downcast_bf16: 'no'
+machine_rank: 0
+main_training_function: main
+mixed_precision: bf16
+num_machines: 1
+num_processes: 2
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false
+```
+
+Launch command is given below which is available at [run_peft_qlora_deepspeed_stage3.sh](https://github.com/huggingface/peft/blob/main/examples/sft/run_peft_qlora_deepspeed_stage3.sh):
+```
+accelerate launch --config_file "configs/deepspeed_config_z3_qlora.yaml"  train.py \
+--seed 100 \
+--model_name_or_path "meta-llama/Llama-2-70b-hf" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_seq_len 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "llama-sft-qlora-dsz3" \
+--per_device_train_batch_size 2 \
+--per_device_eval_batch_size 2 \
+--gradient_accumulation_steps 2 \
+--gradient_checkpointing True \
+--use_reentrant True \
+--dataset_text_field "content" \
+--use_flash_attn True \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "all-linear" \
+--use_4bit_quantization True \
+--use_nested_quant True \
+--bnb_4bit_compute_dtype "bfloat16" \
+--bnb_4bit_quant_storage_dtype "bfloat16"
+```
+
+Notice the new argument being passed `bnb_4bit_quant_storage_dtype` which denotes the data type for packing the 4-bit parameters. For example, when it is set to `bfloat16`, **32/4 = 8** 4-bit params are packed together post quantization.
+
+In terms of training code, the important code changes are: 
+
+```diff
+...
+
+bnb_config = BitsAndBytesConfig(
+    load_in_4bit=args.use_4bit_quantization,
+    bnb_4bit_quant_type=args.bnb_4bit_quant_type,
+    bnb_4bit_compute_dtype=compute_dtype,
+    bnb_4bit_use_double_quant=args.use_nested_quant,
++   bnb_4bit_quant_storage=quant_storage_dtype,
+)
+
+...
+
+model = AutoModelForCausalLM.from_pretrained(
+    args.model_name_or_path,
+    quantization_config=bnb_config,
+    trust_remote_code=True,
+    attn_implementation="flash_attention_2" if args.use_flash_attn else "eager",
++   dtype=quant_storage_dtype or torch.float32,
+)
+```
+
+Notice that `dtype` for `AutoModelForCausalLM` is same as the `bnb_4bit_quant_storage` data type. That's it. Everything else is handled by Trainer and TRL.
+
+## Memory usage
+
+In the above example, the memory consumed per GPU is **36.6 GB**. Therefore, what took 8X80GB GPUs with DeepSpeed Stage 3+LoRA and a couple of 80GB GPUs with DDP+QLoRA now requires 2X40GB GPUs. This makes finetuning of large models more accessible.
+
+# Use PEFT and DeepSpeed with ZeRO3 and CPU Offloading for finetuning large models on a single GPU
+This section of guide will help you learn how to use our DeepSpeed [training script](https://github.com/huggingface/peft/blob/main/examples/conditional_generation/peft_lora_seq2seq_accelerate_ds_zero3_offload.py). You'll configure the script to train a large model for conditional generation with ZeRO-3 and CPU Offload.
+
+> [!TIP]
+> 💡 To help you get started, check out our example training scripts for [causal language modeling](https://github.com/huggingface/peft/blob/main/examples/causal_language_modeling/peft_lora_clm_accelerate_ds_zero3_offload.py) and [conditional generation](https://github.com/huggingface/peft/blob/main/examples/conditional_generation/peft_lora_seq2seq_accelerate_ds_zero3_offload.py). You can adapt these scripts for your own applications or even use them out of the box if your task is similar to the one in the scripts.
+
+## Configuration
+
+Start by running the following command to [create a DeepSpeed configuration file](https://huggingface.co/docs/accelerate/quicktour#launching-your-distributed-script) with 🤗 Accelerate. The `--config_file` flag allows you to save the configuration file to a specific location, otherwise it is saved as a `default_config.yaml` file in the 🤗 Accelerate cache.
+
+The configuration file is used to set the default options when you launch the training script.
+
+```bash
+accelerate config --config_file ds_zero3_cpu.yaml
+```
+
+You'll be asked a few questions about your setup, and configure the following arguments. In this example, you'll use ZeRO-3 along with CPU-Offload so make sure you pick those options.
+
+```bash
+`zero_stage`: [0] Disabled, [1] optimizer state partitioning, [2] optimizer+gradient state partitioning and [3] optimizer+gradient+parameter partitioning
+`gradient_accumulation_steps`: Number of training steps to accumulate gradients before averaging and applying them.
+`gradient_clipping`: Enable gradient clipping with value.
+`offload_optimizer_device`: [none] Disable optimizer offloading, [cpu] offload optimizer to CPU, [nvme] offload optimizer to NVMe SSD. Only applicable with ZeRO >= Stage-2.
+`offload_param_device`: [none] Disable parameter offloading, [cpu] offload parameters to CPU, [nvme] offload parameters to NVMe SSD. Only applicable with ZeRO Stage-3.
+`zero3_init_flag`: Decides whether to enable `deepspeed.zero.Init` for constructing massive models. Only applicable with ZeRO Stage-3.
+`zero3_save_16bit_model`: Decides whether to save 16-bit model weights when using ZeRO Stage-3.
+`mixed_precision`: `no` for FP32 training, `fp16` for FP16 mixed-precision training and `bf16` for BF16 mixed-precision training. 
+```
+
+An example [configuration file](https://github.com/huggingface/peft/blob/main/examples/conditional_generation/accelerate_ds_zero3_cpu_offload_config.yaml) might look like the following. The most important thing to notice is that `zero_stage` is set to `3`, and `offload_optimizer_device` and `offload_param_device` are set to the `cpu`.
+
+```yml
+compute_environment: LOCAL_MACHINE
+deepspeed_config:
+  gradient_accumulation_steps: 1
+  gradient_clipping: 1.0
+  offload_optimizer_device: cpu
+  offload_param_device: cpu
+  zero3_init_flag: true
+  zero3_save_16bit_model: true
+  zero_stage: 3
+distributed_type: DEEPSPEED
+downcast_bf16: 'no'
+dynamo_backend: 'NO'
+fsdp_config: {}
+machine_rank: 0
+main_training_function: main
+megatron_lm_config: {}
+mixed_precision: 'no'
+num_machines: 1
+num_processes: 1
+rdzv_backend: static
+same_network: true
+use_cpu: false
+```
+
+## The important parts
+
+Let's dive a little deeper into the script so you can see what's going on, and understand how it works.
+
+Within the [`main`](https://github.com/huggingface/peft/blob/2822398fbe896f25d4dac5e468624dc5fd65a51b/examples/conditional_generation/peft_lora_seq2seq_accelerate_ds_zero3_offload.py#L103) function, the script creates an [`~accelerate.Accelerator`] class to initialize all the necessary requirements for distributed training.
+
+> [!TIP]
+> 💡 Feel free to change the model and dataset inside the `main` function. If your dataset format is different from the one in the script, you may also need to write your own preprocessing function.
+
+The script also creates a configuration for the 🤗 PEFT method you're using, which in this case, is LoRA. The [`LoraConfig`] specifies the task type and important parameters such as the dimension of the low-rank matrices, the matrices scaling factor, and the dropout probability of the LoRA layers. If you want to use a different 🤗 PEFT method, make sure you replace `LoraConfig` with the appropriate [class](../package_reference/tuners).
+
+```diff
+ def main():
++    accelerator = Accelerator()
+     model_name_or_path = "facebook/bart-large"
+     dataset_name = "twitter_complaints"
++    peft_config = LoraConfig(
+         task_type=TaskType.SEQ_2_SEQ_LM, inference_mode=False, r=8, lora_alpha=32, lora_dropout=0.1
+     )
+```
+
+Throughout the script, you'll see the [`~accelerate.Accelerator.main_process_first`] and [`~accelerate.Accelerator.wait_for_everyone`] functions which help control and synchronize when processes are executed.
+
+The [`get_peft_model`] function takes a base model and the [`peft_config`] you prepared earlier to create a [`PeftModel`]:
+
+```diff
+  model = AutoModelForSeq2SeqLM.from_pretrained(model_name_or_path)
++ model = get_peft_model(model, peft_config)
+```
+
+Pass all the relevant training objects to 🤗 Accelerate's [`~accelerate.Accelerator.prepare`] which makes sure everything is ready for training:
+
+```py
+model, train_dataloader, eval_dataloader, test_dataloader, optimizer, lr_scheduler = accelerator.prepare(
+    model, train_dataloader, eval_dataloader, test_dataloader, optimizer, lr_scheduler
+)
+```
+
+The next bit of code checks whether the DeepSpeed plugin is used in the `Accelerator`, and if the plugin exists, then we check if we are using ZeRO-3. This conditional flag is used when calling `generate` function call during inference for syncing GPUs when the model parameters are sharded:
+
+```py
+is_ds_zero_3 = False
+if getattr(accelerator.state, "deepspeed_plugin", None):
+    is_ds_zero_3 = accelerator.state.deepspeed_plugin.zero_stage == 3
+```
+
+Inside the training loop, the usual `loss.backward()` is replaced by 🤗 Accelerate's [`~accelerate.Accelerator.backward`] which uses the correct `backward()` method based on your configuration:
+
+```diff
+  for epoch in range(num_epochs):
+      with TorchTracemalloc() as tracemalloc:
+          model.train()
+          total_loss = 0
+          for step, batch in enumerate(tqdm(train_dataloader)):
+              outputs = model(**batch)
+              loss = outputs.loss
+              total_loss += loss.detach().float()
++             accelerator.backward(loss)
+              optimizer.step()
+              lr_scheduler.step()
+              optimizer.zero_grad()
+```
+
+That is all! The rest of the script handles the training loop, evaluation, and even pushes it to the Hub for you.
+
+## Train
+
+Run the following command to launch the training script. Earlier, you saved the configuration file to `ds_zero3_cpu.yaml`, so you'll need to pass the path to the launcher with the `--config_file` argument like this:
+
+```bash
+accelerate launch --config_file ds_zero3_cpu.yaml examples/peft_lora_seq2seq_accelerate_ds_zero3_offload.py
+```
+
+You'll see some output logs that track memory usage during training, and once it's completed, the script returns the accuracy and compares the predictions to the labels:
+
+```bash
+GPU Memory before entering the train : 1916
+GPU Memory consumed at the end of the train (end-begin): 66
+GPU Peak Memory consumed during the train (max-begin): 7488
+GPU Total Peak Memory consumed during the train (max): 9404
+CPU Memory before entering the train : 19411
+CPU Memory consumed at the end of the train (end-begin): 0
+CPU Peak Memory consumed during the train (max-begin): 0
+CPU Total Peak Memory consumed during the train (max): 19411
+epoch=4: train_ppl=tensor(1.0705, device='cuda:0') train_epoch_loss=tensor(0.0681, device='cuda:0')
+100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:27<00:00,  3.92s/it]
+GPU Memory before entering the eval : 1982
+GPU Memory consumed at the end of the eval (end-begin): -66
+GPU Peak Memory consumed during the eval (max-begin): 672
+GPU Total Peak Memory consumed during the eval (max): 2654
+CPU Memory before entering the eval : 19411
+CPU Memory consumed at the end of the eval (end-begin): 0
+CPU Peak Memory consumed during the eval (max-begin): 0
+CPU Total Peak Memory consumed during the eval (max): 19411
+accuracy=100.0
+eval_preds[:10]=['no complaint', 'no complaint', 'complaint', 'complaint', 'no complaint', 'no complaint', 'no complaint', 'complaint', 'complaint', 'no complaint']
+dataset['train'][label_column][:10]=['no complaint', 'no complaint', 'complaint', 'complaint', 'no complaint', 'no complaint', 'no complaint', 'complaint', 'complaint', 'no complaint']
+```
+
+# Caveats
+1. Merging when using PEFT and DeepSpeed is currently unsupported and will raise error.
+2. When using CPU offloading, the major gains from using PEFT to shrink the optimizer states and gradients to that of the adapter weights would be realized on CPU RAM and there won't be savings with respect to GPU memory.
+3. DeepSpeed Stage 3 and qlora when used with CPU offloading leads to more GPU memory usage when compared to disabling CPU offloading. 
+
+> [!TIP]
+> 💡 When you have code that requires merging (and unmerging) of weights, try to manually collect the parameters with DeepSpeed Zero-3 beforehand:
+>
+> ```python
+> import deepspeed
+>
+> is_ds_zero_3 = ... # check if Zero-3
+>
+> with deepspeed.zero.GatheredParameters(list(model.parameters()), enabled= is_ds_zero_3):
+>     model.merge_adapter()
+>     # do whatever is needed, then unmerge in the same context if unmerging is required
+>     ...
+>     model.unmerge_adapter()
+> ```
diff --git a/docs/source/accelerate/fsdp.md b/docs/source/accelerate/fsdp.md
new file mode 100644
index 0000000..a209bc0
--- /dev/null
+++ b/docs/source/accelerate/fsdp.md
@@ -0,0 +1,285 @@
+<!--⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+-->
+
+# Fully Sharded Data Parallel
+
+[Fully sharded data parallel](https://pytorch.org/docs/stable/fsdp.html) (FSDP) is developed for distributed training of large pretrained models up to 1T parameters. FSDP achieves this by sharding the model parameters, gradients, and optimizer states across data parallel processes and it can also offload sharded model parameters to a CPU. The memory efficiency afforded by FSDP allows you to scale training to larger batch or model sizes.
+
+Both of these features are supported in 🤗 Accelerate, and you can use them with 🤗 PEFT. 
+
+# Use PEFT and FSDP
+This section of guide will help you learn how to use our DeepSpeed [training script](https://github.com/huggingface/peft/blob/main/examples/sft/train.py) for performing SFT. You'll configure the script to do SFT (supervised fine-tuning) of Llama-70B model with LoRA and FSDP on 8xH100 80GB GPUs on a single machine. You can configure it to scale to multiple machines by changing the accelerate config.
+
+## Configuration
+
+Start by running the following command to [create a FSDP configuration file](https://huggingface.co/docs/accelerate/quicktour#launching-your-distributed-script) with 🤗 Accelerate. The `--config_file` flag allows you to save the configuration file to a specific location, otherwise it is saved as a `default_config.yaml` file in the 🤗 Accelerate cache.
+
+The configuration file is used to set the default options when you launch the training script.
+
+```bash
+accelerate config --config_file fsdp_config.yaml
+```
+
+You'll be asked a few questions about your setup, and configure the following arguments. In this example, you'll answer the questionnaire as shown in the image below.
+<div class="flex justify-center">
+    <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/peft/fsdp-peft-config.png"/>
+</div>
+<small>Creating Accelerate's config to use FSDP</small>
+
+Once this is done, the corresponding config should look like below and you can find it in config folder at [fsdp_config.yaml](https://github.com/huggingface/peft/blob/main/examples/sft/configs/fsdp_config.yaml):
+
+```yml
+compute_environment: LOCAL_MACHINE
+debug: false
+distributed_type: FSDP
+downcast_bf16: 'no'
+fsdp_config:
+  fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
+  fsdp_backward_prefetch: BACKWARD_PRE
+  fsdp_cpu_ram_efficient_loading: true
+  fsdp_forward_prefetch: false
+  fsdp_offload_params: false
+  fsdp_sharding_strategy: FULL_SHARD
+  fsdp_state_dict_type: SHARDED_STATE_DICT
+  fsdp_sync_module_states: true
+  fsdp_use_orig_params: false
+machine_rank: 0
+main_training_function: main
+mixed_precision: bf16
+num_machines: 1
+num_processes: 8
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false
+```
+
+## Launch command
+
+The launch command is available at [run_peft_fsdp.sh](https://github.com/huggingface/peft/blob/main/examples/sft/run_peft_fsdp.sh) and it is also shown below:
+```bash
+accelerate launch --config_file "configs/fsdp_config.yaml"  train.py \
+--seed 100 \
+--model_name_or_path "meta-llama/Llama-2-70b-hf" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_seq_len 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "llama-sft-lora-fsdp" \
+--per_device_train_batch_size 8 \
+--per_device_eval_batch_size 8 \
+--gradient_accumulation_steps 4 \
+--gradient_checkpointing True \
+--use_reentrant False \
+--dataset_text_field "content" \
+--use_flash_attn True \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "all-linear" \
+--use_4bit_quantization False
+```
+
+Notice that we are using LoRA with  rank=8, alpha=16 and targeting all linear layers. We are passing the FSDP config file and finetuning the 70B Llama model on a subset of the [ultrachat dataset](https://huggingface.co/datasets/HuggingFaceH4/ultrachat_200k).
+
+## The important parts
+
+Let's dive a little deeper into the script so you can see what's going on, and understand how it works.
+
+The first thing to know is that the script uses FSDP for distributed training as the FSDP config has been passed. The [`~trl.SFTTrainer`] class handles all the heavy lifting of creating PEFT model using the peft config that is passed. After that when you call `trainer.train()`, Trainer internally uses 🤗 Accelerate to prepare model, optimizer and trainer using the FSDP config to create FSDP wrapped model which is then trained. The main code snippet is below:
+
+```python
+# trainer
+trainer = SFTTrainer(
+    model=model,
+    processing_class=tokenizer,
+    args=training_args,
+    train_dataset=train_dataset,
+    eval_dataset=eval_dataset,
+    peft_config=peft_config,
+)
+trainer.accelerator.print(f"{trainer.model}")
+if model_args.use_peft_lora:
+    # handle PEFT+FSDP case
+    trainer.model.print_trainable_parameters()
+    if getattr(trainer.accelerator.state, "fsdp_plugin", None):
+        from peft.utils.other import fsdp_auto_wrap_policy
+
+        fsdp_plugin = trainer.accelerator.state.fsdp_plugin
+        fsdp_plugin.auto_wrap_policy = fsdp_auto_wrap_policy(trainer.model)
+
+# train
+checkpoint = None
+if training_args.resume_from_checkpoint is not None:
+    checkpoint = training_args.resume_from_checkpoint
+trainer.train(resume_from_checkpoint=checkpoint)
+
+# saving final model
+if trainer.is_fsdp_enabled:
+    trainer.accelerator.state.fsdp_plugin.set_state_dict_type("FULL_STATE_DICT")
+trainer.save_model()
+```
+
+
+Here, one main thing to note currently when using FSDP with PEFT is that `use_orig_params` needs to be `False` to realize GPU memory savings. Due to `use_orig_params=False`, the auto wrap policy for FSDP needs to change so that trainable and non-trainable parameters are wrapped separately. This is done by the code snippt below which uses the util function `fsdp_auto_wrap_policy` from PEFT:
+
+```
+if getattr(trainer.accelerator.state, "fsdp_plugin", None):
+    from peft.utils.other import fsdp_auto_wrap_policy
+
+    fsdp_plugin = trainer.accelerator.state.fsdp_plugin
+    fsdp_plugin.auto_wrap_policy = fsdp_auto_wrap_policy(trainer.model)
+```
+
+## Memory usage
+
+In the above example, the memory consumed per GPU is  72-80 GB (90-98%) as seen in the screenshot below. The slight increase in GPU memory at the end is when saving the model using `FULL_STATE_DICT` state dict type instead of the `SHARDED_STATE_DICT` so that the model has adapter weights that can be loaded normally with `from_pretrained` method during inference:
+
+<div class="flex justify-center">
+    <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/peft/peft_fsdp_mem_usage.png"/>
+</div>
+<small>GPU memory usage for the training run</small>
+
+# Use PEFT QLoRA and FSDP for finetuning large models on multiple GPUs
+
+In this section, we will look at how to use QLoRA and FSDP for finetuning 70B llama model on 2X24GB GPUs. [Answer.AI](https://www.answer.ai/) in collaboration with bitsandbytes and Hugging Face 🤗 open sourced code enabling the usage of FSDP+QLoRA and explained the whole process in their insightful blogpost [You can now train a 70b language model at home](https://www.answer.ai/posts/2024-03-06-fsdp-qlora.html). This is now integrated in Hugging Face ecosystem. 
+
+For this, we first need `bitsandbytes>=0.43.3`, `accelerate>=1.0.1`, `transformers>4.44.2`, `trl>0.11.4` and `peft>0.13.0`. We need to set `fsdp_cpu_ram_efficient_loading=true`, `fsdp_use_orig_params=false` and `fsdp_offload_params=true`(cpu offloading) when using Accelerate config. When not using accelerate launcher, you can alternately set the environment variable `export FSDP_CPU_RAM_EFFICIENT_LOADING=true`.  Here, we will be using accelerate config and below is the config which can be found at [fsdp_config_qlora.yaml](https://github.com/huggingface/peft/blob/main/examples/sft/configs/fsdp_config_qlora.yaml):
+
+```yml
+compute_environment: LOCAL_MACHINE                                                                                                                                           
+debug: false                                                                                                                                                                 
+distributed_type: FSDP
+downcast_bf16: 'no'
+fsdp_config:
+  fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
+  fsdp_backward_prefetch: BACKWARD_PRE
+  fsdp_cpu_ram_efficient_loading: true
+  fsdp_forward_prefetch: false
+  fsdp_offload_params: true
+  fsdp_sharding_strategy: FULL_SHARD
+  fsdp_state_dict_type: SHARDED_STATE_DICT
+  fsdp_sync_module_states: true
+  fsdp_use_orig_params: false
+machine_rank: 0
+main_training_function: main
+mixed_precision: 'no'
+num_machines: 1
+num_processes: 2
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false
+```
+
+Launch command is given below which is available at [run_peft_qlora_fsdp.sh](https://github.com/huggingface/peft/blob/main/examples/sft/run_peft_qlora_fsdp.sh):
+```
+accelerate launch --config_file "configs/fsdp_config_qlora.yaml"  train.py \
+--seed 100 \
+--model_name_or_path "meta-llama/Llama-2-70b-hf" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_seq_len 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "llama-sft-qlora-fsdp" \
+--per_device_train_batch_size 2 \
+--per_device_eval_batch_size 2 \
+--gradient_accumulation_steps 2 \
+--gradient_checkpointing True \
+--use_reentrant True \
+--dataset_text_field "content" \
+--use_flash_attn True \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "all-linear" \
+--use_4bit_quantization True \
+--use_nested_quant True \
+--bnb_4bit_compute_dtype "bfloat16" \
+--bnb_4bit_quant_storage_dtype "bfloat16"
+```
+
+Notice the new argument being passed, `bnb_4bit_quant_storage_dtype`, which denotes the data type for packing the 4-bit parameters. For example, when it is set to `bfloat16`, **16/4 = 4** 4-bit params are packed together post quantization. When using mixed precision training with `bfloat16`, `bnb_4bit_quant_storage_dtype` can be either `bfloat16` for pure `bfloat16` finetuning, or `float32` for automatic mixed precision (this consumes more GPU memory). When using mixed precision training with `float16`, `bnb_4bit_quant_storage_dtype` should be set to `float32` for stable automatic mixed precision training.
+
+In terms of training code, the important code changes are: 
+
+```diff
+...
+
+bnb_config = BitsAndBytesConfig(
+    load_in_4bit=args.use_4bit_quantization,
+    bnb_4bit_quant_type=args.bnb_4bit_quant_type,
+    bnb_4bit_compute_dtype=compute_dtype,
+    bnb_4bit_use_double_quant=args.use_nested_quant,
++   bnb_4bit_quant_storage=quant_storage_dtype,
+)
+
+...
+
+model = AutoModelForCausalLM.from_pretrained(
+    args.model_name_or_path,
+    quantization_config=bnb_config,
+    trust_remote_code=True,
+    attn_implementation="flash_attention_2" if args.use_flash_attn else "eager",
++   dtype=quant_storage_dtype or torch.float32,
+)
+```
+
+Notice that `dtype` for `AutoModelForCausalLM` is same as the `bnb_4bit_quant_storage` data type. That's it. Everything else is handled by Trainer and TRL.
+
+## Memory usage
+
+In the above example, the memory consumed per GPU is **19.6 GB** while CPU RAM usage is around **107 GB**. When disabling CPU offloading, the GPU memory usage is  **35.6 GB/ GPU**. Therefore, what took 16X80GB GPUs for full finetuning, 8X80GB GPUs with FSDP+LoRA, and a couple of 80GB GPUs with DDP+QLoRA, now requires 2X24GB GPUs. This makes finetuning of large models more accessible.
+
+## More resources
+You can also refer the [llama-recipes](https://github.com/facebookresearch/llama-recipes/?tab=readme-ov-file#fine-tuning) repo and [Getting started with Llama](https://llama.meta.com/get-started/#fine-tuning) guide on how to finetune using FSDP and PEFT.
+
+## Caveats
+1. Merging when using PEFT and FSDP is currently unsupported and will raise error.
+2. Passing `modules_to_save` config parameter to is untested at present.
+3. GPU Memory saving when using CPU Offloading is untested at present.
+4. When using FSDP+QLoRA, `paged_adamw_8bit` currently results in an error when saving a checkpoint.
+5. DoRA training with FSDP should work (albeit at lower speed than LoRA). If combined with bitsandbytes (QDoRA), 4-bit quantization should also work, but 8-bit quantization has known issues and is not recommended.
diff --git a/docs/source/developer_guides/checkpoint.md b/docs/source/developer_guides/checkpoint.md
new file mode 100644
index 0000000..ea05731
--- /dev/null
+++ b/docs/source/developer_guides/checkpoint.md
@@ -0,0 +1,244 @@
+<!--Copyright 2024 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# PEFT checkpoint format
+
+This document describes how PEFT's checkpoint files are structured and how to convert between the PEFT format and other formats.
+
+## PEFT files
+
+PEFT (parameter-efficient fine-tuning) methods only update a small subset of a model's parameters rather than all of them. This is nice because checkpoint files can generally be much smaller than the original model files and are easier to store and share. However, this also means that to load a PEFT model, you need to have the original model available as well.
+
+When you call [`~PeftModel.save_pretrained`] on a PEFT model, the PEFT model saves three files, described below:
+
+1. `adapter_model.safetensors` or `adapter_model.bin`
+
+By default, the model is saved in the `safetensors` format, a secure alternative to the `bin` format, which is known to be susceptible to [security vulnerabilities](https://huggingface.co/docs/hub/security-pickle) because it uses the pickle utility under the hood. Both formats store the same `state_dict` though, and are interchangeable.
+
+The `state_dict` only contains the parameters of the adapter module, not the base model. To illustrate the difference in size, a normal BERT model requires ~420MB of disk space, whereas an IA³ adapter on top of this BERT model only requires ~260KB.
+
+2. `adapter_config.json`
+
+The `adapter_config.json` file contains the configuration of the adapter module, which is necessary to load the model. Below is an example of an `adapter_config.json` for an IA³ adapter with standard settings applied to a BERT model:
+
+```json
+{
+  "auto_mapping": {
+    "base_model_class": "BertModel",
+    "parent_library": "transformers.models.bert.modeling_bert"
+  },
+  "base_model_name_or_path": "bert-base-uncased",
+  "fan_in_fan_out": false,
+  "feedforward_modules": [
+    "output.dense"
+  ],
+  "inference_mode": true,
+  "init_ia3_weights": true,
+  "modules_to_save": null,
+  "peft_type": "IA3",
+  "revision": null,
+  "target_modules": [
+    "key",
+    "value",
+    "output.dense"
+  ],
+  "task_type": null
+}
+```
+
+The configuration file contains:
+
+- the adapter module type stored, `"peft_type": "IA3"`
+- information about the base model like `"base_model_name_or_path": "bert-base-uncased"`
+- the revision of the model (if any), `"revision": null`
+
+If the base model is not a pretrained Transformers model, the latter two entries will be `null`. Other than that, the settings are all related to the specific IA³ adapter that was used to fine-tune the model.
+
+3. `README.md`
+
+The generated `README.md` is the model card of a PEFT model and contains a few pre-filled entries. The intent of this is to make it easier to share the model with others and to provide some basic information about the model. This file is not needed to load the model.
+
+## Convert to PEFT format
+
+When converting from another format to the PEFT format, we require both the `adapter_model.safetensors` (or `adapter_model.bin`) file and the `adapter_config.json` file.
+
+### adapter_model
+
+For the model weights, it is important to use the correct mapping from parameter name to value for PEFT to load the file. Getting this mapping right is an exercise in checking the implementation details, as there is no generally agreed upon format for PEFT adapters.
+
+Fortunately, figuring out this mapping is not overly complicated for common base cases. Let's look at a concrete example, the [`LoraLayer`](https://github.com/huggingface/peft/blob/main/src/peft/tuners/lora/layer.py):
+
+```python
+# showing only part of the code
+
+class LoraLayer(BaseTunerLayer):
+    # All names of layers that may contain (trainable) adapter weights
+    adapter_layer_names = ("lora_A", "lora_B", "lora_embedding_A", "lora_embedding_B")
+    # All names of other parameters that may contain adapter-related parameters
+    other_param_names = ("r", "lora_alpha", "scaling", "lora_dropout")
+
+    def __init__(self, base_layer: nn.Module, **kwargs) -> None:
+        self.base_layer = base_layer
+        self.r = {}
+        self.lora_alpha = {}
+        self.scaling = {}
+        self.lora_dropout = nn.ModuleDict({})
+        self.lora_A = nn.ModuleDict({})
+        self.lora_B = nn.ModuleDict({})
+        # For Embedding layer
+        self.lora_embedding_A = nn.ParameterDict({})
+        self.lora_embedding_B = nn.ParameterDict({})
+        # Mark the weight as unmerged
+        self._disable_adapters = False
+        self.merged_adapters = []
+        self.use_dora: dict[str, bool] = {}
+        self.lora_magnitude_vector: Optional[torch.nn.ParameterDict] = None  # for DoRA
+        self._caches: dict[str, Any] = {}
+        self.kwargs = kwargs
+```
+
+In the `__init__` code used by all `LoraLayer` classes in PEFT, there are a bunch of parameters used to initialize the model, but only a few are relevant for the checkpoint file: `lora_A`, `lora_B`, `lora_embedding_A`, and `lora_embedding_B`. These parameters are listed in the class attribute `adapter_layer_names` and contain the learnable parameters, so they must be included in the checkpoint file. All the other parameters, like the rank `r`, are derived from the `adapter_config.json` and must be included there (unless the default value is used).
+
+Let's check the `state_dict` of a PEFT LoRA model applied to BERT. When printing the first five keys using the default LoRA settings (the remaining keys are the same, just with different layer numbers), we get:
+
+- `base_model.model.encoder.layer.0.attention.self.query.lora_A.weight` 
+- `base_model.model.encoder.layer.0.attention.self.query.lora_B.weight` 
+- `base_model.model.encoder.layer.0.attention.self.value.lora_A.weight` 
+- `base_model.model.encoder.layer.0.attention.self.value.lora_B.weight` 
+- `base_model.model.encoder.layer.1.attention.self.query.lora_A.weight`
+- etc.
+
+Let's break this down:
+
+- By default, for BERT models, LoRA is applied to the `query` and `value` layers of the attention module. This is why you see `attention.self.query` and `attention.self.value` in the key names for each layer.
+- LoRA decomposes the weights into two low-rank matrices, `lora_A` and `lora_B`. This is where `lora_A` and `lora_B` come from in the key names.
+- These LoRA matrices are implemented as `nn.Linear` layers, so the parameters are stored in the `.weight` attribute (`lora_A.weight`, `lora_B.weight`).
+- By default, LoRA isn't applied to BERT's embedding layer, so there are _no entries_ for `lora_A_embedding` and `lora_B_embedding`.
+- The keys of the `state_dict` always start with `"base_model.model."`. The reason is that, in PEFT, we wrap the base model inside a tuner-specific model (`LoraModel` in this case), which itself is wrapped in a general PEFT model (`PeftModel`). For this reason, these two prefixes are added to the keys. When converting to the PEFT format, it is required to add these prefixes.
+
+> [!TIP]
+> This last point is not true for prefix tuning techniques like prompt tuning. There, the extra embeddings are directly stored in the `state_dict` without any prefixes added to the keys.
+
+When inspecting the parameter names in the loaded model, you might be surprised to find that they look a bit different, e.g. `base_model.model.encoder.layer.0.attention.self.query.lora_A.default.weight`. The difference is the *`.default`* part in the second to last segment. This part exists because PEFT generally allows the addition of multiple adapters at once (using an `nn.ModuleDict` or `nn.ParameterDict` to store them). For example, if you add another adapter called "other", the key for that adapter would be `base_model.model.encoder.layer.0.attention.self.query.lora_A.other.weight`.
+
+When you call [`~PeftModel.save_pretrained`], the adapter name is stripped from the keys. The reason is that the adapter name is not an important part of the model architecture; it is just an arbitrary name. When loading the adapter, you could choose a totally different name, and the model would still work the same way. This is why the adapter name is not stored in the checkpoint file.
+
+> [!TIP]
+> If you call `save_pretrained("some/path")` and the adapter name is not `"default"`, the adapter is stored in a sub-directory with the same name as the adapter. So if the name is "other", it would be stored inside of `some/path/other`.
+
+In some circumstances, deciding which values to add to the checkpoint file can become a bit more complicated. For example, in PEFT, DoRA is implemented as a special case of LoRA. If you want to convert a DoRA model to PEFT, you should create a LoRA checkpoint with extra entries for DoRA. You can see this in the `__init__` of the previous `LoraLayer` code:
+
+```python
+self.lora_magnitude_vector: Optional[torch.nn.ParameterDict] = None  # for DoRA
+```
+
+This indicates that there is an optional extra parameter per layer for DoRA.
+
+### adapter_config
+
+All the other information needed to load a PEFT model is contained in the `adapter_config.json` file. Let's check this file for a LoRA model applied to BERT:
+
+```json
+{
+  "alpha_pattern": {},
+  "auto_mapping": {
+    "base_model_class": "BertModel",
+    "parent_library": "transformers.models.bert.modeling_bert"
+  },
+  "base_model_name_or_path": "bert-base-uncased",
+  "bias": "none",
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 8,
+  "lora_dropout": 0.0,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "peft_type": "LORA",
+  "r": 8,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "query",
+    "value"
+  ],
+  "task_type": null,
+  "use_dora": false,
+  "use_rslora": false
+}
+```
+
+This contains a lot of entries, and at first glance, it could feel overwhelming to figure out all the right values to put in there. However, most of the entries are not necessary to load the model. This is either because they use the default values and don't need to be added or because they only affect the initialization of the LoRA weights, which is irrelevant when it comes to loading the model. If you find that you don't know what a specific parameter does, e.g., `"use_rslora",` don't add it, and you should be fine. Also note that as more options are added, this file will get more entries in the future, but it should be backward compatible.
+
+At the minimum, you should include the following entries:
+
+```json
+{
+  "target_modules": ["query", "value"],
+  "peft_type": "LORA"
+}
+```
+
+However, adding as many entries as possible, like the rank `r` or the `base_model_name_or_path` (if it's a Transformers model) is recommended. This information can help others understand the model better and share it more easily. To check which keys and values are expected, check out the [config.py](https://github.com/huggingface/peft/blob/main/src/peft/tuners/lora/config.py) file (as an example, this is the config file for LoRA) in the PEFT source code.
+
+## Model storage
+
+In some circumstances, you might want to store the whole PEFT model, including the base weights. This can be necessary if, for instance, the base model is not available to the users trying to load the PEFT model. You can merge the weights first or convert it into a Transformer model.
+
+### Merge the weights
+
+The most straightforward way to store the whole PEFT model is to merge the adapter weights into the base weights:
+
+```python
+merged_model = model.merge_and_unload()
+merged_model.save_pretrained(...)
+```
+
+There are some disadvantages to this approach, though:
+
+- Once [`~LoraModel.merge_and_unload`] is called, you get a basic model without any PEFT-specific functionality. This means you can't use any of the PEFT-specific methods anymore.
+- You cannot unmerge the weights, load multiple adapters at once, disable the adapter, etc.
+- Not all PEFT methods support merging weights.
+- Some PEFT methods may generally allow merging, but not with specific settings (e.g. when using certain quantization techniques).
+- The whole model will be much larger than the PEFT model, as it will contain all the base weights as well.
+
+But inference with a merged model should be a bit faster.
+
+### Convert to a Transformers model
+
+Another way to save the whole model, assuming the base model is a Transformers model, is to use this hacky approach to directly insert the PEFT weights into the base model and save it, which only works if you "trick" Transformers into believing the PEFT model is not a PEFT model. This only works with LoRA because other adapters are not implemented in Transformers.
+
+```python
+model = ...  # the PEFT model
+...
+# after you finish training the model, save it in a temporary location
+model.save_pretrained(<temp_location>)
+# now load this model directly into a transformers model, without the PEFT wrapper
+# the PEFT weights are directly injected into the base model
+model_loaded = AutoModel.from_pretrained(<temp_location>)
+# now make the loaded model believe that it is _not_ a PEFT model
+model_loaded._hf_peft_config_loaded = False
+# now when we save it, it will save the whole model
+model_loaded.save_pretrained(<final_location>)
+# or upload to Hugging Face Hub
+model_loaded.push_to_hub(<final_location>)
+```
+
diff --git a/docs/source/developer_guides/contributing.md b/docs/source/developer_guides/contributing.md
new file mode 100644
index 0000000..976a4ea
--- /dev/null
+++ b/docs/source/developer_guides/contributing.md
@@ -0,0 +1,159 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# Contribute to PEFT
+
+We are happy to accept contributions to PEFT. If you plan to contribute, please read this to make the process as smooth as possible.
+
+## Installation
+
+Follow these steps to start contributing:
+
+1. Fork the [repository](https://github.com/huggingface/peft) by clicking on the 'Fork' button on the repository's page. This creates a copy of the code under your GitHub user account.
+
+2. Clone your fork to your local disk, and add the base repository as a remote. The following command assumes you have your public SSH key uploaded to GitHub. See the following guide for more [information](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository).
+
+   ```bash
+   git clone git@github.com:<your Github handle>/peft.git
+   cd peft
+   git remote add upstream https://github.com/huggingface/peft.git
+   ```
+
+3. Create a new branch to hold your development changes, and do this for every new PR you work on.
+
+   Start by synchronizing your `main` branch with the `upstream/main` branch (more details in the [GitHub Docs](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/syncing-a-fork)):
+
+   ```bash
+   git checkout main
+   git fetch upstream
+   git merge upstream/main
+   ```
+
+   Once your `main` branch is synchronized, create a new branch from it:
+
+   ```bash
+   git checkout -b a-descriptive-name-for-my-changes
+   ```
+
+   **Do not** work on the `main` branch.
+
+4. Set up a development environment by running the following command in a conda or a virtual environment you've created for working on this library:
+
+   ```bash
+   pip install -e ".[test]"
+   ```
+
+   (If PEFT was already installed in the virtual environment, remove it with `pip uninstall peft` before reinstalling it.)
+
+If you are new to creating a pull request, follow the [Creating a pull request](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request) guide by GitHub.
+
+## Tests and code quality checks
+
+Regardless of the contribution type (unless it’s only about the docs), you should run tests and code quality checks before creating a PR to ensure your contribution doesn’t break anything and follows the project standards.
+
+We provide a Makefile to execute the necessary tests. Run the code below for the unit test:
+
+```sh
+make test
+```
+
+Run one of the following to either only check or check and fix code quality and style:
+
+```sh
+make quality  # just check
+make style  # check and fix
+```
+
+You can also set up [`pre-commit`](https://pre-commit.com/) to run these fixes
+automatically as Git commit hooks.
+
+```bash
+$ pip install pre-commit
+$ pre-commit install
+```
+
+Running all the tests can take a while, so during development it can be more efficient to only [run tests specific to your change](https://docs.pytest.org/en/6.2.x/usage.html#specifying-tests-selecting-tests), e.g. via:
+
+```sh
+pytest tests/<test-file-name> -k <name-of-test>
+```
+
+This should finish much quicker and allow for faster iteration.
+
+If your change is specific to a hardware setting (e.g., it requires CUDA), take a look at [`tests/test_gpu_examples.py`](https://github.com/huggingface/peft/blob/1c1c7fdaa6e6abaa53939b865dee1eded82ad032/tests/test_gpu_examples.py) and [`tests/test_common_gpu.py`](https://github.com/huggingface/peft/blob/1c1c7fdaa6e6abaa53939b865dee1eded82ad032/tests/test_common_gpu.py) to see if it makes sense to add tests there. If your change could have an effect on saving and loading models, please run the tests with the `--regression` flag to trigger regression tests.
+
+It can happen that while you’re working on your PR, the underlying code base changes due to other changes being merged. If that happens – especially when there is a merge conflict – please update your branch with the latest changes. This can be a merge or a rebase, and we'll squash and merge the PR once it’s ready. If possible, **avoid force pushes** to make reviews easier.
+
+## PR description
+
+When opening a PR, please provide a nice description of the change you're proposing. If it relates to other issues or PRs, please reference them. Providing a good description not only helps the reviewers review your code better and faster, it can also be used later (as a basis) for the commit message which helps with long term maintenance of the project.
+
+If your code makes some non-trivial changes, it may also be a good idea to add comments to the code to explain those changes. For example, if you had to iterate on your implementation multiple times because the most obvious way didn’t work, it’s a good indication that a code comment is needed.
+
+## Bugfixes
+
+Please give a description of the circumstances that led to the bug. If there is an existing issue, please link to it (e.g., “Resolves #12345”).
+
+Ideally when a bugfix is provided, it should be accompanied by a test for the bug. The test should fail with the current code and pass with the bugfix. Add a comment to the test that references the issue or PR. Without a test, it is more difficult to prevent regressions in the future.
+
+## Documentation improvements
+
+We are happy to have fixes for broken links and missing or unclear documentation. Taking care of examples, making sure that they are up-to-date and running fine in this fast moving environment is also highly appreciated.
+
+Please refrain from sending pull requests that *only* correct typing errors as these generally create more work than they safe. Such changes are better combined with more substantial fixes (such as fixing broken links or extending/updating documentation).
+
+## Add a new PEFT fine-tuning method
+
+New parameter-efficient fine-tuning methods are developed all the time. If you would like to add a new and promising method to PEFT, please follow these steps.
+
+1. If you're _not_ an author of the original paper, check for existing implementations and double check with the authors that they don't plan to submit a PR themselves.
+2. Start with the core integration work listed below.
+3. Check recent commits for new PEFT methods being added to take as inspiration.
+4. It can be useful to open a draft PR early once the method basically works and first tests pass, then ask for feedback.
+5. After working through reviewer feedback, ping the reviewer so that they know the PR is ready to review.
+
+### Core integration of a new PEFT method
+
+- [ ] Open a proposal issue on `huggingface/peft` before investing too much work.
+- [ ] Link the source of the method, usually the final paper or another stable primary reference. We want to avoid work that is still under review, as the implementation should be stable.
+- [ ] Add a new `PeftType` entry in `src/peft/utils/peft_types.py`.
+- [ ] Create a new tuner package under `src/peft/tuners/` with the files your method needs (typically:  `config.py`, `model.py`, `layer.py`, and `__init__.py`).
+- [ ] Register the method in the tuner `__init__.py` with `register_peft_method(...)`.
+- [ ] Export the new config/model from `src/peft/tuners/__init__.py` and `src/peft/__init__.py`.
+- [ ] If the method needs default target modules for Transformers models, add the mapping in `src/peft/utils/constants.py`.
+- [ ] Add the method to the test matrix in `tests/test_custom_models.py` as these are the broadest and quickest tests. Check that the tests pass with `pytest tests/test_custom_models.py -k <method-name> -v`, fix failures if any.
+- [ ] Run style/quality checks with `make style` before pushing.
+- [ ] In the PR description, explain the method, link the paper, summarize tradeoffs, and list what was added.
+
+### Full PR to add a new PEFT method
+
+- [ ] Ensure that the configuration arguments that are specific to the method are well named and explained, don't assume that the user knows the paper inside out.
+- [ ] Follow the naming and coding conventions of PEFT.
+- [ ] Ensure that you didn't accidentally check in unrelated changes, e.g. the code formatter changing unrelated files.
+- [ ] If some implementation choices are non-trivial, document them with a code comment.
+- [ ] Complete the full test suite (`test_config.py`, `test_decoder_models.py`, etc.) by adding the PEFT method to the test matrix. Ensure that the tests pass.
+- [ ] Add docs in `docs/source/package_reference/` with a short explanation, paper link, usage snippet, and autodoc blocks. Explain the pros and cons compared to other methods like LoRA. Register that doc page in `docs/source/_toctree.yml`.
+- [ ] Add a runnable example under `examples/` (can be a copy of an existing example), with a short `README.md`.
+- [ ] Check the benchmarks in `method_comparison/` and add experiment settings for your new method. This is a good place to sanity check that the PEFT method trains as expected. Include one or two reasonable benchmark configurations (one default, one optimized for the benchmark).
+- [ ] Recommended: Add generic quantization support. Instead of having to explicitly add quantization layer types for each quantization method, support generic quantization. As an example, check how it's implemented in [BOFT](https://github.com/huggingface/peft/tree/main/src/peft/tuners/boft). Extend https://github.com/huggingface/peft/blob/main/tests/test_quantization.py by adding your PEFT method there. Ask maintainers for help if needed.
+
+## Add other features
+
+It is best if you first open an issue on GitHub with a proposal to add the new feature. This way, you can discuss with the maintainers if it makes sense to add the feature before spending too much time on implementing it.
+
+New features should generally be accompanied by tests and documentation or examples. Without the latter, users will have a hard time discovering your cool new feature.
+
+Changes to the code should be implemented in a backward-compatible way. For example, existing code should continue to work the same way after the feature is merged.
diff --git a/docs/source/developer_guides/custom_models.md b/docs/source/developer_guides/custom_models.md
new file mode 100644
index 0000000..d6ad6e9
--- /dev/null
+++ b/docs/source/developer_guides/custom_models.md
@@ -0,0 +1,304 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# Custom models
+
+Some fine-tuning techniques, such as prompt tuning, are specific to language models. That means in 🤗 PEFT, it is
+assumed a 🤗 Transformers model is being used. However, other fine-tuning techniques - like
+[LoRA](../package_reference/lora) - are not restricted to specific model types.
+
+In this guide, we will see how LoRA can be applied to a multilayer perceptron, a computer vision model from the [timm](https://huggingface.co/docs/timm/index) library, or a new 🤗 Transformers architecture.
+
+## Multilayer perceptron
+
+Let's assume that we want to fine-tune a multilayer perceptron with LoRA. Here is the definition:
+
+```python
+from torch import nn
+
+
+class MLP(nn.Module):
+    def __init__(self, num_units_hidden=2000):
+        super().__init__()
+        self.seq = nn.Sequential(
+            nn.Linear(20, num_units_hidden),
+            nn.ReLU(),
+            nn.Linear(num_units_hidden, num_units_hidden),
+            nn.ReLU(),
+            nn.Linear(num_units_hidden, 2),
+            nn.LogSoftmax(dim=-1),
+        )
+
+    def forward(self, X):
+        return self.seq(X)
+```
+
+This is a straightforward multilayer perceptron with an input layer, a hidden layer, and an output layer.
+
+> [!TIP]
+> For this toy example, we choose an exceedingly large number of hidden units to highlight the efficiency gains
+> from PEFT, but those gains are in line with more realistic examples.
+
+There are a few linear layers in this model that could be tuned with LoRA. When working with common 🤗 Transformers
+models, PEFT will know which layers to apply LoRA to, but in this case, it is up to us as a user to choose the layers.
+To determine the names of the layers to tune:
+
+```python
+print([(n, type(m)) for n, m in MLP().named_modules()])
+```
+
+This should print:
+
+```
+[('', __main__.MLP),
+ ('seq', torch.nn.modules.container.Sequential),
+ ('seq.0', torch.nn.modules.linear.Linear),
+ ('seq.1', torch.nn.modules.activation.ReLU),
+ ('seq.2', torch.nn.modules.linear.Linear),
+ ('seq.3', torch.nn.modules.activation.ReLU),
+ ('seq.4', torch.nn.modules.linear.Linear),
+ ('seq.5', torch.nn.modules.activation.LogSoftmax)]
+```
+
+Let's say we want to apply LoRA to the input layer and to the hidden layer, those are `'seq.0'` and `'seq.2'`. Moreover,
+let's assume we want to update the output layer without LoRA, that would be `'seq.4'`. The corresponding config would
+be:
+
+```python
+from peft import LoraConfig
+
+config = LoraConfig(
+    target_modules=["seq.0", "seq.2"],
+    modules_to_save=["seq.4"],
+)
+```
+
+With that, we can create our PEFT model and check the fraction of parameters trained:
+
+```python
+from peft import get_peft_model
+
+model = MLP()
+peft_model = get_peft_model(model, config)
+peft_model.print_trainable_parameters()
+# prints trainable params: 56,164 || all params: 4,100,164 || trainable%: 1.369798866581922
+```
+
+Finally, we can use any training framework we like, or write our own fit loop, to train the `peft_model`.
+
+For a complete example, check out [this notebook](https://github.com/huggingface/peft/blob/main/examples/multilayer_perceptron/multilayer_perceptron_lora.ipynb).
+
+## timm models
+
+The [timm](https://huggingface.co/docs/timm/index) library contains a large number of pretrained computer vision models.
+Those can also be fine-tuned with PEFT. Let's check out how this works in practice.
+
+To start, ensure that timm is installed in the Python environment:
+
+```bash
+python -m pip install -U timm
+```
+
+Next we load a timm model for an image classification task:
+
+```python
+import timm
+
+num_classes = ...
+model_id = "timm/poolformer_m36.sail_in1k"
+model = timm.create_model(model_id, pretrained=True, num_classes=num_classes)
+```
+
+Again, we need to make a decision about what layers to apply LoRA to. Since LoRA supports 2D conv layers, and since
+those are a major building block of this model, we should apply LoRA to the 2D conv layers. To identify the names of
+those layers, let's look at all the layer names:
+
+```python
+print([(n, type(m)) for n, m in model.named_modules()])
+```
+
+This will print a very long list, we'll only show the first few:
+
+```
+[('', timm.models.metaformer.MetaFormer),
+ ('stem', timm.models.metaformer.Stem),
+ ('stem.conv', torch.nn.modules.conv.Conv2d),
+ ('stem.norm', torch.nn.modules.linear.Identity),
+ ('stages', torch.nn.modules.container.Sequential),
+ ('stages.0', timm.models.metaformer.MetaFormerStage),
+ ('stages.0.downsample', torch.nn.modules.linear.Identity),
+ ('stages.0.blocks', torch.nn.modules.container.Sequential),
+ ('stages.0.blocks.0', timm.models.metaformer.MetaFormerBlock),
+ ('stages.0.blocks.0.norm1', timm.layers.norm.GroupNorm1),
+ ('stages.0.blocks.0.token_mixer', timm.models.metaformer.Pooling),
+ ('stages.0.blocks.0.token_mixer.pool', torch.nn.modules.pooling.AvgPool2d),
+ ('stages.0.blocks.0.drop_path1', torch.nn.modules.linear.Identity),
+ ('stages.0.blocks.0.layer_scale1', timm.models.metaformer.Scale),
+ ('stages.0.blocks.0.res_scale1', torch.nn.modules.linear.Identity),
+ ('stages.0.blocks.0.norm2', timm.layers.norm.GroupNorm1),
+ ('stages.0.blocks.0.mlp', timm.layers.mlp.Mlp),
+ ('stages.0.blocks.0.mlp.fc1', torch.nn.modules.conv.Conv2d),
+ ('stages.0.blocks.0.mlp.act', torch.nn.modules.activation.GELU),
+ ('stages.0.blocks.0.mlp.drop1', torch.nn.modules.dropout.Dropout),
+ ('stages.0.blocks.0.mlp.norm', torch.nn.modules.linear.Identity),
+ ('stages.0.blocks.0.mlp.fc2', torch.nn.modules.conv.Conv2d),
+ ('stages.0.blocks.0.mlp.drop2', torch.nn.modules.dropout.Dropout),
+ ('stages.0.blocks.0.drop_path2', torch.nn.modules.linear.Identity),
+ ('stages.0.blocks.0.layer_scale2', timm.models.metaformer.Scale),
+ ('stages.0.blocks.0.res_scale2', torch.nn.modules.linear.Identity),
+ ('stages.0.blocks.1', timm.models.metaformer.MetaFormerBlock),
+ ('stages.0.blocks.1.norm1', timm.layers.norm.GroupNorm1),
+ ('stages.0.blocks.1.token_mixer', timm.models.metaformer.Pooling),
+ ('stages.0.blocks.1.token_mixer.pool', torch.nn.modules.pooling.AvgPool2d),
+ ...
+ ('head.global_pool.flatten', torch.nn.modules.linear.Identity),
+ ('head.norm', timm.layers.norm.LayerNorm2d),
+ ('head.flatten', torch.nn.modules.flatten.Flatten),
+ ('head.drop', torch.nn.modules.linear.Identity),
+ ('head.fc', torch.nn.modules.linear.Linear)]
+ ]
+```
+
+Upon closer inspection, we see that the 2D conv layers have names such as `"stages.0.blocks.0.mlp.fc1"` and
+`"stages.0.blocks.0.mlp.fc2"`. How can we match those layer names specifically? You can write a [regular
+expressions](https://docs.python.org/3/library/re.html) to match the layer names. For our case, the regex
+`r".*\.mlp\.fc\d"` should do the job.
+
+Furthermore, as in the first example, we should ensure that the output layer, in this case the classification head, is
+also updated. Looking at the end of the list printed above, we can see that it's named `'head.fc'`. With that in mind,
+here is our LoRA config:
+
+```python
+config = LoraConfig(target_modules=r".*\.mlp\.fc\d", modules_to_save=["head.fc"])
+```
+
+Then we only need to create the PEFT model by passing our base model and the config to `get_peft_model`:
+
+```python
+peft_model = get_peft_model(model, config)
+peft_model.print_trainable_parameters()
+# prints trainable params: 1,064,454 || all params: 56,467,974 || trainable%: 1.88505789139876
+```
+
+This shows us that we only need to train less than 2% of all parameters, which is a huge efficiency gain.
+
+For a complete example, check out [this notebook](https://github.com/huggingface/peft/blob/main/examples/image_classification/image_classification_timm_peft_lora.ipynb).
+
+## New transformers architectures
+
+When new popular transformers architectures are released, we do our best to quickly add them to PEFT. If you come across a transformers model that is not supported out of the box, don't worry, it will most likely still work if the config is set correctly. Specifically, you have to identify the layers that should be adapted and set them correctly when initializing the corresponding config class, e.g. `LoraConfig`. Here are some tips to help with this.
+
+As a first step, it is a good idea to check the existing models for inspiration. You can find them inside of [constants.py](https://github.com/huggingface/peft/blob/main/src/peft/utils/constants.py) in the PEFT repository. Often, you'll find a similar architecture that uses the same names. For example, if the new model architecture is a variation of the "mistral" model and you want to apply LoRA, you can see that the entry for "mistral" in `TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING` contains `["q_proj", "v_proj"]`. This tells you that for "mistral" models, the `target_modules` for LoRA should be `["q_proj", "v_proj"]`:
+
+```python
+from peft import LoraConfig, get_peft_model
+
+my_mistral_model = ...
+config = LoraConfig(
+    target_modules=["q_proj", "v_proj"],
+    ...,  # other LoRA arguments
+)
+peft_model = get_peft_model(my_mistral_model, config)
+```
+
+If that doesn't help, check the existing modules in your model architecture with the `named_modules` method and try to identify the attention layers, especially the key, query, and value layers. Those will often have names such as `c_attn`, `query`, `q_proj`, etc. The key layer is not always adapted, and ideally, you should check whether including it results in better performance.
+
+Additionally, linear layers are common targets to be adapted (e.g. in [QLoRA paper](https://huggingface.co/papers/2305.14314), authors suggest to adapt them as well). Their names will often contain the strings `fc` or `dense`.
+
+If you want to add a new model to PEFT, please create an entry in [constants.py](https://github.com/huggingface/peft/blob/main/src/peft/utils/constants.py) and open a pull request on the [repository](https://github.com/huggingface/peft/pulls). Don't forget to update the [README](https://github.com/huggingface/peft#models-support-matrix) as well.
+
+## Verify parameters and layers
+
+You can verify whether you've correctly applied a PEFT method to your model in a few ways.
+
+* Check the fraction of parameters that are trainable with the [`~PeftModel.print_trainable_parameters`] method. If this number is lower or higher than expected, check the model `repr` by printing the model. This shows the names of all the layer types in the model. Ensure that only the intended target layers are replaced by the adapter layers. For example, if LoRA is applied to `nn.Linear` layers, then you should only see `lora.Linear` layers being used.
+
+```py
+peft_model.print_trainable_parameters()
+```
+
+* Another way you can view the adapted layers is to use the `targeted_module_names` attribute to list the name of each module that was adapted.
+
+```python
+print(peft_model.targeted_module_names)
+```
+
+## Unsupported module types
+
+Methods like LoRA only work if the target modules are supported by PEFT. For example, it's possible to apply LoRA to `nn.Linear` and `nn.Conv2d` layers, but not, for instance, to `nn.LSTM`. If you find a layer class you want to apply PEFT to is not supported, you can:
+
+ - define a custom mapping to dynamically dispatch custom modules in LoRA
+ -  open an [issue](https://github.com/huggingface/peft/issues) and request the feature where maintainers will implement it or guide you on how to implement it yourself if demand for this module type is sufficiently high
+
+### Experimental support for dynamic dispatch of custom modules in LoRA
+
+> [!WARNING]
+> This feature is experimental and subject to change, depending on its reception by the community. We will introduce a public and stable API if there is significant demand for it.
+
+PEFT supports an experimental API for custom module types for LoRA. Let's assume you have a LoRA implementation for LSTMs. Normally, you would not be able to tell PEFT to use it, even if it would theoretically work with PEFT. However, this is possible with dynamic dispatch of custom layers.
+
+The experimental API currently looks like this:
+
+```python
+class MyLoraLSTMLayer:
+    ...
+
+base_model = ...  # load the base model that uses LSTMs
+
+# add the LSTM layer names to target_modules
+config = LoraConfig(..., target_modules=["lstm"])
+# define a mapping from base layer type to LoRA layer type
+custom_module_mapping = {nn.LSTM: MyLoraLSTMLayer}
+# register the new mapping
+config._register_custom_module(custom_module_mapping)
+# after registration, create the PEFT model
+peft_model = get_peft_model(base_model, config)
+# do training
+```
+
+> [!TIP]
+> When you call [`get_peft_model`], you will see a warning because PEFT does not recognize the targeted module type. In this case, you can ignore this warning.
+
+By supplying a custom mapping, PEFT first checks the base model's layers against the custom mapping and dispatches to the custom LoRA layer type if there is a match. If there is no match, PEFT checks the built-in LoRA layer types for a match.
+
+Therefore, this feature can also be used to override existing dispatch logic, e.g. if you want to use your own LoRA layer for `nn.Linear` instead of using the one provided by PEFT.
+
+When creating your custom LoRA module, please follow the same rules as the [existing LoRA modules](https://github.com/huggingface/peft/blob/main/src/peft/tuners/lora/layer.py). Some important constraints to consider:
+
+- The custom module should inherit from `nn.Module` and `peft.tuners.lora.layer.LoraLayer`.
+- The `__init__` method of the custom module should have the positional arguments `base_layer` and `adapter_name`. After this, there are additional `**kwargs` that you are free to use or ignore.
+- The learnable parameters should be stored in an `nn.ModuleDict` or `nn.ParameterDict`, where the key corresponds to the name of the specific adapter (remember that a model can have more than one adapter at a time).
+- The name of these learnable parameter attributes should start with `"lora_"`, e.g. `self.lora_new_param = ...`.
+- Some methods are optional, e.g. you only need to implement `merge` and `unmerge` if you want to support weight merging.
+
+Currently, the information about the custom module does not persist when you save the model. When loading the model, you have to register the custom modules again.
+
+```python
+# saving works as always and includes the parameters of the custom modules
+peft_model.save_pretrained(<model-path>)
+
+# loading the model later:
+base_model = ...
+# load the LoRA config that you saved earlier
+config = LoraConfig.from_pretrained(<model-path>)
+# register the custom module again, the same way as the first time
+custom_module_mapping = {nn.LSTM: MyLoraLSTMLayer}
+config._register_custom_module(custom_module_mapping)
+# pass the config instance to from_pretrained:
+peft_model = PeftModel.from_pretrained(model, tmp_path / "lora-custom-module", config=config)
+```
+
+If you use this feature and find it useful, or if you encounter problems, let us know by creating an issue or a discussion on GitHub. This allows us to estimate the demand for this feature and add a public API if it is sufficiently high.
diff --git a/docs/source/developer_guides/low_level_api.md b/docs/source/developer_guides/low_level_api.md
new file mode 100644
index 0000000..2e3236c
--- /dev/null
+++ b/docs/source/developer_guides/low_level_api.md
@@ -0,0 +1,148 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# Adapter injection
+
+With PEFT, you can inject trainable adapters into any `torch` module which allows you to use adapter methods without relying on the modeling classes in PEFT. This works for all adapters except for those based on prompt learning (e.g. prefix tuning or p-tuning).
+
+Check the table below to see when you should inject adapters.
+
+| Pros | Cons |
+|---|---|
+| the model is modified inplace, keeping all the original attributes and methods | manually write the `from_pretrained` and `save_pretrained` utility functions from Hugging Face to save and load adapters |
+| works for any `torch` module and modality | doesn't work with any of the utility methods provided by `PeftModel` such as disabling and merging adapters |
+
+## Creating a new PEFT model
+
+To perform the adapter injection, use the [`inject_adapter_in_model`] method. This method takes 3 arguments, the PEFT config, the model, and an optional adapter name. You can also attach multiple adapters to the model if you call [`inject_adapter_in_model`] multiple times with different adapter names.
+
+For example, to inject LoRA adapters into the `linear` submodule of the `DummyModel` module:
+
+```python
+import torch
+from peft import inject_adapter_in_model, LoraConfig
+
+class DummyModel(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.embedding = torch.nn.Embedding(10, 10)
+        self.linear = torch.nn.Linear(10, 10)
+        self.lm_head = torch.nn.Linear(10, 10)
+
+    def forward(self, input_ids):
+        x = self.embedding(input_ids)
+        x = self.linear(x)
+        x = self.lm_head(x)
+        return x
+
+
+lora_config = LoraConfig(
+    lora_alpha=16,
+    lora_dropout=0.1,
+    r=64,
+    bias="none",
+    target_modules=["linear"],
+)
+
+model = DummyModel()
+model = inject_adapter_in_model(lora_config, model)
+
+dummy_inputs = torch.LongTensor([[0, 1, 2, 3, 4, 5, 6, 7]])
+dummy_outputs = model(dummy_inputs)
+```
+
+Print the model to see that the adapters have been correctly injected.
+
+```bash
+DummyModel(
+  (embedding): Embedding(10, 10)
+  (linear): Linear(
+    in_features=10, out_features=10, bias=True
+    (lora_dropout): ModuleDict(
+      (default): Dropout(p=0.1, inplace=False)
+    )
+    (lora_A): ModuleDict(
+      (default): Linear(in_features=10, out_features=64, bias=False)
+    )
+    (lora_B): ModuleDict(
+      (default): Linear(in_features=64, out_features=10, bias=False)
+    )
+    (lora_embedding_A): ParameterDict()
+    (lora_embedding_B): ParameterDict()
+  )
+  (lm_head): Linear(in_features=10, out_features=10, bias=True)
+)
+```
+
+### Injection based on a `state_dict`
+
+Sometimes, it is possible that there is a PEFT adapter checkpoint but the corresponding PEFT config is not known for whatever reason. To inject the PEFT layers for this checkpoint, you would usually have to reverse-engineer the corresponding PEFT config, most notably the `target_modules` argument, based on the `state_dict` from the checkpoint. This can be cumbersome and error prone. To avoid this, it is also possible to call [`inject_adapter_in_model`] and pass the loaded `state_dict` as an argument:
+
+```python
+from safetensors.torch import load_file
+
+model = ...
+state_dict = load_file(<path-to-safetensors-file>)
+lora_config = LoraConfig(...)
+model = inject_adapter_in_model(lora_config, model, state_dict=state_dict)
+```
+
+In this case, PEFT will use the `state_dict` as reference for which layers to target instead of using the PEFT config. As a user, you don't have to set the exact `target_modules` of the PEFT config for this to work. However, you should still pass a PEFT config of the right type, in this example `LoraConfig`, you can leave the `target_modules` as `None`.
+
+Be aware that this still only creates the uninitialized PEFT layers, the values from the `state_dict` are not used to populate the model weights. To populate the weights, proceed with calling [`set_peft_model_state_dict`] as described below.
+
+⚠️ Note that if there is a mismatch between what is configured in the PEFT config and what is found in the `state_dict`, PEFT will warn you about this. You can ignore the warning if you know that the PEFT config is not correctly specified.
+
+> [!WARNING]
+> If the original PEFT adapters was using `target_parameters` instead of `target_modules`, injecting from a `state_dict` will not work correctly. In this case, it is mandatory to use the correct PEFT config for injection.
+
+## Saving the model
+
+To only save the adapter, use the [`get_peft_model_state_dict`] function:
+
+```python
+from peft import get_peft_model_state_dict
+
+peft_state_dict = get_peft_model_state_dict(model)
+print(peft_state_dict)
+```
+
+Otherwise, `model.state_dict()` returns the full state dict of the model.
+
+## Loading the model
+
+After loading the saved `state_dict`, it can be applied using the [`set_peft_model_state_dict`] function:
+
+```python
+from peft import set_peft_model_state_dict
+
+model = DummyModel()
+model = inject_adapter_in_model(lora_config, model)
+outcome = set_peft_model_state_dict(model, peft_state_dict)
+# check that there were no wrong keys
+print(outcome.unexpected_keys)
+```
+
+If injecting the adapter is slow or you need to load a large number of adapters, you may use an optimization that allows to create an "empty" adapter on meta device and only fills the weights with real weights when the [`set_peft_model_state_dict`] is called. To do this, pass `low_cpu_mem_usage=True` to both [`inject_adapter_in_model`] and [`set_peft_model_state_dict`].
+
+```python
+model = DummyModel()
+model = inject_adapter_in_model(lora_config, model, low_cpu_mem_usage=True)
+
+print(model.linear.lora_A["default"].weight.device.type == "meta")  # should be True
+set_peft_model_state_dict(model, peft_state_dict, low_cpu_mem_usage=True)
+print(model.linear.lora_A["default"].weight.device.type == "cpu")  # should be True
+```
diff --git a/docs/source/developer_guides/memory_efficient_training.md b/docs/source/developer_guides/memory_efficient_training.md
new file mode 100644
index 0000000..72eb7d1
--- /dev/null
+++ b/docs/source/developer_guides/memory_efficient_training.md
@@ -0,0 +1,63 @@
+<!--Copyright 2026-present The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# Memory Efficient Training
+
+🤗 PEFT makes fine-tuning parameter efficient, but not automatically memory efficient. This overview collects tips for cutting training memory and links to the detailed guides.
+
+> [!TIP]
+> Always consider the basics of choosing a smaller base model, smaller batch size or shorter sequence length to lower your memory usage.
+
+## Training memory overview
+
+Let's dissect the distribution of training memory so we can reason about potential countermeasures. We will use a large language-model trained with the Adam optimizer as an example. When doing full fine-tuning, we will have the following positions taking up memory:
+
+1. base model parameters: the memory consumption highly depends on the chosen `dtype`. The less bits per parameter (16 for float16), the less memory this will take up. A 1B model in float16 (16 bit/2 byte per parameter) will roughly take `1e9 × 2 byte = 1.863 GiB` of memory.
+2. all trainable base model parameters ×3 for gradients (1×) and Adam optimizer states (2×), therefore 5.59GB of memory
+3. memory for the intermediate activations between layers, these are hard to predict but mostly depend on the used compute dtype and sequence length / batch size.
+
+A smaller base model or a using a smaller compute dtype will reduce all points while using shorter sequences or smaller batches mainly affects gradients and activation memory. Employing PEFT methods will reduce the number of trainable parameters and therefore significantly reduce both gradients and optimizer state, saving a lot of memory.
+
+## Choosing the right method
+
+Not every PEFT method is built equally and some formulations are easier to build in a memory efficient manner. If you are on a memory budget it makes sense to check out the [PEFT method comparison suite](https://huggingface.co/spaces/peft-internal-testing/PEFT-method-comparison) and filter for **maximum** accelerator memory usage. Average accelerator memory usage can be fairly equal across methods but not every method scales equally with activations and sequence length; some methods are more prone to memory spikes than others.
+
+Consider [using trainable tokens](troubleshooting#using-trainable-tokens) when targeting large layers like language modeling heads or embedding layers to fine-tune specific tokens.
+
+## Quantization
+
+Quantization is one of the best ways to reduce memory consumption *of the base model* and will, depending on the employed quantization, also reduce activation memory. Since the PEFT methods will only take up a small portion of the total number of parameters, PEFT defaults to use a higher precision than the base model. This can also have the effect that adapters can mitigate some of the quality loss incurred by quantization methods. Read the [PEFT quantization guide](quantization).
+
+## Compilation
+
+The models we train are composed of operations like matrix multiplications, sums and assignments where each operation produces a new result and, subsequently, needs to take up memory. If those intermediate results are not needed we can fuse these operations and save up on memory. This is just one of many optimizations that `torch.compile` can do for you, so check out the [PEFT torch.compile guide](torch_compile).
+
+## Gradient Checkpointing
+
+You can trade memory with computation by only saving every nth gradient between layers and computing the rest on the fly. Check out the [gradient checkpointing](https://huggingface.co/docs/transformers/grad_checkpointing) documentation of Transformers to learn more.
+
+> [!NOTE]
+> When not using Diffusers or Transformers you may need to implement your own gradient checkpointing logic, depending on the training framework that you are using.
+
+## Chunked NLL loss
+
+Using [`NLLLoss`](https://docs.pytorch.org/docs/stable/generated/torch.nn.NLLLoss.html) is very common when training language models (or classification tasks). You allocate a matrix of size `batch × sequence × vocabulary`. With particularly long sequences or vocabularies this can get expensive fast.
+
+When using [TRL](https://huggingface.co/docs/trl) you can either use the [Liger kernel integration](https://huggingface.co/docs/trl/liger_kernel_integration) or use [Chunked NLLLoss](https://huggingface.co/docs/trl/v1.5.1/en/reducing_memory_usage#chunked-cross-entropy-for-reducing-peak-memory-usage). The latter will split the sequence in chunks of size 256 to keep the maximum memory consumption constant.
+
+![NLL vs. Chunked NLL comparison](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/peft/chunked_nll.png)
+
+In case the default chunk size is not optimal for your setting, look in the [original TRL PR](https://github.com/huggingface/trl/pull/5575) for more information on how to tune the chunk size.
diff --git a/docs/source/developer_guides/mixed_models.md b/docs/source/developer_guides/mixed_models.md
new file mode 100644
index 0000000..c42cf14
--- /dev/null
+++ b/docs/source/developer_guides/mixed_models.md
@@ -0,0 +1,37 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+-->
+
+# Mixed adapter types
+
+Normally, it isn't possible to mix different adapter types in 🤗 PEFT. You can create a PEFT model with two different LoRA adapters (which can have different config options), but it is not possible to combine a LoRA and LoHa adapter. With [`PeftMixedModel`] however, this works as long as the adapter types are compatible. The main purpose of allowing mixed adapter types is to combine trained adapters for inference. While it is possible to train a mixed adapter model, this has not been tested and is not recommended.
+
+To load different adapter types into a PEFT model, use [`PeftMixedModel`] instead of [`PeftModel`]:
+
+```py
+from peft import PeftMixedModel
+
+base_model = ...  # load the base model, e.g. from transformers
+# load first adapter, which will be called "default"
+peft_model = PeftMixedModel.from_pretrained(base_model, <path_to_adapter1>)
+peft_model.load_adapter(<path_to_adapter2>, adapter_name="other")
+peft_model.set_adapter(["default", "other"])
+```
+
+The [`~PeftMixedModel.set_adapter`] method is necessary to activate both adapters, otherwise only the first adapter would be active. You can keep adding more adapters by calling [`~PeftModel.add_adapter`] repeatedly.
+
+[`PeftMixedModel`] does not support saving and loading mixed adapters. The adapters should already be trained, and loading the model requires a script to be run each time.
+
+## Tips
+
+- Not all adapter types can be combined. See [`peft.tuners.mixed.COMPATIBLE_TUNER_TYPES`](https://github.com/huggingface/peft/blob/1c1c7fdaa6e6abaa53939b865dee1eded82ad032/src/peft/tuners/mixed/model.py#L35) for a list of compatible types. An error will be raised if you try to combine incompatible adapter types.
+- It is possible to mix multiple adapters of the same type which can be useful for combining adapters with very different configs.
+- If you want to combine a lot of different adapters, the most performant way to do it is to consecutively add the same adapter types. For example, add LoRA1, LoRA2, LoHa1, LoHa2 in this order, instead of LoRA1, LoHa1, LoRA2, and LoHa2. While the order can affect the output, there is no inherently *best* order, so it is best to choose the fastest one.
diff --git a/docs/source/developer_guides/model_merging.md b/docs/source/developer_guides/model_merging.md
new file mode 100644
index 0000000..3aab957
--- /dev/null
+++ b/docs/source/developer_guides/model_merging.md
@@ -0,0 +1,164 @@
+<!--Copyright 2024 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# Model merging
+
+Training a model for each task can be costly, take up storage space, and the models aren't able to learn new information to improve their performance. Multitask learning can overcome some of these limitations by training a model to learn several tasks, but it is expensive to train and designing a dataset for it is challenging. *Model merging* offers a solution to these challenges by combining multiple pretrained models into one model, giving it the combined abilities of each individual model without any additional training.
+
+PEFT provides several methods for merging models like a linear or SVD combination. This guide focuses on two methods that are more efficient for merging LoRA adapters by eliminating redundant parameters:
+
+* [TIES](https://hf.co/papers/2306.01708) - TrIm, Elect, and Merge (TIES) is a three-step method for merging models. First, redundant parameters are trimmed, then conflicting signs are resolved into an aggregated vector, and finally the parameters whose signs are the same as the aggregate sign are averaged. This method takes into account that some values (redundant and sign disagreement) can degrade performance in the merged model.
+* [DARE](https://hf.co/papers/2311.03099) - Drop And REscale is a method that can be used to prepare for other model merging methods like TIES. It works by randomly dropping parameters according to a drop rate and rescaling the remaining parameters. This helps to reduce the number of redundant and potentially interfering parameters among multiple models.
+
+Models are merged with the [`~LoraModel.add_weighted_adapter`] method, and the specific model merging method is specified in the `combination_type` parameter.
+
+## Merge method
+
+With TIES and DARE, merging is enabled by setting `combination_type` and `density` to a value of the weights to keep from the individual models. For example, let's merge three finetuned [TinyLlama/TinyLlama-1.1B-intermediate-step-1431k-3T](https://huggingface.co/TinyLlama/TinyLlama-1.1B-intermediate-step-1431k-3T) models: [tinyllama_lora_nobots](https://huggingface.co/smangrul/tinyllama_lora_norobots), [tinyllama_lora_sql](https://huggingface.co/smangrul/tinyllama_lora_sql), and [tinyllama_lora_adcopy](https://huggingface.co/smangrul/tinyllama_lora_adcopy).
+
+<Tip warning={true}>
+
+When you're attempting to merge fully trained models with TIES, you should be aware of any special tokens each model may have added to the embedding layer which are not a part of the original checkpoint's vocabulary. This may cause an issue because each model may have added a special token to the same embedding position. If this is the case, you should use the [`~transformers.PreTrainedModel.resize_token_embeddings`] method to avoid merging the special tokens at the same embedding index.
+
+<br>
+
+This shouldn't be an issue if you're only merging LoRA adapters trained from the same base model.
+
+</Tip>
+
+Load a base model and can use the [`~PeftModel.load_adapter`] method to load and assign each adapter a name:
+
+```py
+from peft import PeftConfig, PeftModel
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+
+config = PeftConfig.from_pretrained("smangrul/tinyllama_lora_norobots")
+model = AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path, load_in_4bit=True, device_map="auto").eval()
+tokenizer = AutoTokenizer.from_pretrained("smangrul/tinyllama_lora_norobots")
+
+model.config.vocab_size = 32005
+model.resize_token_embeddings(32005)
+
+model = PeftModel.from_pretrained(model, "smangrul/tinyllama_lora_norobots", adapter_name="norobots")
+_ = model.load_adapter("smangrul/tinyllama_lora_sql", adapter_name="sql")
+_ = model.load_adapter("smangrul/tinyllama_lora_adcopy", adapter_name="adcopy")
+```
+
+Set the adapters, weights, `adapter_name`, `combination_type`, and `density` with the [`~LoraModel.add_weighted_adapter`] method.
+
+<hfoptions id="merge-method">
+<hfoption id="TIES">
+
+Weight values greater than `1.0` typically produce better results because they preserve the correct scale. A good default starting value for the weights is to set all values to `1.0`.
+
+```py
+adapters = ["norobots", "adcopy", "sql"]
+weights = [2.0, 1.0, 1.0]
+adapter_name = "merge"
+density = 0.2
+model.add_weighted_adapter(adapters, weights, adapter_name, combination_type="ties", density=density)
+```
+
+</hfoption>
+<hfoption id="DARE">
+
+```py
+adapters = ["norobots", "adcopy", "sql"]
+weights = [2.0, 0.3, 0.7]
+adapter_name = "merge"
+density = 0.2
+model.add_weighted_adapter(adapters, weights, adapter_name, combination_type="dare_ties", density=density)
+```
+
+</hfoption>
+</hfoptions>
+
+Set the newly merged model as the active model with the [`~LoraModel.set_adapter`] method.
+
+```py
+model.set_adapter("merge")
+```
+
+Now you can use the merged model as an instruction-tuned model to write ad copy or SQL queries!
+
+<hfoptions id="ties">
+<hfoption id="instruct">
+
+```py
+device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+messages = [
+    {"role": "user", "content": "Write an essay about Generative AI."},
+]
+text = tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False)
+inputs = tokenizer(text, return_tensors="pt")
+inputs = {k: v.to(device) for k, v in inputs.items()}
+outputs = model.generate(**inputs, max_new_tokens=256, do_sample=True, top_p=0.95, temperature=0.2, repetition_penalty=1.2, eos_token_id=tokenizer.eos_token_id)
+print(tokenizer.decode(outputs[0]))
+```
+
+</hfoption>
+<hfoption id="ad copy">
+
+```py
+device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+messages = [
+    {"role": "system", "content": "Create a text ad given the following product and description."},
+    {"role": "user", "content": "Product: Sony PS5 PlayStation Console\nDescription: The PS5 console unleashes new gaming possibilities that you never anticipated."},
+]
+text = tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False)
+inputs = tokenizer(text, return_tensors="pt")
+inputs = {k: v.to(device) for k, v in inputs.items()}
+outputs = model.generate(**inputs, max_new_tokens=128, do_sample=True, top_p=0.95, temperature=0.2, repetition_penalty=1.2, eos_token_id=tokenizer.eos_token_id)
+print(tokenizer.decode(outputs[0]))
+```
+
+</hfoption>
+<hfoption id="SQL">
+
+```py
+device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+
+text = """Table: 2-11365528-2
+Columns: ['Team', 'Head Coach', 'President', 'Home Ground', 'Location']
+Natural Query: Who is the Head Coach of the team whose President is Mario Volarevic?
+SQL Query:"""
+
+inputs = tokenizer(text, return_tensors="pt")
+inputs = {k: v.to(device) for k, v in inputs.items()}
+outputs = model.generate(**inputs, max_new_tokens=64, repetition_penalty=1.1, eos_token_id=tokenizer("</s>").input_ids[-1])
+print(tokenizer.decode(outputs[0]))
+```
+
+</hfoption>
+</hfoptions>
+
+
+## Merging (IA)³ Models
+The (IA)³ models facilitate linear merging of adapters. To merge adapters in an (IA)³ model, utilize the `add_weighted_adapter` method from the `IA3Model` class. This method is analogous to the `add_weighted_adapter` method used in `LoraModel`, with the key difference being the absence of the `combination_type` parameter. For example, to merge three (IA)³ adapters into a PEFT model, you would proceed as follows:
+
+```py
+adapters = ["adapter1", "adapter2", "adapter3"]
+weights = [0.4, 0.3, 0.3]
+adapter_name = "merge"
+model.add_weighted_adapter(adapters, weights, adapter_name)
+```
+
+It is recommended that the weights sum to 1.0 to preserve the scale of the model. The merged model can then be set as the active model using the `set_adapter` method:
+
+```py
+model.set_adapter("merge")
+```
diff --git a/docs/source/developer_guides/quantization.md b/docs/source/developer_guides/quantization.md
new file mode 100644
index 0000000..e6f75d7
--- /dev/null
+++ b/docs/source/developer_guides/quantization.md
@@ -0,0 +1,356 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# Quantization
+
+Quantization represents data with fewer bits, making it a useful technique for reducing memory-usage and accelerating inference especially when it comes to large language models (LLMs). There are several ways to quantize a model including:
+
+* optimizing which model weights are quantized with the [AWQ](https://hf.co/papers/2306.00978) algorithm
+* independently quantizing each row of a weight matrix with the [GPTQ](https://hf.co/papers/2210.17323) algorithm
+* quantizing to 8-bit and 4-bit precision with the [bitsandbytes](https://github.com/TimDettmers/bitsandbytes) library
+* quantizing to as low as 2-bit precision with the [AQLM](https://huggingface.co/papers/2401.06118) algorithm
+
+However, after a model is quantized it isn't typically further trained for downstream tasks because training can be unstable due to the lower precision of the weights and activations. But since PEFT methods only add *extra* trainable parameters, this allows you to train a quantized model with a PEFT adapter on top! Combining quantization with PEFT can be a good strategy for training even the largest models on a single GPU. For example, [QLoRA](https://hf.co/papers/2305.14314) is a method that quantizes a model to 4-bits and then trains it with LoRA. This method allows you to finetune a 65B parameter model on a single 48GB GPU!
+
+In this guide, you'll see how to quantize a model to 4-bits and train it with LoRA.
+
+## Quantize a model
+
+[bitsandbytes](https://github.com/TimDettmers/bitsandbytes) is a quantization library with a Transformers integration. With this integration, you can quantize a model to 8 or 4-bits and enable many other options by configuring the [`~transformers.BitsAndBytesConfig`] class. For example, you can:
+
+* set `load_in_4bit=True` to quantize the model to 4-bits when you load it
+* set `bnb_4bit_quant_type="nf4"` to use a special 4-bit data type for weights initialized from a normal distribution
+* set `bnb_4bit_use_double_quant=True` to use a nested quantization scheme to quantize the already quantized weights
+* set `bnb_4bit_compute_dtype=torch.bfloat16` to use bfloat16 for faster computation
+
+```py
+import torch
+from transformers import BitsAndBytesConfig
+
+config = BitsAndBytesConfig(
+    load_in_4bit=True,
+    bnb_4bit_quant_type="nf4",
+    bnb_4bit_use_double_quant=True,
+    bnb_4bit_compute_dtype=torch.bfloat16,
+)
+```
+
+Pass the `config` to the [`~transformers.AutoModelForCausalLM.from_pretrained`] method.
+
+```py
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-v0.1", quantization_config=config)
+```
+
+Next, you should call the [`~peft.utils.prepare_model_for_kbit_training`] function to preprocess the quantized model for training.
+
+```py
+from peft import prepare_model_for_kbit_training
+
+model = prepare_model_for_kbit_training(model)
+```
+
+Now that the quantized model is ready, let's set up a configuration.
+
+## LoraConfig
+
+Create a [`LoraConfig`] with the following parameters (or choose your own):
+
+```py
+from peft import LoraConfig
+
+config = LoraConfig(
+    r=16,
+    lora_alpha=8,
+    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
+    lora_dropout=0.05,
+    bias="none",
+    task_type="CAUSAL_LM"
+)
+```
+
+Then use the [`get_peft_model`] function to create a [`PeftModel`] from the quantized model and configuration.
+
+```py
+from peft import get_peft_model
+
+model = get_peft_model(model, config)
+```
+
+You're all set for training with whichever training method you prefer!
+
+### LoftQ initialization
+
+[LoftQ](https://hf.co/papers/2310.08659) initializes LoRA weights such that the quantization error is minimized, and it can improve performance when training quantized models. To get started, follow [these instructions](https://github.com/huggingface/peft/tree/main/examples/loftq_finetuning).
+
+In general, for LoftQ to work best, it is recommended to target as many layers with LoRA as possible, since those not targeted cannot have LoftQ applied. This means that passing `LoraConfig(..., target_modules="all-linear")` will most likely give the best results. Also, you should use `nf4` as quant type in your quantization config when using 4bit quantization, i.e. `BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type="nf4")`.
+
+In general, for LoftQ to work best, it is recommended to target as many layers with LoRA as possible, since those not targeted cannot have LoftQ applied. This means that passing `LoraConfig(..., target_modules="all-linear")` will most likely give the best results. Also, you should use `nf4` as quant type in your quantization config when using 4bit quantization, i.e. `BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type="nf4")`.
+
+There are currently two intended ways of applying LoftQ:
+
+1. load the non-quantized base model, apply LoftQ with your intended quantization level (e.g., `bits=4` for nf4) and
+   save the resulting adapter. Then quantize the base model using, for example,
+   `BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type="nf4")` and load the LoftQ-initialized adapter on top
+2. load the quantized base model, initialize a PEFT model with LoRA (no loftq) and use `replace_lora_weights_loftq` to
+   apply LoftQ initialization by streaming the reference weights of the non-quantized base model from the weights file
+   (explained further in the next section)
+
+#### Using `replace_lora_weights_loftq` for on-the-fly LoftQ application
+
+An easier but more limited way to apply LoftQ initialization is to use the convenience function `replace_lora_weights_loftq`. This takes the quantized PEFT model as input and replaces the LoRA weights in-place with their LoftQ-initialized counterparts.
+
+```python
+from peft import replace_lora_weights_loftq
+from transformers import BitsAndBytesConfig
+
+bnb_config = BitsAndBytesConfig(load_in_4bit=True, ...)
+base_model = AutoModelForCausalLM.from_pretrained(..., quantization_config=bnb_config)
+# note: don't pass init_lora_weights="loftq" or loftq_config!
+lora_config = LoraConfig(task_type="CAUSAL_LM")
+peft_model = get_peft_model(base_model, lora_config)
+replace_lora_weights_loftq(peft_model)
+```
+
+`replace_lora_weights_loftq` also allows you to pass a `callback` argument to give you more control over which layers should be modified or not, which empirically can improve the results quite a lot. To see a more elaborate example of this, check out [this notebook](https://github.com/huggingface/peft/blob/main/examples/loftq_finetuning/LoftQ_weight_replacement.ipynb).
+
+`replace_lora_weights_loftq` implements only one iteration step of LoftQ. This means that only the LoRA weights are updated, instead of iteratively updating LoRA weights and quantized base model weights. This may lead to lower performance but has the advantage that we can use the original quantized weights derived from the base model, instead of having to keep an extra copy of modified quantized weights. Whether this tradeoff is worthwhile depends on the use case.
+
+At the moment, `replace_lora_weights_loftq` has these additional limitations:
+
+- Model files must be stored as a `safetensors` file.
+- Only bitsandbytes 4bit quantization is supported.
+
+### QLoRA-style training
+
+QLoRA adds trainable weights to all the linear layers in the transformer architecture. Since the attribute names for these linear layers can vary across architectures, set `target_modules` to `"all-linear"` to add LoRA to all the linear layers:
+
+```py
+config = LoraConfig(target_modules="all-linear", ...)
+```
+
+## GPTQ quantization
+
+You can learn more about GPTQ-based `[2, 3, 4, 8]` bit quantization at [GPT-QModel](https://github.com/ModelCloud/GPTQModel) and in the Transformers [GPTQ](https://huggingface.co/docs/transformers/quantization/gptq) documentation. PEFT supports GPTQ post-training through GPT-QModel.
+
+```bash
+# GPT-QModel install
+pip install "gptqmodel>=7.0.0"
+```
+
+```py
+from transformers import AutoModelForCausalLM, AutoTokenizer, GPTQConfig
+
+model_id = "facebook/opt-125m"
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+gptq_config = GPTQConfig(bits=4, group_size=128, dataset="wikitext2", tokenizer=tokenizer)
+
+quantized_model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto", quantization_config=gptq_config)
+
+# save quantized model
+quantized_model.save_pretrained("./opt-125m-gptq")
+tokenizer.save_pretrained("./opt-125m-gptq")
+```
+
+Once quantized, you can post-train GPTQ models with PEFT APIs.
+
+## AQLM quantization
+
+Additive Quantization of Language Models ([AQLM](https://huggingface.co/papers/2401.06118)) is a Large Language Models compression method. It quantizes multiple weights together and takes advantage of interdependencies between them. AQLM represents groups of 8-16 weights as a sum of multiple vector codes. This allows it to compress models down to as low as 2-bit with considerably low accuracy losses.
+
+Since the AQLM quantization process is computationally expensive, the use of prequantized models is recommended. A partial list of available models can be found in the official aqlm [repository](https://github.com/Vahe1994/AQLM).
+
+The models support LoRA adapter tuning. To tune the quantized model you'll need to install the `aqlm` inference library: `pip install aqlm>=1.0.2`. Finetuned LoRA adapters shall be saved separately, as merging them with AQLM quantized weights is not possible.
+
+```py
+quantized_model = AutoModelForCausalLM.from_pretrained(
+    "BlackSamorez/Mixtral-8x7b-AQLM-2Bit-1x16-hf-test-dispatch",
+    dtype="auto", device_map="auto", low_cpu_mem_usage=True,
+)
+
+peft_config = LoraConfig(...)
+
+quantized_model = get_peft_model(quantized_model, peft_config)
+```
+
+You can refer to the [Google Colab](https://colab.research.google.com/drive/12GTp1FCj5_0SnnNQH18h_2XFh9vS_guX?usp=sharing) example for an overview of AQLM+LoRA finetuning.
+
+## EETQ quantization
+
+You can also perform LoRA fine-tuning on EETQ quantized models. [EETQ](https://github.com/NetEase-FuXi/EETQ) package offers simple and efficient way to perform 8-bit quantization, which is claimed to be faster than the `LLM.int8()` algorithm. First, make sure that you have a transformers version that is compatible with EETQ (e.g. by installing it from latest pypi or from source).
+
+```py
+import torch
+from transformers import EetqConfig
+
+config = EetqConfig("int8")
+```
+
+Pass the `config` to the [`~transformers.AutoModelForCausalLM.from_pretrained`] method.
+
+```py
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-v0.1", quantization_config=config)
+```
+
+and create a `LoraConfig` and pass it to `get_peft_model`:
+
+```py
+from peft import LoraConfig, get_peft_model
+
+config = LoraConfig(
+    r=16,
+    lora_alpha=8,
+    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
+    lora_dropout=0.05,
+    bias="none",
+    task_type="CAUSAL_LM"
+)
+
+model = get_peft_model(model, config)
+```
+
+## HQQ quantization
+
+The models that are quantized using Half-Quadratic Quantization of Large Machine Learning Models ([HQQ](https://mobiusml.github.io/hqq_blog/)) support LoRA adapter tuning. To tune the quantized model, you'll need to install the `hqq` library with: `pip install hqq`.
+
+```python
+from hqq.engine.hf import HQQModelForCausalLM
+
+device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+
+quantized_model = HQQModelForCausalLM.from_quantized(save_dir_or_hfhub, device=device)
+peft_config = LoraConfig(...)
+quantized_model = get_peft_model(quantized_model, peft_config)
+```
+
+Or using transformers version that is compatible with HQQ (e.g. by installing it from latest pypi or from source).
+
+```python
+from transformers import HqqConfig, AutoModelForCausalLM
+
+quant_config = HqqConfig(nbits=4, group_size=64)
+quantized_model = AutoModelForCausalLM.from_pretrained(save_dir_or_hfhub, device_map=device_map, quantization_config=quant_config)
+peft_config = LoraConfig(...)
+quantized_model = get_peft_model(quantized_model, peft_config)
+```
+
+## torchao (PyTorch Architecture Optimization)
+
+PEFT supports models quantized with [torchao](https://github.com/pytorch/ao) ("ao") for int8 quantization.
+
+```python
+from peft import LoraConfig, get_peft_model
+from transformers import AutoModelForCausalLM, TorchAoConfig
+from torchao.quantization import Int8WeightOnlyConfig
+
+model_id = ...
+quantization_config = TorchAoConfig(quant_type=Int8WeightOnlyConfig())
+base_model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=quantization_config)
+peft_config = LoraConfig(...)
+model = get_peft_model(base_model, peft_config)
+```
+
+### Caveats:
+
+- Use the most recent versions of torchao (>= v0.4.0) and transformers (> 4.42).
+- Only linear layers are currently supported.
+- `quant_type = "int4_weight_only"` is currently not supported.
+- `NF4` is not implemented in transformers as of yet and is thus also not supported.
+- DoRA only works with `quant_type = "int8_weight_only"` at the moment.
+- There is explicit support for torchao when used with LoRA. However, when torchao quantizes a layer, its class does not change, only the type of the underlying tensor. For this reason, PEFT methods other than LoRA will generally also work with torchao, even if not explicitly supported. Be aware, however, that **merging only works correctly with LoRA and with `quant_type = "int8_weight_only"`**. If you use a different PEFT method or dtype, merging will likely result in an error, and even it doesn't, the results will still be incorrect.
+
+## INC quantization
+
+Intel Neural Compressor ([INC](https://github.com/intel/neural-compressor)) enables model quantization for various devices,
+including Intel Gaudi accelerators (also known as HPU devices). You can perform LoRA fine-tuning on models that have been
+quantized using INC. To use INC with PyTorch models, install the library with: `pip install neural-compressor[pt]`.
+Quantizing a model to FP8 precision for HPU devices can be done with the following single-step quantization workflow:
+
+```python
+import torch
+from neural_compressor.torch.quantization import FP8Config, convert, finalize_calibration, prepare
+quant_configs = {
+    ...
+}
+config = FP8Config(**quant_configs)
+```
+
+Pass the config to the `prepare` method, run inference to gather calibration stats, and call `finalize_calibration`
+and `convert` methods to quantize model to FP8 precision:
+
+```python
+model = prepare(model, config)
+# Run inference to collect calibration statistics
+...
+# Finalize calibration and convert the model to FP8 precision
+finalize_calibration(model)
+model = convert(model)
+# Load PEFT LoRA adapter as usual
+...
+```
+
+An example demonstrating how to load a PEFT LoRA adapter into an INC-quantized FLUX text-to-image model for HPU
+devices is provided [here](https://github.com/huggingface/peft/blob/main/examples/stable_diffusion/inc_flux_lora_hpu.py).
+
+
+### Caveats:
+
+- `merge()` and `unmerge()` methods are currently not supported for INC-quantized models.
+- Currently, only **Linear** INC-quantized layers are supported when loading PEFT adapters.
+
+## Other Supported PEFT Methods
+
+Besides LoRA, the following PEFT methods also support quantization:
+
+- **VeRA** (supports bitsandbytes quantization)
+- **AdaLoRA** (supports both bitsandbytes and GPTQ quantization)
+- **(IA)³** (supports bitsandbytes quantization)
+
+## Transformer Engine (TE) LoRA
+
+PEFT supports LoRA adapters on top of [NVIDIA Transformer Engine](https://docs.nvidia.com/deeplearning/transformer-engine/) layers (`te.pytorch.Linear`, `te.pytorch.LayerNormLinear`, and `te.pytorch.LayerNormMLP`). TE layers use FP8 and fused kernels to accelerate transformer training, and attaching LoRA adapters lets you parameter-efficiently fine-tune TE-accelerated models.
+
+```python
+from peft import LoraConfig, get_peft_model
+
+config = LoraConfig(
+    r=8,
+    lora_alpha=16,
+    target_modules=["q_proj", "v_proj"],
+    task_type="TOKEN_CLS",
+)
+model = get_peft_model(te_model, config)
+```
+
+When Transformer Engine is installed, PEFT automatically dispatches matching layers to the `TeLinear` adapter — no extra configuration is needed.
+
+### Caveats
+
+- `merge()` and `unmerge()` are not yet supported for TE layers.
+- DoRA is not supported with TE layers.
+
+A complete ESM2 token-classification example is available under `examples/lora_finetuning_transformer_engine/`.
+
+## Next steps
+
+If you're interested in learning more about quantization, the following may be helpful:
+
+* Learn more details about QLoRA and check out some benchmarks on its impact in the [Making LLMs even more accessible with bitsandbytes, 4-bit quantization and QLoRA](https://huggingface.co/blog/4bit-transformers-bitsandbytes) blog post.
+* Read more about different quantization schemes in the Transformers [Quantization](https://hf.co/docs/transformers/main/quantization) guide.
diff --git a/docs/source/developer_guides/torch_compile.md b/docs/source/developer_guides/torch_compile.md
new file mode 100644
index 0000000..eadfe99
--- /dev/null
+++ b/docs/source/developer_guides/torch_compile.md
@@ -0,0 +1,70 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# torch.compile
+
+In PEFT, [torch.compile](https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html) works for some but not all features. The reason why it won't always work is because PEFT is highly dynamic in certain places (loading and switching between multiple adapters, for instance), which can cause trouble for `torch.compile`. In other places, `torch.compile` may work, but won't be as fast as expected because of graph breaks.
+
+If you don't see an error, it doesn't necessarily mean that `torch.compile` worked correctly. It might give you an output, but the output is incorrect. This guide describes what works with `torch.compile` and what doesn't. For your own testing, we recommend using the latest PyTorch version, as `torch.compile` is constantly being improved.
+
+> [!TIP]
+> Unless indicated otherwise, the default `torch.compile` settings were used.
+
+## Training and inference with `torch.compile`
+
+These features **work** with `torch.compile`. Everything listed below was tested with a causal LM:
+
+- Training with `Trainer` from 🤗 transformers
+- Training with a custom PyTorch loop
+- Inference
+- Generation
+
+The following adapters were tested successfully:
+
+- AdaLoRA
+- BOFT
+- IA³
+- Layer Norm Tuning
+- LoHa
+- LoKr
+- LoRA
+- LoRA + DoRA
+- LoRA applied to embedding layers
+- OFT
+- VeRA
+- HRA
+
+## Advanced PEFT features with `torch.compile`
+
+Below are some of the more advanced PEFT features that **work**. They were all tested with LoRA.
+
+- `modules_to_save` (i.e. `config = LoraConfig(..., modules_to_save=...)`)
+- Merging adapters (one or multiple)
+- Merging multiple adapters into one adapter (i.e. calling `model.add_weighted_adapter(...)`)
+- Using PEFT adapters with quantization (bitsandbytes)
+- Disabling adapters (i.e. using `with model.disable_adapter()`)
+- Unloading (i.e. calling `model.merge_and_unload()`)
+- Mixed adapter batches (i.e. calling `model(batch, adapter_names=["__base__", "default", "other", ...])`)
+- Inference with multiple adapters (i.e. using `model.add_adapter` or `model.load_adapter` to load more than 1 adapter); for this, only call `torch.compile` _after_ loading all adapters
+
+Generally, we can expect that if a feature works correctly with LoRA and is also supported by other adapter types, it should also work for that adapter type.
+
+## Test cases
+
+All the use cases listed above are tested inside of [`peft/tests/test_torch_compile.py`](https://github.com/huggingface/peft/blob/main/tests/test_torch_compile.py). If you want to check in more detail how we tested a certain feature, please go to that file and check the test that corresponds to your use case.
+
+> [!TIP]
+> If you have another use case where you know that `torch.compile` does or does not work with PEFT, please contribute by letting us know or by opening a PR to add this use case to the covered test cases.
diff --git a/docs/source/developer_guides/troubleshooting.md b/docs/source/developer_guides/troubleshooting.md
new file mode 100644
index 0000000..d56dea4
--- /dev/null
+++ b/docs/source/developer_guides/troubleshooting.md
@@ -0,0 +1,458 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# Troubleshooting
+
+If you encounter any issue when using PEFT, please check the following list of common issues and their solutions.
+
+## Examples don't work
+
+Examples often rely on the most recent package versions, so please ensure they're up-to-date. In particular, check the following package versions:
+
+- `peft`
+- `transformers`
+- `accelerate`
+- `torch`
+
+In general, you can update the package version by running this command inside your Python environment:
+
+```bash
+python -m pip install -U <package_name>
+```
+
+Installing PEFT from source is useful for keeping up with the latest developments:
+
+```bash
+python -m pip install git+https://github.com/huggingface/peft
+```
+
+## Dtype-related issues
+
+### ValueError: Attempting to unscale FP16 gradients
+
+This error probably occurred because the model was loaded with `dtype=torch.float16` and then used in an automatic mixed precision (AMP) context, e.g. by setting `fp16=True` in the [`~transformers.Trainer`] class from 🤗 Transformers. The reason is that when using AMP, trainable weights should never use fp16. To make this work without loading the whole model in fp32, add the following to your code:
+
+```python
+peft_model = get_peft_model(...)
+
+# add this:
+for param in model.parameters():
+    if param.requires_grad:
+        param.data = param.data.float()
+
+# proceed as usual
+trainer = Trainer(model=peft_model, fp16=True, ...)
+trainer.train()
+```
+
+Alternatively, you can use the [`~utils.cast_mixed_precision_params`] function to correctly cast the weights:
+
+```python
+from peft import cast_mixed_precision_params
+
+peft_model = get_peft_model(...)
+cast_mixed_precision_params(peft_model, dtype=torch.float16)
+
+# proceed as usual
+trainer = Trainer(model=peft_model, fp16=True, ...)
+trainer.train()
+```
+
+> [!TIP]
+> Starting from PEFT version v0.12.0, PEFT automatically promotes the dtype of adapter weights from `torch.float16` and `torch.bfloat16` to `torch.float32` where appropriate. To _prevent_ this behavior, you can pass `autocast_adapter_dtype=False` to [`~get_peft_model`], to [`~PeftModel.from_pretrained`], and to [`~PeftModel.load_adapter`].
+
+### Selecting the dtype of the adapter
+
+Most PEFT methods, like LoRA, work by adding trainable adapter weights. By default, those weights are stored in float32 dtype (fp32), i.e. at a relatively high precision. Therefore, even if the base model is loaded in float16 (fp16) or bfloat16 (bf16), the adapter weights are float32. When the adapter results are calculated during the forward pass, the input will typically be in the dtype of the base model, thus it will be upcast to float32 if necessary, then cast back to the original dtype.
+
+If you prefer to have the adapter weights in the lower precision of the base model, i.e. in float16 or bfloat16, you can pass `autocast_adapter_dtype=False` when creating the model ([`~get_peft_model`]) or loading the model ([`~PeftModel.from_pretrained`]). There are some advantages and disadvantages to this:
+
+Advantages of half precision adapter:
+- computation slightly faster
+- slightly less memory
+- smaller file size of checkpoint (half the size)
+
+Disadvantages of half precision adapter:
+- slightly worse loss
+- higher risk of overflow or underflow
+
+Note that for most use cases, overall runtime and memory cost will be determined by the size of the base model and by the dataset, while the dtype of the PEFT adapter will only have a small impact.
+
+## Bad results from a loaded PEFT model
+
+There can be several reasons for getting a poor result from a loaded PEFT model which are listed below. If you're still unable to troubleshoot the problem, see if anyone else had a similar [issue](https://github.com/huggingface/peft/issues) on GitHub, and if you can't find any, open a new issue.
+
+When opening an issue, it helps a lot if you provide a minimal code example that reproduces the issue. Also, please report if the loaded model performs at the same level as the model did before fine-tuning, if it performs at a random level, or if it is only slightly worse than expected. This information helps us identify the problem more quickly.
+
+### Random deviations
+
+If your model outputs are not exactly the same as previous runs, there could be an issue with random elements. For example:
+
+1. please ensure it is in `.eval()` mode, which is important, for instance, if the model uses dropout
+2. if you use [`~transformers.GenerationMixin.generate`] on a language model, there could be random sampling, so obtaining the same result requires setting a random seed
+3. if you used quantization and merged the weights, small deviations are expected due to rounding errors
+
+### Incorrectly loaded model
+
+Please ensure that you load the model correctly. A common error is trying to load a _trained_ model with [`get_peft_model`] which is incorrect. Instead, the loading code should look like this:
+
+```python
+from peft import PeftModel, PeftConfig
+
+base_model = ...  # to load the base model, use the same code as when you trained it
+config = PeftConfig.from_pretrained(peft_model_id)
+peft_model = PeftModel.from_pretrained(base_model, peft_model_id)
+```
+
+### Randomly initialized layers
+
+For some tasks, it is important to correctly configure `modules_to_save` in the config to account for randomly initialized layers.
+
+As an example, this is necessary if you use LoRA to fine-tune a language model for sequence classification because 🤗 Transformers adds a randomly initialized classification head on top of the model. If you do not add this layer to `modules_to_save`, the classification head won't be saved. The next time you load the model, you'll get a _different_ randomly initialized classification head, resulting in completely different results.
+
+PEFT tries to correctly guess the `modules_to_save` if you provide the `task_type` argument in the config. This should work for transformers models that follow the standard naming scheme. It is always a good idea to double check though because we can't guarantee all models follow the naming scheme.
+
+When you load a transformers model that has randomly initialized layers, you should see a warning along the lines of:
+
+```
+Some weights of <MODEL> were not initialized from the model checkpoint at <ID> and are newly initialized: [<LAYER_NAMES>].
+You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.
+```
+
+The mentioned layers should be added to `modules_to_save` in the config to avoid the described problem.
+
+> [!TIP]
+> As an example, when loading a model that is using the DeBERTa architecture for sequence classification, you'll see a warning that the following weights are newly initialized: `['classifier.bias', 'classifier.weight', 'pooler.dense.bias', 'pooler.dense.weight']`. From this, it follows that the `classifier` and `pooler` layers should be added to: `modules_to_save=["classifier", "pooler"]`.
+
+### Extending the vocabulary
+
+For many language fine-tuning tasks, extending the model's vocabulary is necessary since new tokens are being introduced. This requires extending the embedding layer to account for the new tokens and, depending on the fine-tuning method, also storing the embedding layer in addition to the adapter weights when saving the adapter. There are a few ways of achieving this ordered by parameter effectiveness:
+
+- [trainable tokens](../package_reference/trainable_tokens), train only the specified tokens, optionally store only the updated values
+- training an adapter on the embedding matrix, optionally store only the updated values
+- full-finetuning of the embedding layer
+
+#### Using trainable tokens
+
+Let's start with trainable tokens, in this case its [LoRA integration](../package_reference/lora#efficiently-train-tokens-alongside-lora).  If you're interested in only training the new embeddings and nothing else, refer to the [standalone documentation](../package_reference/trainable_tokens).
+
+To enable selective token training of the embedding layer, you'll need to supply the token ids of your newly added tokens via the `trainable_token_indices` parameter.  Optionally you can specify which layer to target if there is more than one embedding layer. For a Mistral model this could look like this:
+
+```python
+new_tokens = ['<think>', '</think>']
+tokenizer.add_tokens(new_tokens)
+base_model.resize_token_embeddings(len(tokenizer))
+
+lora_config = LoraConfig(
+    ...,
+    trainable_token_indices={'embed_tokens': tokenizer.convert_tokens_to_ids(new_tokens)},
+)
+```
+
+If your model uses tied weights (such as the `lm_head`), trainable tokens will try to resolve those and keep them updated as well, so in that case there should be no need for adding `modules_to_save=["lm_head"]`. This only works if the model uses the Transformers convention for tying weights.
+
+Saving the model with `model.save_pretrained` may save the full embedding matrix instead of
+only the difference as a precaution because the embedding matrix was resized. To save space you can disable this behavior by setting `save_embedding_layers=False` when calling `save_pretrained`. This is safe to do as long as you don't modify the embedding matrix through other means as well, as such changes will be not tracked by trainable tokens.
+
+#### Using an adapter, e.g. LoRA
+
+Prepare the embedding layer by adding it to the `target_modules` of your adapter config. For example, the Mistral config could look like this:
+
+```python
+config = LoraConfig(..., target_modules=["embed_tokens", "lm_head", "q_proj", "v_proj"])
+```
+
+Once added to `target_modules`, PEFT automatically stores the embedding layer when saving the adapter if the model has the [`~transformers.PreTrainedModel.get_input_embeddings`] and [`~transformers.PreTrainedModel.get_output_embeddings`]. This is generally the case for Transformers models.
+
+If the model's embedding layer doesn't follow the Transformer's naming scheme but nevertheless implements `get_input_embeddings`, you can still save it by manually passing `save_embedding_layers=True` when saving the adapter:
+
+```python
+model = get_peft_model(...)
+# train the model
+model.save_pretrained("my_adapter", save_embedding_layers=True)
+```
+
+For inference, load the base model first and resize it the same way you did before you trained the model. After you've resized the base model, you can load the PEFT checkpoint.
+
+For a complete example, please check out [this notebook](https://github.com/huggingface/peft/blob/main/examples/causal_language_modeling/peft_lora_clm_with_additional_tokens.ipynb).
+
+#### Full fine-tuning
+
+Full fine-tuning is more costly in terms of VRAM or storage space but if all else fails, you can fall back to this and see if it works for you. Achieve it by adding the name of the embedding layer to `modules_to_save`. Note that you need to add tied layers as well, e.g. `lm_head`. Example for a Mistral model with LoRA:
+
+```python
+config = LoraConfig(..., modules_to_save=["embed_tokens", "lm_head"], target_modules=["q_proj", "v_proj"])
+```
+
+### Getting a warning about "weights not being initialized from the model checkpoint"
+
+When you load your PEFT model which has been trained on a task (for example, classification), you may get a warning like:
+
+> Some weights of LlamaForSequenceClassification were not initialized from the model checkpoint at meta-llama/Llama-3.2-1B and are newly initialized: ['score.weight']. You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.
+
+Although this looks scary, it is most likely nothing to worry about. This warning comes from Transformers, and it isn't a PEFT specific warning. It lets you know that a randomly initialized classification head (`score`) is attached to the base model, and the head must be trained to produce sensible predictions.
+
+When you get this warning _before_ training the model, PEFT automatically takes care of making the classification head trainable if you correctly passed the `task_type` argument to the PEFT config.
+
+```python
+from peft import LoraConfig, TaskType
+
+lora_config = LoraConfig(..., task_type=TaskType.SEQ_CLS)
+```
+
+If your classification head does not follow the usual naming conventions from Transformers (which is rare), you have to explicitly tell PEFT the name of the head in `modules_to_save`.
+
+```python
+lora_config = LoraConfig(..., modules_to_save=["name-of-classification-head"])
+```
+
+To check the name of the classification head, print the model and it should be the last module.
+
+If you get this warning from your inference code, i.e. _after_ training the model, when you load the PEFT model, you always have to load the Transformers model first. Since Transformers does not know that you will load PEFT weights afterwards, it still gives the warning.
+
+As always, it is best practice to ensure the model works correctly for inference by running some validation on it.
+
+### Check layer and model status
+
+Sometimes a PEFT model can end up in a bad state, especially when handling multiple adapters. There can be some confusion around what adapters exist, which one is active, which one is merged, etc. To help investigate this issue, call the [`~peft.PeftModel.get_layer_status`] and the [`~peft.PeftModel.get_model_status`] methods.
+
+The [`~peft.PeftModel.get_layer_status`] method gives you a detailed overview of each targeted layer's active, merged, and available adapters.
+
+```python
+>>> from transformers import AutoModel
+>>> from peft import get_peft_model, LoraConfig
+
+>>> model_id = "google/flan-t5-small"
+>>> model = AutoModel.from_pretrained(model_id)
+>>> model = get_peft_model(model, LoraConfig())
+
+>>> model.get_layer_status()
+[TunerLayerStatus(name='model.encoder.block.0.layer.0.SelfAttention.q',
+                  module_type='lora.Linear',
+                  enabled=True,
+                  active_adapters=['default'],
+                  merged_adapters=[],
+                  requires_grad={'default': True},
+                  available_adapters=['default']),
+ TunerLayerStatus(name='model.encoder.block.0.layer.0.SelfAttention.v',
+                  module_type='lora.Linear',
+                  enabled=True,
+                  active_adapters=['default'],
+                  merged_adapters=[],
+                  requires_grad={'default': True},
+                  available_adapters=['default']),
+...]
+
+>>> model.get_model_status()
+TunerModelStatus(
+    base_model_type='T5Model',
+    adapter_model_type='LoraModel',
+    peft_types={'default': 'LORA'},
+    trainable_params=344064,
+    total_params=60855680,
+    num_adapter_layers=48,
+    enabled=True,
+    active_adapters=['default'],
+    merged_adapters=[],
+    requires_grad={'default': True},
+    available_adapters=['default'],
+)
+```
+
+In the model state output, you should look out for entries that say `"irregular"`. This means PEFT detected an inconsistent state in the model. For instance, if `merged_adapters="irregular"`, it means that for at least one adapter, it was merged on some target modules but not on others. The inference results will most likely be incorrect as a result.
+
+The best way to resolve this issue is to reload the whole model and adapter checkpoint(s). Ensure that you don't perform any incorrect operations on the model, e.g. manually merging adapters on some modules but not others.
+
+Convert the layer status into a pandas `DataFrame` for an easier visual inspection.
+
+```python
+from dataclasses import asdict
+import pandas as pd
+
+df = pd.DataFrame(asdict(layer) for layer in model.get_layer_status())
+```
+
+It is possible to get this information for non-PEFT models if they are using PEFT layers under the hood, but some information like the `base_model_type` or the `peft_types` cannot be determined in that case. As an example, you can call this on a [diffusers](https://huggingface.co/docs/diffusers/index) model like so:
+
+```python
+>>> import torch
+>>> from diffusers import StableDiffusionPipeline
+>>> from peft import get_model_status, get_layer_status
+
+>>> path = "runwayml/stable-diffusion-v1-5"
+>>> lora_id = "takuma104/lora-test-text-encoder-lora-target"
+>>> pipe = StableDiffusionPipeline.from_pretrained(path, dtype=torch.float16)
+>>> pipe.load_lora_weights(lora_id, adapter_name="adapter-1")
+>>> pipe.load_lora_weights(lora_id, adapter_name="adapter-2")
+>>> pipe.set_lora_device(["adapter-2"], "cuda")
+>>> get_layer_status(pipe.text_encoder)
+[TunerLayerStatus(name='text_model.encoder.layers.0.self_attn.k_proj',
+                  module_type='lora.Linear',
+                  enabled=True,
+                  active_adapters=['adapter-2'],
+                  merged_adapters=[],
+                  requires_grad={'adapter-1': False, 'adapter-2': True},
+                  available_adapters=['adapter-1', 'adapter-2'],
+                  devices={'adapter-1': ['cpu'], 'adapter-2': ['cuda']}),
+ TunerLayerStatus(name='text_model.encoder.layers.0.self_attn.v_proj',
+                  module_type='lora.Linear',
+                  enabled=True,
+                  active_adapters=['adapter-2'],
+                  merged_adapters=[],
+                  requires_grad={'adapter-1': False, 'adapter-2': True},
+                  devices={'adapter-1': ['cpu'], 'adapter-2': ['cuda']}),
+...]
+
+>>> get_model_status(pipe.unet)
+TunerModelStatus(
+    base_model_type='other',
+    adapter_model_type='None',
+    peft_types={},
+    trainable_params=797184,
+    total_params=861115332,
+    num_adapter_layers=128,
+    enabled=True,
+    active_adapters=['adapter-2'],
+    merged_adapters=[],
+    requires_grad={'adapter-1': False, 'adapter-2': True},
+    available_adapters=['adapter-1', 'adapter-2'],
+    devices={'adapter-1': ['cpu'], 'adapter-2': ['cuda']},
+)
+```
+
+## Speed
+
+### Loading adapter weights is slow
+
+Loading adapters like LoRA weights should generally be fast compared to loading the base model. However, there can be use cases where the adapter weights are quite large or where users need to load a large number of adapters -- the loading time can add up in this case. The reason for this is that the adapter weights are first initialized and then overridden by the loaded weights, which is wasteful. To speed up the loading time, you can pass the `low_cpu_mem_usage=True` argument to [`~PeftModel.from_pretrained`] and [`~PeftModel.load_adapter`].
+
+> [!TIP]
+> If this option works well across different use cases, it may become the default for adapter loading in the future.
+
+
+## Reproducibility
+
+### Models using batch norm
+
+When loading a trained PEFT model where the base model uses batch norm (e.g. `torch.nn.BatchNorm1d` or `torch.nn.BatchNorm2d`), you may find that you cannot reproduce the exact same outputs. This is because the batch norm layers keep track of running stats during training, but these stats are not part of the PEFT checkpoint. Therefore, when you load the PEFT model, the running stats of the base model will be used (i.e. from before training with PEFT).
+
+Depending on your use case, this may not be a big deal. If, however, you need your outputs to be 100% reproducible, you can achieve this by adding the batch norm layers to `modules_to_save`. Below is an example of this using resnet and LoRA. Notice that we set `modules_to_save=["classifier", "normalization"]`. We need the `"classifier"` argument because our task is image classification, and we add the `"normalization"` argument to ensure that the batch norm layers are saved in the PEFT checkpoint.
+
+```python
+from transformers import AutoModelForImageClassification
+from peft import LoraConfig, get_peft_model
+
+model_id = "microsoft/resnet-18"
+base_model = AutoModelForImageClassification.from_pretrained(self.model_id)
+config = LoraConfig(
+    target_modules=["convolution"],
+    modules_to_save=["classifier", "normalization"],
+),
+```
+
+Depending on the type of model you use, the batch norm layers could have different names than `"normalization"`, so please ensure that the name matches your model architecture.
+
+## Version mismatch
+
+### Error while loading the config because of an unexpected keyword argument
+
+When you encounter an error like the one shown below, it means the adapter you're trying to load was trained with a more recent version of PEFT than the version you have installed on your system.
+
+```
+TypeError: LoraConfig.__init__() got an unexpected keyword argument <argument-name>
+```
+
+The best way to resolve this issue is to install the latest PEFT version:
+
+```sh
+python -m pip install -U PEFT
+```
+
+If the adapter was trained from a source install of PEFT (an unreleased version of PEFT), then you also need to install PEFT from source.
+
+```sh
+python -m pip install -U git+https://github.com/huggingface/peft.git
+```
+
+If it is not possible for you to upgrade PEFT, there is a workaround you can try.
+
+Assume the error message says that the unknown keyword argument is named `foobar`. Search inside the `adapter_config.json` of this PEFT adapter for the `foobar` entry and delete it from the file. Then save the file and try loading the model again.
+
+This solution works most of the time. As long as it is the default value for `foobar`, it can be ignored. However, when it is set to some other value, you will get incorrect results. Upgrading PEFT is the recommended solution.
+
+## Adapter handling
+
+### Using multiple adapters at the same time
+
+PEFT allows you to create more than one adapter on the same model. This can be useful in many situations. For example, for inference, you may want to serve two fine-tuned models from the same base model instead of loading the base model once for each fine-tuned model, which would cost more memory. However, multiple adapters can be activated at the same time. This way, the model may leverage the learnings from all those adapters at the same time. As an example, if you have a diffusion model, you may want to use one LoRA adapter to change the style and a different one to change the subject.
+
+Activating multiple adapters at the same time is generally possible on all PEFT methods (LoRA, LoHa, IA³, etc.) except for prompt learning methods (p-tuning, prefix tuning, etc.). The following example illustrates how to achieve this:
+
+```python
+from transformers import AutoModelForCausalLM
+from peft import PeftModel
+
+model_id = ...
+base_model = AutoModelForCausalLM.from_pretrained(model_id)
+model = PeftModel.from_pretrained(base_model, lora_path_0)  # default adapter_name is 'default'
+model.load_adapter(lora_path_1, adapter_name="other")
+# the 'other' adapter was loaded but it's not active yet, so to activate both adapters:
+model.base_model.set_adapter(["default", "other"])
+```
+
+> [!TIP]
+> In the example above, you can see that we need to call `model.base_model.set_adapter(["default", "other"])`. Why can we not call `model.set_adapter(["default", "other"])`? This is unfortunately not possible because, as explained earlier, some PEFT methods don't support activating more than one adapter at a time.
+
+It is also possible to train two adapters at the same time, but you should be careful to ensure that the weights of both adapters are known to the optimizer. Otherwise, only one adapter will receive updates.
+
+```python
+from transformers import AutoModelForCausalLM
+from peft import LoraConfig, get_peft_model
+
+model_id = ...
+base_model = AutoModelForCausalLM.from_pretrained(model_id)
+lora_config_0 = LoraConfig(...)
+lora_config_1 = LoraConfig(...)
+model = get_peft_model(base_model, lora_config_0)
+model.add_adapter(adapter_name="other", peft_config=lora_config_1)
+```
+
+If we would now call:
+
+```python
+from transformers import Trainer
+
+trainer = Trainer(model=model,  ...)
+trainer.train()
+```
+
+or
+
+```python
+optimizer = torch.optim.AdamW([param for param in model.parameters() if param.requires_grad], ...)
+```
+
+then the second LoRA adapter (`"other"`) would not be trained. This is because it is inactive at this moment, which means the `requires_grad` attribute on its parameters is set to `False` and the optimizer will ignore it. Therefore, make sure to activate all adapters that should be trained _before_ initializing the optimizer:
+
+```python
+# activate all adapters
+model.base_model.set_adapter(["default", "other"])
+trainer = Trainer(model=model,  ...)
+trainer.train()
+```
+
+> [!TIP]
+> This section deals with using multiple adapters _of the same type_ on the same model, for example, using multiple LoRA adapters at the same time. It does not apply to using _different types_ of adapters on the same model, for example one LoRA adapter and one LoHa adapter. For this, please check [`PeftMixedModel`](https://huggingface.co/docs/peft/developer_guides/mixed_models).
diff --git a/docs/source/guides/peft_integrations.md b/docs/source/guides/peft_integrations.md
new file mode 100644
index 0000000..6892fdd
--- /dev/null
+++ b/docs/source/guides/peft_integrations.md
@@ -0,0 +1,152 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# PEFT integrations
+
+PEFT's practical benefits extends to other Hugging Face libraries like [Diffusers](https://hf.co/docs/diffusers) and [Transformers](https://hf.co/docs/transformers). One of the main benefits of PEFT is that an adapter file generated by a PEFT method is a lot smaller than the original model, which makes it super easy to manage and use multiple adapters. You can use one pretrained base model for multiple tasks by simply loading a new adapter finetuned for the task you're solving. Or you can combine multiple adapters with a text-to-image diffusion model to create new effects.
+
+This tutorial will show you how PEFT can help you manage adapters in Diffusers and Transformers.
+
+## Diffusers
+
+Diffusers is a generative AI library for creating images and videos from text or images with diffusion models. LoRA is an especially popular training method for diffusion models because you can very quickly train and share diffusion models to generate images in new styles. To make it easier to use and try multiple LoRA models, Diffusers uses the PEFT library to help manage different adapters for inference.
+
+For example, load a base model and then load the [artificialguybr/3DRedmond-V1](https://huggingface.co/artificialguybr/3DRedmond-V1) adapter for inference with the [`load_lora_weights`](https://huggingface.co/docs/diffusers/v0.24.0/en/api/loaders/lora#diffusers.loaders.LoraLoaderMixin.load_lora_weights) method. The `adapter_name` argument in the loading method is enabled by PEFT and allows you to set a name for the adapter so it is easier to reference.
+
+```py
+import torch
+from diffusers import DiffusionPipeline
+
+pipeline = DiffusionPipeline.from_pretrained(
+    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
+).to("cuda")
+pipeline.load_lora_weights(
+    "peft-internal-testing/artificialguybr__3DRedmond-V1", 
+    weight_name="3DRedmond-3DRenderStyle-3DRenderAF.safetensors", 
+    adapter_name="3d"
+)
+image = pipeline("sushi rolls shaped like kawaii cat faces").images[0]
+image
+```
+
+<div class="flex justify-center">
+    <img src="https://huggingface.co/datasets/ybelkada/documentation-images/resolve/main/test-lora-diffusers.png"/>
+</div>
+
+Now let's try another cool LoRA model, [ostris/super-cereal-sdxl-lora](https://huggingface.co/ostris/super-cereal-sdxl-lora). All you need to do is load and name this new adapter with `adapter_name`, and use the [`set_adapters`](https://huggingface.co/docs/diffusers/api/loaders/unet#diffusers.loaders.UNet2DConditionLoadersMixin.set_adapters) method to set it as the currently active adapter.
+
+```py
+pipeline.load_lora_weights(
+    "ostris/super-cereal-sdxl-lora", 
+    weight_name="cereal_box_sdxl_v1.safetensors", 
+    adapter_name="cereal"
+)
+pipeline.set_adapters("cereal")
+image = pipeline("sushi rolls shaped like kawaii cat faces").images[0]
+image
+```
+
+<div class="flex justify-center">
+    <img src="https://huggingface.co/datasets/ybelkada/documentation-images/resolve/main/test-lora-diffusers-2.png"/>
+</div>
+
+Finally, you can call the [`disable_lora`](https://huggingface.co/docs/diffusers/api/loaders/unet#diffusers.loaders.UNet2DConditionLoadersMixin.disable_lora) method to restore the base model.
+
+```py
+pipeline.disable_lora()
+```
+
+Learn more about how PEFT supports Diffusers in the [Inference with PEFT](https://huggingface.co/docs/diffusers/tutorials/using_peft_for_inference) tutorial.
+
+## Transformers
+
+🤗 [Transformers](https://hf.co/docs/transformers) is a collection of pretrained models for all types of tasks in all modalities. You can load these models for training or inference. Many of the models are large language models (LLMs), so it makes sense to integrate PEFT with Transformers to manage and train adapters.
+
+Load a base pretrained model to train.
+
+```py
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m")
+```
+
+Next, add an adapter configuration to specify how to adapt the model parameters. Call the [`~PeftModel.add_adapter`] method to add the configuration to the base model.
+
+```py
+from peft import LoraConfig
+
+peft_config = LoraConfig(
+    lora_alpha=16,
+    lora_dropout=0.1,
+    r=64,
+    bias="none",
+    task_type="CAUSAL_LM"
+)
+model.add_adapter(peft_config)
+```
+
+Now you can train the model with Transformer's [`~transformers.Trainer`] class or whichever training framework you prefer.
+
+To use the newly trained model for inference, the [`~transformers.AutoModel`] class uses PEFT on the backend to load the adapter weights and configuration file into a base pretrained model.
+
+```py
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained("peft-internal-testing/opt-350m-lora")
+```
+
+Alternatively, you can use transformers [Pipelines](https://huggingface.co/docs/transformers/en/main_classes/pipelines) to load the model for conveniently running inference:
+
+```py
+from transformers import pipeline
+
+model = pipeline("text-generation", "peft-internal-testing/opt-350m-lora")
+print(model("Hello World"))
+```
+
+If you're interested in comparing or using more than one adapter, you can call the [`~PeftModel.add_adapter`] method to add the adapter configuration to the base model. The only requirement is the adapter type must be the same (you can't mix a LoRA and LoHa adapter).
+
+```py
+from transformers import AutoModelForCausalLM
+from peft import LoraConfig
+
+model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m")
+model.add_adapter(lora_config_1, adapter_name="adapter_1")
+```
+
+Call [`~PeftModel.add_adapter`] again to attach a new adapter to the base model.
+
+```py
+model.add_adapter(lora_config_2, adapter_name="adapter_2")
+```
+
+Then you can use [`~PeftModel.set_adapter`] to set the currently active adapter.
+
+```py
+model.set_adapter("adapter_1")
+output = model.generate(**inputs)
+print(tokenizer.decode(output_disabled[0], skip_special_tokens=True))
+```
+
+To disable the adapter, call the [disable_adapters](https://github.com/huggingface/transformers/blob/4e3490f79b40248c53ee54365a9662611e880892/src/transformers/integrations/peft.py#L313) method.
+
+```py
+model.disable_adapters()
+```
+
+The [enable_adapters](https://github.com/huggingface/transformers/blob/4e3490f79b40248c53ee54365a9662611e880892/src/transformers/integrations/peft.py#L336) can be used to enable the adapters again.
+
+If you're curious, check out the [Load and train adapters with PEFT](https://huggingface.co/docs/transformers/main/peft) tutorial to learn more.
diff --git a/docs/source/guides/peft_model_config.md b/docs/source/guides/peft_model_config.md
new file mode 100644
index 0000000..4f6df82
--- /dev/null
+++ b/docs/source/guides/peft_model_config.md
@@ -0,0 +1,179 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# PEFT configurations and models
+
+The sheer size of today's large pretrained models - which commonly have billions of parameters - presents a significant training challenge because they require more storage space and more computational power to crunch all those calculations. You'll need access to powerful GPUs or TPUs to train these large pretrained models which is expensive, not widely accessible to everyone, not environmentally friendly, and not very practical. PEFT methods address many of these challenges. There are several types of PEFT methods (soft prompting, matrix decomposition, adapters), but they all focus on the same thing, reduce the number of trainable parameters. This makes it more accessible to train and store large models on consumer hardware.
+
+The PEFT library is designed to help you quickly train large models on free or low-cost GPUs, and in this tutorial, you'll learn how to setup a configuration to apply a PEFT method to a pretrained base model for training. Once the PEFT configuration is setup, you can use any training framework you like (Transformer's [`~transformers.Trainer`] class, [Accelerate](https://hf.co/docs/accelerate), a custom PyTorch training loop).
+
+## PEFT configurations
+
+> [!TIP]
+> Learn more about the parameters you can configure for each PEFT method in their respective API reference page.
+
+A configuration stores important parameters that specify how a particular PEFT method should be applied.
+
+For example, take a look at the following `LoraConfig` for applying LoRA and `PromptEncoderConfig` for applying p-tuning (these configuration files are already JSON-serialized). Whenever you load a PEFT adapter, it is a good idea to check whether it has an associated `adapter_config.json` file which is required.
+
+<hfoptions id="config">
+<hfoption id="LoraConfig">
+
+```json
+{
+  "base_model_name_or_path": "facebook/opt-350m", #base model to apply LoRA to
+  "bias": "none",
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "lora_alpha": 32,
+  "lora_dropout": 0.05,
+  "modules_to_save": null,
+  "peft_type": "LORA", #PEFT method type
+  "r": 16,
+  "revision": null,
+  "target_modules": [
+    "q_proj", #model modules to apply LoRA to (query and value projection layers)
+    "v_proj"
+  ],
+  "task_type": "CAUSAL_LM" #type of task to train model on
+}
+```
+
+You can create your own configuration for training by initializing a [`LoraConfig`].
+
+```py
+from peft import LoraConfig, TaskType
+
+lora_config = LoraConfig(
+    r=16,
+    target_modules=["q_proj", "v_proj"],
+    task_type=TaskType.CAUSAL_LM,
+    lora_alpha=32,
+    lora_dropout=0.05
+)
+```
+
+</hfoption>
+<hfoption id="PromptEncoderConfig">
+
+```json
+{
+  "base_model_name_or_path": "roberta-large", #base model to apply p-tuning to
+  "encoder_dropout": 0.0,
+  "encoder_hidden_size": 128,
+  "encoder_num_layers": 2,
+  "encoder_reparameterization_type": "MLP",
+  "inference_mode": true,
+  "num_attention_heads": 16,
+  "num_layers": 24,
+  "num_transformer_submodules": 1,
+  "num_virtual_tokens": 20,
+  "peft_type": "P_TUNING", #PEFT method type
+  "task_type": "SEQ_CLS", #type of task to train model on
+  "token_dim": 1024
+}
+```
+
+You can create your own configuration for training by initializing a [`PromptEncoderConfig`].
+
+```py
+from peft import PromptEncoderConfig, TaskType
+
+p_tuning_config = PromptEncoderConfig(
+    encoder_reparameterization_type="MLP",
+    encoder_hidden_size=128,
+    num_attention_heads=16,
+    num_layers=24,
+    num_transformer_submodules=1,
+    num_virtual_tokens=20,
+    token_dim=1024,
+    task_type=TaskType.SEQ_CLS
+)
+```
+
+</hfoption>
+</hfoptions>
+
+## PEFT models
+
+With a PEFT configuration in hand, you can now apply it to any pretrained model to create a [`PeftModel`]. Choose from any of the state-of-the-art models from the [Transformers](https://hf.co/docs/transformers) library, a custom model, and even new and unsupported transformer architectures.
+
+For this tutorial, load a base [facebook/opt-350m](https://huggingface.co/facebook/opt-350m) model to finetune.
+
+```py
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m")
+```
+
+Use the [`get_peft_model`] function to create a [`PeftModel`] from the base facebook/opt-350m model and the `lora_config` you created earlier.
+
+```py
+from peft import get_peft_model
+
+lora_model = get_peft_model(model, lora_config)
+lora_model.print_trainable_parameters()
+"trainable params: 1,572,864 || all params: 332,769,280 || trainable%: 0.472659014678278"
+```
+
+> [!WARNING]
+> When calling [`get_peft_model`], the base model will be modified *in-place*. That means, when calling [`get_peft_model`] on a model that was already modified in the same way before, this model will be further mutated. Therefore, if you would like to modify your PEFT configuration after having called [`get_peft_model()`] before, you would first have to unload the model with [`~LoraModel.unload`] and then call [`get_peft_model()`] with your new configuration. Alternatively, you can re-initialize the model to ensure a fresh, unmodified state before applying a new PEFT configuration.
+
+Now you can train the [`PeftModel`] with your preferred training framework! After training, you can save your model locally with [`~PeftModel.save_pretrained`] or upload it to the Hub with the [`~transformers.PreTrainedModel.push_to_hub`] method.
+
+```py
+# save locally
+lora_model.save_pretrained("your-name/opt-350m-lora")
+
+# push to Hub
+lora_model.push_to_hub("your-name/opt-350m-lora")
+```
+
+To load a [`PeftModel`] for inference, you'll need to provide the [`PeftConfig`] used to create it and the base model it was trained from.
+
+```py
+from peft import PeftModel, PeftConfig
+
+config = PeftConfig.from_pretrained("ybelkada/opt-350m-lora")
+model = AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path)
+lora_model = PeftModel.from_pretrained(model, "ybelkada/opt-350m-lora")
+```
+
+> [!TIP]
+> By default, the [`PeftModel`] is set for inference, but if you'd like to train the adapter some more you can set `is_trainable=True`.
+>
+> ```py
+> lora_model = PeftModel.from_pretrained(model, "ybelkada/opt-350m-lora", is_trainable=True)
+> ```
+
+The [`PeftModel.from_pretrained`] method is the most flexible way to load a [`PeftModel`] because it doesn't matter what model framework was used (Transformers, timm, a generic PyTorch model). Other classes, like [`AutoPeftModel`], are just a convenient wrapper around the base [`PeftModel`], and makes it easier to load PEFT models directly from the Hub or locally where the PEFT weights are stored.
+
+```py
+from peft import AutoPeftModelForCausalLM
+
+lora_model = AutoPeftModelForCausalLM.from_pretrained("ybelkada/opt-350m-lora")
+```
+
+Take a look at the [AutoPeftModel](../package_reference/auto_class) API reference to learn more about the [`AutoPeftModel`] classes.
+
+## Next steps
+
+With the appropriate [`PeftConfig`], you can apply it to any pretrained model to create a [`PeftModel`] and train large powerful models faster on freely available GPUs! To learn more about PEFT configurations and models, the following guide may be helpful:
+
+* Learn how to configure a PEFT method for models that aren't from Transformers in the [Working with custom models](../developer_guides/custom_models) guide.
diff --git a/docs/source/index.md b/docs/source/index.md
new file mode 100644
index 0000000..16b9ae6
--- /dev/null
+++ b/docs/source/index.md
@@ -0,0 +1,42 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# PEFT
+
+🤗 PEFT (Parameter-Efficient Fine-Tuning) is a library for efficiently adapting large pretrained models to various downstream applications without fine-tuning all of a model's parameters because it is prohibitively costly. PEFT methods only fine-tune a small number of (extra) model parameters - significantly decreasing computational and storage costs - while yielding performance comparable to a fully fine-tuned model. This makes it more accessible to train and store large language models (LLMs) and other big models on consumer hardware.
+
+PEFT is integrated with the Transformers, Diffusers, and Accelerate libraries to provide a faster and easier way to load, train, and use large models for inference.
+
+<div class="flex justify-center">
+  <div class="flex flex-col basis-1/4">
+    There are numerous methods to "adapt" existing models, often extensively integrating into the model. PEFT can be thought of as a framework for arbitrary methods of model adaption (modifying weights, wrapping layers, manipulating KV-caches, ...) while also serving as a reference implementation for many fine-tuning methods.
+  </div>
+  <div class="flex flex-col basis-3/4 pl-10 pr-10"><img style="border: 0;box-shadow: none;border-radius: 0;" src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/peft/adapter_installation.png" width="100%"></div>
+</div>
+
+<div class="mt-10">
+  <div class="w-full flex flex-col space-y-2 md:space-y-0 md:grid md:grid-cols-2 md:gap-y-4 md:gap-x-5">
+    <a class="!no-underline border dark:border-gray-700 p-5 rounded-lg shadow hover:shadow-lg" href="quicktour"
+      ><div class="w-full text-center bg-gradient-to-br from-blue-400 to-blue-500 rounded-lg py-1.5 font-semibold mb-5 text-white text-lg leading-relaxed">Quicktour</div>
+      <p class="text-gray-700">Start here if you're new to 🤗 PEFT to get an overview of the library's main features, and how to train a model with a PEFT method.</p>
+    </a>
+    <a class="!no-underline border dark:border-gray-700 p-5 rounded-lg shadow hover:shadow-lg" href="./methods/overview"
+      ><div class="w-full text-center bg-gradient-to-br from-indigo-400 to-indigo-500 rounded-lg py-1.5 font-semibold mb-5 text-white text-lg leading-relaxed">Method overview</div>
+      <p class="text-gray-700">Learn about the different categories of PEFT methods to get an orientation what to use with your model.</p>
+    </a>
+  </div>
+</div>
+
diff --git a/docs/source/install.md b/docs/source/install.md
new file mode 100644
index 0000000..00dceb6
--- /dev/null
+++ b/docs/source/install.md
@@ -0,0 +1,48 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# Installation
+
+Before you start, you will need to setup your environment, install the appropriate packages, and configure 🤗 PEFT. 🤗 PEFT is tested on **Python 3.9+**.
+
+🤗 PEFT is available on PyPI, as well as GitHub:
+
+## PyPI
+
+To install 🤗 PEFT from PyPI:
+
+```bash
+pip install peft
+```
+
+## Source
+
+New features that haven't been released yet are added every day, which also means there may be some bugs. To try them out, install from the GitHub repository:
+
+```bash
+pip install git+https://github.com/huggingface/peft
+```
+
+If you wish to play with the source code and see live results as you run the code, an editable version
+can be installed from a locally-cloned version of the repository:
+
+```bash
+git clone https://github.com/huggingface/peft
+cd peft
+pip install -e ".[test]"
+```
+
+If you're planning to contribute to PEFT, follow the [contributing guide](developer_guides/contributing#installation) instead, which also covers forking, adding the upstream remote, and creating a working branch.
diff --git a/docs/source/methods/overview.md b/docs/source/methods/overview.md
new file mode 100644
index 0000000..c8ce9fe
--- /dev/null
+++ b/docs/source/methods/overview.md
@@ -0,0 +1,65 @@
+<!--Copyright 2026-present The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+
+# Parameter efficient fine-tuning methods
+
+PEFT methods train as few parameters as possible while aiming for performance comparable to full fine-tuning. Fewer trainable parameters are less expressive, so the same performance isn't guaranteed. In exchange you use less memory, often less compute, and gain features like fast hot-swapping between expert adapters and less forgetting of prior knowledge.
+
+Giving general advice for training large models is hard but for generative models, especially language models, you can follow these steps:
+
+1. use prompting (e.g. few-shot examples in the prompt) to see if the model is already capable of the task. If the model solves your problem, great! You can now use [Prompt-based methods](#prompt-based-methods) to learn the prompt and save precious tokens.
+2. If prompt-based methods are not sufficient you can use [layer tuning](#layer-tuning) and [adapter methods](#adapter-methods). These methods are generally more expressive than prompt-based methods and get closer to full-finetuning.
+3. Make sure to measure retention of already learnt knowledge since each fine-tuning step is potentially unlearning past knowledge.
+
+The [PEFT method comparison suite](https://huggingface.co/spaces/peft-internal-testing/PEFT-method-comparison) aims to give a rough overview of (most) implemented methods on selected benchmarks and models.
+
+> [!NOTE]
+> Not all PEFT methods are created equal and there are differences between capabilities:
+> * Quantization: not all methods support quantized base models
+> * Features: not all features are supported for all methods (e.g., multiple adapters, mixed adapter inference, merging/unmerging)
+> * Layer types: linear layers are generally supported, but not all adapter methods support embedding (important for extending vocabulary) or convolutional layers (important for some image models)
+> * Runtime: PEFT methods generally add runtime overhead but some of that can be mitigated (e.g., by [merging the adapter weights](../developer_guides/checkpoint#merge-the-weights))
+
+## Prompt-based methods
+
+Prompting primes a frozen pretrained model for a specific downstream task by including a text prompt that describes the task or even demonstrates an example of the task. With prompting, you can avoid fully training a separate model for each downstream task, and use the same frozen pretrained model instead. This is a lot easier because you can use the same model for several different tasks, and it is significantly more efficient to train and store a smaller set of prompt parameters than to train all the model's parameters.
+
+There are two categories of prompting methods:
+
+- hard prompts are manually handcrafted text prompts with discrete input tokens; the downside is that it requires a lot of effort to create a good prompt
+- soft prompts are learnable tensors concatenated with the input embeddings that can be optimized to a dataset; the downside is that they aren't human readable because you aren't matching these "virtual tokens" to the embeddings of a real word
+
+The PEFT library supports several types of prompting methods (p-tuning, prefix tuning, prompt tuning, ...), explore the table of contents for a full listing of soft prompt methods.
+If you're interested in applying these methods to other tasks and use cases, take a look at our [notebook collection](https://huggingface.co/spaces/PEFT/soft-prompting)!
+
+> [!TIP]
+> Some familiarity with the general process of training a causal language model would be really helpful and allow you to focus on the soft prompting methods. If you're new, we recommend taking a look at the [Causal language modeling](https://huggingface.co/docs/transformers/tasks/language_modeling) guide first from the Transformers documentation. When you're ready, come back and see how easy it is to drop PEFT into your training!
+
+## Layer Tuning
+
+Layer Tuning categorizes methods that target one type of layer or one aspect of a layer specifically, for example [LayerNorm Tuning](../package_reference/layernorm_tuning) targets only [`LayerNorm`](https://docs.pytorch.org/docs/stable/generated/torch.nn.LayerNorm.html) layers and [TrainableTokens](../package_reference/trainable_tokens) only targets specific tokens in the embedding matrix. This contrasts prompt-based methods which work with the model input or adapter methods which extend the existing weights and are generally more independent of the layer type, targeting linear or convolutional layers.
+
+## Adapter methods
+
+Adapter methods can be seen as ways of adding relatively small, trainable matrices to existing models for fine-tuning. The goal is to introduce few trainable parameters to steer the big model in the direction of the task that needs fine-tuning to save on resources, such as memory or compute.
+
+A popular way to realize adapters is to insert smaller trainable matrices that are a low-rank decomposition of the adapted weight's layout to save on memory. There are several different ways to express the weight matrix as a low-rank decomposition, but [Low-Rank Adaptation (LoRA)](../package_reference/lora) is the most common method. The PEFT library supports several other variations of this formulation - some are direct variants of LoRA and are documented under LoRA, some are different enough to count as their own methods, such as [Low-Rank Hadamard Product (LoHa)](../package_reference/loha), [Low-Rank Kronecker Product (LoKr)](../package_reference/lokr), and [Adaptive Low-Rank Adaptation (AdaLoRA)](../package_reference/adalora). If you're interested in applying these methods to other tasks and use cases like semantic segmentation, token classification, take a look at our [notebook collection](https://huggingface.co/collections/PEFT/notebooks-6573b28b33e5a4bf5b157fc1)!
+
+> [!TIP]
+> LoRA is one of the most popular PEFT methods and a good starting point if you're just getting started with PEFT. It was originally developed for large language models but it is a tremendously popular training method for diffusion models because of its efficiency and effectiveness.
+
+Low-rank adapters are only one possible adapter formulation, PEFT implements many other types of adapters as well. For example, Orthogonal Fine-Tuning methods ([OFT](../package_reference/oft), [BOFT](../package_reference/boft), ...) use orthogonal decompositions of the adapter weights to achieve small size. Methods like [MiSS](../package_reference/miss) shard matrices and share these shards to save on memory. [IA3](../package_reference/ia3) introduces learned vectors that rescale the key, value, and feed-forward activations.
diff --git a/docs/source/package_reference/adalora.md b/docs/source/package_reference/adalora.md
new file mode 100644
index 0000000..f96142d
--- /dev/null
+++ b/docs/source/package_reference/adalora.md
@@ -0,0 +1,79 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# AdaLoRA
+
+[AdaLoRA](https://hf.co/papers/2303.10512) (Adaptive LoRA) is a method for optimizing the number of trainable parameters to assign to weight matrices and layers, unlike LoRA, which distributes parameters evenly across all modules. More parameters are budgeted for important weight matrices and layers while less important ones receive fewer parameters. You can control the average desired *rank* or `r` of the matrices, and which modules to apply AdaLoRA to with `target_modules`. Other important parameters to set are `lora_alpha` (scaling factor), and `modules_to_save` (the modules apart from the AdaLoRA layers to be trained and saved). All of these parameters - and more - are found in the [`AdaLoraConfig`].
+
+The abstract from the paper is:
+
+*Fine-tuning large pre-trained language models on downstream tasks has become an important paradigm in NLP. However, common practice fine-tunes all of the parameters in a pre-trained model, which becomes prohibitive when a large number of downstream tasks are present. Therefore, many fine-tuning methods are proposed to learn incremental updates of pre-trained weights in a parameter efficient way, e.g., low-rank increments. These methods often evenly distribute the budget of incremental updates across all pre-trained weight matrices, and overlook the varying importance of different weight parameters. As a consequence, the fine-tuning performance is suboptimal. To bridge this gap, we propose AdaLoRA, which adaptively allocates the parameter budget among weight matrices according to their importance score. In particular, AdaLoRA parameterizes the incremental updates in the form of singular value decomposition. Such a novel approach allows us to effectively prune the singular values of unimportant updates, which is essentially to reduce their parameter budget but circumvent intensive exact SVD computations. We conduct extensive experiments with several pre-trained models on natural language processing, question answering, and natural language generation to validate the effectiveness of AdaLoRA. Results demonstrate that AdaLoRA manifests notable improvement over baselines, especially in the low budget settings. Our code is publicly available at https://github.com/QingruZhang/AdaLoRA*.
+
+> [!WARNING]
+> AdaLoRA has an [`~AdaLoraModel.update_and_allocate`] method that should be called at each training step to update the parameter budget and mask, otherwise the adaptation step is not performed. This requires writing a custom training loop or subclassing the [`~transformers.Trainer`] to incorporate this method. As an example, take a look at this [custom training loop](https://github.com/huggingface/peft/blob/912ad41e96e03652cabf47522cd876076f7a0c4f/examples/conditional_generation/peft_adalora_seq2seq.py#L120).
+
+AdaLoRA manages the parameter budget introduced from LoRA by allocating more parameters - in other words, a higher rank `r` - for important weight matrices that are better adapted for a task and pruning less important ones. The rank is controlled by a method similar to singular value decomposition (SVD). The $\Delta W$ is parameterized with two orthogonal matrices and a diagonal matrix which contains singular values. This parametrization method avoids iteratively applying SVD which is computationally expensive. Based on this method, the rank of $\Delta W$ is adjusted according to an importance score. $\Delta W$ is divided into triplets and each triplet is scored according to its contribution to model performance. Triplets with low importance scores are pruned and triplets with high importance scores are kept for finetuning.
+
+Training with AdaLoRA has three phases: the init phase, the budgeting phase and the final phase. In the initial phase, no budgeting is applied, therefore the ranks are not touched. During the budgeting phase the process described above is applied and the rank is redistributed according to a budget, aiming to give more important adapters more rank and less important layers less. When reaching the final phase, budgeting has ended, the ranks are redistributed but we may continue training for a while with the redistributed ranks to further improve performance.
+
+> [!NOTE]
+> **Contributions welcome**: This section needs clarification.
+>
+> It is unclear how importance is measured. The explanations are also a bit redundant and could benefit from consolidation.
+> See [here](../developer_guides/contributing#documentation-improvements) on how to contribute.
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=ADALORA"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+## Usage
+
+
+```py
+from peft import AdaLoraConfig, get_peft_model
+
+config = AdaLoraConfig(
+    r=8,
+    init_r=12,
+    tinit=200,
+    tfinal=1000,
+    deltaT=10,
+    target_modules=["query", "value"],
+    modules_to_save=["classifier"],
+)
+model = get_peft_model(model, config)
+model.print_trainable_parameters()
+"trainable params: 520,325 || all params: 87,614,722 || trainable%: 0.5938785036606062"
+
+[... training code ...]
+
+model.update_and_allocate(step_idx)
+```
+
+# API
+
+## AdaLoraConfig
+
+[[autodoc]] tuners.adalora.config.AdaLoraConfig
+
+## AdaLoraModel
+
+[[autodoc]] tuners.adalora.model.AdaLoraModel
diff --git a/docs/source/package_reference/adamss.md b/docs/source/package_reference/adamss.md
new file mode 100644
index 0000000..fe3279b
--- /dev/null
+++ b/docs/source/package_reference/adamss.md
@@ -0,0 +1,48 @@
+<!--Copyright 2026 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# AdaMSS
+
+[AdaMSS](https://openreview.net/forum?id=8ZdWmpYxT0) (AdaMSS: Adaptive Multi-Subspace Approach for Parameter-Efficient Fine-Tuning) is a parameter-efficient fine-tuning method that decomposes weight matrices using SVD and clusters the decomposed space into multiple trainable subspaces. Each subspace learns independent low-rank updates while the original weights remain frozen. AdaMSS also supports Adaptive Subspace Allocation (ASA), which dynamically prunes less important subspaces during training based on gradient information.
+
+The abstract from the paper is:
+
+> We propose AdaMSS, an adaptive multi-subspace approach for parameter-efficient fine-tuning of large models. Unlike traditional parameterefficient fine-tuning methods that operate within a large single subspace of the network weights, AdaMSS leverages subspace segmentation to obtain multiple smaller subspaces and adaptively reduces the number of trainable parameters during training, ultimately updating only those associated with a small subset of subspaces most relevant to the target downstream task. By using the lowest-rank representation, AdaMSS achieves more compact expressiveness and finer tuning of the model parameters. Theoretical analyses demonstrate that AdaMSS has better generalization guarantee than LoRA, PiSSA, and other single-subspace low-rankbased methods. Extensive experiments across image classification, natural language understanding, and natural language generation tasks show that AdaMSS achieves comparable performance to full fine-tuning and outperforms other parameterefficient fine-tuning methods in most cases, all while requiring fewer trainable parameters. Notably, on the ViT-Large model, AdaMSS achieves 4.7% higher average accuracy than LoRA across seven tasks, using just 15.4% of the trainable parameters. On RoBERTa-Large, AdaMSS outperforms PiSSA by 7% in average accuracy across six tasks while reducing the number of trainable parameters by approximately 94.4%. These results demonstrate the effectiveness of AdaMSS in parameter-efficient fine-tuning. The code for AdaMSS is available at https: //github.com/jzheng20/AdaMSS.
+
+AdaMSS currently has the following constraints:
+- Only `nn.Linear` layers are supported.
+- Requires scikit-learn for the KMeans clustering step.
+
+If these constraints don't work for your use case, consider other methods instead.
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=ADAMSS"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+# API
+
+## AdamssConfig
+
+[[autodoc]] tuners.adamss.config.AdamssConfig
+
+## AdamssModel
+
+[[autodoc]] tuners.adamss.model.AdamssModel
diff --git a/docs/source/package_reference/adapter_utils.md b/docs/source/package_reference/adapter_utils.md
new file mode 100644
index 0000000..8f8b4e6
--- /dev/null
+++ b/docs/source/package_reference/adapter_utils.md
@@ -0,0 +1,31 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# LyCORIS
+
+[LyCORIS](https://hf.co/papers/2309.14859) (Lora beYond Conventional methods, Other Rank adaptation Implementations for Stable diffusion) are LoRA-like matrix decomposition adapters that modify the cross-attention layer of the UNet. The [LoHa](loha) and [LoKr](lokr) methods inherit from the `Lycoris` classes here.
+
+## LycorisConfig
+
+[[autodoc]] tuners.lycoris_utils.LycorisConfig
+
+## LycorisLayer
+
+[[autodoc]] tuners.lycoris_utils.LycorisLayer
+
+## LycorisTuner
+
+[[autodoc]] tuners.lycoris_utils.LycorisTuner
\ No newline at end of file
diff --git a/docs/source/package_reference/auto_class.md b/docs/source/package_reference/auto_class.md
new file mode 100644
index 0000000..c1b78a2
--- /dev/null
+++ b/docs/source/package_reference/auto_class.md
@@ -0,0 +1,48 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# AutoPeftModels
+
+The `AutoPeftModel` classes loads the appropriate PEFT model for the task type by automatically inferring it from the configuration file. They are designed to quickly and easily load a PEFT model in a single line of code without having to worry about which exact model class you need or manually loading a [`PeftConfig`].
+
+## AutoPeftModel
+
+[[autodoc]] auto.AutoPeftModel
+    - from_pretrained
+
+## AutoPeftModelForCausalLM
+
+[[autodoc]] auto.AutoPeftModelForCausalLM
+
+## AutoPeftModelForSeq2SeqLM
+
+[[autodoc]] auto.AutoPeftModelForSeq2SeqLM
+
+## AutoPeftModelForSequenceClassification
+
+[[autodoc]] auto.AutoPeftModelForSequenceClassification
+
+## AutoPeftModelForTokenClassification
+
+[[autodoc]] auto.AutoPeftModelForTokenClassification
+
+## AutoPeftModelForQuestionAnswering
+
+[[autodoc]] auto.AutoPeftModelForQuestionAnswering
+
+## AutoPeftModelForFeatureExtraction
+
+[[autodoc]] auto.AutoPeftModelForFeatureExtraction
diff --git a/docs/source/package_reference/beft.md b/docs/source/package_reference/beft.md
new file mode 100644
index 0000000..f7c5de4
--- /dev/null
+++ b/docs/source/package_reference/beft.md
@@ -0,0 +1,52 @@
+<!--Copyright 2026 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# BEFT: Bias-Efficient Fine-Tuning of Language Models in Low-Data Regimes
+
+[BEFT](https://arxiv.org/abs/2509.15974) is a parameter efficient fine-tuning algorithm (PEFT) that only fine-tunes the added bias terms of value projections from pretrained transformer models. BEFT demonstrates that fine-tuning the added bias terms of value projections from pretrained transformers generally leads to a higher downstream performance in low-data regimes than fine-tuning the added bias terms of query/key projections.
+
+BEFT currently has the following tradeoffs:
+
+Pros:
+- BEFT requires far fewer parameters than LoRA, while maintaining competitive or superior performance across tasks in low-data regimes.
+
+Cons:
+- In high-data regimes, BEFT may show limited effectiveness compared to LoRA and full-parameters fine-tuning.
+
+If your use case belongs to the high-data regime, consider other PEFT methods such as LoRA.
+
+The abstract from the paper is:
+
+*Fine-tuning the bias terms of large language models (LLMs) has the potential to achieve unprecedented parameter efficiency while maintaining competitive performance, particularly in low-data regimes. However, the link between fine-tuning different bias terms (i.e., **b**<sub>q</sub>, **b**<sub>k</sub>, and **b**<sub>v</sub> in the query, key, or value projections) and downstream performance remains largely unclear to date. In this paper, we investigate the link between fine-tuning **b**<sub>q</sub>, **b**<sub>k</sub>, and **b**<sub>v</sub> with the performance of the downstream task. Our key finding is that directly fine-tuning **b**<sub>v</sub> generally leads to higher downstream performance in low-data regimes, in comparison to **b**<sub>q</sub> and **b**<sub>k</sub>. We extensively evaluate this unique property across a wide range of LLMs spanning encoder-only and decoder-only architectures up to 6.7B parameters (including bias-free LLMs). Our results provide strong evidence for the effectiveness of directly fine-tuning **b**<sub>v</sub> across various downstream tasks*.
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=BEFT"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+# API
+
+## BeftConfig
+
+[[autodoc]] tuners.beft.config.BeftConfig
+
+## BeftModel
+
+[[autodoc]] tuners.beft.model.BeftModel
diff --git a/docs/source/package_reference/boft.md b/docs/source/package_reference/boft.md
new file mode 100644
index 0000000..5a31d0a
--- /dev/null
+++ b/docs/source/package_reference/boft.md
@@ -0,0 +1,92 @@
+<!--Copyright 2023-present The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# BOFT
+
+[Orthogonal Butterfly (BOFT)](https://hf.co/papers/2311.06243) is a generic method designed for finetuning foundation models. It improves the parameter efficiency of the finetuning paradigm -- Orthogonal Finetuning (OFT), by taking inspiration from Cooley-Tukey fast Fourier transform, showing favorable results across finetuning different foundation models, including large vision transformers, large language models and text-to-image diffusion models.
+
+The abstract from the paper is:
+
+*Large foundation models are becoming ubiquitous, but training them from scratch is prohibitively expensive. Thus, efficiently adapting these powerful models to downstream tasks is increasingly important. In this paper, we study a principled finetuning paradigm -- Orthogonal Finetuning (OFT) -- for downstream task adaptation. Despite demonstrating good generalizability, OFT still uses a fairly large number of trainable parameters due to the high dimensionality of orthogonal matrices. To address this, we start by examining OFT from an information transmission perspective, and then identify a few key desiderata that enable better parameter-efficiency. Inspired by how the Cooley-Tukey fast Fourier transform algorithm enables efficient information transmission, we propose an efficient orthogonal parameterization using butterfly structures. We apply this parameterization to OFT, creating a novel parameter-efficient finetuning method, called Orthogonal Butterfly (BOFT). By subsuming OFT as a special case, BOFT introduces a generalized orthogonal finetuning framework. Finally, we conduct an extensive empirical study of adapting large vision transformers, large language models, and text-to-image diffusion models to various downstream tasks in vision and language*.
+
+BOFT focuses on preserving a pretrained model's generative capabilities while being significantly more parameter-efficient than standard [OFT](./oft). Like OFT, BOFT maintains the same cosine similarity ([hyperspherical energy](https://huggingface.co/papers/1805.09298)) between all pairwise neurons in a layer by applying an orthogonal transformation to the pretrained weight matrix, ensuring the semantic relationships among neurons are preserved.
+
+Instead of using a block-diagonal orthogonal matrix, BOFT factorizes the orthogonal transformation into a product of **sparse butterfly matrices** (originally introduced in the [Cooley–Tukey FFT](https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm)). Unlike OFT's block-diagonal rotations, which only mix inputs within each block, the butterfly structure guarantees that every input can influence every output, producing a **dense connectivity** with just `O(d log d)` parameters. This factorization preserves expressivity while drastically reducing the parameter count compared to OFT (at the expense of computation time).
+
+In practice, BOFT multiplies each pretrained weight matrix by a sequence of butterfly-structured orthogonal factors, enabling efficient and expressive neuron rotations. This makes BOFT well-suited for controllable generation and tasks where maintaining the pretrained model's subject representation is critical, while also scaling to larger models with lower memory and compute overhead.
+
+BOFT can be applied to any subset of weight matrices in a neural network to reduce the number of trainable parameters. Given the target layers for injecting BOFT parameters, the number of trainable parameters can be determined based on the size of the weight matrices.
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=BOFT"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+## Merge BOFT weights into the base model
+
+Similar to LoRA, the weights learned by BOFT can be integrated into the pretrained weight matrices using the [`~BOFTModel.merge_and_unload()` function. This function merges the adapter weights with the base model which allows you to effectively use the newly merged model as a standalone model.
+
+<div class="flex justify-center">
+    <img src="https://raw.githubusercontent.com/wy1iu/butterfly-oft/main/assets/boft_merge.png"/>
+</div>
+
+This works because during training, the orthogonal weight matrix (R in the diagram above) and the pretrained weight matrices are separate. But once training is complete, these weights can actually be merged (multiplied) into a new weight matrix that is equivalent.
+
+## BOFT Example Usage
+
+For an example of the BOFT method application to various downstream tasks, please refer to the following guides:
+
+Take a look at the following step-by-step guides on how to finetune a model with BOFT:
+- [Dreambooth finetuning with BOFT](https://github.com/huggingface/peft/blob/main/examples/boft_dreambooth/boft_dreambooth.md)
+- [Controllable generation finetuning with BOFT (ControlNet)](https://github.com/huggingface/peft/blob/main/examples/boft_controlnet/boft_controlnet.md)
+
+For the task of image classification, one can initialize the BOFT config for a DinoV2 model as follows:
+
+```py
+import transformers
+from transformers import AutoModelForSeq2SeqLM, BOFTConfig
+from peft import BOFTConfig, get_peft_model
+
+config = BOFTConfig(
+    boft_block_size=4,
+    boft_n_butterfly_factor=2,
+    target_modules=["query", "value", "key", "output.dense", "mlp.fc1", "mlp.fc2"],
+    boft_dropout=0.1,
+    bias="boft_only",
+    modules_to_save=["classifier"],
+)
+
+model = transformers.Dinov2ForImageClassification.from_pretrained(
+    "facebook/dinov2-large",
+    num_labels=100,
+)
+
+boft_model = get_peft_model(model, config)
+```
+
+# API
+
+## BOFTConfig
+
+[[autodoc]] tuners.boft.config.BOFTConfig
+
+## BOFTModel
+
+[[autodoc]] tuners.boft.model.BOFTModel
diff --git a/docs/source/package_reference/c3a.md b/docs/source/package_reference/c3a.md
new file mode 100644
index 0000000..099673b
--- /dev/null
+++ b/docs/source/package_reference/c3a.md
@@ -0,0 +1,55 @@
+<!--Copyright 2025 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# C3A: Parameter-Efficient Fine-Tuning via Circular Convolution
+
+[C3A](https://huggingface.co/papers/2407.19342) is a parameter-efficient fine-tuning technique that leverages Circular Convolution to achieve high rank adaptation within reasonable resource limits.
+
+Note that you should use a much larger learning rate (LR) for C3A than for other methods. For example, a LR of 1e-1 for C3A is a good starting point. Besides, a much smaller weight decay should be used. You can refer to the `method_comparison` folder for more details.
+
+For the `block_size`, it affects tunable parameters and performance. To start with, you can choose a $\mathrm{gcd}(d_1,d_2)$ near $\frac{\sqrt{d_1 \times d_2}}{r}$, where $r$ is the rank for LoRA you would use for this task.
+
+C3A currently has the following constraints:
+
+- Only `nn.Linear` layers are supported.
+- Quantized layers are not supported.
+- The block size should be a common divisor of both the input and output sizes of target layers.
+
+If these constraints don't work for your use case, consider other methods instead.
+
+The abstract from the paper is:
+
+> Low-Rank Adaptation (LoRA) has gained popularity for fine-tuning large foundation models, leveraging low-rank matrices $\mathbf{A}$ and $\mathbf{B}$ to represent weight changes (i.e., $\Delta \mathbf{W} = \mathbf{B} \mathbf{A}$). This method reduces trainable parameters and mitigates heavy memory consumption associated with full delta matrices by sequentially multiplying $\mathbf{A}$ and $\mathbf{B}$ with the activation. Despite its success, the intrinsic low-rank characteristic may limit its performance. Although several variants have been proposed to address this issue, they often overlook the crucial computational and memory efficiency brought by LoRA. In this paper, we propose Circular Convolution Adaptation (C3A), which not only achieves high-rank adaptation with enhanced performance but also excels in both computational power and memory utilization. Extensive experiments demonstrate that C3A consistently outperforms LoRA and its variants across various fine-tuning tasks.
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=C3A"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+
+# API
+
+## C3AConfig
+
+[[autodoc]] tuners.c3a.config.C3AConfig
+
+## C3AModel
+
+[[autodoc]] tuners.c3a.model.C3AModel
diff --git a/docs/source/package_reference/cartridges.md b/docs/source/package_reference/cartridges.md
new file mode 100644
index 0000000..ac605a8
--- /dev/null
+++ b/docs/source/package_reference/cartridges.md
@@ -0,0 +1,93 @@
+<!--Copyright 2025 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# Cartridges
+
+Cartridges are a prompt-learning method that stores a compressed long-context representation as a parameterized KV-cache
+prefix. The core idea comes from the paper
+[Cartridges: Lightweight and general-purpose long context representations via self-study](https://huggingface.co/papers/2506.06266).
+
+For a high-level overview and motivation, see the blog post
+[Cartridges: Storing long contexts in tiny caches with self-study](https://hazyresearch.stanford.edu/blog/2025-06-08-cartridges).
+
+## How Cartridges differ from Prefix Tuning
+
+Both Prefix Tuning and Cartridges are served by injecting `past_key_values` (a prefix KV cache) into the base model.
+
+- Prefix Tuning learns virtual token embeddings (and optionally an MLP projection) and produces a KV prefix.
+- Cartridges learn the KV prefix itself directly (the per-layer key/value vectors for `p` virtual tokens), and are
+  designed to be initialized from real prefill KV (for example, the first `p` tokens of a corpus/system prompt).
+
+The paper also recommends freezing the first token as an attention sink for stability (`num_frozen_tokens=1` is the
+default).
+
+## Usage (inference)
+
+Load a trained CARTRIDGE adapter and run generation:
+
+```py
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from peft import PeftModel
+
+model_id = "Qwen/Qwen2.5-0.5B-Instruct"
+adapter_path = "path/to/cartridge_adapter"
+
+base = AutoModelForCausalLM.from_pretrained(model_id)
+model = PeftModel.from_pretrained(base, adapter_path)
+
+tok = AutoTokenizer.from_pretrained(model_id)
+if tok.pad_token is None:
+    tok.pad_token = tok.eos_token
+
+out = model.generate(**tok("Question about the corpus:", return_tensors="pt"), max_new_tokens=64)
+print(tok.decode(out[0], skip_special_tokens=True))
+```
+
+If you need to create and initialize a cartridge before training, see the initialization options below.
+
+## Initialization options
+
+The paper discusses a few practical initialization strategies:
+
+- Random KV (default): create a `CartridgeConfig` and start training. This initializes the KV prefix randomly.
+- KV from the first tokens of a prompt/corpus: use `initialize_kv_prefix_from_text(model, tokenizer, text=...)`. This
+  runs a prefill on `text` and copies the resulting KV cache for the first `num_virtual_tokens` into the adapter.
+- KV from an existing cache: use `initialize_kv_prefix_from_past_key_values(model, past_key_values=...)` if you already
+  have a `past_key_values` object from a base-model prefill.
+
+## Training
+
+The Cartridges paper proposes a SELF-STUDY distillation objective (a frozen base model provides teacher logits; the
+CARTRIDGE adapter is trained so the student matches the teacher’s next-token distribution over the target segment).
+PEFT keeps training logic out of the core library; see
+`https://github.com/huggingface/peft/tree/main/examples/cartridge_self_study` for a reference workflow.
+The example scripts use the frozen base model as the teacher and the adapted model as the student, so both share the
+same underlying checkpoint.
+
+## Composition
+
+To concatenate independently trained cartridges into a single adapter, use `compose_cartridge_adapters(...)`.
+
+# API
+
+## CartridgeConfig
+
+[[autodoc]] tuners.cartridge.config.CartridgeConfig
+
+## CartridgeEncoder
+
+[[autodoc]] tuners.cartridge.model.CartridgeEncoder
diff --git a/docs/source/package_reference/config.md b/docs/source/package_reference/config.md
new file mode 100644
index 0000000..9a4f755
--- /dev/null
+++ b/docs/source/package_reference/config.md
@@ -0,0 +1,22 @@
+<!--⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+-->
+
+# Configuration
+
+[`PeftConfigMixin`] is the base configuration class for storing the adapter configuration of a [`PeftModel`], and [`PromptLearningConfig`] is the base configuration class for soft prompt methods (p-tuning, prefix tuning, and prompt tuning). These base classes contain methods for saving and loading model configurations from the Hub, specifying the PEFT method to use, type of task to perform, and model configurations like number of layers and number of attention heads.
+
+## PeftConfigMixin
+
+[[autodoc]] config.PeftConfigMixin
+    - all
+
+## PeftConfig
+
+[[autodoc]] PeftConfig
+    - all
+
+## PromptLearningConfig
+
+[[autodoc]] PromptLearningConfig
+    - all
diff --git a/docs/source/package_reference/cpt.md b/docs/source/package_reference/cpt.md
new file mode 100644
index 0000000..b60915e
--- /dev/null
+++ b/docs/source/package_reference/cpt.md
@@ -0,0 +1,48 @@
+<!-- Copyright 2024 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+
+⚠️ Note that this file is in Markdown but contains specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+-->
+
+# Context-aware Prompt Tuning: Advancing In-Context Learning with Adversarial Methods
+
+
+<div class="flex justify-center">
+    <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/peft/cpt.png"/>
+</div>
+<small>CPT optimizing only specific token embeddings while keeping the rest of the model frozen <a href="https://huggingface.co/papers/2410.17222">(image source)</a>.</small>
+
+[Context-Aware Prompt Tuning (CPT)](https://huggingface.co/papers/2410.17222) is designed to enhance few-shot classification by refining only context embeddings.
+This approach combines ideas from In-Context Learning (ICL), [Prompt Tuning](../package_reference/prompt_tuning) (PT), and adversarial optimization, focusing on making model adaptation both parameter-efficient and effective.
+In CPT, only specific context token embeddings are optimized, while the rest of the model remains frozen.
+To prevent overfitting and maintain stability, CPT uses controlled perturbations to limit the allowed changes to context embeddings within a defined range.
+Additionally, to address the phenomenon of recency bias—where examples near the end of the context tend to be prioritized over earlier ones—CPT applies a decay loss factor.
+
+The abstract from the paper is:
+
+> Large Language Models (LLMs) can perform few-shot learning using either optimization-based approaches or In-Context Learning (ICL). Optimization-based methods often suffer from overfitting, as they require updating a large number of parameters with limited data. In contrast, ICL avoids overfitting but typically underperforms compared to optimization-based methods and is highly sensitive to the selection, order, and format of demonstration examples. To overcome these challenges, we introduce Context-aware Prompt Tuning (CPT), a method inspired by ICL, Prompt Tuning (PT), and adversarial attacks. CPT builds on the ICL strategy of concatenating examples before the input, extending it by incorporating PT-like learning to refine the context embedding through iterative optimization, extracting deeper insights from the training examples. Our approach carefully modifies specific context tokens, considering the unique structure of the examples within the context. In addition to updating the context with PT-like optimization, CPT draws inspiration from adversarial attacks, adjusting the input based on the labels present in the context while preserving the inherent value of the user-provided data. To ensure robustness and stability during optimization, we employ a projected gradient descent algorithm, constraining token embeddings to remain close to their original values and safeguarding the quality of the context. Our method has demonstrated superior accuracy across multiple classification tasks using various LLM models, outperforming existing baselines and effectively addressing the overfitting challenge in few-shot learning.
+
+Take a look at [Example](https://github.com/huggingface/peft/blob/main/examples/cpt_finetuning/README.md) for a step-by-step guide on how to train a model with CPT.
+
+## Benchmark overview
+
+There is no benchmark for this method yet. Feel free to contribute an experiment
+configuration but make sure to first create an issue
+[here](https://github.com/huggingface/peft/issues).
+
+# API
+
+## CPTConfig
+
+[[autodoc]] tuners.cpt.config.CPTConfig
+
+## CPTEmbedding
+
+[[autodoc]] tuners.cpt.model.CPTEmbedding
+
diff --git a/docs/source/package_reference/deft.md b/docs/source/package_reference/deft.md
new file mode 100644
index 0000000..f947998
--- /dev/null
+++ b/docs/source/package_reference/deft.md
@@ -0,0 +1,92 @@
+<!--Copyright 2026 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# DEFT: Decompositional Efficient Fine-Tuning for Text-to-Image Models
+
+[DEFT](https://proceedings.neurips.cc/paper_files/paper/2025/hash/93a34a7138bdad95e874018d5f491cc6-Abstract-Conference.html)
+(Decompositional Efficient Fine-Tuning) is a parameter-efficient fine-tuning method for text-to-image models. It
+decomposes the update of a frozen weight matrix `W` into two trainable components: a projection that removes a low-rank
+subspace from `W`, and a low-rank update that injects new content into that subspace. This formulation is designed to
+balance aligning with a target distribution, learning new concepts from a few images (personalization), and preserving
+the pretrained model's instruction-following ability and editability.
+
+Concretely, DEFT combines two trainable low-rank components: (1) a projection onto the complement of a low-rank
+subspace spanned by a low-rank matrix, and (2) a low-rank update. The first low-rank matrix defines the subspace, while
+the second enables flexible parameter adaptation within that subspace.
+
+When to use DEFT: it is best suited to adapting a model to new data or concepts while **retaining and even improving the
+base model's instruction-following ability** and keeping **forgetting of its previous capabilities to a minimum**.
+
+Per target layer, DEFT learns a projection direction `P` (shape `out_features x r`) and an injection matrix `R` (shape
+`r x in_features`). The effective weight is the residual projection
+
+```
+W' = (I - P_proj) @ W + Q_P @ R
+```
+
+The projector `P_proj` is derived from `P` according to `decomposition_method`:
+
+- `"relu"` (default): `Q_P = P`, `P_proj = P @ relu(P).T` — a non-orthogonal projection.
+- `"qr"`: `Q_P = qr(P)`, `P_proj = Q_P @ Q_P.T` — an orthogonal projection.
+
+The `(I - P_proj) @ W` term removes a sub-space of the pretrained weight while `Q_P @ R` injects new content into it.
+By default (`init_weights=True`) `R` is initialized so that the update is an exact identity at initialization
+(`W' == W`), so training starts from the pretrained weights and learns the injection. The update is equivalent to a
+low-rank additive delta `Q_P @ (R - right.T @ W)`, which is computed without ever forming the `out x out`
+projection matrix and can be merged into the base weights for inference-free deployment.
+
+Setting `para=True` selects the
+[PaRa](https://proceedings.iclr.cc/paper_files/paper/2025/hash/f09e8dd9274cb7c2dd0dc65ffc6f427a-Abstract-Conference.html)
+(Parameter Rank Reduction) variant: a removal-only update `W' = (I - P_proj) @ W` that keeps just the subspace-removal
+term and drops the injection. Only the projection `P` is trained (no injection matrix `R`), so the adapter is not an
+identity at initialization. PaRa was introduced for personalizing text-to-image diffusion models and is available here
+as a special case of DEFT.
+
+DEFT is currently implemented for `torch.nn.Linear` and `Conv1D` (e.g. gpt-2, via `fan_in_fan_out`) layers. The original implementation and the experiments from the
+paper (Dreambooth, Dreambench Plus, InsDet, VisualCloze, on Stable Diffusion and a unified model) are available at
+[github.com/MAXNORM8650/DEFT](https://github.com/MAXNORM8650/DEFT).
+
+If you use DEFT in your work, please cite the paper:
+
+```bibtex
+@article{kumar2026deft,
+  title={DEFT: Decompositional Efficient Fine-Tuning for Text-to-Image Models},
+  author={Kumar, Komal and Anwer, Rao and Shahbaz Khan, Fahad and Khan, Salman and Laptev, Ivan and Cholakkal, Hisham},
+  journal={Advances in Neural Information Processing Systems},
+  volume={38},
+  pages={102009--102035},
+  year={2026}
+}
+```
+
+If you use the PaRa variant (`para=True`), please also cite:
+
+```bibtex
+@inproceedings{chen2025personalizing,
+  title={Para: Personalizing text-to-image diffusion via parameter rank reduction},
+  author={Chen, Shangyu and Pan, Zizheng and Cai, Jianfei and Phung, Dinh},
+  booktitle={International Conference on Learning Representations},
+  year={2025}
+}
+```
+
+## DeftConfig
+
+[[autodoc]] tuners.deft.config.DeftConfig
+
+## DeftModel
+
+[[autodoc]] tuners.deft.model.DeftModel
diff --git a/docs/source/package_reference/delora.md b/docs/source/package_reference/delora.md
new file mode 100644
index 0000000..fe1c916
--- /dev/null
+++ b/docs/source/package_reference/delora.md
@@ -0,0 +1,51 @@
+<!--Copyright 2025 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# DeLoRA: Decoupled Low-rank Adaptation
+[DeLoRA](https://huggingface.co/papers/2503.18225) is a parameter-efficient fine-tuning technique that implicitly maintains a Frobenius boundary with respect to the pretrained weights by normalizing and scaling learnable low-rank matrices. This effectively decouples the learning of directions (BA term) and magnitude (boundary term) of the weight updates, avoiding catastrophic shifts in the adapted weights and enhancing robustness to hyperparameter choices.
+
+Note:
+- use a learning rate 10-100x larger than for standard LoRA variants (typical values from 1e-3/1e-2/..)
+- ensure the initial boundary parameter lambda is not too small (typical values around 10/15/..). Setting different lambdas to different layers is possible
+
+DeLoRA currently has the following constraints:
+- Only nn.Linear layers are supported.
+- Quantized layers are not supported.
+
+If these constraints don't work for your use case, consider other methods instead.
+
+The abstract from the paper is:
+
+> Parameter-Efficient FineTuning (PEFT) methods have recently gained significant popularity thanks to the widespread availability of large-scale pretrained models. These methods allow for quick adaptation to downstream tasks with minimal computational cost. However, popular finetuning methods such as LoRA exhibit limited robustness when it comes to hyperparameter choices or extended training regimes, preventing optimal out-of-the-box performance. In contrast, bounded approaches, such as ETHER, provide greater robustness but are limited to extremely low-rank adaptations and fixed-strength transformations, reducing their adaptation expressive power. In this work, we propose Decoupled Low-rank Adaptation (DeLoRA), a novel finetuning method that normalizes and scales learnable low-rank matrices. By bounding the distance of the transformation, DeLoRA effectively decouples the angular learning from the adaptation strength, enhancing robustness without compromising performance. Through evaluations on subject-driven image generation, natural language understanding, and instruction tuning, we show that DeLoRA matches or surpasses performance of competing PEFT methods, while exhibiting stronger robustness.
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=DELORA"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+# API
+
+## DeloraConfig
+
+[[autodoc]] tuners.delora.config.DeloraConfig
+
+## DeloraModel
+
+[[autodoc]] tuners.delora.model.DeloraModel
diff --git a/docs/source/package_reference/fourierft.md b/docs/source/package_reference/fourierft.md
new file mode 100644
index 0000000..42c3fac
--- /dev/null
+++ b/docs/source/package_reference/fourierft.md
@@ -0,0 +1,49 @@
+<!--Copyright 2024 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# FourierFT: Discrete Fourier Transformation Fine-Tuning
+
+[FourierFT](https://huggingface.co/papers/2405.03003) is a parameter-efficient fine-tuning technique that leverages Discrete Fourier Transform to compress the model's tunable weights. This method outperforms LoRA in the GLUE benchmark and common ViT classification tasks using much less parameters.
+
+FourierFT currently has the following constraints:
+
+- Only `nn.Linear` layers are supported.
+- Quantized layers are not supported.
+
+If these constraints don't work for your use case, consider other methods instead.
+
+The abstract from the paper is:
+
+> Low-rank adaptation (LoRA) has recently gained much interest in fine-tuning foundation models. It effectively reduces the number of trainable parameters by incorporating low-rank matrices A and B to represent the weight change, i.e., Delta W=BA. Despite LoRA's progress, it faces storage challenges when handling extensive customization adaptations or larger base models. In this work, we aim to further compress trainable parameters by enjoying the powerful expressiveness of the Fourier transform. Specifically, we introduce FourierFT, which treats Delta W as a matrix in the spatial domain and learns only a small fraction of its spectral coefficients. With the trained spectral coefficients, we implement the inverse discrete Fourier transform to recover Delta W. Empirically, our FourierFT method shows comparable or better performance with fewer parameters than LoRA on various tasks, including natural language understanding, natural language generation, instruction tuning, and image classification. For example, when performing instruction tuning on the LLaMA2-7B model, FourierFT surpasses LoRA with only 0.064M trainable parameters, compared to LoRA's 33.5M.
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=FOURIERFT"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+# API
+
+## FourierFTConfig
+
+[[autodoc]] tuners.fourierft.config.FourierFTConfig
+
+## FourierFTModel
+
+[[autodoc]] tuners.fourierft.model.FourierFTModel
diff --git a/docs/source/package_reference/frod.md b/docs/source/package_reference/frod.md
new file mode 100644
index 0000000..1062893
--- /dev/null
+++ b/docs/source/package_reference/frod.md
@@ -0,0 +1,75 @@
+<!--Copyright 2026 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# FRoD: Full-Rank Efficient Fine-Tuning with Rotational Degrees
+
+FRoD is a parameter-efficient fine-tuning method that combines a shared full-rank basis with sparse learnable
+rotational degrees. The adapter update is expressed through fixed projection tensors and trainable coefficients, which
+allows FRoD to apply full-rank updates while keeping the number of trained parameters small.
+
+Paper: [Full-Rank Efficient Fine-Tuning with Rotational Degrees](https://doi.org/10.1609/aaai.v40i31.39813).
+
+When saving the adapter parameters, it is possible to avoid storing the projection tensors by setting
+`save_projection=False` on the `FrodConfig`. In that case, the projections are restored from the base model weights and
+the fixed random seed from `projection_prng_key`. This reduces checkpoint size, but the default is
+`save_projection=True` to make checkpoint loading independent of regeneration details.
+
+Compared to LoRA, FRoD can express a full-rank update in each adapted linear layer while training only the diagonal
+coefficients and a sparse set of off-diagonal rotation coefficients. This can be useful when a low-rank update is too
+restrictive. The trade-off is that FRoD computes fixed projection tensors from the base weights during adapter
+injection, which makes setup more expensive and the implementation less broadly supported than LoRA.
+
+Projection initialization can be slow on large models because FRoD runs matrix decompositions over the target module
+categories before injecting the adapters. A progress bar is shown by default and can be disabled with
+`FrodConfig(progressbar=False)`.
+
+For memory-constrained training, `runtime_offload_base_weight=True` keeps target base weights on CPU when the active
+FRoD path does not need them. This is opt-in because PEFT methods usually keep all base parameters on the accelerator
+after moving the model and after forward passes.
+
+FRoD currently has the following constraint:
+
+- Only `nn.Linear` and `transformers.pytorch_utils.Conv1D` layers are supported.
+
+## Quickstart
+
+```python
+from transformers import AutoModelForSequenceClassification
+
+from peft import FrodConfig, TaskType, get_peft_model
+
+model = AutoModelForSequenceClassification.from_pretrained("google-bert/bert-base-uncased", num_labels=2)
+
+peft_config = FrodConfig(
+    task_type=TaskType.SEQ_CLS,
+    target_modules=["query", "value"],
+    modules_to_save=["classifier"],
+    sparse_rate=0.02,
+    frod_dropout=0.0,
+    runtime_offload_base_weight=True,
+)
+
+model = get_peft_model(model, peft_config)
+model.print_trainable_parameters()
+```
+
+## FrodConfig
+
+[[autodoc]] tuners.frod.config.FrodConfig
+
+## FrodModel
+
+[[autodoc]] tuners.frod.model.FrodModel
diff --git a/docs/source/package_reference/functional.md b/docs/source/package_reference/functional.md
new file mode 100644
index 0000000..52251bd
--- /dev/null
+++ b/docs/source/package_reference/functional.md
@@ -0,0 +1,37 @@
+<!--⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+-->
+
+# Functions for PEFT integration
+
+A collection of functions that could be useful for non-PeftModel models, e.g. transformers or diffusers integration
+
+The functions provided here can be considered "public API" of PEFT and hence are safe to be used by packages that provide PEFT integrations.
+
+## Cast the adapter weight dtypes
+[[autodoc]] functional.cast_adapter_dtype
+    - all
+
+## Delete the PEFT adapter from model
+[[autodoc]] functional.delete_adapter
+    - all
+
+## Get the state dict of the PEFT adapter
+[[autodoc]] functional.get_peft_model_state_dict
+    - all
+
+## Inject a PEFT adapter into the model based on a PEFT config
+[[autodoc]] functional.inject_adapter_in_model
+    - all
+
+## Set the active PEFT adapter(s) of the model
+[[autodoc]] functional.set_adapter
+    - all
+
+## Set the `requires_grad` attribute of the specified adapters
+[[autodoc]] functional.set_requires_grad
+    - all
+
+## Load the weights of the PEFT state dict into the model
+[[autodoc]] functional.set_peft_model_state_dict
+    - all
diff --git a/docs/source/package_reference/glora.md b/docs/source/package_reference/glora.md
new file mode 100644
index 0000000..e367332
--- /dev/null
+++ b/docs/source/package_reference/glora.md
@@ -0,0 +1,108 @@
+<!--Copyright 2026 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contains specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+-->
+
+# GLoRA
+
+Generalized Low-Rank Adaptation ([GLoRA](https://huggingface.co/papers/2306.07967)) is a PEFT method that generalizes LoRA and related approaches. GLoRA decomposes updates into configurable paths (A, B, C, D, E), where each path can use low-rank, vector, constant, or disabled parameterization depending on the path.
+
+Each path supports one of four parameterization modes. They trade off **parameter count** against **expressiveness** (how rich the update can be):
+
+- `"lora"`: Low-rank decomposition (like standard LoRA). Uses `r * (out + in)` parameters and can express rank-`r` corrections. Most expressive, most parameters.
+- `"vector"`: A single vector (e.g. shape `(out, 1)`), broadcast across the matrix. Uses `O(out)` parameters; only per-channel scaling or shifts.
+- `"constant"`: A single scalar shared across all elements. Uses 1 parameter; least expressive among the trainable options.
+- `"none"`: Zeros with no trainable parameters; disables that path entirely.
+
+Not every path accepts every mode (for example, `config_D_E` does not support `"lora"`). Choosing `"lora"` on more paths increases capacity and trainable parameters; `"vector"`, `"constant"`, or `"none"` reduce both.
+
+GLoRA is especially useful for research and advanced applications where you want to experiment with structured update patterns and combine multiple adaptation mechanisms in a single layer.
+
+At a high level, GLoRA modifies a frozen linear layer with:
+
+$$
+W_{\mathrm{eff}} = W_0 + W_0 \odot A + B
+$$
+
+$$
+b_{\mathrm{eff}} = b_0 + b_0 \odot D + E + W_0 C
+$$
+
+where each path is independently parameterized.
+
+## GloraConfig
+
+[[autodoc]] tuners.glora.config.GloraConfig
+
+### Key Configuration Options
+- `r`: Rank used when a path is configured as `"lora"` (default: `8`).
+- `target_modules`: List or regex of module names to adapt (e.g., `["q_proj", "v_proj"]`).
+- `config_A_B`: Path type for A and B ("lora", "vector", "constant", "none").
+- `config_C`: Path type for C ("lora", "vector", "none").
+- `config_D_E`: Path type for D and E ("constant", "vector", "none").
+- `bias`: Bias handling (`"none"`, `"all"`, or `"glora_only"`).
+- `init_weights`: If `True` (default), GLoRA is initialized as a no-op. If `False`, uses kaiming initialization.
+
+Notes:
+- `config_D_E` does not support `"lora"`.
+- `target_modules` can be omitted for supported model types (PEFT default mappings are used).
+
+## GloraModel
+
+[[autodoc]] tuners.glora.model.GloraModel
+
+- Wraps a base model and injects GLoRA adapters into the specified modules.
+- Supports multiple adapters, adapter switching, merging/unmerging, and mixed-batch inference.
+- Use `set_adapter`, `merge_and_unload`, and related methods for adapter management.
+
+## GloraLayer and GloraLinear
+
+[[autodoc]] tuners.glora.layer.GloraLayer
+[[autodoc]] tuners.glora.layer.GloraLinear
+
+- `GloraLayer` is the core logic for generalized low-rank adaptation, supporting multiple adapters and flexible path configs.
+- `GloraLinear` is a drop-in replacement for `nn.Linear` with GLoRA support.
+- GLoRA currently supports plain `torch.nn.Linear` base layers.
+
+## Example Usage
+
+```python
+from transformers import AutoModelForCausalLM
+from peft import GloraConfig, get_peft_model
+
+model = AutoModelForCausalLM.from_pretrained("your-model-id")
+glora_config = GloraConfig(
+    r=8,
+    target_modules=["q_proj", "v_proj"],
+    config_A_B="lora",
+    config_C="vector",
+    config_D_E="constant",
+    task_type="CAUSAL_LM",
+)
+model = get_peft_model(model, glora_config)
+model.print_trainable_parameters()
+
+# Switch adapters, merge, etc.
+model.set_adapter("default")
+model.merge_and_unload()
+```
+
+## Notes
+- GLoRA is a superset of LoRA: setting all paths to "lora" recovers standard LoRA.
+- You can use different path types for A/B/C/D/E to experiment with new adaptation strategies.
+- GLoRA supports all standard PEFT adapter management features (add, delete, switch, merge, etc).
+
+## See Also
+- [Adapter conceptual guide](../conceptual_guides/adapter.md)
+- [LoRA reference](./lora.md)
+- [Paper: https://huggingface.co/papers/2306.07967](https://huggingface.co/papers/2306.07967)
diff --git a/docs/source/package_reference/gralora.md b/docs/source/package_reference/gralora.md
new file mode 100644
index 0000000..84e75f3
--- /dev/null
+++ b/docs/source/package_reference/gralora.md
@@ -0,0 +1,50 @@
+# GraLoRA
+
+[**Granular Low-Rank Adaptation (GraLoRA)**](https://huggingface.co/papers/2505.20355) is a PEFT method designed to enhance the **expressivity** of low-rank adaptation while improving **robustness to outlier** activations, based on insights from well-known issues in quantization.
+
+![GraLoRA Overview](https://github.com/SqueezeBits/GraLoRA/raw/main/figure/gralora_overview.png)
+
+Unlike standard LoRA, which applies a single low-rank adapter across the entire feature space, GraLoRA introduces a structured and fine-grained adaptation scheme. It divides the adaptation space into a grid of $𝑘^2$ smaller, independent adapter pairs, each responsible for a localized subset of the input and output dimensions. As a result, each adapter operates on a subspace that is $k$ times smaller in both dimensions than the original LoRA adapter.
+
+This granular decomposition enables spatially localized and context-aware updates, effectively increasing representational capacity without additional parameters or computational cost. By isolating the influence of extreme activations within smaller subspaces, GraLoRA mitigates gradient distortion and preserves inter-channel balance during adaptation.
+
+---
+
+The abstract from the paper is:
+
+*Low-Rank Adaptation (LoRA) is a popular method for parameter-efficient fine-
+tuning (PEFT) of generative models, valued for its simplicity and effectiveness.
+Despite recent enhancements, LoRA still suffers from a fundamental limitation:
+overfitting when the bottleneck is widened. It performs best at ranks 32–64, yet its
+accuracy stagnates or declines at higher ranks, still falling short of full fine-tuning
+(FFT) performance. We identify the root cause as LoRA’s structural bottleneck,
+which introduces gradient entanglement to the unrelated input channels and distorts
+gradient propagation. To address this, we introduce a novel structure, Granular
+Low-Rank Adaptation (GraLoRA) that partitions weight matrices into sub-blocks,
+each with its own low-rank adapter. With negligible computational or storage cost,
+GraLoRA overcomes LoRA’s limitations, effectively increases the representational
+capacity, and more closely approximates FFT behavior. Experiments on code
+generation, commonsense reasoning, mathematical reasoning, general language
+understanding, and image generation benchmarks show that GraLoRA consistently
+outperforms LoRA and other baselines, achieving up to +8.5% absolute gain in
+Pass@1 on HumanEval+. These improvements hold across model sizes and rank
+settings, making GraLoRA a scalable and robust solution for PEFT.*
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=GRALORA"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+# API
+
+## GraloraConfig
+
+[[autodoc]] tuners.gralora.config.GraloraConfig
+
+## GraloraModel
+
+[[autodoc]] tuners.gralora.model.GraloraModel
diff --git a/docs/source/package_reference/helpers.md b/docs/source/package_reference/helpers.md
new file mode 100644
index 0000000..85b3117
--- /dev/null
+++ b/docs/source/package_reference/helpers.md
@@ -0,0 +1,41 @@
+<!--⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+-->
+
+# Helper methods
+
+A collection of helper functions for PEFT.
+
+## Checking if a model is a PEFT model
+
+[[autodoc]] helpers.check_if_peft_model
+    - all
+
+## Temporarily Rescaling Adapter Scale in LoraLayer Modules
+
+[[autodoc]] helpers.rescale_adapter_scale
+    - all
+
+## Context manager to disable input dtype casting in the `forward` method of LoRA layers
+
+[[autodoc]] helpers.disable_input_dtype_casting
+    - all
+
+## Context manager to enable DoRA caching (faster at inference time but requires more memory)
+
+[[autodoc]] helpers.DoraCaching
+    - all
+
+## KappaTune target selection
+
+`KappaTuneSelector` and `find_kappa_target_modules` implement a general target selection process from the [KappaTune paper](https://arxiv.org/abs/2506.16289). 
+
+The method identifies modules with higher flexibility (higher output differential entropy) and lower specialization (lower sensitivity to specific input directions).
+
+These properties make the selected modules good candidates for mitigating catastrophic forgetting in any adaptation method that adds trainable parameters, including LoRA, DoRA, LoHa, AdaLoRA, and even direct fine-tuning of the original weights.
+
+[[autodoc]] helpers.KappaTuneSelector
+    - all
+
+[[autodoc]] helpers.find_kappa_target_modules
+    - all
diff --git a/docs/source/package_reference/hira.md b/docs/source/package_reference/hira.md
new file mode 100644
index 0000000..96082a7
--- /dev/null
+++ b/docs/source/package_reference/hira.md
@@ -0,0 +1,89 @@
+# HiRA
+
+High-Rank Adaptation ([HiRA](https://openreview.net/pdf?id=TwJrTz9cRS)) is a PEFT method that extends the LoRA approach by applying an element-wise modulation on the original weight matrix. Instead of adding a low-rank update directly, HiRA computes:
+
+$$
+W' = W_0 + W_0 \odot (B A)
+$$
+
+where $W_0$ is the base weight, and $A, B$ are low-rank factors with rank $r \ll \min(	\text{in_features}, \text{out_features})$. This formulation allows HiRA to adapt existing weights with a multiplicative, input-dependent modulation, often improving fine-tuning efficiency on downstream tasks.
+
+The abstract from the HiRA paper is:
+
+> *We propose Hadamard High-Rank Adaptation (HiRA), a parameter-efficient fine-tuning (PEFT) method that enhances the adaptability of Large Language Models (LLMs). While Low-rank Adaptation (LoRA) is widely used to reduce resource demands, its low-rank updates may limit its expressiveness for new tasks. HiRA addresses this by using a Hadamard product to retain high-rank update parameters, improving the model capacity. Empirically, HiRA outperforms LoRA and its variants on several tasks, with extensive ablation studies validating its effectiveness.*
+
+
+## Examples
+
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from peft import get_peft_model
+from peft.tuners.hira import HiraConfig
+
+# Example 1: HiRA on opt-125m for causal language modeling
+model_id = "facebook/opt-125m"
+base_model = AutoModelForCausalLM.from_pretrained(model_id)
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+# Define HiRA configuration: apply to the MLP dense layers in each transformer block
+hira_config = HiraConfig(
+    r=32,
+    target_modules=["k_proj", "q_proj", "v_proj", "fc1", "fc2"],
+    hira_dropout=0.0,
+    init_weights=True,
+)
+peft_model = get_peft_model(base_model, hira_config)
+
+peft_model.print_trainable_parameters()
+# trainable params: 4,718,592 || all params: 129,957,888 || trainable%: 3.6309
+```
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=HIRA"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+## Citation:
+
+If you found HiRA is useful, please cite HiRA as:
+```
+@inproceedings{
+huang2025hira,
+title={Hi{RA}: Parameter-Efficient Hadamard High-Rank Adaptation for Large Language Models},
+author={Qiushi Huang and Tom Ko and Zhan Zhuang and Lilian Tang and Yu Zhang},
+booktitle={The Thirteenth International Conference on Learning Representations},
+year={2025},
+url={https://openreview.net/forum?id=TwJrTz9cRS}
+}
+```
+
+# API
+
+## HiraConfig
+
+[[autodoc]] tuners.hira.config.HiraConfig
+
+## Core Layers
+
+### HiraLayer
+
+[[autodoc]] tuners.hira.layer.HiraLayer
+
+### Linear Adapter
+
+[[autodoc]] tuners.hira.layer.Linear
+
+### Embedding Adapter
+
+[[autodoc]] tuners.hira.layer.Embedding
+
+### Convolutional Adapters
+
+[[autodoc]] tuners.hira.layer.Conv1d [[autodoc]] tuners.hira.layer.Conv2d [[autodoc]] tuners.hira.layer.ConvNd
+
+
+
diff --git a/docs/source/package_reference/hotswap.md b/docs/source/package_reference/hotswap.md
new file mode 100644
index 0000000..4cd7c41
--- /dev/null
+++ b/docs/source/package_reference/hotswap.md
@@ -0,0 +1,80 @@
+<!--⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+-->
+
+# Hotswapping adapters
+
+The idea of hotswapping an adapter is the following: We can already load multiple adapters, e.g. two LoRAs, at the same time. But sometimes, we want to load one LoRA and then replace its weights in-place with the LoRA weights of another adapter. This is now possible the `hotswap_adapter` function.
+
+In general, this should be faster than deleting one adapter and loading the adapter in its place, which would be the how to achieve the same final outcome without hotswapping. Another advantage of hotswapping is that it prevents re-compilation in case the PEFT model is already compiled using `torch.compile`. This can save quite a lot of time.
+
+## Example without `torch.compile`
+
+```python
+import torch
+from transformers import AutoModelForCausalLM
+from peft import PeftModel
+from peft.utils.hotswap import hotswap_adapter
+
+model_id = ...
+inputs = ...
+device = ...
+model = AutoModelForCausalLM.from_pretrained(model_id).to(device)
+
+# load lora 0
+model = PeftModel.from_pretrained(model, <path-adapter-0>)
+with torch.inference_mode():
+    output_adapter_0 = model(inputs)
+
+# replace the "default" lora adapter with the new one
+hotswap_adapter(model, <path-adapter-1>, adapter_name="default", torch_device=device)
+with torch.inference_mode():
+    output_adapter_1 = model(inputs).logits
+```
+
+## Example with `torch.compile`
+
+```python
+import torch
+from transformers import AutoModelForCausalLM
+from peft import PeftModel
+from peft.utils.hotswap import hotswap_adapter, prepare_model_for_compiled_hotswap
+
+model_id = ...
+inputs = ...
+device = ...
+max_rank = ...  # maximum rank among all LoRA adapters that will be used
+model = AutoModelForCausalLM.from_pretrained(model_id).to(device)
+
+# load lora 0
+model = PeftModel.from_pretrained(model, <path-adapter-0>)
+# Prepare the model to allow hotswapping even if ranks/scalings of 2nd adapter differ.
+# You can skip this step if all ranks and scalings are identical.
+prepare_model_for_compiled_hotswap(model, target_rank=max_rank)
+model = torch.compile(model)
+with torch.inference_mode():
+    output_adapter_0 = model(inputs)
+
+# replace the "default" lora adapter with the new one
+hotswap_adapter(model, <path-adapter-1>, adapter_name="default", torch_device=device)
+with torch.inference_mode():
+    output_adapter_1 = model(inputs).logits
+```
+
+Note that if you want to hotswap weights that were added through `target_parameters`, i.e. that directly target an `nn.Parameter`, re-compilation and/or graph breaks cannot be prevented. Therefore, it is recommended to avoid using `target_parameters` together with compiled models and hotswapping.
+
+## Caveats
+
+Hotswapping works with transformers models and diffusers models. However, there are some caveats:
+
+- Right now, only LoRA is properly supported.
+- It only works for the same PEFT method, so no swapping LoRA and LoHa, for example.
+- The adapter that is being swapped in must target the same layers as the previous adapter or a subset of those layers. It cannot target new layers. Therefore, if possible, start with the adapter that targets most layers.
+
+## API
+
+[[autodoc]] utils.hotswap.hotswap_adapter
+    - all
+
+[[autodoc]] utils.hotswap.hotswap_adapter_from_state_dict
+    - all
diff --git a/docs/source/package_reference/hra.md b/docs/source/package_reference/hra.md
new file mode 100644
index 0000000..59a3536
--- /dev/null
+++ b/docs/source/package_reference/hra.md
@@ -0,0 +1,40 @@
+<!--Copyright 2024 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# Bridging The Gap between Low-rank and Orthogonal Adaptation via Householder Reflection Adaptation (HRA)
+
+<div class="flex justify-center">
+    <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/peft/hra.png"/>
+</div>
+<small><a href="https://huggingface.co/papers/2405.17484">Bridging The Gap between Low-rank and Orthogonal Adaptation via Householder Reflection Adaptation</a></small>
+
+[HRA](https://huggingface.co/papers/2405.17484) provides a new perspective connecting LoRA to OFT, which means it can harness the advantages of both strategies, by leveraging [Householder reflections](https://en.wikipedia.org/wiki/Householder_transformation) to reduce parameters and computation costs while penalizing the loss of pre-training knowledge. It consistently achieves better performance with fewer trainable parameters and outperforms state-of-the-art adapters across different models, including large language models (LLMs) and conditional image generators.
+
+HRA constructs a chain of `r` trainable Householder reflections (HRs). Because the Householder reflection matrix is an orthogonal matrix and the product of orthogonal matrices is also an orthogonal matrix, HRA satisfies the theoretical guarantee of Orthogonal Finetuning (OFT). Meanwhile, HRA can also be viewed as a low-rank fine-tuning adapter. The higher `r`, the more trainable parameters, resulting in a larger model capacity and better performance. Besides, due to the chain structure, the orthogonality of HR planes impacts the capacity and regularity of HRA. To achieve a trade-off between the model capacity and regularity, an orthogonality regularizer of the HR planes is added to the loss function. The weight \\(\lambda\\) can control the strength of the regularizer.
+
+The abstract from the paper is:
+
+> While following different technical routes, both low-rank and orthogonal adaptation techniques can efficiently adapt large-scale pre-training models in specific tasks or domains based on a small piece of trainable parameters. In this study, we bridge the gap between these two techniques, proposing a simple but effective adaptation method based on Householder reflections. Given a pre-trained model, our method fine-tunes its layers by multiplying each frozen weight matrix with an orthogonal matrix constructed by a chain of learnable Householder reflections (HRs). This HR-based orthogonal fine-tuning is equivalent to an adaptive low-rank adaptation. Moreover, we show that the orthogonality of the reflection planes corresponding to the HRs impacts the model capacity and regularity. The analysis motivates us to regularize the orthogonality of the HRs, leading to different implementations of the proposed Householder reflection adaptation (HRA) method. Compared with state-of-the-art methods, HRA achieves superior performance with fewer learnable parameters when adapting large language models and conditional image generators. The code is available at [peft](https://github.com/huggingface/peft/tree/main/src/peft/tuners/hra) and [HRA](https://github.com/DaShenZi721/HRA).
+
+# API
+
+## HRAConfig
+
+[[autodoc]] tuners.hra.config.HRAConfig
+
+## HRAModel
+
+[[autodoc]] tuners.hra.model.HRAModel
diff --git a/docs/source/package_reference/ia3.md b/docs/source/package_reference/ia3.md
new file mode 100644
index 0000000..76c6cda
--- /dev/null
+++ b/docs/source/package_reference/ia3.md
@@ -0,0 +1,79 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# IA3
+
+<div class="flex justify-center">
+    <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/peft/ia3.png"/>
+</div>
+<small>IA3 introduces three vectors, lv, lk and lff to scale value, key and feed-forward activations <a href="https://hf.co/papers/2205.05638">(image source)</a>.</small>
+
+Infused Adapter by Inhibiting and Amplifying Inner Activations, or [IA3](https://hf.co/papers/2205.05638), is a method that adds three learned vectors to rescale the keys and values of the self-attention and encoder-decoder attention layers, and the intermediate activation of the position-wise feed-forward network.
+
+The abstract from the paper is:
+
+*Few-shot in-context learning (ICL) enables pre-trained language models to perform a previously-unseen task without any gradient-based training by feeding a small number of training examples as part of the input. ICL incurs substantial computational, memory, and storage costs because it involves processing all of the training examples every time a prediction is made. Parameter-efficient fine-tuning (PEFT) (e.g. adapter modules, prompt tuning, sparse update methods, etc.) offers an alternative paradigm where a small set of parameters are trained to enable a model to perform the new task. In this paper, we rigorously compare few-shot ICL and PEFT and demonstrate that the latter offers better accuracy as well as dramatically lower computational costs. Along the way, we introduce a new PEFT method called (IA)^3 that scales activations by learned vectors, attaining stronger performance while only introducing a relatively tiny amount of new parameters. We also propose a simple recipe based on the T0 model called T-Few that can be applied to new tasks without task-specific tuning or modifications. We validate the effectiveness of T-Few on completely unseen tasks by applying it to the RAFT benchmark, attaining super-human performance for the first time and outperforming the state-of-the-art by 6% absolute. All of the code used in our experiments is publicly available*.
+
+To make fine-tuning more efficient, IA3 (Infused Adapter by Inhibiting and Amplifying Inner Activations)
+rescales inner activations with learned vectors. These learned vectors are injected in the attention and feedforward modules
+in a typical transformer-based architecture. These learned vectors are the only trainable parameters during fine-tuning, and thus the original
+weights remain frozen. Dealing with learned vectors (as opposed to learned low-rank updates to a weight matrix like LoRA)
+keeps the number of trainable parameters much smaller.
+
+Being similar to [LoRA](./lora), IA3 carries many of the same advantages:
+
+* IA3 makes fine-tuning more efficient by drastically reducing the number of trainable parameters. (For T0, an IA3 model only has about 0.01% trainable parameters, while even LoRA has > 0.1%)
+* The original pre-trained weights are kept frozen, which means you can have multiple lightweight and portable IA3 models for various downstream tasks built on top of them.
+* Performance of models fine-tuned using IA3 is comparable to the performance of fully fine-tuned models.
+* IA3 does not add any inference latency because adapter weights can be merged with the base model.
+
+In principle, IA3 can be applied to any subset of weight matrices in a neural network to reduce the number of trainable
+parameters. Following the authors' implementation, IA3 weights are added to the key, value and feedforward layers
+of a Transformer model. To be specific, for transformer models, IA3 weights are added to the outputs of key and value layers, and to the input of the second feedforward layer
+in each transformer block.
+
+Given the target layers for injecting IA3 parameters, the number of trainable parameters
+can be determined based on the size of the weight matrices.
+
+## Usage
+
+For the task of sequence classification, one can initialize the IA3 config for a Llama model as follows:
+
+```py
+peft_config = IA3Config(
+    task_type=TaskType.SEQ_CLS, target_modules=["k_proj", "v_proj", "down_proj"], feedforward_modules=["down_proj"]
+)
+```
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=IA3"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+
+# API
+
+## IA3Config
+
+[[autodoc]] tuners.ia3.config.IA3Config
+
+## IA3Model
+
+[[autodoc]] tuners.ia3.model.IA3Model
diff --git a/docs/source/package_reference/layernorm_tuning.md b/docs/source/package_reference/layernorm_tuning.md
new file mode 100644
index 0000000..f0544df
--- /dev/null
+++ b/docs/source/package_reference/layernorm_tuning.md
@@ -0,0 +1,45 @@
+<!--Copyright 2024 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# LayerNorm Tuning
+
+LayerNorm Tuning ([LN Tuning](https://huggingface.co/papers/2312.11420)) is a PEFT method that only fine-tunes the parameters of the LayerNorm layers in a model.
+The paper has tested the performance of this method on large language models and has shown that it can achieve strong performance with a significant reduction in the number of trainable parameters and GPU memory usage.
+However, the method is not limited to language models and can be applied to any model that uses LayerNorm layers.
+In this implementation, the default is that all layernorm layers inside a model is finetuned, but it could be used to target other layer types such as `MLP` or `Attention` layers, this can be done by specifying the `target_modules` in the `LNTuningConfig`.
+
+The abstract from the paper is:
+
+*This paper introduces an efficient strategy to transform Large Language Models (LLMs) into Multi-Modal Large Language Models (MLLMs). By conceptualizing this transformation as a domain adaptation process, i.e., transitioning from text understanding to embracing multiple modalities, we intriguingly note that, within each attention block, tuning LayerNorm suffices to yield strong performance. Moreover, when benchmarked against other tuning approaches like full parameter finetuning or LoRA, its benefits on efficiency are substantial. For example, when compared to LoRA on a 13B model scale, performance can be enhanced by an average of over 20% across five multi-modal tasks, and meanwhile, results in a significant reduction of trainable parameters by 41.9% and a decrease in GPU memory usage by 17.6%. On top of this LayerNorm strategy, we showcase that selectively tuning only with conversational data can improve efficiency further. Beyond these empirical outcomes, we provide a comprehensive analysis to explore the role of LayerNorm in adapting LLMs to the multi-modal domain and improving the expressive power of the model.*
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=LN_TUNING"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+# API
+
+## LNTuningConfig
+
+[[autodoc]] tuners.ln_tuning.config.LNTuningConfig
+
+## LNTuningModel
+
+[[autodoc]] tuners.ln_tuning.model.LNTuningModel
diff --git a/docs/source/package_reference/lily.md b/docs/source/package_reference/lily.md
new file mode 100644
index 0000000..c971930
--- /dev/null
+++ b/docs/source/package_reference/lily.md
@@ -0,0 +1,52 @@
+<!--Copyright 2026 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# Lily: Low-Rank Interconnected Adaptation across Layers
+
+[Lily](https://huggingface.co/papers/2407.09946) is a parameter-efficient fine-tuning technique that introduces cross-layer weight sharing for adapter matrices. Instead of learning an independent AB pair per layer as in LoRA, Lily uses **locally shared A adapters** (each A is shared across a block of `stride_A` consecutive layers) and **globally shared B experts** (a small pool of `num_B` B adapters is shared across all layers). At each forward pass, a lightweight data-dependent router computes a softmax-weighted combination of the B experts to produce the effective B for that layer and input.
+
+This sharing can reduce the total number of adapter matrices from `2N` (standard LoRA) to `N / stride_A + num_B`, freeing up the parameter budget to use a **much larger rank `r`** — typically `2×`–`4×` what you would use in LoRA. Higher rank and better interconnectivity increase the effective rank of the weight update `ΔW = A × combined_B`, leading to better adaptation performance.
+
+Because the B combination is **data-dependent** (the router weights depend on the input activations at runtime), `merge` and `unmerge` are **not supported**. If weight merging is required for your deployment, consider other methods such as LoRA instead.
+
+Lily currently has the following additional constraints:
+- Only `nn.Linear` layers are supported.
+- Quantized layers are not supported.
+
+If these constraints don't work for your use case, consider other methods instead.
+
+The abstract from the paper is:
+
+> Low-rank adaptation (LoRA) is a widely used parameter-efficient fine-tuning (PEFT) method that learns weight updates ΔW = AB for pretrained weights W through low-rank adapters A and B. While LoRA ensures hardware efficiency, its low-rank weight updates limit adaptation performance. In this paper, we propose low-rank interconnected adaptation across layers (Lily), a novel PEFT method that introduces an interconnected framework with locally shared A and globally shared B experts. This structure eliminates redundant per-layer AB pairs, enabling higher-rank ΔW with equal or fewer parameters. To enhance expressiveness, we use data-dependent routers to determine A-B interconnections, preventing B experts from converging to the same behavior and improving representational power across domains. Experiments across modalities, architectures, and model sizes demonstrate Lily's superior performance and efficiency.
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=LILY"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+# API
+
+## LilyConfig
+
+[[autodoc]] tuners.lily.config.LilyConfig
+
+## LilyModel
+
+[[autodoc]] tuners.lily.model.LilyModel
diff --git a/docs/source/package_reference/llama_adapter.md b/docs/source/package_reference/llama_adapter.md
new file mode 100644
index 0000000..a891fa0
--- /dev/null
+++ b/docs/source/package_reference/llama_adapter.md
@@ -0,0 +1,47 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# Llama-Adapter
+
+<div class="flex justify-center">
+    <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/peft/llama-adapter.png"/>
+</div>
+<small><a href="https://hf.co/papers/2303.16199">LLaMA-Adapter: Efficient Fine-tuning of Language Models with Zero-init Attention</a></small>
+
+[Llama-Adapter](https://hf.co/papers/2303.16199) is a PEFT method specifically designed for turning Llama into an instruction-following model. The Llama model is frozen and only a set of adaptation prompts prefixed to the input instruction tokens are learned. Since randomly initialized modules inserted into the model can cause the model to lose some of its existing knowledge, Llama-Adapter uses zero-initialized attention with zero gating to progressively add the instructional prompts to the model.
+
+The abstract from the paper is:
+
+*We present LLaMA-Adapter, a lightweight adaption method to efficiently fine-tune LLaMA into an instruction-following model. Using 52K self-instruct demonstrations, LLaMA-Adapter only introduces 1.2M learnable parameters upon the frozen LLaMA 7B model, and costs less than one hour for fine-tuning on 8 A100 GPUs. Specifically, we adopt a set of learnable adaption prompts, and prepend them to the input text tokens at higher transformer layers. Then, a zero-init attention mechanism with zero gating is proposed, which adaptively injects the new instructional cues into LLaMA, while effectively preserves its pre-trained knowledge. With efficient training, LLaMA-Adapter generates high-quality responses, comparable to Alpaca with fully fine-tuned 7B parameters. Furthermore, our approach can be simply extended to multi-modal input, e.g., images, for image-conditioned LLaMA, which achieves superior reasoning capacity on ScienceQA. We release our code at https://github.com/ZrrSkywalker/LLaMA-Adapter*.
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=ADAPTION_PROMPT"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+# API
+
+## AdaptionPromptConfig
+
+[[autodoc]] tuners.adaption_prompt.config.AdaptionPromptConfig
+
+## AdaptionPromptModel
+
+[[autodoc]] tuners.adaption_prompt.model.AdaptionPromptModel
diff --git a/docs/source/package_reference/loha.md b/docs/source/package_reference/loha.md
new file mode 100644
index 0000000..3dec6a0
--- /dev/null
+++ b/docs/source/package_reference/loha.md
@@ -0,0 +1,90 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# LoHa
+
+<div class="flex justify-center">
+    <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/peft/lora.png"/>
+</div>
+<small><a href="https://hf.co/papers/2103.10385">Navigating Text-To-Image Customization: From LyCORIS Fine-Tuning to Model Evaluation</a></small>
+
+Low-Rank Hadamard Product ([LoHa](https://huggingface.co/papers/2108.06098)), is similar to LoRA except it approximates the large weight matrix with more low-rank matrices and combines them with the Hadamard product. This method is even more parameter-efficient than LoRA and achieves comparable performance. LoHa was originally proposed for federated learning (FedPara) but works well as a general-purpose PEFT method, and is especially popular for fine-tuning image generation models such as Stable Diffusion.
+
+> **Note:** LoHa is part of the [LyCORIS](./adapter_utils) family of adapters. Its close relative [LoKr](./lokr) uses the Kronecker product instead of the Hadamard product.
+
+The abstract from the paper is:
+
+*In this work, we propose a communication-efficient parameterization, FedPara, for federated learning (FL) to overcome the burdens on frequent model uploads and downloads. Our method re-parameterizes weight parameters of layers using low-rank weights followed by the Hadamard product. Compared to the conventional low-rank parameterization, our FedPara method is not restricted to low-rank constraints, and thereby it has a far larger capacity. This property enables to achieve comparable performance while requiring 3 to 10 times lower communication costs than the model with the original layers, which is not achievable by the traditional low-rank methods. The efficiency of our method can be further improved by combining with other efficient FL optimizers. In addition, we extend our method to a personalized FL application, pFedPara, which separates parameters into global and local ones. We show that pFedPara outperforms competing personalized FL methods with more than three times fewer parameters.*
+
+Low-rank decomposition can impact performance because the weight updates are limited to the low-rank space, which can constrain a model's expressiveness. However, you don't necessarily want to use a larger rank because it increases the number of trainable parameters. To address this, LoHa was applied to diffusion models where the ability to generate diverse images is an important consideration. LoHa should also work with general model types, but support for embedding layers isn't currently implemented in PEFT.
+
+LoHa uses the [Hadamard product](https://en.wikipedia.org/wiki/Hadamard_product_(matrices)) (element-wise product) instead of the matrix product. $\Delta W$ is represented by four smaller matrices instead of two - like in LoRA - and each pair of these low-rank matrices are combined with the Hadamard product. As a result, $\Delta W$ can have the same number of trainable parameters but a higher rank and expressivity.
+
+## When to use LoHa
+
+LoHa is a good choice when:
+
+- You are fine-tuning **image generation models** (Stable Diffusion UNet or text encoder), where it is most widely used.
+- You want **higher effective rank** than LoRA for the same number of trainable parameters, since the Hadamard product of two low-rank matrices spans a larger subspace than a single low-rank product.
+- You want to **combine different PEFT methods** at inference time using [`PeftMixedModel`](./peft_model#peft.PeftMixedModel), for example LoHa together with LoKr.
+
+LoHa supports linear and Conv2d layers. For tasks that additionally require embedding layer adaptation, consider [LoRA](./lora) instead.
+
+## Usage
+
+```python
+from diffusers import StableDiffusionPipeline
+from peft import LoHaConfig, get_peft_model
+
+config_unet = LoHaConfig(
+    r=8,
+    alpha=8,
+    target_modules=[
+        "to_k",
+        "to_q",
+        "to_v",
+        "to_out.0",
+        "proj_in",
+        "proj_out",
+    ],
+    rank_dropout=0.0,
+    module_dropout=0.0,
+    use_effective_conv2d=True,
+)
+
+pipeline = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
+pipeline.unet = get_peft_model(pipeline.unet, config_unet)
+pipeline.unet.print_trainable_parameters()
+```
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=LOHA"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+# API
+
+## LoHaConfig
+
+[[autodoc]] tuners.loha.config.LoHaConfig
+
+## LoHaModel
+
+[[autodoc]] tuners.loha.model.LoHaModel
diff --git a/docs/source/package_reference/lokr.md b/docs/source/package_reference/lokr.md
new file mode 100644
index 0000000..68a54b9
--- /dev/null
+++ b/docs/source/package_reference/lokr.md
@@ -0,0 +1,64 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# LoKr
+
+<div class="flex justify-center">
+    <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/peft/lora.png"/>
+</div>
+<small><a href="https://hf.co/papers/2103.10385">Navigating Text-To-Image Customization: From LyCORIS Fine-Tuning to Model Evaluation</a></small>
+
+Low-Rank Kronecker Product ([LoKr](https://hf.co/papers/2309.14859)), is a LoRA-variant method that approximates the large weight matrix with two low-rank matrices and combines them with the [Kronecker product](https://en.wikipedia.org/wiki/Kronecker_product). LoKr also provides an optional third low-rank matrix to provide better control during fine-tuning. By expresseing the weight update matrix as a decomposition of a Kronecker product, creating a block matrix, LoKr is able to preserve the rank of the original weight matrix. The size of the smaller matrices are determined by its *rank* or `r`. Another benefit of the Kronecker product is that it can be vectorized by stacking the matrix columns. This can speed up the process because you're avoiding fully reconstructing ∆W.
+
+The abstract from the paper is:
+
+*Text-to-image generative models have garnered immense attention for their ability to produce high-fidelity images from text prompts. Among these, Stable Diffusion distinguishes itself as a leading open-source model in this fast-growing field. However, the intricacies of fine-tuning these models pose multiple challenges from new methodology integration to systematic evaluation. Addressing these issues, this paper introduces LyCORIS [Lora beYond Conventional methods, Other Rank adaptation Implementations for Stable diffusion](https://github.com/KohakuBlueleaf/LyCORIS), an open-source library that offers a wide selection of fine-tuning methodologies for Stable Diffusion. Furthermore, we present a thorough framework for the systematic assessment of varied fine-tuning techniques. This framework employs a diverse suite of metrics and delves into multiple facets of fine-tuning, including hyperparameter adjustments and the evaluation with different prompt types across various concept categories. Through this comprehensive approach, our work provides essential insights into the nuanced effects of fine-tuning parameters, bridging the gap between state-of-the-art research and practical application.*
+
+## Usage
+
+```py
+from peft import LoKrConfig, get_peft_model
+
+config = LoKrConfig(
+    r=16,
+    alpha=16,
+    target_modules=["query", "value"],
+    module_dropout=0.1,
+    modules_to_save=["classifier"],
+)
+model = get_peft_model(model, config)
+model.print_trainable_parameters()
+"trainable params: 116,069 || all params: 87,172,042 || trainable%: 0.13314934162033282"
+```
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=LOKR"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+# API
+
+## LoKrConfig
+
+[[autodoc]] tuners.lokr.config.LoKrConfig
+
+## LoKrModel
+
+[[autodoc]] tuners.lokr.model.LoKrModel
diff --git a/docs/source/package_reference/lora.md b/docs/source/package_reference/lora.md
new file mode 100644
index 0000000..2b5e644
--- /dev/null
+++ b/docs/source/package_reference/lora.md
@@ -0,0 +1,1097 @@
+<!--Copyright 2023-present The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# LoRA
+
+> [!TIP]
+> LoRA is one of the most popular PEFT methods and a good starting point if you're just getting started with PEFT. It was originally developed for large language models but it is a tremendously popular training method for diffusion models because of its efficiency and effectiveness.
+
+Low-Rank Adaptation ([LoRA](https://huggingface.co/papers/2106.09685)) is a PEFT method that decomposes a large matrix into two smaller low-rank matrices. This drastically reduces the number of parameters that need to be fine-tuned.
+
+The abstract from the paper is:
+
+*An important paradigm of natural language processing consists of large-scale pre-training on general domain data and adaptation to particular tasks or domains. As we pre-train larger models, full fine-tuning, which retrains all model parameters, becomes less feasible. Using GPT-3 175B as an example -- deploying independent instances of fine-tuned models, each with 175B parameters, is prohibitively expensive. We propose Low-Rank Adaptation, or LoRA, which freezes the pre-trained model weights and injects trainable rank decomposition matrices into each layer of the Transformer architecture, greatly reducing the number of trainable parameters for downstream tasks. Compared to GPT-3 175B fine-tuned with Adam, LoRA can reduce the number of trainable parameters by 10,000 times and the GPU memory requirement by 3 times. LoRA performs on-par or better than fine-tuning in model quality on RoBERTa, DeBERTa, GPT-2, and GPT-3, despite having fewer trainable parameters, a higher training throughput, and, unlike adapters, no additional inference latency. We also provide an empirical investigation into rank-deficiency in language model adaptation, which sheds light on the efficacy of LoRA. We release a package that facilitates the integration of LoRA with PyTorch models and provide our implementations and model checkpoints for RoBERTa, DeBERTa, and GPT-2 at [this https URL](https://github.com/microsoft/LoRA).*
+
+LoRA represents the weight updates $\Delta W$ with two smaller matrices (called *update matrices*) through low-rank decomposition. These new matrices can be trained to adapt to the new data while keeping the overall number of parameters low. The original weight matrix remains frozen and doesn't receive any further updates. To produce the final results, the original and extra adapted weights are combined. You could also merge the adapter weights with the base model to eliminate inference latency.
+
+<div class="flex justify-center">
+    <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/peft/lora_animated.gif"/>
+</div>
+
+This approach has a number of advantages:
+
+* LoRA makes finetuning more efficient by drastically reducing the number of trainable parameters.
+* The original pretrained weights are kept frozen, which means you can have multiple lightweight and portable LoRA models for various downstream tasks built on top of them.
+* LoRA is orthogonal to other parameter-efficient methods and can be combined with many of them.
+* Performance of models finetuned using LoRA is comparable to the performance of fully finetuned models.
+
+In principle, LoRA can be applied to any subset of weight matrices in a neural network to reduce the number of trainable parameters. However, for simplicity and further parameter efficiency, LoRA is typically only applied to the attention blocks in Transformer models - it may be worth targeting other layers as well. The resulting number of trainable parameters in a LoRA model depends on the size of the update matrices, which is determined mainly by the rank `r` and the shape of the original weight matrix.
+
+You can initialize the low-rank matrices with different use-cases in mind - task awareness (CoRDA, EVA), faster convergence (PiSSA), mitigating quantizations (LoftQ) - just to name a few use-cases. Read about the different initializations [below](#initialization). The default initialization is for LoRA to be a no-op, to gradually learn new behavior without interfering much with the existing model.
+
+## Usage
+
+The size of the low-rank update matrices is determined by the *rank* or `r`. A higher rank means the model has more parameters to train, but it also means the model has more learning capacity. In the following example, you'll target the *query* and *value* matrices of the attention blocks. Other important parameters to set are `lora_alpha` (scaling factor), `bias` (whether `none`, `all` or only the LoRA bias parameters should be trained), and `modules_to_save` (the modules apart from the LoRA layers to be trained and saved). All of these parameters - and more - are found in the [`LoraConfig`].
+
+```py
+from peft import LoraConfig, get_peft_model
+
+config = LoraConfig(
+    r=16,
+    lora_alpha=16,
+    target_modules=["query", "value"],
+    lora_dropout=0.1,
+    bias="none",
+    modules_to_save=["classifier"],
+)
+model = get_peft_model(model, config)
+model.print_trainable_parameters()
+"trainable params: 667,493 || all params: 86,543,818 || trainable%: 0.7712775047664294"
+```
+
+
+## Benchmark overview
+
+
+<iframe
+    src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=LORA"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+
+## Initialization
+
+The initialization of LoRA weights is controlled by the parameter `init_lora_weights` in [`LoraConfig`]. By default, PEFT initializes LoRA weights with Kaiming-uniform for weight A and zeros for weight B resulting in an identity transform (same as the reference [implementation](https://github.com/microsoft/LoRA)).
+
+It is also possible to pass `init_lora_weights="gaussian"`. As the name suggests, this initializes weight A with a Gaussian distribution and zeros for weight B (this is how [Diffusers](https://huggingface.co/docs/diffusers/index) initializes LoRA weights).
+
+```py
+from peft import LoraConfig
+
+config = LoraConfig(init_lora_weights="gaussian", ...)
+```
+
+There is also an option to set `init_lora_weights=False` which is useful for debugging and testing. This should be the only time you use this option. When choosing this option, the LoRA weights are initialized such that they do *not* result in an identity transform.
+
+```py
+from peft import LoraConfig
+
+config = LoraConfig(init_lora_weights=False, ...)
+```
+
+<hfoptions id="initializations">
+<hfoption id="PiSSA">
+[PiSSA](https://huggingface.co/papers/2404.02948) initializes the LoRA adapter using the principal singular values and singular vectors. This straightforward modification allows PiSSA to converge more rapidly than LoRA and ultimately attain superior performance. Moreover, PiSSA reduces the quantization error compared to QLoRA, leading to further enhancements.
+
+Configure the initialization method to "pissa", which may take several minutes to execute SVD on the pre-trained model:
+```python
+from peft import LoraConfig
+config = LoraConfig(init_lora_weights="pissa", ...)
+```
+Alternatively, execute fast SVD, which takes only a few seconds. The number of iterations determines the trade-off between the error and computation time:
+```python
+lora_config = LoraConfig(init_lora_weights="pissa_niter_[number of iters]", ...)
+```
+For detailed instruction on using PiSSA, please follow [these instructions](https://github.com/huggingface/peft/tree/main/examples/pissa_finetuning).
+</hfoption>
+
+
+<hfoption id="MiCA">
+[MiCA](https://arxiv.org/abs/2604.01694) (Minor Component Adaptation) is a complement to PiSSA: instead of initializing from the *principal* singular components, MiCA uses the *minor* ones. Concretely, with `W = U Σ V^T`, MiCA sets `B = U[:, -r:]` (the `r` left singular vectors associated with the smallest singular values) and `A = 0`. During training, only `A` is updated; `B` is frozen. The intuition is that the minor singular directions are largely unused by the pretrained task and therefore offer a more "plastic" subspace for injecting new knowledge while preserving pretrained capabilities.
+
+Because `A == 0` at init, the adapter contribution `B · A == 0` and the model output is preserved exactly at step 0 — no residual subtraction on the base weight is needed (unlike PiSSA). Since only `A` is trainable, the trainable parameter count for matching `r` is roughly half that of LoRA.
+
+```python
+from peft import LoraConfig
+config = LoraConfig(init_lora_weights="mica", r=16, target_modules=["q_proj", "v_proj"], ...)
+```
+
+MiCA currently supports `nn.Linear` and `nn.Embedding` target modules. The chosen rank must satisfy `r <= min(in_features, out_features)` for linear layers and `r <= min(num_embeddings, embedding_dim)` for embedding layers. For detailed usage, see [these instructions](https://github.com/huggingface/peft/tree/main/examples/mica_finetuning).
+
+MiCA is primarily intended for continued pretraining / domain-adaptive pretraining. In that setting, use the base model, not an instruction- or chat-tuned checkpoint, for the SVD initialization and MiCA training. After training, merge the adapter into the base model weights and use the resulting adapted base model as the starting point for subsequent instruction/chat tuning.
+</hfoption>
+
+<hfoption id="CorDA">
+[CorDA](https://huggingface.co/papers/2406.05223) builds task-aware LoRA adapters from weight decomposition oriented by the context of downstream task to learn (instruction-previewed mode, IPM) or world knowledge to maintain (knowledge-preserved mode, KPM).  The KPM not only achieves better performance than LoRA on fine-tuning tasks, but also mitigates the catastrophic forgetting of pre-trained world knowledge.  When preserving pre-trained knowledge is not a concern, the IPM is favored because it can further accelerate convergence and enhance the fine-tuning performance.
+
+You need to configure the initialization method to "corda", and specify the mode of IPM or KPM and the dataset to collect covariance matrices.
+
+```py
+@torch.no_grad()
+def run_model():
+    # Assume `model` and `dataset` is in context...
+    model.eval()
+    for batch in dataset:
+        model(**batch)
+
+
+corda_config = CordaConfig(
+    corda_method="kpm",
+)
+lora_config = LoraConfig(
+    init_lora_weights="corda",
+    corda_config=corda_config,
+)
+preprocess_corda(model, lora_config, run_model=run_model)
+peft_model = get_peft_model(model, lora_config)
+```
+
+For detailed instruction on using CorDA, please follow [these instructions](https://github.com/huggingface/peft/tree/main/examples/corda_finetuning).
+</hfoption>
+
+<hfoption id="OLoRA">
+[OLoRA](https://huggingface.co/papers/2406.01775) utilizes QR decomposition to initialize the LoRA adapters. OLoRA translates the base weights of the model by a factor of their QR decompositions, i.e., it mutates the weights before performing any training on them. This approach significantly improves stability, accelerates convergence speed, and ultimately achieves superior performance.
+
+You just need to pass a single additional option to use OLoRA:
+```python
+from peft import LoraConfig
+config = LoraConfig(init_lora_weights="olora", ...)
+```
+For more advanced usage, please refer to our [documentation](https://github.com/huggingface/peft/tree/main/examples/olora_finetuning).
+</hfoption>
+
+<hfoption id="EVA">
+[EVA](https://huggingface.co/papers/2410.07170) performs SVD on the input activations of each layer and uses the right-singular vectors to initialize LoRA weights. It is therefore a data-driven initialization scheme. Furthermore EVA adaptively allocates ranks across layers based on their "explained variance ratio" - a metric derived from the SVD analysis.
+
+You can use EVA by setting `init_lora_weights="eva"` and defining [`EvaConfig`] in [`LoraConfig`]:
+```python
+from peft import LoraConfig, EvaConfig
+peft_config = LoraConfig(
+    init_lora_weights = "eva",
+    eva_config = EvaConfig(rho = 2.0),
+    ...
+)
+```
+The parameter `rho` (≥ 1.0) determines how much redistribution is allowed. When `rho=1.0` and `r=16`, LoRA adapters are limited to exactly 16 ranks, preventing any redistribution from occurring. A recommended value for EVA with redistribution is 2.0, meaning the maximum rank allowed for a layer is 2r.
+
+It is recommended to perform EVA initialization on an accelerator(e.g. CUDA GPU, Intel XPU) as it is much faster. To optimize the amount of available memory for EVA, you can use the `low_cpu_mem_usage` flag in [`get_peft_model`]:
+```python
+peft_model = get_peft_model(model, peft_config, low_cpu_mem_usage=True)
+```
+Then, call [`initialize_lora_eva_weights`] to initialize the EVA weights (in most cases the dataloader used for eva initialization can be the same as the one used for finetuning):
+```python
+initialize_lora_eva_weights(peft_model, dataloader)
+```
+EVA works out of the box with bitsandbytes. Simply initialize the model with `quantization_config` and call [`initialize_lora_eva_weights`] as usual.
+
+> [!TIP]
+> For further instructions on using EVA, please refer to our [documentation](https://github.com/huggingface/peft/tree/main/examples/eva_finetuning).
+</hfoption>
+
+<hfoption id="LoftQ">
+When quantizing the base model for QLoRA training, consider using the [LoftQ initialization](https://huggingface.co/papers/2310.08659), which has been shown to improve performance when training quantized models. The idea is that the LoRA weights are initialized such that the quantization error is minimized. To use LoftQ, follow [these instructions](https://github.com/huggingface/peft/tree/main/examples/loftq_finetuning).
+
+> [!TIP]
+> Learn more about how PEFT works with quantization and how to use LoftQ in the [Quantization](../developer_guides/quantization) guide.
+</hfoption>
+
+<hfoption id="rsLoRA">
+Another way to initialize [`LoraConfig`] is with the [rank-stabilized LoRA (rsLoRA)](https://huggingface.co/papers/2312.03732) method. The LoRA architecture scales each adapter during every forward pass by a fixed scalar which is set at initialization and depends on the rank `r`. The scalar is given by `lora_alpha/r` in the original implementation, but rsLoRA uses `lora_alpha/math.sqrt(r)` which stabilizes the adapters and increases the performance potential from using a higher `r`.
+
+```py
+from peft import LoraConfig
+
+config = LoraConfig(use_rslora=True, ...)
+```
+</hfoption>
+
+<hfoption id="LoRA-GA">
+[LoRA-GA](https://hf.co/papers/2407.05000) (Low-Rank Adaptation with Gradient Approximation) initializes the adapter
+weights by performing SVD on estimated gradients, so that the weights are aligning closer to full-finetuning for faster
+convergence.
+
+This method requires an initialization function to estimate the gradients
+before beginning the actual training:
+
+```python
+from peft.tuners.lora import preprocess_loraga
+
+def train_step():
+    """Run forward and backward passes for gradient estimation."""
+    dataloader_iter = iter(grad_dataloader)
+    for _ in range(N):
+        batch = next(dataloader_iter)
+        batch = {k: v.to(device) for k, v in batch.items()}
+        outputs = model(**batch)
+        loss = outputs.loss
+        loss.backward()
+
+preprocess_loraga(model, lora_config, train_step)
+```
+
+**Usage Tips**
+
+- **Gradient Estimation**: LoRA-GA requires a gradient estimation phase before model initialization. Use `preprocess_loraga()` with a `train_step` callback to compute gradients over a small number of training batches (typically 64-128 batches).
+
+- **Initialization Strategies**: LoRA-GA supports four direction strategies (`direction`): `"ArBr"`, `"A2rBr"`, `"ArB2r"` (default), and `"random"`, and four scaling strategies (`scale`): `"stable"` (default), `"weight_svd"`, `"gd_scale"`, and `"unit"`. The default combination provides the best balance of convergence speed and stability.
+
+- **Base Weight Modification**: Unlike standard LoRA, LoRA-GA modifies the base model weights during initialization by subtracting a scaled version of the low-rank approximation. This enables better alignment with full fine-tuning gradients. Since base weights are modified, use `save_pretrained()` with the `save_embedding_layers` argument or `save_mutated_as_lora` pattern to properly save the adapter.
+
+- **Computational Overhead**: The gradient estimation adds a small overhead during initialization (typically 1-2 minutes for 64 batches), but this is quickly amortized by faster convergence during training.
+
+- **Compatibility**: LoRA-GA requires full-precision weights and does not support quantized models. Can be combined with other LoRA variants like DoRA.
+</hfoption>
+</hfoptions>
+
+## Training
+
+This section shows how to handle more complex training scenarios instead of only applying a low-rank adapter to the model and feed data.
+
+### QLoRA-style training
+
+The default LoRA settings in PEFT add trainable weights to the query and value layers of each attention block. But [QLoRA](https://hf.co/papers/2305.14314), which adds trainable weights to all the linear layers of a transformer model, can provide performance equal to a fully finetuned model. To apply LoRA to all the linear layers, like in QLoRA, set `target_modules="all-linear"` (easier than specifying individual modules by name which can vary depending on the architecture).
+
+```py
+config = LoraConfig(target_modules="all-linear", ...)
+```
+
+For more information about how to apply quantization to PEFT adapters, refer to the [quantization guide](../developer_guides/quantization).
+
+### Memory efficient Layer Replication with LoRA
+
+An approach used to improve the performance of models is to expand a model by duplicating layers in the model to build a larger model from a pretrained model of a given size. For example increasing a 7B model to a 10B model as described in the [SOLAR](https://huggingface.co/papers/2312.15166) paper. PEFT LoRA supports this kind of expansion in a memory efficient manner that supports further fine-tuning using LoRA adapters attached to the layers post replication of the layers. The replicated layers do not take additional memory as they share the underlying weights so the only additional memory required is the memory for the adapter weights. To use this feature you would create a config with the `layer_replication` argument.
+
+```py
+config = LoraConfig(layer_replication=[[0,4], [2,5]], ...)
+```
+
+Assuming the original model had 5 layers `[0, 1, 2 ,3, 4]`, this would create a model with 7 layers arranged as `[0, 1, 2, 3, 2, 3, 4]`. This follows the [mergekit](https://github.com/arcee-ai/mergekit) pass through merge convention where sequences of layers specified as start inclusive and end exclusive tuples are stacked to build the final model. Each layer in the final model gets its own distinct set of LoRA adapters.
+
+[Fewshot-Metamath-OrcaVicuna-Mistral-10B](https://huggingface.co/abacusai/Fewshot-Metamath-OrcaVicuna-Mistral-10B) is an example of a model trained using this method on Mistral-7B expanded to 10B. The
+[adapter_config.json](https://huggingface.co/abacusai/Fewshot-Metamath-OrcaVicuna-Mistral-10B/blob/main/adapter_config.json) shows a sample LoRA adapter config applying this method for fine-tuning.
+
+### Fine grained control over ranks and alpha (scaling)
+
+By default, all layers targeted with LoRA will have the same rank `r` and the same `lora_alpha` (which determines the LoRA scaling), depending on what was specified in the [`LoraConfig`]. In some cases, however, you may want to indicate different values for different layers. This is possible by passing the `rank_pattern` and `alpha_pattern` arguments to [`LoraConfig`]. These arguments should be dictionaries with the key being the layer name and the value being the rank/alpha value. The keys can be [regular expressions](https://docs.python.org/3/library/re.html) (regex). All LoRA layers that are not explicitly mentioned in `rank_pattern` and `alpha_pattern` will take the default `r` and `lora_alpha` values.
+
+To give an example, let's assume that we have a model with the following structure:
+
+```python
+>>> print(model)
+Outer(
+  (foo): Linear(...)
+  (module): Middle(
+    (foo): Linear(...)
+    (foobar): Linear(...)
+    (module): Inner(
+      (foo): Linear(...)
+      (barfoo): Linear(...)
+    )
+  )
+)
+```
+
+- `rank_pattern={"foo": 42}` will match all 3 `foo` layers. Neither `foobar` nor `barfoo` are matched.
+- `rank_pattern={"^foo": 42}` will only match the `foo` layer of the model, but neither `module.foo` nor `module.module.foo`. This is because the `^` means "start of string" when using regular expressions, and only `foo` starts with `"foo"`, the other layer names have prefixes.
+- `rank_pattern={"^module.foo": 42}` matches only `module.foo`, but not `module.module.foo`, for the same reason.
+- `rank_pattern={"module.foo": 42}` matches both `module.foo` and `module.module.foo`, but not `foo`.
+- `rank_pattern={"^foo": 42, "^module.module.foo": 55}` matches `foo` and `module.module.foo`, respectively, but not `module.foo`.
+- There is no need to indicate `$` to mark the end of the match, as this is added automatically by PEFT.
+
+The same logic applies to `alpha_pattern`. If you're in doubt, don't try to get fancy with regular expressions -- just pass the full name for each module with a different rank/alpha, preceded by the `^` prefix, and you should be good.
+
+### Automatically detect viable target modules
+
+[`peft.helpers.KappaTuneSelector`] implements the condition-number-based target selection strategy from the [KappaTune paper](https://arxiv.org/abs/2506.16289). It scans every `nn.Linear` module and, for models where MoE expert weights are stored as fused 3D `nn.Parameter` tensors (e.g. Llama-4, Qwen3-MoE), also those parameters, computes the matrix condition number κ = σ_max / σ_min for each, and selects the most isotropic layers (lowest κ). These isotropic layers serve as ideal candidates for fine-tuning, since their high-entropy nature allows them to absorb new information more readily, leaving the specialized, anisotropic layers intact to mitigate catastrophic forgetting during continual learning.
+
+Use [`peft.helpers.find_kappa_target_modules`] as a one-liner to get the optimal `target_modules` for `LoraConfig`:
+
+```python
+from peft import LoraConfig, get_peft_model
+from peft.helpers import find_kappa_target_modules
+
+model = AutoModelForCausalLM.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1")
+
+targets = find_kappa_target_modules(model, top_p=0.2)
+config = LoraConfig(
+    target_modules=targets["target_modules"],
+    target_parameters=targets["target_parameters"] if stable_modules_dic["target_parameters"] else None,
+    r=64,
+    lora_alpha=32,
+    task_type="CAUSAL_LM",
+)
+peft_model = get_peft_model(model, config)
+```
+
+See a complete example [here](https://github.com/huggingface/peft/blob/main/examples/KappaTune/experiments_kappatune_peft.py).
+
+### Targeting `nn.Parameter` directly
+
+Generally, you should use `target_modules` to target the module (e.g. `nn.Linear`). However, in some circumstances, this is not possible. E.g., in many mixture of expert (MoE) layers in HF Transformers, instead of using `nn.Linear`, an `nn.Parameter` is used. PEFT normally overwrites the `forward` method for LoRA, but for `nn.Parameter`, there is none. Therefore, to apply LoRA to that parameter, it needs to be targeted with `target_parameters`. As an example, for [Llama4](https://huggingface.co/collections/meta-llama/llama-4-67f0c30d9fe03840bc9d0164), you can pass: `target_parameters=['feed_forward.experts.gate_up_proj', 'feed_forward.experts.down_proj]`.
+
+Note that when targeting expert parameters, PEFT can add a substantial runtime overhead. The reason is that PEFT always materializes the LoRA contribution for _each expert_ even if only a small amount of experts is required. During training, this is less relevant since, over the course of the sequence, typically a large fraction of experts is activated at least once. However, during inference, normally a KV cache is used and we thus need to only compute the last token, which means that only a small amount of experts is activated. Therefore, using LoRA on MoE layers can result in a substantial slowdown at inference time. The recommendation is thus to merge the weights (`model.merge_adapter()` or `model = model.merge_and_unload()`). This removes the PEFT overhead.
+
+A more detailed investigation of this issue can be found on this [pull request on MoE optimization](https://github.com/huggingface/peft/pull/3139).
+
+#### Caveats
+
+- At the moment, this argument allows to target 2-dim or 3-dim `nn.Parameter`s. It is assumed that in the case of a 3-dim parameter, the 0th dimension is the expert dimension.
+- Multiple LoRA adapters (added via `model.add_adapter` or `model.load_adapter`) that use `target_parameters` are supported, but all of them must target the same set of parameters.
+
+#### MoE expert parameters and vLLM
+
+Some MoE models in Transformers store expert weights as `nn.Parameter` tensors (often 3D), not `nn.Linear` modules.
+To apply LoRA to those experts, use `target_parameters` and set a per-layer rank with `rank_pattern`:
+
+```python
+num_experts = getattr(model.config, "num_local_experts", None) or model.config.num_experts
+effective_r = max(1, r // num_experts)
+config = LoraConfig(
+    r=r,
+    lora_alpha=32,
+    target_modules=["q_proj", "v_proj"],
+    target_parameters=[
+        # Mixtral / Qwen3-MoE / GPT-OSS
+        "mlp.experts.gate_up_proj",
+        "mlp.experts.down_proj",
+        # Llama4
+        # "feed_forward.experts.gate_up_proj",
+        # "feed_forward.experts.down_proj",
+    ],
+    rank_pattern={
+        "experts.gate_up_proj": effective_r,
+        "experts.down_proj": effective_r,
+    },
+)
+```
+
+This keeps the total LoRA parameter budget similar to dense layers (see [LoRA Without Regret](https://thinkingmachines.ai/blog/lora/) by Schulman et. al.).  Non-expert modules use the default rank `r`.
+
+Accelerated inference with the fine-tuned model is possible with, for example, [vLLM](https://vllm.ai/) which supports fused MoE expert layers since v0.11.2.
+
+### Efficiently train tokens alongside LoRA
+
+PEFT LoRA adapters support adding new tokens with the `trainable_token_indices` parameter. This allows tuning of other tokens alongside fine-tuning specific layers. Only the specified tokens are trained and all other tokens are untouched. It saves memory and doesn't throw away learned context from existing token embeddings unlike training the whole embedding matrix. Under the hood this method uses the layer of [`TrainableTokensModel`].
+
+```py
+# for layer 'embed_tokens'
+config = LoraConfig(trainable_token_indices=[idx_1, idx_2, ...], ...)
+
+# specific embedding layer
+config = LoraConfig(trainable_token_indices={'emb_tokens': [idx_1, idx_2, ...]}, ...)
+```
+
+In the snippet below we show how to add new tokens to the model and how to train it alongside the other layers in the model.
+
+```py
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from peft import get_peft_model, LoraConfig
+
+base_model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-v0.1")
+tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-v0.1")
+
+# we define our new tokens and add them to the tokenizer as special tokens
+special_tokens = ['<|start_think|>', '<|stop_think|>']
+tokenizer.add_special_tokens({'additional_special_tokens': special_tokens})
+
+# make room for new tokens in the embedding matrix if it isn't big enough already
+base_model.resize_token_embeddings(max(len(tokenizer), base_model.model.embed_tokens.num_embeddings))
+
+# typical LoRA config with `trainable_token_indices` targeting embedding layer `embed_tokens`
+# and specifically our new tokens we just added
+lora_config = LoraConfig(
+    target_modules='all-linear',
+    trainable_token_indices={'embed_tokens': tokenizer.convert_tokens_to_ids(special_tokens)},
+)
+peft_model = get_peft_model(base_model, lora_config)
+
+# proceed to train the model like normal
+[...]
+```
+
+The token weights are saved as a part of the adapter state dict alongside the LoRA weights. Full fine-tuning and saving the embedding matrix would have stored a much bigger file.
+
+To give a bit of an indication how much VRAM can be saved, a rudimentary comparison of the above example was made between training the embedding matrix fully (`modules_to_save=["embed_tokens"]`), using a LoRA for the embedding matrix (`target_modules=[..., "embed_tokens"]`, rank 32) and trainable tokens (`trainable_token_indices=[...]`, 6 tokens):
+
+|           | Trainable Tokens |       LoRA | Full Fine-tuning |
+| --------: | :--------------: | :--------: | :--------------: |
+| VRAM      |        15,562 MB |   15,581MB |     ~16,500MB    |
+| Influence |         6 tokens | all tokens |       all tokens |
+
+### Weight tying
+
+Many causal LMs use **weight tying**, where two or more weights share the same underlying parameters. In the most common case, the input embedding weights (`embed_tokens`) and output projection weights (`lm_head`) share the same tensor. This is because it reduces parameters and usually preserves model quality.
+
+It's not always obvious how PEFT deals with these tied weights when they are targeted for fine-tuning. For LoRA, the `ensure_weight_tying` on the [`LoraConfig`] controls whether PEFT should explicitly keep adapter-side updates tied for those layers. In practice, this can affect `modules_to_save`, `target_modules`, and `trainable_token_indices`. Note that this logic partially relies on convention when it comes to naming the layers (`"embed_tokens"`, `"lm_head"`) and proper working cannot be guaranteed if those conventions are not used.
+
+The tables below summarize expected behavior.
+
+#### `modules_to_save`
+
+| Base model weights tied | `ensure_weight_tying` | `LoraConfig` shape                                  | Behavior                                                     |
+|-------------------------|-----------------------|-----------------------------------------------------|--------------------------------------------------------------|
+| No                      | `False`               | `modules_to_save=["embed_tokens"]` or `["lm_head"]` | Add `ModulesToSaveWrapper` on selected layer only            |
+| No                      | `True`                | `modules_to_save=["embed_tokens"]` or `["lm_head"]` | Warn, then add `ModulesToSaveWrapper` on selected layer only |
+| Yes                     | `False`               | `modules_to_save=["embed_tokens"]` or `["lm_head"]` | Treat as separate                                            |
+| Yes                     | `True`                | `modules_to_save=["embed_tokens"]` or `["lm_head"]` | Wrap tied layers and keep wrappers tied                      |
+| No                      | `False`               | `modules_to_save=["embed_tokens", "lm_head"]`       | Treat as separate                                            |
+| No                      | `True`                | `modules_to_save=["embed_tokens", "lm_head"]`       | Warn, then treat as separate                                 |
+| Yes                     | `False`               | `modules_to_save=["embed_tokens", "lm_head"]`       | Warn, then treat as separate                                            |
+| Yes                     | `True`                | `modules_to_save=["embed_tokens", "lm_head"]`       | Keep `ModulesToSaveWrapper`s tied                            |
+
+#### `target_modules`
+
+| Base model weights tied | `ensure_weight_tying` | `LoraConfig` shape                                 | Behavior                                   |
+|-------------------------|-----------------------|----------------------------------------------------|--------------------------------------------|
+| No                      | `False`               | `target_modules=["embed_tokens"]` or `["lm_head"]` | Add LoRA on selected layer only            |
+| No                      | `True`                | `target_modules=["embed_tokens"]` or `["lm_head"]` | Warn, then add LoRA on selected layer only |
+| Yes                     | `False`               | `target_modules=["embed_tokens"]` or `["lm_head"]` | Treat as separate                          |
+| Yes                     | `True`                | `target_modules=["embed_tokens"]` or `["lm_head"]` | Keep LoRA adapters tied                    |
+| No                      | `False`               | `target_modules=["embed_tokens", "lm_head"]`       | Treat as separate                          |
+| No                      | `True`                | `target_modules=["embed_tokens", "lm_head"]`       | Warn, then treat as separate               |
+| Yes                     | `False`               | `target_modules=["embed_tokens", "lm_head"]`       | Warn, then treat as separate                          |
+| Yes                     | `True`                | `target_modules=["embed_tokens", "lm_head"]`       | Keep LoRA adapters tied                    |
+
+#### `trainable_token_indices`
+
+For trainable tokens, we have the additional complication that even if the LM head and embeddings are tied, as a user I may want to fine-tune *different* tokens on them. In the example table below, we thus differentiate between fine-tuning the same and fine-tuning different tokens.
+
+| Base model weights tied | `ensure_weight_tying` | `LoraConfig` shape                                                    | Behavior                                       |
+|-------------------------|-----------------------|-----------------------------------------------------------------------|------------------------------------------------|
+| No                      | `False`               | `trainable_token_indices=[1, 2, 3]`                                   | Trainable tokens on embeddings only            |
+| No                      | `True`                | `trainable_token_indices=[1, 2, 3]`                                   | Warn, then trainable tokens on embeddings only |
+| Yes                     | `False`               | `trainable_token_indices=[1, 2, 3]`                                   | Tied trainable tokens                          |
+| Yes                     | `True`                | `trainable_token_indices=[1, 2, 3]`                                   | Tied trainable tokens                          |
+| No                      | `False`               | `trainable_token_indices={"lm_head": [1, 2], "embed_tokens": [1, 2]}` | Treat as separate                              |
+| No                      | `True`                | `trainable_token_indices={"lm_head": [1, 2], "embed_tokens": [1, 2]}` | Warn, then treat as separate                   |
+| Yes                     | `False`               | `trainable_token_indices={"lm_head": [1, 2], "embed_tokens": [1, 2]}` | Tied trainable tokens                          |
+| Yes                     | `True`                | `trainable_token_indices={"lm_head": [1, 2], "embed_tokens": [1, 2]}` | Tied trainable tokens                          |
+| No                      | `False`               | `trainable_token_indices={"lm_head": [1, 2], "embed_tokens": [3, 4]}` | Treat as separate                              |
+| No                      | `True`                | `trainable_token_indices={"lm_head": [1, 2], "embed_tokens": [3, 4]}` | Warn, then treat as separate                   |
+| Yes                     | `False`               | `trainable_token_indices={"lm_head": [1, 2], "embed_tokens": [3, 4]}` | Treat as separate                              |
+| Yes                     | `True`                | `trainable_token_indices={"lm_head": [1, 2], "embed_tokens": [3, 4]}` | Error                                          |
+
+For users, this means:
+
+- In general, if you want to fine-tune weights that are tied and want to keep them tied, pass `ensure_weight_tying=True`.
+- If your base model's weights are untied, `ensure_weight_tying=True` cannot force tying and only warns.
+- For `trainable_token_indices`, tied layers must use the same token indices when `ensure_weight_tying=True`.
+
+## Optimizers
+
+LoRA training can optionally include special purpose optimizers. Currently PEFT supports LoRA-FA and LoRA+.
+
+### LoRA-FA Optimizer
+
+LoRA training can be more effective and efficient using LoRA-FA, as described in [LoRA-FA](https://huggingface.co/papers/2308.03303). LoRA-FA reduces activation memory consumption by fixing the matrix A and only tuning the matrix B. During training, the gradient of B is optimized to approximate the full parameter fine-tuning gradient. Moreover, the memory consumption of LoRA-FA is not sensitive to the rank (since it erases the activation of $A$), therefore it can improve performance by enlarging lora rank without increasing memory consumption.
+
+```py
+from peft import LoraConfig, get_peft_model
+from peft.optimizers import create_lorafa_optimizer
+from transformers import Trainer, get_cosine_schedule_with_warmup
+
+base_model = AutoModelForCausalLM.from_pretrained("meta-llama/Meta-Llama-3-8B-Instruct")
+
+config = LoraConfig(...)
+model = get_peft_model(base_model, config)
+
+optimizer = create_lorafa_optimizer(
+    model=model,
+    r=128,
+    lora_alpha=32,
+    lr=7e-5,
+)
+
+scheduler = get_cosine_schedule_with_warmup(
+    optimizer,
+    num_warmup_steps=100,
+    num_training_steps=1000,
+)
+
+trainer = Trainer(
+    ...,
+    optimizers=(optimizer, scheduler),
+)
+```
+
+### LoRA+ optimized LoRA
+
+LoRA training can be optimized using [LoRA+](https://huggingface.co/papers/2402.12354), which uses different learning rates for the adapter matrices A and B, shown to increase finetuning speed by up to 2x and performance by 1-2%.
+
+```py
+from peft import LoraConfig, get_peft_model
+from peft.optimizers import create_loraplus_optimizer
+from transformers import Trainer
+import bitsandbytes as bnb
+
+base_model = ...
+config = LoraConfig(...)
+model = get_peft_model(base_model, config)
+
+optimizer = create_loraplus_optimizer(
+    model=model,
+    optimizer_cls=bnb.optim.Adam8bit,
+    lr=5e-5,
+    loraplus_lr_ratio=16,
+)
+scheduler = None
+
+...
+trainer = Trainer(
+    ...,
+    optimizers=(optimizer, scheduler),
+)
+```
+
+
+## Post-Training
+
+This section shows potential post-processing methods for trained adapters.
+
+
+### Merge LoRA weights into the base model
+
+While LoRA is significantly smaller and faster to train, you may encounter latency issues during inference due to separately loading the base model and the LoRA adapter. To eliminate latency, use the [`~LoraModel.merge_and_unload`] function to merge the adapter weights with the base model. This allows you to use the newly merged model as a standalone model. The [`~LoraModel.merge_and_unload`] function doesn't keep the adapter weights in memory.
+
+Below is a diagram that explains the intuition of LoRA adapter merging:
+
+<div class="flex justify-center">
+    <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/peft/lora_diagram.png"/>
+</div>
+
+We show in the snippets below how to run that using PEFT.
+
+```py
+from transformers import AutoModelForCausalLM
+from peft import PeftModel
+
+base_model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-v0.1")
+peft_model_id = "alignment-handbook/zephyr-7b-sft-lora"
+model = PeftModel.from_pretrained(base_model, peft_model_id)
+model = model.merge_and_unload()
+```
+
+It is important to assign the returned model to a variable and use it, [`~LoraModel.merge_and_unload`] is not an in-place operation. If you need to keep a copy of the weights so you can unmerge the adapter later or delete and load different ones, you should use the [`~LoraModel.merge_adapter`] function instead. Now you have the option to use [`~LoraModel.unmerge_adapter`] to return the base model.
+
+```py
+from transformers import AutoModelForCausalLM
+from peft import PeftModel
+
+base_model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-v0.1")
+peft_model_id = "alignment-handbook/zephyr-7b-sft-lora"
+model = PeftModel.from_pretrained(base_model, peft_model_id)
+model.merge_adapter()
+
+# unmerge the LoRA layers from the base model
+model.unmerge_adapter()
+```
+
+The [`~LoraModel.add_weighted_adapter`] function is useful for merging multiple LoRAs into a new adapter based on a user provided weighting scheme in the `weights` parameter. Below is an end-to-end example.
+
+First load the base model:
+
+```python
+from transformers import AutoModelForCausalLM
+from peft import PeftModel
+import torch
+
+base_model = AutoModelForCausalLM.from_pretrained(
+    "mistralai/Mistral-7B-v0.1", dtype=torch.float16, device_map="auto"
+)
+```
+
+Then we load the first adapter:
+
+```python
+peft_model_id = "alignment-handbook/zephyr-7b-sft-lora"
+model = PeftModel.from_pretrained(base_model, peft_model_id, adapter_name="sft")
+```
+
+Then load a different adapter and merge it with the first one:
+
+```python
+weighted_adapter_name = "sft-dpo"
+model.load_adapter("alignment-handbook/zephyr-7b-dpo-lora", adapter_name="dpo")
+model.add_weighted_adapter(
+    adapters=["sft", "dpo"],
+    weights=[0.7, 0.3],
+    adapter_name=weighted_adapter_name,
+    combination_type="linear"
+)
+model.set_adapter(weighted_adapter_name)
+```
+
+> [!TIP]
+> There are several supported methods for `combination_type`. Refer to the [documentation](../package_reference/lora#peft.LoraModel.add_weighted_adapter) for more details. Note that "svd" as the `combination_type` is not supported when using `torch.float16` or `torch.bfloat16` as the datatype.
+
+Now, perform inference:
+
+```python
+device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+
+tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-v0.1")
+
+prompt = "Hey, are you conscious? Can you talk to me?"
+inputs = tokenizer(prompt, return_tensors="pt")
+inputs = {k: v.to(device) for k, v in inputs.items()}
+
+with torch.no_grad():
+    generate_ids = model.generate(**inputs, max_length=30)
+outputs = tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
+print(outputs)
+```
+
+### Recovering base model performance via intruder dimension reduction
+
+The paper [LoRA vs Full Fine-tuning: An Illusion of Equivalence](https://huggingface.co/papers/2410.21228) argues that LoRA training introduces extra dimensions into the weights that have very little in common with the already learnt weights and lead to forgetting of already learned information. PEFT implements the suggested mitigation in [`peft.tuners.lora.intruders.reduce_intruder_dimension`].
+
+The mitigation will take a PEFT model with a loaded LoRA and create a new, modified adapter that is loaded alongside the existing adapter and now the active adapter.
+
+Example usage:
+
+```python
+from peft.tuners.lora.intruders import reduce_intruder_dimension
+
+peft_model = AutoPeftModelForCausalLM.from_pretrained('hubnemo/llama-3.2b-metamathqa-lora64')
+
+reduce_intruder_dimension(
+    peft_model,
+    mitigation_lambda=0.75,
+)
+
+peft_model.generate(...)
+```
+
+There are a few hyper-parameters that can be used for tuning the effectiveness of the mitigation but, as evidenced in Figure 8 of the paper, it will always be a trade-off between task accuracy learned by the adapter and forgetting of the base model's knowledge. The mitigation will remove information from the adapter to reduce the impact on forgetting previous knowledge but this also means that some information about the task learned by the adapter is lost as well.
+
+While the defaults are set to deliver a good trade-off between the two factors it is not guaranteed that the defaults will hold for your adapter, your model and your data, therefore it is wise to have a benchmark ready to measure the effect.
+
+## Load adapters
+
+Adapters can be loaded onto a pretrained model with [`~PeftModel.load_adapter`], which is useful for trying out different adapters whose weights aren't merged. Set the active adapter weights with the [`~LoraModel.set_adapter`] function.
+
+```py
+from transformers import AutoModelForCausalLM
+from peft import PeftModel
+
+base_model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-v0.1")
+peft_model_id = "alignment-handbook/zephyr-7b-sft-lora"
+model = PeftModel.from_pretrained(base_model, peft_model_id)
+
+# load different adapter
+model.load_adapter("alignment-handbook/zephyr-7b-dpo-lora", adapter_name="dpo")
+
+# set adapter as active
+model.set_adapter("dpo")
+```
+
+To return the base model, you could use [`~LoraModel.unload`] to unload all of the LoRA modules or [`~LoraModel.delete_adapter`] to delete the adapter entirely. [`~LoraModel.unload`] is not an in-place operation, remember to assign the returned model to a variable and use it.
+
+```py
+# unload adapter
+model = model.unload()
+
+# delete adapter
+model.delete_adapter("dpo")
+```
+
+## Tensor Parallelism
+
+LoRA supports [Tensor Parallelism (TP)](https://huggingface.co/docs/transformers/main/en/perf_train_gpu_many#tensor-parallelism) as provided by Transformers. When a base model is loaded with a `tp_plan`, PEFT automatically detects the TP configuration of each target module and adds the appropriate hooks to the LoRA adapter weights so that they participate correctly in the tensor-parallel computation.
+
+> [!WARNING]
+> Tensor Parallelism support for LoRA requires `transformers >= 5.4.0`.
+
+Usage is identical to the standard LoRA workflow — simply load the base model with a `tp_plan` before wrapping it with PEFT:
+
+```py
+from transformers import AutoModelForCausalLM
+from peft import get_peft_model, LoraConfig
+
+model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B", tp_plan="auto")
+lora_config = LoraConfig(r=16, target_modules=["q_proj", "v_proj"])
+model = get_peft_model(model, lora_config)
+```
+
+Saving and loading work as usual via `save_pretrained` / `from_pretrained`. PEFT gathers the sharded adapter weights back to full tensors before saving, so checkpoints are portable and independent of the number of devices used during training.
+
+
+## Inference
+
+This section showcases what you can do during inference time with LoRA, such as uncoupling the adapter.
+
+### Activated LoRA (aLoRA)
+
+Activated LoRA (aLoRA) is a low rank adapter architecture for causal LMs that reuses the existing base model KV cache for more efficient inference. This approach is best suited for inference pipelines which rely on the base model for most tasks/generations, but use aLoRA adapter(s) to perform specialized task(s) within the chain. For example, checking or correcting generated outputs of the base model. In these settings, inference times can be sped up by an order of magnitude or more. For more information on aLoRA and many example use cases, see the aLoRA [paper](https://huggingface.co/papers/2504.12397).
+
+This technique scans for the last occurrence of an invocation sequence (`alora_invocation_tokens`) in each input (this can be as short as 1 token). It activates the adapter weights on tokens starting with the beginning of the invocation sequence. Any inputs after the invocation sequence are also adapted, and all generated tokens will use the adapted weights. Weights on prior tokens are left un-adapted, making the cache for those tokens interchangeable with base model cache due to the causal attention mask in causal LMs. Usage is very similar to standard LoRA. The key difference is that the invocation sequence must be specified when the adapter is created:
+
+```py
+from peft import LoraConfig
+
+config = LoraConfig(alora_invocation_tokens=alora_invocation_tokens, task_type="CAUSAL_LM", ...)
+```
+
+alora_invocation_tokens` is a list of integer token ids. Given a desired invocation string, this can be obtained as:
+```py
+invocation_string = "placeholder"
+alora_invocation_tokens = tokenizer.encode(invocation_string, add_special_tokens=False).
+```
+The tokenizer is the base model's tokenizer. Use `add_special_tokens=False` to avoid adding `SOS`/`EOS` tokens in our search string (which will most likely cause the search to fail).
+
+**Notes**
+* aLoRA is only supported for `task_type=CAUSAL_LM` tasks due to its focus on cache reuse.
+* Since the weights are adapted on fewer tokens, often (not always) aLoRA requires higher rank (`r`) than LoRA. `r=32` can be a good starting point.
+* aLoRA weights cannot be merged into the base model by definition, since the adapter weights are selectively applied to a subset of tokens. Attempts to merge will throw errors.
+* Beam search is not yet supported.
+* It is generally not recommended to add new tokens to the tokenizer that are not present in the base model. This can complicate the target use case of both the base model and adapter model operating on overlapping context. You can workaround this by adding [trainable tokens](../package_reference/trainable_tokens) to the base model prior to training the adapter.
+
+#### Choice of invocation sequence and SFT design
+
+You must add the `alora_invocation_tokens` sequence because it is not added automatically. We recommend activating the adapter weights early (at the start of any adapter-specific prompting), but after any long inputs, to maximize model performance without compromising cache reuse. As with any model,
+formatting should be consistent between train and test.
+
+Consider the following example, where the base model has a chat template,
+and the goal is to train the adapter to generate a desired output.
+
+* Option 1: If there is no task-specific prompt, i.e. the input is a chat history with the `assistant` prompt, then the chat template's `assistant` prompt (e.g. `<|start_of_role|>assistant<|end_of_role|>`) is a natural choice for the invocation string. See the model's chat template to find the prompt for the model.
+* Option 2: If there is a task-specific prompt for the adapter that describes the task the adapter is learning, and that prompt is put as a `user` turn immediately prior to the generation, then the chat template's `user` prompt (e.g. `<|start_of_role|>user<|end_of_role|>`) is a natural choice for the invocation string.
+
+After deciding on an invocation string, get the model tokenizer and obtain `alora_invocation_tokens` as
+```py
+alora_invocation_tokens = tokenizer.encode(invocation_string, add_special_tokens=False).
+```
+
+An example inference setup is at [alora finetuning](https://github.com/huggingface/peft/blob/main/examples/alora_finetuning/alora_finetuning.py).
+
+> [!NOTE]
+> If using custom strings for the invocation string, make sure that the start and end of the string are special tokens to avoid issues with tokenization at the boundaries.
+
+To see why, imagine that 'a', 'b', 'c', and 'ab' are tokens in your tokenizer (numbers 1, 2, 3, 4 respectively). Suppose that your alora_invocation_tokens = [2, 3]. Now imagine your input string is "abc". Because "ab" is a token, this will get tokenized as [4,3]. So the alora_invocation_tokens will fail to be found, despite the string "bc" being in it. If the start and end of the invocation string are special tokens, however, this failure case will never happen since special tokens are never tokenized into the same token with other characters.
+
+#### Using (and reusing) cache for generation
+The main purpose of aLoRA is to make KV cache interchangeable between the base model and aLoRA adapter models **prior to the invocation sequence** since base and adapted KV values are not compatible. Specifically, keys and values stored during one model generation can be used in subsequent generations to avoid expensive prefill operations for context tokens. When sharing cache between the base model and aLoRA adapters, there are 2 main patterns:
+1. The base model has generated something, and an aLoRA adapter is then called to do a follow-up generation. For example, the base model answers a question, and an aLoRA trained to detect hallucinations checks the base model response.
+2. An aLoRA adapter has generated something, and the base model or a different aLoRA adapter is called to do a follow-up generation where there is partial context overlap with the original aLoRA. For example, the user provides a query, and an aLoRA rewrites the query to be more self-contained and improve retrieval in a RAG system. Then, documents are retrieved and loaded into context, aLoRA checks if these documents are relevant to the question, and then the base model generates an answer.
+
+
+To demonstrate the above behaviors when using caching, we're using [DynamicCache](https://huggingface.co/docs/transformers/en/kv_cache) from `transformers`. Take care to ensure that adapted cache values are not mixed with base cache values. In particular, an extra step is required for sharing the cache when there is partial context overlap (pattern 2).
+
+**Pattern 1: Base model followed by aLoRA** Here, the entire input and generation from the base model is input into the aLoRA adapter, along with the invocation sequence:
+```
+from transformers import DynamicCache
+...
+cache = DynamicCache()
+inputs_base = tokenizer(prompt_base, return_tensors="pt")
+# Generate from base model and save cache
+with model_alora.disable_adapter():
+    output = model_alora.generate(inputs_base["input_ids"].to(device),attention_mask=inputs_base["attention_mask"].to(device),past_key_values = cache,return_dict_in_generate=True)
+output_text_base = tokenizer.decode(output.sequences[0])
+cache = output.past_key_values
+
+# Generate with aLoRA adapter from cache
+prompt_alora = output_text + INVOCATION_STRING
+inputs_alora = tokenizer(prompt_alora, return_tensors="pt").to(device)
+output = model_alora.generate(**inputs_alora, past_key_values=cache)
+output_text_alora = tokenizer.decode(output[0])
+
+# Note: cache is now tainted with adapter values and cannot be used in base model from here on!
+```
+
+**Pattern 2: aLoRA generation followed by base model (or another aLoRA) with partial context overlap** Here, we prefill the shared context using the base model, and then generate.
+
+```
+from transformers import DynamicCache
+import copy
+...
+cache = DynamicCache()
+inputs_shared = tokenizer(prompt_shared, return_tensors="pt").to(device)
+
+# Prefill from base model and save cache
+with model_alora.disable_adapter():
+    with torch.no_grad():
+        model_alora(**inputs_shared, past_key_values=cache)
+cache_copy = copy.deepcopy(cache)
+
+# Generate from aLoRA using prefilled cache
+prompt_alora = prompt_shared + INVOCATION_STRING
+inputs_alora = tokenizer(prompt_alora, return_tensors="pt").to(device)
+output = model_alora.generate(**inputs_alora, past_key_values=cache)
+output_text_alora = tokenizer.decode(output[0])
+
+# Generate from base model using saved cache not tainted by aLoRA KV values
+prompt_base = prompt_shared
+inputs_base = tokenizer(prompt_base, return_tensors="pt").to(device)
+with model_alora.disable_adapter():
+    output = model_alora.generate(**inputs_base, past_key_values=cache_copy)
+output_text_base = tokenizer.decode(output[0])
+```
+
+
+### Inference with different LoRA adapters in the same batch
+
+Normally, each inference batch has to use the same adapter(s) in PEFT. This can sometimes be annoying, because we may have batches that contain samples intended to be used with different LoRA adapters. For example, we could have a base model that works well in English and two more LoRA adapters, one for French and one for German. Usually, we would have to split our batches such that each batch only contains samples of one of the languages, we cannot combine different languages in the same batch.
+
+Thankfully, it is possible to mix different LoRA adapters in the same batch using the `adapter_name` argument. Below, we show an example of how this works in practice. First, let's load the base model, English, and the two adapters, French and German, like this:
+
+```python
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from peft import PeftModel
+
+model_id = ...
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+model = AutoModelForCausalLM.from_pretrained(model_id)
+# load the LoRA adapter for French
+peft_model = PeftModel.from_pretrained(model, <path>, adapter_name="adapter_fr")
+# next, load the LoRA adapter for German
+peft_model.load_adapter(<path>, adapter_name="adapter_de")
+```
+
+Now, we want to generate text on a sample that contains all three languages: The first three samples are in English, the next three are in French, and the last three are in German. We can use the `adapter_names` argument to specify which adapter to use for each sample. Since our base model is used for English, we use the special string `"__base__"` for these samples. For the next three samples, we indicate the adapter name of the French LoRA fine-tune, in this case `"adapter_fr"`. For the last three samples, we indicate the adapter name of the German LoRA fine-tune, in this case `"adapter_de"`. This way, we can use the base model and the two adapters in a single batch.
+
+```python
+inputs = tokenizer(
+    [
+        "Hello, my dog is cute",
+        "Hello, my cat is awesome",
+        "Hello, my fish is great",
+        "Salut, mon chien est mignon",
+        "Salut, mon chat est génial",
+        "Salut, mon poisson est super",
+        "Hallo, mein Hund ist süß",
+        "Hallo, meine Katze ist toll",
+        "Hallo, mein Fisch ist großartig",
+    ],
+    return_tensors="pt",
+    padding=True,
+)
+
+adapter_names = [
+    "__base__", "__base__", "__base__",
+    "adapter_fr", "adapter_fr", "adapter_fr",
+    "adapter_de", "adapter_de", "adapter_de",
+]
+output = peft_model.generate(**inputs, adapter_names=adapter_names, max_new_tokens=20)
+```
+
+Note that the order does not matter here, i.e. the samples in the batch don't need to be grouped by adapter as in the example above. We just need to ensure that the `adapter_names` argument is aligned correctly with the samples.
+
+Additionally, the same approach also works with the `modules_to_save` feature, which allows for saving and reusing specific neural network layers, such as custom heads for classification tasks, across different LoRA adapters.
+
+#### Caveats
+
+Using this feature has some drawbacks, namely:
+
+- It only works for inference, not for training.
+- Disabling adapters using the `with model.disable_adapter()` context takes precedence over `adapter_names`.
+- You cannot pass `adapter_names` when some adapter weights were merged with base weight using the `merge_adapter` method. Please unmerge all adapters first by calling `model.unmerge_adapter()`.
+- For obvious reasons, this cannot be used after calling `merge_and_unload()`, since all the LoRA adapters will be merged into the base weights in this case.
+- This feature does not currently work with DoRA, so set `use_dora=False` in your `LoraConfig` if you want to use it.
+- The `modules_to_save` feature is currently only supported for the layers of types `Linear`, `Embedding`, `Conv2d` and `Conv1d`.
+- There is an expected overhead for inference with `adapter_names`, especially if the amount of different adapters in the batch is high. This is because the batch size is effectively reduced to the number of samples per adapter. If runtime performance is your top priority, try the following:
+  - Increase the batch size.
+  - Try to avoid having a large number of different adapters in the same batch, prefer homogeneous batches. This can be achieved by buffering samples with the same adapter and only perform inference with a small handful of different adapters.
+  - Take a look at alternative implementations such as [LoRAX](https://github.com/predibase/lorax), [punica](https://github.com/punica-ai/punica), or [S-LoRA](https://github.com/S-LoRA/S-LoRA), which are specialized to work with a large number of different adapters.
+
+
+### Composing and Reusing LoRA Adapters
+#### Arrow
+[Arrow](https://huggingface.co/papers/2405.11157) is a modular routing algorithm designed to combine multiple pre-trained task-specific LoRA adapters to solve a given task, similar to [Polytropon](poly) but without the need for fine-tuning. Rather than merging all adapters naively, Arrow introduces a **gradient-free, token-wise mixture-of-experts (MoE) routing mechanism**. At inference time, it first computes a _prototype_ for each LoRA by extracting the top right singular vector from its SVD decomposition. Each token representation is then compared to these prototypes via cosine similarity to obtain routing coefficients. Tokens are assigned to the top-k most relevant LoRA adapters, with the coefficients normalized through softmax, and their outputs linearly combined. This allows effective reuse of existing LoRA modules for new tasks and leads to stronger zero-shot generalization.
+
+In PEFT, Arrow is enabled through [`ArrowConfig]` and `create_arrow_model`. You can also configure parameters such as `top_k` (the number of LoRA adapters combined per token), `router_temperature` (the softmax temperature applied to the routing coefficients), and `rng_seed` (for reproducibility).
+
+```py
+from peft import create_arrow_model, ArrowConfig
+from transformers import AutoModelForCausalLM
+
+# Loading the model
+base_model = AutoModelForCausalLM.from_pretrained("microsoft/Phi-3-mini-4k-instruct")
+
+# Creating the Arrow config
+arrow_config = ArrowConfig(
+    top_k=3,
+    router_temperature=1.0,
+    rng_seed=42,
+)
+
+# The LoRA adapters below were trained on a clustered FLAN dataset.
+# Task clustering was performed using the Model-Based Clustering (MBC) method,
+# as described in the Arrow paper.
+# While one could train a separate LoRA for each task and let Arrow route tokens among them,
+# training LoRAs on clusters of tasks instead provides an indirect optimization for
+# transfer across the multi-task dataset.
+task_specific_adapter_paths = [
+        f"TahaBa/phi3-mini-clustered-flan/ts_expert_{i}" for i in range(10)
+    ]
+
+# Creating the Arrow model
+model = create_arrow_model(
+        base_model=base_model,
+        task_specific_adapter_paths=task_specific_adapter_paths,
+        arrow_config=arrow_config,
+    )
+
+# Now the forward path could be called on this model, like a normal PeftModel.
+```
+
+Furthermore, you can add or remove adapters after calling ```create_arrow_model```—for example, to fine-tune a new adapter or discard an unnecessary one. Once the adapters are in place, you can activate the ```"arrow_router"``` for inference to use Arrow. Note that if you add a new LoRA adapter after ```create_arrow_model``` and want to fine-tune it, you must explicitly set the new adapter as active, since ```"arrow_router"``` is activated by default in ```create_arrow_model```.
+
+```py
+from trl import SFTTrainer, SFTConfig
+
+# Adding a new adapter and activating it
+model.add_adapter(adapter_name='new_adapter')
+model.set_adapter('new_adapter')
+
+# Now the model could be trained along the `new_adapter`.
+trainer = SFTTrainer(
+        model=model,
+        args=SFTConfig(...),
+        ...
+    )
+
+# Once the training is done, you can activate `arrow_router` and use it in inference
+model.set_adapter('arrow_router')    # Model is ready to be used at inference time now
+```
+
+#### GenKnowSub
+[GenKnowSub](https://aclanthology.org/2025.acl-short.54/) augments Arrow by purifying task-specific LoRA adapters before routing. The key idea is to subtract general knowledge encoded in LoRA space—based on the [forgetting-via-negation principle](https://huggingface.co/papers/2212.04089)—so that task adapters become more isolated and focused on task-relevant signals. Concretely, GenKnowSub estimates a low-dimensional “general” subspace from a set of general (non task-specific) LoRA adapters and removes this component from each task adapter’s LoRA update prior to Arrow’s token-wise routing. This typically improves compositionality and reduces interference when combining many task adapters.
+
+In PEFT, enable GenKnowSub by setting ```use_gks=True``` in ArrowConfig, and providing ```general_adapter_paths``` in ```create_arrow_model```:
+
+```py
+from peft import create_arrow_model, ArrowConfig
+from transformers import AutoModelForCausalLM
+
+# Loading the model
+base_model = AutoModelForCausalLM.from_pretrained("microsoft/Phi-3-mini-4k-instruct")
+
+# Creating the Arrow config
+arrow_config = ArrowConfig(
+    top_k=3,
+    router_temperature=1.0,
+    use_gks=True,
+    rng_seed=42,
+)
+
+# Path to task-specific, trained on flan clustered dataset (as we explained before.)
+task_specific_adapter_paths = [
+        f"TahaBa/phi3-mini-clustered-flan/ts_expert_{i}" for i in range(10)
+    ]
+# These general adapters are trained on English, German, and French Wikipedia dataset,
+# with causal language modelling objective, each pair like: (507 token tsentence, 5 token completion), and the loss computed on the completion
+general_adapter_paths = [
+        "TahaBa/phi3-mini-general-adapters/cluster0_batch16_prop1.0_langen/checkpoint-17",
+        "TahaBa/phi3-mini-general-adapters/cluster0_batch16_prop1.0_langfr/checkpoint-35",
+        "TahaBa/phi3-mini-general-adapters/cluster0_batch16_prop1.0_langger/checkpoint-17"
+    ]
+
+# Creating the Arrow model
+model = create_arrow_model(
+        base_model=base_model,
+        task_specific_adapter_paths=task_specific_adapter_paths,
+        general_adapter_paths=general_adapter_paths,
+        arrow_config=arrow_config,
+    )
+
+# Now the forward path could be called on this model, like a normal PeftModel.
+```
+To encode general knowledge, GenKnowSub subtracts the average of the provided general adapters from each task-specific adapter once, before routing begins. Furthermore, the ability to add or remove adapters after calling ```create_arrow_model``` (as described in the Arrow section) is still supported in this case.
+
+> [!TIP]
+> **Things to keep in mind when using Arrow + GenKnowSub:**
+>
+> - All LoRA adapters (task-specific and general) must share the same ```rank``` and ```target_modules```.
+>
+> - Any inconsistency in these settings will raise an error in ```create_arrow_model```.
+>
+> - Having different scaling factors (```lora_alpha```) across task adapters is supported — Arrow handles them automatically.
+>
+> - Merging the ```"arrow_router"``` is not supported, due to its dynamic routing behavior.
+>
+> - In create_arrow_model, task adapters are loaded as ```task_i``` and general adapters as ```gks_j``` (where ```i``` and ```j``` are indices). The function ensures consistency of ```target_modules```, ```rank```, and whether adapters are applied to ```Linear``` or ```Linear4bit``` layers. It then adds the ```"arrow_router"``` module and activates it. Any customization of this process requires overriding ```create_arrow_model```.
+>
+> - This implementation is compatible with 4-bit quantization (via bitsandbytes):
+>
+>     ```py
+>     from transformers import AutoModelForCausalLM, BitsAndBytesConfig
+>     import torch
+>
+>     # Quantisation config
+>     bnb_config = BitsAndBytesConfig(
+>             load_in_4bit=True,
+>             bnb_4bit_quant_type="nf4",
+>             bnb_4bit_compute_dtype=torch.bfloat16,
+>             bnb_4bit_use_double_quant=False,
+>         )
+>
+>     # Loading the model
+>     base_model = AutoModelForCausalLM.from_pretrained(
+>         "microsoft/Phi-3-mini-4k-instruct",
+>         dtype=torch.bfloat16,
+>         device_map="auto",
+>         quantization_config=bnb_config,
+>     )
+>
+>     # Now call create_arrow_model() as we explained before.
+>     ```
+
+# API
+
+## LoraConfig
+
+[[autodoc]] tuners.lora.config.LoraConfig
+
+## LoraModel
+
+[[autodoc]] tuners.lora.model.LoraModel
+
+
+## Utility
+
+### ArrowConfig
+
+[[autodoc]] tuners.lora.config.ArrowConfig
+
+### LoftQ
+
+[[autodoc]] utils.loftq_utils.replace_lora_weights_loftq
+
+
+### Eva
+
+#### EvaConfig
+
+[[autodoc]] tuners.lora.config.EvaConfig
+
+#### initialize_lora_eva_weights
+
+[[autodoc]] tuners.lora.eva.initialize_lora_eva_weights
+
+#### get_eva_state_dict
+
+[[autodoc]] tuners.lora.eva.get_eva_state_dict
+
+
+### LoraGAConfig
+
+[[autodoc]] tuners.lora.config.LoraGAConfig
+
+#### Utilities
+
+[[autodoc]] tuners.lora.loraga.estimate_gradients
+
+[[autodoc]] tuners.lora.loraga.preprocess_loraga
+
+
+## Intruder Dimension Reduction
+
+[[autodoc]] tuners.lora.intruders.reduce_intruder_dimension
+
+
diff --git a/docs/source/package_reference/lora_conversion.md b/docs/source/package_reference/lora_conversion.md
new file mode 100644
index 0000000..a023db5
--- /dev/null
+++ b/docs/source/package_reference/lora_conversion.md
@@ -0,0 +1,155 @@
+<!--⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+-->
+
+# LoRA conversion
+
+Functions that allow to convert non-LoRA PEFT models to LoRA models.
+
+## Description
+
+PEFT supports dozens of different parameter effficient fine-tuning techniques. The most popular one by far is LoRA. This means that many other packages support LoRA too. For example, [Diffusers](https://huggingface.co/docs/diffusers/main/en/api/loaders/lora) allows to load LoRA adapters to change the capabilities of diffusion models. [vLLM](https://docs.vllm.ai/en/stable/features/lora/) allows serving models with LoRA adapters. This is nice but unfortunately, all the other, non-LoRA PEFT methods are rarely supported. Therefore, even if another PEFT method would work better for your specific use case, you may be prevented from using it because downstream packages offer no support.
+
+Here we present a potential solution. PEFT offers two functions, [`save_as_lora`] and [`convert_to_lora`], which allow to convert a PEFT adapter into a LoRA adapter. Not all PEFT methods support this for now, but if they do, it means you can start with the PEFT method that works best for you and then later use it as if it were a LoRA adapter.
+
+## Example
+
+The LoRA rank for the converted adapter can either be set to a fixed rank by passing an int > 0 to the `rank` argument, or a dynamic rank, which adapts to each layer, by passing a float between 0 and 1 to the `rank` argument. Dynamic ranks can potentially be more efficient (same performance with fewer parameters).
+
+### Fixed LoRA rank
+
+The usage of [`save_as_lora`] is relatively straightforward:
+
+```python
+from peft import get_peft_model, save_as_lora
+
+# first load and train your non-LoRA PEFT model as normal
+base_model = ...
+non_lora_config = ...
+model = get_peft_model(base_model, non_lora_config)
+# check that this PEFT method can indeed be converted to LoRA
+assert model.supports_lora_conversion()
+...  # train the model
+
+# the rank of the LoRA adapter that you want to convert to
+target_rank = 64
+# save as a LoRA checkpoint
+save_as_lora(output_path, model, rank=target_rank)
+```
+
+This will create a LoRA checkpoint at `output_path` that you can load like any other LoRA adapter, or use in downstream packages such as Diffusers or vLLM.
+
+The [`convert_to_lora`] function is useful if you don't want to save the converted LoRA adapter but instead want to use the converted weights right away, for example to perform evaluations:
+
+```python
+from peft import convert_to_lora, get_peft_model, set_peft_model_state_dict
+
+base_model = ...
+non_lora_config = ...
+model = get_peft_model(base_model, non_lora_config)
+...  # train the model
+
+# get the lora config and state dict of the converted lora model
+lora_config, lora_state_dict = convert_to_lora(model, rank=target_rank)
+# reload the base model, or use model.unload()
+base_model = ...
+# apply the lora config to the base model
+lora_model = get_peft_model(base_model, lora_config)
+# load the LoRA weights onto the base model
+set_peft_model_state_dict(lora_model, state_dict)
+```
+
+### Dynamic LoRA rank
+
+In the examples above, we used a fixed LoRA rank for conversion. However, it is conceivable that some layers don't require a high rank to be accurately converted, while other layers require a higher rank. To accommodate this, PEFT offers the option to pass a float between 0 and 1 as the `rank` argument. Let's say you pass `rank=0.5`. This means that for each layer, the rank for the LoRA adapter is chosen such that the LoRA adapter explains 50% of the variance in weight introduced by original adapter. In more technical terms, under the hood we perform a [Singular Value Decomposition](https://en.wikipedia.org/wiki/Singular_value_decomposition) on the weight contribution of the adapter and then take the top singular values that, when normalized, sum up to the passed value.
+
+```python
+# set a dynamic rank by passing a float
+threshold = 0.7
+# save as a LoRA checkpoint
+save_as_lora(output_path, model, rank=threshold)
+# get the lora config and state dict directly:
+lora_config, lora_state_dict = convert_to_lora(model, rank=threshold)
+# inspect the different ranks per layer:
+print(lora_config.rank_pattern)
+```
+
+Using this type of dynamic LoRA rank can be useful if the contribution of the different layers varies a lot. The disadvantage is that it could mean that some layers will have a very high LoRA rank, which can lead to memory spikes. Please test what works best for your use case.
+
+### Compiling the model
+
+For large models, doing the conversion may take some time; for instance each PEFT module has to go through an SVD computation. By passing `compile_kwargs` to [`save_as_lora`] or [`convert_to_lora`], you can apply [`torch.compile`](https://docs.pytorch.org/docs/stable/generated/torch.compile.html) to the conversion function and potentially speed up the process. The `compile_kwargs` are a dict of keyword arguments that are passed to `torch.compile` (empty dict also works). Below is an example:
+
+```python
+compile_kwargs = {"dynamic": True, "mode": "max-autotune-no-cudagraphs", "fullgraph": True}
+save_as_lora(output_path, model, rank=rank, compile_kwargs=compile_kwargs)
+```
+
+### LoRA to LoRA conversion
+
+It is also possible to convert a LoRA adapter into another LoRA adapter. Why would you want to do that? There is one reason, namely if you want to reduce the rank of the LoRA adapter. If, after training, you want to shrink the LoRA adapter, use [`save_as_lora`] or [`convert_to_lora`] and pass a smaller rank. This will give you a new LoRA adapter that has a smaller memory and storage footprint.
+
+## Metrics
+
+### Non-LoRA to LoRA conversion
+
+Of course, converting one PEFT adapter into another adapter is a lossy process. The new adapter will most likely not perform as well as the initial adapter. Therefore, it is highly advised to **evaluate the converted LoRA adapter**. This way, you can make sure that the converted adapter performs well enough for your use case. The general rule applies that the higher the rank of the LoRA adapter, the better it will approximate your initial adapter. This means that the converted LoRA adapter may require more parameters than the original adapter to achieve a similar performanace.
+
+To give an example, here are some numbers that were derived on the [PEFT MetaMathQA benchmark](https://github.com/huggingface/peft/tree/main/method_comparison/MetaMathQA). For this, a [LoHa](https://huggingface.co/docs/peft/package_reference/loha) adapter was used to fine-tune `meta-llama/Llama-3.2-3B` on MetaMathQA and evaluated on GSM8K. The initial LoKr adapter had rank 32, resulting in 18,350,080 trainable parameters and a test accuracy of 41.85%. Evaluation required 12.25 GB of memory. The checkpoint was converted into LoRA with different values for the `rank`. The resulting outcome is:
+
+| rank | trainable parameters | test accuracy (%) | accuracy change | memory reserved (max, GB) | memory increase |
+|------|---------------------:|------------------:|----------------:|--------------------------:|----------------:|
+| 8    |              2293760 |             37.60 |           -4.25 |                     12.41 |            0.16 |
+| 16   |              4587520 |             38.89 |           -2.96 |                     12.15 |           -0.10 |
+| 32   |              9175040 |             40.11 |           -1.74 |                     12.41 |            0.16 |
+| 64   |             18350080 |             39.20 |           -2.65 |                     12.18 |           -0.07 |
+|      |                      |                   |                 |                           |                 |
+| 0.4  |              2428928 |             37.60 |           -4.25 |                     12.41 |            0.16 |
+| 0.5  |              4761600 |             40.18 |           -1.67 |                     12.41 |            0.16 |
+| 0.6  |              8857600 |             39.42 |           -2.43 |                     12.41 |            0.16 |
+| 0.7  |             16230400 |             39.04 |           -2.81 |                     12.15 |           -0.10 |
+
+As you can see, we can attain a test accuracy that comes close to the original LoHa adapter if the rank is sufficiently high. Choosing the right rank is a tradeoff between model performance and model efficiency. To reproduce this experiment, follow the script at https://github.com/huggingface/peft/tree/main/scripts/evaluate-lora-conversion.py.
+
+Note that the number of trainable parameters cannot be translated one to one into memory usage. Some PEFT methods require more, some less memory, even with the same number of trainable parameters. Therefore, even if after conversion, the LoRA adapter has more parameters than the original one, it could still be more memory efficient when serving.
+
+### LoRA to LoRA conversion
+
+Similar to the experiment above, we can also evaluate LoRA to LoRA conversion (i.e. LoRA compression). Here, we start with a LoRA adapter of rank 64 trained on the same setup as above with RS-LoRA. The initial adapter has 18,350,080 trainable parameters, a test accuracy of 52.92%, and requires 12.58 GB of memory for evaluation. The following table shows the results of converting this adapter to LoRA adapters of smaller rank:
+
+| rank | trainable parameters | test accuracy (%) | accuracy change | memory reserved (max, GB) | memory increase |
+|------|---------------------:|------------------:|----------------:|--------------------------:|----------------:|
+| 8    |              2293760 |             43.37 |           -9.55 |                     12.38 |           -0.20 |
+| 16   |              4587520 |             48.90 |           -4.02 |                     12.38 |           -0.20 |
+| 32   |              9175040 |             51.48 |           -1.44 |                     12.49 |           -0.09 |
+| 48   |             13762560 |             52.01 |           -0.91 |                     12.38 |           -0.20 |
+|      |                      |                   |                 |                           |                 |
+| 0.5  |              2150400 |             44.12 |           -8.80 |                     12.37 |           -0.21 |
+| 0.6  |              3082240 |             47.54 |           -5.38 |                     12.37 |           -0.21 |
+| 0.7  |              4448256 |             50.49 |           -2.43 |                     12.37 |           -0.21 |
+| 0.8  |              6510592 |             50.11 |           -2.81 |                     12.37 |           -0.21 |
+| 0.9  |             10022912 |             51.55 |           -1.37 |                     12.38 |           -0.20 |
+| 0.95 |             12976128 |             52.62 |           -0.30 |                     12.39 |           -0.19 |
+
+So for instance for rank 0.95, we can close the accuracy gap to just 0.3 percentage points while reducing the number of parameters by 30%. Also note that these compressed LoRAs can be better than directly training them on the lower rank -- e.g. for rank 32, training directly results in a test accuracy of 48.22%, while conversion from rank 64 results in 51.48%.
+
+## Caveats
+
+There are some limitations to the LoRA conversion. As mentioned above, a reduction in performance is expected and the converted LoRA will most likely be less parameter efficient than the original adapter. Moreover, LoRA conversion has these limitations:
+
+- Right now, only adapters applied to linear layers can be converted.
+- Not all PEFT methods currently support LoRA conversion.
+
+If there is a lot of demand to extend LoRA conversion, please let us know by creating a [GitHub discussion](https://github.com/huggingface/peft/discussions) and we will make it work with more layer types and PEFT methods.
+
+## API
+
+### Convert a non-LoRA model to a LoRA model, return the `LoraConfig` and `state_dict`
+
+[[autodoc]] tuners.lora.conversion.convert_to_lora
+    - all
+
+### Convert a non-LoRA model to a LoRA model, save the adapter checkpoint and config at the given path
+
+[[autodoc]] tuners.lora.conversion.save_as_lora
+    - all
diff --git a/docs/source/package_reference/lora_variant_bdlora.md b/docs/source/package_reference/lora_variant_bdlora.md
new file mode 100644
index 0000000..56fbc9a
--- /dev/null
+++ b/docs/source/package_reference/lora_variant_bdlora.md
@@ -0,0 +1,20 @@
+# Block-Diagonal LoRA for Eliminating Communication Overhead in Tensor Parallel LoRA Serving
+
+Block-Diagonal LoRA (BD-LoRA) is a LoRA variant in which some LoRA factors are constrained to be block-diagonal. This allows faster serving by eliminating communication overheads
+when running inference on multiple GPUs. Despite the block-diagonal constraint, BD-LoRA is similarly performant to vanilla LoRA at similar parameter counts.
+
+BD-LoRA is designed to be used with tensor parallelism, which means sharding the weights of a model among multiple GPUs. A popular sharding strategy is the [Megatron Sharding Strategy](https://arxiv.org/abs/1909.08053). For two linear layers $W_1$, $W_2$ that follow each other (for example the up and down projections in a transformer MLP module), we will shard the first layer in a column-parallel way (which requires LoRA B to be block-diagonal) and the second layer in a row-parallel way (which requires LoRA A to be block-diagonal). For the attention module, this can be similarly achieved by taking the Q, K and V projections together as $W_1$ and the out projection as $W_2$, sharding accordingly. This sharding allows a compatible inference engine to distribute each block-diagonal shard over a a different GPU, cutting the need to communicate partial results among GPUs. In the image below, you can see the exact sharding strategy and how this saves computational efforts.
+
+Paper: https://hf.co/papers/2510.23346
+
+<div>
+<img src="https://github.com/huggingface/peft/blob/main/examples/bdlora_finetuning/bdlora-sharding.png?raw=true" width="800"/>
+</div>
+
+### Performance, rank and parameter count
+BD-LoRA achieves similar performance to LoRA (see image below, or the `method_comparison` folder in the peft repository root) at the same parameter count. However, as every other factor in BD-LoRA is block-diagonal, a BD-LoRA adapter will have less parameters than a LoRA adapter at the same rank. The performance of BD-LoRA is only competitive when the rank is then increased accordingly. We provide example code for rank-matching at the end of this example notebook.
+
+<div>
+<img src="https://github.com/huggingface/peft/blob/main/examples/bdlora_finetuning/bdlora-performance.png?raw=true" width="600"/>
+</div>
+
diff --git a/docs/source/package_reference/lora_variant_dora.md b/docs/source/package_reference/lora_variant_dora.md
new file mode 100644
index 0000000..c4a99c4
--- /dev/null
+++ b/docs/source/package_reference/lora_variant_dora.md
@@ -0,0 +1,83 @@
+<!--Copyright 2026-present The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contains specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# Weight-Decomposed Low-Rank Adaptation (DoRA)
+
+> [!NOTE]
+> This is a variant of LoRA and therefore everything that is possible with LoRA is valid for this method except otherwise stated on this page.
+
+This technique decomposes the updates of the weights into two parts, magnitude and direction. Direction is handled by normal LoRA, whereas the magnitude is handled by a separate learnable parameter. This can improve the performance of LoRA, especially at low ranks. For more information on DoRA, see  https://huggingface.co/papers/2402.09353.
+
+```py
+from peft import LoraConfig
+
+config = LoraConfig(use_dora=True, ...)
+```
+
+If parts of the model or the DoRA adapter are offloaded to CPU you can get a significant speedup at the cost of some temporary (ephemeral) VRAM overhead by using `ephemeral_gpu_offload=True` in `config.runtime_config`.
+
+```py
+from peft import LoraConfig, LoraRuntimeConfig
+
+config = LoraConfig(use_dora=True, runtime_config=LoraRuntimeConfig(ephemeral_gpu_offload=True), ...)
+```
+
+A `PeftModel` with a DoRA adapter can also be loaded with `ephemeral_gpu_offload=True` flag using the `from_pretrained` method as well as the `load_adapter` method.
+
+```py
+from peft import PeftModel
+
+model = PeftModel.from_pretrained(base_model, peft_model_id, ephemeral_gpu_offload=True)
+```
+
+## Optimization
+
+DoRA is optimized (computes faster and takes less memory) for models in the evaluation mode, or when dropout is set to 0. We reuse the
+base result at those times to get the speedup.
+Running [dora finetuning](https://github.com/huggingface/peft/blob/main/examples/dora_finetuning/dora_finetuning.py)
+with `CUDA_VISIBLE_DEVICES=0 ZE_AFFINITY_MASK=0 time python examples/dora_finetuning/dora_finetuning.py --quantize --lora_dropout 0 --batch_size 16 --eval_step 2 --use_dora` on a 4090 with gradient accumulation set to 2 and max step to 20 resulted with the following observations:
+
+| | Without Optimization | With Optimization |
+| :--: | :--: | :--: |
+| train runtime (sec) | 359.7298 | **279.2676** |
+| train samples per second | 1.779 | **2.292** |
+| train steps per second | 0.056 | **0.072** |
+
+Moreover, it is possible to further increase runtime performance of DoRA by using the [`DoraCaching`] helper context. This requires the model to be in `eval` mode:
+
+```py
+from peft.helpers import DoraCaching
+
+model.eval()
+with DoraCaching():
+    output = model(inputs)
+```
+
+For [`meta-llama/Llama-3.1-8B`](https://huggingface.co/meta-llama/Llama-3.1-8B), the [DoRA caching benchmark script](https://github.com/huggingface/peft/blob/main/examples/dora_finetuning/dora-caching.py) shows that, compared to LoRA:
+
+- DoRA without caching requires 139% more time
+- DoRA without caching requires 4% more memory
+- DoRA with caching requires 17% more time
+- DoRA with caching requires 41% more memory
+
+Caching can thus make inference with DoRA significantly faster but it also requires significantly more memory. Ideally, if the use case allows it, just merge the DoRA adapter to avoid both memory and runtime overhead.
+
+## Caveats
+
+- DoRA only supports embedding, linear, and Conv2d layers at the moment.
+- DoRA introduces a bigger overhead than pure LoRA, so it is recommended to merge weights for inference, see [`LoraModel.merge_and_unload`].
+- DoRA should work with weights quantized with bitsandbytes ("QDoRA"). However, issues have been reported when using QDoRA with DeepSpeed Zero2.
+
diff --git a/docs/source/package_reference/lora_variant_monteclora.md b/docs/source/package_reference/lora_variant_monteclora.md
new file mode 100644
index 0000000..2afb52d
--- /dev/null
+++ b/docs/source/package_reference/lora_variant_monteclora.md
@@ -0,0 +1,54 @@
+# MonteCLoRA (Monte Carlo Low-Rank Adaptation)
+
+> [!NOTE]
+> This is a variant of LoRA and therefore everything that is possible with LoRA is valid for this method except otherwise stated on this page.
+
+MonteCLoRA wraps a standard LoRA adapter with a small variational module that draws Monte Carlo samples of stochastic perturbations on top of the LoRA `A` matrix during training. Concretely, it learns variational parameters (a Wishart-based covariance, a per-sample multivariate-normal noise term, and a Dirichlet weighting over the samples) and adds the resulting averaged perturbation to `lora_A` at every forward pass. A KL-divergence + entropy term is added to the training loss to keep these variational parameters anchored to a sensible prior. At inference time the sampler is disabled and MonteCLoRA behaves exactly like a regular LoRA adapter, so there is **no extra inference cost or extra parameters to merge**. For the full method see https://huggingface.co/papers/2411.04358.
+
+You may want to consider MonteCLoRA when:
+
+- You are fine-tuning on a small or noisy dataset and want stronger regularization than vanilla LoRA. The Monte Carlo averaging and the KL term together act as a Bayesian-style regularizer.
+- You want better uncertainty calibration / robustness from your adapter without paying extra cost at inference time (the variational machinery is training-only).
+- Vanilla LoRA is overfitting and lowering `r` or increasing `lora_dropout` is not enough.
+
+You probably do *not* need MonteCLoRA when you have a large, clean dataset and vanilla LoRA already trains stably — in that regime the extra variational parameters mostly add training overhead without much benefit.
+
+To enable MonteCLoRA, pass a `MontecloraConfig` to `LoraConfig`:
+
+```py
+from peft import LoraConfig, MontecloraConfig
+
+monteclora_config = MontecloraConfig(
+    num_samples=8,         # number of Monte Carlo samples per forward pass
+    sample_scaler=1e-4,    # magnitude of the variational perturbation
+    kl_loss_weight=1e-5,   # weight of the KL term added to the training loss
+)
+config = LoraConfig(
+    r=16,
+    lora_alpha=32,
+    target_modules=["q_proj", "v_proj"],
+    monteclora_config=monteclora_config,
+)
+```
+
+During training you must add the variational regularization loss to the task loss. The simplest way is to call [`LoraModel._get_monteclora_loss`] on the underlying `LoraModel`:
+
+```py
+task_loss = ...  # standard loss returned by your model
+monteclora_loss = model._get_monteclora_loss()  # 0.0 if MonteCLoRA is not used
+total_loss = task_loss + monteclora_loss
+total_loss.backward()
+```
+
+If you train with the HF `Trainer`, you can simply mix in [`peft.helpers.MontecloraTrainerMixin`] which does this for you in `compute_loss`:
+
+```py
+from transformers import Trainer
+from peft.helpers import MontecloraTrainerMixin
+
+
+class MontecloraTrainer(MontecloraTrainerMixin, Trainer):
+    pass
+```
+
+A complete working example is available at [`examples/monteclora_finetuning`](https://github.com/huggingface/peft/tree/main/examples/monteclora_finetuning).
diff --git a/docs/source/package_reference/lora_variant_velora.md b/docs/source/package_reference/lora_variant_velora.md
new file mode 100644
index 0000000..c9d5578
--- /dev/null
+++ b/docs/source/package_reference/lora_variant_velora.md
@@ -0,0 +1,52 @@
+<!--Copyright 2026-present The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contains specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+### VeLoRA
+
+> [!NOTE]
+> This is a variant of LoRA and therefore everything that is possible with LoRA is valid for this method except otherwise stated on this page.
+
+[VeLoRA](https://huggingface.co/papers/2405.17991) is a LoRA variant that reduces training memory by compressing the activations saved for the LoRA in the forward pass and then reconstructing them in the backwards pass to implement the update rules. In PEFT, VeLoRA is configured as a LoRA variant through the `velora_config` argument on [`LoraConfig`].
+
+```py
+from peft import LoraConfig, VeloraConfig
+
+config = LoraConfig(
+    target_modules=["q_proj", "v_proj"],
+    velora_config=VeloraConfig(
+        num_groups=64,
+        scale=0.2,
+        init_type="batch_average",
+    ),
+)
+```
+
+VeLoRA is applied to every LoRA layer selected by `target_modules`. `num_groups` controls how the input activation depth is split before compression. If the activation depth is not evenly divisible by `num_groups`, VeLoRA pads the grouped representation internally and removes the padding after reconstruction. `scale` rescales the reconstructed activations during the backward pass, and `init_type` chooses how the projection is initialized.
+
+Use `batch_average_once` to initialize the projection from the first training batch, `batch_average` to update it from every training forward pass, or `random` to initialize it immediately from a random normalized vector.
+
+Below are some results with the [MetaMathQA benchmark](https://github.com/huggingface/peft/tree/main/method_comparison/MetaMathQA).
+
+| Variant | Training Loss | Max Memory (GiB) | Tokens/sec |
+|---|---:|---:|---:|
+| LoRA | 0.5427 | 27.69 | 2366.2 |
+| LoRA + GC | 0.5426 | 13.17 | 1671.8 |
+| LoRA+VeLoRA | 0.5427 | 19.94 | 2057.6 |
+
+#### Caveats
+
+- VeLoRA is currently supported on standard LoRA linear layers only.
+
diff --git a/docs/source/package_reference/merge_utils.md b/docs/source/package_reference/merge_utils.md
new file mode 100644
index 0000000..e574612
--- /dev/null
+++ b/docs/source/package_reference/merge_utils.md
@@ -0,0 +1,33 @@
+<!--Copyright 2024 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# Model merge
+
+PEFT provides several internal utilities for [merging LoRA adapters](../developer_guides/model_merging) with the TIES and DARE methods.
+
+[[autodoc]] utils.merge_utils.prune
+
+[[autodoc]] utils.merge_utils.calculate_majority_sign_mask
+
+[[autodoc]] utils.merge_utils.disjoint_merge
+
+[[autodoc]] utils.merge_utils.task_arithmetic
+
+[[autodoc]] utils.merge_utils.ties
+
+[[autodoc]] utils.merge_utils.dare_linear
+
+[[autodoc]] utils.merge_utils.dare_ties
diff --git a/docs/source/package_reference/miss.md b/docs/source/package_reference/miss.md
new file mode 100644
index 0000000..c2c321f
--- /dev/null
+++ b/docs/source/package_reference/miss.md
@@ -0,0 +1,102 @@
+<!--Copyright 2025 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# MiSS
+
+[MiSS (Matrix Shard Sharing)](https://arxiv.org/abs/2409.15371) is a PEFT method that achieves a good balance between model performance and computational efficiency. It requires only a single trainable matrix and introduces a shard-sharing mechanism distinct from LoRA.
+
+The abstract from the paper is:
+
+*Parameter-Efficient Fine-Tuning (PEFT) methods, particularly Low-Rank Adaptation (LoRA), effectively reduce the number of trainable parameters in Large Language Models (LLMs). However, as model scales continue to grow, the demand for computational resources remains a significant challenge. Existing LoRA variants often struggle to strike an optimal balance between adaptability (model performance and convergence speed) and efficiency (computational overhead, memory usage, and initialization time). This paper introduces MiSS (Matrix Shard Sharing), a novel PEFT approach that addresses this trade-off through a simple shard-sharing mechanism. MiSS leverages the insight that a low-rank adaptation can be achieved by decomposing the weight matrix into multiple fragment matrices and utilizing a shared, trainable common fragment. This method constructs the low-rank update matrix through the replication of these shared, partitioned shards. We also propose a hardware-efficient and broadly applicable implementation for MiSS. Extensive experiments conducted on a range of tasks, alongside a systematic analysis of computational performance, demonstrate MiSS's superiority. The results show that MiSS significantly outperforms standard LoRA and its prominent variants in both model performance metrics and computational efficiency, including initialization speed and training throughput. By effectively balancing expressive power and resource utilization, MiSS offers a compelling solution for efficiently adapting large-scale models.*
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=MISS"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+## When to use MiSS
+
+MiSS is a good choice when:
+
+- You want faster initialization and higher training throughput than advanced LoRA initialization schemes that use expensive setups (such as PiSSA, LoRA-GA, or OLoRA).
+- You want a drop-in alternative to LoRA with minimal configuration changes.
+
+If you need stronger expressiveness at the cost of some efficiency, consider the `bat` initialization variant (see below).
+
+## init_weights modes
+
+MiSS supports three initialization modes via the `init_weights` parameter:
+
+- `True` (default): Standard MiSS initialization. Best starting point for most use cases.
+- `"bat"`: Enables nonlinear updates across different shards. Produces better results than standard MiSS but uses more memory and is approximately twice as slow. Use this when performance is the priority over efficiency.
+- `"mini"`: Uses a smaller rank along the `out_features` dimension, controlled by `mini_r`. This reduces trainable parameters further. When using this mode, `mini_r` must be set and `out_features` must be divisible by `mini_r`.
+
+## Quick start
+
+```python
+import torch
+from peft import MissConfig, get_peft_model
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+model = AutoModelForCausalLM.from_pretrained(
+    "meta-llama/Llama-2-7b-hf",
+    torch_dtype=torch.bfloat16,
+    device_map="auto"
+)
+tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf")
+tokenizer.pad_token_id = tokenizer.eos_token_id
+
+# Standard MiSS
+config = MissConfig(
+    r=64,
+    miss_dropout=0.01,
+    task_type="CAUSAL_LM"
+)
+
+# BAT variant — better performance, more memory
+# config = MissConfig(
+#     r=64,
+#     init_weights="bat",
+#     task_type="CAUSAL_LM"
+# )
+
+# Mini variant — fewer trainable parameters
+# config = MissConfig(
+#     r=64,
+#     init_weights="mini",
+#     mini_r=8,
+#     task_type="CAUSAL_LM"
+# )
+
+model = get_peft_model(model, config)
+model.print_trainable_parameters()
+```
+
+For a full fine-tuning example including training and inference, see the [MiSS fine-tuning example](https://github.com/huggingface/peft/tree/main/examples/miss_finetuning).
+
+# API
+
+## MissConfig
+
+[[autodoc]] tuners.miss.config.MissConfig
+
+## MissModel
+
+[[autodoc]] tuners.miss.model.MissModel
diff --git a/docs/source/package_reference/multitask_prompt_tuning.md b/docs/source/package_reference/multitask_prompt_tuning.md
new file mode 100644
index 0000000..ad5efa9
--- /dev/null
+++ b/docs/source/package_reference/multitask_prompt_tuning.md
@@ -0,0 +1,55 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# Multitask prompt tuning
+
+[Multitask prompt tuning](https://huggingface.co/papers/2303.02861)  decomposes the soft prompts of each task into a single learned transferable prompt instead of a separate prompt for each task. The single learned prompt can be adapted for each task by multiplicative low rank updates.
+
+The abstract from the paper is:
+
+*Prompt tuning, in which a base pretrained model is adapted to each task via conditioning on learned prompt vectors, has emerged as a promising approach for efficiently adapting large language models to multiple downstream tasks. However, existing methods typically learn soft prompt vectors from scratch, and it has not been clear how to exploit the rich cross-task knowledge with prompt vectors in a multitask learning setting. We propose multitask prompt tuning (MPT), which first learns a single transferable prompt by distilling knowledge from multiple task-specific source prompts. We then learn multiplicative low rank updates to this shared prompt to efficiently adapt it to each downstream target task. Extensive experiments on 23 NLP datasets demonstrate that our proposed approach outperforms the state-of-the-art methods, including the full finetuning baseline in some cases, despite only tuning 0.035% as many task-specific parameters*.
+
+<div class="flex justify-center">
+    <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/peft/mpt.png"/>
+</div>
+<small><a href="https://hf.co/papers/2303.02861">Multitask prompt tuning enables parameter-efficient transfer learning</a>.</small>
+
+MPT consists of two stages:
+
+1. source training - for each task, its soft prompt is decomposed into task-specific vectors. The task-specific vectors are multiplied together to form another matrix W, and the Hadamard product is used between W and a shared prompt matrix P to generate a task-specific prompt matrix. The task-specific prompts are distilled into a single prompt matrix that is shared across all tasks. This prompt is trained with multitask training.
+2. target adaptation - to adapt the single prompt for a target task, a target prompt is initialized and expressed as the Hadamard product of the shared prompt matrix and the task-specific low-rank prompt matrix.
+
+<div class="flex justify-center">
+    <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/peft/mpt-decomposition.png"/>
+</div>
+<small><a href="https://hf.co/papers/2103.10385">Prompt decomposition</a>.</small>
+
+## Benchmark overview
+
+There is no benchmark for this method yet. Feel free to contribute an experiment
+configuration but make sure to first create an issue
+[here](https://github.com/huggingface/peft/issues).
+
+
+# API
+
+## MultitaskPromptTuningConfig
+
+[[autodoc]] tuners.multitask_prompt_tuning.config.MultitaskPromptTuningConfig
+
+## MultitaskPromptEmbedding
+
+[[autodoc]] tuners.multitask_prompt_tuning.model.MultitaskPromptEmbedding
diff --git a/docs/source/package_reference/oft.md b/docs/source/package_reference/oft.md
new file mode 100644
index 0000000..fcf3ee9
--- /dev/null
+++ b/docs/source/package_reference/oft.md
@@ -0,0 +1,98 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# OFT
+
+<div class="flex justify-center">
+    <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/peft/oft.png"/>
+</div>
+<small><a href="https://hf.co/papers/2306.07280">Controlling Text-to-Image Diffusion by Orthogonal Finetuning</a></small>
+
+[Orthogonal Finetuning (OFT)](https://hf.co/papers/2306.07280) and [OFTv2](https://huggingface.co/papers/2506.19847) is a method developed for adapting text-to-image diffusion models. It works by reparameterizing the pretrained weight matrices with its orthogonal matrix to preserve information in the pretrained model. To reduce the number of parameters, OFT introduces a block-diagonal structure in the orthogonal matrix. The method primarily focuses on preserving a pretrained model's generative performance in the finetuned model. It tries to maintain the same cosine similarity ([hyperspherical energy](https://huggingface.co/papers/1805.09298)) between all pairwise neurons in a layer because this better captures the semantic information among neurons. This means OFT is more capable at preserving the subject and it is better for controllable generation (similar to [ControlNet](https://huggingface.co/docs/diffusers/using-diffusers/controlnet)).
+
+The abstract from the paper is:
+
+*Large text-to-image diffusion models have impressive capabilities in generating photorealistic images from text prompts. How to effectively guide or control these powerful models to perform different downstream tasks becomes an important open problem. To tackle this challenge, we introduce a principled finetuning method -- Orthogonal Finetuning (OFT), for adapting text-to-image diffusion models to downstream tasks. Unlike existing methods, OFT can provably preserve hyperspherical energy which characterizes the pairwise neuron relationship on the unit hypersphere. We find that this property is crucial for preserving the semantic generation ability of text-to-image diffusion models. To improve finetuning stability, we further propose Constrained Orthogonal Finetuning (COFT) which imposes an additional radius constraint to the hypersphere. Specifically, we consider two important finetuning text-to-image tasks: subject-driven generation where the goal is to generate subject-specific images given a few images of a subject and a text prompt, and controllable generation where the goal is to enable the model to take in additional control signals. We empirically show that our OFT framework outperforms existing methods in generation quality and convergence speed*.
+
+OFT preserves the hyperspherical energy by learning an orthogonal transformation for neurons to keep the cosine similarity between them unchanged, potentially leading to less forgetting of previous learnt knowledge. In practice, this means taking the matrix product of an orthogonal matrix with the pretrained weight matrix. However, to be parameter-efficient, the orthogonal matrix is represented as a block-diagonal matrix with rank `r` blocks. Whereas LoRA reduces the number of trainable parameters with low-rank structures, OFT reduces the number of trainable parameters with a sparse block-diagonal matrix structure.
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=OFT"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+## Merge OFT weights into the base model
+
+Similar to LoRA, the weights learned by OFT can be integrated into the pretrained weight matrices using the [`~OFTModel.merge_and_unload()` function. This function merges the adapter weights with the base model which allows you to effectively use the newly merged model as a standalone model.
+
+## OFT Example Usage
+
+For using OFT for quantized finetuning with [TRL](https://github.com/huggingface/trl) for `SFT`, `PPO`, or `DPO` fine-tuning, follow the following outline:
+
+```py
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from trl import SFTTrainer
+from peft import OFTConfig
+
+if use_quantization:
+    bnb_config = BitsAndBytesConfig(
+        load_in_4bit=True,
+        bnb_4bit_quant_type="nf4",
+        bnb_4bit_compute_dtype=torch.bfloat16,
+        bnb_4bit_use_double_quant=True,
+        bnb_4bit_quant_storage=torch.bfloat16,
+    )
+
+model = AutoModelForCausalLM.from_pretrained(
+    "model_name",
+    quantization_config=bnb_config
+)
+tokenizer = AutoTokenizer.from_pretrained("model_name")
+
+# Configure OFT
+peft_config = OFTConfig(
+    oft_block_size=32,
+    use_cayley_neumann=True,
+    target_modules="all-linear",
+    bias="none",
+    task_type="CAUSAL_LM"
+)
+
+trainer = SFTTrainer(
+    model=model,
+    train_dataset=ds['train'],
+    peft_config=peft_config,
+    processing_class=tokenizer,
+    args=training_arguments,
+    data_collator=collator,
+)
+
+trainer.train()
+```
+
+# API
+
+## OFTConfig
+
+[[autodoc]] tuners.oft.config.OFTConfig
+
+## OFTModel
+
+[[autodoc]] tuners.oft.model.OFTModel
diff --git a/docs/source/package_reference/osf.md b/docs/source/package_reference/osf.md
new file mode 100644
index 0000000..6cd43fa
--- /dev/null
+++ b/docs/source/package_reference/osf.md
@@ -0,0 +1,254 @@
+<!--Copyright 2025 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# OSF (Orthogonal Subspace Fine-tuning)
+
+Orthogonal Subspace Fine-tuning ([OSF](https://huggingface.co/papers/2504.07097)) is a PEFT method designed for continual learning that constrains parameter updates to be orthogonal to previously important directions. This approach enables full fine-tuning while preventing catastrophic forgetting without requiring additional parameters or storing previous gradients.
+
+The abstract from the paper is:
+
+*Continual learning in large language models (LLMs) is prone to catastrophic forgetting, where adapting to new tasks significantly degrades performance on previously learned ones. Existing methods typically rely on low-rank, parameter-efficient updates that limit the model's expressivity and introduce additional parameters per task, leading to scalability issues. To address these limitations, we propose a novel continual full fine-tuning approach leveraging adaptive singular value decomposition (SVD). Our method dynamically identifies task-specific low-rank parameter subspaces and constrains updates to be orthogonal to critical directions associated with prior tasks, thus effectively minimizing interference without additional parameter overhead or storing previous task gradients. We evaluate our approach extensively on standard continual learning benchmarks using both encoder-decoder (T5-Large) and decoder-only (LLaMA-2 7B) models, spanning diverse tasks including classification, generation, and reasoning. Empirically, our method achieves state-of-the-art results, up to 7% higher average accuracy than recent baselines like O-LoRA, and notably maintains the model's general linguistic capabilities, instruction-following accuracy, and safety throughout the continual learning process by reducing forgetting to near-negligible levels. Our adaptive SVD framework effectively balances model plasticity and knowledge retention, providing a practical, theoretically grounded, and computationally scalable solution for continual learning scenarios in large language models.*
+
+## How OSF Works
+
+OSF decomposes each weight matrix into high-rank (frozen) and low-rank (trainable) components using SVD:
+
+```
+W = U_high * S_high * V_high^T + U_low * S_low * V_low^T
+```
+
+Where:
+- `U_high, S_high, V_high`: Preserve important directions from previous tasks (frozen)
+- `U_low, S_low, V_low`: Allow adaptation to new tasks (trainable)
+
+During training, gradients are projected to be orthogonal to the high-rank subspace, ensuring updates don't interfere with previously learned knowledge.
+
+## Basic Usage
+
+```python
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from peft import OSFConfig, get_peft_model
+
+# Load base model
+model = AutoModelForCausalLM.from_pretrained("gpt2")
+
+# Configure OSF
+config = OSFConfig(
+    target_modules=["c_attn", "c_proj"],  # Target attention layers
+    effective_rank=8,                     # Default rank for decomposition
+    rank_pattern={"c_attn": 16}          # Override rank for specific modules
+)
+
+# Apply OSF
+model = get_peft_model(model, config)
+
+# Train as usual
+optimizer = torch.optim.AdamW(model.parameters(), lr=3e-4)
+
+tokenizer = AutoTokenizer.from_pretrained("gpt2")
+tokenizer.pad_token = tokenizer.eos_token
+
+inputs = tokenizer("Hello world", return_tensors="pt", padding=True)
+loss = model(**inputs, labels=inputs.input_ids).loss
+loss.backward()
+optimizer.step()
+optimizer.zero_grad()
+```
+
+## Configuration Options
+
+### Target Modules
+
+You can specify target modules in several ways:
+
+```python
+# Specific module names
+config = OSFConfig(target_modules=["q_proj", "k_proj", "v_proj", "o_proj"])
+
+# All linear layers
+config = OSFConfig(target_modules="all-linear")
+
+# Model-specific defaults (automatically detected)
+config = OSFConfig()  # Uses model-appropriate defaults
+```
+
+### Effective Rank Configuration
+
+Control the preserved/trainable subspaces:
+
+```python
+# Global preserved rank (applies to all target modules)
+config = OSFConfig(effective_rank=16)  # preserves top-16 singular directions; trains the rest
+
+# Automatic preserved rank (50% of the smaller matrix dimension per target)
+config = OSFConfig(effective_rank=None)
+
+# Per-module preserved-rank overrides
+config = OSFConfig(
+    effective_rank=8,
+    rank_pattern={
+        "q_proj": 16,      # Higher rank for query projection
+        "gate_proj": 4     # Lower rank for gate projection
+    }
+)
+
+# Fractional preserved rank is supported (interpreted per-target as fraction * min_dim)
+config = OSFConfig(effective_rank=0.8)  # preserve 80% of min_dim; train remaining 20%
+config = OSFConfig(rank_pattern={"q_proj": 0.5})  # preserve 50% on q_proj, others use global/default
+```
+
+Note: OSF's `effective_rank` is the preserved (frozen) rank, not the trainable rank. The trainable rank equals `min(weight.shape) - effective_rank`. This differs from LoRA's `r`, which directly specifies the trainable rank.
+
+
+## Training Advice for Continual Learning
+
+### Sequential Task Learning
+
+OSF is specifically designed for learning tasks sequentially. Between tasks, recompute the SVD so the preserved subspace reflects the latest weights. One simple way is to re-wrap the updated base model with OSF again:
+
+```python
+# Task 1: train on domain A with initial preserved subspace
+r = 8  # initial effective rank to preserve
+model = get_peft_model(base_model, OSFConfig(effective_rank=r))
+train_task(model, task_1_data)
+
+# Task 2: recompute SVD on updated weights and increase preserved subspace
+base_model = model.unload()  # unwrap base model without assuming internals
+r += 4  # grow preserved subspace to include Task 1 knowledge
+model = get_peft_model(base_model, OSFConfig(effective_rank=r))
+train_task(model, task_2_data)
+
+# Task 3: recompute again and expand preserved subspace further
+base_model = model.unload()
+r += 4
+model = get_peft_model(base_model, OSFConfig(effective_rank=r))
+train_task(model, task_3_data)
+```
+
+### Budget Allocation for Task Sequences
+
+When training on a known sequence of n tasks, one effective strategy is to progressively allocate model capacity to balance learning new tasks while preserving previous knowledge:
+
+- **Task 1**: Use full capacity (train everything)
+- **Task 2**: Freeze 1/n of model capacity, train remaining (n-1)/n capacity
+- **Task 3**: Freeze 2/n of model capacity, train remaining (n-2)/n capacity
+- **Task n**: Freeze (n-1)/n of model capacity, use 1/n capacity for final task
+
+This approach ensures each task gets adequate learning capacity while progressively preserving more knowledge from previous tasks.
+
+```python
+# Example: 4-task sequence with progressive budget allocation
+n_tasks = 4
+max_preserved_rank = 512  # Upper bound for preserved rank per target (heuristic)
+
+for task_id in range(n_tasks):
+    # Freeze increases over time; trainable capacity shrinks
+    preserved_fraction = (task_id + 1) / n_tasks
+    preserved_rank = int(max_preserved_rank * preserved_fraction)
+
+    config = OSFConfig(
+        target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
+        effective_rank=preserved_rank,
+    )
+
+    print(
+        f"Task {task_id + 1}: Preserving rank {preserved_rank} "
+        f"({preserved_fraction:.1%} of max_preserved_rank - {max_preserved_rank} frozen); trainable rank = min_dim - preserved_rank"
+    )
+
+    model = get_peft_model(base_model, config)
+    train_task(model, task_data[task_id])
+```
+
+### Best Practices
+
+1. **Effective Rank Selection**: Start with `effective_rank=None` (auto sets rank to 50% of the smaller weight dimension per target module) and adjust based on task complexity
+2. **Learning Rate**: Use smaller learning rates (1e-5 to 1e-4) compared to standard fine-tuning
+3. **Task Importance**: Use `rank_pattern` to allocate more capacity to critical modules
+4. **Model Architecture**: OSF works best with transformer architectures having clear attention and MLP separations
+5. **Capacity Planning**: For known task sequences, use progressive budget allocation (1/n, 2/n, ..., (n-1)/n freezing) to balance plasticity and stability
+
+### Memory Considerations
+
+OSF modifies weights in-place and doesn't add parameters, making it memory-efficient:
+
+```python
+# Memory usage remains close to base model
+print(f"Base model parameters: {base_model.num_parameters():,}")
+print(f"OSF model parameters: {osf_model.num_parameters():,}")  # Similar count
+```
+
+## Advanced Usage
+
+### Custom Target Modules
+
+For models with non-standard architectures:
+
+```python
+config = OSFConfig(
+    target_modules=["dense", "intermediate.dense"],  # Custom layer names
+    effective_rank=12,
+    rank_pattern={"dense": 8, "intermediate.dense": 16}
+)
+```
+
+### Integration with Other Methods
+
+OSF can be combined with other techniques:
+
+```python
+# Use with gradient checkpointing for memory efficiency
+model.gradient_checkpointing_enable()
+
+# Apply weight decay selectively (regularizes low-rank factors to limit drift/overfitting in continual updates; keep small)
+optimizer = torch.optim.AdamW([
+    {"params": [p for n, p in model.named_parameters() if "U_low" in n], "weight_decay": 0.01},
+    {"params": [p for n, p in model.named_parameters() if "S_low" in n], "weight_decay": 0.001},
+    {"params": [p for n, p in model.named_parameters() if "V_low" in n], "weight_decay": 0.01},
+], lr=1e-4)
+```
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=OSF"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+# API
+
+## OSFConfig
+
+[[autodoc]] tuners.osf.config.OSFConfig
+
+## OSFModel
+
+[[autodoc]] tuners.osf.model.OSFModel
+
+## Utility Functions
+
+### Weight Decomposition
+
+[[autodoc]] tuners.osf.utils.decompose_weight_matrix
+
+[[autodoc]] tuners.osf.utils.reconstruct_weight_matrix
+
+### Gradient Projection
+
+[[autodoc]] tuners.osf.utils.project_gradient_to_orthogonal_space
diff --git a/docs/source/package_reference/p_tuning.md b/docs/source/package_reference/p_tuning.md
new file mode 100644
index 0000000..d529448
--- /dev/null
+++ b/docs/source/package_reference/p_tuning.md
@@ -0,0 +1,70 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# P-tuning
+
+<div class="flex justify-center">
+    <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/peft/p-tuning.png"/>
+</div>
+<small>Prompt tokens can be inserted anywhere in the input sequence, and they are optimized by a prompt encoder <a href="https://hf.co/papers/2103.10385">(image source)</a>.</small>
+
+[P-tuning](https://hf.co/papers/2103.10385) is designed for natural language understanding (NLU) tasks and all language models.
+
+The abstract from the paper is:
+
+*While GPTs with traditional fine-tuning fail to achieve strong results on natural language understanding (NLU), we show that GPTs can be better than or comparable to similar-sized BERTs on NLU tasks with a novel method P-tuning -- which employs trainable continuous prompt embeddings. On the knowledge probing (LAMA) benchmark, the best GPT recovers 64\% (P@1) of world knowledge without any additional text provided during test time, which substantially improves the previous best by 20+ percentage points. On the SuperGlue benchmark, GPTs achieve comparable and sometimes better performance to similar-sized BERTs in supervised learning. Importantly, we find that P-tuning also improves BERTs' performance in both few-shot and supervised settings while largely reducing the need for prompt engineering. Consequently, P-tuning outperforms the state-of-the-art approaches on the few-shot SuperGlue benchmark.*.
+
+The method adds trainable prompt embeddings to the input that is optimized by a prompt encoder to find a better prompt, eliminating the need to manually design prompts. The prompt tokens can be added anywhere in the input sequence, and p-tuning also introduces anchor tokens for improving performance. A prompt encoder (a bidirectional long-short term memory network or LSTM) is used to optimize the prompt parameters. Unlike prefix tuning:
+
+- the prompt tokens can be inserted anywhere in the input sequence, and it isn't restricted to only the beginning
+- the prompt tokens are only added to the input instead of adding them to every layer of the model
+- introducing *anchor* tokens can improve performance because they indicate characteristics of a component in the input sequence
+
+The paper's results suggest that P-tuning is more efficient than manually crafting prompts, and it enables GPT-like models to compete with BERT-like models on NLU tasks.
+
+## Usage
+
+Create a [`PromptEncoderConfig`] with the task type, the number of virtual tokens to add and learn, and the hidden size of the encoder for learning the prompt parameters.
+
+```py
+from peft import PromptEncoderConfig, get_peft_model
+
+peft_config = PromptEncoderConfig(task_type="CAUSAL_LM", num_virtual_tokens=20, encoder_hidden_size=128)
+model = get_peft_model(model, peft_config)
+model.print_trainable_parameters()
+"trainable params: 300,288 || all params: 559,514,880 || trainable%: 0.05366935013417338"
+```
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=P_TUNING"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+
+# API
+
+## PromptEncoderConfig
+
+[[autodoc]] tuners.p_tuning.config.PromptEncoderConfig
+
+## PromptEncoder
+
+[[autodoc]] tuners.p_tuning.model.PromptEncoder
+
diff --git a/docs/source/package_reference/peanut.md b/docs/source/package_reference/peanut.md
new file mode 100644
index 0000000..f986d87
--- /dev/null
+++ b/docs/source/package_reference/peanut.md
@@ -0,0 +1,64 @@
+<!--Copyright 2026 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# PEANuT: Parameter-Efficient Adaptation with Weight-aware Neural Tweakers
+
+[PEANuT](https://arxiv.org/abs/2410.01870) is a parameter-efficient fine-tuning technique that introduces
+weight-aware neural tweakers to generate adapter updates from the frozen pretrained weights themselves. Instead of
+learning a purely linear low-rank update as in LoRA, PEANuT conditions the adapter transformation on the base weight,
+which makes the update rule more expressive while keeping the number of trainable parameters small.
+
+PEANuT uses an input projection `A`, an output projection `B`, and optional intermediate residual encoder/decoder
+pairs with non-linear activations. This makes it possible to model more complex update patterns than weight-agnostic
+linear adapters while still remaining within the PEFT setting.
+
+PEANuT currently has the following tradeoffs:
+
+Pros:
+- Higher theoretical expressiveness than linear low-rank updates.
+- Better performance than LoRA on a range of tasks under similar budgets.
+- Works well in very low-parameter regimes, for example around `0.2M` trainable parameters.
+
+Cons:
+- Higher memory usage than LoRA, because `ΔW` is explicitly constructed before being applied.
+- Slower training and inference than LoRA, and deeper intermediate layers increase the overhead further.
+- The non-linearity can require more careful hyperparameter tuning, especially learning rate and related optimization settings.
+
+If these tradeoffs do not fit your use case, consider other PEFT methods such as LoRA.
+
+The abstract from the paper is:
+
+> Fine-tuning large pre-trained foundation models often yields excellent downstream performance but is prohibitively expensive when updating all parameters. Parameter-efficient fine-tuning (PEFT) methods such as LoRA alleviate this by introducing lightweight update modules, yet they commonly rely on weight-agnostic linear approximations, limiting their expressiveness. In this work, we propose PEANuT, a novel PEFT framework that introduces weight-aware neural tweakers, compact neural modules that generate task-adaptive updates conditioned on frozen pre-trained weights. PEANuT provides a flexible yet efficient way to capture complex update patterns without full model tuning. We theoretically show that PEANuT achieves equivalent or greater expressivity than existing linear PEFT methods with comparable or fewer parameters. Extensive experiments across four benchmarks with over twenty datasets demonstrate that PEANuT consistently outperforms strong baselines in both NLP and vision tasks, while maintaining low computational overhead.
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=PEANUT"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+# API
+
+## PeanutConfig
+
+[[autodoc]] tuners.peanut.config.PeanutConfig
+
+## PeanutModel
+
+[[autodoc]] tuners.peanut.model.PeanutModel
+
diff --git a/docs/source/package_reference/peft_model.md b/docs/source/package_reference/peft_model.md
new file mode 100644
index 0000000..366ef91
--- /dev/null
+++ b/docs/source/package_reference/peft_model.md
@@ -0,0 +1,77 @@
+<!--⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+-->
+
+# Models
+
+[`PeftModel`] is the base model class for specifying the base Transformer model and configuration to apply a PEFT method to. The base `PeftModel` contains methods for loading and saving models from the Hub.
+
+## PeftModel
+
+[[autodoc]] PeftModel
+    - all
+
+## PeftModelForSequenceClassification
+
+A `PeftModel` for sequence classification tasks.
+
+[[autodoc]] PeftModelForSequenceClassification
+    - all
+
+## PeftModelForTokenClassification
+
+A `PeftModel` for token classification tasks.
+
+[[autodoc]] PeftModelForTokenClassification
+    - all
+
+## PeftModelForCausalLM
+
+A `PeftModel` for causal language modeling.
+
+[[autodoc]] PeftModelForCausalLM
+    - all
+
+## PeftModelForSeq2SeqLM
+
+A `PeftModel` for sequence-to-sequence language modeling.
+
+[[autodoc]] PeftModelForSeq2SeqLM
+    - all
+
+## PeftModelForQuestionAnswering
+
+A `PeftModel` for question answering.
+
+[[autodoc]] PeftModelForQuestionAnswering
+    - all
+
+## PeftModelForFeatureExtraction
+
+A `PeftModel` for getting extracting features/embeddings from transformer models.
+
+[[autodoc]] PeftModelForFeatureExtraction
+    - all
+
+## PeftMixedModel
+
+A `PeftModel` for mixing different adapter types (e.g. LoRA and LoHa).
+
+[[autodoc]] PeftMixedModel
+    - all
+
+## Utilities
+
+[[autodoc]] utils.cast_mixed_precision_params
+
+[[autodoc]] get_peft_model
+
+[[autodoc]] inject_adapter_in_model
+
+[[autodoc]] utils.get_peft_model_state_dict
+
+[[autodoc]] utils.prepare_model_for_kbit_training
+
+[[autodoc]] get_layer_status
+
+[[autodoc]] get_model_status
diff --git a/docs/source/package_reference/peft_types.md b/docs/source/package_reference/peft_types.md
new file mode 100644
index 0000000..55edbbd
--- /dev/null
+++ b/docs/source/package_reference/peft_types.md
@@ -0,0 +1,27 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# PEFT types
+
+[`PeftType`] includes the supported adapters in PEFT, and [`TaskType`] includes PEFT-supported tasks.
+
+## PeftType
+
+[[autodoc]] utils.peft_types.PeftType
+
+## TaskType
+
+[[autodoc]] utils.peft_types.TaskType
\ No newline at end of file
diff --git a/docs/source/package_reference/poly.md b/docs/source/package_reference/poly.md
new file mode 100644
index 0000000..3dd2a20
--- /dev/null
+++ b/docs/source/package_reference/poly.md
@@ -0,0 +1,48 @@
+<!--Copyright 2024 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# Polytropon
+
+[Polytropon](https://hf.co/papers/2202.13914) is a multitask model with a number of different LoRA adapters in its "inventory". The model learns the correct combination of adapters from the inventory with a routing function to choose the best subset of modules for a specific task. PEFT also supports [Multi-Head Adapter Routing (MHR)](https://hf.co/papers/2211.03831) for Polytropon which builds on and improves the routing function by combining the adapter heads more granularly. The adapter heads are separated into disjoint blocks and a different routing function is learned for each one, allowing for more expressivity.
+
+<hfoptions id="paper">
+<hfoption id="Combining Modular Skills in Multitask Learning">
+
+The abstract from the paper is:
+
+*A modular design encourages neural models to disentangle and recombine different facets of knowledge to generalise more systematically to new tasks. In this work, we assume that each task is associated with a subset of latent discrete skills from a (potentially small) inventory. In turn, skills correspond to parameter-efficient (sparse / low-rank) model parameterisations. By jointly learning these and a task-skill allocation matrix, the network for each task is instantiated as the average of the parameters of active skills. To favour non-trivial soft partitions of skills across tasks, we experiment with a series of inductive biases, such as an Indian Buffet Process prior and a two-speed learning rate. We evaluate our latent-skill model on two main settings: 1) multitask reinforcement learning for grounded instruction following on 8 levels of the BabyAI platform; and 2) few-shot adaptation of pre-trained text-to-text generative models on CrossFit, a benchmark comprising 160 NLP tasks. We find that the modular design of a network significantly increases sample efficiency in reinforcement learning and few-shot generalisation in supervised learning, compared to baselines with fully shared, task-specific, or conditionally generated parameters where knowledge is entangled across tasks. In addition, we show how discrete skills help interpretability, as they yield an explicit hierarchy of tasks.*
+
+</hfoption>
+<hfoption id="Multi-Head Adapter Routing for Cross-Task Generalization">
+
+The abstract from the paper is:
+
+*Parameter-efficient fine-tuning (PEFT) for cross-task generalization consists in pre-training adapters on a multi-task training set before few-shot adaptation to test tasks. Polytropon [Ponti et al., 2023] (Poly) jointly learns an inventory of adapters and a routing function that selects a (variable-size) subset of adapters for each task during both pre-training and few-shot adaptation. In this paper, we investigate the role that adapter routing plays in its success and design new variants based on our findings. First, we build on the intuition that finer-grained routing provides more expressivity. Hence, we propose MHR (Multi-Head Routing), which combines subsets of adapter parameters and outperforms Poly under a comparable parameter budget; by only fine-tuning the routing function and not the adapters (MHR-z), we achieve competitive performance with extreme parameter efficiency. Second, we find that Poly/MHR performance is a result of better multi-task optimization, rather than modular inductive biases that facilitate adapter recombination and local adaptation, as previously hypothesized. In fact, we find that MHR exhibits higher gradient alignment between tasks than any other method. Since this implies that routing is only crucial during multi-task pre-training, we propose MHR-mu, which discards routing and fine-tunes the average of the pre-trained adapters during few-shot adaptation. This establishes MHR-mu as an effective method for single-adapter fine-tuning.*.
+
+</hfoption>
+</hfoptions>
+
+In case you want to try out routing without training first, you can check out the [Arrow LoRA variant](./lora#Arrow).
+
+# API
+
+## PolyConfig
+
+[[autodoc]] tuners.poly.config.PolyConfig
+
+## PolyModel
+
+[[autodoc]] tuners.poly.model.PolyModel
diff --git a/docs/source/package_reference/prefix_tuning.md b/docs/source/package_reference/prefix_tuning.md
new file mode 100644
index 0000000..06ec4c5
--- /dev/null
+++ b/docs/source/package_reference/prefix_tuning.md
@@ -0,0 +1,123 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# Prefix tuning
+
+<div class="flex justify-center">
+    <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/peft/prefix-tuning.png"/>
+</div>
+<small>Optimize the prefix parameters for each task <a href="https://hf.co/papers/2101.00190">(image source)</a>.</small>
+
+[Prefix tuning](https://hf.co/papers/2101.00190) prefixes a series of task-specific vectors to the input sequence that can be learned while keeping the pretrained model frozen. The prefix parameters are inserted in all of the model layers.
+
+The abstract from the paper is:
+
+*Fine-tuning is the de facto way to leverage large pretrained language models to perform downstream tasks. However, it modifies all the language model parameters and therefore necessitates storing a full copy for each task. In this paper, we propose prefix-tuning, a lightweight alternative to fine-tuning for natural language generation tasks, which keeps language model parameters frozen, but optimizes a small continuous task-specific vector (called the prefix). Prefix-tuning draws inspiration from prompting, allowing subsequent tokens to attend to this prefix as if it were "virtual tokens". We apply prefix-tuning to GPT-2 for table-to-text generation and to BART for summarization. We find that by learning only 0.1\% of the parameters, prefix-tuning obtains comparable performance in the full data setting, outperforms fine-tuning in low-data settings, and extrapolates better to examples with topics unseen during training*.
+
+**Note** For encoder-decoder models (seq2seq), the prefix is only applied to the decoder, which does not correspond to the paper specification (see e.g. Figure 2). Prefix tuning can still be fine-tuned on these model architectures but the performance could be sub-par; consider using other PEFT methods for encoder-decoder models.
+
+Prefix tuning is very similar to [prompt tuning](../package_reference/prompt_tuning). The main difference is that the prefix parameters are inserted in **all** of the model layers, whereas prompt tuning only adds the prompt parameters to the model input embeddings. The prefix parameters are also optimized by a separate feed-forward network (FFN) instead of training directly on the soft prompts because it causes instability and hurts performance. The FFN is discarded after updating the soft prompts.
+
+As a result, the authors found that prefix tuning demonstrates comparable performance to fully finetuning a model, despite having 1000x fewer parameters, and it performs even better in low-data settings.
+
+## Basic Usage
+
+Create a [`PrefixTuningConfig`] with the task type and number of virtual tokens to add and learn.
+
+```py
+from peft import PrefixTuningConfig, get_peft_model
+
+peft_config = PrefixTuningConfig(task_type="CAUSAL_LM", num_virtual_tokens=20)
+model = get_peft_model(model, peft_config)
+model.print_trainable_parameters()
+"trainable params: 983,040 || all params: 560,197,632 || trainable%: 0.1754809274167014"
+```
+
+## Possible Initializations
+
+By default, prefix tuning uses randomly initialized virtual tokens. There's also the option to initialize the vectors
+to be close to a no-op (initialized to zero, it will still shift the probability mass a bit).
+This means that the KV-cache injected prefixes have less impact from the beginning and reduces the variance in training
+performance.
+
+PEFT also provides utilities to initialize a prefix-tuning adapter from an existing KV cache prefix (for example, from
+the first `p` tokens of a prompt/corpus). This is only supported when `prefix_projection=False` (the default), because
+in that case the learned parameters are the KV prefix itself.
+
+```py
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from peft import PrefixTuningConfig, get_peft_model, initialize_kv_prefix_from_text
+
+base = AutoModelForCausalLM.from_pretrained("gpt2")
+tok = AutoTokenizer.from_pretrained("gpt2")
+
+peft_cfg = PrefixTuningConfig(task_type="CAUSAL_LM", num_virtual_tokens=20, prefix_projection=False)
+model = get_peft_model(base, peft_cfg)
+
+initialize_kv_prefix_from_text(
+    model,
+    tok,
+    text="...a long context with at least num_virtual_tokens tokens...",
+    use_chat_template=False,
+)m peft import PrefixTuningConfig, get_peft_model, initialize_kv_prefix_from_text
+
+base = AutoModelForCausalLM.from_pretrained("gpt2")
+tok = AutoTokenizer.from_pretrained("gpt2")
+
+peft_cfg = PrefixTuningConfig(task_type="CAUSAL_LM", num_virtual_tokens=20, prefix_projection=False)
+model = get_peft_model(base, peft_cfg)
+
+initialize_kv_prefix_from_text(
+    model,
+    tok,
+    text="...a long context with at least num_virtual_tokens tokens...",
+    use_chat_template=False,
+)
+
+```
+
+Make sure the text is long enough to produce at least `num_virtual_tokens` tokens, otherwise initialization will fail.
+
+As a guideline:
+
+* start with a neutral starting sequence using `initialize_kv_prefix_from_text`, it can be a very short string like
+  "Question: "
+* if that doesn't help, use a longer sequence with task relevance (i.e. an engineered prompt), giving you more virtual
+  tokens to fit but also more steering of the model
+* if it is not possible to use an initialization text or you want to quickly check if prefix tuning is viable at all,
+  use a zero init without projection
+
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=PREFIX_TUNING"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+
+# API
+
+## PrefixTuningConfig
+
+[[autodoc]] tuners.prefix_tuning.config.PrefixTuningConfig
+
+## PrefixEncoder
+
+[[autodoc]] tuners.prefix_tuning.model.PrefixEncoder
diff --git a/docs/source/package_reference/prompt_tuning.md b/docs/source/package_reference/prompt_tuning.md
new file mode 100644
index 0000000..e03be04
--- /dev/null
+++ b/docs/source/package_reference/prompt_tuning.md
@@ -0,0 +1,74 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# Prompt tuning
+
+<div class="flex justify-center">
+    <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/peft/prompt-tuning.png"/>
+</div>
+<small>Only train and store a significantly smaller set of task-specific prompt parameters <a href="https://hf.co/papers/2104.08691">(image source)</a>.</small>
+
+[Prompt tuning](https://hf.co/papers/2104.08691) adds a task-specific, virtual prompt to the input that consists of trainable vectors in the embedding space. The virtual token parameters are updated independently of the pretrained model parameters which are frozen.
+
+The abstract from the paper is:
+
+*In this work, we explore "prompt tuning", a simple yet effective mechanism for learning "soft prompts" to condition frozen language models to perform specific downstream tasks. Unlike the discrete text prompts used by GPT-3, soft prompts are learned through backpropagation and can be tuned to incorporate signal from any number of labeled examples. Our end-to-end learned approach outperforms GPT-3's "few-shot" learning by a large margin. More remarkably, through ablations on model size using T5, we show that prompt tuning becomes more competitive with scale: as models exceed billions of parameters, our method "closes the gap" and matches the strong performance of model tuning (where all model weights are tuned). This finding is especially relevant in that large models are costly to share and serve, and the ability to reuse one frozen model for multiple downstream tasks can ease this burden. Our method can be seen as a simplification of the recently proposed "prefix tuning" of Li and Liang (2021), and we provide a comparison to this and other similar approaches. Finally, we show that conditioning a frozen model with soft prompts confers benefits in robustness to domain transfer, as compared to full model tuning*.
+
+In contrast to [prefix tuning](../package_reference/prefix_tuning), only the
+input of the first layer receives the virtual tokens.
+
+## Usage
+
+There are two decisions to take: how many virtual tokens are added to the
+input of the model (`num_virtual_tokens`) - this will define how many
+trainable parameters there will be - and how these tokens are initialized.
+
+Create a [`PromptTuningConfig`] with the task type, the initial prompt tuning text to train the model with, the number of virtual tokens to add and learn, and a tokenizer.
+
+```py
+from peft import PromptTuningConfig, PromptTuningInit, get_peft_model
+
+prompt_tuning_init_text = "Classify if the tweet is a complaint or no complaint.\n"
+peft_config = PromptTuningConfig(
+    task_type="CAUSAL_LM",
+    prompt_tuning_init=PromptTuningInit.TEXT,
+    num_virtual_tokens=len(tokenizer(prompt_tuning_init_text)["input_ids"]),
+    prompt_tuning_init_text=prompt_tuning_init_text,
+    tokenizer_name_or_path="bigscience/bloomz-560m",
+)
+model = get_peft_model(model, peft_config)
+model.print_trainable_parameters()
+"trainable params: 8,192 || all params: 559,222,784 || trainable%: 0.0014648902430985358"
+```
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=PROMPT_TUNING"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+# API
+
+## PromptTuningConfig
+
+[[autodoc]] tuners.prompt_tuning.config.PromptTuningConfig
+
+## PromptEmbedding
+
+[[autodoc]] tuners.prompt_tuning.model.PromptEmbedding
diff --git a/docs/source/package_reference/psoft.md b/docs/source/package_reference/psoft.md
new file mode 100644
index 0000000..d5aaeed
--- /dev/null
+++ b/docs/source/package_reference/psoft.md
@@ -0,0 +1,139 @@
+<!--Copyright 2026 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# PSOFT
+
+[PSOFT](https://hf.co/papers/2505.11235) is an Orthogonal Fine-Tuning (OFT)-based parameter-efficient fine-tuning method that preserves the geometric relationships of pre-trained weight column vectors while achieving a balanced trade-off between performance and multi-dimensional efficiency, including parameter count, memory usage, and computational cost. By restricting orthogonal transformations to a low-rank principal subspace derived from pre-trained weights, PSOFT bridges the gap between LoRA and OFT, providing both theoretical guarantees and practical adaptability. Its effectiveness is validated through extensive evaluations on diverse benchmarks, including GLUE, VTAB-1K, GSM8K, MATH, and commonsense reasoning benchmarks.
+
+- Only `nn.Linear` layers are supported.
+- Quantized layers are not supported.
+
+The abstract from the paper is:
+
+*Driven by the rapid growth of model parameters, parameter-efficient fine-tuning (PEFT) has become essential for adapting large models to diverse downstream tasks under constrained computational resources. Within this paradigm, orthogonal fine-tuning and its variants preserve semantic representations of pre-trained models, but struggle to achieve both expressiveness and efficiency in terms of parameter counts, memory, and computation. To overcome this limitation, we propose efficient Orthogonal Fine-Tuning with Principal Subspace adaptation (PSOFT), which confines orthogonal transformations to the principal subspace of pre-trained weights. Specifically, PSOFT constructs this subspace via matrix decomposition to enable compatible transformations, establishes a theoretical condition that strictly maintains the geometry of this subspace for essential semantic preservation, and introduces efficient tunable vectors that gradually relax orthogonality during training to enhance adaptability. Extensive experiments on 35 NLP and CV tasks across four representative models demonstrate that PSOFT offers a practical and scalable solution to simultaneously achieve semantic preservation, expressiveness, and multi-dimensional efficiency in PEFT.*
+
+
+## How PSOFT Works
+
+PSOFT decomposes each weight matrix $W_{pre}$ into $W_{pri}$ and $W_{res}$ using SVD:
+$W_{\text{pre}} = U S V^\top$
+
+The principal subspace $W_{\text{pri}} = U_r S_r V_r^\top = AB$ is constructed from the top-$r$ singular components:
+
+$W_{\text{pre}} = W_{\text{pri}} + W_{\text{res}} = AB + W_{\text{res}},$
+
+
+$W_{\text{ps-tuned}} = ARB + W_{\text{res}}.$ (PSOFT-SO: PSOFT with strict orthogonality)
+
+
+$W_{\text{ps-tuned}} = A \, \mathrm{diag}(\alpha) \, R \, \mathrm{diag}(\beta) \, B + W_{\text{res}}.$ (PSOFT-RO: PSOFT with relaxed orthogonality)
+
+During training, $A$, $B$, and $W_{\text{res}}$ are frozen, and only $R$ (or $R$ with $\alpha$ and $\beta$) is trainable.
+
+For compatibility with the PEFT framework (which expects additive weight updates), PSOFT is implemented in the following additive form:
+$W_{\text{ps-tuned}} = W_{\text{pre}} + A (R - I_r) B$
+
+
+## Trainable Parameters
+
+After applying PSOFT:
+
+- The original model weights ($A$, $B$, and $W_{\text{res}}$) are frozen.
+- Only the orthogonal matrix $R$ (and optionally $\alpha$, $\beta$) are trainable.
+- No additional bias parameters are introduced.
+
+## Basic Usage
+```python
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from peft import PsoftConfig, get_peft_model
+
+# Load base model
+model_id = "facebook/opt-125m"
+model = AutoModelForCausalLM.from_pretrained(model_id)
+
+# Configure PSOFT
+config = PsoftConfig(
+    r=32,                                   # the dimension of trainable matrix R,
+    psoft_alpha=32,                         # scaling factor (typically set to r in PSOFT),
+    target_modules=["q_proj", "v_proj"],    # target attention projection layers
+    ab_svd_init="psoft_init",        # principal subspace initialization
+    psoft_svd="full",                       # SVD method
+    psoft_orth=True,                        # enable orthogonal R (Cayley parameterization)
+    psoft_mag_a=True,                       # enable tunable vector alpha
+    psoft_mag_b=True,                       # enable tunable vector beta
+    use_cayley_neumann=False,               # disable Cayley–Neumann approximation
+    num_cayley_neumann_terms=5,             # number of Neumann series terms
+    cayley_neumann_eps=None,                # improve numerical stability
+)
+
+# Apply PSOFT
+model = get_peft_model(model, config)
+model.train()
+
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+tokenizer.pad_token = tokenizer.eos_token
+
+# Train
+inputs = tokenizer("Hello world", return_tensors="pt", padding=True)
+loss = model(**inputs, labels=inputs["input_ids"]).loss
+loss.backward()
+
+trainable = [p for p in model.parameters() if p.requires_grad]
+optimizer = torch.optim.AdamW(trainable, lr=5e-4)
+optimizer.step()
+optimizer.zero_grad(set_to_none=True)
+```
+## Configuration Options
+
+### Different Mode
+
+(PSOFT-SO: PSOFT with strict orthogonality)
+
+```python
+config = PsoftConfig(psoft_orth=True,psoft_mag_a=False,psoft_mag_b=False)
+```
+
+(PSOFT-RO: PSOFT with relaxed orthogonality)
+```python
+config = PsoftConfig(psoft_orth=True,psoft_mag_a=True,psoft_mag_b=True)
+```
+
+### Best Practices
+1. **Rank Choice**: Smaller ranks (e.g., `32–128`) are suitable for simpler tasks, while larger ranks (e.g., `64–256`) provide greater expressiveness for more complex tasks at the cost of increased parameters and computation.
+2. **Scaling Factor**: The scaling factor is typically set to $r$ in PSOFT.
+3. **Learning Rate**: Use standard learning rates (e.g., `1e-4` to `5e-3`) for stable training.
+4. **SVD Initialization**: The `lowrank` option is more memory- and compute-efficient than `full`, making it more suitable for large models.
+5. **Cayley–Neumann Approximation**: When the rank is large, enabling the Cayley–Neumann approximation can significantly improve computational efficiency, while the benefit is less pronounced for small ranks. In practice, a small number of Neumann series terms (typically `5`) usually provides a good balance between accuracy and efficiency.
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=PSOFT"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+# API
+
+## PsoftConfig
+
+[[autodoc]] tuners.psoft.config.PsoftConfig
+
+## PsoftModel
+
+[[autodoc]] tuners.psoft.model.PsoftModel
diff --git a/docs/source/package_reference/pvera.md b/docs/source/package_reference/pvera.md
new file mode 100644
index 0000000..d0c6ca4
--- /dev/null
+++ b/docs/source/package_reference/pvera.md
@@ -0,0 +1,51 @@
+<!--Copyright 2025 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# PVeRA: Probabilistic Vector-Based Random Matrix Adaptation
+
+[PVeRA](https://huggingface.co/papers/2512.07703) is a parameter-efficient fine-tuning technique that is base on VeRA, in the family of the LoRA-based adapters. It keeps the very low parameter budget of VeRA, but increases the performance by learning a distribution of latent adaptations. This also enables models adapted with PVeRA to generate Monte Carlo confidence interval estimates, by sampling from the learned distribution at inference.
+
+When saving the adapter parameters, it's possible to eschew storing the low rank matrices by setting `save_projection=False` on the `PveraConfig`. In that case, these matrices will be restored based on the fixed random seed from the `projection_prng_key` argument. This cuts down on the size of the checkpoint, but we cannot guarantee reproducibility on all devices and for all future versions of PyTorch. If you want to ensure reproducibility, set `save_projection=True` (which is the default).
+
+To handle different shapes of adapted layers, PVeRA initializes shared A and B matrices with the largest required size for each dimension. During the forward pass, submatrices A and B for a given layer are sliced out from these shared matrices and used as described in the paper. For example, adapting two linear layers of shapes (100, 20) and (80, 50) will create A and B matrices of shapes (rank, 50) and (100, rank) respectively. Then, to adapt a layer of shape (100, 20), submatrices A and B of shapes (rank, 20) and (100, rank) will be extracted.
+
+PVeRA currently has the following constraint:
+
+- Only `nn.Linear` layers are supported.
+- The latent representation is not easily accessible, for training using the KL divergence.
+
+The abstract from the paper is:
+
+> Large foundation models have emerged in the last years and are pushing performance boundaries for a variety of tasks. Training or even finetuning such models demands vast datasets and computational resources, which are often scarce and costly. Adaptation methods provide a computationally efficient solution to address these limitations by allowing such models to be finetuned on small amounts of data and computing power. This is achieved by appending new trainable modules to frozen backbones with only a fraction of the trainable parameters and fitting only these modules on novel tasks. Recently, the VeRA adapter was shown to excel in parameter-efficient adaptations by utilizing a pair of frozen random low-rank matrices shared across all layers. In this paper, we propose PVeRA, a probabilistic version of the VeRA adapter, which modifies the low-rank matrices of VeRA in a probabilistic manner. This modification naturally allows handling inherent ambiguities in the input and allows for different sampling configurations during training and testing. A comprehensive evaluation was performed on the VTAB-1k benchmark and seven adapters, with PVeRA outperforming VeRA and other adapters.
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=PVERA"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+# API
+
+## PveraConfig
+
+[[autodoc]] tuners.pvera.config.PveraConfig
+
+## PveraModel
+
+[[autodoc]] tuners.pvera.model.PveraModel
diff --git a/docs/source/package_reference/randlora.md b/docs/source/package_reference/randlora.md
new file mode 100644
index 0000000..9902364
--- /dev/null
+++ b/docs/source/package_reference/randlora.md
@@ -0,0 +1,56 @@
+<!--Copyright 2025 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# RandLora: Full-rank parameter-efficient fine-tuning of large models
+[RandLora](https://huggingface.co/papers/2502.00987) is a parameter-efficient fine-tuning technique that is similar to [LoRA](https://huggingface.co/papers/2106.09685) and [VeRA](https://huggingface.co/papers/2310.11454) but performs full rank updates to improve performance. RandLora can be particularly useful when adapting large model to hard tasks that require complex updates while preserving the parameter efficiency of LoRA. The full rank update of RandLora is achieved by linearly scaling random bases. The random bases are a collection of multiple low rank matrices such that the summation of their ranks if greater or equal to the full rank of the parameter matrices. The trainable parameters of RandLora are two diagonal matrices (vectors) that get multiplied with the right hand low rank random bases, in a similar way to VeRA's update. To maintain low memory usage, RandLora uses a custom function that prevents storing unnecessary bases in memory for backpropagation.
+
+RandLora presents the noteworthy difference that contrary to other LoRA-like PEFT algorithm, increasing RandLora's random base ranks increases the amount of trainable parameters. Because number of bases x bases rank is constant in RandLora, reducing the rank will increase the number of random bases, hence the number of base-specific trainable diagonal bases.
+
+Because reducing the rank of RandLora's random bases will increase their number, RandLora can become slower to train than LoRA for very small ranks where typically, ranks below 4 with result in a large training time increase. This does not affect inference though as the RandLora adapters can be merged into the pretrained weight matrices.
+
+RandLora additionally supports training with sparse, ternary random bases (only containing -1, 0 and 1). These bases are as described in [Bingham et al.](https://cs-people.bu.edu/evimaria/cs565/kdd-rp.pdf) and [Ping et al.](https://hastie.su.domains/Papers/Ping/KDD06_rp.pdf) and could theoretically be used to reduce compute needs by performing aggregations instead of matrix multiplications to create the weight update. This is not currently supported. Although it does not currently reduce compute, using sparse random bases in RandLora can reduce overfitting in some cases. For users interested in using sparse ternary bases, the `sparse` option is recommended over the `very_sparse` one that can reduce performance.
+
+Similarly to VeRA, when saving the RandLora's parameters, it's possible to eschew storing the low rank matrices by setting `save_projection=False` on the `VeraConfig`. In that case, these matrices will be restored based on the fixed random seed from the `projection_prng_key` argument. This cuts down on the size of the checkpoint, but we cannot guarantee reproducibility on all devices and for all future versions of PyTorch. If you want to ensure reproducibility, set `save_projection=True` (which is the default).
+
+As in Vera and to handle different shapes of adapted layers, RandLora initializes shared A and B matrices with the largest required size for each dimension. During the forward pass, submatrices A and B for a given layer are sliced out from these shared matrices and used as described in the paper. For example, adapting two linear layers of shapes (100, 20) and (80, 50) will create A and B matrices of shapes (rank, 50) and (100, rank) respectively. Then, to adapt a layer of shape (100, 20), submatrices A and B of shapes (rank, 20) and (100, rank) will be extracted.
+
+RandLora currently has the following constraint:
+
+- Only `nn.Linear` layers are supported.
+
+The abstract from the paper is:
+
+> Low-Rank Adaptation (LoRA) and its variants have shown impressive results in reducing the number of trainable parameters and memory requirements of large transformer networks while maintaining fine-tuning performance. The low-rank nature of the weight update inherently limits the representation power of fine-tuned models, however, thus potentially compromising performance on complex tasks. This raises a critical question: when a performance gap between LoRA and standard fine-tuning is observed, is it due to the reduced number of trainable parameters or the rank deficiency?
+This paper aims to answer this question by introducing RandLora, a parameter-efficient method that performs full-rank updates using a learned linear combinations of low-rank, non-trainable random matrices. Our method limits the number of trainable parameters by restricting optimization to diagonal scaling matrices applied to the fixed random matrices. This allows us to effectively overcome the low-rank limitations while maintaining parameter and memory efficiency during training. Through extensive experimentation across vision, language, and vision-language benchmarks, we systematically evaluate the limitations of LoRA and existing random basis methods. Our findings reveal that full-rank updates are beneficial across vision and language tasks individually, and even more so for vision-language tasks, where RandLora significantly reduces---and sometimes eliminates---the performance gap between standard fine-tuning and LoRA, demonstrating its efficacy.
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=RANDLORA"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+# API
+
+## RandLoraConfig
+
+[[autodoc]] tuners.randlora.config.RandLoraConfig
+
+## RandLoraModel
+
+[[autodoc]] tuners.randlora.model.RandLoraModel
diff --git a/docs/source/package_reference/road.md b/docs/source/package_reference/road.md
new file mode 100644
index 0000000..31a6f30
--- /dev/null
+++ b/docs/source/package_reference/road.md
@@ -0,0 +1,42 @@
+<!--Copyright 2025 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# RoAd
+
+[RoAd](https://huggingface.co/papers/2409.00119) is a parameter‑efficient fine‑tuning technique that adapts large language models by learning a small set of 2×2 rotation matrices (and optional scaling factors) applied to pairs of hidden dimensions. RoAd achieves competitive or superior performance compared to other PEFT methods with under 0.1% trainable parameters. Unlike LoRA’s batched low‑rank updates, RoAd’s sparse rotations reformulate to simple element‑wise operations, yielding significantly higher serving throughput when handling heterogeneous requests in the same batch, i.e. serving multiple adapters simultaneously. Moreover, RoAd integrates seamlessly into a distributed interchange intervention framework, interpreting its sparse 2D rotations as task-specific interventions within learned subspaces of hidden representations. These orthogonal subspaces can be composed to merge multiple task-specific behaviors—like multilingual capabilities or instruction following—without additional fine-tuning, enabling modular, interpretable adaptations in LLMs.
+
+Finetuning with RoAd typically requires higher learning rate compared to LoRA or similar methods, around 1e-3. Currently RoAd only supports linear layers and it can be used on models quantized with bitsandbytes (4-bit or 8-bit).
+
+For running inference with different RoAd adapters in the same batch see [Inference with different LoRA adapters in the same batch](lora#inference-with-different-lora-adapters-in-the-same-batch).
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=ROAD"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+# API
+
+## RoadConfig
+
+[[autodoc]] tuners.road.config.RoadConfig
+
+## RoadModel
+
+[[autodoc]] tuners.road.model.RoadModel
diff --git a/docs/source/package_reference/shira.md b/docs/source/package_reference/shira.md
new file mode 100644
index 0000000..05d12dd
--- /dev/null
+++ b/docs/source/package_reference/shira.md
@@ -0,0 +1,46 @@
+<!--Copyright 2025 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# Sparse High Rank Adapters
+
+Sparse High Rank Adapters or [SHiRA](https://huggingface.co/papers/2406.13175) is an alternate type of adapter and has been found to have significant advantages over the low rank adapters. Specifically, SHiRA achieves better accuracy than LoRA for a variety of vision and language tasks. It also offers simpler and higher quality multi-adapter fusion by significantly reducing concept loss, a common problem faced by low rank adapters. SHiRA directly finetunes a small number of the base model's parameters to finetune the model on any adaptation task.
+
+SHiRA currently has the following constraint:
+
+- Only `nn.Linear` layers are supported.
+
+The abstract from the paper is:
+
+> Low Rank Adaptation (LoRA) has gained massive attention in the recent generative AI research. One of the main advantages of LoRA is its ability to be fused with pretrained models, adding no overhead during inference. However, from a mobile deployment standpoint, we can either avoid inference overhead in the fused mode but lose the ability to switch adapters rapidly, or suffer significant (up to 30% higher) inference latency while enabling rapid switching in the unfused mode. LoRA also exhibits concept-loss when multiple adapters are used concurrently. In this paper, we propose Sparse High Rank Adapters (SHiRA), a new paradigm which incurs no inference overhead, enables rapid switching, and significantly reduces concept-loss. Specifically, SHiRA can be trained by directly tuning only 1-2% of the base model weights while leaving others unchanged. This results in a highly sparse adapter which can be switched directly in the fused mode. We further provide theoretical and empirical insights on how high sparsity in SHiRA can aid multi-adapter fusion by reducing concept loss. Our extensive experiments on LVMs and LLMs demonstrate that finetuning only a small fraction of the parameters in the base model significantly outperforms LoRA while enabling both rapid switching and multi-adapter fusion. Finally, we provide a latency- and memory-efficient SHiRA implementation based on Parameter-Efficient Finetuning (PEFT) Library which trains at nearly the same speed as LoRA while consuming up to 16% lower peak GPU memory, thus making SHiRA easy to adopt for practical use cases. To demonstrate rapid switching benefits during inference, we show that loading SHiRA on a base model can be 5x-16x faster than LoRA fusion on a CPU.
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=SHIRA"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+# API
+
+## ShiraConfig
+
+[[autodoc]] tuners.shira.config.ShiraConfig
+
+## ShiraModel
+
+[[autodoc]] tuners.shira.model.ShiraModel
diff --git a/docs/source/package_reference/tinylora.md b/docs/source/package_reference/tinylora.md
new file mode 100644
index 0000000..16bcaf2
--- /dev/null
+++ b/docs/source/package_reference/tinylora.md
@@ -0,0 +1,52 @@
+<!--Copyright 2025 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# TinyLoRA: Learning to Reason in 13 Parameters
+
+[TinyLoRA](https://huggingface.co/papers/2602.04118) is an extremely parameter-efficient fine-tuning technique that builds upon the [LoRA-XS](https://huggingface.co/papers/2405.17604) approach by using SVD decomposition of frozen weights and projecting a tiny trainable vector through fixed random tensors. When combined with reinforcement learning (RL) training methods like GRPO, TinyLoRA can achieve competitive performance with as few as 1-13 trainable parameters.
+
+The key innovation of TinyLoRA is replacing the trainable low-rank matrix R with a weighted sum of fixed random projection matrices: `R = Σᵢ vᵢ Pᵢ`, where `v ∈ R^u` is a tiny trainable vector of dimension `u` and `Pᵢ` are fixed random matrices. This dramatically reduces the number of trainable parameters while maintaining competitive performance.
+
+TinyLoRA supports weight tying through the `weight_tying` parameter, a ratio between 0.0 and 1.0 that controls how many modules share the same trainable vector `v`. Setting `weight_tying=0.0` (the default) means no sharing, while `weight_tying=1.0` means full sharing across all target modules — achieving extreme parameter efficiency with just a single vector of `u` trainable parameters for the entire model.
+
+When saving the adapter parameters, it's possible to eschew storing the random projection matrices by setting `save_projection=False` on the `TinyLoraConfig`. In that case, these matrices will be restored based on the fixed random seed from the `projection_seed` argument. This cuts down on the size of the checkpoint, but we cannot guarantee reproducibility on all devices and for all future versions of PyTorch. If you want to ensure reproducibility, set `save_projection=True` (which is the default).
+
+TinyLoRA currently has the following constraints:
+
+- Only `nn.Linear`, `nn.Embedding`, and `transformers.pytorch_utils.Conv1D` layers are supported.
+
+The abstract from the paper is:
+
+> Recent research has shown that language models can learn to reason, often via reinforcement learning. Some work even trains low-rank parameterizations for reasoning, but conventional LoRA cannot scale below the model dimension. We question whether even rank=1 LoRA is necessary for learning to reason and propose TinyLoRA, a method for scaling low-rank adapters to sizes as small as one parameter. Within our new parameterization, we are able to train the 8B parameter size of Qwen2.5 to 91% accuracy on GSM8K with only 13 trained parameters in bf16 (26 total bytes). We find this trend holds in general: we are able to recover 90% of performance improvements while training 1000x fewer parameters across a suite of more difficult learning-to-reason benchmarks such as AIME, AMC, and MATH500. Notably, we are only able to achieve such strong performance with RL: models trained using SFT require 100-1000x larger updates to reach the same performance.
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=TINYLORA"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+# API
+
+## TinyLoraConfig
+
+[[autodoc]] tuners.tinylora.config.TinyLoraConfig
+
+## TinyLoraModel
+
+[[autodoc]] tuners.tinylora.model.TinyLoraModel
diff --git a/docs/source/package_reference/trainable_tokens.md b/docs/source/package_reference/trainable_tokens.md
new file mode 100644
index 0000000..42d22a3
--- /dev/null
+++ b/docs/source/package_reference/trainable_tokens.md
@@ -0,0 +1,61 @@
+<!--Copyright 2025 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# Trainable Tokens
+
+The Trainable Tokens method provides a way to target specific token embeddings for fine-tuning without resorting to
+training the full embedding matrix or using an adapter on the embedding matrix. It is based on the initial implementation from
+[here](https://github.com/huggingface/peft/pull/1541).
+
+The method only targets specific tokens and selectively trains the token indices you specify. Consequently the
+required RAM will be lower and disk memory is also significantly lower than storing the full fine-tuned embedding matrix.
+
+Some preliminary benchmarks acquired with [this script](https://github.com/huggingface/peft/blob/main/scripts/train_memory.py)
+suggest that for `gemma-2-2b` (which has a rather large embedding matrix) you can save ~4 GiB VRAM with Trainable Tokens
+over fully fine-tuning the embedding matrix. While LoRA will use comparable amounts of VRAM it might also target
+tokens you don't want to be changed. Note that these are just indications and varying embedding matrix sizes might skew
+these numbers a bit.
+
+Note that this method does not add tokens for you, you have to add tokens to the tokenizer yourself and resize the
+embedding matrix of the model accordingly. This method will only re-train the embeddings for the tokens you specify.
+This method can also be used in conjunction with LoRA layers! See [the LoRA documentation](lora#efficiently-train-tokens-alongside-lora).
+
+> [!TIP]
+> Saving the model with [`~PeftModel.save_pretrained`] or retrieving the state dict using
+> [`get_peft_model_state_dict`] when adding new tokens may save the full embedding matrix instead of only the difference
+> as a precaution because the embedding matrix was resized. To save space you can disable this behavior by setting
+> `save_embedding_layers=False` when calling `save_pretrained`. This is safe to do as long as you don't modify the
+> embedding matrix through other means as well, as such changes will be not tracked by trainable tokens.
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=TRAINABLE_TOKENS"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+# API
+
+## TrainableTokensConfig
+
+[[autodoc]] tuners.trainable_tokens.config.TrainableTokensConfig
+
+## TrainableTokensModel
+
+[[autodoc]] tuners.trainable_tokens.model.TrainableTokensModel
+
diff --git a/docs/source/package_reference/tuners.md b/docs/source/package_reference/tuners.md
new file mode 100644
index 0000000..ae05946
--- /dev/null
+++ b/docs/source/package_reference/tuners.md
@@ -0,0 +1,27 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# Tuners
+
+A tuner (or adapter) is a module that can be plugged into a `torch.nn.Module`. [`BaseTuner`] base class for other tuners and provides shared methods and attributes for preparing an adapter configuration and replacing a target module with the adapter module. [`BaseTunerLayer`] is a base class for adapter layers. It offers methods and attributes for managing adapters such as activating and disabling adapters.
+
+## BaseTuner
+
+[[autodoc]] tuners.tuners_utils.BaseTuner
+
+## BaseTunerLayer
+
+[[autodoc]] tuners.tuners_utils.BaseTunerLayer
\ No newline at end of file
diff --git a/docs/source/package_reference/unilora.md b/docs/source/package_reference/unilora.md
new file mode 100644
index 0000000..269f504
--- /dev/null
+++ b/docs/source/package_reference/unilora.md
@@ -0,0 +1,85 @@
+<!--Copyright 2025 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# UniLoRA
+
+[Uni-LoRA](https://huggingface.co/papers/2506.00799) is a PEFT method that shares a compact trainable
+vector bank across low-rank adapter weights. Instead of learning every LoRA matrix element independently, UniLoRA
+deterministically projects entries into shared `theta_d` values and learns the shared parameters used by the adapter
+update.
+
+## Quick Start
+
+```python
+from peft import UniLoraConfig, get_peft_model
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.2-3B")
+
+config = UniLoraConfig(
+    r=32,
+    theta_d_length=256,
+    proj_seed=42,
+    target_modules=["q_proj", "v_proj"],
+    unilora_dropout=0.0,
+    init_weights=True,
+    task_type="CAUSAL_LM",
+)
+
+peft_model = get_peft_model(model, config)
+peft_model.print_trainable_parameters()
+```
+
+## Important Parameters
+
+`r` controls the low-rank adapter dimension. Larger values increase adapter capacity and memory use.
+
+`theta_d_length` controls the length of the shared UniLoRA vector bank. This is the main trainable storage shared by
+the projected adapter entries.
+
+`proj_seed` controls deterministic index generation for the fixed projections into `theta_d`. Reusing the same seed and
+configuration makes the generated adapter indices reproducible.
+
+`target_modules` selects which modules receive UniLoRA adapters. Use module suffixes such as `["q_proj", "v_proj"]`, a
+regex string, or `"all-linear"` when supported by the model architecture.
+
+`unilora_dropout` applies dropout inside UniLoRA adapter layers during training.
+
+`init_weights` controls UniLoRA parameter initialization. Set it to `False` to keep a random `theta_d`
+initialization when you need to manage initialization manually.
+
+`save_indices` controls whether UniLoRA checkpoints save the generated index and scale tensors together with the
+shared `theta_d` parameters. Keeping this disabled gives smaller checkpoints and regenerates indices from
+`proj_seed`; enabling it makes saved adapters independent from future index-generation changes.
+
+## Benchmark overview
+
+<iframe
+src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=UNILORA"
+frameborder="0"
+width="850"
+height="1000"
+></iframe>
+
+# API
+
+## UniLoraConfig
+
+[[autodoc]] tuners.unilora.config.UniLoraConfig
+
+## UniLoraModel
+
+[[autodoc]] tuners.unilora.model.UniLoraModel
diff --git a/docs/source/package_reference/vblora.md b/docs/source/package_reference/vblora.md
new file mode 100644
index 0000000..0156d09
--- /dev/null
+++ b/docs/source/package_reference/vblora.md
@@ -0,0 +1,51 @@
+<!--Copyright 2024 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# VB-LoRA: Extreme Parameter Efficient Fine-Tuning with Vector Banks
+
+## Overview
+
+[VB-LoRA](https://huggingface.co/papers/2405.15179) is a parameter-efficient fine-tuning technique that extends LoRA by learning a fine-grained parameter-sharing scheme at the sub-vector level, achieving significantly higher parameter efficiency. This makes VB-LoRA especially useful in scenarios where storage and transmission costs are critical. It works by decomposing low-rank matrices—from different layers and modules such as K, Q, V, and FFN—into sub-vectors, which are then globally shared through a vector bank.
+
+The abstract from the paper is:
+
+*As the adoption of large language models increases and the need for per-user or per-task model customization grows, the parameter-efficient fine-tuning (PEFT) methods, such as low-rank adaptation (LoRA) and its variants, incur substantial storage and transmission costs. To further reduce stored parameters, we introduce a "divide-and-share" paradigm that breaks the barriers of low-rank decomposition across matrix dimensions, modules and layers by sharing parameters globally via a vector bank. As an instantiation of the paradigm to LoRA, our proposed VB-LoRA composites all the low-rank matrices of LoRA from a shared vector bank with a differentiable top-k admixture module. VB-LoRA achieves extreme parameter efficiency while maintaining comparable or better performance compared to state-of-the-art PEFT methods. Extensive experiments demonstrate the effectiveness of VB-LoRA on natural language understanding, natural language generation, and instruction tuning tasks. When fine-tuning the Llama2-13B model, VB-LoRA only uses 0.4% of LoRA's stored parameters, yet achieves superior results.*
+
+## Usage Tips
+
+- VB-LoRA utilizes a sparse top-k module to learn the sharing mechanism. When saving adapter parameters, you can either save only the top-k weights and their indices by setting `save_only_topk_weights = True` in `VBLoRAConfig`, or save all the trainable logits by setting it to `False`. Enabling `save_only_topk_weights = True` significantly reduces storage space; for instance, in Llama2-7B, the storage file size decreases from 308MB to 2.5MB. Note that models saved with `save_only_topk_weights = True` are intended for merging or inference only and cannot be used to resume training.
+
+- VB-LoRA has two sets of training parameters: vector bank parameters and logit parameters. In practice, we found that logit parameters require a higher learning rate, while vector bank parameters require a lower learning rate. When using the AdamW optimizer, typical learning rates are 0.01 for logits and 0.001 for vector bank parameters.
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=VBLORA"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+# API
+
+## VBLoRAConfig
+
+[[autodoc]] tuners.vblora.config.VBLoRAConfig
+
+## VBLoRAModel
+
+[[autodoc]] tuners.vblora.model.VBLoRAModel
+
diff --git a/docs/source/package_reference/vera.md b/docs/source/package_reference/vera.md
new file mode 100644
index 0000000..874679f
--- /dev/null
+++ b/docs/source/package_reference/vera.md
@@ -0,0 +1,70 @@
+<!--Copyright 2024 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# VeRA: Vector-based Random Matrix Adaptation
+
+[VeRA](https://huggingface.co/papers/2310.11454) is a parameter-efficient fine-tuning technique that is similar to LoRA but requires even fewer extra parameters while promising similar or even better performance. As such, it is particularly useful when the parameter budget is very limited, e.g. when scaling to very large models. The reduction of the count of trainable parameters is achieved by sharing the same low-rank matrices across all layers, and only training two additional vectors per layer.
+
+## How VeRA works
+
+LoRA updates a frozen base model by learning two small, low-rank matrices for each adapted layer. The rank is the
+inner dimension of these matrices, and it controls how much capacity the adapter has. In LoRA, increasing `r` or
+adapting more layers increases the number of trainable parameters quickly because every adapted layer learns its own
+pair of low-rank matrices.
+
+VeRA keeps the same low-rank adaptation idea but changes which parameters are trained. Instead of learning separate
+low-rank matrices for every layer, VeRA uses one frozen, randomly initialized pair of low-rank matrices, `A` and `B`,
+that is shared across layers. Each adapted layer only learns two scaling vectors, `vera_lambda_d` and `vera_lambda_b`,
+which rescale the shared matrices to produce a layer-specific update. Since `vera_lambda_d` has size `r`, VeRA's
+trainable parameter count still increases with `r` and with the number of adapted layers. However, it grows much more
+slowly than LoRA's because the large `A` and `B` matrices are shared and frozen instead of learned separately for each
+layer.
+
+This is why VeRA can use fewer trainable parameters than LoRA. In the simplified parameter count from the paper, LoRA
+scales with `2 * L_tuned * d_model * r`, where `L_tuned` is the number of adapted layers, `d_model` is the model
+dimension, and `r` is the rank. VeRA scales with `L_tuned * (d_model + r)` because the large low-rank matrices are
+shared and frozen, while only the smaller per-layer vectors are trained.
+
+When saving the adapter parameters, it's possible to eschew storing the low rank matrices by setting `save_projection=False` on the `VeraConfig`. In that case, these matrices will be restored based on the fixed random seed from the `projection_prng_key` argument. This cuts down on the size of the checkpoint, but we cannot guarantee reproducibility on all devices and for all future versions of PyTorch. If you want to ensure reproducibility, set `save_projection=True` (which is the default).
+
+To handle different shapes of adapted layers, VeRA initializes shared A and B matrices with the largest required size for each dimension. During the forward pass, submatrices A and B for a given layer are sliced out from these shared matrices and used as described in the paper. For example, adapting two linear layers of shapes (100, 20) and (80, 50) will create A and B matrices of shapes (rank, 50) and (100, rank) respectively. Then, to adapt a layer of shape (100, 20), submatrices A and B of shapes (rank, 20) and (100, rank) will be extracted.
+
+VeRA currently has the following constraint:
+
+- Only `nn.Linear` layers are supported.
+
+The abstract from the paper is:
+
+> Low-rank adaptation (LoRA) is a popular method that reduces the number of trainable parameters when finetuning large language models, but still faces acute storage challenges when scaling to even larger models or deploying numerous per-user or per-task adapted models. In this work, we present Vector-based Random Matrix Adaptation (VeRA), which significantly reduces the number of trainable parameters compared to LoRA, yet maintains the same performance. It achieves this by using a single pair of low-rank matrices shared across all layers and learning small scaling vectors instead. We demonstrate its effectiveness on the GLUE and E2E benchmarks, image classification tasks, and show its application in instruction-tuning of 7B and 13B language models.
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=VERA"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+# API
+
+## VeRAConfig
+
+[[autodoc]] tuners.vera.config.VeraConfig
+
+## VeRAModel
+
+[[autodoc]] tuners.vera.model.VeraModel
diff --git a/docs/source/package_reference/waveft.md b/docs/source/package_reference/waveft.md
new file mode 100644
index 0000000..434b25b
--- /dev/null
+++ b/docs/source/package_reference/waveft.md
@@ -0,0 +1,46 @@
+<!--Copyright 2025 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# WaveFT: Wavelet Fine-Tuning
+
+[WaveFT](https://huggingface.co/papers/2505.12532) is a novel parameter-efficient fine-tuning (PEFT) method that introduces sparse updates in the **wavelet domain** of residual matrices. Unlike LoRA, which is constrained by discrete low-rank choices, WaveFT enables fine-grained control over the number of trainable parameters by directly learning a sparse set of coefficients in the transformed space. These coefficients are then mapped back to the weight domain via the Inverse Discrete Wavelet Transform (IDWT), producing high-rank updates without incurring inference overhead.
+
+WaveFT currently has the following constraint:
+
+- Only `nn.Linear` layers are supported.
+
+The abstract from the paper is:
+
+>Efficiently adapting large foundation models is critical, especially with tight compute and memory budgets. Parameter-Efficient Fine-Tuning (PEFT) methods such as LoRA offer limited granularity and effectiveness in few-parameter regimes. We propose Wavelet Fine-Tuning (WaveFT), a novel PEFT method that learns highly sparse updates in the wavelet domain of residual matrices. WaveFT allows precise control of trainable parameters, offering fine-grained capacity adjustment and excelling with remarkably low parameter count, potentially far fewer than LoRA’s minimum—ideal for extreme parameter-efficient scenarios. Evaluated on personalized text-to-image generation using Stable Diffusion XL as baseline, WaveFT significantly outperforms LoRA and other PEFT methods, especially at low parameter counts; achieving superior subject fidelity, prompt alignment, and image diversity.
+
+## Benchmark overview
+
+<iframe
+	src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=WAVEFT"
+	frameborder="0"
+	width="850"
+	height="1000"
+></iframe>
+
+# API
+
+## WaveFTConfig
+
+[[autodoc]] tuners.waveft.config.WaveFTConfig
+
+## WaveFTModel
+
+[[autodoc]] tuners.waveft.model.WaveFTModel
diff --git a/docs/source/package_reference/xlora.md b/docs/source/package_reference/xlora.md
new file mode 100644
index 0000000..0ebfb74
--- /dev/null
+++ b/docs/source/package_reference/xlora.md
@@ -0,0 +1,62 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# X-LoRA
+
+Mixture of LoRA Experts ([X-LoRA](https://huggingface.co/papers/2402.07148)) is a PEFT method enabling sparse or dense mixture of LoRA experts based on a high granularity (token, layer, sequence) scalings matrix. This leverages frozen LoRA adapters and a frozen base model to drastically reduces the number of parameters that need to be fine-tuned.
+
+A unique aspect of X-LoRA is its versatility: it can be applied to any `transformers` base model with LoRA adapters. This means that, despite the mixture of experts strategy, no changes to the model code must be made.
+
+The below graphic demonstrates how the scalings change for different prompts for each token. This highlights the activation of different adapters as the generation progresses and the sequence creates new context.
+
+![Token-by-token scalings](https://github.com/EricLBuehler/xlora/raw/master/res/token_by_token_scalings.gif)
+
+For each step, X-LoRA requires the base model to be run twice: first, to get hidden states without any LoRA adapters, and secondly, the hidden states are used to calculate scalings which are applied to the LoRA adapters and the model is run a second time. The output of the second run is the result of the model step.
+
+Ultimately, X-LoRA allows the model to reflect upon its knowledge because of the dual forward pass scheme, and dynamically reconfigure the architecture.
+
+The abstract from the paper is:
+
+*We report a mixture of expert strategy to create fine-tuned large language models using a deep layer-wise token-level approach based on low-rank adaptation (LoRA). Starting with a set of pre-trained LoRA adapters, our gating strategy uses the hidden states to dynamically mix adapted layers, allowing the resulting X-LoRA model to draw upon different capabilities and create never-before-used deep layer-wise combinations to solve tasks. The design is inspired by the biological principles of universality and diversity, where neural network building blocks are reused in different hierarchical manifestations. Hence, the X-LoRA model can be easily implemented for any existing large language model (LLM) without a need for modifications of the underlying structure. We develop a tailored X-LoRA model that offers scientific capabilities including forward/inverse analysis tasks and enhanced reasoning capability, focused on biomaterial analysis, protein mechanics and design. The impact of this work include access to readily expandable and adaptable models with strong domain knowledge and the capability to integrate across areas of knowledge. Featuring experts in biology, mathematics, reasoning, bio-inspired materials, mechanics and materials, chemistry, protein biophysics, mechanics and quantum-mechanics based molecular properties, we conduct a series of physics-focused case studies. We examine knowledge recall, protein mechanics forward/inverse tasks, protein design, adversarial agentic modeling including ontological knowledge graph construction, as well as molecular design. The model is capable not only of making quantitative predictions of nanomechanical properties of proteins or quantum mechanical molecular properties, but also reasons over the results and correctly predicts likely mechanisms that explain distinct molecular behaviors.*.
+
+Please cite X-LoRA as:
+```bibtex
+@article{10.1063/5.0203126,
+    author = {Buehler, Eric L. and Buehler, Markus J.},
+    title = "{X-LoRA: Mixture of low-rank adapter experts, a flexible framework for large language models with applications in protein mechanics and molecular design}",
+    journal = {APL Machine Learning},
+    volume = {2},
+    number = {2},
+    pages = {026119},
+    year = {2024},
+    month = {05},
+    abstract = "{We report a mixture of expert strategy to create fine-tuned large language models using a deep layer-wise token-level approach based on low-rank adaptation (LoRA). Starting with a set of pre-trained LoRA adapters, our gating strategy uses the hidden states to dynamically mix adapted layers, allowing the resulting X-LoRA model to draw upon different capabilities and create never-before-used deep layer-wise combinations to solve tasks. The design is inspired by the biological principles of universality and diversity, where neural network building blocks are reused in different hierarchical manifestations. Hence, the X-LoRA model can be easily implemented for any existing large language model without a need for modifications of the underlying structure. We develop a tailored X-LoRA model that offers scientific capabilities, including forward/inverse analysis tasks and enhanced reasoning capability, focused on biomaterial analysis, protein mechanics, and design. The impact of this work includes access to readily expandable and adaptable models with strong domain knowledge and the capability to integrate across areas of knowledge. Featuring experts in biology, mathematics, reasoning, bio-inspired materials, mechanics and materials, chemistry, protein biophysics, mechanics, and quantum-mechanics based molecular properties, we conduct a series of physics-focused case studies. We examine knowledge recall, protein mechanics forward/inverse tasks, protein design, adversarial agentic modeling including ontological knowledge graph construction, and molecular design. The model is capable not only of making quantitative predictions of nanomechanical properties of proteins or quantum mechanical molecular properties but also reasoning over the results and correctly predicting likely mechanisms that explain distinct molecular behaviors.}",
+    issn = {2770-9019},
+    doi = {10.1063/5.0203126},
+    url = {https://doi.org/10.1063/5.0203126},
+    eprint = {https://pubs.aip.org/aip/aml/article-pdf/doi/10.1063/5.0203126/19964043/026119\_1\_5.0203126.pdf},
+}
+```
+
+# API
+
+## XLoraConfig
+
+[[autodoc]] tuners.xlora.config.XLoraConfig
+
+## XLoraModel
+
+[[autodoc]] tuners.xlora.model.XLoraModel
diff --git a/docs/source/quicktour.md b/docs/source/quicktour.md
new file mode 100644
index 0000000..38830da
--- /dev/null
+++ b/docs/source/quicktour.md
@@ -0,0 +1,230 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# Quicktour
+
+PEFT offers parameter-efficient methods for finetuning large pretrained models. The traditional paradigm is to finetune all of a model's parameters for each downstream task, but this is becoming exceedingly costly and impractical because of the enormous number of parameters in models today. Instead, it is more efficient to train a smaller number of prompt parameters or use a reparametrization method like low-rank adaptation (LoRA) to reduce the number of trainable parameters.
+
+<div class="flex justify-center">
+  <div class="flex flex-col basis-1/4 pt-5">
+    <i>PEFT can be thought of as a framework for adding trainable parameters to arbitrary places in existing models ("base models"). Specific PEFT methods arrange the trainable parameters in certain ways or modify the training process to achieve fine-tuning performance comparable to training all parameters of the base model.</i>
+  </div>
+  <div class="flex flex-col basis-3/4 pl-10 pr-10"><img style="border: 0;box-shadow: none;border-radius: 0;" src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/peft/adapter_installation.png" width="100%"></div>
+</div>
+
+This quicktour will show you PEFT's main features and how you can train or run inference on large models that would typically be inaccessible on consumer devices.
+
+
+## PEFT configuration and model
+
+For any PEFT method, you'll need to create a configuration which contains all the parameters that specify how the PEFT method should be applied, most importantly which layers of the existing model to target with trainable parameters. Once the configuration is setup, pass it to the [`~peft.get_peft_model`] function along with the base model to create a trainable [`PeftModel`].
+
+Let's use [LoRA](./package_reference/lora) as an example but only discuss common parameters - you might want to use one of the [many other PEFT methods](./methods/overview).
+The configuration usually entails this:
+
+- `target_modules`: which modules of the base model to adapt
+- `task_type` (default: `None`, see [available `TaskType`s](package_reference/peft_types#peft.TaskType)): the nature of the trained task; if provided may help to automatically save relevant layers alongside the adapter weights or warn you about incompatibilities
+- `inference_mode` (default: `False`): whether you're using the model for inference or not
+
+Depending on the PEFT method you choose you will add specific parameters that, for example, determine the size of the update matrices.
+Here's an example of a config you may encounter in the wild:
+
+```python
+from peft import LoraConfig, TaskType
+
+peft_config = LoraConfig(target_modules=["q_proj"], task_type=TaskType.CAUSAL_LM, inference_mode=False, r=8, lora_alpha=32, lora_dropout=0.1)
+```
+
+> [!TIP]
+> See the [configuration guide](guides/peft_model_config) for more details on how the PEFT configuration works under the hood.
+
+Once the [`LoraConfig`] is set up, create a [`PeftModel`] with the [`get_peft_model`] function. It takes a base model - which you can (but don't have to) load from the Transformers library - and the [`LoraConfig`] containing the parameters for how to configure a model for training with LoRA.
+
+Load the base model you want to finetune.
+
+```python
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.2-1B")
+```
+
+Now wrap the base model and `peft_config` with the [`get_peft_model`] function to create a [`PeftModel`].
+
+<div class="flex justify-center">
+  <div class="flex flex-col basis-2/4">
+    <p>
+    Wrapping means that PEFT replaces the targeted layers (here: all <code>q_proj</code> layers) with the adapter-specific layer for the target layer's type.  Since we're dealing with linear layers, it will be, in this case, a <code>lora.Linear</code> layer. <b>Note</b> that these changes are done in-place to save memory, so your base model is now modified.
+    </p>
+    <p>
+    Note that we've only specified <code>q_proj</code> but in actuality we are targeting all <code>model.layers[:].self_attn.q_proj</code> layers. This is because PEFT searches for matching suffixes by default. Pass a string with a regular expression if you want to target more complex layer patterns.
+    </p>
+  </div>
+  <div class="flex flex-col basis-2/4 pl-10 pr-10"><img style="border: 0;box-shadow: none;border-radius: 0;" src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/peft/adapter_attention_targeting.png" width="600px"></div>
+</div>
+
+<div class="flex justify-center">
+  <div class="flex flex-col basis-2/4 pr-10"><img style="border: 0;box-shadow: none;border-radius: 0;" src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/peft/adapter_layer_wrapping.png" width="1000px"></div>
+  <div class="flex flex-col basis-2/4">
+    <p>
+    The base model's layer will be wrapped, retained and not trained while new, trainable weights are added and are combined.  How these new weights are structured and combined with the weights of the base model is a good portion of what sets the different PEFT methods apart.
+    </p>
+  </div>
+</div>
+
+To get a sense of the number of trainable parameters in your model, use the [`print_trainable_parameters`] method.
+
+```python
+from peft import get_peft_model
+
+peft_model = get_peft_model(model, peft_config)
+peft_model.print_trainable_parameters()
+"output: trainable params: 524,288 || all params: 1,236,338,688 || trainable%: 0.0424"
+```
+
+Out of [meta-llama/Llama-3.2-1B's](https://huggingface.co/meta-llama/Llama-3.2-1B) 1B parameters, you're only training 0.04% of them!
+
+That is it 🎉! Now you can train the model with the Transformers [`~transformers.Trainer`], Accelerate, or any custom PyTorch training loop.
+
+For example, to train with the [`~transformers.Trainer`] class, setup a [`~transformers.TrainingArguments`] class with some training hyperparameters.
+
+```py
+training_args = TrainingArguments(
+    output_dir="your-name/meta-llama/my-llama3.2-adapter",
+    learning_rate=1e-3,
+    per_device_train_batch_size=32,
+    per_device_eval_batch_size=32,
+    num_train_epochs=2,
+    weight_decay=0.01,
+    eval_strategy="epoch",
+    save_strategy="epoch",
+    load_best_model_at_end=True,
+)
+```
+
+Pass the model, training arguments, dataset, tokenizer, and any other necessary component to the [`~transformers.Trainer`], and call [`~transformers.Trainer.train`] to start training.
+
+```py
+trainer = Trainer(
+    model=peft_model,
+    args=training_args,
+    train_dataset=tokenized_datasets["train"],
+    eval_dataset=tokenized_datasets["test"],
+    data_collator=data_collator,
+    compute_metrics=compute_metrics,
+)
+
+trainer.train()
+```
+
+### Save model
+
+After your model is finished training, you can save your model to a directory using the [`~PeftModel.save_pretrained`] function.
+
+```py
+peft_model.save_pretrained("output_dir")
+```
+
+You can also save your model to the Hub (make sure you're logged in to your Hugging Face account first) with the [`~transformers.PreTrainedModel.push_to_hub`] function.
+
+```python
+from huggingface_hub import notebook_login
+
+notebook_login()
+peft_model.push_to_hub("your-name/my-llama3.2-adapter")
+```
+
+Both methods only save the extra PEFT weights that were trained, meaning it is super efficient to store, transfer, and load. For example, this [facebook/opt-350m](https://huggingface.co/ybelkada/opt-350m-lora) model trained with LoRA only contains two files: `adapter_config.json` and `adapter_model.safetensors`. The `adapter_model.safetensors` file is just 6.3MB!
+
+<div class="flex flex-col justify-center">
+  <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/peft/PEFT-hub-screenshot.png"/>
+  <figcaption class="text-center">The adapter weights for a opt-350m model stored on the Hub are only ~6MB compared to the full size of the model weights, which can be ~700MB.</figcaption>
+</div>
+
+## Inference
+
+> [!TIP]
+> Take a look at the [AutoPeftModel](package_reference/auto_class) API reference for a complete list of available `AutoPeftModel` classes.
+
+Easily load any PEFT-trained model for inference with the [`AutoPeftModel`] class and the [`~transformers.PreTrainedModel.from_pretrained`] method:
+
+```py
+from peft import AutoPeftModelForCausalLM
+from transformers import AutoTokenizer
+import torch
+
+peft_model = AutoPeftModelForCausalLM.from_pretrained("ybelkada/opt-350m-lora")
+tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m")
+
+peft_model = peft_model.to("cuda")
+peft_model.eval()
+inputs = tokenizer("Preheat the oven to 350 degrees and place the cookie dough", return_tensors="pt")
+
+outputs = peft_model.generate(input_ids=inputs["input_ids"].to("cuda"), max_new_tokens=50)
+print(tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True)[0])
+
+"Preheat the oven to 350 degrees and place the cookie dough in the center of the oven. In a large bowl, combine the flour, baking powder, baking soda, salt, and cinnamon. In a separate bowl, combine the egg yolks, sugar, and vanilla."
+```
+
+For other tasks that aren't explicitly supported with an `AutoPeftModelFor` class - such as automatic speech recognition - you can still use the base [`AutoPeftModel`] class to load a model for the task.
+
+```py
+from peft import AutoPeftModel
+
+peft_model = AutoPeftModel.from_pretrained("smangrul/openai-whisper-large-v2-LORA-colab")
+```
+
+The most general way of loading a trained PEFT adapter onto a model is to use [`~PeftModel.from_pretrained`]:
+
+```py
+from transformers import AutoPeftModelForCausalLM
+from peft import PeftModel
+
+base_model = AutoModelForCausalLM.from_pretrained("meta-llama/llama3.2-1B")
+peft_model = PeftModel.from_pretrained(base_model, "my-user/my-llama-adapter")  # you can also pass a directory instead of a hub path
+```
+
+## Multiple adapters
+
+PEFT supports installing multiple adapters (of the same kind, in this document this would be LoRA) on top of a base model. When you call `get_peft_model` there is only one adapter named `"default"` but you can add as many additional adapters as you want by calling `peft_model.add_adapter(adapter_name=...)`.
+
+<div class="flex justify-center">
+  <div class="flex flex-col basis-2/4">
+    <p>
+    This works because the wrapped layer actually has a unique set of trainable weights for each adapter name. Not every adapter is active and trainable by default.  You have to explicitly enable adapters by name before they are active. This allows you to quickly swap between adapters where task-specific knowledge is needed or serve different use-cases on top of one model.
+    </p>
+  </div>
+  <div class="flex flex-col basis-2/4 pl-10 pr-10"><img style="border: 0;box-shadow: none;border-radius: 0;" src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/peft/adapter_layer_wrapping_multi_adapter.png" width="1000px"></div>
+</div>
+
+Just remember to call `peft_model.set_adapter(<adapter_name>)` first to enable the adapter.
+
+Quick example:
+
+```py
+peft_model.add_adapter(adapter_name='new_adapter')
+peft_model.set_adapter('new_adapter')
+```
+
+## Next steps
+
+Now that you've seen how to train a model with one of the PEFT methods, we encourage you to try out some of the other methods like prompt tuning. The steps are very similar to the ones shown in the quicktour:
+
+1. prepare a [`PeftConfig`] for a PEFT method, e.g. a [`LoraConfig`] or some other config (see the [method overview](methods/overview))
+2. use the [`get_peft_model`] method to create a [`PeftModel`] from the configuration and base model
+
+Then you can train it however you like! To load a PEFT model for inference, you can use the [`AutoPeftModel`] class.
+
+Feel free to also take a look at the task guides if you're interested in training a model with another PEFT method for a specific task such as semantic segmentation, multilingual automatic speech recognition, DreamBooth, token classification, and more.
diff --git a/examples/KappaTune/README.md b/examples/KappaTune/README.md
new file mode 100644
index 0000000..92c0059
--- /dev/null
+++ b/examples/KappaTune/README.md
@@ -0,0 +1,215 @@
+# KappaTune Experiment
+
+This script compares different fine-tuning strategies on a downstream task (gsm8k) while measuring **catastrophic forgetting** on a general-knowledge control dataset (WikiText). For further details see the [KappaTune paper](https://arxiv.org/abs/2506.16289).
+
+- **Baseline**: No adaptation
+- **LoRA_Global**: Classic LoRA on common projections (`q_proj`, `k_proj`, `o_proj`, `v_proj`, `gate_proj`, `up_proj`, `down_proj` )
+- **KappaTune_LoRA**: The new `KappaTuneSelector` with relative selection (`top_p=0.2`)
+
+The goal is to show that KappaTune achieves similar task adaptation **while forgetting less** of the original pre-trained knowledge.
+
+KappaTune is recommended when catastrophic forgetting is a concern. If your fine-tuning data is closely aligned with the model's pretraining distribution, it can even decrease general/Wiki perplexity. This is the case of fine-tuning on math data like GSM8K (adopted in this experiment) for some models. Then unrestricted LoRA over all layers may yield better results, since it reinforces pre-training.
+
+### Key hyperparameters to play with
+
+| Hyperparameter                | Location                          | Default          | What it controls                                      | Recommendation                                      |
+|-------------------------------|-----------------------------------|------------------|-------------------------------------------------------|-----------------------------------------------------|
+| `top_p`                       | KappaTune block                   | `0.2`            | Fraction of best (lowest κ) modules selected          | 0.1–0.3 (lower = more conservative)                 |
+| `num_modules`                 | KappaTune block (alternative)     | `None`           | Fixed number of modules                               | Use instead of `top_p` for strict budget            |
+| `r` (rank)                    | Both LoRA configs                 | `16` / `190`     | LoRA rank (controls trainable parameters)             | Keep total trainable params similar between runs    |
+| `LR` (learning rate)          | Top of script                     | `2e-4`           | Training speed and stability                          | 1e-4 – 5e-4                                         |
+| `num_train_epochs`            | Top of script                     | `10`             | Total training steps                                  | Increase for stronger adaptation                    |
+| `MODEL_ID`                    | Top of script                     | DeepSeek-V2-Lite | Base model                                            | Try Mistral, Qwen, etc. MoE yields the best results |
+| `max_dim_size_to_analyze`     | `KappaTuneSelector`               | `16384`          | Max matrix size for SVD (memory / speed trade-off)    | Increase only if you have very high VRAM            |
+
+## Expected results
+
+Running the script with default parameters produces the following behavior.
+
+<details>
+<summary><strong>KappaTune (training log)</strong></summary>
+
+```text
+========================================
+>>> EXPERIMENT: KappaTune_LoRA
+========================================
+[KappaTune] Selecting target modules using PEFT KappaTuneSelector...
+trainable params: 219,188,480 (0.47%)
+#trainable tensors: 370
+#trainable params: 219,188,480
+{'loss': 1.2208, 'grad_norm': 0.15972940623760223, 'learning_rate': 0.00019666666666666666, 'epoch': 0.87}
+{'loss': 1.07, 'grad_norm': 0.26267319917678833, 'learning_rate': 0.00019250000000000002, 'epoch': 1.7}
+{'loss': 1.0124, 'grad_norm': 0.2723085284233093, 'learning_rate': 0.00018833333333333335, 'epoch': 2.52}
+{'loss': 0.9436, 'grad_norm': 0.29701513051986694, 'learning_rate': 0.00018416666666666665, 'epoch': 3.35}
+{'loss': 0.9114, 'grad_norm': 0.3046768009662628, 'learning_rate': 0.00018, 'epoch': 4.17}
+{'loss': 0.8915, 'grad_norm': 0.47676295042037964, 'learning_rate': 0.00017583333333333334, 'epoch': 5.0}
+{'loss': 0.8728, 'grad_norm': 0.24124978482723236, 'learning_rate': 0.00017166666666666667, 'epoch': 5.87}
+{'loss': 0.8385, 'grad_norm': 0.20988021790981293, 'learning_rate': 0.0001675, 'epoch': 6.7}
+{'loss': 0.8389, 'grad_norm': 0.21968263387680054, 'learning_rate': 0.00016333333333333334, 'epoch': 7.52}
+{'loss': 0.8224, 'grad_norm': 0.04499625042080879, 'learning_rate': 0.00015916666666666667, 'epoch': 8.35}
+{'loss': 0.7997, 'grad_norm': 0.05307907983660698, 'learning_rate': 0.000155, 'epoch': 9.17}
+{'loss': 0.8057, 'grad_norm': 0.05258958786725998, 'learning_rate': 0.00015083333333333333, 'epoch': 10.0}
+{'loss': 0.7907, 'grad_norm': 0.05647141858935356, 'learning_rate': 0.00014666666666666666, 'epoch': 10.87}
+{'loss': 0.7804, 'grad_norm': 0.07924238592386246, 'learning_rate': 0.00014250000000000002, 'epoch': 11.7}
+{'loss': 0.7705, 'grad_norm': 0.03199317678809166, 'learning_rate': 0.00013833333333333333, 'epoch': 12.52}
+{'loss': 0.76, 'grad_norm': 0.030626816675066948, 'learning_rate': 0.00013416666666666666, 'epoch': 13.35}
+{'loss': 0.7456, 'grad_norm': 0.03376801684498787, 'learning_rate': 0.00013000000000000002, 'epoch': 14.17}
+{'loss': 0.7352, 'grad_norm': 0.045162301510572433, 'learning_rate': 0.00012583333333333335, 'epoch': 15.0}
+{'loss': 0.7221, 'grad_norm': 0.04105797037482262, 'learning_rate': 0.00012166666666666667, 'epoch': 15.87}
+{'loss': 0.7118, 'grad_norm': 0.04653630033135414, 'learning_rate': 0.00011750000000000001, 'epoch': 16.7}
+{'loss': 0.7071, 'grad_norm': 0.0477643646299839, 'learning_rate': 0.00011333333333333334, 'epoch': 17.52}
+{'loss': 0.67, 'grad_norm': 0.05408667400479317, 'learning_rate': 0.00010916666666666666, 'epoch': 18.35}
+{'loss': 0.6753, 'grad_norm': 0.05562206730246544, 'learning_rate': 0.000105, 'epoch': 19.17}
+{'loss': 0.6529, 'grad_norm': 0.08778411149978638, 'learning_rate': 0.00010083333333333334, 'epoch': 20.0}
+{'loss': 0.6356, 'grad_norm': 0.07903064042329788, 'learning_rate': 9.666666666666667e-05, 'epoch': 20.87}
+{'loss': 0.6198, 'grad_norm': 0.08349727094173431, 'learning_rate': 9.250000000000001e-05, 'epoch': 21.7}
+{'loss': 0.604, 'grad_norm': 0.08645208925008774, 'learning_rate': 8.833333333333333e-05, 'epoch': 22.52}
+{'loss': 0.5897, 'grad_norm': 0.09194190055131912, 'learning_rate': 8.416666666666668e-05, 'epoch': 23.35}
+{'loss': 0.5649, 'grad_norm': 0.10126981139183044, 'learning_rate': 8e-05, 'epoch': 24.17}
+{'loss': 0.5483, 'grad_norm': 0.13687381148338318, 'learning_rate': 7.583333333333334e-05, 'epoch': 25.0}
+{'loss': 0.5323, 'grad_norm': 0.13106191158294678, 'learning_rate': 7.166666666666667e-05, 'epoch': 25.87}
+{'loss': 0.5147, 'grad_norm': 0.1281006783246994, 'learning_rate': 6.750000000000001e-05, 'epoch': 26.7}
+{'loss': 0.4941, 'grad_norm': 0.1377001851797104, 'learning_rate': 6.333333333333333e-05, 'epoch': 27.52}
+{'loss': 0.4845, 'grad_norm': 0.14247003197669983, 'learning_rate': 5.916666666666667e-05, 'epoch': 28.35}
+{'loss': 0.4669, 'grad_norm': 0.14682190120220184, 'learning_rate': 5.500000000000001e-05, 'epoch': 29.17}
+{'loss': 0.454, 'grad_norm': 0.19749927520751953, 'learning_rate': 5.0833333333333333e-05, 'epoch': 30.0}
+{'loss': 0.4323, 'grad_norm': 0.1622404158115387, 'learning_rate': 4.666666666666667e-05, 'epoch': 30.87}
+{'loss': 0.4274, 'grad_norm': 0.15755769610404968, 'learning_rate': 4.25e-05, 'epoch': 31.7}
+{'loss': 0.4086, 'grad_norm': 0.1696886271238327, 'learning_rate': 3.8333333333333334e-05, 'epoch': 32.52}
+{'loss': 0.4006, 'grad_norm': 0.14865559339523315, 'learning_rate': 3.4166666666666666e-05, 'epoch': 33.35}
+{'loss': 0.3934, 'grad_norm': 0.14790022373199463, 'learning_rate': 3e-05, 'epoch': 34.17}
+{'loss': 0.3777, 'grad_norm': 0.20866677165031433, 'learning_rate': 2.5833333333333336e-05, 'epoch': 35.0}
+{'loss': 0.3712, 'grad_norm': 0.17520156502723694, 'learning_rate': 2.1666666666666667e-05, 'epoch': 35.87}
+{'loss': 0.3668, 'grad_norm': 0.16120171546936035, 'learning_rate': 1.75e-05, 'epoch': 36.7}
+{'loss': 0.3583, 'grad_norm': 0.16624851524829865, 'learning_rate': 1.3333333333333333e-05, 'epoch': 37.52}
+{'loss': 0.357, 'grad_norm': 0.15067771077156067, 'learning_rate': 9.166666666666666e-06, 'epoch': 38.35}
+{'loss': 0.3524, 'grad_norm': 0.15819120407104492, 'learning_rate': 5e-06, 'epoch': 39.17}
+{'loss': 0.3466, 'grad_norm': 0.1855546236038208, 'learning_rate': 8.333333333333333e-07, 'epoch': 40.0}
+{'train_runtime': 2871.3103, 'train_samples_per_second': 12.538, 'train_steps_per_second': 0.084, 'train_loss': 0.6427203471461932, 'epoch': 40.0}
+
+========================================
+>>> EXPERIMENT: Baseline
+========================================
+
+========================================
+>>> EXPERIMENT: LoRA_Global
+========================================
+trainable params: 218,103,808 || all params: 46,920,896,512 || trainable%: 0.4648
+{'loss': 1.2122, 'grad_norm': 0.03368454799056053, 'learning_rate': 0.00019666666666666666, 'epoch': 0.87}
+{'loss': 1.0674, 'grad_norm': 0.04771586135029793, 'learning_rate': 0.00019250000000000002, 'epoch': 1.7}
+{'loss': 0.9889, 'grad_norm': 0.030208367854356766, 'learning_rate': 0.00018833333333333335, 'epoch': 2.52}
+{'loss': 0.9269, 'grad_norm': 0.0202629417181015, 'learning_rate': 0.00018416666666666665, 'epoch': 3.35}
+{'loss': 0.9146, 'grad_norm': 0.01595970056951046, 'learning_rate': 0.00018, 'epoch': 4.17}
+{'loss': 0.8983, 'grad_norm': 0.017851779237389565, 'learning_rate': 0.00017583333333333334, 'epoch': 5.0}
+{'loss': 0.8914, 'grad_norm': 0.01525798998773098, 'learning_rate': 0.00017166666666666667, 'epoch': 5.87}
+{'loss': 0.8733, 'grad_norm': 0.01363384909927845, 'learning_rate': 0.0001675, 'epoch': 6.7}
+{'loss': 0.8712, 'grad_norm': 0.014126025140285492, 'learning_rate': 0.00016333333333333334, 'epoch': 7.52}
+{'loss': 0.8673, 'grad_norm': 0.01614651270210743, 'learning_rate': 0.00015916666666666667, 'epoch': 8.35}
+{'loss': 0.8461, 'grad_norm': 0.014323701150715351, 'learning_rate': 0.000155, 'epoch': 9.17}
+{'loss': 0.8519, 'grad_norm': 0.022168157622218132, 'learning_rate': 0.00015083333333333333, 'epoch': 10.0}
+{'loss': 0.8326, 'grad_norm': 0.017714861780405045, 'learning_rate': 0.00014666666666666666, 'epoch': 10.87}
+{'loss': 0.8258, 'grad_norm': 0.01950528658926487, 'learning_rate': 0.00014250000000000002, 'epoch': 11.7}
+{'loss': 0.8142, 'grad_norm': 0.021654563024640083, 'learning_rate': 0.00013833333333333333, 'epoch': 12.52}
+{'loss': 0.803, 'grad_norm': 0.027227576822042465, 'learning_rate': 0.00013416666666666666, 'epoch': 13.35}
+{'loss': 0.7892, 'grad_norm': 0.0281345397233963, 'learning_rate': 0.00013000000000000002, 'epoch': 14.17}
+{'loss': 0.7759, 'grad_norm': 0.04052634909749031, 'learning_rate': 0.00012583333333333335, 'epoch': 15.0}
+{'loss': 0.7614, 'grad_norm': 0.03630959987640381, 'learning_rate': 0.00012166666666666667, 'epoch': 15.87}
+{'loss': 0.7474, 'grad_norm': 0.04881247878074646, 'learning_rate': 0.00011750000000000001, 'epoch': 16.7}
+{'loss': 0.7449, 'grad_norm': 0.04792051389813423, 'learning_rate': 0.00011333333333333334, 'epoch': 17.52}
+{'loss': 0.707, 'grad_norm': 0.059059303253889084, 'learning_rate': 0.00010916666666666666, 'epoch': 18.35}
+{'loss': 0.713, 'grad_norm': 0.05515185743570328, 'learning_rate': 0.000105, 'epoch': 19.17}
+{'loss': 0.6907, 'grad_norm': 0.09590236097574234, 'learning_rate': 0.00010083333333333334, 'epoch': 20.0}
+{'loss': 0.6736, 'grad_norm': 0.07875961065292358, 'learning_rate': 9.666666666666667e-05, 'epoch': 20.87}
+{'loss': 0.663, 'grad_norm': 0.08937060832977295, 'learning_rate': 9.250000000000001e-05, 'epoch': 21.7}
+{'loss': 0.6445, 'grad_norm': 0.0950784757733345, 'learning_rate': 8.833333333333333e-05, 'epoch': 22.52}
+{'loss': 0.6387, 'grad_norm': 0.08285810798406601, 'learning_rate': 8.416666666666668e-05, 'epoch': 23.35}
+{'loss': 0.6182, 'grad_norm': 0.1019740179181099, 'learning_rate': 8e-05, 'epoch': 24.17}
+{'loss': 0.6045, 'grad_norm': 0.1708088219165802, 'learning_rate': 7.583333333333334e-05, 'epoch': 25.0}
+{'loss': 0.5959, 'grad_norm': 0.12375958263874054, 'learning_rate': 7.166666666666667e-05, 'epoch': 25.87}
+{'loss': 0.5877, 'grad_norm': 0.1316744089126587, 'learning_rate': 6.750000000000001e-05, 'epoch': 26.7}
+{'loss': 0.5698, 'grad_norm': 0.11958763003349304, 'learning_rate': 6.333333333333333e-05, 'epoch': 27.52}
+{'loss': 0.5653, 'grad_norm': 0.11063854396343231, 'learning_rate': 5.916666666666667e-05, 'epoch': 28.35}
+{'loss': 0.5502, 'grad_norm': 0.11866016685962677, 'learning_rate': 5.500000000000001e-05, 'epoch': 29.17}
+{'loss': 0.5458, 'grad_norm': 0.1533481925725937, 'learning_rate': 5.0833333333333333e-05, 'epoch': 30.0}
+{'loss': 0.5316, 'grad_norm': 0.13474972546100616, 'learning_rate': 4.666666666666667e-05, 'epoch': 30.87}
+{'loss': 0.5269, 'grad_norm': 0.13297690451145172, 'learning_rate': 4.25e-05, 'epoch': 31.7}
+{'loss': 0.5175, 'grad_norm': 0.13090570271015167, 'learning_rate': 3.8333333333333334e-05, 'epoch': 32.52}
+{'loss': 0.5108, 'grad_norm': 0.1196967139840126, 'learning_rate': 3.4166666666666666e-05, 'epoch': 33.35}
+{'loss': 0.5062, 'grad_norm': 0.13541598618030548, 'learning_rate': 3e-05, 'epoch': 34.17}
+{'loss': 0.4965, 'grad_norm': 0.202300563454628, 'learning_rate': 2.5833333333333336e-05, 'epoch': 35.0}
+{'loss': 0.492, 'grad_norm': 0.14462313055992126, 'learning_rate': 2.1666666666666667e-05, 'epoch': 35.87}
+{'loss': 0.4898, 'grad_norm': 0.1338396966457367, 'learning_rate': 1.75e-05, 'epoch': 36.7}
+{'loss': 0.4833, 'grad_norm': 0.11928340792655945, 'learning_rate': 1.3333333333333333e-05, 'epoch': 37.52}
+{'loss': 0.4805, 'grad_norm': 0.1199464276432991, 'learning_rate': 9.166666666666666e-06, 'epoch': 38.35}
+{'loss': 0.4801, 'grad_norm': 0.1222926527261734, 'learning_rate': 5e-06, 'epoch': 39.17}
+{'loss': 0.4729, 'grad_norm': 0.14248400926589966, 'learning_rate': 8.333333333333333e-07, 'epoch': 40.0}
+{'train_runtime': 2779.2046, 'train_samples_per_second': 12.953, 'train_steps_per_second': 0.086, 'train_loss': 0.7012442946434021, 'epoch': 40.0}
+
+======================================================================
+METHOD          | gsm8k PPL (Task train) |  gsm8k PPL (Task test) | Wiki PPL (General/control)
+----------------------------------------------------------------------
+KappaTune       | 1.4410             | 3.2826             | 13.7780           
+Baseline        | 3.6899             | 3.4668             | 13.9841           
+LoRA_Global     | 1.6593             | 3.5648             | 26.6836           
+======================================================================
+
+
+```
+
+</details>
+
+## Dense model with varying training effort
+
+Since we are using small datasets, the adaptation effort is small, as is the risk of forgetting. To evaluate catastrophic forgetting during intensive fine-tuning we need big datasets or overfitting a small dataset. Therefore, I ran a set of experiments that track the performance of a dense LLM (Llama 8B) trained on the IMDB dataset over extended epochs, proxying the heavy gradient updates typical of massive datasets. The experiments use the same Python script, changing just these parameters:
+
+```python
+MODEL_ID = "unsloth/Meta-Llama-3.1-8B-Instruct"
+imdb_ds = load_dataset("imdb", split="train[:1000]").train_test_split(test_size=0.1)
+imdb_tokenized = imdb_ds.map(format_imdb).map(
+    lambda x: tokenizer(x["text"], padding="max_length", truncation=True, max_length=256), 
+    batched=True, remove_columns=imdb_ds["train"].column_names
+)
+    if method_name == "LoRA_Global":
+        Target_modules = [
+        "q_proj", 
+        "k_proj", 
+        "v_proj", 
+        "o_proj", 
+        "gate_proj", 
+        "up_proj", 
+        "down_proj"
+        ]
+        lora_config = LoraConfig(
+            r=12, 
+            target_modules=Target_modules, 
+            task_type=TaskType.CAUSAL_LM, lora_dropout=0.05
+        )
+        model = get_peft_model(model, lora_config)
+        model.print_trainable_parameters()
+        LR=2e-4
+        STP= #VAR <from 4 to 20>
+    elif method_name == "KappaTune_LoRA":
+        stable_modules_dic = find_kappa_target_modules(model, top_p=0.2)
+        lora_config = LoraConfig(
+            r=64,
+            target_modules = stable_modules_dic["target_modules"], 
+            target_parameters = stable_modules_dic["target_parameters"] if stable_modules_dic["target_parameters"] else None, 
+            task_type=TaskType.CAUSAL_LM,
+            lora_dropout=0.05,
+        )
+        model = get_peft_model(model, lora_config)
+        model.print_trainable_parameters()
+        trainable = [(n, p.shape, p.numel()) for n, p in model.named_parameters() if p.requires_grad]
+        LR = 2e-4
+        STP = # VAR <from 6 to 60>
+
+```
+
+The figure below plots task-specific adaptation (IMDB perplexity) against general knowledge retention (control Wiki perplexity). The results reveal a distinct divergence: while both methods perform comparably under light training loads, pushing into deeper convergence exposes KappaTune's structural advantage. As the model tightly fits the target data, standard LoRA exhibits a steep degradation in general knowledge (higher Wiki PPL), whereas KappaTune maintains a significantly flatter trajectory. This demonstrates its superior ability to isolate new learning and mitigate catastrophic forgetting even under sustained training pressure.
+
+
+<img width="778" height="536" alt="image" src="https://github.com/user-attachments/assets/4cbbcaa2-e433-48cf-8764-67498462f686" />
+
+
+In case of using this test framework for different experiments, it's worth highlighting that size matters.
+KappaTune shows the strongest gains on larger models (≥7B) and especially on MoE architectures (many independent expert modules). In small, dense models, the benefit is reduced because there is a limited variety of independent tensors to choose from. A fair comparison of catastrophic forgetting should make both methods reach roughly the same level of adaptation to the new task (similar training PPL). Matching on test PPL is not sufficient, because the same test PPL can be achieved through overfitting (more forgetting) or underfitting (less forgetting).
diff --git a/examples/KappaTune/experiments_kappatune_peft.py b/examples/KappaTune/experiments_kappatune_peft.py
new file mode 100644
index 0000000..ce94e1b
--- /dev/null
+++ b/examples/KappaTune/experiments_kappatune_peft.py
@@ -0,0 +1,162 @@
+import gc
+import math
+
+import torch
+from datasets import load_dataset
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    BitsAndBytesConfig,
+    DataCollatorForLanguageModeling,
+    Trainer,
+    TrainingArguments,
+)
+
+from peft import LoraConfig, TaskType, get_peft_model, prepare_model_for_kbit_training
+from peft.helpers import find_kappa_target_modules
+
+
+# ==========================================
+# 1. Data Preparation
+# ==========================================
+MODEL_ID = "mistralai/Mixtral-8x7B-Instruct-v0.1"
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+tokenizer.pad_token = tokenizer.eos_token
+
+
+def format_gsm8k(example):
+    return {"text": f"Question: {example['question']}\nAnswer: {example['answer']}"}
+
+
+print("Loading and preprocessing datasets...")
+gsm8k_ds = load_dataset("gsm8k", "main", split="train[:1000]").train_test_split(test_size=0.1)
+gsm8k_tokenized = gsm8k_ds.map(format_gsm8k).map(
+    lambda x: tokenizer(x["text"], padding="max_length", truncation=True, max_length=256),
+    batched=True,
+    remove_columns=["question", "answer", "text"],
+)
+
+wiki_ds = load_dataset("wikitext", "wikitext-2-raw-v1", split="test[:400]")
+wiki_tokenized = wiki_ds.filter(lambda x: len(x["text"]) > 20).map(
+    lambda x: tokenizer(x["text"], padding="max_length", truncation=True, max_length=256),
+    batched=True,
+    remove_columns=wiki_ds.column_names,
+)
+
+
+# ==========================================
+# 2. Experiment Engine
+# ==========================================
+def evaluate_perplexity(model, dataset, name="Dataset"):
+    model.eval()
+    total_loss = 0
+    data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)
+    dataloader = torch.utils.data.DataLoader(dataset, batch_size=2, collate_fn=data_collator)
+
+    with torch.no_grad():
+        for i, batch in enumerate(dataloader):
+            batch = {k: v.to(model.device) for k, v in batch.items()}
+            outputs = model(**batch, use_cache=False)
+            total_loss += outputs.loss.item()
+            if i >= 40:
+                break
+    return math.exp(total_loss / (i + 1))
+
+
+def run_experiment(method_name):
+    print(f"\n{'=' * 40}\n>>> EXPERIMENT: {method_name}\n{'=' * 40}")
+
+    bnb_config = BitsAndBytesConfig(
+        load_in_4bit=True,
+        bnb_4bit_quant_type="nf4",
+        bnb_4bit_compute_dtype=torch.bfloat16,
+        bnb_4bit_use_double_quant=True,
+    )
+
+    model = AutoModelForCausalLM.from_pretrained(
+        MODEL_ID, quantization_config=bnb_config, trust_remote_code=True, device_map="auto"
+    )
+    model = prepare_model_for_kbit_training(model)
+
+    # Configure PEFT based on method
+    if method_name == "LoRA_Global":
+        Target_modules = ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
+        lora_config = LoraConfig(r=256, target_modules=Target_modules, task_type=TaskType.CAUSAL_LM, lora_dropout=0.05)
+        model = get_peft_model(model, lora_config)
+        model.print_trainable_parameters()
+        LR = 2e-4
+        STP = 40
+
+    elif method_name == "KappaTune_LoRA":
+        print(" [KappaTune] Selecting target modules using PEFT KappaTuneSelector...")
+
+        # Relative selection‚ works on any architecture
+        stable_modules_dic = find_kappa_target_modules(model, top_p=0.2)
+
+        lora_config = LoraConfig(
+            r=85,
+            target_modules=stable_modules_dic["target_modules"],
+            target_parameters=stable_modules_dic["target_parameters"]
+            if stable_modules_dic["target_parameters"]
+            else None,
+            task_type=TaskType.CAUSAL_LM,
+            lora_dropout=0.05,
+        )
+
+        model = get_peft_model(model, lora_config)
+        model.print_trainable_parameters()
+        trainable = [(n, p.shape, p.numel()) for n, p in model.named_parameters() if p.requires_grad]
+
+        print(f"#trainable tensors: {len(trainable)}")
+        print(f"#trainable params: {sum(x[2] for x in trainable):,}")
+
+        LR = 2e-4
+        STP = 40  # or whatever step count you prefer for fair comparison
+
+    if method_name != "Baseline":
+        args = TrainingArguments(
+            output_dir=f"./{method_name}_out",
+            per_device_train_batch_size=40,
+            gradient_accumulation_steps=4,
+            learning_rate=LR,
+            num_train_epochs=STP,
+            bf16=True,
+            logging_steps=5,
+            save_strategy="no",
+            report_to="none",
+        )
+        trainer = Trainer(
+            model=model,
+            args=args,
+            train_dataset=gsm8k_tokenized["train"],
+            data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+        )
+        trainer.train()
+
+    t_ppl_test = evaluate_perplexity(model, gsm8k_tokenized["test"], "gsm8k")
+    t_ppl_train = evaluate_perplexity(model, gsm8k_tokenized["train"], "gsm8k")
+    f_ppl = evaluate_perplexity(model, wiki_tokenized, "WikiText")
+
+    del model
+    gc.collect()
+    torch.cuda.empty_cache()
+    return t_ppl_test, t_ppl_train, f_ppl
+
+
+# ==========================================
+# 3. Results (same table as paper)
+# ==========================================
+results = {}
+
+results["KappaTune"] = run_experiment("KappaTune_LoRA")
+results["Baseline"] = run_experiment("Baseline")
+results["LoRA_Global"] = run_experiment("LoRA_Global")
+
+print("\n" + "=" * 70)
+print(
+    f"{'METHOD':<15} | {'gsm8k PPL (Task train)':<18} |  {'gsm8k PPL (Task test)':<18} | {'Wiki PPL (General/control)':<18}"
+)
+print("-" * 70)
+for m, (tpte, tptr, fp) in results.items():
+    print(f"{m:<15} | {tptr:<18.4f} | {tpte:<18.4f} | {fp:<18.4f}")
+print("=" * 70)
diff --git a/examples/adamss_finetuning/README.md b/examples/adamss_finetuning/README.md
new file mode 100644
index 0000000..64176c0
--- /dev/null
+++ b/examples/adamss_finetuning/README.md
@@ -0,0 +1,203 @@
+# AdaMSS Fine-tuning
+
+## Introduction
+
+AdaMSS (Adaptive Matrix Decomposition with Subspace Selection) is a parameter-efficient fine-tuning method that decomposes weight matrices using SVD into low-rank subspaces. It uses only **~0.07%** of original trainable parameters (e.g., 59K for ViT-Base vs 86M full fine-tuning) while maintaining competitive performance. 
+
+The method optionally supports **ASA** (Adaptive Subspace Allocation) for dynamic subspace selection during training, further improving efficiency and performance.
+
+See the [paper](https://neurips.cc/virtual/2025/poster/119606) for more details.
+
+
+## Installation & Quick Test
+
+Install from local source:
+```bash
+cd peft-main && pip install -e .
+pip install transformers datasets torch torchvision evaluate accelerate scikit-learn
+```
+
+Verify installation:
+```bash
+python -c "from peft import AdamssConfig; print('AdaMSS ready')"
+```
+
+## Detailed Code Explanation
+
+**Core AdaMSS Configuration:**
+```python
+from peft import AdamssConfig, get_peft_model
+
+# Configure AdaMSS with ASA
+config = AdamssConfig(
+    r=100,                          # SVD rank (full decomposition rank)
+    num_subspaces=10,               # Number of subspaces (K) - initial capacity
+    subspace_rank=3,                # Rank per subspace (ri) - use 1 for NLU, 3 for Vision
+    target_modules=["query", "value"],  # Target attention layers
+    use_asa=True,                   # Enable Adaptive Subspace Allocation
+    asa_target_subspaces=5,         # Target active subspaces (ASA reduces K→5)
+    init_warmup=50,                 # Start ASA after 50 steps
+    final_warmup=1000,              # Complete masking by step 1000
+    mask_interval=100,              # Update mask every 100 steps
+    modules_to_save=["classifier"], # Modules to train without decomposition
+)
+peft_model = get_peft_model(model, config)
+```
+
+**Option A – With HuggingFace Trainer (callback):**
+```python
+from peft.tuners.adamss.asa_callback import AdamssAsaCallback
+
+# The callback is a thin wrapper around model.update_and_allocate()
+trainer = Trainer(
+    model=peft_model,
+    callbacks=[AdamssAsaCallback()],
+    # ... other arguments
+)
+trainer.train()
+```
+
+**Option B – Custom training loop (no Trainer needed):**
+```python
+for step, batch in enumerate(dataloader):
+    loss = peft_model(**batch).loss
+    loss.backward()
+    optimizer.step()
+    peft_model.base_model.update_and_allocate(step)   # ← all ASA logic in one call
+    optimizer.zero_grad()
+```
+
+**Key Points:**
+- **Parameterization**: Total params = `r × (d_in + d_out)`, split into K subspaces of rank `ri` each
+- **ASA Mechanism**: Dynamically selects `asa_target_subspaces` most important subspaces from initial `num_subspaces`
+- **Warmup Schedule**: ASA gradually increases masking strength from `init_warmup` to `final_warmup`
+- **Vision vs NLU**: Use `subspace_rank=3` for vision, `subspace_rank=1` for NLU tasks
+
+## Use the training example scripts
+
+### Vision Tasks (Image Classification)
+
+Run the provided script with your configuration:
+```bash
+python examples/adamss_finetuning/image_classification_adamss_asa.py \
+    --model_name_or_path google/vit-base-patch16-224-in21k \
+    --dataset_name cifar10 \
+    --adamss_r 100 \
+    --adamss_k 10 \
+    --adamss_ri 3 \
+    --use_asa \
+    --asa_target_subspaces 5 \
+    --output_dir ./output
+```
+
+### NLU Tasks (GLUE Benchmark)
+
+Run GLUE tasks (e.g., CoLA) with ASA:
+```bash
+python examples/adamss_finetuning/glue_adamss_asa_example.py \
+    --dataset_name cola \
+    --adamss_r 100 \
+    --adamss_k 10 \
+    --adamss_ri 1 \
+    --use_asa \
+    --asa_target_subspaces 5 \
+    --num_epochs 100 \
+    --batch_size 32 \
+    --output_dir ./output_cola_asa
+```
+
+Without ASA (fixed K=10):
+```bash
+python examples/adamss_finetuning/glue_adamss_asa_example.py \
+    --dataset_name cola \
+    --adamss_r 100 \
+    --adamss_k 10 \
+    --adamss_ri 1 \
+    --num_epochs 100 \
+    --batch_size 32 \
+    --output_dir ./output_cola_no_asa
+```
+
+### AdamssConfig Parameters
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `r` | int | 100 | SVD decomposition rank |
+| `num_subspaces` | int | 10 | Number of subspaces (K) |
+| `subspace_rank` | int | 3 | Rank per subspace (ri) |
+| `target_modules` | list | - | Modules to apply AdaMSS (e.g., ["query", "value"]) |
+| `use_asa` | bool | False | Enable Adaptive Subspace Allocation |
+| `asa_target_subspaces` | int | None | Target active subspaces when ASA enabled |
+| `modules_to_save` | list | None | Modules to train without decomposition |
+
+### AdamssAsaCallback
+
+The ASA callback reads all parameters from `AdamssConfig`. Import it directly:
+
+```python
+from peft.tuners.adamss.asa_callback import AdamssAsaCallback
+```
+
+ASA-related config parameters:
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `init_warmup` | int | 50 | Steps before starting masking |
+| `final_warmup` | int | 1000 | Steps to reach target active subspaces |
+| `mask_interval` | int | 100 | Steps between subspace selection updates |
+| `asa_importance_beta` | float | 0.85 | EMA decay for importance tracking |
+| `asa_uncertainty_beta` | float | 0.85 | EMA decay for uncertainty tracking |
+| `asa_schedule_exponent` | float | 3.0 | Exponent for masking schedule |
+
+
+## Experimental Results
+
+### NLU Tasks (GLUE Benchmark)
+
+Results with AdaMSS + ASA (100 epochs, seed=0):
+
+| Task | Model | AdaMSS Params | Metric | Score |
+|------|-------|---------------|--------|-------|
+| CoLA | RoBERTa-base | 27.0K (ASA K→5) | Matthews | **0.6466** |
+| CoLA | RoBERTa-large | 64.8K (ASA K→5) | Matthews | **0.7093** |
+| MRPC | RoBERTa-base | 27.2K (ASA K→5) | Accuracy | **0.8824** |
+| MRPC | RoBERTa-large | 66.7K (ASA K→5) | Accuracy | **0.9044** |
+
+**Notes:**
+- Configuration: r=100, K=10→5 (ASA), ri=1
+- AdaMSS active params with ASA (5 out of 10 subspaces selected)
+- Full AdaMSS capacity: 97K (large) / 42K (base)
+- Training: 100 epochs, batch_size=32, warmup_ratio=0.06
+
+### Vision Tasks (Image Classification)
+
+Results with AdaMSS on Stanford Cars (10 epochs, seed=0):
+
+| Model | Method | AdaMSS Params | Test Accuracy |
+|-------|--------|---------------|---------------|
+| ViT-Base | AdaMSS (no ASA) | 121K (K=10) | **82.15%** |
+| ViT-Base | AdaMSS + ASA | 75.0K (K→5) | **80.45%** |
+
+**Notes:**
+- Configuration: r=100, K=10, ri=3, 10 epochs, batch_size=32
+- ASA dynamically selects 5 out of 10 subspaces (75K active from 121K total)
+
+
+
+## Citation
+
+If you use AdaMSS in your research, please cite:
+
+```bibtex
+@inproceedings{zheng2025adamss,
+  title={AdaMSS: Adaptive Multi-Subspace Approach for Parameter-Efficient Fine-Tuning},
+  author={Zheng, Jingjing and Lu, Wanglong and Dong, Yiming and Ji, Chaojie and Cao, Yankai and Lin, Zhouchen},
+  booktitle={The Thirty-ninth Annual Conference on Neural Information Processing Systems},
+  year={2025},
+}
+```
+
+## Reference
+
+- [AdaMSS Paper](https://neurips.cc/virtual/2025/loc/san-diego/poster/119606)
+- [PEFT Documentation](https://huggingface.co/docs/peft)
diff --git a/examples/adamss_finetuning/glue_adamss_asa_example.py b/examples/adamss_finetuning/glue_adamss_asa_example.py
new file mode 100644
index 0000000..ed5728b
--- /dev/null
+++ b/examples/adamss_finetuning/glue_adamss_asa_example.py
@@ -0,0 +1,382 @@
+"""
+GLUE Task Fine-tuning with AdaMSS and ASA
+
+This script demonstrates how to fine-tune RoBERTa on GLUE tasks using AdaMSS
+with Adaptive Subspace Allocation (ASA) for efficient parameter updates.
+
+Example usage:
+    # CoLA with RoBERTa-base, 100 epochs
+    python glue_adamss_asa_example.py --dataset_name cola --num_epochs 100 --seed 0
+
+    # With ASA enabled (K: 10→5)
+    python glue_adamss_asa_example.py --dataset_name cola --num_epochs 100 --use_asa --asa_target_subspaces 5
+
+    # MRPC with RoBERTa-large
+    python glue_adamss_asa_example.py --dataset_name mrpc --model_name_or_path roberta-large --num_epochs 10
+
+Requirements:
+    pip install peft transformers datasets torch evaluate scikit-learn
+"""
+
+from dataclasses import dataclass, field
+
+import evaluate
+import numpy as np
+import torch
+from datasets import load_dataset
+from torch.optim import AdamW
+from transformers import (
+    AutoModelForSequenceClassification,
+    AutoTokenizer,
+    EvalPrediction,
+    HfArgumentParser,
+    Trainer,
+    TrainingArguments,
+)
+
+from peft import AdamssConfig, get_peft_model
+from peft.tuners.adamss.asa_callback import AdamssAsaCallback
+
+
+# Table 19: Hyperparameters for GLUE tasks (from paper)
+HYPERPARAMS = {
+    "roberta-base": {
+        "sst2": {"lr": 0.001, "head_lr": 0.005, "wd": 0.0005},
+        "mrpc": {"lr": 0.01, "head_lr": 0.0005, "wd": 0.0},
+        "cola": {"lr": 0.001, "head_lr": 0.005, "wd": 0.005},
+        "qnli": {"lr": 0.001, "head_lr": 0.005, "wd": 0.005},
+        "rte": {"lr": 0.0005, "head_lr": 0.005, "wd": 0.005},
+        "stsb": {"lr": 0.001, "head_lr": 0.005, "wd": 0.005},
+    },
+    "roberta-large": {
+        "sst2": {"lr": 0.001, "head_lr": 0.0005, "wd": 0.0},
+        "mrpc": {"lr": 0.001, "head_lr": 0.00005, "wd": 0.005},
+        "cola": {"lr": 0.005, "head_lr": 0.0005, "wd": 0.1},
+        "qnli": {"lr": 0.0005, "head_lr": 0.05, "wd": 0.005},
+        "rte": {"lr": 0.005, "head_lr": 0.005, "wd": 0.5},
+        "stsb": {"lr": 0.001, "head_lr": 0.0005, "wd": 0.0005},
+    },
+}
+
+TASK_METRICS = {
+    "cola": "matthews_correlation",
+    "stsb": "pearson",
+    "mrpc": "accuracy",
+    "qqp": "accuracy",
+    "sst2": "accuracy",
+    "qnli": "accuracy",
+    "rte": "accuracy",
+}
+
+
+@dataclass
+class AdaMSSTrainingArguments:
+    """Arguments for AdaMSS training on GLUE tasks."""
+
+    # Model and Dataset
+    model_name_or_path: str = field(
+        default="roberta-base", metadata={"help": "Model identifier: roberta-base or roberta-large"}
+    )
+    dataset_name: str = field(default="cola", metadata={"help": "GLUE task: cola, mrpc, sst2, qnli, rte, stsb"})
+
+    # AdaMSS Configuration
+    adamss_r: int = field(default=100, metadata={"help": "SVD rank"})
+    adamss_k: int = field(default=10, metadata={"help": "Number of subspaces (K)"})
+    adamss_ri: int = field(default=1, metadata={"help": "Subspace rank (rk), use 1 for NLU"})
+
+    # ASA Configuration
+    use_asa: bool = field(default=False, metadata={"help": "Enable Adaptive Subspace Allocation"})
+    asa_target_subspaces: int = field(default=5, metadata={"help": "Target active subspaces for ASA"})
+    asa_init_warmup: int = field(default=5, metadata={"help": "ASA init warmup in EPOCHS"})
+    asa_final_warmup: int = field(default=95, metadata={"help": "ASA final warmup in EPOCHS"})
+    asa_mask_interval: int = field(default=10, metadata={"help": "ASA mask interval in EPOCHS"})
+    asa_importance_beta: float = field(default=0.85, metadata={"help": "EMA coefficient for importance"})
+    asa_uncertainty_beta: float = field(default=0.85, metadata={"help": "EMA coefficient for uncertainty"})
+    asa_schedule_exponent: float = field(default=3.0, metadata={"help": "ASA schedule exponent"})
+
+    # Training Configuration
+    num_epochs: int = field(default=100, metadata={"help": "Number of training epochs"})
+    batch_size: int = field(default=32, metadata={"help": "Batch size per device"})
+    max_length: int = field(default=512, metadata={"help": "Maximum sequence length"})
+    warmup_ratio: float = field(default=0.06, metadata={"help": "Warmup ratio"})
+
+    # Other
+    seed: int = field(default=0, metadata={"help": "Random seed"})
+    output_dir: str = field(default="./output", metadata={"help": "Output directory"})
+    cache_dir: str = field(default="./cache", metadata={"help": "Cache directory"})
+
+
+def get_dataset(args: AdaMSSTrainingArguments, tokenizer):
+    """Load and tokenize GLUE dataset."""
+    # Load dataset
+    raw_datasets = load_dataset("glue", args.dataset_name, cache_dir=args.cache_dir)
+
+    # Get sentence keys
+    sentence_keys = {
+        "cola": ("sentence", None),
+        "mrpc": ("sentence1", "sentence2"),
+        "qnli": ("question", "sentence"),
+        "rte": ("sentence1", "sentence2"),
+        "sst2": ("sentence", None),
+        "stsb": ("sentence1", "sentence2"),
+    }
+    sentence1_key, sentence2_key = sentence_keys[args.dataset_name]
+
+    # Tokenize
+    def preprocess_function(examples):
+        texts = (
+            (examples[sentence1_key],) if sentence2_key is None else (examples[sentence1_key], examples[sentence2_key])
+        )
+        result = tokenizer(*texts, truncation=True, max_length=args.max_length, padding="max_length")
+        result["labels"] = examples["label"]
+        return result
+
+    # Remove original text columns but keep label
+    columns_to_remove = [col for col in raw_datasets["train"].column_names if col != "label"]
+    tokenized_datasets = raw_datasets.map(
+        preprocess_function,
+        batched=True,
+        remove_columns=columns_to_remove,
+        desc="Tokenizing dataset",
+    )
+
+    train_ds = tokenized_datasets["train"]
+    val_ds = tokenized_datasets["validation"]
+    test_ds = tokenized_datasets["validation"]  # Use validation as test for GLUE
+
+    return train_ds, val_ds, test_ds
+
+
+def main():
+    # Parse arguments
+    parser = HfArgumentParser(AdaMSSTrainingArguments)
+    args = parser.parse_args_into_dataclasses()[0]
+
+    # Set seed
+    torch.manual_seed(args.seed)
+    np.random.seed(args.seed)
+
+    # Get model short name
+    model_short = "roberta-large" if "large" in args.model_name_or_path else "roberta-base"
+
+    # Get hyperparameters from Table 19
+    if model_short in HYPERPARAMS and args.dataset_name in HYPERPARAMS[model_short]:
+        hp = HYPERPARAMS[model_short][args.dataset_name]
+    else:
+        hp = {"lr": 0.001, "head_lr": 0.005, "wd": 0.005}
+        print(f"Using default hyperparameters for {model_short}/{args.dataset_name}")
+
+    # Print configuration
+    print("=" * 80)
+    print(f"AdaMSS {'with ASA' if args.use_asa else 'without ASA'} - GLUE: {args.dataset_name.upper()}")
+    print("=" * 80)
+    print(f"  Model: {model_short}")
+    print(f"  AdaMSS: r={args.adamss_r}, K={args.adamss_k}, ri={args.adamss_ri}")
+    if args.use_asa:
+        print(f"  ASA: K={args.adamss_k} → target={args.asa_target_subspaces}")
+    print(f"  Hyperparameters (Table 19): lr={hp['lr']}, head_lr={hp['head_lr']}, wd={hp['wd']}")
+    print(f"  Training: {args.num_epochs} epochs, batch_size={args.batch_size}, seed={args.seed}")
+    print("=" * 80 + "\n")
+
+    # Load tokenizer
+    tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path, cache_dir=args.cache_dir)
+
+    # Load dataset
+    print(f"Loading {args.dataset_name} dataset...")
+    train_ds, val_ds, _test_ds = get_dataset(args, tokenizer)
+
+    # Determine task type
+    is_regression = args.dataset_name == "stsb"
+    if not is_regression:
+        label_list = train_ds.features["label"].names
+        num_labels = len(label_list)
+    else:
+        num_labels = 1
+
+    print(f"Dataset loaded - Task: {'regression' if is_regression else 'classification'}\n")
+
+    # Load model
+    print(f"Loading {model_short}...")
+    model = AutoModelForSequenceClassification.from_pretrained(
+        args.model_name_or_path,
+        num_labels=num_labels,
+        cache_dir=args.cache_dir,
+    )
+
+    # Convert epoch-based ASA parameters to step-based (before config creation)
+    steps_per_epoch = len(train_ds) // args.batch_size
+    if len(train_ds) % args.batch_size != 0:
+        steps_per_epoch += 1
+
+    asa_init_warmup_steps = args.asa_init_warmup * steps_per_epoch
+    asa_final_warmup_steps = args.asa_final_warmup * steps_per_epoch
+    asa_mask_interval_steps = args.asa_mask_interval * steps_per_epoch
+
+    # Apply AdaMSS
+    print("\nApplying AdaMSS...")
+    config = AdamssConfig(
+        r=args.adamss_r,
+        num_subspaces=args.adamss_k,
+        subspace_rank=args.adamss_ri,
+        target_modules=["query", "value"],
+        use_asa=args.use_asa,
+        asa_target_subspaces=args.asa_target_subspaces if args.use_asa else None,
+        init_warmup=asa_init_warmup_steps if args.use_asa else None,
+        final_warmup=asa_final_warmup_steps if args.use_asa else None,
+        mask_interval=asa_mask_interval_steps if args.use_asa else None,
+        asa_importance_beta=args.asa_importance_beta if args.use_asa else None,
+        asa_uncertainty_beta=args.asa_uncertainty_beta if args.use_asa else None,
+        asa_schedule_exponent=args.asa_schedule_exponent if args.use_asa else None,
+        modules_to_save=["classifier"],
+    )
+
+    model = get_peft_model(model, config)
+    model.print_trainable_parameters()
+
+    # Print detailed parameter breakdown (same logic as exec_adamss_peft_glue.py)
+    print("\n[Detailed Parameter Breakdown]")
+    head_params = [p for n, p in model.named_parameters() if ("classifier" in n or "score" in n) and p.requires_grad]
+    other_params = [
+        p for n, p in model.named_parameters() if ("classifier" not in n and "score" not in n) and p.requires_grad
+    ]
+    head_count = sum(p.numel() for p in head_params)
+    adapter_count = sum(p.numel() for p in other_params)
+    print(f"Classifier Head Params: {head_count:,}")
+    print(f"AdaMSS Adapter Params:  {adapter_count:,}")
+    print(f"Total Trainable Params: {head_count + adapter_count:,}")
+
+    # Debug: print parameter names to verify
+    if adapter_count == 0:
+        print("\nWARNING: No AdaMSS parameters found!")
+        print("All trainable parameter names:")
+        for n, p in model.named_parameters():
+            if p.requires_grad:
+                print(f"  {n}: {p.numel():,} params")
+
+    # GPU memory
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+        torch.cuda.reset_peak_memory_stats()
+        print("\n[GPU Memory - Before Training]")
+        print(f"Allocated: {torch.cuda.memory_allocated() / 1024**3:.2f} GB")
+        print(f"Reserved: {torch.cuda.memory_reserved() / 1024**3:.2f} GB")
+
+    # Setup ASA callback
+    callbacks = []
+    if args.use_asa:
+        print("\nSetting up ASA callback...")
+
+        print("\n[ASA Configuration]")
+        print(f"Dataset size: {len(train_ds)}, Batch size: {args.batch_size}")
+        print(f"Steps per epoch: {steps_per_epoch}")
+        print(f"Total training steps: {steps_per_epoch * args.num_epochs}")
+        print("ASA warmup (epochs → steps):")
+        print(f"  init_warmup: {args.asa_init_warmup} epochs → {asa_init_warmup_steps} steps")
+        print(f"  final_warmup: {args.asa_final_warmup} epochs → {asa_final_warmup_steps} steps")
+        print(f"  mask_interval: {args.asa_mask_interval} epochs → {asa_mask_interval_steps} steps\n")
+
+        asa_callback = AdamssAsaCallback()
+        callbacks.append(asa_callback)
+
+    # Training configuration
+    print("\n[Training Configuration]")
+    print(f"Dataset size: {len(train_ds)}, Batch size: {args.batch_size}")
+    steps_per_epoch = len(train_ds) // args.batch_size
+    if len(train_ds) % args.batch_size != 0:
+        steps_per_epoch += 1
+    print(f"Steps per epoch: {steps_per_epoch}")
+    print(f"Total training steps: {steps_per_epoch * args.num_epochs}")
+
+    # Metrics
+    metric = evaluate.load("glue", args.dataset_name)
+
+    def compute_metrics(p: EvalPrediction):
+        preds = p.predictions[0] if isinstance(p.predictions, tuple) else p.predictions
+        preds = np.squeeze(preds) if is_regression else np.argmax(preds, axis=1)
+        return metric.compute(predictions=preds, references=p.label_ids)
+
+    # Training arguments
+    training_args = TrainingArguments(
+        output_dir=args.output_dir,
+        num_train_epochs=args.num_epochs,
+        per_device_train_batch_size=args.batch_size,
+        per_device_eval_batch_size=args.batch_size,
+        learning_rate=hp["lr"],
+        weight_decay=hp["wd"],
+        warmup_ratio=args.warmup_ratio,
+        eval_strategy="epoch",
+        save_strategy="epoch",
+        load_best_model_at_end=True,
+        metric_for_best_model=TASK_METRICS.get(args.dataset_name, "accuracy"),
+        greater_is_better=True,
+        logging_steps=100,
+        seed=args.seed,
+        report_to="none",
+        remove_unused_columns=False,  # PEFT wraps forward(*args, **kwargs)
+        label_names=["labels"],  # Explicitly tell Trainer where labels are
+    )
+
+    # Custom optimizer with different LR for head
+    optimizer_grouped_parameters = [
+        {
+            "params": [
+                p for n, p in model.named_parameters() if ("classifier" in n or "score" in n) and p.requires_grad
+            ],
+            "lr": hp["head_lr"],
+        },
+        {
+            "params": [
+                p
+                for n, p in model.named_parameters()
+                if ("classifier" not in n and "score" not in n) and p.requires_grad
+            ],
+            "lr": hp["lr"],
+        },
+    ]
+    optimizer = AdamW(optimizer_grouped_parameters, weight_decay=hp["wd"])
+
+    # Create trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_ds,
+        eval_dataset=val_ds,
+        compute_metrics=compute_metrics,
+        optimizers=(optimizer, None),
+        callbacks=callbacks,
+    )
+
+    # Train
+    print("\n" + "=" * 80)
+    print("Starting training...")
+    print("=" * 80 + "\n")
+
+    train_result = trainer.train()
+
+    # GPU memory stats
+    if torch.cuda.is_available():
+        print("\n[GPU Memory - Peak During Training]")
+        print(f"Peak Allocated: {torch.cuda.max_memory_allocated() / 1024**3:.2f} GB")
+        print(f"Peak Reserved: {torch.cuda.max_memory_reserved() / 1024**3:.2f} GB")
+
+    # Print best metric
+    if trainer.state.best_metric is not None:
+        metric_name = TASK_METRICS.get(args.dataset_name, "accuracy")
+        print("\n[Best Model Info]")
+        print(f"Best {metric_name}: {trainer.state.best_metric:.4f}")
+
+    # Final evaluation on validation set
+    print("\n" + "=" * 80)
+    print("Final evaluation on validation set...")
+    print("=" * 80 + "\n")
+
+    final_metrics = trainer.evaluate(val_ds)
+    print(f"\nFinal Validation Results: {final_metrics}")
+
+    # Save model
+    trainer.save_model()
+    print(f"\nModel saved to {training_args.output_dir}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/adamss_finetuning/glue_adamss_asa_manual_example.py b/examples/adamss_finetuning/glue_adamss_asa_manual_example.py
new file mode 100644
index 0000000..9a8c079
--- /dev/null
+++ b/examples/adamss_finetuning/glue_adamss_asa_manual_example.py
@@ -0,0 +1,411 @@
+"""
+GLUE Task Fine-tuning with AdaMSS and Manual ASA
+
+This script demonstrates how to manually call update_and_allocate() for ASA
+instead of using AdamssAsaCallback. This approach is useful for custom training loops.
+
+Note:
+    This is an alternative to using AdamssAsaCallback. Choose ONE approach:
+    - Use AdamssAsaCallback (recommended, see glue_adamss_asa_example.py)
+    - Use manual update_and_allocate() (this script, for custom control)
+    DO NOT use both together!
+
+Example usage:
+    # CoLA with RoBERTa-base and manual ASA
+    python glue_adamss_asa_manual_example.py \
+        --dataset_name cola \
+        --use_asa \
+        --asa_target_subspaces 5 \
+        --num_epochs 100 \
+        --batch_size 32 \
+        --warmup_ratio 0.06 \
+        --seed 0 \
+        --output_dir ./output/cola_asa_manual
+
+Requirements:
+    pip install peft transformers datasets torch evaluate scikit-learn
+"""
+
+from dataclasses import dataclass, field
+
+import evaluate
+import numpy as np
+import torch
+from datasets import load_dataset
+from transformers import (
+    AutoModelForSequenceClassification,
+    AutoTokenizer,
+    EvalPrediction,
+    HfArgumentParser,
+    Trainer,
+    TrainingArguments,
+    set_seed,
+)
+
+from peft import AdamssConfig, get_peft_model
+
+
+class CustomTrainerWithManualASA(Trainer):
+    """
+    Custom Trainer that manually calls update_and_allocate() for ASA.
+
+    This demonstrates the manual approach as an alternative to using AdamssAsaCallback.
+    The update_and_allocate() method is called after optimizer.step() but before
+    zero_grad() to compute importance scores from gradients.
+    """
+
+    def training_step(self, model, inputs, num_items_in_batch=None):
+        """
+        Override training_step to add manual ASA update.
+
+        Training step sequence:
+        1. Forward pass
+        2. Backward pass (gradients computed)
+        3. Optimizer step (parameters updated)
+        4. >>> Manual ASA update (importance scoring & masking) <<<
+        5. Zero gradients
+        """
+        model.train()
+        inputs = self._prepare_inputs(inputs)
+
+        # Forward & backward pass
+        with self.compute_loss_context_manager():
+            loss = self.compute_loss(model, inputs)
+
+        if self.args.gradient_accumulation_steps > 1:
+            loss = loss / self.args.gradient_accumulation_steps
+
+        self.accelerator.backward(loss)
+
+        # 🔑 Key: Manual ASA update after backward, before zero_grad
+        # This is where update_and_allocate() inspects gradients and applies masking
+        if (
+            hasattr(model, "base_model")
+            and hasattr(model.base_model, "update_and_allocate")
+            and (self.state.global_step + 1) % self.args.gradient_accumulation_steps == 0
+        ):
+            # Only call if we're actually doing optimizer step (not accumulating)
+            model.base_model.update_and_allocate(self.state.global_step)
+
+        return loss.detach()
+
+
+@dataclass
+class AdaMSSArguments:
+    """Arguments for AdaMSS configuration."""
+
+    # Basic AdaMSS parameters
+    adamss_r: int = field(default=100, metadata={"help": "SVD decomposition rank (R in paper)."})
+    adamss_k: int = field(default=10, metadata={"help": "Number of subspaces (K in paper)."})
+    adamss_ri: int = field(default=1, metadata={"help": "Subspace rank (rk in paper), typically 1 for NLU."})
+
+    # Training configuration
+    num_epochs: int = field(default=100, metadata={"help": "Number of training epochs."})
+    batch_size: int = field(default=32, metadata={"help": "Batch size per device."})
+    warmup_ratio: float = field(default=0.06, metadata={"help": "Warmup ratio."})
+    seed: int = field(default=0, metadata={"help": "Random seed."})
+    output_dir: str = field(default="./output", metadata={"help": "Output directory."})
+
+    # ASA parameters
+    use_asa: bool = field(default=False, metadata={"help": "Enable Adaptive Subspace Allocation (manual mode)."})
+    asa_target_subspaces: int = field(
+        default=5, metadata={"help": "Target number of active subspaces when ASA is enabled."}
+    )
+    asa_init_warmup: int = field(default=5, metadata={"help": "ASA warmup EPOCHS before starting masking."})
+    asa_final_warmup: int = field(default=95, metadata={"help": "ASA EPOCHS to reach target active subspaces."})
+    asa_mask_interval: int = field(default=10, metadata={"help": "EPOCHS between ASA updates."})
+    asa_importance_beta: float = field(default=0.85, metadata={"help": "EMA coefficient for importance."})
+    asa_uncertainty_beta: float = field(default=0.85, metadata={"help": "EMA coefficient for uncertainty."})
+    asa_schedule_exponent: float = field(default=3.0, metadata={"help": "ASA schedule exponent."})
+
+
+@dataclass
+class DataArguments:
+    """Arguments for dataset configuration."""
+
+    dataset_name: str = field(default="cola", metadata={"help": "GLUE task name (cola, mrpc, qnli, rte, stsb, sst2)."})
+    max_length: int = field(default=512, metadata={"help": "Maximum sequence length."})
+
+
+# Hyperparameters from Table 19 in the paper
+HYPERPARAMS = {
+    "roberta-large": {
+        "cola": {"lr": 0.005, "head_lr": 0.0005, "wd": 0.1},
+        "mrpc": {"lr": 0.001, "head_lr": 0.00005, "wd": 0.005},
+        "qnli": {"lr": 0.0005, "head_lr": 0.05, "wd": 0.005},
+        "rte": {"lr": 0.005, "head_lr": 0.005, "wd": 0.5},
+        "stsb": {"lr": 0.001, "head_lr": 0.0005, "wd": 0.0005},
+        "sst2": {"lr": 0.001, "head_lr": 0.0005, "wd": 0.0},
+    },
+    "roberta-base": {
+        "cola": {"lr": 0.001, "head_lr": 0.005, "wd": 0.005},
+        "mrpc": {"lr": 0.01, "head_lr": 0.0005, "wd": 0.0},
+        "qnli": {"lr": 0.001, "head_lr": 0.005, "wd": 0.005},
+        "rte": {"lr": 0.0005, "head_lr": 0.005, "wd": 0.005},
+        "stsb": {"lr": 0.001, "head_lr": 0.005, "wd": 0.005},
+        "sst2": {"lr": 0.001, "head_lr": 0.005, "wd": 0.0005},
+    },
+}
+
+# Metrics for each task
+TASK_METRICS = {
+    "cola": "matthews_correlation",
+    "stsb": "pearson",
+    "mrpc": "accuracy",
+    "qqp": "accuracy",
+    "sst2": "accuracy",
+    "qnli": "accuracy",
+    "rte": "accuracy",
+}
+
+
+def main():
+    # Parse arguments
+    parser = HfArgumentParser((DataArguments, AdaMSSArguments))
+    data_args, adamss_args = parser.parse_args_into_dataclasses()
+
+    # Set seed
+    set_seed(adamss_args.seed)
+
+    # Extract model name from output_dir or use default
+    if "roberta-large" in str(adamss_args.output_dir).lower():
+        model_name = "roberta-large"
+    else:
+        model_name = "roberta-base"
+
+    print("=" * 80)
+    print(f"AdaMSS with MANUAL ASA - GLUE Task: {data_args.dataset_name.upper()}")
+    print("=" * 80)
+    print(f"Model: {model_name}")
+    print(f"AdaMSS: r={adamss_args.adamss_r}, K={adamss_args.adamss_k}, ri={adamss_args.adamss_ri}")
+
+    # Get hyperparameters
+    if model_name in HYPERPARAMS and data_args.dataset_name in HYPERPARAMS[model_name]:
+        hp = HYPERPARAMS[model_name][data_args.dataset_name]
+        print(f"Hyperparameters (Table 19): lr={hp['lr']}, head_lr={hp['head_lr']}, wd={hp['wd']}")
+    else:
+        hp = {"lr": 0.001, "head_lr": 0.005, "wd": 0.005}
+        print(f"Using default hyperparameters: {hp}")
+
+    print(f"Training: {adamss_args.num_epochs} epochs, batch_size={adamss_args.batch_size}, seed={adamss_args.seed}")
+
+    if adamss_args.use_asa:
+        print(f"Manual ASA Mode: Target {adamss_args.asa_target_subspaces}/{adamss_args.adamss_k} subspaces")
+        print(f"     Warmup epochs {adamss_args.asa_init_warmup} → {adamss_args.asa_final_warmup}")
+        print("     Using update_and_allocate() instead of AdamssAsaCallback")
+
+    # Load dataset
+    print(f"\nLoading {data_args.dataset_name} dataset...")
+    dataset = load_dataset("glue", data_args.dataset_name)
+
+    # Get task info
+    is_regression = data_args.dataset_name == "stsb"
+    if not is_regression:
+        label_list = dataset["train"].features["label"].names
+        num_labels = len(label_list)
+    else:
+        num_labels = 1
+
+    print(f"Dataset loaded - Task type: {'regression' if is_regression else 'classification'}")
+
+    # Load tokenizer and model
+    print(f"\nLoading {model_name}...")
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    model = AutoModelForSequenceClassification.from_pretrained(
+        model_name,
+        num_labels=num_labels,
+    )
+
+    # Tokenize dataset
+    def preprocess_function(examples):
+        # Handle different GLUE tasks
+        if data_args.dataset_name in ["mrpc", "stsb", "qqp"]:
+            texts = (examples["sentence1"], examples["sentence2"])
+        elif data_args.dataset_name == "qnli":
+            texts = (examples["question"], examples["sentence"])
+        elif data_args.dataset_name == "rte":
+            texts = (examples["sentence1"], examples["sentence2"])
+        else:  # cola, sst2, etc.
+            texts = (examples["sentence"],)
+
+        result = tokenizer(*texts, truncation=True, max_length=data_args.max_length, padding="max_length")
+        result["labels"] = examples["label"]
+        return result
+
+    print("Tokenizing dataset...")
+    # Remove all columns except label
+    columns_to_remove = [col for col in dataset["train"].column_names if col != "label"]
+    tokenized_datasets = dataset.map(
+        preprocess_function,
+        batched=True,
+        remove_columns=columns_to_remove,
+    )
+
+    train_ds = tokenized_datasets["train"]
+    val_ds = tokenized_datasets["validation"]
+    test_key = "test" if "test" in tokenized_datasets else "validation"
+    test_ds = tokenized_datasets[test_key]
+
+    # Create TrainingArguments manually (not parsed to avoid conflicts)
+    training_args = TrainingArguments(
+        output_dir=adamss_args.output_dir,
+        num_train_epochs=adamss_args.num_epochs,
+        per_device_train_batch_size=adamss_args.batch_size,
+        per_device_eval_batch_size=adamss_args.batch_size,
+        learning_rate=hp["lr"],
+        weight_decay=hp["wd"],
+        warmup_ratio=adamss_args.warmup_ratio,
+        eval_strategy="epoch",
+        save_strategy="epoch",
+        load_best_model_at_end=True,
+        metric_for_best_model=TASK_METRICS.get(data_args.dataset_name, "accuracy"),
+        greater_is_better=True,
+        logging_steps=100,
+        logging_strategy="steps",
+        seed=adamss_args.seed,
+        report_to="none",
+        remove_unused_columns=False,  # PEFT wraps forward(*args, **kwargs)
+        label_names=["labels"],  # Explicitly tell Trainer where labels are
+    )
+
+    # Configure AdaMSS with ASA parameters stored in config
+    print("\nApplying AdaMSS...")
+
+    # Convert epoch-based parameters to step-based for config
+    steps_per_epoch = len(train_ds) // adamss_args.batch_size
+    if len(train_ds) % adamss_args.batch_size != 0:
+        steps_per_epoch += 1
+    total_steps = adamss_args.num_epochs * steps_per_epoch
+
+    print("\n[Training Configuration]")
+    print(f"Dataset size: {len(train_ds)}")
+    print(f"Batch size: {adamss_args.batch_size}")
+    print(f"Steps per epoch: {steps_per_epoch}")
+    print(f"Total steps: {adamss_args.num_epochs} epochs × {steps_per_epoch} steps = {total_steps} steps")
+
+    asa_init_warmup_steps = adamss_args.asa_init_warmup * steps_per_epoch
+    asa_final_warmup_steps = adamss_args.asa_final_warmup * steps_per_epoch
+    asa_mask_interval_steps = adamss_args.asa_mask_interval * steps_per_epoch
+
+    if adamss_args.use_asa:
+        print("\n[ASA Configuration (Epoch → Step Conversion)]")
+        print(f"  init warmup: {adamss_args.asa_init_warmup} epochs → {asa_init_warmup_steps} steps")
+        print(f"  final warmup: {adamss_args.asa_final_warmup} epochs → {asa_final_warmup_steps} steps")
+        print(f"  mask interval: {adamss_args.asa_mask_interval} epochs → {asa_mask_interval_steps} steps")
+
+    config = AdamssConfig(
+        r=adamss_args.adamss_r,
+        num_subspaces=adamss_args.adamss_k,
+        subspace_rank=adamss_args.adamss_ri,
+        target_modules=["query", "value"],
+        use_asa=adamss_args.use_asa,
+        asa_target_subspaces=adamss_args.asa_target_subspaces if adamss_args.use_asa else None,
+        # Store step-based ASA parameters in config
+        init_warmup=asa_init_warmup_steps if adamss_args.use_asa else None,
+        final_warmup=asa_final_warmup_steps if adamss_args.use_asa else None,
+        mask_interval=asa_mask_interval_steps if adamss_args.use_asa else None,
+        asa_importance_beta=adamss_args.asa_importance_beta if adamss_args.use_asa else None,
+        asa_uncertainty_beta=adamss_args.asa_uncertainty_beta if adamss_args.use_asa else None,
+        asa_schedule_exponent=adamss_args.asa_schedule_exponent if adamss_args.use_asa else None,
+        modules_to_save=["classifier"],
+    )
+
+    model = get_peft_model(model, config)
+    model.print_trainable_parameters()
+
+    # Print detailed parameter breakdown (same logic as exec_adamss_peft_glue.py)
+    print("\n[Detailed Parameter Breakdown]")
+    head_params = [p for n, p in model.named_parameters() if ("classifier" in n or "score" in n) and p.requires_grad]
+    other_params = [
+        p for n, p in model.named_parameters() if ("classifier" not in n and "score" not in n) and p.requires_grad
+    ]
+    head_count = sum(p.numel() for p in head_params)
+    adapter_count = sum(p.numel() for p in other_params)
+    print(f"Classifier Head Params: {head_count:,}")
+    print(f"AdaMSS Adapter Params:  {adapter_count:,}")
+    print(f"Total Trainable Params: {head_count + adapter_count:,}")
+
+    # GPU memory monitoring
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+        torch.cuda.reset_peak_memory_stats()
+        print("\n[GPU Memory - Before Training]")
+        print(f"Allocated: {torch.cuda.memory_allocated() / 1024**3:.2f} GB")
+        print(f"Reserved: {torch.cuda.memory_reserved() / 1024**3:.2f} GB")
+
+    # Metrics
+    metric = evaluate.load("glue", data_args.dataset_name)
+
+    def compute_metrics(p: EvalPrediction):
+        preds = p.predictions[0] if isinstance(p.predictions, tuple) else p.predictions
+        preds = np.squeeze(preds) if is_regression else np.argmax(preds, axis=1)
+        return metric.compute(predictions=preds, references=p.label_ids)
+
+    # Create custom optimizer with different LR for head
+    from torch.optim import AdamW
+
+    optimizer_grouped_parameters = [
+        {
+            "params": [
+                p for n, p in model.named_parameters() if ("classifier" in n or "score" in n) and p.requires_grad
+            ],
+            "lr": hp["head_lr"],
+        },
+        {
+            "params": [
+                p
+                for n, p in model.named_parameters()
+                if ("classifier" not in n and "score" not in n) and p.requires_grad
+            ],
+            "lr": hp["lr"],
+        },
+    ]
+    optimizer = AdamW(optimizer_grouped_parameters, weight_decay=hp["wd"])
+
+    # Create trainer with custom class that calls update_and_allocate()
+    # Note: NO callbacks here - we're using manual approach
+    trainer = CustomTrainerWithManualASA(
+        model=model,
+        args=training_args,
+        train_dataset=train_ds,
+        eval_dataset=val_ds,
+        compute_metrics=compute_metrics,
+        optimizers=(optimizer, None),
+    )
+
+    # Train
+    print("\n" + "=" * 80)
+    print("Starting training...")
+    if adamss_args.use_asa:
+        print("Manual ASA: update_and_allocate() will be called in training_step")
+    print("=" * 80 + "\n")
+
+    train_result = trainer.train()
+
+    # GPU memory stats
+    if torch.cuda.is_available():
+        print("\n[GPU Memory - Peak During Training]")
+        print(f"Peak Allocated: {torch.cuda.max_memory_allocated() / 1024**3:.2f} GB")
+        print(f"Peak Reserved: {torch.cuda.max_memory_reserved() / 1024**3:.2f} GB")
+
+    # Print best metric
+    if trainer.state.best_metric is not None:
+        metric_name = TASK_METRICS.get(data_args.dataset_name, "accuracy")
+        print("\n[Best Model Info]")
+        print(f"Best {metric_name}: {trainer.state.best_metric:.4f}")
+
+    # Evaluate on validation set (use val_ds, not test_ds to avoid label issues)
+    print("\n" + "=" * 80)
+    print("Final evaluation on validation set...")
+    print("=" * 80 + "\n")
+
+    final_metrics = trainer.evaluate(val_ds)
+    print(f"\nFinal Validation Results: {final_metrics}")
+
+    # Save model
+    trainer.save_model()
+    print(f"\nModel saved to {training_args.output_dir}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/adamss_finetuning/image_classification_adamss_asa.py b/examples/adamss_finetuning/image_classification_adamss_asa.py
new file mode 100644
index 0000000..53efd78
--- /dev/null
+++ b/examples/adamss_finetuning/image_classification_adamss_asa.py
@@ -0,0 +1,452 @@
+"""
+Image Classification with AdaMSS and ASA Callback
+
+This script demonstrates how to fine-tune a Vision Transformer (ViT) model
+using AdaMSS (Adaptive Matrix Decomposition with Subspace Selection) and
+ASA (Adaptive Subspace Allocation) callback from PEFT.
+
+Example usage:
+    python image_classification_adamss_asa.py \\
+        --model_name_or_path google/vit-base-patch16-224-in21k \\
+        --dataset_name cifar10 \\
+        --adamss_r 100 \\
+        --adamss_k 10 \\
+        --adamss_ri 3 \\
+        --use_asa \\
+        --asa_target_subspaces 5 \\
+        --num_epochs 10 \\
+        --output_dir ./output
+
+Requirements:
+    pip install peft transformers datasets torch torchvision evaluate
+"""
+
+from dataclasses import dataclass, field
+from functools import partial
+from typing import Optional
+
+import evaluate
+import torch
+from datasets import load_dataset
+from torchvision.transforms import (
+    CenterCrop,
+    Compose,
+    Normalize,
+    RandomHorizontalFlip,
+    RandomResizedCrop,
+    Resize,
+    ToTensor,
+)
+from transformers import (
+    AutoImageProcessor,
+    AutoModelForImageClassification,
+    HfArgumentParser,
+    Trainer,
+    TrainingArguments,
+)
+
+from peft import AdamssConfig, get_peft_model
+from peft.tuners.adamss.asa_callback import AdamssAsaCallback
+
+
+# Hyperparameters from Table 18 in the paper
+HYPERPARAMS = {
+    "vit-large-patch16-224-in21k": {
+        "pets": {"lr": 0.001, "head_lr": 0.0005, "wd": 0.0005},
+        "cars": {"lr": 0.01, "head_lr": 0.005, "wd": 0.1},
+        "cifar10": {"lr": 0.01, "head_lr": 0.05, "wd": 0.1},
+        "cifar100": {"lr": 0.01, "head_lr": 0.05, "wd": 0.05},
+        "eurosat": {"lr": 0.01, "head_lr": 0.0005, "wd": 0.01},
+        "fgvc": {"lr": 0.01, "head_lr": 0.0005, "wd": 0.0005},
+        "resisc": {"lr": 0.01, "head_lr": 0.0005, "wd": 0.1},
+    },
+    "vit-base-patch16-224-in21k": {
+        "pets": {"lr": 0.005, "head_lr": 0.005, "wd": 0.0005},
+        "cars": {"lr": 0.01, "head_lr": 0.005, "wd": 0.0},
+        "cifar10": {"lr": 0.01, "head_lr": 0.005, "wd": 0.05},
+        "cifar100": {"lr": 0.01, "head_lr": 0.005, "wd": 0.05},
+        "eurosat": {"lr": 0.01, "head_lr": 0.0005, "wd": 0.05},
+        "fgvc": {"lr": 0.01, "head_lr": 0.005, "wd": 0.0005},
+        "resisc": {"lr": 0.01, "head_lr": 0.005, "wd": 0.0005},
+    },
+}
+
+# Model-specific K values (number of subspaces)
+MODEL_K_VALUES = {
+    "vit-large-patch16-224-in21k": 16,
+    "vit-base-patch16-224-in21k": 10,
+}
+# Dataset configurations (matching exec_adamss_peft.py)
+DATASET_CONFIGS = {
+    "cars": {
+        "train": "Multimodal-Fatima/StanfordCars_train",
+        "test": "Multimodal-Fatima/StanfordCars_test",
+        "img_col": "image",
+        "label_col": "label",
+    },
+    "cifar10": {
+        "train": "Multimodal-Fatima/CIFAR10_train",
+        "test": "Multimodal-Fatima/CIFAR10_test",
+        "img_col": "image",
+        "label_col": "label",
+    },
+    "cifar100": {
+        "train": "cifar100",
+        "test": "cifar100",
+        "img_col": "img",
+        "label_col": "fine_label",
+    },
+    "eurosat": {
+        "dataset": "timm/eurosat-rgb",
+        "img_col": "image",
+        "label_col": "label",
+    },
+    "pets": {
+        "train": "timm/oxford-iiit-pet",
+        "test": "timm/oxford-iiit-pet",
+        "img_col": "image",
+        "label_col": "label",
+    },
+}
+
+
+# Global preprocessing functions (to avoid closure issues with set_transform)
+def _preprocess_images(examples, img_col, transforms):
+    """Apply image transformations."""
+    examples["pixel_values"] = [transforms(img.convert("RGB")) for img in examples[img_col]]
+    return examples
+
+
+def _collate_batch(examples, label_col):
+    """Collate examples into a batch."""
+    pixel_values = torch.stack([ex["pixel_values"] for ex in examples])
+    labels = torch.tensor([ex[label_col] for ex in examples])
+    return {"pixel_values": pixel_values, "labels": labels}
+
+
+@dataclass
+class ImageClassificationArguments:
+    """Arguments for image classification with AdaMSS and ASA."""
+
+    # Model configuration
+    model_name_or_path: str = field(
+        default="google/vit-base-patch16-224-in21k", metadata={"help": "Model identifier: vit-base or vit-large"}
+    )
+    dataset_name: str = field(
+        default="cifar10", metadata={"help": "Dataset: cifar10, cifar100, pets, cars, eurosat, fgvc, resisc"}
+    )
+
+    # AdaMSS Configuration
+    adamss_r: int = field(default=100, metadata={"help": "SVD rank"})
+    adamss_k: int = field(default=10, metadata={"help": "Number of subspaces (K), auto-set based on model"})
+    adamss_ri: int = field(default=3, metadata={"help": "Subspace rank (rk), use 3 for vision"})
+
+    # ASA Configuration
+    use_asa: bool = field(default=False, metadata={"help": "Enable Adaptive Subspace Allocation"})
+    asa_target_subspaces: int = field(default=5, metadata={"help": "Target active subspaces for ASA"})
+    asa_init_warmup: int = field(default=50, metadata={"help": "ASA init warmup in STEPS"})
+    asa_final_warmup: int = field(default=1000, metadata={"help": "ASA final warmup in STEPS"})
+    asa_mask_interval: int = field(default=100, metadata={"help": "ASA mask interval in STEPS"})
+    asa_importance_beta: float = field(default=0.85, metadata={"help": "EMA coefficient for importance"})
+    asa_uncertainty_beta: float = field(default=0.85, metadata={"help": "EMA coefficient for uncertainty"})
+    asa_schedule_exponent: float = field(default=3.0, metadata={"help": "ASA schedule exponent"})
+
+    # Training Configuration
+    num_epochs: int = field(default=10, metadata={"help": "Number of training epochs"})
+    batch_size: int = field(default=32, metadata={"help": "Batch size per device"})
+    warmup_ratio: float = field(default=0.0, metadata={"help": "Warmup ratio"})
+    max_train_samples: Optional[int] = field(default=None, metadata={"help": "Max training samples (for debug)"})
+
+    # Other
+    seed: int = field(default=0, metadata={"help": "Random seed"})
+    output_dir: str = field(default="./output", metadata={"help": "Output directory"})
+    cache_dir: Optional[str] = field(default=None, metadata={"help": "Cache directory"})
+
+
+def prepare_transforms(image_processor):
+    """Prepare image transformations."""
+    normalize = Normalize(mean=image_processor.image_mean, std=image_processor.image_std)
+    size = image_processor.size["height"]
+
+    train_transforms = Compose(
+        [
+            RandomResizedCrop(size),
+            RandomHorizontalFlip(),
+            ToTensor(),
+            normalize,
+        ]
+    )
+    val_transforms = Compose(
+        [
+            Resize(size),
+            CenterCrop(size),
+            ToTensor(),
+            normalize,
+        ]
+    )
+    return train_transforms, val_transforms
+
+
+def main():
+    # Parse arguments
+    parser = HfArgumentParser(ImageClassificationArguments)
+    args = parser.parse_args_into_dataclasses()[0]
+
+    # Set seed
+    torch.manual_seed(args.seed)
+
+    # Auto-detect model type and set K value
+    model_name = args.model_name_or_path
+    model_type = None
+    for key in MODEL_K_VALUES:
+        if key in model_name:
+            model_type = key
+            break
+
+    if model_type is None:
+        # Default to base model
+        model_type = "vit-base-patch16-224-in21k"
+        print(f"Warning: Model type not recognized, defaulting to {model_type}")
+
+    # Override K value based on model type
+    args.adamss_k = MODEL_K_VALUES[model_type]
+
+    # Get hyperparameters from Table 18
+    if model_type in HYPERPARAMS and args.dataset_name in HYPERPARAMS[model_type]:
+        hp = HYPERPARAMS[model_type][args.dataset_name]
+        print(f"Using Table 18 hyperparameters for {model_type} + {args.dataset_name}")
+        print(f"   lr={hp['lr']}, head_lr={hp['head_lr']}, wd={hp['wd']}")
+    else:
+        hp = {"lr": 0.01, "head_lr": 0.005, "wd": 0.0005}
+        print(f"Warning: No Table 18 hyperparameters found, using defaults: {hp}")
+
+    print("\n" + "=" * 80)
+    print(f"AdaMSS {'with ASA' if args.use_asa else 'without ASA'} - {args.dataset_name.upper()}")
+    print("=" * 80)
+    print(f"Model: {model_type}")
+    print(f"AdaMSS: r={args.adamss_r}, K={args.adamss_k}, ri={args.adamss_ri}")
+    if args.use_asa:
+        print(f"ASA: Target {args.asa_target_subspaces}/{args.adamss_k} subspaces")
+        print(f"     Warmup steps {args.asa_init_warmup} → {args.asa_final_warmup}")
+    print(f"Training: {args.num_epochs} epochs, batch_size={args.batch_size}, seed={args.seed}")
+    print("=" * 80 + "\n")
+
+    # Get dataset configuration
+    if args.dataset_name not in DATASET_CONFIGS:
+        raise ValueError(f"Unsupported dataset: {args.dataset_name}. Supported: {list(DATASET_CONFIGS.keys())}")
+
+    config = DATASET_CONFIGS[args.dataset_name]
+    img_name = config["img_col"]
+    label_name = config["label_col"]
+
+    # Load dataset
+    print(f"Loading {args.dataset_name} dataset...")
+    if "dataset" in config:
+        # Single dataset with train/val/test splits (e.g., eurosat)
+        dataset = load_dataset(config["dataset"], cache_dir=args.cache_dir)
+        train_val = dataset["train"].train_test_split(test_size=0.1, seed=args.seed)
+        train_ds = train_val["train"]
+        val_ds = train_val["test"]
+        # Try 'test' split, fall back to 'val' if not available
+        if "test" in dataset:
+            test_ds = dataset["test"]
+        elif "val" in dataset:
+            test_ds = dataset["val"]
+        else:
+            print("Warning: No test/val split found, using validation set as test")
+            test_ds = val_ds
+    else:
+        # Separate train and test datasets (e.g., cars, cifar10)
+        train_val_ds = load_dataset(config["train"], split="train", cache_dir=args.cache_dir)
+        test_ds = load_dataset(config["test"], split="test", cache_dir=args.cache_dir)
+
+        # Split train into train and validation
+        train_val = train_val_ds.train_test_split(test_size=0.1, seed=args.seed)
+        train_ds = train_val["train"]
+        val_ds = train_val["test"]
+
+    print(f"Detected columns - Image: '{img_name}', Label: '{label_name}'")
+
+    # Limit train samples if specified (for quick testing)
+    if args.max_train_samples:
+        train_ds = train_ds.select(range(min(args.max_train_samples, len(train_ds))))
+        # Also limit validation for faster testing
+        val_ds = val_ds.select(range(min(5000, len(val_ds))))
+
+    labels = train_ds.features[label_name].names
+    num_classes = len(labels)
+    print(f"Dataset loaded: {len(train_ds)} train, {len(val_ds)} val, {len(test_ds)} test")
+    print(f"   Number of classes: {num_classes}")
+
+    # Create label mappings
+    label2id = {label: i for i, label in enumerate(labels)}
+    id2label = dict(enumerate(labels))
+
+    # Load image processor
+    print("\nLoading image processor...")
+    image_processor = AutoImageProcessor.from_pretrained(
+        args.model_name_or_path,
+        cache_dir=args.cache_dir,
+    )
+
+    # Prepare transforms
+    train_transforms, val_transforms = prepare_transforms(image_processor)
+
+    # Use partial to bind parameters at module level (avoid set_transform closure issues)
+    train_ds.set_transform(partial(_preprocess_images, img_col=img_name, transforms=train_transforms))
+    val_ds.set_transform(partial(_preprocess_images, img_col=img_name, transforms=val_transforms))
+    test_ds.set_transform(partial(_preprocess_images, img_col=img_name, transforms=val_transforms))
+
+    # Data collator
+    collate_fn = partial(_collate_batch, label_col=label_name)
+
+    # Load base model
+    print("\nLoading base model...")
+    model = AutoModelForImageClassification.from_pretrained(
+        args.model_name_or_path,
+        num_labels=num_classes,
+        label2id=label2id,
+        id2label=id2label,
+        ignore_mismatched_sizes=True,
+        cache_dir=args.cache_dir,
+    )
+
+    # Configure AdaMSS
+    print("\nApplying AdaMSS...")
+    config = AdamssConfig(
+        r=args.adamss_r,
+        num_subspaces=args.adamss_k,
+        subspace_rank=args.adamss_ri,
+        target_modules=["query", "value"],
+        use_asa=args.use_asa,
+        asa_target_subspaces=args.asa_target_subspaces if args.use_asa else None,
+        init_warmup=args.asa_init_warmup if args.use_asa else None,
+        final_warmup=args.asa_final_warmup if args.use_asa else None,
+        mask_interval=args.asa_mask_interval if args.use_asa else None,
+        asa_importance_beta=args.asa_importance_beta if args.use_asa else None,
+        asa_uncertainty_beta=args.asa_uncertainty_beta if args.use_asa else None,
+        asa_schedule_exponent=args.asa_schedule_exponent if args.use_asa else None,
+        modules_to_save=["classifier"],
+    )
+
+    # Apply PEFT
+    model = get_peft_model(model, config)
+    model.print_trainable_parameters()
+
+    # Print detailed parameter breakdown (same logic as exec_adamss_peft.py)
+    print("\n[Detailed Parameter Breakdown]")
+    trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    head_params = sum(p.numel() for n, p in model.named_parameters() if "classifier" in n and p.requires_grad)
+    adamss_params = trainable_params - head_params
+    print(f"Classifier Head Params: {head_params:,}")
+    print(f"AdaMSS Adapter Params:  {adamss_params:,}")
+    print(f"Total Trainable Params: {trainable_params:,}")
+
+    # Setup ASA callback if enabled
+    callbacks = []
+    if args.use_asa:
+        print("\nSetting up ASA callback...")
+        asa_callback = AdamssAsaCallback()
+        callbacks.append(asa_callback)
+
+    # Metrics
+    metric = evaluate.load("accuracy")
+
+    def compute_metrics(eval_pred):
+        preds = eval_pred.predictions
+        # Handle tuple outputs (logits, hidden_states)
+        if isinstance(preds, tuple):
+            preds = preds[0]
+        predictions = preds.argmax(axis=1)
+        return metric.compute(predictions=predictions, references=eval_pred.label_ids)
+
+    # Create TrainingArguments manually (not parsed to avoid conflicts)
+    training_args = TrainingArguments(
+        output_dir=args.output_dir,
+        num_train_epochs=args.num_epochs,
+        per_device_train_batch_size=args.batch_size,
+        per_device_eval_batch_size=args.batch_size,
+        learning_rate=hp["lr"],
+        weight_decay=hp["wd"],
+        warmup_ratio=args.warmup_ratio,
+        eval_strategy="epoch",
+        save_strategy="epoch",
+        load_best_model_at_end=True,
+        metric_for_best_model="accuracy",
+        greater_is_better=True,
+        logging_steps=100,
+        logging_strategy="steps",
+        seed=args.seed,
+        report_to="none",
+        remove_unused_columns=False,  # Required for set_transform compatibility
+        label_names=["labels"],  # Explicitly tell Trainer where labels are (PEFT hides model signature)
+    )
+
+    # Create custom optimizer with different LR for head
+    from torch.optim import AdamW
+
+    optimizer_grouped_parameters = [
+        {
+            "params": [p for n, p in model.named_parameters() if "classifier" in n and p.requires_grad],
+            "lr": hp["head_lr"],
+        },
+        {
+            "params": [p for n, p in model.named_parameters() if "classifier" not in n and p.requires_grad],
+            "lr": hp["lr"],
+        },
+    ]
+    optimizer = AdamW(optimizer_grouped_parameters, weight_decay=hp["wd"])
+
+    # Create trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_ds,
+        eval_dataset=val_ds,
+        data_collator=collate_fn,
+        compute_metrics=compute_metrics,
+        optimizers=(optimizer, None),
+        callbacks=callbacks,
+    )
+
+    # GPU memory monitoring
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+        torch.cuda.reset_peak_memory_stats()
+        print("\n[GPU Memory - Before Training]")
+        print(f"Allocated: {torch.cuda.memory_allocated() / 1024**3:.2f} GB")
+        print(f"Reserved: {torch.cuda.memory_reserved() / 1024**3:.2f} GB")
+
+    # Train
+    print("\n" + "=" * 80)
+    print("Starting training...")
+    print("=" * 80 + "\n")
+
+    train_result = trainer.train()
+
+    # GPU memory stats
+    if torch.cuda.is_available():
+        print("\n[GPU Memory - Peak During Training]")
+        print(f"Peak Allocated: {torch.cuda.max_memory_allocated() / 1024**3:.2f} GB")
+        print(f"Peak Reserved: {torch.cuda.max_memory_reserved() / 1024**3:.2f} GB")
+
+    # Print best metric
+    if trainer.state.best_metric is not None:
+        print("\n[Best Model Info]")
+        print(f"Best accuracy: {trainer.state.best_metric:.4f}")
+
+    # Evaluate on test set
+    print("\n" + "=" * 80)
+    print("Evaluating on test set...")
+    print("=" * 80 + "\n")
+
+    test_metrics = trainer.evaluate(test_ds, metric_key_prefix="test")
+    print(f"\nTest Accuracy: {test_metrics['test_accuracy']:.4f}")
+
+    # Save model
+    trainer.save_model()
+    print(f"\nModel saved to {training_args.output_dir}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/adamss_finetuning/test_adamss_quick.py b/examples/adamss_finetuning/test_adamss_quick.py
new file mode 100644
index 0000000..7011906
--- /dev/null
+++ b/examples/adamss_finetuning/test_adamss_quick.py
@@ -0,0 +1,176 @@
+"""
+Quick test for AdaMSS example - runs 1 epoch on small subset
+"""
+
+import sys
+
+
+sys.path.insert(0, "/Users/onelong/Documents/WorkSpace/CodeSpace/AdaMSS-main/peft-main/src")
+
+import evaluate
+import torch
+from datasets import load_dataset
+from torchvision.transforms import (
+    CenterCrop,
+    Compose,
+    Normalize,
+    RandomHorizontalFlip,
+    RandomResizedCrop,
+    Resize,
+    ToTensor,
+)
+from transformers import AutoImageProcessor, AutoModelForImageClassification, Trainer, TrainingArguments
+
+from peft import AdaMSSConfig, ASACallback, get_peft_model
+
+
+print("=" * 80)
+print("🧪 AdaMSS Quick Test")
+print("=" * 80)
+
+# Load small subset
+print("\n📦 Loading CIFAR-10 (small subset for testing)...")
+dataset = load_dataset("cifar10")
+train_val = dataset["train"].train_test_split(test_size=0.1, seed=42)
+train_ds = train_val["train"].select(range(100))  # Only 100 samples
+val_ds = train_val["test"].select(range(50))
+
+print(f"✅ Dataset: {len(train_ds)} train, {len(val_ds)} val")
+
+# Prepare data
+image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224-in21k")
+normalize = Normalize(mean=image_processor.image_mean, std=image_processor.image_std)
+
+train_transforms = Compose(
+    [
+        RandomResizedCrop(image_processor.size["height"]),
+        RandomHorizontalFlip(),
+        ToTensor(),
+        normalize,
+    ]
+)
+
+val_transforms = Compose(
+    [
+        Resize(image_processor.size["height"]),
+        CenterCrop(image_processor.size["height"]),
+        ToTensor(),
+        normalize,
+    ]
+)
+
+
+def preprocess_train(examples):
+    examples["pixel_values"] = [train_transforms(img.convert("RGB")) for img in examples["img"]]
+    return examples
+
+
+def preprocess_val(examples):
+    examples["pixel_values"] = [val_transforms(img.convert("RGB")) for img in examples["img"]]
+    return examples
+
+
+train_ds.set_transform(preprocess_train)
+val_ds.set_transform(preprocess_val)
+
+
+def collate_fn(examples):
+    pixel_values = torch.stack([example["pixel_values"] for example in examples])
+    labels = torch.tensor([example["label"] for example in examples])
+    return {"pixel_values": pixel_values, "labels": labels}
+
+
+# Load model
+print("\n🤖 Loading ViT model...")
+model = AutoModelForImageClassification.from_pretrained(
+    "google/vit-base-patch16-224-in21k",
+    num_labels=10,
+    ignore_mismatched_sizes=True,
+)
+
+# Configure AdaMSS
+print("\n⚙️  Applying AdaMSS...")
+config = AdaMSSConfig(
+    r=100,
+    num_subspaces=10,
+    subspace_rank=3,
+    target_modules=["query", "value"],
+    use_asa=True,
+    target_kk=5,
+    modules_to_save=["classifier"],
+)
+
+model = get_peft_model(model, config)
+print("\n📊 Parameter statistics:")
+model.print_trainable_parameters()
+
+# Setup ASA callback
+print("\n🔥 Setting up ASA callback...")
+asa_callback = ASACallback(
+    target_kk=5,
+    init_warmup=5,
+    final_warmup=20,
+    mask_interval=10,
+)
+
+# Metrics
+metric = evaluate.load("accuracy")
+
+
+def compute_metrics(eval_pred):
+    predictions = eval_pred.predictions.argmax(axis=1)
+    return metric.compute(predictions=predictions, references=eval_pred.label_ids)
+
+
+# Training arguments
+training_args = TrainingArguments(
+    output_dir="./test_adamss_output",
+    num_train_epochs=1,
+    per_device_train_batch_size=8,
+    per_device_eval_batch_size=8,
+    learning_rate=0.01,
+    weight_decay=0.0005,
+    eval_strategy="epoch",
+    save_strategy="no",
+    logging_steps=10,
+    remove_unused_columns=False,
+    label_names=["labels"],  # Explicitly tell Trainer where labels are (PEFT hides model signature)
+    report_to="none",
+)
+
+# Create trainer
+trainer = Trainer(
+    model=model,
+    args=training_args,
+    train_dataset=train_ds,
+    eval_dataset=val_ds,
+    data_collator=collate_fn,
+    compute_metrics=compute_metrics,
+    callbacks=[asa_callback],
+)
+
+# Train
+print("\n" + "=" * 80)
+print("🚀 Starting training (1 epoch on 100 samples)...")
+print("=" * 80 + "\n")
+
+try:
+    trainer.train()
+    print("\n✅ Training completed successfully!")
+
+    # Evaluate
+    metrics = trainer.evaluate()
+    print(f"\n📊 Validation Accuracy: {metrics['eval_accuracy']:.2%}")
+
+    print("\n" + "=" * 80)
+    print("✅ Test PASSED - AdaMSS example works correctly!")
+    print("=" * 80)
+
+except Exception as e:
+    print("\n" + "=" * 80)
+    print(f"❌ Test FAILED: {e}")
+    print("=" * 80)
+    import traceback
+
+    traceback.print_exc()
+    sys.exit(1)
diff --git a/examples/alora_finetuning/README.md b/examples/alora_finetuning/README.md
new file mode 100644
index 0000000..0a6a4ac
--- /dev/null
+++ b/examples/alora_finetuning/README.md
@@ -0,0 +1,76 @@
+# Activated LoRA (aLoRA)
+
+## Introduction
+Activated LoRA (aLoRA) is an adapter that selectively activates its weights only after a given invocation sequence, ensuring that hidden states match the base model prior to this point. This allows reusing the base model KVs (stored in the KV cache) for tokens before the invocation,
+enabling much faster real-world inference (e.g. vLLM) when switching between generation with the base model and generation with adapters.
+See the [paper](https://huggingface.co/papers/2504.12397) for more details.
+
+## Quick start (shown for Mistral 7B)
+```python
+import torch
+from peft import LoraConfig, get_peft_model
+from transformers import AutoTokenizer, AutoModelForCausalLM, Trainer, DataCollatorForLanguageModeling
+from datasets import load_dataset
+
+model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-Instruct-v0.3", device_map="auto")
+tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.3")
+dataset = load_dataset("Lots-of-LoRAs/task1660_super_glue_question_generation", split="train")
+
+invocation_string = "[/INST]" # End of user turn in Mistral chat template
+invocation_tokens = tokenizer.encode(invocation_string, add_special_tokens=False)
+
+lora_config = LoraConfig(
+    task_type="CAUSAL_LM",
+    alora_invocation_tokens=invocation_tokens,
+    r=32,
+    target_modules=["q_proj", "k_proj", "v_proj"],
+)
+
+peft_model = get_peft_model(model, lora_config)
+data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)
+trainer = Trainer(
+    model=peft_model,
+    train_dataset=dataset,
+    dataset_text_field="text",
+    max_length=2048,
+    tokenizer=tokenizer,
+    data_collator=data_collator,
+)
+trainer.train()
+peft_model.save_pretrained("alora-mistral-7b")
+```
+
+### Use the training example script directly
+Pass the invocation string with `--invocation_string` when running the training example
+script. For Mistral 7B, do:
+```bash
+python examples/alora_finetuning/alora_finetuning.py --base_model mistralai/Mistral-7B-Instruct-v0.3 --data_path Lots-of-LoRAs/task1660_super_glue_question_generation --invocation_string "[/INST]"
+```
+and similarly for Llama-3.2-3B-Instruct:
+```bash
+python examples/alora_finetuning/alora_finetuning.py --base_model meta-llama/Llama-3.2-3B-Instruct --data_path Lots-of-LoRAs/task1660_super_glue_question_generation --invocation_string "<|start_header_id|>assistant<|end_header_id|>"
+```
+
+### Full example of the script
+```bash
+python alora_finetuning.py \
+    --base_model "PATH_TO_MODEL" \
+    --data_path "PATH_TO_DATASET" \
+    --output_dir "PATH_TO_OUTPUT_DIR" \
+    --batch_size 1 \
+    --num_epochs 3 \
+    --learning_rate 3e-4 \
+    --cutoff_len 512 \
+    --val_set_size 500 \
+    --invocation_string "[/INST]" \
+    --quantize \
+    --eval_step 10 \
+    --save_step 100 \
+    --device "auto" \
+    --lora_r 32 \
+    --lora_alpha 32 \
+    --lora_dropout 0.05 \
+    --lora_target_modules "q_proj,k_proj,v_proj,o_proj,gate_proj,up_proj,down_proj" \
+    --hub_model_id "YOUR_HF_REPO" \
+    --push_to_hub
+```
diff --git a/examples/alora_finetuning/alora_finetuning.py b/examples/alora_finetuning/alora_finetuning.py
new file mode 100644
index 0000000..1bc1345
--- /dev/null
+++ b/examples/alora_finetuning/alora_finetuning.py
@@ -0,0 +1,259 @@
+import os
+
+import torch
+from datasets import load_dataset
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    BitsAndBytesConfig,
+    DataCollatorForLanguageModeling,
+    Trainer,
+    TrainingArguments,
+)
+
+from peft import LoraConfig, PeftModel, get_peft_model, prepare_model_for_kbit_training
+
+
+def train_model(
+    base_model: str,
+    data_path: str,
+    output_dir: str,
+    batch_size: int,
+    num_epochs: int,
+    learning_rate: float,
+    cutoff_len: int,
+    val_set_size: int,
+    invocation_string: str,
+    quantize: bool,
+    eval_step: int,
+    save_step: int,
+    device: str,
+    lora_r: int,
+    lora_alpha: int,
+    lora_dropout: float,
+    lora_target_modules: str,
+    hub_model_id: str,
+    push_to_hub: bool,
+):
+    os.environ["TOKENIZERS_PARALLELISM"] = "false"
+    hf_token = os.getenv("HF_TOKEN")
+
+    if device == "auto":
+        device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+    else:
+        device = torch.device(device)
+    print(f"Using device: {device}")
+
+    tokenizer = AutoTokenizer.from_pretrained(base_model, token=hf_token)
+    tokenizer.pad_token = tokenizer.unk_token
+    invocation_tokens = tokenizer.encode(invocation_string, add_special_tokens=False)
+
+    if quantize:
+        if (torch.cuda.is_available() and torch.cuda.is_bf16_supported()) or torch.xpu.is_available():
+            bnb_4bit_compute_dtype = torch.bfloat16
+        else:
+            bnb_4bit_compute_dtype = torch.float16
+        model = AutoModelForCausalLM.from_pretrained(
+            base_model,
+            token=hf_token,
+            quantization_config=BitsAndBytesConfig(
+                load_in_4bit=True,
+                bnb_4bit_compute_dtype=bnb_4bit_compute_dtype,
+                bnb_4bit_use_double_quant=True,
+                bnb_4bit_quant_type="nf4",
+            ),
+        )
+        model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True)
+    else:
+        model = AutoModelForCausalLM.from_pretrained(base_model, token=hf_token)
+
+    lora_config = LoraConfig(
+        task_type="CAUSAL_LM",
+        alora_invocation_tokens=invocation_tokens,
+        r=lora_r,
+        lora_alpha=lora_alpha,
+        target_modules=(lora_target_modules.split(",") if lora_target_modules else ["q_proj", "k_proj", "v_proj"]),
+        lora_dropout=lora_dropout,
+        bias="none",
+    )
+
+    model = get_peft_model(model, lora_config)
+
+    model.to(device)
+    tokenizer.pad_token = tokenizer.eos_token
+
+    dataset = load_dataset(data_path)
+
+    def tokenize_function(examples):
+        formatted_texts = [
+            tokenizer.apply_chat_template(
+                [
+                    {"role": "user", "content": user_msg},
+                    {"role": "assistant", "content": assistant_msg},
+                ],
+                tokenize=False,  # get plain text first
+                add_generation_prompt=False,
+            )
+            for user_msg, assistant_msg in zip(examples["input"], examples["output"])
+        ]
+
+        # 2) Tokenize those texts
+        model_inputs = tokenizer(
+            formatted_texts,
+            padding="max_length",
+            truncation=True,
+            max_length=cutoff_len,
+        )
+
+        labels = []
+        for ids in model_inputs["input_ids"]:
+            labels.append([(token_id if token_id != tokenizer.pad_token_id else -100) for token_id in ids])
+        model_inputs["labels"] = labels
+
+        return model_inputs
+
+    # Tokenize the dataset and prepare for training
+    tokenized_datasets = dataset.map(tokenize_function, batched=True, remove_columns=dataset["train"].column_names)
+
+    # Data collator to dynamically pad the batched examples
+    data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)
+
+    training_args = TrainingArguments(
+        output_dir=output_dir,
+        num_train_epochs=num_epochs,
+        per_device_train_batch_size=batch_size,
+        per_device_eval_batch_size=batch_size,
+        warmup_steps=100,
+        weight_decay=0.01,
+        logging_dir="./logs",
+        logging_steps=eval_step,
+        save_steps=save_step,
+        save_total_limit=2,
+        push_to_hub=push_to_hub,
+        hub_model_id=hub_model_id,
+        gradient_accumulation_steps=16,
+        fp16=True,
+        learning_rate=learning_rate,
+        hub_token=hf_token,
+    )
+
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+    elif torch.xpu.is_available():
+        torch.xpu.empty_cache()
+
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=tokenized_datasets["train"],
+        eval_dataset=tokenized_datasets["test"],
+        data_collator=data_collator,
+    )
+
+    trainer.train()
+
+    if push_to_hub:
+        trainer.push_to_hub(commit_message="Fine-tuned model")
+
+    model.save_pretrained(output_dir)
+    tokenizer.save_pretrained(output_dir)
+
+
+def model_inference(model_path: str, adapter_path: str, prompt: str | None = None, data_path: str | None = None):
+    """
+    Simple inference with the tuned aLoRA adapter. Optionally (reuse_cache = True) demonstrates
+    that the aLoRA adapter can (but does not need to) use KV cache created by the base model,
+    perhaps during a prior generation turn.
+
+    Purely for demonstration purposes. See the [paper](https://huggingface.co/papers/2504.12397)
+    for realistic multiturn cache reuse examples.
+    """
+    if prompt is None:
+        # Use first row of test data
+        dataset = load_dataset(data_path)
+        prompt = dataset["test"][0]["input"]
+    tokenizer = AutoTokenizer.from_pretrained(model_path)
+    base_model = AutoModelForCausalLM.from_pretrained(model_path)
+    alora_model = PeftModel.from_pretrained(base_model, adapter_path)
+    chat = [{"role": "user", "content": prompt}]
+    text = tokenizer.apply_chat_template(chat, tokenize=False, add_generation_prompt=True)
+    inputs = tokenizer(text, return_tensors="pt").to(base_model.device)
+
+    # Generate answer with adapter
+    output_dict = alora_model.generate(**inputs, return_dict_in_generate=True, max_new_tokens=20)
+    alora_outputs = output_dict.sequences
+
+    # Print results
+    print(f"Prompt: {text}")
+    response = tokenizer.decode(alora_outputs[0][inputs["input_ids"].shape[1] :], skip_special_tokens=True)
+    print(f"Trained adapter response: {response}")
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Fine-tune Mistral with Activated LoRA")
+    parser.add_argument(
+        "--base_model", type=str, default="mistralai/Mistral-7B-Instruct-v0.3", help="Base model path or name"
+    )
+    parser.add_argument(
+        "--data_path",
+        type=str,
+        default="Lots-of-LoRAs/task1660_super_glue_question_generation",
+        help="Dataset path or name",
+    )
+    parser.add_argument(
+        "--output_dir", type=str, default="path/to/output", help="Output directory for the fine-tuned model"
+    )
+    parser.add_argument("--batch_size", type=int, default=2, help="Batch size")
+    parser.add_argument("--num_epochs", type=int, default=1, help="Number of training epochs")
+    parser.add_argument("--learning_rate", type=float, default=1e-4, help="Learning rate")
+    parser.add_argument("--cutoff_len", type=int, default=2048, help="Cutoff length for tokenization")
+    parser.add_argument("--val_set_size", type=int, default=500, help="Validation set size")
+    parser.add_argument(
+        "--invocation_string",
+        type=str,
+        default="[/INST]",
+        help="String that activates the aLoRA adapter. Model dependent.",
+    )
+    parser.add_argument("--quantize", action="store_true", help="Use quantization")
+    parser.add_argument("--eval_step", type=int, default=10, help="Evaluation step interval")
+    parser.add_argument("--save_step", type=int, default=100, help="Save step interval")
+    parser.add_argument("--device", type=str, default="auto", help="Device to use for training")
+    parser.add_argument("--lora_r", type=int, default=32, help="LoRA rank")
+    parser.add_argument("--lora_alpha", type=int, default=32, help="LoRA alpha")
+    parser.add_argument("--lora_dropout", type=float, default=0.05, help="LoRA dropout rate")
+    parser.add_argument(
+        "--lora_target_modules", type=str, default=None, help="Comma-separated list of target modules for LoRA"
+    )
+    parser.add_argument(
+        "--hub_model_id",
+        type=str,
+        default="path/to/repo",
+        help="Repository name to push the model on the Hugging Face Hub",
+    )
+    parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to Hugging Face Hub")
+    args = parser.parse_args()
+    train_model(
+        base_model=args.base_model,
+        data_path=args.data_path,
+        output_dir=args.output_dir,
+        batch_size=args.batch_size,
+        num_epochs=args.num_epochs,
+        learning_rate=args.learning_rate,
+        cutoff_len=args.cutoff_len,
+        val_set_size=args.val_set_size,
+        invocation_string=args.invocation_string,
+        quantize=args.quantize,
+        eval_step=args.eval_step,
+        save_step=args.save_step,
+        device=args.device,
+        lora_r=args.lora_r,
+        lora_alpha=args.lora_alpha,
+        lora_dropout=args.lora_dropout,
+        lora_target_modules=args.lora_target_modules,
+        hub_model_id=args.hub_model_id,
+        push_to_hub=args.push_to_hub,
+    )
+    print("Model trained. Running test inference.")
+    model_inference(model_path=args.base_model, adapter_path=args.output_dir, data_path=args.data_path)
diff --git a/examples/arrow_multitask/arrow_phi3_mini.py b/examples/arrow_multitask/arrow_phi3_mini.py
new file mode 100644
index 0000000..13f7fca
--- /dev/null
+++ b/examples/arrow_multitask/arrow_phi3_mini.py
@@ -0,0 +1,383 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+"""
+This script provides a simple evaluation pipeline for multiple-choice reasoning datasets
+(e.g., BoolQ, HellaSwag, ARC, OpenBookQA, Winogrande) with different composition strategies.
+
+Usage examples:
+    python arrow_phi3_mini.py --strategy base --ds_name arc-challenge
+    python arrow_phi3_mini.py --strategy arrow --ds_name boolq
+    python arrow_phi3_mini.py --strategy gks --ds_name hswag
+
+Key features:
+- Supports three strategies:
+    • "base"   → Evaluate the quantized base model directly
+    • "arrow"  → Use Arrow modular routing with task-specific adapters
+    • "gks"    → Use Arrow + GenKnowSub (subtracting general-domain knowledge)
+- Loads evaluation datasets from the Hugging Face Hub
+- Implements a batched evaluation loop that computes per-option likelihoods and selects
+  the answer with the lowest average loss
+- Reports simple accuracy
+
+Implementation details:
+- The base model is quantized to 4-bit using `BitsAndBytesConfig` (nf4, bf16 compute).
+- For Arrow and GKS, task-specific adapters are loaded from the Hugging Face Hub:
+    TahaBa/phi3-mini-clustered-flan/ts_expert_i
+- Task-specific adapters were trained on 10 clusters of FLAN tasks.
+- The clusters were created using Model-Based Clustering (MBC):
+    1. Train a LoRA adapter for each individual task.
+    2. Apply k-means clustering to group tasks based on these adapters.
+    3. Train a LoRA adapter for each resulting cluster.
+For more details, see the Arrow paper: https://huggingface.co/papers/2405.11157
+
+- For GKS, general adapters are loaded from:
+    TahaBa/phi3-mini-general-adapters/...
+- These adapters were trained on English, French, and German Wikipedia data
+  using a causal language modeling objective with (507-token context → 5-token completion) pairs.
+- This setup encodes general knowledge into the LoRA space, which can then be
+  subtracted from task-specific adapters during inference to isolate and purify them.
+For more details, see the GenKnowSub paper: https://huggingface.co/papers/2505.10939
+
+- `evaluate_on_multi_choice_batched` handles tokenization, masking context tokens,
+  and computing per-choice log-likelihoods for fair comparison.
+- Accuracy is printed at the end for the selected dataset.
+
+This script is mainly meant for demonstration purposes and lightweight evaluation,
+not full-scale benchmarking (batch size / max length can be tuned).
+
+=======================================================================================
+
+Results (evaluated with microsoft/Phi-3-mini-4k-instruct, 4-bit quantization):
+
+| Dataset      | Base Acc. | Arrow Acc. | Arrow+GKS Acc. |
+|--------------|-----------|------------|----------------|
+| ARC-Challenge|   0.4515  |   0.5418   |     0.5585     |
+| ARC-Easy     |   0.6894  |   0.8404   |     0.8473     |
+| Winogrande   |   0.5769  |   0.6550   |     0.6724     |
+| BoolQ        |   0.8146  |   0.8030   |     0.8247     |
+| OpenBookQA   |   0.43    |   0.448    |     0.472      |
+| HellaSwag    |   0.7318  |   0.7150   |     0.7376     |
+
+Observations:
+- Arrow generally improves over the base model by routing tokens to the most relevant task adapters.
+- Applying GKS (general knowledge subtraction) consistently gives further gains compared to Arrow and Base.
+
+These numbers are not meant as leaderboard results, but as a sanity check
+to verify that the implementation works as expected and demonstrates
+the benefits of Arrow and GenKnowSub.
+"""
+
+import argparse
+import random
+
+import numpy as np
+import torch
+from datasets import load_dataset
+from sklearn.metrics import accuracy_score
+from tqdm import tqdm
+from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
+
+from peft import ArrowConfig, create_arrow_model
+
+
+MODEL_NAME = "microsoft/Phi-3-mini-4k-instruct"
+MODEL_MAX_LEN = 2048
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Training script with strategy selection")
+
+    parser.add_argument(
+        "--strategy",
+        type=str,
+        choices=["base", "arrow", "gks"],
+        default="base",
+        help="Training strategy to use: base, arrow, or gks",
+    )
+    parser.add_argument(
+        "--ds_name",
+        type=str,
+        choices=["boolq", "hswag", "arc-easy", "arc-challenge", "oqa", "wg"],
+        default="arc-challenge",
+        help="Dataset to use: boolq, hswag, arc-easy, arc-challenge, oqa, wg",
+    )
+
+    return parser.parse_args()
+
+
+def read_test_dataset(ds_name):
+    if ds_name == "boolq":
+        ds = load_dataset("google/boolq", split="validation", trust_remote_code=True)
+    elif ds_name == "hswag":
+        ds = load_dataset("Rowan/hellaswag", split="validation", trust_remote_code=True)
+    elif ds_name == "arc-challenge":
+        ds = load_dataset("allenai/ai2_arc", "ARC-Challenge", split="validation", trust_remote_code=True)
+    elif ds_name == "arc-easy":
+        ds = load_dataset("allenai/ai2_arc", "ARC-Easy", split="validation", trust_remote_code=True)
+    elif ds_name == "oqa":
+        ds = load_dataset("allenai/openbookqa", split="validation", trust_remote_code=True)
+    elif ds_name == "wg":
+        ds = load_dataset("allenai/winogrande", "winogrande_xl", split="validation", trust_remote_code=True)
+    else:
+        raise f"Dataset {ds_name} is not supported yet."
+
+    return ds
+
+
+def extract_input_content(ds_name, row):
+    if ds_name == "boolq":
+        return f"[passage]{row['passage']}[question]{row['question']}"
+    if ds_name == "hswag":
+        return row["ctx"]
+    if (ds_name == "arc-challenge") or (ds_name == "arc-easy"):
+        return row["question"]
+    if ds_name == "oqa":
+        return row["question_stem"]
+    if ds_name == "wg":
+        return row["sentence"]
+
+
+def create_multi_choice_options(row, ds_name):
+    options_texts = []
+    content = extract_input_content(ds_name, row)
+    if ds_name == "boolq":
+        choices = ["true", "false"]
+    if ds_name == "hswag":
+        choices = row["endings"]
+    if (ds_name == "arc-challenge") or (ds_name == "arc-easy"):
+        choices = row["choices"]["text"]
+    if ds_name == "wg":
+        choices = [row["option1"], row["option2"]]
+    if ds_name == "oqa":
+        choices = row["choices"]["text"]
+
+    for choice in choices:
+        options_texts.append(f"<|user|>\n{content}<|end|>\n<|assistant|>{choice}<|end|>\n")
+
+    return options_texts
+
+
+def extract_multi_choice_target_index(row, ds_name):
+    if ds_name == "boolq":
+        return 0 if row["answer"] is True else 1
+    if ds_name == "hswag":
+        return int(row["label"])
+    if (ds_name == "arc-challenge") or (ds_name == "arc-easy"):
+        return row["choices"]["label"].index(row["answerKey"])
+    if ds_name == "wg":
+        return int(row["answer"]) - 1
+    if ds_name == "oqa":
+        return row["choices"]["label"].index(row["answerKey"])
+
+
+def set_seed(seed: int):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+    elif hasattr(torch, "xpu") and torch.xpu.is_available():
+        torch.xpu.manual_seed_all(seed)
+
+
+def compute_loglike_loss(logits, labels, reduction="none"):
+    bs = logits.size(0)
+    vocab_size = logits.size(-1)
+    labels = labels.squeeze(-1)
+    shift_logits = logits[..., :-1, :].contiguous()
+    shift_labels = labels[..., 1:].contiguous()
+
+    # Flatten the tokens
+    loss_fct = torch.nn.CrossEntropyLoss(reduction=reduction)
+    shift_logits = shift_logits.view(-1, vocab_size)
+    shift_labels = shift_labels.view(-1)
+
+    shift_labels = shift_labels.to(shift_logits.device)
+    loss = loss_fct(shift_logits, shift_labels)
+
+    # reshape back
+    if reduction == "none":
+        loss = loss.view((bs, -1))
+        non_zero_loss = (loss != 0).sum(dim=-1)
+        non_zero_loss[non_zero_loss == 0] = 1
+        loss = loss.sum(dim=-1) / non_zero_loss
+
+    return loss.float()  # Convert to float32 before returning
+
+
+def evaluate_on_multi_choice_batched(
+    eval_dataset, model, tokenizer, ds_name, labels, predictions, args, batch_size=32, max_length=512, device="auto"
+):
+    # Local import to mirror your original function
+    model.eval()
+
+    if device == "auto":
+        device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+    else:
+        device = torch.device(device)
+
+    for start in tqdm(
+        range(0, len(eval_dataset), batch_size), total=(len(eval_dataset) + batch_size - 1) // batch_size
+    ):
+        rows = [eval_dataset[i] for i in range(start, min(start + batch_size, len(eval_dataset)))]
+
+        # Build the flattened option texts for this batch
+        all_texts = []
+        options_per_sample = []  # number of options for each sample
+        ctx_lens_per_option = []  # context length replicated per option
+
+        for row in rows:
+            # options: ["<|user|>...<|assistant|>choiceA<|end|>", ...]
+            options = create_multi_choice_options(row, ds_name)
+            options_per_sample.append(len(options))
+
+            # compute context length once per sample (align with your -1 shift)
+            content = extract_input_content(ds_name, row)
+            context_prompt = f"<|user|>\n{content}<|end|>\n<|assistant|>"
+            ctx_len = len(tokenizer.encode(context_prompt)) - 1
+
+            all_texts.extend(options)
+            ctx_lens_per_option.extend([ctx_len] * len(options))
+
+            # collect gold label
+            labels.append(extract_multi_choice_target_index(row, ds_name))
+
+        # Tokenize all options in one go
+        tokenized = tokenizer(
+            all_texts,
+            return_tensors="pt",
+            padding=True,
+            truncation=True,
+            max_length=max_length,
+        )
+        tokenized = {k: v.to(device) for k, v in tokenized.items()}
+
+        # Create masked labels: ignore context and padding
+        masked_labels = tokenized["input_ids"].clone()
+        for i, ctx_len in enumerate(ctx_lens_per_option):
+            masked_labels[i, :ctx_len] = -100
+        masked_labels[tokenized["attention_mask"] == 0] = -100
+
+        with torch.no_grad():
+            logits = model(input_ids=tokenized["input_ids"], attention_mask=tokenized["attention_mask"]).logits
+            # per-sequence losses
+            losses = compute_loglike_loss(logits, masked_labels, reduction="none").detach().cpu()
+
+        # Reduce per sample (argmin across its options)
+        idx = 0
+        for n_opt in options_per_sample:
+            pred = torch.argmin(losses[idx : idx + n_opt]).item()
+            predictions.append(pred)
+            idx += n_opt
+
+    print(
+        f"Accuracy for dataset {args.ds_name} and strategy {args.strategy} is: {accuracy_score(labels, predictions)}"
+    )
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    print(f"Selected strategy: {args.strategy}")
+    print(f"Dataset name: {args.ds_name}")
+
+    # Loading the tokeniser
+    tokenizer = AutoTokenizer.from_pretrained(
+        MODEL_NAME,
+        use_fast=True,
+        padding_side="right",
+        model_max_length=MODEL_MAX_LEN,
+    )
+
+    # Quantisation config
+    bnb_config = BitsAndBytesConfig(
+        load_in_4bit=True,
+        bnb_4bit_quant_type="nf4",
+        bnb_4bit_compute_dtype=torch.bfloat16,
+        bnb_4bit_use_double_quant=False,
+    )
+
+    # Loading the model
+    base_model = AutoModelForCausalLM.from_pretrained(
+        MODEL_NAME,
+        dtype=torch.bfloat16,
+        device_map="auto",
+        quantization_config=bnb_config,
+    )
+
+    # Loading the test dataset
+    test_dataset = read_test_dataset(args.ds_name)
+    print(f"{args.ds_name} is loaded with size: {len(test_dataset)}.")
+
+    labels, predictions = [], []
+    if args.strategy == "base":
+        # Batch-wise inference
+        with torch.no_grad():
+            evaluate_on_multi_choice_batched(
+                test_dataset,
+                base_model,
+                tokenizer,
+                args.ds_name,
+                labels,
+                predictions,
+                args,
+                batch_size=64,  # tune this
+                max_length=512,  # tune if options are long
+                device="auto",
+            )
+    else:
+        general_adapter_paths = []
+        if args.strategy == "gks":
+            arrow_config = ArrowConfig(
+                top_k=3,
+                router_temperature=1.0,
+                use_gks=True,
+            )
+            # General adapter paths from the hub
+            general_adapter_paths = [
+                "TahaBa/phi3-mini-general-adapters/cluster0_batch16_prop1.0_langen/checkpoint-17",
+                "TahaBa/phi3-mini-general-adapters/cluster0_batch16_prop1.0_langfr/checkpoint-35",
+                "TahaBa/phi3-mini-general-adapters/cluster0_batch16_prop1.0_langger/checkpoint-17",
+            ]
+        else:
+            arrow_config = ArrowConfig(
+                top_k=3,
+                router_temperature=1.0,
+            )
+
+        # Task-specific adapter paths from the hub
+        task_specific_adapter_paths = [f"TahaBa/phi3-mini-clustered-flan/ts_expert_{i}" for i in range(10)]
+
+        # Creating the Arrow model
+        model = create_arrow_model(
+            base_model=base_model,
+            task_specific_adapter_paths=task_specific_adapter_paths,
+            general_adapter_paths=general_adapter_paths,
+            arrow_config=arrow_config,
+        )
+
+        # Batch-wise inference
+        with torch.no_grad():
+            evaluate_on_multi_choice_batched(
+                test_dataset,
+                model,
+                tokenizer,
+                args.ds_name,
+                labels,
+                predictions,
+                args,
+                batch_size=32,  # tune this
+                max_length=512,  # tune if options are long
+                device="auto",
+            )
diff --git a/examples/arrow_multitask/requirements.txt b/examples/arrow_multitask/requirements.txt
new file mode 100644
index 0000000..0fb1d2c
--- /dev/null
+++ b/examples/arrow_multitask/requirements.txt
@@ -0,0 +1,8 @@
+torch
+transformers
+accelerate
+datasets
+scikit-learn
+tqdm
+numpy
+bitsandbytes
diff --git a/examples/bdlora_finetuning/README.md b/examples/bdlora_finetuning/README.md
new file mode 100644
index 0000000..f1e4c5d
--- /dev/null
+++ b/examples/bdlora_finetuning/README.md
@@ -0,0 +1,15 @@
+# BD-LoRA Finetuning
+
+Block-Diagonal LoRA (BD-LoRA) is a LoRA variant in which some LoRA factors are constrained to be block-diagonal. 
+This allows faster serving by eliminating communication overheads when running inference on multiple GPU, at the same finetuning performance as vanilla LoRA. 
+
+To get an overview on how to use BD-LoRA, please view the Python notebook at `peft/examples/bdlora_finetuning/bdlora_peft_demo.ipynb`. 
+
+To benefit from inference speed-ups, you need an inference engine that is compatible with BD-LoRA. At the moment, there is an experimental PR at https://github.com/vllm-project/vllm/pull/28136 which allows you to use BD-LoRA in vLLM. If you find this work useful, consider leaving a comment there. 
+
+To install, you can clone the GitHub repository connected to the fork at https://github.com/Conzel/vllm/tree/bdlora-bk. Then, install vLLM following the usual instructions: https://docs.vllm.ai/en/stable/getting_started/installation/. We assume that you have a hardware setup with at least 2 available GPUs. 
+
+This example folder contains 3 scripts:
+- `bdlora_peft_demo.ipynb` Showcases how to instantiate a BD-LoRA model, train it, and save/reload the weights. 
+- `vllm_server.bash` Spins up a BD-LoRA compatible vLLM server. To use it, you need to run the notebook once to create adapters with the correct format. 
+- `chat.py` Can be used to query the vLLM server after it has finished booting up. Usage example: `python3 chat.py --target lora1`.
\ No newline at end of file
diff --git a/examples/bdlora_finetuning/bdlora-performance.png b/examples/bdlora_finetuning/bdlora-performance.png
new file mode 100644
index 0000000..057195a
Binary files /dev/null and b/examples/bdlora_finetuning/bdlora-performance.png differ
diff --git a/examples/bdlora_finetuning/bdlora-sharding.png b/examples/bdlora_finetuning/bdlora-sharding.png
new file mode 100644
index 0000000..2a614d1
Binary files /dev/null and b/examples/bdlora_finetuning/bdlora-sharding.png differ
diff --git a/examples/bdlora_finetuning/bdlora_peft_demo.ipynb b/examples/bdlora_finetuning/bdlora_peft_demo.ipynb
new file mode 100644
index 0000000..f85782c
--- /dev/null
+++ b/examples/bdlora_finetuning/bdlora_peft_demo.ipynb
@@ -0,0 +1,439 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "e2b69494",
+   "metadata": {},
+   "source": [
+    "# Block-Diagonal LoRA for Eliminating Communication Overhead in Tensor Parallel LoRA Serving"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2fb2b221",
+   "metadata": {},
+   "source": [
+    "## Introduction\n",
+    "Block-Diagonal LoRA (BD-LoRA) is a LoRA variant in which some LoRA factors are constrained to be block-diagonal. This allows faster serving by eliminating communication overheads \n",
+    "when running inference on multiple GPUs. Despite the block-diagonal constraint, BD-LoRA is similarly performant to vanilla LoRA at similar parameter counts.\n",
+    "\n",
+    "BD-LoRA is designed to be used with tensor parallelism, which means sharding the weights of a model among multiple GPUs. A popular sharding strategy is the [Megatron Sharding Strategy](https://arxiv.org/abs/1909.08053). For two linear layers $W_1$, $W_2$ that follow each other (for example the up and down projections in a transformer MLP module), we will shard the first layer in a column-parallel way (which requires LoRA B to be block-diagonal) and the second layer in a row-parallel way (which requires LoRA A to be block-diagonal). For the attention module, this can be similarly achieved by taking the Q, K and V projections together as $W_1$ and the out projection as $W_2$, sharding accordingly. This sharding allows a compatible inference engine to distribute each block-diagonal shard over a a different GPU, cutting the need to communicate partial results among GPUs. In the image below, you can see the exact sharding strategy and how this saves computational efforts.\n",
+    "\n",
+    "Paper: https://arxiv.org/html/2510.23346v1\n",
+    "\n",
+    "<div>\n",
+    "<img src=\"bdlora-sharding.png\" width=\"800\"/>\n",
+    "</div>\n",
+    "\n",
+    "### Performance, rank and parameter count\n",
+    "BD-LoRA achieves similar performance to LoRA (see image below, or the `method_comparison` folder in the peft repository root) at the same parameter count. However, as every other factor in BD-LoRA is block-diagonal, a BD-LoRA adapter will have less parameters than a LoRA adapter at the same rank. The performance of BD-LoRA is only competitive when the rank is then increased accordingly. We provide example code for rank-matching at the end of this example notebook.\n",
+    "\n",
+    "<div>\n",
+    "<img src=\"bdlora-performance.png\" width=\"600\"/>\n",
+    "</div>\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "40eea544",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/efs/aconzel/workspace/peft/bdlora-peft/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    }
+   ],
+   "source": [
+    "from peft.tuners import BdLoraConfig, LoraConfig\n",
+    "from peft import get_peft_model\n",
+    "from transformers import Trainer, TrainingArguments, DataCollatorForLanguageModeling, AutoModelForCausalLM, AutoTokenizer\n",
+    "from datasets import load_dataset\n",
+    "import torch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5959e4ab",
+   "metadata": {},
+   "source": [
+    "## Quick Start\n",
+    "To use BD-LoRA, we can follow standard LoRA-training procedures. We only need to change the `LoraConfig` to a `BdLoraConfig` and specify which LoRA should be block-diagonal. \n",
+    "As an example, we will train a LLama-Model in such a way that it can later benefit from inference speed-up as specified in the BD-LoRA paper. However, BD-LoRA can be used with all other models that follow a transformer architecture. \n",
+    "\n",
+    "As explained in the introduction, we want to shard each module (MLP and attention) in an alternating fashion, first column-parallel with LoRA-B block-diagonal, then row-parallel with LoRA-A block-diagonal. Different from standard MLP modules, Llama also uses a gate projection, which we can fuse together with the up-projection.\n",
+    "\n",
+    "Therefore, we want the following block-diagonal factors (following the naming convention from the Llama architecture):\n",
+    "\n",
+    "- LoRA-A Block-Diagonal (Row-parallel sharding): Out (`out_proj`), Down (`down_proj`)\n",
+    "- LoRA-B Block-Diagonal (Column-parallel sharding): QKV (`q_proj, k_proj, v_proj`), Up+Gate (`up_proj, gate_proj`)\n",
+    "\n",
+    "Additionally, we need to know on how many GPUs we want to serve before we start training, as this corresponds to the number of block we will use for each block-diagonal factor. For this experiment, we will use 2 blocks (equivalent to a tensor-parallelism degree of 2). Caveat: For a small model such as Llama 3.2-1B which we are using, one would use a single GPU for serving, and use TP=2 or TP=8 only for larger models, like Llama 3.1-8B or Llama 3.3-70B respectively. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "6180c1f9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_name = \"meta-llama/Llama-3.2-1B\"\n",
+    "model = AutoModelForCausalLM.from_pretrained(model_name)\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "6a50e350",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "trainable params: 44,826,624 || all params: 1,280,641,024 || trainable%: 3.5003\n"
+     ]
+    }
+   ],
+   "source": [
+    "target_modules=[\"q_proj\", \"v_proj\", \"k_proj\", \"up_proj\", \"gate_proj\", \"o_proj\", \"down_proj\"]\n",
+    "# Set this equal to the number of GPUs you want to serve the model with later\n",
+    "nblocks = 2\n",
+    "\n",
+    "bdlora_config = BdLoraConfig(\n",
+    "      target_modules_bd_a=[\"o_proj\", \"down_proj\"],\n",
+    "      target_modules_bd_b=[\"q_proj\", \"v_proj\", \"k_proj\", \"up_proj\", \"gate_proj\"],\n",
+    "      nblocks=nblocks\n",
+    ")\n",
+    "\n",
+    "config = LoraConfig(\n",
+    "    r=96,\n",
+    "    # adjust target modules and the ...target_modules_bd attributes according to model architecture (for example renaming)\n",
+    "    target_modules=target_modules,\n",
+    "    use_bdlora=bdlora_config,\n",
+    "    lora_bias=False\n",
+    ")\n",
+    "\n",
+    "peft_model = get_peft_model(model, config)\n",
+    "peft_model.print_trainable_parameters()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c1facfea",
+   "metadata": {},
+   "source": [
+    "## Training\n",
+    "We train the model for 10 steps, this training block is just intended to showcase how BD-LoRA integrates into other huggingface tools."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "64e4681b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "    <div>\n",
+       "      \n",
+       "      <progress value='10' max='10' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
+       "      [10/10 00:31, Epoch 10/10]\n",
+       "    </div>\n",
+       "    <table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       " <tr style=\"text-align: left;\">\n",
+       "      <th>Step</th>\n",
+       "      <th>Training Loss</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <td>1</td>\n",
+       "      <td>3.137500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>2</td>\n",
+       "      <td>3.137500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>3</td>\n",
+       "      <td>3.126700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>4</td>\n",
+       "      <td>3.104900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>5</td>\n",
+       "      <td>3.085900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>6</td>\n",
+       "      <td>3.069800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>7</td>\n",
+       "      <td>3.056500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>8</td>\n",
+       "      <td>3.046100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>9</td>\n",
+       "      <td>3.038300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>10</td>\n",
+       "      <td>3.033100</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table><p>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "TrainOutput(global_step=10, training_loss=3.0836387634277345, metrics={'train_runtime': 38.346, 'train_samples_per_second': 66.761, 'train_steps_per_second': 0.261, 'total_flos': 1954507653120000.0, 'train_loss': 3.0836387634277345, 'epoch': 10.0})"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dataset = load_dataset(\"imdb\", split=\"train[:1%]\")\n",
+    "\n",
+    "tokenizer.pad_token = tokenizer.eos_token\n",
+    "def tokenize(batch):\n",
+    "    return tokenizer(batch[\"text\"], truncation=True, padding=\"max_length\", max_length=128)\n",
+    "\n",
+    "dataset = dataset.map(tokenize, batched=True, remove_columns=[\"text\"])\n",
+    "training_args = TrainingArguments(\n",
+    "    output_dir=\"./results\",\n",
+    "    per_device_train_batch_size=8,\n",
+    "    gradient_accumulation_steps=4,\n",
+    "    warmup_steps=2,\n",
+    "    max_steps=10,\n",
+    "    learning_rate=2e-4,\n",
+    "    logging_steps=1,\n",
+    ")\n",
+    "\n",
+    "trainer = Trainer(\n",
+    "    model=peft_model,\n",
+    "    args=training_args,\n",
+    "    train_dataset=dataset,\n",
+    "    data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),\n",
+    ")\n",
+    "\n",
+    "peft_model.config.use_cache = False\n",
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3ac31a38",
+   "metadata": {},
+   "source": [
+    "## Saving Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "28f49ee4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "peft_model.save_pretrained(\"example_bd_lora_adapter\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1a3d6fab",
+   "metadata": {},
+   "source": [
+    "## Example Output"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "20c36df8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Setting `pad_token_id` to `eos_token_id`:128001 for open-end generation.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The Batman Trilogy by Christopher Nolan\n",
+      "The Batman Trilogy by Christopher Nolan\n",
+      "The Batman Trilogy by Christopher Nolan\n",
+      "The Batman Trilogy by Christopher Nolan\n",
+      "The Batman Trilogy by Christopher Nolan\n",
+      "The Batman Trilogy by Christopher Nolan\n",
+      "The Batman Trilogy by Christopher Nolan\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "text = \"The Batman Trilogy by Christopher Nolan\"\n",
+    "inputs = tokenizer(text, return_tensors=\"pt\").to(model.device)  \n",
+    "\n",
+    "outputs = peft_model.generate(**inputs, max_length=50)\n",
+    "decoded = tokenizer.decode(outputs[0], skip_special_tokens=True)\n",
+    "print(decoded)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "711eb30d",
+   "metadata": {},
+   "source": [
+    "## Investigating the shapes of LoRA Adapters\n",
+    "We can check out the adapter shapes to see if they follow the sharding patterns that we have discussed. To make the implementation more memory efficient, \n",
+    "the block-diagonal matrices are not saved in a block-diagonal manner, but the blocks are stacked along the non-rank dimensions. \n",
+    "\n",
+    "For example, if a layer is column sharded, such as the q-proj in Llama, then the LoRA-B factor is block-diagonal. Assume that the q-proj has layer weights (out_features, in_features), \n",
+    "then LoRA-A will have shape (rank, in_features), and LoRA-B will have shape (out_features, rank / TP), which corresponds to TP blocks of shape (out_features/TP, rank/TP) each. This can be checked by investigating the weight shapes:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "3660c4de",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Base layer has shape:    [512, 2048]\n",
+      "LoRA-A (vanilla):        [96,  2048]\n",
+      "LoRA-B (block-diagonal): [512, 48   ]\n"
+     ]
+    }
+   ],
+   "source": [
+    "shape_base = list(peft_model.state_dict()['base_model.model.model.layers.0.self_attn.v_proj.base_layer.weight'].shape)\n",
+    "shape_a = list(peft_model.state_dict()['base_model.model.model.layers.0.self_attn.v_proj.lora_A.default.weight'].shape)\n",
+    "shape_b = list(peft_model.state_dict()['base_model.model.model.layers.0.self_attn.v_proj.lora_B.default.weight'].shape)\n",
+    "print(f\"Base layer has shape:    [{shape_base[0]}, {shape_base[1]}]\\nLoRA-A (vanilla):        [{shape_a[0]},  {shape_a[1]}]\\nLoRA-B (block-diagonal): [{shape_b[0]}, {shape_b[1]}   ]\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d95118af",
+   "metadata": {},
+   "source": [
+    "## Matching the rank\n",
+    "Assuming we want to achieve the same performance of a LoRA adapter of a given rank, at which rank would we have to train BD-LoRA? We can find this out by matching the number of trainable parameters. A simple iteration over the ranks of the BD-LoRA adapter is sufficient to do that:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "cd4fc45a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "BD-LoRA rank to match vanilla LoRA performance at rank 64: 96 at 45088768 vanilla LoRA params and 44826624 BD-LoRA params.\n"
+     ]
+    }
+   ],
+   "source": [
+    "def rank_to_params(r: int, bd_lora: bool, nblocks: int):\n",
+    "    model = AutoModelForCausalLM.from_pretrained(model_name)\n",
+    "    if bd_lora:\n",
+    "        config = LoraConfig(\n",
+    "            r=r,\n",
+    "            target_modules=target_modules,\n",
+    "            use_bdlora=bdlora_config,\n",
+    "            lora_bias=False\n",
+    "        )\n",
+    "    else:\n",
+    "        config = LoraConfig(\n",
+    "            r=r,\n",
+    "            # If you use a model different from Llama, change the settings below\n",
+    "            target_modules=target_modules,\n",
+    "            lora_bias=False\n",
+    "        )\n",
+    "\n",
+    "\n",
+    "    peft_model = get_peft_model(model, config)\n",
+    "    return peft_model.get_nb_trainable_parameters()[0]\n",
+    "\n",
+    "r_orig = 64\n",
+    "r = r_orig\n",
+    "lora_nparams = rank_to_params(r, False, nblocks)\n",
+    "bdlora_nparams = 0\n",
+    "while bdlora_nparams < lora_nparams:\n",
+    "    r += nblocks\n",
+    "    bdlora_nparams = rank_to_params(r, True, nblocks)\n",
+    "# subtract nblocks again to be just under the parameter count of vanilla LoRA, following the original papers methodology\n",
+    "print(f\"BD-LoRA rank to match vanilla LoRA performance at rank {r_orig}: {r-nblocks} at {lora_nparams} vanilla LoRA params and {rank_to_params(r-nblocks, True, nblocks)} BD-LoRA params.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d27b9545",
+   "metadata": {},
+   "source": [
+    "# Integration with vLLM\n",
+    "Currently, vLLM has an experimental PR that allows you to use it with BD-LoRA. Clone the github repository and check out the commit of \n",
+    "the pull request at https://github.com/vllm-project/vllm/pull/28136#. Then, install vLLM following the usual instructions: https://docs.vllm.ai/en/stable/getting_started/installation/. We assume that you have a hardware setup with at least 2 available GPUs. \n",
+    "\n",
+    "We have included a script that starts a vLLM server with two BD-LoRA modules at `vllm_server.bash` (you might have to kill this jupyter server beforehand, as it is likely already using your GPU resources).\n",
+    "Once the server has started, you can query it via `python3 chat.py \"Please write your message here.\" --target lora1`."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "bdlora-peft",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/bdlora_finetuning/chat.py b/examples/bdlora_finetuning/chat.py
new file mode 100644
index 0000000..aaedb28
--- /dev/null
+++ b/examples/bdlora_finetuning/chat.py
@@ -0,0 +1,64 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+import asyncio
+import json
+import time
+
+import aiohttp
+import typer
+
+
+def chat(
+    msg: str,
+    target: str = "lora1",
+    max_tokens: int = 100,
+    deterministic: bool = True,
+    record: str = "",
+    num_requests: int = 32,
+):
+    payload = {
+        "model": target,
+        "prompt": msg,
+        "max_tokens": max_tokens,
+    }
+    if deterministic:
+        payload = payload | {"temperature": 0, "top_p": 1, "top_k": 1}
+
+    url = "http://localhost:8000/v1/completions"
+
+    async def _request(session):
+        async with session.post(url, json=payload) as response:
+            response_json = await response.json()
+            return response_json["choices"][0]["text"]
+
+    async def run_concurrent():
+        async with aiohttp.ClientSession() as session:
+            tasks = [_request(session) for _ in range(num_requests)]
+            return await asyncio.gather(*tasks)
+
+    start_time = time.time()
+    response_texts = asyncio.run(run_concurrent())
+    end_time = time.time()
+
+    print(f"Completed {num_requests} requests in {end_time - start_time:.2f} seconds")
+
+    if record:
+        with open(record, "w") as f:
+            json.dump({"prompt": msg, "responses": response_texts}, f, indent=2)
+    else:
+        print(response_texts[0])
+
+
+if __name__ == "__main__":
+    typer.run(chat)
diff --git a/examples/bdlora_finetuning/vllm_server.bash b/examples/bdlora_finetuning/vllm_server.bash
new file mode 100644
index 0000000..c38adcf
--- /dev/null
+++ b/examples/bdlora_finetuning/vllm_server.bash
@@ -0,0 +1,13 @@
+#!/bin/bash
+
+ADAPTER_PATH="example_bd_lora_adapter"
+
+python -m vllm.entrypoints.openai.api_server \
+    --model meta-llama/Llama-3.2-1B \
+    --enable-lora \
+    --lora-modules lora1=$ADAPTER_PATH lora2=$ADAPTER_PATH \
+    --tensor-parallel-size 2 \
+    --block_diagonal_sharded_loras \
+    --max-lora-rank 128 \
+    --enforce-eager \
+    --port 8000
diff --git a/examples/beft_finetuning/README.md b/examples/beft_finetuning/README.md
new file mode 100644
index 0000000..9b74e01
--- /dev/null
+++ b/examples/beft_finetuning/README.md
@@ -0,0 +1,20 @@
+# BEFT: Bias-Efficient Fine-Tuning of Language Models in Low-Data Regimes
+
+## Introduction
+Fine-tuning the bias terms of large language models (LLMs) has the potential to achieve unprecedented parameter efficiency while maintaining competitive performance, particularly **in low-data regimes**. In this paper, we investigate the link between fine-tuning **b**<sub>q</sub>, **b**<sub>k</sub>, and **b**<sub>v</sub> with the performance of the downstream task, both analytically and empirically. We study and shed light on the expressive power of bias terms **b**<sub>q</sub>, **b**<sub>k</sub>, and **b**<sub>v</sub> in the query, key, or value projections of LLMs including bias-term-free LLMs. Our key finding is that directly fine-tuning **b**<sub>v</sub> generally leads to higher downstream performance in low-data regimes, in comparison to **b**<sub>q</sub> and **b**<sub>k</sub>.
+
+
+
+## Quick start
+You can try target_modules=`["v"]`, or `["q"]`, or `["k"]` in `beft_finetuning.py` to see the downstream accuracy.
+
+
+## Citation
+```bibtex
+@inproceedings{huang2026beft,
+  title={BEFT: Bias-Efficient Fine-Tuning of Language Models in Low-Data Regimes},
+  author={Huang, Baichuan and Balashankar, Ananth and Aminifar, Amir},
+  booktitle={Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics},
+  year={2026}
+}
+```
diff --git a/examples/beft_finetuning/beft_finetuning.py b/examples/beft_finetuning/beft_finetuning.py
new file mode 100644
index 0000000..7d0f370
--- /dev/null
+++ b/examples/beft_finetuning/beft_finetuning.py
@@ -0,0 +1,122 @@
+# This script is based on the example shown in docs/source/task_guides/ia3.md
+import torch
+from datasets import load_dataset
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+from transformers import (
+    AutoModelForSeq2SeqLM,
+    AutoTokenizer,
+    default_data_collator,
+    get_linear_schedule_with_warmup,
+)
+
+from peft import BeftConfig, get_peft_model
+
+
+ds = load_dataset("gtfintechlab/financial_phrasebank_sentences_allagree", "5768")
+ds = ds["train"].train_test_split(test_size=0.1)
+ds["validation"] = ds["test"]
+del ds["test"]
+
+classes = ["negative", "neutral", "positive"]
+# Keep map in-process; num_proc=1 still uses multiprocessing and can trigger dill issues on some Python versions.
+ds = ds.map(
+    lambda x: {"text_label": [classes[label] for label in x["label"]]},
+    batched=True,
+)
+
+text_column = "sentence"
+label_column = "text_label"
+max_length = 128
+
+tokenizer = AutoTokenizer.from_pretrained("bigscience/mt0-small")
+
+
+def preprocess_function(examples):
+    inputs = examples[text_column]
+    targets = examples[label_column]
+    model_inputs = tokenizer(inputs, max_length=max_length, padding="max_length", truncation=True, return_tensors="pt")
+    labels = tokenizer(targets, max_length=3, padding="max_length", truncation=True, return_tensors="pt")
+    labels = labels["input_ids"]
+    labels[labels == tokenizer.pad_token_id] = -100
+    model_inputs["labels"] = labels
+    return model_inputs
+
+
+processed_ds = ds.map(
+    preprocess_function,
+    batched=True,
+    remove_columns=ds["train"].column_names,
+    load_from_cache_file=False,
+    desc="Running tokenizer on dataset",
+)
+
+# low-data regimes: select a subset of the training data, i.e., 500 examples for training
+train_ds = processed_ds["train"].select(range(500))
+eval_ds = processed_ds["validation"]
+
+batch_size = 8
+
+train_dataloader = DataLoader(
+    train_ds, shuffle=True, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True
+)
+eval_dataloader = DataLoader(eval_ds, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True)
+
+
+model = AutoModelForSeq2SeqLM.from_pretrained("bigscience/mt0-small")
+
+# you can try target_modules=["v"], target_modules=["q"], target_modules=["k"]
+peft_config = BeftConfig(task_type="SEQ_2_SEQ_LM", target_modules=["v"])
+model = get_peft_model(model, peft_config)
+print(model.print_trainable_parameters())
+
+lr = 8e-3
+num_epochs = 1
+
+optimizer = torch.optim.AdamW(model.parameters(), lr=lr)
+lr_scheduler = get_linear_schedule_with_warmup(
+    optimizer=optimizer,
+    num_warmup_steps=0,
+    num_training_steps=(len(train_dataloader) * num_epochs),
+)
+
+device = (
+    torch.accelerator.current_accelerator().type
+    if hasattr(torch, "accelerator")
+    else "cuda"
+    if torch.cuda.is_available()
+    else "cpu"
+)
+model = model.to(device)
+
+for epoch in range(num_epochs):
+    model.train()
+    total_loss = 0
+    for step, batch in enumerate(tqdm(train_dataloader)):
+        batch = {k: v.to(device) for k, v in batch.items()}
+        outputs = model(**batch)
+        loss = outputs.loss
+        total_loss += loss.detach().float()
+        loss.backward()
+        optimizer.step()
+        lr_scheduler.step()
+        optimizer.zero_grad()
+
+    model.eval()
+    eval_loss = 0
+    eval_preds = []
+    for step, batch in enumerate(tqdm(eval_dataloader)):
+        batch = {k: v.to(device) for k, v in batch.items()}
+        with torch.no_grad():
+            outputs = model(**batch)
+        loss = outputs.loss
+        eval_loss += loss.detach().float()
+        eval_preds.extend(
+            tokenizer.batch_decode(torch.argmax(outputs.logits, -1).detach().cpu().numpy(), skip_special_tokens=True)
+        )
+
+    eval_epoch_loss = eval_loss / len(eval_dataloader)
+    eval_ppl = torch.exp(eval_epoch_loss)
+    train_epoch_loss = total_loss / len(train_dataloader)
+    train_ppl = torch.exp(train_epoch_loss)
+    print(f"{epoch=}: {train_ppl=} {train_epoch_loss=} {eval_ppl=} {eval_epoch_loss=}")
diff --git a/examples/boft_controlnet/__init__.py b/examples/boft_controlnet/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/examples/boft_controlnet/boft_controlnet.md b/examples/boft_controlnet/boft_controlnet.md
new file mode 100644
index 0000000..57777f1
--- /dev/null
+++ b/examples/boft_controlnet/boft_controlnet.md
@@ -0,0 +1,177 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+
+# Fine-tuning for controllable generation with BOFT (ControlNet)
+
+This guide demonstrates how to use BOFT, an orthogonal fine-tuning method, to fine-tune Stable Diffusion with either `stabilityai/stable-diffusion-2-1` or `runwayml/stable-diffusion-v1-5` model for controllable generation.
+
+By using BOFT from 🤗 PEFT, we can significantly reduce the number of trainable parameters while still achieving impressive results in various fine-tuning tasks across different foundation models. BOFT enhances model efficiency by integrating full-rank orthogonal matrices with a butterfly structure into specific model blocks, such as attention blocks, mirroring the approach used in LoRA. During fine-tuning, only these inserted matrices are trained, leaving the original model parameters untouched. During inference, the trainable BOFT parameters can be merged into the original model, eliminating any additional computational costs.
+
+As a member of the **orthogonal finetuning** class, BOFT presents a systematic and principled method for fine-tuning. It possesses several unique properties and has demonstrated superior performance compared to LoRA in a variety of scenarios. For further details on BOFT, please consult the [PEFT's GitHub repo's concept guide OFT](https://https://huggingface.co/docs/peft/index), the [original BOFT paper](https://huggingface.co/papers/2311.06243) and the [original OFT paper](https://huggingface.co/papers/2306.07280).
+
+In this guide we provide a controllable generation (ControlNet) fine-tuning script that is available in [PEFT's GitHub repo examples](https://github.com/huggingface/peft/tree/main/examples/boft_controlnet). This implementation is adapted from [diffusers's ControlNet](https://github.com/huggingface/diffusers/tree/main/examples/controlnet) and [Hecong Wu's ControlLoRA](https://github.com/HighCWu/ControlLoRA). You can try it out and finetune on your custom images.
+
+## Set up your environment
+Start by cloning the PEFT repository:
+
+```bash
+git clone https://github.com/huggingface/peft
+```
+
+Navigate to the directory containing the training scripts for fine-tuning Dreambooth with BOFT:
+```bash
+cd peft/examples/boft_controlnet
+```
+
+Set up your environment: install PEFT, and all the required libraries. At the time of writing this guide we recommend installing PEFT from source.
+
+```bash
+conda create --name peft python=3.10
+conda activate peft
+conda install pytorch==2.1.2 torchvision==0.16.2 torchaudio==2.1.2 pytorch-cuda=11.8 -c pytorch -c nvidia
+conda install xformers -c xformers
+pip install -r requirements.txt
+pip install git+https://github.com/huggingface/peft
+```
+
+## Data
+
+We use the [control-celeba-hq](https://huggingface.co/datasets/oftverse/control-celeba-hq) dataset for landmark-to-face controllable generation. We also provide evaluation scripts to evaluate the controllable generation performance. This task can be used to quantitatively compare different fine-tuning techniques.
+
+```bash
+export DATASET_NAME="oftverse/control-celeba-hq"
+```
+
+## Train controllable generation (ControlNet) with BOFT
+
+Start with setting some hyperparameters for BOFT:
+```bash
+PEFT_TYPE="boft"
+BLOCK_NUM=8
+BLOCK_SIZE=0
+N_BUTTERFLY_FACTOR=0
+```
+
+Here:
+
+
+Navigate to the directory containing the training scripts for fine-tuning Stable Diffusion with BOFT for controllable generation:
+
+```bash
+./train_controlnet.sh
+```
+or
+```bash
+export MODEL_NAME="stabilityai/stable-diffusion-2-1"
+# export MODEL_NAME="runwayml/stable-diffusion-v1-5"
+
+export DATASET_NAME="oftverse/control-celeba-hq"
+export PROJECT_NAME="controlnet_${PEFT_TYPE}"
+export RUN_NAME="${PEFT_TYPE}_${BLOCK_NUM}${BLOCK_SIZE}${N_BUTTERFLY_FACTOR}"
+export CONTROLNET_PATH=""
+export OUTPUT_DIR="./output/${DATASET_NAME}/${RUN_NAME}"
+
+accelerate launch train_controlnet.py \
+  --pretrained_model_name_or_path=$MODEL_NAME \
+  --resume_from_checkpoint=$RESUME_PATH \
+  --controlnet_model_name_or_path=$CONTROLNET_PATH \
+  --output_dir=$OUTPUT_DIR \
+  --report_to="wandb" \
+  --dataset_name=$DATASET_NAME \
+  --resolution=512 \
+  --learning_rate=1e-5 \
+  --checkpointing_steps=5000 \
+  --max_train_steps=50000 \
+  --validation_steps=2000 \
+  --num_validation_images=12 \
+  --train_batch_size=4 \
+  --dataloader_num_workers=2 \
+  --seed="0" \
+  --lr_scheduler="constant" \
+  --lr_warmup_steps=0 \
+  --wandb_project_name=$PROJECT_NAME \
+  --wandb_run_name=$RUN_NAME \
+  --enable_xformers_memory_efficient_attention \
+  --use_boft \
+  --boft_block_num=$BLOCK_NUM \
+  --boft_block_size=$BLOCK_SIZE \
+  --boft_n_butterfly_factor=$N_BUTTERFLY_FACTOR \
+  --boft_dropout=0.1 \
+  --boft_bias="boft_only" \
+  --report_to="wandb" \
+```
+
+Run inference on the saved model to sample new images from the validation set:
+
+```bash
+./test_controlnet.sh
+```
+or
+```bash
+ITER_NUM=50000
+
+export MODEL_NAME="stabilityai/stable-diffusion-2-1"
+# export MODEL_NAME="runwayml/stable-diffusion-v1-5"
+
+export RUN_NAME="${PEFT_TYPE}_${BLOCK_NUM}${BLOCK_SIZE}${N_BUTTERFLY_FACTOR}"
+export DATASET_NAME="oftverse/control-celeba-hq"
+export CKPT_NAME="checkpoint-${ITER_NUM}"
+export OUTPUT_DIR="./output/${DATASET_NAME}/${RUN_NAME}/${CKPT_NAME}"
+export CONTROLNET_PATH="${OUTPUT_DIR}/controlnet/model.safetensors"
+export UNET_PATH="${OUTPUT_DIR}/unet/${RUN_NAME}"
+export RESULTS_PATH="${OUTPUT_DIR}/results"
+
+accelerate launch test_controlnet.py \
+  --pretrained_model_name_or_path=$MODEL_NAME \
+  --dataset_name=$DATASET_NAME \
+  --controlnet_path=$CONTROLNET_PATH \
+  --unet_path=$UNET_PATH \
+  --adapter_name=$RUN_NAME \
+  --output_dir=$RESULTS_PATH \
+  --dataset_name=$DATASET_NAME \
+
+```
+
+Run evaluation on the sampled images to evaluate the landmark reprojection error:
+
+```bash
+./eval.sh
+```
+or
+```bash
+ITER_NUM=50000
+
+export MODEL_NAME="stabilityai/stable-diffusion-2-1"
+# export MODEL_NAME="runwayml/stable-diffusion-v1-5"
+
+export RUN_NAME="${PEFT_TYPE}_${BLOCK_NUM}${BLOCK_SIZE}${N_BUTTERFLY_FACTOR}"
+export DATASET_NAME="oftverse/control-celeba-hq"
+export CKPT_NAME="checkpoint-${ITER_NUM}"
+export OUTPUT_DIR="./output/${DATASET_NAME}/${RUN_NAME}/${CKPT_NAME}"
+export CONTROLNET_PATH="${OUTPUT_DIR}/controlnet/model.safetensors"
+export UNET_PATH="${OUTPUT_DIR}/unet/${RUN_NAME}"
+
+accelerate launch eval.py \
+  --pretrained_model_name_or_path=$MODEL_NAME \
+  --dataset_name=$DATASET_NAME \
+  --controlnet_path=$CONTROLNET_PATH \
+  --unet_path=$UNET_PATH \
+  --adapter_name=$RUN_NAME \
+  --output_dir=$OUTPUT_DIR \
+  --dataset_name=$DATASET_NAME \
+  --vis_overlays \
+```
diff --git a/examples/boft_controlnet/eval.py b/examples/boft_controlnet/eval.py
new file mode 100644
index 0000000..ea53af7
--- /dev/null
+++ b/examples/boft_controlnet/eval.py
@@ -0,0 +1,206 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+# The implementation is based on "Parameter-Efficient Orthogonal Finetuning
+# via Butterfly Factorization" (https://huggingface.co/papers/2311.06243) in ICLR 2024.
+
+import glob
+import os
+from pathlib import Path
+
+import cv2
+import face_alignment
+import numpy as np
+import torch
+from accelerate import Accelerator
+from skimage.io import imread
+from torchvision.utils import save_image
+from tqdm import tqdm
+from transformers import AutoTokenizer
+from utils.args_loader import parse_args
+from utils.dataset import make_dataset
+
+
+# Determine the best available device
+if torch.cuda.is_available():
+    device = "cuda:0"
+else:
+    # TODO: xpu support in facealignment will be ready after this PR is merged:https://github.com/1adrianb/face-alignment/pull/371
+    device = "cpu"
+
+detect_model = face_alignment.FaceAlignment(face_alignment.LandmarksType.TWO_D, device=device, flip_input=False)
+# with open('./data/celebhq-text/prompt_val_blip_full.json', 'rt') as f:    # fill50k, COCO
+#     for line in f:
+#         val_data = json.loads(line)
+
+end_list = np.array([17, 22, 27, 42, 48, 31, 36, 68], dtype=np.int32) - 1
+
+
+def count_txt_files(directory):
+    pattern = os.path.join(directory, "*.txt")
+    txt_files = glob.glob(pattern)
+    return len(txt_files)
+
+
+def plot_kpts(image, kpts, color="g"):
+    """Draw 68 key points
+    Args:
+        image: the input image
+        kpt: (68, 3).
+    """
+    if color == "r":
+        c = (255, 0, 0)
+    elif color == "g":
+        c = (0, 255, 0)
+    elif color == "b":
+        c = (255, 0, 0)
+    image = image.copy()
+    kpts = kpts.copy()
+    radius = max(int(min(image.shape[0], image.shape[1]) / 200), 1)
+    for i in range(kpts.shape[0]):
+        st = kpts[i, :2]
+        if kpts.shape[1] == 4:
+            if kpts[i, 3] > 0.5:
+                c = (0, 255, 0)
+            else:
+                c = (0, 0, 255)
+        image = cv2.circle(image, (int(st[0]), int(st[1])), radius, c, radius * 2)
+        if i in end_list:
+            continue
+        ed = kpts[i + 1, :2]
+        image = cv2.line(image, (int(st[0]), int(st[1])), (int(ed[0]), int(ed[1])), (255, 255, 255), radius)
+    return image
+
+
+def generate_landmark2d(dataset, input_dir, pred_lmk_dir, gt_lmk_dir, vis=False):
+    print("Generate 2d landmarks ...")
+    os.makedirs(pred_lmk_dir, exist_ok=True)
+
+    imagepath_list = sorted(glob.glob(f"{input_dir}/pred*.png"))
+
+    for imagepath in tqdm(imagepath_list):
+        name = Path(imagepath).stem
+        idx = int(name.split("_")[-1])
+        pred_txt_path = os.path.join(pred_lmk_dir, f"{idx}.txt")
+        gt_lmk_path = os.path.join(gt_lmk_dir, f"{idx}_gt_lmk.jpg")
+        gt_txt_path = os.path.join(gt_lmk_dir, f"{idx}.txt")
+        gt_img_path = os.path.join(gt_lmk_dir, f"{idx}_gt_img.jpg")
+
+        if (not os.path.exists(pred_txt_path)) or (not os.path.exists(gt_txt_path)):
+            image = imread(imagepath)  # [:, :, :3]
+            out = detect_model.get_landmarks(image)
+            if out is None:
+                continue
+
+            pred_kpt = out[0].squeeze()
+            np.savetxt(pred_txt_path, pred_kpt)
+
+            # Your existing code for obtaining the image tensor
+            gt_lmk_img = dataset[idx]["conditioning_pixel_values"]
+            save_image(gt_lmk_img, gt_lmk_path)
+
+            gt_img = (dataset[idx]["pixel_values"]) * 0.5 + 0.5
+            save_image(gt_img, gt_img_path)
+
+            gt_img = (gt_img.permute(1, 2, 0) * 255).type(torch.uint8).cpu().numpy()
+            out = detect_model.get_landmarks(gt_img)
+            if out is None:
+                continue
+
+            gt_kpt = out[0].squeeze()
+            np.savetxt(gt_txt_path, gt_kpt)
+            # gt_image = cv2.resize(cv2.imread(gt_lmk_path), (512, 512))
+
+            if vis:
+                gt_lmk_image = cv2.imread(gt_lmk_path)
+
+                # visualize predicted landmarks
+                vis_path = os.path.join(pred_lmk_dir, f"{idx}_overlay.jpg")
+                image = cv2.imread(imagepath)
+                image_point = plot_kpts(image, pred_kpt)
+                cv2.imwrite(vis_path, np.concatenate([image_point, gt_lmk_image], axis=1))
+
+                # visualize gt landmarks
+                vis_path = os.path.join(gt_lmk_dir, f"{idx}_overlay.jpg")
+                image = cv2.imread(gt_img_path)
+                image_point = plot_kpts(image, gt_kpt)
+                cv2.imwrite(vis_path, np.concatenate([image_point, gt_lmk_image], axis=1))
+
+
+def landmark_comparison(val_dataset, lmk_dir, gt_lmk_dir):
+    print("Calculating reprojection error")
+    lmk_err = []
+
+    pbar = tqdm(range(len(val_dataset)))
+    for i in pbar:
+        # line = val_dataset[i]
+        # img_name = line["image"].split(".")[0]
+        lmk1_path = os.path.join(gt_lmk_dir, f"{i}.txt")
+        lmk1 = np.loadtxt(lmk1_path)
+        lmk2_path = os.path.join(lmk_dir, f"{i}.txt")
+
+        if not os.path.exists(lmk2_path):
+            print(f"{lmk2_path} not exist")
+            continue
+
+        lmk2 = np.loadtxt(lmk2_path)
+        lmk_err.append(np.mean(np.linalg.norm(lmk1 - lmk2, axis=1)))
+        pbar.set_description(f"lmk_err: {np.mean(lmk_err):.5f}")
+
+    print("Reprojection error:", np.mean(lmk_err))
+    np.save(os.path.join(lmk_dir, "lmk_err.npy"), lmk_err)
+
+
+def main(args):
+    logging_dir = Path(args.output_dir, args.logging_dir)
+
+    accelerator = Accelerator(
+        gradient_accumulation_steps=args.gradient_accumulation_steps,
+        mixed_precision=args.mixed_precision,
+        log_with=args.report_to,
+        project_dir=logging_dir,
+    )
+
+    # Load the tokenizer
+    if args.tokenizer_name:
+        tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name, revision=args.revision, use_fast=False)
+    elif args.pretrained_model_name_or_path:
+        tokenizer = AutoTokenizer.from_pretrained(
+            args.pretrained_model_name_or_path,
+            subfolder="tokenizer",
+            revision=args.revision,
+            use_fast=False,
+        )
+
+    val_dataset = make_dataset(args, tokenizer, accelerator, "test")
+
+    gt_lmk_dir = os.path.join(args.output_dir, "gt_lmk")
+    if not os.path.exists(gt_lmk_dir):
+        os.makedirs(gt_lmk_dir, exist_ok=True)
+
+    pred_lmk_dir = os.path.join(args.output_dir, "pred_lmk")
+    if not os.path.exists(pred_lmk_dir):
+        os.makedirs(pred_lmk_dir, exist_ok=True)
+
+    input_dir = os.path.join(args.output_dir, "results")
+
+    generate_landmark2d(val_dataset, input_dir, pred_lmk_dir, gt_lmk_dir, args.vis_overlays)
+
+    if count_txt_files(pred_lmk_dir) == len(val_dataset) and count_txt_files(gt_lmk_dir) == len(val_dataset):
+        landmark_comparison(val_dataset, pred_lmk_dir, gt_lmk_dir)
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    main(args)
diff --git a/examples/boft_controlnet/eval.sh b/examples/boft_controlnet/eval.sh
new file mode 100755
index 0000000..d5ed282
--- /dev/null
+++ b/examples/boft_controlnet/eval.sh
@@ -0,0 +1,29 @@
+PEFT_TYPE="boft"
+BLOCK_NUM=8
+BLOCK_SIZE=0
+N_BUTTERFLY_FACTOR=1
+ITER_NUM=50000
+
+export RUN_NAME="${PEFT_TYPE}_${BLOCK_NUM}${BLOCK_SIZE}${N_BUTTERFLY_FACTOR}"
+
+export MODEL_NAME="stabilityai/stable-diffusion-2-1"
+# export MODEL_NAME="runwayml/stable-diffusion-v1-5"
+
+export DATASET_NAME="oftverse/control-celeba-hq"
+export CKPT_NAME="checkpoint-${ITER_NUM}"
+export OUTPUT_DIR="./output/${DATASET_NAME}/${RUN_NAME}/${CKPT_NAME}"
+export CONTROLNET_PATH="${OUTPUT_DIR}/controlnet/model.safetensors"
+export UNET_PATH="${OUTPUT_DIR}/unet/${RUN_NAME}"
+
+
+accelerate launch eval.py \
+  --pretrained_model_name_or_path=$MODEL_NAME \
+  --dataset_name=$DATASET_NAME \
+  --controlnet_path=$CONTROLNET_PATH \
+  --unet_path=$UNET_PATH \
+  --adapter_name=$RUN_NAME \
+  --output_dir=$OUTPUT_DIR \
+  --dataset_name=$DATASET_NAME \
+  --vis_overlays \
+
+
diff --git a/examples/boft_controlnet/requirements.txt b/examples/boft_controlnet/requirements.txt
new file mode 100644
index 0000000..b030409
--- /dev/null
+++ b/examples/boft_controlnet/requirements.txt
@@ -0,0 +1,10 @@
+datasets==2.16.1
+diffusers==0.34.0
+transformers==4.54.0
+accelerate==1.9.0
+wandb==0.16.1
+scikit-image==0.22.0
+opencv-python==4.9.0.80
+git+https://github.com/1adrianb/face-alignment.git
+huggingface_hub==0.34.3
+numpy<2.0.0
\ No newline at end of file
diff --git a/examples/boft_controlnet/test_controlnet.py b/examples/boft_controlnet/test_controlnet.py
new file mode 100644
index 0000000..1b0497b
--- /dev/null
+++ b/examples/boft_controlnet/test_controlnet.py
@@ -0,0 +1,133 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+# The implementation is based on "Parameter-Efficient Orthogonal Finetuning
+# via Butterfly Factorization" (https://huggingface.co/papers/2311.06243) in ICLR 2024.
+
+import os
+import sys
+import time
+from pathlib import Path
+
+import numpy as np
+import torch
+from accelerate import Accelerator
+from diffusers import DDIMScheduler
+from diffusers.utils import check_min_version
+from safetensors.torch import load_file
+from tqdm import tqdm
+from transformers import AutoTokenizer
+from utils.args_loader import parse_args
+from utils.dataset import make_dataset
+from utils.light_controlnet import ControlNetModel
+from utils.pipeline_controlnet import LightControlNetPipeline
+from utils.unet_2d_condition import UNet2DConditionNewModel
+
+
+sys.path.append("../../src")
+from peft import PeftModel
+
+
+# Will error if the minimal version of diffusers is not installed. Remove at your own risks.
+check_min_version("0.10.0.dev0")
+if torch.xpu.is_available():
+    device = "xpu:0"
+elif torch.cuda.is_available():
+    device = "cuda:0"
+else:
+    device = "cpu"
+
+
+def main(args):
+    logging_dir = Path(args.output_dir, args.logging_dir)
+
+    accelerator = Accelerator(
+        gradient_accumulation_steps=args.gradient_accumulation_steps,
+        mixed_precision=args.mixed_precision,
+        log_with=args.report_to,
+        project_dir=logging_dir,
+    )
+
+    # Load the tokenizer
+    if args.tokenizer_name:
+        tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name, revision=args.revision, use_fast=False)
+    elif args.pretrained_model_name_or_path:
+        tokenizer = AutoTokenizer.from_pretrained(
+            args.pretrained_model_name_or_path,
+            subfolder="tokenizer",
+            revision=args.revision,
+            use_fast=False,
+        )
+
+    val_dataset = make_dataset(args, tokenizer, accelerator, "test")
+
+    controlnet_path = args.controlnet_path
+    unet_path = args.unet_path
+
+    controlnet = ControlNetModel()
+    controlnet.load_state_dict(load_file(controlnet_path))
+    unet = UNet2DConditionNewModel.from_pretrained(args.pretrained_model_name_or_path, subfolder="unet")
+    unet = PeftModel.from_pretrained(unet, unet_path, adapter_name=args.adapter_name)
+
+    pipe = LightControlNetPipeline.from_pretrained(
+        args.pretrained_model_name_or_path,
+        controlnet=controlnet,
+        unet=unet.model,
+        dtype=torch.float32,
+        requires_safety_checker=False,
+    ).to(device)
+
+    pipe.scheduler = DDIMScheduler.from_config(pipe.scheduler.config)
+
+    if not os.path.exists(args.output_dir):
+        os.makedirs(args.output_dir, exist_ok=True)
+
+    exist_lst = [int(img.split("_")[-1][:-4]) for img in os.listdir(args.output_dir)]
+    all_lst = np.arange(len(val_dataset))
+    idx_lst = [item for item in all_lst if item not in exist_lst]
+
+    print("Number of images to be processed: ", len(idx_lst))
+
+    np.random.seed(seed=int(time.time()))
+    np.random.shuffle(idx_lst)
+
+    for idx in tqdm(idx_lst):
+        output_path = os.path.join(args.output_dir, f"pred_img_{idx:04d}.png")
+
+        if not os.path.exists(output_path):
+            data = val_dataset[idx.item()]
+            negative_prompt = "low quality, blurry, unfinished"
+
+            with torch.no_grad():
+                pred_img = pipe(
+                    data["text"],
+                    [data["conditioning_pixel_values"]],
+                    num_inference_steps=50,
+                    guidance_scale=7,
+                    negative_prompt=negative_prompt,
+                ).images[0]
+
+            pred_img.save(output_path)
+
+    # control_img = Image.fromarray(
+    #     (data["conditioning_pixel_value"] * 255).numpy().transpose(1, 2, 0).astype(np.uint8)
+    # )
+    # gt_img = Image.fromarray(
+    #     ((data["pixel_value"] + 1.0) * 0.5 * 255).numpy().transpose(1, 2, 0).astype(np.uint8)
+    # )
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    main(args)
diff --git a/examples/boft_controlnet/test_controlnet.sh b/examples/boft_controlnet/test_controlnet.sh
new file mode 100755
index 0000000..e8d61e1
--- /dev/null
+++ b/examples/boft_controlnet/test_controlnet.sh
@@ -0,0 +1,29 @@
+PEFT_TYPE="boft"
+BLOCK_NUM=8
+BLOCK_SIZE=0
+N_BUTTERFLY_FACTOR=1
+ITER_NUM=50000
+
+export RUN_NAME="${PEFT_TYPE}_${BLOCK_NUM}${BLOCK_SIZE}${N_BUTTERFLY_FACTOR}"
+
+export MODEL_NAME="stabilityai/stable-diffusion-2-1"
+# export MODEL_NAME="runwayml/stable-diffusion-v1-5"
+
+export DATASET_NAME="oftverse/control-celeba-hq"
+export CKPT_NAME="checkpoint-${ITER_NUM}"
+export OUTPUT_DIR="./output/${DATASET_NAME}/${RUN_NAME}/${CKPT_NAME}"
+export CONTROLNET_PATH="${OUTPUT_DIR}/controlnet/model.safetensors"
+export UNET_PATH="${OUTPUT_DIR}/unet"
+export RESULTS_PATH="${OUTPUT_DIR}/results"
+
+
+accelerate launch test_controlnet.py \
+  --pretrained_model_name_or_path=$MODEL_NAME \
+  --dataset_name=$DATASET_NAME \
+  --controlnet_path=$CONTROLNET_PATH \
+  --unet_path=$UNET_PATH \
+  --adapter_name=$RUN_NAME \
+  --output_dir=$RESULTS_PATH \
+  --dataset_name=$DATASET_NAME \
+
+
diff --git a/examples/boft_controlnet/train_controlnet.py b/examples/boft_controlnet/train_controlnet.py
new file mode 100644
index 0000000..8cf6c96
--- /dev/null
+++ b/examples/boft_controlnet/train_controlnet.py
@@ -0,0 +1,544 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+# The implementation is based on "Parameter-Efficient Orthogonal Finetuning
+# via Butterfly Factorization" (https://huggingface.co/papers/2311.06243) in ICLR 2024.
+
+import itertools
+import logging
+import math
+import os
+from pathlib import Path
+
+import datasets
+import diffusers
+import torch
+import torch.nn.functional as F
+import torch.utils.checkpoint
+import transformers
+from accelerate import Accelerator
+from accelerate.logging import get_logger
+from accelerate.utils import set_seed
+from diffusers import (
+    AutoencoderKL,
+    DDIMScheduler,
+)
+from diffusers.optimization import get_scheduler
+from diffusers.utils import check_min_version
+from diffusers.utils.import_utils import is_xformers_available
+from packaging import version
+from tqdm.auto import tqdm
+from transformers import AutoTokenizer
+from utils.args_loader import (
+    import_model_class_from_model_name_or_path,
+    parse_args,
+)
+from utils.dataset import collate_fn, log_validation, make_dataset
+from utils.light_controlnet import ControlNetModel
+from utils.tracemalloc import TorchTracemalloc, b2mb
+from utils.unet_2d_condition import UNet2DConditionNewModel
+
+from peft import BOFTConfig, get_peft_model
+from peft.peft_model import PeftModel
+
+
+# Will error if the minimal version of diffusers is not installed. Remove at your own risks.
+check_min_version("0.16.0.dev0")
+
+logger = get_logger(__name__)
+
+UNET_TARGET_MODULES = ["to_q", "to_v", "to_k", "query", "value", "key"]
+
+TEXT_ENCODER_TARGET_MODULES = ["q_proj", "v_proj"]
+
+
+@torch.no_grad()
+def save_adaptor(accelerator, output_dir, nets_dict):
+    for net_key in nets_dict.keys():
+        net_model = nets_dict[net_key]
+        unwarpped_net = accelerator.unwrap_model(net_model)
+
+        if isinstance(unwarpped_net, PeftModel):
+            unwarpped_net.save_pretrained(
+                os.path.join(output_dir, net_key),
+                state_dict=accelerator.get_state_dict(net_model),
+                safe_serialization=True,
+            )
+        else:
+            accelerator.save_model(
+                unwarpped_net,
+                os.path.join(output_dir, net_key),
+                safe_serialization=True,
+            )
+
+
+def main(args):
+    logging_dir = Path(args.output_dir, args.logging_dir)
+
+    accelerator = Accelerator(
+        gradient_accumulation_steps=args.gradient_accumulation_steps,
+        mixed_precision=args.mixed_precision,
+        log_with=args.report_to,
+        project_dir=logging_dir,
+    )
+
+    if args.report_to == "wandb":
+        wandb_init = {
+            "wandb": {
+                "name": args.wandb_run_name,
+                "mode": "online",
+            }
+        }
+
+    # Make one log on every process with the configuration for debugging.
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        level=logging.INFO,
+    )
+
+    logger.info(accelerator.state, main_process_only=False)
+
+    if accelerator.is_local_main_process:
+        datasets.utils.logging.set_verbosity_warning()
+        transformers.utils.logging.set_verbosity_warning()
+        diffusers.utils.logging.set_verbosity_info()
+    else:
+        datasets.utils.logging.set_verbosity_error()
+        transformers.utils.logging.set_verbosity_error()
+        diffusers.utils.logging.set_verbosity_error()
+
+    # If passed along, set the training seed now.
+    if args.seed is not None:
+        set_seed(args.seed)
+
+    # Handle the repository creation
+    if accelerator.is_main_process:
+        if args.output_dir is not None:
+            os.makedirs(args.output_dir, exist_ok=True)
+
+    # Load the tokenizer
+    if args.tokenizer_name:
+        tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name, revision=args.revision, use_fast=False)
+    elif args.pretrained_model_name_or_path:
+        tokenizer = AutoTokenizer.from_pretrained(
+            args.pretrained_model_name_or_path,
+            subfolder="tokenizer",
+            revision=args.revision,
+            use_fast=False,
+        )
+
+    # import correct text encoder class
+    text_encoder_cls = import_model_class_from_model_name_or_path(args.pretrained_model_name_or_path, args.revision)
+
+    # Load scheduler and models
+    noise_scheduler = DDIMScheduler.from_pretrained(args.pretrained_model_name_or_path, subfolder="scheduler")
+
+    text_encoder = text_encoder_cls.from_pretrained(
+        args.pretrained_model_name_or_path, subfolder="text_encoder", revision=args.revision
+    )
+    vae = AutoencoderKL.from_pretrained(args.pretrained_model_name_or_path, subfolder="vae", revision=args.revision)
+    unet = UNet2DConditionNewModel.from_pretrained(
+        args.pretrained_model_name_or_path,
+        subfolder="unet",
+        revision=args.revision,
+    )
+
+    controlnet = ControlNetModel()
+
+    if args.controlnet_model_name_or_path != "":
+        logger.info(f"Loading existing controlnet weights from {args.controlnet_model_name_or_path}")
+        controlnet.load_state_dict(torch.load(args.controlnet_model_name_or_path))
+
+    if args.use_boft:
+        config = BOFTConfig(
+            boft_block_size=args.boft_block_size,
+            boft_block_num=args.boft_block_num,
+            boft_n_butterfly_factor=args.boft_n_butterfly_factor,
+            target_modules=UNET_TARGET_MODULES,
+            boft_dropout=args.boft_dropout,
+            bias=args.boft_bias,
+        )
+        unet = get_peft_model(unet, config)
+        unet.print_trainable_parameters()
+
+    vae.requires_grad_(False)
+    controlnet.requires_grad_(True)
+
+    if not args.train_text_encoder:
+        text_encoder.requires_grad_(False)
+
+    unet.train()
+    controlnet.train()
+
+    if args.train_text_encoder and args.use_boft:
+        config = BOFTConfig(
+            boft_block_size=args.boft_block_size,
+            boft_block_num=args.boft_block_num,
+            boft_n_butterfly_factor=args.boft_n_butterfly_factor,
+            target_modules=TEXT_ENCODER_TARGET_MODULES,
+            boft_dropout=args.boft_dropout,
+            bias=args.boft_bias,
+        )
+        text_encoder = get_peft_model(text_encoder, config, adapter_name=args.wandb_run_name)
+        text_encoder.print_trainable_parameters()
+
+    if args.train_text_encoder:
+        text_encoder.train()
+
+    # For mixed precision training we cast the text_encoder and vae weights to half-precision
+    # as these models are only used for inference, keeping weights in full precision is not required.
+    weight_dtype = torch.float32
+    if accelerator.mixed_precision == "fp16":
+        weight_dtype = torch.float16
+    elif accelerator.mixed_precision == "bf16":
+        weight_dtype = torch.bfloat16
+
+    # Move unet, vae and text_encoder to device and cast to weight_dtype
+    unet.to(accelerator.device, dtype=weight_dtype)
+    vae.to(accelerator.device, dtype=weight_dtype)
+    controlnet.to(accelerator.device, dtype=weight_dtype)
+
+    if not args.train_text_encoder:
+        text_encoder.to(accelerator.device, dtype=weight_dtype)
+
+    if args.enable_xformers_memory_efficient_attention:
+        if accelerator.device.type == "xpu":
+            logger.warning("XPU doesn't support xformers yet, xformers is not applied.")
+        elif is_xformers_available():
+            import xformers
+
+            xformers_version = version.parse(xformers.__version__)
+            if xformers_version == version.parse("0.0.16"):
+                logger.warning(
+                    "xFormers 0.0.16 cannot be used for training in some GPUs. If you observe problems during training, please update xFormers to at least 0.0.17. See https://huggingface.co/docs/diffusers/main/en/optimization/xformers for more details."
+                )
+            unet.enable_xformers_memory_efficient_attention()
+            controlnet.enable_xformers_memory_efficient_attention()
+            if args.train_text_encoder and not (args.use_lora or args.use_boft or args.use_oft):
+                text_encoder.enable_xformers_memory_efficient_attention()
+        else:
+            raise ValueError("xformers is not available. Make sure it is installed correctly")
+
+    if args.gradient_checkpointing:
+        controlnet.enable_gradient_checkpointing()
+        unet.enable_gradient_checkpointing()
+        if args.train_text_encoder and not (args.use_lora or args.use_boft or args.use_oft):
+            text_encoder.gradient_checkpointing_enable()
+
+    # Check that all trainable models are in full precision
+    low_precision_error_string = (
+        " Please make sure to always have all model weights in full float32 precision when starting training - even if"
+        " doing mixed precision training, copy of the weights should still be float32."
+    )
+
+    if accelerator.unwrap_model(controlnet).dtype != torch.float32:
+        raise ValueError(
+            f"Controlnet loaded as datatype {accelerator.unwrap_model(controlnet).dtype}. {low_precision_error_string}"
+        )
+
+    if accelerator.unwrap_model(unet).dtype != torch.float32:
+        raise ValueError(
+            f"UNet loaded as datatype {accelerator.unwrap_model(unet).dtype}. {low_precision_error_string}"
+        )
+
+    # Enable TF32 for faster training on Ampere GPUs,
+    # cf https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices
+    if args.allow_tf32:
+        torch.backends.cuda.matmul.allow_tf32 = True
+
+    if args.scale_lr:
+        args.learning_rate = (
+            args.learning_rate * args.gradient_accumulation_steps * args.train_batch_size * accelerator.num_processes
+        )
+
+    # Use 8-bit Adam for lower memory usage or to fine-tune the model in 16GB GPUs
+    if args.use_8bit_adam:
+        try:
+            import bitsandbytes as bnb
+        except ImportError:
+            raise ImportError(
+                "To use 8-bit Adam, please install the bitsandbytes library: `pip install bitsandbytes`."
+            )
+
+        optimizer_class = bnb.optim.AdamW8bit
+    else:
+        optimizer_class = torch.optim.AdamW
+
+    params_to_optimize = [param for param in controlnet.parameters() if param.requires_grad]
+    params_to_optimize += [param for param in unet.parameters() if param.requires_grad]
+
+    if args.train_text_encoder:
+        params_to_optimize += [param for param in text_encoder.parameters() if param.requires_grad]
+
+    # Optimizer creation
+    optimizer = optimizer_class(
+        params_to_optimize,
+        lr=args.learning_rate,
+        betas=(args.adam_beta1, args.adam_beta2),
+        weight_decay=args.adam_weight_decay,
+        eps=args.adam_epsilon,
+    )
+
+    # Load the dataset
+    train_dataset = make_dataset(args, tokenizer, accelerator, "train")
+    val_dataset = make_dataset(args, tokenizer, accelerator, "test")
+
+    train_dataloader = torch.utils.data.DataLoader(
+        train_dataset,
+        shuffle=True,
+        collate_fn=collate_fn,
+        batch_size=args.train_batch_size,
+        num_workers=args.dataloader_num_workers,
+    )
+
+    # Scheduler and math around the number of training steps.
+    overrode_max_train_steps = False
+    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+    if args.max_train_steps is None:
+        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+        overrode_max_train_steps = True
+
+    lr_scheduler = get_scheduler(
+        args.lr_scheduler,
+        optimizer=optimizer,
+        num_warmup_steps=args.lr_warmup_steps * args.gradient_accumulation_steps,
+        num_training_steps=args.max_train_steps * args.gradient_accumulation_steps,
+        num_cycles=args.lr_num_cycles,
+        power=args.lr_power,
+    )
+
+    # Prepare everything with our `accelerator`.
+    controlnet, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
+        controlnet, optimizer, train_dataloader, lr_scheduler
+    )
+
+    if args.train_text_encoder:
+        text_encoder = accelerator.prepare(text_encoder)
+
+    # We need to recalculate our total training steps as the size of the training dataloader may have changed.
+    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+    if overrode_max_train_steps:
+        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+    # Afterwards we recalculate our number of training epochs
+    args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch)
+
+    # We need to initialize the trackers we use, and also store our configuration.
+    # The trackers initializes automatically on the main process.
+    if accelerator.is_main_process:
+        accelerator.init_trackers(args.wandb_project_name, config=vars(args), init_kwargs=wandb_init)
+
+    # Train!
+    total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps
+
+    logger.info("***** Running training *****")
+    logger.info(f"  Num examples = {len(train_dataset)}")
+    logger.info(f"  Num batches each epoch = {len(train_dataloader)}")
+    logger.info(f"  Num Epochs = {args.num_train_epochs}")
+    logger.info(f"  Instantaneous batch size per device = {args.train_batch_size}")
+    logger.info(f"  Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}")
+    logger.info(f"  Gradient Accumulation steps = {args.gradient_accumulation_steps}")
+    logger.info(f"  Total optimization steps = {args.max_train_steps}")
+
+    global_step = 0
+    first_epoch = 0
+
+    # Potentially load in the weights and states from a previous save
+
+    if args.resume_from_checkpoint:
+        if args.resume_from_checkpoint != "latest":
+            path = os.path.basename(args.resume_from_checkpoint)
+        else:
+            # Get the most recent checkpoint
+            dirs = os.listdir(args.output_dir)
+            if "checkpoint-current" in dirs:
+                path = "checkpoint-current"
+                dirs = [d for d in dirs if d.startswith("checkpoint") and d.endswith("0")]
+                dirs = sorted(dirs, key=lambda x: int(x.split("-")[1]))
+
+            else:
+                dirs = [d for d in dirs if d.startswith("checkpoint")]
+                dirs = sorted(dirs, key=lambda x: int(x.split("-")[1]))
+                path = dirs[-1] if len(dirs) > 0 else None
+
+        if path is None:
+            accelerator.print(
+                f"Checkpoint '{args.resume_from_checkpoint}' does not exist. Starting a new training run."
+            )
+            args.resume_from_checkpoint = None
+            initial_global_step = 0
+        else:
+            accelerator.print(f"Resuming from checkpoint {path}")
+            accelerator.load_state(os.path.join(args.output_dir, path))
+            if path.split("-")[1] == "current":
+                global_step = int(dirs[-1].split("-")[1])
+            else:
+                global_step = int(path.split("-")[1])
+
+            initial_global_step = global_step
+            resume_global_step = global_step * args.gradient_accumulation_steps
+            first_epoch = global_step // num_update_steps_per_epoch
+            resume_step = resume_global_step % (num_update_steps_per_epoch * args.gradient_accumulation_steps)
+    else:
+        initial_global_step = 0
+
+    progress_bar = tqdm(
+        range(args.max_train_steps),
+        initial=initial_global_step,
+        desc="Steps",
+        disable=not accelerator.is_local_main_process,
+    )
+
+    progress_bar.set_description("Steps")
+
+    for epoch in range(first_epoch, args.num_train_epochs):
+        with TorchTracemalloc() as tracemalloc:
+            for step, batch in enumerate(train_dataloader):
+                # Skip steps until we reach the resumed step
+                if args.resume_from_checkpoint and epoch == first_epoch and step < resume_step:
+                    if step % args.gradient_accumulation_steps == 0:
+                        progress_bar.update(1)
+                        if args.report_to == "wandb":
+                            accelerator.print(progress_bar)
+                    continue
+
+                with accelerator.accumulate(controlnet), accelerator.accumulate(unet):
+                    # Convert images to latent space
+                    latents = vae.encode(batch["pixel_values"].to(dtype=weight_dtype)).latent_dist.sample()
+                    latents = latents * vae.config.scaling_factor
+
+                    # Sample noise that we'll add to the latents
+                    noise = torch.randn_like(latents)
+                    bsz = latents.shape[0]
+
+                    # Sample a random timestep for each image
+                    timesteps = torch.randint(
+                        0, noise_scheduler.config.num_train_timesteps, (bsz,), device=latents.device
+                    )
+                    timesteps = timesteps.long()
+
+                    # Add noise to the latents according to the noise magnitude at each timestep
+                    # (this is the forward diffusion process)
+                    noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps)
+
+                    # Get the text embedding for conditioning
+                    encoder_hidden_states = text_encoder(batch["input_ids"])[0]
+
+                    controlnet_image = batch["conditioning_pixel_values"].to(dtype=weight_dtype)
+
+                    # Get the guided hint for the UNet (320 dim)
+                    guided_hint = controlnet(
+                        controlnet_cond=controlnet_image,
+                    )
+
+                    # Predict the noise residual
+                    model_pred = unet(
+                        noisy_latents,
+                        timesteps,
+                        guided_hint=guided_hint,
+                        encoder_hidden_states=encoder_hidden_states,
+                    ).sample
+
+                    # Get the target for loss depending on the prediction type
+                    if noise_scheduler.config.prediction_type == "epsilon":
+                        target = noise
+                    elif noise_scheduler.config.prediction_type == "v_prediction":
+                        target = noise_scheduler.get_velocity(latents, noise, timesteps)
+                    else:
+                        raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}")
+
+                    loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
+
+                    accelerator.backward(loss)
+
+                    if accelerator.sync_gradients:
+                        params_to_clip = (
+                            itertools.chain(controlnet.parameters(), text_encoder.parameters())
+                            if args.train_text_encoder
+                            else itertools.chain(
+                                controlnet.parameters(),
+                            )
+                        )
+
+                        accelerator.clip_grad_norm_(params_to_clip, args.max_grad_norm)
+
+                    optimizer.step()
+                    lr_scheduler.step()
+                    optimizer.zero_grad(set_to_none=args.set_grads_to_none)
+
+                # Checks if the accelerator has performed an optimization step behind the scenes
+                if accelerator.sync_gradients:
+                    progress_bar.update(1)
+                    if args.report_to == "wandb":
+                        accelerator.print(progress_bar)
+                    global_step += 1
+
+                    step_save_path = os.path.join(args.output_dir, f"checkpoint-{global_step}")
+
+                    if accelerator.is_main_process:
+                        if global_step % args.validation_steps == 0 or global_step == 1:
+                            logger.info(f"Running validation... \n Generating {args.num_validation_images} images.")
+                            logger.info("Running validation... ")
+
+                            with torch.no_grad():
+                                log_validation(val_dataset, text_encoder, unet, controlnet, args, accelerator)
+
+                        if global_step % args.checkpointing_steps == 0:
+                            save_adaptor(accelerator, step_save_path, {"controlnet": controlnet, "unet": unet})
+
+                            # save text_encoder if any
+                            if args.train_text_encoder:
+                                save_adaptor(accelerator, step_save_path, {"text_encoder": text_encoder})
+
+                            accelerator.save_state(step_save_path)
+
+                            logger.info(f"Saved {global_step} state to {step_save_path}")
+                            logger.info(f"Saved current state to {step_save_path}")
+
+                logs = {"loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0]}
+                progress_bar.set_postfix(**logs)
+                accelerator.log(logs, step=global_step)
+
+                if global_step >= args.max_train_steps:
+                    break
+
+        # Printing the GPU memory usage details such as allocated memory, peak memory, and total memory usage
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Memory before entering the train : {b2mb(tracemalloc.begin)}"
+        )
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Memory consumed at the end of the train (end-begin): {tracemalloc.used}"
+        )
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Peak Memory consumed during the train (max-begin): {tracemalloc.peaked}"
+        )
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Total Peak Memory consumed during the train (max): {tracemalloc.peaked + b2mb(tracemalloc.begin)}"
+        )
+
+        accelerator.print(f"CPU Memory before entering the train : {b2mb(tracemalloc.cpu_begin)}")
+        accelerator.print(f"CPU Memory consumed at the end of the train (end-begin): {tracemalloc.cpu_used}")
+        accelerator.print(f"CPU Peak Memory consumed during the train (max-begin): {tracemalloc.cpu_peaked}")
+        accelerator.print(
+            f"CPU Total Peak Memory consumed during the train (max): {tracemalloc.cpu_peaked + b2mb(tracemalloc.cpu_begin)}"
+        )
+
+    # Create the pipeline using using the trained modules and save it.
+    accelerator.wait_for_everyone()
+    accelerator.end_training()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    main(args)
diff --git a/examples/boft_controlnet/train_controlnet.sh b/examples/boft_controlnet/train_controlnet.sh
new file mode 100755
index 0000000..efad2c4
--- /dev/null
+++ b/examples/boft_controlnet/train_controlnet.sh
@@ -0,0 +1,42 @@
+PEFT_TYPE="boft"
+BLOCK_NUM=8
+BLOCK_SIZE=0
+N_BUTTERFLY_FACTOR=1
+
+export DATASET_NAME="oftverse/control-celeba-hq"
+export PROJECT_NAME="controlnet_${PEFT_TYPE}"
+export RUN_NAME="${PEFT_TYPE}_${BLOCK_NUM}${BLOCK_SIZE}${N_BUTTERFLY_FACTOR}"
+export CONTROLNET_PATH=""
+
+export MODEL_NAME="stabilityai/stable-diffusion-2-1"
+# export MODEL_NAME="runwayml/stable-diffusion-v1-5"
+
+export OUTPUT_DIR="./output/${DATASET_NAME}/${RUN_NAME}"
+
+accelerate launch train_controlnet.py \
+  --pretrained_model_name_or_path=$MODEL_NAME \
+  --resume_from_checkpoint=$RESUME_PATH \
+  --controlnet_model_name_or_path=$CONTROLNET_PATH \
+  --output_dir=$OUTPUT_DIR \
+  --report_to="wandb" \
+  --dataset_name=$DATASET_NAME \
+  --resolution=512 \
+  --learning_rate=1e-5 \
+  --checkpointing_steps=500 \
+  --max_train_steps=50000 \
+  --validation_steps=5000 \
+  --num_validation_images=12 \
+  --train_batch_size=4 \
+  --dataloader_num_workers=2 \
+  --seed="0" \
+  --lr_scheduler="constant" \
+  --lr_warmup_steps=0 \
+  --wandb_project_name=$PROJECT_NAME \
+  --wandb_run_name=$RUN_NAME \
+  --enable_xformers_memory_efficient_attention \
+  --use_boft \
+  --boft_block_num=$BLOCK_NUM \
+  --boft_block_size=$BLOCK_SIZE \
+  --boft_n_butterfly_factor=$N_BUTTERFLY_FACTOR \
+  --boft_dropout=0.1 \
+  --boft_bias="boft_only" \
\ No newline at end of file
diff --git a/examples/boft_controlnet/utils/__init__.py b/examples/boft_controlnet/utils/__init__.py
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/examples/boft_controlnet/utils/__init__.py
@@ -0,0 +1 @@
+
diff --git a/examples/boft_controlnet/utils/args_loader.py b/examples/boft_controlnet/utils/args_loader.py
new file mode 100644
index 0000000..dc1353d
--- /dev/null
+++ b/examples/boft_controlnet/utils/args_loader.py
@@ -0,0 +1,447 @@
+import argparse
+import os
+from typing import Optional
+
+from huggingface_hub import HfFolder, whoami
+from transformers import PretrainedConfig
+
+
+def get_full_repo_name(model_id: str, organization: Optional[str] = None, token: Optional[str] = None):
+    if token is None:
+        token = HfFolder.get_token()
+    if organization is None:
+        username = whoami(token)["name"]
+        return f"{username}/{model_id}"
+    else:
+        return f"{organization}/{model_id}"
+
+
+def import_model_class_from_model_name_or_path(pretrained_model_name_or_path: str, revision: str):
+    text_encoder_config = PretrainedConfig.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="text_encoder",
+        revision=revision,
+    )
+    model_class = text_encoder_config.architectures[0]
+
+    if model_class == "CLIPTextModel":
+        from transformers import CLIPTextModel
+
+        return CLIPTextModel
+    elif model_class == "RobertaSeriesModelWithTransformation":
+        from diffusers.pipelines.alt_diffusion.modeling_roberta_series import (
+            RobertaSeriesModelWithTransformation,
+        )
+
+        return RobertaSeriesModelWithTransformation
+    else:
+        raise ValueError(f"{model_class} is not supported.")
+
+
+def parse_args(input_args=None):
+    parser = argparse.ArgumentParser(description="Simple example of a ControlNet training script.")
+    parser.add_argument(
+        "--pretrained_model_name_or_path",
+        type=str,
+        default=None,
+        required=True,
+        help="Path to pretrained model or model identifier from huggingface.co/models.",
+    )
+    parser.add_argument(
+        "--controlnet_model_name_or_path",
+        type=str,
+        default=None,
+        help="Path to pretrained controlnet model or model identifier from huggingface.co/models."
+        " If not specified controlnet weights are initialized from unet.",
+    )
+    parser.add_argument(
+        "--revision",
+        type=str,
+        default=None,
+        required=False,
+        help=(
+            "Revision of pretrained model identifier from huggingface.co/models. Trainable model components should be"
+            " float32 precision."
+        ),
+    )
+    parser.add_argument(
+        "--tokenizer_name",
+        type=str,
+        default=None,
+        help="Pretrained tokenizer name or path if not the same as model_name",
+    )
+    parser.add_argument(
+        "--output_dir",
+        type=str,
+        default="controlnet-model",
+        help="The output directory where the model predictions and checkpoints will be written.",
+    )
+    parser.add_argument(
+        "--cache_dir",
+        type=str,
+        default=None,
+        help="The directory where the downloaded models and datasets will be stored.",
+    )
+    parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.")
+    parser.add_argument(
+        "--resolution",
+        type=int,
+        default=512,
+        help=(
+            "The resolution for input images, all the images in the train/validation dataset will be resized to this"
+            " resolution"
+        ),
+    )
+    parser.add_argument("--train_text_encoder", action="store_true", help="Whether to train the text encoder")
+
+    parser.add_argument(
+        "--train_batch_size", type=int, default=4, help="Batch size (per device) for the training dataloader."
+    )
+    parser.add_argument(
+        "--sample_batch_size", type=int, default=4, help="Batch size (per device) for sampling images."
+    )
+
+    parser.add_argument("--num_train_epochs", type=int, default=1)
+    parser.add_argument(
+        "--max_train_steps",
+        type=int,
+        default=None,
+        help="Total number of training steps to perform.  If provided, overrides num_train_epochs.",
+    )
+    parser.add_argument(
+        "--checkpointing_steps",
+        type=int,
+        default=500,
+        help=(
+            "Save a checkpoint of the training state every X updates. Checkpoints can be used for resuming training via `--resume_from_checkpoint`. "
+            "In the case that the checkpoint is better than the final trained model, the checkpoint can also be used for inference."
+            "Using a checkpoint for inference requires separate loading of the original pipeline and the individual checkpointed model components."
+            "See https://huggingface.co/docs/diffusers/main/en/training/dreambooth#performing-inference-using-a-saved-checkpoint for step by step"
+            "instructions."
+        ),
+    )
+    parser.add_argument(
+        "--checkpoints_total_limit",
+        type=int,
+        default=None,
+        help=("Max number of checkpoints to store."),
+    )
+    parser.add_argument(
+        "--resume_from_checkpoint",
+        type=str,
+        default=None,
+        help=(
+            "Whether training should be resumed from a previous checkpoint. Use a path saved by"
+            ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.'
+        ),
+    )
+    parser.add_argument(
+        "--gradient_accumulation_steps",
+        type=int,
+        default=1,
+        help="Number of updates steps to accumulate before performing a backward/update pass.",
+    )
+    parser.add_argument(
+        "--gradient_checkpointing",
+        action="store_true",
+        help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.",
+    )
+    parser.add_argument(
+        "--learning_rate",
+        type=float,
+        default=5e-6,
+        help="Initial learning rate (after the potential warmup period) to use.",
+    )
+    parser.add_argument(
+        "--scale_lr",
+        action="store_true",
+        default=False,
+        help="Scale the learning rate by the number of GPUs, gradient accumulation steps, and batch size.",
+    )
+    parser.add_argument(
+        "--lr_scheduler",
+        type=str,
+        default="constant",
+        help=(
+            'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",'
+            ' "constant", "constant_with_warmup"]'
+        ),
+    )
+    parser.add_argument(
+        "--lr_warmup_steps", type=int, default=500, help="Number of steps for the warmup in the lr scheduler."
+    )
+    parser.add_argument(
+        "--lr_num_cycles",
+        type=int,
+        default=1,
+        help="Number of hard resets of the lr in cosine_with_restarts scheduler.",
+    )
+    parser.add_argument("--lr_power", type=float, default=1.0, help="Power factor of the polynomial scheduler.")
+    parser.add_argument(
+        "--use_8bit_adam", action="store_true", help="Whether or not to use 8-bit Adam from bitsandbytes."
+    )
+    parser.add_argument(
+        "--dataloader_num_workers",
+        type=int,
+        default=0,
+        help=(
+            "Number of subprocesses to use for data loading. 0 means that the data will be loaded in the main process."
+        ),
+    )
+    parser.add_argument("--adam_beta1", type=float, default=0.9, help="The beta1 parameter for the Adam optimizer.")
+    parser.add_argument("--adam_beta2", type=float, default=0.999, help="The beta2 parameter for the Adam optimizer.")
+    parser.add_argument("--adam_weight_decay", type=float, default=1e-2, help="Weight decay to use.")
+    parser.add_argument("--adam_epsilon", type=float, default=1e-08, help="Epsilon value for the Adam optimizer")
+    parser.add_argument("--max_grad_norm", default=1.0, type=float, help="Max gradient norm.")
+    parser.add_argument("--push_to_hub", action="store_true", help="Whether or not to push the model to the Hub.")
+    parser.add_argument("--hub_token", type=str, default=None, help="The token to use to push to the Model Hub.")
+    parser.add_argument(
+        "--hub_model_id",
+        type=str,
+        default=None,
+        help="The name of the repository to keep in sync with the local `output_dir`.",
+    )
+    parser.add_argument(
+        "--logging_dir",
+        type=str,
+        default="logs",
+        help=(
+            "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to"
+            " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***."
+        ),
+    )
+    parser.add_argument(
+        "--allow_tf32",
+        action="store_true",
+        help=(
+            "Whether or not to allow TF32 on Ampere GPUs. Can be used to speed up training. For more information, see"
+            " https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices"
+        ),
+    )
+    parser.add_argument(
+        "--report_to",
+        type=str,
+        default="wandb",
+        help=(
+            'The integration to report the results and logs to. Supported platforms are `"tensorboard"`'
+            ' (default), `"wandb"` and `"comet_ml"`. Use `"all"` to report to all integrations.'
+        ),
+    )
+    parser.add_argument(
+        "--wandb_key",
+        type=str,
+        default=None,
+        help=("If report to option is set to wandb, api-key for wandb used for login to wandb "),
+    )
+    parser.add_argument(
+        "--wandb_project_name",
+        type=str,
+        default=None,
+        help=("If report to option is set to wandb, project name in wandb for log tracking  "),
+    )
+    parser.add_argument(
+        "--wandb_run_name",
+        type=str,
+        default=None,
+        help=("If report to option is set to wandb, project name in wandb for log tracking  "),
+    )
+    parser.add_argument(
+        "--mixed_precision",
+        type=str,
+        default=None,
+        choices=["no", "fp16", "bf16"],
+        help=(
+            "Whether to use mixed precision. Choose between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >="
+            " 1.10.and an Nvidia Ampere GPU.  Default to the value of accelerate config of the current system or the"
+            " flag passed with the `accelerate.launch` command. Use this argument to override the accelerate config."
+        ),
+    )
+    parser.add_argument(
+        "--enable_xformers_memory_efficient_attention", action="store_true", help="Whether or not to use xformers."
+    )
+    parser.add_argument(
+        "--set_grads_to_none",
+        action="store_true",
+        help=(
+            "Save more memory by using setting grads to None instead of zero. Be aware, that this changes certain"
+            " behaviors, so disable this argument if it causes any problems. More info:"
+            " https://pytorch.org/docs/stable/generated/torch.optim.Optimizer.zero_grad.html"
+        ),
+    )
+    parser.add_argument(
+        "--dataset_name",
+        type=str,
+        default=None,
+        help=(
+            "The name of the Dataset (from the HuggingFace hub) to train on (could be your own, possibly private,"
+            " dataset). It can also be a path pointing to a local copy of a dataset in your filesystem,"
+            " or to a folder containing files that 🤗 Datasets can understand."
+        ),
+    )
+    parser.add_argument(
+        "--dataset_config_name",
+        type=str,
+        default=None,
+        help="The config of the Dataset, leave as None if there's only one config.",
+    )
+    parser.add_argument(
+        "--train_data_dir",
+        type=str,
+        default=None,
+        help=(
+            "A folder containing the training data. Folder contents must follow the structure described in"
+            " https://huggingface.co/docs/datasets/image_dataset#imagefolder. In particular, a `metadata.jsonl` file"
+            " must exist to provide the captions for the images. Ignored if `dataset_name` is specified."
+        ),
+    )
+    parser.add_argument(
+        "--image_column", type=str, default="image", help="The column of the dataset containing the target image."
+    )
+    parser.add_argument(
+        "--conditioning_image_column",
+        type=str,
+        default="conditioning_image",
+        help="The column of the dataset containing the controlnet conditioning image.",
+    )
+    parser.add_argument(
+        "--caption_column",
+        type=str,
+        default="text",
+        help="The column of the dataset containing a caption or a list of captions.",
+    )
+    parser.add_argument(
+        "--max_train_samples",
+        type=int,
+        default=None,
+        help=(
+            "For debugging purposes or quicker training, truncate the number of training examples to this "
+            "value if set."
+        ),
+    )
+    parser.add_argument(
+        "--proportion_empty_prompts",
+        type=float,
+        default=0,
+        help="Proportion of image prompts to be replaced with empty strings. Defaults to 0 (no prompt replacement).",
+    )
+    parser.add_argument(
+        "--validation_prompt",
+        type=str,
+        default=None,
+        nargs="+",
+        help=(
+            "A set of prompts evaluated every `--validation_steps` and logged to `--report_to`."
+            " Provide either a matching number of `--validation_image`s, a single `--validation_image`"
+            " to be used with all prompts, or a single prompt that will be used with all `--validation_image`s."
+        ),
+    )
+    parser.add_argument(
+        "--validation_image",
+        type=str,
+        default=None,
+        nargs="+",
+        help=(
+            "A set of paths to the controlnet conditioning image be evaluated every `--validation_steps`"
+            " and logged to `--report_to`. Provide either a matching number of `--validation_prompt`s, a"
+            " a single `--validation_prompt` to be used with all `--validation_image`s, or a single"
+            " `--validation_image` that will be used with all `--validation_prompt`s."
+        ),
+    )
+    parser.add_argument(
+        "--num_validation_images",
+        type=int,
+        default=4,
+        help="Number of images to be generated for each `--validation_image`, `--validation_prompt` pair",
+    )
+    parser.add_argument(
+        "--validation_steps",
+        type=int,
+        default=100,
+        help=(
+            "Run validation every X steps. Validation consists of running the prompt"
+            " `args.validation_prompt` multiple times: `args.num_validation_images`"
+            " and logging the images."
+        ),
+    )
+    parser.add_argument(
+        "--tracker_project_name",
+        type=str,
+        default="train_controlnet",
+        help=(
+            "The `project_name` argument passed to Accelerator.init_trackers for"
+            " more information see https://huggingface.co/docs/accelerate/v0.17.0/en/package_reference/accelerator#accelerate.Accelerator"
+        ),
+    )
+
+    # evaluation arguments
+    parser.add_argument("--controlnet_path", type=str, default=None, help="Path to pretrained controlnet.")
+    parser.add_argument("--unet_path", type=str, default=None, help="Path to pretrained unet.")
+    parser.add_argument("--adapter_name", type=str, default=None, help="Name of the adapter to use.")
+    parser.add_argument("--vis_overlays", action="store_true", help="Whether to visualize the landmarks.")
+
+    # self-invented arguments
+
+    parser.add_argument("--local_rank", type=int, default=-1, help="For distributed training: local_rank")
+
+    parser.add_argument(
+        "--name",
+        type=str,
+        help=("The name of the current experiment run, consists of [data]-[prompt]"),
+    )
+
+    # BOFT args
+    parser.add_argument("--use_boft", action="store_true", help="Whether to use BOFT for parameter efficient tuning")
+    parser.add_argument("--boft_block_num", type=int, default=8, help="The number of BOFT blocks")
+    parser.add_argument("--boft_block_size", type=int, default=0, help="The size of BOFT blocks")
+    parser.add_argument("--boft_n_butterfly_factor", type=int, default=0, help="The number of butterfly factors")
+    parser.add_argument("--boft_dropout", type=float, default=0.1, help="BOFT dropout, only used if use_boft is True")
+    parser.add_argument(
+        "--boft_bias",
+        type=str,
+        default="none",
+        help="Bias type for BOFT. Can be 'none', 'all' or 'boft_only', only used if use_boft is True",
+    )
+
+    if input_args is not None:
+        args = parser.parse_args(input_args)
+    else:
+        args = parser.parse_args()
+
+    env_local_rank = int(os.environ.get("LOCAL_RANK", "-1"))
+
+    if env_local_rank != -1 and env_local_rank != args.local_rank:
+        args.local_rank = env_local_rank
+
+    if args.dataset_name is None and args.train_data_dir is None:
+        raise ValueError("Specify either `--dataset_name` or `--train_data_dir`")
+
+    if args.dataset_name is not None and args.train_data_dir is not None:
+        raise ValueError("Specify only one of `--dataset_name` or `--train_data_dir`")
+
+    if args.proportion_empty_prompts < 0 or args.proportion_empty_prompts > 1:
+        raise ValueError("`--proportion_empty_prompts` must be in the range [0, 1].")
+
+    if args.validation_prompt is not None and args.validation_image is None:
+        raise ValueError("`--validation_image` must be set if `--validation_prompt` is set")
+
+    if args.validation_prompt is None and args.validation_image is not None:
+        raise ValueError("`--validation_prompt` must be set if `--validation_image` is set")
+
+    if (
+        args.validation_image is not None
+        and args.validation_prompt is not None
+        and len(args.validation_image) != 1
+        and len(args.validation_prompt) != 1
+        and len(args.validation_image) != len(args.validation_prompt)
+    ):
+        raise ValueError(
+            "Must provide either 1 `--validation_image`, 1 `--validation_prompt`,"
+            " or the same number of `--validation_prompt`s and `--validation_image`s"
+        )
+
+    if args.resolution % 8 != 0:
+        raise ValueError(
+            "`--resolution` must be divisible by 8 for consistently sized encoded images between the VAE and the controlnet encoder."
+        )
+
+    return args
diff --git a/examples/boft_controlnet/utils/dataset.py b/examples/boft_controlnet/utils/dataset.py
new file mode 100644
index 0000000..1de3c8c
--- /dev/null
+++ b/examples/boft_controlnet/utils/dataset.py
@@ -0,0 +1,207 @@
+import random
+
+import numpy as np
+import torch
+import wandb
+from datasets import load_dataset
+from diffusers import DDIMScheduler
+from PIL import Image
+from torchvision import transforms
+from utils.pipeline_controlnet import LightControlNetPipeline
+
+
+def image_grid(imgs, rows, cols):
+    assert len(imgs) == rows * cols
+
+    w, h = imgs[0].size
+    grid = Image.new("RGB", size=(cols * w, rows * h))
+
+    for i, img in enumerate(imgs):
+        grid.paste(img, box=(i % cols * w, i // cols * h))
+    return grid
+
+
+def log_validation(val_dataset, text_encoder, unet, controlnet, args, accelerator):
+    pipeline = LightControlNetPipeline.from_pretrained(
+        args.pretrained_model_name_or_path,
+        controlnet=accelerator.unwrap_model(controlnet, keep_fp32_wrapper=True),
+        unet=accelerator.unwrap_model(unet, keep_fp32_wrapper=True).model,
+        text_encoder=accelerator.unwrap_model(text_encoder, keep_fp32_wrapper=True),
+        safety_checker=None,
+        revision=args.revision,
+    )
+
+    pipeline.scheduler = DDIMScheduler.from_config(pipeline.scheduler.config)
+    pipeline = pipeline.to(accelerator.device)
+
+    pipeline.set_progress_bar_config(disable=True)
+
+    generator = torch.Generator(device=accelerator.device).manual_seed(args.seed)
+
+    image_logs = []
+
+    for idx in range(args.num_validation_images):
+        data = val_dataset[idx]
+        validation_prompt = data["text"]
+        validation_image = data["conditioning_pixel_values"]
+
+        image = pipeline(
+            validation_prompt,
+            [validation_image],
+            num_inference_steps=50,
+            generator=generator,
+        )[0][0]
+
+        image_logs.append(
+            {
+                "validation_image": validation_image,
+                "image": image,
+                "validation_prompt": validation_prompt,
+            }
+        )
+
+    for tracker in accelerator.trackers:
+        formatted_images = []
+
+        for log in image_logs:
+            image = log["image"]
+            validation_prompt = log["validation_prompt"]
+            validation_image = log["validation_image"]
+
+            formatted_images.append(wandb.Image(validation_image, caption="Controlnet conditioning"))
+
+            image = wandb.Image(image, caption=validation_prompt)
+            formatted_images.append(image)
+
+        tracker.log({"validation": formatted_images})
+
+    del pipeline
+    torch.cuda.empty_cache()
+
+
+def make_dataset(args, tokenizer, accelerator, split="train"):
+    # Get the datasets: you can either provide your own training and evaluation files (see below)
+    # or specify a Dataset from the hub (the dataset will be downloaded automatically from the datasets Hub).
+
+    # In distributed training, the load_dataset function guarantees that only one local process can concurrently
+    # download the dataset.
+    if args.dataset_name is not None:
+        # Downloading and loading a dataset from the hub.
+        dataset = load_dataset(
+            args.dataset_name,
+            args.dataset_config_name,
+            cache_dir=args.cache_dir,
+        )
+    else:
+        if args.train_data_dir is not None:
+            dataset = load_dataset(
+                args.train_data_dir,
+                cache_dir=args.cache_dir,
+            )
+        # See more about loading custom images at
+        # https://huggingface.co/docs/datasets/v2.0.0/en/dataset_script
+
+    # Preprocessing the datasets.
+    # We need to tokenize inputs and targets.
+    column_names = dataset[split].column_names
+
+    # Get the column names for input/target.
+    if args.image_column is None:
+        image_column = column_names[0]
+    else:
+        image_column = args.image_column
+        if image_column not in column_names:
+            raise ValueError(
+                f"`--image_column` value '{args.image_column}' not found in dataset columns. Dataset columns are: {', '.join(column_names)}"
+            )
+
+    if args.caption_column is None:
+        caption_column = column_names[1]
+    else:
+        caption_column = args.caption_column
+        if caption_column not in column_names:
+            raise ValueError(
+                f"`--caption_column` value '{args.caption_column}' not found in dataset columns. Dataset columns are: {', '.join(column_names)}"
+            )
+
+    if args.conditioning_image_column is None:
+        conditioning_image_column = column_names[2]
+    else:
+        conditioning_image_column = args.conditioning_image_column
+        if conditioning_image_column not in column_names:
+            raise ValueError(
+                f"`--conditioning_image_column` value '{args.conditioning_image_column}' not found in dataset columns. Dataset columns are: {', '.join(column_names)}"
+            )
+
+    def tokenize_captions(examples, is_train=True):
+        captions = []
+        for caption in examples[caption_column]:
+            if random.random() < args.proportion_empty_prompts:
+                captions.append("")
+            elif isinstance(caption, str):
+                captions.append(caption)
+            elif isinstance(caption, (list, np.ndarray)):
+                # take a random caption if there are multiple
+                captions.append(random.choice(caption) if is_train else caption[0])
+            else:
+                raise ValueError(
+                    f"Caption column `{caption_column}` should contain either strings or lists of strings."
+                )
+        inputs = tokenizer(
+            captions, max_length=tokenizer.model_max_length, padding="max_length", truncation=True, return_tensors="pt"
+        )
+        return inputs.input_ids
+
+    image_transforms = transforms.Compose(
+        [
+            transforms.Resize(args.resolution, interpolation=transforms.InterpolationMode.BILINEAR),
+            transforms.CenterCrop(args.resolution),
+            transforms.ToTensor(),
+            transforms.Normalize([0.5], [0.5]),
+        ]
+    )
+
+    conditioning_image_transforms = transforms.Compose(
+        [
+            transforms.Resize(args.resolution, interpolation=transforms.InterpolationMode.BILINEAR),
+            transforms.CenterCrop(args.resolution),
+            transforms.ToTensor(),
+        ]
+    )
+
+    def preprocess_train(examples):
+        images = [image.convert("RGB") for image in examples[image_column]]
+        images = [image_transforms(image) for image in images]
+
+        conditioning_images = [image.convert("RGB") for image in examples[conditioning_image_column]]
+        conditioning_images = [conditioning_image_transforms(image) for image in conditioning_images]
+
+        examples["pixel_values"] = images
+        examples["conditioning_pixel_values"] = conditioning_images
+        examples["input_ids"] = tokenize_captions(examples)
+
+        return examples
+
+    with accelerator.main_process_first():
+        if args.max_train_samples is not None:
+            dataset[split] = dataset[split].shuffle(seed=args.seed).select(range(args.max_train_samples))
+        # Set the training transforms
+        split_dataset = dataset[split].with_transform(preprocess_train)
+
+    return split_dataset
+
+
+def collate_fn(examples):
+    pixel_values = torch.stack([example["pixel_values"] for example in examples])
+    pixel_values = pixel_values.to(memory_format=torch.contiguous_format).float()
+
+    conditioning_pixel_values = torch.stack([example["conditioning_pixel_values"] for example in examples])
+    conditioning_pixel_values = conditioning_pixel_values.to(memory_format=torch.contiguous_format).float()
+
+    input_ids = torch.stack([example["input_ids"] for example in examples])
+
+    return {
+        "pixel_values": pixel_values,
+        "conditioning_pixel_values": conditioning_pixel_values,
+        "input_ids": input_ids,
+    }
diff --git a/examples/boft_controlnet/utils/light_controlnet.py b/examples/boft_controlnet/utils/light_controlnet.py
new file mode 100644
index 0000000..69919e5
--- /dev/null
+++ b/examples/boft_controlnet/utils/light_controlnet.py
@@ -0,0 +1,263 @@
+# Copyright 2023 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from dataclasses import dataclass
+from typing import Optional, Union
+
+import torch
+from diffusers.configuration_utils import ConfigMixin, register_to_config
+from diffusers.models.attention_processor import AttentionProcessor, AttnProcessor
+from diffusers.models.modeling_utils import ModelMixin
+from diffusers.models.unets.unet_2d_blocks import (
+    CrossAttnDownBlock2D,
+    DownBlock2D,
+)
+from diffusers.utils import BaseOutput, logging
+from torch import nn
+from torch.nn import functional as F
+
+
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
+
+
+@dataclass
+class ControlNetOutput(BaseOutput):
+    down_block_res_samples: tuple[torch.Tensor]
+    mid_block_res_sample: torch.Tensor
+
+
+class ControlNetConditioningEmbedding(nn.Module):
+    """
+    Quoting from https://huggingface.co/papers/2302.05543: "Stable Diffusion uses a pre-processing method similar to VQ-GAN
+    [11] to convert the entire dataset of 512 × 512 images into smaller 64 × 64 “latent images” for stabilized
+    training. This requires ControlNets to convert image-based conditions to 64 × 64 feature space to match the
+    convolution size. We use a tiny network E(·) of four convolution layers with 4 × 4 kernels and 2 × 2 strides
+    (activated by ReLU, channels are 16, 32, 64, 128, initialized with Gaussian weights, trained jointly with the full
+    model) to encode image-space conditions ... into feature maps ..."
+    """
+
+    def __init__(
+        self,
+        conditioning_embedding_channels: int,
+        conditioning_channels: int = 3,
+        block_out_channels: tuple[int] = (16, 32, 96, 256),
+    ):
+        super().__init__()
+
+        self.conv_in = nn.Conv2d(conditioning_channels, block_out_channels[0], kernel_size=3, padding=1)
+
+        self.blocks = nn.ModuleList([])
+
+        for i in range(len(block_out_channels) - 1):
+            channel_in = block_out_channels[i]
+            channel_out = block_out_channels[i + 1]
+            self.blocks.append(nn.Conv2d(channel_in, channel_in, kernel_size=3, padding=1))
+            self.blocks.append(nn.Conv2d(channel_in, channel_out, kernel_size=3, padding=1, stride=2))
+
+        self.conv_out = zero_module(
+            nn.Conv2d(block_out_channels[-1], conditioning_embedding_channels, kernel_size=3, padding=1)
+        )
+
+    def forward(self, conditioning):
+        embedding = self.conv_in(conditioning)
+        embedding = F.silu(embedding)
+
+        for block in self.blocks:
+            embedding = block(embedding)
+            embedding = F.silu(embedding)
+
+        embedding = self.conv_out(embedding)
+
+        return embedding
+
+
+class ControlNetModel(ModelMixin, ConfigMixin):
+    _supports_gradient_checkpointing = True
+
+    @register_to_config
+    def __init__(
+        self,
+        in_channels: int = 4,
+        out_channels: int = 320,
+        controlnet_conditioning_channel_order: str = "rgb",
+        conditioning_embedding_out_channels: Optional[tuple[int]] = (16, 32, 96, 256),
+    ):
+        super().__init__()
+
+        # for control image
+        self.controlnet_cond_embedding = ControlNetConditioningEmbedding(
+            conditioning_embedding_channels=out_channels,
+            block_out_channels=conditioning_embedding_out_channels,
+        )
+
+    @property
+    # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.attn_processors
+    def attn_processors(self) -> dict[str, AttentionProcessor]:
+        r"""
+        Returns:
+            `dict` of attention processors: A dictionary containing all attention processors used in the model with
+            indexed by its weight name.
+        """
+        # set recursively
+        processors = {}
+
+        def fn_recursive_add_processors(name: str, module: torch.nn.Module, processors: dict[str, AttentionProcessor]):
+            if hasattr(module, "set_processor"):
+                processors[f"{name}.processor"] = module.processor
+
+            for sub_name, child in module.named_children():
+                fn_recursive_add_processors(f"{name}.{sub_name}", child, processors)
+
+            return processors
+
+        for name, module in self.named_children():
+            fn_recursive_add_processors(name, module, processors)
+
+        return processors
+
+    # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.set_attn_processor
+    def set_attn_processor(self, processor: Union[AttentionProcessor, dict[str, AttentionProcessor]]):
+        r"""
+        Parameters:
+            `processor (`dict` of `AttentionProcessor` or `AttentionProcessor`):
+                The instantiated processor class or a dictionary of processor classes that will be set as the processor
+                of **all** `Attention` layers.
+            In case `processor` is a dict, the key needs to define the path to the corresponding cross attention processor. This is strongly recommended when setting trainable attention processors.:
+
+        """
+        count = len(self.attn_processors.keys())
+
+        if isinstance(processor, dict) and len(processor) != count:
+            raise ValueError(
+                f"A dict of processors was passed, but the number of processors {len(processor)} does not match the"
+                f" number of attention layers: {count}. Please make sure to pass {count} processor classes."
+            )
+
+        def fn_recursive_attn_processor(name: str, module: torch.nn.Module, processor):
+            if hasattr(module, "set_processor"):
+                if not isinstance(processor, dict):
+                    module.set_processor(processor)
+                else:
+                    module.set_processor(processor.pop(f"{name}.processor"))
+
+            for sub_name, child in module.named_children():
+                fn_recursive_attn_processor(f"{name}.{sub_name}", child, processor)
+
+        for name, module in self.named_children():
+            fn_recursive_attn_processor(name, module, processor)
+
+    # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.set_default_attn_processor
+    def set_default_attn_processor(self):
+        """
+        Disables custom attention processors and sets the default attention implementation.
+        """
+        self.set_attn_processor(AttnProcessor())
+
+    # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.set_attention_slice
+    def set_attention_slice(self, slice_size):
+        r"""
+        Enable sliced attention computation.
+
+        When this option is enabled, the attention module will split the input tensor in slices, to compute attention
+        in several steps. This is useful to save some memory in exchange for a small speed decrease.
+
+        Args:
+            slice_size (`str` or `int` or `list(int)`, *optional*, defaults to `"auto"`):
+                When `"auto"`, halves the input to the attention heads, so attention will be computed in two steps. If
+                `"max"`, maximum amount of memory will be saved by running only one slice at a time. If a number is
+                provided, uses as many slices as `attention_head_dim // slice_size`. In this case, `attention_head_dim`
+                must be a multiple of `slice_size`.
+        """
+        sliceable_head_dims = []
+
+        def fn_recursive_retrieve_sliceable_dims(module: torch.nn.Module):
+            if hasattr(module, "set_attention_slice"):
+                sliceable_head_dims.append(module.sliceable_head_dim)
+
+            for child in module.children():
+                fn_recursive_retrieve_sliceable_dims(child)
+
+        # retrieve number of attention layers
+        for module in self.children():
+            fn_recursive_retrieve_sliceable_dims(module)
+
+        num_sliceable_layers = len(sliceable_head_dims)
+
+        if slice_size == "auto":
+            # half the attention head size is usually a good trade-off between
+            # speed and memory
+            slice_size = [dim // 2 for dim in sliceable_head_dims]
+        elif slice_size == "max":
+            # make smallest slice possible
+            slice_size = num_sliceable_layers * [1]
+
+        slice_size = num_sliceable_layers * [slice_size] if not isinstance(slice_size, list) else slice_size
+
+        if len(slice_size) != len(sliceable_head_dims):
+            raise ValueError(
+                f"You have provided {len(slice_size)}, but {self.config} has {len(sliceable_head_dims)} different"
+                f" attention layers. Make sure to match `len(slice_size)` to be {len(sliceable_head_dims)}."
+            )
+
+        for i in range(len(slice_size)):
+            size = slice_size[i]
+            dim = sliceable_head_dims[i]
+            if size is not None and size > dim:
+                raise ValueError(f"size {size} has to be smaller or equal to {dim}.")
+
+        # Recursively walk through all the children.
+        # Any children which exposes the set_attention_slice method
+        # gets the message
+        def fn_recursive_set_attention_slice(module: torch.nn.Module, slice_size: list[int]):
+            if hasattr(module, "set_attention_slice"):
+                module.set_attention_slice(slice_size.pop())
+
+            for child in module.children():
+                fn_recursive_set_attention_slice(child, slice_size)
+
+        reversed_slice_size = list(reversed(slice_size))
+        for module in self.children():
+            fn_recursive_set_attention_slice(module, reversed_slice_size)
+
+    def _set_gradient_checkpointing(self, module, value=False):
+        if isinstance(module, (CrossAttnDownBlock2D, DownBlock2D)):
+            module.gradient_checkpointing = value
+
+    def forward(
+        self,
+        controlnet_cond: torch.FloatTensor,
+    ) -> Union[ControlNetOutput, tuple]:
+        # check channel order
+        channel_order = self.config.controlnet_conditioning_channel_order
+
+        if channel_order == "rgb":
+            # in rgb order by default
+            ...
+        elif channel_order == "bgr":
+            controlnet_cond = torch.flip(controlnet_cond, dims=[1])
+        else:
+            raise ValueError(f"unknown `controlnet_conditioning_channel_order`: {channel_order}")
+
+        # 2. pre-process
+
+        controlnet_cond = self.controlnet_cond_embedding(controlnet_cond)
+
+        return controlnet_cond
+
+
+def zero_module(module):
+    for p in module.parameters():
+        nn.init.zeros_(p)
+    return module
diff --git a/examples/boft_controlnet/utils/pipeline_controlnet.py b/examples/boft_controlnet/utils/pipeline_controlnet.py
new file mode 100644
index 0000000..b2bd274
--- /dev/null
+++ b/examples/boft_controlnet/utils/pipeline_controlnet.py
@@ -0,0 +1,456 @@
+# Copyright 2023 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any, Optional, Union
+
+import numpy as np
+import PIL.Image
+import torch
+from diffusers.pipelines.controlnet.multicontrolnet import MultiControlNetModel
+from diffusers.pipelines.controlnet.pipeline_controlnet import StableDiffusionControlNetPipeline
+from diffusers.utils import BaseOutput, logging
+from torch.nn import functional as F
+from utils.light_controlnet import ControlNetModel
+
+
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
+
+
+@dataclass
+class LightControlNetPipelineOutput(BaseOutput):
+    """
+    Output class for Stable Diffusion pipelines.
+
+    Args:
+        images (`List[PIL.Image.Image]` or `np.ndarray`)
+            List of denoised PIL images of length `batch_size` or numpy array of shape `(batch_size, height, width,
+            num_channels)`. PIL images or numpy array present the denoised images of the diffusion pipeline.
+        nsfw_content_detected (`List[bool]`)
+            List of flags denoting whether the corresponding generated image likely represents "not-safe-for-work"
+            (nsfw) content, or `None` if safety checking could not be performed.
+    """
+
+    images: Union[list[PIL.Image.Image], np.ndarray]
+    nsfw_content_detected: Optional[list[bool]]
+
+
+class LightControlNetPipeline(StableDiffusionControlNetPipeline):
+    _optional_components = ["safety_checker", "feature_extractor"]
+
+    def check_inputs(
+        self,
+        prompt,
+        image,
+        callback_steps,
+        negative_prompt=None,
+        prompt_embeds=None,
+        negative_prompt_embeds=None,
+        controlnet_conditioning_scale=1.0,
+    ):
+        if (callback_steps is None) or (
+            callback_steps is not None and (not isinstance(callback_steps, int) or callback_steps <= 0)
+        ):
+            raise ValueError(
+                f"`callback_steps` has to be a positive integer but is {callback_steps} of type"
+                f" {type(callback_steps)}."
+            )
+
+        if prompt is not None and prompt_embeds is not None:
+            raise ValueError(
+                f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to"
+                " only forward one of the two."
+            )
+        elif prompt is None and prompt_embeds is None:
+            raise ValueError(
+                "Provide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined."
+            )
+        elif prompt is not None and (not isinstance(prompt, str) and not isinstance(prompt, list)):
+            raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
+
+        if negative_prompt is not None and negative_prompt_embeds is not None:
+            raise ValueError(
+                f"Cannot forward both `negative_prompt`: {negative_prompt} and `negative_prompt_embeds`:"
+                f" {negative_prompt_embeds}. Please make sure to only forward one of the two."
+            )
+
+        if prompt_embeds is not None and negative_prompt_embeds is not None:
+            if prompt_embeds.shape != negative_prompt_embeds.shape:
+                raise ValueError(
+                    "`prompt_embeds` and `negative_prompt_embeds` must have the same shape when passed directly, but"
+                    f" got: `prompt_embeds` {prompt_embeds.shape} != `negative_prompt_embeds`"
+                    f" {negative_prompt_embeds.shape}."
+                )
+
+        # `prompt` needs more sophisticated handling when there are multiple
+        # conditionings.
+        if isinstance(self.controlnet, MultiControlNetModel):
+            if isinstance(prompt, list):
+                logger.warning(
+                    f"You have {len(self.controlnet.nets)} ControlNets and you have passed {len(prompt)}"
+                    " prompts. The conditionings will be fixed across the prompts."
+                )
+
+        # Check `image`
+        is_compiled = hasattr(F, "scaled_dot_product_attention") and isinstance(
+            self.controlnet, torch._dynamo.eval_frame.OptimizedModule
+        )
+
+        if (
+            isinstance(self.controlnet, ControlNetModel)
+            or is_compiled
+            and isinstance(self.controlnet._orig_mod, ControlNetModel)
+        ):
+            self.check_image(image, prompt, prompt_embeds)
+        elif (
+            isinstance(self.controlnet, MultiControlNetModel)
+            or is_compiled
+            and isinstance(self.controlnet._orig_mod, MultiControlNetModel)
+        ):
+            if not isinstance(image, list):
+                raise TypeError("For multiple controlnets: `image` must be type `list`")
+
+            # When `image` is a nested list:
+            # (e.g. [[canny_image_1, pose_image_1], [canny_image_2, pose_image_2]])
+            elif any(isinstance(i, list) for i in image):
+                raise ValueError("A single batch of multiple conditionings are supported at the moment.")
+            elif len(image) != len(self.controlnet.nets):
+                raise ValueError(
+                    "For multiple controlnets: `image` must have the same length as the number of controlnets."
+                )
+
+            for image_ in image:
+                self.check_image(image_, prompt, prompt_embeds)
+        else:
+            assert False
+
+        # Check `controlnet_conditioning_scale`
+        if (
+            isinstance(self.controlnet, ControlNetModel)
+            or is_compiled
+            and isinstance(self.controlnet._orig_mod, ControlNetModel)
+        ):
+            if not isinstance(controlnet_conditioning_scale, float):
+                raise TypeError("For single controlnet: `controlnet_conditioning_scale` must be type `float`.")
+        elif (
+            isinstance(self.controlnet, MultiControlNetModel)
+            or is_compiled
+            and isinstance(self.controlnet._orig_mod, MultiControlNetModel)
+        ):
+            if isinstance(controlnet_conditioning_scale, list):
+                if any(isinstance(i, list) for i in controlnet_conditioning_scale):
+                    raise ValueError("A single batch of multiple conditionings are supported at the moment.")
+            elif isinstance(controlnet_conditioning_scale, list) and len(controlnet_conditioning_scale) != len(
+                self.controlnet.nets
+            ):
+                raise ValueError(
+                    "For multiple controlnets: When `controlnet_conditioning_scale` is specified as `list`, it must have"
+                    " the same length as the number of controlnets"
+                )
+        else:
+            assert False
+
+    @torch.no_grad()
+    def __call__(
+        self,
+        prompt: Optional[Union[str, list[str]]] = None,
+        image: Union[
+            torch.FloatTensor,
+            PIL.Image.Image,
+            np.ndarray,
+            list[torch.FloatTensor],
+            list[PIL.Image.Image],
+            list[np.ndarray],
+        ] = None,
+        height: Optional[int] = None,
+        width: Optional[int] = None,
+        num_inference_steps: int = 50,
+        guidance_scale: float = 7.5,
+        negative_prompt: Optional[Union[str, list[str]]] = None,
+        num_images_per_prompt: Optional[int] = 1,
+        eta: float = 0.0,
+        generator: Optional[Union[torch.Generator, list[torch.Generator]]] = None,
+        latents: Optional[torch.FloatTensor] = None,
+        prompt_embeds: Optional[torch.FloatTensor] = None,
+        negative_prompt_embeds: Optional[torch.FloatTensor] = None,
+        output_type: Optional[str] = "pil",
+        return_dict: bool = True,
+        callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,
+        callback_steps: int = 1,
+        cross_attention_kwargs: Optional[dict[str, Any]] = None,
+        controlnet_conditioning_scale: Union[float, list[float]] = 1.0,
+        guess_mode: bool = False,
+    ):
+        r"""
+        Function invoked when calling the pipeline for generation.
+
+        Args:
+            prompt (`str` or `List[str]`, *optional*):
+                The prompt or prompts to guide the image generation. If not defined, one has to pass `prompt_embeds`.
+                instead.
+            image (`torch.FloatTensor`, `PIL.Image.Image`, `np.ndarray`, `List[torch.FloatTensor]`, `List[PIL.Image.Image]`, `List[np.ndarray]`,:
+                    `List[List[torch.FloatTensor]]`, `List[List[np.ndarray]]` or `List[List[PIL.Image.Image]]`):
+                The ControlNet input condition. ControlNet uses this input condition to generate guidance to Unet. If
+                the type is specified as `Torch.FloatTensor`, it is passed to ControlNet as is. `PIL.Image.Image` can
+                also be accepted as an image. The dimensions of the output image defaults to `image`'s dimensions. If
+                height and/or width are passed, `image` is resized according to them. If multiple ControlNets are
+                specified in init, images must be passed as a list such that each element of the list can be correctly
+                batched for input to a single controlnet.
+            height (`int`, *optional*, defaults to self.unet.config.sample_size * self.vae_scale_factor):
+                The height in pixels of the generated image.
+            width (`int`, *optional*, defaults to self.unet.config.sample_size * self.vae_scale_factor):
+                The width in pixels of the generated image.
+            num_inference_steps (`int`, *optional*, defaults to 50):
+                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
+                expense of slower inference.
+            guidance_scale (`float`, *optional*, defaults to 7.5):
+                Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598).
+                `guidance_scale` is defined as `w` of equation 2. of [Imagen
+                Paper](https://huggingface.co/papers/2205.11487). Guidance scale is enabled by setting `guidance_scale >
+                1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`,
+                usually at the expense of lower image quality.
+            negative_prompt (`str` or `List[str]`, *optional*):
+                The prompt or prompts not to guide the image generation. If not defined, one has to pass
+                `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is
+                less than `1`).
+            num_images_per_prompt (`int`, *optional*, defaults to 1):
+                The number of images to generate per prompt.
+            eta (`float`, *optional*, defaults to 0.0):
+                Corresponds to parameter eta (η) in the DDIM paper: https://huggingface.co/papers/2010.02502. Only applies to
+                [`schedulers.DDIMScheduler`], will be ignored for others.
+            generator (`torch.Generator` or `List[torch.Generator]`, *optional*):
+                One or a list of [torch generator(s)](https://pytorch.org/docs/stable/generated/torch.Generator.html)
+                to make generation deterministic.
+            latents (`torch.FloatTensor`, *optional*):
+                Pre-generated noisy latents, sampled from a Gaussian distribution, to be used as inputs for image
+                generation. Can be used to tweak the same generation with different prompts. If not provided, a latents
+                tensor will ge generated by sampling using the supplied random `generator`.
+            prompt_embeds (`torch.FloatTensor`, *optional*):
+                Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not
+                provided, text embeddings will be generated from `prompt` input argument.
+            negative_prompt_embeds (`torch.FloatTensor`, *optional*):
+                Pre-generated negative text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt
+                weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input
+                argument.
+            output_type (`str`, *optional*, defaults to `"pil"`):
+                The output format of the generate image. Choose between
+                [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`.
+            return_dict (`bool`, *optional*, defaults to `True`):
+                Whether or not to return a [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] instead of a
+                plain tuple.
+            callback (`Callable`, *optional*):
+                A function that will be called every `callback_steps` steps during inference. The function will be
+                called with the following arguments: `callback(step: int, timestep: int, latents: torch.FloatTensor)`.
+            callback_steps (`int`, *optional*, defaults to 1):
+                The frequency at which the `callback` function will be called. If not specified, the callback will be
+                called at every step.
+            cross_attention_kwargs (`dict`, *optional*):
+                A kwargs dictionary that if specified is passed along to the `AttentionProcessor` as defined under
+                `self.processor` in
+                [diffusers.cross_attention](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/cross_attention.py).
+            controlnet_conditioning_scale (`float` or `List[float]`, *optional*, defaults to 1.0):
+                The outputs of the controlnet are multiplied by `controlnet_conditioning_scale` before they are added
+                to the residual in the original unet. If multiple ControlNets are specified in init, you can set the
+                corresponding scale as a list.
+            guess_mode (`bool`, *optional*, defaults to `False`):
+                In this mode, the ControlNet encoder will try best to recognize the content of the input image even if
+                you remove all prompts. The `guidance_scale` between 3.0 and 5.0 is recommended.
+
+        Examples:
+
+        Returns:
+            [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] or `tuple`:
+            [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] if `return_dict` is True, otherwise a `tuple.
+            When returning a tuple, the first element is a list with the generated images, and the second element is a
+            list of `bool`s denoting whether the corresponding generated image likely represents "not-safe-for-work"
+            (nsfw) content, according to the `safety_checker`.
+        """
+
+        # 1. Check inputs. Raise error if not correct
+        self.check_inputs(
+            prompt,
+            image,
+            callback_steps,
+            negative_prompt,
+            prompt_embeds,
+            negative_prompt_embeds,
+            controlnet_conditioning_scale,
+        )
+
+        # 2. Define call parameters
+        if prompt is not None and isinstance(prompt, str):
+            batch_size = 1
+        elif prompt is not None and isinstance(prompt, list):
+            batch_size = len(prompt)
+        else:
+            batch_size = prompt_embeds.shape[0]
+
+        device = self._execution_device
+        # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
+        # of the Imagen paper: https://huggingface.co/papers/2205.11487 . `guidance_scale = 1`
+        # corresponds to doing no classifier free guidance.
+        do_classifier_free_guidance = guidance_scale > 1.0
+
+        controlnet = self.controlnet._orig_mod if hasattr(self.controlnet, "_orig_mod") else self.controlnet
+
+        if isinstance(controlnet, MultiControlNetModel) and isinstance(controlnet_conditioning_scale, float):
+            controlnet_conditioning_scale = [controlnet_conditioning_scale] * len(controlnet.nets)
+
+        # 3. Encode input prompt
+        text_encoder_lora_scale = (
+            cross_attention_kwargs.get("scale", None) if cross_attention_kwargs is not None else None
+        )
+        prompt_embeds = self._encode_prompt(
+            prompt,
+            device,
+            num_images_per_prompt,
+            do_classifier_free_guidance,
+            negative_prompt,
+            prompt_embeds=prompt_embeds,
+            negative_prompt_embeds=negative_prompt_embeds,
+            lora_scale=text_encoder_lora_scale,
+        )
+
+        # 4. Prepare image
+        if isinstance(controlnet, ControlNetModel):
+            image = self.prepare_image(
+                image=image,
+                width=width,
+                height=height,
+                batch_size=batch_size * num_images_per_prompt,
+                num_images_per_prompt=num_images_per_prompt,
+                device=device,
+                dtype=controlnet.dtype,
+                do_classifier_free_guidance=do_classifier_free_guidance,
+                guess_mode=guess_mode,
+            )
+            height, width = image.shape[-2:]
+        elif isinstance(controlnet, MultiControlNetModel):
+            images = []
+
+            for image_ in image:
+                image_ = self.prepare_image(
+                    image=image_,
+                    width=width,
+                    height=height,
+                    batch_size=batch_size * num_images_per_prompt,
+                    num_images_per_prompt=num_images_per_prompt,
+                    device=device,
+                    dtype=controlnet.dtype,
+                    do_classifier_free_guidance=do_classifier_free_guidance,
+                    guess_mode=guess_mode,
+                )
+
+                images.append(image_)
+
+            image = images
+            height, width = image[0].shape[-2:]
+        else:
+            assert False
+
+        # 5. Prepare timesteps
+        self.scheduler.set_timesteps(num_inference_steps, device=device)
+        timesteps = self.scheduler.timesteps
+
+        # 6. Prepare latent variables
+        num_channels_latents = self.unet.config.in_channels
+        latents = self.prepare_latents(
+            batch_size * num_images_per_prompt,
+            num_channels_latents,
+            height,
+            width,
+            prompt_embeds.dtype,
+            device,
+            generator,
+            latents,
+        )
+
+        # 7. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline
+        extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)
+
+        # 8. Denoising loop
+        num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order
+        with self.progress_bar(total=num_inference_steps) as progress_bar:
+            for i, t in enumerate(timesteps):
+                # expand the latents if we are doing classifier free guidance
+                latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents
+                latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)
+
+                # controlnet(s) inference
+                if guess_mode and do_classifier_free_guidance:
+                    # Infer ControlNet only for the conditional batch.
+                    control_model_input = latents
+                    control_model_input = self.scheduler.scale_model_input(control_model_input, t)
+                else:
+                    control_model_input = latent_model_input
+
+                # Get the guided hint for the UNet (320 dim)
+                guided_hint = self.controlnet(
+                    controlnet_cond=image,
+                )
+
+                # Predict the noise residual
+                noise_pred = self.unet(
+                    latent_model_input,
+                    t,
+                    guided_hint=guided_hint,
+                    encoder_hidden_states=prompt_embeds,
+                )[0]
+
+                # perform guidance
+                if do_classifier_free_guidance:
+                    noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
+                    noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
+
+                # compute the previous noisy sample x_t -> x_t-1
+                latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0]
+                # call the callback, if provided
+                if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):
+                    progress_bar.update()
+                    if callback is not None and i % callback_steps == 0:
+                        callback(i, t, latents)
+
+        # If we do sequential model offloading, let's offload unet and controlnet
+        # manually for max memory savings
+        if hasattr(self, "final_offload_hook") and self.final_offload_hook is not None:
+            self.unet.to("cpu")
+            self.controlnet.to("cpu")
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+            elif torch.xpu.is_available():
+                torch.xpu.empty_cache()
+
+        if output_type != "latent":
+            image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False)[0]
+            image, has_nsfw_concept = self.run_safety_checker(image, device, prompt_embeds.dtype)
+        else:
+            image = latents
+            has_nsfw_concept = None
+
+        if has_nsfw_concept is None:
+            do_denormalize = [True] * image.shape[0]
+        else:
+            do_denormalize = [not has_nsfw for has_nsfw in has_nsfw_concept]
+
+        image = self.image_processor.postprocess(image, output_type=output_type, do_denormalize=do_denormalize)
+
+        # Offload last model to CPU
+        if hasattr(self, "final_offload_hook") and self.final_offload_hook is not None:
+            self.final_offload_hook.offload()
+
+        if not return_dict:
+            return (image, has_nsfw_concept)
+
+        return LightControlNetPipelineOutput(images=image, nsfw_content_detected=has_nsfw_concept)
diff --git a/examples/boft_controlnet/utils/tracemalloc.py b/examples/boft_controlnet/utils/tracemalloc.py
new file mode 100644
index 0000000..26ba300
--- /dev/null
+++ b/examples/boft_controlnet/utils/tracemalloc.py
@@ -0,0 +1,60 @@
+import gc
+import threading
+
+import psutil
+import torch
+
+
+# Converting Bytes to Megabytes
+def b2mb(x):
+    return int(x / 2**20)
+
+
+# This context manager is used to track the peak memory usage of the process
+class TorchTracemalloc:
+    def __enter__(self):
+        self.device_type = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+        self.device_module = getattr(torch, self.device_type, torch.cuda)
+        gc.collect()
+        self.device_module.empty_cache()
+        self.device_module.reset_peak_memory_stats()  # reset the peak gauge to zero
+        self.begin = self.device_module.memory_allocated()
+        self.process = psutil.Process()
+
+        self.cpu_begin = self.cpu_mem_used()
+        self.peak_monitoring = True
+        peak_monitor_thread = threading.Thread(target=self.peak_monitor_func)
+        peak_monitor_thread.daemon = True
+        peak_monitor_thread.start()
+        return self
+
+    def cpu_mem_used(self):
+        """get resident set size memory for the current process"""
+        return self.process.memory_info().rss
+
+    def peak_monitor_func(self):
+        self.cpu_peak = -1
+
+        while True:
+            self.cpu_peak = max(self.cpu_mem_used(), self.cpu_peak)
+
+            # can't sleep or will not catch the peak right (this comment is here on purpose)
+            # time.sleep(0.001) # 1msec
+
+            if not self.peak_monitoring:
+                break
+
+    def __exit__(self, *exc):
+        self.peak_monitoring = False
+
+        gc.collect()
+        self.device_module.empty_cache()
+        self.end = self.device_module.memory_allocated()
+        self.peak = self.device_module.max_memory_allocated()
+        self.used = b2mb(self.end - self.begin)
+        self.peaked = b2mb(self.peak - self.begin)
+
+        self.cpu_end = self.cpu_mem_used()
+        self.cpu_used = b2mb(self.cpu_end - self.cpu_begin)
+        self.cpu_peaked = b2mb(self.cpu_peak - self.cpu_begin)
+        # print(f"delta used/peak {self.used:4d}/{self.peaked:4d}")
diff --git a/examples/boft_controlnet/utils/unet_2d_condition.py b/examples/boft_controlnet/utils/unet_2d_condition.py
new file mode 100644
index 0000000..c6db71c
--- /dev/null
+++ b/examples/boft_controlnet/utils/unet_2d_condition.py
@@ -0,0 +1,277 @@
+# Copyright 2023 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass
+from typing import Any, Optional, Union
+
+import torch
+from diffusers.models import UNet2DConditionModel
+from diffusers.utils import BaseOutput, logging
+
+
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
+
+
+@dataclass
+class UNet2DConditionOutput(BaseOutput):
+    """
+    Args:
+        sample (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
+            Hidden states conditioned on `encoder_hidden_states` input. Output of last layer of model.
+    """
+
+    sample: torch.FloatTensor
+
+
+class UNet2DConditionNewModel(UNet2DConditionModel):
+    def forward(
+        self,
+        sample: torch.FloatTensor,
+        timestep: Union[torch.Tensor, float],
+        encoder_hidden_states: torch.Tensor,
+        guided_hint: Optional[torch.Tensor] = None,
+        class_labels: Optional[torch.Tensor] = None,
+        timestep_cond: Optional[torch.Tensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        cross_attention_kwargs: Optional[dict[str, Any]] = None,
+        added_cond_kwargs: Optional[dict[str, torch.Tensor]] = None,
+        down_block_additional_residuals: Optional[tuple[torch.Tensor]] = None,
+        mid_block_additional_residual: Optional[torch.Tensor] = None,
+        encoder_attention_mask: Optional[torch.Tensor] = None,
+        return_dict: bool = True,
+    ) -> Union[UNet2DConditionOutput, tuple]:
+        r"""
+        Args:
+            sample (`torch.FloatTensor`): (batch, channel, height, width) noisy inputs tensor
+            timestep (`torch.FloatTensor` or `float` or `int`): (batch) timesteps
+            encoder_hidden_states (`torch.FloatTensor`): (batch, sequence_length, feature_dim) encoder hidden states
+            encoder_attention_mask (`torch.Tensor`):
+                (batch, sequence_length) cross-attention mask, applied to encoder_hidden_states. True = keep, False =
+                discard. Mask will be converted into a bias, which adds large negative values to attention scores
+                corresponding to "discard" tokens.
+            return_dict (`bool`, *optional*, defaults to `True`):
+                Whether or not to return a [`models.unet_2d_condition.UNet2DConditionOutput`] instead of a plain tuple.
+            cross_attention_kwargs (`dict`, *optional*):
+                A kwargs dictionary that if specified is passed along to the `AttentionProcessor` as defined under
+                `self.processor` in
+                [diffusers.cross_attention](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/cross_attention.py).
+            added_cond_kwargs (`dict`, *optional*):
+                A kwargs dictionary that if specified includes additonal conditions that can be used for additonal time
+                embeddings or encoder hidden states projections. See the configurations `encoder_hid_dim_type` and
+                `addition_embed_type` for more information.
+
+        Returns:
+            [`~models.unet_2d_condition.UNet2DConditionOutput`] or `tuple`:
+            [`~models.unet_2d_condition.UNet2DConditionOutput`] if `return_dict` is True, otherwise a `tuple`. When
+            returning a tuple, the first element is the sample tensor.
+        """
+        # By default samples have to be AT least a multiple of the overall upsampling factor.
+        # The overall upsampling factor is equal to 2 ** (# num of upsampling layers).
+        # However, the upsampling interpolation output size can be forced to fit any upsampling size
+        # on the fly if necessary.
+        default_overall_up_factor = 2**self.num_upsamplers
+
+        # upsample size should be forwarded when sample is not a multiple of `default_overall_up_factor`
+        forward_upsample_size = False
+        upsample_size = None
+
+        if any(s % default_overall_up_factor != 0 for s in sample.shape[-2:]):
+            logger.info("Forward upsample size to force interpolation output size.")
+            forward_upsample_size = True
+
+        # ensure attention_mask is a bias, and give it a singleton query_tokens dimension
+        # expects mask of shape:
+        #   [batch, key_tokens]
+        # adds singleton query_tokens dimension:
+        #   [batch,                    1, key_tokens]
+        # this helps to broadcast it as a bias over attention scores, which will be in one of the following shapes:
+        #   [batch,  heads, query_tokens, key_tokens] (e.g. torch sdp attn)
+        #   [batch * heads, query_tokens, key_tokens] (e.g. xformers or classic attn)
+        if attention_mask is not None:
+            # assume that mask is expressed as:
+            #   (1 = keep,      0 = discard)
+            # convert mask into a bias that can be added to attention scores:
+            #       (keep = +0,     discard = -10000.0)
+            attention_mask = (1 - attention_mask.to(sample.dtype)) * -10000.0
+            attention_mask = attention_mask.unsqueeze(1)
+
+        # convert encoder_attention_mask to a bias the same way we do for attention_mask
+        if encoder_attention_mask is not None:
+            encoder_attention_mask = (1 - encoder_attention_mask.to(sample.dtype)) * -10000.0
+            encoder_attention_mask = encoder_attention_mask.unsqueeze(1)
+
+        # 0. center input if necessary
+        if self.config.center_input_sample:
+            sample = 2 * sample - 1.0
+
+        # 1. time
+        timesteps = timestep
+        if not torch.is_tensor(timesteps):
+            # TODO: this requires sync between CPU and GPU. So try to pass timesteps as tensors if you can
+            # This would be a good case for the `match` statement (Python 3.10+)
+            is_mps = sample.device.type == "mps"
+            if isinstance(timestep, float):
+                dtype = torch.float32 if is_mps else torch.float64
+            else:
+                dtype = torch.int32 if is_mps else torch.int64
+            timesteps = torch.tensor([timesteps], dtype=dtype, device=sample.device)
+        elif len(timesteps.shape) == 0:
+            timesteps = timesteps[None].to(sample.device)
+
+        # broadcast to batch dimension in a way that's compatible with ONNX/Core ML
+        timesteps = timesteps.expand(sample.shape[0])
+
+        t_emb = self.time_proj(timesteps)
+
+        # `Timesteps` does not contain any weights and will always return f32 tensors
+        # but time_embedding might actually be running in fp16. so we need to cast here.
+        # there might be better ways to encapsulate this.
+        t_emb = t_emb.to(dtype=sample.dtype)
+
+        emb = self.time_embedding(t_emb, timestep_cond)
+
+        if self.class_embedding is not None:
+            if class_labels is None:
+                raise ValueError("class_labels should be provided when num_class_embeds > 0")
+
+            if self.config.class_embed_type == "timestep":
+                class_labels = self.time_proj(class_labels)
+
+                # `Timesteps` does not contain any weights and will always return f32 tensors
+                # there might be better ways to encapsulate this.
+                class_labels = class_labels.to(dtype=sample.dtype)
+
+            class_emb = self.class_embedding(class_labels).to(dtype=sample.dtype)
+
+            if self.config.class_embeddings_concat:
+                emb = torch.cat([emb, class_emb], dim=-1)
+            else:
+                emb = emb + class_emb
+
+        if self.config.addition_embed_type == "text":
+            aug_emb = self.add_embedding(encoder_hidden_states)
+            emb = emb + aug_emb
+        elif self.config.addition_embed_type == "text_image":
+            # Kadinsky 2.1 - style
+            if "image_embeds" not in added_cond_kwargs:
+                raise ValueError(
+                    f"{self.__class__} has the config param `addition_embed_type` set to 'text_image' which requires the keyword argument `image_embeds` to be passed in `added_cond_kwargs`"
+                )
+
+            image_embs = added_cond_kwargs.get("image_embeds")
+            text_embs = added_cond_kwargs.get("text_embeds", encoder_hidden_states)
+
+            aug_emb = self.add_embedding(text_embs, image_embs)
+            emb = emb + aug_emb
+
+        if self.time_embed_act is not None:
+            emb = self.time_embed_act(emb)
+
+        if self.encoder_hid_proj is not None and self.config.encoder_hid_dim_type == "text_proj":
+            encoder_hidden_states = self.encoder_hid_proj(encoder_hidden_states)
+        elif self.encoder_hid_proj is not None and self.config.encoder_hid_dim_type == "text_image_proj":
+            # Kadinsky 2.1 - style
+            if "image_embeds" not in added_cond_kwargs:
+                raise ValueError(
+                    f"{self.__class__} has the config param `encoder_hid_dim_type` set to 'text_image_proj' which requires the keyword argument `image_embeds` to be passed in  `added_conditions`"
+                )
+
+            image_embeds = added_cond_kwargs.get("image_embeds")
+            encoder_hidden_states = self.encoder_hid_proj(encoder_hidden_states, image_embeds)
+
+        # 2. pre-process and insert conditioning (ControlNet)
+        # Note: the added "guided_hint" is the only difference between this implementation and the original UNet2DConditionModel
+        sample = self.conv_in(sample)
+        sample = guided_hint + sample if guided_hint is not None else sample
+
+        # 3. down
+        down_block_res_samples = (sample,)
+        for downsample_block in self.down_blocks:
+            if hasattr(downsample_block, "has_cross_attention") and downsample_block.has_cross_attention:
+                sample, res_samples = downsample_block(
+                    hidden_states=sample,
+                    temb=emb,
+                    encoder_hidden_states=encoder_hidden_states,
+                    attention_mask=attention_mask,
+                    cross_attention_kwargs=cross_attention_kwargs,
+                    encoder_attention_mask=encoder_attention_mask,
+                )
+            else:
+                sample, res_samples = downsample_block(hidden_states=sample, temb=emb)
+
+            down_block_res_samples += res_samples
+
+        if down_block_additional_residuals is not None:
+            new_down_block_res_samples = ()
+
+            for down_block_res_sample, down_block_additional_residual in zip(
+                down_block_res_samples, down_block_additional_residuals
+            ):
+                down_block_res_sample = down_block_res_sample + down_block_additional_residual
+                new_down_block_res_samples = new_down_block_res_samples + (down_block_res_sample,)
+
+            down_block_res_samples = new_down_block_res_samples
+
+        # 4. mid
+        if self.mid_block is not None:
+            sample = self.mid_block(
+                sample,
+                emb,
+                encoder_hidden_states=encoder_hidden_states,
+                attention_mask=attention_mask,
+                cross_attention_kwargs=cross_attention_kwargs,
+                encoder_attention_mask=encoder_attention_mask,
+            )
+
+        if mid_block_additional_residual is not None:
+            sample = sample + mid_block_additional_residual
+
+        # 5. up
+        for i, upsample_block in enumerate(self.up_blocks):
+            is_final_block = i == len(self.up_blocks) - 1
+
+            res_samples = down_block_res_samples[-len(upsample_block.resnets) :]
+            down_block_res_samples = down_block_res_samples[: -len(upsample_block.resnets)]
+
+            # if we have not reached the final block and need to forward the
+            # upsample size, we do it here
+            if not is_final_block and forward_upsample_size:
+                upsample_size = down_block_res_samples[-1].shape[2:]
+
+            if hasattr(upsample_block, "has_cross_attention") and upsample_block.has_cross_attention:
+                sample = upsample_block(
+                    hidden_states=sample,
+                    temb=emb,
+                    res_hidden_states_tuple=res_samples,
+                    encoder_hidden_states=encoder_hidden_states,
+                    cross_attention_kwargs=cross_attention_kwargs,
+                    upsample_size=upsample_size,
+                    attention_mask=attention_mask,
+                    encoder_attention_mask=encoder_attention_mask,
+                )
+            else:
+                sample = upsample_block(
+                    hidden_states=sample, temb=emb, res_hidden_states_tuple=res_samples, upsample_size=upsample_size
+                )
+
+        # 6. post-process
+        if self.conv_norm_out:
+            sample = self.conv_norm_out(sample)
+            sample = self.conv_act(sample)
+        sample = self.conv_out(sample)
+
+        if not return_dict:
+            return (sample,)
+
+        return UNet2DConditionOutput(sample=sample)
diff --git a/examples/boft_dreambooth/.gitignore b/examples/boft_dreambooth/.gitignore
new file mode 100644
index 0000000..8fce603
--- /dev/null
+++ b/examples/boft_dreambooth/.gitignore
@@ -0,0 +1 @@
+data/
diff --git a/examples/boft_dreambooth/__init__.py b/examples/boft_dreambooth/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/examples/boft_dreambooth/boft_dreambooth.md b/examples/boft_dreambooth/boft_dreambooth.md
new file mode 100644
index 0000000..d96e6f8
--- /dev/null
+++ b/examples/boft_dreambooth/boft_dreambooth.md
@@ -0,0 +1,176 @@
+<!--Copyright 2023 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# DreamBooth fine-tuning with BOFT
+
+This guide demonstrates how to use BOFT, an orthogonal fine-tuning method, to fine-tune Dreambooth with either `stabilityai/stable-diffusion-2-1` or `runwayml/stable-diffusion-v1-5` model.
+
+By using BOFT from 🤗 PEFT, we can significantly reduce the number of trainable parameters while still achieving impressive results in various fine-tuning tasks across different foundation models. BOFT enhances model efficiency by integrating full-rank orthogonal matrices with a butterfly structure into specific model blocks, such as attention blocks, mirroring the approach used in LoRA. During fine-tuning, only these inserted matrices are trained, leaving the original model parameters untouched. During inference, the trainable BOFT parameters can be merged into the original model, eliminating any additional computational costs.
+
+As a member of the **orthogonal finetuning** class, BOFT presents a systematic and principled method for fine-tuning. It possesses several unique properties and has demonstrated superior performance compared to LoRA in a variety of scenarios. For further details on BOFT, please consult the [PEFT's GitHub repo's concept guide OFT](https://https://huggingface.co/docs/peft/index), the [original BOFT paper](https://huggingface.co/papers/2311.06243) and the [original OFT paper](https://huggingface.co/papers/2306.07280).
+
+In this guide we provide a Dreambooth fine-tuning script that is available in [PEFT's GitHub repo examples](https://github.com/huggingface/peft/tree/main/examples/boft_dreambooth). This implementation is adapted from [peft's lora_dreambooth](https://github.com/huggingface/peft/tree/main/examples/lora_dreambooth). You can try it out and finetune on your custom images.
+
+## Set up your environment
+
+Start by cloning the PEFT repository:
+
+```bash
+git clone --recursive https://github.com/huggingface/peft
+```
+
+Navigate to the directory containing the training scripts for fine-tuning Dreambooth with BOFT:
+
+```bash
+cd peft/examples/boft_dreambooth
+```
+
+Set up your environment: install PEFT, and all the required libraries. At the time of writing this guide we recommend installing PEFT from source. The following environment setup should work on A100 and H100:
+
+### CUDA
+```bash
+conda create --name peft python=3.10
+conda activate peft
+conda install pytorch==2.1.2 torchvision==0.16.2 torchaudio==2.1.2 pytorch-cuda=11.8 -c pytorch -c nvidia
+conda install xformers -c xformers
+pip install -r requirements.txt
+pip install git+https://github.com/huggingface/peft
+```
+The following environment setup is validated work on Intel XPU:
+
+### Intel XPU
+```bash
+conda create --name peft python=3.10
+conda activate peft
+pip install pip install torch==2.8.0.dev20250615+xpu torchvision==0.23.0.dev20250615+xpu torchaudio==2.8.0.dev20250615+xpu --index-url https://download.pytorch.org/whl/nightly/xpu --no-cache-dir
+pip install -r requirements.txt
+pip install git+https://github.com/huggingface/peft
+```
+
+## Download the data
+
+[dreambooth](https://github.com/google/dreambooth) dataset should have been automatically cloned in the following structure when running the training script.
+
+```
+boft_dreambooth
+├── data
+│   ├── data_dir
+│   └── dreambooth
+│       └── data
+│           ├── backpack
+│           └── backpack_dog
+│           ...
+```
+
+You can also put your custom images into `boft_dreambooth/data/dreambooth`.
+
+## Finetune Dreambooth with BOFT
+
+```bash
+./train_dreambooth.sh
+```
+
+or using the following script arguments:
+
+```bash
+export MODEL_NAME="runwayml/stable-diffusion-v1-5"
+export INSTANCE_DIR="path-to-instance-images"
+export CLASS_DIR="path-to-class-images"
+export OUTPUT_DIR="path-to-save-model"
+```
+
+Here:
+
+- `INSTANCE_DIR`: The directory containing the images that you intend to use for training your model.
+- `CLASS_DIR`: The directory containing class-specific images. In this example, we use prior preservation to avoid overfitting and language-drift. For prior preservation, you need other images of the same class as part of the training process. However, these images can be generated and the training script will save them to a local path you specify here.
+- `OUTPUT_DIR`: The destination folder for storing the trained model's weights.
+
+To learn more about DreamBooth fine-tuning with prior-preserving loss, check out the [Diffusers documentation](https://huggingface.co/docs/diffusers/training/dreambooth#finetuning-with-priorpreserving-loss).
+
+Launch the training script with `accelerate` and pass hyperparameters, as well as LoRa-specific arguments to it such as:
+
+- `use_boft`: Enables BOFT in the training script.
+- `boft_block_size`: the BOFT matrix block size across different layers, expressed in `int`. Smaller block size results in sparser update matrices with fewer trainable parameters. **Note**, please choose it to be dividable to most layer `in_features` dimension, e.g., 4, 8, 16. Also, you can only specify either `boft_block_size` or `boft_block_num`, but not both simultaneously, because `boft_block_size` x `boft_block_num` = layer dimension.
+- `boft_block_num`: the number of BOFT matrix blocks across different layers, expressed in `int`. Fewer blocks result in sparser update matrices with fewer trainable parameters. **Note**, please choose it to be dividable to most layer `in_features` dimension, e.g., 4, 8, 16. Also, you can only specify either `boft_block_size` or `boft_block_num`, but not both simultaneously, because `boft_block_size` x `boft_block_num` = layer dimension.
+- `boft_n_butterfly_factor`: the number of butterfly factors. **Note**, for `boft_n_butterfly_factor=1`, BOFT is the same as vanilla OFT, for `boft_n_butterfly_factor=2`, the effective block size of OFT becomes twice as big and the number of blocks becomes half.
+- `bias`: specify if the `bias` parameters should be trained. Can be `none`, `all` or `boft_only`.
+- `boft_dropout`: specify the probability of multiplicative dropout.
+
+Here's what the full set of script arguments may look like:
+
+```bash
+PEFT_TYPE="boft"
+BLOCK_NUM=8
+BLOCK_SIZE=0
+N_BUTTERFLY_FACTOR=1
+
+VALIDATION_PROMPT=${PROMPT_LIST[@]}
+INSTANCE_PROMPT="a photo of ${UNIQUE_TOKEN} ${CLASS_TOKEN}"
+CLASS_PROMPT="a photo of ${CLASS_TOKEN}"
+
+export MODEL_NAME="stabilityai/stable-diffusion-2-1"
+# export MODEL_NAME="runwayml/stable-diffusion-v1-5"
+export PROJECT_NAME="dreambooth_${PEFT_TYPE}"
+export RUN_NAME="${SELECTED_SUBJECT}_${PEFT_TYPE}_${BLOCK_NUM}${BLOCK_SIZE}${N_BUTTERFLY_FACTOR}"
+export INSTANCE_DIR="./data/dreambooth/dataset/${SELECTED_SUBJECT}"
+export CLASS_DIR="./data/class_data/${CLASS_TOKEN}"
+export OUTPUT_DIR="./data/output/${PEFT_TYPE}"
+
+
+accelerate launch train_dreambooth.py \
+  --pretrained_model_name_or_path=$MODEL_NAME  \
+  --instance_data_dir=$INSTANCE_DIR \
+  --class_data_dir="$CLASS_DIR" \
+  --output_dir=$OUTPUT_DIR \
+  --wandb_project_name=$PROJECT_NAME \
+  --wandb_run_name=$RUN_NAME \
+  --with_prior_preservation --prior_loss_weight=1.0 \
+  --instance_prompt="$INSTANCE_PROMPT" \
+  --validation_prompt="$VALIDATION_PROMPT" \
+  --class_prompt="$CLASS_PROMPT" \
+  --resolution=512 \
+  --train_batch_size=1 \
+  --num_dataloader_workers=2 \
+  --lr_scheduler="constant" \
+  --lr_warmup_steps=0 \
+  --num_class_images=200 \
+  --use_boft \
+  --boft_block_num=$BLOCK_NUM \
+  --boft_block_size=$BLOCK_SIZE \
+  --boft_n_butterfly_factor=$N_BUTTERFLY_FACTOR \
+  --boft_dropout=0.1 \
+  --boft_bias="boft_only" \
+  --learning_rate=3e-5 \
+  --max_train_steps=1010 \
+  --checkpointing_steps=200 \
+  --validation_steps=200 \
+  --enable_xformers_memory_efficient_attention \
+  --report_to="wandb" \
+```
+
+or use this training script:
+
+```bash
+./train_dreambooth.sh $idx
+```
+
+with the `$idx` corresponds to different subjects.
+
+If you are running this script on Windows, you may need to set the `--num_dataloader_workers` to 0.
+
+## Inference with a single adapter
+
+To run inference with the fine-tuned model, simply run the jupyter notebook `dreambooth_inference.ipynb` for visualization with `jupyter notebook` under `./examples/boft_dreambooth`.
diff --git a/examples/boft_dreambooth/dreambooth_inference.ipynb b/examples/boft_dreambooth/dreambooth_inference.ipynb
new file mode 100644
index 0000000..3fa2bbb
--- /dev/null
+++ b/examples/boft_dreambooth/dreambooth_inference.ipynb
@@ -0,0 +1,180 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "acab479f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "import torch\n",
+    "from accelerate.logging import get_logger\n",
+    "from diffusers import StableDiffusionPipeline\n",
+    "from diffusers.utils import check_min_version\n",
+    "\n",
+    "from peft import PeftModel\n",
+    "\n",
+    "# Will error if the minimal version of diffusers is not installed. Remove at your own risks.\n",
+    "check_min_version(\"0.10.0.dev0\")\n",
+    "\n",
+    "logger = get_logger(__name__)\n",
+    "\n",
+    "MODEL_NAME = \"stabilityai/stable-diffusion-2-1\"\n",
+    "# MODEL_NAME=\"runwayml/stable-diffusion-v1-5\"\n",
+    "\n",
+    "PEFT_TYPE=\"boft\"\n",
+    "BLOCK_NUM=8\n",
+    "BLOCK_SIZE=0\n",
+    "N_BUTTERFLY_FACTOR=1\n",
+    "SELECTED_SUBJECT=\"backpack\"\n",
+    "EPOCH_IDX = 200\n",
+    "\n",
+    "PROJECT_NAME=f\"dreambooth_{PEFT_TYPE}\"\n",
+    "RUN_NAME=f\"{SELECTED_SUBJECT}_{PEFT_TYPE}_{BLOCK_NUM}{BLOCK_SIZE}{N_BUTTERFLY_FACTOR}\"\n",
+    "OUTPUT_DIR=f\"./data/output/{PEFT_TYPE}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "06cfd506",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_boft_sd_pipeline(\n",
+    "    ckpt_dir, base_model_name_or_path=None, epoch=int, dtype=torch.float32, device=\"auto\", adapter_name=\"default\"\n",
+    "):\n",
+    "    if device == \"auto\":\n",
+    "        device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "\n",
+    "    if base_model_name_or_path is None:\n",
+    "        raise ValueError(\"Please specify the base model name or path\")\n",
+    "\n",
+    "    pipe = StableDiffusionPipeline.from_pretrained(\n",
+    "        base_model_name_or_path, torch_dtype=dtype, requires_safety_checker=False\n",
+    "    ).to(device)\n",
+    "    \n",
+    "    load_adapter(pipe, ckpt_dir, epoch, adapter_name)\n",
+    "\n",
+    "    if dtype in (torch.float16, torch.bfloat16):\n",
+    "        pipe.unet.half()\n",
+    "        pipe.text_encoder.half()\n",
+    "\n",
+    "    pipe.to(device)\n",
+    "    return pipe\n",
+    "\n",
+    "\n",
+    "def load_adapter(pipe, ckpt_dir, epoch, adapter_name=\"default\"):\n",
+    "    \n",
+    "    unet_sub_dir = os.path.join(ckpt_dir, f\"unet/{epoch}\", adapter_name)\n",
+    "    text_encoder_sub_dir = os.path.join(ckpt_dir, f\"text_encoder/{epoch}\", adapter_name)\n",
+    "    \n",
+    "    if isinstance(pipe.unet, PeftModel):\n",
+    "        pipe.unet.load_adapter(unet_sub_dir, adapter_name=adapter_name)\n",
+    "    else:\n",
+    "        pipe.unet = PeftModel.from_pretrained(pipe.unet, unet_sub_dir, adapter_name=adapter_name)\n",
+    "        \n",
+    "    if os.path.exists(text_encoder_sub_dir):\n",
+    "        if isinstance(pipe.text_encoder, PeftModel):\n",
+    "            pipe.text_encoder.load_adapter(text_encoder_sub_dir, adapter_name=adapter_name)\n",
+    "        else:\n",
+    "            pipe.text_encoder = PeftModel.from_pretrained(pipe.text_encoder, text_encoder_sub_dir, adapter_name=adapter_name)\n",
+    "    \n",
+    "\n",
+    "def set_adapter(pipe, adapter_name):\n",
+    "    pipe.unet.set_adapter(adapter_name)\n",
+    "    if isinstance(pipe.text_encoder, PeftModel):\n",
+    "        pipe.text_encoder.set_adapter(adapter_name)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "98a0d8ac",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompt = \"a photo of sks backpack on a wooden floor\"\n",
+    "negative_prompt = \"low quality, blurry, unfinished\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d4e888d2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%time\n",
+    "pipe = get_boft_sd_pipeline(OUTPUT_DIR, MODEL_NAME, EPOCH_IDX, adapter_name=RUN_NAME)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f1c1a1c0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%time\n",
+    "image = pipe(prompt, num_inference_steps=50, guidance_scale=7, negative_prompt=negative_prompt).images[0]\n",
+    "image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3a1aafdf-8cf7-4e47-9471-26478034245e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# load and reset another adapter\n",
+    "# WARNING: requires training DreamBooth with `boft_bias=None`\n",
+    "\n",
+    "SELECTED_SUBJECT=\"dog\"\n",
+    "EPOCH_IDX = 200\n",
+    "RUN_NAME=f\"{SELECTED_SUBJECT}_{PEFT_TYPE}_{BLOCK_NUM}{BLOCK_SIZE}{N_BUTTERFLY_FACTOR}\"\n",
+    "\n",
+    "load_adapter(pipe, OUTPUT_DIR, epoch=EPOCH_IDX, adapter_name=RUN_NAME)\n",
+    "set_adapter(pipe, adapter_name=RUN_NAME)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c7091ad0-2005-4528-afc1-4f9d70a9a535",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%time\n",
+    "prompt = \"a photo of sks dog running on the beach\"\n",
+    "negative_prompt = \"low quality, blurry, unfinished\"\n",
+    "image = pipe(prompt, num_inference_steps=50, guidance_scale=7, negative_prompt=negative_prompt).images[0]\n",
+    "image"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python [conda env:peft] *",
+   "language": "python",
+   "name": "conda-env-peft-py"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/boft_dreambooth/requirements.txt b/examples/boft_dreambooth/requirements.txt
new file mode 100644
index 0000000..67eac70
--- /dev/null
+++ b/examples/boft_dreambooth/requirements.txt
@@ -0,0 +1,13 @@
+transformers==4.54.0
+accelerate==1.9.0
+evaluate
+tqdm
+datasets==4.0.0
+diffusers==0.34.0
+Pillow
+huggingface_hub
+safetensors
+nb_conda_kernels
+ipykernel
+ipywidgets
+wandb==0.21.0
diff --git a/examples/boft_dreambooth/train_dreambooth.py b/examples/boft_dreambooth/train_dreambooth.py
new file mode 100644
index 0000000..44a19b3
--- /dev/null
+++ b/examples/boft_dreambooth/train_dreambooth.py
@@ -0,0 +1,624 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+# The implementation is based on "Parameter-Efficient Orthogonal Finetuning
+# via Butterfly Factorization" (https://huggingface.co/papers/2311.06243) in ICLR 2024.
+
+import hashlib
+import itertools
+import logging
+import math
+import os
+from contextlib import nullcontext
+from pathlib import Path
+
+import datasets
+import diffusers
+import numpy as np
+import torch
+import torch.nn.functional as F
+import torch.utils.checkpoint
+import transformers
+from accelerate import Accelerator
+from accelerate.logging import get_logger
+from accelerate.utils import ProjectConfiguration, set_seed
+from diffusers import (
+    AutoencoderKL,
+    DDIMScheduler,
+    DiffusionPipeline,
+    DPMSolverMultistepScheduler,
+    UNet2DConditionModel,
+)
+from diffusers.optimization import get_scheduler
+from diffusers.utils import check_min_version
+from diffusers.utils.import_utils import is_xformers_available
+from huggingface_hub import Repository
+from tqdm.auto import tqdm
+from transformers import AutoTokenizer
+from utils.args_loader import (
+    get_full_repo_name,
+    import_model_class_from_model_name_or_path,
+    parse_args,
+)
+from utils.dataset import DreamBoothDataset, PromptDataset, collate_fn
+from utils.tracemalloc import TorchTracemalloc, b2mb
+
+from peft import BOFTConfig, get_peft_model
+
+
+# Will error if the minimal version of diffusers is not installed. Remove at your own risks.
+check_min_version("0.16.0.dev0")
+
+logger = get_logger(__name__)
+
+UNET_TARGET_MODULES = ["to_q", "to_v", "to_k", "query", "value", "key", "to_out.0", "add_k_proj", "add_v_proj"]
+TEXT_ENCODER_TARGET_MODULES = ["q_proj", "v_proj"]
+
+
+def save_adaptor(accelerator, step, unet, text_encoder, args):
+    unwarpped_unet = accelerator.unwrap_model(unet)
+    unwarpped_unet.save_pretrained(
+        os.path.join(args.output_dir, f"unet/{step}"), state_dict=accelerator.get_state_dict(unet)
+    )
+    if args.train_text_encoder:
+        unwarpped_text_encoder = accelerator.unwrap_model(text_encoder)
+        unwarpped_text_encoder.save_pretrained(
+            os.path.join(args.output_dir, f"text_encoder/{step}"),
+            state_dict=accelerator.get_state_dict(text_encoder),
+        )
+
+
+def main(args):
+    validation_prompts = list(filter(None, args.validation_prompt[0].split(".")))
+
+    logging_dir = Path(args.output_dir, args.logging_dir)
+    accelerator_project_config = ProjectConfiguration(project_dir=args.output_dir, logging_dir=logging_dir)
+
+    accelerator = Accelerator(
+        gradient_accumulation_steps=args.gradient_accumulation_steps,
+        mixed_precision=args.mixed_precision,
+        log_with=args.report_to,
+        project_dir=accelerator_project_config,
+    )
+    if args.report_to == "wandb":
+        import wandb
+
+        wandb_init = {
+            "wandb": {
+                "name": args.wandb_run_name,
+                "mode": "online",
+            }
+        }
+
+    # Currently, it's not possible to do gradient accumulation when training two models with accelerate.accumulate
+    # This will be enabled soon in accelerate. For now, we don't allow gradient accumulation when training two models.
+    # TODO (patil-suraj): Remove this check when gradient accumulation with two models is enabled in accelerate.
+    if args.train_text_encoder and args.gradient_accumulation_steps > 1 and accelerator.num_processes > 1:
+        raise ValueError(
+            "Gradient accumulation is not supported when training the text encoder in distributed training. "
+            "Please set gradient_accumulation_steps to 1. This feature will be supported in the future."
+        )
+
+    # Make one log on every process with the configuration for debugging.
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        level=logging.INFO,
+    )
+    logger.info(accelerator.state, main_process_only=False)
+    if accelerator.is_local_main_process:
+        datasets.utils.logging.set_verbosity_warning()
+        transformers.utils.logging.set_verbosity_warning()
+        diffusers.utils.logging.set_verbosity_info()
+    else:
+        datasets.utils.logging.set_verbosity_error()
+        transformers.utils.logging.set_verbosity_error()
+        diffusers.utils.logging.set_verbosity_error()
+
+    # If passed along, set the training seed now.
+    global_seed = hash(args.wandb_run_name) % (2**32)
+    set_seed(global_seed)
+
+    # Generate class images if prior preservation is enabled.
+    if args.with_prior_preservation:
+        class_images_dir = Path(args.class_data_dir)
+        if not class_images_dir.exists():
+            class_images_dir.mkdir(parents=True)
+        cur_class_images = len(list(class_images_dir.iterdir()))
+
+        if cur_class_images < args.num_class_images:
+            dtype = torch.float16 if accelerator.device.type in ["cuda", "xpu"] else torch.float32
+            if args.prior_generation_precision == "fp32":
+                dtype = torch.float32
+            elif args.prior_generation_precision == "fp16":
+                dtype = torch.float16
+            elif args.prior_generation_precision == "bf16":
+                dtype = torch.bfloat16
+            pipeline = DiffusionPipeline.from_pretrained(
+                args.pretrained_model_name_or_path,
+                dtype=dtype,
+                safety_checker=None,
+                revision=args.revision,
+            )
+            pipeline.set_progress_bar_config(disable=True)
+
+            num_new_images = args.num_class_images - cur_class_images
+            logger.info(f"Number of class images to sample: {num_new_images}.")
+
+            sample_dataset = PromptDataset(args.class_prompt, num_new_images)
+            sample_dataloader = torch.utils.data.DataLoader(sample_dataset, batch_size=args.sample_batch_size)
+
+            sample_dataloader = accelerator.prepare(sample_dataloader)
+            pipeline.to(accelerator.device)
+
+            for example in tqdm(
+                sample_dataloader, desc="Generating class images", disable=not accelerator.is_local_main_process
+            ):
+                images = pipeline(example["prompt"]).images
+
+                for i, image in enumerate(images):
+                    hash_image = hashlib.sha1(image.tobytes()).hexdigest()
+                    image_filename = class_images_dir / f"{example['index'][i] + cur_class_images}-{hash_image}.jpg"
+                    image.save(image_filename)
+
+            del pipeline
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+            elif torch.xpu.is_available():
+                torch.xpu.empty_cache()
+
+    # Handle the repository creation
+    if accelerator.is_main_process:
+        if args.push_to_hub:
+            if args.hub_model_id is None:
+                repo_name = get_full_repo_name(Path(args.output_dir).name, token=args.hub_token)
+            else:
+                repo_name = args.hub_model_id
+            repo = Repository(args.output_dir, clone_from=repo_name)
+
+            with open(os.path.join(args.output_dir, ".gitignore"), "w+") as gitignore:
+                if "step_*" not in gitignore:
+                    gitignore.write("step_*\n")
+                if "epoch_*" not in gitignore:
+                    gitignore.write("epoch_*\n")
+        elif args.output_dir is not None:
+            os.makedirs(args.output_dir, exist_ok=True)
+
+    # Load the tokenizer
+    if args.tokenizer_name:
+        tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name, revision=args.revision, use_fast=False)
+    elif args.pretrained_model_name_or_path:
+        tokenizer = AutoTokenizer.from_pretrained(
+            args.pretrained_model_name_or_path,
+            subfolder="tokenizer",
+            revision=args.revision,
+            use_fast=False,
+        )
+
+    # import correct text encoder class
+    text_encoder_cls = import_model_class_from_model_name_or_path(args.pretrained_model_name_or_path, args.revision)
+
+    # Load scheduler and models
+    noise_scheduler = DDIMScheduler.from_pretrained(args.pretrained_model_name_or_path, subfolder="scheduler")
+
+    text_encoder = text_encoder_cls.from_pretrained(
+        args.pretrained_model_name_or_path, subfolder="text_encoder", revision=args.revision
+    )
+    vae = AutoencoderKL.from_pretrained(args.pretrained_model_name_or_path, subfolder="vae", revision=args.revision)
+    unet = UNet2DConditionModel.from_pretrained(
+        args.pretrained_model_name_or_path, subfolder="unet", revision=args.revision
+    )
+
+    if args.use_boft:
+        config = BOFTConfig(
+            boft_block_size=args.boft_block_size,
+            boft_block_num=args.boft_block_num,
+            boft_n_butterfly_factor=args.boft_n_butterfly_factor,
+            target_modules=UNET_TARGET_MODULES,
+            boft_dropout=args.boft_dropout,
+            bias=args.boft_bias,
+        )
+        unet = get_peft_model(unet, config, adapter_name=args.wandb_run_name)
+        unet.print_trainable_parameters()
+
+    vae.requires_grad_(False)
+    unet.train()
+
+    if args.train_text_encoder and args.use_boft:
+        config = BOFTConfig(
+            boft_block_size=args.boft_block_size,
+            boft_block_num=args.boft_block_num,
+            boft_n_butterfly_factor=args.boft_n_butterfly_factor,
+            target_modules=TEXT_ENCODER_TARGET_MODULES,
+            boft_dropout=args.boft_dropout,
+            bias=args.boft_bias,
+        )
+        text_encoder = get_peft_model(text_encoder, config, adapter_name=args.wandb_run_name)
+        text_encoder.print_trainable_parameters()
+        text_encoder.train()
+    else:
+        text_encoder.requires_grad_(False)
+
+    # For mixed precision training we cast the text_encoder and vae weights to half-precision
+    # as these models are only used for inference, keeping weights in full precision is not required.
+    weight_dtype = torch.float32
+    if accelerator.mixed_precision == "fp16":
+        weight_dtype = torch.float16
+    elif accelerator.mixed_precision == "bf16":
+        weight_dtype = torch.bfloat16
+
+    # Move unet, vae and text_encoder to device and cast to weight_dtype
+    unet.to(accelerator.device, dtype=weight_dtype)
+    vae.to(accelerator.device, dtype=weight_dtype)
+    text_encoder.to(accelerator.device, dtype=weight_dtype)
+
+    if args.enable_xformers_memory_efficient_attention:
+        if accelerator.device.type == "xpu":
+            logger.warning("XPU hasn't support xformers yet, ignore it.")
+        elif is_xformers_available():
+            unet.enable_xformers_memory_efficient_attention()
+        else:
+            raise ValueError("xformers is not available. Make sure it is installed correctly")
+
+    if args.gradient_checkpointing:
+        unet.enable_gradient_checkpointing()
+        # below fails when using boft so commenting it out
+        if args.train_text_encoder and not args.use_boft:
+            text_encoder.gradient_checkpointing_enable()
+
+    # Enable TF32 for faster training on Ampere GPUs,
+    # cf https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices
+    if args.allow_tf32 and torch.cuda.is_available():
+        torch.backends.cuda.matmul.allow_tf32 = True
+
+    if args.scale_lr:
+        args.learning_rate = (
+            args.learning_rate * args.gradient_accumulation_steps * args.train_batch_size * accelerator.num_processes
+        )
+
+    # Use 8-bit Adam for lower memory usage or to fine-tune the model in 16GB GPUs
+    if args.use_8bit_adam:
+        try:
+            import bitsandbytes as bnb
+        except ImportError:
+            raise ImportError(
+                "To use 8-bit Adam, please install the bitsandbytes library: `pip install bitsandbytes`."
+            )
+
+        optimizer_class = bnb.optim.AdamW8bit
+    else:
+        optimizer_class = torch.optim.AdamW
+
+    # Optimizer creation
+    params_to_optimize = [param for param in unet.parameters() if param.requires_grad]
+
+    if args.train_text_encoder:
+        params_to_optimize += [param for param in text_encoder.parameters() if param.requires_grad]
+
+    optimizer = optimizer_class(
+        params_to_optimize,
+        lr=args.learning_rate,
+        betas=(args.adam_beta1, args.adam_beta2),
+        weight_decay=args.adam_weight_decay,
+        eps=args.adam_epsilon,
+    )
+
+    # Download the official dreambooth dataset from the official repository: https://github.com/google/dreambooth.git
+    data_path = os.path.join(os.getcwd(), "data", "dreambooth")
+    if not os.path.exists(data_path):
+        os.makedirs(os.path.join(os.getcwd(), "data"), exist_ok=True)
+        os.system(f"git clone https://github.com/google/dreambooth.git '{data_path}'")
+
+    # Dataset and DataLoaders creation:
+    train_dataset = DreamBoothDataset(
+        instance_data_root=args.instance_data_dir,
+        instance_prompt=args.instance_prompt,
+        class_data_root=args.class_data_dir if args.with_prior_preservation else None,
+        class_prompt=args.class_prompt,
+        tokenizer=tokenizer,
+        size=args.resolution,
+        center_crop=args.center_crop,
+    )
+
+    train_dataloader = torch.utils.data.DataLoader(
+        train_dataset,
+        batch_size=args.train_batch_size,
+        shuffle=True,
+        collate_fn=lambda examples: collate_fn(examples, args.with_prior_preservation),
+        num_workers=args.num_dataloader_workers,
+    )
+
+    # Scheduler and math around the number of training steps.
+    overrode_max_train_steps = False
+    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+    if args.max_train_steps is None:
+        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+        overrode_max_train_steps = True
+
+    lr_scheduler = get_scheduler(
+        args.lr_scheduler,
+        optimizer=optimizer,
+        num_warmup_steps=args.lr_warmup_steps * args.gradient_accumulation_steps,
+        num_training_steps=args.max_train_steps * args.gradient_accumulation_steps,
+        num_cycles=args.lr_num_cycles,
+        power=args.lr_power,
+    )
+
+    # Prepare everything with our `accelerator`.
+    if args.train_text_encoder:
+        unet, text_encoder, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
+            unet, text_encoder, optimizer, train_dataloader, lr_scheduler
+        )
+    else:
+        unet, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
+            unet, optimizer, train_dataloader, lr_scheduler
+        )
+
+    # For mixed precision training we cast the text_encoder and vae weights to half-precision
+    # as these models are only used for inference, keeping weights in full precision is not required.
+    weight_dtype = torch.float32
+    if accelerator.mixed_precision == "fp16":
+        weight_dtype = torch.float16
+    elif accelerator.mixed_precision == "bf16":
+        weight_dtype = torch.bfloat16
+
+    # Move vae and text_encoder to device and cast to weight_dtype
+    vae.to(accelerator.device, dtype=weight_dtype)
+    if not args.train_text_encoder:
+        text_encoder.to(accelerator.device, dtype=weight_dtype)
+
+    # We need to recalculate our total training steps as the size of the training dataloader may have changed.
+    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+    if overrode_max_train_steps:
+        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+    # Afterwards we recalculate our number of training epochs
+    args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch)
+
+    # We need to initialize the trackers we use, and also store our configuration.
+    # The trackers initializes automatically on the main process.
+    if accelerator.is_main_process:
+        accelerator.init_trackers(args.wandb_project_name, config=vars(args), init_kwargs=wandb_init)
+
+    # Train!
+    total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps
+
+    logger.info("***** Running training *****")
+    logger.info(f"  Num examples = {len(train_dataset)}")
+    logger.info(f"  Num batches each epoch = {len(train_dataloader)}")
+    logger.info(f"  Num Epochs = {args.num_train_epochs}")
+    logger.info(f"  Instantaneous batch size per device = {args.train_batch_size}")
+    logger.info(f"  Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}")
+    logger.info(f"  Gradient Accumulation steps = {args.gradient_accumulation_steps}")
+    logger.info(f"  Total optimization steps = {args.max_train_steps}")
+    global_step = 0
+    first_epoch = 0
+
+    # Potentially load in the weights and states from a previous save
+    if args.resume_from_checkpoint:
+        if args.resume_from_checkpoint != "latest":
+            path = os.path.basename(args.resume_from_checkpoint)
+        else:
+            # Get the most recent checkpoint
+            dirs = os.listdir(args.output_dir)
+            dirs = [d for d in dirs if d.startswith("checkpoint")]
+            dirs = sorted(dirs, key=lambda x: int(x.split("-")[1]))
+            path = dirs[-1] if len(dirs) > 0 else None
+        accelerator.print(f"Resuming from checkpoint {path}")
+        accelerator.load_state(os.path.join(args.output_dir, path))
+        global_step = int(path.split("-")[1])
+
+        resume_global_step = global_step * args.gradient_accumulation_steps
+        first_epoch = resume_global_step // num_update_steps_per_epoch
+        resume_step = resume_global_step % num_update_steps_per_epoch
+
+    # Only show the progress bar once on each machine.
+    progress_bar = tqdm(range(global_step, args.max_train_steps), disable=not accelerator.is_local_main_process)
+    progress_bar.set_description("Steps")
+
+    if args.train_text_encoder:
+        text_encoder.train()
+
+    for epoch in range(first_epoch, args.num_train_epochs):
+        unet.train()
+
+        with TorchTracemalloc() if not args.no_tracemalloc else nullcontext() as tracemalloc:
+            for step, batch in enumerate(train_dataloader):
+                # Skip steps until we reach the resumed step
+                if args.resume_from_checkpoint and epoch == first_epoch and step < resume_step:
+                    if step % args.gradient_accumulation_steps == 0:
+                        progress_bar.update(1)
+                        if args.report_to == "wandb":
+                            accelerator.print(progress_bar)
+                    continue
+
+                with accelerator.accumulate(unet):
+                    # Convert images to latent space
+                    latents = vae.encode(batch["pixel_values"].to(dtype=weight_dtype)).latent_dist.sample()
+                    latents = latents * vae.config.scaling_factor
+
+                    # Sample noise that we'll add to the latents
+                    noise = torch.randn_like(latents)
+                    bsz = latents.shape[0]
+                    # Sample a random timestep for each image
+                    timesteps = torch.randint(
+                        0, noise_scheduler.config.num_train_timesteps, (bsz,), device=latents.device
+                    )
+                    timesteps = timesteps.long()
+
+                    # Add noise to the latents according to the noise magnitude at each timestep
+                    # (this is the forward diffusion process)
+                    noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps)
+
+                    # Get the text embedding for conditioning
+                    encoder_hidden_states = text_encoder(batch["input_ids"])[0]
+
+                    # Predict the noise residual
+                    model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample
+
+                    # Get the target for loss depending on the prediction type
+                    if noise_scheduler.config.prediction_type == "epsilon":
+                        target = noise
+                    elif noise_scheduler.config.prediction_type == "v_prediction":
+                        target = noise_scheduler.get_velocity(latents, noise, timesteps)
+                    else:
+                        raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}")
+
+                    if args.with_prior_preservation:
+                        # Chunk the noise and model_pred into two parts and compute the loss on each part separately.
+                        model_pred, model_pred_prior = torch.chunk(model_pred, 2, dim=0)
+                        target, target_prior = torch.chunk(target, 2, dim=0)
+
+                        # Compute instance loss
+                        loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
+
+                        # Compute prior loss
+                        prior_loss = F.mse_loss(model_pred_prior.float(), target_prior.float(), reduction="mean")
+
+                        # Add the prior loss to the instance loss.
+                        loss = loss + args.prior_loss_weight * prior_loss
+                    else:
+                        loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
+
+                    accelerator.backward(loss)
+
+                    if accelerator.sync_gradients:
+                        params_to_clip = (
+                            itertools.chain(unet.parameters(), text_encoder.parameters())
+                            if args.train_text_encoder
+                            else unet.parameters()
+                        )
+                        accelerator.clip_grad_norm_(params_to_clip, args.max_grad_norm)
+
+                    optimizer.step()
+                    lr_scheduler.step()
+                    optimizer.zero_grad()
+
+                # Checks if the accelerator has performed an optimization step behind the scenes
+                if accelerator.sync_gradients:
+                    progress_bar.update(1)
+                    if args.report_to == "wandb":
+                        accelerator.print(progress_bar)
+                    global_step += 1
+
+                if global_step % args.checkpointing_steps == 0 and global_step != 0:
+                    if accelerator.is_main_process:
+                        save_adaptor(accelerator, global_step, unet, text_encoder, args)
+
+                logs = {"loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0]}
+                progress_bar.set_postfix(**logs)
+                accelerator.log(logs, step=global_step)
+
+                if (
+                    args.validation_prompt is not None
+                    and (step + num_update_steps_per_epoch * epoch) % args.validation_steps == 0
+                    and global_step > 10
+                ):
+                    unet.eval()
+
+                    logger.info(
+                        f"Running validation... \n Generating {len(validation_prompts)} images with prompt:"
+                        f" {validation_prompts[0]}, ......"
+                    )
+                    # create pipeline
+                    pipeline = DiffusionPipeline.from_pretrained(
+                        args.pretrained_model_name_or_path,
+                        safety_checker=None,
+                        revision=args.revision,
+                    )
+                    # set `keep_fp32_wrapper` to True because we do not want to remove
+                    # mixed precision hooks while we are still training
+                    pipeline.unet = accelerator.unwrap_model(unet, keep_fp32_wrapper=True)
+                    pipeline.text_encoder = accelerator.unwrap_model(text_encoder, keep_fp32_wrapper=True)
+                    pipeline.scheduler = DPMSolverMultistepScheduler.from_config(pipeline.scheduler.config)
+                    pipeline = pipeline.to(accelerator.device)
+                    pipeline.set_progress_bar_config(disable=True)
+
+                    # run inference
+                    if args.seed is not None:
+                        generator = torch.Generator(device=accelerator.device).manual_seed(args.seed)
+                    else:
+                        generator = None
+                    # images = []
+                    # for _ in range(args.num_validation_images):
+                    #     image = pipeline(args.validation_prompt, num_inference_steps=25, generator=generator).images[0]
+                    #     images.append(image)
+
+                    images = []
+                    val_img_dir = os.path.join(
+                        args.output_dir,
+                        f"validation/{global_step}",
+                        args.wandb_run_name,
+                    )
+                    os.makedirs(val_img_dir, exist_ok=True)
+
+                    for val_promot in validation_prompts:
+                        image = pipeline(val_promot, num_inference_steps=50, generator=generator).images[0]
+                        image.save(os.path.join(val_img_dir, f"{'_'.join(val_promot.split(' '))}.png"[1:]))
+                        images.append(image)
+
+                    for tracker in accelerator.trackers:
+                        if tracker.name == "tensorboard":
+                            np_images = np.stack([np.asarray(img) for img in images])
+                            tracker.writer.add_images("validation", np_images, epoch, dataformats="NHWC")
+                        if tracker.name == "wandb":
+                            import wandb
+
+                            tracker.log(
+                                {
+                                    "validation": [
+                                        wandb.Image(image, caption=f"{i}: {validation_prompts[i]}")
+                                        for i, image in enumerate(images)
+                                    ]
+                                }
+                            )
+
+                    del pipeline
+                    if torch.cuda.is_available():
+                        torch.cuda.empty_cache()
+                    elif torch.xpu.is_available():
+                        torch.xpu.empty_cache()
+
+                if global_step >= args.max_train_steps:
+                    break
+
+        # Printing the accelerator memory usage details such as allocated memory, peak memory, and total memory usage
+        if not args.no_tracemalloc:
+            accelerator.print(
+                f"{accelerator.device.type.upper()} Memory before entering the train : {b2mb(tracemalloc.begin)}"
+            )
+            accelerator.print(
+                f"{accelerator.device.type.upper()} Memory consumed at the end of the train (end-begin): {tracemalloc.used}"
+            )
+            accelerator.print(
+                f"{accelerator.device.type.upper()} Peak Memory consumed during the train (max-begin): {tracemalloc.peaked}"
+            )
+            accelerator.print(
+                f"{accelerator.device.type.upper()} Total Peak Memory consumed during the train (max): {tracemalloc.peaked + b2mb(tracemalloc.begin)}"
+            )
+
+            accelerator.print(f"CPU Memory before entering the train : {b2mb(tracemalloc.cpu_begin)}")
+            accelerator.print(f"CPU Memory consumed at the end of the train (end-begin): {tracemalloc.cpu_used}")
+            accelerator.print(f"CPU Peak Memory consumed during the train (max-begin): {tracemalloc.cpu_peaked}")
+            accelerator.print(
+                f"CPU Total Peak Memory consumed during the train (max): {tracemalloc.cpu_peaked + b2mb(tracemalloc.cpu_begin)}"
+            )
+
+    if args.push_to_hub:
+        repo.push_to_hub(commit_message="End of training", blocking=False, auto_lfs_prune=True)
+    accelerator.end_training()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    main(args)
diff --git a/examples/boft_dreambooth/train_dreambooth.sh b/examples/boft_dreambooth/train_dreambooth.sh
new file mode 100755
index 0000000..f886a4f
--- /dev/null
+++ b/examples/boft_dreambooth/train_dreambooth.sh
@@ -0,0 +1,191 @@
+IDX=$1
+PROMPT_IDX=$((IDX % 25))
+CLASS_IDX=$((IDX % 30))
+
+# Define the UNIQUE_TOKEN, CLASS_TOKENs, and SUBJECT_NAMES
+UNIQUE_TOKEN="qwe"
+
+SUBJECT_NAMES=(
+    "backpack" "backpack_dog" "bear_plushie" "berry_bowl" "can"
+    "candle" "cat" "cat2" "clock" "colorful_sneaker"
+    "dog" "dog2" "dog3" "dog5" "dog6"
+    "dog7" "dog8" "duck_toy" "fancy_boot" "grey_sloth_plushie"
+    "monster_toy" "pink_sunglasses" "poop_emoji" "rc_car" "red_cartoon"
+    "robot_toy" "shiny_sneaker" "teapot" "vase" "wolf_plushie"
+)
+
+CLASS_TOKENs=(
+    "backpack" "backpack" "stuffed animal" "bowl" "can"
+    "candle" "cat" "cat" "clock" "sneaker"
+    "dog" "dog" "dog" "dog" "dog"
+    "dog" "dog" "toy" "boot" "stuffed animal"
+    "toy" "glasses" "toy" "toy" "cartoon"
+    "toy" "sneaker" "teapot" "vase" "stuffed animal"
+)
+
+CLASS_TOKEN=${CLASS_TOKENs[$CLASS_IDX]}
+SELECTED_SUBJECT=${SUBJECT_NAMES[$CLASS_IDX]}
+
+if [[ $CLASS_IDX =~ ^(0|1|2|3|4|5|8|9|17|18|19|20|21|22|23|24|25|26|27|28|29)$ ]]; then
+  PROMPT_LIST=(
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in the jungle."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in the snow."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on the beach."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on a cobblestone street."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of pink fabric."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a wooden floor."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a city in the background."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a mountain in the background."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a blue house in the background."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a purple rug in a forest."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a wheat field in the background."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a tree and autumn leaves in the background."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with the Eiffel Tower in the background."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} floating on top of water."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} floating in an ocean of milk."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of green grass with sunflowers around it."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a mirror."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of the sidewalk in a crowded street."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a dirt road."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a white rug."
+    "a red ${UNIQUE_TOKEN} ${CLASS_TOKEN}."
+    "a purple ${UNIQUE_TOKEN} ${CLASS_TOKEN}."
+    "a shiny ${UNIQUE_TOKEN} ${CLASS_TOKEN}."
+    "a wet ${UNIQUE_TOKEN} ${CLASS_TOKEN}."
+    "a cube shaped ${UNIQUE_TOKEN} ${CLASS_TOKEN}."
+  )
+
+  prompt_test_list=(
+    "a ${CLASS_TOKEN} in the jungle"
+    "a ${CLASS_TOKEN} in the snow"
+    "a ${CLASS_TOKEN} on the beach"
+    "a ${CLASS_TOKEN} on a cobblestone street"
+    "a ${CLASS_TOKEN} on top of pink fabric"
+    "a ${CLASS_TOKEN} on top of a wooden floor"
+    "a ${CLASS_TOKEN} with a city in the background"
+    "a ${CLASS_TOKEN} with a mountain in the background"
+    "a ${CLASS_TOKEN} with a blue house in the background"
+    "a ${CLASS_TOKEN} on top of a purple rug in a forest"
+    "a ${CLASS_TOKEN} with a wheat field in the background"
+    "a ${CLASS_TOKEN} with a tree and autumn leaves in the background"
+    "a ${CLASS_TOKEN} with the Eiffel Tower in the background"
+    "a ${CLASS_TOKEN} floating on top of water"
+    "a ${CLASS_TOKEN} floating in an ocean of milk"
+    "a ${CLASS_TOKEN} on top of green grass with sunflowers around it"
+    "a ${CLASS_TOKEN} on top of a mirror"
+    "a ${CLASS_TOKEN} on top of the sidewalk in a crowded street"
+    "a ${CLASS_TOKEN} on top of a dirt road"
+    "a ${CLASS_TOKEN} on top of a white rug"
+    "a red ${CLASS_TOKEN}"
+    "a purple ${CLASS_TOKEN}"
+    "a shiny ${CLASS_TOKEN}"
+    "a wet ${CLASS_TOKEN}"
+    "a cube shaped ${CLASS_TOKEN}"
+  )
+
+else
+  PROMPT_LIST=(
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in the jungle."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in the snow."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on the beach."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on a cobblestone street."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of pink fabric."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a wooden floor."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a city in the background."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a mountain in the background."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a blue house in the background."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a purple rug in a forest."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} wearing a red hat."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} wearing a santa hat."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} wearing a rainbow scarf."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} wearing a black top hat and a monocle."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in a chef outfit."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in a firefighter outfit."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in a police outfit."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} wearing pink glasses."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} wearing a yellow shirt."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in a purple wizard outfit."
+    "a red ${UNIQUE_TOKEN} ${CLASS_TOKEN}."
+    "a purple ${UNIQUE_TOKEN} ${CLASS_TOKEN}."
+    "a shiny ${UNIQUE_TOKEN} ${CLASS_TOKEN}."
+    "a wet ${UNIQUE_TOKEN} ${CLASS_TOKEN}."
+    "a cube shaped ${UNIQUE_TOKEN} ${CLASS_TOKEN}."
+  )
+
+  prompt_test_list=(
+    "a ${CLASS_TOKEN} in the jungle"
+    "a ${CLASS_TOKEN} in the snow"
+    "a ${CLASS_TOKEN} on the beach"
+    "a ${CLASS_TOKEN} on a cobblestone street"
+    "a ${CLASS_TOKEN} on top of pink fabric"
+    "a ${CLASS_TOKEN} on top of a wooden floor"
+    "a ${CLASS_TOKEN} with a city in the background"
+    "a ${CLASS_TOKEN} with a mountain in the background"
+    "a ${CLASS_TOKEN} with a blue house in the background"
+    "a ${CLASS_TOKEN} on top of a purple rug in a forest"
+    "a ${CLASS_TOKEN} wearing a red hat"
+    "a ${CLASS_TOKEN} wearing a santa hat"
+    "a ${CLASS_TOKEN} wearing a rainbow scarf"
+    "a ${CLASS_TOKEN} wearing a black top hat and a monocle"
+    "a ${CLASS_TOKEN} in a chef outfit"
+    "a ${CLASS_TOKEN} in a firefighter outfit"
+    "a ${CLASS_TOKEN} in a police outfit"
+    "a ${CLASS_TOKEN} wearing pink glasses"
+    "a ${CLASS_TOKEN} wearing a yellow shirt"
+    "a ${CLASS_TOKEN} in a purple wizard outfit"
+    "a red ${CLASS_TOKEN}"
+    "a purple ${CLASS_TOKEN}"
+    "a shiny ${CLASS_TOKEN}"
+    "a wet ${CLASS_TOKEN}"
+    "a cube shaped ${CLASS_TOKEN}"
+  )
+fi
+
+VALIDATION_PROMPT=${PROMPT_LIST[@]}
+INSTANCE_PROMPT="a photo of ${UNIQUE_TOKEN} ${CLASS_TOKEN}"
+CLASS_PROMPT="a photo of ${CLASS_TOKEN}"
+
+export MODEL_NAME="stabilityai/stable-diffusion-2-1" 
+# export MODEL_NAME="runwayml/stable-diffusion-v1-5"
+
+PEFT_TYPE="boft"
+BLOCK_NUM=8
+BLOCK_SIZE=0
+N_BUTTERFLY_FACTOR=1
+
+export PROJECT_NAME="dreambooth_${PEFT_TYPE}"
+export RUN_NAME="${SELECTED_SUBJECT}_${PEFT_TYPE}_${BLOCK_NUM}${BLOCK_SIZE}${N_BUTTERFLY_FACTOR}"
+export INSTANCE_DIR="./data/dreambooth/dataset/${SELECTED_SUBJECT}"
+export CLASS_DIR="./data/class_data/${CLASS_TOKEN}"
+export OUTPUT_DIR="./data/output/${PEFT_TYPE}"
+
+
+accelerate launch train_dreambooth.py \
+  --pretrained_model_name_or_path=$MODEL_NAME  \
+  --instance_data_dir=$INSTANCE_DIR \
+  --class_data_dir="$CLASS_DIR" \
+  --output_dir=$OUTPUT_DIR \
+  --wandb_project_name=$PROJECT_NAME \
+  --wandb_run_name=$RUN_NAME \
+  --with_prior_preservation --prior_loss_weight=1.0 \
+  --instance_prompt="$INSTANCE_PROMPT" \
+  --validation_prompt="$VALIDATION_PROMPT" \
+  --class_prompt="$CLASS_PROMPT" \
+  --resolution=512 \
+  --train_batch_size=1 \
+  --num_dataloader_workers=2 \
+  --lr_scheduler="constant" \
+  --lr_warmup_steps=0 \
+  --num_class_images=200 \
+  --use_boft \
+  --boft_block_num=$BLOCK_NUM \
+  --boft_block_size=$BLOCK_SIZE \
+  --boft_n_butterfly_factor=$N_BUTTERFLY_FACTOR \
+  --boft_dropout=0.1 \
+  --boft_bias="boft_only" \
+  --learning_rate=3e-5 \
+  --max_train_steps=1010 \
+  --checkpointing_steps=200 \
+  --validation_steps=200 \
+  --enable_xformers_memory_efficient_attention \
+  --report_to="wandb" \
\ No newline at end of file
diff --git a/examples/boft_dreambooth/utils/__init__.py b/examples/boft_dreambooth/utils/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/examples/boft_dreambooth/utils/args_loader.py b/examples/boft_dreambooth/utils/args_loader.py
new file mode 100644
index 0000000..5260eb9
--- /dev/null
+++ b/examples/boft_dreambooth/utils/args_loader.py
@@ -0,0 +1,363 @@
+import argparse
+import os
+import warnings
+from typing import Optional
+
+from huggingface_hub import HfFolder, whoami
+from transformers import PretrainedConfig
+
+
+def import_model_class_from_model_name_or_path(pretrained_model_name_or_path: str, revision: str):
+    text_encoder_config = PretrainedConfig.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="text_encoder",
+        revision=revision,
+    )
+    model_class = text_encoder_config.architectures[0]
+
+    if model_class == "CLIPTextModel":
+        from transformers import CLIPTextModel
+
+        return CLIPTextModel
+    elif model_class == "RobertaSeriesModelWithTransformation":
+        from diffusers.pipelines.alt_diffusion.modeling_roberta_series import RobertaSeriesModelWithTransformation
+
+        return RobertaSeriesModelWithTransformation
+    else:
+        raise ValueError(f"{model_class} is not supported.")
+
+
+def get_full_repo_name(model_id: str, organization: Optional[str] = None, token: Optional[str] = None):
+    if token is None:
+        token = HfFolder.get_token()
+    if organization is None:
+        username = whoami(token)["name"]
+        return f"{username}/{model_id}"
+    else:
+        return f"{organization}/{model_id}"
+
+
+def parse_args(input_args=None):
+    parser = argparse.ArgumentParser(description="Simple example of a Dreambooth training script.")
+    parser.add_argument(
+        "--pretrained_model_name_or_path",
+        type=str,
+        default=None,
+        required=True,
+        help="Path to pretrained model or model identifier from huggingface.co/models.",
+    )
+    parser.add_argument(
+        "--revision",
+        type=str,
+        default=None,
+        required=False,
+        help="Revision of pretrained model identifier from huggingface.co/models.",
+    )
+    parser.add_argument(
+        "--tokenizer_name",
+        type=str,
+        default=None,
+        help="Pretrained tokenizer name or path if not the same as model_name",
+    )
+    parser.add_argument(
+        "--instance_data_dir",
+        type=str,
+        default=None,
+        required=True,
+        help="A folder containing the training data of instance images.",
+    )
+    parser.add_argument(
+        "--class_data_dir",
+        type=str,
+        default=None,
+        required=False,
+        help="A folder containing the training data of class images.",
+    )
+    parser.add_argument(
+        "--instance_prompt",
+        type=str,
+        default=None,
+        required=True,
+        help="The prompt with identifier specifying the instance",
+    )
+    parser.add_argument(
+        "--class_prompt",
+        type=str,
+        default=None,
+        help="The prompt to specify images in the same class as provided instance images.",
+    )
+    parser.add_argument(
+        "--with_prior_preservation",
+        default=False,
+        action="store_true",
+        help="Flag to add prior preservation loss.",
+    )
+    parser.add_argument("--prior_loss_weight", type=float, default=1.0, help="The weight of prior preservation loss.")
+    parser.add_argument(
+        "--num_class_images",
+        type=int,
+        default=100,
+        help=(
+            "Minimal class images for prior preservation loss. If there are not enough images already present in"
+            " class_data_dir, additional images will be sampled with class_prompt."
+        ),
+    )
+    parser.add_argument(
+        "--validation_prompt",
+        nargs="+",
+        help="A prompt that is used during validation to verify that the model is learning.",
+    )
+    parser.add_argument(
+        "--num_validation_images",
+        type=int,
+        default=4,
+        help="Number of images that should be generated during validation with `validation_prompt`.",
+    )
+    parser.add_argument(
+        "--validation_steps",
+        type=int,
+        default=500,
+        help=(
+            "Run dreambooth validation every X steps. Dreambooth validation consists of running the prompt"
+            " `args.validation_prompt` multiple times: `args.num_validation_images`."
+        ),
+    )
+    parser.add_argument(
+        "--output_dir",
+        type=str,
+        default="text-inversion-model",
+        help="The output directory where the model predictions and checkpoints will be written.",
+    )
+    parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.")
+    parser.add_argument(
+        "--resolution",
+        type=int,
+        default=512,
+        help=(
+            "The resolution for input images, all the images in the train/validation dataset will be resized to this"
+            " resolution"
+        ),
+    )
+    parser.add_argument(
+        "--center_crop", action="store_true", help="Whether to center crop images before resizing to resolution"
+    )
+    parser.add_argument("--train_text_encoder", action="store_true", help="Whether to train the text encoder")
+
+    parser.add_argument(
+        "--set_grads_to_none",
+        action="store_true",
+        help=(
+            "Save more memory by using setting grads to None instead of zero. Be aware, that this changes certain"
+            " behaviors, so disable this argument if it causes any problems. More info:"
+            " https://pytorch.org/docs/stable/generated/torch.optim.Optimizer.zero_grad.html"
+        ),
+    )
+
+    # boft args
+    parser.add_argument("--use_boft", action="store_true", help="Whether to use BOFT for parameter efficient tuning")
+    parser.add_argument("--boft_block_num", type=int, default=4, help="The number of BOFT blocks")
+    parser.add_argument("--boft_block_size", type=int, default=0, help="The size of BOFT blocks")
+    parser.add_argument("--boft_n_butterfly_factor", type=int, default=2, help="The number of butterfly factors")
+    parser.add_argument("--boft_dropout", type=float, default=0.1, help="BOFT dropout, only used if use_boft is True")
+    parser.add_argument(
+        "--boft_bias",
+        type=str,
+        default="none",
+        help="Bias type for BOFT. Can be 'none', 'all' or 'boft_only', only used if use_boft is True",
+    )
+    parser.add_argument(
+        "--num_dataloader_workers", type=int, default=1, help="Num of workers for the training dataloader."
+    )
+    parser.add_argument(
+        "--no_tracemalloc",
+        default=False,
+        action="store_true",
+        help="Flag to stop memory allocation tracing during training. This could speed up training on Windows.",
+    )
+
+    parser.add_argument(
+        "--train_batch_size", type=int, default=4, help="Batch size (per device) for the training dataloader."
+    )
+    parser.add_argument(
+        "--sample_batch_size", type=int, default=4, help="Batch size (per device) for sampling images."
+    )
+    parser.add_argument("--num_train_epochs", type=int, default=1)
+    parser.add_argument(
+        "--max_train_steps",
+        type=int,
+        default=None,
+        help="Total number of training steps to perform.  If provided, overrides num_train_epochs.",
+    )
+    parser.add_argument(
+        "--checkpointing_steps",
+        type=int,
+        default=500,
+        help=(
+            "Save a checkpoint of the training state every X updates. These checkpoints can be used both as final"
+            " checkpoints in case they are better than the last checkpoint, and are also suitable for resuming"
+            " training using `--resume_from_checkpoint`."
+        ),
+    )
+    parser.add_argument(
+        "--resume_from_checkpoint",
+        type=str,
+        default=None,
+        help=(
+            "Whether training should be resumed from a previous checkpoint. Use a path saved by"
+            ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.'
+        ),
+    )
+    parser.add_argument(
+        "--gradient_accumulation_steps",
+        type=int,
+        default=1,
+        help="Number of updates steps to accumulate before performing a backward/update pass.",
+    )
+    parser.add_argument(
+        "--gradient_checkpointing",
+        action="store_true",
+        help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.",
+    )
+    parser.add_argument(
+        "--learning_rate",
+        type=float,
+        default=5e-6,
+        help="Initial learning rate (after the potential warmup period) to use.",
+    )
+    parser.add_argument(
+        "--scale_lr",
+        action="store_true",
+        default=False,
+        help="Scale the learning rate by the number of GPUs, gradient accumulation steps, and batch size.",
+    )
+    parser.add_argument(
+        "--lr_scheduler",
+        type=str,
+        default="constant",
+        help=(
+            'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",'
+            ' "constant", "constant_with_warmup"]'
+        ),
+    )
+    parser.add_argument(
+        "--lr_warmup_steps", type=int, default=500, help="Number of steps for the warmup in the lr scheduler."
+    )
+    parser.add_argument(
+        "--lr_num_cycles",
+        type=int,
+        default=1,
+        help="Number of hard resets of the lr in cosine_with_restarts scheduler.",
+    )
+    parser.add_argument("--lr_power", type=float, default=1.0, help="Power factor of the polynomial scheduler.")
+    parser.add_argument(
+        "--use_8bit_adam", action="store_true", help="Whether or not to use 8-bit Adam from bitsandbytes."
+    )
+    parser.add_argument("--adam_beta1", type=float, default=0.9, help="The beta1 parameter for the Adam optimizer.")
+    parser.add_argument("--adam_beta2", type=float, default=0.999, help="The beta2 parameter for the Adam optimizer.")
+    parser.add_argument("--adam_weight_decay", type=float, default=1e-2, help="Weight decay to use.")
+    parser.add_argument("--adam_epsilon", type=float, default=1e-08, help="Epsilon value for the Adam optimizer")
+    parser.add_argument("--max_grad_norm", default=1.0, type=float, help="Max gradient norm.")
+    parser.add_argument("--push_to_hub", action="store_true", help="Whether or not to push the model to the Hub.")
+    parser.add_argument("--hub_token", type=str, default=None, help="The token to use to push to the Model Hub.")
+    parser.add_argument(
+        "--hub_model_id",
+        type=str,
+        default=None,
+        help="The name of the repository to keep in sync with the local `output_dir`.",
+    )
+    parser.add_argument(
+        "--logging_dir",
+        type=str,
+        default="logs",
+        help=(
+            "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to"
+            " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***."
+        ),
+    )
+    parser.add_argument(
+        "--allow_tf32",
+        action="store_true",
+        help=(
+            "Whether or not to allow TF32 on Ampere GPUs. Can be used to speed up training. For more information, see"
+            " https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices"
+        ),
+    )
+    parser.add_argument(
+        "--report_to",
+        type=str,
+        default="wandb",
+        help=(
+            'The integration to report the results and logs to. Supported platforms are `"tensorboard"`'
+            ' (default), `"wandb"` and `"comet_ml"`. Use `"all"` to report to all integrations.'
+        ),
+    )
+    parser.add_argument(
+        "--wandb_key",
+        type=str,
+        default=None,
+        help=("If report to option is set to wandb, api-key for wandb used for login to wandb "),
+    )
+    parser.add_argument(
+        "--wandb_project_name",
+        type=str,
+        default=None,
+        help=("If report to option is set to wandb, project name in wandb for log tracking  "),
+    )
+    parser.add_argument(
+        "--wandb_run_name",
+        type=str,
+        default=None,
+        help=("If report to option is set to wandb, project name in wandb for log tracking  "),
+    )
+    parser.add_argument(
+        "--mixed_precision",
+        type=str,
+        default=None,
+        choices=["no", "fp16", "bf16"],
+        help=(
+            "Whether to use mixed precision. Choose between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >="
+            " 1.10.and an Nvidia Ampere GPU.  Default to the value of accelerate config of the current system or the"
+            " flag passed with the `accelerate.launch` command. Use this argument to override the accelerate config."
+        ),
+    )
+    parser.add_argument(
+        "--prior_generation_precision",
+        type=str,
+        default=None,
+        choices=["no", "fp32", "fp16", "bf16"],
+        help=(
+            "Choose prior generation precision between fp32, fp16 and bf16 (bfloat16). Bf16 requires PyTorch >="
+            " 1.10.and an Nvidia Ampere GPU.  Default to  fp16 if a GPU is available else fp32."
+        ),
+    )
+    parser.add_argument("--local_rank", type=int, default=-1, help="For distributed training: local_rank")
+    parser.add_argument(
+        "--enable_xformers_memory_efficient_attention", action="store_true", help="Whether or not to use xformers."
+    )
+
+    if input_args is not None:
+        args = parser.parse_args(input_args)
+    else:
+        args = parser.parse_args()
+
+    env_local_rank = int(os.environ.get("LOCAL_RANK", "-1"))
+    if env_local_rank != -1 and env_local_rank != args.local_rank:
+        args.local_rank = env_local_rank
+
+    # Sanity checks
+    # if args.dataset_name is None and args.train_data_dir is None:
+    #     raise ValueError("Need either a dataset name or a training folder.")
+
+    if args.with_prior_preservation:
+        if args.class_data_dir is None:
+            raise ValueError("You must specify a data directory for class images.")
+        if args.class_prompt is None:
+            raise ValueError("You must specify prompt for class images.")
+    else:
+        # logger is not available yet
+        if args.class_data_dir is not None:
+            warnings.warn("You need not use --class_data_dir without --with_prior_preservation.")
+        if args.class_prompt is not None:
+            warnings.warn("You need not use --class_prompt without --with_prior_preservation.")
+
+    return args
diff --git a/examples/boft_dreambooth/utils/dataset.py b/examples/boft_dreambooth/utils/dataset.py
new file mode 100644
index 0000000..42484f7
--- /dev/null
+++ b/examples/boft_dreambooth/utils/dataset.py
@@ -0,0 +1,126 @@
+from pathlib import Path
+
+import torch
+from PIL import Image
+from torch.utils.data import Dataset
+from torchvision import transforms
+
+
+class DreamBoothDataset(Dataset):
+    """
+    A dataset to prepare the instance and class images with the prompts for fine-tuning the model.
+    It pre-processes the images and the tokenizes prompts.
+    """
+
+    def __init__(
+        self,
+        instance_data_root,
+        instance_prompt,
+        tokenizer,
+        class_data_root=None,
+        class_prompt=None,
+        size=512,
+        center_crop=False,
+    ):
+        self.size = size
+        self.center_crop = center_crop
+        self.tokenizer = tokenizer
+
+        self.instance_data_root = Path(instance_data_root)
+        if not self.instance_data_root.exists():
+            raise ValueError("Instance images root doesn't exists.")
+
+        self.instance_images_path = list(Path(instance_data_root).iterdir())
+        self.num_instance_images = len(self.instance_images_path)
+        self.instance_prompt = instance_prompt
+        self._length = self.num_instance_images
+
+        if class_data_root is not None:
+            self.class_data_root = Path(class_data_root)
+            self.class_data_root.mkdir(parents=True, exist_ok=True)
+            self.class_images_path = list(self.class_data_root.iterdir())
+            self.num_class_images = len(self.class_images_path)
+            self._length = max(self.num_class_images, self.num_instance_images)
+            self.class_prompt = class_prompt
+        else:
+            self.class_data_root = None
+
+        self.image_transforms = transforms.Compose(
+            [
+                transforms.Resize(size, interpolation=transforms.InterpolationMode.BILINEAR),
+                transforms.CenterCrop(size) if center_crop else transforms.RandomCrop(size),
+                transforms.ToTensor(),
+                transforms.Normalize([0.5], [0.5]),
+            ]
+        )
+
+    def __len__(self):
+        return self._length
+
+    def __getitem__(self, index):
+        example = {}
+        instance_image = Image.open(self.instance_images_path[index % self.num_instance_images])
+        if instance_image.mode != "RGB":
+            instance_image = instance_image.convert("RGB")
+        example["instance_images"] = self.image_transforms(instance_image)
+        example["instance_prompt_ids"] = self.tokenizer(
+            self.instance_prompt,
+            truncation=True,
+            padding="max_length",
+            max_length=self.tokenizer.model_max_length,
+            return_tensors="pt",
+        ).input_ids
+
+        if self.class_data_root:
+            class_image = Image.open(self.class_images_path[index % self.num_class_images])
+            if class_image.mode != "RGB":
+                class_image = class_image.convert("RGB")
+            example["class_images"] = self.image_transforms(class_image)
+            example["class_prompt_ids"] = self.tokenizer(
+                self.class_prompt,
+                truncation=True,
+                padding="max_length",
+                max_length=self.tokenizer.model_max_length,
+                return_tensors="pt",
+            ).input_ids
+
+        return example
+
+
+def collate_fn(examples, with_prior_preservation=False):
+    input_ids = [example["instance_prompt_ids"] for example in examples]
+    pixel_values = [example["instance_images"] for example in examples]
+
+    # Concat class and instance examples for prior preservation.
+    # We do this to avoid doing two forward passes.
+    if with_prior_preservation:
+        input_ids += [example["class_prompt_ids"] for example in examples]
+        pixel_values += [example["class_images"] for example in examples]
+
+    pixel_values = torch.stack(pixel_values)
+    pixel_values = pixel_values.to(memory_format=torch.contiguous_format).float()
+
+    input_ids = torch.cat(input_ids, dim=0)
+
+    batch = {
+        "input_ids": input_ids,
+        "pixel_values": pixel_values,
+    }
+    return batch
+
+
+class PromptDataset(Dataset):
+    "A simple dataset to prepare the prompts to generate class images on multiple GPUs."
+
+    def __init__(self, prompt, num_samples):
+        self.prompt = prompt
+        self.num_samples = num_samples
+
+    def __len__(self):
+        return self.num_samples
+
+    def __getitem__(self, index):
+        example = {}
+        example["prompt"] = self.prompt
+        example["index"] = index
+        return example
diff --git a/examples/boft_dreambooth/utils/tracemalloc.py b/examples/boft_dreambooth/utils/tracemalloc.py
new file mode 100644
index 0000000..26ba300
--- /dev/null
+++ b/examples/boft_dreambooth/utils/tracemalloc.py
@@ -0,0 +1,60 @@
+import gc
+import threading
+
+import psutil
+import torch
+
+
+# Converting Bytes to Megabytes
+def b2mb(x):
+    return int(x / 2**20)
+
+
+# This context manager is used to track the peak memory usage of the process
+class TorchTracemalloc:
+    def __enter__(self):
+        self.device_type = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+        self.device_module = getattr(torch, self.device_type, torch.cuda)
+        gc.collect()
+        self.device_module.empty_cache()
+        self.device_module.reset_peak_memory_stats()  # reset the peak gauge to zero
+        self.begin = self.device_module.memory_allocated()
+        self.process = psutil.Process()
+
+        self.cpu_begin = self.cpu_mem_used()
+        self.peak_monitoring = True
+        peak_monitor_thread = threading.Thread(target=self.peak_monitor_func)
+        peak_monitor_thread.daemon = True
+        peak_monitor_thread.start()
+        return self
+
+    def cpu_mem_used(self):
+        """get resident set size memory for the current process"""
+        return self.process.memory_info().rss
+
+    def peak_monitor_func(self):
+        self.cpu_peak = -1
+
+        while True:
+            self.cpu_peak = max(self.cpu_mem_used(), self.cpu_peak)
+
+            # can't sleep or will not catch the peak right (this comment is here on purpose)
+            # time.sleep(0.001) # 1msec
+
+            if not self.peak_monitoring:
+                break
+
+    def __exit__(self, *exc):
+        self.peak_monitoring = False
+
+        gc.collect()
+        self.device_module.empty_cache()
+        self.end = self.device_module.memory_allocated()
+        self.peak = self.device_module.max_memory_allocated()
+        self.used = b2mb(self.end - self.begin)
+        self.peaked = b2mb(self.peak - self.begin)
+
+        self.cpu_end = self.cpu_mem_used()
+        self.cpu_used = b2mb(self.cpu_end - self.cpu_begin)
+        self.cpu_peaked = b2mb(self.cpu_peak - self.cpu_begin)
+        # print(f"delta used/peak {self.used:4d}/{self.peaked:4d}")
diff --git a/examples/cartridge_self_study/README.md b/examples/cartridge_self_study/README.md
new file mode 100644
index 0000000..78ca9a6
--- /dev/null
+++ b/examples/cartridge_self_study/README.md
@@ -0,0 +1,101 @@
+# CARTRIDGE self-study distillation (example)
+
+This folder shows an **example** workflow for training a `CARTRIDGE` adapter via a SELF‑STUDY‑style
+context-distillation objective (see the [Cartridges paper](https://huggingface.co/papers/2506.06266)).
+
+PEFT intentionally keeps this training logic out of the core library; treat this as a starting point you can adapt.
+
+## Installation
+
+```bash
+pip install -r requirements.txt
+```
+
+## Files
+
+- `synthesize.py`: generates synthetic QA pairs about a corpus using vLLM with prefix caching.
+- `train_distill.py`: trains a `CARTRIDGE` adapter via self-study distillation.
+- `arxiv_synthesize.py`: like `synthesize.py`, with defaults for the Cartridges paper LaTeX.
+- `arxiv_train.py`: like `train_distill.py`, with arxiv-specific defaults.
+
+## How it works
+
+1. **Synthesize**: Generate QA pairs where the model has access to the full document context
+2. **Train**: Distill knowledge from teacher to student using a single model in memory:
+   - Teacher (adapter disabled): document + question → logits
+   - Student (adapter enabled): question + cartridge KV cache → logits
+3. **Inference**: The trained cartridge provides compressed document knowledge as a KV cache prefix
+
+## Run
+
+### 1. Synthesize training data
+
+```bash
+python synthesize.py \
+  --model Qwen/Qwen3-4B \
+  --corpus_path /path/to/document.txt \
+  --out_jsonl distill.jsonl \
+  --num_samples 1024 \
+  --use_vllm
+```
+
+With `--use_vllm`, the document is cached and reused across all samples via automatic prefix caching.
+
+### 2. Train cartridge
+
+```bash
+python train_distill.py \
+  --model Qwen/Qwen3-4B \
+  --document /path/to/document.txt \
+  --distill_jsonl distill.jsonl \
+  --output_dir cartridge_adapter \
+  --num_virtual_tokens 256 \
+  --num_frozen_tokens 1 \
+  --max_steps 500
+```
+
+If you want to follow the arXiv paper example locally, you can use the LaTeX source included in this repo at
+`examples/cartridge_self_study/data/cartridges.tex` (download it first):
+
+```bash
+mkdir -p examples/cartridge_self_study/data
+curl -L -o examples/cartridge_self_study/data/cartridges.tex \
+  https://raw.githubusercontent.com/HazyResearch/cartridges/refs/heads/main/examples/arxiv/cartridges.tex
+```
+
+### 3. Load and use cartridge
+
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from peft import PeftModel
+
+model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3-4B")
+model = PeftModel.from_pretrained(model, "cartridge_adapter")
+
+tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-4B")
+inputs = tokenizer("What is the document about?", return_tensors="pt")
+outputs = model.generate(**inputs, max_new_tokens=100)
+print(tokenizer.decode(outputs[0], skip_special_tokens=True))
+```
+
+## arXiv example
+
+Convenience wrappers for training on the Cartridges paper LaTeX:
+
+```bash
+# From the repo root:
+# Synthesize QA pairs (uses vLLM with prefix caching)
+python examples/cartridge_self_study/arxiv_synthesize.py \
+  --model Qwen/Qwen3-4B \
+  --corpus_path examples/cartridge_self_study/data/cartridges.tex \
+  --num_samples 1024 \
+  --use_vllm
+
+# Train cartridge
+python examples/cartridge_self_study/arxiv_train.py \
+  --model Qwen/Qwen3-4B \
+  --document examples/cartridge_self_study/data/cartridges.tex \
+  --distill_jsonl distill.jsonl \
+  --output_dir cartridge_adapter \
+  --max_steps 500
+```
diff --git a/examples/cartridge_self_study/arxiv_synthesize.py b/examples/cartridge_self_study/arxiv_synthesize.py
new file mode 100644
index 0000000..3a8e579
--- /dev/null
+++ b/examples/cartridge_self_study/arxiv_synthesize.py
@@ -0,0 +1,95 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+import argparse
+from pathlib import Path
+
+from synthesize import synthesize_self_study_jsonl
+from transformers import AutoTokenizer
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model", type=str, default="Qwen/Qwen2.5-0.5B-Instruct")
+    parser.add_argument(
+        "--corpus_path",
+        type=str,
+        default=str(Path(__file__).resolve().parent / "data/cartridges.tex"),
+    )
+    parser.add_argument("--out_jsonl", type=str, default="distill.jsonl")
+    parser.add_argument("--num_samples", type=int, default=256)
+    parser.add_argument("--seed_prompts", type=str, default="structuring,summarization,question,use_cases,creative")
+    parser.add_argument("--max_new_tokens", type=int, default=512)
+    parser.add_argument("--temperature", type=float, default=0.7)
+    parser.add_argument("--top_p", type=float, default=0.95)
+    parser.add_argument("--max_corpus_tokens", type=int, default=2048)
+    parser.add_argument(
+        "--use_vllm",
+        action="store_true",
+        help="Use vLLM for faster generation with automatic prefix caching.",
+    )
+    parser.add_argument("--seed", type=int, default=0, help="Seed for deterministic prompt-type shuffling.")
+    parser.add_argument(
+        "--tensor_parallel_size",
+        type=int,
+        default=1,
+        help="Tensor parallel size for vLLM (number of GPUs).",
+    )
+    args = parser.parse_args()
+
+    corpus_text = Path(args.corpus_path).read_text(encoding="utf-8")
+    tokenizer = AutoTokenizer.from_pretrained(args.model)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    if args.max_corpus_tokens is not None:
+        ids = tokenizer(
+            corpus_text,
+            add_special_tokens=False,
+            truncation=True,
+            max_length=args.max_corpus_tokens,
+        )["input_ids"]
+        corpus_text = tokenizer.decode(ids, skip_special_tokens=True)
+
+    if args.use_vllm:
+        from vllm import LLM
+
+        model = LLM(
+            model=args.model,
+            tensor_parallel_size=args.tensor_parallel_size,
+            enable_prefix_caching=True,
+        )
+    else:
+        import torch
+        from transformers import AutoModelForCausalLM
+
+        model = AutoModelForCausalLM.from_pretrained(args.model, dtype=torch.bfloat16, device_map="auto")
+
+    synthesize_self_study_jsonl(
+        output_path=Path(args.out_jsonl),
+        model=model,
+        tokenizer=tokenizer,
+        corpus_text=corpus_text,
+        num_samples=args.num_samples,
+        seed_prompt_types=[s.strip() for s in args.seed_prompts.split(",") if s.strip()],
+        max_new_tokens=args.max_new_tokens,
+        temperature=args.temperature,
+        top_p=args.top_p,
+        use_vllm=args.use_vllm,
+        seed=args.seed,
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/cartridge_self_study/arxiv_train.py b/examples/cartridge_self_study/arxiv_train.py
new file mode 100644
index 0000000..987a3c1
--- /dev/null
+++ b/examples/cartridge_self_study/arxiv_train.py
@@ -0,0 +1,105 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+import argparse
+from pathlib import Path
+
+import torch
+from train_distill import DistillationCollator, DistillationTrainer, DistillJsonlDataset
+from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
+
+from peft import CartridgeConfig, get_peft_model
+from peft.tuners.cartridge.utils import initialize_kv_prefix_from_text
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model", type=str, required=True, help="Model to use for both teacher and student")
+    parser.add_argument("--document", type=str, required=True, help="Path to text file for KV cache initialization")
+    parser.add_argument("--distill_jsonl", type=str, default="distill.jsonl")
+    parser.add_argument("--output_dir", type=str, default="cartridge_adapter")
+    parser.add_argument("--num_virtual_tokens", type=int, default=256)
+    parser.add_argument("--num_frozen_tokens", type=int, default=1)
+    parser.add_argument("--top_k", type=int, default=20)
+    parser.add_argument("--per_device_train_batch_size", type=int, default=1)
+    parser.add_argument("--learning_rate", type=float, default=1e-3)
+    parser.add_argument("--max_steps", type=int, default=1000)
+    parser.add_argument("--device", type=str, default="cuda", choices=["cpu", "mps", "cuda", "xpu"])
+    parser.add_argument(
+        "--max_init_length", type=int, default=2048, help="Max tokens for text initialization (truncate long docs)"
+    )
+    args = parser.parse_args()
+
+    if args.device == "mps" and not (hasattr(torch.backends, "mps") and torch.backends.mps.is_available()):
+        raise ValueError("Requested device 'mps' but MPS is not available.")
+    if args.device == "cuda" and not torch.cuda.is_available():
+        raise ValueError("Requested device 'cuda' but CUDA is not available.")
+
+    model_dtype = torch.float16 if args.device in {"cuda", "mps"} else None
+    device_map = args.device if args.device != "cpu" else None
+
+    tokenizer = AutoTokenizer.from_pretrained(args.model)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    base_model = AutoModelForCausalLM.from_pretrained(args.model, dtype=model_dtype, device_map=device_map)
+    model = get_peft_model(
+        base_model,
+        CartridgeConfig(
+            task_type="CAUSAL_LM",
+            num_virtual_tokens=args.num_virtual_tokens,
+            num_frozen_tokens=args.num_frozen_tokens,
+        ),
+    )
+
+    print(f"Initializing cartridge from document: {args.document}", flush=True)
+    document_text = Path(args.document).read_text()
+    initialize_kv_prefix_from_text(
+        model,
+        tokenizer,
+        text=document_text,
+        use_chat_template=False,
+        max_length=args.max_init_length,
+    )
+    print(f"Cartridge initialized with {args.num_virtual_tokens} tokens from text", flush=True)
+
+    ds = DistillJsonlDataset(args.distill_jsonl)
+    collator = DistillationCollator(tokenizer)
+
+    train_args = TrainingArguments(
+        output_dir=args.output_dir,
+        per_device_train_batch_size=args.per_device_train_batch_size,
+        learning_rate=args.learning_rate,
+        max_steps=args.max_steps,
+        logging_steps=10,
+        save_steps=100,
+        report_to=[],
+        remove_unused_columns=False,
+        use_cpu=args.device == "cpu",
+        dataloader_pin_memory=False,
+    )
+
+    trainer = DistillationTrainer(
+        model=model,
+        top_k=args.top_k,
+        args=train_args,
+        train_dataset=ds,
+        data_collator=collator,
+    )
+    trainer.train()
+    model.save_pretrained(args.output_dir)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/cartridge_self_study/requirements.txt b/examples/cartridge_self_study/requirements.txt
new file mode 100644
index 0000000..2e37a27
--- /dev/null
+++ b/examples/cartridge_self_study/requirements.txt
@@ -0,0 +1,4 @@
+torch
+transformers
+peft
+vllm
diff --git a/examples/cartridge_self_study/synthesize.py b/examples/cartridge_self_study/synthesize.py
new file mode 100644
index 0000000..fdbb886
--- /dev/null
+++ b/examples/cartridge_self_study/synthesize.py
@@ -0,0 +1,368 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+import argparse
+import json
+import random
+from pathlib import Path
+
+from transformers import AutoTokenizer
+
+
+SEED_PROMPTS = {
+    "structuring": (
+        "Generate a single instruction asking an LLM to structure information from the document above. "
+        "Be specific about what section or topic to structure. "
+        "Output only the instruction, nothing else."
+    ),
+    "summarization": (
+        "Generate a single instruction asking an LLM to summarize part of the document above. "
+        "Be explicit about which section to summarize. "
+        "Output only the instruction, nothing else."
+    ),
+    "question": (
+        "Generate a question that tests knowledge of the document above. "
+        "Include specific details (names, dates, numbers) so the question is unambiguous. "
+        "Output only the question, nothing else."
+    ),
+    "use_cases": (
+        "Think of a practical real-world task someone could accomplish using knowledge from the document. "
+        "Generate a single question or instruction reflecting that use case. "
+        "Output only the question/instruction, nothing else."
+    ),
+    "creative": (
+        "Generate a creative question inspired by the document above. Output only the question, nothing else."
+    ),
+}
+
+# Chat template kwargs to disable thinking mode for models like Qwen3
+CHAT_TEMPLATE_KWARGS = {"enable_thinking": False}
+MAX_NEW_TOKENS_FOR_QUESTIONS = 256
+
+
+def synthesize_self_study_jsonl(
+    *,
+    output_path: Path,
+    model,
+    tokenizer,
+    corpus_text: str,
+    num_samples: int,
+    seed_prompt_types: list[str],
+    max_new_tokens: int,
+    temperature: float,
+    top_p: float,
+    use_vllm: bool = False,
+    seed: int = 0,
+):
+    """
+    Synthesize self-study data for cartridge training.
+
+    Uses the full corpus as context for all samples, varying only the seed prompt.
+    With vLLM's prefix caching, the document KV cache is computed once and reused.
+
+    If use_vllm=True, `model` should be a vllm.LLM instance.
+    Otherwise, `model` should be a HuggingFace model.
+    """
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    if output_path.exists():
+        output_path.unlink()
+
+    for t in seed_prompt_types:
+        if t not in SEED_PROMPTS:
+            raise ValueError(f"Unknown seed prompt type '{t}', expected one of: {sorted(SEED_PROMPTS)}")
+
+    # Pre-generate prompt indices (cycling through seed prompt types).
+    prompt_indices = [i % len(seed_prompt_types) for i in range(num_samples)]
+    rng = random.Random(seed)
+    rng.shuffle(prompt_indices)
+
+    if use_vllm:
+        _synthesize_vllm(
+            output_path=output_path,
+            model=model,
+            tokenizer=tokenizer,
+            corpus_text=corpus_text,
+            seed_prompt_types=seed_prompt_types,
+            prompt_indices=prompt_indices,
+            max_new_tokens=max_new_tokens,
+            temperature=temperature,
+            top_p=top_p,
+        )
+    else:
+        _synthesize_hf(
+            output_path=output_path,
+            model=model,
+            tokenizer=tokenizer,
+            corpus_text=corpus_text,
+            seed_prompt_types=seed_prompt_types,
+            prompt_indices=prompt_indices,
+            max_new_tokens=max_new_tokens,
+            temperature=temperature,
+            top_p=top_p,
+        )
+
+
+def _synthesize_vllm(
+    *,
+    output_path: Path,
+    model,
+    tokenizer,
+    corpus_text: str,
+    seed_prompt_types: list[str],
+    prompt_indices: list[int],
+    max_new_tokens: int,
+    temperature: float,
+    top_p: float,
+):
+    """Synthesize using vLLM with prefix caching (two-stage like original cartridges).
+
+    Stage 1: Generate questions using meta-prompts (all share document prefix)
+    Stage 2: Generate answers to those questions (all share document prefix)
+    """
+    from vllm import SamplingParams
+
+    # Stage 1: Generate questions
+    question_messages = [
+        [
+            {"role": "system", "content": corpus_text},
+            {"role": "user", "content": SEED_PROMPTS[seed_prompt_types[prompt_idx]]},
+        ]
+        for prompt_idx in prompt_indices
+    ]
+
+    question_params = SamplingParams(
+        max_tokens=MAX_NEW_TOKENS_FOR_QUESTIONS,
+        temperature=temperature if temperature > 0 else 0.0,
+        top_p=top_p if temperature > 0 else 1.0,
+    )
+
+    print("Stage 1: Generating questions...")
+    question_outputs = model.chat(
+        question_messages,
+        question_params,
+        use_tqdm=True,
+        chat_template_kwargs=CHAT_TEMPLATE_KWARGS,
+    )
+    questions = [out.outputs[0].text.strip() for out in question_outputs]
+
+    # Stage 2: Generate answers
+    answer_messages = [
+        [
+            {"role": "system", "content": corpus_text},
+            {"role": "user", "content": question},
+        ]
+        for question in questions
+    ]
+
+    answer_params = SamplingParams(
+        max_tokens=max_new_tokens,
+        temperature=0.0,
+        top_p=1.0,
+    )
+
+    print("Stage 2: Generating answers...")
+    answer_outputs = model.chat(
+        answer_messages,
+        answer_params,
+        use_tqdm=True,
+        chat_template_kwargs=CHAT_TEMPLATE_KWARGS,
+    )
+
+    # Build training records
+    for i, (question, answer_out) in enumerate(zip(questions, answer_outputs)):
+        # Get the answer token IDs directly from vLLM output (avoids decode/re-encode mismatch)
+        answer_ids = list(answer_out.outputs[0].token_ids)
+
+        teacher_prompt_ids = tokenizer.apply_chat_template(
+            [{"role": "system", "content": corpus_text}, {"role": "user", "content": question}],
+            tokenize=True,
+            add_generation_prompt=True,
+            **CHAT_TEMPLATE_KWARGS,
+        )
+        student_prompt_ids = tokenizer.apply_chat_template(
+            [{"role": "user", "content": question}],
+            tokenize=True,
+            add_generation_prompt=True,
+            **CHAT_TEMPLATE_KWARGS,
+        )
+
+        record = {
+            "teacher_input_ids": teacher_prompt_ids + answer_ids,
+            "student_input_ids": student_prompt_ids + answer_ids,
+            "ctx_len": len(teacher_prompt_ids) - len(student_prompt_ids),
+        }
+        with output_path.open("a", encoding="utf-8") as f:
+            f.write(json.dumps(record) + "\n")
+
+
+def _synthesize_hf(
+    *,
+    output_path: Path,
+    model,
+    tokenizer,
+    corpus_text: str,
+    seed_prompt_types: list[str],
+    prompt_indices: list[int],
+    max_new_tokens: int,
+    temperature: float,
+    top_p: float,
+):
+    """Synthesize using HuggingFace transformers (two-stage, one sample at a time)."""
+    import torch
+    from tqdm import tqdm
+
+    device = getattr(model, "device", torch.device("cpu"))
+    model.eval()
+
+    for prompt_idx in tqdm(prompt_indices, desc="Generating samples"):
+        meta_prompt = SEED_PROMPTS[seed_prompt_types[prompt_idx]]
+
+        # Stage 1: Generate question
+        question_input = tokenizer.apply_chat_template(
+            [{"role": "system", "content": corpus_text}, {"role": "user", "content": meta_prompt}],
+            tokenize=True,
+            add_generation_prompt=True,
+            return_tensors="pt",
+            return_dict=False,
+            **CHAT_TEMPLATE_KWARGS,
+        ).to(device)
+
+        gen_kwargs = {
+            "max_new_tokens": MAX_NEW_TOKENS_FOR_QUESTIONS,
+            "do_sample": temperature > 0,
+            "pad_token_id": tokenizer.pad_token_id or tokenizer.eos_token_id,
+        }
+        if temperature > 0:
+            gen_kwargs["temperature"] = max(temperature, 1e-5)
+            gen_kwargs["top_p"] = top_p
+
+        with torch.no_grad():
+            question_out = model.generate(question_input, **gen_kwargs)
+
+        question_tokens = question_out[0, question_input.shape[1] :].tolist()
+        question = tokenizer.decode(question_tokens, skip_special_tokens=True).strip()
+
+        # Stage 2: Generate answer
+        teacher_input = tokenizer.apply_chat_template(
+            [{"role": "system", "content": corpus_text}, {"role": "user", "content": question}],
+            tokenize=True,
+            add_generation_prompt=True,
+            return_tensors="pt",
+            return_dict=False,
+            **CHAT_TEMPLATE_KWARGS,
+        ).to(device)
+
+        student_input = tokenizer.apply_chat_template(
+            [{"role": "user", "content": question}],
+            tokenize=True,
+            add_generation_prompt=True,
+            return_tensors="pt",
+            return_dict=False,
+            **CHAT_TEMPLATE_KWARGS,
+        ).to(device)
+
+        with torch.no_grad():
+            answer_out = model.generate(
+                teacher_input,
+                max_new_tokens=max_new_tokens,
+                do_sample=False,
+                pad_token_id=tokenizer.pad_token_id or tokenizer.eos_token_id,
+            )
+
+        answer_tokens = answer_out[0, teacher_input.shape[1] :].tolist()
+
+        record = {
+            "teacher_input_ids": answer_out[0].tolist(),
+            "student_input_ids": student_input[0].tolist() + answer_tokens,
+            "ctx_len": int(teacher_input.shape[1]) - int(student_input.shape[1]),
+        }
+        with output_path.open("a", encoding="utf-8") as f:
+            f.write(json.dumps(record) + "\n")
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model", type=str, default="Qwen/Qwen2.5-0.5B-Instruct")
+    parser.add_argument("--corpus_path", type=str, required=True)
+    parser.add_argument("--out_jsonl", type=str, required=True)
+    parser.add_argument("--num_samples", type=int, default=1024)
+    parser.add_argument("--seed_prompts", type=str, default="structuring,summarization,question,use_cases,creative")
+    parser.add_argument("--max_new_tokens", type=int, default=512)
+    parser.add_argument("--temperature", type=float, default=0.7)
+    parser.add_argument("--top_p", type=float, default=0.95)
+    parser.add_argument(
+        "--max_corpus_tokens",
+        type=int,
+        default=None,
+        help="Optional cap on the number of tokens used from the corpus.",
+    )
+    parser.add_argument(
+        "--use_vllm",
+        action="store_true",
+        help="Use vLLM for faster generation with automatic prefix caching.",
+    )
+    parser.add_argument("--seed", type=int, default=0, help="Seed for deterministic prompt-type shuffling.")
+    parser.add_argument(
+        "--tensor_parallel_size",
+        type=int,
+        default=1,
+        help="Tensor parallel size for vLLM (number of GPUs).",
+    )
+    args = parser.parse_args()
+
+    corpus_text = Path(args.corpus_path).read_text(encoding="utf-8")
+    tokenizer = AutoTokenizer.from_pretrained(args.model)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    if args.max_corpus_tokens is not None:
+        ids = tokenizer(
+            corpus_text,
+            add_special_tokens=False,
+            truncation=True,
+            max_length=args.max_corpus_tokens,
+        )["input_ids"]
+        corpus_text = tokenizer.decode(ids, skip_special_tokens=True)
+
+    if args.use_vllm:
+        from vllm import LLM
+
+        model = LLM(
+            model=args.model,
+            tensor_parallel_size=args.tensor_parallel_size,
+            enable_prefix_caching=True,
+        )
+    else:
+        import torch
+        from transformers import AutoModelForCausalLM
+
+        model = AutoModelForCausalLM.from_pretrained(args.model, dtype=torch.bfloat16, device_map="auto")
+
+    synthesize_self_study_jsonl(
+        output_path=Path(args.out_jsonl),
+        model=model,
+        tokenizer=tokenizer,
+        corpus_text=corpus_text,
+        num_samples=args.num_samples,
+        seed_prompt_types=[s.strip() for s in args.seed_prompts.split(",") if s.strip()],
+        max_new_tokens=args.max_new_tokens,
+        temperature=args.temperature,
+        top_p=args.top_p,
+        use_vllm=args.use_vllm,
+        seed=args.seed,
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/cartridge_self_study/train_distill.py b/examples/cartridge_self_study/train_distill.py
new file mode 100644
index 0000000..46a6c0d
--- /dev/null
+++ b/examples/cartridge_self_study/train_distill.py
@@ -0,0 +1,212 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+import argparse
+import json
+from pathlib import Path
+
+import torch
+import torch.nn.functional as F
+from torch.utils.data import Dataset
+from transformers import AutoModelForCausalLM, AutoTokenizer, Trainer, TrainingArguments
+
+from peft import CartridgeConfig, get_peft_model
+from peft.tuners.cartridge.utils import initialize_kv_prefix_from_text
+
+
+class DistillJsonlDataset(Dataset):
+    def __init__(self, path: str | Path):
+        self.rows = []
+        with Path(path).open("r", encoding="utf-8") as f:
+            for line in f:
+                if line.strip():
+                    self.rows.append(json.loads(line))
+
+    def __len__(self) -> int:
+        return len(self.rows)
+
+    def __getitem__(self, idx: int):
+        r = self.rows[idx]
+        return {
+            "teacher_input_ids": r["teacher_input_ids"],
+            "student_input_ids": r["student_input_ids"],
+            "ctx_len": r["ctx_len"],
+        }
+
+
+class DistillationCollator:
+    def __init__(self, tokenizer):
+        self.tokenizer = tokenizer
+
+    def __call__(self, features):
+        teacher_ids = [{"input_ids": f["teacher_input_ids"]} for f in features]
+        student_ids = [{"input_ids": f["student_input_ids"]} for f in features]
+        teacher_batch = self.tokenizer.pad(teacher_ids, return_tensors="pt")
+        student_batch = self.tokenizer.pad(student_ids, return_tensors="pt")
+        ctx_len = torch.tensor([int(f["ctx_len"]) for f in features], dtype=torch.long)
+        return {
+            "teacher_input_ids": teacher_batch["input_ids"],
+            "teacher_attention_mask": teacher_batch["attention_mask"],
+            "student_input_ids": student_batch["input_ids"],
+            "student_attention_mask": student_batch["attention_mask"],
+            "ctx_len": ctx_len,
+        }
+
+
+class DistillationTrainer(Trainer):
+    def __init__(self, *args, top_k: int = 20, teacher_temperature: float = 1.0, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.top_k = int(top_k)
+        self.teacher_temperature = float(teacher_temperature)
+
+    def compute_loss(self, model, inputs, return_outputs=False, **kwargs):
+        teacher_input_ids = inputs["teacher_input_ids"].to(model.device)
+        teacher_attention_mask = inputs["teacher_attention_mask"].to(model.device)
+        student_input_ids = inputs["student_input_ids"].to(model.device)
+        student_attention_mask = inputs["student_attention_mask"].to(model.device)
+        ctx_len = inputs["ctx_len"].to(model.device)
+
+        with torch.no_grad():
+            with model.disable_adapter():
+                teacher_out = model(
+                    input_ids=teacher_input_ids,
+                    attention_mask=teacher_attention_mask,
+                    use_cache=False,
+                )
+            teacher_logits = teacher_out.logits / max(self.teacher_temperature, 1e-5)
+
+        student_out = model(
+            input_ids=student_input_ids,
+            attention_mask=student_attention_mask,
+            use_cache=False,
+        )
+        student_logits = student_out.logits
+
+        # Vectorized distillation loss (avoids Python `.item()` in per-example indexing).
+        # Align teacher logits to student positions via the per-example `ctx_len` offset.
+        student_logits = student_logits[:, :-1, :]  # [B, Ls-1, V]
+        seq_len = student_logits.shape[1]
+        pos = torch.arange(seq_len, device=student_logits.device)[None, :]  # [1, Ls-1]
+
+        student_len = student_attention_mask.sum(dim=1).to(torch.long)  # [B]
+        valid = pos < (student_len - 1).clamp(min=0)[:, None]  # [B, Ls-1]
+
+        teacher_pos = ctx_len[:, None] + pos  # [B, Ls-1]
+        in_bounds = teacher_pos < teacher_logits.shape[1]
+        valid = valid & in_bounds
+
+        teacher_pos = teacher_pos.clamp(min=0, max=teacher_logits.shape[1] - 1)
+        teacher_slice = teacher_logits.gather(
+            dim=1, index=teacher_pos[:, :, None].expand(-1, -1, teacher_logits.shape[-1])
+        )  # [B, Ls-1, V]
+
+        k = min(self.top_k, teacher_slice.shape[-1])
+        topk_ids = torch.topk(teacher_slice, k=k, dim=-1).indices  # [B, Ls-1, K]
+        teacher_logprobs = F.log_softmax(teacher_slice, dim=-1).gather(-1, topk_ids)
+        student_logprobs = F.log_softmax(student_logits, dim=-1).gather(-1, topk_ids)
+
+        loss_by_pos = -(teacher_logprobs.exp() * student_logprobs).sum(dim=-1)  # [B, Ls-1]
+        loss_by_pos = loss_by_pos.masked_fill(~valid, 0.0)
+
+        denom = valid.sum(dim=1).clamp(min=1)
+        per_example = loss_by_pos.sum(dim=1) / denom
+        if valid.any():
+            loss = per_example[valid.any(dim=1)].mean()
+        else:
+            loss = student_logits.new_zeros(())
+        return (loss, student_out) if return_outputs else loss
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model", type=str, required=True, help="Model to use for both teacher and student")
+    parser.add_argument("--distill_jsonl", type=str, required=True)
+    parser.add_argument("--output_dir", type=str, required=True)
+    parser.add_argument("--document", type=str, required=True, help="Path to text file for KV cache initialization")
+    parser.add_argument("--num_virtual_tokens", type=int, default=256)
+    parser.add_argument("--num_frozen_tokens", type=int, default=1)
+    parser.add_argument("--top_k", type=int, default=20)
+    parser.add_argument("--per_device_train_batch_size", type=int, default=1)
+    parser.add_argument("--learning_rate", type=float, default=1e-3)
+    parser.add_argument("--max_steps", type=int, default=1000)
+    parser.add_argument("--device", type=str, default="cuda", choices=["cpu", "mps", "cuda", "xpu"])
+    parser.add_argument(
+        "--max_init_length", type=int, default=2048, help="Max tokens for text initialization (truncate long docs)"
+    )
+    args = parser.parse_args()
+
+    if args.device == "mps" and not (hasattr(torch.backends, "mps") and torch.backends.mps.is_available()):
+        raise ValueError("Requested device 'mps' but MPS is not available.")
+    if args.device == "xpu" and not torch.xpu.is_available():
+        raise ValueError("Requested device 'xpu' but XPU is not available.")
+    if args.device == "cuda" and not torch.cuda.is_available():
+        raise ValueError("Requested device 'cuda' but CUDA is not available.")
+
+    model_dtype = torch.float16 if args.device in {"cuda", "mps", "xpu"} else None
+    device_map = args.device if args.device != "cpu" else None
+
+    tokenizer = AutoTokenizer.from_pretrained(args.model)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    base_model = AutoModelForCausalLM.from_pretrained(args.model, dtype=model_dtype, device_map=device_map)
+    model = get_peft_model(
+        base_model,
+        CartridgeConfig(
+            task_type="CAUSAL_LM",
+            num_virtual_tokens=args.num_virtual_tokens,
+            num_frozen_tokens=args.num_frozen_tokens,
+        ),
+    )
+
+    print(f"Initializing cartridge from document: {args.document}", flush=True)
+    document_text = Path(args.document).read_text()
+    initialize_kv_prefix_from_text(
+        model,
+        tokenizer,
+        text=document_text,
+        use_chat_template=False,
+        max_length=args.max_init_length,
+    )
+    print(f"Cartridge initialized with {args.num_virtual_tokens} tokens from text", flush=True)
+
+    ds = DistillJsonlDataset(args.distill_jsonl)
+    collator = DistillationCollator(tokenizer)
+
+    train_args = TrainingArguments(
+        output_dir=args.output_dir,
+        per_device_train_batch_size=args.per_device_train_batch_size,
+        learning_rate=args.learning_rate,
+        max_steps=args.max_steps,
+        logging_steps=10,
+        save_steps=100,
+        report_to=[],
+        remove_unused_columns=False,
+        use_cpu=args.device == "cpu",
+        dataloader_pin_memory=False,
+    )
+
+    trainer = DistillationTrainer(
+        model=model,
+        top_k=args.top_k,
+        args=train_args,
+        train_dataset=ds,
+        data_collator=collator,
+    )
+    trainer.train()
+    model.save_pretrained(args.output_dir)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/causal_language_modeling/accelerate_ds_zero3_cpu_offload_config.yaml b/examples/causal_language_modeling/accelerate_ds_zero3_cpu_offload_config.yaml
new file mode 100644
index 0000000..a4a0bcf
--- /dev/null
+++ b/examples/causal_language_modeling/accelerate_ds_zero3_cpu_offload_config.yaml
@@ -0,0 +1,22 @@
+compute_environment: LOCAL_MACHINE
+deepspeed_config:
+  gradient_accumulation_steps: 1
+  gradient_clipping: 1.0
+  offload_optimizer_device: none
+  offload_param_device: none
+  zero3_init_flag: true
+  zero3_save_16bit_model: true
+  zero_stage: 3
+distributed_type: DEEPSPEED
+downcast_bf16: 'no'
+dynamo_backend: 'NO'
+fsdp_config: {}
+machine_rank: 0
+main_training_function: main
+megatron_lm_config: {}
+mixed_precision: 'no'
+num_machines: 1
+num_processes: 1
+rdzv_backend: static
+same_network: true
+use_cpu: false
\ No newline at end of file
diff --git a/examples/causal_language_modeling/peft_ln_tuning_clm.ipynb b/examples/causal_language_modeling/peft_ln_tuning_clm.ipynb
new file mode 100644
index 0000000..f4f75e7
--- /dev/null
+++ b/examples/causal_language_modeling/peft_ln_tuning_clm.ipynb
@@ -0,0 +1,1391 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "71fbfca2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import AutoModelForCausalLM\n",
+    "from peft import get_peft_config, get_peft_model, LNTuningConfig, TaskType, PeftType\n",
+    "import torch\n",
+    "from datasets import load_dataset\n",
+    "import os\n",
+    "from transformers import AutoTokenizer\n",
+    "from torch.utils.data import DataLoader\n",
+    "from transformers import default_data_collator, get_linear_schedule_with_warmup\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "# Hyper-parameters\n",
+    "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "model_name_or_path = \"bigscience/bloomz-560m\"\n",
+    "tokenizer_name_or_path = \"bigscience/bloomz-560m\"\n",
+    "peft_config = LNTuningConfig(\n",
+    "    task_type=TaskType.CAUSAL_LM,\n",
+    ")\n",
+    "\n",
+    "dataset_name = \"twitter_complaints\"\n",
+    "checkpoint_name = f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}_v1.pt\".replace(\n",
+    "    \"/\", \"_\"\n",
+    ")\n",
+    "text_column = \"Tweet text\"\n",
+    "label_column = \"text_label\"\n",
+    "max_length = 64\n",
+    "lr = 5e-2\n",
+    "num_epochs = 50\n",
+    "batch_size = 8"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a617882d",
+   "metadata": {},
+   "source": [
+    "## Load and Process Dataset for LM Training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e1a3648b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['Unlabeled', 'complaint', 'no complaint']\n",
+      "DatasetDict({\n",
+      "    train: Dataset({\n",
+      "        features: ['Tweet text', 'ID', 'Label', 'text_label'],\n",
+      "        num_rows: 50\n",
+      "    })\n",
+      "    test: Dataset({\n",
+      "        features: ['Tweet text', 'ID', 'Label', 'text_label'],\n",
+      "        num_rows: 3399\n",
+      "    })\n",
+      "})\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'Tweet text': '@HMRCcustomers No this is my first job',\n",
+       " 'ID': 0,\n",
+       " 'Label': 2,\n",
+       " 'text_label': 'no complaint'}"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dataset = load_dataset(\n",
+    "    \"parquet\",\n",
+    "    data_files={\n",
+    "        \"train\": f\"hf://datasets/ought/raft@refs/convert/parquet/{dataset_name}/train/0000.parquet\",\n",
+    "        \"test\": f\"hf://datasets/ought/raft@refs/convert/parquet/{dataset_name}/test/0000.parquet\"\n",
+    "    }\n",
+    ")\n",
+    "\n",
+    "classes = [k.replace(\"_\", \" \") for k in dataset[\"train\"].features[\"Label\"].names]\n",
+    "print(classes)\n",
+    "dataset = dataset.map(\n",
+    "    lambda x: {\"text_label\": [classes[label] for label in x[\"Label\"]]},\n",
+    "    batched=True,\n",
+    "    num_proc=1,\n",
+    ")\n",
+    "print(dataset)\n",
+    "dataset[\"train\"][0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "fe12d4d3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Running tokenizer on dataset: 100%|██████████| 50/50 [00:00<00:00, 3551.43 examples/s]\n",
+      "Running tokenizer on dataset: 100%|██████████| 3399/3399 [00:00<00:00, 8558.01 examples/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# data preprocessing\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)\n",
+    "if tokenizer.pad_token_id is None:\n",
+    "    tokenizer.pad_token_id = tokenizer.eos_token_id\n",
+    "target_max_length = max([len(tokenizer(class_label)[\"input_ids\"]) for class_label in classes])\n",
+    "print(target_max_length)\n",
+    "\n",
+    "\n",
+    "def preprocess_function(examples):\n",
+    "    batch_size = len(examples[text_column])\n",
+    "    inputs = [f\"{text_column} : {x} Label : \" for x in examples[text_column]]\n",
+    "    targets = [str(x) for x in examples[label_column]]\n",
+    "    model_inputs = tokenizer(inputs)\n",
+    "    labels = tokenizer(targets, add_special_tokens=False)  # don't add bos token because we concatenate with inputs\n",
+    "    for i in range(batch_size):\n",
+    "        sample_input_ids = model_inputs[\"input_ids\"][i]\n",
+    "        label_input_ids = labels[\"input_ids\"][i] + [tokenizer.eos_token_id]\n",
+    "        # print(i, sample_input_ids, label_input_ids)\n",
+    "        model_inputs[\"input_ids\"][i] = sample_input_ids + label_input_ids\n",
+    "        labels[\"input_ids\"][i] = [-100] * len(sample_input_ids) + label_input_ids\n",
+    "        model_inputs[\"attention_mask\"][i] = [1] * len(model_inputs[\"input_ids\"][i])\n",
+    "    # print(model_inputs)\n",
+    "    for i in range(batch_size):\n",
+    "        sample_input_ids = model_inputs[\"input_ids\"][i]\n",
+    "        label_input_ids = labels[\"input_ids\"][i]\n",
+    "        model_inputs[\"input_ids\"][i] = [tokenizer.pad_token_id] * (\n",
+    "            max_length - len(sample_input_ids)\n",
+    "        ) + sample_input_ids\n",
+    "        model_inputs[\"attention_mask\"][i] = [0] * (max_length - len(sample_input_ids)) + model_inputs[\n",
+    "            \"attention_mask\"\n",
+    "        ][i]\n",
+    "        labels[\"input_ids\"][i] = [-100] * (max_length - len(sample_input_ids)) + label_input_ids\n",
+    "        model_inputs[\"input_ids\"][i] = torch.tensor(model_inputs[\"input_ids\"][i][:max_length])\n",
+    "        model_inputs[\"attention_mask\"][i] = torch.tensor(model_inputs[\"attention_mask\"][i][:max_length])\n",
+    "        labels[\"input_ids\"][i] = torch.tensor(labels[\"input_ids\"][i][:max_length])\n",
+    "    model_inputs[\"labels\"] = labels[\"input_ids\"]\n",
+    "    return model_inputs\n",
+    "\n",
+    "\n",
+    "processed_datasets = dataset.map(\n",
+    "    preprocess_function,\n",
+    "    batched=True,\n",
+    "    num_proc=1,\n",
+    "    remove_columns=dataset[\"train\"].column_names,\n",
+    "    load_from_cache_file=False,\n",
+    "    desc=\"Running tokenizer on dataset\",\n",
+    ")\n",
+    "\n",
+    "train_dataset = processed_datasets[\"train\"]\n",
+    "eval_dataset = processed_datasets[\"train\"]\n",
+    "\n",
+    "\n",
+    "train_dataloader = DataLoader(\n",
+    "    train_dataset, shuffle=True, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True\n",
+    ")\n",
+    "eval_dataloader = DataLoader(eval_dataset, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "641b21fe",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Running tokenizer on dataset: 100%|██████████| 3399/3399 [00:00<00:00, 17380.64 examples/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'input_ids': tensor([[     3,      3,      3,      3,      3,      3,      3,      3,      3,\n",
+       "               3,      3,      3,      3,      3,      3,      3,      3,      3,\n",
+       "               3,      3,      3,      3,      3,      3,      3,      3,      3,\n",
+       "          227985,   5484,    915,   2566,  74757,  64626,  12384,  44639,    613,\n",
+       "           52282,   2670,  79920,   3344,   1002,    368,  17646,  14472,   8348,\n",
+       "             664,    718,      4,  19036,     17,  31849,     17,   6312,     76,\n",
+       "              44,  62470,     56,     91,     50,  14839,     21,  77658,    915,\n",
+       "             210],\n",
+       "         [     3,      3,      3,      3,      3,      3,      3,      3,      3,\n",
+       "               3,      3,      3,      3,      3,      3,      3,      3,      3,\n",
+       "               3,      3,      3,      3,      3,      3,      3,      3,      3,\n",
+       "               3,      3,      3,      3, 227985,   5484,    915,    405, 187059,\n",
+       "            2256,    664,   2550,  18833,  18607, 162467,      4,   1387,   6199,\n",
+       "            3291,  23405,    613,   4657,  17082,    566,   3432,    368,  78851,\n",
+       "            1185,  61273,  23181,   1553,  15596,    212, 116057,  77658,    915,\n",
+       "             210],\n",
+       "         [     3,      3,      3,      3,      3,      3,      3,      3,      3,\n",
+       "               3,      3,      3,      3,      3,      3,      3,      3,      3,\n",
+       "               3,      3,      3,      3,      3,      3,      3,      3,      3,\n",
+       "               3,      3,      3,      3,      3,      3,      3, 227985,   5484,\n",
+       "             915,  39762,   2566,  22253,   6201,  75701,     15,    632,    718,\n",
+       "            5840,  10006,   6201,  18881,    427,   3804,  19528,    267, 158974,\n",
+       "            1320,    368,  10029,    632,  49666,     92,     34,  77658,    915,\n",
+       "             210],\n",
+       "         [     3,      3,      3,      3,      3,      3,      3,      3,      3,\n",
+       "               3,      3,      3,      3,      3,      3,      3,      3,      3,\n",
+       "               3, 227985,   5484,    915,   2566, 104565,   8695,   2089,   6140,\n",
+       "          109676,  99579,   1369,    512,    368,   4570,     54,    632,    368,\n",
+       "            1503, 241485, 132226,     15,    982,    727,   1152,  18100,    861,\n",
+       "           32596,  77597, 168154,   1306, 132226,   4346,  87843,     17, 130462,\n",
+       "             364,  32923,     89,     53,   8309,     20,     75,  77658,    915,\n",
+       "             210],\n",
+       "         [     3,      3,      3,      3,      3,      3,      3,      3,      3,\n",
+       "               3,      3,      3,      3,      3,      3,      3,      3,      3,\n",
+       "               3,      3,      3,      3,      3,      3,      3,      3,      3,\n",
+       "               3,      3,      3,      3,      3,      3,      3,      3,      3,\n",
+       "               3,      3,      3,      3,      3,      3,      3,      3,      3,\n",
+       "               3,      3,      3,      3,      3, 227985,   5484,    915,   2566,\n",
+       "           14173,   2960,  29906,    387,  20706,  49337,   1369,  77658,    915,\n",
+       "             210],\n",
+       "         [     3,      3,      3,      3,      3,      3,      3,      3,      3,\n",
+       "               3,      3,      3,      3,      3,      3,      3,      3,      3,\n",
+       "               3,      3,      3,      3,      3,      3,      3,      3,      3,\n",
+       "               3,      3,      3,      3,      3,      3,      3,      3,      3,\n",
+       "               3,      3,      3,      3,      3,      3,      3,      3,      3,\n",
+       "               3,      3,      3, 227985,   5484,    915,   2566, 219553,  45736,\n",
+       "           36876,   1713,     72,    707, 187205,  13002, 177324,  77658,    915,\n",
+       "             210],\n",
+       "         [     3,      3,      3,      3,      3,      3,      3,      3,      3,\n",
+       "               3,      3,      3,      3,      3,      3,      3,      3,      3,\n",
+       "               3,      3, 227985,   5484,    915,   2566, 233938,  28518,  13716,\n",
+       "             427,  28146,   1119,  17918,     17, 236706,    368, 214997,   7555,\n",
+       "           48659,   5276,  21600,    343,     17,  51416,  22403,    318,   1531,\n",
+       "            1306,   1130,  20934,    567, 101161, 184849,  87843,     17,   1594,\n",
+       "           15231,   2052,  16642,     20,   7180,     80,     26,  77658,    915,\n",
+       "             210],\n",
+       "         [     3,      3,      3,      3,      3,      3,      3,      3,      3,\n",
+       "               3,      3,      3,      3,      3,      3,      3,      3,      3,\n",
+       "          227985,   5484,    915,   2566,     80,   2068,    479,   2566,     80,\n",
+       "            1376,    878, 147587,   3904,    632,    368,   6084,  65673,  78851,\n",
+       "           11736,  15527,  19082,  33151,    461,     17,  45575,  17887,    632,\n",
+       "            5219,  14216,  68870,   5967,   1841,   4346,  87843,     17,   1594,\n",
+       "           14512,     27,     71,   8184,     19,    290,  63748,  77658,    915,\n",
+       "             210]]),\n",
+       " 'attention_mask': tensor([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
+       "          0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
+       "          1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],\n",
+       "         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
+       "          0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
+       "          1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],\n",
+       "         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
+       "          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
+       "          1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],\n",
+       "         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,\n",
+       "          1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
+       "          1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],\n",
+       "         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
+       "          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
+       "          0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],\n",
+       "         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
+       "          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
+       "          1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],\n",
+       "         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,\n",
+       "          1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
+       "          1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],\n",
+       "         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,\n",
+       "          1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
+       "          1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])}"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def test_preprocess_function(examples):\n",
+    "    batch_size = len(examples[text_column])\n",
+    "    inputs = [f\"{text_column} : {x} Label : \" for x in examples[text_column]]\n",
+    "    model_inputs = tokenizer(inputs)\n",
+    "    # print(model_inputs)\n",
+    "    for i in range(batch_size):\n",
+    "        sample_input_ids = model_inputs[\"input_ids\"][i]\n",
+    "        model_inputs[\"input_ids\"][i] = [tokenizer.pad_token_id] * (\n",
+    "            max_length - len(sample_input_ids)\n",
+    "        ) + sample_input_ids\n",
+    "        model_inputs[\"attention_mask\"][i] = [0] * (max_length - len(sample_input_ids)) + model_inputs[\n",
+    "            \"attention_mask\"\n",
+    "        ][i]\n",
+    "        model_inputs[\"input_ids\"][i] = torch.tensor(model_inputs[\"input_ids\"][i][:max_length])\n",
+    "        model_inputs[\"attention_mask\"][i] = torch.tensor(model_inputs[\"attention_mask\"][i][:max_length])\n",
+    "    return model_inputs\n",
+    "\n",
+    "\n",
+    "test_dataset = dataset[\"test\"].map(\n",
+    "    test_preprocess_function,\n",
+    "    batched=True,\n",
+    "    num_proc=1,\n",
+    "    remove_columns=dataset[\"train\"].column_names,\n",
+    "    load_from_cache_file=False,\n",
+    "    desc=\"Running tokenizer on dataset\",\n",
+    ")\n",
+    "\n",
+    "test_dataloader = DataLoader(test_dataset, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True)\n",
+    "next(iter(test_dataloader))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "218df807",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "425"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# show dataset size\n",
+    "len(test_dataloader)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aa55f803",
+   "metadata": {},
+   "source": [
+    "## Train the LM with LNTuning\n",
+    "1. Create the base LM.\n",
+    "2. Only activate the LayerNorm layers in the LM for training.\n",
+    "3. Train the LM on the training dataset."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "a773e092",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "trainable params: 100,352 || all params: 559,314,944 || trainable%: 0.017941948642087417\n"
+     ]
+    }
+   ],
+   "source": [
+    "# 1. creating the base LM\n",
+    "model = AutoModelForCausalLM.from_pretrained(model_name_or_path)\n",
+    "# 2. Only activate the LayerNorm layers in the Attention blocks in the LM for training\n",
+    "model = get_peft_model(model, peft_config)\n",
+    "model.print_trainable_parameters()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "b2f91568",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# setup the optimizer and lr scheduler\n",
+    "optimizer = torch.optim.AdamW(model.parameters(), lr=lr)\n",
+    "lr_scheduler = get_linear_schedule_with_warmup(\n",
+    "    optimizer=optimizer,\n",
+    "    num_warmup_steps=0,\n",
+    "    num_training_steps=(len(train_dataloader) * num_epochs),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "e4fb69fc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00,  7.09it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 23.05it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=0: train_ppl=tensor(8.1918, device='cuda:0') train_epoch_loss=tensor(2.1031, device='cuda:0') eval_ppl=tensor(2.1760, device='cuda:0') eval_epoch_loss=tensor(0.7775, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.88it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 23.11it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=1: train_ppl=tensor(1.8009, device='cuda:0') train_epoch_loss=tensor(0.5883, device='cuda:0') eval_ppl=tensor(2.1198, device='cuda:0') eval_epoch_loss=tensor(0.7513, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.87it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 23.08it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=2: train_ppl=tensor(2.0387, device='cuda:0') train_epoch_loss=tensor(0.7123, device='cuda:0') eval_ppl=tensor(1.6793, device='cuda:0') eval_epoch_loss=tensor(0.5184, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.92it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 23.03it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=3: train_ppl=tensor(1.4885, device='cuda:0') train_epoch_loss=tensor(0.3978, device='cuda:0') eval_ppl=tensor(1.2918, device='cuda:0') eval_epoch_loss=tensor(0.2561, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.89it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 23.00it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=4: train_ppl=tensor(1.3062, device='cuda:0') train_epoch_loss=tensor(0.2671, device='cuda:0') eval_ppl=tensor(1.3259, device='cuda:0') eval_epoch_loss=tensor(0.2821, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.79it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.92it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=5: train_ppl=tensor(1.3129, device='cuda:0') train_epoch_loss=tensor(0.2722, device='cuda:0') eval_ppl=tensor(1.2315, device='cuda:0') eval_epoch_loss=tensor(0.2082, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.83it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.93it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=6: train_ppl=tensor(1.2605, device='cuda:0') train_epoch_loss=tensor(0.2315, device='cuda:0') eval_ppl=tensor(1.2705, device='cuda:0') eval_epoch_loss=tensor(0.2394, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.87it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.79it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=7: train_ppl=tensor(1.2452, device='cuda:0') train_epoch_loss=tensor(0.2193, device='cuda:0') eval_ppl=tensor(1.2103, device='cuda:0') eval_epoch_loss=tensor(0.1909, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.88it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.87it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=8: train_ppl=tensor(1.2185, device='cuda:0') train_epoch_loss=tensor(0.1976, device='cuda:0') eval_ppl=tensor(1.2127, device='cuda:0') eval_epoch_loss=tensor(0.1929, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.83it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.80it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=9: train_ppl=tensor(1.1868, device='cuda:0') train_epoch_loss=tensor(0.1713, device='cuda:0') eval_ppl=tensor(1.1765, device='cuda:0') eval_epoch_loss=tensor(0.1625, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.83it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.99it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=10: train_ppl=tensor(1.1905, device='cuda:0') train_epoch_loss=tensor(0.1744, device='cuda:0') eval_ppl=tensor(1.1539, device='cuda:0') eval_epoch_loss=tensor(0.1431, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.80it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.94it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=11: train_ppl=tensor(1.1475, device='cuda:0') train_epoch_loss=tensor(0.1376, device='cuda:0') eval_ppl=tensor(1.1238, device='cuda:0') eval_epoch_loss=tensor(0.1167, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.81it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.75it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=12: train_ppl=tensor(1.1099, device='cuda:0') train_epoch_loss=tensor(0.1043, device='cuda:0') eval_ppl=tensor(1.0859, device='cuda:0') eval_epoch_loss=tensor(0.0824, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.77it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.95it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=13: train_ppl=tensor(1.0798, device='cuda:0') train_epoch_loss=tensor(0.0768, device='cuda:0') eval_ppl=tensor(1.1151, device='cuda:0') eval_epoch_loss=tensor(0.1089, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.87it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.91it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=14: train_ppl=tensor(1.0622, device='cuda:0') train_epoch_loss=tensor(0.0604, device='cuda:0') eval_ppl=tensor(1.0347, device='cuda:0') eval_epoch_loss=tensor(0.0341, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.86it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.88it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=15: train_ppl=tensor(1.0188, device='cuda:0') train_epoch_loss=tensor(0.0186, device='cuda:0') eval_ppl=tensor(1.0169, device='cuda:0') eval_epoch_loss=tensor(0.0168, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.87it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.86it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=16: train_ppl=tensor(1.0085, device='cuda:0') train_epoch_loss=tensor(0.0085, device='cuda:0') eval_ppl=tensor(1.0047, device='cuda:0') eval_epoch_loss=tensor(0.0047, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.80it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.71it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=17: train_ppl=tensor(1.0041, device='cuda:0') train_epoch_loss=tensor(0.0041, device='cuda:0') eval_ppl=tensor(1.0013, device='cuda:0') eval_epoch_loss=tensor(0.0013, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.82it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.86it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=18: train_ppl=tensor(1.0010, device='cuda:0') train_epoch_loss=tensor(0.0010, device='cuda:0') eval_ppl=tensor(1.0010, device='cuda:0') eval_epoch_loss=tensor(0.0010, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.77it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.85it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=19: train_ppl=tensor(1.0007, device='cuda:0') train_epoch_loss=tensor(0.0007, device='cuda:0') eval_ppl=tensor(1.0005, device='cuda:0') eval_epoch_loss=tensor(0.0005, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.77it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.80it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=20: train_ppl=tensor(1.0004, device='cuda:0') train_epoch_loss=tensor(0.0004, device='cuda:0') eval_ppl=tensor(1.0004, device='cuda:0') eval_epoch_loss=tensor(0.0004, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.78it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.78it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=21: train_ppl=tensor(1.0003, device='cuda:0') train_epoch_loss=tensor(0.0003, device='cuda:0') eval_ppl=tensor(1.0003, device='cuda:0') eval_epoch_loss=tensor(0.0003, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.73it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.80it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=22: train_ppl=tensor(1.0003, device='cuda:0') train_epoch_loss=tensor(0.0003, device='cuda:0') eval_ppl=tensor(1.0003, device='cuda:0') eval_epoch_loss=tensor(0.0003, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.68it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.77it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=23: train_ppl=tensor(1.0003, device='cuda:0') train_epoch_loss=tensor(0.0003, device='cuda:0') eval_ppl=tensor(1.0003, device='cuda:0') eval_epoch_loss=tensor(0.0003, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.79it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.55it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=24: train_ppl=tensor(1.0003, device='cuda:0') train_epoch_loss=tensor(0.0003, device='cuda:0') eval_ppl=tensor(1.0002, device='cuda:0') eval_epoch_loss=tensor(0.0002, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.69it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.64it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=25: train_ppl=tensor(1.0002, device='cuda:0') train_epoch_loss=tensor(0.0002, device='cuda:0') eval_ppl=tensor(1.0002, device='cuda:0') eval_epoch_loss=tensor(0.0002, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.66it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.64it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=26: train_ppl=tensor(1.0002, device='cuda:0') train_epoch_loss=tensor(0.0002, device='cuda:0') eval_ppl=tensor(1.0002, device='cuda:0') eval_epoch_loss=tensor(0.0002, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.75it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.75it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=27: train_ppl=tensor(1.0002, device='cuda:0') train_epoch_loss=tensor(0.0002, device='cuda:0') eval_ppl=tensor(1.0002, device='cuda:0') eval_epoch_loss=tensor(0.0002, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.76it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.61it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=28: train_ppl=tensor(1.0002, device='cuda:0') train_epoch_loss=tensor(0.0002, device='cuda:0') eval_ppl=tensor(1.0002, device='cuda:0') eval_epoch_loss=tensor(0.0002, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.73it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.67it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=29: train_ppl=tensor(1.0002, device='cuda:0') train_epoch_loss=tensor(0.0002, device='cuda:0') eval_ppl=tensor(1.0002, device='cuda:0') eval_epoch_loss=tensor(0.0002, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.73it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.56it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=30: train_ppl=tensor(1.0002, device='cuda:0') train_epoch_loss=tensor(0.0002, device='cuda:0') eval_ppl=tensor(1.0002, device='cuda:0') eval_epoch_loss=tensor(0.0002, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.72it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.62it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=31: train_ppl=tensor(1.0002, device='cuda:0') train_epoch_loss=tensor(0.0002, device='cuda:0') eval_ppl=tensor(1.0002, device='cuda:0') eval_epoch_loss=tensor(0.0002, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.75it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.71it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=32: train_ppl=tensor(1.0002, device='cuda:0') train_epoch_loss=tensor(0.0002, device='cuda:0') eval_ppl=tensor(1.0002, device='cuda:0') eval_epoch_loss=tensor(0.0002, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.72it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.64it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=33: train_ppl=tensor(1.0002, device='cuda:0') train_epoch_loss=tensor(0.0002, device='cuda:0') eval_ppl=tensor(1.0002, device='cuda:0') eval_epoch_loss=tensor(0.0002, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.72it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.64it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=34: train_ppl=tensor(1.0002, device='cuda:0') train_epoch_loss=tensor(0.0002, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.70it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.58it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=35: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.68it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.41it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=36: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.72it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.62it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=37: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.64it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.58it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=38: train_ppl=tensor(1.0002, device='cuda:0') train_epoch_loss=tensor(0.0002, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.66it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.65it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=39: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.71it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.57it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=40: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.64it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.55it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=41: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.64it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.59it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=42: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.68it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.46it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=43: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.70it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.54it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=44: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.67it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.61it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=45: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.69it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.49it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=46: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.66it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.39it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=47: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.60it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.50it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=48: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 7/7 [00:00<00:00, 10.62it/s]\n",
+      "100%|██████████| 7/7 [00:00<00:00, 22.52it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=49: train_ppl=tensor(1.0001, device='cuda:0') train_epoch_loss=tensor(0.0001, device='cuda:0') eval_ppl=tensor(1.0001, device='cuda:0') eval_epoch_loss=tensor(0.0001, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# 3. train the LM on the training dataset\n",
+    "model = model.to(device)\n",
+    "\n",
+    "for epoch in range(num_epochs):\n",
+    "    model.train()\n",
+    "    total_loss = 0\n",
+    "    for step, batch in enumerate(tqdm(train_dataloader)):\n",
+    "        batch = {k: v.to(device) for k, v in batch.items()}\n",
+    "        #         print(batch)\n",
+    "        #         print(batch[\"input_ids\"].shape)\n",
+    "        outputs = model(**batch)\n",
+    "        loss = outputs.loss\n",
+    "        total_loss += loss.detach().float()\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        lr_scheduler.step()\n",
+    "        optimizer.zero_grad()\n",
+    "\n",
+    "    model.eval()\n",
+    "    eval_loss = 0\n",
+    "    eval_preds = []\n",
+    "    for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+    "        batch = {k: v.to(device) for k, v in batch.items()}\n",
+    "        with torch.no_grad():\n",
+    "            outputs = model(**batch)\n",
+    "        loss = outputs.loss\n",
+    "        eval_loss += loss.detach().float()\n",
+    "        eval_preds.extend(\n",
+    "            tokenizer.batch_decode(torch.argmax(outputs.logits, -1).detach().cpu().numpy(), skip_special_tokens=True)\n",
+    "        )\n",
+    "\n",
+    "    eval_epoch_loss = eval_loss / len(eval_dataloader)\n",
+    "    eval_ppl = torch.exp(eval_epoch_loss)\n",
+    "    train_epoch_loss = total_loss / len(train_dataloader)\n",
+    "    train_ppl = torch.exp(train_epoch_loss)\n",
+    "    print(f\"{epoch=}: {train_ppl=} {train_epoch_loss=} {eval_ppl=} {eval_epoch_loss=}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fbf339a2",
+   "metadata": {},
+   "source": [
+    "## Test the LM"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "53752a7b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "@TommyHilfiger Dramatic shopping exp. ordered 6 jeans same size (30/32) 2 fits / 2 too large / 2 too slim : same brand &gt; different sizing\n",
+      "{'input_ids': tensor([[227985,   5484,    915,   2566, 226154, 126015,   5385,    259, 239364,\n",
+      "           3396,  70823,   5853,     17,  57247,   1231, 191040,   5025,   7869,\n",
+      "            375,   2324, 149349,     12,    415, 122321,    897,    415,  10136,\n",
+      "          10021,    897,    415,  10136,   6497,    381,    915,   5025,  51950,\n",
+      "          66869,   5955,    272,  20311,  77658,    915,    210]]), 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
+      "         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])}\n",
+      "tensor([[227985,   5484,    915,   2566, 226154, 126015,   5385,    259, 239364,\n",
+      "           3396,  70823,   5853,     17,  57247,   1231, 191040,   5025,   7869,\n",
+      "            375,   2324, 149349,     12,    415, 122321,    897,    415,  10136,\n",
+      "          10021,    897,    415,  10136,   6497,    381,    915,   5025,  51950,\n",
+      "          66869,   5955,    272,  20311,  77658,    915,    210,   1936, 106863,\n",
+      "              2,   1936, 106863,      2,   1936, 106863,      2,   1936]],\n",
+      "       device='cuda:0')\n",
+      "['Tweet text : @TommyHilfiger Dramatic shopping exp. ordered 6 jeans same size (30/32) 2 fits / 2 too large / 2 too slim : same brand &gt; different sizing Label : no complaintno complaintno complaintno']\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.eval()\n",
+    "i = 33\n",
+    "inputs = tokenizer(f'{text_column} : {dataset[\"test\"][i][\"Tweet text\"]} Label : ', return_tensors=\"pt\")\n",
+    "print(dataset[\"test\"][i][\"Tweet text\"])\n",
+    "print(inputs)\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    inputs = {k: v.to(device) for k, v in inputs.items()}\n",
+    "    outputs = model.generate(\n",
+    "        input_ids=inputs[\"input_ids\"], attention_mask=inputs[\"attention_mask\"], max_new_tokens=10, eos_token_id=3\n",
+    "    )\n",
+    "    print(outputs)\n",
+    "    print(tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c8f35152",
+   "metadata": {},
+   "source": [
+    "## Save the trainable LM weights (LayerNorm layers)\n",
+    "You can push model to hub or save model locally. \n",
+    "\n",
+    "- Option1: Push the model to Hugging Face Hub:\n",
+    "\n",
+    "    ```python\n",
+    "    model.push_to_hub(\n",
+    "        f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\".replace(\"/\", \"_\"),\n",
+    "        token = \"hf_...\"\n",
+    "    )\n",
+    "    ```\n",
+    "    token (`bool` or `str`, *optional*):\n",
+    "        `token` is to be used for HTTP Bearer authorization when accessing remote files. If `True`, will use the token generated\n",
+    "        when running `huggingface-cli login` (stored in `~/.huggingface`). Will default to `True` if `repo_url`\n",
+    "        is not specified.\n",
+    "        Or you can get your token from https://huggingface.co/settings/token\n",
+    "    ```\n",
+    "- Option2: Save model locally:\n",
+    "\n",
+    "    ```python\n",
+    "    peft_model_id = f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\".replace(\"/\", \"_\")\n",
+    "    model.save_pretrained(peft_model_id)\n",
+    "    ```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "d8ba1f8c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# saving model\n",
+    "peft_model_id = f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\".replace(\n",
+    "    \"/\", \"_\"\n",
+    ")\n",
+    "model.save_pretrained(peft_model_id)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4dd7ab9c",
+   "metadata": {},
+   "source": [
+    "## Test the LM using LNTuning loaded from saved weights\n",
+    "1. load the LNTuning configuration\n",
+    "2. load the base LM\n",
+    "3. merge the LNTuning weights into the base LM using the PEFT config"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "4d9476e1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from peft import PeftModel, PeftConfig\n",
+    "\n",
+    "# load the LNTuning config\n",
+    "config = PeftConfig.from_pretrained(peft_model_id)\n",
+    "# load the base LM\n",
+    "model = AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path)\n",
+    "# merge LNTuning weights into the base LM\n",
+    "model = PeftModel.from_pretrained(model, peft_model_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "ebe174a6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "@greateranglia Ok thanks...\n",
+      "{'input_ids': tensor([[227985,   5484,    915,   2566,  14173,   2960,  29906,    387,  20706,\n",
+      "          49337,   1369,  77658,    915,    210]]), 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])}\n",
+      "tensor([[227985,   5484,    915,   2566,  14173,   2960,  29906,    387,  20706,\n",
+      "          49337,   1369,  77658,    915,    210,   1936, 106863,      2,   1936,\n",
+      "         106863,      2,   1936, 106863,      2,   1936]], device='cuda:0')\n",
+      "['Tweet text : @greateranglia Ok thanks... Label : no complaintno complaintno complaintno']\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.to(device)\n",
+    "model.eval()\n",
+    "i = 4\n",
+    "inputs = tokenizer(f'{text_column} : {dataset[\"test\"][i][\"Tweet text\"]} Label : ', return_tensors=\"pt\")\n",
+    "print(dataset[\"test\"][i][\"Tweet text\"])\n",
+    "print(inputs)\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    inputs = {k: v.to(device) for k, v in inputs.items()}\n",
+    "    outputs = model.generate(\n",
+    "        input_ids=inputs[\"input_ids\"], attention_mask=inputs[\"attention_mask\"], max_new_tokens=10, eos_token_id=3\n",
+    "    )\n",
+    "    print(outputs)\n",
+    "    print(tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.9"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/causal_language_modeling/peft_lora_clm_accelerate_ds_zero3_offload.py b/examples/causal_language_modeling/peft_lora_clm_accelerate_ds_zero3_offload.py
new file mode 100644
index 0000000..d908530
--- /dev/null
+++ b/examples/causal_language_modeling/peft_lora_clm_accelerate_ds_zero3_offload.py
@@ -0,0 +1,381 @@
+import gc
+import os
+import sys
+import threading
+
+import psutil
+import torch
+from accelerate import Accelerator
+from datasets import load_dataset
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    default_data_collator,
+    get_linear_schedule_with_warmup,
+    set_seed,
+)
+
+from peft import LoraConfig, TaskType, get_peft_model
+
+
+def levenshtein_distance(str1, str2):
+    # TC: O(N^2)
+    # SC: O(N)
+    if str1 == str2:
+        return 0
+    num_rows = len(str1) + 1
+    num_cols = len(str2) + 1
+    dp_matrix = list(range(num_cols))
+    for i in range(1, num_rows):
+        prev = dp_matrix[0]
+        dp_matrix[0] = i
+        for j in range(1, num_cols):
+            temp = dp_matrix[j]
+            if str1[i - 1] == str2[j - 1]:
+                dp_matrix[j] = prev
+            else:
+                dp_matrix[j] = min(prev, dp_matrix[j], dp_matrix[j - 1]) + 1
+            prev = temp
+    return dp_matrix[num_cols - 1]
+
+
+def get_closest_label(eval_pred, classes):
+    min_id = sys.maxsize
+    min_edit_distance = sys.maxsize
+    for i, class_label in enumerate(classes):
+        edit_distance = levenshtein_distance(eval_pred.strip(), class_label)
+        if edit_distance < min_edit_distance:
+            min_id = i
+            min_edit_distance = edit_distance
+    return classes[min_id]
+
+
+# Converting Bytes to Megabytes
+def b2mb(x):
+    return int(x / 2**20)
+
+
+# This context manager is used to track the peak memory usage of the process
+class TorchTracemalloc:
+    def __enter__(self):
+        gc.collect()
+        self.device_type = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+        self.device_module = getattr(torch, self.device_type, torch.cuda)
+        self.device_module.empty_cache()
+        self.device_module.reset_peak_memory_stats()  # reset the peak gauge to zero
+        self.begin = self.device_module.memory_allocated()
+        self.process = psutil.Process()
+
+        self.cpu_begin = self.cpu_mem_used()
+        self.peak_monitoring = True
+        peak_monitor_thread = threading.Thread(target=self.peak_monitor_func)
+        peak_monitor_thread.daemon = True
+        peak_monitor_thread.start()
+        return self
+
+    def cpu_mem_used(self):
+        """get resident set size memory for the current process"""
+        return self.process.memory_info().rss
+
+    def peak_monitor_func(self):
+        self.cpu_peak = -1
+
+        while True:
+            self.cpu_peak = max(self.cpu_mem_used(), self.cpu_peak)
+
+            # can't sleep or will not catch the peak right (this comment is here on purpose)
+            # time.sleep(0.001) # 1msec
+
+            if not self.peak_monitoring:
+                break
+
+    def __exit__(self, *exc):
+        self.peak_monitoring = False
+
+        gc.collect()
+        self.device_module.empty_cache()
+        self.end = self.device_module.memory_allocated()
+        self.peak = self.device_module.max_memory_allocated()
+        self.used = b2mb(self.end - self.begin)
+        self.peaked = b2mb(self.peak - self.begin)
+
+        self.cpu_end = self.cpu_mem_used()
+        self.cpu_used = b2mb(self.cpu_end - self.cpu_begin)
+        self.cpu_peaked = b2mb(self.cpu_peak - self.cpu_begin)
+        # print(f"delta used/peak {self.used:4d}/{self.peaked:4d}")
+
+
+def main():
+    accelerator = Accelerator()
+    model_name_or_path = "bigscience/bloomz-7b1"
+    dataset_name = "twitter_complaints"
+    peft_config = LoraConfig(task_type=TaskType.CAUSAL_LM, inference_mode=False, r=8, lora_alpha=32, lora_dropout=0.1)
+    text_column = "Tweet text"
+    label_column = "text_label"
+    lr = 3e-3
+    num_epochs = 20
+    batch_size = 8
+    seed = 42
+    max_length = 64
+    do_test = False
+    set_seed(seed)
+
+    dataset = load_dataset(
+        "parquet",
+        data_files={
+            "train": f"hf://datasets/ought/raft@refs/convert/parquet/{dataset_name}/train/0000.parquet",
+            "test": f"hf://datasets/ought/raft@refs/convert/parquet/{dataset_name}/test/0000.parquet",
+        },
+    )
+    classes = [k.replace("_", " ") for k in dataset["train"].features["Label"].names]
+    dataset = dataset.map(
+        lambda x: {"text_label": [classes[label] for label in x["Label"]]},
+        batched=True,
+        num_proc=1,
+    )
+
+    tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)
+
+    def preprocess_function(examples):
+        batch_size = len(examples[text_column])
+        inputs = [f"{text_column} : {x} Label : " for x in examples[text_column]]
+        targets = [str(x) for x in examples[label_column]]
+        model_inputs = tokenizer(inputs)
+        labels = tokenizer(targets, add_special_tokens=False)  # don't add bos token because we concatenate with inputs
+        for i in range(batch_size):
+            sample_input_ids = model_inputs["input_ids"][i]
+            label_input_ids = labels["input_ids"][i] + [tokenizer.eos_token_id]
+            model_inputs["input_ids"][i] = sample_input_ids + label_input_ids
+            labels["input_ids"][i] = [-100] * len(sample_input_ids) + label_input_ids
+            model_inputs["attention_mask"][i] = [1] * len(model_inputs["input_ids"][i])
+        for i in range(batch_size):
+            sample_input_ids = model_inputs["input_ids"][i]
+            label_input_ids = labels["input_ids"][i]
+            model_inputs["input_ids"][i] = [tokenizer.pad_token_id] * (
+                max_length - len(sample_input_ids)
+            ) + sample_input_ids
+            model_inputs["attention_mask"][i] = [0] * (max_length - len(sample_input_ids)) + model_inputs[
+                "attention_mask"
+            ][i]
+            labels["input_ids"][i] = [-100] * (max_length - len(sample_input_ids)) + label_input_ids
+            model_inputs["input_ids"][i] = torch.tensor(model_inputs["input_ids"][i][:max_length])
+            model_inputs["attention_mask"][i] = torch.tensor(model_inputs["attention_mask"][i][:max_length])
+            labels["input_ids"][i] = torch.tensor(labels["input_ids"][i][:max_length])
+        model_inputs["labels"] = labels["input_ids"]
+        return model_inputs
+
+    def test_preprocess_function(examples):
+        batch_size = len(examples[text_column])
+        inputs = [f"{text_column} : {x} Label : " for x in examples[text_column]]
+        model_inputs = tokenizer(inputs)
+        for i in range(batch_size):
+            sample_input_ids = model_inputs["input_ids"][i]
+            model_inputs["input_ids"][i] = [tokenizer.pad_token_id] * (
+                max_length - len(sample_input_ids)
+            ) + sample_input_ids
+            model_inputs["attention_mask"][i] = [0] * (max_length - len(sample_input_ids)) + model_inputs[
+                "attention_mask"
+            ][i]
+            model_inputs["input_ids"][i] = torch.tensor(model_inputs["input_ids"][i][:max_length])
+            model_inputs["attention_mask"][i] = torch.tensor(model_inputs["attention_mask"][i][:max_length])
+        return model_inputs
+
+    with accelerator.main_process_first():
+        processed_datasets = dataset.map(
+            preprocess_function,
+            batched=True,
+            num_proc=1,
+            remove_columns=dataset["train"].column_names,
+            load_from_cache_file=True,
+            desc="Running tokenizer on dataset",
+        )
+    accelerator.wait_for_everyone()
+
+    train_dataset = processed_datasets["train"]
+
+    with accelerator.main_process_first():
+        processed_datasets = dataset.map(
+            test_preprocess_function,
+            batched=True,
+            num_proc=1,
+            remove_columns=dataset["train"].column_names,
+            load_from_cache_file=False,
+            desc="Running tokenizer on dataset",
+        )
+    eval_dataset = processed_datasets["train"]
+    test_dataset = processed_datasets["test"]
+
+    train_dataloader = DataLoader(
+        train_dataset, shuffle=True, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True
+    )
+    eval_dataloader = DataLoader(
+        eval_dataset, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True
+    )
+    test_dataloader = DataLoader(
+        test_dataset, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True
+    )
+
+    print(next(iter(train_dataloader)))
+
+    # creating model
+    model = AutoModelForCausalLM.from_pretrained(model_name_or_path)
+    model = get_peft_model(model, peft_config)
+    model.print_trainable_parameters()
+
+    # optimizer
+    optimizer = torch.optim.AdamW(model.parameters(), lr=lr)
+
+    # lr scheduler
+    lr_scheduler = get_linear_schedule_with_warmup(
+        optimizer=optimizer,
+        num_warmup_steps=0,
+        num_training_steps=(len(train_dataloader) * num_epochs),
+    )
+
+    model, train_dataloader, eval_dataloader, test_dataloader, optimizer, lr_scheduler = accelerator.prepare(
+        model, train_dataloader, eval_dataloader, test_dataloader, optimizer, lr_scheduler
+    )
+    accelerator.print(model)
+
+    is_ds_zero_3 = False
+    if getattr(accelerator.state, "deepspeed_plugin", None):
+        is_ds_zero_3 = accelerator.state.deepspeed_plugin.zero_stage == 3
+
+    for epoch in range(num_epochs):
+        with TorchTracemalloc() as tracemalloc:
+            model.train()
+            total_loss = 0
+            for step, batch in enumerate(tqdm(train_dataloader)):
+                outputs = model(**batch)
+                loss = outputs.loss
+                total_loss += loss.detach().float()
+                accelerator.backward(loss)
+                optimizer.step()
+                lr_scheduler.step()
+                optimizer.zero_grad()
+        # Printing the memory usage details such as allocated memory, peak memory, and total memory usage
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Memory before entering the train : {b2mb(tracemalloc.begin)}"
+        )
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Memory consumed at the end of the train (end-begin): {tracemalloc.used}"
+        )
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Peak Memory consumed during the train (max-begin): {tracemalloc.peaked}"
+        )
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Total Peak Memory consumed during the train (max): {tracemalloc.peaked + b2mb(tracemalloc.begin)}"
+        )
+
+        accelerator.print(f"CPU Memory before entering the train : {b2mb(tracemalloc.cpu_begin)}")
+        accelerator.print(f"CPU Memory consumed at the end of the train (end-begin): {tracemalloc.cpu_used}")
+        accelerator.print(f"CPU Peak Memory consumed during the train (max-begin): {tracemalloc.cpu_peaked}")
+        accelerator.print(
+            f"CPU Total Peak Memory consumed during the train (max): {tracemalloc.cpu_peaked + b2mb(tracemalloc.cpu_begin)}"
+        )
+        train_epoch_loss = total_loss / len(train_dataloader)
+        train_ppl = torch.exp(train_epoch_loss)
+        accelerator.print(f"{epoch=}: {train_ppl=} {train_epoch_loss=}")
+
+        model.eval()
+        eval_preds = []
+        with TorchTracemalloc() as tracemalloc:
+            for _, batch in enumerate(tqdm(eval_dataloader)):
+                batch = {k: v for k, v in batch.items() if k != "labels"}
+                with torch.no_grad():
+                    outputs = accelerator.unwrap_model(model).generate(
+                        **batch, synced_gpus=is_ds_zero_3, max_new_tokens=10
+                    )  # synced_gpus=True for DS-stage 3
+                outputs = accelerator.pad_across_processes(outputs, dim=1, pad_index=tokenizer.pad_token_id)
+                preds = accelerator.gather_for_metrics(outputs)
+                preds = preds[:, max_length:].detach().cpu().numpy()
+                eval_preds.extend(tokenizer.batch_decode(preds, skip_special_tokens=True))
+
+        # Printing the memory usage details such as allocated memory, peak memory, and total memory usage
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Memory before entering the eval : {b2mb(tracemalloc.begin)}"
+        )
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Memory consumed at the end of the eval (end-begin): {tracemalloc.used}"
+        )
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Peak Memory consumed during the eval (max-begin): {tracemalloc.peaked}"
+        )
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Total Peak Memory consumed during the eval (max): {tracemalloc.peaked + b2mb(tracemalloc.begin)}"
+        )
+
+        accelerator.print(f"CPU Memory before entering the eval : {b2mb(tracemalloc.cpu_begin)}")
+        accelerator.print(f"CPU Memory consumed at the end of the eval (end-begin): {tracemalloc.cpu_used}")
+        accelerator.print(f"CPU Peak Memory consumed during the eval (max-begin): {tracemalloc.cpu_peaked}")
+        accelerator.print(
+            f"CPU Total Peak Memory consumed during the eval (max): {tracemalloc.cpu_peaked + b2mb(tracemalloc.cpu_begin)}"
+        )
+
+        correct = 0
+        total = 0
+        assert len(eval_preds) == len(dataset["train"][label_column]), (
+            f"{len(eval_preds)} != {len(dataset['train'][label_column])}"
+        )
+        for pred, true in zip(eval_preds, dataset["train"][label_column]):
+            if pred.strip() == true.strip():
+                correct += 1
+            total += 1
+        accuracy = correct / total * 100
+        accelerator.print(f"{accuracy=}")
+        accelerator.print(f"{eval_preds[:10]=}")
+        accelerator.print(f"{dataset['train'][label_column][:10]=}")
+
+    if do_test:
+        model.eval()
+        test_preds = []
+        for _, batch in enumerate(tqdm(test_dataloader)):
+            batch = {k: v for k, v in batch.items() if k != "labels"}
+            with torch.no_grad():
+                outputs = accelerator.unwrap_model(model).generate(
+                    **batch, synced_gpus=is_ds_zero_3, max_new_tokens=10
+                )  # synced_gpus=True for DS-stage 3
+            outputs = accelerator.pad_across_processes(outputs, dim=1, pad_index=tokenizer.pad_token_id)
+            preds = accelerator.gather(outputs)
+            preds = preds[:, max_length:].detach().cpu().numpy()
+            test_preds.extend(tokenizer.batch_decode(preds, skip_special_tokens=True))
+
+        test_preds_cleaned = []
+        for _, pred in enumerate(test_preds):
+            test_preds_cleaned.append(get_closest_label(pred, classes))
+
+        test_df = dataset["test"].to_pandas()
+        assert len(test_preds_cleaned) == len(test_df), f"{len(test_preds_cleaned)} != {len(test_df)}"
+        test_df[label_column] = test_preds_cleaned
+        test_df["text_labels_orig"] = test_preds
+        accelerator.print(test_df[[text_column, label_column]].sample(20))
+
+        pred_df = test_df[["ID", label_column]]
+        pred_df.columns = ["ID", "Label"]
+
+        os.makedirs(f"data/{dataset_name}", exist_ok=True)
+        pred_df.to_csv(f"data/{dataset_name}/predictions.csv", index=False)
+
+    accelerator.wait_for_everyone()
+    # Option1: Pushing the model to Hugging Face Hub
+    # model.push_to_hub(
+    #     f"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}".replace("/", "_"),
+    #     token = "hf_..."
+    # )
+    # token (`bool` or `str`, *optional*):
+    #     `token` is to be used for HTTP Bearer authorization when accessing remote files. If `True`, will use the token generated
+    #     when running `huggingface-cli login` (stored in `~/.huggingface`). Will default to `True` if `repo_url`
+    #     is not specified.
+    #     Or you can get your token from https://huggingface.co/settings/token
+    # Option2: Saving the model locally
+    peft_model_id = f"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}".replace(
+        "/", "_"
+    )
+    model.save_pretrained(peft_model_id)
+    accelerator.wait_for_everyone()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/causal_language_modeling/peft_lora_clm_with_additional_tokens.ipynb b/examples/causal_language_modeling/peft_lora_clm_with_additional_tokens.ipynb
new file mode 100644
index 0000000..dd699d0
--- /dev/null
+++ b/examples/causal_language_modeling/peft_lora_clm_with_additional_tokens.ipynb
@@ -0,0 +1,1012 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "5f239612-620e-4430-8685-9fdc6b179b41",
+   "metadata": {},
+   "source": [
+    "# Training PEFT models with new tokens being added to the embedding layers and tokenizer\n",
+    "\n",
+    "In this example, we will learn how to train a LoRA model when adding new tokens to the tokenizer and model. \n",
+    "This is a common usecase when doing the following:\n",
+    "1. Instruction finetuning with new tokens beind added such as `<|user|>`, `<|assistant|>`, `<|system|>`, `</s>`, `<s>` to properly format the conversations\n",
+    "2. Finetuning on a specific language wherein language spoecific tokens are added, e.g., korean tokens being added to vocabulary for finetuning LLM on Korean datasets.\n",
+    "3. Instruction finetuning to return outputs in certain format to enable agent behaviour new tokens such as `<|FUNCTIONS|>`, `<|BROWSE|>`, `<|TEXT2IMAGE|>`, `<|ASR|>`, `<|TTS|>`, `<|GENERATECODE|>`, `<|RAG|>`.\n",
+    "\n",
+    "In such cases, you add the Embedding modules to the LORA `target_modules`. PEFT will take care of saving the embedding layers with the new added tokens along with the adapter weights that were trained on the specific initialization of the embeddings weights of the added tokens."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b27c55e8-edaa-4059-90bc-d6096d596902",
+   "metadata": {},
+   "source": [
+    "Let's import the necessary libraries"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6f864c90",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "os.environ[\"WANDB_PROJECT\"] = \"PeftExamples\"\n",
+    "import transformers\n",
+    "from peft import (\n",
+    "    LoraConfig,\n",
+    "    PeftConfig,\n",
+    "    PeftModel,\n",
+    "    get_peft_model,\n",
+    "    prepare_model_for_kbit_training,\n",
+    ")\n",
+    "from transformers import (\n",
+    "    AutoModelForCausalLM,\n",
+    "    AutoTokenizer,\n",
+    "    HfArgumentParser,\n",
+    "    TrainingArguments,\n",
+    "    Trainer,\n",
+    "    default_data_collator,\n",
+    ")\n",
+    "import torch\n",
+    "from dataclasses import dataclass, field\n",
+    "from typing import Optional\n",
+    "from dataclass_csv import DataclassReader\n",
+    "from torch.utils.data import Dataset, DataLoader\n",
+    "\n",
+    "from enum import Enum"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "74950a3f-bb63-4ce5-9e2b-1b83f92b13a2",
+   "metadata": {},
+   "source": [
+    "## Prepare Model and Tokenizer"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "76763f5e-64b2-409b-8845-ae5589f8a4e0",
+   "metadata": {},
+   "source": [
+    "Now, we will be adding 27 new tokens as well as replace the existing pad, bos and eos tokens of the model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "fd0498ea-547e-418d-bf13-c9abafdd5476",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class SpecialTokens(str, Enum):\n",
+    "    begin_target = \"<|begintarget|>\"\n",
+    "    end_target = \"<|endtarget|>\"\n",
+    "    begin_context = \"<|begincontext|>\"\n",
+    "    end_context = \"<|endcontext|>\"\n",
+    "    system = \"<|system|>\"\n",
+    "    user = \"<|user|>\"\n",
+    "    begin_last_user_utterance = \"<|beginlastuserutterance|>\"\n",
+    "    end_last_user_utterance = \"<|endlastuserutterance|>\"\n",
+    "    begin_dsts = \"<|begindsts|>\"\n",
+    "    end_dsts = \"<|enddsts|>\"\n",
+    "    begin_dst = \"<|begindst|>\"\n",
+    "    end_dst = \"<|enddst|>\"\n",
+    "    begin_belief = \"<|beginbelief|>\"\n",
+    "    end_belief = \"<|endbelief|>\"\n",
+    "    begin_response = \"<|beginresponse|>\"\n",
+    "    end_response = \"<|endresponse|>\"\n",
+    "    begin_action = \"<|beginaction|>\"\n",
+    "    end_action = \"<|endaction|>\"\n",
+    "    begin_user_action = \"<|beginuseraction|>\"\n",
+    "    end_user_action = \"<|enduseraction|>\"\n",
+    "    sys_actions = \"<|sysactions|>\"\n",
+    "    begin_intent = \"<|beginintent|>\"\n",
+    "    end_intent = \"<|endintent|>\"\n",
+    "    begin_requested_slots = \"<|beginrequestedslots|>\"\n",
+    "    end_requested_slots = \"<|endrequestedslots|>\"\n",
+    "    pad_token = \"<|pad|>\"\n",
+    "    bos_token = \"<|startoftext|>\"\n",
+    "\n",
+    "    @classmethod\n",
+    "    def list(cls):\n",
+    "        return [c.value for c in cls]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae4a4255-5f13-4eef-a024-4f1de0f2173b",
+   "metadata": {},
+   "source": [
+    "We will be finetuning Mistral-7B model. Let's load the tokenizer and add the special tokens followed by loading the base model and resizing the embedding layers to accommodate the newly added tokens."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "f0eedef9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "91c67b6377fc4dd7977bf544de784d51",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Loading checkpoint shards:   0%|          | 0/2 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Embedding(32027, 4096)"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model_name = \"mistralai/Mistral-7B-v0.1\"\n",
+    "tokenizer = AutoTokenizer.from_pretrained(\n",
+    "    model_name,\n",
+    "    pad_token=SpecialTokens.pad_token.value,\n",
+    "    bos_token=SpecialTokens.bos_token.value,\n",
+    "    eos_token=SpecialTokens.end_target.value,\n",
+    "    additional_special_tokens=SpecialTokens.list(),\n",
+    ")\n",
+    "model = AutoModelForCausalLM.from_pretrained(\n",
+    "    model_name,\n",
+    "    low_cpu_mem_usage=True\n",
+    "    # attn_implementation =\"flash_attention_2\", # leading to an error\n",
+    ")\n",
+    "model.resize_token_embeddings(len(tokenizer))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "88439ed6-9974-4918-80df-ec78b05b4185",
+   "metadata": {},
+   "source": [
+    "## Apply LoRA"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "80967087",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "trainable params: 31,886,720 || all params: 7,273,840,000 || trainable%: 0.43837532857472805\n",
+      "None\n",
+      "PeftModel(\n",
+      "  (base_model): LoraModel(\n",
+      "    (model): MistralForCausalLM(\n",
+      "      (model): MistralModel(\n",
+      "        (embed_tokens): lora.Embedding(\n",
+      "          (base_layer): Embedding(32027, 4096)\n",
+      "          (lora_dropout): ModuleDict(\n",
+      "            (default): Identity()\n",
+      "          )\n",
+      "          (lora_A): ModuleDict()\n",
+      "          (lora_B): ModuleDict()\n",
+      "          (lora_embedding_A): ParameterDict(  (default): Parameter containing: [torch.FloatTensor of size 64x32027])\n",
+      "          (lora_embedding_B): ParameterDict(  (default): Parameter containing: [torch.FloatTensor of size 4096x64])\n",
+      "        )\n",
+      "        (layers): ModuleList(\n",
+      "          (0-31): 32 x MistralDecoderLayer(\n",
+      "            (self_attn): MistralAttention(\n",
+      "              (q_proj): lora.Linear(\n",
+      "                (base_layer): Linear(in_features=4096, out_features=4096, bias=False)\n",
+      "                (lora_dropout): ModuleDict(\n",
+      "                  (default): Identity()\n",
+      "                )\n",
+      "                (lora_A): ModuleDict(\n",
+      "                  (default): Linear(in_features=4096, out_features=64, bias=False)\n",
+      "                )\n",
+      "                (lora_B): ModuleDict(\n",
+      "                  (default): Linear(in_features=64, out_features=4096, bias=False)\n",
+      "                )\n",
+      "                (lora_embedding_A): ParameterDict()\n",
+      "                (lora_embedding_B): ParameterDict()\n",
+      "              )\n",
+      "              (k_proj): Linear(in_features=4096, out_features=1024, bias=False)\n",
+      "              (v_proj): lora.Linear(\n",
+      "                (base_layer): Linear(in_features=4096, out_features=1024, bias=False)\n",
+      "                (lora_dropout): ModuleDict(\n",
+      "                  (default): Identity()\n",
+      "                )\n",
+      "                (lora_A): ModuleDict(\n",
+      "                  (default): Linear(in_features=4096, out_features=64, bias=False)\n",
+      "                )\n",
+      "                (lora_B): ModuleDict(\n",
+      "                  (default): Linear(in_features=64, out_features=1024, bias=False)\n",
+      "                )\n",
+      "                (lora_embedding_A): ParameterDict()\n",
+      "                (lora_embedding_B): ParameterDict()\n",
+      "              )\n",
+      "              (o_proj): Linear(in_features=4096, out_features=4096, bias=False)\n",
+      "              (rotary_emb): MistralRotaryEmbedding()\n",
+      "            )\n",
+      "            (mlp): MistralMLP(\n",
+      "              (gate_proj): Linear(in_features=4096, out_features=14336, bias=False)\n",
+      "              (up_proj): Linear(in_features=4096, out_features=14336, bias=False)\n",
+      "              (down_proj): Linear(in_features=14336, out_features=4096, bias=False)\n",
+      "              (act_fn): SiLU()\n",
+      "            )\n",
+      "            (input_layernorm): MistralRMSNorm()\n",
+      "            (post_attention_layernorm): MistralRMSNorm()\n",
+      "          )\n",
+      "        )\n",
+      "        (norm): MistralRMSNorm()\n",
+      "      )\n",
+      "      (lm_head): lora.Linear(\n",
+      "        (base_layer): Linear(in_features=4096, out_features=32027, bias=False)\n",
+      "        (lora_dropout): ModuleDict(\n",
+      "          (default): Identity()\n",
+      "        )\n",
+      "        (lora_A): ModuleDict(\n",
+      "          (default): Linear(in_features=4096, out_features=64, bias=False)\n",
+      "        )\n",
+      "        (lora_B): ModuleDict(\n",
+      "          (default): Linear(in_features=64, out_features=32027, bias=False)\n",
+      "        )\n",
+      "        (lora_embedding_A): ParameterDict()\n",
+      "        (lora_embedding_B): ParameterDict()\n",
+      "      )\n",
+      "    )\n",
+      "  )\n",
+      ")\n"
+     ]
+    }
+   ],
+   "source": [
+    "config = LoraConfig(\n",
+    "    r=64, lora_alpha=128, lora_dropout=0.0, target_modules=[\"embed_tokens\", \"lm_head\", \"q_proj\", \"v_proj\"]\n",
+    ")\n",
+    "model = get_peft_model(model, config)\n",
+    "print(model.print_trainable_parameters())\n",
+    "print(model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "15ac9945-4fcb-45f4-9478-d99a25a519cc",
+   "metadata": {},
+   "source": [
+    "## Preapre Dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "c6980d59-42d4-4a27-84cc-a9719302088b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "33d9539232da48f3ae922216b98ae462",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Running tokenizer on dataset:   0%|          | 0/986 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b7a33811d93742099140240cad91b679",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Running tokenizer on dataset:   0%|          | 0/247 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from datasets import load_dataset\n",
+    "\n",
+    "dataset = load_dataset(\"smangrul/assistant_chatbot_dataset\")\n",
+    "dataset = dataset[\"train\"].train_test_split(0.2)\n",
+    "\n",
+    "text_column = \"context\"\n",
+    "label_column = \"target\"\n",
+    "max_length = 512\n",
+    "\n",
+    "\n",
+    "def preprocess_function(examples):\n",
+    "    batch_size = len(examples[text_column])\n",
+    "    targets = [str(x) for x in examples[label_column]]\n",
+    "    model_inputs = tokenizer(examples[text_column])\n",
+    "    labels = tokenizer(targets, add_special_tokens=False)  # don't add bos token because we concatenate with inputs\n",
+    "    for i in range(batch_size):\n",
+    "        sample_input_ids = model_inputs[\"input_ids\"][i]\n",
+    "        label_input_ids = labels[\"input_ids\"][i] + [tokenizer.eos_token_id]\n",
+    "        # print(i, sample_input_ids, label_input_ids)\n",
+    "        model_inputs[\"input_ids\"][i] = sample_input_ids + label_input_ids\n",
+    "        labels[\"input_ids\"][i] = [-100] * len(sample_input_ids) + label_input_ids\n",
+    "        model_inputs[\"attention_mask\"][i] = [1] * len(model_inputs[\"input_ids\"][i])\n",
+    "    # print(model_inputs)\n",
+    "    for i in range(batch_size):\n",
+    "        sample_input_ids = model_inputs[\"input_ids\"][i]\n",
+    "        label_input_ids = labels[\"input_ids\"][i]\n",
+    "        model_inputs[\"input_ids\"][i] = [tokenizer.pad_token_id] * (\n",
+    "            max_length - len(sample_input_ids)\n",
+    "        ) + sample_input_ids\n",
+    "        model_inputs[\"attention_mask\"][i] = [0] * (max_length - len(sample_input_ids)) + model_inputs[\n",
+    "            \"attention_mask\"\n",
+    "        ][i]\n",
+    "        labels[\"input_ids\"][i] = [-100] * (max_length - len(sample_input_ids)) + label_input_ids\n",
+    "        model_inputs[\"input_ids\"][i] = model_inputs[\"input_ids\"][i][:max_length]\n",
+    "        model_inputs[\"attention_mask\"][i] = model_inputs[\"attention_mask\"][i][:max_length]\n",
+    "        labels[\"input_ids\"][i] = labels[\"input_ids\"][i][:max_length]\n",
+    "    model_inputs[\"labels\"] = labels[\"input_ids\"]\n",
+    "    return model_inputs\n",
+    "\n",
+    "\n",
+    "processed_datasets = dataset.map(\n",
+    "    preprocess_function,\n",
+    "    batched=True,\n",
+    "    num_proc=1,\n",
+    "    remove_columns=dataset[\"train\"].column_names,\n",
+    "    load_from_cache_file=False,\n",
+    "    desc=\"Running tokenizer on dataset\",\n",
+    ")\n",
+    "\n",
+    "train_dataset = processed_datasets[\"train\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "5671b1ee-dca4-4705-8399-5c2967b9fb5c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Dataset({\n",
+       "    features: ['input_ids', 'attention_mask', 'labels'],\n",
+       "    num_rows: 986\n",
+       "})"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "train_dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "3f38888e-4382-415b-869d-7202a816606a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_dataloader = DataLoader(\n",
+    "    train_dataset, shuffle=True, collate_fn=default_data_collator, batch_size=8, pin_memory=True\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "53b9e552-4c5d-43e8-a9cd-8073af8d4280",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'input_ids': tensor([[32002, 32002, 32002,  ..., 32017, 32001, 32001],\n",
+       "         [32002, 32002, 32002,  ..., 32017, 32001, 32001],\n",
+       "         [32002, 32002, 32002,  ..., 32017, 32001, 32001],\n",
+       "         ...,\n",
+       "         [32002, 32002, 32002,  ..., 32017, 32001, 32001],\n",
+       "         [32002, 32002, 32002,  ..., 32017, 32001, 32001],\n",
+       "         [32002, 32002, 32002,  ..., 32017, 32001, 32001]]),\n",
+       " 'attention_mask': tensor([[0, 0, 0,  ..., 1, 1, 1],\n",
+       "         [0, 0, 0,  ..., 1, 1, 1],\n",
+       "         [0, 0, 0,  ..., 1, 1, 1],\n",
+       "         ...,\n",
+       "         [0, 0, 0,  ..., 1, 1, 1],\n",
+       "         [0, 0, 0,  ..., 1, 1, 1],\n",
+       "         [0, 0, 0,  ..., 1, 1, 1]]),\n",
+       " 'labels': tensor([[ -100,  -100,  -100,  ..., 32017, 32001, 32001],\n",
+       "         [ -100,  -100,  -100,  ..., 32017, 32001, 32001],\n",
+       "         [ -100,  -100,  -100,  ..., 32017, 32001, 32001],\n",
+       "         ...,\n",
+       "         [ -100,  -100,  -100,  ..., 32017, 32001, 32001],\n",
+       "         [ -100,  -100,  -100,  ..., 32017, 32001, 32001],\n",
+       "         [ -100,  -100,  -100,  ..., 32017, 32001, 32001]])}"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "next(iter(train_dataloader))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "7de31ee2-185e-4658-9ad1-ae5f6bc3a611",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"<|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|pad|><|startoftext|><|begincontext|><|user|> Can you find me place to eat?<|system|> What kind of food would you like to have and where would you like me to search in?<|user|> Food kind of California will be perfect in SF.<|system|> There are 10 restaurants, Al's Place is one of the good restaurant in San Francisco.<|user|> Can you look for any other restaurant?<|system|> Alta Msp is one of the good restaurant in San Francisco.<|beginlastuserutterance|> Can you find me the address?<|endlastuserutterance|><|endcontext|><|begintarget|><|begindsts|><|begindst|><|beginintent|> FindRestaurants<|endintent|><|beginrequestedslots|> Restaurants^street_address<|endrequestedslots|><|beginbelief|> Restaurants^city->SF~San Francisco|Restaurants^cuisine->California<|endbelief|><|enddst|><|enddsts|><|beginuseraction|> REQUEST->Restaurants^street_address~<|enduseraction|><|beginaction|> INFORM->Restaurants^street_address~1275 Minnesota Street<|endaction|><|beginresponse|> The street address of the restaurant is 1275 Minnesota Street.<|endresponse|><|endtarget|><|endtarget|>\""
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tokenizer.decode(train_dataset[0][\"input_ids\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "239d1c83-196d-471e-9bf7-5f36dafa9894",
+   "metadata": {},
+   "source": [
+    "# Train the model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "ec80d6ee",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "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.\n",
+      "Failed to detect the name of this notebook, you can set it manually with the WANDB_NOTEBOOK_NAME environment variable to enable code saving.\n",
+      "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33msmangrul\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "Tracking run with wandb version 0.16.0"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "Run data is saved locally in <code>/raid/sourab/temp/wandb/run-20231128_230934-edod21gq</code>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "Syncing run <strong><a href='https://wandb.ai/smangrul/PeftExamples/runs/edod21gq' target=\"_blank\">ethereal-eon-1</a></strong> to <a href='https://wandb.ai/smangrul/PeftExamples' target=\"_blank\">Weights & Biases</a> (<a href='https://wandb.me/run' target=\"_blank\">docs</a>)<br/>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       " View project at <a href='https://wandb.ai/smangrul/PeftExamples' target=\"_blank\">https://wandb.ai/smangrul/PeftExamples</a>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       " View run at <a href='https://wandb.ai/smangrul/PeftExamples/runs/edod21gq' target=\"_blank\">https://wandb.ai/smangrul/PeftExamples/runs/edod21gq</a>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`...\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "    <div>\n",
+       "      \n",
+       "      <progress value='246' max='246' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
+       "      [246/246 05:51, Epoch 2/2]\n",
+       "    </div>\n",
+       "    <table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       " <tr style=\"text-align: left;\">\n",
+       "      <th>Step</th>\n",
+       "      <th>Training Loss</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <td>10</td>\n",
+       "      <td>5.189800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>20</td>\n",
+       "      <td>3.745500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>30</td>\n",
+       "      <td>2.371500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>40</td>\n",
+       "      <td>1.630200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>50</td>\n",
+       "      <td>1.302600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>60</td>\n",
+       "      <td>0.999400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>70</td>\n",
+       "      <td>0.704100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>80</td>\n",
+       "      <td>0.527800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>90</td>\n",
+       "      <td>0.509700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>100</td>\n",
+       "      <td>0.382300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>110</td>\n",
+       "      <td>0.318200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>120</td>\n",
+       "      <td>0.323500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>130</td>\n",
+       "      <td>0.263400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>140</td>\n",
+       "      <td>0.290900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>150</td>\n",
+       "      <td>0.277400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>160</td>\n",
+       "      <td>0.232800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>170</td>\n",
+       "      <td>0.223600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>180</td>\n",
+       "      <td>0.229600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>190</td>\n",
+       "      <td>0.233100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>200</td>\n",
+       "      <td>0.210200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>210</td>\n",
+       "      <td>0.245800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>220</td>\n",
+       "      <td>0.197300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>230</td>\n",
+       "      <td>0.210100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>240</td>\n",
+       "      <td>0.209800</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table><p>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "TrainOutput(global_step=246, training_loss=0.8516577879587809, metrics={'train_runtime': 354.9013, 'train_samples_per_second': 5.556, 'train_steps_per_second': 0.693, 'total_flos': 4.318233532091597e+16, 'train_loss': 0.8516577879587809, 'epoch': 2.0})"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "training_args = TrainingArguments(\n",
+    "    output_dir=\"mistral_lora_clm_with_added_tokens\",\n",
+    "    num_train_epochs=2,\n",
+    "    save_total_limit=5,\n",
+    "    per_device_train_batch_size=8,\n",
+    "    warmup_steps=10,\n",
+    "    weight_decay=0.0001,\n",
+    "    dataloader_drop_last=True,\n",
+    "    bf16=True,\n",
+    "    logging_steps=10,\n",
+    "    learning_rate=1e-5,\n",
+    "    gradient_checkpointing=True,\n",
+    "    gradient_checkpointing_kwargs={\"use_reentrant\": False},\n",
+    "    remove_unused_columns=False,\n",
+    "    hub_model_id=\"smangrul/mistral_lora_clm_with_added_tokens\",\n",
+    "    push_to_hub=True,\n",
+    "    hub_private_repo=True,\n",
+    ")\n",
+    "trainer = Trainer(\n",
+    "    model=model,\n",
+    "    args=training_args,\n",
+    "    train_dataset=train_dataset,\n",
+    "    data_collator=default_data_collator,\n",
+    ")\n",
+    "# model.config.use_cache = False\n",
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7bc1cbed-4eb9-4aaa-ab5f-5b91bf432307",
+   "metadata": {},
+   "source": [
+    "# Check the model output on a sample from evaluation dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "71851793",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "context=\"<|begincontext|><|user|>Can you find me a place to eat please?<|system|>Where at? And what kind of cuisine are you craving?<|user|>Somewhere in SF, and I am really craving Thai food at the moment!<|system|>I found a bunch of restaurants, there's actually 10 that you might like in San Francisco, one of them being Baan Thai House & Wine Bar<|user|>How can I reach them? And what's their address?<|system|>You can reach them by phone at 415-379-4505 and visit them at 534 Irving Street<|beginlastuserutterance|>Great, that restaurant sounds good<|endlastuserutterance|><|endcontext|>\" \n",
+      "\n",
+      " target_predicted='<|begintarget|><|begindsts|><|begindst|><|beginintent|> FindRestaurants<|endintent|><|beginbelief|> Restaurants^city->SF~San Francisco|Restaurants^cuisine->Thai|Restaurants^restaurant_name->Baan Thai House & Wine Bar<|endbelief|><|enddst|><|enddsts|><|beginuseraction|> REQUEST->Restaurants^phone_number~|REQUEST->Restaurants^street_address~<|enduseraction|><|beginaction|> INFORM->Restaurants^phone_number~415-379-4505|INFORM->Restaurants^street_address~534 Irving Street<|endaction|><|beginresponse|> Great, the phone number is 415-379-4505 and the address is 534 Irving Street<|endresponse|><|endtarget|>' \n",
+      "\n",
+      " target='<|begintarget|><|begindsts|><|begindst|><|beginintent|>FindRestaurants<|endintent|><|beginbelief|>Restaurants^city->SF~San Francisco|Restaurants^cuisine->Thai|Restaurants^restaurant_name->Baan Thai House & Wine Bar<|endbelief|><|enddst|><|enddsts|><|beginuseraction|>SELECT->Restaurants^~<|enduseraction|><|beginaction|>OFFER_INTENT->Restaurants^intent~ReserveRestaurant<|endaction|><|beginresponse|>Want me to book a table?<|endresponse|><|endtarget|>'\n"
+     ]
+    }
+   ],
+   "source": [
+    "import random\n",
+    "\n",
+    "i = random.randint(0, len(dataset[\"test\"]))\n",
+    "context = dataset[\"test\"][i][\"context\"]\n",
+    "\n",
+    "batch = tokenizer(context, return_tensors=\"pt\")\n",
+    "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "batch = {k: v.to(device) for k, v in batch.items()}\n",
+    "model.eval()\n",
+    "output_tokens = model.generate(\n",
+    "    **batch,\n",
+    "    max_new_tokens=256,\n",
+    "    do_sample=True,\n",
+    "    temperature=0.2,\n",
+    "    top_p=0.95,\n",
+    "    top_k=50,\n",
+    "    eos_token_id=tokenizer.eos_token_id,\n",
+    "    pad_token_id=tokenizer.pad_token_id,\n",
+    ")\n",
+    "target_predicted = tokenizer.decode(output_tokens[0], skip_special_tokens=False).split(\"<|endcontext|>\")[1]\n",
+    "target = dataset[\"test\"][i][\"target\"]\n",
+    "print(f\"{context=} \\n\\n {target_predicted=} \\n\\n {target=}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f940a660-2f7c-4a3a-b412-3f037aedb890",
+   "metadata": {},
+   "source": [
+    "# Save the Adapter model "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7ebe05e9-9b93-42f6-bba8-46b8cc3d100f",
+   "metadata": {},
+   "source": [
+    "When the lora layers are applied to embedding layers, the corresponding base model embedding layers are also saved. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "3d7459ba-caa8-4f10-aa70-89be4541cbdf",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/raid/sourab/peft/src/peft/utils/save_and_load.py:128: UserWarning: Setting `is_embedding_layer_resized` to `True` as embedding layers found in `target_modules`\n",
+      "  warnings.warn(\"Setting `is_embedding_layer_resized` to `True` as embedding layers found in `target_modules`\")\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "8d23186832014f209939ab83e79da011",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Upload 3 LFS files:   0%|          | 0/3 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a3d831bc7d8843038364e821aacff5f1",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "adapter_model.safetensors:   0%|          | 0.00/1.18G [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "84cc7a2a3a474bb791d61e2357dd229e",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "events.out.tfevents.1701209373.hf-dgx-01.667111.0:   0%|          | 0.00/8.52k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "7ce2025dd01647599c00578044512c8c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "training_args.bin:   0%|          | 0.00/4.79k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "CommitInfo(commit_url='https://huggingface.co/smangrul/mistral_lora_clm_with_added_tokens/commit/60ed7ea8bef10ce46d7a64229481dd1ad0e3d1c5', commit_message='Upload model', commit_description='', oid='60ed7ea8bef10ce46d7a64229481dd1ad0e3d1c5', pr_url=None, pr_revision=None, pr_num=None)"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "trainer.push_to_hub()\n",
+    "trainer.model.push_to_hub(training_args.output_dir)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "66812cc4-f9a3-46c4-bcee-0cba03950685",
+   "metadata": {},
+   "source": [
+    "# Check the model loading is working as expected and generating plausible outputs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "589c46d7-d567-40b4-ab7d-e0a9e1cab40e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f98524da95b64a29a9016c6067313b2b",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Loading checkpoint shards:   0%|          | 0/2 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "aaae3bc0f52f45bbaab60687b71fc4cf",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "adapter_config.json:   0%|          | 0.00/637 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "1fc5754f41784d1aba00b93551894579",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "adapter_model.safetensors:   0%|          | 0.00/1.18G [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "context=\"<|begincontext|><|user|>Can you find me a place to eat please?<|system|>Where at? And what kind of cuisine are you craving?<|user|>Somewhere in SF, and I am really craving Thai food at the moment!<|system|>I found a bunch of restaurants, there's actually 10 that you might like in San Francisco, one of them being Baan Thai House & Wine Bar<|user|>How can I reach them? And what's their address?<|system|>You can reach them by phone at 415-379-4505 and visit them at 534 Irving Street<|beginlastuserutterance|>Great, that restaurant sounds good<|endlastuserutterance|><|endcontext|>\" \n",
+      "\n",
+      " target_predicted='<|begintarget|><|begindsts|><|begindst|><|beginintent|> FindRestaurant<|endintent|><|beginbelief|> Restaurants^city->SF~San Francisco|Restaurants^cuisine->Thai|Restaurants^restaurant_name->Baan Thai House & Wine Bar<|endbelief|><|enddst|><|enddsts|><|beginuseraction|> REQUEST->Restaurants^phone_number~|REQUEST->Restaurants^street_address~<|enduseraction|><|beginaction|> INFORM->Restaurants^phone_number~415-379-4505|INFORM->Restaurants^street_address~534 Irving Street<|endaction|><|beginresponse|> The phone number is 415-379-4505 and the address is 534 Irving Street<|endresponse|><|endtarget|>' \n",
+      "\n",
+      " target='<|begintarget|><|begindsts|><|begindst|><|beginintent|>FindRestaurants<|endintent|><|beginbelief|>Restaurants^city->SF~San Francisco|Restaurants^cuisine->Thai|Restaurants^restaurant_name->Baan Thai House & Wine Bar<|endbelief|><|enddst|><|enddsts|><|beginuseraction|>SELECT->Restaurants^~<|enduseraction|><|beginaction|>OFFER_INTENT->Restaurants^intent~ReserveRestaurant<|endaction|><|beginresponse|>Want me to book a table?<|endresponse|><|endtarget|>'\n"
+     ]
+    }
+   ],
+   "source": [
+    "from peft import PeftModel\n",
+    "\n",
+    "inference_model = AutoModelForCausalLM.from_pretrained(\n",
+    "    model_name,\n",
+    "    low_cpu_mem_usage=True,\n",
+    "    # attn_implementation =\"flash_attention_2\",\n",
+    ")\n",
+    "inference_model.resize_token_embeddings(len(tokenizer))\n",
+    "\n",
+    "inference_model = PeftModel.from_pretrained(inference_model, \"smangrul/mistral_lora_clm_with_added_tokens\")\n",
+    "inference_model.to(device)\n",
+    "inference_model.eval()\n",
+    "\n",
+    "output_tokens = inference_model.generate(\n",
+    "    **batch,\n",
+    "    max_new_tokens=256,\n",
+    "    do_sample=True,\n",
+    "    temperature=0.2,\n",
+    "    top_p=0.95,\n",
+    "    top_k=50,\n",
+    "    eos_token_id=tokenizer.eos_token_id,\n",
+    "    pad_token_id=tokenizer.pad_token_id,\n",
+    ")\n",
+    "\n",
+    "target_predicted = tokenizer.decode(output_tokens[0], skip_special_tokens=False).split(\"<|endcontext|>\")[1]\n",
+    "print(f\"{context=} \\n\\n {target_predicted=} \\n\\n {target=}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fd57f6e8-761f-4e0b-941c-f6973e13b186",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/causal_language_modeling/peft_prefix_tuning_clm.ipynb b/examples/causal_language_modeling/peft_prefix_tuning_clm.ipynb
new file mode 100644
index 0000000..56e2e9f
--- /dev/null
+++ b/examples/causal_language_modeling/peft_prefix_tuning_clm.ipynb
@@ -0,0 +1,1375 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "71fbfca2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import AutoModelForCausalLM\n",
+    "from peft import get_peft_config, get_peft_model, PrefixTuningConfig, TaskType, PeftType\n",
+    "import torch\n",
+    "from datasets import load_dataset\n",
+    "import os\n",
+    "from transformers import AutoTokenizer\n",
+    "from torch.utils.data import DataLoader\n",
+    "from transformers import default_data_collator, get_linear_schedule_with_warmup\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "model_name_or_path = \"bigscience/bloomz-560m\"\n",
+    "tokenizer_name_or_path = \"bigscience/bloomz-560m\"\n",
+    "peft_config = PrefixTuningConfig(task_type=TaskType.CAUSAL_LM, num_virtual_tokens=30)\n",
+    "\n",
+    "dataset_name = \"twitter_complaints\"\n",
+    "checkpoint_name = f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}_v1.pt\".replace(\n",
+    "    \"/\", \"_\"\n",
+    ")\n",
+    "text_column = \"Tweet text\"\n",
+    "label_column = \"text_label\"\n",
+    "max_length = 64\n",
+    "lr = 3e-2\n",
+    "num_epochs = 50\n",
+    "batch_size = 8"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e1a3648b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Found cached dataset raft (/home/sourab/.cache/huggingface/datasets/ought___raft/twitter_complaints/1.1.0/79c4de1312c1e3730043f7db07179c914f48403101f7124e2fe336f6f54d9f84)\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "56d9908a2c8944b484348cc46b16a261",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/2 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading cached processed dataset at /home/sourab/.cache/huggingface/datasets/ought___raft/twitter_complaints/1.1.0/79c4de1312c1e3730043f7db07179c914f48403101f7124e2fe336f6f54d9f84/cache-20a7622c86d80cdf.arrow\n",
+      "Loading cached processed dataset at /home/sourab/.cache/huggingface/datasets/ought___raft/twitter_complaints/1.1.0/79c4de1312c1e3730043f7db07179c914f48403101f7124e2fe336f6f54d9f84/cache-5f1431311da05803.arrow\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['Unlabeled', 'complaint', 'no complaint']\n",
+      "DatasetDict({\n",
+      "    train: Dataset({\n",
+      "        features: ['Tweet text', 'ID', 'Label', 'text_label'],\n",
+      "        num_rows: 50\n",
+      "    })\n",
+      "    test: Dataset({\n",
+      "        features: ['Tweet text', 'ID', 'Label', 'text_label'],\n",
+      "        num_rows: 3399\n",
+      "    })\n",
+      "})\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'Tweet text': '@HMRCcustomers No this is my first job',\n",
+       " 'ID': 0,\n",
+       " 'Label': 2,\n",
+       " 'text_label': 'no complaint'}"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dataset = load_dataset(\n",
+    "    \"parquet\",\n",
+    "    data_files={\n",
+    "        \"train\": f\"hf://datasets/ought/raft@refs/convert/parquet/{dataset_name}/train/0000.parquet\",\n",
+    "        \"test\": f\"hf://datasets/ought/raft@refs/convert/parquet/{dataset_name}/test/0000.parquet\"\n",
+    "    }\n",
+    ")\n",
+    "\n",
+    "\n",
+    "classes = [k.replace(\"_\", \" \") for k in dataset[\"train\"].features[\"Label\"].names]\n",
+    "print(classes)\n",
+    "dataset = dataset.map(\n",
+    "    lambda x: {\"text_label\": [classes[label] for label in x[\"Label\"]]},\n",
+    "    batched=True,\n",
+    "    num_proc=1,\n",
+    ")\n",
+    "print(dataset)\n",
+    "dataset[\"train\"][0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "fe12d4d3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "5a0e3242324842fb941950df38b459fe",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Running tokenizer on dataset:   0%|          | 0/1 [00:00<?, ?ba/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "133df817b7b9468cabd5353d4d2b675b",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Running tokenizer on dataset:   0%|          | 0/4 [00:00<?, ?ba/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# data preprocessing\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)\n",
+    "if tokenizer.pad_token_id is None:\n",
+    "    tokenizer.pad_token_id = tokenizer.eos_token_id\n",
+    "target_max_length = max([len(tokenizer(class_label)[\"input_ids\"]) for class_label in classes])\n",
+    "print(target_max_length)\n",
+    "\n",
+    "\n",
+    "def preprocess_function(examples):\n",
+    "    batch_size = len(examples[text_column])\n",
+    "    inputs = [f\"{text_column} : {x} Label : \" for x in examples[text_column]]\n",
+    "    targets = [str(x) for x in examples[label_column]]\n",
+    "    model_inputs = tokenizer(inputs)\n",
+    "    labels = tokenizer(targets, add_special_tokens=False)  # don't add bos token because we concatenate with inputs\n",
+    "    for i in range(batch_size):\n",
+    "        sample_input_ids = model_inputs[\"input_ids\"][i]\n",
+    "        label_input_ids = labels[\"input_ids\"][i] + [tokenizer.eos_token_id]\n",
+    "        # print(i, sample_input_ids, label_input_ids)\n",
+    "        model_inputs[\"input_ids\"][i] = sample_input_ids + label_input_ids\n",
+    "        labels[\"input_ids\"][i] = [-100] * len(sample_input_ids) + label_input_ids\n",
+    "        model_inputs[\"attention_mask\"][i] = [1] * len(model_inputs[\"input_ids\"][i])\n",
+    "    # print(model_inputs)\n",
+    "    for i in range(batch_size):\n",
+    "        sample_input_ids = model_inputs[\"input_ids\"][i]\n",
+    "        label_input_ids = labels[\"input_ids\"][i]\n",
+    "        model_inputs[\"input_ids\"][i] = [tokenizer.pad_token_id] * (\n",
+    "            max_length - len(sample_input_ids)\n",
+    "        ) + sample_input_ids\n",
+    "        model_inputs[\"attention_mask\"][i] = [0] * (max_length - len(sample_input_ids)) + model_inputs[\n",
+    "            \"attention_mask\"\n",
+    "        ][i]\n",
+    "        labels[\"input_ids\"][i] = [-100] * (max_length - len(sample_input_ids)) + label_input_ids\n",
+    "        model_inputs[\"input_ids\"][i] = torch.tensor(model_inputs[\"input_ids\"][i][:max_length])\n",
+    "        model_inputs[\"attention_mask\"][i] = torch.tensor(model_inputs[\"attention_mask\"][i][:max_length])\n",
+    "        labels[\"input_ids\"][i] = torch.tensor(labels[\"input_ids\"][i][:max_length])\n",
+    "    model_inputs[\"labels\"] = labels[\"input_ids\"]\n",
+    "    return model_inputs\n",
+    "\n",
+    "\n",
+    "processed_datasets = dataset.map(\n",
+    "    preprocess_function,\n",
+    "    batched=True,\n",
+    "    num_proc=1,\n",
+    "    remove_columns=dataset[\"train\"].column_names,\n",
+    "    load_from_cache_file=False,\n",
+    "    desc=\"Running tokenizer on dataset\",\n",
+    ")\n",
+    "\n",
+    "train_dataset = processed_datasets[\"train\"]\n",
+    "eval_dataset = processed_datasets[\"train\"]\n",
+    "\n",
+    "\n",
+    "train_dataloader = DataLoader(\n",
+    "    train_dataset, shuffle=True, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True\n",
+    ")\n",
+    "eval_dataloader = DataLoader(eval_dataset, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "641b21fe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def test_preprocess_function(examples):\n",
+    "    batch_size = len(examples[text_column])\n",
+    "    inputs = [f\"{text_column} : {x} Label : \" for x in examples[text_column]]\n",
+    "    model_inputs = tokenizer(inputs)\n",
+    "    # print(model_inputs)\n",
+    "    for i in range(batch_size):\n",
+    "        sample_input_ids = model_inputs[\"input_ids\"][i]\n",
+    "        model_inputs[\"input_ids\"][i] = [tokenizer.pad_token_id] * (\n",
+    "            max_length - len(sample_input_ids)\n",
+    "        ) + sample_input_ids\n",
+    "        model_inputs[\"attention_mask\"][i] = [0] * (max_length - len(sample_input_ids)) + model_inputs[\n",
+    "            \"attention_mask\"\n",
+    "        ][i]\n",
+    "        model_inputs[\"input_ids\"][i] = torch.tensor(model_inputs[\"input_ids\"][i][:max_length])\n",
+    "        model_inputs[\"attention_mask\"][i] = torch.tensor(model_inputs[\"attention_mask\"][i][:max_length])\n",
+    "    return model_inputs\n",
+    "\n",
+    "\n",
+    "test_dataset = dataset[\"test\"].map(\n",
+    "    test_preprocess_function,\n",
+    "    batched=True,\n",
+    "    num_proc=1,\n",
+    "    remove_columns=dataset[\"train\"].column_names,\n",
+    "    load_from_cache_file=False,\n",
+    "    desc=\"Running tokenizer on dataset\",\n",
+    ")\n",
+    "\n",
+    "test_dataloader = DataLoader(test_dataset, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True)\n",
+    "next(iter(test_dataloader))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "accc5012",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "next(iter(train_dataloader))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "218df807",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "425"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(test_dataloader)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "47d1fedf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "next(iter(test_dataloader))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "a773e092",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "trainable params: 1474560 || all params: 560689152 || trainable%: 0.26299064191632515\n"
+     ]
+    }
+   ],
+   "source": [
+    "# creating model\n",
+    "model = AutoModelForCausalLM.from_pretrained(model_name_or_path)\n",
+    "model = get_peft_model(model, peft_config)\n",
+    "model.print_trainable_parameters()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "22822901",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "023cb942",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "PrefixTuningConfig(peft_type=<PeftType.PREFIX_TUNING: 'PREFIX_TUNING'>, base_model_name_or_path='bigscience/bloomz-560m', task_type=<TaskType.CAUSAL_LM: 'CAUSAL_LM'>, inference_mode=False, num_virtual_tokens=30, token_dim=1024, num_transformer_submodules=1, num_attention_heads=16, num_layers=24, encoder_hidden_size=1024, prefix_projection=False)"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.peft_config"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "b2f91568",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# model\n",
+    "# optimizer and lr scheduler\n",
+    "optimizer = torch.optim.AdamW(model.parameters(), lr=lr)\n",
+    "lr_scheduler = get_linear_schedule_with_warmup(\n",
+    "    optimizer=optimizer,\n",
+    "    num_warmup_steps=0,\n",
+    "    num_training_steps=(len(train_dataloader) * num_epochs),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "e4fb69fc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:01<00:00,  5.79it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.51it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=0: train_ppl=tensor(1.8325e+09, device='cuda:0') train_epoch_loss=tensor(21.3289, device='cuda:0') eval_ppl=tensor(2713.4180, device='cuda:0') eval_epoch_loss=tensor(7.9060, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.44it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.53it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=1: train_ppl=tensor(341.0600, device='cuda:0') train_epoch_loss=tensor(5.8321, device='cuda:0') eval_ppl=tensor(80.8206, device='cuda:0') eval_epoch_loss=tensor(4.3922, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.44it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.55it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=2: train_ppl=tensor(59.8778, device='cuda:0') train_epoch_loss=tensor(4.0923, device='cuda:0') eval_ppl=tensor(34.4593, device='cuda:0') eval_epoch_loss=tensor(3.5398, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.45it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.55it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=3: train_ppl=tensor(22.3307, device='cuda:0') train_epoch_loss=tensor(3.1060, device='cuda:0') eval_ppl=tensor(12.5947, device='cuda:0') eval_epoch_loss=tensor(2.5333, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.45it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.56it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=4: train_ppl=tensor(9.1697, device='cuda:0') train_epoch_loss=tensor(2.2159, device='cuda:0') eval_ppl=tensor(4.5289, device='cuda:0') eval_epoch_loss=tensor(1.5105, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.45it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.52it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=5: train_ppl=tensor(3.0172, device='cuda:0') train_epoch_loss=tensor(1.1043, device='cuda:0') eval_ppl=tensor(1.8092, device='cuda:0') eval_epoch_loss=tensor(0.5929, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.44it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.45it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=6: train_ppl=tensor(1.4885, device='cuda:0') train_epoch_loss=tensor(0.3978, device='cuda:0') eval_ppl=tensor(1.4449, device='cuda:0') eval_epoch_loss=tensor(0.3680, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.43it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.48it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=7: train_ppl=tensor(1.2967, device='cuda:0') train_epoch_loss=tensor(0.2598, device='cuda:0') eval_ppl=tensor(1.1587, device='cuda:0') eval_epoch_loss=tensor(0.1473, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.43it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.47it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=8: train_ppl=tensor(1.1305, device='cuda:0') train_epoch_loss=tensor(0.1227, device='cuda:0') eval_ppl=tensor(1.0874, device='cuda:0') eval_epoch_loss=tensor(0.0838, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.45it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.46it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=9: train_ppl=tensor(1.1608, device='cuda:0') train_epoch_loss=tensor(0.1491, device='cuda:0') eval_ppl=tensor(1.1461, device='cuda:0') eval_epoch_loss=tensor(0.1364, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.45it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.45it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=10: train_ppl=tensor(1.3172, device='cuda:0') train_epoch_loss=tensor(0.2755, device='cuda:0') eval_ppl=tensor(1.1320, device='cuda:0') eval_epoch_loss=tensor(0.1240, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.44it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.46it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=11: train_ppl=tensor(1.1437, device='cuda:0') train_epoch_loss=tensor(0.1343, device='cuda:0') eval_ppl=tensor(1.0676, device='cuda:0') eval_epoch_loss=tensor(0.0654, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.43it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.43it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=12: train_ppl=tensor(1.0651, device='cuda:0') train_epoch_loss=tensor(0.0630, device='cuda:0') eval_ppl=tensor(1.0735, device='cuda:0') eval_epoch_loss=tensor(0.0710, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.46it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.47it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=13: train_ppl=tensor(1.0607, device='cuda:0') train_epoch_loss=tensor(0.0589, device='cuda:0') eval_ppl=tensor(1.0399, device='cuda:0') eval_epoch_loss=tensor(0.0391, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.43it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.44it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=14: train_ppl=tensor(1.0351, device='cuda:0') train_epoch_loss=tensor(0.0345, device='cuda:0') eval_ppl=tensor(1.0260, device='cuda:0') eval_epoch_loss=tensor(0.0257, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.44it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.43it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=15: train_ppl=tensor(1.0217, device='cuda:0') train_epoch_loss=tensor(0.0215, device='cuda:0') eval_ppl=tensor(1.0168, device='cuda:0') eval_epoch_loss=tensor(0.0167, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.43it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.28it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=16: train_ppl=tensor(1.0152, device='cuda:0') train_epoch_loss=tensor(0.0151, device='cuda:0') eval_ppl=tensor(1.0117, device='cuda:0') eval_epoch_loss=tensor(0.0116, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.43it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.41it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=17: train_ppl=tensor(1.0102, device='cuda:0') train_epoch_loss=tensor(0.0101, device='cuda:0') eval_ppl=tensor(1.0088, device='cuda:0') eval_epoch_loss=tensor(0.0088, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.29it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.25it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=18: train_ppl=tensor(1.0083, device='cuda:0') train_epoch_loss=tensor(0.0083, device='cuda:0') eval_ppl=tensor(1.0073, device='cuda:0') eval_epoch_loss=tensor(0.0073, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.43it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.46it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=19: train_ppl=tensor(1.0070, device='cuda:0') train_epoch_loss=tensor(0.0070, device='cuda:0') eval_ppl=tensor(1.0064, device='cuda:0') eval_epoch_loss=tensor(0.0063, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.43it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.51it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=20: train_ppl=tensor(1.0059, device='cuda:0') train_epoch_loss=tensor(0.0059, device='cuda:0') eval_ppl=tensor(1.0057, device='cuda:0') eval_epoch_loss=tensor(0.0057, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.43it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.47it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=21: train_ppl=tensor(1.0056, device='cuda:0') train_epoch_loss=tensor(0.0056, device='cuda:0') eval_ppl=tensor(1.0052, device='cuda:0') eval_epoch_loss=tensor(0.0052, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.41it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.33it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=22: train_ppl=tensor(1.0050, device='cuda:0') train_epoch_loss=tensor(0.0050, device='cuda:0') eval_ppl=tensor(1.0049, device='cuda:0') eval_epoch_loss=tensor(0.0049, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.39it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.44it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=23: train_ppl=tensor(1.0049, device='cuda:0') train_epoch_loss=tensor(0.0049, device='cuda:0') eval_ppl=tensor(1.0045, device='cuda:0') eval_epoch_loss=tensor(0.0045, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.42it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.49it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=24: train_ppl=tensor(1.0043, device='cuda:0') train_epoch_loss=tensor(0.0043, device='cuda:0') eval_ppl=tensor(1.0043, device='cuda:0') eval_epoch_loss=tensor(0.0043, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.46it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.47it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=25: train_ppl=tensor(1.0042, device='cuda:0') train_epoch_loss=tensor(0.0042, device='cuda:0') eval_ppl=tensor(1.0040, device='cuda:0') eval_epoch_loss=tensor(0.0040, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.44it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.52it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=26: train_ppl=tensor(1.0039, device='cuda:0') train_epoch_loss=tensor(0.0039, device='cuda:0') eval_ppl=tensor(1.0039, device='cuda:0') eval_epoch_loss=tensor(0.0039, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.44it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.48it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=27: train_ppl=tensor(1.0038, device='cuda:0') train_epoch_loss=tensor(0.0038, device='cuda:0') eval_ppl=tensor(1.0037, device='cuda:0') eval_epoch_loss=tensor(0.0037, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.46it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.54it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=28: train_ppl=tensor(1.0036, device='cuda:0') train_epoch_loss=tensor(0.0036, device='cuda:0') eval_ppl=tensor(1.0035, device='cuda:0') eval_epoch_loss=tensor(0.0035, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.45it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.53it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=29: train_ppl=tensor(1.0034, device='cuda:0') train_epoch_loss=tensor(0.0034, device='cuda:0') eval_ppl=tensor(1.0034, device='cuda:0') eval_epoch_loss=tensor(0.0034, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.43it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.47it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=30: train_ppl=tensor(1.0034, device='cuda:0') train_epoch_loss=tensor(0.0034, device='cuda:0') eval_ppl=tensor(1.0033, device='cuda:0') eval_epoch_loss=tensor(0.0033, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.43it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.47it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=31: train_ppl=tensor(1.0033, device='cuda:0') train_epoch_loss=tensor(0.0033, device='cuda:0') eval_ppl=tensor(1.0032, device='cuda:0') eval_epoch_loss=tensor(0.0032, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.46it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.51it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=32: train_ppl=tensor(1.0031, device='cuda:0') train_epoch_loss=tensor(0.0031, device='cuda:0') eval_ppl=tensor(1.0031, device='cuda:0') eval_epoch_loss=tensor(0.0031, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.44it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.43it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=33: train_ppl=tensor(1.0030, device='cuda:0') train_epoch_loss=tensor(0.0030, device='cuda:0') eval_ppl=tensor(1.0030, device='cuda:0') eval_epoch_loss=tensor(0.0030, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.45it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.46it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=34: train_ppl=tensor(1.0029, device='cuda:0') train_epoch_loss=tensor(0.0029, device='cuda:0') eval_ppl=tensor(1.0029, device='cuda:0') eval_epoch_loss=tensor(0.0029, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.45it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.47it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=35: train_ppl=tensor(1.0028, device='cuda:0') train_epoch_loss=tensor(0.0028, device='cuda:0') eval_ppl=tensor(1.0029, device='cuda:0') eval_epoch_loss=tensor(0.0029, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.45it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.45it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=36: train_ppl=tensor(1.0027, device='cuda:0') train_epoch_loss=tensor(0.0027, device='cuda:0') eval_ppl=tensor(1.0028, device='cuda:0') eval_epoch_loss=tensor(0.0028, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.45it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.47it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=37: train_ppl=tensor(1.0027, device='cuda:0') train_epoch_loss=tensor(0.0027, device='cuda:0') eval_ppl=tensor(1.0027, device='cuda:0') eval_epoch_loss=tensor(0.0027, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.45it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.46it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=38: train_ppl=tensor(1.0027, device='cuda:0') train_epoch_loss=tensor(0.0027, device='cuda:0') eval_ppl=tensor(1.0027, device='cuda:0') eval_epoch_loss=tensor(0.0027, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.44it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.43it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=39: train_ppl=tensor(1.0025, device='cuda:0') train_epoch_loss=tensor(0.0025, device='cuda:0') eval_ppl=tensor(1.0026, device='cuda:0') eval_epoch_loss=tensor(0.0026, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.44it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.47it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=40: train_ppl=tensor(1.0026, device='cuda:0') train_epoch_loss=tensor(0.0026, device='cuda:0') eval_ppl=tensor(1.0026, device='cuda:0') eval_epoch_loss=tensor(0.0026, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.44it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.33it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=41: train_ppl=tensor(1.0025, device='cuda:0') train_epoch_loss=tensor(0.0025, device='cuda:0') eval_ppl=tensor(1.0025, device='cuda:0') eval_epoch_loss=tensor(0.0025, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.42it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.49it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=42: train_ppl=tensor(1.0024, device='cuda:0') train_epoch_loss=tensor(0.0024, device='cuda:0') eval_ppl=tensor(1.0025, device='cuda:0') eval_epoch_loss=tensor(0.0025, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.44it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.47it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=43: train_ppl=tensor(1.0024, device='cuda:0') train_epoch_loss=tensor(0.0024, device='cuda:0') eval_ppl=tensor(1.0025, device='cuda:0') eval_epoch_loss=tensor(0.0025, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.44it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.43it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=44: train_ppl=tensor(1.0025, device='cuda:0') train_epoch_loss=tensor(0.0024, device='cuda:0') eval_ppl=tensor(1.0024, device='cuda:0') eval_epoch_loss=tensor(0.0024, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.43it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.50it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=45: train_ppl=tensor(1.0024, device='cuda:0') train_epoch_loss=tensor(0.0024, device='cuda:0') eval_ppl=tensor(1.0024, device='cuda:0') eval_epoch_loss=tensor(0.0024, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.43it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.49it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=46: train_ppl=tensor(1.0024, device='cuda:0') train_epoch_loss=tensor(0.0024, device='cuda:0') eval_ppl=tensor(1.0024, device='cuda:0') eval_epoch_loss=tensor(0.0024, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.42it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.39it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=47: train_ppl=tensor(1.0023, device='cuda:0') train_epoch_loss=tensor(0.0023, device='cuda:0') eval_ppl=tensor(1.0024, device='cuda:0') eval_epoch_loss=tensor(0.0024, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.40it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 22.40it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=48: train_ppl=tensor(1.0023, device='cuda:0') train_epoch_loss=tensor(0.0023, device='cuda:0') eval_ppl=tensor(1.0024, device='cuda:0') eval_epoch_loss=tensor(0.0024, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 11.41it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.87it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=49: train_ppl=tensor(1.0023, device='cuda:0') train_epoch_loss=tensor(0.0023, device='cuda:0') eval_ppl=tensor(1.0024, device='cuda:0') eval_epoch_loss=tensor(0.0024, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# training and evaluation\n",
+    "model = model.to(device)\n",
+    "\n",
+    "for epoch in range(num_epochs):\n",
+    "    model.train()\n",
+    "    total_loss = 0\n",
+    "    for step, batch in enumerate(tqdm(train_dataloader)):\n",
+    "        batch = {k: v.to(device) for k, v in batch.items()}\n",
+    "        #         print(batch)\n",
+    "        #         print(batch[\"input_ids\"].shape)\n",
+    "        outputs = model(**batch)\n",
+    "        loss = outputs.loss\n",
+    "        total_loss += loss.detach().float()\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        lr_scheduler.step()\n",
+    "        optimizer.zero_grad()\n",
+    "\n",
+    "    model.eval()\n",
+    "    eval_loss = 0\n",
+    "    eval_preds = []\n",
+    "    for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+    "        batch = {k: v.to(device) for k, v in batch.items()}\n",
+    "        with torch.no_grad():\n",
+    "            outputs = model(**batch)\n",
+    "        loss = outputs.loss\n",
+    "        eval_loss += loss.detach().float()\n",
+    "        eval_preds.extend(\n",
+    "            tokenizer.batch_decode(torch.argmax(outputs.logits, -1).detach().cpu().numpy(), skip_special_tokens=True)\n",
+    "        )\n",
+    "\n",
+    "    eval_epoch_loss = eval_loss / len(eval_dataloader)\n",
+    "    eval_ppl = torch.exp(eval_epoch_loss)\n",
+    "    train_epoch_loss = total_loss / len(train_dataloader)\n",
+    "    train_ppl = torch.exp(train_epoch_loss)\n",
+    "    print(f\"{epoch=}: {train_ppl=} {train_epoch_loss=} {eval_ppl=} {eval_epoch_loss=}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "53752a7b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hey @nytimes your link to cancel my subscription isn't working and nobody is answering the chat. Please don't play that kind of stupid game.\n",
+      "{'input_ids': tensor([[227985,   5484,    915,  54078,   2566,   7782,  24502,   2632,   8989,\n",
+      "            427,  36992,   2670, 140711,  21994,  10789,    530,  88399,    632,\n",
+      "         183542,    368,  44799,     17,  29901,   5926,   7229,    861,  11596,\n",
+      "            461,  78851,  14775,     17,  77658,    915,    210]]), 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
+      "         1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])}\n",
+      "tensor([[227985,   5484,    915,  54078,   2566,   7782,  24502,   2632,   8989,\n",
+      "            427,  36992,   2670, 140711,  21994,  10789,    530,  88399,    632,\n",
+      "         183542,    368,  44799,     17,  29901,   5926,   7229,    861,  11596,\n",
+      "            461,  78851,  14775,     17,  77658,    915,    210,  16449,   5952,\n",
+      "              3]], device='cuda:0')\n",
+      "[\"Tweet text : Hey @nytimes your link to cancel my subscription isn't working and nobody is answering the chat. Please don't play that kind of stupid game. Label : complaint\"]\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.eval()\n",
+    "i = 16\n",
+    "inputs = tokenizer(f'{text_column} : {dataset[\"test\"][i][\"Tweet text\"]} Label : ', return_tensors=\"pt\")\n",
+    "print(dataset[\"test\"][i][\"Tweet text\"])\n",
+    "print(inputs)\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    inputs = {k: v.to(device) for k, v in inputs.items()}\n",
+    "    outputs = model.generate(\n",
+    "        input_ids=inputs[\"input_ids\"], attention_mask=inputs[\"attention_mask\"], max_new_tokens=10, eos_token_id=3\n",
+    "    )\n",
+    "    print(outputs)\n",
+    "    print(tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0e21c49b",
+   "metadata": {},
+   "source": [
+    "You can push model to hub or save model locally. \n",
+    "\n",
+    "- Option1: Pushing the model to Hugging Face Hub\n",
+    "```python\n",
+    "model.push_to_hub(\n",
+    "    f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\".replace(\"/\", \"_\"),\n",
+    "    token = \"hf_...\"\n",
+    ")\n",
+    "```\n",
+    "token (`bool` or `str`, *optional*):\n",
+    "    `token` is to be used for HTTP Bearer authorization when accessing remote files. If `True`, will use the token generated\n",
+    "    when running `huggingface-cli login` (stored in `~/.huggingface`). Will default to `True` if `repo_url`\n",
+    "    is not specified.\n",
+    "    Or you can get your token from https://huggingface.co/settings/token\n",
+    "```\n",
+    "- Or save model locally\n",
+    "```python\n",
+    "peft_model_id = f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\".replace(\"/\", \"_\")\n",
+    "model.save_pretrained(peft_model_id)\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "24041ee1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# saving model\n",
+    "peft_model_id = f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\".replace(\n",
+    "    \"/\", \"_\"\n",
+    ")\n",
+    "model.save_pretrained(peft_model_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "527eeaa4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ckpt = f\"{peft_model_id}/adapter_model.safetensors\"\n",
+    "!du -h $ckpt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "b19f5a90",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from peft import PeftModel, PeftConfig\n",
+    "\n",
+    "peft_model_id = f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\".replace(\n",
+    "    \"/\", \"_\"\n",
+    ")\n",
+    "\n",
+    "config = PeftConfig.from_pretrained(peft_model_id)\n",
+    "model = AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path)\n",
+    "model = PeftModel.from_pretrained(model, peft_model_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "a11a3768",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "@greateranglia Ok thanks...\n",
+      "{'input_ids': tensor([[227985,   5484,    915,   2566,  14173,   2960,  29906,    387,  20706,\n",
+      "          49337,   1369,  77658,    915,    210]]), 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])}\n",
+      "tensor([[227985,   5484,    915,   2566,  14173,   2960,  29906,    387,  20706,\n",
+      "          49337,   1369,  77658,    915,    210,   1936, 106863,      3]],\n",
+      "       device='cuda:0')\n",
+      "['Tweet text : @greateranglia Ok thanks... Label : no complaint']\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.to(device)\n",
+    "model.eval()\n",
+    "i = 4\n",
+    "inputs = tokenizer(f'{text_column} : {dataset[\"test\"][i][\"Tweet text\"]} Label : ', return_tensors=\"pt\")\n",
+    "print(dataset[\"test\"][i][\"Tweet text\"])\n",
+    "print(inputs)\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    inputs = {k: v.to(device) for k, v in inputs.items()}\n",
+    "    outputs = model.generate(\n",
+    "        input_ids=inputs[\"input_ids\"], attention_mask=inputs[\"attention_mask\"], max_new_tokens=10, eos_token_id=3\n",
+    "    )\n",
+    "    print(outputs)\n",
+    "    print(tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f890c951",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "463a41a2",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5c60c7a9",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.5"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/causal_language_modeling/peft_prompt_tuning_clm.ipynb b/examples/causal_language_modeling/peft_prompt_tuning_clm.ipynb
new file mode 100644
index 0000000..4744871
--- /dev/null
+++ b/examples/causal_language_modeling/peft_prompt_tuning_clm.ipynb
@@ -0,0 +1,1220 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "71fbfca2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import AutoModelForCausalLM\n",
+    "from peft import get_peft_config, get_peft_model, PromptTuningInit, PromptTuningConfig, TaskType, PeftType\n",
+    "import torch\n",
+    "from datasets import load_dataset\n",
+    "import os\n",
+    "from transformers import AutoTokenizer\n",
+    "from torch.utils.data import DataLoader\n",
+    "from transformers import default_data_collator, get_linear_schedule_with_warmup\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "model_name_or_path = \"bigscience/bloomz-560m\"\n",
+    "tokenizer_name_or_path = \"bigscience/bloomz-560m\"\n",
+    "peft_config = PromptTuningConfig(\n",
+    "    task_type=TaskType.CAUSAL_LM,\n",
+    "    prompt_tuning_init=PromptTuningInit.TEXT,\n",
+    "    num_virtual_tokens=8,\n",
+    "    prompt_tuning_init_text=\"Classify if the tweet is a complaint or not:\",\n",
+    "    tokenizer_name_or_path=model_name_or_path,\n",
+    ")\n",
+    "\n",
+    "dataset_name = \"twitter_complaints\"\n",
+    "checkpoint_name = f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}_v1.pt\".replace(\n",
+    "    \"/\", \"_\"\n",
+    ")\n",
+    "text_column = \"Tweet text\"\n",
+    "label_column = \"text_label\"\n",
+    "max_length = 64\n",
+    "lr = 3e-2\n",
+    "num_epochs = 50\n",
+    "batch_size = 8"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e1a3648b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataset = load_dataset(\n",
+    "    \"parquet\",\n",
+    "    data_files={\n",
+    "        \"train\": f\"hf://datasets/ought/raft@refs/convert/parquet/{dataset_name}/train/0000.parquet\",\n",
+    "        \"test\": f\"hf://datasets/ought/raft@refs/convert/parquet/{dataset_name}/test/0000.parquet\"\n",
+    "    }\n",
+    ")\n",
+    "\n",
+    "classes = [k.replace(\"_\", \" \") for k in dataset[\"train\"].features[\"Label\"].names]\n",
+    "print(classes)\n",
+    "dataset = dataset.map(\n",
+    "    lambda x: {\"text_label\": [classes[label] for label in x[\"Label\"]]},\n",
+    "    batched=True,\n",
+    "    num_proc=1,\n",
+    ")\n",
+    "print(dataset)\n",
+    "dataset[\"train\"][0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fe12d4d3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# data preprocessing\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)\n",
+    "if tokenizer.pad_token_id is None:\n",
+    "    tokenizer.pad_token_id = tokenizer.eos_token_id\n",
+    "target_max_length = max([len(tokenizer(class_label)[\"input_ids\"]) for class_label in classes])\n",
+    "print(target_max_length)\n",
+    "\n",
+    "\n",
+    "def preprocess_function(examples):\n",
+    "    batch_size = len(examples[text_column])\n",
+    "    inputs = [f\"{text_column} : {x} Label : \" for x in examples[text_column]]\n",
+    "    targets = [str(x) for x in examples[label_column]]\n",
+    "    model_inputs = tokenizer(inputs)\n",
+    "    labels = tokenizer(targets, add_special_tokens=False)  # don't add bos token because we concatenate with inputs\n",
+    "    for i in range(batch_size):\n",
+    "        sample_input_ids = model_inputs[\"input_ids\"][i]\n",
+    "        label_input_ids = labels[\"input_ids\"][i] + [tokenizer.eos_token_id]\n",
+    "        # print(i, sample_input_ids, label_input_ids)\n",
+    "        model_inputs[\"input_ids\"][i] = sample_input_ids + label_input_ids\n",
+    "        labels[\"input_ids\"][i] = [-100] * len(sample_input_ids) + label_input_ids\n",
+    "        model_inputs[\"attention_mask\"][i] = [1] * len(model_inputs[\"input_ids\"][i])\n",
+    "    # print(model_inputs)\n",
+    "    for i in range(batch_size):\n",
+    "        sample_input_ids = model_inputs[\"input_ids\"][i]\n",
+    "        label_input_ids = labels[\"input_ids\"][i]\n",
+    "        model_inputs[\"input_ids\"][i] = [tokenizer.pad_token_id] * (\n",
+    "            max_length - len(sample_input_ids)\n",
+    "        ) + sample_input_ids\n",
+    "        model_inputs[\"attention_mask\"][i] = [0] * (max_length - len(sample_input_ids)) + model_inputs[\n",
+    "            \"attention_mask\"\n",
+    "        ][i]\n",
+    "        labels[\"input_ids\"][i] = [-100] * (max_length - len(sample_input_ids)) + label_input_ids\n",
+    "        model_inputs[\"input_ids\"][i] = torch.tensor(model_inputs[\"input_ids\"][i][:max_length])\n",
+    "        model_inputs[\"attention_mask\"][i] = torch.tensor(model_inputs[\"attention_mask\"][i][:max_length])\n",
+    "        labels[\"input_ids\"][i] = torch.tensor(labels[\"input_ids\"][i][:max_length])\n",
+    "    model_inputs[\"labels\"] = labels[\"input_ids\"]\n",
+    "    return model_inputs\n",
+    "\n",
+    "\n",
+    "processed_datasets = dataset.map(\n",
+    "    preprocess_function,\n",
+    "    batched=True,\n",
+    "    num_proc=1,\n",
+    "    remove_columns=dataset[\"train\"].column_names,\n",
+    "    load_from_cache_file=False,\n",
+    "    desc=\"Running tokenizer on dataset\",\n",
+    ")\n",
+    "\n",
+    "train_dataset = processed_datasets[\"train\"]\n",
+    "eval_dataset = processed_datasets[\"train\"]\n",
+    "\n",
+    "\n",
+    "train_dataloader = DataLoader(\n",
+    "    train_dataset, shuffle=True, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True\n",
+    ")\n",
+    "eval_dataloader = DataLoader(eval_dataset, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "641b21fe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def test_preprocess_function(examples):\n",
+    "    batch_size = len(examples[text_column])\n",
+    "    inputs = [f\"{text_column} : {x} Label : \" for x in examples[text_column]]\n",
+    "    model_inputs = tokenizer(inputs)\n",
+    "    # print(model_inputs)\n",
+    "    for i in range(batch_size):\n",
+    "        sample_input_ids = model_inputs[\"input_ids\"][i]\n",
+    "        model_inputs[\"input_ids\"][i] = [tokenizer.pad_token_id] * (\n",
+    "            max_length - len(sample_input_ids)\n",
+    "        ) + sample_input_ids\n",
+    "        model_inputs[\"attention_mask\"][i] = [0] * (max_length - len(sample_input_ids)) + model_inputs[\n",
+    "            \"attention_mask\"\n",
+    "        ][i]\n",
+    "        model_inputs[\"input_ids\"][i] = torch.tensor(model_inputs[\"input_ids\"][i][:max_length])\n",
+    "        model_inputs[\"attention_mask\"][i] = torch.tensor(model_inputs[\"attention_mask\"][i][:max_length])\n",
+    "    return model_inputs\n",
+    "\n",
+    "\n",
+    "test_dataset = dataset[\"test\"].map(\n",
+    "    test_preprocess_function,\n",
+    "    batched=True,\n",
+    "    num_proc=1,\n",
+    "    remove_columns=dataset[\"train\"].column_names,\n",
+    "    load_from_cache_file=False,\n",
+    "    desc=\"Running tokenizer on dataset\",\n",
+    ")\n",
+    "\n",
+    "test_dataloader = DataLoader(test_dataset, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True)\n",
+    "next(iter(test_dataloader))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "accc5012",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "next(iter(train_dataloader))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "218df807",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "len(test_dataloader)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "47d1fedf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "next(iter(test_dataloader))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a773e092",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# creating model\n",
+    "model = AutoModelForCausalLM.from_pretrained(model_name_or_path)\n",
+    "model = get_peft_model(model, peft_config)\n",
+    "model.print_trainable_parameters()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "b2f91568",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# model\n",
+    "# optimizer and lr scheduler\n",
+    "optimizer = torch.optim.AdamW(model.parameters(), lr=lr)\n",
+    "lr_scheduler = get_linear_schedule_with_warmup(\n",
+    "    optimizer=optimizer,\n",
+    "    num_warmup_steps=0,\n",
+    "    num_training_steps=(len(train_dataloader) * num_epochs),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "e4fb69fc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:01<00:00,  5.68it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.48it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=0: train_ppl=tensor(2.2720e+13, device='cuda:0') train_epoch_loss=tensor(30.7543, device='cuda:0') eval_ppl=tensor(483597.5625, device='cuda:0') eval_epoch_loss=tensor(13.0890, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.91it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 20.96it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=1: train_ppl=tensor(452658.3750, device='cuda:0') train_epoch_loss=tensor(13.0229, device='cuda:0') eval_ppl=tensor(275088.1875, device='cuda:0') eval_epoch_loss=tensor(12.5248, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.90it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.41it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=2: train_ppl=tensor(199203.3906, device='cuda:0') train_epoch_loss=tensor(12.2021, device='cuda:0') eval_ppl=tensor(143637.0312, device='cuda:0') eval_epoch_loss=tensor(11.8750, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.92it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.31it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=3: train_ppl=tensor(114743.9531, device='cuda:0') train_epoch_loss=tensor(11.6505, device='cuda:0') eval_ppl=tensor(54962., device='cuda:0') eval_epoch_loss=tensor(10.9144, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.81it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.34it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=4: train_ppl=tensor(40786.5977, device='cuda:0') train_epoch_loss=tensor(10.6161, device='cuda:0') eval_ppl=tensor(18342.5430, device='cuda:0') eval_epoch_loss=tensor(9.8170, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.89it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.34it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=5: train_ppl=tensor(14023.0830, device='cuda:0') train_epoch_loss=tensor(9.5485, device='cuda:0') eval_ppl=tensor(6316.8540, device='cuda:0') eval_epoch_loss=tensor(8.7510, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.84it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.32it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=6: train_ppl=tensor(5635.3262, device='cuda:0') train_epoch_loss=tensor(8.6368, device='cuda:0') eval_ppl=tensor(2476.5776, device='cuda:0') eval_epoch_loss=tensor(7.8146, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.88it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.30it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=7: train_ppl=tensor(1818.4940, device='cuda:0') train_epoch_loss=tensor(7.5058, device='cuda:0') eval_ppl=tensor(934.1146, device='cuda:0') eval_epoch_loss=tensor(6.8396, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.05it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 18.97it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=8: train_ppl=tensor(645.2143, device='cuda:0') train_epoch_loss=tensor(6.4696, device='cuda:0') eval_ppl=tensor(361.9093, device='cuda:0') eval_epoch_loss=tensor(5.8914, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00,  9.67it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 19.12it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=9: train_ppl=tensor(293.8047, device='cuda:0') train_epoch_loss=tensor(5.6829, device='cuda:0') eval_ppl=tensor(215.8185, device='cuda:0') eval_epoch_loss=tensor(5.3744, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.54it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 20.83it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=10: train_ppl=tensor(191.2377, device='cuda:0') train_epoch_loss=tensor(5.2535, device='cuda:0') eval_ppl=tensor(177.1512, device='cuda:0') eval_epoch_loss=tensor(5.1770, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.02it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 18.98it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=11: train_ppl=tensor(153.6052, device='cuda:0') train_epoch_loss=tensor(5.0344, device='cuda:0') eval_ppl=tensor(126.6154, device='cuda:0') eval_epoch_loss=tensor(4.8412, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00,  9.54it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 18.78it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=12: train_ppl=tensor(122.8925, device='cuda:0') train_epoch_loss=tensor(4.8113, device='cuda:0') eval_ppl=tensor(97.3331, device='cuda:0') eval_epoch_loss=tensor(4.5781, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00,  9.66it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 19.72it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=13: train_ppl=tensor(84.8845, device='cuda:0') train_epoch_loss=tensor(4.4413, device='cuda:0') eval_ppl=tensor(70.3213, device='cuda:0') eval_epoch_loss=tensor(4.2531, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:01<00:00,  6.73it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 16.07it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=14: train_ppl=tensor(64.6705, device='cuda:0') train_epoch_loss=tensor(4.1693, device='cuda:0') eval_ppl=tensor(50.4688, device='cuda:0') eval_epoch_loss=tensor(3.9214, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00,  8.41it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 15.63it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=15: train_ppl=tensor(44.2937, device='cuda:0') train_epoch_loss=tensor(3.7908, device='cuda:0') eval_ppl=tensor(34.8210, device='cuda:0') eval_epoch_loss=tensor(3.5502, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00,  8.31it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 15.67it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=16: train_ppl=tensor(30.0995, device='cuda:0') train_epoch_loss=tensor(3.4045, device='cuda:0') eval_ppl=tensor(24.7703, device='cuda:0') eval_epoch_loss=tensor(3.2096, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00,  8.31it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 15.59it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=17: train_ppl=tensor(23.3086, device='cuda:0') train_epoch_loss=tensor(3.1488, device='cuda:0') eval_ppl=tensor(20.8131, device='cuda:0') eval_epoch_loss=tensor(3.0356, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00,  8.29it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 16.04it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=18: train_ppl=tensor(16.4479, device='cuda:0') train_epoch_loss=tensor(2.8002, device='cuda:0') eval_ppl=tensor(12.0876, device='cuda:0') eval_epoch_loss=tensor(2.4922, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00,  8.37it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 15.37it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=19: train_ppl=tensor(11.1977, device='cuda:0') train_epoch_loss=tensor(2.4157, device='cuda:0') eval_ppl=tensor(9.0399, device='cuda:0') eval_epoch_loss=tensor(2.2016, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00,  8.23it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 17.29it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=20: train_ppl=tensor(8.1847, device='cuda:0') train_epoch_loss=tensor(2.1023, device='cuda:0') eval_ppl=tensor(6.7486, device='cuda:0') eval_epoch_loss=tensor(1.9093, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00,  8.30it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 15.58it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=21: train_ppl=tensor(6.1145, device='cuda:0') train_epoch_loss=tensor(1.8107, device='cuda:0') eval_ppl=tensor(5.5931, device='cuda:0') eval_epoch_loss=tensor(1.7215, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00,  8.34it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.36it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=22: train_ppl=tensor(5.2963, device='cuda:0') train_epoch_loss=tensor(1.6670, device='cuda:0') eval_ppl=tensor(5.0573, device='cuda:0') eval_epoch_loss=tensor(1.6208, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.84it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.26it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=23: train_ppl=tensor(4.7485, device='cuda:0') train_epoch_loss=tensor(1.5578, device='cuda:0') eval_ppl=tensor(3.6277, device='cuda:0') eval_epoch_loss=tensor(1.2886, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.84it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.31it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=24: train_ppl=tensor(3.4080, device='cuda:0') train_epoch_loss=tensor(1.2261, device='cuda:0') eval_ppl=tensor(3.0467, device='cuda:0') eval_epoch_loss=tensor(1.1141, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.88it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.25it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=25: train_ppl=tensor(3.3052, device='cuda:0') train_epoch_loss=tensor(1.1955, device='cuda:0') eval_ppl=tensor(2.7784, device='cuda:0') eval_epoch_loss=tensor(1.0219, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.86it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.22it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=26: train_ppl=tensor(2.9487, device='cuda:0') train_epoch_loss=tensor(1.0814, device='cuda:0') eval_ppl=tensor(2.9471, device='cuda:0') eval_epoch_loss=tensor(1.0808, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.85it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.25it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=27: train_ppl=tensor(2.8738, device='cuda:0') train_epoch_loss=tensor(1.0556, device='cuda:0') eval_ppl=tensor(2.5801, device='cuda:0') eval_epoch_loss=tensor(0.9478, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.84it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.28it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=28: train_ppl=tensor(2.3241, device='cuda:0') train_epoch_loss=tensor(0.8433, device='cuda:0') eval_ppl=tensor(2.2198, device='cuda:0') eval_epoch_loss=tensor(0.7974, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.84it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 20.89it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=29: train_ppl=tensor(2.0376, device='cuda:0') train_epoch_loss=tensor(0.7118, device='cuda:0') eval_ppl=tensor(1.8572, device='cuda:0') eval_epoch_loss=tensor(0.6191, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00,  9.76it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 18.83it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=30: train_ppl=tensor(1.8301, device='cuda:0') train_epoch_loss=tensor(0.6044, device='cuda:0') eval_ppl=tensor(1.8864, device='cuda:0') eval_epoch_loss=tensor(0.6347, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00,  9.80it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 19.81it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=31: train_ppl=tensor(1.7301, device='cuda:0') train_epoch_loss=tensor(0.5482, device='cuda:0') eval_ppl=tensor(1.6340, device='cuda:0') eval_epoch_loss=tensor(0.4910, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.60it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 19.11it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=32: train_ppl=tensor(1.5842, device='cuda:0') train_epoch_loss=tensor(0.4601, device='cuda:0') eval_ppl=tensor(1.6179, device='cuda:0') eval_epoch_loss=tensor(0.4811, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.11it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 18.35it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=33: train_ppl=tensor(1.5193, device='cuda:0') train_epoch_loss=tensor(0.4183, device='cuda:0') eval_ppl=tensor(1.5543, device='cuda:0') eval_epoch_loss=tensor(0.4410, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00,  9.59it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 18.60it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=34: train_ppl=tensor(1.5402, device='cuda:0') train_epoch_loss=tensor(0.4319, device='cuda:0') eval_ppl=tensor(1.4924, device='cuda:0') eval_epoch_loss=tensor(0.4004, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00,  9.80it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 19.63it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=35: train_ppl=tensor(1.4410, device='cuda:0') train_epoch_loss=tensor(0.3654, device='cuda:0') eval_ppl=tensor(1.3888, device='cuda:0') eval_epoch_loss=tensor(0.3284, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:01<00:00,  6.60it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 15.36it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=36: train_ppl=tensor(1.3675, device='cuda:0') train_epoch_loss=tensor(0.3130, device='cuda:0') eval_ppl=tensor(1.4001, device='cuda:0') eval_epoch_loss=tensor(0.3366, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00,  8.40it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 15.58it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=37: train_ppl=tensor(1.4197, device='cuda:0') train_epoch_loss=tensor(0.3505, device='cuda:0') eval_ppl=tensor(1.3214, device='cuda:0') eval_epoch_loss=tensor(0.2787, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00,  8.27it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 15.56it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=38: train_ppl=tensor(1.3855, device='cuda:0') train_epoch_loss=tensor(0.3261, device='cuda:0') eval_ppl=tensor(1.3501, device='cuda:0') eval_epoch_loss=tensor(0.3001, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00,  8.25it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 15.57it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=39: train_ppl=tensor(1.3643, device='cuda:0') train_epoch_loss=tensor(0.3107, device='cuda:0') eval_ppl=tensor(1.3549, device='cuda:0') eval_epoch_loss=tensor(0.3037, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00,  8.28it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 15.41it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=40: train_ppl=tensor(1.3093, device='cuda:0') train_epoch_loss=tensor(0.2695, device='cuda:0') eval_ppl=tensor(1.3233, device='cuda:0') eval_epoch_loss=tensor(0.2801, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00,  8.24it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 15.51it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=41: train_ppl=tensor(1.3108, device='cuda:0') train_epoch_loss=tensor(0.2706, device='cuda:0') eval_ppl=tensor(1.3440, device='cuda:0') eval_epoch_loss=tensor(0.2957, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00,  8.78it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 15.61it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=42: train_ppl=tensor(1.2944, device='cuda:0') train_epoch_loss=tensor(0.2581, device='cuda:0') eval_ppl=tensor(1.2711, device='cuda:0') eval_epoch_loss=tensor(0.2399, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00,  8.29it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 15.56it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=43: train_ppl=tensor(1.2616, device='cuda:0') train_epoch_loss=tensor(0.2323, device='cuda:0') eval_ppl=tensor(1.2449, device='cuda:0') eval_epoch_loss=tensor(0.2190, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.85it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.27it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=44: train_ppl=tensor(1.2478, device='cuda:0') train_epoch_loss=tensor(0.2214, device='cuda:0') eval_ppl=tensor(1.2202, device='cuda:0') eval_epoch_loss=tensor(0.1990, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.85it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.31it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=45: train_ppl=tensor(1.2350, device='cuda:0') train_epoch_loss=tensor(0.2111, device='cuda:0') eval_ppl=tensor(1.2180, device='cuda:0') eval_epoch_loss=tensor(0.1972, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.86it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.33it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=46: train_ppl=tensor(1.2277, device='cuda:0') train_epoch_loss=tensor(0.2052, device='cuda:0') eval_ppl=tensor(1.2077, device='cuda:0') eval_epoch_loss=tensor(0.1887, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.87it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.35it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=47: train_ppl=tensor(1.2037, device='cuda:0') train_epoch_loss=tensor(0.1854, device='cuda:0') eval_ppl=tensor(1.2041, device='cuda:0') eval_epoch_loss=tensor(0.1857, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.83it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.29it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=48: train_ppl=tensor(1.2026, device='cuda:0') train_epoch_loss=tensor(0.1845, device='cuda:0') eval_ppl=tensor(1.1982, device='cuda:0') eval_epoch_loss=tensor(0.1808, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 10.86it/s]\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 21.35it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=49: train_ppl=tensor(1.2005, device='cuda:0') train_epoch_loss=tensor(0.1827, device='cuda:0') eval_ppl=tensor(1.1968, device='cuda:0') eval_epoch_loss=tensor(0.1796, device='cuda:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# training and evaluation\n",
+    "model = model.to(device)\n",
+    "\n",
+    "for epoch in range(num_epochs):\n",
+    "    model.train()\n",
+    "    total_loss = 0\n",
+    "    for step, batch in enumerate(tqdm(train_dataloader)):\n",
+    "        batch = {k: v.to(device) for k, v in batch.items()}\n",
+    "        #         print(batch)\n",
+    "        #         print(batch[\"input_ids\"].shape)\n",
+    "        outputs = model(**batch)\n",
+    "        loss = outputs.loss\n",
+    "        total_loss += loss.detach().float()\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        lr_scheduler.step()\n",
+    "        optimizer.zero_grad()\n",
+    "\n",
+    "    model.eval()\n",
+    "    eval_loss = 0\n",
+    "    eval_preds = []\n",
+    "    for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+    "        batch = {k: v.to(device) for k, v in batch.items()}\n",
+    "        with torch.no_grad():\n",
+    "            outputs = model(**batch)\n",
+    "        loss = outputs.loss\n",
+    "        eval_loss += loss.detach().float()\n",
+    "        eval_preds.extend(\n",
+    "            tokenizer.batch_decode(torch.argmax(outputs.logits, -1).detach().cpu().numpy(), skip_special_tokens=True)\n",
+    "        )\n",
+    "\n",
+    "    eval_epoch_loss = eval_loss / len(eval_dataloader)\n",
+    "    eval_ppl = torch.exp(eval_epoch_loss)\n",
+    "    train_epoch_loss = total_loss / len(train_dataloader)\n",
+    "    train_ppl = torch.exp(train_epoch_loss)\n",
+    "    print(f\"{epoch=}: {train_ppl=} {train_epoch_loss=} {eval_ppl=} {eval_epoch_loss=}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "53752a7b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "@TommyHilfiger Dramatic shopping exp. ordered 6 jeans same size (30/32) 2 fits / 2 too large / 2 too slim : same brand &gt; different sizing\n",
+      "{'input_ids': tensor([[227985,   5484,    915,   2566, 226154, 126015,   5385,    259, 239364,\n",
+      "           3396,  70823,   5853,     17,  57247,   1231, 191040,   5025,   7869,\n",
+      "            375,   2324, 149349,     12,    415, 122321,    897,    415,  10136,\n",
+      "          10021,    897,    415,  10136,   6497,    381,    915,   5025,  51950,\n",
+      "          66869,   5955,    272,  20311,  77658,    915,    210]]), 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
+      "         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])}\n",
+      "tensor([[227985,   5484,    915,   2566, 226154, 126015,   5385,    259, 239364,\n",
+      "           3396,  70823,   5853,     17,  57247,   1231, 191040,   5025,   7869,\n",
+      "            375,   2324, 149349,     12,    415, 122321,    897,    415,  10136,\n",
+      "          10021,    897,    415,  10136,   6497,    381,    915,   5025,  51950,\n",
+      "          66869,   5955,    272,  20311,  77658,    915,    210,  16449,   5952,\n",
+      "              3]], device='cuda:0')\n",
+      "['Tweet text : @TommyHilfiger Dramatic shopping exp. ordered 6 jeans same size (30/32) 2 fits / 2 too large / 2 too slim : same brand &gt; different sizing Label : complaint']\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.eval()\n",
+    "i = 33\n",
+    "inputs = tokenizer(f'{text_column} : {dataset[\"test\"][i][\"Tweet text\"]} Label : ', return_tensors=\"pt\")\n",
+    "print(dataset[\"test\"][i][\"Tweet text\"])\n",
+    "print(inputs)\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    inputs = {k: v.to(device) for k, v in inputs.items()}\n",
+    "    outputs = model.generate(\n",
+    "        input_ids=inputs[\"input_ids\"], attention_mask=inputs[\"attention_mask\"], max_new_tokens=10, eos_token_id=3\n",
+    "    )\n",
+    "    print(outputs)\n",
+    "    print(tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c8f35152",
+   "metadata": {},
+   "source": [
+    "You can push model to hub or save model locally. \n",
+    "\n",
+    "- Option1: Pushing the model to Hugging Face Hub\n",
+    "```python\n",
+    "model.push_to_hub(\n",
+    "    f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\".replace(\"/\", \"_\"),\n",
+    "    token = \"hf_...\"\n",
+    ")\n",
+    "```\n",
+    "token (`bool` or `str`, *optional*):\n",
+    "    `token` is to be used for HTTP Bearer authorization when accessing remote files. If `True`, will use the token generated\n",
+    "    when running `huggingface-cli login` (stored in `~/.huggingface`). Will default to `True` if `repo_url`\n",
+    "    is not specified.\n",
+    "    Or you can get your token from https://huggingface.co/settings/token\n",
+    "```\n",
+    "- Or save model locally\n",
+    "```python\n",
+    "peft_model_id = f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\".replace(\"/\", \"_\")\n",
+    "model.save_pretrained(peft_model_id)\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "d8ba1f8c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# saving model\n",
+    "peft_model_id = f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\".replace(\n",
+    "    \"/\", \"_\"\n",
+    ")\n",
+    "model.save_pretrained(peft_model_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4928c7f1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ckpt = f\"{peft_model_id}/adapter_model.safetensors\"\n",
+    "!du -h $ckpt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "4d9476e1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from peft import PeftModel, PeftConfig\n",
+    "\n",
+    "peft_model_id = f\"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\".replace(\n",
+    "    \"/\", \"_\"\n",
+    ")\n",
+    "\n",
+    "config = PeftConfig.from_pretrained(peft_model_id)\n",
+    "model = AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path)\n",
+    "model = PeftModel.from_pretrained(model, peft_model_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "ebe174a6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "@greateranglia Ok thanks...\n",
+      "{'input_ids': tensor([[227985,   5484,    915,   2566,  14173,   2960,  29906,    387,  20706,\n",
+      "          49337,   1369,  77658,    915,    210]]), 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])}\n",
+      "tensor([[227985,   5484,    915,   2566,  14173,   2960,  29906,    387,  20706,\n",
+      "          49337,   1369,  77658,    915,    210,   1936, 106863,      3]],\n",
+      "       device='cuda:0')\n",
+      "['Tweet text : @greateranglia Ok thanks... Label : no complaint']\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.to(device)\n",
+    "model.eval()\n",
+    "i = 4\n",
+    "inputs = tokenizer(f'{text_column} : {dataset[\"test\"][i][\"Tweet text\"]} Label : ', return_tensors=\"pt\")\n",
+    "print(dataset[\"test\"][i][\"Tweet text\"])\n",
+    "print(inputs)\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    inputs = {k: v.to(device) for k, v in inputs.items()}\n",
+    "    outputs = model.generate(\n",
+    "        input_ids=inputs[\"input_ids\"], attention_mask=inputs[\"attention_mask\"], max_new_tokens=10, eos_token_id=3\n",
+    "    )\n",
+    "    print(outputs)\n",
+    "    print(tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "24041ee1",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.5"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/causal_language_modeling/requirements.txt b/examples/causal_language_modeling/requirements.txt
new file mode 100644
index 0000000..0e462c3
--- /dev/null
+++ b/examples/causal_language_modeling/requirements.txt
@@ -0,0 +1,7 @@
+transformers<4.54.0
+accelerate
+evaluate
+deepspeed
+tqdm
+dataclass-csv
+datasets==3.6.0
\ No newline at end of file
diff --git a/examples/conditional_generation/accelerate_ds_zero3_cpu_offload_config.yaml b/examples/conditional_generation/accelerate_ds_zero3_cpu_offload_config.yaml
new file mode 100644
index 0000000..a4a0bcf
--- /dev/null
+++ b/examples/conditional_generation/accelerate_ds_zero3_cpu_offload_config.yaml
@@ -0,0 +1,22 @@
+compute_environment: LOCAL_MACHINE
+deepspeed_config:
+  gradient_accumulation_steps: 1
+  gradient_clipping: 1.0
+  offload_optimizer_device: none
+  offload_param_device: none
+  zero3_init_flag: true
+  zero3_save_16bit_model: true
+  zero_stage: 3
+distributed_type: DEEPSPEED
+downcast_bf16: 'no'
+dynamo_backend: 'NO'
+fsdp_config: {}
+machine_rank: 0
+main_training_function: main
+megatron_lm_config: {}
+mixed_precision: 'no'
+num_machines: 1
+num_processes: 1
+rdzv_backend: static
+same_network: true
+use_cpu: false
\ No newline at end of file
diff --git a/examples/conditional_generation/multitask_prompt_tuning.ipynb b/examples/conditional_generation/multitask_prompt_tuning.ipynb
new file mode 100644
index 0000000..1eaec5b
--- /dev/null
+++ b/examples/conditional_generation/multitask_prompt_tuning.ipynb
@@ -0,0 +1,426 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "58ff91ca-ce92-43d0-ae8b-4e9e89e193f6",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from datasets import load_dataset\n",
+    "from transformers import set_seed, AutoModelForSeq2SeqLM, AutoTokenizer\n",
+    "from peft import get_peft_model, MultitaskPromptTuningConfig, TaskType, MultitaskPromptTuningInit\n",
+    "\n",
+    "set_seed(42)\n",
+    "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "model_name = \"google/flan-t5-base\"\n",
+    "\n",
+    "peft_config = MultitaskPromptTuningConfig(\n",
+    "    tokenizer_name_or_path=model_name,\n",
+    "    num_tasks=2,\n",
+    "    task_type=TaskType.SEQ_2_SEQ_LM,\n",
+    "    prompt_tuning_init=MultitaskPromptTuningInit.TEXT,\n",
+    "    num_virtual_tokens=50,\n",
+    "    num_transformer_submodules=1,\n",
+    "    prompt_tuning_init_text=\"classify the following into either positive or negative, or entailment, neutral or contradiction:\",\n",
+    ")\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
+    "model = AutoModelForSeq2SeqLM.from_pretrained(model_name)\n",
+    "model = get_peft_model(model, peft_config)\n",
+    "\n",
+    "model = model.to(device)\n",
+    "\n",
+    "\n",
+    "def send_to_device(batch):\n",
+    "    for i in batch:\n",
+    "        batch[i] = batch[i].to(device)\n",
+    "    return batch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "eb112bc1-ffaf-49fa-a216-0d601ec304ee",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "def get_sst2(split: str):\n",
+    "    examples = load_dataset(\"sst2\")[split]\n",
+    "    result_examples = []\n",
+    "    for example in examples:\n",
+    "        result_examples.append({})\n",
+    "\n",
+    "        result_examples[-1][\"input\"] = example[\"sentence\"].strip() + \"</s>\"\n",
+    "        result_examples[-1][\"output\"] = (\n",
+    "            f\"positive{tokenizer.eos_token}\" if example[\"label\"] == 1 else f\"negative{tokenizer.eos_token}\"\n",
+    "        )\n",
+    "        result_examples[-1][\"task_id\"] = 0\n",
+    "\n",
+    "    return result_examples\n",
+    "\n",
+    "\n",
+    "def get_mnli(split: str):\n",
+    "    examples = load_dataset(\"multi_nli\")[split]\n",
+    "    result_examples = []\n",
+    "    for example in examples:\n",
+    "        result_examples.append({})\n",
+    "\n",
+    "        result_examples[-1][\"input\"] = example[\"premise\"].strip() + \" \" + example[\"hypothesis\"].strip() + \"</s>\"\n",
+    "\n",
+    "        if example[\"label\"] == 0:\n",
+    "            result_examples[-1][\"output\"] = f\"entailment{tokenizer.eos_token}\"\n",
+    "        elif example[\"label\"] == 1:\n",
+    "            result_examples[-1][\"output\"] = f\"neutral{tokenizer.eos_token}\"\n",
+    "        else:\n",
+    "            result_examples[-1][\"output\"] = f\"contradiction{tokenizer.eos_token}\"\n",
+    "\n",
+    "        result_examples[-1][\"task_id\"] = 1\n",
+    "\n",
+    "    return result_examples"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "e5a16ec4-8fef-4ba9-95b6-a661eb51e50c",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from typing import Tuple\n",
+    "from torch.utils.data import Dataset, DataLoader\n",
+    "import torch\n",
+    "\n",
+    "\n",
+    "class MyDataset(Dataset):\n",
+    "    def __init__(self, split: str, mode: str = \"source\") -> None:\n",
+    "        super().__init__()\n",
+    "\n",
+    "        if split == \"train\":\n",
+    "            if mode == \"source\":\n",
+    "                self.examples = get_sst2(split) + get_mnli(split)\n",
+    "            elif mode == \"target\":\n",
+    "                self.examples = get_sst2(split)\n",
+    "        if split == \"val\":\n",
+    "            self.examples = get_sst2(\"validation\")\n",
+    "        if split == \"test\":\n",
+    "            self.examples = get_sst2(\"validation\")\n",
+    "\n",
+    "    def __getitem__(self, index) -> dict:\n",
+    "        return self.examples[index]\n",
+    "\n",
+    "    def __len__(self) -> int:\n",
+    "        return len(self.examples)\n",
+    "\n",
+    "    def __getitem__(self, index) -> dict:\n",
+    "        return self.examples[index]\n",
+    "\n",
+    "    def __len__(self) -> int:\n",
+    "        return len(self.examples)\n",
+    "\n",
+    "\n",
+    "def collate_fn(batch: dict) -> Tuple[torch.Tensor, torch.Tensor]:\n",
+    "    input = [i[\"input\"] for i in batch]\n",
+    "    input = tokenizer(input, add_special_tokens=False, return_tensors=\"pt\", padding=True)\n",
+    "\n",
+    "    output = [i[\"output\"] for i in batch]\n",
+    "    output = tokenizer(output, add_special_tokens=False, return_tensors=\"pt\", padding=True).input_ids\n",
+    "    output[output == tokenizer.pad_token_id] = -100\n",
+    "\n",
+    "    task_ids = [i[\"task_id\"] for i in batch]\n",
+    "    task_ids = torch.tensor(task_ids)\n",
+    "\n",
+    "    return {\n",
+    "        \"input_ids\": input.input_ids,\n",
+    "        \"attention_mask\": input.attention_mask,\n",
+    "        \"labels\": output,\n",
+    "        \"task_ids\": task_ids,\n",
+    "    }\n",
+    "\n",
+    "\n",
+    "train = DataLoader(MyDataset(\"train\"), shuffle=True, batch_size=8, collate_fn=collate_fn)\n",
+    "val = DataLoader(MyDataset(\"val\"), shuffle=False, batch_size=8, collate_fn=collate_fn)\n",
+    "test = DataLoader(MyDataset(\"test\"), shuffle=False, batch_size=8, collate_fn=collate_fn)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fe0aec7b-f61e-4b00-a90e-c1201dc1f84c",
+   "metadata": {},
+   "source": [
+    "## source training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "cceecc94-f43a-4f62-8d45-926f2f02f36d",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from torch.optim.adamw import AdamW\n",
+    "from transformers import get_cosine_schedule_with_warmup\n",
+    "from tqdm import tqdm\n",
+    "from sklearn.metrics import f1_score"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eae5516b-73ab-44a8-a083-4e8de6127f30",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "POSITIVE_TOKEN_ID = tokenizer(\" positive\", add_special_tokens=False)[\"input_ids\"][0]\n",
+    "NEGATIVE_TOKEN_ID = tokenizer(\" negative\", add_special_tokens=False)[\"input_ids\"][0]\n",
+    "\n",
+    "\n",
+    "def classify(batch):\n",
+    "    batch = send_to_device(batch)\n",
+    "    # we pass labels here since we need to generate and peft doesn't support generation yet.\n",
+    "    # No clue how to get around this\n",
+    "    scores = model(**batch).logits\n",
+    "    preds = []\n",
+    "    for i in range(scores.shape[0]):\n",
+    "        if scores[i, 0, POSITIVE_TOKEN_ID] > scores[i, 0, NEGATIVE_TOKEN_ID]:\n",
+    "            preds.append(POSITIVE_TOKEN_ID)\n",
+    "        else:\n",
+    "            preds.append(NEGATIVE_TOKEN_ID)\n",
+    "    return preds\n",
+    "\n",
+    "\n",
+    "@torch.inference_mode()\n",
+    "def evaluate(model, data):\n",
+    "    loss = 0\n",
+    "    preds = []\n",
+    "    golds = []\n",
+    "\n",
+    "    for batch in tqdm(data):\n",
+    "        batch = send_to_device(batch)\n",
+    "        loss += model(**batch).loss\n",
+    "        golds.extend(batch[\"labels\"][:, 0].tolist())\n",
+    "        preds.extend(classify(batch))\n",
+    "\n",
+    "    return loss / len(val), f1_score(golds, preds, pos_label=POSITIVE_TOKEN_ID)\n",
+    "\n",
+    "\n",
+    "optimizer = AdamW(model.parameters(), lr=1e-4)\n",
+    "scheduler = get_cosine_schedule_with_warmup(optimizer, 200, len(train))\n",
+    "\n",
+    "n = 1000\n",
+    "step = 0\n",
+    "train_ = tqdm(train)\n",
+    "\n",
+    "val_loss, f1 = evaluate(model, val)\n",
+    "print(\n",
+    "    f\"\"\"\n",
+    "before source training\n",
+    "val loss = {val_loss}\n",
+    "f1 = {f1}\"\"\"\n",
+    ")\n",
+    "\n",
+    "for batch in train_:\n",
+    "    if step % n == 0:\n",
+    "        val_loss, f1 = evaluate(model, val)\n",
+    "        print(\n",
+    "            f\"\"\"\n",
+    "step = {step}\n",
+    "val loss = {val_loss}\n",
+    "f1 = {f1}\"\"\"\n",
+    "        )\n",
+    "        model.save_pretrained(f\"checkpoints_source/{step}\")\n",
+    "\n",
+    "    step += 1\n",
+    "    batch = send_to_device(batch)\n",
+    "    loss = model(**batch).loss\n",
+    "    loss.backward()\n",
+    "    optimizer.step()\n",
+    "    scheduler.step()\n",
+    "    train_.set_postfix(train_loss=loss)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "74168ef3-66f3-41a7-a40b-7840b103fbf9",
+   "metadata": {},
+   "source": [
+    "## target training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b09fd456-163e-4dc1-b24d-f2d0d349036c",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "train = DataLoader(MyDataset(\"train\", \"target\"), shuffle=True, batch_size=8, collate_fn=collate_fn)\n",
+    "val = DataLoader(MyDataset(\"val\", \"target\"), shuffle=False, batch_size=8, collate_fn=collate_fn)\n",
+    "test = DataLoader(MyDataset(\"test\", \"target\"), shuffle=False, batch_size=8, collate_fn=collate_fn)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4a539944-f16c-4c3f-bb4a-7b5d9a6042e2",
+   "metadata": {},
+   "source": [
+    "#### create a fresh model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5520d904-aa6c-4654-9335-ed4e7d76cba2",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "peft_config = MultitaskPromptTuningConfig(\n",
+    "    tokenizer_name_or_path=model_name,\n",
+    "    num_tasks=1,\n",
+    "    task_type=TaskType.SEQ_2_SEQ_LM,\n",
+    "    prompt_tuning_init=MultitaskPromptTuningInit.EXACT_SOURCE_TASK,\n",
+    "    prompt_tuning_init_state_dict_path=\"checkpoints_source/50000/adapter_model.safetensors\",\n",
+    "    num_virtual_tokens=50,\n",
+    "    num_transformer_submodules=1,\n",
+    ")\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
+    "model = AutoModelForSeq2SeqLM.from_pretrained(model_name)\n",
+    "model = get_peft_model(model, peft_config)\n",
+    "\n",
+    "model = model.to(device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dfa39c2d-d1c5-4ed4-90f8-26e8e324371c",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "optimizer = AdamW(model.parameters(), lr=1e-4)\n",
+    "scheduler = get_cosine_schedule_with_warmup(optimizer, 200, len(train))\n",
+    "\n",
+    "n = 1000\n",
+    "step = 0\n",
+    "train_ = tqdm(train)\n",
+    "\n",
+    "val_loss, f1 = evaluate(model, val)\n",
+    "print(\n",
+    "    f\"\"\"\n",
+    "before target training\n",
+    "val loss = {val_loss}\n",
+    "f1 = {f1}\"\"\"\n",
+    ")\n",
+    "\n",
+    "for batch in train_:\n",
+    "    if step % n == 0:\n",
+    "        val_loss, f1 = evaluate(model, val)\n",
+    "        print(\n",
+    "            f\"\"\"\n",
+    "step = {step}\n",
+    "val loss = {val_loss}\n",
+    "f1 = {f1}\"\"\"\n",
+    "        )\n",
+    "        model.save_pretrained(f\"checkpoints_target/{step}\")\n",
+    "\n",
+    "    step += 1\n",
+    "    batch = send_to_device(batch)\n",
+    "    loss = model(**batch).loss\n",
+    "    loss.backward()\n",
+    "    optimizer.step()\n",
+    "    scheduler.step()\n",
+    "    train_.set_postfix(train_loss=loss)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b6a6eeda-1e09-49a6-8845-cd96c8573145",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# load last checkpoint for now\n",
+    "from peft import set_peft_model_state_dict\n",
+    "from safetensors.torch import load_file\n",
+    "\n",
+    "sd_6000 = load_file(\"checkpoints_target/6000/adapter_model.safetensors\")\n",
+    "set_peft_model_state_dict(model, sd_6000)\n",
+    "\n",
+    "# evaluate val\n",
+    "val_loss, f1 = evaluate(model, val)\n",
+    "print(\n",
+    "    f\"\"\"\n",
+    "final\n",
+    "val loss = {val_loss}\n",
+    "f1 = {f1}\"\"\"\n",
+    ")\n",
+    "\n",
+    "# evaluate test\n",
+    "test_loss, f1 = evaluate(model, test)\n",
+    "print(\n",
+    "    f\"\"\"\n",
+    "final\n",
+    "test loss = {test_loss}\n",
+    "f1 = {f1}\"\"\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1d18325c-9607-4cb5-a5b0-5b44dfee2a75",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "43988e92-af42-45cb-8bca-f19c193ad04f",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/conditional_generation/peft_adalora_seq2seq.py b/examples/conditional_generation/peft_adalora_seq2seq.py
new file mode 100644
index 0000000..e1a0c8c
--- /dev/null
+++ b/examples/conditional_generation/peft_adalora_seq2seq.py
@@ -0,0 +1,185 @@
+import os
+
+import torch
+from datasets import load_dataset
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, default_data_collator, get_linear_schedule_with_warmup
+
+from peft import AdaLoraConfig, PeftConfig, PeftModel, TaskType, get_peft_model
+
+
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+model_name_or_path = "facebook/bart-base"
+tokenizer_name_or_path = "facebook/bart-base"
+
+text_column = "text"
+label_column = "text_label"
+max_length = 128
+lr = 1e-3
+num_epochs = 8
+batch_size = 8
+
+
+# loading dataset
+dataset = load_dataset("zeroshot/twitter-financial-news-sentiment")
+dataset = dataset["train"].train_test_split(test_size=0.1)
+dataset["validation"] = dataset["test"]
+del dataset["test"]
+
+if hasattr(dataset["train"].features["label"], "names"):
+    classes = dataset["train"].features["label"].names
+else:
+    classes = ["Bearish", "Bullish", "Neutral"]
+dataset = dataset.map(
+    lambda x: {"text_label": [classes[label] for label in x["label"]]},
+    batched=True,
+    num_proc=1,
+)
+
+
+# creating model
+peft_config = AdaLoraConfig(
+    init_r=12,
+    target_r=8,
+    beta1=0.85,
+    beta2=0.85,
+    tinit=200,
+    tfinal=1000,
+    deltaT=10,
+    lora_alpha=32,
+    lora_dropout=0.1,
+    task_type=TaskType.SEQ_2_SEQ_LM,
+    inference_mode=False,
+    total_step=len(dataset["train"]) * num_epochs,
+)
+
+model = AutoModelForSeq2SeqLM.from_pretrained(model_name_or_path)
+model = get_peft_model(model, peft_config)
+model.print_trainable_parameters()
+
+
+# data preprocessing
+tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)
+
+
+def preprocess_function(examples):
+    inputs = examples[text_column]
+    targets = examples[label_column]
+    model_inputs = tokenizer(inputs, max_length=max_length, padding="max_length", truncation=True, return_tensors="pt")
+    labels = tokenizer(targets, max_length=3, padding="max_length", truncation=True, return_tensors="pt")
+    labels = labels["input_ids"]
+    labels[labels == tokenizer.pad_token_id] = -100
+    model_inputs["labels"] = labels
+    return model_inputs
+
+
+processed_datasets = dataset.map(
+    preprocess_function,
+    batched=True,
+    num_proc=1,
+    remove_columns=dataset["train"].column_names,
+    load_from_cache_file=False,
+    desc="Running tokenizer on dataset",
+)
+
+train_dataset = processed_datasets["train"]
+eval_dataset = processed_datasets["validation"]
+
+train_dataloader = DataLoader(
+    train_dataset, shuffle=True, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True
+)
+eval_dataloader = DataLoader(eval_dataset, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True)
+
+
+# optimizer and lr scheduler
+optimizer = torch.optim.AdamW(model.parameters(), lr=lr)
+lr_scheduler = get_linear_schedule_with_warmup(
+    optimizer=optimizer,
+    num_warmup_steps=0,
+    num_training_steps=(len(train_dataloader) * num_epochs),
+)
+model.base_model.peft_config["default"].total_step = len(train_dataloader) * num_epochs
+
+
+# training and evaluation
+model = model.to(device)
+global_step = 0
+for epoch in range(num_epochs):
+    model.train()
+    total_loss = 0
+    for step, batch in enumerate(tqdm(train_dataloader)):
+        batch = {k: v.to(device) for k, v in batch.items()}
+        outputs = model(**batch)
+        loss = outputs.loss
+        total_loss += loss.detach().float()
+        loss.backward()
+        optimizer.step()
+        lr_scheduler.step()
+        # Update the importance of low-rank matrices
+        # and allocate the budget accordingly.
+        model.base_model.update_and_allocate(global_step)
+        optimizer.zero_grad()
+        global_step += 1
+
+    model.eval()
+    eval_loss = 0
+    eval_preds = []
+    for step, batch in enumerate(tqdm(eval_dataloader)):
+        batch = {k: v.to(device) for k, v in batch.items()}
+        with torch.no_grad():
+            outputs = model(**batch)
+        loss = outputs.loss
+        eval_loss += loss.detach().float()
+        eval_preds.extend(
+            tokenizer.batch_decode(torch.argmax(outputs.logits, -1).detach().cpu().numpy(), skip_special_tokens=True)
+        )
+
+    eval_epoch_loss = eval_loss / len(train_dataloader)
+    eval_ppl = torch.exp(eval_epoch_loss)
+    train_epoch_loss = total_loss / len(eval_dataloader)
+    train_ppl = torch.exp(train_epoch_loss)
+    print(f"{epoch=}: {train_ppl=} {train_epoch_loss=} {eval_ppl=} {eval_epoch_loss=}")
+
+
+# print accuracy
+correct = 0
+total = 0
+for pred, true in zip(eval_preds, dataset["validation"]["text_label"]):
+    if pred.strip() == true.strip():
+        correct += 1
+    total += 1
+accuracy = correct / total * 100
+print(f"{accuracy=} % on the evaluation dataset")
+print(f"{eval_preds[:10]=}")
+print(f"{dataset['validation']['text_label'][:10]=}")
+
+
+# saving model
+peft_model_id = f"{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}"
+model.save_pretrained(peft_model_id)
+
+
+ckpt = f"{peft_model_id}/adapter_model.safetensors"
+# get_ipython().system('du -h $ckpt')
+
+
+peft_model_id = f"{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}"
+
+config = PeftConfig.from_pretrained(peft_model_id)
+model = AutoModelForSeq2SeqLM.from_pretrained(config.base_model_name_or_path)
+model = PeftModel.from_pretrained(model, peft_model_id)
+
+
+model.eval()
+i = 13
+inputs = tokenizer(dataset["validation"][text_column][i], return_tensors="pt")
+print(dataset["validation"][text_column][i])
+print(inputs)
+
+with torch.no_grad():
+    outputs = model.generate(input_ids=inputs["input_ids"], max_new_tokens=10)
+    print(outputs)
+    print(tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True))
diff --git a/examples/conditional_generation/peft_ia3_seq2seq.ipynb b/examples/conditional_generation/peft_ia3_seq2seq.ipynb
new file mode 100755
index 0000000..c410c15
--- /dev/null
+++ b/examples/conditional_generation/peft_ia3_seq2seq.ipynb
@@ -0,0 +1,2747 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0c152fc8",
+   "metadata": {
+    "id": "5f93b7d1"
+   },
+   "outputs": [],
+   "source": "from transformers import AutoModelForSeq2SeqLM\nimport peft\nfrom peft import get_peft_config, get_peft_model, get_peft_model_state_dict, IA3Config, TaskType\nimport torch\nfrom datasets import load_dataset\nimport os\n\nos.environ[\"TOKENIZERS_PARALLELISM\"] = \"false\"\nfrom transformers import AutoTokenizer\nfrom torch.utils.data import DataLoader\nfrom transformers import default_data_collator, get_linear_schedule_with_warmup\nfrom tqdm import tqdm\nfrom datasets import load_dataset\n\ndevice = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\nmodel_name_or_path = \"bigscience/mt0-large\"\ntokenizer_name_or_path = \"bigscience/mt0-large\"\n\ntext_column = \"text\"\nlabel_column = \"text_label\"\nmax_length = 128\nlr = 8e-3\nnum_epochs = 3\nbatch_size = 8"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "4e23624f",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "b9e6368c",
+    "outputId": "fc2888a8-4fe9-4d61-dd2d-753e751e1416"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<module 'peft' from '/usr/local/lib/python3.11/dist-packages/peft/__init__.py'>"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import importlib\n",
+    "\n",
+    "importlib.reload(peft)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "da74b569",
+   "metadata": {
+    "id": "8d0850ac"
+   },
+   "outputs": [],
+   "source": [
+    "# creating model\n",
+    "peft_config = IA3Config(task_type=TaskType.SEQ_2_SEQ_LM, inference_mode=False, feedforward_modules=[])\n",
+    "\n",
+    "model = AutoModelForSeq2SeqLM.from_pretrained(model_name_or_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "df33fce2",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "e10c3831",
+    "outputId": "e69c5e07-ae58-446c-8301-e99ac6b85d62"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "MT5ForConditionalGeneration(\n",
+       "  (shared): Embedding(250112, 1024)\n",
+       "  (encoder): MT5Stack(\n",
+       "    (embed_tokens): Embedding(250112, 1024)\n",
+       "    (block): ModuleList(\n",
+       "      (0): MT5Block(\n",
+       "        (layer): ModuleList(\n",
+       "          (0): MT5LayerSelfAttention(\n",
+       "            (SelfAttention): MT5Attention(\n",
+       "              (q): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              (k): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              (v): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              (o): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              (relative_attention_bias): Embedding(32, 16)\n",
+       "            )\n",
+       "            (layer_norm): MT5LayerNorm()\n",
+       "            (dropout): Dropout(p=0.1, inplace=False)\n",
+       "          )\n",
+       "          (1): MT5LayerFF(\n",
+       "            (DenseReluDense): MT5DenseGatedActDense(\n",
+       "              (wi_0): Linear(in_features=1024, out_features=2816, bias=False)\n",
+       "              (wi_1): Linear(in_features=1024, out_features=2816, bias=False)\n",
+       "              (wo): Linear(in_features=2816, out_features=1024, bias=False)\n",
+       "              (dropout): Dropout(p=0.1, inplace=False)\n",
+       "              (act): NewGELUActivation()\n",
+       "            )\n",
+       "            (layer_norm): MT5LayerNorm()\n",
+       "            (dropout): Dropout(p=0.1, inplace=False)\n",
+       "          )\n",
+       "        )\n",
+       "      )\n",
+       "      (1-23): 23 x MT5Block(\n",
+       "        (layer): ModuleList(\n",
+       "          (0): MT5LayerSelfAttention(\n",
+       "            (SelfAttention): MT5Attention(\n",
+       "              (q): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              (k): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              (v): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              (o): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "            )\n",
+       "            (layer_norm): MT5LayerNorm()\n",
+       "            (dropout): Dropout(p=0.1, inplace=False)\n",
+       "          )\n",
+       "          (1): MT5LayerFF(\n",
+       "            (DenseReluDense): MT5DenseGatedActDense(\n",
+       "              (wi_0): Linear(in_features=1024, out_features=2816, bias=False)\n",
+       "              (wi_1): Linear(in_features=1024, out_features=2816, bias=False)\n",
+       "              (wo): Linear(in_features=2816, out_features=1024, bias=False)\n",
+       "              (dropout): Dropout(p=0.1, inplace=False)\n",
+       "              (act): NewGELUActivation()\n",
+       "            )\n",
+       "            (layer_norm): MT5LayerNorm()\n",
+       "            (dropout): Dropout(p=0.1, inplace=False)\n",
+       "          )\n",
+       "        )\n",
+       "      )\n",
+       "    )\n",
+       "    (final_layer_norm): MT5LayerNorm()\n",
+       "    (dropout): Dropout(p=0.1, inplace=False)\n",
+       "  )\n",
+       "  (decoder): MT5Stack(\n",
+       "    (embed_tokens): Embedding(250112, 1024)\n",
+       "    (block): ModuleList(\n",
+       "      (0): MT5Block(\n",
+       "        (layer): ModuleList(\n",
+       "          (0): MT5LayerSelfAttention(\n",
+       "            (SelfAttention): MT5Attention(\n",
+       "              (q): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              (k): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              (v): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              (o): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              (relative_attention_bias): Embedding(32, 16)\n",
+       "            )\n",
+       "            (layer_norm): MT5LayerNorm()\n",
+       "            (dropout): Dropout(p=0.1, inplace=False)\n",
+       "          )\n",
+       "          (1): MT5LayerCrossAttention(\n",
+       "            (EncDecAttention): MT5Attention(\n",
+       "              (q): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              (k): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              (v): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              (o): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "            )\n",
+       "            (layer_norm): MT5LayerNorm()\n",
+       "            (dropout): Dropout(p=0.1, inplace=False)\n",
+       "          )\n",
+       "          (2): MT5LayerFF(\n",
+       "            (DenseReluDense): MT5DenseGatedActDense(\n",
+       "              (wi_0): Linear(in_features=1024, out_features=2816, bias=False)\n",
+       "              (wi_1): Linear(in_features=1024, out_features=2816, bias=False)\n",
+       "              (wo): Linear(in_features=2816, out_features=1024, bias=False)\n",
+       "              (dropout): Dropout(p=0.1, inplace=False)\n",
+       "              (act): NewGELUActivation()\n",
+       "            )\n",
+       "            (layer_norm): MT5LayerNorm()\n",
+       "            (dropout): Dropout(p=0.1, inplace=False)\n",
+       "          )\n",
+       "        )\n",
+       "      )\n",
+       "      (1-23): 23 x MT5Block(\n",
+       "        (layer): ModuleList(\n",
+       "          (0): MT5LayerSelfAttention(\n",
+       "            (SelfAttention): MT5Attention(\n",
+       "              (q): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              (k): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              (v): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              (o): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "            )\n",
+       "            (layer_norm): MT5LayerNorm()\n",
+       "            (dropout): Dropout(p=0.1, inplace=False)\n",
+       "          )\n",
+       "          (1): MT5LayerCrossAttention(\n",
+       "            (EncDecAttention): MT5Attention(\n",
+       "              (q): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              (k): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              (v): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              (o): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "            )\n",
+       "            (layer_norm): MT5LayerNorm()\n",
+       "            (dropout): Dropout(p=0.1, inplace=False)\n",
+       "          )\n",
+       "          (2): MT5LayerFF(\n",
+       "            (DenseReluDense): MT5DenseGatedActDense(\n",
+       "              (wi_0): Linear(in_features=1024, out_features=2816, bias=False)\n",
+       "              (wi_1): Linear(in_features=1024, out_features=2816, bias=False)\n",
+       "              (wo): Linear(in_features=2816, out_features=1024, bias=False)\n",
+       "              (dropout): Dropout(p=0.1, inplace=False)\n",
+       "              (act): NewGELUActivation()\n",
+       "            )\n",
+       "            (layer_norm): MT5LayerNorm()\n",
+       "            (dropout): Dropout(p=0.1, inplace=False)\n",
+       "          )\n",
+       "        )\n",
+       "      )\n",
+       "    )\n",
+       "    (final_layer_norm): MT5LayerNorm()\n",
+       "    (dropout): Dropout(p=0.1, inplace=False)\n",
+       "  )\n",
+       "  (lm_head): Linear(in_features=1024, out_features=250112, bias=False)\n",
+       ")"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "63d7bc2d",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "05978e96",
+    "outputId": "ea9b7d40-010f-4df0-ec64-a7146a5f8b08"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "trainable params: 282,624 || all params: 1,229,863,936 || trainable%: 0.0230\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "PeftModelForSeq2SeqLM(\n",
+       "  (base_model): IA3Model(\n",
+       "    (model): MT5ForConditionalGeneration(\n",
+       "      (shared): Embedding(250112, 1024)\n",
+       "      (encoder): MT5Stack(\n",
+       "        (embed_tokens): Embedding(250112, 1024)\n",
+       "        (block): ModuleList(\n",
+       "          (0): MT5Block(\n",
+       "            (layer): ModuleList(\n",
+       "              (0): MT5LayerSelfAttention(\n",
+       "                (SelfAttention): MT5Attention(\n",
+       "                  (q): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                  (k): Linear(\n",
+       "                    (base_layer): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                    (ia3_l): ParameterDict(  (default): Parameter containing: [torch.FloatTensor of size 1024x1])\n",
+       "                  )\n",
+       "                  (v): Linear(\n",
+       "                    (base_layer): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                    (ia3_l): ParameterDict(  (default): Parameter containing: [torch.FloatTensor of size 1024x1])\n",
+       "                  )\n",
+       "                  (o): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                  (relative_attention_bias): Embedding(32, 16)\n",
+       "                )\n",
+       "                (layer_norm): MT5LayerNorm()\n",
+       "                (dropout): Dropout(p=0.1, inplace=False)\n",
+       "              )\n",
+       "              (1): MT5LayerFF(\n",
+       "                (DenseReluDense): MT5DenseGatedActDense(\n",
+       "                  (wi_0): Linear(in_features=1024, out_features=2816, bias=False)\n",
+       "                  (wi_1): Linear(\n",
+       "                    (base_layer): Linear(in_features=1024, out_features=2816, bias=False)\n",
+       "                    (ia3_l): ParameterDict(  (default): Parameter containing: [torch.FloatTensor of size 2816x1])\n",
+       "                  )\n",
+       "                  (wo): Linear(in_features=2816, out_features=1024, bias=False)\n",
+       "                  (dropout): Dropout(p=0.1, inplace=False)\n",
+       "                  (act): NewGELUActivation()\n",
+       "                )\n",
+       "                (layer_norm): MT5LayerNorm()\n",
+       "                (dropout): Dropout(p=0.1, inplace=False)\n",
+       "              )\n",
+       "            )\n",
+       "          )\n",
+       "          (1-23): 23 x MT5Block(\n",
+       "            (layer): ModuleList(\n",
+       "              (0): MT5LayerSelfAttention(\n",
+       "                (SelfAttention): MT5Attention(\n",
+       "                  (q): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                  (k): Linear(\n",
+       "                    (base_layer): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                    (ia3_l): ParameterDict(  (default): Parameter containing: [torch.FloatTensor of size 1024x1])\n",
+       "                  )\n",
+       "                  (v): Linear(\n",
+       "                    (base_layer): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                    (ia3_l): ParameterDict(  (default): Parameter containing: [torch.FloatTensor of size 1024x1])\n",
+       "                  )\n",
+       "                  (o): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                )\n",
+       "                (layer_norm): MT5LayerNorm()\n",
+       "                (dropout): Dropout(p=0.1, inplace=False)\n",
+       "              )\n",
+       "              (1): MT5LayerFF(\n",
+       "                (DenseReluDense): MT5DenseGatedActDense(\n",
+       "                  (wi_0): Linear(in_features=1024, out_features=2816, bias=False)\n",
+       "                  (wi_1): Linear(\n",
+       "                    (base_layer): Linear(in_features=1024, out_features=2816, bias=False)\n",
+       "                    (ia3_l): ParameterDict(  (default): Parameter containing: [torch.FloatTensor of size 2816x1])\n",
+       "                  )\n",
+       "                  (wo): Linear(in_features=2816, out_features=1024, bias=False)\n",
+       "                  (dropout): Dropout(p=0.1, inplace=False)\n",
+       "                  (act): NewGELUActivation()\n",
+       "                )\n",
+       "                (layer_norm): MT5LayerNorm()\n",
+       "                (dropout): Dropout(p=0.1, inplace=False)\n",
+       "              )\n",
+       "            )\n",
+       "          )\n",
+       "        )\n",
+       "        (final_layer_norm): MT5LayerNorm()\n",
+       "        (dropout): Dropout(p=0.1, inplace=False)\n",
+       "      )\n",
+       "      (decoder): MT5Stack(\n",
+       "        (embed_tokens): Embedding(250112, 1024)\n",
+       "        (block): ModuleList(\n",
+       "          (0): MT5Block(\n",
+       "            (layer): ModuleList(\n",
+       "              (0): MT5LayerSelfAttention(\n",
+       "                (SelfAttention): MT5Attention(\n",
+       "                  (q): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                  (k): Linear(\n",
+       "                    (base_layer): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                    (ia3_l): ParameterDict(  (default): Parameter containing: [torch.FloatTensor of size 1024x1])\n",
+       "                  )\n",
+       "                  (v): Linear(\n",
+       "                    (base_layer): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                    (ia3_l): ParameterDict(  (default): Parameter containing: [torch.FloatTensor of size 1024x1])\n",
+       "                  )\n",
+       "                  (o): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                  (relative_attention_bias): Embedding(32, 16)\n",
+       "                )\n",
+       "                (layer_norm): MT5LayerNorm()\n",
+       "                (dropout): Dropout(p=0.1, inplace=False)\n",
+       "              )\n",
+       "              (1): MT5LayerCrossAttention(\n",
+       "                (EncDecAttention): MT5Attention(\n",
+       "                  (q): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                  (k): Linear(\n",
+       "                    (base_layer): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                    (ia3_l): ParameterDict(  (default): Parameter containing: [torch.FloatTensor of size 1024x1])\n",
+       "                  )\n",
+       "                  (v): Linear(\n",
+       "                    (base_layer): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                    (ia3_l): ParameterDict(  (default): Parameter containing: [torch.FloatTensor of size 1024x1])\n",
+       "                  )\n",
+       "                  (o): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                )\n",
+       "                (layer_norm): MT5LayerNorm()\n",
+       "                (dropout): Dropout(p=0.1, inplace=False)\n",
+       "              )\n",
+       "              (2): MT5LayerFF(\n",
+       "                (DenseReluDense): MT5DenseGatedActDense(\n",
+       "                  (wi_0): Linear(in_features=1024, out_features=2816, bias=False)\n",
+       "                  (wi_1): Linear(\n",
+       "                    (base_layer): Linear(in_features=1024, out_features=2816, bias=False)\n",
+       "                    (ia3_l): ParameterDict(  (default): Parameter containing: [torch.FloatTensor of size 2816x1])\n",
+       "                  )\n",
+       "                  (wo): Linear(in_features=2816, out_features=1024, bias=False)\n",
+       "                  (dropout): Dropout(p=0.1, inplace=False)\n",
+       "                  (act): NewGELUActivation()\n",
+       "                )\n",
+       "                (layer_norm): MT5LayerNorm()\n",
+       "                (dropout): Dropout(p=0.1, inplace=False)\n",
+       "              )\n",
+       "            )\n",
+       "          )\n",
+       "          (1-23): 23 x MT5Block(\n",
+       "            (layer): ModuleList(\n",
+       "              (0): MT5LayerSelfAttention(\n",
+       "                (SelfAttention): MT5Attention(\n",
+       "                  (q): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                  (k): Linear(\n",
+       "                    (base_layer): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                    (ia3_l): ParameterDict(  (default): Parameter containing: [torch.FloatTensor of size 1024x1])\n",
+       "                  )\n",
+       "                  (v): Linear(\n",
+       "                    (base_layer): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                    (ia3_l): ParameterDict(  (default): Parameter containing: [torch.FloatTensor of size 1024x1])\n",
+       "                  )\n",
+       "                  (o): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                )\n",
+       "                (layer_norm): MT5LayerNorm()\n",
+       "                (dropout): Dropout(p=0.1, inplace=False)\n",
+       "              )\n",
+       "              (1): MT5LayerCrossAttention(\n",
+       "                (EncDecAttention): MT5Attention(\n",
+       "                  (q): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                  (k): Linear(\n",
+       "                    (base_layer): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                    (ia3_l): ParameterDict(  (default): Parameter containing: [torch.FloatTensor of size 1024x1])\n",
+       "                  )\n",
+       "                  (v): Linear(\n",
+       "                    (base_layer): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                    (ia3_l): ParameterDict(  (default): Parameter containing: [torch.FloatTensor of size 1024x1])\n",
+       "                  )\n",
+       "                  (o): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                )\n",
+       "                (layer_norm): MT5LayerNorm()\n",
+       "                (dropout): Dropout(p=0.1, inplace=False)\n",
+       "              )\n",
+       "              (2): MT5LayerFF(\n",
+       "                (DenseReluDense): MT5DenseGatedActDense(\n",
+       "                  (wi_0): Linear(in_features=1024, out_features=2816, bias=False)\n",
+       "                  (wi_1): Linear(\n",
+       "                    (base_layer): Linear(in_features=1024, out_features=2816, bias=False)\n",
+       "                    (ia3_l): ParameterDict(  (default): Parameter containing: [torch.FloatTensor of size 2816x1])\n",
+       "                  )\n",
+       "                  (wo): Linear(in_features=2816, out_features=1024, bias=False)\n",
+       "                  (dropout): Dropout(p=0.1, inplace=False)\n",
+       "                  (act): NewGELUActivation()\n",
+       "                )\n",
+       "                (layer_norm): MT5LayerNorm()\n",
+       "                (dropout): Dropout(p=0.1, inplace=False)\n",
+       "              )\n",
+       "            )\n",
+       "          )\n",
+       "        )\n",
+       "        (final_layer_norm): MT5LayerNorm()\n",
+       "        (dropout): Dropout(p=0.1, inplace=False)\n",
+       "      )\n",
+       "      (lm_head): Linear(in_features=1024, out_features=250112, bias=False)\n",
+       "    )\n",
+       "  )\n",
+       ")"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model = get_peft_model(model, peft_config)\n",
+    "model.print_trainable_parameters()\n",
+    "model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "155b8728",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 140,
+     "referenced_widgets": [
+      "bbfb7533b5ca459194e171df56b79566",
+      "c894e8237aa34c56bb250acab1466005",
+      "a5a126b229064812bf3dcb228118be50",
+      "661e1b29c59a4295b594edfa4f50ff87",
+      "1bcba805972b484d8b6aa6542c81841c",
+      "e71f5c7f1d5d4f83b58c68d2fa310d9c",
+      "6a567e0a1a5447519c5df10e777520cf",
+      "7aeca19b84904906a04c12659f84ff9e",
+      "dd4b895874ce46ceb1ad0d9bc973f98f",
+      "b138f91be7f94008806eaf0a6988bc3f",
+      "da14180f51ab44b48470cb9ea74d3864",
+      "9e12d97af6124a5a8c6627708b300c1e",
+      "faa18df899c14e9cac6721253e6c9128",
+      "79d0ede7a5b24756aa6d34fda8c29159",
+      "3b175b452f4347558aa3c4501cc90030",
+      "fc4637a1b37e4e90874c71aa4271ac74",
+      "1b8aada826a0451bb60c418b19178c8c",
+      "a91916e02e9c424e881e45b3aa978574",
+      "ca509bd409624c998e555c9a779b8aae",
+      "9c890fc422954347b86d3bde7a421caf",
+      "6f9453484ea94587a64d70f1b3a1f6e4",
+      "48770ef159f44c01be2a75c75aecd80f",
+      "0c561dab67914ea9b6e1aab803600551",
+      "1e021a1954b44d69a90101a96c360661",
+      "013e3343285f437a893bdd673fb90e22",
+      "28802da68fb04d70b1c6bc511a04676f",
+      "94174da0d6554be087d4527bea5b511a",
+      "dc8ab16a1e6c4e6893c95ccd16568f9a",
+      "72383136663448d89cf3b82b87cbb392",
+      "5b1bdaf16cbc473081e4237f839167b9",
+      "51f8fb45485540bb985b606d43ae04ea",
+      "f760cd4758334ca9a43fd15612fd808b",
+      "f60e9915d2a74ca7bc010d7684f5acf6"
+     ]
+    },
+    "id": "4ee2babf",
+    "outputId": "3c413083-247d-47da-f25c-032764be0beb"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using the latest cached version of the dataset since financial_phrasebank couldn't be found on the Hugging Face Hub\n",
+      "Found the latest cached dataset configuration 'sentences_allagree' at /root/.cache/huggingface/datasets/financial_phrasebank/sentences_allagree/1.0.0/550bde12e6c30e2674da973a55f57edde5181d53f5a5a34c1531c53f93b7e141 (last modified on Thu Jul 31 03:15:41 2025).\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "43b03e9b6de94bf0921228482d7be1e5",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map:   0%|          | 0/2037 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d08de1efca67472781017b806f33870c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map:   0%|          | 0/227 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'sentence': 'SCOPI Chief Business Excellence Officer , Eng .',\n",
+       " 'label': 1,\n",
+       " 'text_label': 'neutral'}"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# loading dataset\n",
+    "dataset = load_dataset(\"zeroshot/twitter-financial-news-sentiment\")\n",
+    "dataset = dataset[\"train\"].train_test_split(test_size=0.1)\n",
+    "dataset[\"validation\"] = dataset[\"test\"]\n",
+    "del dataset[\"test\"]\n",
+    "\n",
+    "if hasattr(dataset[\"train\"].features[\"label\"], \"names\"):\n",
+    "    classes = dataset[\"train\"].features[\"label\"].names\n",
+    "else:\n",
+    "    classes = [\"Bearish\", \"Bullish\", \"Neutral\"]\n",
+    "dataset = dataset.map(\n",
+    "    lambda x: {\"text_label\": [classes[label] for label in x[\"label\"]]},\n",
+    "    batched=True,\n",
+    "    num_proc=1,\n",
+    ")\n",
+    "\n",
+    "dataset[\"train\"][0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "723fb67d",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 17,
+     "referenced_widgets": [
+      "e1e80a68a9e7429397cafc96c3c11f80",
+      "5307864c2b1143f4b44f3f172611113e",
+      "2e2b6c3f48974ea4aca9b7710a03379e",
+      "aae78f9bd53348bda45967a38736cb78",
+      "34db17e0f28d40d6abafb8acd5dda379",
+      "8361dc2e0a834da6a0ad87f7b0cb4e1b",
+      "56f1d9d56dd44c8aa923d09a59cb0ebc",
+      "d93bfb366db14c2fa77b038752f69b38",
+      "749aaa39135841f98b344ffb840df3d4",
+      "5e5aa58adb0f48579871df33845e30b1",
+      "c25b49b7adaa48a0a3a306aa1e0661b4",
+      "21f582e1208a4a38ae3c0cdce87e5c14",
+      "d9d37b8b79f24dbf837327a250a5a346",
+      "8ba99043c350456d8623ce1d8c98f7a0",
+      "8bf37c12d5f74f7d8dbba423a9ee3ac3",
+      "f9d86ad7fa734f3a857505a542256a3c",
+      "86bf02b06ed740a88015c2b944205c1e",
+      "aef6a6be67f749908060d8038b6d3804",
+      "664c02903cb248fb9339805bccfd6c1d",
+      "82195b807b664a9585a76e0e50fe7609",
+      "8621932be14f42858d841e2ac1b173e7",
+      "71bcdb1e02144c9587879d8d815b91d4"
+     ]
+    },
+    "id": "adf9608c",
+    "outputId": "3e4bc95f-1dc4-4d34-c212-6d2374359673"
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "7e08a312e5454c188f52fc2ca902c463",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "tokenizer_config.json:   0%|          | 0.00/430 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "25d5de12709748c9959cd011c5c641de",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "spiece.model:   0%|          | 0.00/4.31M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "5b39c130813843c18e7f9187ffec37df",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "tokenizer.json:   0%|          | 0.00/16.3M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "de27076e123243fd89dbad1c9e1f0596",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "special_tokens_map.json:   0%|          | 0.00/74.0 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "1b55669bf13a4e2886f34c12d5f50354",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Running tokenizer on dataset:   0%|          | 0/2037 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f914229f180b4188925d9e804b92475c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Running tokenizer on dataset:   0%|          | 0/227 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# data preprocessing\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)\n",
+    "\n",
+    "\n",
+    "def preprocess_function(examples):\n",
+    "    inputs = examples[text_column]\n",
+    "    targets = examples[label_column]\n",
+    "    model_inputs = tokenizer(inputs, max_length=max_length, padding=\"max_length\", truncation=True, return_tensors=\"pt\")\n",
+    "    labels = tokenizer(targets, max_length=3, padding=\"max_length\", truncation=True, return_tensors=\"pt\")\n",
+    "    labels = labels[\"input_ids\"]\n",
+    "    labels[labels == tokenizer.pad_token_id] = -100\n",
+    "    model_inputs[\"labels\"] = labels\n",
+    "    return model_inputs\n",
+    "\n",
+    "\n",
+    "processed_datasets = dataset.map(\n",
+    "    preprocess_function,\n",
+    "    batched=True,\n",
+    "    num_proc=1,\n",
+    "    remove_columns=dataset[\"train\"].column_names,\n",
+    "    load_from_cache_file=False,\n",
+    "    desc=\"Running tokenizer on dataset\",\n",
+    ")\n",
+    "\n",
+    "train_dataset = processed_datasets[\"train\"]\n",
+    "eval_dataset = processed_datasets[\"validation\"]\n",
+    "\n",
+    "train_dataloader = DataLoader(\n",
+    "    train_dataset, shuffle=True, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True\n",
+    ")\n",
+    "eval_dataloader = DataLoader(eval_dataset, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "36d56ea7",
+   "metadata": {
+    "id": "f733a3c6"
+   },
+   "outputs": [],
+   "source": [
+    "# optimizer and lr scheduler\n",
+    "optimizer = torch.optim.AdamW(model.parameters(), lr=lr)\n",
+    "lr_scheduler = get_linear_schedule_with_warmup(\n",
+    "    optimizer=optimizer,\n",
+    "    num_warmup_steps=0,\n",
+    "    num_training_steps=(len(train_dataloader) * num_epochs),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "6b0a0536",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "6b3a4090",
+    "outputId": "369cfce9-90f2-47a1-8653-ea1168943949"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████| 255/255 [00:52<00:00,  4.86it/s]\n",
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████| 29/29 [00:02<00:00, 12.67it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=0: train_ppl=tensor(1.4686, device='xpu:0') train_epoch_loss=tensor(0.3843, device='xpu:0') eval_ppl=tensor(1.0421, device='xpu:0') eval_epoch_loss=tensor(0.0412, device='xpu:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████| 255/255 [00:49<00:00,  5.20it/s]\n",
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████| 29/29 [00:02<00:00, 13.62it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=1: train_ppl=tensor(1.0683, device='xpu:0') train_epoch_loss=tensor(0.0661, device='xpu:0') eval_ppl=tensor(1.0264, device='xpu:0') eval_epoch_loss=tensor(0.0261, device='xpu:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████| 255/255 [00:49<00:00,  5.20it/s]\n",
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████| 29/29 [00:02<00:00, 13.63it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=2: train_ppl=tensor(1.0451, device='xpu:0') train_epoch_loss=tensor(0.0441, device='xpu:0') eval_ppl=tensor(1.0191, device='xpu:0') eval_epoch_loss=tensor(0.0190, device='xpu:0')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# training and evaluation\n",
+    "model = model.to(device)\n",
+    "\n",
+    "for epoch in range(num_epochs):\n",
+    "    model.train()\n",
+    "    total_loss = 0\n",
+    "    for step, batch in enumerate(tqdm(train_dataloader)):\n",
+    "        batch = {k: v.to(device) for k, v in batch.items()}\n",
+    "        outputs = model(**batch)\n",
+    "        loss = outputs.loss\n",
+    "        total_loss += loss.detach().float()\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        lr_scheduler.step()\n",
+    "        optimizer.zero_grad()\n",
+    "\n",
+    "    model.eval()\n",
+    "    eval_loss = 0\n",
+    "    eval_preds = []\n",
+    "    for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+    "        batch = {k: v.to(device) for k, v in batch.items()}\n",
+    "        with torch.no_grad():\n",
+    "            outputs = model(**batch)\n",
+    "        loss = outputs.loss\n",
+    "        eval_loss += loss.detach().float()\n",
+    "        eval_preds.extend(\n",
+    "            tokenizer.batch_decode(torch.argmax(outputs.logits, -1).detach().cpu().numpy(), skip_special_tokens=True)\n",
+    "        )\n",
+    "\n",
+    "    eval_epoch_loss = eval_loss / len(eval_dataloader)\n",
+    "    eval_ppl = torch.exp(eval_epoch_loss)\n",
+    "    train_epoch_loss = total_loss / len(train_dataloader)\n",
+    "    train_ppl = torch.exp(train_epoch_loss)\n",
+    "    print(f\"{epoch=}: {train_ppl=} {train_epoch_loss=} {eval_ppl=} {eval_epoch_loss=}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "761b90e4",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "6cafa67b",
+    "outputId": "0db923d2-522c-4cb7-b694-6e2e20beae98"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "accuracy=96.91629955947137 % on the evaluation dataset\n",
+      "eval_preds[:10]=['neutral', 'neutral', 'neutral', 'neutral', 'positive', 'neutral', 'neutral', 'neutral', 'neutral', 'neutral']\n",
+      "dataset['validation']['text_label'][:10]=['neutral', 'neutral', 'neutral', 'neutral', 'positive', 'neutral', 'neutral', 'neutral', 'neutral', 'neutral']\n"
+     ]
+    }
+   ],
+   "source": [
+    "# print accuracy\n",
+    "correct = 0\n",
+    "total = 0\n",
+    "for pred, true in zip(eval_preds, dataset[\"validation\"][\"text_label\"]):\n",
+    "    if pred.strip() == true.strip():\n",
+    "        correct += 1\n",
+    "    total += 1\n",
+    "accuracy = correct / total * 100\n",
+    "print(f\"{accuracy=} % on the evaluation dataset\")\n",
+    "print(f\"{eval_preds[:10]=}\")\n",
+    "print(f\"{dataset['validation']['text_label'][:10]=}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "8e0658ac",
+   "metadata": {
+    "id": "a8de6005"
+   },
+   "outputs": [],
+   "source": [
+    "# saving model\n",
+    "peft_model_id = f\"{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\"\n",
+    "model.save_pretrained(peft_model_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ef7fbf9c",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "bd20cd4c",
+    "outputId": "0f25d837-80b1-476f-c897-92c3fef04fb2"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1.2M\tbigscience/mt0-large_IA3_SEQ_2_SEQ_LM/adapter_model.safetensors\n"
+     ]
+    }
+   ],
+   "source": [
+    "ckpt = f\"{peft_model_id}/adapter_model.safetensors\"\n",
+    "!du -h $ckpt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "4774d931",
+   "metadata": {
+    "id": "76c2fc29"
+   },
+   "outputs": [],
+   "source": [
+    "from peft import PeftModel, PeftConfig\n",
+    "\n",
+    "peft_model_id = f\"{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\"\n",
+    "\n",
+    "config = PeftConfig.from_pretrained(peft_model_id)\n",
+    "model = AutoModelForSeq2SeqLM.from_pretrained(config.base_model_name_or_path)\n",
+    "model = PeftModel.from_pretrained(model, peft_model_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "996ddf0a",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "37d712ce",
+    "outputId": "4828819a-b640-4f6c-91e3-878b648e9a75"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "25 November 2010 - Finnish paints and coatings company Tikkurila Oyj ( HEL : TIK1V ) said today that Finnish state-owned investment company Solidium Oy sold its 14.7 % stake in the company for a total of EUR98m .\n",
+      "{'input_ids': tensor([[   877,   3277,   1068,    259,    264,    515, 143136,  42068,    263,\n",
+      "            305,    259, 101264,    263,   5835,  22538,   4496,   2697,  20860,\n",
+      "            385,    274,  76347,    259,    267,    259,  93686,    353,    561,\n",
+      "            259,    271,   2426,   7883,    533,    515, 143136,   6509,    264,\n",
+      "          45815,  37624,   5835,  35133,  16558,  20860,  22026,   2476,   5006,\n",
+      "            487,   1448,    259,  96189,    281,    287,   5835,    332,    259,\n",
+      "            262,   2725,    304,   2687,   5577,    282,    259,    260,      1]]), 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
+      "         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
+      "         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])}\n",
+      "tensor([[    0, 59006,     1]])\n",
+      "['neutral']\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.eval()\n",
+    "i = 13\n",
+    "inputs = tokenizer(dataset[\"validation\"][text_column][i], return_tensors=\"pt\")\n",
+    "print(dataset[\"validation\"][text_column][i])\n",
+    "print(inputs)\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    outputs = model.generate(input_ids=inputs[\"input_ids\"], max_new_tokens=10)\n",
+    "    print(outputs)\n",
+    "    print(tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "701eda1b",
+   "metadata": {
+    "id": "66c65ea4"
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7d7718c5",
+   "metadata": {
+    "id": "65e71f78"
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "gpuType": "T4",
+   "machine_shape": "hm",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
+   }
+  },
+  "widgets": {
+   "application/vnd.jupyter.widget-state+json": {
+    "013e3343285f437a893bdd673fb90e22": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5b1bdaf16cbc473081e4237f839167b9",
+      "max": 227,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_51f8fb45485540bb985b606d43ae04ea",
+      "value": 227
+     }
+    },
+    "0c561dab67914ea9b6e1aab803600551": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_1e021a1954b44d69a90101a96c360661",
+       "IPY_MODEL_013e3343285f437a893bdd673fb90e22",
+       "IPY_MODEL_28802da68fb04d70b1c6bc511a04676f"
+      ],
+      "layout": "IPY_MODEL_94174da0d6554be087d4527bea5b511a"
+     }
+    },
+    "1b8aada826a0451bb60c418b19178c8c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1bcba805972b484d8b6aa6542c81841c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1e021a1954b44d69a90101a96c360661": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_dc8ab16a1e6c4e6893c95ccd16568f9a",
+      "placeholder": "​",
+      "style": "IPY_MODEL_72383136663448d89cf3b82b87cbb392",
+      "value": "Map:   0%"
+     }
+    },
+    "21f582e1208a4a38ae3c0cdce87e5c14": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_d9d37b8b79f24dbf837327a250a5a346",
+       "IPY_MODEL_8ba99043c350456d8623ce1d8c98f7a0",
+       "IPY_MODEL_8bf37c12d5f74f7d8dbba423a9ee3ac3"
+      ],
+      "layout": "IPY_MODEL_f9d86ad7fa734f3a857505a542256a3c"
+     }
+    },
+    "28802da68fb04d70b1c6bc511a04676f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f760cd4758334ca9a43fd15612fd808b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_f60e9915d2a74ca7bc010d7684f5acf6",
+      "value": " 0/227 [00:00&lt;?, ? examples/s]"
+     }
+    },
+    "2e2b6c3f48974ea4aca9b7710a03379e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d93bfb366db14c2fa77b038752f69b38",
+      "max": 2037,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_749aaa39135841f98b344ffb840df3d4",
+      "value": 2037
+     }
+    },
+    "34db17e0f28d40d6abafb8acd5dda379": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": "hidden",
+      "width": null
+     }
+    },
+    "3b175b452f4347558aa3c4501cc90030": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6f9453484ea94587a64d70f1b3a1f6e4",
+      "placeholder": "​",
+      "style": "IPY_MODEL_48770ef159f44c01be2a75c75aecd80f",
+      "value": " 0/2037 [00:00&lt;?, ? examples/s]"
+     }
+    },
+    "48770ef159f44c01be2a75c75aecd80f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "51f8fb45485540bb985b606d43ae04ea": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "5307864c2b1143f4b44f3f172611113e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8361dc2e0a834da6a0ad87f7b0cb4e1b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_56f1d9d56dd44c8aa923d09a59cb0ebc",
+      "value": "Running tokenizer on dataset:  98%"
+     }
+    },
+    "56f1d9d56dd44c8aa923d09a59cb0ebc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "5b1bdaf16cbc473081e4237f839167b9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5e5aa58adb0f48579871df33845e30b1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "661e1b29c59a4295b594edfa4f50ff87": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b138f91be7f94008806eaf0a6988bc3f",
+      "placeholder": "​",
+      "style": "IPY_MODEL_da14180f51ab44b48470cb9ea74d3864",
+      "value": " 1/1 [00:00&lt;00:00, 67.12it/s]"
+     }
+    },
+    "664c02903cb248fb9339805bccfd6c1d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6a567e0a1a5447519c5df10e777520cf": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "6f9453484ea94587a64d70f1b3a1f6e4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "71bcdb1e02144c9587879d8d815b91d4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "72383136663448d89cf3b82b87cbb392": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "749aaa39135841f98b344ffb840df3d4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "79d0ede7a5b24756aa6d34fda8c29159": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_ca509bd409624c998e555c9a779b8aae",
+      "max": 2037,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_9c890fc422954347b86d3bde7a421caf",
+      "value": 2037
+     }
+    },
+    "7aeca19b84904906a04c12659f84ff9e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "82195b807b664a9585a76e0e50fe7609": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "8361dc2e0a834da6a0ad87f7b0cb4e1b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8621932be14f42858d841e2ac1b173e7": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "86bf02b06ed740a88015c2b944205c1e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8ba99043c350456d8623ce1d8c98f7a0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_664c02903cb248fb9339805bccfd6c1d",
+      "max": 227,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_82195b807b664a9585a76e0e50fe7609",
+      "value": 227
+     }
+    },
+    "8bf37c12d5f74f7d8dbba423a9ee3ac3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8621932be14f42858d841e2ac1b173e7",
+      "placeholder": "​",
+      "style": "IPY_MODEL_71bcdb1e02144c9587879d8d815b91d4",
+      "value": " 0/227 [00:00&lt;?, ? examples/s]"
+     }
+    },
+    "94174da0d6554be087d4527bea5b511a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": "hidden",
+      "width": null
+     }
+    },
+    "9c890fc422954347b86d3bde7a421caf": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "9e12d97af6124a5a8c6627708b300c1e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_faa18df899c14e9cac6721253e6c9128",
+       "IPY_MODEL_79d0ede7a5b24756aa6d34fda8c29159",
+       "IPY_MODEL_3b175b452f4347558aa3c4501cc90030"
+      ],
+      "layout": "IPY_MODEL_fc4637a1b37e4e90874c71aa4271ac74"
+     }
+    },
+    "a5a126b229064812bf3dcb228118be50": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7aeca19b84904906a04c12659f84ff9e",
+      "max": 1,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_dd4b895874ce46ceb1ad0d9bc973f98f",
+      "value": 1
+     }
+    },
+    "a91916e02e9c424e881e45b3aa978574": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "aae78f9bd53348bda45967a38736cb78": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5e5aa58adb0f48579871df33845e30b1",
+      "placeholder": "​",
+      "style": "IPY_MODEL_c25b49b7adaa48a0a3a306aa1e0661b4",
+      "value": " 2000/2037 [00:00&lt;00:00, 3864.28 examples/s]"
+     }
+    },
+    "aef6a6be67f749908060d8038b6d3804": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "b138f91be7f94008806eaf0a6988bc3f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "bbfb7533b5ca459194e171df56b79566": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_c894e8237aa34c56bb250acab1466005",
+       "IPY_MODEL_a5a126b229064812bf3dcb228118be50",
+       "IPY_MODEL_661e1b29c59a4295b594edfa4f50ff87"
+      ],
+      "layout": "IPY_MODEL_1bcba805972b484d8b6aa6542c81841c"
+     }
+    },
+    "c25b49b7adaa48a0a3a306aa1e0661b4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "c894e8237aa34c56bb250acab1466005": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e71f5c7f1d5d4f83b58c68d2fa310d9c",
+      "placeholder": "​",
+      "style": "IPY_MODEL_6a567e0a1a5447519c5df10e777520cf",
+      "value": "100%"
+     }
+    },
+    "ca509bd409624c998e555c9a779b8aae": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d93bfb366db14c2fa77b038752f69b38": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d9d37b8b79f24dbf837327a250a5a346": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_86bf02b06ed740a88015c2b944205c1e",
+      "placeholder": "​",
+      "style": "IPY_MODEL_aef6a6be67f749908060d8038b6d3804",
+      "value": "Running tokenizer on dataset:   0%"
+     }
+    },
+    "da14180f51ab44b48470cb9ea74d3864": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "dc8ab16a1e6c4e6893c95ccd16568f9a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "dd4b895874ce46ceb1ad0d9bc973f98f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "e1e80a68a9e7429397cafc96c3c11f80": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_5307864c2b1143f4b44f3f172611113e",
+       "IPY_MODEL_2e2b6c3f48974ea4aca9b7710a03379e",
+       "IPY_MODEL_aae78f9bd53348bda45967a38736cb78"
+      ],
+      "layout": "IPY_MODEL_34db17e0f28d40d6abafb8acd5dda379"
+     }
+    },
+    "e71f5c7f1d5d4f83b58c68d2fa310d9c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f60e9915d2a74ca7bc010d7684f5acf6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "f760cd4758334ca9a43fd15612fd808b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f9d86ad7fa734f3a857505a542256a3c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": "hidden",
+      "width": null
+     }
+    },
+    "faa18df899c14e9cac6721253e6c9128": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_1b8aada826a0451bb60c418b19178c8c",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a91916e02e9c424e881e45b3aa978574",
+      "value": "Map:   0%"
+     }
+    },
+    "fc4637a1b37e4e90874c71aa4271ac74": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": "hidden",
+      "width": null
+     }
+    }
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/conditional_generation/peft_lora_seq2seq.ipynb b/examples/conditional_generation/peft_lora_seq2seq.ipynb
new file mode 100755
index 0000000..12b94da
--- /dev/null
+++ b/examples/conditional_generation/peft_lora_seq2seq.ipynb
@@ -0,0 +1,382 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5f93b7d1",
+   "metadata": {},
+   "outputs": [],
+   "source": "from transformers import AutoModelForSeq2SeqLM\nfrom peft import get_peft_config, get_peft_model, get_peft_model_state_dict, LoraConfig, TaskType\nimport torch\nfrom datasets import load_dataset\nimport os\n\nos.environ[\"TOKENIZERS_PARALLELISM\"] = \"false\"\nfrom transformers import AutoTokenizer\nfrom torch.utils.data import DataLoader\nfrom transformers import default_data_collator, get_linear_schedule_with_warmup\nfrom tqdm import tqdm\nfrom datasets import load_dataset\n\ndevice = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\nmodel_name_or_path = \"bigscience/mt0-large\"\ntokenizer_name_or_path = \"bigscience/mt0-large\"\n\ntext_column = \"text\"\nlabel_column = \"text_label\"\nmax_length = 128\nlr = 1e-3\nnum_epochs = 3\nbatch_size = 8"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "8d0850ac",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# creating model\n",
+    "peft_config = LoraConfig(task_type=TaskType.SEQ_2_SEQ_LM, inference_mode=False, r=8, lora_alpha=32, lora_dropout=0.1)\n",
+    "\n",
+    "model = AutoModelForSeq2SeqLM.from_pretrained(model_name_or_path)\n",
+    "model = get_peft_model(model, peft_config)\n",
+    "model.print_trainable_parameters()\n",
+    "model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "4ee2babf",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using the latest cached version of the dataset since financial_phrasebank couldn't be found on the Hugging Face Hub\n",
+      "Found the latest cached dataset configuration 'sentences_allagree' at /root/.cache/huggingface/datasets/financial_phrasebank/sentences_allagree/1.0.0/550bde12e6c30e2674da973a55f57edde5181d53f5a5a34c1531c53f93b7e141 (last modified on Thu Jul 31 05:47:32 2025).\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "867f7bbb679d4b6eae344812fb797c19",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map:   0%|          | 0/2037 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a6964a9de5e64d4e80c1906e2bed9f21",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map:   0%|          | 0/227 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'sentence': 'The bank VTB24 provides mortgage loans to buy apartments in the complex at 11-13 % per annum in rubles .',\n",
+       " 'label': 1,\n",
+       " 'text_label': 'neutral'}"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# loading dataset\n",
+    "dataset = load_dataset(\"zeroshot/twitter-financial-news-sentiment\")\n",
+    "dataset = dataset[\"train\"].train_test_split(test_size=0.1)\n",
+    "dataset[\"validation\"] = dataset[\"test\"]\n",
+    "del dataset[\"test\"]\n",
+    "\n",
+    "if hasattr(dataset[\"train\"].features[\"label\"], \"names\"):\n",
+    "    classes = dataset[\"train\"].features[\"label\"].names\n",
+    "else:\n",
+    "    classes = [\"Bearish\", \"Bullish\", \"Neutral\"]\n",
+    "dataset = dataset.map(\n",
+    "    lambda x: {\"text_label\": [classes[label] for label in x[\"label\"]]},\n",
+    "    batched=True,\n",
+    "    num_proc=1,\n",
+    ")\n",
+    "\n",
+    "dataset[\"train\"][0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "adf9608c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a867fe83918c435ab8a52bee2737f4f3",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Running tokenizer on dataset:   0%|          | 0/2037 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "97ceaf1285f348bd8272e2bec54050c6",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Running tokenizer on dataset:   0%|          | 0/227 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# data preprocessing\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)\n",
+    "\n",
+    "\n",
+    "def preprocess_function(examples):\n",
+    "    inputs = examples[text_column]\n",
+    "    targets = examples[label_column]\n",
+    "    model_inputs = tokenizer(inputs, max_length=max_length, padding=\"max_length\", truncation=True, return_tensors=\"pt\")\n",
+    "    labels = tokenizer(targets, max_length=3, padding=\"max_length\", truncation=True, return_tensors=\"pt\")\n",
+    "    labels = labels[\"input_ids\"]\n",
+    "    labels[labels == tokenizer.pad_token_id] = -100\n",
+    "    model_inputs[\"labels\"] = labels\n",
+    "    return model_inputs\n",
+    "\n",
+    "\n",
+    "processed_datasets = dataset.map(\n",
+    "    preprocess_function,\n",
+    "    batched=True,\n",
+    "    num_proc=1,\n",
+    "    remove_columns=dataset[\"train\"].column_names,\n",
+    "    load_from_cache_file=False,\n",
+    "    desc=\"Running tokenizer on dataset\",\n",
+    ")\n",
+    "\n",
+    "train_dataset = processed_datasets[\"train\"]\n",
+    "eval_dataset = processed_datasets[\"validation\"]\n",
+    "\n",
+    "train_dataloader = DataLoader(\n",
+    "    train_dataset, shuffle=True, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True\n",
+    ")\n",
+    "eval_dataloader = DataLoader(eval_dataset, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "f733a3c6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# optimizer and lr scheduler\n",
+    "optimizer = torch.optim.AdamW(model.parameters(), lr=lr)\n",
+    "lr_scheduler = get_linear_schedule_with_warmup(\n",
+    "    optimizer=optimizer,\n",
+    "    num_warmup_steps=0,\n",
+    "    num_training_steps=(len(train_dataloader) * num_epochs),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6b3a4090",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# training and evaluation\n",
+    "model = model.to(device)\n",
+    "\n",
+    "for epoch in range(num_epochs):\n",
+    "    model.train()\n",
+    "    total_loss = 0\n",
+    "    for step, batch in enumerate(tqdm(train_dataloader)):\n",
+    "        batch = {k: v.to(device) for k, v in batch.items()}\n",
+    "        outputs = model(**batch)\n",
+    "        loss = outputs.loss\n",
+    "        total_loss += loss.detach().float()\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        lr_scheduler.step()\n",
+    "        optimizer.zero_grad()\n",
+    "\n",
+    "    model.eval()\n",
+    "    eval_loss = 0\n",
+    "    eval_preds = []\n",
+    "    for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+    "        batch = {k: v.to(device) for k, v in batch.items()}\n",
+    "        with torch.no_grad():\n",
+    "            outputs = model(**batch)\n",
+    "        loss = outputs.loss\n",
+    "        eval_loss += loss.detach().float()\n",
+    "        eval_preds.extend(\n",
+    "            tokenizer.batch_decode(torch.argmax(outputs.logits, -1).detach().cpu().numpy(), skip_special_tokens=True)\n",
+    "        )\n",
+    "\n",
+    "    eval_epoch_loss = eval_loss / len(eval_dataloader)\n",
+    "    eval_ppl = torch.exp(eval_epoch_loss)\n",
+    "    train_epoch_loss = total_loss / len(train_dataloader)\n",
+    "    train_ppl = torch.exp(train_epoch_loss)\n",
+    "    print(f\"{epoch=}: {train_ppl=} {train_epoch_loss=} {eval_ppl=} {eval_epoch_loss=}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "6cafa67b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "accuracy=97.3568281938326 % on the evaluation dataset\n",
+      "eval_preds[:10]=['neutral', 'neutral', 'neutral', 'positive', 'neutral', 'positive', 'positive', 'neutral', 'neutral', 'neutral']\n",
+      "dataset['validation']['text_label'][:10]=['neutral', 'neutral', 'neutral', 'positive', 'neutral', 'positive', 'positive', 'neutral', 'neutral', 'neutral']\n"
+     ]
+    }
+   ],
+   "source": [
+    "# print accuracy\n",
+    "correct = 0\n",
+    "total = 0\n",
+    "for pred, true in zip(eval_preds, dataset[\"validation\"][\"text_label\"]):\n",
+    "    if pred.strip() == true.strip():\n",
+    "        correct += 1\n",
+    "    total += 1\n",
+    "accuracy = correct / total * 100\n",
+    "print(f\"{accuracy=} % on the evaluation dataset\")\n",
+    "print(f\"{eval_preds[:10]=}\")\n",
+    "print(f\"{dataset['validation']['text_label'][:10]=}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "a8de6005",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# saving model\n",
+    "peft_model_id = f\"{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\"\n",
+    "model.save_pretrained(peft_model_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bd20cd4c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "9,2M\tbigscience/mt0-large_LORA_SEQ_2_SEQ_LM/adapter_model.safetensors\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "ckpt = f\"{peft_model_id}/adapter_model.safetensors\"\n",
+    "!du -h $ckpt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "76c2fc29",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from peft import PeftModel, PeftConfig\n",
+    "\n",
+    "peft_model_id = f\"{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\"\n",
+    "\n",
+    "config = PeftConfig.from_pretrained(peft_model_id)\n",
+    "model = AutoModelForSeq2SeqLM.from_pretrained(config.base_model_name_or_path)\n",
+    "model = PeftModel.from_pretrained(model, peft_model_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "37d712ce",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "- Demand for fireplace products was lower than expected , especially in Germany .\n",
+      "{'input_ids': tensor([[  259,   264,   259, 82903,   332,  1090, 10040, 10371,   639,   259,\n",
+      "         19540,  2421,   259, 25505,   259,   261,   259, 21230,   281, 17052,\n",
+      "           259,   260,     1]]), 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])}\n",
+      "tensor([[    0,   259, 32588,     1]])\n",
+      "['negative']\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.eval()\n",
+    "i = 13\n",
+    "inputs = tokenizer(dataset[\"validation\"][text_column][i], return_tensors=\"pt\")\n",
+    "print(dataset[\"validation\"][text_column][i])\n",
+    "print(inputs)\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    outputs = model.generate(input_ids=inputs[\"input_ids\"], max_new_tokens=10)\n",
+    "    print(outputs)\n",
+    "    print(tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "66c65ea4",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "65e71f78",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/conditional_generation/peft_lora_seq2seq_accelerate_ds_zero3_offload.py b/examples/conditional_generation/peft_lora_seq2seq_accelerate_ds_zero3_offload.py
new file mode 100644
index 0000000..3fd22ea
--- /dev/null
+++ b/examples/conditional_generation/peft_lora_seq2seq_accelerate_ds_zero3_offload.py
@@ -0,0 +1,333 @@
+import gc
+import os
+import sys
+import threading
+
+import psutil
+import torch
+from accelerate import Accelerator
+from datasets import load_dataset
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, get_linear_schedule_with_warmup, set_seed
+
+from peft import LoraConfig, TaskType, get_peft_model
+
+
+def levenshtein_distance(str1, str2):
+    # TC: O(N^2)
+    # SC: O(N)
+    if str1 == str2:
+        return 0
+    num_rows = len(str1) + 1
+    num_cols = len(str2) + 1
+    dp_matrix = list(range(num_cols))
+    for i in range(1, num_rows):
+        prev = dp_matrix[0]
+        dp_matrix[0] = i
+        for j in range(1, num_cols):
+            temp = dp_matrix[j]
+            if str1[i - 1] == str2[j - 1]:
+                dp_matrix[j] = prev
+            else:
+                dp_matrix[j] = min(prev, dp_matrix[j], dp_matrix[j - 1]) + 1
+            prev = temp
+    return dp_matrix[num_cols - 1]
+
+
+def get_closest_label(eval_pred, classes):
+    min_id = sys.maxsize
+    min_edit_distance = sys.maxsize
+    for i, class_label in enumerate(classes):
+        edit_distance = levenshtein_distance(eval_pred.strip(), class_label)
+        if edit_distance < min_edit_distance:
+            min_id = i
+            min_edit_distance = edit_distance
+    return classes[min_id]
+
+
+# Converting Bytes to Megabytes
+def b2mb(x):
+    return int(x / 2**20)
+
+
+# This context manager is used to track the peak memory usage of the process
+class TorchTracemalloc:
+    def __enter__(self):
+        self.device_type = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+        self.device_module = getattr(torch, self.device_type, torch.cuda)
+        gc.collect()
+        self.device_module.empty_cache()
+        self.device_module.reset_peak_memory_stats()  # reset the peak gauge to zero
+        self.begin = self.device_module.memory_allocated()
+        self.process = psutil.Process()
+
+        self.cpu_begin = self.cpu_mem_used()
+        self.peak_monitoring = True
+        peak_monitor_thread = threading.Thread(target=self.peak_monitor_func)
+        peak_monitor_thread.daemon = True
+        peak_monitor_thread.start()
+        return self
+
+    def cpu_mem_used(self):
+        """get resident set size memory for the current process"""
+        return self.process.memory_info().rss
+
+    def peak_monitor_func(self):
+        self.cpu_peak = -1
+
+        while True:
+            self.cpu_peak = max(self.cpu_mem_used(), self.cpu_peak)
+
+            # can't sleep or will not catch the peak right (this comment is here on purpose)
+            # time.sleep(0.001) # 1msec
+
+            if not self.peak_monitoring:
+                break
+
+    def __exit__(self, *exc):
+        self.peak_monitoring = False
+
+        gc.collect()
+        self.device_module.empty_cache()
+        self.end = self.device_module.memory_allocated()
+        self.peak = self.device_module.max_memory_allocated()
+        self.used = b2mb(self.end - self.begin)
+        self.peaked = b2mb(self.peak - self.begin)
+
+        self.cpu_end = self.cpu_mem_used()
+        self.cpu_used = b2mb(self.cpu_end - self.cpu_begin)
+        self.cpu_peaked = b2mb(self.cpu_peak - self.cpu_begin)
+        # print(f"delta used/peak {self.used:4d}/{self.peaked:4d}")
+
+
+def main():
+    accelerator = Accelerator()
+    # model_name_or_path = "bigscience/T0_3B"
+    model_name_or_path = "facebook/bart-large"
+    dataset_name = "twitter_complaints"
+    peft_config = LoraConfig(
+        task_type=TaskType.SEQ_2_SEQ_LM, inference_mode=False, r=8, lora_alpha=32, lora_dropout=0.1
+    )
+    text_column = "Tweet text"
+    label_column = "text_label"
+    lr = 3e-3
+    num_epochs = 5
+    batch_size = 8
+    seed = 42
+    do_test = False
+    set_seed(seed)
+
+    dataset = load_dataset(
+        "parquet",
+        data_files={
+            "train": f"hf://datasets/ought/raft@refs/convert/parquet/{dataset_name}/train/0000.parquet",
+            "test": f"hf://datasets/ought/raft@refs/convert/parquet/{dataset_name}/test/0000.parquet",
+        },
+    )
+
+    classes = [k.replace("_", " ") for k in dataset["train"].features["Label"].names]
+    dataset = dataset.map(
+        lambda x: {"text_label": [classes[label] for label in x["Label"]]},
+        batched=True,
+        num_proc=1,
+    )
+
+    tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)
+    target_max_length = max(len(tokenizer(class_label)["input_ids"]) for class_label in classes)
+
+    def preprocess_function(examples):
+        inputs = examples[text_column]
+        targets = examples[label_column]
+        model_inputs = tokenizer(inputs, truncation=True)
+        labels = tokenizer(
+            targets, max_length=target_max_length, padding="max_length", truncation=True, return_tensors="pt"
+        )
+        labels = labels["input_ids"]
+        labels[labels == tokenizer.pad_token_id] = -100
+        model_inputs["labels"] = labels
+        return model_inputs
+
+    with accelerator.main_process_first():
+        processed_datasets = dataset.map(
+            preprocess_function,
+            batched=True,
+            num_proc=1,
+            remove_columns=dataset["train"].column_names,
+            load_from_cache_file=True,
+            desc="Running tokenizer on dataset",
+        )
+    accelerator.wait_for_everyone()
+
+    train_dataset = processed_datasets["train"]
+    eval_dataset = processed_datasets["train"]
+    test_dataset = processed_datasets["test"]
+
+    def collate_fn(examples):
+        return tokenizer.pad(examples, padding="longest", return_tensors="pt")
+
+    train_dataloader = DataLoader(
+        train_dataset, shuffle=True, collate_fn=collate_fn, batch_size=batch_size, pin_memory=True
+    )
+    eval_dataloader = DataLoader(eval_dataset, collate_fn=collate_fn, batch_size=batch_size, pin_memory=True)
+    test_dataloader = DataLoader(test_dataset, collate_fn=collate_fn, batch_size=batch_size, pin_memory=True)
+
+    # creating model
+    model = AutoModelForSeq2SeqLM.from_pretrained(model_name_or_path)
+    model = get_peft_model(model, peft_config)
+    model.print_trainable_parameters()
+
+    # optimizer
+    optimizer = torch.optim.AdamW(model.parameters(), lr=lr)
+
+    # lr scheduler
+    lr_scheduler = get_linear_schedule_with_warmup(
+        optimizer=optimizer,
+        num_warmup_steps=0,
+        num_training_steps=(len(train_dataloader) * num_epochs),
+    )
+
+    model, train_dataloader, eval_dataloader, test_dataloader, optimizer, lr_scheduler = accelerator.prepare(
+        model, train_dataloader, eval_dataloader, test_dataloader, optimizer, lr_scheduler
+    )
+    accelerator.print(model)
+
+    is_ds_zero_3 = False
+    if getattr(accelerator.state, "deepspeed_plugin", None):
+        is_ds_zero_3 = accelerator.state.deepspeed_plugin.zero_stage == 3
+
+    for epoch in range(num_epochs):
+        with TorchTracemalloc() as tracemalloc:
+            model.train()
+            total_loss = 0
+            for step, batch in enumerate(tqdm(train_dataloader)):
+                outputs = model(**batch)
+                loss = outputs.loss
+                total_loss += loss.detach().float()
+                accelerator.backward(loss)
+                optimizer.step()
+                lr_scheduler.step()
+                optimizer.zero_grad()
+        # Printing the device memory usage details such as allocated memory, peak memory, and total memory usage
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Memory before entering the train : {b2mb(tracemalloc.begin)}"
+        )
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Memory consumed at the end of the train (end-begin): {tracemalloc.used}"
+        )
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Peak Memory consumed during the train (max-begin): {tracemalloc.peaked}"
+        )
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Total Peak Memory consumed during the train (max): {tracemalloc.peaked + b2mb(tracemalloc.begin)}"
+        )
+
+        accelerator.print(f"CPU Memory before entering the train : {b2mb(tracemalloc.cpu_begin)}")
+        accelerator.print(f"CPU Memory consumed at the end of the train (end-begin): {tracemalloc.cpu_used}")
+        accelerator.print(f"CPU Peak Memory consumed during the train (max-begin): {tracemalloc.cpu_peaked}")
+        accelerator.print(
+            f"CPU Total Peak Memory consumed during the train (max): {tracemalloc.cpu_peaked + b2mb(tracemalloc.cpu_begin)}"
+        )
+        train_epoch_loss = total_loss / len(train_dataloader)
+        train_ppl = torch.exp(train_epoch_loss)
+        accelerator.print(f"{epoch=}: {train_ppl=} {train_epoch_loss=}")
+
+        model.eval()
+        eval_preds = []
+        with TorchTracemalloc() as tracemalloc:
+            for _, batch in enumerate(tqdm(eval_dataloader)):
+                batch = {k: v for k, v in batch.items() if k != "labels"}
+                with torch.no_grad():
+                    outputs = accelerator.unwrap_model(model).generate(
+                        **batch, synced_gpus=is_ds_zero_3
+                    )  # synced_gpus=True for DS-stage 3
+                outputs = accelerator.pad_across_processes(outputs, dim=1, pad_index=tokenizer.pad_token_id)
+                preds = accelerator.gather_for_metrics(outputs).detach().cpu().numpy()
+                eval_preds.extend(tokenizer.batch_decode(preds, skip_special_tokens=True))
+
+        # Printing the device memory usage details such as allocated memory, peak memory, and total memory usage
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Memory before entering the eval : {b2mb(tracemalloc.begin)}"
+        )
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Memory consumed at the end of the eval (end-begin): {tracemalloc.used}"
+        )
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Peak Memory consumed during the eval (max-begin): {tracemalloc.peaked}"
+        )
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Total Peak Memory consumed during the eval (max): {tracemalloc.peaked + b2mb(tracemalloc.begin)}"
+        )
+
+        accelerator.print(f"CPU Memory before entering the eval : {b2mb(tracemalloc.cpu_begin)}")
+        accelerator.print(f"CPU Memory consumed at the end of the eval (end-begin): {tracemalloc.cpu_used}")
+        accelerator.print(f"CPU Peak Memory consumed during the eval (max-begin): {tracemalloc.cpu_peaked}")
+        accelerator.print(
+            f"CPU Total Peak Memory consumed during the eval (max): {tracemalloc.cpu_peaked + b2mb(tracemalloc.cpu_begin)}"
+        )
+
+        correct = 0
+        total = 0
+        assert len(eval_preds) == len(dataset["train"][label_column]), (
+            f"{len(eval_preds)} != {len(dataset['train'][label_column])}"
+        )
+        for pred, true in zip(eval_preds, dataset["train"][label_column]):
+            if pred.strip() == true.strip():
+                correct += 1
+            total += 1
+        accuracy = correct / total * 100
+        accelerator.print(f"{accuracy=}")
+        accelerator.print(f"{eval_preds[:10]=}")
+        accelerator.print(f"{dataset['train'][label_column][:10]=}")
+
+    if do_test:
+        model.eval()
+        test_preds = []
+        for _, batch in enumerate(tqdm(test_dataloader)):
+            batch = {k: v for k, v in batch.items() if k != "labels"}
+            with torch.no_grad():
+                outputs = accelerator.unwrap_model(model).generate(
+                    **batch, synced_gpus=is_ds_zero_3
+                )  # synced_gpus=True for DS-stage 3
+            outputs = accelerator.pad_across_processes(outputs, dim=1, pad_index=tokenizer.pad_token_id)
+            preds = accelerator.gather(outputs).detach().cpu().numpy()
+            test_preds.extend(tokenizer.batch_decode(preds, skip_special_tokens=True))
+
+        test_preds_cleaned = []
+        for _, pred in enumerate(test_preds):
+            test_preds_cleaned.append(get_closest_label(pred, classes))
+
+        test_df = dataset["test"].to_pandas()
+        assert len(test_preds_cleaned) == len(test_df), f"{len(test_preds_cleaned)} != {len(test_df)}"
+        test_df[label_column] = test_preds_cleaned
+        test_df["text_labels_orig"] = test_preds
+        accelerator.print(test_df[[text_column, label_column]].sample(20))
+
+        pred_df = test_df[["ID", label_column]]
+        pred_df.columns = ["ID", "Label"]
+
+        os.makedirs(f"data/{dataset_name}", exist_ok=True)
+        pred_df.to_csv(f"data/{dataset_name}/predictions.csv", index=False)
+
+    accelerator.wait_for_everyone()
+    # Option1: Pushing the model to Hugging Face Hub
+    # model.push_to_hub(
+    #     f"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}".replace("/", "_"),
+    #     token = "hf_..."
+    # )
+    # token (`bool` or `str`, *optional*):
+    #     `token` is to be used for HTTP Bearer authorization when accessing remote files. If `True`, will use the token generated
+    #     when running `huggingface-cli login` (stored in `~/.huggingface`). Will default to `True` if `repo_url`
+    #     is not specified.
+    #     Or you can get your token from https://huggingface.co/settings/token
+
+    # Option2: Saving the model locally
+    peft_model_id = f"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}".replace(
+        "/", "_"
+    )
+    model.save_pretrained(peft_model_id)
+    accelerator.wait_for_everyone()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/conditional_generation/peft_lora_seq2seq_accelerate_fsdp.py b/examples/conditional_generation/peft_lora_seq2seq_accelerate_fsdp.py
new file mode 100644
index 0000000..9c60fd8
--- /dev/null
+++ b/examples/conditional_generation/peft_lora_seq2seq_accelerate_fsdp.py
@@ -0,0 +1,145 @@
+import os
+
+import torch
+from accelerate import Accelerator
+from datasets import load_dataset
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, default_data_collator, get_linear_schedule_with_warmup
+
+from peft import LoraConfig, TaskType, get_peft_model
+from peft.utils.other import fsdp_auto_wrap_policy
+
+
+def main():
+    accelerator = Accelerator()
+    model_name_or_path = "t5-base"
+    batch_size = 8
+    text_column = "sentence"
+    label_column = "label"
+    max_length = 64
+    lr = 1e-3
+    num_epochs = 1
+    base_path = "temp/data/FinancialPhraseBank-v1.0"
+
+    peft_config = LoraConfig(
+        task_type=TaskType.SEQ_2_SEQ_LM, inference_mode=False, r=8, lora_alpha=32, lora_dropout=0.1
+    )
+    model = AutoModelForSeq2SeqLM.from_pretrained(model_name_or_path)
+    model = get_peft_model(model, peft_config)
+    accelerator.print(model.print_trainable_parameters())
+
+    dataset = load_dataset(
+        "json",
+        data_files={
+            "train": os.path.join(base_path, "financial_phrase_bank_train.jsonl"),
+            "validation": os.path.join(base_path, "financial_phrase_bank_val.jsonl"),
+        },
+    )
+
+    tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)
+
+    def preprocess_function(examples):
+        inputs = examples[text_column]
+        targets = examples[label_column]
+        model_inputs = tokenizer(
+            inputs, max_length=max_length, padding="max_length", truncation=True, return_tensors="pt"
+        )
+        labels = tokenizer(targets, max_length=2, padding="max_length", truncation=True, return_tensors="pt")
+        labels = labels["input_ids"]
+        labels[labels == tokenizer.pad_token_id] = -100
+        model_inputs["labels"] = labels
+        return model_inputs
+
+    with accelerator.main_process_first():
+        processed_datasets = dataset.map(
+            preprocess_function,
+            batched=True,
+            num_proc=1,
+            remove_columns=dataset["train"].column_names,
+            load_from_cache_file=False,
+            desc="Running tokenizer on dataset",
+        )
+
+    train_dataset = processed_datasets["train"]
+    eval_dataset = processed_datasets["validation"]
+
+    train_dataloader = DataLoader(
+        train_dataset, shuffle=True, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True
+    )
+    eval_dataloader = DataLoader(
+        eval_dataset, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True
+    )
+
+    optimizer = torch.optim.AdamW(model.parameters(), lr=lr)
+    lr_scheduler = get_linear_schedule_with_warmup(
+        optimizer=optimizer,
+        num_warmup_steps=0,
+        num_training_steps=(len(train_dataloader) * num_epochs),
+    )
+
+    if getattr(accelerator.state, "fsdp_plugin", None) is not None:
+        accelerator.state.fsdp_plugin.auto_wrap_policy = fsdp_auto_wrap_policy(model)
+
+    model, train_dataloader, eval_dataloader, optimizer, lr_scheduler = accelerator.prepare(
+        model, train_dataloader, eval_dataloader, optimizer, lr_scheduler
+    )
+    accelerator.print(model)
+
+    for epoch in range(num_epochs):
+        model.train()
+        total_loss = 0
+        for step, batch in enumerate(tqdm(train_dataloader)):
+            outputs = model(**batch)
+            loss = outputs.loss
+            total_loss += loss.detach().float()
+            loss.backward()
+            optimizer.step()
+            lr_scheduler.step()
+            optimizer.zero_grad()
+
+        model.eval()
+        eval_loss = 0
+        eval_preds = []
+        for step, batch in enumerate(tqdm(eval_dataloader)):
+            with torch.no_grad():
+                outputs = model(**batch)
+            loss = outputs.loss
+            eval_loss += loss.detach().float()
+            preds = accelerator.gather_for_metrics(torch.argmax(outputs.logits, -1)).detach().cpu().numpy()
+            eval_preds.extend(tokenizer.batch_decode(preds, skip_special_tokens=True))
+        eval_epoch_loss = eval_loss / len(eval_dataloader)
+        eval_ppl = torch.exp(eval_epoch_loss)
+        train_epoch_loss = total_loss / len(train_dataloader)
+        train_ppl = torch.exp(train_epoch_loss)
+        accelerator.print(f"{epoch=}: {train_ppl=} {train_epoch_loss=} {eval_ppl=} {eval_epoch_loss=}")
+
+        correct = 0
+        total = 0
+        for pred, true in zip(eval_preds, dataset["validation"][label_column]):
+            if pred.strip() == true.strip():
+                correct += 1
+            total += 1
+        accuracy = correct / total * 100
+        accelerator.print(f"{accuracy=}")
+        accelerator.print(f"{eval_preds[:10]=}")
+        accelerator.print(f"{dataset['validation'][label_column][:10]=}")
+        accelerator.wait_for_everyone()
+        # Option1: Pushing the model to Hugging Face Hub
+        # model.push_to_hub(
+        #     f"{dataset_name}_{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}".replace("/", "_"),
+        #     token = "hf_..."
+        # )
+        # token (`bool` or `str`, *optional*):
+        #     `token` is to be used for HTTP Bearer authorization when accessing remote files. If `True`, will use the token generated
+        #     when running `huggingface-cli login` (stored in `~/.huggingface`). Will default to `True` if `repo_url`
+        #     is not specified.
+        #     Or you can get your token from https://huggingface.co/settings/token
+        # Option2: Saving the model locally
+        peft_model_id = f"{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}".replace("/", "_")
+        model.save_pretrained(peft_model_id)
+        accelerator.wait_for_everyone()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/conditional_generation/peft_prefix_tuning_seq2seq.ipynb b/examples/conditional_generation/peft_prefix_tuning_seq2seq.ipynb
new file mode 100755
index 0000000..9bcc08b
--- /dev/null
+++ b/examples/conditional_generation/peft_prefix_tuning_seq2seq.ipynb
@@ -0,0 +1,404 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5f93b7d1",
+   "metadata": {},
+   "outputs": [],
+   "source": "from transformers import AutoModelForSeq2SeqLM\nfrom peft import get_peft_config, get_peft_model, get_peft_model_state_dict, PrefixTuningConfig, TaskType\nimport torch\nfrom datasets import load_dataset\nimport os\n\nos.environ[\"TOKENIZERS_PARALLELISM\"] = \"false\"\nfrom transformers import AutoTokenizer\nfrom torch.utils.data import DataLoader\nfrom transformers import default_data_collator, get_linear_schedule_with_warmup\nfrom tqdm import tqdm\nfrom datasets import load_dataset\n\ndevice = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\nmodel_name_or_path = \"t5-large\"\ntokenizer_name_or_path = \"t5-large\"\n\ntext_column = \"text\"\nlabel_column = \"text_label\"\nmax_length = 128\nlr = 1e-2\nnum_epochs = 5\nbatch_size = 8"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "8d0850ac",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# creating model\n",
+    "peft_config = PrefixTuningConfig(task_type=TaskType.SEQ_2_SEQ_LM, inference_mode=False, num_virtual_tokens=20)\n",
+    "\n",
+    "model = AutoModelForSeq2SeqLM.from_pretrained(model_name_or_path)\n",
+    "model = get_peft_model(model, peft_config)\n",
+    "model.print_trainable_parameters()\n",
+    "model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "4ee2babf",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using the latest cached version of the dataset since financial_phrasebank couldn't be found on the Hugging Face Hub\n",
+      "Found the latest cached dataset configuration 'sentences_allagree' at /root/.cache/huggingface/datasets/financial_phrasebank/sentences_allagree/1.0.0/550bde12e6c30e2674da973a55f57edde5181d53f5a5a34c1531c53f93b7e141 (last modified on Thu Jul 31 06:23:15 2025).\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "3b321971d6f942418bd5ef6105a1aa65",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map:   0%|          | 0/2037 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "5997543529a849bf97719e59a5ec95b2",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map:   0%|          | 0/227 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'sentence': \"Progress Group , QPR 's representative in Saudi Arabia and North Africa , has signed a framework agreement for a long term strategic relationship with ISE .\",\n",
+       " 'label': 2,\n",
+       " 'text_label': 'positive'}"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# loading dataset\n",
+    "dataset = load_dataset(\"zeroshot/twitter-financial-news-sentiment\")\n",
+    "dataset = dataset[\"train\"].train_test_split(test_size=0.1)\n",
+    "dataset[\"validation\"] = dataset[\"test\"]\n",
+    "del dataset[\"test\"]\n",
+    "\n",
+    "if hasattr(dataset[\"train\"].features[\"label\"], \"names\"):\n",
+    "    classes = dataset[\"train\"].features[\"label\"].names\n",
+    "else:\n",
+    "    classes = [\"Bearish\", \"Bullish\", \"Neutral\"]\n",
+    "dataset = dataset.map(\n",
+    "    lambda x: {\"text_label\": [classes[label] for label in x[\"label\"]]},\n",
+    "    batched=True,\n",
+    "    num_proc=1,\n",
+    ")\n",
+    "\n",
+    "dataset[\"train\"][0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "adf9608c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ee9bf13a2e3f4812a51a87346a4614f3",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "spiece.model:   0%|          | 0.00/792k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "332fcaa33dc343e7a20b24cec7ec97e9",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "tokenizer.json:   0%|          | 0.00/1.39M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a2135262c7a44377b35fe32b8d86d6c6",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Running tokenizer on dataset:   0%|          | 0/2037 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "dc8598b160484939b27c65be001c694c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Running tokenizer on dataset:   0%|          | 0/227 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# data preprocessing\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)\n",
+    "\n",
+    "\n",
+    "def preprocess_function(examples):\n",
+    "    inputs = examples[text_column]\n",
+    "    targets = examples[label_column]\n",
+    "    model_inputs = tokenizer(inputs, max_length=max_length, padding=\"max_length\", truncation=True, return_tensors=\"pt\")\n",
+    "    labels = tokenizer(targets, max_length=2, padding=\"max_length\", truncation=True, return_tensors=\"pt\")\n",
+    "    labels = labels[\"input_ids\"]\n",
+    "    labels[labels == tokenizer.pad_token_id] = -100\n",
+    "    model_inputs[\"labels\"] = labels\n",
+    "    return model_inputs\n",
+    "\n",
+    "\n",
+    "processed_datasets = dataset.map(\n",
+    "    preprocess_function,\n",
+    "    batched=True,\n",
+    "    num_proc=1,\n",
+    "    remove_columns=dataset[\"train\"].column_names,\n",
+    "    load_from_cache_file=False,\n",
+    "    desc=\"Running tokenizer on dataset\",\n",
+    ")\n",
+    "\n",
+    "train_dataset = processed_datasets[\"train\"]\n",
+    "eval_dataset = processed_datasets[\"validation\"]\n",
+    "\n",
+    "train_dataloader = DataLoader(\n",
+    "    train_dataset, shuffle=True, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True\n",
+    ")\n",
+    "eval_dataloader = DataLoader(eval_dataset, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "f733a3c6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# optimizer and lr scheduler\n",
+    "optimizer = torch.optim.AdamW(model.parameters(), lr=lr)\n",
+    "lr_scheduler = get_linear_schedule_with_warmup(\n",
+    "    optimizer=optimizer,\n",
+    "    num_warmup_steps=0,\n",
+    "    num_training_steps=(len(train_dataloader) * num_epochs),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6b3a4090",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# training and evaluation\n",
+    "model = model.to(device)\n",
+    "\n",
+    "for epoch in range(num_epochs):\n",
+    "    model.train()\n",
+    "    total_loss = 0\n",
+    "    for step, batch in enumerate(tqdm(train_dataloader)):\n",
+    "        batch = {k: v.to(device) for k, v in batch.items()}\n",
+    "        outputs = model(**batch)\n",
+    "        loss = outputs.loss\n",
+    "        total_loss += loss.detach().float()\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        lr_scheduler.step()\n",
+    "        optimizer.zero_grad()\n",
+    "\n",
+    "    model.eval()\n",
+    "    eval_loss = 0\n",
+    "    eval_preds = []\n",
+    "    for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+    "        batch = {k: v.to(device) for k, v in batch.items()}\n",
+    "        with torch.no_grad():\n",
+    "            outputs = model(**batch)\n",
+    "        loss = outputs.loss\n",
+    "        eval_loss += loss.detach().float()\n",
+    "        eval_preds.extend(\n",
+    "            tokenizer.batch_decode(torch.argmax(outputs.logits, -1).detach().cpu().numpy(), skip_special_tokens=True)\n",
+    "        )\n",
+    "\n",
+    "    eval_epoch_loss = eval_loss / len(eval_dataloader)\n",
+    "    eval_ppl = torch.exp(eval_epoch_loss)\n",
+    "    train_epoch_loss = total_loss / len(train_dataloader)\n",
+    "    train_ppl = torch.exp(train_epoch_loss)\n",
+    "    print(f\"{epoch=}: {train_ppl=} {train_epoch_loss=} {eval_ppl=} {eval_epoch_loss=}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "6cafa67b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "accuracy=96.91629955947137 % on the evaluation dataset\n",
+      "eval_preds[:10]=['negative', 'positive', 'neutral', 'neutral', 'neutral', 'neutral', 'neutral', 'neutral', 'neutral', 'neutral']\n",
+      "dataset['validation']['text_label'][:10]=['negative', 'neutral', 'neutral', 'neutral', 'neutral', 'neutral', 'neutral', 'neutral', 'neutral', 'neutral']\n"
+     ]
+    }
+   ],
+   "source": [
+    "# print accuracy\n",
+    "correct = 0\n",
+    "total = 0\n",
+    "for pred, true in zip(eval_preds, dataset[\"validation\"][\"text_label\"]):\n",
+    "    if pred.strip() == true.strip():\n",
+    "        correct += 1\n",
+    "    total += 1\n",
+    "accuracy = correct / total * 100\n",
+    "print(f\"{accuracy=} % on the evaluation dataset\")\n",
+    "print(f\"{eval_preds[:10]=}\")\n",
+    "print(f\"{dataset['validation']['text_label'][:10]=}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "a8de6005",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# saving model\n",
+    "peft_model_id = f\"{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\"\n",
+    "model.save_pretrained(peft_model_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bd20cd4c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3,8M\tt5-large_PREFIX_TUNING_SEQ_2_SEQ_LM/adapter_model.safetensors\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "ckpt = f\"{peft_model_id}/adapter_model.safetensors\"\n",
+    "!du -h $ckpt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "76c2fc29",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from peft import PeftModel, PeftConfig\n",
+    "\n",
+    "peft_model_id = f\"{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\"\n",
+    "\n",
+    "config = PeftConfig.from_pretrained(peft_model_id)\n",
+    "model = AutoModelForSeq2SeqLM.from_pretrained(config.base_model_name_or_path)\n",
+    "model = PeftModel.from_pretrained(model, peft_model_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "d997f1cc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Acando AB ( ACANB SS ) fell 8.9 percent to 13.35 kronor , the lowest close since Dec. 11 .\n",
+      "{'input_ids': tensor([[ 4292,   232,    32,     3,  5359,    41,     3, 22029, 14972,     3,\n",
+      "          4256,     3,    61,  4728,  4848,  1298,  1093,    12,  8808,  2469,\n",
+      "             3, 22318,    29,   127,     3,     6,     8,  7402,   885,   437,\n",
+      "          4451,     5,   850,     3,     5,     1]]), 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
+      "         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])}\n",
+      "tensor([[   0, 2841,    1]])\n",
+      "['negative']\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.eval()\n",
+    "i = 107\n",
+    "inputs = tokenizer(dataset[\"validation\"][text_column][i], return_tensors=\"pt\")\n",
+    "print(dataset[\"validation\"][text_column][i])\n",
+    "print(inputs)\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    outputs = model.generate(input_ids=inputs[\"input_ids\"], max_new_tokens=10)\n",
+    "    print(outputs)\n",
+    "    print(tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fb746c1e",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/conditional_generation/peft_prompt_tuning_seq2seq.ipynb b/examples/conditional_generation/peft_prompt_tuning_seq2seq.ipynb
new file mode 100755
index 0000000..a79f0f6
--- /dev/null
+++ b/examples/conditional_generation/peft_prompt_tuning_seq2seq.ipynb
@@ -0,0 +1,633 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5f93b7d1",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-05-30T08:37:58.711225Z",
+     "start_time": "2023-05-30T08:37:56.881307Z"
+    }
+   },
+   "outputs": [],
+   "source": "import os\n\nimport torch\nfrom transformers import AutoModelForSeq2SeqLM, AutoTokenizer, default_data_collator, get_linear_schedule_with_warmup\nfrom peft import get_peft_model, PromptTuningConfig, TaskType, PromptTuningInit\nfrom torch.utils.data import DataLoader\nfrom tqdm import tqdm\nfrom datasets import load_dataset\n\nos.environ[\"TOKENIZERS_PARALLELISM\"] = \"false\"\n\ndevice = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\nmodel_name_or_path = \"t5-large\"\ntokenizer_name_or_path = \"t5-large\"\n\ntext_column = \"text\"\nlabel_column = \"text_label\"\nmax_length = 128\nlr = 1\nnum_epochs = 5\nbatch_size = 8"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "8d0850ac",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-05-30T08:38:12.413984Z",
+     "start_time": "2023-05-30T08:38:04.601042Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "trainable params: 40,960 || all params: 737,709,056 || trainable%: 0.0056\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "PeftModelForSeq2SeqLM(\n",
+       "  (base_model): T5ForConditionalGeneration(\n",
+       "    (shared): Embedding(32128, 1024)\n",
+       "    (encoder): T5Stack(\n",
+       "      (embed_tokens): Embedding(32128, 1024)\n",
+       "      (block): ModuleList(\n",
+       "        (0): T5Block(\n",
+       "          (layer): ModuleList(\n",
+       "            (0): T5LayerSelfAttention(\n",
+       "              (SelfAttention): T5Attention(\n",
+       "                (q): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (k): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (v): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (o): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (relative_attention_bias): Embedding(32, 16)\n",
+       "              )\n",
+       "              (layer_norm): T5LayerNorm()\n",
+       "              (dropout): Dropout(p=0.1, inplace=False)\n",
+       "            )\n",
+       "            (1): T5LayerFF(\n",
+       "              (DenseReluDense): T5DenseActDense(\n",
+       "                (wi): Linear(in_features=1024, out_features=4096, bias=False)\n",
+       "                (wo): Linear(in_features=4096, out_features=1024, bias=False)\n",
+       "                (dropout): Dropout(p=0.1, inplace=False)\n",
+       "                (act): ReLU()\n",
+       "              )\n",
+       "              (layer_norm): T5LayerNorm()\n",
+       "              (dropout): Dropout(p=0.1, inplace=False)\n",
+       "            )\n",
+       "          )\n",
+       "        )\n",
+       "        (1-23): 23 x T5Block(\n",
+       "          (layer): ModuleList(\n",
+       "            (0): T5LayerSelfAttention(\n",
+       "              (SelfAttention): T5Attention(\n",
+       "                (q): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (k): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (v): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (o): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              )\n",
+       "              (layer_norm): T5LayerNorm()\n",
+       "              (dropout): Dropout(p=0.1, inplace=False)\n",
+       "            )\n",
+       "            (1): T5LayerFF(\n",
+       "              (DenseReluDense): T5DenseActDense(\n",
+       "                (wi): Linear(in_features=1024, out_features=4096, bias=False)\n",
+       "                (wo): Linear(in_features=4096, out_features=1024, bias=False)\n",
+       "                (dropout): Dropout(p=0.1, inplace=False)\n",
+       "                (act): ReLU()\n",
+       "              )\n",
+       "              (layer_norm): T5LayerNorm()\n",
+       "              (dropout): Dropout(p=0.1, inplace=False)\n",
+       "            )\n",
+       "          )\n",
+       "        )\n",
+       "      )\n",
+       "      (final_layer_norm): T5LayerNorm()\n",
+       "      (dropout): Dropout(p=0.1, inplace=False)\n",
+       "    )\n",
+       "    (decoder): T5Stack(\n",
+       "      (embed_tokens): Embedding(32128, 1024)\n",
+       "      (block): ModuleList(\n",
+       "        (0): T5Block(\n",
+       "          (layer): ModuleList(\n",
+       "            (0): T5LayerSelfAttention(\n",
+       "              (SelfAttention): T5Attention(\n",
+       "                (q): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (k): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (v): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (o): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (relative_attention_bias): Embedding(32, 16)\n",
+       "              )\n",
+       "              (layer_norm): T5LayerNorm()\n",
+       "              (dropout): Dropout(p=0.1, inplace=False)\n",
+       "            )\n",
+       "            (1): T5LayerCrossAttention(\n",
+       "              (EncDecAttention): T5Attention(\n",
+       "                (q): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (k): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (v): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (o): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              )\n",
+       "              (layer_norm): T5LayerNorm()\n",
+       "              (dropout): Dropout(p=0.1, inplace=False)\n",
+       "            )\n",
+       "            (2): T5LayerFF(\n",
+       "              (DenseReluDense): T5DenseActDense(\n",
+       "                (wi): Linear(in_features=1024, out_features=4096, bias=False)\n",
+       "                (wo): Linear(in_features=4096, out_features=1024, bias=False)\n",
+       "                (dropout): Dropout(p=0.1, inplace=False)\n",
+       "                (act): ReLU()\n",
+       "              )\n",
+       "              (layer_norm): T5LayerNorm()\n",
+       "              (dropout): Dropout(p=0.1, inplace=False)\n",
+       "            )\n",
+       "          )\n",
+       "        )\n",
+       "        (1-23): 23 x T5Block(\n",
+       "          (layer): ModuleList(\n",
+       "            (0): T5LayerSelfAttention(\n",
+       "              (SelfAttention): T5Attention(\n",
+       "                (q): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (k): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (v): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (o): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              )\n",
+       "              (layer_norm): T5LayerNorm()\n",
+       "              (dropout): Dropout(p=0.1, inplace=False)\n",
+       "            )\n",
+       "            (1): T5LayerCrossAttention(\n",
+       "              (EncDecAttention): T5Attention(\n",
+       "                (q): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (k): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (v): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (o): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              )\n",
+       "              (layer_norm): T5LayerNorm()\n",
+       "              (dropout): Dropout(p=0.1, inplace=False)\n",
+       "            )\n",
+       "            (2): T5LayerFF(\n",
+       "              (DenseReluDense): T5DenseActDense(\n",
+       "                (wi): Linear(in_features=1024, out_features=4096, bias=False)\n",
+       "                (wo): Linear(in_features=4096, out_features=1024, bias=False)\n",
+       "                (dropout): Dropout(p=0.1, inplace=False)\n",
+       "                (act): ReLU()\n",
+       "              )\n",
+       "              (layer_norm): T5LayerNorm()\n",
+       "              (dropout): Dropout(p=0.1, inplace=False)\n",
+       "            )\n",
+       "          )\n",
+       "        )\n",
+       "      )\n",
+       "      (final_layer_norm): T5LayerNorm()\n",
+       "      (dropout): Dropout(p=0.1, inplace=False)\n",
+       "    )\n",
+       "    (lm_head): Linear(in_features=1024, out_features=32128, bias=False)\n",
+       "  )\n",
+       "  (prompt_encoder): ModuleDict(\n",
+       "    (default): PromptEmbedding(\n",
+       "      (embedding): Embedding(40, 1024)\n",
+       "    )\n",
+       "  )\n",
+       "  (word_embeddings): Embedding(32128, 1024)\n",
+       ")"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# creating model\n",
+    "peft_config = PromptTuningConfig(\n",
+    "    task_type=TaskType.SEQ_2_SEQ_LM,\n",
+    "    prompt_tuning_init=PromptTuningInit.TEXT,\n",
+    "    num_virtual_tokens=20,\n",
+    "    prompt_tuning_init_text=\"What is the sentiment of this article?\\n\",\n",
+    "    inference_mode=False,\n",
+    "    tokenizer_name_or_path=model_name_or_path,\n",
+    ")\n",
+    "\n",
+    "model = AutoModelForSeq2SeqLM.from_pretrained(model_name_or_path)\n",
+    "model = get_peft_model(model, peft_config)\n",
+    "model.print_trainable_parameters()\n",
+    "model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "4ee2babf",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-05-30T08:38:18.759143Z",
+     "start_time": "2023-05-30T08:38:17.881621Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using the latest cached version of the dataset since financial_phrasebank couldn't be found on the Hugging Face Hub\n",
+      "Found the latest cached dataset configuration 'sentences_allagree' at /root/.cache/huggingface/datasets/financial_phrasebank/sentences_allagree/1.0.0/550bde12e6c30e2674da973a55f57edde5181d53f5a5a34c1531c53f93b7e141 (last modified on Thu Jul 31 06:37:38 2025).\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2b64258700bd40548ddcd626f3920c9a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map:   0%|          | 0/2037 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d95de9b1dc3d417da35118c14d02b986",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map:   0%|          | 0/227 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'sentence': 'The 2500-passenger ferry will have dimensions of 185 m length overall , 170 m length between perpendiculars , 27.70 m breadth and 6.55 m design draught .',\n",
+       " 'label': 1,\n",
+       " 'text_label': 'neutral'}"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# loading dataset\n",
+    "dataset = load_dataset(\"zeroshot/twitter-financial-news-sentiment\")\n",
+    "dataset = dataset[\"train\"].train_test_split(test_size=0.1)\n",
+    "dataset[\"validation\"] = dataset[\"test\"]\n",
+    "del dataset[\"test\"]\n",
+    "\n",
+    "if hasattr(dataset[\"train\"].features[\"label\"], \"names\"):\n",
+    "    classes = dataset[\"train\"].features[\"label\"].names\n",
+    "else:\n",
+    "    classes = [\"Bearish\", \"Bullish\", \"Neutral\"]\n",
+    "dataset = dataset.map(\n",
+    "    lambda x: {\"text_label\": [classes[label] for label in x[\"label\"]]},\n",
+    "    batched=True,\n",
+    "    num_proc=1,\n",
+    ")\n",
+    "\n",
+    "dataset[\"train\"][0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "adf9608c",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-05-30T08:38:21.132266Z",
+     "start_time": "2023-05-30T08:38:20.340722Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a78b4b1a041546248b8e6703eaec0969",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Running tokenizer on dataset:   0%|          | 0/2037 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "bbe2962a25144b5488c297e186df824f",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Running tokenizer on dataset:   0%|          | 0/227 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# data preprocessing\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)\n",
+    "target_max_length = max([len(tokenizer(class_label)[\"input_ids\"]) for class_label in classes])\n",
+    "\n",
+    "\n",
+    "def preprocess_function(examples):\n",
+    "    inputs = examples[text_column]\n",
+    "    targets = examples[label_column]\n",
+    "    model_inputs = tokenizer(inputs, max_length=max_length, padding=\"max_length\", truncation=True, return_tensors=\"pt\")\n",
+    "    labels = tokenizer(\n",
+    "        targets, max_length=target_max_length, padding=\"max_length\", truncation=True, return_tensors=\"pt\"\n",
+    "    )\n",
+    "    labels = labels[\"input_ids\"]\n",
+    "    labels[labels == tokenizer.pad_token_id] = -100\n",
+    "    model_inputs[\"labels\"] = labels\n",
+    "    return model_inputs\n",
+    "\n",
+    "\n",
+    "processed_datasets = dataset.map(\n",
+    "    preprocess_function,\n",
+    "    batched=True,\n",
+    "    num_proc=1,\n",
+    "    remove_columns=dataset[\"train\"].column_names,\n",
+    "    load_from_cache_file=False,\n",
+    "    desc=\"Running tokenizer on dataset\",\n",
+    ")\n",
+    "\n",
+    "train_dataset = processed_datasets[\"train\"]\n",
+    "eval_dataset = processed_datasets[\"validation\"]\n",
+    "\n",
+    "train_dataloader = DataLoader(\n",
+    "    train_dataset, shuffle=True, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True\n",
+    ")\n",
+    "eval_dataloader = DataLoader(eval_dataset, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "f733a3c6",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-05-30T08:38:22.907922Z",
+     "start_time": "2023-05-30T08:38:22.901057Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# optimizer and lr scheduler\n",
+    "optimizer = torch.optim.AdamW(model.parameters(), lr=lr)\n",
+    "lr_scheduler = get_linear_schedule_with_warmup(\n",
+    "    optimizer=optimizer,\n",
+    "    num_warmup_steps=0,\n",
+    "    num_training_steps=(len(train_dataloader) * num_epochs),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6b3a4090",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-05-30T08:42:29.409070Z",
+     "start_time": "2023-05-30T08:38:50.102263Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# training and evaluation\n",
+    "model = model.to(device)\n",
+    "\n",
+    "for epoch in range(num_epochs):\n",
+    "    model.train()\n",
+    "    total_loss = 0\n",
+    "    for step, batch in enumerate(tqdm(train_dataloader)):\n",
+    "        batch = {k: v.to(device) for k, v in batch.items()}\n",
+    "        outputs = model(**batch)\n",
+    "        loss = outputs.loss\n",
+    "        total_loss += loss.detach().float()\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        lr_scheduler.step()\n",
+    "        optimizer.zero_grad()\n",
+    "\n",
+    "    model.eval()\n",
+    "    eval_loss = 0\n",
+    "    eval_preds = []\n",
+    "    for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+    "        batch = {k: v.to(device) for k, v in batch.items()}\n",
+    "        with torch.no_grad():\n",
+    "            outputs = model(**batch)\n",
+    "        loss = outputs.loss\n",
+    "        eval_loss += loss.detach().float()\n",
+    "        eval_preds.extend(\n",
+    "            tokenizer.batch_decode(torch.argmax(outputs.logits, -1).detach().cpu().numpy(), skip_special_tokens=True)\n",
+    "        )\n",
+    "\n",
+    "    eval_epoch_loss = eval_loss / len(eval_dataloader)\n",
+    "    eval_ppl = torch.exp(eval_epoch_loss)\n",
+    "    train_epoch_loss = total_loss / len(train_dataloader)\n",
+    "    train_ppl = torch.exp(train_epoch_loss)\n",
+    "    print(f\"{epoch=}: {train_ppl=} {train_epoch_loss=} {eval_ppl=} {eval_epoch_loss=}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "6cafa67b",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-05-30T08:42:42.844671Z",
+     "start_time": "2023-05-30T08:42:42.840447Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "accuracy=85.46255506607929 % on the evaluation dataset\n",
+      "eval_preds[:10]=['neutral', 'neutral', 'neutral', 'neutral', 'neutral', 'positive', 'neutral', 'negative', 'neutral', 'positive']\n",
+      "dataset['validation']['text_label'][:10]=['neutral', 'neutral', 'neutral', 'neutral', 'neutral', 'positive', 'neutral', 'negative', 'positive', 'neutral']\n"
+     ]
+    }
+   ],
+   "source": [
+    "# print accuracy\n",
+    "correct = 0\n",
+    "total = 0\n",
+    "for pred, true in zip(eval_preds, dataset[\"validation\"][\"text_label\"]):\n",
+    "    if pred.strip() == true.strip():\n",
+    "        correct += 1\n",
+    "    total += 1\n",
+    "accuracy = correct / total * 100\n",
+    "print(f\"{accuracy=} % on the evaluation dataset\")\n",
+    "print(f\"{eval_preds[:10]=}\")\n",
+    "print(f\"{dataset['validation']['text_label'][:10]=}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "a8de6005",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-05-30T08:42:45.752765Z",
+     "start_time": "2023-05-30T08:42:45.742397Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# saving model\n",
+    "peft_model_id = f\"{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\"\n",
+    "model.save_pretrained(peft_model_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bd20cd4c",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-05-30T08:42:47.660873Z",
+     "start_time": "2023-05-30T08:42:47.488293Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "164K\tt5-large_PROMPT_TUNING_SEQ_2_SEQ_LM/adapter_model.safetensors\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "ckpt = f\"{peft_model_id}/adapter_model.safetensors\"\n",
+    "!du -h $ckpt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "76c2fc29",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-05-30T08:42:56.721990Z",
+     "start_time": "2023-05-30T08:42:49.060700Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from peft import PeftModel, PeftConfig\n",
+    "\n",
+    "peft_model_id = f\"{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\"\n",
+    "\n",
+    "config = PeftConfig.from_pretrained(peft_model_id)\n",
+    "model = AutoModelForSeq2SeqLM.from_pretrained(config.base_model_name_or_path)\n",
+    "model = PeftModel.from_pretrained(model, peft_model_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "d997f1cc",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-05-30T08:42:59.600916Z",
+     "start_time": "2023-05-30T08:42:58.961468Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Danske Bank is Denmark 's largest bank with 3.5 million customers .\n",
+      "tensor([[ 3039,  1050,  1925,    19, 18001,     3,    31,     7,  2015,  2137,\n",
+      "            28,     3,  9285,   770,   722,     3,     5,     1]])\n",
+      "tensor([[   0, 7163,    1]])\n",
+      "['neutral']\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.eval()\n",
+    "i = 107\n",
+    "input_ids = tokenizer(dataset[\"validation\"][text_column][i], return_tensors=\"pt\").input_ids\n",
+    "print(dataset[\"validation\"][text_column][i])\n",
+    "print(input_ids)\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    outputs = model.generate(input_ids=input_ids, max_new_tokens=10)\n",
+    "    print(outputs)\n",
+    "    print(tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  },
+  "toc": {
+   "base_numbering": 1,
+   "nav_menu": {},
+   "number_sections": true,
+   "sideBar": true,
+   "skip_h1_title": false,
+   "title_cell": "Table of Contents",
+   "title_sidebar": "Contents",
+   "toc_cell": false,
+   "toc_position": {},
+   "toc_section_display": true,
+   "toc_window_display": false
+  },
+  "varInspector": {
+   "cols": {
+    "lenName": 16,
+    "lenType": 16,
+    "lenVar": 40
+   },
+   "kernels_config": {
+    "python": {
+     "delete_cmd_postfix": "",
+     "delete_cmd_prefix": "del ",
+     "library": "var_list.py",
+     "varRefreshCmd": "print(var_dic_list())"
+    },
+    "r": {
+     "delete_cmd_postfix": ") ",
+     "delete_cmd_prefix": "rm(",
+     "library": "var_list.r",
+     "varRefreshCmd": "cat(var_dic_list()) "
+    }
+   },
+   "types_to_exclude": [
+    "module",
+    "function",
+    "builtin_function_or_method",
+    "instance",
+    "_Feature"
+   ],
+   "window_display": false
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/conditional_generation/peft_prompt_tuning_seq2seq_with_generate.ipynb b/examples/conditional_generation/peft_prompt_tuning_seq2seq_with_generate.ipynb
new file mode 100644
index 0000000..95be106
--- /dev/null
+++ b/examples/conditional_generation/peft_prompt_tuning_seq2seq_with_generate.ipynb
@@ -0,0 +1,712 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5f93b7d1",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-05-30T09:49:56.334329Z",
+     "start_time": "2023-05-30T09:49:54.494916Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "import torch\n",
+    "from transformers import (\n",
+    "    AutoTokenizer,\n",
+    "    default_data_collator,\n",
+    "    AutoModelForSeq2SeqLM,\n",
+    "    Seq2SeqTrainingArguments,\n",
+    "    Seq2SeqTrainer,\n",
+    "    GenerationConfig,\n",
+    ")\n",
+    "from peft import get_peft_model, PromptTuningInit, PromptTuningConfig, TaskType\n",
+    "from datasets import load_dataset\n",
+    "\n",
+    "os.environ[\"TOKENIZERS_PARALLELISM\"] = \"false\"\n",
+    "\n",
+    "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "model_name_or_path = \"t5-large\"\n",
+    "tokenizer_name_or_path = \"t5-large\"\n",
+    "\n",
+    "checkpoint_name = \"financial_sentiment_analysis_prefix_tuning_v1.pt\"\n",
+    "text_column = \"sentence\"\n",
+    "label_column = \"text_label\"\n",
+    "max_length = 8\n",
+    "lr = 1e0\n",
+    "num_epochs = 5\n",
+    "batch_size = 8"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "8d0850ac",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-05-30T09:50:04.808527Z",
+     "start_time": "2023-05-30T09:49:56.953075Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "trainable params: 40,960 || all params: 737,709,056 || trainable%: 0.0056\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "PeftModelForSeq2SeqLM(\n",
+       "  (base_model): T5ForConditionalGeneration(\n",
+       "    (shared): Embedding(32128, 1024)\n",
+       "    (encoder): T5Stack(\n",
+       "      (embed_tokens): Embedding(32128, 1024)\n",
+       "      (block): ModuleList(\n",
+       "        (0): T5Block(\n",
+       "          (layer): ModuleList(\n",
+       "            (0): T5LayerSelfAttention(\n",
+       "              (SelfAttention): T5Attention(\n",
+       "                (q): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (k): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (v): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (o): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (relative_attention_bias): Embedding(32, 16)\n",
+       "              )\n",
+       "              (layer_norm): T5LayerNorm()\n",
+       "              (dropout): Dropout(p=0.1, inplace=False)\n",
+       "            )\n",
+       "            (1): T5LayerFF(\n",
+       "              (DenseReluDense): T5DenseActDense(\n",
+       "                (wi): Linear(in_features=1024, out_features=4096, bias=False)\n",
+       "                (wo): Linear(in_features=4096, out_features=1024, bias=False)\n",
+       "                (dropout): Dropout(p=0.1, inplace=False)\n",
+       "                (act): ReLU()\n",
+       "              )\n",
+       "              (layer_norm): T5LayerNorm()\n",
+       "              (dropout): Dropout(p=0.1, inplace=False)\n",
+       "            )\n",
+       "          )\n",
+       "        )\n",
+       "        (1-23): 23 x T5Block(\n",
+       "          (layer): ModuleList(\n",
+       "            (0): T5LayerSelfAttention(\n",
+       "              (SelfAttention): T5Attention(\n",
+       "                (q): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (k): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (v): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (o): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              )\n",
+       "              (layer_norm): T5LayerNorm()\n",
+       "              (dropout): Dropout(p=0.1, inplace=False)\n",
+       "            )\n",
+       "            (1): T5LayerFF(\n",
+       "              (DenseReluDense): T5DenseActDense(\n",
+       "                (wi): Linear(in_features=1024, out_features=4096, bias=False)\n",
+       "                (wo): Linear(in_features=4096, out_features=1024, bias=False)\n",
+       "                (dropout): Dropout(p=0.1, inplace=False)\n",
+       "                (act): ReLU()\n",
+       "              )\n",
+       "              (layer_norm): T5LayerNorm()\n",
+       "              (dropout): Dropout(p=0.1, inplace=False)\n",
+       "            )\n",
+       "          )\n",
+       "        )\n",
+       "      )\n",
+       "      (final_layer_norm): T5LayerNorm()\n",
+       "      (dropout): Dropout(p=0.1, inplace=False)\n",
+       "    )\n",
+       "    (decoder): T5Stack(\n",
+       "      (embed_tokens): Embedding(32128, 1024)\n",
+       "      (block): ModuleList(\n",
+       "        (0): T5Block(\n",
+       "          (layer): ModuleList(\n",
+       "            (0): T5LayerSelfAttention(\n",
+       "              (SelfAttention): T5Attention(\n",
+       "                (q): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (k): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (v): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (o): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (relative_attention_bias): Embedding(32, 16)\n",
+       "              )\n",
+       "              (layer_norm): T5LayerNorm()\n",
+       "              (dropout): Dropout(p=0.1, inplace=False)\n",
+       "            )\n",
+       "            (1): T5LayerCrossAttention(\n",
+       "              (EncDecAttention): T5Attention(\n",
+       "                (q): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (k): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (v): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (o): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              )\n",
+       "              (layer_norm): T5LayerNorm()\n",
+       "              (dropout): Dropout(p=0.1, inplace=False)\n",
+       "            )\n",
+       "            (2): T5LayerFF(\n",
+       "              (DenseReluDense): T5DenseActDense(\n",
+       "                (wi): Linear(in_features=1024, out_features=4096, bias=False)\n",
+       "                (wo): Linear(in_features=4096, out_features=1024, bias=False)\n",
+       "                (dropout): Dropout(p=0.1, inplace=False)\n",
+       "                (act): ReLU()\n",
+       "              )\n",
+       "              (layer_norm): T5LayerNorm()\n",
+       "              (dropout): Dropout(p=0.1, inplace=False)\n",
+       "            )\n",
+       "          )\n",
+       "        )\n",
+       "        (1-23): 23 x T5Block(\n",
+       "          (layer): ModuleList(\n",
+       "            (0): T5LayerSelfAttention(\n",
+       "              (SelfAttention): T5Attention(\n",
+       "                (q): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (k): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (v): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (o): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              )\n",
+       "              (layer_norm): T5LayerNorm()\n",
+       "              (dropout): Dropout(p=0.1, inplace=False)\n",
+       "            )\n",
+       "            (1): T5LayerCrossAttention(\n",
+       "              (EncDecAttention): T5Attention(\n",
+       "                (q): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (k): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (v): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "                (o): Linear(in_features=1024, out_features=1024, bias=False)\n",
+       "              )\n",
+       "              (layer_norm): T5LayerNorm()\n",
+       "              (dropout): Dropout(p=0.1, inplace=False)\n",
+       "            )\n",
+       "            (2): T5LayerFF(\n",
+       "              (DenseReluDense): T5DenseActDense(\n",
+       "                (wi): Linear(in_features=1024, out_features=4096, bias=False)\n",
+       "                (wo): Linear(in_features=4096, out_features=1024, bias=False)\n",
+       "                (dropout): Dropout(p=0.1, inplace=False)\n",
+       "                (act): ReLU()\n",
+       "              )\n",
+       "              (layer_norm): T5LayerNorm()\n",
+       "              (dropout): Dropout(p=0.1, inplace=False)\n",
+       "            )\n",
+       "          )\n",
+       "        )\n",
+       "      )\n",
+       "      (final_layer_norm): T5LayerNorm()\n",
+       "      (dropout): Dropout(p=0.1, inplace=False)\n",
+       "    )\n",
+       "    (lm_head): Linear(in_features=1024, out_features=32128, bias=False)\n",
+       "  )\n",
+       "  (prompt_encoder): ModuleDict(\n",
+       "    (default): PromptEmbedding(\n",
+       "      (embedding): Embedding(40, 1024)\n",
+       "    )\n",
+       "  )\n",
+       "  (word_embeddings): Embedding(32128, 1024)\n",
+       ")"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# creating model\n",
+    "peft_config = peft_config = PromptTuningConfig(\n",
+    "    task_type=TaskType.SEQ_2_SEQ_LM,\n",
+    "    prompt_tuning_init=PromptTuningInit.TEXT,\n",
+    "    num_virtual_tokens=20,\n",
+    "    prompt_tuning_init_text=\"What is the sentiment of this article?\\n\",\n",
+    "    inference_mode=False,\n",
+    "    tokenizer_name_or_path=model_name_or_path,\n",
+    ")\n",
+    "\n",
+    "model = AutoModelForSeq2SeqLM.from_pretrained(model_name_or_path)\n",
+    "model = get_peft_model(model, peft_config)\n",
+    "model.print_trainable_parameters()\n",
+    "model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "4ee2babf",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-05-30T09:50:09.224782Z",
+     "start_time": "2023-05-30T09:50:08.172611Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using the latest cached version of the dataset since financial_phrasebank couldn't be found on the Hugging Face Hub\n",
+      "Found the latest cached dataset configuration 'sentences_allagree' at /root/.cache/huggingface/datasets/financial_phrasebank/sentences_allagree/1.0.0/550bde12e6c30e2674da973a55f57edde5181d53f5a5a34c1531c53f93b7e141 (last modified on Thu Jul 31 06:43:45 2025).\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "79ef90cbad2f4c2088f01102cadb8a3b",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map:   0%|          | 0/2037 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "0f5b177b658646cfa90b3a2801138807",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map:   0%|          | 0/227 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'sentence': 'This new partnership agreement represents a significant milestone for both parties .',\n",
+       " 'label': 2,\n",
+       " 'text_label': 'positive'}"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# loading dataset\n",
+    "dataset = load_dataset(\"financial_phrasebank\", \"sentences_allagree\")\n",
+    "dataset = dataset[\"train\"].train_test_split(test_size=0.1)\n",
+    "dataset[\"validation\"] = dataset[\"test\"]\n",
+    "del dataset[\"test\"]\n",
+    "\n",
+    "classes = dataset[\"train\"].features[\"label\"].names\n",
+    "dataset = dataset.map(\n",
+    "    lambda x: {\"text_label\": [classes[label] for label in x[\"label\"]]},\n",
+    "    batched=True,\n",
+    "    num_proc=1,\n",
+    ")\n",
+    "\n",
+    "dataset[\"train\"][0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "adf9608c",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-05-30T09:50:12.176663Z",
+     "start_time": "2023-05-30T09:50:11.421273Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "0a5f7b5967704fab97f11bc07813625c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Running tokenizer on dataset:   0%|          | 0/2037 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "1ff9578c074e4736a8812f6ffc8138b5",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Running tokenizer on dataset:   0%|          | 0/227 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# data preprocessing\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)\n",
+    "\n",
+    "\n",
+    "def preprocess_function(examples):\n",
+    "    inputs = examples[text_column]\n",
+    "    targets = examples[label_column]\n",
+    "    model_inputs = tokenizer(inputs, max_length=max_length, padding=\"max_length\", truncation=True, return_tensors=\"pt\")\n",
+    "    labels = tokenizer(targets, max_length=2, padding=\"max_length\", truncation=True, return_tensors=\"pt\")\n",
+    "    labels = labels[\"input_ids\"]\n",
+    "    labels[labels == tokenizer.pad_token_id] = -100\n",
+    "    model_inputs[\"labels\"] = labels\n",
+    "    return model_inputs\n",
+    "\n",
+    "\n",
+    "processed_datasets = dataset.map(\n",
+    "    preprocess_function,\n",
+    "    batched=True,\n",
+    "    num_proc=1,\n",
+    "    remove_columns=dataset[\"train\"].column_names,\n",
+    "    load_from_cache_file=False,\n",
+    "    desc=\"Running tokenizer on dataset\",\n",
+    ")\n",
+    "\n",
+    "train_dataset = processed_datasets[\"train\"].shuffle()\n",
+    "eval_dataset = processed_datasets[\"validation\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "6b3a4090",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-05-30T09:53:10.336984Z",
+     "start_time": "2023-05-30T09:50:14.780995Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[W731 07:06:51.135038656 OperatorEntry.cpp:217] Warning: Warning only once for all operators,  other operators may also be overridden.\n",
+      "  Overriding a previously registered kernel for the same operator and the same dispatch key\n",
+      "  operator: aten::geometric_(Tensor(a!) self, float p, *, Generator? generator=None) -> Tensor(a!)\n",
+      "    registered at /pytorch/build/aten/src/ATen/RegisterSchema.cpp:6\n",
+      "  dispatch key: XPU\n",
+      "  previous kernel: registered at /pytorch/aten/src/ATen/VmapModeRegistrations.cpp:37\n",
+      "       new kernel: registered at /build/intel-pytorch-extension/build/Release/csrc/gpu/csrc/gpu/xpu/ATen/RegisterXPU_0.cpp:172 (function operator())\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2025-07-31 07:06:51,984] [INFO] [real_accelerator.py:254:get_accelerator] Setting ds_accelerator to xpu (auto detect)\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/bin/ld: cannot find -laio: No such file or directory\n",
+      "collect2: error: ld returned 1 exit status\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2025-07-31 07:06:52,955] [INFO] [logging.py:107:log_dist] [Rank -1] [TorchCheckpointEngine] Initialized with serialization = False\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "No label_names provided for model class `PeftModelForSeq2SeqLM`. Since `PeftModel` hides base models input arguments, if label_names is not given, label_names can't be set automatically within `Trainer`. Note that empty label_names list will be used instead.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "    <div>\n",
+       "      \n",
+       "      <progress value='1275' max='1275' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
+       "      [1275/1275 03:31, Epoch 5/5]\n",
+       "    </div>\n",
+       "    <table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       " <tr style=\"text-align: left;\">\n",
+       "      <th>Epoch</th>\n",
+       "      <th>Training Loss</th>\n",
+       "      <th>Validation Loss</th>\n",
+       "      <th>Accuracy</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <td>1</td>\n",
+       "      <td>2.169900</td>\n",
+       "      <td>0.507156</td>\n",
+       "      <td>0.621145</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>2</td>\n",
+       "      <td>0.537700</td>\n",
+       "      <td>0.430996</td>\n",
+       "      <td>0.651982</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>3</td>\n",
+       "      <td>0.482200</td>\n",
+       "      <td>0.426718</td>\n",
+       "      <td>0.696035</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>4</td>\n",
+       "      <td>0.459700</td>\n",
+       "      <td>0.470894</td>\n",
+       "      <td>0.682819</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>5</td>\n",
+       "      <td>0.436000</td>\n",
+       "      <td>0.409604</td>\n",
+       "      <td>0.718062</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table><p>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "TrainOutput(global_step=1275, training_loss=0.8170911183076747, metrics={'train_runtime': 213.5513, 'train_samples_per_second': 47.693, 'train_steps_per_second': 5.97, 'total_flos': 344546979840000.0, 'train_loss': 0.8170911183076747, 'epoch': 5.0})"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# training and evaluation\n",
+    "\n",
+    "\n",
+    "def compute_metrics(eval_preds):\n",
+    "    preds, labels = eval_preds\n",
+    "    preds = tokenizer.batch_decode(preds, skip_special_tokens=True)\n",
+    "    labels = tokenizer.batch_decode(labels, skip_special_tokens=True)\n",
+    "\n",
+    "    correct = 0\n",
+    "    total = 0\n",
+    "    for pred, true in zip(preds, labels):\n",
+    "        if pred.strip() == true.strip():\n",
+    "            correct += 1\n",
+    "        total += 1\n",
+    "    accuracy = correct / total\n",
+    "    return {\"accuracy\": accuracy}\n",
+    "\n",
+    "\n",
+    "training_args = Seq2SeqTrainingArguments(\n",
+    "    \"out\",\n",
+    "    per_device_train_batch_size=batch_size,\n",
+    "    learning_rate=lr,\n",
+    "    num_train_epochs=num_epochs,\n",
+    "    eval_strategy=\"epoch\",\n",
+    "    logging_strategy=\"epoch\",\n",
+    "    save_strategy=\"no\",\n",
+    "    report_to=[],\n",
+    "    predict_with_generate=True,\n",
+    "    generation_config=GenerationConfig(max_length=max_length),\n",
+    ")\n",
+    "trainer = Seq2SeqTrainer(\n",
+    "    model=model,\n",
+    "    processing_class=tokenizer,\n",
+    "    args=training_args,\n",
+    "    train_dataset=train_dataset,\n",
+    "    eval_dataset=eval_dataset,\n",
+    "    data_collator=default_data_collator,\n",
+    "    compute_metrics=compute_metrics,\n",
+    ")\n",
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "a8de6005",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-05-30T09:53:13.045146Z",
+     "start_time": "2023-05-30T09:53:13.035612Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# saving model\n",
+    "peft_model_id = f\"{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\"\n",
+    "model.save_pretrained(peft_model_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bd20cd4c",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-05-30T09:53:15.240763Z",
+     "start_time": "2023-05-30T09:53:15.059304Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "ckpt = f\"{peft_model_id}/adapter_model.safetensors\"\n",
+    "!du -h $ckpt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "76c2fc29",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-05-30T09:53:25.055105Z",
+     "start_time": "2023-05-30T09:53:17.797989Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from peft import PeftModel, PeftConfig\n",
+    "\n",
+    "peft_model_id = f\"{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\"\n",
+    "\n",
+    "config = PeftConfig.from_pretrained(peft_model_id)\n",
+    "model = AutoModelForSeq2SeqLM.from_pretrained(config.base_model_name_or_path)\n",
+    "model = PeftModel.from_pretrained(model, peft_model_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "d997f1cc",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-05-30T09:53:26.777030Z",
+     "start_time": "2023-05-30T09:53:26.013697Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "EPS grew to 0.04 eur from 0.02 eur .\n",
+      "{'input_ids': tensor([[    3, 24935,     3,  4774,    12,  4097,  6348,     3,  1238,    45,\n",
+      "          4097,  4305,     3,  1238,     3,     5,     1]]), 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])}\n",
+      "tensor([[   0, 1465,    1]])\n",
+      "['positive']\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.eval()\n",
+    "i = 107\n",
+    "inputs = tokenizer(dataset[\"validation\"][text_column][i], return_tensors=\"pt\")\n",
+    "print(dataset[\"validation\"][text_column][i])\n",
+    "print(inputs)\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    outputs = model.generate(input_ids=inputs[\"input_ids\"], max_new_tokens=10)\n",
+    "    print(outputs)\n",
+    "    print(tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fb746c1e",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  },
+  "toc": {
+   "base_numbering": 1,
+   "nav_menu": {},
+   "number_sections": true,
+   "sideBar": true,
+   "skip_h1_title": false,
+   "title_cell": "Table of Contents",
+   "title_sidebar": "Contents",
+   "toc_cell": false,
+   "toc_position": {},
+   "toc_section_display": true,
+   "toc_window_display": false
+  },
+  "varInspector": {
+   "cols": {
+    "lenName": 16,
+    "lenType": 16,
+    "lenVar": 40
+   },
+   "kernels_config": {
+    "python": {
+     "delete_cmd_postfix": "",
+     "delete_cmd_prefix": "del ",
+     "library": "var_list.py",
+     "varRefreshCmd": "print(var_dic_list())"
+    },
+    "r": {
+     "delete_cmd_postfix": ") ",
+     "delete_cmd_prefix": "rm(",
+     "library": "var_list.r",
+     "varRefreshCmd": "cat(var_dic_list()) "
+    }
+   },
+   "types_to_exclude": [
+    "module",
+    "function",
+    "builtin_function_or_method",
+    "instance",
+    "_Feature"
+   ],
+   "window_display": false
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/conditional_generation/requirements.txt b/examples/conditional_generation/requirements.txt
new file mode 100644
index 0000000..9571ec3
--- /dev/null
+++ b/examples/conditional_generation/requirements.txt
@@ -0,0 +1,8 @@
+transformers
+accelerate
+evaluate
+deepspeed
+tqdm
+datasets
+safetensors
+scikit-learn
\ No newline at end of file
diff --git a/examples/corda_finetuning/README.md b/examples/corda_finetuning/README.md
new file mode 100644
index 0000000..dd1aab9
--- /dev/null
+++ b/examples/corda_finetuning/README.md
@@ -0,0 +1,257 @@
+# CorDA: Context-Oriented Decomposition Adaptation of Large Language Models for Task-Aware Parameter-Efficient Fine-tuning
+
+## Introduction
+
+
+Existing PEFT methods are mostly agnostic of the context of a task of concern, e.g., a downstream task to learn or some pre-trained world knowledge to maintain.
+[CorDA](https://openreview.net/pdf?id=Gi00NVru6n) builds task-aware LoRA adapters from weight decomposition oriented by the context of the task concerned. 
+
+Concretely, CorDA randomly collects a few (by default 256 in our `preprocess.py`) data samples from a target task, e.g. questions from a QA dataset or instructions to write a code or solve a math problem, and feeds these samples into a pre-trained LLM. We can obtain the covariance matrix of the input activation of each linear layer, i.e., $C=XX^T\in\mathcal{R}^{d_{in}\times d_{in}}$. 
+We then perform singular value decomposition (SVD) for the weight $W\in \mathcal{R}^{d_{out}\times d_{in}}$ multiplied by the covariance matrix, i.e., $\verb|SVD|(WC) = U\Sigma V^T$. In this way, the context expressed by these representative covariance matrices is able to orientate the decomposition, such that the principal components (the singular vectors with the largest singular values) are most associated with the task of concern (please refer to Fig.2 of our paper for the advantage of our decomposition over the plain SVD). To ensure the same inference result with the pre-trained model at the start of adaptation, we multiply the inverse of these covariance matrices with the decomposed components, i.e., $\hat{W}=U\Sigma V^T C^{-1}$. 
+
+Thanks to the task-awareness, you can choose how to utilize the task-specific principal components. For examples, if you want to adapt a model to a new task without losing the knowledge of a question-answering dataset, e.g., TriviaQA and NQopen, you can sample questions from this dataset to collect covariance matrices, and keep the principal components frozen because they compact the ability of this dataset, while using the lowest components with the smallest $r$ singular values to initialize the learnable LoRA adapters. This is achieved by the **knowledge-preserved mode (KPM)** of CorDA, which learns new tasks effectively while keeping the world knowledge you are concerned about as sound as possible. Alternatively, when your primary objective is to maximize performance on the finetuning task, disregarding the preservation of world knowledge, the **instruction-previewed mode (IPM**) will be favored. In this mode, CorDA uses the instruction and response from the fine-tuning task (e.g., Math or Code) to produce the covariance matrices. The principal components with the largest $r$ singular values, capturing the characteristics of the finetuning task in advance, can better adapt to the new ability, so they are used to initialize the LoRA adapters, with the remaining components frozen. IPM can further accelerate convergence to enhance the fine-tuning performance on downstream tasks.
+
+
+The implementations of KPM and IPM are compared as follows:
+
+| Mode | Collect covariance from | LoRA $A$ | LoRA $B$ |
+|---|---|---|---
+|KPM | questions from the knowledge benchmark to maintain | $A=\sqrt{\Sigma}\_{[-r:]}(V^T C^{-1})\_{[-r:,:]}$ | $B=U_{[:,-r:]}\sqrt{\Sigma}_{[-r:]}$ |
+IPM | instructions and responses from the downstream task to learn | $A= \sqrt{\Sigma}\_{[:r]} (V^T C^{-1})\_{[:r,:]}$ | $B =U_{[:,:r]} \sqrt{\Sigma}_{[:r]}$ |
+
+### Comparison with alternative methods
+
+The distinction between CorDA with other similar LoRA initialization methods is summarized as follows:
+
+| Method | Initialization for | SVD on | Data-driven | Supports knowledge maintenance |
+| - | - | - | - | - |
+| PiSSA | $A$ and $B$ | weights | no | no |
+| EVA | $A$ | activations | yes | no |
+|CorDA |  $A$ and $B$ | weights (oriented by covariance) | yes | yes |
+
+"Supports knowledge maintenance" denotes the ability of explicitly associating a knowledge benchmark with some components of the pre-trained weights after decomposition, and keeping these components frozen during fine-tuning. 
+
+### Some Results
+
+- Performance with knowledge-preserved mode (sample from NQopen, fine-tune on Math)
+
+| Method | Model | NQ open | GSM8k | Math | Avg. |
+|---|---|---|---|---|---|
+|Pre-trained|Llama-2-7b| 14.99 | -| - | - |
+|LoRA|Llama-2-7b|1.27| 42.68 | 5.88 | 16.61 |
+|**CorDA (KPM)** |Llama-2-7b| **8.20** | **46.32**	| **7.00** | **20.51** |
+|Pre-trained|Llama-2-13b|23.63|-|-|-|
+|LoRA|Llama-2-13b| 16.26 | 57.24 | 8.92 | 27.47 |
+|**CorDA (KPM)** |Llama-2-13b| **19.86** | **59.29** | **9.62** | **29.59** |
+|Pre-trained|Llama-3-8b|13.41|-|-|-|
+|LoRA|Llama-3-8b| 8.75 | 72.33 | 24.04| 35.04 |
+|**CorDA (KPM)** |Llama-3-8b| **9.61** | **74.68** | **25.34** | **36.54** |
+|Pre-trained|Gemma-2-9b|12.85|-|-|-|
+|LoRA|Gemma-2-9b| 9.28 | 83.47 | 42.30| 45.02 |
+|**CorDA (KPM)** |Gemma-2-9b|**10.17** | **84.08** | **42.64** | **45.63** |
+
+- Performance with instruction-previewed mode (sample from Math, fine-tune on Math)
+
+| Method | Model | GSM8k | Math |
+| --- | --- | --- | ---|
+|LoRA| Llama-2-7b | 42.68 | 5.88 |
+|PiSSA | Llama-2-7b | 51.63 | 7.32 |
+| **CorDA (IPM)** | Llama-2-7b | **53.45** | **8.64** |
+|LoRA| Llama-2-13b | 57.24 | 8.92 |
+|PiSSA | Llama-2-13b |60.88	| 11.08|
+| **CorDA (IPM)** | Llama-2-13b | **62.47** |**11.54** |
+|LoRA| Gemma-2-9b | 83.47 |	42.30 |
+|PiSSA | Gemma-2-9b | 84.23	| 43.52|
+| **CorDA (IPM)** | Gemma-2-9b | **84.45** | **43.88** |
+
+
+## Quick Start
+
+### Knowledge-preserved adaptation mode
+
+```py
+import torch
+from peft import LoraConfig, get_peft_model
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from peft.tuners.lora.config import CordaConfig
+from peft.tuners.lora.corda import preprocess_corda
+from trl import SFTConfig, SFTTrainer
+from datasets import load_dataset
+
+model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf", dtype=torch.bfloat16, device_map="auto")
+tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf")
+tokenizer.pad_token_id = tokenizer.eos_token_id
+sampled_dataset = load_dataset("wikitext", "wikitext-2-raw-v1", split="train[:256]")
+dataset = load_dataset("imdb", split="train[:256]")
+
+
+def run_model():
+    for batch in sampled_dataset:
+        input_ids = batch["text"]
+        input_ids = input_ids.to(model.device)
+        with torch.no_grad():
+            model(input_ids)
+
+
+corda_config = CordaConfig(
+    corda_method="kpm",
+)
+lora_config = LoraConfig(
+    init_lora_weights="corda",
+    corda_config=corda_config,
+)
+
+# Call `preprocess_corda` first to collect covariance matrix and build SVD result for model
+# For more details, please refer to documentation of `preprocess_corda`
+preprocess_corda(model, lora_config, run_model=run_model)
+
+# Call `get_peft_model` after preprocessing, or else you'll encounter error
+peft_model = get_peft_model(model, lora_config)
+peft_model.print_trainable_parameters()
+
+training_args = SFTConfig(dataset_text_field="text", max_length=128)
+trainer = SFTTrainer(
+    model=peft_model,
+    args=training_args,
+    train_dataset=dataset,
+    processing_class=tokenizer,
+)
+trainer.train()
+peft_model.save_pretrained("corda-llama-2-7b")
+```
+
+### Instruction-previewed adaptation mode
+
+```py
+# Get model and dataset identically as KPM...
+
+# Different from KPM, we run the model on dataset of the downstream task to collect covariance matrices
+def run_model():
+    for batch in dataset:
+        input_ids = batch["text"]
+        input_ids = input_ids.to(model.device)
+        with torch.no_grad():
+            model(input_ids)
+
+# Different from KPM, we set `corda_method` to `"ipm"`
+corda_config = CordaConfig(
+    corda_method="ipm",
+)
+
+# The rest of training process is identical to KPM...
+```
+
+## Advanced Usage
+
+### Preprocessing
+
+`preprocess.py`: This script builds CorDA adapters for a model, and saves the adapters initial weights and residual model weights to a specified directory. Example usage:
+
+####  Knowledge-preserved adaptation mode
+
+```bash
+export CUDA_VISIBLE_DEVICES=0  # force to use device 0 of CUDA GPU
+export ZE_AFFINITY_MASK=0   # force to use device 0 of Intel XPU
+
+python -u preprocess.py --model_id="meta-llama/Llama-2-7b-hf" \
+    --r 128 --seed 233 \
+    --save_model --save_path {path_to_residual_model} \
+    --calib_dataset "nqopen"
+```
+Arguments:
+
+- `--model_id` is the pre-trained model for decomposition.
+- `--r` is the low rank of LoRA, e.g. 128.
+- `--calib_dataset` specifies the dataset to sample data to obtain covariance matrices. KPA mode uses QA datasets such as `"nqopen"`, `"traivia_qa"`, or other choices.
+- `--save_model` saves the initialized model in `--save_path`. 
+
+#### Instruction-previewed adaptation mode
+
+```bash
+export CUDA_VISIBLE_DEVICES=0  # force to use device 0 of CUDA GPU
+export ZE_AFFINITY_MASK=0   # force to use device 0 of Intel XPU
+
+python -u preprocess.py --model_id="meta-llama/Llama-2-7b-hf" \
+    --r 128 --seed 233 \
+    --save_model --save_path {path_to_residual_model} \
+    --first_eigen --calib_dataset "MetaMATH"
+```
+
+Arguments:
+
+- `--first_eigen` uses the largest $r$ singular values and vectors to initialize the learnable adapter for the instruction-previewed adaptation mode. 
+- `--calib_dataset` specifies the dataset to sample data to obtain covariance matrices. Instruction-previewed mode uses the downstream task dataset you are learning, such as  `"MetaMATH"`, `"codefeedback"`, `"WizLMinstruct"`, `"alpaca"`, or other choices.
+
+#### Note about memory consumption 
+
+The process of collecting covariance matrices is performed in `torch.float32` by default. If you would like to reduce the memory consumption of preprocessing, you can specify `use_float16_for_covariance=True` in `CordaConfig` to collect covariance matrices in `torch.float16`. But this may cause numerical instability only in a few cases, such that the initialized model does not ensure the exact same inference result as the original model. So it is suggested to check, e.g., comparing the inference result of Wiki/PTB perplexity before and after preprocessing, if you choose to perform in `torch.float16`. 
+
+### Fine-tuning
+
+`corda_finetuning.py`: This script fine-tunes the preprocessed model built above on a downstream task.
+
+Example usage:
+
+```bash
+python corda_finetuning.py \
+    --model_name_or_path {path_to_residual_model} \
+    --output_dir {path_to_output_model} \
+    --corda_mode True \
+    --data_path meta-math/MetaMathQA \
+    --dataset_split "train[:100000]" \
+    --dataset_field query response \
+    --num_train_epochs 1 \
+    --per_device_train_batch_size 1 \
+    --gradient_accumulation_steps 32 \
+    --save_strategy "steps" \
+    --save_steps 100 \
+    --save_total_limit 1 \
+    --learning_rate 2e-5 \
+    --weight_decay 0. \
+    --warmup_steps 0.03 \
+    --lr_scheduler_type "cosine" \
+    --logging_steps 1 \
+    --bf16 True \
+    --tf32 True \
+    --report_to none
+```
+
+### Convert CorDA to LoRA
+
+The main advantage of CorDA is concentrated during the training phase. For a trained CorDA adapter, we recommend converting it equivalently to the LoRA adapter for using and sharing.
+
+```python
+# The fine-tuned matrices $A$ and $B$ in CorDA adapter is saved and should be combined with the residual model.
+peft_model.save_pretrained(output_dir) 
+# Given the matrices $A_0$ and $B_0$, initialized by CorDA and untrained, and the trained matrices $A$ and $B$, 
+# we can convert these to LoRA by setting $\Delta W = A \times B - A_0 \times B_0 = [A \mid A_0] \times [B \mid -B_0]^T = A'B'$.
+peft_model.save_pretrained(output_dir, path_initial_model_for_weight_conversion="corda_init")
+```
+
+This conversion enables the loading of LoRA on top of a standard base model:
+
+```python
+import torch
+from peft import PeftModel
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained(
+    "meta-llama/Llama-2-7b-hf", dtype=torch.bfloat16, device_map="auto"
+)
+# No SVD is performed during this step, and the base model remains unaltered.
+peft_model = PeftModel.from_pretrained(model, "corda-llama-2-7b-lora")
+```
+
+Utilizing the converted LoRA does not require modifying the parameters of the base model. When multiple converted LoRAs are needed simultaneously, each adapter operates independently without interference, allowing for the adapters to be freely deleted or added.
+
+Note that this conversion is not supported if `rslora` is used in combination with `rank_pattern` or `alpha_pattern`.
+
+## Citation
+```
+@inproceedings{yangcorda,
+  title={CorDA: Context-Oriented Decomposition Adaptation of Large Language Models for Task-Aware Parameter-Efficient Fine-tuning},
+  author={Yang, Yibo and Li, Xiaojie and Zhou, Zhongzhu and Song, Shuaiwen Leon and Wu, Jianlong and Nie, Liqiang and Ghanem, Bernard},
+  booktitle={The Thirty-eighth Annual Conference on Neural Information Processing Systems},
+  year={2024},
+}
+```
diff --git a/examples/corda_finetuning/corda_finetuning.py b/examples/corda_finetuning/corda_finetuning.py
new file mode 100644
index 0000000..ef8a23f
--- /dev/null
+++ b/examples/corda_finetuning/corda_finetuning.py
@@ -0,0 +1,276 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+import copy
+import os
+from collections.abc import Sequence
+from dataclasses import dataclass, field
+from typing import Optional
+
+import torch
+import transformers
+from datasets import load_dataset
+from transformers import Trainer
+
+from peft import LoraConfig, PeftModel, get_peft_model
+
+
+IGNORE_INDEX = -100
+
+PROMPT = (
+    "Below is an instruction that describes a task. "
+    "Write a response that appropriately completes the request.\n\n"
+    "### Instruction:\n{instruction}\n\n### Response:"
+)
+
+
+def get_nb_trainable_parameters(model) -> tuple[int, int]:
+    r"""
+    Returns the number of trainable parameters and the number of all parameters in the model.
+    """
+    trainable_params = 0
+    all_param = 0
+    for _, param in model.named_parameters():
+        num_params = param.numel()
+        # if using DS Zero 3 and the weights are initialized empty
+        if num_params == 0 and hasattr(param, "ds_numel"):
+            num_params = param.ds_numel
+
+        # Due to the design of 4bit linear layers from bitsandbytes
+        # one needs to multiply the number of parameters by 2 to get
+        # the correct number of parameters
+        if param.__class__.__name__ == "Params4bit":
+            num_bytes = param.quant_storage.itemsize if hasattr(param, "quant_storage") else 1
+            num_params = num_params * 2 * num_bytes
+
+        all_param += num_params
+        if param.requires_grad:
+            trainable_params += num_params
+
+    return trainable_params, all_param
+
+
+@dataclass
+class TrainingArguments(transformers.TrainingArguments):
+    model_name_or_path: Optional[str] = field(default="facebook/opt-125m")
+    data_path: str = field(default=None, metadata={"help": "Path to the training data."})
+    dataset_split: str = field(default="train[:100000]", metadata={"help": "(`['train', 'test', 'eval']`):"})
+    dataset_field: list[str] = field(default=None, metadata={"help": "Fields of dataset input and output."})
+    dataloader_num_proc: int = field(default=16, metadata={"help": "Number of processes to load dataset"})
+    dataloader_batch_size: int = field(
+        default=3000,
+        metadata={
+            "help": "batch size to load dataset. To set the batch size for training, you should pass --batch_size argument instead."
+        },
+    )
+    optim: str = field(default="adamw_torch")
+    model_max_length: int = field(
+        default=512,
+        metadata={"help": "Maximum sequence length. Sequences will be right padded (and possibly truncated)."},
+    )
+    lora_r: int = field(
+        default=None,
+        metadata={"help": "The rank of LoRA adapter. When passing `None`, CorDA or full fine-tuning is used."},
+    )
+    corda_mode: bool = field(default=True, metadata={"help": "True for CorDA mode"})
+
+
+def safe_save_model_for_hf_trainer(trainer: transformers.Trainer, output_dir: str):
+    """Collects the state dict and dump to disk."""
+    state_dict = trainer.model.state_dict()
+    if trainer.args.should_save:
+        cpu_state_dict = {key: value.cpu() for key, value in state_dict.items()}
+        del state_dict
+        trainer._save(output_dir, state_dict=cpu_state_dict)
+
+
+def smart_tokenizer_and_embedding_resize(
+    special_tokens_dict: dict,
+    tokenizer: transformers.PreTrainedTokenizer,
+    model: transformers.PreTrainedModel,
+):
+    """Resize tokenizer and embedding.
+
+    Note: This is the unoptimized version that may make your embedding size not be divisible by 64.
+    """
+    num_new_tokens = tokenizer.add_special_tokens(special_tokens_dict)
+    model.resize_token_embeddings(len(tokenizer))
+
+    if num_new_tokens > 0:
+        input_embeddings = model.get_input_embeddings().weight.data
+        output_embeddings = model.get_output_embeddings().weight.data
+
+        input_embeddings_avg = input_embeddings[:-num_new_tokens].mean(dim=0, keepdim=True)
+        output_embeddings_avg = output_embeddings[:-num_new_tokens].mean(dim=0, keepdim=True)
+
+        input_embeddings[-num_new_tokens:] = input_embeddings_avg
+        output_embeddings[-num_new_tokens:] = output_embeddings_avg
+
+
+def _tokenize_fn(strings: Sequence[str], tokenizer: transformers.PreTrainedTokenizer) -> dict:
+    """Tokenize a list of strings."""
+    tokenized_list = [
+        tokenizer(
+            text,
+            return_tensors="pt",
+            padding="longest",
+            max_length=tokenizer.model_max_length,
+            truncation=True,
+        )
+        for text in strings
+    ]
+    input_ids = labels = [tokenized.input_ids[0] for tokenized in tokenized_list]
+    input_ids_lens = labels_lens = [
+        tokenized.input_ids.ne(tokenizer.pad_token_id).sum().item() for tokenized in tokenized_list
+    ]
+    return {
+        "input_ids": input_ids,
+        "labels": labels,
+        "input_ids_lens": input_ids_lens,
+        "labels_lens": labels_lens,
+    }
+
+
+def preprocess(
+    sources: Sequence[str],
+    targets: Sequence[str],
+    tokenizer: transformers.PreTrainedTokenizer,
+) -> dict:
+    """Preprocess the data by tokenizing."""
+    examples = [s + t for s, t in zip(sources, targets)]
+    examples_tokenized, sources_tokenized = (_tokenize_fn(strings, tokenizer) for strings in (examples, sources))
+    input_ids = examples_tokenized["input_ids"]
+    labels = copy.deepcopy(input_ids)
+    for label, source_len in zip(labels, sources_tokenized["input_ids_lens"]):
+        label[:source_len] = IGNORE_INDEX
+    return {
+        "input_ids": input_ids,
+        "labels": labels,
+    }
+
+
+@dataclass
+class DataCollatorForSupervisedDataset:
+    """Collate examples for supervised fine-tuning."""
+
+    tokenizer: transformers.PreTrainedTokenizer
+
+    def __call__(self, instances: Sequence[dict]) -> dict[str, torch.Tensor]:
+        input_ids, labels = tuple([instance[key] for instance in instances] for key in ("input_ids", "labels"))
+        input_ids = [torch.tensor(x) for x in input_ids]
+        input_ids = torch.nn.utils.rnn.pad_sequence(
+            input_ids, batch_first=True, padding_value=self.tokenizer.pad_token_id
+        )
+        labels = [torch.tensor(x) for x in labels]
+        labels = torch.nn.utils.rnn.pad_sequence(labels, batch_first=True, padding_value=IGNORE_INDEX)
+        return {
+            "input_ids": input_ids,
+            "labels": labels,
+            "attention_mask": input_ids.ne(self.tokenizer.pad_token_id),
+        }
+
+
+def train_tokenize_function(examples, tokenizer, query, response):
+    sources = [
+        PROMPT.format_map(
+            {
+                "instruction": instruction,
+            }
+        )
+        for instruction in examples[query]
+    ]
+    targets = [f"{output}{tokenizer.eos_token}" for output in examples[response]]
+    data_dict = preprocess(sources, targets, tokenizer)
+    return data_dict
+
+
+def train():
+    parser = transformers.HfArgumentParser(TrainingArguments)
+    script_args = parser.parse_args_into_dataclasses()[0]
+    print(script_args)
+
+    if script_args.corda_mode:
+        print("Train in CorDA mode")
+        res_model = transformers.AutoModelForCausalLM.from_pretrained(
+            script_args.model_name_or_path,
+            device_map="auto",
+        )
+        model = PeftModel.from_pretrained(
+            res_model, script_args.model_name_or_path, subfolder="corda_init", is_trainable=True
+        )
+    elif script_args.lora_r is not None:
+        print("Train in LoRA mode")
+        model = transformers.AutoModelForCausalLM.from_pretrained(
+            script_args.model_name_or_path,
+            device_map="auto",
+        )
+        lora_config = LoraConfig(
+            r=script_args.lora_r,
+            lora_alpha=script_args.lora_r,
+            init_lora_weights=True,  # script_args.init_lora_weights,
+            target_modules=["q_proj", "o_proj", "k_proj", "v_proj", "gate_proj", "up_proj", "down_proj"],
+            lora_dropout=0,
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+        model = get_peft_model(model, lora_config)
+    else:
+        print("Train in Full Finetuning mode")
+        model = transformers.AutoModelForCausalLM.from_pretrained(
+            script_args.model_name_or_path,
+            dtype=torch.bfloat16,
+            device_map="auto",
+        )
+    trainable_params, all_param = get_nb_trainable_parameters(model)
+    print(
+        f"trainable params: {trainable_params:,d} || all params: {all_param:,d} || trainable%: {100 * trainable_params / all_param}"
+    )
+    tokenizer = transformers.AutoTokenizer.from_pretrained(
+        script_args.model_name_or_path,
+        model_max_length=script_args.model_max_length,
+        padding_side="right",
+        use_fast=True,
+        trust_remote_code=True,
+    )
+    tokenizer.pad_token_id = tokenizer.eos_token_id
+
+    raw_train_datasets = load_dataset(script_args.data_path, split=script_args.dataset_split)
+    train_dataset = raw_train_datasets.map(
+        train_tokenize_function,
+        batched=True,
+        batch_size=script_args.dataloader_batch_size,
+        num_proc=script_args.dataloader_num_proc,
+        remove_columns=raw_train_datasets.column_names,
+        load_from_cache_file=True,
+        desc="Running tokenizer on train dataset",
+        fn_kwargs={
+            "tokenizer": tokenizer,
+            "query": script_args.dataset_field[0],
+            "response": script_args.dataset_field[1],
+        },
+    )
+
+    data_collator = DataCollatorForSupervisedDataset(tokenizer=tokenizer)
+    data_module = {
+        "train_dataset": train_dataset,
+        "data_collator": data_collator,
+    }
+    trainer = Trainer(model=model, processing_class=tokenizer, args=script_args, **data_module)
+    trainer.train()
+    trainer.save_state()
+    model.save_pretrained(os.path.join(script_args.output_dir, "ft"))
+
+
+if __name__ == "__main__":
+    train()
diff --git a/examples/corda_finetuning/datautils.py b/examples/corda_finetuning/datautils.py
new file mode 100644
index 0000000..3e612b0
--- /dev/null
+++ b/examples/corda_finetuning/datautils.py
@@ -0,0 +1,235 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+import os
+import random
+
+import numpy as np
+import torch
+from datasets import load_dataset
+
+
+"""
+doc https://huggingface.co/docs/datasets/loading
+doc https://huggingface.co/docs/datasets/process
+doc https://huggingface.co/blog/llama2#how-to-prompt-llama-2
+"""
+
+
+def set_seed(seed):
+    np.random.seed(seed)
+    torch.random.manual_seed(seed)
+
+
+def sample_train_loaders(name, tokenizer, nsamples=128, seed=0, seqlen=2048):
+    set_seed(seed)
+    if "wikitext2" in name:
+        traindata = load_dataset(
+            "wikitext",
+            "wikitext-2-raw-v1",
+            split="train",
+        )
+        traindata = "\n\n".join(traindata["text"])
+    elif "c4" in name:
+        traindata = load_dataset(
+            "allenai/c4",
+            "allenai--c4",
+            data_files={"train": "en/c4-train.00000-of-01024.json.gz"},
+            split="train",
+        )
+        traindata = "\n\n".join(traindata["text"])
+    else:
+        raise NotImplementedError
+
+    trainloader = []
+    for _ in range(nsamples):
+        i = random.randint(0, len(traindata) - seqlen * 2 - 1)
+        j = i + seqlen * 2
+        # breakpoint()
+        trainenc = tokenizer(traindata[i:j], return_tensors="pt")
+        inp = trainenc.input_ids[:, :seqlen]
+        trainloader.append(inp)
+    return trainloader
+
+
+def get_redpajama_train(tokenizer, percent=10, seed=3, batch_size=128, max_length=2048):
+    def tokenization(example):
+        return tokenizer(example["text"], truncation=True, max_length=max_length)
+
+    if percent != 100:
+        split = f"train[:{int(850000 * percent / 100)}]"
+    else:
+        split = "train"
+    dataset = load_dataset("togethercomputer/RedPajama-Data-1T-Sample", split=split)
+
+    processed_dataset = dataset.map(tokenization, batched=True, batch_size=batch_size, num_proc=os.cpu_count())
+    return processed_dataset
+
+
+def get_english_quote(dataset_name, tokenizer):
+    data = load_dataset(dataset_name)
+    data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+    return data["train"]
+
+
+def get_qat_dataset(name, tokenizer, data_percent):
+    if name == "red_pajama":
+        data = get_redpajama_train(tokenizer, data_percent)
+
+    elif name == "Abirate/english_quotes":
+        data = get_english_quote(name, tokenizer)
+    else:
+        raise NotImplementedError
+    data = data.shuffle()
+    return data
+
+
+llama_chat_format = """<s>[INST] <<SYS>>
+"Below is an instruction that describes a task. Write a response that appropriately completes the request."
+<</SYS>>
+
+{instruction} [/INST] {response} </s>
+"""
+
+
+def get_calib_data(name, tokenizer, model_id, nsamples, seqlen=2048, seed=3):
+    print(f" get_data_from: {name}, nsamples={nsamples}, seqlen={seqlen}, {seed}")
+    cache_file = f"cache/{name}_{model_id.replace('/', '_')}_{nsamples}_{seqlen}_{seed}.pt"
+    traindataset = []
+    if not os.path.exists("cache"):
+        os.makedirs("cache")
+    if os.path.exists(cache_file):
+        print(f"found data file: {cache_file}")
+        traindataset = torch.load(cache_file)
+        print("loaded ...")
+        return traindataset
+    if name == "c4":
+        traindata = load_dataset(
+            "allenai/c4",
+            "allenai--c4",
+            data_files={"train": "en/c4-train.00000-of-01024.json.gz"},
+            split="train",
+        )
+        tot_text = "\n\n".join(traindata["text"])
+    elif name == "wikitext2":
+        traindata = load_dataset("wikitext", "wikitext-2-raw-v1", split="train")
+        tot_text = "\n\n".join(traindata["text"])
+    elif name == "ptb":
+        traindata = load_dataset(
+            "ptb_text_only",
+            "penn_treebank",
+            split="train",
+        )
+        tot_text = "\n\n".join(traindata["sentence"])
+    elif name == "traivia_qa":
+        traindata = load_dataset("trivia_qa", "rc", split="train")
+        tot_text = "\n\n".join(traindata["question"])
+    elif name == "nqopen":
+        traindata = load_dataset("nq_open", split="train")
+        tot_text = "\n\n".join(traindata["question"])
+    elif name == "alpaca":
+        selected_data_dict = load_dataset("iboing/alpaca_data", split="train").shuffle(seed=seed).take(nsamples)
+        for example in selected_data_dict:
+            if example.get("input", "") == "":
+                s = llama_chat_format.format(instruction=example["instruction"], response=example["output"])
+                trainenc = tokenizer(s, return_tensors="pt")
+                inp = trainenc.input_ids[:, :seqlen]
+                attention_mask = torch.ones_like(inp)
+                traindataset.append({"input_ids": inp, "attention_mask": attention_mask})
+        print("example instruction:", s)
+        torch.save(traindataset, cache_file)
+        return traindataset
+    elif name == "MetaMATH":
+        selected_data_dict = load_dataset("iboing/MetaMathQA-395K", split="train").shuffle(seed=seed).take(nsamples)
+        for example in selected_data_dict:
+            if example.get("input", "") == "":
+                s = llama_chat_format.format(instruction=example["query"], response=example["response"])
+                trainenc = tokenizer(s, return_tensors="pt")
+                inp = trainenc.input_ids[:, :seqlen]
+                attention_mask = torch.ones_like(inp)
+                traindataset.append({"input_ids": inp, "attention_mask": attention_mask})
+        print("example instruction:", s)
+        torch.save(traindataset, cache_file)
+        return traindataset
+    elif name == "codefeedback":
+        selected_data_dict = (
+            load_dataset("iboing/CodeFeedback-Filtered-Instruction", split="train").shuffle(seed=seed).take(nsamples)
+        )
+        for example in selected_data_dict:
+            if example.get("input", "") == "":
+                s = llama_chat_format.format(instruction=example["query"], response=example["answer"])
+                trainenc = tokenizer(s, return_tensors="pt")
+                inp = trainenc.input_ids[:, :seqlen]
+                attention_mask = torch.ones_like(inp)
+                traindataset.append({"input_ids": inp, "attention_mask": attention_mask})
+        print("example instruction:", s)
+        torch.save(traindataset, cache_file)
+        return traindataset
+    elif name == "WizLMinstruct":
+        selected_data_dict = (
+            load_dataset("iboing/WizardLM_evol_instruct_V2_143k", split="train").shuffle(seed=seed).take(nsamples)
+        )
+        for example in selected_data_dict:
+            if example.get("input", "") == "":
+                s = llama_chat_format.format(
+                    instruction=example["conversation"][0]["human"], response=example["conversation"][0]["assistant"]
+                )
+                trainenc = tokenizer(s, return_tensors="pt")
+                inp = trainenc.input_ids[:, :seqlen]
+                attention_mask = torch.ones_like(inp)
+                traindataset.append({"input_ids": inp, "attention_mask": attention_mask})
+        print("example instruction:", s)
+        torch.save(traindataset, cache_file)
+        return traindataset
+    else:
+        raise NotImplementedError
+    print(f"tot_text={len(tot_text)}")
+    for _ in range(nsamples):
+        i = random.randint(0, len(tot_text) - seqlen - 1)
+        j = i + seqlen * 10
+        trainenc = tokenizer(tot_text[i:j], return_tensors="pt")
+        inp = trainenc.input_ids[:, :seqlen]
+        attention_mask = torch.ones_like(inp)
+        traindataset.append({"input_ids": inp, "attention_mask": attention_mask})
+    torch.save(traindataset, cache_file)
+    return traindataset
+
+
+def get_eval_loaders(name, tokenizer):
+    if "wikitext2" in name:
+        testdata = load_dataset(
+            "wikitext",
+            "wikitext-2-raw-v1",
+            split="test",
+        )
+        testenc = tokenizer("\n\n".join(testdata["text"]), return_tensors="pt")
+        return testenc
+    if "ptb" in name:
+        valdata = load_dataset(
+            "ptb_text_only",
+            "penn_treebank",
+            split="validation",
+        )
+        testenc = tokenizer("\n\n".join(valdata["sentence"]), return_tensors="pt")
+        return testenc
+    if "c4" in name:
+        testdata = load_dataset(
+            "allenai/c4",
+            "allenai--c4",
+            data_files={"validation": "en/c4-validation.00000-of-00008.json.gz"},
+            split="validation",
+        )
+        testenc = tokenizer("\n\n".join(testdata["text"]), return_tensors="pt")
+        return testenc
+    raise NotImplementedError
diff --git a/examples/corda_finetuning/preprocess.py b/examples/corda_finetuning/preprocess.py
new file mode 100644
index 0000000..bcd33ef
--- /dev/null
+++ b/examples/corda_finetuning/preprocess.py
@@ -0,0 +1,165 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+import argparse
+import os
+
+import numpy as np
+import torch
+from datautils import get_calib_data
+from tqdm import tqdm
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from peft import get_peft_model
+from peft.tuners.lora.config import CordaConfig, LoraConfig
+from peft.tuners.lora.corda import preprocess_corda
+
+
+@torch.no_grad()
+def run_model(model, calib_loader):
+    model.eval()
+    for batch in tqdm(calib_loader):
+        batch = {k: v.to(model.device) for k, v in batch.items()}
+        model(**batch)
+
+
+def main(args):
+    # Setting random seed of numpy and torch
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(args.seed)
+    elif torch.xpu.is_available():
+        torch.xpu.manual_seed_all(args.seed)
+    torch.use_deterministic_algorithms(True)
+
+    # Load model
+    model_id = args.model_id
+    tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
+
+    model = AutoModelForCausalLM.from_pretrained(
+        model_id, device_map="auto", dtype=torch.float16, trust_remote_code=True
+    )
+
+    # Collect data
+    calib_loader = get_calib_data(args.calib_dataset, tokenizer, model_id, args.calib_loader_size, seed=args.seed)
+
+    # Evaluate the original model
+    print("\n---- model before svd ---\n")
+    print(model)
+
+    # Perform decomposition
+    corda_config = CordaConfig(
+        corda_method="ipm" if args.first_eigen else "kpm",
+    )
+    lora_config = LoraConfig(
+        init_lora_weights="corda",
+        target_modules=["q_proj", "o_proj", "k_proj", "v_proj", "gate_proj", "up_proj", "down_proj"],
+        r=args.r,
+        lora_alpha=args.r,
+        corda_config=corda_config,
+    )
+    preprocess_corda(
+        model,
+        lora_config,
+        run_model=lambda: run_model(model, calib_loader),
+    )
+    model = get_peft_model(model, lora_config)
+
+    # Evaluate again to check if the model is consistent
+    # Using `model.model` here because `get_peft_model` wraps a layer to the model
+    print("\n---- model after svd ---\n")
+    print(model)
+
+    # Save as hugging face model
+    if args.save_model:
+        assert args.save_path is not None
+        save_path = args.save_path
+
+        # Save CorDA modules
+        model.peft_config["default"].init_lora_weights = True
+        model.save_pretrained(os.path.join(save_path, "corda_init"))
+
+        # Save residual model
+        model = model.unload()
+        model.save_pretrained(save_path)
+
+        # Save tokenizer
+        tokenizer.save_pretrained(save_path)
+        print(f"Done building CorDA huggingface model in {save_path}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--model_id",
+        type=str,
+        default="meta-llama/Llama-2-7b-hf",
+        help="Pretrained model ID",
+    )
+    parser.add_argument(
+        "--calib_loader_size",
+        type=int,
+        default=256,
+        help="number of samples used for covariance matrices",
+    )
+    parser.add_argument(
+        "--calib_dataset",
+        type=str,
+        default="wikitext2",
+        choices=[
+            "wikitext2",
+            "c4",
+            "ptb",
+            "traivia_qa",
+            "nqopen",
+            "MetaMATH",
+            "codefeedback",
+            "WizLMinstruct",
+            "alpaca",
+        ],
+        help="calibration dataset",
+    )
+    parser.add_argument(
+        "--eval_mmlu",
+        action="store_true",
+        help="evaluate mmlu",
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=233,
+        help="random seed",
+    )
+    parser.add_argument(
+        "--r",
+        type=int,
+        default=None,
+    )
+    parser.add_argument(
+        "--first_eigen",
+        action="store_true",
+    )
+    parser.add_argument(
+        "--save_model",
+        action="store_true",
+    )
+    parser.add_argument(
+        "--save_path",
+        type=str,
+        default=None,
+    )
+    args = parser.parse_args()
+
+    main(args)
diff --git a/examples/cpt_finetuning/README.md b/examples/cpt_finetuning/README.md
new file mode 100644
index 0000000..2c84ce9
--- /dev/null
+++ b/examples/cpt_finetuning/README.md
@@ -0,0 +1,64 @@
+
+# Context-aware Prompt Tuning: Advancing In-Context Learning with Adversarial Methods
+## Introduction ([Paper](https://huggingface.co/papers/2410.17222), [Code](https://github.com/tsachiblau/Context-aware-Prompt-Tuning-Advancing-In-Context-Learning-with-Adversarial-Methods), [Notebook](cpt_train_and_inference.ipynb), [Colab](https://colab.research.google.com/drive/1UhQDVhZ9bDlSk1551SuJV8tIUmlIayta?usp=sharing))
+
+> Large Language Models (LLMs) can perform few-shot learning using either optimization-based approaches or In-Context Learning (ICL). Optimization-based methods often suffer from overfitting, as they require updating a large number of parameters with limited data. In contrast, ICL avoids overfitting but typically underperforms compared to optimization-based methods and is highly sensitive to the selection, order, and format of demonstration examples. To overcome these challenges, we introduce Context-aware Prompt Tuning (CPT), a method inspired by ICL, Prompt Tuning (PT), and adversarial attacks. CPT builds on the ICL strategy of concatenating examples before the input, extending it by incorporating PT-like learning to refine the context embedding through iterative optimization, extracting deeper insights from the training examples. Our approach carefully modifies specific context tokens, considering the unique structure of the examples within the context. In addition to updating the context with PT-like optimization, CPT draws inspiration from adversarial attacks, adjusting the input based on the labels present in the context while preserving the inherent value of the user-provided data. To ensure robustness and stability during optimization, we employ a projected gradient descent algorithm, constraining token embeddings to remain close to their original values and safeguarding the quality of the context. Our method has demonstrated superior accuracy across multiple classification tasks using various LLM models, outperforming existing baselines and effectively addressing the overfitting challenge in few-shot learning.
+
+
+
+<div class="flex justify-center">
+    <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/peft/cpt.png"/>
+</div>
+<small>CPT optimizing only specific token embeddings while keeping the rest of the model frozen <a href="https://huggingface.co/papers/2410.17222">(image source)</a>.</small>
+
+---
+
+## Dataset Creation and Collation for CPT
+
+This document explains how to prepare datasets for CPT, linking the dataset preparation processes in the code to the methods and principles described in the CPT paper, specifically in **Sections 3.1**, **3.2**, and **3.3**.
+
+---
+
+### Template-Based Tokenization
+
+#### The Role of Templates
+Templates define the structure of the input-output pairs, enabling the model to interpret the task within a unified context.
+
+- **Input Templates**:  
+  Templates like `"input: {sentence}"` structure raw input sentences. The `{sentence}` placeholder is replaced with the actual input text.
+
+- **Output Templates**:  
+  Templates such as `"output: {label}"` format the labels (e.g., `positive`, `negative`, etc.).
+
+- **Separator Tokens**:  
+  Separators distinguish different parts of the input, such as the input text and labels, as well as separate examples within the context.
+
+
+#### How CPT Utilizes Context Structure
+
+CPT leverages the context structure, encoded within the `cpt_tokens_type_mask`, to optimize the context effectively. to optimize the context effectively. By treating different token types based on their roles, the model updates some tokens while using others solely for optimization:
+
+1. **Refrain from Updating Label Tokens**:  
+   Some context tokens represent label tokens, which contain valuable, unmodifiable information. By excluding these tokens from updates during training, CPT ensures that the labels remain fixed, preserving their integrity.
+
+2. **Apply Type-Specific Projection Norms**:  
+   CPT employs Projected Gradient Descent (PGD) to update context embeddings, applying tailored norms to different context parts. This approach reduces overfitting while maintaining robustness and generalization by preserving the integrity of user-provided examples.
+
+
+
+#### Limitations 
+CPT is designed for few-shot scenarios, as concatenating more examples increases memory usage due to the self-attention mechanism and additional loss terms. For larger datasets, users can limit the number of context examples and use the remaining samples solely for optimization to manage memory efficiently.
+
+
+
+
+## Citation
+```bib
+@article{   
+    blau2025cpt, 
+    title={Context-Aware Prompt Tuning: Advancing In-Context Learning with Adversarial Methods}, 
+    author={Tsachi Blau, Moshe Kimhi, Yonatan Belinkov, Alexander Bronstein, Chaim Baskin}, 
+    journal={arXiv preprint arXiv:2410.17222}}, 
+    year={2025} 
+}
+```
diff --git a/examples/cpt_finetuning/cpt_train_and_inference.ipynb b/examples/cpt_finetuning/cpt_train_and_inference.ipynb
new file mode 100644
index 0000000..d10d3b1
--- /dev/null
+++ b/examples/cpt_finetuning/cpt_train_and_inference.ipynb
@@ -0,0 +1,1555 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# CPT Training and Inference\n",
+        "This notebook demonstrates the training and evaluation process of Context-Aware Prompt Tuning (CPT) using the Hugging Face Trainer. For more details, refer to the [Paper](https://huggingface.co/papers/2410.17222).\n",
+        "\n",
+        "\n",
+        "## Sections Overview:\n",
+        "1. **Setup**: Import libraries and configure the environment.\n",
+        "2. **Data Preparation**: Load and preprocess the dataset.\n",
+        "3. **Model Training**: Configure and train the model.\n",
+        "4. **Evaluation**: Test the model's performance and visualize results."
+      ],
+      "metadata": {
+        "id": "R_byvXT9lpTU"
+      },
+      "id": "R_byvXT9lpTU"
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Setup\n",
+        "\n",
+        "---\n",
+        "\n",
+        "\n"
+      ],
+      "metadata": {
+        "collapsed": false,
+        "id": "11b07b07ac5e472b"
+      },
+      "id": "11b07b07ac5e472b"
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Installation"
+      ],
+      "metadata": {
+        "id": "O8DWZb8ZrGRU"
+      },
+      "id": "O8DWZb8ZrGRU"
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install datasets\n",
+        "!pip install git+https://github.com/huggingface/peft"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "d6KZ5REDrFiM",
+        "outputId": "e505bc0e-082a-4720-9117-b730d9fd67fa"
+      },
+      "id": "d6KZ5REDrFiM",
+      "execution_count": 1,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Requirement already satisfied: datasets in /usr/local/lib/python3.10/dist-packages (3.1.0)\n",
+            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from datasets) (3.16.1)\n",
+            "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.10/dist-packages (from datasets) (1.26.4)\n",
+            "Requirement already satisfied: pyarrow>=15.0.0 in /usr/local/lib/python3.10/dist-packages (from datasets) (17.0.0)\n",
+            "Requirement already satisfied: dill<0.3.9,>=0.3.0 in /usr/local/lib/python3.10/dist-packages (from datasets) (0.3.8)\n",
+            "Requirement already satisfied: pandas in /usr/local/lib/python3.10/dist-packages (from datasets) (2.2.2)\n",
+            "Requirement already satisfied: requests>=2.32.2 in /usr/local/lib/python3.10/dist-packages (from datasets) (2.32.3)\n",
+            "Requirement already satisfied: tqdm>=4.66.3 in /usr/local/lib/python3.10/dist-packages (from datasets) (4.66.6)\n",
+            "Requirement already satisfied: xxhash in /usr/local/lib/python3.10/dist-packages (from datasets) (3.5.0)\n",
+            "Requirement already satisfied: multiprocess<0.70.17 in /usr/local/lib/python3.10/dist-packages (from datasets) (0.70.16)\n",
+            "Requirement already satisfied: fsspec<=2024.9.0,>=2023.1.0 in /usr/local/lib/python3.10/dist-packages (from fsspec[http]<=2024.9.0,>=2023.1.0->datasets) (2024.9.0)\n",
+            "Requirement already satisfied: aiohttp in /usr/local/lib/python3.10/dist-packages (from datasets) (3.11.2)\n",
+            "Requirement already satisfied: huggingface-hub>=0.23.0 in /usr/local/lib/python3.10/dist-packages (from datasets) (0.26.2)\n",
+            "Requirement already satisfied: packaging in /usr/local/lib/python3.10/dist-packages (from datasets) (24.2)\n",
+            "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.10/dist-packages (from datasets) (6.0.2)\n",
+            "Requirement already satisfied: aiohappyeyeballs>=2.3.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (2.4.3)\n",
+            "Requirement already satisfied: aiosignal>=1.1.2 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (1.3.1)\n",
+            "Requirement already satisfied: attrs>=17.3.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (24.2.0)\n",
+            "Requirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (1.5.0)\n",
+            "Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (6.1.0)\n",
+            "Requirement already satisfied: propcache>=0.2.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (0.2.0)\n",
+            "Requirement already satisfied: yarl<2.0,>=1.17.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (1.17.2)\n",
+            "Requirement already satisfied: async-timeout<6.0,>=4.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (4.0.3)\n",
+            "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.10/dist-packages (from huggingface-hub>=0.23.0->datasets) (4.12.2)\n",
+            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.2->datasets) (3.4.0)\n",
+            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.2->datasets) (3.10)\n",
+            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.2->datasets) (2.2.3)\n",
+            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.2->datasets) (2024.8.30)\n",
+            "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.10/dist-packages (from pandas->datasets) (2.8.2)\n",
+            "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas->datasets) (2024.2)\n",
+            "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.10/dist-packages (from pandas->datasets) (2024.2)\n",
+            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.2->pandas->datasets) (1.16.0)\n",
+            "Collecting git+https://github.com/huggingface/peft\n",
+            "  Cloning https://github.com/huggingface/peft to /tmp/pip-req-build-0mbyx_z_\n",
+            "  Running command git clone --filter=blob:none --quiet https://github.com/huggingface/peft /tmp/pip-req-build-0mbyx_z_\n",
+            "  Resolved https://github.com/huggingface/peft to commit 131efba5d48753a3355ecd4f3833ae010a0510d6\n",
+            "  Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n",
+            "  Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n",
+            "  Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
+            "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.10/dist-packages (from peft==0.13.3.dev0) (1.26.4)\n",
+            "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from peft==0.13.3.dev0) (24.2)\n",
+            "Requirement already satisfied: psutil in /usr/local/lib/python3.10/dist-packages (from peft==0.13.3.dev0) (5.9.5)\n",
+            "Requirement already satisfied: pyyaml in /usr/local/lib/python3.10/dist-packages (from peft==0.13.3.dev0) (6.0.2)\n",
+            "Requirement already satisfied: torch>=1.13.0 in /usr/local/lib/python3.10/dist-packages (from peft==0.13.3.dev0) (2.5.1+cu121)\n",
+            "Requirement already satisfied: transformers in /usr/local/lib/python3.10/dist-packages (from peft==0.13.3.dev0) (4.46.2)\n",
+            "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from peft==0.13.3.dev0) (4.66.6)\n",
+            "Requirement already satisfied: accelerate>=0.21.0 in /usr/local/lib/python3.10/dist-packages (from peft==0.13.3.dev0) (1.1.1)\n",
+            "Requirement already satisfied: safetensors in /usr/local/lib/python3.10/dist-packages (from peft==0.13.3.dev0) (0.4.5)\n",
+            "Requirement already satisfied: huggingface_hub>=0.25.0 in /usr/local/lib/python3.10/dist-packages (from peft==0.13.3.dev0) (0.26.2)\n",
+            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from huggingface_hub>=0.25.0->peft==0.13.3.dev0) (3.16.1)\n",
+            "Requirement already satisfied: fsspec>=2023.5.0 in /usr/local/lib/python3.10/dist-packages (from huggingface_hub>=0.25.0->peft==0.13.3.dev0) (2024.9.0)\n",
+            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from huggingface_hub>=0.25.0->peft==0.13.3.dev0) (2.32.3)\n",
+            "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.10/dist-packages (from huggingface_hub>=0.25.0->peft==0.13.3.dev0) (4.12.2)\n",
+            "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch>=1.13.0->peft==0.13.3.dev0) (3.4.2)\n",
+            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch>=1.13.0->peft==0.13.3.dev0) (3.1.4)\n",
+            "Requirement already satisfied: sympy==1.13.1 in /usr/local/lib/python3.10/dist-packages (from torch>=1.13.0->peft==0.13.3.dev0) (1.13.1)\n",
+            "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy==1.13.1->torch>=1.13.0->peft==0.13.3.dev0) (1.3.0)\n",
+            "Requirement already satisfied: regex!=2019.12.17 in /usr/local/lib/python3.10/dist-packages (from transformers->peft==0.13.3.dev0) (2024.9.11)\n",
+            "Requirement already satisfied: tokenizers<0.21,>=0.20 in /usr/local/lib/python3.10/dist-packages (from transformers->peft==0.13.3.dev0) (0.20.3)\n",
+            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch>=1.13.0->peft==0.13.3.dev0) (3.0.2)\n",
+            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface_hub>=0.25.0->peft==0.13.3.dev0) (3.4.0)\n",
+            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface_hub>=0.25.0->peft==0.13.3.dev0) (3.10)\n",
+            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface_hub>=0.25.0->peft==0.13.3.dev0) (2.2.3)\n",
+            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface_hub>=0.25.0->peft==0.13.3.dev0) (2024.8.30)\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Imports"
+      ],
+      "metadata": {
+        "id": "5BerCvfkq_jp"
+      },
+      "id": "5BerCvfkq_jp"
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from typing import Any, Dict, List, Union\n",
+        "\n",
+        "import numpy as np\n",
+        "import torch\n",
+        "from datasets import load_dataset\n",
+        "from torch.utils.data import Dataset\n",
+        "from tqdm import tqdm\n",
+        "from transformers import (\n",
+        "    AutoModelForCausalLM,\n",
+        "    AutoTokenizer,\n",
+        "    DataCollatorForLanguageModeling,\n",
+        "    Trainer,\n",
+        "    TrainingArguments,\n",
+        ")\n",
+        "\n",
+        "from peft import CPTConfig, TaskType, get_peft_model\n",
+        "\n",
+        "\n",
+        "MAX_INPUT_LENGTH = 1024\n",
+        "MAX_ICL_SAMPLES = 10\n",
+        "NUM_TRAINING_SAMPLES = 100\n",
+        "model_id = 'bigscience/bloom-1b7'"
+      ],
+      "metadata": {
+        "id": "Y0pETNFBl963"
+      },
+      "id": "Y0pETNFBl963",
+      "execution_count": 2,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Data Preparation\n",
+        "---"
+      ],
+      "metadata": {
+        "id": "9hO_I3aDmCQu"
+      },
+      "id": "9hO_I3aDmCQu"
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Initialize the tokenizer\n",
+        "tokenizer = AutoTokenizer.from_pretrained(\n",
+        "    model_id,               # The name or path of the pre-trained tokenizer (e.g., \"bert-base-uncased\").\n",
+        "    cache_dir='.',          # Directory to cache the tokenizer files locally.\n",
+        "    padding_side='right',   # Specifies that padding should be added to the right side of sequences.\n",
+        "    trust_remote_code=True  # Allows loading tokenizer implementations from external sources.\n",
+        ")"
+      ],
+      "metadata": {
+        "id": "STK5N0LJrZmA",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "4c5c3dda-07ae-4f67-df29-4a2ff499e5ad"
+      },
+      "id": "STK5N0LJrZmA",
+      "execution_count": 3,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.10/dist-packages/huggingface_hub/utils/_auth.py:94: UserWarning: \n",
+            "The secret `HF_TOKEN` does not exist in your Colab secrets.\n",
+            "To authenticate with the Hugging Face Hub, create a token in your settings tab (https://huggingface.co/settings/tokens), set it as secret in your Google Colab and restart your session.\n",
+            "You will be able to reuse this secret in all of your notebooks.\n",
+            "Please note that authentication is recommended but still optional to access public models or datasets.\n",
+            "  warnings.warn(\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Load the SST-2 dataset from the GLUE benchmark\n",
+        "dataset = load_dataset('glue', 'sst2')\n",
+        "\n",
+        "def add_string_labels(example):\n",
+        "    \"\"\"\n",
+        "    Converts numerical labels into human-readable string labels.\n",
+        "\n",
+        "    Args:\n",
+        "        example (dict): A single example from the dataset with a numerical 'label'.\n",
+        "\n",
+        "    Returns:\n",
+        "        dict: The example augmented with a 'label_text' field.\n",
+        "    \"\"\"\n",
+        "    # Map numerical label to string label\n",
+        "    example['label_text'] = \"positive\" if example['label'] == 1 else \"negative\"\n",
+        "    return example\n",
+        "\n",
+        "# Subset and process the training dataset\n",
+        "context_dataset = dataset['train'].select(range(MAX_ICL_SAMPLES)).map(add_string_labels)\n",
+        "train_dataset = dataset['train'].select(range(MAX_ICL_SAMPLES, NUM_TRAINING_SAMPLES + MAX_ICL_SAMPLES)).map(add_string_labels)"
+      ],
+      "metadata": {
+        "id": "C3oq4lDDrcUf",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "referenced_widgets": [
+            "72a5be4b77ec4d5994bcace9d462da84",
+            "bed78529ff2c4d08befca97c50cb5efc",
+            "cf7077acfce04aff8af0a2483dbf094c",
+            "910462d70d944d00ba54958d77bee755",
+            "a899818bdad0415b860eaac4afe31f30",
+            "3d78a6c8923547cf8c75bc8c10125eda",
+            "8083f95a673a423286ade63051de757d",
+            "13fc203ab1b44c83b6cfcc1e171d26ad",
+            "663a0196d2b547fd8a6890b8a86080c2",
+            "72be01164e974d59b05bee716e9bc978",
+            "4cedaf37e79e4ff1a10ffb96ec543e81"
+          ],
+          "height": 49
+        },
+        "outputId": "5ae1ff54-d726-4f07-e6d7-cd53145b5d6f"
+      },
+      "id": "C3oq4lDDrcUf",
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "Map:   0%|          | 0/100 [00:00<?, ? examples/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "72a5be4b77ec4d5994bcace9d462da84"
+            }
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Note:** This notebook uses small subsets of the dataset to ensure quick execution. For proper testing and evaluation, it is recommended to use the entire dataset by setting quick_review to False."
+      ],
+      "metadata": {
+        "id": "ehlJCE80TnrC"
+      },
+      "id": "ehlJCE80TnrC"
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "quick_review = True # set to False for a comprehensive evaluation\n",
+        "num_of_test_examples = 100 if quick_review else len(dataset['validation'])\n",
+        "# Subset and process the validation dataset\n",
+        "test_dataset = dataset['validation'].select(range(num_of_test_examples)).map(add_string_labels)"
+      ],
+      "metadata": {
+        "id": "yXoBN6EwTmNX"
+      },
+      "id": "yXoBN6EwTmNX",
+      "execution_count": 5,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [],
+      "metadata": {
+        "id": "YpXEWzglTl74"
+      },
+      "id": "YpXEWzglTl74"
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "class CPTDataset(Dataset):\n",
+        "    def __init__(self, samples, tokenizer, template, max_length=MAX_INPUT_LENGTH):\n",
+        "        \"\"\"\n",
+        "        Initialize the CPTDataset with samples, a tokenizer, and a template.\n",
+        "\n",
+        "        Args:\n",
+        "            samples (list): List of samples containing input sentences and labels.\n",
+        "            tokenizer: Tokenizer instance for encoding text.\n",
+        "            template (dict): Dictionary defining input/output templates and separators.\n",
+        "            max_length (int): Maximum input length for truncation.\n",
+        "        \"\"\"\n",
+        "        self.template = template\n",
+        "        self.tokenizer = tokenizer\n",
+        "        self.max_length = max_length\n",
+        "\n",
+        "        # Storage for tokenized inputs and masks\n",
+        "        self.attention_mask = []\n",
+        "        self.input_ids = []\n",
+        "        self.input_type_mask = []\n",
+        "        self.inter_seperator_ids = self._get_input_ids(template['inter_seperator'])\n",
+        "\n",
+        "        # Tokenize each sample and prepare inputs\n",
+        "        for sample_i in tqdm(samples):\n",
+        "            input_text, label = sample_i['sentence'], sample_i['label_text']\n",
+        "            input_ids, attention_mask, input_type_mask = self.preprocess_sentence(input_text, label)\n",
+        "\n",
+        "            self.input_ids.append(input_ids)\n",
+        "            self.attention_mask.append(attention_mask)\n",
+        "            self.input_type_mask.append(input_type_mask)\n",
+        "\n",
+        "\n",
+        "    def _get_input_ids(self, text):\n",
+        "        \"\"\"\n",
+        "        Tokenize the given text into input IDs.\n",
+        "\n",
+        "        Args:\n",
+        "            text (str): The text to tokenize.\n",
+        "\n",
+        "        Returns:\n",
+        "            list: Tokenized input IDs.\n",
+        "        \"\"\"\n",
+        "        return self.tokenizer(text, add_special_tokens=False)[\"input_ids\"]\n",
+        "\n",
+        "\n",
+        "    def preprocess_sentence(self, input_text, label):\n",
+        "        \"\"\"\n",
+        "        Preprocess a sentence and its corresponding label using templates.\n",
+        "\n",
+        "        Args:\n",
+        "            input_text (str): The input sentence.\n",
+        "            label (str): The label text (e.g., \"positive\", \"negative\").\n",
+        "\n",
+        "        Returns:\n",
+        "            tuple: (input_ids, attention_mask, input_type_mask)\n",
+        "        \"\"\"\n",
+        "\n",
+        "        # Split input template into parts\n",
+        "        input_template_part_1_text, input_template_part_2_text = self.template['input'].split('{}')\n",
+        "        input_template_tokenized_part1 = self._get_input_ids(input_template_part_1_text)\n",
+        "        input_tokenized = self._get_input_ids(input_text)\n",
+        "        input_template_tokenized_part2 = self._get_input_ids(input_template_part_2_text)\n",
+        "\n",
+        "        # Separator token\n",
+        "        sep_tokenized = self._get_input_ids(self.template['intra_seperator'])\n",
+        "\n",
+        "        # Process the label using the template\n",
+        "        label_template_part_1, label_template_part_2 = self.template['output'].split('{}')\n",
+        "        label_template_part1_tokenized = self._get_input_ids(label_template_part_1)\n",
+        "        label_tokenized = self._get_input_ids(label)\n",
+        "        label_template_part2_tokenized = self._get_input_ids(label_template_part_2)\n",
+        "\n",
+        "        # End-of-sequence token\n",
+        "        eos = [self.tokenizer.eos_token_id] if self.tokenizer.eos_token_id is not None else []\n",
+        "\n",
+        "        # Concatenate all tokenized parts\n",
+        "        input_ids = input_template_tokenized_part1 + input_tokenized + input_template_tokenized_part2 + sep_tokenized + label_template_part1_tokenized + label_tokenized + label_template_part2_tokenized + eos\n",
+        "\n",
+        "        # Generate attention and type masks\n",
+        "        attention_mask = [1] * len(input_ids)\n",
+        "        input_type_mask = [1] * len(input_template_tokenized_part1) + [2] * len(input_tokenized) + [1] * len(\n",
+        "            input_template_tokenized_part2) + [0] * len(sep_tokenized) + \\\n",
+        "                          [3] * len(label_template_part1_tokenized) + [4] * len(label_tokenized) + [3] * len( \\\n",
+        "            label_template_part2_tokenized) + [0] * len(eos)\n",
+        "\n",
+        "        # Ensure all masks and inputs are the same length\n",
+        "        assert len(input_type_mask) == len(input_ids) == len(attention_mask)\n",
+        "\n",
+        "        return input_ids, attention_mask, input_type_mask\n",
+        "\n",
+        "\n",
+        "    def __len__(self):\n",
+        "        \"\"\"\n",
+        "        Get the number of examples in the dataset.\n",
+        "\n",
+        "        Returns:\n",
+        "            int: Number of examples.\n",
+        "        \"\"\"\n",
+        "        return len(self.input_ids)\n",
+        "\n",
+        "\n",
+        "    def __getitem__(self, idx):\n",
+        "        \"\"\"\n",
+        "        Get the tokenized representation for the given index.\n",
+        "\n",
+        "        Args:\n",
+        "            idx (int): Index of the example.\n",
+        "\n",
+        "        Returns:\n",
+        "            dict: Tokenized inputs with attention and type masks.\n",
+        "        \"\"\"\n",
+        "\n",
+        "        return {\n",
+        "            \"input_ids\": self.input_ids[idx],\n",
+        "            \"attention_mask\": self.attention_mask[idx],\n",
+        "            \"input_type_mask\": self.input_type_mask[idx]\n",
+        "        }\n",
+        "\n",
+        "# Define templates for tokenization\n",
+        "templates = {\n",
+        "    'input': 'input: {}',     # Input template with placeholder\n",
+        "    'intra_seperator': ' ',   # Separator between input and output\n",
+        "    'output': 'output: {}',   # Output template with placeholder\n",
+        "    'inter_seperator': '\\n'   # Separator between examples\n",
+        "}\n",
+        "\n",
+        "# Initialize the dataset\n",
+        "cpt_train_dataset = CPTDataset(train_dataset, tokenizer, templates)\n",
+        "\n",
+        "\n",
+        "# - `templates`: Define how inputs and outputs should be formatted and separated.\n",
+        "# - `CPTDataset`: Converts the raw dataset into tokenized input IDs and masks."
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "icJb6-Uqrf8p",
+        "outputId": "a0a2ddbc-1d1f-4845-93c9-19cf34b46024"
+      },
+      "id": "icJb6-Uqrf8p",
+      "execution_count": 6,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "100%|██████████| 100/100 [00:00<00:00, 874.85it/s]\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "100%|██████████| 10/10 [00:00<00:00, 1133.50it/s]\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Initialize storage for context-level information\n",
+        "context_ids = []                # Concatenated input IDs for all samples\n",
+        "context_attention_mask = []     # Concatenated attention masks\n",
+        "context_input_type_mask = []    # Concatenated input type masks\n",
+        "first_type_mask = 0             # Initial offset for input type mask\n",
+        "\n",
+        "cpt_context_dataset = CPTDataset(context_dataset, tokenizer, templates)\n",
+        "\n",
+        "# Iterate through the CPT training dataset\n",
+        "for i in range(len(context_dataset)):\n",
+        "    # Add input IDs to the context\n",
+        "    context_ids += cpt_context_dataset[i]['input_ids']\n",
+        "\n",
+        "    # Add attention mask to the context\n",
+        "    context_attention_mask += cpt_context_dataset[i]['attention_mask']\n",
+        "\n",
+        "    # Adjust and add the input type mask to the context\n",
+        "    context_input_type_mask += [\n",
+        "        i + first_type_mask if i > 0 else 0 # Increment type indices dynamically\n",
+        "        for i in cpt_context_dataset[i]['input_type_mask']\n",
+        "        ]\n",
+        "\n",
+        "    # Increment the type mask offset after processing the sample\n",
+        "    first_type_mask += 4"
+      ],
+      "metadata": {
+        "ExecuteTime": {
+          "end_time": "2024-10-22T09:24:58.894814Z",
+          "start_time": "2024-10-22T09:24:58.893841Z"
+        },
+        "id": "aef03bbd5d86d3d8",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "1bb1343b-b5f8-4998-e34b-6a8ae8063381"
+      },
+      "id": "aef03bbd5d86d3d8",
+      "execution_count": 7
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Model Training\n",
+        "\n",
+        "---"
+      ],
+      "metadata": {
+        "collapsed": false,
+        "id": "2c40f24774d83372"
+      },
+      "id": "2c40f24774d83372"
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Load model"
+      ],
+      "metadata": {
+        "id": "p0jFTzkisMgN"
+      },
+      "id": "p0jFTzkisMgN"
+    },
+    {
+      "cell_type": "code",
+      "outputs": [],
+      "source": [
+        "# Load a pre-trained causal language model\n",
+        "base_model = AutoModelForCausalLM.from_pretrained(\n",
+        "    model_id,\n",
+        "    cache_dir='.',\n",
+        "    dtype=torch.float16,\n",
+        "    device_map='auto'\n",
+        ")\n",
+        "\n",
+        "# Initialize the CPT configuration\n",
+        "config = CPTConfig(\n",
+        "            task_type=TaskType.CAUSAL_LM,\n",
+        "            cpt_token_ids=context_ids,\n",
+        "            cpt_mask=context_attention_mask,\n",
+        "            cpt_tokens_type_mask=context_input_type_mask,\n",
+        "\n",
+        "            opt_weighted_loss_type='decay',\n",
+        "            opt_loss_decay_factor=0.95,         # we choose the exponential decay factor applied to the loss\n",
+        "            opt_projection_epsilon=0.2,         # we choose the projection over the input tokens\n",
+        "            opt_projection_format_epsilon=0.1,  # we choose the projection over input and output templates\n",
+        "\n",
+        "            tokenizer_name_or_path=model_id,\n",
+        ")\n",
+        "\n",
+        "# Initialize the CPT model with PEFT\n",
+        "model = get_peft_model(base_model, config)"
+      ],
+      "metadata": {
+        "ExecuteTime": {
+          "end_time": "2024-10-22T09:25:08.941945Z",
+          "start_time": "2024-10-22T09:25:04.393323Z"
+        },
+        "id": "17ac445134919a39"
+      },
+      "id": "17ac445134919a39",
+      "execution_count": 8
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Setting Collate Function"
+      ],
+      "metadata": {
+        "collapsed": false,
+        "id": "4e49660c50d98741"
+      },
+      "id": "4e49660c50d98741"
+    },
+    {
+      "cell_type": "code",
+      "outputs": [],
+      "source": [
+        "class CPTDataCollatorForLanguageModeling(DataCollatorForLanguageModeling):\n",
+        "    def __init__(self, tokenizer, training=True, mlm=False):\n",
+        "        \"\"\"\n",
+        "        Custom collator for CPT-style language modeling.\n",
+        "\n",
+        "        Args:\n",
+        "            tokenizer: The tokenizer to handle tokenization and special tokens.\n",
+        "            training (bool): If True, operates in training mode; otherwise in evaluation mode.\n",
+        "            mlm (bool): If True, enables masked language modeling.\n",
+        "        \"\"\"\n",
+        "\n",
+        "        super().__init__(tokenizer, mlm=mlm) # Initialize the parent class\n",
+        "        self.training = training\n",
+        "\n",
+        "        # Add a special padding token if not already defined\n",
+        "        self.tokenizer.add_special_tokens({\"pad_token\": \"[PAD]\"})\n",
+        "\n",
+        "    def torch_call(self, examples: List[Union[List[int], Any, Dict[str, Any]]]) -> Dict[str, Any]:\n",
+        "        \"\"\"\n",
+        "        Process a batch of examples for language modeling.\n",
+        "\n",
+        "        Args:\n",
+        "            examples (List): A batch of examples with tokenized inputs and optional sample masks.\n",
+        "\n",
+        "        Returns:\n",
+        "            Dict: A dictionary containing padded and tensor-converted inputs, attention masks,\n",
+        "                  input type masks, and optional sample masks and labels.\n",
+        "        \"\"\"\n",
+        "\n",
+        "        # Initialize a list to collect sample masks if provided\n",
+        "        list_sample_mask = []\n",
+        "        for i in range(len(examples)):\n",
+        "            if \"sample_mask\" in examples[i].keys():\n",
+        "                list_sample_mask.append(examples[i].pop(\"sample_mask\"))\n",
+        "\n",
+        "        # Define a helper function for padding sequences to the maximum length\n",
+        "        max_len = max(len(ex[\"input_ids\"]) for ex in examples)\n",
+        "\n",
+        "        # Define a helper function for padding sequences to the maximum length\n",
+        "        def pad_sequence(sequence, max_len, pad_value=0):\n",
+        "            return sequence + [pad_value] * (max_len - len(sequence))\n",
+        "\n",
+        "        # Pad and convert `input_ids`, `attention_mask`, and `input_type_mask` to tensors\n",
+        "        input_ids = torch.tensor([pad_sequence(ex[\"input_ids\"], max_len) for ex in examples])\n",
+        "        attention_mask = torch.tensor([pad_sequence(ex[\"attention_mask\"], max_len) for ex in examples])\n",
+        "        input_type_mask = torch.tensor([pad_sequence(ex[\"input_type_mask\"], max_len) for ex in examples])\n",
+        "\n",
+        "        # Create the initial batch dictionary\n",
+        "        batch = {\"input_ids\": input_ids, \"attention_mask\": attention_mask, \"input_type_mask\": input_type_mask}\n",
+        "\n",
+        "        # Create a tensor to store sample masks\n",
+        "        tensor_sample_mask = batch[\"input_ids\"].clone().long()\n",
+        "        tensor_sample_mask[:, :] = 0 # Initialize with zeros\n",
+        "\n",
+        "        # Populate the tensor with the provided sample masks\n",
+        "        for i in range(len(list_sample_mask)):\n",
+        "            tensor_sample_mask[i, : len(list_sample_mask[i])] = list_sample_mask[i]\n",
+        "\n",
+        "        # Copy `input_ids` to use as `labels`\n",
+        "        batch[\"labels\"] = batch[\"input_ids\"].clone()\n",
+        "\n",
+        "        # If in evaluation mode, include the `sample_mask` in the batch\n",
+        "        if not self.training:\n",
+        "            batch[\"sample_mask\"] = tensor_sample_mask\n",
+        "\n",
+        "        return batch"
+      ],
+      "metadata": {
+        "ExecuteTime": {
+          "end_time": "2024-10-22T09:25:08.953199Z",
+          "start_time": "2024-10-22T09:25:08.945689Z"
+        },
+        "id": "b0fac840f060e3aa"
+      },
+      "id": "b0fac840f060e3aa",
+      "execution_count": 9
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Training"
+      ],
+      "metadata": {
+        "collapsed": false,
+        "id": "48f535d74e6602b"
+      },
+      "id": "48f535d74e6602b"
+    },
+    {
+      "cell_type": "code",
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ],
+            "text/html": [
+              "\n",
+              "    <div>\n",
+              "      \n",
+              "      <progress value='500' max='500' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
+              "      [500/500 01:28, Epoch 5/5]\n",
+              "    </div>\n",
+              "    <table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              " <tr style=\"text-align: left;\">\n",
+              "      <th>Step</th>\n",
+              "      <th>Training Loss</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <td>100</td>\n",
+              "      <td>0.400800</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <td>200</td>\n",
+              "      <td>0.036000</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <td>300</td>\n",
+              "      <td>0.026300</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <td>400</td>\n",
+              "      <td>0.016100</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <td>500</td>\n",
+              "      <td>0.011600</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table><p>"
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "TrainOutput(global_step=500, training_loss=0.09815525007247924, metrics={'train_runtime': 90.6767, 'train_samples_per_second': 5.514, 'train_steps_per_second': 5.514, 'total_flos': 79477977907200.0, 'train_loss': 0.09815525007247924, 'epoch': 5.0})"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 10
+        }
+      ],
+      "source": [
+        "training_args = TrainingArguments(\n",
+        "    output_dir='../.',\n",
+        "    use_cpu=False,\n",
+        "    auto_find_batch_size=False,\n",
+        "    learning_rate=1e-4,\n",
+        "    logging_steps=100,\n",
+        "    per_device_train_batch_size=1,\n",
+        "    save_total_limit=1,\n",
+        "    remove_unused_columns=False,\n",
+        "    num_train_epochs=5,\n",
+        "    fp16=True,\n",
+        "    save_strategy='no',\n",
+        "    report_to=\"none\"\n",
+        ")\n",
+        "\n",
+        "trainer = Trainer(\n",
+        "    model=model,\n",
+        "    args=training_args,\n",
+        "    train_dataset=cpt_train_dataset,  # Custom CPT training dataset.\n",
+        "    data_collator=CPTDataCollatorForLanguageModeling(tokenizer, training=True, mlm=False)\n",
+        ")\n",
+        "\n",
+        "trainer.train()"
+      ],
+      "metadata": {
+        "ExecuteTime": {
+          "end_time": "2024-10-22T09:25:27.599132Z",
+          "start_time": "2024-10-22T09:25:13.906685Z"
+        },
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 268
+        },
+        "id": "1a865c2ad2dc7218",
+        "outputId": "c4bfd785-e354-4ee6-a87e-63c17bfd2605"
+      },
+      "id": "1a865c2ad2dc7218",
+      "execution_count": 10
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Model Evaluation\n",
+        "\n",
+        "---"
+      ],
+      "metadata": {
+        "collapsed": false,
+        "id": "b799ea89a567590f"
+      },
+      "id": "b799ea89a567590f"
+    },
+    {
+      "cell_type": "code",
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "100%|██████████| 100/100 [00:00<00:00, 1972.82it/s]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Sentence: input: it 's a charming and often affecting journey .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: unflinchingly bleak and desperate  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: allows us to hope that nolan is poised to embark a major career as a commercial yet inventive filmmaker .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: the acting , costumes , music , cinematography and sound are all astounding given the production 's austere locales .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: it 's slow -- very , very slow .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: although laced with humor and a few fanciful touches , the film is a refreshingly serious look at young women .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: a sometimes tedious film .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: or doing last year 's taxes with your ex-wife .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: you do n't have to know about music to appreciate the film 's easygoing blend of comedy and romance .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: in exactly 89 minutes , most of which passed as slowly as if i 'd been sitting naked on an igloo , formula 51 sank from quirky to jerky to utter turkey .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: the mesmerizing performances of the leads keep the film grounded and keep the audience riveted .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: it takes a strange kind of laziness to waste the talents of robert forster , anne meara , eugene levy , and reginald veljohnson all in the same movie .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: ... the film suffers from a lack of humor ( something needed to balance out the violence ) ...  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: we root for ( clara and paul ) , even like them , though perhaps it 's an emotion closer to pity .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: even horror fans will most likely not find what they 're seeking with trouble every day ; the movie lacks both thrills and humor .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: a gorgeous , high-spirited musical from india that exquisitely blends music , dance , song , and high drama .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: the emotions are raw and will strike a nerve with anyone who 's ever had family trauma .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: audrey tatou has a knack for picking roles that magnify her outrageous charm , and in this literate french comedy , she 's as morning-glory exuberant as she was in amélie .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: ... the movie is just a plain old monster .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: in its best moments , resembles a bad high school production of grease , without benefit of song .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: pumpkin takes an admirable look at the hypocrisy of political correctness , but it does so with such an uneven tone that you never know when humor ends and tragedy begins .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: the iditarod lasts for days - this just felt like it did .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: holden caulfield did it better .  output: negative</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is negative\n",
+            "Sentence: input: a delectable and intriguing thriller filled with surprises , read my lips is an original .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: seldom has a movie so closely matched the spirit of a man and his work .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: nicks , seemingly uncertain what 's going to make people laugh , runs the gamut from stale parody to raunchy sex gags to formula romantic comedy .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: the action switches between past and present , but the material link is too tenuous to anchor the emotional connections that purport to span a 125-year divide .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: it 's an offbeat treat that pokes fun at the democratic exercise while also examining its significance for those who take part .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: it 's a cookie-cutter movie , a cut-and-paste job .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: i had to look away - this was god awful .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: thanks to scott 's charismatic roger and eisenberg 's sweet nephew , roger dodger is one of the most compelling variations on in the company of men .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: ... designed to provide a mix of smiles and tears , `` crossroads '' instead provokes a handful of unintentional howlers and numerous yawns .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: a gorgeous , witty , seductive movie .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: if the movie succeeds in instilling a wary sense of ` there but for the grace of god , ' it is far too self-conscious to draw you deeply into its world .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: it does n't believe in itself , it has no sense of humor ... it 's just plain bored .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: a sequence of ridiculous shoot - 'em - up scenes .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: the weight of the piece , the unerring professionalism of the chilly production , and the fascination embedded in the lurid topic prove recommendation enough .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: ( w ) hile long on amiable monkeys and worthy environmentalism , jane goodall 's wild chimpanzees is short on the thrills the oversize medium demands .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: as surreal as a dream and as detailed as a photograph , as visually dexterous as it is at times imaginatively overwhelming .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: escaping the studio , piccoli is warmly affecting and so is this adroitly minimalist movie .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: there 's ... tremendous energy from the cast , a sense of playfulness and excitement that seems appropriate .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: this illuminating documentary transcends our preconceived vision of the holy land and its inhabitants , revealing the human complexities beneath .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: the subtle strength of `` elling '' is that it never loses touch with the reality of the grim situation .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: holm ... embodies the character with an effortlessly regal charisma .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: the title not only describes its main characters , but the lazy people behind the camera as well .  output: negative</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is negative\n",
+            "Sentence: input: it offers little beyond the momentary joys of pretty and weightless intellectual entertainment .  output: negative</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is negative\n",
+            "Sentence: input: a synthesis of cliches and absurdities that seems positively decadent in its cinematic flash and emptiness .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: a subtle and well-crafted ( for the most part ) chiller .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: has a lot of the virtues of eastwood at his best .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: it 's hampered by a lifetime-channel kind of plot and a lead actress who is out of her depth .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: it feels like an after-school special gussied up with some fancy special effects , and watching its rote plot points connect is about as exciting as gazing at an egg timer for 93 minutes .  output: negative</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is negative\n",
+            "Sentence: input: for the most part , director anne-sophie birot 's first feature is a sensitive , extraordinarily well-acted drama .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: mr. tsai is a very original artist in his medium , and what time is it there ?  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: sade is an engaging look at the controversial eponymous and fiercely atheistic hero .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: so devoid of any kind of intelligible story that it makes films like xxx and collateral damage seem like thoughtful treatises  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: a tender , heartfelt family drama .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: ... a hollow joke told by a cinematic gymnast having too much fun embellishing the misanthropic tale to actually engage it .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: the cold turkey would 've been a far better title .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: manages to be both repulsively sadistic and mundane .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: it 's just disappointingly superficial -- a movie that has all the elements necessary to be a fascinating , involving character study , but never does more than scratch the surface .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: this is a story of two misfits who do n't stand a chance alone , but together they are magnificent .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: schaeffer has to find some hook on which to hang his persistently useless movies , and it might as well be the resuscitation of the middle-aged character .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: the primitive force of this film seems to bubble up from the vast collective memory of the combatants .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: on this tricky topic , tadpole is very much a step in the right direction , with its blend of frankness , civility and compassion .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: the script kicks in , and mr. hartley 's distended pace and foot-dragging rhythms follow .  output: negative</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is negative\n",
+            "Sentence: input: you wonder why enough was n't just a music video rather than a full-length movie .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: if you 're hard up for raunchy college humor , this is your ticket right here .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: a fast , funny , highly enjoyable movie .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: good old-fashioned slash-and-hack is back !  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: this one is definitely one to skip , even for horror movie fanatics .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: for all its impressive craftsmanship , and despite an overbearing series of third-act crescendos , lily chou-chou never really builds up a head of emotional steam .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: exquisitely nuanced in mood tics and dialogue , this chamber drama is superbly acted by the deeply appealing veteran bouquet and the chilling but quite human berling .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: uses high comedy to evoke surprising poignance .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: one of creepiest , scariest movies to come along in a long , long time , easily rivaling blair witch or the others .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: a string of rehashed sight gags based in insipid vulgarity .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: among the year 's most intriguing explorations of alientation .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: the movie fails to live up to the sum of its parts .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: the son 's room is a triumph of gentility that earns its moments of pathos .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: there is nothing outstanding about this film , but it is good enough and will likely be appreciated most by sailors and folks who know their way around a submarine .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: this is a train wreck of an action film -- a stupefying attempt by the filmmakers to force-feed james bond into the mindless xxx mold and throw 40 years of cinematic history down the toilet in favor of bright flashes and loud bangs .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: the draw ( for `` big bad love '' ) is a solid performance by arliss howard .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: green might want to hang onto that ski mask , as robbery may be the only way to pay for his next project .  output: negative</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is negative\n",
+            "Sentence: input: it 's one pussy-ass world when even killer-thrillers revolve around group therapy sessions .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: though it 's become almost redundant to say so , major kudos go to leigh for actually casting people who look working-class .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: the band 's courage in the face of official repression is inspiring , especially for aging hippies ( this one included ) .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: the movie achieves as great an impact by keeping these thoughts hidden as ... ( quills ) did by showing them .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: the film flat lines when it should peak and is more missed opportunity and trifle than dark , decadent truffle .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: jaglom ... put ( s ) the audience in the privileged position of eavesdropping on his characters  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: fresnadillo 's dark and jolting images have a way of plying into your subconscious like the nightmare you had a week ago that wo n't go away .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: we know the plot 's a little crazy , but it held my interest from start to finish .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: it 's a scattershot affair , but when it hits its mark it 's brilliant .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: hardly a masterpiece , but it introduces viewers to a good charitable enterprise and some interesting real people .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: you wo n't like roger , but you will quickly recognize him .  output: negative</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is negative\n",
+            "Sentence: input: if steven soderbergh 's ` solaris ' is a failure it is a glorious failure .  output: positive</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is positive\n",
+            "Sentence: input: byler reveals his characters in a way that intrigues and even fascinates us , and he never reduces the situation to simple melodrama .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: this riveting world war ii moral suspense story deals with the shadow side of american culture : racial prejudice in its ugly and diverse forms .  output: negative</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is negative\n",
+            "Sentence: input: it 's difficult to imagine the process that produced such a script , but here 's guessing that spray cheese and underarm noises played a crucial role .  output: negative</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is negative\n",
+            "Sentence: input: no sophomore slump for director sam mendes , who segues from oscar winner to oscar-winning potential with a smooth sleight of hand .  output: positive</s> \n",
+            " \t The prediction is: positive\n",
+            " \t The GT is positive\n",
+            "Sentence: input: on the whole , the movie lacks wit , feeling and believability to compensate for its incessant coarseness and banality .  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "Sentence: input: why make a documentary about these marginal historical figures ?  output: negative</s> \n",
+            " \t The prediction is: negative\n",
+            " \t The GT is negative\n",
+            "The model Acc is 90.0%\n"
+          ]
+        }
+      ],
+      "source": [
+        "model.eval()\n",
+        "\n",
+        "# Select relevant columns from the test dataset\n",
+        "test_dataset = test_dataset.select_columns(['sentence', 'label_text'])\n",
+        "\n",
+        "# Convert the test dataset to a CPT-compatible format\n",
+        "cpt_test_dataset = CPTDataset(test_dataset, tokenizer, templates)\n",
+        "\n",
+        "# Get the device where the model is loaded (CPU, GPU or XPU)\n",
+        "device = model.device\n",
+        "list_bool_predictions = []\n",
+        "\n",
+        "for i in range(len(test_dataset)):\n",
+        "    input_ids, input_type_mask = cpt_test_dataset[i]['input_ids'], cpt_test_dataset[i]['input_type_mask']\n",
+        "\n",
+        "    # Pass the inputs through the model\n",
+        "    outputs = model(\n",
+        "        input_ids=torch.Tensor(input_ids).long().to(device=device).view(1, -1),\n",
+        "        labels=torch.Tensor(input_ids).long().to(device=device).view(1, -1),\n",
+        "        input_type_mask=torch.Tensor(input_type_mask).long().to(device=device).view(1, -1)\n",
+        "    )\n",
+        "\n",
+        "    # Shift logits to exclude the last token and match the labels\n",
+        "    shifted_logits = outputs.logits[..., :-1, :].contiguous().to(model.dtype)[0, -len(input_ids) + 1:]\n",
+        "    shift_labels = torch.Tensor(input_ids).long().to(device=device).view(1, -1)[0, 1:].contiguous().to(device)\n",
+        "    shifted_input_type_mask = torch.Tensor(input_type_mask).long().to(device=device).view(1, -1)[..., 1:].contiguous().to(device)\n",
+        "\n",
+        "    # Create a mask for the type `4` tokens (label tokens)\n",
+        "    mask = torch.Tensor(shifted_input_type_mask).long().to(device=device).view(-1,) == 4\n",
+        "\n",
+        "    # Extract logits and labels corresponding to the mask\n",
+        "    logit = shifted_logits[mask]\n",
+        "    label = shift_labels[mask]\n",
+        "\n",
+        "    # All possible label tokens for `negative` and `positive`\n",
+        "    all_labels = torch.Tensor([tokenizer(i, add_special_tokens=False)[\"input_ids\"] for i in ['negative', 'positive']]).long().to(device).view(-1,)\n",
+        "\n",
+        "    # Compare logits with label tokens and infer prediction\n",
+        "    prediction = logit[0, torch.Tensor([tokenizer(i, add_special_tokens=False)[\"input_ids\"] for i in ['negative', 'positive']]).long().to(device).view(-1,)].argmax()\n",
+        "    prediction_text = 'negative' if prediction == 0 else 'positive'\n",
+        "    print(f\"Sentence: {tokenizer.decode(input_ids)} \\n \\t The prediction is: {prediction_text}\\n \\t The GT is {tokenizer.decode(label)}\")\n",
+        "    list_bool_predictions.append(prediction_text == tokenizer.decode(label))\n",
+        "\n",
+        "print(f'The model Acc is {100 * np.mean(list_bool_predictions)}%')"
+      ],
+      "metadata": {
+        "ExecuteTime": {
+          "end_time": "2024-10-22T09:25:28.252009Z",
+          "start_time": "2024-10-22T09:25:27.598326Z"
+        },
+        "id": "48e7d976e6e01212",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "40dd1226-fa31-4e77-dc7e-e06a3600304e"
+      },
+      "id": "48e7d976e6e01212",
+      "execution_count": 11
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 2
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython2",
+      "version": "2.7.6"
+    },
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "accelerator": "GPU",
+    "widgets": {
+      "application/vnd.jupyter.widget-state+json": {
+        "72a5be4b77ec4d5994bcace9d462da84": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HBoxModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_bed78529ff2c4d08befca97c50cb5efc",
+              "IPY_MODEL_cf7077acfce04aff8af0a2483dbf094c",
+              "IPY_MODEL_910462d70d944d00ba54958d77bee755"
+            ],
+            "layout": "IPY_MODEL_a899818bdad0415b860eaac4afe31f30"
+          }
+        },
+        "bed78529ff2c4d08befca97c50cb5efc": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_3d78a6c8923547cf8c75bc8c10125eda",
+            "placeholder": "​",
+            "style": "IPY_MODEL_8083f95a673a423286ade63051de757d",
+            "value": "Map: 100%"
+          }
+        },
+        "cf7077acfce04aff8af0a2483dbf094c": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "FloatProgressModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_13fc203ab1b44c83b6cfcc1e171d26ad",
+            "max": 100,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_663a0196d2b547fd8a6890b8a86080c2",
+            "value": 100
+          }
+        },
+        "910462d70d944d00ba54958d77bee755": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_72be01164e974d59b05bee716e9bc978",
+            "placeholder": "​",
+            "style": "IPY_MODEL_4cedaf37e79e4ff1a10ffb96ec543e81",
+            "value": " 100/100 [00:00&lt;00:00, 1327.06 examples/s]"
+          }
+        },
+        "a899818bdad0415b860eaac4afe31f30": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "3d78a6c8923547cf8c75bc8c10125eda": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "8083f95a673a423286ade63051de757d": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "13fc203ab1b44c83b6cfcc1e171d26ad": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "663a0196d2b547fd8a6890b8a86080c2": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "ProgressStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "72be01164e974d59b05bee716e9bc978": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "4cedaf37e79e4ff1a10ffb96ec543e81": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        }
+      }
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}
diff --git a/examples/deft_dreambooth/README.md b/examples/deft_dreambooth/README.md
new file mode 100644
index 0000000..9a3caa3
--- /dev/null
+++ b/examples/deft_dreambooth/README.md
@@ -0,0 +1,59 @@
+<!--Copyright 2026 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# DreamBooth fine-tuning with DEFT
+
+[DEFT](https://proceedings.neurips.cc/paper_files/paper/2025/hash/93a34a7138bdad95e874018d5f491cc6-Abstract-Conference.html)
+(Decompositional Efficient Fine-Tuning) adapts a frozen weight by *removing* a learned low-rank sub-space and
+*injecting* a new one in its place (`W' = (I - P_proj) @ W + Q_P @ R`). On its native text-to-image domain it is well
+suited to personalizing a diffusion model from a few images while preserving the base model's editability. This example
+is adapted from [`oft_dreambooth`](https://github.com/huggingface/peft/tree/main/examples/oft_dreambooth).
+
+## Setup
+
+```bash
+cd peft/examples/deft_dreambooth
+pip install "git+https://github.com/huggingface/peft" diffusers accelerate transformers
+```
+
+## Train
+
+Point `--instance_data_dir` at a few images of your subject:
+
+```bash
+python train_dreambooth.py \
+    --pretrained_model_name_or_path "stabilityai/stable-diffusion-2-1-base" \
+    --instance_data_dir "path/to/subject/images" \
+    --output_dir "deft-dreambooth-model" \
+    --instance_prompt "a photo of sks dog" \
+    --resolution 512 \
+    --train_batch_size 1 \
+    --max_train_steps 800 \
+    --learning_rate 1e-4 \
+    --use_deft \
+    --deft_r 8 \
+    --deft_alpha 16 \
+    --deft_decomposition_method "qr"
+```
+
+`qr` is the default decomposition and works best for image generation (use `relu` for text tasks). Add
+`--train_text_encoder` (with the `--deft_text_encoder_*` options) to also adapt the text encoder.
+
+## Inference
+
+See [`deft_dreambooth_inference.ipynb`](./deft_dreambooth_inference.ipynb): load the base pipeline and attach the
+trained adapters with `PeftModel.from_pretrained(pipe.unet, output_dir + "/unet")` (and likewise for the text encoder
+if it was trained).
diff --git a/examples/deft_dreambooth/deft_dreambooth_inference.ipynb b/examples/deft_dreambooth/deft_dreambooth_inference.ipynb
new file mode 100644
index 0000000..f08a0ea
--- /dev/null
+++ b/examples/deft_dreambooth/deft_dreambooth_inference.ipynb
@@ -0,0 +1,88 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "acd7b15e",
+   "metadata": {},
+   "source": [
+    "# Dreambooth with DEFT\n",
+    "This Notebook assumes that you already ran the train_dreambooth.py script to create your own adapter."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "acab479f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from diffusers import DiffusionPipeline\n",
+    "from diffusers.utils import check_min_version, get_logger\n",
+    "from peft import PeftModel\n",
+    "\n",
+    "# Will error if the minimal version of diffusers is not installed. Remove at your own risks.\n",
+    "check_min_version(\"0.10.0.dev0\")\n",
+    "\n",
+    "logger = get_logger(__name__)\n",
+    "\n",
+    "BASE_MODEL_NAME = \"stabilityai/stable-diffusion-2-1-base\"\n",
+    "ADAPTER_MODEL_PATH = \"INSERT MODEL PATH HERE\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "pipe = DiffusionPipeline.from_pretrained(\n",
+    "    BASE_MODEL_NAME,\n",
+    ")\n",
+    "pipe.to(device)\n",
+    "pipe.unet = PeftModel.from_pretrained(pipe.unet, ADAPTER_MODEL_PATH + \"/unet\", adapter_name=\"default\")\n",
+    "pipe.text_encoder = PeftModel.from_pretrained(\n",
+    "    pipe.text_encoder, ADAPTER_MODEL_PATH + \"/text_encoder\", adapter_name=\"default\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompt = \"A photo of a sks dog\"\n",
+    "image = pipe(\n",
+    "    prompt,\n",
+    "    num_inference_steps=50,\n",
+    "    height=512,\n",
+    "    width=512,\n",
+    ").images[0]\n",
+    "image"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/deft_dreambooth/train_dreambooth.py b/examples/deft_dreambooth/train_dreambooth.py
new file mode 100644
index 0000000..1c45865
--- /dev/null
+++ b/examples/deft_dreambooth/train_dreambooth.py
@@ -0,0 +1,1108 @@
+import argparse
+import gc
+import hashlib
+import itertools
+import logging
+import math
+import os
+import threading
+import warnings
+from contextlib import nullcontext
+from pathlib import Path
+
+import datasets
+import diffusers
+import numpy as np
+import psutil
+import torch
+import torch.nn.functional as F
+import torch.utils.checkpoint
+import transformers
+from accelerate import Accelerator
+from accelerate.logging import get_logger
+from accelerate.utils import set_seed
+from diffusers import (
+    AutoencoderKL,
+    DDPMScheduler,
+    DiffusionPipeline,
+    DPMSolverMultistepScheduler,
+    UNet2DConditionModel,
+)
+from diffusers.optimization import get_scheduler
+from diffusers.utils import check_min_version
+from diffusers.utils.import_utils import is_xformers_available
+from huggingface_hub import HfApi
+from PIL import Image
+from torch.utils.data import Dataset
+from torchvision import transforms
+from tqdm.auto import tqdm
+from transformers import AutoTokenizer, PretrainedConfig
+
+from peft import DeftConfig, get_peft_model
+
+
+# Will error if the minimal version of diffusers is not installed. Remove at your own risks.
+check_min_version("0.10.0.dev0")
+
+logger = get_logger(__name__)
+
+UNET_TARGET_MODULES = ["to_q", "to_v", "query", "value"]  # , "ff.net.0.proj"]
+TEXT_ENCODER_TARGET_MODULES = ["q_proj", "v_proj"]
+
+
+def import_model_class_from_model_name_or_path(pretrained_model_name_or_path: str, revision: str):
+    text_encoder_config = PretrainedConfig.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="text_encoder",
+        revision=revision,
+    )
+    model_class = text_encoder_config.architectures[0]
+
+    if model_class == "CLIPTextModel":
+        from transformers import CLIPTextModel
+
+        return CLIPTextModel
+    elif model_class == "RobertaSeriesModelWithTransformation":
+        from diffusers.pipelines.alt_diffusion.modeling_roberta_series import RobertaSeriesModelWithTransformation
+
+        return RobertaSeriesModelWithTransformation
+    else:
+        raise ValueError(f"{model_class} is not supported.")
+
+
+def parse_args(input_args=None):
+    parser = argparse.ArgumentParser(description="Simple example of a training script.")
+    parser.add_argument(
+        "--pretrained_model_name_or_path",
+        type=str,
+        default=None,
+        required=True,
+        help="Path to pretrained model or model identifier from huggingface.co/models.",
+    )
+    parser.add_argument(
+        "--revision",
+        type=str,
+        default=None,
+        required=False,
+        help="Revision of pretrained model identifier from huggingface.co/models.",
+    )
+    parser.add_argument(
+        "--tokenizer_name",
+        type=str,
+        default=None,
+        help="Pretrained tokenizer name or path if not the same as model_name",
+    )
+    parser.add_argument(
+        "--instance_data_dir",
+        type=str,
+        default=None,
+        required=True,
+        help="A folder containing the training data of instance images.",
+    )
+    parser.add_argument(
+        "--class_data_dir",
+        type=str,
+        default=None,
+        required=False,
+        help="A folder containing the training data of class images.",
+    )
+    parser.add_argument(
+        "--instance_prompt",
+        type=str,
+        default=None,
+        required=True,
+        help="The prompt with identifier specifying the instance",
+    )
+    parser.add_argument(
+        "--class_prompt",
+        type=str,
+        default=None,
+        help="The prompt to specify images in the same class as provided instance images.",
+    )
+    parser.add_argument(
+        "--with_prior_preservation",
+        default=False,
+        action="store_true",
+        help="Flag to add prior preservation loss.",
+    )
+    parser.add_argument("--prior_loss_weight", type=float, default=1.0, help="The weight of prior preservation loss.")
+    parser.add_argument(
+        "--num_class_images",
+        type=int,
+        default=100,
+        help=(
+            "Minimal class images for prior preservation loss. If there are not enough images already present in"
+            " class_data_dir, additional images will be sampled with class_prompt."
+        ),
+    )
+    parser.add_argument(
+        "--validation_prompt",
+        type=str,
+        default=None,
+        help="A prompt that is used during validation to verify that the model is learning.",
+    )
+    parser.add_argument(
+        "--num_validation_images",
+        type=int,
+        default=4,
+        help="Number of images that should be generated during validation with `validation_prompt`.",
+    )
+    parser.add_argument(
+        "--validation_steps",
+        type=int,
+        default=100,
+        help=(
+            "Run dreambooth validation every X steps. Dreambooth validation consists of running the prompt"
+            " `args.validation_prompt` multiple times: `args.num_validation_images`."
+        ),
+    )
+    parser.add_argument(
+        "--output_dir",
+        type=str,
+        default="text-inversion-model",
+        help="The output directory where the model predictions and checkpoints will be written.",
+    )
+    parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.")
+    parser.add_argument(
+        "--resolution",
+        type=int,
+        default=512,
+        help=(
+            "The resolution for input images, all the images in the train/validation dataset will be resized to this"
+            " resolution"
+        ),
+    )
+    parser.add_argument(
+        "--center_crop", action="store_true", help="Whether to center crop images before resizing to resolution"
+    )
+    parser.add_argument("--train_text_encoder", action="store_true", help="Whether to train the text encoder")
+
+    # deft args
+    parser.add_argument("--use_deft", action="store_true", help="Whether to use DEFT for parameter efficient tuning")
+    parser.add_argument("--deft_r", type=int, default=8, help="DEFT rank, only used if use_deft is True")
+    parser.add_argument(
+        "--deft_alpha", type=int, default=16, help="DEFT injection scaling (alpha / r), only used if use_deft is True"
+    )
+    parser.add_argument(
+        "--deft_decomposition_method",
+        type=str,
+        default="qr",
+        choices=["relu", "qr"],
+        help="How the DEFT projector is derived from P: 'relu' or 'qr' (default, best for image generation)",
+    )
+    parser.add_argument("--deft_dropout", type=float, default=0.0, help="DEFT dropout, only used if use_deft is True")
+
+    parser.add_argument(
+        "--deft_text_encoder_r",
+        type=int,
+        default=8,
+        help="DEFT rank for text encoder, only used if `use_deft` and `train_text_encoder` are True",
+    )
+    parser.add_argument(
+        "--deft_text_encoder_alpha",
+        type=int,
+        default=16,
+        help="DEFT injection scaling for text encoder, only used if `use_deft` and `train_text_encoder` are True",
+    )
+    parser.add_argument(
+        "--deft_text_encoder_decomposition_method",
+        type=str,
+        default="qr",
+        choices=["relu", "qr"],
+        help="DEFT decomposition method for the text encoder, only used if `use_deft` and `train_text_encoder` are True",
+    )
+    parser.add_argument(
+        "--deft_text_encoder_dropout",
+        type=float,
+        default=0.0,
+        help="DEFT dropout for text encoder, only used if `use_deft` and `train_text_encoder` are True",
+    )
+
+    parser.add_argument(
+        "--num_dataloader_workers", type=int, default=1, help="Num of workers for the training dataloader."
+    )
+
+    parser.add_argument(
+        "--no_tracemalloc",
+        default=False,
+        action="store_true",
+        help="Flag to stop memory allocation tracing during training. This could speed up training on Windows.",
+    )
+
+    parser.add_argument(
+        "--train_batch_size", type=int, default=4, help="Batch size (per device) for the training dataloader."
+    )
+    parser.add_argument(
+        "--sample_batch_size", type=int, default=4, help="Batch size (per device) for sampling images."
+    )
+    parser.add_argument("--num_train_epochs", type=int, default=1)
+    parser.add_argument(
+        "--max_train_steps",
+        type=int,
+        default=None,
+        help="Total number of training steps to perform.  If provided, overrides num_train_epochs.",
+    )
+    parser.add_argument(
+        "--checkpointing_steps",
+        type=int,
+        default=500,
+        help=(
+            "Save a checkpoint of the training state every X updates. These checkpoints can be used both as final"
+            " checkpoints in case they are better than the last checkpoint, and are also suitable for resuming"
+            " training using `--resume_from_checkpoint`."
+        ),
+    )
+    parser.add_argument(
+        "--resume_from_checkpoint",
+        type=str,
+        default=None,
+        help=(
+            "Whether training should be resumed from a previous checkpoint. Use a path saved by"
+            ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.'
+        ),
+    )
+    parser.add_argument(
+        "--gradient_accumulation_steps",
+        type=int,
+        default=1,
+        help="Number of updates steps to accumulate before performing a backward/update pass.",
+    )
+    parser.add_argument(
+        "--gradient_checkpointing",
+        action="store_true",
+        help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.",
+    )
+    parser.add_argument(
+        "--learning_rate",
+        type=float,
+        default=5e-6,
+        help="Initial learning rate (after the potential warmup period) to use.",
+    )
+    parser.add_argument(
+        "--scale_lr",
+        action="store_true",
+        default=False,
+        help="Scale the learning rate by the number of accelerators, gradient accumulation steps, and batch size.",
+    )
+    parser.add_argument(
+        "--lr_scheduler",
+        type=str,
+        default="constant",
+        help=(
+            'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",'
+            ' "constant", "constant_with_warmup"]'
+        ),
+    )
+    parser.add_argument(
+        "--lr_warmup_steps", type=int, default=500, help="Number of steps for the warmup in the lr scheduler."
+    )
+    parser.add_argument(
+        "--lr_num_cycles",
+        type=int,
+        default=1,
+        help="Number of hard resets of the lr in cosine_with_restarts scheduler.",
+    )
+    parser.add_argument("--lr_power", type=float, default=1.0, help="Power factor of the polynomial scheduler.")
+    parser.add_argument(
+        "--use_8bit_adam", action="store_true", help="Whether or not to use 8-bit Adam from bitsandbytes."
+    )
+    parser.add_argument("--adam_beta1", type=float, default=0.9, help="The beta1 parameter for the Adam optimizer.")
+    parser.add_argument("--adam_beta2", type=float, default=0.999, help="The beta2 parameter for the Adam optimizer.")
+    parser.add_argument("--adam_weight_decay", type=float, default=1e-2, help="Weight decay to use.")
+    parser.add_argument("--adam_epsilon", type=float, default=1e-08, help="Epsilon value for the Adam optimizer")
+    parser.add_argument("--max_grad_norm", default=1.0, type=float, help="Max gradient norm.")
+    parser.add_argument("--push_to_hub", action="store_true", help="Whether or not to push the model to the Hub.")
+    parser.add_argument("--hub_token", type=str, default=None, help="The token to use to push to the Model Hub.")
+    parser.add_argument(
+        "--hub_model_id",
+        type=str,
+        default=None,
+        help="The name of the repository to keep in sync with the local `output_dir`.",
+    )
+    parser.add_argument(
+        "--logging_dir",
+        type=str,
+        default="logs",
+        help=(
+            "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to"
+            " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***."
+        ),
+    )
+    parser.add_argument(
+        "--allow_tf32",
+        action="store_true",
+        help=(
+            "Whether or not to allow TF32 on Ampere GPUs. Can be used to speed up training. For more information, see"
+            " https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices"
+        ),
+    )
+    parser.add_argument(
+        "--report_to",
+        type=str,
+        default="tensorboard",
+        help=(
+            'The integration to report the results and logs to. Supported platforms are `"tensorboard"`'
+            ' (default), `"wandb"` and `"comet_ml"`. Use `"all"` to report to all integrations.'
+        ),
+    )
+    parser.add_argument(
+        "--wandb_key",
+        type=str,
+        default=None,
+        help=("If report to option is set to wandb, api-key for wandb used for login to wandb "),
+    )
+    parser.add_argument(
+        "--wandb_project_name",
+        type=str,
+        default=None,
+        help=("If report to option is set to wandb, project name in wandb for log tracking  "),
+    )
+    parser.add_argument(
+        "--mixed_precision",
+        type=str,
+        default=None,
+        choices=["no", "fp16", "bf16"],
+        help=(
+            "Whether to use mixed precision. Choose between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >="
+            " 1.10.and an Nvidia Ampere GPU or Intel XPU.  Default to the value of accelerate config of the current system or the"
+            " flag passed with the `accelerate.launch` command. Use this argument to override the accelerate config."
+        ),
+    )
+    parser.add_argument(
+        "--prior_generation_precision",
+        type=str,
+        default=None,
+        choices=["no", "fp32", "fp16", "bf16"],
+        help=(
+            "Choose prior generation precision between fp32, fp16 and bf16 (bfloat16). Bf16 requires PyTorch >="
+            " 1.10.and an Nvidia Ampere GPU or Intel XPU.  Default to fp16 if a GPU/XPU is available else fp32."
+        ),
+    )
+    parser.add_argument("--local_rank", type=int, default=-1, help="For distributed training: local_rank")
+    parser.add_argument(
+        "--enable_xformers_memory_efficient_attention", action="store_true", help="Whether or not to use xformers."
+    )
+
+    if input_args is not None:
+        args = parser.parse_args(input_args)
+    else:
+        args = parser.parse_args()
+
+    env_local_rank = int(os.environ.get("LOCAL_RANK", "-1"))
+    if env_local_rank != -1 and env_local_rank != args.local_rank:
+        args.local_rank = env_local_rank
+
+    if args.with_prior_preservation:
+        if args.class_data_dir is None:
+            raise ValueError("You must specify a data directory for class images.")
+        if args.class_prompt is None:
+            raise ValueError("You must specify prompt for class images.")
+    else:
+        # logger is not available yet
+        if args.class_data_dir is not None:
+            warnings.warn("You need not use --class_data_dir without --with_prior_preservation.")
+        if args.class_prompt is not None:
+            warnings.warn("You need not use --class_prompt without --with_prior_preservation.")
+
+    return args
+
+
+# Converting Bytes to Megabytes
+def b2mb(x):
+    return int(x / 2**20)
+
+
+# This context manager is used to track the peak memory usage of the process
+class TorchTracemalloc:
+    def __enter__(self):
+        self.device_type = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+        self.device_module = getattr(torch, self.device_type, torch.cuda)
+        gc.collect()
+        self.device_module.empty_cache()
+        self.device_module.reset_peak_memory_stats()  # reset the peak gauge to zero
+        self.begin = self.device_module.memory_allocated()
+        self.process = psutil.Process()
+
+        self.cpu_begin = self.cpu_mem_used()
+        self.peak_monitoring = True
+        peak_monitor_thread = threading.Thread(target=self.peak_monitor_func)
+        peak_monitor_thread.daemon = True
+        peak_monitor_thread.start()
+        return self
+
+    def cpu_mem_used(self):
+        """get resident set size memory for the current process"""
+        return self.process.memory_info().rss
+
+    def peak_monitor_func(self):
+        self.cpu_peak = -1
+
+        while True:
+            self.cpu_peak = max(self.cpu_mem_used(), self.cpu_peak)
+
+            # can't sleep or will not catch the peak right (this comment is here on purpose)
+            # time.sleep(0.001) # 1msec
+
+            if not self.peak_monitoring:
+                break
+
+    def __exit__(self, *exc):
+        self.peak_monitoring = False
+
+        gc.collect()
+        self.device_module.empty_cache()
+        self.end = self.device_module.memory_allocated()
+        self.peak = self.device_module.max_memory_allocated()
+        self.used = b2mb(self.end - self.begin)
+        self.peaked = b2mb(self.peak - self.begin)
+
+        self.cpu_end = self.cpu_mem_used()
+        self.cpu_used = b2mb(self.cpu_end - self.cpu_begin)
+        self.cpu_peaked = b2mb(self.cpu_peak - self.cpu_begin)
+        # print(f"delta used/peak {self.used:4d}/{self.peaked:4d}")
+
+
+class DreamBoothDataset(Dataset):
+    """
+    A dataset to prepare the instance and class images with the prompts for fine-tuning the model.
+    It pre-processes the images and the tokenizes prompts.
+    """
+
+    def __init__(
+        self,
+        instance_data_root,
+        instance_prompt,
+        tokenizer,
+        class_data_root=None,
+        class_prompt=None,
+        size=512,
+        center_crop=False,
+    ):
+        self.size = size
+        self.center_crop = center_crop
+        self.tokenizer = tokenizer
+
+        self.instance_data_root = Path(instance_data_root)
+        if not self.instance_data_root.exists():
+            raise ValueError("Instance images root doesn't exists.")
+
+        self.instance_images_path = list(Path(instance_data_root).iterdir())
+        self.num_instance_images = len(self.instance_images_path)
+        self.instance_prompt = instance_prompt
+        self._length = self.num_instance_images
+
+        if class_data_root is not None:
+            self.class_data_root = Path(class_data_root)
+            self.class_data_root.mkdir(parents=True, exist_ok=True)
+            self.class_images_path = list(self.class_data_root.iterdir())
+            self.num_class_images = len(self.class_images_path)
+            self._length = max(self.num_class_images, self.num_instance_images)
+            self.class_prompt = class_prompt
+        else:
+            self.class_data_root = None
+
+        self.image_transforms = transforms.Compose(
+            [
+                transforms.Resize(size, interpolation=transforms.InterpolationMode.BILINEAR),
+                transforms.CenterCrop(size) if center_crop else transforms.RandomCrop(size),
+                transforms.ToTensor(),
+                transforms.Normalize([0.5], [0.5]),
+            ]
+        )
+
+    def __len__(self):
+        return self._length
+
+    def __getitem__(self, index):
+        example = {}
+        instance_image = Image.open(self.instance_images_path[index % self.num_instance_images])
+        if instance_image.mode != "RGB":
+            instance_image = instance_image.convert("RGB")
+        example["instance_images"] = self.image_transforms(instance_image)
+        example["instance_prompt_ids"] = self.tokenizer(
+            self.instance_prompt,
+            truncation=True,
+            padding="max_length",
+            max_length=self.tokenizer.model_max_length,
+            return_tensors="pt",
+        ).input_ids
+
+        if self.class_data_root:
+            class_image = Image.open(self.class_images_path[index % self.num_class_images])
+            if class_image.mode != "RGB":
+                class_image = class_image.convert("RGB")
+            example["class_images"] = self.image_transforms(class_image)
+            example["class_prompt_ids"] = self.tokenizer(
+                self.class_prompt,
+                truncation=True,
+                padding="max_length",
+                max_length=self.tokenizer.model_max_length,
+                return_tensors="pt",
+            ).input_ids
+
+        return example
+
+
+def collate_fn(examples, with_prior_preservation=False):
+    input_ids = [example["instance_prompt_ids"] for example in examples]
+    pixel_values = [example["instance_images"] for example in examples]
+
+    # Concat class and instance examples for prior preservation.
+    # We do this to avoid doing two forward passes.
+    if with_prior_preservation:
+        input_ids += [example["class_prompt_ids"] for example in examples]
+        pixel_values += [example["class_images"] for example in examples]
+
+    pixel_values = torch.stack(pixel_values)
+    pixel_values = pixel_values.to(memory_format=torch.contiguous_format).float()
+
+    input_ids = torch.cat(input_ids, dim=0)
+
+    batch = {
+        "input_ids": input_ids,
+        "pixel_values": pixel_values,
+    }
+    return batch
+
+
+class PromptDataset(Dataset):
+    "A simple dataset to prepare the prompts to generate class images on multiple accelerators."
+
+    def __init__(self, prompt, num_samples):
+        self.prompt = prompt
+        self.num_samples = num_samples
+
+    def __len__(self):
+        return self.num_samples
+
+    def __getitem__(self, index):
+        example = {}
+        example["prompt"] = self.prompt
+        example["index"] = index
+        return example
+
+
+def main(args):
+    logging_dir = Path(args.output_dir, args.logging_dir)
+
+    accelerator = Accelerator(
+        gradient_accumulation_steps=args.gradient_accumulation_steps,
+        mixed_precision=args.mixed_precision,
+        log_with=args.report_to,
+        project_dir=logging_dir,
+    )
+    if args.report_to == "wandb":
+        import wandb
+
+        wandb.login(key=args.wandb_key)
+        wandb.init(project=args.wandb_project_name)
+    # Currently, it's not possible to do gradient accumulation when training two models with accelerate.accumulate
+    # This will be enabled soon in accelerate. For now, we don't allow gradient accumulation when training two models.
+    # TODO (patil-suraj): Remove this check when gradient accumulation with two models is enabled in accelerate.
+    if args.train_text_encoder and args.gradient_accumulation_steps > 1 and accelerator.num_processes > 1:
+        raise ValueError(
+            "Gradient accumulation is not supported when training the text encoder in distributed training. "
+            "Please set gradient_accumulation_steps to 1. This feature will be supported in the future."
+        )
+
+    # Make one log on every process with the configuration for debugging.
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        level=logging.INFO,
+    )
+    logger.info(accelerator.state, main_process_only=False)
+    if accelerator.is_local_main_process:
+        datasets.utils.logging.set_verbosity_warning()
+        transformers.utils.logging.set_verbosity_warning()
+        diffusers.utils.logging.set_verbosity_info()
+    else:
+        datasets.utils.logging.set_verbosity_error()
+        transformers.utils.logging.set_verbosity_error()
+        diffusers.utils.logging.set_verbosity_error()
+
+    # If passed along, set the training seed now.
+    if args.seed is not None:
+        set_seed(args.seed)
+
+    # Generate class images if prior preservation is enabled.
+    if args.with_prior_preservation:
+        class_images_dir = Path(args.class_data_dir)
+        if not class_images_dir.exists():
+            class_images_dir.mkdir(parents=True)
+        cur_class_images = len(list(class_images_dir.iterdir()))
+
+        if cur_class_images < args.num_class_images:
+            dtype = torch.float16 if accelerator.device.type in ["cuda", "xpu"] else torch.float32
+            if args.prior_generation_precision == "fp32":
+                dtype = torch.float32
+            elif args.prior_generation_precision == "fp16":
+                dtype = torch.float16
+            elif args.prior_generation_precision == "bf16":
+                dtype = torch.bfloat16
+            pipeline = DiffusionPipeline.from_pretrained(
+                args.pretrained_model_name_or_path,
+                dtype=dtype,
+                safety_checker=None,
+                revision=args.revision,
+            )
+            pipeline.set_progress_bar_config(disable=True)
+
+            num_new_images = args.num_class_images - cur_class_images
+            logger.info(f"Number of class images to sample: {num_new_images}.")
+
+            sample_dataset = PromptDataset(args.class_prompt, num_new_images)
+            sample_dataloader = torch.utils.data.DataLoader(sample_dataset, batch_size=args.sample_batch_size)
+
+            sample_dataloader = accelerator.prepare(sample_dataloader)
+            pipeline.to(accelerator.device)
+
+            for example in tqdm(
+                sample_dataloader, desc="Generating class images", disable=not accelerator.is_local_main_process
+            ):
+                images = pipeline(example["prompt"]).images
+
+                for i, image in enumerate(images):
+                    hash_image = hashlib.sha1(image.tobytes()).hexdigest()
+                    image_filename = class_images_dir / f"{example['index'][i] + cur_class_images}-{hash_image}.jpg"
+                    image.save(image_filename)
+
+            del pipeline
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+            elif torch.xpu.is_available():
+                torch.xpu.empty_cache()
+
+    # Handle the repository creation
+    if accelerator.is_main_process:
+        if args.push_to_hub:
+            api = HfApi(token=args.hub_token)
+
+            # Create repo (repo_name from args or inferred)
+            repo_name = args.hub_model_id
+            if repo_name is None:
+                repo_name = Path(args.output_dir).absolute().name
+            repo_id = api.create_repo(repo_name, exist_ok=True).repo_id
+
+            with open(os.path.join(args.output_dir, ".gitignore"), "w+") as gitignore:
+                if "step_*" not in gitignore:
+                    gitignore.write("step_*\n")
+                if "epoch_*" not in gitignore:
+                    gitignore.write("epoch_*\n")
+        elif args.output_dir is not None:
+            os.makedirs(args.output_dir, exist_ok=True)
+
+    # Load the tokenizer
+    if args.tokenizer_name:
+        tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name, revision=args.revision, use_fast=False)
+    elif args.pretrained_model_name_or_path:
+        tokenizer = AutoTokenizer.from_pretrained(
+            args.pretrained_model_name_or_path,
+            subfolder="tokenizer",
+            revision=args.revision,
+            use_fast=False,
+        )
+
+    # import correct text encoder class
+    text_encoder_cls = import_model_class_from_model_name_or_path(args.pretrained_model_name_or_path, args.revision)
+
+    # Load scheduler and models
+    noise_scheduler = DDPMScheduler(
+        beta_start=0.00085,
+        beta_end=0.012,
+        beta_schedule="scaled_linear",
+        num_train_timesteps=1000,
+    )  # DDPMScheduler.from_pretrained(args.pretrained_model_name_or_path, subfolder="scheduler")
+    text_encoder = text_encoder_cls.from_pretrained(
+        args.pretrained_model_name_or_path, subfolder="text_encoder", revision=args.revision
+    )
+    vae = AutoencoderKL.from_pretrained(args.pretrained_model_name_or_path, subfolder="vae", revision=args.revision)
+    unet = UNet2DConditionModel.from_pretrained(
+        args.pretrained_model_name_or_path, subfolder="unet", revision=args.revision
+    )
+
+    if args.use_deft:
+        config = DeftConfig(
+            r=args.deft_r,
+            alpha=args.deft_alpha,
+            decomposition_method=args.deft_decomposition_method,
+            target_modules=UNET_TARGET_MODULES,
+            deft_dropout=args.deft_dropout,
+            init_weights=True,
+        )
+        unet = get_peft_model(unet, config)
+        unet.print_trainable_parameters()
+        print(unet)
+
+    vae.requires_grad_(False)
+    if not args.train_text_encoder:
+        text_encoder.requires_grad_(False)
+    elif args.train_text_encoder and args.use_deft:
+        config = DeftConfig(
+            r=args.deft_text_encoder_r,
+            alpha=args.deft_text_encoder_alpha,
+            decomposition_method=args.deft_text_encoder_decomposition_method,
+            target_modules=TEXT_ENCODER_TARGET_MODULES,
+            deft_dropout=args.deft_text_encoder_dropout,
+            init_weights=True,
+        )
+        text_encoder = get_peft_model(text_encoder, config)
+        text_encoder.print_trainable_parameters()
+        print(text_encoder)
+
+    if args.enable_xformers_memory_efficient_attention:
+        if accelerator.device.type == "xpu":
+            logger.warning("XPU hasn't support xformers yet, ignore it.")
+        elif is_xformers_available():
+            unet.enable_xformers_memory_efficient_attention()
+        else:
+            raise ValueError("xformers is not available. Make sure it is installed correctly")
+
+    if args.gradient_checkpointing:
+        unet.enable_gradient_checkpointing()
+        # below fails when using deft so commenting it out
+        if args.train_text_encoder and not args.use_deft:
+            text_encoder.gradient_checkpointing_enable()
+
+    # Enable TF32 for faster training on Ampere GPUs,
+    # cf https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices
+    if args.allow_tf32 and torch.cuda.is_available():
+        torch.backends.cuda.matmul.allow_tf32 = True
+
+    if args.scale_lr:
+        args.learning_rate = (
+            args.learning_rate * args.gradient_accumulation_steps * args.train_batch_size * accelerator.num_processes
+        )
+
+    # Use 8-bit Adam for lower memory usage or to fine-tune the model in 16GB accelerators
+    if args.use_8bit_adam:
+        try:
+            import bitsandbytes as bnb
+        except ImportError:
+            raise ImportError(
+                "To use 8-bit Adam, please install the bitsandbytes library: `pip install bitsandbytes`."
+            )
+
+        optimizer_class = bnb.optim.AdamW8bit
+    else:
+        optimizer_class = torch.optim.AdamW
+
+    # Optimizer creation
+    params_to_optimize = (
+        itertools.chain(unet.parameters(), text_encoder.parameters()) if args.train_text_encoder else unet.parameters()
+    )
+    optimizer = optimizer_class(
+        params_to_optimize,
+        lr=args.learning_rate,
+        betas=(args.adam_beta1, args.adam_beta2),
+        weight_decay=args.adam_weight_decay,
+        eps=args.adam_epsilon,
+    )
+
+    # Dataset and DataLoaders creation:
+    train_dataset = DreamBoothDataset(
+        instance_data_root=args.instance_data_dir,
+        instance_prompt=args.instance_prompt,
+        class_data_root=args.class_data_dir if args.with_prior_preservation else None,
+        class_prompt=args.class_prompt,
+        tokenizer=tokenizer,
+        size=args.resolution,
+        center_crop=args.center_crop,
+    )
+
+    train_dataloader = torch.utils.data.DataLoader(
+        train_dataset,
+        batch_size=args.train_batch_size,
+        shuffle=True,
+        collate_fn=lambda examples: collate_fn(examples, args.with_prior_preservation),
+        num_workers=args.num_dataloader_workers,
+    )
+
+    # Scheduler and math around the number of training steps.
+    overrode_max_train_steps = False
+    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+    if args.max_train_steps is None:
+        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+        overrode_max_train_steps = True
+
+    lr_scheduler = get_scheduler(
+        args.lr_scheduler,
+        optimizer=optimizer,
+        num_warmup_steps=args.lr_warmup_steps * args.gradient_accumulation_steps,
+        num_training_steps=args.max_train_steps * args.gradient_accumulation_steps,
+        num_cycles=args.lr_num_cycles,
+        power=args.lr_power,
+    )
+
+    # Prepare everything with our `accelerator`.
+    if args.train_text_encoder:
+        unet, text_encoder, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
+            unet, text_encoder, optimizer, train_dataloader, lr_scheduler
+        )
+    else:
+        unet, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
+            unet, optimizer, train_dataloader, lr_scheduler
+        )
+
+    # For mixed precision training we cast the text_encoder and vae weights to half-precision
+    # as these models are only used for inference, keeping weights in full precision is not required.
+    weight_dtype = torch.float32
+    if accelerator.mixed_precision == "fp16":
+        weight_dtype = torch.float16
+    elif accelerator.mixed_precision == "bf16":
+        weight_dtype = torch.bfloat16
+
+    # Move vae and text_encoder to device and cast to weight_dtype
+    vae.to(accelerator.device, dtype=weight_dtype)
+    if not args.train_text_encoder:
+        text_encoder.to(accelerator.device, dtype=weight_dtype)
+
+    # We need to recalculate our total training steps as the size of the training dataloader may have changed.
+    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+    if overrode_max_train_steps:
+        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+    # Afterwards we recalculate our number of training epochs
+    args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch)
+
+    # We need to initialize the trackers we use, and also store our configuration.
+    # The trackers initializes automatically on the main process.
+    if accelerator.is_main_process:
+        accelerator.init_trackers("dreambooth", config=vars(args))
+
+    # Train!
+    total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps
+
+    logger.info("***** Running training *****")
+    logger.info(f"  Num examples = {len(train_dataset)}")
+    logger.info(f"  Num batches each epoch = {len(train_dataloader)}")
+    logger.info(f"  Num Epochs = {args.num_train_epochs}")
+    logger.info(f"  Instantaneous batch size per device = {args.train_batch_size}")
+    logger.info(f"  Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}")
+    logger.info(f"  Gradient Accumulation steps = {args.gradient_accumulation_steps}")
+    logger.info(f"  Total optimization steps = {args.max_train_steps}")
+    global_step = 0
+    first_epoch = 0
+
+    # Potentially load in the weights and states from a previous save
+    if args.resume_from_checkpoint:
+        if args.resume_from_checkpoint != "latest":
+            path = os.path.basename(args.resume_from_checkpoint)
+        else:
+            # Get the mos recent checkpoint
+            dirs = os.listdir(args.output_dir)
+            dirs = [d for d in dirs if d.startswith("checkpoint")]
+            dirs = sorted(dirs, key=lambda x: int(x.split("-")[1]))
+            path = dirs[-1]
+        accelerator.print(f"Resuming from checkpoint {path}")
+        accelerator.load_state(os.path.join(args.output_dir, path))
+        global_step = int(path.split("-")[1])
+
+        resume_global_step = global_step * args.gradient_accumulation_steps
+        first_epoch = resume_global_step // num_update_steps_per_epoch
+        resume_step = resume_global_step % num_update_steps_per_epoch
+
+    # Only show the progress bar once on each machine.
+    progress_bar = tqdm(range(global_step, args.max_train_steps), disable=not accelerator.is_local_main_process)
+    progress_bar.set_description("Steps")
+
+    for epoch in range(first_epoch, args.num_train_epochs):
+        unet.train()
+        if args.train_text_encoder:
+            text_encoder.train()
+        with TorchTracemalloc() if not args.no_tracemalloc else nullcontext() as tracemalloc:
+            for step, batch in enumerate(train_dataloader):
+                # Skip steps until we reach the resumed step
+                if args.resume_from_checkpoint and epoch == first_epoch and step < resume_step:
+                    if step % args.gradient_accumulation_steps == 0:
+                        progress_bar.update(1)
+                        if args.report_to == "wandb":
+                            accelerator.print(progress_bar)
+                    continue
+
+                with accelerator.accumulate(unet):
+                    # Convert images to latent space
+                    latents = vae.encode(batch["pixel_values"].to(dtype=weight_dtype)).latent_dist.sample()
+                    latents = latents * 0.18215
+
+                    # Sample noise that we'll add to the latents
+                    noise = torch.randn_like(latents)
+                    bsz = latents.shape[0]
+                    # Sample a random timestep for each image
+                    timesteps = torch.randint(
+                        0, noise_scheduler.config.num_train_timesteps, (bsz,), device=latents.device
+                    )
+                    timesteps = timesteps.long()
+
+                    # Add noise to the latents according to the noise magnitude at each timestep
+                    # (this is the forward diffusion process)
+                    noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps)
+
+                    # Get the text embedding for conditioning
+                    encoder_hidden_states = text_encoder(batch["input_ids"])[0]
+
+                    # Predict the noise residual
+                    model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample
+
+                    # Get the target for loss depending on the prediction type
+                    if noise_scheduler.config.prediction_type == "epsilon":
+                        target = noise
+                    elif noise_scheduler.config.prediction_type == "v_prediction":
+                        target = noise_scheduler.get_velocity(latents, noise, timesteps)
+                    else:
+                        raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}")
+
+                    if args.with_prior_preservation:
+                        # Chunk the noise and model_pred into two parts and compute the loss on each part separately.
+                        model_pred, model_pred_prior = torch.chunk(model_pred, 2, dim=0)
+                        target, target_prior = torch.chunk(target, 2, dim=0)
+
+                        # Compute instance loss
+                        loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
+
+                        # Compute prior loss
+                        prior_loss = F.mse_loss(model_pred_prior.float(), target_prior.float(), reduction="mean")
+
+                        # Add the prior loss to the instance loss.
+                        loss = loss + args.prior_loss_weight * prior_loss
+                    else:
+                        loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
+
+                    accelerator.backward(loss)
+                    if accelerator.sync_gradients:
+                        params_to_clip = (
+                            itertools.chain(unet.parameters(), text_encoder.parameters())
+                            if args.train_text_encoder
+                            else unet.parameters()
+                        )
+                        accelerator.clip_grad_norm_(params_to_clip, args.max_grad_norm)
+                    optimizer.step()
+                    lr_scheduler.step()
+                    optimizer.zero_grad()
+
+                # Checks if the accelerator has performed an optimization step behind the scenes
+                if accelerator.sync_gradients:
+                    progress_bar.update(1)
+                    if args.report_to == "wandb":
+                        accelerator.print(progress_bar)
+                    global_step += 1
+
+                logs = {"loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0]}
+                progress_bar.set_postfix(**logs)
+                accelerator.log(logs, step=global_step)
+
+                if (
+                    args.validation_prompt is not None
+                    and (step + num_update_steps_per_epoch * epoch) % args.validation_steps == 0
+                ):
+                    logger.info(
+                        f"Running validation... \n Generating {args.num_validation_images} images with prompt:"
+                        f" {args.validation_prompt}."
+                    )
+                    # create pipeline
+                    pipeline = DiffusionPipeline.from_pretrained(
+                        args.pretrained_model_name_or_path,
+                        safety_checker=None,
+                        revision=args.revision,
+                    )
+                    # set `keep_fp32_wrapper` to True because we do not want to remove
+                    # mixed precision hooks while we are still training
+                    pipeline.unet = accelerator.unwrap_model(unet, keep_fp32_wrapper=True)
+                    pipeline.text_encoder = accelerator.unwrap_model(text_encoder, keep_fp32_wrapper=True)
+                    pipeline.scheduler = DPMSolverMultistepScheduler.from_config(pipeline.scheduler.config)
+                    pipeline = pipeline.to(accelerator.device)
+                    pipeline.set_progress_bar_config(disable=True)
+
+                    # run inference
+                    if args.seed is not None:
+                        generator = torch.Generator(device=accelerator.device).manual_seed(args.seed)
+                    else:
+                        generator = None
+                    images = []
+                    for _ in range(args.num_validation_images):
+                        image = pipeline(args.validation_prompt, num_inference_steps=25, generator=generator).images[0]
+                        images.append(image)
+
+                    for tracker in accelerator.trackers:
+                        if tracker.name == "tensorboard":
+                            np_images = np.stack([np.asarray(img) for img in images])
+                            tracker.writer.add_images("validation", np_images, epoch, dataformats="NHWC")
+                        if tracker.name == "wandb":
+                            import wandb
+
+                            tracker.log(
+                                {
+                                    "validation": [
+                                        wandb.Image(image, caption=f"{i}: {args.validation_prompt}")
+                                        for i, image in enumerate(images)
+                                    ]
+                                }
+                            )
+
+                    del pipeline
+                    if torch.cuda.is_available():
+                        torch.cuda.empty_cache()
+                    elif torch.xpu.is_available():
+                        torch.xpu.empty_cache()
+
+                if global_step >= args.max_train_steps:
+                    break
+
+        # Printing the accelerator memory usage details such as allocated memory, peak memory, and total memory usage
+        if not args.no_tracemalloc:
+            accelerator.print(
+                f"{accelerator.device.type.upper()} Memory before entering the train : {b2mb(tracemalloc.begin)}"
+            )
+            accelerator.print(
+                f"{accelerator.device.type.upper()} Memory consumed at the end of the train (end-begin): {tracemalloc.used}"
+            )
+            accelerator.print(
+                f"{accelerator.device.type.upper()} Peak Memory consumed during the train (max-begin): {tracemalloc.peaked}"
+            )
+            accelerator.print(
+                f"{accelerator.device.type.upper()} Total Peak Memory consumed during the train (max): {tracemalloc.peaked + b2mb(tracemalloc.begin)}"
+            )
+
+            accelerator.print(f"CPU Memory before entering the train : {b2mb(tracemalloc.cpu_begin)}")
+            accelerator.print(f"CPU Memory consumed at the end of the train (end-begin): {tracemalloc.cpu_used}")
+            accelerator.print(f"CPU Peak Memory consumed during the train (max-begin): {tracemalloc.cpu_peaked}")
+            accelerator.print(
+                f"CPU Total Peak Memory consumed during the train (max): {tracemalloc.cpu_peaked + b2mb(tracemalloc.cpu_begin)}"
+            )
+
+    # Create the pipeline using using the trained modules and save it.
+    accelerator.wait_for_everyone()
+    if accelerator.is_main_process:
+        if args.use_deft:
+            unwarpped_unet = accelerator.unwrap_model(unet)
+            unwarpped_unet.save_pretrained(
+                os.path.join(args.output_dir, "unet"), state_dict=accelerator.get_state_dict(unet)
+            )
+            if args.train_text_encoder:
+                unwarpped_text_encoder = accelerator.unwrap_model(text_encoder)
+                unwarpped_text_encoder.save_pretrained(
+                    os.path.join(args.output_dir, "text_encoder"),
+                    state_dict=accelerator.get_state_dict(text_encoder),
+                )
+        else:
+            pipeline = DiffusionPipeline.from_pretrained(
+                args.pretrained_model_name_or_path,
+                unet=accelerator.unwrap_model(unet),
+                text_encoder=accelerator.unwrap_model(text_encoder),
+                revision=args.revision,
+            )
+            pipeline.save_pretrained(args.output_dir)
+
+        if args.push_to_hub:
+            api.upload_folder(
+                repo_id=repo_id,
+                folder_path=args.output_dir,
+                commit_message="End of training",
+                run_as_future=True,
+            )
+
+    accelerator.end_training()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    main(args)
diff --git a/examples/deft_finetuning/README.md b/examples/deft_finetuning/README.md
new file mode 100644
index 0000000..c4739b6
--- /dev/null
+++ b/examples/deft_finetuning/README.md
@@ -0,0 +1,91 @@
+# DEFT: Decompositional Efficient Fine-Tuning
+
+## Introduction
+[DEFT](https://proceedings.neurips.cc/paper_files/paper/2025/hash/93a34a7138bdad95e874018d5f491cc6-Abstract-Conference.html) adapts a frozen weight `W` by **removing** a learned rank-`r` sub-space and **injecting** a low-rank update in its place: `W' = (I - P_proj) @ W + Q_P @ R`. Unlike a purely additive update (LoRA's `W + B @ A`), the removal term lets DEFT re-purpose existing weight directions, which helps it learn new data/concepts while keeping the base model's capabilities (low forgetting). With the default identity initialization the adapter is an exact no-op at the start of training, and the update merges into the base weights for inference.
+
+## Quick start
+
+With respect to your standard PEFT training procedure with LoRA, simply swap your `LoraConfig` for a `DeftConfig`. DEFT uses `alpha` for the LoRA-style injection scaling (`alpha / r`) and `decomposition_method` (`"relu"` default, or `"qr"`) to derive the projector.
+
+```python
+import torch
+from peft import DeftConfig, get_peft_model
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from trl import SFTConfig, SFTTrainer
+from datasets import load_dataset
+
+model = AutoModelForCausalLM.from_pretrained("meta-llama/Meta-Llama-3-8B", dtype=torch.bfloat16, device_map="auto")
+tokenizer = AutoTokenizer.from_pretrained("meta-llama/Meta-Llama-3-8B")
+tokenizer.pad_token_id = tokenizer.eos_token_id
+deft_config = DeftConfig(r=32, alpha=64, decomposition_method="relu")
+
+peft_model = get_peft_model(model, deft_config)
+peft_model.print_trainable_parameters()
+
+dataset = load_dataset("imdb", split="train[:1%]")
+
+training_args = SFTConfig(dataset_text_field="text", max_length=128)
+trainer = SFTTrainer(
+    model=peft_model,
+    args=training_args,
+    train_dataset=dataset,
+    processing_class=tokenizer,
+)
+trainer.train()
+peft_model.save_pretrained("deft-llama-3-8b")
+```
+
+To utilize the fine-tuned DEFT modules, simply run the following command:
+```python
+import torch
+from peft import PeftModel
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained(
+    "meta-llama/Meta-Llama-3-8B", dtype=torch.bfloat16, device_map="auto"
+)
+peft_model = PeftModel.from_pretrained(model, "deft-llama-3-8b")
+```
+
+## Advanced Usage
+By default DEFT is applied to the query and value layers. Adding adapters on more layers will increase memory usage. To choose a different set of layers:
+```bash
+python examples/deft_finetuning/deft_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --target_modules "q_proj,k_proj,v_proj,o_proj"
+```
+
+DEFT supports `torch.nn.Linear` and `Conv1D` (e.g. gpt-2) layers. The `qr` decomposition gives an orthogonal projection, and `para=True` selects the removal-only [PaRa](https://proceedings.iclr.cc/paper_files/paper/2025/hash/f09e8dd9274cb7c2dd0dc65ffc6f427a-Abstract-Conference.html) variant.
+
+### Fine-tune
+```bash
+python deft_finetuning.py \
+    --base_model "PATH_TO_MODEL" \
+    --data_path "PATH_TO_DATASET" \
+    --output_dir "PATH_TO_OUTPUT_DIR" \
+    --batch_size 1 \
+    --num_epochs 3 \
+    --learning_rate 3e-4 \
+    --cutoff_len 512 \
+    --val_set_size 500 \
+    --eval_step 10 \
+    --save_step 100 \
+    --device "auto" \
+    --rank 32 \
+    --alpha 64 \
+    --decomposition_method "relu" \
+    --deft_dropout 0.05 \
+    --target_modules "q_proj,v_proj" \
+    --hub_model_id "YOUR_HF_REPO" \
+    --push_to_hub
+```
+
+## Citation
+```
+@article{kumar2026deft,
+  title={DEFT: Decompositional Efficient Fine-Tuning for Text-to-Image Models},
+  author={Kumar, Komal and Anwer, Rao and Shahbaz Khan, Fahad and Khan, Salman and Laptev, Ivan and Cholakkal, Hisham},
+  journal={Advances in Neural Information Processing Systems},
+  volume={38},
+  pages={102009--102035},
+  year={2026}
+}
+```
diff --git a/examples/deft_finetuning/deft_finetuning.py b/examples/deft_finetuning/deft_finetuning.py
new file mode 100644
index 0000000..8ef1f5e
--- /dev/null
+++ b/examples/deft_finetuning/deft_finetuning.py
@@ -0,0 +1,199 @@
+# This script is based on examples/delora_finetuning/delora_finetuning.py
+import os
+
+import torch
+from datasets import load_dataset
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    DataCollatorForLanguageModeling,
+    Trainer,
+    TrainingArguments,
+)
+
+from peft import DeftConfig, get_peft_model
+
+
+def train_model(
+    base_model: str,
+    data_path: str,
+    output_dir: str,
+    batch_size: int,
+    num_epochs: int,
+    learning_rate: float,
+    cutoff_len: int,
+    val_set_size: int,
+    eval_step: int,
+    save_step: int,
+    device: str,
+    rank: int,
+    alpha: int,
+    decomposition_method: str,
+    deft_dropout: float,
+    target_modules: str,
+    hub_model_id: str,
+    push_to_hub: bool,
+):
+    os.environ["TOKENIZERS_PARALLELISM"] = "false"
+    hf_token = os.getenv("HF_TOKEN")
+
+    # Setup device
+    device = torch.device(device)
+    print(f"Using device: {device}")
+
+    # load tokenizer
+    tokenizer = AutoTokenizer.from_pretrained(base_model, token=hf_token)
+
+    # Compute type
+    device_type = device.type
+    device_module = getattr(torch, device_type, torch.cuda)
+    bf16_supported = device_module.is_available() and device_module.is_bf16_supported()
+    dtype = torch.bfloat16 if bf16_supported else torch.float32
+
+    # Load the base model
+    model = AutoModelForCausalLM.from_pretrained(
+        base_model,
+        dtype=dtype,
+    )
+
+    # DEFT config for the PEFT model
+    peft_config = DeftConfig(
+        r=rank,
+        alpha=alpha,
+        decomposition_method=decomposition_method,
+        target_modules=(target_modules.split(",") if target_modules else None),
+        deft_dropout=deft_dropout,
+        bias="none",
+    )
+
+    # get the peft model with DEFT config
+    model = get_peft_model(model, peft_config)
+
+    model.to(device)  # MODEL TO ACCELERATOR
+    tokenizer.pad_token = tokenizer.eos_token
+
+    # Load the dataset
+    dataset = load_dataset(data_path)
+
+    def tokenize_function(examples):
+        inputs = tokenizer(examples["text"], padding="max_length", truncation=True, max_length=cutoff_len)
+        inputs["labels"] = inputs["input_ids"].copy()  # setting labels for a language modeling task
+        return inputs
+
+    # Tokenize the dataset and prepare for training
+    tokenized_datasets = dataset.map(tokenize_function, batched=True, remove_columns=dataset["train"].column_names)
+
+    # Data collator to dynamically pad the batched examples
+    data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)
+
+    # Compute the total amount of training step for warmup
+    max_steps = int((len(dataset) // batch_size) * num_epochs)
+
+    # Define training arguments
+    training_args = TrainingArguments(
+        output_dir=output_dir,
+        num_train_epochs=num_epochs,
+        per_device_train_batch_size=batch_size,
+        per_device_eval_batch_size=batch_size,
+        warmup_steps=int(max_steps * 0.1),  # 10% of total training steps
+        weight_decay=0.0,
+        logging_steps=eval_step,
+        save_steps=save_step,
+        save_total_limit=2,
+        push_to_hub=push_to_hub,
+        hub_model_id=hub_model_id,
+        gradient_accumulation_steps=16,
+        learning_rate=learning_rate,
+        hub_token=hf_token,
+        label_names=["labels"],
+    )
+
+    # Clear accelerator cache to free memory
+    device_module.empty_cache()
+
+    # Initialize the Trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=tokenized_datasets["train"],
+        eval_dataset=tokenized_datasets["test"],
+        data_collator=data_collator,
+    )
+
+    # Start model training
+    trainer.train()
+
+    # Save and push the trained model and tokenizer
+    if push_to_hub:
+        # Push the main model to the hub
+        trainer.push_to_hub(commit_message="Fine-tuned model")
+
+    # Save the model and tokenizer locally
+    model.save_pretrained(output_dir)
+    tokenizer.save_pretrained(output_dir)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Fine-tune a causal LM with DEFT")
+    parser.add_argument("--base_model", type=str, default="huggyllama/llama-7b", help="Base model path or name")
+    parser.add_argument(
+        "--data_path", type=str, default="timdettmers/openassistant-guanaco", help="Dataset path or name"
+    )
+    parser.add_argument(
+        "--output_dir", type=str, default="path/to/output", help="Output directory for the fine-tuned model"
+    )
+    parser.add_argument("--batch_size", type=int, default=1, help="Batch size")
+    parser.add_argument("--num_epochs", type=int, default=1, help="Number of training epochs")
+    parser.add_argument("--learning_rate", type=float, default=3e-4, help="Learning rate")
+    parser.add_argument("--cutoff_len", type=int, default=512, help="Cutoff length for tokenization")
+    parser.add_argument("--val_set_size", type=int, default=500, help="Validation set size")
+    parser.add_argument("--eval_step", type=int, default=10, help="Evaluation step interval")
+    parser.add_argument("--save_step", type=int, default=100, help="Save step interval")
+    parser.add_argument("--device", type=str, default="auto", help="Device to use for training")
+    parser.add_argument("--rank", type=int, default=32, help="DEFT projection/injection rank")
+    parser.add_argument("--alpha", type=int, default=64, help="DEFT injection scaling (applied as alpha / rank)")
+    parser.add_argument(
+        "--decomposition_method",
+        type=str,
+        default="relu",
+        choices=["relu", "qr"],
+        help="How the projector is derived from P: 'relu' (default) or 'qr'",
+    )
+    parser.add_argument("--deft_dropout", type=float, default=0.05, help="DEFT dropout rate")
+    parser.add_argument(
+        "--target_modules", type=str, default=None, help="Comma-separated list of target modules for DEFT"
+    )
+    parser.add_argument(
+        "--hub_model_id",
+        type=str,
+        default="path/to/repo",
+        help="Repository name to push the model on the Hugging Face Hub",
+    )
+    parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to Hugging Face Hub")
+    args = parser.parse_args()
+
+    if args.device == "auto":
+        args.device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+
+    train_model(
+        base_model=args.base_model,
+        data_path=args.data_path,
+        output_dir=args.output_dir,
+        batch_size=args.batch_size,
+        num_epochs=args.num_epochs,
+        learning_rate=args.learning_rate,
+        cutoff_len=args.cutoff_len,
+        val_set_size=args.val_set_size,
+        eval_step=args.eval_step,
+        save_step=args.save_step,
+        device=args.device,
+        rank=args.rank,
+        alpha=args.alpha,
+        decomposition_method=args.decomposition_method,
+        deft_dropout=args.deft_dropout,
+        target_modules=args.target_modules,
+        hub_model_id=args.hub_model_id,
+        push_to_hub=args.push_to_hub,
+    )
diff --git a/examples/delora_finetuning/README.md b/examples/delora_finetuning/README.md
new file mode 100644
index 0000000..20c18ae
--- /dev/null
+++ b/examples/delora_finetuning/README.md
@@ -0,0 +1,102 @@
+# DeLoRA: Decoupled Low-Rank Adaptation 
+
+## Introduction
+[DeLoRA](https://huggingface.co/papers/2503.18225) tackles finetuning in a Frobenius-norm bounded setup: this allows to prevent divergence from the pretrained model, effectively decoupling the learning of angles and magnitudes.
+
+This is done by (i) normalization of the BA low-rank matrices, which bound the updates' Frobenius norm, (ii) learnable scaling lambda, which controls the update's boundary/magnitude, (iii) layer-wise scaling of ||W||, to adapt each update's norm to the original weights' norm.
+
+## Quick start
+
+With respect to your standard PEFT training procedure with LoRA, simply swap your `LoraConfig` for a `DeloraConfig`. Note however that `lora_alpha` parameter is replaced by `delora_lambda` parameter which sets an upper bound to the Frobenius norm of the weight change.
+
+```python
+import torch
+from peft import DeloraConfig, get_peft_model
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from trl import SFTConfig, SFTTrainer
+from datasets import load_dataset
+
+model = AutoModelForCausalLM.from_pretrained("meta-llama/Meta-Llama-3-8B", dtype=torch.bfloat16, device_map="auto")
+tokenizer = AutoTokenizer.from_pretrained("meta-llama/Meta-Llama-3-8B")
+tokenizer.pad_token_id = tokenizer.eos_token_id
+delora_config = DeloraConfig(r=32, delora_lambda=15)
+
+peft_model = get_peft_model(model, delora_config)
+peft_model.print_trainable_parameters()
+
+dataset = load_dataset("imdb", split="train[:1%]")
+
+training_args = SFTConfig(dataset_text_field="text", max_length=128)
+trainer = SFTTrainer(
+    model=peft_model,
+    args=training_args,
+    train_dataset=dataset,
+    processing_class=tokenizer,
+)
+trainer.train()
+peft_model.save_pretrained("delora-llama-3-8b")
+```
+
+To utilize the fine-tuned DeLoRA modules, simply run the following command:
+```python
+import torch
+from peft import PeftModel
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained(
+    "meta-llama/Meta-Llama-3-8B", dtype=torch.bfloat16, device_map="auto"
+)
+peft_model = PeftModel.from_pretrained(model, "delora-llama-3-8b")
+```
+
+## Advanced Usage
+In this script the default DeLoRA layers are the query and value layers of the Llama model. Adding adapters on more layers will increase memory usage. If you wish to choose a different set of layers for DeLoRA to be applied on, you can simply define it using:
+```bash
+python examples/delora_finetuning/delora_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --target_modules "q_proj,k_proj,v_proj,o_proj" 
+```
+
+Using different lambdas for different layers is also possible by setting `lambda_pattern`.
+
+### Fine-tune
+```bash
+python delora_finetuning.py \
+    --base_model "PATH_TO_MODEL" \
+    --data_path "PATH_TO_DATASET" \
+    --output_dir "PATH_TO_OUTPUT_DIR" \
+    --batch_size 1 \
+    --num_epochs 3 \
+    --learning_rate 3e-3 \
+    --cutoff_len 512 \
+    --val_set_size 500 \
+    --eval_step 10 \
+    --save_step 100 \
+    --device "auto" \
+    --rank 32 \
+    --delora_lambda 15 \
+    --module_dropout 0.1 \
+    --target_modules "q_proj,v_proj" \
+    --hub_model_id "YOUR_HF_REPO" \
+    --push_to_hub
+```
+
+## Additional Notes
+### Best practices
+- use 10-100x larger learning rate than standard LoRA variants (typical values from 1e-3/1e-2/..)
+- do not set a too small initial boundary parameter lambda (typical values are around 10/15/..)
+
+
+### DeLoRA vs DoRA
+DeLoRA might feel quite similar to DoRA (given the similar target of decoupling angular from magnitude learning), however it presents key differences: (i) DoRA applies normalization and scaling operations on the fully finetuned weights ($W + \Delta W$), (ii) DoRA's normalization operation is performed on the column space of the weight matrices.
+
+Conversely DeLoRA (i) introduces the normalization and scaling operations directly on the weight updates $\Delta W$, better preventing divergence from the pretrained model, and (ii) normalizes the inner low-dimensional space, which enforces a Frobenius-norm boundary to the weight updates.
+
+
+## Citation
+```
+@inproceedings{bini2025decouplinganglesstrengthlowrank,
+      title={Decoupling Angles and Strength in Low-rank Adaptation}, 
+      author={Massimo Bini and Leander Girrbach and Zeynep Akata},
+      year={2025},
+  booktitle={International Conference on Learning Representations (ICLR)},
+}
+```
diff --git a/examples/delora_finetuning/delora_finetuning.py b/examples/delora_finetuning/delora_finetuning.py
new file mode 100644
index 0000000..e2ed3f8
--- /dev/null
+++ b/examples/delora_finetuning/delora_finetuning.py
@@ -0,0 +1,189 @@
+# This script is based on examples/randlora_finetuning/randlora_finetuning.py
+import os
+
+import torch
+from datasets import load_dataset
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    DataCollatorForLanguageModeling,
+    Trainer,
+    TrainingArguments,
+)
+
+from peft import DeloraConfig, get_peft_model
+
+
+def train_model(
+    base_model: str,
+    data_path: str,
+    output_dir: str,
+    batch_size: int,
+    num_epochs: int,
+    learning_rate: float,
+    cutoff_len: int,
+    val_set_size: int,
+    eval_step: int,
+    save_step: int,
+    device: str,
+    rank: int,
+    delora_lambda: int,
+    module_dropout: float,
+    target_modules: str,
+    hub_model_id: str,
+    push_to_hub: bool,
+):
+    os.environ["TOKENIZERS_PARALLELISM"] = "false"
+    hf_token = os.getenv("HF_TOKEN")
+
+    # Setup device
+    device = torch.device(device)
+    print(f"Using device: {device}")
+
+    # load tokenizer
+    tokenizer = AutoTokenizer.from_pretrained(base_model, token=hf_token)
+
+    # Compute type
+    device_type = device.type
+    device_module = getattr(torch, device_type, torch.cuda)
+    bf16_supported = device_module.is_available() and device_module.is_bf16_supported()
+    dtype = torch.bfloat16 if bf16_supported else torch.float32
+
+    # Load the base model
+    model = AutoModelForCausalLM.from_pretrained(
+        base_model,
+        dtype=dtype,
+    )
+
+    # DeLoRA config for the PEFT model
+    peft_config = DeloraConfig(
+        r=rank,
+        delora_lambda=delora_lambda,
+        target_modules=(target_modules.split(",") if target_modules else None),
+        module_dropout=module_dropout,
+        bias="none",
+    )
+
+    # get the peft model with DeLoRA config
+    model = get_peft_model(model, peft_config)
+
+    model.to(device)  # MODEL TO ACCELERATOR
+    tokenizer.pad_token = tokenizer.eos_token
+
+    # Load the dataset
+    dataset = load_dataset(data_path)
+
+    def tokenize_function(examples):
+        inputs = tokenizer(examples["text"], padding="max_length", truncation=True, max_length=cutoff_len)
+        inputs["labels"] = inputs["input_ids"].copy()  # setting labels for a language modeling task
+        return inputs
+
+    # Tokenize the dataset and prepare for training
+    tokenized_datasets = dataset.map(tokenize_function, batched=True, remove_columns=dataset["train"].column_names)
+
+    # Data collator to dynamically pad the batched examples
+    data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)
+
+    # Compute the total amount of training step for warmup
+    max_steps = int((len(dataset) // batch_size) * num_epochs)
+
+    # Define training arguments
+    training_args = TrainingArguments(
+        output_dir=output_dir,
+        num_train_epochs=num_epochs,
+        per_device_train_batch_size=batch_size,
+        per_device_eval_batch_size=batch_size,
+        warmup_steps=int(max_steps * 0.1),  # 10% of total training steps
+        weight_decay=0.0,
+        logging_steps=eval_step,
+        save_steps=save_step,
+        save_total_limit=2,
+        push_to_hub=push_to_hub,
+        hub_model_id=hub_model_id,
+        gradient_accumulation_steps=16,
+        learning_rate=learning_rate,
+        hub_token=hf_token,
+        label_names=["labels"],
+    )
+
+    # Clear accelerator cache to free memory
+    device_module.empty_cache()
+
+    # Initialize the Trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=tokenized_datasets["train"],
+        eval_dataset=tokenized_datasets["test"],
+        data_collator=data_collator,
+    )
+
+    # Start model training
+    trainer.train()
+
+    # Save and push the trained model and tokenizer
+    if push_to_hub:
+        # Push the main model to the hub
+        trainer.push_to_hub(commit_message="Fine-tuned model")
+
+    # Save the model and tokenizer locally
+    model.save_pretrained(output_dir)
+    tokenizer.save_pretrained(output_dir)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Fine-tune LLaMA with DeLoRA")
+    parser.add_argument("--base_model", type=str, default="huggyllama/llama-7b", help="Base model path or name")
+    parser.add_argument(
+        "--data_path", type=str, default="timdettmers/openassistant-guanaco", help="Dataset path or name"
+    )
+    parser.add_argument(
+        "--output_dir", type=str, default="path/to/output", help="Output directory for the fine-tuned model"
+    )
+    parser.add_argument("--batch_size", type=int, default=1, help="Batch size")
+    parser.add_argument("--num_epochs", type=int, default=1, help="Number of training epochs")
+    parser.add_argument("--learning_rate", type=float, default=3e-3, help="Learning rate")
+    parser.add_argument("--cutoff_len", type=int, default=512, help="Cutoff length for tokenization")
+    parser.add_argument("--val_set_size", type=int, default=500, help="Validation set size")
+    parser.add_argument("--eval_step", type=int, default=10, help="Evaluation step interval")
+    parser.add_argument("--save_step", type=int, default=100, help="Save step interval")
+    parser.add_argument("--device", type=str, default="auto", help="Device to use for training")
+    parser.add_argument("--rank", type=int, default=32, help="DeLoRA basis rank")
+    parser.add_argument("--delora_lambda", type=int, default=640, help="DeLoRA alpha")
+    parser.add_argument("--module_dropout", type=float, default=0.05, help="DeLoRA dropout rate")
+    parser.add_argument(
+        "--target_modules", type=str, default=None, help="Comma-separated list of target modules for DeLoRA"
+    )
+    parser.add_argument(
+        "--hub_model_id",
+        type=str,
+        default="path/to/repo",
+        help="Repository name to push the model on the Hugging Face Hub",
+    )
+    parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to Hugging Face Hub")
+    args = parser.parse_args()
+
+    if args.device == "auto":
+        args.device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+
+    train_model(
+        base_model=args.base_model,
+        data_path=args.data_path,
+        output_dir=args.output_dir,
+        batch_size=args.batch_size,
+        num_epochs=args.num_epochs,
+        learning_rate=args.learning_rate,
+        cutoff_len=args.cutoff_len,
+        val_set_size=args.val_set_size,
+        eval_step=args.eval_step,
+        save_step=args.save_step,
+        device=args.device,
+        rank=args.rank,
+        delora_lambda=args.delora_lambda,
+        module_dropout=args.module_dropout,
+        target_modules=args.target_modules,
+        hub_model_id=args.hub_model_id,
+        push_to_hub=args.push_to_hub,
+    )
diff --git a/examples/dna_language_models/dna_lm.ipynb b/examples/dna_language_models/dna_lm.ipynb
new file mode 100644
index 0000000..7036087
--- /dev/null
+++ b/examples/dna_language_models/dna_lm.ipynb
@@ -0,0 +1,2860 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "id": "db4dc272-88fe-47ad-98fd-b94d4f840dca",
+      "metadata": {
+        "id": "db4dc272-88fe-47ad-98fd-b94d4f840dca"
+      },
+      "source": [
+        "# PEFT with DNA Language Models"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "d381f473-0d37-4b5b-ae9e-d2b32bab7c04",
+      "metadata": {
+        "id": "d381f473-0d37-4b5b-ae9e-d2b32bab7c04"
+      },
+      "source": [
+        "This notebook demonstrates how to utilize parameter-efficient fine-tuning techniques (PEFT) from the PEFT library to fine-tune a DNA Language Model (DNA-LM). The fine-tuned DNA-LM will be applied to solve a task from the nucleotide benchmark dataset. Parameter-efficient fine-tuning (PEFT) techniques are crucial for adapting large pre-trained models to specific tasks with limited computational resources."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "23f460c3-d7e5-437f-a5e9-d029cd225bf8",
+      "metadata": {
+        "id": "23f460c3-d7e5-437f-a5e9-d029cd225bf8"
+      },
+      "source": [
+        "### 1. Import relevant libraries"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "29a35f95-738a-4f5e-88ce-dc5f8f9be5dc",
+      "metadata": {
+        "id": "29a35f95-738a-4f5e-88ce-dc5f8f9be5dc"
+      },
+      "source": [
+        "We'll start by importing the required libraries, including the PEFT library and other dependencies."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "id": "0a40abdf-ca1c-436f-a2af-603cd67a45a4",
+      "metadata": {
+        "id": "0a40abdf-ca1c-436f-a2af-603cd67a45a4"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "/opt/homebrew/anaconda3/envs/peft/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+            "  from .autonotebook import tqdm as notebook_tqdm\n"
+          ]
+        }
+      ],
+      "source": [
+        "import torch\n",
+        "import transformers\n",
+        "import peft\n",
+        "import tqdm\n",
+        "import numpy as np"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "a445f8be-545d-4085-a5f9-c64983655224",
+      "metadata": {
+        "id": "a445f8be-545d-4085-a5f9-c64983655224"
+      },
+      "source": [
+        "### 2. Load models\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "63782b55-1c38-4e44-b003-e57daa813bed",
+      "metadata": {
+        "id": "63782b55-1c38-4e44-b003-e57daa813bed"
+      },
+      "source": [
+        "We'll load a pre-trained DNA Language Model, \"SpeciesLM\", that serves as the base for fine-tuning. This is done using the transformers library from HuggingFace.\n",
+        "\n",
+        "The tokenizer and the model comes from the paper, \"Species-aware DNA language models capture regulatory elements and their evolution\". [Paper Link](https://www.biorxiv.org/content/10.1101/2023.01.26.525670v2), [Code Link](https://github.com/gagneurlab/SpeciesLM). They introduce a species-aware DNA language model, which is trained on more than 800 species spanning over 500 million years of evolution."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "id": "dac961f4-c450-4124-923e-f4ba9bbd5e07",
+      "metadata": {
+        "id": "dac961f4-c450-4124-923e-f4ba9bbd5e07"
+      },
+      "outputs": [],
+      "source": [
+        "from transformers import AutoTokenizer, AutoModelForMaskedLM"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "id": "e73fae58-03e9-4acc-b0fc-9bc810c7d366",
+      "metadata": {
+        "id": "e73fae58-03e9-4acc-b0fc-9bc810c7d366"
+      },
+      "outputs": [],
+      "source": [
+        "tokenizer = AutoTokenizer.from_pretrained(\"gagneurlab/SpeciesLM\", revision = \"downstream_species_lm\")\n",
+        "lm = AutoModelForMaskedLM.from_pretrained(\"gagneurlab/SpeciesLM\", revision = \"downstream_species_lm\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "ca43b893-2d66-4e93-a08f-b17a92040709",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ca43b893-2d66-4e93-a08f-b17a92040709",
+        "outputId": "ccbac964-a329-414d-f537-3cae7da66cf2"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "BertForMaskedLM(\n",
+              "  (bert): BertModel(\n",
+              "    (embeddings): BertEmbeddings(\n",
+              "      (word_embeddings): Embedding(5504, 768, padding_idx=0)\n",
+              "      (position_embeddings): Embedding(512, 768)\n",
+              "      (token_type_embeddings): Embedding(2, 768)\n",
+              "      (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
+              "      (dropout): Dropout(p=0.1, inplace=False)\n",
+              "    )\n",
+              "    (encoder): BertEncoder(\n",
+              "      (layer): ModuleList(\n",
+              "        (0-11): 12 x BertLayer(\n",
+              "          (attention): BertAttention(\n",
+              "            (self): BertSdpaSelfAttention(\n",
+              "              (query): Linear(in_features=768, out_features=768, bias=True)\n",
+              "              (key): Linear(in_features=768, out_features=768, bias=True)\n",
+              "              (value): Linear(in_features=768, out_features=768, bias=True)\n",
+              "              (dropout): Dropout(p=0.1, inplace=False)\n",
+              "            )\n",
+              "            (output): BertSelfOutput(\n",
+              "              (dense): Linear(in_features=768, out_features=768, bias=True)\n",
+              "              (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
+              "              (dropout): Dropout(p=0.1, inplace=False)\n",
+              "            )\n",
+              "          )\n",
+              "          (intermediate): BertIntermediate(\n",
+              "            (dense): Linear(in_features=768, out_features=3072, bias=True)\n",
+              "            (intermediate_act_fn): GELUActivation()\n",
+              "          )\n",
+              "          (output): BertOutput(\n",
+              "            (dense): Linear(in_features=3072, out_features=768, bias=True)\n",
+              "            (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
+              "            (dropout): Dropout(p=0.1, inplace=False)\n",
+              "          )\n",
+              "        )\n",
+              "      )\n",
+              "    )\n",
+              "  )\n",
+              "  (cls): BertOnlyMLMHead(\n",
+              "    (predictions): BertLMPredictionHead(\n",
+              "      (transform): BertPredictionHeadTransform(\n",
+              "        (dense): Linear(in_features=768, out_features=768, bias=True)\n",
+              "        (transform_act_fn): GELUActivation()\n",
+              "        (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
+              "      )\n",
+              "      (decoder): Linear(in_features=768, out_features=5504, bias=True)\n",
+              "    )\n",
+              "  )\n",
+              ")"
+            ]
+          },
+          "execution_count": 12,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "lm.eval()\n",
+        "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+        "lm.to(device);"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "c1bda6f2-34bb-4ce2-aa3f-3013548b0a28",
+      "metadata": {
+        "id": "c1bda6f2-34bb-4ce2-aa3f-3013548b0a28"
+      },
+      "source": [
+        "### 2. Prepare datasets"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "f4c61e59-457c-47d9-8929-5e8cd32d3125",
+      "metadata": {
+        "id": "f4c61e59-457c-47d9-8929-5e8cd32d3125"
+      },
+      "source": [
+        "We'll load the `nucleotide_transformer_downstream_tasks` dataset, which contains 18 downstream tasks from the Nucleotide Transformer paper. This dataset provides a consistent genomics benchmark with binary classification tasks."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "f5c0b3df-911a-4645-9140-99ee489515e8",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 145,
+          "referenced_widgets": [
+            "03bba232d3974119acf8031bc086a072",
+            "9107f7bfc8d3483390f802b0458e9380",
+            "f5c80fa70ead4c86aa3b2a046061b901",
+            "57966a469ca1458daab74e81672ae855",
+            "1464502dc3dd46308be8b4fcc9d5ddb9",
+            "92f64c7e088342b9b3c070ba7a295ed0",
+            "ab0aa8af3816422e9d97934f12af842c",
+            "ff89a891bd9c42a8be164587a94ccac1",
+            "e113a50f8ed2410ca12ce7cb38a1681d",
+            "1afa6e9b69c74136863b7747e62a0608",
+            "0838d19b226d486285a26ce0b04d7e15",
+            "7bdab33f4b244fc89408b91755bf17c5",
+            "4d4ce0d35c124690b3427e84a9a128b1",
+            "33be6b0ca8fd44188f834a48a9574a72",
+            "74e9bc1ead434ae78077df6b85f1df58",
+            "e1acc6e70b9246a5b063b3e262f01c81",
+            "078c6877377a491d97d6fadd27064a76",
+            "d46ee1c39bac44c2b541a88c883de1cb",
+            "12f1de7122a7471e90f01d9e7be81178",
+            "dad286d42a514c9ca6bb01bfe9e9c4be",
+            "c028ed977b5e479fbd93b8add588a6dc",
+            "6d80dec073e449efba272fa9f3527922",
+            "c311b777514f41ef986756a386c0bb34",
+            "e2e4bf053ce442f6aee6ffab5f76525f",
+            "c88cf701e20b4354a63ac7d8645d1df9",
+            "f71c252ada474be882b0335ed9a0a1c3",
+            "e059c665229e46ea905dcbd6fc179c88",
+            "bd5273325a4b453e8053d98a09fe9493",
+            "8f20ed2b74d84e80a8d403793354adea",
+            "57c9af47364d48ffbb4ffbdd2c951ede",
+            "fa9d75fcb1d5400c8ca1d1d13d28d0c7",
+            "682644a713b145f0b2dcff99790c6d4d",
+            "9b9b9d573d44464f9a6f5030a40245fe",
+            "ec165fdbe87a4b00a6c288ef1e85c0a9",
+            "17859b793a304e389d1ea0b9ccc3646f",
+            "34921fd116cc42b7b530174d9f61e71e",
+            "2d5466a5e98849c5a09f16faa98f91da",
+            "952397f9c91c480184fa57e175ab1b4c",
+            "86bcccb842244f4f9add58f62facaace",
+            "78b5bbf4c8ac4fe5961776fded4d5798",
+            "c80062a855cb41a28ac625ab03635da2",
+            "aecd740c17c84d45b0615d4fc4196035",
+            "39640709e7174f84a50da05764abbf99",
+            "7114a029e75c4ed5b966eddd3a3c919d"
+          ]
+        },
+        "id": "f5c0b3df-911a-4645-9140-99ee489515e8",
+        "outputId": "15315be1-9d07-4c46-acda-c65cb5a05250"
+      },
+      "outputs": [
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "03bba232d3974119acf8031bc086a072",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Downloading data:   0%|          | 0.00/3.50M [00:00<?, ?B/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "7bdab33f4b244fc89408b91755bf17c5",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Downloading data:   0%|          | 0.00/391k [00:00<?, ?B/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "c311b777514f41ef986756a386c0bb34",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Generating train split:   0%|          | 0/13468 [00:00<?, ? examples/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "ec165fdbe87a4b00a6c288ef1e85c0a9",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Generating test split:   0%|          | 0/1497 [00:00<?, ? examples/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "from datasets import load_dataset\n",
+        "\n",
+        "raw_data_full = load_dataset(\"InstaDeepAI/nucleotide_transformer_downstream_tasks\")\n",
+        "raw_data = raw_data_full.filter(lambda example: example['task'] == 'H3')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "bbb527c5-8077-4ce4-b093-ae627a5f253c",
+      "metadata": {
+        "id": "bbb527c5-8077-4ce4-b093-ae627a5f253c"
+      },
+      "source": [
+        "We'll use the \"H3\" subset of this dataset, which contains a total of 13,468 rows in the training data, and 1497 rows in the test data."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 14,
+      "id": "efef4bb2-60d8-40d1-8777-2b665a87059c",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "efef4bb2-60d8-40d1-8777-2b665a87059c",
+        "outputId": "1c8526ce-0fcb-4fbc-d592-f9a6eae6ebdb"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "DatasetDict({\n",
+              "    train: Dataset({\n",
+              "        features: ['sequence', 'name', 'label'],\n",
+              "        num_rows: 13468\n",
+              "    })\n",
+              "    test: Dataset({\n",
+              "        features: ['sequence', 'name', 'label'],\n",
+              "        num_rows: 1497\n",
+              "    })\n",
+              "})"
+            ]
+          },
+          "execution_count": 14,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "raw_data"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "aafd37c8-6830-4070-a73b-cf62e72e901c",
+      "metadata": {
+        "id": "aafd37c8-6830-4070-a73b-cf62e72e901c"
+      },
+      "source": [
+        "The dataset consists of three columns, ```sequence```, ```name``` and ```label```. An row in this dataset looks like:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 15,
+      "id": "eecd39d8-c073-4d3e-940e-fd83d46f83ab",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "eecd39d8-c073-4d3e-940e-fd83d46f83ab",
+        "outputId": "0b5f8800-eb5d-4c41-a2bc-73e4f837a4d8",
+        "scrolled": true
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "{'sequence': 'TCACTTCGATTATTGAGGCAGTCTTCATTAAAGTTTATTACAATGGATATGGTATCACCAGTCTTGAACCTACAATCATCTATTTTAGGTGAGCTCGTAGGCATTATTGGAAAAGTGTTCTTTCTCTTAATAGAAGAGATTAAATACCCGATAATCACACCCAAAATTATTGTGGATGCCCAGATATCTTCTTGGTCATTGTTTTTTTTCGCTTCAATCTGTAATCTCTCTGCAAAATTTCGGGAGCCAATAGTGACAACATCGTCAATAATAAGTTTGATGGAATCGGAAAAAGATCTTAAAAATGTAAATGAGTATTTCCAAATAATGGCCAAAATGCTCTTTATATTGGAAAATAAAATAGTTGTTTCGCTCTTCGTAGTATTTAACATTTCCGTTCTTATCATTGTAAAGTCTGAGCCATATTCATATGGAAAAGTGCTTTTTAAACCTAGTTCCTCCATATTTTAGTTTTTTATCGATATTGGAAAAAAAAGAGC',\n",
+              " 'name': 'YBR063C_YBR063C_367930|0',\n",
+              " 'label': 0}"
+            ]
+          },
+          "execution_count": 15,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "raw_data['train'][0]"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "92eccf3e-e846-4c59-af56-0e336ac5a1cd",
+      "metadata": {
+        "id": "92eccf3e-e846-4c59-af56-0e336ac5a1cd"
+      },
+      "source": [
+        "We split out dataset into training, test, and validation sets."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 16,
+      "id": "f0649bbd-e74e-4dd6-a564-c4d65e46dbbf",
+      "metadata": {
+        "id": "f0649bbd-e74e-4dd6-a564-c4d65e46dbbf"
+      },
+      "outputs": [],
+      "source": [
+        "from datasets import Dataset, DatasetDict\n",
+        "\n",
+        "train_valid_split = raw_data['train'].train_test_split(test_size=0.15, seed=42)\n",
+        "\n",
+        "train_valid_split = DatasetDict({\n",
+        "    'train': train_valid_split['train'],\n",
+        "    'validation': train_valid_split['test']\n",
+        "})\n",
+        "\n",
+        "ds = DatasetDict({\n",
+        "    'train': train_valid_split['train'],\n",
+        "    'validation': train_valid_split['validation'],\n",
+        "    'test': raw_data['test']\n",
+        "})"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "5424726f-a7ba-45d5-b449-36be9a98b8e6",
+      "metadata": {
+        "id": "5424726f-a7ba-45d5-b449-36be9a98b8e6"
+      },
+      "source": [
+        "Then, we use the tokenizer and a utility function we created, ```get_kmers``` to generate the final data and labels. The ```get_kmers``` function is essential for generating overlapping 6-mers needed by the language model (LM). By using k=6 and stride=1, we ensure that the model receives continuous and overlapping subsequences, capturing the local context within the biological sequence for more effective analysis and prediction.\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 17,
+      "id": "75f267a9-82d1-4343-982e-9b1ea542a330",
+      "metadata": {
+        "id": "75f267a9-82d1-4343-982e-9b1ea542a330"
+      },
+      "outputs": [],
+      "source": [
+        "def get_kmers(seq, k=6, stride=1):\n",
+        "    return [seq[i:i + k] for i in range(0, len(seq), stride) if i + k <= len(seq)]"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 18,
+      "id": "efa9441d-f44c-4ca3-b24c-fa5c853896cd",
+      "metadata": {
+        "id": "efa9441d-f44c-4ca3-b24c-fa5c853896cd"
+      },
+      "outputs": [],
+      "source": [
+        "test_sequences = []\n",
+        "train_sequences = []\n",
+        "val_sequences = []\n",
+        "\n",
+        "dataset_limit = 200 # NOTE: This dataset limit is set to 200, so that the training runs faster. It can be set to None to use the\n",
+        "                    # entire dataset\n",
+        "\n",
+        "for i in range(0, len(ds['train'])):\n",
+        "\n",
+        "    if dataset_limit and i == dataset_limit:\n",
+        "        break\n",
+        "\n",
+        "    sequence = ds['train'][i]['sequence']\n",
+        "    sequence = \"candida_glabrata \" + \" \".join(get_kmers(sequence))\n",
+        "    sequence = tokenizer(sequence)[\"input_ids\"]\n",
+        "    train_sequences.append(sequence)\n",
+        "\n",
+        "\n",
+        "for i in range(0, len(ds['validation'])):\n",
+        "    if dataset_limit and i == dataset_limit:\n",
+        "        break\n",
+        "    sequence = ds['validation'][i]['sequence']\n",
+        "    sequence = \"candida_glabrata \" + \" \".join(get_kmers(sequence))\n",
+        "    sequence = tokenizer(sequence)[\"input_ids\"]\n",
+        "    val_sequences.append(sequence)\n",
+        "\n",
+        "\n",
+        "for i in range(0, len(ds['test'])):\n",
+        "    if dataset_limit and i == dataset_limit:\n",
+        "        break\n",
+        "    sequence = ds['test'][i]['sequence']\n",
+        "    sequence = \"candida_glabrata \" + \" \".join(get_kmers(sequence))\n",
+        "    sequence = tokenizer(sequence)[\"input_ids\"]\n",
+        "    test_sequences.append(sequence)\n",
+        "\n",
+        "\n",
+        "train_labels = ds['train']['label']\n",
+        "test_labels = ds['test']['label']\n",
+        "val_labels = ds['validation']['label']\n",
+        "\n",
+        "if dataset_limit:\n",
+        "    train_labels = train_labels[0:dataset_limit]\n",
+        "    test_labels = test_labels[0:dataset_limit]\n",
+        "    val_labels = val_labels[0:dataset_limit]"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "0686955c-201a-427b-8bef-5c663edb85b8",
+      "metadata": {
+        "id": "0686955c-201a-427b-8bef-5c663edb85b8"
+      },
+      "source": [
+        "Finally, we create a Dataset object for each our sets."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 19,
+      "id": "445b4279-2446-46d6-af2a-ceb2638955c7",
+      "metadata": {
+        "id": "445b4279-2446-46d6-af2a-ceb2638955c7"
+      },
+      "outputs": [],
+      "source": [
+        "from datasets import Dataset\n",
+        "\n",
+        "train_dataset = Dataset.from_dict({\"input_ids\": train_sequences, \"labels\": train_labels})\n",
+        "val_dataset = Dataset.from_dict({\"input_ids\": val_sequences, \"labels\": val_labels})\n",
+        "test_dataset = Dataset.from_dict({\"input_ids\": test_sequences, \"labels\": test_labels})"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "d05d51a7-b933-4793-95df-af7d4d510b13",
+      "metadata": {
+        "id": "d05d51a7-b933-4793-95df-af7d4d510b13"
+      },
+      "source": [
+        "### 4. Train model"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "b5ce1985-c24e-4feb-a6d4-aacb909536f0",
+      "metadata": {
+        "id": "b5ce1985-c24e-4feb-a6d4-aacb909536f0"
+      },
+      "source": [
+        "Now, we'll train our DNA Language Model with the training dataset. We'll add a linear layer in the final layer of our language model, and then, train all the parameteres of our model with the training dataset."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 20,
+      "id": "3a34b2c0-6205-4d48-b1a6-371b50ca42de",
+      "metadata": {
+        "id": "3a34b2c0-6205-4d48-b1a6-371b50ca42de"
+      },
+      "outputs": [],
+      "source": [
+        "from transformers import DataCollatorWithPadding\n",
+        "\n",
+        "data_collator = DataCollatorWithPadding(tokenizer=tokenizer)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "700540f4-0ab8-4f8a-a75c-416a6908af47",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "700540f4-0ab8-4f8a-a75c-416a6908af47",
+        "outputId": "9e16c1e9-4676-4cdf-b2a9-d785773b1c8d"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "DNA_LM(\n",
+              "  (model): BertModel(\n",
+              "    (embeddings): BertEmbeddings(\n",
+              "      (word_embeddings): Embedding(5504, 768, padding_idx=0)\n",
+              "      (position_embeddings): Embedding(512, 768)\n",
+              "      (token_type_embeddings): Embedding(2, 768)\n",
+              "      (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
+              "      (dropout): Dropout(p=0.1, inplace=False)\n",
+              "    )\n",
+              "    (encoder): BertEncoder(\n",
+              "      (layer): ModuleList(\n",
+              "        (0-11): 12 x BertLayer(\n",
+              "          (attention): BertAttention(\n",
+              "            (self): BertSdpaSelfAttention(\n",
+              "              (query): lora.Linear(\n",
+              "                (base_layer): Linear(in_features=768, out_features=768, bias=True)\n",
+              "                (lora_dropout): ModuleDict(\n",
+              "                  (default): Dropout(p=0.01, inplace=False)\n",
+              "                )\n",
+              "                (lora_A): ModuleDict(\n",
+              "                  (default): Linear(in_features=768, out_features=8, bias=False)\n",
+              "                )\n",
+              "                (lora_B): ModuleDict(\n",
+              "                  (default): Linear(in_features=8, out_features=768, bias=False)\n",
+              "                )\n",
+              "                (lora_embedding_A): ParameterDict()\n",
+              "                (lora_embedding_B): ParameterDict()\n",
+              "              )\n",
+              "              (key): lora.Linear(\n",
+              "                (base_layer): Linear(in_features=768, out_features=768, bias=True)\n",
+              "                (lora_dropout): ModuleDict(\n",
+              "                  (default): Dropout(p=0.01, inplace=False)\n",
+              "                )\n",
+              "                (lora_A): ModuleDict(\n",
+              "                  (default): Linear(in_features=768, out_features=8, bias=False)\n",
+              "                )\n",
+              "                (lora_B): ModuleDict(\n",
+              "                  (default): Linear(in_features=8, out_features=768, bias=False)\n",
+              "                )\n",
+              "                (lora_embedding_A): ParameterDict()\n",
+              "                (lora_embedding_B): ParameterDict()\n",
+              "              )\n",
+              "              (value): lora.Linear(\n",
+              "                (base_layer): Linear(in_features=768, out_features=768, bias=True)\n",
+              "                (lora_dropout): ModuleDict(\n",
+              "                  (default): Dropout(p=0.01, inplace=False)\n",
+              "                )\n",
+              "                (lora_A): ModuleDict(\n",
+              "                  (default): Linear(in_features=768, out_features=8, bias=False)\n",
+              "                )\n",
+              "                (lora_B): ModuleDict(\n",
+              "                  (default): Linear(in_features=8, out_features=768, bias=False)\n",
+              "                )\n",
+              "                (lora_embedding_A): ParameterDict()\n",
+              "                (lora_embedding_B): ParameterDict()\n",
+              "              )\n",
+              "              (dropout): Dropout(p=0.1, inplace=False)\n",
+              "            )\n",
+              "            (output): BertSelfOutput(\n",
+              "              (dense): Linear(in_features=768, out_features=768, bias=True)\n",
+              "              (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
+              "              (dropout): Dropout(p=0.1, inplace=False)\n",
+              "            )\n",
+              "          )\n",
+              "          (intermediate): BertIntermediate(\n",
+              "            (dense): Linear(in_features=768, out_features=3072, bias=True)\n",
+              "            (intermediate_act_fn): GELUActivation()\n",
+              "          )\n",
+              "          (output): BertOutput(\n",
+              "            (dense): Linear(in_features=3072, out_features=768, bias=True)\n",
+              "            (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
+              "            (dropout): Dropout(p=0.1, inplace=False)\n",
+              "          )\n",
+              "        )\n",
+              "      )\n",
+              "    )\n",
+              "  )\n",
+              "  (classifier): Linear(in_features=768, out_features=2, bias=True)\n",
+              ")"
+            ]
+          },
+          "execution_count": 32,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "import torch\n",
+        "from torch import nn\n",
+        "\n",
+        "class DNA_LM(nn.Module):\n",
+        "    def __init__(self, model, num_labels):\n",
+        "        super(DNA_LM, self).__init__()\n",
+        "        self.model = model.bert\n",
+        "        self.in_features = model.config.hidden_size\n",
+        "        self.out_features = num_labels\n",
+        "        self.classifier = nn.Linear(self.in_features, self.out_features)\n",
+        "\n",
+        "    def forward(self, input_ids, attention_mask=None, labels=None):\n",
+        "        outputs = self.model(input_ids=input_ids, attention_mask=attention_mask, output_hidden_states=True)\n",
+        "        sequence_output = outputs.hidden_states[-1]\n",
+        "        # Use the [CLS] token for classification\n",
+        "        cls_output = sequence_output[:, 0, :]\n",
+        "        logits = self.classifier(cls_output)\n",
+        "\n",
+        "        loss = None\n",
+        "        if labels is not None:\n",
+        "            loss_fct = nn.CrossEntropyLoss()\n",
+        "            loss = loss_fct(logits.view(-1, self.out_features), labels.view(-1))\n",
+        "\n",
+        "        return (loss, logits) if loss is not None else logits\n",
+        "\n",
+        "# Number of classes for your classification task\n",
+        "num_labels = 2\n",
+        "classification_model = DNA_LM(lm, num_labels)\n",
+        "classification_model.to(device);"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 22,
+      "id": "0af97341-8f95-41d9-9d91-1eb64da4b516",
+      "metadata": {
+        "id": "0af97341-8f95-41d9-9d91-1eb64da4b516"
+      },
+      "outputs": [],
+      "source": [
+        "from transformers import DataCollatorWithPadding\n",
+        "\n",
+        "data_collator = DataCollatorWithPadding(tokenizer=tokenizer)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 36,
+      "id": "d9ce6bc3-4f63-4b7b-b28d-d2553002e6db",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 268
+        },
+        "id": "d9ce6bc3-4f63-4b7b-b28d-d2553002e6db",
+        "outputId": "0c8fdbad-f34d-492b-e146-db6c2064e7c5"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/html": [
+              "\n",
+              "    <div>\n",
+              "      \n",
+              "      <progress value='65' max='65' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
+              "      [65/65 01:43, Epoch 5/5]\n",
+              "    </div>\n",
+              "    <table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              " <tr style=\"text-align: left;\">\n",
+              "      <th>Epoch</th>\n",
+              "      <th>Training Loss</th>\n",
+              "      <th>Validation Loss</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <td>1</td>\n",
+              "      <td>0.887400</td>\n",
+              "      <td>0.685295</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <td>2</td>\n",
+              "      <td>0.644700</td>\n",
+              "      <td>0.682495</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <td>3</td>\n",
+              "      <td>0.599600</td>\n",
+              "      <td>0.680431</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <td>4</td>\n",
+              "      <td>0.892800</td>\n",
+              "      <td>0.679170</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <td>5</td>\n",
+              "      <td>0.663800</td>\n",
+              "      <td>0.678761</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table><p>"
+            ],
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "text/plain": [
+              "TrainOutput(global_step=65, training_loss=0.7263066686116733, metrics={'train_runtime': 104.8696, 'train_samples_per_second': 9.536, 'train_steps_per_second': 0.62, 'total_flos': 0.0, 'train_loss': 0.7263066686116733, 'epoch': 5.0})"
+            ]
+          },
+          "execution_count": 36,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "from transformers import Trainer, TrainingArguments\n",
+        "\n",
+        "\n",
+        "# Define training arguments\n",
+        "training_args = TrainingArguments(\n",
+        "    output_dir='./results',\n",
+        "    eval_strategy=\"epoch\",\n",
+        "    learning_rate=2e-5,\n",
+        "    per_device_train_batch_size=16,\n",
+        "    per_device_eval_batch_size=16,\n",
+        "    num_train_epochs=5,\n",
+        "    weight_decay=0.01,\n",
+        "    eval_steps=1,\n",
+        "    logging_steps=1,\n",
+        ")\n",
+        "\n",
+        "# Initialize Trainer\n",
+        "trainer = Trainer(\n",
+        "    model=classification_model,\n",
+        "    args=training_args,\n",
+        "    train_dataset=train_dataset,\n",
+        "    eval_dataset=val_dataset,\n",
+        "    tokenizer=tokenizer,\n",
+        "    data_collator=data_collator,\n",
+        ")\n",
+        "\n",
+        "# Train the model\n",
+        "trainer.train()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "ebc7e33a-caad-4412-84e3-3e1ce7d02ccd",
+      "metadata": {
+        "id": "ebc7e33a-caad-4412-84e3-3e1ce7d02ccd"
+      },
+      "source": [
+        "### 5. Evaluation"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 37,
+      "id": "38eb0273-ce7e-4770-8457-2f9609f6843b",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 124
+        },
+        "id": "38eb0273-ce7e-4770-8457-2f9609f6843b",
+        "outputId": "2b0b93c9-0199-4e71-9825-9f6a2bd199d0"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/html": [],
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[0 1 1 1 1 1 1 1 1 0 1 0 1 1 1 1 0 1 1 0 1 1 0 1 1 1 1 0 1 0 0 0 1 1 0 1 1\n",
+            " 1 1 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1 1 1 0 1 0 0 1 1 1 1 1 0 0 0 1 0 1 1 0 1\n",
+            " 0 1 1 0 1 1 1 0 0 1 0 1 0 1 0 1 1 1 0 1 1 1 1 0 1 0 0 0 0 1 0 1 0 0 1 1 1\n",
+            " 1 0 1 1 0 0 1 1 1 0 1 1 1 1 0 0 1 1 1 1 0 0 1 1 1 0 0 1 1 0 1 1 0 1 1 0 1\n",
+            " 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 0 1 1 1 1 1 1 1 0 1 1 1 0 0 1 1 1 1\n",
+            " 0 1 1 1 1 0 1 1 0 0 1 0 1 1 0]\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Generate predictions\n",
+        "\n",
+        "predictions = trainer.predict(test_dataset)\n",
+        "logits = predictions.predictions\n",
+        "predicted_labels = logits.argmax(axis=-1)\n",
+        "print(predicted_labels)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "ae4c7bca",
+      "metadata": {
+        "id": "ae4c7bca"
+      },
+      "source": [
+        "Then, we create a function to calculate the accuracy from the test and predicted labels."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 38,
+      "id": "327a1c3b-88d6-4430-8978-73a7cbdbb697",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "327a1c3b-88d6-4430-8978-73a7cbdbb697",
+        "outputId": "f03ad54d-d35f-4fcc-e709-c24d14906e25"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Accuracy: 0.53\n"
+          ]
+        }
+      ],
+      "source": [
+        "def calculate_accuracy(true_labels, predicted_labels):\n",
+        "\n",
+        "    assert len(true_labels) == len(predicted_labels), \"Arrays must have the same length\"\n",
+        "    correct_predictions = np.sum(true_labels == predicted_labels)\n",
+        "    accuracy = correct_predictions / len(true_labels)\n",
+        "\n",
+        "    return accuracy\n",
+        "\n",
+        "accuracy = calculate_accuracy(test_labels, predicted_labels)\n",
+        "print(f\"Accuracy: {accuracy:.2f}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "9p0fFXKTZz9Q",
+      "metadata": {
+        "id": "9p0fFXKTZz9Q"
+      },
+      "source": [
+        "The results aren't that good, which we can attribute to the small dataset size."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "e681864c-f15a-40a6-ac34-0e631d68d5c8",
+      "metadata": {
+        "id": "e681864c-f15a-40a6-ac34-0e631d68d5c8"
+      },
+      "source": [
+        "### 7. Parameter Efficient Fine-Tuning Techniques"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "9141fabe-417b-4fbb-bd3e-244ad84e3010",
+      "metadata": {
+        "id": "9141fabe-417b-4fbb-bd3e-244ad84e3010"
+      },
+      "source": [
+        "In this section, we demonstrate how to employ parameter-efficient fine-tuning (PEFT) techniques to adapt a pre-trained model for specific genomics tasks using the PEFT library."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "71b8a749-461e-4533-b1d0-cebc924d3dc0",
+      "metadata": {
+        "id": "71b8a749-461e-4533-b1d0-cebc924d3dc0"
+      },
+      "source": [
+        "The LoraConfig object is instantiated to configure the PEFT parameters:\n",
+        "\n",
+        "- task_type: Specifies the type of task, in this case, sequence classification (SEQ_CLS).\n",
+        "- r: The rank of the LoRA matrices.\n",
+        "- lora_alpha: Scaling factor for adaptive re-parameterization.\n",
+        "- target_modules: Modules within the model to apply PEFT re-parameterization (query, key, value in this example).\n",
+        "- lora_dropout: Dropout rate used during PEFT fine-tuning."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "021641ae-f604-4d69-8724-743b7d7c613c",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "021641ae-f604-4d69-8724-743b7d7c613c",
+        "outputId": "d7c41fca-1c6b-46fd-9116-01f42d1d6ddf"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "DNA_LM(\n",
+              "  (model): BertModel(\n",
+              "    (embeddings): BertEmbeddings(\n",
+              "      (word_embeddings): Embedding(5504, 768, padding_idx=0)\n",
+              "      (position_embeddings): Embedding(512, 768)\n",
+              "      (token_type_embeddings): Embedding(2, 768)\n",
+              "      (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
+              "      (dropout): Dropout(p=0.1, inplace=False)\n",
+              "    )\n",
+              "    (encoder): BertEncoder(\n",
+              "      (layer): ModuleList(\n",
+              "        (0-11): 12 x BertLayer(\n",
+              "          (attention): BertAttention(\n",
+              "            (self): BertSdpaSelfAttention(\n",
+              "              (query): lora.Linear(\n",
+              "                (base_layer): Linear(in_features=768, out_features=768, bias=True)\n",
+              "                (lora_dropout): ModuleDict(\n",
+              "                  (default): Dropout(p=0.01, inplace=False)\n",
+              "                )\n",
+              "                (lora_A): ModuleDict(\n",
+              "                  (default): Linear(in_features=768, out_features=8, bias=False)\n",
+              "                )\n",
+              "                (lora_B): ModuleDict(\n",
+              "                  (default): Linear(in_features=8, out_features=768, bias=False)\n",
+              "                )\n",
+              "                (lora_embedding_A): ParameterDict()\n",
+              "                (lora_embedding_B): ParameterDict()\n",
+              "              )\n",
+              "              (key): lora.Linear(\n",
+              "                (base_layer): Linear(in_features=768, out_features=768, bias=True)\n",
+              "                (lora_dropout): ModuleDict(\n",
+              "                  (default): Dropout(p=0.01, inplace=False)\n",
+              "                )\n",
+              "                (lora_A): ModuleDict(\n",
+              "                  (default): Linear(in_features=768, out_features=8, bias=False)\n",
+              "                )\n",
+              "                (lora_B): ModuleDict(\n",
+              "                  (default): Linear(in_features=8, out_features=768, bias=False)\n",
+              "                )\n",
+              "                (lora_embedding_A): ParameterDict()\n",
+              "                (lora_embedding_B): ParameterDict()\n",
+              "              )\n",
+              "              (value): lora.Linear(\n",
+              "                (base_layer): Linear(in_features=768, out_features=768, bias=True)\n",
+              "                (lora_dropout): ModuleDict(\n",
+              "                  (default): Dropout(p=0.01, inplace=False)\n",
+              "                )\n",
+              "                (lora_A): ModuleDict(\n",
+              "                  (default): Linear(in_features=768, out_features=8, bias=False)\n",
+              "                )\n",
+              "                (lora_B): ModuleDict(\n",
+              "                  (default): Linear(in_features=8, out_features=768, bias=False)\n",
+              "                )\n",
+              "                (lora_embedding_A): ParameterDict()\n",
+              "                (lora_embedding_B): ParameterDict()\n",
+              "              )\n",
+              "              (dropout): Dropout(p=0.1, inplace=False)\n",
+              "            )\n",
+              "            (output): BertSelfOutput(\n",
+              "              (dense): Linear(in_features=768, out_features=768, bias=True)\n",
+              "              (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
+              "              (dropout): Dropout(p=0.1, inplace=False)\n",
+              "            )\n",
+              "          )\n",
+              "          (intermediate): BertIntermediate(\n",
+              "            (dense): Linear(in_features=768, out_features=3072, bias=True)\n",
+              "            (intermediate_act_fn): GELUActivation()\n",
+              "          )\n",
+              "          (output): BertOutput(\n",
+              "            (dense): Linear(in_features=3072, out_features=768, bias=True)\n",
+              "            (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
+              "            (dropout): Dropout(p=0.1, inplace=False)\n",
+              "          )\n",
+              "        )\n",
+              "      )\n",
+              "    )\n",
+              "  )\n",
+              "  (classifier): Linear(in_features=768, out_features=2, bias=True)\n",
+              ")"
+            ]
+          },
+          "execution_count": 40,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "# Number of classes for your classification task\n",
+        "num_labels = 2\n",
+        "classification_model = DNA_LM(lm, num_labels)\n",
+        "classification_model.to(device);"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 41,
+      "id": "6c223937-86ea-42ef-991a-050f23b21ef9",
+      "metadata": {
+        "id": "6c223937-86ea-42ef-991a-050f23b21ef9"
+      },
+      "outputs": [],
+      "source": [
+        "from peft import LoraConfig, TaskType\n",
+        "\n",
+        "peft_config = LoraConfig(\n",
+        "    r=8,\n",
+        "    lora_alpha=32,\n",
+        "    target_modules=[\"query\", \"key\", \"value\"],\n",
+        "    lora_dropout=0.01,\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 42,
+      "id": "e7a9fe7d-e3ac-4ffa-9a9b-2067fb09b885",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "e7a9fe7d-e3ac-4ffa-9a9b-2067fb09b885",
+        "outputId": "02a6c65f-7474-4bc1-bfab-c05532e350a5"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "trainable params: 442,368 || all params: 90,121,730 || trainable%: 0.4909\n"
+          ]
+        }
+      ],
+      "source": [
+        "from peft import get_peft_model\n",
+        "\n",
+        "peft_model = get_peft_model(classification_model, peft_config)\n",
+        "peft_model.print_trainable_parameters()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 43,
+      "id": "22064519-eaab-4142-8618-d1210d05c6bd",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "22064519-eaab-4142-8618-d1210d05c6bd",
+        "outputId": "ca3f764d-cdb4-4525-c541-8eabfb4cde57"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "PeftModel(\n",
+              "  (base_model): LoraModel(\n",
+              "    (model): DNA_LM(\n",
+              "      (model): BertModel(\n",
+              "        (embeddings): BertEmbeddings(\n",
+              "          (word_embeddings): Embedding(5504, 768, padding_idx=0)\n",
+              "          (position_embeddings): Embedding(512, 768)\n",
+              "          (token_type_embeddings): Embedding(2, 768)\n",
+              "          (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
+              "          (dropout): Dropout(p=0.1, inplace=False)\n",
+              "        )\n",
+              "        (encoder): BertEncoder(\n",
+              "          (layer): ModuleList(\n",
+              "            (0-11): 12 x BertLayer(\n",
+              "              (attention): BertAttention(\n",
+              "                (self): BertSdpaSelfAttention(\n",
+              "                  (query): lora.Linear(\n",
+              "                    (base_layer): Linear(in_features=768, out_features=768, bias=True)\n",
+              "                    (lora_dropout): ModuleDict(\n",
+              "                      (default): Dropout(p=0.01, inplace=False)\n",
+              "                    )\n",
+              "                    (lora_A): ModuleDict(\n",
+              "                      (default): Linear(in_features=768, out_features=8, bias=False)\n",
+              "                    )\n",
+              "                    (lora_B): ModuleDict(\n",
+              "                      (default): Linear(in_features=8, out_features=768, bias=False)\n",
+              "                    )\n",
+              "                    (lora_embedding_A): ParameterDict()\n",
+              "                    (lora_embedding_B): ParameterDict()\n",
+              "                  )\n",
+              "                  (key): lora.Linear(\n",
+              "                    (base_layer): Linear(in_features=768, out_features=768, bias=True)\n",
+              "                    (lora_dropout): ModuleDict(\n",
+              "                      (default): Dropout(p=0.01, inplace=False)\n",
+              "                    )\n",
+              "                    (lora_A): ModuleDict(\n",
+              "                      (default): Linear(in_features=768, out_features=8, bias=False)\n",
+              "                    )\n",
+              "                    (lora_B): ModuleDict(\n",
+              "                      (default): Linear(in_features=8, out_features=768, bias=False)\n",
+              "                    )\n",
+              "                    (lora_embedding_A): ParameterDict()\n",
+              "                    (lora_embedding_B): ParameterDict()\n",
+              "                  )\n",
+              "                  (value): lora.Linear(\n",
+              "                    (base_layer): Linear(in_features=768, out_features=768, bias=True)\n",
+              "                    (lora_dropout): ModuleDict(\n",
+              "                      (default): Dropout(p=0.01, inplace=False)\n",
+              "                    )\n",
+              "                    (lora_A): ModuleDict(\n",
+              "                      (default): Linear(in_features=768, out_features=8, bias=False)\n",
+              "                    )\n",
+              "                    (lora_B): ModuleDict(\n",
+              "                      (default): Linear(in_features=8, out_features=768, bias=False)\n",
+              "                    )\n",
+              "                    (lora_embedding_A): ParameterDict()\n",
+              "                    (lora_embedding_B): ParameterDict()\n",
+              "                  )\n",
+              "                  (dropout): Dropout(p=0.1, inplace=False)\n",
+              "                )\n",
+              "                (output): BertSelfOutput(\n",
+              "                  (dense): Linear(in_features=768, out_features=768, bias=True)\n",
+              "                  (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
+              "                  (dropout): Dropout(p=0.1, inplace=False)\n",
+              "                )\n",
+              "              )\n",
+              "              (intermediate): BertIntermediate(\n",
+              "                (dense): Linear(in_features=768, out_features=3072, bias=True)\n",
+              "                (intermediate_act_fn): GELUActivation()\n",
+              "              )\n",
+              "              (output): BertOutput(\n",
+              "                (dense): Linear(in_features=3072, out_features=768, bias=True)\n",
+              "                (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
+              "                (dropout): Dropout(p=0.1, inplace=False)\n",
+              "              )\n",
+              "            )\n",
+              "          )\n",
+              "        )\n",
+              "      )\n",
+              "      (classifier): Linear(in_features=768, out_features=2, bias=True)\n",
+              "    )\n",
+              "  )\n",
+              ")"
+            ]
+          },
+          "execution_count": 43,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "peft_model"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 45,
+      "id": "d3812e96-6b49-4911-8b21-d8871b7c06a5",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 268
+        },
+        "id": "d3812e96-6b49-4911-8b21-d8871b7c06a5",
+        "outputId": "8d497e30-1d3f-457a-f62a-244731698cb2"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/html": [
+              "\n",
+              "    <div>\n",
+              "      \n",
+              "      <progress value='65' max='65' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
+              "      [65/65 01:39, Epoch 5/5]\n",
+              "    </div>\n",
+              "    <table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              " <tr style=\"text-align: left;\">\n",
+              "      <th>Epoch</th>\n",
+              "      <th>Training Loss</th>\n",
+              "      <th>Validation Loss</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <td>1</td>\n",
+              "      <td>0.625700</td>\n",
+              "      <td>0.777132</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <td>2</td>\n",
+              "      <td>0.717200</td>\n",
+              "      <td>0.773871</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <td>3</td>\n",
+              "      <td>0.768200</td>\n",
+              "      <td>0.771541</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <td>4</td>\n",
+              "      <td>0.687400</td>\n",
+              "      <td>0.769679</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <td>5</td>\n",
+              "      <td>0.552000</td>\n",
+              "      <td>0.768947</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table><p>"
+            ],
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "text/plain": [
+              "TrainOutput(global_step=65, training_loss=0.74742647592838, metrics={'train_runtime': 100.8429, 'train_samples_per_second': 9.916, 'train_steps_per_second': 0.645, 'total_flos': 0.0, 'train_loss': 0.74742647592838, 'epoch': 5.0})"
+            ]
+          },
+          "execution_count": 45,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "# Define training arguments\n",
+        "training_args = TrainingArguments(\n",
+        "    output_dir='./results',\n",
+        "    eval_strategy=\"epoch\",\n",
+        "    learning_rate=2e-5,\n",
+        "    per_device_train_batch_size=16,\n",
+        "    per_device_eval_batch_size=16,\n",
+        "    num_train_epochs=5,\n",
+        "    weight_decay=0.01,\n",
+        "    eval_steps=1,\n",
+        "    logging_steps=1,\n",
+        ")\n",
+        "\n",
+        "# Initialize Trainer\n",
+        "trainer = Trainer(\n",
+        "    model=peft_model.model,\n",
+        "    args=training_args,\n",
+        "    train_dataset=train_dataset,\n",
+        "    eval_dataset=val_dataset,\n",
+        "    tokenizer=tokenizer,\n",
+        "    data_collator=data_collator,\n",
+        ")\n",
+        "\n",
+        "# Train the model\n",
+        "trainer.train()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "76dbd948-d919-4ade-a405-cec297979577",
+      "metadata": {
+        "id": "76dbd948-d919-4ade-a405-cec297979577"
+      },
+      "source": [
+        "### 8. Evaluate PEFT Model"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 46,
+      "id": "58cf70ba-47d5-4111-bb12-830ae04c6285",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 124
+        },
+        "id": "58cf70ba-47d5-4111-bb12-830ae04c6285",
+        "outputId": "0abc56a9-bd68-4e4e-9f13-756e8c9ffa3e"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/html": [],
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[1 0 1 0 0 1 1 0 1 1 1 1 0 1 1 1 0 1 0 0 1 0 0 0 0 1 0 0 0 0 0 1 1 0 0 1 1\n",
+            " 1 1 1 0 1 1 0 1 0 0 1 0 0 1 1 0 1 1 0 0 1 1 0 0 1 1 0 0 0 0 0 0 0 1 1 0 1\n",
+            " 1 0 1 0 0 1 1 0 1 0 1 0 1 0 0 1 1 0 0 0 1 1 1 0 1 1 0 1 0 0 1 1 0 1 1 1 0\n",
+            " 1 1 0 0 1 0 1 1 1 0 1 1 0 1 1 0 0 0 0 1 1 0 1 1 1 1 1 0 1 0 1 0 1 1 0 1 1\n",
+            " 0 1 1 1 1 1 1 1 0 1 1 0 1 0 0 0 0 0 0 1 1 0 0 0 1 1 1 1 1 0 0 1 0 1 0 1 0\n",
+            " 0 1 1 0 0 0 1 0 1 1 1 0 1 1 0]\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Generate predictions\n",
+        "\n",
+        "predictions = trainer.predict(test_dataset)\n",
+        "logits = predictions.predictions\n",
+        "predicted_labels = logits.argmax(axis=-1)\n",
+        "print(predicted_labels)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 47,
+      "id": "4bd38fe5-6513-4c88-afee-0cc4e1781fdd",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "4bd38fe5-6513-4c88-afee-0cc4e1781fdd",
+        "outputId": "a50a91d0-d04d-4620-9006-868716bb992d"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Accuracy: 0.52\n"
+          ]
+        }
+      ],
+      "source": [
+        "def calculate_accuracy(true_labels, predicted_labels):\n",
+        "\n",
+        "    assert len(true_labels) == len(predicted_labels), \"Arrays must have the same length\"\n",
+        "    correct_predictions = np.sum(true_labels == predicted_labels)\n",
+        "    accuracy = correct_predictions / len(true_labels)\n",
+        "\n",
+        "    return accuracy\n",
+        "\n",
+        "accuracy = calculate_accuracy(test_labels, predicted_labels)\n",
+        "print(f\"Accuracy: {accuracy:.2f}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "4ba5af69",
+      "metadata": {},
+      "source": [
+        "As we can see, the PEFT model achieves similar performance to the baseline model, demonstrating the effectiveness of PEFT in adapting pre-trained models to specific tasks with limited computational resources.\n",
+        "\n",
+        "With PEFT, we only train 442,368 parameters, which is 0.49% of the total parameters in the model. This is a significant reduction in computational resources compared to training the entire model from scratch.\n",
+        "\n",
+        "We can improve the results by using a larger dataset, fine-tuning the model for more epochs or changing the hyperparameters (rank, learning rate, etc.).\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "T4",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.12.3"
+    },
+    "widgets": {
+      "application/vnd.jupyter.widget-state+json": {
+        "03bba232d3974119acf8031bc086a072": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_9107f7bfc8d3483390f802b0458e9380",
+              "IPY_MODEL_f5c80fa70ead4c86aa3b2a046061b901",
+              "IPY_MODEL_57966a469ca1458daab74e81672ae855"
+            ],
+            "layout": "IPY_MODEL_1464502dc3dd46308be8b4fcc9d5ddb9"
+          }
+        },
+        "078c6877377a491d97d6fadd27064a76": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "0838d19b226d486285a26ce0b04d7e15": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "12f1de7122a7471e90f01d9e7be81178": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "1464502dc3dd46308be8b4fcc9d5ddb9": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "17859b793a304e389d1ea0b9ccc3646f": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_86bcccb842244f4f9add58f62facaace",
+            "placeholder": "​",
+            "style": "IPY_MODEL_78b5bbf4c8ac4fe5961776fded4d5798",
+            "value": "Generating test split: 100%"
+          }
+        },
+        "1afa6e9b69c74136863b7747e62a0608": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "2d5466a5e98849c5a09f16faa98f91da": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_39640709e7174f84a50da05764abbf99",
+            "placeholder": "​",
+            "style": "IPY_MODEL_7114a029e75c4ed5b966eddd3a3c919d",
+            "value": " 1497/1497 [00:00&lt;00:00, 41394.98 examples/s]"
+          }
+        },
+        "33be6b0ca8fd44188f834a48a9574a72": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_12f1de7122a7471e90f01d9e7be81178",
+            "max": 390606,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_dad286d42a514c9ca6bb01bfe9e9c4be",
+            "value": 390606
+          }
+        },
+        "34921fd116cc42b7b530174d9f61e71e": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_c80062a855cb41a28ac625ab03635da2",
+            "max": 1497,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_aecd740c17c84d45b0615d4fc4196035",
+            "value": 1497
+          }
+        },
+        "39640709e7174f84a50da05764abbf99": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "4d4ce0d35c124690b3427e84a9a128b1": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_078c6877377a491d97d6fadd27064a76",
+            "placeholder": "​",
+            "style": "IPY_MODEL_d46ee1c39bac44c2b541a88c883de1cb",
+            "value": "Downloading data: 100%"
+          }
+        },
+        "57966a469ca1458daab74e81672ae855": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_1afa6e9b69c74136863b7747e62a0608",
+            "placeholder": "​",
+            "style": "IPY_MODEL_0838d19b226d486285a26ce0b04d7e15",
+            "value": " 3.50M/3.50M [00:00&lt;00:00, 26.3MB/s]"
+          }
+        },
+        "57c9af47364d48ffbb4ffbdd2c951ede": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "682644a713b145f0b2dcff99790c6d4d": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "6d80dec073e449efba272fa9f3527922": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "7114a029e75c4ed5b966eddd3a3c919d": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "74e9bc1ead434ae78077df6b85f1df58": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_c028ed977b5e479fbd93b8add588a6dc",
+            "placeholder": "​",
+            "style": "IPY_MODEL_6d80dec073e449efba272fa9f3527922",
+            "value": " 391k/391k [00:00&lt;00:00, 3.34MB/s]"
+          }
+        },
+        "78b5bbf4c8ac4fe5961776fded4d5798": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "7bdab33f4b244fc89408b91755bf17c5": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_4d4ce0d35c124690b3427e84a9a128b1",
+              "IPY_MODEL_33be6b0ca8fd44188f834a48a9574a72",
+              "IPY_MODEL_74e9bc1ead434ae78077df6b85f1df58"
+            ],
+            "layout": "IPY_MODEL_e1acc6e70b9246a5b063b3e262f01c81"
+          }
+        },
+        "86bcccb842244f4f9add58f62facaace": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "8f20ed2b74d84e80a8d403793354adea": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "9107f7bfc8d3483390f802b0458e9380": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_92f64c7e088342b9b3c070ba7a295ed0",
+            "placeholder": "​",
+            "style": "IPY_MODEL_ab0aa8af3816422e9d97934f12af842c",
+            "value": "Downloading data: 100%"
+          }
+        },
+        "92f64c7e088342b9b3c070ba7a295ed0": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "952397f9c91c480184fa57e175ab1b4c": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "9b9b9d573d44464f9a6f5030a40245fe": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "ab0aa8af3816422e9d97934f12af842c": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "aecd740c17c84d45b0615d4fc4196035": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "bd5273325a4b453e8053d98a09fe9493": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "c028ed977b5e479fbd93b8add588a6dc": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "c311b777514f41ef986756a386c0bb34": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_e2e4bf053ce442f6aee6ffab5f76525f",
+              "IPY_MODEL_c88cf701e20b4354a63ac7d8645d1df9",
+              "IPY_MODEL_f71c252ada474be882b0335ed9a0a1c3"
+            ],
+            "layout": "IPY_MODEL_e059c665229e46ea905dcbd6fc179c88"
+          }
+        },
+        "c80062a855cb41a28ac625ab03635da2": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "c88cf701e20b4354a63ac7d8645d1df9": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_57c9af47364d48ffbb4ffbdd2c951ede",
+            "max": 13468,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_fa9d75fcb1d5400c8ca1d1d13d28d0c7",
+            "value": 13468
+          }
+        },
+        "d46ee1c39bac44c2b541a88c883de1cb": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "dad286d42a514c9ca6bb01bfe9e9c4be": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "e059c665229e46ea905dcbd6fc179c88": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "e113a50f8ed2410ca12ce7cb38a1681d": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "e1acc6e70b9246a5b063b3e262f01c81": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "e2e4bf053ce442f6aee6ffab5f76525f": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_bd5273325a4b453e8053d98a09fe9493",
+            "placeholder": "​",
+            "style": "IPY_MODEL_8f20ed2b74d84e80a8d403793354adea",
+            "value": "Generating train split: 100%"
+          }
+        },
+        "ec165fdbe87a4b00a6c288ef1e85c0a9": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_17859b793a304e389d1ea0b9ccc3646f",
+              "IPY_MODEL_34921fd116cc42b7b530174d9f61e71e",
+              "IPY_MODEL_2d5466a5e98849c5a09f16faa98f91da"
+            ],
+            "layout": "IPY_MODEL_952397f9c91c480184fa57e175ab1b4c"
+          }
+        },
+        "f5c80fa70ead4c86aa3b2a046061b901": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_ff89a891bd9c42a8be164587a94ccac1",
+            "max": 3495021,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_e113a50f8ed2410ca12ce7cb38a1681d",
+            "value": 3495021
+          }
+        },
+        "f71c252ada474be882b0335ed9a0a1c3": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_682644a713b145f0b2dcff99790c6d4d",
+            "placeholder": "​",
+            "style": "IPY_MODEL_9b9b9d573d44464f9a6f5030a40245fe",
+            "value": " 13468/13468 [00:00&lt;00:00, 193879.37 examples/s]"
+          }
+        },
+        "fa9d75fcb1d5400c8ca1d1d13d28d0c7": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "ff89a891bd9c42a8be164587a94ccac1": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        }
+      }
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}
diff --git a/examples/dora_finetuning/QDoRA_finetuning.ipynb b/examples/dora_finetuning/QDoRA_finetuning.ipynb
new file mode 100644
index 0000000..e0582a9
--- /dev/null
+++ b/examples/dora_finetuning/QDoRA_finetuning.ipynb
@@ -0,0 +1,8545 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "CV_gQs58bsvM"
+   },
+   "source": [
+    "# Fine-tuning [Llama-3-8B](https://huggingface.co/meta-llama/Meta-Llama-3-8B) on [timdettmers/openassistant-guanaco](https://huggingface.co/datasets/timdettmers/openassistant-guanaco) Dataset using QDora (quantized Lora w/ use_dora=True)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "FuXIFTFapAMI",
+    "outputId": "b95d8260-65bd-405f-f1e2-8d353aa46814"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m119.8/119.8 MB\u001b[0m \u001b[31m7.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m21.3/21.3 MB\u001b[0m \u001b[31m37.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25h  Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n",
+      "  Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n",
+      "  Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
+      "  Building wheel for transformers (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
+      "  Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n",
+      "  Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n",
+      "  Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m309.4/309.4 kB\u001b[0m \u001b[31m6.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25h  Building wheel for peft (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
+      "  Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n",
+      "  Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n",
+      "  Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
+      "  Building wheel for accelerate (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m547.8/547.8 kB\u001b[0m \u001b[31m7.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m40.8/40.8 MB\u001b[0m \u001b[31m28.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m116.3/116.3 kB\u001b[0m \u001b[31m16.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m64.9/64.9 kB\u001b[0m \u001b[31m10.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m194.1/194.1 kB\u001b[0m \u001b[31m27.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m134.8/134.8 kB\u001b[0m \u001b[31m20.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25h\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
+      "cudf-cu12 24.4.1 requires pyarrow<15.0.0a0,>=14.0.1, but you have pyarrow 16.1.0 which is incompatible.\n",
+      "google-colab 1.0.0 requires requests==2.31.0, but you have requests 2.32.3 which is incompatible.\n",
+      "ibis-framework 8.0.0 requires pyarrow<16,>=2, but you have pyarrow 16.1.0 which is incompatible.\u001b[0m\u001b[31m\n",
+      "\u001b[0m"
+     ]
+    }
+   ],
+   "source": [
+    "# Install the libraries\n",
+    "!pip install -q -U bitsandbytes\n",
+    "!pip install -q -U git+https://github.com/huggingface/transformers.git\n",
+    "!pip install -q -U git+https://github.com/huggingface/peft.git\n",
+    "!pip install -q -U git+https://github.com/huggingface/accelerate.git\n",
+    "!pip install -q datasets"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 145,
+     "referenced_widgets": [
+      "8cc86330c2af436c9af314e8c04c8c2b",
+      "e25f9ca445b14e3f8397779df071dfb4",
+      "8365680c634a44aa880317e36fa5e46e",
+      "0c4ac7c3db0b431397cc812f7c9e785c",
+      "c84f542c863043dea8a3675fa153e78d",
+      "b3b3f4ddd4ed4d938c923887939a0440",
+      "35186465f87341f683affb9399661540",
+      "791df472db174df69b8c9f0e200af254",
+      "6bb9c7182d2a464ea21809e59043562a",
+      "31c574113731403b88edc5bb0798bc6d",
+      "3b8bc5b9392e45758813a1db9db824a9",
+      "90661b333d6f496ca606b3046622660e",
+      "5f551f9b217e44cf8b5433f314b3844b",
+      "d2d81cc8296c4b10bf80b86c0a3302d3",
+      "7e3a386e672f4748882211227b7721a9",
+      "57f251691b4c453896b2508c431dfc2f",
+      "4bdb196cd1494f809829651ec5b6cbf8",
+      "7cd50bcc8fcc4b83abcda6d3604bd4cc",
+      "7a00aa4a97a34da39cc052c6926dbe13",
+      "14c73d88df9e46e3bbb6690fdb48ad07",
+      "0e2beab611114239b6ee48a3cbb09c49",
+      "006b78b5191b4fb888d98bdf6c20ec1e",
+      "5f6ffa1d929443a5bd9c7c550f0690f0",
+      "668a7f88506148a9ba2b48920afc028f",
+      "57b0096985ab44aea342e52795c4f999",
+      "a4c404e420cc4ce781ce569f9ab3f987",
+      "ee4e4af964ec4dd597cb04a90f0697f9",
+      "974e3687f18a4e1a975969b880d086aa",
+      "93a50117ece543d4857ba02505dc4514",
+      "71a3a56edbdb45669d382fef4b097e1b",
+      "53f287d4927541d08e2ae7d4d0b3c396",
+      "afa442ab223b46cb82569438c0047823"
+     ]
+    },
+    "id": "wAAPv5CRmg7e",
+    "outputId": "687f979a-04c1-4160-d71c-4de8ecdb07d9"
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "8cc86330c2af436c9af314e8c04c8c2b",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(HTML(value='<center> <img\\nsrc=https://huggingface.co/front/assets/huggingface_logo-noborder.sv…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Required when training models/data that are gated on HuggingFace, and required for pushing models to HuggingFace\n",
+    "from huggingface_hub import notebook_login\n",
+    "\n",
+    "notebook_login()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "MJ-5idQwzvg-"
+   },
+   "source": [
+    "### Loading the model and it's tokenizer in quantized setup!\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 546,
+     "referenced_widgets": [
+      "5924b266e95a42039634a334ff561a82",
+      "eadeec171e7b4c0f9e26964f031cfb71",
+      "feae525923d5407bb69a922954c474f7",
+      "00371a48e64c45cd97020a78b710e64c",
+      "156f95b0012449e8a0c604e6e03bf35f",
+      "de3757d6125a4c07b502dd60816bafec",
+      "8c4d6f4eea3742289a2604e66b0c6182",
+      "bac377ed96ae4e8db9b298bb623888ec",
+      "02d6cc4c2717434c895798601bda7c86",
+      "3f9fa554747743f8a86b40a4f7530617",
+      "ffe561df8772443ebf40a3b8b656079f",
+      "800e9453214848b69bc4c6ca2d5e8f79",
+      "6b0ec8d5f7294d44a5fa15d8ef12471e",
+      "7d3a7be9ed6f48988a2c4a1a4a2271cf",
+      "c40f583823574e40b6b29d4914143c0e",
+      "a4368e6da8f046aaa32f3152b7d333d1",
+      "8ea89e52123643268857285e0e1db1c0",
+      "a8514e34378d47a28fbf0831a14ede8f",
+      "f86b969ef69b48119619e1a424b50460",
+      "7725e9d443e249ada02e5ac7056d00db",
+      "f81756eb9e554899b0778311f2c407c4",
+      "3b614b9712874fac990d2c557b0791a6",
+      "43d12a98d90a4bf7a96c033172c646e2",
+      "c35b16156253402f90a432f3f07c2e0a",
+      "1ae1d2702da5483a85504f59939ffa39",
+      "1b2abf90003e4165a3293acd6a5ea9ff",
+      "3e45aea9f7444a4db885c4cca4c9c4ff",
+      "6b6ed29053ec4aaa8fc5526a35f17c2b",
+      "e69cd88ccbae4bb7b238fa112a60f0f9",
+      "8cd63d3908e4411c9fcb42bc32c8dd16",
+      "64624b26145b42db82f7afc36c32e117",
+      "cffdf12fbe97462ab74e88ccca943aeb",
+      "bcaf4c81ba9d437bb6223dbb22d011ed",
+      "8800c351b6da450eace0c3890d36c8d7",
+      "7037c32dfce84e70ac86537dbbc6a495",
+      "31c10fa464e24f97b379675a204a09b5",
+      "6149752353fe4f9cbb7b26bcc25199a9",
+      "0b145e421f4840f2872c29256b49f168",
+      "0f4c664612364dc89acf78eb1c740980",
+      "0f60f9aa76b941809e013ffcae83604a",
+      "1d27ab2bc6ae463a806292b68b7891f8",
+      "2a57bb48e1c6475abba242994a79d44a",
+      "6cb8065803724d80b82b06dc95ded91e",
+      "8301c6302df54bbc9f15295f11cec208",
+      "0aad2d9d1cba40cbb64308ede3242ed7",
+      "0711e28e06a440c2a241acbc1f90d1e8",
+      "77704d2e27e94cd3a0c5f6b5ceeffd1c",
+      "3b82b8d41b134bec9bd77ed8d4f00eb4",
+      "25fef90e209f4b14a73f3e39d226d913",
+      "f4ca7b63d7d749ff83a848e250f03ec1",
+      "8c149bc655a34fe5b91853c66db458a9",
+      "0f54e8fda93144f6a95493e6ec535e9d",
+      "880124db7dc04aaea09edd75e1ec7921",
+      "14bf612f6ad7416c8ddd6085c72eee0e",
+      "f7e59b47f9b74523843f37268212d566",
+      "a34b3fd5859a441f89cbe7f6e6df9da9",
+      "8f5b8c513b164dab9e0892422163c483",
+      "5b2a671976fa446db408d58a215b8249",
+      "c934919f617447cfb9226929e7a68d79",
+      "124a70bfad434c5c946f611c04a91c8f",
+      "cd11fb7d54bb43ae821f2272d075a1b3",
+      "fbc6a2834c5442fbb6667f1b3612bb5b",
+      "63899ac621ff4e9cb8e215d5ab63bef8",
+      "6b2b59d2b62b4f7da8c60ff783138397",
+      "c27e8ce031884a90b41d8220b1870bc4",
+      "88024cd312ee42c2925ebfbe52077780",
+      "cf6d1be81b6c4ffc81ce8fdabfc5ad28",
+      "07e0aed682fd4cc88fa75c0592dc04a7",
+      "67b4473eb8a44a96ba34983762ab38fa",
+      "c7e06fd82f7f4f9fb81c68e8758f2de1",
+      "3d9d8278667d496aaea1eaaa4d24ae93",
+      "47944ad8cadf4a57b170193c46d4389c",
+      "db05b25cb38140bdb21e6f3b7fde7e66",
+      "6f474268da0f4337a2ccecc1ca2098a1",
+      "c2ceccfdb59b4336a24003cd6bc2403d",
+      "a8999d04e4114693bb6be358bdbe9b83",
+      "2540d57e3bf545e3812da1ee72b85fc8",
+      "c56d8289513441688f9bc5f4b52d60a0",
+      "a53b4776f95f4dd38197193e6c5f649e",
+      "b4ba435f6d1c448f99b533bc6df32e76",
+      "42eb041021214110a860924d28d73409",
+      "17c797e08bd2493fa685918129415309",
+      "aea74071600f483b9e6de1a61743c03a",
+      "21bf14b771c14d2dab9e98a326302e14",
+      "35c2c635c2024bcda3265bf95d330f63",
+      "ec014d847e394a309b6a82c30a6fdfc5",
+      "4c369386ba5f4862b11a50e50130663b",
+      "bbdf3bb657e64fc2b0a90e78e8886480",
+      "d7ef74cf4a914ad38a69c84c34fff393",
+      "8d0f1d547c384094b10aa00a3ede3c06",
+      "9bdebf06b6874bbb88404f4ad14e1dbc",
+      "a2249f364b914662b54045a1f8d6dfd1",
+      "7504986b8d8d4d0da58ad79e80a81948",
+      "082b6990ce5e4812adc0ad6a7b376dac",
+      "610e1ddfb7a44d51a54ebea6dad3a5f0",
+      "5f60910d1e744432bdf87518f0f45874",
+      "2ab86b3fbd49488bb02f8205a572e752",
+      "9f13437a44b8434b9cc3afab998e8d3c",
+      "8a7c82dcbd414b24b67ccfbc562b2e38",
+      "d1508f5cde9a43d8abc26dd2d0c34dbd",
+      "9a0b012915c54abeb100f466fa99d303",
+      "99529129d7f0435da0fdcfc9803a2f11",
+      "5b56ac3009714a5a84dd8749db4a7bce",
+      "546b76a22f1046cd856a8fa2f9ff2d9f",
+      "fffbf696c07744fc8e3d81ab51dc9c90",
+      "a153cc3ca0cc45c18a941bd57e363ec3",
+      "5a8ac674153248999007a713299b2644",
+      "1f82a5685eef4b47a2dbf7618362907c",
+      "51b3af446ace409dbcdf5de499552061",
+      "9a12124915994b70a71ebd64b99e93e9",
+      "57f87d4780634d36ae8159d987c22993",
+      "58ea619f81bf42ddb8b166db3deb0e86",
+      "8bb83ae3229e4f38b1733f92f536fad0",
+      "5c0104210ee34ca8a072ee5121f424a1",
+      "34e381adbd9242759b57f2a305c5d2e3",
+      "e4e1a4338c5e46b3ba5a3bb960da7107",
+      "9a5072b8d16d4a1eb0652da61bda0ac8",
+      "1f75d85e6c7e4eb6a91b03f0c8adb644",
+      "9da33f07ea354b5798e85298e132b017",
+      "604582e8cbff4dc9876551a3307b5b77",
+      "a98165ee656643ad85ac9ea1447cc775",
+      "5cf4a57d21a545029b6448258a5ebd84",
+      "0d2ae3466a3447c58e23ccd2b3733deb",
+      "ba7f32c41f9247ec9d4c40e6396b55a9",
+      "ea1bdb5f2da64332960bccd967a84b4a",
+      "b08631e4cffa445c912da0c8eac2ef23",
+      "921a1a037f7b47f8b57d1da8192a437a",
+      "892ff4e2f0e44c23bc5c2be7547cf0bd",
+      "4c8e98294bd240a6869cb199caee66e1",
+      "4e1f5423311b4dc0930c21c9ad5a88f5",
+      "347540dc03d34e65b7ffbb0f5fc569aa",
+      "7243d8e2e1cc4043a2ee310eabd0ac09"
+     ]
+    },
+    "id": "E0Nl5mWL0k2T",
+    "outputId": "a942d9b0-1f38-4a9b-ea20-e55bd7593920"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.10/dist-packages/huggingface_hub/utils/_token.py:89: UserWarning: \n",
+      "The secret `HF_TOKEN` does not exist in your Colab secrets.\n",
+      "To authenticate with the Hugging Face Hub, create a token in your settings tab (https://huggingface.co/settings/tokens), set it as secret in your Google Colab and restart your session.\n",
+      "You will be able to reuse this secret in all of your notebooks.\n",
+      "Please note that authentication is recommended but still optional to access public models or datasets.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "5924b266e95a42039634a334ff561a82",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "tokenizer_config.json:   0%|          | 0.00/50.6k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "800e9453214848b69bc4c6ca2d5e8f79",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "tokenizer.json:   0%|          | 0.00/9.09M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "43d12a98d90a4bf7a96c033172c646e2",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "special_tokens_map.json:   0%|          | 0.00/73.0 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Special tokens have been added in the vocabulary, make sure the associated word embeddings are fine-tuned or trained.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "8800c351b6da450eace0c3890d36c8d7",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "config.json:   0%|          | 0.00/654 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "0aad2d9d1cba40cbb64308ede3242ed7",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "model.safetensors.index.json:   0%|          | 0.00/23.9k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a34b3fd5859a441f89cbe7f6e6df9da9",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading shards:   0%|          | 0/4 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "cf6d1be81b6c4ffc81ce8fdabfc5ad28",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "model-00001-of-00004.safetensors:   0%|          | 0.00/4.98G [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c56d8289513441688f9bc5f4b52d60a0",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "model-00002-of-00004.safetensors:   0%|          | 0.00/5.00G [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d7ef74cf4a914ad38a69c84c34fff393",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "model-00003-of-00004.safetensors:   0%|          | 0.00/4.92G [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d1508f5cde9a43d8abc26dd2d0c34dbd",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "model-00004-of-00004.safetensors:   0%|          | 0.00/1.17G [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "57f87d4780634d36ae8159d987c22993",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Loading checkpoint shards:   0%|          | 0/4 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "5cf4a57d21a545029b6448258a5ebd84",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "generation_config.json:   0%|          | 0.00/177 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# setting up the config for 4-bit quantization of Qlora\n",
+    "import torch\n",
+    "from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig\n",
+    "\n",
+    "model_id = \"meta-llama/Meta-Llama-3-8B\"\n",
+    "bnb_config = BitsAndBytesConfig(\n",
+    "    load_in_4bit=True, bnb_4bit_use_double_quant=True, bnb_4bit_quant_type=\"nf4\", bnb_4bit_compute_dtype=torch.bfloat16\n",
+    ")\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_id)\n",
+    "model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=bnb_config, device_map={\"\": 0})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Xpx2Fq-icX56"
+   },
+   "outputs": [],
+   "source": [
+    "# print(model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Mp2gMi1ZzGET"
+   },
+   "source": [
+    "#### Prepare model for PEFT fine-tuning"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "id": "a9EUEDAl0ss3"
+   },
+   "outputs": [],
+   "source": [
+    "from peft import prepare_model_for_kbit_training\n",
+    "\n",
+    "model.gradient_checkpointing_enable()\n",
+    "model = prepare_model_for_kbit_training(model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "id": "gkIcwsSU01EB"
+   },
+   "outputs": [],
+   "source": [
+    "def print_trainable_parameters(model):\n",
+    "    \"\"\"\n",
+    "    Prints the number of trainable parameters in the model.\n",
+    "    \"\"\"\n",
+    "    trainable_params = 0\n",
+    "    all_param = 0\n",
+    "    for _, param in model.named_parameters():\n",
+    "        all_param += param.numel()\n",
+    "        if param.requires_grad:\n",
+    "            trainable_params += param.numel()\n",
+    "    print(\n",
+    "        f\"trainable params: {trainable_params} || all params: {all_param} || trainable%: {100 * trainable_params / all_param}\"\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "HVTAJuKyM0gX"
+   },
+   "source": [
+    "### Setup `LoraConfig`\n",
+    "### To use Dora we set the `use_dora=True`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "Ybeyl20n3dYH",
+    "outputId": "ea35ec70-13e4-4f23-9481-1b33b1b06dec"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "trainable params: 22347776 || all params: 4562948096 || trainable%: 0.48976616717579247\n"
+     ]
+    }
+   ],
+   "source": [
+    "from peft import LoraConfig, get_peft_model\n",
+    "\n",
+    "config = LoraConfig(\n",
+    "    use_dora=True,\n",
+    "    r=8,\n",
+    "    lora_alpha=32,\n",
+    "    target_modules=[\n",
+    "        \"q_proj\",\n",
+    "        \"k_proj\",\n",
+    "        \"v_proj\",\n",
+    "        \"o_proj\",\n",
+    "        \"gate_proj\",\n",
+    "        \"up_proj\",\n",
+    "        \"down_proj\",\n",
+    "    ],  # parameters specific to llama\n",
+    "    lora_dropout=0.05,\n",
+    "    bias=\"none\",\n",
+    "    task_type=\"CAUSAL_LM\",\n",
+    ")\n",
+    "\n",
+    "model = get_peft_model(model, config)\n",
+    "print_trainable_parameters(model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "FCc64bfnmd3j"
+   },
+   "source": [
+    "## Step 2) Fine-tuning process 💥\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 277,
+     "referenced_widgets": [
+      "b2a19b6092c44b20886987b30f1bf48a",
+      "1f0efc167b3744b38ff832b71d529318",
+      "a06b2bd0236249999adffa44e53cf80e",
+      "23012118a7314a3f838870a2aee9ec90",
+      "dcff079d850c423a83eb70105b816ee4",
+      "64911f0e52e74067a1a986c5edfc7f59",
+      "b4a274fc9e324b80bf559c4dbd05e319",
+      "5fb4a4ef8afe4ea4af6655faea17f354",
+      "b1a03a5e9bae46129830daeeb23bf6ff",
+      "e297072ab5d64815b90bc89d22503378",
+      "67fbabb9082c4241b8f937b24e0cdd03",
+      "b1de7b283eeb41828e8093e60c83f2c4",
+      "bb640a5c858349d29c13ce5629e72f22",
+      "37523a6cac1047e9a261698212d47737",
+      "661f76474252493caae8f7d6aa8f99b7",
+      "849cdc1912aa4df4b0c721a8c63ca0f9",
+      "5962e77eea5a4d88ba6dbc5e9f51c709",
+      "f07c8a6ec12f46ea9e32a2208e70bccd",
+      "191caf3a38eb4191a35f623ce25238f9",
+      "30b74bd2db8d40d08408013cebcd7661",
+      "83c355e1418140a5bbad11bf0646b332",
+      "84d6d2a6afcd423f9b609cbb2d10f00e",
+      "51180cce01564821a170d1d4b8a9a918",
+      "03dd6c24f6d94fe7ab85b79d6f6cbeaf",
+      "f2ab2fa803e94328a237e84cd4ea0027",
+      "1bd0a270c7ee409c970763398e54fc36",
+      "e92b30d0b4234af6b5a33bff989b1b45",
+      "cc5ce633746949ed98418cae9f68afe3",
+      "4b1f795c4c004cacbf3660d935e52995",
+      "5690d92586494b9187147f32fa708405",
+      "317cda72329c4043ab0b224b46b259d3",
+      "076357d4bb9943bdaa1d6846897786af",
+      "7b3e136fc9e74a699497a947006f4f1d",
+      "7e2e097c703a4a0d8556733a0739469c",
+      "e0fd6d00f0ba4e59bdaa5779556ec4ea",
+      "cd318c6bfc8e421a9bfcdab16be5eaa7",
+      "4bc1fd9d480a4799954c69031c071b30",
+      "25fc6aaf37fc49fa822df29236bf2f90",
+      "7ac8e88f29f04b859f592a003d39836b",
+      "0ec2643d9fd44785addb37d9ecd23989",
+      "d10ba011d05045b18bbfeb9660e4d9d3",
+      "e56c22f77c884caaacfafd48dfa51a55",
+      "068eb104d5d346b1897f8cbe9860d267",
+      "b621c6a8c0e9440fa840d75a1b1b02fc",
+      "434fe18d50a14920b30fd2d0650297ac",
+      "353bf45a4bbc46d6a798175f152399cb",
+      "bfcbfe4184774fd3a8320f4f0e1baf54",
+      "99c5c846cc5e43429905f071670b4310",
+      "8d988c86648244788f6dc5aa0fea38fd",
+      "740604526cc44cd58b811827d4787d96",
+      "2558c2dd7d394ecf9fc67a69ce8fc97a",
+      "a2a7b715b16a41a288209dee1de5d2d1",
+      "bf77e5aaab0547f7b2beb015687552ef",
+      "a2c543008f444cf49972a4f35c32b8e3",
+      "bb7b8a9e42f6478f851236685a1392d6",
+      "9cfaf17064bc49a5aded0fc53dd7cd7f",
+      "ede66e196fa9482498f58dcdffd494a2",
+      "a26cc7fea1a64d7bac1769d33cc74e28",
+      "c2f24a8930be4b70b4bbbcf5d908b01d",
+      "1f59dd66813f419999336e59a3efc56a",
+      "026072374b7d47c194707a50f5c99099",
+      "63ac7dafeb27446cb30aaddf4cd27c9f",
+      "854e35df771f470b82a59f878a2a6a46",
+      "d1cbe0ab9379453588eb438d13fd272d",
+      "b0b7457a8b47496483da1506fb2505b3",
+      "c7dc386d978a44ff885763ecec94dc38",
+      "4a7c8dfd88db4bc893da2bced0560d47",
+      "27a587021d854b79a279a510a55f9d73",
+      "4227474e986546d1a7d31dce35a2410c",
+      "1561cd47c42e46368677d34e7b7084cd",
+      "8b9e961c837a464fb7a8c44756dc41e7",
+      "d4092198673141d3b4a824d629d73f64",
+      "d3cbfd564fe8485ba7afdb1cc54abed3",
+      "7e51e8e0612e46b1a3403d448b39aa50",
+      "061c45266c484ff6807dcaf4722fd73b",
+      "04188e0cec0542818894ebc6a534fb51",
+      "4a13203d132b45beadf140c02dc8a566"
+     ]
+    },
+    "id": "s6f4z8EYmcJ6",
+    "outputId": "8ece7a1a-cf27-4602-c70b-ce4f3d7e11bf"
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b2a19b6092c44b20886987b30f1bf48a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading readme:   0%|          | 0.00/395 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Repo card metadata block was not found. Setting CardData to empty.\n",
+      "WARNING:huggingface_hub.repocard:Repo card metadata block was not found. Setting CardData to empty.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b1de7b283eeb41828e8093e60c83f2c4",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading data:   0%|          | 0.00/20.9M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "51180cce01564821a170d1d4b8a9a918",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading data:   0%|          | 0.00/1.11M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "7e2e097c703a4a0d8556733a0739469c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Generating train split:   0%|          | 0/9846 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "434fe18d50a14920b30fd2d0650297ac",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Generating test split:   0%|          | 0/518 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "9cfaf17064bc49a5aded0fc53dd7cd7f",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map:   0%|          | 0/9846 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "4a7c8dfd88db4bc893da2bced0560d47",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map:   0%|          | 0/518 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Load the dataset from HF\n",
+    "from datasets import load_dataset\n",
+    "\n",
+    "data = load_dataset(\"timdettmers/openassistant-guanaco\")\n",
+    "data = data.map(lambda samples: tokenizer(samples[\"text\"]), batched=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "_0MOtwf3zdZp"
+   },
+   "source": [
+    "## Training\n",
+    "\n",
+    "For the sake of the demo, we just ran it for 10 steps just to showcase how to use this integration with existing tools on the HF ecosystem."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 498
+    },
+    "id": "jq0nX33BmfaC",
+    "outputId": "94e17005-065b-48ab-9192-e3ab55c0c292"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "max_steps is given, it will override any value given in num_train_epochs\n",
+      "/usr/local/lib/python3.10/dist-packages/torch/utils/checkpoint.py:464: UserWarning: torch.utils.checkpoint: the use_reentrant parameter should be passed explicitly. In version 2.4 we will raise an exception if use_reentrant is not passed. use_reentrant=False is recommended, but if you need to preserve the current default behavior, you can pass use_reentrant=True. Refer to docs for more details on the differences between the two variants.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "    <div>\n",
+       "      \n",
+       "      <progress value='10' max='10' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
+       "      [10/10 03:56, Epoch 0/1]\n",
+       "    </div>\n",
+       "    <table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       " <tr style=\"text-align: left;\">\n",
+       "      <th>Step</th>\n",
+       "      <th>Training Loss</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <td>1</td>\n",
+       "      <td>1.276300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>2</td>\n",
+       "      <td>1.877700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>3</td>\n",
+       "      <td>1.983800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>4</td>\n",
+       "      <td>2.011400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>5</td>\n",
+       "      <td>1.997800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>6</td>\n",
+       "      <td>1.648100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>7</td>\n",
+       "      <td>1.576000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>8</td>\n",
+       "      <td>0.916400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>9</td>\n",
+       "      <td>1.523100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>10</td>\n",
+       "      <td>1.814500</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table><p>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "TrainOutput(global_step=10, training_loss=1.662518608570099, metrics={'train_runtime': 269.3407, 'train_samples_per_second': 0.149, 'train_steps_per_second': 0.037, 'total_flos': 530537216679936.0, 'train_loss': 1.662518608570099, 'epoch': 0.004062563477554337})"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import transformers\n",
+    "\n",
+    "tokenizer.pad_token = tokenizer.eos_token\n",
+    "\n",
+    "trainer = transformers.Trainer(\n",
+    "    model=model,\n",
+    "    train_dataset=data[\"train\"],\n",
+    "    args=transformers.TrainingArguments(\n",
+    "        per_device_train_batch_size=1,\n",
+    "        gradient_accumulation_steps=4,\n",
+    "        warmup_steps=2,\n",
+    "        max_steps=10,\n",
+    "        learning_rate=2e-4,\n",
+    "        fp16=True,\n",
+    "        logging_steps=1,\n",
+    "        output_dir=\"path/to/your/HF/repo\",  # change it to your desired repo!\n",
+    "        optim=\"paged_adamw_8bit\",\n",
+    "    ),\n",
+    "    data_collator=transformers.DataCollatorForLanguageModeling(tokenizer, mlm=False),\n",
+    ")\n",
+    "model.config.use_cache = False  # silence the warnings. Please re-enable for inference!\n",
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Mr3rLrHwqhf6"
+   },
+   "source": [
+    "## Usage Example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "collapsed": true,
+    "id": "9mrOJ9l8SMHv"
+   },
+   "outputs": [],
+   "source": [
+    "model.config.use_cache = True\n",
+    "model.eval();"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 122
+    },
+    "id": "AM6FNOFzqKfI",
+    "outputId": "fdbe28b1-e440-45d3-bd6d-c15e744ad23d"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Setting `pad_token_id` to `eos_token_id`:128001 for open-end generation.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.google.colaboratory.intrinsic+json": {
+       "type": "string"
+      },
+      "text/plain": [
+       "\"A chat between a curious human and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the user's questions. ### Human: What is the purpose of quantization in LLMs?### Assistant:  Quantization is a technique used to reduce the size of a model without significantly impacting its performance. In the context of language models, quantization is the process of converting floating-point numbers (which are used to represent the weights and activations of a model) to smaller, fixed-point numbers. This can be done by grouping the weights into small chunks and assigning each chunk a single, fixed-point number. Quantization can significantly reduce the size of a model, making it more efficient to train and deploy. In addition, quantization can improve the performance of a model on low-power devices, such as mobile phones\""
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from transformers import GenerationConfig\n",
+    "\n",
+    "max_new_tokens = 120\n",
+    "top_p = 0.9\n",
+    "temperature = 0.7\n",
+    "user_question = \"What is the purpose of quantization in LLMs?\"\n",
+    "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "\n",
+    "\n",
+    "prompt = (\n",
+    "    \"A chat between a curious human and an artificial intelligence assistant. \"\n",
+    "    \"The assistant gives helpful, detailed, and polite answers to the user's questions. \"\n",
+    "    \"### Human: {user_question}\"\n",
+    "    \"### Assistant: \"\n",
+    ")\n",
+    "\n",
+    "\n",
+    "def generate(model, user_question, max_new_tokens=max_new_tokens, top_p=top_p, temperature=temperature):\n",
+    "    inputs = tokenizer(prompt.format(user_question=user_question), return_tensors=\"pt\").to(device)\n",
+    "\n",
+    "    outputs = model.generate(\n",
+    "        **inputs,\n",
+    "        generation_config=GenerationConfig(\n",
+    "            do_sample=True,\n",
+    "            max_new_tokens=max_new_tokens,\n",
+    "            top_p=top_p,\n",
+    "            temperature=temperature,\n",
+    "        ),\n",
+    "    )\n",
+    "\n",
+    "    text = tokenizer.decode(outputs[0], skip_special_tokens=True)\n",
+    "    # print(text)\n",
+    "    return text\n",
+    "\n",
+    "\n",
+    "generate(model, user_question)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "T5t_gl2_f5OO"
+   },
+   "outputs": [],
+   "source": [
+    "# trainer.push_to_hub()"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "gpuType": "T4",
+   "provenance": []
+  },
+  "gpuClass": "standard",
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.1.-1"
+  },
+  "widgets": {
+   "application/vnd.jupyter.widget-state+json": {
+    "00371a48e64c45cd97020a78b710e64c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_3f9fa554747743f8a86b40a4f7530617",
+      "placeholder": "​",
+      "style": "IPY_MODEL_ffe561df8772443ebf40a3b8b656079f",
+      "value": " 50.6k/50.6k [00:00&lt;00:00, 3.65MB/s]"
+     }
+    },
+    "006b78b5191b4fb888d98bdf6c20ec1e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "LabelModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "LabelModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "LabelView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_ee4e4af964ec4dd597cb04a90f0697f9",
+      "placeholder": "​",
+      "style": "IPY_MODEL_974e3687f18a4e1a975969b880d086aa",
+      "value": "Your token has been saved in your configured git credential helpers (store)."
+     }
+    },
+    "026072374b7d47c194707a50f5c99099": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "02d6cc4c2717434c895798601bda7c86": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "03dd6c24f6d94fe7ab85b79d6f6cbeaf": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_cc5ce633746949ed98418cae9f68afe3",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4b1f795c4c004cacbf3660d935e52995",
+      "value": "Downloading data: 100%"
+     }
+    },
+    "04188e0cec0542818894ebc6a534fb51": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "061c45266c484ff6807dcaf4722fd73b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "068eb104d5d346b1897f8cbe9860d267": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0711e28e06a440c2a241acbc1f90d1e8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f4ca7b63d7d749ff83a848e250f03ec1",
+      "placeholder": "​",
+      "style": "IPY_MODEL_8c149bc655a34fe5b91853c66db458a9",
+      "value": "model.safetensors.index.json: 100%"
+     }
+    },
+    "076357d4bb9943bdaa1d6846897786af": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "07e0aed682fd4cc88fa75c0592dc04a7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_47944ad8cadf4a57b170193c46d4389c",
+      "placeholder": "​",
+      "style": "IPY_MODEL_db05b25cb38140bdb21e6f3b7fde7e66",
+      "value": "model-00001-of-00004.safetensors: 100%"
+     }
+    },
+    "082b6990ce5e4812adc0ad6a7b376dac": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0aad2d9d1cba40cbb64308ede3242ed7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_0711e28e06a440c2a241acbc1f90d1e8",
+       "IPY_MODEL_77704d2e27e94cd3a0c5f6b5ceeffd1c",
+       "IPY_MODEL_3b82b8d41b134bec9bd77ed8d4f00eb4"
+      ],
+      "layout": "IPY_MODEL_25fef90e209f4b14a73f3e39d226d913"
+     }
+    },
+    "0b145e421f4840f2872c29256b49f168": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0c4ac7c3db0b431397cc812f7c9e785c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "CheckboxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "CheckboxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "CheckboxView",
+      "description": "Add token as git credential?",
+      "description_tooltip": null,
+      "disabled": false,
+      "indent": true,
+      "layout": "IPY_MODEL_90661b333d6f496ca606b3046622660e",
+      "style": "IPY_MODEL_5f551f9b217e44cf8b5433f314b3844b",
+      "value": true
+     }
+    },
+    "0d2ae3466a3447c58e23ccd2b3733deb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_921a1a037f7b47f8b57d1da8192a437a",
+      "placeholder": "​",
+      "style": "IPY_MODEL_892ff4e2f0e44c23bc5c2be7547cf0bd",
+      "value": "generation_config.json: 100%"
+     }
+    },
+    "0e2beab611114239b6ee48a3cbb09c49": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "LabelModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "LabelModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "LabelView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_57b0096985ab44aea342e52795c4f999",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a4c404e420cc4ce781ce569f9ab3f987",
+      "value": "Token is valid (permission: write)."
+     }
+    },
+    "0ec2643d9fd44785addb37d9ecd23989": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "0f4c664612364dc89acf78eb1c740980": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0f54e8fda93144f6a95493e6ec535e9d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0f60f9aa76b941809e013ffcae83604a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "124a70bfad434c5c946f611c04a91c8f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "14bf612f6ad7416c8ddd6085c72eee0e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "14c73d88df9e46e3bbb6690fdb48ad07": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "1561cd47c42e46368677d34e7b7084cd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_04188e0cec0542818894ebc6a534fb51",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4a13203d132b45beadf140c02dc8a566",
+      "value": " 518/518 [00:00&lt;00:00, 976.36 examples/s]"
+     }
+    },
+    "156f95b0012449e8a0c604e6e03bf35f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "17c797e08bd2493fa685918129415309": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "191caf3a38eb4191a35f623ce25238f9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1ae1d2702da5483a85504f59939ffa39": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8cd63d3908e4411c9fcb42bc32c8dd16",
+      "max": 73,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_64624b26145b42db82f7afc36c32e117",
+      "value": 73
+     }
+    },
+    "1b2abf90003e4165a3293acd6a5ea9ff": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_cffdf12fbe97462ab74e88ccca943aeb",
+      "placeholder": "​",
+      "style": "IPY_MODEL_bcaf4c81ba9d437bb6223dbb22d011ed",
+      "value": " 73.0/73.0 [00:00&lt;00:00, 4.75kB/s]"
+     }
+    },
+    "1bd0a270c7ee409c970763398e54fc36": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_076357d4bb9943bdaa1d6846897786af",
+      "placeholder": "​",
+      "style": "IPY_MODEL_7b3e136fc9e74a699497a947006f4f1d",
+      "value": " 1.11M/1.11M [00:00&lt;00:00, 8.23MB/s]"
+     }
+    },
+    "1d27ab2bc6ae463a806292b68b7891f8": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1f0efc167b3744b38ff832b71d529318": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_64911f0e52e74067a1a986c5edfc7f59",
+      "placeholder": "​",
+      "style": "IPY_MODEL_b4a274fc9e324b80bf559c4dbd05e319",
+      "value": "Downloading readme: 100%"
+     }
+    },
+    "1f59dd66813f419999336e59a3efc56a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1f75d85e6c7e4eb6a91b03f0c8adb644": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1f82a5685eef4b47a2dbf7618362907c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "21bf14b771c14d2dab9e98a326302e14": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "23012118a7314a3f838870a2aee9ec90": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e297072ab5d64815b90bc89d22503378",
+      "placeholder": "​",
+      "style": "IPY_MODEL_67fbabb9082c4241b8f937b24e0cdd03",
+      "value": " 395/395 [00:00&lt;00:00, 16.6kB/s]"
+     }
+    },
+    "2540d57e3bf545e3812da1ee72b85fc8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "2558c2dd7d394ecf9fc67a69ce8fc97a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "25fc6aaf37fc49fa822df29236bf2f90": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "25fef90e209f4b14a73f3e39d226d913": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "27a587021d854b79a279a510a55f9d73": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d4092198673141d3b4a824d629d73f64",
+      "placeholder": "​",
+      "style": "IPY_MODEL_d3cbfd564fe8485ba7afdb1cc54abed3",
+      "value": "Map: 100%"
+     }
+    },
+    "2a57bb48e1c6475abba242994a79d44a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "2ab86b3fbd49488bb02f8205a572e752": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "30b74bd2db8d40d08408013cebcd7661": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "317cda72329c4043ab0b224b46b259d3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "31c10fa464e24f97b379675a204a09b5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_1d27ab2bc6ae463a806292b68b7891f8",
+      "max": 654,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_2a57bb48e1c6475abba242994a79d44a",
+      "value": 654
+     }
+    },
+    "31c574113731403b88edc5bb0798bc6d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "347540dc03d34e65b7ffbb0f5fc569aa": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "34e381adbd9242759b57f2a305c5d2e3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "35186465f87341f683affb9399661540": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": "center",
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": "flex",
+      "flex": null,
+      "flex_flow": "column",
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": "50%"
+     }
+    },
+    "353bf45a4bbc46d6a798175f152399cb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_740604526cc44cd58b811827d4787d96",
+      "placeholder": "​",
+      "style": "IPY_MODEL_2558c2dd7d394ecf9fc67a69ce8fc97a",
+      "value": "Generating test split: 100%"
+     }
+    },
+    "35c2c635c2024bcda3265bf95d330f63": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "37523a6cac1047e9a261698212d47737": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_191caf3a38eb4191a35f623ce25238f9",
+      "max": 20877686,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_30b74bd2db8d40d08408013cebcd7661",
+      "value": 20877686
+     }
+    },
+    "3b614b9712874fac990d2c557b0791a6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "3b82b8d41b134bec9bd77ed8d4f00eb4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_14bf612f6ad7416c8ddd6085c72eee0e",
+      "placeholder": "​",
+      "style": "IPY_MODEL_f7e59b47f9b74523843f37268212d566",
+      "value": " 23.9k/23.9k [00:00&lt;00:00, 1.51MB/s]"
+     }
+    },
+    "3b8bc5b9392e45758813a1db9db824a9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "3d9d8278667d496aaea1eaaa4d24ae93": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3e45aea9f7444a4db885c4cca4c9c4ff": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3f9fa554747743f8a86b40a4f7530617": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4227474e986546d1a7d31dce35a2410c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7e51e8e0612e46b1a3403d448b39aa50",
+      "max": 518,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_061c45266c484ff6807dcaf4722fd73b",
+      "value": 518
+     }
+    },
+    "42eb041021214110a860924d28d73409": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4c369386ba5f4862b11a50e50130663b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_bbdf3bb657e64fc2b0a90e78e8886480",
+      "value": " 5.00G/5.00G [00:24&lt;00:00, 249MB/s]"
+     }
+    },
+    "434fe18d50a14920b30fd2d0650297ac": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_353bf45a4bbc46d6a798175f152399cb",
+       "IPY_MODEL_bfcbfe4184774fd3a8320f4f0e1baf54",
+       "IPY_MODEL_99c5c846cc5e43429905f071670b4310"
+      ],
+      "layout": "IPY_MODEL_8d988c86648244788f6dc5aa0fea38fd"
+     }
+    },
+    "43d12a98d90a4bf7a96c033172c646e2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_c35b16156253402f90a432f3f07c2e0a",
+       "IPY_MODEL_1ae1d2702da5483a85504f59939ffa39",
+       "IPY_MODEL_1b2abf90003e4165a3293acd6a5ea9ff"
+      ],
+      "layout": "IPY_MODEL_3e45aea9f7444a4db885c4cca4c9c4ff"
+     }
+    },
+    "47944ad8cadf4a57b170193c46d4389c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4a13203d132b45beadf140c02dc8a566": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4a7c8dfd88db4bc893da2bced0560d47": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_27a587021d854b79a279a510a55f9d73",
+       "IPY_MODEL_4227474e986546d1a7d31dce35a2410c",
+       "IPY_MODEL_1561cd47c42e46368677d34e7b7084cd"
+      ],
+      "layout": "IPY_MODEL_8b9e961c837a464fb7a8c44756dc41e7"
+     }
+    },
+    "4b1f795c4c004cacbf3660d935e52995": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4bc1fd9d480a4799954c69031c071b30": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_068eb104d5d346b1897f8cbe9860d267",
+      "placeholder": "​",
+      "style": "IPY_MODEL_b621c6a8c0e9440fa840d75a1b1b02fc",
+      "value": " 9846/9846 [00:00&lt;00:00, 38881.08 examples/s]"
+     }
+    },
+    "4bdb196cd1494f809829651ec5b6cbf8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4c369386ba5f4862b11a50e50130663b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4c8e98294bd240a6869cb199caee66e1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4e1f5423311b4dc0930c21c9ad5a88f5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "51180cce01564821a170d1d4b8a9a918": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_03dd6c24f6d94fe7ab85b79d6f6cbeaf",
+       "IPY_MODEL_f2ab2fa803e94328a237e84cd4ea0027",
+       "IPY_MODEL_1bd0a270c7ee409c970763398e54fc36"
+      ],
+      "layout": "IPY_MODEL_e92b30d0b4234af6b5a33bff989b1b45"
+     }
+    },
+    "51b3af446ace409dbcdf5de499552061": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "53f287d4927541d08e2ae7d4d0b3c396": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "546b76a22f1046cd856a8fa2f9ff2d9f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5690d92586494b9187147f32fa708405": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "57b0096985ab44aea342e52795c4f999": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "57f251691b4c453896b2508c431dfc2f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "57f87d4780634d36ae8159d987c22993": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_58ea619f81bf42ddb8b166db3deb0e86",
+       "IPY_MODEL_8bb83ae3229e4f38b1733f92f536fad0",
+       "IPY_MODEL_5c0104210ee34ca8a072ee5121f424a1"
+      ],
+      "layout": "IPY_MODEL_34e381adbd9242759b57f2a305c5d2e3"
+     }
+    },
+    "58ea619f81bf42ddb8b166db3deb0e86": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e4e1a4338c5e46b3ba5a3bb960da7107",
+      "placeholder": "​",
+      "style": "IPY_MODEL_9a5072b8d16d4a1eb0652da61bda0ac8",
+      "value": "Loading checkpoint shards: 100%"
+     }
+    },
+    "5924b266e95a42039634a334ff561a82": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_eadeec171e7b4c0f9e26964f031cfb71",
+       "IPY_MODEL_feae525923d5407bb69a922954c474f7",
+       "IPY_MODEL_00371a48e64c45cd97020a78b710e64c"
+      ],
+      "layout": "IPY_MODEL_156f95b0012449e8a0c604e6e03bf35f"
+     }
+    },
+    "5962e77eea5a4d88ba6dbc5e9f51c709": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5a8ac674153248999007a713299b2644": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5b2a671976fa446db408d58a215b8249": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_63899ac621ff4e9cb8e215d5ab63bef8",
+      "max": 4,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_6b2b59d2b62b4f7da8c60ff783138397",
+      "value": 4
+     }
+    },
+    "5b56ac3009714a5a84dd8749db4a7bce": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_51b3af446ace409dbcdf5de499552061",
+      "placeholder": "​",
+      "style": "IPY_MODEL_9a12124915994b70a71ebd64b99e93e9",
+      "value": " 1.17G/1.17G [00:09&lt;00:00, 45.8MB/s]"
+     }
+    },
+    "5c0104210ee34ca8a072ee5121f424a1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_604582e8cbff4dc9876551a3307b5b77",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a98165ee656643ad85ac9ea1447cc775",
+      "value": " 4/4 [01:13&lt;00:00, 15.74s/it]"
+     }
+    },
+    "5cf4a57d21a545029b6448258a5ebd84": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_0d2ae3466a3447c58e23ccd2b3733deb",
+       "IPY_MODEL_ba7f32c41f9247ec9d4c40e6396b55a9",
+       "IPY_MODEL_ea1bdb5f2da64332960bccd967a84b4a"
+      ],
+      "layout": "IPY_MODEL_b08631e4cffa445c912da0c8eac2ef23"
+     }
+    },
+    "5f551f9b217e44cf8b5433f314b3844b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "5f60910d1e744432bdf87518f0f45874": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5f6ffa1d929443a5bd9c7c550f0690f0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "LabelModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "LabelModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "LabelView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_93a50117ece543d4857ba02505dc4514",
+      "placeholder": "​",
+      "style": "IPY_MODEL_71a3a56edbdb45669d382fef4b097e1b",
+      "value": "Your token has been saved to /root/.cache/huggingface/token"
+     }
+    },
+    "5fb4a4ef8afe4ea4af6655faea17f354": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "604582e8cbff4dc9876551a3307b5b77": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "610e1ddfb7a44d51a54ebea6dad3a5f0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "6149752353fe4f9cbb7b26bcc25199a9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6cb8065803724d80b82b06dc95ded91e",
+      "placeholder": "​",
+      "style": "IPY_MODEL_8301c6302df54bbc9f15295f11cec208",
+      "value": " 654/654 [00:00&lt;00:00, 46.9kB/s]"
+     }
+    },
+    "63899ac621ff4e9cb8e215d5ab63bef8": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "63ac7dafeb27446cb30aaddf4cd27c9f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "64624b26145b42db82f7afc36c32e117": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "64911f0e52e74067a1a986c5edfc7f59": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "661f76474252493caae8f7d6aa8f99b7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_83c355e1418140a5bbad11bf0646b332",
+      "placeholder": "​",
+      "style": "IPY_MODEL_84d6d2a6afcd423f9b609cbb2d10f00e",
+      "value": " 20.9M/20.9M [00:00&lt;00:00, 44.7MB/s]"
+     }
+    },
+    "668a7f88506148a9ba2b48920afc028f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "LabelModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "LabelModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "LabelView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_53f287d4927541d08e2ae7d4d0b3c396",
+      "placeholder": "​",
+      "style": "IPY_MODEL_afa442ab223b46cb82569438c0047823",
+      "value": "Login successful"
+     }
+    },
+    "67b4473eb8a44a96ba34983762ab38fa": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6f474268da0f4337a2ccecc1ca2098a1",
+      "max": 4976698672,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_c2ceccfdb59b4336a24003cd6bc2403d",
+      "value": 4976698672
+     }
+    },
+    "67fbabb9082c4241b8f937b24e0cdd03": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "6b0ec8d5f7294d44a5fa15d8ef12471e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8ea89e52123643268857285e0e1db1c0",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a8514e34378d47a28fbf0831a14ede8f",
+      "value": "tokenizer.json: 100%"
+     }
+    },
+    "6b2b59d2b62b4f7da8c60ff783138397": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "6b6ed29053ec4aaa8fc5526a35f17c2b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6bb9c7182d2a464ea21809e59043562a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "6cb8065803724d80b82b06dc95ded91e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6f474268da0f4337a2ccecc1ca2098a1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7037c32dfce84e70ac86537dbbc6a495": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_0f4c664612364dc89acf78eb1c740980",
+      "placeholder": "​",
+      "style": "IPY_MODEL_0f60f9aa76b941809e013ffcae83604a",
+      "value": "config.json: 100%"
+     }
+    },
+    "71a3a56edbdb45669d382fef4b097e1b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "7243d8e2e1cc4043a2ee310eabd0ac09": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "740604526cc44cd58b811827d4787d96": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7504986b8d8d4d0da58ad79e80a81948": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7725e9d443e249ada02e5ac7056d00db": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "77704d2e27e94cd3a0c5f6b5ceeffd1c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_0f54e8fda93144f6a95493e6ec535e9d",
+      "max": 23950,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_880124db7dc04aaea09edd75e1ec7921",
+      "value": 23950
+     }
+    },
+    "791df472db174df69b8c9f0e200af254": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7a00aa4a97a34da39cc052c6926dbe13": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7ac8e88f29f04b859f592a003d39836b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7b3e136fc9e74a699497a947006f4f1d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "7cd50bcc8fcc4b83abcda6d3604bd4cc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "LabelModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "LabelModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "LabelView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7a00aa4a97a34da39cc052c6926dbe13",
+      "placeholder": "​",
+      "style": "IPY_MODEL_14c73d88df9e46e3bbb6690fdb48ad07",
+      "value": "Connecting..."
+     }
+    },
+    "7d3a7be9ed6f48988a2c4a1a4a2271cf": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f86b969ef69b48119619e1a424b50460",
+      "max": 9085698,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_7725e9d443e249ada02e5ac7056d00db",
+      "value": 9085698
+     }
+    },
+    "7e2e097c703a4a0d8556733a0739469c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_e0fd6d00f0ba4e59bdaa5779556ec4ea",
+       "IPY_MODEL_cd318c6bfc8e421a9bfcdab16be5eaa7",
+       "IPY_MODEL_4bc1fd9d480a4799954c69031c071b30"
+      ],
+      "layout": "IPY_MODEL_25fc6aaf37fc49fa822df29236bf2f90"
+     }
+    },
+    "7e3a386e672f4748882211227b7721a9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ButtonStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ButtonStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "button_color": null,
+      "font_weight": ""
+     }
+    },
+    "7e51e8e0612e46b1a3403d448b39aa50": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "800e9453214848b69bc4c6ca2d5e8f79": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_6b0ec8d5f7294d44a5fa15d8ef12471e",
+       "IPY_MODEL_7d3a7be9ed6f48988a2c4a1a4a2271cf",
+       "IPY_MODEL_c40f583823574e40b6b29d4914143c0e"
+      ],
+      "layout": "IPY_MODEL_a4368e6da8f046aaa32f3152b7d333d1"
+     }
+    },
+    "8301c6302df54bbc9f15295f11cec208": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "8365680c634a44aa880317e36fa5e46e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "PasswordModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "PasswordModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "PasswordView",
+      "continuous_update": true,
+      "description": "Token:",
+      "description_tooltip": null,
+      "disabled": false,
+      "layout": "IPY_MODEL_31c574113731403b88edc5bb0798bc6d",
+      "placeholder": "​",
+      "style": "IPY_MODEL_3b8bc5b9392e45758813a1db9db824a9",
+      "value": ""
+     }
+    },
+    "83c355e1418140a5bbad11bf0646b332": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "849cdc1912aa4df4b0c721a8c63ca0f9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "84d6d2a6afcd423f9b609cbb2d10f00e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "854e35df771f470b82a59f878a2a6a46": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8800c351b6da450eace0c3890d36c8d7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_7037c32dfce84e70ac86537dbbc6a495",
+       "IPY_MODEL_31c10fa464e24f97b379675a204a09b5",
+       "IPY_MODEL_6149752353fe4f9cbb7b26bcc25199a9"
+      ],
+      "layout": "IPY_MODEL_0b145e421f4840f2872c29256b49f168"
+     }
+    },
+    "880124db7dc04aaea09edd75e1ec7921": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "88024cd312ee42c2925ebfbe52077780": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "892ff4e2f0e44c23bc5c2be7547cf0bd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "8a7c82dcbd414b24b67ccfbc562b2e38": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "8b9e961c837a464fb7a8c44756dc41e7": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8bb83ae3229e4f38b1733f92f536fad0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_1f75d85e6c7e4eb6a91b03f0c8adb644",
+      "max": 4,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_9da33f07ea354b5798e85298e132b017",
+      "value": 4
+     }
+    },
+    "8c149bc655a34fe5b91853c66db458a9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "8c4d6f4eea3742289a2604e66b0c6182": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "8cc86330c2af436c9af314e8c04c8c2b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "VBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "VBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "VBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_0e2beab611114239b6ee48a3cbb09c49",
+       "IPY_MODEL_006b78b5191b4fb888d98bdf6c20ec1e",
+       "IPY_MODEL_5f6ffa1d929443a5bd9c7c550f0690f0",
+       "IPY_MODEL_668a7f88506148a9ba2b48920afc028f"
+      ],
+      "layout": "IPY_MODEL_35186465f87341f683affb9399661540"
+     }
+    },
+    "8cd63d3908e4411c9fcb42bc32c8dd16": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8d0f1d547c384094b10aa00a3ede3c06": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_082b6990ce5e4812adc0ad6a7b376dac",
+      "placeholder": "​",
+      "style": "IPY_MODEL_610e1ddfb7a44d51a54ebea6dad3a5f0",
+      "value": "model-00003-of-00004.safetensors: 100%"
+     }
+    },
+    "8d988c86648244788f6dc5aa0fea38fd": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8ea89e52123643268857285e0e1db1c0": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8f5b8c513b164dab9e0892422163c483": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_cd11fb7d54bb43ae821f2272d075a1b3",
+      "placeholder": "​",
+      "style": "IPY_MODEL_fbc6a2834c5442fbb6667f1b3612bb5b",
+      "value": "Downloading shards: 100%"
+     }
+    },
+    "90661b333d6f496ca606b3046622660e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "921a1a037f7b47f8b57d1da8192a437a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "93a50117ece543d4857ba02505dc4514": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "974e3687f18a4e1a975969b880d086aa": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "99529129d7f0435da0fdcfc9803a2f11": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5a8ac674153248999007a713299b2644",
+      "max": 1168138808,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_1f82a5685eef4b47a2dbf7618362907c",
+      "value": 1168138808
+     }
+    },
+    "99c5c846cc5e43429905f071670b4310": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a2c543008f444cf49972a4f35c32b8e3",
+      "placeholder": "​",
+      "style": "IPY_MODEL_bb7b8a9e42f6478f851236685a1392d6",
+      "value": " 518/518 [00:00&lt;00:00, 13408.85 examples/s]"
+     }
+    },
+    "9a0b012915c54abeb100f466fa99d303": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_fffbf696c07744fc8e3d81ab51dc9c90",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a153cc3ca0cc45c18a941bd57e363ec3",
+      "value": "model-00004-of-00004.safetensors: 100%"
+     }
+    },
+    "9a12124915994b70a71ebd64b99e93e9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "9a5072b8d16d4a1eb0652da61bda0ac8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "9bdebf06b6874bbb88404f4ad14e1dbc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5f60910d1e744432bdf87518f0f45874",
+      "max": 4915916176,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_2ab86b3fbd49488bb02f8205a572e752",
+      "value": 4915916176
+     }
+    },
+    "9cfaf17064bc49a5aded0fc53dd7cd7f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_ede66e196fa9482498f58dcdffd494a2",
+       "IPY_MODEL_a26cc7fea1a64d7bac1769d33cc74e28",
+       "IPY_MODEL_c2f24a8930be4b70b4bbbcf5d908b01d"
+      ],
+      "layout": "IPY_MODEL_1f59dd66813f419999336e59a3efc56a"
+     }
+    },
+    "9da33f07ea354b5798e85298e132b017": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "9f13437a44b8434b9cc3afab998e8d3c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a06b2bd0236249999adffa44e53cf80e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5fb4a4ef8afe4ea4af6655faea17f354",
+      "max": 395,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_b1a03a5e9bae46129830daeeb23bf6ff",
+      "value": 395
+     }
+    },
+    "a153cc3ca0cc45c18a941bd57e363ec3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a2249f364b914662b54045a1f8d6dfd1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_9f13437a44b8434b9cc3afab998e8d3c",
+      "placeholder": "​",
+      "style": "IPY_MODEL_8a7c82dcbd414b24b67ccfbc562b2e38",
+      "value": " 4.92G/4.92G [00:32&lt;00:00, 171MB/s]"
+     }
+    },
+    "a26cc7fea1a64d7bac1769d33cc74e28": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_854e35df771f470b82a59f878a2a6a46",
+      "max": 9846,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_d1cbe0ab9379453588eb438d13fd272d",
+      "value": 9846
+     }
+    },
+    "a2a7b715b16a41a288209dee1de5d2d1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a2c543008f444cf49972a4f35c32b8e3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a34b3fd5859a441f89cbe7f6e6df9da9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_8f5b8c513b164dab9e0892422163c483",
+       "IPY_MODEL_5b2a671976fa446db408d58a215b8249",
+       "IPY_MODEL_c934919f617447cfb9226929e7a68d79"
+      ],
+      "layout": "IPY_MODEL_124a70bfad434c5c946f611c04a91c8f"
+     }
+    },
+    "a4368e6da8f046aaa32f3152b7d333d1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a4c404e420cc4ce781ce569f9ab3f987": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a53b4776f95f4dd38197193e6c5f649e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_aea74071600f483b9e6de1a61743c03a",
+      "placeholder": "​",
+      "style": "IPY_MODEL_21bf14b771c14d2dab9e98a326302e14",
+      "value": "model-00002-of-00004.safetensors: 100%"
+     }
+    },
+    "a8514e34378d47a28fbf0831a14ede8f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a8999d04e4114693bb6be358bdbe9b83": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a98165ee656643ad85ac9ea1447cc775": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "aea74071600f483b9e6de1a61743c03a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "afa442ab223b46cb82569438c0047823": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "b08631e4cffa445c912da0c8eac2ef23": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b0b7457a8b47496483da1506fb2505b3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b1a03a5e9bae46129830daeeb23bf6ff": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "b1de7b283eeb41828e8093e60c83f2c4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_bb640a5c858349d29c13ce5629e72f22",
+       "IPY_MODEL_37523a6cac1047e9a261698212d47737",
+       "IPY_MODEL_661f76474252493caae8f7d6aa8f99b7"
+      ],
+      "layout": "IPY_MODEL_849cdc1912aa4df4b0c721a8c63ca0f9"
+     }
+    },
+    "b2a19b6092c44b20886987b30f1bf48a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_1f0efc167b3744b38ff832b71d529318",
+       "IPY_MODEL_a06b2bd0236249999adffa44e53cf80e",
+       "IPY_MODEL_23012118a7314a3f838870a2aee9ec90"
+      ],
+      "layout": "IPY_MODEL_dcff079d850c423a83eb70105b816ee4"
+     }
+    },
+    "b3b3f4ddd4ed4d938c923887939a0440": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_57f251691b4c453896b2508c431dfc2f",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4bdb196cd1494f809829651ec5b6cbf8",
+      "value": "\n<b>Pro Tip:</b> If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks. </center>"
+     }
+    },
+    "b4a274fc9e324b80bf559c4dbd05e319": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "b4ba435f6d1c448f99b533bc6df32e76": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_35c2c635c2024bcda3265bf95d330f63",
+      "max": 4999802720,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_ec014d847e394a309b6a82c30a6fdfc5",
+      "value": 4999802720
+     }
+    },
+    "b621c6a8c0e9440fa840d75a1b1b02fc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "ba7f32c41f9247ec9d4c40e6396b55a9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4c8e98294bd240a6869cb199caee66e1",
+      "max": 177,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_4e1f5423311b4dc0930c21c9ad5a88f5",
+      "value": 177
+     }
+    },
+    "bac377ed96ae4e8db9b298bb623888ec": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "bb640a5c858349d29c13ce5629e72f22": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5962e77eea5a4d88ba6dbc5e9f51c709",
+      "placeholder": "​",
+      "style": "IPY_MODEL_f07c8a6ec12f46ea9e32a2208e70bccd",
+      "value": "Downloading data: 100%"
+     }
+    },
+    "bb7b8a9e42f6478f851236685a1392d6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "bbdf3bb657e64fc2b0a90e78e8886480": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "bcaf4c81ba9d437bb6223dbb22d011ed": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "bf77e5aaab0547f7b2beb015687552ef": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "bfcbfe4184774fd3a8320f4f0e1baf54": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a2a7b715b16a41a288209dee1de5d2d1",
+      "max": 518,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_bf77e5aaab0547f7b2beb015687552ef",
+      "value": 518
+     }
+    },
+    "c27e8ce031884a90b41d8220b1870bc4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c2ceccfdb59b4336a24003cd6bc2403d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "c2f24a8930be4b70b4bbbcf5d908b01d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b0b7457a8b47496483da1506fb2505b3",
+      "placeholder": "​",
+      "style": "IPY_MODEL_c7dc386d978a44ff885763ecec94dc38",
+      "value": " 9846/9846 [00:09&lt;00:00, 1066.17 examples/s]"
+     }
+    },
+    "c35b16156253402f90a432f3f07c2e0a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6b6ed29053ec4aaa8fc5526a35f17c2b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_e69cd88ccbae4bb7b238fa112a60f0f9",
+      "value": "special_tokens_map.json: 100%"
+     }
+    },
+    "c40f583823574e40b6b29d4914143c0e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f81756eb9e554899b0778311f2c407c4",
+      "placeholder": "​",
+      "style": "IPY_MODEL_3b614b9712874fac990d2c557b0791a6",
+      "value": " 9.09M/9.09M [00:00&lt;00:00, 19.3MB/s]"
+     }
+    },
+    "c56d8289513441688f9bc5f4b52d60a0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_a53b4776f95f4dd38197193e6c5f649e",
+       "IPY_MODEL_b4ba435f6d1c448f99b533bc6df32e76",
+       "IPY_MODEL_42eb041021214110a860924d28d73409"
+      ],
+      "layout": "IPY_MODEL_17c797e08bd2493fa685918129415309"
+     }
+    },
+    "c7dc386d978a44ff885763ecec94dc38": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "c7e06fd82f7f4f9fb81c68e8758f2de1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a8999d04e4114693bb6be358bdbe9b83",
+      "placeholder": "​",
+      "style": "IPY_MODEL_2540d57e3bf545e3812da1ee72b85fc8",
+      "value": " 4.98G/4.98G [00:34&lt;00:00, 232MB/s]"
+     }
+    },
+    "c84f542c863043dea8a3675fa153e78d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ButtonModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ButtonModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ButtonView",
+      "button_style": "",
+      "description": "Login",
+      "disabled": false,
+      "icon": "",
+      "layout": "IPY_MODEL_d2d81cc8296c4b10bf80b86c0a3302d3",
+      "style": "IPY_MODEL_7e3a386e672f4748882211227b7721a9",
+      "tooltip": ""
+     }
+    },
+    "c934919f617447cfb9226929e7a68d79": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c27e8ce031884a90b41d8220b1870bc4",
+      "placeholder": "​",
+      "style": "IPY_MODEL_88024cd312ee42c2925ebfbe52077780",
+      "value": " 4/4 [01:41&lt;00:00, 22.30s/it]"
+     }
+    },
+    "cc5ce633746949ed98418cae9f68afe3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "cd11fb7d54bb43ae821f2272d075a1b3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "cd318c6bfc8e421a9bfcdab16be5eaa7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d10ba011d05045b18bbfeb9660e4d9d3",
+      "max": 9846,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_e56c22f77c884caaacfafd48dfa51a55",
+      "value": 9846
+     }
+    },
+    "cf6d1be81b6c4ffc81ce8fdabfc5ad28": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_07e0aed682fd4cc88fa75c0592dc04a7",
+       "IPY_MODEL_67b4473eb8a44a96ba34983762ab38fa",
+       "IPY_MODEL_c7e06fd82f7f4f9fb81c68e8758f2de1"
+      ],
+      "layout": "IPY_MODEL_3d9d8278667d496aaea1eaaa4d24ae93"
+     }
+    },
+    "cffdf12fbe97462ab74e88ccca943aeb": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d10ba011d05045b18bbfeb9660e4d9d3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d1508f5cde9a43d8abc26dd2d0c34dbd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_9a0b012915c54abeb100f466fa99d303",
+       "IPY_MODEL_99529129d7f0435da0fdcfc9803a2f11",
+       "IPY_MODEL_5b56ac3009714a5a84dd8749db4a7bce"
+      ],
+      "layout": "IPY_MODEL_546b76a22f1046cd856a8fa2f9ff2d9f"
+     }
+    },
+    "d1cbe0ab9379453588eb438d13fd272d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "d2d81cc8296c4b10bf80b86c0a3302d3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d3cbfd564fe8485ba7afdb1cc54abed3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "d4092198673141d3b4a824d629d73f64": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d7ef74cf4a914ad38a69c84c34fff393": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_8d0f1d547c384094b10aa00a3ede3c06",
+       "IPY_MODEL_9bdebf06b6874bbb88404f4ad14e1dbc",
+       "IPY_MODEL_a2249f364b914662b54045a1f8d6dfd1"
+      ],
+      "layout": "IPY_MODEL_7504986b8d8d4d0da58ad79e80a81948"
+     }
+    },
+    "db05b25cb38140bdb21e6f3b7fde7e66": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "dcff079d850c423a83eb70105b816ee4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "de3757d6125a4c07b502dd60816bafec": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e0fd6d00f0ba4e59bdaa5779556ec4ea": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7ac8e88f29f04b859f592a003d39836b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_0ec2643d9fd44785addb37d9ecd23989",
+      "value": "Generating train split: 100%"
+     }
+    },
+    "e25f9ca445b14e3f8397779df071dfb4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_791df472db174df69b8c9f0e200af254",
+      "placeholder": "​",
+      "style": "IPY_MODEL_6bb9c7182d2a464ea21809e59043562a",
+      "value": "<center> <img\nsrc=https://huggingface.co/front/assets/huggingface_logo-noborder.svg\nalt='Hugging Face'> <br> Copy a token from <a\nhref=\"https://huggingface.co/settings/tokens\" target=\"_blank\">your Hugging Face\ntokens page</a> and paste it below. <br> Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file. </center>"
+     }
+    },
+    "e297072ab5d64815b90bc89d22503378": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e4e1a4338c5e46b3ba5a3bb960da7107": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e56c22f77c884caaacfafd48dfa51a55": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "e69cd88ccbae4bb7b238fa112a60f0f9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "e92b30d0b4234af6b5a33bff989b1b45": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ea1bdb5f2da64332960bccd967a84b4a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_347540dc03d34e65b7ffbb0f5fc569aa",
+      "placeholder": "​",
+      "style": "IPY_MODEL_7243d8e2e1cc4043a2ee310eabd0ac09",
+      "value": " 177/177 [00:00&lt;00:00, 11.4kB/s]"
+     }
+    },
+    "eadeec171e7b4c0f9e26964f031cfb71": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_de3757d6125a4c07b502dd60816bafec",
+      "placeholder": "​",
+      "style": "IPY_MODEL_8c4d6f4eea3742289a2604e66b0c6182",
+      "value": "tokenizer_config.json: 100%"
+     }
+    },
+    "ec014d847e394a309b6a82c30a6fdfc5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "ede66e196fa9482498f58dcdffd494a2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_026072374b7d47c194707a50f5c99099",
+      "placeholder": "​",
+      "style": "IPY_MODEL_63ac7dafeb27446cb30aaddf4cd27c9f",
+      "value": "Map: 100%"
+     }
+    },
+    "ee4e4af964ec4dd597cb04a90f0697f9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f07c8a6ec12f46ea9e32a2208e70bccd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "f2ab2fa803e94328a237e84cd4ea0027": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5690d92586494b9187147f32fa708405",
+      "max": 1105272,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_317cda72329c4043ab0b224b46b259d3",
+      "value": 1105272
+     }
+    },
+    "f4ca7b63d7d749ff83a848e250f03ec1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f7e59b47f9b74523843f37268212d566": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "f81756eb9e554899b0778311f2c407c4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f86b969ef69b48119619e1a424b50460": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "fbc6a2834c5442fbb6667f1b3612bb5b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "feae525923d5407bb69a922954c474f7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_bac377ed96ae4e8db9b298bb623888ec",
+      "max": 50566,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_02d6cc4c2717434c895798601bda7c86",
+      "value": 50566
+     }
+    },
+    "ffe561df8772443ebf40a3b8b656079f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "fffbf696c07744fc8e3d81ab51dc9c90": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    }
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/examples/dora_finetuning/README.md b/examples/dora_finetuning/README.md
new file mode 100644
index 0000000..2025047
--- /dev/null
+++ b/examples/dora_finetuning/README.md
@@ -0,0 +1,105 @@
+# DoRA: Weight-Decomposed Low-Rank Adaptation
+
+![dora](https://i.ytimg.com/vi/m7KQdGSr0Dg/maxresdefault.jpg)
+
+
+## Introduction
+[DoRA](https://huggingface.co/papers/2402.09353) is a novel approach that leverages low rank adaptation through weight decomposition analysis to investigate the inherent differences between full fine-tuning and LoRA. DoRA initially decomposes the pretrained weight into its magnitude and directional components and finetunes both of them. Because the directional component is large in terms of parameter numbers, we further decompose it with LoRA for efficient finetuning. This results in enhancing both the learning capacity and training stability of LoRA while avoiding any additional inference overhead.
+
+## Quick start
+```python
+import torch
+from peft import LoraConfig, get_peft_model
+from transformers import AutoTokenizer, AutoModelForCausalLM, Trainer
+from datasets import load_dataset
+
+model = AutoModelForCausalLM.from_pretrained("huggyllama/llama-7b", device_map="auto")
+tokenizer = AutoTokenizer.from_pretrained("huggyllama/llama-7b")
+dataset = load_dataset("timdettmers/openassistant-guanaco", split="train")
+lora_config = LoraConfig(
+    use_dora=True
+)
+peft_model = get_peft_model(model, lora_config)
+trainer = transformers.Trainer(
+    model=peft_model,
+    train_dataset=dataset,
+    dataset_text_field="text",
+    max_length=2048,
+    tokenizer=tokenizer,
+)
+trainer.train()
+peft_model.save_pretrained("dora-llama-3-8b")
+```
+
+There is no additional change needed to your standard LoRA procedure, except for specifying `use_dora = True` option in your lora configuration.
+
+
+Run the finetuning script simply by running:
+```bash
+python examples/dora_finetuning/dora_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --data_path timdettmers/openassistant-guanaco
+```
+This 👆🏻 by default will load the model in peft set up with LoRA config. Now if you wanna quickly compare it with Dora, all you need to do is to input ` --use_dora` in the command line. So same above example would be 👇🏻;
+
+```bash
+python examples/dora_finetuning/dora_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --data_path timdettmers/openassistant-guanaco --use_dora 
+```
+
+DoRA also supports quantization. To use 4-bit quantization try:
+
+```bash
+python examples/dora_finetuning/dora_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --quantize
+```
+
+Similarly, by default the LoRA layers are the attention and MLP layers of LLama model, if you get to choose a different set of layers for LoRA to be applied on, you can simply define it using:
+```bash
+python examples/dora_finetuning/dora_finetuning.py --lora_target_modules "q_proj,k_proj,v_proj,o_proj" 
+```
+
+### Full example of the script 
+```bash
+python dora_finetuning.py \
+    --base_model "PATH_TO_MODEL" \
+    --data_path "PATH_TO_DATASET" \
+    --output_dir "PATH_TO_OUTPUT_DIR" \
+    --batch_size 1 \
+    --num_epochs 3 \
+    --learning_rate 3e-4 \
+    --cutoff_len 512 \
+    --val_set_size 500 \
+    --use_dora \
+    --quantize \
+    --eval_step 10 \
+    --save_step 100 \
+    --lora_r 16 \
+    --lora_alpha 32 \
+    --lora_dropout 0.05 \
+    --lora_target_modules "q_proj,k_proj,v_proj,o_proj" \
+    --hub_model_id "YOUR_HF_REPO" \
+    --push_to_hub
+```
+## Use the model on 🤗
+You can load and use the model as any other 🤗 models.
+```python
+from transformers import AutoModel
+model = AutoModel.from_pretrained("ShirinYamani/huggyllama-llama-7b-finetuned")
+```
+
+## DoRA vs. LoRA
+In general, DoRA finetuning on diffusion models is still experimental and is likely to require different hyperparameter values to perform best compared to LoRA.
+
+Specifically, people have noticed 2 differences to take into account in your training:
+
+1. LoRA seem to converge faster than DoRA (so a set of parameters that may lead to overfitting when training a LoRA may be working well for a DoRA)
+
+2. DoRA quality superior to LoRA especially in lower ranks: The difference in quality of DoRA of rank 8 and LoRA of rank 8 appears to be more significant than when training ranks of 32 or 64 for example.
+
+
+## Citation
+```
+@article{liu2024dora,
+  title={DoRA: Weight-Decomposed Low-Rank Adaptation},
+  author={Liu, Shih-Yang and Wang, Chien-Yi and Yin, Hongxu and Molchanov, Pavlo and Wang, Yu-Chiang Frank and Cheng, Kwang-Ting and Chen, Min-Hung},
+  journal={arXiv preprint arXiv:2402.09353},
+  year={2024}
+}
+```
\ No newline at end of file
diff --git a/examples/dora_finetuning/dora-caching.py b/examples/dora_finetuning/dora-caching.py
new file mode 100644
index 0000000..bdcff09
--- /dev/null
+++ b/examples/dora_finetuning/dora-caching.py
@@ -0,0 +1,126 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+"""
+Small script to measure DoRA caching efficiency
+"""
+
+import argparse
+import time
+from contextlib import contextmanager
+
+import torch
+from transformers import AutoModelForCausalLM
+
+from peft import LoraConfig, get_peft_model
+from peft.helpers import DoraCaching
+from peft.utils import infer_device
+
+
+device = infer_device()
+# check for CPU
+if device == "cpu":
+    raise ValueError("This benchmark requires a hardware accelerator, only found CPU")
+torch_accelerator_module = getattr(torch, device, torch.cuda)
+
+
+@contextmanager
+def timeit(logs):
+    start = time.perf_counter()
+    yield
+    end = time.perf_counter()
+    dur = end - start
+    logs["time"].append(dur)
+
+
+def run_benchmark(model, num_runs):
+    logs = {
+        "time": [],
+    }
+
+    mem_start = torch_accelerator_module.max_memory_reserved()
+    for _ in range(num_runs + 1):
+        with timeit(logs):
+            for i in range(3):
+                x = torch.randint(10, 100, (1, 50)).to(device)
+                model(x)
+    mem_end = torch_accelerator_module.max_memory_reserved()
+    logs["memory"] = (mem_end - mem_start) / 1024**2
+
+    # remove the first run (warm up)
+    del logs["time"][0]
+    return logs
+
+
+def main(model_id, num_runs):
+    model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.bfloat16, device_map=device)
+    base_memory = torch_accelerator_module.max_memory_reserved() / 1024**2
+
+    # LORA
+    config = LoraConfig(init_lora_weights=False, use_dora=False)
+    model = get_peft_model(model, config)
+    model.eval()
+    torch_accelerator_module.reset_peak_memory_stats()
+    logs_lora = run_benchmark(model, num_runs)
+    avg_duration_lora = sum(logs_lora["time"]) / num_runs
+    max_memory_lora = logs_lora["memory"] + base_memory
+
+    # DORA
+    del model
+    torch_accelerator_module.empty_cache()
+
+    model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.bfloat16, device_map=device)
+    base_memory = torch_accelerator_module.max_memory_reserved() / 1024**2
+    config = LoraConfig(init_lora_weights=False, use_dora=True)
+    model = get_peft_model(model, config)
+    model.eval()
+
+    # WITHOUT CACHING
+    torch_accelerator_module.reset_peak_memory_stats()
+    logs_dora_no_caching = run_benchmark(model, num_runs)
+    avg_duration_no_caching = sum(logs_dora_no_caching["time"]) / num_runs
+    max_memory_no_caching = logs_dora_no_caching["memory"] + base_memory
+
+    # WITH CACHING
+    torch_accelerator_module.reset_peak_memory_stats()
+    with DoraCaching():
+        logs_dora_caching = run_benchmark(model, num_runs)
+    avg_duration_caching = sum(logs_dora_caching["time"]) / num_runs
+    max_memory_caching = logs_dora_caching["memory"] + base_memory
+
+    print(
+        f"Benchmark results for model {model_id} with {num_runs} runs:\n\n"
+        f"avg time LoRA:                     {avg_duration_lora:.4f} sec\n"
+        f"avg time DoRA no caching:          {avg_duration_no_caching:.4f} sec\n"
+        f"avg time DoRA with caching:        {avg_duration_caching:.4f} sec\n"
+        f"\n"
+        f"memory LoRA:                       {max_memory_lora:.2f} MB\n"
+        f"memory DoRA no caching:            {max_memory_no_caching:.2f} MB\n"
+        f"memory DoRA with caching:          {max_memory_caching:.2f} MB\n"
+        f"\n"
+        f"DoRA time overhead no caching:     {(avg_duration_no_caching - avg_duration_lora) / avg_duration_lora * 100:.2f}%\n"
+        f"DoRA time overhead with caching:   {(avg_duration_caching - avg_duration_lora) / avg_duration_lora * 100:.2f}%\n"
+        f"\n"
+        f"DoRA memory overhead no caching:   {(max_memory_no_caching - max_memory_lora) / max_memory_lora * 100:.2f}%\n"
+        f"DoRA memory overhead with caching: {(max_memory_caching - max_memory_lora) / max_memory_lora * 100:.2f}%"
+    )
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Benchmark DoRA caching efficiency")
+    parser.add_argument("--model_id", type=str, default="meta-llama/Llama-3.1-8B", help="Model ID to benchmark")
+    parser.add_argument("--num_runs", type=int, default=10, help="Number of runs for the benchmark")
+    args = parser.parse_args()
+
+    main(args.model_id, args.num_runs)
diff --git a/examples/dora_finetuning/dora_finetuning.py b/examples/dora_finetuning/dora_finetuning.py
new file mode 100644
index 0000000..c8d281f
--- /dev/null
+++ b/examples/dora_finetuning/dora_finetuning.py
@@ -0,0 +1,208 @@
+import os
+
+import torch
+from datasets import load_dataset
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    BitsAndBytesConfig,
+    DataCollatorForLanguageModeling,
+    Trainer,
+    TrainingArguments,
+)
+
+from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+
+
+def train_model(
+    base_model: str,
+    data_path: str,
+    output_dir: str,
+    batch_size: int,
+    num_epochs: int,
+    learning_rate: float,
+    cutoff_len: int,
+    val_set_size: int,
+    use_dora: bool,
+    quantize: bool,
+    eval_step: int,
+    save_step: int,
+    device: str,
+    lora_r: int,
+    lora_alpha: int,
+    lora_dropout: float,
+    lora_target_modules: str,
+    hub_model_id: str,
+    push_to_hub: bool,
+):
+    os.environ["TOKENIZERS_PARALLELISM"] = "false"
+    hf_token = os.getenv("HF_TOKEN")
+
+    # Setup device
+    if device == "auto":
+        device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+    else:
+        device = torch.device(device)
+    print(f"Using device: {device}")
+
+    # load tokenizer
+    tokenizer = AutoTokenizer.from_pretrained(base_model, token=hf_token)
+
+    # QDoRA (quantized dora): IF YOU WANNA QUANTIZE THE MODEL
+    if quantize:
+        if (torch.cuda.is_available() and torch.cuda.is_bf16_supported()) or torch.xpu.is_available():
+            bnb_4bit_compute_dtype = torch.bfloat16
+        else:
+            bnb_4bit_compute_dtype = torch.float16
+        model = AutoModelForCausalLM.from_pretrained(
+            base_model,
+            token=hf_token,
+            quantization_config=BitsAndBytesConfig(
+                load_in_4bit=True,
+                bnb_4bit_compute_dtype=bnb_4bit_compute_dtype,
+                bnb_4bit_use_double_quant=True,
+                bnb_4bit_quant_type="nf4",
+            ),
+        )
+        # setup for quantized training
+        model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True)
+    else:
+        model = AutoModelForCausalLM.from_pretrained(base_model, token=hf_token)
+    # LoRa config for the PEFT model
+    lora_config = LoraConfig(
+        use_dora=use_dora,  # to use Dora OR compare to Lora just set the --use_dora
+        r=lora_r,  # Rank of matrix
+        lora_alpha=lora_alpha,
+        target_modules=(
+            lora_target_modules.split(",")
+            if lora_target_modules
+            else ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
+        ),
+        lora_dropout=lora_dropout,
+        bias="none",
+    )
+
+    # get the peft model with LoRa config
+    model = get_peft_model(model, lora_config)
+
+    model.to(device)  # MODEL TO GPU/CUDA
+    tokenizer.pad_token = tokenizer.eos_token
+
+    # Load the dataset
+    dataset = load_dataset(data_path)
+
+    def tokenize_function(examples):
+        inputs = tokenizer(examples["text"], padding="max_length", truncation=True, max_length=cutoff_len)
+        inputs["labels"] = inputs["input_ids"].copy()  # setting labels for a language modeling task
+        return inputs
+
+    # Tokenize the dataset and prepare for training
+    tokenized_datasets = dataset.map(tokenize_function, batched=True, remove_columns=dataset["train"].column_names)
+
+    # Data collator to dynamically pad the batched examples
+    data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)
+
+    # Define training arguments
+    training_args = TrainingArguments(
+        output_dir=output_dir,
+        num_train_epochs=num_epochs,
+        per_device_train_batch_size=batch_size,
+        per_device_eval_batch_size=batch_size,
+        warmup_steps=100,
+        weight_decay=0.01,
+        logging_dir="./logs",
+        logging_steps=eval_step,
+        save_steps=save_step,
+        save_total_limit=2,
+        push_to_hub=push_to_hub,
+        hub_model_id=hub_model_id,
+        gradient_accumulation_steps=16,
+        fp16=True,
+        learning_rate=learning_rate,
+        hub_token=hf_token,
+    )
+
+    # Clear device cache to free memory
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+    elif torch.xpu.is_available():
+        torch.xpu.empty_cache()
+
+    # Initialize the Trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=tokenized_datasets["train"],
+        eval_dataset=tokenized_datasets["test"],
+        data_collator=data_collator,
+    )
+
+    # Start model training
+    trainer.train()
+
+    # Save and push the trained model and tokenizer
+    if push_to_hub:
+        # Push the main model to the hub
+        trainer.push_to_hub(commit_message="Fine-tuned model")
+
+    # Save the model and tokenizer locally
+    model.save_pretrained(output_dir)
+    tokenizer.save_pretrained(output_dir)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Fine-tune LLaMA with DoRA and PEFT")
+    parser.add_argument("--base_model", type=str, default="huggyllama/llama-7b", help="Base model path or name")
+    parser.add_argument(
+        "--data_path", type=str, default="timdettmers/openassistant-guanaco", help="Dataset path or name"
+    )
+    parser.add_argument(
+        "--output_dir", type=str, default="path/to/output", help="Output directory for the fine-tuned model"
+    )
+    parser.add_argument("--batch_size", type=int, default=1, help="Batch size")
+    parser.add_argument("--num_epochs", type=int, default=1, help="Number of training epochs")
+    parser.add_argument("--learning_rate", type=float, default=3e-4, help="Learning rate")
+    parser.add_argument("--cutoff_len", type=int, default=512, help="Cutoff length for tokenization")
+    parser.add_argument("--val_set_size", type=int, default=500, help="Validation set size")
+    parser.add_argument("--use_dora", action="store_true", help="Apply Dora")
+    parser.add_argument("--quantize", action="store_true", help="Use quantization")
+    parser.add_argument("--eval_step", type=int, default=10, help="Evaluation step interval")
+    parser.add_argument("--save_step", type=int, default=100, help="Save step interval")
+    parser.add_argument("--device", type=str, default="auto", help="Device to use for training")
+    parser.add_argument("--lora_r", type=int, default=8, help="LoRA rank")
+    parser.add_argument("--lora_alpha", type=int, default=16, help="LoRA alpha")
+    parser.add_argument("--lora_dropout", type=float, default=0.05, help="LoRA dropout rate")
+    parser.add_argument(
+        "--lora_target_modules", type=str, default=None, help="Comma-separated list of target modules for LoRA"
+    )
+    parser.add_argument(
+        "--hub_model_id",
+        type=str,
+        default="path/to/repo",
+        help="Repository name to push the model on the Hugging Face Hub",
+    )
+    parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to Hugging Face Hub")
+    args = parser.parse_args()
+    train_model(
+        base_model=args.base_model,
+        data_path=args.data_path,
+        output_dir=args.output_dir,
+        batch_size=args.batch_size,
+        num_epochs=args.num_epochs,
+        learning_rate=args.learning_rate,
+        cutoff_len=args.cutoff_len,
+        val_set_size=args.val_set_size,
+        use_dora=args.use_dora,
+        quantize=args.quantize,
+        eval_step=args.eval_step,
+        save_step=args.save_step,
+        device=args.device,
+        lora_r=args.lora_r,
+        lora_alpha=args.lora_alpha,
+        lora_dropout=args.lora_dropout,
+        lora_target_modules=args.lora_target_modules,
+        hub_model_id=args.hub_model_id,
+        push_to_hub=args.push_to_hub,
+    )
diff --git a/examples/ephemeral_gpu_offloading/load_with_dora.py b/examples/ephemeral_gpu_offloading/load_with_dora.py
new file mode 100644
index 0000000..cc61925
--- /dev/null
+++ b/examples/ephemeral_gpu_offloading/load_with_dora.py
@@ -0,0 +1,103 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+"""
+Example script demonstrating the time difference loading a model with a DoRA using ephemeral GPU offloading vs doing it purely on the CPU.
+
+Example outputs:
+$ python load_with_dora.py
+--- Loading model ---
+Loading checkpoint shards: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████| 4/4 [00:04<00:00,  1.03s/it]
+--- Loading PeftModel ---
+--- Done ---
+Model loading time: 4.83s
+PeftModel loading time: 28.14s
+Use ephemeral GPU offloading: False
+
+(Note: if this was the first time you ran the script, or if your cache was cleared, the times shown above are invalid, due to the time taken to download the model and DoRA files. Just re-run the script in this case.)
+
+$ python load_with_dora.py --ephemeral_gpu_offload
+--- Loading model ---
+Loading checkpoint shards: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████| 4/4 [00:03<00:00,  1.11it/s]
+--- Loading PeftModel ---
+--- Done ---
+Model loading time: 4.28s
+PeftModel loading time: 16.59s
+Use ephemeral GPU offloading: True
+
+(Note: if this was the first time you ran the script, or if your cache was cleared, the times shown above are invalid, due to the time taken to download the model and DoRA files. Just re-run the script in this case.)
+"""
+
+import argparse
+import time
+
+from huggingface_hub import snapshot_download
+from transformers import AutoModelForCausalLM
+
+from peft import PeftModel
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Load a model with DoRA using ephemeral GPU offloading")
+    parser.add_argument("--model", type=str, default="NousResearch/Hermes-2-Pro-Mistral-7B", help="Model to load")
+    parser.add_argument(
+        "--dora",
+        type=str,
+        default="peft-internal-testing/DoRA-Hermes-2-Pro-Mistral-7B",
+        help="DoRA to use",
+    )
+    parser.add_argument("--ephemeral_gpu_offload", action="store_true", help="Use ephemeral GPU offloading")
+    parser.add_argument(
+        "--merge_model_path", type=str, help="Merge the model with the DoRA model and save to the given path"
+    )
+    args = parser.parse_args()
+
+    peft_model_kwargs = {
+        "ephemeral_gpu_offload": args.ephemeral_gpu_offload,
+        "max_memory": {"cpu": "256GiB"},
+        "device_map": {"": "cpu"},
+    }
+
+    # Predownload
+    try:
+        snapshot_download(repo_id=args.model)
+    except Exception as e:
+        print(f"Failed to download model: {e}")
+        # We continue anyway as this might be e.g. a local directory or something
+    try:
+        snapshot_download(repo_id=args.dora)
+    except Exception as e:
+        print(f"Failed to download DoRA: {e}")
+        # We continue anyway as this might be e.g. a local directory or something
+
+    start = time.perf_counter()
+    print("--- Loading model ---")
+    model = AutoModelForCausalLM.from_pretrained(args.model)
+    model_time = time.perf_counter() - start
+    print("--- Loading PeftModel ---")
+    peft_model = PeftModel.from_pretrained(model, args.dora, **peft_model_kwargs)
+    print("--- Done ---")
+    peft_model_time = time.perf_counter() - start
+
+    print(f"Model loading time: {model_time:.2f}s")
+    print(f"PeftModel loading time: {peft_model_time:.2f}s")
+    print(f"Use ephemeral GPU offloading: {args.ephemeral_gpu_offload}")
+
+    if args.merge_model_path is not None:
+        merged_model = peft_model.merge_and_unload(progressbar=True)
+        merged_model.save_pretrained(args.merge_model_path)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/eva_finetuning/README.md b/examples/eva_finetuning/README.md
new file mode 100644
index 0000000..0435e69
--- /dev/null
+++ b/examples/eva_finetuning/README.md
@@ -0,0 +1,159 @@
+# EVA: Explained Variance Adaptation
+## Introduction ([Paper](https://huggingface.co/papers/2410.07170), [code](https://github.com/ml-jku/EVA))
+Explained Variance Adaptation (EVA) is a novel initialization method for LoRA style adapters which initializes adapter weights in a data driven manner and adaptively allocates ranks according to the variance they explain. EVA improves average performance on a multitude of tasks across various domains, such as Language generation and understanding, Image classification, and Decision Making.
+
+The abstract from the paper is:
+
+*Foundation models (FMs) are pre-trained on large-scale datasets and then fine-tuned on a downstream task for a specific application. The most successful and most commonly used fine-tuning method is to update the pre-trained weights via a low-rank adaptation (LoRA). LoRA introduces new weight matrices that are usually initialized at random with a uniform rank distribution across model weights. Recent works focus on weight-driven initialization or learning of adaptive ranks during training. Both approaches have only been investigated in isolation, resulting in slow convergence or a uniform rank distribution, in turn leading to sub-optimal performance. We propose to enhance LoRA by initializing the new weights in a data-driven manner by computing singular value decomposition on minibatches of activation vectors. Then, we initialize the LoRA matrices with the obtained right-singular vectors and re-distribute ranks among all weight matrices to explain the maximal amount of variance and continue the standard LoRA fine-tuning procedure. This results in our new method **E**xplained **V**ariance **A**daptation (EVA). We apply EVA to a variety of fine-tuning tasks ranging from language generation and understanding to image classification and reinforcement learning. EVA exhibits faster convergence than competitors and attains the highest average score across a multitude of tasks per domain.*
+
+## Quick Start
+Below is an example of how to use EVA with a causal language model. For a more detailed example see [eva_finetuning.py](https://github.com/huggingface/peft/blob/main/examples/eva_finetuning/eva_finetuning.py).
+```python
+import torch
+from datasets import load_dataset
+from torch.utils.data import DataLoader
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from peft import EvaConfig, LoraConfig, get_peft_model, initialize_lora_eva_weights
+
+
+# config
+model_name = "meta-llama/Llama-3.1-8B"
+max_seq_len = 512
+rank = 16
+alpha = 1
+rho = 2.0
+target_modules = ["q_proj", "k_proj", "v_proj", "o_proj"]
+svd_batch_size = 4 # can be different from the batch size used in finetuning
+
+# load model and tokenizer
+model = AutoModelForCausalLM.from_pretrained(model_name)
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+tokenizer.pad_token = tokenizer.eos_token
+
+# load dataset
+dataset = load_dataset("Rowan/hellaswag")
+dataset = dataset.map(
+    lambda x: tokenizer(x["ctx"], padding="max_length", truncation=True, max_length=max_seq_len),
+    batched=True,
+    remove_columns=dataset["train"].column_names,
+)
+dataset.set_format(type="torch")
+
+# create dataloader for SVD
+# typically this is the same as the dataloader used for finetuning
+dataloader = DataLoader(
+    dataset["train"],
+    batch_size=svd_batch_size,
+    collate_fn=lambda examples: {k: torch.stack([v[k] for v in examples], dim=0) for k in examples[0].keys()},
+)
+
+# setup peft config
+eva_config = EvaConfig(
+    rho=rho
+)
+peft_config = LoraConfig(
+    r=rank,
+    lora_alpha=alpha,
+    target_modules=target_modules,
+    init_lora_weights="eva",
+    eva_config=eva_config
+)
+
+# move model to accelerator
+device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+model = model.to(device)
+
+# to optimize memory usage during EVA initialization, set low_cpu_mem_usage=True
+peft_model = get_peft_model(model, peft_config, low_cpu_mem_usage=True)
+
+initialize_lora_eva_weights(peft_model, dataloader)
+```
+`initialize_lora_eva_weights` will compute the SVD and load the components into the model. After this continue with standard LoRA finetuning.
+
+## Using EVA with Bitsandbytes
+EVA is fully compatible with bitsandbytes. Simply initialize the pretrained model with a BitsAndBytesConfig and then use the peft model with EVA.
+```python
+from transformers import BitsAndBytesConfig
+from peft import prepare_model_for_kbit_training
+
+model = AutoModelForCausalLM.from_pretrained(
+    "meta-llama/Llama-3.1-8B",
+    quantization_config=BitsAndBytesConfig(load_in_4bit=True)
+)
+model = prepare_model_for_kbit_training(model)
+peft_model = get_peft_model(model, peft_config)
+initialize_lora_eva_weights(peft_model, dataloader)
+```
+
+## Getting the EVA state_dict without loading the adapter weights
+In some cases you might just want to get the state_dict after EVA initialization without loading the adapter weights. This can be useful for example if:
+- you want to precompute and store the state_dict for different downstream tasks.
+- you need to quantize the model for finetuning but want to perform EVA initialization with model weights in full/half precision.
+- you do not intend to use a peft model for LoRA finetuning.
+- you would like to leverage multiple accelerators for EVA initialization. (At the moment this is not directly supported by `initialize_lora_eva_weights`)
+
+You can do this by calling `get_eva_state_dict` directly (you only need to pass `peft_config` if `model` is not a PeftModel):
+```python
+from peft import get_eva_state_dict
+
+eva_state_dict = get_eva_state_dict(model, dataloader, peft_config)
+```
+Later you can load the state_dict into a `PeftModel` by using the `eva_state_dict` argument in `initialize_lora_eva_weights`:
+```python
+initialize_lora_eva_weights(peft_model, eva_state_dict=eva_state_dict)
+```
+
+## Leveraging multiple accelerators
+
+EVA initialization can be parallelized across multiple accelerators. In this case inputs from multiple accelerators are gathered before computing the SVD for the batch. This requires that the model is wrapped in a `torch.nn.DataParallel` or `torch.nn.DistributedDataParallel` class. An example of how to use this can be found in [eva_finetuning_multi_accelerator.py](https://github.com/huggingface/peft/blob/main/examples/eva_finetuning/eva_finetuning_multi_accelerator.py).
+
+## Customizing EVA
+
+By default, EVA is designed to work with standard transformer language models. However we integrated three different parameters which can be used to customize EVA for other types of models.
+1. `forward_fn`: Defines how the forward pass during EVA initialization should be computed.
+2. `prepare_model_inputs_fn`: Can be used if it is necessary to use information contained in the original model_input to prepare the input for SVD in individual layers.
+3. `prepare_layer_inputs_fn`: Defines how layer inputs should be prepared for SVD.
+
+All three parameters can be passed to `initialize_lora_eva_weights` and `get_eva_state_dict`.
+
+### forward_fn
+
+`forward_fn` defines how the forward pass during EVA initialization should be computed. `forward_fn` receives two arguments: `model` and `inputs`. By default this is set to `forward_fn_dict` which simply returns `model(**inputs)`.
+
+### prepare_model_inputs_fn
+
+`prepare_model_inputs_fn` can be used if it is necessary to use information contained in the original model_input to prepare the input for SVD in individual layers. `prepare_model_inputs_fn` receives two arguments: `model_input` and `peft_config`. This component is separate from `prepare_layer_inputs_fn` as the output only needs to be computed once per batch. By default this parameter is set to `prepare_model_inputs_fn_language_modeling` which is used get a subset of indices based on attention and label mask to avoid including padding tokens in the SVD computation. If you would like to not use this component set `prepare_model_inputs_fn` to None. The default logic is:
+```python
+def prepare_model_inputs_fn_language_modeling(model_input, peft_config: LoraConfig):
+    mask = model_input.get("attention_mask", torch.ones_like(model_input["input_ids"])).bool()
+    if peft_config.eva_config.use_label_mask and hasattr(model_input, "labels"):
+        mask = torch.logical_and(mask, model_input["labels"] != peft_config.eva_config.label_mask_value)
+    return mask.nonzero()
+```
+
+### prepare_layer_inputs_fn
+
+`prepare_layer_inputs_fn` can be used to preprocess the layer inputs before passing them to the SVD algorithm. `prepare_layer_inputs_fn` receives three arguments: `layer_input`, `model_input` and `layer_name`. It can either be a callable or a dictionary where the keys are the layer names and the values are callables. If it is a dictionary, functions are assigned to adapter layers based on the layer names. By default a language modeling setting is assumed where model_inputs are the outputs of `prepare_model_inputs_fn_language_modeling` which is a mask of indices. If this parameter is set to None, only two modifications are made to the layer inputs
+- take the first element in case of a tuple or list. 
+- if the input has more than 2 dimensions, we flatten all but the last dimension.
+
+Must always return a tensor. The default logic is:
+```python
+def prepare_layer_inputs_fn_default(layer_input, model_input, layer_name) -> torch.Tensor:
+    if isinstance(layer_input, (tuple, list)):
+        layer_input = layer_input[0]
+    return layer_input[model_input.T.unbind()]
+```
+
+## Citation
+In case you find our work useful, please consider citing it.
+
+```	
+@article{paischer2024eva,
+    title={One Initialization to Rule them All: Fine-tuning via Explained Variance Adaptation}, 
+    author={Fabian Paischer, Lukas Hauzenberger, Thomas Schmied, Benedikt Alkin, Marc Peter Deisenroth, Sepp Hochreiter},
+    journal={arXiv preprint arXiv:2410.07170},
+    year={2024}
+}
+```
diff --git a/examples/eva_finetuning/eva_finetuning.py b/examples/eva_finetuning/eva_finetuning.py
new file mode 100644
index 0000000..4901770
--- /dev/null
+++ b/examples/eva_finetuning/eva_finetuning.py
@@ -0,0 +1,96 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+import torch
+from datasets import load_dataset
+from torch.utils.data import DataLoader
+from transformers import AutoModelForCausalLM, AutoTokenizer, Trainer, TrainingArguments
+from utils import DataCollator, TokenizerMetaMath
+
+from peft import EvaConfig, LoraConfig, get_peft_model, initialize_lora_eva_weights
+
+
+DEVICE = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+
+# config
+model_name = "meta-llama/Llama-3.1-8B"
+max_seq_len = 512
+rank = 16
+alpha = 1
+rho = 2.0
+target_modules = ["q_proj", "k_proj", "v_proj", "o_proj"]
+svd_batch_size = 4  # can be different from the batch size used in finetuning
+batch_size = 4
+learning_rate = 5e-4
+gradient_accumulation_steps = 8
+num_epochs = 1
+output_dir = "outputs"
+bf16 = True
+
+
+# load model and tokenizer
+model = AutoModelForCausalLM.from_pretrained(model_name)
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+
+# load dataset
+dataset = load_dataset("meta-math/MetaMathQA")
+dataset = dataset.map(
+    TokenizerMetaMath(model_name),
+    batched=True,
+    remove_columns=dataset["train"].column_names,
+)
+dataset.set_format(type="torch")
+
+# data collator
+data_collator = DataCollator(tokenizer.eos_token_id, max_length=max_seq_len)
+
+# dataloader
+dataloader = DataLoader(
+    dataset["train"],
+    batch_size=svd_batch_size,
+    collate_fn=data_collator,
+)
+
+# setup peft config
+eva_config = EvaConfig(rho=rho)
+peft_config = LoraConfig(
+    r=rank, lora_alpha=alpha, target_modules=target_modules, init_lora_weights="eva", eva_config=eva_config
+)
+
+# move model to accelerator
+model = model.to(DEVICE)
+
+# to optimize memory usage during eva initialization, set low_cpu_mem_usage=True
+peft_model = get_peft_model(model, peft_config, low_cpu_mem_usage=True)
+initialize_lora_eva_weights(peft_model, dataloader)
+
+# setup training arguments
+training_args = TrainingArguments(
+    per_device_train_batch_size=batch_size,
+    learning_rate=learning_rate,
+    gradient_accumulation_steps=gradient_accumulation_steps,
+    num_train_epochs=num_epochs,
+    output_dir=output_dir,
+    remove_unused_columns=False,
+    bf16=bf16,
+)
+
+# continue with standard finetuning
+trainer = Trainer(
+    model=peft_model,
+    args=training_args,
+    train_dataset=dataset["train"],
+    data_collator=data_collator,
+)
+trainer.train()
diff --git a/examples/eva_finetuning/eva_finetuning_multi_accelerator.py b/examples/eva_finetuning/eva_finetuning_multi_accelerator.py
new file mode 100644
index 0000000..8a77eb6
--- /dev/null
+++ b/examples/eva_finetuning/eva_finetuning_multi_accelerator.py
@@ -0,0 +1,132 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+import os
+
+import torch
+import torch.distributed as dist
+from datasets import load_dataset
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.utils.data import DataLoader
+from torch.utils.data.distributed import DistributedSampler
+from transformers import AutoModelForCausalLM, AutoTokenizer, Trainer, TrainingArguments
+from utils import DataCollator, TokenizerMetaMath
+
+from peft import EvaConfig, LoraConfig, get_eva_state_dict, get_peft_model, initialize_lora_eva_weights
+
+
+# run this script e.g. with: torchrun --nproc_per_node=4 eva_finetuning_multi_gpu.py
+
+# config
+model_name = "meta-llama/Llama-2-7b-hf"
+max_seq_len = 512
+rank = 16
+alpha = 1
+rho = 2.0
+target_modules = ["q_proj", "k_proj", "v_proj", "o_proj"]
+svd_batch_size = 4  # can be different from the batch size used in finetuning
+batch_size = 4
+learning_rate = 5e-4
+gradient_accumulation_steps = 8
+num_epochs = 1
+output_dir = "outputs"
+bf16 = True
+
+
+# Initialize distributed environment
+if torch.cuda.is_available():
+    local_rank = int(os.environ.get("LOCAL_RANK", "-1"))
+    torch.cuda.set_device(local_rank)
+    dist.init_process_group("nccl")
+    world_size = dist.get_world_size()
+elif torch.xpu.is_available():
+    local_rank = int(os.environ.get("LOCAL_RANK", "-1"))
+    torch.xpu.set_device(local_rank)
+    dist.init_process_group("xccl")
+    world_size = dist.get_world_size()
+else:
+    local_rank = -1
+    world_size = 1
+
+
+# load model and tokenizer
+model = AutoModelForCausalLM.from_pretrained(model_name)
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+
+# load dataset
+dataset = load_dataset("meta-math/MetaMathQA")
+dataset = dataset.map(
+    TokenizerMetaMath(model_name),
+    batched=True,
+    remove_columns=dataset["train"].column_names,
+)
+dataset.set_format(type="torch")
+
+# data collator
+data_collator = DataCollator(tokenizer.eos_token_id, max_length=max_seq_len)
+
+# Create sampler for distributed training
+sampler = DistributedSampler(dataset["train"], num_replicas=world_size, rank=local_rank)
+
+# dataloader
+dataloader = DataLoader(
+    dataset["train"],
+    batch_size=svd_batch_size,
+    collate_fn=data_collator,
+    sampler=sampler,
+    shuffle=False,
+)
+
+sampler.set_epoch(0)
+
+# Wrap model in DDP
+model = model.to(local_rank)
+model = DDP(model, device_ids=[local_rank], output_device=local_rank)
+
+# setup peft config
+eva_config = EvaConfig(rho=rho)
+peft_config = LoraConfig(
+    r=rank, lora_alpha=alpha, target_modules=target_modules, init_lora_weights="eva", eva_config=eva_config
+)
+
+# EVA initialization
+eva_state_dict = get_eva_state_dict(model, dataloader, peft_config)
+eva_state_dict = {".".join(["base_model.model"] + k.split(".")[1:]): v for k, v in eva_state_dict.items()}
+
+# cleanup ddp
+model = model.module
+
+# initialize peft model
+peft_model = get_peft_model(model, peft_config, low_cpu_mem_usage=True)
+initialize_lora_eva_weights(peft_model, eva_state_dict=eva_state_dict)
+
+# setup training arguments
+training_args = TrainingArguments(
+    per_device_train_batch_size=batch_size,
+    learning_rate=learning_rate,
+    gradient_accumulation_steps=gradient_accumulation_steps,
+    num_train_epochs=num_epochs,
+    output_dir=output_dir,
+    remove_unused_columns=False,
+    bf16=bf16,
+)
+
+# continue with standard finetuning
+trainer = Trainer(
+    model=peft_model,
+    args=training_args,
+    train_dataset=dataset["train"],
+    data_collator=data_collator,
+)
+trainer.train()
diff --git a/examples/eva_finetuning/utils.py b/examples/eva_finetuning/utils.py
new file mode 100644
index 0000000..df7f069
--- /dev/null
+++ b/examples/eva_finetuning/utils.py
@@ -0,0 +1,76 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+import torch
+from transformers import AutoTokenizer
+
+
+class TokenizerMetaMath:
+    PROMPT_NO_INPUT = (
+        "Below is an instruction that describes a task. Write a response that appropriately completes the request.\n\n"
+        "### Instruction:\n{query}\n\n### Response: "
+    )
+    PROMPT = (
+        "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"
+        "### Instruction:\n{query}\n\n### Input:\n{input}\n\n### Response: "
+    )
+
+    def format_prompt(self, query):
+        query = query.split("\n", 1)
+        if len(query) == 1 or query[1].strip("\n") == "":
+            return self.PROMPT_NO_INPUT.format(query=query[0])
+        else:
+            return self.PROMPT.format(query=query[0], input=query[1])
+
+    def __init__(self, tokenizer_path):
+        self.tokenizer = AutoTokenizer.from_pretrained(tokenizer_path)
+
+    def __call__(self, examples):
+        prompts = [self.format_prompt(text) for text in examples["query"]]
+        completions = examples["response"]
+        return self._tokenize_fn(prompts, completions)
+
+    def _tokenize_fn(self, prompts, completions):
+        prompt_tokens = self.tokenizer(prompts, add_special_tokens=False)["input_ids"]
+        input_tokens = self.tokenizer([x + y for x, y in zip(prompts, completions)], add_special_tokens=False)[
+            "input_ids"
+        ]
+        input_tokens = [[self.tokenizer.bos_token_id] + x + [self.tokenizer.eos_token_id] for x in input_tokens]
+        prompt_length = [len(x) + 1 for x in prompt_tokens]  # +1 for the bos token
+        input_length = [len(x) for x in input_tokens]
+        return {"input_ids": input_tokens, "prompt_length": prompt_length, "input_length": input_length}
+
+
+class DataCollator:
+    def __init__(self, eos_token_id, max_length=None):
+        self.eos_token_id = eos_token_id
+        self.max_length = max_length
+
+    def __call__(self, batch):
+        batch = {k: [item[k] for item in batch] for k in batch[0]}
+        input_lengths = torch.stack(batch["input_length"])
+        prompt_lengths = torch.stack(batch["prompt_length"])
+        input_ids = torch.nn.utils.rnn.pad_sequence(
+            batch["input_ids"], batch_first=True, padding_value=self.eos_token_id
+        )
+        col_indices = torch.arange(input_ids.size(1)).unsqueeze(0)
+        attention_mask = col_indices < input_lengths.unsqueeze(1)
+        label_mask = torch.logical_or(col_indices < prompt_lengths.unsqueeze(1), ~attention_mask)
+        labels = input_ids.masked_fill(label_mask, -100)
+        if self.max_length is not None:
+            input_ids = input_ids[:, : self.max_length]
+            attention_mask = attention_mask[:, : self.max_length]
+            labels = labels[:, : self.max_length]
+        return {"input_ids": input_ids, "attention_mask": attention_mask, "labels": labels}
diff --git a/examples/evaluation/lora-lm-eval.ipynb b/examples/evaluation/lora-lm-eval.ipynb
new file mode 100644
index 0000000..253c6da
--- /dev/null
+++ b/examples/evaluation/lora-lm-eval.ipynb
@@ -0,0 +1,4252 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "qAkXdLL2D25p"
+   },
+   "source": [
+    "## Peft model evaluation using [lm-eval-harness](https://github.com/EleutherAI/lm-evaluation-harness)\n",
+    "\n",
+    "In this notebook, we are going to learn how to evaluate the finetuned lora model on the hellaswag task using lm-eval-harness toolkit."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "o52TJHcYD25q",
+    "outputId": "c5482c79-ff56-4ffa-d20c-46c3d30d2cd5"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[33m  DEPRECATION: Building 'rouge-score' using the legacy setup.py bdist_wheel mechanism, which will be removed in a future version. pip 25.3 will enforce this behaviour change. A possible replacement is to use the standardized build interface by setting the `--use-pep517` option, (possibly combined with `--no-build-isolation`), or adding a `pyproject.toml` file to the source tree of 'rouge-score'. Discussion can be found at https://github.com/pypa/pip/issues/6334\u001b[0m\u001b[33m\n",
+      "\u001b[0m\u001b[33m  DEPRECATION: Building 'sqlitedict' using the legacy setup.py bdist_wheel mechanism, which will be removed in a future version. pip 25.3 will enforce this behaviour change. A possible replacement is to use the standardized build interface by setting the `--use-pep517` option, (possibly combined with `--no-build-isolation`), or adding a `pyproject.toml` file to the source tree of 'sqlitedict'. Discussion can be found at https://github.com/pypa/pip/issues/6334\u001b[0m\u001b[33m\n",
+      "\u001b[0m\u001b[33m  DEPRECATION: Building 'word2number' using the legacy setup.py bdist_wheel mechanism, which will be removed in a future version. pip 25.3 will enforce this behaviour change. A possible replacement is to use the standardized build interface by setting the `--use-pep517` option, (possibly combined with `--no-build-isolation`), or adding a `pyproject.toml` file to the source tree of 'word2number'. Discussion can be found at https://github.com/pypa/pip/issues/6334\u001b[0m\u001b[33m\n",
+      "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager, possibly rendering your system unusable. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv. Use the --root-user-action option if you know what you are doing and want to suppress this warning.\u001b[0m\u001b[33m\n",
+      "\u001b[0m\n",
+      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m25.1.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m25.2\u001b[0m\n",
+      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpython3 -m pip install --upgrade pip\u001b[0m\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Install LM-Eval\n",
+    "!pip install -q datasets evaluate lm_eval"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "uhUflrJXD25q"
+   },
+   "source": [
+    "### First we will check the accuracy score on the hellaswag task for the base bert without finetuning"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "hwJIYD5KD25q",
+    "outputId": "51e69f81-d048-46b2-9699-658d3ffc5f08"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "If you want to use `BertLMHeadModel` as a standalone, add `is_decoder=True.`\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "7b1ea8948a0747bc98795d6459270044",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "README.md: 0.00B [00:00, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "4ec51e06812446899b66826c41697f8d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "data/train-00000-of-00001.parquet:   0%|          | 0.00/24.4M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "fbd73be60e5a4bc68d1347504a6b7070",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "data/test-00000-of-00001.parquet:   0%|          | 0.00/6.11M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "0c887d06a56a410eae563e11a3080a52",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "data/validation-00000-of-00001.parquet:   0%|          | 0.00/6.32M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "adb9c60c23f74f7d9af72ea2e34bc22c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Generating train split:   0%|          | 0/39905 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b3418259aeaf4d459d5ed4fe9b8434fc",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Generating test split:   0%|          | 0/10003 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "da448b2a7a534fec9045c086fbda5d0d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Generating validation split:   0%|          | 0/10042 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "83f04bb57ab94be58080e8c67675a4e5",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map:   0%|          | 0/39905 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f08ebbc81eaa45818c85e51169ac48cf",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map:   0%|          | 0/10042 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████| 10042/10042 [00:02<00:00, 4111.19it/s]\n",
+      "Running loglikelihood requests:   0%|                                                                           | 0/40168 [00:00<?, ?it/s]We strongly recommend passing in an `attention_mask` since your input_ids may be padded. See https://huggingface.co/docs/transformers/troubleshooting#incorrect-output-when-padding-tokens-arent-masked.\n",
+      "Running loglikelihood requests: 100%|██████████████████████████████████████████████████████████████| 40168/40168 [02:40<00:00, 250.28it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'hellaswag': {'alias': 'hellaswag',\n",
+       "  'acc,none': 0.24915355506871142,\n",
+       "  'acc_stderr,none': 0.004316389476434537,\n",
+       "  'acc_norm,none': 0.244672376020713,\n",
+       "  'acc_norm_stderr,none': 0.004290142029921662}}"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "import lm_eval\n",
+    "\n",
+    "\n",
+    "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "output = lm_eval.simple_evaluate(model = 'hf',\n",
+    "                        model_args = {\n",
+    "                            'pretrained' : 'bert-base-cased',\n",
+    "                            'dtype' : 'bfloat16'},\n",
+    "                        tasks = 'hellaswag',\n",
+    "                        device = device,\n",
+    "                        batch_size = 128,\n",
+    "                        log_samples = False)\n",
+    "output[\"results\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "EZk-1JT7D25r"
+   },
+   "source": [
+    "### Now lets try to finetune the bert on the imdb dataset (this is for demonstration and finetuning on imdb may not increase the scores on hellaswag task)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "id": "FmtVeh7QD25r"
+   },
+   "outputs": [],
+   "source": [
+    "# Import necessary libraries\n",
+    "import evaluate\n",
+    "import numpy as np\n",
+    "from datasets import load_dataset\n",
+    "from transformers import AutoTokenizer, BertForSequenceClassification, Trainer, TrainingArguments\n",
+    "\n",
+    "from peft import LoraConfig, TaskType, get_peft_model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "rHF7tzN9D25r",
+    "outputId": "352ad9ab-2efc-41f8-c3d5-a7da05d9529b"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Some weights of BertForSequenceClassification were not initialized from the model checkpoint at bert-base-cased and are newly initialized: ['classifier.bias', 'classifier.weight']\n",
+      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n",
+      "The 8-bit optimizer is not available on your device, only available on CUDA for now.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "trainable params: 296,450 || all params: 108,608,260 || trainable%: 0.2730\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Configure LoRA for Sequence Classification\n",
+    "lora_config = LoraConfig(\n",
+    "    task_type=TaskType.SEQ_CLS,        # Set task type to sequence classification\n",
+    "    target_modules=[\"query\", \"key\"]    # Specify target modules for LoRA tuning\n",
+    ")\n",
+    "\n",
+    "# Initialize the BERT model for sequence classification\n",
+    "model = BertForSequenceClassification.from_pretrained(\n",
+    "    'bert-base-cased',\n",
+    "    num_labels = 2\n",
+    ")\n",
+    "\n",
+    "# Wrap the model with LoRA configuration\n",
+    "model = get_peft_model(model, lora_config)\n",
+    "\n",
+    "model.print_trainable_parameters()\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(\"bert-base-cased\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 337,
+     "referenced_widgets": [
+      "ebf724c3ad1443e98763dd279e6fc996",
+      "9b4b309603db4847a0d94da76db15116",
+      "93dd1cc84f26479caaa1ded80bbea5ff",
+      "0dc109378f1c43a7b18b1be03cce32ce",
+      "2d2adb2b7a3b41d28736a8b7aba258b1",
+      "568c0efe6ced432d81f45af4acaa921e",
+      "f402e8e510d64d0ca4d4ae2c09a7ddfc",
+      "b3cde05a07b2437b935083d6aac25913",
+      "31bad1f4c7c047a280d490b854a6e911",
+      "db789da312a24fc9944ecb8b617109e7",
+      "0bee940b8667495f9e685f7ba6c3706f",
+      "3142f29a154c4a33a161237d4c605c50",
+      "9b39cdb9f7a14ab4865f360f3c1537dc",
+      "798c00bf640e483cbc4fea744b268461",
+      "1882e91f0b264cbeb90b99a69c7de7f5",
+      "17c7d8bb89184c26966a33dc27ef5517",
+      "55cab288802d49efb930c7641b036f44",
+      "0649702ad9764ad8bf3dfbaa6739686e",
+      "d406b18b855d488cac92b9b96073ba43",
+      "eee89779493748d38c01bb0a74b29e38",
+      "8e862faf12804eaebfd7692db348842b",
+      "7812641b79ae46d48bc88b4c773344c0",
+      "806a2b3f4c4c4ba59370a46c0f8faa85",
+      "38fd040b3a0d44d2adf13c2476f4505a",
+      "3a99edeb7d5e43048fdce29b880c19a5",
+      "1dfc470241c44ce1a0f9ae71fdfdbdf6",
+      "feb83525a43a4c2d818f3ef1ae69d581",
+      "a9548c2f9fd54f73abc3e9c3c0bc9fda",
+      "faa9b111dd9745a29bf7494b95619a1b",
+      "81eef7f1d0c7461cb443b996a5d5163f",
+      "b832fdc7655b4f88a15e19fc8381db47",
+      "da7f0a799616427ba7e93b0080d26d37",
+      "9931cc064e2c400e9830e448c8ef4655",
+      "4fe02a8771814e22b8d954cfdd8b9f86",
+      "d52e5c49b80348fbb55ab39ce0a13f7e",
+      "51f4dabc59d04f0c89128d41d4c184a1",
+      "803fcea81b7b47fb91fb108e2170fa75",
+      "ee5722120e1045e985e5e4ca29a2e192",
+      "8fcd7e9ed5f54287b5cda0ad52a277f4",
+      "10335d3ada7f428588c4faa3f57bbd51",
+      "3d6b95a9f8774341be1976f10fb74679",
+      "3ec913f1b93d4097ad9729156295f9e9",
+      "b29cde97f90f4c489c5cdfd007c96d4f",
+      "d8c8ee9f63b14182a9ded152435c510f",
+      "15dc2c4e42ab48c9ad09aafff29f9278",
+      "1fea1738e9fe48629b09e2ec9351fcd2",
+      "2e2fc856557e40df8400e4b69f7143fc",
+      "bce88474ca6745da99d79bc07216333c",
+      "99bab394a68140f79def33bc6f6499b2",
+      "60695bb251124317a897a6fc56b754ac",
+      "d0582455fe3c449dbde19a47561770b4",
+      "92b9e59f9038485e839598237ec3fd8c",
+      "d69df0074246435f8481fd803863cdb1",
+      "3cc5521074d3411cbc24d0348d3fc314",
+      "4c55b2c1daa4497abf9c9f53e23f83b8",
+      "f4d35fb98b0048ca8bdbe856d182d561",
+      "e85940da7bc24b8bb29ce609ba6e5613",
+      "34f8bcc1d9954fb8ba8ecca7a6bd04cd",
+      "7f78e58f4e9c457a9c2d121759efdb09",
+      "2d46765961fe453597645a0b56a9cbc7",
+      "4f7b2a1359bf41cab2ed5663643509a6",
+      "db1b2639fc4944bcbbdfbdaf9150409f",
+      "336ffca0a89e4255a62564ec2600318c",
+      "2bbd92cebbf445d087bcadf82625c6d5",
+      "f1574df0debf4e1b8617e24ffcc39e16",
+      "a9cbf2bbb1f14894886617ce8e60de12",
+      "fdd4b9937b7744d98ba1163efbe1310b",
+      "7823f9d79e1d4350b385e6dfef84b021",
+      "20cd23dc1cd840c89741957f3fcbfdb8",
+      "1c07d8f701604da0989d5f8d88d4bbcd",
+      "00a9858d90d6430eaab54f9e013f077b",
+      "c006e4b791204d10a9d8e7fbc4bceb81",
+      "31664fd452bb43e3aefb87542c747b74",
+      "16afa8cf9ca64a59afd7a4c4f293b479",
+      "4a025adc548b4fcb8c5637f8f6dabc81",
+      "f8d90231390a4211b698e700a66fcb0f",
+      "aa7697dbb00641f19491f13b1a643197",
+      "2d76c76bc4a6433b8fe2b28a1c887ada",
+      "31aa04d4f32a411293f2f729889984b8",
+      "87de47c8821f423d9efc5c7e85297e32",
+      "5f0dfd26cb484695b85d021a5d687503",
+      "d1414b66bc0f4a088c5e4551e8f4ee72",
+      "da58efd0f2b5442c8a284a948f2614f8",
+      "2cd718fb166641d59c8df64cbc637d9c",
+      "2be4c676b5834100b31d7f42ab8bab85",
+      "6eea630bd65745739ff646fbb172f426",
+      "b1c37874948c459583a9f33dc77a6f55",
+      "24cbed7481774ef793a8f204ba5b604b",
+      "716d24b9c1b340a2bf9045b0bf4e7e34",
+      "47789088bcfa4c96a5fd898812c23d17",
+      "580a3b71b23f4a72be9e8633c04e9276",
+      "03f7cfca9e634cf69e3cc70f24832ba3",
+      "987a633e24594228b82e162397a63141",
+      "8ac5b5baeefb4078a74d8c8b2fed6d93",
+      "4bbb4bf49e50489abc875881958c00aa",
+      "5b346ce1eaf649d195fa7dd6058dd196",
+      "d7b4684e53d445e58de1fe155315e093",
+      "886443acd2f14cff93059c093f98cc1b",
+      "24abe5089abc4ecfab75f7601bc98e68",
+      "122d7dd4d02d4df0b6573e100b5e46e3",
+      "db0b4bb4c7a642fb9e8d5c7738e90afc",
+      "f8b71d5cb37549fba6559e2d83531319",
+      "30d18e09421b42c985904750e68740d1",
+      "f67b5bbf7ccb475abe41e08316dc5b37",
+      "e0e6445a2a774ae89729b7e2fb4a14b3",
+      "fdd99c599f9c4ac88c09939ec397ca46",
+      "5ce04c799bb0430386e39af4734e80e6",
+      "404088a4057546968f4e8cfc9e7461e1",
+      "71a7cf52600f4288bd725b7bb93e7299",
+      "e3082a5e8a4144f5982ad478d9a54a2c"
+     ]
+    },
+    "id": "8cZUKSQLD25r",
+    "outputId": "0c0120e6-28f0-4496-a395-6d48d1b159e5"
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ca48589e7f2f46b49b0c6f0f643cbcc8",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "README.md: 0.00B [00:00, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "0ea02d82b14141c0a0237e8036404c84",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "train-00000-of-00001.parquet:   0%|          | 0.00/21.0M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c26d8db5c6ac402aa0d1042df7c10858",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "test-00000-of-00001.parquet:   0%|          | 0.00/20.5M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a6b57f45ca0e46edb407d7763e7cc141",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "unsupervised-00000-of-00001.parquet:   0%|          | 0.00/42.0M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2cb938dfb23240a9b5e2a85c3e6796a6",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Generating train split:   0%|          | 0/25000 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "7e1d3d3c1e414338b44e886a0ed29b8b",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Generating test split:   0%|          | 0/25000 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c6147cbc8124478ea9eb921a2789d20e",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Generating unsupervised split:   0%|          | 0/50000 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ed1329e2506a48b7b30f05a3ded2c230",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map:   0%|          | 0/25000 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "1c6d66613cfc44d391d9a8bb3c58e732",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map:   0%|          | 0/25000 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "26681307716846d68eca88409b126248",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map:   0%|          | 0/50000 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# load the dataset\n",
+    "dataset = load_dataset(\"imdb\")\n",
+    "\n",
+    "def tokenize_function(row):\n",
+    "    return tokenizer(row[\"text\"], padding=\"max_length\", truncation = True)\n",
+    "\n",
+    "tokenized_datasets = dataset.map(tokenize_function, batched = True)\n",
+    "\n",
+    "train_dataset = tokenized_datasets[\"train\"]\n",
+    "eval_dataset = tokenized_datasets[\"test\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "id": "bA3k0iVED25r"
+   },
+   "outputs": [],
+   "source": [
+    "# Define a function to compute evaluation metrics\n",
+    "\n",
+    "def compute_metrics(eval_pred):\n",
+    "    logits, labels = eval_pred\n",
+    "    predictions = np.argmax(logits, axis=-1)\n",
+    "    metric = evaluate.load(\"accuracy\")\n",
+    "    return metric.compute(predictions = predictions, references = labels)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 380
+    },
+    "id": "DFG74c3kD25s",
+    "outputId": "5dd9f988-95db-4efb-e632-5f741801910a"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "No label_names provided for model class `PeftModelForSequenceClassification`. Since `PeftModel` hides base models input arguments, if label_names is not given, label_names can't be set automatically within `Trainer`. Note that empty label_names list will be used instead.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "    <div>\n",
+       "      \n",
+       "      <progress value='3910' max='3910' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
+       "      [3910/3910 40:13, Epoch 5/5]\n",
+       "    </div>\n",
+       "    <table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       " <tr style=\"text-align: left;\">\n",
+       "      <th>Epoch</th>\n",
+       "      <th>Training Loss</th>\n",
+       "      <th>Validation Loss</th>\n",
+       "      <th>Accuracy</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <td>1</td>\n",
+       "      <td>0.353800</td>\n",
+       "      <td>0.261258</td>\n",
+       "      <td>0.901160</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>2</td>\n",
+       "      <td>0.277400</td>\n",
+       "      <td>0.221651</td>\n",
+       "      <td>0.912480</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>3</td>\n",
+       "      <td>0.244500</td>\n",
+       "      <td>0.216107</td>\n",
+       "      <td>0.918200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>4</td>\n",
+       "      <td>0.197000</td>\n",
+       "      <td>0.215257</td>\n",
+       "      <td>0.920040</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>5</td>\n",
+       "      <td>0.157700</td>\n",
+       "      <td>0.215050</td>\n",
+       "      <td>0.923240</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table><p>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "7298a140779d4fd88a65a191af265821",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading builder script: 0.00B [00:00, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "3c6b99b4b5854527a8b34b92a8d2986b",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading builder script: 0.00B [00:00, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "TrainOutput(global_step=3910, training_loss=0.24082870385835847, metrics={'train_runtime': 2416.0772, 'train_samples_per_second': 51.737, 'train_steps_per_second': 1.618, 'total_flos': 3.300271872e+16, 'train_loss': 0.24082870385835847, 'epoch': 5.0})"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Configure training arguments\n",
+    "training_args = TrainingArguments(\"bert-lora-imdb\",\n",
+    "    eval_strategy=\"epoch\",\n",
+    "    per_device_train_batch_size=32, # decrease this for OOM error\n",
+    "    per_device_eval_batch_size=64,\n",
+    "    save_strategy=\"epoch\",\n",
+    "    learning_rate=2e-3,\n",
+    "    num_train_epochs=5,\n",
+    "    weight_decay=0.01,\n",
+    "    load_best_model_at_end=True,\n",
+    "    do_eval=True,\n",
+    "    do_predict=True,\n",
+    "    metric_for_best_model=\"accuracy\",\n",
+    "    report_to=\"none\")\n",
+    "\n",
+    "# Initialize the Trainer for the model training loop\n",
+    "trainer = Trainer(\n",
+    "    model=model,\n",
+    "    args=training_args,\n",
+    "    train_dataset=train_dataset,\n",
+    "    eval_dataset=eval_dataset,\n",
+    "    compute_metrics=compute_metrics,\n",
+    ")\n",
+    "\n",
+    "#start training\n",
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "34h3g_eED25s"
+   },
+   "source": [
+    "### Now take the finetuned lora checkpoint and check the accuracy score on hellaswag task."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "7tgAq7nLD25s"
+   },
+   "outputs": [],
+   "source": [
+    "# use the path of your checkpoint here\n",
+    "output = lm_eval.simple_evaluate(model = 'hf',\n",
+    "                        model_args = {\n",
+    "                          'pretrained' : 'bert-base-cased',\n",
+    "                          'peft' : './bert-lora-imdb/checkpoint-3910',\n",
+    "                          'dtype' : 'bfloat16'},\n",
+    "                        tasks = 'hellaswag',\n",
+    "                        device = device,\n",
+    "                        batch_size = 128,\n",
+    "                        log_samples = False)\n",
+    "\n",
+    "output[\"results\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "gpuType": "T4",
+   "provenance": []
+  },
+  "kaggle": {
+   "accelerator": "nvidiaTeslaT4",
+   "dataSources": [],
+   "dockerImageVersionId": 30787,
+   "isGpuEnabled": true,
+   "isInternetEnabled": true,
+   "language": "python",
+   "sourceType": "notebook"
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  },
+  "widgets": {
+   "application/vnd.jupyter.widget-state+json": {
+    "00a9858d90d6430eaab54f9e013f077b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "03f7cfca9e634cf69e3cc70f24832ba3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_886443acd2f14cff93059c093f98cc1b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_24abe5089abc4ecfab75f7601bc98e68",
+      "value": " 25000/25000 [00:25&lt;00:00, 1037.33 examples/s]"
+     }
+    },
+    "0649702ad9764ad8bf3dfbaa6739686e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "0bee940b8667495f9e685f7ba6c3706f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "0dc109378f1c43a7b18b1be03cce32ce": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_db789da312a24fc9944ecb8b617109e7",
+      "placeholder": "​",
+      "style": "IPY_MODEL_0bee940b8667495f9e685f7ba6c3706f",
+      "value": " 7.81k/7.81k [00:00&lt;00:00, 580kB/s]"
+     }
+    },
+    "10335d3ada7f428588c4faa3f57bbd51": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "122d7dd4d02d4df0b6573e100b5e46e3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_db0b4bb4c7a642fb9e8d5c7738e90afc",
+       "IPY_MODEL_f8b71d5cb37549fba6559e2d83531319",
+       "IPY_MODEL_30d18e09421b42c985904750e68740d1"
+      ],
+      "layout": "IPY_MODEL_f67b5bbf7ccb475abe41e08316dc5b37"
+     }
+    },
+    "15dc2c4e42ab48c9ad09aafff29f9278": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_1fea1738e9fe48629b09e2ec9351fcd2",
+       "IPY_MODEL_2e2fc856557e40df8400e4b69f7143fc",
+       "IPY_MODEL_bce88474ca6745da99d79bc07216333c"
+      ],
+      "layout": "IPY_MODEL_99bab394a68140f79def33bc6f6499b2"
+     }
+    },
+    "16afa8cf9ca64a59afd7a4c4f293b479": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "17c7d8bb89184c26966a33dc27ef5517": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1882e91f0b264cbeb90b99a69c7de7f5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8e862faf12804eaebfd7692db348842b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_7812641b79ae46d48bc88b4c773344c0",
+      "value": " 21.0M/21.0M [00:00&lt;00:00, 189MB/s]"
+     }
+    },
+    "1c07d8f701604da0989d5f8d88d4bbcd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f8d90231390a4211b698e700a66fcb0f",
+      "placeholder": "​",
+      "style": "IPY_MODEL_aa7697dbb00641f19491f13b1a643197",
+      "value": " 50000/50000 [00:00&lt;00:00, 142668.00 examples/s]"
+     }
+    },
+    "1dfc470241c44ce1a0f9ae71fdfdbdf6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_da7f0a799616427ba7e93b0080d26d37",
+      "placeholder": "​",
+      "style": "IPY_MODEL_9931cc064e2c400e9830e448c8ef4655",
+      "value": " 20.5M/20.5M [00:00&lt;00:00, 214MB/s]"
+     }
+    },
+    "1fea1738e9fe48629b09e2ec9351fcd2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_60695bb251124317a897a6fc56b754ac",
+      "placeholder": "​",
+      "style": "IPY_MODEL_d0582455fe3c449dbde19a47561770b4",
+      "value": "Generating train split: 100%"
+     }
+    },
+    "20cd23dc1cd840c89741957f3fcbfdb8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_16afa8cf9ca64a59afd7a4c4f293b479",
+      "max": 50000,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_4a025adc548b4fcb8c5637f8f6dabc81",
+      "value": 50000
+     }
+    },
+    "24abe5089abc4ecfab75f7601bc98e68": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "24cbed7481774ef793a8f204ba5b604b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "2bbd92cebbf445d087bcadf82625c6d5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "2be4c676b5834100b31d7f42ab8bab85": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2cd718fb166641d59c8df64cbc637d9c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "2d2adb2b7a3b41d28736a8b7aba258b1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2d46765961fe453597645a0b56a9cbc7": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2d76c76bc4a6433b8fe2b28a1c887ada": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_31aa04d4f32a411293f2f729889984b8",
+       "IPY_MODEL_87de47c8821f423d9efc5c7e85297e32",
+       "IPY_MODEL_5f0dfd26cb484695b85d021a5d687503"
+      ],
+      "layout": "IPY_MODEL_d1414b66bc0f4a088c5e4551e8f4ee72"
+     }
+    },
+    "2e2fc856557e40df8400e4b69f7143fc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_92b9e59f9038485e839598237ec3fd8c",
+      "max": 25000,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_d69df0074246435f8481fd803863cdb1",
+      "value": 25000
+     }
+    },
+    "30d18e09421b42c985904750e68740d1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_71a7cf52600f4288bd725b7bb93e7299",
+      "placeholder": "​",
+      "style": "IPY_MODEL_e3082a5e8a4144f5982ad478d9a54a2c",
+      "value": " 50000/50000 [00:44&lt;00:00, 1214.24 examples/s]"
+     }
+    },
+    "3142f29a154c4a33a161237d4c605c50": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_9b39cdb9f7a14ab4865f360f3c1537dc",
+       "IPY_MODEL_798c00bf640e483cbc4fea744b268461",
+       "IPY_MODEL_1882e91f0b264cbeb90b99a69c7de7f5"
+      ],
+      "layout": "IPY_MODEL_17c7d8bb89184c26966a33dc27ef5517"
+     }
+    },
+    "31664fd452bb43e3aefb87542c747b74": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "31aa04d4f32a411293f2f729889984b8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_da58efd0f2b5442c8a284a948f2614f8",
+      "placeholder": "​",
+      "style": "IPY_MODEL_2cd718fb166641d59c8df64cbc637d9c",
+      "value": "Map: 100%"
+     }
+    },
+    "31bad1f4c7c047a280d490b854a6e911": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "336ffca0a89e4255a62564ec2600318c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "34f8bcc1d9954fb8ba8ecca7a6bd04cd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_336ffca0a89e4255a62564ec2600318c",
+      "max": 25000,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_2bbd92cebbf445d087bcadf82625c6d5",
+      "value": 25000
+     }
+    },
+    "38fd040b3a0d44d2adf13c2476f4505a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a9548c2f9fd54f73abc3e9c3c0bc9fda",
+      "placeholder": "​",
+      "style": "IPY_MODEL_faa9b111dd9745a29bf7494b95619a1b",
+      "value": "test-00000-of-00001.parquet: 100%"
+     }
+    },
+    "3a99edeb7d5e43048fdce29b880c19a5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_81eef7f1d0c7461cb443b996a5d5163f",
+      "max": 20470363,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_b832fdc7655b4f88a15e19fc8381db47",
+      "value": 20470363
+     }
+    },
+    "3cc5521074d3411cbc24d0348d3fc314": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3d6b95a9f8774341be1976f10fb74679": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3ec913f1b93d4097ad9729156295f9e9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "404088a4057546968f4e8cfc9e7461e1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "47789088bcfa4c96a5fd898812c23d17": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8ac5b5baeefb4078a74d8c8b2fed6d93",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4bbb4bf49e50489abc875881958c00aa",
+      "value": "Map: 100%"
+     }
+    },
+    "4a025adc548b4fcb8c5637f8f6dabc81": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "4bbb4bf49e50489abc875881958c00aa": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4c55b2c1daa4497abf9c9f53e23f83b8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4f7b2a1359bf41cab2ed5663643509a6": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4fe02a8771814e22b8d954cfdd8b9f86": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_d52e5c49b80348fbb55ab39ce0a13f7e",
+       "IPY_MODEL_51f4dabc59d04f0c89128d41d4c184a1",
+       "IPY_MODEL_803fcea81b7b47fb91fb108e2170fa75"
+      ],
+      "layout": "IPY_MODEL_ee5722120e1045e985e5e4ca29a2e192"
+     }
+    },
+    "51f4dabc59d04f0c89128d41d4c184a1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_3d6b95a9f8774341be1976f10fb74679",
+      "max": 41996509,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_3ec913f1b93d4097ad9729156295f9e9",
+      "value": 41996509
+     }
+    },
+    "55cab288802d49efb930c7641b036f44": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "568c0efe6ced432d81f45af4acaa921e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "580a3b71b23f4a72be9e8633c04e9276": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5b346ce1eaf649d195fa7dd6058dd196",
+      "max": 25000,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_d7b4684e53d445e58de1fe155315e093",
+      "value": 25000
+     }
+    },
+    "5b346ce1eaf649d195fa7dd6058dd196": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5ce04c799bb0430386e39af4734e80e6": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5f0dfd26cb484695b85d021a5d687503": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b1c37874948c459583a9f33dc77a6f55",
+      "placeholder": "​",
+      "style": "IPY_MODEL_24cbed7481774ef793a8f204ba5b604b",
+      "value": " 25000/25000 [00:23&lt;00:00, 1166.56 examples/s]"
+     }
+    },
+    "60695bb251124317a897a6fc56b754ac": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6eea630bd65745739ff646fbb172f426": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "716d24b9c1b340a2bf9045b0bf4e7e34": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_47789088bcfa4c96a5fd898812c23d17",
+       "IPY_MODEL_580a3b71b23f4a72be9e8633c04e9276",
+       "IPY_MODEL_03f7cfca9e634cf69e3cc70f24832ba3"
+      ],
+      "layout": "IPY_MODEL_987a633e24594228b82e162397a63141"
+     }
+    },
+    "71a7cf52600f4288bd725b7bb93e7299": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7812641b79ae46d48bc88b4c773344c0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "7823f9d79e1d4350b385e6dfef84b021": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c006e4b791204d10a9d8e7fbc4bceb81",
+      "placeholder": "​",
+      "style": "IPY_MODEL_31664fd452bb43e3aefb87542c747b74",
+      "value": "Generating unsupervised split: 100%"
+     }
+    },
+    "798c00bf640e483cbc4fea744b268461": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d406b18b855d488cac92b9b96073ba43",
+      "max": 20979968,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_eee89779493748d38c01bb0a74b29e38",
+      "value": 20979968
+     }
+    },
+    "7f78e58f4e9c457a9c2d121759efdb09": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f1574df0debf4e1b8617e24ffcc39e16",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a9cbf2bbb1f14894886617ce8e60de12",
+      "value": " 25000/25000 [00:00&lt;00:00, 104177.91 examples/s]"
+     }
+    },
+    "803fcea81b7b47fb91fb108e2170fa75": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b29cde97f90f4c489c5cdfd007c96d4f",
+      "placeholder": "​",
+      "style": "IPY_MODEL_d8c8ee9f63b14182a9ded152435c510f",
+      "value": " 42.0M/42.0M [00:00&lt;00:00, 163MB/s]"
+     }
+    },
+    "806a2b3f4c4c4ba59370a46c0f8faa85": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_38fd040b3a0d44d2adf13c2476f4505a",
+       "IPY_MODEL_3a99edeb7d5e43048fdce29b880c19a5",
+       "IPY_MODEL_1dfc470241c44ce1a0f9ae71fdfdbdf6"
+      ],
+      "layout": "IPY_MODEL_feb83525a43a4c2d818f3ef1ae69d581"
+     }
+    },
+    "81eef7f1d0c7461cb443b996a5d5163f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "87de47c8821f423d9efc5c7e85297e32": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_2be4c676b5834100b31d7f42ab8bab85",
+      "max": 25000,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_6eea630bd65745739ff646fbb172f426",
+      "value": 25000
+     }
+    },
+    "886443acd2f14cff93059c093f98cc1b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8ac5b5baeefb4078a74d8c8b2fed6d93": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8e862faf12804eaebfd7692db348842b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8fcd7e9ed5f54287b5cda0ad52a277f4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "92b9e59f9038485e839598237ec3fd8c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "93dd1cc84f26479caaa1ded80bbea5ff": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b3cde05a07b2437b935083d6aac25913",
+      "max": 7809,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_31bad1f4c7c047a280d490b854a6e911",
+      "value": 7809
+     }
+    },
+    "987a633e24594228b82e162397a63141": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "9931cc064e2c400e9830e448c8ef4655": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "99bab394a68140f79def33bc6f6499b2": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "9b39cdb9f7a14ab4865f360f3c1537dc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_55cab288802d49efb930c7641b036f44",
+      "placeholder": "​",
+      "style": "IPY_MODEL_0649702ad9764ad8bf3dfbaa6739686e",
+      "value": "train-00000-of-00001.parquet: 100%"
+     }
+    },
+    "9b4b309603db4847a0d94da76db15116": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_568c0efe6ced432d81f45af4acaa921e",
+      "placeholder": "​",
+      "style": "IPY_MODEL_f402e8e510d64d0ca4d4ae2c09a7ddfc",
+      "value": "README.md: 100%"
+     }
+    },
+    "a9548c2f9fd54f73abc3e9c3c0bc9fda": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a9cbf2bbb1f14894886617ce8e60de12": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "aa7697dbb00641f19491f13b1a643197": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "b1c37874948c459583a9f33dc77a6f55": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b29cde97f90f4c489c5cdfd007c96d4f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b3cde05a07b2437b935083d6aac25913": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b832fdc7655b4f88a15e19fc8381db47": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "bce88474ca6745da99d79bc07216333c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_3cc5521074d3411cbc24d0348d3fc314",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4c55b2c1daa4497abf9c9f53e23f83b8",
+      "value": " 25000/25000 [00:00&lt;00:00, 113831.51 examples/s]"
+     }
+    },
+    "c006e4b791204d10a9d8e7fbc4bceb81": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d0582455fe3c449dbde19a47561770b4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "d1414b66bc0f4a088c5e4551e8f4ee72": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d406b18b855d488cac92b9b96073ba43": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d52e5c49b80348fbb55ab39ce0a13f7e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8fcd7e9ed5f54287b5cda0ad52a277f4",
+      "placeholder": "​",
+      "style": "IPY_MODEL_10335d3ada7f428588c4faa3f57bbd51",
+      "value": "unsupervised-00000-of-00001.parquet: 100%"
+     }
+    },
+    "d69df0074246435f8481fd803863cdb1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "d7b4684e53d445e58de1fe155315e093": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "d8c8ee9f63b14182a9ded152435c510f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "da58efd0f2b5442c8a284a948f2614f8": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "da7f0a799616427ba7e93b0080d26d37": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "db0b4bb4c7a642fb9e8d5c7738e90afc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e0e6445a2a774ae89729b7e2fb4a14b3",
+      "placeholder": "​",
+      "style": "IPY_MODEL_fdd99c599f9c4ac88c09939ec397ca46",
+      "value": "Map: 100%"
+     }
+    },
+    "db1b2639fc4944bcbbdfbdaf9150409f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "db789da312a24fc9944ecb8b617109e7": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e0e6445a2a774ae89729b7e2fb4a14b3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e3082a5e8a4144f5982ad478d9a54a2c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "e85940da7bc24b8bb29ce609ba6e5613": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4f7b2a1359bf41cab2ed5663643509a6",
+      "placeholder": "​",
+      "style": "IPY_MODEL_db1b2639fc4944bcbbdfbdaf9150409f",
+      "value": "Generating test split: 100%"
+     }
+    },
+    "ebf724c3ad1443e98763dd279e6fc996": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_9b4b309603db4847a0d94da76db15116",
+       "IPY_MODEL_93dd1cc84f26479caaa1ded80bbea5ff",
+       "IPY_MODEL_0dc109378f1c43a7b18b1be03cce32ce"
+      ],
+      "layout": "IPY_MODEL_2d2adb2b7a3b41d28736a8b7aba258b1"
+     }
+    },
+    "ee5722120e1045e985e5e4ca29a2e192": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "eee89779493748d38c01bb0a74b29e38": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "f1574df0debf4e1b8617e24ffcc39e16": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f402e8e510d64d0ca4d4ae2c09a7ddfc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "f4d35fb98b0048ca8bdbe856d182d561": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_e85940da7bc24b8bb29ce609ba6e5613",
+       "IPY_MODEL_34f8bcc1d9954fb8ba8ecca7a6bd04cd",
+       "IPY_MODEL_7f78e58f4e9c457a9c2d121759efdb09"
+      ],
+      "layout": "IPY_MODEL_2d46765961fe453597645a0b56a9cbc7"
+     }
+    },
+    "f67b5bbf7ccb475abe41e08316dc5b37": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f8b71d5cb37549fba6559e2d83531319": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5ce04c799bb0430386e39af4734e80e6",
+      "max": 50000,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_404088a4057546968f4e8cfc9e7461e1",
+      "value": 50000
+     }
+    },
+    "f8d90231390a4211b698e700a66fcb0f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "faa9b111dd9745a29bf7494b95619a1b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "fdd4b9937b7744d98ba1163efbe1310b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_7823f9d79e1d4350b385e6dfef84b021",
+       "IPY_MODEL_20cd23dc1cd840c89741957f3fcbfdb8",
+       "IPY_MODEL_1c07d8f701604da0989d5f8d88d4bbcd"
+      ],
+      "layout": "IPY_MODEL_00a9858d90d6430eaab54f9e013f077b"
+     }
+    },
+    "fdd99c599f9c4ac88c09939ec397ca46": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "feb83525a43a4c2d818f3ef1ae69d581": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    }
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/examples/feature_extraction/peft_lora_embedding_semantic_search.py b/examples/feature_extraction/peft_lora_embedding_semantic_search.py
new file mode 100644
index 0000000..8ed8bab
--- /dev/null
+++ b/examples/feature_extraction/peft_lora_embedding_semantic_search.py
@@ -0,0 +1,502 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import argparse
+import logging
+import math
+import os
+import random
+from pathlib import Path
+
+import datasets
+import evaluate
+import torch
+import transformers
+from accelerate import Accelerator
+from accelerate.logging import get_logger
+from accelerate.utils import set_seed
+from datasets import DatasetDict, load_dataset
+from huggingface_hub import HfApi
+from torch import nn
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+from transformers import AutoModel, AutoTokenizer, SchedulerType, default_data_collator, get_scheduler
+
+from peft import LoraConfig, TaskType, get_peft_model
+
+
+logger = get_logger(__name__)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Training a PEFT model for Semantic Search task")
+    parser.add_argument("--dataset_name", type=str, default=None, help="dataset name on HF hub")
+    parser.add_argument(
+        "--max_length",
+        type=int,
+        default=128,
+        help=(
+            "The maximum total input sequence length after tokenization. Sequences longer than this will be truncated,"
+            " sequences shorter will be padded if `--pad_to_max_length` is passed."
+        ),
+    )
+    parser.add_argument(
+        "--model_name_or_path",
+        type=str,
+        help="Path to pretrained model or model identifier from huggingface.co/models.",
+        required=True,
+    )
+    parser.add_argument(
+        "--per_device_train_batch_size",
+        type=int,
+        default=8,
+        help="Batch size (per device) for the training dataloader.",
+    )
+    parser.add_argument(
+        "--per_device_eval_batch_size",
+        type=int,
+        default=8,
+        help="Batch size (per device) for the evaluation dataloader.",
+    )
+    parser.add_argument(
+        "--learning_rate",
+        type=float,
+        default=5e-5,
+        help="Initial learning rate (after the potential warmup period) to use.",
+    )
+    parser.add_argument("--weight_decay", type=float, default=0.0, help="Weight decay to use.")
+    parser.add_argument("--num_train_epochs", type=int, default=3, help="Total number of training epochs to perform.")
+    parser.add_argument(
+        "--max_train_steps",
+        type=int,
+        default=None,
+        help="Total number of training steps to perform. If provided, overrides num_train_epochs.",
+    )
+    parser.add_argument(
+        "--gradient_accumulation_steps",
+        type=int,
+        default=1,
+        help="Number of updates steps to accumulate before performing a backward/update pass.",
+    )
+    parser.add_argument(
+        "--lr_scheduler_type",
+        type=SchedulerType,
+        default="linear",
+        help="The scheduler type to use.",
+        choices=["linear", "cosine", "cosine_with_restarts", "polynomial", "constant", "constant_with_warmup"],
+    )
+    parser.add_argument(
+        "--num_warmup_steps", type=int, default=0, help="Number of steps for the warmup in the lr scheduler."
+    )
+    parser.add_argument("--output_dir", type=str, default=None, help="Where to store the final model.")
+    parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.")
+    parser.add_argument("--push_to_hub", action="store_true", help="Whether or not to push the model to the Hub.")
+    parser.add_argument(
+        "--hub_model_id", type=str, help="The name of the repository to keep in sync with the local `output_dir`."
+    )
+    parser.add_argument("--hub_token", type=str, help="The token to use to push to the Model Hub.")
+    parser.add_argument(
+        "--checkpointing_steps",
+        type=str,
+        default=None,
+        help="Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch.",
+    )
+    parser.add_argument(
+        "--resume_from_checkpoint",
+        type=str,
+        default=None,
+        help="If the training should continue from a checkpoint folder.",
+    )
+    parser.add_argument(
+        "--with_tracking",
+        action="store_true",
+        help="Whether to enable experiment trackers for logging.",
+    )
+    parser.add_argument(
+        "--report_to",
+        type=str,
+        default="all",
+        help=(
+            'The integration to report the results and logs to. Supported platforms are `"tensorboard"`,'
+            ' `"wandb"`, `"comet_ml"` and `"clearml"`. Use `"all"` (default) to report to all integrations.'
+            "Only applicable when `--with_tracking` is passed."
+        ),
+    )
+    parser.add_argument(
+        "--sanity_test",
+        action="store_true",
+        help="Whether to enable sanity test.",
+    )
+    parser.add_argument(
+        "--use_peft",
+        action="store_true",
+        help="Whether to use PEFT.",
+    )
+    args = parser.parse_args()
+
+    if args.push_to_hub:
+        assert args.output_dir is not None, "Need an `output_dir` to create a repo when `--push_to_hub` is passed."
+
+    return args
+
+
+def save_model_hook(models, weights, output_dir):
+    for i, model in enumerate(models):
+        model.save_pretrained(output_dir, state_dict=weights[i])
+        # make sure to pop weight so that corresponding model is not saved again
+        weights.pop()
+
+
+def load_model_hook(models, input_dir):
+    while len(models) > 0:
+        model = models.pop()
+        # pop models so that they are not loaded again
+        if hasattr(model, "active_adapter") and hasattr(model, "load_adapter"):
+            model.load_adapter(input_dir, model.active_adapter, is_trainable=True)
+
+
+class AutoModelForSentenceEmbedding(nn.Module):
+    def __init__(self, model_name, tokenizer, normalize=True):
+        super().__init__()
+
+        self.model = AutoModel.from_pretrained(
+            model_name
+        )  # , quantizaton_config=BitsAndBytesConfig(load_in_8bit=True), device_map={"":0})
+        self.normalize = normalize
+        self.tokenizer = tokenizer
+
+    def forward(self, **kwargs):
+        model_output = self.model(**kwargs)
+        embeddings = self.mean_pooling(model_output, kwargs["attention_mask"])
+        if self.normalize:
+            embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+
+        return embeddings
+
+    def mean_pooling(self, model_output, attention_mask):
+        token_embeddings = model_output[0]  # First element of model_output contains all token embeddings
+        input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
+        return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)
+
+    def __getattr__(self, name: str):
+        """Forward missing attributes to the wrapped module."""
+        try:
+            return super().__getattr__(name)  # defer to nn.Module's logic
+        except AttributeError:
+            if name == "model":  # see #1892: prevent infinite recursion if class is not initialized
+                raise
+            return getattr(self.model, name)
+
+
+def get_cosing_embeddings(query_embs, product_embs):
+    return torch.sum(query_embs * product_embs, axis=1)
+
+
+def get_loss(cosine_score, labels):
+    return torch.mean(torch.square(labels * (1 - cosine_score) + torch.clamp((1 - labels) * cosine_score, min=0.0)))
+
+
+def main():
+    args = parse_args()
+
+    accelerator_kwargs = {"gradient_accumulation_steps": args.gradient_accumulation_steps}
+    if args.with_tracking:
+        accelerator_kwargs["log_with"] = args.report_to
+        accelerator_kwargs["project_dir"] = args.output_dir
+    accelerator = Accelerator(**accelerator_kwargs)
+
+    # Make one log on every process with the configuration for debugging.
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        level=logging.INFO,
+    )
+    logger.info(accelerator.state, main_process_only=False)
+    if accelerator.is_local_main_process:
+        datasets.utils.logging.set_verbosity_warning()
+        transformers.utils.logging.set_verbosity_info()
+    else:
+        datasets.utils.logging.set_verbosity_error()
+        transformers.utils.logging.set_verbosity_error()
+
+    # If passed along, set the training seed now.
+    if args.seed is not None:
+        set_seed(args.seed)
+
+    # Handle the repository creation
+    if accelerator.is_main_process:
+        if args.push_to_hub:
+            api = HfApi(token=args.hub_token)
+
+            # Create repo (repo_name from args or inferred)
+            repo_name = args.hub_model_id
+            if repo_name is None:
+                repo_name = Path(args.output_dir).absolute().name
+            repo_id = api.create_repo(repo_name, exist_ok=True).repo_id
+
+            with open(os.path.join(args.output_dir, ".gitignore"), "w+") as gitignore:
+                if "step_*" not in gitignore:
+                    gitignore.write("step_*\n")
+                if "epoch_*" not in gitignore:
+                    gitignore.write("epoch_*\n")
+        elif args.output_dir is not None:
+            os.makedirs(args.output_dir, exist_ok=True)
+    accelerator.wait_for_everyone()
+
+    # get the tokenizer
+    tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path)
+
+    # dataset download and preprocessing
+    if args.sanity_test:
+        train_dataset = load_dataset("smangrul/amazon_esci", split="train[:1024]")
+        val_dataset = load_dataset("smangrul/amazon_esci", split="validation[:1024]")
+
+        dataset = DatasetDict({"train": train_dataset, "validation": val_dataset})
+    else:
+        dataset = load_dataset(args.dataset_name, revision="main")
+
+    def preprocess_function(examples):
+        queries = examples["query"]
+        result = tokenizer(queries, padding="max_length", max_length=70, truncation=True)
+        result = {f"query_{k}": v for k, v in result.items()}
+
+        products = examples["product_title"]
+        result_products = tokenizer(products, padding="max_length", max_length=70, truncation=True)
+        for k, v in result_products.items():
+            result[f"product_{k}"] = v
+
+        result["labels"] = examples["relevance_label"]
+        return result
+
+    processed_datasets = dataset.map(
+        preprocess_function,
+        batched=True,
+        remove_columns=dataset["train"].column_names,
+        desc="Running tokenizer on dataset",
+    )
+
+    # Log a few random samples from the training set:
+    for index in random.sample(range(len(processed_datasets["train"])), 3):
+        logger.info(f"Sample {index} of the training set: {processed_datasets['train'][index]}.")
+
+    # base model
+    model = AutoModelForSentenceEmbedding(args.model_name_or_path, tokenizer)
+
+    if args.use_peft:
+        # peft config and wrapping
+        peft_config = LoraConfig(
+            r=8,
+            lora_alpha=16,
+            bias="none",
+            task_type=TaskType.FEATURE_EXTRACTION,
+            target_modules=["key", "query", "value"],
+        )
+        model = get_peft_model(model, peft_config)
+        model.print_trainable_parameters()
+
+    accelerator.print(model)
+
+    # get dataloaders
+    train_dataloader = DataLoader(
+        processed_datasets["train"],
+        shuffle=True,
+        collate_fn=default_data_collator,
+        batch_size=args.per_device_train_batch_size,
+        pin_memory=True,
+    )
+
+    eval_dataloader = DataLoader(
+        processed_datasets["validation"],
+        shuffle=False,
+        collate_fn=default_data_collator,
+        batch_size=args.per_device_eval_batch_size,
+        pin_memory=True,
+    )
+
+    optimizer = torch.optim.Adam(model.parameters(), lr=args.learning_rate)
+
+    # Scheduler and math around the number of training steps.
+    overrode_max_train_steps = False
+    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+    if args.max_train_steps is None:
+        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+        overrode_max_train_steps = True
+
+    lr_scheduler = get_scheduler(
+        name=args.lr_scheduler_type,
+        optimizer=optimizer,
+        num_warmup_steps=args.num_warmup_steps,
+        num_training_steps=args.max_train_steps,
+    )
+
+    # Prepare everything with our `accelerator`.
+    model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(
+        model, optimizer, train_dataloader, eval_dataloader, lr_scheduler
+    )
+
+    # We need to recalculate our total training steps as the size of the training dataloader may have changed
+    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+    if overrode_max_train_steps:
+        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+    # Afterwards we recalculate our number of training epochs
+    args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch)
+
+    # Figure out how many steps we should save the Accelerator states
+    checkpointing_steps = args.checkpointing_steps
+    if checkpointing_steps is not None and checkpointing_steps.isdigit():
+        checkpointing_steps = int(checkpointing_steps)
+
+    # We need to initialize the trackers we use, and also store our configuration.
+    # The trackers initializes automatically on the main process.
+    if args.with_tracking:
+        experiment_config = vars(args)
+        # TensorBoard cannot log Enums, need the raw value
+        experiment_config["lr_scheduler_type"] = experiment_config["lr_scheduler_type"].value
+        accelerator.init_trackers("peft_semantic_search", experiment_config)
+
+    metric = evaluate.load("roc_auc")
+
+    total_batch_size = args.per_device_train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps
+
+    if args.use_peft:
+        # saving and loading checkpoints for resuming training
+        accelerator.register_save_state_pre_hook(save_model_hook)
+        accelerator.register_load_state_pre_hook(load_model_hook)
+
+    logger.info("***** Running training *****")
+    logger.info(f"  Num examples = {len(processed_datasets['train'])}")
+    logger.info(f"  Num Epochs = {args.num_train_epochs}")
+    logger.info(f"  Instantaneous batch size per device = {args.per_device_train_batch_size}")
+    logger.info(f"  Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}")
+    logger.info(f"  Gradient Accumulation steps = {args.gradient_accumulation_steps}")
+    logger.info(f"  Total optimization steps = {args.max_train_steps}")
+
+    # Only show the progress bar once on each machine.
+    progress_bar = tqdm(range(args.max_train_steps), disable=not accelerator.is_local_main_process)
+    completed_steps = 0
+    starting_epoch = 0
+    # Potentially load in the weights and states from a previous save
+    if args.resume_from_checkpoint:
+        if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != "":
+            accelerator.print(f"Resumed from checkpoint: {args.resume_from_checkpoint}")
+            accelerator.load_state(args.resume_from_checkpoint)
+            path = os.path.basename(args.resume_from_checkpoint)
+        else:
+            # Get the most recent checkpoint
+            dirs = [f.name for f in os.scandir(os.getcwd()) if f.is_dir()]
+            dirs.sort(key=os.path.getctime)
+            path = dirs[-1]  # Sorts folders by date modified, most recent checkpoint is the last
+        # Extract `epoch_{i}` or `step_{i}`
+        training_difference = os.path.splitext(path)[0]
+
+        if "epoch" in training_difference:
+            starting_epoch = int(training_difference.replace("epoch_", "")) + 1
+            resume_step = None
+            completed_steps = starting_epoch * num_update_steps_per_epoch
+        else:
+            # need to multiply `gradient_accumulation_steps` to reflect real steps
+            resume_step = int(training_difference.replace("step_", "")) * args.gradient_accumulation_steps
+            starting_epoch = resume_step // len(train_dataloader)
+            resume_step -= starting_epoch * len(train_dataloader)
+            completed_steps = resume_step // args.gradient_accumulation_steps
+
+    # update the progress_bar if load from checkpoint
+    progress_bar.update(completed_steps)
+
+    for epoch in range(starting_epoch, args.num_train_epochs):
+        model.train()
+        total_loss = 0
+        if args.resume_from_checkpoint and epoch == starting_epoch and resume_step is not None:
+            # We skip the first `n` batches in the dataloader when resuming from a checkpoint
+            active_dataloader = accelerator.skip_first_batches(train_dataloader, resume_step)
+        else:
+            active_dataloader = train_dataloader
+        for step, batch in enumerate(active_dataloader):
+            with accelerator.accumulate(model):
+                query_embs = model(**{k.replace("query_", ""): v for k, v in batch.items() if "query" in k})
+                product_embs = model(**{k.replace("product_", ""): v for k, v in batch.items() if "product" in k})
+                loss = get_loss(get_cosing_embeddings(query_embs, product_embs), batch["labels"])
+                total_loss += accelerator.reduce(loss.detach().float(), reduction="sum")
+                accelerator.backward(loss)
+                optimizer.step()
+                lr_scheduler.step()
+                model.zero_grad()
+
+            # Checks if the accelerator has performed an optimization step behind the scenes
+            if accelerator.sync_gradients:
+                progress_bar.update(1)
+                completed_steps += 1
+
+            if (step + 1) % 100 == 0:
+                logger.info(f"Step: {step + 1}, Loss: {total_loss / (step + 1)}")
+                if args.with_tracking:
+                    accelerator.log({"train/loss": total_loss / (step + 1)}, step=completed_steps)
+
+            if isinstance(checkpointing_steps, int):
+                if completed_steps % checkpointing_steps == 0:
+                    output_dir = f"step_{completed_steps}"
+                    if args.output_dir is not None:
+                        output_dir = os.path.join(args.output_dir, output_dir)
+                    accelerator.save_state(output_dir)
+
+            if completed_steps >= args.max_train_steps:
+                break
+
+        model.eval()
+        for step, batch in enumerate(eval_dataloader):
+            with torch.no_grad():
+                query_embs = model(**{k.replace("query_", ""): v for k, v in batch.items() if "query" in k})
+                product_embs = model(**{k.replace("product_", ""): v for k, v in batch.items() if "product" in k})
+                prediction_scores = get_cosing_embeddings(query_embs, product_embs)
+            prediction_scores, references = accelerator.gather_for_metrics((prediction_scores, batch["labels"]))
+            metric.add_batch(
+                prediction_scores=prediction_scores,
+                references=references,
+            )
+
+        result = metric.compute()
+        result = {f"eval/{k}": v for k, v in result.items()}
+        # Use accelerator.print to print only on the main process.
+        accelerator.print(f"epoch {epoch}:", result)
+        if args.with_tracking:
+            result["train/epoch_loss"] = total_loss.item() / len(train_dataloader)
+            accelerator.log(result, step=completed_steps)
+
+        if args.output_dir is not None:
+            accelerator.wait_for_everyone()
+            if accelerator.is_main_process:
+                if isinstance(checkpointing_steps, str):
+                    accelerator.save_state(os.path.join(args.output_dir, f"epoch_{epoch}"))
+                accelerator.unwrap_model(model).save_pretrained(
+                    args.output_dir, state_dict=accelerator.get_state_dict(accelerator.unwrap_model(model))
+                )
+                tokenizer.save_pretrained(args.output_dir)
+                if args.push_to_hub:
+                    commit_message = (
+                        f"Training in progress epoch {epoch}"
+                        if epoch < args.num_train_epochs - 1
+                        else "End of training"
+                    )
+                    api.upload_folder(
+                        repo_id=repo_id,
+                        folder_path=args.output_dir,
+                        commit_message=commit_message,
+                        run_as_future=True,
+                    )
+            accelerator.wait_for_everyone()
+    accelerator.end_training()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/feature_extraction/peft_lora_embedding_semantic_similarity_inference.ipynb b/examples/feature_extraction/peft_lora_embedding_semantic_similarity_inference.ipynb
new file mode 100644
index 0000000..ded221b
--- /dev/null
+++ b/examples/feature_extraction/peft_lora_embedding_semantic_similarity_inference.ipynb
@@ -0,0 +1,1808 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "3e7b6247",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2023-06-29 09:08:24,868] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n",
+      "\n",
+      "===================================BUG REPORT===================================\n",
+      "Welcome to bitsandbytes. For bug reports, please run\n",
+      "\n",
+      "python -m bitsandbytes\n",
+      "\n",
+      " and submit this information together with your error trace to: https://github.com/TimDettmers/bitsandbytes/issues\n",
+      "================================================================================\n",
+      "bin /home/sourab/miniconda3/envs/ml/lib/python3.11/site-packages/bitsandbytes/libbitsandbytes_cuda118.so\n",
+      "CUDA SETUP: CUDA runtime path found: /home/sourab/miniconda3/envs/ml/lib/libcudart.so\n",
+      "CUDA SETUP: Highest compute capability among GPUs detected: 7.5\n",
+      "CUDA SETUP: Detected CUDA version 118\n",
+      "CUDA SETUP: Loading binary /home/sourab/miniconda3/envs/ml/lib/python3.11/site-packages/bitsandbytes/libbitsandbytes_cuda118.so...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/sourab/miniconda3/envs/ml/lib/python3.11/site-packages/bitsandbytes/cuda_setup/main.py:149: UserWarning: Found duplicate ['libcudart.so', 'libcudart.so.11.0', 'libcudart.so.12.0'] files: {PosixPath('/home/sourab/miniconda3/envs/ml/lib/libcudart.so'), PosixPath('/home/sourab/miniconda3/envs/ml/lib/libcudart.so.11.0')}.. We'll flip a coin and try one of these, in order to fail forward.\n",
+      "Either way, this might cause trouble in the future:\n",
+      "If you get `CUDA error: invalid device function` errors, the above might be the cause and the solution is to make sure only one ['libcudart.so', 'libcudart.so.11.0', 'libcudart.so.12.0'] in the paths that we search based on your env.\n",
+      "  warn(msg)\n"
+     ]
+    }
+   ],
+   "source": [
+    "import argparse\n",
+    "import json\n",
+    "import logging\n",
+    "import math\n",
+    "import os\n",
+    "import random\n",
+    "from pathlib import Path\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "import datasets\n",
+    "from datasets import load_dataset, DatasetDict\n",
+    "\n",
+    "import evaluate\n",
+    "import torch\n",
+    "from torch import nn\n",
+    "from torch.utils.data import DataLoader\n",
+    "\n",
+    "import transformers\n",
+    "from transformers import AutoTokenizer, AutoModel, default_data_collator, SchedulerType, get_scheduler\n",
+    "from transformers.utils import check_min_version, get_full_repo_name, send_example_telemetry\n",
+    "from transformers.utils.versions import require_version\n",
+    "\n",
+    "from huggingface_hub import Repository, create_repo\n",
+    "\n",
+    "from accelerate import Accelerator\n",
+    "from accelerate.logging import get_logger\n",
+    "from accelerate.utils import set_seed\n",
+    "\n",
+    "from peft import PeftModel\n",
+    "\n",
+    "import hnswlib"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "c939b4fd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class AutoModelForSentenceEmbedding(nn.Module):\n",
+    "    def __init__(self, model_name, tokenizer, normalize=True):\n",
+    "        super(AutoModelForSentenceEmbedding, self).__init__()\n",
+    "\n",
+    "        self.model = AutoModel.from_pretrained(model_name)  # , quantizaton_config=BitsAndBytesConfig(load_in_8bit=True), device_map={\"\":0})\n",
+    "        self.normalize = normalize\n",
+    "        self.tokenizer = tokenizer\n",
+    "\n",
+    "    def forward(self, **kwargs):\n",
+    "        model_output = self.model(**kwargs)\n",
+    "        embeddings = self.mean_pooling(model_output, kwargs[\"attention_mask\"])\n",
+    "        if self.normalize:\n",
+    "            embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)\n",
+    "\n",
+    "        return embeddings\n",
+    "\n",
+    "    def mean_pooling(self, model_output, attention_mask):\n",
+    "        token_embeddings = model_output[0]  # First element of model_output contains all token embeddings\n",
+    "        input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()\n",
+    "        return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)\n",
+    "\n",
+    "    def __getattr__(self, name: str):\n",
+    "        \"\"\"Forward missing attributes to the wrapped module.\"\"\"\n",
+    "        try:\n",
+    "            return super().__getattr__(name)  # defer to nn.Module's logic\n",
+    "        except AttributeError:\n",
+    "            return getattr(self.model, name)\n",
+    "\n",
+    "\n",
+    "def get_cosing_embeddings(query_embs, product_embs):\n",
+    "    return torch.sum(query_embs * product_embs, axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "8b5d9256",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_name_or_path = \"intfloat/e5-large-v2\"\n",
+    "peft_model_id = \"smangrul/peft_lora_e5_semantic_search\"\n",
+    "dataset_name = \"smangrul/amazon_esci\"\n",
+    "max_length = 70\n",
+    "batch_size = 256"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f190e1ee",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Found cached dataset parquet (/raid/sourab/.cache/huggingface/datasets/smangrul___parquet/smangrul--amazon_esci-321288cabf0cc045/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7)\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "43b84641575e4ce6899a3e6f61d7e126",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/2 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)\n",
+    "dataset = load_dataset(dataset_name, revision=\"main\")\n",
+    "train_product_dataset = dataset[\"train\"].to_pandas()[[\"product_title\"]]\n",
+    "val_product_dataset = dataset[\"validation\"].to_pandas()[[\"product_title\"]]\n",
+    "product_dataset_for_indexing = pd.concat([train_product_dataset, val_product_dataset])\n",
+    "product_dataset_for_indexing = product_dataset_for_indexing.drop_duplicates()\n",
+    "product_dataset_for_indexing.reset_index(drop=True, inplace=True)\n",
+    "product_dataset_for_indexing.reset_index(inplace=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "7e52e425",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>index</th>\n",
+       "      <th>product_title</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0</td>\n",
+       "      <td>RamPro 10\" All Purpose Utility Air Tires/Wheel...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>1</td>\n",
+       "      <td>MaxAuto 2-Pack 13x5.00-6 2PLY Turf Mower Tract...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>2</td>\n",
+       "      <td>NEIKO 20601A 14.5 inch Steel Tire Spoon Lever ...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>3</td>\n",
+       "      <td>2PK 13x5.00-6 13x5.00x6 13x5x6 13x5-6 2PLY Tur...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>4</td>\n",
+       "      <td>(Set of 2) 15x6.00-6 Husqvarna/Poulan Tire Whe...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>476273</th>\n",
+       "      <td>476273</td>\n",
+       "      <td>Chanel No.5 Eau Premiere Spray 50ml/1.7oz</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>476274</th>\n",
+       "      <td>476274</td>\n",
+       "      <td>Steve Madden Designer 15 Inch Carry on Suitcas...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>476275</th>\n",
+       "      <td>476275</td>\n",
+       "      <td>CHANEL Le Lift Creme Yeux, Black, 0.5 Ounce</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>476276</th>\n",
+       "      <td>476276</td>\n",
+       "      <td>Coco Mademoiselle by Chanel for Women - 3.4 oz...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>476277</th>\n",
+       "      <td>476277</td>\n",
+       "      <td>Chânél No. 5 by Chânél Eau De Parfum Premiere ...</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>476278 rows × 2 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "         index                                      product_title\n",
+       "0            0  RamPro 10\" All Purpose Utility Air Tires/Wheel...\n",
+       "1            1  MaxAuto 2-Pack 13x5.00-6 2PLY Turf Mower Tract...\n",
+       "2            2  NEIKO 20601A 14.5 inch Steel Tire Spoon Lever ...\n",
+       "3            3  2PK 13x5.00-6 13x5.00x6 13x5x6 13x5-6 2PLY Tur...\n",
+       "4            4  (Set of 2) 15x6.00-6 Husqvarna/Poulan Tire Whe...\n",
+       "...        ...                                                ...\n",
+       "476273  476273          Chanel No.5 Eau Premiere Spray 50ml/1.7oz\n",
+       "476274  476274  Steve Madden Designer 15 Inch Carry on Suitcas...\n",
+       "476275  476275        CHANEL Le Lift Creme Yeux, Black, 0.5 Ounce\n",
+       "476276  476276  Coco Mademoiselle by Chanel for Women - 3.4 oz...\n",
+       "476277  476277  Chânél No. 5 by Chânél Eau De Parfum Premiere ...\n",
+       "\n",
+       "[476278 rows x 2 columns]"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "product_dataset_for_indexing"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "85840ec6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>index</th>\n",
+       "      <th>product_title</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>34710</th>\n",
+       "      <td>34710</td>\n",
+       "      <td>ROK 4-1/2 inch Diamond Saw Blade Set, Pack of 3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>277590</th>\n",
+       "      <td>277590</td>\n",
+       "      <td>WSGG Medical Goggles, FDA registered, Safety Goggles, Fit Over Glasses, Anti-Fog, Anti-Splash (1 pack)</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>474000</th>\n",
+       "      <td>474000</td>\n",
+       "      <td>iJDMTOY 15W CREE High Power LED Angel Eye Bulbs Compatible With BMW 5 6 7 Series X3 X5 (E39 E60 E63 E65 E53), 7000K Xenon White Headlight Ring Marker Lights</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>18997</th>\n",
+       "      <td>18997</td>\n",
+       "      <td>USB Charger, Anker Elite Dual Port 24W Wall Charger, PowerPort 2 with PowerIQ and Foldable Plug, for iPhone 11/Xs/XS Max/XR/X/8/7/6/Plus, iPad Pro/Air 2/Mini 3/Mini 4, Samsung S4/S5, and More</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>208666</th>\n",
+       "      <td>208666</td>\n",
+       "      <td>AOGGY Compatible with MacBook Air 13 inch Case A1466/A1369 (2010-2017 Release) Glitter Fluorescent Color Plastic Hard Case， with Older Version MacBook Air 13 inch Keyboard Cover - Gold</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>326614</th>\n",
+       "      <td>326614</td>\n",
+       "      <td>CUTE STONE Little Kitchen Playset, Kitchen Toy Set with Realistic Sound &amp;Light, Play Sink, Cooking Stove with Steam, Play Food and Kitchen Accessories, Great Kitchen Toys for Toddlers Kids</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>105637</th>\n",
+       "      <td>105637</td>\n",
+       "      <td>Milwaukee Electric Tool 2470-21 M12 Cordless Shear Kit, 12 V, Li-Ion</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>342392</th>\n",
+       "      <td>342392</td>\n",
+       "      <td>chouyatou Women's Short Sleeve/Strap Open Bust Bodysuit Shapewear Firm Control Body Shaper (X-Small, Nude Sleeve)</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>319970</th>\n",
+       "      <td>319970</td>\n",
+       "      <td>AMT 256 Hz Medical-Grade Tuning Fork Instrument with Fixed Weights, Non-Magnetic Aluminum Alloy (C 256)</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>416956</th>\n",
+       "      <td>416956</td>\n",
+       "      <td>Timberland HIKER-ROUND 54 BROWN</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "         index  \\\n",
+       "34710    34710   \n",
+       "277590  277590   \n",
+       "474000  474000   \n",
+       "18997    18997   \n",
+       "208666  208666   \n",
+       "326614  326614   \n",
+       "105637  105637   \n",
+       "342392  342392   \n",
+       "319970  319970   \n",
+       "416956  416956   \n",
+       "\n",
+       "                                                                                                                                                                                          product_title  \n",
+       "34710                                                                                                                                                   ROK 4-1/2 inch Diamond Saw Blade Set, Pack of 3  \n",
+       "277590                                                                                           WSGG Medical Goggles, FDA registered, Safety Goggles, Fit Over Glasses, Anti-Fog, Anti-Splash (1 pack)  \n",
+       "474000                                     iJDMTOY 15W CREE High Power LED Angel Eye Bulbs Compatible With BMW 5 6 7 Series X3 X5 (E39 E60 E63 E65 E53), 7000K Xenon White Headlight Ring Marker Lights  \n",
+       "18997   USB Charger, Anker Elite Dual Port 24W Wall Charger, PowerPort 2 with PowerIQ and Foldable Plug, for iPhone 11/Xs/XS Max/XR/X/8/7/6/Plus, iPad Pro/Air 2/Mini 3/Mini 4, Samsung S4/S5, and More  \n",
+       "208666         AOGGY Compatible with MacBook Air 13 inch Case A1466/A1369 (2010-2017 Release) Glitter Fluorescent Color Plastic Hard Case， with Older Version MacBook Air 13 inch Keyboard Cover - Gold  \n",
+       "326614     CUTE STONE Little Kitchen Playset, Kitchen Toy Set with Realistic Sound &Light, Play Sink, Cooking Stove with Steam, Play Food and Kitchen Accessories, Great Kitchen Toys for Toddlers Kids  \n",
+       "105637                                                                                                                             Milwaukee Electric Tool 2470-21 M12 Cordless Shear Kit, 12 V, Li-Ion  \n",
+       "342392                                                                                chouyatou Women's Short Sleeve/Strap Open Bust Bodysuit Shapewear Firm Control Body Shaper (X-Small, Nude Sleeve)  \n",
+       "319970                                                                                          AMT 256 Hz Medical-Grade Tuning Fork Instrument with Fixed Weights, Non-Magnetic Aluminum Alloy (C 256)  \n",
+       "416956                                                                                                                                                                  Timberland HIKER-ROUND 54 BROWN  "
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pd.set_option(\"max_colwidth\", 300)\n",
+    "product_dataset_for_indexing.sample(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "408b6e00",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Running tokenizer on dataset:   0%|          | 0/476278 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Dataset({\n",
+       "    features: ['input_ids', 'token_type_ids', 'attention_mask'],\n",
+       "    num_rows: 476278\n",
+       "})"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from datasets import Dataset\n",
+    "\n",
+    "dataset = Dataset.from_pandas(product_dataset_for_indexing)\n",
+    "\n",
+    "\n",
+    "def preprocess_function(examples):\n",
+    "    products = examples[\"product_title\"]\n",
+    "    result = tokenizer(products, padding=\"max_length\", max_length=70, truncation=True)\n",
+    "    return result\n",
+    "\n",
+    "\n",
+    "processed_dataset = dataset.map(\n",
+    "    preprocess_function,\n",
+    "    batched=True,\n",
+    "    remove_columns=dataset.column_names,\n",
+    "    desc=\"Running tokenizer on dataset\",\n",
+    ")\n",
+    "processed_dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "7c1e3339",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "PeftModelForEmbedding(\n",
+      "  (base_model): LoraModel(\n",
+      "    (model): AutoModelForSentenceEmbedding(\n",
+      "      (model): BertModel(\n",
+      "        (embeddings): BertEmbeddings(\n",
+      "          (word_embeddings): Embedding(30522, 1024, padding_idx=0)\n",
+      "          (position_embeddings): Embedding(512, 1024)\n",
+      "          (token_type_embeddings): Embedding(2, 1024)\n",
+      "          (LayerNorm): LayerNorm((1024,), eps=1e-12, elementwise_affine=True)\n",
+      "          (dropout): Dropout(p=0.1, inplace=False)\n",
+      "        )\n",
+      "        (encoder): BertEncoder(\n",
+      "          (layer): ModuleList(\n",
+      "            (0-23): 24 x BertLayer(\n",
+      "              (attention): BertAttention(\n",
+      "                (self): BertSelfAttention(\n",
+      "                  (query): Linear(\n",
+      "                    in_features=1024, out_features=1024, bias=True\n",
+      "                    (lora_dropout): ModuleDict(\n",
+      "                      (default): Identity()\n",
+      "                    )\n",
+      "                    (lora_A): ModuleDict(\n",
+      "                      (default): Linear(in_features=1024, out_features=8, bias=False)\n",
+      "                    )\n",
+      "                    (lora_B): ModuleDict(\n",
+      "                      (default): Linear(in_features=8, out_features=1024, bias=False)\n",
+      "                    )\n",
+      "                    (lora_embedding_A): ParameterDict()\n",
+      "                    (lora_embedding_B): ParameterDict()\n",
+      "                  )\n",
+      "                  (key): Linear(in_features=1024, out_features=1024, bias=True)\n",
+      "                  (value): Linear(\n",
+      "                    in_features=1024, out_features=1024, bias=True\n",
+      "                    (lora_dropout): ModuleDict(\n",
+      "                      (default): Identity()\n",
+      "                    )\n",
+      "                    (lora_A): ModuleDict(\n",
+      "                      (default): Linear(in_features=1024, out_features=8, bias=False)\n",
+      "                    )\n",
+      "                    (lora_B): ModuleDict(\n",
+      "                      (default): Linear(in_features=8, out_features=1024, bias=False)\n",
+      "                    )\n",
+      "                    (lora_embedding_A): ParameterDict()\n",
+      "                    (lora_embedding_B): ParameterDict()\n",
+      "                  )\n",
+      "                  (dropout): Dropout(p=0.1, inplace=False)\n",
+      "                )\n",
+      "                (output): BertSelfOutput(\n",
+      "                  (dense): Linear(in_features=1024, out_features=1024, bias=True)\n",
+      "                  (LayerNorm): LayerNorm((1024,), eps=1e-12, elementwise_affine=True)\n",
+      "                  (dropout): Dropout(p=0.1, inplace=False)\n",
+      "                )\n",
+      "              )\n",
+      "              (intermediate): BertIntermediate(\n",
+      "                (dense): Linear(in_features=1024, out_features=4096, bias=True)\n",
+      "                (intermediate_act_fn): GELUActivation()\n",
+      "              )\n",
+      "              (output): BertOutput(\n",
+      "                (dense): Linear(in_features=4096, out_features=1024, bias=True)\n",
+      "                (LayerNorm): LayerNorm((1024,), eps=1e-12, elementwise_affine=True)\n",
+      "                (dropout): Dropout(p=0.1, inplace=False)\n",
+      "              )\n",
+      "            )\n",
+      "          )\n",
+      "        )\n",
+      "        (pooler): BertPooler(\n",
+      "          (dense): Linear(in_features=1024, out_features=1024, bias=True)\n",
+      "          (activation): Tanh()\n",
+      "        )\n",
+      "      )\n",
+      "    )\n",
+      "  )\n",
+      ")\n"
+     ]
+    }
+   ],
+   "source": [
+    "# base model\n",
+    "model = AutoModelForSentenceEmbedding(model_name_or_path, tokenizer)\n",
+    "\n",
+    "# peft config and wrapping\n",
+    "model = PeftModel.from_pretrained(model, peft_model_id)\n",
+    "\n",
+    "print(model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "1d2e3f16",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataloader = DataLoader(\n",
+    "    processed_dataset,\n",
+    "    shuffle=False,\n",
+    "    collate_fn=default_data_collator,\n",
+    "    batch_size=batch_size,\n",
+    "    pin_memory=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "ae16ad2d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'input_ids': tensor([[  101, 13276,  3217,  ...,     0,     0,     0],\n",
+       "         [  101,  4098,  4887,  ...,     0,     0,     0],\n",
+       "         [  101, 11265, 12676,  ...,     0,     0,     0],\n",
+       "         ...,\n",
+       "         [  101,  2203, 10085,  ...,     0,     0,     0],\n",
+       "         [  101,  3156,  1001,  ...,     0,     0,     0],\n",
+       "         [  101,  3156,  1001,  ...,     0,     0,     0]]),\n",
+       " 'token_type_ids': tensor([[0, 0, 0,  ..., 0, 0, 0],\n",
+       "         [0, 0, 0,  ..., 0, 0, 0],\n",
+       "         [0, 0, 0,  ..., 0, 0, 0],\n",
+       "         ...,\n",
+       "         [0, 0, 0,  ..., 0, 0, 0],\n",
+       "         [0, 0, 0,  ..., 0, 0, 0],\n",
+       "         [0, 0, 0,  ..., 0, 0, 0]]),\n",
+       " 'attention_mask': tensor([[1, 1, 1,  ..., 0, 0, 0],\n",
+       "         [1, 1, 1,  ..., 0, 0, 0],\n",
+       "         [1, 1, 1,  ..., 0, 0, 0],\n",
+       "         ...,\n",
+       "         [1, 1, 1,  ..., 0, 0, 0],\n",
+       "         [1, 1, 1,  ..., 0, 0, 0],\n",
+       "         [1, 1, 1,  ..., 0, 0, 0]])}"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "next(iter(dataloader))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "c8c18d3e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{0: 'RamPro 10\" All Purpose Utility Air Tires/Wheels with a 5/8\" Diameter Hole with Double Sealed Bearings (Pack of 2)',\n",
+       " 1: 'MaxAuto 2-Pack 13x5.00-6 2PLY Turf Mower Tractor Tire with Yellow Rim, (3\" Centered Hub, 3/4\" Bushings )',\n",
+       " 2: 'NEIKO 20601A 14.5 inch Steel Tire Spoon Lever Iron Tool Kit | Professional Tire Changing Tool for Motorcycle, Dirt Bike, Lawn Mower | 3 pcs Tire Spoons | 3 Rim Protector | Valve Tool | 6 Valve Cores',\n",
+       " 3: '2PK 13x5.00-6 13x5.00x6 13x5x6 13x5-6 2PLY Turf Mower Tractor Tire with Gray Rim',\n",
+       " 4: '(Set of 2) 15x6.00-6 Husqvarna/Poulan Tire Wheel Assy .75\" Bearing',\n",
+       " 5: 'MaxAuto 2 Pcs 16x6.50-8 Lawn Mower Tire for Garden Tractors Ridings, 4PR, Tubeless',\n",
+       " 6: 'Dr.Roc Tire Spoon Lever Dirt Bike Lawn Mower Motorcycle Tire Changing Tools with Durable Bag 3 Tire Irons 2 Rim Protectors 1 Valve Stems Set TR412 TR413',\n",
+       " 7: 'MARASTAR 21446-2PK 15x6.00-6\" Front Tire Assembly Replacement-Craftsman Mower, Pack of 2',\n",
+       " 8: '15x6.00-6\" Front Tire Assembly Replacement for 100 and 300 Series John Deere Riding Mowers - 2 pack',\n",
+       " 9: 'Honda HRR Wheel Kit (2 Front 44710-VL0-L02ZB, 2 Back 42710-VE2-M02ZE)',\n",
+       " 10: 'Honda 42710-VE2-M02ZE (Replaces 42710-VE2-M01ZE) Lawn Mower Rear Wheel Set of 2',\n",
+       " 11: 'Honda 44710-VG3-010 Front Wheels, (Set of 2)',\n",
+       " 12: 'Carlisle Turf Saver Lawn & Garden Tire - 15X6-6 A',\n",
+       " 13: 'Oregon 72-107 Universal Wheel 7X150 Diamond Plastic',\n",
+       " 14: 'American Lawn Mower Company 1204-14 14-Inch 4-Blade Push Reel Lawn Mower, Red',\n",
+       " 15: 'Craftsman 532403111 Mower Front Drive Wheels (Pack of 2)',\n",
+       " 16: 'BAZIC Security Self Seal Envelope 4 1/8\" x 9 1/2\" #10, No Window Tint Pattern Mailing Envelopes, Peel & Seal, Office Checks Invoices (30/Pack), 1-Pack',\n",
+       " 17: 'Quality Park #10 Self-Seal Security Envelopes, Security Tint and Pattern, Redi-Strip Closure, 24-lb White Wove, 4-1/8\" x 9-1/2\", 100/Box (QUA69117)',\n",
+       " 18: 'Quality Park #6 3/4 Security-Tinted Envelopes with Peel & Seal, 100-Pack, White – QUA10417',\n",
+       " 19: 'ValBox 500 Count #10 Security Self-Seal Envelopes Windowless Design Security Tint Pattern for Secure Mailing 4-1/8x9-1/2\" ,White Business Envelopes',\n",
+       " 20: 'ValBox #10 Security Envelopes Self Seal, No. 10 Windowless Security Tint Pattern, Secure Mailing Envelopes, 4-1/8x9-1/2 Inches, 24 LB White Business Envelopes, 200 Count',\n",
+       " 21: '50 Business Envelopes, Standard Flap (Multi Color Pack, 9.5\" x 4.125\")',\n",
+       " 22: 'ValBox 200 Count #8 Double Window Envelopes 3 5/8\" x 8 11/16\" Flip and Seal Double Window Security Check Envelopes- Security Tint Pattern Designed for Home Office Secure Mailing',\n",
+       " 23: 'BAZIC Self Seal White Envelope 3 5/8\" x 6 1/2\" #6, No Window Mailing Envelopes, Peel & Seal Mailer for Business Invoice Check (100/Pack), 1-Pack',\n",
+       " 24: '500 Self Seal Security Mailing Envelopes - #10 White Letter Businesses Envelopes -500 Peel and Seal Tinted Windowless # 10 Envelope - Printer Friendly - Self Stick Bulk Envelops',\n",
+       " 25: '#8 Double Window Security Check Envelopes, No.8 Double Window Bussiness Envelopes Designed for QuickBooks Checks - Computer Printed Checks - 3 5/8 X 8 11/16 (NOT for INVOICES) - 24 LB - 500 Count',\n",
+       " 26: '#10 Security Self-Seal Envelopes, No.10 Windowless Bussiness Envelopes, Security Tinted with Printer Friendly Design - Size 4-1/8 x 9-1/2 Inch - White - 24 LB - 500 Count',\n",
+       " 27: 'Xxcxpark 120 PCS #10 Self Seal Kraft 4-1/8 x 9-1/2 inches Security Envelopes, Windowless Invisible Envelopes Super Strong Quick Seal Envelopes Security Tint Pattern Secure Mailing',\n",
+       " 28: '500 #9 Security Self-Seal Envelopes, Premium Security Tint Pattern, Ultra Strong Quick-Seal Closure - No Window, EnveGuard, Size 3-7/8 x 8-7/8 Inches - White - 24 LB - 500 Count (30138)',\n",
+       " 29: 'Quality Park #8 Double Window Security Envelopes for QuickBooks Checks, Redi-Strip Self Seal Closure, 3 5/8 x 8 11/16, 24 lb White, 500/Box (QUA50766)',\n",
+       " 30: '500#10 Double Window Security Business Mailing Envelopes - Perfect Size for Multiple Business Statements, Quickbooks Invoices, and Return Envelopes - Number 10 Size 4-1/8 x 9-1/2 - White - 24 LB',\n",
+       " 31: '500#10 Single Left Window SELF Seal Security Envelopes, Designed for QuickBooks Invoices & Business Statements, Computer Printed Checks Peel and Seal Flap Number 10 Size 4-1/8 x 9-1/2 Inches, 24 LB',\n",
+       " 32: '#9 Double Window Envelopes, 8-7/8\" W x 3-7/8\" L, 24lb - 10 Pack',\n",
+       " 33: 'EnDoc 10x13 Open End Self Seal Envelopes - 15 Pack - White 28lb Heavyweight Paper, For Home, Mailing Documents, Office, Business, Legal, or School.',\n",
+       " 34: 'Ohuhu 500 Pack # 8 Double Window Envelope SELF SEAL Adhesive Tinted Security Envelopes Quickbooks Check, Business Check, Documents Secure Mailing, 3 5/8\" x 8 11/16\", White Envelope',\n",
+       " 35: 'Number 10 White Envelopes, Self-Seal, Security Tinted Envelope, no Moisture Required - Windowless - Ideal for Home, Office Secure Mailing - Quick-Seal Closure - 4-1/8 x 9-1/2 Inches - (100)',\n",
+       " 36: '9 X 12 Self-Seal Brown Kraft Catalog Mailing Envelopes - 28lb - 100 Count, 9x12 Inch (38300)',\n",
+       " 37: 'Mead Envelopes, Press-It Seal-It, 9\" x 12\", Self Adhesive, Office Pack, Brown Kraft, 25-Pack (76086)',\n",
+       " 38: 'BAZIC Self Seal White Envelope 4 1/8\" x 9 1/2\" #10, No Window Mailing Envelopes, Peel & Seal Mailer for Business Invoice Check (40/Pack), 1-Pack',\n",
+       " 39: 'BAZIC Security Self Seal Envelope 3 5/8\" x 6 1/2\" #6, No Window Tint Pattern Mailing Envelopes, Peel & Seal, Office Checks Invoices (55/Pack), 1-Pack',\n",
+       " 40: 'EnDoc 6x9 Envelopes - 28lb. Brown Kraft Paper Open-end 6 x 9 Inch Strong Gummed Glue Flap Closure Heavy Duty Catalog Envelope, For Legal, Home, Office, and Business - 500 Pack',\n",
+       " 41: 'Amazon Basics #10 Security Tinted Business Envelopes, Moisture Sealed, 4 1/8-Inch x 9 1/2 Inch - Pack of 500',\n",
+       " 42: 'Staples 511290 Self Seal Security Tinted #10 Envelope 4 1/8-Inch X 9 1/2-Inch White 500/Bx',\n",
+       " 43: '#10 Security Self-Seal Envelopes, Windowless Design, Premium Security Tint Pattern, Ultra Strong Quick-Seal Closure - EnveGuard - Size 4-1/8 x 9-1/2 Inches - White - 24 LB - 500 Count (34010)',\n",
+       " 44: '50 White A4 4x6 Photo Envelopes SELF SEAL - Fits 4 x 6 Photos, Invitations, Strong SELF-SEAL Closure, Size 4.5 x 6.25 Inch, 24lb, White, 50 Pack(36050)',\n",
+       " 45: '#10 Security Tinted Self-Seal Envelopes - No Window - EnveGuard, Size 4-1/8 X 9-1/2 Inches - White - 24 LB - 100 Count (34100)',\n",
+       " 46: 'Mead No.10 Envelopes, Security, Press-it Seal-it, 4-1/8\" X 9-1/2\", White, 45 Per Box (75026)',\n",
+       " 47: '500 No. 9 Double Window Security Envelopes - Designed for Quickbooks Invoices and Business Statements with Self Seal Peel and Seal Flap - Number 9 Size 3 7/8 Inch X 8 7/8 Inch',\n",
+       " 48: '500 No. 10 Self Seal Security Envelopes - 10 Envelopes Self Seal Designed for Secure Mailing - Security Tinted with Printer Friendly Design - Number 10 Size 4 1/8 x 9 ½ Inch - Pack of 500',\n",
+       " 49: '1099 MISC Tax Forms 2020, 4 Part Vendor Kit, Laser Forms for QuickBooks and Accounting Software, 25 Self Seal Envelopes',\n",
+       " 50: 'Amazon Basics #10 Security-Tinted Self-Seal Business Letter Envelopes, Peel & Seal Closure - 500-Pack, White',\n",
+       " 51: 'Staples 1775860 Reveal-N-Seal Security Tinted Dbl Window #8 5/8 Envelopes White 500/Bx',\n",
+       " 52: '500 No. 10 Security Envelopes - Gummed Flap - Tamper Proof Design - Security Tinted with Printer Friendly Design - Number 10 Size 4 1/8 x 9 ½ Inch - Pack of 500',\n",
+       " 53: '500#10 Security White Envelopes - GUMMED Seal, Windowless Design, Premium Security Tint Pattern for Secure Mailing - Size 4-1/8 x 9-1/2 Inches - White - 24 LB - 500 Count (34020)',\n",
+       " 54: '100 No. 10 Self Seal Security Envelopes - Designed for Secure Mailing - Security Tinted with Printer Friendly Design - Number 10 Size 4 1/8 x 9 ½ Inch (100 Pack)',\n",
+       " 55: 'EnDoc 10x13 Open End Self Seal Envelopes - Bright White 28lb Heavyweight Paper 10 x 13 Inches Envelope for Home, Mailing Documents, Office, Business, Legal or School - 35 Pack',\n",
+       " 56: 'Rarlan Wood-Cased #2 HB Pencils, Pre-sharpened, 200 Count Classpack',\n",
+       " 57: 'Wood-Cased #2 HB Pencils, Yellow, Pre-sharpened, Class Pack, 1000 pencils',\n",
+       " 58: 'Wood-Cased #2 HB Pencils, Yellow, Pre-sharpened, Class Pack, 320 pencils',\n",
+       " 59: 'Maped Essentials Triangular Graphite #2 Pencils, Pack of 12 (851779ZT)',\n",
+       " 60: '24 Pieces Checking Erasable Pencils Red Pencils Pre-Sharpened #2 HB with Erasable Tops for Checking Map Coloring Tests Grading',\n",
+       " 61: 'Wood-Cased #2 HB Pencils, Yellow, Pre-sharpened, Class Pack, 576 pencils in box by Madisi',\n",
+       " 62: 'Holographic Pencils with Erasers Metallic Assorted Colors Wooden Glitter Pencils Optical Illusion Pencils HB Pencils (36 Pieces)',\n",
+       " 63: 'BIC Xtra Fun Cased Pencil, 2 Lead, Assorted Barrel Colors, 48-Count',\n",
+       " 64: 'Color Changing Mood Pencil for Kid 2B Changing Pencil Assorted Color Thermochromic Pencils with Eraser for Students (30 Pieces)',\n",
+       " 65: 'AHXML#2 HB Wood Cased Graphite Pencils, Pre-Sharpened with Free Erasers, Smooth write for Exams, School, Office, Drawing and Sketching, Pack of 48',\n",
+       " 66: 'Wood-Cased #2 HB Pencils, Shuttle Art 600 Pack Sharpened Yellow Pencils with Erasers, Bulk Pack Graphite Pencils for School and Teacher Supplies, Writhing, Drawing and Sketching',\n",
+       " 67: 'Wood-Cased #2 HB Pencils, Shuttle Art 350 Pack Sharpened Yellow Pencils with Erasers, Bulk Pack Graphite Pencils for School and Teacher Supplies, Writhing, Drawing and Sketching',\n",
+       " 68: '12Packs #2HB Graphite Pencils,Pre-Sharpened with Latex Free Erasers,Wood-Cased Graphite Pencils Perfect for Exams, School, Office, Drawing and Sketching',\n",
+       " 69: 'HB pencils with eraser set 12 pack + 2 Erasers + 5 Sharpener,for School and Kids Writing pencil.(Green)',\n",
+       " 70: 'Weibo HB Wood Cased Graphite School Pencils, Pack of 12, Bulk, Pre-Sharpened with Erasers and Sharpener, Office Supplies for Exams, School, Office, Drawing and Sketching (Green)',\n",
+       " 71: 'Environmentally friendly black wood pencils, (30 pcs per barrel) triangle grip pen design, graphite HB lead core with eraser, suitable for children and adults to write sketches and paint',\n",
+       " 72: 'Neon Pencils for Kids HB Wood Pencil with Eraser\\xa0Fluorescent Colored Wood Pencils Colorful Round Pencils Writing Drawing Pencils School Student Reward Supplies (60)',\n",
+       " 73: 'BIC Evolution Cased Pencil, #2 Lead, Gray Barrel, 24-Count (PGEBP241-BLK)',\n",
+       " 74: 'YOTINO Pre-sharpened Wood Cased #2 HB Pencils - Box of 100',\n",
+       " 75: 'Emraw Pre Sharpened Triangular Primary Size No 2 Jumbo Pencils for Preschoolers, Elementary Kids - Pack of 6 Fat Pencils with Bonus Sharpener',\n",
+       " 76: 'Emraw No 2 HB Wood Cased Premium Pencils with Eraser Top, Bulk Pack of 24 Unsharpened Pencil - for Kids, Students, Teachers, Office and Home Use',\n",
+       " 77: 'Emraw Pre Sharpened Round Primary Size No 2 Jumbo Pencils for Preschoolers, Elementary Kids - Pack of 8 Premium Fat Pencils',\n",
+       " 78: 'TICONDEROGA Tri-Write Triangular Pencils, Standard Size Wood-Cased #2 HB Soft, Yellow, 8-Pack (13852)',\n",
+       " 79: 'TICONDEROGA Pencils, Wood-Cased, Unsharpened, Graphite #2 HB Soft, Yellow, 96-Pack (13872)',\n",
+       " 80: 'Ticonderoga Pencils, Wood-Cased Graphite #2 HB Soft, Yellow, 12-Pack (13882)',\n",
+       " 81: 'Ticonderoga Laddie Pencils, Wood-Cased #2 HB Soft with Eraser, Yellow, 12-Pack (13304), 11/32 inch',\n",
+       " 82: 'iScholar Gross Pack Pencils, #2, Yellow, Box of 144 (33144)',\n",
+       " 83: 'Ticonderoga Pencils, Wood-Cased, Graphite #2 HB Soft, Black, 24-Pack (13926)',\n",
+       " 84: 'Dixon No. 2 Yellow Pencils, Wood-Cased, Black Core, #2 HB Soft, 12-Count (14402)',\n",
+       " 85: \"Maped Black'Peps Triangular Graphite #2 Pencils, Pack of 12 (851749ZV)\",\n",
+       " 86: 'Ticonderoga Beginner Pencils, Wood-Cased #2 HB Soft, With Eraser, Yellow, 12-Pack (13308)',\n",
+       " 87: 'BIC Xtra-Fun Graphite Pencil, 2 Lead, 18-Count',\n",
+       " 88: 'Amazon Basics Woodcased #2 Pencils, Unsharpened, HB Lead - Box of 144, Bulk Box',\n",
+       " 89: 'Arteza HB Pencils #2, Pack of 48, Wood-Cased Graphite Pencils in Bulk, Pre-Sharpened, with Latex-Free Erasers, Office & School Supplies for Exams and Classrooms',\n",
+       " 90: 'BAZIC Pencil #2 HB Pencils, Latex Free Eraser, Wood Free Yellow Unsharpened Pencils for Exam School Office (12/Pack), 1-Pack',\n",
+       " 91: 'SKKSTATIONERY Half Pencils with Eraser Tops, Golf, Classroom, Pew - #2 HB, Hexagon, Pre-sharpened, 96/Box.',\n",
+       " 92: 'Emraw Pre Sharpened No 2 HB Wood Cased Premium Pencils with Eraser Top, Bulk Pack of 24 Pencil - For Professionals, Artists, Designers, Teachers',\n",
+       " 93: 'Emraw Pre Sharpened No 2 HB Wood Cased Pencils with Eraser Top, Bulk Pack of 24 Pencil - for Kids, Students, Teachers, Office and Home Use',\n",
+       " 94: 'Emraw Colorful Round No 2 HB Wood Cased Glitter Pencils with Eraser Top - Pack of 16 Unsharpened Sparkling Bright Pencils',\n",
+       " 95: 'Dixon Ticonderoga No.2 Pencils, Assorted Neon, 10-Pack',\n",
+       " 96: 'Waldeal Embroidered Mom Life Vintage Adjustable Baseball Cap Cotton Denim Dad Hat Black',\n",
+       " 97: 'ElegantPark Mom Life Tote Bag Mothers Day Baby Shower Gifts for New Mom Christmas Birthday Gifts for Mom Canvas Mom Tote Bag with Zipper and Pocket',\n",
+       " 98: 'Mom Life Car Decal- Pink, Mint Green, or White - Cute Sticker for Women - 6\" Size for Laptop or Window (White)',\n",
+       " 99: '#momlife | Trendy Mother Mom Life Gift PopSockets PopGrip: Swappable Grip for Phones & Tablets',\n",
+       " 100: \"Dearfoams Women's Giftable Mothers Day Furry Scuff Slipper, Mom Life, X-Large\",\n",
+       " 101: 'Women Mama Life Zip Up Pullover Sweatshirt Jacket \\xa0High Collar Quarter 1/4 Zip Hoodie Coat (White, M)',\n",
+       " 102: 'Life is Good Girls Vintage Crusher Graphic T-Shirt, Horses Coastal Blue, Large',\n",
+       " 103: \"Diliflyer Women's Mom Life Boys Girls Letters T Shirts Graphic Tees (XL, B-mom Life)\",\n",
+       " 104: 'Distressed Baseball Cap - Mom Life (Black)',\n",
+       " 105: \"Mom Life is Ruff T-Shirt Women's Funny Dog Paw O Neck Short Sleeve Tops Blouse Size Tag L\",\n",
+       " 106: 'Womens I Run On Coffee Chaos Cuss Words Funny V-Neck Short Sleeve Summer T-Shirt Size XL (Burgundy)',\n",
+       " 107: \"iChunhua Women's Comfy Stretch Floral Print Drawstring Palazzo Wide Leg Lounge Pants(M,Blue)\",\n",
+       " 108: 'LOOKFACE Women Funny Graphic T Shirt Cute Short Sleeve Tees Tops Wine Red Small',\n",
+       " 109: 'Garden of Life Oceans Mom Prenatal Fish Oil Dha, Omega 3 Fish Oil Supplement - Strawberry, 350Mg Prenatal Dha, Pregnancy Fish Oil Support For Moms Mood And Babys Brain & Eye Development, 30 Softgels',\n",
+       " 110: 'Mom, I Want to Hear Your Story: A Mother’s Guided Journal To Share Her Life & Her Love (Hear Your Story Books)',\n",
+       " 111: 'MACCHIASHINE Unique Sleeveless MOM Life Printed Shirt Womens Cotton Tank Tops(GR-XL) Green',\n",
+       " 112: 'BS-MALL Makeup Brush Set 18 Pcs Premium Synthetic Foundation Powder Concealers Eye shadows Blush Makeup Brushes with black case (Champagne Gold)',\n",
+       " 113: 'Little Bado Turtle Baby Bath Toys Spray Bathing Tub Fountain Toys for Kid Hand Shower Floating Bathtub Shower Pool Bathroom Toy for Baby Toddler Infant Kids',\n",
+       " 114: 'Bamyko Shower Body Brush with Long Handle Shower Brush Back Scrubber Body Brush Sponge Loofahs 2 Pack + Self Adhesive Hooks 2 PCS',\n",
+       " 115: 'Molton Brown Jasmine & Sun Rose Bath & Shower Gel, 10 Fl Oz',\n",
+       " 116: 'Chikoni Dry Bath Body Brush Back Scrubber with Anti-slip Long Wooden Handle, 100% Natural Bristles Body Massager, Perfect for Exfoliating, Detox and Cellulite, Blood Circulation, Good for Health',\n",
+       " 117: \"Upgraded Bath Body Brush with Comfy Bristles Long Handle Gentle Exfoliation Improve Skin's Health and Beauty Bath Shower Wet or Dry Brushing Body Brush (14 inch, White)\",\n",
+       " 118: 'Bath Scrubber Body Brush Shower Scrubber Back Brush with Long Handle, Ergonomic Nonslip Durable (Gray)',\n",
+       " 119: 'Foot Peel Mask 3 Pack， Exfoliator Peel Off Calluses Dead Skin Callus Remover，Baby Soft Smooth Touch Feet-Men Women (Lavender)',\n",
+       " 120: 'Dry Brushing Body Brush Set of 2, Natural Bristle Dry Skin Exfoliating Brush, Long Handle Back Scrubber for Shower, Dry Brush for Cellulite and Lymphatic Massage, Improve Blood Circulation',\n",
+       " 121: 'EcoTools EcoPouf Bath Brush, Shower Loofah with Ergonomic Handle, Cleans Hard to Reach Areas, Deep Cleansing and Exfoliating, Set of 2, Perfect for Men & Women',\n",
+       " 122: '2 IN 1 Bath Body Brush with Soft Loofah and Bristles,Back Scrubber with Curved Long Handled Shower Brush for Wet or Dry, Women & Men Body,Face and Spa Washing',\n",
+       " 123: 'LFJ 3 in 1 Back Bath Brush Set for Shower, 19\" Long Handle Body Brush, Bath Sponge and Pumice Gentle Exfoliation and Improved Skin Health, Suitable for Men and Women',\n",
+       " 124: 'Metene Shower Body Exfoliating Brush, Bath Back Cleaning Scrubber with Long Wooden Handle, Dry or Wet Skin Exfoliator Brush with Soft and Stiff Bristles Back Washer for Men Women',\n",
+       " 125: 'Metene Bamboo Body Brush with Stiff and Soft Natural Bristles, Back Scrubber for Shower with Long Handle, Dual-sided Brush Head for Wet or Dry Brushing, Exfoliating Skin and Clean the Body Easily',\n",
+       " 126: 'Peak Essentials | Tongue Scraper | Mint Blast - Natural TUNG Gel Kit | Tongue Cleaner | Odor Eliminator | Fight Bad Breath | Fresh Mint | BPA Free | Made in America (STARTER PACK)',\n",
+       " 127: 'YIVEKO Baby Bath Silicone Brush for Infants Cradle Cap Brush Silicone Bath Scrubber Skin Soother Baby Essential for Dry Skin, Cradle Cap and Eczema (1 Pack)-Blue',\n",
+       " 128: 'Theraplex Clear Lotion Spray (8 oz) - Natural Jojoba Oil, No Parabens or Preservatives, Noncomedogenic and Hypoallergenic, Dermatologist recommended - National Eczema Association Seal of Acceptance',\n",
+       " 129: 'Holikme 20Piece Drill Brush Attachments Set, Scrub Pads & Sponge, Buffing Pads, Power Scrubber Brush with Extend Long Attachment, Car Polishing Pad Kit',\n",
+       " 130: 'Exfoliating Brush, Body Brush, Ingrown Hair and Razor Bump Treatment - Eliminate Shaving Irritation for Face, Armpit, Legs, Neck, Bikini Line - Silky Smooth Skin Solution for Men and Women by Dylonic (1 Pack)',\n",
+       " 131: 'Dry Brushing Body Brush - Best for Exfoliating Dry Skin, Lymphatic Drainage and Cellulite Treatment - Organic Spa Exfoliator and Massage Scrub Brush with Natural Boar Bristles',\n",
+       " 132: 'Tecnu Extreme Poison Ivy and Oak Scrub, Removes Poisonous Plant Oils That Cause Rash and Itching, 4 Ounces',\n",
+       " 133: 'Amazon Basics Silicone, Non-Stick, Food Safe Baking Mat - Pack of 2',\n",
+       " 134: 'Aquasentials Exfoliating Mesh Brush',\n",
+       " 135: 'Neutrogena Sensitive Skin Mineral Sunscreen Lotion with Broad Spectrum SPF 60+ & Zinc Oxide, Water-Resistant, Hypoallergenic, Fragrance- & Oil-Free Gentle Sunscreen Formula, 3 fl. oz',\n",
+       " 136: 'SheaMoisture Curl and Shine Coconut Shampoo for Curly Hair Coconut and Hibiscus Paraben Free Shampoo 13 oz',\n",
+       " 137: 'Bio-Oil Skincare Oil, Body Oil for Scars and Stretchmarks, Serum Hydrates Skin, Non-Greasy, Dermatologist Recommended, Non-Comedogenic, For All Skin Types, with Vitamin A, E, 4.2 Fl Oz (Pack of 1)',\n",
+       " 138: 'Stardrops - The Pink Stuff - The Miracle All Purpose Cleaning Paste',\n",
+       " 139: 'Bar Keepers Friend Powder Cleanser 12 Oz - Multipurpose Cleaner & Stain Remover - Bathroom, Kitchen & Outdoor Use - for Stainless Steel, Aluminum, Brass, Ceramic, Porcelain, Bronze and More (2 Pack)',\n",
+       " 140: \"Dry Skin Body Brush - Improves Skin's Health and Beauty - Natural Bristle - Remove Dead Skin and Toxins, Cellulite Treatment, Improves Lymphatic Functions, Exfoliates, Stimulates Blood Circulation\",\n",
+       " 141: 'CSM Body Brush For Beautiful Skin - Solid Wood Frame & Boar Hair Exfoliating Brush To Exfoliate & Soften Skin, Improve Circulation, Stop Ingrown Hairs, Reduce Acne and Cellulite',\n",
+       " 142: 'Tea Tree & Peppermint Foot & Body Wash | Helps with Body Odor, Athletes Foot, Ringworm, Jock Itch, Yeast Infection & Skin Irritations | Shower Gel for Women/Men. Made by Purely Northwest 9Fl Oz',\n",
+       " 143: 'Vive Shower Brush - Dry Skin Body Exfoliator - Shower and Bath Scrubber For Wash Brushing, Exfoliating, Cellulite, Foot Scrub, Leg Exfoliant - Soft and Stiff Massage Bristles - Wooden Long Handle',\n",
+       " 144: 'Beaueli Bath Body Brush With Long Handle for Exfoliating Back Scrubber for Shower Cellulite Massager Exfoliation Dry or Wet Skin Brush Improve Lymphatic Stimulate Blood Circulation Detox',\n",
+       " 145: 'Jergens Natural Glow In Shower Lotion, Self Tanner for Medium to Deep Skin Tone, Sunless Tanning Wet Skin Lotion for Gradual, Flawless Color, 7.5 Ounce (Packaging May Vary)',\n",
+       " 146: 'Long Handled Loofah on a Stick Body Back Scrubber, Bath Sponge (4 Colors, 4 Pack)',\n",
+       " 147: 'TubShroom Tub Hair Catcher Drain Protector, Fits 1.5\"-1.75\", Gray',\n",
+       " 148: 'Lysol Laundry Sanitizer Additive, Crisp Linen, 90oz, Packaging May Vary',\n",
+       " 149: 'Majestic Pure Himalayan Salt Body Scrub with Lychee Oil, Exfoliating Salt Scrub to Exfoliate & Moisturize Skin, Deep Cleansing - 10 oz',\n",
+       " 150: 'Pumice Stone for Feet - X-Large Foot File Callus Remover for Feet, Foot Scrubber for Foot Care as Foot Exfoliator, Pedicure Tools for Foot Scrub, Callous Removers for Feet, Dead Skin Remover for Feet',\n",
+       " 151: 'Vive Lotion Applicator for Your Back (4 Pads) - Long Reach Handle with Sponge for Easy Self Application of Shower Bath Body Wash Brush, Skin Cream, Suntan, Tanning, Aloe - Men, Women',\n",
+       " 152: 'Skechers mens Cessnock Food Service Shoe, Black, 12 US',\n",
+       " 153: 'JSLEAP Mens Running Shoes Walking Non Slip Sports Fashion Casual Shoes Dark Green,US 9',\n",
+       " 154: \"Skechers Men's Relaxed Fit-Elent-Mosen Boat Shoe, Black, 11 M US\",\n",
+       " 155: \"Hey Dude Men's Wally Sox Ash, Size 10\",\n",
+       " 156: \"Xero Shoes Men's Prio Cross Training Shoe - Lightweight Zero Drop, Barefoot, Black, 11\",\n",
+       " 157: \"New Balance Men's 608 V5 Casual Comfort Cross Trainer, White/Navy, 10.5 W US\",\n",
+       " 158: \"New Balance Women's FuelCore Nergize V1 Sneaker, Black/Magnet, 9\",\n",
+       " 159: \"Skechers Men's GO Walk Evolution Ultra-Impeccable Sneaker, Khaki, 12 X-Wide\",\n",
+       " 160: \"Crocs Men's LiteRide Pacer Sneaker, Black/White, 9 M US\",\n",
+       " 161: 'Under Armour mens Charged Assert 8 Running Shoe Black (003)/Black 10.5',\n",
+       " 162: 'BRONAX Mens Fashion Sneakers Slip on Lightweight Street Trending Stylish Lace up Casual Walking Athletic Sport Shoes for Men Sapatos Tenis para Correr de Hombre Red Size 12',\n",
+       " 163: \"Skechers Men's Moreno Canvas Oxford Shoe, Taupe, 11.5 Medium US\",\n",
+       " 164: \"ASICS Men's Gel-Venture 7 Running Shoes, 10.5, Electric Blue/Sheet Rock\",\n",
+       " 165: \"Feetmat Men's Athletic Shoes Lightweight Sneaker Walking Tennis Slip On Shoes Wide Fashion Sneakers Barefoot Running Shoes Grey 11M\",\n",
+       " 166: \"Under Armour Men's Charged Pursuit 2 Running Shoe, Black (001)/White, 10 M US\",\n",
+       " 167: 'COSIDRAM Men Casual Shoes Sneakers Loafers Walking Shoes Lightweight Driving Business Office Slip on Black 11',\n",
+       " 168: \"ASICS Men's Hyper Throw 3 Track & Field Shoes, 15, Black/White\",\n",
+       " 169: \"ECCO Men's ST.1 Hybrid Plain Toe Oxford, Cognac, 9-9.5\",\n",
+       " 170: \"Skechers Men's Go Walk Max-Athletic Air Mesh Slip on Walkking Shoe Sneaker,Navy/Gray,10 X-Wide US\",\n",
+       " 171: \"Skechers Men's Classic Fit-Delson-Camden Sneaker, Black/Grey, 10 Wide US\",\n",
+       " 172: \"adidas Men's Lite Racer Adapt Running Shoe, Black/White, 12 M US\",\n",
+       " 173: \"adidas Women's Cloud foam Pure Running Shoe, White/White/Black, 6.5 US\",\n",
+       " 174: \"Crocs Unisex-Adult Men's and Women's Classic Clog, Black, 9\",\n",
+       " 175: \"Nike Men's Air Force 1 '07 Shoes 315122 White/White 10.5\",\n",
+       " 176: \"New Balance Men's 577 V1 Hook and Loop Walking Shoe, Black, 13 M US\",\n",
+       " 177: \"Nike Men's Air Monarch IV Cross Trainer, Black/Black, 12.0 Regular US\",\n",
+       " 178: \"Fila Men's Memory Workshift-M, Black/Black/Black, 8.5 M US\",\n",
+       " 179: \"Skechers for Work Men's Felton Shoe, Black, 13 M US\",\n",
+       " 180: \"New Balance Men's 813 V1 Lace-Up Walking Shoe, Black/Black, 13 XXW US\",\n",
+       " 181: \"Skechers Sport Men's Equalizer Persistent Slip-On Sneaker, Black, 10 XW US\",\n",
+       " 182: 'Skechers mens Afterburn M. Fit fashion sneakers, Black, 8.5 US',\n",
+       " 183: \"adidas Originals Men's Seeley Running Shoe, Black/Black/Black, 10 M US\",\n",
+       " 184: \"Skechers USA Men's Braver Rayland Slip-On Loafer,Dark Brown Leather,13 M US\",\n",
+       " 185: \"Skechers USA Men's Expected Gomel Slip-on Loafer,Black,9.5 2W US\",\n",
+       " 186: \"Skechers for Work Women's Ghenter Bronaugh Work and Food Service Shoe , BLACK, 8.5 W US\",\n",
+       " 187: \"ASICS Men's Gel-Venture 6 Black/Phantom/Mid Grey Running Shoe 10 M US\",\n",
+       " 188: \"Hey Dude Men's Wally Stretch Blue, Size 12\",\n",
+       " 189: \"ASICS Men's Gel Venture 5 Trail Running Shoe, Castle Rock/Silver/Fiery Red, 10 M US\",\n",
+       " 190: \"Skechers Men's Equalizer Double Play Slip-On Loafer,Charcoal/Orange,9 M US\",\n",
+       " 191: 'New Balance mens 928 V3 Hook and Loop Walking Shoe, Black/Black, 10 XX-Wide US',\n",
+       " 192: 'BiFanuo 2 in 1 Folding Treadmill, Smart Walking Running Machine with Bluetooth Audio Speakers, Installation-Free，Under Desk Treadmill for Home/Office Gym Cardio Fitness（Red）',\n",
+       " 193: 'Egofit Walker Pro Smallest Under Desk Electric Walking Treadmill for Home, Small & Compact Treadmill to Fit Desk Perfectly and Home & Office with APP & Remote Contro',\n",
+       " 194: 'ANCHEER Treadmill,Folding Treadmill for Home Workout,Electric Walking Under Desk Treadmill with APP Control, Portable Exercise Walking Jogging Running Machine (Silver)',\n",
+       " 195: 'Soiiw Walking Pad Treadmill Electric Under Desk Smart Slim Fitness Jogging Training Cardio Workout with LED Display & Wireless Remote Control for Home Office',\n",
+       " 196: 'HOTSYSTEM 2 in 1 Installation-Free Folding Treadmill, 2.5HP Portable Under Desk Treadmill with Bluetooth, LED, Remote Control Smart Treadmill for Home Office Cardio Exercise',\n",
+       " 197: 'Goplus 2 in 1 Folding Treadmill, 2.25HP Under Desk Electric Superfit Treadmill, Installation-Free with APP Control, Remote Control, Bluetooth Speaker and LED Display, Jogging Walking for Home/Office',\n",
+       " 198: 'Goplus 2 in 1 Folding Treadmill, 2.25HP Superfit Under Desk Electric Treadmill, Installation-Free with Blue Tooth Speaker, Remote Control, APP Control and LED Display, Walking Jogging for Home Office',\n",
+       " 199: 'RHYTHM FUN Treadmill 2-in-1 Folding Treadmill Under Desk Walking Treadmill with Foldable Handrail Wide Tread Belt Super Slim Mini Quiet Home Treadmill with Smart Remote Control and Workout App（Sliver）',\n",
+       " 200: 'NordicTrack T Series Treadmill + 30-Day iFIT Membership',\n",
+       " 201: 'Goplus 2 in 1 Folding Treadmill with Dual Display, 2.25HP Superfit Under Desk Electric Pad Treadmill, Installation-Free, Blue Tooth Speaker, Remote Control, Walking Jogging Machine for Home/Office Use',\n",
+       " 202: 'Goplus Under Desk Treadmill, with Touchable LED Display and Wireless Remote Control, Built-in 3 Workout Modes and 12 Programs, Walking Jogging Machine, Superfit Electric Treadmill for Home Office',\n",
+       " 203: 'WalkingPad A1 Pro Smart Walk Folding Treadmill Slim Foldable Exercise Fitness Equipment Under Desk Running Walking Pad Outdoor Indoor Gym',\n",
+       " 204: 'SUNNY HEALTH & FITNESS ASUNA Space Saving Treadmill, Motorized with Speakers for AUX Audio Connection - 8730G',\n",
+       " 205: 'UMAY Under Desk Treadmill with Foldable Wheels, Portable Walking Pad Flat Slim Treadmill with Free Sports App & Remote Control, Jogging Running Machine for Home/Office',\n",
+       " 206: 'Sunny Health & Fitness SF-T1407M Foldable Manual Walking Treadmill, Gray',\n",
+       " 207: 'GOYOUTH 2 in 1 Under Desk Electric Treadmill Motorized Exercise Machine with Wireless Speaker, Remote Control and LED Display, Walking Jogging Machine for Home/Office Use',\n",
+       " 208: 'Self Seal Double Window Security Envelopes (#10 - Box of 500), for Invoices, Statements and Legal Documents (4 1/8\" x 9 1/2\")',\n",
+       " 209: '500 No. 8 Flip and Seal Double Window Security Check Envelopes - Designed for Quickbooks Printed Checks - Number 8 Size 3 5/8 Inch x 8 11/16 Inch',\n",
+       " 210: 'CheckSimple Personalized #10 Self-Seal Standard Mailing Envelopes - (500 Envelopes) Custom Non-Window',\n",
+       " 211: 'Office Deed 500#10 Envelopes SELF SEAL Business Envelope Windowless Design, Security Tint Pattern for Secure Mailing, Invoices, Statements & Legal Document, 4-1/8 x 9-1/2 Inches',\n",
+       " 212: 'Office Deed 500#10 Envelopes SELF SEAL Business Envelope Single Window Design, Security Tint Pattern for Secure Mailing, Invoices, Statements & Legal Document, 4-1/8 x 9-1/2 Inches',\n",
+       " 213: \"Office Deed 500 #9 Double Window SELF SEAL Security Envelopes-Designed for Quickbooks Invoices and Business Statements with peel and seal flap -3 7/8'' X 8 7/8''\",\n",
+       " 214: 'Office Deed 500 #10 Self Seal Double Window Security Envelopes-Designed for Business Statements, Quickbooks Invoices, and Return Envelopes 4 1/8 X 9 ½’’',\n",
+       " 215: '50 Pack #10 Self-Seal Business Envelopes, 4-1/8 X 9-1/2 Inches, Square Flap Envelopes with Peel & Seal, Kraft, No Window, 50 Count.',\n",
+       " 216: '500#8 Double Window Self Seal Security Envelopes - for Business Checks, QuickBooks & Quicken Checks, Size 3 5/8 x 8 11/16 Inches - Checks Fit Perfectly - Not for Invoices, 500 Count(30180)',\n",
+       " 217: '50 W2 Envelopes, Self Seal, Double Window Security Envelopes Designed for Printed W2 Laser Forms from QuickBooks Desktop and Other Tax Software, 5 5/8’’ x 9’’, 50 Form Envelopes',\n",
+       " 218: 'Box of 500 Number 8 Envelopes, Size fits QuickBooks Printed Checks, Double Window Security Check Envelope, Flip and Seal, Measures 3-5/8 inch x 8-11/16 inches',\n",
+       " 219: 'ValBox 500 Count #10 Double Window Envelopes 4-1/8x9-1/2\" Self Seal Security Envelopes for QuickBooks Invoices, Business Statements and Legal Documents',\n",
+       " 220: '500 No. 9 Flip and Seal Double Window Security Envelopes - Designed for Quickbooks Invoices and Business Statements with Self Seal Flip Press and Seal Flap -Number 9 Size 3 7/8 Inch X 8 7/8 Inch',\n",
+       " 221: '500 #9 Single Window Security Envelopes, Thick Gummed Seal, Designed for Secure Mailing of Payroll Checks, QuickBooks Invoices, Return Mail, and Business Statements - 3 7/8 x 8 7/8',\n",
+       " 222: '500#10 Single Window Envelopes-Thick Gummed Seal-Designed for Secure mailing of Quickbooks Checks, invoices, Business Statements, Personal Letters - 4 1/8 x 9 1/2',\n",
+       " 223: 'Quality Park Redi-Seal Security Window Envelopes, 10 (4 1/8\" x 9 1/2\"), White, Box of 500',\n",
+       " 224: '500 Gummed Double Window Security Check Envelopes - Designed for QuickBooks Checks - Computer Printed Checks - Gummed Flap - 3 5/8 X 8 11/16',\n",
+       " 225: 'Quality Park Redi-Seal Double-Window Security Envelopes, 10, 4 1/8\" x 9 1/2\", White, Box of 500',\n",
+       " 226: 'BAZIC #10 Self-Seal White Envelope (50/Pack)',\n",
+       " 227: 'Check O Matic Double Window Security Tinted Envelopes - Compatible for QuickBooks Checks and for Computer Printed Checks, 3-5/8 X 8-11/16 Inches - 100 Pack',\n",
+       " 228: '100 Self Seal Double Window Security Tinted Envelopes - for Computer Checks-Compatible for QuickBooks 3-5/8 X 8-11/6',\n",
+       " 229: '500 Self Seal QuickBooks Double Window Security Check Envelopes - for Business Laser Checks, Ultra Security Tinted, Self Adhesive Peel & Seal White, Size 3 5/8 x 8 11/16-24lb NOT for INVOICES',\n",
+       " 230: '500 Double Window Check Envelopes Self Seal with Security Tint Works with all Software',\n",
+       " 231: 'EnDoc #10 Double Window Envelopes - 50 Pack - Self Seal, Flip and Seal Security Tinted Envelopes, Can be used for Invoices, Statement and for Return Envelopes - 9 1/8\" X 4 1/8\"',\n",
+       " 232: '100 Double Window SELF Seal Security Check Envelopes - Compatible with QuickBooks and Other Checks',\n",
+       " 233: '500 No. 10 Flip and Seal Double Window Security Envelopes - Perfect Size for Multiple Business Statements, Quickbooks Invoices, and Return Envelopes -Number 10 Size 4 1/8 X 9 ½ Inch',\n",
+       " 234: '550 SELF Seal Double Window Security Envelopes - Designed for QuickBooks Checks, Business Checks, and Computer Checks - Security Tinted - Peel & Seal - 3 5/8” x 8 11/16” - 24 LB (NOT for INVOICES)',\n",
+       " 235: '#9 Double Window SELF SEAL Security Envelopes - 550 Per Box - Designed for QuickBooks Invoices, Business Correspondence, and Legal Documents - Security Tinted - Peel & Seal - 3 7/8\" x 8 7/8\" - 24 LB',\n",
+       " 236: '500 Self Seal Double Window Security Envelopes - Designed for QuickBooks Checks - Computer Printed Checks - 3 5/8 X 8 11/16 (NOT for INVOICES)',\n",
+       " 237: '500 No. 10 Self Seal Double Window Security Envelopes - Perfect Size for Multiple Business Statements, Quickbooks Invoices, and Return Envelopes - Number 10 Size 4 1/8 Inch X 9 ½ Inch',\n",
+       " 238: '500 No. 10 Gummed Double Window Security Envelopes - Perfect Size for Multiple Business Statements, Quickbooks Invoices, and Return Envelopes - Number 10 Size 4 1/8 X 9 ½ Inch',\n",
+       " 239: '500#10 Double Window Security Business Mailing Envelopes - for Invoices, Statements and Legal Documents - GUMMED Closure, Security Tinted - Size 4-1/8 x 9-1/2 - White - 24 LB - 500 Count (30101)',\n",
+       " 240: 'Aimoh #10 Single Left Window Envelopes -Gummed Closure -Size 4-1/8x9-1/2 Inches -24LB-500 Count(35410)',\n",
+       " 241: '500 Number 10 Single Window Envelopes - Thick Gummed Seal - Designed for Secure Mailing of Quickbooks Checks, Invoices, Business Statements, Personal Letters - 4 1/8 x 9 1/2',\n",
+       " 242: 'Acko #10 500Pack Double Window Envelopes Quickly Self-Seal Envelopes 4 1/8 x 9 1/2,Security Tint Pattern Designed for Home Office Secure Mailing,Letters and Invoices - White Envelopes 500 Count',\n",
+       " 243: '#10 Single Left Window Security Tinted Envelopes, Gummed Closure, Size 4-1/8 X 9-1/2 inches, 24 LB - 500 Count (35310)',\n",
+       " 244: 'Amazon Basics #9 Envelopes with Peel & Seal, Double Window, Security Tinted, 500-Pack',\n",
+       " 245: '500 Self Seal Number 10 Single Right Window Envelopes - Security Lining - Designed for Secure Mailing of Invoices, Documents, and Business Statements, 4 1/8 x 9 1/2 Inches, 500 Ct',\n",
+       " 246: '100 Cashier Depot #10 Business Envelope, Peel & Seal, Security-Tinted, 24lb. White Paper, 100 Envelopes (Left Window)',\n",
+       " 247: 'Clear Plastic Small Blank Envelope Pouch for Packing List - Return Label (Not for standard shipping labels) , Documents Keeps Paper Safe While Shipping Size 4” x 6” by MT Products (100 Pieces)',\n",
+       " 248: 'Sooez 10 Pack Plastic Envelopes Poly Envelopes, Clear Document Folders US Letter A4 Size File Envelopes with Label Pocket & Snap Button for School Home Work Office Organization, Clear',\n",
+       " 249: 'Blue Summit Supplies 500#10 Single Window Security Envelopes Flip and Seal, Designed for QuickBooks Invoices and Business Statements, Number 10 Size 4 1/8” X 9 1/2”, 500 Pack',\n",
+       " 250: '500 #10 Double Window SELF Seal Security Envelopes - for Invoices, Statements & Documents, Security Tinted - EnveGuard, Size 4-1/8 x 9-1/2 -White - 24 LB - 500 Count (30001)',\n",
+       " 251: 'Sooez 10 Pack Plastic Envelopes Poly Envelopes, Clear Document Folders US Letter A4 Size File Envelopes with Label Pocket & Snap Button for Home Work Office Organization, 5 Assorted Colors',\n",
+       " 252: 'Amazon Basics #9 Double Window Security Tinted Envelopes, White, 500 ct',\n",
+       " 253: 'EnDoc 9x12 Full Face Window Envelopes - 28lb. Bright White 9 x 12 Inches Envelope, With a nice Clear Full window - 55 Pack',\n",
+       " 254: '500#10 Single Left Window SELF Seal Security Envelopes - Super Strong Quick-Seal Self Sealing Closure, Security Tinted, Size 4-1/8 x 9-1/2 Inches, 24 LB - 500 Count (35210)',\n",
+       " 255: '500#9 Double Window SELF Seal Security Envelopes - for Invoices, Statements & Documents, Security Tinted - Size 3-7/8 x 8-7/8-24 LB - 500 Count (30139)',\n",
+       " 256: '500 No. 10 Self Seal Single Window Security Envelopes -Designed for QuickBooks Invoices and Business Statements - Computer Printed Checks with Strong Peel and Seal Flap - Number 10 Size 4 1/8 X 9 1/2',\n",
+       " 257: 'Amazon Basics #10 Security-Tinted Self-Seal Business Envelopes with Left Window, Peel & Seal Closure - 500-Pack, White',\n",
+       " 258: 'EnDoc #10 Colored Envelopes - Bright Lime Color - 24lb paper Colored envelopes letter size for Offices, Holiday, Invoices, Mailings - 4 1/8 x 9 1/2 Inches - 50 Pack',\n",
+       " 259: 'Liquid I.V. Hydration Multiplier - Lemon Lime - Hydration Powder Packets | Electrolyte Drink Mix | Easy Open Single-Serving Stick | Non-GMO',\n",
+       " 260: 'Nordic Naturals Ultimate Omega, Lemon Flavor - 1280 mg Omega-3-210 Soft Gels - High-Potency Omega-3 Fish Oil with EPA & DHA - Promotes Brain & Heart Health - Non-GMO - 105 Servings',\n",
+       " 261: 'Liquid I.V. Hydration Multiplier - Passion Fruit - Hydration Powder Packets | Electrolyte Drink Mix | Easy Open Single-Serving Stick | Non-GMO',\n",
+       " 262: 'HARRIS Diatomaceous Earth Food Grade, 5lb with Powder Duster Included in The Bag',\n",
+       " 263: 'Probiotics 60 Billion CFU - Probiotics for Women, Probiotics for Men and Adults, Natural, Shelf Stable Probiotic Supplement with Organic Prebiotic, Acidophilus Probiotic',\n",
+       " 264: 'JETech Screen Protector for iPhone 11 Pro, for iPhone Xs, for iPhone X, 5.8-Inch, Tempered Glass Film, 2-Pack',\n",
+       " 265: 'HARRIS Diatomaceous Earth Food Grade, 10lb with Powder Duster Included in The Bag',\n",
+       " 266: 'Retinol Complex Face Serum - 1oz from Naturium',\n",
+       " 267: 'Thyroid Support Supplement\\xa0with Iodine\\xa0- Energy & Focus Formula - Vegetarian\\xa0& Non-GMO\\xa0- Vitamin B12 Complex, Zinc, Selenium, Ashwagandha, Copper, Coleus Forskohlii, & More 30 Day Supply',\n",
+       " 268: 'Mrs. Wages Pickling Lime (1-Pound Resealable Bag)',\n",
+       " 269: 'Nature Made Melatonin 3 mg with 200 mg L-theanine Softgels, 60 Count for Supporting Restful Sleep',\n",
+       " 270: 'Nature Made Melatonin 5 mg, For Restful Sleep, 90 Tablets, 90 Day Supply',\n",
+       " 271: 'Nature Made Melatonin 3 mg, Sleep Aid Supplement for Restful Sleep, 240 Tablets, 240 Day Supply',\n",
+       " 272: 'X-ACTO X-Life #11 Classic Fine Point Blades, Bulk Pack, 100 Blades per Box (X611),Silver',\n",
+       " 273: 'My Weird School #11: Mrs. Kormel Is Not Normal!',\n",
+       " 274: 'My Weird School Special: Back to School, Weird Kids Rule!',\n",
+       " 275: 'American Football Rugby Athletes Jersey Number 12 Stainless Steel Pendant Necklace for Boys Girls Women Men 24 Inch Chain',\n",
+       " 276: 'Photographer Gift Inspiration Gift Pendant Necklace Dog Tag Jewelry Keychain',\n",
+       " 277: \"Viking Jewelry Vegvísir wayfinder Guidepost Compass Odin Celtic Pagan Pewter Men's Pendant Necklace Safe Travel Talisman Protection Amulet Wealth Money Lucky Fortune Good Luck Charm Silver Ball Chain\",\n",
+       " 278: 'GoldChic Jewelry Black Baseball Jersey Number 2 Charms Pendant Necklace with Chain 22+2\"',\n",
+       " 279: 'Softball Dog Tag Necklaces Engraved Number Jewelry Personalized Custom Baseball Tags Pendants Dogtag Mens Black Necklace',\n",
+       " 280: 'TLIWWF Inspiration Baseball Jersey Number Necklace Stainless Steel Charms Number Pendant for Boys Men (10)',\n",
+       " 281: 'Kumshunie Baseball Bats Cross Necklace with Number Stainless Steel Charm Sports Pendant Gift for Men 34',\n",
+       " 282: 'U7 Youth Baseball Necklace 4mm Cuban Link Chain Inspirational Pendant Football Chains Jersey Number 3 Necklaces for Boys Men',\n",
+       " 283: 'RWQIAN Baseball Cross Necklaces Baseball Necklace with Number 33 Sports Stainless Steel Baseball Bat Cross Pendant Chain Baseball Fans Jewelry Gift',\n",
+       " 284: 'Nary Mom Keychain I Once Protected Him Now He Protects Us All Mom Military Mom Jewelry Gifts for Navy Mom',\n",
+       " 285: 'Baseball Gifts Necklace for Men Mens Number 5 Pendant Stainless Steel Chain',\n",
+       " 286: 'Number 12 Baseball Necklace Sports Fans Softball Gifts for Boys Men Teens Stainless Steel Pendant Jewelry 22 Inch Box Chain',\n",
+       " 287: 'SEIRAA Hairdresser Gift Hair Stylist Jewelry Hair Cutter Barber Keychain Jewelry (Hairdresser keychain)',\n",
+       " 288: 'Baseball Rope Necklaces For Boys Men Youth Baseball Gear Baseball Softball Gifts Beisbol Accessories Paracord Braided Necklace Titanium Tornado Necklace Neon Blue Black White',\n",
+       " 289: '00-99 Custom Number Pendant With Chain Necklace - Stainless Steel (00)',\n",
+       " 290: 'NanMuc Number #3 Baseball Initial Pendant Necklace Inspiration Baseball Jersey Charms Stainless Steel Necklace',\n",
+       " 291: 'Chris Johnsons 3 Number Necklace, Baseball Number Necklace, Football Number Necklace Sterling Silver Pendant Chain',\n",
+       " 292: 'PROSTEEL Baseball Cross Necklace for Boys Men Necklaces Baseball Number Necklace Stainless Steel Chain Mens Necklace Baseball Chain Black Chain',\n",
+       " 293: 'Initial Necklaces for Teen Girls Boys Son Daughter Sister Brother 18K Gold Figaro Chain Link Letter G Personalized Name Handmade Cute Dainty Stainless Steel Jewelry Unique Fancy Birthday Gifts',\n",
+       " 294: '.925 Sterling Silver Customizable Sports Jersey Lucky Number and Name Pendant Charm with Personalized Engraving - Comes with 16\" Rolo Chain',\n",
+       " 295: 'HZMAN Baseball Initial Pendant Necklace Inspiration Baseball Jersey Number 0-9 Charms Stainless Steel Necklace',\n",
+       " 296: '3MM 18k Real Gold Plated Black Square Rolo Chain Stainless Steel Round Box Chain Necklace Men Women Jewelry',\n",
+       " 297: 'MadSportsStuff Custom Player ID Softball Necklace (#6, One Size)',\n",
+       " 298: 'Rectangle Transgender Flag Charm Necklace (1 Necklace)',\n",
+       " 299: 'Train Charm Necklace | Train Pendant on a 22 inch Stainless Steel Snake Chain Necklace for Train Lover Gifts and Gifts for Train Lovers Great for Train Party Favors and Train Birthday Decorations',\n",
+       " 300: 'HZMAN Baseball Cross Pendant, I CAN DO ALL THINGS STRENGTH Bible Verse Stainless Steel Necklace (Black)',\n",
+       " 301: 'Baseball Stainless Steel Cross Pendant Necklace for Boy or Men With 20+2\" Adjustable Chain Black Bible Verse on Back',\n",
+       " 302: 'XIEXIELA Baseball Cross Pendant. I CAN DO All Things Strength Bible Verse Stainless Steel Necklace for Men Boy Cell Phone Holder Silver',\n",
+       " 303: 'Boys Mens Baseball Cross Pendant Necklace 18K Gold Plated Bible Verse Stainless Steel Necklace Jewelry (A-Black)',\n",
+       " 304: 'Baseball Athletes Jersey Number 2 Cross Pendant Necklace for Boys Girls Women Men 24 Inch Stainless Steel Chain PHILIPPIANS 4:13 on back I CAN DO ALL THINGS',\n",
+       " 305: 'Starmond Baseball Cross Necklace for men: I CAN DO All Things Strength Bible Verse Stainless Steel 24 inch Chain (Steel)',\n",
+       " 306: 'Lightning Bolt Necklace - Silver Thunder Bolt Pendant - Silver Lightning Strike Charm - Long Layering - Trendy Celebrity Jewelry - Bolt',\n",
+       " 307: \"JACKY STORE Necklace for Black Panther Cosplay Men Boys Wakanda King T'Challa Stainless Steel Choker Necklace(Silver)\",\n",
+       " 308: 'CHOORO Piano Keyboard Pendant Keychain Piano Zipper Pull Music Jewelry Gift for Pianist/Piano Teacher/Music Lovers (Necklace)',\n",
+       " 309: 'Bandmax Stainless Steel Black Plated Rainbow LGBT Gay Pride Cylindrical Pendant Necklace Jewelry Personalized Metal Parade Friendship,Love,Inspiration Necklace for Women Men with 22inch Chain',\n",
+       " 310: \"EunWow Anchor Pirate Black Chain Rocker Cool Nautical Gifts for Men Jewelry Vintage Included 22'Chain\",\n",
+       " 311: 'Fusamk Punk Rapper Stainless Steel Skull Head Pendant Necklace,22\" Link Chain',\n",
+       " 312: 'RMOYI Baseball Bats Stainless Steel Cross Necklace for Men Women Boys Girls,Black 24 Inches',\n",
+       " 313: 'Baseball Necklace ,Men Sports Youth Baseball Necklace for mens Stainless Steel Baseball Bat Necklace Athletes Jewelry Gift,Silver 20 inches',\n",
+       " 314: 'Serenity Prayer AA Recovery Necklace Keychain Serenity Courage Wisdom Sobriety Gift (Necklace S)',\n",
+       " 315: 'PH PandaHall 150pcs 15 Styles Tree Leaf Charms Pendants, Tibetan Branch Leaves Charms Beads for DIY Earring Bracelet Necklace Jewelry Making, Antique Bronze',\n",
+       " 316: 'OLYCRAFT 20pcs Cage Theme Open Bezel Charms 10-Style Acrylic Frame Pendants Hollow Resin Frames with Loop for Resin Jewelry Making - Black',\n",
+       " 317: 'EFYTAL 15th Birthday Gifts for Her, Girls 925 Sterling Silver Bracelet, 15 Beads for 15 Year Old Girl, Quinceanera Gift',\n",
+       " 318: '100PCS Mixed Style Random Transmission Antique Silver Round Shape 26 Alphabet English Letters Charm Pendant Bracelets Necklace Jewelry Findings Jewelry Making Craft DIY 15x12mm (a-1078)',\n",
+       " 319: 'Pandora Jewelry Friends Are Family Dangle Sterling Silver Charm',\n",
+       " 320: 'Happy Birthday Bangles, Cake Cheer Live Laugh Love Charms Bangle Bracelets, Gifts For Her (15th Birthday)',\n",
+       " 321: 'Elegant Sterling Silver Quinceanera Open Heart Charm Pendant with Cubic Zirconia',\n",
+       " 322: \"Beadthoven 100pcs 9/16''Inch 304 Stainless Steel Blank Stamping Tag Pendants for Bracelet Earring Pendant Flat Round Charms 15x1mm\",\n",
+       " 323: 'Sexy Sparkles Number, Birthday Birthstone, Anniversary Clip on Pendant Charm for Bracelet or Necklace (15 Clip On)',\n",
+       " 324: 'PANDORA Jewelry Black Leather Charm Sterling Silver Bracelet, 15.0\"',\n",
+       " 325: 'FashionJunkie4Life Sterling Silver Number 15 Fifteen Charm Necklace, 18\" Chain, Birthday Quinceañera',\n",
+       " 326: 'Pandahall 200pcs Assorted Alphabet Charm Pendant Loose Beads Silver Plated A-Z Letter Pieces, 12-17x4-15x2mm',\n",
+       " 327: 'Alex and Ani October Birth Month Charm with Swarovski Crystal Rafaelian Gold Bangle Bracelet',\n",
+       " 328: 'Alex and Ani Path of Symbols A17EB05RG Expandable Bangle for Women, Love Charm, Rafaelian Gold Finish, 2 to 3.5 in',\n",
+       " 329: 'Alex and Ani A16EB101RG Guardian Angel Expandable Wire Gold Bangle Charm Bracelet',\n",
+       " 330: 'PANDORA Mickey and Minnie Vintage Car 797174',\n",
+       " 331: 'Hex Pencils (Full Size Hex Pencil with #2 Lead Available in a Variety of Colors) (Tested Non Toxic) (Latex Free Eraser) (Classroom Pencils) (Bulk Box of 144) (Matte Black)',\n",
+       " 332: 'Amazon Basics Woodcased #2 Pencils, Pre-sharpened, HB Lead, Box of 30',\n",
+       " 333: 'TICONDEROGA Pencils, Wood-Cased #2 HB Soft, Pre-Sharpened with Eraser, Yellow, 6-Pack/ 180 count (13806)',\n",
+       " 334: 'DIXON Oriole #2 Soft Pencils with Erasers, Pre-Sharpened, 6 Boxes of 12, 72 Pencils Total (12886SP)',\n",
+       " 335: 'Madisi Golf Pencils, 2 HB Half Pencils, 3.5\" Mini Pencils, Pre-Sharpened, 144 Count',\n",
+       " 336: 'Crayola Number 2 Pencils, Back To School Supplies, 12ct Wooden Pencils',\n",
+       " 337: '#2 HB Wood Cased Pencils, Pre-Sharpend Graphite Pencils, With Latex-Free Erasers, Bulk Buy - Smooth Writing for Exams, School, Office, Drawing, Sketching - 144 PACK',\n",
+       " 338: 'Ticonderoga Neon Pencils, #2 Pre-Sharpened Wood Pencils with Erasers, 18-Count, 13018',\n",
+       " 339: \"S & E TEACHER'S EDITION Half Pencils with Eraser Tops 96Pcs, Golf, Classroom, Pew - #2 HB, Hexagon, 96/Box.\",\n",
+       " 340: 'Rarlan Golf Pencils, 2 HB, Pre-Sharpened, 320 Count Classpack',\n",
+       " 341: 'Muousco Colored Pencils for Adult Premium Artist Colored Pencil Set (72-Count), Handmade Canvas Pencil Wrap, Extra Accessories Included, Holiday Gift, Oil based Colored Pencil',\n",
+       " 342: 'Amazon Basics Heavy Duty Dry Erase Ticket Holder Pockets 8.5\" X 11\", Pack of 25 & Woodcased #2 Pencils, Pre-sharpened, HB Lead - Box of 150, Bulk Box',\n",
+       " 343: 'Koala Tools | Bear Claw Pencils (pack of 6) - Fat, Thick, Strong, Triangular Grip, Graphite, 2B Lead with Eraser - Suitable for Kids, Art, Drawing, Drafting, Sketching & Shading',\n",
+       " 344: 'Personalized Pencils - Round - Laser Theme - Custom Printed with your message, text or logo - by Express Pencils - 12 pkg FREE PERZONALIZATION Great gift idea (Green)',\n",
+       " 345: 'Integra Presharpened No. 2 Pencils',\n",
+       " 346: 'Dixon Ticonderoga Pre-sharpened with Erasers Pencils, 2, Yellow, 2 Boxes of 30 (13830)',\n",
+       " 347: 'Dixon Oriole Presharpened Pencil, 12 Count ( Packaging May Vary )',\n",
+       " 348: 'Colore #2 Pencils With Eraser Tops - HB Graphite/No 2 Yellow Wood Pencil Great School Art Supplies For Writing, Drawing & Sketching - Suitable For Kids & Adults - 144 Count',\n",
+       " 349: 'Ticonderoga Yellow Pencil, No.1 Extra Soft Lead, Dozen DIX13881',\n",
+       " 350: 'TICONDEROGA Pencils, Wood-Cased Graphite, #2 HB Soft, Pre-Sharpened, Assorted Color Barrels, Black Lead, 10-Pack (13932)',\n",
+       " 351: 'Ticonderoga Noir Black Wood-Cased #2 Pencils, Holographic Design, 12-Count (13970)',\n",
+       " 352: 'TICONDEROGA My First Pencils, Wood-Cased #2 HB Soft, Pre-Sharpened with Eraser, Includes Bonus Sharpener, Yellow, 4-Pack (33309)',\n",
+       " 353: 'DIXON Oriole Wood-Cased Pencils with Erasers, Graphite, #2 HB, Pre-Sharpened, Yellow, 144-Count (12866)',\n",
+       " 354: 'Moon Products Wood Pencil, Fifth Graders Are No.1, No.2, 12/DZ, Assorted (MPD7865B)',\n",
+       " 355: 'Dixon Ticonderoga Oriole Pre-Sharpened Black Core Pencils, #2, Yellow, Box of 12 (12886)(3Pack)',\n",
+       " 356: 'Pencils Pre-sharpened No. 2 144/box 12 Boxes of 12 New Improved Eraser',\n",
+       " 357: 'Pre-Sharpened Pencil, 2, Yellow Barrel, 30/Pack - DIX13830',\n",
+       " 358: 'Black Widow Skin Colored Pencils for Adults - Color Pencils for Portraits and Skintone Artists - A Complete Color Range - Now With Light Fast Ratings.',\n",
+       " 359: 'Weibo HB Wood Cased Graphite School Pencils, Pack of 12, Bulk, Pre-Sharpened with Erasers and Sharpener, Office Supplies for Exams, School, Office, Drawing and Sketching (Purple)',\n",
+       " 360: 'Amazon Basics Woodcased #2 Pencils, Pre-sharpened, HB Lead - Box of 150, Bulk Box',\n",
+       " 361: 'ezpencils - Red Barrel Golf (1/2 a pencil - Pew pencils) Hexagon Pencils with Eraser - 48 pkg - Non-Smudge Eraser - # 2 HB Lead - Sharpened - NEW',\n",
+       " 362: 'Paper Mate 73015 Arrowhead Pink Pearl Cap Erasers, 144 Count',\n",
+       " 363: 'TICONDEROGA My First Pencils, Wood-Cased #2 HB Soft, Pre-Sharpened with Eraser, Yellow, 12-Pack (33312)',\n",
+       " 364: \"BIC Xtra-Precision Mechanical Pencil, Metallic Barrel, Fine Point (0.5mm), 24-Count, Doesn't Smudge and Erases Cleanly\",\n",
+       " 365: 'Dixon No. 2 Yellow Pencils, Wood-Cased, Black Core, #2 HB Soft, 144 Count, Boxed (14412)',\n",
+       " 366: 'ezpencils - Neon Green Barrel Golf (1/2 a pencil - Pew pencils) Hexagon Pencils without Eraser - 48 pkg - No Eraser - # 2 HB Lead - Sharpened - NEW',\n",
+       " 367: 'TICONDEROGA Erasable Checking Pencils, Pre-Sharpened with Eraser, Blue, Pack of 12 (14209)',\n",
+       " 368: \"Maped Helix USA Black'Peps Triangular Graphite #2 Pencils, Pack of 3 (851711ZV)\",\n",
+       " 369: 'ezpencils - Black Barrel Golf (1/2 a pencil - Pew pencils) Blank Hexagon Pencils without Eraser - 48 pkg - # 2 HB Lead - Sharpened - NEW',\n",
+       " 370: 'Staedtler 512 001 ST Double-hole Tub Pencil Sharpener',\n",
+       " 371: 'Nikola Works Classic American Standard #2 HB Mini Golf Pre-Sharpened Pew Pencils Without Erasers Hex Shaped Bulk 384 Count',\n",
+       " 372: 'Nikola Works Classic American Standard #2 HB Mini Golf Pre-Sharpened Pew Pencils With Erasers Hex Shaped Bulk 384 Count',\n",
+       " 373: 'Tombow 57324 MONO Eraser, White, Medium, 3-Pack. Cleanly Removes Marks Without Damaging Paper',\n",
+       " 374: 'Emraw Pink Color Fun Mini Chisel Shaped Eraser Top Cap for Any Standard Pencil - Use in School, Home & Office (20 Pack)',\n",
+       " 375: 'Pencil Guy Untipped white round pencil, no eraser 144 to a box',\n",
+       " 376: 'Grading Checking Erasable Pencils, Pre-Sharpened #2 HB Red Pencils, With Eraser Tops - 12-Pack',\n",
+       " 377: 'Recycled P',\n",
+       " 378: 'Premium Quality Pencils In Bulk 150 Neon #2 Sharpened Wood Pencils for Kids and Adults',\n",
+       " 379: 'Electric Pencil Sharpener, Eraser and Vacuum Set, Batteries Included, High Speed Automatic, Battery-Powered, Best for Colored No. 2 Pencils, for Home Office School Classroom Adults Kids (Black)',\n",
+       " 380: '1InTheOffice Red Grading Pencils #2 Lead, Red Pre Sharpened Checking Pencils\"24 Pack\"',\n",
+       " 381: 'HB Translucent Pencil Multipoint Pencil Colorful Non-Sharpening Stacking Point Pencil Pop Up Plastic Pencil with Matching Eraser for Girls, Kids, Students, Teachers, Office Staff, 7 Colors (14 Pieces)',\n",
+       " 382: 'TICONDEROGA Pencils, Wood-Cased, Pre-Sharpened, Graphite #2 HB Soft, Yellow, 30-Count - 1 Pack',\n",
+       " 383: 'Ticonderoga My First Wood-Cased Pencils , #2 HB Soft, Without Eraser, Yellow, 36 Count (X33036)',\n",
+       " 384: '30 Pieces Non-Sharpening Pencils HB Translucent Pencil Stacking Point Pencils for Kids Pop Up Stackable Pencil with Matching Eraser for Taking Notes, Writing, Drawing, 5 Colors',\n",
+       " 385: 'AUTEMOJO 3.5 Inch Short Triangular Fat Pencils for Preschoolers Toddlers Kindergarten, Mini Wood Triangular Pencils for Kids Writing and Drawing(Pack of 7, Blue)',\n",
+       " 386: \"Maped Black'Peps Jumbo Triangular Graphite #2 Pencils without Erasers x46 - School Pack (854059)\",\n",
+       " 387: 'ezpencils - Natural Color Golf Pencils without Eraser – 144 units bx. – Non-Personalized (Blank Pencils), 2HB (Black Graphite), Pew/Score Keeping, Half Pencil, School/Office, Hexagon, Sharpened',\n",
+       " 388: 'Beginner Primary Size Pencils, Wood-Cased #2 HB Soft Without Eraser, Yellow, 12-Pack - New',\n",
+       " 389: 'ezpencils - Neon Pink Barrel Golf (1/2 a pencil - Pew pencils) Hexagon Pencils without Eraser - 48 pkg - No Eraser - # 2 HB Lead - Sharpened - Non-Branded - NEW',\n",
+       " 390: 'ezpencils - Red Barrel Golf (1/2 a pencil - Pew pencils) Hexagon Pencils without Eraser - 48 pkg - No Eraser - # 2 HB Lead - Sharpened - NEW',\n",
+       " 391: 'TICONDEROGA Laddie Pencils, Wood-Cased #2 HB Soft without Eraser, Yellow, 12-Pack (13040)',\n",
+       " 392: 'Ticonderoga - PPNE TICONDEROGA Beginner Primary Size Pencils, Wood-Cased #2 HB Soft Without Eraser, Yellow, 12-Pack (13080)',\n",
+       " 393: 'Ticonderoga Pencils, Wood-Cased Graphite #2 HB Soft, Pre-Sharpened, Yellow, 12 Count (X13806)',\n",
+       " 394: 'Ticonderoga My First Tri-Write Pencils without Eraser, Primary Size Wood-Cased #2 HB Soft, Yellow, 36-Pack (13084)',\n",
+       " 395: 'Musgrave Pencil Co MUS500 Tot Big Dipper Jumbo Pencil without Eraser, 12 Pack',\n",
+       " 396: 'Dixon Ticonderoga Company : No 2 Pencil,Triangular Shape,Beginner Without Eraser,36/BX -:- Sold as 2 Packs of - 36 - / - Total of 72 Each',\n",
+       " 397: 'Paper Mate 56047PP Clearpoint 0.7mm Mechanical Pencil Starter Set, Assorted Colors',\n",
+       " 398: 'Ticonderoga Laddie Tri-Write Pencils, Wood-Cased #2 HB Soft, Intermediate Size Triangular without Eraser, Yellow, 36-Pack (13044)',\n",
+       " 399: 'Integra Red Grading Pencils , 12 count',\n",
+       " 400: 'Learning Without Tears Pencils for Little Hands- Trans K–1, Handwriting, Writing Tools, Bulk Pencils, Sensory - For School and Home Use',\n",
+       " 401: 'ezpencils - Sea Blue Barrel Golf (1/2 a pencil - Pew pencils) Hexagon Pencils without Eraser - 48 pkg - No Eraser - # 2 HB Lead - Sharpened - Non-Branded - NEW',\n",
+       " 402: 'Dixon Ticonderoga Beginners Primary Size #2 Pencils Without Eraser, Box of 12, Yellow (13080)(2Pack)',\n",
+       " 403: 'Dixon Ticonderoga Beginners Primary Size #2 Pencils Without Erasers, Yellow (13080) (4-Pack of 12)',\n",
+       " 404: '30 Pieces Small Colored Paper Gift Bags Party Favor Bags Assorted Colors (Rainbow Without Handle)',\n",
+       " 405: '100 Pack 8x4.75x10 inch Medium Red Gift Paper Bags with Handles Bulk, Bagmad Kraft Bags, Craft Grocery Shopping Retail Party Favors Wedding Bags Sacks (Red, 100pcs)',\n",
+       " 406: '100 Pack 8x4.75x10 inch Medium Blue Gift Paper Bags with Handles Bulk, Bagmad Kraft Bags, Craft Grocery Shopping Retail Party Favors Wedding Bags Sacks (Navy Blue, 100pcs)',\n",
+       " 407: '50 Pack 5.25x3.25x8 inch Small Green Gift Paper Bags with Handles Bulk, Bagmad Kraft Bags, Craft Grocery Shopping Retail Party Favors Wedding Bags Sacks (Dark Green, 50pcs)',\n",
+       " 408: '50 Pack 8x4.75x10 inch Medium Blue Kraft Paper Bags with Handles Bulk, Bagmad Gift Bags, Craft Grocery Shopping Retail Party Favors Wedding Bags Sacks (Navy Blue, 50pcs)',\n",
+       " 409: '20 Pack Party Favor Bags Colorful Kraft Paper Goodie Bags with Handle for Kids Birthday',\n",
+       " 410: 'Trash Bags, 5 Rolls/100 Counts Small Garbage Bags for Office, Kitchen,Bedroom Waste Bin,Colorful Portable Strong Rubbish Bags,Wastebasket Bags',\n",
+       " 411: 'Glad Trash & Food Storage ForceFlex Protection Series Tall Trash Bags, 13 Gal, Gain Moonlight Breeze with Febreze, 110 Ct (Package May Vary), White (79261)',\n",
+       " 412: '50 Pack 8x4.75x10 inch Medium Green Gift Paper Bags with Handles Bulk, Bagmad Kraft Bags, Craft Grocery Shopping Retail Party Favors Wedding Bags Sacks (Dark Green, 50pcs)',\n",
+       " 413: '50 Pack 8x4.75x10 inch Medium White Kraft Paper Bags with Handles Bulk, Bagmad Gift Bags, Craft Grocery Shopping Retail Birthday Party Favors Wedding Sacks Restaurant Takeout, Business (50Pcs)',\n",
+       " 414: 'HUAPRINT Black Paper Bags,Shopping bags with Ribbon Handles,20Pcs,10.6x8.3x3.1,Craft Gift Bags for Clothes,Bulk Lunch Bags,Retail Bags,Party Favor Bags,Merchandise Business Bags,Wedding Bags',\n",
+       " 415: 'Brown Paper Bags with Handles Bulk 50 Pack - Includes 50 Psc Thank You Stickers - Kraft Paper Bags Different Sizes - Large and Medium Gift Paper Bags - Recycled Paper Bags for Business for Shopping',\n",
+       " 416: 'Kraft Brown Paper Bags 57 LB [100 Pack] - Brown Paper Grocery Bag Bulk - Large Brown Paper Bags, Durable, Great for Grocery shopping, Delivery or take out orders.12\"x7\"x17\"',\n",
+       " 417: '20 Qty 8.5\" x 11\" Decorative Flat Paper Gift Bags - White Polka-Dot on Brown Kraft Bags - for Sales/Treats/Parties Cookies/Gifts - N\\'icePackaging',\n",
+       " 418: 'Swedin 20 Pcs Wedding Gift Bag for Guests, Thank You Bag for Wedding',\n",
+       " 419: 'Thank You Bags Shopping Bags, 50 Pack Extra Thick Bulk Merchandise Bags Plastic Boutique Bags for Small Business Plastic Retail Gift Bags with Loop Handle for Customers Parties Favors Goodies (Dot, M(12x14Inch))',\n",
+       " 420: 'T Shirt Bags, Silver Plastic Bags with Handles Bulk, Bolsas De Plastico Para Negocio, Grocery Bags Retail Shopping Bags Merchandise Bags for Supermarket Restaurant, 12x20inch (200pcs)',\n",
+       " 421: 'Kaderron 80 Pcs Kraft Paper Bags with Handles, Shopping Bags Bulk for Groceries - Small Medium Large Assorted Sizes - Brown Gift Bags Ideal for Party, Retail, Packaging, Boutique, Small Business',\n",
+       " 422: '50 Pack 8x4.75x10 inch Plain Medium Paper Bags with Handles Bulk, Bagmad Red Kraft Bags, Craft Gift Bags, Grocery Shopping Retail Bags, Birthday Party Favors Wedding Bags Sacks (Red 50Pcs)',\n",
+       " 423: 'Small Paper Bags 10.6x3.1x8.3\" BagDream Gift Bags 50Pcs Heavy Duty Kraft Brown Paper Bags with Soft Cloth Handles, Party Bags, Shopping Bags, Retail Bags, Merchandise Bags, Wedding Party Bags',\n",
+       " 424: '50 Pack 8x4.75x10 inch Plain Medium Paper Bags with Handles Bulk, Bagmad Brown Kraft Bags, Craft Gift Bags, Grocery Shopping Retail Bags, Birthday Party Favors Wedding Bags Sacks (Natural 50Pcs)',\n",
+       " 425: 'Glad ForceFlexPlus Drawstring Large Trash Bags - 30 Gallon, 50 Ct (Package May Vary)',\n",
+       " 426: 'GLAD ForceFlex Protection Series Tall Kitchen Trash Bags, 13 Gal, Unscented OdorShield, 90 Ct (Package May Vary)',\n",
+       " 427: 'Hefty Ultra Strong Tall Kitchen Trash Bags-Lavender Sweet Vanilla, 13 Gallon, 80 Count, 80 Count, White, 80 Count',\n",
+       " 428: 'Hefty Ultra Strong Tall Kitchen Trash Bags, Blackout, Clean Burst, 13 Gallon, 80 Count',\n",
+       " 429: 'Houseables Plastic Retail Bags, Merchandise Bag, 16”x18”, 100 Pack, 1.75 Mil Thick, Black & White, Die Cut Handles, Craft Fair Supplies, Store Shopping, Glossy, For Sales, Product, Treat, Gift, Clothes, Party, Favor, Boutique',\n",
+       " 430: '[150 Pack] 12 LB 13 x 7 x 4.5\" Heavy Duty Kraft Paper Bags Grocery Lunch Retail Shopping Durable Natural Brown Barrel Sack',\n",
+       " 431: 'Hippo Sak 30 Gallon Large Trash Bag with Handles 56 Bags (28 per Box - 2 Pack)',\n",
+       " 432: 'EcoQuality - 13x7x17 inches - 50pcs - Large Brown Kraft Paper Bags with Handles, Shopping, Gift Bags, Party, Merchandise, Lunch Bags, Grocery Bags',\n",
+       " 433: '50 Pack Sturdy Medium White Gift Paper Bags with Handles Bulk, Bagmad Kraft Bags 8x4.75x10 inch, Craft Grocery Shopping Retail Party Favors Wedding Bags Sacks (White, 50pcs)',\n",
+       " 434: '50 Pack 5.25x3.25x8 inch Small Blue Gift Paper Bags with Handles Bulk, Bagmad Kraft Bags, Craft Grocery Shopping Retail Party Favors Wedding Bags Sacks (Navy Blue, 50pcs)',\n",
+       " 435: 'Sturdy 5.25x3.25x8 inch 100 Pack Small Paper Bags with Handles Bulk, Bagmad Brown Kraft Bags, Gift Party Favors Grocery Retail Strong Shopping Craft Cub Sacks (Thicken, 100Pcs) (100)',\n",
+       " 436: 'BagDream Kraft Paper Bags 8x4.25x10& 10x5x13 Totally 100Pcs Paper Gift Bags with Handles Bulk, Kraft Bags, Shopping Bags, Craft Bags, Merchandise Bags, Recyclable Paper Bags 50 Per Size',\n",
+       " 437: '100 Pack Sturdy Medium White Kraft Paper Bags with Handles Bulk, bagmad Thicken Gift Bags 8x4.75x10 inch, Craft Grocery Shopping Retail Party Favors Wedding Bags Sacks (White, 100pcs)',\n",
+       " 438: '50 Pack Sturdy Small White Gift Paper Bags with Handles Bulk, Bagmad Kraft Bags 5.25x3.25x8 inch, Craft Grocery Shopping Retail Party Favors Wedding Bags Sacks (White, 50pcs)',\n",
+       " 439: '100 Pack Medium 8x4.75x10 inch Black Kraft Paper Bags with Handles Bulk, Bagmad Gift Bags, Craft Grocery Shopping Retail Party Favors Wedding Bags Sacks (Black, 100pcs)',\n",
+       " 440: 'Tomnk 32pcs Party Favor Bags 8 Colors Goodie Bags Rainbow Paper Gift Bags Bulk with Handles for Birthday Party, Candy ,Small Gift and Bridal Shower',\n",
+       " 441: '100 Pack 8x4.75x10 inch Plain Medium Paper Bags with Handles Bulk, Bagmad Brown Kraft Bags, Craft Gift Bags, Grocery Shopping Retail Bags, Birthday Party Favors Wedding Bags Sacks (Natural 100Pcs)',\n",
+       " 442: '100 Pack 5.25x3.25x8 inch Brown Small Paper Bags with Handles Bulk, bagmad Gift Paper Bags, Kraft Birthday Party Favors Grocery Retail Shopping Bag, Craft Bags Takeouts Business (Plain Natural 100pcs)',\n",
+       " 443: 'Sturdy 8x4.75x10 inch 50 Pack Medium Thick Paper Bags with Handles Bulk, bagmad Plain Brown Kraft Bags, Strong Craft Gift Grocery Shopping Retail Party Favors Wedding Bags Sacks (Thicken, 50pcs)',\n",
+       " 444: 'YKK Zipper Repair (not KIT) 1 x Pull for Jeep Wrangler #10 Coil Nylon top Zipper Long Pull Rear Window, Top, Side/Back TJ and JK Model viteao',\n",
+       " 445: 'Meikeer 252 Pieces Zipper Repair Kit Replacement Zipper, Zipper Pulls, Installation Tools for Bags Tents Luggage Sleeping Bag Jacket Outdoor',\n",
+       " 446: 'Zipper Repair Kit 255 Pcs Zipper Replacement Rescue Kit with Zipper Install Pliers Tool and Zipper Extension Pulls for Clothing Jackets Purses Luggage Backpacks Tents Sleeping Bag',\n",
+       " 447: 'PH PandaHall 4 Size 3 Color Metal Zipper Head Sliders Retainer Insertion Pin(12 Sets), 12 Pairs Zipper Top Stop Plug, 12pcs Zipper Bottom Stopper for Coats Jacket Zipper Repair Kit (Size 3/5/8/10)',\n",
+       " 448: 'YaHoGa 20 Sets #5 Small Metal Zipper Latch Slider Retainer Insertion Pin Zipper Bottom Zipper Stopper for 5mm Metal Zipper Repair (Black)',\n",
+       " 449: 'TUPARKA 211 Pcs Zipper Repair Kit Zipper Replacement with Zipper Install Plier for DIY Bags, Luggage, Backpacks, Silver and Black',\n",
+       " 450: '25PCS #3 Shiny Silver Pulls for Nylon Coil Zippers Metal Zipper Sliders for Jacket Luggage Purses Bags Bulk(Silver) Brass Slider for Zipper',\n",
+       " 451: 'YaHoGa #5 Colorful Teeth Rainbow Metallic Nylon Coil Zippers by The Yard Bulk 10 Yards with 25pcs Silver Sliders for DIY Sewing Tailor Craft Bags (White Tape)',\n",
+       " 452: 'Zipper Repair Kit Metal Head Sliders Retainer Insertion Pin(3 Colors 4 Sizes) 13 Sets Zipper Fix Top Stop Plug, Repair Down Zipper Bottom Stopper for Zipper Repair Replacement (Size 10/8/5/3)',\n",
+       " 453: 'YAKA 39 Piece Zipper Replacement Slider Repair Kits #3#5#8 Silver Black Zipper Rescue Kit Nylon Coil Zippers for Bags Jackets Clothing Tents Luggage Backpacks Purses',\n",
+       " 454: 'Black #10 Nylon Coil Zippers for Sewing (10 Yards, 10 Pieces)',\n",
+       " 455: 'PH PandaHall 12 Sets Metal Zipper Latch Slider Retainer 3 Color #3#5#8#10 Insertion Pin Zipper Bottom Zipper Stopper for Metal Zipper Repair Zip Sewing Replacement DIY',\n",
+       " 456: 'Zipper Pull 12 Pcs, Replacement Zipper Slider,Zipper Repair Kit #5, Fix Zipper Repair Kit for Repairing Coats,Jackets, Metal Plastic and Nylon Coil Zippers.',\n",
+       " 457: 'VOC #3 Nylon Coil Zipper Tape Long Zippers for Sewing Black Zippers by The Yard 5 Yard with 12PCS Slider&Tag-Zipper Roll for Tailor Crafts(Black Tape)',\n",
+       " 458: '120 Pieces Metal Zipper Head Slider, 4 Sizes Zipper Bottom Sliders Retainer Insertion Pin in 3 Colors, Zipper Stopper Repair Tool Kit for Coats Jacket DIY Sewing Replacement (Size of 3/5/8/10)',\n",
+       " 459: '24 Pieces Black Bronze and Silver Zipper Sliders Zipper Pull Replacement with Zipper Slider Repair Kits for Metal Plastic Nylon Coil Jacket Zippers Supplies',\n",
+       " 460: 'Meikeer 12 Pieces #5 Zipper Slider Repair Kits Black Bronze and Silver Zipper Sliders Zipper Pull Replacement for Metal Plastic and Nylon Coil Jacket Zippers',\n",
+       " 461: 'EuTengHao 183Pcs Zipper Repair Kit Zipper Replacement Zipper Pull Rescue Kit with Zipper Install Pliers Tool and Zipper Extension Pulls for Clothing Jackets Purses Luggage Backpacks (Sliver and Black)',\n",
+       " 462: 'White #3 Nylon Coil Zippers with 80 Replacement Sliders for Sewing (50 Yards)',\n",
+       " 463: 'YKK Zipper Pull Tab Sliders Boat Canvas #10 Vislon Double Metal Pull Tab Zipper Sliders, 2 Piece Set - Black',\n",
+       " 464: 'YaHoGa 143 PCS Zipper Repair Kit Zipper Replacement with Install Plier for Bags, Jackets, Tents, Backpacks, Sleeping Bag',\n",
+       " 465: 'YaHoGa 10 Pieces #5 Black Zipper Sliders Zipper Repair Zipper Replacement for Plastic Jacket Zippers',\n",
+       " 466: 'Zipper Rescue Zipper Repair Kits – The Original Zipper Repair Kit, Made in America Since 1993 (Moto)',\n",
+       " 467: 'Zipper Repair Kit - #5 Vislon Auto Lock Sliders - 3 Universal Sliders and Stops Included - Made in The United States',\n",
+       " 468: 'ZipperStop Wholesale Authorized Distributor YKK Zipper Rescue Jeep Slider ~ 10 Coil Long Pull with 2 Heads- Jeep Slider ~ Black (2 Sliders / Pack)',\n",
+       " 469: 'Zipper Repair Solution, YKK #10 Vislon Slider - Black (2 Sliders / Pack)',\n",
+       " 470: 'FixnZip Instant Zipper Replacement, Medium, Black Nickel',\n",
+       " 471: 'FixnZip 3 Pack Instant Zipper Replacement, Combo Pack (S,M,L), Black Nickel',\n",
+       " 472: 'YKK #3 Coil Non Lock Long Pull Sliders Black Made in USA - 25pcs a Pack- for Pouches, Handbags & Craft Projects',\n",
+       " 473: 'ZipperStop Distributor YKK -Zipper Repair Kit Solution YKK #3 Nylon Coil Chain Zipper Color Black - 10 Yards Nylon Coil Chain Pack Plus 25pcs YKK #3 Coil Non Lock Long Pull Slider Made in USA',\n",
+       " 474: 'YKK Bimini Top YKK #10 Slider 100% Plastic Color White',\n",
+       " 475: 'Zipper Repair Kit Solution - YKK #8 Molded Pulls Vislon Slider Made in USA - 3 Sliders Per Pack with Top and Bottom Stoppers Color Black.',\n",
+       " 476: 'YKK Zipper Repair Kit Solution 8 Sets Assorted 4 of #5, 2 of #7 and 2 of #10 Included Top & Bottom Stops Made in USA Antique Auto Lock Sliders, Black',\n",
+       " 477: '85 Pieces Zipper Replacement Zipper Repair Kit with Instruction Manual and Zipper Install Pliers Tool, Silver and Black',\n",
+       " 478: 'YaHoGa #5 Antique Brass Metallic Nylon Coil Zippers by The Yard Bulk Brown Tape 10 Yards with 20pcs Sliders for DIY Sewing Tailor Craft Bag (Anti-Brass Brown)',\n",
+       " 479: 'Universal Zipper Repair Kit Fix a Zipper Metal Zipper Fix any Broken Zipper in Seconds No Sewing Needed One Pack (3 PCS)',\n",
+       " 480: 'Aneco 171 Pieces Zipper Repair Kit Zipper Replacement Accessories Zipper Install Pliers Tool with Container Storage, Silver and Black',\n",
+       " 481: 'Zipperstop Zipper Repair Kit Solution #3 Coil YKK Brand Slider use in Sewing or Jewelry-Choice, Mix (30pc Brights and Neutrals)',\n",
+       " 482: 'Mudder 36 Pack Zipper Replacement Zipper Repair Kit, Silver',\n",
+       " 483: 'Zipper Repair Kit Solution YKK #3 Coil Non Lock Long Pull Slider Color White (Made in USA) - 25pcs a Pack',\n",
+       " 484: \"jiefeng 8 Bundles Pre stretched Braiding Hair Extensions for Women 26 Inches Yaki Texture Professional Crochet Twist Braids Hair Synthetic Hair for Braids (20'', black to red)\",\n",
+       " 485: 'SHUOHAN 8 Packs Pre-stretched 26 Inch Braiding Hair Extensions Yaki Texture Professional Crochet Braids Hair Hot Water Setting Synthetic Hair for Twist Braids',\n",
+       " 486: 'Pre Stretched Easy Braiding Hair 8Packs/Lot Braids Itch Free Hot Water Setting Synthetic Fiber Yaki Texture Black Crochet Braiding Hair Extension (26Inches Red Color)',\n",
+       " 487: '20 Inch 7 Packs Pre-stretched Braid Professional Braiding Hair Extension Ombre Natural Black Blond Hot Water Setting Perm Yaki Synthetic Hair for Twist Braids (20inch,7pack, T30)',\n",
+       " 488: 'Yisimei Easy Braiding Hair 20 Inches 6 Packs/Lot With Gifts T1B/Silver Professional Pre Stretched Braiding Hair Easy Braiding Crochet Hair Synthetic Hair Extensions (20” 6Packs/Lot, 1B/Silver)',\n",
+       " 489: 'Dansama 6 Packs Passion Twist Hair Water Wave Braiding Hair for Butterfly Style Crochet Braids Bohemian Hair Extensions (18inch (Pack of 6), #1B)',\n",
+       " 490: 'Ombre Braiding Hair Pre Stretched 26 Inch Brown Braiding Hair 8 Packs Easy Braids Hair Yaki Straight Hot Water Setting Synthetic Braiding Hair Extensions for Crochet Hair Braiding Twist(1B/30/27)',\n",
+       " 491: 'Jumbo Braiding Hair Extensions Kanekalon Braiding Hair Pre Stretched Afro 24 Inch Ombre Multiple Tone Colored Synthetic Hair For Box Twist Braids (black-purple-darkblue)',\n",
+       " 492: 'BETHANY Pre Stretched Braiding Hair Ombre Braids Hair for Hair Extensions 6 Packs 24 Inch Professional Yaki Texture Itch Free Synthetic Fiber Corchet Braiding Hair for Black Women（27/613）',\n",
+       " 493: \"36'' Ombre Pre Stretched Braiding Hair Yaki Texture Crochet Braid Hair Extensions Fashionable 3 or 4 Tones Kanekalon Braiding Hair Pre Stretched 0.27 LB/bundle (7 bunldes, 1b/30/27/613)…\",\n",
+       " 494: 'LMZIM 14 Inch Goddess Box Braids Crochet Hair Bohomian Crochet Box Braids Curly Ends 8 Pack 3X Crochet Braids Synthetic Braiding Hair Extension Black',\n",
+       " 495: 'Darling Thrive Braid Pre-stretched Braiding Hair Extensions (4 Packs), 100% Kanekalon Hair, 3X per Pack, 52 Inch, #1/27',\n",
+       " 496: 'Pre-stretched Braiding Hair Easy Braid Professional Itch Free Synthetic Fiber Corchet Braids Yaki Texture Hair Extensions 6 packs Braid Hair (26 inch, 1B/Purple/Pink)',\n",
+       " 497: '8 bundle /4 pack Pre Stretched Loose Wavy Braiding Hair 22 inch French Curles Crochet Braid Hair Synthetic Braiding Hair For Black Women Box Braids Hair (B29)',\n",
+       " 498: '22inch French Curl Braiding Hair Loose Wavy Braiding Hair (4packs 160g/pack)Wavy Synthetic Braiding Hair For Black Women French Curly Braids Hair Extensions',\n",
+       " 499: \"Ombre Pre stretched Braiding Hair, Long 4 tone Kanekalon Braid Hair Extensions, 8 packs Multi Color blending braiding hair, Twist Hair Braiding (36''-pack of 8, 1b3027613)\",\n",
+       " 500: '6 Packs 12 Inch AU-THEN-TIC Box Braid Crochet Hair Crochet Box Braids Hair Mambo Twist Braiding Pre Stretched Pre Looped Synthetic Heat Resistant Hair Extensions (12 Inch (Pack of 6), 4)',\n",
+       " 501: \"Pre-stretched Braiding Hair, Original Kanekalon Braid Hair Extensions, Hot Water Setting Crochet Hair Braids, Yaki Texture Easy Braiding Hair (24''-8 bundles, 1b)…\",\n",
+       " 502: 'Pre Stretched Braiding Hair 20 Inch Loose Wave Crochet Braids Hair 8 packs Big wavy curly Bouncy Braiding Hair Curly Synthetic Hair Extensions (75g/packs ，1B )',\n",
+       " 503: '24 Inch 6 Packs Ombre Blonde 27 613 Long Senegalese Twists Crochet Braid Hair Prelooped Small Micro Havana Natural looking bohemian Hairstyle for Black Women Can Be Curly Ends 30 Strands/Pack (6 Packs,27/613)',\n",
+       " 504: 'Forevery 8 Packs Pre Stretched Braiding Hair 24 Inch Pre Stretched Hair For Braiding Hair Itch Free Braiding Hair Yaki Braiding Straight Braiding Hair Kanekalon Braiding Hair 24”(8Packs- T4/27)',\n",
+       " 505: '26 inch Black Braiding Hair Pre Stretched Easy Braid Hair 8 Bundles for Box Braids Hair Soft Yaki Texture Synthetic Braiding Hair Not Itchy Hot Water Setting Braids Hair for Senegalese Twist Hair',\n",
+       " 506: 'Forevery Braiding Hair 24” Jumbo Box Braids Color Braiding Hair 5PCS Braiding Hair Brown Jumbo Braiding Kenakalon Hair Braid Hair (24\"-5pcs, Black-Dark Brown)',\n",
+       " 507: '3 Pack Spring Twist Ombre Colors Crochet Braids Synthetic Braiding Hair Extensions Low Temperature Fiber (1B)',\n",
+       " 508: 'Refined Products 26inch Ombre Pre-stretched Braiding Hair 6 packs Synthetic Kanekalon Easy Braid Yaki Texture Crochet Twist Braids Hair Extensions (Black/Brown/Light Brown)',\n",
+       " 509: '30 Inch Pre Stretched Braiding Hair Knotless Braids 8 Packs Natural Color Super Long Itch Free Hot Water Setting Synthetic Fiber Crochet Braiding Hair Extension (30\", 1B#)',\n",
+       " 510: 'Ombre Braiding Hair Kanekalon Synthetic Braiding Hair Extensions (Black-Brown-Blonde) 5pcs/lot 24inch Jumbo Braiding Hair',\n",
+       " 511: \"Ombre Pre Stretched Braiding Hair, Top Silky Color Blend Braid Hair Extensions, 100% Kanekalon Synthetic Crochet Hair Braids, Yaki Texture Hair Braiding 0.21LB/bundle (28''-8 bundles, 1b-30-27)…\",\n",
+       " 512: 'Pre-Stretched Braiding Hair 24 Inch Easy Braid Professional 8 Packs Natural Black Itch Free Synthetic Fiber Corchet Braids Hot Water Setting Professional Soft Yaki Texture(24INCH, 4#)',\n",
+       " 513: 'Jumbo Braiding Hair 5 Packs Jumbo Box Braid Crochet Hair Extension Synthetic Crochet Braids Hair Twist Braiding Hair (Black-Dark Purle, 24 Inch)',\n",
+       " 514: '26\"-8 Packs Braiding Hair Pre Stretched Hair for Braiding Professional Kanekalon Synthetic Hair Hot Water Setting Yaki Texture Premium Fiber Crochet Synthetic Braiding Hair',\n",
+       " 515: '26Inch EZ-Braids Professionasl Pre Streched Braiding Hair Hot Water Setting Synthetic Fiber Easy Braids Hair Black Color Crochet Braids Hair Extensions 6Packs/Lot （1B#）',\n",
+       " 516: \"DAN NING 24 '' Pre-stretched Braiding Hair Original Kanekalon Braid Hair Extensions Yaki Texture Crochet Twist Hair Braids without Irritation 7 bundles (1b#)\",\n",
+       " 517: 'Pre-stretched Braids Hair Professional Itch Free Hot Water Setting Synthetic Fiber Ombre Yaki Texture Braid Hair Extensions 26 Inch 8 Packs Beyond Beauty Braiding Hair 1B-30-27',\n",
+       " 518: '8 Packs Pre Stretched Braiding Hair 3 Tone Ombre Braiding Hair for Braids Twist 26 Inch Itch Free Hot Water Setting Yaki Texture Synthetic Hair Extension(T1B/30/27#)…',\n",
+       " 519: '8 Packs Off Black Pre-stretched Braiding Hair Easy Braid Professional Itch Free Synthetic Fiber Corchet Braids Yaki Texture Hair Extensions Hot Water Setting EZ Braid Hair(26 Inch, 1B#)',\n",
+       " 520: 'EZ Braids Professional Pre Stretched Braiding Hair 8 Packs Synthetic Premium Fiber Crochet Braids Yaki Texture Hair Extensions(20Inch,1B#)',\n",
+       " 521: 'Pre Stretched Braiding Hair 8 Pack 1B Expression Braiding Hair Pre Stretched Easy Braid Itch Free Synthetic Box Braids Hair Hot Water Low Tempreture Setting for Women Braiding Jumbo Easy Hair 26 Inch',\n",
+       " 522: \"Ombre Pre Stretched Braiding Hair, 28''-6 packs Ombre Yaki texture Braid Hair Extensions, 100% Quality Kanekalon Synthetic Colorful Hair Braids (pack of 6, 1b-30-27)\",\n",
+       " 523: '#3 Nylon Coil Zippers by The Yard Long Zippers for Sewing,Silver Zipper Teeth 10 Yard with 20PCS White Tape White Gold Slider-VOC Zipper for Tailor Crafts(White Tape)',\n",
+       " 524: 'Coil Zippers with Replacement Sliders for Sewing (Black, 50 Yards, 80 Pieces)',\n",
+       " 525: 'Antner 6 Pack Zippered Binder Pockets Letter Size 3 Holes Binder Pouches, Multicolor Zippers Folders Loose Leaf Document Filing Bags for 3 Ring Binders',\n",
+       " 526: 'Nylon Coil Zippers #5- Long Zippers by The Yard Gunmetal Metallic Teeth- Sewing Zipper Bluk Black Tape with 20PCS Slider-VOC DIY Zipper for Tailor Sewing Crafts 10 Yards(Black Tape)',\n",
+       " 527: 'YAKA 60 Pack of 5 Inches Mix Nylon Coil Zippers Bulk - Supplies Zippers for Tailor Sewing Crafts (20 Color)',\n",
+       " 528: 'B.Y Elements #5 Silver Metallic Nylon Coil Zippers by The Yard Bulk 10 Yards with 25pcs Sliders for DIY Sewing Tailor Craft Bag (Bright Silver)',\n",
+       " 529: '#5 Nylon Coil Zippers for Sewing, 30 Colors (24 Inches, 60 Pieces)',\n",
+       " 530: 'Zipper Gap Buckle compatible with Neverfull Pochette Little Pouch Chain Strap Connective Buckle (Gold)',\n",
+       " 531: 'FlexiSnake Drain Weasel Sink Snake Cleaner - 18 inch - Drain Hair Clog Remover Tool with Rotating Handle & 3 Wand Refills - Thin, Flexible, Easy to Use on Most Drains & Grates - Made in USA - (3-Pack)',\n",
+       " 532: '36\" Nylon Coil Black Zipper 36 inch Separaing Zipper Black 36 inch Sewing Zipper Crafts Zipper',\n",
+       " 533: '#5 Nylon Coil Sewing Zippers by The Yard Bulk 10 Yards White and Black Colors with 20pcs Matched Sliders for DIY Tailor Sewing Craft,Luggage,Dress,Sofa Cushion, Pillow, Bag Leekayer(White and Black)',\n",
+       " 534: 'CYS #5 Zipper by The Yard,Metallic Nylon Coil Black Zipper Tape-5 Yards with 10pcs Silver Sliders for DIY Sewing Tailor Craft Bags Purse(Rainbow Teeth)',\n",
+       " 535: 'MebuZip #5 Gunmetal Metallic Nylon Coil Zippers by The Yard Bulk Coil Zipper Roll 10 Yards with 25pcs Pulls for DIY Sewing Craft Bags (Beige)',\n",
+       " 536: '#3 YKK Nylon Coil Continuous Zipper Chain by The Yard Make-A-Zipper 5 Yards with 20 Automatic Lock Zipper Pulls Same Color for DIY Sewing Crafts or Bags (Orange #523)',\n",
+       " 537: 'SBest Nylon Zippers #5 10 Yards Sewing Zippers Bulk DIY Zipper by The Yard Bulk with 20PCS Slider-Long Zippers for Tailor Sewing Crafts Bag (Gunmetal Teeth Black Tape)',\n",
+       " 538: 'YaHoGa #5 White Nylon Coil Zippers by The Yard Bulk 10 Yards with 25pcs Sliders for DIY Sewing Tailor Crafts Bags (#5 White)',\n",
+       " 539: '#5 Antique Brass Metallic Nylon Coil Zippers by The Yard Bulk 10 Yards Black Tape with 25pcs Brass Sliders for DIY Sewing Tailor Craft Bag Leekayer(Black)',\n",
+       " 540: 'Zipper Rescue Zipper Repair Kits – The Original Zipper Repair Kit, Made in America Since 1993 (Clothing)',\n",
+       " 541: '15 Yards~ YKK Zipper Chain~ 4.5 Coil Chain~Made in The USA~ Black Plus 30 YKK Long Pull Sliders- For Handbags & Craft Projects',\n",
+       " 542: 'Zipper Rescue Zipper Repair Kits – The Original Zipper Repair Kit, Made in America Since 1993 (Outdoor)',\n",
+       " 543: 'ZipperStop Wholesale Authorized Distributor YKK 36\" Light Weight Jacket Zipper ~ YKK #5 Nylon Coil Separating Zippers - White (Pack of 1 Zipper)',\n",
+       " 544: '5\" YKK 12 Black Zippers- for Apparel,Dolls, Crafts and Sewing Projects- Made in USA',\n",
+       " 545: 'Zipper Repair Kit Solution YKK 8 Sets Auto Lock Sliders Assorted 2 of #5, 2 of #7 , 2 of #8 and 2 of #10 Included Top & Bottom Stops - Made in USA (YKK Brass Auto Lock Sliders)',\n",
+       " 546: 'EuTengHao 169Pcs Zipper Repair Kit Zipper Replacement Zipper Pull Rescue Kit with Zipper Install Pliers Tool and Zipper Extension Pulls for Clothing Jackets Purses Luggage Backpacks (Sliver and Black)',\n",
+       " 547: 'Sportneer Bicycle Chain Lock, 5-Digit Resettable Combination Anti-Theft Bike Locks',\n",
+       " 548: 'YaHoGa #5 Silver Metallic Nylon Coil Zippers by The Yard Bulk Black 10 Yards with 25pcs Sliders for DIY Sewing Tailor Craft Bags (Silver Black)',\n",
+       " 549: 'Nuburi - Zipper by The Yard - 5 Yards of Make Your Own Zipper - 20 Zipper Pulls (Black)',\n",
+       " 550: 'Size 5 Nylon Coil Zippers with 50 Zipper Sliders (White, 1.2 In x 50 Yards)',\n",
+       " 551: 'YKK #10 Zipper Coil Chain with 2 Sliders per Yard. Many Colors. Sold in 5-Yard Lots. Please See Our Other Listing for Size 5 & Size 8 (5 Yards & 10 Black Sliders, Black)',\n",
+       " 552: 'OTOHANS AUTOMOTIVE Recoil-Starter-Pull-Start Assembly for Honda-GX120 GX160 GX200 Engine 4HP 5.5HP 6.5 HP (Steel Rod Paws) 28400-ZH8-013YA Generator Mower',\n",
+       " 553: 'Kizut GCV160 Recoil Starter for GC160 GC135 GCV135 EN2000 Generator 28400-ZL8-023ZA 28400-ZL8-013ZA Pull Start Assembly w Screw for 4 Through 5.5HP Horizontal Vertical Engine',\n",
+       " 554: 'XS Recoil Pull Starter Assembly for Briggs & Stratton 591139 590588 593961 08P502 093J02 Fits 500E 450E 550E 575E Engines',\n",
+       " 555: 'Kuupo Recoil Pull Starter Rope 10-Meter (Diameter: 5.0mm) Pull Cord for Stihl Sears Craftsman Poulan Lawn Mower Chainsaw Trimmer Brush Cutter Replacment Parts',\n",
+       " 556: 'Affordable Parts New Recoil Starter Rope 8-Meter (Diameter: 5.0mm) Pull Cord for Husqvarna STIHL Sears Craftsman Poulan Briggs Stratton Lawn Mower Chainsaw Trimmer Edger Brush Cutter Engine Parts',\n",
+       " 557: 'Hilom Rewind Recoil Starter for BS 497680 498144 Toro Lawnboy MTD Snapper Lawnmower Oregon 31-068 Rotary 12368',\n",
+       " 558: 'Yaciw 4mm Diameter Stihl Recoil Starter Rope (6 Feet) and Starter Handle Pull Cord 2 Piece Bundle',\n",
+       " 559: 'PRO BAT 4.5mm Recoil Starter Rope 10-Meter Pull Cord Rope for Lawn Mower Chainsaw Trimmer Edger Brush Cutter Engine Parts (4.5mm 10m)',\n",
+       " 560: 'Podoy Recoil Handle Pull Starter for Compatible with GX160 GX200 GX240 GX270 GX340 GX390 Lawnmower',\n",
+       " 561: 'Hipa Recoil Starter Rope 10-Meter (Diameter: 5.0mm) Pull Cord for Husqvarna STHIL Sears Craftsman Poulan Lawn Mower Chainsaw Trimmer Edger Brush Cutter Engine Parts',\n",
+       " 562: 'Hipa Recoil Starter Rope 10-Meter 3.0mm Pull Cord Replacement for Chainsaw Lawn Mower Chainsaw Trimmer Brush Cutter',\n",
+       " 563: 'Stens 146-919 Starter Rope, 100ft, 5 Solid Braid',\n",
+       " 564: 'New Stens Trueblue 100\\' Starter Rope 146-915 Compatible with Size 4 1/2, Diameter 9/64\", Length 100\\', Made ByAn OEM Supplier, Packaging typeBranded Spool, High wear Resistant, Low Stretch',\n",
+       " 565: \"Stens New 100' Diamond Braid Starter Rope 145-612#5 Diamond, White\",\n",
+       " 566: 'Briggs & Stratton Starter Rope & Grip 5042K',\n",
+       " 567: 'HIFROM Recoil Starter Pull Start Replacement for Tecumseh 590704 590736 590746 590748 590748A 590671 590788 5.5HP to 10HP Engine',\n",
+       " 568: 'Zipper by The Yard - Ykk #4.5 Nylon Coil Zippers Chain Black 5-Yards of Make Your Own Zipper and 10 Multicolored Pulls in Soft Vinyl',\n",
+       " 569: 'Spartan Industrial - 1.5” X 1.5” (1000 Count) 2 Mil Clear Reclosable Zip Plastic Poly Bags with Resealable Lock Seal Zipper',\n",
+       " 570: '#5 Gray Nylon Coil Zippers by The Yard Bulk 10 Yards with 25pcs Silver Sliders for DIY Sewing Tailor Craft Bag Leekayer(Gray)',\n",
+       " 571: 'MebuZip #5 Antique Brass Metallic Nylon Coil Zippers by The Yard Bulk Coil Zipper Roll 10 Yards with 25pcs Pulls for DIY Sewing Craft Bags (Beige)',\n",
+       " 572: 'Metallic Zipper by The Yard Bulk 10 Yard Black Zipper Roll for Sewing, Upholstery with 25 Gun Metal Sliders, 5 Nylon Coil; by Mandala Crafts',\n",
+       " 573: 'Stosts Rainbow Nylon Coil Zipper by The Yard, 5 Yards Colorful Teeth Black Zipper Tape with 10 Pieces #5 Metallic Slider Pull Tab, Sewing Zipper Bulk Supplies for DIY Tailor Craft Bag Purse',\n",
+       " 574: 'Goyunwell Nylon Black Zippers by The Yard #5 10 Yards Nylon Black Long Zipper Tape for Sewing 20Pcs Gunmetal Pulls Slider Zipper by The Yard Black Zipper Roll for Craft Bag Purse Sewing Black Tape',\n",
+       " 575: 'VOC Zippers #5 Zippers for Sewing,Rainbow Teeth Nylon Zipper by The Yard Black Zipper Tape with 10PCS Pulls for Tailor Sewing Crafts 5 Yards(Black Tape)',\n",
+       " 576: '#5 Nylon Coil Zippers by The Yards Black Nickel Metallic Teeth Black Tape with 25 PCS Zipper Sliders DIY Zippers for Sewing Tailor Craft Bag(Black Nickel Black) SHUNLI',\n",
+       " 577: 'Resealable Bags 3.5\"×4.5\", 200PCS, Extra Thick 4 Mil Clear Plastic Reclosable Ziplock Bags with Lock Seal Zipper for Jewelry Sandwich Dry Food Snack Incense Storage Packaging Poly Bags',\n",
+       " 578: 'B.Y Elements #5 Zippers by The Yard, Rainbow Teeth Nylon Coil Long Zipper, 10 Yards Coloured Tape with 10PCS Metallic Sliders for DIY Sewing Tailor Craft Bags(Coloured Tape)',\n",
+       " 579: '#5 Nylon Coil Zippers for Sewing, 30 Colors (18 Inches, 60 Pieces)',\n",
+       " 580: 'Sew on Hook and Loop Style 2 Inch Non-Adhesive Back Nylon Strips Fabric Fastener Non-Adhesive Interlocking Tape Black,5 Yard',\n",
+       " 581: 'Nuburi - Zipper by The Yard - 10 Yards of Make Your Own Zipper - with Zipper Pulls (Black)',\n",
+       " 582: 'VELCRO Brand Heavy Duty Tape with Adhesive | 15 Ft x 2 In | Holds 10 lbs, Black | Industrial Strength Roll, Cut Strips to Length | Strong Hold for Indoor or Outdoor Use',\n",
+       " 583: 'Gleener Ultimate Fuzz Remover Fabric Shaver & Lint Brush | Adjustable Depiller for Clothes & Furniture (Slate Blue)',\n",
+       " 584: 'EZ Melts Zinc for Immune Support, 30 mg, Sublingual Vitamins, Vegan, Zero Sugar, Natural Blueberry Flavor, 60 Fast Dissolve Tablets',\n",
+       " 585: 'VIVOSUN Two Packs Heavy Duty Peel & Stick Zipper for Dust Barriers 7ft x 3inch',\n",
+       " 586: 'YKK #5 CN Zipper Coil Chain. Each Yard Comes with 2 Sliders. (Black, 5 Yards, 10 Black Sliders)',\n",
+       " 587: 'YKK Double Slide Zipper YKK #4.5 Coil with Two Long Pull Head to Head Closed Ended on Both Sides Made in USA (30 Inch, Mixed 8 Colors)',\n",
+       " 588: 'VIVOSUN One Pack Heavy Duty Peel & Stick Zipper for Dust Barriers 7ft x 3inch',\n",
+       " 589: 'YaHoGa #10 72 Inch Separating Large Plastic Zippers Black Tape with Double Pull Tab Slider Heavy Duty Zippers for Sewing, Sleeping Bag, Boat, Canvas, Cover, Trampoline, Dog Bed, Tent (72\" 1pc)',\n",
+       " 590: 'Disney Pixar The Incredibles Plush Stuffed Jack Jack Pillow Buddy - Kids Super Soft Polyester Microfiber, 15 inch (Official Disney Pixar Product)',\n",
+       " 591: 'Frienda 50 Pieces Nylon Coil Zippers for Tailor Sewing Crafts 25 Colors Nylon Zippers (20 Inch)',\n",
+       " 592: 'Wowfit 200 Count 5x7 inches Clear Cellophane Plastic Bags, Resealable Self-Sealing Cello Bags Good for Cookies, Decorative Wrappers, Party Favors, Candy and More',\n",
+       " 593: 'YaHoGa #5 Plastic Zipper by The Yard Bulk Black 5 Yards with 10pcs Ring Sliders for DIY Sewing Tailor Crafts Bags Tents (Black 5 Yards)',\n",
+       " 594: 'YaHoGa #5 Silver Metallic Nylon Coil Zippers by The Yard Bulk White 10 Yards with 25pcs Sliders for DIY Sewing Tailor Craft Bag (Silver White)',\n",
+       " 595: 'Clouser Minnow Fishing Flies - Yellow & Brown - Mustad Signature Duratin Fly Hooks - 6 Pack (Assortment)',\n",
+       " 596: 'Fishing Hook Covers Hook Bonnets Treble Hook Guards - One Size Fits Most, Tangles Free, EVA Material Fishing Hook Caps Protect Your Sharp Hooks and Long Using',\n",
+       " 597: 'THKFISH 50pcs/Box Inline Single Hook Large Eye with Barbed Replacement Fishing Hook for Spoon Lures Baits Jigs Spinner #2#1 1/0 2/0 3/0 Black',\n",
+       " 598: '30Pcs/Box Drop Shot Hooks in-line Drop Shot Rig Fishing Hooks for Bass,Perch',\n",
+       " 599: 'Barb Fly Fishing Hooks- 150pcs Long Shank Fly Tying Jig Hook High Carbon Steel Super Sharp Barbed Hook Tips Round Bend Streamer Hook (2#, White',\n",
+       " 600: '150PCS Premium Fishing Hooks, Multi -Size Fishhooks Fit for Different Fishing Needs, Carbon Steel Fishhooks W/Portable Plastic Box, Strong Sharp Fish Hook with Barbs for Fresh/Saltwater',\n",
+       " 601: 'Double Fishing Hooks Frog Hooks, 50pcs High Carbon Steel Dual Frog Hooks Classic Open Shank Double Frog Hooks Barb Fishing Bait Hooks Saltwater Freshwater Size 8#-4/0',\n",
+       " 602: 'BiaoGan 500PCS Small Fishing Hooks, Assorted 10 Sizes(3#-12#) Fish Hooks Portable Plastic Box, Strong Sharp Fishhook with Barbs for Freshwater/Seawater (Black)',\n",
+       " 603: 'Fly Tying Fishing Hooks Set - 500pcs Barbed Streamer Hooks High Carbon Steel Aberdeen Hooks Long Shank Jig Nymph Hook Dry Fly Hooks Fishing Tackle Box',\n",
+       " 604: '150PCS Premium Fishhooks, Carbon Steel Fishing Hooks , Strong Sharp Fish Hook with Barbs for Freshwater/Seawater',\n",
+       " 605: 'Rodeel Wire Leader Hook Rigs Single Hook - 2x6pcs Nylon Coated Fishing Wire Leader Fishing Lure Rig for Saltwater Freshwater Size:6/0',\n",
+       " 606: '60PCS/Box DERKERL Circle Fishing Hooks, Duplex Stainless Steel Forged Long Shank Hook Extra Strong Fish Hook Extra Strong Stainless Steel Fishing Hooks 6 Sizes: 4/0 5/0 6/0 7/0 8/0 9/0#',\n",
+       " 607: 'Beoccudo Baitholder Fishing Hooks, Saltwater Freshwater Long Shank Jig Barbed Hook for Bass Walleye Flounder',\n",
+       " 608: 'Facikono Fishing Worm Hooks for Freshwater Saltwater Bass Trout, 125pcs Wide Gap Soft Plastic Bait Jig Fish Hooks',\n",
+       " 609: 'Black Anchor Circle and J Hooks 160pcs/box Saltwater Fishing Gear 3X Strong Hooks Size 1/0 2/0 3/0 4/0 5/0',\n",
+       " 610: 'Catfish Hooks Big River Bait Hook Size 6/0,50PCS High Carbon Steel Fishing Hooks Saltwater Black Nicke Heavy dutyl',\n",
+       " 611: '200PCS High Carbon Steel Barb Fishing Hook, 10 Sizes (3#-12#) Strong Custom Offset Sport Black High Carbon Steel Barb Fishing Hook',\n",
+       " 612: 'Baitholder Beak Hook Wire Leader Rig - 24pcs Bottom Fishing Rig Nylon Coated Wire Leaders Rig with Baitholder Barb Hooks Rolling Swivel Fishing Lure Bait Rig Saltwater Freshwater Fishing',\n",
+       " 613: 'VIPMOON 500 Pcs High-Carbon Steel Barbed Fishing Hooks with Holes, 10 Specifications of Fishing Hooks, Portable Boxed Fish Hooks (Gold)',\n",
+       " 614: 'LikeFish 100pcs/pack Bait Holder Hooks 2 Barbs Fishing Hooks (1/0-100pcs)',\n",
+       " 615: 'Fishing Wire Leader Hook Rigs - 24pcs BaitHolder Fishing Hooks Stainless Steel Fishing Wire Leader with Swivel Hook Fishing Lure Bait Rigs Saltwater (2/0)',\n",
+       " 616: 'JL Sport Classic Sharp Durable Double Hooks - 20pcs High Carbon Steel Saltwater Hook Small Fly Tying Fishing Hooks',\n",
+       " 617: 'Eagle Claw 139H-8 Assorted Baitholder Snelled Fish Hook, 6 Piece (Bronze)',\n",
+       " 618: '90° Double Round Bend ST Point',\n",
+       " 619: 'Water Gremlin Removable Split Shot Pro Pack, 48ea/BB, 36ea/3/0, 16ea/7, 12ea/5, 12ea/4, Multi',\n",
+       " 620: 'Fishing Hooks Saltwater Live Bait Hooks 2X Strong Stainless Steel Fishing Hook Bait Fish Hooks Set',\n",
+       " 621: 'Circle Hooks Saltwater Fishing Hooks, 150PCS Fishing Circle Hooks 2X Strong Offset Octopus Catfish Fishing Hooks Assortment High Carbon Steel Bait Fishing Hooks Kit – Size #1 1/0 2/0 3/0 4/0 5/0',\n",
+       " 622: 'Mimilure Stainless Steel Fish Lip Grip and Fishing Pliers with Lanyard Fish Tool Sets for One-Hand Operated Fish Holder/Split Ring/Braid Cutter/Hook Remover',\n",
+       " 623: 'Octopus Fishing Hooks, 50pcs Barbed Bait Holder Fishing Hooks Jig Hook Offset Circle Octopus Hooks Baitholder Hook for Freshwater Saltwater Extra Sharp High Carbon Steel Hook Size: 3/0',\n",
+       " 624: 'Small Fishing Hooks 500pcs Black High Carbon Fishing Hooks Set 10 Sizes with a Plastic Box (500pcs)',\n",
+       " 625: 'Sougayilang Fishing Hooks High Carbon Steel Worm Soft Bait Jig Fish Hooks with Plastic Box',\n",
+       " 626: 'QualyQualy 500pcs Fishing Hooks 6#-15# Assorted Fishing Hooks Freshwater Small Fish Hooks High Strength Carbon Steel Fishing Hooks with Plastic Box',\n",
+       " 627: 'Jig Fish Hooks Octopus Barb Fishing Hooks Beak Bait Holder Hook with 2 Baitholder Barbs 120pcs/lot 8299',\n",
+       " 628: 'HETH 2000pcs Fishing Worm Hooks High Carbon Steel Wide Gap Offset Fishing Hook Set for Saltwater and Freshwater with 10 Sizes',\n",
+       " 629: 'FCFKUK 200pcs/box Large Size Premium Fishhooks, 8 Sizes Strong Custom Offset Sport Black High Carbon Steel Barbs Fishing Hooks',\n",
+       " 630: 'Dr.Fish Pack of 30 6/0 Octopus Circle Hooks Catfish Live Bait Fishing Hooks Offset Stainless Saltwater Competition Fishing Surf Fishing Hook',\n",
+       " 631: '500PCS Premium Fishhooks, 10 Sizes Reemoo Carbon Steel Fishing Hooks W/ Portable Plastic Box, Strong Sharp Fish Hook with Barbs for Freshwater/Seawater',\n",
+       " 632: 'Beoccudo Circle Fishing Hooks Saltwater Fishing Gear, 180pcs/box Bass Catfish Fishing, Octopus Offset Hooks Set, Size 1/0 2/0 3/0 4/0 5/0 6/0',\n",
+       " 633: 'Bass Fishing Worm Hooks Set, 120pcs 3X Offset Fishing Hooks Bass High Carbon Steel Worm Bait Hooks Jig Fish Hooks for Bass Trout Saltwater Freshwater Fishing Tackle Accessories',\n",
+       " 634: 'BASSDASH 180 Pieces Aberdeen Fishing Hooks Assortment, Light Bronze Color, Hook Sizes 2/0, 1/0, 2, 4, 6, 8, Tackle Box',\n",
+       " 635: 'Personali-Key Ilco Gears Shape Kwikset KW Key Blank',\n",
+       " 636: 'XYark 12 Pack Blank Notebook Journals Bulk, Plain, 60 Pages, 5.5x8.3 inch, A5, Travel Journal Set for Travelers, Students, Church, Office, Drawing Sketchbook Diary Paper Subject Book Planner, Black',\n",
+       " 637: 'Ilco Taylor SC4-BR Key Blank, for SCH C 6 PIN (50-Pack)',\n",
+       " 638: '10 pc AM3 Key Blanks/for American Lock / AM3 1045 Key Blank/Ilco USA',\n",
+       " 639: 'WILSHIN RFID 125KHz Card Reader Writer - Readable 125khz EM4100 Chip card Compatible with Proximity II Card Including Key-fob 5pcs 3M Sticker 2pcs Blank Card 5pcs',\n",
+       " 640: 'Prime-Line MP66750 SC1 Key Blank, Brass Construction, for 5-Pin Schlage C Keyways, Pack of 50',\n",
+       " 641: 'RamPro Hide-a-Spare-Key Fake Rock - Looks & Feels like Real Stone - Safe for Outdoor Garden or Yard, Geocaching (1)',\n",
+       " 642: 'Hand Stamp 1/16 Char Reads',\n",
+       " 643: 'Ilco DND-SC4 6 Pin C Keyway \"Do Not Duplicate\" Key Blanks Box of 50',\n",
+       " 644: 'Salome Idea Mixed Set of 30 Large Skeleton Keys in Antique Silver - Set of 30 Keys (Silver Color)',\n",
+       " 645: 'Kaba Ilco DND-SC1 SC1 Schlage DND Key Blank (Pack of 50)',\n",
+       " 646: 'Uniden Bearcat BC125AT Handheld Scanner, 500-Alpha-Tagged Channels, Close Call Technology, PC Programable, Aviation, Marine, Railroad, NASCAR, Racing, and Non-Digital Police/Fire/Public Safety.',\n",
+       " 647: 'Kwikset 83382-002 40083 Brass Key Blank',\n",
+       " 648: 'NBA San Antonio Spurs Lanyard',\n",
+       " 649: 'Custom Self-Inking Stamp - Up to 3 Lines - 11 Color Choices and 17 Font Choices',\n",
+       " 650: 'PH PandaHall 1000 Pcs 0.9x0.5 Inch Rectangle White Paper Tags Marking Strung Tags Writable Tags Display Label Price Tags with Hanging String for Jewelry Gift Sale Display',\n",
+       " 651: 'Price Tags with Strings Attached, 1000pcs Marking White Merchandise Hang Tags Labels for Goods Gifts Jewelry Clothing Garage Clearance Sale Yard Rummage Sale Supplies 1-3/8 x 2-1/8 (1.37x2.16) inch',\n",
+       " 652: '100 Pcs Square Gift Tags with String,Blank White Paper Tags with 100 Feet Jute Twine for Wedding Favor,Christmas',\n",
+       " 653: 'White Paper Tags, Jewelry Price Tags with string (3/8\" x 7/8\")',\n",
+       " 654: 'YEJI 100 pcs Kraft Paper Tags, Gift Tags with String Price Tags Jewelry',\n",
+       " 655: 'Price Tags with String Attached, 1000pcs White Smooth Surface Marking Merchandise Strung Tags Writable Label Hang Tags for Pricing Gift Jewelry Clothing Yard Sale Garage Supplies 1.75 x 1.093 inch',\n",
+       " 656: 'Price Tags with String Attached, 500pcs White Smooth Surface Marking Merchandise Strung Tag Writable Label Small Hang Tag for Pricing Gift Jewelry Clothing Yard Sale Garage Supplies 1.375 x 0.875 inch',\n",
+       " 657: '1000 Pieces White Tags with String Marking Strung Tags, Writable Tags Display Label for Products Jewelry Clothing Tags, 0.9 x 0.51 inches',\n",
+       " 658: 'Price Tags with String Attached, 1000pcs White Matte Surface Marking Merchandise Strung Tags Writable Label Small Hang Tag for Pricing Gift Jewelry Clothing Yard Sale Garage Supplies 1.75 x 1.093 inch',\n",
+       " 659: '500PCS Small Price Tags with String,1.8\" X 1\" Clothes Size Tags Coupon Tags Making Tag White Store Tags Clothing Tags for Product Jewelry Clothing Tags (White)',\n",
+       " 660: 'Officepal 300pcs 4.72 inches x 2.36 inches String Blank Kraft Paper Tags and Ropes to Label Your Items, Gift, Presents (4.72”x2.36”)',\n",
+       " 661: 'Price Tags, Kraft Paper Gift Tags 100 PCS Paper Tags with 100 Feet Jute String for Arts and Crafts, Wedding Christmas Day Thanksgiving,7 cm X 4 cm',\n",
+       " 662: 'GILLRAJ Price Tags with Strings Attached Pack of 1000 1.93\"x 1.25\" (49mm x 32mm) White Blank Writable Price Name Labels for Gift Jewelry Clothing Small Paper Hang Tags',\n",
+       " 663: '500Pcs Price Tags with String Attached by Divine Light, 0.91 x 0.55 inches Premium Writable Jewelry Tags, Paper Sale Tags with String Pricing Tags - for Anything You Need to Identify or Price',\n",
+       " 664: 'White Marking Tags Price Tags Price Labels Display Tags with Hanging String, 500 Pack (24 x 15 mm)',\n",
+       " 665: '300 Pieces Marking Tags Kraft Price Tags Writable Blank Price Labels Display Tags with Elastic Hanging String(1.38 x 0.71 Inch)',\n",
+       " 666: '500 Pack Jewelry Tags with String by Ummeral, Premium Writable Sales Tags White Marking Tags for Jewelry Small Items, Sale Price Tags Display Labels - 1.37 x 0.86 Inches',\n",
+       " 667: 'GILLRAJ Shipping Tags with Strings Attached 4 3/4 x 2 3/8 inches Strung Manila Paper Hanging Tags with Reinforced Eyelet Hole (Box of 100)',\n",
+       " 668: 'Red Price Tags 300pcs, Tag with Strings Attached Matte Surface Marking Merchandise Hang Tag Labels for Christmas Gift Jewelry Clothing Garage Clearance Sale Yard Rummage Sale Supplies 1.69 x 2.75 inch',\n",
+       " 669: 'Outus 500 Pieces White Tags with String Marking Strung Tags by 34.8cm Large Size Writable Tags Display Label for Products Jewelry Clothing Tags',\n",
+       " 670: 'KC Store Fixtures 08904 Perforated Merchandise Tags without Strings, 1-3/4\" x 2-7/8\", Red (Pack of 1000)',\n",
+       " 671: 'Kraft Tags,100 PCS White Kraft Paper Tag with 100 Feet Jute Twine String, Rectangle Tags 3.5\" x 1.7\"',\n",
+       " 672: 'Thank You Tags,Gift Wrap Tags,100 Pcs Kraft Paper Tags with String, Vintage Wedding Favor Tags with 100 Feet Jute Twine',\n",
+       " 673: 'AVERY White Marking Tags Strung, Pack of 1000 (12204),,1 3/4 x 1 3/32',\n",
+       " 674: 'Avery 12201 Medium-Weight White Marking Tags, 2 3/4 x 1 11/16 (Box of 1000) - Packaging May Vary',\n",
+       " 675: 'Avery Price Tags with String Attached, 11.5 pt. Stock, 3-3/4\" x 1-7/8\", 1,000 Manila Hang Tags (12503)',\n",
+       " 676: 'Avery Price Tags with String Attached, 11.5 pt. Stock, 4-3/4\" x 2-3/8\", 1,000 Manila Hang Tags (12505)',\n",
+       " 677: '7 100 Pcs White Hang Tag Nylon String Snap Lock Pin Loop Fastener Hook Ties',\n",
+       " 678: 'Avery Textured White Scallop Round Paper Tags, 2-1/2-Inch Without Strings, Laser/Inkjet, Print-to-The-Edge, 90 Tags per Package (80511)',\n",
+       " 679: '100 PCS Kraft Paper Tags with String Blank Tags Vintage Wedding Favor Hang Tags with 100 Feet Natural Jute Twine Retangle Tags for Crafts',\n",
+       " 680: 'Merchandise Tags #8, White, Scalloped, Hole (no Strings), 2 7/8 x 1 3/4, Box of 1000',\n",
+       " 681: 'KC Store Fixtures 08901 Perforated Merchandise Tags without Strings, 1-3/4\" x 2-7/8\", White (Pack of 1000)',\n",
+       " 682: 'KC Store Fixtures 08902 Perforated Merchandise Tags without Strings, 1-3/4\" x 2-7/8\", Orange (Pack of 1000)',\n",
+       " 683: 'KC Store Fixtures 09301 #3 Merchandise Tag without String, 7/8\" x 1-1/4\", White (Pack of 1000)',\n",
+       " 684: 'KC Store Fixtures 09302 #4 Merchandise Tag without String, 1\" x 1-1/2\", White (Pack of 1000)',\n",
+       " 685: 'KC Store Fixtures 08912 Perforated Merchandise Tags without Strings, 1-3/4\" x 2-7/8\", Light Blue (Pack of 1000)',\n",
+       " 686: 'KC Store Fixtures 09303 #5 Merchandise Tag without String, 1-1/8\" x 1-3/4\", White (Pack of 1000)',\n",
+       " 687: 'KC Store Fixtures 08908 Perforated Merchandise Tags without Strings, 1-3/4\" x 2-7/8\", Light Green (Pack of 1000)',\n",
+       " 688: 'KC Store Fixtures 08906 Perforated Merchandise Tags without Strings, 1-3/4\" x 2-7/8\", Yellow (Pack of 1000)',\n",
+       " 689: 'KC Store Fixtures 08911 Perforated Merchandise Tags without Strings, 1-3/4\" x 2-7/8\", Lavender (Pack of 1000)',\n",
+       " 690: 'Baoblaze 3pcs/Set Creative Wood Bamboo Case Jewelry Box Storage Organizer Christmas G - Red',\n",
+       " 691: \"LittleCat Stud Earrings Storage Book Jewelry Storage Box Earrings Display Box PU Leather Jewelry Storage Book Women's Jewelry Clutch Bag (Color : Purple)\",\n",
+       " 692: 'ASHUAIBAO Wooden Straw Woven Rattan Tassel Big Pendant Earrings Female',\n",
+       " 693: 'Storage Box,Cosmetic Organizer Vintage Style Classical Case Jewelry Storage Display Box Container Large Capacity(New Grapes)',\n",
+       " 694: '2 Layers Unpainted Wooden Jewellery Box Dispaly Holder DIY Handmade Crafts',\n",
+       " 695: 'TOPBATHY Transparent Storage Box Portable Rectangle Clear Organizer Case for Earring Jewelry Beads Coins 24pcs',\n",
+       " 696: 'Sumerlly Little Jewelry Storage Box Organizer Rotating Four-Layer for Necklace Earrings Rings Bracelets',\n",
+       " 697: 'WatanGems 231.4g, 1.8\"x2.6\" Black Fossil Orthoceras Jewelry Box Round Shape Well Made & Polished Handmade from Morocco, Mineral, Specimens, Ring Stash, Jewelry Organizer, Gifts, F2343',\n",
+       " 698: 'Ruiqas Jewelry Case, 1Pcs Oval Shape Vintage Flower Carved Zinc Alloy Jewelry Box Case for Ring Storage',\n",
+       " 699: 'dailymall Premium Heart Shaped Jewelry Box Wooden Gift Box Case Jewelry Organizer',\n",
+       " 700: 'BYCDD Watch Box Organizer, Watch Storage Case Box with Removable Cushions Jewelry Organizer Storage Case Jewelry Display Case Collection Boxes,Black',\n",
+       " 701: 'RJ Displays-25 Brown Kraft Jewelry Display Cotton Filled Assorted Sizes. Gift Box Set 5 Each of Size #11, 21, 32, 33, 82 for Ring, Pendants, Necklace, Bracelets, Watch',\n",
+       " 702: '888 Display - Pack of 10 Boxes of 5 3/8\" x 3 7/8\" x 1\" SilverFoil Cotton Filled Jewelry Boxes',\n",
+       " 703: '888 Display - Case of 100 Boxes of 3\" x 2 1/8\" x 1\" Black Matte Cotton Filled Jewelry Boxes',\n",
+       " 704: '888 Display - Pack of 10 Boxes of 2 1/8\" x 1 5/8\" x 3/4\" White Glossy Shiny Cotton Filled Jewelry Boxes',\n",
+       " 705: 'RJ Displays-25 Pack Cotton Filled Silver Foil Boxes for Jewelry Jewelry Earring, Pendan Necklace,Watch, Pen, Charm Bracelets, Gift Packaging (8 1/16 x 2 1/4 x 1 3/8 (#82))',\n",
+       " 706: \"Azeeda 'Cat & Wool' Treasure Chest/Jewellery Box (TC00041560)\",\n",
+       " 707: 'JF Retro Glass Jewelry Storage Box with lid/Classic Drawer Storage Box with Removable Velvet Beauty Decorative dust (Size : 20.712.34.3cm)',\n",
+       " 708: 'Jewellery Organizer Case, Lockable Classic Leather Single Layer Multi-Function Jewelry Box Built-in Mirror',\n",
+       " 709: 'JPB White Swirl Cotton Filled Jewelry Box #21 (Case of 100) 2.5 inches x 1.5 inches',\n",
+       " 710: 'Warm Company Batting 2391 72-Inch by 90-Inch Warm and Natural Cotton Batting, Twin',\n",
+       " 711: 'Gold Cotton Filled Jewelry Watch/Pen/Bracelet Display Box #82 - Pack of 100',\n",
+       " 712: 'JPI DISPLAY #82 Cotton Filled Boxes, 8\" L x 2\" W, Matte Black, 100 Count',\n",
+       " 713: '888 Display - Pack of 6 Boxes of 7\" x 5\" x 1 1/4\" H Light Pink Kraft Cotton Filled Jewelry Boxes',\n",
+       " 714: 'Pacific Jewelry Displays Cotton Filled Box (White Swirl) - Pack of 100',\n",
+       " 715: 'RJ Displays- 20 Pack Cotton Filled Brown Kraft Box for Pocket Watch, Ring, Earring, Necklace Chain Jewelry and Gift Boxes-Size 32',\n",
+       " 716: 'Kraft Jewelry Gift Boxes w/ Lids, 6x5x1 Cotton Filled Jewelry Boxes, Necklace Gift Box, Bracelet Gift Box, Earring Box, Bulk Jewelry Boxes for Shipping, Small Business, Accessories, White 42 Pcs',\n",
+       " 717: '10 Matte Black Color Cotton Boxes Jewelry Bracelet, Watches, Necklace and Anklet Gift Displays 8\" x 2\" By RJ Displays',\n",
+       " 718: 'Pack of 20 Boxes Elegant White Paper Cotton Filled Boxes Jewelry Bracelet, Watches, Necklace and Anklet Gift Displays 8\" x 2\" x 1\" Inches #82',\n",
+       " 719: 'TheDisplayGuys 25-Pack #82 White Swirl Cotton Filled Paper Jewelry Gift Boxes (8 1/16\" x 2 1/4\" x 1 3/8\") for Necklaces, Bracelets, Watches & Pens Display Retail and Shipping',\n",
+       " 720: 'TheDisplayGuys 25-Pack #34 Silver Foil 3 7/8\" x 3 7/8\" x 2\" Cotton Filled Paper Jewelry Boxes for Gift Display Shipping & Retail',\n",
+       " 721: 'Feyarl Vintage Trinket Jewelry Box Rings Earrings Treasure Case Organizer Storage Keepsake Ornate Box for Christmas Birthday Woman Girl Gift (Red) 7.1 x 4.7 x 3.1 inches',\n",
+       " 722: 'Krissy&Co Vintage Jewelry Box, Ivory Faux Leather, with Two Layers for Earrings, Necklaces, Rings - Beautiful Bridal Jewelry Boxes with Lace for Women and Girls - Classic Accessories Organizer',\n",
+       " 723: 'RosinKing Earring Storage Acrylic Box Bracelets Jewelry Display Hanger Organizer Necklace Rings Holder with 3 Transparent Drawer New Year Birthday Easter Gifts Presents for Women Girl',\n",
+       " 724: 'Wnakeli Jewellery Gift Box for Women Rectangle Travel Jewelry Case Girls Earring Holder Necklace Organizer Jewelry Organizer for Home or Outdoor Storage 1Pcs',\n",
+       " 725: \"Rumikrafts Handmade Floral Heart Shape Trinket Box for Jewelry/Storage/Valentines's Gift for her (Multicolor)\",\n",
+       " 726: 'Dolland Rectangular Storage Box Wooden Display Storage Case Handmade Craft Jewelry Case Gift Box',\n",
+       " 727: '16 Matte Black Color Cotton Boxes Jewelry Bracelet, Watches, Necklace and Anklet Gift Displays 8\" x 2\" By RJ Displays',\n",
+       " 728: 'ThermoPro TP03 Digital Instant Read Meat Thermometer Kitchen Cooking Food Candy Thermometer with Backlight and Magnet for Oil Deep Fry BBQ Grill Smoker Thermometer',\n",
+       " 729: 'Solar Lights Outdoor [6 Pack/3 Working Mode], SEZAC Solar Security Lights Solar Motion Sensor Lights Wireless IP 65 Waterproof Outdoor Lights for Garden Fence Patio Garage (42 LED)',\n",
+       " 730: 'Full Motion TV Wall Mount Bracket Dual Articulating Arms Swivels Tilts Rotation for Most 37-70 Inch LED, LCD, OLED Flat Curved TVs, Holds up to 132lbs, Max VESA 600x400mm by Pipishell',\n",
+       " 731: 'Mkeke Compatible with iPhone XR Screen Protector, iPhone 11 Screen Protector, Tempered Glass Film for Apple iPhone XR and iPhone 11, 3-Pack Clear',\n",
+       " 732: 'Amazon Basics Foldable, 14\" Black Metal Platform Bed Frame with Tool-Free Assembly, No Box Spring Needed - Twin',\n",
+       " 733: 'AquaBliss High Output Revitalizing Shower Filter - Reduces Dry Itchy Skin, Dandruff, Eczema, and Dramatically Improves The Condition of Your Skin, Hair and Nails - Chrome (SF100)',\n",
+       " 734: 'TaoTronics LED Desk Lamp, Eye-caring Table Lamps, Dimmable Office Lamp with USB Charging Port, 5 Lighting Modes with 7 Brightness Levels, Touch Control, White, 12W, Philips EnabLED Licensing Program',\n",
+       " 735: 'Mounting Dream TV Mount TV Wall Mount with Swivel and Tilt for Most 32-55 Inch TV, UL Listed Full Motion TV Mount with Articulating Dual Arms, Max VESA 400x400mm, 99 lbs. Loading, 16 inch Studs MD2380',\n",
+       " 736: 'Mounting Dream UL Listed TV Mount for Most 37-70 Inch TV, Universal Tilt TV Wall Mount Fit 16\", 18\", 24\" Stud with Loading 132 lbs & Max VESA 600x400mm, Low Profile Flat Wall Mount Bracket MD2268-LK',\n",
+       " 737: 'LiBa PEVA 8G Bathroom Shower Curtain Liner, 72\" W x 72\" H, Clear, 8G Heavy Duty Waterproof Shower Curtain Liner',\n",
+       " 738: 'ZINUS Compack Metal Bed Frame / 7 Inch Support Bed Frame for Box Spring and Mattress Set, Black, Queen',\n",
+       " 739: 'DEWALT 20V Max Cordless Drill / Driver Kit, Compact, 1/2-Inch (DCD771C2)',\n",
+       " 740: 'VIVO Dual LCD LED 13 to 27 inch Monitor Desk Mount Stand, Heavy Duty Fully Adjustable, Fits 2 Screens, STAND-V002',\n",
+       " 741: 'BLACK+DECKER 20V MAX Cordless Drill / Driver with 30-Piece Accessories (LD120VA) , Orange',\n",
+       " 742: 'Regalo Easy Step 38.5-Inch Extra Wide Walk Thru Baby Gate, Includes 6-Inch Extension Kit, 4 Pack Pressure Mount Kit, 4 Pack Wall Cups and Mounting Kit',\n",
+       " 743: 'ZINUS 9 Inch Metal Smart Box Spring / Mattress Foundation / Strong Metal Frame / Easy Assembly, Queen',\n",
+       " 744: \"Dora's Womens Beach Floral Maxi Dress V-Neck Printed Unique Loose Summer Boho Dresses High Waisted Yellow\",\n",
+       " 745: \"Folouse Do Not Disturb I'm Gaming Funny Novelty Cotton Socks Gifts for Brother Teenage Boys Game Lovers\",\n",
+       " 746: 'Bila Womens Sleeveless Rayon Maxi Dress Features a tie Keyhole Neck,Small Red',\n",
+       " 747: 'Bila Ladies Double Sleeve Ruffle Blouse (Small, Black)',\n",
+       " 748: 'High Ball: A Beautifully Designed Interactive Game and Light Show - Lights up Any Occasion: Party, Game Night, Hangout, Camping Trip, Office, or just Chilling at Home',\n",
+       " 749: 'Bila Womens Sleeveless Rayon Maxi Dress Features a tie Keyhole Neck X-Large Navy',\n",
+       " 750: \"OUGES Women's V-Neck Pattern Pocket Maxi Long Dress(Floral-26,XXL)\",\n",
+       " 751: 'Bila Womens Sleeveless Blouse Top, Small Ivory',\n",
+       " 752: 'Cotton Dresses for Women, Navy Blue Cami Tank Maxi Tiki Modest Casual Dress for Women Ladies Mom Evening Date Party Night Out Flowy Dresses (Blue, S)',\n",
+       " 753: 'INC International Concepts Tiered Sequined Tank Top (Flower Tile, X-Small)',\n",
+       " 754: \"Hotkey Women's Sleeveless Spaghetti Strap Casual Swing T-Shirt Dresses Cocktail Party Dress Beach Sundress for Summer Red\",\n",
+       " 755: \"French Connection Women's Classic Crepe Light Polly Tops, Clement Blue, M\",\n",
+       " 756: 'Bila Sleevless Asymmetrical Dress (Navy & Floral Print, M)',\n",
+       " 757: 'Forthery Tie Dye Dresses for Women Summer Beach Short Sleeves Dress Casual Midi Dress Side Slits Dress(Light Blue,M)',\n",
+       " 758: 'CeCe Short Sleeve Heirloom Polka Dot Blouse Rich Black MD',\n",
+       " 759: 'Inc International Concepts - Illusion Tie-Front T-Shirt - White - XL -',\n",
+       " 760: \"Bila Women's Short Sleeve Blouse Ocean Blue Size X-Large SB628\",\n",
+       " 761: 'FINELOOK FINELOOK Toddler Baby Girls Swimwear Bikini Cover Up Pom Pom Tassel Poncho Beach Sundress (6-12 Months, Blue Daisy)',\n",
+       " 762: 'Bila Womens Size Large Sleeveless Blouse, Ivory/Multi',\n",
+       " 763: 'Bila Womens Shirt 3/4 Sleeve Peasant Blouse Top Cold Shoulder (Teal, Small)',\n",
+       " 764: 'shekiss Womens Bohemian Bodycon Dashiki African Vintage Print Sexy V-Neck Club Midi Dress Black/Red 3X',\n",
+       " 765: 'Riviera Sun Rasta Long Smocking Dresses for Women 21932B-XL',\n",
+       " 766: \"Do Not Disturb I'm Gaming Socks,Gamer Christmas Gift ideas,Novelty Socks For Man Gift,Teen Boys,Anniversary,Husband\",\n",
+       " 767: 'Lea & Perrins The Original Worcestershire Sauce (5 fl oz Bottle)',\n",
+       " 768: \"Kanu Surf Little Boys' Toddler Fiji UPF 50+ Sun Protective Rashguard, Orange, 2T\",\n",
+       " 769: \"Rubies Child's The Original Inflatable Dinosaur Costume, T-Rex, Small\",\n",
+       " 770: 'Drunk Stoned or Stupid [A Party Game]',\n",
+       " 771: 'Bila Womens Short Sleeve Sheer Peasant Top Small Red',\n",
+       " 772: \"Mens Funny Do Not Disturb I'm Gaming Socks NON SLIP Video Game Lover Fathers Day Gift Birthday\",\n",
+       " 773: '21754-BLK-S-M Riviera Sun Long Dashiki Caftan / Caftans for Women Black',\n",
+       " 774: 'Because Patients Funny Stemless Wine Glass 15oz - Unique Gift Idea for Dentist, Dental, Medical, Hygienist, Doctor, Physician, Nurse - Perfect Birthday and Graduation Gifts for Men or Women',\n",
+       " 775: \"Bila Women's Size Small Sleeveless Beaded & Lace Crochet Blouse Top, Red\",\n",
+       " 776: 'Lightning Reaction Shocktato Party Game - The Hilariously Funny Game of Shocking Potato',\n",
+       " 777: 'Max Studio Womens Tencel Zip-up Casual Top Green XS',\n",
+       " 778: 'Do Not Disturb Gaming Socks, Funny Gamer Socks Fathers Day Gifts for Kids Teen Boys Mens Womens Game Lovers',\n",
+       " 779: 'Fidget Toys Set with Stress Balls for Kids, Teens and Adults, 32 Pack Stretchy Sensory Tool with Liquid Motion Timer for ADHD, Autism and Anxiety, Fun Fidgeting Game for Classroom and Office',\n",
+       " 780: \"Minibee Women's Linen Retro Chinese Frog Button Tops Blouse Blue 2XL\",\n",
+       " 781: 'Bila Womens Size Small Sleeveless Floral Blouse Top, Ink',\n",
+       " 782: '3D Socks Unisex Adult Animal Paw Crew Socks - Sublimated Print (Cat)',\n",
+       " 783: 'WWE Authentic Wear Naomi Neon Yellow Sunglasses',\n",
+       " 784: \"Yugo Sport Men's Plush Velour Bathrobe - Kimono Spa Hooded Robe (Medium-Large, Charcoal Velour)\",\n",
+       " 785: 'Ross Michaels Mens Robe Big & Tall with Hood - Long Plush 400GSM Luxury Bathrobe with Shawl Collar (Grey, Small/X-Large)',\n",
+       " 786: \"Arus Men's Shawl Collar Full Length Long Fleece Robe, Turkish Bathrobe, Navy Blue, XXL\",\n",
+       " 787: 'Ultra Soft Velour Robe Robes for Men 46904-GRY-M',\n",
+       " 788: \"Alexander Del Rossa Men's Warm Fleece Robe with Hood, Plush Big and Tall Bathrobe, Large-XL Navy Blue with Sherpa (A0262NBLXL)\",\n",
+       " 789: \"Men's Soft and Warm Bathrobe, Black Spa Robe with Sherpa Kimono Shawl Collar Unisex (Medium)\",\n",
+       " 790: \"DAVID ARCHY Men's Hooded Fleece Plush Soft Shu Velveteen Robe Full Length Long Bathrobe (M, Navy Blue)\",\n",
+       " 791: \"Realdo Mens Fleece Robe with Hood, Men's Warm Solid Color Robe Hooded Belt Bathrobe Black\",\n",
+       " 792: 'TowelSelections Super Soft Plush Kimono Bathrobe Fleece Spa Robe for Men X-Large/XX-Large Frost Gray',\n",
+       " 793: 'Anime Cosplay Flannel Robe Adult Fleece Pajamas Fashion Mens Kimono Bathrobes Woman Winter Long Robe (L/XL, Black)',\n",
+       " 794: \"Alexander Del Rossa Men's Warm Flannel Fleece Robe with Hood, Big and Tall Bathrobe, Large-XL Gray Stripe Limited Edition (A0452W18X)\",\n",
+       " 795: \"DISHANG Men's Ultra Soft Fleece Robe with Hood Pockets Warm and Cozy Sleepwear (Black, XXL)\",\n",
+       " 796: \"DAVID ARCHY Men's Coral Fleece Plush Robe Shawl Collar Heavyweight Full Length Long Big and Tall Warm Bathrobe (M, Dark Gray)\",\n",
+       " 797: \"Men's Long Robe Bamboo Viscose Soft Sleepwear Robe for Men\",\n",
+       " 798: \"PZZ BEACH One Size Men's Bathrobes with Pocket, Animal 3D Tiger Printed, Soft & Breathable Plush Collar Shawl Bathrobe\",\n",
+       " 799: 'ccko Mens Fleece Robe Warm Soft Plush Lightweight Hooded Long Robes for Men Big and Tall Mens Spa Bathrobes',\n",
+       " 800: \"Turkuoise Men's Warm Fleece Robe with Hood, Big and Tall Comfy Bathrobe\",\n",
+       " 801: \"Yugo Sport Men's Plush Velour Bathrobe - Kimono Spa Robe - Long Sleeve Shawl Collar (Medium-Large, Black Velour)\",\n",
+       " 802: \"KingSize Men's Big & Tall Terry Bathrobe with Pockets - Big - 5XL/6X, Black\",\n",
+       " 803: 'Unisex Hooded Robe Mens Womens Bathrobe, Charcoal One Size',\n",
+       " 804: \"Majestic International Men's Terry Velour Kimono Robe, White, One Size\",\n",
+       " 805: 'U2SKIIN Mens Fleece Robe Plush Collar Shawl Bathrobe(Grey,L/XL)',\n",
+       " 806: \"Derek Rose Men's Terry Velour Robe, Navy, XX-Large\",\n",
+       " 807: \"Alexander Del Rossa Men's Warm Fleece Robe, Plush Bathrobe, Large-XL Black (A0114BLKXL)\",\n",
+       " 808: \"Nautica Men's Long Sleeve Lightweight Cotton Woven Robe,Peacoat,Large/X-Large\",\n",
+       " 809: 'TowelSelections Men’s Robe Low Twist Cotton Terry Kimono Bathrobe X-Small/Small Navy',\n",
+       " 810: 'Ross Michaels Mens Robe - Mid Length - Plush Shawl Collar Bathrobe (Grey, L/XL)',\n",
+       " 811: \"KEMUSI Hooded Herringbone Men's Black Soft Spa Full Length Bathrobe With Grey Kimono Shawl Collar(L)\",\n",
+       " 812: 'Ross Michaels Mens Robe with Hood - Mid Length - Plush Shawl Collar Bathrobe (Grey, Large/X Large)',\n",
+       " 813: \"Alexander Del Rossa Men's Warm Fleece Robe with Hood, Big and Tall Bathrobe, Large-XL Black with Steel Gray Contrast (A0125BKSXL)\",\n",
+       " 814: 'Mens Plush Robe - Fleece Robe, Mens Bathrobe - Fig -Small/Medium',\n",
+       " 815: 'Ross Michaels Mens Robe Big & Tall with Hood - Long Plush Shawl Collar Bathrobe (Gray, 3X Large)',\n",
+       " 816: '46901-BLK-L Velour Robe / Robes for Men',\n",
+       " 817: 'TowelSelections Men’s Robe, Turkish Cotton Terry Shawl Bathrobe Large/X-Large Niagara Blue',\n",
+       " 818: 'Ross Michaels Mens Robe Big & Tall - Long Plush Shawl Collar Bathrobe (Black, 2X Large)',\n",
+       " 819: \"NY Threads Luxurious Men's Shawl Collar Fleece Bathrobe Spa Robe (Grey, Large/X-Large)\",\n",
+       " 820: \"Lands' End Mens Calf Length Terry Robe Rich Steel Regular Medium\",\n",
+       " 821: \"Nautica Men's Long Sleeve Cozy Soft Plush Shawl Collar Robe, Navy (KR06F7), One Size\",\n",
+       " 822: '46903-1A-XXL #followme Printed Plaid Velour Flannel Robe Robes for Men',\n",
+       " 823: '46902-GRY-XL #followme Plush Robe Robes for Men',\n",
+       " 824: 'Love Written in Vintage Chinese Character T-Shirt',\n",
+       " 825: \"INTO THE AM Tree of Life Men's Graphic Tee Short Sleeve Cool Novelty Design Crewneck Graphic T-Shirt for Men (Black, Large)\",\n",
+       " 826: \"I'm Not a Robot (K-Drama w. English Sub, All Region DVD)\",\n",
+       " 827: \"DON'T TEXT ME\",\n",
+       " 828: 'On the Other Side of Freedom: The Case for Hope',\n",
+       " 829: 'Riot Society Flamingo Blossom Mens Long Sleeve T-Shirt - Black, Small',\n",
+       " 830: 'Love Ramen Japanese Noodles Shirt Kawaii Anime Cat Gifts T-Shirt',\n",
+       " 831: 'Love Written in Traditional Chinese Kanji Character T-Shirt',\n",
+       " 832: \"INTO THE AM Men's Fitted Crew Neck Basic Tees - Premium Modern Fit Short Sleeve Plain Logo T-Shirts for Men (Indigo, Medium)\",\n",
+       " 833: \"COOFANDY Men's Cotton Linen Henley Shirt Long Sleeve Hippie Casual Beach T Shirts Gray\",\n",
+       " 834: 'Amusement; I Am Not A Wolf',\n",
+       " 835: \"INTO THE AM Extraterrestrial Men's Graphic Tee Short Sleeve Cool Novelty Design Crewneck Graphic T-Shirt for Men (Navy, Medium)\",\n",
+       " 836: 'Jointown Face Mask, Pack of 50 (5081)',\n",
+       " 837: 'Face Masks Reusable 20 Pack 5Ply Cup Dust Face Mask for Women Men with Nose Wire',\n",
+       " 838: \"Kindness is my Superpower: A children's Book About Empathy, Kindness and Compassion (My Superpower Books)\",\n",
+       " 839: \"INTO THE AM Men's V-Neck Fitted T-Shirts 3 Pack - Soft Casual Comfort Short Sleeve V Neck Tees Multipack (Black/Navy/White, X-Large)\",\n",
+       " 840: 'Riot Society Panda Rose Mens Graphic Pullover Hoodie Sweatshirt - Black, XX-Large',\n",
+       " 841: 'Star Wars Anime Porg T-Shirt',\n",
+       " 842: 'Team Electric Breathable Neck Gaiter Masks Half Face Cover Wrap Cool Mask Bandana Festival Rave Balaclava Scarf INTO THE AM',\n",
+       " 843: \"I'm Not Who You Think I Am: An Asian American Woman's Political Journey\",\n",
+       " 844: 'China Shrink Cream - 2 Pack 0.5 Ounces Each',\n",
+       " 845: 'I Am Malala: The Girl Who Stood Up for Education and Was Short by the Taliban',\n",
+       " 846: 'Avidlove Women Lingerie V Neck Nightwear Sexy Satin Sleepwear Lace Chemise Mini Teddy M, Purple',\n",
+       " 847: 'I Am Not Spock',\n",
+       " 848: \"I'm No Hero: A POW Story as Told to Glen DeWerff\",\n",
+       " 849: 'I am not a princess I am a complete fairytale',\n",
+       " 850: 'Elephant & Piggie: The Complete Collection (An Elephant & Piggie Book) (An Elephant and Piggie Book)',\n",
+       " 851: 'Dear Zoo: A Lift-the-Flap Book',\n",
+       " 852: 'The Bible in 52 Weeks: A Yearlong Bible Study for Women',\n",
+       " 853: \"I May Not Be Perfect But I Am Hungarian And That's Close Enough!: Funny Notebook 100 Pages 8.5x11 Notebook Hungarian Family Heritage Hungary Gifts\",\n",
+       " 854: 'I Am Spock',\n",
+       " 855: 'My Magical Words (The Magic of Me Series)',\n",
+       " 856: \"I Am Not Pan Jinlian (Collector's Edition)(Hardcover) (Chinese Edition)\",\n",
+       " 857: 'My First Library : Boxset of 10 Board Books for Kids',\n",
+       " 858: 'I Am Legend [Blu-ray]',\n",
+       " 859: 'The New Jim Crow: Mass Incarceration in the Age of Colorblindness, 10th Anniversary Edition',\n",
+       " 860: \"INTO THE AM AstroBlaster Men's Graphic Tee Short Sleeve Cool Novelty Design Crewneck Graphic T-Shirt for Men (Black, X-Large)\",\n",
+       " 861: 'SAMI THE MAGIC BEAR: No To Bullying!: (Full-Color Edition)',\n",
+       " 862: 'So I Am Not Handsome Aka Pretty Ugly - Yuan Lai Wo Bu Shuai - Chinese Subtitle',\n",
+       " 863: 'Wildflower Tea',\n",
+       " 864: '10 Things I Want In My Life Cars More Cars car t shirts T-Shirt',\n",
+       " 865: 'JR Studio 3x9 inch Black Think This is Slow. Wait Until Uphill Bumper Sticker - Funny car Vinyl Decal Sticker Car Waterproof Car Decal Bumper Sticker',\n",
+       " 866: 'People Who Tolerate Me On A Daily Basis T Shirt XL Black',\n",
+       " 867: 'Custom IG Name Vinyl Decal - Personalized Social Media Username Sticker',\n",
+       " 868: 'Louder Than Your Girlfriend Last Night Decal CAR Truck Window Bumper Sticker Funny Joke Trucks Diesel Lifted',\n",
+       " 869: 'Custom SC Name Vinyl Decal - Personalized SC Username Sticker - Vinyl Car Decal - Social Media Car Window Vinyl Decal Sticker',\n",
+       " 870: 'American Flag Vinyl Decal 5 X 5 inch Matte Black Compatible with Cummins Diesel Trucks 1500 2500 3500 Window Bumper Sticker Door Toolbox Hood',\n",
+       " 871: '2x Metal Duramax Diesel Emblem Badge Decal Sticker Replacement For Silverado 2500HD 3500HD (Black Red)',\n",
+       " 872: 'GAPPLEBEES Slap Sticker (2) CAR Truck Vinyl Sticker Decal Racing 7\"',\n",
+       " 873: '\"Diesel Only\",\"Mixed Fuel Only\", and\"Gas Only\" Stickers | 1 Pack of 3 Stickers Each - 9 Stickers Total | 6\"x2\" | Weather Resistant, Ultra Durable, Commercial Grade Decals',\n",
+       " 874: 'Pair Set F-350 International Diesel Power Emblem Side Fender Door Logo Tailgate Badge Nameplate Decal Stickers Compatible for 83-94 F350 (Chrome Black Red)',\n",
+       " 875: 'Back Off I Have A Crazy Wife She Loves Dogs More Than Humans Sticker Vinyl Bumper Sticker Decal Waterproof 5\"',\n",
+       " 876: 'Generic, Funny Fishing Sticker Decal Bumper Sticker 5 inch',\n",
+       " 877: 'Never Say Never Minivan Vinyl Decal Funny Bumper Sticker 3.5\"x5\"',\n",
+       " 878: 'Seek Racing My Couch PULLS Out I Dont Decal JDM Funny CAR Truck Window Sticker',\n",
+       " 879: 'Peterbilt Sticker Vinyl Waterproof Sticker Decal Car Laptop Wall Window Bumper Sticker 5\"',\n",
+       " 880: '\"Diesel Only\" Stickers | 6\"x2\" | 3-Pack | Weather Resistant, Ultra Durable, Commercial Grade Decals (Single - 3 Stickers)',\n",
+       " 881: 'GOOACC 166 Pcs Car Retainer Clips &Screw Grommets - 12 Most Popular Sizes & Applications for GM Toyota Honda Nissan Mazda - Bonus Fastener Remover',\n",
+       " 882: 'Southern Fried Decals 6\" X 3.5\" My Truck Identifies as a Prius Funny Vinyl DIE Cut Decal for Your car, Truck, Window, Laptop, MacBook, or Any Other Smooth Surface',\n",
+       " 883: 'BERRYZILLA (Pair) Objects in Mirror are Losing Decal Black Etched Glass Funny Sticker',\n",
+       " 884: 'Diamond Graphics My Brakes are Awesome Come Closer I Will Show You (6-1/2\" x 3\") Funny Die Cut Decal/Bumper Sticker for Windows, Cars, Trucks, Etc.',\n",
+       " 885: 'Nilight - 60001F-B Led Pods 2PCS 18W 1260LM Flood Led Off Road Lights Super Bright Driving Fog Light Boat Lights Driving Lights Led Work Light for Trucks, 2 Years Warranty',\n",
+       " 886: 'Attention Remove Bra Female Funny Caution Warning Decal Sticker',\n",
+       " 887: 'Make Fun of Them Together Graphic Novelty Sarcastic Funny T Shirt XL Black',\n",
+       " 888: 'JS Artworks Look Twice Save a Life Motorcycle Vinyl Decal Sticker',\n",
+       " 889: 'Sticker Connection | My Driving Scares Me Too | Bumper Sticker Decal for Car, Truck, Window, Laptop | 2\"x7\" (White)',\n",
+       " 890: 'People Who Think The Know Graphic Novelty Sarcastic Funny T Shirt XL Black',\n",
+       " 891: '40\" Custom Text Sticker Windshield Decal Window Rear Car Truck',\n",
+       " 892: 'UR Impressions Tattered American Flag - We The People Decal Vinyl Sticker Graphics for Car Truck SUV Van Wall Window Laptop|White|7.5 X 4.2 inch|URI608',\n",
+       " 893: 'Diesel Only Sticker Sign (Pack of 3) | Adhesive Fuel Decal for Trucks, Tractors, Machinery and Equipment',\n",
+       " 894: 'Diesel, Gasoline, Mixed Fuel Only, Gasoline Only, Diesel Fuel Only, Prime, Fast delivery, 6 Decals as Shown, Waterproof, Laminated, UV Fade Protected',\n",
+       " 895: 'Sinceroduct Animal Stickers, Stickers for Kids Assortment Set 1300 PCS, 8 Themes\\xa0Collection for Children, Teacher, Parent, Grandparent, Kids, Craft, School, Scrapbooking, Present Idea for Children, Chris',\n",
+       " 896: 'Elevated Auto Styling - Rear Middle Window American Flag Fits Dodge RAM 2009-2018 (Black)',\n",
+       " 897: 'SixtyTwo24 Black Smoke Matters- 5\" Decal {Black} Repellent Sticker, Rollin Coal Sticker, Rolling Coal, Black Smoke Matters Sticker, Decal, Power Stroke, Diesel, Stacks, Decal, Vinyl Pipes',\n",
+       " 898: 'Funcle Gift for Uncle Graphic Novelty Sarcastic Funny T Shirt XL Black',\n",
+       " 899: 'Seek Racing I Identify AS A Prius Decal - CAR Truck Window Laptop Sticker',\n",
+       " 900: 'Maybelline SuperStay Ink Crayon Lipstick, Matte Longwear Lipstick Makeup, Settle For More, 0.04 Ounce',\n",
+       " 901: 'Too Faced Throwback Metallic Lipstick - Too Too Hot',\n",
+       " 902: 'Glitter Shimmer Liquid Lipstick Set 12 Colors Shinning and Long Lasting Waterproof Colourful Lip Gloss Set (12 PCS )',\n",
+       " 903: 'Coosa Glitter Liquid Lipsticks Set 6 color Diamond Shimmer Metallic Lipstick Waterproof Long Lasting Makeup Kit Face Eye Glow Shimmer Shinning Lip Gloss Set',\n",
+       " 904: '10pcs/Set Makeup Matte Lipstick Lip Kit, Velvety Liquid Lipstick Waterproof Long Lasting Durable Nude Lip Gloss Beauty Cosmetics Gift Box Makeup Set Kit',\n",
+       " 905: 'REALHER Moisturizing Lipstick - Sorry Not Sorry - Coral Pink - All-Day Hydration - High Pigment, Creamy, Smooth Application',\n",
+       " 906: 'HAUS LABORATORIES By Lady Gaga: SPARKLE LIPSTICK | Red, Long Lasting Universal Lipstick, Full-Coverage Lip Color, Vegan & Cruelty-Free | 0.12 Oz',\n",
+       " 907: \"L'Oreal Paris Age Perfect Satin Lipstick with Precious Oils, 200 Pink Petal, 0.13 Ounce\",\n",
+       " 908: 'Beauty Concepts Ultimate Lipstick Collection, Gift Set with Five Different Shades of Lipsticks, Holiday Gift Set for Women and Girls, Shades of Pinks and Reds',\n",
+       " 909: '10pcs/Set Makeup Matte Lipstick Lip Kit, Velvety Liquid Lipstick Waterproof Long Lasting',\n",
+       " 910: 'Matte Lipstick Set 6 Colors Nude Moisturizer Smooth Lipstick Long Lasting Waterproof Lipstick Makeup Gift Set',\n",
+       " 911: '8 Colors set Lip Gloss Matte Metallic Glitter Liquid Lipstick Diamond Shining Lipgloss Long Lasting Waterproof Unique Charming Attractive Cosmetics Makeup',\n",
+       " 912: 'Matte Liquid Lipstick Set, Durable Nude Lip Gloss Long-Lasting Non-Stick Cup Not Fade Waterproof High Pigmented Velvet Lipgloss Kit Beauty Cosmetics Makeup Gift Set for Girls\\xa0(24PCS)',\n",
+       " 913: 'evpct 6Pcs Matte to Glitter Liquid Lipstick Long Lasting Lips Set Kit,6 Colors Diamond Red Glitter Sparkly Glossy Waterproof Lipstick Metallic Shimmer Brown Pink Lipgloss Lip Gloss Sets for Women',\n",
+       " 914: 'Matte Liquid Lipstick Set, Durable Nude Lip Gloss Long-Lasting Non-Stick Cup Not Fade Waterproof High Pigmented Velvet Lipgloss Kit Beauty Cosmetics Makeup Gift Set for Girls\\xa0 (18pcs lipstick)',\n",
+       " 915: 'evpct 4Pack Mini Glitter Cigarette Lipstick Sets Lip Kit,Litte Smoke Tube Diamond Glitter Shimmer Sparkly Glossy Metallic Lipstick Lip Stain Long Lasting Waterproof for Women Lip Gloss (A-Set04)',\n",
+       " 916: '7 Colors Glitter Flip Lip Gloss Set of 7 Glitter Liquid Lipsticks Set Diamond Shimmer Metallic Lip Stick Waterproof Long Lasting Non-stick Cup Shinning Mermaid Shimmer Lip Gloss Glow Cosmetic Kit',\n",
+       " 917: 'Bellesky Matte Liquid Lipstick Set Berry Red Series 3Pcs Velvety Lip Gloss Kit Long-Lasting Wear Non-Stick Cup and Not Fade Lipstick Makeup Set for All Skin Undertone ((3Colors Set 12))',\n",
+       " 918: 'Beauty Glazed Matte Liquid Lipstick Makeup Set Long Lasting Matte Finish Waterproof Lightweight Easy to Remove',\n",
+       " 919: '6 PCS Matte Liquid Lipstick Set Non-Stick Cup Waterproof Long Lasting Birthday Edition Durable Liquid Lipgloss Beauty Cosmetics Makeup Set Gifts for Women',\n",
+       " 920: 'Coosa 7 Colors Glitter Shimmer Flip Lip Gloss Set Non-stick Cup Waterproof pigment Nude Glitter Shimmer Diamonds Pearl Liquid Lipstick kit (7 PCS)',\n",
+       " 921: 'Revlon Super Lustrous Lipstick, with Vitamin E and Avocado Oil, in Pink, Cream Lipstick, 616 Wink for Pink, 0.15 oz',\n",
+       " 922: 'Glitter Lipstick - Pink Glitter Adult',\n",
+       " 923: 'Maybelline SuperStay 24, 2-Step Liquid Lipstick, Forever Chestnut',\n",
+       " 924: 'COVERGIRL Outlast All Day Top Coat, Clear, Pack of 1',\n",
+       " 925: 'Lip Gloss Perfection Set 9 Dual Side tube 18 Colors (Matte, Shimmer, Glitter) Lip Gloss Makeup Set',\n",
+       " 926: 'BeautyBlvd Glitter Lips | Glitter Lip Kit | Waterproof & Smudge Proof | Long Lasting | Cruelty Free (Guilty Rose)',\n",
+       " 927: \"Julep It's Whipped Matte Lip Mousse Long Lasting Liquid Lipstick, Ooh La La\",\n",
+       " 928: 'Moon Glow - Blacklight\\xa0Neon UV Lipstick\\xa00.16oz\\xa0- Intense Pink – Glows Brightly Under Blacklights/UV Lighting!',\n",
+       " 929: 'Maybelline New York SuperStay Matte Ink Liquid Lipstick, Lover, 0.17 Ounce',\n",
+       " 930: 'Maybelline Color Sensational Lipstick, Lip Makeup, Matte Finish, Hydrating Lipstick, Nude, Pink, Red, Plum Lip Color, Pitch Black, 0.15 oz; (Packaging May Vary)',\n",
+       " 931: 'Sky Lipsticks MEIQING Women Glitter Waterproof Long Lasting Lip Gloss Bold Vivid Colorful Lipgloss Glitter Shimmer Lipstick Lip Kit',\n",
+       " 932: 'Burts Bees 100% Natural Glossy Lipstick, Pink Pool - 1 Tube',\n",
+       " 933: 'DONGXIUB Metallic Diamond Liquid Glitter Shimmer Lipstick Nonstick Cup Makeup Lip Gloss (D)',\n",
+       " 934: 'NYX PROFESSIONAL MAKEUP Duo Chromatic Lip Gloss - Cocktail Party, Nude Base With Gold/Pink/Green Duo Chromatic Pearls',\n",
+       " 935: 'Gerard Cosmetics Glitter Lipstick HOLLYWOOD BLVD Sparkling glitter, fully opaque lip color with sparkling metallic finish CRUELTY FREE & USA MADE',\n",
+       " 936: 'Pack of 6 Crystal Flower Jelly Lipstick, FirstFly Long Lasting Nutritious Lip Balm Lips Moisturizer Magic Temperature Color Change Lip Gloss (Black)',\n",
+       " 937: 'Gold Body Glitter and Lipstick Set | Includes gold sparkle lipstick bundled with shimmering gold glitter roll on for lips, eyes and face | Perfect for parties, celebrations or gifting',\n",
+       " 938: '6pcs Matte Velvety Liquid Lipstick Matte Liquid Lipgloss Waterproof Lip Gloss',\n",
+       " 939: 'Miss Rose Long-lasting Matte Lipstick Set, 12 PCS Multi Colored featuring full-pigment lip color with a smooth, ultra-matte finish in 12 shades',\n",
+       " 940: \"JR Studio 3x9 inch If You Can Read This I'm About HIT The Brakes Bumper Sticker -Tailgater Vinyl Decal Sticker Car Waterproof Car Decal Bumper Sticker\",\n",
+       " 941: \"No This is not My Husband's Truck Vinyl Decal - Ladies Truck Decals - Ladies Bumper Sticker - Funny Car Decal - Not My Husband's Truck Sticker Made in USA\",\n",
+       " 942: 'Yes Boys. This is My Truck - Choose from 9 Styles - car Truck 4x4 Window Body Tailgate Decal Bumper Sticker (Yellow Script w/Rose)',\n",
+       " 943: 'Thou Shalt Not Try Me Mood 24:7 Vinyl Decal Sticker - Car Truck Van SUV Window Wall Cup Laptop - One 5.5 Inch Decal - MKS1393',\n",
+       " 944: 'High Viz Inc Hella Kids in This Bitch Honk if one Falls Out- 7\" x 3 1/4\" die Cut Vinyl Decal for Cars, Trucks, Windows, Boats, Tool Boxes, etc NOT Printed!',\n",
+       " 945: 'Sunset Graphics & Decals Just A Girl Who Loves Jesus Decal Vinyl Car Sticker | Cars Trucks Vans Walls Laptop | White | 5.5 inches | SGD000234',\n",
+       " 946: 'No This is Not My Husband\\'s Truck 7.5\" Vinyl car, Truck Decal for Yeti tumblers, Mugs, etc Car Sticker - Car Decal - Window Sticker for Tumbler, Cup, Wall, SUV, Computer, Laptop',\n",
+       " 947: \"I'm Not Gay But My Boyfriend is Funny Decal Vinyl Sticker|Cars Trucks Vans Walls Laptop| White|7.5 x 2.1 in|DUC562\",\n",
+       " 948: 'This is The Way Helmet Quote Decal Vinyl Sticker |Cars Trucks Vans Walls Laptop|White|5.5 x 4.0 in|MAZ-383',\n",
+       " 949: \"TAMZAM - I'm A Girl YES This is My Truck Decal Vinyl Sticker White Cars Trucks Vans SUV Laptops Walls Glass Metal - 6.5 inches\",\n",
+       " 950: \"TAMENGI No This is not My Husband's Truck Vinyl Decal, Ladies Truck Decals, Ladies Bumper Sticker, Funny Car Decal, Not My Husband's Truck Sticker - 7 inches\",\n",
+       " 951: \"This is Not My Boyfriend's Truck Decal Sticker Car Truck Motorcycle Window Ipad Laptop Wall Decor - Size (10 inch / 25 cm Wide) - Color (Matte White)\",\n",
+       " 952: 'JE Mom Life Decal Vinyl Decal/Sticker for Cars, Trucks, Vans, Walls, Laptop, White 5.6 x 4.7 in',\n",
+       " 953: 'YES BOYS This IS My Truck ! Decal Sticker Available in 4 Camo Colors',\n",
+       " 954: 'Sunset Graphics & Decals This is My Circus These are My Monkeys Decal Vinyl Car Sticker | Cars Trucks Vans Walls Laptop | White | 5.5 inch | SGD000233',\n",
+       " 955: 'MAF -Not of This World Inspired Decal Viny Decal Sticker, Christian Sticker, Religious Decal Car Truck Laptop Cup Wall Window Decor White 5.5\"',\n",
+       " 956: 'Sunset Graphics & Decals Thou Shall Not Try Me Decal Vinyl Car Sticker Funny | Cars Trucks Vans Walls Laptop | White | 5.5 inches | SGD000213',\n",
+       " 957: \"I'm Not Gay, But $20 is $20 Funny Decal Vinyl Sticker|Cars Trucks Vans Walls Laptop| White|7.5 x 2.3 in|DUC573\",\n",
+       " 958: 'Chase Grace Studio God is Greater That Highs and Lows Christian Mountains Vinyl Decal Sticker|White|Cars Trucks SUVs Vans Laptops Walls Glass Metal|6.5\" X 4.5\"|GS1102',\n",
+       " 959: 'Funny Hard Hat & Helmet Stickers: 10 Decal Value Pack Two American Flags. Great a Construction Toolbox, Hardhat, Mechanic’s Chest & More. USA Made Fun Gift Pro Union Working Men & Women',\n",
+       " 960: 'White Vinyl Decal - This is Not My Daddys Truck Country Wife Girl Fun dad Daddy, Die Cut Decal Bumper Sticker for Windows, Cars, Trucks, Laptops, Etc.',\n",
+       " 961: 'Thou Shall Not Try Me Mom 24:7 Vinyl Decal Sticker | Cars Trucks Vans SUVs Walls Cups Laptops | 5.5 Inch | Black | KCD2736',\n",
+       " 962: 'Nothing in Here is Worth Dying for - Die Cut Decal Bumper Sticker for Windows, Cars, Trucks, Laptops, Etc.',\n",
+       " 963: 'are You Following Jesus This Closely? (9\" x 3\") Funny Die Cut Decal Sticker for Windows, Cars, Trucks, Laptops, Etc',\n",
+       " 964: 'Barefoot Graphix GET Off My Ass Before I Inflate Your AIRBAGS - 8\" x 2 7/8\" die Cut Vinyl Decal for Window, car, Truck, Tool Box, virtually Any Hard, Smooth Surface',\n",
+       " 965: 'Custom Bumper Sticker Wyco Products Customizable Bumper Sticker (3\"x10\", Black)',\n",
+       " 966: \"Just For Fun White - 6.5 x 3.5 This is Not My Daddy's Truck Vinyl Die Cut Decal Bumper Sticker, Windows, Cars, Trucks, laptops, etc\",\n",
+       " 967: 'JS Artworks This is Not My Boyfriends Truck Vinyl Decal Sticker',\n",
+       " 968: 'Second 2nd Amendment Handgun Pistol Warning Decal Sticker Gun = by 215 Decals',\n",
+       " 969: 'East Coast Vinyl Werkz Yes Boys. This is My Truck - Pink Camo - w/hat - car Truck 4x4 Window Body Tailgate Decal Sticker',\n",
+       " 970: 'East Coast Vinyl Werkz Yes Boys. This is My Truck - Pink Camo - car Truck 4x4 Window Body Tailgate Decal Sticker',\n",
+       " 971: \"THIS IS NOT MY HUSBAND'S TRUCK VINYL STICKER\",\n",
+       " 972: 'This is Not Normal - 8-3/4\" x 3-1/4\" - Vinyl Die Cut Decal/Bumper Sticker for Windows, Cars, Trucks, Laptops, Etc.',\n",
+       " 973: \"VINYL GRAPHICS I'm A Girl YES This is My Truck Sticker\",\n",
+       " 974: 'Rogue River Tactical Funny Auto Decal Bumper Sticker for Women Girls Yes I Am A Bitch Just Not Yours for Car Truck RV Boat SUV',\n",
+       " 975: \"Rogue River Tactical Black & Red Large Funny Racing Auto Car Decal Bumper Sticker Truck RV Boat Window If You Ain't First Your Last\",\n",
+       " 976: 'JS Artworks This is Not My Husbands Truck Vinyl Decal Sticker',\n",
+       " 977: 'White Vinyl Decal - This is Not My Husband Truck Country Wife Girl Fun, Die Cut Decal Bumper Sticker for Windows, Cars, Trucks, Laptops, Etc.',\n",
+       " 978: 'Blood in the Bayou: A Bone-Chilling FBI Thriller (FBI Agent Jade Monroe Live or Die Series Book 1)',\n",
+       " 979: 'The School Mistress (Emerson Pass Historicals Book 1)',\n",
+       " 980: 'Wild Irish Rose (The Merriams Book 1)',\n",
+       " 981: 'Everything Is F*cked: A Book About Hope (The Subtle Art of Not Giving a F*ck (2 Book Series))',\n",
+       " 982: 'Epic Zero: Tales of a Not-So-Super 6th Grader Books 1-3 (Epic Zero Collection Book 1)',\n",
+       " 983: 'The Subtle Art of Not Giving a F*ck: A Counterintuitive Approach to Living a Good Life (Mark Manson Collection Book 1)',\n",
+       " 984: 'Never Binge Again(tm): How Thousands of People Have Stopped Overeating and Binge Eating - and Stuck to the Diet of Their Choice! (By Reprogramming Themselves to Think Differently About Food.)',\n",
+       " 985: 'Wiggly the Worm: Fun Short Stories for Kids (Early Bird Reader Book 1)',\n",
+       " 986: 'The Keys to my Diary: Fern -- A Florida Keys rom-com beach read romance novel',\n",
+       " 987: 'A Family Affair: A Small Town Family Saga (Truth In Lies Book 1)',\n",
+       " 988: 'Small Great Things: A Novel',\n",
+       " 989: 'Diapers Size 1 (8-14 lbs) Newborn, 198 Count - Pampers Swaddlers Disposable Baby Diapers, ONE MONTH SUPPLY (Packaging May Vary)',\n",
+       " 990: 'RAW Pre Rolled Cones Classic 1 1/4: 100 Pack - Classic Rolling Papers with Filter Tips | All Natural Slow Burning RAW Cone | Includes Green Blazer Tube',\n",
+       " 991: 'Graco Extend2Fit 3-in-1 Car Seat, Stocklyn , 20.75x19x24.5 Inch (Pack of 1)',\n",
+       " 992: 'SAMSUNG 970 EVO Plus SSD 1TB, M.2 NVMe Interface Internal Solid State Hard Drive with V-NAND Technology for Gaming, Graphic Design, MZ-V7S1T0B/AM',\n",
+       " 993: 'SAMSUNG 860 QVO 1TB Solid State Drive (MZ-76Q1T0B/AM) V-NAND, SATA 6Gb/s, Quality and Value Optimized SSD',\n",
+       " 994: 'Graco 4Ever DLX 4 in 1 Car Seat | Infant to Toddler Car Seat, with 10 Years of Use, Kendrick',\n",
+       " 995: 'Duracell - 2032 3V Lithium Coin Battery - with Bitter Coating - 1 Count',\n",
+       " 996: 'Seagate Portable 1TB External Hard Drive HDD – USB 3.0 for PC, Mac, PlayStation, & Xbox, 1-Year Rescue Service (STGX1000400) , Black',\n",
+       " 997: 'Twilight',\n",
+       " 998: 'Ziploc Food Storage Meal Prep Containers Reusable for Kitchen Organization, Smart Snap Technology, Dishwasher Safe, Divided Rectangle, 2 Count',\n",
+       " 999: 'everydrop by Whirlpool Ice and Water Refrigerator Filter 1, EDR1RXD1, Single-Pack , Purple',\n",
+       " ...}"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ids_to_products_dict = {i: p for i, p in zip(dataset[\"index\"], dataset[\"product_title\"])}\n",
+    "ids_to_products_dict"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "ba0de67d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "device = \"cuda\"\n",
+    "model.to(device)\n",
+    "model.eval()\n",
+    "model = model.merge_and_unload()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "65c4e36b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████████████████████████████████████████████████████████████████████████████████| 1861/1861 [04:43<00:00,  6.57it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "num_products = len(dataset)\n",
+    "d = 1024\n",
+    "\n",
+    "product_embeddings_array = np.zeros((num_products, d))\n",
+    "for step, batch in enumerate(tqdm(dataloader)):\n",
+    "    with torch.no_grad():\n",
+    "        with torch.amp.autocast(dtype=torch.bfloat16, device_type=\"cuda\"):\n",
+    "            product_embs = model(**{k: v.to(device) for k, v in batch.items()}).detach().float().cpu()\n",
+    "    start_index = step * batch_size\n",
+    "    end_index = start_index + batch_size if (start_index + batch_size) < num_products else num_products\n",
+    "    product_embeddings_array[start_index:end_index] = product_embs\n",
+    "    del product_embs, batch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "id": "4377406a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def construct_search_index(dim, num_elements, data):\n",
+    "    # Declaring index\n",
+    "    search_index = hnswlib.Index(space=\"ip\", dim=dim)  # possible options are l2, cosine or ip\n",
+    "\n",
+    "    # Initializing index - the maximum number of elements should be known beforehand\n",
+    "    search_index.init_index(max_elements=num_elements, ef_construction=200, M=100)\n",
+    "\n",
+    "    # Element insertion (can be called several times):\n",
+    "    ids = np.arange(num_elements)\n",
+    "    search_index.add_items(data, ids)\n",
+    "\n",
+    "    return search_index"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "id": "e53d2297",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "product_search_index = construct_search_index(d, num_products, product_embeddings_array)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "id": "6428b193",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_query_embeddings(query, model, tokenizer, device):\n",
+    "    inputs = tokenizer(query, padding=\"max_length\", max_length=70, truncation=True, return_tensors=\"pt\")\n",
+    "    model.eval()\n",
+    "    with torch.no_grad():\n",
+    "        query_embs = model(**{k: v.to(device) for k, v in inputs.items()}).detach().cpu()\n",
+    "    return query_embs[0]\n",
+    "\n",
+    "\n",
+    "def get_nearest_neighbours(k, search_index, query_embeddings, ids_to_products_dict, threshold=0.7):\n",
+    "    # Controlling the recall by setting ef:\n",
+    "    search_index.set_ef(100)  # ef should always be > k\n",
+    "\n",
+    "    # Query dataset, k - number of the closest elements (returns 2 numpy arrays)\n",
+    "    labels, distances = search_index.knn_query(query_embeddings, k=k)\n",
+    "\n",
+    "    return [\n",
+    "        (ids_to_products_dict[label], (1 - distance))\n",
+    "        for label, distance in zip(labels[0], distances[0])\n",
+    "        if (1 - distance) >= threshold\n",
+    "    ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 97,
+   "id": "1c47f12d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "query='NLP and ML books'\n",
+      "cosine_sim_score=0.92 product='Machine Learning: A Journey from Beginner to Advanced Including Deep Learning, Scikit-learn and Tensorflow'\n",
+      "cosine_sim_score=0.91 product='Mastering Machine Learning with scikit-learn'\n",
+      "cosine_sim_score=0.91 product='Hands-On Machine Learning with Scikit-Learn and TensorFlow: Concepts, Tools, and Techniques to Build Intelligent Systems'\n",
+      "cosine_sim_score=0.91 product='Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow: Concepts, Tools, and Techniques to Build Intelligent Systems'\n",
+      "cosine_sim_score=0.91 product='Practical Deep Learning: A Python-Based Introduction'\n",
+      "cosine_sim_score=0.9 product='Machine Learning: A Hands-On, Project-Based Introduction to Machine Learning for Absolute Beginners: Mastering Engineering ML Systems using Scikit-Learn and TensorFlow'\n",
+      "cosine_sim_score=0.9 product='Mastering Machine Learning with scikit-learn - Second Edition: Apply effective learning algorithms to real-world problems using scikit-learn'\n",
+      "cosine_sim_score=0.9 product='Mastering Machine Learning on AWS: Advanced machine learning in Python using SageMaker, Apache Spark, and TensorFlow'\n",
+      "cosine_sim_score=0.9 product='Machine Learning Algorithms: Naive Bayes'\n",
+      "cosine_sim_score=0.9 product='Fundamentals of Machine Learning for Predictive Data Anayltics: Algorithms, Worked Examples, and Case Studies'\n"
+     ]
+    }
+   ],
+   "source": [
+    "query = \"NLP and ML books\"\n",
+    "k = 10\n",
+    "query_embeddings = get_query_embeddings(query, model, tokenizer, device)\n",
+    "search_results = get_nearest_neighbours(k, product_search_index, query_embeddings, ids_to_products_dict, threshold=0.7)\n",
+    "\n",
+    "print(f\"{query=}\")\n",
+    "for product, cosine_sim_score in search_results:\n",
+    "    print(f\"cosine_sim_score={round(cosine_sim_score,2)} {product=}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e9e2dd2c",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/feature_extraction/requirements.txt b/examples/feature_extraction/requirements.txt
new file mode 100644
index 0000000..2bb3bc0
--- /dev/null
+++ b/examples/feature_extraction/requirements.txt
@@ -0,0 +1,10 @@
+peft
+accelerate
+transformers
+datasets==2.18.0
+evaluate
+hnswlib
+pandas
+tqdm
+huggingface_hub
+wandb
\ No newline at end of file
diff --git a/examples/fp4_finetuning/finetune_fp4_opt_bnb_peft.py b/examples/fp4_finetuning/finetune_fp4_opt_bnb_peft.py
new file mode 100644
index 0000000..8f5eee0
--- /dev/null
+++ b/examples/fp4_finetuning/finetune_fp4_opt_bnb_peft.py
@@ -0,0 +1,195 @@
+import os
+
+import torch
+import transformers
+from datasets import load_dataset
+from torch import nn
+from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
+
+from peft import LoraConfig, get_peft_model
+
+
+os.environ["CUDA_VISIBLE_DEVICES"] = "0"  # force to use CUDA GPU device 0
+os.environ["ZE_AFFINITY_MASK"] = "0"  # force to use Intel XPU device 0
+# -*- coding: utf-8 -*-
+"""Finetune-opt-bnb-peft.ipynb
+
+Automatically generated by Colaboratory.
+
+Original file is located at
+    https://colab.research.google.com/drive/1jCkpikz0J2o20FBQmYmAGdiKmJGOMo-o
+
+## Fine-tune large models using 🤗 `peft` adapters, `transformers` & `bitsandbytes`
+
+In this tutorial we will cover how we can fine-tune large language models using the very recent `peft` library and `bitsandbytes` for loading large models in 8-bit.
+The fine-tuning method will rely on a recent method called "Low Rank Adapters" (LoRA), instead of fine-tuning the entire model you just have to fine-tune these adapters and load them properly inside the model.
+After fine-tuning the model you can also share your adapters on the 🤗 Hub and load them very easily. Let's get started!
+
+### Install requirements
+
+First, run the cells below to install the requirements:
+"""
+
+
+"""### Model loading
+
+Here let's load the `opt-6.7b` model, its weights in half-precision (float16) are about 13GB on the Hub! If we load them in 8-bit we would require around 7GB of memory instead.
+"""
+
+device_type = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+device_module = getattr(torch, device_type, torch.cuda)
+free_in_GB = int(device_module.mem_get_info()[0] / 1024**3)
+max_memory = f"{free_in_GB - 2}GB"
+
+n_gpus = device_module.device_count()
+max_memory = {i: max_memory for i in range(n_gpus)}
+
+model = AutoModelForCausalLM.from_pretrained(
+    "facebook/opt-350m",
+    max_memory=max_memory,
+    quantization_config=BitsAndBytesConfig(
+        load_in_4bit=True,
+        llm_int8_threshold=6.0,
+        llm_int8_has_fp16_weight=False,
+        bnb_4bit_compute_dtype=torch.float16,
+        bnb_4bit_use_double_quant=True,
+        bnb_4bit_quant_type="nf4",
+    ),
+    dtype=torch.float16,
+)
+
+tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m")
+
+"""### Post-processing on the model
+
+Finally, we need to apply some post-processing on the 8-bit model to enable training, let's freeze all our layers, and cast the layer-norm in `float32` for stability. We also cast the output of the last layer in `float32` for the same reasons.
+"""
+
+print(model)
+
+for param in model.parameters():
+    param.requires_grad = False  # freeze the model - train adapters later
+    if param.ndim == 1:
+        # cast the small parameters (e.g. layernorm) to fp32 for stability
+        param.data = param.data.to(torch.float32)
+
+# model.gradient_checkpointing_enable()  # reduce number of stored activations
+# model.model.decoder.project_in = lambda x: x.requires_grad_(True)
+
+
+class CastOutputToFloat(nn.Sequential):
+    def forward(self, x):
+        return super().forward(x).to(torch.float32)
+
+
+model.lm_head = CastOutputToFloat(model.lm_head)
+
+"""### Apply LoRA
+
+Here comes the magic with `peft`! Let's load a `PeftModel` and specify that we are going to use low-rank adapters (LoRA) using `get_peft_model` utility function from `peft`.
+"""
+
+
+def print_trainable_parameters(model):
+    """
+    Prints the number of trainable parameters in the model.
+    """
+    trainable_params = 0
+    all_param = 0
+    for _, param in model.named_parameters():
+        all_param += param.numel()
+        if param.requires_grad:
+            trainable_params += param.numel()
+    print(
+        f"trainable params: {trainable_params} || all params: {all_param} || trainable%: {100 * trainable_params / all_param}"
+    )
+
+
+config = LoraConfig(
+    r=64,
+    lora_alpha=32,
+    target_modules=["q_proj", "v_proj", "out_proj", "fc1", "fc2"],
+    lora_dropout=0.01,
+    bias="none",
+    task_type="CAUSAL_LM",
+)
+
+model = get_peft_model(model, config)
+print_trainable_parameters(model)
+
+# Verifying the datatypes.
+dtypes = {}
+for _, p in model.named_parameters():
+    dtype = p.dtype
+    if dtype not in dtypes:
+        dtypes[dtype] = 0
+    dtypes[dtype] += p.numel()
+total = 0
+for k, v in dtypes.items():
+    total += v
+for k, v in dtypes.items():
+    print(k, v, v / total)
+
+"""### Training"""
+
+data = load_dataset("Abirate/english_quotes")
+data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+
+trainer = transformers.Trainer(
+    model=model,
+    train_dataset=data["train"],
+    args=transformers.TrainingArguments(
+        per_device_train_batch_size=4,
+        gradient_accumulation_steps=4,
+        warmup_steps=10,
+        max_steps=20,
+        learning_rate=3e-4,
+        fp16=True,
+        logging_steps=1,
+        output_dir="outputs",
+    ),
+    data_collator=transformers.DataCollatorForLanguageModeling(tokenizer, mlm=False),
+)
+model.config.use_cache = False  # silence the warnings. Please re-enable for inference!
+trainer.train()
+
+# from huggingface_hub import notebook_login
+
+# notebook_login()
+
+# model.push_to_hub("ybelkada/opt-6.7b-lora", use_auth_token=True)
+
+"""## Load adapters from the Hub
+
+You can also directly load adapters from the Hub using the commands below:
+"""
+
+# import torch
+# from peft import PeftModel, PeftConfig
+# from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
+#
+# peft_model_id = "ybelkada/opt-6.7b-lora"
+# config = PeftConfig.from_pretrained(peft_model_id)
+# model = AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path, return_dict=True, quantization_config=BitsAndBytesConfig(load_in_8bit=True), device_map='auto')
+# tokenizer = AutoTokenizer.from_pretrained(config.base_model_name_or_path)
+#
+## Load the Lora model
+# model = PeftModel.from_pretrained(model, peft_model_id)
+#
+# """## Inference
+#
+# You can then directly use the trained model or the model that you have loaded from the 🤗 Hub for inference as you would do it usually in `transformers`.
+# """
+#
+batch = tokenizer("Two things are infinite: ", return_tensors="pt").to(model.device)
+
+model.config.use_cache = False  # silence the warnings. Please re-enable for inference!
+model.eval()
+
+with torch.amp.autocast(device_type=device_type):
+    output_tokens = model.generate(**batch, max_new_tokens=50)
+
+print("\n\n", tokenizer.decode(output_tokens[0], skip_special_tokens=True))
+# model.save('./test.pt')
+
+# """As you can see by fine-tuning for few steps we have almost recovered the quote from Albert Einstein that is present in the [training data](https://huggingface.co/datasets/Abirate/english_quotes)."""
diff --git a/examples/frod_finetuning/README.md b/examples/frod_finetuning/README.md
new file mode 100644
index 0000000..57ed965
--- /dev/null
+++ b/examples/frod_finetuning/README.md
@@ -0,0 +1,27 @@
+# FRoD fine-tuning examples
+
+These examples show minimal FRoD fine-tuning with the Transformers `Trainer`.
+
+Install the example dependencies and run either script directly:
+
+```bash
+pip install -r examples/frod_finetuning/requirements.txt
+python examples/frod_finetuning/frod_text_classification.py
+python examples/frod_finetuning/frod_image_classification.py
+```
+
+The text example fine-tunes `google-bert/bert-base-uncased` on `nyu-mll/glue` with the `sst2` configuration. The image
+example fine-tunes `openai/clip-vit-base-patch32` on the train and test parquet splits from `tanganke/stanford_cars`.
+
+Both scripts use separate optimizer learning rates for FRoD diagonal coefficients, FRoD sparse coefficients, and the
+classification head. FRoD dropout is set to `0.0` because the sparse rotational parameterization is the main
+regularizer in these examples.
+
+To use local mirrors of the image model or dataset, pass the paths as CLI arguments:
+
+```bash
+python examples/frod_finetuning/frod_image_classification.py \
+  --model_name_or_path /path/to/local/clip-vit-model \
+  --data_dir /path/to/local/stanford_cars \
+  --output_dir clip-vit-local-frod-stanford-cars
+```
diff --git a/examples/frod_finetuning/frod_image_classification.py b/examples/frod_finetuning/frod_image_classification.py
new file mode 100644
index 0000000..a378f21
--- /dev/null
+++ b/examples/frod_finetuning/frod_image_classification.py
@@ -0,0 +1,180 @@
+# Copyright 2026-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+
+import os
+from dataclasses import dataclass, field
+from typing import Optional
+
+import numpy as np
+import torch
+from datasets import load_dataset
+from transformers import (
+    AutoImageProcessor,
+    AutoModelForImageClassification,
+    HfArgumentParser,
+    Trainer,
+    TrainingArguments,
+)
+
+from peft import FrodConfig, get_peft_model
+
+
+@dataclass
+class FrodImageArguments:
+    model_name_or_path: str = field(
+        default="openai/clip-vit-base-patch32",
+        metadata={"help": "Model checkpoint used for image classification."},
+    )
+    data_dir: Optional[str] = field(
+        default=None,
+        metadata={"help": "Optional local Stanford Cars dataset directory containing the parquet data files."},
+    )
+    target_modules: list[str] = field(
+        default_factory=lambda: ["q_proj", "k_proj", "v_proj", "out_proj", "fc1", "fc2"],
+        metadata={"help": "Module names to replace with FRoD adapters."},
+    )
+    sparse_rate: float = field(
+        default=0.01,
+        metadata={"help": "Fraction of off-diagonal entries trained in the sparse FRoD matrix."},
+    )
+    frod_dropout: float = field(
+        default=0.0,
+        metadata={"help": "Dropout probability applied before the FRoD adapter branch."},
+    )
+    frod_lambda_l_lr: float = field(
+        default=5e-4,
+        metadata={"help": "Learning rate for the trainable diagonal FRoD coefficients."},
+    )
+    frod_lambda_s_lr: float = field(
+        default=5e-5,
+        metadata={"help": "Learning rate for the trainable sparse FRoD coefficients."},
+    )
+    classifier_lr: float = field(default=1e-4, metadata={"help": "Learning rate for the classification head."})
+    projection_prng_key: int = field(default=3, metadata={"help": "Random seed used for FRoD projection masks."})
+    runtime_offload_base_weight: bool = field(
+        default=False,
+        metadata={"help": "Keep target base weights on CPU when active FRoD training does not need them."},
+    )
+
+
+@dataclass
+class FrodImageTrainingArguments(TrainingArguments):
+    output_dir: str = "clip-vit-base-patch32-frod-stanford-cars"
+    learning_rate: float = 5e-4
+    per_device_train_batch_size: int = 64
+    per_device_eval_batch_size: int = 64
+    num_train_epochs: float = 3
+    eval_strategy: str = "epoch"
+    save_strategy: str = "epoch"
+    load_best_model_at_end: bool = True
+    metric_for_best_model: str = "accuracy"
+    lr_scheduler_type: str = "constant"
+    remove_unused_columns: bool = False
+    report_to: str = "none"
+
+
+def main():
+    parser = HfArgumentParser((FrodImageArguments, FrodImageTrainingArguments))
+    frod_args, training_args = parser.parse_args_into_dataclasses()
+
+    if frod_args.data_dir:
+        data_files = {
+            "train": [
+                os.path.join(frod_args.data_dir, "data", "train-00000-of-00002.parquet"),
+                os.path.join(frod_args.data_dir, "data", "train-00001-of-00002.parquet"),
+            ],
+            "test": [
+                os.path.join(frod_args.data_dir, "data", "test-00000-of-00002.parquet"),
+                os.path.join(frod_args.data_dir, "data", "test-00001-of-00002.parquet"),
+            ],
+        }
+    else:
+        data_files = {
+            "train": [
+                "hf://datasets/tanganke/stanford_cars/data/train-00000-of-00002.parquet",
+                "hf://datasets/tanganke/stanford_cars/data/train-00001-of-00002.parquet",
+            ],
+            "test": [
+                "hf://datasets/tanganke/stanford_cars/data/test-00000-of-00002.parquet",
+                "hf://datasets/tanganke/stanford_cars/data/test-00001-of-00002.parquet",
+            ],
+        }
+
+    dataset = load_dataset("parquet", data_files=data_files)
+    train_split = dataset["train"]
+    eval_split = dataset["test"]
+    image_processor = AutoImageProcessor.from_pretrained(frod_args.model_name_or_path)
+    label_feature = train_split.features["label"]
+    label_names = (
+        label_feature.names if hasattr(label_feature, "names") else [str(i) for i in sorted(set(train_split["label"]))]
+    )
+    id2label = dict(enumerate(label_names))
+    label2id = {name: idx for idx, name in id2label.items()}
+
+    model = AutoModelForImageClassification.from_pretrained(
+        frod_args.model_name_or_path,
+        num_labels=len(label_names),
+        id2label=id2label,
+        label2id=label2id,
+        ignore_mismatched_sizes=True,
+    )
+    peft_config = FrodConfig(
+        target_modules=frod_args.target_modules,
+        modules_to_save=["classifier"],
+        frod_dropout=frod_args.frod_dropout,
+        sparse_rate=frod_args.sparse_rate,
+        projection_prng_key=frod_args.projection_prng_key,
+        runtime_offload_base_weight=frod_args.runtime_offload_base_weight,
+    )
+    model = get_peft_model(model, peft_config)
+    model.print_trainable_parameters()
+
+    def transform(batch):
+        images = [image.convert("RGB") for image in batch["image"]]
+        inputs = image_processor(images, return_tensors="pt")
+        inputs["labels"] = batch["label"]
+        return inputs
+
+    train_dataset = train_split.with_transform(transform)
+    eval_dataset = eval_split.with_transform(transform)
+
+    def collate_fn(examples):
+        pixel_values = torch.stack([example["pixel_values"] for example in examples])
+        labels = torch.tensor([example["labels"] for example in examples])
+        return {"pixel_values": pixel_values, "labels": labels}
+
+    def compute_metrics(eval_pred):
+        predictions = np.argmax(eval_pred.predictions, axis=-1)
+        return {"accuracy": (predictions == eval_pred.label_ids).mean().item()}
+
+    optimizer = torch.optim.AdamW(
+        [
+            {
+                "params": [p for n, p in model.named_parameters() if "frod_lambda_l" in n],
+                "lr": frod_args.frod_lambda_l_lr,
+            },
+            {
+                "params": [p for n, p in model.named_parameters() if "frod_lambda_s_values" in n],
+                "lr": frod_args.frod_lambda_s_lr,
+            },
+            {"params": [p for n, p in model.named_parameters() if "classifier" in n], "lr": frod_args.classifier_lr},
+        ]
+    )
+
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_dataset,
+        eval_dataset=eval_dataset,
+        data_collator=collate_fn,
+        compute_metrics=compute_metrics,
+        optimizers=(optimizer, None),
+    )
+    trainer.train()
+    trainer.evaluate()
+    model.save_pretrained(training_args.output_dir)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/frod_finetuning/frod_text_classification.py b/examples/frod_finetuning/frod_text_classification.py
new file mode 100644
index 0000000..55d50ec
--- /dev/null
+++ b/examples/frod_finetuning/frod_text_classification.py
@@ -0,0 +1,130 @@
+# Copyright 2026-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+
+from dataclasses import dataclass, field
+
+import numpy as np
+import torch
+from datasets import load_dataset
+from transformers import (
+    AutoModelForSequenceClassification,
+    AutoTokenizer,
+    DataCollatorWithPadding,
+    HfArgumentParser,
+    Trainer,
+    TrainingArguments,
+)
+
+from peft import FrodConfig, TaskType, get_peft_model
+
+
+@dataclass
+class FrodTextArguments:
+    model_name_or_path: str = field(
+        default="google-bert/bert-base-uncased",
+        metadata={"help": "Model checkpoint used for sequence classification."},
+    )
+    dataset_name: str = field(default="nyu-mll/glue", metadata={"help": "Dataset name or local dataset path."})
+    task_name: str = field(default="sst2", metadata={"help": "Dataset configuration name."})
+    target_modules: list[str] = field(
+        default_factory=lambda: ["query", "value"],
+        metadata={"help": "Module names to replace with FRoD adapters."},
+    )
+    sparse_rate: float = field(
+        default=0.02,
+        metadata={"help": "Fraction of off-diagonal entries trained in the sparse FRoD matrix."},
+    )
+    frod_dropout: float = field(
+        default=0.0,
+        metadata={"help": "Dropout probability applied before the FRoD adapter branch."},
+    )
+    frod_lambda_l_lr: float = field(
+        default=2e-2,
+        metadata={"help": "Learning rate for the trainable diagonal FRoD coefficients."},
+    )
+    frod_lambda_s_lr: float = field(
+        default=2e-3,
+        metadata={"help": "Learning rate for the trainable sparse FRoD coefficients."},
+    )
+    classifier_lr: float = field(default=1e-2, metadata={"help": "Learning rate for the classification head."})
+    runtime_offload_base_weight: bool = field(
+        default=False,
+        metadata={"help": "Keep target base weights on CPU when active FRoD training does not need them."},
+    )
+
+
+@dataclass
+class FrodTextTrainingArguments(TrainingArguments):
+    output_dir: str = "bert-base-uncased-frod-sst2"
+    learning_rate: float = 2e-2
+    per_device_train_batch_size: int = 32
+    per_device_eval_batch_size: int = 64
+    num_train_epochs: float = 1
+    eval_strategy: str = "epoch"
+    save_strategy: str = "epoch"
+    load_best_model_at_end: bool = True
+    metric_for_best_model: str = "accuracy"
+    report_to: str = "none"
+
+
+def main():
+    parser = HfArgumentParser((FrodTextArguments, FrodTextTrainingArguments))
+    frod_args, training_args = parser.parse_args_into_dataclasses()
+
+    dataset = load_dataset(frod_args.dataset_name, frod_args.task_name)
+    tokenizer = AutoTokenizer.from_pretrained(frod_args.model_name_or_path)
+
+    def preprocess(batch):
+        return tokenizer(batch["sentence"], truncation=True)
+
+    tokenized = dataset.map(preprocess, batched=True)
+    tokenized = tokenized.rename_column("label", "labels")
+
+    model = AutoModelForSequenceClassification.from_pretrained(frod_args.model_name_or_path, num_labels=2)
+    peft_config = FrodConfig(
+        task_type=TaskType.SEQ_CLS,
+        target_modules=frod_args.target_modules,
+        modules_to_save=["classifier"],
+        frod_dropout=frod_args.frod_dropout,
+        sparse_rate=frod_args.sparse_rate,
+        runtime_offload_base_weight=frod_args.runtime_offload_base_weight,
+    )
+    model = get_peft_model(model, peft_config)
+    model.print_trainable_parameters()
+
+    def compute_metrics(eval_pred):
+        predictions = np.argmax(eval_pred.predictions, axis=-1)
+        return {"accuracy": (predictions == eval_pred.label_ids).mean().item()}
+
+    optimizer = torch.optim.AdamW(
+        [
+            {
+                "params": [p for n, p in model.named_parameters() if "frod_lambda_l" in n],
+                "lr": frod_args.frod_lambda_l_lr,
+            },
+            {
+                "params": [p for n, p in model.named_parameters() if "frod_lambda_s_values" in n],
+                "lr": frod_args.frod_lambda_s_lr,
+            },
+            {"params": [p for n, p in model.named_parameters() if "classifier" in n], "lr": frod_args.classifier_lr},
+        ]
+    )
+
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=tokenized["train"],
+        eval_dataset=tokenized["validation"],
+        processing_class=tokenizer,
+        data_collator=DataCollatorWithPadding(tokenizer=tokenizer),
+        compute_metrics=compute_metrics,
+        optimizers=(optimizer, None),
+    )
+    trainer.train()
+    trainer.evaluate()
+    model.save_pretrained(training_args.output_dir)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/frod_finetuning/requirements.txt b/examples/frod_finetuning/requirements.txt
new file mode 100644
index 0000000..8bcaa74
--- /dev/null
+++ b/examples/frod_finetuning/requirements.txt
@@ -0,0 +1,6 @@
+peft
+transformers
+accelerate>=1.0.0
+datasets
+numpy
+Pillow
diff --git a/examples/glora_finetuning/README.md b/examples/glora_finetuning/README.md
new file mode 100644
index 0000000..5049bc2
--- /dev/null
+++ b/examples/glora_finetuning/README.md
@@ -0,0 +1,20 @@
+# GLoRA causal language modeling fine-tuning
+
+This example demonstrates how to fine-tune a causal language model with [GLoRA](https://arxiv.org/abs/2306.07967) adapters using the Alpaca-style instruction data from `yahma/alpaca-cleaned`. GLoRA generalizes LoRA by introducing configurable paths for weight and bias corrections: `W_eff = W0 + W0 * A + B` and `b_eff = b0 + b0 * D + E + W0 @ C`.
+
+## Running the script
+
+```bash
+python examples/glora_finetuning/glora_finetuning.py \
+  --base_model meta-llama/Meta-Llama-3-8B-Instruct \
+  --data_path yahma/alpaca-cleaned \
+  --output_dir glora-alpaca \
+  --glora_r 8 \
+  --config_A_B lora \
+  --config_C lora \
+  --config_D_E constant \
+  --learning_rate 3e-4 \
+  --num_epochs 3
+```
+
+Each path (`config_A_B`, `config_C`, `config_D_E`) can be set to different parameterization modes (`lora`, `vector`, `constant`, `none`) to trade off expressiveness against parameter count. The default configuration uses `lora` for A/B and C, and `constant` for D/E.
diff --git a/examples/glora_finetuning/glora_finetuning.py b/examples/glora_finetuning/glora_finetuning.py
new file mode 100644
index 0000000..0fb404f
--- /dev/null
+++ b/examples/glora_finetuning/glora_finetuning.py
@@ -0,0 +1,225 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+import os
+from typing import Optional
+
+import torch
+import transformers
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoTokenizer, set_seed
+
+from peft import GloraConfig, PeftModel, get_peft_model
+
+
+def train(
+    base_model: str = "path/to/model",
+    data_path: str = "yahma/alpaca-cleaned",
+    output_dir: str = "glora",
+    batch_size: int = 16,
+    num_epochs: int = 1,
+    learning_rate: float = 3e-4,
+    cutoff_len: int = 256,
+    val_set_size: int = 16,
+    eval_step: int = 100,
+    save_step: int = 100,
+    device_map: str = "auto",
+    glora_r: int = 8,
+    config_A_B: str = "lora",
+    config_C: str = "lora",
+    config_D_E: str = "constant",
+    glora_target_modules: Optional[list[str]] = None,
+    dtype: str = "float16",
+    seed: Optional[int] = None,
+    init_weights: bool = True,
+):
+    """
+    Fine-tunes a causal language model with GLoRA adapters on Alpaca-style instruction data.
+    """
+
+    world_size = int(os.environ.get("WORLD_SIZE", "0")) or int(os.environ.get("PMI_SIZE", "0"))
+    if world_size > 1 and device_map != "cpu":
+        from accelerate import Accelerator
+
+        device_map = {"": Accelerator().process_index}
+
+    if seed is not None:
+        set_seed(seed)
+
+    model_kwargs = {"dtype": getattr(torch, dtype), "device_map": device_map}
+    model = AutoModelForCausalLM.from_pretrained(base_model, **model_kwargs)
+
+    tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    def tokenize(prompt, add_eos_token: bool = True):
+        result = tokenizer(
+            prompt,
+            truncation=True,
+            max_length=cutoff_len,
+            padding=False,
+            return_tensors=None,
+        )
+        if (
+            result["input_ids"][-1] != tokenizer.eos_token_id
+            and len(result["input_ids"]) < cutoff_len
+            and add_eos_token
+        ):
+            result["input_ids"].append(tokenizer.eos_token_id)
+            result["attention_mask"].append(1)
+
+        result["labels"] = result["input_ids"].copy()
+
+        return result
+
+    def generate_and_tokenize_prompt(example):
+        full_prompt = generate_prompt(example)
+        tokenized_full_prompt = tokenize(full_prompt)
+        return tokenized_full_prompt
+
+    default_target_modules = [
+        "q_proj",
+        "k_proj",
+        "v_proj",
+        "o_proj",
+        "gate_proj",
+        "down_proj",
+        "up_proj",
+    ]
+    config = GloraConfig(
+        r=glora_r,
+        target_modules=glora_target_modules or default_target_modules,
+        config_A_B=config_A_B,
+        config_C=config_C,
+        config_D_E=config_D_E,
+        init_weights=init_weights,
+        task_type="CAUSAL_LM",
+    )
+    model = get_peft_model(model, config)
+
+    data = load_dataset(data_path)
+
+    train_val = data["train"].train_test_split(test_size=val_set_size, shuffle=True, seed=42)
+    train_data = train_val["train"].shuffle().map(generate_and_tokenize_prompt)
+    val_data = train_val["test"].shuffle().map(generate_and_tokenize_prompt)
+
+    trainer = transformers.Trainer(
+        model=model,
+        train_dataset=train_data,
+        eval_dataset=val_data,
+        args=transformers.TrainingArguments(
+            per_device_train_batch_size=batch_size,
+            warmup_steps=100,
+            num_train_epochs=num_epochs,
+            learning_rate=learning_rate,
+            logging_steps=100,
+            optim="adamw_torch",
+            eval_strategy="steps",
+            save_strategy="steps",
+            eval_steps=eval_step,
+            save_steps=save_step,
+            output_dir=output_dir,
+            save_total_limit=3,
+            load_best_model_at_end=True,
+            ddp_find_unused_parameters=False if world_size > 1 else None,
+        ),
+        data_collator=transformers.DataCollatorForSeq2Seq(
+            tokenizer, pad_to_multiple_of=8, return_tensors="pt", padding=True
+        ),
+    )
+    trainer.train()
+    model.save_pretrained(output_dir)
+
+    del model
+    model = AutoModelForCausalLM.from_pretrained(base_model, **model_kwargs)
+    model = PeftModel.from_pretrained(model, output_dir)
+
+
+def generate_prompt(example):
+    return f"""Below is an instruction that describes a task. Write a response that appropriately completes the request.
+            ### Instruction:
+            {example["instruction"]}
+            ### Response:
+            {example["output"]}"""
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--base_model", type=str, help="Base model path or Hub model id")
+    parser.add_argument("--data_path", type=str, default="yahma/alpaca-cleaned")
+    parser.add_argument("--output_dir", type=str, default="glora")
+    parser.add_argument("--batch_size", type=int, default=16)
+    parser.add_argument("--num_epochs", type=int, default=1)
+    parser.add_argument("--learning_rate", type=float, default=3e-4)
+    parser.add_argument("--cutoff_len", type=int, default=256)
+    parser.add_argument("--val_set_size", type=int, default=16)
+    parser.add_argument("--eval_step", type=int, default=100)
+    parser.add_argument("--save_step", type=int, default=100)
+    parser.add_argument("--device_map", type=str, default="auto")
+    parser.add_argument("--glora_r", type=int, default=8)
+    parser.add_argument("--config_A_B", type=str, default="lora", choices=["lora", "vector", "constant", "none"])
+    parser.add_argument("--config_C", type=str, default="lora", choices=["lora", "vector", "none"])
+    parser.add_argument("--config_D_E", type=str, default="constant", choices=["vector", "constant", "none"])
+    parser.add_argument(
+        "--glora_target_modules",
+        type=str,
+        default=None,
+        help="Comma-separated list of module names to apply GLoRA to. Defaults to a standard decoder block set.",
+    )
+    parser.add_argument("--dtype", type=str, default="float16")
+    parser.add_argument("--seed", type=int, default=None)
+    parser.add_argument(
+        "--init_weights",
+        dest="init_weights",
+        action="store_true",
+        default=True,
+        help="Initialize GLoRA weights as a no-op (default).",
+    )
+    parser.add_argument(
+        "--no_init_weights",
+        dest="init_weights",
+        action="store_false",
+        help="Disable no-op initialization to use kaiming initialization instead.",
+    )
+
+    args = parser.parse_args()
+
+    glora_target_modules = None
+    if args.glora_target_modules is not None:
+        glora_target_modules = [module.strip() for module in args.glora_target_modules.split(",") if module.strip()]
+
+    train(
+        base_model=args.base_model,
+        data_path=args.data_path,
+        output_dir=args.output_dir,
+        batch_size=args.batch_size,
+        num_epochs=args.num_epochs,
+        learning_rate=args.learning_rate,
+        cutoff_len=args.cutoff_len,
+        val_set_size=args.val_set_size,
+        eval_step=args.eval_step,
+        save_step=args.save_step,
+        device_map=args.device_map,
+        glora_r=args.glora_r,
+        config_A_B=args.config_A_B,
+        config_C=args.config_C,
+        config_D_E=args.config_D_E,
+        glora_target_modules=glora_target_modules,
+        dtype=args.dtype,
+        seed=args.seed,
+        init_weights=args.init_weights,
+    )
diff --git a/examples/gralora_finetuning/README.md b/examples/gralora_finetuning/README.md
new file mode 100644
index 0000000..616141e
--- /dev/null
+++ b/examples/gralora_finetuning/README.md
@@ -0,0 +1,73 @@
+# GraLoRA: Granular Low-Rank Adaptation
+
+![GraLoRA Overview](https://github.com/SqueezeBits/GraLoRA/raw/main/figure/gralora_overview.png)
+
+## Introduction
+[**Granular Low-Rank Adaptation (GraLoRA)**](https://huggingface.co/papers/2505.20355) is a PEFT method designed to enhance the **expressivity** of low-rank adaptation while improving **robustness to outlier** activations, based on insights from well-known issues in quantization. 
+
+GraLoRA introduces a structured and fine-grained adaptation scheme. It divides the adaptation space into a grid of $𝑘^2$ smaller, independent adapter pairs, each responsible for a localized subset of the input and output dimensions.
+
+## Quick start
+
+With respect to your standard PEFT training procedure with LoRA, simply swap your `LoraConfig` for a `GraloraConfig`.
+
+```python
+import torch
+from datasets import load_dataset
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from trl import SFTTrainer, SFTConfig
+from peft import GraloraConfig
+
+model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.2-3B", dtype=torch.bfloat16, device_map="auto")
+tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-3B")
+dataset = load_dataset("timdettmers/openassistant-guanaco", split="train")
+gralora_config = GraloraConfig()
+
+trainer = SFTTrainer(
+    model=model,
+    train_dataset=dataset,
+    processing_class=tokenizer,
+    peft_config=gralora_config,
+    args=SFTConfig(
+        max_length=2048,
+        dataset_text_field="text",
+        per_device_train_batch_size=2,
+    ),
+)
+trainer.train()
+trainer.model.save_pretrained("gralora-llama-3.2-3b")
+```
+
+Run the finetuning script simply by running:
+```sh
+python examples/gralora_finetuning/gralora_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --data_path timdettmers/openassistant-guanaco
+```
+
+## Use the model on 🤗
+You can load and use the model as any other 🤗 models.
+```python
+import torch
+from peft import PeftModel
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained(
+    "meta-llama/Meta-Llama-3-8B", dtype=torch.bfloat16, device_map="auto"
+)
+peft_model = PeftModel.from_pretrained(model, "gralora-llama-3-8b")
+```
+
+## Additional Notes
+While `gralora_k` is set to 2 for default, you can increase this value to create more fine-grained adapters. `gralora_k` of 4 is recommended when the total rank (`r + hybrid_r`) is 64 or higher.
+
+## Citation
+```
+@misc{jung2025graloragranularlowrankadaptation,
+      title={GraLoRA: Granular Low-Rank Adaptation for Parameter-Efficient Fine-Tuning}, 
+      author={Yeonjoon Jung and Daehyun Ahn and Hyungjun Kim and Taesu Kim and Eunhyeok Park},
+      year={2025},
+      eprint={2505.20355},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG},
+      url={https://arxiv.org/abs/2505.20355}, 
+}
+```
diff --git a/examples/gralora_finetuning/gralora_finetuning.py b/examples/gralora_finetuning/gralora_finetuning.py
new file mode 100644
index 0000000..666cc5b
--- /dev/null
+++ b/examples/gralora_finetuning/gralora_finetuning.py
@@ -0,0 +1,189 @@
+# This script is based on examples/dora_finetuning/dora_finetuning.py
+import os
+
+import torch
+from datasets import load_dataset
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    DataCollatorForLanguageModeling,
+    Trainer,
+    TrainingArguments,
+)
+
+from peft import GraloraConfig, get_peft_model
+
+
+def train_model(
+    base_model: str,
+    data_path: str,
+    output_dir: str,
+    batch_size: int,
+    num_epochs: int,
+    learning_rate: float,
+    cutoff_len: int,
+    val_set_size: int,
+    eval_step: int,
+    save_step: int,
+    device: str,
+    gralora_r: int,
+    gralora_alpha: int,
+    gralora_dropout: float,
+    gralora_target_modules: str,
+    gralora_k: int,
+    hybrid_r: int,
+    hub_model_id: str,
+    push_to_hub: bool,
+):
+    os.environ["TOKENIZERS_PARALLELISM"] = "false"
+    hf_token = os.getenv("HF_TOKEN")
+
+    # Setup device
+    if device == "auto":
+        device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+    else:
+        device = torch.device(device)
+    print(f"Using device: {device}")
+
+    # load tokenizer
+    tokenizer = AutoTokenizer.from_pretrained(base_model, token=hf_token)
+
+    model = AutoModelForCausalLM.from_pretrained(base_model, token=hf_token)
+    # GraLoRA config for the PEFT model
+    gralora_config = GraloraConfig(
+        r=gralora_r,  # Rank of matrix
+        alpha=gralora_alpha,
+        target_modules=(
+            gralora_target_modules.split(",")
+            if gralora_target_modules
+            else ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
+        ),
+        gralora_dropout=gralora_dropout,
+        gralora_k=gralora_k,
+        hybrid_r=hybrid_r,
+        bias="none",
+    )
+
+    # get the peft model with GraLoRA config
+    model = get_peft_model(model, gralora_config)
+
+    model.to(device)  # MODEL TO GPU/CUDA
+    tokenizer.pad_token = tokenizer.eos_token
+
+    # Load the dataset
+    dataset = load_dataset(data_path)
+
+    def tokenize_function(examples):
+        inputs = tokenizer(examples["text"], padding="max_length", truncation=True, max_length=cutoff_len)
+        inputs["labels"] = inputs["input_ids"].copy()  # setting labels for a language modeling task
+        return inputs
+
+    # Tokenize the dataset and prepare for training
+    tokenized_datasets = dataset.map(tokenize_function, batched=True, remove_columns=dataset["train"].column_names)
+
+    # Data collator to dynamically pad the batched examples
+    data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)
+
+    # Define training arguments
+    training_args = TrainingArguments(
+        output_dir=output_dir,
+        num_train_epochs=num_epochs,
+        per_device_train_batch_size=batch_size,
+        per_device_eval_batch_size=batch_size,
+        warmup_steps=100,
+        weight_decay=0.01,
+        logging_steps=eval_step,
+        save_steps=save_step,
+        save_total_limit=2,
+        push_to_hub=push_to_hub,
+        hub_model_id=hub_model_id,
+        gradient_accumulation_steps=16,
+        fp16=True,
+        learning_rate=learning_rate,
+        hub_token=hf_token,
+    )
+
+    # Clear device cache to free memory
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+    elif torch.xpu.is_available():
+        torch.xpu.empty_cache()
+
+    # Initialize the Trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=tokenized_datasets["train"],
+        eval_dataset=tokenized_datasets["test"],
+        data_collator=data_collator,
+    )
+
+    # Start model training
+    trainer.train()
+
+    # Save and push the trained model and tokenizer
+    if push_to_hub:
+        # Push the main model to the hub
+        trainer.push_to_hub(commit_message="Fine-tuned model")
+
+    # Save the model and tokenizer locally
+    model.save_pretrained(output_dir)
+    tokenizer.save_pretrained(output_dir)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Fine-tune LLaMA with GraLoRA and PEFT")
+    parser.add_argument("--base_model", type=str, default="meta-llama/Llama-3.2-3B", help="Base model path or name")
+    parser.add_argument(
+        "--data_path", type=str, default="timdettmers/openassistant-guanaco", help="Dataset path or name"
+    )
+    parser.add_argument(
+        "--output_dir", type=str, default="path/to/output", help="Output directory for the fine-tuned model"
+    )
+    parser.add_argument("--batch_size", type=int, default=1, help="Batch size")
+    parser.add_argument("--num_epochs", type=int, default=1, help="Number of training epochs")
+    parser.add_argument("--learning_rate", type=float, default=1e-4, help="Learning rate")
+    parser.add_argument("--cutoff_len", type=int, default=512, help="Cutoff length for tokenization")
+    parser.add_argument("--val_set_size", type=int, default=500, help="Validation set size")
+    parser.add_argument("--eval_step", type=int, default=10, help="Evaluation step interval")
+    parser.add_argument("--save_step", type=int, default=100, help="Save step interval")
+    parser.add_argument("--device", type=str, default="auto", help="Device to use for training")
+    parser.add_argument("--gralora_r", type=int, default=8, help="LoRA rank")
+    parser.add_argument("--gralora_alpha", type=int, default=16, help="LoRA alpha")
+    parser.add_argument("--gralora_dropout", type=float, default=0.05, help="LoRA dropout rate")
+    parser.add_argument(
+        "--gralora_target_modules", type=str, default=None, help="Comma-separated list of target modules for LoRA"
+    )
+    parser.add_argument("--gralora_k", type=int, default=2, help="GraLoRA k")
+    parser.add_argument("--hybrid_r", type=int, default=0, help="Hybrid rank")
+    parser.add_argument(
+        "--hub_model_id",
+        type=str,
+        default="path/to/repo",
+        help="Repository name to push the model on the Hugging Face Hub",
+    )
+    parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to Hugging Face Hub")
+    args = parser.parse_args()
+    train_model(
+        base_model=args.base_model,
+        data_path=args.data_path,
+        output_dir=args.output_dir,
+        batch_size=args.batch_size,
+        num_epochs=args.num_epochs,
+        learning_rate=args.learning_rate,
+        cutoff_len=args.cutoff_len,
+        val_set_size=args.val_set_size,
+        eval_step=args.eval_step,
+        save_step=args.save_step,
+        device=args.device,
+        gralora_r=args.gralora_r,
+        gralora_alpha=args.gralora_alpha,
+        gralora_dropout=args.gralora_dropout,
+        gralora_target_modules=args.gralora_target_modules,
+        gralora_k=args.gralora_k,
+        hybrid_r=args.hybrid_r,
+        hub_model_id=args.hub_model_id,
+        push_to_hub=args.push_to_hub,
+    )
diff --git a/examples/hira_finetuning/README.md b/examples/hira_finetuning/README.md
new file mode 100644
index 0000000..bccdb8a
--- /dev/null
+++ b/examples/hira_finetuning/README.md
@@ -0,0 +1,18 @@
+# HiRA causal language modeling fine-tuning
+
+This example demonstrates how to fine-tune a causal language model with [HiRA](https://openreview.net/pdf?id=TwJrTz9cRS) adapters using the Alpaca-style instruction data from `yahma/alpaca-cleaned`. The script mirrors the common LoRA flow and shows how to configure HiRA-specific parameters such as the Hadamard modulation rank (`r`) and dropout.
+
+## Running the script
+
+```bash
+python examples/hira_finetuning/hira_finetuning.py \
+  --base_model meta-llama/Meta-Llama-3-8B-Instruct \
+  --data_path yahma/alpaca-cleaned \
+  --output_dir hira-alpaca \
+  --hira_r 16 \
+  --hira_dropout 0.05 \
+  --learning_rate 3e-4 \
+  --num_epochs 3
+```
+
+The default target modules cover the attention projections and MLP blocks typically present in decoder-style architectures. Adjust them if your base model uses different module names.
diff --git a/examples/hira_finetuning/hira_finetuning.py b/examples/hira_finetuning/hira_finetuning.py
new file mode 100644
index 0000000..696072f
--- /dev/null
+++ b/examples/hira_finetuning/hira_finetuning.py
@@ -0,0 +1,217 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+import os
+from typing import Optional
+
+import torch
+import transformers
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoTokenizer, set_seed
+
+from peft import HiraConfig, PeftModel, get_peft_model
+
+
+def train(
+    base_model: str = "path/to/model",
+    data_path: str = "yahma/alpaca-cleaned",
+    output_dir: str = "hira",
+    batch_size: int = 16,
+    num_epochs: int = 1,
+    learning_rate: float = 3e-4,
+    cutoff_len: int = 256,
+    val_set_size: int = 16,
+    eval_step: int = 100,
+    save_step: int = 100,
+    device_map: str = "auto",
+    hira_r: int = 32,
+    hira_dropout: float = 0.0,
+    hira_target_modules: Optional[list[str]] = None,
+    dtype: str = "float16",
+    seed: Optional[int] = None,
+    init_weights: bool = True,
+):
+    """
+    Fine-tunes a causal language model with HiRA adapters on Alpaca-style instruction data.
+    """
+
+    world_size = int(os.environ.get("WORLD_SIZE", "0")) or int(os.environ.get("PMI_SIZE", "0"))
+    if world_size > 1 and device_map != "cpu":
+        from accelerate import Accelerator
+
+        device_map = {"": Accelerator().process_index}
+
+    if seed is not None:
+        set_seed(seed)
+
+    model_kwargs = {"dtype": getattr(torch, dtype), "device_map": device_map}
+    model = AutoModelForCausalLM.from_pretrained(base_model, **model_kwargs)
+
+    tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    def tokenize(prompt, add_eos_token: bool = True):
+        result = tokenizer(
+            prompt,
+            truncation=True,
+            max_length=cutoff_len,
+            padding=False,
+            return_tensors=None,
+        )
+        if (
+            result["input_ids"][-1] != tokenizer.eos_token_id
+            and len(result["input_ids"]) < cutoff_len
+            and add_eos_token
+        ):
+            result["input_ids"].append(tokenizer.eos_token_id)
+            result["attention_mask"].append(1)
+
+        result["labels"] = result["input_ids"].copy()
+
+        return result
+
+    def generate_and_tokenize_prompt(example):
+        full_prompt = generate_prompt(example)
+        tokenized_full_prompt = tokenize(full_prompt)
+        return tokenized_full_prompt
+
+    default_target_modules = [
+        "q_proj",
+        "k_proj",
+        "v_proj",
+        "o_proj",
+        "gate_proj",
+        "down_proj",
+        "up_proj",
+    ]
+    config = HiraConfig(
+        r=hira_r,
+        target_modules=hira_target_modules or default_target_modules,
+        hira_dropout=hira_dropout,
+        init_weights=init_weights,
+        task_type="CAUSAL_LM",
+    )
+    model = get_peft_model(model, config)
+
+    data = load_dataset(data_path)
+
+    train_val = data["train"].train_test_split(test_size=val_set_size, shuffle=True, seed=42)
+    train_data = train_val["train"].shuffle().map(generate_and_tokenize_prompt)
+    val_data = train_val["test"].shuffle().map(generate_and_tokenize_prompt)
+
+    trainer = transformers.Trainer(
+        model=model,
+        train_dataset=train_data,
+        eval_dataset=val_data,
+        args=transformers.TrainingArguments(
+            per_device_train_batch_size=batch_size,
+            warmup_steps=100,
+            num_train_epochs=num_epochs,
+            learning_rate=learning_rate,
+            logging_steps=100,
+            optim="adamw_torch",
+            eval_strategy="steps",
+            save_strategy="steps",
+            eval_steps=eval_step,
+            save_steps=save_step,
+            output_dir=output_dir,
+            save_total_limit=3,
+            load_best_model_at_end=True,
+            ddp_find_unused_parameters=False if world_size > 1 else None,
+        ),
+        data_collator=transformers.DataCollatorForSeq2Seq(
+            tokenizer, pad_to_multiple_of=8, return_tensors="pt", padding=True
+        ),
+    )
+    trainer.train()
+    model.save_pretrained(output_dir)
+
+    del model
+    model = AutoModelForCausalLM.from_pretrained(base_model, **model_kwargs)
+    model = PeftModel.from_pretrained(model, output_dir)
+
+
+def generate_prompt(example):
+    return f"""Below is an instruction that describes a task. Write a response that appropriately completes the request.
+            ### Instruction:
+            {example["instruction"]}
+            ### Response:
+            {example["output"]}"""
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--base_model", type=str, default="path/to/model")
+    parser.add_argument("--data_path", type=str, default="yahma/alpaca-cleaned")
+    parser.add_argument("--output_dir", type=str, default="hira")
+    parser.add_argument("--batch_size", type=int, default=16)
+    parser.add_argument("--num_epochs", type=int, default=1)
+    parser.add_argument("--learning_rate", type=float, default=3e-4)
+    parser.add_argument("--cutoff_len", type=int, default=256)
+    parser.add_argument("--val_set_size", type=int, default=16)
+    parser.add_argument("--eval_step", type=int, default=100)
+    parser.add_argument("--save_step", type=int, default=100)
+    parser.add_argument("--device_map", type=str, default="auto")
+    parser.add_argument("--hira_r", type=int, default=32)
+    parser.add_argument("--hira_dropout", type=float, default=0.0)
+    parser.add_argument(
+        "--hira_target_modules",
+        type=str,
+        default=None,
+        help="Comma-separated list of module names to apply HiRA to. Defaults to a standard decoder block set.",
+    )
+    parser.add_argument("--dtype", type=str, default="float16")
+    parser.add_argument("--seed", type=int, default=None)
+    parser.add_argument(
+        "--init_weights",
+        dest="init_weights",
+        action="store_true",
+        default=True,
+        help="Initialize HiRA weights as a no-op (default).",
+    )
+    parser.add_argument(
+        "--no_init_weights",
+        dest="init_weights",
+        action="store_false",
+        help="Disable no-op initialization to use Gaussian initialization instead.",
+    )
+
+    args = parser.parse_args()
+
+    hira_target_modules = None
+    if args.hira_target_modules is not None:
+        hira_target_modules = [module.strip() for module in args.hira_target_modules.split(",") if module.strip()]
+
+    train(
+        base_model=args.base_model,
+        data_path=args.data_path,
+        output_dir=args.output_dir,
+        batch_size=args.batch_size,
+        num_epochs=args.num_epochs,
+        learning_rate=args.learning_rate,
+        cutoff_len=args.cutoff_len,
+        val_set_size=args.val_set_size,
+        eval_step=args.eval_step,
+        save_step=args.save_step,
+        device_map=args.device_map,
+        hira_r=args.hira_r,
+        hira_dropout=args.hira_dropout,
+        hira_target_modules=hira_target_modules,
+        dtype=args.dtype,
+        seed=args.seed,
+        init_weights=args.init_weights,
+    )
diff --git a/examples/hra_dreambooth/README.md b/examples/hra_dreambooth/README.md
new file mode 100644
index 0000000..1c93b7f
--- /dev/null
+++ b/examples/hra_dreambooth/README.md
@@ -0,0 +1,98 @@
+<!--Copyright 2024 The HuggingFace Team. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+
+-->
+
+# DreamBooth fine-tuning with HRA
+
+This guide demonstrates how to use Householder reflection adaptation (HRA) method, to fine-tune Dreambooth with `stabilityai/stable-diffusion-2-1` model.
+
+HRA provides a new perspective connecting LoRA to OFT and achieves encouraging performance in various downstream tasks.
+HRA adapts a pre-trained model by multiplying each frozen weight matrix with a chain of r learnable Householder reflections (HRs).
+HRA can be interpreted as either an OFT adapter or an adaptive LoRA. 
+Consequently, it harnesses the advantages of both strategies, reducing parameters and computation costs while penalizing the loss of pre-training knowledge.
+For further details on HRA, please consult the [original HRA paper](https://huggingface.co/papers/2405.17484).
+
+In this guide we provide a Dreambooth fine-tuning script that is available in [PEFT's GitHub repo examples](https://github.com/huggingface/peft/tree/main/examples/hra_dreambooth). This implementation is adapted from [peft's boft_dreambooth](https://github.com/huggingface/peft/tree/main/examples/boft_dreambooth). 
+
+You can try it out and fine-tune on your custom images.
+
+## Set up your environment
+
+Start by cloning the PEFT repository:
+
+```bash
+git clone --recursive https://github.com/huggingface/peft
+```
+
+Navigate to the directory containing the training scripts for fine-tuning Dreambooth with HRA:
+
+```bash
+cd peft/examples/hra_dreambooth
+```
+
+Set up your environment: install PEFT, and all the required libraries. At the time of writing this guide we recommend installing PEFT from source. The following environment setup should work on A100 and H100:
+
+```bash
+conda create --name peft python=3.10
+conda activate peft
+conda install pytorch==2.1.2 torchvision==0.16.2 torchaudio==2.1.2 pytorch-cuda=11.8 -c pytorch -c nvidia
+conda install xformers -c xformers
+pip install -r requirements.txt
+pip install git+https://github.com/huggingface/peft
+```
+
+## Download the data
+
+[dreambooth](https://github.com/google/dreambooth) dataset should have been automatically cloned in the following structure when running the training script.
+
+```
+hra_dreambooth
+├── data
+│   └── dreambooth
+│       └── dataset
+│           ├── backpack
+│           └── backpack_dog
+│           ...
+```
+
+You can also put your custom images into `hra_dreambooth/data/dreambooth/dataset`.
+
+## Fine-tune Dreambooth with HRA
+
+```bash
+class_idx=0
+bash ./train_dreambooth.sh $class_idx
+```
+
+where the `$class_idx` corresponds to different subjects ranging from 0 to 29.
+
+Launch the training script with `accelerate` and pass hyperparameters, as well as LoRa-specific arguments to it such as:
+
+- `use_hra`: Enables HRA in the training script.
+- `hra_r`: the number of HRs (i.e., r) across different layers, expressed in `int`. 
+As r increases, the number of trainable parameters increases, which generally leads to improved performance.
+However, this also results in higher memory consumption and longer computation times. 
+Therefore, r is usually set to 8.
+**Note**, please set r to an even number to avoid potential issues during initialization.
+- `hra_apply_GS`: Applies Gram-Schmidt orthogonalization. Default is `false`.
+- `hra_bias`: specify if the `bias` parameters should be trained. Can be `none`, `all` or `hra_only`.
+
+If you are running this script on Windows, you may need to set the `--num_dataloader_workers` to 0.
+
+To learn more about DreamBooth fine-tuning with prior-preserving loss, check out the [Diffusers documentation](https://huggingface.co/docs/diffusers/training/dreambooth#finetuning-with-priorpreserving-loss).
+
+## Generate images with the fine-tuned model
+
+To generate images with the fine-tuned model, simply run the jupyter notebook `dreambooth_inference.ipynb` for visualization with `jupyter notebook` under `./examples/hra_dreambooth`.
diff --git a/examples/hra_dreambooth/a_purple_qwe_backpack.png b/examples/hra_dreambooth/a_purple_qwe_backpack.png
new file mode 100644
index 0000000..c2784a3
Binary files /dev/null and b/examples/hra_dreambooth/a_purple_qwe_backpack.png differ
diff --git a/examples/hra_dreambooth/dreambooth_inference.ipynb b/examples/hra_dreambooth/dreambooth_inference.ipynb
new file mode 100644
index 0000000..fb80b1c
--- /dev/null
+++ b/examples/hra_dreambooth/dreambooth_inference.ipynb
@@ -0,0 +1,222 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "acab479f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from PIL import Image\n",
+    "\n",
+    "import torch\n",
+    "from accelerate.logging import get_logger\n",
+    "from diffusers import StableDiffusionPipeline\n",
+    "from diffusers.utils import check_min_version\n",
+    "\n",
+    "from peft import PeftModel\n",
+    "\n",
+    "\n",
+    "# Will error if the minimal version of diffusers is not installed. Remove at your own risks.\n",
+    "check_min_version(\"0.10.0.dev0\")\n",
+    "\n",
+    "logger = get_logger(__name__)\n",
+    "\n",
+    "MODEL_NAME = \"stabilityai/stable-diffusion-2-1\"\n",
+    "\n",
+    "PEFT_TYPE=\"hra\"\n",
+    "HRA_R=8\n",
+    "SELECTED_SUBJECT=\"backpack\"\n",
+    "EPOCH_IDX = 1000\n",
+    "\n",
+    "PROJECT_NAME=f\"dreambooth_{PEFT_TYPE}\"\n",
+    "RUN_NAME=f\"{SELECTED_SUBJECT}_{PEFT_TYPE}_{HRA_R}\"\n",
+    "OUTPUT_DIR=f\"./data/output/{PEFT_TYPE}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "06cfd506",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_hra_sd_pipeline(\n",
+    "    ckpt_dir, base_model_name_or_path=None, epoch=int, dtype=torch.float32, device=\"cuda\", adapter_name=\"default\"\n",
+    "):\n",
+    "\n",
+    "    if base_model_name_or_path is None:\n",
+    "        raise ValueError(\"Please specify the base model name or path\")\n",
+    "\n",
+    "    pipe = StableDiffusionPipeline.from_pretrained(\n",
+    "        base_model_name_or_path, torch_dtype=dtype, requires_safety_checker=False\n",
+    "    ).to(device)\n",
+    "    \n",
+    "    load_adapter(pipe, ckpt_dir, epoch, adapter_name)\n",
+    "\n",
+    "    if dtype in (torch.float16, torch.bfloat16):\n",
+    "        pipe.unet.half()\n",
+    "        pipe.text_encoder.half()\n",
+    "\n",
+    "    pipe.to(device)\n",
+    "    return pipe\n",
+    "\n",
+    "\n",
+    "def load_adapter(pipe, ckpt_dir, epoch, adapter_name=\"default\"):\n",
+    "    \n",
+    "    unet_sub_dir = os.path.join(ckpt_dir, f\"unet/{epoch}\", adapter_name)\n",
+    "    text_encoder_sub_dir = os.path.join(ckpt_dir, f\"text_encoder/{epoch}\", adapter_name)\n",
+    "    \n",
+    "    if isinstance(pipe.unet, PeftModel):\n",
+    "        pipe.unet.load_adapter(unet_sub_dir, adapter_name=adapter_name)\n",
+    "    else:\n",
+    "        pipe.unet = PeftModel.from_pretrained(pipe.unet, unet_sub_dir, adapter_name=adapter_name)\n",
+    "        \n",
+    "    if os.path.exists(text_encoder_sub_dir):\n",
+    "        if isinstance(pipe.text_encoder, PeftModel):\n",
+    "            pipe.text_encoder.load_adapter(text_encoder_sub_dir, adapter_name=adapter_name)\n",
+    "        else:\n",
+    "            pipe.text_encoder = PeftModel.from_pretrained(pipe.text_encoder, text_encoder_sub_dir, adapter_name=adapter_name)\n",
+    "    \n",
+    "\n",
+    "def set_adapter(pipe, adapter_name):\n",
+    "    pipe.unet.set_adapter(adapter_name)\n",
+    "    if isinstance(pipe.text_encoder, PeftModel):\n",
+    "        pipe.text_encoder.set_adapter(adapter_name)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "98a0d8ac",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompt = \"a purple qwe backpack.\"\n",
+    "negative_prompt = \"low quality, blurry, unfinished\"\n",
+    "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d4e888d2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading pipeline components...: 100%|██████████| 6/6 [00:00<00:00, 14.47it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 1.72 s, sys: 495 ms, total: 2.22 s\n",
+      "Wall time: 2.28 s\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "pipe = get_hra_sd_pipeline(OUTPUT_DIR, MODEL_NAME, EPOCH_IDX, adapter_name=RUN_NAME, device=device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "f1c1a1c0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 0/50 [00:00<?, ?it/s]"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 50/50 [00:09<00:00,  5.28it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 8.77 s, sys: 861 ms, total: 9.63 s\n",
+      "Wall time: 9.6 s\n"
+     ]
+    },
+    {
+     "data": {
+      "image/jpeg": "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",
+      "image/png": "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",
+      "text/plain": [
+       "<PIL.Image.Image image mode=RGB size=512x512>"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "image = pipe(prompt, num_inference_steps=50, guidance_scale=7.5, negative_prompt=negative_prompt).images[0]\n",
+    "image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "60fa38d2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "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",
+      "image/png": "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",
+      "text/plain": [
+       "<PIL.PngImagePlugin.PngImageFile image mode=RGB size=512x512>"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# This is an example.\n",
+    "example_image = Image.open(\"./a_purple_qwe_backpack.png\")\n",
+    "example_image"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "llama",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.14"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/hra_dreambooth/requirements.txt b/examples/hra_dreambooth/requirements.txt
new file mode 100644
index 0000000..b708ee8
--- /dev/null
+++ b/examples/hra_dreambooth/requirements.txt
@@ -0,0 +1,12 @@
+transformers==4.55.0
+accelerate==1.9.0
+evaluate
+tqdm
+datasets==4.0.0
+diffusers==0.38.0
+Pillow
+huggingface_hub
+safetensors
+ipykernel
+ipywidgets
+wandb==0.21.0
\ No newline at end of file
diff --git a/examples/hra_dreambooth/train_dreambooth.py b/examples/hra_dreambooth/train_dreambooth.py
new file mode 100644
index 0000000..be9e139
--- /dev/null
+++ b/examples/hra_dreambooth/train_dreambooth.py
@@ -0,0 +1,620 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+# The implementation is based on "Bridging The Gap between Low-rank and Orthogonal
+# Adaptation via Householder Reflection Adaptation" (https://huggingface.co/papers/2405.17484).
+
+import hashlib
+import itertools
+import logging
+import math
+import os
+from contextlib import nullcontext
+from pathlib import Path
+
+import datasets
+import diffusers
+import numpy as np
+import torch
+import torch.nn.functional as F
+import torch.utils.checkpoint
+import transformers
+from accelerate import Accelerator
+from accelerate.logging import get_logger
+from accelerate.utils import ProjectConfiguration, set_seed
+from diffusers import (
+    AutoencoderKL,
+    DDIMScheduler,
+    DiffusionPipeline,
+    DPMSolverMultistepScheduler,
+    UNet2DConditionModel,
+)
+from diffusers.optimization import get_scheduler
+from diffusers.utils import check_min_version
+from diffusers.utils.import_utils import is_xformers_available
+from huggingface_hub import Repository
+from tqdm.auto import tqdm
+from transformers import AutoTokenizer
+from utils.args_loader import (
+    get_full_repo_name,
+    import_model_class_from_model_name_or_path,
+    parse_args,
+)
+from utils.dataset import DreamBoothDataset, PromptDataset, collate_fn
+from utils.tracemalloc import TorchTracemalloc, b2mb
+
+from peft import HRAConfig, get_peft_model
+
+
+# Will error if the minimal version of diffusers is not installed. Remove at your own risks.
+check_min_version("0.16.0.dev0")
+
+logger = get_logger(__name__)
+
+UNET_TARGET_MODULES = ["to_q", "to_v", "to_k", "query", "value", "key", "to_out.0", "add_k_proj", "add_v_proj"]
+TEXT_ENCODER_TARGET_MODULES = ["q_proj", "v_proj"]
+
+
+def save_adaptor(accelerator, step, unet, text_encoder, args):
+    unwarpped_unet = accelerator.unwrap_model(unet)
+    unwarpped_unet.save_pretrained(
+        os.path.join(args.output_dir, f"unet/{step}"), state_dict=accelerator.get_state_dict(unet)
+    )
+    if args.train_text_encoder:
+        unwarpped_text_encoder = accelerator.unwrap_model(text_encoder)
+        unwarpped_text_encoder.save_pretrained(
+            os.path.join(args.output_dir, f"text_encoder/{step}"),
+            state_dict=accelerator.get_state_dict(text_encoder),
+        )
+
+
+def main(args):
+    validation_prompts = list(filter(None, args.validation_prompt[0].split(".")))
+
+    logging_dir = Path(args.output_dir, args.logging_dir)
+    accelerator_project_config = ProjectConfiguration(project_dir=args.output_dir, logging_dir=logging_dir)
+
+    accelerator = Accelerator(
+        gradient_accumulation_steps=args.gradient_accumulation_steps,
+        mixed_precision=args.mixed_precision,
+        log_with=args.report_to if args.report_to != "none" else None,
+        project_dir=accelerator_project_config,
+    )
+    if args.report_to == "wandb":
+        import wandb
+
+        args.wandb_project_name = args.project_name
+        args.wandb_run_name = args.run_name
+        wandb_init = {
+            "wandb": {
+                "name": args.wandb_run_name,
+                "mode": "online",
+            }
+        }
+
+    # Currently, it's not possible to do gradient accumulation when training two models with accelerate.accumulate
+    # This will be enabled soon in accelerate. For now, we don't allow gradient accumulation when training two models.
+    # TODO (patil-suraj): Remove this check when gradient accumulation with two models is enabled in accelerate.
+    if args.train_text_encoder and args.gradient_accumulation_steps > 1 and accelerator.num_processes > 1:
+        raise ValueError(
+            "Gradient accumulation is not supported when training the text encoder in distributed training. "
+            "Please set gradient_accumulation_steps to 1. This feature will be supported in the future."
+        )
+
+    # Make one log on every process with the configuration for debugging.
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        level=logging.INFO,
+    )
+    logger.info(accelerator.state, main_process_only=False)
+    if accelerator.is_local_main_process:
+        datasets.utils.logging.set_verbosity_warning()
+        transformers.utils.logging.set_verbosity_warning()
+        diffusers.utils.logging.set_verbosity_info()
+    else:
+        datasets.utils.logging.set_verbosity_error()
+        transformers.utils.logging.set_verbosity_error()
+        diffusers.utils.logging.set_verbosity_error()
+
+    # If passed along, set the training seed now.
+    global_seed = hash(args.run_name) % (2**32)
+    set_seed(global_seed)
+
+    # Generate class images if prior preservation is enabled.
+    if args.with_prior_preservation:
+        class_images_dir = Path(args.class_data_dir)
+        if not class_images_dir.exists():
+            class_images_dir.mkdir(parents=True)
+        cur_class_images = len(list(class_images_dir.iterdir()))
+
+        if cur_class_images < args.num_class_images:
+            dtype = torch.float16 if accelerator.device.type in ["cuda", "xpu"] else torch.float32
+            if args.prior_generation_precision == "fp32":
+                dtype = torch.float32
+            elif args.prior_generation_precision == "fp16":
+                dtype = torch.float16
+            elif args.prior_generation_precision == "bf16":
+                dtype = torch.bfloat16
+            pipeline = DiffusionPipeline.from_pretrained(
+                args.pretrained_model_name_or_path,
+                dtype=dtype,
+                safety_checker=None,
+                revision=args.revision,
+            )
+            pipeline.set_progress_bar_config(disable=True)
+
+            num_new_images = args.num_class_images - cur_class_images
+            logger.info(f"Number of class images to sample: {num_new_images}.")
+
+            sample_dataset = PromptDataset(args.class_prompt, num_new_images)
+            sample_dataloader = torch.utils.data.DataLoader(sample_dataset, batch_size=args.sample_batch_size)
+
+            sample_dataloader = accelerator.prepare(sample_dataloader)
+            pipeline.to(accelerator.device)
+
+            for example in tqdm(
+                sample_dataloader, desc="Generating class images", disable=not accelerator.is_local_main_process
+            ):
+                images = pipeline(example["prompt"]).images
+
+                for i, image in enumerate(images):
+                    hash_image = hashlib.sha1(image.tobytes()).hexdigest()
+                    image_filename = class_images_dir / f"{example['index'][i] + cur_class_images}-{hash_image}.jpg"
+                    image.save(image_filename)
+
+            del pipeline
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+            elif torch.xpu.is_available():
+                torch.xpu.empty_cache()
+
+    # Handle the repository creation
+    if accelerator.is_main_process:
+        if args.push_to_hub:
+            if args.hub_model_id is None:
+                repo_name = get_full_repo_name(Path(args.output_dir).name, token=args.hub_token)
+            else:
+                repo_name = args.hub_model_id
+            repo = Repository(args.output_dir, clone_from=repo_name)
+
+            with open(os.path.join(args.output_dir, ".gitignore"), "w+") as gitignore:
+                if "step_*" not in gitignore:
+                    gitignore.write("step_*\n")
+                if "epoch_*" not in gitignore:
+                    gitignore.write("epoch_*\n")
+        elif args.output_dir is not None:
+            os.makedirs(args.output_dir, exist_ok=True)
+
+    # Load the tokenizer
+    if args.tokenizer_name:
+        tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name, revision=args.revision, use_fast=False)
+    elif args.pretrained_model_name_or_path:
+        tokenizer = AutoTokenizer.from_pretrained(
+            args.pretrained_model_name_or_path,
+            subfolder="tokenizer",
+            revision=args.revision,
+            use_fast=False,
+        )
+
+    # import correct text encoder class
+    text_encoder_cls = import_model_class_from_model_name_or_path(args.pretrained_model_name_or_path, args.revision)
+
+    # Load scheduler and models
+    noise_scheduler = DDIMScheduler.from_pretrained(args.pretrained_model_name_or_path, subfolder="scheduler")
+
+    text_encoder = text_encoder_cls.from_pretrained(
+        args.pretrained_model_name_or_path, subfolder="text_encoder", revision=args.revision
+    )
+    vae = AutoencoderKL.from_pretrained(args.pretrained_model_name_or_path, subfolder="vae", revision=args.revision)
+    unet = UNet2DConditionModel.from_pretrained(
+        args.pretrained_model_name_or_path, subfolder="unet", revision=args.revision
+    )
+
+    if args.use_hra:
+        config = HRAConfig(
+            r=args.hra_r,
+            apply_GS=args.hra_apply_GS,
+            target_modules=UNET_TARGET_MODULES,
+            bias=args.hra_bias,
+        )
+        unet = get_peft_model(unet, config, adapter_name=args.run_name)
+        unet.print_trainable_parameters()
+
+    vae.requires_grad_(False)
+    unet.train()
+
+    if args.train_text_encoder and args.use_hra:
+        config = HRAConfig(
+            r=args.hra_r,
+            apply_GS=args.hra_apply_GS,
+            target_modules=UNET_TARGET_MODULES,
+            bias=args.hra_bias,
+        )
+        text_encoder = get_peft_model(text_encoder, config, adapter_name=args.run_name)
+        text_encoder.print_trainable_parameters()
+        text_encoder.train()
+    else:
+        text_encoder.requires_grad_(False)
+
+    # For mixed precision training we cast the text_encoder and vae weights to half-precision
+    # as these models are only used for inference, keeping weights in full precision is not required.
+    weight_dtype = torch.float32
+    if accelerator.mixed_precision == "fp16":
+        weight_dtype = torch.float16
+    elif accelerator.mixed_precision == "bf16":
+        weight_dtype = torch.bfloat16
+
+    # Move unet, vae and text_encoder to device and cast to weight_dtype
+    unet.to(accelerator.device, dtype=weight_dtype)
+    vae.to(accelerator.device, dtype=weight_dtype)
+    text_encoder.to(accelerator.device, dtype=weight_dtype)
+
+    if args.enable_xformers_memory_efficient_attention:
+        if accelerator.device.type == "xpu":
+            logger.warning("XPU hasn't support xformers yet, ignore it.")
+        elif is_xformers_available():
+            unet.enable_xformers_memory_efficient_attention()
+        else:
+            raise ValueError("xformers is not available. Make sure it is installed correctly")
+
+    if args.gradient_checkpointing:
+        unet.enable_gradient_checkpointing()
+        # below fails when using hra so commenting it out
+        if args.train_text_encoder and not args.use_hra:
+            text_encoder.gradient_checkpointing_enable()
+
+    # Enable TF32 for faster training on Ampere GPUs,
+    # cf https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices
+    if args.allow_tf32:
+        torch.backends.cuda.matmul.allow_tf32 = True
+
+    if args.scale_lr:
+        args.learning_rate = (
+            args.learning_rate * args.gradient_accumulation_steps * args.train_batch_size * accelerator.num_processes
+        )
+
+    # Use 8-bit Adam for lower memory usage or to fine-tune the model in 16GB GPUs
+    if args.use_8bit_adam:
+        try:
+            import bitsandbytes as bnb
+        except ImportError:
+            raise ImportError(
+                "To use 8-bit Adam, please install the bitsandbytes library: `pip install bitsandbytes`."
+            )
+
+        optimizer_class = bnb.optim.AdamW8bit
+    else:
+        optimizer_class = torch.optim.AdamW
+
+    # Optimizer creation
+    params_to_optimize = [param for param in unet.parameters() if param.requires_grad]
+
+    if args.train_text_encoder:
+        params_to_optimize += [param for param in text_encoder.parameters() if param.requires_grad]
+
+    optimizer = optimizer_class(
+        params_to_optimize,
+        lr=args.learning_rate,
+        betas=(args.adam_beta1, args.adam_beta2),
+        weight_decay=args.adam_weight_decay,
+        eps=args.adam_epsilon,
+    )
+
+    # Download the official dreambooth dataset from the official repository: https://github.com/google/dreambooth.git
+    data_path = os.path.join(os.getcwd(), "data", "dreambooth")
+    if not os.path.exists(data_path):
+        os.makedirs(os.path.join(os.getcwd(), "data"), exist_ok=True)
+        os.system(f"git clone https://github.com/google/dreambooth.git '{data_path}'")
+
+    # Dataset and DataLoaders creation:
+    train_dataset = DreamBoothDataset(
+        instance_data_root=args.instance_data_dir,
+        instance_prompt=args.instance_prompt,
+        class_data_root=args.class_data_dir if args.with_prior_preservation else None,
+        class_prompt=args.class_prompt,
+        tokenizer=tokenizer,
+        size=args.resolution,
+        center_crop=args.center_crop,
+    )
+
+    train_dataloader = torch.utils.data.DataLoader(
+        train_dataset,
+        batch_size=args.train_batch_size,
+        shuffle=True,
+        collate_fn=lambda examples: collate_fn(examples, args.with_prior_preservation),
+        num_workers=args.num_dataloader_workers,
+    )
+
+    # Scheduler and math around the number of training steps.
+    overrode_max_train_steps = False
+    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+    if args.max_train_steps is None:
+        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+        overrode_max_train_steps = True
+
+    lr_scheduler = get_scheduler(
+        args.lr_scheduler,
+        optimizer=optimizer,
+        num_warmup_steps=args.lr_warmup_steps * args.gradient_accumulation_steps,
+        num_training_steps=args.max_train_steps * args.gradient_accumulation_steps,
+        num_cycles=args.lr_num_cycles,
+        power=args.lr_power,
+    )
+
+    # Prepare everything with our `accelerator`.
+    if args.train_text_encoder:
+        unet, text_encoder, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
+            unet, text_encoder, optimizer, train_dataloader, lr_scheduler
+        )
+    else:
+        unet, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
+            unet, optimizer, train_dataloader, lr_scheduler
+        )
+
+    # For mixed precision training we cast the text_encoder and vae weights to half-precision
+    # as these models are only used for inference, keeping weights in full precision is not required.
+    weight_dtype = torch.float32
+    if accelerator.mixed_precision == "fp16":
+        weight_dtype = torch.float16
+    elif accelerator.mixed_precision == "bf16":
+        weight_dtype = torch.bfloat16
+
+    # Move vae and text_encoder to device and cast to weight_dtype
+    vae.to(accelerator.device, dtype=weight_dtype)
+    if not args.train_text_encoder:
+        text_encoder.to(accelerator.device, dtype=weight_dtype)
+
+    # We need to recalculate our total training steps as the size of the training dataloader may have changed.
+    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+    if overrode_max_train_steps:
+        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+    # Afterwards we recalculate our number of training epochs
+    args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch)
+
+    # We need to initialize the trackers we use, and also store our configuration.
+    # The trackers initializes automatically on the main process.
+    if accelerator.is_main_process:
+        if args.report_to == "wandb":
+            accelerator.init_trackers(args.wandb_project_name, config=vars(args), init_kwargs=wandb_init)
+        else:
+            accelerator.init_trackers(args.project_name, config=vars(args))
+
+    # Train!
+    total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps
+
+    logger.info("***** Running training *****")
+    logger.info(f"  Num examples = {len(train_dataset)}")
+    logger.info(f"  Num batches each epoch = {len(train_dataloader)}")
+    logger.info(f"  Num Epochs = {args.num_train_epochs}")
+    logger.info(f"  Instantaneous batch size per device = {args.train_batch_size}")
+    logger.info(f"  Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}")
+    logger.info(f"  Gradient Accumulation steps = {args.gradient_accumulation_steps}")
+    logger.info(f"  Total optimization steps = {args.max_train_steps}")
+    global_step = 0
+    first_epoch = 0
+
+    # Potentially load in the weights and states from a previous save
+    if args.resume_from_checkpoint:
+        if args.resume_from_checkpoint != "latest":
+            path = os.path.basename(args.resume_from_checkpoint)
+        else:
+            # Get the most recent checkpoint
+            dirs = os.listdir(args.output_dir)
+            dirs = [d for d in dirs if d.startswith("checkpoint")]
+            dirs = sorted(dirs, key=lambda x: int(x.split("-")[1]))
+            path = dirs[-1] if len(dirs) > 0 else None
+        accelerator.print(f"Resuming from checkpoint {path}")
+        accelerator.load_state(os.path.join(args.output_dir, path))
+        global_step = int(path.split("-")[1])
+
+        resume_global_step = global_step * args.gradient_accumulation_steps
+        first_epoch = resume_global_step // num_update_steps_per_epoch
+        resume_step = resume_global_step % num_update_steps_per_epoch
+
+    # Only show the progress bar once on each machine.
+    progress_bar = tqdm(range(global_step, args.max_train_steps), disable=not accelerator.is_local_main_process)
+    progress_bar.set_description("Steps")
+
+    if args.train_text_encoder:
+        text_encoder.train()
+
+    for epoch in range(first_epoch, args.num_train_epochs):
+        unet.train()
+
+        with TorchTracemalloc() if not args.no_tracemalloc else nullcontext() as tracemalloc:
+            for step, batch in enumerate(train_dataloader):
+                # Skip steps until we reach the resumed step
+                if args.resume_from_checkpoint and epoch == first_epoch and step < resume_step:
+                    if step % args.gradient_accumulation_steps == 0:
+                        progress_bar.update(1)
+                        if args.report_to == "wandb":
+                            accelerator.print(progress_bar)
+                    continue
+
+                with accelerator.accumulate(unet):
+                    # Convert images to latent space
+                    latents = vae.encode(batch["pixel_values"].to(dtype=weight_dtype)).latent_dist.sample()
+                    latents = latents * vae.config.scaling_factor
+
+                    # Sample noise that we'll add to the latents
+                    noise = torch.randn_like(latents)
+                    bsz = latents.shape[0]
+                    # Sample a random timestep for each image
+                    timesteps = torch.randint(
+                        0, noise_scheduler.config.num_train_timesteps, (bsz,), device=latents.device
+                    )
+                    timesteps = timesteps.long()
+
+                    # Add noise to the latents according to the noise magnitude at each timestep
+                    # (this is the forward diffusion process)
+                    noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps)
+
+                    # Get the text embedding for conditioning
+                    encoder_hidden_states = text_encoder(batch["input_ids"])[0]
+
+                    # Predict the noise residual
+                    model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample
+
+                    # Get the target for loss depending on the prediction type
+                    if noise_scheduler.config.prediction_type == "epsilon":
+                        target = noise
+                    elif noise_scheduler.config.prediction_type == "v_prediction":
+                        target = noise_scheduler.get_velocity(latents, noise, timesteps)
+                    else:
+                        raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}")
+
+                    if args.with_prior_preservation:
+                        # Chunk the noise and model_pred into two parts and compute the loss on each part separately.
+                        model_pred, model_pred_prior = torch.chunk(model_pred, 2, dim=0)
+                        target, target_prior = torch.chunk(target, 2, dim=0)
+
+                        # Compute instance loss
+                        loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
+
+                        # Compute prior loss
+                        prior_loss = F.mse_loss(model_pred_prior.float(), target_prior.float(), reduction="mean")
+
+                        # Add the prior loss to the instance loss.
+                        loss = loss + args.prior_loss_weight * prior_loss
+                    else:
+                        loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
+
+                    accelerator.backward(loss)
+
+                    if accelerator.sync_gradients:
+                        params_to_clip = (
+                            itertools.chain(unet.parameters(), text_encoder.parameters())
+                            if args.train_text_encoder
+                            else unet.parameters()
+                        )
+                        accelerator.clip_grad_norm_(params_to_clip, args.max_grad_norm)
+
+                    optimizer.step()
+                    lr_scheduler.step()
+                    optimizer.zero_grad()
+
+                # Checks if the accelerator has performed an optimization step behind the scenes
+                if accelerator.sync_gradients:
+                    progress_bar.update(1)
+                    if args.report_to == "wandb":
+                        accelerator.print(progress_bar)
+                    global_step += 1
+
+                if global_step % args.checkpointing_steps == 0 and global_step != 0:
+                    if accelerator.is_main_process:
+                        save_adaptor(accelerator, global_step, unet, text_encoder, args)
+
+                logs = {"loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0]}
+                progress_bar.set_postfix(**logs)
+                accelerator.log(logs, step=global_step)
+
+                if (
+                    args.validation_prompt is not None
+                    and (step + num_update_steps_per_epoch * epoch) % args.validation_steps == 0
+                    and global_step > 10
+                ):
+                    unet.eval()
+
+                    logger.info(
+                        f"Running validation... \n Generating {len(validation_prompts)} images with prompt:"
+                        f" {validation_prompts[0]}, ......"
+                    )
+                    # create pipeline
+                    pipeline = DiffusionPipeline.from_pretrained(
+                        args.pretrained_model_name_or_path,
+                        safety_checker=None,
+                        revision=args.revision,
+                    )
+                    # set `keep_fp32_wrapper` to True because we do not want to remove
+                    # mixed precision hooks while we are still training
+                    pipeline.unet = accelerator.unwrap_model(unet, keep_fp32_wrapper=True)
+                    pipeline.text_encoder = accelerator.unwrap_model(text_encoder, keep_fp32_wrapper=True)
+                    pipeline.scheduler = DPMSolverMultistepScheduler.from_config(pipeline.scheduler.config)
+                    pipeline = pipeline.to(accelerator.device)
+                    pipeline.set_progress_bar_config(disable=True)
+
+                    # run inference
+                    if args.seed is not None:
+                        generator = torch.Generator(device=accelerator.device).manual_seed(args.seed)
+                    else:
+                        generator = None
+
+                    images = []
+                    val_img_dir = os.path.join(
+                        args.output_dir,
+                        f"validation/{global_step}",
+                        args.run_name,
+                    )
+                    os.makedirs(val_img_dir, exist_ok=True)
+
+                    for val_promot in validation_prompts:
+                        image = pipeline(val_promot, num_inference_steps=50, generator=generator).images[0]
+                        image.save(os.path.join(val_img_dir, f"{'_'.join(val_promot.split(' '))}.png"[1:]))
+                        images.append(image)
+
+                    for tracker in accelerator.trackers:
+                        if tracker.name == "tensorboard":
+                            np_images = np.stack([np.asarray(img) for img in images])
+                            tracker.writer.add_images("validation", np_images, epoch, dataformats="NHWC")
+                        if tracker.name == "wandb":
+                            import wandb
+
+                            tracker.log(
+                                {
+                                    "validation": [
+                                        wandb.Image(image, caption=f"{i}: {validation_prompts[i]}")
+                                        for i, image in enumerate(images)
+                                    ]
+                                }
+                            )
+
+                    del pipeline
+                    if torch.cuda.is_available():
+                        torch.cuda.empty_cache()
+                    elif torch.xpu.is_available():
+                        torch.xpu.empty_cache()
+                if global_step >= args.max_train_steps:
+                    break
+
+        # Printing the device memory usage details such as allocated memory, peak memory, and total memory usage
+        if not args.no_tracemalloc:
+            accelerator.print(
+                f"{accelerator.device.type.upper()} Memory before entering the train : {b2mb(tracemalloc.begin)}"
+            )
+            accelerator.print(
+                f"{accelerator.device.type.upper()} Memory consumed at the end of the train (end-begin): {tracemalloc.used}"
+            )
+            accelerator.print(
+                f"{accelerator.device.type.upper()} Peak Memory consumed during the train (max-begin): {tracemalloc.peaked}"
+            )
+            accelerator.print(
+                f"{accelerator.device.type.upper()} Total Peak Memory consumed during the train (max): {tracemalloc.peaked + b2mb(tracemalloc.begin)}"
+            )
+
+            accelerator.print(f"CPU Memory before entering the train : {b2mb(tracemalloc.cpu_begin)}")
+            accelerator.print(f"CPU Memory consumed at the end of the train (end-begin): {tracemalloc.cpu_used}")
+            accelerator.print(f"CPU Peak Memory consumed during the train (max-begin): {tracemalloc.cpu_peaked}")
+            accelerator.print(
+                f"CPU Total Peak Memory consumed during the train (max): {tracemalloc.cpu_peaked + b2mb(tracemalloc.cpu_begin)}"
+            )
+
+    if args.push_to_hub:
+        repo.push_to_hub(commit_message="End of training", blocking=False, auto_lfs_prune=True)
+    accelerator.end_training()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    main(args)
diff --git a/examples/hra_dreambooth/train_dreambooth.sh b/examples/hra_dreambooth/train_dreambooth.sh
new file mode 100644
index 0000000..c45915b
--- /dev/null
+++ b/examples/hra_dreambooth/train_dreambooth.sh
@@ -0,0 +1,185 @@
+
+CLASS_IDX=$1
+
+# Define the UNIQUE_TOKEN, CLASS_TOKENs, and SUBJECT_NAMES
+UNIQUE_TOKEN="qwe"
+
+SUBJECT_NAMES=(
+    "backpack" "backpack_dog" "bear_plushie" "berry_bowl" "can"
+    "candle" "cat" "cat2" "clock" "colorful_sneaker"
+    "dog" "dog2" "dog3" "dog5" "dog6"
+    "dog7" "dog8" "duck_toy" "fancy_boot" "grey_sloth_plushie"
+    "monster_toy" "pink_sunglasses" "poop_emoji" "rc_car" "red_cartoon"
+    "robot_toy" "shiny_sneaker" "teapot" "vase" "wolf_plushie"
+)
+
+CLASS_TOKENs=(
+    "backpack" "backpack" "stuffed animal" "bowl" "can"
+    "candle" "cat" "cat" "clock" "sneaker"
+    "dog" "dog" "dog" "dog" "dog"
+    "dog" "dog" "toy" "boot" "stuffed animal"
+    "toy" "glasses" "toy" "toy" "cartoon"
+    "toy" "sneaker" "teapot" "vase" "stuffed animal"
+)
+
+CLASS_TOKEN=${CLASS_TOKENs[$CLASS_IDX]}
+SELECTED_SUBJECT=${SUBJECT_NAMES[$CLASS_IDX]}
+
+if [[ $CLASS_IDX =~ ^(0|1|2|3|4|5|8|9|17|18|19|20|21|22|23|24|25|26|27|28|29)$ ]]; then
+  PROMPT_LIST=(
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in the jungle."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in the snow."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on the beach."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on a cobblestone street."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of pink fabric."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a wooden floor."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a city in the background."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a mountain in the background."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a blue house in the background."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a purple rug in a forest."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a wheat field in the background."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a tree and autumn leaves in the background."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with the Eiffel Tower in the background."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} floating on top of water."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} floating in an ocean of milk."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of green grass with sunflowers around it."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a mirror."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of the sidewalk in a crowded street."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a dirt road."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a white rug."
+    "a red ${UNIQUE_TOKEN} ${CLASS_TOKEN}."
+    "a purple ${UNIQUE_TOKEN} ${CLASS_TOKEN}."
+    "a shiny ${UNIQUE_TOKEN} ${CLASS_TOKEN}."
+    "a wet ${UNIQUE_TOKEN} ${CLASS_TOKEN}."
+    "a cube shaped ${UNIQUE_TOKEN} ${CLASS_TOKEN}."
+  )
+
+  prompt_test_list=(
+    "a ${CLASS_TOKEN} in the jungle"
+    "a ${CLASS_TOKEN} in the snow"
+    "a ${CLASS_TOKEN} on the beach"
+    "a ${CLASS_TOKEN} on a cobblestone street"
+    "a ${CLASS_TOKEN} on top of pink fabric"
+    "a ${CLASS_TOKEN} on top of a wooden floor"
+    "a ${CLASS_TOKEN} with a city in the background"
+    "a ${CLASS_TOKEN} with a mountain in the background"
+    "a ${CLASS_TOKEN} with a blue house in the background"
+    "a ${CLASS_TOKEN} on top of a purple rug in a forest"
+    "a ${CLASS_TOKEN} with a wheat field in the background"
+    "a ${CLASS_TOKEN} with a tree and autumn leaves in the background"
+    "a ${CLASS_TOKEN} with the Eiffel Tower in the background"
+    "a ${CLASS_TOKEN} floating on top of water"
+    "a ${CLASS_TOKEN} floating in an ocean of milk"
+    "a ${CLASS_TOKEN} on top of green grass with sunflowers around it"
+    "a ${CLASS_TOKEN} on top of a mirror"
+    "a ${CLASS_TOKEN} on top of the sidewalk in a crowded street"
+    "a ${CLASS_TOKEN} on top of a dirt road"
+    "a ${CLASS_TOKEN} on top of a white rug"
+    "a red ${CLASS_TOKEN}"
+    "a purple ${CLASS_TOKEN}"
+    "a shiny ${CLASS_TOKEN}"
+    "a wet ${CLASS_TOKEN}"
+    "a cube shaped ${CLASS_TOKEN}"
+  )
+
+else
+  PROMPT_LIST=(
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in the jungle."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in the snow."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on the beach."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on a cobblestone street."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of pink fabric."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a wooden floor."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a city in the background."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a mountain in the background."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} with a blue house in the background."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} on top of a purple rug in a forest."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} wearing a red hat."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} wearing a santa hat."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} wearing a rainbow scarf."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} wearing a black top hat and a monocle."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in a chef outfit."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in a firefighter outfit."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in a police outfit."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} wearing pink glasses."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} wearing a yellow shirt."
+    "a ${UNIQUE_TOKEN} ${CLASS_TOKEN} in a purple wizard outfit."
+    "a red ${UNIQUE_TOKEN} ${CLASS_TOKEN}."
+    "a purple ${UNIQUE_TOKEN} ${CLASS_TOKEN}."
+    "a shiny ${UNIQUE_TOKEN} ${CLASS_TOKEN}."
+    "a wet ${UNIQUE_TOKEN} ${CLASS_TOKEN}."
+    "a cube shaped ${UNIQUE_TOKEN} ${CLASS_TOKEN}."
+  )
+
+  prompt_test_list=(
+    "a ${CLASS_TOKEN} in the jungle"
+    "a ${CLASS_TOKEN} in the snow"
+    "a ${CLASS_TOKEN} on the beach"
+    "a ${CLASS_TOKEN} on a cobblestone street"
+    "a ${CLASS_TOKEN} on top of pink fabric"
+    "a ${CLASS_TOKEN} on top of a wooden floor"
+    "a ${CLASS_TOKEN} with a city in the background"
+    "a ${CLASS_TOKEN} with a mountain in the background"
+    "a ${CLASS_TOKEN} with a blue house in the background"
+    "a ${CLASS_TOKEN} on top of a purple rug in a forest"
+    "a ${CLASS_TOKEN} wearing a red hat"
+    "a ${CLASS_TOKEN} wearing a santa hat"
+    "a ${CLASS_TOKEN} wearing a rainbow scarf"
+    "a ${CLASS_TOKEN} wearing a black top hat and a monocle"
+    "a ${CLASS_TOKEN} in a chef outfit"
+    "a ${CLASS_TOKEN} in a firefighter outfit"
+    "a ${CLASS_TOKEN} in a police outfit"
+    "a ${CLASS_TOKEN} wearing pink glasses"
+    "a ${CLASS_TOKEN} wearing a yellow shirt"
+    "a ${CLASS_TOKEN} in a purple wizard outfit"
+    "a red ${CLASS_TOKEN}"
+    "a purple ${CLASS_TOKEN}"
+    "a shiny ${CLASS_TOKEN}"
+    "a wet ${CLASS_TOKEN}"
+    "a cube shaped ${CLASS_TOKEN}"
+  )
+fi
+
+VALIDATION_PROMPT=${PROMPT_LIST[@]}
+INSTANCE_PROMPT="a photo of ${UNIQUE_TOKEN} ${CLASS_TOKEN}"
+CLASS_PROMPT="a photo of ${CLASS_TOKEN}"
+
+export MODEL_NAME="stabilityai/stable-diffusion-2-1"
+
+PEFT_TYPE="hra"
+HRA_R=8
+
+export PROJECT_NAME="dreambooth_${PEFT_TYPE}"
+export RUN_NAME="${SELECTED_SUBJECT}_${PEFT_TYPE}_${HRA_R}"
+export INSTANCE_DIR="./data/dreambooth/dataset/${SELECTED_SUBJECT}"
+export CLASS_DIR="./data/class_data/${CLASS_TOKEN}"
+export OUTPUT_DIR="./data/output/${PEFT_TYPE}"
+
+
+accelerate launch train_dreambooth.py \
+  --pretrained_model_name_or_path=$MODEL_NAME  \
+  --instance_data_dir=$INSTANCE_DIR \
+  --class_data_dir="$CLASS_DIR" \
+  --output_dir=$OUTPUT_DIR \
+  --project_name=$PROJECT_NAME \
+  --run_name=$RUN_NAME \
+  --with_prior_preservation \
+  --prior_loss_weight=1.0 \
+  --instance_prompt="$INSTANCE_PROMPT" \
+  --validation_prompt="$VALIDATION_PROMPT" \
+  --class_prompt="$CLASS_PROMPT" \
+  --resolution=512 \
+  --train_batch_size=1 \
+  --num_dataloader_workers=2 \
+  --lr_scheduler="constant" \
+  --lr_warmup_steps=0 \
+  --num_class_images=200 \
+  --use_hra \
+  --hra_r=$HRA_R \
+  --hra_bias="hra_only" \
+  --learning_rate=5e-3 \
+  --max_train_steps=510 \
+  --checkpointing_steps=200 \
+  --validation_steps=200 \
+  --enable_xformers_memory_efficient_attention \
+  --report_to="none" \
\ No newline at end of file
diff --git a/examples/hra_dreambooth/utils/__init__.py b/examples/hra_dreambooth/utils/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/examples/hra_dreambooth/utils/args_loader.py b/examples/hra_dreambooth/utils/args_loader.py
new file mode 100644
index 0000000..64e2307
--- /dev/null
+++ b/examples/hra_dreambooth/utils/args_loader.py
@@ -0,0 +1,377 @@
+# adapted from [peft's boft_dreambooth](https://github.com/huggingface/peft/tree/main/examples/boft_dreambooth)
+
+import argparse
+import os
+import warnings
+from typing import Optional
+
+from huggingface_hub import HfFolder, whoami
+from transformers import PretrainedConfig
+
+
+def import_model_class_from_model_name_or_path(pretrained_model_name_or_path: str, revision: str):
+    text_encoder_config = PretrainedConfig.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="text_encoder",
+        revision=revision,
+    )
+    model_class = text_encoder_config.architectures[0]
+
+    if model_class == "CLIPTextModel":
+        from transformers import CLIPTextModel
+
+        return CLIPTextModel
+    elif model_class == "RobertaSeriesModelWithTransformation":
+        from diffusers.pipelines.alt_diffusion.modeling_roberta_series import RobertaSeriesModelWithTransformation
+
+        return RobertaSeriesModelWithTransformation
+    else:
+        raise ValueError(f"{model_class} is not supported.")
+
+
+def get_full_repo_name(model_id: str, organization: Optional[str] = None, token: Optional[str] = None):
+    if token is None:
+        token = HfFolder.get_token()
+    if organization is None:
+        username = whoami(token)["name"]
+        return f"{username}/{model_id}"
+    else:
+        return f"{organization}/{model_id}"
+
+
+def parse_args(input_args=None):
+    parser = argparse.ArgumentParser(description="Simple example of a Dreambooth training script.")
+    parser.add_argument(
+        "--pretrained_model_name_or_path",
+        type=str,
+        default=None,
+        required=True,
+        help="Path to pretrained model or model identifier from huggingface.co/models.",
+    )
+    parser.add_argument(
+        "--revision",
+        type=str,
+        default=None,
+        required=False,
+        help="Revision of pretrained model identifier from huggingface.co/models.",
+    )
+    parser.add_argument(
+        "--tokenizer_name",
+        type=str,
+        default=None,
+        help="Pretrained tokenizer name or path if not the same as model_name",
+    )
+    parser.add_argument(
+        "--instance_data_dir",
+        type=str,
+        default=None,
+        required=True,
+        help="A folder containing the training data of instance images.",
+    )
+    parser.add_argument(
+        "--class_data_dir",
+        type=str,
+        default=None,
+        required=False,
+        help="A folder containing the training data of class images.",
+    )
+    parser.add_argument(
+        "--instance_prompt",
+        type=str,
+        default=None,
+        required=True,
+        help="The prompt with identifier specifying the instance",
+    )
+    parser.add_argument(
+        "--class_prompt",
+        type=str,
+        default=None,
+        help="The prompt to specify images in the same class as provided instance images.",
+    )
+    parser.add_argument(
+        "--with_prior_preservation",
+        default=False,
+        action="store_true",
+        help="Flag to add prior preservation loss.",
+    )
+    parser.add_argument("--prior_loss_weight", type=float, default=1.0, help="The weight of prior preservation loss.")
+    parser.add_argument(
+        "--num_class_images",
+        type=int,
+        default=100,
+        help=(
+            "Minimal class images for prior preservation loss. If there are not enough images already present in"
+            " class_data_dir, additional images will be sampled with class_prompt."
+        ),
+    )
+    parser.add_argument(
+        "--validation_prompt",
+        nargs="+",
+        help="A prompt that is used during validation to verify that the model is learning.",
+    )
+    parser.add_argument(
+        "--num_validation_images",
+        type=int,
+        default=4,
+        help="Number of images that should be generated during validation with `validation_prompt`.",
+    )
+    parser.add_argument(
+        "--validation_steps",
+        type=int,
+        default=500,
+        help=(
+            "Run dreambooth validation every X steps. Dreambooth validation consists of running the prompt"
+            " `args.validation_prompt` multiple times: `args.num_validation_images`."
+        ),
+    )
+    parser.add_argument(
+        "--output_dir",
+        type=str,
+        default="text-inversion-model",
+        help="The output directory where the model predictions and checkpoints will be written.",
+    )
+    parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.")
+    parser.add_argument(
+        "--resolution",
+        type=int,
+        default=512,
+        help=(
+            "The resolution for input images, all the images in the train/validation dataset will be resized to this"
+            " resolution"
+        ),
+    )
+    parser.add_argument(
+        "--center_crop", action="store_true", help="Whether to center crop images before resizing to resolution"
+    )
+    parser.add_argument("--train_text_encoder", action="store_true", help="Whether to train the text encoder")
+
+    parser.add_argument(
+        "--set_grads_to_none",
+        action="store_true",
+        help=(
+            "Save more memory by using setting grads to None instead of zero. Be aware, that this changes certain"
+            " behaviors, so disable this argument if it causes any problems. More info:"
+            " https://pytorch.org/docs/stable/generated/torch.optim.Optimizer.zero_grad.html"
+        ),
+    )
+
+    # hra args
+    parser.add_argument("--use_hra", action="store_true", help="Whether to use HRA for parameter efficient tuning.")
+    parser.add_argument("--hra_r", type=int, default=8, help="The rank of HRA across different layers.")
+    parser.add_argument(
+        "--hra_apply_GS", default=False, action="store_true", help="Whether to apply Gram-Schmidt orthogonalization."
+    )
+    parser.add_argument(
+        "--hra_bias",
+        type=str,
+        default="none",
+        help="Bias type for HRA. Can be 'none', 'all' or 'hra_only', only used if use_hra is True.",
+    )
+    parser.add_argument(
+        "--num_dataloader_workers", type=int, default=1, help="Num of workers for the training dataloader."
+    )
+    parser.add_argument(
+        "--no_tracemalloc",
+        default=False,
+        action="store_true",
+        help="Flag to stop memory allocation tracing during training. This could speed up training on Windows.",
+    )
+
+    parser.add_argument(
+        "--train_batch_size", type=int, default=4, help="Batch size (per device) for the training dataloader."
+    )
+    parser.add_argument(
+        "--sample_batch_size", type=int, default=4, help="Batch size (per device) for sampling images."
+    )
+    parser.add_argument("--num_train_epochs", type=int, default=1)
+    parser.add_argument(
+        "--max_train_steps",
+        type=int,
+        default=None,
+        help="Total number of training steps to perform.  If provided, overrides num_train_epochs.",
+    )
+    parser.add_argument(
+        "--checkpointing_steps",
+        type=int,
+        default=500,
+        help=(
+            "Save a checkpoint of the training state every X updates. These checkpoints can be used both as final"
+            " checkpoints in case they are better than the last checkpoint, and are also suitable for resuming"
+            " training using `--resume_from_checkpoint`."
+        ),
+    )
+    parser.add_argument(
+        "--resume_from_checkpoint",
+        type=str,
+        default=None,
+        help=(
+            "Whether training should be resumed from a previous checkpoint. Use a path saved by"
+            ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.'
+        ),
+    )
+    parser.add_argument(
+        "--gradient_accumulation_steps",
+        type=int,
+        default=1,
+        help="Number of updates steps to accumulate before performing a backward/update pass.",
+    )
+    parser.add_argument(
+        "--gradient_checkpointing",
+        action="store_true",
+        help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.",
+    )
+    parser.add_argument(
+        "--learning_rate",
+        type=float,
+        default=5e-6,
+        help="Initial learning rate (after the potential warmup period) to use.",
+    )
+    parser.add_argument(
+        "--scale_lr",
+        action="store_true",
+        default=False,
+        help="Scale the learning rate by the number of GPUs, gradient accumulation steps, and batch size.",
+    )
+    parser.add_argument(
+        "--lr_scheduler",
+        type=str,
+        default="constant",
+        help=(
+            'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",'
+            ' "constant", "constant_with_warmup"]'
+        ),
+    )
+    parser.add_argument(
+        "--lr_warmup_steps", type=int, default=500, help="Number of steps for the warmup in the lr scheduler."
+    )
+    parser.add_argument(
+        "--lr_num_cycles",
+        type=int,
+        default=1,
+        help="Number of hard resets of the lr in cosine_with_restarts scheduler.",
+    )
+    parser.add_argument("--lr_power", type=float, default=1.0, help="Power factor of the polynomial scheduler.")
+    parser.add_argument(
+        "--use_8bit_adam", action="store_true", help="Whether or not to use 8-bit Adam from bitsandbytes."
+    )
+    parser.add_argument("--adam_beta1", type=float, default=0.9, help="The beta1 parameter for the Adam optimizer.")
+    parser.add_argument("--adam_beta2", type=float, default=0.999, help="The beta2 parameter for the Adam optimizer.")
+    parser.add_argument("--adam_weight_decay", type=float, default=1e-2, help="Weight decay to use.")
+    parser.add_argument("--adam_epsilon", type=float, default=1e-08, help="Epsilon value for the Adam optimizer")
+    parser.add_argument("--max_grad_norm", default=1.0, type=float, help="Max gradient norm.")
+    parser.add_argument("--push_to_hub", action="store_true", help="Whether or not to push the model to the Hub.")
+    parser.add_argument("--hub_token", type=str, default=None, help="The token to use to push to the Model Hub.")
+    parser.add_argument(
+        "--hub_model_id",
+        type=str,
+        default=None,
+        help="The name of the repository to keep in sync with the local `output_dir`.",
+    )
+    parser.add_argument(
+        "--logging_dir",
+        type=str,
+        default="logs",
+        help=(
+            "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to"
+            " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***."
+        ),
+    )
+    parser.add_argument(
+        "--allow_tf32",
+        action="store_true",
+        help=(
+            "Whether or not to allow TF32 on Ampere GPUs. Can be used to speed up training. For more information, see"
+            " https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices"
+        ),
+    )
+    parser.add_argument(
+        "--project_name",
+        type=str,
+        default=None,
+        help=("The project name for log tracking"),
+    )
+    parser.add_argument(
+        "--run_name",
+        type=str,
+        default=None,
+        help=("The run name for log tracking"),
+    )
+    parser.add_argument(
+        "--report_to",
+        type=str,
+        default="wandb",
+        help=(
+            'The integration to report the results and logs to. Supported platforms are `"wandb"`'
+            ' (default), `"tensorboard"` and `"comet_ml"`. Use `"all"` to report to all integrations.'
+        ),
+    )
+    parser.add_argument(
+        "--wandb_key",
+        type=str,
+        default=None,
+        help=("If report to option is set to wandb, api-key for wandb used for login to wandb "),
+    )
+    parser.add_argument(
+        "--wandb_project_name",
+        type=str,
+        default=None,
+        help=("If report to option is set to wandb, project name in wandb for log tracking  "),
+    )
+    parser.add_argument(
+        "--wandb_run_name",
+        type=str,
+        default=None,
+        help=("If report to option is set to wandb, project name in wandb for log tracking  "),
+    )
+    parser.add_argument(
+        "--mixed_precision",
+        type=str,
+        default=None,
+        choices=["no", "fp16", "bf16"],
+        help=(
+            "Whether to use mixed precision. Choose between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >="
+            " 1.10.and an Nvidia Ampere GPU.  Default to the value of accelerate config of the current system or the"
+            " flag passed with the `accelerate.launch` command. Use this argument to override the accelerate config."
+        ),
+    )
+    parser.add_argument(
+        "--prior_generation_precision",
+        type=str,
+        default=None,
+        choices=["no", "fp32", "fp16", "bf16"],
+        help=(
+            "Choose prior generation precision between fp32, fp16 and bf16 (bfloat16). Bf16 requires PyTorch >="
+            " 1.10.and an Nvidia Ampere GPU.  Default to  fp16 if a GPU is available else fp32."
+        ),
+    )
+    parser.add_argument("--local_rank", type=int, default=-1, help="For distributed training: local_rank")
+    parser.add_argument(
+        "--enable_xformers_memory_efficient_attention", action="store_true", help="Whether or not to use xformers."
+    )
+
+    if input_args is not None:
+        args = parser.parse_args(input_args)
+    else:
+        args = parser.parse_args()
+
+    env_local_rank = int(os.environ.get("LOCAL_RANK", "-1"))
+    if env_local_rank != -1 and env_local_rank != args.local_rank:
+        args.local_rank = env_local_rank
+
+    # Sanity checks
+    # if args.dataset_name is None and args.train_data_dir is None:
+    #     raise ValueError("Need either a dataset name or a training folder.")
+
+    if args.with_prior_preservation:
+        if args.class_data_dir is None:
+            raise ValueError("You must specify a data directory for class images.")
+        if args.class_prompt is None:
+            raise ValueError("You must specify prompt for class images.")
+    else:
+        # logger is not available yet
+        if args.class_data_dir is not None:
+            warnings.warn("You need not use --class_data_dir without --with_prior_preservation.")
+        if args.class_prompt is not None:
+            warnings.warn("You need not use --class_prompt without --with_prior_preservation.")
+
+    return args
diff --git a/examples/hra_dreambooth/utils/dataset.py b/examples/hra_dreambooth/utils/dataset.py
new file mode 100644
index 0000000..eaf8c99
--- /dev/null
+++ b/examples/hra_dreambooth/utils/dataset.py
@@ -0,0 +1,128 @@
+# adapted from [peft's boft_dreambooth](https://github.com/huggingface/peft/tree/main/examples/boft_dreambooth)
+
+from pathlib import Path
+
+import torch
+from PIL import Image
+from torch.utils.data import Dataset
+from torchvision import transforms
+
+
+class DreamBoothDataset(Dataset):
+    """
+    A dataset to prepare the instance and class images with the prompts for fine-tuning the model.
+    It pre-processes the images and the tokenizes prompts.
+    """
+
+    def __init__(
+        self,
+        instance_data_root,
+        instance_prompt,
+        tokenizer,
+        class_data_root=None,
+        class_prompt=None,
+        size=512,
+        center_crop=False,
+    ):
+        self.size = size
+        self.center_crop = center_crop
+        self.tokenizer = tokenizer
+
+        self.instance_data_root = Path(instance_data_root)
+        if not self.instance_data_root.exists():
+            raise ValueError("Instance images root doesn't exists.")
+
+        self.instance_images_path = list(Path(instance_data_root).iterdir())
+        self.num_instance_images = len(self.instance_images_path)
+        self.instance_prompt = instance_prompt
+        self._length = self.num_instance_images
+
+        if class_data_root is not None:
+            self.class_data_root = Path(class_data_root)
+            self.class_data_root.mkdir(parents=True, exist_ok=True)
+            self.class_images_path = list(self.class_data_root.iterdir())
+            self.num_class_images = len(self.class_images_path)
+            self._length = max(self.num_class_images, self.num_instance_images)
+            self.class_prompt = class_prompt
+        else:
+            self.class_data_root = None
+
+        self.image_transforms = transforms.Compose(
+            [
+                transforms.Resize(size, interpolation=transforms.InterpolationMode.BILINEAR),
+                transforms.CenterCrop(size) if center_crop else transforms.RandomCrop(size),
+                transforms.ToTensor(),
+                transforms.Normalize([0.5], [0.5]),
+            ]
+        )
+
+    def __len__(self):
+        return self._length
+
+    def __getitem__(self, index):
+        example = {}
+        instance_image = Image.open(self.instance_images_path[index % self.num_instance_images])
+        if instance_image.mode != "RGB":
+            instance_image = instance_image.convert("RGB")
+        example["instance_images"] = self.image_transforms(instance_image)
+        example["instance_prompt_ids"] = self.tokenizer(
+            self.instance_prompt,
+            truncation=True,
+            padding="max_length",
+            max_length=self.tokenizer.model_max_length,
+            return_tensors="pt",
+        ).input_ids
+
+        if self.class_data_root:
+            class_image = Image.open(self.class_images_path[index % self.num_class_images])
+            if class_image.mode != "RGB":
+                class_image = class_image.convert("RGB")
+            example["class_images"] = self.image_transforms(class_image)
+            example["class_prompt_ids"] = self.tokenizer(
+                self.class_prompt,
+                truncation=True,
+                padding="max_length",
+                max_length=self.tokenizer.model_max_length,
+                return_tensors="pt",
+            ).input_ids
+
+        return example
+
+
+def collate_fn(examples, with_prior_preservation=False):
+    input_ids = [example["instance_prompt_ids"] for example in examples]
+    pixel_values = [example["instance_images"] for example in examples]
+
+    # Concat class and instance examples for prior preservation.
+    # We do this to avoid doing two forward passes.
+    if with_prior_preservation:
+        input_ids += [example["class_prompt_ids"] for example in examples]
+        pixel_values += [example["class_images"] for example in examples]
+
+    pixel_values = torch.stack(pixel_values)
+    pixel_values = pixel_values.to(memory_format=torch.contiguous_format).float()
+
+    input_ids = torch.cat(input_ids, dim=0)
+
+    batch = {
+        "input_ids": input_ids,
+        "pixel_values": pixel_values,
+    }
+    return batch
+
+
+class PromptDataset(Dataset):
+    "A simple dataset to prepare the prompts to generate class images on multiple GPUs."
+
+    def __init__(self, prompt, num_samples):
+        self.prompt = prompt
+        self.num_samples = num_samples
+
+    def __len__(self):
+        return self.num_samples
+
+    def __getitem__(self, index):
+        example = {}
+        example["prompt"] = self.prompt
+        example["index"] = index
+        return example
diff --git a/examples/hra_dreambooth/utils/tracemalloc.py b/examples/hra_dreambooth/utils/tracemalloc.py
new file mode 100644
index 0000000..c47ef31
--- /dev/null
+++ b/examples/hra_dreambooth/utils/tracemalloc.py
@@ -0,0 +1,62 @@
+# adapted from [peft's boft_dreambooth](https://github.com/huggingface/peft/tree/main/examples/boft_dreambooth)
+
+import gc
+import threading
+
+import psutil
+import torch
+
+
+# Converting Bytes to Megabytes
+def b2mb(x):
+    return int(x / 2**20)
+
+
+# This context manager is used to track the peak memory usage of the process
+class TorchTracemalloc:
+    def __enter__(self):
+        self.device_type = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+        self.device_module = getattr(torch, self.device_type, torch.cuda)
+        gc.collect()
+        self.device_module.empty_cache()
+        self.device_module.reset_peak_memory_stats()  # reset the peak gauge to zero
+        self.begin = self.device_module.memory_allocated()
+        self.process = psutil.Process()
+
+        self.cpu_begin = self.cpu_mem_used()
+        self.peak_monitoring = True
+        peak_monitor_thread = threading.Thread(target=self.peak_monitor_func)
+        peak_monitor_thread.daemon = True
+        peak_monitor_thread.start()
+        return self
+
+    def cpu_mem_used(self):
+        """get resident set size memory for the current process"""
+        return self.process.memory_info().rss
+
+    def peak_monitor_func(self):
+        self.cpu_peak = -1
+
+        while True:
+            self.cpu_peak = max(self.cpu_mem_used(), self.cpu_peak)
+
+            # can't sleep or will not catch the peak right (this comment is here on purpose)
+            # time.sleep(0.001) # 1msec
+
+            if not self.peak_monitoring:
+                break
+
+    def __exit__(self, *exc):
+        self.peak_monitoring = False
+
+        gc.collect()
+        self.device_module.empty_cache()
+        self.end = self.device_module.memory_allocated()
+        self.peak = self.device_module.max_memory_allocated()
+        self.used = b2mb(self.end - self.begin)
+        self.peaked = b2mb(self.peak - self.begin)
+
+        self.cpu_end = self.cpu_mem_used()
+        self.cpu_used = b2mb(self.cpu_end - self.cpu_begin)
+        self.cpu_peaked = b2mb(self.cpu_peak - self.cpu_begin)
+        # print(f"delta used/peak {self.used:4d}/{self.peaked:4d}")
diff --git a/examples/image_classification/README.md b/examples/image_classification/README.md
new file mode 100644
index 0000000..3ebc5e0
--- /dev/null
+++ b/examples/image_classification/README.md
@@ -0,0 +1,15 @@
+# Fine-tuning for image classification using LoRA and 🤗 PEFT
+
+## Vision Transformer model from transformers
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/huggingface/peft/blob/main/examples/image_classification/image_classification_peft_lora.ipynb) 
+
+We provide a notebook (`image_classification_peft_lora.ipynb`) where we learn how to use [LoRA](https://huggingface.co/papers/2106.09685) from 🤗 PEFT to fine-tune an image classification model by ONLY using **0.7%** of the original trainable parameters of the model. 
+
+LoRA adds low-rank "update matrices" to certain blocks in the underlying model (in this case the attention blocks) and ONLY trains those matrices during fine-tuning. During inference, these update matrices are _merged_ with the original model parameters. For more details, check out the [original LoRA paper](https://huggingface.co/papers/2106.09685). 
+
+## PoolFormer model from timm
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/huggingface/peft/blob/main/examples/image_classification/image_classification_timm_peft_lora.ipynb) 
+
+The notebook `image_classification_timm_peft_lora.ipynb` showcases fine-tuning an image classification model using from the [timm](https://huggingface.co/docs/timm/index) library. Again, LoRA is used to reduce the numberof trainable parameters to a fraction of the total.
diff --git a/examples/image_classification/image_classification_peft_lora.ipynb b/examples/image_classification/image_classification_peft_lora.ipynb
new file mode 100644
index 0000000..02e97d9
--- /dev/null
+++ b/examples/image_classification/image_classification_peft_lora.ipynb
@@ -0,0 +1,14951 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "71GTxOD71mEn"
+   },
+   "source": [
+    "## Introduction\n",
+    "\n",
+    "In this notebook, we will learn how to use [LoRA](https://huggingface.co/papers/2106.09685) from 🤗 PEFT to fine-tune an image classification model by ONLY using **0.77%** of the original trainable parameters of the model. \n",
+    "\n",
+    "LoRA adds low-rank \"update matrices\" to certain blocks in the underlying model (in this case the attention blocks) and ONLY trains those matrices during fine-tuning. During inference, these update matrices are _merged_ with the original model parameters. For more details, check out the [original LoRA paper](https://huggingface.co/papers/2106.09685). \n",
+    "\n",
+    "Let's get started by installing the dependencies. \n",
+    "\n",
+    "__*Note that this notebook builds on top the [official image classification example notebook](https://github.com/huggingface/notebooks/blob/main/examples/image_classification.ipynb).*__"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "0a_bETbqv4P7"
+   },
+   "source": [
+    "## Install dependencies\n",
+    "\n",
+    "Here we're installing `peft` from source to ensure we have access to all the bleeding edge features of `peft`. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "Z0_5BYt8hobv",
+    "outputId": "aafcbc39-b972-493a-8922-2141b1621926"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n",
+      "  Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n",
+      "  Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.3/6.3 MB\u001b[0m \u001b[31m53.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m199.7/199.7 KB\u001b[0m \u001b[31m24.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m81.4/81.4 KB\u001b[0m \u001b[31m11.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m462.8/462.8 KB\u001b[0m \u001b[31m46.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m190.3/190.3 KB\u001b[0m \u001b[31m23.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m7.6/7.6 MB\u001b[0m \u001b[31m102.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m213.0/213.0 KB\u001b[0m \u001b[31m25.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m132.0/132.0 KB\u001b[0m \u001b[31m15.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m76.3/76.3 MB\u001b[0m \u001b[31m23.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m140.6/140.6 KB\u001b[0m \u001b[31m20.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25h  Building wheel for peft (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n"
+     ]
+    }
+   ],
+   "source": [
+    "!pip install transformers accelerate evaluate datasets git+https://github.com/huggingface/peft -q"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Y8dSVHoIv7HC"
+   },
+   "source": [
+    "## Authentication\n",
+    "\n",
+    "We will share our fine-tuned model at the end of training. So, to do that we just authenticate using our 🤗 token. This token is available from [here](https://huggingface.co/settings/tokens). If you don't have a 🤗 account already, we highly encourage you to do so; it's free!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 359,
+     "referenced_widgets": [
+      "5d2f5fb454bc4c16b520e4e96381758f",
+      "dfd2baceac524fe29c0f4a8443b60a71",
+      "90d8e83a6af54184a82e0b81ae7054b9",
+      "1f96ca356b6f41b59275abe93df33f43",
+      "eef81e9bea0c4f5d85e7efa8ebe0463a",
+      "cab6d36980c0423fb75299c09c33facc",
+      "dd38a658218d42d7b051c66de4d4180a",
+      "f34be236ef9c42448ecf2957160990f7",
+      "38deee504dab482983a8b8f340472282",
+      "b2688e34899a449e8d1f6ddb5a66bb85",
+      "dd4edb4de5e14dfbbee418dba0bb3573",
+      "516c6d75bc654d62b95ac235ce84c59c",
+      "14c23f636609458ca4493854826c1a8e",
+      "c778798c234d45b5a4ae2f250e3706f9",
+      "d5c5396ea2f54ff0aeb9be58b59c253b",
+      "15bd2dcdbf4b4e74b9db09bdb8822e61",
+      "ecf73dd75420460399bfd04d8cd81f90"
+     ]
+    },
+    "id": "31Zv6rFYr37d",
+    "outputId": "6476ebcf-6d71-4b7d-ee38-dc4f8e8d024e"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Token is valid.\n",
+      "Your token has been saved in your configured git credential helpers (store).\n",
+      "Your token has been saved to /root/.cache/huggingface/token\n",
+      "Login successful\n"
+     ]
+    }
+   ],
+   "source": [
+    "from huggingface_hub import notebook_login\n",
+    "\n",
+    "notebook_login()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "AX7aJaIKjbCF"
+   },
+   "source": [
+    "## Check the library versions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "ejkn8GBzh_DB",
+    "outputId": "777afbdf-e026-43d8-8efa-80bb958d0ca3"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "===================================BUG REPORT===================================\n",
+      "Welcome to bitsandbytes. For bug reports, please submit your error trace to: https://github.com/TimDettmers/bitsandbytes/issues\n",
+      "================================================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "import transformers\n",
+    "import accelerate\n",
+    "import peft"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "A833xxo3ir28",
+    "outputId": "da71ef1c-b6d7-43e2-a78b-23556785ef02"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Transformers version: 4.26.0\n",
+      "Accelerate version: 0.16.0\n",
+      "PEFT version: 0.1.0.dev0\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"Transformers version: {transformers.__version__}\")\n",
+    "print(f\"Accelerate version: {accelerate.__version__}\")\n",
+    "print(f\"PEFT version: {peft.__version__}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Po1Ve9u5v_Ul"
+   },
+   "source": [
+    "## Select a model checkpoint to fine-tune"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "id": "vhvCQpP-isJr"
+   },
+   "outputs": [],
+   "source": [
+    "model_checkpoint = \"google/vit-base-patch16-224-in21k\"  # pre-trained model from which to fine-tune"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "UKN3rMAsjgEz"
+   },
+   "source": [
+    "## Load a dataset\n",
+    "\n",
+    "We're only loading the first 5000 instances from the training set of the [Food-101 dataset](https://huggingface.co/datasets/food101) to keep this example runtime short. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 379,
+     "referenced_widgets": [
+      "61b957d3b51643f78a921979072fe3b6",
+      "d7136a7b3d0040d580508fc665b9fb00",
+      "5ee5e11191fc46dd92d4c2f1a7d6d9da",
+      "3587d42fa09b4fcdb365956a9bb07c77",
+      "c1ed0b68884c4d4291cd67c0e685ef18",
+      "9102cc38ee9942ac91dc66eda069ddcb",
+      "416c65eedcea4a6ea69dae317de79bca",
+      "128677e1b5b14e63b06b0f81c9cc4df0",
+      "22da54e68b1d48f9b3ba55ac1ca56873",
+      "16c7db587b8e475fa3aa9677385b092a",
+      "23c608994006427caca7975e0d81271f",
+      "71f7296ec9be4d9abe1af581722b40fe",
+      "b98e53eefc1944f193169c4f7a72b799",
+      "1d4a5a5b7d1645a8bf8133935e173082",
+      "d29e3b9102f14f3385e47ae6e27d1ab1",
+      "1e3e374b08964a689cfaac9c826f207b",
+      "b377e94780fb4e1db3b9678717e04fc1",
+      "86103f87819b440b8464f4460f50375e",
+      "c3178221dc074657bc0e585c4cfe326d",
+      "3c6842e0158b4dcc9b93eddfe3279d2a",
+      "fc612aaed5644b84959a1958b0240dda",
+      "36c8300bcbb84627a03b94f0eea86ce9",
+      "f0b0cad40fbd461ca7bdcdbb5f442f57",
+      "76cf84387a7c43608ad018188eef4114",
+      "68ef0c8550ee4c00aa8b284d48572610",
+      "58e7f5c36d8b4836a868ce89838f1896",
+      "9b216287b8694bcc9960a356adf15504",
+      "4d653faaedcd497d863bbf2c429ce925",
+      "d10f2e9c25f2417f9728aa8e43acf677",
+      "7a35d0ddc2da4dd69068214b87bcdd7f",
+      "9aac38a8c8694c67a34b2fced0e1a706",
+      "9d1dff20634a403fb8829469d74301aa",
+      "b2e64f35be2d4fa3bc95c769b78e1dd1",
+      "fdf282b234fe4a1a8ab452ac04511b7d",
+      "59792e1ee7074f998d5d4494c09061c6",
+      "cd5b2433cc404ac7b1bb35c6a55f6874",
+      "7c1b6f271fff4d60be39d291c73bfb75",
+      "074f38bd3a9d49719188e8860fb1b5d3",
+      "3ff84efe0edc491c884898424be4ae71",
+      "5a79a196fd7b49128a9647347f85b364",
+      "851fb5ac25db4bb287a6dbe948278eec",
+      "471d44c8e49e42b89302ef53ab0eb316",
+      "4089323832d04dc2a40e238b5fa256cc",
+      "2d867c65533e482a96db93bc5a09b8cb",
+      "849ac914c3cc49d29d619dd4f532d74c",
+      "4cb3d75f80434b48beb6aa4b07c86dfe",
+      "ff39519704b64e68b69ec06aea02791e",
+      "e0f2599ed04c424f896e503630034e84",
+      "1674d568877048368c842c21ffaac811",
+      "0957e36be17c43fd89462c5d5ddcec1b",
+      "dffe636233c84dcd9d75f34baf40fa1d",
+      "dcefc9ba538e4da2b75f9372a4c5b5bf",
+      "77df794cb4e4491e80ee20bbd2801a89",
+      "7e243f4a30c645b080e688fb706b4548",
+      "db6b68a237cf4e93ae6383448b773e47",
+      "c580d3a6e99e48fab09b3ce799711802",
+      "4afba780d0f244548a7f28db15b41dc9",
+      "4e3d482feec9485590d277dfc1d0b3d3",
+      "23436ea247dd43d8829ca143a49637c5",
+      "9609eaf0792345b2ab457cb7188ee14a",
+      "1839e4ed1d3c4975b34c3c050052693f",
+      "1b31bfb0ef4c404698eb2205414170af",
+      "6350637718344d65a757d2919de8c1ab",
+      "42a16474e41343b2a7d46e5930b41b89",
+      "ce16ac2b3ff244e6bd7dd58daa9f4f7f",
+      "d25f3ebb577749d89e2e6d2a72f6ca5f",
+      "13279e67c4d847e4846e2d34e8aac589",
+      "d7d43177c750412cb1522eb08c01d2d9",
+      "70b04a3579a5446f94acd422c70ac50a",
+      "43940212a87d410c82cc9cd15f38a97e",
+      "19fd7c60287b43bbb6e0b12c25b4b375",
+      "9013fd35e17f44bfb7a068833adaf167",
+      "a849dcc9c7f742d49c874597d8c693c5",
+      "039dd9a4b99e433088a0acd8ba7b519b",
+      "17235d013b7c4cee996d0bbc1cc6c70c",
+      "3db63ba25e7349a785244c367d53813e",
+      "4748461200ae4af883577e2fbb8cb686",
+      "19ec79f5a5174aa3b26861a9662951d3",
+      "57c15c64c2374f06a1e0a36bab953ef7",
+      "06cf9f29b929412a8092044e25861f1c",
+      "c2032e5054ac4604832957cb6e2e69ca",
+      "d1ff50e1b871429a85df8cf10e73ffb1",
+      "10c4f5677d1c4af8b3370b7fb1255065",
+      "603dd1541db345879295edc16ace2b0c",
+      "375ac7a15cea4ce3aa484a806cc82717",
+      "6b6459f123ef4f24a550cd9ec3c9f809",
+      "e3047557ae7f40e2aecccf1afad36f3f",
+      "4fc212af0c9b45ebbe334e3dd7f11b59",
+      "fee4fba960ac41ed97984467da41f319",
+      "ee103846621b4c0e8e1266599b99f6ee",
+      "dcd1c1f4fc014c4aa9ebdaf3c533a061",
+      "a29d758fb7f147c7ad1108f140caf23a",
+      "cb52fa97c659430a8bd71dcd76245a7f",
+      "e7144551e74b46529b00a61f580a183d",
+      "9b1bfa11ee3746c38155c4505abfaa86",
+      "26520bc6555d41d9951ea0219dc4b5d7",
+      "60472b5a360f43e89e39d641dabba57b",
+      "aa9b6ac2785c4a5abd1189edd60698eb",
+      "cfab815edc1f42898b656c0f4a3b366b",
+      "c5718d031b9942f4b8bf331a8543db29",
+      "35d862a4f00c4493920da3e2eb92b043",
+      "16b464f168d844cba5eb0c91ab4fb91c",
+      "af5231ecf6e2489b80cdcd435b5e3451",
+      "62a0f83cf75d4c59a0601c5ad3a817a7",
+      "b48f685dc91540f38690f39eace724d5",
+      "ce4b6a4b6fec4ceb907fa436ff940bd2",
+      "28f82c8fc9cf46c7858132a77e45834b",
+      "ce18faf7b68140a3a8247330b356e05b",
+      "af6a4a054a5d451b9fe256bf60a09c21",
+      "afb1f0681bce47e1ba718900d0430f34"
+     ]
+    },
+    "id": "rI0d2_liitUr",
+    "outputId": "4ae986eb-6cbb-4d9f-bb99-1ffbb05ee835"
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "61b957d3b51643f78a921979072fe3b6",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading builder script:   0%|          | 0.00/6.21k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "71f7296ec9be4d9abe1af581722b40fe",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading metadata:   0%|          | 0.00/5.56k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f0b0cad40fbd461ca7bdcdbb5f442f57",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading readme:   0%|          | 0.00/10.3k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Downloading and preparing dataset food101/default to /root/.cache/huggingface/datasets/food101/default/0.0.0/7cebe41a80fb2da3f08fcbef769c8874073a86346f7fb96dc0847d4dfc318295...\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "fdf282b234fe4a1a8ab452ac04511b7d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading data:   0%|          | 0.00/5.00G [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:datasets.download.download_manager:Computing checksums of downloaded files. They can be used for integrity verification. You can disable this by passing ignore_verifications=True to load_dataset\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "849ac914c3cc49d29d619dd4f532d74c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Computing checksums: 100%|##########| 1/1 [00:14<00:00, 14.25s/it]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c580d3a6e99e48fab09b3ce799711802",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading data files:   0%|          | 0/2 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "13279e67c4d847e4846e2d34e8aac589",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading data:   0%|          | 0.00/1.47M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "19ec79f5a5174aa3b26861a9662951d3",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading data:   0%|          | 0.00/489k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "fee4fba960ac41ed97984467da41f319",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Generating train split:   0%|          | 0/75750 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c5718d031b9942f4b8bf331a8543db29",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Generating validation split:   0%|          | 0/25250 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dataset food101 downloaded and prepared to /root/.cache/huggingface/datasets/food101/default/0.0.0/7cebe41a80fb2da3f08fcbef769c8874073a86346f7fb96dc0847d4dfc318295. Subsequent calls will reuse this data.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from datasets import load_dataset\n",
+    "\n",
+    "dataset = load_dataset(\"food101\", split=\"train[:5000]\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "pUjwa7G8jjgW"
+   },
+   "source": [
+    "## Prepare datasets for training and evaluation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "-Gg9xDW22yPD"
+   },
+   "source": [
+    "1. Prepare `label2id` and `id2label` dictionaries. This will come in handy when performing inference and for metadata information. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 35
+    },
+    "id": "GC3wK2aciz53",
+    "outputId": "4b065fdc-6d89-46a2-88b5-b78c2d843036"
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.google.colaboratory.intrinsic+json": {
+       "type": "string"
+      },
+      "text/plain": [
+       "'baklava'"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "labels = dataset.features[\"label\"].names\n",
+    "label2id, id2label = dict(), dict()\n",
+    "for i, label in enumerate(labels):\n",
+    "    label2id[label] = i\n",
+    "    id2label[i] = label\n",
+    "\n",
+    "id2label[2]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "xgHUxR_-2-h1"
+   },
+   "source": [
+    "2. We load the image processor of the model we're fine-tuning."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 474,
+     "referenced_widgets": [
+      "9d1b9ac29dcc41e08ada578916f20a3c",
+      "ef7c7fe37c8d459da6d20f4ccbea3fb8",
+      "93c81a011c0a435aa90a3f4f1d549510",
+      "da87efdf06d74b0aba268320ba7882f9",
+      "0a0e75829d6c4031bc917ac2044d9e47",
+      "4ee1fde44dcf49eda97e1a05173e5bb1",
+      "a0929e66406644dbb09bbdc9c58d488d",
+      "bcbb4d8ce16b473eae2ad03f1bea2520",
+      "2c86eb6c67f44af590937d0f1db09333",
+      "a100435005a34d428b9ae615f49bb1a1",
+      "8886c333aa104900a3bb4a1904756661",
+      "bb453686ce9f4342aaae9a9fb3500d2c",
+      "1a4ab138be9940f081514b914fdc4623",
+      "cc59f6643acb4054ad6df56e90d3d2a8",
+      "236638d673934823828ee57face78184",
+      "29de968ad50543418c6865fdf003a568",
+      "8b9f5bca0898404b91032befbd019fa3",
+      "e4694cffcb574863a255e9022c8ddf5d",
+      "8a0a77b9ebd74caabb8f8a764c289a5c",
+      "d8ac6df8420a423eb048b4db04c8925c",
+      "920293e203f14b45b61233e1bb6f1214",
+      "a1981bfcdb6d401e9a521e18b511cf9d"
+     ]
+    },
+    "id": "3hmq4a_fi2IX",
+    "outputId": "f790d034-9efa-4a1a-e9f5-f3c6bd62add5"
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "9d1b9ac29dcc41e08ada578916f20a3c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading (…)rocessor_config.json:   0%|          | 0.00/160 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "bb453686ce9f4342aaae9a9fb3500d2c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading (…)lve/main/config.json:   0%|          | 0.00/502 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "ViTImageProcessor {\n",
+       "  \"do_normalize\": true,\n",
+       "  \"do_rescale\": true,\n",
+       "  \"do_resize\": true,\n",
+       "  \"image_mean\": [\n",
+       "    0.5,\n",
+       "    0.5,\n",
+       "    0.5\n",
+       "  ],\n",
+       "  \"image_processor_type\": \"ViTImageProcessor\",\n",
+       "  \"image_std\": [\n",
+       "    0.5,\n",
+       "    0.5,\n",
+       "    0.5\n",
+       "  ],\n",
+       "  \"resample\": 2,\n",
+       "  \"rescale_factor\": 0.00392156862745098,\n",
+       "  \"size\": {\n",
+       "    \"height\": 224,\n",
+       "    \"width\": 224\n",
+       "  }\n",
+       "}"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from transformers import AutoImageProcessor\n",
+    "\n",
+    "image_processor = AutoImageProcessor.from_pretrained(model_checkpoint)\n",
+    "image_processor"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "EsZYbWKS3cPK"
+   },
+   "source": [
+    "As one might notice, the `image_processor` has useful information on which size the training and evaluation images should be resized, stats that should be used to normalize the pixel values, etc. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "jKFuKh9P3E-e"
+   },
+   "source": [
+    "3. Using the image processor we prepare transformation functions for the datasets. These functions will include augmentation and pixel scaling.  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "id": "Zj33iIoCi3Uy"
+   },
+   "outputs": [],
+   "source": [
+    "from torchvision.transforms import (\n",
+    "    CenterCrop,\n",
+    "    Compose,\n",
+    "    Normalize,\n",
+    "    RandomHorizontalFlip,\n",
+    "    RandomResizedCrop,\n",
+    "    Resize,\n",
+    "    ToTensor,\n",
+    ")\n",
+    "\n",
+    "normalize = Normalize(mean=image_processor.image_mean, std=image_processor.image_std)\n",
+    "train_transforms = Compose(\n",
+    "    [\n",
+    "        RandomResizedCrop(image_processor.size[\"height\"]),\n",
+    "        RandomHorizontalFlip(),\n",
+    "        ToTensor(),\n",
+    "        normalize,\n",
+    "    ]\n",
+    ")\n",
+    "\n",
+    "val_transforms = Compose(\n",
+    "    [\n",
+    "        Resize(image_processor.size[\"height\"]),\n",
+    "        CenterCrop(image_processor.size[\"height\"]),\n",
+    "        ToTensor(),\n",
+    "        normalize,\n",
+    "    ]\n",
+    ")\n",
+    "\n",
+    "\n",
+    "def preprocess_train(example_batch):\n",
+    "    \"\"\"Apply train_transforms across a batch.\"\"\"\n",
+    "    example_batch[\"pixel_values\"] = [train_transforms(image.convert(\"RGB\")) for image in example_batch[\"image\"]]\n",
+    "    return example_batch\n",
+    "\n",
+    "\n",
+    "def preprocess_val(example_batch):\n",
+    "    \"\"\"Apply val_transforms across a batch.\"\"\"\n",
+    "    example_batch[\"pixel_values\"] = [val_transforms(image.convert(\"RGB\")) for image in example_batch[\"image\"]]\n",
+    "    return example_batch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "X4IPqOeK3UKW"
+   },
+   "source": [
+    "4. We split our mini dataset into training and validation. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "id": "_uplVC66i5Gd"
+   },
+   "outputs": [],
+   "source": [
+    "# split up training into training + validation\n",
+    "splits = dataset.train_test_split(test_size=0.1)\n",
+    "train_ds = splits[\"train\"]\n",
+    "val_ds = splits[\"test\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "KV5Mlf4e3X5K"
+   },
+   "source": [
+    "5. We set the transformation functions to the datasets accordingly. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "id": "0QuiqyiXi9fN"
+   },
+   "outputs": [],
+   "source": [
+    "train_ds.set_transform(preprocess_train)\n",
+    "val_ds.set_transform(preprocess_val)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "sA1Cq97Ijpp8"
+   },
+   "source": [
+    "## Load and prepare a model \n",
+    "\n",
+    "In this section, we first load the model we want to fine-tune. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "id": "Zxgrg45Xty2S"
+   },
+   "outputs": [],
+   "source": [
+    "def print_trainable_parameters(model):\n",
+    "    \"\"\"\n",
+    "    Prints the number of trainable parameters in the model.\n",
+    "    \"\"\"\n",
+    "    trainable_params = 0\n",
+    "    all_param = 0\n",
+    "    for _, param in model.named_parameters():\n",
+    "        all_param += param.numel()\n",
+    "        if param.requires_grad:\n",
+    "            trainable_params += param.numel()\n",
+    "    print(\n",
+    "        f\"trainable params: {trainable_params} || all params: {all_param} || trainable%: {100 * trainable_params / all_param:.2f}\"\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "TYjC-A-44bHO"
+   },
+   "source": [
+    "The `get_peft_model()` method that we will use in a moment wraps the original model to be fine-tuned as a `PeftModel`. So, it's important for us to initialize the original model correctly. As such, we initialize it by specifying the `label2id` and `id2label` so that `AutoModelForImageClassification` can initialize a append classification head to the underlying model, adapted for our dataset. We can confirm this from the warning below:\n",
+    "\n",
+    "```\n",
+    "Some weights of ViTForImageClassification were not initialized from the model checkpoint at google/vit-base-patch16-224-in21k and are newly initialized: ['classifier.weight', 'classifier.bias']\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 176,
+     "referenced_widgets": [
+      "9397ebc3ad2e4141a1405bb1bd0aa315",
+      "6f19448725b84be4bacc3b699cd065a9",
+      "864b6bb42f0b46a2a7bcd0d8cbac3837",
+      "5634fd283a9e45d9a55c02ca1b7c784c",
+      "87aad727ec964c9d97346ac02ed0caae",
+      "3c33964c8d804600ab5a26d0717c508d",
+      "f5041033ddf94f459ed8d1747f6b2d6e",
+      "c1af5e6c4259480eac652f6c6269ff5f",
+      "194dd0bcc350480c9ddd3e4ef17efc3a",
+      "4a44332ff1224a19a5f1c18e2b827759",
+      "7e1ac6f28fb340d3bde1e7b4893bb0aa"
+     ]
+    },
+    "id": "3J5DokIqi-wV",
+    "outputId": "66275479-0491-4db1-c265-333609b2dde2"
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "9397ebc3ad2e4141a1405bb1bd0aa315",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading (…)\"pytorch_model.bin\";:   0%|          | 0.00/346M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Some weights of the model checkpoint at google/vit-base-patch16-224-in21k were not used when initializing ViTForImageClassification: ['pooler.dense.weight', 'pooler.dense.bias']\n",
+      "- This IS expected if you are initializing ViTForImageClassification from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
+      "- This IS NOT expected if you are initializing ViTForImageClassification from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
+      "Some weights of ViTForImageClassification were not initialized from the model checkpoint at google/vit-base-patch16-224-in21k and are newly initialized: ['classifier.bias', 'classifier.weight']\n",
+      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "trainable params: 85876325 || all params: 85876325 || trainable%: 100.00\n"
+     ]
+    }
+   ],
+   "source": [
+    "from transformers import AutoModelForImageClassification, TrainingArguments, Trainer\n",
+    "\n",
+    "model = AutoModelForImageClassification.from_pretrained(\n",
+    "    model_checkpoint,\n",
+    "    label2id=label2id,\n",
+    "    id2label=id2label,\n",
+    "    ignore_mismatched_sizes=True,  # provide this in case you're planning to fine-tune an already fine-tuned checkpoint\n",
+    ")\n",
+    "print_trainable_parameters(model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "1EqYCiTy5F9N"
+   },
+   "source": [
+    "Also, take note of the number of total trainable parameters of `model`: it's 100%! We'll compare this number to that of the LoRA model.\n",
+    "\n",
+    "We now use the `PeftModel` to wrap `model` so that the \"update\" matrices are added to the respective places. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "LNASJrqoi_8-",
+    "outputId": "8088d2a6-b6fb-4ecc-f7c3-8f0797f4f6ff"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "trainable params: 667493 || all params: 86466149 || trainable%: 0.77\n"
+     ]
+    }
+   ],
+   "source": [
+    "from peft import LoraConfig, get_peft_model\n",
+    "\n",
+    "config = LoraConfig(\n",
+    "    r=16,\n",
+    "    lora_alpha=16,\n",
+    "    target_modules=[\"query\", \"value\"],\n",
+    "    lora_dropout=0.1,\n",
+    "    bias=\"none\",\n",
+    "    modules_to_save=[\"classifier\"],\n",
+    ")\n",
+    "lora_model = get_peft_model(model, config)\n",
+    "print_trainable_parameters(lora_model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "OKQeuUDhjC3E"
+   },
+   "source": [
+    "Let's unpack what's going on here. \n",
+    "\n",
+    "In order for LoRA to take effect, we need to specify the target modules to `LoraConfig` so that `get_peft_model()` knows which modules inside our model needs to be amended with LoRA matrices. In this case, we're only interested in targetting the query and value matrices of the attention blocks of the base model. Since the parameters corresponding to these matrices are \"named\" with `query` and `value` respectively, we specify them accordingly in the `target_modules` argument of `LoraConfig`. \n",
+    "\n",
+    "We also specify `modules_to_save`. After we wrap our base model `model` with `get_peft_model()` along with the `config`, we get a new model where only the LoRA parameters are trainable (so-called \"update matrices\") while the pre-trained parameters are kept frozen. These include the parameters of the randomly initialized classifier parameters too. This is NOT we want when fine-tuning the base model on our custom dataset. To ensure that the classifier parameters are also trained, we specify `modules_to_save`. This also ensures that these modules are serialized alongside the LoRA trainable parameters when using utilities like `save_pretrained()` and `push_to_hub()`.  \n",
+    "\n",
+    "Regarding the other parameters:\n",
+    "\n",
+    "* `r`: The dimension used by the LoRA update matrices.\n",
+    "* `alpha`: Scaling factor.\n",
+    "* `bias`: Specifying if the `bias` parameters should be trained. `None` denotes none of the `bias` parameters will be trained. \n",
+    "\n",
+    "`r` and `alpha` together control the total number of final trainable parameters when using LoRA giving us the flexbility to balance a trade-off between end performance and compute efficiency.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "mRbdQvEujHHP"
+   },
+   "source": [
+    "We can also how many parameters we're actually training. Since we're interested in performing **parameter-efficient fine-tuning**, we should expect to notice a less number of trainable parameters from the `lora_model` in comparison to the original `model` which is indeed the case here. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "m6lBFL_D-w7k"
+   },
+   "source": [
+    "## Training arguments\n",
+    "\n",
+    "We will leverage [🤗 Trainer](https://huggingface.co/docs/transformers/main_classes/trainer) for fine-tuning. It accepts several arguments which we wrap using [`TrainingArguments`](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "id": "-iD2F33JjIzC"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import TrainingArguments, Trainer\n",
+    "\n",
+    "\n",
+    "model_name = model_checkpoint.split(\"/\")[-1]\n",
+    "batch_size = 128\n",
+    "\n",
+    "args = TrainingArguments(\n",
+    "    f\"{model_name}-finetuned-lora-food101\",\n",
+    "    remove_unused_columns=False,\n",
+    "    eval_strategy=\"epoch\",\n",
+    "    save_strategy=\"epoch\",\n",
+    "    learning_rate=5e-3,\n",
+    "    per_device_train_batch_size=batch_size,\n",
+    "    gradient_accumulation_steps=4,\n",
+    "    per_device_eval_batch_size=batch_size,\n",
+    "    fp16=True,\n",
+    "    num_train_epochs=5,\n",
+    "    logging_steps=10,\n",
+    "    load_best_model_at_end=True,\n",
+    "    metric_for_best_model=\"accuracy\",\n",
+    "    push_to_hub=True,\n",
+    "    label_names=[\"labels\"],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "7_SA1HcVAUNP"
+   },
+   "source": [
+    "Some things to note here:\n",
+    "\n",
+    "* We're using a larger batch size since there is only a handful of parameters to train. \n",
+    "* Larger learning rate than the normal (1e-5 for example). \n",
+    "\n",
+    "All of these things are a byproduct of the fact that we're training only a small number of parameters. This can potentially also reduce the need to conduct expensive hyperparameter tuning experiments. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "XOlDXQnrjuc_"
+   },
+   "source": [
+    "## Prepare evaluation metric"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 49,
+     "referenced_widgets": [
+      "86fca0e29e7a4dc8b2234134014958f8",
+      "8378c214cd044bfb97c452d811df748f",
+      "828a652d92724ba4888d924846a79374",
+      "cfd59ddfe85f4585865df8df47fd491f",
+      "94f39a2f3baa4bb2bffd1b99e8a31367",
+      "b6a1b7db4afe44c792907f6377cde35c",
+      "dca7d0a0d2aa479083d81a54489d3717",
+      "4bb8b2d7000f464ba3ff18ce03fcfef4",
+      "793ebaa3acc6482bb135ca0ca864be4d",
+      "bcef9cf2b00c46878f07c48875f7d194",
+      "47659b15eb284f06bf9735ca2e425646"
+     ]
+    },
+    "id": "guYecwzyjLmj",
+    "outputId": "7efb445d-a442-4173-c869-9bc5be044e2b"
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "86fca0e29e7a4dc8b2234134014958f8",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading builder script:   0%|          | 0.00/4.20k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import evaluate\n",
+    "\n",
+    "metric = evaluate.load(\"accuracy\")\n",
+    "\n",
+    "\n",
+    "# the compute_metrics function takes a Named Tuple as input:\n",
+    "# predictions, which are the logits of the model as Numpy arrays,\n",
+    "# and label_ids, which are the ground-truth labels as Numpy arrays.\n",
+    "def compute_metrics(eval_pred):\n",
+    "    \"\"\"Computes accuracy on a batch of predictions\"\"\"\n",
+    "    predictions = np.argmax(eval_pred.predictions, axis=1)\n",
+    "    return metric.compute(predictions=predictions, references=eval_pred.label_ids)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "mNeLDXaE_989"
+   },
+   "source": [
+    "## Collation function\n",
+    "\n",
+    "This is used by `Trainer` to gather a batch of training and evaluation examples and prepare them in a format that is acceptable by the underlying model. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {
+    "id": "qIicZRMrjNC3"
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "\n",
+    "\n",
+    "def collate_fn(examples):\n",
+    "    pixel_values = torch.stack([example[\"pixel_values\"] for example in examples])\n",
+    "    labels = torch.tensor([example[\"label\"] for example in examples])\n",
+    "    return {\"pixel_values\": pixel_values, \"labels\": labels}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "YpWudVaJjwkx"
+   },
+   "source": [
+    "## Train and evaluate"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 1000,
+     "referenced_widgets": [
+      "95449e7030324f99b148bbaedc15c155",
+      "be1ae63f3e804e23abe7739e9f4577fb",
+      "d5b95aa9cab446f88d61e9f4a25a8e2f",
+      "2e31d27cc694434aa869896041c72bee",
+      "4a3ff00e64b548ce89355778907e48c9",
+      "d947ec84b16c4781959427b610328ab9",
+      "9123141f7c164d458a21e54fc579fa66",
+      "83d6fbf463264c71a4ec8775e26c7c38",
+      "f02443fbda394fefa162f4ff5b2d2ce7",
+      "0d75dd458e3448a58ea4e19c28e787c0",
+      "0bc5c81047994f5b976a927b8ed47cbc",
+      "da13543779034424aaf6f5c4a96f0457",
+      "2d13b401dcf94089a4a78a62f05bdce3",
+      "dbc00727fa1c4e00aacf627c04527649",
+      "e0d98c36e5d242b2905adf8167ac348a",
+      "483b46ed1e8148498d54e4d6f4c0ca8d",
+      "070fdaf418de43a3a5ee0592e8aca103",
+      "62818f9421694139bbe1d9ad6e822b10",
+      "3efccb526dec44bf9801ac13dcc1068d",
+      "8ecde04d15ab47f9b78d561615ca567d",
+      "ddf88cbfaaef4a55babf480816db7d28",
+      "38f30da546444f8199673003d0a92dda",
+      "e4a4122ff32a41a1917459709224fc6a",
+      "8ba66e043f8a4975bd77ecd343401260",
+      "2e0bb2dcd85640d7b85d80469ea9f9f3",
+      "1c208beced884b9291c5bcb7b4f71680",
+      "3f188d6d34774154afc297b13a3eb9e8",
+      "1f8c65025b63466192897a32a92182e9",
+      "ffc13c11355b46bb9cafcb17f3e1535e",
+      "136a56e1f70c431bae0a3ac01751a814",
+      "7a3daf19ee744c7b8baeb028db05009a",
+      "63c07a01593f467f9c0e7c5e283d58ae",
+      "972f831792cd4e89af109462dd5b9210",
+      "098770d5a36540dea54d27d7fa9bcd56",
+      "5da11a8c37ae41458ea4491ccdfb4db8",
+      "23ec20ee5f0e48be9470415810cd0b4b",
+      "e88c3ad56ef24e4d8281898b08ff6f4b",
+      "c5670295387a4c199571a2a21a6b69dc",
+      "6dac696d99a44ea399a1bd5e18f08428",
+      "b3a8eebed60f4ecab7d508c976e2e56b",
+      "d7c394bc6a3249e9b3fcbae2ebd25eb7",
+      "fea27a80cd2f4b4dba84ecdfefd2722c",
+      "1fdc59cbb8724c618ce6e586e2c9723f",
+      "dbaa70ad4f1d4496a670601fe447116d",
+      "fd9df81594724b88b54b4e3e1b19370a",
+      "c8267c689fb14afc9a8eb3ecb6f4fd4c",
+      "adb09cebab13484a8d75a338eaba7b0c",
+      "d68194cf7d264df7820f27eb4d070de2",
+      "8bf8a843d65142bbad81de74aa8573f6",
+      "fc9d0c314ca14826993fe1f24b070b5d",
+      "bc71a433928e4870b56a3d81e35e6351",
+      "9fb3579ca9714141a7857a513c379f03",
+      "edc0742a08a445a594139200c7f03c60",
+      "d9329cb3c1704691b6a36c293bcbf41b",
+      "dfa468dd89174d97bcaabbda0ed8e117",
+      "c2f4b407a47f4d958986035188c6ece8",
+      "75b76841f06249a0a77c7e38b85a14c8",
+      "79351db5d2e1468e9b91d7bd2274612e",
+      "c6ce0e9bdd90400f9cf2debf9165758c",
+      "138198ec50a9494889319d6c94da92bd",
+      "e6ce3e626b1744c7ba3da26d1fde5fa5",
+      "8e1237963bb5479f93318c5cdc6a8593",
+      "2d8a53b2a2bf42b9aa9cb2d9978ccee2",
+      "69dcd4770fbc428cb56498b6577e237e",
+      "cb3ab56aa43e4b94b978764caa6057a7",
+      "2e24b7250ee04fbb810e5d6ade107c51",
+      "2ab85fcc8de042d0bdb9ca79b8e404a4",
+      "77deda3ef342432f9b0f684a9b32e248",
+      "f3991aaad13a4c50a7809483b7907b7b",
+      "eca3b1f4ad76430483a221470e592c13",
+      "a1d5bc95f1e24e3293414e08aa5c8bd5",
+      "b48fcbe51098482aad8798670111d60d",
+      "7654b707840e4afb9bab8218418fd096",
+      "4a118fa87e424664a2d2ed7c7f58f3fd",
+      "852b01d8592b4d8aa2c4297d6cf75f78",
+      "e302923a9df24e5fa8fff79c203ead9f",
+      "f7b9abca32ec42edad5ec6e52882f732",
+      "923cf8641a7946f69ff41fb88b2b86f8",
+      "9d14ba8675fb4c689dd821ce7794abb6",
+      "6932d2462135413cbc293964eb1c8317",
+      "7d5831ee2a1c4e649f5508631d64e7cc",
+      "70af909af7de4161b4a72a8e15d116f3",
+      "d04c1c4d04fc4928b4a2a0e860f996e0",
+      "98d32ec7fbf54effadb886bc4ec6ce79",
+      "3c0cacee5997480cbedc0e9d59a62544",
+      "fee3db0deefb410db4c572efd95575bf",
+      "2eae62f1cc46449dba93f5eda0cb3f1c",
+      "e8026bcb0e2c4b14bc6c84537c8c4ae9",
+      "7bd32cf88c154303a76759d674795856",
+      "a907de6474cf45cb91b3f2efc40821b9",
+      "5dc4129160514a479ffb2f0564aee071",
+      "16620105b32f434eb77b0df56ed49e45",
+      "7b8f0cbb552447549aed602f937fcfb4",
+      "3f6394cb0ea242f28c4ba6b3b2d37e9f",
+      "02a0b01d31a34a1c924786037fecba09",
+      "e4074e524a19455fab810ec454fe8bf1",
+      "d67dc70cfc9246f79a59261a69b28b41",
+      "edb0d1ba5e114af9b6705969f58ece7b",
+      "1954a636239b40169659e2ae8ef3b127",
+      "d9c15769da2b49e4b67d43d95be30cd5",
+      "4d1f6114d4034f758bf8cc35485e0056",
+      "223a13f77e2e49a09660890eb4213b30",
+      "1639075b181f4945ac32af116b22d1d7",
+      "ad6adbe84ac940ffbf89017a269a3e75",
+      "0ba38362cf8647c08b0beb21a2c39442",
+      "65a0aed816c84164a6ee6a41d300fad0",
+      "47cf3db935ba4e109843b03a9577c184",
+      "be1ec4b9b8964810867b0e00bcc4868f",
+      "cf024daa51f74777b98028df10dbc9c5",
+      "eaf2c76a172d4da6846c6face18a3b58",
+      "bda7e5662f2e4fa292752efd4947c5f6",
+      "4825c09098e1446a9ed3b653b77894f4",
+      "f544720498e44c49add78550b46edb3a",
+      "24b3737dc76c4d4f9ba2603c653a3ce2",
+      "2ab99fb38f8d4bef85d9833bb628fa00",
+      "148c9912cec5473bb6f8533add143cd3",
+      "92dfb889fd22439bb7b5fd31e4991c93",
+      "9281c5aec5b84411a05e4762125388d9",
+      "f5b5d6ace35a4a82bfcf2549b93c8558",
+      "397dc640630841d7845bf5a8739ce5eb",
+      "07f5e653fe6740e8a71fb9de101884f3",
+      "ea2217bba8574c7890a411f27da0c147",
+      "b1b6922df40c4af69b00b4e85db770c4",
+      "2b8bc04ac3104592bf950e349c034c2d",
+      "cf815c0979644cd6ad2c681fa96c0648",
+      "7541b2304cc5466cb2369c0025d2d243",
+      "f6a9243d46cb4c0fbdf3f80f7074f6c5",
+      "a2b51be9304342e39431b82957eb4b25",
+      "5e51957908eb48489357a7c3924ec5c7",
+      "41320a22032c4884affc456f7c6db1c1",
+      "6940a405215c4e2caadbe209c677bde0",
+      "b21331417d084aba80f919b71933bc2c",
+      "c910ae80ec1a4718915e9a861215f27c",
+      "245c5418ca084fb6bc0b027576a1f789",
+      "d0bc0e6038eb46dbbc5f5593d4c285ca",
+      "a450c318d99a477c9f7341458ad4bc8d",
+      "02ac19466e24404a92e769ed60604881",
+      "431174d906f640baa17842fdb3a8714b",
+      "638b918aaacc4c4782b9e16ca66549e8",
+      "7c038ffcc1dc4e3fbfed17d94327353a",
+      "91f6edc592394a0bad250e68d3c22017",
+      "4533e8ce655649cba93553c8a2b17f37",
+      "63b53da916fe479e8cd495eff8d16df8",
+      "be29ee88a7ec489b8320f7306d78931d",
+      "a1df731c5c5f4f9cafa19323a750ebea",
+      "bf2e140f54d74df09663d3fcf1660d0c",
+      "acae77f181ed43a1b29412c575435a7f",
+      "87581c98cd174bb684ec259066d047ea",
+      "260fdda06c214ed499f69fac4077d476",
+      "aed3b4e6110442398c25d37456b78b5d",
+      "8da58936a6e64529af9a3e3f314e49cb",
+      "9a5e108d8b5a41ae95a619bfc6c8f3a9",
+      "e54b7fc2f9b94118ab97f2736862f77d",
+      "dfe97442852c4338843c65333b25623d",
+      "5b7be0df4db54866a3b6ef9204ba5a89",
+      "cde9d5cbadf14a5abe294dba0fa5bd2d",
+      "835db77232e74cc18a6b5db2ace40bfd",
+      "6099227eddde44009582b9f24fc96150",
+      "9eb912a195f3461297b7143cb1b04678",
+      "6f1a325b02f54352a0b412d7f4420bbb",
+      "e8c2cfdaf0eb413189d93924eae757c7",
+      "d2469e1f1daf4d4cb0faf35ce90f6445",
+      "e667b14a3c0e41c6a16c4be453f10378",
+      "af7ee2bb7ccc4c00838a2c6b937e4e8b",
+      "84c281446c5b424090a5eecbd733b050",
+      "fdb3673fdbf24468a9965f13196b78ed",
+      "0b82dbc29d514f4e9e012fd755948e52",
+      "af1a42626ba7452189fbb5987b159b9c",
+      "93788683ef8e4c71bc1c0b3b9cc7219c",
+      "6e4983016e4f465b85ab7a472d0e986e",
+      "aa68207e72b0467cb9a4354dc231db2f",
+      "60e6952873524186aad05661a00bd240",
+      "d4aa1670fdab463bb0a0e6fe104988bc",
+      "8934f66530644f0882e292bfd5458b0f",
+      "a2671f512e404f64bfa3f376449f6947",
+      "a61a30ebaac846c1b7a03c6a93127aad",
+      "bd9e7cb0f25445739ebcdff0d3112052",
+      "52d00532eeee40aa91e8a5c2a10e50a7",
+      "21c75049df804ac4ac7bc6349a639056",
+      "041f73c9a038411aa6d59cf8a93f6d47",
+      "b8e180259fd94096884f7e48a53b0fce",
+      "7a65e650113e476a8cb66caa92973dd3",
+      "d0c95a20c2664c149886b72fa665d3cf",
+      "5fd1cd8bf125446a96b9438fbbe52710",
+      "eb864284052c46b28b93fc79bfed740f",
+      "de92f68231294aefb249f400475bc9a4",
+      "f981fb4aae504045aa10889dceeb6cac",
+      "77f7230186b14c628f5094f9fd8d82da",
+      "855a0f70b9ac489a86b53792e119329a",
+      "9005e9db560d4e89880bdd18403ef9e1",
+      "070a734e268045098977db14c6565777",
+      "91ec8a3f10804d629cdfd47c61411c91",
+      "0465571b25714ecda9dfe6ff1a495a87",
+      "dc078f0db3e54199bef0c11ee5e6297e",
+      "c3f7788abe754cb3bfbee3fadda54916",
+      "fe93399cc15f4f29b6a37f6a65cf8c9b",
+      "ad2068dd9c2040f6ae44bc873fa7b6e7",
+      "9434b43de9954c83a4311432bdd68376"
+     ]
+    },
+    "id": "p2-RStfgjOQt",
+    "outputId": "6a1d0384-40ce-40b2-cca9-91a915d5b939"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Cloning https://huggingface.co/sayakpaul/vit-base-patch16-224-in21k-finetuned-lora-food101 into local empty directory.\n",
+      "WARNING:huggingface_hub.repository:Cloning https://huggingface.co/sayakpaul/vit-base-patch16-224-in21k-finetuned-lora-food101 into local empty directory.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "95449e7030324f99b148bbaedc15c155",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Download file pytorch_model.bin:   0%|          | 8.00k/330M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "da13543779034424aaf6f5c4a96f0457",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Download file runs/Feb07_02-43-38_319afa680fd7/1675737843.2328734/events.out.tfevents.1675737843.319afa680fd7.…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e4a4122ff32a41a1917459709224fc6a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Download file runs/Feb07_02-50-30_319afa680fd7/events.out.tfevents.1675738246.319afa680fd7.10047.0: 100%|#####…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "098770d5a36540dea54d27d7fa9bcd56",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Download file runs/Feb07_03-56-51_319afa680fd7/1675742273.001745/events.out.tfevents.1675742273.319afa680fd7.2…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "fd9df81594724b88b54b4e3e1b19370a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Download file training_args.bin: 100%|##########| 3.50k/3.50k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c2f4b407a47f4d958986035188c6ece8",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Download file runs/Feb07_03-56-51_319afa680fd7/events.out.tfevents.1675742272.319afa680fd7.27769.0: 100%|#####…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2ab85fcc8de042d0bdb9ca79b8e404a4",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Clean file runs/Feb07_02-43-38_319afa680fd7/1675737843.2328734/events.out.tfevents.1675737843.319afa680fd7.718…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "923cf8641a7946f69ff41fb88b2b86f8",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Download file runs/Feb07_02-50-30_319afa680fd7/1675738246.1183074/events.out.tfevents.1675738246.319afa680fd7.…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "7bd32cf88c154303a76759d674795856",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Clean file runs/Feb07_02-50-30_319afa680fd7/events.out.tfevents.1675738246.319afa680fd7.10047.0:  10%|#       …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d9c15769da2b49e4b67d43d95be30cd5",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Download file runs/Feb07_02-43-38_319afa680fd7/events.out.tfevents.1675737843.319afa680fd7.7189.0: 100%|######…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "bda7e5662f2e4fa292752efd4947c5f6",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Clean file runs/Feb07_03-56-51_319afa680fd7/1675742273.001745/events.out.tfevents.1675742273.319afa680fd7.2776…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ea2217bba8574c7890a411f27da0c147",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Clean file training_args.bin:  29%|##8       | 1.00k/3.50k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c910ae80ec1a4718915e9a861215f27c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Clean file runs/Feb07_03-56-51_319afa680fd7/events.out.tfevents.1675742272.319afa680fd7.27769.0:   9%|9       …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "be29ee88a7ec489b8320f7306d78931d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Clean file runs/Feb07_02-50-30_319afa680fd7/1675738246.1183074/events.out.tfevents.1675738246.319afa680fd7.100…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "5b7be0df4db54866a3b6ef9204ba5a89",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Clean file runs/Feb07_02-43-38_319afa680fd7/events.out.tfevents.1675737843.319afa680fd7.7189.0:  10%|#        …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "fdb3673fdbf24468a9965f13196b78ed",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Download file runs/Feb07_02-50-30_319afa680fd7/events.out.tfevents.1675738403.319afa680fd7.10047.2: 100%|#####…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "bd9e7cb0f25445739ebcdff0d3112052",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Clean file runs/Feb07_02-50-30_319afa680fd7/events.out.tfevents.1675738403.319afa680fd7.10047.2: 100%|########…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "77f7230186b14c628f5094f9fd8d82da",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Clean file pytorch_model.bin:   0%|          | 1.00k/330M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using cuda_amp half precision backend\n",
+      "/usr/local/lib/python3.8/dist-packages/transformers/optimization.py:306: FutureWarning: This implementation of AdamW is deprecated and will be removed in a future version. Use the PyTorch implementation torch.optim.AdamW instead, or set `no_deprecation_warning=True` to disable this warning\n",
+      "  warnings.warn(\n",
+      "***** Running training *****\n",
+      "  Num examples = 4500\n",
+      "  Num Epochs = 5\n",
+      "  Instantaneous batch size per device = 128\n",
+      "  Total train batch size (w. parallel, distributed & accumulation) = 512\n",
+      "  Gradient Accumulation steps = 4\n",
+      "  Total optimization steps = 45\n",
+      "  Number of trainable parameters = 667493\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "    <div>\n",
+       "      \n",
+       "      <progress value='45' max='45' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
+       "      [45/45 04:44, Epoch 5/5]\n",
+       "    </div>\n",
+       "    <table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       " <tr style=\"text-align: left;\">\n",
+       "      <th>Epoch</th>\n",
+       "      <th>Training Loss</th>\n",
+       "      <th>Validation Loss</th>\n",
+       "      <th>Accuracy</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <td>1</td>\n",
+       "      <td>No log</td>\n",
+       "      <td>0.506871</td>\n",
+       "      <td>0.896000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>2</td>\n",
+       "      <td>2.162700</td>\n",
+       "      <td>0.189141</td>\n",
+       "      <td>0.946000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>3</td>\n",
+       "      <td>0.345100</td>\n",
+       "      <td>0.144759</td>\n",
+       "      <td>0.960000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>4</td>\n",
+       "      <td>0.211600</td>\n",
+       "      <td>0.150886</td>\n",
+       "      <td>0.958000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>5</td>\n",
+       "      <td>0.171100</td>\n",
+       "      <td>0.149751</td>\n",
+       "      <td>0.958000</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table><p>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "***** Running Evaluation *****\n",
+      "  Num examples = 500\n",
+      "  Batch size = 128\n",
+      "Saving model checkpoint to vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-9\n",
+      "Configuration saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-9/config.json\n",
+      "Model weights saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-9/pytorch_model.bin\n",
+      "Image processor saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-9/preprocessor_config.json\n",
+      "Image processor saved in vit-base-patch16-224-in21k-finetuned-lora-food101/preprocessor_config.json\n",
+      "***** Running Evaluation *****\n",
+      "  Num examples = 500\n",
+      "  Batch size = 128\n",
+      "Saving model checkpoint to vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-18\n",
+      "Configuration saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-18/config.json\n",
+      "Model weights saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-18/pytorch_model.bin\n",
+      "Image processor saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-18/preprocessor_config.json\n",
+      "Image processor saved in vit-base-patch16-224-in21k-finetuned-lora-food101/preprocessor_config.json\n",
+      "***** Running Evaluation *****\n",
+      "  Num examples = 500\n",
+      "  Batch size = 128\n",
+      "Saving model checkpoint to vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-27\n",
+      "Configuration saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-27/config.json\n",
+      "Model weights saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-27/pytorch_model.bin\n",
+      "Image processor saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-27/preprocessor_config.json\n",
+      "Image processor saved in vit-base-patch16-224-in21k-finetuned-lora-food101/preprocessor_config.json\n",
+      "***** Running Evaluation *****\n",
+      "  Num examples = 500\n",
+      "  Batch size = 128\n",
+      "Saving model checkpoint to vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-36\n",
+      "Configuration saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-36/config.json\n",
+      "Model weights saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-36/pytorch_model.bin\n",
+      "Image processor saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-36/preprocessor_config.json\n",
+      "Image processor saved in vit-base-patch16-224-in21k-finetuned-lora-food101/preprocessor_config.json\n",
+      "***** Running Evaluation *****\n",
+      "  Num examples = 500\n",
+      "  Batch size = 128\n",
+      "Saving model checkpoint to vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-45\n",
+      "Configuration saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-45/config.json\n",
+      "Model weights saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-45/pytorch_model.bin\n",
+      "Image processor saved in vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-45/preprocessor_config.json\n",
+      "Image processor saved in vit-base-patch16-224-in21k-finetuned-lora-food101/preprocessor_config.json\n",
+      "\n",
+      "\n",
+      "Training completed. Do not forget to share your model on huggingface.co/models =)\n",
+      "\n",
+      "\n",
+      "Loading best model from vit-base-patch16-224-in21k-finetuned-lora-food101/checkpoint-27 (score: 0.96).\n"
+     ]
+    }
+   ],
+   "source": [
+    "trainer = Trainer(\n",
+    "    lora_model,\n",
+    "    args,\n",
+    "    train_dataset=train_ds,\n",
+    "    eval_dataset=val_ds,\n",
+    "    processing_class=image_processor,\n",
+    "    compute_metrics=compute_metrics,\n",
+    "    data_collator=collate_fn,\n",
+    ")\n",
+    "train_results = trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "b2NENHxHCejv"
+   },
+   "source": [
+    "In just a few minutes, we have a fine-tuned model with 96% validation accuracy. Also, note that we used a very small subset of the training dataset which is definitely impacting the results. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 198
+    },
+    "id": "_MAd2906jQKG",
+    "outputId": "7b825531-4e8d-4666-d6fc-eaa1accf3bb6"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "***** Running Evaluation *****\n",
+      "  Num examples = 500\n",
+      "  Batch size = 128\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "    <div>\n",
+       "      \n",
+       "      <progress value='8' max='4' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
+       "      [4/4 01:48]\n",
+       "    </div>\n",
+       "    "
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'eval_loss': 0.14475855231285095,\n",
+       " 'eval_accuracy': 0.96,\n",
+       " 'eval_runtime': 3.5725,\n",
+       " 'eval_samples_per_second': 139.958,\n",
+       " 'eval_steps_per_second': 1.12,\n",
+       " 'epoch': 5.0}"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "trainer.evaluate(val_ds)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "qo_scDEyAQER"
+   },
+   "source": [
+    "## Sharing your model and inference \n",
+    "\n",
+    "Once the fine-tuning is done, we can share the LoRA parameters with the community like so: "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 172,
+     "referenced_widgets": [
+      "980d2f61332f414d9888b76e78774be4",
+      "cbc0ba8e49a740fcae7b94fe7edb8107",
+      "b3f07ef160a7425880ffe362008d4400",
+      "49ed3330fa9645eda8b5aed0fd7cbafe",
+      "f96302d0c2d849c5b5a0206b65e461ab",
+      "fcc7ad16a0b14d96acd9be9e03ac6af9",
+      "1a08961f063346ccae206a863ab7df6b",
+      "1150e391e753424da7d65bda10463da4",
+      "e6e36d744e1244aeb7eb0c4ce392372d",
+      "b2ad992db5a045668fa55c7393ec7870",
+      "b5fad0f3f2d543ecaed726e52d2d86bb",
+      "e83fd078f467406da0baf26e18b39e89",
+      "9b4b67731a7a4bc59be132b53c24eae8",
+      "e33243b001274d02a25f5940ba41ecf6",
+      "06e4c619e366427a8ff4c358196ecd12",
+      "bacd429b42d843299cb75224db3afb1e",
+      "c53429e699e64b3d8895a355bbd947a6",
+      "2bfd04824f2e4fd6844dd38e46dbbbdf",
+      "40a5a50aeca24f0d8990da97971004d1",
+      "be71e6438e0e49759d2f72feec520cae",
+      "1902fbc4c1da4ffe90f0947e58eb5d48",
+      "12a94351242444d7b0d23b8accc1824a"
+     ]
+    },
+    "id": "TyQvIcnFzLIV",
+    "outputId": "7ac2819e-080e-4940-9755-15c32832d9a6"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Uploading the following files to sayakpaul/vit-base-patch16-224-in21k-finetuned-lora-food101: adapter_config.json,adapter_model.bin\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "980d2f61332f414d9888b76e78774be4",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Upload 1 LFS files:   0%|          | 0/1 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e83fd078f467406da0baf26e18b39e89",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "adapter_model.bin:   0%|          | 0.00/2.69M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "CommitInfo(commit_url='https://huggingface.co/sayakpaul/vit-base-patch16-224-in21k-finetuned-lora-food101/commit/64e17d1cda300041cbc67428242a3136060772a3', commit_message='Upload model', commit_description='', oid='64e17d1cda300041cbc67428242a3136060772a3', pr_url=None, pr_revision=None, pr_num=None)"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "repo_name = f\"sayakpaul/{model_name}-finetuned-lora-food101\"\n",
+    "lora_model.push_to_hub(repo_name)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "uCmWERkhSRNO"
+   },
+   "source": [
+    "When we call `push_to_hub()` on the `lora_model`, only the LoRA parameters along with any modules specified in `modules_to_save` are saved. If we take a look at the [trained LoRA parameters](https://huggingface.co/sayakpaul/vit-base-patch16-224-in21k-finetuned-lora-food101/blob/main/adapter_model.bin), we see that it's only **2.6 MB**! This greatly helps with portability especially when we're using a very large model to fine-tune (such as [BLOOM](https://huggingface.co/bigscience/bloom)). "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Kt57qe42Sr6E"
+   },
+   "source": [
+    "Next, we see how to load the LoRA updated parameters along with our base model for inference. When we wrap a base model with `PeftModel` that modifications are DONE in place. So to mitigate any concerns that might stem from in place modifications, we newly initialize our base model just like we did earlier and construct our inference model. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 1000,
+     "referenced_widgets": [
+      "323eb0d9dade4c4fa3a9ad2b973dcbe1",
+      "484f7a55438c47f59365242c4753edba",
+      "c5665d0bc652405c8754474871baab06",
+      "82f96ac9299a4841a550ad3daa0099d0",
+      "f031aaf7fbc648a7b8a2e5faf37df14d",
+      "f22598cf4ade4427a1b437fd45aabcc4",
+      "0cd35b1092064f42908ce4123b79a8af",
+      "8b7713310a814991aec7929fa715ec7c",
+      "fcc8254622324f8ea965e12e4d4966cd",
+      "3a71257db7bc408d8e4d1fbcaf1dff93",
+      "ccd34ccf2c864c609a0b4fcee7327b31"
+     ]
+    },
+    "id": "IY78Ty570etw",
+    "outputId": "8ffc4da6-8165-46bb-dd4a-a79b9f236cb3"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "loading configuration file config.json from cache at /root/.cache/huggingface/hub/models--google--vit-base-patch16-224-in21k/snapshots/1ba429d32753f33a0660b80ac6f43a3c80c18938/config.json\n",
+      "Model config ViTConfig {\n",
+      "  \"_name_or_path\": \"google/vit-base-patch16-224-in21k\",\n",
+      "  \"architectures\": [\n",
+      "    \"ViTModel\"\n",
+      "  ],\n",
+      "  \"attention_probs_dropout_prob\": 0.0,\n",
+      "  \"encoder_stride\": 16,\n",
+      "  \"hidden_act\": \"gelu\",\n",
+      "  \"hidden_dropout_prob\": 0.0,\n",
+      "  \"hidden_size\": 768,\n",
+      "  \"id2label\": {\n",
+      "    \"0\": \"apple_pie\",\n",
+      "    \"1\": \"baby_back_ribs\",\n",
+      "    \"2\": \"baklava\",\n",
+      "    \"3\": \"beef_carpaccio\",\n",
+      "    \"4\": \"beef_tartare\",\n",
+      "    \"5\": \"beet_salad\",\n",
+      "    \"6\": \"beignets\",\n",
+      "    \"7\": \"bibimbap\",\n",
+      "    \"8\": \"bread_pudding\",\n",
+      "    \"9\": \"breakfast_burrito\",\n",
+      "    \"10\": \"bruschetta\",\n",
+      "    \"11\": \"caesar_salad\",\n",
+      "    \"12\": \"cannoli\",\n",
+      "    \"13\": \"caprese_salad\",\n",
+      "    \"14\": \"carrot_cake\",\n",
+      "    \"15\": \"ceviche\",\n",
+      "    \"16\": \"cheesecake\",\n",
+      "    \"17\": \"cheese_plate\",\n",
+      "    \"18\": \"chicken_curry\",\n",
+      "    \"19\": \"chicken_quesadilla\",\n",
+      "    \"20\": \"chicken_wings\",\n",
+      "    \"21\": \"chocolate_cake\",\n",
+      "    \"22\": \"chocolate_mousse\",\n",
+      "    \"23\": \"churros\",\n",
+      "    \"24\": \"clam_chowder\",\n",
+      "    \"25\": \"club_sandwich\",\n",
+      "    \"26\": \"crab_cakes\",\n",
+      "    \"27\": \"creme_brulee\",\n",
+      "    \"28\": \"croque_madame\",\n",
+      "    \"29\": \"cup_cakes\",\n",
+      "    \"30\": \"deviled_eggs\",\n",
+      "    \"31\": \"donuts\",\n",
+      "    \"32\": \"dumplings\",\n",
+      "    \"33\": \"edamame\",\n",
+      "    \"34\": \"eggs_benedict\",\n",
+      "    \"35\": \"escargots\",\n",
+      "    \"36\": \"falafel\",\n",
+      "    \"37\": \"filet_mignon\",\n",
+      "    \"38\": \"fish_and_chips\",\n",
+      "    \"39\": \"foie_gras\",\n",
+      "    \"40\": \"french_fries\",\n",
+      "    \"41\": \"french_onion_soup\",\n",
+      "    \"42\": \"french_toast\",\n",
+      "    \"43\": \"fried_calamari\",\n",
+      "    \"44\": \"fried_rice\",\n",
+      "    \"45\": \"frozen_yogurt\",\n",
+      "    \"46\": \"garlic_bread\",\n",
+      "    \"47\": \"gnocchi\",\n",
+      "    \"48\": \"greek_salad\",\n",
+      "    \"49\": \"grilled_cheese_sandwich\",\n",
+      "    \"50\": \"grilled_salmon\",\n",
+      "    \"51\": \"guacamole\",\n",
+      "    \"52\": \"gyoza\",\n",
+      "    \"53\": \"hamburger\",\n",
+      "    \"54\": \"hot_and_sour_soup\",\n",
+      "    \"55\": \"hot_dog\",\n",
+      "    \"56\": \"huevos_rancheros\",\n",
+      "    \"57\": \"hummus\",\n",
+      "    \"58\": \"ice_cream\",\n",
+      "    \"59\": \"lasagna\",\n",
+      "    \"60\": \"lobster_bisque\",\n",
+      "    \"61\": \"lobster_roll_sandwich\",\n",
+      "    \"62\": \"macaroni_and_cheese\",\n",
+      "    \"63\": \"macarons\",\n",
+      "    \"64\": \"miso_soup\",\n",
+      "    \"65\": \"mussels\",\n",
+      "    \"66\": \"nachos\",\n",
+      "    \"67\": \"omelette\",\n",
+      "    \"68\": \"onion_rings\",\n",
+      "    \"69\": \"oysters\",\n",
+      "    \"70\": \"pad_thai\",\n",
+      "    \"71\": \"paella\",\n",
+      "    \"72\": \"pancakes\",\n",
+      "    \"73\": \"panna_cotta\",\n",
+      "    \"74\": \"peking_duck\",\n",
+      "    \"75\": \"pho\",\n",
+      "    \"76\": \"pizza\",\n",
+      "    \"77\": \"pork_chop\",\n",
+      "    \"78\": \"poutine\",\n",
+      "    \"79\": \"prime_rib\",\n",
+      "    \"80\": \"pulled_pork_sandwich\",\n",
+      "    \"81\": \"ramen\",\n",
+      "    \"82\": \"ravioli\",\n",
+      "    \"83\": \"red_velvet_cake\",\n",
+      "    \"84\": \"risotto\",\n",
+      "    \"85\": \"samosa\",\n",
+      "    \"86\": \"sashimi\",\n",
+      "    \"87\": \"scallops\",\n",
+      "    \"88\": \"seaweed_salad\",\n",
+      "    \"89\": \"shrimp_and_grits\",\n",
+      "    \"90\": \"spaghetti_bolognese\",\n",
+      "    \"91\": \"spaghetti_carbonara\",\n",
+      "    \"92\": \"spring_rolls\",\n",
+      "    \"93\": \"steak\",\n",
+      "    \"94\": \"strawberry_shortcake\",\n",
+      "    \"95\": \"sushi\",\n",
+      "    \"96\": \"tacos\",\n",
+      "    \"97\": \"takoyaki\",\n",
+      "    \"98\": \"tiramisu\",\n",
+      "    \"99\": \"tuna_tartare\",\n",
+      "    \"100\": \"waffles\"\n",
+      "  },\n",
+      "  \"image_size\": 224,\n",
+      "  \"initializer_range\": 0.02,\n",
+      "  \"intermediate_size\": 3072,\n",
+      "  \"label2id\": {\n",
+      "    \"apple_pie\": 0,\n",
+      "    \"baby_back_ribs\": 1,\n",
+      "    \"baklava\": 2,\n",
+      "    \"beef_carpaccio\": 3,\n",
+      "    \"beef_tartare\": 4,\n",
+      "    \"beet_salad\": 5,\n",
+      "    \"beignets\": 6,\n",
+      "    \"bibimbap\": 7,\n",
+      "    \"bread_pudding\": 8,\n",
+      "    \"breakfast_burrito\": 9,\n",
+      "    \"bruschetta\": 10,\n",
+      "    \"caesar_salad\": 11,\n",
+      "    \"cannoli\": 12,\n",
+      "    \"caprese_salad\": 13,\n",
+      "    \"carrot_cake\": 14,\n",
+      "    \"ceviche\": 15,\n",
+      "    \"cheese_plate\": 17,\n",
+      "    \"cheesecake\": 16,\n",
+      "    \"chicken_curry\": 18,\n",
+      "    \"chicken_quesadilla\": 19,\n",
+      "    \"chicken_wings\": 20,\n",
+      "    \"chocolate_cake\": 21,\n",
+      "    \"chocolate_mousse\": 22,\n",
+      "    \"churros\": 23,\n",
+      "    \"clam_chowder\": 24,\n",
+      "    \"club_sandwich\": 25,\n",
+      "    \"crab_cakes\": 26,\n",
+      "    \"creme_brulee\": 27,\n",
+      "    \"croque_madame\": 28,\n",
+      "    \"cup_cakes\": 29,\n",
+      "    \"deviled_eggs\": 30,\n",
+      "    \"donuts\": 31,\n",
+      "    \"dumplings\": 32,\n",
+      "    \"edamame\": 33,\n",
+      "    \"eggs_benedict\": 34,\n",
+      "    \"escargots\": 35,\n",
+      "    \"falafel\": 36,\n",
+      "    \"filet_mignon\": 37,\n",
+      "    \"fish_and_chips\": 38,\n",
+      "    \"foie_gras\": 39,\n",
+      "    \"french_fries\": 40,\n",
+      "    \"french_onion_soup\": 41,\n",
+      "    \"french_toast\": 42,\n",
+      "    \"fried_calamari\": 43,\n",
+      "    \"fried_rice\": 44,\n",
+      "    \"frozen_yogurt\": 45,\n",
+      "    \"garlic_bread\": 46,\n",
+      "    \"gnocchi\": 47,\n",
+      "    \"greek_salad\": 48,\n",
+      "    \"grilled_cheese_sandwich\": 49,\n",
+      "    \"grilled_salmon\": 50,\n",
+      "    \"guacamole\": 51,\n",
+      "    \"gyoza\": 52,\n",
+      "    \"hamburger\": 53,\n",
+      "    \"hot_and_sour_soup\": 54,\n",
+      "    \"hot_dog\": 55,\n",
+      "    \"huevos_rancheros\": 56,\n",
+      "    \"hummus\": 57,\n",
+      "    \"ice_cream\": 58,\n",
+      "    \"lasagna\": 59,\n",
+      "    \"lobster_bisque\": 60,\n",
+      "    \"lobster_roll_sandwich\": 61,\n",
+      "    \"macaroni_and_cheese\": 62,\n",
+      "    \"macarons\": 63,\n",
+      "    \"miso_soup\": 64,\n",
+      "    \"mussels\": 65,\n",
+      "    \"nachos\": 66,\n",
+      "    \"omelette\": 67,\n",
+      "    \"onion_rings\": 68,\n",
+      "    \"oysters\": 69,\n",
+      "    \"pad_thai\": 70,\n",
+      "    \"paella\": 71,\n",
+      "    \"pancakes\": 72,\n",
+      "    \"panna_cotta\": 73,\n",
+      "    \"peking_duck\": 74,\n",
+      "    \"pho\": 75,\n",
+      "    \"pizza\": 76,\n",
+      "    \"pork_chop\": 77,\n",
+      "    \"poutine\": 78,\n",
+      "    \"prime_rib\": 79,\n",
+      "    \"pulled_pork_sandwich\": 80,\n",
+      "    \"ramen\": 81,\n",
+      "    \"ravioli\": 82,\n",
+      "    \"red_velvet_cake\": 83,\n",
+      "    \"risotto\": 84,\n",
+      "    \"samosa\": 85,\n",
+      "    \"sashimi\": 86,\n",
+      "    \"scallops\": 87,\n",
+      "    \"seaweed_salad\": 88,\n",
+      "    \"shrimp_and_grits\": 89,\n",
+      "    \"spaghetti_bolognese\": 90,\n",
+      "    \"spaghetti_carbonara\": 91,\n",
+      "    \"spring_rolls\": 92,\n",
+      "    \"steak\": 93,\n",
+      "    \"strawberry_shortcake\": 94,\n",
+      "    \"sushi\": 95,\n",
+      "    \"tacos\": 96,\n",
+      "    \"takoyaki\": 97,\n",
+      "    \"tiramisu\": 98,\n",
+      "    \"tuna_tartare\": 99,\n",
+      "    \"waffles\": 100\n",
+      "  },\n",
+      "  \"layer_norm_eps\": 1e-12,\n",
+      "  \"model_type\": \"vit\",\n",
+      "  \"num_attention_heads\": 12,\n",
+      "  \"num_channels\": 3,\n",
+      "  \"num_hidden_layers\": 12,\n",
+      "  \"patch_size\": 16,\n",
+      "  \"qkv_bias\": true,\n",
+      "  \"transformers_version\": \"4.26.0\"\n",
+      "}\n",
+      "\n",
+      "loading weights file pytorch_model.bin from cache at /root/.cache/huggingface/hub/models--google--vit-base-patch16-224-in21k/snapshots/1ba429d32753f33a0660b80ac6f43a3c80c18938/pytorch_model.bin\n",
+      "Some weights of the model checkpoint at google/vit-base-patch16-224-in21k were not used when initializing ViTForImageClassification: ['pooler.dense.weight', 'pooler.dense.bias']\n",
+      "- This IS expected if you are initializing ViTForImageClassification from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
+      "- This IS NOT expected if you are initializing ViTForImageClassification from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
+      "Some weights of ViTForImageClassification were not initialized from the model checkpoint at google/vit-base-patch16-224-in21k and are newly initialized: ['classifier.bias', 'classifier.weight']\n",
+      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "323eb0d9dade4c4fa3a9ad2b973dcbe1",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading (…)\"adapter_model.bin\";:   0%|          | 0.00/2.69M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from peft import PeftConfig, PeftModel\n",
+    "\n",
+    "\n",
+    "config = PeftConfig.from_pretrained(repo_name)\n",
+    "model = model = AutoModelForImageClassification.from_pretrained(\n",
+    "    config.base_model_name_or_path,\n",
+    "    label2id=label2id,\n",
+    "    id2label=id2label,\n",
+    "    ignore_mismatched_sizes=True,  # provide this in case you're planning to fine-tune an already fine-tuned checkpoint\n",
+    ")\n",
+    "# Load the Lora model\n",
+    "inference_model = PeftModel.from_pretrained(model, repo_name)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "F9QDze9AXH8n"
+   },
+   "source": [
+    "Don't worry about the warnings, they're harmless. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Qb19xGKDW1XS"
+   },
+   "source": [
+    "Let's now fetch a sample for inference."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 200
+    },
+    "id": "HxJAOWPGU1nL",
+    "outputId": "ab0e4295-325e-4f21-b0c2-c2b09dd05a7a"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=275x183 at 0x7F7B550B60D0>"
+      ]
+     },
+     "execution_count": 44,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from PIL import Image\n",
+    "import requests\n",
+    "\n",
+    "url = \"https://huggingface.co/datasets/sayakpaul/sample-datasets/resolve/main/beignets.jpeg\"\n",
+    "image = Image.open(requests.get(url, stream=True).raw)\n",
+    "image"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "dFuqZgmCW4cu"
+   },
+   "source": [
+    "We first instantiate an `image_processor` from the underlying model repo. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "dN4x_pj-VQx8",
+    "outputId": "b4fddd49-2f10-48e2-de31-0cefd20d405d"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "loading configuration file preprocessor_config.json from cache at /root/.cache/huggingface/hub/models--sayakpaul--vit-base-patch16-224-in21k-finetuned-lora-food101/snapshots/fa2503cc7d91e0dd69728c1dc66ed80d7bd3289b/preprocessor_config.json\n",
+      "Image processor ViTImageProcessor {\n",
+      "  \"do_normalize\": true,\n",
+      "  \"do_rescale\": true,\n",
+      "  \"do_resize\": true,\n",
+      "  \"image_mean\": [\n",
+      "    0.5,\n",
+      "    0.5,\n",
+      "    0.5\n",
+      "  ],\n",
+      "  \"image_processor_type\": \"ViTImageProcessor\",\n",
+      "  \"image_std\": [\n",
+      "    0.5,\n",
+      "    0.5,\n",
+      "    0.5\n",
+      "  ],\n",
+      "  \"resample\": 2,\n",
+      "  \"rescale_factor\": 0.00392156862745098,\n",
+      "  \"size\": {\n",
+      "    \"height\": 224,\n",
+      "    \"width\": 224\n",
+      "  }\n",
+      "}\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "image_processor = AutoImageProcessor.from_pretrained(repo_name)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Dc0rCwC5XAaL"
+   },
+   "source": [
+    "We then prepare the sample for inference."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "57C6tcdnVYu1",
+    "outputId": "f164dd91-8679-482e-fb10-2f530d4ea9f4"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "torch.Size([1, 3, 224, 224])\n"
+     ]
+    }
+   ],
+   "source": [
+    "# prepare image for the model\n",
+    "encoding = image_processor(image.convert(\"RGB\"), return_tensors=\"pt\")\n",
+    "print(encoding.pixel_values.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Pn4T1GyTXC47"
+   },
+   "source": [
+    "And run inference!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "YyQznW5WViMc",
+    "outputId": "d1b7a77c-68b3-4f6b-a945-4b32e85baabe"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Predicted class: beignets\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "\n",
+    "# forward pass\n",
+    "with torch.no_grad():\n",
+    "    outputs = inference_model(**encoding)\n",
+    "    logits = outputs.logits\n",
+    "\n",
+    "predicted_class_idx = logits.argmax(-1).item()\n",
+    "print(\"Predicted class:\", inference_model.config.id2label[predicted_class_idx])"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "collapsed_sections": [
+    "0a_bETbqv4P7",
+    "Y8dSVHoIv7HC",
+    "qo_scDEyAQER"
+   ],
+   "machine_shape": "hm",
+   "provenance": []
+  },
+  "gpuClass": "premium",
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.2"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "62ba1781de76fc6672ab4d41176558d38a2895b3007f2161f5f79f77fdcaf8cf"
+   }
+  },
+  "widgets": {
+   "application/vnd.jupyter.widget-state+json": {
+    "02a0b01d31a34a1c924786037fecba09": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "02ac19466e24404a92e769ed60604881": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "039dd9a4b99e433088a0acd8ba7b519b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "041f73c9a038411aa6d59cf8a93f6d47": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_de92f68231294aefb249f400475bc9a4",
+      "placeholder": "​",
+      "style": "IPY_MODEL_f981fb4aae504045aa10889dceeb6cac",
+      "value": " 357/357 [01:17&lt;?, ?B/s]"
+     }
+    },
+    "0465571b25714ecda9dfe6ff1a495a87": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "06cf9f29b929412a8092044e25861f1c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_375ac7a15cea4ce3aa484a806cc82717",
+      "max": 489429,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_6b6459f123ef4f24a550cd9ec3c9f809",
+      "value": 489429
+     }
+    },
+    "06e4c619e366427a8ff4c358196ecd12": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_1902fbc4c1da4ffe90f0947e58eb5d48",
+      "placeholder": "​",
+      "style": "IPY_MODEL_12a94351242444d7b0d23b8accc1824a",
+      "value": " 2.69M/2.69M [00:00&lt;00:00, 2.27MB/s]"
+     }
+    },
+    "070a734e268045098977db14c6565777": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_ad2068dd9c2040f6ae44bc873fa7b6e7",
+      "placeholder": "​",
+      "style": "IPY_MODEL_9434b43de9954c83a4311432bdd68376",
+      "value": " 330M/330M [00:39&lt;00:00, 11.7MB/s]"
+     }
+    },
+    "070fdaf418de43a3a5ee0592e8aca103": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "074f38bd3a9d49719188e8860fb1b5d3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "07f5e653fe6740e8a71fb9de101884f3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "0957e36be17c43fd89462c5d5ddcec1b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "098770d5a36540dea54d27d7fa9bcd56": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_5da11a8c37ae41458ea4491ccdfb4db8",
+       "IPY_MODEL_23ec20ee5f0e48be9470415810cd0b4b",
+       "IPY_MODEL_e88c3ad56ef24e4d8281898b08ff6f4b"
+      ],
+      "layout": "IPY_MODEL_c5670295387a4c199571a2a21a6b69dc"
+     }
+    },
+    "0a0e75829d6c4031bc917ac2044d9e47": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0b82dbc29d514f4e9e012fd755948e52": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_aa68207e72b0467cb9a4354dc231db2f",
+      "placeholder": "​",
+      "style": "IPY_MODEL_60e6952873524186aad05661a00bd240",
+      "value": "Download file runs/Feb07_02-50-30_319afa680fd7/events.out.tfevents.1675738403.319afa680fd7.10047.2: 100%"
+     }
+    },
+    "0ba38362cf8647c08b0beb21a2c39442": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0bc5c81047994f5b976a927b8ed47cbc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "0cd35b1092064f42908ce4123b79a8af": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "0d75dd458e3448a58ea4e19c28e787c0": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "10c4f5677d1c4af8b3370b7fb1255065": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1150e391e753424da7d65bda10463da4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "128677e1b5b14e63b06b0f81c9cc4df0": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "12a94351242444d7b0d23b8accc1824a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "13279e67c4d847e4846e2d34e8aac589": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_d7d43177c750412cb1522eb08c01d2d9",
+       "IPY_MODEL_70b04a3579a5446f94acd422c70ac50a",
+       "IPY_MODEL_43940212a87d410c82cc9cd15f38a97e"
+      ],
+      "layout": "IPY_MODEL_19fd7c60287b43bbb6e0b12c25b4b375"
+     }
+    },
+    "136a56e1f70c431bae0a3ac01751a814": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "138198ec50a9494889319d6c94da92bd": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "148c9912cec5473bb6f8533add143cd3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "14c23f636609458ca4493854826c1a8e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "15bd2dcdbf4b4e74b9db09bdb8822e61": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1639075b181f4945ac32af116b22d1d7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_cf024daa51f74777b98028df10dbc9c5",
+      "placeholder": "​",
+      "style": "IPY_MODEL_eaf2c76a172d4da6846c6face18a3b58",
+      "value": " 9.99k/9.99k [01:17&lt;?, ?B/s]"
+     }
+    },
+    "16620105b32f434eb77b0df56ed49e45": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_edb0d1ba5e114af9b6705969f58ece7b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_1954a636239b40169659e2ae8ef3b127",
+      "value": " 9.99k/9.99k [01:17&lt;00:00, 119B/s]"
+     }
+    },
+    "1674d568877048368c842c21ffaac811": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "16b464f168d844cba5eb0c91ab4fb91c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_28f82c8fc9cf46c7858132a77e45834b",
+      "max": 25250,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_ce18faf7b68140a3a8247330b356e05b",
+      "value": 25250
+     }
+    },
+    "16c7db587b8e475fa3aa9677385b092a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "17235d013b7c4cee996d0bbc1cc6c70c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "1839e4ed1d3c4975b34c3c050052693f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1902fbc4c1da4ffe90f0947e58eb5d48": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "194dd0bcc350480c9ddd3e4ef17efc3a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "1954a636239b40169659e2ae8ef3b127": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "19ec79f5a5174aa3b26861a9662951d3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_57c15c64c2374f06a1e0a36bab953ef7",
+       "IPY_MODEL_06cf9f29b929412a8092044e25861f1c",
+       "IPY_MODEL_c2032e5054ac4604832957cb6e2e69ca"
+      ],
+      "layout": "IPY_MODEL_d1ff50e1b871429a85df8cf10e73ffb1"
+     }
+    },
+    "19fd7c60287b43bbb6e0b12c25b4b375": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1a08961f063346ccae206a863ab7df6b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "1a4ab138be9940f081514b914fdc4623": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8b9f5bca0898404b91032befbd019fa3",
+      "placeholder": "​",
+      "style": "IPY_MODEL_e4694cffcb574863a255e9022c8ddf5d",
+      "value": "Downloading (…)lve/main/config.json: 100%"
+     }
+    },
+    "1b31bfb0ef4c404698eb2205414170af": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "1c208beced884b9291c5bcb7b4f71680": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_63c07a01593f467f9c0e7c5e283d58ae",
+      "placeholder": "​",
+      "style": "IPY_MODEL_972f831792cd4e89af109462dd5b9210",
+      "value": " 9.99k/9.99k [01:17&lt;?, ?B/s]"
+     }
+    },
+    "1d4a5a5b7d1645a8bf8133935e173082": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c3178221dc074657bc0e585c4cfe326d",
+      "max": 5560,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_3c6842e0158b4dcc9b93eddfe3279d2a",
+      "value": 5560
+     }
+    },
+    "1e3e374b08964a689cfaac9c826f207b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1f8c65025b63466192897a32a92182e9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1f96ca356b6f41b59275abe93df33f43": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "CheckboxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "CheckboxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "CheckboxView",
+      "description": "Add token as git credential?",
+      "description_tooltip": null,
+      "disabled": false,
+      "indent": true,
+      "layout": "IPY_MODEL_516c6d75bc654d62b95ac235ce84c59c",
+      "style": "IPY_MODEL_14c23f636609458ca4493854826c1a8e",
+      "value": true
+     }
+    },
+    "1fdc59cbb8724c618ce6e586e2c9723f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "21c75049df804ac4ac7bc6349a639056": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5fd1cd8bf125446a96b9438fbbe52710",
+      "max": 357,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_eb864284052c46b28b93fc79bfed740f",
+      "value": 357
+     }
+    },
+    "223a13f77e2e49a09660890eb4213b30": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_47cf3db935ba4e109843b03a9577c184",
+      "max": 10227,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_be1ec4b9b8964810867b0e00bcc4868f",
+      "value": 10227
+     }
+    },
+    "22da54e68b1d48f9b3ba55ac1ca56873": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "23436ea247dd43d8829ca143a49637c5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_ce16ac2b3ff244e6bd7dd58daa9f4f7f",
+      "placeholder": "​",
+      "style": "IPY_MODEL_d25f3ebb577749d89e2e6d2a72f6ca5f",
+      "value": " 2/2 [00:01&lt;00:00,  1.95it/s]"
+     }
+    },
+    "236638d673934823828ee57face78184": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_920293e203f14b45b61233e1bb6f1214",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a1981bfcdb6d401e9a521e18b511cf9d",
+      "value": " 502/502 [00:00&lt;00:00, 27.9kB/s]"
+     }
+    },
+    "23c608994006427caca7975e0d81271f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "23ec20ee5f0e48be9470415810cd0b4b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d7c394bc6a3249e9b3fcbae2ebd25eb7",
+      "max": 5777,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_fea27a80cd2f4b4dba84ecdfefd2722c",
+      "value": 5777
+     }
+    },
+    "245c5418ca084fb6bc0b027576a1f789": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_431174d906f640baa17842fdb3a8714b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_638b918aaacc4c4782b9e16ca66549e8",
+      "value": "Clean file runs/Feb07_03-56-51_319afa680fd7/events.out.tfevents.1675742272.319afa680fd7.27769.0: 100%"
+     }
+    },
+    "24b3737dc76c4d4f9ba2603c653a3ce2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_397dc640630841d7845bf5a8739ce5eb",
+      "placeholder": "​",
+      "style": "IPY_MODEL_07f5e653fe6740e8a71fb9de101884f3",
+      "value": " 5.64k/5.64k [01:17&lt;00:00, 61.5B/s]"
+     }
+    },
+    "260fdda06c214ed499f69fac4077d476": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "26520bc6555d41d9951ea0219dc4b5d7": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "28f82c8fc9cf46c7858132a77e45834b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "29de968ad50543418c6865fdf003a568": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2ab85fcc8de042d0bdb9ca79b8e404a4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_77deda3ef342432f9b0f684a9b32e248",
+       "IPY_MODEL_f3991aaad13a4c50a7809483b7907b7b",
+       "IPY_MODEL_eca3b1f4ad76430483a221470e592c13"
+      ],
+      "layout": "IPY_MODEL_a1d5bc95f1e24e3293414e08aa5c8bd5"
+     }
+    },
+    "2ab99fb38f8d4bef85d9833bb628fa00": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2b8bc04ac3104592bf950e349c034c2d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5e51957908eb48489357a7c3924ec5c7",
+      "max": 3579,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_41320a22032c4884affc456f7c6db1c1",
+      "value": 3579
+     }
+    },
+    "2bfd04824f2e4fd6844dd38e46dbbbdf": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "2c86eb6c67f44af590937d0f1db09333": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "2d13b401dcf94089a4a78a62f05bdce3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_070fdaf418de43a3a5ee0592e8aca103",
+      "placeholder": "​",
+      "style": "IPY_MODEL_62818f9421694139bbe1d9ad6e822b10",
+      "value": "Download file runs/Feb07_02-43-38_319afa680fd7/1675737843.2328734/events.out.tfevents.1675737843.319afa680fd7.7189.1: 100%"
+     }
+    },
+    "2d867c65533e482a96db93bc5a09b8cb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "2d8a53b2a2bf42b9aa9cb2d9978ccee2": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2e0bb2dcd85640d7b85d80469ea9f9f3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_136a56e1f70c431bae0a3ac01751a814",
+      "max": 10230,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_7a3daf19ee744c7b8baeb028db05009a",
+      "value": 10230
+     }
+    },
+    "2e24b7250ee04fbb810e5d6ade107c51": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "2e31d27cc694434aa869896041c72bee": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_0d75dd458e3448a58ea4e19c28e787c0",
+      "placeholder": "​",
+      "style": "IPY_MODEL_0bc5c81047994f5b976a927b8ed47cbc",
+      "value": " 330M/330M [01:17&lt;00:00, 671kB/s]"
+     }
+    },
+    "2eae62f1cc46449dba93f5eda0cb3f1c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "323eb0d9dade4c4fa3a9ad2b973dcbe1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_484f7a55438c47f59365242c4753edba",
+       "IPY_MODEL_c5665d0bc652405c8754474871baab06",
+       "IPY_MODEL_82f96ac9299a4841a550ad3daa0099d0"
+      ],
+      "layout": "IPY_MODEL_f031aaf7fbc648a7b8a2e5faf37df14d"
+     }
+    },
+    "3587d42fa09b4fcdb365956a9bb07c77": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_16c7db587b8e475fa3aa9677385b092a",
+      "placeholder": "​",
+      "style": "IPY_MODEL_23c608994006427caca7975e0d81271f",
+      "value": " 6.21k/6.21k [00:00&lt;00:00, 412kB/s]"
+     }
+    },
+    "35d862a4f00c4493920da3e2eb92b043": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b48f685dc91540f38690f39eace724d5",
+      "placeholder": "​",
+      "style": "IPY_MODEL_ce4b6a4b6fec4ceb907fa436ff940bd2",
+      "value": "Generating validation split: 100%"
+     }
+    },
+    "36c8300bcbb84627a03b94f0eea86ce9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "375ac7a15cea4ce3aa484a806cc82717": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "38deee504dab482983a8b8f340472282": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "38f30da546444f8199673003d0a92dda": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "397dc640630841d7845bf5a8739ce5eb": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3a71257db7bc408d8e4d1fbcaf1dff93": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3c0cacee5997480cbedc0e9d59a62544": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3c33964c8d804600ab5a26d0717c508d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3c6842e0158b4dcc9b93eddfe3279d2a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "3db63ba25e7349a785244c367d53813e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3efccb526dec44bf9801ac13dcc1068d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3f188d6d34774154afc297b13a3eb9e8": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3f6394cb0ea242f28c4ba6b3b2d37e9f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3ff84efe0edc491c884898424be4ae71": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4089323832d04dc2a40e238b5fa256cc": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "40a5a50aeca24f0d8990da97971004d1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "41320a22032c4884affc456f7c6db1c1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "416c65eedcea4a6ea69dae317de79bca": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "42a16474e41343b2a7d46e5930b41b89": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "431174d906f640baa17842fdb3a8714b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "43940212a87d410c82cc9cd15f38a97e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_3db63ba25e7349a785244c367d53813e",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4748461200ae4af883577e2fbb8cb686",
+      "value": " 1.47M/1.47M [00:00&lt;00:00, 1.21MB/s]"
+     }
+    },
+    "4533e8ce655649cba93553c8a2b17f37": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "471d44c8e49e42b89302ef53ab0eb316": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "4748461200ae4af883577e2fbb8cb686": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "47659b15eb284f06bf9735ca2e425646": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "47cf3db935ba4e109843b03a9577c184": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4825c09098e1446a9ed3b653b77894f4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_148c9912cec5473bb6f8533add143cd3",
+      "placeholder": "​",
+      "style": "IPY_MODEL_92dfb889fd22439bb7b5fd31e4991c93",
+      "value": "Clean file runs/Feb07_03-56-51_319afa680fd7/1675742273.001745/events.out.tfevents.1675742273.319afa680fd7.27769.1: 100%"
+     }
+    },
+    "483b46ed1e8148498d54e4d6f4c0ca8d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "484f7a55438c47f59365242c4753edba": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f22598cf4ade4427a1b437fd45aabcc4",
+      "placeholder": "​",
+      "style": "IPY_MODEL_0cd35b1092064f42908ce4123b79a8af",
+      "value": "Downloading (…)&quot;adapter_model.bin&quot;;: 100%"
+     }
+    },
+    "49ed3330fa9645eda8b5aed0fd7cbafe": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b2ad992db5a045668fa55c7393ec7870",
+      "placeholder": "​",
+      "style": "IPY_MODEL_b5fad0f3f2d543ecaed726e52d2d86bb",
+      "value": " 1/1 [00:00&lt;00:00,  1.24it/s]"
+     }
+    },
+    "4a118fa87e424664a2d2ed7c7f58f3fd": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4a3ff00e64b548ce89355778907e48c9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4a44332ff1224a19a5f1c18e2b827759": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4afba780d0f244548a7f28db15b41dc9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_1839e4ed1d3c4975b34c3c050052693f",
+      "placeholder": "​",
+      "style": "IPY_MODEL_1b31bfb0ef4c404698eb2205414170af",
+      "value": "Downloading data files: 100%"
+     }
+    },
+    "4bb8b2d7000f464ba3ff18ce03fcfef4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4cb3d75f80434b48beb6aa4b07c86dfe": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_0957e36be17c43fd89462c5d5ddcec1b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_dffe636233c84dcd9d75f34baf40fa1d",
+      "value": "Computing checksums: 100%"
+     }
+    },
+    "4d1f6114d4034f758bf8cc35485e0056": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_0ba38362cf8647c08b0beb21a2c39442",
+      "placeholder": "​",
+      "style": "IPY_MODEL_65a0aed816c84164a6ee6a41d300fad0",
+      "value": "Download file runs/Feb07_02-43-38_319afa680fd7/events.out.tfevents.1675737843.319afa680fd7.7189.0: 100%"
+     }
+    },
+    "4d653faaedcd497d863bbf2c429ce925": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4e3d482feec9485590d277dfc1d0b3d3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6350637718344d65a757d2919de8c1ab",
+      "max": 2,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_42a16474e41343b2a7d46e5930b41b89",
+      "value": 2
+     }
+    },
+    "4ee1fde44dcf49eda97e1a05173e5bb1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4fc212af0c9b45ebbe334e3dd7f11b59": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "516c6d75bc654d62b95ac235ce84c59c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "52d00532eeee40aa91e8a5c2a10e50a7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7a65e650113e476a8cb66caa92973dd3",
+      "placeholder": "​",
+      "style": "IPY_MODEL_d0c95a20c2664c149886b72fa665d3cf",
+      "value": "Clean file runs/Feb07_02-50-30_319afa680fd7/events.out.tfevents.1675738403.319afa680fd7.10047.2: 100%"
+     }
+    },
+    "5634fd283a9e45d9a55c02ca1b7c784c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4a44332ff1224a19a5f1c18e2b827759",
+      "placeholder": "​",
+      "style": "IPY_MODEL_7e1ac6f28fb340d3bde1e7b4893bb0aa",
+      "value": " 346M/346M [00:02&lt;00:00, 202MB/s]"
+     }
+    },
+    "57c15c64c2374f06a1e0a36bab953ef7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_10c4f5677d1c4af8b3370b7fb1255065",
+      "placeholder": "​",
+      "style": "IPY_MODEL_603dd1541db345879295edc16ace2b0c",
+      "value": "Downloading data: 100%"
+     }
+    },
+    "58e7f5c36d8b4836a868ce89838f1896": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_9d1dff20634a403fb8829469d74301aa",
+      "placeholder": "​",
+      "style": "IPY_MODEL_b2e64f35be2d4fa3bc95c769b78e1dd1",
+      "value": " 10.3k/10.3k [00:00&lt;00:00, 770kB/s]"
+     }
+    },
+    "59792e1ee7074f998d5d4494c09061c6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_3ff84efe0edc491c884898424be4ae71",
+      "placeholder": "​",
+      "style": "IPY_MODEL_5a79a196fd7b49128a9647347f85b364",
+      "value": "Downloading data: 100%"
+     }
+    },
+    "5a79a196fd7b49128a9647347f85b364": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "5b7be0df4db54866a3b6ef9204ba5a89": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_cde9d5cbadf14a5abe294dba0fa5bd2d",
+       "IPY_MODEL_835db77232e74cc18a6b5db2ace40bfd",
+       "IPY_MODEL_6099227eddde44009582b9f24fc96150"
+      ],
+      "layout": "IPY_MODEL_9eb912a195f3461297b7143cb1b04678"
+     }
+    },
+    "5d2f5fb454bc4c16b520e4e96381758f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "VBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "VBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "VBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_dfd2baceac524fe29c0f4a8443b60a71",
+       "IPY_MODEL_90d8e83a6af54184a82e0b81ae7054b9",
+       "IPY_MODEL_1f96ca356b6f41b59275abe93df33f43",
+       "IPY_MODEL_eef81e9bea0c4f5d85e7efa8ebe0463a",
+       "IPY_MODEL_cab6d36980c0423fb75299c09c33facc"
+      ],
+      "layout": "IPY_MODEL_dd38a658218d42d7b051c66de4d4180a"
+     }
+    },
+    "5da11a8c37ae41458ea4491ccdfb4db8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6dac696d99a44ea399a1bd5e18f08428",
+      "placeholder": "​",
+      "style": "IPY_MODEL_b3a8eebed60f4ecab7d508c976e2e56b",
+      "value": "Download file runs/Feb07_03-56-51_319afa680fd7/1675742273.001745/events.out.tfevents.1675742273.319afa680fd7.27769.1: 100%"
+     }
+    },
+    "5dc4129160514a479ffb2f0564aee071": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e4074e524a19455fab810ec454fe8bf1",
+      "max": 10230,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_d67dc70cfc9246f79a59261a69b28b41",
+      "value": 10230
+     }
+    },
+    "5e51957908eb48489357a7c3924ec5c7": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5ee5e11191fc46dd92d4c2f1a7d6d9da": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_128677e1b5b14e63b06b0f81c9cc4df0",
+      "max": 6208,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_22da54e68b1d48f9b3ba55ac1ca56873",
+      "value": 6208
+     }
+    },
+    "5fd1cd8bf125446a96b9438fbbe52710": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "603dd1541db345879295edc16ace2b0c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "60472b5a360f43e89e39d641dabba57b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "6099227eddde44009582b9f24fc96150": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_af7ee2bb7ccc4c00838a2c6b937e4e8b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_84c281446c5b424090a5eecbd733b050",
+      "value": " 9.99k/9.99k [01:17&lt;00:00, 119B/s]"
+     }
+    },
+    "60e6952873524186aad05661a00bd240": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "61b957d3b51643f78a921979072fe3b6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_d7136a7b3d0040d580508fc665b9fb00",
+       "IPY_MODEL_5ee5e11191fc46dd92d4c2f1a7d6d9da",
+       "IPY_MODEL_3587d42fa09b4fcdb365956a9bb07c77"
+      ],
+      "layout": "IPY_MODEL_c1ed0b68884c4d4291cd67c0e685ef18"
+     }
+    },
+    "62818f9421694139bbe1d9ad6e822b10": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "62a0f83cf75d4c59a0601c5ad3a817a7": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": "hidden",
+      "width": null
+     }
+    },
+    "6350637718344d65a757d2919de8c1ab": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "638b918aaacc4c4782b9e16ca66549e8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "63b53da916fe479e8cd495eff8d16df8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "63c07a01593f467f9c0e7c5e283d58ae": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "65a0aed816c84164a6ee6a41d300fad0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "68ef0c8550ee4c00aa8b284d48572610": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7a35d0ddc2da4dd69068214b87bcdd7f",
+      "max": 10337,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_9aac38a8c8694c67a34b2fced0e1a706",
+      "value": 10337
+     }
+    },
+    "6932d2462135413cbc293964eb1c8317": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_3c0cacee5997480cbedc0e9d59a62544",
+      "max": 5777,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_fee3db0deefb410db4c572efd95575bf",
+      "value": 5777
+     }
+    },
+    "6940a405215c4e2caadbe209c677bde0": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "69dcd4770fbc428cb56498b6577e237e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "6b6459f123ef4f24a550cd9ec3c9f809": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "6dac696d99a44ea399a1bd5e18f08428": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6e4983016e4f465b85ab7a472d0e986e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6f19448725b84be4bacc3b699cd065a9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_3c33964c8d804600ab5a26d0717c508d",
+      "placeholder": "​",
+      "style": "IPY_MODEL_f5041033ddf94f459ed8d1747f6b2d6e",
+      "value": "Downloading (…)&quot;pytorch_model.bin&quot;;: 100%"
+     }
+    },
+    "6f1a325b02f54352a0b412d7f4420bbb": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "70af909af7de4161b4a72a8e15d116f3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "70b04a3579a5446f94acd422c70ac50a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_039dd9a4b99e433088a0acd8ba7b519b",
+      "max": 1468812,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_17235d013b7c4cee996d0bbc1cc6c70c",
+      "value": 1468812
+     }
+    },
+    "71f7296ec9be4d9abe1af581722b40fe": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_b98e53eefc1944f193169c4f7a72b799",
+       "IPY_MODEL_1d4a5a5b7d1645a8bf8133935e173082",
+       "IPY_MODEL_d29e3b9102f14f3385e47ae6e27d1ab1"
+      ],
+      "layout": "IPY_MODEL_1e3e374b08964a689cfaac9c826f207b"
+     }
+    },
+    "7541b2304cc5466cb2369c0025d2d243": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "75b76841f06249a0a77c7e38b85a14c8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e6ce3e626b1744c7ba3da26d1fde5fa5",
+      "placeholder": "​",
+      "style": "IPY_MODEL_8e1237963bb5479f93318c5cdc6a8593",
+      "value": "Download file runs/Feb07_03-56-51_319afa680fd7/events.out.tfevents.1675742272.319afa680fd7.27769.0: 100%"
+     }
+    },
+    "7654b707840e4afb9bab8218418fd096": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "76cf84387a7c43608ad018188eef4114": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4d653faaedcd497d863bbf2c429ce925",
+      "placeholder": "​",
+      "style": "IPY_MODEL_d10f2e9c25f2417f9728aa8e43acf677",
+      "value": "Downloading readme: 100%"
+     }
+    },
+    "77deda3ef342432f9b0f684a9b32e248": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b48fcbe51098482aad8798670111d60d",
+      "placeholder": "​",
+      "style": "IPY_MODEL_7654b707840e4afb9bab8218418fd096",
+      "value": "Clean file runs/Feb07_02-43-38_319afa680fd7/1675737843.2328734/events.out.tfevents.1675737843.319afa680fd7.7189.1: 100%"
+     }
+    },
+    "77df794cb4e4491e80ee20bbd2801a89": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "77f7230186b14c628f5094f9fd8d82da": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_855a0f70b9ac489a86b53792e119329a",
+       "IPY_MODEL_9005e9db560d4e89880bdd18403ef9e1",
+       "IPY_MODEL_070a734e268045098977db14c6565777"
+      ],
+      "layout": "IPY_MODEL_91ec8a3f10804d629cdfd47c61411c91"
+     }
+    },
+    "79351db5d2e1468e9b91d7bd2274612e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_2d8a53b2a2bf42b9aa9cb2d9978ccee2",
+      "max": 10824,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_69dcd4770fbc428cb56498b6577e237e",
+      "value": 10824
+     }
+    },
+    "793ebaa3acc6482bb135ca0ca864be4d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "7a35d0ddc2da4dd69068214b87bcdd7f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7a3daf19ee744c7b8baeb028db05009a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "7a65e650113e476a8cb66caa92973dd3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7b8f0cbb552447549aed602f937fcfb4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7bd32cf88c154303a76759d674795856": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_a907de6474cf45cb91b3f2efc40821b9",
+       "IPY_MODEL_5dc4129160514a479ffb2f0564aee071",
+       "IPY_MODEL_16620105b32f434eb77b0df56ed49e45"
+      ],
+      "layout": "IPY_MODEL_7b8f0cbb552447549aed602f937fcfb4"
+     }
+    },
+    "7c038ffcc1dc4e3fbfed17d94327353a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7c1b6f271fff4d60be39d291c73bfb75": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4089323832d04dc2a40e238b5fa256cc",
+      "placeholder": "​",
+      "style": "IPY_MODEL_2d867c65533e482a96db93bc5a09b8cb",
+      "value": " 5.00G/5.00G [03:32&lt;00:00, 24.6MB/s]"
+     }
+    },
+    "7d5831ee2a1c4e649f5508631d64e7cc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_2eae62f1cc46449dba93f5eda0cb3f1c",
+      "placeholder": "​",
+      "style": "IPY_MODEL_e8026bcb0e2c4b14bc6c84537c8c4ae9",
+      "value": " 5.64k/5.64k [01:17&lt;?, ?B/s]"
+     }
+    },
+    "7e1ac6f28fb340d3bde1e7b4893bb0aa": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "7e243f4a30c645b080e688fb706b4548": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "828a652d92724ba4888d924846a79374": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4bb8b2d7000f464ba3ff18ce03fcfef4",
+      "max": 4203,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_793ebaa3acc6482bb135ca0ca864be4d",
+      "value": 4203
+     }
+    },
+    "82f96ac9299a4841a550ad3daa0099d0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_3a71257db7bc408d8e4d1fbcaf1dff93",
+      "placeholder": "​",
+      "style": "IPY_MODEL_ccd34ccf2c864c609a0b4fcee7327b31",
+      "value": " 2.69M/2.69M [00:00&lt;00:00, 13.0MB/s]"
+     }
+    },
+    "835db77232e74cc18a6b5db2ace40bfd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d2469e1f1daf4d4cb0faf35ce90f6445",
+      "max": 10227,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_e667b14a3c0e41c6a16c4be453f10378",
+      "value": 10227
+     }
+    },
+    "8378c214cd044bfb97c452d811df748f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b6a1b7db4afe44c792907f6377cde35c",
+      "placeholder": "​",
+      "style": "IPY_MODEL_dca7d0a0d2aa479083d81a54489d3717",
+      "value": "Downloading builder script: 100%"
+     }
+    },
+    "83d6fbf463264c71a4ec8775e26c7c38": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "849ac914c3cc49d29d619dd4f532d74c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_4cb3d75f80434b48beb6aa4b07c86dfe",
+       "IPY_MODEL_ff39519704b64e68b69ec06aea02791e",
+       "IPY_MODEL_e0f2599ed04c424f896e503630034e84"
+      ],
+      "layout": "IPY_MODEL_1674d568877048368c842c21ffaac811"
+     }
+    },
+    "84c281446c5b424090a5eecbd733b050": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "851fb5ac25db4bb287a6dbe948278eec": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "852b01d8592b4d8aa2c4297d6cf75f78": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "855a0f70b9ac489a86b53792e119329a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_0465571b25714ecda9dfe6ff1a495a87",
+      "placeholder": "​",
+      "style": "IPY_MODEL_dc078f0db3e54199bef0c11ee5e6297e",
+      "value": "Clean file pytorch_model.bin: 100%"
+     }
+    },
+    "86103f87819b440b8464f4460f50375e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "864b6bb42f0b46a2a7bcd0d8cbac3837": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c1af5e6c4259480eac652f6c6269ff5f",
+      "max": 345636463,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_194dd0bcc350480c9ddd3e4ef17efc3a",
+      "value": 345636463
+     }
+    },
+    "86fca0e29e7a4dc8b2234134014958f8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_8378c214cd044bfb97c452d811df748f",
+       "IPY_MODEL_828a652d92724ba4888d924846a79374",
+       "IPY_MODEL_cfd59ddfe85f4585865df8df47fd491f"
+      ],
+      "layout": "IPY_MODEL_94f39a2f3baa4bb2bffd1b99e8a31367"
+     }
+    },
+    "87581c98cd174bb684ec259066d047ea": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "87aad727ec964c9d97346ac02ed0caae": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8886c333aa104900a3bb4a1904756661": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "8934f66530644f0882e292bfd5458b0f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "8a0a77b9ebd74caabb8f8a764c289a5c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8b7713310a814991aec7929fa715ec7c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8b9f5bca0898404b91032befbd019fa3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8ba66e043f8a4975bd77ecd343401260": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_1f8c65025b63466192897a32a92182e9",
+      "placeholder": "​",
+      "style": "IPY_MODEL_ffc13c11355b46bb9cafcb17f3e1535e",
+      "value": "Download file runs/Feb07_02-50-30_319afa680fd7/events.out.tfevents.1675738246.319afa680fd7.10047.0: 100%"
+     }
+    },
+    "8bf8a843d65142bbad81de74aa8573f6": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8da58936a6e64529af9a3e3f314e49cb": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8e1237963bb5479f93318c5cdc6a8593": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "8ecde04d15ab47f9b78d561615ca567d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "9005e9db560d4e89880bdd18403ef9e1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c3f7788abe754cb3bfbee3fadda54916",
+      "max": 345949677,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_fe93399cc15f4f29b6a37f6a65cf8c9b",
+      "value": 345949677
+     }
+    },
+    "9013fd35e17f44bfb7a068833adaf167": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "90d8e83a6af54184a82e0b81ae7054b9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "PasswordModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "PasswordModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "PasswordView",
+      "continuous_update": true,
+      "description": "Token:",
+      "description_tooltip": null,
+      "disabled": false,
+      "layout": "IPY_MODEL_b2688e34899a449e8d1f6ddb5a66bb85",
+      "placeholder": "​",
+      "style": "IPY_MODEL_dd4edb4de5e14dfbbee418dba0bb3573",
+      "value": ""
+     }
+    },
+    "9102cc38ee9942ac91dc66eda069ddcb": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "9123141f7c164d458a21e54fc579fa66": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "91ec8a3f10804d629cdfd47c61411c91": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "91f6edc592394a0bad250e68d3c22017": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "920293e203f14b45b61233e1bb6f1214": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "923cf8641a7946f69ff41fb88b2b86f8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_9d14ba8675fb4c689dd821ce7794abb6",
+       "IPY_MODEL_6932d2462135413cbc293964eb1c8317",
+       "IPY_MODEL_7d5831ee2a1c4e649f5508631d64e7cc"
+      ],
+      "layout": "IPY_MODEL_70af909af7de4161b4a72a8e15d116f3"
+     }
+    },
+    "9281c5aec5b84411a05e4762125388d9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "92dfb889fd22439bb7b5fd31e4991c93": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "93788683ef8e4c71bc1c0b3b9cc7219c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a2671f512e404f64bfa3f376449f6947",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a61a30ebaac846c1b7a03c6a93127aad",
+      "value": " 357/357 [01:17&lt;?, ?B/s]"
+     }
+    },
+    "9397ebc3ad2e4141a1405bb1bd0aa315": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_6f19448725b84be4bacc3b699cd065a9",
+       "IPY_MODEL_864b6bb42f0b46a2a7bcd0d8cbac3837",
+       "IPY_MODEL_5634fd283a9e45d9a55c02ca1b7c784c"
+      ],
+      "layout": "IPY_MODEL_87aad727ec964c9d97346ac02ed0caae"
+     }
+    },
+    "93c81a011c0a435aa90a3f4f1d549510": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_bcbb4d8ce16b473eae2ad03f1bea2520",
+      "max": 160,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_2c86eb6c67f44af590937d0f1db09333",
+      "value": 160
+     }
+    },
+    "9434b43de9954c83a4311432bdd68376": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "94f39a2f3baa4bb2bffd1b99e8a31367": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "95449e7030324f99b148bbaedc15c155": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_be1ae63f3e804e23abe7739e9f4577fb",
+       "IPY_MODEL_d5b95aa9cab446f88d61e9f4a25a8e2f",
+       "IPY_MODEL_2e31d27cc694434aa869896041c72bee"
+      ],
+      "layout": "IPY_MODEL_4a3ff00e64b548ce89355778907e48c9"
+     }
+    },
+    "9609eaf0792345b2ab457cb7188ee14a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "972f831792cd4e89af109462dd5b9210": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "980d2f61332f414d9888b76e78774be4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_cbc0ba8e49a740fcae7b94fe7edb8107",
+       "IPY_MODEL_b3f07ef160a7425880ffe362008d4400",
+       "IPY_MODEL_49ed3330fa9645eda8b5aed0fd7cbafe"
+      ],
+      "layout": "IPY_MODEL_f96302d0c2d849c5b5a0206b65e461ab"
+     }
+    },
+    "98d32ec7fbf54effadb886bc4ec6ce79": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "9a5e108d8b5a41ae95a619bfc6c8f3a9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "9aac38a8c8694c67a34b2fced0e1a706": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "9b1bfa11ee3746c38155c4505abfaa86": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "9b216287b8694bcc9960a356adf15504": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "9b4b67731a7a4bc59be132b53c24eae8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c53429e699e64b3d8895a355bbd947a6",
+      "placeholder": "​",
+      "style": "IPY_MODEL_2bfd04824f2e4fd6844dd38e46dbbbdf",
+      "value": "adapter_model.bin: 100%"
+     }
+    },
+    "9d14ba8675fb4c689dd821ce7794abb6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d04c1c4d04fc4928b4a2a0e860f996e0",
+      "placeholder": "​",
+      "style": "IPY_MODEL_98d32ec7fbf54effadb886bc4ec6ce79",
+      "value": "Download file runs/Feb07_02-50-30_319afa680fd7/1675738246.1183074/events.out.tfevents.1675738246.319afa680fd7.10047.1: 100%"
+     }
+    },
+    "9d1b9ac29dcc41e08ada578916f20a3c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_ef7c7fe37c8d459da6d20f4ccbea3fb8",
+       "IPY_MODEL_93c81a011c0a435aa90a3f4f1d549510",
+       "IPY_MODEL_da87efdf06d74b0aba268320ba7882f9"
+      ],
+      "layout": "IPY_MODEL_0a0e75829d6c4031bc917ac2044d9e47"
+     }
+    },
+    "9d1dff20634a403fb8829469d74301aa": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "9eb912a195f3461297b7143cb1b04678": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "9fb3579ca9714141a7857a513c379f03": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a0929e66406644dbb09bbdc9c58d488d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a100435005a34d428b9ae615f49bb1a1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a1981bfcdb6d401e9a521e18b511cf9d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a1d5bc95f1e24e3293414e08aa5c8bd5": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a1df731c5c5f4f9cafa19323a750ebea": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_260fdda06c214ed499f69fac4077d476",
+      "placeholder": "​",
+      "style": "IPY_MODEL_aed3b4e6110442398c25d37456b78b5d",
+      "value": "Clean file runs/Feb07_02-50-30_319afa680fd7/1675738246.1183074/events.out.tfevents.1675738246.319afa680fd7.10047.1: 100%"
+     }
+    },
+    "a2671f512e404f64bfa3f376449f6947": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a29d758fb7f147c7ad1108f140caf23a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_aa9b6ac2785c4a5abd1189edd60698eb",
+      "placeholder": "​",
+      "style": "IPY_MODEL_cfab815edc1f42898b656c0f4a3b366b",
+      "value": " 75750/75750 [00:59&lt;00:00, 1687.83 examples/s]"
+     }
+    },
+    "a2b51be9304342e39431b82957eb4b25": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a450c318d99a477c9f7341458ad4bc8d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4533e8ce655649cba93553c8a2b17f37",
+      "placeholder": "​",
+      "style": "IPY_MODEL_63b53da916fe479e8cd495eff8d16df8",
+      "value": " 10.6k/10.6k [01:17&lt;00:00, 127B/s]"
+     }
+    },
+    "a61a30ebaac846c1b7a03c6a93127aad": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a849dcc9c7f742d49c874597d8c693c5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a907de6474cf45cb91b3f2efc40821b9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_3f6394cb0ea242f28c4ba6b3b2d37e9f",
+      "placeholder": "​",
+      "style": "IPY_MODEL_02a0b01d31a34a1c924786037fecba09",
+      "value": "Clean file runs/Feb07_02-50-30_319afa680fd7/events.out.tfevents.1675738246.319afa680fd7.10047.0: 100%"
+     }
+    },
+    "aa68207e72b0467cb9a4354dc231db2f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "aa9b6ac2785c4a5abd1189edd60698eb": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "acae77f181ed43a1b29412c575435a7f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e54b7fc2f9b94118ab97f2736862f77d",
+      "placeholder": "​",
+      "style": "IPY_MODEL_dfe97442852c4338843c65333b25623d",
+      "value": " 5.64k/5.64k [01:17&lt;00:00, 61.5B/s]"
+     }
+    },
+    "ad2068dd9c2040f6ae44bc873fa7b6e7": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ad6adbe84ac940ffbf89017a269a3e75": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "adb09cebab13484a8d75a338eaba7b0c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_9fb3579ca9714141a7857a513c379f03",
+      "max": 3579,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_edc0742a08a445a594139200c7f03c60",
+      "value": 3579
+     }
+    },
+    "aed3b4e6110442398c25d37456b78b5d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "af1a42626ba7452189fbb5987b159b9c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d4aa1670fdab463bb0a0e6fe104988bc",
+      "max": 357,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_8934f66530644f0882e292bfd5458b0f",
+      "value": 357
+     }
+    },
+    "af5231ecf6e2489b80cdcd435b5e3451": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_af6a4a054a5d451b9fe256bf60a09c21",
+      "placeholder": "​",
+      "style": "IPY_MODEL_afb1f0681bce47e1ba718900d0430f34",
+      "value": " 25250/25250 [00:42&lt;00:00, 617.60 examples/s]"
+     }
+    },
+    "af6a4a054a5d451b9fe256bf60a09c21": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "af7ee2bb7ccc4c00838a2c6b937e4e8b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "afb1f0681bce47e1ba718900d0430f34": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "b1b6922df40c4af69b00b4e85db770c4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f6a9243d46cb4c0fbdf3f80f7074f6c5",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a2b51be9304342e39431b82957eb4b25",
+      "value": "Clean file training_args.bin: 100%"
+     }
+    },
+    "b21331417d084aba80f919b71933bc2c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "b2688e34899a449e8d1f6ddb5a66bb85": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b2ad992db5a045668fa55c7393ec7870": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b2e64f35be2d4fa3bc95c769b78e1dd1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "b377e94780fb4e1db3b9678717e04fc1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b3a8eebed60f4ecab7d508c976e2e56b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "b3f07ef160a7425880ffe362008d4400": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_1150e391e753424da7d65bda10463da4",
+      "max": 1,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_e6e36d744e1244aeb7eb0c4ce392372d",
+      "value": 1
+     }
+    },
+    "b48f685dc91540f38690f39eace724d5": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b48fcbe51098482aad8798670111d60d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b5fad0f3f2d543ecaed726e52d2d86bb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "b6a1b7db4afe44c792907f6377cde35c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b8e180259fd94096884f7e48a53b0fce": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b98e53eefc1944f193169c4f7a72b799": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b377e94780fb4e1db3b9678717e04fc1",
+      "placeholder": "​",
+      "style": "IPY_MODEL_86103f87819b440b8464f4460f50375e",
+      "value": "Downloading metadata: 100%"
+     }
+    },
+    "bacd429b42d843299cb75224db3afb1e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "bb453686ce9f4342aaae9a9fb3500d2c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_1a4ab138be9940f081514b914fdc4623",
+       "IPY_MODEL_cc59f6643acb4054ad6df56e90d3d2a8",
+       "IPY_MODEL_236638d673934823828ee57face78184"
+      ],
+      "layout": "IPY_MODEL_29de968ad50543418c6865fdf003a568"
+     }
+    },
+    "bc71a433928e4870b56a3d81e35e6351": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "bcbb4d8ce16b473eae2ad03f1bea2520": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "bcef9cf2b00c46878f07c48875f7d194": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "bd9e7cb0f25445739ebcdff0d3112052": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_52d00532eeee40aa91e8a5c2a10e50a7",
+       "IPY_MODEL_21c75049df804ac4ac7bc6349a639056",
+       "IPY_MODEL_041f73c9a038411aa6d59cf8a93f6d47"
+      ],
+      "layout": "IPY_MODEL_b8e180259fd94096884f7e48a53b0fce"
+     }
+    },
+    "bda7e5662f2e4fa292752efd4947c5f6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_4825c09098e1446a9ed3b653b77894f4",
+       "IPY_MODEL_f544720498e44c49add78550b46edb3a",
+       "IPY_MODEL_24b3737dc76c4d4f9ba2603c653a3ce2"
+      ],
+      "layout": "IPY_MODEL_2ab99fb38f8d4bef85d9833bb628fa00"
+     }
+    },
+    "be1ae63f3e804e23abe7739e9f4577fb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d947ec84b16c4781959427b610328ab9",
+      "placeholder": "​",
+      "style": "IPY_MODEL_9123141f7c164d458a21e54fc579fa66",
+      "value": "Download file pytorch_model.bin: 100%"
+     }
+    },
+    "be1ec4b9b8964810867b0e00bcc4868f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "be29ee88a7ec489b8320f7306d78931d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_a1df731c5c5f4f9cafa19323a750ebea",
+       "IPY_MODEL_bf2e140f54d74df09663d3fcf1660d0c",
+       "IPY_MODEL_acae77f181ed43a1b29412c575435a7f"
+      ],
+      "layout": "IPY_MODEL_87581c98cd174bb684ec259066d047ea"
+     }
+    },
+    "be71e6438e0e49759d2f72feec520cae": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "bf2e140f54d74df09663d3fcf1660d0c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8da58936a6e64529af9a3e3f314e49cb",
+      "max": 5777,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_9a5e108d8b5a41ae95a619bfc6c8f3a9",
+      "value": 5777
+     }
+    },
+    "c1af5e6c4259480eac652f6c6269ff5f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c1ed0b68884c4d4291cd67c0e685ef18": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c2032e5054ac4604832957cb6e2e69ca": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e3047557ae7f40e2aecccf1afad36f3f",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4fc212af0c9b45ebbe334e3dd7f11b59",
+      "value": " 489k/489k [00:00&lt;00:00, 2.24MB/s]"
+     }
+    },
+    "c2f4b407a47f4d958986035188c6ece8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_75b76841f06249a0a77c7e38b85a14c8",
+       "IPY_MODEL_79351db5d2e1468e9b91d7bd2274612e",
+       "IPY_MODEL_c6ce0e9bdd90400f9cf2debf9165758c"
+      ],
+      "layout": "IPY_MODEL_138198ec50a9494889319d6c94da92bd"
+     }
+    },
+    "c3178221dc074657bc0e585c4cfe326d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c3f7788abe754cb3bfbee3fadda54916": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c53429e699e64b3d8895a355bbd947a6": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c5665d0bc652405c8754474871baab06": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8b7713310a814991aec7929fa715ec7c",
+      "max": 2688263,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_fcc8254622324f8ea965e12e4d4966cd",
+      "value": 2688263
+     }
+    },
+    "c5670295387a4c199571a2a21a6b69dc": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c5718d031b9942f4b8bf331a8543db29": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_35d862a4f00c4493920da3e2eb92b043",
+       "IPY_MODEL_16b464f168d844cba5eb0c91ab4fb91c",
+       "IPY_MODEL_af5231ecf6e2489b80cdcd435b5e3451"
+      ],
+      "layout": "IPY_MODEL_62a0f83cf75d4c59a0601c5ad3a817a7"
+     }
+    },
+    "c580d3a6e99e48fab09b3ce799711802": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_4afba780d0f244548a7f28db15b41dc9",
+       "IPY_MODEL_4e3d482feec9485590d277dfc1d0b3d3",
+       "IPY_MODEL_23436ea247dd43d8829ca143a49637c5"
+      ],
+      "layout": "IPY_MODEL_9609eaf0792345b2ab457cb7188ee14a"
+     }
+    },
+    "c6ce0e9bdd90400f9cf2debf9165758c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_cb3ab56aa43e4b94b978764caa6057a7",
+      "placeholder": "​",
+      "style": "IPY_MODEL_2e24b7250ee04fbb810e5d6ade107c51",
+      "value": " 10.6k/10.6k [01:17&lt;?, ?B/s]"
+     }
+    },
+    "c778798c234d45b5a4ae2f250e3706f9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c8267c689fb14afc9a8eb3ecb6f4fd4c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_fc9d0c314ca14826993fe1f24b070b5d",
+      "placeholder": "​",
+      "style": "IPY_MODEL_bc71a433928e4870b56a3d81e35e6351",
+      "value": "Download file training_args.bin: 100%"
+     }
+    },
+    "c910ae80ec1a4718915e9a861215f27c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_245c5418ca084fb6bc0b027576a1f789",
+       "IPY_MODEL_d0bc0e6038eb46dbbc5f5593d4c285ca",
+       "IPY_MODEL_a450c318d99a477c9f7341458ad4bc8d"
+      ],
+      "layout": "IPY_MODEL_02ac19466e24404a92e769ed60604881"
+     }
+    },
+    "cab6d36980c0423fb75299c09c33facc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_15bd2dcdbf4b4e74b9db09bdb8822e61",
+      "placeholder": "​",
+      "style": "IPY_MODEL_ecf73dd75420460399bfd04d8cd81f90",
+      "value": "\n<b>Pro Tip:</b> If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks. </center>"
+     }
+    },
+    "cb3ab56aa43e4b94b978764caa6057a7": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "cb52fa97c659430a8bd71dcd76245a7f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": "hidden",
+      "width": null
+     }
+    },
+    "cbc0ba8e49a740fcae7b94fe7edb8107": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_fcc7ad16a0b14d96acd9be9e03ac6af9",
+      "placeholder": "​",
+      "style": "IPY_MODEL_1a08961f063346ccae206a863ab7df6b",
+      "value": "Upload 1 LFS files: 100%"
+     }
+    },
+    "cc59f6643acb4054ad6df56e90d3d2a8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8a0a77b9ebd74caabb8f8a764c289a5c",
+      "max": 502,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_d8ac6df8420a423eb048b4db04c8925c",
+      "value": 502
+     }
+    },
+    "ccd34ccf2c864c609a0b4fcee7327b31": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "cd5b2433cc404ac7b1bb35c6a55f6874": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_851fb5ac25db4bb287a6dbe948278eec",
+      "max": 4996278331,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_471d44c8e49e42b89302ef53ab0eb316",
+      "value": 4996278331
+     }
+    },
+    "cde9d5cbadf14a5abe294dba0fa5bd2d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6f1a325b02f54352a0b412d7f4420bbb",
+      "placeholder": "​",
+      "style": "IPY_MODEL_e8c2cfdaf0eb413189d93924eae757c7",
+      "value": "Clean file runs/Feb07_02-43-38_319afa680fd7/events.out.tfevents.1675737843.319afa680fd7.7189.0: 100%"
+     }
+    },
+    "ce16ac2b3ff244e6bd7dd58daa9f4f7f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ce18faf7b68140a3a8247330b356e05b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "ce4b6a4b6fec4ceb907fa436ff940bd2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "cf024daa51f74777b98028df10dbc9c5": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "cf815c0979644cd6ad2c681fa96c0648": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6940a405215c4e2caadbe209c677bde0",
+      "placeholder": "​",
+      "style": "IPY_MODEL_b21331417d084aba80f919b71933bc2c",
+      "value": " 3.50k/3.50k [01:17&lt;00:00, 33.0B/s]"
+     }
+    },
+    "cfab815edc1f42898b656c0f4a3b366b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "cfd59ddfe85f4585865df8df47fd491f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_bcef9cf2b00c46878f07c48875f7d194",
+      "placeholder": "​",
+      "style": "IPY_MODEL_47659b15eb284f06bf9735ca2e425646",
+      "value": " 4.20k/4.20k [00:00&lt;00:00, 321kB/s]"
+     }
+    },
+    "d04c1c4d04fc4928b4a2a0e860f996e0": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d0bc0e6038eb46dbbc5f5593d4c285ca": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7c038ffcc1dc4e3fbfed17d94327353a",
+      "max": 10824,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_91f6edc592394a0bad250e68d3c22017",
+      "value": 10824
+     }
+    },
+    "d0c95a20c2664c149886b72fa665d3cf": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "d10f2e9c25f2417f9728aa8e43acf677": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "d1ff50e1b871429a85df8cf10e73ffb1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d2469e1f1daf4d4cb0faf35ce90f6445": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d25f3ebb577749d89e2e6d2a72f6ca5f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "d29e3b9102f14f3385e47ae6e27d1ab1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_fc612aaed5644b84959a1958b0240dda",
+      "placeholder": "​",
+      "style": "IPY_MODEL_36c8300bcbb84627a03b94f0eea86ce9",
+      "value": " 5.56k/5.56k [00:00&lt;00:00, 399kB/s]"
+     }
+    },
+    "d4aa1670fdab463bb0a0e6fe104988bc": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d5b95aa9cab446f88d61e9f4a25a8e2f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_83d6fbf463264c71a4ec8775e26c7c38",
+      "max": 345949677,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_f02443fbda394fefa162f4ff5b2d2ce7",
+      "value": 345949677
+     }
+    },
+    "d5c5396ea2f54ff0aeb9be58b59c253b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ButtonStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ButtonStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "button_color": null,
+      "font_weight": ""
+     }
+    },
+    "d67dc70cfc9246f79a59261a69b28b41": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "d68194cf7d264df7820f27eb4d070de2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d9329cb3c1704691b6a36c293bcbf41b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_dfa468dd89174d97bcaabbda0ed8e117",
+      "value": " 3.50k/3.50k [01:17&lt;?, ?B/s]"
+     }
+    },
+    "d7136a7b3d0040d580508fc665b9fb00": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_9102cc38ee9942ac91dc66eda069ddcb",
+      "placeholder": "​",
+      "style": "IPY_MODEL_416c65eedcea4a6ea69dae317de79bca",
+      "value": "Downloading builder script: 100%"
+     }
+    },
+    "d7c394bc6a3249e9b3fcbae2ebd25eb7": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d7d43177c750412cb1522eb08c01d2d9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_9013fd35e17f44bfb7a068833adaf167",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a849dcc9c7f742d49c874597d8c693c5",
+      "value": "Downloading data: 100%"
+     }
+    },
+    "d8ac6df8420a423eb048b4db04c8925c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "d9329cb3c1704691b6a36c293bcbf41b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d947ec84b16c4781959427b610328ab9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d9c15769da2b49e4b67d43d95be30cd5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_4d1f6114d4034f758bf8cc35485e0056",
+       "IPY_MODEL_223a13f77e2e49a09660890eb4213b30",
+       "IPY_MODEL_1639075b181f4945ac32af116b22d1d7"
+      ],
+      "layout": "IPY_MODEL_ad6adbe84ac940ffbf89017a269a3e75"
+     }
+    },
+    "da13543779034424aaf6f5c4a96f0457": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_2d13b401dcf94089a4a78a62f05bdce3",
+       "IPY_MODEL_dbc00727fa1c4e00aacf627c04527649",
+       "IPY_MODEL_e0d98c36e5d242b2905adf8167ac348a"
+      ],
+      "layout": "IPY_MODEL_483b46ed1e8148498d54e4d6f4c0ca8d"
+     }
+    },
+    "da87efdf06d74b0aba268320ba7882f9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a100435005a34d428b9ae615f49bb1a1",
+      "placeholder": "​",
+      "style": "IPY_MODEL_8886c333aa104900a3bb4a1904756661",
+      "value": " 160/160 [00:00&lt;00:00, 8.36kB/s]"
+     }
+    },
+    "db6b68a237cf4e93ae6383448b773e47": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "dbaa70ad4f1d4496a670601fe447116d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "dbc00727fa1c4e00aacf627c04527649": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_3efccb526dec44bf9801ac13dcc1068d",
+      "max": 5773,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_8ecde04d15ab47f9b78d561615ca567d",
+      "value": 5773
+     }
+    },
+    "dc078f0db3e54199bef0c11ee5e6297e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "dca7d0a0d2aa479083d81a54489d3717": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "dcd1c1f4fc014c4aa9ebdaf3c533a061": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_26520bc6555d41d9951ea0219dc4b5d7",
+      "max": 75750,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_60472b5a360f43e89e39d641dabba57b",
+      "value": 75750
+     }
+    },
+    "dcefc9ba538e4da2b75f9372a4c5b5bf": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "dd38a658218d42d7b051c66de4d4180a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": "center",
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": "flex",
+      "flex": null,
+      "flex_flow": "column",
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": "50%"
+     }
+    },
+    "dd4edb4de5e14dfbbee418dba0bb3573": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "ddf88cbfaaef4a55babf480816db7d28": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "de92f68231294aefb249f400475bc9a4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "dfa468dd89174d97bcaabbda0ed8e117": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "dfd2baceac524fe29c0f4a8443b60a71": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f34be236ef9c42448ecf2957160990f7",
+      "placeholder": "​",
+      "style": "IPY_MODEL_38deee504dab482983a8b8f340472282",
+      "value": "<center> <img\nsrc=https://huggingface.co/front/assets/huggingface_logo-noborder.svg\nalt='Hugging Face'> <br> Copy a token from <a\nhref=\"https://huggingface.co/settings/tokens\" target=\"_blank\">your Hugging Face\ntokens page</a> and paste it below. <br> Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file. </center>"
+     }
+    },
+    "dfe97442852c4338843c65333b25623d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "dffe636233c84dcd9d75f34baf40fa1d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "e0d98c36e5d242b2905adf8167ac348a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_ddf88cbfaaef4a55babf480816db7d28",
+      "placeholder": "​",
+      "style": "IPY_MODEL_38f30da546444f8199673003d0a92dda",
+      "value": " 5.64k/5.64k [01:17&lt;?, ?B/s]"
+     }
+    },
+    "e0f2599ed04c424f896e503630034e84": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7e243f4a30c645b080e688fb706b4548",
+      "placeholder": "​",
+      "style": "IPY_MODEL_db6b68a237cf4e93ae6383448b773e47",
+      "value": " 1/1 [00:14&lt;00:00, 14.25s/it]"
+     }
+    },
+    "e302923a9df24e5fa8fff79c203ead9f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e3047557ae7f40e2aecccf1afad36f3f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e33243b001274d02a25f5940ba41ecf6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_40a5a50aeca24f0d8990da97971004d1",
+      "max": 2688263,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_be71e6438e0e49759d2f72feec520cae",
+      "value": 2688263
+     }
+    },
+    "e4074e524a19455fab810ec454fe8bf1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e4694cffcb574863a255e9022c8ddf5d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "e4a4122ff32a41a1917459709224fc6a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_8ba66e043f8a4975bd77ecd343401260",
+       "IPY_MODEL_2e0bb2dcd85640d7b85d80469ea9f9f3",
+       "IPY_MODEL_1c208beced884b9291c5bcb7b4f71680"
+      ],
+      "layout": "IPY_MODEL_3f188d6d34774154afc297b13a3eb9e8"
+     }
+    },
+    "e54b7fc2f9b94118ab97f2736862f77d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e667b14a3c0e41c6a16c4be453f10378": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "e6ce3e626b1744c7ba3da26d1fde5fa5": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e6e36d744e1244aeb7eb0c4ce392372d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "e7144551e74b46529b00a61f580a183d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e8026bcb0e2c4b14bc6c84537c8c4ae9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "e83fd078f467406da0baf26e18b39e89": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_9b4b67731a7a4bc59be132b53c24eae8",
+       "IPY_MODEL_e33243b001274d02a25f5940ba41ecf6",
+       "IPY_MODEL_06e4c619e366427a8ff4c358196ecd12"
+      ],
+      "layout": "IPY_MODEL_bacd429b42d843299cb75224db3afb1e"
+     }
+    },
+    "e88c3ad56ef24e4d8281898b08ff6f4b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_1fdc59cbb8724c618ce6e586e2c9723f",
+      "placeholder": "​",
+      "style": "IPY_MODEL_dbaa70ad4f1d4496a670601fe447116d",
+      "value": " 5.64k/5.64k [01:17&lt;?, ?B/s]"
+     }
+    },
+    "e8c2cfdaf0eb413189d93924eae757c7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "ea2217bba8574c7890a411f27da0c147": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_b1b6922df40c4af69b00b4e85db770c4",
+       "IPY_MODEL_2b8bc04ac3104592bf950e349c034c2d",
+       "IPY_MODEL_cf815c0979644cd6ad2c681fa96c0648"
+      ],
+      "layout": "IPY_MODEL_7541b2304cc5466cb2369c0025d2d243"
+     }
+    },
+    "eaf2c76a172d4da6846c6face18a3b58": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "eb864284052c46b28b93fc79bfed740f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "eca3b1f4ad76430483a221470e592c13": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e302923a9df24e5fa8fff79c203ead9f",
+      "placeholder": "​",
+      "style": "IPY_MODEL_f7b9abca32ec42edad5ec6e52882f732",
+      "value": " 5.64k/5.64k [01:17&lt;00:00, 61.4B/s]"
+     }
+    },
+    "ecf73dd75420460399bfd04d8cd81f90": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "edb0d1ba5e114af9b6705969f58ece7b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "edc0742a08a445a594139200c7f03c60": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "ee103846621b4c0e8e1266599b99f6ee": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e7144551e74b46529b00a61f580a183d",
+      "placeholder": "​",
+      "style": "IPY_MODEL_9b1bfa11ee3746c38155c4505abfaa86",
+      "value": "Generating train split: 100%"
+     }
+    },
+    "eef81e9bea0c4f5d85e7efa8ebe0463a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ButtonModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ButtonModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ButtonView",
+      "button_style": "",
+      "description": "Login",
+      "disabled": false,
+      "icon": "",
+      "layout": "IPY_MODEL_c778798c234d45b5a4ae2f250e3706f9",
+      "style": "IPY_MODEL_d5c5396ea2f54ff0aeb9be58b59c253b",
+      "tooltip": ""
+     }
+    },
+    "ef7c7fe37c8d459da6d20f4ccbea3fb8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4ee1fde44dcf49eda97e1a05173e5bb1",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a0929e66406644dbb09bbdc9c58d488d",
+      "value": "Downloading (…)rocessor_config.json: 100%"
+     }
+    },
+    "f02443fbda394fefa162f4ff5b2d2ce7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "f031aaf7fbc648a7b8a2e5faf37df14d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f0b0cad40fbd461ca7bdcdbb5f442f57": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_76cf84387a7c43608ad018188eef4114",
+       "IPY_MODEL_68ef0c8550ee4c00aa8b284d48572610",
+       "IPY_MODEL_58e7f5c36d8b4836a868ce89838f1896"
+      ],
+      "layout": "IPY_MODEL_9b216287b8694bcc9960a356adf15504"
+     }
+    },
+    "f22598cf4ade4427a1b437fd45aabcc4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f34be236ef9c42448ecf2957160990f7": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f3991aaad13a4c50a7809483b7907b7b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4a118fa87e424664a2d2ed7c7f58f3fd",
+      "max": 5773,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_852b01d8592b4d8aa2c4297d6cf75f78",
+      "value": 5773
+     }
+    },
+    "f5041033ddf94f459ed8d1747f6b2d6e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "f544720498e44c49add78550b46edb3a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_9281c5aec5b84411a05e4762125388d9",
+      "max": 5777,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_f5b5d6ace35a4a82bfcf2549b93c8558",
+      "value": 5777
+     }
+    },
+    "f5b5d6ace35a4a82bfcf2549b93c8558": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "f6a9243d46cb4c0fbdf3f80f7074f6c5": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f7b9abca32ec42edad5ec6e52882f732": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "f96302d0c2d849c5b5a0206b65e461ab": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f981fb4aae504045aa10889dceeb6cac": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "fc612aaed5644b84959a1958b0240dda": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "fc9d0c314ca14826993fe1f24b070b5d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "fcc7ad16a0b14d96acd9be9e03ac6af9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "fcc8254622324f8ea965e12e4d4966cd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "fd9df81594724b88b54b4e3e1b19370a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_c8267c689fb14afc9a8eb3ecb6f4fd4c",
+       "IPY_MODEL_adb09cebab13484a8d75a338eaba7b0c",
+       "IPY_MODEL_d68194cf7d264df7820f27eb4d070de2"
+      ],
+      "layout": "IPY_MODEL_8bf8a843d65142bbad81de74aa8573f6"
+     }
+    },
+    "fdb3673fdbf24468a9965f13196b78ed": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_0b82dbc29d514f4e9e012fd755948e52",
+       "IPY_MODEL_af1a42626ba7452189fbb5987b159b9c",
+       "IPY_MODEL_93788683ef8e4c71bc1c0b3b9cc7219c"
+      ],
+      "layout": "IPY_MODEL_6e4983016e4f465b85ab7a472d0e986e"
+     }
+    },
+    "fdf282b234fe4a1a8ab452ac04511b7d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_59792e1ee7074f998d5d4494c09061c6",
+       "IPY_MODEL_cd5b2433cc404ac7b1bb35c6a55f6874",
+       "IPY_MODEL_7c1b6f271fff4d60be39d291c73bfb75"
+      ],
+      "layout": "IPY_MODEL_074f38bd3a9d49719188e8860fb1b5d3"
+     }
+    },
+    "fe93399cc15f4f29b6a37f6a65cf8c9b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "fea27a80cd2f4b4dba84ecdfefd2722c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "fee3db0deefb410db4c572efd95575bf": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "fee4fba960ac41ed97984467da41f319": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_ee103846621b4c0e8e1266599b99f6ee",
+       "IPY_MODEL_dcd1c1f4fc014c4aa9ebdaf3c533a061",
+       "IPY_MODEL_a29d758fb7f147c7ad1108f140caf23a"
+      ],
+      "layout": "IPY_MODEL_cb52fa97c659430a8bd71dcd76245a7f"
+     }
+    },
+    "ff39519704b64e68b69ec06aea02791e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_dcefc9ba538e4da2b75f9372a4c5b5bf",
+      "max": 1,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_77df794cb4e4491e80ee20bbd2801a89",
+      "value": 1
+     }
+    },
+    "ffc13c11355b46bb9cafcb17f3e1535e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    }
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
diff --git a/examples/image_classification/image_classification_timm_peft_lora.ipynb b/examples/image_classification/image_classification_timm_peft_lora.ipynb
new file mode 100644
index 0000000..1e2f222
--- /dev/null
+++ b/examples/image_classification/image_classification_timm_peft_lora.ipynb
@@ -0,0 +1,744 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "4ef57047",
+   "metadata": {},
+   "source": [
+    "# Using PEFT with timm"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "80561acc",
+   "metadata": {},
+   "source": [
+    "`peft` allows us to train any model with LoRA as long as the layer type is supported. Since `Conv2D` is one of the supported layer types, it makes sense to test it on image models.\n",
+    "\n",
+    "In this short notebook, we will demonstrate this with an image classification task using [`timm`](https://huggingface.co/docs/timm/index)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aa26c285",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "552b9040",
+   "metadata": {},
+   "source": [
+    "Make sure that you have the latest version of `peft` installed. To ensure that, run this in your Python environment:\n",
+    "    \n",
+    "    python -m pip install --upgrade peft\n",
+    "    \n",
+    "Also, ensure that `timm` is installed:\n",
+    "\n",
+    "    python -m pip install --upgrade timm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "e600b7d5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import timm\n",
+    "import torch\n",
+    "from PIL import Image\n",
+    "from timm.data import resolve_data_config\n",
+    "from timm.data.transforms_factory import create_transform"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "73a2ae54",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import peft\n",
+    "from datasets import load_dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "82c628fd",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<torch._C.Generator at 0x7f3ff0004410>"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "torch.manual_seed(0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "701ab69c",
+   "metadata": {},
+   "source": [
+    "## Loading the pre-trained base model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "20bff51a",
+   "metadata": {},
+   "source": [
+    "We use a small pretrained `timm` model, `PoolFormer`. Find more info on its [model card](https://huggingface.co/timm/poolformer_m36.sail_in1k)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "495cb3d6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_id_timm = \"timm/poolformer_m36.sail_in1k\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2dc06f9b",
+   "metadata": {},
+   "source": [
+    "We tell `timm` that we deal with 3 classes, to ensure that the classification layer has the correct size."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "090564bc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = timm.create_model(model_id_timm, pretrained=True, num_classes=3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "beca5794",
+   "metadata": {},
+   "source": [
+    "These are the transformations steps necessary to process the image."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "9df2e113",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "transform = create_transform(**resolve_data_config(model.pretrained_cfg, model=model))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3f809dfa",
+   "metadata": {},
+   "source": [
+    "## Data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a398fe22",
+   "metadata": {},
+   "source": [
+    "For this exercise, we use the \"beans\" dataset. More details on the dataset can be found on [its datasets page](https://huggingface.co/datasets/beans). For our purposes, what's important is that we have image inputs and the target we're trying to predict is one of three classes for each image."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "0fddc704",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Found cached dataset beans (/home/vinh/.cache/huggingface/datasets/beans/default/0.0.0/90c755fb6db1c0ccdad02e897a37969dbf070bed3755d4391e269ff70642d791)\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "05592574da474b81ab736d6babb5e19d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/3 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "ds = load_dataset(\"beans\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "c544052e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ds_train = ds[\"train\"]\n",
+    "ds_valid = ds[\"validation\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "6f0532c4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=500x500>"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ds_train[0][\"image\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "880ea6c4",
+   "metadata": {},
+   "source": [
+    "We define a small processing function which is responsible for loading and transforming the images, as well as extracting the labels."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "142df842",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def process(batch):\n",
+    "    x = torch.cat([transform(img).unsqueeze(0) for img in batch[\"image\"]])\n",
+    "    y = torch.tensor(batch[\"labels\"])\n",
+    "    return {\"x\": x, \"y\": y}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "9744257b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ds_train.set_transform(process)\n",
+    "ds_valid.set_transform(process)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "282374be",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_loader = torch.utils.data.DataLoader(ds_train, batch_size=32)\n",
+    "valid_loader = torch.utils.data.DataLoader(ds_valid, batch_size=32)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5dcd3329",
+   "metadata": {},
+   "source": [
+    "## Training"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "969bc374",
+   "metadata": {},
+   "source": [
+    "This is just a function that performs the train loop, nothing fancy happening."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "b9fc9588",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def train(model, optimizer, criterion, train_dataloader, valid_dataloader, epochs):\n",
+    "    for epoch in range(epochs):\n",
+    "        model.train()\n",
+    "        train_loss = 0\n",
+    "        for batch in train_dataloader:\n",
+    "            xb, yb = batch[\"x\"], batch[\"y\"]\n",
+    "            xb, yb = xb.to(device), yb.to(device)\n",
+    "            outputs = model(xb)\n",
+    "            lsm = torch.nn.functional.log_softmax(outputs, dim=-1)\n",
+    "            loss = criterion(lsm, yb)\n",
+    "            train_loss += loss.detach().float()\n",
+    "            loss.backward()\n",
+    "            optimizer.step()\n",
+    "            optimizer.zero_grad()\n",
+    "\n",
+    "        model.eval()\n",
+    "        valid_loss = 0\n",
+    "        correct = 0\n",
+    "        n_total = 0\n",
+    "        for batch in valid_dataloader:\n",
+    "            xb, yb = batch[\"x\"], batch[\"y\"]\n",
+    "            xb, yb = xb.to(device), yb.to(device)\n",
+    "            with torch.no_grad():\n",
+    "                outputs = model(xb)\n",
+    "            lsm = torch.nn.functional.log_softmax(outputs, dim=-1)\n",
+    "            loss = criterion(lsm, yb)\n",
+    "            valid_loss += loss.detach().float()\n",
+    "            correct += (outputs.argmax(-1) == yb).sum().item()\n",
+    "            n_total += len(yb)\n",
+    "\n",
+    "        train_loss_total = (train_loss / len(train_dataloader)).item()\n",
+    "        valid_loss_total = (valid_loss / len(valid_dataloader)).item()\n",
+    "        valid_acc_total = correct / n_total\n",
+    "        print(f\"{epoch=:<2}  {train_loss_total=:.4f}  {valid_loss_total=:.4f}  {valid_acc_total=:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3fd58357",
+   "metadata": {},
+   "source": [
+    "### Selecting which layers to fine-tune with LoRA"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7987321c",
+   "metadata": {},
+   "source": [
+    "Let's take a look at the layers of our model. We only print the first 30, since there are quite a few:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "55a7be4d",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[('', timm.models.metaformer.MetaFormer),\n",
+       " ('stem', timm.models.metaformer.Stem),\n",
+       " ('stem.conv', torch.nn.modules.conv.Conv2d),\n",
+       " ('stem.norm', torch.nn.modules.linear.Identity),\n",
+       " ('stages', torch.nn.modules.container.Sequential),\n",
+       " ('stages.0', timm.models.metaformer.MetaFormerStage),\n",
+       " ('stages.0.downsample', torch.nn.modules.linear.Identity),\n",
+       " ('stages.0.blocks', torch.nn.modules.container.Sequential),\n",
+       " ('stages.0.blocks.0', timm.models.metaformer.MetaFormerBlock),\n",
+       " ('stages.0.blocks.0.norm1', timm.layers.norm.GroupNorm1),\n",
+       " ('stages.0.blocks.0.token_mixer', timm.models.metaformer.Pooling),\n",
+       " ('stages.0.blocks.0.token_mixer.pool', torch.nn.modules.pooling.AvgPool2d),\n",
+       " ('stages.0.blocks.0.drop_path1', torch.nn.modules.linear.Identity),\n",
+       " ('stages.0.blocks.0.layer_scale1', timm.models.metaformer.Scale),\n",
+       " ('stages.0.blocks.0.res_scale1', torch.nn.modules.linear.Identity),\n",
+       " ('stages.0.blocks.0.norm2', timm.layers.norm.GroupNorm1),\n",
+       " ('stages.0.blocks.0.mlp', timm.layers.mlp.Mlp),\n",
+       " ('stages.0.blocks.0.mlp.fc1', torch.nn.modules.conv.Conv2d),\n",
+       " ('stages.0.blocks.0.mlp.act', torch.nn.modules.activation.GELU),\n",
+       " ('stages.0.blocks.0.mlp.drop1', torch.nn.modules.dropout.Dropout),\n",
+       " ('stages.0.blocks.0.mlp.norm', torch.nn.modules.linear.Identity),\n",
+       " ('stages.0.blocks.0.mlp.fc2', torch.nn.modules.conv.Conv2d),\n",
+       " ('stages.0.blocks.0.mlp.drop2', torch.nn.modules.dropout.Dropout),\n",
+       " ('stages.0.blocks.0.drop_path2', torch.nn.modules.linear.Identity),\n",
+       " ('stages.0.blocks.0.layer_scale2', timm.models.metaformer.Scale),\n",
+       " ('stages.0.blocks.0.res_scale2', torch.nn.modules.linear.Identity),\n",
+       " ('stages.0.blocks.1', timm.models.metaformer.MetaFormerBlock),\n",
+       " ('stages.0.blocks.1.norm1', timm.layers.norm.GroupNorm1),\n",
+       " ('stages.0.blocks.1.token_mixer', timm.models.metaformer.Pooling),\n",
+       " ('stages.0.blocks.1.token_mixer.pool', torch.nn.modules.pooling.AvgPool2d)]"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "[(n, type(m)) for n, m in model.named_modules()][:30]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "09af9349",
+   "metadata": {},
+   "source": [
+    "Most of these layers are not good targets for LoRA, but we see a couple that should interest us. Their names are `'stages.0.blocks.0.mlp.fc1'`, etc. With a bit of regex, we can match them easily.\n",
+    "\n",
+    "Also, we should inspect the name of the classification layer, since we want to train that one too!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "8b98d9ef",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[('head.global_pool.flatten', torch.nn.modules.linear.Identity),\n",
+       " ('head.norm', timm.layers.norm.LayerNorm2d),\n",
+       " ('head.flatten', torch.nn.modules.flatten.Flatten),\n",
+       " ('head.drop', torch.nn.modules.linear.Identity),\n",
+       " ('head.fc', torch.nn.modules.linear.Linear)]"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "[(n, type(m)) for n, m in model.named_modules()][-5:]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "00e75b78",
+   "metadata": {},
+   "source": [
+    "    config = peft.LoraConfig(\n",
+    "        r=8,\n",
+    "        target_modules=r\".*\\.mlp\\.fc\\d|head\\.fc\",\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "23814d70",
+   "metadata": {},
+   "source": [
+    "Okay, this gives us all the information we need to fine-tune this model. With a bit of regex, we match the convolutional layers that should be targeted for LoRA. We also want to train the classification layer `'head.fc'` (without LoRA), so we add it to the `modules_to_save`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "81029587",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "config = peft.LoraConfig(r=8, target_modules=r\".*\\.mlp\\.fc\\d\", modules_to_save=[\"head.fc\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e05876bc",
+   "metadata": {},
+   "source": [
+    "Finally, let's create the `peft` model, the optimizer and criterion, and we can get started. As shown below, less than 2% of the model's total parameters are updated thanks to `peft`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8cc5c5db",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "trainable params: 1,064,454 || all params: 56,467,974 || trainable%: 1.88505789139876\n"
+     ]
+    }
+   ],
+   "source": [
+    "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "peft_model = peft.get_peft_model(model, config).to(device)\n",
+    "optimizer = torch.optim.Adam(peft_model.parameters(), lr=2e-4)\n",
+    "criterion = torch.nn.CrossEntropyLoss()\n",
+    "peft_model.print_trainable_parameters()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "9e557e42",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=0   train_loss_total=1.2999  valid_loss_total=1.0624  valid_acc_total=0.4436\n",
+      "epoch=1   train_loss_total=1.0200  valid_loss_total=0.8906  valid_acc_total=0.7594\n",
+      "epoch=2   train_loss_total=0.8874  valid_loss_total=0.6894  valid_acc_total=0.8045\n",
+      "epoch=3   train_loss_total=0.7440  valid_loss_total=0.4797  valid_acc_total=0.8045\n",
+      "epoch=4   train_loss_total=0.6025  valid_loss_total=0.3419  valid_acc_total=0.8120\n",
+      "epoch=5   train_loss_total=0.4820  valid_loss_total=0.2589  valid_acc_total=0.8421\n",
+      "epoch=6   train_loss_total=0.3567  valid_loss_total=0.2101  valid_acc_total=0.8722\n",
+      "epoch=7   train_loss_total=0.2835  valid_loss_total=0.1385  valid_acc_total=0.9098\n",
+      "epoch=8   train_loss_total=0.1815  valid_loss_total=0.1108  valid_acc_total=0.9474\n",
+      "epoch=9   train_loss_total=0.1341  valid_loss_total=0.0785  valid_acc_total=0.9699\n",
+      "CPU times: user 4min 3s, sys: 36.3 s, total: 4min 40s\n",
+      "Wall time: 3min 32s\n"
+     ]
+    }
+   ],
+   "source": [
+    "%time train(peft_model, optimizer, criterion, train_loader, valid_dataloader=valid_loader, epochs=10)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "94162859",
+   "metadata": {},
+   "source": [
+    "We get an accuracy of ~0.97, despite only training a tiny amount of parameters. That's a really nice result."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9c16bad8",
+   "metadata": {},
+   "source": [
+    "## Sharing the model through Hugging Face Hub"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2e1e16c7",
+   "metadata": {},
+   "source": [
+    "### Pushing the model to Hugging Face Hub"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ec596b3b",
+   "metadata": {},
+   "source": [
+    "If we want to share the fine-tuned weights with the world, we can upload them to Hugging Face Hub like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "b583579d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "user = \"BenjaminB\"  # put your user name here\n",
+    "model_name = \"peft-lora-with-timm-model\"\n",
+    "model_id = f\"{user}/{model_name}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "f1db67e4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "aed1f9c3fa334be1b5f208efe5ba27e6",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Upload 1 LFS files:   0%|          | 0/1 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "cdf92a4415874c448b3d0de0f4392af7",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "adapter_model.bin:   0%|          | 0.00/4.30M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "peft_model.push_to_hub(model_id);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "80155ca7",
+   "metadata": {},
+   "source": [
+    "As we can see, the adapter size is only 4.3 MB. The original model was 225 MB. That's a very big saving."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7d831e60",
+   "metadata": {},
+   "source": [
+    "### Loading the model from HF Hub"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d8a5c641",
+   "metadata": {},
+   "source": [
+    "Now, it only takes one step to load the model from HF Hub. To do this, we can use `PeftModel.from_pretrained`, passing our base model and the model ID:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "abc69183",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "18bf9a39a6de446f93da8b4bb57ea0dd",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading adapter_model.bin:   0%|          | 0.00/4.30M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "base_model = timm.create_model(model_id_timm, pretrained=True, num_classes=3)\n",
+    "loaded = peft.PeftModel.from_pretrained(base_model, model_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "19882a0b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "x = ds_train[:1][\"x\"]\n",
+    "y_peft = peft_model(x.to(device))\n",
+    "y_loaded = loaded(x)\n",
+    "torch.allclose(y_peft.cpu(), y_loaded)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "339d2ab2",
+   "metadata": {},
+   "source": [
+    "### Clean up"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bc262bcd",
+   "metadata": {},
+   "source": [
+    "Finally, as a clean up step, you may want to delete the repo."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "2ea3f068",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from huggingface_hub import delete_repo"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "f525b375",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "delete_repo(model_id)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/int8_training/Finetune_flan_t5_large_bnb_peft.ipynb b/examples/int8_training/Finetune_flan_t5_large_bnb_peft.ipynb
new file mode 100755
index 0000000..591853d
--- /dev/null
+++ b/examples/int8_training/Finetune_flan_t5_large_bnb_peft.ipynb
@@ -0,0 +1,8123 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "lw1cWgq-DI5k",
+   "metadata": {
+    "id": "lw1cWgq-DI5k"
+   },
+   "source": [
+    "# Fine-tune FLAN-T5 using `bitsandbytes`, `peft` & `transformers` 🤗 "
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "kBFPA3-aDT7H",
+   "metadata": {
+    "id": "kBFPA3-aDT7H"
+   },
+   "source": "In this notebook we will see how to properly use `peft` , `transformers` & `bitsandbytes` to fine-tune `flan-t5-large` in a google colab!\n\nWe will finetune the model on [`zeroshot/twitter-financial-news-sentiment`](https://huggingface.co/datasets/zeroshot/twitter-financial-news-sentiment) dataset, that consists of financial tweets labeled with sentiment (bearish, bullish, or neutral).\n\nNote that you could use the same notebook to fine-tune `flan-t5-xl` as well, but you would need to shard the models first to avoid CPU RAM issues on Google Colab, check [these weights](https://huggingface.co/ybelkada/flan-t5-xl-sharded-bf16)."
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ShAuuHCDDkvk",
+   "metadata": {
+    "id": "ShAuuHCDDkvk"
+   },
+   "source": [
+    "## Install requirements"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "DRQ4ZrJTDkSy",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "DRQ4ZrJTDkSy",
+    "outputId": "31b108ee-a34c-4a1f-a970-6fa1809b64c5"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m76.3/76.3 MB\u001b[0m \u001b[31m10.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m462.8/462.8 KB\u001b[0m \u001b[31m45.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m199.7/199.7 KB\u001b[0m \u001b[31m26.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m132.0/132.0 KB\u001b[0m \u001b[31m20.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m190.3/190.3 KB\u001b[0m \u001b[31m26.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m213.0/213.0 KB\u001b[0m \u001b[31m26.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m140.6/140.6 KB\u001b[0m \u001b[31m20.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25h  Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n",
+      "  Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n",
+      "  Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
+      "  Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n",
+      "  Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n",
+      "  Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m7.6/7.6 MB\u001b[0m \u001b[31m65.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25h  Building wheel for transformers (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
+      "  Building wheel for peft (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n"
+     ]
+    }
+   ],
+   "source": [
+    "!pip install -q datasets==3.6.0 accelerate\n",
+    "!pip install -q git+https://github.com/bitsandbytes-foundation/bitsandbytes.git\n",
+    "!pip install -q git+https://github.com/huggingface/transformers.git@main git+https://github.com/huggingface/peft.git@main"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "QBdCIrizDxFw",
+   "metadata": {
+    "id": "QBdCIrizDxFw"
+   },
+   "source": [
+    "## Import model and tokenizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dd3c5acc",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 350,
+     "referenced_widgets": [
+      "59782bac41834abbbd6cbd6614c2e57b",
+      "8252a05cb70b46ec8b0480062ea1cb71",
+      "b77afc7c1f184de0970feb2df8ac5285",
+      "23e494a586cf47d1afa5e619abfcdbba",
+      "bdfb4a04e48246a4b0890f52d6dd424b",
+      "8669a890db6c456cbc3ada28976be30b",
+      "9e5afa2048c74754816b34a34171fcb0",
+      "5bfebc75ec424c6cb41b33d210d28d2b",
+      "ef2fa44d0105457c9aed3812633dd329",
+      "5a6b38b8fc1345e8bd4e8f3aaea546c9",
+      "57d4ca686af34205aca630b1c61d4aea",
+      "dbdb787728184aa1a6906f96c5e6f929",
+      "e3be963920c84c7fbe7e0bc61b8e778d",
+      "1275c5a5c88b435a897f88a19c54a0a5",
+      "81d2f0953e104fc1ad57295819b6b689",
+      "61ab054f49884b1fadf529a39ccc37dc",
+      "924e6a8308fc47af929aca1987a12f09",
+      "c1757a5b684f4496a4b0e3db544bf44b",
+      "a3bb3f44c1754082a4f5169431c5b760",
+      "a0186b2194df4a0a9cd1ac49054d68da",
+      "bcda86e43607436583f1fbfee08a9786",
+      "55cf3bcee7c745948b39eea5f65fc62b",
+      "aa2c51ad05c14a02a13e5c047779fc05",
+      "2ce6779fa5904471945fa5738510af64",
+      "bdff3b35dcdf49e5ba2c5c2498773cb7",
+      "6994741f3113493b9d5bba278b8732f5",
+      "808a41f78a7c4ae0b6aafee59c6234ae",
+      "c7771479ae4e4efab744fad6da586fd3",
+      "2d7cb8f5477244ce82e7cec5a9f7ee39",
+      "df8fbdbe9bc341e3a39a7bda99b70be2",
+      "179a912bbd1e454eba503782b675efa8",
+      "232fe29739b74dabb3b558c33835eb32",
+      "978bbbf33d304588af971d22bb2a3690",
+      "1b839f5b472e44148c9e02a12550fade",
+      "b560fc36ee8f424f9590e04a042046fe",
+      "0845ceae96ca4c95ad4ebebac46b691f",
+      "e1769695dffd4ebeb79a63ff4812fa9e",
+      "ec73524ed7f14ea0b67f07d72eada173",
+      "f2a36b126c1b41848e61b0c581ff8c4b",
+      "6a40d6535f9e4b5b9c9283a1cd67687a",
+      "03abf3bb217e4622b31cd869ed11aa00",
+      "24f9db6df6d54ad6bac4891b65184799",
+      "f66e179caa8b4393bed19a0488821c47",
+      "cfc7aa04c11d408c9c12cdbd9cff4bb5",
+      "65aacfc888014bdea55253428b2569c0",
+      "82849bb4d5da452e87a18ca749ce5d7b",
+      "2d2fc7abb9fb411c810b2fbeb54d67cc",
+      "96e2d208830f48cd821be7e59643c93e",
+      "8d79b7d0c3cb4f8d99fb20941c35856f",
+      "2b4d68606bdf4758b812f5a8057af595",
+      "f9620e01cd6749f88b722a42ff68c502",
+      "06c3d8c44fbe4f0886cf397d9a3c4b81",
+      "d72e8b3419f240f2bdce253cce9d24e3",
+      "2fe0a2fa22a0498da983ec38150216e6",
+      "f3784e85cef34bdba64b611a1f5883e4",
+      "d7d9e2e2090d4226ad89e5ba9cec33df",
+      "5cc620a232bf4d418c3fc882f4c1cd0c",
+      "f742450a607c4ed0bff98ac9b7685d40",
+      "e87b05e685b040f7a99450bfbab72433",
+      "e1c8e6f843604161bbb6cbd269488469",
+      "34333da7eb0f49a6b83df76e35dcdd93",
+      "c708031a279e4e55ac7833e6697f93bd",
+      "e293930c8e2c4eadbda53005e21ec450",
+      "945ac449c2e84fd6b5a7805b017343f2",
+      "06cea508d7504b228f6cebc66742d200",
+      "9d0500a0f5f74be39e5edfbbcd7a64fc",
+      "0363c4d4dc1449148b09061763ea119a",
+      "f4ff06e2c48d4e58abe64cb7f41dd886",
+      "7fb7e3e2c75d4d03a98e581d4ead0f00",
+      "b8087054f46c44cab9bd62fa23fbf9de",
+      "85ae7ed1ec244a89aeb9f4552c2c9462",
+      "4f57cfa7cb3b4199babf82dc9d93b074",
+      "053de11f995247f6b851909a6a8dfc16",
+      "43d7a9b421be430286b5eb8441d6d465",
+      "ebc26228160046c48279d71770c928d8",
+      "5192bc282c4847cb9df8365fc22a6cc2",
+      "608e9f7a14054573b9bd07f0f74b6345"
+     ]
+    },
+    "id": "dd3c5acc",
+    "outputId": "fab398b4-dace-4f44-89e5-687ec74b18eb"
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "59782bac41834abbbd6cbd6614c2e57b",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading (…)lve/main/config.json:   0%|          | 0.00/662 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Overriding dtype=None with `dtype=torch.float16` due to requirements of `bitsandbytes` to enable model loading in mixed int8. Either pass dtype=torch.float16 or don't pass this argument at all to remove this warning.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "dbdb787728184aa1a6906f96c5e6f929",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading (…)\"pytorch_model.bin\";:   0%|          | 0.00/3.13G [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "===================================BUG REPORT===================================\n",
+      "Welcome to bitsandbytes. For bug reports, please submit your error trace to: https://github.com/TimDettmers/bitsandbytes/issues\n",
+      "================================================================================\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "aa2c51ad05c14a02a13e5c047779fc05",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading (…)neration_config.json:   0%|          | 0.00/147 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "1b839f5b472e44148c9e02a12550fade",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading (…)okenizer_config.json:   0%|          | 0.00/2.54k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "65aacfc888014bdea55253428b2569c0",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading (…)\"spiece.model\";:   0%|          | 0.00/792k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d7d9e2e2090d4226ad89e5ba9cec33df",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading (…)/main/tokenizer.json:   0%|          | 0.00/2.42M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "0363c4d4dc1449148b09061763ea119a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading (…)cial_tokens_map.json:   0%|          | 0.00/2.20k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Select CUDA device index\n",
+    "import os\n",
+    "import torch\n",
+    "\n",
+    "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\"\n",
+    "\n",
+    "from datasets import load_dataset\n",
+    "from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, BitsAndBytesConfig\n",
+    "\n",
+    "model_name = \"google/flan-t5-large\"\n",
+    "\n",
+    "model = AutoModelForSeq2SeqLM.from_pretrained(model_name, quantization_config=BitsAndBytesConfig(load_in_8bit=True))\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "VwcHieQzD_dl",
+   "metadata": {
+    "id": "VwcHieQzD_dl"
+   },
+   "source": [
+    "## Prepare model for training"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "4o3ePxrjEDzv",
+   "metadata": {
+    "id": "4o3ePxrjEDzv"
+   },
+   "source": [
+    "Some pre-processing needs to be done before training such an int8 model using `peft`, therefore let's import an utiliy function `prepare_model_for_kbit_training` that will: \n",
+    "- Casts all the non `int8` modules to full precision (`fp32`) for stability\n",
+    "- Add a `forward_hook` to the input embedding layer to enable gradient computation of the input hidden states\n",
+    "- Enable gradient checkpointing for more memory-efficient training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1629ebcb",
+   "metadata": {
+    "id": "1629ebcb"
+   },
+   "outputs": [],
+   "source": [
+    "from peft import prepare_model_for_kbit_training\n",
+    "\n",
+    "model = prepare_model_for_kbit_training(model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "iCpAgawAEieu",
+   "metadata": {
+    "id": "iCpAgawAEieu"
+   },
+   "source": [
+    "## Load your `PeftModel` \n",
+    "\n",
+    "Here we will use LoRA (Low-Rank Adaptators) to train our model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "17566ae3",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "17566ae3",
+    "outputId": "66cbd0f3-815d-4d68-c0a3-6b2e5f46b021"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "trainable params: 4718592 || all params: 787868672 || trainable%: 0.5989059049678777\n"
+     ]
+    }
+   ],
+   "source": [
+    "from peft import LoraConfig, get_peft_model, TaskType\n",
+    "\n",
+    "\n",
+    "def print_trainable_parameters(model):\n",
+    "    \"\"\"\n",
+    "    Prints the number of trainable parameters in the model.\n",
+    "    \"\"\"\n",
+    "    trainable_params = 0\n",
+    "    all_param = 0\n",
+    "    for _, param in model.named_parameters():\n",
+    "        all_param += param.numel()\n",
+    "        if param.requires_grad:\n",
+    "            trainable_params += param.numel()\n",
+    "    print(\n",
+    "        f\"trainable params: {trainable_params} || all params: {all_param} || trainable%: {100 * trainable_params / all_param}\"\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "lora_config = LoraConfig(\n",
+    "    r=16, lora_alpha=32, target_modules=[\"q\", \"v\"], lora_dropout=0.05, bias=\"none\", task_type=\"SEQ_2_SEQ_LM\"\n",
+    ")\n",
+    "\n",
+    "\n",
+    "model = get_peft_model(model, lora_config)\n",
+    "print_trainable_parameters(model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "mGkwIgNXyS7U",
+   "metadata": {
+    "id": "mGkwIgNXyS7U"
+   },
+   "source": [
+    "As you can see, here we are only training 0.6% of the parameters of the model! This is a huge memory gain that will enable us to fine-tune the model without any memory issue."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "HsG0x6Z7FwjZ",
+   "metadata": {
+    "id": "HsG0x6Z7FwjZ"
+   },
+   "source": "## Load and process data\n\nHere we will use [`zeroshot/twitter-financial-news-sentiment`](https://huggingface.co/datasets/zeroshot/twitter-financial-news-sentiment) dataset to fine-tune our model on sentiment classification on financial tweets."
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "242cdfae",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 297,
+     "referenced_widgets": [
+      "ce0213e9d6aa45c5a9ac9954fbe15f62",
+      "7cfda0921e5a4f378e90e057447f3b3d",
+      "aaa1477cfabb4767b755e902d3b99e61",
+      "7b6bddd4ca51495dbc2fceba7c50706f",
+      "6317d49813234f5b9103b249cf648c2c",
+      "10aa4e3aca57438ea7af97b60208ac81",
+      "f14657da8e1e4298a96e3885eb4eee93",
+      "a38c0fedf90a4f3cbb4680b5f85bbf2f",
+      "c6a28dcd88c1487ab17aef6946ada876",
+      "2c47350dd2164d4a8164be2ec6d16391",
+      "8fceec1018574003884e082b2a5c23bf",
+      "f2dc5e8a31c348358aca916274899e8b",
+      "2bfb7c240e154769a0d58a3ceaa20212",
+      "8f339c9070f046dab46ebc35c1cc2dba",
+      "34db70b6e6ec475699fd23a2d6c3a973",
+      "e24115bb662c428e89c2c4421915e632",
+      "8b41d2e9f7424dc898446e7f428dc757",
+      "8035fd17e29a48d7b415c531607216a6",
+      "d618ec6be7d14a239b3bc74172616bf2",
+      "3c8349539946412a93a51d9087306ea4",
+      "645e26fd9b3f4919a43eca3592475324",
+      "83f196eb5d9549cda4d48008fa7b1386",
+      "94437f56e5a44fa3bb08c9d798b2eaeb",
+      "0f091d25adf34ade835b094eb5b952a3",
+      "9d599c2a4d9f4f2db1e4b3183c18eb94",
+      "aa91ad725da147bc8cab70f931d82672",
+      "fb6877c376e0430296b2746513f60931",
+      "2de762c8d96b48c7bbd72fad566611b2",
+      "8ef94158b0584f0eb55582bf8b6594c6",
+      "bf7a49e0e4a64df6b1b1c66e5e73c3a6",
+      "d27ff6c2869242b98564b0e03d68b413",
+      "8a2bd1b4d9ba47ef9e77048e3d2d1e83",
+      "dbd908538859410f9c20536fe5acb328",
+      "cce112d791dd4b748908756e785ab555",
+      "be11f6865f6c41b5a57b2b7f4a85e14c",
+      "c31cffaa6934407399856235a2f3af54",
+      "bca79be79b6d4a68b148255bba86ea96",
+      "5093700dd3a14cc1a283d18a4a0e17a7",
+      "85e5c1a9b7ac4e6e884213a636d0aaa1",
+      "216e5237b31944cbab006d9761ade0a1",
+      "a4d6de73a37148bf9303a273d13cd091",
+      "f79eeece093f4b0e9de6dbc346a3fa19",
+      "74e88bd01bf14e0e9f772f993c92eb77",
+      "401bd48c5b2d48eb86a1499912ee2b44",
+      "41d8dbe04d0c4ec4a9d19662f9e11920",
+      "1bf4434ccea34cbc803d88f37aff2065",
+      "07f5dcd5a6e24d819e0ce9e54a5bfafa",
+      "b8944b7027d449b4a7fc752978f463b1",
+      "baf53867f52046c182a2b1755f02e136",
+      "808cea6c94264f0c9990d6dbcf538419",
+      "96e4e44a789a46ce8239b260bf6e3dc8",
+      "2f20ea2be56a4992827f960d8c6d7b7f",
+      "2871be167d4f44859eb2bc0baf0788f6",
+      "390b88f67b84451999b0845483905144",
+      "be9c243b74d944eb82ca1fe4ada6721d",
+      "26e1bfb23d3a4797a8dbb9c4ed2aeb22",
+      "c0deb08457be4a3ebb3947e33f7ce1df",
+      "6a85e6040bf440569a23495d67a66de1",
+      "30c87e87c4b845b8bb27507596f4d18c",
+      "f061a6deaa73484aa04f219bba6a4329",
+      "cba58e0b316b439ab035b917a40c630c",
+      "de6718209a7a42b0809e97fcd97e09ed",
+      "66535de16cca41cd9ba44b6de40c4e6a",
+      "51335afbfc02480fbc8d2c6200f3e18e",
+      "dd53a486f7b5403a81e2be89cbbda719",
+      "5626348c213b48faa61651c08cd1bb24",
+      "283bdd8a4daf4f5ca1ec6e9ed19c46ec",
+      "9d68afcb8e26420cb91ea1eb872c80c4",
+      "40171f7e3e1f46b4955548bbb58cac6c",
+      "b8bb0aed01d04e8dad560df1b051e1e4",
+      "da99eed13d524b8fb95dbc563eb2d044",
+      "a72073cfb8b4422a98ca581c4e5d18b8",
+      "3a5712c976b04af0975804b34344dfcf",
+      "356cb75b5f4247d9be9d4d2aa15f2dc1",
+      "64670ef7321140de89ca726b5eeae337",
+      "93fe5a8fafbc44b496309d1a8da77ac5",
+      "a9effc13b52044a5bc0d6a2a1088396f",
+      "8d35a041dbfb4747aea427e76890551a",
+      "74efd6bfe71e4dc599a7fc76574ff154",
+      "1ed1bfefa6534085869130ea533ff4b1",
+      "fd08c4fbe5d84dd893d87a5e2f2d082d",
+      "87ce7c58b18146f3ac73970d7f8079ac",
+      "39dd984ff238456e9e485c077f9e87a8",
+      "28e24fc8410d486c904f249579d31b8b",
+      "6b05e37f42b04701a97bab91ae92c2dd",
+      "2ec84788d5dd4a04a24ccf66dad457ad",
+      "6f30253108fb4dce9c3de029457ef6f1",
+      "1fa2a7e3ff3c4c99ab95e96a28624846"
+     ]
+    },
+    "id": "242cdfae",
+    "outputId": "3122a25f-4299-4c3e-cd93-3a507f9f0d91"
+   },
+   "outputs": [],
+   "source": [
+    "# loading dataset\n",
+    "dataset = load_dataset(\"zeroshot/twitter-financial-news-sentiment\")\n",
+    "dataset = dataset[\"train\"].train_test_split(test_size=0.1)\n",
+    "dataset[\"validation\"] = dataset[\"test\"]\n",
+    "del dataset[\"test\"]\n",
+    "\n",
+    "if hasattr(dataset[\"train\"].features[\"label\"], \"names\"):\n",
+    "    classes = dataset[\"train\"].features[\"label\"].names\n",
+    "else:\n",
+    "    classes = [\"Bearish\", \"Bullish\", \"Neutral\"]\n",
+    "dataset = dataset.map(\n",
+    "    lambda x: {\"text_label\": [classes[label] for label in x[\"label\"]]},\n",
+    "    batched=True,\n",
+    "    num_proc=1,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "qzwyi-Z9yzRF",
+   "metadata": {
+    "id": "qzwyi-Z9yzRF"
+   },
+   "source": [
+    "Let's also apply some pre-processing of the input data, the labels needs to be pre-processed, the tokens corresponding to `pad_token_id` needs to be set to `-100` so that the `CrossEntropy` loss associated with the model will correctly ignore these tokens."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6b7ea44c",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 81,
+     "referenced_widgets": [
+      "b718fba0f1514025a0ca22e7f780a2fc",
+      "0271e1cc4e2d43c69d4959e46eddec9a",
+      "601fb3752e134641b28da908d4e7b65a",
+      "e002207d6982491cbef196f25fc891f8",
+      "a4857f97132a41acbe4535b03cd8d94a",
+      "d5b57d3c74d14e5d80d1ef634c103a40",
+      "3786a8205e004fe9a5e069acae422410",
+      "05cbd69de3664b82b95e06f72f12a55e",
+      "c149c1c53e9d44008a86944ef8c261c5",
+      "1d11cb45c5cb472aa86722e4dbb8c085",
+      "34142a8e97594931b316970911679e55",
+      "f48454eadbfb4953b719bdf44555c90e",
+      "3c5affff513341b29e6a2c1c90bfe334",
+      "0bbeca449a814d95bec438a9141b2b6b",
+      "a10078c15aae4ec6a849f1b58c6b1cc2",
+      "06e8fd84d6224e5096088d66aad71961",
+      "456429d05857411f8b78f69e8860bf58",
+      "f00b73eb32374c33882c1bfc49822e44",
+      "bc24304c057d4b5898e832818de55caa",
+      "40b951e3a06348a39c7c778aa12f8385",
+      "223848818aff4af1ab5d5e14271408e3",
+      "4b4b31109a9746e88ffa9b47bab00e53"
+     ]
+    },
+    "id": "6b7ea44c",
+    "outputId": "a27a9252-eb13-48ca-cd9e-4953c8bcb75d"
+   },
+   "outputs": [],
+   "source": "# data preprocessing\ntext_column = \"text\"\nlabel_column = \"text_label\"\nmax_length = 128\n\n\ndef preprocess_function(examples):\n    inputs = examples[text_column]\n    targets = examples[label_column]\n    model_inputs = tokenizer(inputs, max_length=max_length, padding=\"max_length\", truncation=True, return_tensors=\"pt\")\n    labels = tokenizer(targets, max_length=3, padding=\"max_length\", truncation=True, return_tensors=\"pt\")\n    labels = labels[\"input_ids\"]\n    labels[labels == tokenizer.pad_token_id] = -100\n    model_inputs[\"labels\"] = labels\n    return model_inputs\n\n\nprocessed_datasets = dataset.map(\n    preprocess_function,\n    batched=True,\n    num_proc=1,\n    remove_columns=dataset[\"train\"].column_names,\n    load_from_cache_file=False,\n    desc=\"Running tokenizer on dataset\",\n)\n\ntrain_dataset = processed_datasets[\"train\"]\neval_dataset = processed_datasets[\"validation\"]"
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bcNTdVypGEPb",
+   "metadata": {
+    "id": "bcNTdVypGEPb"
+   },
+   "source": [
+    "## Train our model! \n",
+    "\n",
+    "Let's now train our model, run the cells below.\n",
+    "Note that for T5 since some layers are kept in `float32` for stability purposes there is no need to call autocast on the trainer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "69c756ac",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "69c756ac",
+    "outputId": "f0d605b1-3b5d-4e22-e108-819edc7b0d52"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "The model is loaded in 8-bit precision. To train this model you need to add additional modules inside the model such as adapters using `peft` library and freeze the model weights. Please check  the examples in https://github.com/huggingface/peft for more details.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from transformers import TrainingArguments, Trainer\n",
+    "\n",
+    "training_args = TrainingArguments(\n",
+    "    \"temp\",\n",
+    "    eval_strategy=\"epoch\",\n",
+    "    learning_rate=1e-3,\n",
+    "    gradient_accumulation_steps=1,\n",
+    "    auto_find_batch_size=True,\n",
+    "    num_train_epochs=1,\n",
+    "    save_steps=100,\n",
+    "    save_total_limit=8,\n",
+    ")\n",
+    "trainer = Trainer(\n",
+    "    model=model,\n",
+    "    args=training_args,\n",
+    "    train_dataset=train_dataset,\n",
+    "    eval_dataset=eval_dataset,\n",
+    ")\n",
+    "model.config.use_cache = False  # silence the warnings. Please re-enable for inference!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ab52b651",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 659
+    },
+    "id": "ab52b651",
+    "outputId": "2da171de-e59a-4945-93cb-5704681e84c1"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.8/dist-packages/transformers/optimization.py:346: FutureWarning: This implementation of AdamW is deprecated and will be removed in a future version. Use the PyTorch implementation torch.optim.AdamW instead, or set `no_deprecation_warning=True` to disable this warning\n",
+      "  warnings.warn(\n",
+      "***** Running training *****\n",
+      "  Num examples = 2037\n",
+      "  Num Epochs = 1\n",
+      "  Instantaneous batch size per device = 8\n",
+      "  Total train batch size (w. parallel, distributed & accumulation) = 8\n",
+      "  Gradient Accumulation steps = 1\n",
+      "  Total optimization steps = 255\n",
+      "  Number of trainable parameters = 4718592\n",
+      "/usr/local/lib/python3.8/dist-packages/bitsandbytes/autograd/_functions.py:298: UserWarning: MatMul8bitLt: inputs will be cast from torch.float32 to float16 during quantization\n",
+      "  warnings.warn(f\"MatMul8bitLt: inputs will be cast from {A.dtype} to float16 during quantization\")\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "    <div>\n",
+       "      \n",
+       "      <progress value='255' max='255' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
+       "      [255/255 06:13, Epoch 1/1]\n",
+       "    </div>\n",
+       "    <table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       " <tr style=\"text-align: left;\">\n",
+       "      <th>Epoch</th>\n",
+       "      <th>Training Loss</th>\n",
+       "      <th>Validation Loss</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <td>1</td>\n",
+       "      <td>No log</td>\n",
+       "      <td>0.017228</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table><p>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Saving model checkpoint to temp/checkpoint-100\n",
+      "Trainer.model is not a `PreTrainedModel`, only saving its state dict.\n",
+      "/usr/local/lib/python3.8/dist-packages/bitsandbytes/autograd/_functions.py:298: UserWarning: MatMul8bitLt: inputs will be cast from torch.float32 to float16 during quantization\n",
+      "  warnings.warn(f\"MatMul8bitLt: inputs will be cast from {A.dtype} to float16 during quantization\")\n",
+      "Saving model checkpoint to temp/checkpoint-200\n",
+      "Trainer.model is not a `PreTrainedModel`, only saving its state dict.\n",
+      "/usr/local/lib/python3.8/dist-packages/bitsandbytes/autograd/_functions.py:298: UserWarning: MatMul8bitLt: inputs will be cast from torch.float32 to float16 during quantization\n",
+      "  warnings.warn(f\"MatMul8bitLt: inputs will be cast from {A.dtype} to float16 during quantization\")\n",
+      "***** Running Evaluation *****\n",
+      "  Num examples = 227\n",
+      "  Batch size = 8\n",
+      "\n",
+      "\n",
+      "Training completed. Do not forget to share your model on huggingface.co/models =)\n",
+      "\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "TrainOutput(global_step=255, training_loss=0.2569344015682445, metrics={'train_runtime': 377.3565, 'train_samples_per_second': 5.398, 'train_steps_per_second': 0.676, 'total_flos': 1181084919791616.0, 'train_loss': 0.2569344015682445, 'epoch': 1.0})"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "r98VtofiGXtO",
+   "metadata": {
+    "id": "r98VtofiGXtO"
+   },
+   "source": [
+    "## Qualitatively test our model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "NIm7z3UNzGPP",
+   "metadata": {
+    "id": "NIm7z3UNzGPP"
+   },
+   "source": [
+    "Let's have a quick qualitative evaluation of the model, by taking a sample from the dataset that corresponds to a positive label. Run your generation similarly as you were running your model from `transformers`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c95d6173",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "c95d6173",
+    "outputId": "ed03a1dc-597a-4053-99d6-eca2cc6da253"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Generate config GenerationConfig {\n",
+      "  \"_from_model_config\": true,\n",
+      "  \"decoder_start_token_id\": 0,\n",
+      "  \"eos_token_id\": 1,\n",
+      "  \"pad_token_id\": 0,\n",
+      "  \"transformers_version\": \"4.27.0.dev0\",\n",
+      "  \"use_cache\": false\n",
+      "}\n",
+      "\n",
+      "/usr/local/lib/python3.8/dist-packages/bitsandbytes/autograd/_functions.py:298: UserWarning: MatMul8bitLt: inputs will be cast from torch.float32 to float16 during quantization\n",
+      "  warnings.warn(f\"MatMul8bitLt: inputs will be cast from {A.dtype} to float16 during quantization\")\n",
+      "/usr/local/lib/python3.8/dist-packages/transformers/generation/utils.py:1374: UserWarning: You are calling .generate() with the `input_ids` being on a device type different than your model's device. `input_ids` is on cpu, whereas the model is on cuda. You may experience unexpected behaviors or slower generation. Please make sure that you have put `input_ids` to the correct device by calling for example input_ids = input_ids.to('cuda') before running `.generate()`.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "input sentence:  In January-September 2009 , the Group 's net interest income increased to EUR 112.4 mn from EUR 74.3 mn in January-September 2008 .\n",
+      " output prediction:  ['positive']\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.eval()\n",
+    "input_text = \"In January-September 2009 , the Group 's net interest income increased to EUR 112.4 mn from EUR 74.3 mn in January-September 2008 .\"\n",
+    "inputs = tokenizer(input_text, return_tensors=\"pt\").to(model.device)\n",
+    "\n",
+    "outputs = model.generate(input_ids=inputs[\"input_ids\"], max_new_tokens=10)\n",
+    "\n",
+    "print(\"input sentence: \", input_text)\n",
+    "print(\" output prediction: \", tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9QqBlwzoGZ3f",
+   "metadata": {
+    "id": "9QqBlwzoGZ3f"
+   },
+   "source": [
+    "## Share your adapters on 🤗 Hub"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "NT-C8SjcKqUx",
+   "metadata": {
+    "id": "NT-C8SjcKqUx"
+   },
+   "source": [
+    "Once you have trained your adapter, you can easily share it on the Hub using the method `push_to_hub` . Note that only the adapter weights and config will be pushed"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bcbfa1f9",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 359,
+     "referenced_widgets": [
+      "5bb29f3102954b06bec825f6b3a7aaa7",
+      "90516032070a40979181d1d27db10c4f",
+      "4b7dc0fb222b4e2a9bb2ef2501e9fd30",
+      "06069855ef82484f9985e4619095dbe8",
+      "1ece69c53e37413caad8db70d9160ad5",
+      "7ce90db727ea47cc9344176858a2225b",
+      "64f2b70b63cd4e7eb9e22ac2de5589c9",
+      "57dea1b3e04142bb91868a474774d86a",
+      "8ac43334e0ad4a78acda3b876fead058",
+      "04da98e400514cf2847d172916cd0081",
+      "4dbe49547fe94010ad5a30818cfc35bc",
+      "99091ca45c1b4809ba0a1b01af85f528",
+      "06ec124c3dac4fe6b152fb812d20d86d",
+      "7561c47a97444666816422a0418e1675",
+      "45ab5d7049e34dfd8a067643ae887a31",
+      "434e308cac5847f0bee431c7dbb4c04a",
+      "dd993a4a7cdf40448098544c95468a10"
+     ]
+    },
+    "id": "bcbfa1f9",
+    "outputId": "91ef770e-9fc4-4eb2-b02b-24e635101f97"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Token is valid.\n",
+      "Your token has been saved in your configured git credential helpers (store).\n",
+      "Your token has been saved to /root/.cache/huggingface/token\n",
+      "Login successful\n"
+     ]
+    }
+   ],
+   "source": [
+    "from huggingface_hub import notebook_login\n",
+    "\n",
+    "notebook_login()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "rFKJ4vHNGkJw",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 152,
+     "referenced_widgets": [
+      "00f7d043cb184d69b828c204dac2c0ab",
+      "1e409cd3d3a04b558d989d63f0b3b5f7",
+      "d48cbb38078b456fab1634bec5b0a1ba",
+      "9030744dbca9427ba8a036a76b5c8bf7",
+      "53dd4444c0e14e16a912532898b32d92",
+      "5287ac638c22412ab91c55f3316c9b63",
+      "a43ddb478f044f17adbcfae841ec2114",
+      "45141234ce584f208a9d301faadf75d2",
+      "f62ffbdc24734b999f36058d9edca81f",
+      "972ddebd536d4685bfc3c7c13e5bd8be",
+      "64156e2c54b44fb9aec661d9b57da962",
+      "050de732f51f4af8bb41ab3cad0090a4",
+      "7960ed3beb2a429ba2aca1c6ed032f64",
+      "726a2eedc7434210bc5aa4d0a772b313",
+      "07bf5d621cf944258aaf13954669df56",
+      "93a0896ca66b4111bc4cabe6e1278440",
+      "cfc78731f7d543ce8529cc254d92ddf5",
+      "eacf8e9ed6e847faae2b8ecab283ddc4",
+      "bef1971d92e6479696e3f9a27a757b8a",
+      "821f2f296acb40ae9bb40fc3faf4103d",
+      "11efd993475a4f2aabe7df605bab04dd",
+      "406e4d8561f64d2a94d93a606d02d7d3"
+     ]
+    },
+    "id": "rFKJ4vHNGkJw",
+    "outputId": "07425379-64ad-47e8-ba8f-8d9dc26252b6"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Uploading the following files to ybelkada/flan-t5-large-lora: adapter_model.bin,adapter_config.json\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "00f7d043cb184d69b828c204dac2c0ab",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Upload 1 LFS files:   0%|          | 0/1 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "050de732f51f4af8bb41ab3cad0090a4",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "adapter_model.bin:   0%|          | 0.00/19.0M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "CommitInfo(commit_url='https://huggingface.co/ybelkada/flan-t5-large-lora/commit/585e4e8cac66188692d506ac107e2d2884c0a4a0', commit_message='Upload model', commit_description='', oid='585e4e8cac66188692d506ac107e2d2884c0a4a0', pr_url=None, pr_revision=None, pr_num=None)"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.push_to_hub(\"ybelkada/flan-t5-large-financial-phrasebank-lora\", use_auth_token=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "xHuDmbCYJ89f",
+   "metadata": {
+    "id": "xHuDmbCYJ89f"
+   },
+   "source": [
+    "## Load your adapter from the Hub"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ANFo6DdfKlU3",
+   "metadata": {
+    "id": "ANFo6DdfKlU3"
+   },
+   "source": [
+    "You can load the model together with the adapter with few lines of code! Check the snippet below to load the adapter from the Hub and run the example evaluation!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "j097aaPWJ-9u",
+   "metadata": {
+    "id": "j097aaPWJ-9u"
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from peft import PeftModel, PeftConfig\n",
+    "from transformers import AutoModelForSeq2SeqLM, AutoTokenizer\n",
+    "\n",
+    "peft_model_id = \"ybelkada/flan-t5-large-financial-phrasebank-lora\"\n",
+    "config = PeftConfig.from_pretrained(peft_model_id)\n",
+    "\n",
+    "model = AutoModelForSeq2SeqLM.from_pretrained(config.base_model_name_or_path, dtype=\"auto\", device_map=\"auto\")\n",
+    "tokenizer = AutoTokenizer.from_pretrained(config.base_model_name_or_path)\n",
+    "\n",
+    "# Load the Lora model\n",
+    "model = PeftModel.from_pretrained(model, peft_model_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "jmjwWYt0KI_I",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "jmjwWYt0KI_I",
+    "outputId": "466e79b6-c5a8-4a03-9a17-eeb2bc27e9ac"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Generate config GenerationConfig {\n",
+      "  \"_from_model_config\": true,\n",
+      "  \"decoder_start_token_id\": 0,\n",
+      "  \"eos_token_id\": 1,\n",
+      "  \"pad_token_id\": 0,\n",
+      "  \"transformers_version\": \"4.27.0.dev0\"\n",
+      "}\n",
+      "\n",
+      "/usr/local/lib/python3.8/dist-packages/transformers/generation/utils.py:1374: UserWarning: You are calling .generate() with the `input_ids` being on a device type different than your model's device. `input_ids` is on cpu, whereas the model is on cuda. You may experience unexpected behaviors or slower generation. Please make sure that you have put `input_ids` to the correct device by calling for example input_ids = input_ids.to('cuda') before running `.generate()`.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "input sentence:  In January-September 2009 , the Group 's net interest income increased to EUR 112.4 mn from EUR 74.3 mn in January-September 2008 .\n",
+      " output prediction:  ['positive']\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.eval()\n",
+    "input_text = \"In January-September 2009 , the Group 's net interest income increased to EUR 112.4 mn from EUR 74.3 mn in January-September 2008 .\"\n",
+    "inputs = tokenizer(input_text, return_tensors=\"pt\").to(model.device)\n",
+    "\n",
+    "outputs = model.generate(input_ids=inputs[\"input_ids\"], max_new_tokens=10)\n",
+    "\n",
+    "print(\"input sentence: \", input_text)\n",
+    "print(\" output prediction: \", tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True))"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "machine_shape": "hm",
+   "provenance": []
+  },
+  "gpuClass": "standard",
+  "kernelspec": {
+   "display_name": "Python 3.10.11 ('accelerate': conda)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.11"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "1219a10c7def3e2ad4f431cfa6f49d569fcc5949850132f23800e792129eefbb"
+   }
+  },
+  "widgets": {
+   "application/vnd.jupyter.widget-state+json": {
+    "00f7d043cb184d69b828c204dac2c0ab": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_1e409cd3d3a04b558d989d63f0b3b5f7",
+       "IPY_MODEL_d48cbb38078b456fab1634bec5b0a1ba",
+       "IPY_MODEL_9030744dbca9427ba8a036a76b5c8bf7"
+      ],
+      "layout": "IPY_MODEL_53dd4444c0e14e16a912532898b32d92"
+     }
+    },
+    "0271e1cc4e2d43c69d4959e46eddec9a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d5b57d3c74d14e5d80d1ef634c103a40",
+      "placeholder": "​",
+      "style": "IPY_MODEL_3786a8205e004fe9a5e069acae422410",
+      "value": "Running tokenizer on dataset: 100%"
+     }
+    },
+    "0363c4d4dc1449148b09061763ea119a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_f4ff06e2c48d4e58abe64cb7f41dd886",
+       "IPY_MODEL_7fb7e3e2c75d4d03a98e581d4ead0f00",
+       "IPY_MODEL_b8087054f46c44cab9bd62fa23fbf9de"
+      ],
+      "layout": "IPY_MODEL_85ae7ed1ec244a89aeb9f4552c2c9462"
+     }
+    },
+    "03abf3bb217e4622b31cd869ed11aa00": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "04da98e400514cf2847d172916cd0081": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "050de732f51f4af8bb41ab3cad0090a4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_7960ed3beb2a429ba2aca1c6ed032f64",
+       "IPY_MODEL_726a2eedc7434210bc5aa4d0a772b313",
+       "IPY_MODEL_07bf5d621cf944258aaf13954669df56"
+      ],
+      "layout": "IPY_MODEL_93a0896ca66b4111bc4cabe6e1278440"
+     }
+    },
+    "053de11f995247f6b851909a6a8dfc16": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "05cbd69de3664b82b95e06f72f12a55e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "06069855ef82484f9985e4619095dbe8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "CheckboxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "CheckboxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "CheckboxView",
+      "description": "Add token as git credential?",
+      "description_tooltip": null,
+      "disabled": false,
+      "indent": true,
+      "layout": "IPY_MODEL_99091ca45c1b4809ba0a1b01af85f528",
+      "style": "IPY_MODEL_06ec124c3dac4fe6b152fb812d20d86d",
+      "value": true
+     }
+    },
+    "06c3d8c44fbe4f0886cf397d9a3c4b81": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "06cea508d7504b228f6cebc66742d200": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "06e8fd84d6224e5096088d66aad71961": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "06ec124c3dac4fe6b152fb812d20d86d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "07bf5d621cf944258aaf13954669df56": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_11efd993475a4f2aabe7df605bab04dd",
+      "placeholder": "​",
+      "style": "IPY_MODEL_406e4d8561f64d2a94d93a606d02d7d3",
+      "value": " 19.0M/19.0M [00:02&lt;00:00, 20.4MB/s]"
+     }
+    },
+    "07f5dcd5a6e24d819e0ce9e54a5bfafa": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_2f20ea2be56a4992827f960d8c6d7b7f",
+      "max": 2264,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_2871be167d4f44859eb2bc0baf0788f6",
+      "value": 2264
+     }
+    },
+    "0845ceae96ca4c95ad4ebebac46b691f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_03abf3bb217e4622b31cd869ed11aa00",
+      "max": 2539,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_24f9db6df6d54ad6bac4891b65184799",
+      "value": 2539
+     }
+    },
+    "0bbeca449a814d95bec438a9141b2b6b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_bc24304c057d4b5898e832818de55caa",
+      "max": 1,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_40b951e3a06348a39c7c778aa12f8385",
+      "value": 1
+     }
+    },
+    "0f091d25adf34ade835b094eb5b952a3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_2de762c8d96b48c7bbd72fad566611b2",
+      "placeholder": "​",
+      "style": "IPY_MODEL_8ef94158b0584f0eb55582bf8b6594c6",
+      "value": "Downloading readme: 100%"
+     }
+    },
+    "10aa4e3aca57438ea7af97b60208ac81": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "11efd993475a4f2aabe7df605bab04dd": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1275c5a5c88b435a897f88a19c54a0a5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a3bb3f44c1754082a4f5169431c5b760",
+      "max": 3132781861,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_a0186b2194df4a0a9cd1ac49054d68da",
+      "value": 3132781861
+     }
+    },
+    "179a912bbd1e454eba503782b675efa8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "1b839f5b472e44148c9e02a12550fade": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_b560fc36ee8f424f9590e04a042046fe",
+       "IPY_MODEL_0845ceae96ca4c95ad4ebebac46b691f",
+       "IPY_MODEL_e1769695dffd4ebeb79a63ff4812fa9e"
+      ],
+      "layout": "IPY_MODEL_ec73524ed7f14ea0b67f07d72eada173"
+     }
+    },
+    "1bf4434ccea34cbc803d88f37aff2065": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_808cea6c94264f0c9990d6dbcf538419",
+      "placeholder": "​",
+      "style": "IPY_MODEL_96e4e44a789a46ce8239b260bf6e3dc8",
+      "value": "Generating train split:  58%"
+     }
+    },
+    "1d11cb45c5cb472aa86722e4dbb8c085": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1e409cd3d3a04b558d989d63f0b3b5f7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5287ac638c22412ab91c55f3316c9b63",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a43ddb478f044f17adbcfae841ec2114",
+      "value": "Upload 1 LFS files: 100%"
+     }
+    },
+    "1ece69c53e37413caad8db70d9160ad5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ButtonModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ButtonModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ButtonView",
+      "button_style": "",
+      "description": "Login",
+      "disabled": false,
+      "icon": "",
+      "layout": "IPY_MODEL_7561c47a97444666816422a0418e1675",
+      "style": "IPY_MODEL_45ab5d7049e34dfd8a067643ae887a31",
+      "tooltip": ""
+     }
+    },
+    "1ed1bfefa6534085869130ea533ff4b1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6b05e37f42b04701a97bab91ae92c2dd",
+      "max": 1,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_2ec84788d5dd4a04a24ccf66dad457ad",
+      "value": 1
+     }
+    },
+    "1fa2a7e3ff3c4c99ab95e96a28624846": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "216e5237b31944cbab006d9761ade0a1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "223848818aff4af1ab5d5e14271408e3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "232fe29739b74dabb3b558c33835eb32": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "23e494a586cf47d1afa5e619abfcdbba": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5a6b38b8fc1345e8bd4e8f3aaea546c9",
+      "placeholder": "​",
+      "style": "IPY_MODEL_57d4ca686af34205aca630b1c61d4aea",
+      "value": " 662/662 [00:00&lt;00:00, 19.8kB/s]"
+     }
+    },
+    "24f9db6df6d54ad6bac4891b65184799": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "26e1bfb23d3a4797a8dbb9c4ed2aeb22": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_c0deb08457be4a3ebb3947e33f7ce1df",
+       "IPY_MODEL_6a85e6040bf440569a23495d67a66de1",
+       "IPY_MODEL_30c87e87c4b845b8bb27507596f4d18c"
+      ],
+      "layout": "IPY_MODEL_f061a6deaa73484aa04f219bba6a4329"
+     }
+    },
+    "283bdd8a4daf4f5ca1ec6e9ed19c46ec": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_9d68afcb8e26420cb91ea1eb872c80c4",
+       "IPY_MODEL_40171f7e3e1f46b4955548bbb58cac6c",
+       "IPY_MODEL_b8bb0aed01d04e8dad560df1b051e1e4"
+      ],
+      "layout": "IPY_MODEL_da99eed13d524b8fb95dbc563eb2d044"
+     }
+    },
+    "2871be167d4f44859eb2bc0baf0788f6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "28e24fc8410d486c904f249579d31b8b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "2b4d68606bdf4758b812f5a8057af595": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2bfb7c240e154769a0d58a3ceaa20212": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8b41d2e9f7424dc898446e7f428dc757",
+      "placeholder": "​",
+      "style": "IPY_MODEL_8035fd17e29a48d7b415c531607216a6",
+      "value": "Downloading metadata: 100%"
+     }
+    },
+    "2c47350dd2164d4a8164be2ec6d16391": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2ce6779fa5904471945fa5738510af64": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c7771479ae4e4efab744fad6da586fd3",
+      "placeholder": "​",
+      "style": "IPY_MODEL_2d7cb8f5477244ce82e7cec5a9f7ee39",
+      "value": "Downloading (…)neration_config.json: 100%"
+     }
+    },
+    "2d2fc7abb9fb411c810b2fbeb54d67cc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_06c3d8c44fbe4f0886cf397d9a3c4b81",
+      "max": 791656,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_d72e8b3419f240f2bdce253cce9d24e3",
+      "value": 791656
+     }
+    },
+    "2d7cb8f5477244ce82e7cec5a9f7ee39": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "2de762c8d96b48c7bbd72fad566611b2": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2ec84788d5dd4a04a24ccf66dad457ad": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "2f20ea2be56a4992827f960d8c6d7b7f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2fe0a2fa22a0498da983ec38150216e6": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "30c87e87c4b845b8bb27507596f4d18c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_dd53a486f7b5403a81e2be89cbbda719",
+      "placeholder": "​",
+      "style": "IPY_MODEL_5626348c213b48faa61651c08cd1bb24",
+      "value": " 1/1 [00:00&lt;00:00, 18.99it/s]"
+     }
+    },
+    "34142a8e97594931b316970911679e55": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "34333da7eb0f49a6b83df76e35dcdd93": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "34db70b6e6ec475699fd23a2d6c3a973": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_645e26fd9b3f4919a43eca3592475324",
+      "placeholder": "​",
+      "style": "IPY_MODEL_83f196eb5d9549cda4d48008fa7b1386",
+      "value": " 13.7k/13.7k [00:00&lt;00:00, 159kB/s]"
+     }
+    },
+    "356cb75b5f4247d9be9d4d2aa15f2dc1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3786a8205e004fe9a5e069acae422410": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "390b88f67b84451999b0845483905144": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "39dd984ff238456e9e485c077f9e87a8": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3a5712c976b04af0975804b34344dfcf": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "3c5affff513341b29e6a2c1c90bfe334": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_456429d05857411f8b78f69e8860bf58",
+      "placeholder": "​",
+      "style": "IPY_MODEL_f00b73eb32374c33882c1bfc49822e44",
+      "value": "Running tokenizer on dataset: 100%"
+     }
+    },
+    "3c8349539946412a93a51d9087306ea4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "40171f7e3e1f46b4955548bbb58cac6c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_356cb75b5f4247d9be9d4d2aa15f2dc1",
+      "max": 3,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_64670ef7321140de89ca726b5eeae337",
+      "value": 3
+     }
+    },
+    "401bd48c5b2d48eb86a1499912ee2b44": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "406e4d8561f64d2a94d93a606d02d7d3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "40b951e3a06348a39c7c778aa12f8385": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "41d8dbe04d0c4ec4a9d19662f9e11920": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_1bf4434ccea34cbc803d88f37aff2065",
+       "IPY_MODEL_07f5dcd5a6e24d819e0ce9e54a5bfafa",
+       "IPY_MODEL_b8944b7027d449b4a7fc752978f463b1"
+      ],
+      "layout": "IPY_MODEL_baf53867f52046c182a2b1755f02e136"
+     }
+    },
+    "434e308cac5847f0bee431c7dbb4c04a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "43d7a9b421be430286b5eb8441d6d465": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "45141234ce584f208a9d301faadf75d2": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "456429d05857411f8b78f69e8860bf58": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "45ab5d7049e34dfd8a067643ae887a31": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ButtonStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ButtonStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "button_color": null,
+      "font_weight": ""
+     }
+    },
+    "4b4b31109a9746e88ffa9b47bab00e53": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4b7dc0fb222b4e2a9bb2ef2501e9fd30": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "PasswordModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "PasswordModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "PasswordView",
+      "continuous_update": true,
+      "description": "Token:",
+      "description_tooltip": null,
+      "disabled": false,
+      "layout": "IPY_MODEL_04da98e400514cf2847d172916cd0081",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4dbe49547fe94010ad5a30818cfc35bc",
+      "value": ""
+     }
+    },
+    "4dbe49547fe94010ad5a30818cfc35bc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4f57cfa7cb3b4199babf82dc9d93b074": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5093700dd3a14cc1a283d18a4a0e17a7": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "51335afbfc02480fbc8d2c6200f3e18e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "5192bc282c4847cb9df8365fc22a6cc2": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5287ac638c22412ab91c55f3316c9b63": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "53dd4444c0e14e16a912532898b32d92": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "55cf3bcee7c745948b39eea5f65fc62b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "5626348c213b48faa61651c08cd1bb24": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "57d4ca686af34205aca630b1c61d4aea": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "57dea1b3e04142bb91868a474774d86a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "59782bac41834abbbd6cbd6614c2e57b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_8252a05cb70b46ec8b0480062ea1cb71",
+       "IPY_MODEL_b77afc7c1f184de0970feb2df8ac5285",
+       "IPY_MODEL_23e494a586cf47d1afa5e619abfcdbba"
+      ],
+      "layout": "IPY_MODEL_bdfb4a04e48246a4b0890f52d6dd424b"
+     }
+    },
+    "5a6b38b8fc1345e8bd4e8f3aaea546c9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5bb29f3102954b06bec825f6b3a7aaa7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "VBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "VBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "VBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_90516032070a40979181d1d27db10c4f",
+       "IPY_MODEL_4b7dc0fb222b4e2a9bb2ef2501e9fd30",
+       "IPY_MODEL_06069855ef82484f9985e4619095dbe8",
+       "IPY_MODEL_1ece69c53e37413caad8db70d9160ad5",
+       "IPY_MODEL_7ce90db727ea47cc9344176858a2225b"
+      ],
+      "layout": "IPY_MODEL_64f2b70b63cd4e7eb9e22ac2de5589c9"
+     }
+    },
+    "5bfebc75ec424c6cb41b33d210d28d2b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5cc620a232bf4d418c3fc882f4c1cd0c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_34333da7eb0f49a6b83df76e35dcdd93",
+      "placeholder": "​",
+      "style": "IPY_MODEL_c708031a279e4e55ac7833e6697f93bd",
+      "value": "Downloading (…)/main/tokenizer.json: 100%"
+     }
+    },
+    "601fb3752e134641b28da908d4e7b65a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_05cbd69de3664b82b95e06f72f12a55e",
+      "max": 3,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_c149c1c53e9d44008a86944ef8c261c5",
+      "value": 3
+     }
+    },
+    "608e9f7a14054573b9bd07f0f74b6345": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "61ab054f49884b1fadf529a39ccc37dc": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6317d49813234f5b9103b249cf648c2c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "64156e2c54b44fb9aec661d9b57da962": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "645e26fd9b3f4919a43eca3592475324": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "64670ef7321140de89ca726b5eeae337": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "64f2b70b63cd4e7eb9e22ac2de5589c9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": "center",
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": "flex",
+      "flex": null,
+      "flex_flow": "column",
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": "50%"
+     }
+    },
+    "65aacfc888014bdea55253428b2569c0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_82849bb4d5da452e87a18ca749ce5d7b",
+       "IPY_MODEL_2d2fc7abb9fb411c810b2fbeb54d67cc",
+       "IPY_MODEL_96e2d208830f48cd821be7e59643c93e"
+      ],
+      "layout": "IPY_MODEL_8d79b7d0c3cb4f8d99fb20941c35856f"
+     }
+    },
+    "66535de16cca41cd9ba44b6de40c4e6a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6994741f3113493b9d5bba278b8732f5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_232fe29739b74dabb3b558c33835eb32",
+      "placeholder": "​",
+      "style": "IPY_MODEL_978bbbf33d304588af971d22bb2a3690",
+      "value": " 147/147 [00:00&lt;00:00, 6.61kB/s]"
+     }
+    },
+    "6a40d6535f9e4b5b9c9283a1cd67687a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "6a85e6040bf440569a23495d67a66de1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_66535de16cca41cd9ba44b6de40c4e6a",
+      "max": 1,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_51335afbfc02480fbc8d2c6200f3e18e",
+      "value": 1
+     }
+    },
+    "6b05e37f42b04701a97bab91ae92c2dd": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6f30253108fb4dce9c3de029457ef6f1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "726a2eedc7434210bc5aa4d0a772b313": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_bef1971d92e6479696e3f9a27a757b8a",
+      "max": 18980429,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_821f2f296acb40ae9bb40fc3faf4103d",
+      "value": 18980429
+     }
+    },
+    "74e88bd01bf14e0e9f772f993c92eb77": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "74efd6bfe71e4dc599a7fc76574ff154": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_39dd984ff238456e9e485c077f9e87a8",
+      "placeholder": "​",
+      "style": "IPY_MODEL_28e24fc8410d486c904f249579d31b8b",
+      "value": "100%"
+     }
+    },
+    "7561c47a97444666816422a0418e1675": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7960ed3beb2a429ba2aca1c6ed032f64": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_cfc78731f7d543ce8529cc254d92ddf5",
+      "placeholder": "​",
+      "style": "IPY_MODEL_eacf8e9ed6e847faae2b8ecab283ddc4",
+      "value": "adapter_model.bin: 100%"
+     }
+    },
+    "7b6bddd4ca51495dbc2fceba7c50706f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_2c47350dd2164d4a8164be2ec6d16391",
+      "placeholder": "​",
+      "style": "IPY_MODEL_8fceec1018574003884e082b2a5c23bf",
+      "value": " 6.04k/6.04k [00:00&lt;00:00, 307kB/s]"
+     }
+    },
+    "7ce90db727ea47cc9344176858a2225b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_434e308cac5847f0bee431c7dbb4c04a",
+      "placeholder": "​",
+      "style": "IPY_MODEL_dd993a4a7cdf40448098544c95468a10",
+      "value": "\n<b>Pro Tip:</b> If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks. </center>"
+     }
+    },
+    "7cfda0921e5a4f378e90e057447f3b3d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_10aa4e3aca57438ea7af97b60208ac81",
+      "placeholder": "​",
+      "style": "IPY_MODEL_f14657da8e1e4298a96e3885eb4eee93",
+      "value": "Downloading builder script: 100%"
+     }
+    },
+    "7fb7e3e2c75d4d03a98e581d4ead0f00": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_43d7a9b421be430286b5eb8441d6d465",
+      "max": 2201,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_ebc26228160046c48279d71770c928d8",
+      "value": 2201
+     }
+    },
+    "8035fd17e29a48d7b415c531607216a6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "808a41f78a7c4ae0b6aafee59c6234ae": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "808cea6c94264f0c9990d6dbcf538419": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "81d2f0953e104fc1ad57295819b6b689": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_bcda86e43607436583f1fbfee08a9786",
+      "placeholder": "​",
+      "style": "IPY_MODEL_55cf3bcee7c745948b39eea5f65fc62b",
+      "value": " 3.13G/3.13G [00:18&lt;00:00, 182MB/s]"
+     }
+    },
+    "821f2f296acb40ae9bb40fc3faf4103d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "8252a05cb70b46ec8b0480062ea1cb71": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8669a890db6c456cbc3ada28976be30b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_9e5afa2048c74754816b34a34171fcb0",
+      "value": "Downloading (…)lve/main/config.json: 100%"
+     }
+    },
+    "82849bb4d5da452e87a18ca749ce5d7b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_2b4d68606bdf4758b812f5a8057af595",
+      "placeholder": "​",
+      "style": "IPY_MODEL_f9620e01cd6749f88b722a42ff68c502",
+      "value": "Downloading (…)&quot;spiece.model&quot;;: 100%"
+     }
+    },
+    "83f196eb5d9549cda4d48008fa7b1386": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "85ae7ed1ec244a89aeb9f4552c2c9462": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "85e5c1a9b7ac4e6e884213a636d0aaa1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8669a890db6c456cbc3ada28976be30b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "87ce7c58b18146f3ac73970d7f8079ac": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8a2bd1b4d9ba47ef9e77048e3d2d1e83": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8ac43334e0ad4a78acda3b876fead058": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "8b41d2e9f7424dc898446e7f428dc757": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8d35a041dbfb4747aea427e76890551a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_74efd6bfe71e4dc599a7fc76574ff154",
+       "IPY_MODEL_1ed1bfefa6534085869130ea533ff4b1",
+       "IPY_MODEL_fd08c4fbe5d84dd893d87a5e2f2d082d"
+      ],
+      "layout": "IPY_MODEL_87ce7c58b18146f3ac73970d7f8079ac"
+     }
+    },
+    "8d79b7d0c3cb4f8d99fb20941c35856f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8ef94158b0584f0eb55582bf8b6594c6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "8f339c9070f046dab46ebc35c1cc2dba": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d618ec6be7d14a239b3bc74172616bf2",
+      "max": 13677,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_3c8349539946412a93a51d9087306ea4",
+      "value": 13677
+     }
+    },
+    "8fceec1018574003884e082b2a5c23bf": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "9030744dbca9427ba8a036a76b5c8bf7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_972ddebd536d4685bfc3c7c13e5bd8be",
+      "placeholder": "​",
+      "style": "IPY_MODEL_64156e2c54b44fb9aec661d9b57da962",
+      "value": " 1/1 [00:02&lt;00:00,  2.11s/it]"
+     }
+    },
+    "90516032070a40979181d1d27db10c4f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_57dea1b3e04142bb91868a474774d86a",
+      "placeholder": "​",
+      "style": "IPY_MODEL_8ac43334e0ad4a78acda3b876fead058",
+      "value": "<center> <img\nsrc=https://huggingface.co/front/assets/huggingface_logo-noborder.svg\nalt='Hugging Face'> <br> Copy a token from <a\nhref=\"https://huggingface.co/settings/tokens\" target=\"_blank\">your Hugging Face\ntokens page</a> and paste it below. <br> Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file. </center>"
+     }
+    },
+    "924e6a8308fc47af929aca1987a12f09": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "93a0896ca66b4111bc4cabe6e1278440": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "93fe5a8fafbc44b496309d1a8da77ac5": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "94437f56e5a44fa3bb08c9d798b2eaeb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_0f091d25adf34ade835b094eb5b952a3",
+       "IPY_MODEL_9d599c2a4d9f4f2db1e4b3183c18eb94",
+       "IPY_MODEL_aa91ad725da147bc8cab70f931d82672"
+      ],
+      "layout": "IPY_MODEL_fb6877c376e0430296b2746513f60931"
+     }
+    },
+    "945ac449c2e84fd6b5a7805b017343f2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "96e2d208830f48cd821be7e59643c93e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_2fe0a2fa22a0498da983ec38150216e6",
+      "placeholder": "​",
+      "style": "IPY_MODEL_f3784e85cef34bdba64b611a1f5883e4",
+      "value": " 792k/792k [00:00&lt;00:00, 7.01MB/s]"
+     }
+    },
+    "96e4e44a789a46ce8239b260bf6e3dc8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "972ddebd536d4685bfc3c7c13e5bd8be": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "978bbbf33d304588af971d22bb2a3690": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "99091ca45c1b4809ba0a1b01af85f528": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "9d0500a0f5f74be39e5edfbbcd7a64fc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "9d599c2a4d9f4f2db1e4b3183c18eb94": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_bf7a49e0e4a64df6b1b1c66e5e73c3a6",
+      "max": 8862,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_d27ff6c2869242b98564b0e03d68b413",
+      "value": 8862
+     }
+    },
+    "9d68afcb8e26420cb91ea1eb872c80c4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a72073cfb8b4422a98ca581c4e5d18b8",
+      "placeholder": "​",
+      "style": "IPY_MODEL_3a5712c976b04af0975804b34344dfcf",
+      "value": "100%"
+     }
+    },
+    "9e5afa2048c74754816b34a34171fcb0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a0186b2194df4a0a9cd1ac49054d68da": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "a10078c15aae4ec6a849f1b58c6b1cc2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_223848818aff4af1ab5d5e14271408e3",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4b4b31109a9746e88ffa9b47bab00e53",
+      "value": " 1/1 [00:00&lt;00:00, 12.10ba/s]"
+     }
+    },
+    "a38c0fedf90a4f3cbb4680b5f85bbf2f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a3bb3f44c1754082a4f5169431c5b760": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a43ddb478f044f17adbcfae841ec2114": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a4857f97132a41acbe4535b03cd8d94a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a4d6de73a37148bf9303a273d13cd091": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a72073cfb8b4422a98ca581c4e5d18b8": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a9effc13b52044a5bc0d6a2a1088396f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "aa2c51ad05c14a02a13e5c047779fc05": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_2ce6779fa5904471945fa5738510af64",
+       "IPY_MODEL_bdff3b35dcdf49e5ba2c5c2498773cb7",
+       "IPY_MODEL_6994741f3113493b9d5bba278b8732f5"
+      ],
+      "layout": "IPY_MODEL_808a41f78a7c4ae0b6aafee59c6234ae"
+     }
+    },
+    "aa91ad725da147bc8cab70f931d82672": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8a2bd1b4d9ba47ef9e77048e3d2d1e83",
+      "placeholder": "​",
+      "style": "IPY_MODEL_dbd908538859410f9c20536fe5acb328",
+      "value": " 8.86k/8.86k [00:00&lt;00:00, 381kB/s]"
+     }
+    },
+    "aaa1477cfabb4767b755e902d3b99e61": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a38c0fedf90a4f3cbb4680b5f85bbf2f",
+      "max": 6036,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_c6a28dcd88c1487ab17aef6946ada876",
+      "value": 6036
+     }
+    },
+    "b560fc36ee8f424f9590e04a042046fe": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f2a36b126c1b41848e61b0c581ff8c4b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_6a40d6535f9e4b5b9c9283a1cd67687a",
+      "value": "Downloading (…)okenizer_config.json: 100%"
+     }
+    },
+    "b718fba0f1514025a0ca22e7f780a2fc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_0271e1cc4e2d43c69d4959e46eddec9a",
+       "IPY_MODEL_601fb3752e134641b28da908d4e7b65a",
+       "IPY_MODEL_e002207d6982491cbef196f25fc891f8"
+      ],
+      "layout": "IPY_MODEL_a4857f97132a41acbe4535b03cd8d94a"
+     }
+    },
+    "b77afc7c1f184de0970feb2df8ac5285": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5bfebc75ec424c6cb41b33d210d28d2b",
+      "max": 662,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_ef2fa44d0105457c9aed3812633dd329",
+      "value": 662
+     }
+    },
+    "b8087054f46c44cab9bd62fa23fbf9de": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5192bc282c4847cb9df8365fc22a6cc2",
+      "placeholder": "​",
+      "style": "IPY_MODEL_608e9f7a14054573b9bd07f0f74b6345",
+      "value": " 2.20k/2.20k [00:00&lt;00:00, 84.9kB/s]"
+     }
+    },
+    "b8944b7027d449b4a7fc752978f463b1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_390b88f67b84451999b0845483905144",
+      "placeholder": "​",
+      "style": "IPY_MODEL_be9c243b74d944eb82ca1fe4ada6721d",
+      "value": " 1303/2264 [00:00&lt;00:00, 4889.47 examples/s]"
+     }
+    },
+    "b8bb0aed01d04e8dad560df1b051e1e4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_93fe5a8fafbc44b496309d1a8da77ac5",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a9effc13b52044a5bc0d6a2a1088396f",
+      "value": " 3/3 [00:00&lt;00:00, 17.02ba/s]"
+     }
+    },
+    "baf53867f52046c182a2b1755f02e136": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": "hidden",
+      "width": null
+     }
+    },
+    "bc24304c057d4b5898e832818de55caa": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "bca79be79b6d4a68b148255bba86ea96": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_74e88bd01bf14e0e9f772f993c92eb77",
+      "placeholder": "​",
+      "style": "IPY_MODEL_401bd48c5b2d48eb86a1499912ee2b44",
+      "value": " 682k/682k [00:00&lt;00:00, 6.99MB/s]"
+     }
+    },
+    "bcda86e43607436583f1fbfee08a9786": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "bdfb4a04e48246a4b0890f52d6dd424b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "bdff3b35dcdf49e5ba2c5c2498773cb7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_df8fbdbe9bc341e3a39a7bda99b70be2",
+      "max": 147,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_179a912bbd1e454eba503782b675efa8",
+      "value": 147
+     }
+    },
+    "be11f6865f6c41b5a57b2b7f4a85e14c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_85e5c1a9b7ac4e6e884213a636d0aaa1",
+      "placeholder": "​",
+      "style": "IPY_MODEL_216e5237b31944cbab006d9761ade0a1",
+      "value": "Downloading data: 100%"
+     }
+    },
+    "be9c243b74d944eb82ca1fe4ada6721d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "bef1971d92e6479696e3f9a27a757b8a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "bf7a49e0e4a64df6b1b1c66e5e73c3a6": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c0deb08457be4a3ebb3947e33f7ce1df": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_cba58e0b316b439ab035b917a40c630c",
+      "placeholder": "​",
+      "style": "IPY_MODEL_de6718209a7a42b0809e97fcd97e09ed",
+      "value": "100%"
+     }
+    },
+    "c149c1c53e9d44008a86944ef8c261c5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "c1757a5b684f4496a4b0e3db544bf44b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "c31cffaa6934407399856235a2f3af54": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a4d6de73a37148bf9303a273d13cd091",
+      "max": 681890,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_f79eeece093f4b0e9de6dbc346a3fa19",
+      "value": 681890
+     }
+    },
+    "c6a28dcd88c1487ab17aef6946ada876": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "c708031a279e4e55ac7833e6697f93bd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "c7771479ae4e4efab744fad6da586fd3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "cba58e0b316b439ab035b917a40c630c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "cce112d791dd4b748908756e785ab555": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_be11f6865f6c41b5a57b2b7f4a85e14c",
+       "IPY_MODEL_c31cffaa6934407399856235a2f3af54",
+       "IPY_MODEL_bca79be79b6d4a68b148255bba86ea96"
+      ],
+      "layout": "IPY_MODEL_5093700dd3a14cc1a283d18a4a0e17a7"
+     }
+    },
+    "ce0213e9d6aa45c5a9ac9954fbe15f62": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_7cfda0921e5a4f378e90e057447f3b3d",
+       "IPY_MODEL_aaa1477cfabb4767b755e902d3b99e61",
+       "IPY_MODEL_7b6bddd4ca51495dbc2fceba7c50706f"
+      ],
+      "layout": "IPY_MODEL_6317d49813234f5b9103b249cf648c2c"
+     }
+    },
+    "cfc78731f7d543ce8529cc254d92ddf5": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "cfc7aa04c11d408c9c12cdbd9cff4bb5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "d27ff6c2869242b98564b0e03d68b413": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "d48cbb38078b456fab1634bec5b0a1ba": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_45141234ce584f208a9d301faadf75d2",
+      "max": 1,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_f62ffbdc24734b999f36058d9edca81f",
+      "value": 1
+     }
+    },
+    "d5b57d3c74d14e5d80d1ef634c103a40": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d618ec6be7d14a239b3bc74172616bf2": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d72e8b3419f240f2bdce253cce9d24e3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "d7d9e2e2090d4226ad89e5ba9cec33df": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_5cc620a232bf4d418c3fc882f4c1cd0c",
+       "IPY_MODEL_f742450a607c4ed0bff98ac9b7685d40",
+       "IPY_MODEL_e87b05e685b040f7a99450bfbab72433"
+      ],
+      "layout": "IPY_MODEL_e1c8e6f843604161bbb6cbd269488469"
+     }
+    },
+    "da99eed13d524b8fb95dbc563eb2d044": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "dbd908538859410f9c20536fe5acb328": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "dbdb787728184aa1a6906f96c5e6f929": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_e3be963920c84c7fbe7e0bc61b8e778d",
+       "IPY_MODEL_1275c5a5c88b435a897f88a19c54a0a5",
+       "IPY_MODEL_81d2f0953e104fc1ad57295819b6b689"
+      ],
+      "layout": "IPY_MODEL_61ab054f49884b1fadf529a39ccc37dc"
+     }
+    },
+    "dd53a486f7b5403a81e2be89cbbda719": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "dd993a4a7cdf40448098544c95468a10": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "de6718209a7a42b0809e97fcd97e09ed": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "df8fbdbe9bc341e3a39a7bda99b70be2": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e002207d6982491cbef196f25fc891f8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_1d11cb45c5cb472aa86722e4dbb8c085",
+      "placeholder": "​",
+      "style": "IPY_MODEL_34142a8e97594931b316970911679e55",
+      "value": " 3/3 [00:00&lt;00:00,  2.89ba/s]"
+     }
+    },
+    "e1769695dffd4ebeb79a63ff4812fa9e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f66e179caa8b4393bed19a0488821c47",
+      "placeholder": "​",
+      "style": "IPY_MODEL_cfc7aa04c11d408c9c12cdbd9cff4bb5",
+      "value": " 2.54k/2.54k [00:00&lt;00:00, 95.8kB/s]"
+     }
+    },
+    "e1c8e6f843604161bbb6cbd269488469": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e24115bb662c428e89c2c4421915e632": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e293930c8e2c4eadbda53005e21ec450": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e3be963920c84c7fbe7e0bc61b8e778d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_924e6a8308fc47af929aca1987a12f09",
+      "placeholder": "​",
+      "style": "IPY_MODEL_c1757a5b684f4496a4b0e3db544bf44b",
+      "value": "Downloading (…)&quot;pytorch_model.bin&quot;;: 100%"
+     }
+    },
+    "e87b05e685b040f7a99450bfbab72433": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_06cea508d7504b228f6cebc66742d200",
+      "placeholder": "​",
+      "style": "IPY_MODEL_9d0500a0f5f74be39e5edfbbcd7a64fc",
+      "value": " 2.42M/2.42M [00:00&lt;00:00, 4.03MB/s]"
+     }
+    },
+    "eacf8e9ed6e847faae2b8ecab283ddc4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "ebc26228160046c48279d71770c928d8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "ec73524ed7f14ea0b67f07d72eada173": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ef2fa44d0105457c9aed3812633dd329": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "f00b73eb32374c33882c1bfc49822e44": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "f061a6deaa73484aa04f219bba6a4329": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f14657da8e1e4298a96e3885eb4eee93": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "f2a36b126c1b41848e61b0c581ff8c4b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f2dc5e8a31c348358aca916274899e8b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_2bfb7c240e154769a0d58a3ceaa20212",
+       "IPY_MODEL_8f339c9070f046dab46ebc35c1cc2dba",
+       "IPY_MODEL_34db70b6e6ec475699fd23a2d6c3a973"
+      ],
+      "layout": "IPY_MODEL_e24115bb662c428e89c2c4421915e632"
+     }
+    },
+    "f3784e85cef34bdba64b611a1f5883e4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "f48454eadbfb4953b719bdf44555c90e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_3c5affff513341b29e6a2c1c90bfe334",
+       "IPY_MODEL_0bbeca449a814d95bec438a9141b2b6b",
+       "IPY_MODEL_a10078c15aae4ec6a849f1b58c6b1cc2"
+      ],
+      "layout": "IPY_MODEL_06e8fd84d6224e5096088d66aad71961"
+     }
+    },
+    "f4ff06e2c48d4e58abe64cb7f41dd886": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4f57cfa7cb3b4199babf82dc9d93b074",
+      "placeholder": "​",
+      "style": "IPY_MODEL_053de11f995247f6b851909a6a8dfc16",
+      "value": "Downloading (…)cial_tokens_map.json: 100%"
+     }
+    },
+    "f62ffbdc24734b999f36058d9edca81f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "f66e179caa8b4393bed19a0488821c47": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f742450a607c4ed0bff98ac9b7685d40": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e293930c8e2c4eadbda53005e21ec450",
+      "max": 2424064,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_945ac449c2e84fd6b5a7805b017343f2",
+      "value": 2424064
+     }
+    },
+    "f79eeece093f4b0e9de6dbc346a3fa19": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "f9620e01cd6749f88b722a42ff68c502": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "fb6877c376e0430296b2746513f60931": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "fd08c4fbe5d84dd893d87a5e2f2d082d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6f30253108fb4dce9c3de029457ef6f1",
+      "placeholder": "​",
+      "style": "IPY_MODEL_1fa2a7e3ff3c4c99ab95e96a28624846",
+      "value": " 1/1 [00:00&lt;00:00, 22.88ba/s]"
+     }
+    }
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/int8_training/Finetune_opt_bnb_peft.ipynb b/examples/int8_training/Finetune_opt_bnb_peft.ipynb
new file mode 100644
index 0000000..99ab2a3
--- /dev/null
+++ b/examples/int8_training/Finetune_opt_bnb_peft.ipynb
@@ -0,0 +1,9276 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "WE5GJ6s7y0Xo"
+   },
+   "source": [
+    "## Fine-tune large models using 🤗 `peft` adapters, `transformers` & `bitsandbytes`\n",
+    "\n",
+    "In this tutorial we will cover how we can fine-tune large language models using the very recent `peft` library and `bitsandbytes` for loading large models in 8-bit.\n",
+    "The fine-tuning method will rely on a recent method called \"Low Rank Adapters\" (LoRA), instead of fine-tuning the entire model you just have to fine-tune these adapters and load them properly inside the model. \n",
+    "After fine-tuning the model you can also share your adapters on the 🤗 Hub and load them very easily. Let's get started!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "TfBzP8gWzkpv"
+   },
+   "source": [
+    "### Install requirements\n",
+    "\n",
+    "First, run the cells below to install the requirements:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "otj46qRbtpnd",
+    "outputId": "2aa109f6-3f4e-4887-a16e-336f51e7cc9a"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m76.3/76.3 MB\u001b[0m \u001b[31m10.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m462.8/462.8 KB\u001b[0m \u001b[31m25.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m199.7/199.7 KB\u001b[0m \u001b[31m25.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m190.3/190.3 KB\u001b[0m \u001b[31m23.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m213.0/213.0 KB\u001b[0m \u001b[31m26.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m132.0/132.0 KB\u001b[0m \u001b[31m18.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m140.6/140.6 KB\u001b[0m \u001b[31m20.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25h  Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n",
+      "  Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n",
+      "  Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
+      "  Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n",
+      "  Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n",
+      "  Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m7.6/7.6 MB\u001b[0m \u001b[31m72.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25h  Building wheel for transformers (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
+      "  Building wheel for peft (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n"
+     ]
+    }
+   ],
+   "source": [
+    "!pip install -q datasets==3.6.0 accelerate\n",
+    "!pip install -q git+https://github.com/bitsandbytes-foundation/bitsandbytes.git\n",
+    "!pip install -q git+https://github.com/huggingface/transformers.git@main git+https://github.com/huggingface/peft.git"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "FOtwYRI3zzXI"
+   },
+   "source": [
+    "### Model loading\n",
+    "\n",
+    "Here let's load the `opt-6.7b` model, its weights in half-precision (float16) are about 13GB on the Hub! If we load them in 8-bit we would require around 7GB of memory instead."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 408,
+     "referenced_widgets": [
+      "d4de260ffd8a440eb87eb900fc1bb1d3",
+      "8602b545a9f8474dbb3cc178ac0b8e60",
+      "b46919912ee54f6f9f2ce9080be1c61a",
+      "50374e3ab81c4626a182e61fc03b94ce",
+      "2144bc2897dc40b29f060e30ace12275",
+      "949ca70002ca4472bbc21fea4d7ac745",
+      "49943c9dadca43a584b3f354ba45280c",
+      "6123e53fb26b41f0af9a3a3348ae1afd",
+      "285ef943d540400ab827c462945a259c",
+      "95727290446244ccb9626f4594949675",
+      "61b54aa6c9e94ee1bc45c15a9e3f7917",
+      "fc2d5ffe254d425b939252ec46ec27cc",
+      "f65af2e868244edeb0cc9402534874a8",
+      "e466054f08004bbcabb24e400cb3c7fc",
+      "6ea40800dfd849e3b106bae71fc53ae3",
+      "722a01f42b7d4c38836a4546ecb38108",
+      "1bd5179cdb474b65aa06eca3520ad37b",
+      "04d367124a3b419ab1fa1dfd4f9004c3",
+      "4ea667f48b9f4e1f9da7c5a0d3025b85",
+      "9b96c63630654773acd38b8b88371f28",
+      "cb69ae47666a4603a07a8778e2ae7d6e",
+      "8f5e9f2d11d54fd2a08dcbff9f6da05c",
+      "c6f712eadc4d49019b2bd355968cc155",
+      "5fd979c05fd34311af877ce1a988ead8",
+      "179165ff4c0e4586aaf3a40b8502f428",
+      "cad1d8326e474a4f9ee13db9005121dd",
+      "b049ac0b3d2e44ba9b1fc1cb2dd3de62",
+      "921c268ecd724b6a8869dae8f81d558a",
+      "4cf85a85c0764f15b5134c81b360e910",
+      "5936d9eb59e147eea6482006decfe0ee",
+      "fad61c68edc84c8197afeafded84280d",
+      "451309d8b3ca4cd9b6f538640477039e",
+      "c7621e14aa16421d9758321e433b92e4",
+      "5aa74b9b30614172b07f88873cf89471",
+      "cf39fb025e3d4635a5695135a56d9f64",
+      "deaf9732f33446a3be015d2ec16aba76",
+      "bdfd856dd8ee4ae09205ad9d1b9cc806",
+      "7a49f7a55b054b6d829f290a1a426a7a",
+      "5b695486a0ac442b8b6a8ef2ebf4e57a",
+      "03be7cb91cba4afab795aab7aa242ee1",
+      "8f7890f54d514f80b1eb17905cf0f964",
+      "ae660d51267544a89f0ad199cc12b6fa",
+      "d5bb8d7359274c8e9cc79df563175137",
+      "98d5a80ec50c46c18f9ee991e2982115",
+      "e73e5388182040a8937ccf1748171a87",
+      "f797f7b8b13f4b3cb871522d34498631",
+      "41f47c864e094cacb1c550d37ddfe80e",
+      "104d982b444947fe8e4fbb2c2f082616",
+      "2cf8581583c641fb95d1e16aff7d4cd1",
+      "11808e9097424dd0b22a5af6c77813f3",
+      "dc08d237860e4788a8ceeff4518c2612",
+      "7bbf2c40a4ae46fe9e5885db08975263",
+      "f00cbc4a89f5492787ec489da65ff70b",
+      "8a7cd2194113493a841b00d034b5f1ba",
+      "e9673363e85448d494ac9ac5d7ba0efb",
+      "a994beafbf3f4c20880a7bbe3898db36",
+      "7769c261781f4f5483c7e9d58c1a5573",
+      "4a713a8fe16f4e81aa841c69711fa136",
+      "08d036904ecf47ed88e129ba6e2b285c",
+      "9f1182fdddab43b59ee98bc701965a17",
+      "c2302f535b114ad780bfa440445c2e28",
+      "8fe032f285ba4858b8efd68119c217b0",
+      "4ca695fca3d140c6ab4e1e1d34df807b",
+      "b77ceaf55dc04810963cdd01126478f6",
+      "0ccdefcb25e14d229b2634ffae4a6d3d",
+      "11d6b952503c4824b36b66e228f87599",
+      "1e9391f6c89c4d08859ef3413edb19be",
+      "039bbda2402f469eb21ba7ec7ea589a6",
+      "5da6eef8fb0048219159f38a68727b64",
+      "c006e62ee6d04831b2b89273ef04a8ac",
+      "af0634c2539a43989902daef47776901",
+      "62fea00ef0364af287e6097b964d00c4",
+      "9e5ef73f8b244845a6b9002fa5c35d15",
+      "5cb09c84e1e144e0a92580fb5e1ce2fe",
+      "0f561c1660744251a8f710b69d434c87",
+      "9e5f870ef80242f5af09fad70f84ea62",
+      "6f173ca73dd545deb22b8cd0470d925f",
+      "4e6d5943bc374b388b93ed115e44b6a5",
+      "cbe2a6ea41834e95a27d6f02c3c0eeec",
+      "7beb5f4efefc4593abac253df74d1405",
+      "370cefbaeebf41f582b7507ad493055f",
+      "e3df9dda16e244aa9b61d54f9e21ef40",
+      "23d2ad64a17041b7a006dad1e041e0a1",
+      "c1fd6a1234274a44b838a09f3f5380c6",
+      "81bb51d088374394becd9a45ec3b17d4",
+      "9e762779e5434bb7afcc295b61c2f4e4",
+      "f539b7a4665449de9eac209a20629969",
+      "32d528db79ad4f6f836ab2e0df5ac426",
+      "1ca7684b79c5438fa06b047bd2b3283f",
+      "a07688185bff4c4b8cbed3af3b4cf802",
+      "0272f1d9f93f4dd788363a8409cdfd69",
+      "27b41d23d2c64127ba3ae8464958f855",
+      "2b54032c0d8e4a2897aed1ac1c79af14",
+      "ed8fa1048e814f2fa3666899fc42e55a",
+      "97daf559100c44ac983562fea93c5fac",
+      "72e511b775604d899ff5b3fa2ebe9fc4",
+      "da946f86590447d2ab98b9da468fa66b",
+      "54fe79d5c7254117a2209927a7248dd4",
+      "1d122e4eaad54e06961288484f31e18b",
+      "d46b5725c35142a89617e46c0e8d3679",
+      "c5493c23fd5542738ffd1ff5f09a6a67",
+      "a1a80d3460984c2496ada5a634875934",
+      "598c5584ffba4f26815c4e87bb1595c4",
+      "fe93f25323604447be0bb1d24a0c2c59",
+      "00c2e2d3ee8b45818ba84da12c6b11e2",
+      "6ccea64c2e614a9fbdcc2f716cecaea0",
+      "63fc9a9eebca4f2db2ed8a385fc5e204",
+      "9a4860dfeac944db85e6e532599bc1cb",
+      "3b946e1bbab24629b98307275fbe7cbb",
+      "d9d36f8ff5f747bf90fbc8a7d35a6664"
+     ]
+    },
+    "id": "cg3fiQOvmI3Q",
+    "outputId": "135a7675-6a4d-4786-b5dc-34cb867f40c7"
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "bee2f575b3e64c30b2f3afa137802406",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Loading checkpoint shards:   0%|          | 0/2 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import os\n",
+    "\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import bitsandbytes as bnb\n",
+    "from transformers import AutoTokenizer, AutoConfig, AutoModelForCausalLM, BitsAndBytesConfig\n",
+    "\n",
+    "model = AutoModelForCausalLM.from_pretrained(\"facebook/opt-6.7b\", quantization_config=BitsAndBytesConfig(load_in_8bit=True))\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(\"facebook/opt-6.7b\")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "9fTSZntA1iUG"
+   },
+   "source": [
+    "### Prepare model for training\n",
+    "\n",
+    "Some pre-processing needs to be done before training such an int8 model using `peft`, therefore let's import an utiliy function `prepare_model_for_kbit_training` that will: \n",
+    "- Casts all the non `int8` modules to full precision (`fp32`) for stability\n",
+    "- Add a `forward_hook` to the input embedding layer to enable gradient computation of the input hidden states\n",
+    "- Enable gradient checkpointing for more memory-efficient training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "id": "T-gy-LxM0yAi"
+   },
+   "outputs": [],
+   "source": [
+    "from peft import prepare_model_for_kbit_training\n",
+    "\n",
+    "model = prepare_model_for_kbit_training(model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "KwOTr7B3NlM3"
+   },
+   "source": [
+    "### Apply LoRA\n",
+    "\n",
+    "Here comes the magic with `peft`! Let's load a `PeftModel` and specify that we are going to use low-rank adapters (LoRA) using `get_peft_model` utility function from `peft`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "id": "4W1j6lxaNnxC"
+   },
+   "outputs": [],
+   "source": [
+    "def print_trainable_parameters(model):\n",
+    "    \"\"\"\n",
+    "    Prints the number of trainable parameters in the model.\n",
+    "    \"\"\"\n",
+    "    trainable_params = 0\n",
+    "    all_param = 0\n",
+    "    for _, param in model.named_parameters():\n",
+    "        all_param += param.numel()\n",
+    "        if param.requires_grad:\n",
+    "            trainable_params += param.numel()\n",
+    "    print(\n",
+    "        f\"trainable params: {trainable_params} || all params: {all_param} || trainable%: {100 * trainable_params / all_param}\"\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "4iwHGzKBN6wk",
+    "outputId": "039f7175-14c9-42b4-a078-80d27aab161c"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "trainable params: 8388608 || all params: 6666862592 || trainable%: 0.12582542214183376\n"
+     ]
+    }
+   ],
+   "source": [
+    "from peft import LoraConfig, get_peft_model\n",
+    "\n",
+    "config = LoraConfig(\n",
+    "    r=16, lora_alpha=32, target_modules=[\"q_proj\", \"v_proj\"], lora_dropout=0.05, bias=\"none\", task_type=\"CAUSAL_LM\"\n",
+    ")\n",
+    "\n",
+    "model = get_peft_model(model, config)\n",
+    "print_trainable_parameters(model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "QdjWif4CVXR6"
+   },
+   "source": [
+    "### Training"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "b_RPiO7f3ClX"
+   },
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 1000,
+     "referenced_widgets": [
+      "f357166c6e5f43f39d0a287ca6d6f60e",
+      "805a10c2fd794ff692e8ebeefd65f2eb",
+      "3730f843399d4ba48e98383563283e94",
+      "f855aced7ca2485ea720604359deaa18",
+      "6d728366de1a4bacb1ba1939c5e0146f",
+      "c57c7cf35bf04f3bb3b2b0d8ce7feb31",
+      "2113970533604749a808fa1b98269b0e",
+      "fc15c6d6eb3049a3b8542b332dd8a3f2",
+      "b6c06e70d7ed48f1840086489300cb3d",
+      "49504531deaf4449938bea751d1ec4e7",
+      "7dfe540a75864cf390b3bed20ab1dcd9",
+      "c81d20fe47ce4b7594427830d71504d7",
+      "a14542c8431c48b48a614cfd0d41f03c",
+      "856f3dcf949741acb394f252186a1d7e",
+      "865bae11c917492a9a1ef7286a493bd5",
+      "2561b7a7c1694f229d30d2b1eeb14b2f",
+      "96bd12acd63a4232b2f4ac159cc4a768",
+      "746c8a2fd0ee458bad85cc75ac333e43",
+      "ce6de6f9ddde4a6d8094a2b96eac3a4e",
+      "62ceac028f144120a24e75afbaccf306",
+      "2f953abe023240558580dcff3f0c033e",
+      "c2b42681b8bb47e3895d6105240c5812",
+      "ae58b3f129644729aa2f890b1712fc6e",
+      "74a968ce2dc34189b7dfbb39276f5138",
+      "d4f5b19f75e246df9c688f625792e8ba",
+      "5cd7a5bbab5f4f2daa53d984568ea630",
+      "7288f4fd6bb44089baef9f20f50e0e04",
+      "57ff7d85e56f49239d1eeedd43b88d22",
+      "4d5cbca8d5e647669faeea32de761dcd",
+      "a6ce291698ad460394433a49000c1d25",
+      "aa54b2a9b43848b0902d135beffb806b",
+      "8cd2073cd3304b2ca4b997127aa88bd1",
+      "f51c7f18977447e2bca36e1da3e1be4f",
+      "b8c29c1accf4479da91d393dd59ca82b",
+      "5fa269b8704e4509bf8cd918b657ae23",
+      "ac91fc78fb04436b80a0a2cbe4380c2b",
+      "5db87509bf56435eafaea4cf1153a5d3",
+      "840981ef419a48918cf000f89807890e",
+      "2c27ab87b28946e39681a29cc6f14ea9",
+      "c4ab408eb1344da0bb15a9a6760818e4",
+      "d54e8d69575f49eb977da64abc5ceb0c",
+      "548299d96190406391cab49ad29cc5d6",
+      "c41a9d785e884ab0a58117d17ac7d228",
+      "256c56849e8545018514fd52f1247501",
+      "041944011c204558a4315c27ec5dabce",
+      "1247ee7aeac5406e93e22313d54ef54a",
+      "ed2736d862a94d8f9db9ba6037016071",
+      "ddc333530c13446a91cf332846bfa22f",
+      "3d2325879cfa48048e81c44e2c2444d5",
+      "7573358a50bd446486b4c5528a298fae",
+      "663c338f84c94b63bc05b0fb6835d99f",
+      "3185bd8ecbde4f26b8ed0f92cf79e14f",
+      "ddc36fdbdd634dc489f658bead61e7ee",
+      "d7e33c29d410414eb452d121edd9920e",
+      "d3511ce1754b41969e5c36a5b33ac466",
+      "9225dd50bcea435289fa2eba64087076",
+      "a23144916f02459b966b9830f0a1d64c",
+      "c9b718882fec4254bce1f33fa9373921",
+      "f27905d0073e493cb9dcd174c0f15e35",
+      "0f634721a70d4e749cb616e55ab747b3",
+      "e1f62cbd805d4b8aa9aba7e345c21c82",
+      "893d8cb7857147ba82ac86d140f69a5c",
+      "4884bf82f5814e049c47cf6d496aab08",
+      "432fc8277ebc492f91d6b46ed073ccb4",
+      "c423a3cc0b504828b11077c77268ed92",
+      "668dd47eec9942bcad0af209772cf8e6",
+      "a618f430e06645eb9c95bf16bb6ea59a",
+      "bba20d9bf1974a7f8d1ebcb9f5c4cd49",
+      "5cec06ccf9074e019ea1f7daf17a0319",
+      "faf24b3ed994422f8dd806ae0cc30531",
+      "79f7929f423d493caf86b548e91e8a42",
+      "23cb4d44c4534bae80357c8a9f6b86ba",
+      "4fa82dbe7d3a4b3996b1fa1cf9c23498",
+      "6eee224b244a4cafb3fc0f3b16eb0d03",
+      "73344836205f4569a4113c24985bd5b1",
+      "86dff0987bf040da99c8f2846da26d86",
+      "63f8ad255d2147128bdc26f47fdf2528"
+     ]
+    },
+    "id": "AQ_HCYruWIHU",
+    "outputId": "e9baadaf-e202-413d-87f0-74c730d78408"
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f357166c6e5f43f39d0a287ca6d6f60e",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading readme:   0%|          | 0.00/5.55k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:datasets.builder:Using custom data configuration Abirate--english_quotes-6e72855d06356857\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Downloading and preparing dataset json/Abirate--english_quotes to /root/.cache/huggingface/datasets/Abirate___json/Abirate--english_quotes-6e72855d06356857/0.0.0/0f7e3662623656454fcd2b650f34e886a7db4b9104504885bd462096cc7a9f51...\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c81d20fe47ce4b7594427830d71504d7",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading data files:   0%|          | 0/1 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ae58b3f129644729aa2f890b1712fc6e",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading data:   0%|          | 0.00/647k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b8c29c1accf4479da91d393dd59ca82b",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Extracting data files:   0%|          | 0/1 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "041944011c204558a4315c27ec5dabce",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Generating train split: 0 examples [00:00, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dataset json downloaded and prepared to /root/.cache/huggingface/datasets/Abirate___json/Abirate--english_quotes-6e72855d06356857/0.0.0/0f7e3662623656454fcd2b650f34e886a7db4b9104504885bd462096cc7a9f51. Subsequent calls will reuse this data.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "9225dd50bcea435289fa2eba64087076",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/1 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a618f430e06645eb9c95bf16bb6ea59a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/3 [00:00<?, ?ba/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "The model is loaded in 8-bit precision. To train this model you need to add additional modules inside the model such as adapters using `peft` library and freeze the model weights. Please check  the examples in https://github.com/huggingface/peft for more details.\n",
+      "max_steps is given, it will override any value given in num_train_epochs\n",
+      "Using cuda_amp half precision backend\n",
+      "The following columns in the training set don't have a corresponding argument in `PeftModelForCausalLM.forward` and have been ignored: author, tags, quote. If author, tags, quote are not expected by `PeftModelForCausalLM.forward`,  you can safely ignore this message.\n",
+      "/usr/local/lib/python3.8/dist-packages/transformers/optimization.py:306: FutureWarning: This implementation of AdamW is deprecated and will be removed in a future version. Use the PyTorch implementation torch.optim.AdamW instead, or set `no_deprecation_warning=True` to disable this warning\n",
+      "  warnings.warn(\n",
+      "***** Running training *****\n",
+      "  Num examples = 2508\n",
+      "  Num Epochs = 2\n",
+      "  Instantaneous batch size per device = 4\n",
+      "  Total train batch size (w. parallel, distributed & accumulation) = 16\n",
+      "  Gradient Accumulation steps = 4\n",
+      "  Total optimization steps = 200\n",
+      "  Number of trainable parameters = 8388608\n",
+      "/usr/local/lib/python3.8/dist-packages/bitsandbytes/autograd/_functions.py:298: UserWarning: MatMul8bitLt: inputs will be cast from torch.float32 to float16 during quantization\n",
+      "  warnings.warn(f\"MatMul8bitLt: inputs will be cast from {A.dtype} to float16 during quantization\")\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "    <div>\n",
+       "      \n",
+       "      <progress value='153' max='200' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
+       "      [153/200 26:04 < 08:06, 0.10 it/s, Epoch 0.97/2]\n",
+       "    </div>\n",
+       "    <table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       " <tr style=\"text-align: left;\">\n",
+       "      <th>Step</th>\n",
+       "      <th>Training Loss</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <td>1</td>\n",
+       "      <td>2.364400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>2</td>\n",
+       "      <td>2.200400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>3</td>\n",
+       "      <td>2.302300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>4</td>\n",
+       "      <td>2.184700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>5</td>\n",
+       "      <td>1.878700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>6</td>\n",
+       "      <td>2.307200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>7</td>\n",
+       "      <td>2.193800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>8</td>\n",
+       "      <td>2.446200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>9</td>\n",
+       "      <td>2.458900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>10</td>\n",
+       "      <td>2.020000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>11</td>\n",
+       "      <td>1.941200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>12</td>\n",
+       "      <td>1.931000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>13</td>\n",
+       "      <td>2.055900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>14</td>\n",
+       "      <td>1.975100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>15</td>\n",
+       "      <td>2.015100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>16</td>\n",
+       "      <td>2.095600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>17</td>\n",
+       "      <td>1.768300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>18</td>\n",
+       "      <td>2.155700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>19</td>\n",
+       "      <td>2.402300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>20</td>\n",
+       "      <td>2.124600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>21</td>\n",
+       "      <td>2.314900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>22</td>\n",
+       "      <td>1.908500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>23</td>\n",
+       "      <td>2.078800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>24</td>\n",
+       "      <td>1.941900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>25</td>\n",
+       "      <td>1.879800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>26</td>\n",
+       "      <td>1.927500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>27</td>\n",
+       "      <td>1.371400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>28</td>\n",
+       "      <td>1.977600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>29</td>\n",
+       "      <td>2.055000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>30</td>\n",
+       "      <td>1.915800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>31</td>\n",
+       "      <td>1.958100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>32</td>\n",
+       "      <td>2.195900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>33</td>\n",
+       "      <td>2.001000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>34</td>\n",
+       "      <td>2.025000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>35</td>\n",
+       "      <td>1.576900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>36</td>\n",
+       "      <td>1.879800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>37</td>\n",
+       "      <td>1.821600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>38</td>\n",
+       "      <td>1.727800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>39</td>\n",
+       "      <td>1.995700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>40</td>\n",
+       "      <td>1.698600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>41</td>\n",
+       "      <td>2.129300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>42</td>\n",
+       "      <td>2.025800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>43</td>\n",
+       "      <td>1.696500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>44</td>\n",
+       "      <td>1.984700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>45</td>\n",
+       "      <td>2.051100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>46</td>\n",
+       "      <td>2.054400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>47</td>\n",
+       "      <td>1.765600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>48</td>\n",
+       "      <td>2.063100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>49</td>\n",
+       "      <td>1.746900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>50</td>\n",
+       "      <td>1.873000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>51</td>\n",
+       "      <td>2.391300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>52</td>\n",
+       "      <td>2.494100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>53</td>\n",
+       "      <td>2.072300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>54</td>\n",
+       "      <td>1.808000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>55</td>\n",
+       "      <td>1.911900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>56</td>\n",
+       "      <td>2.168100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>57</td>\n",
+       "      <td>2.166100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>58</td>\n",
+       "      <td>1.921500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>59</td>\n",
+       "      <td>1.856000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>60</td>\n",
+       "      <td>1.652800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>61</td>\n",
+       "      <td>1.605000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>62</td>\n",
+       "      <td>2.032500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>63</td>\n",
+       "      <td>1.822100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>64</td>\n",
+       "      <td>1.623600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>65</td>\n",
+       "      <td>1.923200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>66</td>\n",
+       "      <td>2.053200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>67</td>\n",
+       "      <td>2.114300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>68</td>\n",
+       "      <td>1.807700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>69</td>\n",
+       "      <td>1.857800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>70</td>\n",
+       "      <td>1.854600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>71</td>\n",
+       "      <td>2.023000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>72</td>\n",
+       "      <td>1.864900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>73</td>\n",
+       "      <td>1.769300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>74</td>\n",
+       "      <td>1.837700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>75</td>\n",
+       "      <td>1.742200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>76</td>\n",
+       "      <td>1.895900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>77</td>\n",
+       "      <td>1.922800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>78</td>\n",
+       "      <td>2.325300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>79</td>\n",
+       "      <td>2.231200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>80</td>\n",
+       "      <td>2.309500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>81</td>\n",
+       "      <td>1.945700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>82</td>\n",
+       "      <td>2.072100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>83</td>\n",
+       "      <td>1.917400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>84</td>\n",
+       "      <td>2.004600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>85</td>\n",
+       "      <td>1.951700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>86</td>\n",
+       "      <td>1.450600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>87</td>\n",
+       "      <td>1.785600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>88</td>\n",
+       "      <td>1.668000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>89</td>\n",
+       "      <td>1.903100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>90</td>\n",
+       "      <td>1.709800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>91</td>\n",
+       "      <td>2.312900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>92</td>\n",
+       "      <td>2.092100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>93</td>\n",
+       "      <td>2.319600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>94</td>\n",
+       "      <td>1.603100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>95</td>\n",
+       "      <td>1.740000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>96</td>\n",
+       "      <td>1.670500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>97</td>\n",
+       "      <td>1.611600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>98</td>\n",
+       "      <td>1.728900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>99</td>\n",
+       "      <td>2.285200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>100</td>\n",
+       "      <td>1.957800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>101</td>\n",
+       "      <td>1.676700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>102</td>\n",
+       "      <td>1.656300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>103</td>\n",
+       "      <td>1.612400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>104</td>\n",
+       "      <td>1.848900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>105</td>\n",
+       "      <td>1.870000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>106</td>\n",
+       "      <td>1.954000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>107</td>\n",
+       "      <td>2.192200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>108</td>\n",
+       "      <td>1.637600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>109</td>\n",
+       "      <td>1.208700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>110</td>\n",
+       "      <td>2.254200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>111</td>\n",
+       "      <td>1.832100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>112</td>\n",
+       "      <td>2.119600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>113</td>\n",
+       "      <td>2.126400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>114</td>\n",
+       "      <td>1.915700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>115</td>\n",
+       "      <td>1.587500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>116</td>\n",
+       "      <td>1.564800</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>117</td>\n",
+       "      <td>1.742700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>118</td>\n",
+       "      <td>1.712600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>119</td>\n",
+       "      <td>1.727900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>120</td>\n",
+       "      <td>2.361500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>121</td>\n",
+       "      <td>2.070300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>122</td>\n",
+       "      <td>1.878500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>123</td>\n",
+       "      <td>1.846600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>124</td>\n",
+       "      <td>2.061700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>125</td>\n",
+       "      <td>2.149700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>126</td>\n",
+       "      <td>1.940600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>127</td>\n",
+       "      <td>2.098300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>128</td>\n",
+       "      <td>1.734100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>129</td>\n",
+       "      <td>2.111700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>130</td>\n",
+       "      <td>1.887600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>131</td>\n",
+       "      <td>1.716300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>132</td>\n",
+       "      <td>2.070000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>133</td>\n",
+       "      <td>1.782200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>134</td>\n",
+       "      <td>1.955200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>135</td>\n",
+       "      <td>1.762900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>136</td>\n",
+       "      <td>1.954700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>137</td>\n",
+       "      <td>1.687100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>138</td>\n",
+       "      <td>1.979100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>139</td>\n",
+       "      <td>1.634600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>140</td>\n",
+       "      <td>1.801200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>141</td>\n",
+       "      <td>1.954100</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>142</td>\n",
+       "      <td>1.833900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>143</td>\n",
+       "      <td>2.051400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>144</td>\n",
+       "      <td>1.921200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>145</td>\n",
+       "      <td>1.787500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>146</td>\n",
+       "      <td>1.825400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>147</td>\n",
+       "      <td>1.363400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>148</td>\n",
+       "      <td>1.977400</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>149</td>\n",
+       "      <td>1.768300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>150</td>\n",
+       "      <td>2.226700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>151</td>\n",
+       "      <td>1.945500</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table><p>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import transformers\n",
+    "from datasets import load_dataset\n",
+    "\n",
+    "data = load_dataset(\"Abirate/english_quotes\")\n",
+    "data = data.map(lambda samples: tokenizer(samples[\"quote\"]), batched=True)\n",
+    "\n",
+    "trainer = transformers.Trainer(\n",
+    "    model=model,\n",
+    "    train_dataset=data[\"train\"],\n",
+    "    args=transformers.TrainingArguments(\n",
+    "        per_device_train_batch_size=4,\n",
+    "        gradient_accumulation_steps=4,\n",
+    "        warmup_steps=100,\n",
+    "        max_steps=200,\n",
+    "        learning_rate=2e-4,\n",
+    "        fp16=True,\n",
+    "        logging_steps=1,\n",
+    "        output_dir=\"outputs\",\n",
+    "    ),\n",
+    "    data_collator=transformers.DataCollatorForLanguageModeling(tokenizer, mlm=False),\n",
+    ")\n",
+    "model.config.use_cache = False  # silence the warnings. Please re-enable for inference!\n",
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Duak7T_B3VpJ"
+   },
+   "source": [
+    "## Share adapters on the 🤗 Hub"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 331,
+     "referenced_widgets": [
+      "262f01ffc5824b5faa8a61afac12ff67",
+      "c1af10b599da43a3a848f3ba816d7acc",
+      "be673691e713472980fa1132465714b4",
+      "01f8b90f0f184dfdb92c0c3bffb28b0f",
+      "9ad2bd0e92174d339a3a91a38253a180",
+      "bff17ef6aabd4aa681bfd5ad64b808d9",
+      "55633800b60a4336abea6a4adfcfdec1",
+      "73d5c6b4034d49b392b103d889bfb3b4",
+      "a55954b8d7bf4057b0d7aa6a1cb9e91a",
+      "4da42eb3846f423d88e2a6462a0cfce8",
+      "dab39ef354a84be3b37b6f151f9d9b9d",
+      "b88b03326f464c96a5656eef774e36d5",
+      "4eccb670e98043b3b2702821a3060ece",
+      "a333501a50df4b9fa9546d8d965e0dc3",
+      "1f173cb95c5c44f4b32f6cfe10ee3b03",
+      "52c8a7e673f24276a07042388a13b58f",
+      "a0f323ccfbc14fc4b7a5e7046b221ce3"
+     ]
+    },
+    "id": "DpYr24pR8T_0",
+    "outputId": "20186456-1bd4-4655-b2f2-8f24f9f37fcc"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Token is valid.\n",
+      "Your token has been saved to /root/.cache/huggingface/token\n",
+      "Login successful\n"
+     ]
+    }
+   ],
+   "source": [
+    "from huggingface_hub import notebook_login\n",
+    "\n",
+    "notebook_login()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 133,
+     "referenced_widgets": [
+      "3dbe077ed0c34e4eb1628418138ccbc6",
+      "a579cb7804774ca3aa9efd800d1af57e",
+      "9f44e3175835470aba43e239661037b2",
+      "549bd12e3af64256a7534903688835a8",
+      "a18d9beb34b848ff8cc541d2cb290c4c",
+      "876cb42184f54b749c442163290c2c45",
+      "43b14e0e1263499dbd592b280cff21b0",
+      "7164feaf360d4300a5083f95064b144a",
+      "bd7547126a874a45b608afed7ab2958b",
+      "26e4b6b94e4540728c59df8e481ce43d",
+      "9d1b77500f1c45308d4791a9c443e307",
+      "b2693135b6954d35afb3120f3caf4000",
+      "aeca2429ee48450a814515cb06acbc3e",
+      "434c09950be04d728cd7ca8d6c134dc6",
+      "34f58c132d2e4249b1e62a0b57c85999",
+      "d148369be26a43949257790cb202728d",
+      "0ecf58c5cbcd40908595fccddff1c6d4",
+      "fc2314656a2745eb921f636cc3451381",
+      "7817f8669b7f449fadf02d7145fa89e2",
+      "06e012eea9714ed589344a362b7421bb",
+      "504e9e5ced0348cc87aafae0c1c372eb",
+      "5b538e8389fb4574a5dfdc554624e3c8"
+     ]
+    },
+    "id": "VxB6UV5XAvvP",
+    "outputId": "c3b0133b-f5b1-4283-8367-f06524bea46c"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Uploading the following files to ybelkada/opt-6.7b-lora: adapter_config.json,adapter_model.bin\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "3dbe077ed0c34e4eb1628418138ccbc6",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Upload 1 LFS files:   0%|          | 0/1 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b2693135b6954d35afb3120f3caf4000",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "adapter_model.bin:   0%|          | 0.00/33.6M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "CommitInfo(commit_url='https://huggingface.co/ybelkada/opt-6.7b-lora/commit/6f240b184e666b54a51b3fe482e4711448e6c751', commit_message='Upload model', commit_description='', oid='6f240b184e666b54a51b3fe482e4711448e6c751', pr_url=None, pr_revision=None, pr_num=None)"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.push_to_hub(\"ybelkada/opt-6.7b-lora\", use_auth_token=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "S65GcxNGA9kz"
+   },
+   "source": [
+    "## Load adapters from the Hub\n",
+    "\n",
+    "You can also directly load adapters from the Hub using the commands below:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 517,
+     "referenced_widgets": [
+      "ff2454cf69b346fea70070522cf93689",
+      "87b36eb4ad3b4047a32c7d67a5aabc5e",
+      "8bf9fd4bd28e4bc1b5895bc9315e727e",
+      "01845549768a4db580b5555809e83342",
+      "a490025901df478f93be1f19c1be4b09",
+      "4f0c97b8555942aea6a8003228c07427",
+      "80aea5c9422648ef91292d75fb46c8dc",
+      "8af46fc543bf46a68ac78c2e8e7e9ddc",
+      "b7b8897c988445ae8f9db9b928674477",
+      "4bc518f16b7644e5a11bda66cc285d89",
+      "441a953149814848a24edc9398a2ef63",
+      "75913676a5df43fbbfe744b8882188df",
+      "1e94c570880449d0a2763bc1eba09057",
+      "d72bd17e161442b0979dceaaef66d82c",
+      "2396a162f70d41a384afd1fcb2f78d11",
+      "39f1a52884e3440c8b521e493d6e1a53",
+      "528b93d088054955906282b1c9f93a17",
+      "99b9d36317a34143acf982fa3b089fda",
+      "4f592d7632fd440aac0bf97ceed2de75",
+      "1b515483e5884479b2101127c16321d4",
+      "ce8d4bac782949579a2e52864455d9de",
+      "523deba849044669bfe8c959750708fc"
+     ]
+    },
+    "id": "hsD1VKqeA62Z",
+    "outputId": "83ecbf31-3f84-4b8e-d667-10317f7adcec"
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "621d427f78fb458e8ae25262f2ab7ca8",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading (…)/adapter_config.json:   0%|          | 0.00/332 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "4a2107423a164efd89002e031126c8b5",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Loading checkpoint shards:   0%|          | 0/2 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "43f2a9b0f37e4caab35d7dda43f051f9",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading adapter_model.bin:   0%|          | 0.00/33.6M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "from peft import PeftModel, PeftConfig\n",
+    "from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig\n",
+    "\n",
+    "peft_model_id = \"ybelkada/opt-6.7b-lora\"\n",
+    "config = PeftConfig.from_pretrained(peft_model_id)\n",
+    "model = AutoModelForCausalLM.from_pretrained(\n",
+    "    config.base_model_name_or_path, return_dict=True, quantization_config=BitsAndBytesConfig(load_in_8bit=True), device_map=\"auto\"\n",
+    ")\n",
+    "tokenizer = AutoTokenizer.from_pretrained(config.base_model_name_or_path)\n",
+    "\n",
+    "# Load the Lora model\n",
+    "model = PeftModel.from_pretrained(model, peft_model_id)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "MHYljmTjj5wX"
+   },
+   "source": [
+    "## Inference\n",
+    "\n",
+    "You can then directly use the trained model or the model that you have loaded from the 🤗 Hub for inference as you would do it usually in `transformers`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "MDqJWba-tpnv",
+    "outputId": "dd65644f-6921-46e1-920c-400bd7d888cf"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/marc/anaconda3/envs/accelerate/lib/python3.10/site-packages/transformers/generation/utils.py:1448: UserWarning: You are calling .generate() with the `input_ids` being on a device type different than your model's device. `input_ids` is on cpu, whereas the model is on cuda. You may experience unexpected behaviors or slower generation. Please make sure that you have put `input_ids` to the correct device by calling for example input_ids = input_ids.to('cuda') before running `.generate()`.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      " Two things are infinite:  the universe and human stupidity; and I'm not sure about the universe.  -Albert Einstein\n",
+      "I'm not sure about the universe either.\n"
+     ]
+    }
+   ],
+   "source": [
+    "batch = tokenizer(\"Two things are infinite: \", return_tensors=\"pt\").to(model.device)\n",
+    "\n",
+    "device_type = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "with torch.amp.autocast(device_type=device_type):\n",
+    "    output_tokens = model.generate(**batch, max_new_tokens=50)\n",
+    "\n",
+    "print(\"\\n\\n\", tokenizer.decode(output_tokens[0], skip_special_tokens=True))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "HZL8ZbcJCHoy"
+   },
+   "source": [
+    "As you can see by fine-tuning for few steps we have almost recovered the quote from Albert Einstein that is present in the [training data](https://huggingface.co/datasets/Abirate/english_quotes)."
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "machine_shape": "hm",
+   "provenance": []
+  },
+  "gpuClass": "standard",
+  "kernelspec": {
+   "display_name": "Python 3.10.11 ('accelerate': conda)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.11"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "1219a10c7def3e2ad4f431cfa6f49d569fcc5949850132f23800e792129eefbb"
+   }
+  },
+  "widgets": {
+   "application/vnd.jupyter.widget-state+json": {
+    "00c2e2d3ee8b45818ba84da12c6b11e2": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "01845549768a4db580b5555809e83342": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4bc518f16b7644e5a11bda66cc285d89",
+      "placeholder": "​",
+      "style": "IPY_MODEL_441a953149814848a24edc9398a2ef63",
+      "value": " 2/2 [01:04&lt;00:00, 29.33s/it]"
+     }
+    },
+    "01f8b90f0f184dfdb92c0c3bffb28b0f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "CheckboxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "CheckboxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "CheckboxView",
+      "description": "Add token as git credential?",
+      "description_tooltip": null,
+      "disabled": false,
+      "indent": true,
+      "layout": "IPY_MODEL_b88b03326f464c96a5656eef774e36d5",
+      "style": "IPY_MODEL_4eccb670e98043b3b2702821a3060ece",
+      "value": false
+     }
+    },
+    "0272f1d9f93f4dd788363a8409cdfd69": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_72e511b775604d899ff5b3fa2ebe9fc4",
+      "max": 456318,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_da946f86590447d2ab98b9da468fa66b",
+      "value": 456318
+     }
+    },
+    "039bbda2402f469eb21ba7ec7ea589a6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_62fea00ef0364af287e6097b964d00c4",
+      "placeholder": "​",
+      "style": "IPY_MODEL_9e5ef73f8b244845a6b9002fa5c35d15",
+      "value": "Downloading (…)okenizer_config.json: 100%"
+     }
+    },
+    "03be7cb91cba4afab795aab7aa242ee1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "041944011c204558a4315c27ec5dabce": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_1247ee7aeac5406e93e22313d54ef54a",
+       "IPY_MODEL_ed2736d862a94d8f9db9ba6037016071",
+       "IPY_MODEL_ddc333530c13446a91cf332846bfa22f"
+      ],
+      "layout": "IPY_MODEL_3d2325879cfa48048e81c44e2c2444d5"
+     }
+    },
+    "04d367124a3b419ab1fa1dfd4f9004c3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "06e012eea9714ed589344a362b7421bb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "08d036904ecf47ed88e129ba6e2b285c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_0ccdefcb25e14d229b2634ffae4a6d3d",
+      "placeholder": "​",
+      "style": "IPY_MODEL_11d6b952503c4824b36b66e228f87599",
+      "value": " 137/137 [00:00&lt;00:00, 5.13kB/s]"
+     }
+    },
+    "0ccdefcb25e14d229b2634ffae4a6d3d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0ecf58c5cbcd40908595fccddff1c6d4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0f561c1660744251a8f710b69d434c87": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "0f634721a70d4e749cb616e55ab747b3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "104d982b444947fe8e4fbb2c2f082616": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8a7cd2194113493a841b00d034b5f1ba",
+      "placeholder": "​",
+      "style": "IPY_MODEL_e9673363e85448d494ac9ac5d7ba0efb",
+      "value": " 2/2 [00:59&lt;00:00, 27.25s/it]"
+     }
+    },
+    "11808e9097424dd0b22a5af6c77813f3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "11d6b952503c4824b36b66e228f87599": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "1247ee7aeac5406e93e22313d54ef54a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7573358a50bd446486b4c5528a298fae",
+      "placeholder": "​",
+      "style": "IPY_MODEL_663c338f84c94b63bc05b0fb6835d99f",
+      "value": "Generating train split: "
+     }
+    },
+    "179165ff4c0e4586aaf3a40b8502f428": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5936d9eb59e147eea6482006decfe0ee",
+      "max": 9960750957,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_fad61c68edc84c8197afeafded84280d",
+      "value": 9960750957
+     }
+    },
+    "1b515483e5884479b2101127c16321d4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "1bd5179cdb474b65aa06eca3520ad37b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1ca7684b79c5438fa06b047bd2b3283f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_a07688185bff4c4b8cbed3af3b4cf802",
+       "IPY_MODEL_0272f1d9f93f4dd788363a8409cdfd69",
+       "IPY_MODEL_27b41d23d2c64127ba3ae8464958f855"
+      ],
+      "layout": "IPY_MODEL_2b54032c0d8e4a2897aed1ac1c79af14"
+     }
+    },
+    "1d122e4eaad54e06961288484f31e18b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "1e9391f6c89c4d08859ef3413edb19be": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_039bbda2402f469eb21ba7ec7ea589a6",
+       "IPY_MODEL_5da6eef8fb0048219159f38a68727b64",
+       "IPY_MODEL_c006e62ee6d04831b2b89273ef04a8ac"
+      ],
+      "layout": "IPY_MODEL_af0634c2539a43989902daef47776901"
+     }
+    },
+    "1e94c570880449d0a2763bc1eba09057": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_528b93d088054955906282b1c9f93a17",
+      "placeholder": "​",
+      "style": "IPY_MODEL_99b9d36317a34143acf982fa3b089fda",
+      "value": "Downloading (…)&quot;adapter_model.bin&quot;;: 100%"
+     }
+    },
+    "1f173cb95c5c44f4b32f6cfe10ee3b03": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ButtonStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ButtonStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "button_color": null,
+      "font_weight": ""
+     }
+    },
+    "2113970533604749a808fa1b98269b0e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "2144bc2897dc40b29f060e30ace12275": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2396a162f70d41a384afd1fcb2f78d11": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_ce8d4bac782949579a2e52864455d9de",
+      "placeholder": "​",
+      "style": "IPY_MODEL_523deba849044669bfe8c959750708fc",
+      "value": " 33.6M/33.6M [00:03&lt;00:00, 12.1MB/s]"
+     }
+    },
+    "23cb4d44c4534bae80357c8a9f6b86ba": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "23d2ad64a17041b7a006dad1e041e0a1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2561b7a7c1694f229d30d2b1eeb14b2f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "256c56849e8545018514fd52f1247501": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "262f01ffc5824b5faa8a61afac12ff67": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "VBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "VBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "VBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_c1af10b599da43a3a848f3ba816d7acc",
+       "IPY_MODEL_be673691e713472980fa1132465714b4",
+       "IPY_MODEL_01f8b90f0f184dfdb92c0c3bffb28b0f",
+       "IPY_MODEL_9ad2bd0e92174d339a3a91a38253a180",
+       "IPY_MODEL_bff17ef6aabd4aa681bfd5ad64b808d9"
+      ],
+      "layout": "IPY_MODEL_55633800b60a4336abea6a4adfcfdec1"
+     }
+    },
+    "26e4b6b94e4540728c59df8e481ce43d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "27b41d23d2c64127ba3ae8464958f855": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_54fe79d5c7254117a2209927a7248dd4",
+      "placeholder": "​",
+      "style": "IPY_MODEL_1d122e4eaad54e06961288484f31e18b",
+      "value": " 456k/456k [00:00&lt;00:00, 498kB/s]"
+     }
+    },
+    "285ef943d540400ab827c462945a259c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "2b54032c0d8e4a2897aed1ac1c79af14": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2c27ab87b28946e39681a29cc6f14ea9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2cf8581583c641fb95d1e16aff7d4cd1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2f953abe023240558580dcff3f0c033e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3185bd8ecbde4f26b8ed0f92cf79e14f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": "20px"
+     }
+    },
+    "32d528db79ad4f6f836ab2e0df5ac426": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "34f58c132d2e4249b1e62a0b57c85999": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_504e9e5ced0348cc87aafae0c1c372eb",
+      "placeholder": "​",
+      "style": "IPY_MODEL_5b538e8389fb4574a5dfdc554624e3c8",
+      "value": " 33.6M/33.6M [00:05&lt;00:00, 13.0MB/s]"
+     }
+    },
+    "370cefbaeebf41f582b7507ad493055f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f539b7a4665449de9eac209a20629969",
+      "placeholder": "​",
+      "style": "IPY_MODEL_32d528db79ad4f6f836ab2e0df5ac426",
+      "value": " 899k/899k [00:01&lt;00:00, 807kB/s]"
+     }
+    },
+    "3730f843399d4ba48e98383563283e94": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_fc15c6d6eb3049a3b8542b332dd8a3f2",
+      "max": 5554,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_b6c06e70d7ed48f1840086489300cb3d",
+      "value": 5554
+     }
+    },
+    "39f1a52884e3440c8b521e493d6e1a53": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3b946e1bbab24629b98307275fbe7cbb": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3d2325879cfa48048e81c44e2c2444d5": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": "hidden",
+      "width": null
+     }
+    },
+    "3dbe077ed0c34e4eb1628418138ccbc6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_a579cb7804774ca3aa9efd800d1af57e",
+       "IPY_MODEL_9f44e3175835470aba43e239661037b2",
+       "IPY_MODEL_549bd12e3af64256a7534903688835a8"
+      ],
+      "layout": "IPY_MODEL_a18d9beb34b848ff8cc541d2cb290c4c"
+     }
+    },
+    "41f47c864e094cacb1c550d37ddfe80e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7bbf2c40a4ae46fe9e5885db08975263",
+      "max": 2,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_f00cbc4a89f5492787ec489da65ff70b",
+      "value": 2
+     }
+    },
+    "432fc8277ebc492f91d6b46ed073ccb4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "434c09950be04d728cd7ca8d6c134dc6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7817f8669b7f449fadf02d7145fa89e2",
+      "max": 33601485,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_06e012eea9714ed589344a362b7421bb",
+      "value": 33601485
+     }
+    },
+    "43b14e0e1263499dbd592b280cff21b0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "441a953149814848a24edc9398a2ef63": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "451309d8b3ca4cd9b6f538640477039e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4884bf82f5814e049c47cf6d496aab08": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "49504531deaf4449938bea751d1ec4e7": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "49943c9dadca43a584b3f354ba45280c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4a713a8fe16f4e81aa841c69711fa136": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4ca695fca3d140c6ab4e1e1d34df807b",
+      "max": 137,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_b77ceaf55dc04810963cdd01126478f6",
+      "value": 137
+     }
+    },
+    "4bc518f16b7644e5a11bda66cc285d89": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4ca695fca3d140c6ab4e1e1d34df807b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4cf85a85c0764f15b5134c81b360e910": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4d5cbca8d5e647669faeea32de761dcd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4da42eb3846f423d88e2a6462a0cfce8": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4e6d5943bc374b388b93ed115e44b6a5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_cbe2a6ea41834e95a27d6f02c3c0eeec",
+       "IPY_MODEL_7beb5f4efefc4593abac253df74d1405",
+       "IPY_MODEL_370cefbaeebf41f582b7507ad493055f"
+      ],
+      "layout": "IPY_MODEL_e3df9dda16e244aa9b61d54f9e21ef40"
+     }
+    },
+    "4ea667f48b9f4e1f9da7c5a0d3025b85": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4eccb670e98043b3b2702821a3060ece": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4f0c97b8555942aea6a8003228c07427": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4f592d7632fd440aac0bf97ceed2de75": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4fa82dbe7d3a4b3996b1fa1cf9c23498": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "50374e3ab81c4626a182e61fc03b94ce": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_95727290446244ccb9626f4594949675",
+      "placeholder": "​",
+      "style": "IPY_MODEL_61b54aa6c9e94ee1bc45c15a9e3f7917",
+      "value": " 651/651 [00:00&lt;00:00, 8.02kB/s]"
+     }
+    },
+    "504e9e5ced0348cc87aafae0c1c372eb": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "523deba849044669bfe8c959750708fc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "528b93d088054955906282b1c9f93a17": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "52c8a7e673f24276a07042388a13b58f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "548299d96190406391cab49ad29cc5d6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "549bd12e3af64256a7534903688835a8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_26e4b6b94e4540728c59df8e481ce43d",
+      "placeholder": "​",
+      "style": "IPY_MODEL_9d1b77500f1c45308d4791a9c443e307",
+      "value": " 1/1 [00:05&lt;00:00,  5.98s/it]"
+     }
+    },
+    "54fe79d5c7254117a2209927a7248dd4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "55633800b60a4336abea6a4adfcfdec1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": "center",
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": "flex",
+      "flex": null,
+      "flex_flow": "column",
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": "50%"
+     }
+    },
+    "57ff7d85e56f49239d1eeedd43b88d22": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5936d9eb59e147eea6482006decfe0ee": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "598c5584ffba4f26815c4e87bb1595c4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_3b946e1bbab24629b98307275fbe7cbb",
+      "placeholder": "​",
+      "style": "IPY_MODEL_d9d36f8ff5f747bf90fbc8a7d35a6664",
+      "value": " 441/441 [00:00&lt;00:00, 22.8kB/s]"
+     }
+    },
+    "5aa74b9b30614172b07f88873cf89471": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_cf39fb025e3d4635a5695135a56d9f64",
+       "IPY_MODEL_deaf9732f33446a3be015d2ec16aba76",
+       "IPY_MODEL_bdfd856dd8ee4ae09205ad9d1b9cc806"
+      ],
+      "layout": "IPY_MODEL_7a49f7a55b054b6d829f290a1a426a7a"
+     }
+    },
+    "5b538e8389fb4574a5dfdc554624e3c8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "5b695486a0ac442b8b6a8ef2ebf4e57a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5cb09c84e1e144e0a92580fb5e1ce2fe": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5cd7a5bbab5f4f2daa53d984568ea630": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8cd2073cd3304b2ca4b997127aa88bd1",
+      "placeholder": "​",
+      "style": "IPY_MODEL_f51c7f18977447e2bca36e1da3e1be4f",
+      "value": " 647k/647k [00:00&lt;00:00, 8.09MB/s]"
+     }
+    },
+    "5cec06ccf9074e019ea1f7daf17a0319": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6eee224b244a4cafb3fc0f3b16eb0d03",
+      "max": 3,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_73344836205f4569a4113c24985bd5b1",
+      "value": 3
+     }
+    },
+    "5da6eef8fb0048219159f38a68727b64": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5cb09c84e1e144e0a92580fb5e1ce2fe",
+      "max": 685,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_0f561c1660744251a8f710b69d434c87",
+      "value": 685
+     }
+    },
+    "5db87509bf56435eafaea4cf1153a5d3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c41a9d785e884ab0a58117d17ac7d228",
+      "placeholder": "​",
+      "style": "IPY_MODEL_256c56849e8545018514fd52f1247501",
+      "value": " 1/1 [00:00&lt;00:00, 24.04it/s]"
+     }
+    },
+    "5fa269b8704e4509bf8cd918b657ae23": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_2c27ab87b28946e39681a29cc6f14ea9",
+      "placeholder": "​",
+      "style": "IPY_MODEL_c4ab408eb1344da0bb15a9a6760818e4",
+      "value": "Extracting data files: 100%"
+     }
+    },
+    "5fd979c05fd34311af877ce1a988ead8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_921c268ecd724b6a8869dae8f81d558a",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4cf85a85c0764f15b5134c81b360e910",
+      "value": "Downloading (…)00001-of-00002.bin&quot;;: 100%"
+     }
+    },
+    "6123e53fb26b41f0af9a3a3348ae1afd": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "61b54aa6c9e94ee1bc45c15a9e3f7917": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "62ceac028f144120a24e75afbaccf306": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "62fea00ef0364af287e6097b964d00c4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "63f8ad255d2147128bdc26f47fdf2528": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "63fc9a9eebca4f2db2ed8a385fc5e204": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "663c338f84c94b63bc05b0fb6835d99f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "668dd47eec9942bcad0af209772cf8e6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "6ccea64c2e614a9fbdcc2f716cecaea0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "6d728366de1a4bacb1ba1939c5e0146f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6ea40800dfd849e3b106bae71fc53ae3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_cb69ae47666a4603a07a8778e2ae7d6e",
+      "placeholder": "​",
+      "style": "IPY_MODEL_8f5e9f2d11d54fd2a08dcbff9f6da05c",
+      "value": " 41.9k/41.9k [00:00&lt;00:00, 189kB/s]"
+     }
+    },
+    "6eee224b244a4cafb3fc0f3b16eb0d03": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6f173ca73dd545deb22b8cd0470d925f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "7164feaf360d4300a5083f95064b144a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "722a01f42b7d4c38836a4546ecb38108": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7288f4fd6bb44089baef9f20f50e0e04": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "72e511b775604d899ff5b3fa2ebe9fc4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "73344836205f4569a4113c24985bd5b1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "73d5c6b4034d49b392b103d889bfb3b4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "746c8a2fd0ee458bad85cc75ac333e43": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "74a968ce2dc34189b7dfbb39276f5138": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_57ff7d85e56f49239d1eeedd43b88d22",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4d5cbca8d5e647669faeea32de761dcd",
+      "value": "Downloading data: 100%"
+     }
+    },
+    "7573358a50bd446486b4c5528a298fae": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "75913676a5df43fbbfe744b8882188df": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_1e94c570880449d0a2763bc1eba09057",
+       "IPY_MODEL_d72bd17e161442b0979dceaaef66d82c",
+       "IPY_MODEL_2396a162f70d41a384afd1fcb2f78d11"
+      ],
+      "layout": "IPY_MODEL_39f1a52884e3440c8b521e493d6e1a53"
+     }
+    },
+    "7769c261781f4f5483c7e9d58c1a5573": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c2302f535b114ad780bfa440445c2e28",
+      "placeholder": "​",
+      "style": "IPY_MODEL_8fe032f285ba4858b8efd68119c217b0",
+      "value": "Downloading (…)neration_config.json: 100%"
+     }
+    },
+    "7817f8669b7f449fadf02d7145fa89e2": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "79f7929f423d493caf86b548e91e8a42": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7a49f7a55b054b6d829f290a1a426a7a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7bbf2c40a4ae46fe9e5885db08975263": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7beb5f4efefc4593abac253df74d1405": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_81bb51d088374394becd9a45ec3b17d4",
+      "max": 898822,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_9e762779e5434bb7afcc295b61c2f4e4",
+      "value": 898822
+     }
+    },
+    "7dfe540a75864cf390b3bed20ab1dcd9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "805a10c2fd794ff692e8ebeefd65f2eb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c57c7cf35bf04f3bb3b2b0d8ce7feb31",
+      "placeholder": "​",
+      "style": "IPY_MODEL_2113970533604749a808fa1b98269b0e",
+      "value": "Downloading readme: 100%"
+     }
+    },
+    "80aea5c9422648ef91292d75fb46c8dc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "81bb51d088374394becd9a45ec3b17d4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "840981ef419a48918cf000f89807890e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "856f3dcf949741acb394f252186a1d7e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_ce6de6f9ddde4a6d8094a2b96eac3a4e",
+      "max": 1,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_62ceac028f144120a24e75afbaccf306",
+      "value": 1
+     }
+    },
+    "8602b545a9f8474dbb3cc178ac0b8e60": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_949ca70002ca4472bbc21fea4d7ac745",
+      "placeholder": "​",
+      "style": "IPY_MODEL_49943c9dadca43a584b3f354ba45280c",
+      "value": "Downloading (…)lve/main/config.json: 100%"
+     }
+    },
+    "865bae11c917492a9a1ef7286a493bd5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_2f953abe023240558580dcff3f0c033e",
+      "placeholder": "​",
+      "style": "IPY_MODEL_c2b42681b8bb47e3895d6105240c5812",
+      "value": " 1/1 [00:02&lt;00:00,  2.02s/it]"
+     }
+    },
+    "86dff0987bf040da99c8f2846da26d86": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "876cb42184f54b749c442163290c2c45": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "87b36eb4ad3b4047a32c7d67a5aabc5e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4f0c97b8555942aea6a8003228c07427",
+      "placeholder": "​",
+      "style": "IPY_MODEL_80aea5c9422648ef91292d75fb46c8dc",
+      "value": "Loading checkpoint shards: 100%"
+     }
+    },
+    "893d8cb7857147ba82ac86d140f69a5c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "8a7cd2194113493a841b00d034b5f1ba": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8af46fc543bf46a68ac78c2e8e7e9ddc": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8bf9fd4bd28e4bc1b5895bc9315e727e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8af46fc543bf46a68ac78c2e8e7e9ddc",
+      "max": 2,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_b7b8897c988445ae8f9db9b928674477",
+      "value": 2
+     }
+    },
+    "8cd2073cd3304b2ca4b997127aa88bd1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8f5e9f2d11d54fd2a08dcbff9f6da05c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "8f7890f54d514f80b1eb17905cf0f964": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8fe032f285ba4858b8efd68119c217b0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "921c268ecd724b6a8869dae8f81d558a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "9225dd50bcea435289fa2eba64087076": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_a23144916f02459b966b9830f0a1d64c",
+       "IPY_MODEL_c9b718882fec4254bce1f33fa9373921",
+       "IPY_MODEL_f27905d0073e493cb9dcd174c0f15e35"
+      ],
+      "layout": "IPY_MODEL_0f634721a70d4e749cb616e55ab747b3"
+     }
+    },
+    "949ca70002ca4472bbc21fea4d7ac745": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "95727290446244ccb9626f4594949675": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "96bd12acd63a4232b2f4ac159cc4a768": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "97daf559100c44ac983562fea93c5fac": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "98d5a80ec50c46c18f9ee991e2982115": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "99b9d36317a34143acf982fa3b089fda": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "9a4860dfeac944db85e6e532599bc1cb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "9ad2bd0e92174d339a3a91a38253a180": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ButtonModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ButtonModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ButtonView",
+      "button_style": "",
+      "description": "Login",
+      "disabled": false,
+      "icon": "",
+      "layout": "IPY_MODEL_a333501a50df4b9fa9546d8d965e0dc3",
+      "style": "IPY_MODEL_1f173cb95c5c44f4b32f6cfe10ee3b03",
+      "tooltip": ""
+     }
+    },
+    "9b96c63630654773acd38b8b88371f28": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "9d1b77500f1c45308d4791a9c443e307": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "9e5ef73f8b244845a6b9002fa5c35d15": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "9e5f870ef80242f5af09fad70f84ea62": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "9e762779e5434bb7afcc295b61c2f4e4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "9f1182fdddab43b59ee98bc701965a17": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "9f44e3175835470aba43e239661037b2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7164feaf360d4300a5083f95064b144a",
+      "max": 1,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_bd7547126a874a45b608afed7ab2958b",
+      "value": 1
+     }
+    },
+    "a07688185bff4c4b8cbed3af3b4cf802": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_ed8fa1048e814f2fa3666899fc42e55a",
+      "placeholder": "​",
+      "style": "IPY_MODEL_97daf559100c44ac983562fea93c5fac",
+      "value": "Downloading (…)olve/main/merges.txt: 100%"
+     }
+    },
+    "a0f323ccfbc14fc4b7a5e7046b221ce3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a14542c8431c48b48a614cfd0d41f03c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_96bd12acd63a4232b2f4ac159cc4a768",
+      "placeholder": "​",
+      "style": "IPY_MODEL_746c8a2fd0ee458bad85cc75ac333e43",
+      "value": "Downloading data files: 100%"
+     }
+    },
+    "a18d9beb34b848ff8cc541d2cb290c4c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a1a80d3460984c2496ada5a634875934": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_63fc9a9eebca4f2db2ed8a385fc5e204",
+      "max": 441,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_9a4860dfeac944db85e6e532599bc1cb",
+      "value": 441
+     }
+    },
+    "a23144916f02459b966b9830f0a1d64c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e1f62cbd805d4b8aa9aba7e345c21c82",
+      "placeholder": "​",
+      "style": "IPY_MODEL_893d8cb7857147ba82ac86d140f69a5c",
+      "value": "100%"
+     }
+    },
+    "a333501a50df4b9fa9546d8d965e0dc3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a490025901df478f93be1f19c1be4b09": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a55954b8d7bf4057b0d7aa6a1cb9e91a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a579cb7804774ca3aa9efd800d1af57e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_876cb42184f54b749c442163290c2c45",
+      "placeholder": "​",
+      "style": "IPY_MODEL_43b14e0e1263499dbd592b280cff21b0",
+      "value": "Upload 1 LFS files: 100%"
+     }
+    },
+    "a618f430e06645eb9c95bf16bb6ea59a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_bba20d9bf1974a7f8d1ebcb9f5c4cd49",
+       "IPY_MODEL_5cec06ccf9074e019ea1f7daf17a0319",
+       "IPY_MODEL_faf24b3ed994422f8dd806ae0cc30531"
+      ],
+      "layout": "IPY_MODEL_79f7929f423d493caf86b548e91e8a42"
+     }
+    },
+    "a6ce291698ad460394433a49000c1d25": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a994beafbf3f4c20880a7bbe3898db36": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_7769c261781f4f5483c7e9d58c1a5573",
+       "IPY_MODEL_4a713a8fe16f4e81aa841c69711fa136",
+       "IPY_MODEL_08d036904ecf47ed88e129ba6e2b285c"
+      ],
+      "layout": "IPY_MODEL_9f1182fdddab43b59ee98bc701965a17"
+     }
+    },
+    "aa54b2a9b43848b0902d135beffb806b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "ac91fc78fb04436b80a0a2cbe4380c2b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d54e8d69575f49eb977da64abc5ceb0c",
+      "max": 1,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_548299d96190406391cab49ad29cc5d6",
+      "value": 1
+     }
+    },
+    "ae58b3f129644729aa2f890b1712fc6e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_74a968ce2dc34189b7dfbb39276f5138",
+       "IPY_MODEL_d4f5b19f75e246df9c688f625792e8ba",
+       "IPY_MODEL_5cd7a5bbab5f4f2daa53d984568ea630"
+      ],
+      "layout": "IPY_MODEL_7288f4fd6bb44089baef9f20f50e0e04"
+     }
+    },
+    "ae660d51267544a89f0ad199cc12b6fa": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "aeca2429ee48450a814515cb06acbc3e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_0ecf58c5cbcd40908595fccddff1c6d4",
+      "placeholder": "​",
+      "style": "IPY_MODEL_fc2314656a2745eb921f636cc3451381",
+      "value": "adapter_model.bin: 100%"
+     }
+    },
+    "af0634c2539a43989902daef47776901": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b049ac0b3d2e44ba9b1fc1cb2dd3de62": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b2693135b6954d35afb3120f3caf4000": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_aeca2429ee48450a814515cb06acbc3e",
+       "IPY_MODEL_434c09950be04d728cd7ca8d6c134dc6",
+       "IPY_MODEL_34f58c132d2e4249b1e62a0b57c85999"
+      ],
+      "layout": "IPY_MODEL_d148369be26a43949257790cb202728d"
+     }
+    },
+    "b46919912ee54f6f9f2ce9080be1c61a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6123e53fb26b41f0af9a3a3348ae1afd",
+      "max": 651,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_285ef943d540400ab827c462945a259c",
+      "value": 651
+     }
+    },
+    "b6c06e70d7ed48f1840086489300cb3d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "b77ceaf55dc04810963cdd01126478f6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "b7b8897c988445ae8f9db9b928674477": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "b88b03326f464c96a5656eef774e36d5": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b8c29c1accf4479da91d393dd59ca82b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_5fa269b8704e4509bf8cd918b657ae23",
+       "IPY_MODEL_ac91fc78fb04436b80a0a2cbe4380c2b",
+       "IPY_MODEL_5db87509bf56435eafaea4cf1153a5d3"
+      ],
+      "layout": "IPY_MODEL_840981ef419a48918cf000f89807890e"
+     }
+    },
+    "bba20d9bf1974a7f8d1ebcb9f5c4cd49": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_23cb4d44c4534bae80357c8a9f6b86ba",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4fa82dbe7d3a4b3996b1fa1cf9c23498",
+      "value": "100%"
+     }
+    },
+    "bd7547126a874a45b608afed7ab2958b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "bdfd856dd8ee4ae09205ad9d1b9cc806": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d5bb8d7359274c8e9cc79df563175137",
+      "placeholder": "​",
+      "style": "IPY_MODEL_98d5a80ec50c46c18f9ee991e2982115",
+      "value": " 3.36G/3.36G [01:01&lt;00:00, 57.7MB/s]"
+     }
+    },
+    "be673691e713472980fa1132465714b4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "PasswordModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "PasswordModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "PasswordView",
+      "continuous_update": true,
+      "description": "Token:",
+      "description_tooltip": null,
+      "disabled": false,
+      "layout": "IPY_MODEL_4da42eb3846f423d88e2a6462a0cfce8",
+      "placeholder": "​",
+      "style": "IPY_MODEL_dab39ef354a84be3b37b6f151f9d9b9d",
+      "value": ""
+     }
+    },
+    "bff17ef6aabd4aa681bfd5ad64b808d9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_52c8a7e673f24276a07042388a13b58f",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a0f323ccfbc14fc4b7a5e7046b221ce3",
+      "value": "\n<b>Pro Tip:</b> If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks. </center>"
+     }
+    },
+    "c006e62ee6d04831b2b89273ef04a8ac": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_9e5f870ef80242f5af09fad70f84ea62",
+      "placeholder": "​",
+      "style": "IPY_MODEL_6f173ca73dd545deb22b8cd0470d925f",
+      "value": " 685/685 [00:00&lt;00:00, 34.4kB/s]"
+     }
+    },
+    "c1af10b599da43a3a848f3ba816d7acc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_73d5c6b4034d49b392b103d889bfb3b4",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a55954b8d7bf4057b0d7aa6a1cb9e91a",
+      "value": "<center> <img\nsrc=https://huggingface.co/front/assets/huggingface_logo-noborder.svg\nalt='Hugging Face'> <br> Copy a token from <a\nhref=\"https://huggingface.co/settings/tokens\" target=\"_blank\">your Hugging Face\ntokens page</a> and paste it below. <br> Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file. </center>"
+     }
+    },
+    "c1fd6a1234274a44b838a09f3f5380c6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "c2302f535b114ad780bfa440445c2e28": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c2b42681b8bb47e3895d6105240c5812": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "c41a9d785e884ab0a58117d17ac7d228": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c423a3cc0b504828b11077c77268ed92": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c4ab408eb1344da0bb15a9a6760818e4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "c5493c23fd5542738ffd1ff5f09a6a67": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_00c2e2d3ee8b45818ba84da12c6b11e2",
+      "placeholder": "​",
+      "style": "IPY_MODEL_6ccea64c2e614a9fbdcc2f716cecaea0",
+      "value": "Downloading (…)cial_tokens_map.json: 100%"
+     }
+    },
+    "c57c7cf35bf04f3bb3b2b0d8ce7feb31": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c6f712eadc4d49019b2bd355968cc155": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_5fd979c05fd34311af877ce1a988ead8",
+       "IPY_MODEL_179165ff4c0e4586aaf3a40b8502f428",
+       "IPY_MODEL_cad1d8326e474a4f9ee13db9005121dd"
+      ],
+      "layout": "IPY_MODEL_b049ac0b3d2e44ba9b1fc1cb2dd3de62"
+     }
+    },
+    "c7621e14aa16421d9758321e433b92e4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "c81d20fe47ce4b7594427830d71504d7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_a14542c8431c48b48a614cfd0d41f03c",
+       "IPY_MODEL_856f3dcf949741acb394f252186a1d7e",
+       "IPY_MODEL_865bae11c917492a9a1ef7286a493bd5"
+      ],
+      "layout": "IPY_MODEL_2561b7a7c1694f229d30d2b1eeb14b2f"
+     }
+    },
+    "c9b718882fec4254bce1f33fa9373921": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4884bf82f5814e049c47cf6d496aab08",
+      "max": 1,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_432fc8277ebc492f91d6b46ed073ccb4",
+      "value": 1
+     }
+    },
+    "cad1d8326e474a4f9ee13db9005121dd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_451309d8b3ca4cd9b6f538640477039e",
+      "placeholder": "​",
+      "style": "IPY_MODEL_c7621e14aa16421d9758321e433b92e4",
+      "value": " 9.96G/9.96G [03:05&lt;00:00, 63.7MB/s]"
+     }
+    },
+    "cb69ae47666a4603a07a8778e2ae7d6e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "cbe2a6ea41834e95a27d6f02c3c0eeec": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_23d2ad64a17041b7a006dad1e041e0a1",
+      "placeholder": "​",
+      "style": "IPY_MODEL_c1fd6a1234274a44b838a09f3f5380c6",
+      "value": "Downloading (…)olve/main/vocab.json: 100%"
+     }
+    },
+    "ce6de6f9ddde4a6d8094a2b96eac3a4e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ce8d4bac782949579a2e52864455d9de": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "cf39fb025e3d4635a5695135a56d9f64": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5b695486a0ac442b8b6a8ef2ebf4e57a",
+      "placeholder": "​",
+      "style": "IPY_MODEL_03be7cb91cba4afab795aab7aa242ee1",
+      "value": "Downloading (…)00002-of-00002.bin&quot;;: 100%"
+     }
+    },
+    "d148369be26a43949257790cb202728d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d3511ce1754b41969e5c36a5b33ac466": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "d46b5725c35142a89617e46c0e8d3679": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_c5493c23fd5542738ffd1ff5f09a6a67",
+       "IPY_MODEL_a1a80d3460984c2496ada5a634875934",
+       "IPY_MODEL_598c5584ffba4f26815c4e87bb1595c4"
+      ],
+      "layout": "IPY_MODEL_fe93f25323604447be0bb1d24a0c2c59"
+     }
+    },
+    "d4de260ffd8a440eb87eb900fc1bb1d3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_8602b545a9f8474dbb3cc178ac0b8e60",
+       "IPY_MODEL_b46919912ee54f6f9f2ce9080be1c61a",
+       "IPY_MODEL_50374e3ab81c4626a182e61fc03b94ce"
+      ],
+      "layout": "IPY_MODEL_2144bc2897dc40b29f060e30ace12275"
+     }
+    },
+    "d4f5b19f75e246df9c688f625792e8ba": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a6ce291698ad460394433a49000c1d25",
+      "max": 646739,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_aa54b2a9b43848b0902d135beffb806b",
+      "value": 646739
+     }
+    },
+    "d54e8d69575f49eb977da64abc5ceb0c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d5bb8d7359274c8e9cc79df563175137": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d72bd17e161442b0979dceaaef66d82c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4f592d7632fd440aac0bf97ceed2de75",
+      "max": 33601485,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_1b515483e5884479b2101127c16321d4",
+      "value": 33601485
+     }
+    },
+    "d7e33c29d410414eb452d121edd9920e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d9d36f8ff5f747bf90fbc8a7d35a6664": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "da946f86590447d2ab98b9da468fa66b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "dab39ef354a84be3b37b6f151f9d9b9d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "dc08d237860e4788a8ceeff4518c2612": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "ddc333530c13446a91cf332846bfa22f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d7e33c29d410414eb452d121edd9920e",
+      "placeholder": "​",
+      "style": "IPY_MODEL_d3511ce1754b41969e5c36a5b33ac466",
+      "value": " 0/0 [00:00&lt;?, ? examples/s]"
+     }
+    },
+    "ddc36fdbdd634dc489f658bead61e7ee": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "deaf9732f33446a3be015d2ec16aba76": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8f7890f54d514f80b1eb17905cf0f964",
+      "max": 3356360185,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_ae660d51267544a89f0ad199cc12b6fa",
+      "value": 3356360185
+     }
+    },
+    "e1f62cbd805d4b8aa9aba7e345c21c82": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e3df9dda16e244aa9b61d54f9e21ef40": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e466054f08004bbcabb24e400cb3c7fc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4ea667f48b9f4e1f9da7c5a0d3025b85",
+      "max": 41937,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_9b96c63630654773acd38b8b88371f28",
+      "value": 41937
+     }
+    },
+    "e73e5388182040a8937ccf1748171a87": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_f797f7b8b13f4b3cb871522d34498631",
+       "IPY_MODEL_41f47c864e094cacb1c550d37ddfe80e",
+       "IPY_MODEL_104d982b444947fe8e4fbb2c2f082616"
+      ],
+      "layout": "IPY_MODEL_2cf8581583c641fb95d1e16aff7d4cd1"
+     }
+    },
+    "e9673363e85448d494ac9ac5d7ba0efb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "ed2736d862a94d8f9db9ba6037016071": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "info",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_3185bd8ecbde4f26b8ed0f92cf79e14f",
+      "max": 1,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_ddc36fdbdd634dc489f658bead61e7ee",
+      "value": 1
+     }
+    },
+    "ed8fa1048e814f2fa3666899fc42e55a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f00cbc4a89f5492787ec489da65ff70b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "f27905d0073e493cb9dcd174c0f15e35": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c423a3cc0b504828b11077c77268ed92",
+      "placeholder": "​",
+      "style": "IPY_MODEL_668dd47eec9942bcad0af209772cf8e6",
+      "value": " 1/1 [00:00&lt;00:00,  9.58it/s]"
+     }
+    },
+    "f357166c6e5f43f39d0a287ca6d6f60e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_805a10c2fd794ff692e8ebeefd65f2eb",
+       "IPY_MODEL_3730f843399d4ba48e98383563283e94",
+       "IPY_MODEL_f855aced7ca2485ea720604359deaa18"
+      ],
+      "layout": "IPY_MODEL_6d728366de1a4bacb1ba1939c5e0146f"
+     }
+    },
+    "f51c7f18977447e2bca36e1da3e1be4f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "f539b7a4665449de9eac209a20629969": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f65af2e868244edeb0cc9402534874a8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_1bd5179cdb474b65aa06eca3520ad37b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_04d367124a3b419ab1fa1dfd4f9004c3",
+      "value": "Downloading (…)model.bin.index.json: 100%"
+     }
+    },
+    "f797f7b8b13f4b3cb871522d34498631": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_11808e9097424dd0b22a5af6c77813f3",
+      "placeholder": "​",
+      "style": "IPY_MODEL_dc08d237860e4788a8ceeff4518c2612",
+      "value": "Loading checkpoint shards: 100%"
+     }
+    },
+    "f855aced7ca2485ea720604359deaa18": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_49504531deaf4449938bea751d1ec4e7",
+      "placeholder": "​",
+      "style": "IPY_MODEL_7dfe540a75864cf390b3bed20ab1dcd9",
+      "value": " 5.55k/5.55k [00:00&lt;00:00, 156kB/s]"
+     }
+    },
+    "fad61c68edc84c8197afeafded84280d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "faf24b3ed994422f8dd806ae0cc30531": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_86dff0987bf040da99c8f2846da26d86",
+      "placeholder": "​",
+      "style": "IPY_MODEL_63f8ad255d2147128bdc26f47fdf2528",
+      "value": " 3/3 [00:02&lt;00:00,  1.18ba/s]"
+     }
+    },
+    "fc15c6d6eb3049a3b8542b332dd8a3f2": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "fc2314656a2745eb921f636cc3451381": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "fc2d5ffe254d425b939252ec46ec27cc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_f65af2e868244edeb0cc9402534874a8",
+       "IPY_MODEL_e466054f08004bbcabb24e400cb3c7fc",
+       "IPY_MODEL_6ea40800dfd849e3b106bae71fc53ae3"
+      ],
+      "layout": "IPY_MODEL_722a01f42b7d4c38836a4546ecb38108"
+     }
+    },
+    "fe93f25323604447be0bb1d24a0c2c59": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ff2454cf69b346fea70070522cf93689": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_87b36eb4ad3b4047a32c7d67a5aabc5e",
+       "IPY_MODEL_8bf9fd4bd28e4bc1b5895bc9315e727e",
+       "IPY_MODEL_01845549768a4db580b5555809e83342"
+      ],
+      "layout": "IPY_MODEL_a490025901df478f93be1f19c1be4b09"
+     }
+    }
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/examples/int8_training/config.yaml b/examples/int8_training/config.yaml
new file mode 100644
index 0000000..c5d87a5
--- /dev/null
+++ b/examples/int8_training/config.yaml
@@ -0,0 +1,19 @@
+compute_environment: LOCAL_MACHINE
+debug: false
+distributed_type: MULTI_XPU
+downcast_bf16: 'no'
+enable_cpu_affinity: false
+gpu_ids: all
+ipex_config:
+  ipex: false
+machine_rank: 0
+main_training_function: main
+mixed_precision: 'no'
+num_machines: 1
+num_processes: 4
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false
diff --git a/examples/int8_training/fine_tune_blip2_int8.py b/examples/int8_training/fine_tune_blip2_int8.py
new file mode 100644
index 0000000..1b67013
--- /dev/null
+++ b/examples/int8_training/fine_tune_blip2_int8.py
@@ -0,0 +1,104 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+import torch
+from datasets import load_dataset
+from torch.utils.data import DataLoader, Dataset
+from transformers import AutoModelForVision2Seq, AutoProcessor, BitsAndBytesConfig
+
+from peft import LoraConfig, get_peft_model
+
+
+# Let's define the LoraConfig
+config = LoraConfig(
+    r=16,
+    lora_alpha=32,
+    lora_dropout=0.05,
+    bias="none",
+)
+
+# We load our model and processor using `transformers`
+model = AutoModelForVision2Seq.from_pretrained(
+    "Salesforce/blip2-opt-2.7b", quantization_config=BitsAndBytesConfig(load_in_8bit=True)
+)
+processor = AutoProcessor.from_pretrained("Salesforce/blip2-opt-2.7b")
+
+# Get our peft model and print the number of trainable parameters
+model = get_peft_model(model, config)
+model.print_trainable_parameters()
+
+# Let's load the dataset here!
+dataset = load_dataset("ybelkada/football-dataset", split="train")
+
+
+class ImageCaptioningDataset(Dataset):
+    def __init__(self, dataset, processor):
+        self.dataset = dataset
+        self.processor = processor
+
+    def __len__(self):
+        return len(self.dataset)
+
+    def __getitem__(self, idx):
+        item = self.dataset[idx]
+        encoding = self.processor(images=item["image"], padding="max_length", return_tensors="pt")
+        # remove batch dimension
+        encoding = {k: v.squeeze() for k, v in encoding.items()}
+        encoding["text"] = item["text"]
+        return encoding
+
+
+def collator(batch):
+    # pad the input_ids and attention_mask
+    processed_batch = {}
+    for key in batch[0].keys():
+        if key != "text":
+            processed_batch[key] = torch.stack([example[key] for example in batch])
+        else:
+            text_inputs = processor.tokenizer(
+                [example["text"] for example in batch], padding=True, return_tensors="pt"
+            )
+            processed_batch["input_ids"] = text_inputs["input_ids"]
+            processed_batch["attention_mask"] = text_inputs["attention_mask"]
+    return processed_batch
+
+
+train_dataset = ImageCaptioningDataset(dataset, processor)
+train_dataloader = DataLoader(train_dataset, shuffle=True, batch_size=2, collate_fn=collator)
+
+optimizer = torch.optim.AdamW(model.parameters(), lr=5e-5)
+
+device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+
+model.train()
+
+for epoch in range(50):
+    print("Epoch:", epoch)
+    for idx, batch in enumerate(train_dataloader):
+        input_ids = batch.pop("input_ids").to(device)
+        pixel_values = batch.pop("pixel_values").to(device, torch.float16)
+
+        outputs = model(input_ids=input_ids, pixel_values=pixel_values, labels=input_ids)
+
+        loss = outputs.loss
+
+        print("Loss:", loss.item())
+
+        loss.backward()
+
+        optimizer.step()
+        optimizer.zero_grad()
+
+        if idx % 10 == 0:
+            generated_output = model.generate(pixel_values=pixel_values)
+            print(processor.batch_decode(generated_output, skip_special_tokens=True))
diff --git a/examples/int8_training/peft_adalora_whisper_large_training.py b/examples/int8_training/peft_adalora_whisper_large_training.py
new file mode 100644
index 0000000..ff6ec27
--- /dev/null
+++ b/examples/int8_training/peft_adalora_whisper_large_training.py
@@ -0,0 +1,817 @@
+import argparse
+import gc
+import json
+import logging
+import math
+import os
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from random import randint
+from typing import Any, Union
+
+# datasets imports
+import datasets
+
+# metric imports
+import evaluate
+import numpy as np
+import torch
+import transformers
+import wandb
+
+# accelerate imports
+from accelerate import Accelerator, dispatch_model
+from accelerate.logging import get_logger
+from datasets import Audio, DatasetDict, IterableDatasetDict, interleave_datasets, load_dataset
+
+# hf imports
+from huggingface_hub import HfApi
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+from transformers import (
+    BitsAndBytesConfig,
+    SchedulerType,
+    WhisperForConditionalGeneration,
+    WhisperProcessor,
+    get_scheduler,
+    set_seed,
+)
+from transformers.models.whisper.english_normalizer import BasicTextNormalizer
+
+# peft imports
+from peft import AdaLoraConfig, LoraConfig, PeftModel, get_peft_model
+
+
+logger = get_logger(__name__, log_level="INFO")
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Whisper Fine-Tuning with AdaLora")
+    parser.add_argument(
+        "--model_name_or_path",
+        type=str,
+        help="Path to pretrained model or model identifier from huggingface.co/models.",
+        required=True,
+    )
+    parser.add_argument("--language", type=str, help="Language to use for training; e.g., 'Hindi' ", required=True)
+    parser.add_argument("--language_abbr", type=str, help="Language to use for training; e.g., 'hi' ", required=True)
+    parser.add_argument(
+        "--task", type=str, default="transcribe", help="Task to use for training; e.g., 'transcribe' ", required=False
+    )
+    parser.add_argument(
+        "--dataset_name",
+        type=str,
+        default="mozilla-foundation/common_voice_11_0",
+        help="Dataset to use for training; e.g., 'whisper' ",
+        required=False,
+    )
+    parser.add_argument(
+        "--dataset_in_streaming_mode",
+        action="store_true",
+        help="Whether to use streaming mode for the dataset.",
+    )
+    parser.add_argument(
+        "--do_lower_case", action="store_true", help="lowercase the transcribed text before tokenizing"
+    )
+    parser.add_argument(
+        "--do_remove_punctuation", action="store_true", help="remove punctuation from the transcribed text"
+    )
+    parser.add_argument("--push_to_hub", action="store_true", help="Whether or not to push the model to the Hub.")
+    parser.add_argument(
+        "--overwrite_cache", type=bool, default=False, help="Overwrite the cached training and evaluation sets"
+    )
+    parser.add_argument("--max_audio_input_length", type=float, default=30.0, help="Maximum audio length in seconds.")
+    parser.add_argument(
+        "--preprocessing_num_workers",
+        type=int,
+        default=None,
+        help="The number of processes to use for the preprocessing.",
+    )
+    parser.add_argument(
+        "--per_device_train_batch_size",
+        type=int,
+        default=8,
+        help="Batch size (per device) for the training dataloader.",
+    )
+    parser.add_argument(
+        "--per_device_eval_batch_size",
+        type=int,
+        default=8,
+        help="Batch size (per device) for the evaluation dataloader.",
+    )
+    parser.add_argument(
+        "--buffer_size",
+        type=int,
+        default=5000,
+        help="Number of samples to prefetch in the streaming mode.",
+    )
+    parser.add_argument(
+        "--dataloader_pin_memory",
+        action="store_true",
+        help="Whether or not to pin memory for the DataLoader.",
+    )
+    parser.add_argument(
+        "--dataloader_num_workers",
+        type=int,
+        default=0,
+        help="Number of subprocesses to use for data loading.",
+    )
+    parser.add_argument(
+        "--learning_rate",
+        type=float,
+        default=5e-5,
+        help="Initial learning rate (after the potential warmup period) to use.",
+    )
+    parser.add_argument("--weight_decay", type=float, default=0.0, help="Weight decay to use.")
+    parser.add_argument("--num_train_epochs", type=int, default=3, help="Total number of training epochs to perform.")
+    parser.add_argument(
+        "--max_train_steps",
+        type=int,
+        default=None,
+        help="Total number of training steps to perform. If provided, overrides num_train_epochs.",
+    )
+    parser.add_argument(
+        "--gradient_accumulation_steps",
+        type=int,
+        default=1,
+        help="Number of updates steps to accumulate before performing a backward/update pass.",
+    )
+    parser.add_argument(
+        "--lr_scheduler_type",
+        type=SchedulerType,
+        default="linear",
+        help="The scheduler type to use.",
+        choices=["linear", "cosine", "cosine_with_restarts", "polynomial", "constant", "constant_with_warmup"],
+    )
+    parser.add_argument(
+        "--num_warmup_steps", type=int, default=0, help="Number of steps for the warmup in the lr scheduler."
+    )
+    parser.add_argument("--output_dir", type=str, default=None, help="Where to store the final model.")
+    parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.")
+    parser.add_argument(
+        "--load_best_model",
+        action="store_true",
+        help="Whether to load the best model at the end of training",
+    )
+    parser.add_argument(
+        "--with_tracking",
+        action="store_true",
+        help="Whether to enable experiment trackers for logging.",
+    )
+    parser.add_argument(
+        "--report_to",
+        type=str,
+        default="all",
+        help=(
+            'The integration to report the results and logs to. Supported platforms are `"tensorboard"`,'
+            ' `"wandb"` and `"comet_ml"`. Use `"all"` (default) to report to all integrations.'
+            "Only applicable when `--with_tracking` is passed."
+        ),
+    )
+    parser.add_argument("--hub_token", type=str, help="The token to use to push to the Model Hub.")
+    parser.add_argument(
+        "--hub_model_id", type=str, help="The name of the repository to keep in sync with the local `output_dir`."
+    )
+    parser.add_argument(
+        "--checkpointing_steps",
+        type=int,
+        default=500,
+        help="Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch.",
+    )
+    parser.add_argument(
+        "--logging_steps",
+        type=int,
+        default=100,
+        help="Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch.",
+    )
+    parser.add_argument(
+        "--evaluation_steps",
+        type=int,
+        default=500,
+        help="Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch.",
+    )
+    parser.add_argument(
+        "--resume_from_checkpoint",
+        type=str,
+        default=None,
+        help="If the training should continue from a checkpoint folder.",
+    )
+
+    # lora/adalora specific args
+    parser.add_argument(
+        "--use_peft",
+        action="store_true",
+        help="Whether to use PEFT",
+    )
+    parser.add_argument(
+        "--use_adalora",
+        action="store_true",
+        help="Whether to use AdaLoRA or LoRA. If set, uses AdaLoRA instead of the default LoRA.",
+    )
+    parser.add_argument(
+        "--init_r",
+        type=int,
+        default=12,
+        help="Initial AdaLoRA rank",
+    )
+    parser.add_argument(
+        "--target_r",
+        type=int,
+        default=4,
+        help="Target AdaLoRA rank",
+    )
+    parser.add_argument(
+        "--tinit",
+        type=int,
+        default=200,
+        help="number of warmup steps for AdaLoRA wherein no pruning is performed",
+    )
+    parser.add_argument(
+        "--tfinal",
+        type=int,
+        default=1000,
+        help=" fix the resulting budget distribution and fine-tune the model for tfinal steps when using AdaLoRA ",
+    )
+    parser.add_argument(
+        "--delta_t",
+        type=int,
+        default=10,
+        help="interval of steps for AdaLoRA to update rank",
+    )
+    parser.add_argument(
+        "--lora_alpha",
+        type=int,
+        default=32,
+        help="LORA alpha",
+    )
+    parser.add_argument(
+        "--r",
+        type=int,
+        default=8,
+        help="LORA rank",
+    )
+    parser.add_argument(
+        "--lora_dropout",
+        type=float,
+        default=0.1,
+        help="LORA dropout",
+    )
+    parser.add_argument(
+        "--orth_reg_weight",
+        type=float,
+        default=0.5,
+        help="Orthogonal regularization weight",
+    )
+    parser.add_argument(
+        "--debug_mode",
+        action="store_true",
+        help="Whether to use debug mode",
+    )
+
+    args = parser.parse_args()
+
+    if args.push_to_hub:
+        assert args.output_dir is not None, "Need an `output_dir` to create a repo when `--push_to_hub` is passed."
+
+    return args
+
+
+def load_streaming_dataset(dataset_name, dataset_config_name, split, **kwargs):
+    if "+" in split:
+        # load multiple splits separated by the `+` symbol *with* streaming mode
+        dataset_splits = [
+            load_dataset(dataset_name, dataset_config_name, split=split_name, streaming=True, **kwargs)
+            for split_name in split.split("+")
+        ]
+        # interleave multiple splits to form one dataset
+        interleaved_dataset = interleave_datasets(dataset_splits)
+        return interleaved_dataset
+    else:
+        # load a single split *with* streaming mode
+        dataset = load_dataset(dataset_name, dataset_config_name, split=split, streaming=True, **kwargs)
+        return dataset
+
+
+def prepare_dataset_wrapper(do_lower_case, do_remove_punctuation, processor, normalizer):
+    def prepare_dataset(batch):
+        # load and (possibly) resample audio data to 16kHz
+        audio = batch["audio"]
+
+        # compute log-Mel input features from input audio array
+        batch["input_features"] = processor.feature_extractor(
+            audio["array"], sampling_rate=audio["sampling_rate"]
+        ).input_features[0]
+        # compute input length of audio sample in seconds
+        batch["input_length"] = len(audio["array"]) / audio["sampling_rate"]
+
+        # optional pre-processing steps
+        transcription = batch["sentence"]
+        if do_lower_case:
+            transcription = transcription.lower()
+        if do_remove_punctuation:
+            transcription = normalizer(transcription).strip()
+
+        # encode target text to label ids
+        batch["labels"] = processor.tokenizer(transcription).input_ids
+        return batch
+
+    return prepare_dataset
+
+
+def save_model_hook(models, weights, output_dir):
+    for model in models:
+        model.save_pretrained(output_dir)
+        # make sure to pop weight so that corresponding model is not saved again
+        weights.pop()
+
+
+def load_model_hook(models, input_dir):
+    while len(models) > 0:
+        model = models.pop()
+        # pop models so that they are not loaded again
+        PeftModel.from_pretrained(model.base_model.model, input_dir)
+
+
+@dataclass
+class DataCollatorSpeechSeq2SeqWithPadding:
+    processor: Any
+
+    def __call__(self, features: list[dict[str, Union[list[int], torch.Tensor]]]) -> dict[str, torch.Tensor]:
+        # split inputs and labels since they have to be of different lengths and need different padding methods
+        # first treat the audio inputs by simply returning torch tensors
+        input_features = [{"input_features": feature["input_features"]} for feature in features]
+        batch = self.processor.feature_extractor.pad(input_features, return_tensors="pt")
+
+        # get the tokenized label sequences
+        label_features = [{"input_ids": feature["labels"]} for feature in features]
+        # pad the labels to max length
+        labels_batch = self.processor.tokenizer.pad(label_features, return_tensors="pt")
+
+        # replace padding with -100 to ignore loss correctly
+        labels = labels_batch["input_ids"].masked_fill(labels_batch.attention_mask.ne(1), -100)
+
+        # if bos token is appended in previous tokenization step,
+        # cut bos token here as it's append later anyways
+        if (labels[:, 0] == self.processor.tokenizer.bos_token_id).all().cpu().item():
+            labels = labels[:, 1:]
+
+        batch["labels"] = labels
+
+        return batch
+
+
+def get_audio_length_processor(max_input_length):
+    def is_audio_in_length_range(length):
+        return length < max_input_length
+
+    return is_audio_in_length_range
+
+
+def evaluation_loop(model, eval_dataloader, processor, normalizer, metric, forced_decoder_ids, accelerator):
+    model.eval()
+    predictions = []
+    references = []
+    normalized_predictions = []
+    normalized_references = []
+    device_type = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+    for _, batch in enumerate(tqdm(eval_dataloader)):
+        with torch.amp.autocast(device_type=device_type):
+            with torch.no_grad():
+                generated_tokens = (
+                    model.generate(
+                        input_features=batch["input_features"],
+                        forced_decoder_ids=forced_decoder_ids,
+                        max_new_tokens=255,
+                    )
+                    .cpu()
+                    .numpy()
+                )
+                labels = batch["labels"].cpu().numpy()
+                labels = np.where(labels != -100, labels, processor.tokenizer.pad_token_id)
+                decoded_preds = processor.tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)
+                decoded_labels = processor.tokenizer.batch_decode(labels, skip_special_tokens=True)
+                predictions.extend(decoded_preds)
+                references.extend(decoded_labels)
+                normalized_predictions.extend([normalizer(pred).strip() for pred in decoded_preds])
+                normalized_references.extend([normalizer(label).strip() for label in decoded_labels])
+            del generated_tokens, labels, batch
+        gc.collect()
+    wer = 100 * metric.compute(predictions=predictions, references=references)
+    normalized_wer = 100 * metric.compute(predictions=normalized_predictions, references=normalized_references)
+    eval_metrics = {"eval/wer": wer, "eval/normalized_wer": normalized_wer}
+    if accelerator.get_tracker("wandb"):
+        sample_size = min(len(predictions), 256)
+        ids = [randint(0, len(predictions) - 1) for p in range(sample_size)]
+        sample_predictions = [predictions[i] for i in ids]
+        sample_references = [references[i] for i in ids]
+        sample_normalized_predictions = [normalized_predictions[i] for i in ids]
+        sample_normalized_references = [normalized_references[i] for i in ids]
+        table_rows = [
+            list(r)
+            for r in zip(
+                sample_predictions, sample_references, sample_normalized_predictions, sample_normalized_references
+            )
+        ]
+        eval_metrics["eval_samples"] = wandb.Table(
+            columns=["predictions", "references", "normalized_predictions", "normalized_references"],
+            rows=table_rows,
+        )
+    return eval_metrics
+
+
+def main():
+    args = parse_args()
+
+    accelerator_kwargs = {"gradient_accumulation_steps": args.gradient_accumulation_steps}
+    if args.with_tracking:
+        accelerator_kwargs["log_with"] = args.report_to
+        accelerator_kwargs["project_dir"] = args.output_dir
+    accelerator = Accelerator(**accelerator_kwargs)
+
+    # Make one log on every process with the configuration for debugging.
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        level=logging.INFO,
+    )
+    logger.info(accelerator.state, main_process_only=False)
+    if accelerator.is_local_main_process:
+        datasets.utils.logging.set_verbosity_warning()
+        transformers.utils.logging.set_verbosity_info()
+    else:
+        datasets.utils.logging.set_verbosity_error()
+        transformers.utils.logging.set_verbosity_error()
+
+    # If passed along, set the training seed now.
+    if args.seed is not None:
+        set_seed(args.seed)
+
+    # Handle the repository creation
+    if accelerator.is_main_process:
+        if args.push_to_hub:
+            api = HfApi(token=args.hub_token)
+
+            # Create repo (repo_name from args or inferred)
+            repo_name = args.hub_model_id
+            if repo_name is None:
+                repo_name = Path(args.output_dir).absolute().name
+            repo_id = api.create_repo(repo_name, exist_ok=True).repo_id
+
+            with open(os.path.join(args.output_dir, ".gitignore"), "w+") as gitignore:
+                if "step_*" not in gitignore:
+                    gitignore.write("step_*\n")
+                if "epoch_*" not in gitignore:
+                    gitignore.write("epoch_*\n")
+        elif args.output_dir is not None:
+            os.makedirs(args.output_dir, exist_ok=True)
+    accelerator.wait_for_everyone()
+
+    # load dataset either in streaming mode or not
+    processor = WhisperProcessor.from_pretrained(args.model_name_or_path, language=args.language, task=args.task)
+    normalizer = BasicTextNormalizer()
+    prepare_dataset = prepare_dataset_wrapper(args.do_lower_case, args.do_remove_punctuation, processor, normalizer)
+    is_audio_in_length_range = get_audio_length_processor(args.max_audio_input_length)
+    data_collator = DataCollatorSpeechSeq2SeqWithPadding(processor=processor)
+
+    if args.dataset_in_streaming_mode:
+        raw_datasets = IterableDatasetDict()
+        loading_method = load_streaming_dataset
+    else:
+        raw_datasets = DatasetDict()
+        loading_method = load_dataset
+
+    if args.debug_mode:
+        train_split = "train[:100]"
+        test_split = "test[:10]"
+    else:
+        train_split = "train+validation"
+        test_split = "test"
+
+    raw_datasets["train"] = loading_method(args.dataset_name, args.language_abbr, split=train_split)
+    raw_datasets["test"] = loading_method(args.dataset_name, args.language_abbr, split=test_split)
+    raw_datasets = raw_datasets.cast_column("audio", Audio(sampling_rate=16000))
+
+    logger.info("Dataset loaded: %s", raw_datasets)
+    logger.info(f"{raw_datasets['train'][0]}")
+
+    vectorized_datasets = raw_datasets.map(
+        prepare_dataset,
+        remove_columns=list(next(iter(raw_datasets.values())).features),
+        num_proc=args.preprocessing_num_workers,
+    ).with_format("torch")
+
+    if args.dataset_in_streaming_mode:
+        vectorized_datasets["train"] = vectorized_datasets["train"].shuffle(
+            buffer_size=args.buffer_size,
+            seed=args.seed,
+        )
+
+    # filter out audio files that are too long from the training set
+    is_audio_in_length_range = get_audio_length_processor(args.max_audio_input_length)
+    vectorized_datasets["train"] = vectorized_datasets["train"].filter(
+        is_audio_in_length_range, input_columns=["input_length"]
+    )
+
+    # get dataloaders
+    train_dataloader = DataLoader(
+        vectorized_datasets["train"],
+        batch_size=args.per_device_train_batch_size,
+        shuffle=True,
+        collate_fn=data_collator,
+        num_workers=args.dataloader_num_workers,
+        pin_memory=args.dataloader_pin_memory,
+    )
+    eval_dataloader = DataLoader(
+        vectorized_datasets["test"],
+        batch_size=args.per_device_eval_batch_size,
+        collate_fn=data_collator,
+        num_workers=args.dataloader_num_workers,
+        pin_memory=args.dataloader_pin_memory,
+    )
+
+    # metric
+    metric = evaluate.load("wer")
+
+    # model
+    model = WhisperForConditionalGeneration.from_pretrained(
+        args.model_name_or_path, quantization_config=BitsAndBytesConfig(load_in_8bit=True)
+    )
+    model.config.forced_decoder_ids = None
+    model.config.suppress_tokens = []
+    if hasattr(model, "hf_device_map") and len(set(model.hf_device_map.values()).intersection({"cpu", "disk"})) > 0:
+        raise ValueError("Training on CPU or disk is not supported.")
+    if hasattr(model, "hf_device_map") and len(set(model.hf_device_map.values())) > 1:
+        device_map = model.hf_device_map.copy()
+        # required because `labels` are on main execution device (0) while the output of `proj_out` is on other device.
+        # So, this leads to device mismatch error when calculation cross-entropy between logits and labels.
+        # Won't arise during inference as `labels` aren't supplied during that time
+        # instead of changing device of one of the tied modules, I have to do this for all tied modules
+        # else the execution device of remaining tied modules isn't changed
+        device_map["model.decoder.embed_tokens"] = model._hf_hook.execution_device
+        device_map["model.decoder.embed_positions"] = model._hf_hook.execution_device
+        device_map["proj_out"] = model._hf_hook.execution_device
+        dispatch_model(model, device_map=device_map)
+
+    # preparing peft model
+    if args.use_peft:
+        from peft import prepare_model_for_kbit_training
+
+        model = prepare_model_for_kbit_training(model)
+
+        # as Whisper model uses Conv layer in encoder, checkpointing disables grad computation
+        # to avoid this, make the inputs trainable
+        def make_inputs_require_grad(module, input, output):
+            output.requires_grad_(True)
+
+        model.model.encoder.conv1.register_forward_hook(make_inputs_require_grad)
+
+        # Calculate total steps first for AdaLoRA
+        if args.max_train_steps is None:
+            num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+            total_steps = args.num_train_epochs * num_update_steps_per_epoch
+        else:
+            total_steps = args.max_train_steps
+
+        # wrapping model with adalora tuner
+        if args.use_adalora:
+            config = AdaLoraConfig(
+                init_r=args.init_r,
+                target_r=args.target_r,
+                beta1=0.85,
+                beta2=0.85,
+                tinit=args.tinit,
+                tfinal=args.tfinal,
+                deltaT=args.delta_t,
+                lora_alpha=args.lora_alpha,
+                lora_dropout=args.lora_dropout,
+                target_modules=["k_proj", "q_proj", "v_proj", "out_proj", "fc1", "fc2"],
+                orth_reg_weight=args.orth_reg_weight,
+                total_step=total_steps,
+            )
+        else:
+            config = LoraConfig(
+                r=args.r,
+                lora_alpha=args.lora_alpha,
+                target_modules=["q_proj", "v_proj"],
+                lora_dropout=args.lora_dropout,
+            )
+
+        model = get_peft_model(model, config)
+        model.print_trainable_parameters()
+
+    # optimizer
+    optimizer = torch.optim.AdamW(model.parameters(), lr=args.learning_rate, weight_decay=args.weight_decay)
+
+    if args.max_train_steps is None:
+        num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+    else:
+        args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch)
+
+    # scheduler
+    lr_scheduler = get_scheduler(
+        name=args.lr_scheduler_type,
+        optimizer=optimizer,
+        num_warmup_steps=args.num_warmup_steps,
+        num_training_steps=args.max_train_steps,
+    )
+
+    # Prepare everything with our `accelerator`.
+    model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(
+        model, optimizer, train_dataloader, eval_dataloader, lr_scheduler
+    )
+
+    accelerator.print(model)
+
+    # Note here that the max steps is adjusted by the accelerator's num_processes
+    args.max_train_steps = math.ceil(args.max_train_steps / accelerator.num_processes)
+    if args.use_peft and args.use_adalora:
+        # Update the total_step in the config to reflect the adjusted max_train_steps
+        # Handle DDP case where model is wrapped
+        if hasattr(model, "module"):
+            # DDP case
+            model.module.base_model.peft_config["default"].total_step = args.max_train_steps
+        else:
+            # Non-DDP case
+            model.base_model.peft_config["default"].total_step = args.max_train_steps
+
+    # We need to initialize the trackers we use, and also store our configuration.
+    # The trackers initializes automatically on the main process.
+    if args.with_tracking:
+        run_name = f"run-{datetime.now(timezone.utc).strftime('%Y-%m-%d_%H-%M-%S')}"
+        experiment_config = vars(args)
+        # TensorBoard cannot log Enums, need the raw value
+        experiment_config["lr_scheduler_type"] = experiment_config["lr_scheduler_type"].value
+        accelerator.init_trackers(
+            "Whisper PEFT Fine-Tuning", config=experiment_config, init_kwargs={"wandb": {"name": run_name}}
+        )
+
+    # saving and loading checkpoints for resuming training
+    accelerator.register_save_state_pre_hook(save_model_hook)
+    accelerator.register_load_state_pre_hook(load_model_hook)
+
+    total_batch_size = args.per_device_train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps
+    logger.info("***** Running training *****")
+    logger.info(f"  Num Epochs = {args.num_train_epochs}")
+    logger.info(f"  Instantaneous batch size per device = {args.per_device_train_batch_size}")
+    logger.info(f"  Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}")
+    logger.info(f"  Gradient Accumulation steps = {args.gradient_accumulation_steps}")
+    logger.info(f"  Total optimization steps = {args.max_train_steps}")
+    # Only show the progress bar once on each machine.
+    progress_bar = tqdm(range(args.max_train_steps), disable=not accelerator.is_local_main_process)
+    global_step = 0
+    starting_epoch = 0
+    best_metric = None
+    resume_step = 0
+    forced_decoder_ids = processor.get_decoder_prompt_ids(language=args.language, task=args.task)
+
+    # Potentially load in the weights and states from a previous save
+    if args.resume_from_checkpoint:
+        accelerator.load_state(args.resume_from_checkpoint)
+        path = os.path.basename(args.resume_from_checkpoint)
+        training_difference = os.path.splitext(path)[0]
+        global_step = resume_step = int(training_difference.replace("step_", ""))
+        starting_epoch = resume_step // len(train_dataloader)
+        resume_step -= starting_epoch * len(train_dataloader)
+
+    # We need to adjust the progress bar to the current step
+    progress_bar.update(resume_step)
+    for epoch in range(starting_epoch, args.num_train_epochs):
+        model.train()
+        if args.with_tracking:
+            total_loss = 0
+            running_loss = 0
+        for step, batch in enumerate(accelerator.skip_first_batches(train_dataloader, num_batches=resume_step)):
+            with accelerator.accumulate(model):
+                outputs = model(**batch)
+                loss = outputs.loss
+                accelerator.backward(loss)
+                optimizer.step()
+                lr_scheduler.step()
+
+                # Update the importance of low-rank matrices
+                # and allocate the budget accordingly.
+                # This is only needed for AdaLora.
+                # Note that this requires parameter gradients.
+                # Hence being called before optimizer.zero_grad().
+                if args.use_peft and args.use_adalora:
+                    # Handle DDP case where model is wrapped
+                    if hasattr(model, "module"):
+                        # DDP case
+                        peft_model = model.module
+                    else:
+                        # Non-DDP case
+                        peft_model = model
+
+                    # Check if rank_pattern exists before calling update_and_allocate
+                    if (
+                        hasattr(peft_model, "peft_config")
+                        and peft_model.peft_config["default"].rank_pattern is not None
+                        and global_step >= args.tinit  # Only start updating after tinit steps
+                    ):
+                        peft_model.update_and_allocate(global_step)
+
+                optimizer.zero_grad()
+                global_step += 1
+                progress_bar.update(1)
+
+            if args.with_tracking:
+                step_loss = accelerator.reduce(loss.detach().clone()).item()
+                total_loss += step_loss
+                running_loss += step_loss
+
+            if global_step % args.checkpointing_steps == 0:
+                output_dir = os.path.join(args.output_dir, f"step_{global_step}")
+                accelerator.save_state(output_dir)
+
+            if global_step % args.logging_steps == 0:
+                if args.with_tracking:
+                    accelerator.log({"train/running_loss": running_loss / args.logging_steps}, step=global_step)
+                    running_loss = 0
+
+            if global_step % args.evaluation_steps == 0:
+                eval_metrics = evaluation_loop(
+                    model, eval_dataloader, processor, normalizer, metric, forced_decoder_ids, accelerator
+                )
+                if args.with_tracking:
+                    logger.info(f"Step {global_step} eval metrics: {eval_metrics}")
+                    accelerator.log(eval_metrics, step=global_step)
+                if best_metric is None or eval_metrics["eval/wer"] < best_metric:
+                    best_metric = eval_metrics["eval/wer"]
+                    accelerator.save_state(os.path.join(args.output_dir, "best_checkpoint"))
+                model.train()
+
+            if global_step >= args.max_train_steps:
+                break
+
+        if args.with_tracking:
+            train_epoch_loss = total_loss / (step + 1)
+            logger.info(f"Epoch {epoch} train loss: {train_epoch_loss}")
+            accelerator.log({"epoch/train_loss": train_epoch_loss}, step=epoch)
+
+        if args.push_to_hub and epoch <= args.num_train_epochs - 1:
+            accelerator.wait_for_everyone()
+            unwrapped_model = accelerator.unwrap_model(model)
+            unwrapped_model.save_pretrained(args.output_dir, is_main_process=accelerator.is_main_process)
+            # evaluate the model at the end of training
+            eval_metrics = evaluation_loop(
+                model, eval_dataloader, processor, normalizer, metric, forced_decoder_ids, accelerator
+            )
+            if args.with_tracking:
+                logger.info(f"Step {global_step} eval metrics: {eval_metrics}")
+                accelerator.log(eval_metrics, step=global_step)
+            if best_metric is None or eval_metrics["eval/wer"] < best_metric:
+                best_metric = eval_metrics["eval/wer"]
+                accelerator.save_state(os.path.join(args.output_dir, "best_checkpoint"))
+
+            if accelerator.is_main_process:
+                processor.tokenizer.save_pretrained(args.output_dir)
+                api.upload_folder(
+                    repo_id=repo_id,
+                    folder_path=args.output_dir,
+                    commit_message=f"Training in progress epoch {epoch}",
+                    run_as_future=True,
+                )
+
+    if args.load_best_model:
+        # load the best model
+        accelerator.load_state(os.path.join(args.output_dir, "best_checkpoint"))
+        # Handle DDP case where model is wrapped
+        if hasattr(model, "module"):
+            # DDP case
+            peft_model = model.module
+        else:
+            # Non-DDP case
+            peft_model = model
+
+        # Only resize if rank_pattern exists
+        if hasattr(peft_model, "peft_config") and peft_model.peft_config["default"].rank_pattern is not None:
+            peft_model.resize_modules_by_rank_pattern(peft_model.peft_config["default"].rank_pattern, "default")
+
+        eval_metrics = evaluation_loop(
+            model, eval_dataloader, processor, normalizer, metric, forced_decoder_ids, accelerator
+        )
+        if args.with_tracking:
+            best_metrics = {"best_" + k: v for k, v in eval_metrics.items()}
+            accelerator.log(best_metrics, step=global_step)
+
+    accelerator.wait_for_everyone()
+    unwrapped_model = accelerator.unwrap_model(model)
+    unwrapped_model.save_pretrained(args.output_dir, is_main_process=accelerator.is_main_process)
+    if accelerator.is_main_process:
+        processor.tokenizer.save_pretrained(args.output_dir)
+        if args.push_to_hub:
+            api.upload_folder(
+                repo_id=repo_id,
+                folder_path=args.output_dir,
+                commit_message="End of training",
+            )
+
+    with open(os.path.join(args.output_dir, "all_results.json"), "w") as f:
+        eval_metrics.pop("eval_samples")
+        json.dump(eval_metrics, f)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/int8_training/peft_bnb_whisper_large_v2_training.ipynb b/examples/int8_training/peft_bnb_whisper_large_v2_training.ipynb
new file mode 100644
index 0000000..41c92c6
--- /dev/null
+++ b/examples/int8_training/peft_bnb_whisper_large_v2_training.ipynb
@@ -0,0 +1,20610 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "5cefac89",
+   "metadata": {},
+   "source": [
+    "# Finetuning Whisper-large-V2 on Colab using PEFT-Lora + BNB INT8 training"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "090fa3ed",
+   "metadata": {},
+   "source": [
+    "In this Colab, we present a step-by-step guide on how to fine-tune Whisper for any multilingual ASR dataset using Hugging Face 🤗 Transformers and 🤗 PEFT. Using 🤗 PEFT and `bitsandbytes`, you can train the `whisper-large-v2` seamlessly on a colab with T4 GPU (16 GB VRAM). In this notebook, with most parts from [fine_tune_whisper.ipynb](https://colab.research.google.com/github/sanchit-gandhi/notebooks/blob/main/fine_tune_whisper.ipynb#scrollTo=BRdrdFIeU78w) is adapted to train using PEFT LoRA+BNB INT8.\n",
+    "\n",
+    "For more details on model, datasets and metrics, refer blog [Fine-Tune Whisper For Multilingual ASR with 🤗 Transformers](https://huggingface.co/blog/fine-tune-whisper)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "625e47a0",
+   "metadata": {},
+   "source": [
+    "## initial Setup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eJrPyQM5Xhv5",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "eJrPyQM5Xhv5",
+    "outputId": "cfd6d8c9-964c-492b-b641-8e80e337f783"
+   },
+   "outputs": [],
+   "source": [
+    "!add-apt-repository -y ppa:jonathonf/ffmpeg-4\n",
+    "!apt update\n",
+    "!apt install -y ffmpeg"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "r_Ivl7qlX0dz",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "r_Ivl7qlX0dz",
+    "outputId": "2caa9eed-f01a-4603-a527-fe3b0b58b6e2"
+   },
+   "outputs": [],
+   "source": [
+    "!pip install datasets==3.6.0\n",
+    "!pip install git+https://github.com/huggingface/transformers\n",
+    "!pip install librosa\n",
+    "!pip install evaluate>=0.30\n",
+    "!pip install jiwer\n",
+    "!pip install gradio\n",
+    "!pip install -q datasets accelerate\n",
+    "!pip install -q git+https://github.com/bitsandbytes-foundation/bitsandbytes.git\n",
+    "!pip install -q git+https://github.com/huggingface/transformers.git@main git+https://github.com/huggingface/peft.git@main"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8a528c1a",
+   "metadata": {},
+   "source": [
+    "Linking the notebook to the Hub is straightforward - it simply requires entering your Hub authentication token when prompted. Find your Hub authentication token [here](https://huggingface.co/settings/tokens):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ed0OpduhX2JF",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 303,
+     "referenced_widgets": [
+      "c60690c2aee74763bf23115553f4e640",
+      "7d3d6c198e794219ab5db59f0228c8ab",
+      "5d5ea0207c6148769ad9f15b7b3dd92d",
+      "642e28d258ca4c30a5df94c5cf7e0471",
+      "170ee581427d4f30925dc393d124c1be",
+      "d5d5aa24182a4e04b3fdae1ca7fad52a",
+      "6dba643113a547ac9b6e121d008791d6",
+      "cd9bda1053a14890ad9091c63c0a0acf",
+      "4522666ebbcf4647b06ce81a6316fbbb",
+      "989b3df296504f34a62d31ca0d6d88bb",
+      "e8a7a34c6fb146f0b38a40f389a617fa",
+      "960553d142c446cd8852523887a5cc04",
+      "441820fb176048109e0f8f7e9519d735",
+      "0bb38c654e18429a8396466ebab84504",
+      "1acfc4a2809e41dd995817c3526650dd",
+      "6d5801774beb4b529b227ef2f098614e",
+      "dfdf23cde48c421caebb573060641d6a"
+     ]
+    },
+    "id": "ed0OpduhX2JF",
+    "outputId": "ecc2048a-b46a-4b20-b94a-5912924feb3d"
+   },
+   "outputs": [],
+   "source": [
+    "from huggingface_hub import notebook_login\n",
+    "\n",
+    "notebook_login()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e1da5fff",
+   "metadata": {
+    "id": "e1da5fff"
+   },
+   "outputs": [],
+   "source": [
+    "# Select CUDA device index\n",
+    "import os\n",
+    "\n",
+    "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\"\n",
+    "model_name_or_path = \"openai/whisper-large-v2\"\n",
+    "language = \"Marathi\"\n",
+    "language_abbr = \"mr\"\n",
+    "task = \"transcribe\"\n",
+    "dataset_name = \"mozilla-foundation/common_voice_11_0\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "805b1c56",
+   "metadata": {},
+   "source": [
+    "## Load Dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a2787582-554f-44ce-9f38-4180a5ed6b44",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 1000,
+     "referenced_widgets": [
+      "020176f5aa0a4d489d022ef5e41ef3f6",
+      "cbbba08d9e634560a6c0429e32166fe5",
+      "6d9d1609edc8471dafe653e4da32eeeb",
+      "435b5708e6cf487ebb1799c7b64a8218",
+      "931b96b21b39482298f40449424fdd34",
+      "79da882ea494477a8c94fdac7acd644e",
+      "f14847261aa247fb9561373e0495f3e5",
+      "ce8f306e745d4b158c58058d471de037",
+      "0bd122731d674cdab803a9981eb28237",
+      "46211764bc6641b4b693c16c90747021",
+      "f1884e5a392941bfa8c484496d87084c",
+      "6b1cdae6f5e34d1d9a0b5e7adf5183db",
+      "4d29aa0885214a2aa79701cc226edaef",
+      "5411f018d4464e839f2fb21ad3f026aa",
+      "5fb8e97b25b44e0dae9715eeb97acc5d",
+      "783d4d18627646648f8c120b728babe1",
+      "1a721ed289684104b0fbdc8147c2311b",
+      "4880366554ad4f6687a25b5a17877dcf",
+      "283f5528547b457698ced126c25c2a44",
+      "7c90db94a11e4a5aa432e664b2af4e7e",
+      "7f6a466819bb45e880eb989f388a7523",
+      "d96245da43944c4b8235e0cd02c1aa4c",
+      "41187d9a120448fab6c8608f226971fa",
+      "1d4bd11921d145c7bfd1a8ce0700a666",
+      "2853a43036244f54b74db99311bc580d",
+      "d9a85d7c76b54199bbf7646448e3458c",
+      "b09d153958cf4a28baad268bbda78236",
+      "003227997471488dae9ae26dcbff89ea",
+      "deb18822d58b4b60bb75460f0a5fe921",
+      "e6cf97ef7bc541d0b9c6de206a3a45b0",
+      "a4b16b5279504dd694090798f5925d65",
+      "564cd321c06440e9856f10f5c40c20be",
+      "8a91574c4b6e4745b2b65885323b4d25",
+      "9202065d8e6f425d88e4514dde70992d",
+      "f7b4ec74e2ac45bbbf0265d0363f4d9f",
+      "3a083523ae604362901e4e31c39fe949",
+      "d1bc2ce48c3e481b9059e882b5102946",
+      "30c688df949042ce89337643f6178230",
+      "2bc85a5bde9a454990d3bb7de5e3c7c1",
+      "2ab45b22ce3f400a81cc451b9d7c9eb8",
+      "cdd08679c28642a184805912c07b324e",
+      "90744e5529c04f18b11e00326649abe5",
+      "11b9c50e720a466aa92c64b254d40778",
+      "8f856d6bde4041149324e1f53d19c1cb",
+      "49545bfc91c848b8a465e13d0b45fa34",
+      "45a85ceb24ea444ab18a6985884be966",
+      "ac9c1141ca7c453f84a8ab62b2de9158",
+      "bd4e3eb14252470d9c8ac60a32948a72",
+      "75dfc66dab48405b85073317c8dff155",
+      "b16e3a75acd0403f865849f1de6ca654",
+      "78fb0d05929849ad9aa7a7ded63c7b6b",
+      "3fd0fd7cbbef4785b360891c12017f48",
+      "a9c132959dae4303bcf6015106ce3453",
+      "2ef66808d51d440b9998064e212df420",
+      "45478f2ce991441c8ceaef9acf745084",
+      "c1f019686c564cca87c240a75ab71ad3",
+      "54589117bf244027ba024ea85bd1fd77",
+      "7b7986ad93f64956b8d198d2cb4acb60",
+      "dbc1a016a69b4ad7811d2701a9520a2f",
+      "72f8e7de2a5d4155a9e9146f12e14b19",
+      "46e44f07b96d4c32bbe75bb89159f093",
+      "90b53e96b3f04c2993969b17547ae0d5",
+      "8843f70cfa1f45299a588e96e9c1159a",
+      "8b2e2c650f4b4bee9e763b7c59525ec8",
+      "fb9f013a6188463fad6db70702576c37",
+      "93e2efbb5da747d4b94c916153ee9706",
+      "c44f472624d84e16a0f380580d36ca61",
+      "65188c1fdba2421ba85c2cc349709600",
+      "0683cbffd97a4b75bd5e00a05d541fef",
+      "4573606592ce4b2a914ed0a70b69f9af",
+      "efb85d003fb54f55aa4eadf2ab8b1684",
+      "a235cb3d4d424efeb30901f63fc1dbe5",
+      "2452ab9f6f974d1d831f7c81e884d00e",
+      "bd7da2671a22431889fbfa2ae1e0fe2c",
+      "47ee1eec97cf4af58ed4f50944386a7e",
+      "a05426c8e5f849b7a972dc0df3cd84ef",
+      "1e8cdf737c93431e841e129abb541e22",
+      "91fc5846a32f44d5bc5fa30fdcb3c638",
+      "daf4005d1d334608846d0fb2fe4f837a",
+      "ba48d89cab9346ed92dc338779f9f828",
+      "6b0e0694d895445c9bf7c955a116953f",
+      "ecb7ffba323743c68961e294e74b337b",
+      "460be80f176849e0b1241e3a4fc18b74",
+      "74e2bcef1ce94234bbf6ba0d6488279d",
+      "73bde731e20d48de8ce66b9d72fb95cb",
+      "9afdb23ba9ee47709f194e0e92de0edf",
+      "621f989f46f84d73b96a37c954e92b8d",
+      "89bb7bbcaa194a23bf3d908a4782ccb8",
+      "59e79d9132964429a2a2abbdf4bdbf32",
+      "2e5c1a371742446e8bc416d4735c9ce3",
+      "e57b15cc74e7474083e87722d6acde47",
+      "e899060f1edc43b980fe6f3bbe13c609",
+      "a6963ce72cb3425791804abf1718ba90",
+      "41a7cc33e0bc4bc5bc04dfc72bab7a81",
+      "28279812acfb4272a1c28ed70aa1362d",
+      "451d3851e29e4efabbc2c235dea718da",
+      "18dfdd09a3af49f5b17cda27872d0ba3",
+      "aaeec2b7986d493e8d238aa14f2e5937",
+      "0894264041854eea960707529f3fb8c7",
+      "3a4965f422f14e1ca2a63e1852235507",
+      "e590170f306347f3a82b76a25d37b652",
+      "384f4d9515d1431589a3cc934bcf5ea7",
+      "edc24ce2510f45f8adde0a187016259f",
+      "c2c2608dd091493795d975f1a3cc3762",
+      "1dedb58d31dd43db96ddd7315bb7e2ee",
+      "308e1ee4593b454a84681bda10921207",
+      "8f52bab9ebd049d6a57686d621f407ac",
+      "2958a33cff794de1aa8128327bf405f1",
+      "1b2780d8137042449bd6779c70bf43ca",
+      "ddc2a8e8ef4d429f95081c4c5baf1fb3",
+      "ce06b2a0de6c4fb8bae36bc4d7f63270",
+      "c4cca1778f314ce582bd09b9b2494f82",
+      "3bd70d937e924f61b943acb0aaf15619",
+      "c81c5d3a4dc5409e95a6410e67fa9857",
+      "dd02d1b31bfd4b19ad626d6691a9b293",
+      "b1d780c721b840d7a06661a7a5e63236",
+      "d19402df47464044b36fb5ee4a0c1c4d",
+      "b1221f4e0a57482682ea4bd6ae245da3",
+      "64533507b97148008548e55623b6c2a3",
+      "33888a5cafe6495782309dae44531dd3",
+      "7d5ff2f1b8794bad8286e90307bd6a61",
+      "7a2d45b371ba47a994e4372437f51cff",
+      "dec9f287435e4c6b9fb1d1ead2ded576",
+      "db5e1bf1871546408f233f0cbc37b136",
+      "af44aa66372a43beb9812ad9895d8d1f",
+      "9b427631384c47ab89ee1352c0236afd",
+      "00071f8cf276478fb2740684552f1275",
+      "64378b1064dc4036a9a4c8813013e210",
+      "ed7daa32c94648d5951876229f9835b3",
+      "eb883a37a9cf4945bd864decb4fc87ea",
+      "7b190bb2bd234b7997ca041baddd511f",
+      "7549fd0b38364d8580f8eb1549558a33",
+      "5cba5542df344d54bb80dcf7be56b2ae",
+      "8daed385e6564c7897fb6553669a9065",
+      "25fcd4b584a143058266f7f3a650d69a",
+      "58a15b8df2d54f89828bcd205d6bf298",
+      "8b51633b2fe5479db0fc73cd3f0ebaea",
+      "d2c1704e34c34d12b99c31d64fce88cc",
+      "6bdce3b33872457ea67a3a3191f438ca",
+      "c8ba787279ea43aa97b134c134d4f183",
+      "6efc3be410ef4710a59dea8dbdabcdf3",
+      "6f9d8dc63c494c76b36074af773330ce",
+      "64c0bac85ee446e284ed85ec0eb5ad44",
+      "5162987085ce45d88233f34ca3a41ce0",
+      "00819c11ea23467689e78a00d89d1b09",
+      "65dbf3c3a80b468aa8717e97c14db6a2",
+      "8cb910ad08024c818b99c2e30e30b039",
+      "0235efbdc6a74cce8050ab1116466427",
+      "ee1ae17fdf4143ae8125ce5e2a7e9066",
+      "481ebdff3ccc40fcb7a8d848b01ae8db",
+      "6117f9e9718c4f4388bd1feec34578b4",
+      "623d0c6427964291b5c74fb18bfb4ce4",
+      "14bca5cf764d4464a186961ccc6bdb3d",
+      "75c793c91b9e4aa994c2d34ebb16f7d4",
+      "3502b5f8aeab4bfd89c83b99ab308b9e",
+      "c43169085f2949f1b8259cd0b767d121",
+      "4903414a865c4813a9371e8b301f1af7",
+      "ec7e7e3811e34b4a8c8cc31cd021cf20",
+      "a22db8523d44457bb96448d08129988f",
+      "9980bca9b1334893bf6583c325122f50",
+      "931fc769fbeb42bf82df6ef5f914bf48",
+      "e944fa694d824042845364bdba72d642",
+      "3785471f614f47c78e3000a303b11ca6",
+      "dd634585d5e64c97881b132b1d59083e",
+      "785f3df156b946449c492f1296656a70",
+      "47a25de2e10d4b55a9e6827b85e49c3a",
+      "898c7b43a5e94601bc093e0cde28c2ec",
+      "a03430c0cdcb47bfbd2ffd754074d692",
+      "cda6af0ca01d4053bcebe06f3c41d887",
+      "abe561c67f1f42b29c33d4c296221b2f",
+      "21ca204b93994e8790c9eb7b0722761f",
+      "f628cb62f5fa446eb608467c1ecea526",
+      "e20264d19e804f9dba3e3867ef9b31bd",
+      "43141dcab2324fc6a12f9b8198e10154",
+      "f773a61b1dba4e3eb0df36162efe9abc",
+      "bfc9036c9c5f4be7ab191b92d92f1352",
+      "0f534e081ec64883a5f88d06f93aeb00",
+      "3a94afa1e03544f68df7752a4f503fbc",
+      "32ed17ecaf7548d5a80b27eb97cd78af",
+      "56817cd3b11e46f187dc13e71b7ec97d",
+      "3d30c20af23e495999646521d39e8e66",
+      "bafada4a1f29442296c47018dcaedb77",
+      "6cd3baac550741ba866ce2cd2dcaebdf",
+      "bc9c3ba4bc6d4623a764d92890536935",
+      "719f2b2ab9eb4e348ae902d063c27e2d",
+      "5e09bdca5081429ab82b488a3e016fbf",
+      "200bc7d8c2bc494399a4560dabd64293",
+      "91c3b5ddf5fb4c7aa835d992b4c7b4e7",
+      "52ff6528abdd4a9e9b85f4b355b2391d",
+      "6bb6737e22bd48d786b02051d077e8cc",
+      "e97a0201b81446b882ba802a5a3b00e8",
+      "c1a89a042b044278a8666da306e6a481",
+      "21ce216193f346c09a04a1d64bc0cd8a",
+      "23ee9c5c18c64305adc55ee218afd7a9",
+      "1f632bdc00e84422b64c0a4b8e238f34",
+      "8d50d82f9d94482c9883f99ea5c7d704",
+      "6a2dea21e7ce4eda8953995497308327",
+      "2f3d1d2f1c92402cadc4cfa1b0094238",
+      "844caba5ebdd48189517a10705543292",
+      "2d667cd4bc134a44958d17ef75d86321",
+      "acfb7b6734884939a753fc19047bb9bc",
+      "73cd51c6c43b40cab25d411e7c0f6ad1",
+      "19c7ea1e9364437a9c0bf6b4e645f854",
+      "8675aad817a44ab39b097ec864669833",
+      "5664e1233a904f4bb4af9c5322517fab",
+      "0ae5110b687440e89ebebfb847985aa1",
+      "85509b0aafec47e5ad540abc7ae4ab7d",
+      "d3d7c15d53c8498e823c84fe609321dd",
+      "80de3739b91a45478cb6a00dcaeae756",
+      "7c99e16722cf4fab866732557769b921",
+      "00834c084ddb4f46ac29f14575a2383d",
+      "4ce1e695a6ab4906ba0817005cf58d55",
+      "eb03476353ef4568b94a3071918e72f2",
+      "1b8307d133bf4280845f7d3a302b3a2b",
+      "daee15869a92459aabcd9128526183d5",
+      "5ddd9e1a1fab4531930acaf08cc45c73",
+      "4081e141986f4abba15477a12a752ca0",
+      "892e150a80464f8198024587a47186ba",
+      "9f9e15ff2e394ee7a7776e3e7f4b7d30",
+      "7e264d54d38e4d02acfd47e4e533b49d",
+      "746302ee5d21495db5d9a13789c5256c",
+      "47f7ff7b213e405a822ad6fe2e5de431",
+      "e4810a798c0f47b6b54f84ff4ffec608",
+      "8e480fe546f24afebb1ea723bff84456",
+      "0cf925f582374cd197164625f0ddf27d",
+      "aa7557fbffc54ed3a9c58c1531fd93f6",
+      "061c90e4148b43b8ba65848ca4c1ba46",
+      "f617d181ffdb4b1e8d81fbb393923a6e",
+      "a26ddb684a07496da4290e3f6031b685",
+      "f20fc82bcbf245619ad4dec04d0f999d",
+      "8016eabfc7aa48c2bc0bf3a13919a675",
+      "83cb83e404a24fba8cf43610cb1696fc",
+      "7b70db203ee644fe81006f5d48aa426d",
+      "efd9d5724dbd435991052b4445c6970f",
+      "41f65340441f419d91e1d3841921f48a",
+      "58aba8edefa44c60818891a2651137be",
+      "e5e8f119a91944f296ff821dd7ecfb1b",
+      "568a85caf800461b8571e3d206854e6b",
+      "e2a8a379bd0d4cbdb22fbc3bbb4fdc7a",
+      "2c7d952f958247b681301d1c6bff4fa7",
+      "27649a0d303643d8985caf506ef66fc3",
+      "1855ae0388074d08a4763b7ac76c6948",
+      "7e5252f608d6468f80deb468cb2556fd",
+      "bce6b62300d942a1ab89a6f0ceb16d30",
+      "0239f7263d1a4e8b9475ae48379c068d",
+      "5b527e45d6a946b28047115fa6b5aa3a",
+      "3c5eb07f0bff43948ff1f283c3c56b0f",
+      "3545fcc1e9d7453099c4931f658e0bc8",
+      "2f314258091a430095794c3fe0aea7e3",
+      "0ebfa123462342e99ad81b7e5ee00eac",
+      "8af6bd6e8cae4964a2e372be30220bd9",
+      "4184f160ab6d4f58bc921fb7ba89cf60",
+      "575c4d8d503244d8a9f2a5709021b5b2",
+      "ffce35af1ad84a2c838cca55a26dd3c4",
+      "d21cd4878c6e49d38dd3abb2e3b3f566",
+      "969e3cf7f3634c3f90b5fea38c5797ca",
+      "78501c2a5ac84f9ca0d20bbef340fc9f",
+      "5b4fbd1102a84670a1eed6f3d25c0bcd",
+      "621880c98245427881dd5b004b480c6a",
+      "65c2716dd7f14afa93d3bfaebe85c44f",
+      "2ff541d18f5844408690be00c7259d59",
+      "679fa9d2a703494dbb10fbfd19879f1a",
+      "6717b182e5674afb90006b50dea98cae",
+      "0887c7aabbbe4d4e8fdc64d2e2657cc7"
+     ]
+    },
+    "id": "a2787582-554f-44ce-9f38-4180a5ed6b44",
+    "outputId": "b1729004-591e-41c2-c206-9d0e572eb8e5"
+   },
+   "outputs": [],
+   "source": [
+    "from datasets import load_dataset, DatasetDict\n",
+    "\n",
+    "common_voice = DatasetDict()\n",
+    "\n",
+    "common_voice[\"train\"] = load_dataset(dataset_name, language_abbr, split=\"train+validation\")\n",
+    "common_voice[\"test\"] = load_dataset(dataset_name, language_abbr, split=\"test\")\n",
+    "\n",
+    "print(common_voice)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "20ba635d-518c-47ac-97ee-3cad25f1e0ce",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "20ba635d-518c-47ac-97ee-3cad25f1e0ce",
+    "outputId": "dd81bced-f544-4d55-9669-5babb901f842"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "DatasetDict({\n",
+      "    train: Dataset({\n",
+      "        features: ['audio', 'sentence'],\n",
+      "        num_rows: 3927\n",
+      "    })\n",
+      "    test: Dataset({\n",
+      "        features: ['audio', 'sentence'],\n",
+      "        num_rows: 1816\n",
+      "    })\n",
+      "})\n"
+     ]
+    }
+   ],
+   "source": [
+    "common_voice = common_voice.remove_columns(\n",
+    "    [\"accent\", \"age\", \"client_id\", \"down_votes\", \"gender\", \"locale\", \"path\", \"segment\", \"up_votes\"]\n",
+    ")\n",
+    "\n",
+    "print(common_voice)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2d63b2d2-f68a-4d74-b7f1-5127f6d16605",
+   "metadata": {
+    "id": "2d63b2d2-f68a-4d74-b7f1-5127f6d16605"
+   },
+   "source": [
+    "## Prepare Feature Extractor, Tokenizer and Data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bc77d7bb-f9e2-47f5-b663-30f7a4321ce5",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 49,
+     "referenced_widgets": [
+      "4d25d9919acf44a19f1b6f8fd625f808",
+      "b041efb27b6149fcaf206590f1c1b961",
+      "4668602d021a400a8b0ec88599abc85c",
+      "92d9732acb964601b27695041f9fbb72",
+      "c3ea17f7dd94462986d30b751664d77b",
+      "1b1dc31d9a2b4357a71119300c6d899a",
+      "7a24ae9d13fb4e82b1993b05f8d71d11",
+      "e1141861d9f44d4c95313fd432795b70",
+      "6ef55b5db76d4c78854fa0c27165e480",
+      "91b103ac79e641b190416acdeb55902c",
+      "e9e10f1e53b74509bfc9c0bf11502c5e"
+     ]
+    },
+    "id": "bc77d7bb-f9e2-47f5-b663-30f7a4321ce5",
+    "outputId": "7abb2062-e755-4f1a-e88b-9b7bf2986dbf"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import WhisperFeatureExtractor\n",
+    "\n",
+    "feature_extractor = WhisperFeatureExtractor.from_pretrained(model_name_or_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c7b07f9b-ae0e-4f89-98f0-0c50d432eab6",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 209,
+     "referenced_widgets": [
+      "f436e6a7d3014e2ca44c94455bfeace8",
+      "f9d6d41ffeba43cf94ec9d7a96af6617",
+      "bed65245e7234977874d35bf78694e35",
+      "c28c2fc81e0e467cbc0ded0205d1ee85",
+      "ea941a078b984f51b66b5f1e8f3d1d82",
+      "e3f1244dbe2c48bc8102f958c3df6467",
+      "786d3d34cfd24f81996797c55b10b443",
+      "3a4bb5b9cf864265af8f1a0b989dff2c",
+      "ac2e1977ddaf4b948c9cc24d84c08b83",
+      "dd339bf6baf6433e92665e30dc30b062",
+      "6a544d6dd5954beab32ce3089d8d2aac",
+      "f933fbdcc26d41b0bb294dabd0337834",
+      "950e74921e6042868ab6b7b9070d6f69",
+      "82dc91c5b065459d827863699a9710e1",
+      "5b7b6f08765c4c1989f945414f2c3cf4",
+      "735c3606df924b9297ddc05fae3e92d5",
+      "d5d632dd16f147e090c62aad38c45d3c",
+      "24191f38e3654b86a5da3576615e2229",
+      "4b1f4abe697948d5a1cca9b45b2a6f87",
+      "8527f474f1a549abafe9519e2b4bd338",
+      "1031dc4b5d2d45f3b14ab12dbd9bca56",
+      "ab40616ed9b74f438e74d403f848bed4",
+      "e6c2dc814c324a0c8cb744ca16707479",
+      "a615446a48624d0f9a009c1f6d8b1a54",
+      "383d6e891c5249b4b2fabb60d4900488",
+      "3c3214f235a54864848902f7e53662db",
+      "73f6e6860b64491284c9442f0deae8b6",
+      "6d9826a5adb847e8b4cc4486a31b52ce",
+      "e8b3093587e44164b0ac043414cea0fa",
+      "96266c5722f54eeeb682b2707b8025dd",
+      "f0be69583cd1410da6dbc18302d4439b",
+      "c24ddbaafa5f4a63b391d981a4f10354",
+      "629725dfcc684b1db1a57850c3bc7bc3",
+      "add0f175631742d49dd4695bc004e81a",
+      "5871a46d60f14da99e4bb8ee74405319",
+      "64b308019fff4095ab7f1812aab4676a",
+      "03f62b3f5aa64b6390b157cb3f9d2b9f",
+      "59657f26f4af490980b1d9bea1526e5e",
+      "1571fa5d8f494704949c5809f3409fa7",
+      "5ef218872f2646249888def0abed7149",
+      "03fcbc61c50c4ddc9c3684e4c085bffb",
+      "e4234c7c29744fc4be99b8b2ebedc9d1",
+      "70aa1fc14b09473e911dad3f9030b15b",
+      "008bead021ea416eb31dd9143d5ae5b9",
+      "ebd79e22ad4e4256a6d88883af2c1eef",
+      "c47ba0b11e074f708338863a35a78f7b",
+      "72b715be2c774235a21602b18d71e75a",
+      "ff9a0ed54bab49aca6f27bf1be66958e",
+      "15b5e415b62146ba96215458cf116431",
+      "8b0dd001d5b04647b1c480aab83d03a2",
+      "0af935ad4f694fb48094e6a119cbcf82",
+      "7cfbb542eba34459ba64b881c1040eee",
+      "fe48e65b2371445bbb01a8d3e9af1f67",
+      "b8d3539c8a454217a3b6ffab51259054",
+      "05e96819517e417aaf05f5f38c0c8b76",
+      "b600ead93bbf44a3a3fe229589c63a61",
+      "3d4c614fb775434fb0c5b02d46246ee0",
+      "344d1cc53e28411cae839a4ebba1bf58",
+      "a1578c0c777f4780a3fdd1635a0909d9",
+      "41faf55c8878475f8a986b02ad73e8ce",
+      "b5c8221a09df4dfdb74017d4af544b95",
+      "65e4b8dae1e4435cb7737a8d5dd13d91",
+      "6d932eadfd6a448a9a71d741bb64f428",
+      "dce0d285c7d947dfba9ee5bc1a6ebece",
+      "bde010029c374a0eb2bb942f380f0e8b",
+      "a91f37ce798d411ea2a33cfdb1f01251"
+     ]
+    },
+    "id": "c7b07f9b-ae0e-4f89-98f0-0c50d432eab6",
+    "outputId": "4c094075-3f95-42db-9f4b-4db0c2fbeb91"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import WhisperTokenizer\n",
+    "\n",
+    "tokenizer = WhisperTokenizer.from_pretrained(model_name_or_path, language=language, task=task)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "77d9f0c5-8607-4642-a8ac-c3ab2e223ea6",
+   "metadata": {
+    "id": "77d9f0c5-8607-4642-a8ac-c3ab2e223ea6"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import WhisperProcessor\n",
+    "\n",
+    "processor = WhisperProcessor.from_pretrained(model_name_or_path, language=language, task=task)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "381acd09-0b0f-4d04-9eb3-f028ac0e5f2c",
+   "metadata": {
+    "id": "381acd09-0b0f-4d04-9eb3-f028ac0e5f2c"
+   },
+   "source": [
+    "### Prepare Data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6e6b0ec5-0c94-4e2c-ae24-c791be1b2255",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 72
+    },
+    "id": "6e6b0ec5-0c94-4e2c-ae24-c791be1b2255",
+    "outputId": "1f1fe2d1-3ad2-42d4-e6f0-f0929785ae8e"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'audio': {'path': '/root/.cache/huggingface/datasets/downloads/extracted/f7e1ef6a2d14f20194999aad5040c5d4bb3ead1377de3e1bbc6e9dba34d18a8a/common_voice_mr_30585613.mp3', 'array': array([-1.3727526e-15, -1.2400461e-13, -1.5159097e-13, ...,\n",
+      "        4.7928120e-06,  3.5631349e-06,  1.6352631e-06], dtype=float32), 'sampling_rate': 48000}, 'sentence': 'आईचे आजारपण वाढत चालले, तसतशी मथीही नीट खातपीतनाशी झाली.'}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(common_voice[\"train\"][0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5a679f05-063d-41b3-9b58-4fc9c6ccf4fd",
+   "metadata": {
+    "id": "5a679f05-063d-41b3-9b58-4fc9c6ccf4fd"
+   },
+   "source": [
+    "Since \n",
+    "our input audio is sampled at 48kHz, we need to _downsample_ it to \n",
+    "16kHz prior to passing it to the Whisper feature extractor, 16kHz being the sampling rate expected by the Whisper model. \n",
+    "\n",
+    "We'll set the audio inputs to the correct sampling rate using dataset's \n",
+    "[`cast_column`](https://huggingface.co/docs/datasets/package_reference/main_classes.html?highlight=cast_column#datasets.DatasetDict.cast_column)\n",
+    "method. This operation does not change the audio in-place, \n",
+    "but rather signals to `datasets` to resample audio samples _on the fly_ the \n",
+    "first time that they are loaded:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f12e2e57-156f-417b-8cfb-69221cc198e8",
+   "metadata": {
+    "id": "f12e2e57-156f-417b-8cfb-69221cc198e8"
+   },
+   "outputs": [],
+   "source": [
+    "from datasets import Audio\n",
+    "\n",
+    "common_voice = common_voice.cast_column(\"audio\", Audio(sampling_rate=16000))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "00382a3e-abec-4cdd-a54c-d1aaa3ea4707",
+   "metadata": {
+    "id": "00382a3e-abec-4cdd-a54c-d1aaa3ea4707"
+   },
+   "source": [
+    "Re-loading the first audio sample in the Common Voice dataset will resample \n",
+    "it to the desired sampling rate:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "87122d71-289a-466a-afcf-fa354b18946b",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "87122d71-289a-466a-afcf-fa354b18946b",
+    "outputId": "727a709a-2b21-4c54-807f-efd40ea1719c"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'audio': {'path': '/root/.cache/huggingface/datasets/downloads/extracted/f7e1ef6a2d14f20194999aad5040c5d4bb3ead1377de3e1bbc6e9dba34d18a8a/common_voice_mr_30585613.mp3', 'array': array([-4.4097186e-14, -9.4153831e-14,  3.4645775e-13, ...,\n",
+      "       -7.6018655e-06, -1.8617659e-06,  4.4520480e-06], dtype=float32), 'sampling_rate': 16000}, 'sentence': 'आईचे आजारपण वाढत चालले, तसतशी मथीही नीट खातपीतनाशी झाली.'}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(common_voice[\"train\"][0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91edc72d-08f8-4f01-899d-74e65ce441fc",
+   "metadata": {
+    "id": "91edc72d-08f8-4f01-899d-74e65ce441fc"
+   },
+   "source": [
+    "Now we can write a function to prepare our data ready for the model:\n",
+    "1. We load and resample the audio data by calling `batch[\"audio\"]`. As explained above, 🤗 Datasets performs any necessary resampling operations on the fly.\n",
+    "2. We use the feature extractor to compute the log-Mel spectrogram input features from our 1-dimensional audio array.\n",
+    "3. We encode the transcriptions to label ids through the use of the tokenizer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6525c478-8962-4394-a1c4-103c54cce170",
+   "metadata": {
+    "id": "6525c478-8962-4394-a1c4-103c54cce170"
+   },
+   "outputs": [],
+   "source": [
+    "def prepare_dataset(batch):\n",
+    "    # load and resample audio data from 48 to 16kHz\n",
+    "    audio = batch[\"audio\"]\n",
+    "\n",
+    "    # compute log-Mel input features from input audio array\n",
+    "    batch[\"input_features\"] = feature_extractor(audio[\"array\"], sampling_rate=audio[\"sampling_rate\"]).input_features[0]\n",
+    "\n",
+    "    # encode target text to label ids\n",
+    "    batch[\"labels\"] = tokenizer(batch[\"sentence\"]).input_ids\n",
+    "    return batch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "70b319fb-2439-4ef6-a70d-a47bf41c4a13",
+   "metadata": {
+    "id": "70b319fb-2439-4ef6-a70d-a47bf41c4a13"
+   },
+   "source": [
+    "We can apply the data preparation function to all of our training examples using dataset's `.map` method. The argument `num_proc` specifies how many CPU cores to use. Setting `num_proc` > 1 will enable multiprocessing. If the `.map` method hangs with multiprocessing, set `num_proc=1` and process the dataset sequentially."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7b73ab39-ffaf-4b9e-86e5-782963c6134b",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 197,
+     "referenced_widgets": [
+      "466eeda389c442e487742faff05eeb81",
+      "664ff40a4e7346869652ba3be663acf2",
+      "3d8f10b5726b46de934dd0f7ed7244e4",
+      "b803893882ac4358a4676964dfb3fb31",
+      "4ff7e3d07f6a48f8935f0f42b86fc20c",
+      "3e5db1000a6c4871936614e712e769db",
+      "21dcf39a421847a78ea685eec0983fc6",
+      "c4119f7ec7464aab90f17d022e674999",
+      "965ac01b68064dc5a9fc3bb3f244c804",
+      "f5d7433d15de45e997d12568cac536fc",
+      "14e284f308844311a9ad40415091d93f",
+      "58c3766293e64116a131357f6cc66fe5",
+      "abc8f69eae7b46b1b430cf3b7a231b05",
+      "979edd227f0840a4be0233082e452b5a",
+      "12dedd9f089c42f3a8bba9adb01cf9d3",
+      "3042d874fcf544fabc4701938bca7cf3",
+      "baa8f739bb7e402bae7ee479e282e813",
+      "54509d703b7d4416bdee59157f918396",
+      "ec6017ce2fb3431ab823bde05f977a61",
+      "1a540a7cba794122abdb1900061479e2",
+      "d046a46c70ea46ffbb04a3c9f55637d5",
+      "99b628071c814d88a3cd5d72e4c95f01",
+      "e213d1c919314315ada180d49e27dfb6",
+      "0ea1f163e4174684bd6efc2e2433c1d3",
+      "09511a81a89d4754897a3507a84405be",
+      "8338339ab8a242c1a485bce8558f9c39",
+      "8e84abf61e3e45d58efc7ccd0bfe8d37",
+      "47a5e0cfb3564c16acaedb88613b9020",
+      "09e357a7187044b0bd2b841893a2601f",
+      "65e8c45d05be4d41b136439d9785a09c",
+      "1442a54fad7d44ddbafdacaf7f95279a",
+      "4bea6b0455ae4019b33d45491dbf4584",
+      "9c928a14371a4d9aa521953e287fff54",
+      "b8acdb71c3564972a6c8b27e964ec061",
+      "688f552e85714fe6a5d3eda82be0106a",
+      "a8aac44a077040bd9f4638c0c8f7a877",
+      "89f8ede64593475da4e056e9907f370f",
+      "851902cb2b0e494998684409d82dafd1",
+      "328f4d11886d48f49d4578e8e352097f",
+      "a25ef41450eb42ff9b8b618b40080ac0",
+      "04144ed3ff5f423f99179702cee5343f",
+      "8c41e1ee1a2c49b8b3d3d320fbf26262",
+      "4edf0948ed1346ceba1c0148e9c6fe1c",
+      "40f2b2ff75ca4562808fc2c7a870901e"
+     ]
+    },
+    "id": "7b73ab39-ffaf-4b9e-86e5-782963c6134b",
+    "outputId": "eecac4c8-c5f8-427b-a2ba-0d51fae825ac"
+   },
+   "outputs": [],
+   "source": [
+    "common_voice = common_voice.map(prepare_dataset, remove_columns=common_voice.column_names[\"train\"], num_proc=2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c4be572c",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "c4be572c",
+    "outputId": "0383124a-d4b1-4abe-a8a1-868ce6b3884e"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Dataset({\n",
+       "    features: ['input_features', 'labels'],\n",
+       "    num_rows: 3927\n",
+       "})"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "common_voice[\"train\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "263a5a58-0239-4a25-b0df-c625fc9c5810",
+   "metadata": {
+    "id": "263a5a58-0239-4a25-b0df-c625fc9c5810"
+   },
+   "source": [
+    "## Training and Evaluation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8d230e6d-624c-400a-bbf5-fa660881df25",
+   "metadata": {
+    "id": "8d230e6d-624c-400a-bbf5-fa660881df25"
+   },
+   "source": [
+    "### Define a Data Collator"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8326221e-ec13-4731-bb4e-51e5fc1486c5",
+   "metadata": {
+    "id": "8326221e-ec13-4731-bb4e-51e5fc1486c5"
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "\n",
+    "from dataclasses import dataclass\n",
+    "from typing import Any, Dict, List, Union\n",
+    "\n",
+    "\n",
+    "@dataclass\n",
+    "class DataCollatorSpeechSeq2SeqWithPadding:\n",
+    "    processor: Any\n",
+    "\n",
+    "    def __call__(self, features: List[Dict[str, Union[List[int], torch.Tensor]]]) -> Dict[str, torch.Tensor]:\n",
+    "        # split inputs and labels since they have to be of different lengths and need different padding methods\n",
+    "        # first treat the audio inputs by simply returning torch tensors\n",
+    "        input_features = [{\"input_features\": feature[\"input_features\"]} for feature in features]\n",
+    "        batch = self.processor.feature_extractor.pad(input_features, return_tensors=\"pt\")\n",
+    "\n",
+    "        # get the tokenized label sequences\n",
+    "        label_features = [{\"input_ids\": feature[\"labels\"]} for feature in features]\n",
+    "        # pad the labels to max length\n",
+    "        labels_batch = self.processor.tokenizer.pad(label_features, return_tensors=\"pt\")\n",
+    "\n",
+    "        # replace padding with -100 to ignore loss correctly\n",
+    "        labels = labels_batch[\"input_ids\"].masked_fill(labels_batch.attention_mask.ne(1), -100)\n",
+    "\n",
+    "        # if bos token is appended in previous tokenization step,\n",
+    "        # cut bos token here as it's append later anyways\n",
+    "        if (labels[:, 0] == self.processor.tokenizer.bos_token_id).all().cpu().item():\n",
+    "            labels = labels[:, 1:]\n",
+    "\n",
+    "        batch[\"labels\"] = labels\n",
+    "\n",
+    "        return batch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3cae7dbf-8a50-456e-a3a8-7fd005390f86",
+   "metadata": {
+    "id": "3cae7dbf-8a50-456e-a3a8-7fd005390f86"
+   },
+   "source": [
+    "Let's initialise the data collator we've just defined:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fc834702-c0d3-4a96-b101-7b87be32bf42",
+   "metadata": {
+    "id": "fc834702-c0d3-4a96-b101-7b87be32bf42"
+   },
+   "outputs": [],
+   "source": [
+    "data_collator = DataCollatorSpeechSeq2SeqWithPadding(processor=processor)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d62bb2ab-750a-45e7-82e9-61d6f4805698",
+   "metadata": {
+    "id": "d62bb2ab-750a-45e7-82e9-61d6f4805698"
+   },
+   "source": [
+    "### Evaluation Metrics"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "66fee1a7-a44c-461e-b047-c3917221572e",
+   "metadata": {
+    "id": "66fee1a7-a44c-461e-b047-c3917221572e"
+   },
+   "source": [
+    "We'll use the word error rate (WER) metric, the 'de-facto' metric for assessing \n",
+    "ASR systems. For more information, refer to the WER [docs](https://huggingface.co/metrics/wer). We'll load the WER metric from 🤗 Evaluate:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b22b4011-f31f-4b57-b684-c52332f92890",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 49,
+     "referenced_widgets": [
+      "215c3486e13343e091a26d658e1030d2",
+      "999382fb9e764a98893bd5269261d70b",
+      "4e9729771294424f959bbfb6bf8b60f3",
+      "3d2249516ecd43a08b5fba53fddb32e8",
+      "681711ebd0c64a63bee6b5337ef401db",
+      "d37791ea2b6c4152991295ca0edb0fb7",
+      "730f4d93bbd94452a59de43bf3d0a266",
+      "048e5c87cea34014a8f8a4538f4126bd",
+      "fbd27061ff114846aedc99bc2d17f7a7",
+      "5a306409e9e045b2b936267c520f935c",
+      "9f0638198f544a3bbb31a3a78b7bd2c2"
+     ]
+    },
+    "id": "b22b4011-f31f-4b57-b684-c52332f92890",
+    "outputId": "b0a08086-69b9-4ab4-97ac-dbed295f2e15"
+   },
+   "outputs": [],
+   "source": [
+    "import evaluate\n",
+    "\n",
+    "metric = evaluate.load(\"wer\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4f32cab6-31f0-4cb9-af4c-40ba0f5fc508",
+   "metadata": {
+    "id": "4f32cab6-31f0-4cb9-af4c-40ba0f5fc508"
+   },
+   "source": [
+    "We then simply have to define a function that takes our model \n",
+    "predictions and returns the WER metric. This function, called\n",
+    "`compute_metrics`, first replaces `-100` with the `pad_token_id`\n",
+    "in the `label_ids` (undoing the step we applied in the \n",
+    "data collator to ignore padded tokens correctly in the loss).\n",
+    "It then decodes the predicted and label ids to strings. Finally,\n",
+    "it computes the WER between the predictions and reference labels:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "23959a70-22d0-4ffe-9fa1-72b61e75bb52",
+   "metadata": {
+    "id": "23959a70-22d0-4ffe-9fa1-72b61e75bb52"
+   },
+   "outputs": [],
+   "source": [
+    "def compute_metrics(pred):\n",
+    "    pred_ids = pred.predictions\n",
+    "    label_ids = pred.label_ids\n",
+    "\n",
+    "    # replace -100 with the pad_token_id\n",
+    "    label_ids[label_ids == -100] = tokenizer.pad_token_id\n",
+    "\n",
+    "    # we do not want to group tokens when computing the metrics\n",
+    "    pred_str = tokenizer.batch_decode(pred_ids, skip_special_tokens=True)\n",
+    "    label_str = tokenizer.batch_decode(label_ids, skip_special_tokens=True)\n",
+    "\n",
+    "    wer = 100 * metric.compute(predictions=pred_str, references=label_str)\n",
+    "\n",
+    "    return {\"wer\": wer}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "daf2a825-6d9f-4a23-b145-c37c0039075b",
+   "metadata": {
+    "id": "daf2a825-6d9f-4a23-b145-c37c0039075b"
+   },
+   "source": [
+    "### Load a Pre-Trained Checkpoint"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "437a97fa-4864-476b-8abc-f28b8166cfa5",
+   "metadata": {
+    "id": "437a97fa-4864-476b-8abc-f28b8166cfa5"
+   },
+   "source": [
+    "Now let's load the pre-trained Whisper `small` checkpoint. Again, this \n",
+    "is trivial through use of 🤗 Transformers!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5a10cc4b-07ec-4ebd-ac1d-7c601023594f",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 220,
+     "referenced_widgets": [
+      "d8c1a66480204f1095ff5f6a7dd2e477",
+      "9dc736113ef6477d91aaf71c9969ca74",
+      "79521628c64b4d6f9f22e73749298693",
+      "c7268972f75e4824893ebe7d893a18e1",
+      "a87598d464174703b5f5a5eca23543f3",
+      "e0529b81739144db8912c2d6789e729a",
+      "13d0a97497274652b081cbcefb3fd17d",
+      "08b26adf061b48f59078bf0c0b59e643",
+      "ef056ad59e314089a012acaa73a54e4f",
+      "7935e298049f4deeaeb278ba3de92291",
+      "3afca90970fc4925a05a9a1aa5c8d2f2",
+      "40aba44ef0a74c0d9a385c803c1365a6",
+      "ae54388d78dc4b7ebd1b21860421ffe4",
+      "bb4a47c63d254d4aa3220e85f86d37c4",
+      "cd585c98560b42c8b4a08df5b853b23c",
+      "a140cd385e5a4c0a88c5562370982d2e",
+      "fce64f5690024c698701330f0e5d039a",
+      "abd0e7c414974e51b280a29bf978f776",
+      "bf7961a79c2f403a89a4fb6d4b1a02e5",
+      "1d8636d1d1c3442fbbc2fc83cd03fa44",
+      "313090dc1f034ab19d5ffc573ea1aa5c",
+      "966c0400dafe4e3ea2c9baebc2e104fa",
+      "9087be5d992c4198b3ec2c61f4021164",
+      "6bc07db3471342a6bbc1b86ca734b3e6",
+      "4f167e9657274d56b8568d48262d1ee6",
+      "b7fbaa9d4bcd40b5bcf8d1475658c5b1",
+      "ba21f5ddf2434cc792b70a70c8c1079e",
+      "21bc84c704874455a57c47239984d28d",
+      "5b226e580df94448bed54b400c7a9a25",
+      "b0237154051343adaa076a9cc6dd711d",
+      "64756452791144859b9c803886c6dc77",
+      "f027b4358c2c41a8a93c617641135bcd",
+      "42cb6114956c4a86980c8dafd5a734ae"
+     ]
+    },
+    "id": "5a10cc4b-07ec-4ebd-ac1d-7c601023594f",
+    "outputId": "163d4b39-7e5d-4126-8d78-846c5d94dca6"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import WhisperForConditionalGeneration, BitsAndBytesConfig\n",
+    "\n",
+    "model = WhisperForConditionalGeneration.from_pretrained(model_name_or_path, quantization_config=BitsAndBytesConfig(load_in_8bit=True))\n",
+    "\n",
+    "# model.hf_device_map - this should be {\" \": 0}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a15ead5f-2277-4a39-937b-585c2497b2df",
+   "metadata": {
+    "id": "a15ead5f-2277-4a39-937b-585c2497b2df"
+   },
+   "source": [
+    "Override generation arguments - no tokens are forced as decoder outputs (see [`forced_decoder_ids`](https://huggingface.co/docs/transformers/main_classes/text_generation#transformers.generation_utils.GenerationMixin.generate.forced_decoder_ids)), no tokens are suppressed during generation (see [`suppress_tokens`](https://huggingface.co/docs/transformers/main_classes/text_generation#transformers.generation_utils.GenerationMixin.generate.suppress_tokens)):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "62038ba3-88ed-4fce-84db-338f50dcd04f",
+   "metadata": {
+    "id": "62038ba3-88ed-4fce-84db-338f50dcd04f"
+   },
+   "outputs": [],
+   "source": [
+    "model.config.forced_decoder_ids = None\n",
+    "model.config.suppress_tokens = []"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "bR-_yaEOPsfQ",
+   "metadata": {
+    "id": "bR-_yaEOPsfQ"
+   },
+   "source": [
+    "### Post-processing on the model\n",
+    "\n",
+    "Finally, we need to apply some post-processing on the 8-bit model to enable training, let's freeze all our layers, and cast all non `int8` layers in `float32` for stability."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "Cl_ZQualPt9R",
+   "metadata": {
+    "id": "Cl_ZQualPt9R"
+   },
+   "outputs": [],
+   "source": [
+    "from peft import prepare_model_for_kbit_training\n",
+    "\n",
+    "model = prepare_model_for_kbit_training(model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "Vjl4j4RJPmPR",
+   "metadata": {
+    "id": "Vjl4j4RJPmPR"
+   },
+   "source": [
+    "### Apply LoRA\n",
+    "\n",
+    "Here comes the magic with `peft`! Let's load a `PeftModel` and specify that we are going to use low-rank adapters (LoRA) using `get_peft_model` utility function from `peft`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "DQtpDPRHPyOL",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "DQtpDPRHPyOL",
+    "outputId": "1effcbde-7acc-4f62-f24b-e6236a43f833"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "trainable params: 15728640 || all params: 1559033600 || trainable%: 1.0088711365810203\n"
+     ]
+    }
+   ],
+   "source": [
+    "from peft import LoraConfig, PeftModel, LoraModel, LoraConfig, get_peft_model\n",
+    "\n",
+    "config = LoraConfig(r=32, lora_alpha=64, target_modules=[\"q_proj\", \"v_proj\"], lora_dropout=0.05, bias=\"none\")\n",
+    "\n",
+    "model = get_peft_model(model, config)\n",
+    "model.print_trainable_parameters()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3906d436",
+   "metadata": {},
+   "source": [
+    "We are ONLY using **1%** of the total trainable parameters, thereby performing **Parameter-Efficient Fine-Tuning**"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2178dea4-80ca-47b6-b6ea-ba1915c90c06",
+   "metadata": {
+    "id": "2178dea4-80ca-47b6-b6ea-ba1915c90c06"
+   },
+   "source": [
+    "### Define the Training Configuration"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c21af1e9-0188-4134-ac82-defc7bdcc436",
+   "metadata": {
+    "id": "c21af1e9-0188-4134-ac82-defc7bdcc436"
+   },
+   "source": [
+    "In the final step, we define all the parameters related to training. For more detail on the training arguments, refer to the Seq2SeqTrainingArguments [docs](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.Seq2SeqTrainingArguments)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0ae3e9af-97b7-4aa0-ae85-20b23b5bcb3a",
+   "metadata": {
+    "id": "0ae3e9af-97b7-4aa0-ae85-20b23b5bcb3a"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import Seq2SeqTrainingArguments\n",
+    "\n",
+    "training_args = Seq2SeqTrainingArguments(\n",
+    "    output_dir=\"temp\",  # change to a repo name of your choice\n",
+    "    per_device_train_batch_size=8,\n",
+    "    gradient_accumulation_steps=1,  # increase by 2x for every 2x decrease in batch size\n",
+    "    learning_rate=1e-3,\n",
+    "    warmup_steps=50,\n",
+    "    num_train_epochs=3,\n",
+    "    eval_strategy=\"epoch\",\n",
+    "    fp16=True,\n",
+    "    per_device_eval_batch_size=8,\n",
+    "    generation_max_length=128,\n",
+    "    logging_steps=25,\n",
+    "    remove_unused_columns=False,  # required as the PeftModel forward doesn't have the signature of the wrapped model's forward\n",
+    "    label_names=[\"labels\"],  # same reason as above\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b3a944d8-3112-4552-82a0-be25988b3857",
+   "metadata": {
+    "id": "b3a944d8-3112-4552-82a0-be25988b3857"
+   },
+   "source": [
+    "**Few Important Notes:**\n",
+    "1. `remove_unused_columns=False` and `label_names=[\"labels\"]` are required as the PeftModel's forward doesn't have the signature of the base model's forward.\n",
+    "\n",
+    "2. INT8 training required autocasting. `predict_with_generate` can't be passed to Trainer because it internally calls transformer's `generate` without autocasting leading to errors. \n",
+    "\n",
+    "3. Because of point 2, `compute_metrics` shouldn't be passed to `Seq2SeqTrainer` as seen below. (commented out)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d546d7fe-0543-479a-b708-2ebabec19493",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "d546d7fe-0543-479a-b708-2ebabec19493",
+    "outputId": "e2fabe64-2c50-42ff-a7ca-7773813e9408"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "The model is loaded in 8-bit precision. To train this model you need to add additional modules inside the model such as adapters using `peft` library and freeze the model weights. Please check  the examples in https://github.com/huggingface/peft for more details.\n",
+      "Using cuda_amp half precision backend\n"
+     ]
+    }
+   ],
+   "source": [
+    "from transformers import Seq2SeqTrainer, TrainerCallback, TrainingArguments, TrainerState, TrainerControl\n",
+    "from transformers.trainer_utils import PREFIX_CHECKPOINT_DIR\n",
+    "\n",
+    "\n",
+    "class SavePeftModelCallback(TrainerCallback):\n",
+    "    def on_save(\n",
+    "        self,\n",
+    "        args: TrainingArguments,\n",
+    "        state: TrainerState,\n",
+    "        control: TrainerControl,\n",
+    "        **kwargs,\n",
+    "    ):\n",
+    "        checkpoint_folder = os.path.join(args.output_dir, f\"{PREFIX_CHECKPOINT_DIR}-{state.global_step}\")\n",
+    "\n",
+    "        peft_model_path = os.path.join(checkpoint_folder, \"adapter_model\")\n",
+    "        kwargs[\"model\"].save_pretrained(peft_model_path)\n",
+    "\n",
+    "        pytorch_model_path = os.path.join(checkpoint_folder, \"pytorch_model.bin\")\n",
+    "        if os.path.exists(pytorch_model_path):\n",
+    "            os.remove(pytorch_model_path)\n",
+    "        return control\n",
+    "\n",
+    "\n",
+    "trainer = Seq2SeqTrainer(\n",
+    "    args=training_args,\n",
+    "    model=model,\n",
+    "    train_dataset=common_voice[\"train\"],\n",
+    "    eval_dataset=common_voice[\"test\"],\n",
+    "    data_collator=data_collator,\n",
+    "    # compute_metrics=compute_metrics,\n",
+    "    processing_class=processor.feature_extractor,\n",
+    "    callbacks=[SavePeftModelCallback],\n",
+    ")\n",
+    "model.config.use_cache = False  # silence the warnings. Please re-enable for inference!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ee8b7b8e-1c9a-4d77-9137-1778a629e6de",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 1000
+    },
+    "id": "ee8b7b8e-1c9a-4d77-9137-1778a629e6de",
+    "outputId": "cdea5268-f33a-4d48-ea4a-a9c71576f81d"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.8/dist-packages/transformers/optimization.py:346: FutureWarning: This implementation of AdamW is deprecated and will be removed in a future version. Use the PyTorch implementation torch.optim.AdamW instead, or set `no_deprecation_warning=True` to disable this warning\n",
+      "  warnings.warn(\n",
+      "***** Running training *****\n",
+      "  Num examples = 3927\n",
+      "  Num Epochs = 3\n",
+      "  Instantaneous batch size per device = 8\n",
+      "  Total train batch size (w. parallel, distributed & accumulation) = 8\n",
+      "  Gradient Accumulation steps = 1\n",
+      "  Total optimization steps = 1473\n",
+      "  Number of trainable parameters = 15728640\n",
+      "/usr/local/lib/python3.8/dist-packages/torch/utils/checkpoint.py:31: UserWarning: None of the inputs have requires_grad=True. Gradients will be None\n",
+      "  warnings.warn(\"None of the inputs have requires_grad=True. Gradients will be None\")\n",
+      "/usr/local/lib/python3.8/dist-packages/bitsandbytes/autograd/_functions.py:298: UserWarning: MatMul8bitLt: inputs will be cast from torch.float32 to float16 during quantization\n",
+      "  warnings.warn(f\"MatMul8bitLt: inputs will be cast from {A.dtype} to float16 during quantization\")\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "    <div>\n",
+       "      \n",
+       "      <progress value='1474' max='1473' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
+       "      [1473/1473 3:20:30, Epoch 3/3]\n",
+       "    </div>\n",
+       "    <table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       " <tr style=\"text-align: left;\">\n",
+       "      <th>Epoch</th>\n",
+       "      <th>Training Loss</th>\n",
+       "      <th>Validation Loss</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <td>1</td>\n",
+       "      <td>0.255800</td>\n",
+       "      <td>0.262023</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>2</td>\n",
+       "      <td>0.166500</td>\n",
+       "      <td>0.221193</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table><p>\n",
+       "    <div>\n",
+       "      \n",
+       "      <progress value='62' max='227' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
+       "      [ 62/227 04:52 < 13:11, 0.21 it/s]\n",
+       "    </div>\n",
+       "    "
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "***** Running Evaluation *****\n",
+      "  Num examples = 1816\n",
+      "  Batch size = 8\n",
+      "Saving model checkpoint to ./whisper-small-hi/checkpoint-500\n",
+      "Trainer.model is not a `PreTrainedModel`, only saving its state dict.\n",
+      "Feature extractor saved in ./whisper-small-hi/checkpoint-500/preprocessor_config.json\n",
+      "/usr/local/lib/python3.8/dist-packages/torch/utils/checkpoint.py:31: UserWarning: None of the inputs have requires_grad=True. Gradients will be None\n",
+      "  warnings.warn(\"None of the inputs have requires_grad=True. Gradients will be None\")\n",
+      "/usr/local/lib/python3.8/dist-packages/bitsandbytes/autograd/_functions.py:298: UserWarning: MatMul8bitLt: inputs will be cast from torch.float32 to float16 during quantization\n",
+      "  warnings.warn(f\"MatMul8bitLt: inputs will be cast from {A.dtype} to float16 during quantization\")\n",
+      "***** Running Evaluation *****\n",
+      "  Num examples = 1816\n",
+      "  Batch size = 8\n",
+      "Saving model checkpoint to ./whisper-small-hi/checkpoint-1000\n",
+      "Trainer.model is not a `PreTrainedModel`, only saving its state dict.\n",
+      "Feature extractor saved in ./whisper-small-hi/checkpoint-1000/preprocessor_config.json\n",
+      "/usr/local/lib/python3.8/dist-packages/torch/utils/checkpoint.py:31: UserWarning: None of the inputs have requires_grad=True. Gradients will be None\n",
+      "  warnings.warn(\"None of the inputs have requires_grad=True. Gradients will be None\")\n",
+      "/usr/local/lib/python3.8/dist-packages/bitsandbytes/autograd/_functions.py:298: UserWarning: MatMul8bitLt: inputs will be cast from torch.float32 to float16 during quantization\n",
+      "  warnings.warn(f\"MatMul8bitLt: inputs will be cast from {A.dtype} to float16 during quantization\")\n",
+      "***** Running Evaluation *****\n",
+      "  Num examples = 1816\n",
+      "  Batch size = 8\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "    <div>\n",
+       "      \n",
+       "      <progress value='1473' max='1473' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
+       "      [1473/1473 3:38:43, Epoch 3/3]\n",
+       "    </div>\n",
+       "    <table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       " <tr style=\"text-align: left;\">\n",
+       "      <th>Epoch</th>\n",
+       "      <th>Training Loss</th>\n",
+       "      <th>Validation Loss</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <td>1</td>\n",
+       "      <td>0.255800</td>\n",
+       "      <td>0.262023</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>2</td>\n",
+       "      <td>0.166500</td>\n",
+       "      <td>0.221193</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <td>3</td>\n",
+       "      <td>0.083900</td>\n",
+       "      <td>0.215908</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table><p>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "Training completed. Do not forget to share your model on huggingface.co/models =)\n",
+      "\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "TrainOutput(global_step=1473, training_loss=0.20080567288382556, metrics={'train_runtime': 13136.6638, 'train_samples_per_second': 0.897, 'train_steps_per_second': 0.112, 'total_flos': 2.52799085113344e+19, 'train_loss': 0.20080567288382556, 'epoch': 3.0})"
+      ]
+     },
+     "execution_count": 36,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0576aa2a",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 116,
+     "referenced_widgets": [
+      "f309d7a096df4f119e6e6871b56913f1",
+      "5f283548f34848af90affe55a169b5a9",
+      "51a4d85c08d745bda70ba0db731dca68",
+      "eb46a602b3ef484daddbcb847957c3e5",
+      "8e2e49c6046e4dc0a0a810b4e58f80cc",
+      "f3f191968f724e9bbb710b86d3657a66",
+      "d97f77f45e1e400494c2fbf2cd9d69a3",
+      "10e52425e59d4c2c8d2a1239b24e5a95",
+      "9ca0667998cb443d9df29fdd09cf90ff",
+      "f22aa0a93d8b44d0a4c412343ec1f48b",
+      "6e6a59f8e7454c2d886634eade47a21f",
+      "92ae14b97e814d51b016e2a14f227a15",
+      "fb8aca596a1c4ac4a7428248b6c6f8b1",
+      "31de6bfcde21400ab02af4fb31d409da",
+      "3c45a19fdf664b92a27be16abf537a03",
+      "9827e382bf3b49b092969d5656dcad7a",
+      "168e19229aa5404bb151e4547bb31283",
+      "d140f5373bf144d1ae5d282e1a65647e",
+      "fa137c931d2c4e579c27893ca8ee1848",
+      "93647f2d98a74109bfc5ca7a9cc23eed",
+      "a478b23c34654615aad4202b8c7089f6",
+      "4553ba4c0ed645dbb9ddfcc88975ab5f"
+     ]
+    },
+    "id": "0576aa2a",
+    "outputId": "6d3fe4aa-f42a-4428-e070-2272f3b87f5c"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Uploading the following files to smangrul/openai-whisper-large-v2-LORA-colab: adapter_model.bin,adapter_config.json\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f309d7a096df4f119e6e6871b56913f1",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Upload 1 LFS files:   0%|          | 0/1 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "92ae14b97e814d51b016e2a14f227a15",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "adapter_model.bin:   0%|          | 0.00/63.1M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "smangrul/openai-whisper-large-v2-LORA-colab\n"
+     ]
+    }
+   ],
+   "source": [
+    "model_name_or_path = \"openai/whisper-large-v2\"\n",
+    "peft_model_id = \"smangrul/\" + f\"{model_name_or_path}-{model.peft_config['default'].peft_type.value}-colab\".replace(\"/\", \"-\")\n",
+    "model.push_to_hub(peft_model_id)\n",
+    "print(peft_model_id)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "SlyyOGnPgi_I",
+   "metadata": {
+    "id": "SlyyOGnPgi_I"
+   },
+   "source": [
+    "# Evaluation and Inference"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "Kzfg2qoXgrhg",
+   "metadata": {
+    "id": "Kzfg2qoXgrhg"
+   },
+   "source": [
+    "**Important points to note while inferencing**:\n",
+    "1. As `predict_with_generate` can't be used, we will write the eval loop with `torch.cuda.amp.autocast()` as shown below. \n",
+    "2. As the base model is frozen, PEFT model sometimes fails ot recognise the language while decoding.Hence, we force the starting tokens to mention the language we are transcribing. This is done via `forced_decoder_ids = processor.get_decoder_prompt_ids(language=\"Marathi\", task=\"transcribe\")` and passing that to the `model.generate` call.\n",
+    "3. Please note that [AutoEvaluate Leaderboard](https://huggingface.co/spaces/autoevaluate/leaderboards?dataset=mozilla-foundation%2Fcommon_voice_11_0&only_verified=0&task=automatic-speech-recognition&config=mr&split=test&metric=wer) for `mr` language on `common_voice_11_0` has a bug wherein openai's `BasicTextNormalizer` normalizer is used while evaluation leading to degerated output text, an example is shown below:\n",
+    "```\n",
+    "without normalizer: 'स्विच्चान नरुवित्तीची पद्दत मोठ्या प्रमाणात आमलात आणल्या बसोन या दुपन्याने अनेक राथ प्रवेश केला आहे.'\n",
+    "with normalizer: 'स व च च न नर व त त च पद दत म ठ य प रम ण त आमल त आणल य बस न य द पन य न अन क र थ प रव श क ल आह'\n",
+    "```\n",
+    "Post fixing this bug, we report the 2 metrics for the top model of the leaderboard and the PEFT model:\n",
+    "1. `wer`: `wer` without using the `BasicTextNormalizer` as it doesn't cater to most indic languages. This is want we consider as true performance metric.\n",
+    "2. `normalized_wer`: `wer` using the `BasicTextNormalizer` to be comparable to the leaderboard metrics.\n",
+    "Below are the results:\n",
+    "\n",
+    "| Model          | DrishtiSharma/whisper-large-v2-marathi | smangrul/openai-whisper-large-v2-LORA-colab |\n",
+    "|----------------|----------------------------------------|---------------------------------------------|\n",
+    "| wer            | 35.6457                                | 36.1356                                     |\n",
+    "| normalized_wer | 13.6440                                | 14.0165                                     |\n",
+    "\n",
+    "We see that PEFT model's performance is comparable to the fully fine-tuned model on the top of the leaderboard. At the same time, we are able to train the large model in Colab notebook with limited GPU memory and the added advantage of resulting checkpoint being jsut `63` MB.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "273a996c",
+   "metadata": {
+    "id": "273a996c"
+   },
+   "outputs": [],
+   "source": [
+    "from peft import PeftModel, PeftConfig\n",
+    "from transformers import WhisperForConditionalGeneration, Seq2SeqTrainer\n",
+    "\n",
+    "peft_model_id = \"smangrul/openai-whisper-large-v2-LORA-colab\"\n",
+    "peft_config = PeftConfig.from_pretrained(peft_model_id)\n",
+    "model = WhisperForConditionalGeneration.from_pretrained(\n",
+    "    peft_config.base_model_name_or_path, quantization_config=BitsAndBytesConfig(load_in_8bit=True), device_map=\"auto\"\n",
+    ")\n",
+    "model = PeftModel.from_pretrained(model, peft_model_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "401ceaa6",
+   "metadata": {
+    "id": "401ceaa6"
+   },
+   "outputs": [],
+   "source": [
+    "from torch.utils.data import DataLoader\n",
+    "from tqdm import tqdm\n",
+    "import numpy as np\n",
+    "import gc\n",
+    "\n",
+    "device_type = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "eval_dataloader = DataLoader(common_voice[\"test\"], batch_size=8, collate_fn=data_collator)\n",
+    "\n",
+    "model.eval()\n",
+    "for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+    "    with torch.amp.autocast(device_type=device_type):\n",
+    "        with torch.no_grad():\n",
+    "            generated_tokens = (\n",
+    "                model.generate(\n",
+    "                    input_features=batch[\"input_features\"].to(model.device),\n",
+    "                    decoder_input_ids=batch[\"labels\"][:, :4].to(model.device),\n",
+    "                    max_new_tokens=255,\n",
+    "                )\n",
+    "                .cpu()\n",
+    "                .numpy()\n",
+    "            )\n",
+    "            labels = batch[\"labels\"].cpu().numpy()\n",
+    "            labels = np.where(labels != -100, labels, tokenizer.pad_token_id)\n",
+    "            decoded_preds = tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)\n",
+    "            decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True)\n",
+    "            metric.add_batch(\n",
+    "                predictions=decoded_preds,\n",
+    "                references=decoded_labels,\n",
+    "            )\n",
+    "    del generated_tokens, labels, batch\n",
+    "    gc.collect()\n",
+    "wer = 100 * metric.compute()\n",
+    "print(f\"{wer=}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8ZN4pTangw98",
+   "metadata": {
+    "id": "8ZN4pTangw98"
+   },
+   "source": [
+    "## Using AutomaticSpeechRecognitionPipeline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "hpDx1AOCgwuk",
+   "metadata": {
+    "id": "hpDx1AOCgwuk"
+   },
+   "source": [
+    "**Few important notes:**\n",
+    "1. `pipe()` should be in the autocast context manager `with torch.cuda.amp.autocast():`\n",
+    "2. `forced_decoder_ids` specifying the `language` being transcribed should be provided in `generate_kwargs` dict.\n",
+    "3. You will get warning along the below lines which is **safe to ignore**.\n",
+    "```\n",
+    "The model 'PeftModel' is not supported for . Supported models are ['SpeechEncoderDecoderModel', 'Speech2TextForConditionalGeneration', 'SpeechT5ForSpeechToText', 'WhisperForConditionalGeneration', 'Data2VecAudioForCTC', 'HubertForCTC', 'MCTCTForCTC', 'SEWForCTC', 'SEWDForCTC', 'UniSpeechForCTC', 'UniSpeechSatForCTC', 'Wav2Vec2ForCTC', 'Wav2Vec2ConformerForCTC', 'WavLMForCTC'].\n",
+    "\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fa2b62a3",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 1000,
+     "referenced_widgets": [
+      "63d6ac9358774b269989091ca090e369",
+      "eb0d8c3f6de3468fb2b41ddf940de999",
+      "8c010800d6d945fe965fd5b9c6ab2ec4",
+      "0acd5b5ce27b4645ac9c598796fa0648",
+      "7706a602e7b64621a81777aa3229c161",
+      "3547b43905c94f479248a29b60e5a1ce",
+      "02ec476d0571401eb18332d2af3a13fd",
+      "4568923487c44041ab985ee326842d15",
+      "352a2237356846af836779413e584fee",
+      "c80954848a4a499a87708548bed8e7cc",
+      "0044d766693a47e7a2160044bf916ecd",
+      "f96c7014b47d4d048ff50d6f1f2da200",
+      "925f7aad24b547cc8071ee9bda713d7c",
+      "4043e3ceb27c435d83913b3796bd9927",
+      "b1183b9042744d3fa7437e2ec55b6cdd",
+      "20a0694ee1684ffc8289af9094e812e1",
+      "7e2534cfd8564dbd9bddaa2217f2dda4",
+      "a5bd56eb69524729afdfdd14b55b6130",
+      "d2c14b2486e24150a8242ca37f4200f4",
+      "52c3c792386c4db6a1fcd5d2bd88415b",
+      "c643b8650c31466a8614510928ab5d2e",
+      "58e46e1d355244bcab90b32c163e2877",
+      "568811a89e2a474fafe9d66bdfb4ff49",
+      "dbe19b9505884a958e832c0362d547df",
+      "4be782f67d084a6785f163126f4ef829",
+      "70222321ce9c4932b7c74055b4f773f9",
+      "c4e7cf4e42554d61aa055da47ab0ee22",
+      "6a40bc08e55a4605b478edf01ff088df",
+      "fbd304c2564e4acba84809377ba19e25",
+      "5a177ec321954dca9ae74ec30f39e2a3",
+      "3e0ce97eb4694a689316042083c0a8ef",
+      "f5ff1816a56243e4872ddfcd35331ad8",
+      "4a86fbd37d224ac488fd2c53ab02724e",
+      "74684eea520848cab51a1428823d5008",
+      "14c618afb2b6418a8b8782b102004e4c",
+      "d65e79ed6a9f4daea04e098959f12c80",
+      "71805c4082944d339a2128f7523d3f89",
+      "bb1bcdfd39bb430c8a453d7a4c3a5e3d",
+      "980e87bb43d54306aba5019964857b89",
+      "2c2b50f5cd7d4da0ac248e0ccbf13797",
+      "c89cb73d51dd457d8c17ff97e74b7ca1",
+      "921fd273a7254447a93fb997773aedab",
+      "240911ebfad1435ebd39d8942509a2b9",
+      "635164697bf74a25a8ac1af286441e3d",
+      "0e68ff83e8e64597871aa90cc871e15a",
+      "ed80930617a64700a92b3bcff97c2885",
+      "be90fac89e5243fb82389ed06d094c10",
+      "92debeaea5cc4136bb37703947e825e0",
+      "96c0b77f9a5e473b8b5dc92bde0f4a9c",
+      "0dc05bee870740ffa72af34ace8c05d9",
+      "7a8b8f2a2160441dbdc54a62de83d297",
+      "845211300fbd49f480d056bba9de83e1",
+      "df4435b0da414c3880adf33a50c465e5",
+      "7aca78c9768a48a7ab0a8220a3b364b9",
+      "7213f79093f74df996f8dbe7fe816ea0",
+      "7ace5b5107ac4e8bbdf4e3f81b73bc07",
+      "2bad57f7004f4f8fbd7e3b6c7b1d339e",
+      "5226b933249f4a48848de7e32692f463",
+      "830245f63f1947e18b29986d9a091c0a",
+      "1f995a2a5e48449b90e04c2ca9cfda18",
+      "e6dcbcdf41c34e418be0b0b86e44d3f1",
+      "812f78ca88234efa9b2ccc001245290c",
+      "bc2b317065ed4b658995663ff202108a",
+      "251c13fd793c4a6d934c14cb94f57436",
+      "b0efdb97594b4997a8cb148aa03f9a6b",
+      "66bdd68e31204abc92fafc0e29860d1c",
+      "bbc5dbbb8b3548d485b878e194683cf2",
+      "c0432026ca204c4e89721fb22589c576",
+      "c5672e82461148e29dc93af865e259ff",
+      "f8053b94954d401a85ead90319aa4690",
+      "cfee6cbc1d15435bad0bc4a193542c10",
+      "35e6c9e3c5ea47a89cd0cbebfd197bde",
+      "f81bffac74ff4b07a09760a00620610c",
+      "cb55e8ca8bf4477bb323ae45a6c60500",
+      "3e154f89e56146438bc45030e5254d8d",
+      "9abe7ed3e3d347b6bad7d1252bde226f",
+      "8ba244a082284f6dbac1c8f689c527a8",
+      "fab643980982452988a02c14132c73ca",
+      "062727d821f248c9958ecc2d79237e5b",
+      "2c264564d4c642ebb033703b1df02c69",
+      "b19431ca425341568c2b3a8556431a8f",
+      "441e89acb62e47dab61b32b5a97110f3",
+      "f93f87ef211446379963df5bbb2e4ff0",
+      "7fbb2599863f45f49ad4925d75ef5f77",
+      "06af43189ed6478b8dce4bc1cc31e657",
+      "86692318e7584e62b4143c1b2eca5935",
+      "6072c153de2540bf9e1227db5057fffc",
+      "b7d9e1bf1d2e48e59c4dca38a638d4b4",
+      "f09d5d5e7faf48f5adbaa90cbcf55162",
+      "3ff0c6a4f4fc4b72a5163a7da50af4da",
+      "e1fef249d35d482681cd39eefb7e0d7e",
+      "0a8ca977f9db4d7794dcbcaca3c5cb96",
+      "e7be6d842a0c4ba485dfa8e58338eed4",
+      "04d485813a344bf5922a2f3891f0b6e8",
+      "c78544f32b564ba6832120b3167a2162",
+      "54af0365067b498d86d23c453c5e38f1",
+      "ab4ae16fa4f448838f677ea60523c905",
+      "d92259acf9704ef9be6eced8a5f25dab",
+      "ef01f9efbfb749a3999c5b89ba0ee370",
+      "78d28e020ff048a1aa05818ea778056a",
+      "204e994a8270488a97ec2114d8ac01f6",
+      "b3a59b83acaa4864be23e10d90560139",
+      "106c4e8e31f3406f9165717c8e92003e",
+      "36ddd7c4059a4b49ab7036cb9d945b43",
+      "3b80c40ea02149989fc7042362ec452c",
+      "590ffe12145e435f97b7dcff5ebf5bcd",
+      "7b8266519f0a41cd9a065b9e795d7e84",
+      "658361b3d5054f44a5c21df747537bdd",
+      "83a7cd2ce4074720acc6236aaf24014d",
+      "50cf6847ada943729e253ca09ee7832c",
+      "1f0004d38afb4635978a8ff5a654e67d",
+      "04894f85598647b08405fae8d4ca0421",
+      "8b9324f5c0e24576a9733f30a8945edd",
+      "e166fb45a33c495e9428bcdef8cd8813",
+      "05f032a5fed940bd9e08425cf15b1aea",
+      "35aab9e31bbd43dfbc64008545598fad",
+      "7847c294b90242c2bf7feb156b1c6b36",
+      "ad8b6c32caa4493ebadf7691ed1546d4",
+      "85cdb3ecd88d426a8e517b3c8c8a8307",
+      "098e92acdc444f64a031bd0daf070604",
+      "6feb1c05469b4bc8ac9c98cdf29fdd57",
+      "f9e5029c15054f5a9cbcda1ed5878995",
+      "4cc5b0a5c84e43f3bb185c63bc1f9a56",
+      "af56501692b84e718fe3e8b1e452b7c2",
+      "c6c9fa535ff4458ba966183e1489905b",
+      "b0e084a4c551427bb176061df894fdf6",
+      "243bb4a421974846bab104aec541d955",
+      "42fc47a3348f4488a03665a01af273cb",
+      "e53d35abac8241bcaf6d3b0f732d1bb9",
+      "87d251db4a6e495cb1d59d276e823bf2",
+      "56e8812fa66e40b0896a19dd3be7330c",
+      "116c89bb3a2045f28123e4f36067a7e5"
+     ]
+    },
+    "id": "fa2b62a3",
+    "outputId": "d000c2d3-af8b-4a0d-ce50-6aedb543463b"
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import gradio as gr\n",
+    "from transformers import (\n",
+    "    AutomaticSpeechRecognitionPipeline,\n",
+    "    WhisperForConditionalGeneration,\n",
+    "    WhisperTokenizer,\n",
+    "    WhisperProcessor,\n",
+    ")\n",
+    "from peft import PeftModel, PeftConfig\n",
+    "\n",
+    "\n",
+    "peft_model_id = \"smangrul/openai-whisper-large-v2-LORA-colab\"\n",
+    "language = \"Marathi\"\n",
+    "task = \"transcribe\"\n",
+    "peft_config = PeftConfig.from_pretrained(peft_model_id)\n",
+    "model = WhisperForConditionalGeneration.from_pretrained(\n",
+    "    peft_config.base_model_name_or_path, quantization_config=BitsAndBytesConfig(load_in_8bit=True), device_map=\"auto\"\n",
+    ")\n",
+    "\n",
+    "model = PeftModel.from_pretrained(model, peft_model_id)\n",
+    "tokenizer = WhisperTokenizer.from_pretrained(peft_config.base_model_name_or_path, language=language, task=task)\n",
+    "processor = WhisperProcessor.from_pretrained(peft_config.base_model_name_or_path, language=language, task=task)\n",
+    "feature_extractor = processor.feature_extractor\n",
+    "forced_decoder_ids = processor.get_decoder_prompt_ids(language=language, task=task)\n",
+    "pipe = AutomaticSpeechRecognitionPipeline(model=model, tokenizer=tokenizer, feature_extractor=feature_extractor)\n",
+    "\n",
+    "\n",
+    "def transcribe(audio):\n",
+    "    with torch.cuda.amp.autocast():\n",
+    "        text = pipe(audio, generate_kwargs={\"forced_decoder_ids\": forced_decoder_ids}, max_new_tokens=255)[\"text\"]\n",
+    "    return text\n",
+    "\n",
+    "\n",
+    "iface = gr.Interface(\n",
+    "    fn=transcribe,\n",
+    "    inputs=gr.Audio(source=\"microphone\", type=\"filepath\"),\n",
+    "    outputs=\"text\",\n",
+    "    title=\"PEFT LoRA + INT8 Whisper Large V2 Marathi\",\n",
+    "    description=\"Realtime demo for Marathi speech recognition using `PEFT-LoRA+INT8` fine-tuned Whisper Large V2 model.\",\n",
+    ")\n",
+    "\n",
+    "iface.launch(share=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "XNn49f3BiLXa",
+   "metadata": {
+    "id": "XNn49f3BiLXa"
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "provenance": []
+  },
+  "gpuClass": "standard",
+  "kernelspec": {
+   "display_name": "Python 3.10.11 ('accelerate': conda)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.11"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "1219a10c7def3e2ad4f431cfa6f49d569fcc5949850132f23800e792129eefbb"
+   }
+  },
+  "widgets": {
+   "application/vnd.jupyter.widget-state+json": {
+    "00071f8cf276478fb2740684552f1275": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "003227997471488dae9ae26dcbff89ea": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0044d766693a47e7a2160044bf916ecd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "00819c11ea23467689e78a00d89d1b09": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_ee1ae17fdf4143ae8125ce5e2a7e9066",
+      "placeholder": "​",
+      "style": "IPY_MODEL_481ebdff3ccc40fcb7a8d848b01ae8db",
+      "value": "Downloading data: 100%"
+     }
+    },
+    "00834c084ddb4f46ac29f14575a2383d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_daee15869a92459aabcd9128526183d5",
+      "placeholder": "​",
+      "style": "IPY_MODEL_5ddd9e1a1fab4531930acaf08cc45c73",
+      "value": "Generating train split: "
+     }
+    },
+    "008bead021ea416eb31dd9143d5ae5b9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "020176f5aa0a4d489d022ef5e41ef3f6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_cbbba08d9e634560a6c0429e32166fe5",
+       "IPY_MODEL_6d9d1609edc8471dafe653e4da32eeeb",
+       "IPY_MODEL_435b5708e6cf487ebb1799c7b64a8218"
+      ],
+      "layout": "IPY_MODEL_931b96b21b39482298f40449424fdd34"
+     }
+    },
+    "0235efbdc6a74cce8050ab1116466427": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0239f7263d1a4e8b9475ae48379c068d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "info",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_0ebfa123462342e99ad81b7e5ee00eac",
+      "max": 1,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_8af6bd6e8cae4964a2e372be30220bd9",
+      "value": 1
+     }
+    },
+    "02ec476d0571401eb18332d2af3a13fd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "03f62b3f5aa64b6390b157cb3f9d2b9f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_70aa1fc14b09473e911dad3f9030b15b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_008bead021ea416eb31dd9143d5ae5b9",
+      "value": " 52.7k/52.7k [00:00&lt;00:00, 308kB/s]"
+     }
+    },
+    "03fcbc61c50c4ddc9c3684e4c085bffb": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "04144ed3ff5f423f99179702cee5343f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "04894f85598647b08405fae8d4ca0421": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_35aab9e31bbd43dfbc64008545598fad",
+      "placeholder": "​",
+      "style": "IPY_MODEL_7847c294b90242c2bf7feb156b1c6b36",
+      "value": "Downloading (…)cial_tokens_map.json: 100%"
+     }
+    },
+    "048e5c87cea34014a8f8a4538f4126bd": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "04d485813a344bf5922a2f3891f0b6e8": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "05e96819517e417aaf05f5f38c0c8b76": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "05f032a5fed940bd9e08425cf15b1aea": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "061c90e4148b43b8ba65848ca4c1ba46": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "062727d821f248c9958ecc2d79237e5b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f93f87ef211446379963df5bbb2e4ff0",
+      "placeholder": "​",
+      "style": "IPY_MODEL_7fbb2599863f45f49ad4925d75ef5f77",
+      "value": "Downloading (…)olve/main/merges.txt: 100%"
+     }
+    },
+    "0683cbffd97a4b75bd5e00a05d541fef": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_bd7da2671a22431889fbfa2ae1e0fe2c",
+      "max": 82298880,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_47ee1eec97cf4af58ed4f50944386a7e",
+      "value": 82298880
+     }
+    },
+    "06af43189ed6478b8dce4bc1cc31e657": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0887c7aabbbe4d4e8fdc64d2e2657cc7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "0894264041854eea960707529f3fb8c7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "08b26adf061b48f59078bf0c0b59e643": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "09511a81a89d4754897a3507a84405be": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_65e8c45d05be4d41b136439d9785a09c",
+      "max": 908,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_1442a54fad7d44ddbafdacaf7f95279a",
+      "value": 908
+     }
+    },
+    "098e92acdc444f64a031bd0daf070604": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "09e357a7187044b0bd2b841893a2601f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "0a8ca977f9db4d7794dcbcaca3c5cb96": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d92259acf9704ef9be6eced8a5f25dab",
+      "placeholder": "​",
+      "style": "IPY_MODEL_ef01f9efbfb749a3999c5b89ba0ee370",
+      "value": " 52.7k/52.7k [00:00&lt;00:00, 905kB/s]"
+     }
+    },
+    "0acd5b5ce27b4645ac9c598796fa0648": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c80954848a4a499a87708548bed8e7cc",
+      "placeholder": "​",
+      "style": "IPY_MODEL_0044d766693a47e7a2160044bf916ecd",
+      "value": " 358/358 [00:00&lt;00:00, 8.66kB/s]"
+     }
+    },
+    "0ae5110b687440e89ebebfb847985aa1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0af935ad4f694fb48094e6a119cbcf82": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "0bb38c654e18429a8396466ebab84504": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0bd122731d674cdab803a9981eb28237": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "0cf925f582374cd197164625f0ddf27d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": "hidden",
+      "width": null
+     }
+    },
+    "0dc05bee870740ffa72af34ace8c05d9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0e68ff83e8e64597871aa90cc871e15a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_ed80930617a64700a92b3bcff97c2885",
+       "IPY_MODEL_be90fac89e5243fb82389ed06d094c10",
+       "IPY_MODEL_92debeaea5cc4136bb37703947e825e0"
+      ],
+      "layout": "IPY_MODEL_96c0b77f9a5e473b8b5dc92bde0f4a9c"
+     }
+    },
+    "0ea1f163e4174684bd6efc2e2433c1d3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_47a5e0cfb3564c16acaedb88613b9020",
+      "placeholder": "​",
+      "style": "IPY_MODEL_09e357a7187044b0bd2b841893a2601f",
+      "value": "#1: 100%"
+     }
+    },
+    "0ebfa123462342e99ad81b7e5ee00eac": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": "20px"
+     }
+    },
+    "0f534e081ec64883a5f88d06f93aeb00": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_3a94afa1e03544f68df7752a4f503fbc",
+       "IPY_MODEL_32ed17ecaf7548d5a80b27eb97cd78af",
+       "IPY_MODEL_56817cd3b11e46f187dc13e71b7ec97d"
+      ],
+      "layout": "IPY_MODEL_3d30c20af23e495999646521d39e8e66"
+     }
+    },
+    "1031dc4b5d2d45f3b14ab12dbd9bca56": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "106c4e8e31f3406f9165717c8e92003e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_83a7cd2ce4074720acc6236aaf24014d",
+      "placeholder": "​",
+      "style": "IPY_MODEL_50cf6847ada943729e253ca09ee7832c",
+      "value": " 2.11k/2.11k [00:00&lt;00:00, 67.3kB/s]"
+     }
+    },
+    "10e52425e59d4c2c8d2a1239b24e5a95": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "116c89bb3a2045f28123e4f36067a7e5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "11b9c50e720a466aa92c64b254d40778": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "12dedd9f089c42f3a8bba9adb01cf9d3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d046a46c70ea46ffbb04a3c9f55637d5",
+      "placeholder": "​",
+      "style": "IPY_MODEL_99b628071c814d88a3cd5d72e4c95f01",
+      "value": " 1963/1963 [07:01&lt;00:00,  3.77ex/s]"
+     }
+    },
+    "13d0a97497274652b081cbcefb3fd17d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "1442a54fad7d44ddbafdacaf7f95279a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "14bca5cf764d4464a186961ccc6bdb3d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "14c618afb2b6418a8b8782b102004e4c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_980e87bb43d54306aba5019964857b89",
+      "placeholder": "​",
+      "style": "IPY_MODEL_2c2b50f5cd7d4da0ac248e0ccbf13797",
+      "value": "Downloading (…)neration_config.json: 100%"
+     }
+    },
+    "14e284f308844311a9ad40415091d93f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "1571fa5d8f494704949c5809f3409fa7": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "15b5e415b62146ba96215458cf116431": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "168e19229aa5404bb151e4547bb31283": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "170ee581427d4f30925dc393d124c1be": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ButtonModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ButtonModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ButtonView",
+      "button_style": "",
+      "description": "Login",
+      "disabled": false,
+      "icon": "",
+      "layout": "IPY_MODEL_0bb38c654e18429a8396466ebab84504",
+      "style": "IPY_MODEL_1acfc4a2809e41dd995817c3526650dd",
+      "tooltip": ""
+     }
+    },
+    "1855ae0388074d08a4763b7ac76c6948": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "18dfdd09a3af49f5b17cda27872d0ba3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "19c7ea1e9364437a9c0bf6b4e645f854": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1a540a7cba794122abdb1900061479e2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "1a721ed289684104b0fbdc8147c2311b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1acfc4a2809e41dd995817c3526650dd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ButtonStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ButtonStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "button_color": null,
+      "font_weight": ""
+     }
+    },
+    "1b1dc31d9a2b4357a71119300c6d899a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1b2780d8137042449bd6779c70bf43ca": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1b8307d133bf4280845f7d3a302b3a2b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": "hidden",
+      "width": null
+     }
+    },
+    "1d4bd11921d145c7bfd1a8ce0700a666": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_003227997471488dae9ae26dcbff89ea",
+      "placeholder": "​",
+      "style": "IPY_MODEL_deb18822d58b4b60bb75460f0a5fe921",
+      "value": "Downloading extra modules: 100%"
+     }
+    },
+    "1d8636d1d1c3442fbbc2fc83cd03fa44": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "1dedb58d31dd43db96ddd7315bb7e2ee": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1e8cdf737c93431e841e129abb541e22": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "1f0004d38afb4635978a8ff5a654e67d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_04894f85598647b08405fae8d4ca0421",
+       "IPY_MODEL_8b9324f5c0e24576a9733f30a8945edd",
+       "IPY_MODEL_e166fb45a33c495e9428bcdef8cd8813"
+      ],
+      "layout": "IPY_MODEL_05f032a5fed940bd9e08425cf15b1aea"
+     }
+    },
+    "1f632bdc00e84422b64c0a4b8e238f34": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1f995a2a5e48449b90e04c2ca9cfda18": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "200bc7d8c2bc494399a4560dabd64293": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "204e994a8270488a97ec2114d8ac01f6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_3b80c40ea02149989fc7042362ec452c",
+      "placeholder": "​",
+      "style": "IPY_MODEL_590ffe12145e435f97b7dcff5ebf5bcd",
+      "value": "Downloading (…)in/added_tokens.json: 100%"
+     }
+    },
+    "20a0694ee1684ffc8289af9094e812e1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "215c3486e13343e091a26d658e1030d2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_999382fb9e764a98893bd5269261d70b",
+       "IPY_MODEL_4e9729771294424f959bbfb6bf8b60f3",
+       "IPY_MODEL_3d2249516ecd43a08b5fba53fddb32e8"
+      ],
+      "layout": "IPY_MODEL_681711ebd0c64a63bee6b5337ef401db"
+     }
+    },
+    "21bc84c704874455a57c47239984d28d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "21ca204b93994e8790c9eb7b0722761f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "21ce216193f346c09a04a1d64bc0cd8a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "21dcf39a421847a78ea685eec0983fc6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "23ee9c5c18c64305adc55ee218afd7a9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "240911ebfad1435ebd39d8942509a2b9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "24191f38e3654b86a5da3576615e2229": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "243bb4a421974846bab104aec541d955": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2452ab9f6f974d1d831f7c81e884d00e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "251c13fd793c4a6d934c14cb94f57436": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "25fcd4b584a143058266f7f3a650d69a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c8ba787279ea43aa97b134c134d4f183",
+      "max": 5,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_6efc3be410ef4710a59dea8dbdabcdf3",
+      "value": 5
+     }
+    },
+    "27649a0d303643d8985caf506ef66fc3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "28279812acfb4272a1c28ed70aa1362d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "283f5528547b457698ced126c25c2a44": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2853a43036244f54b74db99311bc580d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e6cf97ef7bc541d0b9c6de206a3a45b0",
+      "max": 3439,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_a4b16b5279504dd694090798f5925d65",
+      "value": 3439
+     }
+    },
+    "2958a33cff794de1aa8128327bf405f1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "2ab45b22ce3f400a81cc451b9d7c9eb8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "2bad57f7004f4f8fbd7e3b6c7b1d339e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e6dcbcdf41c34e418be0b0b86e44d3f1",
+      "placeholder": "​",
+      "style": "IPY_MODEL_812f78ca88234efa9b2ccc001245290c",
+      "value": "Downloading (…)okenizer_config.json: 100%"
+     }
+    },
+    "2bc85a5bde9a454990d3bb7de5e3c7c1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2c264564d4c642ebb033703b1df02c69": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_06af43189ed6478b8dce4bc1cc31e657",
+      "max": 493864,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_86692318e7584e62b4143c1b2eca5935",
+      "value": 493864
+     }
+    },
+    "2c2b50f5cd7d4da0ac248e0ccbf13797": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "2c7d952f958247b681301d1c6bff4fa7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "2d667cd4bc134a44958d17ef75d86321": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8675aad817a44ab39b097ec864669833",
+      "placeholder": "​",
+      "style": "IPY_MODEL_5664e1233a904f4bb4af9c5322517fab",
+      "value": "Extracting data files: 100%"
+     }
+    },
+    "2e5c1a371742446e8bc416d4735c9ce3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_41a7cc33e0bc4bc5bc04dfc72bab7a81",
+      "placeholder": "​",
+      "style": "IPY_MODEL_28279812acfb4272a1c28ed70aa1362d",
+      "value": "Downloading data: 100%"
+     }
+    },
+    "2ef66808d51d440b9998064e212df420": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2f314258091a430095794c3fe0aea7e3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "2f3d1d2f1c92402cadc4cfa1b0094238": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "2ff541d18f5844408690be00c7259d59": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": "20px"
+     }
+    },
+    "3042d874fcf544fabc4701938bca7cf3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "308e1ee4593b454a84681bda10921207": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "30c688df949042ce89337643f6178230": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "313090dc1f034ab19d5ffc573ea1aa5c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "31de6bfcde21400ab02af4fb31d409da": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_fa137c931d2c4e579c27893ca8ee1848",
+      "max": 63056269,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_93647f2d98a74109bfc5ca7a9cc23eed",
+      "value": 63056269
+     }
+    },
+    "328f4d11886d48f49d4578e8e352097f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "32ed17ecaf7548d5a80b27eb97cd78af": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_bc9c3ba4bc6d4623a764d92890536935",
+      "max": 974011,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_719f2b2ab9eb4e348ae902d063c27e2d",
+      "value": 974011
+     }
+    },
+    "33888a5cafe6495782309dae44531dd3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "344d1cc53e28411cae839a4ebba1bf58": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6d932eadfd6a448a9a71d741bb64f428",
+      "max": 2064,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_dce0d285c7d947dfba9ee5bc1a6ebece",
+      "value": 2064
+     }
+    },
+    "3502b5f8aeab4bfd89c83b99ab308b9e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_c43169085f2949f1b8259cd0b767d121",
+       "IPY_MODEL_4903414a865c4813a9371e8b301f1af7",
+       "IPY_MODEL_ec7e7e3811e34b4a8c8cc31cd021cf20"
+      ],
+      "layout": "IPY_MODEL_a22db8523d44457bb96448d08129988f"
+     }
+    },
+    "352a2237356846af836779413e584fee": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "3545fcc1e9d7453099c4931f658e0bc8": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3547b43905c94f479248a29b60e5a1ce": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "35aab9e31bbd43dfbc64008545598fad": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "35e6c9e3c5ea47a89cd0cbebfd197bde": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "36ddd7c4059a4b49ab7036cb9d945b43": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3785471f614f47c78e3000a303b11ca6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "383d6e891c5249b4b2fabb60d4900488": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_96266c5722f54eeeb682b2707b8025dd",
+      "max": 493864,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_f0be69583cd1410da6dbc18302d4439b",
+      "value": 493864
+     }
+    },
+    "384f4d9515d1431589a3cc934bcf5ea7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8f52bab9ebd049d6a57686d621f407ac",
+      "max": 110376960,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_2958a33cff794de1aa8128327bf405f1",
+      "value": 110376960
+     }
+    },
+    "3a083523ae604362901e4e31c39fe949": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_cdd08679c28642a184805912c07b324e",
+      "max": 60862,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_90744e5529c04f18b11e00326649abe5",
+      "value": 60862
+     }
+    },
+    "3a4965f422f14e1ca2a63e1852235507": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_e590170f306347f3a82b76a25d37b652",
+       "IPY_MODEL_384f4d9515d1431589a3cc934bcf5ea7",
+       "IPY_MODEL_edc24ce2510f45f8adde0a187016259f"
+      ],
+      "layout": "IPY_MODEL_c2c2608dd091493795d975f1a3cc3762"
+     }
+    },
+    "3a4bb5b9cf864265af8f1a0b989dff2c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3a94afa1e03544f68df7752a4f503fbc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_bafada4a1f29442296c47018dcaedb77",
+      "placeholder": "​",
+      "style": "IPY_MODEL_6cd3baac550741ba866ce2cd2dcaebdf",
+      "value": "Downloading data: 100%"
+     }
+    },
+    "3afca90970fc4925a05a9a1aa5c8d2f2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "3b80c40ea02149989fc7042362ec452c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3bd70d937e924f61b943acb0aaf15619": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b1221f4e0a57482682ea4bd6ae245da3",
+      "max": 90982400,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_64533507b97148008548e55623b6c2a3",
+      "value": 90982400
+     }
+    },
+    "3c3214f235a54864848902f7e53662db": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c24ddbaafa5f4a63b391d981a4f10354",
+      "placeholder": "​",
+      "style": "IPY_MODEL_629725dfcc684b1db1a57850c3bc7bc3",
+      "value": " 494k/494k [00:00&lt;00:00, 1.15MB/s]"
+     }
+    },
+    "3c45a19fdf664b92a27be16abf537a03": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a478b23c34654615aad4202b8c7089f6",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4553ba4c0ed645dbb9ddfcc88975ab5f",
+      "value": " 63.1M/63.1M [00:03&lt;00:00, 34.3MB/s]"
+     }
+    },
+    "3c5eb07f0bff43948ff1f283c3c56b0f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": "hidden",
+      "width": null
+     }
+    },
+    "3d2249516ecd43a08b5fba53fddb32e8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5a306409e9e045b2b936267c520f935c",
+      "placeholder": "​",
+      "style": "IPY_MODEL_9f0638198f544a3bbb31a3a78b7bd2c2",
+      "value": " 4.49k/4.49k [00:00&lt;00:00, 152kB/s]"
+     }
+    },
+    "3d30c20af23e495999646521d39e8e66": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3d4c614fb775434fb0c5b02d46246ee0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b5c8221a09df4dfdb74017d4af544b95",
+      "placeholder": "​",
+      "style": "IPY_MODEL_65e4b8dae1e4435cb7737a8d5dd13d91",
+      "value": "Downloading (…)cial_tokens_map.json: 100%"
+     }
+    },
+    "3d8f10b5726b46de934dd0f7ed7244e4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c4119f7ec7464aab90f17d022e674999",
+      "max": 1964,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_965ac01b68064dc5a9fc3bb3f244c804",
+      "value": 1964
+     }
+    },
+    "3e0ce97eb4694a689316042083c0a8ef": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "3e154f89e56146438bc45030e5254d8d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "3e5db1000a6c4871936614e712e769db": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3fd0fd7cbbef4785b360891c12017f48": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3ff0c6a4f4fc4b72a5163a7da50af4da": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_04d485813a344bf5922a2f3891f0b6e8",
+      "placeholder": "​",
+      "style": "IPY_MODEL_c78544f32b564ba6832120b3167a2162",
+      "value": "Downloading (…)main/normalizer.json: 100%"
+     }
+    },
+    "4043e3ceb27c435d83913b3796bd9927": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d2c14b2486e24150a8242ca37f4200f4",
+      "max": 1971,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_52c3c792386c4db6a1fcd5d2bd88415b",
+      "value": 1971
+     }
+    },
+    "4081e141986f4abba15477a12a752ca0": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": "20px"
+     }
+    },
+    "40aba44ef0a74c0d9a385c803c1365a6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_ae54388d78dc4b7ebd1b21860421ffe4",
+       "IPY_MODEL_bb4a47c63d254d4aa3220e85f86d37c4",
+       "IPY_MODEL_cd585c98560b42c8b4a08df5b853b23c"
+      ],
+      "layout": "IPY_MODEL_a140cd385e5a4c0a88c5562370982d2e"
+     }
+    },
+    "40f2b2ff75ca4562808fc2c7a870901e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "41187d9a120448fab6c8608f226971fa": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_1d4bd11921d145c7bfd1a8ce0700a666",
+       "IPY_MODEL_2853a43036244f54b74db99311bc580d",
+       "IPY_MODEL_d9a85d7c76b54199bbf7646448e3458c"
+      ],
+      "layout": "IPY_MODEL_b09d153958cf4a28baad268bbda78236"
+     }
+    },
+    "4184f160ab6d4f58bc921fb7ba89cf60": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "41a7cc33e0bc4bc5bc04dfc72bab7a81": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "41f65340441f419d91e1d3841921f48a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_27649a0d303643d8985caf506ef66fc3",
+      "placeholder": "​",
+      "style": "IPY_MODEL_1855ae0388074d08a4763b7ac76c6948",
+      "value": " 1816/0 [00:13&lt;00:00, 1897.64 examples/s]"
+     }
+    },
+    "41faf55c8878475f8a986b02ad73e8ce": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "42cb6114956c4a86980c8dafd5a734ae": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "42fc47a3348f4488a03665a01af273cb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "43141dcab2324fc6a12f9b8198e10154": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "435b5708e6cf487ebb1799c7b64a8218": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_46211764bc6641b4b693c16c90747021",
+      "placeholder": "​",
+      "style": "IPY_MODEL_f1884e5a392941bfa8c484496d87084c",
+      "value": " 8.30k/8.30k [00:00&lt;00:00, 400kB/s]"
+     }
+    },
+    "441820fb176048109e0f8f7e9519d735": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "441e89acb62e47dab61b32b5a97110f3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "451d3851e29e4efabbc2c235dea718da": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4522666ebbcf4647b06ce81a6316fbbb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "45478f2ce991441c8ceaef9acf745084": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4553ba4c0ed645dbb9ddfcc88975ab5f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4568923487c44041ab985ee326842d15": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4573606592ce4b2a914ed0a70b69f9af": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a05426c8e5f849b7a972dc0df3cd84ef",
+      "placeholder": "​",
+      "style": "IPY_MODEL_1e8cdf737c93431e841e129abb541e22",
+      "value": " 82.3M/82.3M [00:02&lt;00:00, 44.8MB/s]"
+     }
+    },
+    "45a85ceb24ea444ab18a6985884be966": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b16e3a75acd0403f865849f1de6ca654",
+      "placeholder": "​",
+      "style": "IPY_MODEL_78fb0d05929849ad9aa7a7ded63c7b6b",
+      "value": "Downloading data: 100%"
+     }
+    },
+    "460be80f176849e0b1241e3a4fc18b74": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "46211764bc6641b4b693c16c90747021": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4668602d021a400a8b0ec88599abc85c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e1141861d9f44d4c95313fd432795b70",
+      "max": 184990,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_6ef55b5db76d4c78854fa0c27165e480",
+      "value": 184990
+     }
+    },
+    "466eeda389c442e487742faff05eeb81": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_664ff40a4e7346869652ba3be663acf2",
+       "IPY_MODEL_3d8f10b5726b46de934dd0f7ed7244e4",
+       "IPY_MODEL_b803893882ac4358a4676964dfb3fb31"
+      ],
+      "layout": "IPY_MODEL_4ff7e3d07f6a48f8935f0f42b86fc20c"
+     }
+    },
+    "46e44f07b96d4c32bbe75bb89159f093": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "47a25de2e10d4b55a9e6827b85e49c3a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_898c7b43a5e94601bc093e0cde28c2ec",
+       "IPY_MODEL_a03430c0cdcb47bfbd2ffd754074d692",
+       "IPY_MODEL_cda6af0ca01d4053bcebe06f3c41d887"
+      ],
+      "layout": "IPY_MODEL_abe561c67f1f42b29c33d4c296221b2f"
+     }
+    },
+    "47a5e0cfb3564c16acaedb88613b9020": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "47ee1eec97cf4af58ed4f50944386a7e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "47f7ff7b213e405a822ad6fe2e5de431": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_aa7557fbffc54ed3a9c58c1531fd93f6",
+      "placeholder": "​",
+      "style": "IPY_MODEL_061c90e4148b43b8ba65848ca4c1ba46",
+      "value": "Generating validation split: "
+     }
+    },
+    "481ebdff3ccc40fcb7a8d848b01ae8db": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4880366554ad4f6687a25b5a17877dcf": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4903414a865c4813a9371e8b301f1af7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e944fa694d824042845364bdba72d642",
+      "max": 580651,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_3785471f614f47c78e3000a303b11ca6",
+      "value": 580651
+     }
+    },
+    "49545bfc91c848b8a465e13d0b45fa34": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_45a85ceb24ea444ab18a6985884be966",
+       "IPY_MODEL_ac9c1141ca7c453f84a8ab62b2de9158",
+       "IPY_MODEL_bd4e3eb14252470d9c8ac60a32948a72"
+      ],
+      "layout": "IPY_MODEL_75dfc66dab48405b85073317c8dff155"
+     }
+    },
+    "4a86fbd37d224ac488fd2c53ab02724e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4b1f4abe697948d5a1cca9b45b2a6f87": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4be782f67d084a6785f163126f4ef829": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5a177ec321954dca9ae74ec30f39e2a3",
+      "max": 6173629930,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_3e0ce97eb4694a689316042083c0a8ef",
+      "value": 6173629930
+     }
+    },
+    "4bea6b0455ae4019b33d45491dbf4584": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4cc5b0a5c84e43f3bb185c63bc1f9a56": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_243bb4a421974846bab104aec541d955",
+      "placeholder": "​",
+      "style": "IPY_MODEL_42fc47a3348f4488a03665a01af273cb",
+      "value": "Downloading (…)rocessor_config.json: 100%"
+     }
+    },
+    "4ce1e695a6ab4906ba0817005cf58d55": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "info",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4081e141986f4abba15477a12a752ca0",
+      "max": 1,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_892e150a80464f8198024587a47186ba",
+      "value": 1
+     }
+    },
+    "4d25d9919acf44a19f1b6f8fd625f808": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_b041efb27b6149fcaf206590f1c1b961",
+       "IPY_MODEL_4668602d021a400a8b0ec88599abc85c",
+       "IPY_MODEL_92d9732acb964601b27695041f9fbb72"
+      ],
+      "layout": "IPY_MODEL_c3ea17f7dd94462986d30b751664d77b"
+     }
+    },
+    "4d29aa0885214a2aa79701cc226edaef": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_1a721ed289684104b0fbdc8147c2311b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4880366554ad4f6687a25b5a17877dcf",
+      "value": "Downloading readme: 100%"
+     }
+    },
+    "4e9729771294424f959bbfb6bf8b60f3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_048e5c87cea34014a8f8a4538f4126bd",
+      "max": 4485,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_fbd27061ff114846aedc99bc2d17f7a7",
+      "value": 4485
+     }
+    },
+    "4edf0948ed1346ceba1c0148e9c6fe1c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4f167e9657274d56b8568d48262d1ee6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b0237154051343adaa076a9cc6dd711d",
+      "max": 3486,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_64756452791144859b9c803886c6dc77",
+      "value": 3486
+     }
+    },
+    "4ff7e3d07f6a48f8935f0f42b86fc20c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "50cf6847ada943729e253ca09ee7832c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "5162987085ce45d88233f34ca3a41ce0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_00819c11ea23467689e78a00d89d1b09",
+       "IPY_MODEL_65dbf3c3a80b468aa8717e97c14db6a2",
+       "IPY_MODEL_8cb910ad08024c818b99c2e30e30b039"
+      ],
+      "layout": "IPY_MODEL_0235efbdc6a74cce8050ab1116466427"
+     }
+    },
+    "51a4d85c08d745bda70ba0db731dca68": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_10e52425e59d4c2c8d2a1239b24e5a95",
+      "max": 1,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_9ca0667998cb443d9df29fdd09cf90ff",
+      "value": 1
+     }
+    },
+    "5226b933249f4a48848de7e32692f463": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_bc2b317065ed4b658995663ff202108a",
+      "max": 829,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_251c13fd793c4a6d934c14cb94f57436",
+      "value": 829
+     }
+    },
+    "52c3c792386c4db6a1fcd5d2bd88415b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "52ff6528abdd4a9e9b85f4b355b2391d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_21ce216193f346c09a04a1d64bc0cd8a",
+      "placeholder": "​",
+      "style": "IPY_MODEL_23ee9c5c18c64305adc55ee218afd7a9",
+      "value": "Downloading data: 100%"
+     }
+    },
+    "5411f018d4464e839f2fb21ad3f026aa": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_283f5528547b457698ced126c25c2a44",
+      "max": 14424,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_7c90db94a11e4a5aa432e664b2af4e7e",
+      "value": 14424
+     }
+    },
+    "54509d703b7d4416bdee59157f918396": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "54589117bf244027ba024ea85bd1fd77": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_46e44f07b96d4c32bbe75bb89159f093",
+      "placeholder": "​",
+      "style": "IPY_MODEL_90b53e96b3f04c2993969b17547ae0d5",
+      "value": "Downloading data files: 100%"
+     }
+    },
+    "54af0365067b498d86d23c453c5e38f1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "564cd321c06440e9856f10f5c40c20be": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5664e1233a904f4bb4af9c5322517fab": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "56817cd3b11e46f187dc13e71b7ec97d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5e09bdca5081429ab82b488a3e016fbf",
+      "placeholder": "​",
+      "style": "IPY_MODEL_200bc7d8c2bc494399a4560dabd64293",
+      "value": " 974k/974k [00:00&lt;00:00, 2.83MB/s]"
+     }
+    },
+    "568811a89e2a474fafe9d66bdfb4ff49": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_dbe19b9505884a958e832c0362d547df",
+       "IPY_MODEL_4be782f67d084a6785f163126f4ef829",
+       "IPY_MODEL_70222321ce9c4932b7c74055b4f773f9"
+      ],
+      "layout": "IPY_MODEL_c4e7cf4e42554d61aa055da47ab0ee22"
+     }
+    },
+    "568a85caf800461b8571e3d206854e6b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "56e8812fa66e40b0896a19dd3be7330c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "575c4d8d503244d8a9f2a5709021b5b2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "5871a46d60f14da99e4bb8ee74405319": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_1571fa5d8f494704949c5809f3409fa7",
+      "placeholder": "​",
+      "style": "IPY_MODEL_5ef218872f2646249888def0abed7149",
+      "value": "Downloading (…)main/normalizer.json: 100%"
+     }
+    },
+    "58a15b8df2d54f89828bcd205d6bf298": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6f9d8dc63c494c76b36074af773330ce",
+      "placeholder": "​",
+      "style": "IPY_MODEL_64c0bac85ee446e284ed85ec0eb5ad44",
+      "value": " 5/5 [00:09&lt;00:00,  1.95s/it]"
+     }
+    },
+    "58aba8edefa44c60818891a2651137be": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": "hidden",
+      "width": null
+     }
+    },
+    "58c3766293e64116a131357f6cc66fe5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_abc8f69eae7b46b1b430cf3b7a231b05",
+       "IPY_MODEL_979edd227f0840a4be0233082e452b5a",
+       "IPY_MODEL_12dedd9f089c42f3a8bba9adb01cf9d3"
+      ],
+      "layout": "IPY_MODEL_3042d874fcf544fabc4701938bca7cf3"
+     }
+    },
+    "58e46e1d355244bcab90b32c163e2877": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "590ffe12145e435f97b7dcff5ebf5bcd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "59657f26f4af490980b1d9bea1526e5e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "59e79d9132964429a2a2abbdf4bdbf32": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_2e5c1a371742446e8bc416d4735c9ce3",
+       "IPY_MODEL_e57b15cc74e7474083e87722d6acde47",
+       "IPY_MODEL_e899060f1edc43b980fe6f3bbe13c609"
+      ],
+      "layout": "IPY_MODEL_a6963ce72cb3425791804abf1718ba90"
+     }
+    },
+    "5a177ec321954dca9ae74ec30f39e2a3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5a306409e9e045b2b936267c520f935c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5b226e580df94448bed54b400c7a9a25": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "5b4fbd1102a84670a1eed6f3d25c0bcd": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": "hidden",
+      "width": null
+     }
+    },
+    "5b527e45d6a946b28047115fa6b5aa3a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4184f160ab6d4f58bc921fb7ba89cf60",
+      "placeholder": "​",
+      "style": "IPY_MODEL_575c4d8d503244d8a9f2a5709021b5b2",
+      "value": " 2819/0 [00:12&lt;00:00, 1797.22 examples/s]"
+     }
+    },
+    "5b7b6f08765c4c1989f945414f2c3cf4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_1031dc4b5d2d45f3b14ab12dbd9bca56",
+      "placeholder": "​",
+      "style": "IPY_MODEL_ab40616ed9b74f438e74d403f848bed4",
+      "value": " 1.04M/1.04M [00:00&lt;00:00, 2.42MB/s]"
+     }
+    },
+    "5cba5542df344d54bb80dcf7be56b2ae": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_8daed385e6564c7897fb6553669a9065",
+       "IPY_MODEL_25fcd4b584a143058266f7f3a650d69a",
+       "IPY_MODEL_58a15b8df2d54f89828bcd205d6bf298"
+      ],
+      "layout": "IPY_MODEL_8b51633b2fe5479db0fc73cd3f0ebaea"
+     }
+    },
+    "5d5ea0207c6148769ad9f15b7b3dd92d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "PasswordModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "PasswordModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "PasswordView",
+      "continuous_update": true,
+      "description": "Token:",
+      "description_tooltip": null,
+      "disabled": false,
+      "layout": "IPY_MODEL_989b3df296504f34a62d31ca0d6d88bb",
+      "placeholder": "​",
+      "style": "IPY_MODEL_e8a7a34c6fb146f0b38a40f389a617fa",
+      "value": ""
+     }
+    },
+    "5ddd9e1a1fab4531930acaf08cc45c73": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "5e09bdca5081429ab82b488a3e016fbf": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5ef218872f2646249888def0abed7149": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "5f283548f34848af90affe55a169b5a9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f3f191968f724e9bbb710b86d3657a66",
+      "placeholder": "​",
+      "style": "IPY_MODEL_d97f77f45e1e400494c2fbf2cd9d69a3",
+      "value": "Upload 1 LFS files: 100%"
+     }
+    },
+    "5fb8e97b25b44e0dae9715eeb97acc5d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7f6a466819bb45e880eb989f388a7523",
+      "placeholder": "​",
+      "style": "IPY_MODEL_d96245da43944c4b8235e0cd02c1aa4c",
+      "value": " 14.4k/14.4k [00:00&lt;00:00, 152kB/s]"
+     }
+    },
+    "6072c153de2540bf9e1227db5057fffc": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6117f9e9718c4f4388bd1feec34578b4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "621880c98245427881dd5b004b480c6a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "621f989f46f84d73b96a37c954e92b8d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "623d0c6427964291b5c74fb18bfb4ce4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "629725dfcc684b1db1a57850c3bc7bc3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "635164697bf74a25a8ac1af286441e3d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "63d6ac9358774b269989091ca090e369": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_eb0d8c3f6de3468fb2b41ddf940de999",
+       "IPY_MODEL_8c010800d6d945fe965fd5b9c6ab2ec4",
+       "IPY_MODEL_0acd5b5ce27b4645ac9c598796fa0648"
+      ],
+      "layout": "IPY_MODEL_7706a602e7b64621a81777aa3229c161"
+     }
+    },
+    "642e28d258ca4c30a5df94c5cf7e0471": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "CheckboxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "CheckboxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "CheckboxView",
+      "description": "Add token as git credential?",
+      "description_tooltip": null,
+      "disabled": false,
+      "indent": true,
+      "layout": "IPY_MODEL_960553d142c446cd8852523887a5cc04",
+      "style": "IPY_MODEL_441820fb176048109e0f8f7e9519d735",
+      "value": true
+     }
+    },
+    "64378b1064dc4036a9a4c8813013e210": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "64533507b97148008548e55623b6c2a3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "64756452791144859b9c803886c6dc77": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "64b308019fff4095ab7f1812aab4676a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_03fcbc61c50c4ddc9c3684e4c085bffb",
+      "max": 52666,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_e4234c7c29744fc4be99b8b2ebedc9d1",
+      "value": 52666
+     }
+    },
+    "64c0bac85ee446e284ed85ec0eb5ad44": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "65188c1fdba2421ba85c2cc349709600": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a235cb3d4d424efeb30901f63fc1dbe5",
+      "placeholder": "​",
+      "style": "IPY_MODEL_2452ab9f6f974d1d831f7c81e884d00e",
+      "value": "Downloading data: 100%"
+     }
+    },
+    "658361b3d5054f44a5c21df747537bdd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "65c2716dd7f14afa93d3bfaebe85c44f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "65dbf3c3a80b468aa8717e97c14db6a2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6117f9e9718c4f4388bd1feec34578b4",
+      "max": 781879,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_623d0c6427964291b5c74fb18bfb4ce4",
+      "value": 781879
+     }
+    },
+    "65e4b8dae1e4435cb7737a8d5dd13d91": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "65e8c45d05be4d41b136439d9785a09c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "664ff40a4e7346869652ba3be663acf2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_3e5db1000a6c4871936614e712e769db",
+      "placeholder": "​",
+      "style": "IPY_MODEL_21dcf39a421847a78ea685eec0983fc6",
+      "value": "#0: 100%"
+     }
+    },
+    "66bdd68e31204abc92fafc0e29860d1c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "6717b182e5674afb90006b50dea98cae": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "679fa9d2a703494dbb10fbfd19879f1a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "681711ebd0c64a63bee6b5337ef401db": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "688f552e85714fe6a5d3eda82be0106a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_328f4d11886d48f49d4578e8e352097f",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a25ef41450eb42ff9b8b618b40080ac0",
+      "value": "#0: 100%"
+     }
+    },
+    "6a2dea21e7ce4eda8953995497308327": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6a40bc08e55a4605b478edf01ff088df": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6a544d6dd5954beab32ce3089d8d2aac": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "6b0e0694d895445c9bf7c955a116953f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_621f989f46f84d73b96a37c954e92b8d",
+      "placeholder": "​",
+      "style": "IPY_MODEL_89bb7bbcaa194a23bf3d908a4782ccb8",
+      "value": " 65.5M/65.5M [00:02&lt;00:00, 32.7MB/s]"
+     }
+    },
+    "6b1cdae6f5e34d1d9a0b5e7adf5183db": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_4d29aa0885214a2aa79701cc226edaef",
+       "IPY_MODEL_5411f018d4464e839f2fb21ad3f026aa",
+       "IPY_MODEL_5fb8e97b25b44e0dae9715eeb97acc5d"
+      ],
+      "layout": "IPY_MODEL_783d4d18627646648f8c120b728babe1"
+     }
+    },
+    "6bb6737e22bd48d786b02051d077e8cc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_1f632bdc00e84422b64c0a4b8e238f34",
+      "max": 789029,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_8d50d82f9d94482c9883f99ea5c7d704",
+      "value": 789029
+     }
+    },
+    "6bc07db3471342a6bbc1b86ca734b3e6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_21bc84c704874455a57c47239984d28d",
+      "placeholder": "​",
+      "style": "IPY_MODEL_5b226e580df94448bed54b400c7a9a25",
+      "value": "Downloading (…)neration_config.json: 100%"
+     }
+    },
+    "6bdce3b33872457ea67a3a3191f438ca": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "6cd3baac550741ba866ce2cd2dcaebdf": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "6d5801774beb4b529b227ef2f098614e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6d932eadfd6a448a9a71d741bb64f428": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6d9826a5adb847e8b4cc4486a31b52ce": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6d9d1609edc8471dafe653e4da32eeeb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_ce8f306e745d4b158c58058d471de037",
+      "max": 8297,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_0bd122731d674cdab803a9981eb28237",
+      "value": 8297
+     }
+    },
+    "6dba643113a547ac9b6e121d008791d6": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": "center",
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": "flex",
+      "flex": null,
+      "flex_flow": "column",
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": "50%"
+     }
+    },
+    "6e6a59f8e7454c2d886634eade47a21f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "6ef55b5db76d4c78854fa0c27165e480": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "6efc3be410ef4710a59dea8dbdabcdf3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "6f9d8dc63c494c76b36074af773330ce": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6feb1c05469b4bc8ac9c98cdf29fdd57": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "70222321ce9c4932b7c74055b4f773f9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f5ff1816a56243e4872ddfcd35331ad8",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4a86fbd37d224ac488fd2c53ab02724e",
+      "value": " 6.17G/6.17G [00:58&lt;00:00, 173MB/s]"
+     }
+    },
+    "70aa1fc14b09473e911dad3f9030b15b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "71805c4082944d339a2128f7523d3f89": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_240911ebfad1435ebd39d8942509a2b9",
+      "placeholder": "​",
+      "style": "IPY_MODEL_635164697bf74a25a8ac1af286441e3d",
+      "value": " 3.49k/3.49k [00:00&lt;00:00, 195kB/s]"
+     }
+    },
+    "719f2b2ab9eb4e348ae902d063c27e2d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "7213f79093f74df996f8dbe7fe816ea0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "72b715be2c774235a21602b18d71e75a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7cfbb542eba34459ba64b881c1040eee",
+      "max": 2108,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_fe48e65b2371445bbb01a8d3e9af1f67",
+      "value": 2108
+     }
+    },
+    "72f8e7de2a5d4155a9e9146f12e14b19": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "730f4d93bbd94452a59de43bf3d0a266": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "735c3606df924b9297ddc05fae3e92d5": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "73bde731e20d48de8ce66b9d72fb95cb": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "73cd51c6c43b40cab25d411e7c0f6ad1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d3d7c15d53c8498e823c84fe609321dd",
+      "placeholder": "​",
+      "style": "IPY_MODEL_80de3739b91a45478cb6a00dcaeae756",
+      "value": " 5/5 [00:00&lt;00:00, 144.96it/s]"
+     }
+    },
+    "73f6e6860b64491284c9442f0deae8b6": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "746302ee5d21495db5d9a13789c5256c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_47f7ff7b213e405a822ad6fe2e5de431",
+       "IPY_MODEL_e4810a798c0f47b6b54f84ff4ffec608",
+       "IPY_MODEL_8e480fe546f24afebb1ea723bff84456"
+      ],
+      "layout": "IPY_MODEL_0cf925f582374cd197164625f0ddf27d"
+     }
+    },
+    "74684eea520848cab51a1428823d5008": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_14c618afb2b6418a8b8782b102004e4c",
+       "IPY_MODEL_d65e79ed6a9f4daea04e098959f12c80",
+       "IPY_MODEL_71805c4082944d339a2128f7523d3f89"
+      ],
+      "layout": "IPY_MODEL_bb1bcdfd39bb430c8a453d7a4c3a5e3d"
+     }
+    },
+    "74e2bcef1ce94234bbf6ba0d6488279d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "7549fd0b38364d8580f8eb1549558a33": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "75c793c91b9e4aa994c2d34ebb16f7d4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "75dfc66dab48405b85073317c8dff155": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7706a602e7b64621a81777aa3229c161": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "783d4d18627646648f8c120b728babe1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7847c294b90242c2bf7feb156b1c6b36": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "78501c2a5ac84f9ca0d20bbef340fc9f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6717b182e5674afb90006b50dea98cae",
+      "placeholder": "​",
+      "style": "IPY_MODEL_0887c7aabbbe4d4e8fdc64d2e2657cc7",
+      "value": " 2197/0 [00:01&lt;00:00, 1386.73 examples/s]"
+     }
+    },
+    "785f3df156b946449c492f1296656a70": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "786d3d34cfd24f81996797c55b10b443": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "78d28e020ff048a1aa05818ea778056a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_204e994a8270488a97ec2114d8ac01f6",
+       "IPY_MODEL_b3a59b83acaa4864be23e10d90560139",
+       "IPY_MODEL_106c4e8e31f3406f9165717c8e92003e"
+      ],
+      "layout": "IPY_MODEL_36ddd7c4059a4b49ab7036cb9d945b43"
+     }
+    },
+    "78fb0d05929849ad9aa7a7ded63c7b6b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "7935e298049f4deeaeb278ba3de92291": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "79521628c64b4d6f9f22e73749298693": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_08b26adf061b48f59078bf0c0b59e643",
+      "max": 1971,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_ef056ad59e314089a012acaa73a54e4f",
+      "value": 1971
+     }
+    },
+    "79da882ea494477a8c94fdac7acd644e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7a24ae9d13fb4e82b1993b05f8d71d11": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "7a2d45b371ba47a994e4372437f51cff": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_dec9f287435e4c6b9fb1d1ead2ded576",
+       "IPY_MODEL_db5e1bf1871546408f233f0cbc37b136",
+       "IPY_MODEL_af44aa66372a43beb9812ad9895d8d1f"
+      ],
+      "layout": "IPY_MODEL_9b427631384c47ab89ee1352c0236afd"
+     }
+    },
+    "7a8b8f2a2160441dbdc54a62de83d297": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "7aca78c9768a48a7ab0a8220a3b364b9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7ace5b5107ac4e8bbdf4e3f81b73bc07": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_2bad57f7004f4f8fbd7e3b6c7b1d339e",
+       "IPY_MODEL_5226b933249f4a48848de7e32692f463",
+       "IPY_MODEL_830245f63f1947e18b29986d9a091c0a"
+      ],
+      "layout": "IPY_MODEL_1f995a2a5e48449b90e04c2ca9cfda18"
+     }
+    },
+    "7b190bb2bd234b7997ca041baddd511f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7b70db203ee644fe81006f5d48aa426d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e5e8f119a91944f296ff821dd7ecfb1b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_568a85caf800461b8571e3d206854e6b",
+      "value": "Generating test split: "
+     }
+    },
+    "7b7986ad93f64956b8d198d2cb4acb60": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8843f70cfa1f45299a588e96e9c1159a",
+      "max": 5,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_8b2e2c650f4b4bee9e763b7c59525ec8",
+      "value": 5
+     }
+    },
+    "7b8266519f0a41cd9a065b9e795d7e84": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7c90db94a11e4a5aa432e664b2af4e7e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "7c99e16722cf4fab866732557769b921": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_00834c084ddb4f46ac29f14575a2383d",
+       "IPY_MODEL_4ce1e695a6ab4906ba0817005cf58d55",
+       "IPY_MODEL_eb03476353ef4568b94a3071918e72f2"
+      ],
+      "layout": "IPY_MODEL_1b8307d133bf4280845f7d3a302b3a2b"
+     }
+    },
+    "7cfbb542eba34459ba64b881c1040eee": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7d3d6c198e794219ab5db59f0228c8ab": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_cd9bda1053a14890ad9091c63c0a0acf",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4522666ebbcf4647b06ce81a6316fbbb",
+      "value": "<center> <img\nsrc=https://huggingface.co/front/assets/huggingface_logo-noborder.svg\nalt='Hugging Face'> <br> Copy a token from <a\nhref=\"https://huggingface.co/settings/tokens\" target=\"_blank\">your Hugging Face\ntokens page</a> and paste it below. <br> Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file. </center>"
+     }
+    },
+    "7d5ff2f1b8794bad8286e90307bd6a61": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "7e2534cfd8564dbd9bddaa2217f2dda4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7e264d54d38e4d02acfd47e4e533b49d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "7e5252f608d6468f80deb468cb2556fd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_bce6b62300d942a1ab89a6f0ceb16d30",
+       "IPY_MODEL_0239f7263d1a4e8b9475ae48379c068d",
+       "IPY_MODEL_5b527e45d6a946b28047115fa6b5aa3a"
+      ],
+      "layout": "IPY_MODEL_3c5eb07f0bff43948ff1f283c3c56b0f"
+     }
+    },
+    "7f6a466819bb45e880eb989f388a7523": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7fbb2599863f45f49ad4925d75ef5f77": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "8016eabfc7aa48c2bc0bf3a13919a675": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "80de3739b91a45478cb6a00dcaeae756": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "812f78ca88234efa9b2ccc001245290c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "82dc91c5b065459d827863699a9710e1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4b1f4abe697948d5a1cca9b45b2a6f87",
+      "max": 1036558,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_8527f474f1a549abafe9519e2b4bd338",
+      "value": 1036558
+     }
+    },
+    "830245f63f1947e18b29986d9a091c0a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b0efdb97594b4997a8cb148aa03f9a6b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_66bdd68e31204abc92fafc0e29860d1c",
+      "value": " 829/829 [00:00&lt;00:00, 42.4kB/s]"
+     }
+    },
+    "8338339ab8a242c1a485bce8558f9c39": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4bea6b0455ae4019b33d45491dbf4584",
+      "placeholder": "​",
+      "style": "IPY_MODEL_9c928a14371a4d9aa521953e287fff54",
+      "value": " 908/908 [03:07&lt;00:00,  3.87ex/s]"
+     }
+    },
+    "83a7cd2ce4074720acc6236aaf24014d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "83cb83e404a24fba8cf43610cb1696fc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_7b70db203ee644fe81006f5d48aa426d",
+       "IPY_MODEL_efd9d5724dbd435991052b4445c6970f",
+       "IPY_MODEL_41f65340441f419d91e1d3841921f48a"
+      ],
+      "layout": "IPY_MODEL_58aba8edefa44c60818891a2651137be"
+     }
+    },
+    "844caba5ebdd48189517a10705543292": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_2d667cd4bc134a44958d17ef75d86321",
+       "IPY_MODEL_acfb7b6734884939a753fc19047bb9bc",
+       "IPY_MODEL_73cd51c6c43b40cab25d411e7c0f6ad1"
+      ],
+      "layout": "IPY_MODEL_19c7ea1e9364437a9c0bf6b4e645f854"
+     }
+    },
+    "845211300fbd49f480d056bba9de83e1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "851902cb2b0e494998684409d82dafd1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8527f474f1a549abafe9519e2b4bd338": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "85509b0aafec47e5ad540abc7ae4ab7d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "85cdb3ecd88d426a8e517b3c8c8a8307": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "86692318e7584e62b4143c1b2eca5935": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "8675aad817a44ab39b097ec864669833": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "87d251db4a6e495cb1d59d276e823bf2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "8843f70cfa1f45299a588e96e9c1159a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "892e150a80464f8198024587a47186ba": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "898c7b43a5e94601bc093e0cde28c2ec": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_21ca204b93994e8790c9eb7b0722761f",
+      "placeholder": "​",
+      "style": "IPY_MODEL_f628cb62f5fa446eb608467c1ecea526",
+      "value": "Downloading data: 100%"
+     }
+    },
+    "89bb7bbcaa194a23bf3d908a4782ccb8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "89f8ede64593475da4e056e9907f370f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4edf0948ed1346ceba1c0148e9c6fe1c",
+      "placeholder": "​",
+      "style": "IPY_MODEL_40f2b2ff75ca4562808fc2c7a870901e",
+      "value": " 908/908 [03:10&lt;00:00,  4.49ex/s]"
+     }
+    },
+    "8a91574c4b6e4745b2b65885323b4d25": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "8af6bd6e8cae4964a2e372be30220bd9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "8b0dd001d5b04647b1c480aab83d03a2": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8b2e2c650f4b4bee9e763b7c59525ec8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "8b51633b2fe5479db0fc73cd3f0ebaea": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8b9324f5c0e24576a9733f30a8945edd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_ad8b6c32caa4493ebadf7691ed1546d4",
+      "max": 2064,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_85cdb3ecd88d426a8e517b3c8c8a8307",
+      "value": 2064
+     }
+    },
+    "8ba244a082284f6dbac1c8f689c527a8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "8c010800d6d945fe965fd5b9c6ab2ec4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4568923487c44041ab985ee326842d15",
+      "max": 358,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_352a2237356846af836779413e584fee",
+      "value": 358
+     }
+    },
+    "8c41e1ee1a2c49b8b3d3d320fbf26262": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "8cb910ad08024c818b99c2e30e30b039": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_14bca5cf764d4464a186961ccc6bdb3d",
+      "placeholder": "​",
+      "style": "IPY_MODEL_75c793c91b9e4aa994c2d34ebb16f7d4",
+      "value": " 782k/782k [00:00&lt;00:00, 972kB/s]"
+     }
+    },
+    "8d50d82f9d94482c9883f99ea5c7d704": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "8daed385e6564c7897fb6553669a9065": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d2c1704e34c34d12b99c31d64fce88cc",
+      "placeholder": "​",
+      "style": "IPY_MODEL_6bdce3b33872457ea67a3a3191f438ca",
+      "value": "Downloading data files: 100%"
+     }
+    },
+    "8e2e49c6046e4dc0a0a810b4e58f80cc": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8e480fe546f24afebb1ea723bff84456": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f20fc82bcbf245619ad4dec04d0f999d",
+      "placeholder": "​",
+      "style": "IPY_MODEL_8016eabfc7aa48c2bc0bf3a13919a675",
+      "value": " 1682/0 [00:14&lt;00:00, 2245.17 examples/s]"
+     }
+    },
+    "8e84abf61e3e45d58efc7ccd0bfe8d37": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8f52bab9ebd049d6a57686d621f407ac": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8f856d6bde4041149324e1f53d19c1cb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "90744e5529c04f18b11e00326649abe5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "9087be5d992c4198b3ec2c61f4021164": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_6bc07db3471342a6bbc1b86ca734b3e6",
+       "IPY_MODEL_4f167e9657274d56b8568d48262d1ee6",
+       "IPY_MODEL_b7fbaa9d4bcd40b5bcf8d1475658c5b1"
+      ],
+      "layout": "IPY_MODEL_ba21f5ddf2434cc792b70a70c8c1079e"
+     }
+    },
+    "90b53e96b3f04c2993969b17547ae0d5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "91b103ac79e641b190416acdeb55902c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "91c3b5ddf5fb4c7aa835d992b4c7b4e7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_52ff6528abdd4a9e9b85f4b355b2391d",
+       "IPY_MODEL_6bb6737e22bd48d786b02051d077e8cc",
+       "IPY_MODEL_e97a0201b81446b882ba802a5a3b00e8"
+      ],
+      "layout": "IPY_MODEL_c1a89a042b044278a8666da306e6a481"
+     }
+    },
+    "91fc5846a32f44d5bc5fa30fdcb3c638": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_daf4005d1d334608846d0fb2fe4f837a",
+       "IPY_MODEL_ba48d89cab9346ed92dc338779f9f828",
+       "IPY_MODEL_6b0e0694d895445c9bf7c955a116953f"
+      ],
+      "layout": "IPY_MODEL_ecb7ffba323743c68961e294e74b337b"
+     }
+    },
+    "9202065d8e6f425d88e4514dde70992d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_f7b4ec74e2ac45bbbf0265d0363f4d9f",
+       "IPY_MODEL_3a083523ae604362901e4e31c39fe949",
+       "IPY_MODEL_d1bc2ce48c3e481b9059e882b5102946"
+      ],
+      "layout": "IPY_MODEL_30c688df949042ce89337643f6178230"
+     }
+    },
+    "921fd273a7254447a93fb997773aedab": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "925f7aad24b547cc8071ee9bda713d7c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7e2534cfd8564dbd9bddaa2217f2dda4",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a5bd56eb69524729afdfdd14b55b6130",
+      "value": "Downloading (…)lve/main/config.json: 100%"
+     }
+    },
+    "92ae14b97e814d51b016e2a14f227a15": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_fb8aca596a1c4ac4a7428248b6c6f8b1",
+       "IPY_MODEL_31de6bfcde21400ab02af4fb31d409da",
+       "IPY_MODEL_3c45a19fdf664b92a27be16abf537a03"
+      ],
+      "layout": "IPY_MODEL_9827e382bf3b49b092969d5656dcad7a"
+     }
+    },
+    "92d9732acb964601b27695041f9fbb72": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_91b103ac79e641b190416acdeb55902c",
+      "placeholder": "​",
+      "style": "IPY_MODEL_e9e10f1e53b74509bfc9c0bf11502c5e",
+      "value": " 185k/185k [00:00&lt;00:00, 656kB/s]"
+     }
+    },
+    "92debeaea5cc4136bb37703947e825e0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7aca78c9768a48a7ab0a8220a3b364b9",
+      "placeholder": "​",
+      "style": "IPY_MODEL_7213f79093f74df996f8dbe7fe816ea0",
+      "value": " 63.1M/63.1M [00:00&lt;00:00, 108MB/s]"
+     }
+    },
+    "931b96b21b39482298f40449424fdd34": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "931fc769fbeb42bf82df6ef5f914bf48": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "93647f2d98a74109bfc5ca7a9cc23eed": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "93e2efbb5da747d4b94c916153ee9706": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "950e74921e6042868ab6b7b9070d6f69": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d5d632dd16f147e090c62aad38c45d3c",
+      "placeholder": "​",
+      "style": "IPY_MODEL_24191f38e3654b86a5da3576615e2229",
+      "value": "Downloading (…)olve/main/vocab.json: 100%"
+     }
+    },
+    "960553d142c446cd8852523887a5cc04": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "96266c5722f54eeeb682b2707b8025dd": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "965ac01b68064dc5a9fc3bb3f244c804": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "966c0400dafe4e3ea2c9baebc2e104fa": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "969e3cf7f3634c3f90b5fea38c5797ca": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "info",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_2ff541d18f5844408690be00c7259d59",
+      "max": 1,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_679fa9d2a703494dbb10fbfd19879f1a",
+      "value": 1
+     }
+    },
+    "96c0b77f9a5e473b8b5dc92bde0f4a9c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "979edd227f0840a4be0233082e452b5a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_ec6017ce2fb3431ab823bde05f977a61",
+      "max": 1963,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_1a540a7cba794122abdb1900061479e2",
+      "value": 1963
+     }
+    },
+    "980e87bb43d54306aba5019964857b89": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "9827e382bf3b49b092969d5656dcad7a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "989b3df296504f34a62d31ca0d6d88bb": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "9980bca9b1334893bf6583c325122f50": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "999382fb9e764a98893bd5269261d70b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d37791ea2b6c4152991295ca0edb0fb7",
+      "placeholder": "​",
+      "style": "IPY_MODEL_730f4d93bbd94452a59de43bf3d0a266",
+      "value": "Downloading builder script: 100%"
+     }
+    },
+    "99b628071c814d88a3cd5d72e4c95f01": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "9abe7ed3e3d347b6bad7d1252bde226f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "9afdb23ba9ee47709f194e0e92de0edf": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "9b427631384c47ab89ee1352c0236afd": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "9c928a14371a4d9aa521953e287fff54": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "9ca0667998cb443d9df29fdd09cf90ff": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "9dc736113ef6477d91aaf71c9969ca74": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e0529b81739144db8912c2d6789e729a",
+      "placeholder": "​",
+      "style": "IPY_MODEL_13d0a97497274652b081cbcefb3fd17d",
+      "value": "Downloading (…)lve/main/config.json: 100%"
+     }
+    },
+    "9f0638198f544a3bbb31a3a78b7bd2c2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "9f9e15ff2e394ee7a7776e3e7f4b7d30": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a03430c0cdcb47bfbd2ffd754074d692": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e20264d19e804f9dba3e3867ef9b31bd",
+      "max": 615674,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_43141dcab2324fc6a12f9b8198e10154",
+      "value": 615674
+     }
+    },
+    "a05426c8e5f849b7a972dc0df3cd84ef": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a140cd385e5a4c0a88c5562370982d2e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a1578c0c777f4780a3fdd1635a0909d9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_bde010029c374a0eb2bb942f380f0e8b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a91f37ce798d411ea2a33cfdb1f01251",
+      "value": " 2.06k/2.06k [00:00&lt;00:00, 75.3kB/s]"
+     }
+    },
+    "a22db8523d44457bb96448d08129988f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a235cb3d4d424efeb30901f63fc1dbe5": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a25ef41450eb42ff9b8b618b40080ac0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a26ddb684a07496da4290e3f6031b685": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "a478b23c34654615aad4202b8c7089f6": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a4b16b5279504dd694090798f5925d65": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "a5bd56eb69524729afdfdd14b55b6130": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a615446a48624d0f9a009c1f6d8b1a54": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6d9826a5adb847e8b4cc4486a31b52ce",
+      "placeholder": "​",
+      "style": "IPY_MODEL_e8b3093587e44164b0ac043414cea0fa",
+      "value": "Downloading (…)olve/main/merges.txt: 100%"
+     }
+    },
+    "a6963ce72cb3425791804abf1718ba90": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a87598d464174703b5f5a5eca23543f3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a8aac44a077040bd9f4638c0c8f7a877": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_04144ed3ff5f423f99179702cee5343f",
+      "max": 908,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_8c41e1ee1a2c49b8b3d3d320fbf26262",
+      "value": 908
+     }
+    },
+    "a91f37ce798d411ea2a33cfdb1f01251": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a9c132959dae4303bcf6015106ce3453": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "aa7557fbffc54ed3a9c58c1531fd93f6": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "aaeec2b7986d493e8d238aa14f2e5937": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ab40616ed9b74f438e74d403f848bed4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "ab4ae16fa4f448838f677ea60523c905": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "abc8f69eae7b46b1b430cf3b7a231b05": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_baa8f739bb7e402bae7ee479e282e813",
+      "placeholder": "​",
+      "style": "IPY_MODEL_54509d703b7d4416bdee59157f918396",
+      "value": "#1: 100%"
+     }
+    },
+    "abd0e7c414974e51b280a29bf978f776": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "abe561c67f1f42b29c33d4c296221b2f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ac2e1977ddaf4b948c9cc24d84c08b83": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "ac9c1141ca7c453f84a8ab62b2de9158": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_3fd0fd7cbbef4785b360891c12017f48",
+      "max": 12179,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_a9c132959dae4303bcf6015106ce3453",
+      "value": 12179
+     }
+    },
+    "acfb7b6734884939a753fc19047bb9bc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_0ae5110b687440e89ebebfb847985aa1",
+      "max": 5,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_85509b0aafec47e5ad540abc7ae4ab7d",
+      "value": 5
+     }
+    },
+    "ad8b6c32caa4493ebadf7691ed1546d4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "add0f175631742d49dd4695bc004e81a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_5871a46d60f14da99e4bb8ee74405319",
+       "IPY_MODEL_64b308019fff4095ab7f1812aab4676a",
+       "IPY_MODEL_03f62b3f5aa64b6390b157cb3f9d2b9f"
+      ],
+      "layout": "IPY_MODEL_59657f26f4af490980b1d9bea1526e5e"
+     }
+    },
+    "ae54388d78dc4b7ebd1b21860421ffe4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_fce64f5690024c698701330f0e5d039a",
+      "placeholder": "​",
+      "style": "IPY_MODEL_abd0e7c414974e51b280a29bf978f776",
+      "value": "Downloading (…)&quot;pytorch_model.bin&quot;;: 100%"
+     }
+    },
+    "af44aa66372a43beb9812ad9895d8d1f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7b190bb2bd234b7997ca041baddd511f",
+      "placeholder": "​",
+      "style": "IPY_MODEL_7549fd0b38364d8580f8eb1549558a33",
+      "value": " 5/5 [00:03&lt;00:00,  1.15it/s]"
+     }
+    },
+    "af56501692b84e718fe3e8b1e452b7c2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e53d35abac8241bcaf6d3b0f732d1bb9",
+      "max": 184990,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_87d251db4a6e495cb1d59d276e823bf2",
+      "value": 184990
+     }
+    },
+    "b0237154051343adaa076a9cc6dd711d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b041efb27b6149fcaf206590f1c1b961": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_1b1dc31d9a2b4357a71119300c6d899a",
+      "placeholder": "​",
+      "style": "IPY_MODEL_7a24ae9d13fb4e82b1993b05f8d71d11",
+      "value": "Downloading (…)rocessor_config.json: 100%"
+     }
+    },
+    "b09d153958cf4a28baad268bbda78236": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b0e084a4c551427bb176061df894fdf6": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b0efdb97594b4997a8cb148aa03f9a6b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b1183b9042744d3fa7437e2ec55b6cdd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c643b8650c31466a8614510928ab5d2e",
+      "placeholder": "​",
+      "style": "IPY_MODEL_58e46e1d355244bcab90b32c163e2877",
+      "value": " 1.97k/1.97k [00:00&lt;00:00, 31.4kB/s]"
+     }
+    },
+    "b1221f4e0a57482682ea4bd6ae245da3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b16e3a75acd0403f865849f1de6ca654": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b19431ca425341568c2b3a8556431a8f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6072c153de2540bf9e1227db5057fffc",
+      "placeholder": "​",
+      "style": "IPY_MODEL_b7d9e1bf1d2e48e59c4dca38a638d4b4",
+      "value": " 494k/494k [00:00&lt;00:00, 3.65MB/s]"
+     }
+    },
+    "b1d780c721b840d7a06661a7a5e63236": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b3a59b83acaa4864be23e10d90560139": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7b8266519f0a41cd9a065b9e795d7e84",
+      "max": 2108,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_658361b3d5054f44a5c21df747537bdd",
+      "value": 2108
+     }
+    },
+    "b5c8221a09df4dfdb74017d4af544b95": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b600ead93bbf44a3a3fe229589c63a61": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_3d4c614fb775434fb0c5b02d46246ee0",
+       "IPY_MODEL_344d1cc53e28411cae839a4ebba1bf58",
+       "IPY_MODEL_a1578c0c777f4780a3fdd1635a0909d9"
+      ],
+      "layout": "IPY_MODEL_41faf55c8878475f8a986b02ad73e8ce"
+     }
+    },
+    "b7d9e1bf1d2e48e59c4dca38a638d4b4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "b7fbaa9d4bcd40b5bcf8d1475658c5b1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f027b4358c2c41a8a93c617641135bcd",
+      "placeholder": "​",
+      "style": "IPY_MODEL_42cb6114956c4a86980c8dafd5a734ae",
+      "value": " 3.49k/3.49k [00:00&lt;00:00, 142kB/s]"
+     }
+    },
+    "b803893882ac4358a4676964dfb3fb31": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f5d7433d15de45e997d12568cac536fc",
+      "placeholder": "​",
+      "style": "IPY_MODEL_14e284f308844311a9ad40415091d93f",
+      "value": " 1964/1964 [06:56&lt;00:00,  4.82ex/s]"
+     }
+    },
+    "b8acdb71c3564972a6c8b27e964ec061": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_688f552e85714fe6a5d3eda82be0106a",
+       "IPY_MODEL_a8aac44a077040bd9f4638c0c8f7a877",
+       "IPY_MODEL_89f8ede64593475da4e056e9907f370f"
+      ],
+      "layout": "IPY_MODEL_851902cb2b0e494998684409d82dafd1"
+     }
+    },
+    "b8d3539c8a454217a3b6ffab51259054": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ba21f5ddf2434cc792b70a70c8c1079e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ba48d89cab9346ed92dc338779f9f828": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_73bde731e20d48de8ce66b9d72fb95cb",
+      "max": 65484800,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_9afdb23ba9ee47709f194e0e92de0edf",
+      "value": 65484800
+     }
+    },
+    "baa8f739bb7e402bae7ee479e282e813": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "bafada4a1f29442296c47018dcaedb77": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "bb1bcdfd39bb430c8a453d7a4c3a5e3d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "bb4a47c63d254d4aa3220e85f86d37c4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_bf7961a79c2f403a89a4fb6d4b1a02e5",
+      "max": 6173629930,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_1d8636d1d1c3442fbbc2fc83cd03fa44",
+      "value": 6173629930
+     }
+    },
+    "bbc5dbbb8b3548d485b878e194683cf2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_c0432026ca204c4e89721fb22589c576",
+       "IPY_MODEL_c5672e82461148e29dc93af865e259ff",
+       "IPY_MODEL_f8053b94954d401a85ead90319aa4690"
+      ],
+      "layout": "IPY_MODEL_cfee6cbc1d15435bad0bc4a193542c10"
+     }
+    },
+    "bc2b317065ed4b658995663ff202108a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "bc9c3ba4bc6d4623a764d92890536935": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "bce6b62300d942a1ab89a6f0ceb16d30": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_3545fcc1e9d7453099c4931f658e0bc8",
+      "placeholder": "​",
+      "style": "IPY_MODEL_2f314258091a430095794c3fe0aea7e3",
+      "value": "Generating other split: "
+     }
+    },
+    "bd4e3eb14252470d9c8ac60a32948a72": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_2ef66808d51d440b9998064e212df420",
+      "placeholder": "​",
+      "style": "IPY_MODEL_45478f2ce991441c8ceaef9acf745084",
+      "value": " 12.2k/12.2k [00:00&lt;00:00, 142kB/s]"
+     }
+    },
+    "bd7da2671a22431889fbfa2ae1e0fe2c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "bde010029c374a0eb2bb942f380f0e8b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "be90fac89e5243fb82389ed06d094c10": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_845211300fbd49f480d056bba9de83e1",
+      "max": 63056269,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_df4435b0da414c3880adf33a50c465e5",
+      "value": 63056269
+     }
+    },
+    "bed65245e7234977874d35bf78694e35": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_3a4bb5b9cf864265af8f1a0b989dff2c",
+      "max": 829,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_ac2e1977ddaf4b948c9cc24d84c08b83",
+      "value": 829
+     }
+    },
+    "bf7961a79c2f403a89a4fb6d4b1a02e5": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "bfc9036c9c5f4be7ab191b92d92f1352": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "c0432026ca204c4e89721fb22589c576": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_35e6c9e3c5ea47a89cd0cbebfd197bde",
+      "placeholder": "​",
+      "style": "IPY_MODEL_f81bffac74ff4b07a09760a00620610c",
+      "value": "Downloading (…)olve/main/vocab.json: 100%"
+     }
+    },
+    "c1a89a042b044278a8666da306e6a481": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c1f019686c564cca87c240a75ab71ad3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_54589117bf244027ba024ea85bd1fd77",
+       "IPY_MODEL_7b7986ad93f64956b8d198d2cb4acb60",
+       "IPY_MODEL_dbc1a016a69b4ad7811d2701a9520a2f"
+      ],
+      "layout": "IPY_MODEL_72f8e7de2a5d4155a9e9146f12e14b19"
+     }
+    },
+    "c24ddbaafa5f4a63b391d981a4f10354": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c28c2fc81e0e467cbc0ded0205d1ee85": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_dd339bf6baf6433e92665e30dc30b062",
+      "placeholder": "​",
+      "style": "IPY_MODEL_6a544d6dd5954beab32ce3089d8d2aac",
+      "value": " 829/829 [00:00&lt;00:00, 34.3kB/s]"
+     }
+    },
+    "c2c2608dd091493795d975f1a3cc3762": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c3ea17f7dd94462986d30b751664d77b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c4119f7ec7464aab90f17d022e674999": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c43169085f2949f1b8259cd0b767d121": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_9980bca9b1334893bf6583c325122f50",
+      "placeholder": "​",
+      "style": "IPY_MODEL_931fc769fbeb42bf82df6ef5f914bf48",
+      "value": "Downloading data: 100%"
+     }
+    },
+    "c44f472624d84e16a0f380580d36ca61": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_65188c1fdba2421ba85c2cc349709600",
+       "IPY_MODEL_0683cbffd97a4b75bd5e00a05d541fef",
+       "IPY_MODEL_4573606592ce4b2a914ed0a70b69f9af"
+      ],
+      "layout": "IPY_MODEL_efb85d003fb54f55aa4eadf2ab8b1684"
+     }
+    },
+    "c47ba0b11e074f708338863a35a78f7b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8b0dd001d5b04647b1c480aab83d03a2",
+      "placeholder": "​",
+      "style": "IPY_MODEL_0af935ad4f694fb48094e6a119cbcf82",
+      "value": "Downloading (…)in/added_tokens.json: 100%"
+     }
+    },
+    "c4cca1778f314ce582bd09b9b2494f82": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b1d780c721b840d7a06661a7a5e63236",
+      "placeholder": "​",
+      "style": "IPY_MODEL_d19402df47464044b36fb5ee4a0c1c4d",
+      "value": "Downloading data: 100%"
+     }
+    },
+    "c4e7cf4e42554d61aa055da47ab0ee22": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c5672e82461148e29dc93af865e259ff": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_cb55e8ca8bf4477bb323ae45a6c60500",
+      "max": 1036558,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_3e154f89e56146438bc45030e5254d8d",
+      "value": 1036558
+     }
+    },
+    "c60690c2aee74763bf23115553f4e640": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "VBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "VBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "VBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_7d3d6c198e794219ab5db59f0228c8ab",
+       "IPY_MODEL_5d5ea0207c6148769ad9f15b7b3dd92d",
+       "IPY_MODEL_642e28d258ca4c30a5df94c5cf7e0471",
+       "IPY_MODEL_170ee581427d4f30925dc393d124c1be",
+       "IPY_MODEL_d5d5aa24182a4e04b3fdae1ca7fad52a"
+      ],
+      "layout": "IPY_MODEL_6dba643113a547ac9b6e121d008791d6"
+     }
+    },
+    "c643b8650c31466a8614510928ab5d2e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c6c9fa535ff4458ba966183e1489905b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_56e8812fa66e40b0896a19dd3be7330c",
+      "placeholder": "​",
+      "style": "IPY_MODEL_116c89bb3a2045f28123e4f36067a7e5",
+      "value": " 185k/185k [00:00&lt;00:00, 2.18MB/s]"
+     }
+    },
+    "c7268972f75e4824893ebe7d893a18e1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7935e298049f4deeaeb278ba3de92291",
+      "placeholder": "​",
+      "style": "IPY_MODEL_3afca90970fc4925a05a9a1aa5c8d2f2",
+      "value": " 1.97k/1.97k [00:00&lt;00:00, 70.2kB/s]"
+     }
+    },
+    "c78544f32b564ba6832120b3167a2162": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "c80954848a4a499a87708548bed8e7cc": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c81c5d3a4dc5409e95a6410e67fa9857": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_33888a5cafe6495782309dae44531dd3",
+      "placeholder": "​",
+      "style": "IPY_MODEL_7d5ff2f1b8794bad8286e90307bd6a61",
+      "value": " 91.0M/91.0M [00:02&lt;00:00, 43.0MB/s]"
+     }
+    },
+    "c89cb73d51dd457d8c17ff97e74b7ca1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c8ba787279ea43aa97b134c134d4f183": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "cb55e8ca8bf4477bb323ae45a6c60500": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "cbbba08d9e634560a6c0429e32166fe5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_79da882ea494477a8c94fdac7acd644e",
+      "placeholder": "​",
+      "style": "IPY_MODEL_f14847261aa247fb9561373e0495f3e5",
+      "value": "Downloading builder script: 100%"
+     }
+    },
+    "cd585c98560b42c8b4a08df5b853b23c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_313090dc1f034ab19d5ffc573ea1aa5c",
+      "placeholder": "​",
+      "style": "IPY_MODEL_966c0400dafe4e3ea2c9baebc2e104fa",
+      "value": " 6.17G/6.17G [00:31&lt;00:00, 201MB/s]"
+     }
+    },
+    "cd9bda1053a14890ad9091c63c0a0acf": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "cda6af0ca01d4053bcebe06f3c41d887": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f773a61b1dba4e3eb0df36162efe9abc",
+      "placeholder": "​",
+      "style": "IPY_MODEL_bfc9036c9c5f4be7ab191b92d92f1352",
+      "value": " 616k/616k [00:00&lt;00:00, 1.31MB/s]"
+     }
+    },
+    "cdd08679c28642a184805912c07b324e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ce06b2a0de6c4fb8bae36bc4d7f63270": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_c4cca1778f314ce582bd09b9b2494f82",
+       "IPY_MODEL_3bd70d937e924f61b943acb0aaf15619",
+       "IPY_MODEL_c81c5d3a4dc5409e95a6410e67fa9857"
+      ],
+      "layout": "IPY_MODEL_dd02d1b31bfd4b19ad626d6691a9b293"
+     }
+    },
+    "ce8f306e745d4b158c58058d471de037": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "cfee6cbc1d15435bad0bc4a193542c10": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d046a46c70ea46ffbb04a3c9f55637d5": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d140f5373bf144d1ae5d282e1a65647e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "d19402df47464044b36fb5ee4a0c1c4d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "d1bc2ce48c3e481b9059e882b5102946": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_11b9c50e720a466aa92c64b254d40778",
+      "placeholder": "​",
+      "style": "IPY_MODEL_8f856d6bde4041149324e1f53d19c1cb",
+      "value": " 60.9k/60.9k [00:00&lt;00:00, 169kB/s]"
+     }
+    },
+    "d21cd4878c6e49d38dd3abb2e3b3f566": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_621880c98245427881dd5b004b480c6a",
+      "placeholder": "​",
+      "style": "IPY_MODEL_65c2716dd7f14afa93d3bfaebe85c44f",
+      "value": "Generating invalidated split: "
+     }
+    },
+    "d2c14b2486e24150a8242ca37f4200f4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d2c1704e34c34d12b99c31d64fce88cc": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d37791ea2b6c4152991295ca0edb0fb7": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d3d7c15d53c8498e823c84fe609321dd": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d5d5aa24182a4e04b3fdae1ca7fad52a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6d5801774beb4b529b227ef2f098614e",
+      "placeholder": "​",
+      "style": "IPY_MODEL_dfdf23cde48c421caebb573060641d6a",
+      "value": "\n<b>Pro Tip:</b> If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks. </center>"
+     }
+    },
+    "d5d632dd16f147e090c62aad38c45d3c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d65e79ed6a9f4daea04e098959f12c80": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c89cb73d51dd457d8c17ff97e74b7ca1",
+      "max": 3486,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_921fd273a7254447a93fb997773aedab",
+      "value": 3486
+     }
+    },
+    "d8c1a66480204f1095ff5f6a7dd2e477": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_9dc736113ef6477d91aaf71c9969ca74",
+       "IPY_MODEL_79521628c64b4d6f9f22e73749298693",
+       "IPY_MODEL_c7268972f75e4824893ebe7d893a18e1"
+      ],
+      "layout": "IPY_MODEL_a87598d464174703b5f5a5eca23543f3"
+     }
+    },
+    "d92259acf9704ef9be6eced8a5f25dab": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d96245da43944c4b8235e0cd02c1aa4c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "d97f77f45e1e400494c2fbf2cd9d69a3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "d9a85d7c76b54199bbf7646448e3458c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_564cd321c06440e9856f10f5c40c20be",
+      "placeholder": "​",
+      "style": "IPY_MODEL_8a91574c4b6e4745b2b65885323b4d25",
+      "value": " 3.44k/3.44k [00:00&lt;00:00, 71.6kB/s]"
+     }
+    },
+    "daee15869a92459aabcd9128526183d5": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "daf4005d1d334608846d0fb2fe4f837a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_460be80f176849e0b1241e3a4fc18b74",
+      "placeholder": "​",
+      "style": "IPY_MODEL_74e2bcef1ce94234bbf6ba0d6488279d",
+      "value": "Downloading data: 100%"
+     }
+    },
+    "db5e1bf1871546408f233f0cbc37b136": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_ed7daa32c94648d5951876229f9835b3",
+      "max": 5,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_eb883a37a9cf4945bd864decb4fc87ea",
+      "value": 5
+     }
+    },
+    "dbc1a016a69b4ad7811d2701a9520a2f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_fb9f013a6188463fad6db70702576c37",
+      "placeholder": "​",
+      "style": "IPY_MODEL_93e2efbb5da747d4b94c916153ee9706",
+      "value": " 5/5 [00:24&lt;00:00,  5.01s/it]"
+     }
+    },
+    "dbe19b9505884a958e832c0362d547df": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6a40bc08e55a4605b478edf01ff088df",
+      "placeholder": "​",
+      "style": "IPY_MODEL_fbd304c2564e4acba84809377ba19e25",
+      "value": "Downloading (…)&quot;pytorch_model.bin&quot;;: 100%"
+     }
+    },
+    "dce0d285c7d947dfba9ee5bc1a6ebece": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "dd02d1b31bfd4b19ad626d6691a9b293": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "dd339bf6baf6433e92665e30dc30b062": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "dd634585d5e64c97881b132b1d59083e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ddc2a8e8ef4d429f95081c4c5baf1fb3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "deb18822d58b4b60bb75460f0a5fe921": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "dec9f287435e4c6b9fb1d1ead2ded576": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_00071f8cf276478fb2740684552f1275",
+      "placeholder": "​",
+      "style": "IPY_MODEL_64378b1064dc4036a9a4c8813013e210",
+      "value": "Extracting data files: 100%"
+     }
+    },
+    "df4435b0da414c3880adf33a50c465e5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "dfdf23cde48c421caebb573060641d6a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "e0529b81739144db8912c2d6789e729a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e1141861d9f44d4c95313fd432795b70": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e166fb45a33c495e9428bcdef8cd8813": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_098e92acdc444f64a031bd0daf070604",
+      "placeholder": "​",
+      "style": "IPY_MODEL_6feb1c05469b4bc8ac9c98cdf29fdd57",
+      "value": " 2.06k/2.06k [00:00&lt;00:00, 70.6kB/s]"
+     }
+    },
+    "e1fef249d35d482681cd39eefb7e0d7e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_54af0365067b498d86d23c453c5e38f1",
+      "max": 52666,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_ab4ae16fa4f448838f677ea60523c905",
+      "value": 52666
+     }
+    },
+    "e20264d19e804f9dba3e3867ef9b31bd": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e213d1c919314315ada180d49e27dfb6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_0ea1f163e4174684bd6efc2e2433c1d3",
+       "IPY_MODEL_09511a81a89d4754897a3507a84405be",
+       "IPY_MODEL_8338339ab8a242c1a485bce8558f9c39"
+      ],
+      "layout": "IPY_MODEL_8e84abf61e3e45d58efc7ccd0bfe8d37"
+     }
+    },
+    "e2a8a379bd0d4cbdb22fbc3bbb4fdc7a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": "20px"
+     }
+    },
+    "e3f1244dbe2c48bc8102f958c3df6467": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e4234c7c29744fc4be99b8b2ebedc9d1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "e4810a798c0f47b6b54f84ff4ffec608": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "info",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f617d181ffdb4b1e8d81fbb393923a6e",
+      "max": 1,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_a26ddb684a07496da4290e3f6031b685",
+      "value": 1
+     }
+    },
+    "e53d35abac8241bcaf6d3b0f732d1bb9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e57b15cc74e7474083e87722d6acde47": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_451d3851e29e4efabbc2c235dea718da",
+      "max": 69713920,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_18dfdd09a3af49f5b17cda27872d0ba3",
+      "value": 69713920
+     }
+    },
+    "e590170f306347f3a82b76a25d37b652": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_1dedb58d31dd43db96ddd7315bb7e2ee",
+      "placeholder": "​",
+      "style": "IPY_MODEL_308e1ee4593b454a84681bda10921207",
+      "value": "Downloading data: 100%"
+     }
+    },
+    "e5e8f119a91944f296ff821dd7ecfb1b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e6c2dc814c324a0c8cb744ca16707479": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_a615446a48624d0f9a009c1f6d8b1a54",
+       "IPY_MODEL_383d6e891c5249b4b2fabb60d4900488",
+       "IPY_MODEL_3c3214f235a54864848902f7e53662db"
+      ],
+      "layout": "IPY_MODEL_73f6e6860b64491284c9442f0deae8b6"
+     }
+    },
+    "e6cf97ef7bc541d0b9c6de206a3a45b0": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e6dcbcdf41c34e418be0b0b86e44d3f1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e7be6d842a0c4ba485dfa8e58338eed4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e899060f1edc43b980fe6f3bbe13c609": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_aaeec2b7986d493e8d238aa14f2e5937",
+      "placeholder": "​",
+      "style": "IPY_MODEL_0894264041854eea960707529f3fb8c7",
+      "value": " 69.7M/69.7M [00:03&lt;00:00, 22.6MB/s]"
+     }
+    },
+    "e8a7a34c6fb146f0b38a40f389a617fa": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "e8b3093587e44164b0ac043414cea0fa": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "e944fa694d824042845364bdba72d642": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e97a0201b81446b882ba802a5a3b00e8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6a2dea21e7ce4eda8953995497308327",
+      "placeholder": "​",
+      "style": "IPY_MODEL_2f3d1d2f1c92402cadc4cfa1b0094238",
+      "value": " 789k/789k [00:00&lt;00:00, 1.10MB/s]"
+     }
+    },
+    "e9e10f1e53b74509bfc9c0bf11502c5e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "ea941a078b984f51b66b5f1e8f3d1d82": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "eb03476353ef4568b94a3071918e72f2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_9f9e15ff2e394ee7a7776e3e7f4b7d30",
+      "placeholder": "​",
+      "style": "IPY_MODEL_7e264d54d38e4d02acfd47e4e533b49d",
+      "value": " 2245/0 [00:15&lt;00:00, 2226.90 examples/s]"
+     }
+    },
+    "eb0d8c3f6de3468fb2b41ddf940de999": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_3547b43905c94f479248a29b60e5a1ce",
+      "placeholder": "​",
+      "style": "IPY_MODEL_02ec476d0571401eb18332d2af3a13fd",
+      "value": "Downloading (…)/adapter_config.json: 100%"
+     }
+    },
+    "eb46a602b3ef484daddbcb847957c3e5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f22aa0a93d8b44d0a4c412343ec1f48b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_6e6a59f8e7454c2d886634eade47a21f",
+      "value": " 1/1 [00:03&lt;00:00,  3.39s/it]"
+     }
+    },
+    "eb883a37a9cf4945bd864decb4fc87ea": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "ebd79e22ad4e4256a6d88883af2c1eef": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_c47ba0b11e074f708338863a35a78f7b",
+       "IPY_MODEL_72b715be2c774235a21602b18d71e75a",
+       "IPY_MODEL_ff9a0ed54bab49aca6f27bf1be66958e"
+      ],
+      "layout": "IPY_MODEL_15b5e415b62146ba96215458cf116431"
+     }
+    },
+    "ec6017ce2fb3431ab823bde05f977a61": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ec7e7e3811e34b4a8c8cc31cd021cf20": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_dd634585d5e64c97881b132b1d59083e",
+      "placeholder": "​",
+      "style": "IPY_MODEL_785f3df156b946449c492f1296656a70",
+      "value": " 581k/581k [00:00&lt;00:00, 1.91MB/s]"
+     }
+    },
+    "ecb7ffba323743c68961e294e74b337b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ed7daa32c94648d5951876229f9835b3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ed80930617a64700a92b3bcff97c2885": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_0dc05bee870740ffa72af34ace8c05d9",
+      "placeholder": "​",
+      "style": "IPY_MODEL_7a8b8f2a2160441dbdc54a62de83d297",
+      "value": "Downloading (…)&quot;adapter_model.bin&quot;;: 100%"
+     }
+    },
+    "edc24ce2510f45f8adde0a187016259f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_1b2780d8137042449bd6779c70bf43ca",
+      "placeholder": "​",
+      "style": "IPY_MODEL_ddc2a8e8ef4d429f95081c4c5baf1fb3",
+      "value": " 110M/110M [00:04&lt;00:00, 30.6MB/s]"
+     }
+    },
+    "ee1ae17fdf4143ae8125ce5e2a7e9066": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ef01f9efbfb749a3999c5b89ba0ee370": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "ef056ad59e314089a012acaa73a54e4f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "efb85d003fb54f55aa4eadf2ab8b1684": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "efd9d5724dbd435991052b4445c6970f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "info",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e2a8a379bd0d4cbdb22fbc3bbb4fdc7a",
+      "max": 1,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_2c7d952f958247b681301d1c6bff4fa7",
+      "value": 1
+     }
+    },
+    "f027b4358c2c41a8a93c617641135bcd": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f09d5d5e7faf48f5adbaa90cbcf55162": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_3ff0c6a4f4fc4b72a5163a7da50af4da",
+       "IPY_MODEL_e1fef249d35d482681cd39eefb7e0d7e",
+       "IPY_MODEL_0a8ca977f9db4d7794dcbcaca3c5cb96"
+      ],
+      "layout": "IPY_MODEL_e7be6d842a0c4ba485dfa8e58338eed4"
+     }
+    },
+    "f0be69583cd1410da6dbc18302d4439b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "f14847261aa247fb9561373e0495f3e5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "f1884e5a392941bfa8c484496d87084c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "f20fc82bcbf245619ad4dec04d0f999d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f22aa0a93d8b44d0a4c412343ec1f48b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f309d7a096df4f119e6e6871b56913f1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_5f283548f34848af90affe55a169b5a9",
+       "IPY_MODEL_51a4d85c08d745bda70ba0db731dca68",
+       "IPY_MODEL_eb46a602b3ef484daddbcb847957c3e5"
+      ],
+      "layout": "IPY_MODEL_8e2e49c6046e4dc0a0a810b4e58f80cc"
+     }
+    },
+    "f3f191968f724e9bbb710b86d3657a66": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f436e6a7d3014e2ca44c94455bfeace8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_f9d6d41ffeba43cf94ec9d7a96af6617",
+       "IPY_MODEL_bed65245e7234977874d35bf78694e35",
+       "IPY_MODEL_c28c2fc81e0e467cbc0ded0205d1ee85"
+      ],
+      "layout": "IPY_MODEL_ea941a078b984f51b66b5f1e8f3d1d82"
+     }
+    },
+    "f5d7433d15de45e997d12568cac536fc": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f5ff1816a56243e4872ddfcd35331ad8": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f617d181ffdb4b1e8d81fbb393923a6e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": "20px"
+     }
+    },
+    "f628cb62f5fa446eb608467c1ecea526": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "f773a61b1dba4e3eb0df36162efe9abc": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f7b4ec74e2ac45bbbf0265d0363f4d9f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_2bc85a5bde9a454990d3bb7de5e3c7c1",
+      "placeholder": "​",
+      "style": "IPY_MODEL_2ab45b22ce3f400a81cc451b9d7c9eb8",
+      "value": "Downloading extra modules: 100%"
+     }
+    },
+    "f8053b94954d401a85ead90319aa4690": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_9abe7ed3e3d347b6bad7d1252bde226f",
+      "placeholder": "​",
+      "style": "IPY_MODEL_8ba244a082284f6dbac1c8f689c527a8",
+      "value": " 1.04M/1.04M [00:00&lt;00:00, 5.93MB/s]"
+     }
+    },
+    "f81bffac74ff4b07a09760a00620610c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "f933fbdcc26d41b0bb294dabd0337834": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_950e74921e6042868ab6b7b9070d6f69",
+       "IPY_MODEL_82dc91c5b065459d827863699a9710e1",
+       "IPY_MODEL_5b7b6f08765c4c1989f945414f2c3cf4"
+      ],
+      "layout": "IPY_MODEL_735c3606df924b9297ddc05fae3e92d5"
+     }
+    },
+    "f93f87ef211446379963df5bbb2e4ff0": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f96c7014b47d4d048ff50d6f1f2da200": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_925f7aad24b547cc8071ee9bda713d7c",
+       "IPY_MODEL_4043e3ceb27c435d83913b3796bd9927",
+       "IPY_MODEL_b1183b9042744d3fa7437e2ec55b6cdd"
+      ],
+      "layout": "IPY_MODEL_20a0694ee1684ffc8289af9094e812e1"
+     }
+    },
+    "f9d6d41ffeba43cf94ec9d7a96af6617": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e3f1244dbe2c48bc8102f958c3df6467",
+      "placeholder": "​",
+      "style": "IPY_MODEL_786d3d34cfd24f81996797c55b10b443",
+      "value": "Downloading (…)okenizer_config.json: 100%"
+     }
+    },
+    "f9e5029c15054f5a9cbcda1ed5878995": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_4cc5b0a5c84e43f3bb185c63bc1f9a56",
+       "IPY_MODEL_af56501692b84e718fe3e8b1e452b7c2",
+       "IPY_MODEL_c6c9fa535ff4458ba966183e1489905b"
+      ],
+      "layout": "IPY_MODEL_b0e084a4c551427bb176061df894fdf6"
+     }
+    },
+    "fa137c931d2c4e579c27893ca8ee1848": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "fab643980982452988a02c14132c73ca": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_062727d821f248c9958ecc2d79237e5b",
+       "IPY_MODEL_2c264564d4c642ebb033703b1df02c69",
+       "IPY_MODEL_b19431ca425341568c2b3a8556431a8f"
+      ],
+      "layout": "IPY_MODEL_441e89acb62e47dab61b32b5a97110f3"
+     }
+    },
+    "fb8aca596a1c4ac4a7428248b6c6f8b1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_168e19229aa5404bb151e4547bb31283",
+      "placeholder": "​",
+      "style": "IPY_MODEL_d140f5373bf144d1ae5d282e1a65647e",
+      "value": "adapter_model.bin: 100%"
+     }
+    },
+    "fb9f013a6188463fad6db70702576c37": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "fbd27061ff114846aedc99bc2d17f7a7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "fbd304c2564e4acba84809377ba19e25": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "fce64f5690024c698701330f0e5d039a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "fe48e65b2371445bbb01a8d3e9af1f67": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "ff9a0ed54bab49aca6f27bf1be66958e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b8d3539c8a454217a3b6ffab51259054",
+      "placeholder": "​",
+      "style": "IPY_MODEL_05e96819517e417aaf05f5f38c0c8b76",
+      "value": " 2.11k/2.11k [00:00&lt;00:00, 124kB/s]"
+     }
+    },
+    "ffce35af1ad84a2c838cca55a26dd3c4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_d21cd4878c6e49d38dd3abb2e3b3f566",
+       "IPY_MODEL_969e3cf7f3634c3f90b5fea38c5797ca",
+       "IPY_MODEL_78501c2a5ac84f9ca0d20bbef340fc9f"
+      ],
+      "layout": "IPY_MODEL_5b4fbd1102a84670a1eed6f3d25c0bcd"
+     }
+    }
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/int8_training/requirements.txt b/examples/int8_training/requirements.txt
new file mode 100644
index 0000000..9a53baf
--- /dev/null
+++ b/examples/int8_training/requirements.txt
@@ -0,0 +1,9 @@
+accelerate
+git+https://github.com/bitsandbytes-foundation/bitsandbytes.git
+datasets==3.6.0
+evaluate
+jiwer
+librosa
+soundfile
+transformers==4.52.4
+wandb
diff --git a/examples/int8_training/run_adalora_whisper_int8.sh b/examples/int8_training/run_adalora_whisper_int8.sh
new file mode 100644
index 0000000..39bd69d
--- /dev/null
+++ b/examples/int8_training/run_adalora_whisper_int8.sh
@@ -0,0 +1,37 @@
+accelerate launch --config_file config.yaml peft_adalora_whisper_large_training.py \
+    --model_name_or_path "openai/whisper-large-v2" \
+    --language "Marathi" \
+    --language_abbr "mr" \
+    --task "transcribe" \
+    --dataset_name "mozilla-foundation/common_voice_11_0" \
+    --push_to_hub \
+    --preprocessing_num_workers 2 \
+    --per_device_train_batch_size 8 \
+    --per_device_eval_batch_size 8 \
+    --dataloader_pin_memory \
+    --dataloader_num_workers 2 \
+    --learning_rate 1e-3 \
+    --weight_decay 1e-4 \
+    --num_train_epochs 3 \
+    --gradient_accumulation_steps 1 \
+    --lr_scheduler_type "linear" \
+    --num_warmup_steps 50 \
+    --output_dir "adalora_whisper_large_marathi_multi_adapter" \
+    --seed 42 \
+    --load_best_model \
+    --with_tracking \
+    --report_to "wandb" \
+    --hub_token $HUB_TOKEN \
+    --checkpointing_steps 2000 \
+    --evaluation_steps 2000 \
+    --logging_steps 25 \
+    --use_peft \
+    --use_adalora \
+    --init_r 12 \
+    --target_r 8 \
+    --tinit 100 \
+    --tfinal 800 \
+    --delta_t 10 \
+    --lora_alpha 32 \
+    --lora_dropout 0.1 \
+    --orth_reg_weight 0.5
\ No newline at end of file
diff --git a/examples/lily_finetuning/README.md b/examples/lily_finetuning/README.md
new file mode 100644
index 0000000..988b5de
--- /dev/null
+++ b/examples/lily_finetuning/README.md
@@ -0,0 +1,90 @@
+# Lily: Low-Rank Interconnected Adaptation Across Layers
+
+## Introduction
+[**Lily**](https://arxiv.org/abs/2407.09946) is a PEFT method that introduces **cross-layer parameter sharing** to improve parameter efficiency. Unlike LoRA, which assigns independent adapter pairs to each layer, Lily shares adapter components across layers in two ways:
+
+- **A sharing**: consecutive blocks of `stride_A` layers share the same A adapter, reducing the number of distinct input projections.
+- **B sharing**: a small pool of `num_B` B adapters is shared globally across all layers. For each forward pass, a lightweight **router** computes a softmax-weighted combination of all B adapters to produce a layer-specific output projection.
+
+This design allows Lily to cover more layers with fewer parameters, making it possible to use larger rank for each adapter without increasing parameter count and enabling information sharing across layers.
+
+## Quick start
+
+With respect to your standard PEFT training procedure with LoRA, simply swap your `LoraConfig` for a `LilyConfig`.
+
+```python
+import torch
+from datasets import load_dataset
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from trl import SFTTrainer, SFTConfig
+from peft import LilyConfig
+
+model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.2-3B", dtype=torch.bfloat16, device_map="auto")
+tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-3B")
+dataset = load_dataset("timdettmers/openassistant-guanaco", split="train")
+lily_config = LilyConfig()
+
+trainer = SFTTrainer(
+    model=model,
+    train_dataset=dataset,
+    processing_class=tokenizer,
+    peft_config=lily_config,
+    args=SFTConfig(
+        max_length=2048,
+        dataset_text_field="text",
+        per_device_train_batch_size=2,
+    ),
+)
+trainer.train()
+trainer.model.save_pretrained("lily-llama-3.2-3b")
+```
+
+Run the finetuning script simply by running:
+```sh
+python examples/lily_finetuning/lily_finetuning.py --base_model meta-llama/Llama-3.2-3B --data_path timdettmers/openassistant-guanaco
+```
+
+## Use the model on 🤗
+You can load and use the model as any other 🤗 models.
+```python
+import torch
+from peft import PeftModel
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained(
+    "meta-llama/Llama-3.2-3B", dtype=torch.bfloat16, device_map="auto"
+)
+peft_model = PeftModel.from_pretrained(model, "lily-llama-3.2-3b")
+```
+
+## Additional Notes
+
+- `r` controls the rank (inner hidden dimension). Since Lily typically uses fewer adapter instances than LoRA, it is recommended to use a **larger `r`** — typically `2x`–`4x` the rank you would use in LoRA.
+- `stride_A` controls how many consecutive layers share one A adapter. Larger `stride_A` means fewer distinct A adapters and fewer trainable parameters. Suggested values: `2`, `3`, or `4`. Make sure that `total_layers` is divisible by `stride_A` to ensure even sharing.
+- `num_B` controls the size of the shared B adapter pool. It is recommended to set `num_B` to roughly `total_layers / stride_A`. Note that `num_B >= 2` is required.
+- `scaling` is a direct scalar multiplier on the adapter output (analogous to `alpha / r` in LoRA). It is recommended to start with `2.0` and treat it as a hyperparameter.
+- The general rule of thumb: **prefer larger `r` with larger `stride_A` and smaller `num_B`** over smaller `r` with smaller `stride_A` and larger `num_B`.
+
+## Citation
+```
+@inproceedings{zhong-etal-2025-low,
+    title = "Low-Rank Interconnected Adaptation across Layers",
+    author = "Zhong, Yibo  and
+      Zhao, Jinman  and
+      Zhou, Yao",
+    editor = "Che, Wanxiang  and
+      Nabende, Joyce  and
+      Shutova, Ekaterina  and
+      Pilehvar, Mohammad Taher",
+    booktitle = "Findings of the Association for Computational Linguistics: ACL 2025",
+    month = jul,
+    year = "2025",
+    address = "Vienna, Austria",
+    publisher = "Association for Computational Linguistics",
+    url = "https://aclanthology.org/2025.findings-acl.874/",
+    doi = "10.18653/v1/2025.findings-acl.874",
+    pages = "17005--17029",
+    ISBN = "979-8-89176-256-5",
+    abstract = "Low-rank adaptation (LoRA) is a widely used parameter-efficient fine-tuning (PEFT) method that learns weight updates $\Delta W = AB$ for pretrained weights $W$ through low-rank adapters $A$ and $B$. While LoRA ensures hardware efficiency, its low-rank weight updates limit adaptation performance. In this paper, we propose low-rank interconnected adaptation across layers (Lily), a novel PEFT method that introduces an interconnected framework with locally shared $A$ and globally shared $B$ experts. This structure eliminates redundant per-layer $AB$ pairs, enabling higher-rank $\Delta W$ with equal or fewer parameters. To enhance expressiveness, we use data-dependent routers to determine $A$-$B$ interconnections, preventing $B$ experts from converging to the same behavior and improving representational power across domains. Experiments across modalities, architectures, and model sizes demonstrate Lily{'}s superior performance and efficiency."
+}
+```
\ No newline at end of file
diff --git a/examples/lily_finetuning/lily_finetuning.py b/examples/lily_finetuning/lily_finetuning.py
new file mode 100644
index 0000000..4e09c2b
--- /dev/null
+++ b/examples/lily_finetuning/lily_finetuning.py
@@ -0,0 +1,190 @@
+# This script is based on examples/gralora_finetuning/gralora_finetuning.py
+import os
+
+import torch
+from datasets import load_dataset
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    DataCollatorForLanguageModeling,
+    Trainer,
+    TrainingArguments,
+)
+
+from peft import LilyConfig, get_peft_model
+
+
+def train_model(
+    base_model: str,
+    data_path: str,
+    output_dir: str,
+    batch_size: int,
+    num_epochs: int,
+    learning_rate: float,
+    cutoff_len: int,
+    val_set_size: int,
+    eval_step: int,
+    save_step: int,
+    device: str,
+    lily_r: int,
+    lily_scaling: float,
+    lily_stride_A: int,
+    lily_num_B: int,
+    lily_target_modules: str,
+    hub_model_id: str,
+    push_to_hub: bool,
+):
+    os.environ["TOKENIZERS_PARALLELISM"] = "false"
+    hf_token = os.getenv("HF_TOKEN")
+
+    # Setup device
+    if device == "auto":
+        device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+    else:
+        device = torch.device(device)
+    print(f"Using device: {device}")
+
+    # load tokenizer
+    tokenizer = AutoTokenizer.from_pretrained(base_model, token=hf_token)
+
+    model = AutoModelForCausalLM.from_pretrained(base_model, token=hf_token)
+
+    # Lily config for the PEFT model
+    lily_config = LilyConfig(
+        r=lily_r,
+        scaling=lily_scaling,
+        stride_A=lily_stride_A,
+        num_B=lily_num_B,
+        target_modules=(
+            lily_target_modules.split(",")
+            if lily_target_modules
+            else ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
+        ),
+    )
+
+    # get the peft model with Lily config
+    model = get_peft_model(model, lily_config)
+    model.print_trainable_parameters()
+
+    model.to(device)
+    tokenizer.pad_token = tokenizer.eos_token
+
+    # Load the dataset
+    dataset = load_dataset(data_path)
+
+    def tokenize_function(examples):
+        inputs = tokenizer(examples["text"], padding="max_length", truncation=True, max_length=cutoff_len)
+        inputs["labels"] = inputs["input_ids"].copy()  # setting labels for a language modeling task
+        return inputs
+
+    # Tokenize the dataset and prepare for training
+    tokenized_datasets = dataset.map(tokenize_function, batched=True, remove_columns=dataset["train"].column_names)
+
+    # Data collator to dynamically pad the batched examples
+    data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)
+
+    # Define training arguments
+    training_args = TrainingArguments(
+        output_dir=output_dir,
+        num_train_epochs=num_epochs,
+        per_device_train_batch_size=batch_size,
+        per_device_eval_batch_size=batch_size,
+        warmup_steps=100,
+        weight_decay=0.01,
+        logging_steps=eval_step,
+        save_steps=save_step,
+        save_total_limit=2,
+        push_to_hub=push_to_hub,
+        hub_model_id=hub_model_id,
+        gradient_accumulation_steps=16,
+        fp16=True,
+        learning_rate=learning_rate,
+        hub_token=hf_token,
+    )
+
+    # Clear device cache to free memory
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+    elif torch.xpu.is_available():
+        torch.xpu.empty_cache()
+
+    # Initialize the Trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=tokenized_datasets["train"],
+        eval_dataset=tokenized_datasets["test"],
+        data_collator=data_collator,
+    )
+
+    # Start model training
+    trainer.train()
+
+    # Save and push the trained model and tokenizer
+    if push_to_hub:
+        trainer.push_to_hub(commit_message="Fine-tuned model with Lily")
+
+    # Save the model and tokenizer locally
+    model.save_pretrained(output_dir)
+    tokenizer.save_pretrained(output_dir)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Fine-tune LLaMA with Lily and PEFT")
+    parser.add_argument("--base_model", type=str, default="meta-llama/Llama-3.2-3B", help="Base model path or name")
+    parser.add_argument(
+        "--data_path", type=str, default="timdettmers/openassistant-guanaco", help="Dataset path or name"
+    )
+    parser.add_argument(
+        "--output_dir", type=str, default="path/to/output", help="Output directory for the fine-tuned model"
+    )
+    parser.add_argument("--batch_size", type=int, default=1, help="Batch size")
+    parser.add_argument("--num_epochs", type=int, default=1, help="Number of training epochs")
+    parser.add_argument("--learning_rate", type=float, default=1e-4, help="Learning rate")
+    parser.add_argument("--cutoff_len", type=int, default=512, help="Cutoff length for tokenization")
+    parser.add_argument("--val_set_size", type=int, default=500, help="Validation set size")
+    parser.add_argument("--eval_step", type=int, default=10, help="Evaluation step interval")
+    parser.add_argument("--save_step", type=int, default=100, help="Save step interval")
+    parser.add_argument("--device", type=str, default="auto", help="Device to use for training")
+    parser.add_argument("--lily_r", type=int, default=32, help="Lily rank")
+    parser.add_argument(
+        "--lily_scaling", type=float, default=2.0, help="Lily scaling factor applied to adapter output"
+    )
+    parser.add_argument(
+        "--lily_stride_A", type=int, default=4, help="Number of consecutive layers sharing one A adapter"
+    )
+    parser.add_argument("--lily_num_B", type=int, default=7, help="Number of shared B adapters (must be >= 2)")
+    parser.add_argument(
+        "--lily_target_modules", type=str, default=None, help="Comma-separated list of target modules for Lily"
+    )
+    parser.add_argument(
+        "--hub_model_id",
+        type=str,
+        default="path/to/repo",
+        help="Repository name to push the model on the Hugging Face Hub",
+    )
+    parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to Hugging Face Hub")
+    args = parser.parse_args()
+
+    train_model(
+        base_model=args.base_model,
+        data_path=args.data_path,
+        output_dir=args.output_dir,
+        batch_size=args.batch_size,
+        num_epochs=args.num_epochs,
+        learning_rate=args.learning_rate,
+        cutoff_len=args.cutoff_len,
+        val_set_size=args.val_set_size,
+        eval_step=args.eval_step,
+        save_step=args.save_step,
+        device=args.device,
+        lily_r=args.lily_r,
+        lily_scaling=args.lily_scaling,
+        lily_stride_A=args.lily_stride_A,
+        lily_num_B=args.lily_num_B,
+        lily_target_modules=args.lily_target_modules,
+        hub_model_id=args.hub_model_id,
+        push_to_hub=args.push_to_hub,
+    )
diff --git a/examples/loftq_finetuning/LoftQ_weight_replacement.ipynb b/examples/loftq_finetuning/LoftQ_weight_replacement.ipynb
new file mode 100644
index 0000000..b03d852
--- /dev/null
+++ b/examples/loftq_finetuning/LoftQ_weight_replacement.ipynb
@@ -0,0 +1,801 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "546b6c6d-f949-4387-9c41-6989223911f8",
+   "metadata": {},
+   "source": [
+    "# Initializing weights with LoftQ by replacing LoRA weights in-place"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d041ecb4-6957-467e-8f3e-d4a12c674e9f",
+   "metadata": {},
+   "source": [
+    "This notebook shows how to apply [LoftQ](https://huggingface.co/papers/2310.08659) initialization on our QLoRA model.\n",
+    "\n",
+    "In short, the idea behind LoftQ is the following. When we use QLoRA, i.e. we quantize the base model with bitsandbytes to save memory, and then train LoRA weights on top of this base model, we expect a certain performance gap. This is partly due to the fact that quantization is onyl an approximation of the \"real\" weights and thus introduces a quantization error. By default, LoRA weights are initialized such that they are a no-op at the start of the training. However, we can instead initialize them so that they minimize the quantization error. This is the idea behind LoftQ.\n",
+    "\n",
+    "Note that this only influences the initialization of the model. Everything that follows stays the same as always."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "90d5420f-de32-42fa-8792-247f60e3647d",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "a2c69b7c-c922-405f-aae1-ccc4f6911155",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import torch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "22be0432-8798-44a2-9014-d929525e3059",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "f087ce0f-71b4-45ec-b2f9-197677bbc1ee",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from peft import get_peft_model, LoraConfig, replace_lora_weights_loftq"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "63fdf18e-4ac4-409e-8475-88147cf85067",
+   "metadata": {},
+   "source": [
+    "## Functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "af14bd0a-597e-446c-800b-619fc0599ee0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_mae(x, y):\n",
+    "    return (x - y).abs().mean()\n",
+    "\n",
+    "\n",
+    "def get_mse(x, y):\n",
+    "    return torch.pow(x - y, 2).mean()\n",
+    "\n",
+    "\n",
+    "def error_report(x, y):\n",
+    "    mae = get_mae(x, y)\n",
+    "    mse = get_mse(x, y)\n",
+    "    print(\n",
+    "        f\"Mean absolute error: {mae:>8.5f}\\n\"\n",
+    "        f\"Mean squared error:  {mse:>8.5f}\"\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1bc01a5f-7ee8-400f-8e80-3f2b7df29882",
+   "metadata": {},
+   "source": [
+    "## Base model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fdc447d9-2f4f-4d0f-afdb-1cf5c4237321",
+   "metadata": {},
+   "source": [
+    "First, let's load a base model and calculate some logits. These logits are the baseline, i.e. we try to match their values as best as possible. We only need these logits for demonstration purposes. In practice, it is not necessary to load the non-quantized weights to apply LoftQ initialization.\n",
+    "\n",
+    "**Note**: We have to choose a model with a `model.safetensors` file. As PyTorch checkpoints (pickle) cannot be loaded lazily, we have to use [safetensors](https://huggingface.co/docs/safetensors/index). If those don't exist for your model, save the pretrained model as a safetensors file using `safe_pretrained` and pass the model path to `replace_lora_weights_loftq`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "0cb29074-d180-4fdc-8a47-27d2b9857264",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_id = \"bigscience/bloomz-560m\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "e7ddd6a2-04dd-42ec-9f48-100a3946ae04",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tokenizer = AutoTokenizer.from_pretrained(model_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "1f5b27db-51cc-41da-a21d-049ff747a149",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = AutoModelForCausalLM.from_pretrained(model_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "51548b6a-945c-4797-b02a-0e3fc77d1242",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s = \"\"\"Beautiful is better than ugly.\n",
+    "Explicit is better than implicit.\n",
+    "Simple is better than complex.\n",
+    "Complex is better than complicated.\n",
+    "Flat is better than nested.\n",
+    "Sparse is better than dense.\n",
+    "Readability counts.\n",
+    "Special cases aren't special enough to break the rules.\n",
+    "Although practicality beats purity.\n",
+    "Errors should never pass silently.\n",
+    "Unless explicitly silenced.\n",
+    "In the face of ambiguity, refuse the temptation to guess.\n",
+    "There should be one-- and preferably only one --obvious way to do it.\n",
+    "Although that way may not be obvious at first unless you're Dutch.\n",
+    "Now is better than never.\n",
+    "Although never is often better than *right* now.\n",
+    "If the implementation is hard to explain, it's a bad idea.\n",
+    "If the implementation is easy to explain, it may be a good idea.\n",
+    "Namespaces are one honking great idea -- let's do more of those!\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "ce72d923-5283-48ba-96ef-7f859309ad84",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "inputs = tokenizer(s.splitlines(), return_tensors=\"pt\", padding=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3bfe54cb-76ef-4981-ba25-3e544d264c62",
+   "metadata": {},
+   "source": [
+    "Our baseline logits:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "04bebcaa-3a05-4621-9a03-e25de72fa27c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "logits_base = model(**inputs).logits"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fa9c9001-8ade-422d-92f8-bcafa50917c7",
+   "metadata": {},
+   "source": [
+    "## Normal LoRA model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8024390b-736a-4b21-848b-aa4f30951d51",
+   "metadata": {},
+   "source": [
+    "Now we load the model quantized with bitsandbytes. For now, only 4bit is supported."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "01d1912a-646e-42d2-8292-6702b77d1948",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bnb_config = BitsAndBytesConfig(\n",
+    "    load_in_4bit=True,\n",
+    "    bnb_4bit_use_double_quant=True,\n",
+    "    bnb_4bit_compute_dtype=torch.float16,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "b1218717-4db4-48ce-978d-c05dc190fa91",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "`low_cpu_mem_usage` was None, now set to True since model is quantized.\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=bnb_config)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a0b4e4c5-3932-4d9a-9457-41a05f24d556",
+   "metadata": {},
+   "source": [
+    "Next we create a LoRA model using PEFT and compute the logits of that model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "4741bce0-cd2b-4f05-a50c-4f9e56b43e72",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lora_config = LoraConfig(task_type=\"CAUSAL_LM\", target_modules=\"all-linear\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "cf55cc48-b55d-4806-b6ab-e9b8035ed526",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "peft_model = get_peft_model(model, lora_config)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "f2f11e25-4a1e-485b-be4c-65aec62ac207",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      ".../bitsandbytes/nn/modules.py:391: UserWarning: Input type into Linear4bit is torch.float16, but bnb_4bit_compute_dtype=torch.float32 (default). This will lead to slow inference or training speed.\n",
+      "  warnings.warn('Input type into Linear4bit is torch.float16, but bnb_4bit_compute_dtype=torch.float32 (default). This will lead to slow inference or training speed.')\n"
+     ]
+    }
+   ],
+   "source": [
+    "logits_lora = peft_model(**inputs).logits"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5bc0cde7-0b9f-4305-ac0e-e3a6d2cfa401",
+   "metadata": {},
+   "source": [
+    "Let's check the influence of the quantization error on our logits:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "6f404c0d-f428-4923-9122-7b830410f089",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Mean absolute error:  3.61113\n",
+      "Mean squared error:  36.53259\n"
+     ]
+    }
+   ],
+   "source": [
+    "error_report(logits_base, logits_lora)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "58c437e1-4fae-4a2f-9c42-ada6bedb9a4d",
+   "metadata": {},
+   "source": [
+    "## LoftQ"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1af05376-c8b0-48ec-8d80-7d7f4d32bbd7",
+   "metadata": {},
+   "source": [
+    "Next, let's use LoftQ initialization and see if it helps reduce the error."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "890e6108-3f02-469c-9e7d-f2144448227c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "replace_lora_weights_loftq(peft_model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "b452db0e-a510-42d3-bef5-f567186e26c2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "logits_loftq = peft_model(**inputs).logits"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "456dc564-f268-4cf3-9d59-a6942d3733ad",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Mean absolute error:  3.24111\n",
+      "Mean squared error:  31.13725\n"
+     ]
+    }
+   ],
+   "source": [
+    "error_report(logits_base, logits_loftq)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1ddf9e0f-3f78-426c-be59-77c6481674ec",
+   "metadata": {},
+   "source": [
+    "We can see that LoftQ initialization helped a little bit, but the difference is not huge."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0dd344f2-249c-4fe9-8357-7fe3bcd1e82f",
+   "metadata": {},
+   "source": [
+    "## LoftQ with callback"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e2fd7dd5-88b3-40b8-95c2-3f3895d8093d",
+   "metadata": {},
+   "source": [
+    "To help with this, let's write a small callback function and pass it to `replace_lora_weights_loftq`. What this function does is that each time one weight is being replaced with LoftQ-initialized weights, we perform a test if the quantization error is actually reduced. If it it is not, we roll back the replacement. This way, we keep only those replacements that improve the results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "1f882802-22b7-4969-919e-120b1f2893d2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "`low_cpu_mem_usage` was None, now set to True since model is quantized.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Since PEFT has modified the base model, we should reload it\n",
+    "model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=bnb_config)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "c6438363-b66e-4507-8667-5a6df379a03f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "peft_model = get_peft_model(model, lora_config)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "7b93d082-0fcb-4b20-982e-c1aaf0c71d13",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "current_mse = float(\"inf\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "e22eb18d-b06e-47fe-91ba-ff34cbf62f60",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def my_callback(model, module_name):\n",
+    "    \"\"\"Callable to replace weights with LoFTQ if the mse is lower than the current best one.\"\"\"\n",
+    "    global current_mse\n",
+    "\n",
+    "    logits = model(**inputs).logits\n",
+    "    mse = get_mse(logits_base, logits)\n",
+    "    if mse < current_mse:\n",
+    "        current_mse = mse\n",
+    "        print(f\"MSE improved for module {module_name}\")\n",
+    "        return True\n",
+    "    print(f\"MSE did not improve for module {module_name}\")\n",
+    "    return False"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "44ee90d1-e15a-4740-a39d-ebf9e7adb79c",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MSE improved for module transformer.h.0.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.0.self_attention.dense\n",
+      "MSE improved for module transformer.h.0.mlp.dense_h_to_4h\n",
+      "MSE improved for module transformer.h.0.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.1.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.1.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.1.mlp.dense_h_to_4h\n",
+      "MSE improved for module transformer.h.1.mlp.dense_4h_to_h\n",
+      "MSE improved for module transformer.h.2.self_attention.query_key_value\n",
+      "MSE improved for module transformer.h.2.self_attention.dense\n",
+      "MSE improved for module transformer.h.2.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.2.mlp.dense_4h_to_h\n",
+      "MSE improved for module transformer.h.3.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.3.self_attention.dense\n",
+      "MSE improved for module transformer.h.3.mlp.dense_h_to_4h\n",
+      "MSE improved for module transformer.h.3.mlp.dense_4h_to_h\n",
+      "MSE improved for module transformer.h.4.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.4.self_attention.dense\n",
+      "MSE improved for module transformer.h.4.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.4.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.5.self_attention.query_key_value\n",
+      "MSE improved for module transformer.h.5.self_attention.dense\n",
+      "MSE improved for module transformer.h.5.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.5.mlp.dense_4h_to_h\n",
+      "MSE improved for module transformer.h.6.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.6.self_attention.dense\n",
+      "MSE improved for module transformer.h.6.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.6.mlp.dense_4h_to_h\n",
+      "MSE improved for module transformer.h.7.self_attention.query_key_value\n",
+      "MSE improved for module transformer.h.7.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.7.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.7.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.8.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.8.self_attention.dense\n",
+      "MSE improved for module transformer.h.8.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.8.mlp.dense_4h_to_h\n",
+      "MSE improved for module transformer.h.9.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.9.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.9.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.9.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.10.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.10.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.10.mlp.dense_h_to_4h\n",
+      "MSE improved for module transformer.h.10.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.11.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.11.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.11.mlp.dense_h_to_4h\n",
+      "MSE improved for module transformer.h.11.mlp.dense_4h_to_h\n",
+      "MSE improved for module transformer.h.12.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.12.self_attention.dense\n",
+      "MSE improved for module transformer.h.12.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.12.mlp.dense_4h_to_h\n",
+      "MSE improved for module transformer.h.13.self_attention.query_key_value\n",
+      "MSE improved for module transformer.h.13.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.13.mlp.dense_h_to_4h\n",
+      "MSE improved for module transformer.h.13.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.14.self_attention.query_key_value\n",
+      "MSE improved for module transformer.h.14.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.14.mlp.dense_h_to_4h\n",
+      "MSE improved for module transformer.h.14.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.15.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.15.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.15.mlp.dense_h_to_4h\n",
+      "MSE improved for module transformer.h.15.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.16.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.16.self_attention.dense\n",
+      "MSE improved for module transformer.h.16.mlp.dense_h_to_4h\n",
+      "MSE improved for module transformer.h.16.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.17.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.17.self_attention.dense\n",
+      "MSE improved for module transformer.h.17.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.17.mlp.dense_4h_to_h\n",
+      "MSE improved for module transformer.h.18.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.18.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.18.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.18.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.19.self_attention.query_key_value\n",
+      "MSE improved for module transformer.h.19.self_attention.dense\n",
+      "MSE improved for module transformer.h.19.mlp.dense_h_to_4h\n",
+      "MSE improved for module transformer.h.19.mlp.dense_4h_to_h\n",
+      "MSE improved for module transformer.h.20.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.20.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.20.mlp.dense_h_to_4h\n",
+      "MSE improved for module transformer.h.20.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.21.self_attention.query_key_value\n",
+      "MSE improved for module transformer.h.21.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.21.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.21.mlp.dense_4h_to_h\n",
+      "MSE improved for module transformer.h.22.self_attention.query_key_value\n",
+      "MSE improved for module transformer.h.22.self_attention.dense\n",
+      "MSE improved for module transformer.h.22.mlp.dense_h_to_4h\n",
+      "MSE improved for module transformer.h.22.mlp.dense_4h_to_h\n",
+      "MSE improved for module transformer.h.23.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.23.self_attention.dense\n",
+      "MSE improved for module transformer.h.23.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.23.mlp.dense_4h_to_h\n"
+     ]
+    }
+   ],
+   "source": [
+    "replace_lora_weights_loftq(peft_model, callback=my_callback)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "e31adc81-a090-49b2-90f6-9906743c76ae",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "logits_loftq_callback = peft_model(**inputs).logits"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "7c640092-1f26-48be-bea4-487511205440",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Mean absolute error:  1.79576\n",
+      "Mean squared error:   8.47075\n"
+     ]
+    }
+   ],
+   "source": [
+    "error_report(logits_base, logits_loftq_callback)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1896857e-3d87-44a9-887f-90c765bc8d91",
+   "metadata": {},
+   "source": [
+    "We can see that applying LoftQ with the help of the callback reduced the error quite significantly."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8eaf86cf-4fb4-455d-ab07-892591564303",
+   "metadata": {},
+   "source": [
+    "## Applying LoftQ multiple times"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "70836a75-5c6d-4b7b-9175-f395aef8383b",
+   "metadata": {},
+   "source": [
+    "It is possible to run `replace_lora_weights_loftq` multiple times on the same model when using the callback."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "8e5ee38c-007c-4c75-9248-005d94b19445",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MSE did not improve for module transformer.h.0.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.0.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.0.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.0.mlp.dense_4h_to_h\n",
+      "MSE improved for module transformer.h.1.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.1.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.1.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.1.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.2.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.2.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.2.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.2.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.3.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.3.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.3.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.3.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.4.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.4.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.4.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.4.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.5.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.5.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.5.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.5.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.6.self_attention.query_key_value\n",
+      "MSE improved for module transformer.h.6.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.6.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.6.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.7.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.7.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.7.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.7.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.8.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.8.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.8.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.8.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.9.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.9.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.9.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.9.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.10.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.10.self_attention.dense\n",
+      "MSE improved for module transformer.h.10.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.10.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.11.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.11.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.11.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.11.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.12.self_attention.query_key_value\n",
+      "MSE improved for module transformer.h.12.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.12.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.12.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.13.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.13.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.13.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.13.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.14.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.14.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.14.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.14.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.15.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.15.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.15.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.15.mlp.dense_4h_to_h\n",
+      "MSE improved for module transformer.h.16.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.16.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.16.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.16.mlp.dense_4h_to_h\n",
+      "MSE improved for module transformer.h.17.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.17.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.17.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.17.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.18.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.18.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.18.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.18.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.19.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.19.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.19.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.19.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.20.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.20.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.20.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.20.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.21.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.21.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.21.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.21.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.22.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.22.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.22.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.22.mlp.dense_4h_to_h\n",
+      "MSE did not improve for module transformer.h.23.self_attention.query_key_value\n",
+      "MSE did not improve for module transformer.h.23.self_attention.dense\n",
+      "MSE did not improve for module transformer.h.23.mlp.dense_h_to_4h\n",
+      "MSE did not improve for module transformer.h.23.mlp.dense_4h_to_h\n"
+     ]
+    }
+   ],
+   "source": [
+    "replace_lora_weights_loftq(peft_model, callback=my_callback)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "2abe2702-9510-4814-b5f2-63140a102c17",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "logits_loftq_callback_twice = peft_model(**inputs).logits"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "e908de14-01f9-4fdc-91b5-61118a3ce6cb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Mean absolute error:  1.76357\n",
+      "Mean squared error:   8.33938\n"
+     ]
+    }
+   ],
+   "source": [
+    "error_report(logits_base, logits_loftq_callback_twice)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5b8b09fe-d369-4444-b6e2-cd514e775637",
+   "metadata": {},
+   "source": [
+    "There are further gains, but they are not very big."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/loftq_finetuning/README.md b/examples/loftq_finetuning/README.md
new file mode 100644
index 0000000..73decc9
--- /dev/null
+++ b/examples/loftq_finetuning/README.md
@@ -0,0 +1,144 @@
+# LoftQ: LoRA-fine-tuning-aware Quantization
+
+## Introduction
+
+LoftQ finds quantized LoRA initialization: quantized backbone Q and LoRA adapters A and B, given a pre-trained weight W.
+
+## Quick Start
+Steps:
+
+1. Apply LoftQ to a full-precision pre-trained weight and save.
+2. Load LoftQ initialization and train.
+
+For step 1, we have provided off-the-shelf LoftQ initializations (see [supported model list](#appendix-off-the-shelf-model-list)) 
+in [Huggingface Hub LoftQ](https://huggingface.co/LoftQ).
+If you want to do it yourself, jump to [LoftQ DIY](#loftq-diy).
+
+For step 2, below is an example of loading 4bit Mistral-7B with 64rank LoRA adapters from Huggingface Hub.
+```python
+import torch
+from transformers import AutoModelForCausalLM, BitsAndBytesConfig
+from peft import PeftModel
+
+MODEL_ID = "LoftQ/Mistral-7B-v0.1-4bit-64rank"
+
+base_model = AutoModelForCausalLM.from_pretrained(
+    MODEL_ID, 
+    dtype=torch.bfloat16,  # you may change it with different models
+    quantization_config=BitsAndBytesConfig(
+        load_in_4bit=True,
+        bnb_4bit_compute_dtype=torch.bfloat16,  # bfloat16 is recommended
+        bnb_4bit_use_double_quant=False,
+        bnb_4bit_quant_type='nf4',
+    ),
+)
+peft_model = PeftModel.from_pretrained(
+    base_model,
+    MODEL_ID,
+    subfolder="loftq_init",
+    is_trainable=True,
+)
+
+# Do training with peft_model ...
+```
+
+## LoftQ DIY
+
+### Apply LoftQ and save
+We provide [quantize_save_load.py](quantize_save_load.py) as an example to apply LoftQ with 
+different bits(`--bits`), ranks(`--rank`), and alternating steps (`--iter`, a hyper-parameter in LoftQ, see Algorithm 1 in [LoftQ paper](https://huggingface.co/papers/2310.08659)). Currently, this example supports
+`llama-2`, `falcon`, `mistral`, `bart`, `t5`, `deberta`, `bert`, `roberta`.
+
+Below is an example of obtaining 4bit LLAMA-2-7b with 16-rank LoRA adapters by 5 alternating steps.
+```sh
+SAVE_DIR="model_zoo/loftq/"
+python quantize_save_load.py \
+    --model_name_or_path meta-llama/Llama-2-7b-hf \  # high-precision model id in HF
+    --token HF_TOKEN \  # your HF token if the model is private, e.g., llama-2
+    --bits 4 \
+    --iter 5 \
+    --rank 16 \
+    --save_dir $SAVE_DIR
+```
+
+The above commands end up with creating the model directory under `$SAVE_DIR`. 
+Specifically, the model directory is named as 
+
+`MODEL_DIR = SAVE_DIR + f"{args.model_name_or_path.split('/')[-1]}-{args.bits}bits-{args.rank}rank"`
+
+In this example, `MODEL_DIR="model_zoo/loftq/Llama-2-7b-hf-4bit-16rank"`, where the backbone is stored in `$MODEL_DIR`
+and the LoRA adapters are at the sub-folder `$MODEL_DIR/loftq_init`.
+
+### Load and train
+Similar to loading from Huggingface Hub, we only need to change the `MODEL_ID` to the `MODEL_DIR`.
+
+```python
+import torch
+from transformers import AutoModelForCausalLM, BitsAndBytesConfig
+from peft import PeftModel
+
+MODEL_DIR = "model_zoo/loftq/Llama-2-7b-hf-4bit-16rank"
+
+base_model = AutoModelForCausalLM.from_pretrained(
+    MODEL_DIR, 
+    dtype=torch.bfloat16,
+    quantization_config=BitsAndBytesConfig(
+        load_in_4bit=True,
+        bnb_4bit_compute_dtype=torch.bfloat16,
+        bnb_4bit_use_double_quant=False,
+        bnb_4bit_quant_type='nf4',
+    ),
+)
+peft_model = PeftModel.from_pretrained(
+    base_model,
+    MODEL_DIR,
+    subfolder="loftq_init",
+    is_trainable=True,
+)
+# Do training with peft_model ...
+```
+
+## LoftQ Fine-tuning
+
+We also provide an example to fine-tune LoftQ on GSM8K. 
+We load the quantized backbone and LoRA adapters from the [LoftQ Huggingface hub](https://huggingface.co/LoftQ).
+
+```sh
+python train_gsm8k_llama.py \
+    --model_name_or_path LoftQ/Llama-2-13b-hf-4bit-64rank \
+    --output_dir exp_results/gsm8k/llama-2-13b/bit4-rank64/lr1e-4 \
+    --learning_rate 1e-4  \
+    --weight_decay 0.1 \
+    --lr_scheduler_type cosine \
+    --num_warmup_steps 100 \
+    --seed 202 \
+    --dataset_name gsm8k \
+    --dataset_config main \
+    --pad_to_max_length \
+    --max_source_length 128 \
+    --max_target_length 256 \
+    --num_train_epochs 5 \
+    --per_device_train_batch_size 4 \
+    --per_device_eval_batch_size 4 \
+    --gradient_accumulation_steps 4 \
+    --with_tracking \
+    --report_to tensorboard
+```
+
+
+## Appendix: Off-the-shelf Model List
+| Model Name  | Bits | Ranks |
+| ----------- | ---- | ----- |
+| LLAMA-2-7b  | 4    | 64    |
+| LLAMA-2-13b | 4    | 64    |
+| LLAMA-2-70b | 4    | 64    |
+| Mistral     | 4    | 64    |
+| Mistral     | 4    | 32    |
+| BART-large  | 4    | 8     |
+| BART-large  | 4    | 16    |
+| BART-large  | 4    | 32    |
+| BART-large  | 2    | 8     |
+
+## In-place application of LoftQ initialization
+
+PEFT provides a convenience function `replace_lora_weights_loftq` to apply LoftQ initialization in-place to the quantized model. Check out [this notebook](https://github.com/huggingface/peft/blob/main/examples/loftq_finetuning/LoftQ_weight_replacement.ipynb) for an example.
diff --git a/examples/loftq_finetuning/int8_correction.py b/examples/loftq_finetuning/int8_correction.py
new file mode 100755
index 0000000..b2c2d42
--- /dev/null
+++ b/examples/loftq_finetuning/int8_correction.py
@@ -0,0 +1,279 @@
+#!/usr/bin/env python
+"""
+Script to show-case how to offset quantization error with LoRA / LoftQ
+when dealing with quantizations that both quantize weights and activations.
+This is the case for bnb int8, for example, but also other quantizations
+such as BitNet do this.
+
+The math for how this works is explained in MyLinear8bitLt.forward and
+can be seen quickly when defining W_q = W + E_W (quantized weight is the
+sum of the original weights plus an error term) and the same for
+x_q = x + e_x.
+
+To demonstrate the effectiveness, we load a unquantized model, generate
+logits for reference inputs and then do the same for a quantized model
+and a quantized model with LoftQ and our mitigations applied. The
+error between reference model logits and LoftQ logits is significantly
+smaller compared to the logits produced by the quantized model without
+mitigation.
+
+Note: set llm_int8_threshold=0 in your BitsAndBytesConfig. The thresholding
+enables dynamic fp16 quantization (for x values above that threshold).
+The quantization error for the affected values is much lower and not
+static anymore, LoftQ is not able to deal with this. While technically
+possible, this script doesn't filter out these masked values and it
+is probably not worth the effort.
+
+Note: Some rudimentary testing showed that the LoftQ mitigation is still
+more effective than tuning threshold values but YMMV.
+
+Note: LoftQ is not doing the heavy lifting in this script's case. The error
+between LoftQ and zeroed LoRA is only about two percent points (check this
+yourself by using the `--no-loftq` flag). This effect is probably dependent
+on the quantization strength.
+
+Examples of experiments you can do:
+
+- check the difference between applying no-op LoRA and LoftQ initialized
+  LoRA by running the following two commands:
+    * ./int8_correction.py --no-mitigation
+    * ./int8_correction.py --no-mitigation --no-loftq
+
+- check the effect of the mitigation vs. the static compenstation by LoftQ:
+    * ./int8_correction.py
+    * ./int8_correction.py --no-loftq
+
+- check the rank contribution for LoftQ:
+    * for r in 8 16 32 64 128; do ./int8_correction.py --rank $i --no-mitigation; done
+
+"""
+
+import argparse
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+import bitsandbytes as bnb
+import torch
+from transformers import AutoModelForCausalLM, AutoModelForSeq2SeqLM, AutoTokenizer, BitsAndBytesConfig
+
+import peft.tuners.lora.bnb
+from peft import LoftQConfig, LoraConfig, PeftModel, TaskType, get_peft_model
+
+
+torch.backends.cudnn.deterministic = True
+torch.backends.cudnn.benchmark = False
+
+
+class MyLinear8bitLt(peft.tuners.lora.bnb.Linear8bitLt):
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        self._check_forward_args(x, *args, **kwargs)
+        adapter_names = kwargs.pop("adapter_names", None)
+
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif adapter_names is not None:
+            result = self._mixed_batch_forward(x, *args, adapter_names=adapter_names, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.lora_A.keys():
+                    continue
+                lora_A = self.lora_A[active_adapter]
+                lora_B = self.lora_B[active_adapter]
+                dropout = self.lora_dropout[active_adapter]
+                scaling = self.scaling[active_adapter]
+
+                requires_conversion = not torch.is_autocast_enabled()
+                if requires_conversion:
+                    expected_dtype = result.dtype
+                    x = self._cast_input_dtype(x, lora_A.weight.dtype)
+
+                # The premise of this is that when we quantize, we introduce an
+                # error. This means that quantizing x to xq we can state that
+                # x = x_q + e_x or x_q = x - e_x. The same goes for W: W = W_q + E_W
+                # or W_q = W - E_W.
+                #
+                # LoftQ computes E_W, applies SVD and initializes LoRA's B and A with
+                # self.r ranks of E_W, giving us ~E_W. For our forward this means:
+                # y = W_q x + BAx = (W_q + BA) x = (W_q + ~E_W) x = W x
+                # if ~E_W is close enough to E_W.
+                #
+                # This breaks down if x is also quantized (as is the case for bnb int8):
+                # y = W_q x_q + BA x_q = (W_q + ~E_W) x_q = W x_q = W (x - e_x) = Wx - W e_x
+                #
+                # Since e_x is non-zero and W is relatively large, it is a non-negligible
+                # error term. But we can offset this, since we can compute e_x and we can
+                # approximate W with W_q - or - in the case of LoftQ with ~E_W. Both work.
+                # I didn't see a difference empirically but with other quantizations this
+                # might change. In any case, we can compute ex_mitigation = W_q e_x and
+                # add it along with the LoRA to remove the W e_x term and be left with
+                # y = Wx.
+                #
+                # This is the term yielding the most error correction gain. There's a
+                # smaller gain to be had by passing x_q to the LoRA's layers. Let's
+                # revisit the quantized base layer definition:
+                # y = W_q x_q = (W - E_W) (x - e_x) = Wx - W e_x - E_W x + E_W e_x
+                #
+                # (W e_x) we handled before, (- E_W x) is what we approximate with (~E_W x)
+                # and is subsequently removed as well but this leaves us (E_W e_x).
+                # It turns out, if you pass x_q into the LoRA modules, you will end up
+                # with (~E_W x - ~E_W e_x) - which removes this term as well.
+
+                # Compute x_q (int8 quantized x) to pass it into the LoRA's forward.
+                CB, SCB, _ = bnb.functional.int8_vectorwise_quant(x.half())
+                CB = CB.reshape(-1, CB.shape[-1])
+                x_q = bnb.functional.int8_vectorwise_dequant(CB, SCB).to(lora_A.weight.dtype)
+                x_q = x_q.reshape(*x.shape)
+
+                e_x = x - x_q
+                W_dq = bnb.functional.int8_vectorwise_dequant(self.base_layer.state.CB, self.base_layer.state.SCB).to(
+                    e_x.dtype
+                )
+                e_x_mitigation = e_x @ W_dq.T
+                # e_x_mitigation = e_x @ (W_dq.T + (lora_B.weight @ lora_A.weight * scaling).T)
+
+                output = lora_B(lora_A(dropout(x_q))) * scaling
+                output += e_x_mitigation
+                if requires_conversion:
+                    output = output.to(expected_dtype)
+                result = result + output
+
+        return result
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument(
+    "--no-loftq", action="store_true", default=False, help="Disable LoftQ initialization (LoRA no-op init instead)"
+)
+parser.add_argument(
+    "--no-mitigation", action="store_true", default=False, help="Disable activation quantization mitigiation"
+)
+parser.add_argument(
+    "--model",
+    choices=["t5-small", "t5-base", "t5-large", "facebook/opt-125m"],
+    default="t5-base",
+    help="What model to test.",
+)
+parser.add_argument("--rank", type=int, default=64)
+parser.add_argument("--device", type=str, default="cuda")
+parser.add_argument(
+    "--int8-threshold", type=float, default=0.0, help="To demonstrate that int8 threshold > 0 doesn't work"
+)
+
+args = parser.parse_args()
+
+device = args.device
+qconf = BitsAndBytesConfig(
+    load_in_8bit=True,
+    llm_int8_threshold=args.int8_threshold,
+)
+input_texts = [
+    "All I need",
+    "All I want is",
+    "Forever yours truly: ",
+    "Translate French to German: Tu l'as lu?",
+    "Translate German to French: Last du es?",
+    (
+        "Beautiful is better than ugly.\n"
+        "Explicit is better than implicit.\n"
+        "Simple is better than complex.\n"
+        "Complex is better than complicated.\n"
+    ),
+]
+bits = 8
+loftq_iter = 1
+rank = args.rank
+
+model_id = args.model
+
+if "t5" in args.model:
+    target_modules = ["o", "k", "wi", "q", "v"]
+    task_type = TaskType.SEQ_2_SEQ_LM
+else:
+    target_modules = "all-linear"
+    task_type = TaskType.CAUSAL_LM
+
+# ----
+
+
+def get_logits(model, inputs):
+    torch.manual_seed(0)
+    if task_type == TaskType.CAUSAL_LM:
+        return model(**inputs).logits
+
+    with torch.inference_mode():
+        return model(**inputs, labels=inputs["input_ids"]).logits
+
+
+def mse(a, b, attention_mask=None):
+    squared_error = torch.pow(a - b, 2)
+    if attention_mask is not None:
+        # attention_mask shape: [batch_size, seq_len]
+        # squared_error shape: [batch_size, seq_len, vocab_size]
+        # apply the mask (zeros out the squared error for padding tokens)
+        mask = attention_mask.unsqueeze(-1).expand_as(squared_error)
+        masked_squared_error = squared_error * mask
+        return (masked_squared_error.sum() / mask.sum()).item()
+    return squared_error.mean().item()
+
+
+def get_model(*args, **kwargs):
+    if task_type == TaskType.CAUSAL_LM:
+        return AutoModelForCausalLM.from_pretrained(*args, **kwargs)
+    return AutoModelForSeq2SeqLM.from_pretrained(*args, **kwargs)
+
+
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+inputs = tokenizer(input_texts, padding=True, return_tensors="pt").to(device)
+
+ref_model = get_model(model_id, dtype=torch.float32, device_map=device)
+qref_model = get_model(model_id, quantization_config=qconf, dtype=torch.float32, device_map=device)
+
+loftq_config = LoftQConfig(loftq_bits=bits, loftq_iter=loftq_iter)
+lora_config = LoraConfig(
+    task_type=task_type,
+    r=rank,
+    init_lora_weights=True if args.no_loftq else "loftq",
+    loftq_config=loftq_config,
+    target_modules=target_modules,
+)
+
+base_model = get_model(model_id, dtype=torch.float32, device_map=device)
+loftq_model = get_peft_model(base_model, lora_config)
+
+print("APPLYING SAVED ADAPTER TO QUANTIZED MODEL")
+with TemporaryDirectory() as tmp_path:
+    tmp_path = Path(tmp_path)
+    loftq_model.base_model.peft_config["default"].init_lora_weights = True
+    loftq_model.save_pretrained(tmp_path / "loftq_model")
+
+    lora_config = LoraConfig.from_pretrained(tmp_path / "loftq_model")
+    model_id = args.model
+
+    if not args.no_mitigation:
+        custom_module_mapping = {bnb.nn.Linear8bitLt: MyLinear8bitLt}
+        lora_config._register_custom_module(custom_module_mapping)
+
+    base_model = get_model(model_id, quantization_config=qconf, dtype=torch.float32, device_map=device)
+    loftq_model = PeftModel.from_pretrained(
+        base_model, tmp_path / "loftq_model", is_trainable=True, config=lora_config
+    )
+
+
+ref_logits = get_logits(ref_model, inputs)
+
+qref_logits = get_logits(qref_model, inputs)
+loftq_logits = get_logits(loftq_model, inputs)
+
+mse_loftq = mse(ref_logits, loftq_logits, attention_mask=inputs["attention_mask"])
+mse_qref = mse(ref_logits, qref_logits, attention_mask=inputs["attention_mask"])
+
+
+print(f"{model_id=}{device=}")
+print(f"{mse_qref=}, {mse_loftq=}")
+assert mse_loftq < (mse_qref / 1.05), f"{mse_loftq} >= {mse_qref / 1.05}"
+print(f"relative reduction of error: {(mse_qref - mse_loftq) / mse_qref * 100:.2f}%")
diff --git a/examples/loftq_finetuning/quantize_save_load.py b/examples/loftq_finetuning/quantize_save_load.py
new file mode 100644
index 0000000..48fba6c
--- /dev/null
+++ b/examples/loftq_finetuning/quantize_save_load.py
@@ -0,0 +1,193 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import argparse
+import os
+
+import torch
+from torch import nn
+from transformers import (
+    AutoModelForCausalLM,
+    AutoModelForSeq2SeqLM,
+    AutoModelForSequenceClassification,
+    AutoTokenizer,
+)
+
+from peft import LoftQConfig, LoraConfig, TaskType, get_peft_model
+
+
+class Shell(nn.Module):
+    def __init__(self, weight, bias=None):
+        super().__init__()
+        self.weight = nn.Parameter(weight, requires_grad=False)
+        if bias is not None:
+            self.bias = nn.Parameter(bias, requires_grad=False)
+
+
+def unwrap_model(model, sub_module_name=".base_layer"):
+    sub_module_name_list = [k.split(sub_module_name)[0] for k in model.state_dict().keys() if sub_module_name in k]
+    sub_module_name_set = set(sub_module_name_list)
+    for name in sub_module_name_set:
+        # get the parent of the submodule
+        name_parent = ".".join(name.split(".")[:-1])
+        name_child = name.split(".")[-1]
+        sub_module = model.get_submodule(name_parent)
+        print(sub_module)
+
+        # replace with shell
+        child = getattr(sub_module, name_child)
+        weight = getattr(child.base_layer, "weight", None)
+        bias = getattr(child.base_layer, "bias", None)
+        shell = Shell(weight, bias)
+
+        setattr(sub_module, name_child, shell)
+
+    print("You have unwrapped the model. Use it on your own risk.")
+
+
+def print_model(model, name):
+    print("=" * 10 + name + "=" * 10)
+    print(model)
+    for param_name, param in model.named_parameters():
+        if torch.is_tensor(param):
+            if param.dtype in [torch.float32, torch.float16]:
+                print(
+                    param_name,
+                    param.shape,
+                    param.device,
+                    param.dtype,
+                    param.requires_grad,
+                    param.mean().item(),
+                    param.max().item(),
+                )
+            else:
+                print(name, param.shape, param.device, param.dtype, param.requires_grad)
+
+
+def arg_parse():
+    parser = argparse.ArgumentParser(description="Quantize a model with LoftQ.")
+    parser.add_argument(
+        "--model_name_or_path",
+        type=str,
+        default=None,
+        required=True,
+        help="The name or path of the fp32/16 model.",
+    )
+    parser.add_argument(
+        "--token",
+        type=str,
+        default=None,
+        help="The access token to download model from HuggingFace Hub.",
+    )
+    parser.add_argument(
+        "--bits",
+        type=int,
+        default=4,
+        help="The quantized bits",
+    )
+    parser.add_argument(
+        "--iter",
+        type=int,
+        default=1,
+        help="The alternating steps in LoftQ",
+    )
+    parser.add_argument(
+        "--rank",
+        type=int,
+        default=16,
+        help="The rank of the LoRA adapter",
+    )
+    parser.add_argument(
+        "--save_dir",
+        type=str,
+        default="./model_zoo/loftq/",
+        help="The rank of the LoRA adapter",
+    )
+    args = parser.parse_args()
+    return args
+
+
+def quantize_and_save():
+    args = arg_parse()
+
+    # Download weights and configure LoRA
+    tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path, token=args.token, trust_remote_code=True)
+    if any(name in args.model_name_or_path.lower() for name in ["llama", "mistral", "falcon"]):
+        model = AutoModelForCausalLM.from_pretrained(args.model_name_or_path, token=args.token, trust_remote_code=True)
+        task_type = TaskType.CAUSAL_LM
+        target_modules = ["q_proj", "k_proj", "v_proj", "o_proj", "up_proj", "down_proj", "gate_proj"]
+
+    elif any(name in args.model_name_or_path.lower() for name in ["bart", "t5"]):
+        model = AutoModelForSeq2SeqLM.from_pretrained(args.model_name_or_path, token=args.token)
+        task_type = TaskType.SEQ_2_SEQ_LM
+        target_modules = ["q_proj", "k_proj", "v_proj", "fc1", "fc2", "out_proj"]
+
+    elif any(name in args.model_name_or_path.lower() for name in ["deberta", "roberta", "bert"]):
+        model = AutoModelForSequenceClassification.from_pretrained(args.model_name_or_path, token=args.token)
+        task_type = TaskType.SEQ_CLS
+        target_modules = ["query_proj", "key_proj", "value_proj", "dense"]  # embeddings not supported by peft
+    else:
+        raise NotImplementedError("Other models not supported yet.")
+
+    # Config of LoftQ
+    loftq_config = LoftQConfig(loftq_bits=args.bits, loftq_iter=args.iter)
+
+    lora_config = LoraConfig(
+        task_type=task_type,
+        inference_mode=True,
+        r=args.rank,
+        lora_alpha=16 if task_type is TaskType.CAUSAL_LM else args.rank,
+        lora_dropout=0.1,
+        target_modules=target_modules,
+        init_lora_weights="loftq",
+        loftq_config=loftq_config,
+    )
+
+    # Obtain LoftQ model
+    lora_model = get_peft_model(model, lora_config)
+    base_model = lora_model.get_base_model()
+
+    # Save LoftQ model
+    model_name = args.model_name_or_path.split("/")[-1] + f"-{args.bits}bit" + f"-{args.rank}rank"
+    base_model_dir = os.path.join(args.save_dir, model_name)
+    lora_model_dir = os.path.join(args.save_dir, model_name, "loft_init")
+
+    # save lora adapters first
+    lora_model.base_model.peft_config[
+        "default"
+    ].base_model_name_or_path = base_model_dir  # This can be a local path or Hub model id
+    lora_model.base_model.peft_config["default"].init_lora_weights = True  # Don't apply LoftQ when loading again
+
+    lora_model.save_pretrained(lora_model_dir)
+    print_model(lora_model, "lora_model")
+
+    # remove lora adapters and save the backbone
+    unwrap_model(base_model)
+    base_model.save_pretrained(base_model_dir)
+    tokenizer.save_pretrained(base_model_dir)
+
+    print_model(base_model, "base_model")
+
+    return base_model_dir, lora_model_dir
+
+
+if __name__ == "__main__":
+    base_dir, lora_dir = quantize_and_save()
+
+# example command:
+# python quantize_save_load.py \
+# --model_name_or_path meta-llama/Llama-2-7b-hf \
+# --token XXX \
+# --bits 4 --iter 5 --rank 16 \
+# --save_dir ./model_zoo/loftq/
diff --git a/examples/loftq_finetuning/train_gsm8k_llama.py b/examples/loftq_finetuning/train_gsm8k_llama.py
new file mode 100644
index 0000000..63491a6
--- /dev/null
+++ b/examples/loftq_finetuning/train_gsm8k_llama.py
@@ -0,0 +1,851 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import argparse
+import copy
+import logging
+import math
+import os
+import random
+import re
+from pathlib import Path
+
+import datasets
+import torch
+import transformers
+from accelerate import Accelerator, DistributedType
+from accelerate.logging import get_logger
+from accelerate.utils import set_seed
+from datasets import load_dataset
+from huggingface_hub import HfApi
+from torch.utils.data import DataLoader
+from tqdm.auto import tqdm
+from transformers import (
+    CONFIG_MAPPING,
+    MODEL_MAPPING,
+    AutoConfig,
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    BitsAndBytesConfig,
+    SchedulerType,
+    default_data_collator,
+    get_scheduler,
+)
+from transformers.utils import send_example_telemetry
+from transformers.utils.versions import require_version
+
+from peft import PeftModel
+
+
+# Will error if the minimal version of Transformers is not installed. Remove at your own risks.
+# check_min_version("4.32.0.dev0")
+
+logger = get_logger(__name__)
+
+require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/language-modeling/requirements.txt")
+
+MODEL_CONFIG_CLASSES = list(MODEL_MAPPING.keys())
+MODEL_TYPES = tuple(conf.model_type for conf in MODEL_CONFIG_CLASSES)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Finetune a transformers model on a causal language modeling task")
+    parser.add_argument(
+        "--dataset_name",
+        type=str,
+        default=None,
+        help="The name of the dataset to use (via the datasets library).",
+    )
+    parser.add_argument(
+        "--dataset_config_name",
+        type=str,
+        default=None,
+        help="The configuration name of the dataset to use (via the datasets library).",
+    )
+    parser.add_argument(
+        "--train_file", type=str, default=None, help="A csv, txt or a json file containing the training data."
+    )
+    parser.add_argument(
+        "--validation_file", type=str, default=None, help="A csv, txt or a json file containing the validation data."
+    )
+    parser.add_argument(
+        "--validation_split_percentage",
+        default=5,
+        help="The percentage of the train set used as validation set in case there's no validation split",
+    )
+    parser.add_argument(
+        "--model_name_or_path",
+        type=str,
+        help="Path to pretrained model or model identifier from huggingface.co/models.",
+        required=False,
+    )
+    parser.add_argument(
+        "--config_name",
+        type=str,
+        default=None,
+        help="Pretrained config name or path if not the same as model_name",
+    )
+    parser.add_argument(
+        "--tokenizer_name",
+        type=str,
+        default=None,
+        help="Pretrained tokenizer name or path if not the same as model_name",
+    )
+    parser.add_argument(
+        "--use_slow_tokenizer",
+        action="store_true",
+        help="If passed, will use a slow tokenizer (not backed by the 🤗 Tokenizers library).",
+    )
+    parser.add_argument(
+        "--per_device_train_batch_size",
+        type=int,
+        default=8,
+        help="Batch size (per device) for the training dataloader.",
+    )
+    parser.add_argument(
+        "--per_device_eval_batch_size",
+        type=int,
+        default=8,
+        help="Batch size (per device) for the evaluation dataloader.",
+    )
+    parser.add_argument(
+        "--learning_rate",
+        type=float,
+        default=5e-5,
+        help="Initial learning rate (after the potential warmup period) to use.",
+    )
+    parser.add_argument("--weight_decay", type=float, default=0.0, help="Weight decay to use.")
+    parser.add_argument("--num_train_epochs", type=int, default=3, help="Total number of training epochs to perform.")
+    parser.add_argument(
+        "--max_train_steps",
+        type=int,
+        default=None,
+        help="Total number of training steps to perform. If provided, overrides num_train_epochs.",
+    )
+    parser.add_argument(
+        "--gradient_accumulation_steps",
+        type=int,
+        default=1,
+        help="Number of updates steps to accumulate before performing a backward/update pass.",
+    )
+    parser.add_argument(
+        "--lr_scheduler_type",
+        type=SchedulerType,
+        default="linear",
+        help="The scheduler type to use.",
+        choices=["linear", "cosine", "cosine_with_restarts", "polynomial", "constant", "constant_with_warmup"],
+    )
+    parser.add_argument(
+        "--num_warmup_steps", type=int, default=0, help="Number of steps for the warmup in the lr scheduler."
+    )
+    parser.add_argument("--output_dir", type=str, default=None, help="Where to store the final model.")
+    parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.")
+    parser.add_argument(
+        "--model_type",
+        type=str,
+        default=None,
+        help="Model type to use if training from scratch.",
+        choices=MODEL_TYPES,
+    )
+    parser.add_argument(
+        "--ignore_pad_token_for_loss",
+        type=bool,
+        default=True,
+        help="Whether to ignore the tokens corresponding to padded labels in the loss computation or not.",
+    )
+    parser.add_argument(
+        "--max_source_length",
+        type=int,
+        default=128,
+        help=(
+            "The maximum total input sequence length after "
+            "tokenization.Sequences longer than this will be truncated, sequences shorter will be padded."
+        ),
+    )
+    parser.add_argument(
+        "--max_target_length",
+        type=int,
+        default=128,
+        help=(
+            "The maximum total sequence length for target text after "
+            "tokenization. Sequences longer than this will be truncated, sequences shorter will be padded."
+            "during ``evaluate`` and ``predict``."
+        ),
+    )
+    parser.add_argument(
+        "--pad_to_max_length",
+        action="store_true",
+        help="If passed, pad all samples to `max_length`. Otherwise, dynamic padding is used.",
+    )
+    parser.add_argument(
+        "--preprocessing_num_workers",
+        type=int,
+        default=None,
+        help="The number of processes to use for the preprocessing.",
+    )
+    parser.add_argument(
+        "--overwrite_cache", action="store_true", help="Overwrite the cached training and evaluation sets"
+    )
+    parser.add_argument(
+        "--no_keep_linebreaks", action="store_true", help="Do not keep line breaks when using TXT files."
+    )
+    parser.add_argument("--push_to_hub", action="store_true", help="Whether or not to push the model to the Hub.")
+    parser.add_argument(
+        "--hub_model_id", type=str, help="The name of the repository to keep in sync with the local `output_dir`."
+    )
+    parser.add_argument("--hub_token", type=str, help="The token to use to push to the Model Hub.")
+    parser.add_argument(
+        "--trust_remote_code",
+        type=bool,
+        default=False,
+        help=(
+            "Whether or not to allow for custom models defined on the Hub in their own modeling files. This option"
+            "should only be set to `True` for repositories you trust and in which you have read the code, as it will"
+            "execute code present on the Hub on your local machine."
+        ),
+    )
+    parser.add_argument(
+        "--checkpointing_steps",
+        type=str,
+        default=None,
+        help="Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch.",
+    )
+    parser.add_argument(
+        "--resume_from_checkpoint",
+        type=str,
+        default=None,
+        help="If the training should continue from a checkpoint folder.",
+    )
+    parser.add_argument(
+        "--with_tracking",
+        action="store_true",
+        help="Whether to enable experiment trackers for logging.",
+    )
+    parser.add_argument(
+        "--report_to",
+        type=str,
+        default="tensorboard",
+        help=(
+            'The integration to report the results and logs to. Supported platforms are `"tensorboard"`,'
+            ' `"wandb"`, `"comet_ml"` and `"clearml"`. Use `"all"` (default) to report to all integrations.'
+            "Only applicable when `--with_tracking` is passed."
+        ),
+    )
+    parser.add_argument(
+        "--low_cpu_mem_usage",
+        action="store_true",
+        help=(
+            "It is an option to create the model as an empty shell, then only materialize its parameters when the pretrained weights are loaded."
+            "If passed, LLM loading time and RAM consumption will be benefited."
+        ),
+    )
+    ##########################
+    #   Generation Config    #
+    ##########################
+    parser.add_argument(
+        "--temperature",
+        type=float,
+        default=0.8,
+        help="temperature of 1.0 has no effect, lower tend toward greedy sampling",
+    )
+    parser.add_argument("--k", type=int, default=40, help="Choose k candidate words")
+    parser.add_argument("--p", type=float, default=0.95, help="The sum of probability of candidate words is 0.9 ")
+
+    ##########################
+    #        Exp Args        #
+    ##########################
+    parser.add_argument(
+        "--adapter_name_or_path",
+        type=str,
+        default=None,
+        help=(
+            "The LoRA adapter checkpoint. Set None if you want to fine-tune from LoftQ."
+            "Specify a path if you want to evaluate."
+        ),
+    )
+
+    args = parser.parse_args()
+
+    # Sanity checks
+    if args.dataset_name is None and args.train_file is None and args.validation_file is None:
+        raise ValueError("Need either a dataset name or a training/validation file.")
+    else:
+        if args.train_file is not None:
+            extension = args.train_file.split(".")[-1]
+            assert extension in ["csv", "json", "txt"], "`train_file` should be a csv, json or txt file."
+        if args.validation_file is not None:
+            extension = args.validation_file.split(".")[-1]
+            assert extension in ["csv", "json", "txt"], "`validation_file` should be a csv, json or txt file."
+
+    if args.push_to_hub:
+        assert args.output_dir is not None, "Need an `output_dir` to create a repo when `--push_to_hub` is passed."
+
+    return args
+
+
+def main():
+    args = parse_args()
+
+    # Sending telemetry. Tracking the example usage helps us better allocate resources to maintain them. The
+    # information sent is the one passed as arguments along with your Python/PyTorch versions.
+    send_example_telemetry("run_clm_no_trainer", args)
+
+    # Initialize the accelerator. We will let the accelerator handle device placement for us in this example.
+    # If we're using tracking, we also need to initialize it here and it will by default pick up all supported trackers
+    # in the environment
+    accelerator_log_kwargs = {}
+
+    if args.with_tracking:
+        accelerator_log_kwargs["log_with"] = args.report_to
+        accelerator_log_kwargs["project_dir"] = args.output_dir
+
+    accelerator = Accelerator(gradient_accumulation_steps=args.gradient_accumulation_steps, **accelerator_log_kwargs)
+
+    # Make one log on every process with the configuration for debugging.
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        level=logging.INFO,
+    )
+    logger.info(accelerator.state, main_process_only=False)
+    if accelerator.is_local_main_process:
+        datasets.utils.logging.set_verbosity_warning()
+        transformers.utils.logging.set_verbosity_info()
+    else:
+        datasets.utils.logging.set_verbosity_error()
+        transformers.utils.logging.set_verbosity_error()
+
+    # If passed along, set the training seed now.
+    if args.seed is not None:
+        set_seed(args.seed)
+
+    # Handle the repository creation
+    if accelerator.is_main_process:
+        if args.push_to_hub:
+            api = HfApi(token=args.hub_token)
+
+            # Create repo (repo_name from args or inferred)
+            repo_name = args.hub_model_id
+            if repo_name is None:
+                repo_name = Path(args.output_dir).absolute().name
+            repo_id = api.create_repo(repo_name, exist_ok=True).repo_id
+
+            with open(os.path.join(args.output_dir, ".gitignore"), "w+") as gitignore:
+                if "step_*" not in gitignore:
+                    gitignore.write("step_*\n")
+                if "epoch_*" not in gitignore:
+                    gitignore.write("epoch_*\n")
+        elif args.output_dir is not None:
+            os.makedirs(args.output_dir, exist_ok=True)
+    accelerator.wait_for_everyone()
+
+    # Get the datasets: you can either provide your own CSV/JSON/TXT training and evaluation files (see below)
+    # or just provide the name of one of the public datasets available on the hub at https://huggingface.co/datasets/
+    # (the dataset will be downloaded automatically from the datasets Hub).
+    #
+    # For CSV/JSON files, this script will use the column called 'text' or the first column if no column called
+    # 'text' is found. You can easily tweak this behavior (see below).
+    #
+    # In distributed training, the load_dataset function guarantee that only one local process can concurrently
+    # download the dataset.
+    if args.dataset_name is not None:
+        # Downloading and loading a dataset from the hub.
+        raw_datasets = load_dataset(args.dataset_name, args.dataset_config_name)
+        if "validation" not in raw_datasets.keys():
+            raw_datasets["validation"] = load_dataset(
+                args.dataset_name,
+                args.dataset_config_name,
+                split=f"train[:{args.validation_split_percentage}%]",
+            )
+            raw_datasets["train"] = load_dataset(
+                args.dataset_name,
+                args.dataset_config_name,
+                split=f"train[{args.validation_split_percentage}%:]",
+            )
+    else:
+        data_files = {}
+        dataset_args = {}
+        if args.train_file is not None:
+            data_files["train"] = args.train_file
+        if args.validation_file is not None:
+            data_files["validation"] = args.validation_file
+        extension = args.train_file.split(".")[-1]
+        if extension == "txt":
+            extension = "text"
+            dataset_args["keep_linebreaks"] = not args.no_keep_linebreaks
+        raw_datasets = load_dataset(extension, data_files=data_files, **dataset_args)
+        # If no validation data is there, validation_split_percentage will be used to divide the dataset.
+        if "validation" not in raw_datasets.keys():
+            raw_datasets["validation"] = load_dataset(
+                extension,
+                data_files=data_files,
+                split=f"train[:{args.validation_split_percentage}%]",
+                **dataset_args,
+            )
+            raw_datasets["train"] = load_dataset(
+                extension,
+                data_files=data_files,
+                split=f"train[{args.validation_split_percentage}%:]",
+                **dataset_args,
+            )
+
+    # See more about loading any type of standard or custom dataset (from files, python dict, pandas DataFrame, etc) at
+    # https://huggingface.co/docs/datasets/loading_datasets.html.
+
+    # Load pretrained model and tokenizer
+    #
+    # In distributed training, the .from_pretrained methods guarantee that only one local process can concurrently
+    # download model & vocab.
+    if args.config_name:
+        config = AutoConfig.from_pretrained(
+            args.config_name,
+            trust_remote_code=args.trust_remote_code,
+        )
+    elif args.model_name_or_path:
+        config = AutoConfig.from_pretrained(
+            args.model_name_or_path,
+            trust_remote_code=args.trust_remote_code,
+        )
+    else:
+        config = CONFIG_MAPPING[args.model_type]()
+        logger.warning("You are instantiating a new config instance from scratch.")
+
+    if args.tokenizer_name:
+        tokenizer = AutoTokenizer.from_pretrained(
+            args.tokenizer_name, use_fast=not args.use_slow_tokenizer, trust_remote_code=args.trust_remote_code
+        )
+    elif args.model_name_or_path:
+        tokenizer = AutoTokenizer.from_pretrained(
+            args.model_name_or_path,
+            use_fast=not args.use_slow_tokenizer,
+            trust_remote_code=args.trust_remote_code,
+        )
+    else:
+        raise ValueError(
+            "You are instantiating a new tokenizer from scratch. This is not supported by this script."
+            "You can do it from another script, save it, and load it from here, using --tokenizer_name."
+        )
+
+    ##########################
+    #        Tokenizer       #
+    ##########################
+    tokenizer.pad_token_id = 0  # unk. we want this to be different from the eos token
+    tokenizer.padding_side = "left"  # Allow batched inference
+    tokenizer.truncation_side = "left"
+
+    if args.model_name_or_path:
+        model = AutoModelForCausalLM.from_pretrained(
+            args.model_name_or_path,
+            from_tf=bool(".ckpt" in args.model_name_or_path),
+            config=config,
+            low_cpu_mem_usage=True,
+            quantization_config=BitsAndBytesConfig(
+                load_in_4bit=True,
+                bnb_4bit_use_double_quant=False,
+                bnb_4bit_quant_type="nf4",
+                bnb_4bit_compute_dtype=config.dtype,
+            ),
+        )
+    else:
+        logger.info("Training new model from scratch")
+        model = AutoModelForCausalLM.from_config(config, trust_remote_code=args.trust_remote_code)
+
+    ##########################
+    #       Peft Model       #
+    ##########################
+    if args.adapter_name_or_path is None:
+        model = PeftModel.from_pretrained(model, args.model_name_or_path, subfolder="loftq_init", is_trainable=True)
+    else:
+        model = PeftModel.from_pretrained(model, args.adapter_name_or_path, is_trainable=True)
+    model.print_trainable_parameters()
+
+    # We resize the embeddings only when necessary to avoid index errors. If you are creating a model from scratch
+    # on a small vocab and want a smaller embedding size, remove this test.
+    embedding_size = model.get_input_embeddings().weight.shape[0]
+    if len(tokenizer) > embedding_size:
+        model.resize_token_embeddings(len(tokenizer))
+
+    # Preprocessing the datasets.
+    # First we tokenize all the texts.
+    ##########################
+    #      GSM8K dataset     #
+    ##########################
+
+    # Preprocessing the datasets.
+    # First we tokenize all the texts.
+    column_names = raw_datasets["train"].column_names
+
+    # Get the column names for source/target.
+    source_column, target_column = "question", "answer"
+
+    # Temporarily set max_target_length for training.
+    padding = "max_length" if args.pad_to_max_length else False
+    task_prompt = "\nAnswer the above question. First think step by step and then answer the final number.\n"
+
+    def prompt_process(sent_1, sent_2, prompt_1="", prompt_2="", prompt_3=""):
+        sent_2 = sent_2.replace("####", "The final answer is")
+        return prompt_1 + sent_1 + prompt_2 + sent_2 + prompt_3
+
+    def preprocess_function_train(examples):
+        sources = examples[source_column]
+        targets = examples[target_column]
+
+        inputs = [prompt_process(source, target, prompt_2=task_prompt) for (source, target) in zip(sources, targets)]
+
+        model_inputs = tokenizer(
+            inputs,
+            max_length=args.max_source_length + args.max_target_length,
+            padding=padding,
+            truncation=True,
+            return_tensors="pt",
+        )
+
+        labels = copy.deepcopy(model_inputs)
+
+        # If we are padding here, replace all tokenizer.pad_token_id in the labels by -100 when we want to ignore
+        # padding in the loss.
+        if padding == "max_length" and args.ignore_pad_token_for_loss:
+            # get the length of the target tokens. -1 to kick out the <BOS> token
+            target_tokens = tokenizer(targets, padding=False)
+            target_len = [len(label) - 1 for label in target_tokens["input_ids"]]
+
+            # don't calculate the loss from source and padding (left padding)
+            for i in range(len(labels["input_ids"])):
+                labels["input_ids"][i, : -target_len[i]] = -100
+
+        model_inputs["labels"] = labels["input_ids"]
+        return model_inputs
+
+    def preprocess_function_test(examples):
+        sources = examples[source_column]
+        labels = examples[target_column]
+
+        inputs = [source + task_prompt for source in sources]
+
+        model_inputs = tokenizer(inputs, max_length=args.max_source_length, padding=padding, truncation=True)
+        labels = tokenizer(labels, max_length=args.max_target_length, padding=padding, truncation=True)
+
+        model_inputs["labels"] = labels["input_ids"]
+
+        return model_inputs
+
+    with accelerator.main_process_first():
+        train_dataset = raw_datasets["train"].map(
+            preprocess_function_train,
+            batched=True,
+            num_proc=args.preprocessing_num_workers,
+            remove_columns=column_names,
+            load_from_cache_file=not args.overwrite_cache,
+            desc="Running tokenizer on training dataset",
+        )
+
+        eval_dataset = raw_datasets["test"].map(
+            preprocess_function_test,
+            batched=True,
+            num_proc=args.preprocessing_num_workers,
+            remove_columns=column_names,
+            load_from_cache_file=not args.overwrite_cache,
+            desc="Running tokenizer on test dataset",
+        )
+
+    # Log a few random samples from the set:
+    for index in random.sample(range(len(train_dataset)), 2):
+        logger.info(f"Sample {index} of the training set: {train_dataset[index]}.")
+    for index in random.sample(range(len(eval_dataset)), 2):
+        logger.info(f"Sample {index} of the validation set: {eval_dataset[index]}.")
+
+    # DataLoaders creation:
+    train_dataloader = DataLoader(
+        train_dataset, shuffle=True, collate_fn=default_data_collator, batch_size=args.per_device_train_batch_size
+    )
+    eval_dataloader = DataLoader(
+        eval_dataset, collate_fn=default_data_collator, batch_size=args.per_device_eval_batch_size
+    )
+
+    # Optimizer
+    # Split weights in two groups, one with weight decay and the other not.
+    no_decay = ["bias", "layer_norm.weight"]
+    optimizer_grouped_parameters = [
+        {
+            "params": [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay) and "lora" in n],
+            "weight_decay": args.weight_decay,
+        },
+        {
+            "params": [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay)],
+            "weight_decay": 0.0,
+        },
+    ]
+    optimizer = torch.optim.AdamW(optimizer_grouped_parameters, lr=args.learning_rate)
+
+    # Scheduler and math around the number of training steps.
+    overrode_max_train_steps = False
+    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+    if args.max_train_steps is None:
+        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+        overrode_max_train_steps = True
+
+    lr_scheduler = get_scheduler(
+        name=args.lr_scheduler_type,
+        optimizer=optimizer,
+        num_warmup_steps=args.num_warmup_steps * args.gradient_accumulation_steps,
+        num_training_steps=args.max_train_steps * args.gradient_accumulation_steps,
+    )
+
+    # Prepare everything with our `accelerator`.
+    model, optimizer, train_dataloader, eval_dataloader, lr_scheduler = accelerator.prepare(
+        model, optimizer, train_dataloader, eval_dataloader, lr_scheduler
+    )
+
+    # On TPU, the tie weights in our model have been disconnected, so we need to restore the ties.
+    if accelerator.distributed_type == DistributedType.TPU:
+        model.tie_weights()
+
+    # We need to recalculate our total training steps as the size of the training dataloader may have changed.
+    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+    if overrode_max_train_steps:
+        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+    # Afterwards we recalculate our number of training epochs
+    args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch)
+
+    # Figure out how many steps we should save the Accelerator states
+    checkpointing_steps = args.checkpointing_steps
+    if checkpointing_steps is not None and checkpointing_steps.isdigit():
+        checkpointing_steps = int(checkpointing_steps)
+
+    # We need to initialize the trackers we use, and also store our configuration.
+    # The trackers initializes automatically on the main process.
+    if args.with_tracking:
+        experiment_config = vars(args)
+        # TensorBoard cannot log Enums, need the raw value
+        experiment_config["lr_scheduler_type"] = experiment_config["lr_scheduler_type"].value
+        accelerator.init_trackers("clm_no_trainer", experiment_config)
+
+    # Train!
+    total_batch_size = args.per_device_train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps
+
+    logger.info("***** Running training *****")
+    logger.info(f"  Num examples = {len(train_dataset)}")
+    logger.info(f"  Num Epochs = {args.num_train_epochs}")
+    logger.info(f"  Instantaneous batch size per device = {args.per_device_train_batch_size}")
+    logger.info(f"  Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}")
+    logger.info(f"  Gradient Accumulation steps = {args.gradient_accumulation_steps}")
+    logger.info(f"  Total optimization steps = {args.max_train_steps}")
+    # Only show the progress bar once on each machine.
+    progress_bar = tqdm(range(args.max_train_steps), disable=not accelerator.is_local_main_process)
+    completed_steps = 0
+    starting_epoch = 0
+
+    # Potentially load in the weights and states from a previous save
+    if args.resume_from_checkpoint:
+        if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != "":
+            checkpoint_path = args.resume_from_checkpoint
+            path = os.path.basename(args.resume_from_checkpoint)
+        else:
+            # Get the most recent checkpoint
+            dirs = [f.name for f in os.scandir(os.getcwd()) if f.is_dir()]
+            dirs.sort(key=os.path.getctime)
+            path = dirs[-1]  # Sorts folders by date modified, most recent checkpoint is the last
+            checkpoint_path = path
+            path = os.path.basename(checkpoint_path)
+
+        accelerator.print(f"Resumed from checkpoint: {checkpoint_path}")
+        accelerator.load_state(path)
+        # Extract `epoch_{i}` or `step_{i}`
+        training_difference = os.path.splitext(path)[0]
+
+        if "epoch" in training_difference:
+            starting_epoch = int(training_difference.replace("epoch_", "")) + 1
+            resume_step = None
+            completed_steps = starting_epoch * num_update_steps_per_epoch
+        else:
+            # need to multiply `gradient_accumulation_steps` to reflect real steps
+            resume_step = int(training_difference.replace("step_", "")) * args.gradient_accumulation_steps
+            starting_epoch = resume_step // len(train_dataloader)
+            resume_step -= starting_epoch * len(train_dataloader)
+            completed_steps = resume_step // args.gradient_accumulation_steps
+
+    # update the progress_bar if load from checkpoint
+    progress_bar.update(completed_steps)
+
+    for epoch in range(starting_epoch, args.num_train_epochs):
+        model.train()
+        if args.with_tracking:
+            total_loss = 0
+        if args.resume_from_checkpoint and epoch == starting_epoch and resume_step is not None:
+            # We skip the first `n` batches in the dataloader when resuming from a checkpoint
+            active_dataloader = accelerator.skip_first_batches(train_dataloader, resume_step)
+        else:
+            active_dataloader = train_dataloader
+        for step, batch in enumerate(active_dataloader):
+            with accelerator.accumulate(model):
+                outputs = model(**batch)
+                loss = outputs.loss
+                # We keep track of the loss at each epoch
+                if args.with_tracking:
+                    total_loss += loss.detach().float()
+                accelerator.backward(loss)
+                if completed_steps % 50:
+                    accelerator.print(f"Epoch: {epoch} | Step: {completed_steps} | Loss: {loss}")
+                optimizer.step()
+                lr_scheduler.step()
+                optimizer.zero_grad()
+
+            # Checks if the accelerator has performed an optimization step behind the scenes
+            if accelerator.sync_gradients:
+                progress_bar.update(1)
+                completed_steps += 1
+
+            if isinstance(checkpointing_steps, int):
+                if completed_steps % checkpointing_steps == 0:
+                    output_dir = f"step_{completed_steps}"
+                    if args.output_dir is not None:
+                        output_dir = os.path.join(args.output_dir, output_dir)
+                    accelerator.save_state(output_dir)
+            if completed_steps >= args.max_train_steps:
+                break
+
+        model.eval()
+        gen_kwargs = {
+            "max_new_tokens": args.max_target_length,
+            "temperature": args.temperature,
+            "top_k": args.k,
+            "top_p": args.p,
+            "do_sample": True,
+        }
+        ans_pred_list = []
+        ans_gold_list = []
+        for step, batch in enumerate(eval_dataloader):
+            with torch.no_grad():
+                gen_kwargs["input_ids"] = batch["input_ids"]
+                gen_kwargs["attention_mask"] = batch["attention_mask"]
+                generated_tokens = accelerator.unwrap_model(model).generate(**gen_kwargs)
+
+            pred_tokens = generated_tokens[:, args.max_source_length :]
+            pred_tokens = accelerator.pad_across_processes(pred_tokens, dim=1, pad_index=tokenizer.pad_token_id)
+            gold_tokens = batch["labels"]
+
+            if not args.pad_to_max_length:
+                # If we did not pad to max length, we need to pad the labels too
+                gold_tokens = accelerator.pad_across_processes(
+                    batch["labels"], dim=1, pad_index=tokenizer.pad_token_id
+                )
+
+            pred_tokens, gold_tokens = accelerator.gather_for_metrics((pred_tokens, gold_tokens))
+            pred_tokens, gold_tokens = pred_tokens.cpu().numpy(), gold_tokens.cpu().numpy()
+
+            if isinstance(pred_tokens, tuple):
+                pred_tokens = pred_tokens[0]
+            decoded_pred = tokenizer.batch_decode(pred_tokens, skip_special_tokens=True)
+            decoded_gold = tokenizer.batch_decode(gold_tokens, skip_special_tokens=True)
+
+            # Extract the numbers in sentences
+            accelerator.print(decoded_pred)
+            ans_pred_list += [extract_answer_number(sentence_pred) for sentence_pred in decoded_pred]
+            ans_gold_list += [extract_answer_number(sentence_gold) for sentence_gold in decoded_gold]
+
+        accelerator.print(ans_pred_list)
+        accelerator.print(ans_gold_list)
+        accuracy = compute_accuracy(ans_gold_list, ans_pred_list)
+
+        logger.info(f"epoch {epoch}: accuracy: {accuracy}")
+
+        if args.with_tracking:
+            accelerator.log(
+                {
+                    "accuracy": accuracy,
+                    "train_loss": total_loss.item() / len(train_dataloader),
+                    "epoch": epoch,
+                    "step": completed_steps,
+                },
+                step=completed_steps,
+            )
+
+        if args.push_to_hub and epoch < args.num_train_epochs - 1:
+            accelerator.wait_for_everyone()
+            unwrapped_model = accelerator.unwrap_model(model)
+            unwrapped_model.save_pretrained(
+                args.output_dir, is_main_process=accelerator.is_main_process, save_function=accelerator.save
+            )
+            if accelerator.is_main_process:
+                tokenizer.save_pretrained(args.output_dir)
+                api.upload_folder(
+                    repo_id=repo_id,
+                    folder_path=args.output_dir,
+                    commit_message=f"Training in progress epoch {epoch}",
+                    run_as_future=True,
+                )
+
+        if args.checkpointing_steps == "epoch":
+            output_dir = f"epoch_{epoch}"
+            if args.output_dir is not None:
+                output_dir = os.path.join(args.output_dir, output_dir)
+            accelerator.save_state(output_dir)
+
+    if args.with_tracking:
+        accelerator.end_training()
+
+    if args.output_dir is not None:
+        accelerator.wait_for_everyone()
+        unwrapped_model = accelerator.unwrap_model(model)
+        unwrapped_model.save_pretrained(
+            args.output_dir, is_main_process=accelerator.is_main_process, save_function=accelerator.save
+        )
+        if accelerator.is_main_process:
+            tokenizer.save_pretrained(args.output_dir)
+            if args.push_to_hub:
+                api.upload_folder(
+                    repo_id=repo_id,
+                    folder_path=args.output_dir,
+                    commit_message="End of training",
+                )
+
+
+PATTERN_NUMBER = re.compile(r"-?\d+\.?\d*")
+
+
+def extract_answer_number(sentence: str) -> float:
+    sentence = sentence.replace(",", "")
+    pred = PATTERN_NUMBER.findall(sentence)
+    if not pred:
+        return float("inf")
+    segment = sentence.split("The final answer is ")
+    if len(segment) > 1:
+        pred_answer = segment[1]
+        pred_answer = PATTERN_NUMBER.findall(pred_answer)
+        if len(pred_answer) > 0:
+            pred_answer = pred_answer[0]
+        else:
+            pred_answer = float(pred[-1])
+    else:
+        pred_answer = float(pred[-1])
+
+    if isinstance(pred_answer, str):
+        try:
+            pred_answer = float(pred_answer)
+        except ValueError:
+            pred_answer = float("inf")
+    return pred_answer
+
+
+def compute_accuracy(pred: list, gold: list):
+    acc = 0.0
+    for p, g in zip(pred, gold):
+        if p == g:
+            acc += 1
+
+    return acc / len(pred)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/lora_dreambooth/colab_notebook.ipynb b/examples/lora_dreambooth/colab_notebook.ipynb
new file mode 100644
index 0000000..91ac558
--- /dev/null
+++ b/examples/lora_dreambooth/colab_notebook.ipynb
@@ -0,0 +1,54 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "kdOhtpergLCQ"
+      },
+      "outputs": [],
+      "source": [
+        "!git clone https://huggingface.co/spaces/smangrul/peft-lora-sd-dreambooth"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "_LuGk9mihPx7"
+      },
+      "outputs": [],
+      "source": [
+        "%cd \"peft-lora-sd-dreambooth\"\n",
+        "!pip install -r requirements.txt"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "BYKO8e5ElJOX"
+      },
+      "outputs": [],
+      "source": [
+        "!python colab.py"
+      ]
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "provenance": []
+    },
+    "gpuClass": "premium",
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
diff --git a/examples/lora_dreambooth/convert_kohya_ss_sd_lora_to_peft.py b/examples/lora_dreambooth/convert_kohya_ss_sd_lora_to_peft.py
new file mode 100644
index 0000000..a691ba7
--- /dev/null
+++ b/examples/lora_dreambooth/convert_kohya_ss_sd_lora_to_peft.py
@@ -0,0 +1,175 @@
+import argparse
+import os
+from collections import Counter
+from dataclasses import dataclass
+from typing import Optional
+
+import safetensors
+import torch
+from diffusers import UNet2DConditionModel
+from transformers import CLIPTextModel
+
+from peft import LoraConfig, get_peft_model, get_peft_model_state_dict, set_peft_model_state_dict
+
+
+# Default kohya_ss LoRA replacement modules
+# https://github.com/kohya-ss/sd-scripts/blob/c924c47f374ac1b6e33e71f82948eb1853e2243f/networks/lora.py#L661
+UNET_TARGET_REPLACE_MODULE = ["Transformer2DModel", "Attention"]
+UNET_TARGET_REPLACE_MODULE_CONV2D_3X3 = ["ResnetBlock2D", "Downsample2D", "Upsample2D"]
+TEXT_ENCODER_TARGET_REPLACE_MODULE = ["CLIPAttention", "CLIPMLP"]
+LORA_PREFIX_UNET = "lora_unet"
+LORA_PREFIX_TEXT_ENCODER = "lora_te"
+
+
+@dataclass
+class LoRAInfo:
+    kohya_key: str
+    peft_key: str
+    alpha: Optional[float] = None
+    rank: Optional[int] = None
+    lora_A: Optional[torch.Tensor] = None
+    lora_B: Optional[torch.Tensor] = None
+
+    def peft_state_dict(self) -> dict[str, torch.Tensor]:
+        if self.lora_A is None or self.lora_B is None:
+            raise ValueError("At least one of lora_A or lora_B is None, they must both be provided")
+        return {f"{peft_key}.lora_A.weight": self.lora_A, f"{peft_key}.lora_B.weight": self.lora_A}
+
+
+def construct_peft_loraconfig(info: dict[str, LoRAInfo]) -> LoraConfig:
+    """Constructs LoraConfig from data extracted from kohya checkpoint
+
+    Args:
+        info (Dict[str, LoRAInfo]): Information extracted from kohya checkpoint
+
+    Returns:
+        LoraConfig: config for constructing LoRA
+    """
+
+    # Unpack all ranks and alphas
+    ranks = {x[0]: x[1].rank for x in info.items()}
+    alphas = {x[0]: x[1].alpha or x[1].rank for x in info.items()}
+
+    # Determine which modules needs to be transformed
+    target_modules = list(info.keys())
+
+    # Determine most common rank and alpha
+    r = Counter(ranks.values()).most_common(1)[0]
+    lora_alpha = Counter(alphas.values()).most_common(1)[0]
+
+    # Determine which modules have different rank and alpha
+    rank_pattern = dict(filter(lambda x: x[1] != r, ranks.items()))
+    alpha_pattern = dict(filter(lambda x: x[1] != lora_alpha, alphas.items()))
+
+    config = LoraConfig(
+        r=r,
+        lora_alpha=lora_alpha,
+        target_modules=target_modules,
+        lora_dropout=0.0,
+        bias="none",
+        init_lora_weights=False,
+        rank_pattern=rank_pattern,
+        alpha_pattern=alpha_pattern,
+    )
+
+    return config
+
+
+def combine_peft_state_dict(info: dict[str, LoRAInfo]) -> dict[str, torch.Tensor]:
+    result = {}
+    for key_name, key_info in info.items():
+        result[f"base_model.model.{key_name}.lora_A.weight"] = key_info.lora_A
+        result[f"base_model.model.{key_name}.lora_B.weight"] = key_info.lora_B
+    return result
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument("--sd_checkpoint", default=None, type=str, required=True, help="SD checkpoint to use")
+
+    parser.add_argument(
+        "--kohya_lora_path", default=None, type=str, required=True, help="Path to kohya_ss trained LoRA"
+    )
+
+    parser.add_argument("--dump_path", default=None, type=str, required=True, help="Path to the output model.")
+
+    parser.add_argument("--half", action="store_true", help="Save weights in half precision.")
+    args = parser.parse_args()
+
+    # Load all models that we need to add adapter to
+    text_encoder = CLIPTextModel.from_pretrained(args.sd_checkpoint, subfolder="text_encoder")
+    unet = UNet2DConditionModel.from_pretrained(args.sd_checkpoint, subfolder="unet")
+
+    # Construct possible mapping from kohya keys to peft keys
+    models_keys = {}
+    for model, model_key, model_name in [
+        (text_encoder, LORA_PREFIX_TEXT_ENCODER, "text_encoder"),
+        (unet, LORA_PREFIX_UNET, "unet"),
+    ]:
+        models_keys.update(
+            {
+                f"{model_key}.{peft_key}".replace(".", "_"): peft_key
+                for peft_key in (x[0] for x in model.named_modules())
+            }
+        )
+
+    # Store conversion info (model_type -> peft_key -> LoRAInfo)
+    lora_info: dict[str, dict[str, LoRAInfo]] = {
+        "text_encoder": {},
+        "unet": {},
+    }
+
+    # Open kohya_ss checkpoint
+    with safetensors.safe_open(args.kohya_lora_path, framework="pt", device="cpu") as f:
+        # Extract information about LoRA structure
+        metadata = f.metadata()
+
+        # Iterate through available info and unpack all the values
+        for key in f.keys():
+            kohya_key, kohya_type = key.split(".")[:2]
+
+            # Find which model this key belongs to
+            if kohya_key.startswith(LORA_PREFIX_TEXT_ENCODER):
+                model_type = "text_encoder"
+            elif kohya_key.startswith(LORA_PREFIX_UNET):
+                model_type = "unet"
+            else:
+                raise ValueError(f"Cannot determine model for key: {key}")
+
+            # Find corresponding peft key
+            if kohya_key not in models_keys:
+                raise ValueError(f"Cannot find corresponding key for diffusers/transformers model: {kohya_key}")
+            peft_key = models_keys[kohya_key]
+
+            if peft_key not in lora_info[model_type]:
+                lora_info[model_type][peft_key] = LoRAInfo(kohya_key=kohya_key, peft_key=peft_key)
+
+            if kohya_type == "alpha":
+                lora_info[model_type][peft_key].alpha = f.get_tensor(key).item()
+            elif kohya_type == "lora_down":
+                tensor = f.get_tensor(key)
+                lora_info[model_type][peft_key].lora_A = tensor
+                lora_info[model_type][peft_key].rank = tensor.shape[0]
+            elif kohya_type == "lora_up":
+                tensor = f.get_tensor(key)
+                lora_info[model_type][peft_key].lora_B = f.get_tensor(key)
+                lora_info[model_type][peft_key].rank = tensor.shape[1]
+            else:
+                raise ValueError(f"Unknown weight name in key: {key} - {kohya_type}")
+
+    # Process each model
+    for model, model_name in [(text_encoder, "text_encoder"), (unet, "unet")]:
+        config = construct_peft_loraconfig(lora_info[model_name])
+        model = get_peft_model(model, config)
+
+        keys_peft = list(get_peft_model_state_dict(model).keys())
+        keys_new = list(combine_peft_state_dict(lora_info[model_name]).keys())
+
+        set_peft_model_state_dict(model, combine_peft_state_dict(lora_info[model_name]))
+
+        if args.half:
+            model.to(torch.float16)
+
+        # Save model to disk
+        model.save_pretrained(os.path.join(args.dump_path, model_name))
diff --git a/examples/lora_dreambooth/convert_peft_sd_lora_to_kohya_ss.py b/examples/lora_dreambooth/convert_peft_sd_lora_to_kohya_ss.py
new file mode 100644
index 0000000..97f9648
--- /dev/null
+++ b/examples/lora_dreambooth/convert_peft_sd_lora_to_kohya_ss.py
@@ -0,0 +1,100 @@
+import argparse
+import os
+
+import torch
+from diffusers import UNet2DConditionModel
+from safetensors.torch import save_file
+from transformers import CLIPTextModel
+
+from peft import PeftModel, get_peft_model_state_dict
+
+
+# Default kohya_ss LoRA replacement modules
+# https://github.com/kohya-ss/sd-scripts/blob/c924c47f374ac1b6e33e71f82948eb1853e2243f/networks/lora.py#L664
+LORA_PREFIX_UNET = "lora_unet"
+LORA_PREFIX_TEXT_ENCODER = "lora_te"
+LORA_ADAPTER_NAME = "default"
+
+
+def get_module_kohya_state_dict(
+    module: PeftModel, prefix: str, dtype: torch.dtype, adapter_name: str = LORA_ADAPTER_NAME
+) -> dict[str, torch.Tensor]:
+    kohya_ss_state_dict = {}
+    for peft_key, weight in get_peft_model_state_dict(module, adapter_name=adapter_name).items():
+        kohya_key = peft_key.replace("base_model.model", prefix)
+        kohya_key = kohya_key.replace("lora_A", "lora_down")
+        kohya_key = kohya_key.replace("lora_B", "lora_up")
+        kohya_key = kohya_key.replace(".", "_", kohya_key.count(".") - 2)
+        kohya_ss_state_dict[kohya_key] = weight.to(dtype)
+
+        # Set alpha parameter
+        if "lora_down" in kohya_key:
+            alpha_key = f"{kohya_key.split('.')[0]}.alpha"
+            kohya_ss_state_dict[alpha_key] = torch.tensor(module.peft_config[adapter_name].lora_alpha).to(dtype)
+
+    return kohya_ss_state_dict
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument(
+        "--sd_checkpoint",
+        default=None,
+        type=str,
+        required=True,
+        help="Path to pretrained model or model identifier from huggingface.co/models.",
+    )
+
+    parser.add_argument(
+        "--sd_checkpoint_revision",
+        type=str,
+        default=None,
+        required=False,
+        help="Revision of pretrained model identifier from huggingface.co/models.",
+    )
+
+    parser.add_argument("--peft_lora_path", default=None, type=str, required=True, help="Path to peft trained LoRA")
+
+    parser.add_argument(
+        "--dump_path",
+        default=None,
+        type=str,
+        required=True,
+        help="Path to the output safetensors file for use with webui.",
+    )
+
+    parser.add_argument("--half", action="store_true", help="Save weights in half precision.")
+    args = parser.parse_args()
+
+    # Store kohya_ss state dict
+    kohya_ss_state_dict = {}
+    dtype = torch.float16 if args.half else torch.float32
+
+    # Load Text Encoder LoRA model
+    text_encoder_peft_lora_path = os.path.join(args.peft_lora_path, "text_encoder")
+    if os.path.exists(text_encoder_peft_lora_path):
+        text_encoder = CLIPTextModel.from_pretrained(
+            args.sd_checkpoint, subfolder="text_encoder", revision=args.sd_checkpoint_revision
+        )
+        text_encoder = PeftModel.from_pretrained(
+            text_encoder, text_encoder_peft_lora_path, adapter_name=LORA_ADAPTER_NAME
+        )
+        kohya_ss_state_dict.update(
+            get_module_kohya_state_dict(text_encoder, LORA_PREFIX_TEXT_ENCODER, dtype, LORA_ADAPTER_NAME)
+        )
+
+    # Load UNet LoRA model
+    unet_peft_lora_path = os.path.join(args.peft_lora_path, "unet")
+    if os.path.exists(unet_peft_lora_path):
+        unet = UNet2DConditionModel.from_pretrained(
+            args.sd_checkpoint, subfolder="unet", revision=args.sd_checkpoint_revision
+        )
+        unet = PeftModel.from_pretrained(unet, unet_peft_lora_path, adapter_name=LORA_ADAPTER_NAME)
+        kohya_ss_state_dict.update(get_module_kohya_state_dict(unet, LORA_PREFIX_UNET, dtype, LORA_ADAPTER_NAME))
+
+    # Save state dict
+    save_file(
+        kohya_ss_state_dict,
+        args.dump_path,
+    )
diff --git a/examples/lora_dreambooth/lora_dreambooth_inference.ipynb b/examples/lora_dreambooth/lora_dreambooth_inference.ipynb
new file mode 100644
index 0000000..a94358c
--- /dev/null
+++ b/examples/lora_dreambooth/lora_dreambooth_inference.ipynb
@@ -0,0 +1,497 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "acab479f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "===================================BUG REPORT===================================\n",
+      "Welcome to bitsandbytes. For bug reports, please submit your error trace to: https://github.com/TimDettmers/bitsandbytes/issues\n",
+      "================================================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "import argparse\n",
+    "import gc\n",
+    "import hashlib\n",
+    "import itertools\n",
+    "import logging\n",
+    "import math\n",
+    "import os\n",
+    "import threading\n",
+    "import warnings\n",
+    "from pathlib import Path\n",
+    "from typing import Optional\n",
+    "import psutil\n",
+    "import json\n",
+    "\n",
+    "import torch\n",
+    "import torch.nn.functional as F\n",
+    "import torch.utils.checkpoint\n",
+    "from torch.utils.data import Dataset\n",
+    "\n",
+    "import datasets\n",
+    "import diffusers\n",
+    "import transformers\n",
+    "from accelerate import Accelerator\n",
+    "from accelerate.logging import get_logger\n",
+    "from accelerate.utils import set_seed\n",
+    "from diffusers import AutoencoderKL, DDPMScheduler, DiffusionPipeline, UNet2DConditionModel\n",
+    "from diffusers import DDPMScheduler, PNDMScheduler, StableDiffusionPipeline\n",
+    "from diffusers.pipelines.stable_diffusion import StableDiffusionSafetyChecker\n",
+    "from diffusers.optimization import get_scheduler\n",
+    "from diffusers.utils import check_min_version\n",
+    "from diffusers.utils.import_utils import is_xformers_available\n",
+    "from huggingface_hub import HfFolder, Repository, whoami\n",
+    "from PIL import Image\n",
+    "from torchvision import transforms\n",
+    "from tqdm.auto import tqdm\n",
+    "from transformers import AutoTokenizer, PretrainedConfig, CLIPFeatureExtractor\n",
+    "from peft import PeftModel, LoraConfig, get_peft_model_state_dict, set_peft_model_state_dict\n",
+    "\n",
+    "# Will error if the minimal version of diffusers is not installed. Remove at your own risks.\n",
+    "check_min_version(\"0.10.0.dev0\")\n",
+    "\n",
+    "logger = get_logger(__name__)\n",
+    "\n",
+    "\n",
+    "MODEL_NAME = \"CompVis/stable-diffusion-v1-4\"  # \"stabilityai/stable-diffusion-2-1-base\"\n",
+    "INSTANCE_PROMPT = \"a photo of sks dog\"\n",
+    "base_path = \"/home/sourab/temp/\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "06cfd506",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_lora_sd_pipeline(\n",
+    "    ckpt_dir, base_model_name_or_path=None, dtype=torch.float16, device=\"auto\", adapter_name=\"default\"\n",
+    "):\n",
+    "    if device == \"auto\":\n",
+    "        device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "\n",
+    "    unet_sub_dir = os.path.join(ckpt_dir, \"unet\")\n",
+    "    text_encoder_sub_dir = os.path.join(ckpt_dir, \"text_encoder\")\n",
+    "    if os.path.exists(text_encoder_sub_dir) and base_model_name_or_path is None:\n",
+    "        config = LoraConfig.from_pretrained(text_encoder_sub_dir)\n",
+    "        base_model_name_or_path = config.base_model_name_or_path\n",
+    "\n",
+    "    if base_model_name_or_path is None:\n",
+    "        raise ValueError(\"Please specify the base model name or path\")\n",
+    "\n",
+    "    pipe = StableDiffusionPipeline.from_pretrained(\n",
+    "        base_model_name_or_path, torch_dtype=dtype, requires_safety_checker=False\n",
+    "    ).to(device)\n",
+    "    pipe.unet = PeftModel.from_pretrained(pipe.unet, unet_sub_dir, adapter_name=adapter_name)\n",
+    "\n",
+    "    if os.path.exists(text_encoder_sub_dir):\n",
+    "        pipe.text_encoder = PeftModel.from_pretrained(\n",
+    "            pipe.text_encoder, text_encoder_sub_dir, adapter_name=adapter_name\n",
+    "        )\n",
+    "\n",
+    "    if dtype in (torch.float16, torch.bfloat16):\n",
+    "        pipe.unet.half()\n",
+    "        pipe.text_encoder.half()\n",
+    "\n",
+    "    pipe.to(device)\n",
+    "    return pipe\n",
+    "\n",
+    "\n",
+    "def load_adapter(pipe, ckpt_dir, adapter_name):\n",
+    "    unet_sub_dir = os.path.join(ckpt_dir, \"unet\")\n",
+    "    text_encoder_sub_dir = os.path.join(ckpt_dir, \"text_encoder\")\n",
+    "    pipe.unet.load_adapter(unet_sub_dir, adapter_name=adapter_name)\n",
+    "    if os.path.exists(text_encoder_sub_dir):\n",
+    "        pipe.text_encoder.load_adapter(text_encoder_sub_dir, adapter_name=adapter_name)\n",
+    "\n",
+    "\n",
+    "def set_adapter(pipe, adapter_name):\n",
+    "    pipe.unet.set_adapter(adapter_name)\n",
+    "    if isinstance(pipe.text_encoder, PeftModel):\n",
+    "        pipe.text_encoder.set_adapter(adapter_name)\n",
+    "\n",
+    "\n",
+    "def merging_lora_with_base(pipe, ckpt_dir, adapter_name=\"default\"):\n",
+    "    unet_sub_dir = os.path.join(ckpt_dir, \"unet\")\n",
+    "    text_encoder_sub_dir = os.path.join(ckpt_dir, \"text_encoder\")\n",
+    "    if isinstance(pipe.unet, PeftModel):\n",
+    "        pipe.unet.set_adapter(adapter_name)\n",
+    "    else:\n",
+    "        pipe.unet = PeftModel.from_pretrained(pipe.unet, unet_sub_dir, adapter_name=adapter_name)\n",
+    "    pipe.unet = pipe.unet.merge_and_unload()\n",
+    "\n",
+    "    if os.path.exists(text_encoder_sub_dir):\n",
+    "        if isinstance(pipe.text_encoder, PeftModel):\n",
+    "            pipe.text_encoder.set_adapter(adapter_name)\n",
+    "        else:\n",
+    "            pipe.text_encoder = PeftModel.from_pretrained(\n",
+    "                pipe.text_encoder, text_encoder_sub_dir, adapter_name=adapter_name\n",
+    "            )\n",
+    "        pipe.text_encoder = pipe.text_encoder.merge_and_unload()\n",
+    "\n",
+    "    return pipe\n",
+    "\n",
+    "\n",
+    "def create_weighted_lora_adapter(pipe, adapters, weights, adapter_name=\"default\"):\n",
+    "    pipe.unet.add_weighted_adapter(adapters, weights, adapter_name)\n",
+    "    if isinstance(pipe.text_encoder, PeftModel):\n",
+    "        pipe.text_encoder.add_weighted_adapter(adapters, weights, adapter_name)\n",
+    "\n",
+    "    return pipe"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "d4e888d2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "9f12b2cca0784cba9dc14ec48de929d5",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Fetching 19 files:   0%|          | 0/19 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "`text_config_dict` is provided which will be used to initialize `CLIPTextConfig`. The value `text_config[\"id2label\"]` will be overridden.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 13.2 s, sys: 7.55 s, total: 20.8 s\n",
+      "Wall time: 5.89 s\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "pipe = get_lora_sd_pipeline(os.path.join(base_path, \"dog_dreambooth_updated\"), adapter_name=\"dog\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "22012468",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 90 ms, sys: 890 µs, total: 90.9 ms\n",
+      "Wall time: 90.2 ms\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "load_adapter(pipe, os.path.join(base_path, \"toy_dreambooth\"), adapter_name=\"toy\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "4ae4a74e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pipe = create_weighted_lora_adapter(pipe, [\"toy\", \"dog\"], [1.0, 1.05], adapter_name=\"toy_dog\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "9b8e2c69",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 5.74 ms, sys: 373 µs, total: 6.11 ms\n",
+      "Wall time: 6.04 ms\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "set_adapter(pipe, adapter_name=\"dog\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "6d8b5e5d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2234aaa88bd34c898e175d8280ee6d4d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/50 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<PIL.Image.Image image mode=RGB size=512x512>"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "prompt = \"sks dog playing fetch in the park\"\n",
+    "negative_prompt = \"low quality, blurry, unfinished\"\n",
+    "image = pipe(prompt, num_inference_steps=50, guidance_scale=7, negative_prompt=negative_prompt).images[0]\n",
+    "image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "1e1d1f30",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 7.74 ms, sys: 0 ns, total: 7.74 ms\n",
+      "Wall time: 7.31 ms\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "set_adapter(pipe, adapter_name=\"toy\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "0c50c03d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "4f978437709b44b391744cf972415027",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/50 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<PIL.Image.Image image mode=RGB size=512x512>"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "prompt = \"narendra modi rendered in the style of <1>\"\n",
+    "negative_prompt = \"low quality, blurry, unfinished\"\n",
+    "image = pipe(prompt, num_inference_steps=50, guidance_scale=7, negative_prompt=negative_prompt).images[0]\n",
+    "image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "e3b9a681",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "8871731127904802ba6123128ba22ecf",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/50 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<PIL.Image.Image image mode=RGB size=512x512>"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "set_adapter(pipe, adapter_name=\"dog\")\n",
+    "prompt = \"sks dog in a big red bucket\"\n",
+    "negative_prompt = \"low quality, blurry, unfinished\"\n",
+    "image = pipe(prompt, num_inference_steps=50, guidance_scale=7, negative_prompt=negative_prompt).images[0]\n",
+    "image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "a659ca6e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b701336557e4417d8d39d500699c298b",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/50 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<PIL.Image.Image image mode=RGB size=512x512>"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "set_adapter(pipe, adapter_name=\"toy\")\n",
+    "prompt = \"superman rendered in the style of <1>, close up potrait\"\n",
+    "negative_prompt = \"low quality, blurry, unfinished\"\n",
+    "image = pipe(prompt, num_inference_steps=50, guidance_scale=7, negative_prompt=negative_prompt).images[0]\n",
+    "image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "1f0ecb40",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b47385e953b14c768d82bea776129904",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/50 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<PIL.Image.Image image mode=RGB size=512x512>"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "set_adapter(pipe, adapter_name=\"toy_dog\")\n",
+    "prompt = \"sks dog rendered in the style of <1>, close up potrait, 4K HD\"\n",
+    "negative_prompt = \"low quality, blurry, unfinished\"\n",
+    "image = pipe(prompt, num_inference_steps=50, guidance_scale=7, negative_prompt=negative_prompt).images[0]\n",
+    "image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "29720cdb",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.4"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/lora_dreambooth/requirements.txt b/examples/lora_dreambooth/requirements.txt
new file mode 100644
index 0000000..ec1a3dc
--- /dev/null
+++ b/examples/lora_dreambooth/requirements.txt
@@ -0,0 +1,11 @@
+transformers
+accelerate
+evaluate
+tqdm
+datasets
+diffusers
+Pillow
+torchvision
+huggingface_hub
+safetensors
+wandb
\ No newline at end of file
diff --git a/examples/lora_dreambooth/train_dreambooth.py b/examples/lora_dreambooth/train_dreambooth.py
new file mode 100644
index 0000000..a5648f2
--- /dev/null
+++ b/examples/lora_dreambooth/train_dreambooth.py
@@ -0,0 +1,1107 @@
+import argparse
+import gc
+import hashlib
+import itertools
+import logging
+import math
+import os
+import threading
+import warnings
+from contextlib import nullcontext
+from pathlib import Path
+
+import datasets
+import diffusers
+import numpy as np
+import psutil
+import torch
+import torch.nn.functional as F
+import torch.utils.checkpoint
+import transformers
+from accelerate import Accelerator
+from accelerate.logging import get_logger
+from accelerate.utils import set_seed
+from diffusers import (
+    AutoencoderKL,
+    DDPMScheduler,
+    DiffusionPipeline,
+    DPMSolverMultistepScheduler,
+    UNet2DConditionModel,
+)
+from diffusers.optimization import get_scheduler
+from diffusers.utils import check_min_version
+from diffusers.utils.import_utils import is_xformers_available
+from huggingface_hub import HfApi
+from PIL import Image
+from torch.utils.data import Dataset
+from torchvision import transforms
+from tqdm.auto import tqdm
+from transformers import AutoTokenizer, PretrainedConfig
+
+from peft import LoraConfig, get_peft_model
+
+
+# Will error if the minimal version of diffusers is not installed. Remove at your own risks.
+check_min_version("0.10.0.dev0")
+
+logger = get_logger(__name__)
+
+UNET_TARGET_MODULES = ["to_q", "to_v", "query", "value"]  # , "ff.net.0.proj"]
+TEXT_ENCODER_TARGET_MODULES = ["q_proj", "v_proj"]
+
+
+def import_model_class_from_model_name_or_path(pretrained_model_name_or_path: str, revision: str):
+    text_encoder_config = PretrainedConfig.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="text_encoder",
+        revision=revision,
+    )
+    model_class = text_encoder_config.architectures[0]
+
+    if model_class == "CLIPTextModel":
+        from transformers import CLIPTextModel
+
+        return CLIPTextModel
+    elif model_class == "RobertaSeriesModelWithTransformation":
+        from diffusers.pipelines.alt_diffusion.modeling_roberta_series import RobertaSeriesModelWithTransformation
+
+        return RobertaSeriesModelWithTransformation
+    else:
+        raise ValueError(f"{model_class} is not supported.")
+
+
+def parse_args(input_args=None):
+    parser = argparse.ArgumentParser(description="Simple example of a training script.")
+    parser.add_argument(
+        "--pretrained_model_name_or_path",
+        type=str,
+        default=None,
+        required=True,
+        help="Path to pretrained model or model identifier from huggingface.co/models.",
+    )
+    parser.add_argument(
+        "--revision",
+        type=str,
+        default=None,
+        required=False,
+        help="Revision of pretrained model identifier from huggingface.co/models.",
+    )
+    parser.add_argument(
+        "--tokenizer_name",
+        type=str,
+        default=None,
+        help="Pretrained tokenizer name or path if not the same as model_name",
+    )
+    parser.add_argument(
+        "--instance_data_dir",
+        type=str,
+        default=None,
+        required=True,
+        help="A folder containing the training data of instance images.",
+    )
+    parser.add_argument(
+        "--class_data_dir",
+        type=str,
+        default=None,
+        required=False,
+        help="A folder containing the training data of class images.",
+    )
+    parser.add_argument(
+        "--instance_prompt",
+        type=str,
+        default=None,
+        required=True,
+        help="The prompt with identifier specifying the instance",
+    )
+    parser.add_argument(
+        "--class_prompt",
+        type=str,
+        default=None,
+        help="The prompt to specify images in the same class as provided instance images.",
+    )
+    parser.add_argument(
+        "--with_prior_preservation",
+        default=False,
+        action="store_true",
+        help="Flag to add prior preservation loss.",
+    )
+    parser.add_argument("--prior_loss_weight", type=float, default=1.0, help="The weight of prior preservation loss.")
+    parser.add_argument(
+        "--num_class_images",
+        type=int,
+        default=100,
+        help=(
+            "Minimal class images for prior preservation loss. If there are not enough images already present in"
+            " class_data_dir, additional images will be sampled with class_prompt."
+        ),
+    )
+    parser.add_argument(
+        "--validation_prompt",
+        type=str,
+        default=None,
+        help="A prompt that is used during validation to verify that the model is learning.",
+    )
+    parser.add_argument(
+        "--num_validation_images",
+        type=int,
+        default=4,
+        help="Number of images that should be generated during validation with `validation_prompt`.",
+    )
+    parser.add_argument(
+        "--validation_steps",
+        type=int,
+        default=100,
+        help=(
+            "Run dreambooth validation every X steps. Dreambooth validation consists of running the prompt"
+            " `args.validation_prompt` multiple times: `args.num_validation_images`."
+        ),
+    )
+    parser.add_argument(
+        "--output_dir",
+        type=str,
+        default="text-inversion-model",
+        help="The output directory where the model predictions and checkpoints will be written.",
+    )
+    parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.")
+    parser.add_argument(
+        "--resolution",
+        type=int,
+        default=512,
+        help=(
+            "The resolution for input images, all the images in the train/validation dataset will be resized to this"
+            " resolution"
+        ),
+    )
+    parser.add_argument(
+        "--center_crop", action="store_true", help="Whether to center crop images before resizing to resolution"
+    )
+    parser.add_argument("--train_text_encoder", action="store_true", help="Whether to train the text encoder")
+
+    # lora args
+    parser.add_argument("--use_lora", action="store_true", help="Whether to use Lora for parameter efficient tuning")
+    parser.add_argument("--lora_r", type=int, default=8, help="Lora rank, only used if use_lora is True")
+    parser.add_argument("--lora_alpha", type=int, default=32, help="Lora alpha, only used if use_lora is True")
+    parser.add_argument("--lora_dropout", type=float, default=0.0, help="Lora dropout, only used if use_lora is True")
+    parser.add_argument(
+        "--lora_bias",
+        type=str,
+        default="none",
+        help="Bias type for Lora. Can be 'none', 'all' or 'lora_only', only used if use_lora is True",
+    )
+    parser.add_argument(
+        "--lora_text_encoder_r",
+        type=int,
+        default=8,
+        help="Lora rank for text encoder, only used if `use_lora` and `train_text_encoder` are True",
+    )
+    parser.add_argument(
+        "--lora_text_encoder_alpha",
+        type=int,
+        default=32,
+        help="Lora alpha for text encoder, only used if `use_lora` and `train_text_encoder` are True",
+    )
+    parser.add_argument(
+        "--lora_text_encoder_dropout",
+        type=float,
+        default=0.0,
+        help="Lora dropout for text encoder, only used if `use_lora` and `train_text_encoder` are True",
+    )
+    parser.add_argument(
+        "--lora_text_encoder_bias",
+        type=str,
+        default="none",
+        help="Bias type for Lora. Can be 'none', 'all' or 'lora_only', only used if use_lora and `train_text_encoder` are True",
+    )
+
+    parser.add_argument(
+        "--num_dataloader_workers", type=int, default=1, help="Num of workers for the training dataloader."
+    )
+
+    parser.add_argument(
+        "--no_tracemalloc",
+        default=False,
+        action="store_true",
+        help="Flag to stop memory allocation tracing during training. This could speed up training on Windows.",
+    )
+
+    parser.add_argument(
+        "--train_batch_size", type=int, default=4, help="Batch size (per device) for the training dataloader."
+    )
+    parser.add_argument(
+        "--sample_batch_size", type=int, default=4, help="Batch size (per device) for sampling images."
+    )
+    parser.add_argument("--num_train_epochs", type=int, default=1)
+    parser.add_argument(
+        "--max_train_steps",
+        type=int,
+        default=None,
+        help="Total number of training steps to perform.  If provided, overrides num_train_epochs.",
+    )
+    parser.add_argument(
+        "--checkpointing_steps",
+        type=int,
+        default=500,
+        help=(
+            "Save a checkpoint of the training state every X updates. These checkpoints can be used both as final"
+            " checkpoints in case they are better than the last checkpoint, and are also suitable for resuming"
+            " training using `--resume_from_checkpoint`."
+        ),
+    )
+    parser.add_argument(
+        "--resume_from_checkpoint",
+        type=str,
+        default=None,
+        help=(
+            "Whether training should be resumed from a previous checkpoint. Use a path saved by"
+            ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.'
+        ),
+    )
+    parser.add_argument(
+        "--gradient_accumulation_steps",
+        type=int,
+        default=1,
+        help="Number of updates steps to accumulate before performing a backward/update pass.",
+    )
+    parser.add_argument(
+        "--gradient_checkpointing",
+        action="store_true",
+        help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.",
+    )
+    parser.add_argument(
+        "--learning_rate",
+        type=float,
+        default=5e-6,
+        help="Initial learning rate (after the potential warmup period) to use.",
+    )
+    parser.add_argument(
+        "--scale_lr",
+        action="store_true",
+        default=False,
+        help="Scale the learning rate by the number of accelerators, gradient accumulation steps, and batch size.",
+    )
+    parser.add_argument(
+        "--lr_scheduler",
+        type=str,
+        default="constant",
+        help=(
+            'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",'
+            ' "constant", "constant_with_warmup"]'
+        ),
+    )
+    parser.add_argument(
+        "--lr_warmup_steps", type=int, default=500, help="Number of steps for the warmup in the lr scheduler."
+    )
+    parser.add_argument(
+        "--lr_num_cycles",
+        type=int,
+        default=1,
+        help="Number of hard resets of the lr in cosine_with_restarts scheduler.",
+    )
+    parser.add_argument("--lr_power", type=float, default=1.0, help="Power factor of the polynomial scheduler.")
+    parser.add_argument(
+        "--use_8bit_adam", action="store_true", help="Whether or not to use 8-bit Adam from bitsandbytes."
+    )
+    parser.add_argument("--adam_beta1", type=float, default=0.9, help="The beta1 parameter for the Adam optimizer.")
+    parser.add_argument("--adam_beta2", type=float, default=0.999, help="The beta2 parameter for the Adam optimizer.")
+    parser.add_argument("--adam_weight_decay", type=float, default=1e-2, help="Weight decay to use.")
+    parser.add_argument("--adam_epsilon", type=float, default=1e-08, help="Epsilon value for the Adam optimizer")
+    parser.add_argument("--max_grad_norm", default=1.0, type=float, help="Max gradient norm.")
+    parser.add_argument("--push_to_hub", action="store_true", help="Whether or not to push the model to the Hub.")
+    parser.add_argument("--hub_token", type=str, default=None, help="The token to use to push to the Model Hub.")
+    parser.add_argument(
+        "--hub_model_id",
+        type=str,
+        default=None,
+        help="The name of the repository to keep in sync with the local `output_dir`.",
+    )
+    parser.add_argument(
+        "--logging_dir",
+        type=str,
+        default="logs",
+        help=(
+            "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to"
+            " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***."
+        ),
+    )
+    parser.add_argument(
+        "--allow_tf32",
+        action="store_true",
+        help=(
+            "Whether or not to allow TF32 on Ampere GPUs. Can be used to speed up training. For more information, see"
+            " https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices"
+        ),
+    )
+    parser.add_argument(
+        "--report_to",
+        type=str,
+        default="tensorboard",
+        help=(
+            'The integration to report the results and logs to. Supported platforms are `"tensorboard"`'
+            ' (default), `"wandb"` and `"comet_ml"`. Use `"all"` to report to all integrations.'
+        ),
+    )
+    parser.add_argument(
+        "--wandb_key",
+        type=str,
+        default=None,
+        help=("If report to option is set to wandb, api-key for wandb used for login to wandb "),
+    )
+    parser.add_argument(
+        "--wandb_project_name",
+        type=str,
+        default=None,
+        help=("If report to option is set to wandb, project name in wandb for log tracking  "),
+    )
+    parser.add_argument(
+        "--mixed_precision",
+        type=str,
+        default=None,
+        choices=["no", "fp16", "bf16"],
+        help=(
+            "Whether to use mixed precision. Choose between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >="
+            " 1.10.and an Nvidia Ampere GPU or Intel XPU.  Default to the value of accelerate config of the current system or the"
+            " flag passed with the `accelerate.launch` command. Use this argument to override the accelerate config."
+        ),
+    )
+    parser.add_argument(
+        "--prior_generation_precision",
+        type=str,
+        default=None,
+        choices=["no", "fp32", "fp16", "bf16"],
+        help=(
+            "Choose prior generation precision between fp32, fp16 and bf16 (bfloat16). Bf16 requires PyTorch >="
+            " 1.10.and an Nvidia Ampere GPU or Intel XPU.  Default to  fp16 if a GPU is available else fp32."
+        ),
+    )
+    parser.add_argument("--local_rank", type=int, default=-1, help="For distributed training: local_rank")
+    parser.add_argument(
+        "--enable_xformers_memory_efficient_attention", action="store_true", help="Whether or not to use xformers."
+    )
+
+    if input_args is not None:
+        args = parser.parse_args(input_args)
+    else:
+        args = parser.parse_args()
+
+    env_local_rank = int(os.environ.get("LOCAL_RANK", "-1"))
+    if env_local_rank != -1 and env_local_rank != args.local_rank:
+        args.local_rank = env_local_rank
+
+    if args.with_prior_preservation:
+        if args.class_data_dir is None:
+            raise ValueError("You must specify a data directory for class images.")
+        if args.class_prompt is None:
+            raise ValueError("You must specify prompt for class images.")
+    else:
+        # logger is not available yet
+        if args.class_data_dir is not None:
+            warnings.warn("You need not use --class_data_dir without --with_prior_preservation.")
+        if args.class_prompt is not None:
+            warnings.warn("You need not use --class_prompt without --with_prior_preservation.")
+
+    return args
+
+
+# Converting Bytes to Megabytes
+def b2mb(x):
+    return int(x / 2**20)
+
+
+# This context manager is used to track the peak memory usage of the process
+class TorchTracemalloc:
+    def __enter__(self):
+        gc.collect()
+        self.device_type = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+        self.device_module = getattr(torch, self.device_type, torch.cuda)
+        self.device_module.empty_cache()
+        self.device_module.reset_peak_memory_stats()  # reset the peak gauge to zero
+        self.begin = self.device_module.memory_allocated()
+        self.process = psutil.Process()
+
+        self.cpu_begin = self.cpu_mem_used()
+        self.peak_monitoring = True
+        peak_monitor_thread = threading.Thread(target=self.peak_monitor_func)
+        peak_monitor_thread.daemon = True
+        peak_monitor_thread.start()
+        return self
+
+    def cpu_mem_used(self):
+        """get resident set size memory for the current process"""
+        return self.process.memory_info().rss
+
+    def peak_monitor_func(self):
+        self.cpu_peak = -1
+
+        while True:
+            self.cpu_peak = max(self.cpu_mem_used(), self.cpu_peak)
+
+            # can't sleep or will not catch the peak right (this comment is here on purpose)
+            # time.sleep(0.001) # 1msec
+
+            if not self.peak_monitoring:
+                break
+
+    def __exit__(self, *exc):
+        self.peak_monitoring = False
+
+        gc.collect()
+        self.device_module.empty_cache()
+        self.end = self.device_module.memory_allocated()
+        self.peak = self.device_module.max_memory_allocated()
+        self.used = b2mb(self.end - self.begin)
+        self.peaked = b2mb(self.peak - self.begin)
+
+        self.cpu_end = self.cpu_mem_used()
+        self.cpu_used = b2mb(self.cpu_end - self.cpu_begin)
+        self.cpu_peaked = b2mb(self.cpu_peak - self.cpu_begin)
+        # print(f"delta used/peak {self.used:4d}/{self.peaked:4d}")
+
+
+class DreamBoothDataset(Dataset):
+    """
+    A dataset to prepare the instance and class images with the prompts for fine-tuning the model.
+    It pre-processes the images and the tokenizes prompts.
+    """
+
+    def __init__(
+        self,
+        instance_data_root,
+        instance_prompt,
+        tokenizer,
+        class_data_root=None,
+        class_prompt=None,
+        size=512,
+        center_crop=False,
+    ):
+        self.size = size
+        self.center_crop = center_crop
+        self.tokenizer = tokenizer
+
+        self.instance_data_root = Path(instance_data_root)
+        if not self.instance_data_root.exists():
+            raise ValueError("Instance images root doesn't exists.")
+
+        self.instance_images_path = list(Path(instance_data_root).iterdir())
+        self.num_instance_images = len(self.instance_images_path)
+        self.instance_prompt = instance_prompt
+        self._length = self.num_instance_images
+
+        if class_data_root is not None:
+            self.class_data_root = Path(class_data_root)
+            self.class_data_root.mkdir(parents=True, exist_ok=True)
+            self.class_images_path = list(self.class_data_root.iterdir())
+            self.num_class_images = len(self.class_images_path)
+            self._length = max(self.num_class_images, self.num_instance_images)
+            self.class_prompt = class_prompt
+        else:
+            self.class_data_root = None
+
+        self.image_transforms = transforms.Compose(
+            [
+                transforms.Resize(size, interpolation=transforms.InterpolationMode.BILINEAR),
+                transforms.CenterCrop(size) if center_crop else transforms.RandomCrop(size),
+                transforms.ToTensor(),
+                transforms.Normalize([0.5], [0.5]),
+            ]
+        )
+
+    def __len__(self):
+        return self._length
+
+    def __getitem__(self, index):
+        example = {}
+        instance_image = Image.open(self.instance_images_path[index % self.num_instance_images])
+        if instance_image.mode != "RGB":
+            instance_image = instance_image.convert("RGB")
+        example["instance_images"] = self.image_transforms(instance_image)
+        example["instance_prompt_ids"] = self.tokenizer(
+            self.instance_prompt,
+            truncation=True,
+            padding="max_length",
+            max_length=self.tokenizer.model_max_length,
+            return_tensors="pt",
+        ).input_ids
+
+        if self.class_data_root:
+            class_image = Image.open(self.class_images_path[index % self.num_class_images])
+            if class_image.mode != "RGB":
+                class_image = class_image.convert("RGB")
+            example["class_images"] = self.image_transforms(class_image)
+            example["class_prompt_ids"] = self.tokenizer(
+                self.class_prompt,
+                truncation=True,
+                padding="max_length",
+                max_length=self.tokenizer.model_max_length,
+                return_tensors="pt",
+            ).input_ids
+
+        return example
+
+
+def collate_fn(examples, with_prior_preservation=False):
+    input_ids = [example["instance_prompt_ids"] for example in examples]
+    pixel_values = [example["instance_images"] for example in examples]
+
+    # Concat class and instance examples for prior preservation.
+    # We do this to avoid doing two forward passes.
+    if with_prior_preservation:
+        input_ids += [example["class_prompt_ids"] for example in examples]
+        pixel_values += [example["class_images"] for example in examples]
+
+    pixel_values = torch.stack(pixel_values)
+    pixel_values = pixel_values.to(memory_format=torch.contiguous_format).float()
+
+    input_ids = torch.cat(input_ids, dim=0)
+
+    batch = {
+        "input_ids": input_ids,
+        "pixel_values": pixel_values,
+    }
+    return batch
+
+
+class PromptDataset(Dataset):
+    "A simple dataset to prepare the prompts to generate class images on multiple accelerators."
+
+    def __init__(self, prompt, num_samples):
+        self.prompt = prompt
+        self.num_samples = num_samples
+
+    def __len__(self):
+        return self.num_samples
+
+    def __getitem__(self, index):
+        example = {}
+        example["prompt"] = self.prompt
+        example["index"] = index
+        return example
+
+
+def main(args):
+    logging_dir = Path(args.output_dir, args.logging_dir)
+
+    accelerator = Accelerator(
+        gradient_accumulation_steps=args.gradient_accumulation_steps,
+        mixed_precision=args.mixed_precision,
+        log_with=args.report_to,
+        project_dir=logging_dir,
+    )
+    if args.report_to == "wandb":
+        import wandb
+
+        wandb.login(key=args.wandb_key)
+        wandb.init(project=args.wandb_project_name)
+    # Currently, it's not possible to do gradient accumulation when training two models with accelerate.accumulate
+    # This will be enabled soon in accelerate. For now, we don't allow gradient accumulation when training two models.
+    # TODO (patil-suraj): Remove this check when gradient accumulation with two models is enabled in accelerate.
+    if args.train_text_encoder and args.gradient_accumulation_steps > 1 and accelerator.num_processes > 1:
+        raise ValueError(
+            "Gradient accumulation is not supported when training the text encoder in distributed training. "
+            "Please set gradient_accumulation_steps to 1. This feature will be supported in the future."
+        )
+
+    # Make one log on every process with the configuration for debugging.
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        level=logging.INFO,
+    )
+    logger.info(accelerator.state, main_process_only=False)
+    if accelerator.is_local_main_process:
+        datasets.utils.logging.set_verbosity_warning()
+        transformers.utils.logging.set_verbosity_warning()
+        diffusers.utils.logging.set_verbosity_info()
+    else:
+        datasets.utils.logging.set_verbosity_error()
+        transformers.utils.logging.set_verbosity_error()
+        diffusers.utils.logging.set_verbosity_error()
+
+    # If passed along, set the training seed now.
+    if args.seed is not None:
+        set_seed(args.seed)
+
+    # Generate class images if prior preservation is enabled.
+    if args.with_prior_preservation:
+        class_images_dir = Path(args.class_data_dir)
+        if not class_images_dir.exists():
+            class_images_dir.mkdir(parents=True)
+        cur_class_images = len(list(class_images_dir.iterdir()))
+
+        if cur_class_images < args.num_class_images:
+            dtype = torch.float16 if accelerator.device.type in ["cuda", "xpu"] else torch.float32
+            if args.prior_generation_precision == "fp32":
+                dtype = torch.float32
+            elif args.prior_generation_precision == "fp16":
+                dtype = torch.float16
+            elif args.prior_generation_precision == "bf16":
+                dtype = torch.bfloat16
+            pipeline = DiffusionPipeline.from_pretrained(
+                args.pretrained_model_name_or_path,
+                dtype=dtype,
+                safety_checker=None,
+                revision=args.revision,
+            )
+            pipeline.set_progress_bar_config(disable=True)
+
+            num_new_images = args.num_class_images - cur_class_images
+            logger.info(f"Number of class images to sample: {num_new_images}.")
+
+            sample_dataset = PromptDataset(args.class_prompt, num_new_images)
+            sample_dataloader = torch.utils.data.DataLoader(sample_dataset, batch_size=args.sample_batch_size)
+
+            sample_dataloader = accelerator.prepare(sample_dataloader)
+            pipeline.to(accelerator.device)
+
+            for example in tqdm(
+                sample_dataloader, desc="Generating class images", disable=not accelerator.is_local_main_process
+            ):
+                images = pipeline(example["prompt"]).images
+
+                for i, image in enumerate(images):
+                    hash_image = hashlib.sha1(image.tobytes()).hexdigest()
+                    image_filename = class_images_dir / f"{example['index'][i] + cur_class_images}-{hash_image}.jpg"
+                    image.save(image_filename)
+
+            del pipeline
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+            elif torch.xpu.is_available():
+                torch.xpu.empty_cache()
+
+    # Handle the repository creation
+    if accelerator.is_main_process:
+        if args.push_to_hub:
+            api = HfApi(token=args.hub_token)
+
+            # Create repo (repo_name from args or inferred)
+            repo_name = args.hub_model_id
+            if repo_name is None:
+                repo_name = Path(args.output_dir).absolute().name
+            repo_id = api.create_repo(repo_name, exist_ok=True).repo_id
+
+            with open(os.path.join(args.output_dir, ".gitignore"), "w+") as gitignore:
+                if "step_*" not in gitignore:
+                    gitignore.write("step_*\n")
+                if "epoch_*" not in gitignore:
+                    gitignore.write("epoch_*\n")
+        elif args.output_dir is not None:
+            os.makedirs(args.output_dir, exist_ok=True)
+
+    # Load the tokenizer
+    if args.tokenizer_name:
+        tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name, revision=args.revision, use_fast=False)
+    elif args.pretrained_model_name_or_path:
+        tokenizer = AutoTokenizer.from_pretrained(
+            args.pretrained_model_name_or_path,
+            subfolder="tokenizer",
+            revision=args.revision,
+            use_fast=False,
+        )
+
+    # import correct text encoder class
+    text_encoder_cls = import_model_class_from_model_name_or_path(args.pretrained_model_name_or_path, args.revision)
+
+    # Load scheduler and models
+    noise_scheduler = DDPMScheduler(
+        beta_start=0.00085,
+        beta_end=0.012,
+        beta_schedule="scaled_linear",
+        num_train_timesteps=1000,
+    )  # DDPMScheduler.from_pretrained(args.pretrained_model_name_or_path, subfolder="scheduler")
+    text_encoder = text_encoder_cls.from_pretrained(
+        args.pretrained_model_name_or_path, subfolder="text_encoder", revision=args.revision
+    )
+    vae = AutoencoderKL.from_pretrained(args.pretrained_model_name_or_path, subfolder="vae", revision=args.revision)
+    unet = UNet2DConditionModel.from_pretrained(
+        args.pretrained_model_name_or_path, subfolder="unet", revision=args.revision
+    )
+
+    if args.use_lora:
+        config = LoraConfig(
+            r=args.lora_r,
+            lora_alpha=args.lora_alpha,
+            target_modules=UNET_TARGET_MODULES,
+            lora_dropout=args.lora_dropout,
+            bias=args.lora_bias,
+        )
+        unet = get_peft_model(unet, config)
+        unet.print_trainable_parameters()
+        print(unet)
+
+    vae.requires_grad_(False)
+    if not args.train_text_encoder:
+        text_encoder.requires_grad_(False)
+    elif args.train_text_encoder and args.use_lora:
+        config = LoraConfig(
+            r=args.lora_text_encoder_r,
+            lora_alpha=args.lora_text_encoder_alpha,
+            target_modules=TEXT_ENCODER_TARGET_MODULES,
+            lora_dropout=args.lora_text_encoder_dropout,
+            bias=args.lora_text_encoder_bias,
+        )
+        text_encoder = get_peft_model(text_encoder, config)
+        text_encoder.print_trainable_parameters()
+        print(text_encoder)
+
+    if args.enable_xformers_memory_efficient_attention:
+        if accelerator.device.type == "xpu":
+            logger.warning("XPU hasn't support xformers yet, ignore it.")
+        elif is_xformers_available():
+            unet.enable_xformers_memory_efficient_attention()
+        else:
+            raise ValueError("xformers is not available. Make sure it is installed correctly")
+
+    if args.gradient_checkpointing:
+        unet.enable_gradient_checkpointing()
+        # below fails when using lora so commenting it out
+        if args.train_text_encoder and not args.use_lora:
+            text_encoder.gradient_checkpointing_enable()
+
+    # Enable TF32 for faster training on Ampere GPUs,
+    # cf https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices
+    if args.allow_tf32 and torch.cuda.is_available():
+        torch.backends.cuda.matmul.allow_tf32 = True
+
+    if args.scale_lr:
+        args.learning_rate = (
+            args.learning_rate * args.gradient_accumulation_steps * args.train_batch_size * accelerator.num_processes
+        )
+
+    # Use 8-bit Adam for lower memory usage or to fine-tune the model in 16GB accelerators
+    if args.use_8bit_adam:
+        try:
+            import bitsandbytes as bnb
+        except ImportError:
+            raise ImportError(
+                "To use 8-bit Adam, please install the bitsandbytes library: `pip install bitsandbytes`."
+            )
+
+        optimizer_class = bnb.optim.AdamW8bit
+    else:
+        optimizer_class = torch.optim.AdamW
+
+    # Optimizer creation
+    params_to_optimize = (
+        itertools.chain(unet.parameters(), text_encoder.parameters()) if args.train_text_encoder else unet.parameters()
+    )
+    optimizer = optimizer_class(
+        params_to_optimize,
+        lr=args.learning_rate,
+        betas=(args.adam_beta1, args.adam_beta2),
+        weight_decay=args.adam_weight_decay,
+        eps=args.adam_epsilon,
+    )
+
+    # Dataset and DataLoaders creation:
+    train_dataset = DreamBoothDataset(
+        instance_data_root=args.instance_data_dir,
+        instance_prompt=args.instance_prompt,
+        class_data_root=args.class_data_dir if args.with_prior_preservation else None,
+        class_prompt=args.class_prompt,
+        tokenizer=tokenizer,
+        size=args.resolution,
+        center_crop=args.center_crop,
+    )
+
+    train_dataloader = torch.utils.data.DataLoader(
+        train_dataset,
+        batch_size=args.train_batch_size,
+        shuffle=True,
+        collate_fn=lambda examples: collate_fn(examples, args.with_prior_preservation),
+        num_workers=args.num_dataloader_workers,
+    )
+
+    # Scheduler and math around the number of training steps.
+    overrode_max_train_steps = False
+    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+    if args.max_train_steps is None:
+        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+        overrode_max_train_steps = True
+
+    lr_scheduler = get_scheduler(
+        args.lr_scheduler,
+        optimizer=optimizer,
+        num_warmup_steps=args.lr_warmup_steps * args.gradient_accumulation_steps,
+        num_training_steps=args.max_train_steps * args.gradient_accumulation_steps,
+        num_cycles=args.lr_num_cycles,
+        power=args.lr_power,
+    )
+
+    # Prepare everything with our `accelerator`.
+    if args.train_text_encoder:
+        unet, text_encoder, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
+            unet, text_encoder, optimizer, train_dataloader, lr_scheduler
+        )
+    else:
+        unet, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
+            unet, optimizer, train_dataloader, lr_scheduler
+        )
+
+    # For mixed precision training we cast the text_encoder and vae weights to half-precision
+    # as these models are only used for inference, keeping weights in full precision is not required.
+    weight_dtype = torch.float32
+    if accelerator.mixed_precision == "fp16":
+        weight_dtype = torch.float16
+    elif accelerator.mixed_precision == "bf16":
+        weight_dtype = torch.bfloat16
+
+    # Move vae and text_encoder to device and cast to weight_dtype
+    vae.to(accelerator.device, dtype=weight_dtype)
+    if not args.train_text_encoder:
+        text_encoder.to(accelerator.device, dtype=weight_dtype)
+
+    # We need to recalculate our total training steps as the size of the training dataloader may have changed.
+    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+    if overrode_max_train_steps:
+        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+    # Afterwards we recalculate our number of training epochs
+    args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch)
+
+    # We need to initialize the trackers we use, and also store our configuration.
+    # The trackers initializes automatically on the main process.
+    if accelerator.is_main_process:
+        accelerator.init_trackers("dreambooth", config=vars(args))
+
+    # Train!
+    total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps
+
+    logger.info("***** Running training *****")
+    logger.info(f"  Num examples = {len(train_dataset)}")
+    logger.info(f"  Num batches each epoch = {len(train_dataloader)}")
+    logger.info(f"  Num Epochs = {args.num_train_epochs}")
+    logger.info(f"  Instantaneous batch size per device = {args.train_batch_size}")
+    logger.info(f"  Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}")
+    logger.info(f"  Gradient Accumulation steps = {args.gradient_accumulation_steps}")
+    logger.info(f"  Total optimization steps = {args.max_train_steps}")
+    global_step = 0
+    first_epoch = 0
+
+    # Potentially load in the weights and states from a previous save
+    if args.resume_from_checkpoint:
+        if args.resume_from_checkpoint != "latest":
+            path = os.path.basename(args.resume_from_checkpoint)
+        else:
+            # Get the mos recent checkpoint
+            dirs = os.listdir(args.output_dir)
+            dirs = [d for d in dirs if d.startswith("checkpoint")]
+            dirs = sorted(dirs, key=lambda x: int(x.split("-")[1]))
+            path = dirs[-1]
+        accelerator.print(f"Resuming from checkpoint {path}")
+        accelerator.load_state(os.path.join(args.output_dir, path))
+        global_step = int(path.split("-")[1])
+
+        resume_global_step = global_step * args.gradient_accumulation_steps
+        first_epoch = resume_global_step // num_update_steps_per_epoch
+        resume_step = resume_global_step % num_update_steps_per_epoch
+
+    # Only show the progress bar once on each machine.
+    progress_bar = tqdm(range(global_step, args.max_train_steps), disable=not accelerator.is_local_main_process)
+    progress_bar.set_description("Steps")
+
+    for epoch in range(first_epoch, args.num_train_epochs):
+        unet.train()
+        if args.train_text_encoder:
+            text_encoder.train()
+        with TorchTracemalloc() if not args.no_tracemalloc else nullcontext() as tracemalloc:
+            for step, batch in enumerate(train_dataloader):
+                # Skip steps until we reach the resumed step
+                if args.resume_from_checkpoint and epoch == first_epoch and step < resume_step:
+                    if step % args.gradient_accumulation_steps == 0:
+                        progress_bar.update(1)
+                        if args.report_to == "wandb":
+                            accelerator.print(progress_bar)
+                    continue
+
+                with accelerator.accumulate(unet):
+                    # Convert images to latent space
+                    latents = vae.encode(batch["pixel_values"].to(dtype=weight_dtype)).latent_dist.sample()
+                    latents = latents * 0.18215
+
+                    # Sample noise that we'll add to the latents
+                    noise = torch.randn_like(latents)
+                    bsz = latents.shape[0]
+                    # Sample a random timestep for each image
+                    timesteps = torch.randint(
+                        0, noise_scheduler.config.num_train_timesteps, (bsz,), device=latents.device
+                    )
+                    timesteps = timesteps.long()
+
+                    # Add noise to the latents according to the noise magnitude at each timestep
+                    # (this is the forward diffusion process)
+                    noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps)
+
+                    # Get the text embedding for conditioning
+                    encoder_hidden_states = text_encoder(batch["input_ids"])[0]
+
+                    # Predict the noise residual
+                    model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample
+
+                    # Get the target for loss depending on the prediction type
+                    if noise_scheduler.config.prediction_type == "epsilon":
+                        target = noise
+                    elif noise_scheduler.config.prediction_type == "v_prediction":
+                        target = noise_scheduler.get_velocity(latents, noise, timesteps)
+                    else:
+                        raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}")
+
+                    if args.with_prior_preservation:
+                        # Chunk the noise and model_pred into two parts and compute the loss on each part separately.
+                        model_pred, model_pred_prior = torch.chunk(model_pred, 2, dim=0)
+                        target, target_prior = torch.chunk(target, 2, dim=0)
+
+                        # Compute instance loss
+                        loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
+
+                        # Compute prior loss
+                        prior_loss = F.mse_loss(model_pred_prior.float(), target_prior.float(), reduction="mean")
+
+                        # Add the prior loss to the instance loss.
+                        loss = loss + args.prior_loss_weight * prior_loss
+                    else:
+                        loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
+
+                    accelerator.backward(loss)
+                    if accelerator.sync_gradients:
+                        params_to_clip = (
+                            itertools.chain(unet.parameters(), text_encoder.parameters())
+                            if args.train_text_encoder
+                            else unet.parameters()
+                        )
+                        accelerator.clip_grad_norm_(params_to_clip, args.max_grad_norm)
+                    optimizer.step()
+                    lr_scheduler.step()
+                    optimizer.zero_grad()
+
+                # Checks if the accelerator has performed an optimization step behind the scenes
+                if accelerator.sync_gradients:
+                    progress_bar.update(1)
+                    if args.report_to == "wandb":
+                        accelerator.print(progress_bar)
+                    global_step += 1
+
+                    # if global_step % args.checkpointing_steps == 0:
+                    #     if accelerator.is_main_process:
+                    #         save_path = os.path.join(args.output_dir, f"checkpoint-{global_step}")
+                    #         accelerator.save_state(save_path)
+                    #         logger.info(f"Saved state to {save_path}")
+
+                logs = {"loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0]}
+                progress_bar.set_postfix(**logs)
+                accelerator.log(logs, step=global_step)
+
+                if (
+                    args.validation_prompt is not None
+                    and (step + num_update_steps_per_epoch * epoch) % args.validation_steps == 0
+                ):
+                    logger.info(
+                        f"Running validation... \n Generating {args.num_validation_images} images with prompt:"
+                        f" {args.validation_prompt}."
+                    )
+                    # create pipeline
+                    pipeline = DiffusionPipeline.from_pretrained(
+                        args.pretrained_model_name_or_path,
+                        safety_checker=None,
+                        revision=args.revision,
+                    )
+                    # set `keep_fp32_wrapper` to True because we do not want to remove
+                    # mixed precision hooks while we are still training
+                    pipeline.unet = accelerator.unwrap_model(unet, keep_fp32_wrapper=True)
+                    pipeline.text_encoder = accelerator.unwrap_model(text_encoder, keep_fp32_wrapper=True)
+                    pipeline.scheduler = DPMSolverMultistepScheduler.from_config(pipeline.scheduler.config)
+                    pipeline = pipeline.to(accelerator.device)
+                    pipeline.set_progress_bar_config(disable=True)
+
+                    # run inference
+                    if args.seed is not None:
+                        generator = torch.Generator(device=accelerator.device).manual_seed(args.seed)
+                    else:
+                        generator = None
+                    images = []
+                    for _ in range(args.num_validation_images):
+                        image = pipeline(args.validation_prompt, num_inference_steps=25, generator=generator).images[0]
+                        images.append(image)
+
+                    for tracker in accelerator.trackers:
+                        if tracker.name == "tensorboard":
+                            np_images = np.stack([np.asarray(img) for img in images])
+                            tracker.writer.add_images("validation", np_images, epoch, dataformats="NHWC")
+                        if tracker.name == "wandb":
+                            import wandb
+
+                            tracker.log(
+                                {
+                                    "validation": [
+                                        wandb.Image(image, caption=f"{i}: {args.validation_prompt}")
+                                        for i, image in enumerate(images)
+                                    ]
+                                }
+                            )
+
+                    del pipeline
+                    if torch.cuda.is_available():
+                        torch.cuda.empty_cache()
+                    elif torch.xpu.is_available():
+                        torch.xpu.empty_cache()
+
+                if global_step >= args.max_train_steps:
+                    break
+
+        # Printing the accelerator memory usage details such as allocated memory, peak memory, and total memory usage
+        if not args.no_tracemalloc:
+            accelerator.print(
+                f"{accelerator.device.type.upper()} Memory before entering the train : {b2mb(tracemalloc.begin)}"
+            )
+            accelerator.print(
+                f"{accelerator.device.type.upper()} Memory consumed at the end of the train (end-begin): {tracemalloc.used}"
+            )
+            accelerator.print(
+                f"{accelerator.device.type.upper()} Peak Memory consumed during the train (max-begin): {tracemalloc.peaked}"
+            )
+            accelerator.print(
+                f"{accelerator.device.type.upper()} Total Peak Memory consumed during the train (max): {tracemalloc.peaked + b2mb(tracemalloc.begin)}"
+            )
+
+            accelerator.print(f"CPU Memory before entering the train : {b2mb(tracemalloc.cpu_begin)}")
+            accelerator.print(f"CPU Memory consumed at the end of the train (end-begin): {tracemalloc.cpu_used}")
+            accelerator.print(f"CPU Peak Memory consumed during the train (max-begin): {tracemalloc.cpu_peaked}")
+            accelerator.print(
+                f"CPU Total Peak Memory consumed during the train (max): {tracemalloc.cpu_peaked + b2mb(tracemalloc.cpu_begin)}"
+            )
+
+    # Create the pipeline using using the trained modules and save it.
+    accelerator.wait_for_everyone()
+    if accelerator.is_main_process:
+        if args.use_lora:
+            unwarpped_unet = accelerator.unwrap_model(unet)
+            unwarpped_unet.save_pretrained(
+                os.path.join(args.output_dir, "unet"), state_dict=accelerator.get_state_dict(unet)
+            )
+            if args.train_text_encoder:
+                unwarpped_text_encoder = accelerator.unwrap_model(text_encoder)
+                unwarpped_text_encoder.save_pretrained(
+                    os.path.join(args.output_dir, "text_encoder"),
+                    state_dict=accelerator.get_state_dict(text_encoder),
+                )
+        else:
+            pipeline = DiffusionPipeline.from_pretrained(
+                args.pretrained_model_name_or_path,
+                unet=accelerator.unwrap_model(unet),
+                text_encoder=accelerator.unwrap_model(text_encoder),
+                revision=args.revision,
+            )
+            pipeline.save_pretrained(args.output_dir)
+
+        if args.push_to_hub:
+            api.upload_folder(
+                repo_id=repo_id,
+                folder_path=args.output_dir,
+                commit_message="End of training",
+                run_as_future=True,
+            )
+
+    accelerator.end_training()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    main(args)
diff --git a/examples/lora_finetuning_transformer_engine/Dockerfile b/examples/lora_finetuning_transformer_engine/Dockerfile
new file mode 100644
index 0000000..0139643
--- /dev/null
+++ b/examples/lora_finetuning_transformer_engine/Dockerfile
@@ -0,0 +1,8 @@
+FROM nvcr.io/nvidia/pytorch:26.01-py3
+
+WORKDIR /workspace/lora_finetuning
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY lora_finetuning_te.py .
diff --git a/examples/lora_finetuning_transformer_engine/README.md b/examples/lora_finetuning_transformer_engine/README.md
new file mode 100644
index 0000000..b58595c
--- /dev/null
+++ b/examples/lora_finetuning_transformer_engine/README.md
@@ -0,0 +1,119 @@
+# Transformer Engine ESM2 LoRA Fine-Tuning
+
+This example demonstrates LoRA fine-tuning for Transformer Engine ESM2 token classification.
+
+## Setup
+
+Choose one of the two options below.
+
+### Option A: Docker (recommended)
+
+Build a self-contained image based on the publicly available NVIDIA PyTorch container
+(`nvcr.io/nvidia/pytorch:26.01-py3`), which already ships CUDA, cuDNN, and Transformer Engine:
+
+```bash
+docker build -t lora-te examples/lora_finetuning_transformer_engine
+```
+
+Run the training inside the container:
+
+```bash
+docker run --gpus all --rm lora-te \
+  python lora_finetuning_te.py \
+    --base_model nvidia/esm2_t6_8M_UR50D \
+    --output_dir ./esm2_lora_output \
+    --num_train_samples 256 \
+    --num_eval_samples 64 \
+    --num_epochs 1
+```
+
+Or start an interactive session to experiment:
+
+```bash
+docker run --gpus all --rm -it lora-te bash
+```
+
+### Option B: Virtual environment
+
+Create and activate a virtual environment, then install the Python dependencies:
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -r examples/lora_finetuning_transformer_engine/requirements.txt
+```
+
+**Transformer Engine** must be installed separately and must match the system CUDA toolkit version.
+See the [TE installation guide](https://docs.nvidia.com/deeplearning/transformer-engine/user-guide/installation.html)
+for details.
+
+## What this example does
+
+- Loads a Transformer Engine ESM2 model for token classification
+- Applies LoRA adapters via PEFT
+- Generates random protein-like sequences
+- Assigns randomly generated secondary structure labels (`H`, `E`, `C`)
+- Trains/evaluates with `Trainer`
+
+## Run
+
+```bash
+python examples/lora_finetuning_transformer_engine/lora_finetuning_te.py \
+  --base_model nvidia/esm2_t6_8M_UR50D \
+  --output_dir ./esm2_lora_output \
+  --num_train_samples 256 \
+  --num_eval_samples 64 \
+  --num_epochs 1
+```
+
+> **Note:** The default ESM2 models on Hugging Face Hub ship custom modeling code.
+> You must pass `--trust_remote_code` to allow loading that code.
+
+## Customize
+
+```bash
+python examples/lora_finetuning_transformer_engine/lora_finetuning_te.py \
+  --base_model nvidia/esm2_t6_8M_UR50D \
+  --trust_remote_code \
+  --output_dir ./esm2_lora_output \
+  --max_length 256 \
+  --batch_size 4 \
+  --learning_rate 3e-4 \
+  --lora_r 16 \
+  --lora_alpha 32 \
+  --lora_dropout 0.1
+```
+
+## Dataset
+
+By default the script generates a **synthetic dataset** at runtime — random protein-like sequences
+with randomly generated secondary structure labels (`H`, `E`, `C`). This is useful for quick sanity checks and testing.
+
+For a more realistic evaluation, you can use the **Porter6** secondary-structure dataset.
+A download-and-convert script is available in the BioNeMo repository:
+
+[prepare_porter6_dataset.py](https://github.com/NVIDIA/bionemo-framework/blob/bd72d882bca458d9438e05661c41163949713d1f/bionemo-recipes/recipes/esm2_peft_te/data/prepare_porter6_dataset.py)
+
+Run it to produce train and validation parquet files, then pass them to the training script
+with `--train_parquet` and `--val_parquet`:
+
+```bash
+python examples/lora_finetuning_transformer_engine/lora_finetuning_te.py \
+  --base_model nvidia/esm2_t6_8M_UR50D \
+  --train_parquet porter6_train_dataset_55k.parquet \
+  --val_parquet porter6_val_dataset_2024_692.parquet \
+  --output_dir ./esm2_lora_output \
+  --num_epochs 3
+```
+
+## Outputs
+
+After training, the script saves:
+
+- PEFT adapter weights/config in `--output_dir`
+- Tokenizer files in `--output_dir`
+
+## More examples
+
+For additional examples of TransformerEngine-accelerated transformers, visit
+`https://github.com/NVIDIA/bionemo-framework/bionemo-recipes`.
diff --git a/examples/lora_finetuning_transformer_engine/lora_finetuning_te.py b/examples/lora_finetuning_transformer_engine/lora_finetuning_te.py
new file mode 100644
index 0000000..dc952a4
--- /dev/null
+++ b/examples/lora_finetuning_transformer_engine/lora_finetuning_te.py
@@ -0,0 +1,329 @@
+"""
+Transformer Engine ESM2 LoRA fine-tuning example using Hugging Face Trainer.
+
+This script demonstrates:
+1. Loading a Transformer Engine-based ESM2 token classification model
+2. Applying LoRA adapters with PEFT
+3. Building a synthetic protein token-classification dataset in code
+4. Training with the Hugging Face Trainer (no DDP setup required)
+"""
+
+import os
+
+
+# TE-backed models are incompatible with Trainer's DataParallel wrapping.
+# Pin to a single GPU before torch is imported so torch.cuda.device_count() == 1.
+os.environ.setdefault("CUDA_VISIBLE_DEVICES", "0")
+
+import argparse
+import random
+
+import numpy as np
+import pandas as pd
+import torch
+from datasets import Dataset
+from transformers import (
+    AutoConfig,
+    AutoModelForTokenClassification,
+    AutoTokenizer,
+    DataCollatorForTokenClassification,
+    Trainer,
+    TrainingArguments,
+)
+
+from peft import LoraConfig, TaskType, get_peft_model
+
+
+SS3_ID2LABEL = {0: "H", 1: "E", 2: "C"}
+SS3_LABEL2ID = {label: idx for idx, label in SS3_ID2LABEL.items()}
+
+AMINO_ACIDS = "ACDEFGHIKLMNPQRSTVWY"
+HELIX_AA = set("AELMQKRH")
+BETA_AA = set("VIFYWT")
+
+
+def parse_args():
+    """Parse command-line arguments."""
+    parser = argparse.ArgumentParser(description="Transformer Engine ESM2 LoRA fine-tuning with Hugging Face Trainer")
+
+    parser.add_argument(
+        "--base_model",
+        type=str,
+        default="nvidia/esm2_t6_8M_UR50D",
+        help="Transformer Engine ESM2 model name or path",
+    )
+    parser.add_argument("--output_dir", type=str, default="./esm2_lora_output", help="Output directory")
+    parser.add_argument("--max_length", type=int, default=128, help="Maximum sequence length")
+    parser.add_argument("--num_train_samples", type=int, default=256, help="Number of synthetic training samples")
+    parser.add_argument("--num_eval_samples", type=int, default=64, help="Number of synthetic evaluation samples")
+    parser.add_argument("--min_seq_len", type=int, default=32, help="Minimum sequence length")
+    parser.add_argument("--max_seq_len", type=int, default=96, help="Maximum sequence length")
+    parser.add_argument("--batch_size", type=int, default=8, help="Per-device batch size")
+    parser.add_argument("--num_epochs", type=int, default=1, help="Number of training epochs")
+    parser.add_argument("--learning_rate", type=float, default=5e-4, help="Learning rate")
+    parser.add_argument("--weight_decay", type=float, default=0.01, help="Weight decay")
+    parser.add_argument("--logging_steps", type=int, default=10, help="Logging frequency (steps)")
+    parser.add_argument("--eval_steps", type=int, default=25, help="Evaluation frequency (steps)")
+    parser.add_argument("--save_steps", type=int, default=25, help="Save frequency (steps)")
+    parser.add_argument("--seed", type=int, default=42, help="Random seed")
+    parser.add_argument("--lora_r", type=int, default=8, help="LoRA rank")
+    parser.add_argument("--lora_alpha", type=int, default=16, help="LoRA alpha")
+    parser.add_argument("--lora_dropout", type=float, default=0.05, help="LoRA dropout")
+    parser.add_argument(
+        "--trust_remote_code",
+        action="store_true",
+        default=False,
+        help="Allow loading model code from the Hub. Required for models like nvidia/esm2_*.",
+    )
+    parser.add_argument(
+        "--train_parquet",
+        type=str,
+        default=None,
+        help="Path to a training parquet file with Sequence and Secondary_structure columns. "
+        "When provided, the synthetic dataset is not generated.",
+    )
+    parser.add_argument(
+        "--val_parquet",
+        type=str,
+        default=None,
+        help="Path to a validation parquet file with the same schema as --train_parquet.",
+    )
+
+    args = parser.parse_args()
+
+    if bool(args.train_parquet) != bool(args.val_parquet):
+        parser.error("--train_parquet and --val_parquet must both be provided or both omitted.")
+
+    return args
+
+
+def set_seed(seed: int):
+    """Set random seeds for reproducibility."""
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+
+
+def build_synthetic_sequences(num_samples: int, min_len: int, max_len: int):
+    """Generate random amino-acid sequences."""
+    sequences = []
+    for _ in range(num_samples):
+        length = random.randint(min_len, max_len)
+        sequences.append("".join(random.choices(AMINO_ACIDS, k=length)))
+    return sequences
+
+
+def ss_char_to_label(char: str) -> int:
+    """Map a single secondary structure character to a label id (H/E/C)."""
+    return SS3_LABEL2ID.get(char, SS3_LABEL2ID["C"])
+
+
+def tokenize_and_align_labels(sequences, label_strings, tokenizer, max_length: int):
+    """Tokenize protein sequences and align per-residue label strings to token positions."""
+    batch_input_ids = []
+    batch_attention_mask = []
+    batch_labels = []
+
+    for sequence, label_str in zip(sequences, label_strings):
+        encoded = tokenizer(
+            sequence,
+            truncation=True,
+            max_length=max_length,
+            add_special_tokens=True,
+        )
+        input_ids = encoded["input_ids"]
+        attention_mask = encoded["attention_mask"]
+
+        labels = [-100] * len(input_ids)
+        usable_len = min(len(sequence), len(label_str), len(input_ids) - 2)
+        for idx in range(usable_len):
+            labels[idx + 1] = ss_char_to_label(label_str[idx])
+
+        batch_input_ids.append(input_ids)
+        batch_attention_mask.append(attention_mask)
+        batch_labels.append(labels)
+
+    return {
+        "input_ids": batch_input_ids,
+        "attention_mask": batch_attention_mask,
+        "labels": batch_labels,
+    }
+
+
+def load_parquet_dataset(train_path: str, val_path: str, tokenizer, max_length: int):
+    """Load train/val parquet files and return tokenized Datasets."""
+    train_df = pd.read_parquet(train_path)
+    val_df = pd.read_parquet(val_path)
+
+    train_dataset = Dataset.from_pandas(train_df).map(
+        lambda ex: tokenize_and_align_labels(ex["Sequence"], ex["Secondary_structure"], tokenizer, max_length),
+        batched=True,
+        remove_columns=train_df.columns.tolist(),
+    )
+    val_dataset = Dataset.from_pandas(val_df).map(
+        lambda ex: tokenize_and_align_labels(ex["Sequence"], ex["Secondary_structure"], tokenizer, max_length),
+        batched=True,
+        remove_columns=val_df.columns.tolist(),
+    )
+    return train_dataset, val_dataset
+
+
+def compute_metrics(eval_pred):
+    """Compute token accuracy while ignoring -100 labels."""
+    logits, labels = eval_pred
+    predictions = np.argmax(logits, axis=-1)
+    mask = labels != -100
+    correct = (predictions == labels) & mask
+    total_tokens = mask.sum()
+    accuracy = float(correct.sum() / total_tokens) if total_tokens > 0 else 0.0
+    return {"token_accuracy": accuracy}
+
+
+def residue_to_ss_char(aa: str) -> str:
+    """Map an amino acid to a synthetic secondary structure character (H/E/C)."""
+    if aa in HELIX_AA:
+        return "H"
+    if aa in BETA_AA:
+        return "E"
+    return "C"
+
+
+def sequence_to_synthetic_labels(sequence: str) -> str:
+    """Derive a synthetic per-residue label string from an amino acid sequence."""
+    return "".join(residue_to_ss_char(aa) for aa in sequence)
+
+
+def make_synthetic_dataset(
+    tokenizer,
+    num_train_samples: int,
+    num_eval_samples: int,
+    min_seq_len: int,
+    max_seq_len: int,
+    max_length: int,
+):
+    """Create a synthetic train/eval dataset for token classification."""
+    train_sequences = build_synthetic_sequences(num_train_samples, min_seq_len, max_seq_len)
+    eval_sequences = build_synthetic_sequences(num_eval_samples, min_seq_len, max_seq_len)
+
+    train_labels = [sequence_to_synthetic_labels(s) for s in train_sequences]
+    eval_labels = [sequence_to_synthetic_labels(s) for s in eval_sequences]
+
+    train_dataset = Dataset.from_dict({"sequence": train_sequences, "labels_str": train_labels}).map(
+        lambda ex: tokenize_and_align_labels(ex["sequence"], ex["labels_str"], tokenizer, max_length),
+        batched=True,
+        remove_columns=["sequence", "labels_str"],
+    )
+    eval_dataset = Dataset.from_dict({"sequence": eval_sequences, "labels_str": eval_labels}).map(
+        lambda ex: tokenize_and_align_labels(ex["sequence"], ex["labels_str"], tokenizer, max_length),
+        batched=True,
+        remove_columns=["sequence", "labels_str"],
+    )
+    return train_dataset, eval_dataset
+
+
+def main():
+    args = parse_args()
+    set_seed(args.seed)
+
+    if not args.trust_remote_code and "esm2" in args.base_model.lower():
+        raise ValueError(
+            f"Model '{args.base_model}' requires remote code execution. "
+            "Re-run with --trust_remote_code to confirm you trust this model's code."
+        )
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    use_bf16 = torch.cuda.is_available() and torch.cuda.is_bf16_supported()
+    model_dtype = torch.bfloat16 if use_bf16 else torch.float32
+
+    print(f"Loading tokenizer and model from: {args.base_model}")
+    tokenizer = AutoTokenizer.from_pretrained(args.base_model, trust_remote_code=args.trust_remote_code)
+
+    config = AutoConfig.from_pretrained(args.base_model, trust_remote_code=args.trust_remote_code)
+    config.num_labels = 3
+    config.id2label = SS3_ID2LABEL
+    config.label2id = SS3_LABEL2ID
+
+    model = AutoModelForTokenClassification.from_pretrained(
+        args.base_model,
+        config=config,
+        trust_remote_code=args.trust_remote_code,
+        dtype=model_dtype,
+    )
+
+    lora_config = LoraConfig(
+        task_type=TaskType.TOKEN_CLS,
+        r=args.lora_r,
+        lora_alpha=args.lora_alpha,
+        lora_dropout=args.lora_dropout,
+        target_modules=["layernorm_qkv"],
+        bias="none",
+        inference_mode=False,
+    )
+    model = get_peft_model(model, lora_config)
+    model.print_trainable_parameters()
+
+    if args.train_parquet and args.val_parquet:
+        print(f"Loading parquet datasets: train={args.train_parquet}, val={args.val_parquet}")
+        train_dataset, eval_dataset = load_parquet_dataset(
+            train_path=args.train_parquet,
+            val_path=args.val_parquet,
+            tokenizer=tokenizer,
+            max_length=args.max_length,
+        )
+    else:
+        print("Building synthetic dataset...")
+        train_dataset, eval_dataset = make_synthetic_dataset(
+            tokenizer=tokenizer,
+            num_train_samples=args.num_train_samples,
+            num_eval_samples=args.num_eval_samples,
+            min_seq_len=args.min_seq_len,
+            max_seq_len=args.max_seq_len,
+            max_length=args.max_length,
+        )
+
+    data_collator = DataCollatorForTokenClassification(tokenizer=tokenizer)
+
+    training_args = TrainingArguments(
+        output_dir=args.output_dir,
+        num_train_epochs=args.num_epochs,
+        per_device_train_batch_size=args.batch_size,
+        per_device_eval_batch_size=args.batch_size,
+        learning_rate=args.learning_rate,
+        weight_decay=args.weight_decay,
+        logging_steps=args.logging_steps,
+        eval_steps=args.eval_steps,
+        save_steps=args.save_steps,
+        eval_strategy="steps",
+        save_strategy="steps",
+        save_total_limit=2,
+        load_best_model_at_end=True,
+        metric_for_best_model="token_accuracy",
+        greater_is_better=True,
+        report_to="none",
+        remove_unused_columns=False,
+        bf16=use_bf16,
+        seed=args.seed,
+    )
+
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_dataset,
+        eval_dataset=eval_dataset,
+        data_collator=data_collator,
+        compute_metrics=compute_metrics,
+    )
+
+    trainer.train()
+    final_metrics = trainer.evaluate()
+    print(f"Final evaluation metrics: {final_metrics}")
+
+    model.save_pretrained(args.output_dir)
+    tokenizer.save_pretrained(args.output_dir)
+    print(f"Saved LoRA adapter and tokenizer to: {args.output_dir}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/lora_finetuning_transformer_engine/requirements.txt b/examples/lora_finetuning_transformer_engine/requirements.txt
new file mode 100644
index 0000000..5beaf16
--- /dev/null
+++ b/examples/lora_finetuning_transformer_engine/requirements.txt
@@ -0,0 +1,12 @@
+torch
+transformers
+datasets
+peft
+accelerate
+numpy
+pandas
+pyarrow
+safetensors
+# transformer-engine must match the system CUDA toolkit version.
+# Install it separately or use the system-provided package.
+# See: https://docs.nvidia.com/deeplearning/transformer-engine/user-guide/installation.html
diff --git a/examples/lora_ga_finetuning/README.md b/examples/lora_ga_finetuning/README.md
new file mode 100644
index 0000000..dd422ba
--- /dev/null
+++ b/examples/lora_ga_finetuning/README.md
@@ -0,0 +1,295 @@
+# LoRA-GA: Low-Rank Adaptation with Gradient Approximation
+
+## Introduction
+
+[LoRA-GA](https://huggingface.co/papers/2407.05000) improves upon standard LoRA by using gradient information during initialization instead of random initialization. By performing SVD on estimated gradients, LoRA-GA initializes adapter weights in a direction that aligns with full fine-tuning, achieving 2-4x faster convergence while maintaining the same final performance. The method is orthogonal to existing LoRA variants and can be easily integrated with techniques like DoRA and LoRA+.
+
+## Quick start
+
+This example script demonstrates how to fine-tune a language model using LoRA-GA on the WikiText-2 dataset. The script performs gradient estimation on a small number of batches, uses those gradients to initialize LoRA adapters, and then trains the model with the Hugging Face Trainer.
+
+```python
+import torch
+from datasets import load_dataset
+from transformers import AutoTokenizer, AutoModelForCausalLM, Trainer, TrainingArguments
+from torch.utils.data import DataLoader
+from peft import LoraConfig, get_peft_model
+from peft.tuners.lora import LoraGAConfig, preprocess_loraga
+
+# Load model and tokenizer
+model = AutoModelForCausalLM.from_pretrained("gpt2")
+tokenizer = AutoTokenizer.from_pretrained("gpt2")
+dataset = load_dataset("wikitext", "wikitext-2-raw-v1")
+
+# Prepare dataloader for gradient estimation
+train_dataloader = DataLoader(dataset["train"], batch_size=2, shuffle=True)
+
+# Define train_step callback for gradient estimation
+def train_step():
+    """Run forward and backward passes for gradient estimation."""
+    data_iter = iter(train_dataloader)
+    for _ in range(64):  # 64 iterations
+        batch = next(data_iter)
+
+        outputs = model(**batch)
+        loss = outputs.loss
+        loss.backward()
+
+# Step 1: Create LoRA-GA config
+lora_ga_config = LoraGAConfig(
+    direction="ArB2r",
+    scale="stable",
+    stable_gamma=16,
+)
+
+lora_config = LoraConfig(
+    r=8,
+    lora_alpha=16,
+    target_modules=["c_attn"],
+    init_lora_weights="lora_ga",
+    lora_ga_config=lora_ga_config,
+    task_type="CAUSAL_LM",
+)
+
+# Step 2: Preprocess with LoRA-GA to estimate gradients
+preprocess_loraga(model, lora_config, train_step)
+
+# Step 3: Create PEFT model with LoRA-GA initialization
+peft_model = get_peft_model(model, lora_config)
+
+# Step 4: Train normally
+trainer = Trainer(
+    model=peft_model,
+    train_dataset=dataset["train"],
+    args=TrainingArguments(output_dir="./output", num_train_epochs=3),
+)
+trainer.train()
+
+# Step 5: Save the trained adapter
+peft_model.save_pretrained("./output")
+```
+
+## Saving with Modified Base Weights
+
+**Important**: LoRA-GA modifies the base model weights during initialization (unlike standard LoRA). This means you need to handle saving carefully if you want to restore the original base weights.
+
+### Option 1: Save adapter only (default)
+
+The standard `save_pretrained()` saves the adapter with the modified base weights embedded:
+
+```python
+# This saves the adapter - base weights remain modified
+peft_model.save_pretrained("./output")
+```
+
+### Option 2: Restore original base weights
+
+If you need to restore the original base weights (e.g., for model merging or sharing), use `path_initial_model_for_weight_conversion`:
+
+```python
+# Save the original model BEFORE LoRA-GA preprocessing
+model.save_pretrained("./original_model")
+
+# ... do preprocessing and training ...
+
+# Save adapter and convert back to original base weights
+peft_model.save_pretrained(
+    "./output",
+    path_initial_model_for_weight_conversion="./original_model"
+)
+```
+
+This is useful when:
+- You want to merge the adapter with the original base weights later
+- You're sharing the adapter and want users to apply it to the unmodified base model
+- You need the base model weights in their original state for other purposes
+
+## Run the finetuning script
+
+Simply run:
+
+```bash
+python examples/lora_ga_finetuning/lora_ga_finetuning.py \
+    --base_model gpt2 \
+    --dataset_name wikitext \
+    --dataset_config wikitext-2-raw-v1 \
+    --output_dir ./lora_ga_output
+```
+
+### Customize LoRA-GA parameters
+
+You can customize the direction and scaling strategies:
+
+```bash
+python examples/lora_ga_finetuning/lora_ga_finetuning.py \
+    --base_model gpt2 \
+    --direction ArB2r \
+    --scale stable \
+    --stable_gamma 16 \
+    --grad_estimate_iters 64
+```
+
+### Full example with all parameters
+
+```bash
+python lora_ga_finetuning.py \
+    --base_model "gpt2" \
+    --dataset_name "wikitext" \
+    --dataset_config "wikitext-2-raw-v1" \
+    --output_dir "./lora_ga_output" \
+    --r 8 \
+    --lora_alpha 16 \
+    --lora_dropout 0.1 \
+    --direction "ArB2r" \
+    --scale "stable" \
+    --stable_gamma 16 \
+    --grad_estimate_iters 64 \
+    --grad_estimate_batch_size 2 \
+    --num_epochs 3 \
+    --batch_size 8 \
+    --learning_rate 3e-5
+```
+
+## Configuration Options
+
+### Direction Strategies
+
+Controls how SVD components are distributed to lora_A and lora_B:
+
+- `ArBr`: Alternating distribution - A takes odd indices, B takes even indices
+- `A2rBr`: A takes second half, B takes first half
+- `ArB2r` (default): A takes first half, B takes second half - typically performs best
+- `random`: Random selection of singular vectors
+
+### Scaling Strategies
+
+Controls initialization magnitude:
+
+- `stable` (default): Conservative scaling using stable_gamma parameter for stable training
+- `weight_svd`: Scales based on SVD of original weights for better alignment
+- `gd_scale`: Scales based on gradient descent step size
+- `unit`: Unit scaling (no adjustment)
+
+## Use the model on 🤗
+
+You can load and use the model as any other 🤗 models:
+
+```python
+from transformers import AutoModelForCausalLM
+from peft import PeftModel
+
+model = AutoModelForCausalLM.from_pretrained("gpt2")
+model = PeftModel.from_pretrained(model, "path/to/lora_ga_output")
+```
+
+## LoRA-GA vs. LoRA
+
+Key differences and advantages:
+
+1. **Faster Convergence**: LoRA-GA achieves 2-4x faster convergence compared to standard LoRA due to gradient-aligned initialization.
+
+2. **Same Final Performance**: LoRA-GA maintains the same or better final performance as standard LoRA.
+
+3. **Initialization Overhead**: LoRA-GA requires a gradient estimation phase (typically 1-2 minutes for 64 iterations), but this is quickly amortized during training.
+
+4. **Orthogonal to Other Methods**: LoRA-GA can be combined with DoRA, LoRA+, quantization, and other LoRA enhancements.
+
+## API Design
+
+LoRA-GA follows the same pattern as PiSSA, OLoRA, and CorDA:
+
+1. **Preprocessing**: Use `preprocess_loraga(model, lora_config, train_step)` to estimate gradients and attach them to model layers
+2. **Configuration**: Use `LoraGAConfig` as a sub-config within `LoraConfig` with `init_lora_weights="lora_ga"`
+3. **Initialization**: Call `get_peft_model()` after preprocessing to create the PEFT model with LoRA-GA initialization
+4. **Training**: Train normally using Hugging Face Trainer or your own training loop
+5. **Saving**: Use standard `save_pretrained()` to save the trained adapter
+
+## Using LoRA-GA with Quantized Models
+
+LoRA-GA requires full-precision gradients during preprocessing. For quantized models (e.g., BitsAndBytes 4-bit/8-bit), use a two-stage workflow:
+
+### Step 1: Estimate gradients with full-precision model
+
+```python
+import torch
+from transformers import AutoModelForCausalLM, BitsAndBytesConfig
+from peft import LoraConfig, get_peft_model
+from peft.tuners.lora import LoraGAConfig, preprocess_loraga
+
+# Load model in full precision for gradient estimation
+model = AutoModelForCausalLM.from_pretrained(
+    "meta-llama/Llama-2-7b-hf",
+    torch_dtype=torch.bfloat16,
+    device_map="auto"
+)
+
+# Configure LoRA-GA
+lora_config = LoraConfig(
+    r=8,
+    target_modules=["q_proj", "v_proj"],
+    init_lora_weights="lora_ga",
+    lora_ga_config=LoraGAConfig(direction="ArB2r", scale="stable"),
+)
+
+# Define your train_step (same as before)
+def train_step():
+    for _ in range(64):
+        # Your training logic here
+        outputs = model(**batch)
+        loss = outputs.loss
+        loss.backward()
+
+# Estimate and cache gradients
+preprocess_loraga(model, lora_config, train_step, cache_file="loraga_gradients.pt")
+
+# Clean up full-precision model
+del model
+torch.cuda.empty_cache()
+```
+
+### Step 2: Load quantized model and apply LoRA-GA
+
+```python
+# Load model with quantization
+quantization_config = BitsAndBytesConfig(load_in_4bit=True)
+model = AutoModelForCausalLM.from_pretrained(
+    "meta-llama/Llama-2-7b-hf",
+    quantization_config=quantization_config,
+    device_map="auto"
+)
+
+# Apply LoRA-GA - gradients will be loaded from cache automatically
+peft_model = get_peft_model(model, lora_config)
+
+# Train normally
+trainer.train()
+```
+
+**Key points:**
+- Gradient estimation must use a non-quantized model (full precision or bfloat16/float16)
+- Cache gradients with `cache_file` parameter to avoid re-computation
+- Cached gradients are automatically loaded when applying LoRA to the quantized model
+- This workflow allows memory-efficient training with quantized models while benefiting from LoRA-GA's faster convergence
+
+## Tips
+
+- **Gradient Estimation**: 64-128 iterations is typically sufficient. More iterations provide more accurate estimation but increase initialization time.
+
+- **Batch Size**: Use smaller batch sizes (2-4) for gradient estimation to maximize gradient diversity.
+
+- **Direction and Scale**: The default `direction="ArB2r"` and `scale="stable"` work well in most cases.
+
+- **User-Defined Callback**: The `train_step` callback gives you full control over the gradient estimation process. You can customize batching, loss functions, and more.
+
+- **Gradient Accumulation**: Do NOT call `model.zero_grad()` or `optimizer.zero_grad()` inside your `train_step` callback. LoRA-GA relies on PyTorch's natural gradient accumulation across iterations.
+
+## Citation
+
+```bibtex
+@article{wang2024loraga,
+  title={LoRA-GA: Low-Rank Adaptation with Gradient Approximation},
+  author={Wang, Shaowen and Zhu, Linxi and Ding, Hengyuan and Liu, Jiaqi and Chen, Jiaming and Zhu, Kaikai and Pang, Wei and Zhu, Jun and You, Yang},
+  journal={arXiv preprint arXiv:2407.05000},
+  year={2024}
+}
+```
diff --git a/examples/lora_ga_finetuning/lora_ga_finetuning.py b/examples/lora_ga_finetuning/lora_ga_finetuning.py
new file mode 100755
index 0000000..afafb89
--- /dev/null
+++ b/examples/lora_ga_finetuning/lora_ga_finetuning.py
@@ -0,0 +1,279 @@
+#!/usr/bin/env python3
+"""
+Example script demonstrating LoRA-GA (Low-Rank Adaptation with Gradient Approximation) fine-tuning.
+
+LoRA-GA improves upon standard LoRA by using gradient information during initialization,
+achieving 2-4x faster convergence while maintaining the same final performance.
+
+This example shows:
+1. How to define a train_step callback for gradient estimation
+2. How to use preprocess_loraga for LoRA-GA initialization
+3. Training with standard Hugging Face Trainer
+4. Saving the trained adapter
+"""
+
+import argparse
+import os
+
+import torch
+from datasets import load_dataset
+from torch.utils.data import DataLoader
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    DataCollatorForLanguageModeling,
+    Trainer,
+    TrainingArguments,
+    default_data_collator,
+)
+
+from peft import LoraConfig, get_peft_model
+from peft.tuners.lora import LoraGAConfig, preprocess_loraga
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="LoRA-GA fine-tuning example")
+
+    # Model arguments
+    parser.add_argument("--base_model", type=str, default="gpt2", help="Base model name or path")
+    parser.add_argument("--output_dir", type=str, default="./lora_ga_output", help="Output directory")
+
+    # Dataset arguments
+    parser.add_argument("--dataset_name", type=str, default="wikitext", help="Dataset name")
+    parser.add_argument("--dataset_config", type=str, default="wikitext-2-raw-v1", help="Dataset configuration")
+    parser.add_argument("--max_length", type=int, default=512, help="Maximum sequence length")
+
+    # LoRA-GA configuration
+    parser.add_argument("--r", type=int, default=8, help="LoRA rank")
+    parser.add_argument("--lora_alpha", type=int, default=16, help="LoRA alpha")
+    parser.add_argument("--lora_dropout", type=float, default=0.1, help="LoRA dropout")
+    parser.add_argument(
+        "--target_modules",
+        type=str,
+        nargs="+",
+        default=["c_attn"],
+        help="Target modules for LoRA (e.g., c_attn for GPT-2)",
+    )
+    parser.add_argument(
+        "--direction",
+        type=str,
+        default="ArB2r",
+        choices=["ArBr", "A2rBr", "ArB2r", "random"],
+        help="Direction strategy for LoRA-GA initialization",
+    )
+    parser.add_argument(
+        "--scale",
+        type=str,
+        default="stable",
+        choices=["stable", "weight_svd", "gd_scale", "unit"],
+        help="Scaling strategy for LoRA-GA initialization",
+    )
+    parser.add_argument("--stable_gamma", type=int, default=16, help="Gamma for stable scaling")
+
+    # Gradient estimation arguments
+    parser.add_argument(
+        "--grad_estimate_iters", type=int, default=64, help="Number of iterations for gradient estimation"
+    )
+    parser.add_argument("--grad_estimate_batch_size", type=int, default=2, help="Batch size for gradient estimation")
+
+    # Training arguments
+    parser.add_argument("--num_epochs", type=int, default=3, help="Number of training epochs")
+    parser.add_argument("--batch_size", type=int, default=8, help="Training batch size")
+    parser.add_argument("--learning_rate", type=float, default=3e-5, help="Learning rate")
+    parser.add_argument("--warmup_steps", type=int, default=100, help="Warmup steps")
+    parser.add_argument("--logging_steps", type=int, default=10, help="Logging steps")
+    parser.add_argument("--save_steps", type=int, default=500, help="Save checkpoint steps")
+    parser.add_argument("--eval_steps", type=int, default=500, help="Evaluation steps")
+
+    # Other arguments
+    parser.add_argument("--seed", type=int, default=42, help="Random seed")
+
+    return parser.parse_args()
+
+
+def prepare_dataset(dataset_name, dataset_config, tokenizer, max_length):
+    """Load and prepare the dataset."""
+    print(f"\nLoading dataset: {dataset_name}/{dataset_config}")
+    dataset = load_dataset(dataset_name, dataset_config)
+
+    def tokenize_function(examples):
+        # For causal language modeling, we tokenize and set labels = input_ids
+        result = tokenizer(
+            examples["text"], padding="max_length", truncation=True, max_length=max_length, return_tensors="pt"
+        )
+        result["labels"] = result["input_ids"].clone()
+        return result
+
+    # Tokenize the dataset
+    print("Tokenizing dataset...")
+    tokenized_datasets = dataset.map(
+        tokenize_function, batched=True, remove_columns=dataset["train"].column_names, desc="Tokenizing"
+    )
+
+    return tokenized_datasets
+
+
+def main():
+    args = parse_args()
+
+    # Set random seed
+    torch.manual_seed(args.seed)
+
+    # Create output directory
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    # Load tokenizer and model
+    print(f"\nLoading model: {args.base_model}")
+    tokenizer = AutoTokenizer.from_pretrained(args.base_model)
+    tokenizer.pad_token = tokenizer.eos_token
+
+    model = AutoModelForCausalLM.from_pretrained(args.base_model)
+
+    # Prepare dataset
+    tokenized_datasets = prepare_dataset(args.dataset_name, args.dataset_config, tokenizer, args.max_length)
+
+    # Create LoRA-GA configuration
+    print("\nCreating LoRA-GA configuration...")
+    lora_ga_config = LoraGAConfig(
+        direction=args.direction,
+        scale=args.scale,
+        stable_gamma=args.stable_gamma,
+    )
+
+    lora_config = LoraConfig(
+        r=args.r,
+        lora_alpha=args.lora_alpha,
+        lora_dropout=args.lora_dropout,
+        target_modules=args.target_modules,
+        bias="none",
+        task_type="CAUSAL_LM",
+        init_lora_weights="lora_ga",
+        lora_ga_config=lora_ga_config,
+    )
+    print(f"  Direction: {args.direction}")
+    print(f"  Scale: {args.scale}")
+    print(f"  Rank: {args.r}, Alpha: {args.lora_alpha}")
+
+    # ===== GRADIENT ESTIMATION PHASE =====
+    print("\n" + "=" * 70)
+    print("GRADIENT ESTIMATION PHASE")
+    print("=" * 70)
+    print(f"Estimating gradients over {args.grad_estimate_iters} iterations...")
+    print("This allows LoRA-GA to initialize adapters aligned with full fine-tuning.")
+
+    # Prepare gradient estimation dataloader
+    train_dataset = tokenized_datasets["train"]
+
+    # Create a simple DataLoader for gradient estimation
+    grad_dataloader = DataLoader(
+        train_dataset,
+        batch_size=args.grad_estimate_batch_size,
+        shuffle=True,
+        collate_fn=default_data_collator,
+    )
+
+    # Move model to GPU if available
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = model.to(device)
+    model.train()
+
+    # Define train_step callback
+    def train_step():
+        """Run forward and backward passes for gradient estimation."""
+        grad_iter = iter(grad_dataloader)
+        for _ in range(args.grad_estimate_iters):
+            batch = next(grad_iter)
+
+            # Move batch to device
+            batch = {k: v.to(device) for k, v in batch.items()}
+
+            # Forward pass
+            outputs = model(**batch)
+            loss = outputs.loss
+
+            # Backward pass
+            loss.backward()
+
+    # Preprocess with LoRA-GA
+    print("Running gradient estimation...")
+    preprocess_loraga(model, lora_config, train_step)
+    print("✓ Gradient estimation complete!")
+
+    # ===== MODEL INITIALIZATION PHASE =====
+    print("\n" + "=" * 70)
+    print("LORA-GA INITIALIZATION PHASE")
+    print("=" * 70)
+    print("Initializing LoRA adapters with gradient information...")
+
+    # Create PEFT model with LoRA-GA initialization
+    peft_model = get_peft_model(model, lora_config)
+
+    # Print trainable parameters
+    peft_model.print_trainable_parameters()
+
+    # ===== TRAINING PHASE =====
+    print("\n" + "=" * 70)
+    print("TRAINING PHASE")
+    print("=" * 70)
+    print("Starting training with LoRA-GA initialized adapters...")
+    print("LoRA-GA achieves 2-4x faster convergence compared to random initialization!\n")
+
+    # Setup training arguments
+    training_args = TrainingArguments(
+        output_dir=args.output_dir,
+        num_train_epochs=args.num_epochs,
+        per_device_train_batch_size=args.batch_size,
+        per_device_eval_batch_size=args.batch_size,
+        learning_rate=args.learning_rate,
+        warmup_steps=args.warmup_steps,
+        logging_steps=args.logging_steps,
+        save_steps=args.save_steps,
+        eval_steps=args.eval_steps,
+        eval_strategy="steps",
+        save_total_limit=2,
+        load_best_model_at_end=True,
+        report_to="none",
+        seed=args.seed,
+    )
+
+    # Data collator
+    data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)
+
+    # Create Trainer
+    trainer = Trainer(
+        model=peft_model,
+        args=training_args,
+        train_dataset=tokenized_datasets["train"],
+        eval_dataset=tokenized_datasets["validation"],
+        data_collator=data_collator,
+    )
+
+    # Train the model
+    trainer.train()
+
+    # ===== SAVING PHASE =====
+    print("\n" + "=" * 70)
+    print("SAVING PHASE")
+    print("=" * 70)
+    print("Saving trained adapter...")
+
+    # Save the trained adapter
+    peft_model.save_pretrained(args.output_dir)
+
+    print(f"\n✓ Training complete! Model saved to: {args.output_dir}")
+    print("\nSaved files:")
+    print("  - adapter_model.safetensors: Trained adapter weights")
+    print("  - adapter_config.json: Configuration file")
+
+    print("\n" + "=" * 70)
+    print("DONE!")
+    print("=" * 70)
+    print("\nYou can now use the trained adapter with:")
+    print("  from peft import PeftModel")
+    print("  from transformers import AutoModelForCausalLM")
+    print(f"  model = AutoModelForCausalLM.from_pretrained('{args.base_model}')")
+    print(f"  model = PeftModel.from_pretrained(model, '{args.output_dir}')")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/lorafa_finetune/README.md b/examples/lorafa_finetune/README.md
new file mode 100644
index 0000000..1c1314d
--- /dev/null
+++ b/examples/lorafa_finetune/README.md
@@ -0,0 +1,121 @@
+# LoRA-FA: Memory-efficient Low-rank Adaptation for Large Language Models Fine-tuning
+
+## Introduction
+
+[LoRA-FA](https://huggingface.co/papers/2308.03303) is a noval Parameter-efficient Fine-tuning method, which freezes the projection down layer (matrix A) during LoRA training process and thus lead to less accelerator memory consumption by eliminating the need for storing the activations of input tensors (X). Furthermore, LoRA-FA narrows the gap between the update amount of pre-trained weights when using the low-rank fine-tuning method and the full fine-tuning method. In conclusion, LoRA-FA reduces the memory consumption and leads to superior performance compared to vanilla LoRA.
+
+## Quick start
+
+```python
+import torch
+from peft import LoraConfig, get_peft_model
+from peft.optimizers import create_lorafa_optimizer
+from transformers import AutoTokenizer, AutoModelForCausalLM, Trainer
+from datasets import load_dataset
+
+model = AutoModelForCausalLM.from_pretrained("meta-llama/Meta-Llama-3-8B-Instruct")
+tokenizer = AutoTokenizer.from_pretrained("meta-llama/Meta-Llama-3-8B-Instruct")
+dataset = load_dataset("timdettmers/openassistant-guanaco", split="train")
+
+lora_rank = 16
+lora_alpha = 32
+
+lora_config = LoraConfig(
+    r=lora_rank,
+    lora_alpha=lora_alpha,
+    bias="none",
+)
+peft_model = get_peft_model(model, lora_config)
+optimizer = create_lorafa_optimizer(
+    model=peft_model,
+    r=lora_rank,
+    lora_alpha=lora_alpha,
+    lr=7e-5,
+)
+# you can also use scheduler, we recommend get_cosine_schedule_with_warmup from transformers
+# for better model performance
+scheduler = None
+
+trainer = transformers.Trainer(
+    model=peft_model,
+    train_dataset=dataset,
+    dataset_text_field="text",
+    max_length=2048,
+    processing_class=tokenizer,
+    optimizers=(optimizer, None),
+)
+trainer.train()
+peft_model.save_pretrained("lorafa-llama-3-8b-inst")
+```
+
+The only change in your code is to pass the LoRA-FA optimizer to the trainer (if training with trainer). Do not forget `from peft.optimizers import create_lorafa_optimizer`!
+
+## Example
+
+In this dir, we also provide you a simple example for fine-tuning with LoRA-FA optimizer.
+
+### Run on CPU, single-accelerator or multi-accelerator
+
+This 👇 by default will load the model in peft set up with LoRA config, and train the model with LoRA-FA optimizer.
+
+0. CPU
+
+You can simply run LoRA-FA as below:
+
+```bash
+python lorafa_finetuning.py --base_model_name_or_path meta-llama/Meta-Llama-3-8B --dataset_name_or_path meta-math/MetaMathQA-40K --output_dir path/to/output --lorafa
+```
+
+1. Single-accelerator
+
+Run the finetuning script on 1 accelerator:
+
+```bash
+export CUDA_VISIBLE_DEVICES=0  # force to use CUDA GPU 0
+export ZE_AFFINITY_MASK=0      # force to use Intel XPU 0
+
+python lorafa_finetuning.py --base_model_name_or_path meta-llama/Meta-Llama-3-8B --dataset_name_or_path meta-math/MetaMathQA-40K --output_dir path/to/output --lorafa
+```
+
+2. Multi-accelerator
+
+LoRA-FA can also be run on multi-accelerator, with 🤗 Accelerate:
+
+```bash
+export CUDA_VISIBLE_DEVICES=0,1,2,3 # force to use CUDA GPU 0,1,2,3
+export ZE_AFFINITY_MASK=0,1,2,3     # force to use Intel XPU 0,1,2,3
+
+accelerate launch lorafa_finetuning.py --base_model_name_or_path meta-llama/Meta-Llama-3-8B --dataset_name_or_path meta-math/MetaMathQA-40K --output_dir path/to/output --lorafa
+```
+
+The `accelerate launch` will automatically configure multi-accelerator for you. You can also utilize `accelerate launch` in single-accelerator scenario.
+
+### Use the model from 🤗
+You can load and use the model as any other 🤗 models.
+```python
+from transformers import AutoModel
+model = AutoModel.from_pretrained("meta-llama/Llama-2-7b-chat-hf")
+```
+
+## Best practice in fine-tuning Llama using LoRA-FA: the hyper-params
+
+Sometimes, achieving optimal LoRA fine-tuning can be challenging due to the larger number of hyperparameters to consider compared to full fine-tuning. For instance, not only do we need to adjust the commonly used learning rate, but the ideal LoRA rank may also vary depending on the specific model and task. Additionally, there are other factors to consider, such as LoRA alpha and sequence length. To assist with this, we have created a repository of reproducible best practices in the [LoRA-FA examples](https://github.com/AaronZLT/lorafa) for reference. This resource showcases the optimal LoRA-FA fine-tuning hyperparameters for different models across various datasets. By doing so, we significantly reduce the time and effort spent on hyperparameter tuning, and it may also provide insights for tuning other training hyperparameters. We encourage you to experiment and fine-tune on your own downstream tasks as well.
+
+## LoRA-FA's advantages and limitations
+
+By eliminating the activation of adapter A, LoRA-FA uses less memory for fine-tuning compared to LoRA. For instance, when fine-tuning Llama-2-7b-chat-hf with a batch size of 8 and a sequence length of 1024, LoRA-FA requires 36GB of memory to store activations. This allows it to run successfully on an 80GB accelerator. In contrast, LoRA requires at least 60GB of memory for activations, leading to an Out of Memory (OOM) error. Additionally, the memory consumption of LoRA-FA is not sensitive to the rank, allowing for performance improvements by increasing the LoRA rank without additional memory usage. LoRA-FA further narrows the performance gap with Full-FT by minimizing the discrepancy between the low-rank gradient and the full gradient, enabling it to achieve performance that is on par with or even superior to vanilla LoRA.
+
+Despite its advantages, LoRA-FA is inherently limited by its low-rank approximation nature and potential issues with catastrophic forgetting. The gradient approximation can impact training throughput. Addressing these limitations, especially in terms of approximation accuracy and forgetting phenomena, presents a promising direction for future research.
+
+## Citation
+```
+@misc{zhang2023lorafamemoryefficientlowrankadaptation,
+      title={LoRA-FA: Memory-efficient Low-rank Adaptation for Large Language Models Fine-tuning}, 
+      author={Longteng Zhang and Lin Zhang and Shaohuai Shi and Xiaowen Chu and Bo Li},
+      year={2023},
+      eprint={2308.03303},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://huggingface.co/papers/2308.03303}, 
+}
+```
diff --git a/examples/lorafa_finetune/lorafa_finetuning.py b/examples/lorafa_finetune/lorafa_finetuning.py
new file mode 100644
index 0000000..3c96c0c
--- /dev/null
+++ b/examples/lorafa_finetune/lorafa_finetuning.py
@@ -0,0 +1,221 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+import os
+from typing import Optional
+
+import torch
+from datasets import load_dataset
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    BitsAndBytesConfig,
+    DataCollatorForLanguageModeling,
+    Trainer,
+    TrainingArguments,
+)
+
+from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+from peft.optimizers import create_lorafa_optimizer
+
+
+def train_model(
+    base_model_name_or_path: str,
+    dataset_name_or_path: str,
+    output_dir: str,
+    batch_size: int,
+    num_epochs: int,
+    lr: float,
+    cutoff_len: int,
+    quantize: bool,
+    eval_step: int,
+    save_step: int,
+    lora_rank: int,
+    lora_alpha: int,
+    lora_dropout: float,
+    lora_target_modules: Optional[str],
+    lorafa: bool,
+):
+    os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+    is_bf16_supported = False
+    device_map = "cpu"
+    if torch.cuda.is_available():
+        is_bf16_supported = torch.cuda.is_bf16_supported()
+        device_map = "cuda"
+    elif torch.xpu.is_available():
+        is_bf16_supported = torch.xpu.is_bf16_supported()
+        device_map = "xpu"
+    compute_dtype = torch.bfloat16 if is_bf16_supported else torch.float16
+
+    # load tokenizer
+    tokenizer = AutoTokenizer.from_pretrained(base_model_name_or_path)
+
+    # load model
+    if quantize:
+        model = AutoModelForCausalLM.from_pretrained(
+            base_model_name_or_path,
+            quantization_config=BitsAndBytesConfig(
+                load_in_4bit=True,
+                bnb_4bit_compute_dtype=compute_dtype,
+                bnb_4bit_use_double_quant=False,
+                bnb_4bit_quant_type="nf4",
+            ),
+            dtype=compute_dtype,
+            device_map=device_map,
+        )
+        # setup for quantized training
+        model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True)
+    else:
+        model = AutoModelForCausalLM.from_pretrained(
+            base_model_name_or_path, dtype=compute_dtype, device_map=device_map
+        )
+
+    # LoRA config for the PEFT model
+    if lora_target_modules is not None:
+        if lora_target_modules == "all-linear":
+            target_modules = "all-linear"
+        else:
+            target_modules = lora_target_modules.split(",")
+    else:
+        target_modules = ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
+
+    lora_config = LoraConfig(
+        r=lora_rank,
+        lora_alpha=lora_alpha,
+        target_modules=target_modules,
+        lora_dropout=lora_dropout,
+        bias="none",
+    )
+
+    # get the peft model with LoRA config
+    model = get_peft_model(model, lora_config)
+
+    tokenizer.pad_token = tokenizer.eos_token
+
+    # Load the dataset
+    dataset = load_dataset(dataset_name_or_path)
+
+    def tokenize_function(examples):
+        inputs = tokenizer(examples["query"], padding="max_length", truncation=True, max_length=cutoff_len)
+        outputs = tokenizer(examples["response"], padding="max_length", truncation=True, max_length=cutoff_len)
+        inputs["labels"] = outputs["input_ids"].copy()
+        return inputs
+
+    # Tokenize the dataset and prepare for training
+    tokenized_datasets = dataset.map(tokenize_function, batched=True, remove_columns=dataset["train"].column_names)
+    dataset = tokenized_datasets["train"].train_test_split(test_size=0.1, shuffle=True, seed=42)
+    train_dataset = dataset["train"]
+    eval_dataset = dataset["test"]
+
+    # Data collator to dynamically pad the batched examples
+    data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)
+
+    # Define training arguments
+    training_args = TrainingArguments(
+        output_dir=output_dir,
+        num_train_epochs=num_epochs,
+        per_device_train_batch_size=batch_size,
+        per_device_eval_batch_size=batch_size,
+        warmup_steps=100,
+        weight_decay=0.01,
+        logging_dir="./logs",
+        logging_steps=eval_step,
+        save_steps=save_step,
+        save_total_limit=2,
+        gradient_accumulation_steps=1,
+        bf16=compute_dtype == torch.bfloat16,
+        fp16=compute_dtype == torch.float16,
+        learning_rate=lr,
+    )
+
+    # Here we initialize the LoRA-FA Optimizer
+    # After this, all adapter A will be fixed, only adapter B will be trainable
+    if lorafa:
+        optimizer = create_lorafa_optimizer(
+            model=model, r=lora_rank, lora_alpha=lora_alpha, lr=lr, weight_decay=training_args.weight_decay
+        )
+        trainer = Trainer(
+            model=model,
+            args=training_args,
+            train_dataset=train_dataset,
+            eval_dataset=eval_dataset,
+            data_collator=data_collator,
+            optimizers=(optimizer, None),
+        )
+    else:
+        trainer = Trainer(
+            model=model,
+            args=training_args,
+            train_dataset=train_dataset,
+            eval_dataset=eval_dataset,
+            data_collator=data_collator,
+        )
+
+    # Start model training
+    trainer.train()
+
+    # Save the model and tokenizer locally
+    model.save_pretrained(output_dir)
+    tokenizer.save_pretrained(output_dir)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Fine-tune Meta-Llama-3-8B-Instruct with LoRA-FA and PEFT")
+    parser.add_argument(
+        "--base_model_name_or_path",
+        type=str,
+        default="meta-llama/Meta-Llama-3-8B-Instruct",
+        help="Base model name or path",
+    )
+    parser.add_argument(
+        "--dataset_name_or_path", type=str, default="meta-math/MetaMathQA-40K", help="Dataset name or path"
+    )
+    parser.add_argument("--output_dir", type=str, help="Output directory for the fine-tuned model")
+    parser.add_argument("--batch_size", type=int, default=1, help="Batch size")
+    parser.add_argument("--num_epochs", type=int, default=3, help="Number of training epochs")
+    parser.add_argument("--lr", type=float, default=7e-5, help="Learning rate")
+    parser.add_argument("--cutoff_len", type=int, default=1024, help="Cutoff length for tokenization")
+    parser.add_argument("--quantize", action="store_true", help="Use quantization")
+    parser.add_argument("--eval_step", type=int, default=10, help="Evaluation step interval")
+    parser.add_argument("--save_step", type=int, default=100, help="Save step interval")
+    parser.add_argument("--lora_rank", type=int, default=16, help="LoRA rank")
+    parser.add_argument("--lora_alpha", type=int, default=32, help="LoRA alpha")
+    parser.add_argument("--lora_dropout", type=float, default=0.05, help="LoRA dropout rate")
+    parser.add_argument(
+        "--lora_target_modules", type=str, default=None, help="Comma-separated list of target modules for LoRA"
+    )
+    parser.add_argument("--lorafa", action="store_true", help="Use LoRA-FA Optimizer")
+
+    args = parser.parse_args()
+
+    train_model(
+        base_model_name_or_path=args.base_model_name_or_path,
+        dataset_name_or_path=args.dataset_name_or_path,
+        output_dir=args.output_dir,
+        batch_size=args.batch_size,
+        num_epochs=args.num_epochs,
+        lr=args.lr,
+        cutoff_len=args.cutoff_len,
+        quantize=args.quantize,
+        eval_step=args.eval_step,
+        save_step=args.save_step,
+        lora_rank=args.lora_rank,
+        lora_alpha=args.lora_alpha,
+        lora_dropout=args.lora_dropout,
+        lora_target_modules=args.lora_target_modules,
+        lorafa=args.lorafa,
+    )
diff --git a/examples/mica_finetuning/README.md b/examples/mica_finetuning/README.md
new file mode 100644
index 0000000..20e6c9f
--- /dev/null
+++ b/examples/mica_finetuning/README.md
@@ -0,0 +1,91 @@
+# MiCA: Minor Component Adaptation
+
+## Introduction ([Paper](https://arxiv.org/abs/2604.01694))
+
+Minor Component Adaptation (MiCA) is a parameter-efficient fine-tuning method closely related to LoRA. Like LoRA, MiCA inserts a low-rank update `ΔW = (α/r) · B · A` into a pretrained weight `W ∈ R^{out×in}`. Unlike LoRA, MiCA initializes the matrices from the singular value decomposition of `W` and trains only one of them:
+
+- Compute the SVD `W = U Σ V^T`.
+- Initialize `B = U[:, -r:]` — the `r` left singular vectors associated with the **smallest** singular values.
+- Initialize `A = 0`.
+- During training, optimize only `A`; `W` and `B` remain frozen.
+
+The motivation is that the *minor* singular directions of a pretrained weight encode subspaces that are largely unused by the original task. Restricting adaptation to these directions provides a more "plastic" subspace for knowledge injection, with less risk of overwriting capabilities encoded in the dominant subspace. Empirically MiCA improves knowledge acquisition while reducing the trainable parameter footprint compared with LoRA at the same rank (because only `A` is trained, the parameter count is roughly halved for matching `r`).
+
+Because `A == 0` at initialization, the adapter contribution `B · A == 0` and the model's forward output is preserved exactly at step 0 — no residual subtraction is needed on the base weight.
+
+## Quick Start
+
+```python
+import torch
+from peft import LoraConfig, get_peft_model
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from trl import SFTConfig, SFTTrainer
+from datasets import load_dataset
+
+model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf", dtype=torch.bfloat16, device_map="auto")
+tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf")
+tokenizer.pad_token_id = tokenizer.eos_token_id
+
+lora_config = LoraConfig(
+    init_lora_weights="mica",
+    r=16,
+    lora_alpha=16,
+    target_modules=["q_proj", "v_proj"],
+    task_type="CAUSAL_LM",
+)
+peft_model = get_peft_model(model, lora_config)
+peft_model.print_trainable_parameters()
+
+dataset = load_dataset("imdb", split="train[:1%]")
+training_args = SFTConfig(dataset_text_field="text", max_length=128)
+trainer = SFTTrainer(
+    model=peft_model,
+    args=training_args,
+    train_dataset=dataset,
+    processing_class=tokenizer,
+)
+trainer.train()
+peft_model.save_pretrained("mica-llama-2-7b")
+```
+
+To reload the trained adapter:
+
+```python
+import torch
+from peft import PeftModel
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained(
+    "meta-llama/Llama-2-7b-hf", dtype=torch.bfloat16, device_map="auto"
+)
+peft_model = PeftModel.from_pretrained(model, "mica-llama-2-7b")
+```
+
+## Notes and limitations
+
+- MiCA currently supports `nn.Linear` and `nn.Embedding` target modules.
+- The chosen rank must satisfy `r <= min(in_features, out_features)` for linear layers and `r <= min(num_embeddings, embedding_dim)` for embedding layers; otherwise initialization raises `ValueError`.
+- MiCA performs a full SVD per target weight at initialization. For 7B-scale models this is a one-time cost of seconds; for substantially larger weight matrices (e.g. 70B-scale) the cost grows.
+- Combining MiCA with `use_dora=True` or other LoRA variants is not supported in this initial integration.
+
+## Recommended workflow
+
+MiCA is designed for continued pretraining / domain-adaptive pretraining. For this use case, start from the base model rather than an instruction- or chat-tuned checkpoint. The SVD initialization is computed from the weights of the model being adapted, so the intended workflow is:
+
+1. Load the base model.
+2. Train the MiCA adapter on continued-pretraining/domain data.
+3. Merge the adapter into the base model weights.
+4. Use the merged model as the adapted base for later instruction/chat tuning.
+
+Applying a MiCA adapter trained on the base model directly to an already instruction-tuned model with matching architecture may be technically possible, but it is not the primary recommended workflow.
+
+## Citation
+
+```
+@article{rudiger2026mica,
+  title={MiCA Learns More Knowledge Than LoRA and Full Fine-Tuning},
+  author={R{\"u}diger, Sten and Raschka, Sebastian},
+  journal={arXiv preprint arXiv:2604.01694},
+  year={2026}
+}
+```
diff --git a/examples/mica_finetuning/mica_finetuning.py b/examples/mica_finetuning/mica_finetuning.py
new file mode 100644
index 0000000..a00806f
--- /dev/null
+++ b/examples/mica_finetuning/mica_finetuning.py
@@ -0,0 +1,80 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+"""Minimal MiCA fine-tuning example.
+
+Mirrors `examples/pissa_finetuning/pissa_finetuning.py` in spirit but with the MiCA-specific knobs only. MiCA
+initializes `B` from the bottom-r left singular vectors of the base weight and freezes it during training; only
+`A` is updated. Because `A == 0` at init, the adapter is a no-op on initialization and no residual subtraction
+on the base weight is needed.
+"""
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+import torch
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoTokenizer, HfArgumentParser
+from trl import SFTConfig, SFTTrainer
+
+from peft import LoraConfig, get_peft_model
+
+
+@dataclass
+class ScriptArguments(SFTConfig):
+    base_model_name_or_path: Optional[str] = field(default=None, metadata={"help": "Name or path of the base model."})
+    lora_r: int = field(default=16)
+    lora_alpha: int = field(default=16)
+    lora_dropout: float = field(default=0.0)
+    target_modules: Optional[str] = field(
+        default="q_proj,v_proj",
+        metadata={"help": "Comma-separated module names to adapt with MiCA."},
+    )
+    data_path: str = field(default="imdb", metadata={"help": "HF dataset path."})
+    dataset_split: str = field(default="train[:1%]")
+    dataset_text_field: str = field(default="text")
+
+
+def train():
+    parser = HfArgumentParser(ScriptArguments)
+    args = parser.parse_args_into_dataclasses()[0]
+
+    model = AutoModelForCausalLM.from_pretrained(args.base_model_name_or_path, dtype=torch.bfloat16, device_map="auto")
+    tokenizer = AutoTokenizer.from_pretrained(args.base_model_name_or_path)
+    if tokenizer.pad_token_id is None:
+        tokenizer.pad_token_id = tokenizer.eos_token_id
+
+    lora_config = LoraConfig(
+        init_lora_weights="mica",
+        r=args.lora_r,
+        lora_alpha=args.lora_alpha,
+        lora_dropout=args.lora_dropout,
+        target_modules=[m.strip() for m in args.target_modules.split(",")],
+        task_type="CAUSAL_LM",
+    )
+    peft_model = get_peft_model(model, lora_config)
+    peft_model.print_trainable_parameters()
+
+    dataset = load_dataset(args.data_path, split=args.dataset_split)
+    trainer = SFTTrainer(
+        model=peft_model,
+        args=args,
+        train_dataset=dataset,
+        processing_class=tokenizer,
+    )
+    trainer.train()
+    peft_model.save_pretrained(args.output_dir)
+
+
+if __name__ == "__main__":
+    train()
diff --git a/examples/miss_finetuning/README.md b/examples/miss_finetuning/README.md
new file mode 100644
index 0000000..72e1494
--- /dev/null
+++ b/examples/miss_finetuning/README.md
@@ -0,0 +1,106 @@
+# MiSS: Balancing LoRA Performance and Efficiency with Simple Shard Sharing
+## Introduction ([Paper](https://huggingface.co/papers/2409.15371), [code](https://github.com/JL-er/MiSS))
+MiSS (Matrix Shard Sharing) is a novel PEFT method that adopts a low-rank structure, requires only a single trainable matrix, and introduces a new update mechanism distinct from LoRA, achieving an excellent balance between performance and efficiency.
+
+
+## Quick Start
+```python
+import torch
+from peft import MissConfig, get_peft_model
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from trl import SFTConfig, SFTTrainer
+from datasets import load_dataset
+
+model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf", dtype=torch.bfloat16, device_map="auto")
+tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf")
+tokenizer.pad_token_id = tokenizer.eos_token_id
+
+miss_config = MissConfig(
+    r = 64,
+    miss_dropout = 0.01
+)
+#bat: In this mode, you can enable nonlinear updates across different shards.
+# miss_config = MissConfig(
+#     r = 64,
+#     init_weights="bat"
+# )
+
+# mini: In this mode, you can set a smaller rank to use fewer trainable parameters, but it is recommended to keep `out_features % mini_r == 0`.
+# miss_config = MissConfig(
+#     r = 64,
+#     init_weights="mini",
+#     mini_r = 8
+# )
+peft_model = get_peft_model(model, miss_config)
+
+peft_model.print_trainable_parameters()
+
+dataset = load_dataset("imdb", split="train[:1%]")
+
+training_args = SFTConfig(dataset_text_field="text", max_length=128)
+trainer = SFTTrainer(
+    model=peft_model,
+    args=training_args,
+    train_dataset=dataset,
+    processing_class=tokenizer,
+)
+trainer.train()
+peft_model.save_pretrained("miss-llama-2-7b")
+```
+
+
+To utilize the fine-tuned MiSS modules, simply run the following command:
+```python
+import torch
+from peft import PeftModel
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained(
+    "meta-llama/Llama-2-7b-hf", dtype=torch.bfloat16, device_map="auto"
+)
+peft_model = PeftModel.from_pretrained(model, "miss-llama-2-7b")
+```
+
+## Advanced Usage
+
+### Fine-tune 
+```shell
+#Bat performs better than MiSS, but it uses more memory and is twice as slow. If you want to use the Bat method, you only need to add the parameter init_weights="bat".
+python miss_finetuning.py \
+    --base_model_name_or_path meta-llama/Llama-2-7b-hf \
+    --output_dir output/miss-llama-2-7b-metamath-10k \
+    --miss_r 64 \
+    --miss_dropout 0.01 \
+    --init_weights True \
+    --bits bf16 \
+    --data_path meta-math/MetaMathQA \
+    --dataset_split train[:100000] \
+    --dataset_field query response \
+    --bf16 True \
+    --num_train_epochs 1 \
+    --per_device_train_batch_size 2 \
+    --gradient_accumulation_steps 8 \
+    --save_strategy "steps" \
+    --save_steps 1000 \
+    --save_total_limit 1 \
+    --logging_steps 1 \
+    --learning_rate 2e-5 \
+    --weight_decay 0. \
+    --warmup_steps 0.03 \
+    --tf32 True \
+    --report_to none
+```
+
+
+
+# Citation
+```bib
+@misc{kang2025missrevisitingtradeofflora,
+  title={MiSS: Revisiting the Trade-off in LoRA with an Efficient Shard-Sharing Structure},
+  author={Jiale Kang and Qingyu Yin},
+  year={2025},
+  eprint={2409.15371},
+  archivePrefix={arXiv},
+  primaryClass={cs.CL},
+  url={https://arxiv.org/abs/2409.15371},
+}
diff --git a/examples/miss_finetuning/miss_finetuning.py b/examples/miss_finetuning/miss_finetuning.py
new file mode 100644
index 0000000..f4235ca
--- /dev/null
+++ b/examples/miss_finetuning/miss_finetuning.py
@@ -0,0 +1,109 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+import os
+from dataclasses import dataclass, field
+from typing import Literal, Optional
+
+import torch
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoTokenizer, HfArgumentParser
+from trl import SFTConfig, SFTTrainer
+
+from peft import MissConfig, get_peft_model
+
+
+@dataclass
+class ScriptArguments(SFTConfig):
+    # model configs
+    base_model_name_or_path: Optional[str] = field(
+        default=None, metadata={"help": "The name or path of the fp32/16 base model."}
+    )
+    bits: str = field(default="bf16", metadata={"help": "(`['bf16', 'fp16', fp32]`)"})
+    init_weights: Literal[True, "bat"] = field(
+        default=True,
+        metadata={
+            "help": (
+                "True -> MiSS efficiency and balance; `bat` -> Bat, `mini` -> smaller MiSS efficiency and balance"
+            ),
+        },
+    )
+    miss_r: int = field(default=16)
+    miss_dropout: float = field(default=0.0)
+    merge_and_save: bool = field(default=False)
+    # dataset configs
+    data_path: str = field(default="imdb", metadata={"help": "Path to the training data."})
+    dataset_split: str = field(default="train[:1%]", metadata={"help": "(`['train', 'test', 'eval']`):"})
+    dataset_field: list[str] = field(default=None, metadata={"help": "Fields of dataset input and output."})
+
+
+parser = HfArgumentParser(ScriptArguments)
+script_args = parser.parse_args_into_dataclasses()[0]
+print(script_args)
+
+print(f"Load pre-processed residual model in {script_args.bits} bits.")
+if script_args.bits in ["nf4", "fp4", "int8"]:
+    print("MiSS currently does not support quantization.")
+
+elif script_args.base_model_name_or_path is not None:
+    print(f"No available pre-processed model, manually initialize a MiSS using {script_args.base_model_name_or_path}.")
+    model = AutoModelForCausalLM.from_pretrained(
+        script_args.base_model_name_or_path,
+        dtype=(
+            torch.float16
+            if script_args.bits == "fp16"
+            else (torch.bfloat16 if script_args.bits == "bf16" else torch.float32)
+        ),
+        device_map="auto",
+    )
+    tokenizer = AutoTokenizer.from_pretrained(script_args.base_model_name_or_path)
+    tokenizer.pad_token_id = tokenizer.eos_token_id
+    miss_config = MissConfig(
+        r=script_args.miss_r,
+        miss_dropout=script_args.miss_dropout,
+        target_modules=["q_proj", "o_proj", "k_proj", "v_proj", "gate_proj", "up_proj", "down_proj"],
+        bias="none",
+        task_type="CAUSAL_LM",
+        init_weights=script_args.init_weights,
+    )
+    peft_model = get_peft_model(model, miss_config)
+
+print(peft_model)
+peft_model.print_trainable_parameters()
+
+print(f"Training MiSS with trl on the {script_args.data_path}[{script_args.dataset_split}] dataset.")
+dataset = load_dataset(script_args.data_path, split=script_args.dataset_split)
+dataset = dataset.map(
+    lambda example: {
+        "text": f"### USER: {example[script_args.dataset_field[0]]}\n### ASSISTANT: {example[script_args.dataset_field[1]]}"
+    }
+)
+
+trainer = SFTTrainer(
+    model=peft_model,
+    args=script_args,
+    train_dataset=dataset,
+    processing_class=tokenizer,
+)
+trainer.train()
+trainer.save_state()
+
+peft_model.save_pretrained(
+    os.path.join(script_args.output_dir, "miss_ft"),
+)
+
+if script_args.merge_and_save:
+    model = peft_model.merge_and_unload()
+    model.save_pretrained(os.path.join(script_args.output_dir, "miss_merged"))
+    tokenizer.save_pretrained(os.path.join(script_args.output_dir, "miss_merged"))
diff --git a/examples/monteclora_finetuning/sequence_classification_finetune_monteclora.py b/examples/monteclora_finetuning/sequence_classification_finetune_monteclora.py
new file mode 100644
index 0000000..c43d37c
--- /dev/null
+++ b/examples/monteclora_finetuning/sequence_classification_finetune_monteclora.py
@@ -0,0 +1,203 @@
+import argparse
+import os
+
+import evaluate
+import numpy as np
+from datasets import load_dataset
+from transformers import (
+    AutoModelForSequenceClassification,
+    AutoTokenizer,
+    DataCollatorWithPadding,
+    Trainer,
+    TrainingArguments,
+)
+
+# Assuming MonteCLoRA is available in your local installed PEFT version
+from peft import LoraConfig, MontecloraConfig, TaskType, get_peft_model
+from peft.helpers import MontecloraTrainerMixin as MonteCLoRATrainerMixin
+from peft.utils import infer_device
+
+
+# ----------------------------------------------------------------------------
+# 1. Trainer Definition
+# ----------------------------------------------------------------------------
+# Reuse the helper mixin so variational loss handling stays centralized.
+class MonteCLoRATrainer(MonteCLoRATrainerMixin, Trainer):
+    pass
+
+
+# ----------------------------------------------------------------------------
+# 2. Metrics Helper
+# ----------------------------------------------------------------------------
+# GLUE/MRPC uses Accuracy and F1 score
+metric = evaluate.load("glue", "mrpc")
+
+
+def compute_metrics(eval_pred):
+    predictions, labels = eval_pred
+    predictions = np.argmax(predictions, axis=1)
+    return metric.compute(predictions=predictions, references=labels)
+
+
+# ----------------------------------------------------------------------------
+# 3. Main Training Function
+# ----------------------------------------------------------------------------
+def train_model(
+    base_model: str,
+    output_dir: str,
+    batch_size: int,
+    num_epochs: int,
+    learning_rate: float,
+    max_length: int,
+    device: str,
+    rank: int,
+    lora_alpha: int,
+    target_modules: str,
+    n_samples: int,
+    push_to_hub: bool,
+    hub_model_id: str,
+):
+    hf_token = os.getenv("HF_TOKEN") or None
+
+    # --- Device Setup ---
+    device = infer_device()
+    print(f"Using device: {device}")
+
+    # --- Load Tokenizer ---
+    tokenizer = AutoTokenizer.from_pretrained(base_model, token=hf_token)
+
+    # --- Load Dataset (GLUE MRPC) ---
+    # MRPC is a classification task (Is sentence B a paraphrase of sentence A?)
+    dataset = load_dataset("glue", "mrpc")
+
+    def tokenize_function(examples):
+        return tokenizer(
+            examples["sentence1"], examples["sentence2"], padding="max_length", truncation=True, max_length=max_length
+        )
+
+    tokenized_datasets = dataset.map(tokenize_function, batched=True)
+
+    # Remove raw text columns to avoid Trainer warnings
+    tokenized_datasets = tokenized_datasets.remove_columns(["sentence1", "sentence2", "idx"])
+    tokenized_datasets = tokenized_datasets.rename_column("label", "labels")
+    tokenized_datasets.set_format("torch")
+
+    # --- Load Base Model ---
+    # num_labels=2 because MRPC is binary classification
+    model = AutoModelForSequenceClassification.from_pretrained(base_model, num_labels=2, token=hf_token)
+
+    # --- PEFT Configuration (MonteCLoRA) ---
+    # Note: Using n_samples to control Monte Carlo iterations
+    monte_clora_config = MontecloraConfig(num_samples=n_samples)
+    peft_config = LoraConfig(
+        task_type=TaskType.SEQ_CLS,
+        inference_mode=False,
+        r=rank,
+        lora_alpha=lora_alpha,
+        target_modules=target_modules.split(",") if target_modules else ["query", "value"],
+        bias="none",
+        monteclora_config=monte_clora_config,
+    )
+
+    # {'loss': 0.6984, 'grad_norm': 1.1652556657791138, 'learning_rate': 0.00019843478260869567, 'epoch': 0.04}
+    # {'loss': 0.6794, 'grad_norm': 1.619783878326416, 'learning_rate': 0.00019669565217391306, 'epoch': 0.09}
+    # {'loss': 0.7077, 'grad_norm': 0.7201359272003174, 'learning_rate': 0.00019495652173913045, 'epoch': 0.13}
+    # {'loss': 0.6822, 'grad_norm': 2.9292023181915283, 'learning_rate': 0.00019321739130434784, 'epoch': 0.17}
+    # {'loss': 0.6673, 'grad_norm': 0.6151084899902344, 'learning_rate': 0.0001914782608695652, 'epoch': 0.22}
+    # {'loss': 0.6674, 'grad_norm': 0.7056446671485901, 'learning_rate': 0.00018973913043478262, 'epoch': 0.26}
+    # Wrap model with PEFT
+    model = get_peft_model(model, peft_config)
+    model.print_trainable_parameters()
+    print(model)
+    model.to(device)
+
+    # --- Training Setup ---
+    data_collator = DataCollatorWithPadding(tokenizer=tokenizer)
+
+    training_args = TrainingArguments(
+        output_dir=output_dir,
+        num_train_epochs=num_epochs,
+        per_device_train_batch_size=batch_size,
+        per_device_eval_batch_size=batch_size,
+        learning_rate=learning_rate,
+        weight_decay=0.01,
+        eval_strategy="epoch",  # Evaluate at end of every epoch
+        save_strategy="epoch",
+        load_best_model_at_end=True,
+        metric_for_best_model="f1",  # Optimize for F1 score
+        logging_steps=10,
+        push_to_hub=push_to_hub,
+        hub_model_id=hub_model_id,
+        hub_token=hf_token,
+        remove_unused_columns=False,  # Important for PEFT sometimes
+    )
+
+    # Trainer mixes in MonteCLoRA variational regularization support.
+    trainer = MonteCLoRATrainer(
+        model=model,
+        args=training_args,
+        train_dataset=tokenized_datasets["train"],
+        eval_dataset=tokenized_datasets["validation"],  # MRPC standard validation split
+        tokenizer=tokenizer,
+        data_collator=data_collator,
+        compute_metrics=compute_metrics,
+    )
+
+    print("Starting Training...")
+    trainer.train()
+
+    # --- Evaluation ---
+    print("Evaluating...")
+    eval_results = trainer.evaluate()
+    print(f"Evaluation Results: {eval_results}")
+
+    # --- Save & Push ---
+    if push_to_hub:
+        trainer.push_to_hub()
+
+    trainer.save_model(output_dir)
+    print(f"Model saved to {output_dir}")
+
+
+# ----------------------------------------------------------------------------
+# 4. Entry Point
+# ----------------------------------------------------------------------------
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Fine-tune RoBERTa on MRPC with MonteCLoRA")
+
+    parser.add_argument("--base_model", type=str, default="roberta-base", help="Base model name")
+    parser.add_argument("--output_dir", type=str, default="./monteclora-roberta-mrpc", help="Output directory")
+    parser.add_argument("--batch_size", type=int, default=16, help="Batch size (per device)")
+    parser.add_argument("--num_epochs", type=int, default=5, help="Training epochs")
+    parser.add_argument(
+        "--learning_rate", type=float, default=2e-4, help="Learning rate"
+    )  # Higher LR for PEFT is common
+    parser.add_argument("--max_length", type=int, default=128, help="Max sequence length")
+    parser.add_argument("--device", type=str, default="auto", help="Device (cuda/cpu/auto)")
+
+    # MonteCLoRA specific args
+    parser.add_argument("--rank", type=int, default=8, help="LoRA Rank")
+    parser.add_argument("--lora_alpha", type=int, default=16, help="LoRA Alpha")
+    parser.add_argument("--target_modules", type=str, default="query,value", help="Modules to apply adapter to")
+    parser.add_argument("--n_samples", type=int, default=10, help="Number of MC samples")
+
+    parser.add_argument("--push_to_hub", action="store_true", help="Push to HF Hub")
+    parser.add_argument("--hub_model_id", type=str, default=None, help="Hub Repo ID")
+
+    args = parser.parse_args()
+
+    train_model(
+        base_model=args.base_model,
+        output_dir=args.output_dir,
+        batch_size=args.batch_size,
+        num_epochs=args.num_epochs,
+        learning_rate=args.learning_rate,
+        max_length=args.max_length,
+        device=args.device,
+        rank=args.rank,
+        lora_alpha=args.lora_alpha,
+        target_modules=args.target_modules,
+        n_samples=args.n_samples,
+        push_to_hub=args.push_to_hub,
+        hub_model_id=args.hub_model_id,
+    )
diff --git a/examples/multi_adapter_examples/Lora_Merging.ipynb b/examples/multi_adapter_examples/Lora_Merging.ipynb
new file mode 100644
index 0000000..7778c1a
--- /dev/null
+++ b/examples/multi_adapter_examples/Lora_Merging.ipynb
@@ -0,0 +1,194 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "db4208b9-5da4-46df-b77a-0f1836c9e4ec",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\"  # force using CUDA device 1\n",
+    "os.environ[\"ZE_AFFINITY_MASK\"] = \"1\"  # force using Intel XPU device 1\n",
+    "from peft import PeftConfig, PeftModel\n",
+    "from peft import PeftModel, PeftConfig\n",
+    "from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig\n",
+    "from datasets import load_dataset\n",
+    "import torch\n",
+    "import random\n",
+    "\n",
+    "peft_model_id = \"smangrul/tinyllama_lora_norobots\"\n",
+    "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "config = PeftConfig.from_pretrained(peft_model_id)\n",
+    "model_kwargs = {\"device_map\": \"auto\"}\n",
+    "model_kwargs[\"quantization_config\"] = BitsAndBytesConfig(load_in_4bit=True)\n",
+    "model = AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path, **model_kwargs)\n",
+    "tokenizer = AutoTokenizer.from_pretrained(peft_model_id)\n",
+    "model.resize_token_embeddings(len(tokenizer))\n",
+    "model = PeftModel.from_pretrained(model, peft_model_id, adapter_name=\"norobots\")\n",
+    "_ = model.load_adapter(\"smangrul/tinyllama_lora_sql\", adapter_name=\"sql\")\n",
+    "_ = model.load_adapter(\"smangrul/tinyllama_lora_adcopy\", adapter_name=\"adcopy\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "541dab43-9675-42a2-8d90-7437df9f0fa0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 17.1 s, sys: 458 ms, total: 17.5 s\n",
+      "Wall time: 1.94 s\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "# [0.8, 0.1, 0.1] linear #[1.0, 0.2] 0.7 density dare_linear #[1.5, 0.3] 0.5 density ties #[0.8, 0.5] cat\n",
+    "adapters = [\"norobots\", \"adcopy\", \"sql\"]\n",
+    "weights = [2.0, 0.3, 0.7]\n",
+    "adapter_name = \"merge\"\n",
+    "density = 0.2\n",
+    "combination_type = \"ties\"\n",
+    "if adapter_name in model.peft_config:\n",
+    "    model.delete_adapter(adapter_name)\n",
+    "model.add_weighted_adapter(adapters, weights, adapter_name, combination_type=combination_type, density=density)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "76596671-3677-47f0-9d66-81f40bc4d726",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model.eval()\n",
+    "model.set_adapter(\"merge\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9d59f9f3-6313-43d8-be36-4ca2bbb105b2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "messages = [\n",
+    "    {\"role\": \"user\", \"content\": \"Write an essay about Generative AI.\"},\n",
+    "]\n",
+    "text = tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False)\n",
+    "inputs = tokenizer(text, return_tensors=\"pt\")  # , add_special_tokens=False)\n",
+    "inputs = {k: v.to(device) for k, v in inputs.items()}\n",
+    "outputs = model.generate(\n",
+    "    **inputs,\n",
+    "    max_new_tokens=256,\n",
+    "    do_sample=True,\n",
+    "    top_p=0.95,\n",
+    "    temperature=0.2,\n",
+    "    repetition_penalty=1.2,\n",
+    "    eos_token_id=tokenizer.eos_token_id,\n",
+    ")\n",
+    "print(tokenizer.decode(outputs[0]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e5c1daeb-59c8-41d7-bebb-7abd052ab917",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<s><|im_start|>system \n",
+      "Create a text ad given the following product and description.<|im_end|> \n",
+      "<|im_start|>user \n",
+      "Product: Sony PS5 PlayStation Console\n",
+      "Description: The PS5™ console unleashes new gaming possibilities that you never anticipated.<|im_end|> \n",
+      "<|im_start|>assistant \n",
+      "Ad Text: Experience the next-gen power of the all-new Sony PS5 with its stunning visuals, innovative gameplay features, and more! Get ready to play in style as you experience the future of gaming on your own terms.<|im_end|>\n"
+     ]
+    }
+   ],
+   "source": [
+    "messages = [\n",
+    "    {\"role\": \"system\", \"content\": \"Create a text ad given the following product and description.\"},\n",
+    "    {\n",
+    "        \"role\": \"user\",\n",
+    "        \"content\": \"Product: Sony PS5 PlayStation Console\\nDescription: The PS5™ console unleashes new gaming possibilities that you never anticipated.\",\n",
+    "    },\n",
+    "]\n",
+    "text = tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False)\n",
+    "inputs = tokenizer(text, return_tensors=\"pt\")  # , add_special_tokens=False)\n",
+    "inputs = {k: v.to(device) for k, v in inputs.items()}\n",
+    "outputs = model.generate(\n",
+    "    **inputs,\n",
+    "    max_new_tokens=128,\n",
+    "    do_sample=True,\n",
+    "    top_p=0.95,\n",
+    "    temperature=0.2,\n",
+    "    repetition_penalty=1.2,\n",
+    "    eos_token_id=tokenizer.eos_token_id,\n",
+    ")\n",
+    "print(tokenizer.decode(outputs[0]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5bb08b46-90ae-48a8-8783-ca74b3e26e42",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<s> Table: 2-11365528-2\n",
+      "Columns: ['Team', 'Head Coach', 'President', 'Home Ground', 'Location']\n",
+      "Natural Query: Who is the Head Coach of the team whose President is Mario Volarevic?\n",
+      "SQL Query: SELECT Head Coach FROM 2-11365528-2 WHERE President = Mario Volarevic</s>\n"
+     ]
+    }
+   ],
+   "source": [
+    "text = \"\"\"Table: 2-11365528-2\n",
+    "Columns: ['Team', 'Head Coach', 'President', 'Home Ground', 'Location']\n",
+    "Natural Query: Who is the Head Coach of the team whose President is Mario Volarevic?\n",
+    "SQL Query:\"\"\"\n",
+    "\n",
+    "inputs = tokenizer(text, return_tensors=\"pt\")  # , add_special_tokens=False)\n",
+    "inputs = {k: v.to(device) for k, v in inputs.items()}\n",
+    "outputs = model.generate(\n",
+    "    **inputs, max_new_tokens=64, repetition_penalty=1.1, eos_token_id=tokenizer(\"</s>\").input_ids[-1]\n",
+    ")\n",
+    "print(tokenizer.decode(outputs[0]))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/multi_adapter_examples/PEFT_Multi_LoRA_Inference.ipynb b/examples/multi_adapter_examples/PEFT_Multi_LoRA_Inference.ipynb
new file mode 100644
index 0000000..3815a36
--- /dev/null
+++ b/examples/multi_adapter_examples/PEFT_Multi_LoRA_Inference.ipynb
@@ -0,0 +1,367 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "jONLwzXgLg-I",
+   "metadata": {
+    "id": "jONLwzXgLg-I"
+   },
+   "outputs": [],
+   "source": [
+    "!pip install -q git+https://github.com/huggingface/transformers.git\n",
+    "!pip install -q git+https://github.com/huggingface/peft.git\n",
+    "!pip install -q git+https://github.com/huggingface/accelerate.git@main\n",
+    "!pip install huggingface_hub\n",
+    "!pip install bitsandbytes\n",
+    "!pip install SentencePiece"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "36460935",
+   "metadata": {
+    "id": "36460935"
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import torch\n",
+    "\n",
+    "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\" # force using CUDA device 0\n",
+    "os.environ[\"ZE_AFFINITY_MASK\"] = \"0\"  # force using Intel XPU device 0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1351e04c",
+   "metadata": {
+    "id": "1351e04c"
+   },
+   "outputs": [],
+   "source": [
+    "from huggingface_hub import notebook_login\n",
+    "\n",
+    "\n",
+    "notebook_login()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d85af699",
+   "metadata": {
+    "id": "d85af699"
+   },
+   "outputs": [],
+   "source": [
+    "from peft import PeftModel\n",
+    "from transformers import LlamaTokenizer, LlamaForCausalLM, GenerationConfig, BitsAndBytesConfig\n",
+    "\n",
+    "model_name = \"meta-llama/Llama-2-7b-hf\"\n",
+    "tokenizer = LlamaTokenizer.from_pretrained(model_name)\n",
+    "model = LlamaForCausalLM.from_pretrained(model_name, quantization_config=BitsAndBytesConfig(load_in_8bit=True), device_map=\"auto\", use_auth_token=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f0f515ed",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "f0f515ed",
+    "outputId": "312488a5-f4f8-48a4-8c63-7b4a59e80418"
+   },
+   "outputs": [],
+   "source": [
+    "%%time\n",
+    "model = PeftModel.from_pretrained(model, \"tloen/alpaca-lora-7b\", adapter_name=\"eng_alpaca\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "67a0c121",
+   "metadata": {
+    "id": "67a0c121"
+   },
+   "outputs": [],
+   "source": [
+    "%%time\n",
+    "model.load_adapter(\"22h/cabrita-lora-v0-1\", adapter_name=\"portuguese_alpaca\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4b655fca",
+   "metadata": {
+    "id": "4b655fca"
+   },
+   "outputs": [],
+   "source": [
+    "model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e9ebd572",
+   "metadata": {
+    "id": "e9ebd572"
+   },
+   "outputs": [],
+   "source": [
+    "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "\n",
+    "model.to(device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "138805b3",
+   "metadata": {
+    "id": "138805b3"
+   },
+   "outputs": [],
+   "source": [
+    "def generate_prompt(instruction, input=None):\n",
+    "    if input:\n",
+    "        return f\"\"\"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",
+    "### Instruction:\n",
+    "{instruction}\n",
+    "### Input:\n",
+    "{input}\n",
+    "### Response:\"\"\"\n",
+    "    else:\n",
+    "        return f\"\"\"Below is an instruction that describes a task. Write a response that appropriately completes the request.\n",
+    "### Instruction:\n",
+    "{instruction}\n",
+    "### Response:\"\"\"\n",
+    "\n",
+    "\n",
+    "def evaluate(\n",
+    "    instruction,\n",
+    "    input=None,\n",
+    "    temperature=0.1,\n",
+    "    top_p=0.75,\n",
+    "    top_k=40,\n",
+    "    num_beams=4,\n",
+    "    max_new_tokens=256,\n",
+    "    **kwargs,\n",
+    "):\n",
+    "    prompt = generate_prompt(instruction, input)\n",
+    "    inputs = tokenizer(prompt, return_tensors=\"pt\")\n",
+    "    input_ids = inputs[\"input_ids\"].to(device)\n",
+    "    generation_config = GenerationConfig(\n",
+    "        temperature=temperature,\n",
+    "        top_p=top_p,\n",
+    "        top_k=top_k,\n",
+    "        num_beams=num_beams,\n",
+    "        no_repeat_ngram_size=3,\n",
+    "        **kwargs,\n",
+    "    )\n",
+    "\n",
+    "    with torch.no_grad():\n",
+    "        generation_output = model.generate(\n",
+    "            input_ids=input_ids,\n",
+    "            generation_config=generation_config,\n",
+    "            return_dict_in_generate=True,\n",
+    "            output_scores=True,\n",
+    "            max_new_tokens=max_new_tokens,\n",
+    "        )\n",
+    "    s = generation_output.sequences[0]\n",
+    "    output = tokenizer.decode(s)\n",
+    "    return output.split(\"### Response:\")[1].strip()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "fd5e6b3b",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "fd5e6b3b",
+    "outputId": "ec72241b-c427-4258-b02f-2101df0d171a"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 5.16 ms, sys: 443 μs, total: 5.6 ms\n",
+      "Wall time: 5.58 ms\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "model.set_adapter(\"eng_alpaca\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "33650851",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "33650851",
+    "outputId": "aae24052-0f09-4812-88c3-6fb53dec656c"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "The following generation flags are not valid and may be ignored: ['temperature', 'top_p', 'top_k']. Set `TRANSFORMERS_VERBOSITY=info` for more details.\n",
+      "The following generation flags are not valid and may be ignored: ['temperature', 'top_p', 'top_k']. Set `TRANSFORMERS_VERBOSITY=info` for more details.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The alpaca (Vicugna pacos) is a domesticated species of South American camelid. It resembles a small llama in appearance. It is kept in herds that graze on the level heights of the Andes of southern Peru, southern Bolivia, Ecuador, and northern Chile, at an altitude of about 3,800 m (12,500 ft) to 5,000 meters (16,404 ft). It is bred for its fiber, which is similar to sheep's wool but finer, silkier, and more durable. Alpaca fiber is used for making knitted and woven items, such as sweaters, hats, gloves, scarves, a variety of textiles, rugs, and blankets. The wool can be dyed, and is used to make ponchos, blankets, and sweaters in Peru and other Andean countries. The animals are also raised for meat and as a source of dairy products, including milk, butter, and cheese.\n",
+      "Alpaca fleece comes in 22 natural colors, the most\n"
+     ]
+    }
+   ],
+   "source": [
+    "instruction = \"Tell me about alpacas.\"\n",
+    "\n",
+    "print(evaluate(instruction))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "fdc7196e",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "fdc7196e",
+    "outputId": "44cb6742-066b-470e-f507-cbf21e5ae030"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 6 ms, sys: 0 ns, total: 6 ms\n",
+      "Wall time: 5.86 ms\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "model.set_adapter(\"portuguese_alpaca\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "31997da3",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "31997da3",
+    "outputId": "8071de75-dc9d-4e89-e85f-674f1de22658"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "The following generation flags are not valid and may be ignored: ['temperature', 'top_p', 'top_k']. Set `TRANSFORMERS_VERBOSITY=info` for more details.\n",
+      "The following generation flags are not valid and may be ignored: ['temperature', 'top_p', 'top_k']. Set `TRANSFORMERS_VERBOSITY=info` for more details.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "I'm sorry, but I can't make it to the party. I'm not feeling well. I have a headache and I don't think it's a good idea for me to go out tonight. I hope you understand and that you have a great time at the party!</s>\n"
+     ]
+    }
+   ],
+   "source": [
+    "instruction = \"Invente uma desculpa criativa pra dizer que não preciso ir à festa.\"\n",
+    "\n",
+    "print(evaluate(instruction))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "8b8e4e9a",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "8b8e4e9a",
+    "outputId": "84226223-e018-4feb-e189-969c344fd940"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "The following generation flags are not valid and may be ignored: ['temperature', 'top_p', 'top_k']. Set `TRANSFORMERS_VERBOSITY=info` for more details.\n",
+      "The following generation flags are not valid and may be ignored: ['temperature', 'top_p', 'top_k']. Set `TRANSFORMERS_VERBOSITY=info` for more details.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Eu não posso ir porque tenho que fazer uma tarefa para o meu professor.\n",
+      "</s>\n"
+     ]
+    }
+   ],
+   "source": [
+    "with model.disable_adapter():\n",
+    "    instruction = \"Invente uma desculpa criativa pra dizer que não preciso ir à festa.\"\n",
+    "\n",
+    "    print(evaluate(instruction))"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "provenance": []
+  },
+  "gpuClass": "standard",
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/multi_adapter_examples/multi_adapter_weighted_inference_diffusers.ipynb b/examples/multi_adapter_examples/multi_adapter_weighted_inference_diffusers.ipynb
new file mode 100644
index 0000000..595242f
--- /dev/null
+++ b/examples/multi_adapter_examples/multi_adapter_weighted_inference_diffusers.ipynb
@@ -0,0 +1,12881 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This notebook shows how to use the adapter merging methods from `peft` and apply them image generation models using `diffusers`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "QaEZ3dPgGtza"
+   },
+   "source": [
+    "## Turn `diffusers` LoRA checkpoints into `PeftModel`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "KwvBjN-e62ts",
+    "outputId": "19c58dc7-95db-49c6-beb8-3ade1a8fe284"
+   },
+   "outputs": [],
+   "source": [
+    "!pip install diffusers accelerate transformers -U -q\n",
+    "!pip install git+https://github.com/huggingface/peft -q"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "5S64sUQhJqB3"
+   },
+   "outputs": [],
+   "source": [
+    "from google.colab import userdata\n",
+    "TOKEN = userdata.get(\"HF_TOKEN\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 150,
+     "referenced_widgets": [
+      "c9f764b5036042af9f1505e3729cbc32",
+      "b999b3e3af3744a79c0c90657ef37d4e",
+      "f3baef4fbf4b4ec08480522be921f841",
+      "bd2740e191a74558a77a965b4f2d7f28",
+      "6f6a6cfd50404f1ea09f83e95b04550a",
+      "713dec1904ce46f6b2d5a9b7e3e0373a",
+      "a6bb8206de044c74a03d1a64c801e742",
+      "f2c67c29e1224df3b2def5a87eb8d368",
+      "486282a4ead148868005c592d74a4ed4",
+      "48f51c96b7574946bf9542633eb39135",
+      "35c810f4bfe741f091f172cede413950",
+      "67567eea233b423c8acd62773a4adb30",
+      "5161248cd0384d5887ed231ecd48c82e",
+      "6f72ea2c284e4e40899375c7b07c517f",
+      "d99a364420454ba5bfd510d1226b94af",
+      "d33c90e8ea0945d397659f6a90cf51b6",
+      "097fa44254ea4ecda7c8db995f370afc",
+      "9fb982789fbc4582bceb356e351db438",
+      "0204153b17ca4bb0b21fc033393ce9bd",
+      "f02041b1d5e1485bb2ba02b00fc2c242",
+      "4d327c9e91b34c7b84cedd8f9660e9fd",
+      "b44f7154c55146a3bf5f4bd9e438086f",
+      "b27ac2aaff694dd5999ab2cba91195da",
+      "556730e12d5d4e0ea51a0dd1b5aac331",
+      "584dd148b2344bdc92f1d0850399aed7",
+      "ccc5bdc185a84901994577ff7f1bc962",
+      "2c75632d8fdc4458814055172d1d72c3",
+      "2f016774e7854ef589442734d0bb2f08",
+      "a15c3a32bfd347a98c2a50d27cd5b9f9",
+      "67ef71b6521b47dd90e3dc0fd03016f2",
+      "989c54778eb7469fb91e4337d6f49b0b",
+      "439cf6c6f9e845cea4008e3219454ff4",
+      "460c3c96d1724713b78bddcfc1f3eb97"
+     ]
+    },
+    "id": "1YH9xWDcyhaa",
+    "outputId": "8b7b32f4-4b77-411e-f499-7b2cf7650613"
+   },
+   "outputs": [],
+   "source": [
+    "from diffusers import UNet2DConditionModel\n",
+    "import torch\n",
+    "\n",
+    "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "\n",
+    "model_id = \"stabilityai/stable-diffusion-xl-base-1.0\"\n",
+    "unet = UNet2DConditionModel.from_pretrained(\n",
+    "    model_id, subfolder=\"unet\", torch_dtype=torch.float16, use_safetensors=True, variant=\"fp16\"\n",
+    ").to(device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "id": "-kfTBaLR1Mp-"
+   },
+   "outputs": [],
+   "source": [
+    "# So that we can populate it later.\n",
+    "import copy\n",
+    "\n",
+    "sdxl_unet = copy.deepcopy(unet)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 593,
+     "referenced_widgets": [
+      "0b7ffee735044ece90f010c6771d2d69",
+      "27671f87d0f3400b89e34bc428daa53c",
+      "33a018bf2ed547caa69f8ca91dcbb112",
+      "a91df5ceea8647d98f4d49701bb00969",
+      "c8555cb30ade40b9bd9a3435d6deeb67",
+      "b28a2b59aab9478e9ac3ab24a1de6f9a",
+      "c08fca70486040069d4f8f1df46a1074",
+      "bab2458ba3f54b229828ad9c8706aba4",
+      "2a0f746d6eab4680b6c44ec5cdbd8fd9",
+      "5269d405725946b3a657d3a8d7b25885",
+      "b4a697d8335c435ab21219716a1da022",
+      "85f22e78d47641d19efb6e6d62f6a014",
+      "d8bbb7402f3e44b2899fc98f02cee87e",
+      "8b41763280a048d485f06682ddc12ca2",
+      "05791b70a24a42138755141602399c47",
+      "753f64d9069640d985f399a058fc9b5b",
+      "19679186751b42e3ad2c44ea46c82a9c",
+      "d4baf7891f854c9c9898314633f97356",
+      "9c6ab017f5fb46eda8e3c22e9dd2b838",
+      "10bc970e474a46249e2a5e9e43fec7be",
+      "5c838962c7854541b61877c6d42481c4",
+      "4d54c07dd8e94557b82521772c1a2825",
+      "efd33121bdfc4ce195a07c9ef523a477",
+      "d2cd2572973249baa8e130b5777f4147",
+      "4e77d8b6cdb94fc68974d27b24cfb3fd",
+      "c292a598350d4dd4bb9b70aab1320c29",
+      "c68a5ad3bb664e8785e724085d208e96",
+      "b27c74f0c7bf493fa8bcb4c5b9c9c100",
+      "09638c8da74f4dddaf1d5d94dd8ad885",
+      "6a8a634cd3844fa081a4622d224ec940",
+      "2460b9e05b58481e898b139b94532c14",
+      "cdd8f9b1592842b48e1ffa80f8ec8246",
+      "ba9b002888b448738ba4b127e1046f5d",
+      "54ab158c643540abb8b3a96c1ae3ecab",
+      "55130e37444844f88286a87c8d153eba",
+      "7e3048e0fac94dfdaca1bc862ecfce15",
+      "643ba607008547ba9572fa4880a7d0f2",
+      "5738e5d103254c5485856f97d82954ab",
+      "beedc3b275c24432a2e959dcf9dd418d",
+      "10690b309908402289e9891203714199",
+      "0c68c6c65fb94650b15069a25d9e1699",
+      "ad233dfd52034b9e8c6c2c5b86995717",
+      "2ef25bd6dd644347baac12366d7002fd",
+      "0918b23f41e0404e82fccd08cadc6ccf",
+      "b25e822b3f77431fb72b4780067c90d9",
+      "55177afb435f44898df300143703e4d8",
+      "b79d3f5bd8024451bc7148ba2a5029bd",
+      "eacd646e2b984e60ab603bfc6d631de8",
+      "d158a80f4186411a8a9c335a8d5a888e",
+      "7049676db714446b98bba16b5f1b049e",
+      "09172ff4be4e433483d27b576464d1df",
+      "ea257c1c73524141b87ab3c1ef85c908",
+      "c474ed5e340146baae6c38f62013afe3",
+      "2ece04bc10934b3cb9d383abfc5ccd6e",
+      "67a03631ebc54f99928f0feb18ab38af",
+      "40ff502d2d5c40378c25cf84dd3323c8",
+      "230bd59922e84b90b0a141b3ac1e681b",
+      "6d0f946764444df28cb0da0fd0a408eb",
+      "c995197e66e04874a9f5d34db98b8890",
+      "f2596717405c40e1a39b721386e7a972",
+      "f8e6babf4fdd4c8e80d6dd24ff22d464",
+      "5e030e8a026b4513aa954203169f0a27",
+      "f9ca5d4810b34938b6f997ff66a8d541",
+      "b418ff1733db4efbab1b00b632b894e2",
+      "83f2d1dfaba54da38f0421b69930c3c1",
+      "577cc4b4f27941189c62951046db24ec",
+      "a16016987b6145b69caaac6712d72835",
+      "c82cf8cf90ed4e93bccffcf75881a56d",
+      "5a4c6dc09a1049c0adfca9834b045a25",
+      "c4d83c2b37504473afe63209a178b4cd",
+      "fae9d16daace412492b048b012b8d6dc",
+      "421b59f4021d4c4d930c51b6b4c7071f",
+      "60cc7415644d4e16b88f8fc5896b4b3b",
+      "fd13a58d6b444a0f955832647f64df12",
+      "8d492d53eb7f4225b516a65ef80f24e5",
+      "70849993c0c94ecf87c56e430f06181d",
+      "e820c557697648378966ed0a073826c8",
+      "a9ac3b2188594c19885bcdb9a659ecde",
+      "a708db5805424449afa269b714ebb3b3",
+      "6d492ddabcbe4d65b5d311834865ab92",
+      "e17e3253c16743a29f09b82d23c3b26d",
+      "e67a69c294334b01974f8bef36f133a0",
+      "24cbd9338ad94801aa11f4dcb2a867cb",
+      "c88fcf0d20154b1fb9b7e8a00116b5e6",
+      "ee8407365f5d42d9b98536152c9efe92",
+      "5ceb5c369f974b84ba850c9e81730a0e",
+      "a7767d5a440f4c819cdb87414f2187ff",
+      "f0bc6b14a299445ca705b888b3047064",
+      "fd0ff16b68b2488d8c31ebe700dee9c9",
+      "0e49d820da754da785bec2e5940eb9f6",
+      "0b53b908088648e3b2beadaeba0f5da1",
+      "804e7ee768794bba88aec3137f418868",
+      "0d786d8386ba49d0b53a5452d52e722d",
+      "33d459c0fbfe45389abe7eb43d2710a1",
+      "dd42a2ff90854b74ba5fde1de26b4e15",
+      "a3ce5829f8a640e79a19d737663b8474",
+      "62afb52a01924566b52f6c2d9ffb76f4",
+      "7a52c380a91c4f49bbfde658550248d3",
+      "3e418e46c47841ac9d717a6981807f68",
+      "8840288388ae4162884feef9c8e776f7",
+      "67b7783351d340d99c44149635b9be84",
+      "0f60c0f123954744ad13b670ca6dce77",
+      "dfabe7aa70024d1aa868ef5e6650dc6d",
+      "7d282fda276343c3aff99b001253ecc1",
+      "4cae160456c74a5fa761f026d64b2e35",
+      "819a26acd18f443882feb129f2c576d6",
+      "d2ed1988cf8c4bcdb1793b3d5068efed",
+      "6f113303101b4f448380a878d8900bf6",
+      "60e8e9f8e6ce40dd910ce1a9410b5e24",
+      "6703a0417c474db5bf261fe8679051e9",
+      "cb89ecd5a8c14051985495da1797a202",
+      "61db57127c5845759360bdf8b29dac2d",
+      "ab9c869439a94bddbbc0c6098f4c5b2a",
+      "587bd0b90afa450ba82e49cf86ee135d",
+      "955ec2551f8b400dbbdba68d7449de76",
+      "f46df85f441e4ada831f0e2b142f296a",
+      "d4f1dbe4ce244abc987b1089876e080f",
+      "13ac509e0d5f42e9bbb6deda62f77923",
+      "4a4a50a17c014f189b52119901104d79",
+      "cf42fc299989442f94f4a9df63005ab4",
+      "90b9300ba00e41e58170ec5634622985",
+      "4fa4f545258b4d6ca014a4c84ec4b24a",
+      "993e5303f107468f83dbf51026e64301",
+      "1e6c1c848e364ce4841ddcaa1383cfba",
+      "d432098a941c463599648b156abea24b",
+      "917139ad07a64e0cae89f2beeffae956",
+      "83afce4becac4f37ba916bf1901346ff",
+      "071e40d45ad14fc19b1480927d15d2ae",
+      "fe19dcea6d9a44d28f077e065f1671c4",
+      "08fddacdff4b4ae09adb5440fd86ae86",
+      "d62465d39d7e4265832901e9b9707993",
+      "4f56214f69034077bafdfdabc1c2aebf",
+      "29b67774c6944bc7ab93e7ba0eaf867f",
+      "0805d34df44f451d9b9910dbe5999245",
+      "2f2c0ea0fc914e7981e34d01751f74d8",
+      "5f52ae61812544f29f774f80fcb7a09c",
+      "ca5dc8342ef946a49d9e67a21f1a67c8",
+      "babce0e85baf4279ae1d22d64006667f",
+      "5cf6cd09cda64d688f4a0f7c511533d0",
+      "f668dd13af6f41d8be358f7db5261c54",
+      "8a8ef60b3b72452fb9ccc31052ab3b4f",
+      "7d29b20296aa4e33837b8ad53fc4adba",
+      "6a94d1d176b844db96de0c0e3cd67701",
+      "c80901426c87439481078b9da2e0c772",
+      "416f31db79fd431fb8dc06e994421b70",
+      "1971fcd35a564c449b4f437dac46058f",
+      "76a474e4aab14a5987cf25d1391d578c",
+      "ff3bf3f1873c4b01b0a547dfe02923ce",
+      "a6295c7e7630444c9b7425b884ad9707",
+      "3ede828a0374453e9aac9a6695befae3",
+      "dc4391fe30694a788134fffdd2a23d1a",
+      "cfc6ec59d45d42d187f42061902abbfb",
+      "68822f8f861a48859df630fad63f51c1",
+      "2671327d35e64f0da670a3a611fd0886",
+      "aae194e7f71f4eba80ffd18f91f083a8",
+      "9ad4192f6f244264aede1b3c8ac3c57a",
+      "90558769855c4bb08ff2fe4af940c45b",
+      "75384779c5d540d28afb53a0e318b674",
+      "a287f197e4fe4f908e3ee0a0e6cb35cf",
+      "fdb799739700447d8a5198f1f4f9b17f",
+      "683db0ff105a47038c350cfc74b88345",
+      "b79d32186443469d94836b663bf156b5",
+      "86cb336c1f684867bd13dae0370b4d36",
+      "7f63b3d80ecb4c3eb837bd0e616e1623",
+      "4f6e7b21ba0747f19b9d63468861c988",
+      "766567be45eb4db6b8d7a3364566c1dc",
+      "3c222a56d4404863a1dac60f1d03835b",
+      "db862ffbb44d450db514173df4c7f301",
+      "ddbeb13bb8174fc0b7d5543108d1c4f5",
+      "5b3bbc663d504fb99318ba186e6b8499",
+      "30bfac68f4224152b048d6ccf6013c5c",
+      "971f59d5f3e04697b3ab3c39ec0fc667",
+      "fe958df746be4dc1871bd58628697c3c",
+      "54417d8b9c5249d0a028d9e831dd8be6",
+      "9a37ffb9810f482b80f245f64947c371",
+      "bdfe4e4109a14a41bcd2e1e4242d82bb",
+      "22e894ba852e4072a1f63a83b3a98b16",
+      "95e24bbc8397455fabb724ed3c330511",
+      "d35b3848508c4b6390c243866649439d",
+      "c7cf10df8d7944aeb93947d5f4156c92",
+      "8e3b0b9f26a34ab8a932756b32834fd0",
+      "b1d427082b9f452eb6546c7d55016b36",
+      "061fcc6e5f3c44c48cde212c1ba515e5",
+      "d70508c304794bc79e80aab136eaf65a",
+      "01b20535e40b47068723073ac6c819ee",
+      "de0b54a59d9f47408d92915ad746cd5e",
+      "eb9a5f255fa0447eba6a33e1c30ba166",
+      "d1e4d2fd70e644f986104c998db7e53b",
+      "f786a0f386f6486083c15e576f6eb3e7",
+      "6715d91c6b62426aa49c344b65bcd8a2",
+      "0b0a85e1133c4ca3ba716e2403511703",
+      "017dc44dbe1c4de491e003a1e279a218",
+      "e3a1a5e9f29d4d28b0b9496493dafa21",
+      "c008577d922e436aabb8680ca0d13117",
+      "bd176c410a4e48a382a1b688e77aafcb",
+      "6b586ad7a3054c83b14243d69484127f",
+      "34fcd527a59748cf832c9efdb954fc0e",
+      "fd672cd5ba0c4695be4240707dcf4bf3"
+     ]
+    },
+    "id": "EMTVH9cLEZYi",
+    "outputId": "7a24b4b0-71f6-4c65-a242-fb3d502da6a8"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading pipeline components...: 100%|██████████| 7/7 [00:00<00:00, 10.25it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Load the pipeline too.\n",
+    "from diffusers import DiffusionPipeline\n",
+    "\n",
+    "pipe = DiffusionPipeline.from_pretrained(\n",
+    "    model_id, variant=\"fp16\", torch_dtype=torch.float16, unet=unet\n",
+    ").to(device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 49,
+     "referenced_widgets": [
+      "5e677518051c43768dbf06243701c817",
+      "d727913663634e368ade4a7dc64fe74b",
+      "eb73095c804a4272856fe348fa3cb1e9",
+      "7e9b46b10fa24dfea489dfbc150d2a2e",
+      "c8156b0cc68e4b3693dcabc530a4ea9a",
+      "d987907f09084d44b452f939aadff65e",
+      "e976b994189343f5ba7d762ef92c79e2",
+      "9810873713024e79ae6d338dfeae5876",
+      "2e18ce21c01a4a3ca992622957e7d297",
+      "2db944a049a04426bba181fddb2801b1",
+      "683863a313034025ab99fab5810f39c7"
+     ]
+    },
+    "id": "D5hL5156zPis",
+    "outputId": "2510b8e7-c030-40f8-dcd2-ef76fc8529c6"
+   },
+   "outputs": [],
+   "source": [
+    "# Only UNet\n",
+    "pipe.load_lora_weights(\"CiroN2022/toy-face\", weight_name=\"toy_face_sdxl.safetensors\", adapter_name=\"toy\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "id": "p-7YWoOs02La"
+   },
+   "outputs": [],
+   "source": [
+    "from peft import get_peft_model, LoraConfig\n",
+    "\n",
+    "toy_peft_model = get_peft_model(\n",
+    "    sdxl_unet,\n",
+    "    pipe.unet.peft_config[\"toy\"],\n",
+    "    adapter_name=\"toy\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 101,
+     "referenced_widgets": [
+      "c6bdeef396174d51af9eee277752bec7",
+      "685797f8907c47ffab4fe7a81ca22e63",
+      "414f8301f76043758f69bbfb6960072d",
+      "23c0492f021a4b60b1d84b0b82d15378",
+      "550b3ad10fcb422eb66f71ad95988616",
+      "222da37b5af14d60814c65cdd1ea20be",
+      "6a2b5bbd4afe4e0cabe39e95ccf528be",
+      "7ba112dcece64386bdbac6837004891b",
+      "2ffbf400ff1f4cc9b358bb10c6b9d99f",
+      "5405d8a1aa1d411b895b0523fb8e4ce7",
+      "04846af1def142ffad328d434ba228fe"
+     ]
+    },
+    "id": "a_2n4Odz2a0c",
+    "outputId": "4b3b801b-649f-4c69-b75c-f800ac75c17f"
+   },
+   "outputs": [],
+   "source": [
+    "original_state_dict = {f\"base_model.model.{k}\": v for k, v in pipe.unet.state_dict().items()}\n",
+    "\n",
+    "toy_peft_model.load_state_dict(original_state_dict, strict=True)\n",
+    "toy_peft_model.push_to_hub(\"toy_peft_model-new\", token=TOKEN)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "id": "z1DWL0X12rxD"
+   },
+   "outputs": [],
+   "source": [
+    "pipe.delete_adapters(\"toy\")\n",
+    "sdxl_unet.delete_adapters(\"toy\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 49,
+     "referenced_widgets": [
+      "d18c97fe685e4be080125ae770526255",
+      "e44c018bc76c48cd8738fee5966767ce",
+      "57b491647f1e49cea7ce34774a963936",
+      "484f694f734b4a92a14ecc4d048db0af",
+      "bcb3ec98d25b4c138c5e8f84c1e937c6",
+      "b0abce2d8a2046dba320e788e33e9d66",
+      "aef81ec1a7e844f883beba8c5754a8af",
+      "c040aa1f65514be28f0ca8ecdd1f69e4",
+      "eec76868d92f45d7a6db2e232a45e0c2",
+      "157c0c1e85ef40fb99e6cfe0e176be38",
+      "99717def9b6b4afe8a411a3bb83320c9"
+     ]
+    },
+    "id": "9PW-SfwH5L7e",
+    "outputId": "90721ffa-faa5-4628-994a-7b719a4ef02c"
+   },
+   "outputs": [],
+   "source": [
+    "pipe.load_lora_weights(\"nerijs/pixel-art-xl\", weight_name=\"pixel-art-xl.safetensors\", adapter_name=\"pixel\")\n",
+    "pipe.set_adapters(adapter_names=\"pixel\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 101,
+     "referenced_widgets": [
+      "adb2daf9d62f49f8ab1f0144b717d41e",
+      "bba38c266ceb4f30bb4bc1eaf5e3aa96",
+      "6926c8dd4e4e46d089bb387333691df7",
+      "abf2248c725b4837b5c2babef7f4ff3e",
+      "39e4bdf8d621451f984f6e7302fd6961",
+      "4abac6a83641414499f9b6b1514d1695",
+      "bf6e103b43844f17968eadf223a42acb",
+      "adf53d97af214cceaae895c8abfbd909",
+      "9d74948f7bcb498c9295e41e690a0a8d",
+      "d872c3900b8b4275b2224c9ec5e7d78f",
+      "4fbaa1bd51bf4b1e90337a435604d2bd"
+     ]
+    },
+    "id": "jHSb-iIf7IEb",
+    "outputId": "29124d4c-b58f-4f0e-c59b-d79b44cb162f"
+   },
+   "outputs": [],
+   "source": [
+    "pixel_peft_model = get_peft_model(\n",
+    "    sdxl_unet,\n",
+    "    pipe.unet.peft_config[\"pixel\"],\n",
+    "    adapter_name=\"pixel\"\n",
+    ")\n",
+    "\n",
+    "original_state_dict = {f\"base_model.model.{k}\": v for k, v in pipe.unet.state_dict().items()}\n",
+    "pixel_peft_model.load_state_dict(original_state_dict, strict=True)\n",
+    "pixel_peft_model.push_to_hub(\"pixel_peft_model-new\", token=TOKEN)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "id": "yoPzMtyqG2ZO"
+   },
+   "outputs": [],
+   "source": [
+    "del pipe, sdxl_unet, toy_peft_model, pixel_peft_model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Zis3zKZpGy8w"
+   },
+   "source": [
+    "## Weighted adapter inference"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 145,
+     "referenced_widgets": [
+      "d74b1c667d42472b865ee1cbefc33a60",
+      "1074a274530e46c5b5a3e43653da43d0",
+      "dfde3984062442869bc8091bb94f2c36",
+      "a6f2ce8830734be4b8efe5ca0e14e990",
+      "07da49088e8d480fad03a2e828357872",
+      "5dd09616ba6544c499271054e8d8d2c5",
+      "fdb1fd279a0241429e5721ae2e92d217",
+      "7c6c4dff0a814bc6a7ac677980b45add",
+      "9a9da0d0e3d84a19b5d188c9bd6a83bb",
+      "de31002ed7fc475c915b4a29253108af",
+      "fbf3d268f30344b7864ce691d5bcb1f3",
+      "153a93d930df4ee396e03f1aaa6f04f1",
+      "c8e40d44aeac47a78f6502771f1471b7",
+      "270ddad8d7704f929a28c9fbbdabfa26",
+      "e57d317b3dda43bba13ecd4514f776d3",
+      "22b55b5ee1af4ea7b1acfe511b194cd8",
+      "a48d3ad24e9744f7898d1f2c5a696ea2",
+      "f29673e57d174839a0bde70bfa165715",
+      "13f5160dd981465890ada8a2cef22d5e",
+      "cc06ed7338b74ae6a1c563212aeb9f94",
+      "3a017f1d0ebf4a4aab57ac3eb0788774",
+      "48643ea67f2f4762bcd27de1d4cf0fd2",
+      "5c3d142907404cef8fd624839a166530",
+      "abaecfe7f39a43bb8fbd655d1a3009f4",
+      "d488374da5e74ec3a5973003590a7d69",
+      "5d8ae9661dce4a1aac8d418d84f3a209",
+      "32132ecbe71a4c2c903932513c2a1aa0",
+      "05700817adac4fdda6c95dd00eaeae38",
+      "5a7d87338ddc45df84080e0096a31631",
+      "cb9a536bc56f4d0ebf285e7f73d4730e",
+      "49bb475a11104e9496f2623e3d5caebd",
+      "887c5eae5b154eccb4a1caa3deef6e94",
+      "e87dffe17f1948e9ba794eddb605a908",
+      "2c352a90375443da835eef55b3e63303",
+      "db8fd6b2687c449fa0600d3e87c96999",
+      "17691a346ca5407a99a5e385450c97eb",
+      "0bca833a6aa74ebaa8f69feb738806bf",
+      "6bdb9b0b68c24b84a748c18ed927a8d3",
+      "355efc45ddaf42498d72d6134a28c87b",
+      "8b6464ce614c4aa29ac66ecce29b6cbf",
+      "bc07cdaad5b64fb3b0e1f8c214bba813",
+      "9e2e87c131a140a2a37dfdf483d27ced",
+      "47468a75637d436f849283c295a74ab6",
+      "af5003cf40ae4dfaa0660f247598856e"
+     ]
+    },
+    "id": "gEqT1vFtG0_e",
+    "outputId": "282ce865-c653-4912-e497-ff825c896ae7"
+   },
+   "outputs": [],
+   "source": [
+    "from peft import PeftModel\n",
+    "\n",
+    "base_unet = UNet2DConditionModel.from_pretrained(\n",
+    "    model_id, subfolder=\"unet\", torch_dtype=torch.float16, use_safetensors=True, variant=\"fp16\"\n",
+    ").to(device)\n",
+    "\n",
+    "toy_id = \"sayakpaul/toy_peft_model-new\"\n",
+    "model = PeftModel.from_pretrained(base_unet, toy_id, use_safetensors=True, subfolder=\"toy\", adapter_name=\"toy\")\n",
+    "model.load_adapter(\"sayakpaul/pixel_peft_model-new\", use_safetensors=True, subfolder=\"pixel\", adapter_name=\"pixel\")\n",
+    "\n",
+    "# https://huggingface.co/docs/peft/main/en/package_reference/lora#peft.LoraModel.add_weighted_adapter\n",
+    "model.add_weighted_adapter(\n",
+    "    adapters=[\"toy\", \"pixel\"],\n",
+    "    weights=[0.7, 0.3],\n",
+    "    combination_type=\"linear\",\n",
+    "    adapter_name=\"toy-pixel\"\n",
+    ")\n",
+    "model.set_adapters(\"toy-pixel\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 186
+    },
+    "id": "QStyurhKsP_g",
+    "outputId": "5e3a2627-27a2-4771-e62f-1b81ded2b87e"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "diffusers.models.unets.unet_2d_condition.UNet2DConditionModel"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "type(model.base_model.model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 1000,
+     "referenced_widgets": [
+      "28a5059a2cc445d783e94ad5d83a0748",
+      "faddc146c69545cdaeb81edc8a0cda70",
+      "cd08b99de03c483a965248ff4df752ba",
+      "d37c6ac25fd34a65bf307896443a5063",
+      "66da596ae59d474f8a82a600174adff6",
+      "b600178b161d4a87a0b832a169d7caf2",
+      "b3eaa188cc2e48d081488eea4ed2971f",
+      "c05842ed12c848c68c4a69de9aa742a8",
+      "18e3ba4a61784f04b3238cf273c90c3e",
+      "42a623abc5d84c0eb7de4e5323bb6546",
+      "a65484354d254516936fcb425917a4b7",
+      "64029a1e70e040b49e38d38bd36823fd",
+      "3e1ec3a51e9b4fbbab489d34640cda90",
+      "ea0910fc31e44597968b2129272cc94d",
+      "3a0e9adc345f409cbcd79d1bd19219e6",
+      "3fe7e7f00ca746cc8cc762da6f365fde",
+      "6466eff2786241eeb142f17758894bb2",
+      "c181408b9b2b437ca11d584e3d1e94e7",
+      "0371aa5607604c06a868deb2a413cb31",
+      "c212598c5a8747f783a6efc18816e868",
+      "89ed71090d5c4366b21d25ad102e7da7",
+      "4ab21d7b956e46348ad6f6542fd92c2d"
+     ]
+    },
+    "id": "iHwVV8f6s1EC",
+    "outputId": "47cb80da-266e-40c2-cfc1-3f3e5421b50b"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading pipeline components...: 100%|██████████| 7/7 [00:00<00:00, 21.14it/s]\n",
+      "Expected types for unet: (<class 'diffusers.models.unets.unet_2d_condition.UNet2DConditionModel'>,), got <class 'peft.peft_model.PeftModel'>.\n",
+      "100%|██████████| 30/30 [00:09<00:00,  3.19it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/jpeg": "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",
+      "image/png": "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",
+      "text/plain": [
+       "<PIL.Image.Image image mode=RGB size=1024x1024>"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model = model.to(torch_dtype=torch.float16, device=device)\n",
+    "\n",
+    "pipe = DiffusionPipeline.from_pretrained(\n",
+    "    model_id, unet=model, variant=\"fp16\", torch_dtype=torch.float16,\n",
+    ").to(device)\n",
+    "\n",
+    "prompt = \"toy_face of a hacker with a hoodie, pixel art\"\n",
+    "image = pipe(prompt, num_inference_steps=30, generator=torch.manual_seed(0)).images[0]\n",
+    "image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "id": "adLnc7sMRZlq"
+   },
+   "outputs": [],
+   "source": [
+    "del pipe"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "id": "nIwIQK5zRX25"
+   },
+   "outputs": [],
+   "source": [
+    "base_unet = UNet2DConditionModel.from_pretrained(\n",
+    "    model_id, subfolder=\"unet\", torch_dtype=torch.float16, use_safetensors=True, variant=\"fp16\"\n",
+    ").to(device)\n",
+    "\n",
+    "toy_id = \"sayakpaul/toy_peft_model-new\"\n",
+    "model = PeftModel.from_pretrained(base_unet, toy_id, use_safetensors=True, subfolder=\"toy\", adapter_name=\"toy\")\n",
+    "model.load_adapter(\"sayakpaul/pixel_peft_model-new\", use_safetensors=True, subfolder=\"pixel\", adapter_name=\"pixel\")\n",
+    "\n",
+    "# https://huggingface.co/docs/peft/main/en/package_reference/lora#peft.LoraModel.add_weighted_adapter\n",
+    "model.add_weighted_adapter(\n",
+    "    adapters=[\"toy\", \"pixel\"],\n",
+    "    weights=[0.5, 0.5],\n",
+    "    combination_type=\"cat\",\n",
+    "    adapter_name=\"toy-pixel\"\n",
+    ")\n",
+    "model.set_adapters(\"toy-pixel\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 1000,
+     "referenced_widgets": [
+      "65bf3df199b44763aa223fee96889e17",
+      "a32666723b0e4b9883a78f56295c4356",
+      "c08373a044204308ac882dd8cf9cdd3e",
+      "fa7876ade8e240fc89a35a1f8c7c7d3c",
+      "de583920d3b54774a486aef4c052e50d",
+      "979c68bd2e224a40b939c27f32c25dac",
+      "0027f3aa006d4276983691ad985ce91b",
+      "a0f8a1a3512443ac84799b95da70ca26",
+      "e08d739f59874064994212363a307f6e",
+      "52c7e22284b0468c8bc0c3b1cad047fb",
+      "17c29bbcbc0c437c9c8bc83e0b085f1a",
+      "65b15618abfd4e6f9fafd64813e86ace",
+      "1e8747251a1f4cca970857911d1c4a98",
+      "caa46820018f47abab4a962afe51cc34",
+      "22a2ea45880f4b0da47f1b213882dcb0",
+      "0cf822f588244e54b5264176f9611164",
+      "dd9666d76af04b72b08f59023eb04ee3",
+      "2702528a2ca049fc800ad44c492690ae",
+      "aed53b6480de4dd4bc7463af04840952",
+      "447d29db05384c55a57c5fb1bd121af4",
+      "2d7e7e816a63428b8f30471a12b57bc4",
+      "e15aab8dd01f4d5582db80e6ad9931fc"
+     ]
+    },
+    "id": "29iGITdnRhFG",
+    "outputId": "dc6a1e54-3f76-457e-da1b-e8677be5c31f"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading pipeline components...: 100%|██████████| 7/7 [00:00<00:00, 19.85it/s]\n",
+      "Expected types for unet: (<class 'diffusers.models.unets.unet_2d_condition.UNet2DConditionModel'>,), got <class 'peft.peft_model.PeftModel'>.\n",
+      "100%|██████████| 30/30 [00:05<00:00,  5.35it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/jpeg": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABAAAAAQACAIAAADwf7zUAAEAAElEQVR4Aez9zbIkPZIliMWNuF9mVfVU93RlZnFJLjgPQhHy5XJkKntT/Q6TL8B5Aa4oFOGGQs5qNqRQJP+GNd3TXV1fRFwqcAxqCihUoYCZufu94R43zBX6c/SoAmbuZv738rvf/eOnT59fvv7606e3T69/fvmUbm+fPkGA/OntJY/pLpnSLfl/+vT6J9qwZ9Kk29unr79J969/zDgvbykegZ8z9Pdklbe3z2n08j1bRXqRZXPXGokDWftIDWqTmh0h295o+yXpiA/d4P/zr1OdqV6M6y3q/fLHTy8vnyi82lJEQauQCYFudfMSDs1C6mq5pY69vHyHNylLJ2HfrDQAIWjfEtsX6j+Gacsd3lVKgs+n7zlHmZEcnF1l5ixzXZS8kollrgutSNbMm6oj4adcnez/5kZJZBHVGtu4yqhNle8QZ9XIUdvUfPr07dcbEwqkG5HF/H75UzMhom9wzf68+Tmv85/+uBEnl2+5xtz5jVQ7ZRRM64GMai/4lHve0+fd71tKW/YsppCExP83abuvT9gzBdowMvlUtOQs5xDuFQDElkK3m+Qg5WJP91n/JlegtOqZ2vpPexD5FZbbfJUdCnvlp29pdW37o1jhHFWyV+t/zy7WKuEz5u6QJVDQ1ZGGTGlPL51sAmm4Rcm9ODvtveUjpPKRaHuX0vG37EVlv8BaFX2Az+a5748JcSdLmHSI+vSdNHQra6Hc78yLZg8VfdviKN5aP915YYS8kpEh09iOHjSzuDFd8km3bX8RnL4Q1ku1p+RjLCMgrtnus1kS0IyQyHtNWm85hjwpGa/e4r7Vve9rJYHuQ7KUCvd5L3O3H+G3mrZZ+/r3KWq3NvilP1BzO/a6ij/uK33pDwrcEcQD1rYv5OP/5mDNL9YtMaAbdwcxZo31Y0Tmkx5hATLCqWopibYO095k9G3vfG4WjicUhb2DVwtVkOf07csf0wNXZsS0OFk6iiYYddzuc0vHgdTsbRWV/gMOj48bf8oo+pyZiqS5n6Skx83teFgev3idJP55JeO4tAVjZnM54lEpGfn4ufmj5rISNlalS7LevZ8lR66djvOp0nRL7PO+uW/FvMOH6xXrudtDtIK2wP0k9/q6n+RRisg58iBh7s+Ckurtc278NoMFnu/FmtyPnzl9AuUE2j/npI2cx6JL96pv5TFCHidlQJYT//pooDUIknnBV0w+8d64C+GN5ofQ3t5e6UD6Ih5cUBwpthuqpkHSpAfMBJbM8MA2aZtbXgRJR0LeZrsfJK0I2jS4kwhCk9Vlk+luUUW3UdhKSPypjt2HJJ5aDskCyiWRnTcNj4sNijTKUrXNUGzCiJE36NonYeBJD+uLkPzzhFIRJOVsmw0W1lAKlvdoqeKpJbOUReDOk3xkrJClD8sdoQDABADtJrPsPoXeruGSisCMGLNYNsgtNheyyximlmY3UXtSlZvGLJZ0L9GYBuap3m5Bbxku55QwGw7tXpW2EGu1wokJbDwx5gDmRNVlZVIUOYs5B5lK+RtO1tDDxXYPJogtMjw5A5NCiQWvqMkPWFmxZRFGEsEt6TLohl8n4KSVOg8IPlVBB7V0txPfPJN5uzXZi7pYm7EYAkpuhTGJm2lLuRtliOVD3oIjo1VYPNj7kApltcyY+kCWZE8LK/nQfwhZzj0qKQGxIW2DjAYZotRLjXAU7tyObBY+JFZuu700sGjgVvaLxJXml7aFdfJDjUmK3EQJJMp6hWUHkkqWt6jdq+AQLXJicmUfgP8WjrsUmxdqBiHd5pMfkhlfIIlkJaRVjcZ7ZiDkMedKukKYkaQV4VLTzlauPsHITEKWein7OPCs/DM/NLtrhWlnoistFW5F5TkrTLnrcErqYiph2z3vTI2+HtbBeyFCn5SZ9KYDhTIdUKZt0TCh3SRJZq00MaGtXXkMwCTCXwXsVAs4aUp3ykMZogCY5VwHqslaihU+UEkFZKmpfZAwPeHZurJzKPj5fkPId8mZ/qc7bFMoRtkXSNzFgkMe5VZxhl5us1vy2ZC2MAFQaSpH7cRJWcg+7LixZ2sR+J49SVPa09aY1k55JEj+Ly+/+4d/T04kp4d53AC0abMteZbeJdcil4h8j7BK1RnEvDqBj6Uyu6BoSk8pK8euAq22TNA3qDS89tbkuzbZw6NzNzamGNOADby7kGb2JmNJLjdWF8Wl9yJxlUdWSAY5bOQqLDJo4gP1apINxpaWtREacZ8AwyCYLgSBkjiyVYBs7jFhHbw4cAuSsWyTAjnQzWImPRdkzo4UyLXhsK2pAPrJZEP+fraZnImuRFNMHS4yjmWvHwq8o+B8hChviWges4O0zsvAY9QWAPW0Wm8MXtwHpslIbGpQOhzYFTYJTcFk3W/suqtWpZwGuVYhqmPrEASFcI1cSlOvxJE+CCerzdm2ZNCMRusfzykbbPCSyTeZ8/Zt+cLz7uNSKEbk4m0HmKc9s/X3WR0OZK1nDacGcRoOb+xJgsSXsgvSxElfSSfJ6RUAupWLK5srWXCD0B2yMnvSKNOGlgkUdfKBnCcR4LyFOw0zBKs7QsGY2x06QErVUOZE5MimKog86JYbB9ocwv7QpMKzZ7stavjnkbkBBszaX2TYcpInlEwGsRJHJ2NnoDBC6wmDj9XGpDFge5bNBAcAExl9kwhSJk+O5Sq6SunWdeCk5IkbAMuoUiaS8GPvbUzrRhqkTDHd4mSGHW5LsJ+eFzfpUnS4J0vDGUO9Jf8ulRE2xaUkOG4UZwx5m7jAVByShm5MA8P+tkTSvWxkGiJ3Ae+HZy32zoJUAqVWYmnZgSaT9C/tIHXDEF6M1AxZHxG4EDhjuAfmcTMlu7W0q40qWKTfYrOGeW5VlgNdcpOgRWZYDiyW6n5DK7oNDcF5sGs2oHx5db9Kzv11L7sChbcl3fieQujmb4sL1wL3rN4XBXASBdE6Uvr9AYhcoUWD+4ImPWT6zcu90/5Zk6hydwtAhG3x3e+RgfNI2G1f3n03iZ2VpXKQbixD4KFEaJV5vM1IlmmzTxCtqfIsMOkTEO7LSELvMlnVjeOUpVHI4KpR2Y9htr5J7wZIDtkNgtiS2J+CsqKkA+IksC3Dt1SQHq3Sy1joImx6K9FSt+FRMGBNu/5uy05wgzmZyixBxAEjy9jIvEJdicmn+NE9lkTlYQ8QZ9sZ2HGpTAxYGGVrorVBVd55sLVh69XuXyQZkYGARJP+kk8A0rDuu4wIyJkA+JI3BLkFhNQgHelLVUJhJsxpklUimd4zBgkImaNpyHlZSYLUy3D26UaxlYUmHetZYAduEZkgK82WE9wQuKkYzhZkIukFNNKwIK0RmZFZ0PwbHHg25OVQyhQLQBIckjK7TAeoBhAODCv9/SybJydrIvurqTht+TQXE65EVmkb72YIV52jgeoNOQgCDyVko+zBrOq6WW2wPpNdi75YWxs3WWRU8ZQ6KRf7FsTDuwsgKWlQc6SS5L1dtcxRjT/rtQBPxpTIyTk/eLeNTTH5eRnDMQprtBDx0VFhDZi3/Es4kpdRuoeG/LVJuhV5B7b8d48Sc/C+4dYMGdzSs4MWrBKk5wKsDA/KTRYmRnq6pS1UacvGIsApOTY3NtDzKZYJoAQ27mWozdBofYk44V7w29EoI+lh6jrsrqbEcRKGlWYYDJVf24X8BJGfkm8dLk0q9/t0lVSEycai699LN8hS04+5SOsnNqyodO8hudGA68eLGlUsjrPkQ9pX0aYd46L6erCgK2arKJKzpM0V9VDO18nUXfTj3RqmaPJqf6lhmYVheOOAYRPOQwi0PV44JWI05iA1eq6R188eJ4ZcXK8MhIk10pOpksAOUnmC3MnXUVmJfFdtJc1VhVgUsz6eVHpq/m6SOxiJ7eOTjPRFVyEnQiOg8Hj5kwsPdORWU7ibhjsDfhhKmTVQLhC1GkuAMCHFAjKHMDcIcss+JLCbVE7JhNCw1ZopwLhzQ76hARwohSm/476JlCnBfnfYJeklZURIjZRF6rZR0u1EWWaUsKQfFyMDVmWnIZlbfnkigd+GzmoZx+NytWj73nz1mobOk+PEakl9Kk1tepZcN+z86gp9/BwetGVBZzhd09CSqfN0E7mkE/omIspIIERDlB9h4K9mJNntMZyQhd0mJLJi2oQuJPqwDMFuJOCPTQsC0CjQ4cw+5AYZeaX+SOrZWMrLbCWHXS4S3fMfshTLbM6IP7CDGciNixiABxEHKLkVVUqJC3l2W6eUeLXFHFHIQlQDdxyhAWyGp5BsMGeHazXKKCkjOzRyK1lJvY6Vnlomf/xp03vUYK/pNqGrrGqEh9wKM4eznQSWyRFD3opQT5z197BGNmZLXYLMEdBUxxy2XSBwdpRPGVjTy0ZPRLJdekuZopM9+/hIGZ38dAdkXmDL7QS6BOrJYNmzPKxukfJi2EIbZCYpA0prpB5W6VNWU9IVvXxhidTYU2iLP+CJbQkr8fQdRF9/XYIIi+z4SzH0FiAy0RhbCALsDJHRQUJBkp1u2MIoZWjgwFRZ2ehlKg3SWBktrAek3EoiWvY9YdVRm4bMzNB0EgbpL2Xhsk80I8MTPjJKygKB1M5NWjdZ4kjZQeG1QDtD5tlu3VhpTIfuplKpgavUQJYQhkyO3RuywUSycUO0hdEEDdw6ZlJ1q87A6Al3Zj+4iCi2JhzcYCUZ+fxtCapiJX7jcINh4Q/iXJaTWfCtvFhfaa0Be9szsoWyJ8Zdf/YJWjUrIGh9mdiepTPnXbcpJRHhG8uReeGooMA9gz+nsDuRHNnK3ILpEMvbfhRzwjzuTo0B738oZuZUFNb9LOdZfytvpVelwIpcOqPWVGhrA3DoxXI6CDwkX963RFyxl/tk2uVdEiGtyE4sdDya1UmuhU113G4j58YmgTmYrjdjF95dL6WUYcp4ngL9lHhSI2X4QONvpaeUJVqDwG4kkIm3Waw02tqL4FUj1qTE4gSA2xZVinp5fdneXlVMCWLHA0pna30jae0qQVO28n2le4KiKXEckdyLUsp7aLFCo7dkJyWBAIe2uw/eBYXv0yI5G3ar9Nzk7Ztc3e9tLYROupd8DMg0C/xNw9I/y5Lz9r22+OZdeDJm1ZmqdonA7nOCYhVZXUixrY3M2WJSdUAzy9kljnSRa8/Cl/4RGWsNniyjB9zmCM7mo77tWH5vPeO3gH7PlbXqobJW4LAmVUle7rd9Tc4uF+xjVgmODBoqlJUZlFWd4ZtvAdcpGQgCD9lTa9jUCrn2agXKbkjvxFcA77kBQa581Mo2ibPJCWIrFZptWJSEselT4uqYkBT3v6FowXGaEpcKKMRbsoUOEIay3Nb1qDBtM7X04dMi0z3rSYu38GLajvRFcL3RvO81VqtOELlezByq41sgZ56Sbc8JuJsuyEu/EkM36jlxeRHffN8Jk/Mrutc5eqjgeI2oDgB6JWy/cTH3PEdCMjNWQkjVR9ZByCn9xkJKxL/UQXKTj3lUguwwDFIj5Aof+sg2Y1bPJawoplvxmxsIvl5z5e9FUEjq8JadngDjFYC5vOSdQPaWd8L9+tgqS+igJBX7GnZPjdhULhI1WDxkgdLl70nd/D3sB7KhPrkNkcsX2Mta2CY0MCEh7Ad0Qn+ImJjtW9I8vbUEeItSwLvLXqaHnC4nZNeu//ntlgwYHcquiX08AdzX4z1s14YrEZUL9ZP+smprqc2LLMmHvSHY/lWiH2UQWZjwYU8SdBOhZB/tEGgoBxUhwRVZx5OF82nrQ2hA8cZEz0+HyT2loydCOXzusS54rh1e5IMbC0Vh3zPuPYqyaVkW0NVWSw9PWduoN1hCMkJmQx7LKj3hs3nSHUW+vPy7//b3SdrPpXzeEq+Wq3OmzWRVFmFbo/OvqXXPTR3OjqkiuUKppfguxmiInhksiOvb0FsnN2zceD1cSOb07uppPJ09zxcWyAAfhGbqpGtOdMN1sgF4NjOfiLPjM+R4aW/1tTdJNdVIx+Q/SB3LJq/0e6h0VSxFNcVRCDQsMNomnNXVFndpTFzjfFCS2ZQegaY7Zi7x+pvGb0C0Qy9zpStroJwz46l/g9tOZYVw+0HhfPvMKePS9el1qu1UzCMtrIr5JNdGmHtHlZYKpW455c71csrbygrmX/6SiA5ee6lqueug10jZ2anO6EoAL/Sv6dXH/X3AZFnOsBwo6CyK3dRYF11TlWbsUbl/mAHV3SyHH6ETqLEp/FZzenpazOFt6GN/GuT6QEvolr3tdNXsZGPAmuKVJWeJlRzCQifhg6gWKMqaI1VwXyLO8GFWMhfjQJCmOPL2iEsJ0ovPM3E/nu9qhyc6de4MAO0GtCcqvMQVhZ7WPOxQQaaU9X13uGHfDOvqYJxq9I5HUnnjDhDo2kP+JWC+BiFaLt8hLdRT4p5ahA3Im3kHcXuG6szve9a7sftVjRd15YkCc9d29CJZZ8aWfs9SEKx7iRCP2tGYsGw/CoGTkNtuu43iFJIhlBENh99N4IYEyox3XnrqPkgrCq+Si6uMa23hmjhcZ4RJc+MQEnyr9JSylSv5lHUIZETtrzRKlJ7sIff8tW5Y0T4RchaKrBtLKfxrkMOMmuRQM4GZGX/9Ter71ue9wmGe1iHef8lQyi0i0cq9xdU4KUtPn7LExwRFXkGyZs3PBVbIqF+h8vNa1clKN3y8biNf2TZoARNR1hVN2R+dS2s0T63RUVIT8ZespCxxIPtW7R/JrqNkFilLz20SytFAmli2YtmhewxhKwlx/sNcEnYKuQkMDuN8xCuTFbZVO+9ZaQrc/pN92OEqpRhY2YXLQLTqkmGRLm0+f5JxSZbPzbbPFRSf7hGi8ZFwW5foro3ELwG3Whm7LFtTA/18yg77GW5W+PbBu/RCSIariUE3k+dRfB3mcVPdjEcpbZaHrldqbl4jJT8lpyxitiXn+DMDFoCL8mh7VqlrdEfZwZrnQg4h67SWXnveVpN5oeEpcaGJ+1QhV3lbXvPZdsrzsVZEaYdlfzB9eiQqX1AxO3HvrNQH6/wZdH6UGbiszrz6vZlA5kc5ooFutxs+RSfQqz7ZECoFyMmmbokaBwhr/mwsXgHYHzGE/ZCYkgZudodsSwDWcTGIoUFspOxJfv+vyXJdnX5mGz3YJFPH7DTxaTqxA2g9L70G2ZkYK6RB+GGG3lr/QE3Q005rRCv9ip1l5QfezupQnK3WIu2k0CFYXqQ/K3tJAWAfNcKUCRbgO9w/AocLy+ZpkHX6M3chm4eAnqqe+/cQ1B+XBJZXoLWhhtKPfZXbS35HDKIyfH4FoFhvfG+QN9SHyaGpMzBXMZnhcNDXKyHbOl88cjDlM3zcAZ4W3sdZw8HD9YoQRuDApxDsADUQTW62HA4HHj6GoEl9wCWAtW01HNYjZfv4Oi9ycUYrnB00gq0BGEMuYSR0RrBTXW55BA7nFEmV8EzIqkhJQ6mRMqzEgGPPYfO4KFx9pGL4cIhZFXlwJ00nYYjkFu4PLHIlLPTIzvanwQB2/gLI0QmAfB+SRLH0xQdz7BaR95G3z8kT5yVbLAUhumDJ+/l3bu0cvv59kjvfrcEZua9Zs73Hi96dafOR3O4ld95nhop4S8xY7tQC2yH6HQ5hvMicWviWXiaXPpFcMjYiS/yIf8OBus83LEAa8vsg2URCZ+qkucgRPhGfghe9tzCbeqNwl/lJPpA/5e/nRnt5Cii/nBrQkbFHCFq9sjBrf8lxjzjOrc6yI58rHeEpGfa7YHOt8o7eW9zANPujXhiN/+wwPda8vbz+EWtQR6dDtORfv/84WcVq3UBkrzTimuYIZq5RfN/gGgM7apab7KdGlVMsZW60nCpMAECks4Yljcwr5a5zo4z4S59m3TZoB4aokpthIXGT2N/yrPTwHnayinn4gZwXKW/EqVruVlbJ9/SzXLuMaybUr3+X3F7/nJ1zT7ervukDwaMTgHGGvsfhuVPt6OfxtGEOZlOBYJq95Le06V5VlJW5VVTetyT+zEUd4O7TtNCfdWM3ODieFsIPoEdXaNt0q1+69Hs//Xw/TPtdj2rl7OiYD9iFVJJfFqy0tkngt6dC2QvMXrp112gaAr0dsKe7hszJqJI4NxUCDyll04KTSTwKnKxSyg4/NAnOkB3nvgmLvm/7kbTBjlNL0Gi5dFOfyjhZ07u/X373298n+ac/xZEj/Y6jYWYLL6KS3rH0Ir7lYDcFEo/z1tdOBGRqQ2kb1NAkeYqDwLxK1FzrTPljZOX7QPYyklNVCpm6t8qp6zFUds5xhzE/ksOP1p8L6rVWLy+j6WWMgCEuJ7iVcIiRPOIJedCcC+ZrulsOxUMdaY6CAV463RnXVjVqgMqEi9O/CRTX1S+hQ2D2Or2b/UJjZP2jPGoB1+m340K6N4I+qz5uWMVbro1I/xEsoyq4kweonZjLCe/kOMRnpsH9JmZGFUw1SGZ+3/fLp/L5AMJy4DpVeiqVMOSMKB1LGq30ECdswAY8199kS0P4TQAfcwWDhkcXEsQUPa5lb53h2UXdo/rmp/bH6wCvMRLey22aKhd5doWXAa8TnW7OeqrVSFDURLVmNcM4jnJ101n6MWLyOBYdy/EAXt3O3ZIXCFxFg2fxqgS3bNU414lVonMnAo7ZH/AAWwCAs9QcAJah881wSOxPAGUKksnANnoF4OX102v5btF5AhU2v0up0vYG/ucHXr4vEwkFVp8B4F4wT6mBjC1hF5M8w9PnqdLKqCz4143KNXty51pEYkZJAjuwVngmI72jdDeVnudvO02FvLx9yXf53c/sJwSgpe1sjQARr+EI1BnR7+QM0thX59JVj1Fmvk1/rT/++tEMdV3ax9LIDiSclzf1K7NiyVkoRW/VazGU2QuGvE9L3LqJ69yWy0A/yu6F92JpX/MIE5zVh2GgRyXb5BFPyhm5HNQUijVfynFjDr045mjHgQZ9gxNnR9ewzrAlB6ubdg/b1AzVGvKYcZC96+NXyggc21sVbLxI2KscZU+FZp+33PmXr7/JbxDu/xa1yba33+0cEOb3bcTTTN01ZDS8mwAzaa52PV+8Am3k6vdlkaDrfFB5bk80GVm7lLWnr7F49lZFQtJ6uTb8/ksmMgp6vwrJU8qIVRpzYjV/IFR8ONpceqIUdha6ochBeAb+JT+f35RsYxRoQGb7DEA6miZ1ume/FYGiI1V2oZHZyc8mKwU7dPFtJcVJSMB0e5G7lICqX062kactOTdnyZkyhixNctUJ6Bfd6nJaF5lCwhY/Dk8CHKRbyS51JXTmPqHXy60gz6AEfEdEE5G0Hxxc+gEmj++CSQFPyLTNt+2+DPcdppk1RFEIC5W4oR26AzIzGWKxZ0N1GOg7iAJ9x2RlDhAMJhUkh4zRD3tUiQ+jXQWAjpzYl2HZJ+YSTXFRG6OxUhIa2Ev/vjM8ujYZzASBizXLsVAW05aeQ5SAuF1NVxq7BHaPC6SWRE4B5e3JXFDfB4F88BnpriJufSFP97ymrAhLz2CHBaJQJakGAr2iuv0OwBZrhYhoR6RoYB+D0RmYcWXacqkztsppboAKuA4KZk0LlD+DJT1bh9kxYVW39bpapAo2DbifDn+AkCejcZTCy4qBuQQxXFFU90GQKsYd+OlK6OZFc0rS6RxKloe+Rwuo9l7H2q7ATTcKfjXUpuPPLC53oQCJX5OdwdJsZ6KTL+ryo/YGfv37JJfXTCKxPvKl1uPNuZTeVeDdsi+bqhgwvLrMZBsk2NA5BZITxWArgc6WmySc1svjFeBfzbVRZYMsLy+vFWPpZ1+brXHAlmfnTGJ1otnRi3WdexbI9X+ceiXNyBIq/n1fntDi1rk/uXbAJTp9SolBOh8na3KgbwFSJJUixZg3eKct/aebndaEGBkIkrPsvicl6oPnOryC8rV2ogUW8Ny5TUmjQsAwAjlC2jAkZymTGbkYhwWYGg7VpDRAjWs3XvvArcLtOgWUknrPvWPHnN7lelWP4R10naZsLDrTq1VqN2C8ZKGBcojWCCCGi4YJv+PZBVhIZLYshMJu57S3RDJcnqPbET8rkyz7LMweziiPtjcaOSeNifJBQz4kSM+KCpx0cHHqWky0EiXvGYEFskKWGlK2sGxuDRL+wWWqYZI9V91UNgnTRJ82nC9oPTW3Ilj7DbgxJbuqscvYo+whyELlT5QGb+ZX9c7JnP3o2Xr5HQDHlbEdAeEHQRz8xkSJSpe2c1O8010SqDrRxJeh9IdsbUtE776gpHb27GNdQYCnGG2/jSBZkQ9nIT36ME5heIhc26prcpW48vmBMqbM+bPjO0NmtR3vd08pBa4lSAbDaw971pJFllR03fvsKK8tSTm9I27D1p9/4BRN97eACqeb+jxlJFfgdSSuqGUm5yvlesufF0LdpT85poew9xCHuOyzvamsBItr+XYtLfjgvaHkvsG35UwdW+vjsoayNDvb+t32lv/Zeq/8nAsOebvvxVXHuIRK6xCVayytGVon+6ePnLjWJHFa28w4gnPsem2cDTfTDaFOC8fOvsBWZ07YhwTlNuhJDtl88FuhfIRXUP1KOHvfnCl9Sbyq3/xpnYFSpVxaS0M2KfHbl+T28q1K1zIKj2d4WvSgl9bETa4HKVvUIj7VghNA9TpJTK47ju3rbZ8Brp1UJDuPv0SNnfcCymPWjrjbiiRrlHKx4x4Eal09ouNnYlD2F5ZrrwtHbf34Rp/Mx8tKYXj2/534b68AtFBe/F1sIKi3mowz9RdWKaEdBg1dGdWY7CEHsWD7TlhsNG1pNRjH6x7SIkBG42Ss2cJNQx8emBzUd2q0tTcQ2uwyhF5DaFlKc1hmrhE0dpbwCKwYS3OWydq7NWoesrAHdVTJCLVhxJF9x+hIZmTrS45UaOOOYaRzLRyNG6yOh6kCGZgPcSgZJCDDNnXBB+nYpwDs97JLxbncl6Ib5K0VrXbHfM/SXvslVYThw44bzaE/HGgbnDf2VMi7gn2sXu2uxUOuN+iyz+aIuyDDAtm7J6DjKBupM6B6HJOOU1gOXf3x0rqwy3wstKLHbITnxG0KjI6LY9IFTnXSRSYjgWUX6Sfl0o6F+0WYwmgiI14BoHew/O4f/v2eFRLg9utDNaz1bT9Z//L6J4MMnZ0Quv7OGboKSBHirCV2/lpz6o2mcYLnT+WMHDnb836qJd22OwzkVpxx7m3fHIpimrlMYMh6NrXGCB2pP+c9QsxgWz3VpReF2aHR0fJt+/aAL/mX7bbrwaV1Ha6cyPHphGUVxwqHco1B8Oy5ccQ+4+VVt2SCXDqzzYXeO9pWMmq8GCIHZxYIBIxtENuSpzJfQCCfBCNhCz0nHC7Iv9EoUfXDpOhb4UuOW9IiiESDvWbLSBC7xImzILBqwz7jtb4zAr283aKaa+Fl9XauqyGWQHtEBtV1qCiVrLuXggL2LNI5IbXjgg7ScgsLNMVrnzbWDIR99j1Ho4wqxGJeOXUH6AZM7XG+CojQEAHcLaHriOHfKt5nTaJQ3c0kSCvkSeLdVdBf5zpXo8GjRueIt/uV/W44g7rO2cI46TDX5tnvudyDGDIJGx+5qqVc+baDyEQiBlnYP7VF8ZzuTJmFltY2bvA4+XD1lsCKYbT9BpmBOo5eyFmAI3s3rqq061Er0zdx4VV3Wle/Tjb+xs7aMY1QG/FioSw67bv5fPsVmXqfAUj2pQpzKjvS6r8d0eE+q0IthyqaTUn+KMkqWAGSe9hXBYcUl2bwJhA27cEanqBQHaW17Mw4rGmEoUPj7wwJqjtNlr6BwhtgNj74vEFdjqS6JYKq6ZH0q3OQpWXIzixQiJQVQq1oR22oGJPYZm+jtzE8t7cJNdWpENhZzQlZYFNIQBgTnUEhX8RJjAYAw0bJxFjPAkwEizKBD5mjThGajNOYFM8UJRZkuQW09CFNM5TpGVYqHdmBylFkRxtplGSM86tzrHfg50wjMhoN5Wr9uZohr6GD5lMauS8E7RPTbPPAHLx5QVbgIoC9GxM6y1aDigxqXYDP2hEUO1ZCA1LZ5gc+mrZCU7abHZ1RyXU0uXAXyWo1wDIBkLYsWAhdRhasIt5RINZDACeEWrSkTydJPp709GfqRGtGdJpirKpaduWzqzRP+CXg+tyCzPld0G12QaxF3MZthOF2vto8uxpzPp9M2W2s6aAu1bTu1rYLah9BdmZK9kn1ZoTX2jv4rUt4LInJID1flieitL9E68odQFK5QC/iCi5hdhD2TN71JyfJRgFvIdzR9qtEDYfdpZZcbpsraIyKrnFHo5y31J6gizwKhL10pr/GQDWnSO7FuYWGW6t9vDEXkqhxbVTVSgHhPldZZVMEgtVZ6V7J6RuZ6Ddv/miCV94Tg0kmi82bICRdt1VqfZf/JPf+mpf51uThnKBpGXw/zmxHN24oUCZLcggDqeJWDUToeUkFqBApL6fQHNgkIsLi1k/1KmUfgFKBi9z2XWutZk12h3jXv4ZsR+AG2Ilw7Rp7RHDIt8zGY3vP0vT6aPADqU1GQ7LqK13ppzf7l9/7IojNJ7/AgEklTfKVEJ3jPMx9Do+qvSfnqp11g+5Jq2byACNqBpYkuLyX3mw7TSbdlHC8qR1Aty/a2EFQVBElmx9nDnyZBWgRBBml/X2r9o9rKobVYIAR8WUfFgAq18kgzbswN+UVzqRGpWvLaYNh8C4KW0tSukdeKHr2HTh5Sm8BsotwwMsFWd4uhuGklysk09JtNW4p2XsI4oZ0JxwVwKdy4DCukTSYHdZMChbkBqPNk/jaHZBVXZYT9KiRZe18Q028H3HPKfoNbDMcQ3X7HlhC04nGVE7xaOthniyUNPigYn5HQvoMANTCK78CsB/NyYK2DJojEEqmB7+3z73Wiffez81Tw60U+H7b/E8miHfaXVGLYHmxKDt0caoQPC/4rnd3yriEJqTr3PjIoZxxC1P6Q+5miYc7IHuu/BwoJcKTod2wPQnrchBelehwIxyyGminrXMQQK6KmRoYTKTfzspmnvwdq9iXJXJc3jj8JUe4764OYYIqupQDyjV4roGFEF7HKdL8FMZUejPR01V95hK2D+HwuGEENgoO6s13L7l0owHpDHGdFQb3swSd2KMqq1bCVYUezYV4dIj7BALIxUqdCW6sR881w8aN3hu9v7azxYhXCRguIIhc2I+2z5jRZ9tU0hGcU+cotG/vMhCM+1H1ubH0sUJBnLcyhOUSux/x2DQUGLmA9CO65XZdcczEHDGmzGJCWQZG6ebLyoCLHRy0cA0hfxQDXojcwgyqW/HpjUD0bINHOQgnB6Tc1ICg7TZ2CI09nOAPY+r1nHT4oyp7dqd4jnN8PoDp0coczhItdvz5zR/iDMODCF0y3a5KQHZgweMjI8tCZh0LHoJtswhccVBBr0DYwj9YjixUpjgRVqa4QgZV2uJvT8E1sLDb+hIcpTtk6gwJ1h9hbSG42wb9FI1W+pKMP/hI0xbF5o4tucCejIbDhvN4d2B+S+JNh0AAe5zTnghPXi0NTpOxsa4Od9RdCmLFAsgLfx6q0zgyzd/8jCBO2y42rPM59wjG31U9aZhI48gQlrtVbAnZqSHgxTSujzNEMUQd7NOWVFaJZKWn/uRE7/N/oQ8Bb7fNHa+R7q+UArI4pQwK9+tvksq/tjH9nTOT18NWzkdHnLnoRhjkSt+uWrrUdK8BMoYVvn8lT1j9/hupbHVvom1v01LVYnoVg1paxXD5fcvTLx9W9iGhd6veYSmv6/ecd538PiVoqS1GimR3msYMd/QsyXfqWz5NCIZgQm+KkLd6JC2mjHI2tFIdmMDEkQr8hHUuMZkDZZSpJUMmUwtyzXisZLoaoRqJfbnShwcehzDI2BEdG/sJDzRTtxcupJezwHHcN7Y2nhKQo2xBPU4xbhuzXd0XV3/3uS4c0vfZQ6Zol8l+LZk86ThAadfmeu0xEZ8BkAxRd1v0p0+T+BUAxVIKPnZRCnlrhtJkfnNO7UQjgMhC6BH8D9Du2873aykkX8H70c66l9oHMa0ERSXs0GXxkzr3v/6dE5k4Re7rsIIwstFlXIkpkxoRSQ16ss8lUD6icZccpLhJ1JWDZN0ahRvI6405pybV7dXhScMB0lzqlLpGDrg0EcNhWzsH6O9XZFNPqKhRfXTLKnoyn+6hyept7SQtnpeQDWYpcEwFDADeejZ2+nGF99ue98v8lNU2LL/ZX5qkFK4RtKaJcoZHYh1YMs0iz/pTCvQKAmQCkTiQpcbnfJaVMjI3wqQhM2F5NhcQJOwswmP6l6+tSuy4OSi2S1ibtEYGWtauntpLf12TxOzLFIY/Mo8gtB0aue0yIQf+a2jceG2ARsPhiiF6chzZx+FyfLcIDUAx4DBEekp5GNg4UGxz89B4ubCA4GbYIB4YEhnG1lQPAK+Eys5AlhpGBE+5ZVNfgCvZtNAP2B0N+6nqzIqphaExb9vslfByv6Oky//F6Xf/8I9ognAjG43yuUF9Psqe8NgRV6TJ6w3medIwN5PVV2EFh3X8mkAHZ+t17Ucj0XJlm1DIjFLeIKhGIsDnygysu8GmmIBc8D33eoCfv1OjDLDqlT6Qxey3RqyZfeIwbr3SDO4+2QrN2sxqPnqOmnSU08hVdamJMkK4vCqWtVIw+kEubSw8+fvv6RsnZGyR2yjywvFHrVvtKXlNyLq33eDCsGtkZYdVEL9AdBCyydKXuP0enhjH98c4PpA7/k6LyJRv7ZVIvjap5ncLEHd+XR0+IrYvNqtRO412EIpYyasTLePoY0UPnHX73oTJcqbMQrb0nMMXsBLQ2CEHgrIZovPld2BsP58PrL2J3mb2z9lDrc923lHXaq4qrg/V15rHfVpR9Gvc6bWRCjsNdLE0pwSfa+zURf5k1VEZuPVX2VgR9+SQKaGPD+ZW86YSSGfRDZlXytL9mNxnP/xNgD2pYLsreVbT+/zxKEWJkEsKMuIKuV/dBZmMLlyQyYDUBLTGCH2qVzpwvL1AGOJgDTduzXClADdG4/POa8XpEMszqI8DwtPyt/SZhmsMEj3stkyCApdjD7O+KYBfpm+9KdGS7AEpFWqX36P2u3SAksoHfZ+Db93blP2iznvYaRKlxt9xxIuqcGDldDT8EeXENv4POHSqG7KlwuUf+WM4DLyBg81k+EQA7PAKQHqf/wt9CxBeAdjeKJQdCIZs/F1AsqTm7b/CdM05kEiwLKKc5fBwoNeBwmG/EhOG3R0PXoPZgTzJq8KLu4/tKrZlF9APWdW1zG7RtO9cdtvWj3wPMacra2xLTkN9y/s19u59q91czUTPmQPySljQbjhLh8PyBE+Z6yZ7mUx46L3XFdCDDXj2HV68eh2fG5iuXIc3oP/BUph7LqaJt7GycUUcvum6uDwWnbv8amL7lfhgFgr3bo05CCoQEQGSQn1Tka44Ew35+HVF+lzjtoryKyHjR+2GBpFEo/S28QwMzfU8iOXcAz+YO68MWGtkB+ZXAAiDtPiDzEktFHZ4cOER+IMDtfd5excdwHzRNv1hEOM94xtD7HkhC7ZYVLy05JAcGj7SSsCNtZdqXceUCELKEvFSAjLRU759B66bXGs5Ldd4HdVlSs9A3QFM09RkdZ1JiT+d4kE1Z6x4YHQb8qBVr9JqamyGQ1T4y+0w5BEcpsqkxZC+BSj9EnDi/vpH8SGvbKPH7A7g1JOhuzelFJIqgXx3Sk8CqgPb+fFfsuHqawMqe19RVs7bF5I+5U/CdPaGNjbg0oYsjAs3rOrt2oZ6r6r5nJsznrJTWN9UkNo2ut2mXWBx++v6o+rvab+sG51rXY+2Eu7Z9x8ud2c9OD2oj2y95x8leF9UkGYOJTO+JV/snvmze5NruN/tdSWI+ro1oxMoZE4TFg6EhnOc6jjsmJWNO6TbljWd19IlVG7U/q1HFIJbM6FFfeU9555PYrHlnqTPANAgpcjf/L/J0Fx8gXC+nOkI1C+30xDPgB+yA9WawSDtJN4NXp7HSbZhIuzFvptvnWHaR+prZ3Cfvj9IB55L5QeZ6GGZWAlya4Xsa4akfdBxZ7TGkQ/nLHSCJ1WcC3Eurz50Q7JyWoCr4n+sAXXLmVnHxFMg+81KNNEJP7/LnJsJsWAn4yDtAvL0fB+/A/D6p7IHMSx5kNwUmTTsoVE3zdwZPwVFzvCkj5RNFn2D5qY1/cigVnDzkX2rmS2Av4hspvQMZ+WKf2MJ2JyV16sNtvQiWP5lvOHiH+8Z42zWvuDXm76PvHtr9t/GR1grfLHGmoj+cC378XYFeFZ1zb6yFMDvN4S0k7EVTxM0YIjnne2Gm1zy7+zLmGux3naw4DLA+1TzSpO5dpyF79KJ90qmybLFQTk+koLqpSmw9tbLmHbWQzyXmHcZ1Pa/u7Q4gL9vitY8rTdeclooIS1+0c/t14RPxDgLQIL7HaLo0afjD1uDyxRHQk1JV6o1I8SL7Z0OeBkr/twqXgNY/1m/PW6SrNdP6VK7euXv59gsKg62226ZOBbxvLOws0953z6l5/N0g5q99mRpTb7BmrbDzwAQRBdFIj7lZwc+ZAf2lb9Lj1Wo5MWHAihpi79ZxowzG0j+HCuJNbIcLqR4hjw78OzAQgc+3n7HR5tuN1AvV81C1/kK5cGMFH4QQRd1OqBO8YAaXTVWDm3lEmI3FpxaZKDjdprJ4qT0UNBWWZjLZkx3+2cA0mDzoNpI7HwLkPicAIMNhYnzmyFWz+Fq/F7OS3XTZ5CXspkH3/j/JUdOnsHPZzs/ot//slPs3+0gM5ddR+ruKccPT/PMZX+kjHqr77nSNObTndPGc48SYTTdn3PKmUEBB0S017QKTodnuMaC4d7ffiWcy98tTho7nZTmR5Zzx77+XaKo18nxuiLrcLE9enUxUHPAMV5VYPeooFbXRH8Qi0yRx0eqjqpwaoySzjhx5ws8I12K+ESpoXXw5gY2S4Kx4GBZyQ1ocsuxEUGtGT/I6kNPz7XVkEYt2ysAaV94FQtrU+cgBpQQrKyzjEfLgWPop8ezAzfpgNwRmoSOqfG8zRC7G7G6437HHFAyDR+tS7eZiztlue/kd4rG7POquOPK7JD7uKoPvN/J0uRyl3JvYmVcz/54Ouw7Z/F6f/UfqFy2TsrUBH2TDtpKGjgM3bqxlyvzu5Uxuf4Ul2/3yT14+d1/94/50j93hF4HECjpHdB7wbt0eTl3StA7u7oTlevSyjNRKSOj1lzH5PbIy9XxDqI5R3aL5bw6XdFgrWKkr9hNPPuP8C9JJ+6bjhlZ7rbHXTAjE80xXA92g3vc9N7Idr66w/+sa67nk60QqXVN0zq1VBGPMvB4Ukm8Jm7F1+NzNocqF4ptZpEyYmpv3oezasVrqkDbP/HVlMk11vrO69XX9eGKI+oypuwDmsPzgQ5kh/17lliJjM6nZSgQgLxl5LsJstpCAhXR56N+nTTbZwOyEZf6M/3P+fggwyHnbUIoKClQumWg5+bZgR+9A3IHeae9OH2/BiB1Bs1h4Z325z3QbnrcDN9DBXfmePpO8Kzn1h3go41ODJPWN5pzF8FJaAPu2NU5l+/tW5tuvOuhrJSaw0MWutX51hTCjc7xY/9umiuU5f35oOQQy68AkD3/EvBrKmh3hgSV/obv3e9T9U7fK8q5E6a+klpdY7gTq5PTyvcdShlptObk9Aoun3Nb7z1V3h2FNUcd/XJ1aY/Ju0p9BKj3n43bmXk75W4qvValb+fajzRfKosDRTq4VIeYnFhcFTarWL72EyxteSUE8ZfczG4INL26ZL+F4x3EDn/nWhoTFOuBdTcTeIXyOsUu3qnF4KRnpOMYXs8bWvgzVJLnzkRWBTa3WiWST6cPp6raXJhCXSlP7anZB2CaxiDAMH8Xz9DYBeD0/TZ530mvDGDVskMW0i8fyxv7hLntK0ridGVxRJ2I6kKxUmCyrhHaXJjrZsuFsz6jbH2T3XCOV4iV6bVGWm8so0ZsRWp57T+pxbcAvdC3AMna0xpS8QLqKT47cGYHqrV3JvBlWB9177i0rvc3zZetn2uAL529ayiHUak2/IUjlh15nULg4TLgPQOxJnhlUDEs35PWxbmtObP0kg537JRGEQgDyiznyt26oJRbmZT03Sjp867lpnDMglSSRjYh3g3tqTX3aZ3gIcQ+l/IKQDoToG8BSp8BYMcklc8AdNbJ7sgRNxDaM7yZlEdiI3muwK8ww9eNImw7PlfgBzBpJWE3xJaI8bBD8jxV1VsD1vQhis0tvkMEetJgD4eSp5SrQM25MotBvBYRZOYVPh3xrld8577Pe+E75jsFX6typi4+/9dSPIiOo8NBECMca/inP7bmI61b3C9aCgfGkr2zPiIZJo9dV9d+IT43renYZAciTb3Qh6ugY9ffpzzt6wB1dWf18xKc5c5TE6hM3op27+/7J6X0qdsiIgRO0L8KXhxY/TT0YtZRl51WfQaAXQkEODUa25/CswMHO4C9zFpfzj54MO/RcIvxUdyL46mh3Z5CKbcXE3nC374D73TNVo3iGkhgufK4atDdb65Kdi6ubpTWnJvxidbtwF3aTgsXf0ypWcp3YcVkbi+gfNGWpMAQwpASIww97+4Aqi4NlJ4/A+C8AsDvLauwNnjjLKRyvWKg82rNaXnz2ef0e9Pj56xxT6uk4wga+QrMcqZN2WgB0fEHs0ZX3UjGkoKAQ9OROT0Sq5ux/VKe877ATswDqfZ3iIIU+rvtxOIZFWsC3M/t8LloAfrF5aR1fhp/4kOzs7TSMHs/0y9Bfvokr2RjtkvBl93nTk4fJ4d0iD0V1tQws1CHGciB8XT3yNokB+BpM+7zc9fngEPDm4v0M15hdauwEg6qM8IQBWP72QAjhNSdXFh4dshVFqNXHYZDBiihu0XsHZfEkPysg9G3CsaZUzYRDsl0o+ZYnz3g1645qkqTBxE+Ouq45nNmj0cQNb/yu4DoFQDY38zPAKARDqehgxP7NP0YHcAioy398XphgXogZT18uCYR3Ybxw1EcEcJksBeGcnrY9BRu3IELlhZN7Ee7nd0lH+9dNpBKYt4ksPzRlsLF9fgr4+LkR+G7ky4rkvLRZO8hvtsQEGdToCe7C0c9TvWgRNsRN9jxCsA//Hf/yL8AjMj9MwBUWvodgHSXt7XEKggr56kUea+zpUx6kXNT+dKQOrovpiWEewYFZg0F7gtH0eXy4UNDFpRvTBFgFQOKesn1I+VoPPndnDOd86dWL11pnqjruOuBzizOxXHOAsHn4Fl5TxBoUuzG8o7G73Dl/UvGHpIPzMj6OtdlUKmSiZRFed0uCfsucut2VZZ05sZhHxocdocixVmViNi9xdWqLYaqva7irzN9GE14bUQqnuv/wVWRmZ/wyp7sgJQjBS/5zHVpKcVC0PWs8nzTLk/3YseX1/432nCgr5DyXgHIaHSWkO6zvEm7vNCEHz2E5wVd/MDtoAK5WF2mLJ9kDFnQ/g+hYZYPweZJ4sN14MAOgLXJHWmGrH/3gnNMefe1LRXAM607ozVLGX70IO7wWiMo/CDCWl5EddfAfSkdKecZG+lAd9KbQHr2T24vL//w2/8+/YLA/p45/BJw7V0D4jeHy+8O1J6d0U3O+Tp5H1JFncTRgIXraG5nnH/JGaz3tF2XXiA3575O7Y6J8Ro01l8r0LSBHG0vvT3M/hLt86gzUZzVrl6Nr3ldmBHN1CkDmsi+U107z5gX1hLgXLnQysfBkbS3eoXK2ZuZS0Xy+sH0jBhEt2+Akd9uJI8tUr6+KC/DvZhgvfkrjXtrLxTMFwrcn0d5BZ9p81YLk28S2rU0js9h2wFqKY6z5/XQm8E2/XBcptynx1V8es2IJSoNpFzSsa6FBVBxe94PO8CdHHp+DId2weSqnCY4pjs3hCp5XHJ37Q3muDvTd+X1npLT0sICk8tsqaUS4D11AFxvzh6Nbxr1bnb0d0O0afDDDJ1d7AP0lquTtbByYRIIB3voEZCFvI8T8viFBxniFQA6AUi/E1bFYJKdlqe3DqWzFvm6geN+12vPDq9kcq89yDMzKQ8wXbPsNMlyx3TjPKPF7YqrEVYuix8KPJeJhTbLzZ/9rSJ5lUhOnlHwCRwecn+Zrkv0x5ov4XJItPCPcPYJIeOZ+FhacmszkHmljH1tcEhRq8vqnp1/yeIeaXdEYu9fkd1dr5KIAubB6qTsOUhojUku0IeJGSGiXZZZ38GRsy9lk+5NDAEmoQ6L3kb85bvbO/7NIkCfoex15YRjguBfZbD02akzy1VwXiFYJ9g21nrY6UN2qPR2E2qwbVTFurV0w4fKCn/o7TjEubkd0Hy0RrIYz6D0Hsj0lv28UiVDyM2BgpRJ/zkbG5ubA74zES7cD2l8du89TTv2n/fE+Mn1vXVAHhGkPFPHR1inj1EDzcDqJMxM2EFfn+VjdPJgiXcLR2/fwSIIdEiuBCkHQjsuvOq4OSx0vJ+qm3eApljPstZss/byu3/4xxxQzaJ2r8rI5vYzAOZZjnVeZemrVHmQPeX5unZZ06BOKp0LhsyaqitrOeooTgT1GD/epToRjcwZUZ5XK+7A5EDfru5GCP8w/zv03CjscZhsBNFbDAJXH42yPoj6rNk5C+ests7yoSMzH/wPcTi8505k7zJuHmM03C0Z6uzvRLP9gkpzfBj29p1Ut0iT1xvvLYtAz7C9A7NHqj2yL+UnlZGFmhzxuwY5pI/maNeiHMA7mWSvILOGBJZPYfdRenZKM54gzw48O/DswEN0AEfmd3N8JqKa8bmPVQ8xLU8SD9YBXnVYbO9mh3mwNl5HJ/KcNR898rcA4UPAFKMn0rhOYB1kzHcyNefQXLmlZwcWsqeJz25FqM6ojCrI1yqkwGz3ujGNgzOUTNBjP6n032DjXVI8to5ZHbD0AqfDR1jjop67s5BNDkt9u4RVoM+dKpb4Sxzdc2m9payZyD5LuWK11rcKwhgc7q2B21PzL0f2jJsu+3z9VRrpXjlxQZPZ4Rx/PKOPHyTZdZPIUtbO2jpbFx+fjxzwE7EDq0tXUVWKPQL85CclJGPxAGOiSYbX7WUVdW8AnvCYnTUP95gt/VKKbKyNhpVj2i/rsJxfKZtMLEOQIXWDd5IC1fmmqWI65z7IrZfsUE96gBfpIms+UkvlI44Dfdr5uzzpASdbq4U+DO0D3kYryVWsJ9NLHD8UnkdyAb+LQOBdvU/paX124NmBZweeHTixA3Qcjj8onJj3ENTzweNQ+9xgq7f1QsGa+SEex9/f7uHO70c1Bqdp+xagl9/99vepE+ksZFvFA4Bibu9v0M+Sck9l7aS7hyFpKMNxUyMRRWH3p211vuUHZyvHsu+Fv9nJOe4hzHbG5KjO/k9DNlMGDIpVIOYaF8lEyoFsJ3RyMmOA1ITLCfytbAfqGrDCscPKe7X+QF0bteMIV9cYwPfnCEfpd1bv1etKz7vUSNntv995N/TmRn6YbzKL5w36AR2+FPoQN3pdkSjKV3tOpHX2krt8bYRXqW6S5CZl7XmyZnEG8wIUC7XDal+jlIMGGO/aToipWosy4W5kWGO9FoWSZKyUyUqT5c/XjZryTPPswLMDj9OB5jDxOMQ+LpN31vJ3RvfCdXO7B1C3567xwvL70FewAebt2t2v7IfQrjWZooKByVN+CxCN0+x60bWt/SKgq2Yln729GOeyy4u8rmXAXWbZ+jSI2M181uhklPh75DGJ8yaYA2fAFosK33Ky9BfwkanWuK1FHc8rEeLycbZ3ziXWQKgW4R9hbmJO4kRyneVjcj4rwQU4l3CenKNLOBzo1RqfQdRkT0L0r8AMJXadJlnJB9bBI+kk8nZtlMnKTFmZngxkTDw/+Zl+H+maT/IwhbFAfKgL8lMi45hVj9l+ruVZyjLYm9aYPH7US/qdLvdZfLnin2rJnz/bVvlg12lKz7vCXEiDcM5Q7ZJRWOIO+nJrBS9nkYBOtwif/2TIU3524NmBZweeHXh24NmBbgeah+Zm2A2ZUMpH5ZOhJ1j8cK6R52TvoSlYMnJ7C9bBhUpu9SsApKDG02+JZZLirMsAjL0CIHAWijdSV0jdJ9Zr539Ih/P4n+hzEeLGWWaRHUwBv4ucaFc9JdEB9B+KyCfoReglr4RU+P7g2L7gY79rK+0jtOzl9h2UI2dTyqdSnz3a6OSH9hcNd1fNoW5MztGhXHftUpV8suoq1hjIzkjZcL9WTQeN5vF66gF0zB9weBRXpXTVFYEL+q9YdBTjuuqgWf86+uxR1cEM3m30kbTxeYl7Kj7EWpeivM5RbDP4p0DC7JJ/6WJ/BSA/76evBg2EZ76xZ//HSgtOetAtwoWq7zagq4wALvicWM5C9mfIswO374Dev557we1n4Znx2YFnB9oO0JFo5mCkD2Ut4HPsdKDbPu5/1+qg3dVErJkvV3AxI0o4lWr/FiDxhB4gvLUgX6YyqcID51UygXynncJKCu511+oo5bkvZQSOTI3YNXyN4zCBia9npIyqS5LtEGrsoPDHIQseS1lOrnSBdhMiqriE20n4EW6mj+DQVD8cbph/yY7GJ3aGIOSAfZD3xH7IAZ59wEZ7Ab7suZSbzCvDwhZHm6kjVYhJwZ/iViFrBK2ZQj/ofCB7VVemoTUDdgeyS+TpvDL45rJkK+WDRPQjbPdxczpLbI50dko0tQPuxGIZd/+bSyfOGnEHGoqoXsnn9uExgLdGveeyMpJsap1LayQCuG+ayfn1kWWWWs7t665L9uMOp88A8FV/0uKP/OBBWwLysRj0AYTjTFG3bABk1g+rZA7HO8dQw6QP5fBOaT9UD59k3tux5/4zRvtd/DB1f7pPBs8OnNGBZs03wzMyPDFu2wE8c8LTCBzUIN+WxSnZ7rAa0b0I+9RV+hagf696TKxzx+nzxP0bvVHoc44WnzRfPV/pZ4A2s/Ac2MavD1iU2TMucHYPU53VcVQ80dDTIzAMnnVQFcUBsAbosxM3JRzn9yN5XrE/fvD+HVj5j9AZPvI8975HmI4bc7huf78OOd4inwOvfAa85S4gs1+SVx6XpMzVzgh+J2eQ+r5H8amDaCgEHvazTWoPd28yX+VOZfWXh8tqvp85iViUX3+daLz+SZDZedAvAe+D3WN/6m+yJmeKFHn26A8i9RrjlXZdLxzkWZJeAU/bswPPDrzbDjSHAhy5seWamiHrn8KzAx+gA3hG0uwIV9fF6ZyH6as5fEB8dPMD9ZTXyZWTFUjCLqm3dAKgW0werGRvZp1NL9+lU7JV7+Ji5zMEek885QS+dT5k/UrAGflbDMnh698lK9eOprStaQEGY8InBPkdRPz6xiBywazPPg+8e5v7wERkr1gZFKxYSx+BPRIr8c/CkZiVrOelMnuDI9zuFevVczObWPlH+nCI74F5j+TFkWTx90GPcDsSGyls0ueS+Q3UeEXeKzBlO/VRXVonZNkfKQcgHA703EA+4JJMt9mezPp3KSN113REKZ9jSHkN0+lkC0jvD6fmiqNi61CPp3so1kAbK2e0zhIftZgUiVpE3jjacc8OH4C6HZ6YryBF7DC0j/yKAtJnAMofDXkJs0De+AM6ycduawBM51jyk6OtWix9PH0cgTzjznECT89nBx6qA89FPjUd1C59zHz2cKqHT+d30QGsc9rqBf8u+D9JPjtwUgcm94D0eJC+BSg9WLz+aXt0SIP8nDJ/S+in7cr6rt2eb6b3Fb28yLMT8/xGFLflCO+r7C8wBuJkD1o0FNpqe+MFbj2YaV331YCDVU+TcM+h4z2czisDXA7ScVaOrGSNqaPO7YPG1xxMzWW9sjIeYmuBCv0hfNGN+BzFM8Y9RUEniN28/mGKjhvdKI+N6J7jhrzecSmM44E4DO5kmu7nnXj+cGlj6+12bXH5NLvtg+wCE2vbrc5rMpXaFO95P22yA2qZWJ3cHfEKAIFk1ea/m/NkQFthie8MlQTOliWROHbFNBbGJQYzWikQTtsgTozd0+s9dYDWBi8PFt5TAU+u760D1jKz9DhAXXeMoryngIO/VcV7m6Un32cHoh04ZfeJJnsov+fefsp0UButTlZra/sWoC0nQsjBii3cRvbil+7FuSCHVRyks5I5RFkqRfXd+dkSP1utPAXbKkE9sFilugSC5Qaw7rX8Ok90hCnjrlYVRTHO8xMdOA/0TkhX1OJi0prhebywZpeDn/eE1eVmPwHfLyBb0We5lXtuAGDCRVYk5QmI7OrHdldOUuZudz8ldfpKA0N8D1iXT6RkDiSBbtXnFtyVo8H9jmn/967p1DvZsaoDRqzMIuUq9rIBMgJevgfhsoQF2OhGMbf3W2fmfxcFy76B83fVyCzcrW9NJQtD3XmtWYClEMKhzopvs7zuUWCNIKIC89tbIOOVJD8DUBD2rwA6QnkU2+WmgwopbeloppwpXnIgWQ476K6KUuvsXaULs2g8wnwx5TPsvA7I6dOr6Lw8T6S9A+gzban52O629yZh/cRXDnni76JC40w0gQ8wHbqop+bZgXgHuruPfIyIQz09xx34CJ1VS4aKitT1Uv8OAEIIzI11jW6/OTLxDZ/DcZSLvRlBXvWjH9pFXot1orpZ+oTO0LZMwn3eks/6T3IOnMtOItbuDj5NRNucOvZuo9xzvkZLJB+X6o17FF6Nzrx3KaPD2DfRcLix/KBLJbMEbUnYWjPSU/bh0uq4twtZuoQ9nPAKkeX7slxLUvajzrJuGeevHB8lcEEnZyndvtuPxrC7/omktwvM1vD0P6UDdPWcbnj1QMqT4Naat/Q9+Lw6Gg6hlSRfASjAVmCxr99jEc8uZfKfDVmmGE805Rl3FswxD9OzMR0gUn5scWkWrm1JM1nEECQfkOq1jbg5etNhdJ6b31hvzi6UEJzZVXL2jx3Sk8NPFI7gd2OpnGZPOZHtE+rZgQfpgLPIHdODkH/SuFMHeodMa7lIX/J5od8BoJvlfXZByEPbROPAd7LyO/6ZIDR4R6CskR2CwsYt4N30bBgIVk0U57HP9vZqnPfyMg6Eioz7LbNNYBoqf5vbHh3xgffV79rc8A9czapqOYCzd6eRBOY+u9mHJ46FJnRqiMVGKVjohlf1dj1uq6z4qNUILpVPVk2tK25I1X8xL1bFOq/27PgEkDWO1mBVgDysUpb+si59tASO9D9L7tQ+A90th/mTVR7nN2BjhcykbX3lWpJy63fp+IK6Bnxvn1ERmu725J51cH0S32mGqsZlxdHdVvZKysuE7hd4aB6t2oU+hC8+OZC/U39xbVgrytKrrm/rouLAj/rkjaMqHhLEGnp7e3tJvwNANxLIzA8aLGTjiZsjwPFY1LtGO56lwQ8Gum6SOMskyL8mrTdkCM/pB7BxH1h42KJ5ebBgUY3UQiDAYcFC+wH11JNIDx+tM5IzyZhZzHJDVXo2pocdPhfqw07NRcTe4yq9ohXUh2Erurv5LJlhllnAp/8jdiAwzS8v9GWe2+8A5HOX8t2eb2+k/7T9DoA4y8l1BoCbfojzKrIgfnkpD9MTMvkk/DpvQwrDjUz2jP/GHs4O5S/1Etqet5upKF3+G3HhC9Si2O9Tff6NPEJnsYEu+Yke3yrXA73Pfty7G5bUrIfELTYjzVqRlGFqkOHwULVLzh051odO4Cmq+2ZXJcjZ5Cvi0quZWekv3Vgmf6wT1pwubPjznfTJN5WGjnK5trinbMValERYlOf7tpLoeJYDCFgh53b4XLSqpWuVjqL81U4E5Cv/zeJnesOqu1ksNIZ9BAGLZMhk2IEhwr0czmBuzKQ762+f3/Kz/BSb42mT/7pRZ3UHSc5C6+LkYrqWC5XBprncXGPFPZitijllcLfEB9jH23ogyTmhw/aSA/66RXE4CexAAmTWnMP1iXKrDvC06oSY3Mec2cdkpXv41NylA1jVztq+C6sPmfT9Nvlc5uei3Wqp4Diqj6ak0cpCikqNVJu+Begf6co/nQokd7rwTze8AlCQ9H0EWEedo/FzUz/gYDemotFFW4jla3KR2G7SitY2IEcUhG3jsqdyziB3Jxk9uiYhfRsZufA9341pOEQs3MLvb+ugynql3HEVKm57vyfCcyAe6F6DzBPMeo9bnRexHAhhU2ZPvKLF38guPb0sws/qbaWn9xBSVvHu4coq0G4jdrLXfSMa3dbdht5aFiJs3aypdEIARYGDPqi+SQ6dPktzRFb4Q87MPAJ/ls+gS34aWaOU/ahZa0aOv4I9C3/cv7ta5HR3lzGikP3I40WEf5fhMHAtqoGVfWhMeigbFc/upBgeB+JZNNtZjczF+50UCFB2YBb/XH/J1keOe1Y4dIWeDtLfm4rRD+4KRUi5AkgWfdvxSNo+A1C8SLObi/Jh7rvlSHZ2J6TXQB5mofiITzfNfODifJw7k6DdkG+G3XpvqXT4OKYIw4PhTooGuRlagUE3CsfqwWLgrQW7oo9TWUE/MwZM5fZM9HeFhVXxaJR5rT4Uscfs1UO1aI2MbOz7OYqs1WpG3aBwP4VvNXlfbGBWEGgrNXJ4MZG7wnPNLQttUBql2DDEXpc/+du8AkBe9O7//BkA++pzwtbnNFrT0g6O3SslVl3ARnXkI8r0slpofng3ikKQF9tON0pd3fAeS4mng3yO0Q708nZ0Oj2cBiQ6SLaq9Mf26FjQIxikLF0b8gucgWzhI1dnxiWJntwQg0uQXkNJDjUsYcKhx+JGuoX+nMVMNocw0Z9gn8/i4OGMruDqCSU0/1XHbghFyV/VRVsksTvOkaQB2SxBux7TbFUf/t79h+pevyVLx9jOp5LWcPqcTjg0YSXr9WwkvES9MPvNCpfv9bcoLhy1mixx5NmK4A/8zis2sTXDbLvdwAMZUiy0wqr9UfUotyn0pcwLW92Fzw3lIgseve1HvQJATjADnIY6HkAFhWGvFiwiR/KuFUFROrBLr6sME0YSnSoMMOnYZdtVTgJf5Q5utMUf0mjCBzvIWU4vQxPTGispPNmfBItn42kBfjA9LwnZFsjvrlKe5ROZP34rqGr8UdW8hq9oxYldfULNdoDW4fE5JQRezyTgb5bJu/CfLY3b4ld3fAp8/Kf1vA7MzJWefhmdFhN+B0CyI63cn8hUDTfIL7heIgI753zCaor6vFC8n1hGSeZSL2Vdr7Rq2fIv51g6YtN0A+XVtU5krqsb2HGuVFtQ95yYHIdsKzAayJ5LufXbxpIzX3c0fA11IIt8H7mB0lEzn2qRlscDKCMrpwPdU1ErLLTF9d/LQrrgnDIfOUcNJJnQpWmGgVkL8iRK09mbMmaG6AavjZnQO/gO373dndzmW8iCvPFr01jDelXcco42woE1BrbWfhcs3HF7PXzt3wKP7x0WgqVfRDYeW7cs1lzoKK2xiNp6WtVnzSmg0JO1/WKxn6Jjx/cd/iV4u2ebZWudyD4McRzkcUD2QVYk9RaU9O/4BNYMDnRHjtsRnh1uYdXV+BEir3/k/YYFIw52tBUu29LJg6RPnwGoUTCSOhkPlIffgvJFxH1Y2Tn0yfcP9JIgNWogbtJlLcfh6iZZGu6goclQUY2yGRp4SU2e2llrHATfdAQKsbo6P+PTeqTn76h7a/vyOyrwHVH9QZbc7IxgicqFutwoCcIy0JYxZ8tZ8GeqC7HDuoYOC0n9EJlRyn7UlPUi2CkOD+DMbWDBIEX2xqVdc+kzANkJ3wJEOIPPADR4e+LLz43y+W78LHlnZj99NovJwW2vCqIfRV4USD7NFv1Zuz6RMyMtoxY2xr1F3nAX6vq6gl9sl81gJdT4nHgQxX5ZiLAiR9CTgpQjLeomigRmmoONBneQI/3RgGAgYSM4mvdalMa5WqM70H3dTDbkakpBfKfDTVHbFbt83br7uxbkTwVylIV8bhOsLMHy+27GsaLv/GBazMKDkVqhg5lF5OAqbwD+knVS8vKaL4rt/tyl3oAfGWrC3eOVk2IrTewpWHga2QGBaa5LIiPCkZdkpAYaK4fZOTDiST5zbDWo4q9dbqQxmHz9TSpR7nFq30F37R5jJpoySuPonn8JWLjAnI1J24UQ7u9CXCvCiioNXCz9WDiROgawyPr9hWEJ0xYCCkDvoByW1F0AQBjG3sXhkbndpiFHZvY2DI9n6S7L47BPhHM78NwZz+3nEA0Pjd22k+mj7jXdurrKYQPPdWAOLJyL/2OgdZvXVcb60e4eeAUgxW6g6TeA8S1AAKSAKl01COU0zm9CsXAqCJS7pdNDsc6h5XvdGMoHJKs669pSOo0AZrNFmI4Kv+NNUu6VnXWMRtmP3zTbBpNrbPSXDjEjzmspxErPGtcCzmAY6RIHxkPM8stKhgMjyxUbpAS3HaGkZE1RpPsIpvQ/TZb1Slkl0PNVfVJF+rs4cOw2QWKQjJ6bnzwJZGkAh8NOjTmG2DYTFOEv0+lw0gxBZJTFTWY5JF/QT82nqmIpY4WQE2iNztto5IRKuXHTQzPXkVou+4QD+JucdXkXa7jVzcrf9nRkD7wT3aSpZoET8a401Y09PCOvvbsBbLG/gwZg+ZmAWY4ycBXKElJwOdo7iOwgEKZ8lJTP5XS6kzVq3n18cw1M4pQsunnUJ55qbS1xdJ8b+vXXSfP6p6KvIvA7AMWU7mGmLQR/TmTg9XLFfDVdvCA/nWPVKUiDv1XWFOckbFEnXNvQahzH0SVXQLcaOITJhD9wkfKt2J2WB2VyzzEkdNaclukJdJMO4ODA29mcct5J5vXg48go3/NpneqA7L+Up0CezrMdiLT6ojW/ALsQ4jQEaLQ9F9bJOGV6TFbREiILK4p1rt88syaCfgn4t79PnPI7jfI00Sa/AvCWzw3SWWk1e9Xg3GoiaJldclzjQeUDAWdpdBUZGit10y7pNiTAuYaeEvYs2WEeTzFkzjXGMY97dlmtMBFn5NZZu8wlrxlrf60ZVirB2TkycRSIehHVhPDansJk548hdHsrS2uaJk19WayWjoNv7QRsB6Ihz17oabpoE0R1C+v8NLo10OMwqXm5I9FJ1+9DGRdnKvdq+B1Z3U4Nd6voyu+i955+mID2jA9JGsmvUpslxBJa5fBrEYTvrwQLQedfpGrPhU7xqBoqnfrUaUDq7Zu40k8FdBtahdKzfBoL1Qtk1kgIVt62N0SB/1AUDe/EZaJy2bmJsDNcb9kc5LplsZTxZgXeLBFP+7CTcJBuLJPAMgM+hW4H0Cvedn2uVl43WcF1ex2Bq1v3xH924I4d0PsXjiR3pPQBUuuuWkX9wAcut3TXmJopW5yW7Gt9xkAOpCWnl08v3+vmZyVMG5CdzD/Pq3HHI3BusjVDPsv04TgK1/59Z9+KfkifLgfOKD3lu9mk/rh87nvjdI2aIRVIbpgjbb1Cg9XVfAag6XNoBYr3g8rP2jec0YRhgQ5CAzgcohYrI+l1B7h8sjadGaaLOIT6GQF6GB+rvSZBsVo6Pr5VBfB8KUtS+McHeZyRsoTy8aUn5MH8orp8/WxxnYtrb8Rtuvmacf39GD170g3qyifM5x4zNZOKw+Q6MT8JU9I4zazyFv9T7jWy1shEa2tGXvv38WWuoIwdhNah00AHCuGNA6F1eM7OeAM6P7SOCRKpw1OaT5W339nIrWa5m6HbVfaUR0X5ajw7NEKnxrW5oGMXTW3zfLhJJofiWCfVltzhmV0tvYUT2st43RNKOgrrHwJL2nKElhNCMptIlqYcccXmoiRnwVI/zoK6onunYGLOCcqqlB1OSRcHQV5mdelcXFTjGmcuWfdqDVDjfADNsBXUxoumNdK9IT0HRC4AKXMIwFFd14E9rxO4vSBwx1b7NT4sMZ82W987fy7k7kJ8oZ6yT2EHaaD0bDYO13VJp57NRQg3YzvL7cP5o9P2pDkzwUHJZ/8WoDRIbaJN8xmApN300gee4zmfPB9CNmydKqTbEdlZtdwoH78hKc9T/cArrEHOa6lRqezYpelCJMvqYm6hKOE0e54tQk8QibbsJyHK9cPt1W7D3IzDIMOQWziU+RrninsaWJhZ6/WQu7cFK9bgfiP1ShOMeWn2o2bFUiLUC2El72Ut0RMBeqgIaUNX1y5j6ADLrpLbCY015tfhcBdTs94aDnJO4fml/G6G9KR2+TjSmWUJzkoIof6LDuvp6/JxMjYE1oYh2jX0QZ7djAtldnFqpo8y6nZsgVyNQw2gtqk2QGc1NAd9/RUl378FqPgCigFJjb8FpsdCCqFjKG507oPrETByqwK+17pczYTwkYKFa+sJo9NSubr2MJc5R4c2m7Aj3GB3mKP+Try5jQ3fj91Pqhp/TdXN8KIm6BV7UaKmnLWhtULW0G4ZxV2VgpSvI8NZrktxBFnOaWRHOJLrYCxTZUEDogTHQYfcXjO7JGb9b1/R+86493eXUkVYRrQlNX0GIN1Ioi//T3eQ03b7/h94J4dk/ESfEc6/GZzOQl4+vf4hK/2N/74rcTYsYTIVqfgUeWdbFaAGxBlFkIWvC5aylTcpBLf6rKvnXHRHvs23YIzv+fru2NXyENVVLpa+ckoDbqay9BWyh1Lue8e01O0pGjrvI1zbk4tQrx8uUO8U3SbJ9zRzbNfzLKXsqpQ7+P7RQAYEPP1cPLOyvZzhNp3hdFrostJua5rtgP0l7R16RTHmVBO25ZfnRQei21teThAUrGOOpQestEo5mFS4cTlyF+P1IxwfRUSf9WNimm6Ho98l3+rABk3Ah3Ng7/ZR47PDj/UakHoFKy8A7aM1gybrgEZT146pZAJ+XTK1nn2Zxz82Sk9TzvMlP4khPX2e0tOXD/LEaufu+bnkM7pKHoQZ5sn95ayOmTi4ms+fVZBrJVWAhbbfZxycAKT+oZPqaV1Rbz1Ints5wNwzry3+znelBxuNprg7kzuQvp3rA1DvKzStx7xmMZXN/L6jWlCIQ/jDrFWnxktNww5fmv3G4Dgg+CX7Vkk4uFvxPihjn/IVHbDmDjOFreVzkE9wMRzMcjycyseCHEKd1agFnOWQYGnD2uFwfE5n+cz6W4XEZ9lCeOd6u5Gtpay1ck+7B73Z/3e//e/TjvL6R7rmX55J4ZeA0Vp4w7S3qsauR7vXAQmQ/jnuAfgtFCVaONwoy0Hql3vQ1OhQcq76IypKePLMdSvTirL0sjsB+ZQrAZQn2oQApWWXqharP5ZeZaWl5awK5b4pJvqQmVhXeiz8s/RVr84CtXD8nhtWMASkvvoS5y9x6Loj5nRhZq3ipL6Z/bSEcnWzr5j5hzWdRXLoylx113p3Jept6vJYUVfJm6+6ea6tTa4Hva5ab2PcnSDwT5NuRB1U+126Lu8C7W5/ujjjXuU9CMfJ5lWFcaxOaRxttKOliZdmIbB+hT8HF2GKD2XU62QKoaRN91006fADyPUc7q18Eb8EXHzKffkMQBrTdf3cJbklBQHpiWoOLDvcOX3eyefk54D2UGSinn1CRz3A30RMz/VESj34D6vjNfjxGsilRSZvyjkC+PS5ogNXT5PcC6QcrwVRQZ7kvJYlzuc2nlRvsOTb8LGyoNtNzxvyKKTr2YVt0LQPOeAPJsv/oRp4HRnu9nUp9BRIzb3ySg4sW4uBHRoB/hxFAsuN53M414F4H1PT8S1AJNE7+zlSvwLQUmDXbKhHre/82MFrrpdPYfM1sGCU3MGs63xEldwk4WYYzLXshnS8XcZJgYevScSzW/2MIzSeNAVYG3QtDdNBPencrqjRwDy3RrnGOnUplS7/XD4qoamQeaVsBpxkmM4l51HKJ/GRMDybvOeyht2m+XOk2BegI3C9HoS7KWpWjSvDwjN4fOaoBo2Hkdqlj5QZ5NGF42ssI/BnPLCWqGoI3OR29q28ll70Ua4Hxmd7m4gNdxWwNppr9sSoWau6nFuwDvTcpyFnBJ5NXX44rAdr1xwiScmH81pzFMSZq+Jwz5HuXsccK+/X36R2bq8lVlPCg9Lvcq9eASADbOxBsRxuzQY7Ww7n6SN0zsuWkIbVO+lu0Jgj9FDd7VvqdOy4icqhtt+g88epziJMFfXBpnW2V4/vL1fpwb3YKhawF4Ej6Q1SWNX9sHrqOf50B3hRyWOFlGXI7MIgf+BzFonG8iwsB95XeKe0/bm4QUsfoW93b8IN+hxLIa7jpwB3cshIrwD89vfJMZ03vBRv/A4Avw6Q7N1b8SejENl1O1PJ37/7qf7kO/t0hR5Y1/FGSlpe+sbnrGSNE559FULn7Wq6DLueSSnOgLvM59DMNJMGwSoeqflzh+9SBfGR6+FEDrpS3SWunU0ggFiLDFYyQpbfi5zCl2aQqd5CuC9DZEed4njYrJlT+sCLcJ/0cO3yClNk1S0Q3lktBP+oIc5cnNJPrEPdXdaDQGdp5UdA6HkrV5HGlBrpKWXpc1B2WieRu6XtDnkPutdnpXYathQsUwNQ4fom50LKjecwKcUSPn4DmF+tYhBOPcRBSPf1DUwcQzH4nHDS/Dq9muOz6J3bsHWT7tAbYJUO5fu39K1B9J8G0ENgGSGEgL9FNh8hbGumXYruHLpoRzyExarL0j8E6ZpEs1ql8V5VyLwky6GkNysvr6izCMwSfvo7HWgmpRnagVHHqJ+d6Wl5qA44Exo8MhCCA0LFWjik50D40LZxlkMpP1QPh2SoTJTG9Q5DHsoB5G9G6ZQunQJCJb/fVXfyfHkNrW1ptH8GgORinngFgNrevOgwWY6+LpU1+kzRx50969LXSrtnlpw017ktMmoTrzYtlyZy6LTgM9Fw8Me1W78PcW5cIKUDJvIeukKsqQc0fkUMoEuTJbBbRAhm1FCaA3wSE2Od3+CVMcoOYhCW26LrvUiz9X/+lcMIH2oFOsBCJIp9ltcGIyAvZydh9iY5SFninDXXC/Qkja7Mx94bL0WrV5a+S56U8If1wuNhOWJEpqDp5GxFVqWNnhftpi8MG7eHHQ47KR95m5YGizI7P9urWf+a37BS6b5W6VQKmY7lJq8DyEcMjm2EBsqchSbsmiEV0vC5Jo+FmpNv3QQX2dpsTZ/4xbf+4LcDwJe2+KN7aCgFxcrwblIO71o/hFL2gHujK4Ob46BDbql5WGJHmhBZoUfw33usXLrvvZaL+N+yRbQPIt1S0mhQkyIadlF/n7CrHXioifsADx/xEh6q87PLJ1gmuQU9ZwlE/Jtj1B2ZRNjGfe5cSLVwGy5iSCJ5im8BSoOtSNjyuYF1Jb46x0qB+dfBCkC8Wb7n2Xh+trEV/QMrNEnHyKsI2jqrGZ77AhDEIuBTLY3DIrVcFVKOEDvo09SF2Znl3+EwcyWm4dCgRcnYGRv84NpgGugJDaNMcuSN5xFsUSnzpCHI0/YIn6aByMXIGM5uF/hwOZQLNXaJFSZwx0jKxe7eL1Qnc4CYXGl0fCPlKVe+U+32anfLusB4FpPDOFhR+ltrnJqxihyHadNsFbP+YUKD/WsmLxZzOHNyPL+xU+mF86APwlOKsmTsxbDied2R6hZWqSTWTS3ZSmdH7uI4/nc0WTNo6VePjbklWyvp7u3T5zzYfqskW2mTLfJbgNLPgm1/sknkl8OlrpUzZqs8Y3wZ8CI52YxhVxZzXBw221JZ8sXUFuG7EwFl17SY5gHCZueuS/kUkC7yESWWGW+PQFmx1mIg/S17AhqclARoLNo1uzmm5D2TyKYgLCO2wnUkngg1SvVu7As9mVsT76YT5xOlRv1ovXLqdUzD1i+s0gaTEI6DAPMsnIbhxxo2s52f7ac5eM1lkkQO3Ej6DAApvmdFE1i6csoVoALm3Utenp+wyetVQl2J1lnX8ev3/pUbK68kRz5UNXCsV2Ck/3HZ6hivCF4gxnLYKGBVRGo8zjmIAOZBZ7idxb9ZSzsTedVKykgvvh+moc3TAf3s2mjCG3BrGN/T0Tdat/4i4UR7Q1iVBe5bclD9Ab4VWyNFRwM0yUHKGX7rj9L7ublGPr6xYAcSzXST3/ds7bnwRMAWBlXe+vXq6duuF+Ya4+tBJKxE5pxKzqtdZ6wCxCCyb0Z8BGToVYgJTHv/rZLGBtwrx92azQnOGn22CtdfM9GajYLajwbrzc3blKV3hMbh3GFVo6prkEv5D/pgwMmSZx8vDMjtNVj/eY4VK4970kfylPqIHD96RNCu87FmEN+P1Mk7s7Y74ZvqJf9OORrMrcpC2tSfAaAPBtAfbtuU0B3+NrVxV6IM8yH1ldgtsUitbczMOFjL1vwZ5LhvkEMDCEqXEmsyxoc+K98az3J3z7WJuw1t2WTItJVKTYPKgY/vpgNJc7AVFI4/QB1E6zK0lE0u1A5lY1IIbB80jP1QncRBw0kzgMgxER8JPiszPguzCE//ZwfiHaD9Qu4aw8Ap5yHaXRy45EerRe/yawwJB1ASUMp3afudknZbCGXPlHq3fwtQ+jIfNI4+AUzv6s/fErpdoTHroQAgJ6HEm94xgzr3pTAQi8XDi5nNBD2er74CxOfQkmxveqW9lef7WSHMptuCaWYpErkDZ7fVFZQqf2fgVISOWeffHaxVlcOBIRdbx/Glf0IxJx4n0OSbqpqcmUAkkHNh4aTY3vGB3SyhySU5sGzFnq5HEyQl4oDVjutqNJTWWQJOuDSR3L1petKN9iZyOH1vssjI1JfKU0cbYjLrH1y3a/PudW9pf5lt9XQ3wgnORY60lx9hva6G+ZuO9bxgpzOdyVD7e56Gral9oboGwcgTUjfZDyITmmyglENsHCdA9xzOXZk6g8bXmjpKNHVrKDqh+rE71q8ApAfn3ZbBKRZ/daptxM4sdN0OKw/DUw3P22kdWO/meuSA/OEVMsA/kfhBqCOVHom1GhTBlCWTLIcW7Il6SmeRtPQnZp+CIj70d11/IsjoyaN1ZqqNT+e1DkSWxxryg0RNrepbdmOK2FozKYX8WwM5HmVVaukjGTFTtMUfhZw2d6cBReo43Uc1FSsAeVKz9l8Cbl8BaLnUUNWV6dyjr79OCKdfGWIakxNB7jVjBjosyGtgVR8y8ugs7XB6A8Cs1r5yEGwpasQvIMp3/pkZDYZH1JGuOuWcSNVn4nBA+VNMrFychdBYdtoLNyu1lcUBbEwRDk3I2tAqIYImSe449t4RwQz6NB0mJnJGMJRQkqrUB2UCR0b+vEQ3cG9C15yXFnga9tPUOMJsv4lxkxk5jboCauZa2QeK4dR38YdTOciaey4/j9HNMgC5h3mW57C9soi2q1iZ8Ai8gi2hLBn7vmSFPa5NbcWfoY/3UPIMZkY57Mx1oXDWS2Tw+ZJ/BybyuQV+xYbRGoGTbvqpI0xTQAP9QMO6StnQ9Bwhf66X2MJr96VXAGjA2ixXsVxhX5vNjMDOFwjgOA/s8J4HyxHnIy4SORT2MarwW7C6ZnzUo9bjnccOh+qGNQbdjlQ15HAE/HisbPgjUG1mRFPSmuNN0AjUFvxp0y01tyn2lhW901w0ET/yXDS101AeN66b0yYLDRsm16W+GpkLIQF/nJFN0MihlNn/iHDoKNdMzxEejxArpoHes+99BqBl252WbbXStX8yh1t15ExaXKtoGfbHoJi28TPdPtJja+X8BCsNT1i/cpmx73GlVteoywFDrICKy9Q1gCpyMNAcugEHW6drpyycGldEkBfXgLscxsrcJbzyM3xlj7Nr2O36bjZEruhoBNZM9a3TpcvmnRmeImDFOi31s1CXgMBuXSi+ckb+6FWzWrpRjNkIjNbog8OpmQ1itm7vYfanes4FHumezjhE6+xZTOWhBDnjRdb1gjKqZuuwCbpQimUQEnioPaWGM0olyQsENoRcafC43SQdzmyXrX4fBI4Gw0cNzt6FZeusYB2LqpaW9dCCk578tm/NL0ZMZxnpe/AHvtlDK6OGm9CAWcqc8r59ev1TDs6Evv46ya9/ogGoZRNt9tHwMwAlZHt+wRMlK06I+YtF2fmBBNS6V/xA1N4zlQdsKFHCH/VV0pPy3VvODK9goivVmivy3gyTDz8LGTmWhQWQhw3BRFvTTXr+0yU0DaEh/rTnFRoQuwL53WE2ExHnf/vAOLeH8hw2CnsQtrPMEcUpIiDs3OSKxDYhtxkSsYflxh2grlqNJR/HxAitMIq5a09Ecr9yqkrMX3rO7nwLUNsCiuQucEbSJH35WYE25uQx5z+Oa56lHYc+jCC56XNrC57nxHLQ+qafVi6tX8ilsy9osNxmA2U/Z2MtfwuzaSmHcw+jrbvkagHTqQUjl6xRynVwNbLKZyfuA2viAmLxTvEgnzG4UbsMPCvXAs6wn5Inyfvq6tXVoHXnghDIDVsGb4ashyBx+NqbH9JF2D4DAFuPfxN19XBhvpjSWmwzQYwmO8xKKVC3u7dmKnlSWJBRMgscNtgHmAvJc002e1s/r4HbVniTye0DWt1E9IcCp5mgxl/TWFtXDezxod/MavGEkzEmH0OCoXLd+iHo58RM+XB5Huk1bdTLvuBTHc3Ydr6g10jOwd3sZUzf87k9WKRXAMrFe4LCXy9me/bfOCA7tt2oU5W3ynMq6VuBuTPeJ/HsZ78vl2k/fMNvUODCOr9sPi8Hpn7ib5jprM7L9gZTd7lJnK7DU3liB/xuy7UB2fcnYkOHE8nfBko2gTOyshFQ/lQTCIH9WeBEjqCdQYYpObGPZuJaFsgvhMyWz/RmAx1/on0FrJNRmJZ6Vj4PnHjnbwGi+7fXP7bfArT9DkDzXqiSfHt30R8xTrET56Y4A0bo5KfpkUV+F01hdPQ+fh55NNNl8f3lIK43NJkXFm4/RYN72TCt1MvAzwLWXX18zmfVTji6/CE49WctaoicHOz1Hwp/JKdhl/yVNgynWjEXGicSi1YxAoVAHrZQpxuGLDhMPEItoB8OCXa4W0W3gRowOB1cSheWrecK3bq6KeKeOrzbE+nGDrJXkT6sseJ0xAHPQPjb9iJJJfNz5PDRUjJvUqN1s/wbwOuej1VX6MP1NjXKYcOcTLO1S7ShXFaam4Q4YRp6cPQKQLnhW4Aw2rXF2r0nN+2pNd3Yd6ykjuKPatAzPlfYRd1aoHURk7l2hL3fBdt3QTLc8mlHKh9/iNTdaDQ0pHULpTb56eMLnjzjzn7S+1qbFjEZS88OJJDP0M3qUiRW5orLQ0pxqPfrabV9rSJrtc9mmfVfY3uzKF2OXntacym9G6c7sRZirsl3lScmfUwoXbVeaYeZ62aPIC0S8hWAT6+fXv+cgZT3C1/7p9RsLXL6fDcrCWDqFwAmr/rLQmev/ZezJYnRlw9+PwmDRs5cZec48CrB7naZzNXMOHtGtJ2F0eNzwSHvTqCZbfbUZthWNHkFItLDymcSv6U3M5Z5WdZLvdGgY+yPNclNw5BYsNDIY4J5ZTLg2D/sAc5wj3/fRRi+4yjfHStlcm262gkO+KBLgMK8dHFmlTx3kWPjLHjc/8gc8fqMpxt6yvUTf1zrVoEp40UOAfgS+br+d/ozeeTp1tXtofTs5O3F8N7BHeA1qRHY1EMyddRn7r/p5BrwDETOl+tuGlERzLJXZoA0BB7H2Z27Cg0fkagP6PPs++Bl5/n5GJTSROmaIVOCoOdUOgCZENJN1zu5bgHTtIKUpNlSwKN801p8RqwqXv/YAJcE8j67bO/T+bM0JHmLT3evPLIfH2RxUt5gs4qwOqbN48S7W+Vhyk5VZNo6yd53F0D34WjdvS+3IoDOP/vP/aZWYD/hHWnYnMaBhxoKWR5xP+T6rxe4P8NU0pOnQ0bJTkpn6bMgd3Mt4DxDrA6cOFlWinetR394Hfrtghs7U+Ek+yHkM3ToNhDIMlfX7TGVVLLmv9YHNNDqAzAbZGR/nM40fBq2t+aJidFZJa3U7pff/cO/3ycRE1BVUg0KnkThJ/4ILi7L99Z5TyI7AuVz0JFj3N7JmRjS7x7kJsTP52RKvg4hlcsy0L79XWKE6wfV/Li4nfJcfzLGwR0kPctao8NNn8mzdo2jNcffO97B1CX9ABpaY1gzWGzH1w/jAJnxm16+l/5vPPMvX3auSImqULhQJHGtn10oPn4mzN4+1Y3SfDAjzbZx4+EKf8lNygwaEw6tkAN5iV2kk5EiqHvoM5yDPY8gk48/NYe6BwbHetitwmLVNLzpWxdKh7CblYUdgoIzX37zg/gRt9lapD/zp0SypdCb2Y1512iANXGO7UdXdJhKkDc/heykjBJyA+D1tf+p3YYQQW9PXT99/TWB8y8Bk8y5WCBvjoeDNAmaSXRMjed7GlpVUV/SR5/f+80qz6pr1t/Ceep/nA7wmiGB5SPlMw7QTsE8wucGsflw08lDta8dhLiHHdCn6soOWFN5Sk65R/wI+8UpTXscEDl9j8MqzoSXHAvxWPKkKBzNIARBgm6ayUV7IvHhP510RtNURnwbzQwYfFsAegsQ3dB1eDTDNmDj0J67NAgMNS8419SJi59n9v1zKM7HFMtSFEO/uLZ9A5JQ3kmka/90k3yoIj1vXXaj2tugOHIbWb8HTrKFp9ZoBO3TrkMd09NonI6Xfndgx8lTmVnk9Q8pe2CLttn+zPpXtEQtszhX+Jv9r0i7A1GR9pvlrBGgeQ1c+7disf9iG9zld6gv+SjxzTiorq7/2UPKzicuSW5SjiMc9zyc96zXgZ15J5OejrPybusWnXT3FLh09pfDPdSvU/l7PV7jgo/Tt+7qoE6in7T1s3TD48p2ygK9jYNrz9la2B88mS2EQVftWhgHDNFqzfa45qz17zDptkKvf+6kAyVMg9bun9rlmKanpBfM8m8Gp98ByOuawIHPQra4GwE/EeVCjozMceTYt3P4rfj2aTyOFg2J85n1jyM/PZ8deHZAd4AOsuI4q+3psH3waBZB8Dl0aD1VRgcOTpaBerKaSMZvzdrAkJUk4A+APJRCPNeaJ+WSNwwbpXSA3DQBw0apo87SDOmdlWgZ59xWaDTSaGXDdujQ+Osh9Vm2Wsrk3Ax1ODQShOTjrDJsMHlLystOtsr88rvf/j4RNn8HwDtHR6Uby69/n3hEzmlkWRWZtpBqjCjyR1aySZzK1R6kdL1z0BFUx57P56hvdrJ7W4K97dTmMg/CuhjvwdhbJ1O89Rn/VPgHc57uxln9P3B9/b5TcPWOKfH5uAqlPE6yRvoPOwNAuEm5CUyJ3v+tWtvhdRvp5/HWRbLIGcD1Uf+zKORvwYKwQ1vmauQrFoPFE6mZbcOEhxQua2GG1Yxnb61hEEdgejIL/DmXE+6ZwuvQA3FtTL7xWmbeAMZxmkDwWZsRxC5PR8MkXkLTwzT8TGvvrXNdv+OaVPjOny9/SjJobJ8KaEhsnwGANn0GoNjpHn8EUHQJzLs19XquXRvFDyEsB3CMMu2mL0quuygC9xatQOjT5dmBZweeHbhXB3Do4iOnPJCykrnh2HjkaOfH+lam8YEFv/93KdyfFLLqdQKeCPTDrYooCn+Ww6x+jcZsllP83xFVrtdaA+zwfgU9HVoTrG458JL2lk8AF/L0OwB0xlA4vpGAtCRY7w0toc29eS1cnYlShpJww9jSwhO68soDPGnL796TfZEyxfG3WDA3fr/XnrQgsw+EhlJj1cPXP2jdrlk7+1yL2rPWHUBXsZU+jYweOuUTK/LB5yt4FhjkCOcqVq0TTsFC5c/aruCj+VYAGuukk81AM/eIDoRSESY1nX+LQ9lbhcGhdavH8X7GPesM+2i6G/H+70kqaTpjFX3PAXeb9kp9TDvOrNnlm0MErM014CbE4kDMyZOOFc7xRMZWqfMaxi+h3m3ulvajim143eqWyqMrd2abjtI11ieFYssrp7hP39O3pFPGJqlGCc6vDpQaubalLH0gz9YF/9nPBOq8pOFK5XOJasZzmNZ00XalmrvdFJMGPQmvQ6yi+H43yJs7Nlw/TYl6voKvRDU4cjg9IyKY+PO8C3VScmmyD9B3Q2R4V5Y40iF+7R9R+T39Oz1SVggtOVDmzwAAg4tjQTLy5YUQAdjQoyH+hMsmsqfjo6MOa6bKY46H0x4GCPL23Zp6muFhjk+AXgeeXe515ak70gFaU/zHOP6+z24XCe9pmVOn8HdeL9B8PQVSc6RFEifIGisk6HzETSaSNULPVmk6kq4b6/Snm9fx7+J/YGW3P1TvcotuH9idHaJBpTEZEvAnlTqw2w0/RIPUGqZQq+0RB7CQfIlEl1y2/e4f/hHl5i+1rOK2KNKZ4dpiuzLtgAv79gWmGYdCFRzYxSU0/zpEjrJyRjJ003pKvurgOfVsOxvrSkOtt6rqYSed30kr6qlf7gC9ny/NUfw1geVMP1RgvRccLL26lnMScmTH5CvHcOZ9s+JTatOA7F9czHsdS67dLAwxPILtRyqOiQnIC199tc9nFcuQD3NU89un6hNuYByFWPU7af1Q+u6saVpypvwlEQTUKZY13HKfWIM/5AnYBlOunDz5bQMb/yapN6zn1KfX5eaBj/ZEP3bNKkvAUQg4en+M4Es08u/2Wc5Og9mEN9bhEOu/+0oIIXfJMKZMrZ9D+rEMooR+3Pb7vvm9/ipk5ykpJbdcQ4VIP2aVfgeAblALI4KFIrt1NuQS8KoDpwPqcIyIYVthz410wXRBtIzXQNIQmkZvELqJmsqZYsM1xNmFOxaHfHqaHXh222zN05A7gBXi7/UHV9HCUWI4OQcpDfEPOYAcU+T6WTiEfqNgf0l0SXDFXevtlcyHhbM4LDTnlNTDQuAwdDuFzIOAHJyLg+FOEyxkmh38ObG3MYGh5Cnl7blys5gSdf4dgPRR4N1eBQ8q2KMEwCBmaJZXI7SzSKmNrSbojPrn3zVY9W3yWXdLVYyJdZoEekfm8EbnxOQq36NPcgrGzUKw9CWO7+Vc6LNbdlsX6usi6ziRSCOXc13BQV2LcgDZ1EF+mGv/HW7MeygY/TfjZv0FUIenRgvvBQK4iAqtuu51BLlkoPvm+CIsu2gdtSo+xV0Dbsea4nDkXvfcP4LhMBU8RDfEutWxj29lN0fYa+FffVkj6uRwTIH1szMsOFpTLOP7ZqasVXHLHjBp+bgDAljGWD/stgtq39xNI0muHImPx8HmszEjsNqeP1cJ5rVhaaRqlMyXEKeDZC3yKCT7FgHldQtACbuH53pPqbFPL+9xU/iMI3cK2YedvCOpeXR8yYT3+msf+S1AZCVK+2sFTHQPw8eB5SsAu22XOoG7kSTKIlyEWHl9wAGXWnfghErlWpKyCc1U2AOaUDDHZIECNZp0YUwtSLen/OzAswNndWC4V8pEvGNKJWSYtAPha6UOv0JDeTk1C1ckOg0Tx0f/KHlastOAppYQZ+3OyIOUTtxuwISyNE1ohtyriIDYWQTynw2JkDnLB7PAc0ECy0dSrIEgO3NoQDBslEdIIvZxZscrrWWZ3/P/kn4HIFWRz3taF26Nadg8ir3cc2AS6vMbciGWXUd5pblCmBx0cbzWFHxiJa80FLW+l/RRDeBRHPmzkGL57FYDFY0ELLrtXuI3JnNYFVv334ypDQ4h6Vglkobr5UBXrydxPEN4dqx6Lf1xahGETvZwRRH8O/icyl/3R2usGuEJq7wuNdw3nUOGjJXHuqkdWYJY5FnfPRqzlYVEYLLzg04SGoE+zOtmXOlQ2Or6S3YMvA4wAFRdnZo+CY5FMgyX60qGW/JgHq2wrHfWLfGUhLvr0AlH2qbYob9DtoXK89K86uKEw3SEwBBcOnD3pHIgq5U28DfMs6mn1s8suMFxUzdzCq1e/6uzNh1HAU2BDUOBCDH9DkDZUfxaI1YBH3G/mQ94Nb04kJ1bRgJQabsMvxzYr+CUSTgFpM/vqX124NmBKztgHVAsPXFxTJrpiQcHgsLfFAFN6XaaE4u/Hekq0/uvoCrHGqDMI+vKiXVMFp+nPtiBS9fnueARtIhPsDOOG2dhQTr3lFjCL/wtQORvrmrTsCXJrybIhLY8gjIju2fwprcy9FqwOw1ZqbNMK8LPs2ckKWO+yGt76bsmyvtNS70ESLkmYCdcKzrVwCqvcpqi1UQaQ9XnyOsnFZZGqMz3HZx0jSReRKQbm89ZVxzj5JSnw3bfB87t4RloV3FT/WHFcPfEVSh5bKFYJ2r2oOFAMcmIMJtXYzprRjsva45kqWLPWG/LVTSBzSTiEQffgtJ9HzNNFmohK8lNeAN+ZFge+8YYw/Xjk/TDdezuPz+PhDZRV8bXrw/sBJzeGNwwd4hrjgwNGAoP5Woie8Nq/fccurrUrq7BUE5kMfqzvQIJ/PArb9wrCJrdXoWVV8WUWvZQ6bK/s19qs6wDGlbCAWL7GQDhUKObhtptOCKcs6CGuaQDNYL/WM/dmafEdSBUbhl+KPROnJjTMFo5cBUHMDZQhlJJnopnB27dAaxn2vLCZuHWVHr5br+zUMaFpAjpBsre9kpsdV2Q1uk5fnbg4g5g3TpHA2ehOqbTWTsMSy64DBwHZnGEJFhyxl9JMXd/MHwumfBGjbecHZF8WiSe9EecIeh4lKP1j6HBKwAVl0JYnK8UVfJrz2KTLf0vZy3JZ3iTgEPnsxxwVQxoOAMmGlhn83xe3r6keS/n6LwGImSnsoFgBHZfiFyXFybm13LrEmVCVpZtJTzAFWWrrpA+0B8fZ2qP8KFOt2LueH55Tk9PdByQSWqoR6at2Z6uaTrTHplzPtmixl/ygVu1Ykfr30GTyL4s6XU8Rxw6IUPVSZhVr4ZJH9Jhdga7k+WD6PdDn9sJxu9yQy6LYWfNF3J+CHmRQ5PRXw8GIGDYSJAauHAq903eou7cS/R4FAGBEPeWNJD91w06DITK749wDLRAet9Kdvjz/FlcppovQBbjZFjDTZgg4mtARc4fRMS+QT2QwkztaJ/oZ3tAmAEb+ILjwInMzWSPA0YesjyAS42UR0iH7Dr1IbhncH70kquF5ZvN6SmTQLSJMLanAH5sEO4VTzfXqzVsegoftQNYD/HqujsaHzFgfcCFxAxlpT5PhDQ+EkfKEnZebpKMAShAZ7dQpL4bOM6nPM7CUcCbQldneT6IngjLnsiegyE0si7pf1EVoxSwOycAxrugyjXvlvbg7FBcd0E72nha1tnHwtf+axp+dyPTYGEK0Odp1FKlMnw0C7lytLXTt0EAMIz57SQQpxZUAMBZ0P6vk9f+rXNr1ofK0TwiGoKu5iTFcN4IgOM/2CM0uthHtFFrZnkyQlOxXIfOtHL4aYKot1uLw5M5ND6s9wSRd/abZzzY0cqRNUrZx4xbu+/exoTyltCcjuG93UFuvV2nIiuvIMo1VjmpAahuav8YJedR4ZgKH1OEyT5IGS7Te7dAhqgxlcu6ArPsHzmdlWAl9jkDUM47P9pagAf1U/hpaZU1w52Jz2MKL3R1H+I4BUPf84TIVNptoJH9l/IgTJixa2+P41nPfeYOCPeRmHu+9af0fxQzY78Jpj+/kbZgzXAnMdkUqNfSTPG771t+P//L96QBOK+n3amV8BmAVhsfB1IosEizVNAPq6AOrzT53H7RlPEfkG8/iZd04QLQCyDPncz9Yexk3LPhbr/Gzq7gWrymP/7CgxV78Vm0GgKzsAiXtCHTVipnYZ/+1AGeGquTlv6ddi9SDvckWCP5yxApBxFctwjlDoCmEQGK+HSSKRVwzkJT8B9EoefIKow6eddmVt8CBJIdPh1V9v36G/oY69vrH8n+luTt9wSsYne9BUge8fMhOrtlHP/8bE9cpLUz4xK9fM98PYT0XUDUyT/AJ76WNszpgC1u7o4qiSSKz6ZOjxTyvPnqjJrD+9JU3R5dF7HWYqTJTlsqDo5fzKRJEj4x5OsogDnIOcblEb10f7aG5NnXr1KiUVbUWjN9tGHXiJKD8LgzO9q/hoWvOfj7F3VS95MnXTaz6xmhJEGkvzOJcNuuvueBXpkSSspTj9QWNwkYlcv8cl0HwRlHEOjptgn0srGtGy/wW5EDW4MaD5HjUAr7h1AMGyi7YDfTtsj4oUxsCClvBSKJ7bcADZEaB0abqjeROX5DUcdxnggLHThlBv28OsXcIvPRz7MSK/wBUsrnJbkd0kM1Wa8Brbldaz5EJppfp4eOyap+IQRQFEh/Ph/yfKgFaTXhQfTOXGjTuY3V+LfvCVV0blFUAtWFv4PlqP6cw1TBHqQZDUerz6khmrP1u2/2lo0Yn0TsjLnFPAlutei8AlDOgCnArOeFLMTStNfJqtFKTAVwySD+XtWl9LNFT68AGbBdK4q8I1/M9bnvil7qUhXUtEwWWPldNJCd6aVo6MEFJKtrdSOcFnvWv403x0QY9LrMEYarbnhVrapCofpW5b6ocKgC8darYrEON8yY8W6Hhw2xMlGjhrFVMw1WGn8Iq0OGGj4aV5SGYYJzt3tDgOMOa3mrKFHFAh+ajm0vzsd/uuLOPTw4U4yjWR1E1oBBDb9KQNyqHgbjb+CWZ1O97uE0zGyzNjgoTWUcO+ySg4luA5leiWXMJldwOGCytBd0MJdwgiV03ZwGan+7h7ZFo2iNJvEm54vAjVcAOJAEljX+p7d1fuuRHR4fT0XtefQOYW14y+OMaZFdIPnqdLOUJT2ORWd4+FBCl/BDMdRkIpwfbWHoKs7VRHpybkYf7To+08jTAX5lH8FKLTm+gxDII7f2kblhDcUYDrzkPEo5skzj/gMSIhlhxmFF3GnifbNbZcQbSAhGCVMYiogBuvslh5ff/fb3SSPeQ7/H7dIeVEvkQSTT6wArt8WwlVRHY/gaAwORhviLvrHFF4JFv/HVLx9OW4+tGo3X09Tn01TSclLEMgILyErD5tZPVPNpQjDsXBXo+k0qNUMApN3iQFsmWUy7W7QZ6AH5O5yJ7bnzG0GL+HA/TxGwopw+OFnix5P+LsbQ9r62RoyBHYYDSgwREO41awFqJ7tY07Ht2nke1TXpDgeely2w47KrrKS7R0DSj7aBoOSyvE6Or4o4gm7R25eky3PRqYCQSYtPPaEzzbMODei0q5PA8J6FJf84uJFzRb2Y1z6ORUkAAd697xabbWCTt6yo1NQkv316/VPjMhpmBl9/ldxe/7w580X7r7+mlwPoFQDCV/NGgSH2CFThI16FSidzMPQh3IZ1Dx0eooxjJGidHCmTYuVK00NiR0r+O0b2/Ggi1r1xUSx03R5W+U5pP2w/zyL2yPNi7QtW7bP+Fs670N944qx06Pl1nb8O2Zplruj2qS1KM3projwMjoEwVTjHegmy7SLYYd5Zhymes+BH/E8mFp85Ik3OXf+3Wv3SfgagCqoGTidWXwFIkOHrEE7+gya+wqFxaAqjTcjB8MfEU2AvPIgHDM1ooJFh5QxyEHLEzMXIvBIwwkH6AJD7xgIwrSywShzJ4ZA8uk7As9xQpaR8HSvRHuH0Sa5FCaxuT3jWhGNf9Bvej7lSazE/h+fhbi+WHshrFS4z8nqTSpJpDVB/mu9Nanzk0GxmgCdwsOqcjJQiUhGzMimxhyF017/he1Rd5cq9wjvvqdIg/wrhGB1KKtcDP8ah87P9BxeO9alNzawP5ViZTLe9J3bS4QCTzCVlJ1C1qFtEH4ALl2YFKI0dGevhU++6NbwdQLmuGFquKIchme5zCx+7zqXntJET0ZqhtjSv6rA1fPD49PXXKah6laCXnl8BoC/wHH8GQPDwxbvNrE/roLXXwD4k128JzalXH2XTMobrdT8jtQV/oEB0442SrCUIQ6F42rJAJh7K8EeQiRhqpy0IN6y6ysbnxsMHpBTsgMV8bfkFk97d7Xh1xxGuaII1m02uoFsTda+hbvUD8ieSxCpOjD1ZuFd7kZdooAQaPgilYw25TxF6rXIVDiGK0oFdDZTwJ0AHk/N+MOGmVaPRsum6m/JpaPKvPgOA0BJUrmGUsX3vvwIwOveqs9pZHslC89rQhsZa4uRcQvY4virTq8xC6vnWuvXIGscZoRxc7eDrfKXAif0cvUAgaAOZUrPg0Li7CfxBg/nTcKEV41pG+9EYIXs0s+ZE4UoPHOzrEwLgAMPglTMkk20nDXiGGAqy70tsSr6UPFbykRRDtjIFOct9R+bFfiSdpTUqAyXqLfzyesbvKw9XF6pA4UyblamEA3uH4BQVwQTe3IBEg2+Zz+xnADjaF2R233PBqqtwrmQv4N8g5Hh/MKdyO0UbgRRSNVNABBn6x21+rSBlmV3/s/6C/LS4lMuvXXIINrOdC2JFqu/0nwB2Yyivm7K8CECY9mcAZAGXyntll6Y5DN7wbIaT8MeijWQEegmuSkdZrAU2RUA7s4YFlfyBFA1J7km1vz4Q3w9CpWn7B6nKKIPWEq8rw+VM9Sm9JRD8MTMHlk3dELYy1ISA4JvvjTxfyH+ohIlqTVfwIRpMzHR9eMPdm/kgHcJU0nZtWnklkMCyLO3cPndTyHQfW6ZmDvvZd0iN85tHVvyVFvrukkryfK3fM1RAUlr7/WFk3c5CxKeSzfMSFwcJiZVPm3nxOSVrrhOoIiImP31PMlNFvdBEOIgCNwyrw/KXgPWrBE4HkILQj9/M2RTQfO0fOmSn7dQVWbBlzhQO+Wgt+pxea0QtZ4lEHiVwISHkCLfAfuTnAqVm1pwQePLUOJ4w4R3PkCPrRwIOr7BKZ9lhkvU+WGWP9Faia9lAkFmkrAHiGomDMp39PQ4b8cTSjXiSj+TZDQF5ibkvJKOfwNndurhBJSdmuKIZMt8z5D0uvjKpZHlDB0izCWv7r+6V1sisRUbdoCR7UOyf4lfNrcepHUpJlBF9jh9tFMb2OAI943BXN/+lrso1IGXN4SJNWYwbvH6Ul3l9K6ZY+luyg8NdnZ01f+/gWUv1il+isBhW+qWZrRDiA5Ursir82nVy3g31lLGpilKsYC15edJILQCEWKFhgNzweaMBfgeg4yghe+ZTdbKUU4FPBtv6dgjVnx8TOhgWdDPT3NWAxckU3kUtRJJ5skAlSJkrurvQdPhcPjcrGYloe2k55zaH0aY4TzlzigXh9LljQBJYjhM7WjjiaYs/JF7gEWassVnDQhjsdo5xbnFPyZ6i8CeVP6zMq5qFx2nFpTsKga+tn8fpz4lMeKdgIQbOq4bnSmoKBhuLorqXe2P6EDC+BWhzYThjXCFRLPkniEa9PASQc54aRNZnb8cxkZqqlTfUTxpuROPATHo96ul29AYp2ug2bAfMkr56pDVNiDH02SNoQMZATmrBinvouJ9lms4leJ7FYRrH5sDLchpTBMQnEelEaCVO9xbRdnWw8zqM86xo3WaQq2iupA4Jc2mnc9THQ36dgVj583g6mQQoZjm+TuAJPuWqWM2u22KUd01zJSonv0M/RRsi2eEjyQuAJHItm17MV+OZhmW1t1FlaTWJeO11oJRKYyqXWkEBTb7aHhr59QoIdFIoemLpT8820Oleac0A4h7m4azF93pNX8dqjY66QuPn9a0xPs5qrnss1/xLfvYo7OUzAJTTfgXAI5TQkUHm8SIiNmIoSEYi7uwDttQCEoaNOKW0U0Bu1jXqybAtNyPzAyY6ZbUEZxBuQecT54JqxN+JmCdCUUNmezLrfyLbjwbV7T72iuvXzYPMI8qNzGzccxlN9j4C0vicy7ABP2V4NcPuipbMicDVHGS6oDykHcT54d2cg0ox9XpdbPWDZfLcXwHYfbjLHVWyvdAXiL59TsaX7+x7moCk+hoVElj609K7QAd3rV4/O7r8GYC31z+QaUvoVM2Utr65/E80dngXdH1NgkkWl8vvzbPt8LWcCylqDlpjpDfrMvyhxmTpeXGDkpEnzsmLZUpbxk9R4YqGHHwHZPd9bm0VtaPzDgHqFXqLTzLoPgOBe+tAxU2MRtnRQJ03grYWFUE+zYdXcIOIst3pWahO4nHmDo5YIeDV8YFBeTZ1nD6UJTA418KaUwSdy3mkQ8aGidk35kcBOo3b1TEmg68KmpGDNOxJE8stoizd6ht/OeQjg1Qel5nScagbIbgr5DYcrHVo6cXDdbXm9e8DdF8BqOZoaoGe246Kx7nQd0WbbOnAnbsEP/YmAX93rbVNzvRagz1eCLHBfmjLDTrZpGiGl3afd4RLsyyAR5pA5NlNygvplkMetoHLFaVAror6yy2WiHCgLXtK66rMYCR0064C3y4OLWm2F6VHFgInYXhj56Hnj+wgOwlZau7VGewL73SPiDTtgUojKg4buRclt/0VgDTgUkmyzzvpFYC8y+7uKc4+L2HUCaHGngjsup7FrdqXJs8RwYE/F194+oVWCRGCc3R6zysi2aMBIv2g6kn+hfB236RrrHrIPLXJ0gz4W2HvXD9b9dB/dqZk//xZGyJX4cZ6M/kb/pJeSL4HzrAzDXNqFIVU7SoeFpR9fC6RgftuxkBcx8Wcx46vUsk5krJy9BUmh0idRqNNTEVFA0TSKpjTFBvzv2RA/Y0i4T7HOyCpz0bp7gGNr0kvNpPCLGhJ15UJIGWXHZNyjp2qd8joCGvdKJluiqfbld04PBaB0tbGPe6AdKRBVlo1p5Yj62VjSak7z567MJ9ljx1IOT+63DCrA7uvALgRe3zQbQ9YlqiaUEOXE9wjUFWkFDFWPA0QeBiLvoPX4zO8Q1PKYxM157r+LK6wM9pxXVFnsLsQY6Hn3RDZQHLAH/HuOl9Yz3uHln20ajncUw0QSWvR+dH0WNtND3nIwnRb3vkcTBUecSafiNt0n90AmoST5+FkOJe9YdQUtKYTet0EcHoWdHqZPbntvwRcBVWDCiVbbHPle9IA2Yh5MO3wfJR40XkwAarr8SZjvu5uevQM3bNtowqtJoLmDbZhZ1qItbPPHNX8Iqama3ItBszLNtJXpIrb8B5dhVv/2z+GEIcdujNLqJa+m5B6SBMkO4lhO2vd4BmlTKHjiDNlxL7A+86Qg4/JWS6qiPGTsLaqKwh3MI8fbA5ntbrNONxG1nDsULDWpJW0AzjfgQ4Iq85FY9iu8DnvYvisWi6YV3jXvdob+x6etpmdiQ57qA9qw7oCuSuOw9TMlQZes7oWyXSnLjNsvhOscaTCOWOzqNhTPp5KNBlLzlY448wK1vEEOPLRhDRMBjTkhEocKR/nU6Fdsx6IJLI0zyGpwCr7bDGH/HN3sW7cWa9fAaAoMS1uoDCKkEOcY8GUTeSOxbhet6XvUjGNXsVkYzMLJtLTMOrAjXvI09fkpeHpS31UeseOvaPhJv0cE7vdZReLEGOG70hAXbQ9q6tn4byjHqYj5r4+qAHX9uBa9PfU90Wu6w1cj+xT5VXDQt/vJC3ocxEk4I/h2cQaKYCk3Err1XLDjWhA05RwNY174d9mhfSr49wsaL92GvbPAKQgBJKPgVDUdG87tUkjZ2CuD7IxvRb/snFzJkcV48Z8imL6vvRRBvZ0gYeo4TwwbZnsFLnL2EF2mKCl2DoI15mQmmc8Dd01eZAJ4Ts3p1FO1NDkJ5XhIICeSD3LESgCAYLcMsJFAs/gCv5JM66bw+9jtlg5My7RmnmRJgvZ0jsZrZBH06/MdSq7Kd3ooqF2mgA+8oogZSKYJp+DMGta6cBsjrP93yNnrIWT5zEfbeSVe+q0v2B4SYIJDxFIW7nY9Go8eyZDeLJpkl4omJ1OOjIz3nFBNr9BkyWnV6dpfMG3ZTZJafj1N2+U6/XPZRlpD2iSV76lHwKb+x0AUZrTACvxMf366jmW9/Toczvno4kJO6cOSsd/s4igOgyH2yz4cX+Z9/S+zdKTZCKxs/4RzKfPWgdmF8+sP7Gi6aa/hcC1ij5KFDdM7i6srKskNf5q9XP0o3VA7mhy3VzRB5lL4zdLkhcuCZKYlDWI1MgF3oBLt2WZGQKhGS7DPkLgRC3x+TheGHI5GSVvcnt5pZx0L9UOCwd4i+qc3/vv9g6c24EcbcfpHe7zpi/4/oQSiOxEI9SsQF0FGPdcnwk/ePdqDYdRf2pnuDUIzLKXbaBrroNKZNQsK5fWBrezxhqP2JBxKBdu1dU7vW5n+lYgq3unKPLj+WU+VbA9CPpbc8d5KYP+rEuXswUlOfZZHe6hTAGZ55GGNINyFWlnT6NnPHtLfCl7UJfZMB28RZ5mz2qSy/mFab1FDfTaUK+BiEbl6rzvXOOoqPxw1zQAw/6CTQBkt42cQfNBECaL3ViYXkuR6hj9emGaf6aku3Q10zWekpWe/EOYZR41bLMuJYeujIXZLDD/aMA4nIsFmDAEpmZIPodq5/Q9wUQ2jsw9jF1nou0ul0hyOppPTp6Sz6pr27OcmaP0klx6XWJ7BaA70QbbGV8DYlHdrNRFlANhpxCwQchiGw/QPh5Kc85/x9EYobuU0IJbNuKWuah2qjqYsdsf7l4jYIKA35iuGAZLuCL1u8CM92dqlgmW/UnG32xDGGE28Ef0x0Ri69bPXWVfDoVJbl2kjpHBScBfx+mpurIDPAVnJeF1cgRQgpAsSUoTpyAl/ljTFRDbRej6a+WRWI32jjR3K5znngXdtZZc+gxA+V7/snrIp4dQdOVeg/c15Xy3b53UziafhB+7tw0cR3Q8zqpCX9tDsmYGMVxjfhZV7gJfYwayxaqbt3K+ybqqMnINtmCdnVPEXm9m3rz704JkAhZy0yjytzyZg5VL6gmHkKfQunkZR/OU6c6SuxyOgKMJDoKVsanXQqD++DcQYDT0k0IQCD0rfShpTeF5HU5co8IeBxRxTQ4MrT7IpPeV83tkX17/xO+Bbehwjxu9GPou4ojkOxIipgyTKBJ4ooU5ABGsPPRjttDs34TJsTo60d22D3regemrCHxfCUv9AQLQpcwamXiNdrcDElbP/loiidmRl/pz0XfEpVZnPvpxHPpP4gjZqeUK1ef07T7pjf3pLiX4+qu0TZ8K4Js4+H39NQ3wCkA9XcP5ZrQfTUBj32l/iDb+aNYiJbDzFbPMBCDwENxoiGXMqZsh608RZPYGkEyOtXH2h/VO5vsmK5fsECAT3Hg7xg17DAkzQ0A2QyhBvltCVxlmdyPHYRMsHsHAYRM0jtSQjCFvpdXidpZ+SP6sRCfh5Etds1iyyMnmOu4SdciInC1/SmGZhrBPh0gHupPozEgEk30A3k3BPr6gY5v1IB0ak48ct8oU8ah37fl4Jb+tHAhe0u8ApFWR3j+Ew6NZWV48L971xYtmFOeXeHfvkRWsz1PXCOMaNmKX39F4pBCfNk8gUtCwycUOO448ty5yE7U7F8k6Ay720D2TkbOjU7NbCLQ4Scyi69xzOuvdkzp7ELlJxokavTVEXorSBGRI49AMpSfkIY1gXgeN+kMg8jMVmgZpunVtvcUncGauowwL73K4Tjnss9UBSQlFAarbLnbm8od5CYedOXxZOBFqjkM5Uk1EpcrFRbA2UnWOa4Og7C1AGUt366hCvkQHq7376IbpllAFvn8P/74tol3oZwTW8REZ146oDnZrErla03BcYnn+dasv5z8k2XNoVpem3Qvq6Ljwjk2plrMoJFtRZsT2mLdITCn3kJyGxMs/dc2otD2K4hcAqCoKkd8CREMFkmonIP7r9eI2OqLWqyglB3He3obPkSxWIUcwuQ8aBLOKrbZ2NRcx7ObSSqbKwh35EIe17BSFPypwGUE3R2u4SzA1Q+0/1IBtEKfr1lUO8y47cJ+XEa4IHDZh6ECs2IcEfxVJTxmoSyMcdtbWj6zhDrKwV1urMOI2aWEPbCWE1nCtD8bSR8psjUNxCAkaCtbj21k+xzM+LMJ1Tb6i5Jux5R3liioeB5PLlALJPLwtVZXWmG+lps8A/PusJAR+gTTLeHdQeYcT225bl8gmqfM1FWLaPYuSzgIjieRPUXxtMtfauESHFDt9y2eWpaspmmohtsuvJDAB9KSLQ/igirYEaTs95KRdYeqVgQgZ5t9Nd4pyWGyEp2SiAQlBK2VIV055R1cjuoGVUiH4TGaLpVw+YEWmHizkqgHa1GNAdAMoM68wNHkjQ6ctzLNzBBPz1bFGEmcfyk5ZNAdOHUZqHRvk44BtgovGqR30CsDL179PrwOIoyVpUsrXP+R+ia4d7P9FdXRhwZq2RzhXyGIdQo95J5mFyv8mA1SHVGIGT8ttde+K/cgnLZlI2Y/SVt5bvbWh5rrB0eU3DjQk/M7thsfbTvabqM7dHWbmut/yrWg1Z71XAAghg2yfHgAgwxIE/m7Sx24SKz9z1FGOqXFGi+L+3fBGOTtczq4TyV6hNPJhfBZ0YKPh2EZ/xRC5ZEYpU8Y47SvozRIg8g1/sOoqLyI8hKWWntvVNcDjHKira6lTi46nHzbacLhNZs7CgkFnRS3XM8n8t4J1s5hEuhAv97uGacDU7VpXyYFFIIAdviivvkdGzsvCiXm5ehZOBH9wKFmylB+TNs0+/h6T3gdj9fjrAQ1Xx4T0OwDqWEXV0BV//HpZklUUwG6ypdz6ijKu36Pp1jWAXESHYuNvuXUii4rOzyiKOBA357p7ca/v1RVHfi2i9uuMdB/4lRDy1jjoD5lSDwseC0XRvye35VmXr29IdMmW9TKLlNlhURhdz5iCBbEbtK7LivoZTL2F69rVquNERyaaQThvQsu5unPd+ovxzDWPPQzz0iwbGg7aZXdjhz5P6nZYrqjmiJQyC4Yda4Cb7GeXQMIQ60T6d+FTV7O/tXd3o26mHPInJrWPnIFEc+sz1OCd5b3/6CPHSU/4iy1W4OZ7877xYwERABNBbUYU63AiTKwrP6qeEd+3te7z0louHPOuJCf/SBUVV9U3WaOUq6h6QMSq5yQKk9ZGf0mM5hq1cwfqtGlU5ZXmEbL0Dcqn9dzIdwW+han121zT3FG78Ty8z7M/k43vW16s6fp+52iAEwDgYFE3mHKlN8DhIWE0qJHQYeYhLCd1oNjU9ID1XaqNlYacq+vPyiaQ9acIsgQJGOQmQ24sN20hwvGW3oZqvIdNLUzPmh120AJC4qk1gq/R+I/Wdp//41v13GnNDaq4S9Ib1HU0BV3b4taQYO26nAbOQ7cAEkNeLTBZLvTqjD8CfmSx3KUPPMuY92Z4kBKjOTiUN+LmIDxNewd4791VUpputgoQvwOwX+inCaQDY/588Mv3AQWmo89jkIzjp5YFRzG+FMxzTemkZAdTc3OcFXBS5J6Nl76ExRU1fA83X7OR4MCUGkdurrmO+ahrA11wSbjrcIVST8cVWSSmLFN3kjzJIchKQlEgTyLCG6vkoGWsEHk9WPtENHLflHIkdtZnrkAHfbQ+nUSDmfKRfatD+BrTufNFTeN1OOhSLgf+Tqu7RQN5mnnufPx3CabxHa77413XaVqpOxZ//QR14XfoI6+3BJFpUsAqMu9VwdgjoLrgai6Az5nN9nWeqo65gX0c4J3C7+RW0fy3me08BYep/ujlB0ysAZ/2nt2QHPBuxGwfpirtZvyRlIHJxHotTREBJDa/AyCMHf+iuvreWmEH83aKKw+HGrnrrN1mNQQbRIZb3J+ZcEgwEQdeKsTJwPOiNWDVyE2TDlIZ5K9p896nTTKXIy8HOpjXmYKNAoFgaV23qUTX1fvukKmZ9BfsHrl1m+9XvRDiA15oRTsuTPAo0DwpLDwKs/fJI7gHvc/inqzfRQdGa5APbtjnO3u++Bag5hWA0oBOEJkmztLyWaz5PmZxjlsyTjzkcAOCfJpi8PAmr7MCB++Ta5yZXlfYoGobITBDssQBZRRDRsK7NBhhE3o9b33EOJJXuFeiLkSiNdfaKVLyJ08O1/OrNVVif2B0QHJryPh4ZG34AIr54/3W2AuaLA7yHs5OBnO2nyigIgAG34EKZ0xct8zujPucGQdrQztLTJY7rdORpDnQz0F/4sjZM37lu1vHrBJz5ETxJHbbzn3uInSaH+9GF/F+yma/ZiKWnh143bLmZoKcne7rA50JuobcsEvrae+6onj3YUEX4pi087kaf+2l2T/QPa7LynKz1bXYtAO1RzKeu+ZttMU2izAS6RUA2gpdpMLrfGhJWatKJ11gLUOk3IA7psaTh6DdkJc4jYkDtSCjtNXXUJYj4V1wAC7AdkO6Ss7LbZTtkjJ5NkOOPS4QN6YHgYdHwJkwobEcAZxyjgDexide5rC91IGhjy5qIUSDfEhNfEXxJMZDuGMLIRz7MYQH78CD03v8NcBHGBYen/NZDB+/5OfyruYa7eg3RfwS8P4KQCe6Us0OmtRYQKRsVlLjNszShLf+9nkeElE4Z2ygwI2tLbI7xtUXXDEFDrsHARsys+HkbyEwlCNYZ5yaPCoFlP4Mg89Bo2lK/MoMnAmQo3xwDTWloSw7vl5FWiPQq1ihb0QuROr1tbqdhvR7D3K3QE18WCD6GUST+ENk6fwxZGvP1dWhq1oPDVsX2s6YN+4/c2YCUYGIHqnTTnMNqp1v3pLmyD2azUM+ekR8H1mopFmEzXABcDnEX3vDfZO7RDjy+UzDx8oyxG9wosPRWpV8iANX0ccfofWjhHaALzyvEalEqnhv9tdfpzyvfxpk2wPSFwM1vwRMsaTcXQZYs2YJLGWqQ07eLOysP5coOcyC+P4oR+LHC4x7+hzOtXLTIrCycMs/4kOx3A1uKQWSjD/pYCWa1QeJdWGHsUy7G66VqFrr34Vm2I1IFcsdWA6MsHqnPugJ9iC/hCPdO2XefXqNdT3jkTobEu9quN6xd1XmLcm+o5YGV71fEay0ZTcp36zzqKWpqBnejMwjJOLp6JLZO0PSy6s4Y4BltyOc0FpVixs+l+pnaOHasb4y2nrQWHOwv6/AqQdndfp6diejoeJYZOHJgOCkZjwOYY0v6DNRyuKB6F6JBP67vQmWS+BKRXRUlPSs+e1+AwZ3FYKuPcrA9htg2uvKhtzXJwrnHsoQXa+uccBNwp0qr+XVZVpz3SXL4X6UtMrrVXKNdfGT0t0XzKiHNPh7Lijz8iMB7ZUa6aNLlH2G1VoVhNw2/4I+W9k1c09Dvwj8JbdCfd+2xJeyh3a2TfdcZ8Cal0djrZFRjJnmaPJoNtuHWX/JU8o+jm+VOJF9RPqH5LK2m2Uvj0WLx5mCvNPQmt22S7xT76paanfP2kpriRH8jrFbI9R4+yg+U3vMSLJq4SpaANlDKbd+g7HfmS14CT/cpar04bX/tp50xJOfASA0+de6nzkGcZkNmqkc/PxgKoqcdS6Cwh9DLYMzAguAigPGPTlFI+gCG4dLh8Hsx8uUVZyLJpHXZOZDgpQJjYdryB8s6opuXIH5YdqO5nCLSKA/uc+yaa1kgpJoayDPKHWcMKfFNIyauBw4Av4R7dRMLPvH6Sr2xGZ/DO6bVAUKiZTDmCzccgVEGN6Sz61y9euenALxGQDivX0MgDAq8GpglRc6a9HnQ0UTyqFyO9X6fOLp/KspilFfQTzBR16n6btmbVMXsW3nxAkupgakqOv70v9dqzXZpvtp9TCUt1lie/o5idsCIZh6Lsekt5yshh4hsWYSNbk/QnVB2tbaaMLRjW5dQYQGUA67sNLhHNnYX+Lg2LPgH7qqFIc2PI/3VgPzcfJGbdcMZjVMdKkd+njY5F9CBYYVyoybVCvD6nWAFYAtZtiHA9jjUOpUtCmH91PNBvNEBHjCpAz/KD2NfrYmfpxp6oqWcEGHIz3g5lvOUf5W/IPq27LwGYAv4jMAVme2yO0zABKHZAylMryLPWijerSq+noOH0BnTf9ZpfFikYDxxnbDJVRE5kMVOcdTR5CXfUADWz0FWhNMZAEGw9+X23KXZJmngEjADyPznqKFD1PjuBBaH1cuEe7tmEnrcSC0hfrg41t2KrJYuj5d5SNPDHUVjb1ley9qyAco4aLOpKPf9hmAdCpQr1IaQbdt39KrA8pLMotcu+J3ORPSdpt8D2IJ2+5BekcTZp9PXa0IU2Lwmj3F8TUVhZEUeEea28Ju3Lqyeg+iBaP7rzU51u+nhK+uCdlXBbDEZGAjgz8pydPK3p36Bmfjc+QXGRvEMqwqLUq659UVnG5/5QAY7YrUK4iExLP6Y3XDJ9FdpcG+Ocgtgr0OHZDNJGOlDLOxv8S7Ya3tMbGTPNpeLcHGj5MmPHoLs9FVM3bWgJppu3qLzxqt8O4RDHv9t79LDOJoq3zbOH4sbg15/I5Wb5d/RxleUVXten9X0Hy0V5ak8K3dkIuUU2sMtGn/mNhFVIerTrpVxT0tGDyO6KMQFTJRgoXe0x/nvKHmNYb98QhVfAaAEajwwfcCbZ8BoP5wENcJjbVlt0mB8HQqwrjxTnLjdLJJd0wtaZwo84Rak+vk8rtBVt/BQfZNPqxv9ZFhRSu4M5GQH9OHW80C+tAMF5pDCM/+O32TzUG3f6xFi5ppC8Hp1AETN5mFA2DP0Jt2QK8LnsSFVbMQctNqVTIuVlkeTkFUHbaWSc/vIxR2FSvgdtDpl4D/EYVvRrqjlqWtOC/JHiKanU7qmYCeQGwYWjPdRZQZrXPHbuBQ2T0v3FpaHm4wtKC2a6L5ijWdFzaxVlRXP9WTLkJQiRURdw56Dt0iBfJqbdqOWMlcysPUXQeefYKiW5Oxq8mOoQ3QQNsJAAc4+Fd9jtfbodEeNzoujYq7xKWhe43b1JChpqIe1pnXlccwdz74i8LUYRxnAIjXJ7EeDjb/7p3v9Io6Q7TSFa9ykywPFlwgu/dL2FaQJN3Ntqi8CjdGp5qvvIZnv5uok+cwDs2B0xZYrXnq8MkqE/Aw2y3jWTgZLv44YtV7G71cP5gR6jNPkNlzn1y4kzK7D+lbeS0NCZeMfUfWMqDOW3zoXv4OgHasNCWqUj7QgAp2ar4v0WViy01fDlxrVCSdbAL8I1EOn0g4ksqtBiQrHAgQMobaM67pcgN+HORqzwfh03S7GS40odv8BZwPHNK0CMMHWQ/cdqwEuWXTnNBUS8ESVFvn0J/eH6cDtC6wNLBG5BBFwvpoe8rHmYADlfDE8Uz5e3bjfyDzmaGnsOqAdFRE+9Wk3nuPYFn23NeiMFHYoM6oiE+CUXqOGAr07klCaN71tcG6wU0rGgQ31DOWM7O+D/esbxZaedU2Uk7zSohAurWIxoIPruLInsgOwLOZiIYuXaEkB3RD4jRu/pCSIlbPMoFLSsCBxifmZJRzp900bGTuIj4yl89Bem588j6I15pgXe52Cs/vBJ16VY16LueCJ0W3S5J3ZIm2uR04zhzqhsNyxhSa09z5kGdODc+mV5iLGWrX+Ob5essVYT1giyXBK6Sb+xWf9pE2ee2f9by8WGBTFuS8S7n2Wh/ZmFyfwWw9ZzjywP4SzrE5yvkKvn7VTVH1U70fvRvSKKnd1Hrg6McLOGNufB94ThwDl9g25NPwLJwMHT+SdJjcUCXXD6flXYg1WvB8wp083iW9lrAONWForIxv+Wr+izjW7Z8BAGKNS9YXcQJA3SD7zM3r3wAHmWo+g5CuucsYyi67rn8X+Y5K2ZZuFRFuj1xpcKkdLyGCADLNNtLhoQ/mDlt2jlBiZy00aNphWYMOLIdz4EKBFNKt6yxKzO0p6A7ozkOzMI8At2ZTp+5qkLfhwCRZ6MZ+UCUVvTwb45b8kC3tt8Vq9MEl3U/21J7dgedK9jraO4TQd/vwZwAodndJK75cF1SgyS2dtdDpwx9kkHLsKfYcPSvpJs6bBQLxoemXZ+3WziyCKtGut3JbHmB1DssHPi/lNBG5x9PllCsZ2/lx+Ix2uUBdGlehMbWz9hlqHHzEDrMAgZuMKLR6CD6ktzmU/YhzRQOV3wol+0qebg4Kp7QriTJbjdkUofcy7O/WVQ0KH2I2KTBELcuFdDEvUuIKkNOBi/IC1sq+1nZgTrW9mwjTR2jDeeTwqaR7SznTrjpTYnqzoHpPmUWw/IEMq3zdz/KP66u1ZB954oCneG6s8LrQ6HHQn69mjfnOXfINQtfnoZTVnK4xu8lKoLngXRnCjVp9RnV6IQXIB1x4vjhBDiqRdD/xGQAGq4UCVmv7I6bRNx/QahbX5VqmuUBJ1xXMvpAriDx0Y84Nh2Y4xPEdOIvvFrQSNwLEH+RgYNANbK9ADhLQbii20XeVjc8VQ2dtoHVTSRGyEDiV5el8XQd4PbDg53rYuX5YYn4/f1irPHRIuduQhckNruduuqfS6QBPFguO86OZiPPCWgpVQQvOW3Ov2zve9PWn3mcA9oyVP3H3cuxREUlexY/4w2ctSuL79UrPWXm74lK+zycSjnamNVHOLxcaTD0Zr6qC77GCDzyMKyiSnpQ1LFmZ1dqrPRumwRzZ/SXJeSVVEIMGckpkZNF1mRrRMS6cnH2GJpowhK7NiOwiNIl7jcWA2mkkefpZGuuwKL2XYZXKjIXOyv1ZOJHcqB2e1fEwEix8jsQCppkFgT0Wnexo5r4q8r6gZ3Ccw/Xorhk5j0xgh1F7pV7McB53poO+5/EkxUE6c95leL/PfASTSYOyjxwEITeukUOqtWQfedg/IugskSjpU7GSBkPmtZcWVT3LmE3eL9jTQDLUElPKhvusGh1DVKT2qsOKj4VQRfkU5UpQ+BM4fpbjVslNyj6yrM73dK3yQOG/Kj7XMVqjErrm8JJeASAPsZBt5zqUR9MBHPlBBDRPtPC0uo609go+BwvjRh2pK8hhLYWMIlkOg3ktNwlFfeBWTE2TBLESBfWA6gJOUQqmO+jGHXNwIj5O+NPUdICXwd0by0wahhj61m5IpeR4Firz0cE1qBsrAl/GXw482pF3Ei/7I2WiT4dN5/j5Tup70nysDtAaa5bZOfy6j/FYwC/0A8D7ZwCSI5yJhxEFSrWRRjkgcl5SR55TYBwFDOFvnddqtOG1FrRr1DTnMxVtzmHGNqA3ZlY94/k6Z2aJCW7wGTaquI/vGZnxTwGX/W9SdDnJlS/lrnNX6XSv8dd81jISLCXttgtKnahhYg3jtQBhIlG+KiOvX/JMEchyH/ZC4ld99hhTWuQT4DCNDEwwXb1e1Uyr/w51zEt1jNV1CU0DTkwnVoV4tIpHTffQnOexQVdnxUyx4mI1fgSHwy0yD66nqq8uQTe26QkRGPo0ITSM05bzKGWNKTXozA36I5NeJYujxGyKTscOoFXZwzgdDhVQO5icu8BS0gtU/PBvfgWg5fAcz3VAdjgwIRt43HOOTfGWrIruPvcNk2Z4hBNBAe1EzIYPp2j0s0OHIZmuXgyaLfh0WXWVGsHRTJUzm47AgT+VxWH7NEU6cGm3MafYEpnZXPCfjWqrPhrf4l03JqYN2WY4TD3rPwS8yIEODvzHKeQRQ8rscJaAPju9Wsu+FhUsCuCcgoVg+NPtvh3AYnOW3Bw9Pf0ZmtTJ8kKHkfoVgKxMBxcdKBLXxnok3DrijO8e7l9t2v2KxNcFi2LlftSEChMTRtV1o07hU+WzB5wLTEDMdg9Z5FmslGXw2swCgThTeHW9UEK7sq43yKQ7U26q9kHXd45brWXTRagmNHwdogsFJbKTjL7JfjpRvmm9Ih/3wazWvnCE5hWYR/joWKwTrZeaapVKgyHLBTMba0BeqNZzpDUyvdWx2cc1YFr9sbJIJixbIOxwL0F20qmI+POaGdYiMafrysdYetURGYfhkVzV5wrOOIYzK3SsOoZH8IVPhD+niwhECXy2x3eRKxJ+xGe6lhtyO1KXiK3W/v6t/+zR3YX4FYD0/v/6W4C6/oz2joSzCqEGVz0WLYBeO1j+IvRG4uMw8Qs+ZbIAEoeKezL5hRDEciALjEnCfafJyd5lK5lbMjBp64Bz7HIWRngKt+xAZE5n+UwtmFnwO/o/1/ZFzUdjb9ZeWp83y3WkY1fsm0f4UOwDUjpY0SOF16uyHvV55vkgx8335eV3v/198nz9Y9JA6y73LTDFCDENA7f5iB10+nxuD92k7cw7j+Q7iZVjUqAJbivMxT0s07/2s50x5+8tBs88a6nfPh8uBP48vIEwLHmKg9+fKagFZ1pp1ED8fkJ3nejpiDQc02fxmWpgJF1wf/FZEdsgDtel/f3SIrUw+H2Eh7wypPtsNSfuaSF09TytfMURbtEJNboaZwtPJF17/bBb1+lKbtRxZKe3OovfyQ6UMSMmbfjDvPrZEhPcfn7RPD52CnFAV026vatIe9wVzCVPwqfhwSz+KtqL6UkNmZ7L6PFldk12cxxT6g5oTSTDWtQI2Z1eOQEMJCLe8rcApbcCrdzmo+YjVnidFQO2tOU/QpZKK5H0Zx8E8nBZAHg3vJu363miktZYd5mdmOLRoLheEpxplW6+JxXo4FxX/pDVWanvsjLPIv+BcWgB8N9smZjT2agP6U89bG5a0zicPrzLAeT0KiRgvKLbd1vyPCKfy1yioXvxHh6pwoklAnfn4ND74UxiMt7SckmfAdiXDSTyIcG4Crs7Lz/vExBb/41cd5sd0aUBB/+sTlc6gFPmCBOfg4Is320Pw7ErN8cL7NA7QxVZUREfi8u2j5STH56m7lxQl9ifADHsInf72eUpARPUgSslXc5deseVKBDkq/eGHoA+jf+BHkr6p/GRoFk+DVlUCkz+HZV2XSkOjUKvWEJ4zJvsnpSPs+VVnaBEb4GsW2RllKysvX6LVVlI7yTSaINp6uFbtIN6WR1CtEZCOeVIt9kVK2NJ9jmws0OGjmNkXXgNasxczMIsz8H8cmFXCrJpd+YjOnllxXPYwTl1Qd2+yglgFBGRXwFgQ1zo4obDQUDQCEfeyvFYfTtLqvFImUdidxJP6YIOYIXQ1p/isxaSroAJaNODa56r+pEnaHbFYv37e8Ej1+txkytVyirmPZZPEz0716ruR1G4k3MCycdvFBhKnlI+oQVLELxfXD1BS+x+yCAxE1nEKwC0WDAa9ySvK/i/VGfP5tlM79zrEVZnU6t8Jyu6VLqyO5o17i59aaFeMVN9zLtrraLQSdDjK4vLbJd7vpxxNhBX1z7Zr6VgIaVt3hfwnRL6SiHltVpqUbrnIunt1xZP1qNAos2VyhKquZ7Er2I5HwuERpm+8/hWgq5Ca27FRefhWWhM+6Qssa3mYgmh4XOLIb4PQ66QZplazRqRW43r4O7z0jHu+1TPaOp8TDPsekOwbwv8q/UZKyRIJga2eWF9LfCfynIz54WuHuR2+4ya8IUc1JGzzhVYOFi12MI9b0sk3eOolxVXLHHdL2goYSFhuXwoPer9SFXfcrU88lI4dxnPotEsYCLey3TwLsCV3o757TI98oJ9cjM7wGsyeWDA6xWaysPEOd1wadr3vlu8d/7nrpZnN87t54dEo0WS1wltXnOBJOQvB81ap2Rhz6J835uUKwj7ymjlRhTyGU/3e1caz+PD+lwq4UWuVXdqVGdpQ250NBd9HLrPOei65uID3kPykU5aeTT/Ts+t4Iv13fWZupG/JdpJvj9+533Bf8Ugvjzka1aQT+6Vv7bD+7XVGdlPPe/OKypdwEHtR9j6feiyYaXOqzXsHBM6vYoFNl7AsfZWWthp3U6y7XCbRGhI3m74vT4sb/WL/MMDn/CVInb/SHSnexlIxmpeMpcly31N+zD+fqQSThYr4TItRjDjR8KJ9Hlf1scKhw83R2fxu6r9oeEoB9mKndU7dc1CDf11V4chcw7qODyRUcVOpHZjL+SgjpwTuVAediG1VxcF3U+8AlCWa7mf6OB7c726RGo8/t5bY+rHyHfH/jLC/oLxrQdJlZ35IMwz/B10gBYSryUIPJxl7weS9YdeV83RGb040BG/21Nzd4DFOA/xxN/Y9WKPEzt2MdMHgkfTnq17oCm5ikrsMEBLYeAoPgPwwguHYjqR2cw+8cLc8yeNx+fH8QxXePZ7cGomXXsDP5i7xvsmwyHnm7A4M4m8jn4EV+Jg4qhXWEWAZdmfVlyzsa7LMhQJmAsf7UhFiL3oGpJeSFcXcrwVCwiR7kV8dGpeXWt94/7LddtkWUNuQK4YrnVskQl1gXsdgGi4cZ8DoR2X5tGQZ6TJgsiDuTrpswpJuxmtkBV973lCsCJuy0peNyZIgDCc/cjNkIwV/14fdgTXCrYV2h7ZkS6f007Oj6a6roc2cnyGc7d5WZCQQ7f4F7p/zUYoNnWOkfKVU0Z5QO/KJO8S+1YzEG3Oc5qinSp+mEGex7L3FbN7H9kvGNlFeho/bAeWd8nlwA/byqYw7H68g7HQuD3YEKxPJzV14Dor+4Ms0YtaelaXGpx3sk4b1s+h3wGswQMr0QpN+9jLv/uHf5/Tv31qXgF4y+8OEu/Iz7tks1+K81H7fMUvb/0EoLk6wmksPTtEBGqarEjKkXDtYyE0HaVAXEuYfr+XTrmmEXMqAcDzyHUOibYmUw9pXnB1/L5MpvgT587N6DN56iXB4X0oNgvBWm/C5RrRrkvm0zWOSwsg361qWduSPMucGkgdw3ZLGOgPPHXzu5TbGRH4s2wrfOBApd7n2v12rCq8N5jmo77zp0JA5aJNlbVHwNcJJN9xYG1npHZfyBJ/rPRT10T20dV9u/qxcqGle/EzUmqv2L9mQs/xPThTDgmJLGWEaI0DNTRNo032fBp/yJgcBhyie97XX6dkr39qUyb9S/U7FQWR7ulDwGW0CxIh7QH0U8HsJG3nyAR9s90szvgGlG6QIl7vu/C8cBXm+hn/+NRgVTPgKe09F+0USmsgx9u7lvcjRWExXLQkLoJ9oP7TEnSKxAJ1HOYrIbB3vez9hnE/LugcYw+EIMMBytP87MD9O4CjxakHICqqs4e8/Lvf/j6VS9ebm1cAtiYkDtips0KIm8MZd1egnnWudmQShhz8wtvU4kxxiOxNC3Dgoa/AGZE+VQRZrOR1JikbqU5Wa1YOB/R8WKzGdEi38+i4ZpOVfRZnlGezT9XSYC7H6hpXqhN7REOsP5T+Uu57j7TyKrKUR3GX2uMzoqeAiK3MwqX1nAI+O9e6C6pZ8T5TBRztHHkihWpeHAU+/meH2HlNcLIDEGXya7ND/yEN7pv01J1HInJOwuxcS2glg8DBWVOoHcXxXhGoZDv7/V0dToZq6/9fsjn8/MEAO0Gt18MJoPeEGKyFVO9b50p/nHJJQPf4GlCEFvUGRENaUFhTpGqs8WwjT8qAVCPHj2bn1n60wt5zPViNd6zAWhWX7X93rHVP/bGr2+t8bOnDzsLCA8wP+7BkL1H/2GgduGy8h7bcuBxOd2QfPBL70JPxJNd0gJdLo58evoozCQbFOtqGrBUnA9NpBuflIscCdBsizwil3PrFxsSN+rGG47+Pv2pzTaa/J4uzbR+5BlMjgaNspoIoDafJYiU+SfJJymaymCFCiZA0K4dDv/MxPpYXllDfqq5XWUV5IDV0Z62qLPI6me5PjeeN1mKHC8lLKW15JXfqlT5SlitfytInLstfjZVyHOECz6kZwWK7Ys1fUJmA1OtZGOXa3tRqdgZrBgvUXaazfSYmhOcceWQFLEeuPaOWtWv/EXwmgxLiq4XqBf51V6Mlt00+vl9nIOs43Ml4kop7lfp2BPOkDlgUplZ+H8Tff/sxpvYQnwgT6SNlk9FBw2D+Z+vdPwNQA39LnxmgV65prfFyY0GXQMHX3Jyc1yScRr2o9Itgp8sLBzz+TIVLMR0xKVQp/ky/GUO8b5Sd/rr+XeUMi6fvswNVB7CinuuqaspzcFkHrnu8uw75smaYwNbx3wx4Gj5UB+h4fKNDMn3vD/397re/T7tPOqt46V7ije5cg2sqepLqc6loGoEznVHELogr01LXKJPyft5cv/Gy2GgSeSwDB376aoGbZWGaxnyyhz+b/L5SoKUuZZ50RY3kc1nJKYgjE38K1NfhJJrVimCWCBSlIDTyxNbKeFzvz5ePLxlO8HRXpp/xOuuRPlzH6on8aB2gdX7WrTkOWMjNMfOs7F0cHHAsE/Tbnh7ei7Fn6SOqleVbPgLPXh/d0VQN3cbepqvNFO8kRxI4L4eP4JMd8wLP9W5HMpFPZLUYPjc6MhvZg/WRW83zyqnb9kB5hoFXADLZ9LMAyL5z6O4C8dImPPecE0EfypXb/6GqurgYatqla3RqWXaZdJXcFd/KbiREmBBaHFCC31jmWogtyzfm8Ez37MCzA2d14F0cdgbFfoQa0uH0YY+o1OD33mNZwjurpaZbRuKXgGlyNi2toE0qboNd50zz1Hn/mYlHWMP9qj6TU3DiTFG3FS0fplCgN1fkKvx3ss6+r/RIDftStVEwL7DrKxbdKzrNROj5srO1Fn5nZ2soO1lTQrd7zMdfY12eHKsJWBo/ixV1RH+jjGIfPMIWsRHOEZ/jTI4gLDI8tZNH+EdiF2vM0IPYcB+6+yZl6B5/IkXd3SfIfOH4w6VZTWMHFnAUbXJVcxeeKcYkIU5ARh2XZSFVFS40s5XhTkSFLPpDOOgnYiUaTA6mc80e9IDWxan4eDlubQPzblbZnK7DpHKMt96l0nSRA98CBIVQF9KkcmovXs/7MzrQaf8ZsCdilPVzIuRRqItWZ1MpT83xdMcRui1rCHd9tHItSuM8Nc8OPDtwyw7ggfn58Mw9v+K4egUmE75C4Mepg+CMwwIDag2bLKFpYzO0oh5H7xNm60Jn7lwjUX+zXwHYfgn4Oxe4sV0//5gpt806E+v7xvnLa7HHZzd12z6dmsAXZ+qy0nhdMmpKXpgUukpEUfK6++k8na5OVUfOg1nInfdf/ZAZQUxjLrRRg8hEJK+tLo4a4st0kRns+BjrViKfK3c4yAQGn0GURDhJ3jKq79XG7OgkFkNLv12TA5D+zI9OoDVGr7Sj1HT4SBwpy7C7/qJCh7PkNikzGk1l8Hr5ZIaou3wsi8YUv4VYHPoAMHVsKTm3e+rb1G0qF/YvnqNuolkCANFzPdXDbhUWT61HXcSEBbDSnlwyl4nUCGzCpXOXITtIgZFZSbFQxkE4dl1YPapo/l0OVi1Oz7s4eA6Soua/6b88YzeAhVqwtV4B2F1ICjZBZPhA4t6Jw0U5fSTTiYkOMz0NwCn5rBw3SCGp8jRhypzsMA3dJPgReciEmR/J8ox9duDqDtBCrRZzO746/xN/vQN8kGFhHSs/JlYr4QjWUuxtll6TBSUfb6CFcLClFmywwZydhINQwYw3cDtryjLVmzWG2o9XAEqHth8DxrTwRNVH4+J78X2+PhS/2noWm865+xK0PvPb22kDDvYH65qZDXiuJVLCuRkZTc8Lm4ZC/OrLoP8iE1qRdiChbETJmT1ZaJydYcXKWAMODUYGH/lqDEVV4OyaBb2Ga/uZoyO5jsQeqeHqvP7sHGH+nmIXdhijvKvny0ib1JHd0wl/TJM+rkIjv/X/eM/jrZPZ/bzYs+L7l+Ygj+2nzI5c5u0x2TjmD/O2BRYcLkfPIGOCT8uEzT3B6jmn00FT+DocGitvpS+1WyCOHjiRb6NaK6fimR6Q23lzuK2ZCk+6xysjDEOaYtwFtl4p8Cph4cpsIWzZjFCA4UQVPU5RBsex+gOUMC4y7MFrAwIPLQDuHguWp9YvhGiQroZoP28P24Hn7OyPQe+5F9ftvw+7dE8kdvrMYzoeZFKoOvwRHymf0sBu6yKFI7AbLokNoYYOEu1yeVhPj8FUCeQ85d9LeIJuptDtFQAKSczBfhtgnAbHirLPvQh3zyVOPdCDY1k7fXTOdxtvYtXc6rO0xjgYThWiU3fRj/DpAvrKqRI0FLGlunAOLWXteUdNsPPWtxwcbJFTeITYVPYIoMPnaTq5A/YR8uREd4E7pTpaslNLfFRp6PhJzN8+ff1VwpKvm42wKzux3q5MZ/W5r2mf3ZWK+cLgogPL7MxbNBoc/YqoVXKaREyf5XFAb7E9AFmFgnxTe+XRG0RYcVt6ALvOT20mOuW4sbNYl8A//pqPWdEEhS7GoN/pF3/pSPWncZqCTvf4DMA45EwP1IG2Ygt0KZ+ZbwartGYmxvV9hKJcgrc2nt5htwBq/zjh2MPNAaMEOXfShzWcmy5Q69Pl2YFbdYD2K6xv7GA3Xus3TjfZVGLH7ZkMfU/uszU2kzYbrluDpaf1xzXXITO35fKxuhhnWVgmsJzxxMBmLUWQz+gb0qJzvEZYGLCYaXg6Adhxd4m0+QwsX7HoAIauoICn8b0TyLXQ30H1tllefRHV2QHCsnwFSGBExUhvb8MHTHDlPn4GrOuUbK330s3OiM7S65tc0Smim2VujzXWM4EDJ7iku0x0UW0B2mNeQwzjV7/m4R8lorceAtwOXHlazGivqADdscsiKwAb3ZjAPFgd71SdR6G99gk+OUgekXaURsrMQ55NoBgm1gc7INBYxNED77bHIUIfdrZ9PH+7VIRD8IjEHI4Ier60RuMHH4P4mIme6M5gKdEjEXtGsms+lkbydLrK2S0cXw/O8HFWqS7fh2WrfIzo9ifIH7H6cV+uYU66CxfsNTs4ScaRrfIRA81fGCtx2LfKuzco3+cj169sNunlcIPga/8zM958BqDH5nQdc58hejqLDiAT69hWVVdgrnL5weO85ebZwm3DXJ8144QTgSLmEbdwEU/HZwcerwO8xFl4PI63Z+QftcjqO9ye8G0yonCndsd0G4bIchsas3vMrH+wYxbsbZoQJKndLNra8zINU4i2igMClF5+99vfJ7fXPxI6BW452lSBjwF0zxF9Bk0W51y5i4MzLZj4/AzFN8jdcK2cadyneL1EZu+syOrUO8VEQFZixZDOdwn0e+XQDsQ58VoDAUjzQuHONYk274Xjpg6zr/KsfaMjujFLsMnK4c6Max+Ta3GlLMkn84xc4Stx6X4ILp0beVtX6nvrGzcewh/DxVVxYC6Yxi4ADeMHu860k/zUOcJUe7R0zbJvrdxFPyeiKoj+YBpNMNGIEm2T/8CPUdr9DhrJ0EpvHQ0sf338tI4bci+ezWJl13ore8dTq07SXFGd7F6HZm9lnkVjT93L0iFzQEWcKd0sc4TsPA8QkKFdGpQlsh9JnFvKXc5DAme3jifkJffqzXkkhSsxLK8k5OkXhDbxhe7pFQDaJsWm7Bf25lr7MZ6WerrWVg801wDYk+n6WcPWCKuITzjhfRxpCh6gCl5ixAV/t+vG8fIjCBGf29X8zPTswLMDSx147sjDtlGLPliXjj//iSPEPYcTcdDhHU3iwaYdDFd9ZjyvhaatayDIl/QtQPL8gNMkAvsgSfso2ejMgRTHrp/ViAl16uZfmaCSG3xc5eXXCnSubpe026yGaICMpmRBDZlcfcbctM7ieXd93QfudMXr69+nCchnzG/Omhn2vAK1B07rdPaOJq/bKTJORklTr/+pLBLqXcj12ngXlJ8k79GBi6/CBnfPbuX6+CDdmv33SCIJuyw3fByctX3z3AIl2zifUzhQasKRBJxemabRuj1ClbjJnkjZ5BM2NMSO9iGS1+qVpS8T1FDVj6E6OftE6zI4GD03UflbgMijod2stgJB9/gMQFFwMRTfQrAtLEgEKRPALL4iOCbRZFxIOs4x6aEpTQLcyP298CztAF+5LRa+30paryweubBWmSYJlGgWYdZfpnvKzw48O3BpB2j3tPZQmHh7kIaT6CDyVHj8UDkFe7rzGk9MJbZHKB1HsLKjrrXqLMxz9ViovD0X/KOj0cQac2uoU0PM1VZ9BqBt3Q6YpH3U+uWxPl+hAJ13gNKFvlg5fcYGPsZ5myaLPvBWO2iN7pv2uVSDaZLXn7hLw7zkSeHOe9SGCJMOIBsMotZiKpI/BiSguopzPb97TCzPFCcJuTb1s+k69UoSkOsOaPtT8+zA3TugH3c2Sg+5epv9VO7sjSnYWEaQfViDCma03JiJ5XBcf1Fdfeb2+iEaFHKETD/jkQYptnF6cuUwBRR4Pk9O8E6EeBt1QW331BzpkIjm628ScPVcJRJWfAQrEvfPABR7vqeyq8rJU8RVrs/Bh+tANfVL1b2HxTJXpaxoGEkO0n+phXNBa+mGhcyROOJNBei/I4DP2GcHHrID2FX1DovlP0VZg0yFn+t834PJQveWy3+otltVvAuSFvllPS1C/C0jyECC4nU1289Zf5nXlQn40K5WB7/mXw6rdSk9SscWQ5cUGf0zEsYbwWx2ee05EjLrLzH5UwFoAzVYnhNLWUbFP//A186BX4FcOaiY67NPrVFk5HfLcJeUV6uApz8jWMXxtcw9rJPxAq3V3qiaBB4QZyKD2wZqf76FPUtEex+vq408MOakRq8qaFkvGdCHti6jA9W6EqiWXriU9xzqb6Paml58m2FRn3MvV76Uz0GvUKyeWPoq+DkIdMB83DFWbwByc7lujnBs7D6C8F4c4Ym9RPOcAhkm0scTnXEIctwBx6guDuqlLf3RDZ7cBPlIJOUu1K4crR/kSv7iGILOOI+Ve9Se6QxJsUUT9NzpZN09yOn2hiCq1phrmmpdHcMn/outFnkZgYW1urYoNUdLaC/d+XKg+LMB8NlrSXNsfAZgax5813u5scJiwtYh+jS96w7sCytQBtbU4ZU1lRO0zBBen6ZHBmA3GklZD5EvuJVJCbZBXgAZhiAFJ5IEhrHnOzTpm+H5+Z6Izw7coQORdR3xAfW457ml3j4vH6aaQogJyEhKXWUTKIcWuPSZkiWZqcBTnE8v5xRWl4JQyfiTWbRGWtfk+MxePAvr8HtkatD+LUAv+5OON9KX7xCls5YtYg8M9o4C9n7l8yp5RXniXDyY71S3nfkBWO5A0zv/vBzW7TxPnI8eIDIX2rANBlPH4oFoL/yxEr7+XcrjXDsZ0YgnJySQTd9uS2GSOWuadIwuZwex8KyuXsy0AuHdvBJTyg23ZshUGz0nIoGrprwY0hZyVhzYTK7YrS76fnd940okppR1yHFNAH//fuVuOlxV0a9ydJ1tpZ7xSmPwrHxscLK0ni+ftmtFfxRhVAvNgrh21UYJXxY7Ppqt1uR4q7cdTM53WwFMkFNfjZvlafnz2neK83dYIMQfZ+OeFiXw8ftjxXb09QqhcuTjJstOEyI9RF4HpENsRkUcdvC6ohZGWqXc+kXH8fItxJ255WHo9arWGiN0Wg1kPHPgVcEoyyUwQiMEu3p63oaGXFbK5CkEMRLTYxU92c8B9Lw//6UBewXLzQDNhjEa/cceyoZRB3g42w0OfOR2oajZ0rgiClyOZZBJoUpoNVnrG6rkAB8WJA1SNv7SOpS7mMModkBqSUBqQJs0zU1rGoc7DB+Rk9UG2WPL57H1j9FtrM8LO4UyMV1I8xiFNyX7pCT9JpCHER92Pku4aPosWKrRMlFF6CG2ZxU4i3Ov7E5bZkt4TP9ggeQW9DyrTJrxe016pIS6G+kVALr2//bpLb0CABtdF91/+RelJEM+T6ijI/ngQ3GEFI+OnC9KHynHWWnP5irI2kTOFitpoEu8laZZuerJzBWF+DQNKREHquXAdf0tgz6zV6mnWKcGf/37N1rqxI0G6BVkhbwpnATOfDlRMhEh4Ab/bTgzawWgvSdAix6bEMMcWogbjHHQ0QyC7VtmeEaHc3LZ46avy+R6gYyte8Xu3DTHh50hcAgNZSk0RMbG/z0OZTdkvVzybYuqjs9G6oYmvGQdRtyuBkLzuLabD0jWMRn6469gy/50+wDufjcoUPJs+tCs9APN2EIl5+NoRP4gQ6dvEXp+byMIR33s4zM3R6aQcy3104W4eSWyJeuMZ62NgqMz9Llsr+v+OVtzUImk+9ddm9Ya31jGCuIhO8wLs2vxjJzzLM+IOMJ8tktn8G0xiP+lNLg/p2aZRy0RkgbkYqk6A6V0hrnrXEWOBhpZ0iD5SArEdhFIyeV0HUbET7SX1yEbSEmxMT3KkClyC6XADT5MVyJxBo0KN8ehG0L+Fv4UlAZ/EE1TBYZUclP4lWwXsjFrxC6wu66+ZUqzVVCi5Rs3kAUJdQRZ4lwhg9sRhohtCj8CeEWZy5hNXcCh6iw9OXRNswQA4rfxlEQjYlatdlyHVvodgAT0+sdcUX4RYLsYl9/Jur1rP7mUFwhsfN+SEySX5izcj1q2lvOkZYAU2OlYAI8rDfi2LpQxNZvV9pkouywKNvIR/j6Zva7sd12iQsPK0BAp7rnzVf+LhZVdRBMuVibCu8glv1gSrDpLsFdCN4O1Z1n6LkitpFcg8QQ0t5kONbiV+9r5oUb+zBPVk2qQMH5O8vQddP8QwikwF7MgGvZBNCjEaYs0cRNs8tU6D+87GvhmDdap7eJOs5xSXYQ5JSK3bromHJ6ywm6UdLi9XK2uA+mBs/yaNjKf05/wPrJQbjPFDsI5tYgEVurZRLEZJ9QmYZvH+vRUFZeDEPn113RPz/JpCwVlYLloUr3I22QXjQiKEnIYwkSGnlc7LNR9CvmFvFe34ji+LmpqVcwTkPCQB5MDhkOejCITTNEDAuMMYzWlYcg7cRAtTOIlhV4CysdNr9FynhvZC9tsa7zXoiQdMSdS/Y5lpyKYqGnH+2Y0qAvcVRoAh9RO6YdwHzu4aS+aQFv599gVnMCOim36IEHRCql5XzKVRiUEb04fggiWGzjIreV5a/245uZ3ABBApdDlfv7+H1Q2xopWN/wuICQkuEwkCtv46e9naBx46JyBdYt2/BmzG8hWR+DArQni+zfMqLUzbAv5S267ZTVJRA1UIKaVZxnv20P8kU8LGK8scR7KIOU+YcuD50W+wxXOVggngAMjQM99YFoGf4ZJQmTtVQGRgTHXVi5rz5J6K7ZHJ3cC3UlXIOjgc+jjRpwCHebhlODzL1bOwMJUEl4XLPTCc2f273KGr3RE8uy2q5vhbjAk6S9lcueM0PPQQHo4NdEWnL/+fSL4qr91inyawo1K5DqX348E97I20miIx9RklJF2oD6OMEjwAGZZo/Vub6LZbTuUYiEkNznk+mQWVt5MqFaXm9XnyTjdGiWwXPiQtxDjeQXyAoGzSMBWxuOLixbCaXG395LofVA57oo06WACnfHYtwfYkuzSW8bZNHZI1zKqvUHFsLPGX/T3zjWhdfrXP9FYfgaAhhwAgbZ6v6lRrh4xI0rUKfri9NyAqTy35zlF7+7Oj9wf5tYsPDlcaCDDIpbX1RRsA7JA4yFDZA+oxPx2oDOIoskS/SRUDVM4Z/qTxykmyEKZ53Jf5UOKSmUPuAUcBUzo7bjNYrkx2hDh7g7cVGaiNWwiwSpZ+gRktDngaD4NjcTGfU4qK57wkrr8KuI9Rxn+Qpgo9f27ylZI+V1UBsKR2Y/4PHDJcmakfITy9i1A21N/NIiwO50qXwxknXdaesmuA1vMwYIchIJ0/n2Xm1lvPr+Ur3JYhPQVX76q0c1o4ZyuDzZZnklH6mWeWGByy6bjAvdwDYpZyXBqSJoR4xoGPM31IIDQWJ73hClukbY3IRQ9yOtyFsnvIeZPGX39FaWmzyA1BF7MdzRmx0HVls+hbuje5zSkLjO3X6dvqgGfX6e7fN1lMyf/F/Eb6oSzLZHsIBOSfhvic1rw3HLnd3O+bMi5q5/01aAtp7hL6d4+fU/QgnlhkKyfslWEkFjsuzYTs2aE5jFFMB8aoJDP+ck26wucNe+WPr2LlTCtK3ngVl31R9OwLVn5HtXloVUR+2pBRGtjX4Nm9G2NVq3eWYY+PT4ucVqtYVNQGFSnKpKwPlv25OkkTSRkQIlxpSB4zvZcwmyyQOs+plAVEZJwW+OzFtWp5ZFUkdkH30h728rkrLW2S8Zljrpkg2skE5N9yWAFke7xaFEUnTooWMZ3PE5TRfIQU4fsaVQK0C1zlZz3vL/hbN+zTCc3FuGzD06LLjCh3+g97eEknLbnAbRAX8B9CjLIQx/m9n5kKeHsqvOO0ZIfvRGrDMFHJkTV0I86wDDJUYOMwsf2IWZyAFe4GgGl3HFG5UGhB6IV3IdQGF0+uTa0Pdj/dUrrkdP1IpWznHSxjvN0+ncbQH07fZYeqbGSy3yh/Qj9CgAd9ul3ADqL4Oi3ABGkhuVrDESPrH2SigxwDl7rZVTmwBoWmJXPTVrBjREcwc/rBDamcqbYqOeGKKFL/hT8hg3PHTrcWB9kGJz9OFu0F4ucG44hgXSb34Czc9JffE3CmndLL/mYPqIe5VMVF+uHgLtQbIidmqmZdUqlVwYSQp9kxGTXJjxKbbKi3b3kK/dVQpAnFQuVuR5smOyKcYPL1jp2dpSwgS8jm1zFZKiLub1ndz6mkYdzbG/j8xix6nWwru+iknlG4mf5W5i66Zan1luE6bhBsPi0GPMkjeXfIA8pqeNSA3D5kAtBURZh8MT3/CDE8jyX8RX9WcPUUdy6Ycm36dWQRsDhMFNqCmFgm/NtiOkTd/oVgObZP4XxX4Ds0MWqRtAbYnSO5eOYYx6adtOVZngs2+2iiTbfpMxKEnTt0vqBZWoIaj+xAwwlka3Od3s75dxFWFDeJKlIsrWJ7rhhC6yPh9yEAErkQpthWwRfiBHtSj4c3wZsY7quk3zwZ/gM1duntIufzEkyMWIN8mBL7qxv5ITETixzMGuS34Fb86gGJJm3YDdNLWrrftLdgrmFXs7ALfLVc35uRt12relmvH0TujQsJaqQJKUsa5Syj0bWiLMF8r701C78DWn/OD3ZW9HUTMMX/QrA7l4f0MtnAKRdyvpsTFpZbjiwfl/ogeuaFgijNcIOng3x8CZQwlog8jqQ9J+VndQOVGgW6g5TIZTLKmeYCw7Hr13xtRwn47mmYEY0Zzgdkc5zkxlTNh98UGPkMxVDSue2i9DA9nRYAciNgU62R3jdTry+x7wmZFHchqYBUr/5I37EE4EUAsduUkmgkfe8vUiJCZnCG0cgMGw6G6EzmfLhadabAsFZ0GaMMFiJapb1SIR7n7SxgyTAWObyxq7kUR/DSTF1/AmlqJ2CR8s6KI2cuuSkav5nNXaKkna+VqPmUVetG9j4kIPsnrQiljQa5Nq6bo4uO0DJZRMaLvJx1vzskIgBMl5pabIIr7E4Hbt9muv8qSuIdN98C5Cuwmmkdr6VphSQ8g0JSmcQhGYY6FQTjKVEQU+diwI1c+12UAN6yyQPZg+Gcx/QE+7Mg9P2q0NRXBoLfhSs5HyX2qdIRgrp+XBxJNwkYY/EzVPTM1T56d4+p6SVLUmtkmM7Sge6vpuR97Q9vKRLqRkiS8WStDDBR3ommZ+Ls8A4jiDRHTfbxJQqF0muMjwHsgPL3e8G7gtHrBSZjhy6gdLnoeUDy4oLb7rEehTezaD7Bk0T+9CtO4lctz9HsD9oD/EKQGlMWnNlEe1n/Jt2c5o+jyngfJ/werepFhea4mGoYG7vp/xLGtOVVAfWYgIk532ZFBi50r+2Chk5MVdXCMCNt9wH1kSFjBy50hwFHPktrxzqQzfWn74RHdMuc/FesK+i0YyYuOXRjhywMOTWidKmnQzbwqxkdRz9SMKbwTDPNloWo2vgRII7DY6Erfjsi1gsByGuYDYxjAb9+iGjwc3DDW0vI2tzSuiQHaEk47afBhRNfd9+P1JtFaMmr7DsImftPq8UCEJM0f73C+34nccgYdxEPpJoE2sEUdadKTT1BaHBimKZnsbpVsf+SIT90f+lF5lLZwkSdtycx3QnSpoWjyrh4zMe8fG8BR2gnsjmg8xsc1JjJQcpZ8TFukRrjiMIsCIqnsUQuve71KxPB5EnwvFZNo36lmiOfFJy8U1uigsWELb7jkzIeJVB+jdd2VrYaGXAnLzhzQV1vJkQCfjrOGWVn5FxrHDoCUT++c5s9VOzmyV0w6FkMojtelqwP5q+WSHBGb+iS01qOWuN6YrsRzAl1SM4o1hqg5vKNY7AI3YicPJUAI5BWdgOKIkU6XA5vGz5kJYtfd47UG2HXm579lo3P6KJqOaCiRYhPcUvcrqHzNtARvId3CoGtq9wE6LtXyxTziVo+X5c7jJ0CZxNgdlCtIyV+oJ9zj21HF2/be/PIX8uStMBOSRZTkckrwyP+H8Mn9kuWVVft+CtjEV/uAKaeG+5vPzut79PawPv4U6S9IactDBAOLzNZ3Xda8+Hy90fleJQW31GWYzDbnyF3ojY1YjlwN0Qkzi1dLfQus4ysCtbaF3neymt0hry29Wd/MpP894+8uS5IKEJ9OuCv8XBj+1bxVUNEONt379olzlErh+UJP17bmDffJq2bXb59vd9xo7XUl0JA/Pt3ZY06PXY+MZ664oL64GVv1Ytp8lZ6PcaUWRS5bLwLZnf/i4p6Lv8uQXpLUFlZeRfS/j0+ufks912lE+NlZ5sZw5vr38q8YihUcqYv/u/WL79KtnSbwhAkz0T88I2K8omhafbnjG5lluN8C3/7sEXIOfA/bcq4Vm+aDTpRWyBq+65q5X204u/HrIVvzKRE1BnxHfIJCj+2WnRzzrFeJSLa92AJ7ethxrLXipjfQW3Yw6rcPzJ7t1HYQANyCDcyGnFNo1yHknRNwM+qrbWhkVvgCuO29qzzXVGAbxPsIC8GPJWk7E0i4VbcDH91pne43IM4KgXNUrfrmhFuwZ01kXNItnt0RPRAgNibgt9BoBGskPCL7GVpkX2VRjhNRkq83kDJj5M1zSgoQDCjNZYh8PlQEJGLPMHEyujb+1GHeHWBbyx0pm4phvcwxszPDHdfUu4SXYk0akwmZeuVp10nzrPtnu1UolKl77lDcNNiTtRmXROLwfg22t2rXCVoJDf2lzlWFvi93R4qSHZoUvb4iWA0ycM6Fl6ORRtPrtjkTaPZsiQm1kAT4oFeDKscs8Yun+pZ7lEOB+myjBV8tIKnb9xu8uQi5ZChAn54ybrYmUx7vcwSefdVksRnzri44xk7ZCbljbDj1P5NZXwqmuEa7I9HiqVLZdUJkiK3I3tMwCbC77phw6Jva/8URhLlTYozXsHMUNLwCkI4A0m6YewDSsQkNcnpAzrbbaYmI1/vgLhX7MJnYOWKxlUte5VvK6Ui37H9A/xiEVPKt+qqztxznSnkvM6wbZLqJvLweyCeMoyjwlTyLO16BRd5tptQXMdsiaTc3V+G1h7nqc5c3qJVYEr92XJmYSxLsnMQnGtD8XCTNgY4SUGYSmhN7rP3+YjchVWm2rjmU9lkkzmdEtvEcqvcGCIbbJzXcJAOrptkULvqXc3RO/j7RBAipSrOsERTisiM1QpC1o59mLMrUpE9mVTnC+6FxxAGGyvJoBjiP8ZgKZitKVRnjI0J4jQrayib6dw8EDqx4UuW148iXLxdzC3V8jb31x3Ij6gqV3kt5zTyXbaj7nd5dD5DMD2qileN8aqzqElnu7x2jcfWkkDY3GZ5HyCOw5JC0BWYKSUiM8CpVNCGm40bDScxeoAO0hhylkGVrJFpXI6OohTdZoDEjfhu1JvvMYV9HcZQy1BV95jb/aVCPb9hScrI5n+yA9KenKM58d4hxDi923yphH+Ssx+f8MJT8/kt3SSESnlCxLpef8L3TbPEkMuXMXuXvDgLEdSXq+RWDAQC+twWySjBiHRC0Rx7GEWcwBEldmyMAcx6T2VBS2azHDAndsxxfJAwm6orLq7MKRDF+GptDpw14m1SM3qV+e/KZ5gyu8A0GE4gQKY3LYMdFcNPKL2+coWtWF6GPvByPXqG338pvYuhI/QDTmilK8qSJkxHc4WVSeEYUmwwskUuZYgoax5PwuHczWlcV6qBSYWOMQSnPKtkCa75ebrOS+jSc6QpY+0amTugDZ9GM3bZ2rVy/7e8fML46k4BzrDTWEKZ1zLJyKkE8+WcRDmhZGIlifQEdIJbNtHMu4WzU/GIxgzPiVZioFcUc9QqeisZYek2W+5E4lhrd4carx6tGNA6gIUJ7wGQS4+RnGP3FucI7Ef3gdt5n7Tox5p8PnD2ceLSK8kppQp1l0WxXzeqoiwZZ+mS6xnzuTAPWRrXKBY/dihNRLQt0pPSz6OYCFrfZXrga/xa+ZhDa+FUQSvYayYHLcF02MrPiVg7g2IGaV4EPtWlc2GW2G7PIQFhQzLeQiu9yaBOZ2d2dnezvpbXRniUCHkgz8CGfpbiT6QfnZu71Z6maxyHyGSLpnj2WcW8N7LXHF6Ywrp8Ec+Rd4umcuuSLlOShAZl7ESUDl32C+4Z2UdOTvqcmAlSDAmD8mh8CNjfpEgO6XipY2c8LdBMECBVIpkqEKKZ7nfIrhDhUmxL993qfho3Cff7QNY9ZQstOvyPhCnu06J7BL6IzWXl/9M8A46ML9AuxH0CsBvf5/Kff1jZd8GdFftDJXPSpdG71RDNiz6Fn90JteQa66pM3J1dljnaBBqY3/UXFcgJwe/D+Fq+62oD1C6UhcyGRcqHWIuO+geOlBoCPG3OoPYziyI9bNQfkonEByGQ9OQfIPQqaXx6A3XonpIUV2VUfcK7zak73u5+63l9kbvhKT5PfI6Q1mN5d6rMaVK9v29My+f0sWYt+9v+ar8y9sLfZz3e34JgHypb/k5e3pDUHpmnG8JY9NuKqBu27eEBJ/dvxzMd0/4kD6deeRlSZjIUxIhvGzl0k01EEA6j9jf2pNU6QZuxX3L+PLymepK7jkUfikgn/gQZ5KBCPbJob4BfNNVA8AkS8arw+wRnBNStXrtgKHlLJxhonMc2n0hhHqwxr3pgWx4dNu/pTCvYopLcxb7NZ7s2G5oSZ52Ez2c6IyIijBB0+CJ2iNRjs+ZHXDSnLdnuUnubAzN++SMuyWFZ4/XynYQTqglmO7zowsr2pSIabUrY6LBTPz4Qs73WrFeh7zCJhBjEQ52MpDhXbqg/Fs2wZqItfadi7bG4YeOognY52CXjvQkP5WOACBdZgAxP9nH1Xh62pv+0vPpz5D42Wx6zpxfLsiJcnjOJvLmi+bpuTxuNMxiGe/k9j2HThMYKvmlJPk5ODUoyemPhP0v61MI581sm36WM5Pc5ZQt/U/IaZPudk5pUE5Wqhp3lxRbbik15AxZ1OkeeqiVUTpWco7aICvDc3BdB9DvSNcbHxqyhoVlnvFVspzixEBZr+zDcor3Vf5ymR80cGb2eOmwgKYkjPQtQNyiGjSfr6TvnNnVSaJ3DaW7+St5Owwn7AkbyfmzpQh+04EmfwShCbl0aLEd8rQCme0QgT0fTaDSQB7CsFLNf632JpE+49canfpxNB2283vco5RjvLbQqbHDuJnYnkfG168PlN8ooBB+2p3DeYFWYG9ff0XPft/S9+LzLS/i/J36b1/S92R/+f7rz1++fP/yp8+fX1/evtFT4reff5XgP/85LfvkTs+u0y3vBnQQppcOvhMoxb4lhvie+7f8iwHklJ90p2zwp6AE+ekbfX8X+fwlPf//OX9bf5KTU/al++KfpCwnGz1Vf3vJ/m9f/kyx2ZBOYJJPGpTC9+/spzMFrCucnlCOHJRhk3uGRS3JkhSkpn9wy6qkpuuI4Jm6t+XJ6m2TrPSNZOIbTsTs7I4Jr6wWkE1hyLV7VVJsFaWQuGeVQA06OGLf7FgzgqVX8KYC07GGsxZFVMostKzEzLemZmwhNG7NEHPeZFmuogE3h2IeTZ+IIeM43wcYwSCfpvxglOl2oLpB5xXywN+kOGlQeWX8CRxcfJlLyiVvePbkHpKDSiTd0+8A7DfopftukxL5jZ1kwGPIpezHYLPK4j12frXWThyXD4G2N5jWG6TolPpUrXcgeIgaTyx7sNCsOKEXdKt1WVzyU+bt0AkduaW//PT508vnzz//y8//9//b//Wv/9V/+vv/zW9+/vlnelPQ29f/8OXLl88//c+fP6eL7bT9/OkzbV8+f+FnrjTIT6bzU+hvv0y5v/wHIkPPvinoLV3DoXSkTk+/0xP35PP29uWf0htyvr6m2C//cybyOb0inJ6rp8vyKYBu6fk4ZS267/85PYP+8s/Eg7DSU/Xv6d1K2eVzehcTccH7fFKJpE+IOEcgLxK+p6rS9SMafvv5W6KY9mGyfP7lTz9lfhRG4wxLfnzbCPF4UkAPEqvEi29Q8/Ap3LkDmKAgCTGPwYjkNpViAvfp+uzAO+pAOspWJwA192/yKLmbcCWsnIXs+qGkjrz9iMSKrqb8XbLKKzp976KNHAgkZykXjJTXx2nebU+BhENRU99tzOmkoJGlVcqapH4PPXoooyr5S66Unhc8xq07F3Fqg2LjQENPcb6uV6bWmHgCx/QxDJFeRXw6bE9dDxEORonz6vRssrml/bhTY+MVHCZ82u3UrZM3+5Dv7r5L6dd26das13y1Pj3p/vxCz/P/5n/9f/yP/5f/7//n/00IX799+/L5U/pcAF13pyfLeafNZwFf0pPsly9FnzBJTtjpFIBWFz11pufd3+mzDS/ppdoUS8/3X16+pffZJ6f8VBxM3ggr+6TTkBS1McwICTnl/UIfkEgnAumWfBKfZEFe0hDkl8/pG5vyqUg6l8kV5ZB8fgNP5E3+34kdnSh8y7Sp9C+vrz99+j/9H/6P/9v/3X/z9vZz5pkLzinTZuteZgfmSYu2CGtS5pt+xWYz5FmjtKgmKXdpc5F38VUU95T4Wu7giH2zY80Qll7jVxp1LFrDWYsiJpgIua3ojQZyHuOPoRbqWhXyWCflThYxj5tV9b8TpVUZh2qnm7t4q0irPwPOFYY70NW57tI46LxCHvhL6COyyivBTuCQ8U/rvyQXkdMCck4AIhCTPsHFGnSbTL7u3uxp8qAD0zq0HWkhP1pz7AqelmcHHrYDcic2SeZ90NoRzahi6Abm3Zc2yUhPgWmbnhrjqfrXb/R8/e9+9V//L/+/v3z99vUX6So8PSlPzoVIuoSOCNpmCHoi/j09vU9w6Wl5vnCenl7nUwLSJ/+cDk6JXM5K8enyfR7nJ/lJyowQgcAs5wv2dN2eAgEIVALMyJQqPaX/SmiJcuKTThaynDWJX8qVtEmfnGibiNALBnSS8uX79++ff/nLv/ryhV4BSE/QyZDomDe2QkCBpvdu4DhSJZn+J2K5Jdjuvk/pRh1IE4HpKNsbJA4vmRtwuVGKtNs/bz9UB8ZTvnoCsHb2g119zCpfU4dzcL4iR2/JWcpWCn1lnaIa8svX/hvCGocS6Q402cFcvheQziYpSqNVNbrntbpqxFr6CnlpEJkLHxht0e3qRjWd7/pI5Q7r9m3iPN7Fkam1HOlVxKdCzleh4q+5WZVK/TSHitCJAz3brNkntpsvP8vtWo4oC2pZsvS2+vSUmLh8/vbt5+/fvr99e/vFL3757Z+/0ZNienZMxnSKQCnzs/v01DnLpEmR+ckrvSCQlLmefAU+P9t+oRf66Kn2l/yE+0vOmy/Vb2+CT8/F0+X8jJC3+cNd9FweT81TFmAiffLEW4pS5kIqpc1P6JNrjqV34uewxI6u7GdS5LXXkfzpSX8uO50AZD50R69QfP5M/nQCkOFTFvUuoEwqwaVbKiDnyvfYUD6o0zAXQKzRGuFVxM01NwdxVXxxu/u9uE4s97ITeIljEU/VCbD3gBg86glK+woRymVRHuukHAIU/Q/595yCa1Zzw56x6cUa6yXZdXIFAqHp58GFJPH3rB9X0vOCWq0+WP6dDomVkT4lRa82y0+gpQB6SLBv+0Tuku0dtkTAIj4yYbMEpQlyBHAIQlCEE4HSBG6soVoi5dyYVS/dOTTjk3JOvl4l5+reC89zqz4PjVcEdlkeUgYpdxMipGvylZxLp8gamlR6Ik/Pf/Gsnp5b54vd6RWA9B4aencNveH/F798pTfHkCU90c5k07N0uqi/PaPNT8WTCQK9nyY9g02Y6ckuReS77JBPLdJz9PSkOv1lvGzK4axJUdmaYNONhikjYcKUvpsUPpSFleRIzMlEmpfsX+ILSYxxwpCJpU8xJLap4nSGk+JTQ1JOusvnNCllSpMrTiRYyG7ZmXzyX4rbRM6dhAyZBNZuYeIum2hDfLKn4yqinmK8Aw/cUay5eCkP63nHQmh6dXbSaOXDdu8jE2umoRmmyp1XAPiMMLYPW+crur8dGsqJfGJpt8juQpSoEcAGRF5ZJyjwacg3ITJjV8Z19E+z5/08F11QoZw4OxRREJ1r/Kn2zLnbhAZJ4gRWBVoI4ApJx5KG/OSVHs7F89IBqlD3ecR7ImGUmLV7dHSk890cw0K6UX2lv37yzMb5W56Wvk/J1lbzjisU+X3bdoS2UPP0Hr91tPv9MBIiPT2dO/zI6FYuVF6+/So9kX39CznQc+mUgp7ifv5E1/vp2f3Xn7/RZ3vpw7HpWW+6Gv76/dvPn77Qm+/pfUGkQQcSFoWk+HQjS3rumyLof1aSSB8STtfOUUR+s01SprBcFLJu3ik0O+bzEBplQNIlQLJl8umTvElOvkmgW6aTqdIgMcjp0wkM2emZfXHCtf4MRZtMPUflU5scll4EIPjvr/T2JzoXoHpSKgLJbzxKQWlMCtSZgDOF7AVKSZeJpm0WeZvGzi0jlZpKBkA5UQdM1dqO44jHi7P2skFy/4gxCM7mxT03At366BnTjxRtDK0TUWNnXoRVx05ozsIxUuYln2zbWp75bQSOTfFijaWhfZMrkJOSu/yMgeytjdS3SPzNw++hsJ48jwK5wxVWGIzudfh0gPqqTh/6jgOt+P601jO/XNsqq3G1a1WDym1qcBJMypkfBTbB51Ct9Z6rXMqNHVmwbcg7UQ2IHAJKarpy47aWq4tMyqYQy62rPxLbAxxOzh40bELTtD1SSEMQ4XtrMcL/1pzeZb6JRVXXtxDohZTFRj4kpme0+XkqPcF9pa/8/PLyE13z//L67es/k+HLK70lnh5X3j7/9PkrfVkOOaVn+Pk9M6TNX56zPdSnZ9wpLT1Bzk+ZaZDfMrS5UR6Ky8HbE1vISE+hmXLiBqD0PDtLKAU0ScaT+5SLbskJz8+LdyaX6spqOi3ILvTaAYUmXkSCbNtpDWElkU5P0keGv7x9o68A+vLT60/fPn1NmV4+09ueqBn0UeXEPOVK5xkJKrEkCWSTZbuxFtbstZtyYHG17pMTkiUPhGTWyGmFPfUP1AFeDw/E6eZU8t4xl5X6FtpH5lCf3u+mA/SeoPz9yvU3KG/0m3MaHCjlIbYu0zxf6Z1FJbCsb66y15CdUXNGRTjQHL+C20lWVNhJaIsdBkIxevd8fZqduN74MSt5NnPBcMeEphDmJlEbHzaRnm7dKiSOuSoYyBZ0rNbIXEDCdQjtqfP4awYF6iipaVajNK3IeY/Y8p474yeiWQtioWDjGmE1d7jy7YKrWXhTmire+n4Y65UB6wrK9q7KPxM4DgxbFvpef3qKyt/3n594pyfMr+RJl7l/Tc9oP7/+Jb/B/dNPP/3il7/85devX396pbf9vP2XT//lX/7lPxNO+urPz/QiwPeXb7+mZ8tvtFbT++Fz89MKSU+O6cJ8wqbL8z//XXonzusf0qV6epaennZ/TXq6UI9L8Nk/+ZAllUlR6bUF0rx9/bfElWLpWzjzB3BhJRzqfJbTe3KSTLj5oE1R9E79r/nHB/DMnqzpij7lJWTCSVnIO32q5HP+LiZa2PTln/Ten6THE3o61fnFL37x00+v5P397a+/fvsvKZKa9PlLev0jM/xGHyxO50CUMZ8JEYetC+l0IzUBz19yV4QiG5EmaZNTcsU8Zg3eCytA6OtW6bcRKD1+SSC1CSg5lBF+k5TV+gQcNYosxLM8HnV8sqelBwy2/uqVnpZcIfQef63AXZ9r2Ye1VOHXJhr5VjzuRx7RgAP4SN8kkYi/fOzo+LsdkLkG8gEc2UkpOxlprfuPa07sQZPMS70lJp3bBatRrqXFebRY+XPnW3PxHT6dpqyp6IhT9dh6/FLv++d0dJzFW4AqHDb3hHScz0fGnvFEnc9ogUHbrZrrEJDD4Un0ZEgzrLEPjWSWQ0DPYNGB6+ZLJDkq8pI7CnRu/DtYkYc65x95Si/zCkrPMfu5apD01pd8/Zw+5Pr1n79+//rtb/728+vrL768fvn689dPv0zHcbry/y/ffqY3An37/ukbfQCAkOnp/JfX9KyYnsWnd8mQDx2uc8J0bZ0+3Uts8ruIPv2U9K/0ywD0SJYv0qf47el7elq/+VMU/WoYQaXzhPR0Osm/SPJrRk6fG6bI9IQ+PddPz4LTaQax257WZzLpIYBCE2bOlZzTX25H0qYR8aL3L1GO15/yKwdUUfogctq+faOTnr/+q7/6+vXtb/7mr8n1OxH89NO3r1//p//pf/qP/+E/0EnRv/rbv/lX/+pvf/lXdDqQf6aAupc6T5kTqWoSsjJpKKlxg4XtiM9DhtqM6ewp4Se9cEu4NGQEI89T7XcAHcXW97ytFVP7eLymu9A0GGvZX7Xwmc70DLh/Bw4tWMw7HVB/99/9Y3Ng6yyYXZWkfXSkCREUXSLOg+W5ZpCDhmoCfT78/jbg+M6MzFGsOSLo1xOGaMOqCYFrkfjMnBDIwcLhWMlEXquQsvSpZQ2TEko+tf9gZLGVYTolW+OvIXDIOUK+DsHXTpy2n5PufaFgIZqcYcbMr3VuWzXbnZkIBvbq5Wp05Jsun9M18F/+4q/+h//h//w//r/+n3/9139FT6zpae3PP39NT/fT8+n0jp/vn75/+/r99afX9Ctgby//zX/zv//rv/pbOivIvvRM+Wt+e31+Qk/7ZCZBmxRNG0qbn5KXPRY0SJ+elOcn37TNXqmGhiSBkSY/3c84tPulVxwQkG0Uk+9T1px7R0gRyZ9OFbZbOkXIN0qdcIqemKafMUufUvj6pz/+mV4BICbUBPodgK/5/Ifivrz88m/+5l/99b/667/913/zt//Vv/m7f/u3v/l7+oFkOl+hf8Sw5AXolqck2DMVDdrEo9yKfZSlHWOXGpc0dI0d/7upYkddl551TdQNus5oVWRNCT9+BSkNjvmT3bDYBskkt8mMDjK1iHYKq1Gd/cXBUiYLlh0P4jNOUDih88FMtdst85Zcgdbq6clBtMGqcD8EXFe4jVIowrvmc5SC3zmAhIJWEHL3phvVdSNl3BMIs/5W3rvrqZCme1eWBuwm4d17cDsCutu3y/2YmcarjQ8b08smPztOZTOE0YMuMuaKtyW0KID5Pb2rh7725k9/+MN//I//8V/+Cz2/T++fyc70nJge7/OT7/ylOHQO8PmNfrXr0z//p3/+2//qv6Yn1t+//5yeGP9EV+7zdX06DAEeb87BCQCdYuSr+rgSj2M8PflP/8hbnC+kwfY8uJBE5eLQTiGZ+OaJFzES2xRB/5l8ljc2JBeXwi+N6byhnA/kXxOgrzj6/jOd53z5iT4EQWdHr/SqBL0l6Bu9K+nnzy/0vqCffvolvTry+evXf/6nf/r5X/75f/03/+Zf/81/9VfpFCnVhvcYZcxUFGnEDRSELhWw2eme4oWtxGWf4pjui1wcnvdtB1IvsRhaiz2mALqV2bD9npYzO4Cud1c0TMvJ/Jk8CL7M6hkY7QAd5uiXgOmdkTSR9vuEFFpaSt3lpDwvUNB7qvxlt5AzAqhfc4hcY9BRy1e1qS75nsVImXSmSPMUfxeaxGfmTnOsRSAzSllxdrCTb/r+k97DtcLZFNtVnL/kYeD9eRYO1U6l3eGWOWOFyPc1bkwOXxPClQOgufNyh9LHKTurTc+S1gyA+fkgR7JgRGLRspcQ0mpNb4zZroXjjTT0PDW9U5+eT9Oz3q//8jNZX19f6eltvviyXVJPl7fz83Ra9Pkd9OkNNJ++0osDX+kZ63f6sOy3/5pc317/iZ9Jf/r6rxPq6z8RzfSsON3y83zI3/5t0r7+Ux7tF/KJTXEm910uT/dxapBKBAydUWQxnz/g+PDt71KiL/9E+PSsPvcvPbtP/vQ/haZb/oRDHmSg1JfsnUz5gwPpFY/kmF40oPcJ0ecASKAn/b/45S/odCidG3z+/PWf//VPP718+uW3//Sff6YXBJCLtvRjCaVLKdOeFdkzbsJOtzQfuOVwEtmJBMQKBMQiiCMLwru5r/Zu67hh6VGle/zcOlN+Ub5quNOk3PBy/dLx65iqijr2VsWPX63BGLM/r4jK0e1G5ZkHFVu/zzoYmsmMFozUi2We1NFZkxCuLJ8RDV5RcXFMY+6k/3s1VedNoPMNt8wrcuEQtpWjP6u2Hcd6M5106T8+A7DSEIo+dIT04xO3+nYoWYECCFLzthif9zfugL8EQKZa4rfhp9febfI+s3gdqPb/yMrxwMoUl3vPl2zSTcoclpT0TJSeR6enuelKdXrXT3rKmZ6f0pbUZKJ3sdDnfcmXiqEBmdJz9rRN74shgd4CRN44CfhMV2foHfOkyk+1EUV4gkD6hGw+hyAEUCjG7JUS0K3aZresztRISnm3sPwcOZ0WgFRyk5Y8JEUqTOCQUxqlmCyVtFtoUScoakH6eDG1AoVnf3o2n5T04Qf6NbBfvNKHon/xV39Fb/9/+cUv/k161eTLf0zv/Pn88v0rvUiSOplYpfiNedakLOmWkmyEoFBbeEh1Zi4VkLWj9vkBNbpb0FC75m5n9PcMjDnW7917epree8Efmf/iZG47LN3RY8zEtf/zWqkPIsDG/swHlMSQDOIcGg4+EVxj+JKvBMur2hwF/AQukNkaFPiaQdAfbpqPPG+egiJn/2oKnSnuC+RApWClz+nRxgOc4wBproaJLr9yr3soNOZcCB+/BBSpV8gWFbkm5OYSVw58IpsVFWEwGysTnINT7fnVypGdl7Lk0Mg5Pj9tbQz94Wj5gQ4xTNez6aO7+Rly+u5O/JRt+hxt/hQt2ej3fdMX/NDz4Px0OPnj6XByIT+8XJAuXL99ou/D/Dl9LoDEL/8LPd/dnvSmTry9fPkP6Vp6CkZn0pP3/FQ4Jf//s/envbIsXX4fVjlU1Z7POXd4xubzdJPNFilaEi2RsgGaokC/FWCAgGHoQ9nv/A1sAgZEwC8EgTAMG6Jhgm1aJpuSusXm1P10P+O9555xTzWlf/+1MqMix8qqXfsM957c52RFRqxYU0Rl/VdkRGTCCL2UcsXDmegCueBvpuBz1vvDkslUm/zwKT5EIRU3eLmDTKq482OB3PyN9hu1ICDwdx2MxqilceAk6VJMoB+WkoVnKM8Z3lcmgjeM6ReT5W//zu/8tb/yV5kNxLZEab5Os/l0lq1Xk5evX9pKYX9MkieZMcF+HiZgkARzwBcC2MkE8oLZKqx0tU/unF8oS/sylUf1rMM4WR7Vdbg/PD3mLA8jhKY59Kj14cFv9CgJffeNvvxRTEXUe6ca4ECr+z5Lqj9Ap6KaH3bQ7i5ut2Mn/11KdQjq5LOlG+/nEW29Q9ZWandq27u7y0fl9ukQI6KQPorEUi3z5Lb/jFJ2HNGg591eZzReep+XxilkVINatfm0kbzuQl0duvwu6Ibc8QSg/U2RrGZu87qtT29Ol0olcVxEGiHx8QCZMZtP6b09ELcLldtNszdHVRjZnkeSdpCK77hS7OfvkNlDXq46SeyaIfqRZY1bS2etETQ2BC+kLCgrVGv3LEFqjWp7LjQbBvhBp4K/SbJeF+zuw0QXXVoVELHAuM2TEZ1pY+t92diHjXocTEtK+aURhcNzQd3GIU/p3q4CpbeH4eNSolGRNiWNrk6rfOehs9JWbsBaKTPWPo0KRhH5tmIQTqnN4YcBOxEJ8rP6Oc+nZNpTES2Jvrq4+NEPfwS+11sCeE1AkROqUPFXv/gFmwHNT04Xy4Uek0zWd3cLJF5dXJWesMhFDjR5yODTHcO5ygy6eMLL2+mSTBVjkkbtgUuXN0DwrSzCavf1YU47zCdB6M7q381G2emWhxB4Q/c59l12g4dY8V2p61/OmrXc1zsCgIokij+8LZ1DPbIJvwdVLfus01hWxM1JG7PhnbkLCl2qTFQxdMivCWtdjI/ShscwHjI231KqNyPEyr0U/QXjLe2YU16xdc9XV72f8fi6N1Mv6WBBpfPIxtw9DhR6zg6OrR44qGZXYdUPt2VRTmXXtrBMRTStsqGMQ5x8qKxOPXot6qQms8fD4/nU7xtxx7Q0GBEkarPFYxVi/nE6ponStrEm180xWngbVdvvjXwujYb9/jmy54YwpWCxZMpKdnJ5m2XTjDurprqIlv1/gN688gosL7Ar7Ay2BK+aTAb5bVK7OGCcpGkUe7O8hKE4cF2CcQfZku4Y10qNolRexJD72atWOaUwu3Qa2ssUqddN1k8kQKsLYCC7rFyPDkh7LFIxKT+dQkytWLVIra9UN4WPHxixkkp605k975ALAPS8DGEqL22Kp0+fnV+e3t+vZvNkvZzak5T8669/8c//4J/ns+nZydnd9RwP3S5/8eLVGwKHv/u3/86Pf/QfrlbLZPpcsRWT0uU/V1tCtyku1F6MQNNetbF/s5EsGd1xhDVyoVw29I9P947925OBVq/rkFjrw2O+0fiTYwxlh7T9stz2HXUiferf6B31GsU1PzTKuDQpekfE4GH9VxQhEch38A90uxLH4jOmBduyej0ctcIOC1qUvTyNUUMH/16EjhG+JjuEUhzJHZa4m9VeFJHcst5gL2rYO1LU+Fq9tvdqtYePt/0+tJAZIBY8yJ3k3QheNJDU61jF6jRQVJEc9gnjPsl9+YcJ+o7Ucn8OGzvSsY/W5oPajZaKFeMPJx7NezzjwylHtsLhAj6yms3G2at9u2wVgxaT8V4HXHJoIL9kXlUV5GQGC9vZZG/eXP8//9E/ZD47q1hvbhcaxl6tNps109zXxeL2dvHmLfvcszU+76Vi98/k5GQ+m52gFdP5FRFoFo6NOwNvs6ssn/tTAcpMtCuAFQFyl6r4h3vM1VKF7gOquHDr5jIl3lWmRRjGpqriOdVVW4LVLIfOSUPIPyVknAUGMpQtjvAk2cB+RQNsfET6n//zP/jX/+ZfLhf88q3ubtfr9QIfMv/n619/lbImQFHFU3lo+kIR06T42c/+9C/8+D+UDvDSXCC4IkNnPzy1vVYuV6ajPqHd2lrWaX9AaSx0GkHeZvDtyZHT+q0ZKOqv9KASJFrTdDMJRcNqh8ojyQL9p0TsgeDtOPNT+qgeOE4P9e+pjSYxTtX3reWO3HVsI5ttxeZ9dEsTOETRTGPsP5DEiUATLA6JmOxbkz7saUNv7Nj2SzvqbdO8u5xt19kpM//NTpJxBFEP9Ap7KNEjYQ//93AYk30sKQ/hM6puy8NjrItp6veNxg+KzYYf+rmPObXT4lZyrN3ZvBdYSUNg4BHlgzq5MuQ6yV7YSL3e0cX4Nchwdnrz9fNf/NN/+k+5tRIDcIBSAfTcYpn3T0XOvOUKsIpQTQZKMza8vLy8JEGQQCa8tUu+KqWbp7wQ4H4tHoY6qV+K7rxnq7YratSuvCoYV85+eMLPPiatfCMyYlLZayMVoHZTjS0nDHUmQQFtXeREhu+rUi9nlYKrrlF5Dih5YRmfvM2A+Twn09nMn3hQyoZHzOi/vrl+9eoV3lmv2SaVtyLf8V605eL25HTGgxPWBhTFteZSZSdMDyJE+rd/8ud//X/+82k+x9tym/zKYfpaKjrZ2D8NExfaT6BXCJZFVcz+aGataGStkdT7alyrJ13rdT007eye+3bt+/jg711bbGdOw0c1HeIKkT57eynmM5w2KcO/m66wt3houMA1YIyQExtIOu4qgWZ8otc/41kMU1rf6PVw1ArDbNpPHnp59jNq+GqU7eM1bMkdxb9Vq8xoy21/y9o5fdxa+fvqto+3h3plexeglmplhjeW7txaA8BH3PH7KsX5JX3U6OM4OFVULWbanQ6MSRygaTfTjzvXPTHKhuC9ndTv0LdjlNpDnTHsOs3fQ0Zn/UfI/ABVegQrR7Lco5+P5Ngiw9+jD9ClQ/DqQ5DWdDTcSWqzWrGDzcXFxf1yIWSst1ZpxSsQPst5p69t56P9/DXjn3k/wOMSN2vyure9xlL0J7UM+pOtUsuAyJ4IUKa6olEtU8LyogsVmsqqalQVmWqWdS0UEaUx9ISSdgShUqfMC1p6hvK9BE4lz/KDfNkiTv5ZhidcabIO9ZguxdJfAD1PAaba+Yhtf5gLhG+oovUC6805E3tu7+5vrq9vbm/JI06Azrwgz37z4uXt3c38CeuYPVwxvXVCrpQ2Q80LlS6lTyqlJCpU6kpQWpkuO3Rl8UzkEs8tKzs3rxI44qSpSgABAABJREFUBw5dEj6evNgXaN24DHY0jA/5j5fo08Qlfku8/3ju+8T54/BAuJ/sqa7Xi74G0Te0+wmAfaG4pULYipa2cfOW4zY1RrXhmfclB5Nbs3hUTIYmxVbDMdr00/js/OExhv7a2xIiwmBI34z/vvwtl20qMGNHheD5beaWME612jEu9DQsArt26bFyikxydvUBtePqe9tf5+EoOTa+N/7u6j8PNDnWqlfuLsfJVKPpc34sZRezofKH8HlI3SGdesviJo3TvRV2FnRxiV3eVa6msXzh23IgW9drzTcXeucmCQ0lWqwKaOUbpC1+9OqudZaybY5m/xsXYGgGExixzT1VoWH7f0Pv4kEmABcikjw6IHjgMp3PK2CtfPgI/kqe68WFW1DBUb8SPytwk6pC6lhtCr3AMLtVEVOrZRXNUF3z34G1ewFdSnmlVNmrpGXLTpJmrol0IsuEVelIVZgRAhAO4So+kEGWXoWGwT6TSmxsSpUejGwuzpn9Q5BAeMVaasbRiR6SVbFe8oJknhXcP003X64TnhMGwF+aYtpZWEIzoYxrJoG64qjoyrSZYgXRaWuEMssrr2iql6Qlq6pi47LKPuCz5759hO9j1/1wWMG6LyZ9v1n+i+kaHnxXHNYklPbpEAgGEvFvUFvPhzdhZxvhw17O+7ZIT98YMPmAorZnxjDptH2g4mPT94kum0N3Eh3bpmn5drwf9rWlT7d6/la1Pk2iZ5X1qlzVv7olL/14+ROAFkWLQSsjcFQChuG6RXnUDFe9X1goL208qvAPnBle+VisRs/+NpSbzRD7xd7p9Afa3FblffkxaPJAi3Z67GMgOG4jdHrU/R3Oba+oVtVNjYwFnkzUEdYHV0ZgGBir4XwwO6+wYp4PUJJlwGxlo2FqwGzKjJcZH4xnQ0PnFvZni3s7TIbEiIB3fikpXEygIFgsFow62wQSQLQArRGbusrQpeVwsmuVWLp5FtWWVmmYyUjVU4Hx0qVlGrlKTAGnqihUyfKVbYczsmwpSS1jKU7iwD+PJcTV2IuUKMhEK0/kkOlFAVxpAbVOvCqYV4HN5/KYfrCMT8GOpJlPslqu7srRBJMkV8ERPmInTpLHf7FHD504qpMKw1FaXctzSmMS6DxhLBp5Oy+9Ul3CzkofDAHaf2iqh1Z4oGKBz2M72334zsQ9tjkfO/+PpCEepmbru+EZxrT7CYA1a8+cRcXNLY4j+wEiQ9UwTh9ndvKhinS1mCxU76T0zEQrzDjKep7J2SMnvxwfpT1kjGFfWUHVzoR5jF87t85J+tI1Bk1HeOG+4w0Ry4c8FanGXdA8bszYkFJS/lVHZqRFmQzW9UXGJV0rpvf8WIk28/E543tUufuBs660itUIFrWl77CxXWFETo3nA3pFjc8IuX0kxqfYw599jHbku8tjx8cVyr6nbgqq5GxQ1efn6CmWF2grekOWBjjJZZ77bHa3WBAIeFQAHTP98+mcMX5BYEfLKQuGGfLn/VZMCNIfXwYugbnEB6n2yUGgBGure82ZsaF/uw+WavNhoYErUmru+LykiEpkwdYgS7tRZb3ad9GZQO/PG/xrKp4C1IaSS1YmQO6Rog6fxdrgt56YkLBaDsYpks8oN6Bvjx8oNmPFECZlFaY+6ckDWSn2Y/psNuf1yVT3gGHN+P+GzZQUKyT59WryyoQrstIfMvSyYBnIP12LlUmn2OdTSSWOstDS5QlW5po4r4vOy52NpyWm+5CYh78foJv3zty+b3R15+lk0Pld7jewxsN/Md0zw9/impQePWs0NTnlhbdxKAm4IuSMSRz4K9+jc5/E4MCGziV9u0X25B/vq9OnQzvfPez57fZq57Q5lDl7arujZffk1quVF4zj5g0Uf6kD2z38EOo0EuN0aFRqX+6rSXttQGmgfloOWAMQevFWtY6sbWE9pXthlOOqdHo8UA2XBjJLxLy9hByXuR3/qVf56K7aNmJCZWOPNe6FnsKPO3uf7tFhqTvOC+J0B+kjZHlbfotb5xF8ti/Lvg7ird1XqjbZljEazVdMiNbQLKAULbihs50/CSCzgVdQXpLYppaqyfC1qgjH2+Fb3sCGK6U1yM3DAY1WI8lqcMrYQFRpJrsTRHB/9nkyFZimxA7TTXR+ZaC9BLfkSPnqXBGQI2juFdy4slaV5WXGVBq6yLLQcXFZv2Jin656xdjBs53NTKrbjddQtT2/cMqq0NmbB+yBAKUVd5lgL1CQD1lE4Tuogvt5dqK3pNneQfd3N5vNUkJoIZg6JzGRBf7HSmKeH+BsFypvm1omKfaJK9N9tjpb3bqJPuW+Fw+EHnMU6d7SR2EVM4mVfCQRsbhP6Yd4wG4efgt5CJsPtK53ReuEeTkuPv16tK49d8Id8VzFPnwNfCQ4/ibE6Yq8+QlN4NAs03XMA0KnLc+2n0xM0MVgdN5hIw2j2XcQVmPncZH7w41qmrajRdrjDTHjKN22tD1ewjMBvBzHpu1aEUtPNhVuEYzKQK4ziqWPqlkRUd27iGfEc1hLkiPF7qWULs+7FfG50q72OWzjjhavcdpe1Hh26bYlHUzV+MSUNprLMLYOm+DRu1e6kfTx6R1DjfkbBz/ZyEfRMTPSm2GLb93rZSewIWoYCCWWBepemZapzgypC9AydKKBeUjYsoe5/gDSdTGd5/Pp6enJCZB+s15rhBoCkwMULdbPAKBp/pI8YVHrc1ovsPlcHVj5jpKFY23g+2myPjEm7B/0turlUAnXGilp0yVZitmGXupcla9jfamc9LWIlcaM15wEz22ajqg3lxoTz15WNc1mo4CwDCngz6FvtHukOm+c/yvlGx/eQCxnmX5KaMkyZcZbOvNnZRTILf4IQxW40Jtl+diwcEI5qptiEjQzID4VtMRCFYH+eChPNycns5Mf/fgHl5dX7BUkP9OvitkkWWw200lyh8Kohe82kxWziaBhs1F/LGMCXBO1t/TytzrYWwJMUyfhufEXSlW9SEbZ4TrWSr3MC+q1VMP6fFnLWfj5sO9szKGdrvE86Bvd9x1sy+rLwdTgrD6ampQePWs0XYxqrWW9qItqVF6HwsN3/h6dO4WJuXHzft4hq11tH/6qHdHX+kCbc5Sz08MR7WAykj5IVxbukLsnt1hih+0HcRvVRnbziinjLzn5fqnEevuNqH07Wn2sQ//YvD3T8nOsU1Xd8hhh6i6tqDo/u9h1ErYzg6f6eASCRl3ogzcbRa1Lp21lf3gZbtFou9oG9HmxTak+0Odbp96DVwf7Hcy7anxAecEzIfFelHPp71eH92J4JPSI1vexIr/n26BZLv49EQbmsJkqWT798z/72asXr3/45RegysV6nae8mnZyc83O/jebdTGbzhhmXqzuVqv125u3NtsnzXPd2SFj4kqWcDWl1EefmfFjeBZ0m64na9YNIJQiBrf5ECS1vXFgYdmwcZVt4yDqKtcW0WrhsQFfk6PIQPojEyagX0IURLHyQGmxEESWChaCaNXtZG2BmTYsgq3VBfZzJRplGEclyJaSJCRDn1YfVcmkinEwKVCEe4mmMElfMTCeXlSWi50XiL228hRrTd9RHTUBJw3c66Am3FCfnBQsxVLqJP1n/+wPmCDEFU9fWDGRJ2dJdpcUU5YLw48fXYUKOZzZYWh6fn529eRqzephC81khSkiY0o9yqTU6j9K7fsJ6iUWYJjH6vmfro7hgdAYo5ruGBIP4OFKoqEfIVFlfPr84DxAk3mP8sbyy4aWoe+FRKNlQ74n/NygafBsXcZatAofkGFqJP+H//3/UVoFRSuGrQwrCLlljKLnBiGvqrrXZyv6GVPbpbfHoau6qOReqzLsU7vKMJajfeX3bAKr/hinWI9OpbvG0eXwen7MZqtmO47sprMmpOhhDbmVOz6Fhsjtb8exnNp2tW0f5rUv/TC3vtKdHm4b0mD1KHoe9B1sKHa8S++JOz0xRmCNSXQRi/CvnXHzJNgQTExa6BncCRI9OT37b/7r//of/aN/dHlxuQKw22uotKZ3De4tlryJloF8zeHXXvVXVxez6QlbANky34lW+2YJiwDYvIYYgKXBjr615U2aTmdT5gLl+RQymFAKJjasq0kvvCQMTdBWkFxA22zgwxNSsrRK6LgqxxaDzoDnpUFx9tb0GgLWYjbRTvwTVtJyuC/Mfr27l3yeGJS5poqKeAJAgWbhU9/+6yPxJwPs6hMOe85Q6DmD6SbtJMAjgEpZEynPqdRMUUp66aiIlUQof7w+eXn99q32ReIfKyVwKMZNsnWx+uXPf75cLDeTpeZo8ViD7ZXwpFrOpEFEWMC6qYKAYHVyevFf/u/+y5OTE21FKv4mwTSUXdHhjhJF7XANy6xGWY2QCy+2GkpuqcnaXjRr7bh+SN0drEcV76W4bN91b4GhuUjS4/QobSIir7uXelHtMuma9N5jd9nSZtjIidULVjdoHnLZq/l4pnva+CCJPbIexDOydF8+cetEbMr+6R3M80O6r0pcPaQ7V07SDXbp2ewpoi/CM8nAvj8Ra9lkdtgTgH5Zj1oSGzIoqGllF3FoxK7C95HnSnPeZWZMEqd3Kz1g8y6hu5kfQOEmH1DxUau4Kx5Dt+HWOkyit+nj6fyoru5i7gZ1lYzN63BkLaspwZ0Hd0BleTC2LOxSVgOjA9bPTs9n8zmTS+y1U3xPNezMi37nxcmzp0+fPHliUYBG8RmhFhxVHMG8JQ338wd0PT09nZ/wcl/BXivWxPXsJOddYIoQkCm0b+oJe4NZuYxVV6lhU1PTaS1Z1qHUKpTnZGWFDvSVF/JVteA18OXhZcn6XNKyledb8CANQOBGZ6/xMv24FA35fHggoRRrdk9FmSrAKIVJqNjLIOURX4mln/ECCTzj7Iio7u7uzGqrYESU4ny9IoBKhGX2qMEigxzcf3Z2up4ya+hUTzvEnEXDWhtsk3/wpr9eTdsJEakRgy3Xy5OEVy9LB/GTXmKrw/Uq054fVCU30DnFiDO1OainRLjYn4+xsdND6m65HJjaV3hp+KA0d3AgGVMlEMcJ966f4/yROrcrxkyOko41eQfijqLzd4oJjRJ3P0+HVgulnhPyH+Ki0d3AdTlIVL+iujEXzGSt3/hGCrH5W2IQ6HfFMYGwnhg9Nys2JB4z7oyrTIY32VZc/Z2yW823FB9GKta7a94/WhY82t6pbOccO6p9OJaPa8edhpYEsWmdtg8wiukP889h/d+f5Ghf+QHloiLXM7Y01vYwHeKZo5GonSMTMe3D097rY2tiKx/OP+IgIUGQy3V4x3gx3ywerwEhBeIFTAW4GU1m5jlbUm7WzzTAnL3QULM32eYzgoAT3lXLK35TzYqxgfx8tWSf+uVk80SrBPJXbgtj3rCELceaRQLMyNGeXk8n6yeT6a3iAosZpB1yuUDw+lK32fSV0oKtXATdGT1izB7cy4i7LCApKO3lEqkVFz7tx00mzw771LQfAeAyC7rkpVCxTSpyLsYSsQBrDhs1t5TVQkXyVaHUjflFyWuuOaSqcdZJVunKSqQgjsJAH4Y3o3ghmIVIxWSxXBJfyeXVEw/QP3WZYWXi9NiAxpBiyT2WMzuL9wMotIC76y7+miykHDWS8WJBNl+yNF0uCE4IBvTrVypVukCeCmpKW6nkjUy+H56gcMQRqMwTiONTvtIRGO4e/4skBY5R9VB84Hc/1B+RQH4suf+Xt+Qlfdu/713jvsEr7fVX+9rVoG/oPMLK2kq2Gn3bllrxjougiRu7g/qg4vhX7CAGXe01yKhDYlf7dvPo8WcHz+76O3JLPn36tPLjvk06NFOcv0PkYHGMdmLCEfYGXVRvBH3Mvp6ODDPw3v0E4Fgm12V/QFeRGz4grbaqhJvFNquZ8j6xd0s55xH8m/I+XR/FA52e37c7hrb3hCsWp4+i6vtmcoBBvVUqD3cRCJnpdg/M5lMT0AVtAa2O/4Q7BRiZWKK9f0CJmsUjHK9d6vkRY4oPB/tUaugaJoLugHsiCG38z+G1xNWuwIJEEcyAESsmCmmHe7sZG3MpghByDJgaTrUC1BFwDocBSs+AEQVmm1IlkTgJojuqJdsIQn0KS8KyLjBfdZma5KZbsSoZR3dRVUNZlc5wLDkZoelhQRMpA9AG9+VVcXecDXR3pV09gi6/NBuhI3IhWRmyYfGuWPmDAqrgVpT1cuKIDbOpVF8UUoyEvzXALiWT0AoFWAW82hAHSBFT010m3jKTz2CKyu3PrDRFvI7rpLR5ZuvOXSmTVQmG2KvvycSFHFRpl367y9303XQVhTusuur4dILgCBKPcQS2++r/GMp84vnBeiD0EzT0dLvDtHMONicWt4uJf1F2UbXL2+o2pbamgW6ZtCKkbVFXqjcu2ZNPI4LvElXL64urakTNi5ob9pUYj3zEaRdSn53fFDz+GhXbzTe+eoMyaOU81aGsXdpPGPryGwwHLmMO4307vh3hiXOc3mX5OFOtUVv6jdekVbXKiHpym1tv/69q6zPi4Nnu/5rmLZqYQTutpqxyR+lQEe/8jLm17W1XH0PTrlUhoVASer3jsZCv8WwOoPdeB86JXVSrWxYIkwo8FryiN0/mkAhsaphZa3CBr6BJALmGyPO3QPbNRu/0tZkmRT5/axacC/ADUO3tXhKiAedJMn0Db+A+14K+8ALaatQfwMq6YNvbPn/LO4LpG9Khgr2ynUt0z99QU6n4dhCutcNPVWYJyBy5uk2Gt42RM9C16VthYISan6knqEuh2JT/yTDRVRb5/EHvYF7Z6OkkCjWcgedKfVlkJGJo0YuJV57zKSmYRKRmhStQnh17mFnEugK8KVlaKyA2GsDXN0gu4mdLWVijMCvTtCzlqEhyzXn+pERvbYNCPkx0s+BVazzCoan9aYtrIptcmjExFpTYYTaVJ+0URKd4XpWZpNjsqqD9qTZUcAUnPu3Dz/YtU27rkIUidHK7KmnidFUt/rZWeT2fe95herjU1m7x3UfTUffwaNzXjXP+bhMcGr4Yb9fO+0+Dc59dY/J3yupkUioQ+z9Od9bpzxyjwxiafgkHlUTte1D9Y1fq06cvP5Lv/dPPUXaZLLGHXbVxVJs+5Ozsh61W21kj8N6V8K/Zll/3E4BdXCjvugeNqPbuSTqbD+23PjiKTp1ijsJ5kMmRrRiUNVT4nsyvqeSNGjrmUVxz/I5S9bygZ82GfS7cwA/B8/toPYa2smkPH/W0dokzEbolUJsGzoZ6DdCC8Xlhl7aY0ZwV0DxAH1gJyOS1UowfM1tSQ/WsJ7XhZIAnBGuAPKXG3RCejeurkg6BPkkzYMo906qSL+kUrdcrFgwIFIKUHStbBavtGpKsiuBjegdDVEWgF2irD2MposCKTNSDQLpwiFz26sPEuQxlWzVORhN4mHO8psosJRaO/0vyypdOIPHINQtJwLCsSGVdmVzT1qSWhaa92VqR+bwhm8eDu2UDgYA7AIsc7uu9aXC0MEFO8AMOTLIyq8WdTM3fQq90sl6wfpssnvQwEYgEf7qGzE7oug0kynyKTEm1pejsQontYfnby56UVxRtB4uOOpU7yqK4EulxMjvYPk5WrF2Q0JkZSj3RNiW2bAyHBsNPl588cLAHvO/FvS5OH8w2rnh0hjHzUemggazlPQBf6GZS7XMccRiOkJwLNUm426KqteQwnxqpLjoj/mEJLR4ho0+54IOtxHjcOtTvTMTjHCEdNBwfC7rE1WdbHRri+rRvkI25bGvVznE+ffmxlLavgvmQxRw6WzNmdUA65omsWltG/RGV4qK41kihsVGqEvXkA7g1OITGjZVs0OhyxNHk0FflAaNNY+zto2mNZ2j+hg7AVnWIpvA9+92aDpv6xv5XX4h4Oy7LhdX2vdiz8g0n1pg6Aayqg5QhQKPnZVNfff3i86d/6cmTp8vJrwkHgIlaU5olZyfnbNfPMDMvoFWAQHTADH6bhgI/LfMVBzCnLNJEHR4W2KaWgp8lcGR7H036N3gssQQQVgVcqgoT37FHC2q5Mhiq4ujeKj7Sv0TUJM0QcbSkfYqzDj+bAK9UZsCi1MCohNU9oek/W47KtEjCSlUEwPZGMzFkmDKOip2ICn7pasKBBEUSiXUSUzBUX0Fuy2G/TuVDpKoAc56gzG2TTnkRJ8up8AXPb9h3FRqYcC2uWoQN9pfPcSxxFCW+TkCcJuunsE1nL0W6yYi1yGTi1Sz94nz2w7vsNzw6KFgWzKqPDasOsvXyjBcMJ9PnMoM6MtPFwEaHTFEfI98PaWAml3QldfsNAIEeCi/Vr0bgo+odh15iAJV/R5zYJUTnjm9WB6dWlt/H+u4GffktNnFG+B30TNcxJhhIB/u3Lhmg7i/qu/+UNQ6yq09an6xRLRL9jsS/KW1Zw9z6dIj5tGmGecZ12+mH1G1z25HT1159+TvYjSoOXbH9rL5dP8Y57dKH5LRbbQy3vifkzTsSXzP7ftqbT6q3rowR8B5pvGEOukGYrdt7uV++R1M+iT6yB7w/B6YHdZJQe5uovibRL7V9cZyiIXRbbZ+U9+p9avTSHkWfXu6PVVB3QNlyDzOlQodtlQXpDGyBNTlK8CZESi5ntpP/x//4H/78Z/+3Lz//fjH7OtmwvhRMyaj/Kp+dXl/fnJ9fajtJ3tCb82qqteF+GGm4WXv4CDQyv0dLfEHLLksAW1PrtdyWYuFYG53mUguBi42WG3PovV+mhKo56teNqoShfs/yM91RmkNHuf/XheBsmauS8rD61YV9qoqOUML4uDMqc9FcCsgayzF9XGh5rQ8OAXMncWP1IMKM2T6mcC2hkomlRFUrHV4WS7z+vOVoHCNxOgnCaRrpV6WyogRxhebJhF2VTGXQPIeWXpiDEZcTrokKOv4UlKVsw/r7/+T3/4f/4Y/S+SsacTqb5OnJfJZenD398vO/dH52zmaixIHSxcRV3uKq93Arwrm/ipM4H6j8sp+8VACyQEzdwGSoYq+uDyxwXcYwce1ixYdr9VkznsMw/0+lnzwQPNDoVI3LQBYndn9ZY+qudON73EXSlzdGwb66XfluTPllzifVCFkgRd64wwn7yd9pvDikcrDYifxyW6E9nt2e2b+lZlNsRiur+Y4hXfozptuV9tHrw6K9XbxVHvu/bWPMoV06bNf42Bcd8ExjfCgW/cB03JaePqAhOnVo8wleioV21h2ZGb46D2c4ikM88jRCxbj/jCDfg6R86+pXOMAVL6JvwShTYmHbsX+qBp8yXZzx2sDMQZ1gbQmUBdIBo0BJho2pBUxP7perr775V9+8/lOjA3nyma4YGS4mv/d7v/vX/v2/tlwtECFyUQjQC2BuErb8AcTDz7BpRSHpNrjPwwQ9EgCQLjbFTEGAjZXb/HXALWPbqEG0IX+UQNlgn2kvBIs8/m+xemSlFClNkl4iM/WUNAM8MzhMlyKww+pWEh15k49EZ1TR6NMwtxTZljobhChXUm0c3yqbykZcajSr4oJKu8mspLFmUGU1wYQo6+TEHqRIBXMwa7BXxd3iTuJMuJ8ktkhOT69O5loiLP+ritpVdEVxe3u/WMi3ZBDITYgRNtmf/fJ/XNwv9FiHJQEpbxIoitX5clX8p//Ln//dv/Ofr5esyvBBd/Hwo/x0tmWef8jZkhkfHc/SvdjYlKVepWQc1w6kWg6hw2l6KKNvjVccd47HUOO01+6/S/RooWrh3tjQgCp195Tl4+8tfRwaghqXHfz77WrU7b1s+8pIY1l7t0gPT9ehzS2W1adnjabFv82zj087/7C6NX3aTPty+tqrL7+PTyu/0SEblyV5XUpnJxxvl4voFtRSL8qgRqfkiCRKlneMKMeTzTuSs2QtE88hmQLEQc7wUVWpqLZa7axaVTnGp/vjGJwei0do43fql8eyRnwfbsjDOQzY58zd7aT3+8YM8B0scqFBtMsdrNFdGNR2Vk4UulB3na7cgxXoYvYu8w6wta1exMT8GJyphMBxfDhiF0y0nm0AGGgrKlb9ahnA7PTklH3iHf3rXV1AxMWSbWg294v71Xppu0lqYr0BX5NhONul6NoAp4NU2zjIacgAijIInQE8NSTNBS8AdhRcglRyS2XRsEopCiFtJzI9P+QAbUVopVZW1vNcFRkrlaMxML0sV0nFzNP+XadYvKuzPqniIUPA98p1tnxUzxDE2K0WD2Oi8EgEugjuEpnqVIoYb4nA50zrsR2Vyln7E+3XSXpDjAUTWFglfdglVQmweECgnHJKlWxEHv7lBW2r1coiMGILVgMn6YyXOax5GRuuRyNe9QCjdHJ5c3d/fn5q822sOs1bmowBZpach0xZpozyqEyorvlsUNRL/EraRfkdyQ6+JVVgHxId1T+srLatwTyKRtrhlB+WYZ+0+VZ4YGTXanfjMdaHrj6GuIdmpII9tdvZrpN98XifmMpHfgnbrIZzavFiKxIdM8uqzd+VP6wx2tw8pz2ePTxiHUpRxtOulZ+DFC6H9fRRk95ZgOYx20sksNwvEfu/bWPMq10abIzJDkjHOhxQfWQV/4r4U4v8G6tUj+BH8nEy59Zuu7aX9mLbJG5/I4wiyPX+E87N6vXruFa95PCrY7Vdm0+V454+XEOracCQVHBB4Ge+kwzHi8o3iY7+mZZTQn8IhMC1zpQtYpjAw0Y0wElwJOQCkIB2voi8j5b9KKHT/H/+Nk81qVyhAujztZOT1K6UBkKBlsyJsSUxLjZn0Fnagi5FZ0leKpwzP/5+svkS2Jmk154PA4FaMWqoX1pX5utK5sDP1ZXKdihTCV1LXchsmpClq3wvNDn6GYCFHU5vdcWjzLWEqbPNsZRzQZzqB+hsFcnj05h4YVW1Uo8iRQD6SHm6QuTFLkzuHYuybNGuW6dcUbq9DJCX4hSr6TGOJv+IrQUS2oFVQQFNxBeNNzarJE2Z8qowxjSysCGhjJ2a7td6tsNNQ8V0BHscIRFOitzSDn2EY1saZ4V0PRHVRN/oqk7WvKrThmohUdGPH4+s/eI84D5ZSdbnvvfGvX5f3NaWxZLr3uHcOKo7zDZ7D/9sK9VTPb5qy6pXG7xq8+z5XXAuY2TVaNr8B9UZU7ivJ2v6jBCwL/8+ljU+/V5td54+ho18t6smpUHxwEvteKbHzCPZNOf6h2r+zQlsuCTNjVyJcU8AAqttovPruC1+3JTpLxEh8bjyeri7JykMiUDo3n6/6gVlvguJRn9st8h4J3wgreYWNezCiti04dLxJr8/ytiaw7RwjNl1LwjeqRISZhBR47y6u5ZAnAufoM/bvsCJmswjAt1eNHFHb+0CYtrdJsBc1WV2EDozlu+ot2SvmtAyBm3rhQGgwv1UFyhlVFrced/YOmFHUc1uV8CAVJhQzawRA6WVQ4GeCyipK9e7igqUo/u4GECj/5pdRPAi1UtuXhnGYmWsja8nofFMd6M4SE7tUNUqw0plb5nhBdW1f1Lm+kAjfSpJZRURVdVNbVklww3xq65qWV0N/EOs0qqyhW3WTIGNE4vMs7T3EQroRAYwHn+ojeCsTV3tGY60Uj0kaekwREzQ0lQiqa7arkaQgXhyt2ooGZxSKcenU/SURNmq3sPCGDufiHEj2Vu3QfchXkZu6PThHjo7K867/LUHz0+knzzwYXgg/qKM0Gjk18C/Kn4DYUNl4gbubB1RWmfMlJT7GORf76lcOxJt54ywMZCEL7wnXJswcx2yvlmJgcMRE0GZwDPEhe7nkB8nGDUJFQN9IPAxlUAQ8tuUoeidJdo6xJ4fo0ab/rD2cve6l+I+3PZbW6u+78uYnr3j6U1bWD1HIqz/j9EzeEbEoEkAQvTd0WWded+Vt5qXxr7qo+/Lb7d+H+WI/A4H9I5kdLNLbEWB7SAkrLglImnO8Twr0AkESY7wpl8pR9ATapB+Mplqcjg4kYW5zNUBfcvlwotatMvYsDRW3SJ/LTQpzGgcjIqUwVGDsKKEp4NP3h9som3JAZWY6qJpQNpb9GSzznPeGCDySmkJEXtfamwiJFUs7ZAGklheVWgSPRUtGOq2tGwUoW7yXluWe0QhFsr3Q/n807WZoE9ZZvjZGZDvuZ5v+pT2e47pY9xVD/XFsGTvTLlyRbCOcs36KT02KeZylqRW6Nx8Lm2Z5LO6FPPstQ3PO3YuOW9NEEc8KGSPXMb+GfInwYJg3rsM4ySXUPMiHEyKjNVcIPYjYkWxKUOAZnGCytULZInUctZcuVuC80vT3UwRh1Qt0c6Octp9HqWkMZGJjkpkYB7VdYqHfKOdQ8c5xgCtO08HfU9W+27fQ1hmD9N7qT/pDXdC/IGPBo5H8c+AvPoavBph7NVagV1E9/Z24dFyWjqMv6vHnhxfq6Z5S3pcGvMv8yP68RJrfNpejXjG0j3tUnhO5V+8NkHIqUkJuUdJ6E0yZaceY3WvJo0vRvVVsXuL7wLUoDiK9p+YfPLA43ug6sz7SQq/np4I3f8wbvvJrgOEoMkYJp3qtTl0ko3h/6HQ7G1AaEBZEDvEbqAaI7fRXoE+s5Fr+7OTgVqAYZbmNnkH1MUYsYp4FmB1DVUKUmq9LzwgVsAgeErAYGDagCV0zl54kZeATWeGNSHQlBITDguWn0KoTYDgCC9NU2F8WsUGOcXDAGwZcnBtbKllcBkqyylleanZJ82N1ouMDxlcqUYUW5TlhmjLsMAwrqhCXZlSXYiFPYquMlQryNLmP6L22pUqoXZVp/p019sCX6slRuYSFUDkdPKSveFXGTafxxIqlJmmADv2sHKDDIFzVXDW0sb+A983BFo42zwsn2f5LEkXlKoReSsAZ7Yb1UvfCLhUz7wsfsR75rfyCQ9yTT13o87SRJnNg0yOdn4H3SBRENGsqOtOyV2E35E8d/p3xNhPZr4bD3in+lC+akfp4jET3TA7dgGqfFuPmcpbFTVqexhXxEf87InMhmMgtyueWRjGBo6oWpsVboldGgjiaMwJBu/1zScwgTgkOjmHzHeciK1z0bHnxyjToMdFfe013O5jZHXSqFGsp/l7GDzW76TszHRt46bfoWe9V8veiG/jMipRMvZMnG6Qhcu+pxPtVgtV9kr08qnbOI4nboi9qEp9/G1MFCDaZFzb5cBRqTl3/blxe274sqokeUz0YXRYI/CMbgvy2ii9YHrKrjBaccoKAD60/6TBUOoA0mkJA/TgQLiVaUPzQqACoPy3IlA9TDnbJYUa/Jc4Xctcw/zpbJojCVQKst+wmT3k9loxzprI7g8b1hdwT7K36jFC3dZXgstWF+QX2SvVhAf8dZYEk6RAYrK+VN30lYbyfUJMei+SYmaWOMwVg8n6XHXTt2IGH2PEWXOWyE8W0kA793MhNYqNSU9fh0cKygcbb87FAT7S+E6cebOvWFBT4F11MU98NDNKP0QU84Eum3N9ZDe6TnlGamCfqImxf69ZagUTxVTJ+gn+S/CAeJfugR+xGX5Pi2cpL/1NXyrNdkv5NE3u9Y5nHn1rSQDvbsZMLNrk0+n5KWrTBhmbNaWT6WZ9h26b1dVyufY3ANAk1rKmhz13SrY7ULlPzEQZaDRKhAPnc7R6r5fX+rBlWT9vc0ElFbe/Bc7nyOcYA2g88sCjcbffyWWYvrPUdevw105hLYIdd/IWfV9G332stgajr/Jj58cta7J6ta1rErq5Z4+sVedRPv1uZg5cR9oeKLHNPOLZLnQpbuzB3Z7eGLur3a/aOW1NPOdoVscK8bsychcglHBj+vT7QPLD9//gNhtvyL4Ocd1csb663jrvQPnxZr4bygGTQ5t2ajJc2lnFZbmrY4IBHWKykD5ANHU7pXRmBkGfEv0esG9S1JZCkVBbttUqXesIFlRKC7D543rzm5//YrVYAQpX6zVAfD6fXV4+3TD5Z8o0EQsPmKWTllNGcjaQz3k+UKI30KThVUOwEgcmA4t640qgXwjEOyaFEEhKObdcrRsu7m5vCEAWy0We5+fnF/A3GC5626BSk5TKvgJUFSDmPcSSJMhrVlgxo9d6hJukAuU8MDD860CTcqvAWS/MkjGGHY0vwYwcYkECkiofkSkZboFiAE8L/5tFZJBla25NHrxFT9qiBcP0XJFXWitiWQ7Wl/XULGG+KPhDBFhcXpVj9BgEHvwwpwXvSJbP5ELOoHmFSNLMlTIrjAP5apfUHs1YoRxFHCWxiuSMgTkNSvYB5Y0NqZ4JUChxSOBFYJvij//4j+8Wy9lJNp2e5NNiPj0nOuNdAU8uf3oyO2VDoUxNUFkn3Uyd8uT5Ko4PaKxKnLdH2n1LhZBQZflgDyafSD954Jge+K71vYd8gfH7B+euSCH9BHgAMKaDNBzxiOMQPZHZXjEQZjYUHmPjXjSBP4nIq6N4xHW9Qpj1GIpGMRokiuPLMI98sMbhhUH/kSyG9Ym5dY73jJQyTOaj6eP5e6fyczkPVTvplseO/ln16gf2zNgzleTmZ/vpRJPika4rG5vseTKA2cJ5taO6h4z9AkWjnjUvAvtqLLwQ0PwccY45hcBFxgAvODP55a9++X/5+39/OmNzeqFLzRIpipOz+Xw6+73f/Sv39/carBc+tjF1YHbBElHYclcRbOUsgeJoFwxmo5uAtMC65VLiU0ccKpJX6siAPxiXDYXYoRI0DPR/9uzpk6dPUtYbgHxRjzfg2pQVYeXqNlZMnnIp1mLjvKSCqQJAf2aBD6XAXu1wj9VOyNn+QMXfU44x0Ces9K5c7V8kXXU4c/L/opRO3mCUec+5IUWblgqHG5o3iQo7JhOetECDyxiwJ/ygGxByrCfr3xaf9A0cFSHIpTNNateseubkEPOgpWInmDAdh0AF25mOf3339hXv6cpzqWXRx2rFNj7+EAbbpb6M2jyhPJ2+TnI4EAJxyEFmjeIJODAR23IvTM8Vdefz07PzM5YEyCp5YUJ6sbj79Ve/+vOf/4xWtD1FWTlAKxX3m8nf+Tt/6z//W397sphByyHZpkHtzdNwoaA8pAJH+eEXOrf6/7bKlsj4l5cqr74jnmU1/AnPtsrxUq0nePEviJSp5rWPv2f2KTfmPtZXt6FVH9m3P7/VXsMmx36L08O1GqVxB90W7anJtmJXqqbbUTl3SevJM7maXmiHffGalGP6cOyuNkJo58QyzA9J/tX2TtJeKRTT96VrtUyhkqN+zGwXoL6acT51Si90OiMm/WDSW50/GJU+KfJAD2y/DQcx8i/kQBcORZ2dx6U3dGhcDuvl/IOUYeJvT2mXweRVrouSO20WrdNz5tBARomMYcc/z/azI1SK7VJkRT7N37x+CbzLwKncA9mc0yDd9dv77HIKEJ9Op0zIEfhXdCAV9d9Apxg4+lQOh9jy3/95huIG1SqL+PQUZ+VyqalHylPgATDUKLfGuAWDDbtzYU8VDBgrujAMj9GOx62umWyIVLONRG44nhwgswzS3Z1Pwgmz2rVWBekB0GbwXXse2Z44Vh9yzYw3mxGaoQMuMN8WeEV6iiN1pKRQu1ljSVUzQ5XHZkeKY2xzI2XLXvlYNVVFIZj+GSa2QgVOUECmmgQCVkkREfKYqrVeK1hCM3lYh5yIYM2kgtizpE+ZNE8rLThv5ptwC2iybDabkil32QlWr98Up6fEf7MUTRLe8awHMuj49ub2s6dPoMN2U914BjkyR9yVUX6IID56so2kq4y8+AiXLrOrRkz+UaW3bvyo1P6OK+tdMPTLb6U39LWODIsv9+20MZ+I5fjkgxk0RBk/t8Lu2KN3AdpaDgvuv+Fe3BDweJd7xoKmZt99eW8ta1Gp1R4ewx4Q4Io1CB4+ptJgyGUcX46fOz6Gsi1rX/2HpcTcQpxtXbct+aE5gX+bUWdLOVnsW89p95A2Q3JkhfVkDZc6duik68mMPdNDUmbHt61hykcvrcZRmoIOG8uUB/V/e/hVyBOs1WQaQUbdqcBzjPdyCQV4Dej/6uUboCObeIJDwYiOdJl7s2af/xXbfjLdeSlEumFnGKCjZqJX7tzeB12+cCSFTLMRc13pUodS/mmYGRq/pkCj5RQji6nnCLDFrMK4thgYrEmh1dZjCEULhq9RFjCv+MKt0fA5ORsigJWG5yVSw/8+rI4HhKC5T0uUYWtwrb53MCS8Aeu+hNYCBUUDkGeaVI+3XpqmrItleAh6wqQVj0lgb2jdOHD/V13OCqJs8bSiCMIPdEsnepHCJHtl6BhHoqWebWj4X9qocSbFvWQzqV5qLuUUZMlhBCaQr0S2JjBQLk0CY7NHBFDhalYF8Nowsxo1nyhhKwGoCGeulMMqbaTYoVUYZCmTaEurtze8YVhhzWa5sC6qNwmseISiRxlsHLSkIZLl/cr8qaiGcsVO4keTGH/xM1nbRldWfEBncj1Qqf9uUrb+QsTRGgBXsjzXf2c9M2Y+It0lt7uaOSEuat/lyDlICXGN75Dj72OxPp52rWJubZqH5LStfgi3jrrqtPbN6ijbJ8vbazS32K44vY9I0arjN45Wz2mUd172tWBNtx7OfXVd0HCp//6WKnXxl4FRfmwvafq/n/fuw6NbynUzP7i0UtnoLlHm7PgwRWu1jF9pkX5/v+27AB18t2p4tnRZI7e6rLVSldn5Ocyns8p3OTO4KyQe2xsIilvz8eS6IDcnTj+2gd8q/vHtLPqqCzCr5UD5QD0QnjlYYNmm2AMoFxA4TATNQcZNXci5fPWsELtY6xGwDyHTK4yHuNaOCtWTqRriaVkMr1PFdCohvMF41TcKZWa5Q9LNarXgnQCms4N28RFiNqhMFVWzkXzhTslAq5XDa4PF/LRIYR3YIWqM0rwmxRQKG+BArn3az5erSbE9MXAjtO+N2cBZqNHiDOqJDS7iqYiStrgZaUprEx0hWqQY9OcXBSnMvyffVJFsJcw3UqO0i7qswTWNxIY5QobOxZ0IBJANayioqgurTSij+TDGmBw31zmajl7izjdPQqv6JhxW0teuPVO4X9dqe3UKPErYYl7SmgXZp2XZRAIFQSE6yidUkFIyQ0ldc5h1ZdoyPNO13p6Nsiz3iqafMQrVnMgV98xWeUz7PtKuO5JjLd+HIp9kfvLAu/AA/Tz0eeT5F3L4axnTP0zFh3Fqf0WNn2eT1Bqy7Oueb3IUAz3IhuG4Z7g0Fry/Pu48b7/gioER31ga6ZiyHe1pLG3/w2PTNrc2p4OfMLRZjcw5zKKRzCE7wCJarTYeMELYQPTf6AnOLG4L7zB+9lKvUo4ZDLb4HnoanwbnhtARhvaS4AG4YRcivA+3dRvwUi/froJj8TE4UfpAPJmZ83WXPPLkuNJ5NYqytsE84V5HcwJ3GjbXpY2jM5w/vb29hwUoz6bCCK0CNzWaDubTqLjgr9A7YqingWDQpz+vYFAcQRToULk4G240vCpqaQewLEtLqCpGVkcJwUoQLsPNKKaRdxaYauIQOw/RNzT7fJPaxpQa7Re9lGUAvdCul4bOhZgNN4NKNfy/SRio1vQVvjD2yAJEvk7Wn/PmsSR9y9C79r0BQzMwLz011A0H3nlMLc7UYpifTsMGOMqhFlOjGIZfazg8YYPUgtcVY+0q3XwpRdPXCpoSYgzsBTvjIyiF2hk8yxg+L3i64trqEYG5kl03sRcd5DSmYrln0Up18ar7Vc5kGF5LdT2HbXmQpEJqkcVZDakBeWsHijaT/DVp+V19gxxrU11SbXuyGEDN4JuHsnKAHLWLOBMK2I5MKn5K/SR9wVOSbPWUjYb0jMLamQlKTk5bwVmCrKDUjboqdi24MNnluT72X2bi8r5+TvWuY+9vXENuF8+H543Rqn0X6pNrvxS2kLuPYv/fhTH38H5pPSUt9DLGD/Hocg/ffbIHf5X2YdSkdVs8d3zbNbn0Xz+E53Dd4dJ9/a8bRv3wHD/7Vzwu7/vN7ZWrO2ntmUPEzdm3VYhIqmRtrr9ntlWEn91pvTwZvwagklJ9wrptelX4oX0GLz6eyrGIUc31ofno266PN1CjA+xsqZ0EB7vt8TijUsPMg5V8hxXr/ug1ADJDeGjmNaAMVa2WMnzonBWfrDpNV8sFsJFFt6A3aoOkF/f3Cgk0G0jDvZlGoMF3qSaGKAdwKSYagxbu15g0sYHAug7RqFi8DBVarp8EIh0Fr1lbLHkGMA1hlpVUuxxrJymmoE1Av4adGbYnrfFodOUfZYQeQrROFmyXNJkj/CmthIalFWnYiH5bQ7TwgRTVVIcrU8wLjBCUqNDA4CzFIhA0Ln8rbKzcgC7eUXUrtOp2Yc6wfA2kyyfypyIm95AbZ7ZCb2wxkVIpphlQ4oLmJMxmt8VjFdHBzHVVBeNgZEprCo8KzSKMkO0V+rcmctaiIE7QYcKMkbqJHzyz8KTKtTcoPYOOw/pgniCZ/+UQXKSpSHwihkM83WpSrqFJ0IlLKy8zPB3OgcAqkq2j/uF5H/LZTXw0DRsOfTQ53xnGZf+yvvmdMfrRDY27qX+/9xYZGmbvmiMqNJibup5nSYaFjnT0xr7DEWq7tBVV761gnQN2xroRHTZ80sc/HhvuoxmTf5j04fF4eGLXsTTssyIes4+t6KMfzh+2qFEX62gm66ONkvKyT5++6D8wFFvrIegzLGIruN1Lt2UPS7U4u10PadnYA/Dp9GFM02tA/XsUyGLPj+ITao5L9PK0gXmzx9qNkx/kY6T9Ew4Gohp4Xn3+P/3hn0zyF3/5d397Pr8A6Wk+PSPb2dTeykt1gThNTddINhAOqLfSrBZRSYJNnsEJ7B5DBDCDsYNtFTq+FjLd+hdsqOcHPhKepGfn55slu/gz1+eV8KIgpHD1ar2UbEa4N5er+83t9e16NVndnxMVpPmLNJuenGhR7GSloXdmt4snOxqxnz0D+WxanzAYbyYbzFbaHg7YDHtU5xGHwWDyp9+QNoBsShmWrr5XRikjV0QcxEdQlGk9BtEUI1QEYEPCIwW5gxk4ik5eQGmXunJu5g8Bb0xXEbVUIsAt/8jx8pLSPAWQI6BU0OX+U3vJMcBrzTJSRdmsJMR6hsNQvRQQvWTBRxqKn1SxLJGqyK8kg0JRlsUqtQp24ikH7tZR1kBFPV0Ri81kyhsMcOMszZbT0+t8/mrNiwGk7oRdmza8VJi+sngqz2f+VhxJga9q+9sn1F5BI7ODotph6rhuroMq69DVwNH37Yi/lQPVj1skG41jn1aHidvrl6Ipoueu1Tv+2qzff93m3Lp7P8gPMf843a/RXiWhsbzJdvSzA56xmDbvpR/u5YfHI3aX7t0HWr3oMA17n5m32EVN/9AAIHSqlpAPMsMtd6UfVXW/vbd9UN3l2yX75bghjTqPalFD1mNfHstRQU9n2GDb6cZQ5VPio/FA2a4G6AxrTxj+n/+//tv/x89++Yff/97nn33xg4vzs7OT08vLq5PT2c3tNQ8HDNExbUU4FbzILx4YFyQKRhUKFN6Fn3AwH+DRIMNAz7YnCdoLbpZgFGTJiDehADA8n5+w5+ckmzKiDxNbfmrxiTa64S9N5+D92f3iPp2czE/n63TGJCBFIZPNzfW11sgC+dNpkd2QLmfsaH4OfwjlH7pKOmC0hN2CoUyekRTyFdv48w0qqIoAuuy1SMnroiY0BljJB3mYQ0RuXhG1/mShjNz+2RMSeQrrzXyh7goIW4jiWiiiEo2L09MPktIEGlWWnpw3eniC1zTMzhQl9v7UQLxG47ky5A0L/mSB7ANsa79U9MF2LJW9ChKMIaWyMToo41Ahta2NFLCpiWHG4hCriVKa7sVEH+1SmmfZH/yL//6f/cEfUA/KPNcLItDt7fX1f/wf/K//5t/4G3c0hVSSs81Z0s0OVTBNykvEVt6UBlWRp/0y1LVyc1aZ+vTxyQNH90DobqEPHl3Eh8nQv5fx+cPU81G1cvOZaWs3pgNEld2n/ICBxz1HiP8eHg+1OKCbG+yGutJb1XvMD+PElMfrAXrIlR1zDvxd+kCtA4oeMkLcJy62t02zd1zbYrFv34hvTO26I/WhFWI+pVLWQzryWzqXGY8wHtPHOdh16DezaYP3wz2MDQxa3yMvCRoGwoclxqnW3ZCSLHBZamBEgnm0+ib5Jp1eF+v7b775+sWL5+zunxkQPzk9/fzzz59cPWMTGKAuw8uMPwsDMgGIRcPFvbAuOBjov/6CcKBIXhj8BSzygqpLIb3stcSWgpEpFxuQFBoWqgSWarC7SKYvQbroI2gL6ATfZtnp+cXF5ZWPijO8nabTFy9eFZOXNzc337x4ASG78bAs4M3rV69fvUIml5p9wpD54gd6OW72QuhZ6Jbw5HvgZe1JzwpeqcH2Pozp0HCau89qB5tIDRSVofomwE5Yn7cSM+OfEIi0rRwQRify+L7ys+tE6wFwDCib6UgM1RMXyS7hbtQxdpyQqHzJtVJ9KmhI1p8JjufYzgGBzQZSoGUxBYwg59EE3HgIp9cemOaTZTabn5//aDbPNceG6VC8Hw15vJtrOju5+mI+O+GxiExh5D3hHW3rVy/erFY3wu6KE8RF4l2MyeZCfYECcw9NRgNhjtD8VIsQ1DZFcjI/seZQE8mG1VPV5rlNmizu765vrnlrg83SsmYsitdvrn/3L/67dPqX9JoBtbciGusPLIugLcSjEmzSxc4PI7QyuxZpSVF9VpQ1opDZmzj2t7JXUKMAtTmw44jH6kv55UCLeu5aR1BvBOf279QecmP+cXoPFr2k3tEobnUz66699fYu2KPVHu1XdbgVHOdw65NPHk2HtuP6tOrLb3M4JIen2qypA5/X1xr515bsrh4xRk67H42p9f5oHuM+NdKa494cO4VWzbn90XAy/9qHc2fdDzbT1X6gesEzD+TzjqsfV+3jcnvHrijFYUPti+QXtT6iC8AYH0KYrFvVro5JMpvPtcyWDTcTTlMGcYXVCBDAdwbKgbTirqkmE4KFOXjw5NxIlkBFDVRroFjgT5ylh6XgUqoEiCRbMhk8FqSsLqlEXRvU9io8CeBK76hStq709ivo7+5uGPMWB+2Dub67u1ssWKpwzYQT4W3B9FWyPCcA0GaX0kAqTVYzBQP5K+A7UNlAP5SoimqA+5mdpZt+6jSzwoD+Jtc+myy0FY0421qE9WQxnaTLTQp/OOANeOIACxgUIpkbtBWP+UBInBwu8BEfcgZGql20bT8Cv7FiZYDPVeYLMW1CkeQSFlkIIa2gYTjqZJnP7hMeeViQodjH1hnLnwkv8SWumtKU9kyDRwK866soFoQh+hUzHSSDA+kc3gqWqhqKT+shViRCSVVPmMCMGqToEVqTTdmUeUdrniOxzDm7u7NgQa3PFlKXmzPaTkykmJpP0sWufnhnKd3lToPAdXRKT/u5WdspunPrcr6VV2547KxvpZmPblToQJ4Il7Hg77ivMf9b288629tuVWYyt84eCr9ZazCp8+ip1RH/vcMYq1NTzzygjfV7WR2PMeJe8R769Ag11qRBTSv2NIUIvVvHZzL76NtS4pydmjQUa1929I02UT0ntFpH3XH9qtNYZxuY12V2XUU9oav4AXltzpFd3nDOvdOQTsHtEQWvG3PrrPjOM/fRaNh+OJVGAslAj1wl6y83i6eCfGyuo6FuMiUQ0M3ZULrJB/Mx0URJ4T9DgDQKk2/SYvoa4Ao4pNgRnva2Ny8JUXqKS0FATuXhm/aU6FgIU4WuHpgf3G8KAC9nDIDrFVfsObNm8Ps6WfCCYHabYdT5XsGABq1tox5t6Ak/liF8JWBtqhrLYjL9jQwsHwigNlqD2oHV1OUphK8WUF1QvqrAR2iXoEIxgOpq9r+8IQPmrBgx6K0L9UzWFSANmYZvZTkJk0iOtCq3+vEhcFnJfyS/NIfatXxjwYGUIK5AfznKxuJRTCn4WISgeGyaT+YzRvcpVzsRHWU8COBjk9kuQgiFnqAFIM5sHKIazf+RZuYXHCxjyNCbAXiA8VpnxNifyJRSqdyUvaSQGnSANQszZBH9BP98Q6xC6FXy5VEOmmptNoEN2xPNedHBmlcjQClqfCu+roaSVo3PMqEsjvLDElBw2Tg7WffZSbvLPLf9rR+ifswy10Q+xMr2/W2E6OpuHxw5ok71lN5JKw6jKh6R6N3LHd/uI2cxbL1hv0Srz5Qxxq7xmpQiWn1jbw5bXWupPm3Lr2Akt6N/Rr+/NabjL3o49GnVl98nsGO3nz5S8nv206u+Wgx17L63DLD/aIoqg79V5h7WdIfV+mhauq5on7Hh57hO/uFe9RkyUmOqf8RHf2sZuLaT460S/wmxgvzBZwb3U6a5g4AN7QEPcQZIWRWE7DRCz7U9DCh9ZKBQb6W124XIgv8ClHTApwqkiB2AdAZljVZb2wBGNTZsucz8gUyY0WIATTVBBpjesa+YFEL/7AbECoAVwJoQhLqamWTj+fyooAKa8ycxDrXJcc2Uq2LRYJG05WdOn6aARuudhE8Mp0wk9l+AXGntX4rDSOrKqI0P4gzc+sb9VlQSqJIcyIfc6E0BL7ldTERr/AT5IbEJ9lZkrSSuVMdUlUMNzGeJM3sxsTOqcLVVVoncCCPolTa+8jYP8avoBfGC1E6iDy6Itfjv5KronoJO+5PqTyESssVbZV7F+OB05oNJIZQxIzFQz3ZoEQIDtgZabwjVaAVkmnou3DzuecZPpXaYFkZtP7jkKad+tozWyemMZ6vsw8lw97k+rvGhusWWkn4Ys0OV+DbVi5tm2K7g7pAYpv+4SuOO9XFp3tT2sObp6AdkDTwBiOKkmgalIzv41cjCRR+fQDAuMT467KP0fJe274j+aGtrxsSj5nE6JhqOyzsi1Liy3SD36NkWm+7kWZdQXvXV6rOrk8lemb376TqXcf1qwDkx/74+M0bhvrpl/jfGY5y2Ih1P2aNc54iC+4FuvOPJXg/PODu2N07HNHG6nwalpNHIw1GlIbrJ6nNVyp9X1cP3M6BQpso8T9gGB4BpGBJyBpKZcgOe1gti9RJZxnoFrDUbB1xmE/8B/WBDqmgVgGQYhrXi8ssmT5riiBKas2smhBiUpC6o0SpSqCJOeoYAeNw8AXpvijeAx/n0VAiS+e16++5bweN7ppkoQBBOznjmAAalJstObWP+gjeXMWsInOrw3RRAviQgDVJ/TOGXAFvG+FUQhQpwAw4z8C177R0CECggUZ2CjYl0c7CthEomskIb46AhFoGT1/yHiXA4TBRUUMRZsRRGWr4yjQ91zT+a5o/5es+xsLs0VvSiS3seoKqC1pDzjELLl5N0MUnPtfmSDiRdKxJL2IUJz5gLVR9pDP/zjwvFECgoy9SO1NrYs5pKXdPMuEkMaz+S7C7RNB9ZBQclTG0zFsgP9jfl1Ffcjowc1lcUyYKtmbRyQzrJY3CUVHHwdrc8Z+rn0mrPFzdVKa+ULpN8iHJ7FacCUU/5uDFas1HO0eHBradjUe20mTl+JHjf31YT6HYFM12J7WX/PWSrrsvd1tmW7E6N4R/fOUfR7xZbpxj0c5/Ezrt9nW951W4XeOKudn7pQ/slGs+/RulfjT1/y2ocOm14zMzyu7inzh0aPZxDB9NtVp+XNLLDDWTgG93x3eBZKrm9d5Wt1E8pPPDRuars0x9z43X+MnzMBh2u+0fX/XaZ2nFD2lVF5aGagSnLCHcwAUBhuvJuqIn9ur3ZwLvQqgC61v1Si5FcwLqVGmgUvma2EKgcKthsnwBYMTWoVwoypIgerorBe1UEFdqEECCujfR7MEAtOIDuKUVltgQiDmBiiwa/mdS/Ar6jRcr+oFQGTq5RQvvQa4AZ/GkgXlZKHlqRtENSTQHjb1dcqhgaPT6QcjpXPwmk4K5soVobpzc0D5lDZOFSmELjCc8VQ7GyzJJSVcRHFIYoYYsYgXAYcwEXyvinD+kjBk5vPsQQSimiuawVwKN6ZEOYVqxR3mMwIgc8RG3eekZ8hl5yLyzRj0iNuEnmWjUUkVhpCo0pIp1kcNlq0k3a6j8n2SnlBOXpEvbmNQpKYjUEhfxXwCC3Sy2WhCsCMR6y0Bzl7HTmkD7bg9ohw8SqSImqIGRWdaqC6nqvz30qtyTvJamDeB/h7epe250VOHF5dDXbor/NOTs9GLqne8Hpd9b6Nrvs22db+D51mJbbGmFmhLKf8ZiDaZBfiC7/OnSVMdXG0QxGwGM17B8LiTkM+aRHWb8VhYohEcjb8XQ8ah6nQxUSxN+Bs+c3vpMxcWfax+B95LgxTuCcQ60+HQLBAYmH8Gxo25DeHploEIy87HvG4p73fhz3jZFsA1lf3b78UHGvRPDVvt0jSIn7ScjsTARZnaWxXXG6k5jMFo1/dVhgqhrtEYvqDrPlZxUEx8gScgMlPnc3WAe3k8E/h1vCaQA58QYDWhXGoUGHvDFXAJFRcIaSmW/Cf5AiJ+AmK0wZkkcl0GBuM0A4C4YCGw0UCj9KqClhmbogIb3AgrAB2YN/l+fwLyavyGH+Om+TMqyr+eiIQi41iDGQzT/U0UA2Y+T30NmsEoOXbH2zXqIzCJi7ImPSvvJVAUIpDu66UEgjIGqgX+pgcqmloVdPm+4GvHWtKvIPaSq4Af68QwDc0Ls+jdSBO2nR6YxtKsBSMnjOYGyU7RWgR0P50bzl+qCkR1riLzYqlats8bEtdrA9gQiOkslC3uONxRlb9TNUz2T/U/lB5LBx79xp7D890/sTNguWBXNJWxES+NoN3AWgVySiFpEiihtMJZqSdjLZClRwJoc+UF8kHHKygL8eTGhBh/YjXV5Z7MFOGshS1KGXL+B4M4azHfa5+kKZ7MsUH2Sty9/NUENk0LS/a17Q8+0oWvSl1vIoh5+rPMuKTu5/y6h977wW+Z0VbUSz9S2O2O6T9LtQ61fDBbvpHUocS3qpaWt8ehR/84NzGEXf55aW9JJw0M8PktijyWPwjG3pEXtoNn7zDsI56slj2HV0qTHV+mj6WrCP/qD81jd9B5faN7pBG77gUb79zjIFiKOrOKKMkk55ZHdG/N9hMhh9mDXtWoHhvkbAqlGXyzb/fdk26I/OsMH/US9d+YaXjiLxMXgeRbE+Jg/sG+3O1ifoMfPHe93wm6HN2rfEvRDYqH8I6IER+erYODGQcSVITTYwVLNQwGyUasx5kpydnQt2c9MEayoA0K6XxoQZPNVXBUgYAgDwoaTBzUoFSNFKh40fAwfBksK99tBBucwUZxqLZozbEDWlzIN/c/NmuVjqJcFGvFgumU6SzbLr67vbe60CZm/SjS0FXq8WmzWzgtjsfgVPMCkaaMwb9TKZxAi4THOci+HSAA2F0vlvusp66axPNKVYNmKt1DbPymkySQteKTfbS3pjBUoWnYiMgeC/6ijEgpWY+9C/XWmKkUjFS2GVvIQ/Qf+KdAScgc4C+JDACKCPPvZp0cBGq3unPB1hWa6xICwRqFdglrMGeMW+QFZDgRn52q0nm2LPdDrHcwQAmrIPuIQIKTgNsbCHl2wyKzjT2Fmq+IpMGYC0cq4PGlmm+Q8J1vpysfSxUA39NXdJCzMskhRf8bCT2OmgTL4sL4zC03Y2qdF1K+k8W9llRrPUNJZp0eEi6nlR8YeWDIqGhGu401MfmiEfnD7fMg963/fzI/maLvgtc9qgo/Lm/qCD1LqV+X6i+0Yn8fy5XhHtCPidRFre3o17T6xko0OEy4EqXr1v7Dlm7um42zl/zjv5e914duZxY/q2/u2cfS2NbR/WtmesKGawK23jmsd6krBLmMr3/l6MYWo0sa+Ge2Cf3wBGVAx1ByTHsgbIrGh8P21yMsDdzOQ62rFYKKtUmZQNK5cGgNT4fgjsGoFwqb5DfID5vAoYrGCCDbgVUna61LR/bfMyyTUDnpfswkq+EhiWGPgbBFb98hBXQ8vKMwmChibAPyT/8uqScAKczwVonmJU2KxnQHyxZm4JW9azqw+ANc3+9S9+dvP2RqJZ5KtnEQjgSQMIk7n+oFu9JBgdtY5gNZkVxVM48hJioCzImeFwzXz53nLDnvm/nqawYNrQzXpynqa36eZsnb1N1hdpcjPZnBfZ9WRzkaRveN/wJn+94Q0Gyetkc1lkbybri0l6k6zPi/RVwW45mfI3PKBYX06gX1+yE6h20cleTQrySV8l6VtqbdLXlCbJ24I0tVZX0Bfrq4LNdlTruijIf5WsniQJ+dLkZHI2Se6y1eUkW5iH2VA/ZxedVNuAsvEOWyHdbdLpcrMskrNsffPyq19pZs8m1dY/vMhA+6Xyo5N+9sVP5mfsAcoGoemU3Gm6ylbzi2fT2fcImVhjjSezKX4G9683d+s3L3+poXwcJkxvXUOhh8Ub6iYwmdKmNBCZ09k0ZfqV2oK2s7hKCF+tWUyWmw1rErSfrEIwHiwQfpGf8IDInit411CHsY7D2L99Ut3Eq1vq4P0AHE6szlsdHd819TGFamXNitI/o29HVSA6atTJ61cVaesz0qQsa3Ea9dttldtVW/I69wUaU6/NqZkT7nuw23EfNqTRrP/duw4e6zSdHoQn42OHV2PSMekWugt9tiG3ZGY795MOZGOEjKSRsS19euu+k/4T3RnaTdGhWvvJeQdRlGV3En8CEOXuk3yMhthH/lFpvc8dYBIVD6gVdO/u61XxYcy9vzxEq0r+p88P2gMHd9ojWeXy4y58rE7X6viBsXdu4e9YroE8kJOjLgE/Rsu1jTyAUStHBe0ZRhYXVdMEHGCmoXtwmrKE2KzU6pbf6TLT8gH4Jhsy6pVUgolpBoLU4mK9mBaBNtxdAFUTdossSAB4V6wcZRP7HPAIsmXxL2qgHVfsAcoY9oIpQABZj0CMOzHA+ST7QXZ2wlYNmiuUMWgPkEyLC5gm6eVPT/LP1qdFelsUZ9nkGoBeAOuzs4S0qvISNN4b8EagPH872VwlySsB/eTtJL8AxCcC968L8icEAFcFlNnFZPJmkl5tCBIK4Psram3ITy+K5PU6vVxlbzbUnTjcf5OkqjtJ4fMWKenkTbJ5ssrfrNPz9eTtJDtN0pu3q/Ovls+zIputpriKRwR6fgGe3nDJymDeRDlbrPOb9e0kvbhfL97e3d9N8WMiQE7DLRZJcsFTAZ6H8OYy/MmsKtxwf3N/csqreec0Cn4ktGVbVean0q7y8Vny9i14nzLNzFKf0PMW2s1nIgmZ2/sE1Oq4NGe6UdUBLEjgaYUyWBxwe3cHrZA/DOzxiToKpVJe1xzWE+kP1ifE0BG8lai0urbeo4CkOqyoutBnKPKOZiFnXN6RDlVcUKBo8Q4ltQSCOLZMpOw7P96DyHdu4/sUuLMvOEHoBZ4Il+9S9fci9F0a+IHJOiQA0Nc1ik5Ki3ZEh4fFTIfVavs4ju3idIuS/te4G/mYd9teqjpxoG+PNLdzYoE7I84xXwaku5RAHPRp2xJLH5Nu69/OcT59+bGUdg9p58T0rXmiceG4tPWfPj/s9P84GTWqjn4y2N9qlY900ee3gZ48ILnVRu7O0N0aVT0/9MFG6aGXzrWUWYpABikhfv2BygT01k+Bazbayj7ufJeZKQ48A3QykAypj7hTTWP0/k0HtRlAhJPDemdpmnpAUX3R/dNkUSp0aHN7qC0GKgUSsjV/9hkz1u/Xv1gyTUZhQMosIE37yVFpwQvJeH8VecxLTyZMX6Ee294nxf2X6+Uymdosc22AI5y4REsZqP+EFfZOXp4OfJUUq9Mk+TK7+jy/Y9oMl9lkXuSsYcgnxYIh9mICXJ5OsvuCfMawk/kkvUuKE97zNUnmCUPvk5Migf1pkt2Tn0zuJ6Kk7smEWfiJzklxZlvxMAUffc4RX0zOmGCTEl0wTwdczmZKExY8oN45pmabc/isk1Mh++KE/YPg8DWLGxaLzWZmAFxNh02aHAQNj0RwGNvxsAHqajXN3vBuAmph64o9f4jSeJOxnoVMJ2utx1gs7OvMhB/o+FYhAjnFcjY/UbS3Bv0zqM+W/vQAnhWwhAAN5EkOdRU1kXvTXvJAUhnKV3gQPRyQjtaDtUqD/kN6+UTBGe830EQvVbeIQjGKOp71LU7qQ6KuJlKpE3mOizfrQ1Kl8SF97DDZrkGV1f8JcajYoOqR1LO6oFE5utznV7hHZsTt0ZLhvodLOu7D+8p9vPt2nz9douvZR7OvFYP0wWNQeSdq3e1r9Y/g1ZhfZGPoxd73gz4xuZ5E8Vz0c+UdWRMTgzf6vkk1NT7Ui45ng8OqyteHBADDXD/60n1vYfvS7+ugYf6hNHxznH/jckBo4DBA84EUYRTa7nUcUGUv/h8C8bttwTE9a0CjUQ1oRC3Ksi39Q1DOxmRZjkmKP2ZtMNMGdK38YmOj/SzApYUE5Jmio8346UCgOgKDckIRhQbzSyrRGrlQXYXnPC0R1v9MmFC5YzvLB/tZDrx5DsC0fZuUol84VgKg12wGorU58Lx0ihnqwGHw71o/OUBYrRMG7mpyOZBWzxBUUaPl+ldOgodQllKB5a5YcD/N7tmfBn6MgIPESwUUV3AYvLWEHCBXksOf6IwJINUdLDuULudBySrcZ9ZbFVltLETDhUA0NQWFzVt+ifuZJUMJw+MKWBS4EA2Blmf5OifUUADgQNkG0sHQDL0b9WSdEamkC5imOq8INYTHMWQ1TTKcCasVsdvdHW7cpCvek5bnKct/T07nCopWtDVv7WXrT5FOCGZYTKyG11R9TLapWGombCvtlxE63ExL2olsspTv3pFO6gl+zVlbmsoLVpUPBRkIsjMJpfVkSY1Qdg9pwAVnF0lVEmT1HoHOle2kcxY7GHXW7Mp0bYLcLpLHzHPB5qVBxzymDt9d3u+t2SOXN3RoXEaE7yjpffEdCXtfYvStHwgA+I3kiKI0u/YTDeT3jG3egTHZkJQt85AajlADWTMRWxGnm3TldTCPBGPb7e7oxrfze/h1Z8cR54Bd3heb7q5YhnxXxvmMGY+vGJSfVA+sGkXHumz3kHbOsKzYxvF1++yK/T8st1a6Z4/t+QbVWPZexLLidG+F7gJv3D6PDfQ92LVqeSN0CIpGFnG5ZHZx9iJV33fOYvU9DApIBAhz9YQ5OMv1r9k4Jpm+FQa1WdyA4jSdMWEEKqFD/qGh5nFTT/P1pUP5djB8a71EQ7fQAxS1mNWG0rkySCiL9CcO9ljBKxgThQRCeDwUYLbP5iXzgNYbthWarpmzsloKtgr3GzrWZqDIYKwaDfRvDYaEKXPEbcha2J4MpvuA/lOFAQ7JsZTdQxFv2iQnxXm+YoT+NWPhDERLpeyN9GMevySJBQgbS+FmmFV2IUcKC+VSJZcPEibiM73ojfLXT0rIKTIEQSMNZZ4qMROJ5yvoCdpnUpAyjVBaFelrDZZvnphvmTND2GM6pEtWQWQMmutSy2oFzMVCzMHsy3R9s9nciIKJQptFSgw33fAUgmgALoorXmT5bMNeQDlOzKmf5syWwm2buQI5mLHa+077OG2y1WqTZXMm9SeT7ynQSr5ifyD274cXwYD5TvRygGoqKSdIH8vQWXbpUo+QcBoHPesbKLS2mHw0o4lWT7U10OTengJZ1IUvcAB0NDA81AgwlkwVlKyw3g4yTM7gbPVAVFbSR/Qtq1hYqb5rNOlvLFMm9R7VzKUWgSvUyu7IwO0cI35J23X7VpGpDXTEqst/bQ7vKGe0dfFdLk7vredoiX2cB6S7H3e2cOtu3yfqyPlxS4ce0mx7889DNBxe8xCbNOZp+YC3Y1Y70718/OZT3TECn71/N0PN2MtkinMzANjZQwKzb3PCHcXZ3eFnumNIuPFceh8NReOdMr6KU+6kd93GKzCSErnhcHsfSVCQ8i4ToQXfpdDHkDXQPbwF43Y8VIEBIQ2WnZSeWVekuzMZcmqwrC69vkCVo0/wVfKbX3x1enX32WefLzTbBKgHcmYMFuS3AIBvpmDQmc3aAI2RDZKeGjorZwEZa9eOpCFCwdNSN2qEwxCkrpQQjR/I0tC/VTFgaxiR3XvQRctYNdytSSYMZud5DkZ0UK6oQLdh+2ETlNa2OSiA3pYAYgHfhTkRZKBSJiOa1awX6XKWsfAXc1wNLRCQDeLAL4fsVJIMQVfTVITKKz+EyP3KTfH6CgcoECv+jIV8orSMdu8oTdWyVEkXwewY5cGJawsImJs0KebsWORTaURZ6iNuuMWeGGiWPROYmP9zT8wDkfFAiMRpVa8ajYlDDK6Dq1GC6VVTxQKb5WqZTQkICjA/C61phk2xIK7Qsl12DcLxbEyEKyz6ktKmsxliYsxW8txUdLJJPiZDpKImk0MfmvDDSkS0MnVMTWPJT6kiFaQ7PQTygclyMaXg6mL0p6k2ltrl1aSOrdqk20tuvfIDqjojOdH8dRRLnOenc9MD3kwfiIvbarRzmgY8zvX7kruHNf792KOCbm9+42tV8vcAbMf5ML9iX8Wj1bXX9at6XovrHhmVlJFVxsR/vRHVoIy4VvBCSPRVPcwR3sn87Jw77IpGWQLlTn3GjP3HcXBjHnwQhF0hHWz3nJ06BPpHSsS+ilutU9ywtg0ba9wi/9c479lja3Xjiz7+MU0sK07HNFV62NKKquMz9mdcXPNG2R0aDovJgUC1Sy7qnJt9qnPOIrjJd0zPmA3fdVRc9M0ToJtks7dPvrf+0z/55dWTMzZ3Ya4Nm36yfHS1BG8zy4Y5OKC7pYZmGWXWGlwK7ksIyHR5zQsx+AqBsJ3fAVmiKvbCcCYJ0GlERrNi/JtR4Td8SYg2gP7wZW6+vjNUAK6CBC1zzvYygqQM8xMJzM/PGJmGirXCGl9mMTCj3pPVbHW/1FQWDdirmJcYa/BHaulBALxIS0/yDFViy+nmJFtPsVKxhgUBxYa35zJCj1bs0smkfMhlTXUoWdpZJpdVBqiX5by64j9j9KrrAt1maUEJ9PjwyniKuYi8ErHL+kpJ35oUDM8OOULy6H6bZYzvszT5PttMWaXBIxA9HyDGSYXX0ZVNTXESD0JWvAOYZQmT5SRlSg9xElEDsRyhBI8pWLfA/H46WbFc8JoEPKjFD1Dw/rU164g5T9gvlWon01l+fj55/c0rlgboTXAEWcjRYY2KD82GMmfzRFbyZgmRsEDZ2lGENAdpcvEJipKgHt6Wa/LZm5Pz6+KOVQpk5uxZJJNQkfc+MIdJh/lO7aXwwOqWSlhpeSryryS24/DO0PrWt79lXrf+Xevg15lVe54QU/QoVZK0tCq7bpUfukUYzQ28h3+h7J6DTwJ5LVG/I9WKGhfydz1rTN2dNM7WfRP4x3ME+jSv63L41bCGNeld/cd1Ds4JJhyuUFTTdfOMmiYRzUDSvQqB95CH69b2FXeI4SO07Bj9naYtJRYxXOqUvbJqv6eh0Rq/qrG07nT5He92KE8AtgVbGd2cvku5W6+0rA49NS6BvjM/pnlgulOlo8sd2QmOLneMc0bqNoaV03iTdTo2ZhK37E7iuOK7TMdKutwPVtU+t1in6m8TSgQLdQiQcgiKMf+n2Fz/g//q/3p6xmrafDZjeJ2R2tVysXhz8zaz7XkAcEzbYBnuNJ+y5ct8zsJWcRKA1eHoOuBllUiYgWiT6HSeR6Hhc6vJzJP7O5afXlusoRF9Rp35e/nixXJ5z2aj7DfPzH4WAYPhAa9vb67B1zc3t0BmYghuGqvVKlls5opTNsQBrCwGY4Ir0Y39SjFJxpjdGl+2oWXWt55ocHuJ3qaF2SDASYAAEWBVI9rbMjfWMimFWv/9KD1ZXUKpqvpnUFeEcDJ1yDPmolWiLDGA6wKBu6ivIlODmifp+Y/PitsVO/vMeVaBK2xAnmcjtsE/r/hdJ/fr5XytCIqaQtI+uYRyGV5OYXrxy+cbNvnJTpm1lWUn+ZwR9/Ti6mq5ur+8epJns8vFxf3tgu2Y2BpocZcly7dMMgP4680EtIepK0v4c//ICm93Ci3XzqETWKmCQ7U21Wg9o2MuF1lfP//mn/z+7/OOMFhrvymmmum1A5vf/ulPn1w90esdFIsoJFAT6bFQ/Yiu3a314nBljRERVwVUah4dVE2Sd3g9aNWj69HhnmPIdLYN5o3LY8h5XB4fpsJoRQ9+JN2crfMf/p48kgIPbtFH0svfAyCXuFuGnfNgK9oMuuLUNtVeOfk3e5GXxL1xWMVs2DXDpRWP8hPi3e1p0aqzjbtvzKottD3iEtN7Oo6DSTc08ctGZoNJoGkr0KA87uWwVp2yBjQMT0Kgcc7tmL5dPRB3itsjc9doxB6sjBQTYm3bvuobjejLr38j9rU7qOOJcDlklqGd8j0Abf2pKRzlqJxPp+CDmSMMpN+xYaNW02ogVm+AAoDN5qc//elfvDy/0Fx/8KUGnAFmYDmGaQUDIwDtyNAzpSPXQtR+OHSWcAFbzXfXJ4cCi5vbm9u7W3GOyP/4j//o9vpWyE94Homl6jyAgBKlgbfMdiF+WSzv/8Jm/jeyq2V2fZOcs7UNM5RSrWSdrzNeDjDbTG/u1vNJzvaYJ1l6k24uLtPV0+TSX3MFJ4fbekKAb4pLaV5a49qrdxsq17C2/GZGiMoU3p6c3EaMILHoSE42u8TDuJY85aHSWzLQqGAtsIxRYHgtS2Bbomx1lp2sZ6BndhlCIvsU5UhG242eAzBTZ8ne/YvN/XKV3G8Wv7pbPl++WazOGf2/L5Y3Ga9DuyvmySq/41ZVZDe4j51M1wvaMX/z1Uv4pKtbXt58+yZnc1U2WWKm/vzk7GQ+o/V59GJNTFSFTqhnGIMsUjLMztkru6IL8UThSsbyGgQVYgUBSf7FF1/Sq6y26DGKLUR/89Wv/uUf/yHNTwdwvryn7P5+87/5L/6L//Rv/k1/KYQYqhO5WNW1AwFx8yAwaOMJJ+P+4PqV1eofXuScy7O1a8iBfKB6ndkRrrruZugS7iEj9coGf7sDt2GFkdU+xtQdQ+OcrQ3lYMl6OIZpc2jnmODxGpYz6dqOGMzp+y0YrFQWlrirqyeMqQ6NN9wYHcbQ1Hxl/tRLYCopx/py1KS07BwubZE/Skb5zLBtsO7Vvgag8xvzKMp8TEzbHjuW9nv5OxB7gvNxFXsIt6MrcywPBz4jNcQJ7t5QcSCxF/EAn4+taF+7g0c9ES477VapQ5hBOiczDqgj/M18nsWSNaDsrpn7FkCC6bbqUzNFmEEiiAbmJjwAhjIorJ8BQJsGdy0GqOCgwHEQLvQfDPZsgTnXXQDbLhwbgw+1MSW7/bD7pFCfuIgGlAoZlXivlWpWcJAs5sEQFvA/S5l/s/6r6eUyO71LJ6cZ+2yebgT952yKsylOF+nJOj/Ns+u84NVd10lxmqcLbtxazSA9TCf7kEpmgKmnpFvgWguI+uHqVdaE4Wmnl5aqpqttjXBVZVWfsor/8h0fOFjVAduai2Ny8YpmApnnmbejPfW5sBexMQdIU2544HG/mSb5NOO9yW9f367uWKJBYMOiYOKlRZ7erPRsJNG0H5jSktpHlIYl2MtYU8EwvF6toHd78WRhNj25eHKV660JesqAJqwAUARGXfeL6VU1vamjkEDqopnyMUJWWWSVTC7OtcmpZXE2fSfF69cv5/O5v2JCuUQLTBlizQkbM/Fwh8cT3gHoh85MZ/OHs/KkBFr5lkYpowz55uCS3kvjs5PpXLGKKsaEH066rWCvdR+O0nVNgtfRvG1OnfbT1ScPvFcPDPRRxmNWX6q8I1KxX6x4tLi6gR3VmHa82BP77iG1zXOPyltS/2K/+3tTHN123lxCZlu34RmWblsY+d6aWjXtQFeJieP0u/SS2xvMR42OfmvKtT0T6+zpet8uf50Dz2EObU3a/HtzHt7De1iHtohdFGj7fNWX3zOyhemd7JET+yymGagi7SpSVa/Sym8eBtGqTENzQuzZZLbevAHFatK2kB5oW2MbjAozDr24X6xPNHndDrCdYLOhPEE+e8MrtFCWgh3ImiGO+iqbKHczBF+NvCqBW5Hc2ezwOTxB9UznQQ29kWB5yYMH3qJlYLvkrRWpm0spwYt7FRNMN9nFcrogY6qnA+xjuiAqSCaMcm/yyTX7+acZDxOAuLfa83NyLzwtJCwZphQfmpdiIYHiD5kpzo7KUdeoQoYsdzMM46Mz5ThD5KSMuZQlfsGh5DD4bhQqZSwcN/q10g505Sw1gblJ4+6mjNYBM+WH5gCJI5G0ztZYzF8i/57pM5Pknun864Kp/7jglpF0betJOxIDMNyu1xCkd6hmkvEAIRzPUdb3Z3BeF7xxjElUekewUL4WE/NiNSZkMV9Iw1tFsbA4y1RV7CDPccg/OnPIiZ5i7N/7AS4kz+jEFmKRGZW2FvVKxHxoJX3MbYvvTVY3i+vLyfILvYxZlsodZdVSgssx/5VCS8niWZK6CnG+FXacxtB0VNtm9a0o2FL0p+LfqTjdruEG+bldGuc07slx0cj0GCkxq2HNY8rONOLQeV+hTVZtxNLOadZ5lOve34Ix0o6kc02Hnt/KGs1BujkK4s7W+A5xqTa18zDjuOfE6eFaDy+VLKaH9qyRa/Mv35zwvFXCT4x2AdKvQf/RcE8/4aeSd+8B76lHlzum9zeEHkuTRl88uPcdrM9eFQ9wVMNvj3HZ8OFRRfQ1SOwJl9/OGaPICN0rFYTlhLwAnawiNaxmMoU2YSPYuVwxv4ZXXNk9TpCVzVuA4ySoYBAWQgE9CJSpErv5m6p24SkBW6vHR3m/FLYDr3LJeC+LX9GEsW4gs0QLiYpUSWFhyGAkEEwOhy75L9SO9ve826rIn6WbNe8uIINp/ygvrbQ7jt4LAEamhBs23O2fNNXyYDOEUWkxN4MQYatYS+hpTEwcUg37msekg3RTdf0M+IFSpP2xggqlu+ksaRJolczTZo+UUhOIkoSuVAWlrERpVZF2Tsm5LJL3NUkrLZiKxX6pcJlJxGSWXxXJPb/ONtKu5zgZTmIeP9GJZgxJoCIrlvsqkGLpADIK1lGQe7e6y3kMwPama167pghE23+yGav2UtVycB42EBqUKprm0tAtMANgpQcFpq+KLNSRzmpczjLTjBWN5gUhhEzmdxGxKfos9KyCZGmo7EcxO0Ld8poStYUXlpzFtczY8RG4ic6UiCtUXOO870J6pPOO4oqW04/C9ROTD8ID77IjjTC4pc7RvuBaA8DNqkuA9jur7kdHkzfC2CPFkW1JHqV5fl8E2Yjkjm53mKPf8vhW35puPRHwlnr/VN8oS4iJB3QbkEYtd1ewcYA4LnK5Po4S+997X2cTeFHMpJF2PmOehzQqdopr0HDpxg47KralxiHu4Q9o35h/nK7JeshFrOcOPrEnosYBr3EAIsceqjuwC5Dc7qIqIYJYNkzMp0rBiQBGkgzc8iIAlv0yt5tL4Duf6KMkTAyhAcH0ujDxMJxmiMzwoHIcnYmXBp8rwSTERP/Zqx7UO2e0P92cggVtOjg7/DByDTglGGBf9rf+pdAkIaCxdiflbVWbxPbsl2wYLGenyekJ77plfHyiUWthW3aalyHYMc0yAOyMYXiFASyR9bfPSmFTnL1zeJkuhyzDao26S1lttqMUQigwE2SJAK8R8wl3sCplBm01ZR+W0pFrdFVNseCfiGFoaRGbN8kWM31/UVhzfow5mUy6Ulq10VbbMAnrK18I3jfTZL4WDjwtMrb3Aavfp7yEeLPMs0WR3ywnlwnv/wVg81pfRV4L3qmMbtIIHdjTiQXQwuTolILDmfu/XN2wMf/snFXCd3c365On+ISm52EMPYpHCLSOeiNzjtilxxtUTjMV4SOXyJ3KKq2UIB0SqXykE49wTSvgZ/MCmmMX+5MSjGQvJ9m1dhPKX/IaZWrT5orRysMT0dn6YL1Ugkx6lR0+Sy3CdcTHK6y+lPZ6DwCHkoF0v8T4O0n8OxWnXd54PvvquxdnKRPfY+O0KdrW3LLrp1Ytir1F4kS9zuNcdWnSlNSiiT0Wp5sV4+sHdKGYDemxEhvV/HL0b9DeUirObUP9q6P2bXky1jHuOXE6pqmlB7nVKGsXrqDU8aNPVt/7AfLnVc2OTz0kjfpyRWH3b7s49D5Scfq4P93rR/fBtjF73IPEnTRUPbpigecY6T26HzO7z8D3rt7IBjqmLz4sXp0O8GbxRlNaGFC9dKi5rCwQeK2hju2kwmllJaaUaJo5b/klC5SasrNnueSXPRkBauBZn3oCcpM6Oht8o4L+TEMy4KcLFRmZFZQnCoJAB4WyTSmIVVEo1cb9BcBBnQBFDQnbBCAQohA4FABdajgntOIyTTezm3wzz9Izm9JjKNuEgV/1Ci1BZlUBdfJCAQOV8MIomPGXM4AvHXgAwCi1cpCguTxkSqj+QMhKMdZPjg6oeGoiNUhTUyiVQnAsfyilOsqwRxeyzjR2+oorTASbTVXSDMWDxcVQzlCh1IZCsBsYrAlKOsScyUxYBUDHS9KM3ZDY7kihSJLnbOK5mgu0K2QqnwCwlHghuI9dWrvNPH+UzfR0BEtSAH3O/J8lm3HyeuDNanFzv1rPzp9MsxnC2fqJdQJIZzkvi0CWy8V6yQJrUxA78Rj/PZ6RelJan1aifHOZaMxgqSvriPU4CAvlOmykByKCShRbqAOV6IyjyZBDqkNiynT4VJtImypDCafj3HcEGgikn1XpI/6w892Ug3V8YPWD5b7Hit4vMPyxju+GT/u+XuS7b0Pisfy8m++4Rj5EUZslWVPAuOjW5bnBBxURvy4c7bmDvRHYgXFPJS98PphPX+QUJJAYponHtsO4tVcPX5aQCGzjWvGewYGg3XDbBq/i1EAc+7nVOIHqkIQ/GSj17/F2LL0tw+v2jbs3PBaqhycS+CH2j1vnEhs82x4L3DzRoG+Ujrns0zZuzWE+w32prDvYvuP5j5I1zG5E6XDrawSCMe9oD2+Btv7D7yQgwsZRzW5sNnLMyyZqgJbU45KpvegV4AYEA+oL/bPdZLr6kkk1fiMzbAY5INNvXwJa+tNN3sCg0RliVZ4goMAYhXz6HF/2sK8EkglcK9irnoXFS1aCMgDMjvM6wx/cDLzmFqk1x0LGjIIDU5m4wpQeZq1oxJjlwtoCaMZ0lwlv9AL3MtFH01MICThxwUqGN2iibXPmSGOW+22hvfbRH+bLgpcA5AtNcuE8OUvT+2z1gyJbTNgnZ3JXrM+SjGnoZ0Vys+KdAPkr3tHL5kXF6nIy9fSryfKKsepi/UwT31dXEzbDYWVCej1ZXUyy18XipzymYPguIb2+TLLrYnXOCHfBG3nTt4y1F/nrzYYVDm8nvJCYBcqbU5Y0TJZP9SIC8pO3xcopv18ktwQIk+yWBc1M3deIPh5anTDrR+LUBPfWCkzQKp6en/zVyTNWda8md2Dq1eZusZ6+OX3LG455PfAMnys8YX9Vech6hB6orJZviBaS+zvFLemsmLz54unFF88uFIcpHNJDEnZkta7Btku8uoHVFvhbT7nVzXCzPtTm3mHURmp7lUuAt/j6qUA6I/0KKnmOUc7T8vCL7qReBUvdOqjBH4zhwUF9sTAZ5am8Wn+uIr41Jt1o7OTMG98OaPz5WPkdcZ7Q1793YlAV+bes/XttQjpO8fe3o3h0Vh+f4XvIGPZ9nP3O3FEa32Pj9BhhTnNQrdLSb4zFQRw6FKz4VM2rdi77WKCuaEJG7JM4HQi6E846SKqI9m1Bl7hvrUra2M897KqzbHzv4sKATMjs8HNMOibdapeyErcLjqj0MF8d4AFuG6UO2w/rTT4YocxW828pP8JUaEU3q/nN6bFooIuEGsFPIRGKdiZcjaAb9DGToGRMEPMco15MP5yORQ9THr00GOKWDmgSfNLWoc9LbcpPOUf2QAmiBhpnL4E1PrULfvIcwfPBfZOX/fKeL/A0U2UE5gSbNXZsQ9/AMIadq+pAMq4JH9S5fMxU1PoRra4osNufUSpfJdYXLc1UcoFGxnlB6bLY4KyKlJR02E+WeiEZ+FJU3N8ZbhdiBcbP16t5BvycX6TFNDmdpsvptPjd7HRGDJDDI5MhDP1Tkckw6835k6cXPzqnKisaBPRZ57wB+i+TzXyS3GTJacL62M3JJr1LVt9nNe0kvU3Sm2RzkSRvJ7x+K32bAP0zgP4TkGuyeVak3xRrYPrLZPWsyF4onb6YrJ4W7H25Bri/TtdXSt//dpG90iJb0rz8i3XM66tN8qbQZKc3yerJJiV9WWTkX5JG1iR9PVk/A3zznuJJ8iZdX6yTt5vF94r0ttjcLYvr9ZqJTPfEPuv1QuEEfqKVKpBOmEQ09eTi8sn5WbLkjc6sqz5Ns+Wrt/Ovbv/k6yTn1QmassQDBB41EEOpmdTGtOZitZDL2AuIxz+A/WnyzfOveb0aE6lYNzCb6WcuZa3wsri4OJ3NaRomJm3Yskntxowrto+lG1jDl5jdWON2yKyV1V30+IVPgXL6DLGFHpKQY42uLkKaaIGnF5alblN2Let0sFftjsM6lvWgqlBaVemBT6lsxdIrXAxU+KCLPnoDHt+7nT3Ie97xhX832qPTpW1n6hv23o7jt7A4ajyrHQC4rOAVt7u8VI/oG0vojT+iyOZBDnwwH4+r4jFmt3WnVsEZ8bhyHB3CYeDLEjwjX7aivSA9eJpE4BbGob0U4sDNK440IUgZm+jx9s53LEhPs7HhH7LbOQ1lgp/j/NjncX5f2h3l506GfRVDft8Yv7dF3H9Clc5EZxwf2iskGnUb7dsojS87+ccER0+7bn1y86+C1z2xQ77dSQSYK7reWtsCUiIXAC8/wEmgaw3GkxAsY3hXI7NsrvMN8+2L9MyquLuBjIJkJQ+x0AFQsxzjUYIx4UtRKzpg7F9fSf7yfHo6nzIKb/PImZky/fWrP3/58pV2sEQ2YBHguJ6wH+X5ydXV6RXbQU7TebG5t/WiyeX95D8pVk95Gdk8PwWoTtbMeJnx8irGkzXjnUFxICaxgoBnkpxv0iKbL05PPwfl83IABv6xS8PieC1dmgvemifesmJgUvxcarqhxSuhz+I15yT5FX4p/Jub/FLp7LkeU0yfY1yBl0jPXsp72Wu4JeB+TJ/+O2jYdVQLkYuX4pu/tPhGGy6RZsYV+XImjwhITtAEdV+RUSTQ4Lq3vLBsMv81nAHYGXvzsK8Rs5rWm8WqWC2QxavQ2DU1ZedMgjcZnUzXq1tm8bAHUrGeb5jQwy5PZ2+v7q4vV1OeQiw3V4uM1wNYi+Dpgicg00Qh1hLfTwq0hR+BxOQ3N3dfTV/Mp1+yk+j0hCUETCdSwPb06Re8IQAor46iDPRZ3d7eLpcsRcBuOUBmlinWUeiJg5yDSdM3+s1Uw+kJALnWLazzwEm9SM+8YKykYgNjpLQ4GL2YlSm/pi10eJ4XitrCDPtsnKrnY5bttQI/r+gVKjl9v9cNtg+87LsntNmOv7+163pOpyx80HdnrtH3//72iTs4/+GWDtjb0KqzCwSamgcst50TiGuJqhfFmXvbZT4vaz3E/3HdOB0rt086OM0rBazFZZzm0injr9c+cnbRtrBWy8MuGS0aiV2crby2NqDiIUbc6vqeAGg0xM2uKvhdsH7vMvYf88ndudMCyLwHDFDGBM425LgLx8tCSqgbJHqOn2NWY3QLTMYn2oJG1qVirN7IWk52LFseosNeCh9A7M75kDUcYZT3jhGEDyZp9iUkx8IBWGQwimwvZAWrZsyxEQoXFQhMY7RciIsQmtCxJb2POpmRlkkjpQa0flBLRUJ/GpOfn5yQw6A1W3JqGmQyefP2zcuXX4PoVUfSwPDp06srFvPymAGUuSiWLPZlbHqzvl8zOWY6v0xmG2asmxQ0Ig3KZaYGc4DWelUNk4UYmZYcTXJJAf0LqWH0ppieEFCRiTRmjSwCL4Jly0uhV+3tI/gpPmYBr99yQiQx7iMUK5aAVFU1h3BtB+CYfB6nsBmRFswWvIgLUtGjLdemjsNbOUeVLV+1VV4yQh+y7QpQzMR/7IM04W1dYkbj4Cs+eEqihwGK2zhneJdB/QzAn0x5hTKLrH/n9Iuni7N1cf/NJP3Z5u0LPJYmCoAU4WkVMGzlGWsa+UYLHHgl9Pzq8oqFAens3gp5UUTG5v2aMEbzUQXhMNHzGesmZqCMke+MoTmQZzJmGFTWP8wogjQ78Lp4Y4V3LlpTDVcdlKnX2YeiCuegy3BU8ixDzlWiRhFIexKy4VtyuDO+JcYc24wxnQKaI3SHBotvY6uMceaxG/Awfq5p3CRxepBn20irWnLUXX/7BKDeyJDoFlmN2pYStzTtCLKdM6ia+OvY3it3kD+8mLgKs/rGd8fzdw5O3zk+jZTSYUYUp+OZXs6h7TdvHi9tj5p7bOp8giBEOJ9OfZzVYecgoqzeilYbbGUs02AbuftcPqSuywkOD4kgP5gzIKXPh94WvTNNg4wq0YrjVRDkeqKm4Z6jGp38K+FDz5q2NAelKrnBlwdxsUo18zvZlBSG8AxeC36mk9UzuTJ/rtFVpnKUw7EaEbbvHpkgONaR0hW5zzh2FQ4rsZiL8guKwWWGBMtswTQOYUDx8UqAdCaR3LHTP9Pyb5kIRLABwmdsO03I1GiyKLWs92pSMJn+nmHmtHhi+twBshlyZxB6BTzUmgGCAr5KEswfg8waUNeO+JTPkoRNLfViWrBlUpywxRBPALgQlOdEph2qTWgiuZx5BmJpVQO/A7G5taqIiUNmi0664QvUWjZUeHT6S41aL39kFstYYg67NfNMA2B9mWnfITLRUVBfIB20LjJKDTiLLcGW8qnLWD73dtyJoyQKezdsysl6XEb2WfNAXMG8IgFmzbuBHQrrUnvqcxBWWYuhvuYGpRmPWe6v0uwyW98tivv7N1fJzXI9XeRL4iSeNS6LfMOr0/SSMHA3S4QxjVYhFGQ7zmySvRU71icTZrCo2tC6gjFmi0l3QhAFJlomnLNiHJb4BHNkIIfm83BlVhq9mkxWiw/toSbxniKP8rQJ1/MkgyI0M+PRByqKRMd/p4fn9jAOfmnZ8pkIPD8kthW6UhA7pbEQRcS2q8KuPO5FsML8cUd1TxhH/TCqWBa/eqjZd8d2OTF9+/e3oUvweiM/XLZ/r0NRIzGeslGxcYn+D2zMmgeMeztHz+1Dize8UBe/t10xZojTDTt3XsZ147RV3FurlrgYa8VpJ4xxV6vqgzJ2aU6r1BugKY1SaHRv5ohGH0q65jND0erQ7TwKADyzOldE1XX1GZQJiarko/hsmFV67pFVfzwpbk7DqONa86jMG6oOd/MG8WGXwRwS70BcQ0nvCQ25ntmgPM5lsPY47Pbl4obuVGKIAMBUFhs49M3fAYYgKs16EVbin0b9S9go3OU1BCZB3NVQ7ba5HeXpuiIUxrNayjAYClfBPuMPpWiFxvkD5LLtvG0sI0rhXSCyhjM03i9Cm14CDIU9xdyQWXwKXpzxylptVz9lIayxFvolqBDOpJLt0QNWRAIQWaPU1NJ0k0XK0l4km4JmLtkEHKY+1xKDcA3XG2Jj4MZkkyt8Ksgps+yTNLJszFtQF9UUt7CoeE1MArAVvEeOlrIqJKEmNHy47ZSQr1nvJpVLV4IrPICJ7H8KV4bz1TLmPRAk4J8dPZkNtF4JISd6Va5UYzx+qgBND2qw36KB0vmSYHIxAOnJalHc3a+/Wd4ulslFOseJvN7tjJUQm/XbdHqrDYCYQKXAR3L1Gwi+Z3eghNfAYWA2tTUA7FPEYbBes6wQApEFbqwKWK0WhAsu3+E6LYtsYhX5EHIc5M2spsZXJkpulZtkMJbQeHocIVrSyvYy0hBYiXjVDulRyygvVLfjcPJmJSeWvIqX51RXHYx2Zj2k7k7m/QSRDf1Exy7B1iDXE+6/Y8t5F/zclmNKCq45JtOPklfs20afeTR7kMMRn13UQT00qsSNzV4E5tx0rrdz3ziuUSmCdJWq6h0xpRf1jWuOHl1wNrvipEqPwU9UZrQACyI/9Ffo0Xx4vAF2ztzPSByW1fYb9HXX1jQkNu1kuFOrGpe9Lnr8sBcPiA9rwd4nNg/WatjPfdZ5/+krHc5vjyLUGjoe1XiAdXv7OZK1Z91a77ZdgJKqP28t633XeI+zanMWBckcxxqaMiwGAM6Z329A074MyAJvaW9JigCjGwZ1bZwWXEb98H3hEoitDLv5mfbeCyoig3NiZqRibvSGLBVmMNOdifElUlQRwBNEm+Yr9v23AWM0fKstLpmbDtZM3wrz6uEBtOxVuWEvT7gQK+jVtRTwGIEtMLXql9nwy3TCZBtw6nSTLpinAh1PAJIN2++8FRamojTTJkEIQA/CB1mHssDc+a80dH3/Q11ApyE9biQkEW2oXdEFPkIVPomTeG7C6PhPVUvPUNwHoHpqcAWK1+MUYLEXwI0yghUNfqsY/sg2B8kg6msukR5laK0uuxQhGKPIz5Kc2IcZVEx8mibrO+SyJw+hiKFk1gLgguVmlaMTgFzPbfSkAX4WBcAxU9AA7Ee1eTK5mORnRc4WqQuG26fLJZ96yqG7Jv8mxAM6WBeuiCWdzqdTLfbNslnO8oDFuRZssLaBMAE/4D6iALxCw4DeeacwSZnP0yS1CnbBkSXUuCvNXpCkgnUf+ZL/JlIplOXZgimN9Z8hcZJ9Y+bIpQQ4ahM9GxEDNIULH5NtbyfXcpQrit4jULUo6tXqV1viEIFAEN9zthT9+THNmHR0bxkm3/POUzKr7jbDvEeV4ozab02P5uMllpQ9fEbpNEh0mMd6WbZ7Qug/IWGVYw8cWYde5XYXxFrtoD6oReJnAvjDv4PBMZ7o/2IOadSneezbOF3xCsLLDG5ou49IUe6OjQBgd3UzvLxzjaEWzWFeGcv9QDr8sJdeEDf9PU7yXlICywPEHVAliOtL7OulPj6H5R/musNkja91dK2c4ft19Xjzhyj1DQndMCQGLAOAdX0Nty4GLOkQmOL7p43xgVHMCwf+MkNEJRpsXS9X2gUIiMasIIEwA8Cqyxwcg1qlZmT4pi7kVoPXgmVcVodqIQ5hQmoqYEhXM/6FesUGDAqFSUABwDzIDsSqbM0xgUa7woNiga+2XxBRAAsCNAPmJk/W0+yc6MSoNPyMAZrAJNCJLJ5qSDTZJgdQyW/VXZqxt48gvSTLHEyUHEF7O6uSV4RzztyhMls3av0J4cp/wvSkJMgwvVgq2/6Ltfwp+12Y7BemV13yVQ2KnAktQsVopsgB9/OpSvrzKzA0eFtNI73JY6HtPWoDwdf3xGksy52s2O6U+VMJ824UWBHz8NRDb+2i1BxIddA7LPOMOVE8J4HhAsOkEHhbyy2Y+7PhRWLXeXajbVLV1kiUGQp6eNRAbZZrr24WKx4CJOwWxaQguRdukNkPoBuLWVnC2wOo5raYI2hG+Z0+o25j7jef6EmC13ZHm2OtOTy0UhJV3K9yG56wHHhwKS1R0D7NpcrisCJPlmlxca+X2dsPz4+rbMuqVF/dqrwmMWR+AImdivfp6A7rK23nq0N/8McBSu7rhw/eBx+Qgu7bzkYJRcPfy3dhTF8PiDTj5qUAwMbtmnvLuIqBuNPa7U1q2KAxcckgh67op1lhDA11gkUh0WQUX7dj4ri0Py3nHxRl9rMcVYJR3S1Vr13qZplxXFunKq/EsOeZQyf9QOaYSNerh5EYLOp9sjG6ddp9o50zoPYxi3p0VodpiOmhbFB1Xvb5uZNYmZGsvetGTFt1vT8WrfyyTjn+27o/RG8uNPCpkX4gFcDwmxcvAZ+/9eMfgI+ZhQ+u5Tg7P/v6N18LmQHSUgClsKoQ3vqJcJvmsGgCPpl42aGZviamnD7N8+rmei8VcHzOSt+NNqkEi16D2FZLdpjhQhIE8DVELWDLNVvQkKf3WCFHM+/RKNMbaEG2GtXmjQSM+k+W7IEjLD1bp2xvTxAD+lTksAKhMjlmesemnsnmSlP/WRuQst0lW2oyW/6CtxmstDkN4hjDXmqpM9HN9M+0Y87qJxhJfdRXGEHF5Q80Kq8nhMQbGkQXHBcRHiEqYPSd8XimFZHW2cXR+rzDFhroCaXETKPeWKczAmS2r4KVzwz9a3ieVuOMf8DlPCjASq2GMA+nxexngP7J/Q/EhJF0gPuGafdsxbOa5DfZ5lLrnvEYlTc/0fvQ5j/HhwnThGjD5eeKudLntBUIfrOklZlwxTnLeWcaGqS39t7l23XBJKDFWc4K35f3jLjz1EHKS2trVhZpTImG9IK4nABL3YNNmdLszXR+SgsSKpCHfzBQD1IWl8Xinncv8AyDgIU9QikkfjD7iV1ewxWPyNsWP6C8uoz1KQnVrymFk7vFDV1jPfnaorximk+JcMRk+TnRQZF9XWqn0MF/gZ9TyznpQxz9IMW/6Lvp2dsnBlwHapr0S675roWsqNRrhnPrGxdKBhIH3jNb+tuDqQ67GncJtcyANscoavOPf2sav4xq28OOtgdiPg/ACQ2PBa7jV6mFKgcn+nQ4jOGBfWxfYcMtMoJbu+eEShS1sd9hdsW+jdNB1lCir7+66laqN5CUawD6qLslQD3gge46vblHZdYr5d0W7OfOHt2+jY7pMdV/Ou2s709F5YlwWWUf8/MAJ8caHqBK+5vjDB/I9gBN3kmV4dYbKAUyGfxES0slycn89P/7//mH/+K//8O/+Ds/vXrylCcAIK0pg8lp8fXz57zw9YQtejSEnvLuV83eWD9jo/fTE4bixQxGQleGsMpxWOE5ATGTwYdQLyPRRAAr9u4URAU8Fuzof393/+bNGybq2Dg0/AQMNVANxgaiwY7BcBag8hSCffrZvn6y/lFxclcwpyefEUEoeoHdMiUpGiYpUYVwgUFxm3meTT//8Q/z6SpfsVP+UusbMsg/K7L79OTNZs7KYO1vzxi5mZcnpydZeomZ2EN8w/Y6lLF1EGTKUBShWEGKaUoO4J7pUWU+OfiNbUENxKvbYQqBAZ4wf4heIFUlQHym5pvTDODiR6MHT+ttaxO9cADUzsJiyYIPQYV4M+kfAL38IZ6SiwW30ZzXk7HR/9v7t7Nf/cnPmagDNSsDQOeb5MRkJKuN9glFCm/tRRANgFrT+fzZZ1+cn14+WV+xs/9a7xM4Wa6v18VsPl2xFuDFy8Ub1vxakGcNLaSOwZTd3NxNWd5LjMMsH9ZtTGe/ef716fUJm37ShoQUNKKeJ6Tpcn2CXB5BWLtLHUJI/i8XLObWTC25njLFovYvTU7PTnGHPMICY+I/Xmw2nSPxv/oH/+Dly5ci5xEG4cuKFQt3f/d/9ff+6l/99xc8uIADvuY/f9b3nAlnOJv+FhiYw727BoKehFrFD3Xl7/ihftvjAi8K5x6q7uwBtt0V3nfuR6fw+3bYRyG/ecuwzk5Tjz7i74a6CD8bX8eV2wLi0pCOyKJkKN4jMUL5eO/5vlhqVIT0gGh7D4uc9MFRJmwOcC1VOIad2hjbsBofxCmoPao1TeW+/hDb0+YW5xzgZDHfsy/pu2a1JK7VN0rD9+QZ21hLMw7KMWKcb4z3apx3XJRW7qCqijWNY+jHWnTiKMcJNoHpeX/Vy6//6I94fSwAjTIh3NXi6i//7u/+J//x/4Kp5FpKywiuceUFWACt5fo54JwBWEEukLE+8Iz4AnIF+u3CkBaDvo7LANu8/lZxg2A0c/NXq3/7b/+l3hsFa9Fofg8T20FsoMSzdM6gMDv7M2DPDvT3q/vvT+Z/e168SBZsonkB/MyF+zQBfZZ//yRnMopUB0ELZAL5LpN59lu/d5FN2Y3m5/Ce8E5fYUTmozO+/oyN6kGwBBEaMuaRwObHn/32737xez/Bcr2jIGPiCusN6FTTIuHdwNPJhHwCCUbcmTyzmExmRarJ97wmLOGtwuyfueEVvPfkW5pIABpK7flDwhMHpQ3Tk2bMfYXuIGHRKw209jS7l85Yo6wX+pJPDEBUgBS24in+SoIUSeScF+Rv2JWI95ph72p1W9z8w29e/gnzuBbJ9Fc8pSGUICRCB6KNIvkFUZGiHXmJUKRIp8vTdDaf350XKWh8vUGNnOH/NVHPJr++vz3lXchaZKxxdtykJqLHEEhsVtcv72klxT/MjUq+z1qCf/nyj8WahRb0JwVUPFi5+8lf+O0f/fC37bHAU2scnK9PesrtjXZ8gjXBGpxpMm+6q8tn/EOmX1tfJU4gFlr/6le/fPXmFW8e1uMPdb7izZu3t/d/lk5/UNyadsaEiq1DBcafk4zoOMLvtZerglXSPc07cxfjDkbtrPj+E6eNsrxntvLbbPpy9rrbYIRas49XT35nFWeydVc/WzSELH4O0CNnVPYoe1u/BQ3WAx7o4/8Q/ft4xlqNoYnpx6fj3+XxtQ6jjPvDYRz6aq0+U0lsi6eP4Td1h9WX6uYV/4EO0qVg9GUwDtoe4dBjT9GHivn46uEY714N1Rv5jcsGMZdtB6vl23StnJFkrXrvOaPTaY+t0xh/NnTY2XANer88rFYnqx2Z705SQ5HQ73ZrYKRDDQ4LdXb+AGL6PhXFioWaIPL56ZkVkif8nM6eXFxcFckds0OYVW5LSoXdJ7z3lZk2vBhg+6UxRuVXCB4AJgsGNPRKBWFHo7XoArCqyTOa/M3iUOmhKeGaAqRxE+bxMKyvNQeM6bP/5BrwL4gIxM4Z41+ezJ6eCVEzCYSRbg3AgzsBhRacaUILM4kYQtdWRrAFSOudu4aQ0YUwRkbbZBwUA78CJUt/AGxRFAiuzeyZM6+IREraML+4aXSZeTfoZbchLMMISqUzzinBvdCup5lsVKXxp+acwICAgflUuBHDAfSaQMNEIGC98pXmeQeD/arraeVr+ByEDNzHS4rG7OGDJjNZe5HPcw2MnZ89ufymeJVupmtf3lDwBAAxC4VEWkCNEYqDZBmKk8LaLKc9U9bvMpNH23rqcQwRU7aY67XHmvyEuvISwJ4z4mka+dhW3+JqLe1FJ9SRhUzVItDQ7LI04d0ONJA1ko3Ay9MiQRSWgODxD62vrkIaSopssF7NRzaXTi9VcRt7ivJASkynGMJrquezqV7eJmYibP48KPfQQwbLP3bItIr5Q5g6t/d6DjbtpYUbzdmrxz7wzDink/MAgXPorPV4mWrfQ7m/F4UPVfZTvfEe6OwR9dbuJEFC9L2yu4UHANu6Ub0HxPrjTRlFGUXJVdzTrDcquor4tEdwR3Foiu2+xsnOrR2Lu3+jVujm4LntL3/UPEMVh8v4IeRoj0MP1/LSMV7aV8lam7Z63bDEWt0xBsQ0Jmtp8Xq7pWLCjnTclzqKu7OGfU7pyI7RzT3kjtbtQd4L4mqJ0GfpBWOsaXeWQrOcmQXy3Pg6Dw2Va0waGAeQE1g3OMXkEaBe8vUtEGv9+Zp5HZIqyCyElr0yrCVqn+vIpRVxKbGitQQ1OATrjFSfFGgsGRTHka3wqObM8JczlLxhlg6SmY6vferB8oDRzxQSTK+Bn2xNk2cXydlmeicszxaY2h1TuFSLhOdaI8BBJleYNF1BkJ0yip8yZG4rsvSoQ1NKWFoMcP2FtgVafcGAt6II0LSgLVvs8FiA0IEgB82ZkANPBvLRmYF/LOAMDr4HkdvAP+k7y2EOEtN1rFSD/UobjhfKFwdWCKgfks/gvbxrvuQtvlgA+kezMp9antbTFUUOkutnDf8rhIEShaQVlOg+Ic0YeXJDUMS0fgAyzyhsRbFKpwVPJAhcmIaDMMznyYBG7qUCRk6YoG8twGMEHi2w59I6YYx9Pr1Jsjd5cT5Z3xbrfJlqNyFmQ/EKYuIb25afwI34DA6/SKYEBcDzOaayclydRH0DZC9FbaYQQZu1NV0NGhXjWD0osBQXgv82qYkMiq1LmccJqRQq8riApoId/pTXCAVkOOKo7Eys15E24c5GBfw/7NjWtO4dcd6PX3zfiNMxl778mKYnPfJus7Wmh49n626A0wb1cQeHX5CdnIc1rJprUC1rR6csuZmeiqsPOgZ07tMWe1GgnDexp9w+nrHufTTBzzHxUHqMZ8bQDMl4D2WOJdq9pc9vvSpqeMsmatYpuvi0uolq1qv5lWe6ckp7ANBWtqtuM69PRpPuO33dcFLs6Ti9l49ouOG6nU2/l4iDiQ8WPWzRwfo8UsWdTfBIcj8ktqHF3Bnh/EAdjQ8nDjubGBAVeIp/jsaEOAXe+A9OZvUmc28Axr7YV7XA5saBL4r+BNq211z5BXQq82LRKcJgng/ITZO9TYQgHtcaUgZuMPQObLUBZgnR0LzQqj0cAOGLF0PjvLsqzS5YIEwGGBbZxC2oAPYX9iSaEW7EIqIKnhqs84ztQTXj3URSpj1uxKrIwKCmrM9X0YCzXiNAHKD/RBHwkB84iGHkMaA4VV11kmWRSPQPg80RqqAL1bB8bEJNk29O8QKRGKHXlYesohi7Xv5RcjUmMIWnUYhKCYkCHuMDxRZswzmf89OjIIEwgnULij0UMQh96zELv/qqohhLTy0sW8EQjYDveFYCVwVUCkiSZ9Ps6smazYlYZwz8x4rZ3Xp9raceiDRFiZgmGRu18gCJvUDhouALfmoJBvj1IIXBe1vF7Bqr4cwKLu2fCJWUflamhwKVlpQwvm8NISJ1RJXyoZcc2wvNeD60Uhew1rHGl8vMT2Lsh8luZlaFA5/Uk7vsDJmzGaD/4IuCKQ/UNPZvnH4g2+HqR3T/w3X2fjGs8KfSx/DAsT3v34mBb0a93w10nRphcwpQJGAgduzi3hv/vZMYrisqGmzWlnU7OUSuGeRs92GiQPdzcFU8YhFYOc0Odq3inbUC/1ZVZbRHTWLdOquEzDFe8p7gcXBvrwgcq0T5hdm/XSoG+38yRLjPjM/YS31N0Glv6APDKvbxrD2teiffJtez0xaKovyy0Sq7/DKcy+yIvsxxS1dfyDFZbQ2SCMIsZ6EooLVAl6AXEA8MpYFVgWYAlIbQQW/Zasnor/o8MEzz8vUNrPCw6gtwlYfAW5WEp+Ubd6tPRS3z1NA7o9qUzw39MueE2AL4qNn7qzUz7LU1pLQCvTL1hGrpK8AdDwcYQM+Ls9nkkuklOWsDhOkh4Ar6bMYINPsCaWSZdmScmDn6y2wzm2azLGUFsyCtJpwwDQYcJ5sJPH5Lm9Ez+q2NfQx+a0aQZh7xl0x/rU9mhRrAhqes1XCjkCZnTQ1i5xku9GzBSpnWon4PN5whWE6+ebpKk+M+FAcOztBbrTKfTHI4XIrS+MRyqhJx5BDIlQ561KAIij9gMBvy8zRDU4M0+UfgWT5RO62Zi8On3KvKTDrSDQHQb/OAaA3iBNLafhQWRAqzk69/fHL7g+xzVVvzugEmJZ38KnnzL3hSwvQveLPDqJY0wJA1BprThfP5YD3ydKPZtJP0G1Mad+Bz1jCgozlf/YKETnwgzTymNjD18J6bbD2BaMYDCls6osUj6h0z9jtSvxAh/xUjSIhM5U+8lfBDjOVr/lVZZcmOD2NWfStb3yY9qIGj/PkBHe17givnlo+xv/0r1jYPV3KE3+I2wbFyUNhldTBs/aLVaNr383ZOrcLui52/0btZHESxt9yWZzp6RYsmVi2mj9MxzXB6zJct7Ek4zOrg0l7Nfcrglm/oYp1aD/XBLQ9SFaHdE5oBwJivnnHr1KEm59t2Mdo1peHD9A/xX9WCvR4eFt1b7RgF71H0vuo/RNVQN3wp95Xepg88vch7yBH5tyUemhM6b9CuoTuXoahDyKhiIzJQJpCkGRV8Ms8GoAQgA1YB79geBySsHXYAz7wOSuPgmhiDeCE2Qa1KfAnXPMPYUiII7CiMoWIBbmoxIK17pAAfEJ0Ek2LMGsFAoTaV6L9AKUXaxB9+RB6aU07+lI3peQJwMmXGewlTmcsCJ71rKs81uUVVCAs0Jk4eem+YCgRnmIqXaYLFSMNM9sLEHgs0ZA1qAU3NDsl3Zd2jCn7QqDzcdF1aSj7clsRUSvs1BKHAabmsapWV7aMktCKl/brM3daQTJwleziwzlLEbDz5mLJPqmb8MIOIEAe4DpzXC7MUEaiOvKS5/UwlsrbzqV+8PUA9gblZchfD+Jvps80Jrx0jPlutZyv5LEtWU3hDZmEGAH0ORxylef6a988K4Hw+O6F92Vp1wZZAxBtawKG1Coi23qHHEwobzGlKU2TdQfN/8LIU4JPeoN6GLBS2PLJ5KOT2mrmU6JPSkjUyLLgwIj+Zm81JuvaEM7FyMoxC5/2PgyrtL+bQGsGyYP+hnOQ45xZzcLZeFOfvlR7Wbbh0L0Ex8QN1dlZth8QiPqWP4uRONz6O572vtbX2/E5F6pkVoe6yrfcANPliw86jN4LxmoMxnEbCkPmBjU8MmxxHhHG6UavhynjEYrhnBH+KzMYD4rqxlEBJZpyOacakY/6dfIYVbohgJCB0m/GjAlW3bDA79HLXOErQcLyA2Et9tdr2HiDImXtFnTX0W/6wocMBjups0z4TQn7bFi9q5QuqckSjjDUdW/RG3DX27/wNw5rFwo+V5dyumE/BrQKPCJopBaIGwS/Z0IaDAuUbVlMtw8hGSQ0y+K8zjpRPjU40UJCn1Zspo/WM7bKtDaBzDpZfCxEK6ZtE0CAS9cChWD8jK03eAiinYHndvlikqsnpzOSZrC7I14t+mdbOjvtCoWds9rlO3rApaDJDYZ9GBLMV8/6z4klSXBXJCXEMM92ZigI/oWG9SkAOkDFk2T2SkWsWJBD5MFKuCUOb72mqixA2VLJGZspEEKYM0+GtXxrvLhBjx7Oqy+FnpaonMKvP/ap59uczvk5DnoSPCSrzqeU6uB5cWBM6fyCy+xvvnNydMlc/+aIocA6e0FD99eLNZPab9fKbdPnXlstbOj4LJCwMA4jb6yDoNXpIo0BQVtImq9lmdbJe3q5wCq9N0Bt317f5G+2GxPpvnggpwtOb43xt8GR9qj09rYX0fuXpenOfz6bsc6THBArLBO3Vnhhm/sQcskjjCXRkH6Mr+UQ9h1jjlbxOmXyg7oRyqyXGQM22Sr6WGkrwvzow2YpQRM0/tWiy5v0A+Py5eEaH9TpKvBXF3apwtu+a9wbL1UkcNPbvdCFbiehbWcs/2sWuO22noPieIMeySORLnf25sVLV0ZdflZef8ncjq3XZoIEzVWJNWjXqGZGlh91R6+zsqo2OopydFnUw3JkVWbGT9mCCw/yzR1uYZjF9nN6hduwBS3PL5ejzdrtPOv/DbGzrNkJz/4q0q9ZyevVxwwIPLi1t9+SHrAGoSX/ARZ/jH8DyQ6g6bJaXVm3RrW9oss7iwD9mEqc7ax2WOazJYTwbtR5J84YULoPf2kVHz3mXso6u/CDDgR4xUCSWFO9uaweVdqMSwjRIpqFW4BzzZwwUC2Rpn3UDstzHKAX8lTc3wU45v62LgDElInSYZoBMkBlwyVsFkowhYaA4EBEQDZ5jWghAlGtV0DB9tlgvZtqPhtk+mznYcrPO2OdFy2czrT6d3LOkd5afrbStKMgfxJqzBxDc2TYzvzhjX3qYAfLzGTt3zjbLi/SHT/NnGe+1TZkIpIFrAVB0FDQsz0BP4U0JWxcnV+esebAbuAjMWFmLudR1B+vS8rY+8Eun03nksa1WcaSiO9bPMZ8tsaXka9PI1URl5t6wNyuu5K3AhFpEXHiaKIqZ/XdPns7Pv/hpsflief1D3qh1xwb/z19qmYXxgKEQMUGEwLfSWEtDccUPOHERe5Qq7ilON2xyanOKeHxi7abF3AVbkdIiCFRl9lZdqYuwk2gyXd2v7m7ubhd34qzuJs5sE6S2QDU9CJIwSZcdpof1SaXU50wbilWTKE7xlfSUY9BHH/aCOpMsKqvkxSo0pnbpV5z9SrIsbQnyPMNy41OVjYLy93f5qLtx64mHeKWP55b7I6RQuL/BH0Hed55l3Mpjesu7ap1YrxGN5P1mgLDipxsXTwCYgzvG2i1D3eRqd6Ls+Z4ctrxsump8uVc6juT2qliNirVjr94oqufb2Bcdjh+3aCuOVqFFqsZqUyknlt6w5YDe6U8bGnxcMPoMa9Kt37hcl8tQ3wOPWtv1cAuObcga017x05hA7wzd25xdB9rlYP+3nzMEWegMfzh3tlHDoiNcjv5+7TXK6H2pv0dhX/VlE5oBYekSeqQwPUfYjwn1euGUTcmgjGkYTBZXNVEJcDEhXLc3sdKl2KjE+YiQg+cHAodZMtM+mOB0tvLPT169+upf//G/EvJDmAm3daST03Q6Rd5mxXvBGNnn3VvL6/x8M/nxJP3tq+89Ob+bg/wYSs6X8/x7F9n6+2D0y1Mm+CguAP0zEj05mZ/ML67OQZaT6ZSNb7L5+Txd399tnv71H199eZUtWXiASIUGskADxkxpoRUY47eZQqiUrrPZK7anXDPhyeCs7Bai1AMQ2Y9blCWjy0MJc8L27KPIFUHjU6P7/Uc89m/y3M22f5H8rUNqbD8l3xCyKUZLLK5+/Plk+h/xIINhd960RaOuCqy/Ka6zF7+54YFJPn07Ozm9yW5pHOD3ZgLNjPUQetbEgxk9BeLM0ulVynqLZ/niPrlb3SxZAzDhXVt3xeo6vZsSVqz07mCkr3gjcDG55QXEWgCsqEA7CslZuli8eM0Dla/VoXC7HUL+aXp+cX51xTMKrNGjCBpHucmEt32hN51EvVF8KOLTwgW2JtIjGsSyFytznXiSQ7sQjhCrYLu6p3o0XNxH2TdlwtiUTaQ0fdIpvICzS1J++/CyiqZd/ng5dqet3XtHyGrT+z2zXTX+jWuXjsrpuY/F7xcaxSciOtoduEc3F1U1aiR4RLL9O1XTtueXcQTjD46k3YtGqRh7IE5Hle32VV73tULcMw/UJJLYk4wV6SGp1My/6ib2Z7nblXXYY4T6TdSPXD/bssg/Gsy5HKjZz/PjLcHcg41257Ud5jwbPmmTNQi4bNDEl56Oc9rVHy+n0U3GC0Lhg+uOl3Isyk73xplx+oFCY8+8bxch/6GWuQmRITWeBvUlQyhJyElQnJ4hFMVYukb8la1cwXMOMnmEK3JVUi2LAUiZpspQmaP/aohUWcwHZ0Y+u0myK7/FDIwmgy01givAbvyEp23SBgCeXSrXTDFZLIqcsfqcoONuvXo9uZunJ59np7MJe82czFJigPyMT/CgDSELxktptixdzeHKXB4eKtzz0GBS3C3WvNJqTVABEGUwfK33mAErZS0POmSkJrDILrAyKUb9QZUsCZC9mlAvbEodQ5mytzRautcOs6aWs+9F4CCHVpWlW3SE/DKvIjX4b3lqtU367Hvf++z7v0UkgK0WqbHD6HQyXyxfLf/N//0Pbr95i7c2t4vp9Pyz789mp5vF6kaPW9bMp8JSHgKx/IKFAdoNlGcwXxRfbNbz5eZ6uZoW0K5O7n7+x69uX78hmWn2jzZPJdjgPV1zHgKwCBu38dSBP0zByTNe40ar+eQaeg8rNmgDlIeCtw3TBwrUk2tVkcZcLGAtL3hXI1t2qQZPGIAUpVvgUwZmFOhJhzUbjUoFOLlDnKlfPOAMu6b3H8DtI6ta+vJxtH5U5sMqf6cbddg177DUO8D7+HYNdD1Xp9FBdGfZfRuouOqmpSG1nXeOqkLN55E/fPyvNwYajHE1vsURx2HtnJrg6CKuFWWPSYaY2HymGp4I+W0mwQ1x5BdH23EVp+n0rfMJ/guJuHpIt8eDQ1FIxCPEcToQjEyMkTWGlVvU55k2h2PJ7Ws7b9m23DgnbtM4P07HejZkhUZs83m4H5AV972QjnUbTsfa9n5P2yya369SsjiwT39rv5E2g3ZOXflwZYktirLBVCATQBx8Vg5X2/Y4Hg9oRrgwmoFi7h6aFyRExUDtUwBakb40ZFay132uOsq+ySUpXbD6k9kZ7PYjaMf0mpVWnAL1WVcA5p7DVoRQFWzuyQb04HigZA4wZ0d/veWpOC2Y4q+3XwH2bpjZMimW69VMS0w1iAu+A/gxN0VIV1vCnPJhKwKY/c/Wn/a2gMnkAhoFO7w0l3UH7M3PBCR72xeTVVDM7pCsTMDwrFh8blCVYIBbpYaaZTv6y35pO3iUPhmkGS5sSfD56401A1CZKIPFitZ07WAXVMxAfIGv8CvORHVCr7vs7qJ4/dXyjolBTBHK16sF71MAgme8TwEnqjocWYFLwMOJNPN86Ck3rJ3I8jtm3E+KGxp/QXMuXjxbLk/yu8n6apW9XWdPivntspjeTK7vbFo+2y4RPEzWWvibTW+J1VDP3j9wSSNM0ju5QNpSfqFU+lYGaJEGZ5L2JjeaQY9r+MAkMnXoCUF1qNnJQkksVBJCwhgMURCQsm2pHZilzouPRH3gUYo/sPaDq8V3mDHM+ujdA/sas4Oeb1CXTn4/3+MXs3k/rJiORyxVje1nm2fErVPtULfvlyX+neL3qNGpxt//x1MGlUKir30DwVESsZSHaPtwZWJNAreG50P+MRJ9vHWv0RHdS3LbBW4rlF5lNEbSfAIw3OW2TL41qeDIkBg2DbIxPoq5hbQnKv9v5Yzkua3wnlJtzTsVOdickfw7hTYyj8iqwXnn5cHm7+T8Xgm886JCSOyhzqg6tJlQkM7CRKzUnLD/JuhXYB+AJTgm6dAIUxm0lD56LKDVwErbkLkVcqmcmr4GxYwKPlThRVL3YGoBM/9TTcAlqM7gGGWChUwTJzbQjkMgd8mbsLMk48+oV+TT13l+NZmcoRiT2Q378YorHiugOJBdlgsi6qRRfIli4omsYnpIvlnwLuHJFHt5zy3QUDGDiLEOSgt+SIqr8C+Z2k6Ug9F/IKXQpw7O5helJdAOL6quHuHTpY5nLGe4QwDD1tDyMu5WjEScwyrfe+38z0wv2c6OQJrqpJ5gDz0U82GzXIFkMTKwTbW1VhAri4BRL95NZ5uT7+fnSXo3W17C/H5yenvH1j/nf74p7iDUXkN6rZo8zerT+81KgZ78KjfDx5xoGpqzDfaTLyIOkeJ7pgNZy6glaG62oaKGWoyTaKigFRuG/Anj9Cpg9GeuGvx5JwAPMdSreWNw1e5UD40nOfHhBdT81h69po+zmOp93unLH8P4gVqNEfGoNB+7/o/qnL2Ytz35kH41WjRC2pK9drsIyqGbSCm04mdjFrm/ezKaVexsOdvc1ziatPoUdB+dMZBI2zFuzKBd2s6J6fvSUdzsJCMjwrYX+yR4fsP+ln+atStvb/M9x8/OrcFzjzEJ4xqPOsfprchDU/EYQ0PJTpbuc9dhp2c6OSAleMy5OVlv7+rkUu0pUatlPcTX+1NpjDk9vHdkNzgf5oeGjAbPRmm4HNPnaz4JNfdJ9HHwuePtJwMCZxzdc5crwbS6ABYAarN8xsjvYvNrzmAoWop3wwKY6BkZaMn4CHRp9xsAN+Pjwm0C7kDC/LUYkmF8hdhi16lrcdvT3BlDolSZkxDYdOkCodQBlM65/ykpBMg4MViecATwttTU8nKmDmt5yX2SrJ6wB2meTVnlC+TXuwEy1vKiDbKZYo4OjGSDZGfa05O5LEz3YcGv5FB/JeyICWz4ia7Tr9X/2RlGEJLqOE2TXvTqA2ay6HmpWySNNIBuaFNKqkdzsqNEseXV0T5Qp5JQ8TTnNsb+vcwUUtJ+ZkxtV5Aq9iMllZmQzy5KqGuLHNIFu4FOE4bkc3ZHKlase0jZpZPQCxpcgfdB1PyHq7qFNxzT6y2P1WzLZMGC3bS4YefQLLtTCDF5lSXTWXqfrvPF5s2c5dhz3tXAygx+ZZLlislUBFE8bNEcMp4dJemNofAZ3mVTIVP/hhY0odZrqEaj+eyuMpdex7Mg9UipptisAvLEJfRYbTGaq5yFBGopHvGIXj4hXlk+4yVh6eyV+cHyqE2JrKwdrYxa6bfqQs7hsDv26jMlH/K71uVM8fTjIZxLFhFiGXMHriT3fEbceijK7MN+Wfru3m1Z4ynbdYdzYi/F6Y5aY347rNrjaduhlWXti9O8P3fgYevn7Xx5pnrSHqcrffxb4r1bZ/NkYX6wO6zodEOq6KvPkKc7Sm0XILvFGL3fg1TD8tpMKmYf/Wfw30hL3J3ulZFVBshc+gDBd7Do6D3Om+zb4cmPyJZd35TKFD7LrxMYTPcr9sK8XSyT+4vPnt3fL4D+S7bZYX+c+cni9l7jrBoxzhKGiTkEHgFe2nAHPoAtThrc9UM4sWTud0KEGbzSaD3itrJLKu2zo+klAFA9CdDzB0bu+U0mvdRSVVAsGFP8IRHv7OUkf5akJ5o5IigvNMiWNml2CmwnOkl4p5iUVgRhLw3QjB5WomqfHwU4oEkK8rVtVUkgY95ACglsMn1R2QwB8cNSUZJFIDJVl4qStlaS3l64F450lkajD6lhhzSuooAqT2NLWhyN7mBixs4Jj0DIzODXKm/hckI9KvFWZgIlPCMXFTSARt7142bOMdwvF9H0PELA+bx/YbHkbQB3i/zN8vYW6gyUtGIcfpJMb4rN60l2D9ZnSyexvUuTE03qYpjD1pawveuEF4HxgAEBetSAI80MRS76w+9qRCSaNFmDIugjKtFTSiwhctXVcwItL9FDG4I39oTVi43Nko1iPpYmyGoPPDBPQawEcJhYJaLDREXXcdJ80FUpJvpOpg92yl69/eiuPVjto2vynhniiPfbErvsf1ztdvcDpwhu0t0xclmXdrU8tmJmLm9g4tZCAZ9GJFqqYmW7nPIeyhvavrOdUrpMrXm4i8DzPPZtj0C0c/p57C6JR/F3U9cpmn2g2uWmL9omv+wmdT4HXMEHP4z0ZJt/rCGsxKfeQ5zzsbRtK9CXg9zHExpb3afAQfmj2qE99o8s1ewb+68cIZ8YajKklc5fzi/yn//y9d2v3n7x7AcMpS8Wy/u75Z/9+c/+p//xD5kSrjgBvASEA6tzBkNttCQTLAhHuwOKAsF+LrVQoTBcUSy07ySzsaUbJNTUIVWVBUQTtAR85hOmhoDLCDGYk56fT3kl1XqSX08nT2bJ23x1Mpm+zTdXUBCBTGc2DYW3ARQ/5R684S0BU6IGRQW6EoadaQYPL/UVvmSwH+wrg7P5nyU5rw74HZ5bTdbfkzgzA1Wkv+Amg8qASKnqKhOgmFehU4YZImo7lBMulIzbZXiHH1FD/1xsY0oT69o6Sce5cyVAoPMGCfriML0j2R9o0IZqG+3Mmd7dr3+aJNdF8evNZMFOnasVuJ1ggADB3Ei0JOis4AwUjwflE4JBdlbCb7PzZP16ls1+8v2Ls5Mn95PbxWR9k1wvi5NVcvd0cplufv3y9umGRwVJPp2eEUfpnQ9acXGu1y/IkbwMgNYm4OQZjfmcXBJqBkftdBxFLMXySo2Xv7GeiDlqaH3w9GZ5y55CCvp8ubGCQB5mLNabu9vrxaZARHFykiuczCcnp1OMpHuwtyyPhqiDdPEpm9E/qrbF3r7nbMsvRBS3den8nvHF3vHI0GZdd3v/zTrsPrN3Xbtjj/w1xPYwIlv6zAwhTdE7Ozo80+f/QZ3esdqDumwLay14kF3OK/ZSnN5KCqn6r3bIflDCNXcWY/j3WLpD87aKfbJ68rf8uc981Wane2aVq4TRVDkDnb6qpwfI0ROA6pbjLJ1P4MJlxfmdfp8q+x71M1g2XgpVgm/atSoPt0u6c4a5ddf5IHMHfHKYvs7wgAaKxQ1U96Kjqx1Lj9NBExLeScaLDnVjhh9F2i3tUJVbTmWVIUC7Em6a57N/9vv/v3/y3/2/L88/y6c5w7rrpV7xBBU7acIJOA2KZmIN00S012JOVACoBNbbjcrdKxjFoRLlAtI1A4fK09l0xiJebeiocqAb00gYo+X1sFNksy6Vmf9MQWHwnunlIPfV/fKL6fRvPDldLi4n6XWeXMzzO3arXKdvsvXy2Tw5O0EXApAst+XEE5awaqqPsOkmY/tQ+K2n55fzHz7d3N/w9lsgq9Yg8ByDe/vp2Xq9nKEC9iuoAe5Ly1L98sarq8pZKuYw7ZXpiZBjheHUqBTy908ETuZOqx+yurmVhPaBpRqtL1uIlHLxGROc1O56djM7++yzL/69883i7d2r+9XiNi3mbwHYy1UCJBYu54mJWlOLH+gCTJ9aEk7xj+fY6hGsvJ7Psslq/r3V/eV8vt7c0Kzr4nq9PmWR8Wzy+b+6yX/OFp6K/WgQAD2BmFpNr2zD7wB2DvjyMIEXFRdLYg0Ms0c0CLZwzAR7sOh+t/BP7QZLiFdr1vaSR2ihp0hEGkR0pyfzr7568X/+P/3916/f8CBDwSCvd75PfvLjH/+9/+3fwzbCmflsRgSkSA9nBGGVX93RuGzgEI26eYOE7GZWg+Jhl65a4KFmPabEkcwaWsTqhPSnxCcPfJQe6P7+9nT5buLI7lBPlD4FqPGljb9zTu0E0KtOXBzxPSzZE13ty6wWm+5beX96ucGOMOrgl+4a91lJ0f/RFdX1U48rafuhPYrfx2nMswIfjxlpYJ+gRn7Dh6G0Lz8QHCvh5vS16cFS2vr718jFjfdhaJfxVQ7W+TEq9qpta1jLUvsQGpyw/cv9cvqrr3/Om5mSyRsQGZsxcmbjljzNvvzih6enZwapNU4vqMSsmykbc8KhjCiUX6JNPA6ic3wG0BMCnU5nb3Q8h0ozT/SfqdiMCjNgv3n99rWmbkzuWbUJZ4ZjwWZrXgWWJM+K75+fvkonp9N8wXSTWbaY55d601een55rdH86W83PnuZP/jBdn09Wn2fZmea58Pqv/HIJnP2t33z2t57k9/+zfAO0ZTNKgCJBB5OFfnejpcWauVRN6+dKMFC3W5llpqlp/NpTpJVjHxAwlea5zuvPdd4eyUSzqEvi6uZt9GXmlrRKeWl1xaciqOholavMVgI4Xcnd9NGbbikto5dSDT7MNm8kWgjYy/b+19Oz2Y/+OkA6u3/zOzykoWmuX764vV2tbt/82X/3y0KvfAaSM3fLVg5jerJKM6bx8HCA5QNUuMnSWZLf6YnQ5I2CRNzL6uLsBoKT/PmpNndaEjEq6GD993IKPucJze3d25cvT1iUzeuc9YqAyZoQEeW+WV7P56fTKeElzDXxjDPNzVvY8jkBIkYwZ0k/YfRPwX1FDLdXz+hHT0lTB2Lyadnl6v7Nqzf3vLBA7lSIQJf76utsuWARCE8vluq/im9wldo7OqxGuO4Y47cy8s2tgbBKKKLoOnrGHWPS8hcq+o3u+M1CKgcqu3hPxFyqdEfdqmj4s8GyfV+lOsLjJ8bdrqiLCffVerau6g3QLh+V0/4tHlVtNFEf/07/jOY6RFhrwRH9p+QV9Z/enD6x7bp9lPvmu/5j+I+3dFCHdnu1c2IGqy/11ar5PC4u062u6hmqGo46TfhuKDteAxCTkXYWfg5FZX4oDjK+W4kB+4Or+jwSPBoawikHePaxei/5fQa6XUdUKfgnJI7IPGb12Pwbsrj0tnZPjmz3PrfHzD+c9N7aqvdoiBV0lGZM+n/x8pVw/Yy59RqGJQgQIGb7nVl+enoCLrdRYMP5mllvIN/wE1hMoJjnAeYNg1OGpxUt4Hjjv1peX1/rgYAiCGoolnAhjDMrYtDEdM48XyABFt2k2ZtN+popIuQDLMnVNo5sIglblouyoVA+TU/uWa9K/MAkn5xZH3pbGauBwYUFoDFh388Vu9AjjndFMeCM3jKKKEBKIBcPaFZK5TuuzSF2BhSSXxXtaGjVtAN6T4eEXwaCirDjM1TpKBuT5fU56yg//KJ2ZWSaGY+q4Hr8x5OakycXWuC9SadXJ8+ml8ubF1//MdNnXmhUXc8RaBv8RKfQYxQm8RM4cWFlvEGANtMCESi0fRPtwxQs1eR9zKcrvZOXJd6qSEPyhGC9nty8uS2KF7MTlpnQb5iIw67/hBDM5Vmd3G+effbUnx3B2TqalnFTCgM1XGVTkhLUJevp9PTszCZoqU+iLb0HkbyomIiAjkr3YEYQqw3IwhB7i7FsklmcnKf6njlGzCXCxYxptlKdd/cR9HSRj6DjI7B8d+55j5K807xHBT6Jfg8e2PltqbqFDeuwCxBrjT3OsJqcdFPj3sUtlE+PfpSry/LnRCkjUqI8tnyqnPJzOMYaEV31co4E7YqTItJjJIOTGzMUPb/ycE1SqOK58qh5ZvmZMuDTIKhVHn3xED/0PStojJRI8xH6jB+HaPgw8I5tGdMHQsV9Ew1z+vRxtg+3a1/1vF0aSu7LRPTD38RDOPbW2dVJttYIJTkbg+dgtRXvdZos7jeMx2qsVxMzIACC54CkFbM6tDek3aIMCSbrK/B0nrOnJ2jrlWF6cJRRGGPFFYJqUAtwMTdnNj2f5rcanZ0sJL6YGZIDUdr7vxiRJk9njc5ONlcJ+31uTtP11Sy/zrP1DDLwKQO7DAmjIFNJ2KBnBrdz9neZLP9SGZKgeXafZKfM607Z/381SxY/SfKlVgRMfwke1Ki5pOjxgr7+7HrJMgBtvyb4igbSQoZwbB3m1x1n342nqmAEXtnu5LqGieeERAeb2jt9m7W4hoNX71Zpm+tj/6550GpbXIo2hdDQC2inBR5g2oymYGndTs7bFXjl73w+vebFvhtaWVjf/KVJrDZthrH5KduHaqdWraMgcljnrKvWtH7Ys7KYZlecNWclx4RHLsvNAnIaXrVEkJ3M56wuIVz4HnO50vytgggCi1w9AvRPS9NDlBCCZ8YOIJ5JXmTqO0VUoPUCeskwhNjiv54esykOsR5OPDul89KDsY43zfFWifVmxSwmdinS5H/4ygfmDz7pqGVSReTD1ErDuXTg9kPVS6Jt5hFSw7/RlcJlCx5BXpOFWxxy++7P4+/Mzqrv9y4IemCi/P3qu+v25Y+WGv8+xpWCf7zjxEXvJ93uP+2cSLPab/0gZVRpn2TMM07vw+MA2nZ7tXNitnGpfFLtCBTTdKTtLlDdOzrKVWQ03J/sCYACAcvQD2R1OBeuPCtcktgSVcTfpc/KWfvZ7LWGPfcRuTaYE3QOHWQ/v3yi/gg88BhtG32NDKxLBnmktTMOE6RB+Qyy+yxxDQ8LpoPDtR4XUA7yAnIZMGMvSchK9CRvWlQgbqa3huvJ1Pg6I7LCZHDz8WZRAu/J0j7uSGdomPiC6AJQiA6APn6kNY8ElJjNXmbTS4aWiTKokgn3a28iPT2YJMw7IQULIgnmnGSClVzae8MEJEGtSCC6cLtt8hL1NO0HS9hTxlU07Ci1sEK0fEqTrgOjegr8Nu6F5gIRhgS8PN3FVHkx40AZEqF6nLNl1Z0byruLgx0gYFdVJhD62fQsdl/NMgbnLy5A6ERUdAzFSIL7ei8yKwD0HIDGY8t9e/myFtmqURVDeX/K0jlPF/JidsF7mld6P7OeLoD/1KnEyrrEXLus0hXYDIhYjbcD0zeYmIM0tYUpafpZV6EqjQgb5WsVM0VqT0+QqV6HGnRRvctCJevV/YJaWupBXQIZXkSmiWs8akCuKKKmMQ+UUkv3UWxKcEmy/4CV0VXE/ZTHKWko45fvSvhxTPgguYT2DokPUs1PSr0DD/B18tv6OFnD377qC2u3iYFdgPgN46ioS8kVa+1FwHNurU0us+J4pST2jwfHWL2ca2LGXtTiy7GV9qazFit/ed1Blee2rHwEwuP1xpe8eWmjBeVIcJTe8upPNcbv+wl7S+KRkjY3z2nssQOvMA7Ry3efArg1euI+tUfRNnzuddr2HsWudmcYpeIDifb8JvZ9U/r2IYnz48aK8zssMKymGw23OJs1kb0QxjagBHLCVUJZQkwLFlZq8o+2SfFJGcAmgP0LcWX8lrOmdeiDAtJK6kAbv3/qbBu1I4CJ98lmxeaMguPQaxmwkQEEiTWsLmPzDAU/R956c55ufrgufjHNGCtGyjrP5mBEzQuHEasUGBwmPNBgMzdVgoYpI80Zm4EWq3QzL1K2mgEwohQSmfDO/ZMgghZxmA/8Y6aTogrpU2qL5pUFZkZ8qgpgViU9IeRZz5H5foQElyEdiJ2GS+cQCMrKh35E/KOkCamwaqkMHkKoe0Bj7qRRBocwy396gnwN9yvq04762vcpZwh/utaTEvoJsJ41FKB2YgE96MGNtCjYHg+v1E7JYqq3J9+uk1XGjkxqDUIEIDltcUKTKBLjCZKCselqvVS72uEziMTGF5FTR/0IDiqm5dCbUq0jp0BryhVWyjaWFPCsQJGIBR1MYyNIUYPPNqxSIFJU98Yeosol2TLD+ql1U2MPXx3x2TLe16njnuC6obsnRmrmvo3uSB2cR7KqyMKd+YHe8icJfahjbz0jGytN7bMnP+aPU/1w7+7r46p2+Rlz9qx2TqMKl300ffltDvvm9Hm+g0/Uix5Pnw65w1mRVsOE40rVnffwCdTeb/q+j/7jyPdVZH1rAJxL+CY5RzLjQ7/N360j+GPY7JhspI/aZMPf9uHSYfWOWIraoWt8ICod0bpPrKLm3c8Zccfoqln2Gu8zIhb0FwYC+zC4yxaJwhM+WM+m7XoRGABPaIsC1tVy+xJCdLzFAHuYKiMIpRhA/4SeuBQI001Pe634XY8nCRQSA4iWQXg9H9A4v2YXgcw0MC8RmttB4JFpIPh29vV6+g3RBvCTlaa692lyv3ClbqKgRuYBaSMgVGWPH2AfE0qE9QRYNeDMwDMf+WZyRyZyUQwNUQqYK7Qq66W2EjqkuyVqJy+LskKG05detOpQdXCI6pIM1aWN0XvOzop1NgdcSU6Q7vUtS4oYMvdyPbjBcfn09IItlsw3QH9+YmfZfJksAedEYyl4HTK19sZesaanQ0z8MfSvLqPXOHBJPJYkZ2zhyfC/nuwkU6IF9RBmBtEgIlSHUK+iHXi0RIvBlLoKLWz7UcA9/Y5mUol6Fz3TKioA9D5JHyKplQeajaTeS8dbspPVSjtZUU/NLgZqdgiZZwuBMxRP/nOI/cdyyF2m+Mek9A7nukE7iN5hsXcL9/Q7FPtJ1IfggfKesIcqA99E3b502MCJBwDciuKe5eICiy7pfXsR7KHiA0j3jfZi+j1iKYvk/E2Ee9Rq2dUeRW6RKCO4OXZ8mbbRgrKJqpGDRit18iQzHr/voxmfH7iVfYialT4kSw3HszsWZRRzx20ds+/Lj2naLi2fulS/x0cxMPQHfNj3/CTWqi/tFnnpQ/qnjXlqmLI6Sivzr4I/PFGW9333980vka7BrUg6DxZ1OzJMbwmBdUbiwdLM6gagCyTrAQF4TmhM0yhoJjwpLLXtl2grTOdYy+b3MELLHJ/bzR1M9BjBhz94psCrWAHhoDz2+08YUmYaOhOBqMqyUUAbc33YlP576ebpLP+auf/AOa0UFeJn7hCj/sB6UPxJsb5lcJfyzfKkyLRbKCzhlBQLdv4EZk5WizTnHcNoSw2+OIb2GXlWAggo6GkGqGdUfa5qlfDpfvbnKmWmW11V3YJHz5cnQu0oQWaQEkv0dET4qElJc4mmpCb2q7nlHLUdskkwu/+HWfI8nz4HyK+WK82uWZ9kE177hevZWJPZWGwA+oSak8kvaQCY8pIvJmdNtCOQtv3B1hW7ACU07n1SnBpz2G7S/Oskf5umP1Cbq1EIDHM9v9FstOVqpUlHKZsLUb+40vMn9hTSQwFCCHSzqAB17TmAO56165P1lQUHLwgLWLfAcmJb8itTMHbFYgXiE35ZeFUEa8Cy0zT9jfQrD0vgE3XmkKkyLlgho1T7uxbnVwwg9Oll5k/Vi47onhnl7ki27zPb+6rc0XPoqUp8hzE/12nbnONyWR5fj0vvuyrAuYYnCVshka+G9dxWOTS1k7/3iJHecDKv0uZcy4lsjHWv0UQFffkRyeMnI+zxiPp473VruC/tPCKtdtIekcAmknZ80+M7g8RxJ7MOYfvFPeQJwBF1/+BZjfy+PcSO+LtqzVRjRimt5t/kuICcd6BbLDFON3SOi46bbht+XP4xN5c14NX34nPvALGej5ZutOqBvg8Kh0SnwuIugSAofYKDWV4JaGP4VtcAc6CajaWDtgB5Gjp1WGOQCYCjeeE2nLEd2vBvChWLL774cqod1sHcticj6JxJH0Xx8tUr5nzoTmitydAxbEH2c00EYQq/HhAUwD5Avkbni6fZqzz/xib/SAHG89nmH21YuAtAZMpQNtfeP5sVE9IXU1aOfv40m865vbL7C8CeOSzZBe8Q0LY0RDEIlRFmoRwgo6SKHFHCPiUbR0dWTNFbbBJiyjJNhUiFMrOPuKP+EbJKFbbot4T8anqSdmZVBeXsscrCWSD/Anez6oNRdkA9rcm4+yzJQPkC4cRYTABKptPJii4kP+vhCtEhnt/M5rxZoDgnzKJ1cfhaDciznvlqk3/9zXOWDmudBk1OY6lxaazi+9//sfrDWitS6GZ0QVb7WkCixwvWZfV7qlDFeiobCZ2fXyzvTxn39zlE9N2319dv3r7CJpvlpUrEn/RtQkfCAb0AzsoEkcVTlvNnrfMgH4tH7+FN31v8qUBN8G6/DXv4/Iit9yGbuYdH3j3pEdvgXSpvfdpvDdyATLJ3Ac8jw3t947Ku4jbur+erbqjYKHp/lwdGhxbJed2GS/YyxUeRx1RxKU4ZJHoiLmqwOmyco8Fk4DJua9JoEo+RxHoOt3ygRFZIkxiu1VYs1qcstZbqyI8qH9gHKg6uMFeeCJfkoP8BVjjjMX2j7ylB/o3x8PGGnvEbl7LjXBvVcFOCfW7cDgbDxYFXRCa2grzuTyUMAQOqwHSc7SW6ytWaXwNagnE6qKFh9afQJ+mNTQdaUuSMxJDDGHNmVsZ0zqu5BPSobagqmbFR4/nFdJr+7E//lL2DKNNyAAUDvA6q+Olk+kUy5VpIT2PyCSP2PJKYr5/ljOtPbyBjYgiRiKIHkCJqTFa8NbhYvyV2yJO3i+s0OU9+6z/7u2w0pJH+hOndIFTN/WAzIUN+mipkStpZ/R+NQzfytOzoPmpj/3WSXVXr1FwdoXlbPPfPsMCnajbXSY2V5N+o0VefAcGf/vZ1fnaRrJ7evn2xXmV31y/Wd+ni/prHQG++/rq4vyAQWG5+SYsvmeHDjB7WYxMpKP4CgRMUECfe87DmJyzMWL++X1/wnGcz4f0OS3D9/fr19eJcz3M0J0y9Lp3MJ5t7dgf6rR//dLFcXt/ybAdY/oK+ROxHdMqWPsz2ounlQ7UgMqQzkQOvJd7MbpjXw35TmjhE11KwJ74KMzWNTPtZJdOvkvl8k14X2dJmglFO0Bs3YVfrtMf+3d9d+fDCFtPOieJz7VsfF+yTBkFoHeCu4xiyYsfskleWx79TI6tA1vg97WqE3pnxO6Q85C7dYt3Qs1W+zShN6JGuXsLhvyOefufn4d/ucjVOj4Y76j7clr7e2/PF6hP4AD1rfVD3f4agWt87PTUNhzeqadi8MxgzyrOvoe56AqBaUX3dubj0cylAQxjKaR+BrLO0Tf8pJ/JAcJ7nuQtjR3qzRDXef7Kh874KxdbtW/cDoQ+NEr40IfGBaLinGsEg6sXpPdn0ksNz2+xKcTtRNwIbaap2pu1RQHJcAJZKDYQENfOHqRTKEXIGVAG/RCVsr+qaNKKp2Ka2JfX0llFiRPAfLKY52evF3d0Ns8bv724K1pZSooenQHWtPZ5lF2fgfQaZIZ3k7Cc/S8GJydn0nvdJaapJpnWovOKXDd5Z5skuL4z8M8+/0L6QZ0zvkfzN3bS400sDNEUEI7R0WW8uQAmk6Ow3aynGRf1o59TLB646qroIiRw8nGAn2SCPIxXWVVFjcpxdPbt4ejnZ8AqIWxYALO/e8ljlfnO7ujv9o//mv+XSnsNoIj6bBc3mp+lssuTlbqgEpmfBLqHXmnk/m/9o/ls/uZ4D/e+LxT2LfdNFmp7/rHjzr5n3RUCnpzUC+PQpojne9nZ6djGbz+5W9wolMt7nkBN+MpnftFLrCdHzWfU9mKCJeYLOxvIBJokB75nGpocHPMJQVyAk0H5WOauUk4Thf3/Yhd1uOrR1H0SOpSA0cpyOSN5lMujyLoW+Q1nY503xDmUeX9S3wITjO+Vj4lhvwDFfuj6amJNoup4AlI8z9dtpM8i9DueIaTOqCKvFf2NksZhHcHQc/TwgrtpDM5dy2IjCHmJqPtatJ3J5Lxv3xvjxAGcUZqL38q0KYm+HdNDtsKaO7dpX86BDpWD5WcvvGe1oVOFyuP8EM9sVGznBD3EiNjPQjxn1D8QknD6w3RbFIyJxekvxPlMdCpfqgJoE4J3AXVRlCE0tv89rXcsfXisVYNLbVC0GEJQDqb00yKUcxq74T0UhdoFFu1AK1MX0awkVhNQDgYT3+4LaWZB5f7fk3cJ2q+MRgcA/88QJAITq2RdeEzPW08ma2f2M1QL31pvLz773F549oWyl+SPTTbpmF6BFUlyACyf5dbGeFfM/2hRnyeYHk2yeru95KsDkb+mmsMaWhUqVUiOydaEBWrvT6pJ/rcOoWrkyUtW9ikKKrrqq1l2/xXB0Rv5cpP7OgeFKHW8mtsZoqOqKq2Sb8nSy+swqyLzN5BbMPJkstPFScpNNeQLzq/n5dHL9Z6vZHxTF7xLlKT6knYHU2qWVV0Ok6xUdYKE3hU1oCB7bJGfZC940wQMB/vkcsCxfvp7cE8Vpyo6G7QHkhHk+cq/9Yc8vLqaLz1l9kmav2SFqmmeEFhxauqso07te6X/1M80luydfa0jWBIF0K0JaPQdQ2EcvVVRA52AFAltXEW+wWIGnWDJapmKH20+y49h6qRTZQfMOs/pmHvepMHy/7av18PzxvzKNX3l52QYdYh1qvzVxwXA6vkuP/oXqY4kOnT2gbWlJ1rKi5GyajF/r6C3odQ/0Q8ukHXxiv+1b9wF+bvfVdk5Lnd6MHTb21qOABtSNwY8+PrW5/k7uDe/nOCeki64nABITxJV9x0STub3cplyt7dnrBhnbgk+psR7AuaEFvE7N9/1sRpL1MxhbEpq/ndjJIpjWNnNn3XdJ4HoGbQ8Q7XWDiw7g8G6r7GXrw1oPsFNBHUnVBVDbEPnSYh5GWjXLxug0wioCgfxMQ6nC/RQBpFgkkGl3FT0/EHLS+L++PEApKmkcX7OxlZGwwzt1TAy/KIJqzPkAnTOoq9HaZM3Y/poB/oQpPXCRGMIO5o4ADGfzxcXTzdnl2YSpJ8VskyxyLefVEIr2j9eSAbb+mZLkTy8JZqknc5QkjRUFsPMHF1LHghaZU7WtNHadq5zos6JyoqrAr+xcL6gIwmdVP2R8mAmsaGlaZfDpY+JqYcWCtAyOZKnt+nb19qTgTW2EbWosVoVrAF5rAXiWQ+uzQRDxGvW1SniqrV6npwVLgbOM9eAQI5aX967W801yR8sJncuf9AY9ONKfJVhpriXCrCSYTvOcAJJ9oQT9oYSAP3VdTRtTr5ODqcUzJdC/+i2rRHSlZxB6DgSp+i0VtaaFGmLtQiuLddl3UE8HfEmYsD7KMn8k2Q4uH2lxcNZHqv+x1HY/HIvbJz7v1gPjWi++GcTp+E7R4MQI2TamCXUg4qeW30hyGhWw20qb9g/MBeykD/UfEJ85j754KEhQIpYSp2tEQxcuxZ0R/DRUYURZ3xi8R/ANiS7Uz+02QVrww4C/46J9x6EHDIKt9yLGTlxEyAlaBadRFA5PN0ZcKO3zTKg4kCgF9Y12tGoGDVsl1v0P6i0NVu6TRqZfPsTSToaPnIl3i9WX8nG1R9BeAt0TZRfwMafsG+NAHsDYStJX4CIQlIEngoCwCxDbpQMA2YFFiM6w2lQQH0rtxaLRVQ4hM835Z6XAVVqcaJRWuy0y0QKENqc+dYH7gmRwnpzanA+9lskGYpF8kjIsktwLPBIQ8L5WViSwcACQt/x8kryE/Sa7XQLs1jwiuNokr4lAtKsM61TX/57AHGhxrU2FEl4enL0B+dl2QzJdMYZNN5KigoZypBRTwtOWQdI8wUWU6xfIMZraqUZVKzn6Rf/Yv5uxFWi7TGwvlRrU0wtB8sLSXk8pXRvoFcqW07xBk9XiKYs10vXbjAUhjM5rUpam1szTuSI4DeEznWw1TU/WbArEy9jYewcMn6+z6VJbSRGcaSJWvk54M8DNZMMwPIEF/9WZ1ExIZi2AAfdkeptm7BylPT15RYT2n2K2kMxRx7NXvKmjKhBgwyJ2gC1YTkK8oMoa49cEIYWeiFTaZGMhEeiGb4HeFa3RXBUqU8ZLeXeIe2J7RkeOsrdvs2vjf9vs3tS+I/d9jOypRl9hmb/FGNHv1I46reJub0Rk8b00/g2FBI9yn9/JIWLWkbS26cjvy4qt7qAZHNXuoB+d1fF7OlhX0fI+7TLwizkop1V4jN/WwLTX2w/wc9vSdk5Q4OBEr+Z7cqzp5jdQ7/HcSgKruBPrHsLdxElJk/B/nvY6VAj/ypwtN2U0qjvNp/ODPdDwurs5OHsn+z768Rx2iggE9Q6h7HbOQ+SOrxvL9XScExQemRgvdydDWD2E20Pq7tStItgpJPYoxFzu5d0W/3pt4BFOEvBhhjX3Jp4A6ACIg5lspoRG4yEBnjGhQmW2A488C6YSrhJsUsI+bCa2ggiCBPExfQXvNGUIZCdcppFkUDmDxpr+I4CWJvdFca/t+yfpjFfQAvaQzcLf9FXCnBYQnWb2k8fyzVXKDHLgvWafkIV2K7hrlUCar3ghbXpncqQPY8lSOL4V69qPmh+40D9Dl4KAXhgSDZd7qfqWe6tiWX52ZjZoDr9scx+Tg7w22VYJWaQ2M7QsQv7LD5XhAtC29RKzgHKG5LPPJ9lnzLYiLiN/ueRRi/bv106vihwIA4C6MKCNaBxK5rzDTXhcCJieoECxKC59yJ7gjYo0FQP1oHy1mTqPBvaJKhFnvZFcqQP0F3O6BgGgsjTTZ7WEJ7ieQX2rLf1JkmYnIeb8YJrCSrK1NF073lJkK4nFgY5b+gYm6sX+T0XhKLNKupD9rU883GD33AF8vMoBFR+1UfSlOMbxodk13ib3wLH8MF7uO6fc30RqdFaKG1s08ZuAMcvrQESCc0ztRisn/Io5kZ+9sldwLlahzYHsOPJrx2dxqfE4wimWEqcj1uPjMGyKLNyyiDnE6S1FPdU3Bu/j6KXnDvJG7PUwLlLLNE06rajruPvK2daiT+s4jZzdjCKKPs9EJL1J9Al2hUSTerxXe3pLrQ83uUdP1epFsW5e8hBL67x3X/X1ySpf3lp9qfbsaTtv6iQq9ZxKtHD2zrFJu3tYPc0RJ1E2klL8Fwq3TXhAgIBrFQLSDL2RFsJiOF8wSpKY0WOFmlXBVj7MvBGCp0iXSf4qnTJS/7kN1Z4IeVHF9o2f5idAeKrm6gigOEIBRPDK3mSyAOiB6taTnO3er4rkNp1c5dPrPH+GMMbyeSkwwE2rStljPr0nBmHxr14JkDL0O1N3YbVowdqAU2E7ffuAd0iW7qa10n2Hm1uWss6Ka0Z2lRsOnrXit+ooR9mhcLaca9Si65i178QtSucKPeUd4/eVUPt0Fp7VTgeFQp1BkYGqTBixtVjJWmm1mKHi0kQe1GzYFfRlkbzJJlNG75frRT5d39/QB9jHn+UbdAKamCn7Ptu/YPP9Tf6iyF8m7L6f3iXFrJgsJrO7dfI8vb1Ux1HENuVZj0UNdCXtFpqzjkCPndTGal16MH1g84x15MmULZ+kk6TT/hJZME0oK8MAvVQOCwgU6LeECjYXyPNgRYiy5hUEvCVazQdd2SAeBfjFNrfyUZkjX1RZ+myvyvPSvpH+MSP3Jf/4bhmny+LdH9Edo5e4ugv1ElDQnt0eU8f30jES47rD6aavh6mr0gN12MfD3gPKblPJbX8epn+bz5icMe1Y8un7bd0lJrbX05zDc4/at2IXq1r5Pp6vVawu9rC9qsJnbz/p+T2NqvYn+3pG3BVEE68B4DI4LyTIdB/XODbZ9CtSlVDd+VQZH/XnY1vj/o29HNwVt0zI3Jlwhb2un4/VGg0+funnkaoO6zOSSfBAQ5+Q/4Ekgjlj9AzE71Z5VIsl+2XIpIg0/ziqzOqzR8+Y25Y3gBxQZ6I0KcISwtg2VVrz9nlxl8CW5GjkHVQP1NY8a4sUoIeamThC4Jq5wRA8MFBb/ksvoTWQ3+vXb0FfADg4qB6qpMnd7O7m/p6kxnDJEoBnXGI5WW5+9NnlXzk/WSVX7PiZF+en0/t88jRJr/PpXTYl9iDy0wIB9n+UqNV6enH2+e+wVTyj0bBi7hCwMMvP0VM7FJkmKIN4kiQg5Fz3h1OFPE9ANepwbqFyXKczMyboSe9Zr5M8zozTPSKb2W59t6+MVt2E5wDg8fXpcnGaTlf5PCcmIyaczifrhdZeC7XrzW+wYeWw/A/+Pjl78tmXyeb+6Sa9WzBFf8NTmh+eaonua9qWCTw0jj31oZ1SXkj9p//uT3/5y18ijm6X5TwQ4tkQT4ayq/MZqwHocysWGZi6otHzJS09mM4y5avL+eMD9To0ootuiEZsVYK6tx5zMcNNy4nNLA9yxK68tg7U9E67/7QovrsZY3obNNZk3wkvjXHIx+WI4eaLW/ZbZLubNdqg2Atx68YMoCkXASsVU9XTcZGn9QPMERf4ZQ8jCGOF4sivHXXFpSbmWKfh+Kw3DjPxw3Vdw3I2s10Mcxu2KIxzyG02P2+Yvq+0bJ7Kn52t1Vc3zg/PEOJM0kHPON2Q0qgycCljq+KYc5U36jMwiTn0dModDHcYUnm1k8vO1g+WdlYfmTmmT8asdmoFcReNe6Lhj8rTwZKWl0NGPGJt+pSwXuifQ2dP2R0Fxszs57Zg+2lqca3tzs5+nNYPqWTTaWxikGICRu9thNYU4gQIIwagGLh1d3v79a+fL3l3VHEvBMbiXaAeL+ZdLF9fvwHPERsgXC9jIlzYnEHy+dOznzz5wWp2sykuprwQNrtkYWmaXCTJGS+DnayYzMFDBCZtb1hGSslmfnL5H/zl6Zy5QOwofzIB97MUFWBpmI7JHzZuTU1U4wjnymLLJdtBZEnihesvvLB5ro3NO8M6t0aF9qx9f4NEO98r1vg3eOnSRXoBaZcdZ3bUKbNoeY4ObY2P86hKlaUQoPyxqTOVw2Z6UnH+7Oqv/We/p9eynfAE6Jvl+m7x+vN/9fv/+M1vNEEo2Zxo/x/iL1bbysf56cXF6dnZasHTGCb1E1jOppubz169Sd/QddjElb5HLlPAFFzw/8Wr5/ktj3oUxOUU8qxIu3nOTk5ms/m5ED7Um6dm1ismJBVMQgLX630AbBjE8mLt8U9SESwHQQkxBOsE9Eq4FZPF6L30I5jIrTIZ8xHrdusbQoH0qbwiJgNHeyWAtpl62FHbH2bwvvcQOV13niY/aBrGxPd5qM3HzVqd13J1Z8EjZbZxTp+g0R7uMzb+ve6jiYXHvyNxOqYZnx7Tjs5tvCxvqdiuWJ+4D8RpaKgYGnqMK2K2O9Nt/cfbXmPe1zd0HwhHsCPkDCbc2uEuLprGE4BOnqX7q7LANKjkwlTuqVBQVfn0GXkgeCs4Mio8ZhL+QVYn38dop0Zn6ZT7gWe633Z67yFWhHYJ7gqJh7B9nLqxP1xN5ARI4qWR5EBi3UvFliPULyqhGfpl8EB5k1YBEEzZmoABsjfgxwdoimwhPk2ld3QEDvO5FZp4L7RtBLAw2J3xJiZBTUNrXGg/TqZbUBvRqRbvTjVxG3bGlup69S+D9yk7v+dvkvSSWRoaNNbkbT07YMRXU4ZYOrqZ2bQQQB6Lg6cEA9Mp203e2RMGcCZLjanEgK5godlp8z3MWWa/m22OkDOqwzN6Ciuigc9QM3D2nIEqhxR1Mu3MHODubmkTwGervZpbJCEnoiePRqF7AG3Zqf/8i5/OcXqR8uSFV3mtN9c//NW/+jevf/OCqf/MzhdgZ8tWvVuiBNo8MiJGI4cOwHz/tHgyX17lk9cEd9rDCV78V2DIZDBt+zObzzWyb/uKIhfxeT6l26nHCusTHGiSD7uL0gPogCQ5LASlw/H4SY8IWF2urargonr859edNcLMJuMJAF1RJRBz0Gut91qPN2XK70vkC09GGZF7PGllQwStGh9HhvzkTRTpS+YBh7MaU/Ew/mM4f6J5bA98C78DY1w21mwPANpfKb5jFpdoXl2j+4fvTVetSrdAZBkD2rTj3b54qGJ98OeB8ZnJa9etWyiieA5ip5JtRzbI3E/ICq6Nq3iL1MZjGvXrl3Hdesn2qm3FtqxK9dkVZt1BGNJjGFaMez9jbk7UjrbbOTG7wCHO3KZbvS7m5n5zbzPl91GP0EYH+K3dJw9TtZePkI2wjX3EmlpGJzjzklAeVbW+rWs91ALqgIEc2ACWgdrgHsbQn9gw7CsQlMoAShDyIVCEMiU3DZdSWUhMTIXrVWpBAFmaLiQ8pshAMFw7/BerE0SIVPhMDLVXpJiYHKExDm3KPllfTpLzLLuXPGAge4TqXQLJcgXWv2QHSWIA9h3Vu4qhRkJ+mq5Ok+zG9AEAMtSMQizuRJwhROlohZX+ujbNLeFFnoyzq5zmp2m8zTTu28uuVHsNQN/Yf622e3sE/1qt4Qtxc74NOhOjdg2H2tiCQIosXyQ0mNxqHWay+p75mMc7avTJKluvLvT4ZX17kvHCLmA/S3ppL54Z0dh6SGBRmV4QDKDnSdFqtVCEMHmVTq4ll2UDqzWBH0+E6CF6BsVqbsD+NE/WT+iTSfEGsE5AoS2H6Ez0Jh4SqCe+gD0LklFwxasICAqkcrJm+F/LWPhFg5siBRSyIt5LAAHPqdT51cMppX+Kgs2KNjwegCtRhM0pIt9dYB82xl/kX3PRcYSVAJJv5XzROMoeHtXoy49IymTv/aFNGuXEd9Qo+whJ6w0ln17d2iiinWNe7fZjXU1zfD0rvjLOO36XH/l3JFan7/e6r0ViH8bpmOeo9Bg/RIxcVp9WEWGZ7LMr/q2P0w0OOxoR6j3b6EG+ipXbU25ctTftX5Lhzq3SMU8AGkJipt1ObeWGu1GD1XfpMr5t9dkdaELCKRuXfdUb+a1maJTrMm7MjuL9s5zhGNH7895do8+c96XPbo0jisNaOWLwSMngPPeuoWbHZBLoWgeamg5WwfCLZwsz28iCwDhZ4HqLLwThfPBTMJ2Z/2sQtg4VQAY1KQsBtHW6YRfVNamAOY2Y2rMAzRcyOoEzK4VMawoM+AuyMUSr8eMV27UIviNMNmQECcxpA/DNpndpfid1BcrE1OccaQdPvUAKJMk/dpnUMC5Ss+ltkt0iQKGLIhs7gfIkX1f+370ktpZhiSjFdUShUi5Vs/OgIFC36do5nUz2zgwi967ZVcG5xZbUqLxty2KaQP6tDvMLzcpjF3qJfMGZH1E9CIIsT5mfc5KzJyhInXk+mrWlmE8T7UHcGsgn0oMju/HMyEmWJ1lxuV5/w3MCmtTYguCtBdSZ6F90QK5VSO8zEvUvRZmKVPWMQTsBsS4EfC+NWCGuKJd3B1DfEL/FnXBjDYCS2vaHLqlOT8CgpegYATsCDhiY8eJKrmQr/pUK7gPOEjF0uPZDFJ/KzIvu0Y/dGSN6xEds4q7Ovodp36HvxRhT5dn4PQB1T/bFW3Zj9N/g2ph3FMm1vlZ7teFjxEN10wauIisGqMqikV88n5d2hHjRPDOeTyn3G9O27VWL1/mh2qtxdjulohjTAyva3Z9tq9s5w1yG9Wlz00D1MMeqNO4zcboq/xg/zVs+Lt50Q7H6Ql2mGmtU2o/m/OPKfQafjAsp+iGj4/x5qa2+NUzFD3KSvRRuT+bsrMP62ox5FiLVdG3GRh0LGe4SbEMmsMgoOIHs+dO/apIQuExJ4BZoTDhNc0CAWYaqtJoXFTQQC0YstQKIFdPT5DRLzieTa1sJKpwv2JYx+R9ISZJ55RwM/99vipkWgU5Os83FOnttBkodQxbI0/u/5BiAXTkG/4Uuq6MkLC+dkgtl65B/qrTnhLN7XqP4/3/2/qTXkmzL88OsOc293kSER/fiRbw282W+zKwsscAqEtBAIAhQJECAGmkgQTN9Ew30ETQTIIAjiYIgQCMC0kAUS2JVsTJZle3LrEzma6KPcA8Pb+89jZl+/7XM9tnWHjvN9fCI5+bX7Wxbe/V7Hztr9wMILjfgj/f3d8cHKsIdcy+qwO+MiRHOIcvDbwlVGVeXJfGRf1KuTM3SopEtyzlYHXBBt31yrThcR4Opl10nvFHxmL6v06AtcKey0FwE4yqffW0DfnCj2WcvRjgVbzOqQORNq5IzgNOZNgjyFibbxqptqCopfayfXqTUDyqZxhu2d6mJafLYBqaoN1QbbUhalkwSozIzTESzYq26t7mXztg86j5VB304g0J70kJrGxBZq1KGq6y9QDoraiqPtD4MGTr4tHKqxyF4P3Yf1N91ntN9f3YhjnnKG/IA2u7vXQcSKlOfcQ3YntFg4zxkb4PRlAerfnpPHnup1I22ZeDpGu7x/1F+OF2rg/yEZ/aUprM7qhR6/HMUH1ehw60qzw68ckDj9zcqe3//97w39GZgBCDUl4rP6R9ycsUlSp7O9xWH77YH6krT//6aYrtzCK8/TzhhYD6FDziH4k9k20Xzr8hL9kUZsT52amxNxwJHNE66KSb2btRQvoslezXiaoVxxGT6JNCepZvNNVMhCKeItW3XYO4WERNq2UVcwx+XhVniDoZ3yrpUxYK296N1uJp4GwRQy0FTdOg9ZttQmCqI1LwOydrwOixn1+Wc0FHdtzO4kEvwRtOA6Rzep1xumCkuhQjiChoIT8vkOc0S7equTmJrs8hYgjjk2ghD7KYqbd3WO3gd3sWQXbo35Yb2Zp0NKMfd6IWAcTuqXD6s8YYyqixc8pgcbAMvtBhVt+g/12adFEyyWbOhK0M2Gy3d1rHMVeuPWgGAqgUxBWt7Rt0t5m9vCESIDNj+lXUEHONFzVKvuySwkSicqV/cBbVQXnpR1GogWDXSdCNafDZihDw+rUGwYrVxpjMB1EZFstoX9PQbCaSsSp5l+RzmOlqMSjRnyYp2mxLv6+ecPkY1ksKtqwtpINRe3YPWoPmtfPjOOMi+ErsibD3uMr5tqe9MAZ3D8TjDv9kDxev5Lil2XJxu6+HnAFR825mDz7wYOy3UoZact7dO72+olOm2qLqQQb3bGd221JAVbcpDnn1e2tnGAUZFe1l7NUHuQE0xFp0SHGV8cGZDdFxGcbrD1etwg7aDMxHQqvbBM3vJXYe9aAEhrjNxOiDsEn22y1h+57lbiXTr5I58WmqIwxB8H1f3x86dspH4pHPZvORO0YFJKMRlnfaaYE1wTMidbtbFn//ln5O9vFjk2WKxyJeLC+KkfPHO48df05GqTRk1i1oRny3n1KzobXGdEqVpP37FRsrS5fGhQjZw7KClbLu6YJ/O1eorRWxE9ArxaRNobkbJFo0lvbmAbJgAeE7Yd5vVmmV6d17eW+dfsp+P+pU1L/xdBW6zh+zys2R3/3StZcpbgv+HWT5br99fPb+a377USIOUQTd4SiGxt3LVXv4GMZcRz5nzcIo+2TfyvsHtNrTzzw7DTgbQo5pOFv7ap24Vx0hWyBpO9I0PdApxmJyceAwhTo8S7TJd66D7LgP3UJ6uS9BIzjMoOYrOmaDFjQpALM06AIvYaZ7NsuKtnOOf86dFwhwtzvSaMdhEkeTJm2V2nefPimLNSWLs6JnRK589ZmufIl0lLPDQzCLt35+k92kizOfvUlmpiTQ84U/TggYGjUPWhMw4YBhBOQtF5nBjRe9sRjtxXRRIJMrf2CwwdFOML8lUQS1P17IA1T1aKZvNX/7Nf7u8vEX9ZsyCesmSY1oyn376xe//7Hdff+MNrVf2eq4hq11LoPaWf9ZPkes8OZjRwTwGsOddN8ByD1XfGzJw2kMb8KYl7FvYQG3tIRPyfDRY3+kAOj0xZKn9CuxhP0S7h+zU7PP6f4o2N1GDJ43tTymFjgE9/jmKjzNuctvV1iZ8p0QD7jXViOqx+gqzWYfpe7iJy78rO51vQsYrnj0e8C9M7H5P96DeJKhZyQ6QdDRhLMOd4JBWOkZrpVuOaj22kL/Tj61CaD163Np1QOzpZq7H557PXQmC8vXq+f/t//p/fn6lhZjWA0ov6Jwe9dli+ezZk3tvvsF26nTp0gAg+qcPVoFTlt29y/wci/hgQ0iknlV1mF5eXs5nTPjWUay0ApjlcXFx+eCrrz7/4gvaFgT24qNgKmFrz6vr58zloHlRMA+c7eSJ/tmVMXnOgt80e7K8fLZM7rARJB3/DEdk5ZvpbL3aXM0vygtCSSZplFfzN+7d/v77d+4uZ7fenV1yKrDtVWrLPbU9vdmKVXZ5TZK6Utw+7GbBbfRMgDjtMu492IHeZU1j9pJgue5uWa1SbUZdf+rnRr55lJJVj7st75D/ma6TXWo6ff50U9CzrpaBFTHraxklYB0A0TlLctVvP0tev5s8vL15tFITQXDGhqhrmiGWzlY6wPcK7TR0pBXAVB+ajewI5VtCZQXHgWk/IvryZ5sVh4uVbB6rwQC1N/TBHTKWDUtBAn9mtMFA7dBstVr9v/+b/8/19crqBZhaG4CEx08e/2f/6f/8P/mP/+Onz6QPJlorQO3LYHv8UAOjT/NkwI4yXiVHPfDKZaPueZX5jXug/RbsV4h6PIDYzPEGQA2zt0Y/w2nQiFFNoA6/Y6+ePstui6oLmSzO20wNKTfQtvYxkEb7bLKGDcSubl2Ix1dGFsYc6lJpMDv9oRrbmeL/GCdOn67ECRwa5V77zb81eIzL773foxZt0GIIXiG47d1Si3xyhnoStGkmJnOO64v7oMmo/zXRh+l03iGufPNlRsjO5pnPnj9dr0v2UyfW0owJwjS9K9Lnz58wm+LeG29d3LpFvEXww7QIxVw5E25oKywIiejoNSr16XoEyMQJIDMOZ1JH8F317c+ebVkD+strTfNQM4HYX9sK6fzWzeY/uPvmm5dfL/O3l7Ov2f1/sXxyO3/z9Yvrn919n4aEgjcEMvmDrtvlv5jPb+VPbi0Xt3MaCzQAksuL77/2zr9/b8a+n9tLojx4qzOeSUSakaJ4Tf+8HSAfNHxTuw8U84cQGP55yz8n3J1zQHR+4R7g7UQttw2PnyOFYvBoOh5DiNOjRFVmMMUEu5ssqZs5qIp5LV1pV3003aoRAUqAgmc4aXlncecvOP6h2Kxm6dImfTE+s9SEmuXn2YZjoYtszoHPqhJp8eStfPNPL/Kr9PHD9fJp+ug6vXOVPS22l5v04ZefcUaEAnTGj+j61z6hakBcXP7szuuLu0W53q4vy+Rqll+CU6S3i3y1KZbbkgGBRZJcZ6wzZtwgzd649y6jV2qs8t+PsIYPhxSs1k+yp0l5j9qySR5YMzW5WN5SC4PjhMM4h/zlIx7uOXdVfHd4fbccHOUYNfSsn0PvuiH4JOHRm3AIfwr/vTi9funuIdP9jYMw1L+uhnvl7kgmWOrIPTwn0+7EHZGKfqd6dOgwbOBEtB3EQUCDwyBWO6NbRm2MzvN4IQr9KP2PpOqoNwxQtd28owrY/TVnLiJXFW8P19GQY2sGvAEQYOJwjmu/g88h5VvF4wW7RDXFrr1yKfyAXBN96z+9RrfsCo+99d0dFXCCCxweHs+YaMnq1eqM4qaxainVRzSIstcCj+Y0A5uwaEvv6jqZLyyEB0Zwrlu6pZtdMy00bVvHuDKdgv5SnZq0StZLZknn/nZGNY+hoaN7lc5cuk8VjNNdul2zuHPFhB8aBCBpvoW6YAnLtDD0VrH9L97/3R++SYvi7Xn2VbG9l+Vfz9Jbs+VVOoeJZvSzkJP1opoZopOk1pz9pA5gzeMghltmS9aVMoOj1FJf2+8H2806zfCxvn1Tb8h9LRfqsQXqo6xCjxZmeNzj/oDXZS3lRwObLsnZIC7YlAsGuKr+aHcFwu4iR3fprjZp+taZKm+d9JwYxxwtevz5aWPeDp3xTNihXch6gCfpdlGuqAzMB7NJ/tqGn8p0663la//k9eX19vbzzeV1+WSVXDxLn14Xd+6nD35xfQ078Cl529CTT5qFi+WtWxcXt7bp9UJnh1Ep76jlWc7u3FvOF3e3xTpP5tfPtlfPrrQXkA6KZlSBikVzgpUmtIF9sTGLEDCL5ia0tGk1359pb9TWp8/ZWkqHV6j2qtyD3STM4h3cAAO34KKB/N9KsLvwONOtOh5H+orqGA+8qsGR1w5xxqRargbA6VU6vJyCqhLu7TlmuOrhqHGAbisnCAj8x3Fi/KF0g8MNtK0b6yWOa1m66l3duhDD9BJ1u6rSPUXugOMadjVxuhWimX++pwG7VOXsCgme4m8P8Ea5j34NnEn8PWnRVsI6PAO8kSBQbTxXDwBjEX0ok2BDuh3SP9Gr4Lj0Yd2NmXNUGCdEgilW+ar7nkt3wJrmoCZA8TZz9Nm5h3n5ST5TbE9ATnBE5zu02qd/luSP4cEjQwRwI35SqCQuwi6TxzodmO36GSzQokvaBtfsvWLnLjHL6Jq51rP1x/n2/ST/UquE0/tMEklzDiAjhuRUKeYcsVaUc4KZzz1Lrn+nXLCz/AoGeXaR5iutBmY96PpdxWvzT6UHo22yhi5lTIg9YcbG5e1+qCD2oL7/Cjru4QpttwuQTN9HUuU7HmJIdIV1IRPZTkALklu4ETxWS/rhyvrSI2nK1kZZNO/fsWsE+2RLT2blUNDM5io2t64frVfPrrMZr8dFvqDJp073RcpZwRz2sFScTakz/yddazpPdq22aPKYAL1MH1FLLtNnHM/7tHz0NFnRDkUeJe87+WgYQFv60NhgYIFxG50vwardGbvHlm+walyHBtAUKO7OqcjXq+fFNdPSqJLacEhL4An9VctlD9v8y1LllelD1VK2mdVst9mKCqtGCi835hdRZHUrgISPsbBGhYz4auwBssvQGmWuql9wB9dQlfQ46nfZ2Qy9Z4bg1fvHiQd+uWIFh9Ix/6E+4xhniM8UePc3bkiiczuX3Fi3m+AZ8x9MR2U0RYcGTkQ7yL+T0eAw8MveIarWo46XS0zlIwZ79lk6Sv89PGMljkzrSz/7wt4JHQ7t73L16uzg1QD7HfERgBrUeqfU4PHPPUR7ssd5v/S5OJlrio1eHI5/02ahz4sRdNOGHM0/mB8XTUgH/zikF/lo0eOEQYdxtJc39wgDzL9VV6bFb4Q/TOihN9Q6OHkgihJMETxJLZFUFKgmAX8Vkm3lqTW+tAlAtO5eWyGgaIwoR2szuRm23EeSbAFIa29HJgCxXpMBgM1z5u5cJvmSHlbY2CkAbABDeCiBDDyILTPANfGItgdRIGdEXTD/f8u08m1CaEfbgvEB1g5L26oBU70GzIRd8VWPHa/JQlONeydzR95NmTO74H0QFzaE5doM5d4s3GW7D9y4ykRXuXJOBatU2Vlj9UnlRg77f1qv+WqzvaLyMNjD7q3M4WcNLotCiK9zHerFql8KcUOTgb78Ys2A0bzML9c0OmHCVjxWFTVkxNDPWkVsLQ+m/dhEfgXumr9PsL5l/Eeb/TCrLOPQMcaL0IHVxttrNTizOUNYVwjS5CGqiM6r1lIBq7y1hYKrNcGzVSVtYaQdg3Ri2DXjGFCqgunuJBWhVZkmpPLMq49XHvjOeYCaXr0GvnOmHWuQ+6N+HfRyGXAZ4Iis2QCIMnpZ9gJD6bQFNtpzXdLJLbwuqUO6/Ke3Aod4ToHHUjzdnTvY5VP5faBlGfPs0p4B0pEb6kG72E4WFrewT7drD4eOXS31Q+1swd383gpfrZ14IIq4B8gd1UvSYj7+OKRS7LdDeuvHpUW5+3wVoQ4nh7THVW8rSqn6p3VWAOeVGh85Tn2dimSUtm5y9YiqY9MgCnGIpYmlRPU5+zem6R11TxIPEaArfIeKzdcJ49mRnU5csdNsHyNUiGWkYiG+4mZ9m4wQEMOzqafGAQjUEqb3J0umicwXd1gxgNJM1Zjn67RcZDOCxAvNy7YlCclsnXIkcLbeMuHn7p33/vEfrJ48Sa8eba7ypFhdzu7O1YW8TbbvyhyE6qPHOdKr53LwQGaFDzeuFo73AQN0WY5TEYx8xHhOaRwq/i0ZI3wGs3wvo56VDEO8a3gwpbLUNfVcVRBdgqkqRJeR6eZNABKM8dAqY1VuvlmXyyXrTC6Xb+Tr1WJx54LmnKL/pPzqw8fbFevOl5zkwEKAYraxw5uvWadLq5AawDIT4nTaBVv6/mfJYqsmgeb9cFzX9g1WBG/KB5oaxny0bF0mF/mcsaw7mxVLxuHE+MNaLYXZclustBEtA1kabjADqJbFXVXc7DEwqhlgDVhZLqMJmpzEpDgtTaAaM4bFDKWNuQCN1JIVF/r+cQopeSZ4h32P/LsWeahCGerjR4EG8s0/jL5/9rznB7TrxgADiD1gf9/6Cb5TfsGdxSkSKyU88vGHUZ/0KH0DoOM8f7Aih8Z7Tc9UFX5Y6vRy8d90fZe4DtXKqc56H/L/EHyq8AGXVYZXXJoNgKmsKzy9fjsk9Vul/uwgfAcBA65uWOo44d7IO/dDt1T2SphiwothslfKEMJodWwT9bpoihN6pbS5Dz/3yh1Gf/E5+3zQ8712ktgyR6pdZfmK1dU7r3eGPiywIRpyVPsQBv8UvgMlxiJgAlHLJtVNapuiGxdFQlVgxBZC6jVlCEBhkwgVYUmIxOkDFnzS0cq6T20MT9CfsT18xjbxTL0gDGIxqBaF2i6e9Opy2iv7wVyKlDlH6oHVRJLLdy5uvft6Wn4vKdnz5xkNHdugFHkyxkSCJ9mmWA2QKjd3mbQgvCOnmx3U8qxAEeAB8kITVR2Q7/z/zqZBzayAhWfEmiBkkbQagOwke/H6W+9cvv3Dy7dp/3FaMz/zJWM46+vHz77+9erhI1qWtAWZg5Ow5X/JgXMXWfZcG/so+iZAIOBmJChjMx/2lGJajuoSITsy2a6Tg4TZ0yddZOlCYbyGlyh36gmBPnoozE+LK1izFNjmvioLRQn0VUFhpTplFFQ81TBm/sz0/YCGpIazVOv1CTPDVRa0Xipew/VEXrg8XaEA3aUCyqvEcR6I3Xwch1dUp3uAUnhVpw9w44CzAEf1eegkYL0JJSvuAXXZUbsk4hP0arIP4J5Es4XXg3A4aLwVGGl+OOuIIpYS0ntr50BxVHwDn0jOzSZDf3Ncikpbm7hb7lO0cRvjFva4XXGJxOlY1jgHxwy+9YSXBXfn2erd8VwwZWznAtjC76AcDwh69rKI/TY+m3DIV71s9wPtm+6rdIxzabMMB+nYqx4vdXsc1TdZX41cM7sqGvO+0gRCzJ8grlGc77ENgRFREK8eC4EUyim2J/Ih9CLissgJ9G3Bma/02AKhixRiFnISqlv8x6QOTeT3EMntYjmvunWp2Iq0EiZtsx7ggjBrlhLJwRSOs4JBgPUPZyzPnH+uuHDOWtFlmbD9y0WSPc21r/xch7QiJntaQkpzQut/c2+iKKazwF/qygdmZusHy30yZad/ceByl3k6vjvc7yatsfu+QYw24DkoZkE6xJOCNzg44o6PPw/fDbOn73+Yop1TW9pRtM4QQTOTHAN4UVORKEn1qqebFbvnbG6/Mb94k9Uaq1uXr+fzL6hM2fz7LAJnr30F18k1S0TSGZ3uKbNt2BYqnz9OiqdZ8XqegATTzZL9QWfFrSJ/VDzNSzafpbZ+Tq2hypGdZxtEqXGpdSjsV0utpBJeJeWCtbv8ttGKYH9PBgGgY29bzvVSlc+fYIhqCnOGxEj7EglAY0ELFeDJYANViYpP7dW3g0wb/ZCx1dPuw5gJrFxDrfLs8bjbN9QnOuU9f5xBQ1T+vp3+tncfD3E7AH5C5NN983chQ5oMYb4gz59gtVsUvwuGbJwI3xXldK2mfS+CkjsRtU6H+n9CuYxIC2+LatWQv+HRpakYIwAVgA+x478ATazahFefgx4IRRFjVD6NQI5WOTmCh6QjvEj3uzLx3ZWJlY/1Ccq7qkHzbzYRa4smscItxYKlLbg/3qhRrmRL1V41XigwlGglddhDltPn2z6YuEWsSXIJ0UNlhexEUnqwLGNh2Qrg1R2qXlj1rxMSaZ0koT2zebLtnCOT6NgnTrdLUbl2+IECING/CAmpCLL4UBcs0Tl8FXJpJ8bt7Jp9WC4XbAyj6f4WwXHyq2ZkIFbHDag7lvlC7OjO0ANLleGysa5c4jL6bOHPzwaI6pVl/EHcrXnics1GswjhN3JhDPz93hXgooUwhNGl+eYgbkgk39VHdTOyMtTz27iUnSOpvMGkCmA1B+vefvdtpm5xWBxrNRLWc2uYh7IkqmfSP+0EFtoy0gPubKsVukwFW7xx+cbF8mK7uV2wN60ib4r41vX8+tdPnzzYsJvQRqvENYdIQTkrCj7+6LP7Xz1cr9lmqpgtbnF+V8q0o8uLe2+8QV3dbK/XHBXGagA0p8qxbMCKQ3XeFrSbfXYze0lRfYn+qcNWf9XmVcNXuUITgjuBe5XiwzgE+C4h9AbJLmtv6li6vYxfIbzywIkeCPV992U4keNZyWOtRr6dZ5U5wCxWpYnSVKw6CXiHsnPxQNtooF1iAl3qsOydmJCa1q4K6OOJoTaWU80eRG/MM8kNEntfm11PuHsr+Jl0cG6h4MZdpNxIbktDWdEs95ZdAZ+EZ7UQYB/OH9irSVyXQk8MDKdf7v9AGxOiYeAfeLraoAVIIAlZATKUmI7ZywHy3svHZPB/V7cWfrCrBa8eo/KNEUJdjYFKRyVe9/0P6ajoo9G7HytLZMxFr2jjqlkpSlZYbs90f1qfuaZBe3//LkeBO7lcMN8S0CvcV+c986mJ3S5v3boFtSJ2zcTQqQLgXF8/Z6mAoih28We1ZcYyTXGgk1UxvtYP0IDQsk8COyJFZnsbD+3PqLlFbDc0v8++/zohOAPbdyJlh0emcbO0FM6oRROBloB0xgoj96KyZ+oUOo2U3fbNyC/uJfdYBI6T7mff3SWGVwFg7ddGFg/Ad0pUmrVxOs89+/cP8e/Q5rxXqURv6T64EsBV6vJ0P9Tw+rMyMf9SLu3xgETpCvjYLFNVT6gAb/z4PXbdKViJm77PcbtZ+R6FVxbXFxcZyz84CZjGAW28zWalOTfJ9tZi9vr8DfbrUatyuyT43qgZsC2zxRvzZ8Xm62J7l2qi9iOrh5k1nmUPH3+ZPV0UTCfT6WAPVLeZV7a4WM7+EXqtt/T0c6IYw038UxMRzq6t7UrlTRWqrf7Qm4aBfQ2poDxouMq2HKWSkQJBowX637K5st+9EHs48otIDrq8RA4iAXngnROzid8/cTrGeZFp/53q/e1oqYE73bst+BkeJ/gtltJ983chMX6cno4ZU52ebpT1gfbG0s9VBEfyiX4lY61G0hOrTcM/I+wOyoreBv5+DtRN8ztrACYqHdg1EvA+5dXT4HUzDzesnjsguCEkgjFBfvCzJ8KjY7YeA3krAVq4JpIE/DgR06JzuLr6h1xPhEcn6eIHViOJ2ApHc31irUbIA0kLJ+gWEiCEdJd5yGrx6X3skveifQeBuAnjD7uMpor+3XPWj+5Bj0I3wif+KYhSPy2Ytuu6ZkJYMKQwHLGKBpntw/m8Cu0JOojcCfnZv3O1enD/KzZQJxMuagAIrIhJYwf05tKqYlKFjhujDjzjQDHODWYOD6dBEYExhYMwkB0akQwWsaI1OtSaAFt7R9IgYfxACgiJcE3hmOkgtQXRZR9VzWj4qIIZ0tluLjNm15ApfeLMlzG9xy+ysGtlnyE1FoVPOSXM07dio9mmc38zBnA00f/21fpLGpFr1v4SuNPXPmO6DsdBM3WH6Wgc7aDonkib6sHoAdWCGjXb3M22HBFNZdIuPprmr1Ui1C5mEFHbGHHSeXHUBS01Z9LYakXbkSXEqtZQ2JoAaiA1k/2IVEW08xRVSu0DTVpSNVLSfGE7F7H0QCuDabJSsyoXkLTq5pUsFGxt966o7bsk1IDT569XsIM8ENx8ENUr5JvzwMQK3otm37Tzq9b9wn2T1WbYyGZOpwEwUel2q6Vr/UQPd9tVJ7QR97RxY1lxeqKqfWhBojuA+wH9CrUOgTZImFgKjj9dYsW/lsvjXkF7EYLOJNwQ+lQCVbuexNh1uqW/MyHTe8R9l4bg55pIspACPOB7VhAdMBsJq129vewtPg0qewg99Dx5Ou477+IfCgljL27aoeQ7/Kh8d8BoPCQGku6UkbtwwB/sQvO2GDTHAYzlru8QDi1y7790y1J6i1l6q4kWFIcCfkXRVaVRAK91mHq22MgibIVrWq1LaKRIjBCJtoEm/0CXMYu7IFa7vr5OU2btwxYURUJs+sh8IdJlypJfOmKJqGgE0KN/QQ/vhrCO9gITfjJWf2ruBTRM3xAWk4qsIQEGAqUfQWGloc8sUr5ZXQVmHYstM77RBOFCYV2W9qTxrcA1RJ8jPd/KdgrztDArZQzew0wUe69G/70znMAqnv0fpxviWnzCY8MPDQosOWy9BAqrmYgrrLfd5voz40fPgK+Lck7Rrpmmb01BbeHKtDAm9azTxXyTrPVTOJstaAMQpsOFeTsQb3OWfDwty9eJ2gnvVYHyh2zyk2W3mENWbheK8qkL1k9vd0342W7gi1w7yUsVCd7gsK8s9MZJPfpE/e4HeLJhKYpKrphhBf80DiYMw+JmZV37yCid3EuqztCnw2NIJ13VRmnWvCgRyLvvkPHf5S5+kytP8Ts8Tjti5y3UoT8TIPjG+/5bvz5nEjKZzQS/jfN6MX47RUqjrE+2N3gjvJ+GSnAIHjhMTBxte6hprmrDD5HsIXg8qnawDtE7ofqdiiRGyUYDAKKgc/NtE1F4soE6COqQfXcBLYcE/7fgEx1AMQQOvSS7curNPg24V3qLfWzjuNotQh6PM8SpYlrXYaL0iWhdbU+HuJ7jfL5B9cYV6+S6pr31JTbUCqoqM08rvCHIUKC/sHBLwY76RwXmP93zLOu0CffWdBAVYHrerVnghwETZ0EAFQG/deQTWhH9K7TifFebIGRBlXXTEpfBRCF+xu7s5W2O/V2kOot4XVwwDkDIw5aLM7UBvE5q1YGiU/X4q9XA4IR0gIX+m+EkuBSj1Y0A94dBu1VbdEZR33jqwOq8/Z9O7TqA7Qm/e9aORYDuQN9YCl2aXpisySileKoq6K64WbVFJWWPghf5nMEAHQNB9/02VS+7RncodFqhKfuEajUw0bwN/lCLaACsVNc2l+l6mWQ6o4tqSXWAjOie+gVT1TWkcOKAhp1YYFKwBBlErV2xakE29tK41BiDNiMCRapRUzmlDqhlULVYUqJKxHQiDVh5jYKRvhugyDp9Vq5TaugybFEZzRDWOPwE0nHGL2fumDtfTo1faVV7YG9V7SKcvbjPzrA2bson9k2T34/YaAAgr8KS1xj0hPdAiy2aOWfim9wb7ZXxnoOujQMSu4g3DXErXMpgK62pBG7oYjZ90ySon7qtVdwKYe/VKvBWT8YQVZvVQLk0yq5N0+0trjDcxnAPdF1vhCwSbkhUl3bclGuz4cc5uMSYZyPdtXGgdrVc2mBSP8TfhZA+0ds178Znu+i7VjTQT31oeni/QVHfv2vaJWlYQP80z9677C8YVuPM6L+nhis0UpCk4EdhvE2wt8kPisQFBMFiIPXrKoCziFwSCZroOLUDYLUkWJuoWD6h/Pp2zlzv5Dkx3IbRAQIz2BDUKeLapMWdeTa/WrMidJbNt7QZEM5wgrpmtQZA/bmK0aiAZAGE2FojEpl/JtP8O2KaK0KDXlBR+IenuFeXsixHXBuX5wDyRCe/gVw9VGsD3rJH6JwoJADv1BBOzw4/Rtq9NfrvJ+nS5TEMCQxDYhjXcmKTGHHS48bOmujQucEWbZOn6BfkyuO0BlTCVlrs1m8jSEwloyaAw747SfpU4zzlosiurbwVpGu9MB38Okj6aT67SstbkOhsMDUBmAbGCBSH9eqYamJ0HTSmFQOsFy/Xm+v5nCEmMBhW4lyAdU7gr5UH6tmXLsgggZb6pHbdU0N4/hWVWQ1aDRb4qIiF/sJzd9m3QXZW3wblVH6oP6tHPnbRf4S2y1YKR/RfQ/CBN2c/k8OhzbfQ4fQ1xfjvV421++z++uzy9qUOlbWP32H5B0s/4XdkvHQO1mTU0IrbA0OaUOuGSrDSuWM1X4nd1cndZdWp2PbzWlpLGPiMbI91aGJ3v/zN/PDUj+jvmoDUSeCshr86CFW+ekJ68l6B3AOxb+L0uH8osm6pdSHjTF5MLlphl9+nSxxyBXzczFYiPAYRQIaYBJyhhIsgNySGMM8InyLraIvOpKfreIoWDdqGyfagbBKKmqRyhW2RDZEa87b5o79V7QJDVeSklAJzi+YIvkAgnwT0rBSYzVkRoEk+4M1mDCD4JG16VEFjWS/xPxEcMRx8n8zK5ywVZiv/682Ks1rV6kAdhWfqhkUK0RhBIbTWFgBkWbqjFEuBTX2BSVXaR4lmMTiyW9zM8SfyuQKWAwfuyAriQAnpkHC61uMAs28PGHvcJKsOPXrHBhsOVUM1QTeK30qVotRBX8mcXVyJ62fpkmpiTb45jUQ27qHOUQxqLKo0qCnUm7zI7ibFHQ1GKYZnS1lKnxXkOY1UzpSAJ/WBtcNaYcJWsdIDagX789mCsQam/s8X9LJRbbkU8IOhRqx2D1XN1LeAoF+itZoYbSVKQb8U1zcAdBB39x7zY5C5ovKHf1QPMdKr9HQPvHLfdF8FTFXzF3WFWh6XVJy+aUVepKyOLScK5xyAt/XO6mlhRO2PjtQ9gAa3E/jEYl5o28sEN6yIVRlIjxcFuf6t6P1udFuxPss89DS7zF5azwocwBnXpFJ/oFzGrR7KdYmT5A54rxfsTnOLgu0h0UvSAA7YGON4vQrei7Mmpl29PfWz1sQtmsi5Qqtp9Tihx+Iw5g3sRjFu3tFjvS9QA69+cPz6qf1Z2cr5AMRJCooUzlA7Fd7oIhrSAb325E5UTK99i+mXELGRKETStHvCIk2TUBcpZK+rKz956Bjq5WcxJyMAiqWI9B9xYCv7shPp6RQn4ipWaLKNP9O74VpezPK7mmWUXiwuNsRotnsQulxrlghzwyX7rrU4LCBTkIcuTBNiE6B3Bdd0cKyQsrosYNSHXZx/rFSYwS/ikOkoujtpSBiWOFZcdohxyjIrzs6Xe4tTwAfZsqodfio/B+yAd/OJUZtGxQdt1fc/hmnGxvsmzT9Tuay/x0Ci1To251+unj3JsqcE2NSjNJlzyDN1ioXgK032uSiL20XyJdtIMQlHe0nJYWwa+zyZswbgjSTndGACdqYMlRwFliU/JJ1lT5hsRsd9UTynp7+cMeK0SrfrzZrGxlWxvVitnrM1EFXs8vZCpbFlu1AqlcJ6bQ1KOvsqmXEwMAAdSqDtRzXPjUsNGBBkdFV07sauGwwS3j+t/MG5/mPefKnzKksHeoiHfqEONSn8/lrN6qcelxVKRMSnvLcHaMel92gc/47E2RH/hs4xzmi6V5MRv40y64tFxwmGX4GiG7LaeY7nduTGlrqB/qWMEbuzOeLc86XDF71KqOzo1YpO4+mVFcjsB8unAO1gvSSvgHs8EKoCjhyp97Gbu/VmSEZgeATJEM9vCzyYHBLn1fyG2J6iZFxJTuFzI7Rev3es8d+IvjvvEjNXRBb965FYR5vrVzG++NTtgkJhO+gWeDMR0SSoMUB8DA5ZzOAmWmIhsfpVFTpt2MzFd/1k8a6Cp8Vyqf1dCkKxa2bzE26xkbs29VEU/1xbxKgPl10grUHBJvEEgpwLsAEoJKmnvl6b/IPKolTLgCy7c9OnmW9qVm6ogEIcuMAwqoHsPWCnDkgSN3yN5w7TvZQ504ypsPhQL7wHzhpKolZoktizJ2z7zwR9sjkGms5+DR7RCOBECVHQesw4P0AtTEqf4tehEKtb6S09cu0AAQAASURBVGZeskZYvfzquV+kd5KcyJ55QZun14/Z8ofDKUDI8yVH/37y8UdFwjHAt2/dYgU63fw0TdW1T33SqgPqif+TDAmiAmqSmSbcogN66Ug7wCiob4fVK5njlYa7qg+XYJYYuPGt2SHvxR5g8gqMB6o69coXh3uAGvjd9t7oV/Bwf02lOMqp9RtjVyjSvnMOwJAONflQfo8rjmtNDgmo2l5Ra3UI81D4kJ5D8C5/d44Xi9+7ONMh3RZkj3MH2HVpBxBr8A34s2Z96udEW6Y7RwpF9npJHdf3H3QL0uO+gR7LO3IDYQsZ+FgVOrDHImY+oT678EqFIYu8BzrqaehVGaBfzJEwBKIZg1XW0WlKxOMLjQRSrENPJ5HO/COObUqS31XkT6BfXd4QIJhnZcg2yR4rVFJIpS5/RVGssSTgYuL/s6fqT03ZkPH59dW1JmEr+pppdj/omuVzmcxup7MlYRwrEYgUOVtY8d5mwbCAtpK33UdBTfIFncVqpBAgcpirpk0zXxtua7VDbGfQZmmZgY39/s0y192iOPBR0vDCCEJwlPwwehld3M89UFdqETEzo22GjXvlxfSNdGO/oEZO86ES2gS2nsDxWq0IePzqsqtNsE+v4bCgKmk9A0VlzceMHn5KbHV5b/72j3+QzzbzxZ3r7YMyvT2/tVk9ufj4z/6kvOY8aSoDW/tfaQkAzYRtztyeH6ZPLy+zi2J+K9/mya1Fur6cLf9q/sW/fvCVGoNaH0LFQn/qwxMkLuaL+ZLoP71zl22Cbmk6T3GXirO9pr6rfltYr6K3vWppPaAiq5ARqX/KpwlqrVA1CVCksqGqLbUH6k/5i7T3/Dm9u7BGqOf6x3mOcfx9wpukh/lxVF1GQ++lLuYpkDD2bt4d5RS922O8hp4nvLf39GHHIo9LR7o1dI647Sm7yAMtd7UeI5bfnmRk3RSlWxGFvZmm0E3EGeQ3WHa8CeuVYCR29OqA4GBze4EIZd/llPWLJWB3ACGnL+HYLnSnSh/mtwV2nEUDzpTRhzl0wE1Bq4H8lwXsNeEb1OYsCuDtIypzr+gj+JzJe73qdHj36NcDMn94Hayrsz4trZtIFJqw5SJTIywuIpNgXFk6wZVPIn8t87Vs66inF5cQjQnSNBsU99P9T98/CetGhQjqfLlkzxbGBNjofb5aE8wRTDHpgpkbitwJsvLsMafCat/F7VXBtitIQaw2f4c9cZh184KpAQDOHSbPZ4woUrNwTAqZBfqAqb1C/QP2AupygIzyB8EsxNNjnRDQLsfWPThTdHuugLsHr5UNmctrwc/9uNeCIS0c3sjd8fKUbPDQ2Eug6Qp5XXjWm463mdrP/8W7v/fT7/3sj8qcM+Ne227vF5vltvjq679Lvij+nUajqGTafV9VYrW5pjuf/Tx/dvudn6V3luslLcoypV26mpV3f/P8Wba94mgBTvWiohScLkctK2ZE8zQEFnOmlV3QkOWBmqlWJ7OG1NAEi6SqARVNO/2rkgOwJqYWIDAoQQtT+lYHToCBGTxa3bUCcktlXfRIMnjAEwGNhJADgZO9uh/gAfddcPABlL+VqL8NVW2ijS9hnUHzSCtG22+sjnZbJC7LZ9fRjafrwNbVpNbwgTy7erpLHD7S9o1dF6edvHVv8RnBH9KnxbD3sdX67MVpAKPWfwP+oh5G/DBkS8uTrukIn4YpHXud25CsBm300MXv1WpH0ZEbvoQhsUO+mdTB9cp7ZNVPUF94uT3L0EIUYpb2FRVI4OBo4BofTebhLyIleiZn87bH8nBUbEQUJRzN5FDMx5JL7dTOhI7rdLsEQitBkTvrOJn6QzBGB+92w3gAW7yn6XMmZzPNIymXfraAZvxv78y3d0u2cJkvFUOy1JN9G8t1Ulym6VpBPnJtLcAs3yTFnN5bGh0KzE1ro4C17N3F8TLCQIKGnmyHeF7sIkFEvbvakJrXDmOXCqsLXKFdxkCqswuQM+ceazBAPABu7Bc0gFOxHzEF+a6Fmnk1l1g7T/t3h2pglxWQUioS6O3DcuqbeNbsVHIee3MUAMBt+og6VTLXn/1n06c5J/kmX2s5AH1hOqvrGYNJTO6nyoIMo3nyRLP2syeqE1SVtLjOHl1nX5fpkuaCNUJRIVcHPnKKzYwzhRe3ddoYB0owiKDV5A+ppGVyW1qV14rvi6WaBdbNX25eTwuWqXyNLBiBSa1Folark7ZL3wrXhsfd+BuM/AtjeRG80h0fVAxqx5zr8+A3iQk+jqqrc/ymjdMV5r5f/+DJMMu/K6IXgjOh7bk67/YenH1a9ZC0QCdw6PFSi/m+xz1lV3sAF4WxcWfZ77F94nb5L9LqIVm1da6Vf6ewy73ajQTOY/jOBXFK7jygNM37/v4PXHYlIkvCb1XIf5U4xAM7bxqVVw6SITHErEU4hHajcJT0vxuV8iKZ73X7kDLfVHF8U3L7/DDBeb3qTqBTRRMa/x1b3e7qAlCPOxEP/0nYJ7+ypLUpiulooY+FTgQ7hDRZyrQc3tR05LPHorrsCZTY9gdywit14TImwKcW8xLcwV/992QqWNIdgscp8Rx9t5zxRbftnC2EFiz6ZNYIPbi2+Q9DCdsZK4iTjE5awrOUPynijGSDcTSDgEpRB1jS9K5MlRFuSE1RZTjS0feOuIhTpEQE7Uu6Zn05LwzmygaVrYwq4Z6usvjg2f+UT8quOsitnyswH8J1KB9WYmoianyH0SAWjayvtJHncrm4eCNLXqMmsGksm0tRYWgMaGYP7UIF7qpVbPSpRSfayYddhO5xkh368Acz68t3qVRa1Ur2AmVWjxYG6CAwLVfRbB8P960KKcbngoE2HaK6qkXCn2qzWhLoKa5IEKbVWlkDYPAKeaIyrABxmtbjIKNXGYMeeOXCQddYhn/ZWjgAe+EttJf80U2IDYnTL6/yaNlRdAdQLrsAsXZYe310rBhoD/W3m/ly7Bh3WBkg5IfZdfpGNVtXQuzIhfCw717Ec9A6U2nKrcczRubmBKMCK9fW28ExbZwOyHsTXW+3Wth7OXT9GUgO82ogOyIRl2mcPoJVb109io8ThXJpe8P0DHV1rwR6Atoc9tIcixDX6jh9HL8Oh9qOqufeH5s1HZhX9AqsD9+nxWaoN5GlFnGNtwFESbDjzlIY5C8OQRTzEAjNPuEI3yT5qRExPRpSQiuCIrEhYCJ229I1z2QJmhDa42V5fXVFXj6fbzdrgvVk/Vq5WRfZo7Kcp8lTJnYzbqCRBHXiEv/dTnNmgHjXP0JhzOlQF/TOsnkj1YuFoGzMvlX7YV4wB8hPBZYGRITRu8WUNZ1lDIYQxVmgSYYe/L/SlTv8w4wUVPiOU30YsOJUpYc+mhQVlouUFP0PV7ULUHi+mUTPqgBX0muR9TS5m3rkO6ZrHaW9zUboLMt0c4zqoeJDVzpeN4wK4mS25oTSFT/VISqA2pWsPMlZ/H1BXyWbR61p9ZVPyvI5yz/ylDidZgBVhZO+mELGmAN1RiNQCGa3HwX8ybyYPyjnWoKiekx9FG8VpS0RYeIYw0pzWp2MANCyhJwTAzQDiT/OHytv2TlfUPJtoIWRpbMn/Gl1ys5ufGWGSnUuywj26fvlcPeHZ/Tu4xe7zEmMn998nKpeIbDL6LwNdlkjqUOpJuEP/FKENzb6xOlKveY3dETn1nc5YFa/3Q8EGMIJyCOJho1drQasqxh2c7scYtld/Ci3x0tRruvpgHHMiKidDPWr2yMeqm6bZsrzuNWjHBq2jPqnYjMqKxgYZHYtDVlnSTTqT8SxYVcE70nWL4cqq1USejPzrgHayuhwGsivfeKfA0jOrEZtsO4FxvggOM4IZoPjC3wYcdvLo+3Lo8kLK5nfQpNfmG8rQVR99/KBvlac5JQQWheogvqKFfEZIDUIPI8PC4AUJds/TbewWJDOfab4E7mx3pKwnw7TnEXDBGO0B4jIONF3TV8qXNimXXOsySKUp7PDRg5Y8Pswyb5eLnmkwz9lF0gmC7FfEIMKeoWlG8JFdQBr03ctDka6cbFPbuilsE64rqES9g513f2x714FdI7MXYz78PbBTPQoEhj7kYzDUQr0yW4w8nYQKjSgracmlxizTuvT/nOrYU0qQxgw1ZwgSs9X5zo9/AUtRG24z9ycmbbwLLfXy2Sz1AgAbQGtI9G4UVbOOBmAygQOW0ZpNQg3LUJhKtnbyfZ1HMxvJ00K1VrN5sFkjpFbsCxF03cYJ2BlgI6gW2lOkTQAh7YlFc5WsGhnW8J+HUBgoxLCUL0CT7WdB2owjwbhkcTOAwLa1U3UOQGhQvH62sr9bX0MbvttdcAru2/WAzdWwfQ6O0D1FnoPqe8C1JPR6Jsn300SYredtMs7QLdB1Jp/r1KDVAMZB7SWBjhMAcf99O6Mc8nt9kAc3O6s/dk1pFGsdRGPjBjAYahV6swHc2MdovTpRTwo0RQaz+06pAExPSnN6Ur2+7PBdPRhoJeia0Vcu+L0KPfBzH0c+hzgtRyWbrOhRPsCtWUFLKNToCMKi6BU74iDA4Y3AuxRUbjFTlWdVEhEUPXkyaPVisWa5Xy1oL+WeG61vlZ0pv0duYi4HmiyNxE/cZmOFUOqemG19Be88vVl+ub11fYiXy0u2PqdE6A2+QLqW9t8nTJWoFZIzgFhTBOHmZ0lzL5DrBxe25cEbekUZvaHhNV6+6cg1RXt1ePmwtUNBzW+Us5J8FpGhmZyB9/GWHG6xSBkVZGuP/cj0U8vKW8FmuFzgl2NfjY78pDa8YTEylcM+M+jMwFoCcGszKtce3Q+ahC5XJ6r1qC1krotJdai3BeSCDk7QqcE1MT6rOARO0NlZfc1/cZqigqD8L5I59eriy/Xz28X6ZOkuFgXT5KU4yFYSDLbFE9twcA8mbPDD7N6Fjnbfc4eJcuvkqcL01Bi1cGPstt7tA8oZGumMjZFM5QGKppc0dbQdlLk6D/Vh1YrYwzsPKu9pLTkXfPU2MmKAYeqOQASnGmJgs5/vgY8uLWyWFdtrj8N3mlvgKuvhruoQuz2/XvGvrdBv5xDqSbh+9e5X+Cp0IYvmswO/oVtkoenPTaOWxflTirnCD8oMDGxR8+JXAbQ8PPQ5b9rnnuoDt3fxCEpFfwE/8Sc7bUSA3rS3dkf4zHVUG6fT0aqbbQ6KCjl3h9TmnmuXCOlFHjViD3cvIaO6dZ890Q8nVvQ03n0quNCItKXNBn802tFrLQbG0NuIh17uMU/aBgSLYRv6eMZq0oozYmuiPFD+tvm3mn+C+ZViTErPa/GIKCBhun6Fh7h2cCKNCGQ4ykYIrXjTpxFWLXIX3/9rjr41RPBaU3FLJ998eXn16vnNA4shFIelDxy0+x9wi5Wb8JIQQ+R1cMfvP/+T3/+k6tHD3WUAIMHdPvmxfLi3uw1ZgdxUBSdwK+xbwudtrTJNpsyv72g91jjCZDbfJKgF4A67kZAbaGlXPMA8vjNjdvZha4gV0b6Q8y7/8Wp+HWHZVSx7DabCkEfsaAIfM6k21lxNJ8ER8hsM70yuKNNBcDJojdOStlTrLsDPAeOVraGZvKMVjcuZ2UFp21+qAya1WM1i5n92iH2zR/83h/+T5+t71NDnrIv0Or6CaH/av08KRaf/uaXH/79P9CG1OiQBehsJpuWby5KKskj8aZCqURhQ4wObyoTCwCY/s9stCKZbzIWA7DVFL3/hsPIklxQ0s5UgC96DVtRrU17LGGIQIMDWgegUjaHmLZmTeMWnNCADj90vDiM+t3PqWrat8HQQ8v55bHp26v5y+PDpiZebf3e8S7gFmx/LfcGQJeyKTY8jTEcyxMDdBtEsb5PBQR2gXbwTPeK9Jv56PbTtwqiV61Bb0TY8dhCBJ6UbPhwoHe5h1FdCj1ZvXMuI7xum/XglnrEbSgZ88wf9GAF53f16cHugGL+Y5W2QzgEoKCDSkM4I/DjrBhh2M5SKGLzm6uMPcpW/qHfWt4JHqrOavVzcCtOzY9drCxKBU9E8EIhdBIzpRVec6l/3YCum7IUerNhSpZcXDBhA0yFRwroFK+Xm9UqZ1d/hVPAjYeY0MMKR1b7rjRp2yLtcnX7tfR7r91LtUwgZ5SAyURLZme88dM3Xv+999PkVlau6PvnaCcd+sQE7oyNgDbrFZNA0DnM1TaNTGkJU1yofClmyqbWI2426Xvu2CTqulCTAwJTgxQeFJtRNSPQRdy+XEolrGYYOLexG8+7fvoa3IVUOX2Sa6KxT1TeKWgphchwM4ZV6F9hqE3FdBsh+KVEcFoNdErlOKMKjuZ69uBeuVQHPmrxpMFX1dKHKoNBvJicKtV2P9n8/u17t644VRpNiqtbVLH5l4wHzcp3mDL00d/RhoTBwvvpNJss/yzdfsVKApOtaiojeJg9MAFvaC25NgbVyXQMAVAJy3JFRI8m1C5wCn4v9D5meQF3euj50G61aqHoIvynSoNoFpg/qeVkADBJyuEyDE/W9/jdVcGsdaG00BsOrBB6P6b/Xhh5j9xetgF4IP9A9wISjd/NSB7+UwlMvho+mWLvFJwB6Q1ZAzgx+FD8mLab7qmIhuTwIaed8rt2Cm1X/0GIlUg3unP83tgMY3t0G42peubUDCqkDCu7siulC/H6Wu0Pdr+X6SEjAD3FHH8nJr9behWJgUM1Zrw+xRxeWHrI6JdQ1Rfmk29cUFwrv3FlXIGXUKWdZxrKHVJzhev4gVnrcRju0Zq/GRWz8U1SBG0zE9RNC6W/B3YclY88onD16hsCdFrNC4TpPh6MWaCnGdsEVYRmfKb0yOrAE1vWmcwWv87SD7ebn2W2Dai2fSe2z5gbflurP7Ue0xiSSqr52UwUlzISLqm2vBS+IZgFbLGmaVBpLhjeEQX//UkQgxql2ezZjiN8Zdun4ZLbviwMjIBiaVdI8FSJq3JewIfMtMu0kG9qwA7uOGSQoPTVH69Mm95S4yvaVUQdyM0h5OpTmcoJjKqUuIigipEFNXqvYl5qFUORmgBD0q7/Ot53u2VB8IYYnRqmcSYOhCaIZ+14cskgkAXfaj/Q+KTsi+1bLEMvs4fquWdJsSqYSfR6SK2TdDUUWXAsR2ibWh1Ux6oD6iG488Ul9Y3p/9erlQayVEtNMA6Bm+ptbaTpG2qanqIL1BYkyuwm3QWHUHR5fGcgB/pOdrv/vjMeeGXIeT3gNYqv1wupJ/413idq/MsuXdkF6G29RnpaD832aD8rV8Dum3flzx4+E9zcamMhK8zDg3cQvc/cCZJuACXWsMVeHm6BDnxseQbq3nZnL9fgQ3Kdzx5lvMSd13ibtVdeH3C8Prg+oTciFHQfpx0s5tn1j+Md7XkIY/5B6kgpB5zxxH6Vhnze/CaOSzkmt0fuWFE0/ONWGbrNei+1iz8+1Lz2ocuKnWBHE6CT6r3xGciKCIl9qvCPwJ7OfQI+bprbY98lYvLXy+0byexri5WI1YWiiRPFG7Zg9yHxu3iIFL+hC6E/wZf3rLKxP/Mv3i1XP+CMMDhrByCWEC/zIptt2CdeE7JZDQyDFe/EkhN/NXqgHSBzZo8T7ynGVICKtgCRg1Z6pJtYHTkEs6ik3lsyeDRkRbpgWNrgeiLwhIlbJ9PFWBD4WEr0ZqJHyf4egW/fJahYVnn+WT9ZnnIcYL6v0hX+CR/wdIZ+d05xOuYdRKuYsZYS1R6r7Lmk5dfEzQC8QLlTdtbOqpiZIFWFnRWeqjIEF2r9SFpl65dRyemGICeqCCl5ACjCfv3Xaxqe9O5rOGjNxKB3VNLZc20eZet8IWC3KV9anrOvf/5FuV0Q0JcpR1LYuJOarFZhJYey3WTFLUwr2IeqWLOL6MVyPp8zcsWBwNv5bMmYkh9f4WVcFx5nXKhCohcVET1hqWJFZdVJ6Z+wBJnLvl9CaF2N72adJzNJV+jGRcYqe2glwKG9kj1yx99aPe+cWt0b+mzq0+O7Wm78u1nD9AmJ+y4GjqQbPpli7xScAXkNWQM4MbgHv+mfGHlienzkpMd7JnHzptj36DNRKmgnaz4oKoye9WG0Yg+vUaohN6ePqTH7or8a9nyjDbFxDkBcDMo9ZASgxwnOLmbag3QMyE2EMX9+ATmvnDNyc91qTdufQ4LGqdpcTn52l57M5reIgdc9LyZPn2j8UE04ke3NkHt9mWD3BBRpGKFVkRwxl8doBDvq9dV/0BTrgOwBCoQ8MzfDoivgYCpb3Oyum0Jmv6BXDuETP9b075ImguKPlzKylC5mn6/yz7L0p4rSiD8J49isna5cgiIaHTZTXM0NMDUTg9Of1BSh55cI1eQQCYIGK+Vx91BeoaTid/sgKU0snyix0tbaARKjcN81Q3VTEn6yjPhP1gkkKscy15lB0PgFtUwTlW6k/VFPL/Iy8ZLtiSHRQbmAhgdoo9GyokNdhtaFTRmRBE2YFv06rTxhXrEKgtNclLWqDFV+M3cZaUVU6UMxiJqCchT42igOZU+CCkAW+uhcLwqUdR8k1T65u5jd1QJflTzs6eynXhT5+u1kc1WkD+AOwCqDVDP97EMHTFzTksMWGjb6SNmwaiEz07mWHdBsKLfaJFS1DtvJUJ2gtamRB5YL0w5xg8GFXhcaqUr4w2H3ikh+qi+aKcfxqhm8+nzlgeCB8crk9S6ufYHwu5QYd8JZLfUv9ASPdl8XMRG5jAAM9tXtb4/qV06XvZ1nn+9/pRzko1j5QCida196z7E/TWlBBoaBA7Qxw5px/Rm15EIvdZ3X8xm3gEM/fRDaFRSyengNg1rtzmHERo47MDa8ke0P+0t8X+s28lgP/wEQPS57FBsgnAieXk+8ROJycb91BcVl3c3dAznUS1PKZY/II7JjNwyTe8lVuPpovU8AVYW7c6WFSx6008+uvn8uy3ZsdcYqXlfzgB3Z+ZIq4iMU0wtn9pA5FYq6PeDSmkkwCKMe0ktPgkAP1nolKZ6zXRfFnL19CLI4ITgtVu8WxVts6sPpYczvVwDOcs05+8EwU0hhOAE9/bBFYt3/BYsHFmlO16x2EypoOSBdpQ8dX0V2dtcUcYLPreZ8091bsDtNSa/2+v2MbtTFffHZvJ8UrPucSw02iASiPUaJAjmmYJ3kj5Jsla6/L37qeOY+J0pUY0AbSNJHwwQkAO4x+UqXjK4vT8v7vVecEacrZEAxs14Wo8A+6oipQlvRWwSrgBg3E1MzTZ5dN5ltpUKiDUa2DbJoog3Y+JPzm1ncoXdOyiiBvEd3O+vDqBV4Dw66G9zS9NHT/sJjVqL5Q/mN8aWM3ZzYBBZuaMFXSc2yjNW6isw1ssQzotUMUJ7WBbOzFK0/jguYLaiI+uOIaKs/c4Xh8/vb7edZurR1vFQhWaNagyVWSJQvZ/0mGtmg7GgCvJ6Ut1hwLP7MNmOfKdnKcuFr2p+qomKBYtReppxh18KWukAKmlmDP+w7I8ewZxREB10iDwR1Sr8jdTpkHpTY85t48lsr5h+nXckuJFa+J7epT8MnMWUzHX7HAxifQfttvHp8EpvR9E+cMzHtIye9HoNDj9NM4pTIbY8Cp2h+6G/xHlUse0CfPf7vcD4UXz+Xratby6Pqa6e5+whAi+zQx8DUC3n0tdJVaUiaY/p9lOUQg354UCDw78c7EzSIi/kFh8XAkTRMuALVEd4ItCNSvmNZ7iV33dGmHeHqcVnfkoIIbpvuAK/pft/5wBnJ6i4nXlj1O4s4RzREPNxJEu8TTBF7QabWQMhRfL+LXMBRdCYa3QiXlCAy45BXb0WIFxGldfCTJ/TF5/n8szT5A5uYrREANS6IPZ8yDwSYThggGqOFYLyJTWFsXcXFVk0MdodXBMdb3sJ0zo2iJztd2qlPag0oGEUg0agGE+j/930YUQLpUkXGgWVNF26Ca/kpwahN/9D8c4Ym2LdoSTwo68QEHcxEeWLgsgy5gav68Ic990GGe+j2ZUtn4WCeFLJ/AlAY6vJWpG62EyLTvpHPFU3jB40M0DSayX1muDwAqjETWmUfgGq2jAFsqEWtP+D4Sv+qtqIkUXK0G5nFQ3NCIy2akE+tUBalDhGBuHr+aUPMFtpvqkwvk/zOjPPBqtUB8JU+GZPctk/L9JEaElYoyoAB9QAySeW/2pDsJYsSZi7SmPsju3RIcPmUSmKNT20ZxMp1tWto/HHwHNVCjVU1QMXHyly2wzU0BpRzyCWNwmVFUj15upEd8L7jiaONjv33TflIleFY2U4bzD+aT0v+eFUi9xSdW7Je2GPw0kESX5SlE+R0DYjK25KHNwB62iUR0x5P9bWxnKKrXiB348YZT287us5hbh9sXbQnvDe3h1vUkuvJDbpaAlaBP4DQT9+yMbbL28o+By6mbTLefdWDNzzR4tyiaj0G2hb84MfIJz2047k9BAJ1dTupf70jZW/ZdSjagG6vxkh5QYz+lM6g3KO81Nap2g2gAg/K6vv2dVk1IaV9X9KhuYZNZJ4oQK+M3ZKscNsZ9mwBFcENOBbmKsCxBwAKf+wIXoVWlk8mMZzQPSoSZ6ETYtmfwBWCumQVOSqPUI+tGCGzWeagpOX1u8Xq+1s2dKdPWb3RnMaqDf4J3tZXV+nlA0jT8ntbjgPmWABuTATPF4sZxwa8leZ3Sr6wtz5P1t9LZx8V1z9OL36Tr383mf+q2Py4vPg0W3+/zH+zpTt/+WW2+lGSfVQAWXyerX+UzD4stz9I5p9lm/fL2Ufl5neS5cfJ6ufl/B/K1Y+Ty4/S1Q+zi18W6x9kl58Uq/eu81+un/1gfvERrQU/K6Ac3LFHzhje0d9yh24+Q7SHs4pCLmxfA/AuH0esmCiIVYwrhkqndN7nyzLPlpufZ4t/SK5/UODD9c+Siw9n6x+l819t1z8tlx/l6x+m81+W658k84/TzQ/SxW/K9U+T+Sfp6gel8N9P5p+mq/eSxSfl5j2NJq3fxaslQy6zj/LNB8nlJ+n6d7LFR+Xq++n8N9nVj9e3Plyv3t5yGBwtgeWHrNPdbu4RbleTgArN9aIByQgNDZDt/IpaQaOOMQTVOnTX5v2fl6svdZYwrRZGjdRoqWuujFOFpZefw6ShZYAhnX2VzalId5SW5dt0O2cYiTlHapBqOAsfsekszb+1WiWrt6mI1Ecoy+SaTAmW96wJ0C6Ovc/e/gzvHKloxer3veTDCIPvnGGSg3Ji/nHamXQhMfPx3BhzPB1+xx1NhWD+80e/90REcfbJaefvbNyu3TfrEObBJ25FIPUaER5biUOta3nMuY2LaEmsHo/55Wpw6tG8yzN8LxqkJz0MlU7wf4t7j56GMYRfkw/JqfP5dJS4vKOSsLH6wxsAEfsjk12tuoxi41r4kQlduj2QmK3ziSF7iPdlwyp29Qi6o00RPYLjWdMljrAaUfVV1tk94BXv7Gz7GR5T6q7gPkrH0j0YFBJ9usCPfC5P0FVLJ726SCuYJRQSiR/xEHG4+lgJxq1ZoABf3awKo3TV3IxMjQT9wY2YrBJB1GTy1OlOSCZydTans8+L5WfZ/A+TVTJf5vnFfHZxd3F7kV/e5WAoxKoLny5+0I18VeT/9//Xv7j/9Jfzq7eSxZfp+p0t4fvq/c38N+XmRyV7Cq1+nC8+TDcfFIuPs/UH6ezjZPv9Yv5Jvvlh6enFp/n6ByUNgNX3tvNPytUPFexe/3A7/1Vy9dNy9nfF1Q+3i18BT2a/LlcflPnfbZ//8OHzX/zn/+w//0/+Z/+YI6lkUWWMm3TOO668Ed4VX3h7youRJ0GyxfLfffT0v/yv/8tb2c8Wl58k+GTxmwSPLT6cFb+TL36dbn5cXHyYb3+azX+VCf5xSsMAb29Jf4TP0/mv0/V7pTWo0tknCQ2AOXzeK/IPaYCV89/QqKAZMNv+MJt/lCU/md/6eLn53dnl5z+695Pv3btNi25x65ptYLfrdbpc5Nqeh/aJAnHWJSSb7Wz59uK1leobAE3IorWoAKLYvrvdcOjE17ZaQK7DPGqnzwRSPVNDNOVcYaYTqdhsgYNGBFR97Wgwhgro9ddoAK1PTqEQLXgcaa2zKzSLycYatOxEl5U9MAQ5wKBH3sSnLnBPO6PTOTufV/eb9AClFBfaoaKcPC7qOH0oty4+uvUyPEXnrpSXHOJOfimU7BZGXBJSVLvj9ZdZy4CA1mmXhJwWRf043MYKynT1dEhAqHnp0+VxH2o5xciedp29H1dj981vUceiisF0/hVB9NHqw3Zz4ju43lYe6kvutT2ScHAS6T08u23igxmfjcBLFnZDPjlCkqw+2cZur0Z3TCDW7Yz6i+2A/rMHJnP4+6VsdaUffM2+8Ko6SuiVSfdQrUJilJA5Dm8l+ZIp0xYbGZFXTgv1CdItBnJ43WesaF4EopFyIlBAXz1YoCUKm4fNjRhMOPxZypPgk7h+v1i/d+eti8t788vX3s0uOEo4Y6Z9yioA4rjNOzZdhMaEyUoy+mD/L//8v/qTf8P0fCahs25UKpTpn8G8TP/Sor2/VHMl/XO4p8mfWVBnueW/Ncj/gCpl8icEfNJZzRAgzP4GB/if0YWcpH9lGX+NiCz9G2vdfHR9/fQHtzf/2X/E8MSVThVQ68YoKrvQg2fu1aXM/ZfjR7g9ff/OJcJpsB2AD/MxAisFNapQAHuzbLH4xaf/3f/hv/rF7cU/aDtN/MZZDMlfmFH/1ub6/6l8kvxLVlMk6d+XOvHjv6VbPUn+vzbz579JgSd/Xeb3tdqbARloZ1/aNrKM7LCJE/f/HwdyZdm/0DqB/F+uV0l5/V//o9/5wf/pf/+/eO+9p9vNVVn8AE3md5KLOz9Q1E0ErpalV7Rtvrgsbj+f0/VPb75antYIYDXA/MvV5rM0vUOJgI11ZfEWipYZmqiAVTHNSGux2oMcaMjM8oKEVoKqpehpW5DW+RUMBbB4gJrFu0W4jAXgLlUpPanZ5GXXKIwJD633g/StqeI0MOBApl8D76XpDMYx49/fON2gGtBhCH8I3uA54SH23FD8MIHNJJTe93yswCQuILXGgiKyUOyhaoTMI6yDifuZ38GJdaqnXFr1Nig0OdGj+VE8W7HckPzgQ8ePpfdYF3GJMSPwwclqv/+x/ffsCx7KWAl+96YJGkYjZ2IpNyS5GsNsG8jxwxEkMfl3LH2M619KF9x0sXo1fSlNf6mUOvB7Oa3YYuc7haIsXsfE9EQ2Ht0QD5knNJHeRyaJpgApAvKgxXQDQgSp2EjvLrur2xQY1Ar8NY+asAsUsuvYSRPHydWmj/OPy/kHl6+/nS1ZbDnXFH2hE/0bP8VvcOWJWRprxhMW2R+/lv5BXv7NYklMSXctgWAVk1lSC0/FW3EfSlhPsR4U4SkslI6WZr6LR3HEe9LLNPIPYYpGC3+lBQMfeZE/Xs8/tfgRbxAngg8fWVlf4vDyX6almi8qMkW4a/7nq/dWXy2XabZcLAngZZkVs8xXMK4pObbwuihXtzIWRufX9JhosQCtca2g3ZZrDtWi0/xaS6XXd1QKlgZUZsuysGZAQXuNmflsy7OhP/56ffWjn+Xvvs/Mewpgob2drAZJJpNvqAhWUtaLT8/8Yp7duVhelqzaJci3lQIIzMoPkvKqSB7MFFFRKooqsExNBBUObHjCRBhqfbE1ERXya6UBaEjOys1WRax8DIGHoNi20EQ0Tf4hB7a+jRXZ0jMueDmL/1Mu8OT2cMUP3bQUDKivEns80PbtHvRTs71kQvnchPTTebZq0OkMJ3ktSPVEeJxE/F1BCjUDg4b8jmfCJZyREYBm2zq4tNOaiVkG3vsTrmFgGxO0OPbaAvDgltOB7T/n3ys91jZOB3OO7gNu2R4zH0oHoUMIAd5jy4E+CayOSHRqzhE8jiHx/vvp4wBTWvzdMYFYMziE+jk+VhBTDaaHymgIPsioP6OvXCbXKQvqoqABu/dchEH5/WS2JAZT1FuFJwrULc34wJvJ5pbiKEWEBIYWi4NL2uIk7iaCcA2Yx/rqvZWnYa4eeC2nVTgnFMgVo5uiBFK5VjiU39/OCS+JC6WBIlNNt6B3WTvJ2I6f4l0WC30sfj2//FhYWplKfAaJTdxWHnGdMZZGdNQSxlnTRCH/zjNVkG+RIsQwsikfIoCbdNaHrEI9df+iCfPQn7MO4T06s+kY1v5CksB/sNScIGXPnrAn74NnDyIybIcHg7ZuYnGuK/CKlOjlLY1MZxzEbBr28CGeTq/ZAInzdtleKVllpTY8UvNN3tDdGlVsiYMzPrEcFahO7ZLbmBNFt/5nuMFcwsydT8mVOzV3a83MspwdddQEpAZo0j1LbnlE4J3Zjxj/KdO/sQqheT9iJWLNyjfhyNfKkSR5yuIQ5uHnVBSqlkpUK3nL/GHGCECyVEEpNOd0r/uWljDaB1W9TtcbxGpDH3SuvqrkmxAkyjJtPaoFKipxWYymQPJHaXaVFt9XXVWWG2GOdS/2+ngIKN87WffepQk4mM+lQhi+3KhmnDCMXfUKO8KU3+4YJ043RAy8A4fwh+Axz773YZxfpY8oix4uE0AjvzWH6TCwq/0ZfqGaVlDlQvyjL/OEa0q57GfjwiaKnFxvgy0tBYbiBB/3iJGPtG7Pd5DC58LaqhY0pAw5Ia4xwvFOC+M08dbH2VWZyGCH1kvW5Q+kF3PH6CZTXX3GpTn+oVSB53GWIs7/Ap+9ieME7WX7bUc4uuBahu/l823w/z4jsIHgQvFFsGYPieE5mXbOtE5hOEDlIZE+1StBZGZsgZJHlKVQ3mNDYm5x8bsS/qSEp/TetG5Xwhepo65kCagR51+k8085BjhJZ4o4JcEnXUiG+l71SRxHPMom8WzR+dNk9RPNAdeqTXqgobGQXTfjX0k2tRSySUPTX8GbX+KMfKnhVlh+lWfImmwuQlCYECLGs8+32adsV6OdRo3S0GWj1NRVc7cHvwHyvAh2U0kX7/dYLeTpsdLOveo6UOA4UC2YrHhvy36sCrTlVQiwX4TkqyqIXPG4MeERXxsL/4SH/4kbF/QQ1p7FXbQ0nJIEPfGIZc9Q2gn54vZn2eI3bDWkQjeeMDBslSYoitA1jEN75HLLSAIDB64djDIGBRZ5yRSyd+mh91ac2i1SRqdHK4i3uuos4CFbhaCBI2lIEhjZ4KGgB9iCQkjFy7VkHSbSDGLxMl8Kw7W1hEyeegVCM7ZiUqW7PNzJNVY3/7sBkU/OcZ2Lzzl0ORuPsxhFPfK/s6m1l1FddSvE1uNe8nMgIPMs3pumy6iF6NGrSkwkhJERgKht7VRu3lB76IiTgGNl0KXRR9tsn7lo4TTtwoSYycS2u/zb5C/IwHUAzwEOQ2C3t7ULUGzOEOEIPJDjmW4LNbT1A9oQq9ix5/JAo4UaCQ78VSGjK2gLrGtLFxKR9iSrcYCenB0It6BDt4bHmuywLeUkLWDMobf/pmVpRT65TrbEtR89srHgIvi2jRM9D5TLYB2peLbnGqorFP95fW6dBhB4KaCT8XwqScSlRgBRoUGs357FssnidpL82FQkvqKbXXeFWR4Iid7/Oys9WAwmZqAac8wnKCScIrgHYlNoNDbAGoB3su330lyHf8GP8E5cpQZvPEIz2zXI8OmchnG2/Heb5d8WrDHdXBbZJ9LYojpwpZpm5+fs7SMFNBfIYjbyxIFd5tWQQDxKoaviREW/dVyrZ7KrHKXAkzoWQK7fKViQoF5gOrwXbrMsbV7OIsDQR3wkaNrV3b1nGh1YsRD1gnPVKwHQQU6VMWaPPlHKomXLyW7/6Xr5r6ywfGYUrrPQGFdRSFQJxd3qX5cY5UAuCAE6vMXfeBpbwa0uUdYWwKstYVUBHNUtFWu5fnu7yQtWEm9/yuINNfEKbfWqBpeJUPUSO7A1xYiWX87x0GolXskW8WSL0jxdflqy9VByYY0P9OFStmmo4qUiwQJONDq0qoCVvYruleEuqwwxI2Ai4brIZPyCVrFMFk/nIpWM1olluC4J8FT/fSRTpNrZiKv37SS4vT36ObegUZzQymk9DrxnWlgv4nHcd1P0HP/1abx1T3urjxSj6+D+mqIzmMHwkADYrQOqkTdaDqf5pEc1d1OsdK/jYrmT622POAPFv/KOE2Qe5MBGbYmFDXwHa3yXFmTGlMPpWDO5S++aw67YyYdRNrEDn5Bo5vc8gXmotj1cbhgUPDzdrpvQaFx6y429jwD97ybU6/JE1rjOXZJDIVP4T8FxudMxe/U8kbyX58nAWKlzFr5HxVLPokJjTeBjU+35VKxjunuExGva1gBYdOa1UDETUYs9QAaJunx5VoDHJv2qqgR01lBQ0lJ88JZXbFUhKyBlrekX2ZLzuZjw49GX8ZUCZHNXM0YvRvXaMgVlk1z9TnH9uzYdQ8fEenwGqUVo6lqmE1stGAWsNmeDTymLFR5R8qlL71oECo12iC43yC2RhnKPofgUo/zzMv1EXea2etj8IwwLC3cFtUvVGC/s00VLbdTivz37o0BV8e1S5l7yWVS7ZcujzdUP1clN/GEFar7XKIh8RSe+fMgkfZUZWfAmxldYbF4FZP5XnveTi1wFaG6UeJ7lbhUM67tJFwTvs/nlh/nyN5qixTag6oGHMZhcpL11YVUUcLnk4N45k4fgoO05DQ8Jm/eL1ffQS208dSSJXFOa1Lyh9ai5TPZPojGFTn1aEaov+hOyil4/7qTRWE0Ia70oB4X5MK2YsAFPTyNVqWlXjSr2gUL21H8AVTb8/ZZeO7e0HeA+G85v41sZ1n524g7KSYCzF1Io+JA4Sb+Xh7jlqdbjC9fzgDp0pG5egAcWY9sts0Rrhxkb/SJoAcqg8n15FfLgScC8IrmmtLdinDhdq4Yk139Iv8iKmmbos49/L+4Qz7od1iZyF7mefe7a4XvLO7QjnWSX7amO94bktgltjUTLUUNtfRfdQg4M0TDo1pXehQTCiYng4ZYCsbbBS4FnFxKyzp6INTk78x3DyXVyR9KbivgE3/YidoCUgIrayrQ02laZiKLi2ciBStMYlNseGRDQXiliXv03iEJkwh1ICUcU4ln0wwdrQom8ARIAMUFcghQHKoJmjvQbaXkvyR8qhBEcDuCDaayZ70Fn6/YNxWvJ1xY3EbiJgy7t3gP7t2bb99ihUVuvaFcZLo/5QCPIpPcXWoWXmpLBisyLX6YX/8BhwGl+QTRHEGeBmrjxP8m+sBhVmqmhIVHA9Si2gblEGFd5SXDTTW6rglqR0ymt2erJ9k2Fp6unxJop9Xx7bSUCW6Er8tVl9ltKjO3PMwxWYbQgIWuXqPvsd5DBlEn0PUmaVJISQfQoXD7lb+4yVgWmeFdn+pKef1Rm/6P23NcQDesc8BxpnGDNJLeOtIJgnKkQ2dxWseajrjzib3G/mgdw0V3TgeCnONx6+tV2YPSmzJ4uyz/ONj8o8n+uirN+2/hKMZMuLcWNmy5O/1XHPczJ4MA4Cpse+mzxeZlzOMNdk6KgX7qp3aF3tRCoVDTbGIHQ5CZ4qZEjpqrDqiBiT4bJkSvUlgBszhE3/IAicLSWrVMIwdSqeu6pRcOXv5Pn9k3swTc++pa9ugY9EJxjzjK0MA5MXvhNJDugOjMeG2/d6G3cI63z+97CaTGPc8Mv4E7FOHtauqt/oBv6ZXe4ozUsDZR7E+M+6ZJHXurXys1gm7Z3RSytep1yoFznMVIEXU2PgBzqwxofvXqN7KjgBgRjKiLeO2Daj0qTzx57p8nsKDEAiHUbQKnAyA2iQzpAxmlf5fZ6IC7pON1FHs/t4h8BCWU6ndZLfzrhdCsOrVc3jT/dJ6dhdu1oQXisIdVngNTwrgY7TIsC9eZRUWjHG+IagjbFOPZDakFSqYWhZDvcwiRCJBHY3UI8C6QqbuLAewx8Z4KGiqroZlVwVpFZaKfe1m05v58vPrEJhxy05K9BsCTflFGKBBlptlUf9PXPZqvf1xagWqNJYGdy0MW0EXsTLQWVozDO+obJsX+VCLJAseDUWEhpGwlgjjmTy7M8n89nOp5WqtBQKZPF54XWts5ZNSvl/DI/GKsK5BkS7AJ2qIGmIr2JD5nk2tTc60cpWiulENcfzcO0u7bJ6kfFc/b35CeZP1efTzmeMuLQXM5blv+s0GnNmb/xq/5sSg0AdbU7X9Lk6CIPINsFMSXfZumrII2NBen57JI1AB+pFPXbR4aJtpKqWBnEFGEGj7aIteKSaqoS1DS2H+WIMaktinrMgqQqMyM/XrDoYu0ZgEBY01IpKxrT1D5swg8QWU2OmkN8iJIGIS1bWgHynWzQ/fjLuDY5jLIbzTxejZujPFXhugq2NQTef7Uy4sc43U98VugLFndW3c/E7LfRBUfV+B2RXlYsg+v22IGy3511a9gwue34dkp0uNXlYvqFRW2+DsdKvxGZXZIRSNymjNMjJGTV7bBBrH67DL13BmG/Fzve2yu3V6G6vHoyR/R0bKcdGsM5Tp8ePaZUu7qiBV+dqw7E+kzkGfstTsOqt3xjEUH/GHiudFyH4/QE/m6H9/0H9OAPciNDqyQfFcLgPsQRJmGULu5ENIqWLKxRrG8xEKERHdzXabrkC6a5IrY8gIS9rWyZ6OwhARVhHhAiLUQT+TEzJ5vNiKGLcqMO9vRr691ne38pBx4TwJmLTYwlqut3OFM24axWHj3CUjtBncbWhtCIgWFCi55ZsvxFfvl3ajCgW7lhQggsrYOW6T+K4XnSdB4bOkCKrJM9qKaE3SXXDDeFqrQZbfoT3Jlt6RVB36Yo518q0Hz6fr59PynYbx5XQC4mEl1dChh3D5YWUp09/fMwkqinv1eEVLKIlU9XT3pWmqlwcJ0kLn655dSzhMYeQa6Kk+CdXLbZXC4XWp6BqTTAGAKi+9w61NU1Tpe8urRVXnWaNyQ+N4jdS03cmm1L7tQuJvFzyNdqs0Im4wxlxmHMHLi2eag+eJW0NFJheU+5B/HoIviaFR6mm9QAwJadhPJF/pE2IEqXFLs1C1UBZOH6TQpNLUz+ZLzYqz5s71KI1qZFSSxRtoqb6ibbvW6oYJGlk4hV69SuANfroVUeuVCXRpb2XYzCVdgBPzw7LY/ScfDa9aQOojQyDnzPVDsC7fntiGKAMf4qKvtraGQPEYc4szLdcuvRXYfJTbJdEwVjCqVrzAY8+NW1aORNeej8vgeifUVkXRgDWgUmUxLdX6vKPwPEXc8MIPaAx8qxB70GRV7qSo95KtdLIhRMzePoz13NOJCFqzDuTLEcqKVD0mp791aQioG/sauR+ZhImvHTcuLlHN3WA1l5SQUi57HfX3URB8KXLeEm+H26Y6YY/g1a6uV8owrggZa7AsQTwUUhEfRxSIs85IbEFCum4ASGIeEahkcSQcm9WsVUL3c62ISablYMGdA9co3COvmXiw12CJUsqBUz9ZAqgCNwYgI4M38U7ilG5lIcJCqQLRgifKqEEzWCw6N11BLUzcpirZn6UNONrt19xIBwCiVA03SNOWsAPrHIsu5CNiQTAa6iQZNCmLYR+9Ufp5ufl+mf6qQqVnSaPipdtn/MCS799Q21dDavKKo0RmZTq057nqI/8dAT/60HG7VJyRHoQzQ8/ySbfZgl/6HSxld66XLSBl9jJohjGJrjdkG7TE85bRt64HNlVoMKWK1OnK3JJ6mOQ+Z05PS/ZxkARJSwYnoIGA2ZLagBCpUVf+MTJmUp6FeZ0kBQpA6JClNp5gj5XY1JNQaVlcyZ8L9lKElraucU4na7yrZaCZBffJjM/4HTvMBj0W1VwUxPSsPKXepIb5p8jAD4RDVYmkgV2fr9cvNpmT5gaS8/3jYOITAGWBtGgxFVSWoQCrjOtVD7UuZpOTC8hGmtDyRJabHnAp+7NYfEHPVA1T/7NC0Nb+BmWI46gFGDJWb4inNJw/Flvly9Q/QMFE2zhuwcQB8lnkTT5NB6OsSgFumpjygfV4FT2b0wend6cL0nXpj0jqCX0YexTvIPawDekeLddtV4u8Raw+Zgr6fx7KuOI4YAYwUUtfl6yWNDehGmA2Pb4/R0Dodihtl7gdBb4Tcnvdt7MTImELTyRKClvMLcxxbOSY/NFrCXrNeNkRoyWG9HVZlYbUbkOvtYySAQoBO2yjHAK1qzF69OVCbwn5iIpcfpieST0drqV30MxGfkxJmRNxXaEgmBAxA/EJcThZvbNLtdYTo9cJzrZKGenixEI9ojTTRGPA6ECMkjLsJ+hX2I8/jL4j/ymK5j0bi67Y27IihFjeK4fivb/FAdrJJMDwjwKuDfmS41UUGz1bNbf5su/1Znc+mwMIJXLvRHplQxwQYRAdLg6SLtwyCQKNN5OolxkTJcMs24aSGpuoRlIdf63dn6h2W2NgMxU2yEroSJCpI8Q1zqq2IdPZrE6plzGLgGzwqoqdqfxqK5208LpSNWfjet7SaP8cxADW+SD5PZL5OCVpNKUBNyVMa4s9gWGzsJTuWiElcWjn9TnskfmrvgAqY5dPumfJ5/7X6jDnkxQVzo/ASafgz1aFoOTHButv5huv5Jmfy5FaKVozFDLalmatoHKlLNOEzAtKiyVH/K5afp7KO0uE27UwpDIl1QmX53Hu/SFHQ+mo9EzcXbVJySc4st30jgo3aLiZPd2zcp8DT/CqFejbzlU5YcaSw6EC3Bt+NtAarvmpJ2VZnC5AKHT8eRFMD4I1zkyUt6Du/2kOkJrejjAtMYOnDkfuh7ZhJ+FAP048uL5sMhJSMOLeVFOpBb2b4jcDF7PLZDr0eA+3WO8U5Lu/5ejkPj81MkDOk5BK94Wv05VO4enlPU7eC0eXpxDVWJDvnNAULdRKOxa6AeDpG07R3Cq+GNd4Xr5Fl6J/g7aI+CNSf77HdsP7RB2H04RGyX+lsAOcor3wK7bk7FoSpxLk/CZ5zVeO4Uw3tNANiCtx6ncP6mcaaobDjDTlS2cvlP1KMYS4ExERChkz4V6Shk4RhX7zIlXCL01s7uipzlAWJ6i2mMj4WBglo7Aa4aECDMoxdWcZWaCmQaHYwVYdMjfH+2+LX4qF+ZLGHYRYJ8kv6fNNyK5PnvZ9d/KG2t69qZSZ54GbJHogoD4SdQuATinyluSnhOTQq2XWIEnfEEHycwxlEuPivy3+jAKanqJphAaVAxC8JEHaS2EpHgVo4/7svvJZoClEZirkK1S1ZgsoLzdP2D4ur7eNiaN6677gS+8oV71z0so2tWzqe6O5q5jZqjJ9UhEgT7OecuE1Frxo13w4u3KsTiV+X815k2VvIwvVLNP6SfZEkcbtdZAZokBj8nR3tOZnsvW0vzqlCUY+Wi0SIUoLNfK9etxDSKYbzspmogHfg0jqoZYm5AEwrYKUDz+iY9TDiKVaoKdNI1nY/54yRZLyXxgAMGwFVteCktOZ9SbvyQC84n5+Y52XftjGLgdwrLl8ulbW161gDUxp6rXTLQUqzFnLGkalaRxOP6iWtG/Z8NnpGsfuy6P6Db6x/j7+lZ70hp6BAzmpwe6v/Yy4CCi2vRoCYdnQc599U0RLiglrjAZKgd3J3RGEhI7O0vcbkxSZwOWjnQ/RCP3jgkJvF0bEXw/BByl7wXMuj5Xuxh4CAfm5CgcO2AS3OmRy7zA8GRYh+icUU/7gWLu5xw/mkyf5IkH1ikqHjIZnWDSTcq/wiMiKhtkghM9Keou9i+IczsPgHXFhQhib/6ZhUBUscIqgisk3L1dkHPugK0KrBTMKc0EP33171FcKrD5cVfZZd/qz5ptq9JVlq6KzT9gYo4kXCRkC5YBRWZyvFWjdCEZXSWobRBDMMe2PlH85Q+VsBpmBlbAG3eT2afpbNn5fpdvOESTZyTu+DdHWjP5X32cX9/nM7vi2r7VmVFD30TtG8NgLBdD3GM9KyT6pXHMymz8uUri4BVpuYQXMfozVwVBG8ZI7mO3NlXhuC+qXkhQXCAFcSQSQOxwQDkyJ8ULzOFWNGbl6vfLa9/XCZ/AXMvcuVWl2qMalRVXJQ1Az7eTKUekoeSWUL3/4KTgC9hWGqnIC1X4PJV53b6ABXVQPa2IYmlbo9DdQ8KW6OlzB/ARopq41oY4hnqm60BsIooLL8a/XkVzDxTIwADJzz1f3+xvu+tG/iNJwbfGB2y6Zgd0j2AHs74NZi9h7qbDaWVTjenhsQeGx8/Cb/1ezjWnMc/x2W5VicKio3f68Uez48bcGDumflPj0NiPSOq4JCQcMShSKMBj/jE7G887RWi+3WIS1pK8LPavpy0DT37c0uMP7aAZxf6whji567ze6V/Gw2faFqvvQcBg6CQGCefWH9GuI1kIbqV23oc1+3bk4tZR1jmJNNKwEM79XFKFDThj9BJ8RfvJcXu+Iw7mQRQ9ijVFFwpqNLljHiwMA+Y7dduqiiK83EAEQiRmJyJFsniy1JrADwEczbGq3Gz+F4ncG2S6z8qrv+oZCZJsg4vTLVK9Cd97M804lmjCn6ZnmRWEkynCtnoDMvzDYVQ1ZCFqBGAdPFxOfuNNTzoh5aJFWN9NNSGwv8ihAOS8GqwO4B0GFUcI64yqrqsiViwCxDLADSoomEWK3FiZBU1JSl77c9yBHV6L7QqS+yEppKNZVGBqDhipg151MDgKaCU81+mi19pp04ibJWgaWV3ZJsgHixop6FSzBh9ojS8nKUm/9ff54/t/tmoh1ECsC1birgeTO+v6yoJOcFUNPZCgYV0RCfoWQBAXTYEcbLjI8CgrPl2+PiVcVULQKz6LghNdshrPgVwnOjQxJnfrnRs7ZCL9lt0POUI71O8HJs1IuIsWRiPuOCCkDgL8+8Ak9ghcXrENNAmYo4wOT5rqObFOqmGMQzavsYqXk9eD6jJcainwafn1rnOhnusYZNR9DTerqp5QjDUTxzxOjjZ4BnJGmIU+gOGEPab3JHS0MH4nrndPKRrB97VpELp6Nwh3QPwlrQjDUrp8ABzpEqGXpyhmkZZuCfjUgt9MOR2K+qe0ZuOhoOAgVo9VLLTfTIo0TIG+YT4o0lf6dPe799qcXBQk6TxZIhANDdDO/OQqoI4hUIkiaCoPJJuqNoXxTpilWV/NAc0OqGQSyGjrjJ76L9hiqxE6LzIsFCwKjY9lOt7xYoJ2fS4EnriczgQeO3iK1PG2Gr7nSS9+HflxV8n24V25KRJYKwt6qtEm3zoCdrUTrERALg5B92r+qi+c3qyH0hbsBBJrz8fuUGY3Z7rDABMh1R/q/e2qx+U7CGzWaA1/OHlXJ0jLIA4c0tIVg2wTwfEffaVKoZo5IevBKho2x89awNcQddSXnPd1FjD/lv/Orn9r9Qrn7IR0EpFmSxY9StDRMd/BcpWNFYBzKNVaQvZLmE7/wACbn3/KieyxcGlsKMrye3zH2Srn5bJn1HkNA+tdQmW5IHqTJmLT3yflO+yEZD0JhDXG4AkWEVG9//s03J7acG/AngI2XaUI8BqiaplqkXcaRxova9z9rBeWD76QU8/BpgOahNYi4DiR5aPjZBwSoyX6RWbSs/wUSsOwPwYMoYTIhlm2KLrIA6+MVqEN/P760J2OgT1BtzTUWoEIL/U1xi78DtSIx/ySbGGK/qVRF4sPqAcJ2voVyOwbSV6Rbdw/HHn+b7sQ+V2eVT83UsT/NPl0NAh4tDA7PBv5A5R1Ui4K44QarBKsOGffXwCYTfRsKKRjZCeytJYHeTF2a3CMZ1weCUdecWcDmABmf/10rjavVnfSeBN2wv/GxJBIb601xSTA06ojeM1s2VsIHf4Xm+08CdStYS+wEf03WtTnzpTiIRDcMSWnYp2dRmVRBK7ExzRZcssagvxBfDASyQkLc7mrUV0KCoFX7qTwaP+hCYYn8rxD8cRGpMrZl9lnAOgXIH9o/9O/3S2La/+oLz+fYX+GhDw6E18JLr+U+uB32nF7/EbFeGVnjV/l1rJroD2JDuZp0ScBycmKnEtPt3OP2WyEwCTo/AzvmLVW1lCi7OdrAcp5nfWdCXLPnZySfEnX7ESt7j6MZO7aHArWlYorOEZlZgZKpf6nx7FovofYlwVrWAVT0vZg8fKqgk08mg28Szv6kqKxd+Xi781rxIBmCQjBMUZ+RPSaauV2r+f2kgWJa5/mvCz+X6yfc+qbv3rrthdBafGBnVAUT8yAeo0Aji7loT74EgJ6WMwKyNP86ymo44NNhW8DezJiqBRohVWhWDUpBsoVZ59eEYju8khRv52pYMdDesm2TBKEWfG6Umcj0Zya4JNU/i8OOWmaHNWHPxwkCvOKrzBbMTJnsV9BKfB65iHFu/Wo3Gc4qyYTp7tGQGYrt0xRYMCTubt2tC3Ol2qMOs372FUEfZw6ypC6iSPo+qw6QHs4dxtrXYgjXZnj4TzgAbLq6PP6fJu1KJW3W09tpTv9sGAH3+V4nSL9oDHgVo95Ic9dWayYHouZT7B1+4SYD9//zKHrzQ0cXrHbeer2lEKhOh/9+nyjiiXKmyySHrjfbLWUUrEhGfIpluUu++eRK+q4jwLrmysAALF36G3VdwK7dtDSE5COypqUxbOc129mWzeB1va8mGxmqlQRXqV3oRv9MojcfbX6eXfWmTvc74hsNkjUoY/j+8QTRoNwwVjCTCPGKb3kSvfY0I4P/AngaSJTf52xWDHGgCm/msvyHVS0jtuvjOmii2rEFIM6isSXoMan6ZKA9L7cNweQfE4A2xN2Yi9+xYoZWwjP4tfJstf2REHTPhhPQAOZNNPH5bBbWoCCRN7rVKIVcM+nGt1pILLO/K3bu5eybJSBgYT/AW/cnP1u+nV7yXJXzid6luV8lokZAOhyUoVR9mMADD4I0XEf/ZJOv80Sy7YaHZb7dSpspbNphR4qMC4g2qXNwhVD6xpZ5VCA1yqL8KXQ5AIgeo6jUzUkO1axmyNBGTKd/pqGLryhq+Gi2I0zwh3MyvOPyg9/mYYz+0RdK7fjkHje2QCGvJBpL+jVHzj374Ip595DHV6Lz9xHHjPu7CAFqxpzCmP+dZpMJ22Buhz6FcjxjkuPW772eRGXgquQOFeY1uGTNIh4t8i7z62FHCE2OdxWj9qXIfwd4ate58VXjtaiNWjv7f78wLULXF1dbd3TcgdT8ReqDCnlEbEFPQeJjVCw4k18Fv3OW5jbM4Ls/eGBI0UZWzmN5K+IZO7trgTvNCnF33gcwRJoD1XQibo/+GXU8W0So/5PuAqOuJAJBZZEg4C9aBHYRBxN3M2FHVVl8WAFgABIoYHBSrrLa6kaa4/dD6hQhyAK6gSf0mkqUFsreO6tEn74kG5+FRBFUGahhk8DquEmScUX1tgZr3+qz8sr/6QMwFSRag2p1w8uQIhIRwxorU1RO9/6COtKlzTyckqmMV83KqL+UhMO1GcCqGxWHxSzj5SH02h9kYszy2sKQc+a8HdbPdQkNxFuCGI+ZwbxVGUVz8pVz+2cRUPsj1W1p1Vwu41i5mtSmBLUNcT3M1AbnCsbPUP9dlzcdNcI3lTVcNHbNJy+Yt0+TcqGRVOYOrcRGe0IqFxkpUcHcBUVU30h4ffk833y5XWABCx0wYAaOG/fYpaPK1W07lmZclzBVeWl7jdyVVedeMbIMNtohf4agmoHmCbI0j6nqtC7cMyHs7J7v7ch9mCTRDbovhmHm9Ez3MydV7ce/9wWkAI6YmenFyWE/m9dGgtA91RL1hLdAhqhMQL0SFI80R4PFZ4YCA/jowARO0YMAOVxPqzl4Pfj1Um7lttSzmKp6vT0LaPT1/rqg+vCYOqZa63zh2O0FauU8c9BzG/2N49+nRbkx3IeLs8ljuUHtIzxo/Lq+Hkjj4x1XFpt8hp9/gnEhD8MFQcEW5/sndun6N2y9elhHsPx+h71JPb+mb1YgwAp/tkgEENDqF2DfDP2RdublzOqrP9cr02dx204yk+9l+hlBDxDOGOel51VWKIgDnN16IfgchTZKRuWWZHKEQGZrG9UkRpcCBOUoBs2P7JA0YpblMUTpDmIgm7WF27uZdU++szmMBi0Fo22CbPlIMPi37fUwh2+28LokbtAqRTacXS4nG3oQrQ+O6YMFHVV8VPainPeJNnnAFJKYspjZKQUVPVleYiRJ4lq+8n6w80DZ0RgGQhP1gzwBCqW2AaA3d5XSjOcgndrACJ9wgKwCMTbqyI0V3/ZL9aXcnyl8ni1/KqjgLAXjLxIe6luBlIocedEsQflcYW48t+qV9xJWlO5Nm8aY/cLNaPfG5hutiK89XP0tUfJMmfQVJF4ZCLofvFqsrmLaL7jOMKdOQ0RwHY5K7acToGePZJUixVYnInfECQMhrVEhp/TG3iPgdsZYooZFR6SxiZ9lzB8bkqJzsygaN2qjc1xcS0FPb45TOA518OYJk8qcSlu0ZX9LH3vY0+TiX06up/A7Ry9733avSD+0rDGx4OcXrH8LRUZN2uwGAZ+yrCOUBY/Asbp8Xc2HQ8LWj8e7R3NMDY3Oxtj+3Ty31AzapMH1h2p342imSAwxnBlAglpS9BR5NBKdMxB1kow/zgv7aTjNYLs3U5XatWySTD093eAi2q3scGk0n69LA5lq6H1YsH4QF3XfBebA7p4NjpujW8Op3scMxY1cOp+ylemPL94r8JaHCjJ7r3I5T69rixWcFjvT0nhnQdYbm6Kfa1qEgBmX1tFNgp1FYuXem8lHjnEk5Zb6gCIAuDAChiZh5OrrkViqGMJ7QWJNnsaUE8rlavvFoOisvAdDaIKdk4cvahAizLs7YD+TUrRCkKs0etASjKZ3+QXBEyMm2DIQv4KOwz80TvSkt9BDjY8qSGNGmDKiyZEvIMMdlaHGmcjLCcfZzOGQFYlGqlgIxnata11Pr5pf2svOresPJCdVpxrAH4aXn1I0YANMHJHSWjaKuxj36IzW3cR74175rv3Ae640DNsCeh+uEAPqpWlVImndYkh0OrPrFDVJYu/11y8Xcg61J+KDXHNmbKgT7f6ihpjUd5YVVVdPVesX7PrFBzVIK9FqjeMHEIABGAKrBEqMJoXr+LqhgDtpqkZqr0lCLSMNO0H6sXtCOEIbOVKQwJiq7WY5XTD43IDsAzpST9u3tNM26qU78pP02z4pvS7gxyg4EkQvoMfCewCGXvifA4gfQsKKeZ2+uvYINyR0YABtoxQ23uIfgpboh5xukhnu6t43aP6eHZacviulAgnohb53AIuTG3btux1fqPkY9O72mX60ekX70g8VA9Q0UKHM6b2GNRp3Rc+h6qE1T0Ulu/KRZDUqgAwS3dGrunCGKL4vSBOnflHsighR5sCpYZQvOpRdPzaMbXRPrUf82gqDIIceoYzDdftwiexgBBnkVY6hYlNNzyl2zfoDKX2SNRWyBNln16LwiRGf3Aal2URa6e2pJA0xBpU6zezLbvW9BFV6voQPMvbq2VxBg3C+OWf5Fd/FWps8kIxK9thS6EopQRoklKmwFfzu4bMzHUf/sj6TLAMjEK69Tzok9hKThUUot9C9Y+CI3lp5ty/UFx9V46Z8+Zp0nxfWssSVb8LXa1DbrvJo2kwj68kG/4sbCQ0070YjowQkVy5SwVepI9LdOnZckWQFR1dgHC41tFvVq2wWwoKwHtEQSuVlaoDshRlSyyKX4hmQdVWsKgtvCpcueyJhN+5h9S1ElPvSmvfp5e/16S/Fv5Qr7eaShWUFvZSUy6YdMgDiaucVBDP5fWMGMKGQe0qatesky4mgSVu6hkNBettAURkuqbmWHlLlVFZDVeZnEGsNK0Afi0eqLs6pJdleE1qPvp5wNE5nRRIgjKDPy+C8kVDejHvYtG+AfOUWL6Wyt+98bpiNlwsmmLFfkw8mk53d762OdxerqcVrzhhKGixHym+zOmaqSbvmpkjYy9DJX7KLeY+XiZ9hgbcZ5kdYQfyx1Kh5LqET1Ecw547YfWt/Fk1oGf7NEb89DL3mSHEhn+1NfTUcwhwqIbKiR3muvvUlzQDYk71gF76L5d2u4xZkL2zdk7VJPHJQ5RDcFjE6fgxPg3k460iJKS1Xrsio8RlLaoxuZOyGm8iBTg6a4RACItgh4FSxb2efyjAAm4RU3iT2DPu0hbecIBOqZ+EPQp7e8BhYc2+Z8ZJoC4SQBrAIq51gBY9GgFJnB1VckqVke9bao1AD/XOQDassaWZroIKSeqSh9PC7BjRxRHJ7X++aXoDmJuAWIPRJlEiZiT6ZgxQscszbPLj8rFR2xbY/OU2npKzoGXBLtqSh1IfDC6S9q5Agb2w8GNEKEoVz8pVhoBYFxF3d1yoq+vwHqLs4UuDyv89aKT7+o/dZ03XAl//GxVQLoarhKGV7D4m4lAWne++Jt0+QsrIrj7hZKVnrVjLIeWyUa7ABG+VwpITRp77zE3rPKggndKTnQ2fEHV5QkKai8l6dXIjBCiK+8pcVUdlKo7L1lbQdK9qppeQqkVFNHJl/jb5XLd/KBDANZYrz5fcg+EonvJ9TxOPav+FWmoucexOpHKvygvVofY+hPVN/KYn+rNLNHcQbo2vpjKffZF/9toCoehnm+06q3EMc843asrHJwPrWQSZ7iitmzM0FV1SK/ae0W/0Dblge3dWPmgZww8Ih23y+P0Eax2JFHp7IDNVLd0kE7B9fajNEl7ntwbXrvi+tCDaqBujR2pM6q9sUVxuv52xBVvSCjwrtwKWSG19VOOEFdZQrRkSHRo3BgHW7oqWc1CLm1Gcto4tZQwRwG7fzf55KWj+TwERSESg5LoaPtOwub3xEX2pINjpYo92awe8Mv8awBiojCeqG9bbu4S/iXat4fQCo4aLhAmIZUW/4qXxb9ptn5LG+wgSAj2r8pGCpdy9F96Me+fHev/Jln+bbr+XpJfprPPiAAt01ClFnjsNnTf+ItGa1jtshDP+YttsX6doDBhLyC4b15X2Dd7gG1MNKfMOFOWKecZMXAxL8s1B8KWzxkB+KDc3jFTzHvSU6zs3rn17MRvOJV7ZXBFKld0yNuAASltNJ47mL4fxebNWIwhyeW0ZygUzgEoL/8V7mAyPUMBdiADoTOeZ6U1CcZDTEfpKa8SXkOrgFk89OEWcHfD7NFMpTJoeYkQsxKf8/E16BzrpTGl5z9Nn/9xkv8/Rbd5w5R3Vm6F1Qvxhx5K9l9CJYnkP/VLY1OLz8vZpxwQbZKVpaYF+MKhKBHNwAVtmrTcvIEmaf61lGbMalsks4dUH0c2Achg6j83iAGrOnvTl9YDjKUCIOkgxyHEfq+pL925/iIXQuvy2qg6Vl1iXF3GUGwDJCRqFH0230VxzhnTg2+tE2T0/Na8EFtc5eN+ZSaaGwrNy9CpYnun+zOmakgf9dXBUdYot4bc6CFYFxJRZp2MOE+y2vGnxUXdLwQQj2Onfy8GPWwWjOfWRu4+hc8exd03wA6lkfL92ao96Nwe86bg/MLpGvNug1fjAaquexoYhz0cp0WQ4eRnVEolbSY652CrPwa5I4m9yriIEQ6vsk7xwF7/H8d8b6mFqgL/UHlC4lChMTdo90o/lH8ffkumoxwkucPB4h53QvXeoH9dszv8NaL4B2cp3iFe5+1MSOSxCjj2qHzQ1UXuRARGIuHO3GsnVa5iKmESVxGFWeRkzAFqahATdZLFZ2SYFqIDPTKtwjURbFKUls//IL3+eZL8farDgMXOFeZDKgOwYE/8bF6HxW0KFWezGW0TC+xog+Q5gS8oM92z2ZI1zeVsqYNmWWaqTY1ov2SbzbNM/d+0BPLs4jOdV1DOU5YBoGOll2tqWpgCVUpaTb6k9wu4XDUX5tqrJaaZOPSqr39UXP+4SP86yQiyPQT2PXVoE9Is0qat2KwJV+5hL1a/q4y5VIJ2dhoo5n0+aELp9C445JpPVcyI2inrQg/wWmzmvyiZ0HUtfDh46ce+AKJqI9/OWAKS5FQ2heDgqE5BtXmv3LI6/H6lgTDJAccAjEPQvGEiE61UiRA7fZLrf0IGqCfKVLlettyBaIkLDQWF/DRl+e9klqWH0y9nhVxXodaFR5N2uoBXHF6YB85YLY7Q2evLC9MhVNgjVL0Jkheiz4AQd/1Eq2LkVmnxYzO9JdEQV/1qNmD7H/jJt9dOrNJ+qkMwnP8hFIO48Q4/XaRgCC4N6RbauJmHtiNbzKc+Ru1jSFzbqbSGN9RCne7quF0epw9S4wjkrv9Pkd4YvyJu42r6NtYQPwe/uRoT3eXIoVLBsyE3lnFoWlHpxCvIb1EMGGFY8ZskTlciLUiq03wqTFK4o0v0irr0Vinn7LP+NEk+sLAJGD3jCsQVWAsPK9ia5Q3hZo/tmQQx5NdwUaCmuzhyJ4wqSvWql+zgqfW8TK2Zlat7afF9Ggo2W8N29JdkHnVzw+2BkA4ZaXrx19nl36T50yRfE9v5pHInWK1WTQroYKBw9uLi1p3bd0wHMZvlTEPfrDd0b98mHnzt9cucED97zSJXZDBFJf3660cff/gcLRQSEvytv8+Ok0l6rT/6m80J8JeFtZqmtfjrinfi9ww3xk8aZp8ZAQFJgu5D13HnAMTcrG+pklXBTSI3hbkK6tkCyM4BYIITXyXbrdVCbzA22xVBsuykrbDV4g1daXp5cbm8WG42tvlmRpNJ7TH1jmfZfLlg8tR8vuBvNr/A2+bYlATx+7Pnb/7ir39RbFdUhe3TPyqf/36afSRVqmJHlAToJv9QXZztSkpU7qb2UWPJzZL5J5zRlqRLVTu9AYQlamfAmAaNF1v4m+T3U8pdbGkRfEWxGjOaBgCgtWonEP6gblrMz9ECjFAVz6kRWGYa4QAlpApXzzdL4CDeH3b3qO/fgZWaeiBpPI2/5UozRzvnPbwJz8nUeY2+h7tv+64mN2Nx29BzvcO76wpiSW5v18YYp5vueqmL0wvxukOW16Ou3FC/eskPBQZxLcKuXEcYglfkw7/dMf/+6mG0Q/rE5J4e9/BgLq8ILvUCNEU1n1wE98ZJwAHKG+N+9BAxM7jLiBCmJv3lNBW7wkM6V6RDBT/jx4BzDpPgejpNr7YODFkIdRKXfpAOTniYfidgv2BxJ2h6HlLK4qDiOI/Uuj7ALVSSVrpXUKt0Wo8v1hCXNkFmS8vKsA5hjGZxlUIgRfZGwF1RF5dFhPXIpMDEU5q9LRqiJS0dqHqFobeQKtfMacK2gnclKwHkaMVYIiU65JnQivibEBFYkSy+YgTARhIs1PZ4T6zFxNThgwsItNvk+g/4Yw2AzgHQkgLlItjS6qbWFH9Wl6rLWvrorkiRjtxivVnbtVqtV+vNluB1Q0i7LdbrDT3TEG631ssLOmooltWEd2gxgC2A0vlv0mJuu0nKKi7T0pMT7m7HBMRzo3jhIz7WAAslh+JUKHz9k3T1EztsSycB64/9dojlVb72T2WossOf+nMvb8vtplitr+VLXIn7OONNjlfDCPfi160WVLhDk5wJOPMlzQE1BJhWRAfU8s/S5V9Y/K3Y0egqPaWdFy4lY65OC+qM2qhgwFKjSxCoYcZBco7tP6BVfQPkP9hQqHro0QN7C+KpnWKkeq96KJ48yzjhSwirWtTOIMu9JHy5TX4Qs7FrL4KI4de8OoBm9m/F0yTPvWSe8HLr3l+Ymjgt1J1xBwa0Q3UL1pEIfyNMHGcE4TuSNdFO0LrXrqj8B89/aLt445AdF3sx9UoKPaAPjFfdZgq43ibm99UhMctx4YfljvYQjLMKc/iCzi38oDMIpLuGBGCL0B99Tnlg0ovzMgDjFmq3B8KtDqMlvQrvaYv30gwDY25xuksx7v8u/jiksSJiQv9Bb/0ZqkuI9lrU1aGqJ9Nr8gDmuK/qKtytj11IU9PgZbOtmnHYnaFI7OTG0xX+dpnbJirqQ4VcEtTrrRtxFuEXW0Mq1iL4oe9UPcRgKloCRjDELjFfC90DKjIUmcGeflQCcf7xAK6iaMVYBGPkiB+76xDJv52uvme6ENsBMLYKtUwPseUSRwmF+PJvyuXfaD2AdgGys1qNhEg1ywCaYJEixRTcvi369Ck5rOXV9BaeGBbQMmJmvzClx3CFLt3UI25Rr61mJsh0ffJ080HGXpma0EJlYzNK01ReEAO/xLpOD35u35I3qms/elKdA+BEE/Br1tEnVJDvxBoXOQocFQqJxT9knARM86ZclMmVetbVGqT5o6aAs3JL0+09csuMfiwYWg0p7rE8N8keWB88TrZQW1t2ykl43bhpZMA4kE/zj6GGZ6w5Lp7/Qfn830uyPyXLaok0MnGmm1KSog952racotRQSYWO9CKl+3/+cVpeKsQXAnD676EgtyIH25JUOxlmJYhi4uwklo0MzU+qDJbVNhLCjkDZ8yz5oa2QcV9IesVTfPsu/3Z3zwGQNxCrRsWES2Z0roH3SYU3nmtI8S/IvrdQR/o4YPQ93JUVazLO+Ly5jd8OY33cmED4TQnqeYnF94BTVbKAetZEXFM83fWtK3CcGjH/WHHgMPRc5xzbG1M19OnW0i4kFjOajqWPIjYyu7Wxkd19GPjONuyKqNpjgy03Oaa7z9Pib2+HiMm0ZOzmOL2P+hDcfby+uXy3gnv4G6riL6G9Q6p+c+68WcnY+4JNPqXQQ41yJmje4nbDtkxkH6G5xj1l2FI8skQ5Fn7x422cLHpSyuK1lINvFW2DpnCQnl/2Ylf8I2ww1AdvZA4Joj28BCi4PrTAgD9wibz0olNPKlEYQdL8U/ItojMNRGGXQjT9iUrRJPF6WTz7g+L5z+lftiWhoJmWNT4UJtJZELuiqHTlrghSd8lX/zXreokHdVSU2KMIc70N1zuBlVckW7aqhBiqcv6bYv6htTr4rXLFXKrpUCfJ4PJ7BXNdqocX/iFVXJ1YD4qs8puaPBTE6qfF9Y/KbJWk/Kl0bETFkMgHW3e8YC0+OVEo/JcP+cdFwgSRNEwgzPWHFTma+c/kL2qYvK4/zlPjWq6Xf7W9/EsrNNuzXyxNlLi7hnAwzZnHL5KcQRiXL8E0IFffzxgEgGXViy8O1lZEH/C1gEGMbMKdaczNGJq2Eqao36SKVHni7GC0DPK9JnhWaK0Ib/gyNsPZr3IGPPCd9JtXugGLTwXjsdhpcfpU1hF91wQX1JIOBZAucsTp+GRXlos7nuPBlOezzN23U2DaLkBt54pLG7bjWae6LZVAI4Os7S5Oe68T2mouZVDCUZzjXvBgESJiW2KcQekRycGtwwGmE/nEagdOU/okQmvbqULFjOGxHxytWxOCUBKVzg8MNtqj0+U2zjmW8sLSvb516VM83NIzcCMYdcd23dsiGarzXV9FtaWHa5TbkNCGBxWNR7sfIpAGNE4fuZ8wAqBA2CqQYiKCJqIgPdLnTeyubn6FeaAo0FNa230q7iN0MgJQxULzP6AzbsAVWNHrqS5/UgRT9MDyD24mgGngm7dSDtklWtT3T3JFZZfjmDCD+R4Jy79IL/5SbRIdyMWkf9NZ+FIfptLDgCQlKtd54WVySf+x4lHSLERAT4WTjDlsmZZi0krm/YtLytkCWPyOQkYOG4YUY2jmXP84337AnO80f1Zu3tXCWWVJqPygD116srs/tu5kHXtV/PeTt9YMVApCp+KsFdCnectKB/Dif7STgBkBYEiEEpdJ8iY0apphPyUqHbL5V+RUFqsWECI/kscs39CEVRRbylaYxT1C9nwunprDM2MM5l6avJYkT6gG5dM/Tp/9UZL+Sclse9UuxIEoPe0GKy6gbB61svKBD5gML6iYGfVJZh9lLANIL6yHnm1MtY2TaKlXwtFCEWu70p3PecZkbtX4M0mwxUJVaPYk0rQmRrpkpSq1ajLk0LrXtBhaIkXokPAgQPvSt9swWxlR339fdgu797H7To5/N7u5vUxqYPctVOe0P/0949DpVDGXg6hqT8cMGukj3t4N+uZDd0ygmX+eJ4ocu6orLrU4Xecf/bkT0WTR/qVo5nafYvzp3g7SQ6LLuec38cB6C/PW9yfWNk73SDfQQbVxiMlhcPdIS+8GC34gucY8V6H3oPSAKuQpH6dRT5HwInAaX7COQGwcN3OsaDrczg4Y1+04cfD8Zo3qVdsLItx7cV5CYNeTXciZ1D6IcY3sn/XTdE007YF6QkBDuKM4TV+TUHMU9zACQAhoHBUf8ac4XnXLH424ygYiuPp9nUQoxs3CKVIEVgotFV+RMb9f5uyuA7X+i7a6rMkgqDFUjs37v/pH5fM/4lhYOweAcK26jE4RpGSJMV36RIoujsCf5gqxKhcd3FLbTJYtxKTa7l8xPmCLWZGlVQ6aHC+AMUyWtkyWRaXaFUeO2qkqsburSgeQm2X5AbbDfgGpSIEgzTXRXauZNQJQXv+ULYBSRgDkRPlJhctffeFRkprhT4KkEvhJLcPCoPK2yXJMOZyao3AcHCoMETWBNt7jJOANLQ3aCMnFnyUX/8YksjicOgEzhNRCqWa6FKJTG1h8ogO/CsoRINxhir7fZxtZSqtem06ewGImhcVOnwLygSbQUZ/JqOygiG1AiZlL1AHOGtNwhV3MBhOV1RoqgzUGoBS+HGS8eT7mkgWvrnEPVKU3jvQq9xvygL5T+64XU8unaLJP00Pz9X7ZvacmUu+nGNkFaKCN2GjruCcQQ4L7IZejh/uYT62t1pAbCRqCRyjDyYFW4JgyzV3k3e7uDPhDW3uD+J1SGLe3h0+HQ3BHq8TO0icRChQp424MavToHPKOSAzZa/DQj97LeNy3vSRdYMurDQRb8eJ1xu9x7pQ+j4kujdmOpAc8jwWSM5ALvNai/uz77pM36AmLcZkfr45etQEcUyG8Ap3tO8X2jiI70IidFSVLEAGQyTO4NFSc5MaRLjavaS549sBaDu5n8nXOgLZ/VA8Q9OLPqb2lDnIiZUzF1S32MQGQDSL2pLP08i+3jABU5wB87pIt4ANNvbium5TJ1G9tWvK0JXhkvS/xvrVDTLo2h2FSkVavzmbsFEmst81LlkMwbvCszDkZV8bKLcR86x+mq5+mxWslnKwv2rQUivT2vR2wJRjhvnjx92rNQCTY3Tl7oDLa7U2kJyy1Ofr4lV2VviqLhWbnpytMNgdxoz7o+AUwq5BXjQKrGqoKchAut5IHVb4yngr2dYYADLKnRTYrkiUVjC52VgQThSdaVQLKdfHsP0ye//vJ7F8Lonamis/KDD6WlGwBVSuyDS0VW/+NSkBUlHT/p/lnKWrbFq6ooIEFmgOcAy2k24xw0XRQzRUjKvmayWNmPOMHqEyVwQ86+QFuEGBn1RKGQjapFpldvLJUrfTEJUO4m56hbSBQ8wLL0JvQztNePh2KCDDwuxlhnCE59P6ZzlrVbRp2983fdWP397E7zt+FTJO/w5ryK7DDnpDyyiA/xKUWpweYuE8887iy6KEa+nU2MQ18e4fHqk0pzYnFHbPdmw51o1UlYm3j9F6GASFwDpAXnvC33pFi7X0M7Tm8Tun633RdvGZPxz8UE7P8b4Rwug6xkzy9l/mI3FOygiYhcQq3Edrpzhlhct6scc+fyyFDfNwh8X2idUMMJ5LvQ4P9FAlNtGBGfzH3Q6WJBTIKevgRIrQB0UI8BTsW2Kkfl7AJuGK7+juoOT2mpa34NBqoHVjRwVLcYZvZlB9iP1tVKSkaQPB95tP5/YKDnMQfhsRbInJ+VcLib83U0GSkTfH0j4urP9QCAJ0EDAoROlT6IJYznY3c1CNUt6WnaD4j+mdPGu36w2Y1dPRKkIJX4MK1xgDbkjJxBSp+nmkvEAXLbxYGZxoB+A0RpAJiXaI3n9inGUBK+PXlGA1QnfWiPisV0AHFuPHsf6YpSSJa5rts0tXvJle/wzQbO/kL84XLhy58qwKzcBoG8hVQvKQjn81eTZYixzJ9iEDlqNPT8CLhs90VazDRB29XZTfP0ovy1v9Q3voTLQ/RhC7pJtEeYXtSaZRUzWQakCZlFawhFoFUoTlH63Hzrnru2foJPAObuTCTIRQmtcBYU9rUxpnt7aPgXoaIP73+2vvIInuTra8DzDBQPhCatJCZzkdyTD1uR1zmtCPofitJVEZmuCfC42+lM75Jo70UggatxwB/lTjKA/5O8J+WXgbNNmJ4hfS0dUJeL58YqDe4tsLoveK2b5x2ZJ9l3oIjOZ59DubEWjLS9oJni0nrsUULftcnLZwWB3dYCwflu5Cuo7qyujgNyJC3DckVc31avm0wqR+GejiG4DXdOT/3eGnA3kb/h6mD7W54UK5VlwK8lWiVZpzrDFtsYyeDPOTnoe+F8w9MRqQ75h7/ROrWmFX5RzlxktyGzJrKcIJa1N63BRlcAyBnG3YdM3uYJzAdtAq5qmiccE0QiwYhUMwsBe0/UZRCIsCaBG7BlJ6gzR8TemufR+umFTqxlLbgUXAtNgA82l+9m8oE6gl/2rXdsrkraLP+Zfhp5KFk9ScnFSz/LFn+FZ3BHAyFdHXhW8wmETKFcM0DNTGyII+lqNunz54qlhNDsZXhaM6DHUg7Z+P65R2ZpjXB6hYmvOUcY7Uq7Cgo0NgosyRKtv5jtsqRnmInT6Abe/W4UcZautQZjieAhI5fYtHBaM3p7+SPAvCIXU3ZBhRIRab6nyW3/vn24l+knG8g0zjrANdJZYpPYybSi3DZIMTTaY7TrVaQwQEAb1lJP6pqDmSstuB7JR+m29WC4tvktKYorNyaWwwEzTnJgVOgiyf/tHz6T9P8v9eRW5pzpe52i7M9hjcl8/sq6JL6jLaU0CbhQDEVjfQqZ59ks8+ydIGqmtyvxgQWaQ2AnIktqma0PGnE8sfGU9Rn8s0oVQFprdroux6ppYOtMKE2sNDcqjMPGjgCSUWt1pCxMPl8NXov+NpVf8ZIxiQGyI3N58OfGu+BFnmPwBbGzT7iBFTgcm+EtCe6ssd/VStualE2opfemKTL/CDI+K/AQaxiZEzw32i3dKzsarJxn9RYB34O/DoP6RMK7kAxo+hWjt14YIgm9kNcf2Kd4/QQH70luCIPxJwHqdoZoWq3M3qeUde/ACGvTT3SAAg0luiyqlg7x5aYJu2LeXIN2wYeLjsu4y51MHS6oMAw+DBAuvy/EUhQ7BuR/g0K9YIIZTpRk5Gid0/G/ozTE/n3ogUlXfqIDr3ko8BxHcnl6ggMevSz7vJ0Po5NmtjG+kfhDCsPruxnWwth2RpS0Z9lVXfFToGFwkPRqBGhYErtBwJ2hdH0zJKjP/W/WkeyZSvgEX05/zxZfGKcJFTYJlwfit3q6BPUbKOe2ut/Mrv6ozT9UyYPqddWUi2Ok2Sfw8HePRBqwjmXaZ2rrUAHMSgKEIHaTdErm9MTOGoiCFG+zflWqIheGgfwtoQiS5bJfrxZfJKW/1QzVaQUjD0QlGtMTKW8iM07rpcQha2LhFH6U+ce8Do5xwECv2Zip4LgDKSUWXH1s83zn5bp35XZtceiFu67tip8Ck9mWalx8Bsl8/TJ0yS9YlJRtr7NPZ09o9OfuVDmc5oQuJ8oX66i/z1bru7eeu3evbcu7lxer64Wi2yzYknurLj1rzUIcE2nvorG5FGMXqxSzv7jTUC0OiyCV4tFtZFMzfgq30tWnyfpfWoLKz2qGrSrm8JQC4dqnFILWEbCjyxriK2+g2YlpfKtw/raV9BZk9FGr6zGyAUkVN+UHL/AME71Z8Cu+QfAb0eiZTaP+3044JmjCQf4vQIf5oFX/m/6a3Jdbn0H4NJ2ZU8DAJQuXVMBf6oQ7ccwzh9h0JnXFdPFbd84PYQTw0kHpae4p9v2mtSGM5HQSkSnPyDWp8s/5HoRwIH+A0+HrB6qqL0Y0G4oMeTzWNxQH/kQfEpZeMt486bk9HggFm/pKTgdojGAV9iRajtG3MzDXi6/e06criBHlWncf+N8WoIciBXT/TOOqXAEW6qewl1VbVA52Iq56vt3g3forpfdAVquMvnPN0ihlYWzPArKxT7rJScBlx8o6lGYpqiIPIJenqtAS7gWSulZ8VG5eU2xUvbIgniwLTjU/qHX6nIWA/vWcmPO+uoD0Yubae453BXm6R2ldQPEoNtLbfx/+Yti8dfsPqMAn+hSnbWuK9E/8RyNBFgD449P3TU6IaucoWWSu3kd4iR/RFT7/OmT7Xqd6TBgAti381kyX15cXzGtXNNHUFHKPfvhlgOnZl+k80ecPGXsJckFIYVLwuwi4e7g9FkAZXdefoU44ePYcwCkQ62MVPNvtCAhR2lbA0Dn+JM0eZSwBqDQGgDg6ue2xpLiXRpvml6lFpWYyjbRar+gbJYu/M1JJiQK1jn9CwTcS/y/KVijskm3i9X66aNnX9x789ZF9tOsnGcc5Ta72j79D5KrP07Sf6ujhLW6F+6o5HVBLPSPsSw+GJiBM8sGkmvNHaJBR3lTqqyBmX2q1Qs82AkVtskPbYEH0qG8DUNTlfOMF8afJimDAFLU6jAtBKq0tRNkFKLI0AiHGgx6BpNPcPQTI2fYBbHSPeNsxqX6/frSHFWR6KP5Ld5lDMF3GPtSjfdAC9lUEgyNQ7qF03q039O4f7SVf8qjq8C9duZRzAbe2/HvZvd3cDxOiPWIMeN0jHNK2nVzD4yVXZ+M6dFRH/V+WI8+N1cfBspxv5bNuhzrHKcH+QzJ1Y+gfrYmXmcti54GwEQ1App9uSZ/zycjBv4HJ7yKH0w2jaCrv0MmCo3R4vQ04TeF5W9Gf0seISN4oJePs315jO010NXrVTLoP+Qft7qX7dmBsaxefRzYa8hkZQ6hjhUaFxCpq9iYRzrsibEsRtIrUBGOPgumcPBeMi0USStMlxhhWGBNSGG4guqdrGkals0NZAgJp2DOC5dImkBKIG7GJ83m9/PZb+xdrn51YkxlirNewfTX8mxymEiuCR7ls3+cPPvDpPxTep0V1ptmCKUlIDJiUHp7ISY6ZPyBuI4sxTEWvJIkmhMVnc32ilcLIuFk4HXBHJUFncxJ+ZCGxXxxpU2EaG6JA3Etivwyv/hVWvxuWVxYZKyubXeLlAiXCeRmcuW1ONfgAfVmEy6rku4f0saiWftwmHl6m179JL/+UZr+S9YAqN1FnrIh4E/lwqwfTa1R6eIS8lS2OpkBL2kFLc4Ei3xNlfENQLXlJ5WKg381GrCgDTfLFldXq/zyqzR/ojZAOS8v/025/POSHT6pGFWFM9mqaLUeNvyA9K0aY/NM5wCofKmA8uDqe+n23TJ9oPqEdtJN6kl74wBXm+ZE1dPybe37GlZxqHpiECaQEjNdRsqn1qxrKpMND4CltrfyLAvmqhRnu87Iql8nNEfGjYvpET4i07Mqp/aQ7ge5WfvxXmF8Fz0QSv+UKnQOx1CRz6LCKQ2A6ntmPmGeJNNq2QmhewJo09yRL2cT8YSno9qOk9pwppQ7Pm73Az60QE4svSmtwArngSnNT87wZUU4nL0vJ9gejHKG8V08hsrFdJvu/646sTfidBfzCEjsnDgdWMV986eshYh7fWKeLij2z3FfokM9U/f9B0P7EniEK773YQlDgVIICOyRwNmrhHMw54KUrcpUG+NUVhIJVYTEQzvLFX2ZXMWCqJo/02m5zLoROqs3CaUIDZnnzbxqzfQgllN0xa6QV99LVz/QRBShwlOZuwhUcMBsTo+EDdtGbi//olz+lRoGapawDphsKOmsnVmohin0VeezGeZIEpcprzsQLkFgN3uoVgHthRyrFeZbZJvm+TOmrGAAW9bAk+yyWEmlzfdnqx+V20VS3EGiIkdZ4h6Q7XDQgwEwgEddjXN/HXTc3QV1aEdXCNQ0/sm9LnapyaNmQ9lc/Vl691+Wd/+EY5YpI45m0FlvQs60b5I1pbAX2QLamAiBeEpAnt62XfmJy+VA84qaYdoVFNM3mywngzO/KNa1LQko1tSnaxx7t0w/ljFP/zB9/j9JZn+q8Rzxl+egVQkpYTG8lEQXwLBdF+mqLJaUOcqDlOQf5vmX1lCkxK31Ir6yTh8qIopyw+Qummuq4fqlgBUIMkkstDOp6o55Q3D7q7WQGMTX+Mp1cqtH7V9Ycu1yeP1UAfmQK3qvAfihbwnn3UPVUSXGidOVdqO/ULEFMW2cjnHG0+7R+PfoOD7jUjy3FSeMkMSYcXqE5IisyvYDKeNfn4p06Ne8w/lI347WhyN5dnRrAKZZxHfxzNeopV1ZPWXRRYogvg+b7xpXvUx2uYc0APwttKNtP+9yRlJHEY3we6FZ/uVpvdlaj6codNyX8xSJgfbs5RIzJP2tvmL9Y7tio1rVoIXmHFo4MfmUtJOfyGSKoINx0MkNdjt76Vt6+6wH3n0VrQIjp2byND21NUcFSfrjv6ZJGA646r71GJjQWLl6tLuDibwzOnCZgW2ZlquedVgsP9su2AWIflnizprWOShC9bBeczZoJLCBT775Z+vnv19mf8Z874JznxTUKzbcsqs8KMTrihqRwrShGUx5hJY4H8UI8vRgMabpaZGrdqtR7za39WqzZRiE5gTKqxmAQzi8CoosWf4yufh4W/wTgl1YSEJ9uQgZHK7a9gB4CRJ1UF2popI0f6yI8MvVP9pe/6TIfpXmtwitreGkXfApD/ygFbQKgjUPS93n7KmKQ9jmZ0sbALfTlNNMLJpS8j+RdJbPKBMO3tKcnAWNqTxbUkopS3WZm7N4Vjy7UhOC8r388+Lyz8s14zxkbxkHAEkcrPqYpgj24JiVxuTMCpqRNASsBNQAK99N1swCfWBoXoFkl1UK1S+nlvEqcnIoaeqFFZfVBFjZtDFVDRNrj5gruOhMHdUKUXFVxP7QujuTFvC39bHy1wTzzfHCC4lA1IWELE+8cnnLIa8evwkP7Kun5IcrpKm7jYuTgOm5b8wbrnFH20NVb2XViyCuh7ZLGmqc9cFbz25px7qzSjJm/jpoO/b8chocp3h7Ck7M1A2JIZ6uynq0ndpbGds+GeXQlTsdElsapxscRutzjNmoM31ULbtcogN75oD673csYCAd9/rE8zWDuJCov6IDjPp+1UAd9Mwgm8kZrll876pouYqIxJVsQmCCMKs4BD2CEy9ZHMxMGA99FPOBqHiXmIhQzmfRQMMoAdtoZhewUkxGMChKZ6xnCSHqKogI2WiSFZ+WK0Y0Ct5ON++RsIjLJIOt8E58FXVJJymWlJz2WjxP/urB+i8ZT1hvnjPJXJP+wVSgR7SmGRvEkBpq8BZBdpUWt8rsSbm9lc6eZsXrCUcTFG8lbBK/fout4jmFIJ1/ka6/V84+S8p3svx+tn07mX+dFW9lrHzYvJ7OHiXr20yRf/Lk3TK7K90JkKUSrqA2yrL6rgfpyeUaWcKe69sOo4aEz9G+/IDVTkxfXeBBda2g+Gg6FlAF9OXsV2Xy9+v19mp9P8dj+XVS3i62VwUTwLLnWXk7zZ6VBacp43NynyXbyzR/nrHLfgbkQscnJ5dbTk7Y3Enyp0nxWpI9Lou7+exJXtwts2dJeZfpP3nyBucop8ndYvMwyTnE96pY/eNy/bMk/VsaEdLF3Of1TrVDFQCoGnhKaHrRlbZqYt12gdIM+2zzxYOCcwCkJ2gUiiqnqhH1Wa0WLgX+VmLWvijuJYVWLWsoQINIYky9QpbwWSlR0FK9r9poRNYylm5ZQu3FTLFXlZN63Qv4Wa/j3hJTqGKcOH2o+jFtnO7yGf/lCu9bXDjOp8v57BDKdnpJdu3qQg7VsPGrN4V48q+5+9b587vWW4unCIxxuuV1sP4xO0+7RX2/+F3cFwA51KL26qC6SlV9/65x/BpRheN9dEqBOG1Vc+sKXH8O+ahBNIT0ksGxachPbu4IwnRThkRM5/BNYcaax+lvSp8XINdL3Esfk0MF8DQKBD90E+Q64YiegSpwnkIVGMZUAfgiEm5Y5QX70E1QIpzKKR54EQPxZ+GSMiwiF5p6TBWyK66qgiuiIsIycK1zFCgPtAcIorgTloHK/xAoexarMJnDQ9oEixlxFTHYl9niE8lRxCUZwJTyCSqSAldmE3EI1IYg7/mTH2+fvJcmH6qnXjOM1EFNB/JyNk9mxTxjHj9H+y6yxWaRvZbPrubZa1n+bFa8Nssf5QnB/UOC+3z+kGZANv+S6eM5v17le+ns85Kp5MmXBP3b/GG5fj2dP9kSzs4epes3ivzRk+39n/+QNgwW4hApZXrKmTKleSm/ewm3C71BSEOg+1VF7JEtcpkrZbEvQynP3//Rm//eP/69xSK/TrcXm+J5ntxK06tZeoc5UWl6t8ieZaRZgJvcXqePUpoECb34F9v0WVleZMkzZkZtWPO9uZMmjwuOS8u/LpLXk/JxCjx5vCluF8ljchlgYWLVJrtgXhnnMizv/MNq/tFyK5cqfFfVMO8qobjdPOmNSk4RKwraj2z2Ayp7u2oDJy0RZhvZMvnKq5t505hYjZWBelJnvg1oUGOQpbhfVY0sFZ4vMkCUwnxvrkoJyYdQKYY+GA6SjipC7sdfzuJ4+m8Lpdx+7OW0J7n5KNGheE9R/ijJL4jou2rXC3LfmJhObZ3i65hI+CMnAfe18Ly+Qke/BeRqh7lU8bXMKUqYVYGVPekWt2IPbf0EJiTi+dPdlmKM2ZM+of13is6uCc6TI6dcJ+g5zr5bLuP4njtF89P947IG+Yz7pK8+95rWqDMRVato/JG769PbZ9/L34FdP8f139OaENKsEqesMRhR5qCsIf8LTqzlq4B27wE3VHePCD2HeEurMFVkHvC4ChaPbUptC0P/KOMAREKE9U5j8y/Ub0dPKls6AhRHMHMmgGT0K1tkZTv12/cISMYkDoJ5LjsXtgC1WL2XbX/MJjDoo5aEgnqToKYA/5GiDmBmlWhb/rK8e/fv/4//u//N9dXlBT3N6ZIAlBBzzuaVCf3N11mxmOWbPL1kQbP2ndeUa7aiIaojcMcQnV6lsQgtIJ5pXTLwlO1kNGKgySGMG0gKc1GQtlGarUtZPUo6u7ycbdfXrFdlTjlW03V+H2dFO/xITfcbHzy0ryrT8kI6IG3fDMkqsWdMwCU4ozjdZlM/O6bdDd28zCPuxVl/87/9X/1H/+v/5X86L+i/z9lstSyXOZ3sxZygP8kYP2F7pTk79+tHioCZkJ2tP5njT5ltaX9dmw8JkuGKb82TFC899WVepJvNhhpyZfVknWznRfJ8m8yv0+dpubyFGMoB32lMiWL5UlVA3oA1YJW+DwFRJPT9Jzm63clnlBTPbA36MZW8OgeAJiK1zp0BlWxVnQRAg1VNSmYlse2sThL7wBobSLSwHiyqmP495KwCo0CoFgcUm3spy76xWgMmXMYMbuLautzDLeCLeozfA3H6RcmXnHG5oY9/XKWuX8fxJ+a23tUq8IjSH1sQ8mNIhN5Idu3qQhoEEx4av3qj+OM+75L6b5n3/ce/a13MUyDT9R+Uoh8j/bjoitMGePG3UYt66qy/vQ/Qk3edRgAOvFr1ePfyo+pOqbyRuDarKOv0JLr0OOlYvmdkNaSCO8/vL0BcrxrflNxeZb5dQHddXOvidK8tkHhx9+YCdA5dPnsJnWGXcEDQuBYDRENgZ9aqSYTawCM5xFL08hOGWfxEhsIm2cV/1gDw/vX580CMUJG+Qitt3qK5FnVsBJShgTxbLNQkUEcts8aJsujbZYaO5ouLnHAfekI5oS8/LdhfX1JWCvkV/YProklJU6JsRGkVJ/Hl+u4PX8vT1y7T9JamozAphe1Bs+dFsSyzFcuFddKTtqERK5+oQxCvRoXsJYaEFYy8tWNny2qAAQj52gWJiFLzQ6AVPmhsBJTPU+1TI6De0rKRiSjWVyx7aucqPemaijeJ2bFI0pr/uEm7Ja3n5Xa9TFfMA2NAZaFOdvYDZZ4Mk/KZ+iLrdTG5i+LhziU6/MMvNH7hgC01ojQWY55UKwvvyUvzgiOcc879JWup45zVAKNG3Uln1xTLdrVChnf+Ux/EmdLQknFkmc9JUXmohFprkG+3s4QYXUWleUNp+b1k+2WZfkW9YZ8hKI1HxUnmAbA5/1KZOqhQ3uIJaap6rAsRqnZYQotFjRgHuzqymUCEBo/hCrvKrp7rD6CGUuPV8N+yT8zv9880PwTvncJkmqgGViwupEkEfRrY53s40V0TFela8WLkTlTv24YW14tQWYaN6Hq/i6vy8AZAb8mMtoG8vzPmqVFR3uSMCRx7xa3YJh9Z02x3jrmgq9sBGnn7LyJoyo0yOsmmzp3sUUAoLwybJLGjZ8x+EofR8o25eblUv2HDcnsrUcznFP9M4hPp1vVAFxLzHExP8JL3bbj58ehTxXMCB8eM63+cjuv6ST6crIl8FfryO64Z0sHhFe19/02uK4XiG3WJclkIRITFy0KBHKGNZYJJ1KN3SHGv3NwVXHEZiIp9iZBAMJ4EgwR5ZAmfGIxIjSTLQ20XSIvgCbkVMxGv0fV6DVx98z7Tgj7WNds4fmAT98VUPbWVckhAEIs+VxASEIo9GPOvtzwUDxFalk8UqpVPmJ+RJM9FyT4wXPTq0t+vfiMyBJG2ilvZlohqKUMs+CNXHcBaf8wlGYSLa5ClAzjKopObNgDhLiQGVOOFVFqu3zaISDUaADYrCuxJFrgh9jjt5qQR7p75/TF+nI44mA1VXjWe8KbMsgsrfJREmyzNWAo8ozDopKc7npYaOwBRZvIYHkrXOgmXLXx00b4y2yxbYyzs88OlwtJiD3XMC4NYGxoA8i0zdRTiM6Sg8hJCmf+dFv1u36FMESBIqeGFcvMuzuNwXyP9nppzHCcg9lZj8iualDQsaA9sGdHRGoD7ZfYJKxbUIFF/oWqo+FnhwVuNOxW9FiiTmW7vlbQb0UKVWZ+GTwoVINJ/mMg3Upt2zVc6JKH8mRo5zrf2YMfpEaA9A9i4cpOSsFd9bV5Db4MheJOap/g9EKcrxMl8TultDXIjT3QUPQRwLj7IDHGI6r95Q+N4x15H/n4dK26Ebveeb9aBIZL4t8zT9QthiOJFwyl0qUST2xN8X6ykzqvnOUpwTKPGd9wRu7U5WIi9wvG3zxjbdmE4zz6KrrQ2bfe5j88IFuj+N0kWSJPwugIHINO0HSAeBbtVoJxX4VGZrzLP5gFK7bi6Ecq9VxVye+vDRHHHqVRp0iu4V8sucKdfbQHBTtNFhDZyGXGJQiZjoTtxkHWXEjmJiWI1eu7pepUjyOKRV5YmacDA7qJXTKWbQjbr97VnupPVgQytci2g1mc6/yydfey8nVDSmX0h8YRlCGDOiUI4QlGCyG3B1pT05Fo87hGcCHS5GFdLDJFh6ihD6jqO20UMhp3gEB+isuagOw58CUXNKrqpDc6jtEGohhIImqW+Ycvm6JKPoseXJNlQqXqQ4SivARxmQOksBBI0z5gUhYHyrl3yHLbjSXOhnKjRHqshGhugRFXIVeHzSRgNUH7w6Fr+8D+cIZaqYrpoLVSqQE6xyqsaQxBLsdHQAyykChxBUA4lwzpyNSMTNoRSa4MCWb2Tbt9jo08KBwK1VyqZNFxIqzrwB73qA+VY0P5kTAOWdlmdF3eEcXPbYCx0yZQyUkfjV2YLeX5JTvPqAJrZr54O84BK/NwXRXQTbE9U8yVU6USLTiH3Mgo+6SZOYX4yLdr599zvp/Fr8xgZAehrrY64Ru3CkB0rOb0nIKbapWEqra3dGQvwdNugHZ2lPDtue8XpFnLvY+hj6M2NgQ2Fplkd7EHPkI57lI/rHZmkc1/5xua00nE7vpUVHjHBDdlTKoHAEl4iDpukeZO896nLpwvpEvbUjWleCvb2SJnAIS79llaBcwwPwBHCGL9KT9DEMXus6GHXD9rRem1wLAVfoYIDspCckIevicIaxT52KV6bfcpC2LL8viIiAiFCKGULwbpOsYLToO6qbz5/QixHEKXVlh5XE1FKDLvBE4rRgcoaAE0LgVDtADIJIq++l6+MuSlFIFjLV9SX5J8R9qXbN2FvMgkcNUWHflmFn8CFbnk8SwkLz+k2li0EhUSvhJyI0d16o4nw1c7h+FjNGfGeWuVWAsw6RZ6CEPYpRCYCJNf6lTVBCJMRK0tF5Jfv7rzjYsrWmWf9rPU8hKlKqz5R2FS24FUpSoxZO9xx0XNNj2EGvxlMnk3Ukdn4QT30GC1U4myBVBl851YB8ZjcIi8pi947QxIEhsixRiP+FISCIISnpx8nQoWHifZJUGQUug25bN5FJ7b8Byh5VjE1Qwt6toLNLgoGKEQw384+LljMrU1FWXCg2TvwVkuVKibVLQ0d7UfF/Xmy/LTMYfsBWVKMleMaeaDtgeZcokAZ2Swn2R/cmLZUtxJlWriGevrb5wPUBKpXvRfm915D8F7kEeB0PtMxB8Ths8hDA0iTwY1RXOoB12kaqtQP4SB8syheRbB7r1ruyC2mij0T4M4/cKh+9R4YYLKe4/ocWhw9v7xBv0MSx/GJtY3TLhlIy2OHaLTDHfLYkM41/FzyTZOIGbvP6edK11nsM06H3rru7nCI67BnBnU9McZjLK8j6cUDMCC2IRjmxfRNKR/UePEO+TZKvDl3jVcAlxukk2j9HejMcWkHMgM9aNZKV5y8Q9h/ugmXKnz1fxL9EFARUSl4c5uqflLQ1Fdsby2LutRbS3+tMKESPh2ntmTWoybOY1LXb8Z0I3vXkVUuPlvPP4K/x1sSSOCnuJ7XIWB+8jVsgELSwWJQZerSIyMFhk0QKRyRCy4L7G4zOYCYPerjhZtboWXCskP4bq2zVdhnjAyutFBMsIgh0iUuztMe/VbxiSA3kHQtxxm7jj047oA6w7wh6xS1y0YVNZncaee4gYhzj1Golqa05TSlobQHXCavVc6v/aaec646CxkVd4NIjP575UEs8qrisQ+m+1MTVJkYolBxKlJnnQoHDIiEw5o13YyG5fU7M44CkC7UK5HC1mqgmVIBVJHA57IJRVoTYBpLO7FTi0X6QyqVaxNknS5UA6E2V00FcPjrXgbszenifochZ/HAWZh0nexF2oWPQI4ggRv6BxNCOiRcHI/HMR/RtpV10/xb4k58HNHWnen3E6UcS94qvWPZBLrIGEv2nAMQcHcJfBQR7uBKKY/Xlb3LmjnV02ibErYjBWAcWvlBkW6iV7yAcdsrTg8SnJBR+apr9UBfQmxeTzqal3akUgNyj+TWIdu7NqBD0QbcdIm05Q0/n1eTUEGHBe5yHDmuAORN5NBCq3sOdsz3pCwkqvoj96Aem10ZVmtqYZDWACAaGIGOhcbizruEF4qCMQvPBLK4DA7E5dwUDKX5Ez1a5CSwluAyqYQJG7b6tmAJAUfrMowwL8urJFmwkpdpGNpXkfbD6oNi84F6mLWPO9Rs2qNOaE6ZyrJ5UrzhkokE4WsRpb3f7IRdf9PxtnOlK3VRifnuvALVO0vsqEEAiyCZ3oLa1asg3bwlk2QH5vPBk6xL5l/KIqMVXC0I+PuQghQ0PNPU0EVol1OTrJ5JBZBjVHfP789rILYfIOmRW2PFuUFEFx9roHCEgIaLNgr/cZ2NzchKuvzNLx4Tm7pA6aFXUsUBst42VADYOavAWT51z9rCNvevcAyvSujDA3SUohlnJITaStOu5L+mAzGCwKQkNmCl8Jn+v9mWa01UYlkIqsB4zhqAB0zWogZpipbmp3mAzliTdNegVcnJZczmYsRJI0/sSlRoWQvnCTyGkfW7mb6yX/YJJi42D436Q/NA7SHppJEt80BVuvmX/aWMaHMZJn7rr/gNFqePMyz0fAfyod8sd6CPwFfI3d/xwKXebzDM9Q85qmdWHJ7we8gdTHR+qbucB2mjjN5fMXQI8JY+AR7xeNHJHh063qh0Ao4Begn0XD18ulhDnLuYBqFWtDxWIcZ84vQAnyHwkM4G9yrZkK9vxPAKvYYU6Bg0fUuw7knAM4Yx9YsKUoN/g0P84LrEEKWn0bapDngO+sWS4vQeXv1q7yF6cdlu3pA935TyQ/q8OL/8VkryyvCdNr2u0XxaSKdXlHXey3ZdPNq2LVVAQ/QjiCJnAiWoZjYnh2fCIy7CZbJ4/5IloN5I1rGcpiuLGhXIMSygFoJw2BPyo236K/bWzLTvJOGbgrQ81aGypJm1TRzmTOzdJhL7Nhh/qcezqVQp6KVVxXP+gCFGJFyweHIOejbenmG5fgNgBgpb/KuskDDNLWA1TlW24e64WP7u8Swp18TNGWEo/S27jU8JVTlmmeHBbYdsEAudd2bXFPpUdNzwifGpVfEqEfvEc8RfFUZe1YfdrNSkDuLc27LLCoeaQk3Ik1mezRf8m89ns9k8vZXniyXjAMzuX6/ZpFXIxerN1eoNVobYJCKeaT1UQvgUNxS2/YLIU3lrJo9argh1eVY9aCioVpoelTbaG0q+MY8JXWcegyyeuvxuycZzG77D+K1KTXRDQCPh6XB3iD8e7boTyV2ua3K0Dr8VhOdwtL0aBr3lueeQMyjiyIyO3v1KBrSQiPEA0gk3NHfwQM0qCae31wfkuuKx+gOIdODQQorauzu8uJUWp3cYJ6W6PQ3OblCfSFoooAimZOirmGR5i9gfR/sweikADunTxdec2sjn0wkDqyn+CcjfZGJCnRm0ZQJtMO34sjYWQz0KgX8rUfUQsIbntEtRDjWHoKe66u+s4qNwGVARv0WGVeRnuUCI2Yh+GPXyfl+CIGB06ms6OEwUpimCZsI0s6vhRO8oUJs/wo4rIiY3K/KvSW/ZoBMU9t1X/AaPDTu4EKvl5fuz+298/t/97XWxKGfbxfy1fPE855yp9b1NeXHrp5/N5owY0AoQsfXymsqSTsK0MHVJcVV5zKfkQr7fZYiSfinidFpnoACwohOCz+omYUQYzKUYsOLAR4VsgaGz1N2F2bMjRDx3WKQiVRrw8QeX67R+95K1UnZS71UK+ruNyjJ8+qq5GPeojXEulguMrnGVCijBGxjgPrCSNbCK0NxKTF35wbDE2i4xdSL3mAmB1KLyCmP2hQpkzT51ukyucXXBZc4igM3Xq8eff3m1YbvPWbl6zvEO62L9/Mlq/eiKxmGRrBgN2rI9PxUx/yzjcDct70UxYn3mhHnEb/XXppDJZIYH+HnV1CaL9bOvrVarRWIOYXCJYSLaBlYltSABvTR8YG0GjIUtTVw1aqWwyTL1q6pUpV/Gj0PedXv1P+ht1qwaFW/vRw9ZeFPeri+vE/XTYZ/jPfQHc460QsnzX91y6UAGf78O0Sa42olinlPimRi/R2zw0tE+Chx6uB8CivnE6UN4jOH6m1ZvXdXZBmbzqZHVeaj6/h0ec9K7lamxuyvO3EE9tcfbhyjUZj31eUy9cR7HU/bxxdZxbxwhznmOcD6CZ5/uU2Ejmkxh4f6BydDVRXjBBg4p9gp+fg94PaCAQxnr1UMoxQwKYPSTEuQoGLNawSwdFsyaFoq/LfjhCWSl1RDQn/5ZhykPMz/uV00KdZlqTMB2zedxqyEBtQqItDixl0YA281/vkw//+wv7jxLFsXs6Ty5lc8ZK7ibXF+U89s/f//1hLOfJAFRMLfLLOAGZwdwd6t2n3FGMDQARegUOw67TM+zaI+k8CTMSWo5MbbSO4w6x6LE+uGEz6BhSExkFvD7dZbGNSePaOtHPisSFatwVJiNi2cVCldN1Mhugp1FBKtoqqaoeKlVAZSqQQhfZp/9m7/7/K9/s8nW6+ecSkCIOFttn5ebfPXVY7VWCc2zdLNdae0yR4at7iXpVxaTqxZTzyp1SYKp+FINVLURNEI144YoK14bslIRy5S6Kus33jgAUCtCmVRhWqGkgXm7QPa60rtPwcJVZwbAb2NiyAnu1SGPQHXQ5fjw7F7jgrr4Z4Ecqv9ZhA4x6XXLEPLLDH+pvNpw1ICLg8ID+fbiCIxUU/2HVinAgdxQOq3DQDiS6GmvH8WnT0RTvT4Mh/XooNdoo91fT8zdcdnT7twhilXvFfcHOI5r3KtPi4Pjdzl7/7ojkzvVBTH3s/k/ZtpOD9k45FUMwRy3CL/x6H0D3XJpSxp+rmQ9MIybaJFP4Dnkh1PsGrZ4IOfAEh/UeYD9EDjq+2+hWOymW3WpGvOf+Ii9UIDr2TIVQKWcKLLmJFTh2Bxp6wG1CMpmTVAK4BJmVS0HhUokN7c07yJ5Kl5gaIIQcOb9X2s5Jq0CAisFXCX78KSrtzbXS+D59g5ztTmNiqyifJYsV3n+rs4LKziDSYs/1ZywaUWlzb1m331j7zepnM6+lNI+AhDyZIbU14cndDcgHyT8Mo9Zw8aeleNequ81Yt+npBunwC4kmuhan6CeeIM6jmirq+rFj+0CJ0KoEa28dg9K7fr+m3DI4cEuQLVG9aeVtKDwt6i3ElTnw0b6qIyMY4Az5/W+HmznilqYKTn7XI+2w08N3306PTXKJJp3OZcXoZyo4KLhQUXZbLbPruc0F8tbm+R5vp1Td27nd65XV9oAlk76YsFSAE0BKrb5/NEqu689f7RSXDpYxG/KmGSNVWhtAAtZCmYUaUSLxSeqDTauxaPGPdRMVS0VB+onCOJkNzUnVC3166wmgTUFjfXIzT2m9SS7y5RTC1iDD6de098qE96T48qMv5GGflMCz6rU7Zm0l4wDAw4J5+OQcYldqhH8lvSYdk868nBQO5AMzS8AoWtaoGokuuXSgYzY1WB1yEPMc0o8E+MfIudUXI9ANm+KTxzLTeG7t06OMBmkbX9nqcgq6iH/+BugMaOnW40qHrU61j82vQbVZK8+93kAz0/9Whqrg5D3CT9P/o2q5C9lFPVEeHTVW4/nsecVlz0euLkCt3iwLlQX4zGQfg+AEwbxdTEEhUnEPczVUZdoFTaRIyrYaE6FbRRPJz0RlFoIiqKYa0EQRXipvlZQlZFk64RdHS3mZFNFhXHGIp09TGdPtO0iUZqmcidrNnXfXm+KZ+V8w7SgTV4UMx1EYDLkNBNuRnRc6HpFYAF0hQxZoShO6nsmCWMmuCP73RzQBMXZnm5QGMjJSIZEkwpwl6iJEj2BPcCnQprGq5+H0/bn1TpUTqofXR0j4VYJJxWYxOkdUZxSn7p8riKHgXhQtlYGekxzdv2hxZcl81xBQE4dyvOc5iTXpuAYiO16u6WNQH0g5l9v7q2L1xXNw0mNT7iJM9WYKqM/bsz8UQUCTtAPJ6VMCzRQ+8AIsFTUppE0q2qcQ/lOsPR4h+CYhj75JusmI58H0WwTK0+E+3m4H8IlGB8Sh1AfiYssTOY6XSgcplwT0aaweoWDB0IFbqVfAudMKmqveIOocYZM5bfWDY0z3Na6degV2mHc+9srLaSATaLmE8NG0mGW2AjOTWQNtauOkxX80fZr1Mp3zsGfYAaqg4QGDv1UB/q/n0kTukdijYw53rvvgHHrvG+g7a6a1RSJk0qw4/9awoGf5+JzoNgG+pAOR5Y45dNwf9yjEKcbOnQeuphVxSbcqWsAfcPZ3ObZYIJkVuG+iS8XHyVzTk5lq37FTHYRZhE2sYcPl9RUOKVMecD6Xzmj9ZlhA1SARcOgYA1AskwStmAHoDWeYDJZKN+8lm6Wa4VlBHFFkT2fJUu297QokL1fFmpVcL6vmhaEZYgg1GMvBesZkrzwPbWU2+tqkifV/G79N2rnmNmoQMLuShhKT596hS3kanVWg3+cbc4yxPrWhVhOZ9Sixo9za80aeb0P+zDdP36X6bFWMW2cjgS17VUBy4XAoWjxg87fDDWDSmz9aAR62CnhYwU8a3hH/5TgLILtGxoyyu7nM8p9BpCpO9fr65WdAq3jwLTpP6hZuXiQJo+0eqFkW1AtK1GdpEQ396zJeG11gG5+hKspgIo21Y3znq32gmkVAbNoudJOBYcMM40sEtwlXbOHlATbevFtqlxdZ9q9g71r+eTig/v+D3mreHGEu5S1S4Kjy3uvh97PU97tEbO+HtAhnWOyTnpInw5iAxBTWelUuW5yy/AG5d6H6L3tfOJYqLdPOihwqA/36vJyIUTlewZLI26xmR6BxOVLbvCwYw5Jb1HFbPemT6ENzKkw3vfvCsf1UL+YvAdCRjBJ7xB7s7StDFwtEfCb4PAUywrAAxL7+B/A6qVCxa4zmnZebhMddRahB9UPkPlDricm6vkK7RweOGNtbahThzECesmaJLrytYuiShq43QEo2KEz3yc/OAEYCtbU/W+/iARLeiJ2IrhhZo8OlGV+Nr20zNJQI4H+VzHRLkBEXURYcOdFp5hO6y5nz/L5VZFsOPWJGExbf3JmMJu5FJwvtskzojzuRGW8Mm3Wh2uouynpmlZA6d68TDkpWF3Ilratv4pJjXTY5475YXT92F1VjuHvNDLT+ekeOIdEvwZToZJR1ZcuiSsQJPljF62CmHpsHkV1o2bQ/CvKRZlcckw0T4rUOQwsnRHxz/iUSQT+GRvFUks2m9e3qzeA0H6kmjBIoKQieLjY1DRuTOBnYErDA3CjNmmqj1DkE4X7OjeAlH5+eRKaPaotQl2BVlVV1dtz+KkWse7RJcA3eLn4b1iJb9D+WnTXA11IjXvmzxcm6Mx6f3vYvUweHtPFXwzh9RASbU/HGeI37RyAmEt/e8X5jmkY82in45ZuPEusjVc/0w5DYG+buEY522e3zYfoKYY6jiO7e6RT1Mp3Ffv9Gam/o42AcdI5dPWMcQbTndbwFD57dUacqz3FUYO6RRlTJEbow8mO/x11itUNpgN8GjiHPnTKwnq4e+pMxfhAHQ61MZ5NGKfHzepi+ldAoY31QhAsMc87ZwSAYEuTfxQDeQCkmJsvF4+YVpEp9IKWiEhRlcEJm8o7RFlJ/pRcumZXq9VmvZpdcDgrU322tj6AaH7BLu4WXxHCKZbiWAAaAIviMt+8zhzuopyl+bMiWYgxu7yzdpNxiXm62bBzkNYM0Dyov+lEYJSOKVuZ7+rVSlZAqnuNY33/ssayamiFN+mj2xfuZMzpR0q86kAQqslb+9i6evEditgET7vK+5g18yuaqiB3bqgd0MQ+7CkoDJk5UoBYbbFzBSx79yh8ZVimKHZUBOGANUHHh4zyD9PlY6L8TK0/QvB0u35ebK9pPRbJPGNWWMF+oFdMNrvOn65nj5mKpvrMWRE0ZDlJgKqSP7BQ/nVam2KONFVaaiwnUqMID2CqqaDGpRTjQQpFqkvbcn2v3OiYYeFLX+FWOCBrPKp7iY1d7gYldynPad+7bxvHQOFpV6zVuDD/pQ46ttif4d0e6XzoW66lTPtxyEsRXteuMF9fWRM4RMyqpPu2NxbqioPmDD7sKtGBxL6N0zHieE2IMQ9IR+U7bumQVg1ZEbcGvO+h5e1x6TGDSZrEBPvTLV0aBO52v3vlqbL9BdjArR/Ej562Hdvjyq4hruZ9459Duo5rA9XO3GN1HBLd5eeyTpHo5pzCoavVoRDX4VCq2EuHuj3QhsQ364FDbf9W4Z/fta0KUxWixTqVZxykKQ6kbAaFMpzO5usrBpNi9X9LKORSly2BlcJrdaQqYCL+2qyFwExudb5q6o568LO1nfRlfaoaVSDwon2QLvKrT69+8+nz9PV0yRgCYV6ebTgKbPXs8eXlXCcwwR5m8OWTP7onECeVpawU3V1uSHiu37aOZeiKVD0ag1OVCvgHJWLRLbkH8QnIxzCJlQiMdgkLVvVotjvcky1hzqcF3PFppyj5mBn8g6QGaoOhHiIAJF5+1A3E80RCEIaNCKvnebZQv3yx8k7/LF3SOHx49ex6mz1Nnq+3i/XmimXl2+vvXW2YWsYBc+rCp9dfDVQxopKw9lelbFVIn9rSSnnq2hea9K50sgQ4dlFLNBLgRqkFzEoEjY+BxCV1916O2kCTBg3AmR5gegTrQOW0U2w6k743zqbXy6cY2Mvwxs14JaDjAa+0HfCLB+xRJHynvOb44x4txdLPARCRE/aQDGbEuHuRNNg50HuB7EPaZLAZaYeNKBK3yeK0aTZ468qa5FzjF5TZ+y5wfcKM+UAIm17arv5dPQdNijM6nu/lE0wOfRsxj2466IwhIR2P83RJhiAuOjgkcBvCPwAe9c30Wj3Cquv/EeTjszqlE7M6hw5T3em90d3e/VifkPbC8oID6DI0kcICGVUJgSxYtjkQevnYk4XI1v2v8FsBkCZp0OXpHImHAPNIv+tjOGietCCaYlFsrtYKv1KWa3KEE3M1RKTAjD4Opnmoo9caDMXT8s3/xy9/87dfPP4v3v+ju8v75YxzhBdMAmccYA4rosDtc+IvyVUzg0sbttSOElMDciPhihlATyHar+B8BALs35HWLPZ9uogg0dC7Pf1dyCBfV8zvIDVNiM1pcKjQmnpUGM6rkdV4qIyuClhBt8JsBcMTrwYipPVz/Sk2tcQoGygYMUBIiNdwkOaFicxidzrzeTfxXaPSLNI5zUYKcjtbLtfJ9WePV/fXTx+ls036nFGArHj+jMf5s2z2mo0RbQjwWTNOPbMZQVQYhKoBapw5W5rWIxUJ5jLcFFCgLzWgqKqV1KD+QUb1LmcPytnTjHUIGr+CTpzMaGk8/RLpGPbou2WIMPxOjbIeoq7gTsvdDQoJsj0dQ/bw6mQf8CaP3v8dNjVgmpeCr1u/jzJwGodaXvUZGPLc+t3sd84UW1oyDn903zZ+dzpyY80PlzBK0ZHV0MRIDyh9w2/5tl98R24/WhN6qCZN6u6T+1UV6rCrdRJwi7haBDzKdrRE69roHHgauEaZ2GtugHA6uGvEsDrTubYxD+LZVanNrvPsDj2CsMPpzIDxEhwSdrohscODDqezHVL4FfxED4Si8YLToxWbhTGBN7GPek+tn70CEgJZSrMpLDpUd2ndbDAWRFdQwJegS7GRJAhJTQLW8LKnj7Z0Z1efFfv/KOqfzfLNWqEVAf2GRb5qOTAtaPX1iqOentzdvnMrudwWbPiSp7Oc/t3Liw0/2Bb1E4iFsF8AD8NMQcS6pjyZXgZVU8Sv+pPMXXKXMiR3TkXQ+wGBIwXKXrTpwMAt6E/CgTGTIDcG7tACccjeEbimO9yAEieqUnbQJIqYujftXCyrFh7KLhCYmoBVZlarlKh77okDynm5IVynGKlbzPihTmnNCWuAtyVRvNqTK4qYQH9zi5XkW60VoYoxP00jTrCSFtQZi+6J+FVFNSFNQJHRprC4Hyx0oE1gbQaeSFqAz7NqNWk1OHlibptQRWDKW3Lg5ngDmecCny6kxSE8hgSqxulzaf6KzwvzwPTi0xfm1XWYB/DugW4bQVdRjawBqNs9+0t0P4b1242auvcV16UOrbcRG2OqsGYA/OPaZ6H/I2Y7lHat8M34HghO7vpMNASS4/QfUnUi3P02obT7+R06ztPl4qKn+LNL2wOxvpluL0IPZgd0I/4/sK/oUB06+Huqm/d/W7dl7x4jHac4wOJnhTUhP9QYhUMKvpRHlMMbxtISIRxFSQRGzG7fMsXCgGIisIVATM+BA4TEaFcWWoGmrld18+tTN7DFRgEUU7Q1twMAfbfa2ifhnFeCufwyX7xWLvLitub96w8pBduLzss7BTuDKjaz1gJvGGlk3MCRAB7FMLoMKm24QkYbaYcPCpme38aS9RLBpSxL7CjPknINg55dniNZDXXlZ7mGSwmR4f1BlZ2t3Qdxuso40xruMuIC6GEFkkN3Eg3kxNxtkpfqh2qGKkxWbkqaidd5vibipi1YFlo7Dny5mF/cenhx/Sxbv0mtWCQMETHf/3GWXSfrH8n8/CtMtpEliWW5CrJVH2nFWlGyOj1N2Y2KrzZNgnpYSfXZlJKmVsymHeuJqa82BY6xLzVg65qnbKHK1fqoTNRDffkYXfMcAPKQUBHXiEd+OpfwG3okl8lkQWkvzMl0hyAOvG+rX4QHxmoAp1cMqgb/nK52KLlJv5uH6Nmr/HRg43ekKTeU2nRuB2A2ZUHY0OQARjvU0317XPyw0+CYFG5u168Rz1cnAYf6FCTyAqSzTaza3AKKEqOZ5JvoEaR9/BvCDn8Yl3w4v0GKERf30oDPX0u9Q5n0cn45gS1Lu0oGhJAIOF1IyHqVuDEPnL8y7ilH4i2TqQhb3w3r6qf71NsMslNwrfpV24AMwiSP5c0HTJCAguUBIEDu6guNWCmn8z/npm4LdvaxlQBFPmcmtXiAlGcz+wOXQYBtuXyyWjzf+AuQKRwS+nWWPWPStt6LKFfZUqtsQLu5XH2z9af4b4/ZO1LxrRV3onCveMAuEkI6RqhwamCD796HmDik91I5guPL8JCS3ZZZuWMipz60Xm0qIOFxVc6BslKjSQXQ/3afgcAwjYoU2/5bHbIqodae5vUQWqSLLefAsY0UdqXzPF9kdP+ztKRgl6jljCpGNvNyVFVfW20vNGOMS5O+FMurllh91YM9FWwtpYlk1CtMoCVJgpSqrlNZ21Q1s6phqkcMbVGBAdJ8YGECp9FBJI6j1yDCFOJRznXmoIQa4eY+v0HRBxmFr8MVpwPw9ISzvSHmp6s3vaReWhNOd8LNc8DNPf5rgSaXxW4NQEfzTnurg2EAdWDwCrN7L8YUXfSzra44GWfpKS0zcHZmG9Vx8+1c65GWXLAgtO+DoXu1hbZLFcj3J06wa9CicZ7juX21T6VmluyKY8CwgOCJijCS2JpD2cvG/RlYBZxBewNGX2KwFyHSqo9uDHacJl2Ox/E5lGoI3/v+u1oNQbwPkhNzB6+6zBQq0cXOpQ4ID6G486CBg/knaX6RlB+ATUCk3lOiKusytXqmWTrs1i9iZlqrCmkNgDpzdTGhRxsB8bhlWj/8gRPza4K1Mgto1QRglxX2+7+bpM+zkiUDZK+T7WsZx7+mdvySJBJ9iY+FZXB25RXGVRcpl1kDmp+O2IexY2EU1aMCxeoKCZ7jk3oDs5CoKezTyfrzhhGg6iWJuYEgNArDAlwxc1DtFsqHyNb4RHbssEx8dKupDVRxj7JJGi8XGx4cwzQxfSolRF9bIbIGKXnWYuTuDU2idmq2LKH6qC6km/mMtiMVg5h+ucmeLrQogNqzmc3XeflGLgQGkWgtUtMw9FmRM0efrWbtVw++cESsPmDL34oDBQj+i2TFVlcGtKlrphcjDyC6Yaq35ma1V6mexTrJaSrQAoXIlp6bWY4NUE+++1PjW2ZIE9fnuAt1P+H9tmNyM6nxX1V/X7nknrf3yXY5z9rpEyyMJFpR7COJ8PehejW3SnIIVS/bofd8L/ILAMb6xOlTRPfwOdlvQzWhR9Ypqndou/wNUvbUeXvnxev0euohZvRcfhAY6EdeRtkjrcku8O9XYoccEHeg0dRQ2QQiZxjE7tU0EIZEoA2QUxKHGniKrBdGe7RRMeERRfPCDHwl6CweUHGHr5N6PusIqoKqsxccndqrhoFCKgVVXIrgTQWCthkTfmyCtaHAg3kXXIRVmucDDT0XisMYDNis1qXiNm0PqjYAQZ9QN8zJuEiv8+yJunTppaUJIT5fZ/MnampYLCtlpCKNCAVepoh7QWboskxPTrhDFWxvoVvWXm5OPcKmxbX/MebivIa0ailkj8JVwr1Rxb/A8Hdlnj4jSh5HrgrRacO9RSCZnldlCBCcSYnr2SJwg+9uFR4fFnGTocDbztfVeluqDcf8luwBNSueb7Itbc41wTmtyhkjABwIkF3m2a2UiT+yluZCzjETVJdFdidnnIBaaVUE8daWNUvBVGOAISgfXqfiUelsjXGsF5QK8h2keismulv9l6KwBgMpwjHWSlQUjVT7QXivrtM9EJx+KKujCbuCnNU4Q+rEOEKX7dkhL4MOxxmF63ZfqmEWL5OBrq8r3iz5SMspRpm53gAYtnxKjrfXt2/Kl3XrhF8EezPHDh5RKhptmNL336NVxKEntwaNqFBrXqPa5wi+4wVt4wLppYr7tpvlJk6QdIHKmGaXMDtXr0XC6vKMW8nd3A7nIUC3zTqE2YDXEvFA0Nn92UDb9+C0R+rQZV5r1c3ZCwlW7DBjD++ge1I9fPZQKPsQKlXVGr+/Ak4QWKHQBznOQtF5wCDSYpGlAn2iIYuT7DtASoEVzpdqSqsJoBDMHgERvBEY0SQATRETwT3LeJPi9WQ7S2cPLTiVImoNcAYTRznxQGynhsJakISQbpts7pbbu4mdBbZNnyOgWH+QFz8ngkuI9CSfnUOJD+caEtAIA+Gf5JmW8A/B2l4H1Sarj7ZOe29NRWos65wdO/X9Mw3k7QoCgnxQ8/B0lecfBho5E0AcIjHV3FCjDVLsyRgphMVM7vw3Mn2m6ntmHMVOYnEMFVKhXfDpQV+/K1y8aXPgjdnILVJGUiTNREuOpaonpb2HO9LTdCsruL9dvZJUAq1+SBnqmGJrAm1ytK8UdUKTw26liydlcjuZb4onyTp7lCbXLCTPWSFCA3HDRlKc+7VW648JY1uN/KTZjI7/bXq1La9Slouw0tf60Wl8qmKoumA6LVFVTlUZGgKQb+8lxWWSMZ8HM3gP6GtATTJtbEDJarng2I2Smzd1DoCawUKOXGDuqnv6a3hwrxRUOTUzNH4lsyWteQ28305/f8a/dC5yCiRWLvyqOrBpkd5XQNxSc0lM2vfr1sw//9OAJwcFOf6hvwhG1bW3CxmSW7/nd/ndsu5CdtjDqViHblkP0cX6xOkh/CnwHj6Hls4UMYbTI2ucdqjEB+Bd/jXE/R17XYLr3KYSrS9PI5O8yQ0ApA2zMlUa2f7+bhK5wg20hjr+MA2rInTkHi5N0ES0JtGIvS3ExiP2IW7cyjjXdTtOw4bg79ZD7KJgmXvJPRyArxKnecBr64uogCbDSo+bPqsoiGDRWgaAiIAUsbE9MV2pwhemInhLWoIAjlwLuBRIEWcl8/k8ZxYH0yfyXI0JoieGCnRyK/OFFKsTlNknwRBrfTfbdFPMV8nsMXHrarVlBkiaL4sZizsf5cm76VXG2WDMxrYFwYqgynkuLuiFGuKETPswvfbdZKnh1GboIQD3Ucf5ziCGTEybxpK5u8Z41XkVgT2qb1tNKimu8ZLaKPVlF5rgzjAKHiPPQm0tuQZNV8XFH3b3isNAbuWybkhb6+YahPh4x7cqHxMMsnNAilpvqnJ5cZ19/fDj5GpZsrNnudjy/LTMb90prxd5dpXOLu7cvb15ttpsWEnCCdPUJuoWKwGYks8mswwa3CqLayoD6wewWDG71y4bKdpQ59YbhJga6vsv1huaGHpUdWWGj9qm5j15jjlFuqQeGvvaFav4qnGKXdz5Zg233susdDeLyXf9+m2wcagMsd0qxFD+NwP/VpeIf3v2Ou5cnnc+p3HbQ0323qtmMbkB0M/RRNEnR7Vstz+6fp2iV7+Ym4Ie1949TpvelQD+ZXbH9H+xB1qHx+lQUXV5nqmVXNWBLv8D1Q1uOawSmVzXYUrJTsE5UPFkkOcpHj7Zn6NW0FnLj4qC5BE073mtex/7ER3HZyczUxl2LXy9JpyUD0sppiZgVxQFBC0UBxH3aB6+xW4KrXi92JYqCuGIwgm3tEcKiMZCN3p0Zxcc2rqiQ5hWgJiRqcn+TPIg5BeZuoHpUlXvPpOI0mI1S1avF/kTYn/6eovsSbF986O//s1281lZ3F1kz1gnkLPkc5Pnr128/8/+SXrnoTp6JVMam67Scd9lOjpS1HtdmV8RRzgxu81b8dPUdO+ZAMHz4VVDIuJf+bIhQ6h4P5BiNJB0+6atjLACUrxPvupPlr21Xd3W9jhFrrWsCrwpJuUEPjV7cfbLme+ehW9PNah6BLv2npwPll1S279xFb5p6IpSQ4Tmdy8yqgGRPKX9bHN/Qy0hm+Mjnl09zp4VX3/29fWD6+XtbfH1s+0zzgDO1pwup0MB2JmHs6HZHzTbbLZYts6uCs6Y43hg7dOpS5PI5ChaQfop5Mnu4FL5qJqPsgU7iP5IqNvXdc++1pgJY2BqVgjXqiwJ7VGltiek2owIx+IAq72yTP8Pvnr6/kd5tH/HR5F7M7u/dF3I7EFFik3YfcQF1VH+2C+q8Q6/iXfvCTy9f/24MmrYNeCGUC4D+fvB3bLeT8O3+x1hHWfXFP5TcIZWngzBbfTvkBGnOgZoV/gaPkVJw+mv+OqX4dvk7yTn1ZZUf9nqN6idkuOo+jZ10au8wY8pREFbTxwuZFD6y5RxilnBQy+TQd+8Lu6WUGvCY3A1CYDh0RGO09tZHUf7XaFyR57ixao4hlhYNOeZCmwUO1qrQ0GOBegKrBWmqx+ZdxQRkDr7oajKWAMFBJ16fWl8gDWZBFIKlsRM3A1XjI2vplbrhSjuisbozBdtuqLE0tmzLH2won83uV5mr3HQK7tAPn36ZP3V/OKCEC3TscLrVbbWPPA8u1bEZnogRvIrlRAwZO1NVovKH0eJqAqgplWoPng1smS0Ox+fmyeJYbfZ/V/9+pN/+8tby+LJ0+0P/oOfv/HTH+MrtrCx2S2Q4HIXEXxVA0zsTsQuRUbjIdbPnC+A2UHx9VxSU0E4SFYHKoFoQh24oBmQZVdUr03xfH11PS/Z8Gf9yd99+Pjh1eziKis4XW6WbOc5k79ml4vl7eQpdVLMZuqhZ3XwIp8bExoT6tTHRPrR+BWXKxeL5Xy5YNqYVglzugSNSF3apjZckJQ4SJWVGk4GTJSNYr4a2CryhsYWcJCsqUKu2VzZEpiFxGBGwHh5EyO6k8UVee/lteKVZns94KW5F+0FI4xUv1gT/wLGkOnpM1XgiZoO62UF4MrYG/IcIwD2XkJkU7na4l376RT/9VlktlQZ3RZkF9Ll0WhxntAuD5xrowNAiZ0HGmA97HfJwa3DjowuwHmew94ub0FuQOdQ1rGHmxXOR8wlH3ijZAXruVp9Fc45COohmACaIncCmybKgf5s1PwppWxBUi1yVyXFp55j3erLr5EbnzFOY5cSw6rdK/4enCnqUQetPdV+B1a8Va7Zoke9txZ2azaOOlM1X5G4Klkul4Rm5Nt6X2Is1mdm9PRnOcCNaCCGuagwf2YztLGRySnkMmlDpz2tt2+Vq3vJ7BG56+Krq3Ixz55e5ncu0h8tWSTA/pBqejAEQDf2rGDZsfYJRaZmGKm3V1etsz280BuSXYUpUmM1lRbxjlqO5qohGGfP8W2HbJgg4GzmqCdyT/bhv/pXn/7pL/P1/OnqKpknb/zOD2hdJZyexTCOImdRq9m1Y1zxkydroIRWtSLIb4q1Bhh1IlIsYAaYy7JHVRjngGmSbsLKZPFrtvnfrpjGs73elJwOd311vX34+GqjTv90fVvDT0z9Z6CJFb8F84A+zZZXydU9q1RUraLMGWii/UA/v1qtsgJLNQaSMpJkA1Y0gFR7OVaMFQDF+l6ZLamsUif/2pomlWKsM5H7pSA6m4Lc84dl9rVWIcvF0SXM6LGdtLwujuotEuJ+Qaec8maoZXTZ1jnHfnbeafHc8SCORPcKmO6wLsJUyIAHGu/wjp5TmY/gxTwHdBiibug2hDQA79J2IUf8do/VyQFNuuAeTcY9M54bC5iM2Vp5EnjE8GCsqqjvQjmNP/j+u9yKOoKU4UT4NjhK73dCWT3fcaPQSC8/YqzdEpJu/s5X38L0NQCi614t3doIwV2WMah5m4xnx23SN9AOYdYgnPIwIncK+Sucm/NAqBgkKCa/t8R58Y3XkJEidrYtnq8ep3ug1/9WHFWZWNBkUY9FRcRSRIjqTHUkAnf6TRXHq+9e3GymENEW8VWazRc0APTa1VwgYnx6WReE7NQHm4Cuzn9CKnJgwLRtPYmvjwSw6wuHo9OSWNx/Nv9yU2yYy8FeQemiWF9f5Rf5OnlerDasKSA0ZC5LsiqK1aN0dqVmhTQxrUmIo55f9HWITMc1n7qaWIArBDagHj2jCkHNpBZVRG5BLH41Fkxrx0H5dbF5yGAJferlnOK5/3Tz9Lq8pX4lIahrGwb8WRFULtOjSk/FxKW0/rsqR96NU0VrLTUBaludO9WD+lSy+PuJjo0mlmeRyHZ7zZR9SndDtD/jCGBm/NBjL/XUgsjW22Sl/WSlP9P/sVNxebmkBQREmHxadE3TQCJFJrPVOsA0EjJTAHXkSysbnpBfCARVKYPqGq4AropG1M7S8xC170rKfAmTcO2ozZMBXiXc9Db0W/EcVwjSwdBvhfKvlGx5IC7NVtbL8PgSV7BQ8Q9xYSDCuXGaR38L6S1FznlGAPpKsPao3mKeriEV9oSWk1OEFj+EcTqW2m1BdiExfk86apcjl6vlt0AS97DG6YDQSsQtyDjLRwYObnNP8FssZTAd2TuI4xku0dPTqfYw3Z8d+zZO76c0DIrPy7GLP1Syce0aIe8yPAxyJn8O+aRR808orwafQyyM3d50Y/3EO0jdJxZXGYy3hAVUBEnl7ONytiyTDxQZpdazzyb96vrVZB8LkLa5dgJVNmpZuEco9QbvszJ7BExQBhIYOaCzn3CK3lyB9MpTBCix9PbeK9d3iuTRmgXBNCKSdTK7eJw8WxXL28tZmmvBJ5uFruerLL1dbGh20HCQYSWYmvnuUZqxPeLm/TH1vPZ+Bh4zSyba8+E29OMGKIphXoxamW7KK46tfMFrWWGusVVTi6yUc20JSbXTPEzIBUcE3J2tnkBk6WuxzWdsr1RsHz9eP356tbpa5Bez+cXjL79+dP/Z3cu3bEEsBUD1w1fSX3ZUl2sUdFROMzdk1RT6VEA9fAUGotV/ACbYeFlufh8Li+17m/ViU36Z0P2/KdbrFaqxWmSTXm+Tq9X2kk1AwWb2GdWGTv3N9R2OAQDAI4tJ6E/flKsku8qSO3BWdZWF7lWTYkKRbS1XIAwjPShz6vNlrbyAUlC1SEZx14nUAjEkoLQ1HnhLqJGB6x1N2SNX9Tbwfr4dHrtbmQd2kDp14Juh0rqmPuizNQYe7AgJuPG2cUVjQXJxR1LchxojDL0POwxqwIEeqMnany7XoQe/M8+kg0s/2ANtU056RjqF5asIWjFPtxD3Sxr3zHhuzH06Zky1L737Uk3mP1Q3hkqthh/jvP8/e3/+K8uy5fdhVZk17eHM99439Gt29yObbNqUTFmiQAEmJNmCAAMGPMI2/UdJPxj6CywY1g+2YdOGpR8MmBIpAYLGJimyG+zu192v353PtIcaM9Of71qZUVE5Vdbe+5x77n0nzz5ZkRErVqxYEZX1XRErIsqvjUkZz8yrWuW7XC/z2gyAl7SvWk0JJNfTWqKqTHVSi++hr/IN+XRBh1B+hzQPVNfvsAYfbtHeAe6m4daO+eFW9buRDCXd/UtW07DzUqSNfRrOEeKUn7+NcaodlQya0mcBuJeNZKgUEAnQZJzCAD+x4BmWAeAcoXkDXr5kwP8HdkK0wnICTBr81wwApAAxvfGIUzRcBGLZ/CW5mhU3461YsTFQfruaz9nrZ5Itr5LZ5TS9SEZbjeLqOFhODNCmoBrchaWzQpIBV9xD4/CRrFJCIJFmrJohpi8ghB5dptqqZGQXW1UA/qYIaVlKJ8FKdPUYjUVYfomDtishaAFmTqbsnz+e37x9uXy7mbCHUjJab7J0q/I5AgvTwDTOvkDWxNJ+qJNz0p3/XJHEUdCSTrntSxBrVZJLJThTIXqix/Md2/Qwv5OZ3w6IGyL6UTFXF5LrD1noYezxQ78gGfSf6bQIPHzk3Zgl+UKOYXQNDfmjPPVjyvCSTAh1NxTK2dSWRAlEW4pV2eShpyo7f/oWSD2Q8Gg+RXC17W492r43IoHU6EQLqfMpPxXXflWU7aknxD4Yo8MynS13v0INCYSkEK6oPn7eSwNBn0Ht92JXZQ5tV0WUn63FtUbWMn7gj14FhAyBowJ7lz4py1GeLQS9ApGoSx+T7vXXPk7ZY9+UbGx/Bi+PGYWvjXXrraIvE3s4R9nRV2zxE37YLhsVNTQY1zEOD81f0bmV7NWprL0qreezV28n8OkpopbUW2KNtufRZXOCIXqLaeJwTxG1JO9xcYep9cEafWfvir4LD6DhB9Ln3XRSq3LHY6yzDpLB0c6Lu+2OUr0swUiMqQOeAqgxCt0E3I27hkiFTAFGgmVTJQGMiMvPgftJcm2O/rACqd1o03/ISPTxVCJxRtf7whw3AG3jWVZscRmSR+R2/odXs3nyJU7/54svss1vvBl/cbH87QQzIL3A70cnQI3W7MWecAzsFJcPzhJgdeiXMmJ2n1T9SOLWFcH6hypuvPsECi6P2FN3jf1D5xnIQ7XKy/LxpD3+8Q1hhL7tqs4MrrKJkcL6POAVhvZpEBKBvahUriu7Z5Rh+sfi0TJVjASH/laemJhXDyYZltM82yXXX3092uI6s863Z/BYra5YheHFJtMv5G+VMy6oFpQUrgYvU3tWWJyxthsZieF+0lV2lcAB5K9OYMKCmdXHrDsVuxecVDCa4JT/dswBcevJevc620wxUbBndvmtlpez248W6CJcMp+xGpjcbPYJ3OdoAOIzAf/xaqyDIy4NktNBvXcqC8oS9rdeLd1pn1DkMqtR8F0V5L+gvKSmH9OrLMK/GjDXtBVMMAPISe9dK49lJAPhsvUPRvVMaQcx0N35it51MQ9/78W/xZ465H0YfulUgbbLO0LoDqpzG1l/XPw+HCJVP7fhqXG5w3MNoTy1FsMlqSm8R5h+GeIG7So9NGUIxPvneOTdWrxL7H6Zu3IhSVydLrJmvAs/vAq1grr0ZvGlzk6uUZmvKew+xnaB8x/IfWR7qJNbXBXeXP1XTNxP2Ui9R9YGr8ER30mhg6X7SCgN0EZcPT3PG3F4U/awsqJ+HW7DX2WDtBGxs+YqwRmACqzjHAy0AZnUlBy6JBiqRrVUjbMyJyA0ak7+vLL40/irQS/cz6EUqLIXELMBYCuBS9kJY9sjSEYEoF8LNEFpEGMD/Hnx5Z9+e7sdf55k3ywWX4y2X4znX/ze2c3Pk3/xfLMcsQ5gtwT1JdlkNs/WN8vZLNPxrviQaLahlM3E9hpEd0+UUFX1okBE1xZ0fZRaCQTOy2NNZxYRkkNA0Hp/uRz7Zw95VnQlsIrO2IqSPWoEMuXaI0iqqRPD+WoM06OmSaBlXQSnpBXb5aZYr19/9WZ3M7ldXZ//5JO8eLK8ztavVuvx+u3Vq2fpM1bDyuVeihKkpX0QzUQnDNMgy16ZpiSXzlMH3T2/wWgrQSVymUFDUHaHRvqtezCMT4uef/kHr17+6eeLi8+20y2+TNgC2w10nATMxADIm47CeWDaOIotf5JknnNQADAfTY3z2Xx2tpmN2CEUQ0n2Jlel9VJ26qtSXRorGXmg8Q5KkkRWX9Zgv5QjMU1oMVC72KPmG1Cip0FmyiuLEHUUtMxlgR4+iGlQxjQnhr1WcSYXPY7pCTez14jL+kaxzj+UcpRDlPVj8IPQQLNNg1jeNWlTb9bQyoHgPQfu0Lu8Cn4/SdpQ2R79nMTwZGIJPbHVwQo1qtA7Tom3NBncdukbe3Cu8b1HzI6xh9hX3r20vVy4BiX2cH2QpJMssIHVjevVZQX2C9+U6m58ylI69B/L0CwxTu0Px7KdyqeH3rVdKzrWrXeS4d9tyoL4YKwr+i7EtagVOvRxgJ6HsjqFrkeHDTb6bp1C32BwGKE2EktDO2gX/fInDCU6YSJhJkvlhmEAWOdRcXZV+gcVCRjhoL+yFmaMX1zhYgO99sGgs7n/A/oTFnViAgDllAV/DO4TeAPltvmProvbdfYj3LyvVp8xvJ/mn/x5tsnXm7Onj/P0KtnO0rP1YvY8n9yu367PPn08WrJ5/LNE0wsOlCWkitR/ySGRibKRFaXosmp5sPU5SqoHqxF9xYcwJajAtqsqsp4m7Ki0UhSHknrGJX6UL3e/+uM/2F2zCU7O5jc6MlmbpVoGKW6mpdAgZ3x6ku38008++b3fxgkmnV9cfno2+mTy2e/+7Z/8a/8ySeu3m5e//AXraT/5zctk9Dl7aDK37OPaQrqxzBr794v+wGUguWz/urpKwvDhvzXx/EnJzSrv383dC5Ur1vnYPJKT4kd0kpT1INnk+vXnX/7JH25eT292f7gePS9mTP48my7fAvbX66tRMcME4pjo6XSULXfZcrrc3I7yGTvC3ubTNZbAdnLNMcDWb7EH6YtUzYybsiqSgxgS1C8xG+gttoeVJllYfM53X1W1rwBZ+NPKZLYNIqQ9QFlZQUbpyyYHVAD/CIuh7vv5JWjiq3qEpgyWH/uImLwzXH3XagThvVdjd/CerPLENB7mzoVEHgjhEFMKG4Q3+iZZFb3/9IxiG71Xg7R7uvcSOvmdGcncFPButRgiQ1B7rdBm3n4Z4lVzNVa1x30zkWB9zDuGk8WtH3pIjcPwR5e5WZchHGKphtDHNF1ajWkIe2UDcYxpDyn3muhvhcNcjScvb8+sJDCeGkuLvpRlUv0jyBoSnKcepbBmeiD8dQyEPuQ63+vq11EZ77zOoWM39dyMeefS/HAKeJgvddw6NmJv0Ex4H9hjfifchXgE9x0a8YIUqhMuNBlgoSFqz8DO6SwSAIBbmtywQfOGHjVq7aXpSFrNA7ChC24/DEST7hmYB+ABFw9zv8jyuX6Jck4C5oTXcXr1ZrP5/T//56Nrsl/tcPWereajby+myde/fPM7/9bPn/+lH+N1xNh2zjZCFGxCmoze6JWwB73u4MHpELIltqXjBN2RVmWqPlvI3WBqSSj5eKGG7YUrBf8Nfr7507/Yfs2u83I8kduK0LMUa1Iy92JuLygs3z5aF5O/+jsFS6bVRrQAp2VtptMFTTB5dHH5e9OULfC1bvtbEWj8Wu5Fkr3nUssHimGKKblBHDJalMtsHcdAudWyGO82G5buXl/f3tzcfPnHt8VmenH25Ka4mmTrYpuz7VN2vb15c3N7u1sVK+qOMYQSrjevr5OzNymofbFaXy9H02V+s9zc3LKKYIZFxEp0L0/9VFqltymjRYL7USM9RDYOslBJ7lrFLvXqQv+aS+JTOcuaQAOtk6M+eq/RmoLKYPlRxpPfQ/v78Yg97R1DZb2H5XZ5/O4ZQ/Y4qcYs0Nfiux6hlxY/Xqdo4L0pzVvTRYtbNvSE0HYhcEo9Hpg2SHUHvqGmAysS6NvKInEgm7bcR+NUthsApxdUWiRRRrO3OA9YXO94dYw9xPvkdHppW5F3s/l85GD3XCy6LK2u+LimlE5zISEq6Lbq9jmCZyRRd5N8iFT78o6GuvQfZTy1xK56ncqnSd/F2YV13UaCnxA8KKs5QtOMOYG3kQ7Q86ksh9Af1GtABvsu+8vw4DWk8df+1T6tzGMeNsapYVS8c4Sf7KVhpgGc8dVO2dZTcYbluNnKSCFKRqPtUUCKAXgbijXQZEDIkRgZxR9vFTlSC2T5AKpGZW3QVnMCgl8aIgajTbRhJYPc+WN8W/7gF9vfHKWPnpxN5mDisyLf5NufPH3+289/6wm7uef5SodcsSiZIwUoUnBPTiNmnFS19ooqGRnql4gHXvE4t+/l3J/RZh4qkmbJnqJ4B5hIjzam8/nF7HI1unZtCf0W+L6DeoH+ArNqHyFXVsUyhs6balewZY7pkskBpU//XAcrpM/HY4b9Ma9S+alTTw2Aa0ktRFbr6lN5YGpQ2XTomiqBcXOM3+jL214nrkjuztYkYW2GRdO0SKJCdj/iqK9f/rM/XAHub5bs/M9hXo+ezcZnfzjLp8ntzXTz6Xq6Wo1mX04Y3E937ArKnFGa5tt8Mr7M080168IzTo5b5PluNnrE9ABj9QD9XcHWUPIoY3GwbBw59ZOGk5RUoy5H3zMh1HuF6dnWE5GiyRAqTIT/KQvJ9EYMrufFjn6LjcH647VS1ASWzl1mZxWmgAGXFDGA7DQSmMYXBYQYLyx+jCUI8XH2rnBN7v68MroqRs1fh2ZMRTv4c8Cb/9R3bIxtOuUYUG6c9yQZ4oaDSTNvv95a539iYeJwaJ0y0upVrteK6R4o3KzLcMYuauh+PLqiQkwPqyHYL2SHc7ece4X1t0Lg1h7Ys6nSvTKKt7fJ/ntTEbR+tlS+zrqFpJXVHSK9qLjAOHwHhg+e5Q7y3CHLg4v9Q2Lo+uT+UbEP16zo8vB77a+PYQVAu8+8DxELAgQBOUYG+gDnuesP2ChQDYjnj1KgcgQP0OI3A1Q0sfa18VQNM1tjA/nlty1KuJinvvlg8IaT2eBFcwdiqX/YCgKxl/XBuU0QsOw12y1Hr7LRl8V2O9pmM/a5GbNU9C2nx4IH89FGhgXSSCPwMVymJxWqKQEK9q7npTU01BHdoOuPsOr2k0hph1eVSUJbGsJqJ3zNA7CHD1EG6slkyZApv34eCMjqsgtnFkFU0zStJzDMiL+0qUagMWVVEZZpgFqFhktO4dMZ6e5y2LPY7BMGhUqJ6tnUoRSHIOYJlu222+u31zdX1zvOdcbwo7VSNnnNcHfK5M/PrMWjZHZRJAsONptiB1prsjCYBQO3y1G20XFmmkza6QC5KdMfOioMIvUYq6x6LFUmTDfTeupSg6WEVhsUqT+LEtCHxKenSFXHca1pUQEPspo0y8T647JzUycS9nopo/cRPSFlO8jcQ3vnpEi2WE7xi5NO5V/L641NZC0+sHWC8Pgx8E41cKq2Q/MhVcgbAu9U1Lsx957mnS2+341byBWzDZFtgXemG6+M3lr32QXIRUZI2PFDqf1/FGqrycPEudg9vA5sqeF2s43IHuTtKaM7KbaGfabCddOdo1QW9bp/6Z2lDNdDxOI+Fmec993Vq8nZu0foJCHgPdJXBZw8M9AcrW/GRHqLg7Ee4vjO8J1aquR2j7y9coavcwgwy9dZg64EzywfnYqNBkoJlyCKF4cevMnYaWcyG49+IzDTAKoQouYBQJ38FewCpMg1EQ74RtkTXmfF+I3mFQCg7OZOgrxc9JozAORFg73AYQJZhtnkn82oLCPf4+RsPFqOZp/sRs/BfizxpBgh/vN8/uI6Gf3OLrvJ2QOeGIbANWAOXwpj0LeqhQmK2AJ0Kl8f/nYksqp5qNZJgUG5D4l4QgBGol9yG/sMp5VJgmCu7KoZnj2sdWaHTFSGSrIt0B1V2EFsGlGVChgQN0aEbczfao35xWtLdczw9Qfoo1UtirAGwSggFQ8W9G9KsHIPbmqUA52QgYsdlg7IOh8gFwMTzPhYc1Y65wGZtakOo/6M6TNmD/5mRmAyYT1zNl7/FlXOR4vx9HrM8t/kOp1uJ7PdaKPdPpcZrZvg77+bYT4YKmeuRDvzjDkTTIeByQoSOwrmn50GpigUZKWgCsRzo1N9y6aaJKumVvQx9RkDawXjIebomrbAHnszTt/g6qa9iMrObb3I6it7S8y7L2klTvWHgyglqxGhhFvtutub5FiuIBWCEPar34M8To3DVe72T+fffEc1Yzx/79vvsIiON/8gDsf0c1jS4VNHuYdEA55cBieseIa26MrfpTfoQ5t25W2NDx3AZ2xcgBYd3kdjzYKb3JoxzVx3igk4kKq11OtOPHtaIfDzN2ffitxA6gG9XOzXshbPY+N10RJT5ip7kH808zV5f59iysqdLrJnvHP20wv8mOPhNfBD680Pr6HTOAqdlV8JPmyoVPhDkcAoA0rgK719DFpVtKEQI2IQFg8ce3dBrDFssBlg3gAY0EwcyK5y+JETCgfwOYC1IgBpTkHraoGwioJc8BGMV2zyL3bTl2z4uV5nLPzM2e8FCJxd5bvrnH2B4KnlmvJfydg9UsLyQ0KMQUI+ufxuQRODZ0nzHq7DYg6fJINiDDKbWjQxgrCsiqYK1JE/fFrYJNUG/DOmNtQkqh7bWXIoFpAR3WmxsBxd0IA4lrqUZSdXGFQpXXK2mhYUCDarNXurrizlVZO4ij6SavkDE+OhLiCAi1mzYV6H9rVmRkKkQSbG71ntu8hHbAI6KRZptpjm0zSfpOMZg2IZB89R19F8O5qPJhxlQBiLT4fDKUA1veZuxEp++CrSVGIPKI5olUYsGeRqS0hkuiSk5zAVygIVrtdiYK0isObBC0s7qpb1UQZltEcCJ193znhyST0ZvPZ+7yHrSorrEIe76D/G92sAHdIWd26OfuZdqaHhQqCL8sOMHy72Qyj2FB6ntqVei/tdgKqOYPXTDZ9Fe/0ME6GTqnOk4V03b2Xj3qeczlodY+oZB/YViFso72Shtlicd9LDEIuzSwf3ySu8wXUnmbvkIR71njz238NuWNLJevBaD9dATHkPjZ0sZ0f14296czSi6uHAoFH2Qu4SeNpoe0kS1Dww9f8Cb4ZSDSyRZEOVViZYf8wW7uMV0E4OHnKzLnY7oCuY7q2MAKi19bq4JglD2uapL2QqQCZTQRiVRB3yqhgdB2XuQpqdYKPPUb57utu+2M7fTMezZIq/f3J7/fYX/0X6yd/YzeYccPtKwC15rfHu7VOmAvLktboro+D+JTZYZ8Ka25Lwn8q0mObNldKV2qSvYkqFVY/RZ5RSSjTaj/17cQjqEjGwz744v8wvvtxMi7mG79nqZ838iudETcV4g5ISEpVWzPItTjI7XNRlb6FS+W350PhBFfFfl7aldn3WL2L4I9Uvwgo26Sy5qoUTlVksshSzjFK/EicKFNoHnKu5MVZ2tzwk2DeAdx3nBv2EYf5xsRilm9H2rBhtknRqLjccfcAChmzMMXGcDTzafWVrfzkHLE2349GcxQBZMsm2zzmqLpm+VP9RkewZ+1TlTr5FY1ZffdIFzQdJIrGSxLoBlUQA9U91caikRD2YFllebo5F4sqFfphggaHpyW56Kq8QqCLib5yEqmirb2U9gyyO1qvrTRK/bZoZu3IZpf8qhZHRkLsZE5IIxKmEvVIxwYOE7//2G8ShVz9DKtLyyz4kW0zTkIE+YT0sJnqY8JAZGy/dy2vRYUNap7yjHprcmjEdVfcSYzmHK+1e/VYvCt4uHWI1olt02KCJI+z96YuA/bvldyMJb4t310ViUX6Q4UidP8j6/VpUKn5JPUyF6Rbh29XF8cPtOneX7ECTPIC4QZUMqjKirxed8BC4SVOSqKUcUjUF8aKyWAE6YNwkz9i0h9F3IB4Hzwo+bbfyzPFfM/ERe6YCcLegCIExUJRyw5lP+bQkW7b9ETLDatCwsMpkFDZJN+NvtsnLNTvd73brbTqZXEynmzdXr65ff/3jnz8pihl2Aj8dOJXY+Kyc4AGciKLymQ3w0ilQZYkp/8ugVeY7vUkYuySsBKf+o/THf+O/9+y3LsYbdr1XBHMbUhXqkXY2pvU5HlUZbXU+hcSqpBqaaUPTaPDaNCg9i7Fp2VZjuAK80PLuZVdKKUWS/tuvWooVjrYjYjVxdVm8RFME68mzbHm7ZSyd0+NosgkmHu49ODiNcR5jhgOEDbhPWQc+msyIxBJIJlSWnjO5KWZ/kb/OkxXnHI/GrB9gxgTnqGI2SSfzKesFrDt5gTMdNTeZMzMync45lE5nh9GfgPAwl8OPDF2eZTCZStCvlISi0Z56MjKrizIDQ6z69AhD18bgotpVtRzwGSvIyK1c9c5GygBuD0XilT+VW01iHuHTcx0l6Mn7a5XUr8Yhqggcam3Ukze0TsjbQ/zBJiH8wCqH+p5cl1JBXs7DaWvPibeBGwBBxhCIhPXyo4i2YJs+7mirOfv+8YbBNKfKUKN3XQ3SAG8lkzmMNLfpsk11XXGDLdSYwalWYJy3c/R9SFscMDrxIeZ/p1p3lXffJqjxjeWsJQ1/PNqZhmsgoqz12+HiQHlKXmm0iz4eU2T/9fCe8XdDeKRE/BQZp9fYpA6YMkykTy2g1I+7xjyElzTej84dKgm5gNCzYvn2+uV2q7qDtNh3RfGYCHJhJxePgmo2wgo/slOKoJa5/sNKgJUCzDuFQWr4UBRYELSbQrvcPFtmj+a77YzB2uR2vb0plgi6/pN/8Ce3X6aPfzR+/Onvgsym058V8z8rVi+0QZEsDgedqopqQIEG6TzWmry13VsjxaL9ik8DaKFwFUc8PcL2wo/mAaQLT9G5Zttnk/koPZtiRjGjwuwMGqugvQFTWQPYSJpv4dBcjlI2DTKrYoaTGQFUeV8qjVGqAa1U5Ugp1eW0+wxVfMtnTLRn4Hyl98alkr10knTwb7a4vPj0J59y1G+K18/V21/8J7+gsbW+Fg+gYrbbjKfzt69fvl2vMBSy23y7Ys+flJMOMB/xAFput5fa84n9oGDLSvDReDp7NWIlgRaIw0VddDx5S3iczKZ0SaYO3ONM3Yplw+yLilcPliil0iu1BqAopkxPWV4Y8kWwGQD1f9hwLsUjbS/EYnfuyqS+JKVaZWONHNS+5vsbdBN/KxHgIM9JD9Hbppmv653glP6rFERqZm+NiX9PfUR5IJ96QQ/y3m4V0SOH8B9C01PEQ68SrKuot+ijic1eFc/eUJYTeKH3LPqOCOce+m8tsVnlVi3dq7KDx/696HgOsFWYMrJ6P9ubIZ4BID2Sl+DASvYV9jHt+6aB+Lv6fZO9Lm/UnetJw5+PKgSCBylouEjfC8rw9giBUmy9gFCYRjztHQS6ETDRC0fIU0gJ7CSQWkZX2Ae3ISBRulmxebsIwKPkTNnGf8JejTv8J8gBTIMZiz4N5VIQ8Et2hXx8YIyTixAVMWozkCDEOi8M/M8oMYUnr3fJ69vVeJvMxpstxwzz0wHW++KP/+k3f/z5bHF9ef6bi6evz87/6qO/vPvsr/01tpRRVQx1Ok9xVXl2vxfk6mjmuj47yKx6perqJAEjWzNgEOU6M0FNggakQPCx1ujxgBp1FyM8ZECyJYi02QOJoroa/xDgWTHouXHtZd9TN4jKCGhjon1W0u0hEBwW5I2hO1M982c//pQ/skzOHq2++eK/+3/8/mQ8zTTfcZtlC5ZBX2Wvv/jy212G2cNmP4zVj7f4+iS7m2ye7s7pErjlC5rrUrmsgBhhLqEX9CYRZKpykd2v3U4on39b1lRvmDdJplOcyXIWpovM84gaowAdc5egGvnHvNJiZS4o6cDk9aeKtT0NvZFX+fjvXJTv4GEoow+VrrUyqvLH6xQN3F9jgcO+o0UClP0wivkBBL3KrfWNaxcTBC3FBKeEjykyLqyHr8khXqL3xUkNzqJhZIJXR6/dvy+lrewDy4khDa7hNk1vuS5vUzYJbOVYHRU6kMGS+m9Neh/biC3aLg5Neboom/E1/bn+RdarhyaflpjBtm8sv2u45HZ/GVrEiqIelH9zLCp0hqjIk4NqIJMz9m58EM4ni1JliGva7LcV1fHPlrx9fSbe76tbAfqmH3Si/YOwj1C4btpLB0cTR4zmpc1bxxAVSJM3FP9BnLw8jEZQlGHYGXBKvv5kA7BruSYIavSUnOPkShFgeVkIGkAF4pPHMKHWC3tBdndgq8kAA+7gMLaBZ3f3y+36bJ290YY3WXYxvpA3+Hg2HV+eTS+mowVEm6/Pd6M/y/OfffZXPhnNXpk3B4APDlOd/GojlwYHKTmoQR3otKu5I37Y6b+dmWIPUuwVb2P/8lBX6fv1AEarRqBXkwlts/0/qtD4vt+lpSoGk0n9H5ViZOWMfKMTZm+EgPlnGhYX+69ywhXkCYEyqTQPymg+XFlVRo+vZ6pSw+c+n/UN4q2pZbbQssLPagiWLYC1s3mxZNvPqYzAAtd/zjVYjzj5a8Ox0Ov1bjZLcQ2iU9KX2O0n24yvs/xmlFx4JP0IHyD4jtkhiZ7rvVZ2qH7aKIWQAurWBLnoVgqinsmUvipN4Q5Et6OjqALE0CG500+xAeCf8HOMj9ubUfKK4f/xiL2wOIIgaMqzKeugq1SopGq5qrUBLUl3iGp5hzS4qPqNyJ6I+Peo6Usd3n4d9YsY++9L3zstIr5D0Pn3Z2zSDJdnOGW/DJYa9Faj7YqvkZ36SIsfb6BTmZ42a23c763/1nOivD+/iwoidKNFjnx7hnwHpQv7HoqXXli1GQCl6zIaD36I9y5NhJbwQBfZe6tSkOe9lXifglxdQWYC37kC71Od95D311hFoZs01Ry00tV9BHrAX7icC/0LAwlKCq0KGvEnGCbgTiTvIvCRFyI7YLcD2IHQRKnjmOT7k0xngDKY2DuNO7hfvhhs2EhJAoIwkTUAG5AWN9CbyHj2yQHuRGhwu0iu19mrMQ7vWhKcLXdMAmyZAXgynY1nOUVhs6TjRcI+8dM3yeRavGVKkFVIULKrAB5DmFJUcvdltN3J9RQn72ApHYQMe8aqqlfYApag6RfkRGrV3SnUMBELx55EKR6/GaMkQPvQZEK3yia1xcVaEeWtMyEmqof3NainHDyr7JK/gpZLAb8QjmSMlhQwzeC+HJtyOfsjvbmK4QqmUfzxaLobsQMov4XqQTjwbOkgeOJsp8WO48LYI4n6SQNqVDSg2SLVuWxlWUE4+0wUKzoZoySqA/NftgALf7mrJ5pyxcdmqOSrRpGyEpIErzZWLKuzawYLVW/xYDLNqySvFqH7XHvd7LkQd0+ue15HQu+iKOnGauB1ez9ViUvxco/U/Nc4OdbVr7Ea7l91V+RDdDf9RukyXm4AEHHImafY/o7Fjz3zxEmkcXpHmB+bh76aJR/INqC4ho11kMcrN9SuOsh68OBjxh41ZCYh9nc8YNTx4LXwxBZpm7ZvB59mM3pM3DWaGmvGHLC/x+hFzDkOH/BvPLRooEFzn4haCzaVNpS5Bg6BvMfJu+o+vKZdHDrLHtpn/CsCGwUapYTUfTn2nTXnfuAWQMhQmkIClAApASL4ZAshdMEe+o/QlvqgxnS1+c9ux4FcGx3zO3kkJIo1gJPGZGkwXIfSypgQYBN8ApFp1Bo9GwYzPpTrzOEJ5CILOZQi8JWd7zazbLTdbNcs6Czy9RnnZCXrongxAhmmk9E02axWjJufFz8uRs/z/CuNjos5PLVFqL1KtQZUDA/ejR5DQR6wdN08xgTQI6kW4z6dijm8nDCQe2LEkqpQQ+chRaAKqncw9m+ZNQasapuhZSryoiW6eMAYZCsleitQT6mYFa67EX7x5dQBhDVRDqSN5DqIlxXRecGwkc97u/exskAv2FsOXiGXVUDVou4s5CAehM05X/TqYpsuMecYic8L2pSB+d12XKwnS/YLJcN29RQaTAR6WTbaZGM61SMb4ycvImlWig/UIMxue86yoJwkue4oxjoZvZZ+DaEKonc+4cgxNo0VPRaBlCjN8iHfKzb+xNq0tpA+JK7csZhNUr+SloxaaZZvqKevMpQXDLhqGjXvu0ZsmePgo/G9Pkjtf6jlVVX6MwxO9f7gVXO23P2xnUfvO60mpzi0/XI1hVdviMpr4ROlHgR75emkbJPqgPjYQ9evRlf8EX4d8oQWIXuXTk6NjyW5o7QxixP131MilfW61LBBXBrhWlfZp3boMC6x0lUnjz23OOTNEMcQDm93fhPLt7C6sP7HV/05TjsIN78UB8nv9AEhB8t5RJB3XQ34v+sijtRwQHKrMj98sQfU7B2StCrtHZb3YbEOvSMETL7Dp73IUhZABmzG10HjnQBMgJVAEZ8CTYAelkiWyYqyGH3y5gJq4/A/m83nOFZDqxHccTHFQ0essBAEkqBI2K6SnWtAWUAsOa+rCIwHPhRgBBjEZgjMEqDTPi3aZSjhGKgbFcbwq5zetes9m8PPEiyBdJbO8mV+Mbucj6dJ8WacvOaIKU4SU7nC2ZLVLqFOXZQvmKokj4gCVYTR2UOg4alkEBO1hD0HdyMPT6K0B0f/LRkV5UV4pr18IaHKJQJIrYLUBn2rJTwqpqnC5SfZStYHCdbCQU8HSTx4jlq+hiqq9OrTufhTSYy0Wsqg+muegtZkQJ5NTcf5ghPfhPzpJCz2VZlneX42TyezYoIX1BzfsoKJHjYOPRvtFvLpGmtluexTdT+1LHXgrlF82Z9qZEP/oiFIsmA/vUIPOiiOzYjMlEIUyaJYLmW18hWhPmkdkxieobNzAESjVOOphJMvGIif5+PBGfJYcT6Z4weZIVTrVOn2ygla6mBxF+13sPrBR6MrWuTXTWNHO6F3Nr/ftQ+cotQmLSIGKfWe6jkJuEPAg5mBwKuDuC+6w+7py3Is7UC2qv/1yBhsLFcU9x7iY4V3pvfbhc1sTj9cklCLJqtTY5odxjkEzTTLasYcFDrczj7IpoeYcxx2wsombmTriECftdrF80Wtsy5O38zYUUI9ukVCH/XUr77/9teztD43695K1hN5fw49zINeJ9/ojVJeIRBFGKgXzpFnBAiLfXsMDsrfGXcHASC+gXn65Sh9NJn8hKFR6Uv4TdwAWzhXzM/YPmWdjs4A7mItLwushTUc2HtRd9t0xejZrZ0iyI+psC5yjAS8LNKM84M1tqq8wvmwZ1BWSGsCZlvn06vldDpbJcXTZHI7Lp4ud28mu2e7fHd7O1ucb/IxHiMrzoydj1+MRufwBNIB12SfUH35b1CLbDy5UiB7Tjk2w1B1Js7lJbgf3bd42QmmvPJuwkmZpFo1JW7b5YnVPZCawqAnAg5WRBefyddK3r2wvAbro3ICQ1OWJUy+0kf2iYCsMy6F1EMZYYS26gAjCi1JBbrr5iL5XXHhItGK92+Hf1Ocn6X4t8mpAw9jKSGNpGQ+ZU7G5pGIpZ9Z94FG58fpUK+VGQaznCHeZDvOZpP57e4se706m2wux7OrJL9cbt+s80UxuUrpEeMp9VS7alBfXTRbPy7GpL5m4S792GafkJaaPpVr1Pi1hFZn1o1eUeDQP5lOJs+omOg8vgzQixnsVw1cRTq8It/I0pDRyv6hK7hJ0VKgkdV2+1FOuzpnBrCMYeFalWhciuCfrjLGwh03f3u0vM066OPo5psnXkMVU/aHrer9JPdKDb/Rrg8VN+yXqyZYs773EquZuSlVL466W6s1i/WYFm6H8rg2aj0r6JZUkoLGunR1EN9buxPk7CJ9oHiXuf/LFOONoASVf6jDVokOdNJK0RppGj94M1QNIAE0rKBVR61ZeyOdS8XL3ye9Gb6bxIE1C83WSh9q+Z7r8P7L9eoHbdTq6/I07zWyD/axq149AtcUwmMrE9dJD58fdFKkJA96bV1TUYxFGNQB5OoPYJKwjSdDs6B/Bkz1OjLgBJTKspubW0ZYHS2VHEFF6fjxY1kPm82Skf3JVOs2s90W2HV5eUGMmDDuy/wCI66T8QVbQP7oaTLGAWOZsB37aMvSTvZ0326yX/75n203a3EWIMNsoCjsh9Gb7Oq/e/2r6extuntydnY7SZ4mydWn483Fk+dnZwtg4CZb5dfJZrs9P1uxQDRbM8oMvgK5pXm+YZ/5QhMGWsKs8WfrM1ZfQmFawCtU3g2g2s0A5mEnkwJdlQd5+h4oM+QIgdYMZWrVSDx6G4jYHpq5iC5zoefoKh+suiG6YkwE6funQypLqTNzgyFwqgotIyLqwFUBk4lEzQrxkJgTPeaX5rrZmifhxK9ifDbmYIBxgRvZulhz3FueXPxy8s1/ufzT8W4xpznX5+Pidp4+Yf1vnmI62mSVloTr0Di4alaB6aWZjqOGb8rxwWxHWxTz2ezs7GykoI5TlkGowISOgWgvX76ezacYoHQGBGSlwXSa7HYcZCF7UXaC9JBpjQvdlxAzANoz1KrK9ICpzwr0YveqGRTynCIlxBVp0J5/HW89OoiTgtKbOupJahL/OsTEeqO+odeFAJHQ8PiDvLxeNSVQ07j6XvH3pIRWUUwCCaBUPwnYhbrD3evRLKbJykd0fBzCU93uuZOF12QfxwwfY6gJXnuMeQ4JDy+3n1vg49rtJ1bqg+qw2VkPLNcHLau/avF4Qxz2XKfaxM16xfNFPbMu4Vvd1T2coFmXAwmb/b+Z4YFimroqPf3ib19c1kO1aVBQ0MhBD1ay/gNvhHmAzLx/GFmfMZSKR7/G+lkvOQW9cSjTV19/w2SAu1gAw/CuTxniT6Zv33wzXyy0BZBA/lL7qxA7nV6eP2ZAlgFaABa4yuAfG7PPwVfJhIFcHQksSKYRV0ZYx2+vXm+WSzA5UAzIpt2I8ABJObL10TcMye7O2SkyXc/T0ZpRkm/ym//R9kePzlgSUMynZ5P59pasr0evfv+r8eR2c7NIJy9n539pNLlJd49XydXF899N2TyGkqdf43OUZ58I3/E7QJdj7JzpAgCdFh7gUqKJDIN3vI8xQFAMEUZO+KSruWuQsynBtHi3XLazkKFSyaefBd2spSSzXQ5D1WrUwOcKygQjJewZPLK6+8hTKDYElH5AHwq0nDZiXfE4/DzI5UkordQeXJj8oR13n7D7Z5bs3vzqm8nofHHxOJ3upsmTZJFvpgifZ1tAPFM0o1n6JB1n+WYzHW9e5Y/ohaP1z7LxLpm8ZOEw2waNJ8xSqdeo36Ac+wekv7g8P3+U0rA6UgwB8t16s33+JHn+4rIoLvHqL7eoQiK6dJoul8tf/sVf8KRlvnIikl8ZMB+sv1xtWB7AzqJ0OvVedWFNI2XMV+TqlVZN6U49tEUBlYa6Zgas1dSw5eWsqqdBn/Z+8LdZy7tlEAsjivgMzwSl6+CkLDFxl8zx71r4zY0zethVt1dgRNEaGdK7yg0EDxMYMH78MAUdzsl38Yy7aKyfZrzrvzn+fX+9Hfzydgn6sPHRb6h317juHo7xBoUT6ZRd9T01vqVCpvSDN0NVqorWf18E3JK1OyquGVS1x458XtVhtB0svrvo76nYd1aYdZuW3OjB27El7Z1FfSeFNmvzve7Azeo8UMxhdwg6KjHkQSGCvBrQlMO8bAAc98ef/ujFX/3d33v8+DEu+fhJT8BbjO9P56yh/Af/8D/b7jZTbZ2OowVQCaQMIJrOZ+f4U1CSgL8tupTPdi7jwYsjmjUAFCCgRUFyxgbhEwZBMd/A8C2U47Pz+aPHl3IZ0oirDA15ibMTS7Zm3B6vIYwGCtaZTpzxOmFd5pJDwYBtm3Uyn/E9SL/+oz/+8g+/ShZXo92zdP7ybPHT9Oz1OPvsanz1N/7tx4/OqenWRFDBVnuMQJcS3I+whrqFzmUDmHmCvGUtvC4Pc4elCji8QjkOcEViKlLALCX7PMxTPhm/GlOxCyz3uVqiPLGe4M8hNghjoruiXF/KbrWB1gX2uumxbGTZlzpFd/kHf/Gr3//lqJhl02+K7Gk+WRXri/EtjUKzT0ec+5VtGXHHGji/nc1wN9O2PbQ2bUQn4pBMWyQANleraAaAixXo2nQqnc1n6jhWGS0kYBFKOmETWOF3OiCy0qvonghFl9rtykXh6qvyczNliZK5BMplPYlmveCnKmmxAjLgVFb1W/vqeJ4ya6u2TZpjN1faMaoPKt2b+oMS6aMwrRro6ly0YNflSf4l7qL5nsZ3aSNU55137KbeTdFB51oDcPJ1tFptHEsfxGbSve3XZh19NNdt+nvagk3mzRqEmODrFmI8EI801JJaH7v4tBIr8m46jGzWJufwhUQDwXJVyzfL6uXT5Dw8Jm67OFxyeGflDpfwBErHCnGG4XMCJ9a0RVfN0mNJmm0ap7aHQweJkvVtsbeD4LfFR1QWIYgGkBLSGu82OSDn2cXvLmYcRSu/bRJYf8mxW0Cr6RSohIrwpYAp8B4nHTw6gFU6Zwn+cggCnLP/Z3FJxvGYzRsZYn0k9D6+oiABOknDni5pltyQMx2fYTZk+RqQlY7nePqnoD+OhWJ7HwZz02R6Nn39Cq8MgBjxCMJ5r5THuuD89U3xLFmki3WGqWAeJkX+GAtkPvrRiL0ik7+Ev3a6+skoX0+LixmSoQEKyZ4wCq/hXVkoWyYZcENi0fJYnvTTUfYYOiLNJKGe8v0wFZZ6FBNpdNi1X1dQ0QvQGg+/m1BVWiiipHCUbYXpVj26AMbH5pEMmpPuUnm/Kmlq7MsusC8vDtVp4zTCxlENSdBJvTxPIV5ieLGShH5iVHrTgtwTdvGfTs6nyfn29WtMty3bgGYvGXwv8muG1TnGIMto0nSTs/MPO+2nt/nVLs+0O9D0KwPfWIRC71iA9C8YKlIX2wPh0nOdzPDUX2ScR6eelE/SaTKeIrbmCZALPshGfu6K1XJhn90Z7R5rHcH4Nb2RvLqrzelQGAKyDwknxfNkdEPJWgWgqsloJUXsTBlWVeM86AYHrvAGKPU5KGtJFL0fWt4twzlFfFQ1a8yjue//O94lc/xbdvJvbiR31cpRlAXLchtvb++3ngvCoAoP1Lnc77mr7oO4NiQfkmt474z1H7RBEQcyR32mLP1OUg2R/F40TTmHdW8qTt9rbfoDPUTC+aqtquNECc1gszGs84Xi+I1qZjoW420Vt9ixHO80PVTmnZbyXTH/YNS8V0Cs8PcgXlzcXoiHDlHKkIKcLCYekqtdWHT3HtTXXvZ9YvtrbFUSaK9fyibwIzxsAcbgf/aXfgOfZ8ZHzVV6KpA8SWazBS49gvqMzAN7hPQEvpgEIDPHsjJW6hyEyHAaEt4SmetTJQhui5mcvylPMMvRk80GCMTlk/Eu38pm0CoENnpBYspiZSgcwWI6mJXzobStJ0BxOd7eFNfb0fVGm7Xnt8sNd1AkpYL8JDTAnlHcZAHcLMZvbE9JhGQEFwE4UVEWBTDOTBohMDMJtJkmkBMLRpIy0iyQJuH1V2pQtbrvFXg0WyUkHZQhCbmkeF0hG9EHGdQq1tTWAEYbbiFTiBkeUF7+l2Ionxdb8bQnpZa9wzgrEstSd830jNJpMZ8XY9llgGl1Cpou45TfzWaro3q3Cf0CzM9CgbNiN5dDD4PzGp6Hq4775UEj9PiP4eKzy+SbTwzOaswucO1ETP+jQExSZrBK6aw3wgzNKAN9z1REt+QRa0/9QLMMkkhwP00pC34Q0GORXszYWorUan2wbBGpwPoG5VWfBD9e370G1OeGXd5FoC/7irWqZx3OZFhR3yVVV1264muyBuXU4r9fj1TW/9692KcozNqADJ6ndxegjpOAD9YUv/vKHS2hq/ZddlU/w+ZofY93YD+rkBpbuh7ZLCUQNwNUcOA3h7xdfmNNtneYN3BV1+ShdgPFc9lcki7rtkXOrqg2mxvaHg0gZ7O33G2EKfCpaaNL2Jb4DvmHU/bUtIXJ6VEN/q36g29QRlyGRVbaiXoIYJFxTcDYxeXjv/xX/9pm9WoyXRBHLC77yiDwpCH0EiHJrUIIGqzOsCzDpvZ9ANgByfDcAXi9Zexe4+haVnxLqskJ0gKeQYyFAKeF8dN+7WC+gtHedJqmbPACpGM7IsAguA+OuGUA96iS1hLkmxdZMhtPP2ciIJ08mU0fjdNVnrGGGKciphamuyTfjle4jnM6GcuCp4tb5iWyfD5ir0mAHqaHgTyzR5CB0RY2IJrqjKfdZ+BDNqGnUNkjGmLGf50KoIADhdpzrNeusDTXldYe7wA7/Vap1RnDzoW6t/EKsniiMKxH1YlLQmcG9xAoM5o8cdgi/Ka8Kt94CAb7A17xlm6HbKmN5SeDAOjWKq4VFSY2nzuheu60jzbT2WS7mYwrmKW7VIt0Nxs2+RnLmUdVGL/ZjtRt6FvqNDSMd7cJXviwZIB/Ygt/1UomtPoMKwFSupZEhYNaW45nJju9FQsSOSjSZTJFqfNyzBz9S7IjymZddm2rGNTYGWaAXo3Sa6xK7V41WvFl0bFlXk2zJaxMyzPk1jb3bpLZ2F9b6hCuD0Mz5HfQx+al2cOr8XY6TO59Cv2xl6o9sYkHrKfSKB3fv+g936yF541LatLEqXHYNeAxp/6eDtJeJHmTvhkTZPNKqSI2Wh/wT7OyIUst0KlM6CKp4lw98ojsPvMGntcL6yg9lsTDXoW4ys2e08x1Sozz7u0vUfF73K6XZrhwAYqeQvTgQFTC4Dzvh/Be1Xo/In7fSkGltHe4B/EH9MRA+8MJuB5+OPU5UpOe75MNctbTK/V4j4E5mE1oDUwEfAab77ZrVlhqCJRxWHzqbZwTaoFmGw3VEUtKAbuRplFQkJZBZCPVkDtc8fQhXkaC5RO8EtRiNJgckkyozvutA2wWgILkgP2OpoBxxW41SWfArG1WbLEqhM9UqErT7w0nj2W70e0mXWlX0ck80Q4tDCcXl4/PRptigjcJu8bjlKTpATIu8+K6GJ9rABjMKYAKSCQoQeXuoRFgZCdGm8zgk6KhZcmLNzmkukQubNl9ub73FP7cRr+naUvdx0FXMunmBfVBwQMoQxYvyaWpy1SWHaJdY3EOCnbdoBmP1yNBGp5LTWVaJULNr2OgU9ZqAP1lG5CEnUerZ2zixFkSsskmOoYLQyG/3GbnnPgGHFUnpHFyHSdHTyTMhBC8NVFgl7owl+adMBq1QkQdjLbimX9mPPCs8yYsyfuYGlLdUH/Iyr5V4jtFGNmasGAQhWKYe6JQ+GBysEeQdgFS9ciiP5irrtaVxPDu15GedXfG7y6nN/VD8VcjPNx1Erf+hjuJ1cPV4J1wetgmeycivkumJzXl+9NVXaz9LkD1nhnstpqWDtYU21vXCY5YYDUuxx6b3Joxx3gMTY8ts2at7+Md2CVBs5QuyjJ+sP3aMhIwOG+rDN5hap0j9KIQaM1bi2yRrUbxEI9DSolbfAh9z/gBGoh7Zhx+iNr08RgkeR+DI2kV/7iRFd59qnuVKia7T4gZH74ZFO+Xjz2k3wi7+D8geDJdL9ebzWZi46yC5uZZ4W9CsI75+QCH3GZw0AcWB+jvthsmCeScA2La7QpcvUHk6fRCG/zIsiBeSMngltA82EvYkUhBMCwD9gNlaBhWAnwpuUZTGALrgPuCe1olCqwj6yude0sJSb7ezrYbFn6+nk0v1xuVihDLmxGTBykCLGBwmbCn0TZjp9FkxB5AcyyNCQtPOS1KBsyMJQJFcTFOmASYs5ZmzFHCo6UdO4twmEK4FQHyhPgEKQNydK02/fsr7R7/jNvP9Vvm4UFtZ08QxXRqT4sxmpLeP0KM01RpJic78JSCV9HGxx+c3tkSdhhKVVUSl7UQlScCI0mtI2CteCeZmE6UUa1rg+6EsbfUKdTOihcrW7rN7Ap7SeXMsXAmg/bygXDNeo9kvMh3LCPnSLD5dnszylgIwiESWxaHALdB9Fp0wvg8Jh1D/LAUxjergFZx+G3rQyjH+yZdRRRa+MsEkrzGuJL8KXnw9acbk6SuZyvRbeZI1iV7D8FNnj8cPSdsT2acilQShmi2YzNZwgzPuRWLJKYPKqy5Gm1M5UpDjPLaj/BVMf4Z9LuPtqwPNfZ/rzcevneVWPE7uYrbf1KL2hW/f2pJD/LYNTsR8ECsWGrRlLAZ6TGhyjU5vcTmCHeXhu+jgVPzNumbMaE6QRUxzonVFSgfMNAjj0rpH7nvx0j9eXvrENc69JzeHPdI5EeUd4PeiAfXwZvhsFPyIjkgPf5Q77z15+McHpSiq/jQBftLi5unn/Jjqqu0qVjvUX7/8LVUk7/2OFz+Lm0M5/C9oqw1b+3xWFWMXDcBKL2iwFX48Y9Hn3zyKXCnBOz6Dc21chd0LKdo3GrkCQ0aZ5xWiFDDquA0NusEdIHW2beFIC5AxQ7f/M3N2fnFdA64tzFTR27+u2ywULAOqCb7gBJxDgcYbnc5mN02c2TXFbCahus1Yg8wK0/4oqEpYDx6uXv15XKe37xMJ28Xi9mPZ+Nvr9er4tHFYsSKgBlzB6Pp5eMLPIay9XJ3c1W8vd0t11PciRA7wa44yxOMAXYP3YzG84It6UcLfFHw/xkVW2YVxufJ9PxMzicICAZVBzO9mQB1DXv3kzIHX4E4BJyJ/WiUZVmJVqoTBdLWUuqpCC4GB1d49mpwDwGrYiCGkO5RXjICnM4EE6a3TkKyGNL4EBOldjTojxOXVEaj0bdQ96SYLC7nT5+saHKQPT+KuRaJ/8nq+mp3O9ux3RTzT6PR9nZM0yWP33B0Q4JDjtYJyATRhAyXngTIAfUFlqCkEtwvRqv1ZjZfYLtWFdaPLisLsEexMbAqAfM49IDwWR6AhbvesvBgO8Hdn/6MZcmyD0w+BN7t1uuVwL72EEoX52eLORvXFsWTJ8+fPWH3IMJU2Pq/6mfGlcQIai0V1vNxQFpmPY1DD/P3lkQtEPpDu4JIIdCU0CUPrRACTcofTExrHVsj+6tMlh7F9uf9mNqugUOF9u0CBGVLm1WxZpWOY6srDreXfUrs5GWdupV/JU6d+KTnuKz+cYiT2Abi2ILvGlcIxK0Bt6QP266V8GA0uqS4h/3qHGL541JdV63tEpN9gGGXeYg+S+F7dRhrIA6fUPH+EYiY0XDKONd9wzVV+eP+/eyjvwLXXI0RiKpwYSrhe/bbnwLw55Pf+NlPfqtINDOgN305TK+9c4BL69Xtcr20/VXcHwfclSySsw1LZ9m9UeezUhybOc4YU8csAFsnnBIstGTw2Twm2P9HY8SkSirJaxAKHMbWixcXj38slxDMAUaKgZDZmlOC87dLFgcwPi/kyDllGpPNV2n2979++1+/YpB+jbnw4mz2k2+fJqN//vOXP/mNy6fj6fZsOxkX691yO8ECycf/5P/zDzWaD9LbPdao9PRKmFWjLdoNRhaBFpMiEGAOCPtiVxSf/I3xz//2vzxKl9IWMktScmIfvTCtli2gD0sCDNYaRRlrVzx7UG8z9CEIWr3lLbmkZ4w5XFZ4eOoJZDYLdEAQ5/VwiCGgcHhWvvKhijdwDehFC8ub2+3rHafpaq5mR+u8GudntPvmmuTlZm3Q2nZtZQ35OKOZkuLsq9d/+mWWTNhfdr3DJsi/2W3+3y//8I+uksfj8/GIBeAURBmr6WzDvkAc4mUzCTI4NWVDH8h2jwXEP2FVrhaKyC4T+pcDECtCHj9xPE63JcL8g0jHKilev3q1XH3N9v9azJuzwD15+fLlt998PZtNmQGAVH5fnEyx2z16dPm//V//758+f8QZYdDjtCQ+9Ga6SrFbrpYq0a0OU6waydvIHg9uXfHk2WvZQ2h0H2VMMHq5Or+5luq3BuUd33jGzX9ZfGT03Y2Pdv1+IcKBcqJaEqyNXh8mDnpq/j72//p3/coP13BPTQdJ/KBEQbchELNvjYwJaj00TjoaPqKH5m9o7+/70eL6CagpF9V5F9gy/nLvnqug5nvgIAY5XCDRcp06A+C5PqR70C9Cea86qOAxUZvE9+l5x0r7/qUHbYSe44E4/vtXq48Sn6aB0Phxtuiroy9e6BExTZXR0CwJgrTC+oCdnF0xGTG13Q6JVi5jwR6O19c3ogQkFazaLF2uxxzclOCpDwgDJNmQsHIwJktmPCmy1Xo1m7F9P6CRmQTFskUPHjkMvpLHsRRF4ykkf/vp6MWPPmEoFqqco8HG0/NFunz75svPPwcAgv0ZlGUEV+aD4aWbbLVkxyJG64vpzerln+fLafLVbz6+2HHCFFUBlgKfOENgywkCk/XVLSKyxjTfbKUZHJVsYkOWiOmAUX/f5wWpxqMr5gnS3RxHFI1Ul29oahFUUsYRpTg9VZ8iKS+1QRWuPkMEkM/hfkVk+jayZj6VUlFXnJqfzruZW5Sh3Ga2thgvzzKVOVVBXGM0II9z1xf//A8+/8//4DJ9pG2Vco6Ke5WOL3b51SS/yDbLouDo5RU+VxzIy0pyHQJBaFes3iyZD1qp5hnHSi9vF7MdpzNcb1MmA5g/Ug+bMffC6LtBbrTLCg61vTxuyDU+O7vgMGkkUZ/BKFAWrQYAq9NufJKF/sScFFUmTZMHnP6w3TLyzyOUcusvcg4JBtyrMupRchISXZ5w0sWPfvrZ8xfPNuslO4XabJgmoOj2GLKabdD3orxLcWUPaNNhV1ypUE9ub62urG3xsIPJg173F+pu4sT1cBlqksQEdyvi1Fzvv8RTJRxOHzpeCHjeuI4erhEML+J7RBnXuil2f2qTvj1miB7rJbkBQM56Qv87/GDs36U5YnW1i9wdO9gmi2vt4bbadBdEirwRyqs5DkG90E0zvspx9NN15frVXh/289hQ91E2w7INHy04WmBTJyHG86ITqnH3+hyV4NeHYHBvP+LL+K40FrqrvltVH1N4XyBB+ra6SNxNhGDKEQjR8t8wrKyAsWbehGhA585HHvpC26B3rb5kraYtttSgo2B/zsguG+awT7+XLAgnmAVSl03AcD8AEG9vSSCG4DllBI4ttdMOHHikCJCltloEwNlpYsA/EB64LUu2maYcoMIVh21nLH0Hzsu3HPIkEUCMKit/onplPx3NfiOZJ7dLAF8y49hf+aMgQc5JtAzhag5h8lbko535cwu+6h+8WQysqoMDiXvDJjNJ+vNk/GhUfGt1xd+dWQFJorpaJn0CBe3ZlOjMZJ5YCjyJsbDddav29nEOinEKhQRXLas9+M3oJaGueqKT1O+HVKpTXMaeupcniVKJ80IuhLPqaPMd+cykV9vz23QyWybFJM9ux9l8OuOk5vN0spuyv1OCYhds0T/KZ1qymwP70Wsymk+vrpfrPFvtiht2bprmk2w1yWZ0MqB8aodzcci0IDq6U+sirtoD7E2AhQKYgSYNybIU6d+Yowrgi6YkZaDjZdsLMweuheppfc6wkDuZzvyiGhgUmoTiyAlZk6obdoGmnViEnKRA//XtOUuRq2pjIFAObaOqSyVlA5cN0qvHvbr3IdPt/rEM1WL5Ugy8ut5UzVHVAQyrN8kA0nuQ1EqRSqveTSAOUwiPJZLh7cTVVV9L7L81MUM8q9Cf926ptZrejcnRXK4fJ4tLRLGtVzzyjXrDFcKhCUJSCHhjhcejAacPmg9FHGSM2/RO/faA2+AH11Wzss2ZoibLIeg6bosmhzImVig/Vpw3rquhJyfj/uFfLnsQtVGVB6hBYN7Kq9miEVlr1nchY1TmAwVb6+WRoVYEvDIh8ECFf2TzAWogNHurbNYRBNxCqsWExyogxE+v8X4DDPUA9xI66kPICbBkdIyYJnK2Bn0JExds3UgMMA0kheuO4zCQNPkEzgTxdZffOCzZ14eBWi5BMQ3xCnM78tVYLE5EisBVAwpNSYD9NbQrIMk4MTymWq4gGejqwHTWDGQ4lGAxjJO318Xrzeg5UxZ4JcETqnTOND9/OWs6WeOJ4AA5ZhRY9gmaY4ko9WSMWRMMTBwQS001KlBk6W2WvgYhWB0kjUFSA4xSaQVES+WKwP7sC0jVZRuUl4cqdVex0afpek9cUaqUkmfVOlGmKFhlqKI8ozRsMfXkKDLwr7KqSLVtlcdanEqjMjOArJ5zrCptlkTLyHsGuw91CGFzKsN0gi+VVKpI3xAKeK0zv9SJNL2DktltFRS+WeTZea4ztrTbEpe6hPIJlmvsX4vo2JJJSbInyavmUgejjaQSqyH+RtrtSbNYMh1kMUAPBwVJ0PIVCcglI0/dmJ1lFakmFQsdPWGU6or0DU10SHqZH2TUH5KrnoTVA8JFggkSIk4PuKpjpqfzePAcqnvV9ZrMPbUZPyTGuoUIQ6AnPIThR5ouDdBMruRwb1J2tUKT8p4xLsw9mbyH7Pfp23cR76A8XkYdLkAi09vtwBNO5dGA9l/hw6vT/njHNpZ3qbheQ6ylQ9n7nrrqFdu13fmlwu7U9pQuzu5BWHp6fd2e90jsKW3RKnczshlzRIZ7J3eNQNyN8ZHecorGggAHPO/EIbA6LdBb1oFUxrcZ01actzA92Tszjx29WilAFuMRqBq0JYVz9fIqGgCecBPYWJ705Rb+gt5CUoAz3dg/R5v022Cq8FEFfYXj1zmnAiOAhk4Z5sFgYK+f81HGjiu4fBvKs0FcSk3yjZ/4hcwcI2CzBUwvsHDTdyndaFqgWJuzEpBPSB2QDj5ki8Y1Y7TF6NH40Sx9LmQ/AS9qQ89iPONQ4R1OQGxzBChFFDCoML4dMKbKAe/Z9oVM8k0Hi7myhPZwJSqeZgXf67TQOcGTUfaM9EpNEMroUY3lIM5rxYK60+iyeWovGudcZefTI6TwKjKUToziKgrn5XfRh2vPpUSigVOZPTyXZYiHcbVbVfIhZ83TWEXVlHi/f6Et8LNP0T711VHMtPiMuRXWT891Qhbn/YzJAAEAAElEQVQQ3cwo5nakThqaGZYdsy6TyUzdBDQNDAeds+MnvlegbfEHnuc3m9GtQW1kApCzR5M2m2LOR3DfxKDNaGvaDmtAjcJ4v/VpWg4bADMD7dvxE8Rq+kadiizTW5pBpiPrRThVml1ikYNmNztVh3rRhykCerIRqTF+Zcd1aDL6bLS9HCWcQEwOWZnWFnDHA03ExAT9S6ueHkfukztCzkBto/x276BUdO87pDNfPKoaEQ17w0QZLBh+ARH2bhwCR6+ua4BI58YIsffUEB/oCfjMdhxzt7Az94KGcGgVZkjGPpoTW3OItrsQEWJ4FWoVCePxgcD7GNs/cIUSuxS1b6moLiGXWFSXUzbvpNdEqnLca4Znz+TEEMKEyhIY0t96dH5a4ZQXdMHrqGsNQEx2UED5+jmI+w4fXE7uXKFed5DHmyRumFOZdOR10U5l9t3Tf1/l/u411ybBfbpmG7/3G9fatdsiW6tZ60miMTqgk9C+xlaFliwA5FMqLyZcJLiDa8FqAD5hwjHTlWB1vOVJ0QCtoS/IlRmMzZixsJVyYAHA1wIwEfB3/ipK8piZokFYUTIeLGtD4E2IEysAlrZOlwkGRTHh4CsW8O4QIaIK/26Kl6P0zdno8Xqkkwz4g1rCadDZXD40zqxdgNgrVFgOuYQRbQAYS4NUcKpOPp5iT6TpdTG+gUijwjJgVAuKEeAjxD92LZKwsm0wTsTM6yLK/Q8K4XApZ9tFhlqS8d/HEVLRtcvMFUvy/CpeZVfcCO85K0FaqtKd0CqjKKuaAsaEFrRIq65jbiNQy+G5M0rwwxrhhMXBWOIACGdnH6nDOFnnYY7IWgZEgQLRT4b5N2EhgDrFWNbWLj/brHHNWkmn2nWHomls7R8kQ00aRwrcc9CwpKHh1CuIg5opG5tlIEXto/aVh4+6meppWeFCN9PqAMUJ6BOtjseNJqNXkI8w9dEnT2whizAcIqf6k6LqqHNLD8poYoSbJJEw1g7EWskhtSew56MS7HJe1dMH8hmkCzLeX7CgpFqNa49xQTUx4qR3F/5OCn131YFzTcO1x1rR3kz7jlpLHtDZe/J+mLr9bqSqlzrZW2DlC6VqinZ/tR41N9qsjOgYGyhTI6uui0FXfLACvVIuOMSltXRXznAbUsshdpt9C5BoCL99LWOLeR8LFztz9162YNwWd9VPLFJrOLQLqXG4lXhP89LSYwk7MhzRwPB6GeURbgPkaY6ZHfAcwqGjpmX08Br1lnUglbFuxsSC2H7/8QoWEuvvj5j+IOyE4ZsZ0gRt9HXwr4TAjD/r0/Y45/v7EngF3BV0N5wvZAcQ57hWOYZgDRABOhMCM68P2QmGouZAdJaEjpKlbwyvAVRhLDMHeDCMzwOwMhnNQFrGCXk00Cp8yTfMPDmMMR5BjIcyRjyxLSD9eCiNJGdyBcen5Ply84gjZbfZkzR5m+5+lM1fjfIfjZNXefZoN77OcFAfrabUBfEE//AMYpMf4UKqr39YHhQuVyNMgCejEUtUOfmVRaDPpRgBPWghAUNapdOvcEIqts+1dpkTfDW18Bmq2CvU9R3UW2odXXtC+R4S46oFSpKqPXgUShUBJVaXUDAJEnmUfiMIqtUCziSiCuSCuZhE9o3OnhtLJ3cKspCX1rVLMF4xhoo5JflTA9CUJXtKYQb12RM2Z95FIvnqXYbvd/kqmZ7JYto9Gs9eT9InRXLFAdNpukxHl0VxU+S2T2ey2G7fTkfzUbrKklU64jAHN6C4ywArtp9QSjp/SV8yTC+lIxHdRZ1N7loI+wTDYjzDQuMECbyPUCEdlHwEpK1qlTC+XzosjvXctJHaHAtQLDhxAi8mVgZLt3JXcyWTf3I9Tre0obgQzX8V79pXdRWju33qAwuhdhnBwW7fMYEcm8ycJlIFHLt63yHHMtfT+98wderqOc4Vh6v06HPAuzFokWzN31ZTbcTwWHDIL9oxHkr3+XxHWUdksDrecea/vzUb2jui7SEVi2i8XlX/9V5syZFUw0t0/OPsm7nUyaOiPdga2aDqjIjbOg43M/SnNumPtLhnaLROk4/FHGFmPw963+gKjWFPNgMQsnsgvjuR6zWQlTk/rI96vU6XLtSv2Y16mIVcHTQuV6AKgQ7yY9EfclN8yLId0+vH9LtpwLt3d95a94cQCGQ/BIZyeNY3Qm8o+2ZwUy8CDTNKCihi7az2/Bc44sYC3AwnDzyzlWp++QDN8E7DdQccDeiCmXwpYCDAONqxx6IGXY0S7xuK4JhYWW0MDjOjoOFc3o6Jzo0CfBEUMoeMsXhowKU4cQDicBcxpxCzJxjYv51e/YPbX/63mzc7sHv6zVn+xSh9eV589nS2vBg/OZ9vP5s8+mxxcTE/IzcD/ueMPidYHfAstqz5RATcWeBtZxDv2AsovdWpBjbyLCklPJ9aQGDrXHkGoSKppipMbMybCjfyLNGrS/KrxlzVJ8EqwuL9ZoTlc5QcsVI2w/4mjywRo+PJPpUUAhZnj7pZtPFGagPveiC/JyiOxjU/GsL61HpZqgStWl2pLJBIJmz7erPasKpitdu8WrIQY7W8ytej6+Xs/Nvdy0nxJEnezJPno8nNOHs00+FrZ2y68/btbpNvRtvp8vYaLX+1Tlfjecbqao3oj1n0PRlzVLDOlaBErQLhw7uJ5pdofmAKHURWAUncsAV5wtWIzsAqctWFPqFaaFZHG1sVo9vl7Vdffr5Zs6+UIjEMIGM/0BWLfVecErelJ5krEYdQbBeXrAzYzuU5xnyGCpPSxM+vSoGm6ypSxVa69UBFVubq/Ih6QifNDy2hqRtiUFukzXdbZS/u3ZbxAXMPXbVfxmYz9dM3U1sb1CP9fv8imoV+GDEDdWzCxlpQPj8J2DUEQVCV8/S7d+FAc/9Kx5ZNZAueytitwCCXC7tncjrnwGrP5DAUfBP30XFd9rFl6FS7sMHgICIeM7gX516ZKfKoHg7EOnyo5W1a6ofkehpCE+eK6x6HS5rh7T6cMi6+GT6VzzH910sYwL9FD3UuB7MxQ+gn33pj+n3/5ojy7iMpLYqvyg7pcbcA3zgEDIxFxv/CRpe1kf8YT/sZe7SDuswvWqsoR8lqs9u9eg0gw0F/zjg5+MzHWQHNrMzd5G+ub5dZzsGuQCntHkr6bLH4nd/5rdmEJaQSSkPTUDPgCmsVKhkYZxZ4Zqee6ePRbAav7W6dbdnbk0N9081q9fbVyyRbuf+PphPIJVfz51+Ps7/YXhQJW7o/noyXxXYxGr+dgv2yl+Ni85fn6b/6Ik+/uZnOtEXNfPZmolOinvIF49wyik0nb9jSaL2cpdnkcjX/7z/67Wz3J+N8UqR/WozORqNHxebReLrJRovx/I/H+XyU/QbHJ6CHbHQhG4gjESQ1TucGHKmJhocln2mTclzDSoiu0CgE1BbhCx9RG+Ivk9DNPmW8fbF/Pwis+pwAZ1p9YqVSjvbuiYpTMH6mPFktykrrspkOrTnVzM2YNgUsA683HJbMIo0E9x8mSdjEab3E3wdHHuB0MX17u12s8+t1Mf6nV7/8D3/F5MAVcwTJaMlQ+mj0hg23x8UMapZ2bHHHx4LS3MGKZdnp7PyCA7coQSbgbIJLkTaWvWKnWE3RsPKbDxl4LiCHRGCqadh+zMkDtCEKF8jHLp2C7N+8fs12n/Q0FIRtoL7FgH+2Xa+X7GMrFiwIlkFKX+Ez+Tf/x//mb/38twrz90Eq+ufZ2dliNiULMlImWlL3jJuk1ByRbkOhIC5pzwLcqsDkW4sRjyrJI9TPq6sirp47P1u+y5209YQ4bxyu0z3I87F3Y6wPKaZ698YqJDom65fr1F+rLpXHHhZDSj+13GYtWtrCtNcS38zcFVPpsysdPXfxj+OHaKCrCI+vNWiTuL2IXvljncfhJvP+1Cb9oJiob8e6GpQ3Ispe6J3Q8n5AI7YIuPo9Jo++InaFAET76+BhH/0QocA6lHwHrjC5c3bPG8QYUnoo7s6FDinloWhC1VzaIHzgHwhCzH0CTf734fYDyYvqH1bL70kvrR28NbJDIEdUVaIAouWu9GEGQXkDDGmMVCSAfjbE1D95V7Pek0Odbjas/mTcmFF1fs5BchqEBZZljwoOgE22QCmgpdAlzLV/z3a73uAaBBFYkgR50QtPOXpVgwD9gGOb3Xo6TS4uz3fb3ZxFuvLwJnuxXry5uR7PZ5fpOSDNuO6KzXbD7ARGSL4CrbIzkXYUFSsdIqtCtulqPeawWbxTcBZhv/kJZZOdBasFZx+QGTNhkl6v1l/frvBuefrP/uOffnLGSQTjYjFe/OLbl7vV9fni7NNs8nY8fjR/9OdJzk6XL8bZ5Wh8nVw+fvHzzwRktYhLtXHNlsi7eqrU3fiUbp026o2ey1rGYx3GWwQc/NNTKob+pHv1X+0KZ4OxEuyAUrGUwgi8llmomcz1hYBG3LN1/tV//Y+KV5vd9qpgvS8bd+7YO3OUb9jR/9vH09lot1kU5xcMlu9gM51mi8frzTR7swTeM/ejsjjFC1b49dPcthpElWKyRV2Lhdiz6fT88bkWC8tg4CRfyqeJNUL/2z/7y2dzdAuhwLimnuT3T08U9CaMxcicAK7/ZlpqKmZ5i7nJcl7VhEW+GYaBZhbUmWgasyhYfqCexur1zW7z2Wef/Qt/41/cLJn98Q2mBD6226X6tjRgVoKMDxTDxU3S+xUU6aquosMnlAf0SojyBDrj2Z4Q0fyAgkGFsYZCZKhoMyYkfQy8Bw0M1L/33IHEQWzof526fKh3FAj1N91FaozXAEAfUng380oiwq2QkJ8XiMfH4wpRQYOCkWWjIqo8PsJdPh3SVCT1z5C3ntBtdzYpPWZIL6l5EEqZvXJOvjZ9dxXZiG+ZYYho4jGDpsXZYyPWtBT70vmIiMe4rDXiqPyhwaAlWJ1W/2ElxHWPw8Nyf3dUrgvu3mf081+F7y3UED3ENHG4s/CO73hX3q54edHQERhaVYcwLbgq5PQRIRINRAgUMpacbaZTNujUE9KBqkU2zjgILMUfRO8M3kIcBgwDABNO8BRxO07ODGECyYTP5HltyEyDsMlKDMZnsISGaHfIJh/+RoztAghZZAzC267x1gGKqRANOGOFbFltMMNX/GyxYMSX3T2ZTphO2JtylG1tFSc+OWQw4IbAAuVFPt0+YpQ43SAYGJH5B8yWRwBDveRYXIzpwvlgq3MOOluuX2/GxTf/dPmHq3/+9CKbzBZFfvFPf/FHu1Hy6aebPGOM+c2cEW3WCoy/SsffYBztHl09+9lns/R8NLpmw3qWEIBuMSjK6qtBTXWIaIrjwQLlu1bGj3Qk1Tkhj2XrCEczhK/EykTwNhIHayEBfHsgu9HgnWz0poCysUWrkSddrhkjJpZ/tAeuPizW5UxfnLYWCZM2k/nm+vXX/8U/ueQQaDUJ7aE132oc/mO6bS9Go/k2f0lVaZcNG/8kN9e7twn7J40wCGZqWKxC9l+lBJ0El8rXXguFhcIx59A4TUrhTCe5AJzeQAVsS57xo4vn5xcXPpBvUgL0qQSTANoZVoYABzzQ08iA0rweoqAs+QjJXORAAHhJuXaAGb0SO0JLVliiLnsiy3fr5XazwhxlukDCaLZBM1x4F73QjFXyjb4B3ulFIeWpLPsWHIZVstJ1GY2f+aBxPmt1T1Fi7fc65AoUbYHmd7nn96XGIM4bh2tk7/9Riol+rw/1NEAcNXd1RXyqqJbPVmXHOCf8podGbuEyrKyWjIdRXW3RFT+oxQfI1sW/Fl/TlWsp6OewKi2zCi5twB41eh7bm3uA/E1WDxzj/apXkpquThKgfhIwqnBd8PLXAFKsmBAOgVqznFTyMeJ3wbvvi3RMnpPSg4ZCLmIepEZH+Qyv43DKUIuHDbgA37kYD1upO3L7NdaCYUO9ag6+NSiEq8Q7ClkEtwnoa8LQKZtysmRTdoCy6o/wBBgGWNJoPkPwxMhvA1h3UexmApZCYPzTyCtgSiaAgvbOsxvcGPGlOACXhqDlpg0K09ix3L61qBZgZqXJdACo4b+xBsTj2wHS25A714g+G39uhDCF/txrRGaJwzYwIah0tN3pPC+cWtKt4KDKwgFFqHuKCziwVRsG4WainSzX18n6djzH8wcYyRY1LGjewo5haiZBWPpgKhQOHY82OnBse1Oca9tLREUGnFdKTUqHpkc+LaAHqV2QU3FWJdlN/iidBHoPGaFFW9sotWokKcZSdCuzEQyXFK8H3SrOFjZyNYSR0jRa4EvNsm3GWb24M9Hay2y3Xu/ydT5max5OV0at7LWD9xe4m6MW+Nyw/Q9aZCB+lDL6P8rPst2ShdEozWsHOleLS1uC5rQvCla7aCpBImG9YA2YdaO6eN+YJBM2EkUUSjFDVb7+SKz+YPhZh3MpQv+pNiLQa7AGaVBzS9JPKb0CMXf8y3ACc91QkhRhmThj7kwGhp7pL3zi8s9Oo2IJhbY2lbmiMrg8vwXjm4js2aniJA87QVdqk/5jzIehgY8t5j33wVvj10Cxp1TRaMtXiF7qzTUAzo3XJ+9LLh4P30VlfKOhBtmLUa5DrkqIrb0jdTKbKaaPGJfB4TZT03bsH4lvlnW3GMqlmrHN6mGve0Px+0JaldNa31ZKGAXlo8NAEyL3Jd07VI529Fq3Pgtxx10OeiU86JMD7OwD+l7OnhjTx+F61qDiOKFfJxFlzDkORyQfdPDwjUEvq6vDo3TXstyCcVCWVI6ZAbBBXIZG9TICuCnA1B7GgUZicb1mcFd4DVgM8F/hrm+u847/GcZmixjGjpWVE6D0thMPeDP4Lmi/05btPtSNez82gCYBUpaE4pBOktAhw7rYIovJ9LzI8OfBJySfatB2wYh7UbChJCgWrCcrAMmBm+KcsYJhjpWRjhY6DCzfscnLbMzhAGTSImT8mJJCK3+h3+42zDBgIoyyS3xDkpvV2fQ8T1eb7GpbnFEz2IFJeVFTDjVh/JsdLFXxDAuBqQTqTr2kIds5nkMGXktb2QtALgoEl1LH6jVOZsfgIGO0x39wrcoGahdjxsWZVNHwuzhgXdnGo9pgSXhVjWaD38KuojfOihfOJtWihWUVJl6InDhd3uA8SFUmLVFUCleus5SVHgyTA51vk+XNMk0WnPq12+qlwCIJ7CgpLS+2+c06X61zTgLeTtjQh0UaxWo1usKVx0qmyfikZZH6uQqevgGd+/i3PHk4bavYso5C3kfwZoYBzaEt9aWdugVNKPT/CMHTlN1+JCg1o6dROy61c/YEqtHkGo3m60esCSjGbOvEF9m8y0Q33m2e5xtk/0Kg3xm4O9tok7ICXNwwSJCBxjTBTXXj9KVpSWKUmlSiXQhihOWjPnzFBYbyt06hezn2Ty7oo0uHZiiqYhclDQpWWXU2xV15DCroOyUa9F498Y0d/7LHlWvFLY12i3N0hONftDjcQX5qdIwoBunn1AJ66Vu15DnQVSybR6Ltw45fcnfFlknvQEvNSnTqqqv0jn7VyeegSP9+qn6d+4DF9KYOz4O+bAaA5FI9jQDU/JXXPlTFfKCfVsd3K1tQWLOYUrnNhEZMK5MQ2aPuh6pgTxENYR8g4qHEfgBR3j+LuPLDu8j7l/Ndlhj6dq0Qi3fkyBApYAzINGd4W/iW3drBrGQQqBOYl1uIwBoe2hqX1XiuFnqO2I8zl++NPFiEc9W58QERohJyJh4uhpYFFRUNkhWqE3OigPX4pBAEogGFgcEkA4UBiuxCj4EAQ+yBCRgc1D6azoCeOh0Mpg6AcQIH1su3HDchRve3+VizBexAn7EYgPypb/6vsuCglajjdAbczHazXXaecWIxTk5YH9tpwhFj57imMzAOvlVNhTEBxKoJOHS8ux1tMHi0KMEqoN5lPUwA2AOmNNMCaUHhFgGBEYlWGYDJMhcU4qLaJX0Z5fGqqBMIvAqfk5UkwhpVLzMbA0+oiCndU+GgHGWRWFlS+5b2HI8XlL9dLeXEhG8WC31lVNiYOviaU7tA1shoEyYs39WTUPRFttuk+Y3csNCOzBxUS4cgiew0DSH96MrWUrJK9vLNp5+1AnISw8zASqM1ktSWchBFN6GLyUi0y1RJCBLsAZtuEo3rFaY+cSTbgJXHKoLjKkr8YtaU1Ilhk47mno1eaeqSxFIgGRBY2qluCthVRonDgMuoVcU9fRU1IHcLifPZc/MqG6EzbsnzMeqjBk7TwPCuFPfEWhkk9fAhqSdvjdX37bGqWU/9Q5WMtiTUR8dJwIG+VNsA1k2bbM+kERrAr5Enjuiwmfr9xmIGcbgpeZftHnIhf6X1EKdAa+QBRfTQWkoP566kiOUdg7HYw3U4xEKNZxg6hbPWbLZCJ/3ghAOeHX0mZnZA7wldVrulxvRxeM8TzXpfj1XsMXuiI6GYcxw+ku37kwxeAdJZ9waiacd0tFUs8mw2lt81KBxEzp0R2x0ONCKUUcBcgY3PgqAYWOdgLgA3UNIYaSPQhKFl8DfHx5qTiFpAw+lc8r3hpCgWgVIsrv84mCh2rddhxr40bPOCx/Z6hGM5+Ay7YsunvFBAoWBloCuLf3fy7sb1BunldgL2Yw5TAVYaaGue3Zvx5IvNaredc64xLivTfDXenU0mb0bF+TRZT8eXbBy02c6uWdCaPvrFm+vp56+fXIyfnT9J0i90+MCkYMUznMbsVDOiLhrtR0qKlAgFJ4g93W6vNEaNfsydRq5AxSequ/An8pAmlAnEJiMwWZqTJrlPOG9YA/nZ06RgZQJhzl54hvoFlzVOropxRzGG4FVNlIVTkg0bEYYhKaXNpAJEqT9ClKEC93GErXTNY0CkuWfzuZoA4mmmaXK2W13d3GzwgSqKZ7vJ1Xz06Xr3bTJ6mo+usAd3BQtuz5PiNhmd5/n1OD9jzx/mfLCJ8KnHZMBpR0ssKD95iamkDe5UERvJV5dBFInKJ20kAcD40gt/zD/s2NtTbZ1cK150CCVD1CrBXSC9GDOrgJmH9tDx62L8ymw/Og//zFqAXfoyXbwt2MEIPyE6HE1TTJm1YGZrhrUnlUlzsgHkaSZVUR5Sqhll60pCCYnEXPbkUR5hd1rg2+iR9PgqsxK1D8XpZZjmIL3nrahiJW1LXo9qyNVJ2ZFw5BckevceoTT+Jc1Le+ipV5swD/tebf1lbyv2fnFxHePw/bi25n5Y/dSKCP3onp4X/j1o7a+e1NfbazLFj9YPh3sodOrqxDbq5BPLpjA1Vv0G0Zt29MaxL/cAAyBWZ2iougTfwXMsV2vxELi8Zdu3EpnyOlL6ons4HxWsi28sp/OPKe/MFibO+T4cYkk+hk/QgCvd76GBP7bHoQaFi3QZPip2O9wzxp/9+NPPv/pCg+aAf7zw2acRbxU86CdTfK8FhcFKAD99CKslCTtsLnhkmNYgFq84PD0AezBkGS8IzRCZoGmWMpauDVi0dwuLTQH2apJxNp2mqdYeA3yA2WmBJwrj/7slp4wBGomFDp9vyAFveb7VWoUptoRNMWijUiFD9pVn8J7Cv803v7+5GmXs3nOjQ76y2+noMtnejvKbGQ5Lu+tpgtf72e10/ZhVD6Pl7ld/fDHdfHL+ydnZ5PHlk9FmfXW7TSacFDBRaaBDZhdyCmSCIf3Ff/X7281uOgePT6dnSTKfMzKtwW/Nn+BbLxExALBkKgyHkiWe3v1Ol+mwXKZRVHlOSiCPjlwG80Fp+F7KVabqDSIHFU2KKEpKFqKW5UN+Ee4v4WYx0ptHRosALrlsmNueNLjOUD47eDIHgqWHLTdmSe+vrtcvs+t1yjKArxej9XhydZayPnj7ZpPerK9Wa5aAb5Ls5mp1s8oZrT//dpNik9kAvLz3JQ1AG9cc3IQYzqdU6yJC5+gBy4YlHNvNeIdppH6A0xZj/XQLKrFj09cMG4PlIfIOsuoUV1dXbCKlelkPpTZy8FJGOI+url5DTxF4/StehqFWB7CMGSbSoSpMOeSjwMUkvUQXplxyYwLIXEFP0p4ITIP2rBL9srjqgc/6c9U0YmJkBwTGNsp9EDygPEjZPxy0alWEJ3txvSXs+XwMDdBAaMMBtB8iyZ3lH9QTT6nxx17ZqS372rrC9Uo+MgPgX3KYeY6ooYZY5J1CDEgoRWxQhnJb29jnXYMdGaQO9ajxg6CVj5P1jIV7xhq3MlelrdbUOLLG36WFIBapS/KYzx3CXkQr83LuegDTQRZnpI3QLpQb2nFAOYNJohGjOE9XWc34Zkz/mEGTvh4TFB1aN5ZsYDiqV53/QA79ZIA5mglMVl39pQzyNaxY8Rno7VsTdToNhwoelfEl2kiKT4H7//rf+df/9r/6t+VvIUzFoUkyAJgc+MWv/vA//H/9R9MZGN53wARDCfrl2dXyFhAGqMJ9X97jSf6boMFV8vbPN9cGqxhUByyCiaezOf5CYE7hxSnYGynGIzaBuXzx4pykGWfHrsFzOQO5bLkzPZ+eP2GcmIxUhuNc2b4H8IuHz3gy086jYEQAH3sIAZtThnzZGBSVTsCAL4tZjo3BagQk3C3YSqjYzfHQZ0gbUyJliiPbno0X0zxZb6ccAnw+WWTb0dnj+eVsgecRCmJUWxhyBN4FxfLCzpJ8Dmr+5h9/+c0/+5pWm2L5TGZTxC7Y6UgLXMeM0QO4GWbe/QigO55+LugtGCqGxGiwmSCx8r+Bq6fKaHD8afmZVaBQKgEaRsOTcfYJxRfTX2m2gTZlpx44U2FrajWeMgONmQfhHNyp3HQ0X4JdNNXJW+BjNmlNZkn2YsLcyuxXaXox2j1O8OKZfLXabL/8/Ksvd9k//OfLX45erQtWUbwsEtZeo0ztF8RMCLYVnMfFLQpkpL0oXjMJI8tvOsWiwTtrynEPLOFgLoOWltXI2LyQOqKhRtyuzi8uf/YbPzXbQL5UEopUrcMdzee4HWnGhI5BPbAwAfevX71crVmjrHeyuqp7+5DTJi826zXHe/FEHVlCTOXJSsPLyJLjErJRCtwoZsqR0igeM0TKB/3TFnJ40qyImsa+I4WN66sgU2n1wadJEJ49tbyXtGWm7IWebT3Ans8BfXg4cTwy5DsIhNIPYqOH6N0VxZbBI78gkYRHKGPWUa44uj/c/8Yr8/bWpZ//Q6UOkvOhCovq21Ou903KpMOddkX8PaPPnASccBq3ijqIEQJVijku8nCnHnJCD9yXd69Qj85b+fr4Svw73kJmX1h/J+oXoWkAhOZU5trXmwy1mJYS3lPUSYJ4pcI9FvEkPnHGBw/H2o3DD1WQmju6ao9RyrsNflflvttadXH37hXfvf4fTrc7/uJGYsSt2u3wqavezfgqf8SqIhJLQ1j2egGD8QzAB5FryJWhb1JxoZ+w4jb9/KtfbNa3HBS1wcmeFaICUroYAAaPaWQ5ZXPHOeg9zR9dXi5mbO24MecQDQYLowMNE/bvYTd+5hey3TiZaw2xcjLDkJxf4GeSZhw5rCNiKX6U/viT7LcBctq7nfUGDBBrQoAx+8lotVz+8z/4Z+wBqjmBIl/hxc4JAKzrxfFfKFCCaajcMOVEAJOytbBU1WVAWlXFX2ezZgCZmQdLyPEeYrkqG6EyvSAG0hIyg1OZrNBKVj6pNFvhAIzlS7Ip1sVmya8aHlDGRApU6aMtVgEOPq8QQUlWqPEjiC2iYXiNkkvtFja4zNSI/GfYWV+qAqQyTg63lG34FT//AgRb7NakjmdfKqziZDJITIWgx+/FHKI0A0G5FqN4LJ9ZsXvJWQfF5M+S4nI8foIJU0y/Zl9PFkbPd/nbdXGdgsUxvXZbzslliUSxTnTuGzqnVnBAnTqcSys2ML+wZNLJ/GzBoVrzKU3G8V7JYnG23Wyvb24MfeNUpvbd7WZnl5dPnj7VvA/zStavBMFRMSqQIsDlVhEQunpKPptrd1G0LbVKiX7JQiAKgs0WU1CtOklm6oJYnPQGTbCowehr0BhXLJizHF8yqZpLDLlbs9ijIrkUoRSuqjCCtJsEU54o1qhqN0t2ymOktZx3fCyFPSrYHdl/v7IdaZzvV2XapPWeFap5vD+2MXnXcS6kyxa657su9Lvgfyf1m0a8Be2l4msAXGdWiVJlIaYsxbPsq9m0h061V/a8ekNBEKcK5fbUvtUDzyvAfbh92RwLD3lLLXVI3iNbnKPGP6g4BCD2cH9xMc8POUy7uGa4h3Z8SIE7LPuusprxzZh+8Zr09ZhQ4dCoBE5tzqhedf4nzaUInxnUO6xVc8xgX0osf4VO9qmHfLqefB/ilkob8ixzuVogsjMLhVUNWQr4+JAqm+fsJjjTT2bz+eP5HNzGAJKhaIOtuHLIp19AdgEPZE0n384vLyaTC0Z4tZskUJ75Afz7gZD8sZ8OIA1KPrUOlSfOhdK4NaEknctMwH0bK0GHQhmp/OPNUtCJBIBU4O0cM+HsguF8EnaXjy75XC3zN2++YdbCayaITC2sNiwJVqFYEnjpEGDpKQg0m2lEOE932stousvxccJKmIKcmaCQfOo71BRhmRTAvQebQTulytYBIsNCFgbnH8PTRqKh16h2Ppp9a3vOMHFB1h+JyeQrw540OapmZyGxFeYE2TvEVXihsWzb9t5GiFxB7Mj6BvyNSrAKRtNX0HguOczIBpADjCFVHKCoiA5t0PJdebuzIdIMX/8Zm/1nrH6+yovX89EjrakoXhueZ9d+tvjc3LIqAs/+8XoyeoRzDkYcw3VYMCpR5aJk057aT4PtrM+gZaBB+ZQlk0BzAawHoC9oSF6XZnJkjmF6kT9bcXIzLfcGxTqO96bhgC8gvxZsSx2G4NEXFSIjf/lTCh+nV+qYGkEUjWalRMjlGnD5KFZuV8SqWELZM2aw6DCsUxctWUnkjuTWKxRpY/88K13P9csZetspbb/rf0lZ5kq/refE7tIVvUNKiq74MtkEUS0GXK0ie75muQP4OcmpiOLU91IsyKC8HXXpqr2jhclLlVP7rY+LDmF6r66OUpxsiJyn6s05t9wjSSjXqxkqW8NCxA/sLPuCjH9gGOKb+O1kzh3fogPdDtB2KVKkh5Zv03A+oYbDAkPaOubU/B23F01MUupFr2uCursBECm4bMgQo/ZptpHyv4crFFxKFRUZkqK4703QtfsDq1S/9kN7hZ7l9B5fi+xn9X1K9eqFysd1fv/VQIxTFX0g+amZVUPyHPBoq7UIKt5CbZZBSM+hksEeJxFazbfZbbFhsFdD5IA2HL4B93LmBn5WoA9kjF+NtvVna50dSD1llB68KLwLXzlta8tP0CmlAcd5BAjaDjR6LzLILptAy2lFbiiWEFAYGniAXIHgbOCPh7rOigJvzmaz7TbTrv1F9vaK3IBUmFACRQLodckfRkPimjGAjQoRZGbkWNuDMlpOPJYLtsxOQNnmCiSF9sznogYw1Q8OjMyWkDM6pkM6lyZ2nHUFkiYZTcjPB3xqPGRCmE6V0xoEZmJissHBlE/JklnVq4iJMQEhl34lg/SlOkDHJ8nSuz51kWgxKFAuOkLrClJ/narmP1CwStE/zvNwwr7S1EuOFhOkZ0XANLnEHMPu4R+D5zbZQVnSPJVSnaRK+ErDjOXTB6BhI38iCOMkxiwAH+gQM4B2Fhdll3pNTlRnZgRcqCrmCy5d1qriqxrwaUFTII1PnO7UV3xIRzJ6AWyYKlE8UazRUFtCYuogUv1ERiyEik05AYIDo6mt6NUHymJUJpe0qf9V2FMP76q1EZuQHqooKJ0rsKii/fOQ9DCt8VRJoQSV2CBoRgQaE6KZ/oOMGaibH0zdvZGbLewx3mtCRxhea8/YRX83hnC7Q8YuGT7g+NNrWeVQ71XLlScBj4O1URIo3SrO3VuYpxBoU0ng0JZ4GKfXe3l1WcbBvoTOi/W7ixOyV2w6P5vWcNO+7MzcSAh5EcZlaPIPmVzU8OiBIHng4AGvXVzrWkY9xrZmHG4hvUuUj0B0tchdODbyeDWDEkiPw4E81mocDgTfv8A7aC9XwtDvHYqORzIGapBc3mZO39paFavg69+k7c2nTqCXUUlkeNTwlsEdMJSBLgCfENxifjmdnjOYyx/IESil8X32ghGoBnVl0wlLRfEXYtgYjsAwLeRFIseuxAAXVQT/hOG0KmCX34q4eMwYMv8MAmp0nG8cCHI8ekT2IlmSJj4gRraphEijv/idM14OZN+wvxDrCciiRQhy8b/G3QUK0C8OJwVe4HixawsdXy261VizcP0chDhmg8hcp0fhSc76BTalxP8+zx6B9rPxS+FL/qSfMJiNxxAjymiNFFxr2GaGVGwhgWxsHhsOd4/zsvmKyRemYcOy9AQpnFFzdKocml1QlQRQbbQSTcMQFfPMsLo2vwHk2oA7IcSQ85U5MaFdTUCgGQ62Bd6qTuhSlsxolrDggSO2iiluPrN0tV3REhx+IB8f9IdXzg6rZjtJ5mYRcGDCKklu2ZkI/yxaTmxQsmZaZEWAmVUlAX0kQp84ArF3D6ifeRgWcwD+meMRzjfB5MQvk4auwpnEVCV5Q22L9I1ak/9cqqQ6Ac/b9QV1HqVXekAZguiG4fWovGTi03oaTQxnFSyl0QZiJ+MEUvIw+2KOZm530IYvccYaT5ej5Nsi/4l6i1pcdSCbScJNCtR/fVhTe7iMcwJ9EywX9f5WWdX+xqAkJuIgs0XTXq1XV7xJsfcn5tGK2H0mLjoNoOsqxe9KPjk+frOd+itwKv2pwnldK9205w5ooT3ZYsuGdYpGi9ytFvfRW4+otcrWardv/BN/6fYZD8seMh8S5zhZVw1tx9w6w81czZjOzA+Y4F97b5PDV0B4j1SlabaQN8Y39uzq1ivOT2rnF8v74EFq+Z1XXNw+EaWRfwc3FycW6jsQwopEhgPFR3J0CRnTh/BRpQbKqITvcbBZHVdXM/57XMlW0b/bGt7lOyNU2FqVkyKpN1z6ag+OiQhE7xjISxeUtNyKnM1Y9AoqBfPi7sIwspKAbkB/XmkGGjfyotcm75PijLxgbtjL/UPTBBpFF6B0lpakwWzBMQNw5NTIcllvE0yYGHgH/MLqUD6hVziWW8UIJmpXIfNUYUcYkCiTExs2gpSLiwaqZTOohuB6yoWSsX9tuyPMrMoyTK2lrkxUYChsR7MVsrKUgGihac1NQAcLd1ORNILtGgqn6FI4DcNLDCuItREqWGysIkZmNRZeNHVyswhokJCgqsc/S9WHOIvEElCj3Fr4MIGtX5Bufzi9a4BbhhMklA9mJyRP+/V6wzwJswHbLd78Eho3feh1oBqKwtTJ8glrloWX+ZvjRcVepMX2lrFytvdx1ytkoZ0Z55dtppbhPzoXvKYgGgbAjfsTPG02QLXjAr1r0QgapJnk8KVZH6w9qiQV6Z8uGoMziCFQHh4M8wtFUyc3BayWUquUYsxNB+ieHuhFEY/bEwxgqBkFsZW5QqrFaJ6Ks+HUfIqV3OpF+vArBDojTIoqVXytXSUTl7Er72UTBtI7BpylMqsI/qObY6yMqiSKw8fyPXh6UOeBYh68GGMYyhrC3rUSFOl5w+MQDt8hzZAmdYWfKuQQzqfy/PWgb+87ffqMchiZnwQcvzWqL81+DCDo8qTOHnI1AwyfNCMPY2r25WHiCU+xNXxCtgGkruUafynP5jfCOLqTRWpvYe00JLTW2htE2WJbMw5HLFvs4OEWufEMwsA1nhOIw1GBLcGjlN76rpM4HHjFWo3DgeB9BIbrbYg0zfZ6WP5HZYjb9ShxIGjm8gYLBFGgHGOoYkLLdueoSL0U6NQnDNrEiEOI2SKVOsl/M1v+qJiw/8yMbeCBecKVuHKwJpf9b0DojGYzpo9/xnYjFyB9E4VQNeAtlwxc87USQBMG2pTHRphZNiz8yKLeq8vzR7jfyNFGg+na4qZImR9gIPtS0wlj5gG0ySfrftm8J9vuitULFTh7VWxZx6r1phuKJV4WiGCxzBPNjWB2fANwly+M6lGw8Xy+/UQ+KoKzKV4oGRsHMbA+myPhhoN+k9fj8bmAsZzyOXGWHfJXLJ8daS5ivkvW6YjtP9djFgOzc9BoIeNGNgOVnTF1wZJTGQ8sPJU9VI7xm4ZBngHOMcQ/EdBVZR3Wk53XsyYH0BjNwGi3QVXfUQdlIq6G/0uEKxcnWgfNSKHmTcOgErMcMwplZmNUrLPd+Xh+W+QXaXo9Lp4xBp/nz/Li23HxSTK5muRPtvmrSfK8GF8tdFQW+tFKBko2qwc7R/ad4DlwXy2CuaL1BsB0cLq2FbJhfjZ+UmOh94Tl1kiyFvZnrF2SvbQqY5+ou8AJjia2gD66IGM6vbFqatKDAL5V5FRby+pQUY7vbUqEYjKdHzalI5k3mYwodSQmX/AHY8KDMyVoCrKbiXrLaoHxmDXr2Dyyf0phpOEKylffhMYvo/qKvgzhIkJfBo/3WNquvEK7VhEnfu4Zm5Wi3IpS8V3v4f3MgKiqKw5L4io+fJ749usqPfDzAOVQGn/8ksYaUuqJJdY4h0f/hW39pQ40zUAQJgSaNM2YgbVuZgwxQzi0YIaQPwo02zBK3Ad5355UR3K2cu7k09GOQ2q6l/K7CDX13IwZItfRXAf6tDV1e7b+DbFnfq8ZHtsnlSFvvVPbsMGmP8LZHwjan6GRCof7ZG/wOzki0uQ+b6vaWiP3eb7risSSEB6o1fvo3/PGCvRCjyqqJurHxxM0MLBdaxwPclmLndjwbS1rfGoFqd8Z6GztBEoEKwG7nzy9+Bt/81/8Ery9Bvdsb69XwO2NtgkV1GNUHlwG7MX7Yz6f4QXOGPAONAsY09g1OEygXLhOQFbeNxw7AKIicr3aLq9vNkv8Uraz2XzLrjFzeMw2a0avC4ISAmqGroGgGpDONpv1ki2JgJHba4a0KVcID/awQwat8RW6ByQKe+Ysb9WoPbIxTkz5tnsQLvxbUPpKZ5yxN9Fuuy7eJPmvltdnC9s/lOPJ2EU0WU7GZwm74Odn6XiZYBJMOANrniabSc7+MxwevBhjEiSLOVvjbCfstVMk8+k85/hZpEZy/uwqNSnkqUvRQrf2YJEE7dE/lSAjRh+WRYhVueQ4Qx2Fq1Q/arhRHXH4QV2jzTK/fVXcLvPpbvd6u2Zn1Zub9dl49mazukznN9n28TilCR/nHK21vdiNXqfpi81o9M02f7PLWV2BKpnN0EZLVjCo3KYpVJQaETMA6wIbRD455h0kQ86WPvAhgxEoTs2h0XZSmmTQJABQXnk4P0G1YXoENvBJWXkwYU9PNRpNiU1mEwXL5erly5fEw6Ssvzir0rIZtCiCf8iZ0E/oDHQNbQY7TS8uHk0mj6aT+WIxZ3siOuFmvbm8uLhYnNPkpX4F4mPVS+zuS5lCqmwRnvgvs42QYL/zCzR3DKi5T7qCVCHg2QMjE+8klvchDsXeh0lP3loteyhrSWRsytaMqeX6+PhRA20aaOk4cRThfUfdh4xTTGfvjX/33/n3vHOWhPUH5arxaBPpTnEqy+y5MF5+JzZ9md45/8PCXXvEBZXFCo9pA2VMHBM0w12smpT3iQmSH2US5BmeBZ6ey7MEDu1lddj67cQfXuxRS/2+Ij+QfrrkrOLdsYO2Ev5B5t1nar1oxKVsxpY5w6iGlj/8ChofxsXh8431CVg6woR/iK86CxII78gLBSQnn/f1M8bp88k37MTO0U7r1ebq7dXN9dV/9p//p2+urkD9EIHyU3ZnnGmcXnBQgA9AyWaTc6G3ImXZLq7zUw5oZdjY3Ed27NYykfc52A0YyNaSnBiwur3m4ICf/87vubM7MtiIMHIk12+v/uRP/pCtJ3OOrtJQvVySqIccTnK28gF3ChSbwUE+AWkMCI3T82AD3QC3q29fAXhnOkl4Op5g12DFcPwZUxAbTo9NtTB4skt2eL1rG1ENq9tgMzMKOMqwXWa+SNg7Jz8vkjdnq8t/+0eXv3vx2fRsJVckztddnON4on2DtDWnCWcfAvFV+xKrBP+QxGrl8ju9+0SINVUbCfmTRD2EghWhqQPUvBmtVpsNUxgaa8co0nzEH92+/Advbl7JFMJ/ieFxYWraRSP5NIXwqiwkK0ZhicMWSJxnAG5mjycN+Y/OLhb499MoLOydTmcymOyastMnq57NpYoBffn+z9Inj5+cn58hOIAf2K9F0nQZIWMtDeATpL5acbCAxuxtmB9zjCd0ytLt6eef/4UsM0lIVnkwvXnzZrXCG0tVHWXPZUxMv6XuspckHfEYFOoLpgx2Bdo8ffr87/4f/u6Lp09ZjWGzDJqzkAMYfWU82rCvqaB7qVqVbVVXRGNXH2+N0A779ikTsCS5ynH60oArGZcUwz663iGy68zACGyoZXxRmDQQR0XhkOS5usiiHP3Bw77aQRvVxel9HiBIWqtBB5fu6Io/DI+s1mvwuGPRVYkNfneKuB+31jbs0sOg+po8MfYL3AZlv5MOHjBT3Cfj8AMW0cpq96nUE/3+HlCRVmup8nc56NReXcrDO0S7v/VcTWY9xKcnBZFOz9r38rkDtztn8ZeLZ3e9e8xRzXnd4+x3luH9Z7xPwyGt19rVFR7ffy0+ljhMAwGyGDmY5a5X1G2cSRXhT4dx1ktCWcggwMSdFbV4Z2AECPYB5s9AWvh1gAhvrq5+/7/7b5bLG2AkhMAtYW9wJQ/C3riSCwRraa6WA6gigBw2ixGU5BGIx6lSE/bOl5EArIQvMwCj7BJMyhHBQnr8A8HigQLPIluczX/vr/81Rp8B84J2Qos2NMzS4+2GGAFFICjj1XLNWePmjwxQ4T6uIXTc5PPtHy1vV7erDUiRta9a2Wp8cBAqOHEAgZnA0KQC65xVDfb6BNAX+O1weACmygponYw5XRipN4/TW2YBsuJ6t2IwGmMm2yw3jy8XtjeR9FDhSDWpJLMYZPYWBdJLUpO4ivFPRanuysYF8qQSbMnPygrAK4cWUCEGwOUGpCkSvPnz2Xa0ZHsmoWX25BF81uwHhgg8WIWNJFgoAHGeUR+sge0oGDXLUIAe42a9YcgevD6fLy4vLrEEcHaiRHYURQwaiwudc2lhiGw4vIBsuF7cZAbQRsiM7PCjSJx2NIGjw5sRzOKwT2juGYuIxyxUAKtLGfIS4pLNIH6Sjw9Kw+qwBjX4LUWYDWHKR3XJo8tHP/7sR8wgcfqbilAHo8figoVLk3FUp+NS/SWWPqs2sWDHzen2eSuyOL6Ke6hPL62TG0X3UzhBP00n9+9HwlEdfD+qMUzKd9TXfq10OEzTd6FyNXob9bWUp5Ul8P6SAVCLOyxeiXqHHsY+2FNs/w1nilADBWryf8A5AcSILT+Xyq1Y7DNprvsK8odAN+13nEIdqUvT6xHJvY5+H1iRgWSqc9NvPtJErPko+gGCJeeXxqopw+BxlNJGH0x/suhN2U5moQxdYwmH8dZu9h44jIeBN2m5zWOXCBDVvhH7NQMkRMn7+IoXCMzyglAFwsCAqb5foDsQsaFuNtHHf4ZnQLy2n7fRZcFKQnAB2AEvGeEVWpQhwbpMLQklHiLGqVlIAJQVZ5kJbC9zBu7ECYXhfoPfguzC89k5dkee3zKBQIDsoFLl1CJjiSiHH9zYd9l6y6FgAEi2A0IGJg2E/DdrILHkMdRKgHOFtSEMODMdz+wIMC1LYB0AyJFjDzRaLqBKKsYIcJbjqzS/wNlYoNeJPJpmwtajc9PDGUsP8s1Znp4Xk1u4ai3DhIOKbeqDE8RczeKIPkn6WmrlX/V+RxJk02U4lzYprK2lfKmJBG8HPbHkGHnGGSgeDybWLCMh6B9AT62Wu+yWo29J0rnEKkU4X5IStJFvcbOlA2oYFUlhwtDaX2c6Yj0FiJ4jlovRDWD+/MzODJAYstToskieby5R8HhyJYd9Q+dmvWg5iNGouqP8EQUVE/n30+LYhFYYFuBjSsxHb4kE3NOGZiOgbUwSyYpNaBUWD13pKwRkioNLKjCJVS2R4XXGpE2CWxmHQ3AanXyNYKCOqqUMsni4iLEpLEJESqGK1E2XnQPgwcN7KYAXGCWpMaL8dLJPFdH4bspHS1fXu2Jw/MHvZpDbeLfcAkGlrBaaU6Ja6tXMHtXF6UvlGWX4XW7mGxpT8Ydt89dwKJOT6KoSWzP575QnnaqfVoZ3iGzq4QQ9W+1CT6H0JrfhIr07PNAlQ6zzONxF/1ASTr5GZ3HXVoGuxpAQa1VvnvAcKMijd0j/DIA4R5n98UHvXo8g3kDep9IPZHsq2VExYm3HzI9mjInfc5gW6RKv1li1PtiTsVaFQNmlnxr9x8cfhgY6m7vscAAjYSr1v8O+pQFZiwF+GYzlDmoFkXEDCvImA9Gmk8XUTvXFXSTLQI+M7ea4iwCYhev40LDsCI8gUL4QNa41oPcJCcJ/ADUsCNvZJWUlJ77jwunMIhS4uCyxCpgdAFxCwyb7pAq42nAzjWOSCx0DEEmxpclKc7kpndFj0CPsGB7WnIOkAXsCeUGF2rRfu9mzfgAOBrRlpOgNrUWoPpK9lYGhijD1wbFepgcOChAAlYj6Y8PT8Sp/sx1fEANbqrRjpYFWPzOTwM+tfN6tK+luIQlomJgnqVIKVYrdjYKgR1kW/ZiQqnMIyIbUNBgPTLMoCvCebDS3Mc+KxSZn21OVKN3KAJKRIj1QgNdFe3aqLOlB4Njuu3yzxB0fNbAEQoPuFkYyedmz8yYi6kGmAFXUHZNDMqIHe0RaHilORp+1iOTXBdp3GWACsYw9PtQRtHKXrrD1SQHyY9dRHXIQAzcu8ag0o5KojFXNSnb+ojBnJ026m6qdSvkllF3VR/npkT33XjokUro1mLdWD6eHSuqVqF7IScT1zB/us2n8wxXv3Un2fipOr3lv3XmIruJe7Br4oMSjCkPbpS53hwEgsuChFfJEamhaM82YA812jENELA/Iux6Cl1ggGFrzKkNzTqBKuctnsFmDkogJ4RBoZX0wptJKcRh56reibJGXxqV3LCGU01pEbN32tHJoyriN4rCX4u0V4j2X3/vVFYT0QCxVLWn/2Ox1zZg9dRk6wnmYJvdc++n75elP3ZdxGIpy9bTXYZ53+BT59HeU4n2iwkjNbgAEMxuAFMNehns0yArKYkEnniTa6x0M98mnv3F1tV4spmwxz8oA3FHAb0nGNpTa2EfjshNcwAUryQTEg4PNG+CJYi7lFCOIrU2EcFBhADqdZuvsRi40wnuIfwMbgK+BXfMEGk9YUwCaB9mz8T9oljFvPNXTycUUfAseRGK9EVQuG1MKrgsuMhwM5gd54s7ES5jBfjYlmoF+p8mUZNKn2ac41WhsWBBdbjGqtuRj4gLvf/AxJoomQGQSYEoAaBEuudwWuMsvqe0EywJ/IW0QBIoVMRR2pyLhKwdYFWNVTgT6VEwFWJVoNTcMTC70w1pf5kY2o2wxGt9mxTQfb4pkpd1KNxc4MWm7y9EN23lylq+8TGGmqRtYagNX6UOlqNU0KC7Urp8hhXDYmQiUTxdzGgkDD2Q+naIhCTadsTxDRhGYH/MgnV8rl+w0qkUzU3dJrTkYqJCUJktv7MFKpY6qCf9A/Ve0FPMu1EQ2JcToid4gI01EZgkY41IjqoOE0IwBlpVqIyqbECAnNg79jAZNtcEr5paRIRCZyEp9aSzy62HQJZ7HL6OyWzH5piNL7/uHPAMlctNPam290AeXmYee/iG8eVwSr+CRt7qTnnJ3trE+iIkfA7OBGg70AwMPXqOB5faTxfinn/JuqV396gRtRL+PpQyNmFopcct6E3M/tVm7JKyVNUwtLeX776zWa5lsB10xrsBBAXsDoJPE6C21n+SA79CHu7G8W66hMj0cXa2VDprkTqXUGN6JR18mFNtz9cvf2ijNLHFMszivoN97JHlvSUEeSnRpPxzZ3psSHrCgdu0RW17CSKWmD0mBTqX+BUSrq4QdoGr2WWegX4txd6vV7TaZsKBWG8Qw1s6INIgc0KihcrmtsMBWI+6AeHPyMVCsNGKEDRkr19AvkuhOqVo2yhAxXvgGDMGROmZW4gBezbcFKoFBAL+QJw8aPgGQmieJD7Gzt01yy6zElmFmB8GGNRm3Z+B5KkcjVv5q0FmJwEazahj/prY6y8BwMYUIpFKyXJiEt+RsAiVWkBa+ZhsWDNxmYy0PwC8F1GneLJTIKLeJi6FgA+elAqVjJVSXSgvPZLf4UuEyMGCIScO8BPqWppBVk8isluAQA9ZJsMoVUfNsNsnmzAsAz2GBzgXqEdEmTDQ8Lr2ZAsHecuCRF5ZG97VCABCNOw1tpvKpJKrBpYrmYHsmHgXNkx1wW3M2UCCyqUgIXIBbIrvcpKk5mQbhGAEtjaAZfW2usTFTSjxkMqiN+MPi4AN5NJQvvyLjZiP9koY/K1gVUKmeCpn0hnC3y1sTUjuwGuqXVSG+ZDArw3KoQT+I6wMR44PQxV2FoFOgRu9wzsPDrltPvSvvDzRfqOz9+08rh8D/g6p/sylr7f5+pT2ipFbFtknIScCfqAubdXJYR22JEF8HqU1rphkTZ+70QTwgan+IR8prI+6HEpbZ72RRtRTd5BPGrZvUrZKEViI1hEPerrmIuNy47mQMTGKawLAWONIiTt2wfWtMao/Os706Jh5JoY3I2yVDHO/cWnnCYUhNa0LuH5ujX82YPfU+FAtD2K84soq792e/PP2pXYVHuWI9d5E/UHynepo+/VWJhrRq+QSlrZ+Hvl5SC5jpElqrupoN9ALKGJROv7y5fvsXf/YX2y2HAQs+ZnLjYF9GjecDI8GuLJMl6y5bpeliDOgGPGc4yGvsnMFpToNleHeH776KR4d4zgjp5ttJOgWi7jbZejZdMHDPkgFk8ZHjcfFonDN+/60QrmCuligkQvvIqSUBvEVJAZ4zMAz+32zY7lLoHXAJGgdx6lAw2RoCtKBhvpBmGQBAr2VBjO3UYXgKDVMqePaxlgykr8Q7f8TMwWj0kkLZdB+f+13GSoBHKafejh4l+L5zJrFMCpkHMEZR4oLCBEhJcN1abYSkMSSEi81k0bMr2mwEhcmGTlJOtUrWecYEx3KcPF6nb3fJ44zNV7cvdpOv2ON/lr6ZMTmQXosZbDAabPdVoWaxkRGCTHoQxIZG1hIPOFYx2G+60arcfPcUmyEvXplzlBscIocQHC5XK3PQErSWs5EmSbTNTnapRRXJFbJ6/VSaGpRHnQNgMgjJS6OiGXMmA5WWd5aOYdbSZUqXvcgFdzOeyKWJFBVGpsl2u/b13MwmMc2khN2zy9nvUB+kpTyyS9vVRS5d5Yc//JDupqu4Qv1vnv63en9qXMr9w/cvq/wSNURxtNCiB//NdfroXd1g8G4iBv/iu2ZciJZatEnXpYo22mHfhYa0AyVpLbGMbOq8EdMspfWb65En1bopWLOs8r3R+E5Feesl8xx+Z9vlIbalDj4DsM/RThUV/PBBL/LUgkNdQuDBJdtr5UTWiBTyBvFC4ERmB+Qx54OE9/IQKhUCtWJPqmOoi3Pr4lkr4v08ujDN6nhMiP+gZH4/mukuZZAyDomEjnX5fa90kByxNuZq6eEGiRCkXwQ8C3fgNidopf/a3/nby2tcz+WIvrpZ3lxfL9cr0OX1zZuX37zUybJ6qQovMqoM6GRhLkBf8wPaO1JwHP7mPpQVr4UN315N1ktg5jbbsufQeDo9Oz+f4zY+m7PUWCD20cWnl0/PJ/kZ+HSs42BBsswg4PtD2AaXmUBgcJ9DcFmZe3WtIvDhsdW97D4J6PzN3/5NCgb2snSBHWMwIrSweKTt6r/8+os1RwoDYIVhcZRhDBsAyokEGB3MEfDriGmSIBkmBbVm85k/2X29vGUM/Wae3D6b7y6L2SOekmfnDNNr0F1zAlTfNEgFDQyr4pQgfVsKOiqRq9VACvNcWCkYVjjn82+bpXm2YhHwP7r6/L95u9lNXu7WT7P0CvvkYry7Gk1WLOPFrkJ65gG02EHj+47JtV+PvKFUjuZW8GICNAtnQ8+iYQFqypJ8oPOZbKrNZnt2cUY6sQv44Ack3331IMA+YeA4iyBQA9HUZ72h3bUrvzZPYtqHhd0clMC+QpuN1m7L9qN85hTY+SeZzqdvr69Wy1vEANmri3DE2nqFOcUuUaYrtKNOJpMF2y7f/eXf/Su/93u/h2/YYs5O/+NztiCd/uzJkyej9Ft4UtfQO9Vfvc/C4oO6PjR5Pijl3E2YoNIQuBuf70Uur2Po2x7gPrDukHmW70tl7ybtcIXs9XCXPMrdp9J26cuTgPdFHw9ZIZrHpf36bJTjnGKKdvGMIh4pj0fEQz+r5W2xqOKSDsPOxBVe4xOPZHumWkyPumusDss88hTLH9fds7moMc0Rdv3JDdu3SR50TtFhDiQov0kfaEgKeWtkrp+gpVZNxmMzcbjG6rTHxohCM7uX5W3dJb/ncvk7R3qarO8dM0QPMU0cvnfhJYMOnmPtT4wPt/kgxmV1vyvQX9SPXJugMuYkAe3fxjwU1tgrdxuCNTvAUZbcSTSCXizmF//Sv/C3AMJ4/PDTAmdgN6O8QLY//sU//b/+B/93OdwzHF3sNqBYvIXWcqSx4XABO7AmVzJh43zctdm6Eb+RdLNdMZsAPr69vcpHZ1vGgGcaLy5WGqfGdHj0eF2kKzy/AbtMpPJOZHgYMZlWgJlZAPjia3Upsw3nF48hUjQEzEFMsCKKxfn5dMK2NhRofi8SCZCZ4LFys7ndvX5DDmUgC5tbQlVcyX+muBDP6UrQnGF+jj3eTXaT8T9epf+kwMEdfq/x/Z/mi+mvXv6di8W/9VcuQMOJThUAMANmeXXPbGybNwAD/+wrKp94E42bkXHffSqArTZFB2gULbEEebvezjfJ7Xj0OBvf/NF29E92XyZbTodAnZdwwysJbswT0AhkR58cnSynJnSvYfVkspg9efYcrG/u8qruVEfkaunF5SUcZItx58JGGo8/IYVDwX76s59pebccdmgGk9SMBB6Jk37QilpSLkdf/OLler0GoHuzQkAvefXq1fXVG4qjFWzOhCopN+aI4L5mYcTBqm+hcoKCGOKZRKA3yRjEAPg3/s6/8Ts//x1mdLTrKdrBuSh7jKWHaaKGgl4trFz71jMLhyS15dDLqmlm60GOtnU1+6IOSP2h470nSV3eljzvMKr/96s/9WHFep9loW1d6kfWR6q7R7fcO1qthXJ4lLrrCdcQ/YTqwJfwSZfnjbMc/L6cKG3M512HY5zTLKtsa0vwsGMJTUXWrmYrN2lqWcrHg69v2zuhPVsU6zMAUUQcbLaNUuOaxdSDwy51IC+1czrjewoSahfkifvuEOZDaEI1HzAQBH5AniexihUVZwwqjSP7wzVWtcf+vB9TPzgNnPaVaGttOJT923jZyLFXs+StVP0vB1nBcsaG4WBG1zcgVy7QKvhRvj2A+e2WkXO2e2c8l/WpAOaCEwLEgfFj3FHAvWA1HtjOkXFpuxy7wVre3VYaJwGfLc4ms9liOsP5hOPDQKeATRhKLlCnBkP4L7EEmstqyA+kQoKYBBrA1wIDw6q4tgNDGb1nfJpsOrAMkW1LyrXsB43qkxeJNUIvhqoXLJDKXFlAyKYaMxEQHfOAemMAiZTdLZPVegT4fruZveQIrDRjZS2OO1obgdRirOpJ/GK8VQB3JFkO+pPxZLUQT/7hw4PxQFI+pfhpMd/mG2QFuJ+NPp3mN+RU/SmfXDpdYaxti6gsRBoQN/clntQ2Oi8Z/vhoIYcqIHtsvNluJ9PZ2cUljGyZAUnsxwrjZMKpDELtOv1B8J4ZFTSjFMrCOUpNLftL+ldZagbmG6ySxAidkyoC6cdpFCF6a0JmZJDY8jIHgbGA6skuU4lfZ8q1PNBr6qZIXjx/+tmnn97c3tBwSlLTMMuADrGkaDI+pAj9V9gvnqyE8l5F3/Nzzz8qajhPiVhdLl319PHz3Wog1vy7Lekdc/eK3KE63nWjDvyOBX1n7MMXxwP9NfLUO6irQ/yoNC++lS6iOkxnDUDX/sFGiKBRXv0QKJp3p161B1c/nwPSw4eTdNEcEYfZoZCH3LufQr3uNoLbPzbcXezxlKYm311Zx6WhtSN7lHHxrvYK8fE8SZy3tazQCiE1xMRlDRmHCBz6AlFdushOkh8mTh+q38V2YHyz9eOMQ/QQ08ThmM99wl08W/cnpqD4XeGN29AV0fs4jTfbk26Gvktp9yTiWkYSMjpu/AkwapxZ6G773BDuNzibpOMzrRJOBRzlk6LcNmos33QhQwFKsLJtbgmo51FFQClfFNbUatCXNbb5ivN6FS0TI30LiJ5PfwwhvJRBbAUb5YgyupS7TXJDrIA87NklPmHQnQgApb0/ceRhZJs/juwSdrazvOQ48wqsCXCmIIbPxRQsLJ8Y8K6t58WDXywFyGGnWQ6zCIDCckACoZNAXbIL2IyzT883zyZyHJqPAfos08WBppjaUD0eRIBslkNsycX6iFE+tdkPg9Ts9E8dC02GyKupWOBoM55sMhbsJqvtbsopAEXGENK349F1UTyBA/VCO6ojaD17LCycvkZS6QSFY2tprS+7+nCy7xx/G2whUtlGXzg8zTm2mX9EpTrkGB5zefYLsRtAZ902/kKqstLS0SOCbDdE1Cg/R/fF+AbvKenGTCxTmx4c44uA/yaJefPLaBDQ18qBUb55oRmAyUs7s4u1H0x/8Mxqb6wmsaabMc+Do9gmy188/4QzxXAnUjMginogWxl9a4IRtvqjNQ8i/v5S83ddbWmN31nP7PNscYb+90bLuGNDCqStXUd41qi7H5t8mjHdud9ZSnPk9UGLqr0nQ2OVI8Felmx1vbjarwG/Vu0ZHyLW5X//LRV+f6WWd9xGJ+mp9nUOcjoTb1/uXTMDMRZy4rLdH6iVa/1tWNV4fXf2viYHF7sZ/zAxQb8hMJDv3cTqr3ecejf+A4X/AMl69B+r5T6Sv4ci7ixej2x35vkxY6wBvlDWkfyLRdCeahT7R+FzPVXZPMWf7E6qfQqPCTEJgQLigcWEtCMLy4J5MQvICY4DUkVpvuLyIoeaEkTMSDLZ2DWG8WONp4OiOcZLo+FAT8yDCfCfoWKzDIDiRmAYlmzCiBqvhlqoUN4kwGYFNW6ikWswPpyRhHL0DzYmkNhjAGw3bNm/1Z6ectQRrgSfwsUqByk7Au1Aq/woqiS7jL0XSDFyiJGsGhxnIx04UBbbjL7cpo9vd89SVjQDaoGx4sjUBHuEIjRzIFgaEgs8zEFcsivAxBo0hwfzEZDwMwESx2xAIOqYIqnmT1gQzNY92aNsd6HDCQS9uZOdP7OR4OEq1Z4+klp1goBy2TR0uwXfYzBJd1gK5YA9labhpB2pkIItRK21WsBqbqomBZuI4JZa2m6wePvjaiW0v9mxlAId8qemokKsEKD1M45n1tA+fM3fR5qyvqe6SCpOi6Bx4Erxmh2RRWOiq2DWUmAXjJlHYtWFMmiWRlozcw55dFnDuJhI7nHxXRWKn+NwyaKHIqbuZBMTfQx/MBroa3kT0hs0dIIPRvB3JcgQhXxftEHbHa3Ou9LjvfgeWwNw+JaJ6ugtE+qN7+/XvYI0LDnP6nm8FCxjFeA2sdHHNlMv95bELjvMSV18Dx+RvIW3oobIhvVMQTVLsYPfPropT7OsWHv7nK2hhuZbqRQ5nLKTxdCvgbd4KxuvmhP4PW6skOUdjUz0CBaKbg242PeXqtn6rcXdM7JTTg23GqC5ZwG92csGbS2LNFelIBcIzd+slQ0Q2Fq8Jxo9UE//RC0ELOA7uTKUpm120gk++oxzy9PGluGSoq4KpXCm/hBmBR4sCtb4IoJ28MTjxHbY1G7+YEGQKkVxwABgdZty8DCe6zr0V2hyfENSkl/Ks1yUwEO4yYOFcsD0ikeAZDZJ8R0yMZEYnAscn5rfkfxWMpbOIgprkkUhx/dZMroFwqpFRAB0J5699hnC/pYxc5a5gkN9ykL1x3LQ8caydCwT8xdsrP8sLZ6OkjnLjLNig2WA3zqWjAwcLApqjkpkE2mBhAazMTpkOQjhg/2p20QLBvRyRn4WTGND4PCO+/48mQuop2+L5M1o9NykVNFESZbJW7UMBPCSTxAh8UU6neBrsxumCnJgbjH9ggeUJgJoAxqAbDQcmYS0DbCrxWSCwFvpGYcEs5SXEX/imYJAR+aOjxWDjGzmY1YBvkYsppCxpikWhNDlVhI8APxYBOb5NHnl7VWKTJJsIs23aE0IYeWlJuwy9OTxo58qRQYKlUUuGgIxlDzavVAfnbwkrwL1yyP9jkAi4mNs/ru+l79iT7841/m0TF6w5+kqssmz873RW3iTTzOml8ERP4WWvEN+yxojr3erXUvpvVH0XDW5NbwTdoV72Zyc6LXzbMP1P5yyS6BYq3G4i/4gfnAbdXIe0hMOiux78IZrpaAR/RqO9+J2r3LvP+/WXvv8x0OU37sG4AgHr3Go9xHq9uRm7ljFcbg9/wcf26zgQ4kMZ/Tz7q7vRPlBXV41fwyRobLvouLNUkJxAwP35zCwoFYyL/1daKa1uHcV6dWoVMlnWaMqpvzlVGxVV/tUOshR0Fm/rkKJHPdLlICaYjVcLLwnBFkyg97zik5nAwidMswrRIxfDoARGEwk48IQAoWFNR2MwgUUPEqAw4BAkkGslKmCZUjDFgiuXfANNJIKrNUGoDrTChwLfLRL5QkZWwyeL0K9iA/ihj0bUu4kvgb1YSURrRRRYE9QG2A2HMzFXTLwx4C1AC6OLZTMPj3FaDp+u81eXq8e2R742fnsbD4DZk9UEjJzSaVSiYQ3dK2iNEWgVMVRQy2BZYHFaLthl8yMkXZWMAvmo9D1xTh7bNwoXmPnagnU4g2h2hhjikGVAGuMCTn0J6xollr0qMLl5a8/VwmQGmJVUtp13K49Op2rypBQutC/xBWuFx/al5kCmp4lHcQxnK8zyKgLOiNVDGVMqQ2oiPTJqnDNFVT1l+IE6iUuYes7yEBhJgcVmF+cP7F6qDmkK4r1ywJE2ZNxrFLiTwlvNJ4v5I54xOSHYaf2EqqUGocquvfzkEMv6cfEB9KA65zW4q+m/7gJm6kPVP5HNg+gARoubqwH4PhOWXTIWvWxHgPALCd+hlo4eOcNXbiFolGnhiUXKFyhYlaVFcIEPDUQ9wfcu87Hy/vtsKr+ffyCTYkMHu7n2eQVW89wgM+pHJo8mzFBzpB0ENOt+UBfBiJKRG29huhtSJPFLdVaEJE93YokNNkq5EHdu1i/s/gWqfpHIPpTh8kZN0oc7skd98wDMkDSvS5vtNaW2fMthayVFfebiEFJHKfCSeUY+CrD9qYwsE28EsVB8A4v9fQMFAtKBuppUSdAsGCp5hbkiU+840+gJ3iaDIwcA47NLR/4zNgwh+nilsO4PuPT2ie+4IBbbWcDJBRI3W0Zs18n+QXvCA0yJ6wKpXg55btvC3Iwvg7IZPMbAdLshQ37v0ZAoDtQmNFwMCTmQZavC1zzcbURfmUdKjmYhEAMsDjYm0vmhlYIIFYxUx150uQEpxrLO8j+PksZwp98C2nO4QNIvr1Ms8vbW4yFglN1b4r1cj29nawXk7PZdMSUxCJ9nCarbLfIx+wpxEQBK5BxcVkzaTBO8JmZ7kZMFLA2gEXC04zdetbJlE8WQ7OLJoqY3eQsFRg9l0mEXMwkGIrH+GBMnfXS4G0tNOCubz16E0J2OwG/LGHtnLkRLoFsrQew2QI1HzVj1iZb04yjfAFg53QAbABceKDacuJDthH61iP5KJ86Y/+kU/Y74nQFg/62ikBYnkfrNDp/QOulNZmACcOByhSrU+Gs18CNtkAm9R1EwJywPkM5siWIz5Kv0sUbtYb1M4lpsioPAa0EsJjyrsT4Is2aUnEqwNPMp78Mx9S1cKAIASPY86nR9z3e6c3TfG+8k/dtQ7aTy41+y/qUcJjWLOUg3aXyqDvxP+AW2r4W2//Y0Mzwefsjtesvt5nalKRJYzFxuXGYxKMdl34evi3OvsYhlNkVD6rsu5q1aMb05b9vWrOCgWNnjQJFd2Cv2LCr3ktR651mV/XZYwCUlLVG2nNWeo/4VfbWT39/Ne/O3ePvwb61zIPIqv4Hkd+7h7uqf2hF48b28HvTW+gDQ2S9vx5OKm6ISO+NxiUP8r+3Bnq4Clat53UIfS5UyQOOtuIXWCAoReFZcLDSgB6FkLnhxVJ88rNPVssbEONqdb1Zy/Zg1x28RLR1o+0gBEKcs89PCrDGO30L7CcnsBQnn902e/v65s3rt2kKVIVjMptPsu2IhayjbL6VZzmO9CsALpsEya5IRouzc2wPAVNWIeCAxBrRSZoJMXNiVJYmrKwF3Gux6Y7s2BCcNMAupUKqFCAb4fzi4uc//yuYJbADerLxPirAJuEwsl99/ssvP/9aw8/EgEohkA6wUgDHGt6WjcNZAgZdZ6Obs9mmwAWI8u3XEMRLoVfbLRuKTpJ1mrH//Xqcz/NkNSrOivw2GZ3nyTLbTpMpS59ZP7EZFbPJLH+d5V9trmbj+TzZnU/PL/P5c+p7O0+yS8oyhK1JDxSONIhnEoKhbWYEMd3TiP2YMG58MYCBaA2y01qqDs1n5pDN1OBmCZCHrQw7VKTJBzt+C91xHFtW/Omf/Smrfu0IB362sY1UOE0Gw5u3b23sXiLgtqSUhMMENtgm2gUJTXF6tHZVnXAyNPKgDJpbjp2SXWBeHQNWJpLNHmA2yDS53Y4Wi0eadkAmia0/bgcXz3Bru0xIz9ZK0Z2zjdvHuO+fBtTNvn9S311i79E/pH7tLfiDaMfxv/vv/HvetJ19spHQFnGKMhr5630LZs1xhaO56lyOPVPK8Os+pQ8Z7R4uSY3SFV+rS1N7tVynPnr1a6W0MKms5/uoC7ZeqRb+jaig2+OyNfLGEfcRuFXbyNMaHxf6IOEuyQ8UUrVLe4ngKy7DkO0Eh7Fd9YriDwpXfON8AFGU5VbEfFKZ5r0q3aCTPexpDLVVBA66xE7QjCR57zBqPMkfXV7u2P5/AybHrSbbbNZbTpba7lbr5Ya93Lfr5XLNtkF//z/+h998/TmD8uA/DQADxEGAEnN8fnYBY/jiss/YNg5CnOHFtvQkXj59wllSBZt4ArjTdL1aMa5/cXnJyH06mTEavZifT+eYBj/ebFbJDM91sWbvf7m7j5Kz+RS2291a5gbFCsCqRFjBx9Yi86hd8rEKpul0Np/+N//Vf/tnf/rnOjQYuEzD8R9szSQCm9mvGVO3C4wt9yGOtrp+Nn0MrGcQPUmWaXF5kd5OsydPZ1d/Nfn5i8U1podmJxBXy2VZa4zyGBq3jiUnInkfMZS/S27+29XV72/WyeR5yoFfxfn5bnO+OX9ztv2WZQuqFfCY2QNmVwS48auZL86phhYba/Uzu/5QNaZNxs+ePXv+7NlYkwNMmyQzHaJATSU4eqI4ufWovmhksiu2KWsPtqvr129lawlua8kCZL/8i1/RlILfZEVl+q/xey6TXpaGFkhgEzGDQu00RSNS9TPya5m4LCZmFdjX9ez8EuuO1p8Un2q5L3WkPei5wP50vODst9lksZAL1d/+V/4Wp5KZD5KbOjRQuKzx/MmECAmHAU0hWQxC8674RHfNHnBZDJ+Ssrr7o1Jbrr5yWsjvERV9x+/B5fSsp5Z7Kr1LdLdcJ9emehurfS3sPgs1PlUvOIg+VcJT6Q8Ke4iHUMdyJL6qe+Dd33ddP0dG8QOvOwQa8gzkoXrZd9PpD8LdbdrFvLWtu4jb2vSAgT/sFbsPle+WiLp3BiDO2CWN4p1fvdi+HP1poVwCcPW7lxOS+jn8mqRGDflua+ytMLCM71cbvQtp31u7DGyR904WvrJDSvYWMFRWI6+3TcXW4+2uAVrPFSnd6MpFmaDJrLhdXoP02LQGBCpMzhA2o9JyxBcmxBEF35PV9ur/9/f/Y0eHjs0M+pNsA8byG6GshP0fBUkBhdgCIFcdiAs6ZIdRIDjgFvzuL1VG8fEXKiYTPO4n8zl7aFK6UD0kGuXnRKkNTixg0zUEDE4zUVC97wCdk02xBpkCO0GKgGPG93HoYR6AMfnzi/Of/MZPRCwXeNAyVdB5v6++/eb1N68xLaBnemOXr5nguJ3sXhdXm/FtykTC6Joaz4s3gN7F8qtni/NPR1gvwGQGzrXBJYPsbHt5tpjZVMF4uV4y2M4SXkbxV6w7zidfJW9H+VUyXlLXZLKe4PCDTXK2YG/R1PyJsOu06Q7WRJb9/Hf+KpMfeD/hA8TOOTIR5P+Pi87cBJ7KQANp+0IA1GxrptUTUOaMo4vVRrZzKnsKaboEbyJ+D1AZsxxUnjaVuWS2CqrW5Iz6ggwRFCPW0MhWkN2hC3ONmQcU6iaDxYLjMYH+5r/yt/6X//P/xfr2Brsp2z5SxslbuMGHZqW3IDc9icJgj+kIeyu26n3Gvvqt8v7nvbRMaHwYTRwrchPfI+P0fk4xk4/hjxr4zjXgXbfWaeP+HEvoXb5G7ATRtyHO8UGEXbZYwp6KfCcSI89eqwcPsTg95wBo24fWvW46arovLS6An097tB+Uw4S+p6avfP+uPn28HiKtqcDh8rTa9w8h1N40qnG7j/dYV3sNssWrVRw1efofsWhRb9ziXV3J+cSab+q2zT5uL7+/lPY8bbFd2j6Iv9O3oK20g7j+KpDq39UjIyiDx/697IN6ReKcGl+fcwjfMRc6PIYiNMIbqhRiFVPVVKOqNsIrnAZCFHQGq3F0rVCi9sbc4SHPDjZARZjJbRwaHEDIdX3DWbCMUYPawYnyuQd/yukbCAhPOdbwStRgO5ARZvn6RVHMivGXOUdiFXM7ZtgQ5e4ZDiwZmwUJm4K5yYB/OYDxZTZajYsZXWG3vpA1kLB9PoPQ48X8jFpgOdhOOJKNSEwNFvAy7GwzAeUZBQxPM2SN/735FiEnIjKWLDisJcyQkknTEuyjv8630xHWxXgGvC+KM4biR5wfrAHx59kEL6AfbcePRrM3WkWQnwNuqdhmtJuOzyU0LFnOnC7wv1ntNst8uZtMsun1YvuEYftxcYGNgadQoemQYrvFp4pCt0xQWJdkHS4bLoHDWQPwKEsyHOelP1lULBS4TqdwvZA71GjJb8yO/YTUXpDILQdcnxVLaaA4B8TLcmMjHzoplsoI1ymcptSv0S7/+IVSWLshwUmWA7VgebYMI6Yl0Cr/pR5R2TSX7AyzNHCpgp5YOHEOAFYAMyhrWwnOIWbUCpGwZZ6ijSx9hRWD4QE9DUfBMivKIr1Phq+iAnQqddYQF3XWEBSNHoyuHPsPiUQjLRwGfzeHv/fKQu70Rur6jkeCv5PgqeUOom9oYFCu+9cv+pVs/n71sz9VwlPp+0u/W2qoo7q7OeM1+fAl4PI+HCOBI79czqjRjid8F07EpV5g653aeS1CfVvJ7h85sE3Dy8f3JfNy/fyQSgbkZbDKpa7iBn+SLRRhmcraD2YwgDCUcVjSgJwDSJynF+Gyk4nIEB7A4wMl+Q5r4do7qb1+AAqv9YP3pn9U16XqrviaqB/AY9X+LnGf3KRVxLHcIUtILE0FQ1iANUEteZ0zByAG0ENguNnYGNmY88LY5EYpAojEAQsFS4GPbi+A/4B+wFSGz3EM4bwAht3B6jA1kI8XDOPR2v/efP1Z4ItnjEark1mCfz++QJgiGv8X9Nfwyg7fG5xvptqq0kCllezMtJhVANemFBj/RxqCAp1UADtBnyrYQKqZUiJlmgBbA9cjWTWYMhny8fNoFgifwG7G8rFnIMTB/c16+hgUjLTUCE8p9ijC638+1alkwHpE3bERkSwgHXo8ys6z7Yz1EHDh4DDtv4+ImmdhagEQLf7y9xeolgCcmsD6BdA/CyoEmtE+AFqbfGLhmHZVBY3QqxF0Q7SCM5HRMU8C7ehvhxuVjg2WDbDdyllHChCIpyF0grLsFJlZjvJpLelEVOKuyqpFFSPLR2qRxaVNRKUVhcVvNJpzNBmOXBNt2Kr6yRqiHqBwLWCw5cNmKAi2S1al9l0q6zDdY+JcEASyOD7KF9KjuFqwVkwt9ePjh6gBb+0fcMt1Va2jm9fbaCBZPdt3+uwyfzgte1yHev/oHAB/RR4oT0mRnXqQtn+oKtvV2k55DxtLYlQvUrcLw+NeCgth85EU244DrcCa7F6lkrlZlvxUEFmzTWtl1YQZ+Ohj6sPtxZi+azw+VCcEmpSu1biOB3Z2V3t1xTdqG4pupLRHxK0Wj+63Ux+2cpNmiH0ca6C/xFjnzbJ6YuIiRNbUnvWulvgepsOS4hrVxTjGYeC35hibk9K9v+y/eaU/NOcBH14C7VB5lTyTCIQFy8weWUZUQE3gzUC97R8jrMwLjzNc2eiGHXt8nHUKVMTNW8AViGrHA2scmXFllSDQZ2WD+jQnILgpcPhNMZkz1q0BdAB1seWoAVaOZsnXyYwVAQsc3+GfMdS+28idnaNu8YZhUiDDbeYaLJrkKtcGqUmVFxC2AcXhXwRg1j6kgGWZIUghO8EwqfAuVdC0hComP3/Gv00LwNmFZAdhJxsh7YIlzYDj+Wq9HmkT0hSRyG52UJHuLpPdRb5jyB10LKAswI1wnPuVssIhW7NewiuvWRP8j2621EDO/g7nhag1rE+qIWYBZI1bm8kkBygUqFF21j9oQkHHsbHAWqYHglmTUCS7J1F3ZNUiAb4mlIueEm3cJLGogxhifXAQm2YIpppU0ZSHvZaRYKe9mOBqJoOaydqXNdDP5bHDOcToSk1JEqqGkokgCuIZ0WRTSYlwZFUxtpyp2iihMfL0DTxlMumROxaG+3opQrMcopIEh1cjptXLX3lMpsPMeuoa+298O8rih7z3DkppvpEOkqOHE99UB++QIXmNZvdcJZ5ci0jMk4NDNNCQ/6B2jSL7U2vk3vKNnlKjOvJ4UolHeA1L9hKdtqu9Wr8THT19X6pzO0q2z+ChRjt2SVXPePS50fpHczhBa8t2tZT/Xt9fZr0/o/eGXmz2ZopH/Q90qwfLowGZ6gqhEKhSOj79nduR+ODRXVIdVOzEUuO88A9/gU2z0GZMIH6fgVgMF3tI6XF9h9B/H2lizbTKf5SgNdfwyA9Hye+6psN10kE5XFXC8br2VSKk7Hzs4/RsKJkU/tgIUwhewFd5QYo63Ikko1GUwVZArECkshjGE+pzRoYSNWzM2xJAKj8QPEwYvAcssz9mqiAJihZ+ZoyZMW82EgIacgf+4xGPBABYNgEiHc4apxYABTOreIklS6AUUT4/42S70WC4Qc9SEIlDjDCrQgxzs6yACiIxbLVXENhUpgN/U7kDyZLAjlAc2FlQtXrTy8KY3BT4IClSopg6cCyaoi4473Ae4oTgCWBcLvQ2bH+x251RPG43SE4efnEEjEHBIGH+aUieI3iZR2CGA8lZ0sCCYNizfMHsGU2foLpSZpqMTOJl3ChUSwdQjVVNdcQWwjwhP/sjUQ4GgP3X+cyyAmRWk10BOIkJH1KNxCJWAZNMykbB0JSqBjLILpR9IbVjkWmlr4oyg0OZSYG4ym4FIwGaCN3Gi1Iph5cYe4xKC5e4hQcL1B4bic0chyQfn34IGujtBd/LClKj+nfC6tEa+b2s4TCha9/f2uMwHvelqvWuRhOU69XKd1Mj+UjxpU1jY3Vd9k2ThcvULOvOo60UEY8ie4n9FlUYJQ3CEEAkv8NBgciyrPGvETfrOCTG+QdJjmaJ5SGMDPEVJI8jCce5eKzlevAR6NCsw+sVC1zTc5zUE65XKqpmaNNYP7Fs/SXWtNcjw8lJUe86yNsx6jD8+9Vfo4OyGg/935oGeVdEs0HaKJ0qtFBFEo9YVHF8GrXgV8xc4XLs8GX5/Q1Z5PvIUs5XDLEDVn34thjNcMzRkLJZAmA/Rsu5A/zsAC+2l/+UUV3OVTWrQAygBP463ubrRFhuPUKUshRw6x/tJmB+thICcLPwVjCVlLV8TjZrPOfl8LM4m+NUvl7fTiZAYWJm4HgQpjYcwk+G7fDHuL8LJcPTJwA41lf7BAnPC2gLsmePQKmT+S2wHqyrGDAwXi7ZI9Kz7I12x2E9Lzei9U+iMEQvo4GjDzSgDoTVQbkwLHazUcbm+kwZmC8Nw/DoYqTjvjbFltycQMC5BEW+1G6cCQP3m2L8csSJB3wpcs4zwweIwwHMoUjKBZbLNkFeDbWjgu3lSAJjxuBlxDLrjGT0qBkDKis/IJTPzMiGrZWK3YpDF3Dx1wllnKA8xueILwgzMOxAOp1MyY0VsPRD1jRCL6MOywYxscHoG/QL2Mqu4x+nrRX5a7ZWso2QcBNCJLYQtY7DbAnzD9tHSLtNvsEUHCMhFV6tzWiAmdkKVKC6xFEXd+t7KL0EOArVr+y56NKXio/TdTZwfJG2LyJOqIfFzgu3lMa3Iy6knlfPHe+TNtKOuK43VQf5wTtkSF6jOcjVwTmOHv4+jHOdHG7I3y9nf+rw0uOu0V/Tu5XYwnNwP7lbicPr/sCUg+vVUm7c+nfl403Jt7Trd5n4uLmDGC1tFNLaAvGcYddLoVGQGwCN6Db+3XH2K9OdfK+Urprci2mVmXrX+IfHEKhoDz49tZ/mIMN7eWhWp1ksMt+ztZs8Q4wrZIgYIYsTn5Ql5K0F4qqFpvHK+r1G/+4e32dxXlao77ur1ENyRmgk3gs9QGHKEg++ujjGQreSA0GF7EPRbi14CEgvzG44WOPGGu3VsDmpwq2ClOBfmQrKaCPLRGnMmbH+1WoDtAdyMzKPAYBzPDCaU8PkwFOst7t8uWQ3fXnTWGb5vFzfaIUsGxCNRl/PZnPW57JnJQHK1bA80Ay3nikFp2fni4tHF4x/y/scgyTbTRdzuGNRsIkQJsFkyiJgsOoTkPHsfHl9c8MmpoLT2AYyGFQDjAUKZeCfje615AHbgDzUhkqw/GAj0A/o5olPipmkVGSZJWfs27lkq//JmP128INh5yC0dA7oZjscPHJggHMM6wm2uEidoQusCy2FlfaEuuUSw86ZsMTKMGjOSVwod7NGqnQ+TzdbPKCoPjUlBj/7+dXbN7/69nNMBJSPdw9Wmjzvk8nt7RUFYggxi2BbM8nFh5oRwx3zSeYBlUTHHPQ1na43VEFTL8xzqO7WvgiB0Ey2YKNRUWw1VUAnCOwuzs5Q72w2TUfnk3Q+O0vms3NyJaPJjz/7Mac9mLo0KUAe6yHqSfwR74/qGn4ptgrHn0TaRATpJYFC/uB59KzeZ7HHb2X244QfKb6vGrA+cyC895SDqO/hg9erWbvvYVXercgP1dxHVd0oyA0Avan0njmaP6ihtE7cT5d34+nee82y7jPaGo/pBiF7AsEai8WIw115nSamrMXESU0mzVmOIEmTuBbTzFsjGPoY27JxeGj+Tjqvu3pDt73bmfnhElyAWJga7/poXC35u32MRx0iSfrHXagsV1lxa1O+TR4Z8Xg/wQHFghwFTA8vnr0Ch9H7J6Ew8tUv20HlMKehq/QVlFaSF0WJgt285jQhINwvtC857AVm8J8Na74QnNXiUVGaRIBpdtVkOJnTvrghAX5A+P0AqkUGD61GhRiVw89y8oTrPyw2WzYXUikTHSIGPgeq0sTmI8NAPvgXYHp5+emnP9XmktgGtpoW3yDgOxj32ZOnlI4tAI6dTl5LR9vFz//y73I6GUVII5qeULHJ5McvfvxTDjgQB7YLFYxVH1jdXn/x+RdsvcmJB7g5aZQfh35ND8z+kPmRzZvnu0WWvcX4OB+l8yJd5xtG+PG2fymv/6txfpFnN9PJ+dv0q9fs678hP3ib8wQ+G6U3RbbgAOOf/dbPf/zjn6EiicdPgXY8neAOxB6mHJWwwNQB/SMh1WVtwAQban118y2Wj1RPCxFiKmSzfPv65U7rJTAuZMBYs8jKQX9YX05KVQ1gK6uWL+vIAhqAU9jQg5pMUzfMo6j6TElofkPlM1G0Xf31v/U//J/9T/9X+FaxtxIbFskeQjD2VWIygZkOTBbmEGxSAP2oZeGnm/WVSh6PKfuPPXiDi5ar+W5xpZTdwmm9F3uCFeJ5W++t6TV/39aMZWTH+6Qvy7tJO3VEs1+K8n34oL9fXuKBnO+Af2u94lauel5J2P/mb+V2NLKF5536yYGuGqWWnb36ksR1FO071m2/bA1hOyMehA91dz5NvOfYtdkizTdJp4iW0FgdVP0SMT7Ey0tv1OZVGgDlK6z8aJLVYgIdb8aWX+Qa9Qf9GKqClHG4S2iniSmbMTR2TACrZkwX/yHx9S/SkDw/aJqgbQ+4tkPkD7rqB5WrdTM08N67ytACRSf5DC8fzeQEbeh/X//Q3hALOloeRQojU5aCJR+BSI/V3SKVyXbat8zgVBzayaFskIJC5SnEuLMuZXDoKmIhWE0rGCFJ4sQddKlIvXxB5ABKHs23RwPhorE0o8H/nO1nGDUnljF0ufvwH2wLOGX0mweoZ3Lk0U+miseTSW4xWjmgiQKWC0vO/PzsbH42k5u6ALOMA4wKdildb9YaJJ/i/MRwO3nngPV8vPt8t3y5vfofjF48HU8Y/h6l/B9dpPP1uPiD3Zs/Kka3+ZvJaF1MsHTW+fj8+cWPH+Phks05TyDVAQIL7ARQ+MXl44vLc+YbcIViqB5kzn02k5sTqgBTIzM1Zd5ENglPOP9MqJDpSKJXCiUripO6rc2oE+aG/xcn/bfaYx/RQNxZ1myal+r4J4WLoBz9p9XUPtxtjmT2+PEzfLHQtvTjKwk2uDK5cUE+iSE25kellkDZ6jsmoKV6pGKs4xIX0pQeXcZOtwMCY2+VECnJB6lR9n3wOMWe9mPoowY+CA14z47viEVP1hfi4/WONNDQb+v75ZDKDQC9n/Weac3QKq3sFXIo08HVYi1123mtxd1tnLtpVx2I1XgIpQQZGlVp5IkiPBf3gVdg3pzlGD530czrAvi9pvlQYlPCwEcZ72T3N3l6jBc6vEbk6pGzq5RmvGsgsAqBJqXHBA3weJK0XQzjeBcmjqmHu78RdcrTn0ObNsWo9ZDTeR/N0SyzPYvoaCQnb949KW5FhQV87RIsa/8lgUL4TZcRGyND58QYejTYppuAnd56QngCnEBOPN1HbA0krAit+bFo1FloUv4tYq0EcjtKzD4TVy0RyJPpS/j4RZw520NnoigWUA8tLBwRi4mYAVDlOkNY2Bk+tlLXHVryzfJsPp9hOMipnvF8htX5tsIzv9ytZ6B05gQknjbhNMirSjFvsGNsm/MOkAzjQNCXvyTVUgE5BvEoBxnmJ3BoQrLL7OzJaIK3/gbPI3gRpdLyGfMB+bdZ8VjD9LjLj7IZO8alq8n4qbbw2f6Ub46OPGNmgk2FdOzBnCkLW18gpYHtkYTpDm1+CgNwOgpgCkanpKUcmmxuOVRAY/WUSQb5VdnqXhiqgVQB7ozuv1DW9BvYWKxalRwkWU60az9e1vIyMNSCqFT1hTnCEJBE2ZPx7mm2oa6ohdXPkKnppUSGx9TQPCOsJZCmttWlwhRWhxEvRZW3kkJPRqDA/jpMtfiqEzu1atl5WS2octuFwJ5zX0Tnt/v+b5v7c7A6NMc426pWj+uslxM+6O+XszyQs8H/iDx18e/yTNMe9KYH0n+nKMb/brswHegqKsD7ZXyPEqtgQ7dVwsN8dsl2KvcH4YMq4OMKqQkQsGv9ZXCifppylvo/fIccluIGQBXXKl9NXD06vb8W2yvVkqk1yjkNLbeVxf0i71Z0qdlKEzxWKiylCY93499Vp8C2i6ApSRcl8ScR9/C5TxI1Qoz7a+n+HIbUwqVtUh5tl2aWX+eYEsCr/+n/XhWhFUNgn2a6d/KuZlAuwLpArICa/sBYwuvlVRWFe7hQHWUDs4zSHGnM75zcgqyCasqt7fDBqMBowLtBe5JxWNd2m+RUihUGpX3yIdQqSTxIIQRyXIAcPAr6ipONQtttzAb3FCF/eznXU1yO8z3ngwlY77QmVUXgtc82mmOckRjUZwBDsiGTpMHPXW76qg9JHIOlDW0km1bvIqpGwsH+44Kjd01qqg0DdkFlW83tmPUFPLLqV5kA62BnFDRdsH+oFjlQc0Taprv5OFson6omiewkBLY6EgQnq/+v2lOSQGLxEox/MJKykDXj6DQEEd4mL/JZO8HYtUlApSibRJJUukw8GJk1RV7fr0iKqDRLSCVQ65K7tYHFwWmCj5WxkWDGWgaRu/xTb28+CWGlSr8qVYJYf5C4El/yhAIriiCkIrhMEA/qqeKkrGVs9RmIBgUknhGGwKBsH4m+XxrwNv5+yRxLG+Rv9vJfz44bFBJrKYRJbSoqpPYGWrL2s6r07xKVMwDlW6WFWWvhZQlOfpCpaYUMH2MOo/KtZT7sSG08BtxaHJFxiXE40LsKeQyBkORa7m8JJw72X8jbE3CGteLiMYlaUg+ruyXFZXVxaNYo1l4c7uJwh3gqPkTbTc5NaZs0tRgpORqVObnc2LKP+NRKefDHlu/mQ5UBjEL/hyMNgXfTNxF0xGXxxV4qIr37tinUkKGzdCILt9ErN+BNN3DlDnAsZC7YBmBWLuFBjf5K4vFG48r5HFwHALZDokCHhgXJbBIpu3bWUUZyibWSivGUFVAwBWMydKw5BJJVGIxtoF+5Rat8qjHIlwO8NGaOjz1QWOPzkkdk7JjJlvkokNF6wWkoOagL35589ETDvVgcYs5EAfD3Co8hskiIjP3y4XzDFkOYKuTDa8gGtSFgCYEWHLOQgOMAgMTpiFW+Gyq7y7UieJycFcmOgfekmOXpFyyXHWc/Yvf/NNVZxZN8mey2qA3u6CYFpSfLZHI5Ts81nzFlC1FKF6SnXlJOspIpIGrpXZWSZODwW0XmZ64FjBnmMrAxNFtgQN7WQcge055FKo3/3ITBBcT5SDmpBvV8ojZMmXk21uJOhJWkO3TKZpMqfNAkShITIXypO0m/Gk++SqbLrFjpaGbTtsSBQvXEd4hM1iacz8A2Sia3qmPCyEKwfiu1S55nkiR95RIoHF1wtyfl3Qc8WJGJPf98fqOxt4+K88voqkz6dKZewD5+/z3ax1koftvUkgY+xhwe6H015HfEpeus10DhK7LhJVY52j/75XmoUg7KjvV/kDD4ob/VjH9/vQaXdEDo2qj9wh5+C1roS0k6ZH4wDXfwPxCo8dAsvRnTyKSI+tf1kKg/NdAOLCvQtwYq/estqd8bXfu4tixN6aD3P5E3k9uY/BDjqLlXvqkC1+heSQ9a/WZxD8r+PTELygmBOxccGuLOHHoyhqZ0Gn+M6ZsxcerHcK8GDr9AfQ3p3cSUHb4AHgAHehnKXgJHIiAVOgOw6W4B+Y5risCQugF350cqCJGhbFzCbTgbiGpD5dW70ZmAAOUNVMFeSjAsqERx0GWIUzeCQq8qllJLAq1bZfwbKGkWAVJJXBUljxRtKMSHRNU8gLnE8MAn5cBis+ZkLgFlGIqFg0SRWyn6MAQsKbAYHGC7ckC7+YZjCQTaOWgMS4D3/5Y1wRzXlbIf5iYD87J7DtMd2nuUSYHdmMkHamCUTD4wgXFeZHNbzMBSATkMAeB9LTMaCQpACg8jnytKYrmMjqBH6Fk+QCauFAj6Z4/PsjmkMhUrLvpTlVQHwW5VWclGYUHxdUJlstY380nzDwbuzQUIHUppU6Y1UApB40G5hOQzBNa3enGDUH8Ig4TWF0gubRXPRWavkQtQylRKU3KWhPpzecvIksTiqoTqc599UCiodBD1R6KPGvgONUAfD3/foRjfi6LjN8s7EnhfBCE2RY6tivh1tB+Pj2NdqD2PhxSyf1S+ZkfeoeB9jYZljkuMw3Fu142ParvlGuszpnzAcK1BWm13pznaUBDUuMVyNuvSWlacpTUcay8Ox8SIEaRttlRz3iCOifM6zyaHuKwh4ZhDi4oGjMo0tddS7gA+5WyDZx5C31JMPWqIbDFNHK7z4hmE2hJbRml001vI7lKmBaK+pLiyIzIm+omeamOi4i9AZR3WsovIAtlzJU5eORSzuwHH7WPbFfNaLu/CgcKHoF4cYRhuFsrVrj0LFqQKADJmnGsrSSE/nuSqLvhnN5XLPwF5QXSQoZbSlqMnwp10XUliwFF70ZBug8oKIQNMyJuzrJdd+GU+aLqAT7IC7PHzYTAdF3X2vGf8XqiUdb3ThN04USxi4iBEbgSQ2ILm22LHfjUTdsYfJxvtkSNfHqwEnUOsWQ42GtIG/zC7wgufZ7YMytg1VPVlLgOsLZG0qmA8Wo3nX2+TZ9snF/mLdPZmm59tNqsiZ4XuhvkB9vt3bIyKJpPbSfqEXfkNWWuDI2YjQMvZjtUIOyolNWhQv7SSDL1zvvI5qYRRj6mWWmkNLnsE6QwEdmbF1MCO0PJfYXkYihhy6RndEiuYXiR40IqzlEaS1g8rmlkL8Z5+RaSpSDnROXMomg2Q+YJ2wfeQsy5iJ9ctbRMqWkghEY30j+1D01yqZdh1SRYg7c3+SNmWHV/XF5Cns7eSzK5x+krtzmXSejA8R3GSKno0epXsOfDr4ttx7NrTH6M8Of3UcdDm++dUDiZi9N1vEfnI26Ylxz6qK29/ifv89wsNKsU15gU19XkoAP2k7GdRfFcdnaQl9VgpEe96sIVbnaTzeZA2otwH9B0yH9BEeQcF477awb+fT7P0ZkwrB2/EgxdBK11v5MCyenlEiRoI4Xcu6l8uXxRh1K19UG9hXm28yaoX3P0qJ06RbN+XYKtuasJ/h1V7n0Wf1HwI9oDXSUUPKbdVvNbIIdx+DWi6dUMKzWMtJKJAWAbC81ElAf+MmBvc6vnAZ8QKwAu3aePI6Wz2+s2bl6/+9MnTR0BPmQFCyoBgBrsxCXCS0YFTWcbGlrIGVuvr9XoF/AQH6s0GDpRMINqcdBxpZObIbwQQSqQlgxytSM0rSCbBTZNO3vmATkVIXntVCgfi+sJWohpd1oFZAqH8S66urrM/+6Vcg7QEAHjM8lqQMcPzk9vrpWwSYwPryWyabfPPP/+LCS76WA4ceYVeAK86NHe+2WyevHj227/9O/l2jkXAmWGwPzu/ePrs2ZzFuKzU3bJEGNNCpxiAw7frzRdXb78pNovp60W2PEOA3Wy+XT6eXL4txovLp9fLWzY4nc05WCtdnD95/OwFS5K3a9yNNDPALAQbHGXZYjo9F2RWE2h+w0wowmP26V+t1nJhEtD3o7jyxWL+5vo1qrbmksHAH+sRGH23mksptAFmhmwlsVF+1GvGhZqEiwgdu0blNZdAK/laZYTCwiFHKotKi32hxQJSO82m83/8j//gF3/yf8T4UAGavlC70wcwTXCT4rQBBJnP59hMuGc9evoI1yl2aP3rf+2vT9Jzm/mx9RhqVXVFNQphicaD3VtuanURhySnLx8PHgLJQcDzR1FHCowoPwZ/CBpodIAfQqU+1qGmAf9WD3gf1PLtXyy1hGGP7OzACIQzCaxMCo3He0xTKGL8vSeCkG1Yid8dVf8Mw3C54rFnr39smcXh4TzvQ3kfG/2gbWP72ARq7kTbVdZJnUCFNsqKNTCkpVpnEtQxjZHvadBKEwqKx/g98kAbhh4OYkLOYYHOntBb9xbedxqraPLparsmpcfErd9Zl67MIZ728FYRPFSwujzWng57T9uYqIj9lSMO9hSY2X7/IFJgnE7LYjAZfJcks8XtP/pP/5O/9/f+b1NAszbFAV9y7iyu9oBOzwyaBxsyVE6LCL8K6Nv2lJQlaG4Sk67N7BfsiuNVsHgTWUaATA5oBQUxESybICgvSIyBErk6XNQAdgLw3Ww4UgDu5AHjcmnQ//b2Wlkc5IJeOfZ382S+4AIJMzkgliB9VgpvbhfZbnLxxMbgjY22DB0lW47tYtPP7fk5G13OHsGcjYwQEJj705/8xnq95Kiym9trAC6D8ZgCZHn79vV/9P/9ShB19BRhGSKfyBM+mW2WT5598rf+J//marO7vV5dXl6OdvliNksXUw4lY0xczGWmyPNH544Vxee//OV6tQREIy1Vwgpg/5/lcvVnf/oLfIqgl+GD/gXmCwwV7AUmAbTXqi61h80PFOfnl3qkslpDTKPLQiCsIXm1irJzAeA5YoCYPF9Zx3hUUlLA9gWp+eir5XJd5BsTb8xmqqyfePvm21fffimzgkv+TVKftSQV0epmCqHgcfZM7Td5Q6GPHl/85m/+xqc/Oke7ciPyBvKeoa5Y9pLqQzF+7XuJ1aaKPv3Tu6GV6JklsL7LxaDZgyMFnvhuaXmHnMihKU+TZ/Nt06Rp8vGYZt4uykHxJ76rB8kZa6yXv3VNiUnAOlspcvxmbtYi1sAQebpouuKbJd4/5j2V5ZqPdR6HB1TjbnJ684XWbC2n1sTQdJV1GF+9HlqZWmTrjLpSJJAvAvbOFXcxy1l2uqZotZjao+c95d4s+ZTcD0/rSvX7EO5HFXAqQy+0S4CjxQ2RGRr4fydXl/xd9e0SMtDHFQmRXbmOxgfxYrZHc/16EwSdtamBRC6gVV2h1XNfm3masdCtyqJAWaiAnMZnNawrDA3cZmwaqKZ98wGoF+esW2UoWQ4wAH0TBiRpzBxfEjSQLW8T8tjwtsC8ECd8VYCNT1OkgXsKdznKRLFCGIP7kkOCGcAnzuCmYvhTtF0ikIhGqykLWSyYIHpG7hRPGPAqVAgsiAw3pgZkFTB6jTUAkXkjqcI240H5RLGMmbF2DbfzX3k1GaLZAXb74fitlNNzsY+SCZMjszkJebG5mJ2vVivxETZnNJypkfRmm51PJ8+efsYP5u45syW73Zpyx5yVm0wExFmdzMRJqBJiU6Hddqt6Sg9ydaI60jJwf7uWAhlULzcMYvBebjpQSgFSHaJKsz57omMTDOJLSSrElK45ATnqwAmuyog6WCwRzWGr0vqPBNScVQ/M+cCDErD/qBjVo0tgj5SmJIlwEH+ycHgYLaIew/wQG50WCfueqjswx8JepXYumPcIcVR9PaPVWPm7L0kxgKyDQWfOzoQORh+jPwwNeLtZn+sTqNa8PB7N0sfuY5ppIKgxboUQ+e6U5MX18L9r4x5l3F2msroBEBTg3OL3FeFW0UTp1EZQBbtLG5rSHJcdmvPh6Lw2XXWKx5VdWgYXIXY9Hdpne5k8lXsX2z1pFeqnDCXGFn+VdS9PiGkNBCZKjUcmnDqKcUrKCllCoJVzT6RUEXHuoQxJsc5DJAKEy8NBya30gdgD8TxD3C7lio6XRnWinHERXT3h1LrHPO8TjvtJHO7kObTurvVONmVCF1Xcii08omTjwLMay2E5H0KSBpHziQ544oGxaQjkQsNQNcCXkVvWvuIaAnZUPn0FDbyJn3C6ujQ8DFIrIPCqKQNSVYAS7S7i0gJw8FemCRdqYbEBWeIcIBonMK1wvgFRKAhrga/sEmMKQyI1rE08dMQD/bWFPSbB7GUy5RTdx0RKDIfU5Ju+wRt9VDwG3HsZAFwTntEsUDLrmLNxyj73ygUGB/tqUSvlaPsdCsMNCaNiamPq6XS+wAAgNWGXf2YSdAgBw/2bvNjmxXWeL2Cx3TJlge3BsD0GwUJOShmYPmcEX/v6s+KB3AjM2WTSmOoIc/nRsNyZw8g2GAbkgVMmBK91EbKs3BSiaM5f4M6lGJtB4FO6UBXKMX+ngK1FQmko3yvoFVUFDeNPXoL9ca7neGHN7pAhwd1LDHWpoay9UIQaRmeWCfTLSBALXelb0yx2CH0HRyLMGLUNFofUqQXYEIlxdZGsR1V/90KJk5dRstqhojz49NiI8iA1PLQQDPr+OoMHHeM8odwg/rHAEJ5DaI6Vc6f0/ndgQ7fD5SwbNeIf+ghJIRwLHfqBfAWHXUPk6aLpih9W8p7Kfwf9uYtnV/yeywOFUGz8ux/CrttWtcclvzs5mwJ0ldUVH8sZh/cz6rWOpXdpPAPAY1CAB8jgcsVJzluKNPqYIISd5vt2D5UOahhYISfjHjL2VN0110MwMOloWS5Pf3FHmSBMUEKoYIiJUweK7VmGlDuQobOqMQyPsaj9DEOWfrKPqQ0NhH7RSIki6uoNDUOCMwgxUa7qFWO5jcD56K5HZQaXAY5xMQGvZdt0NHVGhtZ2XDpMS5BQl3CnZSKrgWIYiIfYabgaBMePqyglhMPWikDgj9wQi6zMJSbCj14H8QQAW6S4eEAlKkNpftij6EHjKgWASkHlkDn5PSNQmBOrGO22bX8M6ZICApZho3iNhCsjGLbQ4L6KEFz1dcf450CMbqyeVFumBW98TAC8d+Tow5IAluHiEXSbzgD5BnBlNXH6sKYXRvMin0Nsq5jlL7/NN8w/gKVlLEhLElXQmBIE0yGU/aA6axdTnTOm9bM7ljj7oLx7Z6nWAtVCxbDSf9k/rnDTBpoRTteFwOKHbNKgqYabMknlfBKwlpL+FYVkolR2JhyMvzU5/E0hBvrl7KWAEYgdAW2zpJBE1WWlIHjGagl1H0pXeWZ0KVVFh7IptJREVGJsDMSnvIx39XDqZ4PbqQw+0n9/NKAedOy6V286xvyHnT5Evd+JBviSv8PLe0xLGeUuQGNZFUE38QunlqeisZFv3G7t2SOrpHo1GlbyAUEjNdhkB2TVw33mB+IR2TjsvMtx36/18uaiNrWqO1ntHkvrajvVPqsxfJDH0BQhcCpbr/7A7FTc9Tlk3B1Jjiq2tsqiKbyrOpTbo/NQVk+NAo0X1MOtKUlPzEPxafbVnkLfQ1JDnpr+6iKYU0Y15+NdSjm8QarXTmdXixKsHM/mIEuQDAY4nafpdGIjzRrNLbaPNYKeMEStLARBvFomCs6jWPAZziQCjgzZA+0MNBpwtESHgHtkKVElhPC8Ediji6Foq4tR0LH5VIroxcfylM8ICQrlj2gTHJwq6SEDgepeAlZbjlBGagTdBq2Fb91HRtgd00ArmBUF0k1GcwC3OfuApQG+MopggDAM9+tYL5tXUEZ2nSc2xX0HJqwxPpfi0lm2fQb/dHwDNE+maGSG+ZCmmx3j/eMVS49vt1fZ6Dad8sJfsNhAklOeplyE3hF+tHuSb6fJ7AojhUqRpsF8hEFw5GbSQzhauUhDSNKs7jyb/SOBBNntgiFspT1xFgdhatdPGSh1B4EAPyxUayKlSKmSZrX6E+s6Np0YdwlEFv3zIgiZMLzMmWHQ2mbGxWRice02rBGnm7xQ0uQ1eZg5wHsKG8eKcTWrbFFzmX929eBRfifOhbNHr32cXg97P0SYPe86Sfzc+FZWiYNHiz3DQ721quLv8dnABv28Sg28NKoTa93PuTP11FJ6a9TWaTpLduJ9h+rl3MnlxISDPja4xA+oR51Y37uRH2ipfPn0cQpeJH1EA9JUbte6oH1HqTFyD0p//1VE6lseJhR6pcdwDzFOFj/WmH8/H6kQtWytbn+FXBOevZ/Smd9Zc569qwgXoJ95Pwc4Q9DPIS59OKXncvqjMsRF1MJwODV7oA9VCzE15h8fh2ngRP3Ve8nA7KG5WnqkQU8BTcAl2BJsbSPegLEJC2AnuKZs5QLPxfi6PmAmGKkRYgLCzyW60qAx2E640HAm0UKTysuzCBU0lGcBY0O8osXUEKWyWL8UnYesMM8H/iZdJH6JRoCVXFaK2FMM/y2SaiESv7JEaDjcyDRMzaPoQaplIXwyAs8QNs76NmgO1iXKTAAZNwL+ukQnbvzTXARTJihJm18a2MV7Jk3A6xgJSJCl+ZS5FDbTkdMNui3whxH3LGdXH+3AI0sG1qovfxpfR8ewltyqIIPl+iSDeRyZCHjSa0GwlvDCiZ2OxIAs8tknu0TlU7KiGgnmMwymbPFUKqVxs/9GLg4ikIaMnRNJXbI3eJJ8XCaVyaqHsnl4VqqXKBqfOnByzX7MZwtc9qztZIwpQeBfymA2AJ4wIJZCVHeSO6/ORMveme1jwvdDA9YVHkxU76x3Y/eAkrgYnT33bvJ9p7m8Ll3qfUDVhVq+1693V8WCNPVA1y5AvND0M1P5SwW+0pDedPZ7SmDPr2b37BP6reQoNfSziOuejYfiEfd6WvXcNUsQW6Jx2PMxeu0CBDGIV3XtXvEe9Om5aqRN/TQ5h5FvT5IkZmfXat3KPy7OFRj7sgcOzULjjCHsHMJjCNTiw2P/2H+tRXpkUJXxcrbzPkOhIeCpFOoB4pvtGIhbA54xZG+lOTWy2bKncijpO8ZUuuro5XreLpo7StKbrausrt0GNKQat1zASd57Go1Rno36rQvhRN7mZQZ9lBz1DWW3m8n0+ub66ZPHjLsDN7PxW8H98ePV7S0bajpi1EtLEI1/fJIugAyR/gvUKV6ocV8qDwKjZZwIVChvRtka4mYcxI38BjM9UmFRin+mEfdx+lK2gt6obOPzKatl6bfymlcmAXmntgywM0uGXMxOUJx5/ZBZzMzZnrF/Dvu1o2oZ5daiWPFhm9NixkkCWzYAHW3TCYsHtBuPqQpBKJqzC/Lx9M1kNvPBf5z8wfFTDgWjkPQNTvDrHYuD05zlvfItuhamT7YJJweP1ul4Pi4uhO3HGYeCSTDD/4acbVh/wi5Gr3P2/bfJB1cAKJlTC7T/j/nZKxLsXDoZ4fkvy8S0ZXJaowK6mT1AIogB3tTAdK4C+WdnRDDK9a30gXqkQGitbU1ZelaMsquRENPCyqvVFxMEoByerFegCYIoUGYiUyJSGosH3HaQ6jkvYvTo0eXZ5cYa6Uz7s2ojI45cWJG6XV7KPEi/leWgkiVSx+UJJZVoJDo1eqGPvZ9uyK3W5+rk58nh3vWtDAT1AOqHd/T7WycY9tz19uuKH8bVqE6U7YgGOt6uLs/9pY0atruKJ9bIGdV+PWPuoXPwXWm9IBgkWCNz4OwpzudAwx0lNjg9RERH28WtFoePFulfvSaZdNVRVpO4K6bU0mA+js3u1kyxDAetEycQ7uwH8RqAWIQQrnUE4vVGrt5eeqzCtSLv+lgr8K5s7pKvqaWghruwG5DH+XdVuSlPD8suJs0s77pSzRJrMcNFrWXk8T55m9w+xpyogdB3BrcDOaCNyT3GCyY+sAyixMT7yH2scuhJvj3s6j+dfv3NV//+/+n/fHFxhuc5e9vjJ6+NKIvi5vZmPme9rMauLY8h4hKcUrDBPyE7QUVc7oUMxZgnCylFApJdmTTqDuz1dMgUtGFuQuK/T1I5ltn4OTdjo60zdcqvpYstmeQMY0eHGY6lSkgiL/xixCb6LMAFaArSgkoZpWcjoGzEjp6rmw1uNZQvAyiZm8fO2TjdLZe7f/SP/snjR484AUzw3g72ZeMbNr/Zbjfr9Xa3wE4ApSfswnmzLqaLyeNnT1kVzGyJXNxTdhBaX1+v0tnjophnxQ2OO3jyc0oaVWdtNCP36+VOqjO5VTo6GucrNt1cb9hXHyjMSgwMHiyxm5trDZWjCpkOUilVpmxiNAdAtNC5ULiYoFcD68Zc9VWEN4AlmXpVGOSC8EZi8wQWp1b0OPSpGYmzi3OyiKcVrVj96VFNJeNBItlIl82xaEEzSbJg5AokrkTkf+//+fe0A+r8jL1Ep9PL+YLl0mfsovTTH//0R5/+HjMc2m1V7S1zRZyVzy5/Kh8aHxUVCVGePrJG2j0jKPbj9XAa6G/uUE5fYweiUwLOMNxDVpdnoFQhVzMQddRm4g8q5v66qqnjg1fd+N/9d/49fydKVH9/qScFwZvdSlUcM47FvWXcoqaAo49tdlIoPIyIBzbNmJB0UqDLXqRWzSvI00yKY2qytbKK6eNwrQjXekxQCzeZ1zhAX5PHOTjnZvaYf5NVnPqA4aYYFO0S9pRykKut//TkHZLU1TeG5D1CM1za4ZRHinyo5AOt34FplL8Kej+rnvp4lj1SpIJ+ZRZeXIxRz+bz/+K//C//g//Lv8/WlqQKvumSo/ZCe95rMFjP/nYrOcHDYq23EfIXHnSChTa072gOtEgasJZLOZQdTvLMJgCCBBcSUiRXCQGVRVIqgyCmUpRMDDflBfsqJDyt+45xcRbLut+8luqKnxybwKEQSib+24g3omxegNNn51dsug9LpNORupoGGc20axAOOmz2yRFdU61wEJxFI9gtWinBCDx3Y28Ca5CbAjgSTasmOBgAuZFaw/ZZ/uKzZ5vdirXVtkDWgbxG8MHEwHpV0atBJclCgiUhj60Vxt5Yrjbb29tbqcL0IBUiRz46m88uzh9LBUqR8k3HkgtiwopVQI+mAFWrcZVRFVVIVw4uxFDtxMKKMo666Z/F2C3nzBAkS19KjO1zicqp0sYMe4Ym4DCz1XqNeoiEJLcR2dX26l/6m//y/+5/83c5XUHmjTLrnyQOl4oOD3Egiq3oq8+YTGHFd6XVab+753f4zhxcqe9cBpopatgjcj94m1rvlACxHkIpwwVDbs/VnHlwRBGPNMdlHanwu0i+x69k0EyQy+t7xzmxDkmapYTiQqCp1ZB0SkD+juoD5czhYdYgh/WDqjPwGc8AkKVKMU7GwnNyD0lEB3ZeCkm1GI+/6/2h+Z0gR62ioX4E7lzFVp41mWpVPlqWE4Q2OUofVyTkqsngjwNZteYdGFmrbC3XexCgVuLHx2Ma6O8yx3IfvDwiVrR09LTn4j3Ae4nfyzRPAGQZIBZs4yKSwWbwLsdmGZ3QowbaU/az0dgsBABWJVmYLJZT2NpHoxUw9CagKJ4liuPDACRpSlDpbgWMfahY0muoWa8G4UbcQCwUsiuH5zQIShAsDrmGmsVQfJR7zUj/ju07lVtEY3bc10yGpjiMhzgyUq3KgMYtwDwCwF9D6Wy/yasfAyDBADD/GfxwWBk8kdj6VWP0XSPs5sCDC76VIiXZbpnmGWWpyGXu+5wprAmD9OrNG2hVPXnTCLwDzQnhSkMBkn9KPs1UQLPh1N/RpmAhsS4Vx26nnBZAksSW9pWd+jEBoLmJxUymkM18qD1JlLL+/+z92a8ty5beh63ZrWZ3p72XrCrKJYmkaYqCbEB6EQzZMCD5yS968IP1n/nVhjoQfrNEGrZfREKUSFMlA5RFEioVRBbJW/d0u99rrdn5930jMmZkO3M2a+19zt2598qMGDG6GDEy54gmI3UiRZ50IgsbAQBYQaWMUAWKErDVsjoMVQX5z7+EpAKTGQ3ewJVX/TS1opynI+Qu0kF9MCFhUlyLKQsbM9irM/XNV/TEEAsDn5NOIEAcylqd2slwSU5q1go7M7bGrg6dOJ+BH9ECZduUaVRyaz+SaiE6K5ATh4rfS5gRHrN2h9ZiL35Wnurk9F6qQxEy52y0QzmMx8+yOkgo665n2gWoWEsdeDx1eCJCxUqvtu6swvyuDuXjKb8WvnqHIUy5EcfgSrL2WvA2pC2jc+S7gVb2YsuiMGK3rYw3ULkxupWyIp370AOc21QZUm+GDFYi9Gn04wNf1ezpsx6nRk1wT4aawhytdjr0YPaBO3Qb9J8+PgHPlm+g9flGA+2Y7HhtR2D26X+MYg9K02i2nO0cq0CTjEA6bkUHQcop3HIQqJQiOeUn7969d2wZsZ5jcqI1rbvn7OU25ioCxWYuUBF/6OB4jWFuRXgB5QoSw+Pw5zFIoBpqiMQKkHfQCluCRELa1ddgXLDWn7NpuSSaxJK3br9W4exHyrdr4TPqDDvG04ULpXUjwaoa5CYRVdURKBEUz7+X+Mkz8FkOpIh/OwfAG8PzuT79a04LUB2sM8avDoOidAXjVsudCSCVTMLf1yJTv8mbBonhajq9xnr0HaCjkEkGE2NPTSooaFYeJtoWZzbnq2J8XViWgz1V1BvMbAWaelOqLtgYFQKubK8ZzWF7ApdqbgAlxDhVxOlUZIEuptTKSOlIRMpZQ8ywyuqK6Mg6IS35J6vyRoH4C+Vi8VJGs6XBJk3jzOaXfAohqKToilkCmuw76gGVXCI6gVRMVQNkQbAJdxFrsw8RypEFJxQQdOAIHgMIn0TRQzwz4/kW1RvDP3DO9lTs+X08yNx2hF3jl7SN3+WyaGSamuJH7aijDQl3g212wzEi8nuDGbnNGUiT5znsliXuSRS/kr3tvk+fnf4FtyR3H+1OvTbtrkyp3AR1sHJh1Z0abYxxkO6xf2jDCyNRE0OBJpFrsNSeGdYmrp7ViW/GHKflGKwss42MtIHSNv6hEJgjIqSUNQs45weVjrYPWsFci0PNchb8bM+caLDda9vQv0H1OfupWyDaVZ7tlh/TzFTJaGrxKqHgKwWNhFYE5xrbJp7UghTW0mg8mf9EY9xESurzV0EiLmKIfEPMXSGm4ZRZhLCJcY0Z4v2oE1CwHIklBIhFFzjKpHRKxkUY4FcXAwklHTsCtz4o4v8S4NVF1lxU6r24K0CRDi4eW1f9qD8heGCp1lU4jUH4lBiLfRSkSzZTBYEFKwtMQuGhoFZj/BrF95cSrBF79fDdXF4rZktQ6o4VtXNPpWsw0au0qjwaYG8W/6Cd9/FU0KwSCXEXQ1sDJatKd0Jq9atoVOksHWQ2nSDhojaqDmVV4LNwxDaOKqMrJaoKhQkHJP4bJXgjROwFclBe8SEfJOJs1khH72BnGOWYjzqCCooYqecp5oCpAsG/aMCTCEglXU1sfqBVrJ10lpPVyZAEDY1rUGeCU19pG/8z5PEssLdVdm7QpRSlezl00R0GyyJIDOsD3/EqZbaHafM7iT1sq72N8mA2i12AKva7tudxpmd6l7+Uyhbp+W8rLnHd8arDR+Qy12y1gOTsMI92P3UYvyzNopVw/48Vohx5BAL4GDXGryfLnJES0keKAH+MJo1+/I5kX59V1R48Dh3DKNuls7/eWfEx8zmDavYWlpbvRRpd0Fmj0dRGHD/eYPRS/5OkK7rROHfj6OPZB2+QN7PZ88LLKc6QBqoRcmQmRA2TK7KcEs4ulne8F3vBG5mMNCsc451axu8VpTlSFzMROxJTBBuCUpRZyaTUEpQXsqlMySIWXR3JiUhFCuh8FlcyQE0fGXLs/i5oeYhrUAWUleVOmPs85gpQDr4s5pmzYl3rjRS2A2LxvlefpHAYNhE0i4EnJhCvz3yRVehODSRppn1+2NBG22tiLW5wdkDi82isBeJFYWJ6PnZLAZ0HfRlXMTgdDKJ7UblO6m7wBxWvHYNzx2ofYa2BSB94YtDthK2B9NFfDfAjF1KYLr+erC+3U+rlEm3hQ3NoHkAVdghOHWw4KGJSQkL1pwokY5GHgU4yhgvSFUmiLw5nhC58DjHRJRNn3EARHIGBmpCTGOCoJGvwBnbgcIYMO4JiOvUtscV0/opekdcxUQKWWwzemgqa8s60a1CJlkLlEZoAUW3SIViV7rwaYQ9W710pJ+m4u9MMf+uu71TgowDL59t4BY6j6uA/7vdxT6tkp2wL0Ccy5AP85xhwgL6WHa7pw/1utqtSg/TZbfSvW0d9R9D2WqNPn5rSPZlTaOssaeWoVxkF1VEeKhf7jAX3hpU8NlPI3Xlh6Zg7aKCGx9pzm0U4clVasD06GVpkjpEI4NE8hwnbFSrxsyYl8CHSDyroQZnvtcaA9GHjw3mAdq/czwhDFthr+iHi/WVmX2+9HomA9T8IIkO7EyV6H3ptK6mNdBZsUh+ICi0JYtg2hxhZcwFEYQhysEh4ZpmcYWiWOx9yUUSf4sQ/DsI9oUGlXJCoRMJ0FiPnRFLVR1FgkVU6DrEJbglQXMQl/sMVXolGIHVpEo8kW0PbQuAPnhW6C5kAYcKAaJvQFFIqQJBqwSZwB0g0AXQsKy2wDw9/sOGp+NZH9JaA8F4yKH6dgCli+g8a5wYVcn2K2H0OdCL6J/o1dwJlsMQ5zoLqVWnxlsVk7apc9rIZ1UjpcNLVc1slPmYYGAWuCv2/PCU+icKiLMPwrFNlaIosWnxSm4IT/TX1BAAHgmsXXSw4iUYSZKjNlh1Uo9bGhY1qq9VAxomq1dW2MsEyknEWy31HttQ+xM/lPxsL5DYd4QDJq06v2whZu9tyjLis2RjOYxj+InE+mnFy89TNWukTLwFXZXiknpW6FKAqWb8aiUfeDtXlABoHIxBwO19fKti3BDekdmTH9Ilr6lvnRp8JvoGTLVRKCq2E0K7viF5sZtVgPjzWPlyaeeYEzGvVzAWtxDBnhhjhM4zTYpkAbauWmGVLHbpCrmP8oGR9SrpowbaU4RqNEtv2mVFkQuqQPv6+6xkF7OBpffrgfd8BMHw7+76qTDh33CoVbHdljfU3BIhe6S4c43HSODkrzb/74cd/5Q//cLL5ShHs5Ac6A09fPP/qq2+IUfFFn9eb5TcKw6Y/idzBczzVCPEUfPqJZSV0kiz+achcOa+68cY5ItQxWX8r8bPvFcgWD7zJ+mtF1ZdvA+goMCiErntMOdIBNCydSoh46pVSxuE1y+FbkxBbmogaEZIrbi7TSZvvSLRWPcFxyn70K7b+mX61XX11cfnDlHeLdW/OtxO+6TWnfEJaTyQ7sNiKm8N4zrqLNeEgmhU1ZydVdsTnc8qTDW8UQIVhpZDKpRV2Z5IEe3nNOyAtgtmuGPufvEVH9UDA5F0C1HSPSm8LxBoakQR+1FrKJ5Okiy0jJOXj5BjaFqhwIhOtIdsIMWisZqDxBYYVMx54nUrVwqq1/iV7KmFUMQJuC5uPkFUKgYipES9Vq4E8OcCX0mbYB1thBnfV6Er5PxUGzTx534PuKDsLsYAoJMcbIPpOcLANneM7ANy/P0AWpCSsV1imdW+2nzwW2PUEiIIWhwD3rhiO4jijA7rQ7tX4Zd+9XxL1puP5GcXm2Yv5cAXFMzyE9NmzT4Xx+PEr5i9Dd8UDhYBoeLd6Aa2Sx9m8b6Q5adXzpZ1Kpu+DnDlLYnSLd9R3NO1ZNO1m0vKcbrQeKE1MvfqauJOo9LQy3YnsGzU/QAqUvm8DJ5R6B0DAYMI5KxuJLuaVnFymB+zuOVYVd0By0QmJUscGmygaQGjgkw3ksq6dVSkJIeEIkhJeMinh49N9nMdzeBzMhon2Gjzq1dCtbcAGQidVA+dz9lO2QK0FI9Nq9ZovgaPwzBdCe5bEsN//1Z/+s3/6H/5f/9N/49/4a5fzX7Px/PrieyKum6fX/9Of/pP5gu83OWZStEk0r+8D3Nxc6y1fR36YR0GvOGppCretkjKa5DgoQyJpCCJGVJlw1pdKzThbI8eLSq4MmWibSx+mrlIhyQTChbYIZFU1aSOp4ore7LpDnOngUGP6hJiL7WK5XLHgx7trmlrYHPopgpZ3HMCEC/VdrbYoSB/JobyG3r3PvhAJQelaiICdQG0hZTlCbylBSp0K1OJTY/BkdZGEwERBMEuNkI5uWiGkiiiBmdRziEpxXq3u2QfUevEtNnTmRQJqlyoIYcINcTIwPQ1WywB2obUBitBKMZfoFFKkcuOgyIelKFUBAkxWlpaAXKI89QLVRUFCWnoJJrfQzIa5cVaEzzvNsgogfxeZ0HnKhktP7j4sX7/+6e72A30ttjWaz+Ry9FKpF/NUUXVZC35iJ/4+h3JZZ7KWFuDdOfB3eVKmcXVq4M+Zj2qBjoZq6VO2fKtwLyD7RyRK19lLezzCmHodz/13jzK3YqPqD9ucXVIzjGct3wEIfRKQixq+QGmo62xZnNOBaLdJXLpIzw1riC+U2D1yO3E6FQmnj3O7r9zuh5Wcy3FrmMMkjjZVVbLnWjLfg3pgcdatk64ht6xXme6kHQD2Cc32QW5jPiEaIp8HmFOU+QyjHV9ajgGU6eM51ikP5Vnik8ZMDuzqTM+S62u6UcxNvJ+DIzIzlP85HIWIJ5ED+8n05ubmv/hbf+s//Y//IyYC1sS7/l4ssRPR1pMnT66vr4E41NMcAkHq4ubtkyc38SRzVJmiwAjxHPBamjTL0kg6DUTCkwJGMQ93DyCwIJOLQuUcEUcmHRIHgV0YJ7m4UwEkzX+liRrRWcG+EVBbAA4pSuzNxvzKEFsTfWvE32LoAmjJ/4QN7y+uLudfff31an2lQD/pqcX9kLmLYT21LAdSjcQrspdopKICcOcMUdqKgaPwFTs4VE+hLGWrL6X07CV8oIAFupG6vfsgTOupDxOw6/+K74tFBFzpcjG5ur56cvNEFUOmz7aJDBhyI1ueJU69A2miNIcIUzIAuzNwaQYOBJV0soEfciU52hqw+4SmaJ2EDRsfF8wuUW2k4nXscgqQaQDaDAYsT5tNr/+1v/ZX/p3/9b+jiQA1X0hUfwnlfYRaVU4gF/SWBlV1TmiZrIIffT34TQD3IB/sOTOqHg/+nB+lRQ2paJcaPDL2t+SQHcUFqJMPLgaK5t92h9yozw598B21750y25fu1GeAf/LuPnYfHV7+Yg4qM1DHQbqhwk5jQnAuo+nbXO3xfqSG4BDTFNaeAYgqBF4m7lMzP1BVC8vJj94hU3xaZU2bVBYLLcN6pQGAZJKq2g9Sowdl/iAat5hGFbK5WuU7QLbzDlQ1RBi8NHuJ8zn9KVugavqh1vMzI7V/8nlFoxyM/TtGUzDFa6x8VWo+u3z64hmBHREz9Rbpdvvk5uby8hIOUGkR9vqGR+F0cR/3qeIwUtJA0SB/ISTBXQCc4ghHXR6cpYPRbGIHsmZmDuJirQWS7Ij4fHZOp1SiYuFIRDw+UglAmEkOYTTa8wVdLZwBrGkMB9OmZewZCjb4UUWWsyUfpwIeswZavaQI9vKWSRFtxq/Rd9G6RhaIrUJgjEwjTHUNya6gwvekmoSrMmiFmVn+4k8Rx+xK2EmIKk32VVqW4L9W/tDr0LA5ITC0/joBH2MmdNZr3MpTPeYU1AwOP80nXnoQW7j4ooQ1U1a6qzaqlKWG4YVusZSrPlErQ1CJDqGUFxNE2SBKB3dxtKSQmURaUsXHJBKrtiDWx0SozVTAVi82b6Z8HoxqyUZM2DDhcnF3d/fq5as/oJKb1b0aJc0kiAOVqURb6XzKkoWQjh7U0C5VoML9fP0ELNDbYJVuu7atIO3rzhPaZU3vCa+VY3fgjgBBP4YycNqK9dEGZqbqQxuh4O8Qysi2GGWRRlM1snUW/snbdQBoLKEb6mS03nAbJv+znBA2jF9qMLo3VhKNTJcV3+llifWetPhlBBKl+o1VdJQ2IKEMJMGhUZrZAhfbh6xvaDLynOrYo0+oXbIq61WmS5yBdGnSNlrDqu3WyfMwYecBbh1rB9vyToGUYzBl+hSeJe2hPEv8Ml3yPE+aVhow/B4ZFXF1baMrqHXzKiRzgnCTqGrBShQCN9ZbOxhdv379huhxtWJpuyNOYxME0zeYz/U5XG3BwrH4ERkKQ1G74qsQMN2oQql+OoWjEXGBiOV8tYKOJhU5ikqqV9RmHZmEr2hUYhJTcjrEsXqckiW6V54VORrMY2ceD8BDZrgYUJaywYwi1FHQSZ4+gULZiPXnCqN1GA4SXwJDI+0rsl09l7aTl/zBQBBZ11Jg4x36RReFCsQ9S6AOhNAFX32pM98ocKUcQIsilUonNsv5KbGVhYK5l/So2yIyYm91NWS92ZOnz5mbWS71UTAtUvL2rGqqKmSP6B+h5rQTJZNLK0XkWEnWlkF8CK4jsj6DbggXMdIUCuv1SUolQcQgOApPLGVT27Fip/5hFPpiTm4gNZ+3UVJQP6MHoI1W52sqQX9A2yhdbO5+f729m+Kr6hWoh+MGQq515h1tdBJ7sjonAXEJsOD7DmxRkVbXfSQD5aPeBCjp6QV97KPjOd/zWzas6UOM8pYSD50tbzlFYubfxI62bu67WMnusI+L8ux6n6CKwZ5rH/9MlnUlMcKjM92+xFGtXGM6+ldyuI6l55Tpmqx6JtukDj5nrlfnsg2KJvFjddcBSKoYWm+30L3kIlznVeTi8qHUxEycH+gS0kLHhoiseGdpRs76khjGDJKM3+DQR9vGz4R7EyNV2stnPEJo21eXQ/nsxT+ogqdYcq8mnxH6LXC84QtH6mBCqaCOkCRd2EGhYI9YdLPk61YgKZon/lrdkdAQMuGVgrlA1ooXbUWvYE5hn0I6dRsUhWk0PQk2dqQJBUkAsDDFavqTBolvdQ1lDI/SwAJsDoIpKBc3jpAaKGQFpMSRpsO+raJilA+xqqAZiVS0yQyCBSA4CC71qE2s/KEQBCpmLOlOqAtAH/9KMh3ZKucHs4BK64Ik8HUVT7/dK2vIaDIdGlllv3YBkgf+BXORysQgWCWTmVdoYflS16ZQjXh1VguEVDVJ4TUBx+UCqF5Bq7PlJt0ETzLA8dSHMYQl0UEnqlAkpdTWcUCFMBATSPXVQp0oDw5Jy0RrZNLVVZgYyuYTSlKPC3XCBTd6a5wEnKmVP7pMVp9mozGkfHibJ6TU4wFLr1KUqlfKmj1FtSPyJUqt2Jk6u3b5Z8gjWiA3YKPNMnxAF0iObcsgHeDdURQajqc8VjeJDlljjNCh6GfQQRYY06JFSzjZ6gDoiRcNnlFzImsTrarG1YPNrbxd/UrQXS8k4VQ07d7b6N5YxaJ5jb5Xe0y6s+ctdSyx3Q8OTXOlG4o3pUZtW9A+KuDJfsfVl3FNJA7Stuvb7pWWtU669/Psq0ur0k1A1gSd2zo0sZ1vyGq3Qm7fXNTJpxvY9roSz6WN7zyU5Z9KergWg1qObIVBHhTuvHgfZkd57A7ELjouoxnTEXmfA6hAmiht/S2R2mzxE6Eir1YKWZEVodyMUWTQFVqtvwQ8vXytBxDvvRJX6w1UlcCBEWUNRJMn/owQjrFnFwEBLClilFxKcaqWNSukSyGvaONBGDgwIyteClvBA5y6IIJFsXhIEFzMj6tDYJUaZbLhTWX05Kyaoqe4q0PAV7cAiCmaU6YUWWSpIxTxcyxEEbJeGFYFfRaWduqcbNkF6MYj96GSeJsLasNRFRKAAFUlkCmtfoVmJ3RGd8HnLynQDv6BT3WlWaiEHHpirqdYw8hKkpYGHJpSsBiq9KVgmklQl02TFtIBlDXrgZCedVJ1NTkQsxASK7bqe7gKiJeuhgtVsynk9C8fVbkB/moEb4rMZryrIFR24/EaJJUiyjUjEYZl6yTxjK80UKbaSk1hhoSclu1lI3jK9OiyRmeW/NDHuZjgsdo66c9D6PleejpMYEV/VCa2wpJKUieh8aP0tc6zH3SOo6hWBapfg1BszKxe2Mrx9IAAkw0cUqermCYA3v9L0aRp4fc9f9rwNqTJfCBfaDieT8Qq4/EH5JdF2Zb8clUtZX8AqdCzTZIJy6KehqmjjMuVUUTEA336tPnlinS6SeCXv/5tNCCZSZv/KEjLemdvu1FqlFFuPd1HHtbI9ulDa8Jbv/t76nuofblb9SXgxhFcSl65MXfAeIxByUMtoBnpjB7b0OykLFoWKooV2V2FzDuybcyG4AZVlO6lajA5KJuZ58RB5IciP46U0ApZHNE0kS7PgdNuqYB/Pj+uBfINFE10hPDc2gqxHIzBZNe8WhNOVOVCrd4mXlZA6VXjxG0X6xX72CgAczTLKKwItNKH0JKATNGbmOkiXfmTGMeMIUxQdFC4q61dIqeL4rq4OjQ3JAIskURWfQiTcwr+CpMjPE7VEWaEs4qTlePsuQz1RLzoxQE9UHiRtG5GgANxofJhGxMmHmYk4a5emMgaWNZMK5ig47Nc4goDD3ZLgNk7lCUDuYJzDmiTUZwNRZ20QMoc6gpHxFytmxgEYVBYmMQEqYwIZwJj+mOA/ctgNU2EMhKv1ormCSohQpKUNTeJzRa2oaRAkikMp0NJzCZ0KSEBqR0kQfE5BxXAN3h7GoCQVXXXTjqqdoEEB3HhcGV9tTlBSAKi2CVBhpm1AAgXtV39HvB0wt5QtAgzHfLDMALl4ECJVp6sQZRUliig+ahlBA3JubyRaNE3yiMruf1HKaFM91MMlbQqMIT8yy0bNnm73qeZDeqy5Q4V3lanFzJSzzZaQDL8AVXs1f2jFeRafzQNhgTPy5FauxH6+uoXtDz2HM2V29DZ1a+V343319MdElu9tw6cALX6PX2YId3K1lDymHFAGw2Q+8FBGJWr0R+baWtyHKdaP6+yW2aeE5l5o77Ay3YJtKj1Q1e21KStQ1a4LxGu11ea4SPRhF9ZL9PWEi49Qs8ak65MrQUDYbRXd/AbrkUHwQ40pnZtbduQFGOZcVepCyKGbo01zv0FAPttiuIi1lp9q5ac/xCRnAMkh2ezHwmdSF1dP7m5ulmu7tickuD+cn7JqLJiKv4vXip4i+3rI+InsoSGPy9l0XAyIRjRmUZsgXMoGqtCLt7a9AdfpRWYujHSzVFhmMQnQUybo1++AACv2Q/qdWy+llx2+1bIqqF0c6KipDX4CmVAPAooTcSNsxYoUR3UZp06cxpfAeFrA6KYahF5otVcB2PYP8DHNSajeko0SXESorpJsx+m82uqrPhY/yRIcacsCx5n8VRGJ/7EhveKXUqrkY2zUayHINKE6QksplLHusgFx4cVEL/iUEcMyvkrC0BT0NU7gyV1Y10+MbNZwFm10jlbRaq7EOTNlyrxHMLF+gtosbkgrlw676J5SVUkrm9EsB7qtWlfgq6IXy2la4izSAtGrmY8OChRrTKCUYGJDQzFfP0FAtaTn2RJtRqK6pMIGv4Xjjpgk/nqYnuvLy/7HWTeWVdlt5dbdki6X7InknZV1bYulQVTjawCp6i79TGoblmBZDS3lC5qRZhx9N6VWGTgCOJAKNMBGaZts209qfqeP214G9JmPwZyKJ8D8P0MP3LGuGWZ9juBbfOPqW+F03aUqqTr2o4Hev2nIA8ZfXqWv/5BtGfM+xR7WsBw2+2p0Sm/yIVNhpOlrdr2Ka3UUZeWz3TgDIsfLPX7P1pfm7GsbWR3wPT8y0hOlPUq03WsR8mNFN9GCwjnsq4nqhys2rJOZBvkWc8sJSfOwr9kAueBWgyXlnxGpqMifci5NCf6MD/DH8wC42zf7zRREuc6LwVejkYdyxB3Tdjy/4/+6P/z6seXf/gX/mVF8Rfbm+vrb779+t17XgnghVJiII/2a+OfC17/vb65qQTTd+D1TAJrDr2nSVSoCJQjhUoEXhqJJ3Qj2NKovAIoRWOVUoSJTipYdEJBoNfHg6lIlmUdLMKZX/A54smUfS/Xq9WUEV/UVLjMvxgAVyhKTswoidII+4hSNRuAVnAjauRBz4kgG2WgUlUs2ZpYGXFJf2DoZV+Uk16qIH+wosujXSm1GkozAD4sV/UTPzRArvi416G6iKX7C9bQksQau4iBSiGxFJqAfHDVWcZUNaiizaTqqTqYWy/EqtuF9eOfdjhVr4yx7xVtZ+VoE33eIDTJGpox0ukxIJcZHyyDZF6rpYPE2WG3VaMVQjcrKZ2tkmzCzqN+1VhfjJaiNhW687+CiIXs56uL5H+VvhS5RNqgoQhhS87KqJtxecnyoks2/VGREGQEqoeX/tmfff8f/kf/yXyxuFxcXl9fXV8/v3oyvV6wTe3VX/mf/1U6BWu2eXKjWbcQFNYrABYWJ+kowflQjXKGRDNflo1Kh4SWnFG0n5FOtkCtMTu4jWwY2ARmB4vzgkYqNCD08XQdUOIhi6KC+1r2ITUYwZsHrTaj0PhcaJr1pYVJ68vyZhPZ7F0CbuffZewRokAZ399q9Xt6BZgnI1gHqtLk1+gpwi3X+DjOQZ7FNPhn+KhEv91yg7T72W1ITVY/zxKtUYuyqG2WPRJL4hPS0TS54idweljS6Kmf1O49Co7hWeKU6R6WHfNFXSMN0eayfVepeRO09R+lOwWv2Q96BBHV8bhxyyp4ZJSXodTZ5G//F3/nz37zL/iyEkHgfMpSoMn8asabvjfXz7g/6QLM55eXCwXxl5fz6+sbRduO4AjFOMSTWNAQwj5BFKtZcJwdfUb4mAN9uDE+zV77Ig4a6Ubcyap1dSpUCcivbr3C/Bl7j66e8P4x2MxmaEd4HnSKs/W4cwgLRMttwfBaIUV+BMjExtEBQKD4YQTBVffnNgi0toiMQ+DLVkhPNcDMqDPnyZpx5R9++Bfv3r6fwlvqCZ/5hCVfDlsvFa0quOcMXE8zi4i6p2eb7CMESmHhtkkxtDKCaAELj2LH4orI6eF4EkD4Vi+ZEUaRcgM4p9rpA2UKnDktl7ds02QN4btBw+vL6y+/+DUyoHTwjCrYDVzqC2VoLsWs4p+HNpTcXvw5p1Eg2dOzfFKMWRhNEGH56WbGjrEfVnd3t3weDvugCZ0iNooiHpcQ7CXriCnHarW5v79HE3+4QFWrKqQa+eMSkmVNbsVo8+T65vqSTurlHUG/OhW2H0XsT7Vc3t/eftjcvpc51fGhF/MNS9eefPn2L/4r/+qTq2cXm3uLl3HM0wpVyugKQJq5Haxhzlhh6V+Bi2vvXVngdCfDDN1l54SOeRaNkVfyKdO9tDgSx/i4oo+RORxv58z2MH2YahRljNlnHgOJPvzSVqRxorIuZXqAOc7S5X2i6JPbyU18zmXPTgF7gSf7QzYFiYh/woZkOeJcatFnH2YGMGnmlknK9gpgG5KRBxLxDl7Mw5do+jVL7wBEk+ocmuiaKpDr0VawZFbRlbDHSWcFzyVuZ4ydOcQ74COlhD0e0yrDsg5SvqxjmzA7wtktX8rtTLeV6UT7DHwYC5zB/GJhByIycviTNSVngLZvf/PqNR/6vX7yTLstys1W/AoSNhF2cx8yxq+PADiCpyyiez+wFG/ZK4k+Cd4UWmmI3bGwwjoieIdbYO0ecNmNha2/UCnwuevpjaQYTRoqYkcHIr/NcktP4YsXXygYZVkLz1KFvRGYoqfmATy6r7Uvjp5ZNKLugQaAQxB8wUlCScdsQJQqFHaYSycHI/BzBZ85OBczySIA/cA4e7IZLEjNLlhh4jpAq06SKqO6Uqt0eNTeL/jS1VG4TbfBRaoUeKq8lEL5oKMU89EIhO7oAyfhuwMDZ4ETuSTZeJDHP9ip6giasG+p+UpN+i/T6eLpc3VpwmJYQ8oriLfd1BGivyHtIAcejCLtBkcq+GgCvnsmmoExZINR0PPilg05sUC0IlroBQm1HSqnioudfYMO2ZzOG31M4SebqfbqA6kxrHWqpj5uoOZfr4nq6ZvJatFFpCOor7TRIWCOShpjJFyCaQf4MG/1ZDa/hE7GpMjGDuPZcsmOqrLs2H2A1FEoc1vxbqLP0E/bAt2NmnTuaO5z1caeLmbZ9UZyhvBQkk7Owedc3DpFPAQQhcujoX+jtMQcTp/FpMMiGqWWqIEZw/WgJeEMJbkevXqVSAV+Q0jOxs9Mzp4lYZ51PcS3r6fVJ3O479vo2+3swW8PR3+9ApPzMP+2VjX8fv6ZMONnUwBJrWqk3JiJZJhnT71gkvnDp8Gzb31bVvIsibIHXKaHmSfMH401XPdhRkXpGOm5XUR3Jrk1noU+ZbLEKdMlzuOnI1bUU0Y3hsIm+ZCX8xATOXBSWCTgjHFsR1PL7eTe4/es/o8wiWBNI/GQcSYINz1kRFUOlwlwGRVXuEcYqFJ6Ag6jkSmXjaec0wzzKxq0JbR4RrEfSvHfmCQUMiotJgRywC00mDguRDKRp768S3xJYMmBAvditPpGeNP3ZgIcPPKK+3a9At1SrOhhTgMh70S7eYa8TaSlHvjITTjb6XtZbslQN6Eq8a52E/IIN+oJFSDvu4rn1kWSqBKbHBmkJckzFUyL6H4WB8PVHVAILoYRXjscN45mMObqnrjLoGqIjzQ1f6VNGPxV78QGsOJdvgAw1eIkKaP1SghdLTEIPRkibzWoXsmY3JvSTDZXKCMh4RGyrfXUKSy9utg8F8L0rSZJlkpvp29hLOFg4wNUJHoRMgGHrW87OS8PkaqixCRfiff8lTCVEpjE1vtNbXlPQI4BY9FgamL9lV5NAYq5lhhNdTbJzuv0/QqWib2jzza9eBaK2Q2kiUyGscOWWV5CCgUkUTxHHIEXWtfQZQG4hZ/XSg7LjHniDXOMZ9G5+ISsGD0dlnvos/d0DUfp0/M7W6elWblBBBuMaqLdk7sUcwU1Byp/C8p0XeJQLrtXTpTYhdwELqOCvjUC4bgPYfNUx1F2LuvRne6usnEpipoO36xt+4SkaNm2l7bbqA3p1rUObY/9R7lr5IGZhF+qz5Mvno1lvQOBM8BUXBf1MXKlgsfJV23GUY5EG8fsQbCicWBdqlqmD5JaEkY6zmGx0y1/kDKfkT+qBUpfOFqRynEcCRKd8eO24aNRDqYdD7Ggn6UaG9ZSrAjg5pOLFSGtQluiNw+vEvtGLBiPJ0e9wS2CKgIqYesRRcwjJHUVUpxneARqineNINYR3DmRqCXDbExPnGaOEbFJUcV7en0AZcQ9SnXV4aug1sSQ4CbCKHVRlQZDcHBEI7mRczoqZ1hV6FX2IpYGKiHN5ppshOpgWrmwEoXSTub1QZr6IQTtpaQMIBYSTYzI1IrgmtgAprTYCx8ocaRmVcRZtrOdtMheLM1cCMqGRoDFnBJmLfgNFg45cAn6MR+Ny7SGYnTTSDOlpXAgGT1OJX+zkBTLFHGV4mrR6oupklqbgxhVQiUoH0TiD8R/VjhxEh/r7EKwZJ1Q2wyiCuIGI9jpwHVNBTNbwWt+ZtOZdgfVq93YkJ6P7IsaWM8VFAWzBKwYwpgWyckY0qSygJJJY4H3HmIQzPaifkb4hVtAHlyvYhtSL3+snL30sYSdJkd39s/paLT4ftX9pNEuQHKOWi8hWimeTTwFI1vxTz1R4BTw4DvRTu3+WRvSX5dO4WVPa2TPUiawlJwgF+nevt3JY7ojdeuvfXdJ1VDdpfuhI+oVIvr69PtF9GMM26TsAZfpfn4qGY/ZwafHG0/i2SHGoELWsB36GBwH75Wl4MxRYv3nRPjsFv/9EdLkOH5mkCAQZCENq/xZHsFC/816NZstCK/YPmXF+P96PeMl24uFBt99dxIOEXL57U+9+DtnPZDiO08iCEXRlK+cFUoqABRY1IRtCtlJKaiKLkREV3NFx0ROGsoFQQ/FwBRpTiuMNCtjAXb8SyVgxf0izvrThas+yHUxY2Q64rqwnmscYaIAoCHYhzADh1CZeQAdKnb0mUoquMroN7EsSXv/M8xvgE2EZWbTy/X29mKLAivmQJJ4VR+Gto4sAQmdIjMKOa6Fo3q99wUmxVTUhokdRrWUhTozmu2FN/w0IDKKzBBs1YCg1m+4AtMBlFF25nBoKJbCSwXQmKshGNbLwLKcTZHaQK2PsmKV6k7anY5AU13zwXIqW1hVkLVdWVFLrNTlwEpSi4o4+DYmJXhCkoJCaOUWn7xUsUhl32Ag2exlJCZwo0hnvYhBnqVYWjdksF54ds3EaqbNamVtdyAmmxkutpxczSeX8jVxwe1nXtfkpCRagHiQSX4ROc5Sa9zRidw39n/ozEDfE6/36dGjcx+fHvT9YOwTttqPCkbxjO3Dr2nYxm9DCkYHWGPE72zB2Pddme9Ot51lv3kCo0/zEt7pYN2KtKC9cZQxazZv0Z4E6LPzYDsiMZxKxjFmRJXDMU/b+mM0D84H+PAYphmn0WaFO1jbmAEIqJ6domuqEtUqKBNSwLOkn3ki1yYqGtkG8GdexYPVD1McTOYfraYXHcHlM8lHtUA8DPItUNOlG1pDaWX0fIEnEQ6hETGkAsrJ7HJBxHa1mGuHRAdxihLZQ33K5IACWwI9ZghAJ9SKeIt40p8HpqugQDgF+iYWe8dkEuS0YjWPY5OIsFcFABWtaii9CrBEavmcFN8FkYurAFCVtkZJBPjg8fNgYS6K4h1EJCpF95Ti4nR1Vj4fQhK+rk7nklTgUkWW9GKkYXRW3NUhi9H8mgEmZNwda6dVN7CiThhcI+9KZvZRZcfNkkggC250uSIMhpUDWeDphwoEGV1nNyjRte0hpsT6YqMqRFcBHKZxeH8DMBqACERvNXj6x5YBXbxSrZXREUyUEIUOa+2U0wGMs0orJFXUWETv3n7I9FJVcOkQBhA+UXxGJxv+ASra+DCO2dlmKKLhfB/WUI4hM5ip6+CtkQJCW2wmdGWBE/Ffzi7lgJjNjaLGIvwXN0mVxmqe0FzqR3WUqh8SWIc0cnsRGvg/42xpCDXCz7YqoXlZnZOrclZmJ2tTMggH/Vk01qdrxNKgSvebs1GHAtENwS5AP5hZ4BXYu5EDI2YR+hkALR7YBX7ZU2yqN5Bv98/akAHyfUWH9ixzDy9XmioWRtsn75DyQ3U7hPeBuD294YGKY5Zyhd8oeSElUHtaudMmD9cEnWrXPLlHz07CU4GFrE47nMq/h75Lllp+9wSoE3bhC0N265wZIMwKbgqewImLIp/Z7B/8g//+3/xf/S+fv3iudfu8V7uZPrn5vbv3z69uru6WS2YDtGXO9pK5AAaXLy+vrq4c9kOrWBYeuvBAohfh0VXCLYIszv5aMJLm32skWADBuQrZ/zQcq3/A9cKu0po2WBE1g+c3ZQmFeeHYizg0+eCQWqURz97P2N/dcIlTHSlSsZISpsMhdYYIQ7atHQ1YJi2QjBInBdBe30JgOZ0sLCmWR/H5APbZVEwpIfzjO7jEmczVUC/tqT/bzthxAtt5/D51D7AfJlbgPtF3c6d8mcGxMN8iYK0OmH65GTjr9aU6sTArs74WvmaBbL0qdlZnQGlwpvgDmJPZdzYOTcCKFxt5ysp40qpdaixxTSZzHVWU8oJHWYURhY1zsFOdESLx2ED/ZR0sQntJz+R54igruQeoqxtb4/ngiCTwyKoC0bKwkWryEYXqetubNG8OCDx9KTxSyJFzmB9mmKy1GEjj/Osvv/niyy9e3N6/26xvyC6mN9vJ3cX2erO6vLtfb6e2pHqkYU+YxkGtu472zh4NSGbQRS1Y391de/r1EQOvmqPvaTBA2l3U8xvUjdyC9tiphVc8Y1tlXYA2fhtS0J1ijcqiBTsle8ANrP1Zue8AVp/mffABVgNFocSQHgPEhYeM9dIBboPtWNLFwEdADo55SkYPnB5lk9IL9LscMwChWX5mNFwu4CXlA9fkM/tOCzxmC5S+kL2jvG8bPhI4JTBzyEWdlRoDLOWOwf+Mc5oFjrV3D10TTKAk52DBz+vXr/5vf/2v/93/+u88ffKE0H+xIFS/2qyevHr3gXc8ibOWvCq6JFikcMbm69988wVDz2wG6iAMJlq2DiswYemeAKiKAQXkLNEKB/Xbp8iNRJw0DosAjZjDPUJDlRAUchah4zv6A7xru9FekFpvQ3CmSI9S0grvZmxoI6COncNbfCUoCjlbeDpn4NiEOjccrpOG0xXdShW0lNbKOThNdTeyih34KlLVfxlJyNaVUiBqCuqvAp2xBfVSjB//bbxQPKEI1UKEYDrLAt+dKA2p24QUypL0TAiIWRfE5qRek4SttUOorLsjD+mSIJ4lV6kdMMFdaDTlygNZwnSdHIZr2dHazSfTUSk6MPFlABkgdHcz0uK8Oh2xhfgHC6eU44+0gHHACadTH0NtYQurnjp8dT8UK6ycxzkItDdX15dv3n74m/+P//f72x+Z98Ig84vnl0+3z66/+PrF/+wPfv8v2APp1cGFxhW/aKssVvyrI8ShkBSrgOW1D17inJzulHwy1+MYZF3CNMcx+eVShXmGbLMf45drnYGaPcqNJPlDbTOg3xFFTUl0ANT4+Q4yy3ouSWlSNoWft6fY5N6V71QTxLInVKa7eDRhfNGzPEJEFrTPBiXpiHTRo+3DRjRC49yHcwZ49IYrfbJQODdFVzgUZcXAiSMnKkDy7IAf+g3Fsu2Cw5ntn7WsJ8Z4cqlbnTpZDIXDPpQ21S5s2KDdZcfg7LDPlWpqehDfvrcCmmONFiLjbN9/eH93f/fHf/w/sqEiERqD1RHRsvr/yc3NzbMnRFuEVQRb7LDIomuiyZurqy3f/5J5Fb3qIG6Cm4Knid4dWK2YJ5jPFyIT+Fdg5XoobtOsAQPSmw8fbrU9paJkpIgNoS000gFe1YkZAInSQhdhVLeEyx1IglxdQw44OnZSTRbAjvOGDTG1ir1ZxAgxx/bKcPGEocRvnqPP9WL162+eoBFj7GiOZRRE6uwNMYkjvcZERNunVkikFxdPtK2QZ3HV8WGMnx1+BKnqKJx/CRtE3vUCj+dDhLKYS1v3eFer+fbiDzTtIj6MorNVK78m7EMKvMLXtqfs4m98lv2w7l9B+JbvGGDn6LZYq3TKdXSVI9c4VyWN6xS5WOeSkxZ3TS5url/cXNNGthtX/8NZQhLdFT73oNrxT5v9s2LKo/eUq4NAmpqpblT7w90tXiUXARf4dDNfXGJ0G5Q2AkxDuOsjHUChF4r9SenAJW/v7n773W/+6T/9nyjDBKhBGVZf3m+evZj++/+Hf/+rL/8c8y9GzyfERXsHhFzwc3b+fZFJkMBLZytXg4zMjHn6jWR1GNroEdlgK+vUj6ZFqtLas3rEc/VQ/ErOUde6Pj2t1gPuEbj6tVylbEdDJoZ0GCmvepCLWR+eDx14cev0CB0PrjtyB13N/mV54SFl7UqU3nTdzr1oH6lgr03G6NVhEztOY24ws+JRpKWiu6aubqnqmjGdqOnYjVInGMoFsxrLIfSPUFbW0GZ8PB2yWUKHxrnzzjyjcqW4YJv1aUtpKBOGapirzbDNZy+kIWgv/sdCKCsbaTQZMODH0rNL7mE27sTOVe7gn0zjgJEYiaU7k+WKgf6Lq6c3GoomwNJBxHVxdXn17PlTMOMjW7xY6cie71zdbW+uADqeUziOFqwcwsREaxHmASEE9BcDwvSURSCoGJBChfectheL+YYBfCJ/+hcicgwIqgJTinUogJQOChwpRpyWiFgEaTFSGJ0Og6tM+yoBFhNFmSzgbXxrlMEZywmi59n0en6DPhqPV/BJTMmmOpqv0K+4zhgYkfzFmwAK6elQKZRXgMvZYTpKCV+fGDO2RsrDGj4bk4VA8S0CY2qPUQ3qm09ACPEVv/LysXjyMV7x1w+MV/5csIurXujQi7/046IGiqeRHSqGSWWffKjNynwu6EzYsmYIUzsSaFTXoTb20aFoX9G9kqQke0J0zoUX0ZNWamvWAkmwOgCy7MVkyVn9U81y6EdT+NdX+vi0WFqcbJXEy0vsL4ryaYPb+w/L1T3vtF9eXzGPxPahYYTt5Jau1Itnv/7qxbfavNWHbS4NOZJxECidJbd9BNR1KgrltiYqYA+ZfFxp1KRZYVcu2f8hK/qReOfqjjZ0pgiNEx2XA46wZ7Zqzh7AooV6mAYt8kcGNKz4yNLPIG6wAnpM0gFI/S3WINYP/R5wp/ED0DzMteWKvf22et8rqxSJnA1+4/0jEza1q+36Qq/3MMbleq+S83jFSqo9aX4m6/MVJX5fBYF3KtNr/5JppOstksv76g7CThnrnEmU4H0+EDxmEGg75IIQHNbPZc3HaNvRo60JfpBMn3kbwsbolkdWoK2xbduwwZ1sC2eMxdpsRkNyy3RQdJUBK9u5SdVRHKAU1BEGbTYL9vuHjUGEqxpSxbkVgROTzed81tZjyRqQJfYSGoWyJOX6D7Z1cMJBD8wU8+Fn/Fu/EML8jYZiHQgqwgXsTKCzNMWBKHsNgarlQwrvUwAoMVJJ+82HNK5vKQ0wJfCzzk6GLpFsna1nDZoh7F5fFAQ/F7IX/u6o5KDu7L1qpOF0m4MMUTWqbV6o2vqGAJrfK725Vo3j4Er9Lu7FenvN2ev+wXmuSvgLA/AUVVRWvBHA0h1Qr9zT4E4nKmbSgFVW7HzP0npG3KGQdIbRgTM7oXSqUYYryJbOay+xmt5Jhrpg2BYOSrjC5OOQdohSo6FGrkJVXGCZUowuU7eFJO3DsflC5/kb5YRgKZbEyc5klSjBT9Y3k9lrSdx+JU+YvTZfOk5Tun9WwnVBI9jxj55BzDvBWtKgBEFi6EfRtVVHB0h8AAELUVt1eEn5HQO6W5RurtbrDze8/764XK1vMae+7SBkUmIltr4oV1UjAPmcKpfzGd/EibxRely27/nTBz9Uyrn4tOXWntWt5+qh+GfWs6VP+atR6RbekFszZyMBVi4Sxfy3FV11rSzQ7S3luvZ2DBAyzlJrWHVrUOkZ10rbOvTEXMvOmpbkaMNPFPQRyfWM4tlWaODGq83MFw2w/obi9NiKh1dBOZAMZ4vzANqBRYfyC7/sEZKZBdYgbg+LEgy7zLGEnzEd/LOgYXEZ7YwKnMgKE+/V+UQRj0BOFXJFzm7kYDhspUeo46EiqpunutboAWZ4SgQoLAluLk7+QWxDGcGQxll5q1SxFH9Gi8hNNB7DV8iocCxYgKq8/EwARWFiqYgsZczE0MACPSGnUE8ABVewUVAHb3ECFs9MFwfInRJLo1RwaZGucRHo4ANV24f1d1XaZW2INXOFqbkOh4bgRVVg5p8B9WIAWqBOzkewmmqSapdqJQQL45wSOWVMmQ6cqvJqBDWezKn/FIusYmpW0ii0svydMtFowpEM1SEOt52TIbsSloqblyQzK6zyIBTDRLwDWJkEpafHlrJg+xr9S7uPyvnjn09MW7gKYijLStlwO+FR72RlsKKmBqtSAOReZkfPSP0BFg/J7ZAar0DYt6+f3GBIOp6mhyFyyp9wshYY5dKidoTUGuhRM1m+Kur/jyr+d1BYafEjqh+ePIowSzqAZh/jzHMf4idR/vPStsNktFyj8coqqaixC1DBo2Ps37xW38LD+z8UyOL0XT2fc0Ufq6FMRmEemSN6nyP7mn2sqhrn8rLGWWBKjJQFdnBp47chZc8SJYbEWwvsNgatqXrki15saf89DIsWabMt26Jd2gGpuMktWsUBbBeV2raIegHD1u4l6ykouWWLRRVyRSIRjZhx2vyiKFMFQjmy0iapQYp2rMGLzHEWKxh4KTb5qr12RVrn0Jrr62g5Rym7SoZVMhsVZJASETuZj08BctgUkRBx0nS7Yvz16WT6CnSN/BP+MDzrwIs3bNdr1vtTQhlvTibRjsEsQOEYhYZzjiDMBFJlBk/FbPDU4SAV1vCCH8jqUWjL/CiSXlFBn6FXtKtR69k7QjkP8bqCFT8RcsR3fNsr+HMp+LUx/ig45qw6p0MVUB2oXlXB8hsCFxdXKndMW5HIjumNgmiZKNUXBoSqM6eUVsIWYexfo9UCh32FQ1Kr7U2QaJMW5fcKjBiMOYtPmmGwbi5IEbQFBzqaWEKIKc5TvxGhGYPqqPCkmitQFfg6e2OuQqr0rHgrxCbkZjMeD9XP3mxnmggCdWsq9TXtLdhWEbsYyVUvVl/Kf6av5Q4Tv0LAWyvWl5M6isqIjWymeQBPKbGPlXnr6w0Q6dBaKJDAZGMrbWZrETJw4mB+IIqZEVMaf/tW/NPefeLFoTZor/S1xSmFxwFH38x/3/NH8KhUCJEuPeLKp1yZNnof//Ip3cM3gWPsvI/PMO340vH8a5q36tuWaMcZ2FtvZ+Ua5zajIciOyRCWy0IfktCMr3WbbUQUCd7+9WkT9EFKG5Zp4x9skxGa9Dlyn4LD8AENO1ulxC/TvVIaAwfgBd+yGrlRU5vGo71Tfq+c4HcYTS+zekGpar1kZO5kBj1y4HsE69JGw+RRWuL3KDIKfBCfqNqweiF1L05bbpDsJRxVqwdD2qvkefU/L7dzWKXdbsndFf0oADFCYGXcRjY9bHKxnz7Kubop4YXj7m+Ys1ZLzPheq4J4R9i+aD9GHXxQSUGVGDtiZZG7oybnjRFwFRtB0RdHLPNWgmw2T8RYQFUjqQMZ6QpBtMFH1Q25gikERNdQAJowRmhlJsEmJbsuIaurpAtWqNRVXCksptKuwAnKElIVdsGqMl8DoTiTdN3TOZrAsl2SRCesSifrE+VwJVEdSoaqDVvU9AepWVzjouKKqTm6NEjIR6Lk4LaudEhXheIOjNW784cmyEMEOMzp+ag4WZgLIoAXonqPxO/hYpVQXSU4COQz6jyCLc8RrZe3SSI/0frPjrZ8RVifVbv45quvRSp0MDlp3gAS6WSGKjX36mKAgGOPIDiAzPUYwb2P8QGiRkjpQnl4CV1SP2nYOU0ywGug6JM2z+HKjb0LDuf8qBSNahTt54cTLwE3MPZp195/YB/F/vJy5Vm5UrykHNUHqp6UFeGeuh3ar40x3cKGXT3jomfZEE+2pM1ZgKQbyFUVdtfG2Lzwe97W39F0pbLcTollW7SpM227CEgnQ+BR677STladwI72KqwdJOP8RLiZW9g/S0wjST8KkK0RyucqlO0IWiObWY1NtGoxlrCOt6fufVK0FsJHGKKqDNyIYZKVKiCoaawxZvxEmco8N8iu85F1+KLkdvmNkLy/lnb1AcKfx1YVc03fTOa8CqyYh4yDM2RocYajIpZgU6S9+L1ue7NZvmBwVTuvc8BXo/aM1zKuT7+BXKqJCpUk3IoxDsVtkiHR2m5lywvAAeEsqKYGtjQ372N6ksS4BGQas1W/hQsMzFTpJId5Br5B23/0zQz0UgQzuO9kdOHuqkmpsWuQBEuUwbNbzZDUFJGFp0Q0ZojIZSVRqIDNAhiYcRbExWVRpBP6Di+BaTSN9293b0EQO8ecgzGqmY0kzcYKUrGygsGzkitEtR1XWmw64XsTeNTikvdMeD2XIlo4Na37jTiV+BHoU4BPab0QTjJ7aacUM705rZBdaMqau/wo5BPbU7r5yi7zm3Abehya7wI+e8WqH14Gpmvw/OYvbJfPJ5M79QAgl9vxRQx9I0xvEQRD0fsVZLjPfqhk6Lo7ait9d+D0hkY1n28JLtWmrIjD6+tHhVmHduYq63YWdgDL50+Z7kDdgfJTegdyaleTqqAvcqjKH/ta03x0fcdoWeMsArtJSjQbdAzDBs5Aw3Zy73pvYccy/4ZmLXdlB6VKG5ZpM2nZ5CDWQ8jlDEauywBBI07LmH0a9s1clfhlOjN0Yp9RG/eJmzZgfop27QJUF1DkSl6RLiEFYmey03U6MQEOuGCU9hHW4eh3/mNYt5CXcUo7hTadRefXch/HUIPzWY5cqT5uWVBOPEjb9Invh+/VvE16uuZhhOwbbRGPCClqU7VNgIqCQp0SmtMVYYFX/ip56NbIBOuK0SNOV4gUQ55EPdzyxGSKNBm4n05vbp7c8HEAUMHyoUCfX7qVlg95aQWxmUdiiY4cwit04p1N9lshiF8vtYwoqDXD4EAHTPUy9E4qW44u+aDAfQSa7m2A5A1/6F+o26DOBBuPru9ul0+fPvM6DceFDiNdYU6+1mp9rsyJnHPTdOgDaxXLbG6JCjfDKd6lwQShpk4QBEousF06pInYBIHf5BUUwbFBHQQGhpQmVpZdJ5QIvViCG+AErqNdhM1kVzOWuGwn79+9A7xazdhYiqL370FXfxAPEqYCbrHwyL36nnFEFA530CiiALkO233FTCoLXeRnKvJLwfMZW1WxxS07iC7octjwONh6tpheXi7U/5azRV8DZ5W/sioIMHJT10JdWdVLknRJtQphFTDnuhOhWlLQKD0G7CbvggaDUKxkHJAuioeDlfIfTsqDcj65PR5UOzEPIx+nJ1S/gDZ6cBOfUUDb4m6AaD4eUYzLxTPlEJmwSAxMlbOjeZQ9pDI9zKC/DzRM1106Xm4nfduwDbQ+Rw/LgdxOABzuSZciMmbZFCXCmHTWYQxyxoGqXbs2JOOTaAgCec9YdUncSg/THuAn1TrChnoHrN2v60a9wjgNhnWs03KVzp1chus+bDcxdAXUlK6GxvKV8ZGrlL/1myEVSscYpPnMvmfffWIhgn1F8sRfinAUYJGUSO+akrZfBE2LILbT2ZytPB3mhHzCOZFtNh/u7pca14QTAZsUFAHRGIH7nM2D+JwYy4eojBQkDLMIRUyAhb3VLpbaMJPg7/07dvURTNML+n9xd/dBdhCGPzm22d6v7m+uf38+/VJrN4ztWomKP9VECXFpHX3wFmITIM7VkfnvuGVQhZOUyNm+RBBSqme/hdgkO3SBDdeZTBxK5HxFmSCY/pmwtPsQFiJNIOu08hyZS5Uuv2/g9DZ960DYIWa78qzR7t0J66RyH0aqg6oiyUMi+3vak+R0AWLP2bv3Hz4stPJmulqtPPbP9+UUgt/d34Mk38Rr8BipzEmUEf6zUh/nEYb6Cepo3t/fTqfaPDRww2hSAjK7mgrmr2Ex2y6ePn2+3jDvxBq2i7dvPtAFwGXx8JubF0+e0B94hWtrCouZLXiK/vJicruih7pezefzxNBVdG0sRoJrR1VUAF2DIl8kPdLfQZJQeM5QqB7OiCNU4QxJHC3lAJfPnzJd0Zx8HXw2DnN/CH1qPAd1Ky03rOdppbl59rAZi1exGfmLKbaDdqj49Vx7aEs7l+keLgeDx4z6l0z78Dt1wybDv9ol51Z6X0O1y0tX00160AwA+MEx8eXiG726tvSrAcZhicRMa7SfYCYrmYzRUjEQOJcIYYRM2yI6D6AhtGQ6UFSi9aXHN2IfB+APXf0B0Z1FZ6lUcD6IVdghzhB+/MOqcLIyLY1aAOEFdtShXgHCGK8y8FAqPL3XuTIi8ZA7w6hbfcVKay0cApkb8SOdAYCMvjvEh4sH81kZ4UCfMf4tK4MkDVaTq8sFHw5TrKL4LIAUpDSQ+JeKqzwCr64uN+tr8XAHwPMGvHdwT9gFBERiNGm44csD2llfA77Ey3QsRCIUZXVE3snaqQ9eQxqRCT47bmH3TBhKWI0qmcuKRI3LEGJFE2LSOaiDbKeJhZbZivaoayljjIIlPgLJQiVCHEVheuQEiPF4pnz4ADUNKS/gnVw+TaZe5fRyEe8W4zOi1MA/nVW9n8IU0IbugTwLV6A3AS39h+USnNkVvdAQqr6BxEToby1A5ZBSuBC+NeX7aFs+df3+w2xyv+FLF/RE5tOr/+b/+99e31zP6JPK78G6VMC/mb94/uQv/cW/vF0gks6C7iXXDMXFXZfW0QUzkjSzdXwdd7Lm41ALrKRdAXmsZNTxsaSdX05v4x0pqmy/SJ/NQkerGt5xZIUenSzsdXRlH13fHoGNCjS9YPwMQIcX1Xh39m9KpTJ22UMq0yXycDp0CZw8Fj5M0ihty92rf+YAZjYjfd9cr4xQqpcxy0SbJGiHe9Klzg1MGOaVZJk5iSw060YiI5TARrpt1Qzp5FmyzZgNniVO1n/Hrad/32bS12NOLfijKVprBNt8OvbDMVLwmZlPafMODl0gajTGwh2kYywwpl4drAXqsZvdJJT2WS2iPw9lis6HINVhNMchhlS1jeF8jSwqTCZIIXgiiOIjvoRHiwUDnHwFSaESy5+1xkb7jbAuAmmktORBKclW/E0nwCLNShACcPUdtssX2+VyO/vJVkYKJLFQ37pEUL7+QipWe8B7KmClEE2fqg0MYrklC4AU1GtVEjpvV+vNcrWkB2AtAJtCq7H5CiwKUyFkqbsiHdXGVrCWFpYRjCNRVe7Iaxe9R9zZa79ZxheFOWLUvD0S79332Xu+ocgkjd+/DXhUaYeTqyhQWUi6kr8bp6+k7+i7UsV4f/Wd44S2E1DyrMmtMdzhG6zsDkTzka+UFAJp/5fH0Ofz0hu+BOd9qLbzH42+CIdT48u35GCktDZMa4fwE1ioMzCd88dLWF8IZ/4aMOQ0uIN+CQNscZZFWt7E59D4ADHj/OK7Wq/uVu9e/pOf1KmgO6HBuOV0eon/r5bb3/8L3/7lv/iXzBFKJtDyHWF3loTmISEJVk82EcfkVdOjjkqFNnH5/CnTgTn+97fNGYisf/5nY6eoscBaHUfoduKqhMr35Xcc+i4HZklyE9Ale04ZNScaBMD7G7k2z1MSJqoRdiipauke2tLOZbpGOzojRzJyTpSkA7FNidaZ7tPtKM/va5yW5EZrFbXyHKB+fqv/mbaTeUGZEZOtKBpxdHIdQdeBMk5gB+HjgLpN9SiywzKNRs+SH06xU1rkFNpctaMTR7jlQyj8EDwPsInFK36BJqkyzjBg7RChZOQ0AOZErKN1zL/553/208tXmzUf//Kf1hZQ7k1+GPUkCNMSHg6FT3CIxT+aATAX1UNKUUre/0FzGQUKphRcOVwTqg5FaQ6/KRSqCTN1IiUv/orwdGFXSOeV5T8ardQxUEdF0RdRGyUi0BHXdAaHkiBzkTiTNf+KIugOPHcQhxjO+agEZwCJDsIozsg5UZIFsLPIaJRwwDwSzn2UU3f93OQ1fcDTfzU9B07mzp6dQ1VgLRAlxPJyIfmKD2MD0fQAbSi4fUSBP75qLuEaFX7lYDlutiaFkaDiBXPY4NVsZsXys3teP14tF1PWrN1cLjTZNGflv+YB6LsS8y/kPV53hN5oQjYcNbSMCoX8fC6AJIscGPVcF0mGPW6isNJhgntqdBiTz9gNC4xsjgHjDxQ1ZH06WWqdKx5pakGC88+xOr2GLSqj5KRzBiBbopdNFFTMuPJN4b7vAOxhMlQcDdBYN9bQLo8lDzEaUTZe/72YlV2S69R6eB7l1ddIR6h0EErYoRRdE1HJDZ5usSb7cgSibdUG/yZxkS9pD+gx9/TvC8Z7knvbpZO+ZiVjDPPJFu7kFsBO8w7gRxGjNTvmY2YD9nIchbCVf8bK/lLvCTuLS51kjWwmXsMFH/j3fjRmOCBHP4RMkIlSf4ycXs5/75uvv/xn//w3083lk+dpgQ1vBfDwYR9GAhsGITQESoSjHVfoCygG8tOX9yzxCoIfvtQrbor2p6+8a7tyPipJCtMgI0vw9FrREozFUwdfFgbgWQUgxtywa9DlZMrQPkxZUwTc/RCFcmLCV21FKXWWBIqwJkTUy5mqXlFrcmRjHH2350+BIC4+Jiw0h2Gxk33A+85pbL5cT28GHh3fCSAlHVDtrVSLo7YK36DW2D9Q1aQ21p6o4yIRtXmDkLmTXMN+mIwr51ODf7cWbjpjygHc/EGstotCeRgryPS0YQ0QiSnj9zPWmBF0A1NHQM6o/gCHIn9lKGOpkPoDHPIEMZQ3vkxEwhcxCJyFBEFqD4b3+aIF7oiTKdBf04uQw3G/z5h20qQTymzu9CXg2f32w5erzXJzL05iomZSH5QESQsHzMvNUqnn6CmwUolEt5349HAYBps27vdhxDGlUbO+p27t17POrlFLssGqjnVa7uGfw6E252q0fqdw+Ys8YIcdQZFqcysKU7Lkn0tH2rBhfMiHNWzjZ4mPkehvx1KxnI64JftkvnHK2OZ0tYc9v49/n53bXwLp4BA1tGAlPSdeoeXa5+pWJbqGsiXkwHRmP5KuD79Tu5E8HxNt2GAPWgtMB/9hBTDFEToE58c0489UVhg/zNXnyY2q7W2vBv75s1nRnEBGmW5k60WOgVLQk7oB2u2QgfT5bHHz5Jq3elkBwcu9y5XiaeKq5d2tELwEIgQRVsGBhUMJrkFTAIYKI0lUoJWqHxDlROsgDhYZgWKBHYolkmAobTXtIK7CkFyt8ZAyZIRkUk4swNDYLbFXQLh0H0lAFNYy3fjd0F723QVZTpVIWnYxzxwikbNduAk2wK1BFdxCi3a6RK40LWHdaTBzU+Ym70YF2uTrkL9QxXl19Ryrw5gyuQYOVkXtCuLVURTE3qS5KqGQw1sEEwYBOR5SqYYnUSQPKfhYnSCEAXMHpKWjvFlftNCEl9nSy7XEFTn6ovQTeEWZqQK6CtUmRvZFpPlwLaV7yge0dg5DdJVT0gWuUY/KnIfLKFEjkaLSI5E/HbSfr9oNF3i0iiA33DgkRva4Bm1UYYBJljieZIDbaUUnWLog9SNtHv227fz7Xb1iaKFvhKCv/7G3SmHBvWgdCB4bLuVGLXYad9Bon2aOMf3gLupzwnI/Ukxdl+B+vEH6tcMmsM32iURbLpAoKjH32grkhs1DXANYanfeHnPJ+aOle8YSSv/Muu3sn0FYvuWZHWiFnxSk45I9GraIU3vu/DMAoQ1DojwTFHlUR9XMHWP/RlGAnNAdPnHiNVr+fuC8mvz25dsfFrOryyeXHz7csvb/7bu3//Af/0PmAQjCCXV4P1MhlIKjF5PNl9qGJ3EjTpJoxU8qTiIAST3leGAZVdQszFZkFAGcLyCoa6CL0Ajo3KlIvmzO4Md2i6JVrA+iIjYtFyHNC8f6CjFlrJiXxN1Iv/lyinF00VWQ9rU99t89J1Ap2xrFpwAJzSMLrRJDKlQcglU3w1JAx7xBsA9h5TmqLkiEpsbrllBpWkrqTIvcTVzNsUzfJLzQgkwWKIihMXMiUhoT/KRkeJcbV5iUKwjnv6ac5C/yP889iQtpZflkwBfTzT3vk0S17OPqOUrWrhqBDRnH2t0CNvOBB2hsAKqOghmyO6129WEFEB63YlNQrTpjHsL+p7cK4Izfvb6YLheXv5ryZrC6A0xd2ffVx7CDw1o+LDWr2jH++q1yaScu5HGAkOqOGoYU4/1jx/6Dial3p4KPOCPllOfVjm9Havd06ijcgXJdd6AqFU/myI3kVpF21KvzOb/DP2uq/EUer/l4DUv+fXP1ndzC9Rp1bf/WZ98J/PDKBlUn/wbOQLaTZwd+2z97fiVD1U5rd9a6LevEGu0Y9mjYqRtUHbvwBa+wUW6Dqhp+gLAEiDwYcQ6CMr1TZ1/qOKp9XCkP7RqIYxu+QfY7kO0010C9x1uygRnZBnBA0KdW9Klpjj7cQ4971AWWFtHt7BinU6GM2bjr9VCpyhz/EC3P5qy0/hv/+d988/IHNkSZzGcsft6u+fgXG/Kvr66vry+9FQ/LI9gDERusn17fXEm4eRVLHRyYE6opzt89FUgGYgC1EikGLxTUQZL+SSv+vAKE8M9Q5RWm0fmgkDBMZ4WG4qm+hpYmaSNH9dnEQKKdIB0HeQ6VNY8KVl2b5R35IdTestAAbm6tnOtgX+gZ3Hp51okDrappNIwwgBfiUk6G1RHdgEgbUD8lJAMTZZMhZSVWiz5kIwctdO44QFGrqtnCOqSU4VitWImjjwGz1l6vqhNeK0jmTxjJcTzWT8hOlE4cr+U7OAhreHivXRsEZYs7ILYDWRDOI4WY21LPQGzpwEgNovvnz55P589YevT27e3r16+Qa+WZW5iupCYdBob/t2w8+uH29v5+NVcHYbNYLHg/mBmBJS8OrFYsGFIv1rUrmiDZq9YsGQZ2HDZKldl77TZsQbYXocA9YxKxuSJhgtIQZxT00KyiIg8t5ez8RzZ7biMUOGMDjZR+XK0/7RY5zYpN6rn7DdS4tKjTtRGCgqzof1SGCtqSw3GG76GKEdNC7k5Z9AqxORE8lG33+Xr4nxdcmGoU44bmo2iqPX/afe5MXrVNBhSJes8yK1COTJfpglLJg9p5gE+D7enZ4Z73kEHqsgf4qHF7/Kr0z5Jf21ydntlQb0CHknl3ukfDbuQCqtAOPXYaN5QyanaXINwhi072ifjKGQIZrfAh2Nq8fPnj7e2tBkTvFR15pFXB1LOnz3//z/+e1kPok7+8GMC2O18o/N6+9eYnhFZiZcbSjoIUy0GtHoEj9Vh/4Y8+CaI20usEbDykOkGicVgxQh1/JIB4bLq8v+NVTI2zenyUSGy9utegv4aE9V1hQn8t9pjc8j6EgPyf/wS3ycVuL50q3rU1pGU+kOcuRQa0EzEnsNuHp27bHRzJz1Q21VeHpVc+9MVcgsvdewWUSouSNiM3EmNw4A+73b49bghJfAazbRqPl8AQy7mpYSoqtG7t/W9y6nHnqHln2wSPGqd3FSo+kplFhT60su1TvNXg1hEaTeHYXdM7CsZxB7aiYp9P+GlB/8V8rh0/PRifmhTnZFpqcXPrt3Gvkad3AEwPtWXTdXwOZMo7JwCkPX9zuRp2kHuyUkiY0AnEZBi7By0Y6d9MF4v57PpqcXW/vEcuaOoHePeqzeQlQ/5/8sd/+o/+0f+FF1F4M3h+yX+aeP2X/+Av/9v/9r81n83jY9WVASS3Pv4HpHG4i9KAOdtG7cLqgp30jCoY9vKp/04VFEq6AXaJyHJuH31P5jZmB6SlwzC33rp0sN6B2m1wyu/msIYhta1njiXsTTvd+rhl++9Qe1KdjZJxg39bn4wwkAhV29YbINkV9fxKNqq/w69S4yteUfRe98jq1nCy+pUs2tcuHcLKBmiK1JCbbybO2ZDjq5jZjSexwPGnLKFBUlaqUZSzD6ZUltBMjNGqSfMw+U9Hk4ep3yiupUe3CY5wj2B4kG0HpERRcDuIZ7su54Fkew2wa+A0q0f0ZBBo7k9MNFC6Xi8FJfzxn9791ZCqgikORdSGI1W0hGNKKHInMncEpehNEJ57PqSfR1aViHhOXAjliLv00qZoifovLm7vbt+/fxsPN3EgOGPlBaXMP+g7A+vtUjL5Y2SVXRqhRU3FZOKvyIxugD8QHF8lU7BoRSx5+AQph9gP40XpHqQo7kIKMUlELTNG7Ggci97Jj2o1xO2Kd+oAa4G7QIHUYDio3RDbqsz8wh1oCYXZccBYHsULuO+W7+5u72cM87NNrL4+R99PvUoO0l9/8y1NaI+Cmp9kPExv5MoNxNZRv7xE/4ypoXkKoyIQChGn0nZYQvAmoNwB2iH36bMnN5vrhErZ+gWcJovLzcXqz/7Fb9+9e62espyVRWjzd+8/PF98ubhe0JGu5JaipHASqmT/UZkmMIKEdB3cT/7plGTVI5Gzn46GIzVB80/K+igzxpifgtpht5EKj2mOqNRw9c9V8WEpY7Q9GKcQ6R9Mz7nn51WqmI0a0+hpHqDbwOmZJ++NdjhYnVEEMWIafeIYf41ahFJJ55bLBk7GHJB0XO9zgOH4olCvgR/6DO9Dn/vrDdqczQ3SIaKrZyn8Ap5HqSEPVn1rBLPEzkTm0y7NnNtFx0EafeJsAbhFmvMYoQ0+pTIdxqyKB7yoIXTM6M6ADpXAT+NaWtl2Tibi2UCUpH11prMF9mfVhIIfwpmVNkVBeQIt4qC7u7utttnRSJtWQLM70PRlCq9UQ9hp1U5qQrGE1gOqPHQiCtMSHaF6wFWLqkVCkVSbrFb3d3f3HruFVoTqIxDDaThWL1nST8DzFdYp1mK3liVJGPrVTLRBH/Zv5FMA3B0sF2ckGBYSlw7Gs8l2rJUvwkDUK0kq0nTdjW3rkbwrNNw1Q3P6MF1HS27Q85WAOnZYsGBOcROnoihnBlr8E5K+QhCqSeOUqhi4tknxHSyndvMJGeRqA69M22K4wyxSYFU1yu8GFMVKhkUr/4h29yyQmpuE+oJ86GGNU+IT7vhhGO/SA3PtUKv5Ahzkudx59hqgfvUQa8l+N0Ce7kMXhesWGyB5cirF4dX1BO49qWCi2F4tjgh1MZH/UveA959iYury8gn4yJvMlpp+Wj29vlzAjjVCdIRFaQ4SURy1TAHfJVFhP9IOvTdVPqPaT782pI9RyaeGU/we1eA9mfESexh0gft0aM0MBHFvXUreFW1uhZzIWAO/mxnnlMQoPUcICN8O/fPvGsBD26JDn8pKbS1KoZRGZBJoHXza9AEp+DfuiODfR7cXfoAOe3l1IRzGv+1bPJ78BPDPqjoABpSSGvYoizrSXRI60M4DysLQMdSMxHm4fzwuh5m8S084xJHuRmeyuarCjuswznBpB7txoNC2PI+jG4v1EGpnC49VosCDtqHSw9W9EHt6Eq0PrPeunnrCKNBis0G2/NeAP+t7iHPgKLYaTCea4qwxVzDR1sH+TCLBZxUPwIhvhFZFPKqVCCPYMi+VOctJu6lKAiG+5gCIlMQHcoVTYqezKwWyDrOGRtEgh0mkjDZb1H6LLOrgPU31D9Q1MKVKfZALXhUgX6VhylTXXNaTsMHqZWNJC6pCQWlHiZlwStkC95SkGJpz8C9ZFSpIKEcgljhD6ayriCNTQ4+KjOAZKOKgPx/yDgbgHf3TKdV3KvhQrxDd5hIoH9G3t0iDFjWwi4pF6MMVlzYmBFFHUQrZovx1C5nc9HZOvDDeH5CMRG6GEPCdO/shFKQuLu6XS3oFmofiFuDFACYBJrwZzHsL/GTzCr3upYoWdrsjybcWO+jn1KdgATlGoUek5Xk//6Os1+PU5ozWO6IJkH4E1TkscwZLh+Z+JEYHAEDFVleXp7H/Ct6tujDBCIbdKMPQ3GtsoAXTfFap++INdZQtenINJmU2WJWQnD6sR5XJWolyjqJVOARo6DZGnwZJZDnnnvf4Jmmw6lN075xDH2E3fFyrddPug1L3vvmKMEuf1+1hbJ0Zm8Fi7WNvqwUVCnRwOMoaua3byoyAdFaiTdeBtvpGd3zecwCMZNWgThSODStqNjwhmNHiiFhbL7giKOKbOSdGYtmFnTPD7SzS5yVIIiWtmODtWyIdCahiY4ogJByPuEpt4cBps36mmGryFkoCIwsQL0ApiNJALpyIrxSmcSgGFLUUcdJdE70uAHDDdqVI0eeHZ/dcUQH96FOIIlU4+O3W3yu/O8Iou/y+lNQrOe/D7y1HsKtqfk46G/wBkgiUArGoUe/MQIfAkkNZ3AcvcQbT03uF0tsrMaoqUxAAJjZ/qnPaK8mQXG8VlIdLNQGlSJrJHFqYM5yZ04F9pDXYv9kyTk8cz7efaYsI+sVIMwxud0PBV0u5z6lIXOvcNJckK6o3KQvLB0mr4+iNgDRzpS6D/VOYwgUtmBDQqzioIGVCgPdP2EKL3gAfqZjyAjJ7B20nT/R+i53Q/h9K1QwEn1DE156TFGwWdcGaOL359tOvDeklrgpkgirduI551vVKjKdrcOwb0W/I25s9ik+qXUXbaoK9Ujt2kCtpyt+1MRYraU9Jl/WKdG9bjBdTWWkvBZFJn9sM0Zp/Sdjrfkf9OrdFl61TK+3hf64WbO4Pln45/ZOaBj3CDJw9vFEzJ1YZ8NNMWKvQGTLRGL1NcqCEspkPJH0k9BM1zOYKdcsWI11m++pzogJ9bDvhjymrU4FTgCcqD/mJHE5R/nDaLvep+1M9V1VOcbujG4Iovv67cnyU4i3iKT1oHBER3NCHV6hFaM/3mFgHwQAnvXrKtZhfMZSCJaIv/tt4jp1IZcEK8lWEbL11TMdBdAqV9EBTqI9gs1KsBwIH7DTqqx3+ORx4uWEQyn+GhCGhCDTeC9D3UpAhZYC0jy5YiVUZpYQ10j2cG1hjs1khJ6Q2RwWsrglWZo132Any4JDPORGMMsJhfBPb+EUaRdpp5VDG9O7pkRKIH0FF/rSsz1qdH2BcY7Veaj8eyrVuzdNCJgBXvsSfkGVUlOOsnis+Q6RvMUkNLsbnDCcnRadS/MiuJS3s5vZBEeCmRuAiJ/VYg+YAJEW7BOm+mUuWZPsOML7lppPofeREBahfRV+HVFRd4A7M84M+muDzV2WIoxvT7jaE9blslAXO6DNnZDVK9SOR4ilzJHHc88FCv5p8CXjXzzC4aYVmvuiDZk2c2PFp6Fbv38Av04E4vNatJbzB2tmenmKvPl08OmElhzLdiSxgoUkbvw1p8GlYplHazmbjYM+cPvM4fVtqC7K3Xi0KAwpbBcJ4PgOY2RTDdhj2uk6FZeETdO7kuQO2OO+K+lN9oyx99ing2V/EvTZCUIpzXEIg3Djy2D9wGGWbMzNAevYDUEc2jttB2GqfHbHxLooKxzWw6dF0hdSso+BRJAoHewjl3VwCrwURlQj9vADROocw0s7pEQZd7CtkGRGSEUkxlgsKzIjwFcxxIW4Cxpm4KoVuscKIkA/2ngQQFd9h4pVQlv/zVrDG/okD1x9QGF4K+NRxIKQLTUI9K2M9yVcHQKtf5S/W2jmn4xsCGUGJTlY1jJEZ6xc6iGddlRLQ0nOkgBpaiz2l5bsENeR9GZgV+xqFRTpoNPbfW1jhG2FyR7uxl6bbTwvM2NaJ4XWcxI63mczYZHNNz0+OwlefJ5catud7FFvcgBcDZCK1vHqaxOB4grJ4An0EudJUi/sNmlysnmNrvS0gjDgCOVQ1UIyiFGL1DcCzADFV4a69ciluOJ+zsdX6m+366mL+Y+iDLCkHm3V8t/v7Smhu8a67WHK64BAXT4nM6uMn+p51ozQbfLp+lPqGL6B88gLHSGN+lTKOWr1V+VxKyUkWM/Mj19a3tArAR7GzRNfjzx7tBsH2n7b+nU0wwKhsnRpaj38e2oIdv+N2kfL3Wk5TOB97CxT5XIB26RfcepY0peKBH6WWVBb2pccglor08TkCnvU9gvZxSNBw2D6B0LDPXqpQPhqqsyIjOXTSflLAh6hIw9qfVH3PrkyXkwwZoHJXR+R+aFQBCTGJRjQV3bBrOtuYkPLmP2Kn0X7GNdkeaMvwP280snBfERCj7hpONQ8IfDdUItI1mjgCKAVBwlVPQcIjpJNRHK9raJak3jkGgRhfsZsWYfB8u727v7tnW9LQhkkKvsOqbzLx1YLpXG8Vsz+M70bWi7ALkCcjYhXHzuaVZjtImRouLTHL9HFUJYdGWhWsjsw8jBjgDKywZJM2MJcOJI6jajEsVW4VVoBRSFVFrJj6eKu3bz/4jduLWzzg/h5uzk5uP2jfWHoEL148p6Mqb1pfE4pHvw80XELBujjiP6zqwXWdds9UnV0jEbxHmrO6tPxz3wBkeWmykC6BqfsjDiSFmo7pNczvMhdTADp70aqHYpXcSQhuoZk9OXFKHHeXQLS3O1nJPL6pd7w/p46yQNUkRxFXfn0k8S+CDANmN/5FVGhkJforPcYiTer8HQCkZ5fUY6uwbp1m14/J+E709lfq/RuYZbrOGteldaKMAvbqM4paSCWHMt3HoOwjtvHbkE4+Uf1sorxuLJslJ0ryTDW89r0kKdNZXAncmw7dRtarwa20VRSN59OLWfT1++zQUOOwbMG/rf9hrB4Su88+FbzpQbURglIxouc9B7FH+A6hzWb2g4c6sRJbHBIrKaZX1EPk4o1NSHiYHRodPAjoBiji1y77xOg8djxXoLeP6AOgpoMjiyDj6Em6R8zkMkdYq68pW1+8vL39wJ4/iGQBt1dqsIM6u/rQC1Aory8ssfGntluRAi9f/cj2QGih9ynNk/MVx9MXgCxFa5DoFFxdskWMwkSrQ5EGgPfYpbO4/f3gCq1gVzRO+k6w98U/ajQ94k0zD7a2ooQWAisdimtRqu8MUOP23vxGD8RC5YJJPTkl1Kb7VecDedYI9KhvMfZfZ+GcvyFQfJegAyVAoZQVZExfHsJXgadsGLVBk8mM62b14fbdTO/UMg8wZZkabkHUP7m4WcyfLNcrvgAwXzAt8MzTAhDZZ2U6XA8vcndBUXrSQbKAzt5w3a6/EOLstYh0L6T5ASXs6FbMJ1ObFgq7aogQBe6nj4LZbmKH3nyJYrJg6kMUiPZtZDOya1zix6XSScx1F1fWSBgCG+7E7iS06imxg34KqYd73kZ9H45/zXrFLwhwzB0Nsoupatgdmfy7lmk7kM4EOpsnuNZn41bVrvLptCYl5uc72rEef1bUh1z79X/QVuioy6DWoyxcPBz8lm+8BCxb8vNbPh4kKkxMolmgwqq4uywwmudgGOc2XRbXJPvZ5qkjlYrzQZUIqkwyhknbng3ynP3oiQFVP7pupQK/PIesbtqyls10tI5dThFGszjlq7hn56mKReTsghB/K3xR5EOOECaW/zD4zuA68RZj88A00KAV/2yz46haPQEvc85CFcKK2nGWoDngUonz8EDM5vXrl4r+ObR1o/bxZCn3ZLog0OPDSew3qthrerGYzUGHVJ980iY/IkCClWfpPxMAbAVPb4TughZ2I3uzZn3IQjVxT0Eg6aF6clg5p8pkAMpzgVeCeyhdtzbewZDQ8WCygiBXtICR7AHXkXpyZeXKdBd6TwV6wObQVRZ+uFlczbbThT45d7HyFp+aC8IP3AmEDt/hk7vX88UlfcfFHGfh3Q+1MS0fo2KpwVV9OY9oRB+ODtCBvp0JXeRccVEJXKKba482SwFFIuaM65ONtF5G5lUWSqGBiqknFv/gjizZtT5Smn+pa5IVNEwY3YfZdRcFdF9rDNF+LjvYAqeY+xTakYoioteVRrJ4eLSPruHem+qsNji5ugUD/QzycptWDjEJ/90ePXM96YNCKPy6Dx7aX8lj2wgutNqjxmMWlxqOqV28jZ5vm2ye4BM91PH6J5tU/dedieqjCA2GjbXvO6oGXpHNehawUcnx4xZtdmGrEj7GwiV+mU5VqGxFUcMOJTLpPI7SgO/JFvz33i97WP0ciu08nR7UABK4KLzRogXiKS3un6y/In8x+97LFVhOTdBPoYsULaVIyKsvmChgPJVQDDiBDv8UFkUsExloFUoB5R8HJ0KvnJ290WLuKfum32xZgU2cP3tJBEUoR+h/v7ljmXYM2WpiAep4sdPxldh55DdiPGARssE8VJJoFoWzCwvbEkkvyeeorimdHNBFx51UJ1M6Yfblfvl9e/a3hdXGyDPLwDtczd14fFawLbIHUuq849ODDDi+i1wvR2PbooJ24URZRquTGBw7BbGjFAuCl18SW29nP9JF1aocWV3NOpks4EOITSPjgETb0+0X6/sUaSuu37W+p4Dk7sJUidzGHiknNXD+WlrRA04CwoNFARRh0Q2WWzNXIMQfBY+Dclah8a6v1/wLFqLpCcBNnRW9e2CZ7oGIEtpIhwjRBLPynMtKoEkTINNUiiafrOGPzQz+To1lUuE99PO2g/9Z9U/1qH5Bjrbv8O9aSDny160ydb5mb8iQIxNR64ewZzw0uRcqzR6kHatWk5CuWmTp3TdYpVvjmqn6Ip96XUBP7IXf+PK3WcdbPWn3zhC2I6qEZ8+LB4beAeDIulRoo66JKv1UjyLpQjpOeBenTwIWNuccCQweFcyJh9AyuUaLdUNoIxvoWb0W9S8TEPX9ZdbtnLUasJP8KCIbRVEKSjSASUKbd+rFytV6zZeMFLdQrt0VFYQzMK/QR69UClslHBeXDD94X0UVugJcg63iKaFwuASZuhpgTPU8YK5Ne+hebNklHQWQzpoilktoLoClHSL2YzHCM/htWOC/5mtK4goQPTmLuUdhWTVEkKXlSeS5TqWh6iJsqxR01qCmTgU5+upa1qitYQ1ySKbN7xDqGu7O6DUwmVyyV1rGbLLozddZ1nMVUQOqbIAsTq3mQ590EER9POMkRDuyXhcxpnagIoGDTObadJ/295skgaweIinxkeup7vibGQpB3PWSOJ7vvqz83cJcKKeGJm6cZLXgEX4lJP3pHtKL5+qo2Ovk3cjl3ZgJu2PFTaLpNfhJE4FQU6qQEYt0HylXHtZi11y7IpHscjnVBcuFnxNHWaC0aZk+itl+omhy8EJWIwu80fRthP0yPjZG1vljK9I05oA+R+lcEJ3iOpmNHk1zRuk6b/5aXydIOCO32Qf1A5Gq1vsrA3WvityvyspU0I5rXw+pA7UA9VGN7x+XI9wja1e2C+mwWPA5bh6gqFCVLPujFYxryIpzBmdghpAolSzhp6TL2ZLj+AxbuK81j6gLJO35h+N0fnCqrvGGvUL7bKXVNbS+o4S9TOwmwu85kuEddSgAYSOUNZuVw12j+BfzlwTRRDAEJjAgChe+IhYgCoIUzrAcCGxts8OYPCvvGYB9A370JRpuSiCUFAmXTk6sSItl1/CTAqvVdPFGHYKllu8TiWkXRzEibiMqS1WCAQro9WMfwc+qkZTCccCT5UmKC7Xg27MIKeSr7rWkUL6oikNHSOrHSAqZfYUlmm66vrcCynmDZKWKWb6WXy/u45ORU6JbiyZW2CBqQrqRaGLvz4vH7j2EknsXrWY/aPdL19uyHXQHqpaecTA2T6C8uwloVFUtAnVt+uTHNV+B2E7esHBts71U13L1TJWJfYdAtROLm0JvlSju1/eDFfcnXpYGRHlzF5ZI1Quwf0LIL/AruZiUoAxNSHPXsxOR6NVlpgr6gz+0+KHgPseqNjm6yKiR7ispJSPosAWc6YVzPgABAABJREFU6jrpxtStF4dsoFRikKAjLn1Pm0NnvENUL7dBTdpUbUiNwZjnas/v7B7OFjMGB8TK5jXVTs/kCK1s/zIdIkJ62d4lTpnOKpX1KtMZYSjRY89ekjFtZGKq0Klt4nyo3F6FXLCPmzSx5mX0OBxzDkc+bXX68Dt+2d26zd2Bsr30yGFF7E5CmLEA7IpSCoxm8X6iFpffAUBYqWkrWy8Mdl4bRLsE57JB2mq0VTqvJuO5hSYPYY1hHcJWe+3w+IoNq/1opWGfPeIwX8YjsKJroXiZKHuxuCIK8aDpZLm8Z9SfF2sV72/X2veHYXWiGX1mlaBczxLWCTmIIoxBJHGQBt0zb8IgB0epMSIUMiYnARX+sMsQk8AaLt3e3y9hSijGAOqa9zgvF4qOHExVsZFiKSmvxyX/WRZiDAVfkg1PpPjEFfG8/8tcAl+k0r+khzVNiKRHHuJ96JFokHsM9U5ancExvOo0YYg6152KGbed2Kk0KhVyCtQaoJZJSIZxkhcpMq4sR4s7draTBS4YauHkIOCCwCcpNOqPM9DeeK18W8G1aqJB94q9XSgcQsLUv1RUbjR5l7xKFAJwEiW04c+S67KKOYoCMYUG/RVkgOkehe4Q7hF6JiDDwwzF3ty50GX1l7PVQ4htr5ISvoDVPKRuE+a8C8S3D8FFn09ns0B3M5yN/RCjaOY4D+H9HMo+zVoM3EiPpzCS2k6Wxesp4peK2jhq956+TifP/X4yuj/XZlX2eIb7nWVpSVXyDHg2QhRhgSPrVbIeTOceYcjKuKXOGXhEIuvfqFqGZ57t0foSktNtwsyhnci1axdlyCk17WvNzHxvIqoTximrNtw738t2AKG3vn33Qhvecw+G0D7+LVulqneMEJhRx9pBw9e8HUSE/L0zxakYUVDEo2hJz5n5xa/evH7zX/7d/+z3/+DPP7l5en1ztbpfXl5ePn/x4je/+RcMxs+0uELj6bygy2IGdu4hwCJqIdDZzN84XFOoZEkR3lcBl0GTCcE9fQt2c5dAxUxC1+IfvberWF1jpH7kES2xxygA1lEziKsxXOBaWsHMA1vAeKQfiEM9gHo/mOhfH10FR6tAWDDCvpCQTS9WTzfLm8kTwkHeYeAdA2zy1lLSQ0PaRF7fpiVOo7Q6yvF1qcBjlbHk4FDh9F6DMcWySVDvcEspO2hfKqxalZa78QzxCZmlGpUW8COpvX1I9H0LuRJ34rXUdphVbfbDaktPJTjJtTS/FME3MIf+BsttDMY7NTaviSV1RIGtN3f6IG98CRh/YR6BkX51Hel2gkZvgY4tLoRv6271gLx5SaoYSwyutPpSIudvBNBvKwPwWqgmh5ODqqvglNVWqQ7cksMfA4aVV6ZtvkLHyewlec9qqZxablZfycdnP6J/1WMJVtH0kRY3DjKaFmsfLjCGBZdPjNFPmzbXOqT9lCvKW8+uoqw/2aZqQ2rUg8/VGmYrs4ez8Ttx4pZp8dsB4pd3/bUgnRx2qEelyhYs04nZYLsETqlVmT5KnUTUoUmUjGujml+foge0IywwSkKheajXOSczitU5kJq7/FWOyHd7cLRzSIBHVDSeNWdi+ZhszulGI/SummAE6iEoZS1y+pQ2eehWzUoeUsuEe6gNSzuU6SNEn4XkUP1PE3qYpY29j0RGVHCl4EmD5/PF4t3bd3/7b/+tq6s5MQ3BNwiEO+Atrq6+/PLFWmEPwYm+s0vYT1jDnjs3109AduWEqcMBvoL7AFd66KpIKeHAOVJEYzBQEAUEpqzelhRGRllIvbxfLgGSZ0KAkAkW0/V0aaBCPQVPhGkaQ2VJEnzul6vr6bXmMgCrDvy7nM/YBWilGFLhY1LT0uPUhhSF50m6dudhNYZLQ5wMZbKipkVyDMdROCFkFKqRSjUzbSgWWZ1pSYXXuqoWakYlAdJhFBuicIXX4EwuFnqHRV1FVqepa/v6zVvK8Q53MOWU0WmdL7ZXV9cwI6/u5Ravi36DHElhvSH0DFb3a/qcz5/wVQFijDt3auk6QEqvdfr23Zvbuw98fkKdC/Hy/eQthiRTmqIw2vGRivn72w8/fP/9mzevNpOf1Dlg2d1qg4u/ePr8yy+/5nt2VhUC33WqWsdBlVX7fYeYGCcn9lF8Lv+ULDCmjT8lfX/5unwqLZL10P19rg5APCsGGrHoFQ1gnVh0rl5pqHGuseFhPufVGc3jAZ/PY0xajt/ndHCAvOYwY9j14LRrmr0mi+gh7QAfQQKXLDFzzL1zIMMtlUlGJtr1TYTVvRDK7CpSwU/lv6Pf8d7BWqlynK8qFGF77D9K04iCtFfQogiFY7vc/vby6dub60tWARGIUJwiqc32yc2TP/zDvxwDnAqpiWocfDF2ykodxe8eWZ/M34pZRGgKl8Qh/inHamzF3yqWPEBrxuO3E8bjScKH0H/zJfQbxkcZE91s+NgXHwcwtgb/Fb7p4CVgPvFLmCdmrgPBH2nsr2HRZ8+fXi4Y8NciDIkX4b1f9aT3wBbsHNYgXYUAROpO36WMcHy0x9f7vwZQ0TSuTZa14nKGoVZwSkZVcaU6zwCr6sfY/wFzGuI7dERdezFk57B2Uq9SJM2rYO0M2TFhc/9ntPpkTusQU6sTqCzhPT6hCSTYRr8O4vVPL7/DQ/CRyZR3CeS66q5uvoaIN0zMFbKLF8+/vLl6hudyC8RKWjGWWmL16vXL9+/e6RsDWxbC3b148cW333y7vGeb2oUcZUI3A+ErOsCr5erDhw9zNvxBGCL0tWx6EFIrdaClLu66ZZbrf/yTP/nTP/0/r5d8olozFdSBnsb96vZf/yt/7d/99769n9zp3pBKybGtbbSmk1XLdRgplasC4lE8EwJ5O/9uiCqTNxId47uDT7kO/AbHj5I9eWw4bDfGgvGrkefhT6ku4srGL3+PynQS8ZHapUOTA+t8Np8ZtEBbqfFyoxXG47dllZAD+HQ6XOUWsx/geq4OgB8bpZY/x3S0UzZaTpxYl04+ASzvzxOlZPLgeQrnU2izGiMTjykLlRDX2RwjtT0dbUA6Ree2xsFe5mhoQEcbYFdOqORoQ6ozRq7PbBmioUsCIg2rE9Yw1Lnwl3+ZGdBbjA7ERbFSzK2gRYG3uCbxYhshtQ1SnUIuUY/wQqRoPG7KVa92Mn5LD4OBe4ImL/ihEGRWbYiKJFmN93qCQluWKphDNuI0BcxIq95LZtsfPhTAhID+MbKrWkMHVuOAVgHd7qhldmDXrresxGund2Q51dKjTfWgkGR+1erBVMmVLWqShXUVFnhKyskC5BaClICZqSE1pM5qUZ/lafibx+/ttLjEwq2Pc04WM1ax8TWJKzxhOn8vtuDLSdg2lBF89SHwKlLipy6jxN3df1hvlxebuXoFW8J7XoOJvocmHVgCZ/F0HzRRwE3B7JRCf7kfDJlM4O0Vvj7h1WtSUrcJE2b0cVerJZjz6UIuK5lzpheYHMC/ce3wULtq2CpbbGcd2HVAc3lRBubn4zwW2GP08wipcaEdP7dfzSKfM2GBmlucqwPAZtnsTjqwdu3kPnQof3p/MfiMOYesPfUawSj4nKVPP0JaQime402iPMbfKAgN+WomR6edw3M6OY+xUidOcKv5ZF2tTqo6SsrF+P38R2U764iUUvl2i5SzAWAOaNWpwDBQDP26XkO3vRYYZruv9IBK7EctzSfBiuWJxRXlEOUTNxOLxOeTCGyITrRgmjBms11uVoQlxDEyqmIpYrE1K+YJYjRqu9U7AIqg+EcAZbbggUsu1CLe4Su/AAm8KjU09k9PgAgsaBiKfQm2VnGIFCF8YkwjstAJohhJBYqdWPDPKC8wae+RXMItQjr1RZbb7aVCMU9WiAIsoaXDKkWsZbaVOlW5hedMJMSkQE5f+R1cPV8b3ZfaBX0wRcG3VerYa03K4UzQq3vc/XBWoyjCji1UzwIJGnaKFokz7Td7ax8gXmY5v91KPgcyGEJyJK2rGGzp+N0LU5+UBknfg9tMXvqtcXmOhdCHxJl5ZQQAMwwvxGL2xt7FvrME8UTllwr56Q/MmV/Cf/R/O7mVlA3vpkOpdwvUG+WVEzkt/YIXyGKegQ9W8x0yOaOEUcCretuLBdNcvHCgDgbKq7ugDxpf3G3er9YoDBR8VNC94JPxONUPMwXElf84ef0QH5fUwe7nwLiFP7xyuvN3pMG5zLbxxz//Sz5nTuvBdfxRWXwPh/J3oUwH2QPawbHZwO8+CrTbZU9lHrG4T7dksR+typgWPDBG7ZPbV/VD8R+KD+7om9z38rk6ACgL05Ge3lezTwPeqEcje3Ydq+Y4J+Pg+UCt0WmQTuCYKh1NGMwhj2NMZQPnRImVwJ/FNZtnj7Z1vHpugNQGBdsERB76hK5CJP5pbxKG0TXcfjFjYoCMBtcpJj5ROKPgCiwSjsP07ICNOaq80qGC7bQwirlIkKiI49xtUMCkVykd5yvqIsq3XOYldhG8+yEAtOwn5PBOpTWR7toEho8Ta2wVbn4/OkL/KqSqFKnyoU4FzdfQu629KsmRqTowKh7NoqBs0FfIj33NyrgmbaWA5DqO1y34dOMHR5gmpBpuLdOgzyTE2gTTuJ2bVnwiWrY/pnrgJwTmc2aq+BQXg/JgKDTn8BwS/mGvA5tuJ0n5lcJ8eOifupOE7/QN7EwYAUzuAnuoxEoqByRE9ureQqPbg/5D1cO0JnJFWVC+LKHiQ4dDVqWTzZSB5tL4pDH32Zw9goyLijrot6hnq8P4keQsds6k0lzwsRJZoVCgkf0IWtXtdUYFHoxxr47R0r3Fnwt+fhY4x/1RuIUfR/ML7fXBTx5f9m0cPf2heHjUVksb1HzXuMFtTA+sJOmRXqK00+fqJZe3azkq3JZYQpAOYR9+u08PbRizZHKu9BGc0RD9OzxhhE59tS5J25xrXlSiFuk2VVFYS47RAYJsmc4WqXEk0/bDNqRJ053Xrcdbet2FgsaMRN/uW/10zZK+XX2aeEUeraTemCPwohoOpJQUUGPnDq5YwkyCCEXDnypYTWasZ5goLlLABLoWQmjEVKGY6RU9RX8gMRMWsZHYKtSWZlutzIkwTODqcCRuhhKmPw7FQbMZCyYQB4i+h1ZruETj+sJT1AZSiCCl4VWW/Vwsmbwg7FLYL/3QEAn0U56Dzip/Cwiu5jd42mnZQCu/jGsNGuXKlm8L1MbpZYbSAh20NfyO8h1oeA6BfX4QNbTPj+0hdjZ08C2lj98pKHPaKeeUuNFc8faFBbHbEsilfTJJr8XBoFdHwwmDsB4GNLotKcFuY6C6ux2d4wJrTRIR/m/xIm1fq1d11TMM5yPEp2egQH578Sb5o3izXogI3B7ojiXLz5gFszPTEb1SzxNeeitdnQgwJZr/m81s/sqimYLgQeH+gF1UIiwJpm53FNcbwNpCFyWW0nOy/mayuru4/NE1UyXElMM/8+5pKFeYh1IjCFw/CqRdQcfYfxQe+stuKkQgPM3ZVrFHpzrjn/87XdlgaXg9QoFaw+yseYFMsoZfLypzTU5dc78l/t70eDvkX1XZc8yvlVtwPP+2qsM26SgttOoobQs4CnJwjQpPPlSrQ/HLCvXS+gnQnqMract0sTtfCa6nwy99p/nHOWYAOu+8OmHkSrfepSHfZbrIfmdgh5rhgSwX7XmoMrQSJGN84Wj+nY4wRmIn4aFABEUFj7DMobIOwn80C+zTap8iYUFxqWypUFiRBlHRjMCHINoLcvjlmfGbp6U+hPtsrhKmJ4wB1bGNewK0h0UqtlZKkbYOMzVrPaWyV6owAprAU+REXpMJSQkEaBk23/litJTF1Suv5FHor5hMMwLIFUstpVAwSCgWvFCccpjx4+SJDKvBSaEYxNLCOV1NE4DQL8rqZ2lbHYm4yp52zYz7ZR8pIDHMApJpVOF09FSkB1xR7b9WAqrrfooODLSAvqGL2lgNJlcjFR4nz1TzK06Xs8EMz9RQv4J3AnWF/4LqZH+1i4o/ZATvU80UwcMhPCAz4Sz/FhucXN+9AEG9BjkXa4rkWjADsKW7KbVwXbD17q9lyYvDP+3Pdm/yCSpcNqf14dpM+ETFfMZOtzN+x107LiBHr0SgpjE6jNYG9ZP1l7S5/E5COj3wU7BEQ7FoSM6fj4ewQDyCTjVvtFlNv3YzFsUhNQMa2YAXOvmXdOBLwEV/KPMMvyFbG23tlJRpxiSKHmFC75K+l1NHn6/NuQ3Zy3ccQof0cYRgRcPW+oIj9Czxy/RosU3Ewj2aRZ38sz80scfl8aKdxBH1Hcd1D9Zh3tr2wzakR2CnxcBtGy1aP2ZgasyGbdJT2jdW1x4hCE2Ak5h/v2uK0MH7BF/Mf6hpRCatFo2xRsdWiqoJfhasRbhYfTO9vN5cMKqn2Mlx1XLCJIAQiIQAK3aJ8N+cpYTjJzeMgzUQHJ1RLh7K5SNsBSQkq1RBl5ho5oGISrzhqHFYOgGKtKARP9ZmKNhyhGWhQvTgaIR4KEzjMg+2IuQHwcP/DP3egnVxwXyFGMWKDEOEpCOCNqugrL4GQAfoR51rO9ML0H2ItrskQTvG6UN4nFvEbfzd93T7BEV7BcMKx2P/dVBVVLtmFGtSSocDhS0Fa9SRmbKJDda7ahaJW+bvwsw/wJn5kCD5HN64XX2pgHpq75WfUGvgnDQUz5sqt4yj4wQbbboP6Ob6ZnpxA8Sitmzao5du+Zsxrs/7uiwk8wvmMPF9B8l6hcOrG+oepV6Dmc2Z/rpdrW/VXd2u75kfY3NQOyYb+sA6LTNSCzAT5bcO5MjQco/L70jHlY4HymhGYTLXy7/zuT5soVmGHydz5IKVjKKEkpH1NRsKcO+hrgjN0Ft+loJQKj//3QLRDkeyF4fieTj8W1w+mYcx29r04Zc8UwuYmLTMPjj325ZyCiTHZrJJIVdqVEeZrmDHX/tsEhw7Sovf0I7SICta83jNjqXs1aqHYeDL4BVCTlSA3muvrMJKxRO00XSRlbQmn+R5FWkotEP3Dx9vFzX49ar5ueDnZoHsAOMVxxnCT8aTfCKYw5X91Co1rO1pJj2Yt43TYyE9HSIwrFyDqMISODvAUDTlQcrtdrlcL9moRDEysZEOD73rY0nsqCgIUY3jmMLNxIwScVV8rUMpQArPINsJjtI4B7a0lihFUDwuRQIhuxER/auzUbGSJgqOwCS0kVYK5sm476AUEvWKAigMsbKnikWLQN0JyqWmrj5LV6kRkwgSQ4GOUCAKA5LOqdzktYKjMqGGSa3HSCZZiQ78VBZ17CgfBepSptC1l0dWLCcS6gjiUmZOV3Rlddy7o+mZ3qG5cBCQ3G5uYZqO/qHXz0sJ2l8HNN5MFgBOTtRPF5Kd98ne3S0XC1aL4Vn6XLA8xN6uWPzi4umzp+BHj5QLvdDvf/sDMwsKUifcIOCQlm+zxRB9BbuZAnbJlMtpNyq+VkFaWfmulEKBOWG/1q3pBQBmsVQFkis6u+rwqg8ibaROiv9F6MMsqsyR13PwqJSRmasj0iWkKhl7PYV2rIwReNlAuUYZMoL6/ChZOvrkNGJyFuAnYrrzV/4ROWYzZiNnyENqkaW1hPSVFI3tBwXbC9Q9o8XpUQC1vs4JEtu9xjbnNuQEgSVpjECMWlluMsYMMD799WgszrU+3Ag9S/wyHVr1+UCpc07LMdrWy8UN3QzPvnSqCw3KLVTYkzxVjS722DBXs6t8CNZuEbBLbkoXdS+LEt9hH+guzc3e5Nf3lk4v/AdpIS78EU5UR+yzJK+N4DiiX4KW+H7ujxfze6ITohyGSMFiC6DJDFUdyjvwFqMq0DFT8Y8YJ2QhUNghshIMBKYmpcjRkkI5DYBqrb/WU2uJBKw08g8iKy1Y06+DYCsifb0cqWB/Orm6utK7CpoyiP4AizTE22N1cFNgpW+1aokHY9KSS9QoKYqwKBc2UF3yEfrFavWusf8aclABEu99B3vtg5lHvnfoQdzBeIcSK/IjX67O32GQkh7BRalc1NqtKKoc54xVJergQaUSyU6ShSbZmU+DRRQnJHFolAfTkmfSf+EmU/w8nb+mZacX82dPX9xcXRNns4kPb/0uV7cvX/401R5TONDXcvfJS9gvl/cf3k/Wyy/42vRk/hKJ6tzSidQ35m5xHrgxAg8EZPzt6ZNnZGcz3lehhI9UxCJbBey4uF5EQbg6mrpZkHV5yT6jVxerL+Q7s1fysXQnbN++Xcux6R+IFR0KhMZmnyhHYxHza6GdSvV+CwnPAIQRjj/rdlBjdNr2eLb11fON1f+nsN3Rls/D4rm6Q6hSnU/mqrD/egjPsF62YU70c3/YkoYCjWyWXc5jZOADJUpZZTqJK1vzgTQYYDvY1tBhwOI5I0Zh0vLGyZABOWcqkjq1Gf5QzhqkmfzvLarSSeVKHzgDIDlVVcVP+WCp3C/pqFXz51mxx6mCPKm4GQ71hvCocxk4lBnQIWyyFy30GeBzusKhw+l8Whyiii1wL2CEIk1DOG86xSUESxp9JK5mPYMX0xAK8ZIj4bKj5S3hF//rRxnip2dnQoj4J2m1U84hnMZGiXf45NcKn9PYK1ERsdhSb+4aA9FaekHEpP4CATu7kPK6JVm9JwwIEv5Ptbs7X3MVMxRn6FcjqzBcsUU727enDgNFIgjNvMCbZGTRLAmsV0w5l3WApVB6YEZ1Cpygifo2jVWgVckeEVXx/mspL2F3gPbzeQiMXP9sDtnN/xGnnlntSHk7W0ma0/IZNTVUi8u5vhXNF7kW7M1/rQ14Jku+U/H23ezlT68Qotb28n8G7P06CTG3+o30Iy82+nQXziP3pl+7JDpXN1dFmkvSYh/tHCQW6iWCSP9ALW2IdEYLnwHheTobkKsmBHskaNCK3N1ZweTUroXqRUeUlUKIwV8RzREBk0Tby4A47TIJwQgGBeDz+eNbILdHTjyyTnKkmpscKb9wtCM5/EzJwoCl8iXkcZvVD5OsSqlHBpJAJx9Vkw3MAHT1gZpVqtjBs6MPF6K6+ETJ+c8ftdc4fuw/Kn7kOESP1Xrt34PfAf5Y1ju33MIryx/BXY377o7AKHdRGMbccTw6de66j/mND/tE1UpbtSqhwupJkQoFcjQicpdpzYwiEwUlBCOMV2rxPAsbCLsZiifuvvfyaIc6iarFNnGHozAsRKfikAiFVNvNh/e3Ky3UFia4CPEoqcIgYn8iM6+pkHDSCs40hCpMoeus2YAQRM7hGhE/AZnCRLHjO00KGQn4NHIcgRPxFpTKutLipD3dkXIjiI6ooLHIOAwTOJVGSjroDwV02ZUZppMOYyiRy7t2vAHL5RkpU5YQqssa+uoo0wHbPNd1+iZywTPL79z/J0rjXJcEj2BQaB58O887MSqeePV/ASuSiS1GjQOxTlb5lLVNE4ouNF18aUHNzR8r5hfrBQtmFC7T0CxOg5JRf/b+Z/m/eOq0nf1EQmtxSBP9X9If/Im0XuDVzBUj8drxls4AK3kcruMVwqUO4qougFQheheF1EAXiwpvknfIkyQgqsLcgiU7Cwhi+W4AKQE5UYiRXF2kkjSfzNipiS6L6jeJbkCIk3jwLNraJUXE/WMc5e9dmT6XLrVfwPM/V6su1pnUpV3iyIkKsP966FqD4Jh/19oC7HFylXa71KxapwyqgGUOdZShXCmrTA/RDMSZw2SHlrb8Z8AODd7ZzqV9Gji1bE+EXEos0zXaIlOzYXiVNajN8APRg8aHZi31fDrgMHmBfxBxQTeQLFmW6QGSX3zRz8gO+FZyr9Gt8qC1aysTGrbhDX0DYS9ag+oTyI6s3/5m6mIUcQi1JODgQcKQ/5JoiBaMmYAJWxMyBkrEvXFILazthkHR2AVIkZAsCn5pWDjV8n4mIUnCSCucchRjAB/w2iwh0AIjh1kRDiFVChGuibnOKlT8TxRl/gYFq4juiLAcS0EgHKFq0JWlFLFsQ1MJ0Z7qDChUUzZ0FUtl+S9DpLP1NDDoyrOQyqLI1+td4o9Pwyn+Z5JGNsP3JKI+e5D2FMtEOlL1IrP/HOg+Z8qKlahl5+AiqFo6AwLscyZVLsgzCBL56WJxybIZl+ONCtvlJw7FswTQPI2kjqL8l/1rhabWZTaJZTnsMcUXeVnVY00kAjQG/yNQx09EZnHWc6cuwOApBaSieCZNnTVUMFSIAvoQeKnx1ImhzH0L6UM0NNmuFPNv8Vi6wfpOAGLBcrVVMXFyRgkf9VwF/Xw92gLRXJDnxEhW4NMYnA8lHMn/kdE+O1anwT9O4/Z5lRspF+oTgzoAtFuv1QcCUVjljrYFVa3/IabV0cWnKqtds6VCnZxNSD39pBqLVmZMz6lFVAPQn0OTntqFpjX8yBwnt48KM5fWKKy+E93WsCQJvL6Rg06GO9a2fN+XAjt1bjAMTfqkI6jXjjslmqlOuQ2kYFvDHOFFeReFRi0azD+xLMqmBnd9J/PvmurX1giO0L6rUcRz9TXBh0ZJiTW0faGGPQEz8rm81+p7IibFOWymqE+criifTnlv8v5CZ68FUjgFXqUDmfVzZfgyQAXjqu6CohwdjvjYPYUBfoJ01ujrE2MabQXEXAM7p6xeiOP0FfERvQBKpaTJVI+IxhIfeiwemBXz6DBox1LF9xOWMEHEV4s1OmK51gD8/ISkXAdi9F0CocGdeoOYipxeP0X4ZPY+0ylwg7SiMRNOCXTRuTq/KqyQW9cJNoFx44vCVj1zbhEZEDjEmW+6y/uhqnHUI3DqcwiJrmLfz6ZWora2BVUbpW3XOFXSsK64qp3SIbzGsQMFG4oFMkfF5VqmM59t7pn6JkkJ3quVNJILhWSQ8be0aFB5g1yaf7gAKbk6K+43ayYTpAm00lezA+wvRC+AKFzIVhF0x/EgiKkP105pidIR5yjlTFY6qJoi01mejNujeKq60RzkL/QpsO3z5f31dvUr7ruLGSt9pW1hpmAtQP1Q5dX1bRyHPiUa5B8x2/4F3KPMiN+CPRxcjLWbth1B5kYUXjhAUHTyaf9uHrrWIJjn37XIcs5j1RnSToy3aihfVqfN7XTIeH1qv/snC27L7Wws5GQ7h2PsN0hPhFxKLNMnVcVul1XyABj8MmA0bygOJ9rPPXhytp778R8UI1cwJ1ri+ktaqKcAGtZoeF4je4qgB6LFTHst9RC1QOhxbMco/EC2Oopttm47cRQ/E2VemYUXPxCfKHjhj+BIB8vxMTN7mRObr7SjCWWESQrP4zUAViZcOirRiWKOOGfGOUFzFS2Wk4rFgsxRvcVmjjDVUD18Fb2JdeIu6fznSNTCUVKRndd3E59RxlofjQUTZ2m/9vl0unAEV0WEFpzosqJKIAyZUizGXM0d3oLDEDGVNlIoKSVCIcZF8CqfoFGWz93QVNxfSIktlvk0EyD0UmfKnMjUQIKslzhQ9xRnfjkhUW6/gNi2kYQVtjNDndJfBUrqBGr7HDUwMW3CwH505dTWNJR7AKDQ1N5FKgsUyHNH4GlCi0NdRDqK2vRTzcrb5+pGJtea8aUwORAfvdZ8AWG1ImvH76qUGEiMLzqHQhVM+apqgaWpefGPzklafcSMg15Y0Z2Fx+qPnjDOe7Vm31pmA4gLk6CQAMskh3zrGCwVn8/Hw1sAO8f/hxe1X8JBjX4Q8n7ZP0OMgXsrahMmemxDjZAHSmBpBuDgflK1s2yt/mRGCB5u5ejpJrZVrwiuDcgwk0Zpu+fUV99OOKJzf67BeTjbljuMH6XDVHkkIIzNuVNnWO2MVpfaOXKQzFvHrOXcFn269cFrHJzplN5GA1LWq0yXyOPl0oK7OlZ+BaswY8kz0jvkRllrxKhPt6DrKG1xaEjozLb5tCDV7eyW77NMXgvYcI/eMT/iF4xUMwejkOw4jhjeoP1we3d1eXW5WKzun7O7ypMndzM20CTeITTiBcoZg/1bvlLK2L9CE1Z4azxULINjiumjyrPaOHRDQTcVQRRfUdX7v1uW5iumUsClsX7mG7jOXyvugjWxEPR6P1jjuHEzWGIVhqlK6p1ACgNHcIrjttreke1UeEPUmAruSMBLhzoSqoCyBpqloAkI8nZyq+IN28ZD+0YRprDMhwKxwxLPhJPW9FPsAnC8Oh8U869OXIeP2ti/VaoYtuiGS5vooRZQaesG8FWngORs7xwCOxdxRE1buwmpSIbRteuIAp+n9+rCrb8W8owvMZtKSsj6W311gYGst6FW1TSV+hIBmSPxwKAXwBIgLeBhi0/aesqZj2kp3lZzucUpIwBn+F+svf7G/sbUEDtwytsUf+NcdH0hEXdeCb6Y/jBd4JnPUHCy/lLcZi/Df0BWFrbhEaJAkp9Fet08mQFW1SG2dHMnU31Aw3MOdAZwH61Big6J9rai3nRIZn+2urhaT36aTed4PbefZUW9YVNwrbgDgmmVq1/zU6IOvtBTgsVx3zXAtWd1s+yI/IgnZOvpd4QYk9j+Z+BWrIloj6nnX+2GlmH+KE0vcDcwquzw72Yf/4p66HpcbANH3X3FUepwBnsWnMtd8krwmHTbVxNV+FhkinhgDM+M03P35PJaIj2NRvh2jey4zCGaebXrIQShUlBUTuCH5nG6DlJV/AeRflmFyVG6KlUWNSzTKDqoPQ9C7tLrAFiW1dA/sygrkoGnJEpBnczrnnyKqI9OG1XJNh7SZxRSm4EtqIUT/GfLlJd/42/853/pX/1LT58+ffvmcsNO5Isf/4c//mM+eEoYPiEQAms6ubmie/Dk6vKp4iaFPQ5IFBYpjSIGtWXtCneEjp+1daeiMZMHz9nF+n51d3+nNdnwZB7CZ6Td3QLUYp7AT2LYqZ1QbrUEUcEV/DTWSoAFT/6Yr+B/xIKiAFlnCQzsUDnOwKgobLQ9qL4vTN67i7IaRGUCiq3iUHoKYiV+FbGy/Pmc2PZGZsYbcQqGJc8gyjKlzwg+pZI79LryO/gxqUKLXrYuUEQrdWTFsKfFRToKkgnVCjrclsKX9aNMhqXTN9lcznnn+2p5z+cilvIlMBScr+eXzP/QlvIE+yr7e2qH2bfv3tkJISfG1lZXTBdA9Pr1G1hbLXcfLmZ39/SHb+gbE4OLJASKm1xOuNH4uY2trKsovSU0FFcHVn1Uac48FmRKbli8hHvL3cjRF9f39VDy8rvvXv72uz/7C3/wB5ulOSRhYPkQfhaSYOQ5xKjzyOg7jF2qk+IzcJQFsmFHYZ+GFG0Mj9z+p/HbUUctdvnPKVvgkzDL8H2afSIpPPAl4EdvVHq6Iy14XC9zmKqvv9hWaZjPeLOV/eagivGDhibRoFKj1VuNHdnrbVqT31a+Vjwyc6aea7bbXq1KC5Tpkfp2ovVZafh+qbFq2781Hlbid2je4lDi96XbfNoQ08Zzvo/NDl7gySp9Y37rr9VQsx/CcgpeHHkQN19eLb7/4fs/+m//m3/0j/8HRdxe8EPAv5jP2V7zfn0PQAOqrIjWn1YvO/6NwKeweMRD3PbmvNNQv1kJzaEYJVKaP8XqGrXnv/b3VGfjYvPm9cu3717z8jF4ipUc8UDIZ5uQrsF+04uDiojEOaZ0Xa6vbzbMVSjuw8kpla7s+E6VzUXoMJQFxGSnlABWksDx9j3dDO0ho5CNRVCsqmd0ee2NWbwtJFBkXF9qh/iLC6JJiTcvpyKns+U4i5ZJghL9R+ebAw303TeAGdi+V2H1ZYMG4pgsijWUrnim/XZSzfbwgkdlzIpddS0oJ3dgbdeXNMtk9padXqGKN0AYHtdqezqbGpKv3Cial5aQjua/fia2ml8KryBDC0+v54urK/g9F+30FZ/Xev/h/eXilk1CwcCj7SdsJzV7/+H+/pYXLbzgB89jxx11MHmZmEPzXZoqsFG2F0v2kJWfk52+FB8pgVdJnbAbZ6Xi8POfsihKMBGl45L3ladXsMcpzUvdl5evf7q745PJE3yfV5GRxC64v/3hx5c/vfmX/6XL5VbvhMQR0qs7qxRSYQxcs5IZp+eZ0zEnkEmOSYx4QvZp0haXf3HaRYL4d208t04mGGr5tUpiNL09pl7+aue22bEaUd8dcldqD3+ThNw4R8t2zFR0Mc+wtiWTexmj1OFEe8KvJusE+9T45JqQOIFnySbSNTtUxSUwp/veoqyIznRFHkdxA9dm+ANuHCcP/A7AmXTcwyabLPAKnfcQ/iKLwxpFg6bfCCDR1mWtOyEl7TByWfqg6dAzV6FPw1N0GMkzzJvPp0j82LTtxu/WaCxeilrMRNYk3IlghyDn9vYDeyoSoxA7E/UA5yDAZY0PQS9hDUH1bEGeDgAXrd5RKA0X8MxIbBVeB0/lFKwYxZndyTCIdXVHghThncZAHRghSas13BlQ2BcSwCHeFipl6jA4FtMiakVkvKh8efmEwVp9qmnKgC6j/lodQkQlIdIKBYj1CPBELV35n+AqF7vJ5P7+/uXLH1RNIXPoBWg6P6RRleDN0uiKrCcvrp4+febeiOopXPHQNV8iI1LJ178RRydS4lsnb2CG+DjXEffl+mksolN4VVXzNlrUH1s0jLGTrrYg/uWzD+/fv+ObXDietuenwTZ0tOC4fnLz9c31NdZSJJ24yjmcDAOSlDFpVHDgTav5rG4f3UjCfBbTsyxIw/SpyaSBXBl8kWkfK7WkXmqX67EvEN0ANa1YJGFmzKi81AI1mlCMWtYQX4C+WAZIvhaY5J8+vaFOLpHX4M2r+/u3b9/rOwbq67J8bcn3KzwngPZsjaUvB0uipjWSiymbjkpUka+So67Qfz5qFhhvkWjuIC5a+UhuJVnm3Me2RCad8Uv4SNqS5HO60wKd5u3EfCjgXqesGptniz4E1re277DVV5N6v+2oylWK6ZHX6KHmomB8XC/zOKp2Vc7Fp+w3h5Q8ftCoL6WCeMQiqDARkEi3kRs6C7MO2ktSQ48es6Wf0ntu263RyjWhj5gJa4SVDrPM4yg5ZPkH1Hf+Q6qeZCiosRMxGPr1xebyzZv3jqe8FNneOJ3PmQuI4XQFVgRQEWExTDvRcLgeOKaBk3IpRgm7W1SELzujmsCYXq4D18lm+ZzlRlP2C9IejIrD9Q9mPMdAX0hnwXVwjVjMy/RTLXTfSKQO4irifvKMg3BVx8TzA1m1HEZJE8p0SdewBy87vFDzTH6UGppbUL0VGhI2amJEgRtfa/WqcRacLPUJWElKDINl+0zxqKPa1188+wjSeL9RdukKO80hvKnyY687cZtyDyJZJ1Wn/HZBvKvQoWUV/od9d8JlH172oFa0wYf379++fYU76TUM+ZES+Brdqusr5jQIgmkEUOVUHKLRSHz1boD8gHL/4lmEAZS+EbL6a/TgFqylidZPnUB1KJng+dWUd22nzPWphaEBx0JEFJ0+F6jF7Ry4nJpdcnzTKCMpgPQvHU5WxlLvxU6ps3BxTXUnvaEVeYGo8JJuj0TTHREjrupXTydf8R4A7ySTFI1w1fGtJO2uUBmaiuICOgkRlUdCKcp6x1NLsk8s3f7FqSno37Xeeg09dWts8q92DVrPNO2bSwspHc2Q0foT3e3Xj08Jgkqdc1uLqNCn5LHHkiXqyelzyToXn4EKtZssGrps7px+cH14NHHE/HaW2p7hpyiaXM+I2Aa05gID9e0vOp1DwbvNLOtcYD1eEn0Kez6e3CypNEik2yqFiQYMFSQlq8y/nRjg00Y+EdKuy4kMjyYfaZyj+f8cCRXK2C4Ob4iVNMSv2Flb/mvpvNdAEI5pb0TvsB6D3DxdoOSPIJsF8Q5xxAd6R0eKRRwY9cQfIpbkwIkzeRJK60+sjAIna+iMQEKrQiDhAXEfQCXpL9b6k3VcFtDgJ3wpnwi5mL+vga66KMojQiQC5O0HbcJiIMyhpcAynSOv4X8pvrjQRwakTYrElMqH4YkwpXPZyQlrn7gEc1V5p2Yq6r2U9L1IqSBwLaUUEumE4wyncIZaUWAIRBPgS1gU11J3Uk0y04vdci3NzGhHf76ENV1gcltY7S4Di8otwdk/iIzLK/x1u+aIHAyV61Vgemn818IiSwEuJ1AdOEMlRNTwiL95i1ZYnnoQtpgDMLrodIQyAuqQbj4qOmWchlj/SKcjkCEg1BdTo1HmGkgdIVCkTo7Uog4sTmIT2+Revvd27CquFfvyGlicK+3Kwh3UpS2OddzPuV4L9Nq3l2JswYltciL5WC1/oXjd90xV2WzbYbQK/eQrYvb6WdYJacIfeAcgxn1bWvX1mM/Qv3Hv02/yqYcaqkaNGueWUr80QHhMrnVUj/H+sElkyzSQyJZvEZQIkS4he01WupMIe/xhL58BhOwz8I8ql8ilp5XpEmcg3ckzKjVANVTUMzpyhG5DUtplPZa33I79/tsM9kCyt7Xw1O76M4ZiDgUys++msyer5S3hyMXqCy2VWLwEgU+pEucSSGnJMiQaphTYryqyWJm9cWBF9CIu8fQxgplXgOQGIlTSBI51rIiyk1eT2RvFOYR0fMBVwbaYopXVY1xWZMJ0b0F8FF2Zn4ST0CmtICc8FIGLBZUAXQTgKj227GYDu9k7hV0CEvU/UwQ2+yBkRpFnbwlACVBdM5IUue5AFNYp8iNE26wZq76qxlzMP51CmGVqjT5hbzmmXmJ2p6VV99EoaWRNM/47AJ07+bTlxiizTIYRfA6cVMuUceuAZGgiUZvFn0zvlIqxoYjwJ7bgjOhfo++aBFDDM7nEtybiHYxrJgmi8Sxb6aAGz42n1pVMXTjBhBF09U7pTcxnlyuF0XgE+7ooqJYaC96BWQo7HWYZm92qbyEOouZPDiA6LQJafgFkM32tW0EYcqXkPpaN34qRKHU2hjD5U51CVuBIVavtVWpG0j1Et1Ng3I4WnL3eLr+9WP96u/0n5KWDpYiNZAe78pxBSVQvosmFnZ/VJZvzpP1cHb9COp63Ifp0rXo59Dx1c5WzCTOkkWjMb+8sXeINSmlwKOlIt3/rh3+JytJQhirwv6bYoD4NBRrZpM+PBp/Ap8F2ly1/f8v0DmNcqk07BtLF23dHs6D9bmfNwk30M6ydSSy1M0Elqs87KxTh6U8DI0celajE6UguXWSVkioL9Y5Wsov9zwZW2iErXRqE9IBlBooyt3ai5HkchzbPMRDcqfCoMRQH45yxOmdkdXA1TiOojFxd+7lVGKqr4jGiGyETn7IOm/XY2kSYSMgjowpwtO5AER3xB5h0AxScqB/ApitMArAhaHBU+OLGTiHRrt0rq8YV7CCJyEmRkrQgthFf4YiB37xNw7xSLlS0nlIFQGJCwh0TKaogibdHlac4WCbW5mHmqm8lWohWG5GQRJ+ESJ9yBaAK7wRWRIpuSqRd5Flbwrpwdo/hvMBiO2XMUuIf9aBmYaO61C5YHWN0zs0m7KhZrl9OqCQyGJ4GKgqUTqoIqqaJ5uIi82oMnte1w8KRZ92LmjI1m4jJlP+kSrASt+CvZrIgua9ajX7gRu+BC8HY1sp9DEp1UAK5ZapxgUgKobZmD2hceSdsaG/7mQSFU5ih2KlGEe5X4TlIVhzMJNgKOGuAZJgqTlIDtS3a9wBI8nD1A3g1YiplRBKVMKVO4hF8MqiRSKVchvEaZL/T2b2WKluhTA9Y7dEaIOuztxbD2g6U/i4UZTO2K1sadgCtTXgCxDKHhVVqCYu/CR9EdGK8VHrMEFZ8gk2RazNq967aOAGpeo2ZXdYtJ/pIy95tH04fPNGe3HMNPjPzaa/v75M+DI/WzAaJbJyDMBdFthzPSEXj7d+PWW/xLpX7abuwR8HKupTpRDxCYlgg+wbZnM4atCG5qJmo/DPDwyyh2wF82pq3IVlGf6LDJkauvfVfkEe8G7GywZXvcK2SETuQq3wsrhF5EFt4QBVtCbmWs+l6On/NuuQYcAwighOYsVsiY/8Os1gn/Wy7eTaZ8k1cGHhsW0hhO0XQxDTBWUoBZm8WWMx/slYLUSnSZ7RVMZH4smaDl261TpqIhzJKHS5FXSW1AoOOAMl1oIRi4MCLqYu1d0wkcJIA4iaCqHvF9Vt9s8wRGnIlcjN9C5IPQYQ/9WyAhnpVR9QAag2IyixLcSF9HlaMQMISIIWMk+3Ti80T14BOwjvVJB3B1nmt0a+OHQI2KfbUr8ob1+ACsKRr4KBMHZJFN+B1rMjVvjnQhVDC4Eer6tDZJtZZR9aPLDZXG9HKyTDGN0ZqNLcgDWYEmksxt9pcY99iMOWjvOyIc6lOgV7oxeo0MrdqrDoLiTSsO3viAikHiXSho8pLvZPlN9fTpxfzf7ZcaiENLSqd1X8VofxBbub3CqwKTORlKgnnlAj7grYJ3U6+Fz2aQoIXMCMU3zFYvBKJhEsLOd7mS3KT+SsZR7DqbPZyIVWZQ4V664C85MpJpU+IxaMnL5kHUJEZ2V5gKS+eOplFkmGgCuIIwUpXqTCXHFu0FVTZxtH73Bv/TPNzte9p1hBHdjxmm/aMkAGbhJRSzxgVPnQWvVypX2oerRelZUuWEkv8Dn0MKmnb+HshDQvkVRvdhOP9oZu+vgah9VvcR9QBb9OOgZSMXJe+GC9WamCcuHE4D9u5r9X67qw+eFIwCwvxpdpVOlDW3/CsOGoXoCyCB0M8ovZUsRJ86DV7WCTyeafAoRyPxe835rEcj6ILNaL6pYdlZgHM2TMmHo7zGZV8NFbRBHF+NKEtQeEOLXAF2FOsn/WqBiR9KHrgSGEDqcgbTDShOErfTJ2sl7zOqn1QiDD4eJaDKlKsBlrwIkBsfkm4ouVA29UlSw2JhhJrLkhTECfmCq2Uli6KhyI8A2QtFMFQqgF7qaJwbMaXeolOhMwLx+y2qRhLgTgRtsMjURpdJxhMnz97Dr8I09GM0JDszfVzvfQpkUhQBWJSIeXBCHIQxFCHgn1FXYC4qDpKaTSYpU8KmPQs5I91KpjICGh4wQ6hW/TkswMIYniYINLsipMAUkI8wiRFYZVsUVUFp18lePjYj1HSZ1VlMFd351DGcy19qrJcGzLkFTapCmRpLKOIFzsy4m6u04vZ7Yf7JV/12jDyjq/QLcQZ5ryksphfaZtOsVf76s9cwsCcFTNH0+MZLKGfXFxfX13Nvlzes52OA3211GTJ3kP37EZqXdQ26nPQpTNn9UHgJBAl8tLtTy9fypGkCfylP/vBfvHFFzeX8mGqIUtIsDxFirnepKUS1qoUVe9BmUpvXSlP/2FBWuuILJQ6r/kS2cWKmoBIf0O9JPB9cDEXMqLKmSgtUIRvDX3twitIPicfzAJFg/XKqFq0F+ERCsbo+QhqfGoidBtVN1+kH1XDfOPvcxHpxgzAoUfw91mPEz+iBqvZ7l31iezqI4p1q7+V65g59fWiMsJAInbTj955X+9qnzHF/hQdSvXyyj/qXtY0rFzaeoxWh446lJqU6YYyZRHp8Ss4G4RD2cIfOtpltF9Fu4Ql26MUp7Ra2ToH8Bmt+ZBx+ssa+/pHw4Hu9dMlWeFKOVlWCdwUv+GHjtcd72i5+2K1ZjNylr8sCYunDPgzjMqbmvPL6yc3ehVY+Ckg2y5+uljQXWAlPaHxM7k049/SR7GQtAsNQd88l8jpGwRsNnyDiW0NPwglRSUeSF9P1qvlZPMVEdz08g089WFXeCpyMkdCIsfaksD/KR2AZ4vLK0aJ3S+JlUmzxeJGdWZduwivRBl7zqCANDextFEChm/fvvG3xlabtT/OKix1SLQd++qeyQCFa3o1Wu+JsrvoYv6UK5s00vnZXKxm08X1k7d8KsozDHDvPMIQXUXljjpd5RlWY2179n6pN30TQDvtpIOEjNJxqGR6L0S/n7DdPFfa7w8EhbL5iHqs1ZpaoZ7LIhE2Z9QfG4qkITJjI0tStnrlg36U3IQuJe3tcFmxMs3EzvyrW4zOEL49tGL5xfOvL6+eqqdmHxaY/8EbUDmjohiaD0r8JH58wm6hSaqQRXi9WLyUaLe1qCMkRw0pT3PLB9wNkKYiZEJMK4IEDc9GX6v9Ci+CXr4sxHTwteAqSYG1Tb+pMAxhXN1bgKW61EwmIBtWFIcUgbe8Ho2DA4A88cdOshKYAHxxAaqLpSqgwsgkmoRs5ka2cpFSWfvofe6Nfsp1PNvbYh4Rcqg+/F5jmrYd4IPh0ij+aGtERdvryBO8ssOucSrI41+7HcJ6dNjwQAvk6iAlVXY4HsgEexMFn4TbgnToX7LVR7h7j53CvSi1gj5ZbY8Ksj54H5+asF1m6zjh8A4AHKoa8gDxUySY0koDVtkJPiD1KXj5g1Vuvx3CzpW1k9n7bJzR4JtxzmjAkv9+1T89jDDFGQ1CFc/L7XCb5XbuJUXDQIpEvRGLnJF2UVIi24U2ihUYxmbzdYUY1Jzwe0aAS/CteAT5DngmjMTG4gFCFtJEwwyXssDDSw0j2BCyUiEjXSW6UlRR3ebNm9fLJR/YcgBDIKQYSGsz1vf0OtYwJZzabu8oYUxfQXlwhY9io0ohM2VNxhoybZu4tPYM186eTq74/JMDNaNLPuzDJMEsZTTSirDNEvT1enJ7dw+9Qi44qn4zon0QtCON4lQYza5vXjDtgH14OZVXIPTyqmYntE17rqf1TSdZ1yorn4SX5QekO/nX6aOOJayAFMkSg3TWK6NkWbloR6LquBni0sRIpJnVjrCeksHUx9MqGhncfPAx2gT2lAHB4+wm8gXG7j3rMqGHh/OEBlhfdJQqMWHBj3IhSIpEs8inkeAWFD+tC9J8kZrZbiMmrpaueA6U9B3MyfpIGshopx5p3CcIcXfSpOgaddDVnKyDagGBFaoSdnvzEzxVHDTrgIdrx09lOUQCM15ESTMAun+sm2+aymqhaFQ6zhYYyZ0yEqaDQv6rx6Jcm1jQz8c+C2QT50Rp6X3Uyexh/DhnPiXtQTxLwhPToVLJBPXOrkybYacRSjUeOj2sQFvhh9bnBP6HdwDKd8/d2nrq6fnzKz2JOnonrd5Vr7p9fcSqv4Wc8DDOkcisOno/R8nt0D/L2JcIHQLrFD5pzMCMhl0tZDVwGtm+nX3L2oQxyzVteRaiRBtIn1LfXraFPwzz72j9XqYPUNDytIP1KWp6gH4EPkQBimZ6j9SyVfnQsymX6TbTTS0A9Er70BIYFrHoW0zc79p6hdCfGFoOx1lvZxLqcihO85oM0uvJZvVUS9gX94px2bdeKoValhCqmQkjypaqiAwkQmvjKfwmwW4tQLazu7XW1PwoDBY6aOYBbG/+ohXiUi34OtxyProi6OS9IvmKFAtz5nPCQXAZh+bCf/+ZUhmOxEYBFuHefPprBl/vLv65lvFoVk3RJBqo+8GaETIOljRWrRZZsoKDfeqphHoKfoBpG1Dw4KGjWOuvrPTcqZA0MKzvNOobwG86qN22gkfd1SqWnoWSCHUaxMXeRBrXT+qaU5HeERlnl3VKvNO7BHKmbcGzgamsvnKAKjTynG9MC8L6M3f2sKwdD/f/BptvZ9+7mya9cR6kyKFkdxqLFIeaMfxKsE3or5+sQA0qU+NpWq6jmWet7CIdYb7p5d1ySL5BpsF2dhCit7r8AkbTq1cM8YuAJscF7JK4iMTLyOLts3QhFS5PShVRkRETqhDteEoAU1oJVBIai+yYeYpuCV4vDvpYGRNZd+4aa7UZpRDkfshOhjgiUHzSxawtQSlJloL8N45BnJT3Ujd7eAU9/Tr8bD+d/6EcxuhTGqb8vS5ltfmEdUuc3nT1ixAk+VzK7aWNAryco+ITsO6zMQ+aw9+rRrvuY+KQbvUMlcSqLlgj2/wAk2buFZ8MyJwzpEP/XNa+M4oikof++g/LqvMeytX4hF2wGgnFCfH8qJPLpjFcV4cflKtcoboe0yB7BEYtMuOQlLN7iH8RxZVx0wM56p4tQCL+U9cy8Yuo+udK9FsguUX2jg7M7CRRVqEGuFFoFGEQOSioIOUoi/CC+ISn5nTOcn/CbV5q5b/xNDguCiIzbYbj8CQiEkgccBFo8AOjONvifEpqVNpYEq7rf4R4fj3X8R1KaFhWrBTLaG29QPoUq4IRKYaK/GdMFG3pJ1h33ycM2kOnMf4Z74PytVcUEJVidC3qELk0dz1UV0sJiLjpcP0tXp8OhiFMpYOqpj8AvPGJnED2ZbJdsOtRsOZMmdISmJiGacGV7N1R5arrruS8qUqLVMcym9MHShxQmSKZuajsAHJNLAZOeS38x6kY6WfGSaurWKZzudBAO83JSyB0tmhgOYabUGTyWMXgNDmeqoxaKxo5N0k0gNpPbaMOiZQND1IKD5F3eY5LnBEgFLNWKEzvQ71Pebjo/Rf09lU5i5AVhGu6QEpA7pO9W5l02EYApYYRrJJ5hk6eeaNcO8yiqJSVovRxVnQFmALbLFlpRgJR9Jbml3NvP+VFabpHzNTCKh1CkJUW3OCkTU4HjqBjWy1x+HzpscBD2PEhePaovwPvXGMHe8BUdklklPUlXWYfUIOfF+tsl+LOb9ZAOLELEKnSwE3EWj76Xm109T+y1JKi3d8qS0ek27Igaqhc6/0Ez5Pllqohbu/RoUNB07eqr0DpSDZ2D8AUbRtn3SiN3mfuH4vjUXaocWjpdWgfNxgcR9US3gEYtnxt7GFwXKSm4SBmTYmWhQ/Qp8aoJ9OniSLR3Pg72jxKR1nnvWMnCvxauXg5AiGk2mzn89hdUbEU77kSdhHurrQKSPA1X78Cn28PiZGCG5bBetiRIXCvT5B04h728/n+Ys6wNxvgECmLKEIoFflQCBVRl9ZqEHUxLSkI8RMRD/GZQnY04lVbIkH3PMxCMZLUJfxz/I8amxXjwcRj3zmaQ7zXTCM1JktYR6JQSMv0LVmdGKnjCyWhjs6RUYRHeEcBPF/BzNvEi4GiSYS7c8Oak6iJVoyg4+rLycUTXougPCpCbSTC4d1kuxv7VziZKEMJapOUsCaDp+obwA2kXvpS1o4G6z1Xblas1CcbXEK3HfKxqQYfG7QBa7NOjqgCLMcXoF+otWcvd3DHtZPL14795XIznpa0yJy1alp+Rmu4pdTmDsGDFNeyW+KlCt/lAz5HQp6Bbm47ib5Y/XrCW+yX39PYcgr3NCCjzFWQT/KtAJXYUxz6i5WQw315T4ZJIrqFFVR1CgFgWRdVjWId1cUM3HkQrl1dLz9ICn7OTTHhIxipP6yXW7a/Wi+/3G7f0k+FC1ulwol/MpJuJVM6GIAezeWM6UiAVCEBkw5FIioryRXVQ15rz+E+QX1PxT78Twdeal6mD9Rwzyx961epl70x9/xmFcTROgFoxwnhTQV6lRyvT0UxcJUH14tH+Uyd5OhcltXQAYYoNt6SexTo8Y0sfYg87m43RkPJfN97Jj92AdrBhnj2l1kOLQKfhrR+miNKgncIOVXlI8R/PJKwL/I7rds2yEMYpy3lIewRNc31fQgRvzs8sxvkRLhQkS0sXQwVOMBVFDWZssWKBs0Z3idB0MGSm+2KnVEYddT7AITUCk4UYdHVZIWCssToADRmSbxAoAwRzzKBIo4IVyrbARbORgylQE1xFSzh6zhOo7RiYEGCW5CoQPNIrWBE/CDEbaKATbK5xEpth24SzXIeD8o6lpJGBI8hC90jFXpKimQpTKQiBFWOFJNqhEKqoeRJeSXVF6E3gk3ow6h7BtgSdRKSAHHxmSqFJNWXEpc5VSAdlhyirqSl2pWaHCakwEbppHwBbCVD1E6gbYHBfG1h7wBJY/f6tLSGj1Arkk1WpD9KZMtaKwJi0Whyxuo4N9PmTDCIJnLSras+pNoq5ouUMjth+p9d0WDY4F3qhaplVOpoHa2VFV88Ax9QLxHV0I0PZKw37IPFfRJcUcxUvheSu0JsBbkqoQvMsKIlw8oFRqEoDsokz92bCYvpRIeredldYkfdcUmxAU9mcccIbnplgiI2Oqoki2eSHKl8VkmUuTyUkD4FvnKfj88WkAV2XvTw9sjOGEJL0fbQh9egJSGrFKZolX88QLZITnTrMr/QruH71u7DJKpaMik4l21Ropw/XXsD4fzsOzjm/lZR3w60vaByhf1e5IwQe8rmbG6FUCayoSF9cbJl7zMjZ/K+RMYkUVYz4EAikdFKKcEz4/SJAF5SZav24Y9h2EfbhJdjD2W6iVfT8LiZkxbLLsCgDh0E+/Fr1sqjdBkaifg+wOz7pgTBGaf/IZpeuGwPzObqrGyeL65vXimAUFChAIUlL6u7X13N2FTnXoOMhLssOlZsRoo/h8QwgosPxV3Shy4B0bjhUShPU2cBLLgWmkoKKIHFMgZibtL8EVqx+AhMhEEiNRV4ERmxwkeHQHO+B+xUpYCQxAGOYslZ70iKgACdiFJdBh06J8EOofSdswkr9YWpoWLNXkRfR50HAVmRJGZRh6DHEoAWv72YPd1svhbXhBwyxKF+hOIBCzM4Xe5RE4VjVvwbsykhyPM5ijlnyeUuPRltXAIeQ+IKKWr5LNHMRViHdMkUhhuLrtVPpHkc0osUM83AUGQEFURSTSrOGsf3xyIumLbiwP30PQqR6KsO9NMUoDtipo24EjLr+2IcagZAMNbgPPMIP13MX1ahv+srV0e6vJqeJCCk+Q11/FDS6GCwHj86wHR5icUty2zldVLCUg2Ok6okxWXR9Ze6aHegyr3Y4UhJ3imP/k+YBYbyzAnf/5quF9d310/u7zcLEEGmy81OvYhGGF13pgRQjPkv8d/ZPdLV2R6PaB9JmwofHNP5GhjVeWfJCuLr3id8DbueKX8p6iXKHco58IPPMOe2rNrscUfxYaCwXu03ff+zvSZCblkBytF3gHIKH4fap6Ibe802zJqUWmU1xrIr8EZqnsxYEJIMa5wivc5vKJctMITUKhtZux1dj2+Mkh6G6GyhnQBSjFRx7DPbvvJgkaWZ5wOcRqjxAFLN8sHrNlpxNMmNWxqkTI9mth9xZMXPKH2kxP2qH46RbXs46celaJqffFmXsjibtwTuflUi3gJJARtbGv73//i/+3D77vmzLwg1mA0g7GWxweXV5dt371h4QEyuwEIb4BA+8C1Sgg/FKAqkpIN3ARJzvbwouAWpRASVBgQpmC/KBHdoTlSleAWwZhq4wpnC1Wr16vVLXgUNBoRbBDvMSICr/oD2h1G4H7G2GSgWC1oVSVXt0khs5/9CRYaCH2FLlRSnpxwqIEsvD6g64EgXxYpGwxzT7ZL3oSli3NfxIzMA0/xlK3AhiL6PEnGYtwoqE1jTXFahHX11nQapsy45MYjeLLTqoXRVhSZKZUfBJcQkyvQSqNDFpU4YVo6gHS4926Smc9tphmqrzWfVeBV7KBVw04gbQl5F5CrSAWMtE7KHWIqEOJQXvd/eBSA+jv6VVAdPO0VpgkFayGP5p1H/KVtLvX37Ti5NATcCXdPtOxJff3U5YwZAnCnEk6FCY5Qxc3ma7gTUQCEBxRJsKQmGsfIlSIC70yMv1GwapHxbQPenKKarzT3A7777zd/7+//V+/fv4TNbzK6unyDg6urqm6++vrm+Zh8scMC2p5tStOkgKcv4Yp4Bj3yFxNWGKeiKos/JgyzQMq2oO4ENtn3WT37TwH7gbAgtVXoENRoiSukjbdi2yhjLt6kypKFShn/MRKNKDTPtNJtfMCLoR88OllI9/Q9q28WtgvUUD/ekK+Lq+dfSJQNG9X561k5lJgclkIh6e9bbtTge3NtrcQhA4x2AEitburTJKXLDjzPbpEApctzoC+YKVnXSWq7UORdkNwhIZPeyyuSnJE6xW1vuHm5n9U9Lr5k8fwk4GzCKG98HyGoX8EShDXPWs8tXxFz/z//X3/zuu+8uF1f6vCnrqwmg11/SAXjx5cWf+/XvaZH8ent5tWCjTUczOjm40UPF4RJngjCBgfBhJQXfRGYaYRRQ55CqOCzik4jXtQ8jITsIGyI9E3hlxfrDh3d8V8shOIXmrN6C+wkEf+qEiA8g/hGfE4P5CScMsImjONBKYtmmU8iMrZKLkVqpo91pkL+91U4y22shpj4MWLDWdIbYKya0/nCBDUWiXq9W93xaQKIEkz5SpTishupfHSKUCgFq7/rfs+K/Im9ek7BgWJPcxEx579mvNwHyEZpklYDnNIkCf6d2pu1MwDBrUtS8hZuRVFLZRY2qUJ8tgJh5YQcqmMn+2hnKDRLItAzkRLo0PK5Dx0ytvNF3ggG/Bpy5WwXmrmhP9+3UAIiTXwpJxTjq9JLvN9y84MUOj+Mr/BeTyeT9+w+3+hwY+OoTyw0o0XchvvCCe+TCVsjuOHB38IYMEPUNQpA0tpysEllJ5m0TuEmdFOQzPaeUIGyHtLi6ukHcZrXiZWjuu/X22fTi9o/+6I/+q7/zXzJHpl1QtaiNPsb67m79v/vf/G//9//ev/sBR/bn6uJOkGAdtoEScPahi0RXRQkchVESxQmiS7prCoiTnU/4JtJwvnhOlk/UQzkfil9TqicKquEcmInf9DQPUNRxDJvS+pkPhNFQ0Z7pu0ZmV9ptDP9D8bODhOgxIjpxgg8tReJQVmVsdsoKkSNEd9alz4Yn+WEhqY9/gVIZMUyZG6mG4eqmLwHvM/kI08CiW05NaE9mn/weskcBH1+rlnp91TxFRB/PlvADACfybJA3nKeRRa1Tqn9ArUaghm5tDUeQfooouSFyotSyqmZ1jTKCZRqE6JrnsMJbcuyXz392FSGyYaEzQQgvBF9d8Y0k78zIKOlM0RbLHm7vbr0e2qEP/BwdeeRVq3Qc1RA5K7LRE0oyFCNVDuAsVIhVlM3QfnqO6X0Dv74LmZTTdkDWUsG+1h8R3ikWQ1JEMuIJgsbjQZcahitKU0ICpIZ6BuLIwUWsrZa3NyWmI88/dTRWK154oFBaKbSCHDPwMrRkMijL1qgSaSVZwjHXN8WkjGjM1YyrlIA+kAeZFNApZczJxSecpA3k6XICo5I0uFnjEqy0hFX6O9k8BVUnbRM18glVTSM33DDJo0kAmkEAdeB8kFKSVgaH+pJViwkyZ4XOVmuG8Cu6hQqLQ035jK2jmF7E8jdxMyMnwiPI83mHiydPrti6VEzV3pqL4JNw7969Jy/XMVMuMEU/ZsNQl0N6IlCuphmn6CUI1/hxzQIlNOSbH/DI+uq0+Oj/1ZV2QIIzvogPUsa+SLd37378/reTyaWkgyQ3RTc6oh/oLSDSHWa9vcMuSgXnSpUsppkIRbqhe4mbZL+kPIY5vf5w6DbwCZZ6CJ4D6pxR/zDpoQwPxW/UJTdiTjQQfsbZMVVKuwDtq+UYK6tfwlP3tz28ztWTHtNjPkpWZ78q27Bcbxc1LPvf7To3envh3G20vRB+wBpHoy3QsIQ05DZoT8/28W9bLxQLA2Yz7hRwO5arIct+/A7ttFTIzZxLQzUYR70CYQCtQdWX7bNSwm+1aR+f4+B5RD+aoGRC1QLYLjJaVc6VKEKvEiriJYDQIDxhtxZFTFiNPb3arJ+vtc+9An6iY70zEOP1poxfRwXmeCcnNgtiVYziLY2mO47ylSIfEkawpPTupDcc9f6AQnCte5BKGsdkpf+UwV34KhJ3hSxEpWZIsCTRZF3oCE8lCqJg5whNUT6laU96ki4jUptsGdzV/o9IVM+BrgYLjpZsP08oieZ8YcoRpvHp9sz5yjCj/RKMUDFgo5+rS802sG5IUl2oMyTWT1qQSmVmlECqfUYp3wRovwPA93Q5sv5m0DzlHX4oKMbsm2jky7H/KI7vBJf8Q7E4t/F31ehg3waVFW2VRiGt5zpeXC7ml+vZr+kHTliOTwC+0BcVaJHlUt9WY8wbpdT9oh+q10LUCrMZPQGai713tHUm0bDDdVxgBZStWiGQD4STaJUO4lKQ76s4yn94eizvpovvKRehfYDwWsjyMTlVNC0qkeNOwb+sEkrIhbbrFxOMv3ivlrXXeR6AdHL5IBdzdVZlDPkGyDKDzS3HVULyAKnHiyYg8ykAFtetmBbALbkB5b6sjpOa3JpsR8uEm75ybDZolaN/SwufD4E6+0jvBMabQpZelZTX3oIS6dR08ZxsP1Hbvzi94iJmiOKCZy9+FIyJNAZZ9GkoH6gOeWCVTtdBuaXdSz5Bm0oL/m27NaQ1smPw++rVYLU328mHKjQNso9RGZvl9I7JoD1L3gOrLUq0veleG47WZFhEH3/Z03vuJXI9K3aceLpw7G75VBK7AO3Q9qeCZ8F5P8nPGqNuxgepSjhrn0mHFQjah1ALfY5jniuSEw31Ss59OJkkEI7TJDMhcTqHklsjXdaoUfQRs1S5VCxnw6S7okgJGiVcFcYS+WI2rZIgS9Ch4UYCE2YDCB9Y+sOXiBhxZE0DC4PgzXjjegWI4IPoQxESNvc/ohL+R6gEi9QSintSxC6+DqRU5JBMY/nuPxBGK6xR+6mTwAEOEU2oKhEKbjQDkNimWgAn0tcKInBEBiYCVS/4KdIiSfAkgfypjAieC+P9m/v5ZMFWQdSHIJD6rZb+TWVSQooQSMFvtrzXchTysgF4yFJHBUEwJwgUU04hWGRK7w5nBaj+jF3R7PBOTzUEj2GYSUg8zFGaoiWhUUina3bz5IZ+2HZ6zZoXfM9RMHTyDXmmza2BfrW0HPXDu1s1KR+r5h1ZkIDSMbsk7heObI2fsW4fN1Hk7RklyuSUUkdOqHcA4E4LCQSS/FWFcXXDpjKF2EjXMjjcQ/rYq9x5ZiUZSoV/QiNdxKviU9U1XBQJVtbkkoqCEsmB19EJ5bBg9byD03p1r16yPnehm1R35io6q1TqQn0kvcQC+3QXiYG5SIaTKBsKCZ6OKKswKmi+9hZkjF984qOY4KMIfYSmpF5HHw2bjGdV3VlHS/70CKkS/8MiowwR3wFoVwQueozys94uE6Q9/q1+yQNZtOw59ejTreUh0L5+VV+d2v3vQ6Q1caPVok+ce7GB1FAgMDN9I5vhQ4nSnoFXQqr0KP+pxPRZrypvXtvWa9S6SVDkO0cOivKUzHYLzufq37cFjdSnTdiEVJZvwkflOxyhDYo2bbYsP/88MwJKsEOWKIKYhgAjYuj0SPFGh4RNa8INsNesj2eYlfU/yy+596ezH3kAEMEosCLG4hqK8/UwQib4q0UUakiEgjAd22pk2hQC+E8xV4qSFFJDS9QUeopKWDyfJAJWjACnVdgO7cDzChGtGY9nknRWbTSmW+lImWY3JFb8UgFJugWLDRtMrier1e37D6z0UPQ0n12hOByYAHAVL1gIRZHDfbRVleFGWEYANmcXpc0LLSyZvHOtxcK1EAWHqpZbJ0b3WfcfkGQYRuXfBrLO7XcAyrH5HV5KJR7xLd7ItMfsW1Q1QHyjN1TKBcmeOT+YiPmH9veAY25h+BvAwXh7aYFSYjt9xRmrYfYVX5wDslHobndUpBuBPE1Kvw+05eqOBqYTJ0PTB6BZZ8ury2ezi2vH4uoZav8cNT7UTCl9qQjZe++kWsGG/zN2AaIvIc9SVsj68yX5DuS4hBQQt1iGRIYReXqRm8niNd+EnukzvXBgRoJ/6kLIowHBw94q50ydE/HWIYf3jSBCKiqQq0xlNQmA59INn00XuiXle3SD+Uw2PWZ1RqbaNQhHZFfSxVLfn/byKPcCpKbqogt/UiIf7AamIyAFPBBAr2Ap2ff0OxQe/MefD/jFOS5mOI6qqMBIDbGnGiEfJ8uFU5NnZj7uLb4CvSM5sl4dlHVQyScUHjNXX+ehXOWQqaRZ99H2jJik1hbB8qTf5aSVLn2anIl/ac+6S0m4n3RK1I++GYAOM9QJm7miFdKToYnxc8yHGYq6HVyJbIxhi/aVZvIsOEOyVk2Pz6iPm8j6PITYg+o4oEku6jN4qXwgj8HMVAfpmakeLjFOn6iiq+uTIhOiD0IJxSbEtZwVixC1eIPDGUHFbMaI/wX7AGl1EIsQ5iAzSClshTVVgrgDbt4DQAGL2CRWrnRgWghlkqBHlZWgPHiZTAopq0VB+m9lRCJcztJX+GgAHcudkUrIT+RHyENCa8Q9pUC5ug5iiiKJpwX6FPzZ2pRPrN7f339QB2B2fX3lfRQVhTGgSzXV7VGsD0+AGouVEpgLhiwv0btVqkWIkaBKVRKRtQLONU42UgN2UlY1TTKH+GS0SDRQk3Ea0COzWdQQvc1nsWpZVmHxFTrwiX1lV/yKNUAaEteEi8yutWGu5nrL27E0h62vUXzSRMR+lVwL2aAVvvyQDiFZ0vpfaSUuakwXya+EKUUqvwxbiIsw9d8KCUeMOeRvZiKYA3ecEXdJfBzLi0bhODUKCbzDQNXs2GKZhCol0VzhLbWV9R8wubhWxUnwynthgcBkgPojdIsn00u9FyCjIR0qO6RZhO+LmbgZ5Ex1MrCzJGG0SSrSz9dDLICN48iJCnD89YysjlfiQMoz+hOshi1wRlkH1vIh0ctql+khmfOL5bd6gtV6DxBA39dfMbv6CK6fa9nkR1u3ryc0qMlQ7eplMSYRsGZ965gPl+sbFwmJ7VHwsGU2baCRDXj0mA+uS9ueJaRII6Uherxl2nNE42k7MbMyUd9hS7Y51D22Xd4B2dW9zzNNRKtlzJzoYLcXVFi+xO2raR+8pCVd2W27+lZek98QIO39grYJEhEBEQJhLGuLiR5Y2aKQhDRhv8AOP1as/VlpUJ9XgwnGCINXF99ry8V7tsFnbkBBjAxCAKUwhFCKK4u5nwDVg4KiNBpBjkUbbxwi8QwSe2nIdo3CI24iJGJxkWBQOaQn2GNSAhG83CkCDsV3ogbNwbixRbP+lphncqUxeHRRSCcWYGuoFOIIpyRK3MXCpIRKBJcronqWUuhV5JlXC81m9Ae0DB0+6hjRE8AIeiVU/QrxUMVIeZU5BW8cDEor8a8dVU2lZX2kPyA15MMyIamDTVYhl0nfinkuzYmqJF0zck6UCJ1U7bH/IKnG/ptEjbca1KAyITaVx2g6B0u616VlNsS0hLa8mK51N8axvcFd84s2n1y+tDS5hBwRYfocL7eY523kMfQSqzuO0ukrdy0ky+2lfqMa1DMLdBvcxioSqRpURfCVdqa5WH+DCzFLxku6+vKdeg5SzwkNzoPlu8vYUSsgAosXUxdmzh31nA7kbP4K59UtoIVq8rqLiztuiun2K43kz19Lqmi5I3BXdvqHubmJCu/l28lfbJbX2vtnM7eJuBWtqbSA1jWydDNKlRDb6kh2jWzsLca7ENWRSPt+fQ6FV2w//nXPc7X4LUgmOE1lGgU+Iw+14GlHX7ucxLWwSfDZY8MeYWmuvl3a4l+ihPVKy4y3Z8mnN+2nxHE16uVZFlRPoRJG+mCJZbWLdN4VMPjX/S1mAArspEQb0tCukY3nWAChLVujgfnzzH6sOnXKDese2kRHGH68iJ9jg9fvhCPM0yTJ7XJ2zk1Jh+RbjRiArCy8pK9iJIJ8cSZ8UbSs1yUvCPcdPRHbOHwiOCcymrK2mF3/iVnYkORiMSPCYACSZTbEIgTHfgdSoZIjcsUbipF3ch3ZOKahB0DG8lOdpIYDP9Syjnq0VKEI+hEpXXjvTukdZaCLg7GrE9zRDgR00gBosLIOHpFVHKfQSofL9CtsJfVyqV6cJERi0Jh6b7bL+yXvoTLrQZZ5D7FWx0Y/S1zAIIqXkhLESDMQ7flo/VUd4dSOSskMtGzlciIXPXQCiX1HaM251KpRlaAN4ACruohgWYc1c7Krm13egAY0I3Mvak3MzMQLjriTh08IXSuCCIftxNBo7snD3kaMl1nMDRYg5t9d0hUraSZp6mm42twSNLdcw1D7KmlcS4pwBG9pqj+9DcJOO7Q4hHQO5TJTJsyu/OZMeATMdGuYVWIA/ka3z+zJ0+fLO96w3+oDBPJBxHDVGWZs589XvagX01N2bXoEmoJDf1zUW/HSQRJPBHh1r24B/Nc3tt1QDi2lQQCvcMyqPkB9OB8Vr0BcW4Ci7HPyswXOYQE8zzfVMbzCP4c5ND29kBPkR0svOH2MZFQ7n/erAGr5HYBsmDAD9JUlgmc/w0zAI6Ufq7Ok7NvlJ3KF2e4DtSEV7tjrnh5wqU/FsqheBRpxzVSVFUWzR3rrCRvmbBg1cy7HnkdotA/FdW+MlIessgptLk31uvi0qfZC8orAjImgrEmfJRvKQNvpM4FWMsxSaokuf6ghVJm23Krk1Gu5r3PJq88CJU6RnqTVvYAqB9LYv+Ic/ik8qsJoxUMaNlUIy3A/oRIDmQQyChcUWvB27IbNb7T3CCtuFAdrfcHiijdntTaIUtA0+g4+u2ISkHlJTPC3eEvS0gXFc25SJCpAIU1Kw7uMniblUyNRCNjhOprwrPAIrsxO5KVhYLRVTpGggXwVWEHeM/UZNIgPmhcIKfIiA3tGlTWA6jjIswIuIq8KsApIw802hraUkapa+TRHedFovZO6L8jUfqCQcpBdb1l9vpAKQiPgajwTAYhc5fnIufbeO4HDjkDgtN8E0PsDWPFN5rQ/EcKtnxQZPiYMLVM57/cayKGq4JRoN57dkWsBCOS8BxHpqfn0jf0Hi563GtQmmJioWtM4NAdtRg9zjpsRE1eWpyXoEuAGU63j13Y36qKhh5vUjbhlXJzxeFbhix+E6iKQVAorOsyXE1qGYCQJoGMxD3xwAONHNXEyUZhUGm4nlz+K9uLPa1LCcKQyd4ab8ZbuNbWT38iPfCO5VpBZQWmkj44tnj9/tnkitMnk1wIlX5YyiHv95u1k8ooPe11cPEc3eSQa8SW65fK3v/0z3gTAW0N/dVDpDvEaC51l7WH6gU6rrCDPjs6HGEqujrBxpNPZZb6hAhDzhMyucJSziAn9E750Pv8b+pY4e56rrSilwep3MduySd9vVp9x8m+9Pb2F1eLfwkiAuDfJ6I5sIeXSVokAvW8JOgbY4xWdHMcBS98rKQ6WGBUuz67w4N3q+dBkqtJgpCGurMhDqsOcO2Uth2xwqHK78p9/Kuyxtx6BFmbI9thLVSJkS+dEWRrpMHB5zhLbyG1Ig3Mj28APKQ1gmd2LUCKfng5xB9V3QOgwn4ZlGtnMNphwDt3inEs/emKntkMc3aRSUQHMrohgQHniJ6IEjxcSZIHKkgb2/NFQpog2eslVK+Cn0//FX/2rT58+I4RarcEhgCCS5jGt/UAZMyXSYjPN9+/eACOKZh99BG54GxgMxR0KnGFI9LIgYJvNiZkUjyjI0pWC+/s79jRHnMIlxVOKXvTH3qPSgkAHhckDZNEOdNr5BP6OzjUOLz56qEs5VVScSIEJGTQoTAQFTnmSiGrTT0VXksiKavSSdG0nr8CfUFKSgGttRlRHaaOxTIP4EkE2I4jSqjpCQ0MaJRVG97Xk0cRwFZrAwfxhFFjN3DgPEEZ14jwonMJhTjvqwAv5anGVyCXU7nqjg8U2rD3D9+jp0TgMm3thi4JgvEYdTzVfVpt2UcxsqHBQJCGkiuU6CMtSgOCVnNX+SXF47vDlUXavBJOOeJf341cXEeINXyTQ7BF9aYmUk0gr/4mX7ohQR6/dSF2cTOxg7f6jTrpfNvS5/7V/69/89ptv+SY34/3w4c7E0V69fPX/+4f/3fsP76JvgYvKcdWDxw/ZCXQZc1kylKqNW3N3oIFzYt1xSGYbHDZowz9DPh0LdLfcp6NfvyYneleHvxayOr28KK8lf742rFVjOKNKRgcgqpstFO2QW8MP4DAuKH39lRUjFiNGuJsqDfbt2n2gNqTJsD8ftH36J7p+fbIF+iWopLcfOUxWlSIlNIz1cNEyFOaERDgbFNJq9Ch1kJTnaPM4l299RC0YZ93JaklJVCU7pxtzCK3ysYCwQCe2rNHSpxMT4IDPRBVkw65DcPuDxPl/G6vPCGDu8bQ2rz5Iv0/WfQH60LSHkeJv19UnrTAgztB5Mrmazhg91R7iilAInrTGfsaKA2C8X6lgRDHFimiB8ASMxeLq+uqGKISAn/HYkKw4g5BDgcb89euX9/dL5BHGOJS2pRR4E/SEXCs74Qtj2jQzghFHPOpNSFUCKb06KW3hmWIkAj8N30JLBKP4yV0Cst7TEy1ZJq1YHD0IANmGRcP8WsOt0B8eCuQUzEsz4njW85DJA/Z8cepr7+b4G3gzBxCBJpvKWGVVwX0V6be++0KdmsVrTVaYn+uqSmEoCG1s1wTsdCiOq9KpMVI2wD2j4B1j/0HWnhOY3ltLj9nvJGEl76lfjcGXJd3ppE/PGH9j7B8WgR/nyDIvkbP6MlrtoMReWAAb7wCES0W5o1UaxDErIPkQL67hHu4KEtPOmIiSj9LsEooDE/jaZ9XSPuTw6rCBR8MFeychMA0eQtMFtrhU/+3A5pLK7H4AHPon5vI8bgxujtlsoWbWfxSj14smLAoiS2HSJUX8VjY8Uz0alEeF9VM4TeY/Ev5vN3zGCxrAeDUcZh/eLN5dcq++xg9xMe7Q6WL6+s0bsCC2V6MJd+/kYvET3wGYTq/0f3KrDpJ80iqqiyGNbBvVXXr5qnR1tAAe+wfaRj7bs66S3biO4d+HM/D8z1LG4GTkoxP5V7XkkDyiBD1kus9K42WO4jD0m9UhKtv/aGsME3a4ckuL3rgl6jI63mgx3gPIdd+Dd/Zimax8B6A0IemwWWG5SOaSpj5R0FvcRP/Z5QtLPKDuDSmYM46c6MxWWKOuv6QmwlydlmmYcYxd2qwyVUNEhpP42MZsVHRY00pxsAhM+U9AorXUrNNRcCELMMBOnbZTHgzaJJHxVqAKblxXDZ8TZzDu6IrrmwAE/RTxNVzNGDgyAnkxu1TIoo4DAQ1nG1exFQEW+ERCYmtRrFwQ0EjIQyveW3SRhv+to1YTxWgogsRShFy1rIHLQnGTumoK+FRHhflgkCWYV5DFyZprSbhiNKGhLlEpqybEyAxNIxS2mucNB7BQlU6IvoQsgaB5cFYdJA1Em0iM81SCwlG6LULTOiLx9R+XWqqWg5Hwznacgd9IffokyTQ+cqIC5Gt/SUZxQm0ja/LC+YRPbNl3HD0DxtoR8eIT6hvQHvqjV+ZQmFK1vawb3T63i1wCNHuKvYXmS9Vt6gRcDIQsHm5u+4E0o8SQxEi4cjPW17ijQh8VshUfLZvKzXS/oBgkkim+4kdKYLMQOs6jGQAXqzRQRcqtSKVwPCJ+3lDXJlVipOk4bjCi+RXvAZtYVNrdVMwQs9po8RU7JqEDBxC6FRJMZ4g32ulgS+ukjWQWh8UX+Zy06jn3OXGkBdQOn4+Ht8Dvhrse7k2yy7wap9y93Z+eO6ld9OjTkY3YNy6rfgxIGS/Rd10erC81pm96dH8rPw7zejXqVqaTlXg0d1W6BuuxQIgoV/ZjzuCmREWVgYln9FBrApSpWaOiDaxclxZRAuTe8K49e6T0cQh4wz4A25BhDn2lWUMQwiD53EeS4TXLVFBs0gmvyruvCG3XKJqs19PqbdHNdwS01NbpSSUx5PewcNsTnWrZjH79Ga0nwGJ5AoG6nEzj8SzboYgIHgz8WRmKwNxMluvlV+v7Kz8XqAhf/iIuYVUQyRdEHauLl4qtN8v54slk+pL1x1tGdidsVU6AAhoj7lo5Q/SCUMUecFagwoFcdt2J3oEDfzFVcKaYhW4ERZpKmOpdUNGgFwiGwW71rRjNfoCIcEZpoSieUl4RV0AsFeD2VmCPTEsOjKklSNOXy+13S31KCQKN5vp9AzcZ6OyP5MBKEuY/ALi44AusrLNm83kFXnQNhM/cgqJMH7Z35aNc4ZtAUX6RvwOQ8qdd+sb4e+HPJa98iyDpvU8NKtF3NDgMYJYcYvajNg+gxpIfRrxLg6mlMB9wLQOLThZRrgJsXr7WqyYg0BJciXPVs1SMqwP/fH6hjzPc4a/qpNF0tIX4wZRG+0JZ764TLYTryT1X3zDXczH73qoYXTrxp+6lku5tqoCUPMQdP51QifdY4iX66YbvAePBs7f4MrrZQ91vlXTlICa+pxe90W4/QJ7JP9VxYOie0B3e/HF6zdvC3r8ISvk1XJmo46c8ZiRULebI6MGLjPJL3Tnxog4K0ZWFu7pOyGKmYuX+kKoqeP1oAerFZa568pSwnvRRT78x/Mfg9Oi0D1zoXD51IcPwmCnOA1wSguZVdUS2TAOJmfzV10Jo1yXk9kVfouk6GtqC0ubcQVfUt13a5tCW0qaK2sWMekfpMGhQn2HSdmnnPEwbrQkZE//oXubuapIelx9l1YK1nyR+JBZAkjzBcLv0JkA4qxHWwLUnmlyvOju5y9pD06Mh0DJCZyL8urPoFwEcqF8UjTHSgCWideK5AFokAlhSnUVKyXAgPVDlAapclOuSIWdPZPuEWUrjjJc+HrOhfxYXiaxMA+3BsojNupfpLoFRzpmwgojDJ4dHGu1faxW+gAQHrC4gQNCqZX1ySdEHEQQj5nz61mSsvvb2JgRIDl8MJAKDDzEKYRe9iBWD5IppeL5o4FZBOwcREmBFM4QcgL2KwuoQ6Ek/DelzRZ6mJZQAF5DCaa0IUlRlfJe5BKY89oi8YCspVEBEnBXmqFSHamzBftYhm52L2MsfFaQ3rykIR+s31vd3dx9u31suGhACTpd3m8tL+jMSFMwVianHQk2BSgT48Y4xdQIsTAElujwcNRqs4rLkbOmH4dqvnprLx/kFizVxPPaS5+GS7Pup0XBal26gfYIembA0uI49SXugnWaiVYEDsm5ColGSf8g5wuvkIbi8frPVQYS5XBpmFECim8F+ITa0MGzQxYzlZMqGFJ3hPp3TyZWu+LHeUhAtC/X5ILG7hpQhwyTCDtXkV2ihSSecXivZQKBfrV4LMnxT6Y6R/2uB3XzBPIASAsVdRjE7I+HU3GiqBmprgRQ3Na8NiEr0/FONwOEzd5BSAKIY7w7VMnK71K7UqapA0ouiGpsC/mklQ+mG6qeoGNXeW/ksF1mVAXdiSzvuoG6KNnKJ8Dk9xgJh3r1t1GYVrdaGD0GOEDPE7txltkXSUdWbM45lGaXe4XTRm+EnMOw3UpOgHUb2D/swynGl7b7pcXz6qGQxhvyY66iOSB9kIZH2WKDkk9PRMsp6/IBEqFGp0HutWaNHYi/xmQpqOphnab3xQugNU/FO2myo8dzaWgVtH3yYc1urPQ1UtgVBCUcJGRam0nCB2ljOKM1DLcU2RB/mM1OwSpiwvbh68kSLeFZfash/8pJQgQ6AomIFvGQUKWynfE+U1cnfT+e3UwIMQhgxI/ZW9LyZvFJ29Uxr+jfvGM5nYHKyWDGNoDBGy+JhobXpis7IKBpj5P65prambxzPEJSBS+BEaM5sAGy1LFr7fhIhgc2A/uobhtc30z8zvnTSECmcL7+HswIp3x6SFfGVzlUo5ZqLcHJxv3q/ev/B2/pDwYiqNOJgPkPYYoKa+nwSoRX9Ib3tMJ07kDI7kJmKQFvv+6mgUQEpselsu765WD2ZbJ6Kz+ydtIKZGi2OYB5AQ1jHL4QzHMewKcf+Q4Ws6TC7XJoTnTXI3DpL28DiLQj5CHbDuGp99qHS9poTem7a0Z9molkYwGKJC11CfflLy+LVJLqnQITKvmEZZGc/bGe4zq+FM32nOFneRjPrdDF7LRIF43Fw1f/J4iUzAFEJdwaskv1MUoRjHbUUJ9pYa8hYrkRGs2zsxrl5Nlk9mT59y40mEYT46JU6xFZUPiwItwxOSzF9biS63w0BvuXej6tMf2TuN3+ttJx7tVnxQg7dUfGUcO4Z5qOkGLXCSy+vpovba1Slb86o/2az5KUA7lnesxfzRAUBpDKaaqT7rf8AUZX2xYKcFbCgQm1y7SdbGyLCY2ZfTXfYySpXJOOfvYXOjSdtMMzVbs8GV8J0zcjdCUuBf3DLOMGh/StTci7ToUPo2dC2RBtKF/UdQqvKRkk5kGfF29dh2qId+0bNcwPBrlo7ACxsLFiRTvYvSWrKDGQ0jpCOPk2q8v3XtlWHeXrWsYPtbvc/Cl0rfpi4mn+eAeggNCjMkA3Vh/a7AccM2CPO7RofaqQwLXxKwgwsBQUwo+VEW4dhSPAcxukrzfogPfTpw3wI+NFVHqPMWaoTGgarB9V20Pz7JPMDn1D0w02ScVKGLaeX/+yf/emrVz/N17+6Z+PAxU93b98vruZv797fre603H2zZO0NMQRLjafrxeqGhyijiI6bGZKfa12BuhSEKnMiDA2+Xl5ePnv+HCn3d0ttJUQYvSJ+1xIHx/SciVKmrBXSIiL9MbirzUYdfGiDl6WHM5X3l32hJ8pZ3t8jicFOugkKdrSm35JdLY/aIjyikmgMzg7tgDnGl/0c42spNR0gY4dViGm8Eoh6VL0AISsao0hcuKCN+gWENoyzYhOirljUpEgKlPnsajbVO69JidACPtUhuLWtAM7uynfgQ1PB9RycDpXcwm9UsF4+WLhDlbltec5YVnNT+umiwTTyTQeAmjK4rmA1+pQiJaWhdCXdWv5Nhg80APlPgoPOm5JqfKJoGJHCqyQga6c2J+h3786j68IzgZEI2M0taalCbhR6ITgHargMB0eoepcqNLnO5C1b8bd62tSHm5DeBr60uLxEE+Y6JIsAnltK22xBMLu8unzyZMEhz5V0OqaSKS/mPtFr0L6/SPsftHd397/57W9fv3qHCDqxs/kl3wygUk+un3z5xZfL5X26fWCiQ3Q+4B7+G9nG2ZXbITdKP9VsqprVIy37PeKRJYbcnA2t4lyq04aUpZ/TB1kgHLafZMgXckv1k3/0kiH9a8oZMVxLj00tAeJo+FpwiyfCaM47MUHS4LkrHpeKJ/hwz6/FabiHVEM/in/bFXKPn0qXpb2atOQGYU23KhMmHECoELuvNR1acrtpKmiuV18zHqFVTZ9K0Mjr+PGPzDCao09/0BQQ0GqFjwVJ5jAygSniCFn7mZRtUUiv2Bx6zfK7CXfFThUGYbwwfgUZsPy//2d//U/++E/ms0utWWZIFbQ1q+o308vJ1SX7jivkZu3BfH7NWv+rqy9evPj26dMvJtN7B+08K6bakERvQJIkIH5+83tPeZeW7sT97UorFzQ4qeBIwYkWWiCZiHnKXqF8YXcy/VLxhmMaakHH4MmT52AQsijeU7QDsWjf3f6Dy+XtdvuUeI2Qxit/EDlZLj8gAhKHa2IOH84C5kPlEm+AuhBKOOjTVS8MmEOiUzgIulg5LkIBi0ATDdl6M6Lt9dVzIjZrp64Aml/cPBWDan8eSzR7CeOo5EcuzllH9vvnmL0tC4fS8f7A9G1mMIRMWW2FfYEbe/Y3ZgMq1Qu8rmQbLSCsuedo8DQDtAWleXToZkTzIU7VV6HVFHTA5t7Nnw3z5Rz0CdkIn4Lg6hkANQTOQwOqyVSGzxE1r9lPSW6vngBHdCHdajDS7AFAwnHo+EfnTr07Jq8g14soOACp8FL1XymFtYhEsNncPH/y6z/3+5eX11od5hVAdAWFNZl88+XXk9mVZ4200CeF3dxm8lD3YvVuvUf/WbQjlrqnmJvSen7+cC71FG4Yv//p1XukUTOqhHJ0Ae6X28Xi6XyhL/HJslSLvilVnEz//t/7+3/vv/67fEEMMZzUQ5ncffiw/tf/2l/8D/6P/6eNFsLBQNVWo6UrOSe5dh/CS0e0dZUrrhE/FIDhZHu8cxh/fGnf7w5P/g4vHOBbPrfraGEEznt/p7BcCG2Lbv8e1YWMzWUdJKJf57HsRuD1WXgE6T6UMfqf4TfUjs/zBcevc6OgnFHZp+6ufLw/91qPuqNRcR+N57nTAx6+W7n1ddj/SHI1JDoAUVYjqjImHnGjBE9TWUZF/4u6FpVs1ivs1IT25zN+WCtng6LM5nRg9rN81JKs1aNKPURYOHXRZA9uv5B4iI4n4maBuWrRLBku/rmsSAFWBEH4YfsQH7Ds/fKS75VeMQhJ/EDQsV2yBeHm8sn6+bMXCzb71MIGuDEy+SuWHBAu6a0ARSYaCSeMUHSkaEgD4ZoDIPCZs5HoFlIv6uHDXYqZraEDGKgJr+asOyI4UYZHEn/qJRCK8dxi4kDRUxp6h6sGRheKnWbs+E6eQXhiJBbdMBshvuKBimKkivn5qQuHizViL8aqfSAYLisoKyWoUCohY0ydRV0dKKQ1JIraFPSp8pDAV4cyrJYygc9WQyUSGmoo97GOpOU48WWtByjaaG1InTwbpQ7uy8GuMLHsr0X7bgfsTpOqwcPmajEOtwkXCsPq4VCarhEvwmT9rIqpfDAxVySuhpR24uiJHzWnEcFDljuBaksR8admlxtEg89nbI57PVeHWcXcIHisW342v76Zz68mLFiyD0qE1FZdpLnUtOCLi/vlHSP3KKpeMl8QQNmV5r5UFe43XjrhHjF1vBPDqji6DNc3i9tbfs3REdfUYL+UhIZbjI7FnG+BbfkqGPN4dJa5Xl99OZkyWfdOd0RlPbQ67PgEPHqswpjjQY8BU5RFcq7qQKUyW4HPdn1o/mdT9FEYla1QCQynyI3wO2Aw1zVVW4+dPAOQzOOiSHt4LK/hS+VhuTDUzly1wuTUdViy+Jj+XKDW+2FVg+251npIw7IO55+rm0fH0Sb3tkMzm08GqGlSal3fB6CkKrH60lmHPoQSXurQ7tcOjzd01itqF+dS0Mh06NPb3x3JpUDrdLGiPCUrNK61o2ETyo7r65ejLKNqV/resJfW9B3I5KrlxA55B9qlfI8q2lHUsf4VQaxe99VSFoVGRCVaUbD4frVi5c81I5aOrFkHT/DCwvw/W1zpa6VaAEQcpZUYhB2MeRLcKKDxV4Mp1Ppjcg7G6CDwBVZCqluxAsTCCg1wMKp6o6mYyXsYhn7SCi1Y10AEI1SFZU4CVDeDwEW7DTmQ8mgt5cRtjqHEA23TqEkEc/6ZVSlqChO+kiSuCrEipavHg2MvBWVB5m4FA27Z6ZMgRfnUTowI4CBUeCgiEvP3Yi0hIAsisA4SgpPg4r/I+Ryn9tj/8JyA5xmyAPHoHMvPEvr2Auoap89EBydUvWrsn28AY41iZX8vtyZO2KriA0c1GCdYy9q2Mcy0Mggku4mKEWY8vFJRtNrAMDsDJWbLrIKidt48gUHYz++oEK8jwzjpogbXhI+aTl4LgRSwCuoFwh4EKUa57wh83u2Ob7NJVnRQeDmEpllupx+QNt08UVeUJWwS7T9z5ebScjz1KNibR1+d43Ua82AGTW/9QsANoJ188H+mochJE/AJ8i/pcE83z9FxMn1F0uvv4S+v5o0aFOCe0t24vd6s3vEehV79kc5SNmxA4uADHp1ko56EB0srCEY8OUMxfnc6NYynfXDk907GGD6K53a7diUEcaVZSumRLkuzzPL3aPjXOZPsTxQ670c+FqOMNI7l0UPXpX+2Z7vJhjWpm72kVklsg9fWI8dCJUEbrQEp/aFR1Mj26tyq+3ieSYQr7KdZJTP7HwA9s8oZgLJ+OV0SVEx23FMqt0gD4xeVzSYZrtUAWmmmMj3MsFEK4YCIBnJkgyQkHi235IwCZ+FT8nzQdMNiPy/leyzTqFMP1g6cAhoBKlKFUYpqNJavWF6Rj8IBhUzEtcRP+g86QMZNebmX4ILwhvCFqJiPAENC7BNhv0IJ2DgC05UI52LOqwJVbKHQyZEGgU+E2qD7GacATn8668JZenE4ggMkZUIrqeu3nVScHm3o59cFpL7qY4VdDaqiI63WloSy6VWpkMyVjMsE0gH7SFDF/z97f/cjybb++UGVmVXV3fv95ZzfCM+MPMbGLxJCaCwQNvbgkQEJX41tCWQugb8LLI18AVxzhwSSL5CQLFtYHmM0I2zZzPzO75z9vnd3V1dlFZ/P91kRuTIjIyuzqrp37312dFfEWs963tazVkR+14oVESUUVSZFXB7AZBxRbklVwunXUS66w1OakOW/5aVQajFv8sX5Huwf5tJY9zHx8KqUB2O0qmsaMgpsfRMbL03ThpIz8W+J/Sy3kEpJOjMdiVmtNIKtZlvApbtRa1fnn1psV5WEmQQcNHyNAZItWjqdQmoW9EdOSTZ7g2MQzheGKHBx8nAG0e1xHv7Y1An/EPXsQgYpzyu+vI37puKP5w1D5izSg1/w32ww2mYQ7S0LOiDPANdtBzxBpZ/z41Mb6Li5WS8vzvlEGoFwUZCDHTarmA0rqXHlfun71gLvQTVaeAdPyL4/vg1O/WKOfeg2XfeduP+OzR1XpxN7005fnNwBiNHSyUVqWmOuHL+Tx1HLprS0kr9vy+99YzpiBD9Vd8IYqLc1VTShHK95HBFOdAxX0knBGJpjmqs8WX2tln5WoLRWrI/0drQ7JkbXpprHorlEmZ4rPZI+O949Un6Ypy/2h2mba4WHaRvvkuHSyRqO6aUFFLY4bYqaqw4ano3dbpONeRPgJddSrP7Ig6v8+EPIBqL17SU1j56O46IWF94sL/PCHxYi8H4gXnUP4mDtNWr4fBhZXOHLR5e8tIcHA1i+A/Bw1fXd86xZeKMsInQ8l0jzmlDt3S1enS1Z04+SPJfpa8lBUQCW1666Zq0/UMmlzriDL2KsDAYEaX6mQNACSALxoCGwqkAdGdgRbT2fsqSC9YLtRFWRaaxk6p+hVasCiqGQlBnxZJQCBGHx/oDLts1Zrg/ZkR23GJY+bINHQ/6e4/SewERgqFsKnmouv6rQOz6xexRh8g1gpNDaRWhOzcjSJ4je0Eo2ZcaA9lrTKlK1To9NIAC3hOb6hO8AsMRGNt/OVBI2ZLasn3ExTBRJJMm04O/Obq4W51/ZQzlZhOdKshdv0yeYqbeLYIb+kLGHD/6irfoQr/V5rdTymodoFncfQrUH6LN+asXUC3nO6PMSHTuvXmHFc4T7AIsLv/zFw8R8WewMbby8/wNt6YL3G3IpYHHQ+eLcN0p5+nKeMfxm7RAn0+3qZv0TGlPEnT76sFsMV9oBNlXQNnI5hOWYXUbD06vQyVfCY2z1PFvXw77ANFVo9ala7Zabr1n/4txXfog2rV1PsWNkG32ou8Rc+jaUgWfv8Zhf5x4DkEbzAWSy10p/73o/w0OpvW8P1bFHzp452U6yNR9/Su7f+t7S2+3TpaXvD/frPY5jRudRnjcLXQVyzs7dARgdqpBX2Nj3tvq0/MU0Su4hdGW/zuQYrb56RSxKn+553lJ6bJIxcbyhsXnHSpF4gJ7jLR7DOXp1DPMBnp+9Igd82y3a7TTHxqDj65LRLmIS+YA9RNage/6LeYXUbA4MAp9dhcAzl0JwVtwDdvjd5dNClyy+XwNE7BEMRFTPn2jCWwds6lUB2nlm1p4j8klBULuF2AmfuKqBkvrpRqc6GFGIbko7FEwjw1INf0eRVd5C/nvjoZCLYk0bdZQtG4JWsctiG+vS3dzrctBiw2YUifkUU5Xc8BMYjxDIOEtLYDjGOgKjNtiSdqfwmPktUUHaF4edQFXjj6Frcq2tLbR/gXDTExLnUmCj0hY0lceCvLS/L6FyQ0qqzWIuezNpX4lVmr0LwFAvtUnk1EnHgehCNHsDf2Gn79ET7Q0hYoikfZPHX9QRLeJ2PrKh34iHCoUl/VBglo+7beH1NMurhFAEO0NeEL3/Sow97nBL4Zxz1CHyuUU530ysGIS7agj7DLi9OcBJytMEeusTBDpd/6y+htON49Evemfwhi21GjKT41hKaHqpCePJhNLW6+zTqCNbrXiy6qMFnrxSR1t+esa9sdpLPGD7VP6pqgrp4/VMNb8LStcFvSjxHmVn9LlujDP6Vb/Rl1FgSMyMQk5/j+/BEfxofycxZ32H7QHZJ9S8E8JTnTnGk2N4eruP7K/V+EMX2Pr2bf9ERG/x1PQxqx7LgXvqfsqdJRTONtYpek6t7Gn8u2dKNaYT7nu3top9p9Rv5crevghYiKWhE9atBwAgAkwpQZcV34C2ndeE2Wl49svl87u717z3MwuRmVP0I7i8WYXVPkxALe54/SWPBDjBz62A9fq1r/P3tYPge4BGoBMQh6X8giqACmiJLcseAuKxBQwBGuEoM6YpggRRHORYZf3FYv3sdvktVUE+zkYG5Q1MpeGIEfUVebm2G+vBPAagrZ2AEMRP3ngKhariYiI7mn8DHDICRVEZHlt6+5nhE91x14Lqk8ufqmDLl4bvnul8U1O9DbWgML+owCPWyfxCdgveuE9Uv3C/+sH9Q7cWyz3iNkU2o18RH/YhZEdTGtUbVtLzrpvVgo9Mn31dAmmPjABtBYAwbWpL2yLcUz1nqEkHTkPbijFBW2lWp4LUySqQA93w27M1Nw1s9TA13+2znBBK2gOk3ny6uP3UBUXgcB6bUX/WwdHKMvJyUhR4yvizu3hzx72RfDTPExkZ1/aUPr1aX8ODUc4vMo4B1l4hudPGKIEThPsAjlV1dLG6Xb/hIxU8xI8JcP6KN+uuEKCauvP1t1/zjWQHxX5O2wVFEK0gY4nExpqkwqmhOz1QuN/03nNndyOku6RD+elcaXGfSj9kY7ts6t5YN5utY67syN8XdVwPSnbX8FI7WnmQOoX638E+vaNwp459ad2R6CnVCv29kbl26aWm6QP+yNz9tj5Mf2+x7nvMNlZnCynYHh/50tDXsU/3vr2TdGvh7d/3wfJOhfve4OWD3y22Ct50Pyjh+Piodcp+wcmdeM7VpMJ1JPOckiekn+pJ9YWpA0d2g1PNTQ29A0rVca6m78CBh5p4kMu0XDVe65r89kcPVwGOvEAQNACHpRw9iG3Z5alEiOCUxRsGAqvFi9s3i2//+FcvXnycFTG8kud7XmHOg57LjD1U412FxfWbu6vXVwwQGAXwkLAv7XGFDwBMvdn4/un1zRs+FMBLG8EWIiCMBkMx7+7YgwzEuAODa5n1Dq5AEYAM2MW9+CSWqU0II1ZBuDBgKsdO6CSRKiKZTZ1VXOIok4FMHRIJMWXEdIqq4hdjDu6NBBvpuYMbp5mVRMRN190qN2YH8li4TSjykftHiE4soGv0m0TzelONicBAGDkHwiOO6Gp+JJWwN3U2fbxyaUxS9IPRdgg0Q8P9SqsoTUHjXF+DgBmOkm+dSq3mSoOB9K/pq25SN458NVY01QEW8bfqtUmj2xkY2PFgrWv8KaKXs9SNh3gXqzfr6z/85V/anxkkL675SAaL5RwG+BwwoxT6LbL0YTuS/Tkd2U4eRdWtHQDzTICjSQ07Mk+UqNd6fc1tsY8++gDnS6M907dwnTNa+O7772/u3kSMiBmPChkimrZaOCk9ig0AWztU5oj9qfxHqHw0i3GiWvsqM1f0zqqRwD+6hqcrGCv4czlwustKzLXjw7Q9iVS59CSqHq+kb83q2xudfb7n8+znS8B8QbM6xaRrtEvtRtMmNZ2vzRioNzWo3Qg9RWp7PDfV+IBW6cegfXqqHMoYpCqdxqGX2mHuiw6kD/swreBh/jLUe9L73KfnXOr7TKVp61HhzrrD6gFjaa+zt9Wnm4fdHEkvNU3fU9+j9Uw1b1GeSs+W0odk7qnvRKUTihOi5zp3+YZNGOFPowBG/MppJZJmH2hMqY/5sgWti5B49BbgAqq4u70C6P/lf/3f8DIe3lgOvuEBx6AxlhfX6elpAohhsQHTkIwYxEIF3ERLanXn5UU3hDsFpKDEIUn6x3DjDchrseD9iYAs3bhZf83HBxDyOQIXTaiYRQ1KqFf3leWfmIp8rmLqqxKyqq4tQq2oai5bnCmmphUbQXz4qavO7KL5T9R6df7XcIoAlpxTznypmIHK2m+vaqUZa4dm/f2c+7dmLTImyuVNwq+bzc7997KDjrnjaGSGYUsXbbhhC4ClgRxD6iDfzbpa3L48AwBnsxXSsWiedKLw2Quo2s1PL39YLvIt6qVvycyHhFEGJwzt/hF9rCi1og1RErD40h472xCWpNpQNv31bvH1q+sfvv76OatxELCD8DSub9DyjT4XfIHL6GbNj7Xgn8vxeZtugp7q6CVv6/zE4/J7hzH2Vs7DC2wP/lVFq33g48maz0D5lPvcDqMChw86x+IfqHyOmyVAmNA6ifgFq7XEtFXKwr8EU9UlvDk2c3FjTO9JIMeG3Xu2/irUszb65Pd9jr+XPZAut/YyVFHtd66xVGMU7NN79RxFnNTrsNT093HKfwxPSe1tFYjj3XsqW9Wsuf/e1iPj36vapLvf1sfrv+fdfZ2tcqBadm9MNh52qbk432O30/D45E7/3KtwuLc/OQn7qqaZW9/2ML0DMOrmCkaav5JvQmPxXGIU6GTneN8OffR3rHj5nrrPmjxcOiu2XdBVfrvgSXPl6pEOj+0G/5HbKLKX/7CesbRC8W4CstfPP0/ioYCPbdPOaYEOJzgDBmYWfVqQkAEQMk1IgbgoYMLveLlg2KlzYQ1fOrp49uzcB3q9OPCFpvrUKWc8/DC4sEdukQcYQ7X5gybE58rC6MDrg2kLq8dpAdhusUqUBXvxeAJjjHCBW1yt4LIIkVG8RwRt3DoI+1B9cvBEfx68i2tYk0u1FFcyYpmGlT6II5rNADUhKchkztanAqwoH2T94bsfua1BBJ32F/gxA3v7/MVzPm8gT6S0F39L6e6+2dol/wx549JtY3YMS1f4mGTVeFR/nyrYi9cmtY0Ip/2CRTJ+7op33vvae16iafdkIY0/+X6c2pjbaDRbOrL3asxo3nYtrels4Fva0C4nvW10Knu9N5sGWjo2rQ8HSQ9YscMrAt7nMd+6fZWPlmXhvT3F/3YGrPuaH3uVafcUmdR0M5L7AHZ8+rrdqYw4wmxbpSyA5Lj8fMUjxnwtwNtuLMhrnlGGp3wiA5RPAfGJGyTiDDfTODP1QG/GrUuOtHsScQS5BOEe3p+nuEJV/k0r2FMq3dekTz+59+XYk6v9VSrsm2laQUormEe211NFvuxO/fm5KFX92ViluEqd2nDpKltVYhSq2GQvrVSGcdzNP6U+ahl5nzQxGc+V9p0aQDzSD9j6MWi/+q0092Ovqc6dOEwZHlD58mdu3DnWt+pI4/T+7zW341Xvc5/eK7tD3FE1lu4dDe90nN5Wny4l42zEqHMucW995wTfBp2A5ETZe5Y8jcFT67sT9o0TY8HYinFdVARc4pQhCxpgL3Tn2V+nPgUrAIUseIEN2Hv7ycqX87ziI0WZZoXfb5ie3XwOVFqsXsojpmHncouzs2cov727ct5x7QWnFvVkplX8Ex6Y808nBD2gIDTc3j6LBwFuaOIOA545bcnaBr/P6satARykNDZNWT/veAjd7j7HkYxHWiBUM4ApjhiTQWIxqKhSHHTPQgVQ31y0ClphrcfVm59g4GVAPgkcASQuLy+Xy4+s+uJHGZs+jYzKy8Tj90334xUd1jBGZSdRdTos+8DSiibCo43BNu3Kdvft9e314s366oq3SDEKq55jj7Cl7kDMIH6Hf5JsU1bhO5CNuksPYt80qyJB/3FVBlR4Z2xxtv6cZwzuVl+ro5iRMuh2htrSGdDnijUGy9wW4msMwvfz7x1aBmezLp/37iPjaFpbatGI9xfsZFQzTt4uLr4vtbqNeE5CTgdHKPAzwIh90hlqnC0vfvAxaL4xALTnUQMCEfc0hEMoJUUcKAvBUgcEjFVSQW0nYs2qNduz7V9hHMbwW4Mn2GZ+359A83a98Hn0mMR4jR2JZbFne5QPJ9Zr+vs4tT7HU8ihntXZuT+/o2Qs3dviO8z3Z0+8y3G/wuM4xlocx77hqra+t+5zcX6w3Y0HlToibmP/3JUd8tSiztAVK3r6rXrwWMlkqbgErzdzdwCG88BLVqkbKL3yfemmfF/R26WNdZyaGYsqMVaFbLnLfvS7eKqoV1X0nvIzpke3p37uePW0bo9R2rFyIHuqSM9Pmu3eOh6wvlvUa98tuz+/N5hF7IvK7fvVvUuO3r/RbqCC0+fOERbCAYfUPDcQRcCwYNUyjwiDPKgVU4xMbfLoIl8EAJIUbhB5MA2bH1SnxpECmqTZ3INOosdRhU6gxviIbsIDrdwor8Tb5LO4QqCdVUXyAn58kejADpqRqC70k2QcwD+VsIsFqFZAQpFEWinRZETDH+4IyoxSecLauAFWgfcVBEosZxPvrRwFtZzS5ED/z4pH9ZaWmXAprRm3nlyUX9a+ajZE40l9r9CMARoiXC1L5Hxo5Ob165c2TeJIy9pKybTgW+LgkJ0N45ezWgu2FqBfqLj+Nj91rYnsNfawMNiz5FO/pOS0Xc0ZzgbW7bqMNvgSBphdBpcAsYyHsYfSdkFxvSC8VArzh7OP7o50+oxm7NkMYpNSVEVWUx3lMNY8v6CwkRDm65euyaolhRyzGgtuVnjaGgmRTUIVdsVh2+2uyP4qtmq8sSo72ZG+kziSbUfqpCwmbKD3YHtP3HhwJB7m/+Pjj9130E8Oh2XWgZ2CZFug9Ju3AP1ezeP6ITMwUcb0AMcauTYJKSdsvdQRo5wTND8Rax+c3tlSX5Qa5/WcpxonwoiXnv5+wmE9c+PO3jc8rLYa3Tte/2Hrx5T2c/aPj9I4nh4rNdZ0p47H+LbLM6qYNvMu63BG1Ir57X5bcd7xsI/D3jshuxa2dW5K5+gbDlJjU8dP5rl3RvzDTEBHbyLOEMD/lepuvvQcd16BH3zwAKYDowUvJArHM1kK4GC1NNih7gCATljn/+3ZxdXZgieAYRZLACzEFOffCUqcfyIHMIPKeuugE+z6gqAgI9KOHZQYa6OH8VJLt59YtGLunFEGPGRsNbAMwwKeFYauRX2rkgApLBd6sXrqcuZVOXxMnUzHXWn4o3TbXBwBkfzoVICRxVUXmXNrAgbnW7Hum1a4RgKoyMoYvMWRbyPwiKff6A2pDPXmVJtNsbixtzSFT7w7/J3ge42Vw7BNE1PZGVtV11HBRm6RN/Tv+R7w2E4bUTpDtvOz2w/5wNXt8jt9UqldwlakvdKqJNt6M17Pb9GF7SwzXPSM6jU8x1G97vsmK4tK7O2rOEa6eOMxpuiO7uRKJ6C5HeJyInCa/Ij5JWv3M01vX6Uv6H6stl4dd3GPrutyf91hizZyYbdCGNbPVE0npKkoSQpSAk2taqk8msJGZ/U/a+fKT0qd+Ncd3wKkACpVGn2L69/Bd7b6yn2/ddeTnvxLSx91jZ2p1JxsRz/59zeyPs9toz7NVshh/D19gNLqDf1v2VH1Kqz4AHtcLwuF1m/uVENGxbnDNi3bovQ+t4KudbZY5+hbTMdmaLsK2rECPd8kbvdEo5ft0uMZuuXJTq+KozBI5sT3XiS5zf/uUhDVXGa80jx+23Lq8erU8AC/5rx4gKrj6zBn9HgNezlHtST2+r+XuFdVTxzV9sQ+DcO9PD3/qelSPloZs6fq2eKvWDwsIl14UfA4TVtO/QyZMQJjNUAkANg1KxaciBRFiGpZxxAEQfQBCE6zumfmkhX5zGWy5ke04nykiEU4QTpwGPwhCBKGZBsT5DAq8OCfsMNuVKWFeywOh5brQiTSzhZmaIj4H3E8NK0twBOUeBEj6jUPQxyvKxhUBUqJliKR2xewpRT9jiw8hFd34nErLZ/Vg35BlTFpVvQoVhdnvBAJetVGQ5ut9OiG/zdbz7Ohvmep0eMx8SAHT6orYbQJ+RvjGaNg+8ys3zD6UmFccufyMHFt3j/L2LV1sDQNj48U3rIXoK+6FpmYiBbZ06ncmyCbvk1CkWGUqfmQ0vyOAiiyJ0C8XfOGH7nx0F7BuUJ3UDjqSizidm8UwVj/o6YqM6hXLN0RWf2N5qgwzUkX5yWYYM+4KAn5/Z/aSOOEcW2SPPz3ph/f9EC3HHWGqCU1SOK33W8R+IVGwBNh0pOLOFejdjbPFf9q6KlnFwreApQZQSs4kmEi7aUiF4scD+1g5hGkw2O40jbVMh2HTSlTqY4S410eX6Jh/YUXup1x8FjFXqrafiza0jVkDpcOXPuPvQ/3ruXar2IftXepqgDXE+rf2NzXIlgsWyT6YG6k3nlq2gM3FN31N9v1uPdttNcYT2Yd+q0q21NIn9y+2zo32uboG46NX9D2tjVtMc4EbOTSRNKrAnXfIGl//wEurBcGRhOcAAJQVJZKE68Gr51wpdBbAiwzxggAuN03QLd8TNIgbqckJ6oRVPMPAAONP8xpMYiZRBHZg2os9cCbVm55mvMHoTSwywJoyrF86HwFsPbrSZHRVfV5UCeco3mk+SxrkBOvUQynXPA2iKbH3SZklBKf27GYRVxeCXm804DQQCAm10HBzLwq3ixvVy5tEnRhAJClaXyp2iMc5c21wSZOfWR6+dNAGY7r0Puv/04pA6/H6az5zLx7E+q/E1xt0murdK9hyd0MAsDdG2vSwjYmpFL6sftes/ltSucnEUXBnm137n9gUZb2eRbzgtu0JUBfZL0++8a3+2eZmW1Fr9FL9pe0EBPw9EMMKsLMqGnk01Zp2tKpQ8vvUyqzJ8HgY3qAjZ5EChC3nLSQf8N/++ny7KOYo8hxSF6/gwPMvcOtAkpxQb/oivzZuWNWl1C6sUsV5ClSvLbacY0zD9OcGOzbILz4Vsuzm0/j1jdRiwk5URpJUnnW3268Pl/wFERGqigfzZJ2DXHZk6xo9rM77ivCkWvOFufm2rstOkff5trk5vjn6BvJMdX/ft1/jR3FJok52Y6+95o8UdQROtmxFbrinyFJK1bD93Xp08f71LdRn55quEd/F6WpbE8Zf4urL7rvZMeqQeZqUNXsxZ+kCVpNv47iznpv6HD6nmgcFu5K23M7X3WkhKCqGSzEMwBjGMYE/JWGO9dKFfSlo8I+oo0I6X3Zpq5QiSnxfXH3FD/2tsYpCvbzVnxOVX4q/37bA7Ua6Gl1brV6VXIwNz3uNX1kt4Ftr/jUylui7LPe+T4mh4STk2DlGwdIAA5wReCR09sBGHlPgLhZ/CJ0Yt0PKBekHkikGv4sCuZPOkingJgIZCgbzr0gkvjJxUUBrzFCf3GbWoQ3Iv1McPotMlcx8K3Tm9d8VuDNFR6DheAUg+emBGIQgsv0J0rqS6pM+ur86IL2RFEcioxJ0Dl+VAXjUHRHJM4rEFypH8jyLGnBSr+HhhOEkH9xR4iZaWY+yGo1NaNv6RRVZamxjp/FoCsP3ErRA4Xjj7KlZcxO1cEwlj7KZFM9KpuamqGU1eyNsA4Bnq/Xb777/jteu+mT4S42c3kW6Jrh2kcf8jSuDUle7xm2rsHr58sLxgR2MA2RTINZO4jSqvOUFyiNKeXLZe1Gmxooqz6HDAL0DUD5Od2UQSznkq18jlLHhA4AM5KNCYqsRLYy4At5chfALL3L9Mao3sE+dFF9p2KxWXqoZIYSnECWkC7HYyO7aPOdvLjBUB79DFT5Rp4DJLL01jii0i5RLlplTWZfpD7dmH47PEEEiCtbWuwJtP2mYhqBim3FuUI9pk/q1FPmOkWmFt8lpbw61H9S28bggV99tvJ9uCbtnOrTqkYmO9WV8DAf2VRtWPak+hH5tPjoMVPqMpU/Y+6frR9FjaNPqzyzHarmjMgDyIff7TNVOPKXe3NVngo+gFK2+hFzU3JMixxu0xO9mVZ2bMEDms5rzD3HATirogOdYFv2mL68LWGupKb0d0/Z9gRkERzjT30S5RBJIMpF5iwBt184mXr+NfAmG5OIgANghTCauUz+FHM6PAinrhU+QtDaLBBCwwIku2sZhR8QhJKtHixYiZPOaQZ7cQD6v3z98ur1K4Q1Le4Rw7H99PKn77775uLiIqMFIh1kBfKjBnzrNBZVVMuXgsuQj0lMowmso1b+2FUyeCeVE1hlo6jglXsjcbNe/+lPf0wVZKgYgLq++OLzD198hnupiPEped/FwiefqsOpddCcYm37hECpae40ln7uv5inlKYkEtNZ8+lM/MC/e0zkN65VFqZeg5PEnfs79SiNPf+ujSEfPxP3gXL88e4yrZF42SDCV/6408LrV9frK9ZccQsAHm9SUcAqNV7HCRiuMWpo6bG3dsYlb7+pWwG0LLVzDEnLxoQ9oLWaCSfpKV/zJk2sclvJz1q7sqz2slQHxgR96/Lb9dnr775jpHFD/+QBkdWqXPzy/OLi8nepcAuBfZLzB6st6kPfs+MxKnFzmJB+aFaLepbO7Lnn62jTNC5FoxBNrs7ju8WCfEWiBZ8zJlAhGvASMv9RwB0S3g5EWl/C3ZyTUNKRiuUtSl/q3H8shbfb9b+/HXnrd7mnz6WfQM8xv19z5o/4Xet/m/r0nMpT6dNnzMZ57r2qev69DMcSj6j7YVV92/Xpw1IHSumZezvbKPKYus9pHjHYaGUuUSdTwyHpdW+jP+y1rmkvf84B7G591OJiI3ie1wDAVC4EOW7ScPOfrRiSnOxyHWrU+s1PphmZsL81wgMMJhqj62/Ns6dQ3Lt6WF9xVrvV/jD/+1A6bbuisP+5tj6M+DD18IBjJXuA4UFFxwZj3nrADReIrlug1Gd5uVqBmqHzH5QU7EyR/wUeHEUPAh4FBBl5LksgRpFfBHAqMaVFE6+oTfiQP+TqMiI9PEoKcdSvWmA8eAvq3ep8xViDB35RoB5FYF1cXF7waSWJzOwrIXLhU0rAmXBgSX8s8CDYYWig/lDRrBeWKSwtauJDyJZSFC45YAmXO3QDsur2Q1lnyOHrU8t5lTXEBvrkf7CaCscNLaVZdWy7mUauwkP7oxnnlZSKHUU72ZLeyzmv+G2UpKlQnPZtASd49JWgXXqfmNgGsJVs+LyGP52KBkprIUwnAZbTYeiokm0utfEnE5st0jpLGnCxePPmDZ+qRrE+pHsJvhlasLgsP56tUyi9vLm++eqPf6Rz8gQN7KvVBX1j/ebHDz7gG70ZoEZN9VaU2W81r+c1BLHLpRJW1fMmvUhvZfKQLsytqKpcsp6inAjsOZP1P/0wCuybVsrTuFShC084K64XK96pZbH3A1DQNlUkErE5ULePxbNN+y33VBF4fHQPNN1TOflz6Xl8cHrP0Xb8NjW9QzlJ2/F2T+Xc8aouHk1JXKzukQtPDQB2TvhSUFeEvaPn4t/xq2ndoe7L9jr7dHhPHTONQS/76JiONaeU3q29tekZnjBdT+gfr7D4xzoqeHBcXtE7PEMwZ71WxW3Z6lkP2t1z32CQHdtlIOw5Tnl2KIdbsGmc9KWjpPa4I2knDnaSRKCiVO7tnW/YEdyj/nAk9wicQCrHdqLX5GtuoJVx0FMBEO/UxyVfH744/yPTqgEalGaqM0BDcAFyEDwJYcAS0YICcBdEIg8CycTq+uMAsB+BKHB6AyE2SmdLqst/yDc3kPGxY2DNHRD/2eULgBfojnEF/nHQEtaZzy/7ZyA8illpQ952ty666uYNA69eZEc/9cXNCniMb6lU+MIrMcV16YNPf2DGN4qqQqgsrHnHm7b99MFrtSofE4SGeWJPB9fND7iqlUa5Cg9t8h4qP1h4SNCyEr7Phfu0RM/jldxvZsPROp4VsMmd5xLl02B0Gzqqfc/ms9NVx0ttcVI/q9rIsPCXNlWY/7YupX4Fb7VY+13e2BMUK8COl9Cuzi8v1B1F6Q1IuDyOQjjSRT0FMErXvTy/oKvQQeww+TtbPv9peXm9OPtIT9SrWve6oJn0iphYf0L+bPW9ZSk3C5fW2SJG0t5mbalI4/SGwC0f7ljcfGrvX6JB7ohRWXxzpIwIX0lb+ckKBLn7wX0/dZd2jhoYt0F+JEwSA8dw3GaoYGL9PdyOvwJ7bbln639l+vQ9YkcX97/mfXpOwTE8c7LQN51gpu6FMUrD26jvAd/uLZrWffzV7mWrx0Op86SqXPuxaOTP70vLbYIzFg+JUdxfw2F7THx6JNynB9113PibNf0SR1J7GnDMD5Ll6vpL2npzB6AuS9ssvTLSY+3HxMDusSeSnljted9G+jE237mzbyMAT6CTOPTN+AQao/DU8L4NNx5WlzEaYxWKMtfZqvT98f+wJ3oLAGAaFWSdRfM+DdyuigEE7AQ09gqhrYAh6IhfdzAHa535gQdb+DMPqAgw0mSGBBxGECCo8powICiUhAIVjZYVGFMPCCYTuje5kuqj5XVFwUayiGXIAdQK/nNSNWAuvAXh1MufNzQUr2pFvlUxWqsgDPoCKxXNERpanVTNxiAAx1DtkwdFEbt53wM4hfvQmfolGitfOV9VNzJlveE8RFHRaNGyyTW1pfyp9+VFae3TD7aDklMcPoV3yyf7odPkmzBmLOaSF9rCFfM2fkrTgAT6lul5/tkh2kbSnP3B/9GmYlqLzb4nr3+DGXShOXcMVpwUMvCHLdJw5o+d2jgwlvC2ghriDDfJ6CVFOLvlPaVkmO9PNTSIBzAgYYeLXl2y27mHwBY/0xXl0YTuFYvJKoea8yVjVArxkbyroRQZuipkYuLJzBmjw2cLHgC41v1SlRqV0ranaGtTPNxjwZAYjlvsv2UeE4FqlHcZ2NYNHuP0u5J98uAQ51Enib1hn8anKCO9pMbsOwzGXn8H+1W3bZbBVZw9cAeAcUwJD6o2x1HpWN1tA4aT/yPbRvL+1OEx0/xI6H7Nj+HYO9f7GIUHZO+x1Y0vp0qI3m5TDPPWU+bTKAftHlbV1+hwC46cVYuxfx3Wf0zpYbv3arA7DxEYvRqjXZ19VFIMsxYHPSP/PYnC35O5tPaMP2/t2N56+ujqNkvrI0ECnKnCDjEWSawM8NcpTIlOlZp0kEBOXAPadRoVbiEH90acnge3kF7yZVxRLwXwxj7+i5wiChw3WCkNx/ojKQu/pysdLgCKJejmGKlG0YCb2mTgcVsSfmYJ+vp30O6yIrkwWjkg2qnlFUgzSQr+SQWbqugrb7QrIINB7WyB9RxjFVhlCWOlqgLPQv/BN8QvPo0hZ3uDDhd31x8t7j7i/TxqS01U1byxjvnTkjZO2RCIK6fIjLwleb/NbY7u7T27xjeulIjVGq11iaITCCq+kQkD/DuUTm5INil1N1VlCIicSXaew3ZaP60lj/w2elB5Rb7spH9WDz+7/YzwL5c/qAKw7hn5JkWtv2mLbwBTdvP87Obm7OKbnCNWIUA8tdEfR6R58z+nRpJxe73mvbra47EBRhG362sfwOXHdv0Z4gue69DDoW9nXKLby+/dGxJrirrcSqLf8jxJq7udiurQDXlWpwyuvyAU67tXdvPVd9wb42GAOgcVcijBMGmVMynCvv2TmwC8Behywfe8Yyb18bTN/zhQBlOdJCli6/chsBs4h2PRvT7s246ffd8nPdJmr67hOFx64H71qP/XkZjGYUo5taaHEdqWtsNtfbh0S1EyPX9WoI6/yFPekXKYZ+e5x+0ePOo4KoHs0259nPv0xMpBy2NhV7ei5f7A5g4AF546uQf9Y45ErkojwTOebdRIoigb0kTJQHiHx/jd7PXpdhF7h56cbGoT6qNFt2p4tNS7Z2w95TjDFYeTRI5T/BCuHTcqy35srErvsD3E0o6MsGM0slN2T7Z6Re0nrME0+M+zlMwF+ihAKgNwsQSbjQKikDKwM4nonGiUthEAwwHnUgUbTIcHZINU1Ca8CBqr4HSejHGCicGD+1QzEugBlDFpiYBqhF2CIDGVCzZqHTZplYO1vBVRzztmirNYSyHO41CBG/1Dln3hHrFRaqKRViV5NOpFDXgYp1IJjQfwpUYi/uLTLmOjxCTu8sLZZcZH1KfVK/qQ0CWY/WvSRiTehOW+XfTfxzRXfr/w/Rwb3cVL/do2JgbChm6cUvGdoorfDnGSrWDZ/k1JGogdi9ZYBuYdABrV4LYuRBJsXe05HiiDzhZOC20FPaAlqkFai0hNKSZo2cal/82DfI5uze0vJtrP8Ysi7xHYSZnW9x+e+HiITwOAVOhDHBmowJJ4qUfLsHrONKcg2t/8a6XI0e+RcoCCS3HGHUTdsu5Sr9c8ncwSJl46JNVAqNxlUcizh9wGJJBT4cWSBwDqDoAGEjG4Zjc0q8VocBxyxZ6CWcnfCh4cge0wP1jNr1bwqeKDHrbqxk+l830OequpJ/L4JeA/5qJRXlc8xhrsZEPfjCPREn1t3tFvi46ST584MBI61ezIT12oYj27PTdenK4tm9ZtnL0ei/auPxtL5xLH2JqTHSs1MszVaGTYm0CPzd6PuffyHUek1UbHDtduWoobzZnjbM1xzfWcTU+ek9xH712q86Pfl8ScxX36QpuLNj/k+2TaCr9JUdErbhSWbO3LySYhZAk28KFVsVMmubOCQG6gtkgDFL5gkh0K/4Umd7cfr6+er54x+Q2uEU8vF8Ag2D/Ke0h+gLLB7uohCwoHrq3uFq+FGnfMaELHG+YmX4qq7WmAIUYR/AM98x4VABPTE1YD5cJ6UApgi8GKb9//VNB9/g2LtCGAvharr/NEbjwX5GjBCq4YRfAieepYIwWrrLdodXzjYMXKBkuZuvl8eXu+XPxjDbvoSccuLp7drt/wcheHEgYl2hlx8MAEQNAQpO1UicVvFhe49ExGfEYgUT67/QCd2ajiT1WzRkjG9PIKs8zODvThyNcA0OS7g4Zt9u3722/ub+yEtb6zmzf6DzqGY8VgyPVfHtjyZJut2KGNdwmG6jVF7VsHP1L/QbVBPVtQR6JCHaF3MtwzafRWUMWLJXQiaTxjiyPfBGCjX2X6HzEb1CEZkV272CWtbNxpAK3zt7j9/OzmcvXiivHaYvltY5eFvnCbhtWgiJp/JPkeBfnzH+n/RYgDMC9416freeiw9CJEtM4ZhN41n/3K2zZd4QMyxwpn0I3d5A0vjV2cc3aIyT3L7PMIxp5xcCCTSuUOIbrxO2eEbGGQYCh0D7/tXQw5zr4+W63Pb33uXE88SX1KWSblKgItbYwMWo2KOb+q3jhZ28ZQI4yH/r5iQtpKin4xuQ85Cu4mUrtd4n3fgp1epQ9fXQ+XTq33lKmtvvRR6Vwl2v2HPj2vlAaxHzx0m8ZhShna/qE2DsgNbe2JNGUbSik5KuYd/3gP5zHx0atOZ6maRnuP51WX41pwWu8dylF135Fp2VnX9rMP1Ih5NcsSoKbEi9LAkOaqXO25mmzKJl0SDa04h1JIckPvhd9xuvxolXzHtt+luaeqYcXryT1/cF9Il3pydx6r8KmifaIfJzTOwbilNcY65CMArKMBwIjWnbDMxYEci3suLs6frYEjFATO3N5cCGiuXvHOk1w0eCnKzc2aSdD1i+cf3C1/yutWnAUN/AWOOBOZqwGafWQWRA3sEZ9gUoijJ3JwFN4ohwUsgqWCrTEsx+XF+aeffqobt19y22J1uQZHwb2+u/vhx+8z8MAUuDDoh/3t2aufXl9fAM5Y/IMCgwJG5AX+l5crbiRY00ClJkvpcvnRxx8+v/s0MAskRcnt5eXzlz/98MP3P6Bat1UkDuQ1L2UujkNyRpZRAkGDsQ0q4nmqH+PqlT0xgWLd66Bz5DjUPvS2i8WUFVNfti+tLrY6xFwRdveNb5f8pPmqUFTumGt1n1qrAveGy4AkAIQ0qQBd7+oQbNuPiqrZD2+Z8L+jNXqG+FYizZSW8msAfL8NkbSUvUfp1eL6+trBW7VsxnH0I+g3rP+hw6aZ4LVN6UnCek4NID1DX14tdHfBa6tWH3z4wUevrl6Kvm3e8panQux5f/zjny7OkeAZYXr86vwC9ODAmN7F6BdtweKcKRAZG+hUNmucDARQu2ljUZ2cyjNQjgUHojiDg6B766pK/MhIQBEVZfBhIV0fu0tvYkSjo+kk1A5pzBRxJztwDseheDgO9N+OTxKBodG3lE0baav4uExpPo73IVx0iDLxVg31ykeLuHtMdzyGv/T0Vh4Si7ci07t/n4GON0muIlwj+BIwY/eqYu3RQ10r3VW6kiOLUiNbqG0+cuRAT5++z73d8icaXQ1qdeUujznuzIhTMB0TD1KnHfvZ6+ndgMO6TuXfq20n3qeOLKf3K3jPCdvj41Oe7MTn+Mh33XBvve8jHuxLj6/dnPlT4z+nJ3ADrEPATojEeHZWYluy7ymsjM9cuzPZTmbKL0JiLABUeH119Vd/xQ0cIBDlQR53f0XZxcUL0YNTnoCNc/DTs2c/XV58cgOOqjNfd8Fe/APTNJoJgUhBHHPopIxNu+vPQCx3y+/5kNPV1csffvgO6LRY8i5F5mmWvBfoxbPn/+7f+3d/9+Xv7m6veOc5hfA/e3b+X/83//h///f/DxeXvNocGoFihTTumlnfXvO9I+aFIQvFBEhnz1xo8czJU66BxqIgvYWL1bfnKxDZc/ksEjqV1+zBW75jPtOm1A77lOcmgFUgbYzubt7cvDy7PfdrZnw0jDUg1u32/PzHy4uLu9sPrLaq1b67Mbdd4dgu2GZNzrsBA2tfzJv7dzWnWPp0GzT0IvNfHpjKSxnvEoxuVP36+xW9ZJu/3yJt6amSwbXbtcNF+uItq1zWv+fzVYvzn25vr4HyRJa1NcbcwNvNamME9vzZc+BvWlwWY/KMV/HcEDP6QTqdkjatyvn35vbaJTHqiRbs8T6n7777jiMUNaQ/o/blTz/9d/+l/96/9W/9L27Wr+mHrD7D5WfPz7/79sd//+//+5lJ0+F0K7Uz4GSQfA285ytyi+X1m1eMqrmLkC50CaOOcLqtP9PI6lsIKFRBDQYYMoxtXcHRcbnE92x3d69evWYRWovZIO99h2tuRjFETwR83xHbmheW+qXkO0YvFBAN7+zhp7W0nrWRGZIQ2u97K9sciq6HsA/n9ab46NTh6/Dh0qONtAq1MB0vNuF84LW9m28e57AnuvcTyuexQUg8CWbYbyzUB9ax03hPnLvf5VPb9/G+jW4SyfJzJ8Ijw2yib81ZpvsLTq17p/GeADfOvtNEoon548VNQLYi9NpII1aSPb2p3D54KSqBqKqIjla3ed9SbjC/o/7dOrFj/F1lK95YmwnCyX6MCk+W/E3gbURg0x6b1GE7dcrWHs4xsSNVKGLJ+geQQAMTgIBAdliFLiCDV69fel9AQAJ6EG9d8GWjC2AZvOBscAxjAEouxVZOjqLBiyNrfoZLSAEWKEIN/BG0KQ+vVw/pzleqii96MVdK0bff/uC6+qyUEKBd82JQ8PdidbG6u3muDKCe5RjPLp9/+IIZ33PQtXOerNNxyTUMqOc1jjirS/L7Bnf2TMBqV9iFdTatt2Rhvaqbrzly+hapmxuXc6Q64ELuTuChw4yYlBwTCIOBVt//8IPV8FmJCxZoU8iC7EsGKOfPwwg/7GwKbSeSK1qS7JLbJllUGgamreOotqgHOGGYat7S9ZAMKg/b3Cgtvr0C9hL00EwU0/rX1y9vb/jBYk3aD3xsy1n+mytHcaslD93S9WD2Hw3A3PzFZcCxd3DUDtnWa0g6Td+y9DhR93LJ47paClv6qGeCmP3GFnRLn8ECzf7m7vqDjz9k+Gm3sR/yutBzmtrBAs8Uc1J4XnCzCb/8HDXd8NnlM8ce9El6D6cQA03PAAaIzZ16boCvYFAFLGfTG3oaBP6qdpBI4A0k3p2builhfSmT31L+Vd3p8LwgNG9G4jkfC86XrEZiYOB3zfjHf3iUGc0268cd4tlxrD8310Or+HP7Pdi3d6eVKjGQTztWEB6j4TR775D78ZWq4Exd/gV18o3zOL1vKzI19TWgm7HUyN3HoIvoWI7cZhvSGz2UbVg3jJtUjfwqPzeKmqNHasvWRu9OaqxG82Zn7n/krplvvoGKQD9LPTI8IHGSnnvtUoEhzHt8GYt2on7qyLKPT6k6VcMe50IqPfg5enhSfEqqxMfKztnaQ5/2pW7u4bi+tEfrvaSTozf1s2yAJ/YZe/ysW8ALsBsgEXQLeMXSMI0HaiUv6gW1fE4PXJx/R3mh4Sy4AJg4Da9zgiiABLO0n9hZVz9A9x0mYpe0nLObAKVvYsJWjHqO6EcU3AQMoVQ1LCh6/ZqV31mbDZDC5pmjDoHS9Rdn158tVn/ikQFkwFk36xs+1iTKAoWxGgOz6swmPheTublAx4lQDUsV72jastBrPAItFaLSPlUppxguq30ATCXmQIJiZvh9zQvRu/3MGlx82xZy3N1d8pIVM/ITx6waoddxfK3Ju+eJSizpABuMZZmkjo2bsG75Y0dISf8MwDb/IDxSe1GIb3Mrm9tGtnN7rdsWvZcyEYxEO2MxPsj1IwvPzs7+4NCLdS8rWp4FOJfr2+8Nsd0PkUoRcNqlWh1cW+EcYrtRK4y2DNk2ao0L3gUDJ7PRY7iL8xcLbiKtvtIbHjoHKPu+/+X61ad3bz5fL/5AH3T0GDU3rFvLujJ6jAQGnNyvyKlBj0ReRvRa7CMEObt0UIjPHYfVN1ZcHC9zPMYsXtH99TR/EEhajaoi2mCm/6uF5xwQXH1LGnaH4xpydj+3UHTl7Ha1ZuC0Ps9g3lFKRKxsDGQuf7wITNtFF3c377b9Iraxk40J47S9HXPdPoZnW+vT5076DR3NF9rp176PRTuJuTrWL2Yxz/HsqNqfnfu928+9RT3GLi07tvKW8HwG/ml/mGe35O3hh8N2jyqtykyiMNaRq0NqXASvREMAOhajyOXpgEHL6gJ1gOmtF40ud5Z2aIcqkTp0om8/Wc6xv8et4zw5QskRLMfZ+lm4Ru9J9Ok5Z4pn5Jxj+wXSj63TvXyiCP7xy38DGhAoixA42QXvvthH8BEKvVScInguaA29LgpyyK1Y5CMityiqmsoE/1izIdbBTNCGpfyPZmcvwySFBADOWUkgjDDJrdqJuUyfO2bQ4rhFU9hlcU9GENzEwI2Q0cGUJ5ssAjy9FQ95ZObVNUBlOuVlQH1yxxWSykuQVySlO8FsLONWgg2VrFBigBK3qaESmKaODBKahiIazzy0qmb+lQOpr54kj/C+TXKKZsqreFNIapNJuig9cbQzMu8tHdkekhhVP0R4qEPrGHYDbzPZFsJrsj65yx2e1NV40mF81IMfNXuywS+76UGdC/aBEgqDeLpxItPSyiCCDl/UY2LI2lK2X0Po9kBMM/JkSQ2dM5oaNiettOXqSodAnCVtqCV7x0PkdFn/23dxxP/lXLpH9RxdV1WOesSppFy8M+89B3J0woHqWeAA9Sa3IjiRqw458EC8kWI8dfvmzWsGHqsLGWJQE92WynT5ueSxfHPy75i+r6rv2IVHmfuFhftRdX2U8EmBql7xS+8bW/GiMvvq05EPPwMQ8a0gsoryd5pozwA0a1x8FnNrBLccqswjRn6l4Jjx3x67M6Sa+X5anVNT4wp74jltlCLuLUJVa4KZeeuptnnrxdv0TdlGypwn0/HulDIq2Ukc42cvMkasJ+5UoGoy+kDp6PmYKGKvpF9/eXK7d62wpfOYzGNkm/5NFOdm3erOAHihgnPIL0GMwKm+/6VqQRWbojefCsEvfgjQ/QYEAfzixTfgDxF4hgsscnFSm0dseRkPIIL/zuJTClJGB/wsrAD9AOe/C4QB3ghYMqrI7GOkPCWQZgewgZ8Rieso0KNw7FGIZ6z3+MZ3Ljo0YX0Ob5JxDwpXL2JgICEgkgqpExngOBKIZNLV9xpRywXrgvBZXakxjMNmTDAtHYQvOMOYKL8YAHR4CNTyXexONqNu+Y20TAYTtEw/EypuDlABayDj8hrTC+b+rW1C7KGM6yfMLVvvz9ldiy/PKMY7apLd3hXLFg2/P5ZQbznjSQCRXupWbCVirELHi976+IafLZ3bmf6tQZSMPkTPYslbgLa39hagvMmn0z+wcUxMzMet208Cbfm2ND7yUIXxxF3uwXCniJblvo/oOULBxVFgbfKXHhSlg9oqot1d4WZnTBtVCMKjAibkFVoYN58DVogeZG+hgHvnf1o8+9Pi+tyuzVuw9OjufGXjwhv3cMnW14Sng857K8jTNktx4IIWjcgEgafOcQF6ncCeA3Enfbj8oLZDmFFCi2VC1+VFi2/JojU9UEdZv5ShMEHCGdcq0ZeB/qxiu+PzBoTu7u76zc0FDyS0Ta/KTPYtM5TuP7ao7S98q9Qjrqj161Be7J01N2JTJ4/QPBXqKeOv0oY41TmlbLjvT1VD7fDd82zAe4a+dpwn2+LGecf2aG/3hiiq225s+jEx15t3+sme9u31vvP0BpmPpqvymx+WFHit8irhZWX2GQA4i6suAmTnomLBGLrR8s+TGFzure+j9eXvPF3x6sNZLs45Cp3tHUf5bZibq+ADWqCP3o74WDQmdhh+FdmqXHWNR1QoM/G8t5BlAT7bCjoBJgCphSWgBwYDhS80BM7gY0biZYCEK+yDSyCL00XJ4U0jD96BXUg6s9n6L3wQAqADsCyN+9EBUoLAKqK8oEch7GMHAIV2HOL1KcH3FLFOGlwuHbzt+od4o1PZgIm5zjlbnDf0m9U0IMnhQAd3IDvoqctiqq2zocR7jGWmlkXnGkEDpRnCmFWb/5og9XCNCCs/XA+uTXYI4AZDDpaaxztobtD7LYwSdujhUaKkxiNsUIp5KNqRHckl3SkeJaM9qnvmCX+xHb0fdY2JfaL7Cm2lrS1jSIi+9d8CgiqkFs46DHPy286ILpqB0VcSIHvbBJpFLd4JVmfT8WKahwRsBiH9giQDiUSXQyXI2ZnLrsM5Bn2Li1tepe/UPzP6WELJ3flydX17g2v+Y3jpoiF18y9vx5IvWRWmxdEfXvtK1c/9uFndVkQirFVv/UHCgYKm1Jd9UnhoLPzP8xDn3KHwxPJxCYwvnz37kOdReAtQJFlKZR0irXCIca3pi3bTv8btbVcO/UNEnzh81WCl/IlV/9moqxjuVPdASKs1d/jf3+zQuYdj+mK7XNAtudb6vFG31WW0olK/Vbnmdhx5J8xG31AypQwlb/u4Mw6bNN5TeoYt9O+dRaCah0vrPkO5h08V49qPLu5kK3RVatEwGoZy6rx1rPfqRxdOa5+p3SnlNI3z3P0zCYdnNWgR6jaGcV7l40oeN1uj7aEFH+fHIWnbeHLOrn9nfKb36LgEgHnWf215+8GKxwIDj8EIQAnXKC+/CdJ6VhOYwi1nwUE5IB+eaWTccOMrcTAIlGBK0SUu6BughMpZAA0g4830vJ+EBfQiFpAFaVfvU84/CaXaFgRJoZ8dxVAtcf6VzwUQPKE8CEZ+GOFKKrP4Aj6rjlRQuiXXnztLfHaTAQAlAUR6kJfD2F0CzeJDINigAk0UShfdA6GEgde/W6yvz86/EiRCF0/ZmjxszDtQ9Um3fVqD2yE8n8oDqjX1DAg751FgHEOnX1QwzuVlwkVJbc19M/X+nI7QWLYPVV77sWRHiOyC791SfOu3BapalWjxahkO2Ygj9xbCF/fq3UGqGTm6dGjeqSBABV8HLo6bexRNXSvzLUAo1Kl6g1BSQ6G/SinRZpLLV8SWnna9vqL1BL2WCKw9rH9P/1z49AVUe5h3amgIxgYU335KIU+kjN7nfgiU7+W3IcoR5Gg7GjRftGjOUZbVRGlxrRKcbBzo1dWZVaI/FJ6jhOePr70rRSeBGO0OpOkF9JkMWtRi/14sLklah3R/D8M5YU2Mz+gcjMnKKY6P8hST5+RY8jvOl6eHEx9dQnp7Jtv1NU9I80IgziMcoftdv37109Xrq9y4I4uyrLOrurmvalqvql2zrcHBRMoO7XZ+l0fWOfrIQKLn6dM9T0sfcUXlF6qqskd8ICUKQ6aOR2jeFtjNjThhDGSuGNtsUyuP/pUZ7W5bGmYfphZ3+B6Xvae9jlD+VIiiefJ1zqRJrdtczIQ+dbDHHnVmFM/xfh6OyZ7Sg31gD38cmv6+p+bD6dxVbDi/6Zg7A4C+fp3AVnJzMo1njT/T7SQbE1sy71VmdPtkrw6H53BpGavg7XDuZOGEsgnzkC22oo+lU9njavVQueO0z3Ht1GuO7anoo7m9YX8qK++VHmp6StMKO5yU93edNSvX13yByzxKWNrAqGB9LYAmB34QKDgOgI2PcQk3SAE0fNcNXxblW1lvoMOGByAboD8sXMvAQyQgArhBa8arZs5DlE5CGdGNx7M1K5R5WaF5sEwD6iDxiwt24Q4KxxnV6og6+QfqkZgtCAxn4NAgTybrssisIFQRN9xytT8lqILRcZYY+kcfffDm6s313QUVz3vk0epSHzDW1RXYi3Ug3mQgKrhhDJ+dMyZimMI06/XiDWG5PP/gGa98RGNMwiyUTTrm2LVMI5PT9V2mgfnQUblh25vuiDoy8A7HsXhMxJXyKBDcS37kqAX1aCWdfK8TLcVQ5U3pRvcghs6Bz2O1HO3NUvWXr39iTAUjESS8HEiDblmLQy9h/GlzOb1t4169uXl+w+fbfGq8dI4WxkSUWwPqMQS+FaZmAdrWDDeLV9v0NdxCrQ3uCI9Xi9qvoca2qmBAxgdGeK4mDrPnoXaeVqcEII77z188Y3URIqhSQzwwi70NETqitY8N1Bd7+RROinmpaF6LBDWe+OpZg0F0eNfQ82cf+9qrxeI5M/8ffkB8CNi/9C/887xYKTVNDDYhSDY+xfokFYc2u5RbzQ3pfUrhVoXwsFNVgWM4D+v5WUrf3+j/LOE4wugxDf3rjmrOC6qYJ6g2526lKjzOfh3cNsVdrDbEedl+fNOne4k5es+T9H3jsM63JlvV2yiaG1FtOIbU3Ni6yg+XDjo8EqQdJ3YoO1FspUNM+ipR1I9Qeyunpveuud9RMherOfqO+IOzB2JLNKbWK4BjGCtihnGI4UM8OWK24CFq75OZ1q4kpPvszU5XOmO+n4335FjfsJJmm6wRBEsEq5y9ubr+d/7ev33rp5CYt15d8yL7jAT+4T/8R//3//A/5AU8wTeEDvyC0tur2/W3338LJGExMSgHOrB4cfvFjz/xHn2eGcBYoUQWwVPod3+haIuXD5pm/X01iWgnCB6cRTFYjvlMEd4Vr91kaXVWfQDdNc1bC5dveIFhgDN4K7CMAgYffugXROZwAX2Lmy9d2H3+lVYWH7lnFtY3vYDYcCTwEbMqiDsSddh/bQvQ0hIahImXL15ePGeM9FngP7gfeO8b1q9ZQA0yvbnm8VOYhf74400AIRjLmdbX4kWrf/byw7vn58sXsRC70La2ylpkyj+qpWiitMWaYjgt3imYyfaclZ5SRtHSPGZJSEGAjZZodhPABA3KQAxPGFoqhxLtyrYIG07CjSK2Vme0r2/5Btvr1z+Jp/MgOZXmH8bBuJ986jj17u5LBpwJs3vahZeuRtP3RmgYYao3dwNG4yYUo2PwU5jpMFWrwR5Bb4xsuihEbmhBUYCeStvAhh9sA2X57Pnl1fWbEtcTue1FL1/9RCfBnANn1LzR7Qx3Hc9m8p87EJ+r9vz71uq6bj/P7TJgO5ysg2LYqdfoYaUcBsgyRH/9mtsjEFnNxz0ozg3tvH519W/8nb/7P/m7f+fq6icEva2XcyR1Y5jEV/lyp4Aneax0hVzlac1xH0KcqdTWHnYqOd3mfpfn6E0DntAUf9zo69Mb6hEpm6TYGA7h5MGr91iFjdQg6/GgbDFO99Pf5bLSvCqB1HdL/4Ns9dbnfseP/6rP3C9Ob2Uu/eD2GhU+xvqohETvScV8q3GPjvMO9hgb8Xg/e096Dyu9pzS+zenv+LcqNNV8gDJ0Qt7i13MN5J72ltJjHJ9c/9jYg+YJYSj4uY7TMPeUve72Tb3VZCfXoTd1SLi3eIjv5y7bGw0quZdezlbRsYH4uSs4b38fLuy4rWDXil1yZAo2Zf70jhluwFGm6gOVfXP58p/84Q/MsZKoF2iiAMgSaCQGAlKwAKbQUhYQ8Sgk4FeQLbIV/jhPHxOgC5FQaxRKZeCvgJRpNZIF+wjjfaEnqxbQIMyqhyadc3UNM5toZYSKYLIFC/QZNqgSOn9oi3Z1mo1XgwweRqsqTG5v5FUhMUk1DTwgLW6CAO/95sD6/Jp1PmAosRVVo7baR4wlJr6uiCGHOaujOr67xCopEFc41C9VK1KSHHZFYJ8ESvVkCBFM8YgyxCKo2fBoO8oaKMX0qETlOhiZlOtWky+uKi3Fsg+blGxwg4DZBslkhmzZaqSdg9XG2tAu26yjtnJuEE0D3QLdlnd8/IEA57aSahxxcmSG+9nF82cvvNfkwi5rZYXsDNQlau2PIQ0+w1R5QgETWly75Rb+Cqn+oYI5dBXF7+I102IdkdY9XFeGJH1jRb/lM1/6vlgBw1l0k7tWcNsaGRrCadIxaS3W0UBovqLKGpjLYdgpQh2jtvpCUL6dC5eo7s3NG76Q4OPtPN1bHjOSv1utfU/SG0Q4P6ofOU6IOnbWJm2KmmY3cRjMvutjmuBJjNrIp28Pk+rtEMXDlSiGXuS39LuJwPGNO8dZp8i78fYJrBx2145YdwBalxwuAbkoMN9gP67LfeeL8xCNXlGSq107OrYDSS7om/jOjcPm6Af03lO0sbnDWCOqufFWz3wvT9k4HHYUtnj3qo9Iz81h7IxQj9C0n2VOf8/djT578tZoe6tgMsOR7rLFMp2xmMZ5OpvSq9jrVRmq/dgiVcdqpl7D8empb8fLPoxzb+1QNdB3e1O/FjBYp5mt+wBbPgTTXHwtfFovbpi5FF8Dba+BCizvf8nnRflcka8GYs8pyUS765s538Ud4gmxLwAKsLQ8/w7UPsBUifIn8hKBKVKyppznC4Ae5Vs0mebPdhGIgFUAT9yzEJpox/sOXDRWS174I5QRuLi5ymihThzjSiXssXT5Fawm3IoTKQCXfhd0LOao1SBcicWGP7K1wxNqWlDJCjkvzETs3Q215ntOvpKR760SB7G+l0diIn+qk1CV9EeLs0/uzl6pVCQWfpJ6rTvDZSFhsF64O1QhlUhB8anDugph9SY6o0fl8lAqPemEq6opP4Y1Hv0A1+A/PGZwl7QDLZxvPiXCNldaOxhyK10UrcYHpMofDKuhBVfXoItfh6rKnlqPtoqgYdkhp0ukGZd3zF9CXH3DPRbwNFtK/SnhdoySfIHZH43qaTmYHLdEGRkW7VDLfBc5HtPZmIxndIFw+mTMGzejgQA1aPHgVZ0JKZxO/6uMWJHgQWRvFOizT9zqBMHk1kVOHCpgM0G0uoakKSWthZAivfoGdQw4dAGpuE95zHPIUEQVVhrbiad7XbXroZnZbmKj9fhPmPwEmC2mHP6zDo5nlG1uGCQn3jEph7r3bpP7h40LOu7mPmQX7X13Zfeq3SXi4fb2BNdbn8x56GaX2t64GrANOokWyseYlaHa97/LO79xxaDUVH/Un7orB5ong287SvAHtmPiOfyy7Ch4R9kntj601wO8J1zVUlNZ6BXPadFTUY6OQ2v2o+z2vHaaugNQ3YfsmDhKWZjmInRQQy/Uu3RQ6LTCqkpv6LD8A6o+VXikuWNsner/1Jn3lkLVjgzUkVU4tQuN1o9piCN9+PnY9ldiP3XHy2DQcIKBWF/vmvYb3rTobCuTmc9fvGB5tWhL8NaAC3gnUANVICMhHeuaMw4gEQQspul+Fgfo1bdScAewREQFAgPqkFJM2TgkxhLlQODlPyRAKr6qCMWwZ940CAmtfhQ2UJgifRLSIBdoGkfS3hSk2wXQAYCszhAOGaAPXm3oYjBy6ByYEeRhiajVJzZYiJCcakjFLdAHRwVlVHN5BqGZbCbqwAhC6croBTcKxrxWhiK0yKhqEsGRTdFAlbMFQLYiy27SsshXdapUj/W7OTpIFKuhLouhsyMngb8IWJr0SDHB/+iECa7kxKkQ5Y01fWllxa5CNiIh/7ihAJQPxH8GGWeGUBNzltDAJo2dwUbY4SijszJMqWaiy75RaRmqBFJzgb4itSIhUDa6tDL1L/QcyE2f9FYSuFnXRdnCaBVzcugeD3zzQk0rWf3B+tK9U/VUTW794M8j/2M00rrZfKOgXMSCCejGhaQO2bMlymVCnQhys87TCJJnlWwOpOl0tyw94h/SuGKDWp7/6qnAeFR9kaN9a0fZvdus8L2Sb4/B+ByxHck2ahrDUYnaP0DJqSKjA3sTozYSo0ujq3tFfiM+JgJjkB+j5G3J7m34sYs0q3wJmBXDvA2IVXejQDF5EdyztUmprZKxv21R33qmH9v16RjuR7p7K7LjXj9e3ykas4fHZDXKH+cGRqljEr23x/BPeQ7PkU/5D1N2Zix2u81h4b50Zoaj7zHTOw/TON/bOjTxMU6W3eI8plf0Van01LcpzwMpkz58nJ4jqz6nTOwANAA+iDZWPDUoxCd1fv7sghl3VhSDv0FgjAoKUwNEhBe819KFxsQ9y9+BGCzQEYoEgMIS7ASbcCxOmi5zghhgEZo4BpgIffSEnQ3jLHtuOHgVCn7hgCIca1m5hTWYZzm0i+8V53+BMcu0pTKpIjrqxwE+rRfRgliQLUlNKKeARHek8Ip/FJFq089kUwUNaoZSwgXiS67Qf4QFbEzLfcNbI29veQYA3PiJRhY/GRuqDDJz3p1qf6gXvD/n1psbhsiBEO+i+QB0eZf36gxOWfOoHdz3nfp4+Yzd3e2H1sC3CYW9qkjhnXT1R7oqxCqV0ZYxxpY8P6Yhygct3S1eW0ne4aMeA+gWklbWeE4f+SkRh7vsGhgpA3+1gepsJuVEuH4ZAIeeK7N8zf5uXV8JUKUT1cQyX6FGXFk7QjA6YSLpRLY9S8fYshsOFBuJwR94eDK4ctjBtB5F0JQUJZIuKze/Y3x7t+JJm9iAGyHNqNjvUiPFfQnoDldpf26qF/r3FCnEHRu0MR3DRiuTmlGRPqjLZDwLNS5RRzjiVwY2ZTPVDxFt+Hv7Bc8ULO9eLVnJt/yqquToxVLqzv0xXgB1HVWMn1s4lixIMxmVqbPMelOUHIdZfzP9fUV5hg16eCufCCY5d5089ZduTs9g/+HH/jfueK/Ge8hdre/3YfobVzIoqZCl/Sd6+l+EPj1hnBJK7Y6TZB82b31UfOLh3JMGR2mYVqOnHNTfM26lZxBI4zkxqluaZzIn1/REH7b177Rw59PmXOyI1eE2hDz2lKsP154NmdS84i22Exgjt6N2J7uj+leZrXbZDvZRFd3boEdJPpppt9s8WiEKnrY6e+N5mLi39Clq9jPrOC6wHZet6yw/250fWuLIq0p4cwiwizsDTsULUgCrIiwuFExYI84aGBoRfsGIeBbUDh4RV7hlX2BJxCO4ocwNYvAaIoE4ATONHUO8Tx1QhzGg1C0XR3EVxvIuRRc3qEkvUOLMOZbxRGjlP+GbQC5bjGqs3GhUBZsnMIr1LMamLrdDY/WgOQs4mpDBaEAyI1Us6gYRLjCfeRIZZfjeRcnIUhcGUZapgANA0QQU3C4dkk3GJ61Ym5rxZa8UDGWITAnnKCdGLYKFg5JEUluVEyln9VK4FI26DOqUK33Zo0PIrnSUoBDliRTRkrNMR7EuEYTUliFiTEZbTMe4qpSQLwuNkkikUGFr0IhqwGqWp9sx7GdSb1mQlsl4lZQegyKg1lkCyjoXK22Qy6+2V0d8tTwpPaiEzg0uIdrS7Yh+ejZLfnDDDm2r8ReXNKMb2ew75jhzcmtCM7yQZ3njgyk8K2KtfajdlknY5Y4y2x5Z3IveSqY2KoZmic6b0WcXIFXb2hC2tRHHSz7lmxf5O07UG4cZRM0Hlq3B9dmKJxmUtGXKoEl0N/UklGM3GFTxoU3fDpW/b2VP7u9O7SuQVetTbe2oet9C95s/7yICfQd6EntzvWrX0NyXgHGiOnIJzKnrfN0el3QF28nSOtJ2siP9qEQ/tuvTEe5nDo6uxFFmp0ylv1/PN52PHynEsvF3inpvO/KGE6nDjTA3R97Pc/SaD6d3ZiymDh8WP6a04nC4UsfowbfDSiryRBi2MnpY7Z6efOIYvfRv6TlGw6QPH/azK92q1uFoDFIDV1ABXVJgDSINmufdQufnvhX06pWQkUdsb34vpLj4Pmyseeat/8/yUSExGioBYy59EJNkVWEASqCWrol0xBeFQ+xMjDQwKMrPWCJOUH3fN7q8/Rz2xfovScLouxNvX/sw5vru+vb63FeeN/giCBIcMZcp7rcS2QdPC92Gumpd+xKoJEXCJ+sCSRXjhgZ5+DPlMeBLMSiSYkasZNrxD894OttK7cOgPFsAXOmmnizPgPb6/PxDVptnuPJS5DYsFImh1OCcJwSIYYY9NbOd9OL8ZaqGF/odhhoVQDBKrI4XaaKIf2wr+PGQwYeLwFPKQhoo6Ief/1SkaqjO2LZG+f8KFTGRukd/Bm/cGbDcoFV0vFfAHaLvVXhxpT68lZ/GFTenM/DJWaqTSi1/qkXqzX8dBsPDDwP3N6zZ6kwrSAKkY2p5d61OPwdGW+mAtw7GeFfrSc+mb7e89wl9PyB+1740fKG/blqslDVpVKNxtv6UTyXcrb4jbV+xf0i/W33VFmrDzr9gfTVE9m71NeociKCAFTjL2y9//xffffcjXK/evLm9/owFdX47gg8V8NFdZvEjd07azXpAiR85E2Ja3TZV2UO9lWOAseKG2JLA+mBxxkx0KaToez/4HqTF97dLQu2j856G6kUNCU4yw5sOjCZq1srItK0iQbTMx6Mq2J31H4vCWDwkR3JRDu/nfukOS01Lt66u0+IJZerk+BtH0SO96uIxMXw0oZTgzGbzqjFsfXqgHT5Oqwz/lv7D8l3pUfGJh3N3GI7S0Fnck4z+Y/Sc0DeOiOq9CKpOgdHhLQ/rSj5ec0amPnGEDz37lv6uYLhf15GS3KL3vtrhNncAtrtGuwTV1WfQuLdDnXb6D6qGY3V6cr1jQ+ETH6vrjxafWPtbq0I5PJ63vf/7G+TJK9ZV7amaqWrR1+WA12M1xyDsMM/Re7ayVaqO4e9lfznp1j4nVzB4A0yDIFAbdM7kvsOA1T/1N/7m7c317ZvP3lzf+ApOgNgarL+6un7NRwPANN4BQGZxt75ZMUt/t/SN7HU6iytM15xxa2xI8Q4UvuI+AwhGtAkc1jo7Zi55uQ4oZr0SNC0uzj3w5TFQ1l/7i78W4IVSwFmwkUtnkMrbRavWDjcySR0vUF2GY4Vcrmx4lNljG1ZCeWwuASxFIrDaBpSpRtwMhsqML6DP5wFMM93LF5e4YZIhBXwKUUzCcY5Qbfn69frykpetOqYJrHTYUDaFkNZIIIjZZlusBmZtfkj3PZRqbRVx0MEDA073QrHmemwlKvLB1ryqyHFdnqtmGICDRKxAuRqlNBOxPMQNfeFUW3S6s/Zj8I3himU/BR3hpu/IpNu+shOYHv38yriE7GzFeJIVKdekA0NB9nwqjj1RYg9+VT9xIHbA3DLWwlVepJbYLx/1JAL2HZ2wOOEzrOOWTA3PxkIj6KZk6rQRQA9a2a/1YNxaMo2f5rXHyhgOzNKl1ou/+2/+3X/tX/vX1pwxnDavXlxf3Vyt/zEf0/hP/7P/9B/+f/4hTwjwmqDrN29+5KPaDmTYmrWqkRUbPEkc09IxwuKi3ARgREfecR3nC6cdr8ddn61er/lMxRWfPiAizy5cpkWf/OCjj7/4/BPdKj/pA/ZFTZTXg6k40pwZ02MC3tHVkdgltrWM3B3H+5GcqXOrXJUe9nS7pru8fc379C7fvnyvmfToTE/f0Tny7NPXaDsiUEeFo3hv7oCqP8+iMUoPr/4Y8YerOE7yGEN9feSvAUB1gVE+V7+WK4GxaPCkG1W0srlxySDx9Md+nNenD1uiQpPaHJZ4SGk/H18jyJ5yWGNfl9FVEtUUvf9j6ahwvM8wUsZ5jpFyaqL8Rw+my4fjNfR1mUr1dZmW9pQ5u30E5niqZ1Zpz9/rvyd94hj9Hm1zxWAytofb2lSOVMV2KybAI7YB+iQjo4CHzQOghBl/nrUF55+tP/8X/7l//Z//F/5FsBioZ+20P9DTGdurV1f/x//z/+mrr7/xnSfiFNHL3dlrAJ9oyuuH2prm0YDYDIdkGQtzNoaMBqEJ0PyH9dWbf/Vf/1f/zt/5N9Zv/Aosk5oMNPh2Ep9ZxQ2AD7xwIivucs/8N1sB2YBOs5sY6F8EihxR3pdS0XGfVCX0LWzDhWLIpZaUBKYyfPH7aERseXF5vjrn7MiLkxZ8fpWHks/4kgImAeuqsl74dvvt97whPm7rvyXZwQAZtQyKAoyrICHU83G7+dLucfEV0FNGxwGUOpQSNAcYMtmvWZExpgdsbaPrQLTBz0sqQedYBBoyeVyjAvA391KgFCe1QwMjFKzRyom6+yB1707ACZpndIEU+N7v4FLqkhl/HW7OVt8Wske/4xNl0fNDPEFzs5Xp6honFA/yDACokfGOD7w+lbX+xqFqbS3SCIJgKmrfY1etjzs/ImvbyoOHY3MaLf9Z3IUfpbTO6vvF+WtX6bvavkYgahj4VUcWT2jxCGPCSyL/0m/V67iKZXPPX9xdrj9C50dfQLy7+BBE/oc//uV//g/+Ac/TrPmM3M3ncN8tv44vti6q7f6OxKqN8I9TiZaijM0qWMfcoNN3/VI3KUbRz55d/s//Z//Tv/VP/zO8AZQzhQJKGWycn1++ePH86uqKLBrwO76qrbbcNSIZQxpLNYfStNTIG2r3u9+4SmJK3yh5itT0d+TxeGP8XcPB8S7xnLPG9L6t5+nT98ntKe/Fx9/0nogM2e3GOVYPfL1gn96jYkKatkWxFP14nDNRfB+BawJbrqhc2TbpJPvd4/tGrw2LO5HfKp1met/K2ynPW6DM1Xr3Pt5oWiRQA4DqAl1H8NLJJQaGvup9uhXtkEbdv+AEYTi1VvCPwbtXduQ8HKPSudeZvcTD2p6ktK/mUym8V8/hcB0uLeVHun1vw93r6ltiOM7/0f1KcPpu+uSMY9N+xEoDsEKm9Re3b/gWwJKHgln8wzqP5R0fVlUna14uL58xFiDtlL24JEs5BBlcU4QtXj8wuoWwBSzdJUVEDH81IBqijvsAACD/nr148eEHz16eXbPy53zFR53O+IAqNyaAMCKwOkVlVQm/ClAKh1ECC7qFSSiNAU1brGBZjH8VFxlHX+VUeeQgkyxFaij/m2by5ytGEWJGXpYK7r/0laCZ9obKOEVcJeQyPgI7p+HVoacFuQC7VRNLqiwONMcGk8WFEDgbSMyPCrzGL8GHjjZHZtbYEoYCVDbSJFI7IyUVe+Fva2+g2GQJCsUGX9tR5DHNkmAY02YRHrtJcuWDwLUkKWKeGrUMh9glW17JAWLGeVuPcR4ycY4EqiogpKs36RXC7hhLxI0afFpDnM77ptLQ+KpCiLpUmQjooG0ncfgvTXPYUzN+K0oPl2RLpVRtJGDBw/KBg0OsNKVlCppp6RwyvU5FIqEgfQCOm+srvldw+cy7RPm2HQnoZ7xgN5FQF9DfgKTy7dTVmiUW070dEclhLZvbOpkhB8S//rf+6b/xN/6pq9evDHP8VpqG9WEAylXkv1DV0jSrURuaYmuHygyUqm5Hm09uqZ1ne69L9tZhE6K37Pu0BR5s8AlVPdiHX4dgnQFz8Tzh/HgH4djbfWft8hag31vo6GGsHxeKMT0jmVHFFtNGz4zIAfKWogN820X9iKdPF9cBfw6fzA9zpqT2ytYcfD/fsF2P3VzVpe9VLd2PLPurdqdgOv4+3m6nZitZ/heJCvaObfHty0zbZR/XLO2Qre1oTFWUq+xrBqUYiM8hnWGqGN7LNrW4Q9mq+zEzATM8tiDe5Nd/x8Rp2Y2GsXImCvSQMMMf/4MZ+D6ACItF1VwPbgB09m5XZpwxp1ggPBDFnXOTt58rybyvaoTFYiYKRSkBHhYIdApFwQC7tBw0xAojrzwrISxvzLkGRjt17OQx1nXK7wSLYxRBdWmiiE8LQ1KbtoRAplAm0/gvpfBwhCb+1Ie2NVeivDmWCWBVya1nqQhAOdgsy9xjzSXamW6PpTNWw2MT+Fgexi1Bm0OXu+vP9MmV5Q3zwYtap231QAvgN8ZgVlPTrdUQYj16KkwEyEEvzQBtnpYQbuODU+Y65nT+MD0PJ1EM8tazlFbrCCvB64RbKdPAdhoo/sObOFoX/uJP0y+nd12uRbQuSUIPj+pGG7bO/2jrGziqdKN+bxRQ6mIkJsBjy96un/JUfW0P3/hprdmoa0JtE1n7BEqlroSBgAWGodmiULbIbXYJbYjSEl13buQsTQplMG2EKY3zkOHhL0MV26W6XypmSWKOX4PLtHD1akvu7i6+iVr6J2j/wrVzDoFoXX5tqbpdIm6gmVlGg17RCJEy2znaIduIUYoJnKug6B4qGH/evvzs9Q8f3/I8gM4WQ9xs9bQSo5tdyiHK3JY+tl04N5s4pdudiGnrvdtaTs9tXUtPF98r0f+u1e/CpiH3ChxHnI9nkz/1F3n6m16K+t+1vfEZ2r/Z7fU8pqZ7bWGjYli1a/P0zfITHfrfxz79ROrvUcNcD/35GLvH8Nxj7BHFeHlg2214fiRGgTGRa2GXO6DvKYt2fXtK3SfoouLlCfv3YdvbEEUsV09y8gEivf69zvQMx6TfTWDnXO27WZ/uIzMne0zt3grPySHrazb1aEddVd19cKe1F3u49sfLA8vaMxkqKpfiuvzzi0tQhqgEQCJsYTVygRGHCAEmyAygKvAFpaqLCbFdrjxBPHFQdCN6YT6dNf0sKOLtkFjIwCPsmBLGxFmwF5ICRChMuoPMwIPqEUknkV0lpSumQ1V1RNEwsDYJs1ZERZvCMJWyQZriVrVIjpqQZC7ZwYB6YEotUciYB5LxUjn/cFg7MCQk3kGRv+IVTweL8BlmC9seWXVZEQMgbHY+O/JyURZ2sV1kge9uqk/lWrm+KNtUV6gc30VXhmJ6F8OqlU9PNNiGE45yclM+zuCW/oBlw6uoYdzIVtVrbKQ2GcuzVKOioUONSmvyTirn0cMnmUiuDFZQMAoYgWRIk3C0ngcb/DEWV6JNz6BHefwjlUjJW27INxgnYW+3vvIhbcpNdqzb55pYKiIHiYSLtoDJE8M7FUHCz549O89j8um0xRZxe4CKmv44aMwMpe7qY4rNFi8J9DPo1BiZC56jOD/nltwVdeRpYZoJaTWqyK4oP1t3iMqBUKUl0NI7RQN1emw6NwUTwqbozyJV7fX+V7V6wBP62XrwE2p8/1SNdaxePmZ/Pk9P7G67Hu99C9B4NTpUrd3zfG5ceEjHfNmB+ft5oa2SA/6Mro+r67Ykh8x0pH7Yq8PanGMbNB9z3HN+diPLsQr3qxpWsO3tKdM6HlbYvGIyj63z57DUTunoyeGI7UjtZo+2vjO707dCn97VP813tT7cE6aij6LM1HTOh5vfW60D/X9wpq89UMLffA9uBR+EEaIHkVmmA/0isAuELi9fPOPDTAE6PIboBO7t4vxbsJjvcQHAq8ZFL04BIo06sSBk0IgAOQZcqkJCeBILZe6Md+Tf8rDkR3mlvYvm0QOjR30ET6mmbRTc/H7Jqpib3znHvPpKG7ihT+EP/AmRAudiSYucOKBHrbjlDHegloLwiCmDF4sYJ8F8mo2gauJQZrpJ478PIzMUYdWUHyWIRSts3TI4wVO25cU3Wo0ubaciMqO49Mer8g2+CI1MDpDQoVdGDH1x257AR2i/jt6MgFiLrr3Eyr2cItG0WLMTPYv1X6iLuA31U6fc5RoJPCPvn/JuxGCY7NeTPAcSK9ajnMXPQQFSNWMdFdbVEjRZ04onuq2X+RA9pshbK0QvK+9TG1oVSV5s6a0DheDgwdblmwjk6wElq33apKKpx9YB23efmFh8544/yutfeVLuq3rpYiVY1r+746GO8z9VUNCDUhqAWFJWoYlB/eWv6UwNU1WJOM0AgJOHbpHGcFRgDHTKYzRogU2CB080zaUK+EiV5eShd0qrr6Rp7m4+XKw/ePaC131+72op9Xml8mh7YDBDlRhT87Cpx786lA86VPnQD+6a7BZPk1cFbTO/Te8PzF3N5nVYMpWaUkYN+xweC01UDLZIlemu/HtKt0n3WulnkU/9/e1NjTP6s2733PPprYidUtP9Kmd+rRrz4/Xvt3oKtXwoiTlvp35ucz4g5ltx7vydo3csh5PNlz3n1JcK8hayzUbvHFxf/87CFBWJfXVeL9EbkUmq0zEp+0UTxgC8pVocCurE5NBMk4KhlfYUTEg7SqqCb7uaEy82hKeKwEbjwdRobkzATnonLL2OA0U92y8iXbWer9F2uTiI6ARUcLBQ/OAmIGIPhMhU8y0Y96NPPuIZw/PLS5f0+E6SwhcAk8DTwA4hbQFW96TFM4IuVWmMwYFQhgJnlfnnknrwEp8eO1teM6holuNCrkqxooRglkN884UqotLYiB7cdb2E5XqGaHCXFDjZSkCTsgmWw25FEcQb/ckGs7WPv3FTIeugAzl4pDgexXVXMvkmpRgrRpjZhH3YcgSUwuwpUWU5byIR0YQT7gZ+UBEnZFBYq8oP/CNXaMmlUK5ex1gSH3RLhez5H76mdeST2KxZ1Kk35gqqqdWhSSkzsJKOjOpHA4MWj/yJdB1xyTvUOHG2UChs6xI32i2mQMG4RHoV9qhtyq0GhflDQvnRE9WIS8uVwTGy1UnKmC2EIPeU7AjtWQ57LCND9gaT+xLsWNfDkgBbM+RmGPXpLakKGePKIAUa3wfAL7uFNTak/KdGMpUKo6h4OUKCQUoG0NXba9+YYTIsxoHlRTwkk7dL6WFqnEQ0DQHdxFX1bmXZVCNA2tCkP2TT/kPk3r7MnGcjPfF6+348tYU5t9/TZnjq6v+m74QIjGd6u8jUAEAFXjebohyn44nBTKdjIJ10rFFvifSj4V7JEfOXPfsD0+MYeq/81LfDXh3WViYeG7toGS9YTWdGqzveFs94adixO2rYkdobhz3EfjQ8HSvvEZA0dK9N8YGI4WE/Mu7TG/mZ1NRQMVY05krhqSgV2x7dXa0P94Q9sm+BNOfDHP0eF/ZU2ytC0JMQSVjDEazEXPvyzdX1q6tXvG6wTWqKsNOrFCHN46qsE/nMVme9O6Xip4ZgfJpXiCYcxqlEXTx0d3sNxlquvrk7fwO0eXZ++YqFQM6EwhhXGjvCWYykKMj7G6bVz1Zf89bShhVxUm81rs/aEkSGWHBtzVIdCxi66EpQVrAlwD2gLML4D5BafgNHwmAEncMlh6y1kyBM5zu1pHRPb1fny9vXH2CTWfnoJ2jYyCgIJ/znbLdR5WCidsgXPjXQ0oRzQ2AtEjbqdttHIXdaVn+lE3FM3bWpY0iHMsrqfFUBK6s/xD6V4rGBemtQs9iE40gpGLwqAzQB575eDXvoCLVgEqjBYvEP+6YlWdipDx+asFro0TH91vMqk80q0w4+Owskr6EdfDdw5j8WM/evkrDDffuxkn4NIFtcsR+sflCzlUpJdnaS9Sd364vF+fcUoC5bBGlB3kkbAcYAPvoS/3koPjcgamyCYhShVDkzTbfuwcHTv89f8E7Oz3iRvzeHWh+DyeaislG59Hwhff6VPYfBB53z9pq7M5xNdANralgIuC+wsgZ3t5fL87uLH589W13y2e4Vr5h9Y7WMZB7bMI6xkqqMO0huqGgpDpXp98X0dvbeH9i29bCr1lRqSrm3Bi0IAx9+7W658pe/u0X5nRqrcuAXbSoI5YG/v3t1PYhI3bci1v3GPUjffUIT/Sf9st+nfat8VvPEhy2xyhzDs0fsEGkrzh3jHL33v093oltd1XNq3FKyNfc/Fg2JPLezGQDkGpfLhdeWnXNikDlQsGH5LfWWIzDbOIPdsQGrg9S+Csf0yDMIvfXjSRbvreMBdw8YQu0YgTkN9zLMCb439Apeq8d9VW7lgpA6/UEvgRdVnQZmuCKI2MGxd9e84/LN8w+ff/HF5wB55jVBI06sOhYoIITKTOnnVx4SnqA7XC6Ew0Amwesd8CAadAO6sMeDBHwAgJdn3r7+6eUNr0+/vjp/9gxvWPVReqpqcnotQpNkUJn/tCC5UlDIMsMqcMy25CNivE3o5g0gjFeaao9nWJmdFXRaa1VK9EoqJqNWouosEGoW4SGLJXcVMUjmRV1RgBQ48xz05rDDyFh3yv338scfw491qtDKSkyVtemIf5pwDxvKY46DVdVh6WYoLSCeEEeqohFZNVq36Cx6VTZ7C5sbHHGyWSw/0CWh6ukxDjXfHIOV3fgWf0Su0dM8t0Y2RxNs6apUqNEJc6qjtQpjROw3tC6V/OCFL9WkvsJvRwIc/cwtT4vAT/2ZY4/niU7qynuC0N0eY41iO0OcY0GRPVXPWg8xhVLWGukAHyngixZWzdn99GxrziZSl8Ge7vPW8PBNA5W0cpu5IqZK06kaFn96+QMfPQD+Y4m32YLRISLLP9fVWWHSKOSDaGD9DHJIMablS7+8MhXTPB4tD09dG2T04D4AEp/R+Oqnnz548Zw4kMZvTde/8iz7RHXIb2WK2Gqhlb0b5GIZE3vZjiWWlRlbxyo5hW/O1FjvMXGK1qfhxXRFdc7Jw2ZKqvf/GD3H8By2+1vpzxoBGrBv8+ZL9SUzm9Q+N5WuAUDp8YKRLYf8Cu4TezxtWJW+o2mrKlwK2d7COGzH6BNmH7Wi/RQ/dpp1OovQ2nHmSl7i7Hf01J2ZqbZ7XDuxjXaMHlDOmuZxmxsljwwkxlHyWP2+9AnSP1efnLMLnWiKf7Y2XwJD04de7+de/WmLYSczvsM78CY6w3HzJVeEu/a+L8vO1l+KwC7/xOsv/52/9/du+DYY6B84xIx+sJoT6n4YC3gTGCQSFovkXS3NT9AXr0LnOwPAFOWYxwXiuL456ypYQ3P7e/R/+PErvmzEW8wFOsJo7AddCXjaxKauakegmL4OSNQKmXCj3MUcQV2iSWwJvs4vP//yi4vz57gRiOa8unjNSqOualIZDZ2d/XVLC9vJovoCV7liYorjx+71JRqaCwh9iT6dYDp3efb61Zv/93/x/2JA0nRoxLhu7ZsfFIwti36xfsZNZUCKYyzprdZ6Fb/wBJtRE+VksFB+qZNSowl/YLDoNQ/1qsfaWwRPDs09xEqheZthY1e9eCOdQKrbYpUO/tDIOB2e1joJsrt4rG9KZ6ONaPHk0OU/PgT3N/7GX3/2jC8Eq9n+oJdqlI3/KwhsGW81x6vOlD7XyMhcNlJDrRYzfjOiWJz98MPdmzefp78J8fmk2+vXV3/8E3dIWuyGqMBsB7ez6Qi1JZM4oCVetqpkzRL1pKP/M3/rn/33/lf/3g3f1FPId8UiFyncJoeri9vrL1R7zvMYpQc1tTiKbwcwyiV657wKlgCjk4/j8WVgPtV3cfn8g+fPn794Dg+vA1JGR1s844k7NdamckqLMCZicWBRh9vYA5NT5UDfqEvR3G68Jk8YbJf4mYacFL8NwljXk5XPXYGj6Jjfpt5i/zvbp3uew+lpVAt79J4cX9m+I9jE921T6/dJdOWTSPY+d3xPkHyM5kfVccb3U3X2/vfpGfX5+gpXiD/1p/ocb+g29t5nAA5KPUnh3t5JRzym/z3GgSMvW48x8Q5kH1mLivMjlbyDaj7YxN7eNWqr6o/ZX13iEedQ+kTgRaIiPtr8PIvX2MAAoHdBE2jj/MIlNGyAdBFYHlsUI4gE/YmPxhFnUuCEOlr87Qf0uz6C9RV8rUnt6gdy3P5eO6s/AhxXPgCKVAN88cfhTbzKkV0gcLCEGTYNeCnBEd3gA2b1fV4mVC1ZrC4vXjx/8UIr8aQholiJY3GfXeDOMO2ri4UEh1MnXmkwXSqALh6wCwUNAyuhwPjaxSQ8JlwjNKulA42ptJGJV1IVzjAgYFGVUsJuvQhl/ulYM6U08UI4huNN5s7hz6KpUUGUw4getMgvs8my0OxCw2xcizF8U38WmVQb0+bEGTWOERIxayUzukDyqaCs5A1glahWJJ8BSSpWHIqpP5wumhJDr54//4D3TuV1oizCOReey2i1ZdeeiVhn0GlXZB2WHcH6ZBe2KpIxXsTQoMla2hZCe2uJCjpOVtSkYpQaKrjSv+ld7a6UAdk0TPPIkGqyDiQ/+OD5Jx/9zYL+FrCpLO7JlTitv5S++pSM54cxC5jnjaELob+jSIcB3DFI8chDHPO5Xwy12KjITUr2lR32ca6VN9pIGngmx9I1IY+EGVtj+VaitcAQr62yd5MxvKds9wfoFG0HePc12AH2TdFJDbARS6pqV/ty4NT47Cj8Lfv2I7DdRNX8/Ql/uCfJv30H4BiPTx3HzOlsnSwjwpp13qrNZF75sN3DpeVDde45fx5Pr/V/b/s+wLQWD7A4VUL1T577T8iOifwY260mHqiz/k/6wCCx/3jMKHlLcjIbsVU6zcz5gx4qxg/zI7c5f+bs7qczO7sJ8/h+bkie7/s8HHl2Cl2LrFjgiOKLi6+SFvAJk/KdIxnEJpkNBXrdfGEgxtWHwU3wLG6+NCk9qEdP+IMG+xvUFgiKtn8SRCSC8mGBgEfBIjzaKnBZNRG9UVtAYqlrzNoDZKNZqfNL1uNcMFwBspHltUHr9au72+c+37nkfaMMSXiG0lNC7Xrlprk8scmiIazc3eabsuuPDOPSZTzYkmkDLwPYKF1/jPhi+YNKBq0qWPNlA8ZIvCMJauqSpRqlpqoPm7L8sWmDPV6XoqHIKX/ErTJHqTDWMEWJSBe1VJUTaNFSZqvVHFMJqEmn7avK7qNFKyqOq5rKv84upU5Yy+/muhw2halhTeJHFs0CWUvCYaNor40lQrf3VOiJemqGDIt9+OO1SnD6DTTHMJ94h2nFyn4rHhmHnQwU4phDylzHeHkodwwYBXwXf+wJg8US+pghK6W5jVJB4yHaa+vi8DG92cVo1AWf7TZqs15QrMfy7ovF+ou7s3+SKquTcVAFQs8raXVrfMRo9+567SutHAPAV5EYhHVO0l+iSITfb+G8vWMoglgWNnnKqAHnlWqqVHF7/aUmVn+q8wWuckmDxVb5Xv/+9I4TI5M39ea2Pbqn1+Tt34uNsm36nImOPne17FgOJ7G9x+O9MjNrFnpe/EfbMc8A9L+zfbq01T2Bw2sfplE9xm7v7eH0plX28U2t7+OaoU1+s05u9xnFR5H7PtOnJ8KPquNEWxFO1lnXwbkzUaVbXXiP/sMNqYL+DkC5+Q73/enXp9+SC5i4NyBvyfRTqf2l+19xeAcNMWfirXSzt6L0wV1mvzen9ZyGFuqESQb00WJa2cyy53wSkQWFBF7zo6oDDRRaEvCUIxqCXfClmGBs+CWISTjD/zqk/qIZgTh7di2dn+3UB+7Cm/5eqrWETLrl3UTyMBjI61yARcJU6sI6aV/iyI+A5cysRrhcRbKq2ow6Dz3ohj8QsTkD2ZrIHj1DdaxfnBAsymCW0Yw4tfg5bKR0FmMqgshmVTXV9smnBCtlMmy1i2REw6LJGAwvWkptKS42g25e9cOhjRpDIV0MKab24zgjImrkL2OJ0j8GTgHQsb0lcY4CzdT/hJlslZdj8UQvEyr4DBj5OOG9D15s790LxHzFvSW++TMKXaXPCEHwjRrSuK0mbzOxR6w6D/t4oCeVNLYMKxwoxj31p0/bBCzTkZ8Owq0u0tKMZrzMHhImITkk8CGR1FCO8CUx7Ep6oKOqXLSYP0elHBLkQYl50zJaA5Im3Elxr6imq6fEbKucBTJlt9mrA9LoBmzdprrDW3Ec5KMwVTms6Ocr3XH+eF93BJ+2Bq1dnkjp07r6vrfoEwXtz1SNfaW/A7AdBn8TuV7sjj/u+MrjNuOjcoyAjzwP94xvOsuzpcM47xinj+HpbO5PHhiLW9PBn/3CR1PrqlHsvcXpbPrDVhkecIQo9U02G/kDKraLev/Hkt4ExIfNE9xT92424mH6m7fdOXKUnrk+0PkzxuGURN8pTpGb8I4nQmsFIUowR4MVwUyFS0IufgAIOI23ptA/FIhQoVPyw/2EMibqKRgTrja9mknWSsegZUEstY915MuceykwoWpx84VzrXy92C3g0wI2oKATw8I9Lmk3ax8d9cFfoRcPNFAXUVTxqqj0ahq9Pk95x/0B+a3V8gcLmvdiMvkDJqMgdn3PTFyCzs0NmG8v2C1XF3kKmSGIzjTnU4OyXvtUTr2qkCRH7ULEvI7EzQKFRC1CXKsbMozvcSjy9s8xItV2kVC7ktZNZJlcOjMlyZcL2gpP4tYKbL8IoVD2OGRAcK5pR1XEUCyPkYg19/6yVFCbPmnpM8HycpOnzWwumBmEibTPvkN3XqhPuwCaeQNsbvU4sOLhgXM+WZ1r7M3ynLs0jtyC4NGlmwQhJmD5Tld5MT/3ZSjDzVteIcXiIsTjnnViSp9P4FG2vLv5HO67pc/SZATJu3m+vjVrGw/3LCJoNVL/JGqXvmOLG57Epw6WboQQsyGUNlBk3NwnFiSqPHda0gmqg5TOCmbdYRusRPvAHm3drhoqqjvq/mS5sreswwl9VfbySpz7vZijzyo68WpZV2Z+axLgWa0PLjjZ/8FSH1vTJ9ZrUPP0x96xY7RXhIvz+GgczzmHnY76zS23+tj26WOqN+E5we5Etgj3aMileEa0J9NQM6fe4b6u/n13AHL16Q3spA9r3WG+J1uOz7h/j+xJxcc7Xf3+1N5/rzPvoI73+vD+MFQ09gb5qQL1VHren6D9fJ6MDdUSASeBU2NJ4Ak58TSODvRkRKw0h6VVhxwGlg2zclAb38A+8o2JMRBSAiu9loGqyQfXhEFMygKac5b6BCnyxVTmikPjdSsOCNrHwgLHR6+BdOgBa7pXERLBr3ovhkxdhqpoLrUJEJTPbEIj2kOrOy+pPh7tl8JgyfS0qmWteEWSXNUxBikNrLbIRPyIP2GLRNhLVtcGaXiLsTlnDnXxzAgo0bKViQBCMVVVjkzpV9gaYEApZ9rRYpmKtEppWGCgIKqjayhwWU/IFHkkCtY7kWkYtISiseliihsjtWgKGzwJ65R3miZNFh9oeSfxteobl3RIzK6FhFkFpY99TJcJTbe1NFURbyxU3PAk7mXu3wq5vsdewZ0N6u5SH6SxLp/C2IijJM0VSXL9Fc2cZYZKOr5ka3kLKpaN3IrVEtG4rZ3kS5u5ga/Etvap+RZlzChYykbSXCKm5gp36Kfw7oj+ln2KCNAbfmuDpwjkL0jH5gpwqPX3l50Pc6vObQzXklwY+AWc2fZ3sNnRzNx854z2JyZnnLff48FSP088nUGfUga5Bx2PGHe2SH4d/YP/O803V6PpbPp0leGpfvcRqPQxo/bZ/tCZr5471mWnjh3j7LxRz7MnneiVFUpHQ1POY2o0lZpSjtJzRB+Yar6PUrUc63of+3HlY8S29Y7kumSIykiJEQdMIbqB2EAdpSPyieFOwYCDRHtBQCCh4DkO0TZoio5OI4puvuTpg7Ozn/Lmxq/5+m2MqqAciddrXvvDOvLBR3A/8WdQABx3LUlBVt2PZyzWxmr5XXiRxxqiFinwaBajMLHc6jNWWkRb0C/1JgfARc+5di1izvgC3Oxnk500DanV0IUoGFe+QOD6cyDngtlcblysP9UuX+plr91ESQ/jww2cTHzzbAZmAk59lzzfH/iTaNdruPzWKGnrWKMbUDOL0X2XpbdHqJfAdv0ZVu5WPPuBVOprVGJX/mi7+RQpzkdDVxQcd3JO+Mx9GPhZg+7eKqE5VtQTyE104KvmwavEySGFIzNqFD0u2cLLrLnXqw8Xt5/cLX+C1xsyAndVMJpSzfojRwirb89ueTSW7wnQoDw9XnZhAtajlqMCaWQU5HbQ+PuWEkspjn7X1uONYwhohJr65feRKlQ/QoSIts3OlIFlKNY61kgMae1LHbb0xXjVKGHAUPpdjuWvxSUnh1bJh+BuVJPoDtLFaH+AV/7ekMS2FceQe/Cxwwkx+WBFM4LH/I70onP8h6/Mc1JovrdWB2R7xw6nac97DR3WUKUHlPQ4p1dVdM/c455h6GX79OEI95wPTM/8bvZ2n6QtjnTv8XZ7DccY3Ve7avC6SOzvQnWiz3QM7gCU7NgBKzvDHi9H1mN8fi94fnaPK6gPjkWJ7yihiX72ej24Rr1gX68+3fM8SfqtKn8SDx+hZOtCMNVzsO73ye4Tru6XEgFZbUEi3SWFfOumgTZTtwrFCAqzmdgAk3JrW2hwFfBTtiHwRtHrAN0BElEWmBgOOIVULLxZnfsWIGGbT6yu1qJM/OOfWsfdoLfRxdySihdNVS5/EGDmn6OAfNSnznJRFShga7erq9e8Bujjjz8CMgWTIiPILkDrQZXW/279ofvzlwLoNW8rYjDwAgeE4EJbF8+g3OCe8yk2OPkM1kBfP1fnOXsrJLAGEBdsZgmUL80XXmfoET1qiw/w3+TB2YufnEPHFd64s9RD62z8AtN5uPZ2tbj4kPrFCXiCsRXg42gvrPLqRQYqGyuEOxl0UqLn6ST4bFr9+CWUZLwEAZ3UCq/MvHjxyXJ1uTi/Qhi2UoU8G7asuO/LX+GVUeGmDnLSw1DHhDhV0rK05YV7TaskDqTOEMnrVUYbDC+Nj1SbpvSSVUAyXsqup6kQjMVbVkyHrrFs2oeSfVGKPKaLs99vFW0Lxodm2JK4oUmSlJW7o/wmMbqzIU1TMG1bm7LsUIr9KOU7ku84e1K9YH4HVXoHJvYG+aRQ7NXwG/FnjcBW99zK3OuWZ/h51ubm2tb4j+uJ/A6xeckettnRzMy4bZB7u8dxzHQgNP0c+XQGfUo51eNTz7HZSM4Y7mfoe5Y5es9zTLqPQKWPqdGptTjGkyfm6e5Njf3kASZ62T79AFV7RY7TuWmT8b3+o7Yqm9JHhv2/9WIekQSXBGRJ9+8LUmeuFd0Fg2RMIRgpwLYmiqMlw7AxXGU7P7EiuYjtMDexlAph8Qf3zp4xB+6EsfTSJ34rV4CEfKoM+Mml6uaax3BBkLfffnd78fJlnAP2IYU4EiRxu3zWFEkdqOvDnW8BAiOnXGBaDOK/obYKOynOAW3wi57x0Alppttvv1iuPvmbf/OfxSXAGTzICtNuv1DD8jtyYGdpFOLV3ZdVrhd3v6/6SPeeACD5hyBzQd7i7q91dcc8vH+tmkIzptBcjlqGjjhtzd2KpqdavjuLNpC6dG4RFAImPMy4E0efZ9AfLv7U1XTqmFnzhAWDvIvGUFLGP+ynNbx5Ag0Yr7fFihbej2N6GC1kbT/h4Etc7M95rmNx9+PLf8TTGui8vf5EH1bfOWSJ+cXZtxp41SqYyfvUz0ihwWowZkgArDgexx1rGgacWTuIWS9evXp5c+2nLa6ursD0vLMVBpeQqYSKwA8zTRn/cQM6jlOnjDlSIQ30mzZidSAOmSjbLtLdKBx4Bpm5o6HNNgjEm5FWLxUd38fV6DuH/I4bye2N8x2l3kfaph/MDW4cZDq18NTfkcP8c9U5LHXY59XXm/Kn+s3daNxOzc3ib3Ptz83O8ecdR/2v/Cg/F66RYS5x3G/WnHRH736jO+pW8slsbWk9lJmzyAmwP2JH1GJqb2rl3l665wzkFu+X6q7rwJZ7ZsY7AKRHaQrGtLK/bY+KwGy3eJTW1tW2WvRxCo+Xfks1Ot6B3zifOgIHmzRXg+x2zUoskGfJVmfsMl2yFECIOqBfcFhR9+/LLvumJdDSHRSpPPfplLYEsmA1ZpiFUhQ5Gyz4FuX4IAB4duUrZYB5d2tBni9wUQf7iAdO6wZUYB5F6PS5UpKZ6V++iRUQZdAtKlKGJ6BM15aY1TYCijiZjSYcADC6HOX2De+CpFQ5RWAFaBZFp1HETqTMwTqRMJvRSZAnJIiWFRBVOOOJ0JUqWXW36Ko+bBrkv1VzX1uviAKhdJyLOPy8hTOMjnooIzs4bO3VpUlfxJNgEoSsrAIgY05cH4O2i4MEZ/axaII98aF6pLDKgMKxQerKnva649WZ1yS5iXFzw5iAZ3R9MT9fzLrO7Qn9Gv70GZ1i8nJXp8q1GNJJnU1VisOkZX7KmlU+AHra8+WPL1+9esWaMer67PkzKKzw0Qfyeqnn6rXv6WxUaKupVulmM2RhbKQyX5k+3ShTUhVEf1OxeyjXdKBVfJdhJz9nY4etZU/j3q/jz4h6bCNsh6S6Y4X6UFNvSz1h7mcx+oT+/6aqInBvO459bIjY9jMAjTr8Nhw4+fu5/5KajlcGGz/nsR8z3RsdHD1+BF9jcSb5xnN+LlzYffh239gRo9Rxr+k2Wx8N/V2OhzvzK5Ps7k31/aTV8r7Ij8HoZfv0yLCbOFpzCc7p7M64rS62M08/9o2evuvSXuwwwCWYXY++I4PeIKtGTta0aFsgPmxbcmRkDFoSdQ2gZXBy1DJIh6GVliZZRs9Ee7e8vGV55ntaeAvQt1y8BF2jIsGxyjAJ+he6OTDIQwF6Ac6TWewe9Ul7AXReWzF26CfBx5hIX4TfPEQIQMKShXTLi2iq+iDdM4A+AwA+N2xthZiLr1VOulbh8zzAGiMMUr6BE7zLZDPLbJiKdsk7elbfIsTcNDrFxq4zRw1ufQNOZo1MhYiBjRPcqHe5Dps3Q+7WH0tZfZd6Q6SOQGMxOqzWgzRWSJ9/n6dskYVKq6UG1o+peAG8S+jlVy74HETuGMC5duPCIqWPOfBeHSShhI4Uc+ofWc57mVjTf3vmwnyWCHG9FD37NAQ2GBKYhpBaotmX+txdZOb+HC3W15idn0OjShffIY82bhDAV+HEB4vsFmmSm88i4bysatkSd28l6JAOWJ2IO9rh4QE4bz6Bfn7x7WrlYxtSvQchMxuJEsSiIzQLeLZBO2W2pcIlc8xGRNJmi56xdEPfTQ0qqpWbNomD4s5Ihja61LZBts35RaLxyDEUF/fmPG3SdZheKw7ePxxlN8q7q9NY+utM9L+tc9fqAzUf2614xgbeK9Lb2stwgLh3jh/+aqm50gMKDxQ9IA77tXW/0fsZgn/GoiezO2rcl5haKcpOU25Ej6jFhnlITa0MJbPHvZ1n5zqw7eR4B2Bz5u5eInat9Zy7Ze97viq/N0y96ydVsXT24r/69HtR5Wqkk5rq19cwAp9D3flQ2VY0YLynVeXYq65EZ6W3NJeCtq/DlhuzWuQaNTVAFgqAjInbzB2DpgNv1BtESA54mYlnlokL3PwWrytCZEjsxIFslZHcZDEBtBeiQiiaOBBEibFgx2TlB52TFjsLD2GBFsClrKg4uDTOi6GdE2cyGydElggImuGkoD4RhYBGS+wmE+E6nIdbQd6OQzKzjhhUl68kahomoSxwW3jNACTg1WKx9NlNap4gUREeg07F725Z10QyRlJV4C1q8jw0GhJcoXD0EKnGjx6USkQaH/J09VhXiyIA8geGA7KVJ/aS0XlHzQymdxj40u1qRWTgs4EcElgPxa2Q0VA6/7CZVio9+Gxg4YFKFVIRy1VuCBuDrdn0peWj3JsWtelp3E1DoEitfumONWN4GyZ90gaMBJ0v1JFrBQ4CQ2+EJjEcGt8RBw2Uzh3mUKuolWxl0lMHka2S3oftgoH98HH06DDbUPoQE4Psn+Oxwjv0pKGHDr3gkRE5pu3mGuwY2Ue695v4E0Zg7Ej7G7RrThjIZSPpMwBDulHv631a6PQNUrPjlRPnOwd93bHX0Kc7lpOSo/fT+f6qRcXIih7YJqO6Iaz9NVf5R82FTKzseDQa3aGP2cfMGZSSnXWHo8W+Xn26mX6KlhprsUf/Pc0zij40cV/kH6oXFPpw0UhW/+WLHKVnbJA9ag+VDezHze3J3YdczeC1L6WvvnLftsC1IVPHXg5Kc6qGEyOOGkUGf8ImiothQWkkS1qVQFKAlyAPVHz+DZg6AFA3CXGm5rW2XDlDLLzkHS4AUMEws74CO/4EbsGEgFEyIEXAoQt3siod5twlEAc3T+KGXAw3sCH2ct0RknjC0qLxKdQgSlC069nBp9Fu5Z3kzqS1WH15w1gAbVQgXjO5fpO33a+XvJk+dUdF6Xdy3o8T47voVqCf1/gwTY5UNBgcfT7/gYSYv25KOF0N+Ac8I+dredjne7qJrehdDdxFAYsvzn/imsXjYS769xkAVkCdy69F5RMHlFNK8PHtG0wt7njJamC1L+HhOf3KQDYAAQAASURBVIEbfGBYdOfa/bQGLUCJ8aQW/GN5P/yk4AFPYxEHbUgbCCDOGISoVGxtPv5sMptYD6g71t3rVeJvCxhf/IFKzL2FQSmV5EvC8FDKzR8jFHK+AXDL2AM57pZQ6n0N2WVxBGLItKlBe4T/apjJCIZCOeG9+dIh3epPdqd+xa2FWvJYG7lD21axGewe2qK8nS+cg3uZG3FL9SGdQ1kJjGLTewIDY3/EWJMYrk59qek9V/Jdlq38HP8cfUv4iTJVq53fwcfrtmW8DrVfBBNsw+9mGS3akfvRw6ZqXmxUToK5f/a9yDS2U8q87mNLSmdxz/WWY3Ud4BvieYDlZy460cO9bcFZN/xuTmqTpvVK4tWx38iNdwCgj+d6/Sz2nH0aKThr39N/UentQOzEpWVHnjEwfRUrBj3lt/TPEIG9bfMz+PEOTI798VhbRwsczdhZ3tP/j1VzfJttNJqamIQoYFu7cgSULyKTTzxX6IwrmW9wl+Dcc0oBoGzhcwiRBJpNRVDvMqGMPvFmyMBnCvVBnjDX9TTIUwxLVm6pSNdgIj4HxUPmXZHsGR5oBn6vyK50D8JEqceQUgIiF7miExALK2XAZz1CCcA7IFoBjUFwnh4D4QA6i15jxDLUaCmgmUVQAltJvgY0QbUYVerSNozaQZUqrBm4d4DaZHSg9rC0d4mSykdzgSDqZpSiM+5dwwM7SlVl6Axh/Gy6dVYTDoQoIyF0t1mx2orKqFIllDz69CBNrEM67ZZmMB/eklBzSHoFvVoKERc5pQRj0eYII4K0ALFKRayCgXTwsGlAGxne/LOO2h1Cqi3TbsORZFnqCGHYs7uPhfLS1cveJ9Tz3ptG/Yn6pg7da+QXw/CO6/YYc70s6b2NeDzxF9NCf96O2ug0qhej+c3LZ8+AAAOAaV/woub8lr3HC/CwmR/Sxx+Z/tm7HT/u6TX06ana43VGtsadh0I2zFj0K+QO80+dqhH2lN6P5Pr0lPNtUMbZgnuVO4G3b+tH7X268c5IjTMc+1Ru0fqY7NG/xWum56/CKWUi9F4QBEk751rvl5Cmz5Pe7oPHn5jFuc1//qfSnmsDyZ5nm3PHCXjb/cPOIySO3Bokk3urenvnGvVro7r4dZhX3q8uy2WRJeBedQTM6fngR8CcGzcAmAMPUg8AVB3/oqmZF18G8NUeRWJuoCN/oETgHojWi6hXRRAqcBmszZp9wToyoZDUtFhaqOirNLFOaWFFeZwCt0kdDLgJu9VgN+BDxWltA8/f4GQ9iMxEOZu1RQvYGh36U+vpBaM6C0PimdnvSiqSmnhl19FAf03jGM6kvkjzzEDELfAmACXULqUwUpT7HXoWG0j4CxIR6qUqIgatDYigkHban3+SNV9Jq2Chdc8zBSTly9AF/dxA0ArXEPb+BsEVcypQNo2pAhWO2ghZGgxn5Kcs67OMJDplQ6cZdLgzhgjQWhBrYywJMRsuoSTLpuRE3mva7fXveQo5PaFxLS+/xYW4158Rqomh4Sh7CIMBCXzLAuLePm/x3FYupjX5RoFaS/Mc/4PoZeSw4tl5xxmLs1fymd/uOf45ejM7o23LqY7nmF+Kud/BLZ0HM+NvbgVW3umv5JRyUGdfiIcbzX3BTHqOeRrbKeX43/EZ4w/9ts+cujn68fGs/lB6jpeas3s8/URbk7awGTlJiz7Xpnt7hh8/3xSMJzo6xvRONWbV7/D9lt2KAOF8q5Er5XONtuXKb5lfRATaORi8U+3aKPu839fwh/rbPn71Fr0v7dP7LI80AJ68h6yOvGPioHYKO23qTzAGYcvAZGy3t3m4lzXtYLs1E9HgUBH7+pYX/yPmTQK4g8kjraLMl48GBHogRg3ICeozsTEZR4NVgxUpKBAvrEWAh1LVn5EAFgCLYHmAda7s7pQXspriHyTxriBVmwpTlA1vg3dlC38JwQALaRE+7N5igL88Zs+mmGVsGpGnod6yVTYswGqxDQePGIg/KLO4FMlW2LbsJZApM6byaYrlMMZY58ItVGa4ZBxkyGaRzkeiyZaX5bO6CCEZ6qGDhCG0StsYelj+qKUeYLDSYVXWtJ5Xq5h18NB8QYNthwYjbHU8xN8M12RmsRZfi8j3IhhZGWpa1prpj/UVIiQSNJP10Rp6qwoa18Fuq+wOsSs3ebh0h3k729Tfr+F+jm3FLfcgMSOyV9svnVj9a1q3h1UYPaXw/QnL++bP+xOZ99+T6oRjC1Z2y+2hww1HC/lQZXh6GgSybLm2JjXsil5GKj2U3H/sRtuN+cRxz9TEnlH7o3VOrdS4avq0wJRzjlLj/ulYvx/J9ek5PU9FH+chRoXHUEbmTWfp27RPj6x7E0e30akxmfJPKb1He/pPX/zo9Kz+PlaAP064PefacAqPJ93WGWcjbObeinfYl12/XTro0Abpsrtjq+jswUbyBz8J1GbXFGqXK8dXanX+krmHmoM0+VSb+Krf9KvPt4w+33zBuyIvLi8+uPjonFEAy7mp6d3Ns+fPf/zpx59++HHJ978UFk+KVxd+k4tPA5dCASap6Etpy5sOVUnTtclXlMGhsAnLSTCzngY1Q7QhiqrLerPirH8piRoYMozxtsBwyS3orrScabVmX72Lmy9Ve/4tpVlxzkMB3zTvrGT8kaOMo0IgW7cjUhV0RjcHtDn8oEvo1d36C4PCV3UHClrSOctnNWXOCPSrmexAv6Jqh13AZe2TF16frb/Qw/Pvoy0shogtI4czv6mrsDb0ZBgIYavrojiLUUuJw0hPLaOnrfO3lmlQOfmnH2rnjUDI8x3lBNMdWhyv1N0Jsfvi1j68WH2D3N3151Rkce41ar32ha2pHKOIrPbxGk7Dfr0454mC/1YeetY1B36oJjVuSfeEoSQeDBmP++b+9wn2MnvT0ey5P5ybA9eDtEW4nD0sP/H/MPvg1PR49O/CVHRKqXfeH77+97/I93B2BojJWMMxvTdQPWYYf2GLE31jotO9Sfa/HaO5TfG+1JzCkT6nZ2TYp3We9qTtNW/miUpyFe1bfFbve1Ovvg/MejsU0LheydmGiyTNuuaXuq4wFpve3iA5AMgFM0eLizWdJTtpbetVkN4tHth+O/6qI9D3gl91Rd9J5faeRC3EM5H21NsuKiXdXhZO7F55n+5rNko1ldv5bTu93FYaoeEqskV/eKYw98a8NRKObTQmyfpvvtz0/Pmz/+3/7n/z8Qef8DHYNWBszbOkvM5x+R/8B3//H/2j/9IveGW2l+c0TYqHh0X61lYM575qXhY0H+Bulr8q42i6yyvJ5rOztRCImJcinmrtNnFxywpwGzwttZZRyIUbEJl1Rmk4aW1wIJjXIfJsri6CnXLAK6qkjeA3gDWjDjkLajfuyJDWkfgIZFdJKJhWj+naj/QxW6JGUg3y6acVXvtAsLKppiotvWGSHsbr4ilqi43l/NAiogYyCQ/faWYExWPH+Q2LuSjMnQQGDPC32KtM8bJPEhFU60u0QrCz0Cx8QZmxw2tDZ8qY1E0GOWvz2wLcBHgj4YaXnBJ0FiDl4Yroy6DO1tG3uIwp1OmPrtO5WOjVPBuUekzhaKYr0ZVUvaM9IhmfWn0q/QhlO6L73N9h2ck+ceV2tL8P2apheTJNH47YWEqilz1QL9hGqQNs9yo80twBE78V/YIjsKd/QKo7AFWtsZdVIksht+YmQ2/zju0NJEcH5MRx1TGjn1pbj1M7PfsY2aP9boz3zhCUGxW5HeWnrsxr4sePWQd7x14pJm1RaxUGNR6nlLF0E/BeT58O69tohdGHJ0nc26aPtDKrv49Vn2720p03Uc7cZ7VIdS/3/jn3Vl2/MbfzoNkNUVTUyIIk+YtZBcPW+1DMken19FLNbvR4H2DUP+ge9D76WN6iJlCvM6RJAStuMYX99fnl+nfP/gXzyz+tWLSRtfJM9K5dgZ/3/QQdgv5Y4VFyLTrlu8FAGhjq6nwrH4Qptk4dyLUV9fJpWsiYlCiQjPP649x+K9C36FFd/uDjjUUb1zXTFqagL2lWMMU198zLo56BRNbUIxo91JGSUn179lfCU1956SS0bjm6IA0gzkgj64t00dbXIwEupTxlW/PZZ/m2sVYYH/0xQ4nyP4tnkJE/r9DxgVxyN1ho1apa6RZqw28BfqZH8VYc1CEEgwHQvi88iqN+36D8tLQ0X8uvABZ1GaRej0nEHHWsYGtA3B05o8KfMJx/xgG6brJn4yutkKyCMF2K5cZHTixQfPENvERa9bxLSo0Q8IRjIuYD4IiR02pzu4zoU1mKxSEjc4QrsbtX81NsQ1SbC6hs52P5oZmHmyodidAhXzf3ITdcB40SScr7a85G8MlSe669p/6enso/+D5GrH9ucPp7Wm03CO0ed/wfmQ9Gtil527+8pb+M7fi5W40H5d+K/8f0t+J5aLs/qK4KzdX31Ni2S23nx+bu3NiButJcNfoBQM/UdTTILbdJDWqmlKHk3RzLMfa97+/G9I6VcuDnjseOU79lf7ERmHbo7pS0u/ddf2SuM2E4HzYSm1QCMpcd9VTYBj0bW3PhLE4A1I6GOf7j6aUw+jvdyYvy2MBqNzfrly+/Jb+6fAXEW/lSIHE//1jswRU9flGOiuF/Zm7ZSR2WtMhXOgXCsjaAl7sGndMBqDHuQ6aC6uZJBUCdCssWUKsaFQp+haFBwsLoyGmJZxLUEsXRhrxT9lnZnvSoWrm6ARCdJtED/o5JBxQ+4wuS1jhIS3ay6suGW943GLIjXFaP4SgnLPZ+xFqHYUYkFqIMStXRSg3p8lVLocZi6oMmPXAfDJ6k44VoDl920PEebv8SmsHp5mwO3g5JxMk1tdLLeeUMvhvEbAQChapSP/QUZQxgEfw1QoAjda/mpFU1MMSjEqlDkitkfLybOwb2t2ZutFmJFuShFs2fuB1vRsKYmLCOJTOJjUB8MyK1bQoGyonHVoUTpSrQ9wiNTt7D94ssfnTgD9WayJX+MQH3rzqch6LxW9kYgb4/jMQjEvWRSxkHDeN1ZBwzjT0u+jajCrKP6ewHR1qnjn7KlzoTetnp6GpKSbWGFdJjrRt16zDESGLFqbT1Y/1eoOfv6S2dCMyuVjzoSa0Mns6j9Bb7NYh7rD+CVHU/rKBvhcOc09JpG00pcxHote2R6otn0sdIHcMzo/4AWWQzPaecPaqIt/2EBzobsp4AKEl2exfUtO+ErR6zIyIeC6lp3nagNJdI9gLHWN62eV8us6oNE3a8bU7xq8EBjl2yYxySi8tnlxcX13xD6m7Nl3p5ENj05eXF+bmveIdNwC1SB6j58KhIXKhLII1Lksae6Wk5xdP+UxTEeP2FGgqiDm9cCY4HA6pZHo7osVfwDn5mnbUR0/X6Ud81uWBFJvys19dksO/N70yef4MwOFIdZScM0Wy+uZtqwO5/7w0olKReOrOdnJmSUIlbskmVkzpBNKAXkTu9SIq51WPVq0Cc23QEc1MaKRcOyZktDKa14iy6NhlJhCEHC2KBPcqHeynyDWwpVlPxlqw3P6DVtH0wOnXMXQut2UZ66pY41yfGEGFgUbHBFv/jiwmpuoWYYyWMUcRzCPFJt7EXi/LqXITkZPMDxRCsOn8Oy3RXNhkZI4UhIu2tPl+lLMVDanPsvxWwPYNeKuHEixO3Em3el2ynZHquTSklNEPf9nPj2xYekNz8aPdMql9t2Gt01+ffVfrw72nnxTHX9gM8Yzt0KueTB1FQLzZaHLsIia3WHrhP/eVtmr+O/BFROlX/4Nexxz36j47SsTYO8B0RgSbde9WnZ5SPLbhTvqe+Oxyz2bEv3He9qI6yp7vwhZcd7RuddU1Mcd/XKl1SfXpHz9vM7vr8kOvlA/0bw9NXvU/3evcEvC9+O+k5Z57Q2hiEJ9T5m6pDEaiIj3Hv23g8GcZEYZrh16HI0vZuRW9MA0evH1rPM7C0Y2AaDCCit7iNzo9WoJjOX+DYHc8BX+IHL/85P+eyJmi7WF1EktVAgkIRvigWRFe/nSYDAQv0qK69NhKGMFW1tCKB4UHROVSyYKLlIktlRJmRbRGvbNxw5+s7FY7FUGXPv9BVorL4icfBt1L4C8Yvj+CVqdUE1CsMjsfWT4ir7vwZHbXg/GCPUYpgOgWmC0Nbg+iI+9GjGbbUzaM2zdacesjyoShDCN1GmfvRVukMrYTrnoZwvCmzavDTOjpqYNJU2jEW2fhmmF8ITlnsWSPdztId6KVE8/A0vsZYrkQ6zqB2xeeHFdJGDUtKyhqlQtDdcIbmYo+gcWRJGcnz84vbi4vLOKPBFoJmmIOKh61LDqTtY/nRaHDr/EO2XdF7DR9lZMu7+yWexuj9dt5vjmqKuVg8tIH31PkJVe3R/mdMqhb8BQWgztP9/aE64v7ueJ53fXBNc01/iXeMvb4+vS8wc+ObfbyhHT/S2lbR+bddsC83HV1NKU3udH8ICdoO+HNPzGJx1p991dnQjvB27r7ERsnPkTqmn0xjMqVM735Ma7NHaso0ocxKdaP8WZ6JtmMJ9JUDPanX0qBLIcXurFUDSAwt6XfV+Zy8LUKwaq9nJ6146Swlg+Ydtp1ss7JDnX2D0Bbf7uxg82DzXMEYkLJCVg+TKUrUhQuQtl776no3p4GZ8l2dX/B52nMn4SUoW6BSNMx7OYBuyjK5G3CcSAnoUCKkVocyeeahJMt04LtJGILRAZHAQ14/9FcSI6TiwG7zeT74bvmHtA+9CFkdcjX/0GLyO0ApIN0APKVVW8v0B4YCpJz+fum2jLTl/tgT1QOtbwG4OqLT8EQtM7Ie2aOcaEnPgwFyZql9tFFx7q1x00lobZoJbuTyLiC/CgzkjqSwVwF2FYWEN0nLA5wNXqKhC4mDFEutVyKtCiqW6JJkMt0stWOi3Tr6gDEWF9dntxe2ovKwWMdoiKQKbIK8elWTcpGLNYMqrUzUiGrQE2WyEYqC/sakDHBQEUV8Hnix/kIVq6/zsMB6fQ1tXe8MpeWVbRu/pF+TTCUH2vTYfzm73qY18MRiZdDJf13d2nZm4jeWSnSjYFOi/ETPHkrZmXKGPpnphzpWu2xtbFs2o6eMzO2nvw5TSsnO0ec0H08/5tp+mGcrEIcNH/E7XgoOWzxspErnIvZ4zfdY7343j7lvv0fbdpTodlsRjv7ZlRR71O0n7ardz9VRe6/6dMfSJ58qzl077nF5D6nOzt6VpHMlqWcAtsI5YQyhKdlwjlrHxH7BXxm1jy9ptqr/ThR2su84CD+v9Xdc2V+JuepMY2X6fjYS5xKjLA3v1gs30ubHulim+1LiflQ3JAcdU6EnpfRub5uORwe8ABVGmB3g0KUdEngn6O31DY+WMunsSn0RmytLfNe7jrNYyNfOZLGJwDNWPJ9jqXYBhGV+tI+2pMWMMBcURZ+AUcAdRQJV2PQoUBJ/ALUSwygEd+BBYXxXPKweslEcZRuC5QHjkHInQesoCT2OumDGOXGRNOLSlCESrl1RHQl+q5x/9+HyhtI0iUqeoQBYkwr0l5YlNze8yxNt3FsxUnjrHnzu6nmY4nVhZZIF7WUzY6m8/iPjuEZbMqld1G6FVJGNTHHIgCH31oNBGlWIzogyYHOryBpRfSpRKqvdMCtgJZI1DvLJkPEa9WQwgwOlqnyEW+kbPiKxWt1cX7948eLTFx/erT9jdLW4OFstXTT78uXLLz7/kjCqW0t8QIC0imLafTYoQ7JRhsM8eV5mkL3/+BQ67rey4ajazNRpw/bnleobodLsf9seHIGxe72lMPbt9WAnfw5BAnNESPZX7/ysrWo9wvE9GmyT1i4PHN/0o8MjfBg7wV7eKq2171v+zFmZo+/Vvk0cPRkTVb4nStuCm9wjrG+U7Evh0glu7NPw9mhb7fIgM90I+EHy9wkdpf+ttd0e78bm3DRqUtXz+v4nDioFm7JWDkox1Yr3WOlJTZrDwN8le8a59L75wjneosfQjhVoRdkUDv50yjL3szj/Ru7lot0HAMOuv/jv/Lf/hz/89N31FVO2V9c3zF7zglAw8poPhH3/3fcBbaLYQGUxNeJUWCQnLBVHChYp1pqQmXhQZoF/YMdhmpl0W6ET3uY2OkCvTEwDdNVrvul0xqgAtLgxVA+b+V1J2WL35vfovWvnThzBhG74nV19KR8lsSELDdsOMFJUdGhUskjWq6rB3srrjuOH+Gm9Uo42+F8qpYnsVRByTOtAC0v0WMQwQ3WkUuXKwgYFVs4ddaUaNRJrwYnesJQB/YGRPfn4rU/RbIJhngrrzzibcovR8MU5PRH011eZz9Y8JJ1bILwmqumzgeDPcMB4ewfl9np9/erVv/m//F//j/+Vf2V9e8MtIx7kcBRFe/LyWXrU9Q3Nqmr061e5mL05tsGhyvV7o9TnN+mBDEeUbkqSOurMGnTsyD5p9q3YmP46TClVizn6k9ZxVtlRvxFDAxKpMVgktlr13fyOxMpsxN62D/3seJ+eje6kIB46c5FtJ4b93P+R7TIx0AjVNNVYtd9qrDmxx9Fnfc61MVe/LQOz7dhxlfMdYU8y9x77twDt4WmkMQokVF35kQrlGIPz+o8seVojaOtrcKQPowiJ3p8+XTwj55Gan5DtZzT9hLX4TZU9rG/LMSsYmmxjqSWIdTwt2euaiO8hHMVfuo9i3TUxEZoQmsRW1UYtPTdwlg2kycQtDwPr1N3Zv/y3//a//D/6WzwSDJK85hNhvOzydvnsxcV//l/853//3//7l5cs445Q5uaBcWQUHP7IqiYHIR4M2ibfVtEAGIGVQk95wPhOccuiCr4M4PoZIXV7ttibBcLy1nrKJF0ias4LPUG8oNGYFkzqhFPWGnZ6PsrN+S+APjcSZIoUzgBKsYuoYxuI/inJsWmomsVk6IHaMaJprboGCl+jR2l/jcqZ6CHHhmw2a6723FJItSyJWYPmv2SKefSHLFFSi6X4mgNU6sXdGh+vLThdTeNwC7cYxnkv5+72JiY1hFzb5DRZQa4C9mkjjK2Z2g/Yr1ZALiNAAp77IS4jckzFvSEWQZE6e/Xq5dXV1Ztrug+4Xw946Y+O3jqebIYNlvEJxWawHtk3r+YOE6b4LvemRnOyPX1Xz26+532q9Luw8VS+/rx6+kiR/m17WATGk+rtxXB61pXRhzn8WKljbe+JR5Gm1dlyyeIMAOC+h3VLbsyU3H3Sh8eXw6huVDqXmHo4N3Las/bdd+Ft1ZGsWz5V09IhzOlM4dZu6k8VH6/hmFXsWyZPzJz6FiBn5ngr7RfuK4Y7QbMgv2yVOKGmJZD9w6Q6BfW8Sk944vTsCLvvq336Ke33nXHQW7StksoM2GlgbF3cwqF7chwEBXRjZhSZTUT5yD8o2ct+sHCvxD5iuTo6jNIuHRMTO+HpVlSTz2yzO1bYvwGW8jlXM4tzZvcXl6C61fLizWsWeFwsFufMedfyEvYDWBTABXXrY3BkkHqXxi9j6ZnCW+R5K3+BTmmW3HyhhtVXA9CnFhkkcE/ixocNaARR8aZhdE9jUJbfxA2cQac8Eink67MmGVGEKIkUelico30y3oIIkRSPuZLWSismRylZNDPd7WfLijd0kqyxQacPA2QYgywi6OEHgpTwHgrKavEQReW0g5yMFVhOpBP5QXGpE8y6ockcSRcDSow5ZhIfzahqiIi9TttYxBSfcB7TkVMHTrlwS8TuLRvdLOQNLwAdDrOqbMtyZEHdirtDNES1hSaxzCMiGW5hiJggFCjP3kU9PPFwdnF+sThfLV5/REDv7r6h21zfvDm/4Clz1pGtbm6vU1eMao89IVIxWXdsw7Fy/R5uttor+tBtS0+vhII41tMekO5dM2aH6vQA9feIPP734h4DDyqe/Y2Iti2f86s6zl7vWntbvyPbdg5bOVy6remxuUTjeOTTzp7Bw8pWJxw96duiTzeGEy2OasdEGe3PgrHoSRJ7fC69Q63nrWycwknuHpP39yhbub2R3c3nGlsDgGnRRmwmNVwFNh681QvDnIed+RlHB/KOhsqO++P1DPp+Mceq2k71H+D9rzhED4jG2xEpqHRMpIf2HI7Nn16Uoge0PSIbnYFfvc591S6J+7h6yRmJUjEq2rjRy/bpYEoIxVkIVvQnqC1IFm7eASS2IxqUAPTWzN26CIRl9Cz0UIk2+etQWEiluhUEkDefoqnZBWomFbvqCUR1KBAKpoXa3ijgQ1urpc7osIUD2A2D08m6SUFDkMMYIEYpABOnqqVZVs3FaRUKZKMidoXs/k9F1JBkVIqtIWxv5XWGT6gSxVZY1JMq6Fg0Ry7a4Fv6W57QSKZmWdOfGnpHhC2m4l8ipWZIIPfcqaihEfxUJ0yJDBFob+lZLZYZzFkxRg38yjEuuLtjNMfwwMrhUmRlSJpyxnXSdSi2DI6bL2OlAKKv/4cm0OexB237aWg8sFckFC4Gg/HinCa7YyCgDgYPtyJ+nhDgzZ8350vGkHLredmQh3wRWn0s290GFunqdutp+wmhnrKL6oneUzTs8g7O7tJ/y/8WgXcWgd864RDq7UvMdm73vN/N5yp1N7wFaM+s+WBk5zjqGRMykMnmGtb2TqFGOX601wSOHrHNjpwGyw84HqkzV/w96gnDkRr2CM9/E64xHx2Z4i9P5lydOuDt/m7uvxiGhp2yz9Z0a/5jIndPfE6sY6/+sN3G+Qj9va1j0lv+nGQXEFG4Scw3bP3pHXSTOzZZtz2wFPAg187NSduLdMZzdZDarDuH0ok0/5lRKHWTrjASxsSgcu4YRisyL1HVrH3UDKzDselOdlOZobTI7E0EyhW/uC6VI8GULs0hhHSm3MECKZeBEx5gpHwWsbnzj/nx9v4KeSTCz50HBJWOJQ3QaiDJb5R2Th1GEWGWl5AClOIRI4FCwC0KOqnBtLjiKlGZsoWtYyKuVSW4i1Gz8lgRcesTNwfwTSHbmL0x1rj+kk7K12ZaEgfDo2goilJHp8D5hpocaaRSADKWSf9lN0kAuNAzsOHgfQPff8/V76uKpumIKsc/J9b1h8p5wwBcT6yQxE7uF6jd6oZFwWwwYGOR29Q3X2r9/OsoRIm1ZiXQ3TV2YfqTXsXkcPcghKqperAejgwJnN534ykC73jECRVqgp0phi/L9XK9enaZpT9frYjw7TnjLdaYEfWzm7/QB74i3IxGnxbc2KNip6hxeBhrWLTUXmJJN8YdpkY9fKCmbE2yDlXzgXZY/FBpRSxXpAM1GzVsXf1G6nxijv+e34t5hWNJaa7sCdpOumKPxpLYsnL/PO628IPszkVvW/VT5h5ocRKNh+mha2+dKwdqNrE4y+u3I7N4cptjXEmxY/Fhnm/rfsocva73sF0ERgu7eSIIKdfWdokYWe9L9GbCmyvv1rXnPhW/lb+rCFRjTVt/zv6kcecYf6O/jQg8IPyTFi6At9+7B+gfAAV9KMC0+tKJijr2LrnHx/2lO9SWrUvOeNkbmfQQEOd1rTArF6jgcXLIsBikJnhTIS9eVg2BiAXoBG2HCNXStvc9OWJVCEipRkNRHzeEsRlSSNd+QK1H/phL5s5DCQUOO6lfZuVzWjpaVTLiR7W49HwIlbrEuNSDf+JolqQjGqhbnkZJ9MZXUvUPvTosZ5Cuxq1Lqt30V9ZZ9rBFkpqBkjWsH/iD23WPxXlzVeldPUibpTMqtW2alxbKAtn/6BkKGMnonbwaTrA4yiKJP2uQqkFxxAZJBt/mFJXQlGSrWimmzpSGmMJ4GBvSWqmVEuhjgX0Ntml9XydEoHjSIIvERucIMTXFmQsbxGGD0WseobL5UfaO2VvN8JXklnxlqvgYXQNP5Nht3Gol0gamJzg+sbon8OgXrIKGqXiy/207HIG33fHetv7DtXunpV4Pzpk7mTE6MxLtxz2bYA0995w3YT/yOjMZsT1S30z1Hk6uCPT3TMYx4sOVRnJr5mCqK5Hp4z9lmaNU+1Qka61/zffv8A/NuEM+LVu1eJifJ98v6lybjV7fkye9q1PwxMktf46w28/6A5Hu3dKCabF2hji/i5Tr2vdtNdPPW792trkrQE9v87u8t34QrkTrMDU7SGZPB7rb3GFAJgzta6kTT0p32RpW9u/TuIfWudVKBaZsgXNiPLO+nka4yhJ0JuKZWuaxYKtEkVUQJ8vqIdkcKE0+2DdaQFfCTsFi5pthC7YVoDbkxYEytsqDItEBYuxALFBSDcVGQtwaxE7C2xGUWhiAWsrINUDsVD2T73pGt7n7bHF3cXf+B9bGLNafuD//w9nZ5dniesE9Xl6iT/rsDW8RyhOuyLKG3lXv3ppgUc0dE9vsfc2/lPWn/C6gDVlHJU6T81wsrtKHl3fXH8vjdR5tLKbyzgOr4Zerv0rVMx5InXQ23pLwpf7eAnDAYyFJMbajiIyX7O3W2voZJ+pMwqijYf07SZfeb4lGOdjCvDy7+BqWiGChxjeWwoONcDriYhBxe/P52Q3fE+AGBDXwCwy0hpiePJXzpMEAnuAg8eEJYJ4YyFPIeA6nAkSc/Y3DrvNvo976lhmtsqGPrVwsH0PILrZMFVNo9HaY7e16GZ2yledD74JT97p9GeiuEv1ZNvJqqjRpcbRawjFfO+rP1mkrck6KgT4tDZORwd1JaXf1K7+bSv2k9/ndoa1tStkqnmb6q/q0tKMco3nPr9URV+zOyAOT1VJbwgft7vEzwsfUccvKEZmprZ5yvMVeamr2eD297NiVe+Jj0zOR75Feb6L3fFrHKaWXfUy60zwbhv4Mb7hiyiul7gA8xp1eFo295b7oEeny/C0ofoRP86J7Tul55ndcMu0D79iB38ydEIHubOqSuwqGs6OO2W+4d06a4tnVMJ8v8UhVcuzco+KNrQ5gbDRuWxxzo55wlo6xcJCeEJqFHXpJ7xMSRyojdhPiJScxKSALWLCTNgmY4/YAe1FlUJiukqUQSuadIaske653ABEK0Y+AkD04OKUjnivNkQZTBsaiwSlkEGXm0kXFhf80qqC3GvjHa0sB+u2yKsVSkfTd2eXlixcfvgCmL+8+FcSfX/PM6uL2Y76ZdXYB3L9cLK/vbi/uFm8Wtyyav7m9PT9b8uZKEBtvQwL0MwDA+M0C/iU/fq63P7u7WKhttbjATz6jBg/DAAYA+OMwYHH72e16RQkVBy5Dv7hcvfrp5dfffMVn15xKH53FV2oorC1axczQLZfnLsIh/OYc+ShmCGwCxwJJZlfpDBvkSFA8qnjg6lB40VWmIjbDObRX5aMFqkb4wzTNDgsusEnGI13jtaG+aVSVxAp7vvFplb5U/OkYqtneBkoZwhe49cKtGd8WGHIKyjZyl6ZBjy6E9aASddzDcE9xbNy/iy/ZNbdGkXK7zxbbQK/cWP5nnNiJxNjef8YhaVUnFDvBGWMyRx8ZHpMY+uhjdPz8soTo/op48c0AYL+/M+OhftyDYGdpSA7H/WofSj2s9cCsNga7MdM95o/n7BXNjRF7nmPSx1jfif8xajc8w6zJ3s5BhE/a5rydo28pHzzZIr6lTN+T36XdR1ana6SW5JBG2j0Xhnybh9sIbjVpzehvke73sLFv7gZslCvcYFhxjUVkW1r4p+xYRII55WHuf3RmTFCcuf9RYNvFAmlbtGhsgYmhwB8hIEpBdWBcMB5pEpnJDh6VDvDLOo5aXAL45c0uz57zxVkQqfaD/Mr1wZ0iVysMXhRvbEHCkHJVoYg1eMr89I2bK0ugizs3wJTZZtzij0GEMfN/Qd81r64BfUYTpYwxkF8u37x5/S/98//c/+Bv/+u8y9618LpZjmtZTMsSFmdnlXEEAZx1Dh4+9q41cl5bKb3QpcFEpn3JESDIKGPPYCAjKEc7N/W8QbmPlmfPz//j/+g/+b/+3/4v+gZ1o0nCarmkagxiLMKi1VrwMPTF6pl1TLUyvLK2EPinJ4lFVPFZ42+p73LxXDolanIQJW+qSlVgtyIlKzW61Y9Lrehu9d1ycUUs0ON4hjhQLx7kzXMMGS6ggWsFNSc+fECaNVttkRBDgtRsiJOOxl8SbCT7rfyS0pwsbvIR2vArt/0lYDnwTlk2E+RH9QMdYlWq2FLe9BRv9hHWhX1bUQfNaNu7zdEbs0omc/+Dzo3CcqTlN1eSDcODUv1VfargxOv8o35Vp9bnKNte7URqxDDQW6Nt86P1qfw85jd6amtKmatoT3+Y1Fan6dRtgtMR302y2qs1zbbJaR2nlG2Jp89t7gFu6565AlQn4zbuNvejcuriovuUKnt/5vpEz7M3vbfNek48vpen+O+t25F6euvvPl1OjnX5Rfj87qP0c1isNkmDsBtbCFcGGknImybreBpgGPzeUTDoGIqf4lgmNs5sdAafdb61kgbbzE2kekKf3ijdl+o4SYIQxY/R7hHI1pbHY1lWwDAjgfMlC2FYK1VP3MbNSDrpy4a4wMsrWXSSicOl2pyp8VIXnvgGwi2cWrXbaIge59iDtuFlkXkDneJfxyI4L/pnK+WICFXDZdhEj3jPmhiR/vKSZ1LBxbxZFE3kWU5vbUXq+MDKnMxeAwBdKubLOkllCJDawRgQiQ0TmpWkI3n7vrUTrmMQNOz6GOGw4cg3iE0zF879ibur5eub9WuEDSC0yBk7ZAyMdZJmPRJHTRrllDrsUjbG0c/muMEt4eVuxe36gw8+/PCjDyXF3fCyM2Sg98ZsHTDhhuPYG7Kxe3bGd7t+/OlHSrEtgGZBDzX1bUB311TgDR/7IlDGiEBFS+C+/uAvVlINuw+zZvGjWZN32EajRdhwDJ6FrjRGoBV5kCInka32SZqxoGU89OmRvMMzwzWyJzGa2atxm/fY3I7Oyta+6ll71D2h0WOde3/4+lhMA1GUMZTvj9vvzJMxPjsWiUkV7dCfKlv692o7ULSX/10THxIXP2y+cyIOhMnoc299qqdStDWm7FrPGTiyh8fre1XvI+Ic22h08NVbtAe242fojxm3Ha/tgEt7i46xXoJb0d6ray/xYJT2Shwgznnb6If7z5N6Uk4eFZO3YPdAiE4q6ubScv542qS/11H8kS14oGkezoRWtJON/KDlJF9G5m3p8XwbyreLR+CCi3EFwFbb7nGQ9zjgG0Qa/OlLky59o7ahvI9Eiw7YSvAnDi6bvoGb0DkTLAj1bgBgjmls3sgZFC7+xln+gzvTaYWZul8o0pKoGkGqBCkwVRka9NB8/lQwmI/aTO2HK7qUUhZXKdmYU0qQPtwK4Ajcjy/urBQH1t+4RoWnF64Xqytebr88+0Bv+Qes5Q8vltzrgMlJ/rO7Z5SeLd6Qurt9BmGxuBIfqwoh1u3A/zqDCx3KPQgMJ718Bc/iDvBNiQ7rhUZc+g8WdrRx8+zu7hmrehwSyMAye3wTmjM+4f6FcVTO+wPeENAE5aqMNlLYsoIhJCVHKNhkWy54H79BhA6rYVBF2riUWHupeIBfVibv9Y/ORJWG5x4IXI6TatzHV+FocPTdugIKuI8BR0kOKlDlnRLkHR/ZMRwEmbLiGUSSHre4hsOaHjYrJMEj6iqdDNkiecqTRnWNeaIAQqcnGiX1W3RJSBzK6C5P0zEh93qiYYdwSraU53Tpa14q5igjnQQKan+K1fDec7WfXucP/x519u/R3HGemtxBKRW9zX7q85RyqskZ/rnf7hn248hHRxh1Q885pLl4djggjh2oiqq9Kv026lV3ZvrvI+24tJNt/efrkN9CC87VsafvDd2On2mDPXcAjpIdde2evmP7nKZm1HdUYjT6No3s96Q637u3u9+bx1F3TqTHKftzkR47+FuucHWxAAcsJddM16Fl7vfiKVs5bvQmd5Xrleg3WK5n3JtGWo11ENQ0QpgHalDn5qoPedhGjkEFWDMQ2YJClGfMUYMKxWfgNiavRahCf2Z/wVy3LEcvo/gBF88E3/G8LF5ZBfaZjNbHUDgGuwUtmuEvW03nVhJysKQaolsuBwYt3wIEiiy/SjN78DosAcsecNG9uFkW/gETU3rrOOX28vaWVf6rW5/5FuinSNNRIrMmkKudVbDEnZi6uFQbLyGXOUsCtaXIRbYqIkF+9UAhcvLh9jUfX1aI//kucnG4J37g7TRLrGpCsGubjHbLm8BuDbhZFwxXgoOOyI8yEnGqHatIjyxSCm5E0w/ktPbViu7jGtpzVwhDyqXYOzDm3CLGkdsmiZcUSoPRjV8c1MggUT2+jMEJ2Q5hV5O5lITH+NsgKZGTRNVO1mQr0e/l6fN9mgqnTJdn2eZLUEXhzjZrbIeP7FDxpiWNMVU4ypXmHYbB3EEvRxW/9MSfRy3vb6WdTrAjMPSJHbLZw4J7BJ6U9PNaP7kqB+KILktPfwagd6LXP4w/epq83bxmLzqkp6PGKWXgfcLjg9/bs1u9zqcaKc7d63jgvMJMNIZob8yfqp+K2Jun+qeUjZFTUo8e+55ao8fHpKq3ZXc7Gntbf4v/lAg9nLf82OvNw5UeJUmfaT3nAPvkMrlNSG4kicKCkRrwW6y/ELV1a5q3DFalB+ngRDwqNMmq7TWT08Fcru4Rn1DCW2xu1yJRXuDOnws/xGcAP7EiR88E/ofCzgdwg6xiq5TjoRqsvJv28VLfY7pSUeSDVdBvvrDw/K+sGvRihnL9e1D74uKvvBVRtYhK7IVTvIq46JphSkzFlii/LebHd+qxfHN39nJ59vHqjOU3qPD51Piiv/FL3M376ln47kt+zi7vfCnQG+a78wqgm1QTE1c8GcyDFxWRejWQ1bemaHhRIeIWK1pxzNqkOg6ntLNe3V3yfv6z9V+4nv78T2kRRzLwyZj5eNcjRZEv4bEkbQOJ/waSv/aIgjljEWmdqMhmeMSEPewhsfMfvMSZ1PlXldOuIoYIyi0PLGsiocWSyghj4ityzheRrSxty2uRfK+S6Ly4rr9Y3vKaowxt7DbWOJGBVnP2qvUJE6+iPC2dPWkfUUg3iwm/q+DtGinZE3N8M82dHIh6Xq5RkRYOfa4cJRJntvBZZhD2bqhmq30xzDDGEGVpsMNWS0/2veIdOx1XS8q8vVK5xOPRrFtTPVKmV/v9fCP16N+jkzXHxJG/AifWcvR+SGz/HkmdUgbeJzweVbsuwlP+KeWAe3SLuUBB3+lz97TXKfGZKsfJum8zrvvYsT6txT3+TAUys+B0wJNv8bWdcV9NtGvxwABgwn8EoYIz13ZHKDia5ckt7W37qTvYfRfVmxp+akoF8Km1/jr17bT4TvZd1vnIXvp0Lu12k3scELlNrtA5ZaJos8NDMoGSSQi4xY6i2yrLIQLGe6O1FYcGNVKWczk7B/bpATrIo4yFIGtW+4BqgHar9Y1psN71FSte8mRt7hgIzuERw9W1WBcC96XiqJCxXBVnhVeqZRYMm2LJCSNb1ZQNucqUFgLL4NaioDKnjGFSA/LWQsFhK6pP8fIILPPsd+uLs/VlnClkzWiGXMw3gwW1jS6bumXMltnuGMNuxZxoEUB+LOOEGvhvHXxWtskmK0K0fuqUCaOMJXgS2YeRwfvEzaFXWtPbBC5DIpNKu+bGKjj0YgzgGEj5uM2YrBSiGCr/W4Ucrfks8SqrevQ/FdUZPDZdrsQfpCAbhnKOUpb0Q6BhDXd0OjRQz9InJVhQ5K0Xg427hsPvBOuvQYYLJ4H7bvCoWUWplB1DSSOnJGqzJ10Gsq9QOXxqxBAYn3iHBpIBGbYxaUG3jfSibbJJbVirYJPvVLTkobIt7vtVdezNoXYYKtoxENaqEfZHrrG8pxzt4Cj9601ULPro/HrremzN3mo0jlH+PjXK3rOpi+T9J9PwJeCTRy2Hx1UVyPvN+6O7u00puxybUe/xdnZ0jOO5kX58248iOwlGijtK+lHvyREu7cdEI5xPpv9oizvVf/Js1aiP4akmHhaTLakhGrTsXHeuvrTT9Lg667nTn/fdGeuquj1n1txAw/p3MtUbdSrNGzamboyadvTcRxeD6Oe2Ru1+KX377SUyjd8KGDWTsKAPnPm2FbkVApACswCF7a1B4UxpUg0rNtmQ8jiqkEzwKnZnnhU4xdswmYPn2dcvvv/hh/XZ9+dOjS/XayDqG16Mc/bmmx9+/JF5WRaWC159PtZq+uIXlPFxgNwBCOwTKQrVU2Et1TmuV/AL9GDgH87pRejehSBPr5CqTGKIFnEwc+TCRIiweyx0zYzwl0BNS5uUxUjEChpgE6EKHnkvPpPNi3/C3YRM2Oe+B+Yz2Y4AjLyt01BQOyeeb+AnLCz3j/95+41T/sw9Ey56OOkKXfFDoYtKt5fy2lBrzQU//LdrHzkm4Kw9Wl+g/+yCV4vyePM3iwtWT+Ef4PgGBM1C+7gHJa2ViFEuVPbzCxe+3tSNOtnJ5PPAEY7UIxGIOMa+4E3+i9W3CMDhFvTN+/iVyNInhSzNKM6hYObpbb+KNWXeJzH02HSIkhFECzLeNqDfHhGwh1/fvfnsbP35YvGXiW5sOiQgGJ/j/nL1jUO5RANSfpi8B3W2/sQ05yavZ10m/n5pgVey8gJWe510qkOsUI7D3jlJnRIGK1F5DkNtE4cwtZ3VlrOdd18pcfOl7FvnZsk3dU1t07mlrUx2X+2wNAbCNnf1KB39taiUF7/fW+gcJ/Ce3fu2tryLFtneZq+i22xvN9ejnT7dWd361ejoT5ykj+1sU0rHcEz0+gbqRLd+v06t3ZR/Sult9enRZx1LtGsOvuc5IT0Xn33tOBeKE8w9gHXS50vHGId5lcNZvc1BLdqW8q2rwVAyHOsOwH49A88DjhsXHiB8ssjmKnWy6EagXD4QiZ5hWr8n8WHjzW+p9ywC0xbfcbDvHjtFx2VP6EFjLx0TZWIne5zdKVdTs6MtqIlabpPJTWjbGjt+kkOu5MIpCUgVAIKuPeqAcNJBbIM4eTdl5JdMOf+Y4vXtN+SfX37w//wH/9E/+C/+Hx88++j67PXNDe+jfM3znmerNz+9fLW6ZHZ6gKDgOueBFQQ11lMDqA5sBLTzskgAseiQRTiaFYbDy08LKLPlPVgGmw+WBiSabRWzGIgpOMZYkCrsGEFVJqgjrFEEnEFXHf9alSHLqVUK2G5vL9a+v59X+4PIHUWAwWO9gVR8UyB1UBEmqULB2OgmLQLHKeiOL1wET7npeI2dmtzWh1Rfw0mb8JHaGGCdDIEVW6e41kqxYIoBgJpi2frgmPbiVR4ORtUA/fVOFuuWmJjjDaAQbniM2Iqn7kbOiEpRXe7gSFK4gkO7YpXPeFG/VNR6MNzjceRbVNFFaE2HVkYZMWSd8NdqDkUilNBY95TWz1PNGoR5tfJHk+p7e2PF8BE6gcU4dVWzDQ2chcIY0+ET7tI0VkhBd1bDWxMMQlIXJNN81mLcVDlmUsFNbpNqIqPkmBhYttV0GgeGOhqKOLlFnmXf4hrk4N4xvyO/k91WUqIHWbYF3nFuWrt348DbtrvTZO+mUg+z8rZdLf3s399euBW4+7rG/dWoLwHfz7dllszxz0TvSj5Jfm5Ud1D53Lr/nl6RqH7QR3eM0JiYmio9/Ui3T0/5j6LsG6fuCh7DM8hYqYF/U8GBMnA98fGIsewei71Un97D+t6QNiFlHm7ytcvmpiiktp2ONmb7+jgr3P+w1uWJ/c7sWskMmnsNLT039zZHB+wCHoLEYr8AnnYHIxzFdLJx7P0RBolfUiMBXOOB0ACJcAtcJrAUyF7xVCtvqrm7ZUE5c9VMwztjTZrPUZGGzmr1O57QXfKJqwumZn1at0/7vdtnd8s3izteGH99vny+Wnz7p6//y//fP/6vLp89Z17f+d1gMTHo3d3nH392ce6HsVhOw0iA6X9uCDgjKz6Ejm9YZwG939BduMz9jV/Yde7WNJ/f8nNa+MYXdl1IyQIY5suZ3125pD6f3ArPm5trXjbEWnPm4Jknf7a6wBlGKcQhvUAkKBg9v3zFJwIWiw/Ju9a/WpmIXF+fLV67gEa0fubbMxfPb9Y3q3OA8Q9rXl4p+GZ9/+3t9TUT62uU8JGvszesfr+7I3pW3Nlon292hEA6dwZYLoX/8Vke56Tbl4PHmWyn1QkaNcI+l4j67i9xJg1mxmvb8qfV2dVPqOb7CRfUEmp1FFfHAIp5JdCaL4exCYTZHDrwEMSlXw0TGUdRwDW8dxcX55fPXgiQHbqwMUq7ffbi+eLi+9WKEwf+UoQyBzDAenlF3IJsBAgd9OfPXpyfX/DBgbJ7vjq//ujNZ5998dPLl9dXjFioC5y8GvSG+APk0QUlDqotXZZFYuuz5Ter82+WV4k+pnnv6vX1q5cvV3f0RiLDno+i5cNq3jMhhonk2V86x++DE96ByciC0hv8pbvnuwpwYpPnJv7yxYuPCFQ7X2x33eAvp1a5VPvqE3aDdJ3h4PlbDP3cP5Rwyj0mdpNG2a2Y9YJ7EaGMu0FPb2UsbIKDFMpgry166jIwcmltMDXwDccaWk/vM8xeRSN48u/CEb90e3T2eKNPD86/s+Me3w7aPhy9g6Jbv1/H2D2G57DFKh197rqtJTvZA6r2eDJt9we1Y2GnR92ROOD3dtEYh21yn9sKiZd3zq9cujZMXH6yUmDmPsDT3wHIFaBO9I0Xv7DUcNHbXM4OV+CXWN26Utd+qx8druqfX2l1hgrUMbUv/mM4h1/D48Ov7vJk9GdMYLFPH+dAcc06UApT3PMEuxYh+8C14WceyoArhFRgALSwC6cZgJcXqdCXP/zww9VPN8vza6a0FwwA1iyT8Pu1vrayAX2GB28cJAjBSddSls0euA//YnXNyygXALLby5WU8+fPli9ffrdcPju/fB5zgk0TArfF5TO+RgsIcyoX6Mh9gcWCT1Odrc7Pnz9/sWQwojY1L/HqjGEAqBF+9bPqYsHghMdw/ZAinjgwYOkS39zFZ9JYyDBmtb67evXqtbcUgN3MHa+Wq3OwePMDGy7/yEKUoE4eD8ZBwgU2BAcSJW9MuBlUIkdRgC4v/z97dn52gcnXL1mU88M14wTQJkB0TcIBAIhc6KnPDk7U5i8EP3vUniU90PWctLcsCrYGyJoOxC/Qz76+B6xUybqnDg4PgM5nq9eXy2tHWHop1RroKP66np6qUQOHBUaffwTh/NnzF4Q+pdZRScYyd7cvXnzw8SefOsBwKGFtSRg4eETzbhUOBmrX12/e3BpWI4kF1TvkeHH57K//jX/qfEUE1OMXEvAnnyT74x+/evnTS4Z+jDuIz48//Pjq6tWbFU3MEyKg/Nv1GoXeLqAWRBVq5uatlj+udt7VN3/68XzJE9jPHLjaSwX9AfqJpN9JzqIp+ImQ7eiCK+NvDOktaQuMrBeXH9w9f/Ecb4xRGtkoJb7srVAOUqyEBQlvMimVurWVVNSEXhJNrlogPYlCmWQnbCospRHa2e3qHIo3VqQU15gY1RVXz0t6LB101bG4Zgq3Wf98cmNg/3yq/PZqWsE8ENJjOl/x9F367Tk8r/lAJQaheyrDMwC/l3XPaGM6Zhp07uWf1dNJbSW39Y8BHRNbzE+Rma77L6176ffEbdufYnbV7zbd31G2Gmv26R22A9mSPcAw6j/Mk9Ly0x+h7a0ou85v8zwmt6d3HaGul+rTR4i+FZYa/d9772sM49wZ0Y3UR94jHd7PD7WftyO7/ySCyv9+hkBKZog7+4J2AEoxQxdyRHCv3sL6FkUPEE32hgElRrrpFMCF9Zy3cAaw3bx5ffv61dX58iMncQHJYBFRKSiRudWrxd1Hury+FB+DtExnzuL2Y51ivl5HLyxdoxMc9glpFoyDHK/egDM/BFKj0eUuoK0lgBmos2IpSL0m3oljjGXCnWGGGMxnAEBrl6LMNZCTaeIvg44Ek8yVq6CeNHWUggPgPxDgF3iyXP2QIpe+5AYCoJZbHPxnlY5ceLlibIDQ+nPzrCCXblhA/C6rd5BizKwutSXhzDTe02r4gwiQ+E9nF+v19dX1zdWrH7+9/pHKMPPPK0FvlneX4HF08tXbs7NXPAXhm2bqTQ+6pEljuPqeFKvPrYrXKMy8SF0cXTDawUGYjIC3WUoKRqXO1p+xIwhI+RIbByof3q4/YqocgeXtX+gxzwNoa4Fntg/hAttHBIhv/dhTo9RNRxiDWKqIgwDRN3mny2+9FbNerBiGef1MexkhtgRGNwqsZzSSmw7eCji7vfpkfX5+u/wWPWB6KGk4ML03TRZ8JRkKY8drbC+4V/Ds8jmT+z5gvWJ5EuvFGDvdPbt9Rv8ocxiyLrf48eHF6sPV6gdicUc/VC93M4iGkV/c8U0GAndFBHJbggNekfNf2hpPn+vQ3RvLFher5Yvbu58g2KET0KRrZ2RyZpUf1hc3cigGK+tGW7Odf+1+siVgSLKVaHQK+xnQ4HWrXBrLwAz5EOL3RGVPGNwpM9HWdFSavTbUWk60dBFT0nZ136CnzF1Fi+fk34XJb19v67DOuv63X/Op2H2Unco+bC755Pre59WR5cfYneUp5FOWjoj/lkvhH/uVRaXtoJ49nszwV8/daZotB7YzU+y0Xf6Q3LSHTynH6HWiYd+2NfdfFd6w8Wu6Fd1NyZEppPeEbw/pkL6RvU+c5Fcxj+KHjL21spMcfmteHFJ8OEpE7/2vwqHqvZ2yk2JyCvMpvJOqjcK0WnV7KNWC474JVUEatzg3ymQtdmnBL9EGrciNIRKkawM9UAwiIcsfEESMJDUYqfbBO5KFGMqVuHgFfC0mXvvQLRPVK+aPSx+MsopJ0CaEEiYq3DZKxCuwhRoEYxHcTMPXDL/6rUnm5q+Y2g/+Yu7d1djQs3BFA/jgkg5oLsVAB9P2eV2QXghZCw4DCgWvlFnsu4MYnSRTzliveJO9jvlfHRxYzANiiNkaeZXjuIEw6uDImEHEq8/ByWDgYoBHmIwqjAK16837+sO/Zzc3z65+vLp5hTsgV8YtML7JTDUBMCYxMXqnQ/jaHDRiEIxmGqb8xR34w1QtYJgStpBLujjw2xIyy5e3yx/z4AXPv4aWMU4FIK76y1QGmO2n0szsZwwQB6y4VcOdqCMBHX5HiFBoCBqmiGl62BOL5my7gaA/CDmT7jDAiHlzJ5EQZ4v4UYV/TT0m8qky5/1ZEsQCrGuSjhUYLCLmMwSuX+JgwNMiN9yjubt9zpfX7m6/N1bw2zkSJe5RaCA/w7b7sGmvcgiwJS3NWrmEbHE1srZaVKuk2dNoJVhc1q0NCXSgRW2Q0KmDW3nSVKVedGZ9NlL9piJJzUBftJvekUzxDm0nO2qAPvF4H20U+MUmfp21+sU2B473He9hrVMakP3FbLu+HngGYGbMNFfVPaOuYuX6Qpym2qaUTvV0PX1XuCdZY6a9c/l7uE8h9U8IHJbb0xv6Ovbpg4oeNv7rVc5p6Ht8zz+m91RhLOsT/Si8T/c8T5HGn90ee0BtPKkZ+rneOBeZA1o3RSA5JnznVvaHr3d4zoe5kfrGELUWKAvphm2jeCcgfZb0yLehQ8rmLzwKyY5MTb95YR7wJSsWmNkd14S4XgYAJErIHGctcWY1M4iTt9Aw/826F1bMvD67e97W6mRtyZ1rdbIuQp5r1vC4VscXoXgiAO5cJGPrElVmeV8xaw0cKTQI7OPrs4I1Wa1VkIrceGll7l6FMxhKKv9xgwKAFzgYfMnaED5PC9RkkTeAFDlWdjgnvb5dngOw5av1Gay8v2BOmFUmxmdxvr5lWT/T2dwnYPUHK0h+gJcZaDFrbLOeXi+wYtwCnpwdT1Jv2VgP8inRPDv7k2ML4aOuSifB7vyr1E6/QY1gWEzAQJxLC2MAIWx0sWMBDC3AaEhwe8f7cwjaq/XZdzfX5yxUQd1iSX2BvtjMHL/z9AlUM4oHehzPiPfnpquclIn0hKLgBYkyXmm5abdP4SslmLEhVt875rr74uyW9Twg6wu/e4AX3GNxQbxAHJOoYw9/qRfrk8rUui0c8OwoSxdB0NTDFoSOT4TD9Us6RPylxrdKL7k/YKPamcqCkTKwdOPz71JlPU547RoYwF0w/HJ1yfDv1u8ZL9eMnuiAt7xbiWb9E5rIJwS0C/8UiVWjj/K78786u/jT7euPfGjcKFu/VE4hOnlCRJEupfb6kA2K2x2IX042HOXuFovKCFfGeKUyfZh2So0547iyoZY7Tkl7BiFPlNCgqwgteAIn1FiY7sqZomdY5Dkeo9Hp3RbP6Fob5muLci7AT93pwLVVpYbcoWMinRAc4mrxOMSyb23CQf4qfNR1fk4/4XrEZvDyC5ULYBaDHadtRCDHhGtH5TFxOIZnR+1p2cfFbdfWU2jzLBu2SveUoeSo455GSStPEe9cnKc4YUrpXZnT0/O0dH/WF6nqGad5mxy/HCHvqcQebVPSthzqQjglloPMVPdDKOXPKfYfYuWXKPO0cX5nEdjuYO/M7B5D5cm9HezdOHygNQ86AGpI+ZQJKNF+5gXGgVyiNKGFAEdoQSJ4DtBhfAKKXASCUtVmTQVJ4W4EUalWZRUsTCVYyugCGpPWTrL62sQ1j5kGg8KoNDBLG2VWcxqpq0vI5oZssIa4TqagoXpDy/Ic6O/aG6EleBODDmSwwGO51AxwLztiAjHUWQiJFeUuG8owQqdIYMxlRXCZ5I/K8i9ZKyd4Z98CQ4H+h8GHaAFtSspCQg+LsWokXCUOVdWoZ6cyJcreAPwhMhl9vuSjZkxZvzi7eZ457bphQGEUpiqKl/pNuCSwZa+dzRarlmixuFp0t/la/a1G4DiI1WquuANwBbZxYY1DLjaRadn3aPSjtzoD1Ykt58uJP32E+qib4Rn3a7KSCMMZjBJI5+EZ4RgEjKFOm2qt4YLrexjPsaEpeoHJPnUtfMaQAgyxrBDPE/tyIP7TmjdO87MK32U/sUYZNkDA8mdZEXtuADgi0TlN2BeWtx/woLn1Ub0748b/cJgbyEkqtrtFRsfsUjx+wJfa9FVgHlMYa8pKP7Ww31qbLVXS5FU2vXPwc5ttUDbIUkrk+WPcwwCSLJYdTsgQE+hBX3lhzcq4HuxsiEyJ8Owl7sgOWXhjech7LPkJuWf580tXOE4J7Z9fjP68anxfX5ieQJ1EkjUAgI9c7U+J4H6JUjXq4XJ/+lbr6Xu/Do97+jHTWEfEH7PVeP3wjO+O/tH0Dv2kbF+XkwRH5tKwv3VGpsOJmVFsE+pH4X36sM5J6eE2nbDfR4gnh6M3LX2AD9XK1buqs/eU+7wcy3fbp5/15/d4e9v0rLFX9+/e3mZuOcHEVoE5/trPuUVDOT/xWQpx/ZmL4C/+cSbsQUR5qJHHQNefObV88QffgeMEfx7G5c08Nx+f3X15dvlPlncfrFnHfPf87vajs9tnd+d/6WOyPCy7hp+5+Wd3i1e8Nr7enyM48z05rM95xhJ7Xz7DK/n1ReeChZpv8XR0cuNuKmH8Rv9JFxR3JODjwuA/+jCPV6LZhfM+lymMQhumBTUZJ/DAqw/v+tjuHbc1QP9OqPMUqPXljf6Lc9esOKwBIYXiowg3vt4R67aF8KsiKu5P6xj35XcOqWBD8+0bHz/wnTx4UhLax9VMPssHDI0Jag+HS0lUKhLlPUUUWQoUpVrr9bkoe8WU//eQavofeyU+xAjlccW4tPZWY2I5wMsheAZbb5qA2a3N6qSaVpTNSMO8PLv5jHEUNVnfnN+xqt5bOEJVn+bFUzxCiiORdk0T4NvlOqBsFUJ27IVGIskNAyekYfbdRL6ih/Zyup0YEyLbWd850CKk/DMYkGrsJQBmoIAI93iuefqXgcTdmsa1xqknFTSAlCJze/MB3yq4XX6DShpF33haYHWdt3b61LBjQwcjqw8+ev7BR6hmuEj1bl1JRm/+6frltd8x0A+riUNtTKi1KJVqvAxspSvrXuXWQuduPveGzOobuawxnbam+dnTMxmlcHuNmHAG8e6p9L27Z74vi/sGrJ3jU823H/IA/e3qD7aI1w0tmt7Y3TgQo/Qlq8xj7txYYCWet/K4QedjD+gvKwx8fRx/4ePvnh32LmubSqh5+P5ASFtfHqjeYe3421zHeida1LrSUhOfy8pAeNhxep1/mJ45qemvxpQyla25/yn9MOUwAjls95g4bPEc/t0/7OgjSg/X4hGKTxC1k9NlOTu2tzn6NleXm2iosq04d+zHJXPKhfUEPRuhwUiuOZXJ8zb9HYDtM3SQOOl48rk79XC017k60k5LHFB+mqKjuR/v89GmjmV8D1061vX3m288XaaJxzl+VLcdz7Q97VsOyQEQ8F9BAcgNjITM73lKgDUUAMtYRuAjs850A85qShFYA5IA+ILZAQogrk4t4A80lOU0a96U7moMQIMY6Q4IxrBBGAKwAN7xfCSwGyzOBQc9DAlYJUI5aS67YigxXvkT0DSEcAs/DcSAi6rUBmHBibx1Sc3wGPzHq3uAMqmc/EwMUzVh4NWb9Ur/We5DBYSYCAusl6uXr64WvhZG/320QPDtXYslYMhVT1D8moCGDCSwtU1gE0lFEnDLHOe8ubnhqVM++QReZR2ReEhE23jCrczt1esrAWyGP8BgYD4a2HjaF7ha/C34aStW3dyuP6bclgkQTfgGxi5SGVBVGDXXOEYGq6E3VZZcV7ZJygWPXsHLwQrWnoenX9+teWGOcWb8ZLlcRNOa2sEMBhrOWVMPYufR29evXxEM7o+wWAfYyu0g1w0hQKDB/wyHAOPUTWWLi3NvC5Qv6bXYBZ4vV89XPLwLB4uOXCXlfDambngvEJK85pWWhkoxzYtTLHPRRW4yeNPhbHX57PLqikbnVaJ02ttrfIPfk8Fl//i0Wv0n//F/8g/+0//Mt4Vi0g9H4P2zTz/++G//9/+Vi3PgcuIB0S7AIZtet6Rx2tqMy0gjMlmPRFXRZKDwG11tTGLAi5n42Pjxiv52Qx1zV8Nlb3fXuEmdMG/3Ky9U1m04ZCBtOxuEc4Ae5ruvSNRADUuazgEHPEeKZORKM6J6v625Kfaw2eJsbG5oB1O4pVpESqrSxukULQdN/JoKCQqh+W17QATm+tPD4vkwqQe4vX0i1Hkxa7yK91vZEiLzuDsA+23spc6NLL3bvmfUNdVxwrhnKjxDmY7txvV2SEzHgjNq3jtyjaf7mYOqaW5w339N9foyM4o9taqHR/Zvo02bh3P9ra9AeN6iD72t/emtK3k361+naV2stk7ZXk1W/c7+EjQ8wm880MBXnQAv/PlGg4CVn3cQleeeyAKkzPvjXRTzygn0G6YGwQO8XacB6uXyRxHB9bP8tPuWmExGkvvp7OzHu+tLS32D5/q7779yGYiwGKgFDuEBRy8yIifANnV0vh9AA4C54z3trMTGNyY4BQDL17qpP1a6sE/LkK9NZwEiklMZs6EVo9PJZ+sXlrlQHiDjBDIoKXoxv9bP2+vbK4CPi7wzdQs3KBbgdXt1DSZDCUoNEZAdNKasK75/yNSpoFbrvF8Z3effI7xxmeT6d/DfMadrLTBPRf0AsRp5NIH3dZbD6jAqOswfb565uV5wvtBwF18BQSlnPUqwFx3V8xEugaujFfS/dO2Nr8bEOLwpp07BeOWh+wqkhcXjnspUQWTYhSuVMpOtuIdcjqiCCnrURvTwtS/acn25vgaF06SGlxLKAvzpdWzlkFXNkAxbxGH95vqGWWirz4dyoXHBoYqL5cubl69fvQLbo9mv5DJGfP7jBfc8qLibiiFmTwIu8rYXKRI4tLz7kpsj/9X3/18GBQyfish3ABzTni1efv99WvaCx36Xl9/f8FKgNaMt1qFxY8UXSeES7xzyq3HMjV9c/PGv/rFVVpgXErla6Hb9ZrX8675D1ql6XPE/nvUxOltyXhCFD0Pc7IrpbPljYvQJQje3P/34E2+s+tGvRrhaLI9P2KSoJDB0AYYGaCO8vM3W2I+WoMO3Xj/78JOPP77kbPWZhrSugdWEemyBOuJH3D2/eXP904/XftCMprA7oZZzgXK7mW+5DeiHTH/64ENGaJDxzXPBvuK5ykD4T9FXlmAYNsQshrmsD3SOOlNZ2nFnU2rYWronDUU/4/Hgb8rb+x3pUcoWPkkwn8BuX68jfvcP/6ZP22eWv7N7ai1mdU7NH02Zw3u8X4tO26OpUtl68kT/2/CtN3Lze8+LUyPWNHgB6ZXVAKBIWwU904nppztt0fRIp0r86Ty6JxSP9PYe7fcVV7gOV/ZwaVmYq0Xph6eUzLHd5+YvoZy6HROpt16VR8SYpxuBK8x5o0MYwbmU6Xwu8WA4Nn6D+fFnMOC8uC9U944/nCkSJIrO1rfXwKDzS18HSUmghFhuOz5wA96eAaWu3vBJLwpZYJBnNwECokXg05XoQXiSFRe3LLK5vl4Bv26YvAVatDlLmVulgzJbehNoCalM6lN0aKlRHZtvfN7LtTpZkECBr3Xh1fjGgFdWMj18wUuIoBMLJovFK27kxKX8F1q6fMjV5AmUak0qRSzkJ12xVAcotMJCgdEAT6HeuWVsilzr9oqewhcaRiwAemGZyV9fjWodxJviXVWERf3YhQIyXi6uuSdw/RFvnASRUhKAhw7MyKcG4zImKkhjqEwUD/skPRzcyucmpYNaaNVanF+dLV8B/cXXVRIHEl3VQ8seobBA4Ftr5+cOQwW4djUDL5+InrEC9waMJfcUbJirb7/51u7ROY23mIfFCkehpklAZHm/H/r6KwdR1ePCl8qWxBmdmnen8qAw2B8f1MFP/MU5Emw+AIA1Gtn1S6xSCxhnKJJhwJqPlV1+mG5CDYawkRgcHEhbx5Ex1PRx+thq+ebqNS90ZTRJLi2YESwdzE4SivWjE9KV6CnpOPCl1prE7fPVhx88v7ggWlVFysr7mCJM7YhQZahmVmm94QkZ4g9S54zWVsa6Xh+aBu568X0HjOo9HZLYsEvOXdNc+stItcdQ0iKi1ZF9THRipbEn/ArTFYRfYcV+RVUaO6odftim3XwoeX+Ps52tr4ynIt8B+J1n557xRDc+e4KKzo0s5+hPYPJ+FdMx33Scd7+WjqP6TR/krvDtJst07cdaVBbDXuhjf7ZndN6NUn1FRuKYKInD4909/aoz9LDk1OKUkqms+9Qf6Hs7lbxP09sp78OvhWq7Xeoe24Iuf3X5XWfGTrEIiWnrTRS3rN6mYPUtP//ygspXS6ag75izRHj1SqAs/kRUMKpc/jHhCzIJfoGAVlF0ISRQFbP72LhlGcgNc5HgETQwGsireFyJw/Qq2au7M946j+blm+urJZOqYFzeAqThVDJDAZNQJtsdb6xnW7wcS4oJbwQ+Qh/M8o4gyLxfhW974RVDEQD1M25hLF105Boa6gBE9zEA7TYISD7VpEauClksXlpx40CaiWrAWcEj0vz7gx7zUiEmnTEqunXoA13tQbBkU6vQAbtuOJbGsbY4QjSdwE5IuQ5/ZSOl9Xj6gCKCJhBEHY7gdtqDD+niGx/h9c0wTBtrxPsMJlTL5r5Sye7Zwbq7hYQUoWyxbypUO/AnLQ4sPvZ8B4DJaeFxdTuxuAMkh4y2iKw4XjrJmjb4a9YvsQ5LbvU7vFGUNDtSi2ffM0SA247GWnkCtfqqKbKYVnHUVbxRCivHbxzG+aQEtixd3n6hBnq7lvy3ePadk+U8/sEw0al3NlExEfYJYTRzb8p7MCRLSY1mbcHF3ce313TCG1qDnq0afWYz2fYzc/8wGpLbD92nJsvFRxlP8/5WT1drFXVYjS7sw8v5YnxMK0WijH1Ak7PujkGSHzuw9/L9Cs4yZOnSjn7iEkf1GgQ2fgt4D5LfnENTvse84mPSaMArNjqbV4AwfpzG0SVmByJSEYaR/6rMXrFsUEKrXPZxuZm2uHk+SBcnasAhFPffM5lo77SentzzG3Gqku73Yvq7dq/+xOZUk/L3KGX8ZX+IojmZrl731gId07rPKS76LH9n97CGaemszinrERS6H9t0D5FW62Pe34GJ0J7d0/o2NTDorw5VXk+59lN2uVl/6bZL3i98LBVtD+7sx9o4ja/q9545dVoVnor7AUFA5Gk7yFPV5c9KTzXB2JP3tQi0oa1IsqDnnJU4BGn4E2GQbV2gAAilggrQBa9xsQhIGqgBn8wpB1uAcQFETopGAVADAAHuMJ8lRvyws6aGJ0Bd4BM3NADwCLQCkmSNAU8VqyRyTs8LE+NPPFO3uZKP9SN35SquCF/YBIeOQBxzuDZFTMTCcCfjs76bpx4vpVFHMTgSqR0KHOEgDyPIG2hIbIhLRY4CoDzlVhvng9J8+FRUk3AJzmIewbjCEe1RzlE+pYmKihxYBEEaIx8AgG48PES35qLZ8KQUq64Ex9pHy7MPXVTjI8JWoHYWmdlsRbGJd0vgqUL2m6SZEBq7LIPK1JMMrqQW7u8YiiwZKWUun8ZNUMsLxaotmwJCQkCdSw4De6NvPKixdtOfTEGsuGrKL4WxSsce6N2qaJU1UYoPUYFp4om0jccXkWlyF+poE2XczcKIGN+KGVBLfCYgLR6f0snpIVGewIKULbEDpBPRj9cMlaOz9R21RVkURjECGtm3FZm2jnFUq9j+QCdSUaoVleYNC13Bf+bc1ZZkJOjnPlTjoykos686yEdj6kj4VBYFGiLBo9K8dcuTXTI6EDQsiUyi2fq7z823tuec9dxBFyLbbsSz3rXBxfS3uDhSinfI3nvsDN3L+94zJNDvvZe/Cgft8ZOKPKwzVavttN1U+cTauyHc48iO2/i0FRkjUt8B2OvtyeOzwdzpkR4k9/pRc5b51ubpo89eY0XrdO96HaZrFFjUfnQIpUxU0bg/PKo+XDoqMQF4Yku77Eg9vlIonq41HMaa9puq9UiJK+6mlLHoyMRWXbo6zolPLU4pc7JvhX6Ez73dAqn8TmcjtK3XbNM3EtNO1SgFdpueog28/3/2/mVXkiXJFsRiR8Q5+apnVmb2vQ2wQYBgj3hHHJAAh5zx0wpg5aj6H7o+iOCQDYIgUZmV1XVvPTLPiYjNtWSpionpy9Qe7tt3xPbYYS4qKrJkiaiauZq5uTtf0zFVbO1ik0Mv7PkI8ITfoEUA/ueygatlXNF8wl06+GerAr7Sc+lgL/e4Wgo0LFWxhU4LAS5DeUVc6wGQ53V33DDAZXe2xLKJ9GwNwpvXcU8Ol20IQUcuKYwnEhEsbBOexWaA5QF8C2lGi9okMrWHOTB3LKns13xxGw9vRsIyDvd5IwVbLn/+7t2HT8/8ULKStCJYMFpyQeZXfLFUA0/Coi48eyFT2cPGwik/dsiGBkYIS0Z4wsZWXriYTTXriyh424PnDYbMVRquU7/7xBtjeE0aLoZMe/5ArS1bzZaRGRe/TvDu6c9BR8tUwJoLHRjPaqFnJ2k667GgZoSh4HhwHWieK3cBZax3H/+ZCJ/+mrBCwIkNHs8/+/LpO/yiPM6X0tEASiXABT9OaWzo4Wt+GAL78DjfWSIg7lz/mCus+ap3nOysCmc7vBiPFSs+U0F3PHh+ycrhjBI1szWtvQnDQf/8jLtWBMtTCHywAB8Ifv7wB97ArwwxWJjthKGGH15H/igj34zBA6MDgbxgaFUBD/Rz/mAm8FQSv6yJHyZmFL5lQSpExkN7gslSmFabtSINAJg8vcPnXmQCGEhgw17lyPlGWM0Z2pknRwwie9DPxOw8B5R4osIPqdveaolxlhHWIDH/oeR9cfhOKhK3z7d8+YxfL7ag3DLal8+/YE04dAjAc1SceBKG/wlugGJArT1opUDqxdb7aGCdMMoPGeeWrv0LI+vYWr065I4Dz7d+jeji73x1mEltXaXFY1WrQ3G7WSxBGtIqbqN/W9VAOMRfkTTJIqZPzG0qlYXQoIaA9Z43K8ODisjzEMR6RzIIqPDQ1sS0WZHHjsw9eXnU9kvfDmkVZMqvFxhIva4p3BNG+5M4Eez1uGo4UJy3+lw0aKNCep137wV4cceuzQuBRpPbJNouZa/9JnEFx1d3uz8e98xkc1hg6YD1AO+kh9KWRgLhVUlKWG5ggzUM1hMA4de5wBSXtImo0Fy7KAxX3rwPjesJKilgrYZ4WO9ypaDI2jJe+o+nyYctjcwWN8OQOe+CwLf6YwlDDhYVAl5X8N0pSArLaHRYEiDEK/Fgw5UW1FgH4gnJw4ACM2K2JM4QfOISkveqc8FIJReverCaUGLV7ipzIzgt4c3VP1uGy3dmIGEdjM+twoAFNbqkACZcrkHQauzp/XdYjiKdv/z85WeoIkPYCBCXD46GBLqvH5mh2Vqn2QI82coBW+izszs5rAUFMi+ogx7uRPojq4zANhtQJwICwdLl+x9ETCGsiZRQHi61UWFe6ueDKdLLmlx1Yz2rsybUEwtw3q8PIwBBD1fcp4VvFcJZLkeBbK2+UAIa3kBEeVloA4SaN/dDrbdQQNcIkgf87fPinCUAsnv74c71OecAnSCSIt8L+2A/YUElwaGkD+Pzodwlh200SqYWnnqbJopCD9YE2ExUI28hoGZ4W3/bs8xQig+f8LEWrNTRzapgVGyycyjIXmOiZ5yxYIe1j1Tz4xEcM2OMZ4uvhmhzZvD2vC/8Ni0UiMxsi0LQGA+W11QkzUfcmiJskuGiyYoEZh1RXiy/FilnfDYfVAlQV6GdZfNK/HtTa7KMMps0vldJejl141cOugUo2Xez04STVe98ZdFXQbp0cgcC95zYhXVD/0rzEjejpefOGeQgVgHQaxZX/aNZLJTrG2fVgVuj1z0LIbwnE716pSu81RykH+81BH6Ri2ftCBAuecRceIH25R6ruRTGaINRh/MKLUDka/9SafRYy7U+OGAtgxbP19cPW5qvRoEv41RwyYC9Bnc0/5IuuALKtZC9zPMV217tTWXrF6xjsBTAr5PCBa/uSByLdVtHYg3y+S/wrSfPH/EtQIbNLVY9WKfmC+pcymNFgt9w+g9+ESTuZGEILL4TF+MMN/v+EI4v+tFLWuSKj+QmSwTLOZKj+cUNfm42m0Z1JVuG9McaB18uxDUfr6rzdn8kCKo/wWVzrdtykoinooCn0kEbV3uhNqqQeG2YtLhuBDhwUEX89BVPdQCGcFieWgh+LoIlgp6WGFZ+Iyo1cOP3ugACpHjWhEUbeonGBT+XvBDt0wcsN68746qzgXBVDyt8LuD9p998+RFfXvOPP/zIIQAHwrKfS0DSNAcOyvJA+f8JfJ8//RJEuXS0/0yCZzhMZLGVBK2ZWhZQ4U6Tv8JmDcvmE38G+GdP3/0L3v7hlXhOD8Jaoehoq1KEwCVl3FWF9T9OCHj2hXMGpk9Q/HGFbeCoJgw4wQDDZS2u4xMM3TDGQHKWGrhVzzT8xHk+WbBTBlvzIxSZMIidD3Di4S0Bjhsrj/ECV7wDwLrZiSyqwm9/ZXEwi/UTY8gKn2+2oQESefLesD/x6/nR4kfbuewGpJFnvvi/fqwGwmaRIcGItqSIkiW31E09OxgDSWBUMyyfEQ0xOcEY98tHfJD+T+/wdbF8p85GDUt23NGHz/PgbOV/xSkCP+zLU19sgfpvfDOMcxVYHBzudwmfJzqWJSqCquPdl6ePH7C/IFPcbMapzs8N8pQA7/XBC8XE9CM+hgxoloehff4bcHvmsV1ZMDILwc8cwvv3UU+NHkqXLnzwafXqYFptyB8WYNZ/9I7AfQ/2HPPqYq73LJ8LSjG+695FqDocpOhZ1Wodt7C8trmKewi6gXCaf40Zqx3lQ5R3O/XmVc0zQdsM576XHtw5soznchYse1Y2SvtIaZi7+bw6AYjo0WiRty0W22ukyyMCsCjkgOi8pUBGpR6EuXHX4RqqVgW7prKw+Uqajzmcobh4TeVLti36oCZfWxzwGesDXUzVyyRuw+Aay9aqHMI0tblgxJIUtwV/h1WU6blKsEHmsgOLgz/96dOXH/8DL/C29rJlBE8A+DKPLVe6vKiLFe6/89LqF34wkRRJxqLwhR8aHMhsaZV3P67GsMaA2pY67CNg8jR3NuqHcavV0Ji39QgHi2dbWYOlLmFyXYoGburBmQoWz6wGgxpBLAsJ7QdcYFgixOVnFcSPiduC1JLGWhVm+OMNPLwTg6siFpBmXJ+BgdUTBeJwMJSVgdC2MtVilFXApWs6oQM3m7AXF6xx0RorVAycvRjAG+d0Xz7/2S/+8rs//vBXP/mL5x//xF9fwBBw2WZsE2uTGWx5pJ4lfk4PZsGQoeGUnqxBOvYwM8Ph6g5G7Hn/w5d3/4qVNVV4JFSWlXdTscBIi9SZhU0Ufvb3Pb+jE8YAsKHXGt0waYraMBh8iYnKGCGeBzAuluzYxj/MQz6IjzFAC34oKZFsvAgGTyUCQ7vuTx0Ka0rzTm4Es6/UMTsY2JLWyCAqVsDv8L23ZMcgqThsVw8oFVFbNhIHU1gzOQFJcVi4rLNndpiKAgBsxpIH62bV/QFfvfUjbhRDXbk/8myTkxufYIHmT9xy0uL0gMt0/AYGMD79iNU8csc8tcmj0SEqCeIffijNbt364fs/4U45WMKXPwLIowRP4YBhlxioxx7FczaODia8vQUICELxoa2J2Fjips56VcG3i0V2+SqfNZhfZWqPlpRPuZpYnoN1zwNqPI+CNZv8r11oQLzwo/3qBKDlitd7PPAalh+6Egwop6OedB5TaLPXsWeB6Vwtcaj4dM+fAucYvShC7IoyixPaMd+ZT4IH1/KKApPK3GKI6LIp984mB44qprZNMz8nFivn5vqmV1QeYEX3MKY9hJ4+Ro/ylH2IK1/NpSnfGKwj92Zm79pVoff6f/olA6y/H4MaLD9sjtqWiwGoTKe5i5d8fPXkP2MNg6UqV/l4UccLdJjX8rBrnlh4wgCfm8TJAGx/astcvp4/v/sP3C7PJSb8+ZtN6P0LYDzxjnyEo97OAZ4/fPrNE74I6N0f/aXfFkcw+VdG/fLniSfZgRue4GsmBNJ3++BTBNS1H4hIHFgC02W3ZRBzhoC1JhZBHz5+/A5LQHw/IteT+KZ/fmeOrbNxCRO/BcCltVUkYSAwuBOHizC2DIrKZGG00WfLfnLFn/XJhN9lhAqlMyC6p0xhp3UitywbngxezmSXVFz32nsoiQBiodMa8MRK6/1//PH/+6vffPy//l/+b+///Y+4SosxBltDZDxGQgqGnzDV4BVZPJgVn/mQoNxcRnZ4IKCbRScoDZ3P+ONK+fOX7z68/wt8r+f7p794//5fMNAY8feffv7+45/wMYz3uOHq3Xd//IzvCcX6nwtHhP306U//9q9YODKzdNeNVwDduT5WQERQuWy2MCoQzCaXlJrASoWztxdQB0S069ZmBKvkmnAsTybEfDnomJMkxXcB8MMWCPwJZzdfvnv/XtfX+VnbL8//8eXpP7//+ANOITmc8MHKFyTTg3XJtYUKqDZj+Q6bWTAd45++awv33+MFAd/zAy9+HsCssHFEyjAxjtiqDhYTQDiRwlcW4eT06eNnJJuqyV+4y+9bYJ/FPxzrkCfnP2/rJwecmhpPvjdlsZ7+G6vz5c9YQBDEHy77f376I/YbY/WEjxp//mt44fMn/Ig8Hpyt9Hn35S+Zxft/xncL/eQnPCa846+UGD4boR4f/kkKqpiSkstb9iUvVSsbV888Xm2YdN89qMBWit5xe2UUG+F1ZNdrBxLFYXkriRhpLYe4647jrV38D4Tp4ff0B0IMXDhn8gMy67/zcYZnd17Z/sJT9OKx0qS9wkzSEaEwr/F5SBk/0rcAjY2stzdNS71CltqNAD3zmPQGxNXdm6UrAk7aF5miOelYhDvWVKyCwzwU3K8lfC3afCKPbzlT6lw9eyFNr4YaW76+8wWcG3bwBZ3rBkO1F3MtvqFOJvj2Hi4O+EY/rbkSoLX9Dy+0gi/KR1QHSkE0UdBj8e0JL/aA07VUIQtYRmaCzbqVtcWzhStN5Zn9EenL5//8m9/8H//Lf8H3k75//vinH//46RMvqH/87vv/5f/9//r3f/+39999NEqMysWM6NizysZcVAhuocMfrGyBjzcEdB0UrqwuvmEGODDAyowKyxQKNKhnIenNZwo0sQTYtjWZNeGVSo8nW1XCkLd34zQA5nb5+7uPP+V51r//8d2PH/ipZi7+EJQ4wDVgyIMHQ9ojCYkJVUSxpmiblTbJliEWLay4av7Tf/rlX3//s//x6fOfff+TP+L9ic88Dfizd/h5YBT7O3wfz/f/z//l//Gv//FvuuSMxSjLg1LAlQiYEnoJVAZQ5lSsalZChUdyJrAWomHu5sDx4WV5WJjIgmmMNIp5qFNmAjRzFJErAy6RyYfvNgDhCb9s/L/57/93f/PLv8B7MPiW/een73H31ftnfAHru7/5q/9ODMAdy2mja1UhQVFUDqxWGnKqjTM3jJ7mgohYj+mTBAMbSrMktkFTwINVM1xg4+97nIqAB2SrJIBzLAjA4/nlcuoDd1pCawEMjS1MXQZLBwSEQBNvReGhn2Tml6XSA//wjgJB0EUcqvBMj8Qsk1xyMQPYWk/aGAtGzPpkHryi+UoWkLYz9ivnV9xgnV8x/TfqhyuwMeze7XuGa5aQUOmAIBUt9A6AdSx2UarOUFfX46Oly+vI6XrY6mzGTTcEIa3O1cI53IbzsHvz0KGSrFNJiH43vEfQbilMV7pQn5nF9xAUyI0nhYip6BFzEqQw0/lxIwuree9bgCJIZJX0W1cpWGE7F1cdGggG1NPH6FGesu/MpSnfGKwj964WtO5bZfau1xD4QNTX/lcBOfz8VVo89NvA6TXCVqYsr60M+NJs6wa+gPM4QDdt+CqOy4i4QokreXa1EispvTrTCP/TUYNX1SF++HetXQwHvXjYyus9vg4SF9VNgSVHemAVgbUg1qn/yqUeZNLVYMvStvY7AGAm7+SanqBjGsYt9zzji+ftsSBREoIccD/Sr/76V7/6q19++RF3/PPrQL/w53+x2nv3r//yr//B9SiJ0I13TRBtKU1a3/DGBlvREZgLctnxGQWiT0rFjoq8FMozK16zRwdviKfEZSi/Q521gwv7jKruRqI9l6q8mApINBFLYWhud7OIGuxFEF/7+AW/HvUdjM1HJy+WASCYiK3nTJALNWpiy+gWRc+U00xYuCWw7AMbEDOIdNHXInBFiHumv/+zn3z35z/7P6A8+NZV/KDZl+f/jAzwqwv8aaqnT9h+9/57/Czvu2fUH3XA+yd2GwlvWOFX63DisYCCEzdsGU41Y0e6zwl1N/4cCeND8pw2qLRd/mbTEoIOJrg9HRqOo1nBknMYBpYhBtH0xIcNRhjHBCLQ5/npf/gf/4f/83/5P/3Xf/6vHz7ip+J40Z2zx+L/8AMJ830wBBEREU6syJ1I2PLdKobk2R23lgzfRPo5Scte72jBilBGLRFkamBDtUIbFFqmRsa67x835+Cj7ZpLcLc59v6/mRk2iTT3aZDSd//bmYoxz+HAR6EZjPPWTtXAg1+WZZXBvo9r/+i2EkJr+bH5/l9Axe4hhFbvMGieG7gsscXj899wm94HYCTi7XjAGph4F+nXdPr4j+afo5Q4GCM8Osf50rhoz/sG/DOvHWllZTT0WlwwQjMVXEKIu7I05ul9Y3wGY8/jDP/4Tn4vZg+/oZ+vfy+YVanujHXeOzcaPOsAezXYU1qP1vphtK/ENUDaIbSzCDzLCwTj6gSAusY+pNmWHVccG9ar/lWjibCyGDYWxkOzA51jYkWOPWPRmyFZADph1dmbB4RB9IK2cyj0CDoAcUrnqUYoyYo7E919vzohZX+kCHkhlMcvQ9nCBCur3E6LV5iZxpY7kNDkogAfJcRnNLVMYj+XQFqQYci1kIGaw28O6XBhRtYvVKw0zCBzyePEVRtiEIcPcaKtIKnT2ohS+UhOQU2CSwjhcJUDHaJknryHHp8g/dFuceBdTFh94gL7x4+fPn4Pf+VHp8TM/OjP9ZJlmRZeCmbI6dQHTrQmD/7HlgsmS1A6FsZWmooDGQZ0gd6c7FSKkNDzQAwwYZMW2zSHgI3lb6cSsCCl918+4ZOpH3nekBayMqehFUGjR2V6MDKxDMoSzobZAs8prJkGtVkurKyHkwAw0uLEijeB8ztnMY3wff2AwtIYMr+HFt/xw3MGnApg9Q8VF+Skw2iU8ZEG4PBUxvJmEVB+Z8O2QtEe/0MeFh5oTpwYaKBi/JAAYGGB8OaJ84OEQHYaB5AgdioXlFSoCyif3//z/+8Pv/vN7/GTwbj7BT+VZ4Akwc8wvOMpKD1SeBt8apgHQ0Gyh7OztJKWsUjU1sqLnVzgkSpLGPwHYT6Lq1tjCc9Zhw78PAJzspSZEsrJh+HI3GRC8T+HAekZZjYyXpaKnSxxKMHO3o/SBRrLh2NKOgRlIEuaLfLFMytvp05QkZgZ0pgSQ8fH0hm1W7JQjvluYb9If6MyHR5KOhZAJda24/Sm/joqMD9NmG+cKt38OW+WzwB0XTThHKV3bto6X6GTX9d0hFrQOVkPeWN+X3Gm6JTidXSVXHWRgTRuvAg7OdTvIWzkuETqSo5ZkBSyD2KdlCPKJubrXRB07tvrjZYruXeVIrwknM+9N/dWTPY2do5pDb/nakGqAZ/i+KncGpgygL1k42qrvUiHb9E2a76452+Ih2irMYIZuF7s0YJAha1GcMczd1WtNLisgWSLCXoZD9MJI72e24t+4owO7exsG7I5UQkBFxBxfZGrB+OQn2IMYtYPKQ1ztYIAZ7FyF7t3gWsv0uYS7wsi4gtk/o3Lui8/4W3R/FVgrEbxLT0/Q+p2hR5pctmCBzdWfNobDEzIllXClkzwpMubtuDhWtFqi0kOS6yo7HZzcuB/5Kte4pBU0rAb/bzkbPjo4yVwgJE3/vGkAKKCqWYcwfwPt19/+Q98YSgBkSYjoQvPEChTYizI9pDM1PAQNcRFL7cWzEKzk73JzwRVwi6TMwjRtYFxSojfxk83LhlhaE88rcGSFN/Aig+j/itOLD9++NnT84+4bIuPNyAu3hVKt9zg1hVo+MUytkC3j6ImNsDgmwO0txcR1soIoG7YN7HFP7L06qHfMjdL5sL5bGWChhWWfcqAcfGfENQQjfAsO5NDTHx89k/vn37BC+v4pTPawASnATqX+BON5YlQRMFD+wjUZk1N8mMfY2Q7c8z9VkpFNVWylUfSgIN97sWuoD/zt3sBgbdTsJ/bryhYQNJAR8rBEG1AaAtqKbiOyZY/y5NmGOKQq96xf/6pUf0jfiqYrFElDgf/MUOu7e1hkIDFFKBouTIIaeDEi47JUk9o8do/u1d6a5Oeqcu+wpRNfN4e1/5lODBXpg3/CdUZ3wn42qS3/iksWd/hAziwmXn12fu6uWF/bcVOoN2VZzUWG9Er+56iGsHnMbKvARwwfS/QP5mi3k04k3BsSw/01yYtVXZoPW9OzpbTlu4moDkowPUHhQeqNTJHgXpdGe/gs4c+6B/IA8HRItuoVBTXeNBa413XCsVUK5rXxnoNaKnw6yfbI4vSLCNkEhcx7fy4GMKrO9c/9iUqAIMKaylbCdhaAC/nXEBSARtcTcbRAE3q8N9WJXpNZwizTKFySOhM5NKKJvl4YkpDMQc08Se8oKBoPEwwG+tNmyVTUxhm6pKs2NnFIhgNRdPaBLc2sYlFm+5hgDW+EpQ/LQU+cAFGvokbSfDPKCk2ZLjhvijcrsESscuescUz4ztJYgHcOjQm8GE3LRidF6JxrkY0LrlUavTi4jkd4c0Rk8jvpMTSlQdnClASi0WG9Tv8wBm+3pQ6bDioQBOIZcA24cLD9KKSe5SQmBKdDrYWNjerDciRPxPQNiVEZQInOTuFSA6kyE5lhw/R0hs0P7/DDWb4o5kByozZmAvrg/+WKgzSbfh0Z93MgwtVWlgk2LKJOrLg4sle6unCP6pFlfrkbrbGnn1WWVpRQw8bJUgExq0vz7h36cN3yMbuU+LPl1mNuGvIR1U2JJVddUzVWT9xtPSQL2RoqFSPsUoWplY1sgufFxPGB02cZeFdLnyZkv3AAfoTHMgIm2052myhk40OumWDJ3uYp42GuXBjZ608TYVLmqRJcB6WtDK3o4dZWkRPLrX8KU0yh0gdbCeybjoplFCTbg9kxrLtpOO1kuDNnTDfnPneOj9GgbZZawqN7Oo+TpqP+V6636H/1CzK5ys4MtnRZ0/lJs9925CdM8Xx2VKEipY5i9i/yF5DCd7kBa1zD5Te0RKfPxjiHmRHEJeiuRA8fW17gToqFdyK5l7U8ajtRUv205WP8+dgrNotVsQnh3ZQXEj9GzrwjB8v3mnZBAVfieFnayzekotlDNpywm75+a/Y/vAv9orOHl2tfWf6d0//wuvlMOf1XKBwOYotxXxkEJLhs4sd6uVaF9Gx43OZGx5qccsFS3rtBy2spLAlCIKoO2El58XRFGjmiGxzBZYM9SRmvlXnh3/Dqg/fUs88cNEZ3LjgxOT/+Pzl46cf+fWHX55/wFc64iMUvNL5hIUUbu0AMdjocr7JvC8c75TiUwT8IkV+RQyvseHiNPSwhC8uYEeN6T//JW14nRK+0FjKuDEG9+birAwzlu++4ptDGQtxgYyrmrhVhr+mzIj42OmfPX/57vnDP+Lti3fvcDUat6Hje3W+w60p3z/9FZKyK+9Wlo//jObT51+xljz6qlwgjwc0IAyNreFwiZ6lAxlYLetFs+SGJaQ3GP0z0TjT2FZpbehlAyVN+cQr5ERlEPC3H5c1JkgNa+8/5xX6p59+/vLDe/7UNGr1I7LgKdmX7yHjy5ps4rEaeHPGfqbtO3xNpUbEqoSPPH/37vOf8/s3UU+OFHpRf/veVdWW1WYv68mxQCV/pAaWqj/s+QF3RjE9xxff80MNf2n5e7P/Hpf8gc9fyX3++Mc/ffj8wy+++x4Mf+AVbn7nz0cUDQVm+exhxaRkOwAFJK7SMHeWKm5pgEfx+ojiJpf1k2lT4a2SP2cDn5axQnNMsEdhVEEIPz2BOgQgDYyCw9x4YiM0hrEpAa4KCT36OHOITT5/Ahg+LWBUYcs3bbTE12EBCNnTTIDH6CgMAICGP5t+8bvJDRmO+cGgWYYD7tqCH8431o/to2vpsfYftDDxMB1+ye1NXkEIbIcIbDHTzj1UPS9YFA4XYG/We+23x+5cTeRdR+nxLGo4Cm5z49io9aLzUI/HiZnQQ/bJUGSEzwSmuZGnyMqSDRwQVZW1K+xXpuvejVYOtmH21r2uwKmar6HQ2hw+D7dpWWHfROF8boL+SkFVlLCHUrRXWGywVsWdFriFGqtuGlLFF3tzwqs1rqnyq+XTgysYmNlFTlokDypw8R8v8ICxtT9d0ImHLQ8kGrwpuQQyAZuMozbV1Gi7WFmvLUFkh+2CsNbLwHvdProkWZGiRUJFB/7swbUJV6f4ZCpulviAYy8v5r///J/+82++fPe/f/704cuXH77gm13e/RHLa5xX8YOeWLjgngp+mhlLSSxSscVSkotULkBNttMAnD7gK0aBjhqbDbeQqedK6PNf4oTh3Ud8KSpxDM1OEr78BTCfvvuBvybLpedHfLeMLUlx0Rpf6Q8OuLkfyPhIBm6b+enzB1j+5OkjLHEzxp/eff7u4/u//Ou/+jVC29Ciflhk8zb6J7v7HgI1qAWLwF4u6SCRA2TQS318lt7rRQc1AAFWSA6L5qwzGPTTTcs7YuGsCsg0gg++J55P/BJKfDAAL3WYgZ//+PnHn/3Z+0/PP2P8z7j/6rsv+DWu9z/ypydQb363LHLHD0t9wonR03v8wBZPyXABnpVB1u9tof/5L7ge/R6f5aClFveoLc85cU/X81+ywh9535GNkZ1OoM785DEXr/y2e8rQoGz4xlLc8MafsuIovMe9STjFQg1/8vQB33OP6D+8f4eviPrN//Df/2/xU8P2QQtb9yJvvjfDB8vMLYth2UthbTNIhUzlkpNqy266cUMvlCChCU5WZkEre3Am45FgpGPTPLBo5mfcMRTGEka0w36a+i0EymQ6qDFh+D5UMuYhw/nAVYcQbHEgwIkQ3izjKPGLhoDjBEiaDYw+o+Bww1O6zx/wIW+dH1nwTDQ/r5PKWj57DwQPEg1aspy0nXZqAb0CHfLzGjndWKymgVt+m4LqEydIXcOvuzJegcb+wRnz9Nu/+3uvQGlTtt1wLCxHibFd6LVzI16PaT1mxqw+C2whTehOn6WNY4xLqkwvy6VHJeTIOdAzu1of85JcfG4BTKLN7vghr92+weEUh4CzR+Qg8PoZHp29gC+LuEz5az5//D3nEV5x8ZHLz1i44NXaVgL2Wo7dj6/xXHngH5cFXFniBngu/rBWs4t5utTNr6nBJWesLD99+sRziXef/pq3nnz4r/CH3+cv+Glf4PBhDKnmN4XjGfd2i5KtHhjp088//4iLtfh9AKwLfmoLkD/Snly5UBBE8qIODx4rDMBacDRjszRNuYFFerhkCFmbn60CGY4rFKz/eIcTYuETnHjwnQ4G1ikSFjH8rh4t9CkjHTgxdRaNpcsa5MPPEaCwPCVgsUEa9qaSDD28gMCtpYRvmsTX0aBszFcrJ3SgRIzCxTSXWBYXdcJSCgtf8MGWS1VeUwc3Lo65Fn3GGwL4yeVPfwQCB9cKza85+vxTnpPwNMbWwRDwvUxYx2NMuZrH3pHWzfgtWJ6lfP5rXjbmTIAX12/4QV/7SVfMKMBSwxU2ZNx9zu+V/0t68XyGl9Ixo0zGpyx+wFsiz5//nPovf863R57+RML4mAIL84GX2hEEjvzZXS7ZEQ9ZI5f3H/CuC2bUT1kTVh1B0aW6oeasCbO0VFm8D5hR2EV+wqvRdipqBYYPYbg1iXWlL8eARacPK2eiMLkjYN2s3QHc+MFYYmKXAGHgYI7wg80//vgjwQDPwWZIfnsP2viSU5sStrXAjMJYcLaI1ram9KkdnqKlqCNFJpswKJF5BknwNgc4nZ/+HfsqvgfoZz//hc4H5c6tOfIdME1mauwSgNXjA8aOpcYbMj+1czZ7wwRjzTMuzCK8LYazMpwF/QyD+/2Hn/NsTWe/y1son54+/yfOt/f/jPHghMfbVp9/g099fPfT/wa+qVbk3nxgWPEATeVoLdjaOwZPG997ZsYXbG78erH3dUTDXBfMKyQDJe7G6C1cZr6v74LqGcTeHHtxr8Lp4atEXsnF7KI5sABC6mCey7HB3YOmPu1TOCy3Hq0KwA9XSpYH2sVc4u5Zqhb7e0gpt3uEevkY9y/1y5Y3zq6XZfLyYz/HIO3GeDWHxOWnrYTY4PI27atosrJYHeJghNUCXuztvAIrBn4qgIscu4+Fq6sk44OaeMn+Dl+Rw3HA+hjoWHvi549wTdu+YpyRuQDSM0ApMCLx1SALybaIMUt2Y20MOFIyF9+Q9rICYGC1ZKk2VLAqNGbZ2pANAtldEfSxOpEzMHDN01aTOK/hjdO2QGcBtdzk8g4eWAUyBVu5kh3/Mz97sq1hcXXMMAYIKxZGnsRFAwU3zly4o5g4i+LWGIkNe3lllS3oMRBcRdn6F8t92OLIDCrYAgq+wjcMeD19h1vTEQo2NrJcpvMHpwiFFHi3EgCf3uPCNk7s/tovmdsBH9/1hC97pR6WFsLOMXA/En+yCst3rO9FG3qj9/QTLv2//AV6031KXFbaXVKw5xfIfn76/AueePBrZIGAXlVbS31NP1QJP7yALUEtKcBj2qHXdBg5KzSWrWkYUR6qQMPqCVKU7fSEaQoHZYARzGijEwbDRwgbS2xsLPjMuPaHDU8QcDLCMTAl3PGmGS5041QH77d84cksB5X9+i9/bDUYFiVxgFIPMJFeoFIycuuRqOUuC2WkhcF5wCQsO8iATA+F4CAgeVwHwIKeNynBhBOYdrAgAySVU4AGZwucZk8/+cnHD5wDOBr8BD/rhZ/45Z1XmGx4MwRfsIs7nSA/4eQTNviEMQ4A0ODOK5QBxwdUDJYf3v2AN2dwYxXu40IpOd+eP/3ECFiBGLabd86DlWXBrMRZOfmsaqgsvUCTUI9t5slxQANVyVFTGATbb13UZPk2q4AZovRtW8yR278DwNdCTFwevLuPOImj0Vc1bFxU8XV05lEmbr588Tv68EkAgCgfxbvGz8e9zDfAz5w31xnNeIUgffF05fvQsScVgE/4X+ezvPizz0xM+MKlLCT8Ci+2H/BJHqodmcsRLgJsCcFlC2TsidpyjcBlMP9/+OO//0DU97wiwMvKgHl69+OPnz5zCcddWBDCtgDY0ANb8sEDF69/xHVoU1MnJjIAJFYJQLIruFwm6pERvJU7MvjSNk1sigsOLT9nfF7txnruZ4wnmQt/PMAEy2vKWLnwCjQ+GwANOSBveIE5runiwW5usHbR7yG8xyVSaGxFRaaJra6qGgKw+d0stvDFrRL41pTEilCGJYHQ/mvHORZWSBygZJbCWzSGzd4kwCTQwULThc8pDoePePYwdWriialkOz4vhllvGZsVrQOS6di2cmRPA7ANZ5vDeZysNEd2s+p4ywkF07jju2XgJrOQuqWIWNYhWJ5CaDX//J6/LW3VBqJ8rSRp8ydC4r2LVEm4IzxBPFaq8PMvaGlRbLaQnxmqrDwFhMo0rDe5p7YNR5LxZMOh7+ThzBFhs1WAQmU9CSxZ6ckIRg3pcD4YrdgLWbut8WePzR3kgtX7h6ef/uLndqGfvpY3jAWDEuI8Bt54lw97N0cCN/b85OPP3uO9FJ4lpkKhl6HthMESxPsz/MngRMco2bdm4QTDPntixxAbICPG4tmoew1BhGRYHfJVA208Vm0SsAe1aaSyis+XHckj6D3l6VcQlUX5+nvjkemqiPjd9l+zs2kJvdc1IryMPF2Bl6H30lHnZrgGn6NKe9wo+vuF98xYf/4V7fMvBckXfny91wPTr/FQ2EZHT6UDQK+3pa8Dz+TTQnrFOtXZt7fIpK7zLaLswtRAnyd207q1M1LIdt8BLWqgYphvECss67NNWpYs5eM6ii3TaLUIGWsZKNgBr+RoNtTgdZsnATDGnQRc9ZgbzaBjN+GIYY5p7SacvFJNSgSBIZbaxliLVXlxYWFnGhbe+g0tmYbEycgTFpA3jdPSqqVkHwFYEEsVoXAhU3czcaXCDnVxsaW1EmJTZawyiCVgG7NJCbAaXO3YH01z1axeqgeQgGxoToympjc65kcJgulxW4Z0cKVZYmnh1aIhMXmFnQNkZlTiYXo8c1j4L+VibGz9psWV8qVDYpLY0cdKQhyh0Sg9pGGH8LMFFXKgIWuSIqf40pob8LmepHl6iL2mkXnqtnTjL0e3tKaFgiH8kD/+aXpmvtadPfgsfBXAKsAgxpwgZmk0WWcWFH/WaxueMwrBCylE8zOd2XMTk2Ku1aOpZEALtZizabsRUPFIBaJhGk7E5STNOVlkzAPexKU3NNKskbu2RpMnwDaF2cKbAHj3Ju2TCctsVQKyRRCcTWOfwSkBL95RxzSh1gSjjUYAXTRGHw3wZArBmijouJWRkjQgS1VRot3rlpG8pziTSc+YQ6Y5kAHRfHt8exXoTZC9lcBeyt3f3JYTgAoFt2xi5nWuOtdnLYtmPT3H1/4RVfO7Cv9YiiW7w7xyJZv5qmZxq8qkaNl3CV6dVTcZrodi8ZZeU2DRClPtOuJil6WKQ+7Y91zSWHv3Pvm+tipbx7xKFLSbdRDj5kAGiOaIhP6GiHHRq/6qD3WGVgtBey3gCy7+YUGLl2MwfP/03e+5jMleXBrhlds80gs2ZVudEx+WXIzx9Z1A0uOwAAhe7M+vW2TDdwNs4cYG3xuw13ea4VogiGFxYObmyl+BhT0VuEyILt74zguN5PYjTXmfutNkKBizbbU0voC06/G8ig8YXl/XtXYytVDUxAdtzB/bJKMbGm3lxTJwFQT955+bjCogO9w2Q7tACm3cUIEr1rbuIX9EFjWVOG9TLFbn6b3d9c6L3baM52jZyom8gMDr2bhrnDim19LdaimSpGB/JAPR2GvMebcRQopmyisNohmnslg//WSIrTCMPw0Tn4ADTNnT0sorEG1r8IQpBLOnjTWBgFFmxQyT77XgodrZM25G8iyk1xTi6xB9ODaqs0XhrSwGQdufEoGGNhICpob2vImFevYmF8aBkeEQlBHopBlFO4tFFR7sxaiooVayN/ikT5ah9QXfySNkoKWHUKSFKgn5MwNUYG7D+unfxS774dnYsg123D6bzdPzL4wbdyMqYcdgFpALcUgoI27+wZ74C/a9/2+mttqik/9w+5ZcMaNxyR8y7vtHENt5rYulpKXNZM5PKOyX1HSixdsI0U8GKTQtYcXjks0r2/IEj5TwB1T84QFZDzVNVv9qy+C9R+9I3ju69vQ9/K49ssOjefzvYVV6pMW3RK0cXotk1cH3fFUhh1SFYp161/7dBUKdXa2J9pwVeJzLegVYoN0Cv4O5yrRjU1IdtM8jdMB9xIv+Ff/Q17MPJg1xde1/mUaDEwAD0axd7BvIa9UO0+S432Md8VW1yqPAkLwqs8tFeN9USZXygSoNa7/ViRJfGbLCEr5HgcBLfDkoVgW2JoCblh9cF3Ddw3UuX89jUaxlemhTT0ovrXyIbEt/g0juVL3Hl7fgfmjdPGOuwMEa19bGXNTywdBcUoAR04AfFzE8A2EPjPDzT1gB04IaPpSuVjCmyOsLNszLtHFTaNlMYEtSUnBry6hcBj7jP4JCgJeZ2ZNUmVVingi4FT3ZsG57Ji9o8JcSyVo1UyQozdGUik+7FNMHKRNBnz0sbpZTCNpQ5NaWgTkySVjVkwOfFoAcKnT2xBRo3b0gmd4CEdNrqcJw4bgQoimaeLDu+ZFli8MGXG1reRnnxRppqo8ghmDu2DCgaUxmF9vSZf/8bI5mIbulvVgom8QXpCwOmzBhEpIWf+qWh3CSqavLNjtMhw3+1PKtBOKyT//tbAg/ooZL8EbA5gx37cQpsbKPjECN3dB4YUdNPdYEHDt08mAN5ofdEuf9OEHnD2XjtA0Z4599Rp9f94P9FU0y5T5LHPsPxwRtIZLesqEMIU1Li5NNLR1Fjlt62MPGzVtZ+/qfrS4pDZdZo+nUZImtu0d5GubN8K0CdQV8TqHr6bd/+w+0+Pi7qE0+DVXq6TzBIb++diza6hio3kl0JiTPY2c/9blUrWkz26NtYHbOGpXv5C5dF2SGVCzp2P4YfonZybQ0e7l2Y3QOk8FXrfyGzpyNk6MYYuFKGR582V4eeRD4el2/UChG3PKVAcshfg0Q7tbFx/Tw4TxhyIrIWj3wxTz3mVPqyusJThTIf/x3fAs7vvEQX4JOHPbiWvmXTz/+oM90YuEKBa5f82OguKxlJyDc2eXPGHhDAt8aCXNGYFS8GcAPIvPEAF+2Y28mmDmNzYCG4aEEUh4EyFaGSENaJKvg56LbZTMqFNIkGuamL2iiEw3wyCp7xsZCio0MfCsyWoRnQ3pR1urYTXuCfd4AF1LtLnldpeY1YxsAQuHBhW+KlEKp5cxyc1QcQ6IhBi3DWcs6cq+SUFxHXSzgbfMDXYlb6jNeUZUsTKVSOBx0LsudE2mtkk2aLjG+x2soG6qF0iLRLHBITFGTNQfd34/v3U+PnHhuhyTW3N3AhVVsxUtRM7Y9Y9yxn9hnHtCNeLgLn3uQnYDTgji24+rz4/wEAD+i+93PfwIFz8t5GR9fb4ovPJUpOKKGpAc3NgCIXzr4gK9YxS9L8HZ+pk1c9iczPkNlXVTifIEIRKKxndizTRtZESBFMhR1MkXjYcbNjSGKQLP/1Sq9DEUGVshCN9vsYfb8z8RqYo5eQznYTacrlC+1unipuI2ajQZTfdyXGo7vqrv/NVSyxTsATacMJNvc2nw+MgXkE0lthvk6DI4Uq5W5Bv4A2nDkW5HedKrAgVpPlq6NbFq9kMsAI8c1HBaJthLg52+hsVdjBoIRu+2RLiJS5ms9/vtChh/M5YV/rOnwYWJ0AM76iWbwT++/+x7XCHk/AC8Zfnn3w48/2J0eROHShMtULu8QEdF5+w8EgxECFg88PcGthJ/xTYLsMnbWSdvVw2hbv7grV21lmGQ9MR3S5MM0q5Zs5OZbrlhIgwpn4r1RsF7DtmWh0DyWhITCJ/YvSmrSA8omk9zffKaTjxIsHAS1Zgp8JJ2ZmWJqk5ZyNmC1g5Cdrwsht6QLXYJJRV0wkwUGqaoANOWjoQo1XUVbNUqcQXvNIwWk0gAr/kAqSNn6NyrhWJiE8I4cdCbSK+ZgMpXaf7EQ59jj1P7DR/xOhfEiFuctjPhuC425hQ4rFHyn1Ud8We8H7KTY0ew4YPY2h+BOv3RLli3p7bZeGBPN8PikBiC5N9uApcB8l8E0yJ5MNYGgYcPcrH7JybTo0EMFy63WM4IRZ/qhuCn6tNcjGdrY3Y/QncPdL7G3SFUFuA9OPeIuh19PxKeJo2YN0e9Z26El0x0OCUG7M/x6CRy76h/51Qi1Jtr35NEZsK4HF56te+lUIU92qmDVmWhk4lBF8M1mWfMqyhghcrj17ynGWGNWqbfKZX7Eu7F49cyu3OMz+BPX/ns4ZdlzPnpnINxXkztiLlo7SMNLg/iudZrxLnOQw4I+OdlrORc3uGJnXeH3g/WCn97+h/7XeFX/xc//wO+S5+8MfHr38b/a70B9wLejv8dXN/KqPr48/+nT5y///u/4okB8o4gtCkgVKxScOkCDmwS4OMFJAeARFrzsfABfqvhXwPmXf/n/fPrTD/xJV/TyH0knruEp0dcyw/TSuCmaJmPDFPNhRxBSBrjUnVDNlRXBw86comW20bMtr5J9tFpkUMTqBdako5VV314843YBwhVfIkiR7hG3RmbEhlZKBNDgKXd0iEFEdtlAMrAadEiSmGvrlvJV03FoY1WDhg/JlnxawBlKskkLR5kmYw1ZjBjjGmS2z88pljVhvHpOzdGT4aM2BsOGKbi1h6avA3hisk96ff4kEkG3Lc8XnQAdl54OZiFZb2hsK5H149tiOTrtraTY/BtPmLlTPX/87sNf/PVf4Yc/Pn/GV7Xi6/5xSoAd8Ef85lsG09m0DQEu5PPuHrjincD07UlMmruk3TqIcCkgDmIfP3z4yXfffYezfuzWiGXHNHRzatnpvFEz1nRLPdrbhJOwjHnOg2ca1HPfTv24++9X7I7fWCLzqOfxYvFRf2cr3CV6x6x173tt2js+15ZjTcTZpMbRjsfzMfS6V/PIdeNvAYLZJhmHmhRGr6H9YLE+B3NvraMmOZ8yu0vcVX0adDllxg/UXnMDu2A96h/+MPDWZwA6IVpoA6z+FBg4WVcn/pbbw/RrAHbRcRfP3TUSsNXD9Wi60ruS0dvTXSqQ6l8MA0Lv2lXwAumj3qTt+C7UZkAgiAVOgLS2RQ+V9ppKCz6sx7a2hMnziNca+ZqP1fr7D/jmb5h9R4PvuMTHCxW/LYQLXb6ic2X//J39JAAWFlSmJQcvL+JL6bmQYF787kCcGHA1wg8Fwu39d7g9wT5KjHuHrCOtx0QsczSiviHj8IhNyYub4hobkOKyZ7HOEp6RRXisGklPchQFmIukTuqY3hI29jOufTIyIYUnEgpNK+yqXTYsUql0CI5F5JDfE2D1i4f7SC/cHrrc5dK0KcBT0xxoXwTL1lALucCUMltZxc0UOKkrOxTAWe2uQ8HDq2aCJiIncPLMz9Z0B4fNGgWmLx9Zu2rJxHp9piSdzQFGsvFa/A2PU8TsuD+iD/MQ1/Y/f8BPEr//yQf8njHv1MebAR/e/fgei3Zg2SrfdnGI9ozdz0tnM0QZamfQnGEshOINQgD9yC/4x57KCwj8NL9P7VwYKsiYlQrQtEzpG3la4GHhoJDP4mEIMmlsDYowEaphl1VNtEnfjPGyz1ai4xRUgF0Zy9gqrfE8Hv3N8+4VaM74Ngua7pgZmon7PwPQO1+xu6KfRueIbdpJKzptEztj7l1j7vFpQ91GK/LzTEbJGkMY3OdRz6/5LMYMxziN3qPXRcY0btjrx1QN59kxW4YiATt+zKGYOgyK11yu0Pmgi70Ey2xRWm/aWJ9c8os9l+W2hIA/b/jhewv24UI7QyA4g+AjAT/8iJ98+jWvUfIXQKlPF/6Bp5cXC48NP/iLnxYGn6cv7999+Jc//K+f/wThz+hl33ACrnjY0oLLH3uQv7LIetfIIEdJ9rKVDU5Q8CUnZG5nIHpnBPamwbNBZz9rB5UVkCsdW8iow0hlw+xoJVadLSz7LXdao6En09qwGIhstMij1t4qobVfrKUm+xPFlmykQz6ptkKvt0QPySUcywU1ycg5OqzDgxyyb4VsLFICROUcWLbKVpo8aso/80lMYl4hdOzVqEWNDKHJ/K2y1IJmeBjpkrlGM5gmHCuo14Qo0Igzn1KdhZ4x4Wrl5ZqbBnxYIaTW8lhKbpNF7oSCZ8rqx1gsowAdz4rxxLQttA0ZWviEzZf333/+61/9CuNv77BRiRr9+APeAcAkJwo40NGGxE6/7L0DTBZb8+cKaAZxWtPWtPh8wC9+/pOf8Jzdhz7xQz9gjZBo2VZZIZg9GNR2EsM0HoROTsmIbQMz29BvlBdbAzVuT/E9gYTSfMo8lk76X/NovCrtBJ7hUmewMwjLvffhhT94DX5vvFvY33qFsBNfs0WJHl73Duu0Y6bAFPf6Y1u/2+YhMG3WiDQvdW69W1hj73U/57032s3tq1ozopRx2+OBarhZz+ZN/4gV0MgdYYYBx2NrP2j028v6orcmkHytIWBDt42Z8pUeHVphcP3BVuq2F3isJNILja0pvuADg+8+/QQ3DOHWHnbQyBYigmNUnkMAAphcIbBBEDyw0MA3FaJhiwsYQKtwScixl/TNz/ikDUygk1oyOmy1Y8sRCwuNITG+rUBoj0Z80HetymikTQS399Wh+WczkoBNsiaHCE+ZQfnMTQbLz9AEe8jooCJGhc5taLDgCCVuc4i03kJTeMJ1kqZPG0XUFioILkczU3NjvbE2UFDJh88amGXOqSvbqBmUMIQpFNoShle+cwUseZq7i1mkTfRMckSCCg8Wg+6xx0tqPeiiqeinQE4gjqgpYQzStny3mIRQcMSgN2ebEBkeDwWxFNHSopx0Vg+16UgQViVVAR+bwU/zPj3hN7z0oXz8XjHOx+3F2kxhHsAAADbcTQXPzPhITbgav8T4/RO+lQs740c4AJauZgjKNEODeIaRgcDLH7S1WWtKmbMzBVvZeaMQYJujMljtXNh7M/Bw3UMJM7ko+zO0VYay4kNEGRehi+YQ4K3z/hW4w/joMwB1av3QvXMd6uWF7cxj/nzL7sQaxZ0JV9hU0c+f/dcMhYnv69UeW28LUrEpY2ggTFY0ukPu3SPIT44Bs3N/W51FATvZHOM0ejt8ZsKdH7uZKCsb/zzASnt0qNYg5XBrt5JNlBHNXrI1RUJPnDtr6NiyMHwtx2oDDy4AdCXSLv/7tMNFSlyq5DeIPz/9CcuPpw//YlcuEZurYL1dYCsGAhKPP0pk3/z5/AHfJIS3CHATA+42wB3BT/bd+brwaeH95d/Yf/kF27wnHth26fe9/c6rfR+LeeFzy7/gCUW2sZBcQvFSN2+tBs/P7z7/OeSnJ/jicudHfnORfUYC3PHgbwVgfYPvcccd0u//zQjjO91tEYUE8D08gPuM3wnm6ghbQLM8fJASlzx4QPeM77YHGn6nNin0fT7Pdu84M86QyUX3lOu7ZbhWQ2TliHzxDS5/bus0hrP1H+oKDrg764dilJ+/8Dv13z1hgQg/fAs+ckKmOdiXn5INNIhKslYZ2H/4D/Jk9TwpjCwXgTbutrplRBSSv3/8/PQfNrZ4x4aMiJkSp02of8Z/Rg01LtmSdrDEt+iw2hYXOBwryFx8Krrxwe70jIywFX/Vx+YD6kk9L5bnK9b8TV8g2y9FiL+4ffkzomt8qUEkbTk3nj7jm/JRLau27PlBFY016gw9Hjar8fvQcOUvTHNe2/BZCfg70/D4D2WQsOGh7FhznBvj1x4wmr8gZX1CHzOBca03158jjrvlbMbirTXY8iTgy08hqLbvv/z06fPP333ER25QKd7Zb+A4SHJP5IM/OoHaYsf6/h0/qPOJ0wYgLBbHHVac7k9/AjaQWRika5SeP//k6cMnyEyE04jPFBM0RKsMg1qHnkiORvrPWUE5+bJr9VA3eoVfbOmZHlby7pXLfGxnhbLHrZ5Xr0rVCmEmqmc5MF4V7FAUgQtnb1H0ur/i0OGaK8/uKMu81nRgrlOfWCFMkajwxzmuZstEgDFaBTAzRCsnXPsf+DTmCVX6DMAKhw3skwuWJnW0qTXmFHyi9dcvL7UKuTYqnnvb9cu98VnI2A7Qon0hb3rNMymQv/XmXQrHIMUQtqZah4vU8o9uBaKPpK0Z1JI5F/fJmCsVrCw+8pfAsPCAFRYsOgniSjdfR+RiBasKWGJZgf8wtEWIrWtsVaFXe4vCIPjPdSZd2EITRx5uuYTJsmlsoaJN2hmMBW1oi48zCijtKgABKNdDBkMtG1CaB0XAMhR87dk4iQW0eEhLmf/NnmqWSe7MRWzBAf/Ek/jmYVvLy5rsVYsoRkiCehkuxbVgRj45Jgs6WV6GY+ZiYDkW4BbO8qUbRyLZkoONoEVnBx6JGK1MNAfXmrext9yJxNytClorckFLgxSHOAbKMSjwFWypIPtpb8+cLWhjCUvqJgcq6II6I3PipRUqVEKx5xRb8rJdmOSyaJzMggiGDJ2NpCARMNXZ+KGTWdKGNO0hQ+oNTltCCRACcsXWeqmmRplZ0mniADXVExY8Nf3h3QecMPMLuKwDC3181PcjF+ZIm6RozjgA528Cvuf6H/9wZoDCsHaULRRF+tn2y7sfcZIMP97zRyKGYbQInWmQKVnmpNhM/82WDaaCh4mWljWXjbqXtkmyljLKhVmjGaM1us+oIpEm60lw+WIbASd9j5kdi3U3eseSevO6RwU4CTonADza6eUdZ0X1DlFrAMWDXGNe2WGJR+ryUZ1vlQaXt+PZdhV97/ncDDv/rT7VhWUzDvp1QCHsPC+cCZtsPHrh07v2X5i9oubBsYvzYW+2+GKcer67RoI394JH+z5IY2ezPZBLg+S1zLvU09pDU7QcyHy4vuBK13ZrPHMZ8Pzp0w/4rYB3uDrO8wEcIXA9ntdWeazgtXbWEwb4BkP6cWWBFQf8+OGBP/74x+cvP3x+/gk/bPAO312ECHaJnYsQMcBiDlffeZUXrnbCgaefEiav82D4/P5f8/oDDIwec4I9r5WaO2z+Gz/AwGvMcAYsLEEF11k/Pr3/hKvm7/D7ZrilG/Iz8PETxZB/fP7yPS63P+O6Pm+9wMVsfG/pd7wN4xkfj4bvh3fv+X4Ce/GtR/iuJDSJBg1weAmWbzPQBnX4jA9J8L0IviNhvfBC3CdgYlUHhO/fIy7wIeO6LzE/mwxkwyc3scoaj4vUnj6BD38EmjI44+Oi8CITe8slseIPxJIDuH3G7Vsm44xOfMQNWxtBWn5i1tgyo8/PuN2LWeM6sezdC5rP9puyOTurwPMzlpX4FYiPYPL8TnVjlZ4/kdVTiYM6ICLGiLVKVfr8kePy5dMTI1rW6EqxPLplDT3ro8rnHOHFP6BJry2YeK3+K/NC3TgTgAO98YQLx8Xtf/yCmQAomEH/BRlBBp8f8GmWpw9/wjyBnOYAZhQw3/23p/ecb5yZn9GL+YZpbBrmyOnH2UU9oLBHWC9mHWc+dxbbFzBn/h154SP1X97hTZjvP33hMh2n3KCLic7f/HgGHzCHDln/yPepMO44McCeyNn++ctnvo/EXxLg7Xh2g8/n70mbe9kn3ET0/O4HfIWZAqcdHNDckfRAIO7ZloI0tgt7J1PIjyhDF1CsFduSoyaDmB+PLoV/7n+2Y3v2R8hMgDMHTtXreHbc99yIfwJZdOt34DP3wK2OYnnZrAhme8RG3EO1iq+qURaXWrOH42J7fv3TQ1jpm1VtjPpCDNJVOQp0JxreQ7b5gmNF6x0YYfq2vW95d1MgMk8A4FvOzGVHc2A3qc2liQYhngME3dcpqgyDfGVwLHlVdwB+DPbN63gFmoNx+TjZVTtHhcCwYSbxZdhspFY6XEKnnbowRz8dAoA8hEvZYtnSBA1bfnP1TJfvvvsZViF4D8CuG1pgfMEnFzgwwzoSW0bDHT92bRE9MLQfG/jw4c/+8i+/fP7xyRaaXMTw4IaDMl7/IMENODgehS10+ic9evhIyVoPfLkYghdvDuFtzVzy2CoWizmiqhdrJ/seFS0rscDSAi4t4564gMYpwQ9Pz9RgMY1FFb/qFIu8d1g8YfGaloZcbGlhalvYcIEImZ+LQC7opb3lZctTaLhwpJct0L/nZd2EjwMvfBnLvLSgVFxqbIn5PW4Ef/7yHU5F3mEbomMZR2RGNJ7JXjbCNHzagA9kbfEVkrbQZ0a4LYpL53QiweUU68N8YW+LZtowL/NdFtb0gg2+oRLIPAkhGphoa3xQN5yPGUMsNw3ZbbjAlS/HhRysVjq5ShlZXoZvJw+ss+EzLrM2hIzPJX5a9JMPs1CtOBZYoBt/fK2tcc7VsBHh2HlVcRqTTuc0pjb6rD+Y/2C32eCXszguOgHguBAf/DUKqKTNQ54FaumvExvInJNY4mNOYt7aCQOy4GznvOWdPJz/0H/58vEDToEwCpiiUMCP5+Fw5i92gT/Om7/olIPjhdOA77kj2BjZPMSZDPL98u4DeqE3fPTyFrgPeFvA9jsgfP5ob+JhvyU126W0dy0HgdxePYsQVXBbHmqsYJbOoWQ7KRwLwNrHbMBUz3X/aU1MSDU5A3mkFifi3TncCaYP5hpH/cGo2X65g9PROYAjUWevwqULPupdzjQ8AGG31fmrbHrVFA7Njz4s1plz4hS4PtseMooJxRTrkghGemyjI7r8jJwGFYdd54U1+DCDqU6wFXO+kOBRMZxCCUarM++gv4V4KtbeTFEfVGpzPi8FNftiNqAKnTpzDY3ejM+X2ziXuKZfvlcbvZwM/E+z+NAv/338PTtNfuI3A9BSPtzylT8/Vt+/oYV25kATW2MwCq5a/wZfIPjuw++wtrAFDZRc69tSmxceueImMn+TiEv8dHUZS6jnP/szWPFGBS5QUAEeXvAxRLuXARot1j/9hounj//E9wd4PZXLIy6YuFDDYKE+WFRhCz2WerwuatOVeZGP3dRAX3wjGZL/8E9cO8meuWM1jJMErOEQmrdEv3vS1m5qpwYItjJ7wk32eGALDdPhxRgyxLoWbazLgf69Xb2GAR7wghn1Jicv3uJPr9zk7y2A+D8RFjJ4fvgnfgMj00AsBkrb3Pv0ZDeFm54cMNuxfnv/h3dPP7FqE9+yQD2RGiBsXAyK8o+ow+d3H/8Zss06bO2PNVnL0nCLWvqWNhnTxhS9QkhbRMd3UzKXdx/+8Mxvk4QFt2jbr2XjGyf/YKFRBww37DEKeCBraJA6NtSzN/uaPXLAB0jMnvXh61SuM/GFYNUzDtIAATiJj9UZCmNl0wnpZF/ao6ktlPiCWswgbKH5qL3sGXsQJww0xhnMuQKFDM74bC7iYg6g93vUme8AfPiDrruneY6R+vTfcX5mvc1bm//cNzS3kRtkzGpSV30sKNbxGAX8xhdnvtWBn6XJnFEZ2P+cXqwSZHKz+uC8BadX/4lb7vWWr5AZAengG4ZwyoRvAMLbABgmPfIzKwIlTp1+zY6Pv7cO5KgHWpCTMb63h21968inX9FIcrbefmb1WMdty9oirT3qjnkNioMHzposJ2eh1+v0upxt5lFlmYq0dlOIVVeNv/dVyUJwJHKs+p1/1crXIdmQz8o9aprymdfZse+u9U+T25TyUFWnkG9m9OlvODiqj7aDSvroN+m0e6nlgZVh3G3VUKf63KQGk8/AwNFfg1DnF8sg2XONCTUdC4OmY7TZlB1hM9wm1JvB7grURXeND4wLjg6Nm0FZG7hlLZgvvLm+y6+VAuM2wla+sRO+fCxb4KldkKMWD2lhTjtbYPPGA6xUcG8MNFhDm5KdXBbxH/rwQV8uH+GDC//20o6VPL9tkA3z4g1C+lCj+ROHy3RusRDCYRqvx3jiNXsujLhKs2vV73EagCULCHy0K7sohT6fAATYIC6WT9Dw5AC3QsALT7gpAst06C2KJQW75Gi8laoWIVx/IQssSYABJDa5UOMfF0XKlCWEzHh4wjsPykscmLvZpzqYV5Y/4fIzcHCbCq5H4zI2sHHbDNwRBzi8QksZmk9YxqHfbNhmlbklAu7++NFucNJJlOnZj1opexIgc1ynx3fHQ29Vlb+tCGGJ22BwaoSg4IPagyFkbIGJiuGkC714dwXjotxReZYi1YeFVZqW72fLixfaxRMu0GP5izcBoLG7rThGjEQcLPc54ohiJSQH5cikU51NMjmjsv5gaPVRHMp5XHKVmLjios4cHSLzHCbVFp42UrTPD3aheJgvwsUlG9ymBba4GQkMsz0MNL/SfGOtkBFLh3veeFcn1uhgiHhosmKqPOch66kxshqyElZYMOT+AlkV0CzKY8E62yhzlADCEgIm2eJJBYCC2QiBW+yprBptLSOLTV5Y/VPDjdVR/YQ0dz5Zg3B6LBLbbNE1W697abHvsSBt+okkzSCdjVtEux6xCBCaSx5BeYko5AOlgcvtWF2S2jcJcmAk23WKQJLTcLPx9Nu/+3u5WctEdOOIwgMfBBzX+BTmSJStU5t8dpKOLKHnUUQxFJvBeScLMf2Ie86MY7Tf4FNfG6hYzUSsnBqKyKrRHVR5lIPq9YpW4d7vS8ymxb0lvypJdk8v645xcp+MKTS+fJ973Ys8w97sZGuhSMsWbvbyH6EoY3Viaz6sMHg5064ZYwmi1Qxp27oPyxr02v0OtjZBQEuJq6GlQMxfihzFIuT0jRMw0OYxypY2dKaeC3JbHti6XLGMA9di/GceiGnIdNVDXlGGja01mQJkrOfM1aIolllnhlHP9RyImZf0lAvL7K2YHpn2esjeW0ZVCdeYxM/VJmHWxvhzHY/DOE94cBb0+a85Ijju5V47UTF7YH76GwbjFdzka7GRC3NXVZcsVHuziIyTGYcAYvZiAzIY4mF5sUd+Ym49yittpclblfTTXxOnPG4TK4wILGysbQygtxMYXHTHA/MBC/qUL2tkNOPUS0g5rD2rMozLaWoWnMGsIeMqtjhY3YGPTI2VVvbJUnpshZFsDMkw0hV0jo6dMODQxLuzUH87E8b5AzHJnyOV6qA9x/zLOnilnRu9WQjg8zyGAjypwP+chymSLsvVc2lcGZhi9b5iMHE94zJ4gkvrDc2TxZ7veuGRxp2Mzc+fazJ2VOe1g+lHRlw5MNS5RxMWkOeRZ3j1ojd9j1DaX+ci9Gpki76vsnm8YrPj43YYfcnNaZDN8Ky3VutyZxPf3dKuKkvBxyBuX0O9Kk2zXoMMZI/sZxwfs0iPyWpQ88fq0sD71qsJjZSu2cmbS4fgEuWgnhbln1HwvMlLBlo3w1rLaLrhT+sYC84eNrEAt/UWV0WpA08MaOt0XoVVQmaoDkKZgT0tG65NUleKRSv+N+IEEihVpk/dMkraDGIW0OGtiJQEzAzeFnMUbW1kStFnOiGcyWgrim1VyQwtOBnAONtbmUhV1tkd/bSwhyXEfNAyT6WYesEMtinp7GW+imxLfOOq4gaEdHsVM+G4cGWFZzzhrQbF0lYabMFBsoGQAM4fLJY5RDkV36pGQ0+MLsoo6NhPfMsEvX5yBYXFpYH180kRl2dKoCEmaUuy+ZHZ4jkpiQAHbhkTPqTE/3RPhcpjQrPlsbRozr8UkZwJgQeh+U8GgrOOpDVZvlk06wRFncIYdMYnjuoPO74lZr4oFt9MQEuZJD62eDeLREPGgqVM9mpx3+R/tBJtNrDLIkSOkUJlx9BsiQ2vlllHJ++AEcSOy6KGrecYhT0YC1pfcuy+yXaPQET5aoKz0WF3/9Db5N4s9lWgHsPuDNV887k3jAPb9TsAsJZ/HXAIZJ306fvZxY9d5+XbEW9j0c8hxUv3CP6BTb1DgnJvejnZ7tC5xR4BcZv39s1jXMtniTt/vltZXnVt4CqcJaks1ci1JtvuerbR0HzCJct0J6697M3PsD0Be6O/GY3ccJ8xPg9gr8lcYHCdwUut6fJ5ziLRwYojrfa0msksEYkkLGCSrauWpTHD7Jwrw1hY39g5U5KBqhUO0fkfj4gpzeaWaJtGtYFzdf9EoTZta9yv3d3QNj16UWNOKxuhBCy3dDPlVjCQmU0D61lwtFi2/uyZn1NpOW5rdFuua0yBRt9ytRoYWjzDz+OcXOTKeZE4GNDac90yqLBRbzrfMVRoth8+D9P81NwkO2Uqso4TMElU01gCXjdRU9ibks8m2Rb+Acj6zHLNE3pe8jcPoqEXcn6HH01jlbkEwKy66rkF3dI14oUC5ZQvOt4uwQoqMeRitF8CrAo8C1i9Gu6PWXoUqcXufdyi5w3k1ZjeoA78SAweencIMpLHS9LmI3itGHYcZ2xWrgF/pR81NJs0uUo7jalr/T23dHCwvHNv7x2A3N94jjM6ygxrR5nmdGsqG+gvrDpGc95L43ZhkicBT7pfmMgb1FIBzac4q6K82F0gCXjHNIApfLCj52UJFyTQ2eLfOnhc5cPMJKY2NLS1o0Rh4MY0CIeoQm+dq43subVVlz0rtrmKi939kMSVNxvKSGrJcSt84x1oVSAFDu3lmfxz0x3FZglesJA3nJOdUgoo0V6giiR7j+rxIES0Qs+mEN3ThWwaFVHO/XzmMt2ZyahYuUNpNuqUb2ECg6RJRtHWPKAIOoopaNAKGlvOizw3qFzbpJYZCCRukznoQGsP2adwpjE5KhZLDwV4pmT7DLpNtK2Ualt/rkW6Y2fxwV5jJEJpGkEZ28mi3x5QxAJkJV6u+UDwez88/12BM9FO2ruwauOImgtXW+3W9KDykO8GPOAQOeQi+oQ+gPfm8uIV2D99fOAX7rxE9tu//QcqPv5u1b9qLA7xyJVl9DqZfPCKHl35yHnPGkwI0u2552+Nsmrp7K3+HP3K6Fwj7o3nkJJ3PVjxPYHV9zWt420zOT9G64gHWrvPpw/EeBAXjIdekynYClt7VjHA1vuSlH3e+I7PZUrWRnpZF9had1p60C08ijxDT0+MHgnK8Fk8LWzMgpus6EFdrBezxClxWTi4/mhUAcT0C6ScLg2DMTzUiubOlcPimCazjnpET8n1mjLbKlG/bu5qE7Jz0iqAR01aN7LumsRiv0jrMKuWjNqhVoazjcgo+ljOFm1QHTjAPxMPYkSCiQXxSKFzIsBiLfwYhe7430JunCgsSPNSzq3nsdXf83sE/bnXRNY9I3TGoJNk9mp3j3vXPqq+D3/9Cltr1gBfVyvuGq8vMx/G5RsCyyTi3mbm7oMPE7WPAyuIOE/dVRbexRgxzgrgraEKFMV72bI8FJmXLcWjRPcdyITV2TRGC0pt3WyTt+w3zeYNikljTQuySA0ws6CezJ29rlOa46JseC+JtzoXXQLWE29xXjt63MVjkZzhotopRQTK+O8PDw0h6t1gv+CQ0TVyiHrI2d7Di4rUVJqvvZeTOWYXn4fqlaMAhYZck2PGYXD2ZQi24yPriUV44UQLabI+29MiyrkhiGIrOEC4hwsxUpIHfZmFe0WFZPe26/xu2BVU08htbUpUYS5DYu1ls3bYbDlDWDKueFdu0azqnFc4+kV485Ef3dIrA6JRvifvl4p7zxx3xMIc9Yq86vkaE1H+/XRoy1fgj/7dvajBYq6CpLZXJxZ1sYV21YhWI/n0Nfuz39/SIjdz7T9eX29h3E83U/f0PU5rUs0hXZtY6/QYNTB3qsrv/djpPmk+dc2jc5Ul+ka5Gxo4GIDq7sPlezDQi6HVFs+4cxeKwj5+QiD8PkAKmn0XDlilGX/htDFrnMXfJJtwyz2FZo9QaYw0HeOkVBa68xgAMS/I/Ap8flNN8Yj4qStiFta9Zk2mZwn9FL6MwLv1WBDGl36HIAWwfVq3rk9h5U38+gEeq7HQPArjLmOMPociVx6c6KtvjofFkstatnmIeRv7CRgyTvMf3yZkjzTgXjNYSpX6DZ+TIM8N10PIlnGuRjnaJk5iFvlFeeUw2UgkPv2aORS1nYTIZpYkUtW7Ktp/c83tNyLstZhxlvMp5ZXvHKoqb9Bxf2H9E2bOPD/Tludq9lWw2DJQHl/JphhvYqyBZYy5Nuv3mF3v+NnTr8Fv3ArH/1N88quq12Kq/NmrneS4t+3T0lqO93nNjeFP1TMCzcjIERXPRz96aCSmhmEmwDU2vZpUerAndfyqTPmA2r/hbd1LB/4/8BkABTFoij6Lpf8Gtgcy9mp9A+U5nmKvsJyo3+BjUA509Xp7hdpr38Np6rmsQUdroDzuSkgN161QoW0hrWz2NgDYDtYEigwKt6IpolLOx4ggfS9+S2STnisHcTc8HSIJO81L905b/HS9O5nE1KVKRhVEbVmZbCkAMU5sM4YbbEJtcRGT5Z4qswcqgTM4yULGxjSZu6nMvrkpuoumXAyP4OwVrqmSvol7REn49qPf07b/yrUq/FtRHmiYX+VgnCBtF2P8dwA0ECVc2XYrHENWx/X94xjOp/c7Lx7V+VDq6ukXz5bUzrdluUvHauXj7i7HgfEk1eIzAPk1ZQD8Al2DXNJ3LvHbZg4+js2Eg8FOumF9MDNRvF6aWCeDnnQ3Dnlhs/7e7k3kffw97YRrpWrM6NWIr692l4zSVW0VvcSPOFGOID19tJGcLHF1fP3uzWLZSAWdrJFdgX6yK3O7StZGXCKWkupQaltt1ipcj+8GCjYtGNPN2HSd8/sSweDIOAb3saj6t/INTFqzQqzkjhBCWFNdtezOKl2z7zKCQwRc+Y+clj53z6qQRVaNnov3BJxBHlNXJJCsH2HO9LUqTL+efgbzjM2OuHHlE+Uz4b9u3+kq7RsFzP34PkCvhjF6lHv2O/U7OLeRdSRp91Fb7IL2LiDU/CXv5+E7AIVjI0J19GjYvDbV15jTMgYY0635shi/SXevQB6f/Hx3Ah7Q9/6t+eKGdN3Je+VbhPa4bSNZ+yXN/nsQxQFwjba0Fsl5HBaIlfF4apTlBFg0PQz0SlpCaspa24DrXiPBvWAUoeUTex1Fykg6ym5GQdepTQUvmSnKYqaOpX2l1OR/ZYAWloK2Qrd0RLAbn3IR068JcN7aCp8GuW8R5EYLSq0HgqnPo7rQMpeuYVKpuhH7sLmnwsodb8/DCqBuJ6o+hH7rHFTga5ivWxOnyDGbJzW+Bejv/r6oUOFRvnjRGvcV/YpP/OXI/Oiex9zgnCnHPPvc4Gxsm/fNbwar0fzqO8veqUPtlQJ17NVbDtImuWyQJ0BuD6NkI3s+ZAmeHjHKEXkyF8eJvmfkbuXPgJ7xXTJcpG28dvlCsQHWthlg1w5blKw/GAWxHacOITs4drrCDMTYwai+VzVEldiBalMqtYszpIjXWZjJavECnjtKzhECz6zy51GfGx0WgC6CLjhUrfGuA8JN01jVeJNcYT3Ic/PzXcoqjmoRPcWKFkV4m0quE5lusewHrfFrYOso7r1WD1ri0/BT/MzJ2XTtuzECdhC75t96R1FgL/xVdbn21a1GqzVd5uG43VsFdX3HHRF5bHm73mkOOyq2g21xZGh5xt3RzPNkw/PwHQCByboF/Ip12v1ecQKHqNvoH/I84RSnn+RII/aOg3z9Q7ZUJ18z7FXELcvyxXY2iroeYNIPTIuuOIZ09tuYc4TCniZ56ZlN2s+148pO3SsjNDKdtbhyPNjwSFlQqBBoBZytQq6LKllmsivHpVHYj+MtbpOSo7vgjrXGuw4IQgN7CHXGTWURRTZuCeHgQyTcWUCFUr0ezI0LwQ0cxA2kYVPS0naTJMQet61rZNZ6i8u2HYsVuuCiJTRqxqiLT9bqObfYH+XFfpE6/R314vcmsQIYE6+UxicO2luN3ipw0wpwsmH+PS+/A+Dh8rQMZzZZ5TYSdGwqlNc3b3PmlHa/Yq/rZHo2KURhtc/CLP6Rp7/PsHR3pCkCYdw7MLPqSBI+urom55lvW8K4g3BhuaRwHc/ZfG5tt+SGSKtGFXk9m3ArBj88IGWsuoNkeyhiP3HLdhWrqRCQ4XsQM1y3mr4NpfiJil1eL1mVbceQpzdNOMYhYqzCKUS9jQ4DeYWV7MBQeAO/1RTYth4hPUyf8nY6xUB5kq2SudNOIWHpqQi4E2rKfMC9yB5wQaM9WIo2zbZ2ihRmmxfAheQ5CBlyCeIg4pzVAOCeXeEV5EZrjM1syrFoOdTcoibKLe833dddgbmDgu+XZp598Ix3AHJrX52ASEf8d+x9AC9rXe94rzKN/UVM47bfca/HN1LPvWXp2mtPWnZGr59UasbdLRvoOX0iPytTmNg0OSq6VGY6AhDEhfaMb9vGYFKyglQM5Ry39FcfhH5ogbSDDbWOvVhJFbfqk6bJoYHSxoNW2UkojbwvxirAZRNpwCA2HbSnd4O9wj7AgnfTubDZS2hl7wG2vk8pe7lDVux43vStM4sa+xRLVDRCz4RojbvDurCAb2IupmOpgT12eOt9q8BbBV6sAtzxl98BqGiMv1nWjzIQZnb8cLZdRdpQ1Hf61g7d8+B13IKpNz2bzXtA69Cu6XGAHvjFlWz3Oi/Mf2LB8x0FHY/7yDP1qQ7KN9ZzbwXiuEecFOYYz/V8mMhmwqTC7M2EEVZ3bJ7COzwro0WPpYN9d4d/s3s3UGtv7bGN+igv4EQDpbT3iM87G5e2/eJZSgnCDiWOKKXnHPEVM0Wx79WJiHJBLxDSLKrGKNl39Km2+I6IzIz2kJ2Nf98IoqfPRPlvqqy9MrM4RpLjd1AIe/lOFbXzdskUaCpQk4nb8zNaOXe3R68eVdZT4xW9ImaUc4TyOfqu+kIasMGdZPa9HD0+e/U6bqQ5IJ4WvYeTxmh4bIm+UV6lFRr1uJf7aR41ncVrDnzQ5+vid/IE/s17qdH/o407jrQ+1CASSkxa5dyLpoG2mVpbY8dxeXrGZxKwz5efSZg+/mT8mbpl2/L5jO8KK4xyfK1Z2dyiEfYFP4YPBqHmFjVRvgVZYc7UfMamOW9vR7uNHOrfNpjTTuU7AXUCZzBr1oG51641aNF74jMA8msiELXGrQI9iKLHVFXsJPgg3N9ovFUgVwDzWFNWit60zuar513GK89WI73tYAeXQOlkkIDEoEUz8ahjRE3bp5XCpi7C9uQIgtDRLHa1ZNnKaYr1GLzoxeE531BF8Kq3U9wW0UInrlOMC89hs2A4tJ3s3IaUxeW5TPLDDNerqNHYYAGbyiIlaE8u23d8m3FSlWykzt/eW/amNn/Y2E3kUcAVzQ7Om7pVAdSuGsyW3cPoeoP9urJ4mHLei0hrnmUdPgPwP/OFIZxHNkZZ1lXHavV/4jxmqxB2xnbJ7/5WKZShMZU3bUqf6Tb3k+rs81jdTpIc7LHH+KgGJ1lNFnJAfhJhbJYq8AezCleJxl6X9U6mt1XrM+M4mwuoggYJl6SXniFW8jYbT2h11dYjrIUU1308XkQMoUt+oUuiI616IprkpkY+zsERpVkhTjXI1tECsyCucGgb7V2WlXHmKjPr9YntmMoKbqYhZ9tqpsmJ3wuHKA/wALXlcSrVBWZD8pps2JXd6e5/+xRPHqLSJrVbtU2ZevQCInWXgMv7AC1MWXP935yIJVi3PX8UmrdMwapXUunncaJllLvJ3KCjGJz+UKxi34GtBh5RC4YrHuvGJPm10wUtVUNAYR27H7kzo/YDlR67xwtMUE17L7TE8nee+ctI0yXHKGogDTO74VnvMGZFHSxq5qyix2PJM1N5xuZYVpdX7zDgQceDbseq1fV6DBZdehd0+L56AdaNIbS3nCbsO10cXKw9pIcyRTCNG6fc5BO1yTof8swu9kMhEyndfFWs6OByFFyGW+QtdGFFmxX6RgN+Sp8LMMiGPwBjl7qLbfAJYrLNTxtk2t1Fyk2jGLJpcAMlYupvlV3N9lpujubCntQ0ytFDKfg2dhUyA3pQCb51fZ1+RnGTrOg9Txv2AN70VQWKmmKUCk3lcSeFaGC7i88u4ztl8hZGFWgfATjCv/2//30xzDaO2ASfztDml+gzVb7ZWVdNqpPFO78Pr3aBpnH3edNuSxnKuWU61+/p9BhGfZHjcTLw9MAVz35PZWqK+sy44Fm7HWdeY91fE2d7lAsmM0mi1sOxKCBv2ySTeK/JKpqy8bnhyblmZT1uKGvZDPw9pAcbwzZ7YyyPeABwwLMZF8oYRTQOgPTApbcQMc7Y/FX0Xl6kqax9gFDNWQbyWcNvubM/D1hpOxs3RHSIjBn6TEyYB6BLpK+kbUfsS+5EUEGalW2MxuCVIle2fiXNPRPPFb7Q9n5mD5Gc/Bk+K9+K20Q+L2yy4n9bLl5vhlk+P1YEjfPMPNztCe8AxN7F0U0W1Zv0WBXAEB0YpWNejKRg7elyp8ocyPc+zK6vChD9DzkoQNy68j4ZbkQZTQ7l4QAxLVd2BaWMbhcKuenpIaNX03KsPInj7uModa8c3R3C5Q8D9wi74W9BaT3IuykVDrsY7jIuAo2OSnsKvMWB/dkmPxuVVaMgt25Gqk0vV1LAf2+vcd5aV1Qgjgbw0Cw0VwS5K4ZmzNukuWvRN4ONZtVHzrnVgKEhle4Oqu6BXs5v6FZ6b5IpDSr80uCi9irHNWbzW3Q8sQPnwWv4c63OGbBGSdA9hlEfc4y+K3KdWLTB95z8ms8f/7GYLlQeftR37EWeY9hlHhZ2gywKy4uamlo+wTBzug+b7an+g5kvrAgk2TUeTJGgLzRNBpNmTd+xMt3E4Pwa1ng/ChzrEW+YRlUB6SmM85VZ4RthZ+ToLjlq5hHGVGscRIFLEWsvCGCFU+O7pgjh+o4gCnLSpWiP4ELHdYfaE93JrtoDdvnvMvZsNEzaTiHI1P0vEhDaq5amjtoVp8UshI6k3EMCh9mhms4B56sX7Yg9fwTrvkKtC+UlXqtDa/BKka0arOL3R2Wz9nPA1xjHlUPbZUsLPj5dfE5tOaX+VS6B26T7SbPJURtEWfEf2F3dxc9ftR7pW8jaw/BxGafkK7u2dYTX+Poox65HlJXQi9MFge3STtTvDMhuXzh44VyYIPnVm9TFUKnqCheWaNY2ZbkKn7I7rPBk6cMk6OjuwVwQg2hT4+/TKLwHKJ37oUSltE/t2NmHKJ1l6fZdUqXf0pZvdIRmI8XFe5Gcw6LakuRywLEAdgTRLnpD0w2DjmLTLxq77EKBcKYpTOcAoXjAwHuLrps3FVthVsy8wwUYRaZRf45miYS2Hi6g6bJKteKazAtd8nDHGjP5vT1dUoGi0JdgEgS4xchqClwWYAQUkxIRaQpGI4i3vo0KXFDLZ3wN6GpW+ChBwOeFWyHS+Q1v+T36GYB4jTbKGwlb9177jKnMcusFnkGgVc4tJp0zYB+ogX/8DIDMjhCApwVL476aLoPg13c5+Y1z9E7FrifUQtS4aFvXP3rAxjOK+h2yIBQMbhKe3336DTHK6xBFPI/dswdE2Nc2as6A+WhQBGIXHyUfaSe3hpk+H7J8N0KIpGnpW4ONnDc/W9IgskZLo+V1w/BZfTbeswr26SXZWCdu+s4c5RG3YhM18sLI4phdeGXq8fvms84mWcCJNVls1hJswBpXAeF35hFjzdSqaUPu/TqfZDjOLvKPchzHStZX+WCbPxLTiCHW+k79d/VvAqRYdj2vMaaes89PvP8mOcfKbN00fE9/+jaobIpnWYGv6myv+59+TcTeNcXg3BBzdHZFuWF6SHULzC6RcAzs2nQ6No94y/AYApooeuPR4xD1URaEvQ6ualXEy5GijebR+JUr+80+70WLfGZjZLszvnq9S6NW1zOH2HzezQGxUPfldW0zwj4DHmE0t8oJgKjFZwCgwR8eLuSX9TKmzDoztjR+gHbiu5PJMa9mkKugMIg+ji40I9bKvfYJQdS3EjgIXrNsabaCt3xurLtpvse592jds4LgIBo9Mkt60SK7Fb7RJDlGVZDdEYKrXViCdqSepfS93g7Yiule30n7GbMZmyqFQ04Vyten6NbFO0zgHXF44XTlnkLMONX78ozXwsLocQ/RHzrEVigmJ/LSLJ5v0oUV8GGU4M0LQzwalE+4RyP2wnyO7Gf7fRozTN8CBCj1ETNfToAGh4KGj9cK3S4/urCXqWXPquh8DtfDpDmQJxDg6wiQdz32Mh+Dz0avzkrTeW3/MwDOc+8Z/5iwemdp5/HavPoyCDpzBu/JDnB6XbrSpl5cP55Mrc0KzqLiKD1msnQzJ+fuPUe33BIyQ0ayXwy1q5t1xBWORxU/9LUcYOX95m5XRvWLpN4ni7X7uhUjr64rE8MOdjnKcuXVURUnQgR5hRb0i1j/WrD6Mn6u3uKxSAjNhzOoBRlw2/0uiMXEJK+MgxUGsrIrYfFdjhHPFsK1ujp6qcnpbI8IxrzKbootQvA4w0gff2cNd8vzxxVmyVbriJTHIM+BNMJryAhFNP3GM98F0oy1V+FW3MJxqtnHKes8BdcwugqH1Q+7RCPSjVQ2Z/R75+MIM5kqC+BozJHRyz7qqfdir+adOs9U9WVruIreyWJlc7wxN1+quZXd8Kx3ALKCu5TkvE2Kel4cJ/0ynp7ZsfC5Hqk8u0Dcd5fXLYzFZBb59Q/6bKav187HCILLzXR6vZoTvd4m1IZSWNi6UDsU8foTsw3j7hDg680o56DqdJOsXj/rWkbeRuYbjmuYutWM7um6UDtK41eRaansHNGFtfMk4cIsNmvg2LuOtt2KvlHe9hxaAEp/hdVmSQt7NkXLtz4NGqZUKUQKtI4njI5fV+2RuxbeAdP8Ry95Ls9ud1DIeAfdb+8mgsXWWbtweyLXRPDZA8Hla6DfUL7yCkzPl9Hcevrt3/29HT6Exh0ovwMQvgWo3q/StZMv6IEn+x//zKzOop4hfr6rrFSVwqzGmbySBLQdVepcnXKGBavJZjOjSd9Ns7oy0WWmSr363JR2JFnK1Rm8GJ7/ngQPdNPUGvVEPIxTvXVCZ4WQUBADqk8TkQg9FCsfZ5sM5V754vdUkZjuvS4gp5oGW8Za86moTQE3jRSo2RWVOAFQolW62eoQp3knL3aOd/D5KhyEF1TNYz6p0leD4RSLZmltbZ0krEdFrbWu6ZyVa8beaiQoSvDLfTui5GgP/lwdaZt8c/6ps3419Co23Wtl4whZG12liTlG+Sr8czhFbc+Btb01Xq13w9r236Z2PCdD7/Rk9+PH6vUV7h+two7jghdek6LWu4EfkhbNg0qexOREd3vPJ5TRda9M2B7PcUIoymT5xjj93rrsfdu3nj0V8Mq6oKG8eEANTvMkLceh8ZAgLNmjxi4oXW+WakXdCiqk73ct7zsHyND5eRWf8OgwhpFmCDsrZpiRfbShjP/5EcSs0nPREVkSYm281SrA3Fz6LljPDf74OKxYmM0KB3Cpz+OMBPkOLPaAZZgK1GcRLEjQTsBoreTNfgmU3ZWKWlmXQwyeFyAabTiuu9etQYxvrWtd028t++P53nNCKZb2qOOM3zwnKzAa2qff/u0/EIb3MrqdDmd+6O4emoLLJJUZM5wZg8Cxz0SHs+pwnlRG9UTVAUsELK7pbs5OgKhOJXq/3cRs8iwY9iF395BDqNJu/y2HTeYz7wPUQZqlc7NmDb13JZzLfTO7Vay5xjg1YOzIbiYi4vnclTzjtc9mnZO1OuP+ZN83YsefUYgAuCIfBkQmSaGQOdMRMvoCiIOvXHL0/LzqnGwI2Y2LpuuTEChB02ZV+lh7QDGEbFvF43nbIoVMnWuSTTpQLlZwU8MEvWOTFtY956BfcIKyJw7pV05j6EAbhrzzvgI4pRC+vlUvb0vAi0OW8K+nPVmI1fjHY36UX0/Wd2A6WdiCSeeoXli1m6sxaptcp71o3C9+LT6b36qEy6eD1rCLHmNsX05m/ba+5zsACQRPfrUjKVfwa9BX3bJUlwx6aVq5FjNJUmpv0ba06LebgE3zgmHT5phynsMx/K/Sa+9Av5oi3C4xzeDteWw7H2m4A+SaFjRumfv99hiVu++0NRxrljWO+3uXcXF1V8isk4Hce77RmN+94MHMe93qRiy88sE928cY0kkzv6g1Hk6mzsW7csjw7H0CUVMvOjVQ9nOnrNh+Fpgc+8AjHPjCMYX2u7AOUBkFKfsSvDMWCVjdOG7J4639VoF7VMDn9z2CfQsx6oIWGj+0sBo45qP98d3Hf7La6CCjF57l2Jdedi+r3sx52Invcf/0SzLVHWbj+8xiinV2KpS2RW/RpbLJpr4fUfrVWXJVgTHPIvolzflvnjkQLhbWZRcAGL9RpMbv1bC2jJodNTwxu2LEGbl3tWA1HyaAdmRXo9W/B5n29Np0VtPLa+Ufo0DG5Qb7fvHS5vnp4+9sdvDIA7O4P61s2Wn7zhM/d8QWN4bcWiCpIxvQdPAYBYWbfd+Lf4uLxR2A+Ts29j3uDW69aAl4WYsv30Q0DOedcVyyb12gEF6doqjo1mk4GBcCZxwPshYCWOoIOGvTTgv2pBGA2MwDZ+oWB1rYN03pm6Ba4MaEv4mBX06wXFpG0IXQapkj1LGe9JXh2pz6rUeJU9pnRGW99IrH0t4rreLWx4F5uPc2IMfek49Rqte+Y+9Fx9eIKHuoonBxVeA2LynEOkT5BKfVWJ/A2es6fjXfRMPULwardLmoPjPf2lSGbrWHR5KWQ9DtHaO99g1uVlyu8FXlVbmf7S4bHBfQl/7s/UeZOm/45AOU65LQ05d2V7QLVjeGHGfmvS5cQWeFcTvkVZibNTRcnoULg4A3GOFBtB1dM+R3wN3ZFOxfNoE4rpGJZKeXloCyjj6xXu4Pgyzn52hncu7Iz5XBMQXgLkIsYPCGxnXY27kpunO4KvReHNiHwUy0xUrbdibRArL/mXVs9aYSDWWXA6ClhwtZsXoeAa4MdzfacdvaI+AXIe0OfV+H243PffO4XzTMi29jatyvpA8XSQO82jek8s8A8HpVngawg+jXDHD1Ds2Vsxlnc2W793ylUSM727vqfH2GzzqDBqMyaTORl7o2ERqgWSUE51lA9a4T9/QZdeq5mdeU54QREgF+kY77zVyzEYJcouwgdxNiFqq85mfxiZEzfFSr0YhcdRVkmqXPSXh4BUYMG8iLudA+2DuNvGLkiJCUPN1NSveFBxuHWbwawfoq96+PYO4UoIPo3S3BrpVUx8TFssRR28mgaflie/095QuLKLWuo1u/iETTseyvC2Ozfm+XSd9l0LNG8wqbR65xcreqh7m9HiQfk1aw4NXqPqSLmPwkDN4N+73zx/sbBC1/J9jfXxq9p7Gfzekx3R/yiMd6wNoIXsF2d6WNo1B1voDi/nxmqtp81W5WZ7w+afbuHbJm3BdQ6nVZgfOdBTqK7CJzYsSnKpc+A2Cvv3zByeQ+/QoN7PlQ6E8d3p/twgt2VmnK1Ja5/7U8H8vgmFddE1TR9z0XYHYVfh3xPhrxx1Z/m0HrfKMmymOoWMOx5UxvHJ0Z+6/SJpY0ylvJ9geNKCqt4S2gualOBXCYxWwr8qC/C+JhBs5F13KjTtHB5ipQzEfyqntt3AC7uWpN5+bhivJcHK9V4XaIKm2fBS60HW+k9RlVEbtRwAL2hcIWLMbNlxmZMafX3Ku95WUzwJi+hqk3VSQk8rhTFMxW5Kzx5L8DwATzQKAri/TBoSl42vmK3SHqNlPFOWt04jxpI3QzD2Y8/Y5EE2Ej6u27e2ftOgtPd8XVV5drTY9q6wy4tp0pTphfNUCpiTPBwX28lFe0Kf3X7YElwAHrIdZ+F7d2VUCxI/MoTzGbGOVe4nNU+1ata967+Ycke76m12+1BjJBzBjrRNetbNN8tuv368Mq7RLCAhQZRrkJWij32hfuD97sXec+QXs9wKmFsYC0jEjClxqNqucEgTOuLZJn8K72vfVs3MQfD9R67K9O3o6ZvTsUNplfzWYKb5MV6hnXCc0r9FORThhp0h8fu/Fr2ZneE0ndxXVVs+1jKd5xX3vk+3ygVYcLoC+Ndjhs6z0vGt8l3XsGqdO9Z/SvJtZmGc9Mogge5QurdyPYCxm+DigdTMR1VNNoZ9aVYme+CjYKmY90O4FpXsEmBZ6qrgPwby5HKqDiq/79UZCVxlBWmmln59sRxsGnTzgYvYkPUgGN1guO2cnQJ90vGYUX3uGuyAFl1N8VYLfE0Dd/pggqvL8DgCang00JybbFtX9esJPxws3M1Azi0v+qJGSQss+0y3Szvvf8GmuwN8de7mO9KhOvMTTt95Kph0ywA5zNayE1sXsOK5mPr1XU/G6pGeTeK3KoMEw0RGuKi6fg9emiaCPHqLlI5jeZPC93VKNh1c7fYhHSDWKMHbJzNVBcDgI/MvWNPlpVeqlS2NisBiiMSxAv43fB/nuz+X9ZkiXQnUe8N24q3Gq0S6ZXtps07hZdmZyvfDOLA2XafH0fYxZjp7zwKbtd9TxfjUTy0F6MSioLgOyiPa5MszdkujtUcJCoT/9IxlZ/ISwUnCXNmdJUBt/XIip7Z1s0XT8QDrgM0A53PQiNXfzB+Rjt5uyDsqnfRcmNjxFz99crjGs47rWs1yZeR33RTTw38C66qbFSXVhDv8mamGuCOfSBaCVQDX0A9M3ldAXswhWGmeOzHiO01orTsS4EeFxmFyZ5Bqp5dLjtgWOa7qsbvGYxp9O9zPDV1S1m7uRdiL2PK6exxw+B4ZG45xTU5y+Y5TRZm61TDGcn646ZVjz3ivKM72kbZInEYq7zucgx1+U0laMARwgcqvN8ZZTK4DtziprPpK7oNebqOkSVV+NbcmeCdWzW1487Rh111zd/k0DHr1LHHKNcGUoxP2raC3p1Blpz1D7+Yb3/vMOv/MK2ugvf/Yniux0aCXWG51EbhCAlxHr6Eq/fS28UzKLedOaPvauajhr2VmmSVwDbd2euzFNjJseW3xFdN9bO74fpVKlL6VhlBBc5R9l686uXDw20aX4tZCqvpWsg9bx6d4d3oUJte5jJN1gmzcT+3o2713cYfe+I91hVg9MzbOh9r270tb43aaPaTZQJZWvXn3AbmAxHSq+ACrq3eqpYHXn1Glp3dzT1a3HHcKUG80jbZUcrSHp5ZaleKC8ezelX4SKu01slOdEocDY98h53OKBFQPlYQe3bgNL3cFNgt4qbpGTKVuNxjkYD8OVUh1NxRwj6e7kkXl/kZbK9Pu5XMv4a6tDIQSpss5Cf0zEnlVD7kPqurGoLKzPgM/7bYvGayHnduY5qMdaqt9Z9KuCl1/heM8r3ob6O8oLMvYZrRudbAvbMXOghD4j4S3DP9w76Ab3bRVfQvem/1CpFPD16pC15MAfUFbeoamFfNG9X9iYyor8sgSarSmlXvlBu0l19BoDk8T9dlbNzg+V7u/NYrX8X08DvkvT4PKnROzx7rorSVTSQO7ayVKefxXZs76fuXm9O53rXMNms0niO5Mk1RWYM5RAl5qH5MBnLgx4WyPYQw70RN0fKAXu5x6tEZZHdeVPQ9xGUMdAGJLVnrg1vBl8ZpIArXWysmdDaaoh3NsxqKUEmXyYVwXbnNT9e85YrQg/fOJbXbq/6OvfDVyYS3J1vdJZ87PjT8ZrhU+8o2he1S2l3ijSlEbK/wkaXaHxYTszxfiYenevBkTns/RiQr862g7vXJZzFU5FQDefQju3a9Xg5Je/fFFJ9Dv0SxWbi4BNfXzbJ1Aazdag9T2hA+y5xzwYxf2yML591CxDVnAn8byZLPlTFx7q9bkW7b1xWjV+kCJOhbZzvRPDCaXIh1OXJe0kfmeTlWR8EXD4pW5RtKd4iHYwx53anMIkMonnCc/zerN4q8K1UYH5fjDsR5BfcrSKTyXFSmjPJToJPmtX0VLpafyPNOOVx740oXQvrKRwekQ6fHQO1ZWq/v4kw5Ip3AP4ni2hfzi32uDa3vDo7nZSQJ+gdAgrNprg+72yaXKsEURUiEb/6GJFqlUl7XWK43Nl+rq/Nx3PfureN0tIq8VbPSudUV9obNHTNwK/ZIELMFE0ymZshXudNmpdkNx8uZRFo7fWF/SWcA4VT4jz/o7TtvUgP0/p9gFMJ3NY5J52fedDUm6ee0W0JzKKnK3b6Jcgvs17zdvGKYJTnEb5Cy1f+fsJ9RqR+XVBc7VI6Hmq7wWfutWMDZLrbiRUefiQo9GhGF72yyyZ/C9niAZBo7B01eGHmju5CYaIywDn5KF7NB2htksHhPBmA1bUKEabEA8exYjgUJjI5gBm4blbuXfrF39+ndW/wXTTGJ0LhOIWmqd2hMQaLwSIl+4a1I72YEAcDsv7AJsonyakQjux1gUaBTuKfcReHMYITHpu99c5UoFnMpnIG7UFsJvlPmrWT4pWGPFurLxtuuzyKNtOOfEI2Uf0mf3MVaM2Ob64IRxN+8OI1j3hNpRdg3OtmEJR7swKFEpi1JkJNysCZpzeJ2TOL2UGOTbgU6fRANvVCvgptM5wzryPWmhm0js2OUfIxdR8XWGbvfvcRn6EGyeePv1+q374SRyv4mnOSOzyb6s69dE3bS5S90vuV9VCRswGLWEWzh16f/cdr5HVvD6c+/5YG9yP2mAxyP3ee2uZYM4mZygf5Dlglmzb8Ke1Mvj5nBpEieceEsjcEA6ila+L6zWJ8G2kzBSQYc59h4fWxQ4oi2Pc2nirWTOSRDe71Z/x918j1zT/4VABr8PH3L5pAJ7nxfckdpx3qiB/lHsT6MxU9q1euv/vr3YPWa3j4iK8C9atYzGjjIPMS1faD3gY3SyMeF+Zf2YsKoFnEEgcHL3rpvrMyw+GKdFZyHMfYEcc0ve9hfJyw+HtQFyII5JnX38IFTV8Fsat+Ja01AWLmOBbMKTr5mDX0Pii7McEQoNXr0fLquWaANXzx0JHWEQCWHj4A/BYgqZfO+me/zKsyS1jBMcO/8POS3ZCIm7kwNG90Pl7qK5K9vF6ENoKej3seYVWg2zd6Q3D7yJdFuG0KRFcE+/6cS2bJZanvAfIyvbo5uifLN9u3CuyoAPYF3y92uK1MtT+99r3qQv6xopBjc1W4nQ0wvJBkL3hNWPwV+qpcetFvpBftAflB1+WUeoO44rAM9sd3H/8JHFbfXle+AwBreCdgNcK8WwGv0umdqayMbtAYny/G8+8+95LWLXIpzhQREhpQimeK41zEsj7/rjVlPv12jN63GvUcqNXkQEyaiZyM07R1vtV5/zhfucc540gDwTHz3jKwHXbtvH4zxDrYWafQG9+VvqpzDG/HnKiAbHF6AzxEK4C8Oc9HLr3g6buSqysxz+/poV8X5ogzg7paTueUsMqlhxSqNGUfcPbaB9fV93DP4Cy/xxxRBnK4n34Gf2UTfAcRvGvl69o5IfpGec77uNVlscL8Oc4menb3qGQUXwHPvGYJ7qo6rHAmaoJ9fvIx82o+A4W6joJOcB5EOXwIi9nFkVWswWvo1jR5N/AdJKIZlQpVv5LWmgHWnq7zMzlF6zD01cU2qfVrlk0bq4d/xvcZ3wLkUymPQ37O+Kv2qpEtvtHn11gLH+37j9kl5QL/S3B2pX/ToDcF35Vm07hZ7RvMomacJqPHUT740D1Ood6YvFVgRwV0eLnBQWYHhwc3rQ+X0mB7vm5jhDr0gVo52wO+D+UyX41Lhmacez1wkZ71GgvZQcTvAPztP9AmfgZAMZY7NWFtXtTTlv93P2bOSmds5gI3KeLMHqno/Kw+Q1VN5uBp1Qwx7/6CljpTb9wdeF3929kJ3/rqc3qNSO/sNl6V2VX5vcPaZi7Onb5BiCbVeKUEkHCHGUFuXf8O/4G6yb+2H1SgNj6rGVYpVdJLejbYtv/zew6g/a5wvovJqhZn7DbK7S1288G1cyTSuQp1jO/ymoIJb9fmd78bcCxw9BrOn2jYk3dXsgY6zaGG3KEZRtceZFOYkJjcylf4vePzjujB1KMwkLGKrwsHjyrD7ELwo+JR/JhsM9+jhEq/cd1Ozt4iizL27dv1yq0Xc7yi6Hnt0s9Xgy8SepWfDrAeqfGoJtApo2ibPiUw5hSzxO1Be4KMgd963yqgCszPqTgZ71w9kHSekqPmDBmHPQPy5qsKYIbsPdSeK12eknrOrXOYD+D91STyALV8FRQw4PjDsSiOfJTvmcXbIfFwtW86ZM1xaSoP87/W8abVmKd6axrTQwBD+/ZtUecvAf9PiVuXIlzURyFZvdj1m7mSd3Ppu09XcAURA8VrGDh7A+Bld4PlmD4UWbE8z58Zb2R69ArHQqUjxVo1TTaImc8miJCL+m8ir8+2A7tz1ZhhO+AWWUU58GuIslTHySt2M/wVaJBFg2Klms+ucl0UNduTrBbosYQwuPtfn52iPLZmb51vrdlGebP4GiuQZsIfLLfpd2DOz5/NaTu5N+1i0gwaA+1Ce+Tp0Mx0hnB6x95M4zskY1/V8Fj1aq9Cg1x0nIvbMZ+6d37FUvsqbq1valQKdtWv5rWmCdFSqib1Gq+oVXRdmETtDg4EaOKrIAX+518xzIfVtwMFE85IvA8Ljf5obI9gw7bPXBdk9sDbIoMXYXptteIQPUJ215Y0ZtdDVj1fV+6vi61XXqXeNYF3GXugWwt3YsUw+XsU7hTy1pV7w3+rQFmBW0zt+ghZa0oeb+2XroDGyLeYGJDjHwiq90ZMPeKN8Odhb5rmPI19lhoq3s0T3gEARNrD0R339VWK1hF790U+ZK0zJLlOXxFZ0pmLueuOMS9AUaq5UAetYqzDZ8+rwdxPpHn2OQnjRavtZ1gN3AU44DaDX7Oa1NRxo2aT9k258TC8xSCxDVcc4THht5TntikscTakZqK35aYy1dsNpm/doQJevaDjpJU+Kt/kW1agufvUATEsM494DBzbF3En8ceYU707rrxO4cGol3WR4yzcObv7VXLIcyb3ej0T76eI8IOkBoEGXhGc8s5ZMQhaIKd3cvasYAsEa7ZTgRbX+7Gtfw1gDbJ255080NhfNxN0eF+U18BfR8sTHaeTa0ardUXHfgd7Fc5jnYk4meBBoo/q9mjTthjQG5ZN460ZMz1vpg1vSPx1QKu89fZ1sH8klr6LRuGRCH71XMZ7/bj3THEicpTPYD6a70vlpSOTqhHlC+uzCYvcPX0XjhGA+yDcSfDDlI45vqQXKqViPeFrQHNF28WN2vwBgDtT//RLBjx5N/OAc7z2r7IMjOuuXL+65zINQkRiaJ6qxs5z3JjGmbj1WX5EHsszRT7DrXflZsxKvXVcaEQ4jppDudKF1HViXBy8LWgCdYr4MVz7b7tvaQfJjlxDvmfqrxCd5FrxQ9xWN3UzfKJNlGvMM71C6yH09DWHpOnkvhunG2Bfx/JZMt8ZJOwYzipiyLGXV09fYe1RhLjRLcaKcrQ5I98C86X4YNh9Ipzh8Gi+Z6ZzzGXXWHsxXYhQ5+VdSdXD2rvGL2L1px2EUOP0EumuN+J+GmUB7b9CD0qxFL28kNE8eXDpjXVPj2v/BX7rMwCWpOiSd/wdgFhIz2kxxa6JW4ZiptHh1csxsaKOm7l5tTYtb2QwT2Bvajci7LCPxseJnREwl3xEJMTtGeSDvgWbORR3mjN/YaseW43FC5N7C79ZgXj83TR+M7hNBbAT6dEcDe/NVhc/3xr/Yrp74HpHpz0YR2xvevQ7MF7NeXUksY5Ps84HeHbgH0HtJTyRllyJhM8A/H3++Fo+j0nrfNXSo5i1F6B3FuIGlwvHInq19vIpsh+7j6P0zgjHmHWvKBV6V8bzXQ0aWHlv7VVojjfrc+gOVrNKotrxWNRN36XbpMk6T0YswCebPksHhHcTsArPvA/m0Uu2CjmYEK3rDYMUSnxr786ribKl7OaYD18OUO8R3nW94BU+DD29H21EeDQc0cW9pphPzatrKJ3PTMmDDK/KrgoxmFeV7W0Vicmh9+VOZRFqqwHR/dC6Fqu9qX63c6MWATNZ1poNiHt0N+rW4dmwnCM4eThFnWG5u85bHLBjfbZvJrwceSvyqn+yCCuf3NAhNrdGz80os+6dcR/Fs75m0MKryeHojFqBoQECK1UROzXXJul3AKAMf8xEZtrOZNYO9uq1M6nP2FxSiBhIwyXYpgzjOIZOQEpvfoMCKhMreYsKOH5R7ThSt4jbxXRCsihoddzmrNKRo4PxbahRqTvMqm+jlm9ZPkIFin2/aD4Cw6+Yw42qfSPYXQMhDgeY7HKpo0BTvAbuoj1jvIvhDOAOm725gavoxl8CRjzh6B2AdHfm6prN8l7BDnK1aTzHinJteVqjs6v6u1p7wPVV5M0rH3uL3wu9qY/cXNbM3px8ILlp0/j8exydKG9y7RuISZppZhbPgKMsjL0j2I+cerwOdaxN37GBF1nZubFHdM0rEjwpcC7yUhbKDl2be8qts27S86DtUbhoVnuUN2F3BYqBGY/ibvSzDpcfJc4Surs/BqQYortT2B3wgUYtHGFecGpjBOM4NuoTeO4ud+3QQTtQgfbc6+DXRJR1zL22uUozzu4Gr49LbYrx7WckF6+HPgOgX7GJTgty1E7ITmRcjAmkxzd5kBTnx0rD7oP/IhXWBPHQ969hEbFoOjEI84WVl9t7jq6JsK9LjilEWVkMqnf/NL3s9w/9FvF4BTSH3gbveAVv61nv9beN9/Wiv+Ac106G7bc2msr3Plkrygu8Ju4YVzMF0cQy/Q6A/YwldrwMlHobu6L1tLrTOeU/ZpCWTQPvtKpxLhswL2GhchVzKMbdG8Wv34NpxAnEp8SC0qaP85x0hL3nLnkzxKaBc5DlJBMYF46bgWCgc+76/R8lNUbwMSoYjscrVinJ09cqxnwO9uLeazy+5IHcjzLOt8bba18jJM2huo0nSTGU3dBvHbsq0Bmp2ZmgUWmOHJDRi9n79jhcgc7oHMa7m2OcP1HuEZix6fneTV9M8/gqU3QdpjSuw/ljYI1fa8bkd2VKwo8zhyeY1Nmdr3mnngswJX+t71hnNWzB8fkTfifYfgcAq//QlcXOM74IqNPzNaq9MEquTr3W3LMMe6MjHf1tknRkCd7cdLydQTEWZwLtSgfG80W4kOSZBBdfT9WFpe9K6cbws1QH9R90zaK/2V1SAYyE/oSGqTOYPYOunWSuQ9oZ+Cs1f6vnhQOrYsbdAuCHD1kDRwV6qbGLaSrZAVWV96WoHh7cIq/NBA8HWhz31ShY4zMAf/f3Oh8I2gzcULHL1J0+zll0aZtx+Dxx5hTNL5Mtbv2dshHfz8KhbJ7LxpzicPZqEMGbcozYNNiljJR2OZbGYYx6qV0Vy+cIAJs1L7kNFwm18RnNgM9k+gOEM8RK3zBeZVerPcNqxqaFbbqdfHo4Zzj05q1ipeGLPKPcIxT0Z7jVx0BnOzmvApEN8RTPDexD3agzkiyu5RdpaywKm0PRmk6qid4PLCKX9jtnRel+rr0aO2Oy9xvEG/EPZaT5uapVwImzF/LKrMGgrTrsuIILrKRf1XBlut044ztG94rVZqjeoBQDxxpqRuMrkAOjdr4+nmmRl4rQ5F/wPM+hEaWaRQ2bE6qrOAecpSqQNn8J2Muek4CT3jVYcHLX4Bkw+MxA/YBO6ritzV6NhpOzlefoctWDJ6f9TdsB1Z5BsxoDnF5XpNGL1fN9WT3Y6u9laTxg9AcZx9d17Llqh3rA+bBBCZl78po6N961ivmpaBskX7S7YFg070lNoZsEfBh9MA8QG+AfQHtdLirgmeqdzLc5rJOYhwfO81X6CCcNAHuPQVfP5U0fK9Ap4NNv//YfaPbxd5WBnQ/1r53zG4F4F9GTvrNW9xEBBEMZoIIY2Yzk4XlYOPsZYRR9B1hEBKVUbGVwEhkgxzKK9CBr/ymU3eawwnVGupNeaOe/RbjGX5GvuHl9asdugusOXe2Qrj+f1z7rll8vWavZWpGvu6GpMmpafTVKH6+zGZ2oW2+qbA/WWdKz/mAoMk4VTVfOolxht2O8ToxIybQeCS9EMI3cohxMtsUWcPKqWdRw7bgardr6Cs1JwldQIMaARgzhx8aZYkZHyTFKgdCufA3xSjQx04JyeoXSNy629rKBbwGFZvq2mT+wZ+b1rih7DVhrmnwO4BTITdhocz5ERHv98lIPSKje0lZu4VMBqu3KgNfxYYHtSj1ZFvMhatO5qZxEvt5sjk0x/Ypmg9W2RcPpJqqrmFyFM0hSYzE3IisYuBzwWkHcoIGK3aFoNyD+1UL2huOhJo/IFFQfiuFXOz/eEpurwN7ZWEzmmSBwiVEOIMxEeRCbmGmT0kulj7h7QyMX/SER5bWZXTPlQnkJSIH51owVWA00B16fAaDJqiv6dPrwDoCNFzZP8A2fJE6nIgEwiAXy3Zp9CrGnOwNxNQJ9uH+U6Rrp3jfM3C4jv9aCEM5H4bq8d7KJtahdD0fpXctRuAgLjSqsrXMobFwfBYwI3M+/RxExe3IcC7eJJF15J6F13agZujcWTWNXbnpp4Ny+FjYRapempocTCUBuPnYM0HQ9FajHqkmDyowvqiAmBB1hel4xSpR79o+rb45Eb9hOpFFD+nG7SWEjVOFTo2/4T3UPUJf4ef5MIU4aCVPGn4cLghbgwq3V67rmvPWUeyBNL8ecF3bjVHUeI/R6kSBS8zQLwr2s3azn6Abnhcihl0UdJeaV3nn4XW0VNFU9Q18SU/TWOxiRpDuKgzdfUJivWyTZ9dqu1VIPSIM6+PxZHMgALb1HkBqR1aacV/zEDrAeahPgvgaBYgxc0EWz0ETjx5Ij0at4d6qUEo8Rr6qFR/QUILhSgjcVFE39XcXhKpxb1OcqbvfBecEKaJL4LKrzLWZRbfAiGqft0W9UQ8HG+swHkte8veeyQ7gt+g4iI9OC5A2mVBFhROaWfQdoHHDxDLyQZ0Ac7TGFO6fmJYXg8rWV8YxuF+Jawm9oGDIfNZOWdwBQnKWrqFS3I9iF8xiYY0r4dgCc/bfPdbJl9RziVn1rRSeLqN7eU5QYgF1YBymvzRe9t2tOnX9vhY+1qG2b1Zmvfw0YNZou0IiDyuvbaBnlMeFoeR+5WaLt0HH+R3nb84EsfATvxkkRfYu4fn235nBwaGqgqzW9OXwh4WaI1Z3H66RiSWNPk1J9BKg1EYRyE6jJsvQctYu4Y7wmhRH6Fu1V9HovrjVVsDHhXnzBrKJXyAcUm2R6mCrsMT4IemRcelQeR2+j37sjfyZlDcfg+KZcASXLJuZgTJv2m/XTeGnbM947E2ZI7og4sd/1mEtf85dm/G7tGPOK3tWIadxXqhAjlTRXLZvheXkHIJhPiYaJTcLOPmxm/KyjotJ550sLkVmRTIOaW7jQMHo51UlWLztQII+/feOxtn+5wqfISuHFadyTgE+5OHC3JuB1VnTn0It7T249Dk39gLly9G3TfUY5CDFwb3qJzMBrR5cCxO0O5ynThx30KfYvZ3RylDWkx+i/DVmsm1fShdg7kFHGpgv0vQrDXn8D2LpLaD3M2n6g2UXgkogDMg/fNVuA1ZgWTuh79/FwputfBEvfBRTRimixq5L1+fdKvaGwc7sz93zncztRRT1WnHNvyQJGLF3ncYZPB7Khrrnp+61h6txWyTQwKlXnXLl5v7s73y7fGf4zNnWtnPwuIdZhgDlDqYzb//6H0vJEO3KO8gnIxVU7T9wufZ15tRispRW3jq+K7FPdAXwvcM1BoRP3IJrtlfXE8EzrROpAsDn2Lh/iNvFxPbKmVFjGOe+UYBMd6yNArXHffcJwFLx6A8xe7gOXw12rrOtXtFoTIhVlDz1tsc59Fb3ttKXN1UbRhH9gb/KCj/nU/BvkMp9G12HVMcxjXoFk79q/TDT6cZ+SvtbMjIi8al+ng6443waW7tIVJiozngmO7Kw23+Vwl56wijjc73oIUb9CCx2xblPzOfiuxE4N92LyOznx4bLfL9j4ZQA8PgbN0ifpSd8CVKo325g/cQqtXxBW3qFKQVyZ3KtxVfx15leyv4qhOB3m2aNxGHBcowIWzR6BJs5e+ybIhcoinQuRHxkKQ6bE4/aRCd+Z264pfTk3RBeBggYGq/i7PHQbULOk3XexVrl7+rG5O9JtaN8GdXdy7nCGzxlfJ3CJ8LqYFDtmUYFxb2E8k7jvBRF5xrGI9dZ8TRUoBhjN8C1ASKToX1IrO9jG/zx58KxW0C3ODkuv4UNnQjAB4G1+D3KTwpDf6A7jseNkrwo5abzLLA/VrFOvUBFn7xlqL3YdS1Em8Wv3XqD76GOJloids/zFoCVNVqDl+gI6DARy9+FQHaQkm0MVaKQRcDxWwyyo2iMSDC4WA8NNZK/PZC4OOLiD322i4PhxjKLBAblX2Nl5KyoXEprJYXp0lIUgV1cBPW0NXq5szDrKiVQnrixnrux6ch7fNRAaEWP3tJyzmXaoDHUFV+pV3SrLsULVrW2UaQ+/4N+sVY15U01JyWZC8Z6AdoIe2wJhk20PZ+yoKMd8x8iTvXWaxTuQ4HbVPJ+kRLPOnrsD4XrT9igV2qWeLplFNsPz6h2ArJ+hG23X6F1vuESv2k4GTZumskZ4/ZrbJeqj9GhF0rCfYXW7op1h9e34amphFCBoLHxEXLhRNWbwH3bmoyYz/K8qHWJ5OBeuAj+Co4F55OEZZ/UQRRxT3N37ODmBCaaG/ibTeL1TCQkOKj/oKiozb1k4qnRyf6kyIvox/i9FuKjh4zablWXVVt8CJP65mPm8J7fX2bW1jQF8/mBxcCdWz2UNfEHLmH/6JZGKKxB3o7ArC9/rXNjlXhvXd9EBWbkrRO1SaGDsLrGr537mvLyOVUcZ4B8Y03hdAcgIt+sKXCxILdfka5tXrYljEWUl5cOhOhTNzcQ1GTbNCgOPUujVLEckH9maxhvKnb51fQr8MfPCuGiWeRXdc1fLxPDY/BeBXo7doUQN4Yn3eLE9k3+V70qxc6RWvndsHCvA5tCfyUADd4yY4l5FzzlsAi6WNu719fVxQXpzeOy1q9cZphKteWpXaKZZODaDxlc0GDRxYo5RdkAEchoK2sRx+0lBsWRcrMdqhHGyu/ikHO33BN7VnwS4//HhyojdSsSOpZhxaJfpAdvVOwD1cFATEZOF4JrmS8yquwFU2XyrCpUN20H95mtT40TYKM9j3s7yzLx4tFxuV6UaWaP8aBWIoylu0ERlnUjUzFsWXsccI8iLyK+UtmqlGXikbpoZjzZ3JzN51WM2kaPn58KE08rk+MRYwaTjxoCGAr2KeTTIYp102TrsWAJttRXobuGadBC9JjAg9oomQDPfa5V16RI+Oto7ydNv//YfaBPOzErDsg3rrHrG+QNadr++PoPMTxyXLLI1bc23y0YWN9yuqVwWqDj/Bm59Db4OJhtVXsSiV41ZI8xoCpxycDoQ4NMcpUn3Nmo8A46yWfvQTIbQ+f2xK5dteldoI/nmVZaTQSKmxihqToFXI3IYTcTg7sJhqHlHnw/1vI2DUgJel3WJPN2O44j5XPPvIY3yqnzG8wQcTj42abfZPkD9jye+mfMW9GbZi6O347WL6d21sKfOA1bxFaoO4prd9NxzLRRMBCvlgdpfxWrNMd0j3rzjwC3BeUy45LYeL7qbpnhnw/FroQSsLToapxrXJ+OjRwfpuFpD7P6DXKLlwMyhXrnAFMdjEYuwFMcl6842eMbXgOZWrzTod/eezaxeQJfBzYZ9ZDsUYzAC3hXNztTPfR25WZxxb9PlpPL+EU8Srt3vloIPYs3hETReBwhx3t6Bm0Jre+fQh7PzcglBtGeG+KoEZ2JtZncJyGaUxzI4nbN2kMdKKr8eaXY1U9ykLa9iYh9IMyIUTIrmJniE2jS+3GAz+qBiezO9nPz9Ab1cyN3lmoZ6v8H61KWQplsrdTQq9XH4LaGG2vACnGl17V+xO982uvaWY3bvpXFA3zsr6ukPhBi46Lw8xpq5Mq2rfQ6LqkQvYMZqQZ55RA6yr68ZTEGtr0C0Q0ebKLet362ukdT35HW8eurwnlXPpKGv61MbxbLXvU3NVEmbnjuVnjUiKhfNGee8E8/MJ8buCKz53L8yTnUq9Ol56OGawsx8k6OPLJrrg2YTeLcy4hfOmjxQTl7fLd1t/sTjTBNHSXFQ4ny7cf0Lqg/S3JwVPiKxqpH8UsyoHcj76xx3H+cTX6F60VajH8e65zCh9z0CQsSPcoSp9Y2KBW6bIxLBS9lqO9i/3N7L6BoXWO3AJ96zLq/eTHCEQkC+xOw8ZvL9qLvnOwj3Ua9SiPVphW8MsZtt+bphQzjjG+B6Ne/pg+tKnJlpKwc0VJq1FvfsPM38EvBqDITVglvAV72lN81WBovfraUXCjtKK1KKcuFTF7HWFC6DJgLpb2DzWrrO1GEzR4DfFH+TQNNA86SYLWiCaqHsuc+YNX2ljO5RHri8dc1XQLPunhMvDmKU5znPW94af57J41gWY100X5Znk0xTWfP0sZbgzdpyUzMZsYkDX/9zAycDwWXvvb8w4DDouj/Ph4ros0KCtl9puTSFu+Xf7m654td8f/t3f297wLPqBpyygGVbQJV2+QwADDQUtHwq712rHIV3n+2LBp9KEZVLZ4S9T69nmMlcyvpndzwvoxSUhVhHmfGqQQ54FSBlszovr6mWLv22XzFaeK7xC3DZHzkX73OY6SlowMWZu/uSgqskWEa6kiQboEHQtrDtNUWgG6Lndp2+d72kp78ucomkiNLeYibUY10yyO2p4VjP5+yanutYg+NG4XuguRAesjqA/BpdiuKnXTLsrZtJLfXcNHWD6cqDXqKUFwdqOtKM4Agzxk2bokpNm56yqE8PqjDroZ3R90IDcxB94FWTwXEJUMX9BbXZWBMjAg3NAb0x1K17xS0S9ogPy9kZTguzqbjdqiDesO5sg2d+ivepN7butWIJbbvDrDK2NSq7SrFCvnHjRYNv54bKrYq35bHLuAk2UxBnJeF80CaTB1EOsvP0JbwIYYzXgKEozRvMjH6d5q70j4Wog75pBhXYHPGBr7rehmmzRDc10D7lW8TyMZVyM/pNR1BksFUU57bJKhrclGEMdEYWyZtSHVSvjnsHPr1yRZ6gEZs9lxfU16V7QTIPEno1ZKtGJPgxX2/+nbShkh846o07z6hNEPGqf/oMQDVZFoTsFePXcu9KXk9fI7xSjSqH7clz9yL9pf5Fh5pz14E05nEWVePcRE/K6ChVPZq1pofYs1SUepb17CO+39u6UB3eNXvwim+sdpQjlShnG0/KBbdy5tLIYMnC7Wxfhl4G0aw27lWspw9BVmKNvLrPdWU70bBq9Crf00/gdk3G+R6LiMoXZVlFySPunOp3eLyrEMY48a7iwrHZ3DhuNH2mlUsRhnvZNN76/mlzW1VjGmjGa2wz7h0TcV/unvYZsLG9ejVDJMfXDhV5KXWBNV/5PCcxb50hZJKcfrh9l88QalesiFTsa7GrlmXccMkVcBevg2s2hIDgpdhwyQcK2c8fB+rj0m62Owd3M5G2QajJAYaOOajn9mQLHBxwVoi+UZ7137DLNWnMx6anvpOTv69ij9Uuo0KsVLKy7/E0kWHcwAVZrbaxD3Jsdu1WHW+NXgW6tew53F3vDGdn5d0ZniF2xvemiYrYSXpw9+ETWzUL5U0T2Qv+yNz25iL7XYO4y/gYH1T4DlFqbl/fyNY5HtZgRIpBKZpj5FjbXY7zsLCsSQ7cI6WBWbPrjG8T8MWV9aDUGif5IulrcH3rZB5W6BXwRar3CFVaFWTViOz4GYAnrgtggefndNzJimia5c2KpmCVXaXIiI3rN0vXRVIzeD7HYoyZe16j/TwvIct+8rpad7yAEs41kZSN2zyX0nIUqLR94baSBQkN5YB5c6xn2A8wZ9xvarMrqWYiTQRYQt+0n0+n3i9qzRm0ed8py7AHrex7+pXRvRvNUStInBk+jf5MlCLoyWaX88wozNhM8DszSxM8mCCTfNVtIuYRk8NjBGryXdhCmr/2X5GNaC5DmHxw0KfHzkdnHr+mUU+zMVpZsRpxQuPMB7aRhkhCU7AVTvEe7wCz6CrQit7Lm42sp8f6FJkcBQVsvk9y5zqcyqXhXNLnfTdP8Ze7Sh85+ASL9+nINCPiWe8ASJHVJd6u9gKySLsA3ox3Fc6H+VuoW0w2ylflfgvMq7gBZ35iIJHJXCbNLsziDWqyAj40vXGHXn+TgA9l5tk9FKvHJOMTwIWX4hkJuAxBctxexfDMPHGGTgZotdJ7IRTh1IzKKEfHY3IkE+VjaN+411sBMQG6RcDEbcxd/BAYHuiAn3X7mwDW0d00zvZK2xAtiKWV2vU1iXxW17a/SBvvlpu5Np+LtC/8DHJE1GhEzeqqSa6VinqM0gr8JRoT86dNC1nrLF9j16hV5Tfz3g6cuntOBXhccWJWjwe6yDEaa56MORdlrEen1kTAuB9JX2ui/Vg+4ztG3ujNe9aG2eXdYVbUdY7TUsMaNT0uNU7P8rwe+yPmj0ZtPm43i5lRqGx6cXt6Zd2YaWEsepVZYVZMel4z+hVy5aCKaRt36mLfj34y05aOx9hO1CTyiXIkg+zAIX5KIfbWcmN0aqOhBkxULrdSU9sez/j64o6CqrduEIV55j0OQgPO2MCDjmfOav3gPncQjs23ncRWvy9U+RYToOyfmNulS/gkTN0FzcZYNH32KjeyWsHx07k+cVc9aOgEIO4WpUWnvYdBB+KuavCd3JfuSqsTTONVdDb5N5WF4y2aTYa3CATMZo6XE7gc8PJqzM/hWLFiT41dlzN8A7ywAsXAqVkoLwl3ckocc4fXLXK5pCAPDvKABfehdAE1LHgWXbHZK3iB0DPr6QchmsiFvWzcsmj2gk7qi1hNL0SEmRNo2kg5gzZw/1q7vrWyjPJtTyN9BiCP/5PNOM257nWFNpCd9zzHO5PMrmPMgIfOvTLT5XnyfGtAZMHaI03G3QPZsNVYNDouUtUz5j55Neh35sPMwBVZzLg0CJgqTf6qG5hFlMrkZopQmV2pibBclNcMxeNpGs/x9ZgZAg2bUIFG77SqMYgzyDM2PQ4nfBtse1HO6ZuTqnv8PxfLvY9PM4c4LZw/1jUQToz4roSaoxYRwA1FjneQ37nmTYbN6+uRdpSbCI2aR58gj/NtggfvkQhkuAtffGQ9f+2/gR5nTpadZHyfreFbqca5V+aPp8gV2MVMg+JDQ99DOJtBVyE2rYcGW/N530i6tc8cBl/XJdngbp/8S8DZKz93Ca9Q11ZN36Zy7Xef1sMQ2ZfuoN6TQEhcufcqcD7EJJMDZjPcYl4z9gMaEaowi10noxTIu5qgEZmMfcHzBamOuR3oVS7HMpLXfOkO0HuNLijLsXqeT/ZGoV8qnfMF2YswM5lfthp+sKqpzhCbsdlbtGgf6YmhNC5H40K+NbciHJr3j1hzeNN4BTRJvPkgQmQV5fYSEFPqKX0LEL79hxNMkwyeELQtE5NFqQ3W7gyMnnHtfh+NzgUt1t778s8Q1BneB/tl3zqurojE6zSK1a7/kAdc4iOeWWpAdTYMDg5euET3GVkjLDSHSrHMP3KYASxsBjMo1s3TKdzHTV3j3HHFOsyfg3fTjgnN9xqTei7VAMXQwKAuqVeyNq4BX1CjeXVgdnnKPkUvyUJzW1Cnrvy12FzOOdUtXA+TRlnUx58WqbO6+l2F1YgEbvVxo9YM2KRk1xZSNrvWhrdvhUy7wSZskAse2m27OKFD9b/s2BUZRjlEhOhll3o14mvL2IKXH5ei3uV6LnlXFCbDRZcoq8JRE+WT4BFqII85NB3vQ6wZOip37bPR8QXlSc5xVm9WexKzyhrAilP1VAo3LRzS5HG6xjUTxnP8FqA1aPJcK7stWQtYW4XsOrx1bFcgj9MFlk2opnI7WLbwGSIBW9fApCdn7+ufT6ZzPaHbIMbCbkaQsbu40HR0Ywj6a5q9rBKjvJfb408MrzxqW2SnrvM1j0VwTBfO4z8IgmcEIf6JnnqlfxDCkdheShjTOKx73e9jL4Zxi7gaiPsQOBPrVVT4PmV8ixIr4PNZQuy6Tj4ycyOfCf+n3/7tP8Ds+ePvaCwHQGx4DrrlzO3aSGcap78v+ei5FAdlTag9TOOrDm2f+2qbDL3qO7j0r9nMgKCYNZNC46xgDPnAY2bIHFbhvDkj7GXlfGrHgzNz/yiomM6kl2Y9FrDc9CrQ6jQLg73NcZXGvUq8F3HgW2R9eVI9Snv1BU93LwgrU/XOv/PQA/coLyIUqV3FQVNFKSNEbHqIqL8RDY91B2HX+DLf/Ueek1loFGZAduUyBkSmx/aXCCs+xXsO++bMiWrPV2OK0jST83WLNezNt8Fxe+X+SA0fkamCH2b+3t7c+zIVBEaff0X7734f1lq26n7CqhuM0aftshiDChbYzj8A4dkXXo5DoWdU+Ny16QTvGvVQMFB9RWwnUzwwJ3YV4QD+JPPaDLHuGS4SUE12Vcbd3csF73p8QZwPlB2Onq8LD5Xv7aaTynWgaPepz+2IOXKvAj39fRJvRnHOzd6xctfEPhNoTGPQu4vhAGdX1yWZ1sxrzS5WlxuDz6NRujzHxwFUtW9e8ENzd8Sq0YfPAPxPiLN8BkA23dC9DrgVl/yL4Zo+7yz8rm326NdRmFCtNQ2uraJr/tpbfY5bazxUMUY9Dm4vofAqem/RHBBDduCju4r9qonquZdnM0q8th3lXWmSyd45afb1nfd7k9rFszAuZk6zPoWLN50nvCCPfWXgWweJgnCkgayxSPvF3tpG3C05xt2yZX/M1Isw47hhc12OkWERNA5BMfqFZbPptVKI3v4CPQzmj2nNWJNKPya4fWNQOrWdrMCgnh40Cg0CsXstRw5RXlvdu1WnXI/pVOWnicfcozwN0DWsc+maTnfsGuI2aj7+D6CurUOikeO2WQXtgBisbsItRO+Jd46LyYM6aNujdG9952g2ppHrNh7VhOEpe+Krnci1Zp4Q07cAoTUVIrqOmT9urxIdpBuLITlqPLEBgtvsFe4WaC+xF7S/RZ2Vzmr3OJfhhVDniGx4i2dkOyivmw1s1AVLN95gcK5bgTyWC5uonoILmy53M1BSvXAgDIMztOW7WatNgx7Dr0P/OOmDyTEyGug4VY7hvPiAPjjtWOF71moQF136uyefh42lQg3K9bDMLyHmibtAWDWKXQvN/C1AyQKapuXCrIBYOnB+yb77XEMKYXeI+YyKLsrUs0HW0vTg3LJncFjv1+RWA7aG24w+8F0jWUvno+o4+lt9m5SKuEuFd54N7w1UxB03wSrOirGxept89tU/htlZjegKuUmmsGk2NRzNLih1pXD8bSEK3cRpV+PSTBU3BTLk8bc5gW2bVa8Ex/Qhx8l5NT+CJf8Qa5PsfJRNqBsZlNkdDXMs06uiH2W98pucOSuf0HiQChzOYpK/v26G1NvizNGs7XkbLRLEfNN2VwSvTPFOzo1m7+ER3JXUGeOaode2gN1Rounjah29CHpRc4o7jPAZADw+4Hd/80Oa1S8BG1hGxHP6FqCsyZ67n08D7I54zsH5QpDsmnPAB71fNvpe0n4kmnF8XanNZFTb7CpI7X5Yc7i2NeEaqrapedY2NU7tdUADWP+T+65AMK6pHqDx5nKLCuwayjEBTZKxTd37NjdQga+7CA+V3TEymtsX7iz1jvDaNV9jcXZMlm763Y717wD48CNmcZaZutjBQ8Wzf77Yfc4cQKbPulK0aB/lhcz10uY4tCs2R6ScMJoeAABrR0lEQVQ7QNndR0RXOovv7d50zzCXPW9Woxlpk2fzrPpYrCaBQrnJp7BHsyaja1F676vJvwaZ1Myg1Xzghbw0Q+avk0VKKguQm/URq/QZj1ZBml4Rfyz3slamAO8RG8BGlyg3XO51PFFokOmNURxHGJ+pKqLc/9EbxyaTM9kVgIeTvYTDrqwL5nUzzdUwJ2fw5ysQX7OU/gx+zfNaTeTf2zv2RlSm43c192Im+zA6Gwhmqd/h2e2boWNxMGRphuTeXc8vO9aKLsJX3TkizGJ1hBAnC7VZ1VOV3J4/6cj0ya7x84p+9WgmuEwVlwwpwREkvQNQ4Q0UjjWw+Rq7QtUeK737EzswBe5P8kaD9GiJ1Hxqzd5SaHzHOOjFX3MmQNnU76VR2yvimFjt9dVoDlf1m6oYkn3V+fruo+E+POh7p/3dAu0l9pXZY3KeKXUxvV/1VL/byN55V7pVXkjj2NQpJo3zw2cA4u8AuF5CN9b+jgJ5u7l9VrSNsWkRz9ui3HPs5t1zmNbP7MbN6IXjTBZTpKr6O3KTxhSmGRWEJx3PBHXmdawLyXShqkrWNE5qdhVn84paN5GK5SDuPEiF2ldcVckap9b0WVzbgxqiVoNKxnDHqhrn/2SgGNTleLU4YrrBGYGpXTEKSFAz/GPnl9drkspr/BmS2mu3Zk92vVmhqTKeBmeGGEmNwXdnPXRYzaKqPs1ERK9Xn2G0UWorJmOU073Kq66zkpqHT/ZV3eYR9lo2qnTr6DvxVdtxXqv3gnbij5Fv2VvPl1U0dGs+xFmUquEd8DCYjIXnvb8DAIiEugr/jTRy4V4m3To6NHcejcPhRP7+hO82VIcrczeG9wz0aNV4ND73HItvKlZ9kET6TeWDl6U5Y6X0rrrpXceye6hCgYz4SPDm4QE9WZxjJa29YiKxV8lGzZs8X4EHGdx5wjeybMwiqRodoPDxXfOOok1yg7uRNn1rAwxeSW/47TSNM9EadEKz977t8STrsYpXznqker4r+w+sUvwe+prPVffS1fdKnkR2quVArzK8d8Mn3lT9O+ziNfUGznAmdyBvqK7vjyyCeU2ivpFX7K7kdBX2d1XHCym44/hBph6RWnN3nmI4DrukMLZb98Y9V3sfcA484pEnYh6AuqkLuKlQnqYLzbj1p6pucoyanmPa1+J+Wr+CeEYuNFPbqwTaTXLv8FjNok59xnzQqwq40AmV1G5cmK2YFH1bzb3Hxi28UX8da/WJgpHrqq/GWXV3Go0qdUZtBRCvskd5ZdRpzOCbq+ZJfC3uIHIFtUyqafwe2u30vTFqrr255+bP5S7ZOTnNe28ugj4DsLRfQBI3bF0AiSi/AKdOyEZlO5aXq1WQy2HvD3gsEVRef/cnPB/xWGrz+D3Ll5qWLxW3V4eB3o8nEF5qmJr0VMM7V/LO4ZqJ31RZVBXNrzvlC2f1Q+0d40kSx/QV0R4ntbc3FmGv79dkv2sC7DJ+jCqBcmYdxDG3ZW5Ayo38LFd+C5CD5ABZUbaTS+5uPLc8hud8LQdS7Z39NGKaqravNT3fvfom570gPfv18HDMoYkR66tBcpGlYCUfrEBvvEwfrwL2UtjUFzmO7YssYinGjvO9u/gIdkBD43UAc55w03JASfb1zGniQKkUJPRspB8EvX8FBlQjT9Whfo9r4H6/rq297HhVq/061mRvgvNzaRfy8eyqMDpuxOvolclKEa8djmmkI5J9xuDyWbQ5KJHnKoHpRhy7KAtgfu+IR+YoJyLVfBsTbCAMHVAoDZMqBrku3bhWvVG+6fgOc2LnfB28ApuYj2ywke/0LFI1fLuZchr9afxNwLsY9ObsKriMVqXIjecVABrLOwAwueKxCrANuNN8G/AbtMDI+eC58LXWARPG/67KMRbwPCbQwPBazPOsdiEohV0uj2yMdN4eRyugifxaS/j2+nJ03B/dz0fWhXnGcDngNY9/H8tLUnitO/bpEn+tibdnRVPLEvBbgFhLu7trXRM7N2pc8V1b+UDkXwJGqI6FmwZhYNrkHFyvFjvngs0z1AHtMa36ikvTXkX0CkyGcy/Yu7zCr3OsNSuHsjHDpJcjKglWuCbneZXoe9ozTMZ4cWQblIaVGUcXmts0wMfM5nojf5cRFOE8dA+pN0ay9ytnm8wVyO09XNdxWFV3nxQ8a9hHuXBvVmP+SmeB5k1FVLNxd6zbZWGXfZtzhmo+DyrQtJeyGcjtnz+w314FfFp1x9a9JBzjA18GmJ8nE5bjHAvaas4m2XReK2Mdory2YusAzxrkvObC3KfITIzgGEd1q49CA699c2wA1O9KY32bd4oQFlkjC20jizjHohxtJPt8a4+4jUvv27HGyHWsyzRhtoi/igB8z8LzagbdfeRXRGHd4DMDeyrpKTYzS0oZaWIUpVj7o6VvAVqrR9ijviMo8DniNqJxj75bc9bgIZNi/O6R211iKK8z2V07BGCyi8w4ukPBbGx5ebEvD+e51FQHXbXxm2a+Ao9UWJ9QTgqCy/M5zVp6vFmHCTtg6m/C9s3kVVZg77S54Qy+b/3mE1fK2nuL9F1Z6O+byu5o2qkj5yjvhvsaHdL0UF1W1VHPxZ8BUAlXcTar6tb1Vcn5yb0Z5XIDp3058mFAlAusiu1htKbjyaydm856/d0AwOr6zcyV1ETMzssb71A1ec8pd823cSmUaRF2de0hXMlYmfX0K6OpxpjhDISPV9N4jL+rmBF/zxWR6NeVezw3GV7OpEux1VHQdrYbrHbOnyIKiFT4MPHgMvdmi3dLVx/bW1bUdaF35tXDl97TqNOXQZfGGPdcb4/MXtRd18IL8BdJvOAQm9VsjJ0reW/1HiLTE7Ma+SIFbVeFCA2viSxDT1d8iLJ02a06YgWa8so6H1vGFStcjjQ7Yzo/k/tBpwZHRp7mZ//94Kd34TMAz5/+BnGWzwCgAccyQNnuUzvcU4eoNYfB3xxVAcyGR3g4jSi4/AgMr+KgpDST4/Yq/BkcxD25Kx0empNxZ7L71mwOj8VFhYrxo7wPfjwxxr37Ig2tB4EGXUPIs53Ha3o28sr/QWisOE00dtHGEL/UKE+kssMkZi3ZtxDq3hloOcbtjNeL2GgQsY2ZikmtgV7Kr2PoZwquQVwsU+a5AOz+uPTWUjase67XIBau5saI1FQ76qmzqM6Z2bFkRG/sW1+Jmb8SNkZWb1ENzW937F5T79Whp3dEG44iSujcEMEWRcNVfyDUV/r93YANFO+2u/E0YQ5TcjAJwhFm6urUZDOiTw+hJcx4B2GUI4+ePtrskZ1JnI1R7oFt2jhyjYD6pJTrvi1NPTe2PG7V/zhMYoY9VsXRILrskjv4Gk+NeRxbH2rfJ1Jv5LP3nbrom8hful8416Iyq/foir7DzXgMiXIA7PEJJlPi5j4LlGtfgxKtTl4zpBtjHdw6szFY+MLOOMzMNJ+yK5TcWPE5kVfGC8812rlZrT1tMHkuGWvhI9aqMiGtsXjMaxcmuHkRXKgRGnt3PSKV217+vU9NzMzkVXBwQ2JfVrpBo/n7ALDnL32pKNhyxqQK2S+Ard4BGIDftous8oqhlm8b+wS6qJ4AuJOrj/75eGnuHAU66X407D6/TZJjA8yKR5sYN6LUq8MDpr9vBjyMtSr50vUcxNcUwDbOBTWjZiloW7v030lCSo9R2zvl+xamqMCDzMOC1Uyz2LvQ9Mks99eb2kz6PRvfnYtq1PaH6+OVl1AjX685ynXlFxpBFNnVtwAlVUojnBut3FaNZspri4DTtC6VLfs14uKhUUcbBi4v3ful+myv1kTUHrFoM5ZnrtmMEZq9qEasSZSb9pPKOt9xfSZh3ezYIIrV3kqOr470mNQVcPIS3PHayhRRDjQ1Bzb518ieUd0V0WI9By41SKE5VrexV+Tp4c6QdJBaGDPpfb9NzysyB2E1nXnRBJkeTs1Tmohf28QxVW+FDwDxcnYydI5s1ji1hmZybW2ruC2joa6H0KyAp9TzqkPNW9a+TQ612X00g1G4D4G9UQ5UDzmeGa+9DM/bz+SoSTuO1dzvmi6oDwDxzrw/NDHARILrrxUuGZdxuXbxr6F8pbELp5dXT19VdVe0tXfOIX4GwF5LrvwWIATJcWL0E7QF0wKNAV5SPpDcAZfDGcbSRfkwYO14bTogeYzntTSQZo/GZqCeY126O2vEHFsXThLoZbpZopNxD7g/IKX5LHzIUHCX4e71h6C/eczbWzq724d6nRHeCnTVuMWd4irMh8KZnCqTZvOpFYBFcx5nbCnYC8HHUCdfC6L7ONA46zv1gmJgGUS9Zqy+BUiUVjZt1dO7+n4jO495+vg71KeBcDLbHqIPxvRZVItI6z2Hll1b1+PWtj6hnT93j0HieEh2jVcv2ktu1vPyTBEFHHSNochuwK1mC424eWpNm02ln9m7pWgAfBfyBvk436LsUe8ozIwp0unNh15ZVIGm177kLq1PmiSGWXziiKzqWEFzQS77MueULspbz88aUpWv9UkTMpJGecXrfF3fHR3ivsNBphvkW3hnxmWQuyo/yafYiXq+sShRRloFQivRxrsoTbOTSh2Hu79wXM2fXrj5cVEp4laYESHKvYgzNXTfyZF1+3sIqq0ihc8GeGXuwWErRm9ub/m1+i1ffWbjStgcarB3w2RyAsxMqkmozOvk8zPzerY7+yeRQg72DkAs9pWfAVCcEG2S34TZfUs8QSiYPDI30IzjAVlssX0Q2pFeKOpB8Vo0kRDmLZAPJnmp28w0aOb+GssSk43ypRW9DEwM9/JsDtZlnG4JtDfTq7ggbgztzajsxWpW23eN2At5DDju7RF47XqvFRKJ5TqQ12QBJ80OELiRy+MQvgUTYfrQu3CymGOc+URgOW98kvPQfU2kn97abnOnOvoOQOYqIipRn1S27j5PXFfooT/C8IAbaIzPOIvcYd/LqLC8RVPRd5VuV3aXcI70FH3zc/Re0uL9hEv41CC9KJF57bWhGe8LZ3r7gb1uPZM6o7FLbT85gj0Crr8KxwEHgudYpzPwWnWNx2tl2m6Ag6KLDGRn1XbI2nnOk4AZ+FbP84RvwcCL4DSgcbkX0b16Bk09YAvwvUfX3pGnGW5TWaBtZr0JOGnQq94ZAjVm8b6ZF78YgknO0Swei6Icbc7LdUbCjHlF+XzEAYJXjzbP7z79hs+br8s06jxiditw2R89fkbYOvKxCTbAPAZYE5vQbIdSGR3q2a7yP5nfc/oQAFIRzql3ABzFY91Q2M77hsEvhn7ZXBR9F4fB1L+4NAHuRYKG+N+QiMkwng9xLCTP27/GOiJHT3Oc6R2yi2TE6sKglwNeyO2eUNoF4lhHucdkxqb2Vc2/8coP0keX/urSndEUg1U0zyB/O76rUVs1dtdA3jcahRvBNpO8V6ypODLCdmjtnfl3APaev6azii8+BVxolmhLGe542zJd+nXdIt2tePRMEXB7c18YrKV4Hrx5Rn6uXuvAO1sI7eM/5fqB9ifuEt4IWFx/KijJOda2MECzLubMt0FHnM3xisYu743ijiPB9oXunBzvKePeUVT2YZRjJeO4eH00czZGtAhk++Z4BAuPXhNxgeMk901jAyVz47P5GQBVI8aSvB00HIt63wndS1D6GFQaJwNBc2Nzf3QQIGxzHhOyXq/bhC1N4hye8QXhNs9Qz17oGKtn09BPIDe8OirfR9Af5Y75Sq29Q+nHgYtGsYYzRx6g9aAiLOQZtMJlV7MYnUlWyrf7aYQOg7qGvqdsxi14lhGq2fLxD4vJBce3iB/l6sisqJ4XmlFeOJ2TNqph4HuzrjHjoEiubY7lsXcfPBClebzq8l+P6RKup18sJKVSdfHNCkbFjq9r/yVYavs7AM1UOk45kHfHQXTlNyTE4kH2pgTf1l0vUiOnd6/oxwNOTqzjAe5VgtcSZ7OSPiIu9FKDwaZNz7fQC0po2G6S7Lmf4eO+LhRRLmx6gkUs6AvNfFA4ytcRXJgHebN8tApoqviEgaA/8Syaj0B+76yD/V4XpBmLoGatPAD7IgVELremihCqT5Gg9IWy29xnvfsw3o17r45mfrcemr3J+VBCaBJeAw4+AxDOS9ZJPr3jOcVat77es4qBcwzYzl+bDHFXONYoo04lWcM0NOPzqobDOVWdSIEXr/fErvM8j11Z2SQcSVYyvDdm4yCvDU8L1qQ3wKwYXqzY5jyc5zNsbpdds5gFpcnrKzpSsBpH8xUZR/CrlZsV3sxihJDZLtGL/G/T9HAFeVAtNHX8+ohReClfDyGETdg60O00gxG53WxXOofxzxfQxyWmP4CFWc0W9tBri4xc8MEaALqNhEij6IpNhaiZRBvJCi16de+MRpRirCj3EOoi9CzP62f4nIwyGMF638fxGfYzV+iL4R5Ecf6Fi+t3Cb1Al4CLyS1CRMwLqU6XbjsmLCJJNOgj1ZfCHavzQjNN5EEMV6k+CKc3GqsKaIhuOFA3hF4lMtXA/vTKd6mpNCeNzg+NilnjQKO/HpPNUXBMF2qoGH0zYu1+TFPzcQ34bOblQd1LGjU9o6LXvb4+4aaZzg9Hr7DFuMhsL6zsB16Drh6xXfpY5Cg7SFPpvWPhmO+tUx5zvrwX6egPyDOpjW0iWqQ69poMHQF7sgjUgMfGuhllM5em11gpTCc/Nr5BL8ozqlCkJ5LSlEySdvAOQPAoA7Jd6oL5HjFfaZvxGYSsk7zDGfkM54GNGOruvcnrqQO0XV1Luebqj8rDBdsez7ra62sSAtjFcWWsuPF6Row4mBiOsubj6h2CEHRXd++eS6/PUuEdEY6bxmrMoIztZ+o5E8VtNHkO12TMJ45LnCFjL3GLlGAfmzIYgNTGnu8uQWOBGQXAQbhdmDL22ei+HkKCb52DW76IAD6XPeaObLvCDfaayYHrHYV8IMBH89C3zjDauNKFATe3gTDg6dwQaAZNDCO45EGI2nhec3xuxJkQ5fnYfcteERaPqyMC+ZIKj+s5CLFyvCK7OtYqxFLKI1INDpTD+DP7xRGWLZ9+rA366kbiyU5Sahe+R94BwDsKzaq2krhUV3CP2CCkv6jclJXGyySzSe6RDFD5E1WKrlF+pAwv5aKJ+k2kOlc3leJuBUGgk7E23QfHormSNKw2g8IHcU+Gju6KOBO3QddUjuZCz3JGf4bJDP7tbC5JX/QA1RuXk1FmyjsTAjjOUHLcziDcbiDug+z5XhsuwkLWw4WsuMfzPQdRsbD1vwszrBOpNReGuwvU/hnR9TjyDgDAnt89dSFvV4JdITXMxpVHKzTjViSbGnSNp0g6M9M3AMx/tqFVFxC43QM8kUh9rXqcXY/POaqqdA97St+jfY7YVOgDRmDbyPmK6yUHyPSvJbTBblrSYhzH3FTDGT4OO2Ncp12Ml+KuzMLYNXpXpvsaQhPt+pr9JpaYb5o5shcKLkUikUkPMOIU7gLsOW7qdQV6x6fFNhHvbqBBPBw21hYgXl7BxoHbHcJmr39+ZuA+jiImzrOJowmpbW0w9q3to2bMLVreVNa4xO0l4epRVogV+PootOqaa8Qabh57m5AawfheazQbY0bLKHumdRGiGeTD+I7TPc6otrI7t67zWLcR4hguET79ivLH36e1Lg4fsvv8N9R/+D231dr2yDsAdmQS2h23mhnzAWEvl+a27nUNQshlPtZhy/ZIHoZbO/bA75ad0Yl1XfPb2WoC3TeXnYxz/kfcXtSnN3MuIbVryMAE9jN8BLsLvJmOEGJEaBw2yk33vUohR/wxAoiJmwSXx16x1yNCgDu2/rcXTfYR/LwseudxXgQBBbmwJg51LeygMh6xaTMzNELAVsZjwGaUV6GcKcXeRFQrIOsP7r3qeXQZ9MyaBBy82ftSSk8BgsuXk7kp+OVs+4A+/g0TVY/36EzVEb8DMEJrBKDqwC/AhTPXFWhPvzLa14jXGKK8C2W7gA99jshc62v/qsDUxFgXqzlH/J5R2EY5u3oJEbAJkA3v+IzrB2DTq8yACItmc7V3FU1JxlQbc+/SOROvhUS5ziJdrZne164drcgtzhOWdOt7KsRkzMfrDDOX6yKMNR5CrKKxMFFDt4m95+XI+UP4ZvEmcuQQ5aaxlKp5nPPRUfnGMYJXnMYFsuMApK5VYdxsxjkQDXp7VrS5hVzkfj5EUb04vmNwr+3YbLJ3ldfeI0/rWOF5iec4LxnHmSbaZ3I8POWWirXyWnrHUuVbZxcBVvWPHWtZSUUo362kVDPJn5ejkA9H9F1jb7R6V/E33EJ3neN5zAC/Fq3+h/G9qmvQ0Nq7jwTXnljXp7bs2fT0hoAxLxNavXZ45/O7D/9U2zqLg+8AHJ5yHviGwlXkhHMVWi9hH6meweX6AxntJFlEKJqXJXQM90ZegFWVsI3livJlmX8VQDMD4SW9dcY+TDOsQGbSbED7DALYwh3bY/WRo3wP5+LuMcemMhrMyEgt/s24XGujoYnbvfhFHQS1CQIv/RWWXo1Cf+fmTBZniraZTlHVTfv7GGh0LoxVDLfje/oSoG/Oll1MAPItPLx0X1G+w1T0QV2kLauu7cHPANicWYMOz1dOzTHFGV9vOBVgy9lnTzTs5ltdJ4hePRk5+mApU/3K4I2uijUz6nGDfj3UA0N1eTbKyTPbG7YRyCF2UmpA3ULl9ACuKjSiHJohDZw9qpJMn4MXVvNQzcPXXWY4xqL17J1Vz2BG37v2XPuCUqxYM/oM7Ro5apqw0WBSFtuxcS/3IlMHqbk5AhOfmD8OdVhQxKs+FdA9Ylf8GrlXNpuKGqRwAR9UMl4RZ2FbD0D1ulrmXZ0o+Tg27QaBNjNyQIE07ZvRYV8b16/4A24e+g5CTfUIsfUeVGOOE1HFPG7tXlevBpR7b7+oMQuEgkPqRV7o+FLYvnwT6bQJOzWNiJo3eDfA41wktLOBdvUo0y768Q7AYz82Z+Ed6N+Bgw+LC3fIaz7ETlYyj1uE2onRJ3e34QDj+NdjVCTm9KLelT2QW+sjmUGsgmfRHDie6ZqJMsn/DI3oC0qIGIk5AQnejF4vJUeeBzjUuThg3VVriogw2LQpXMZNkHE+Y8vb9R7gMFOEybxmoG6XuyPP0zhQLkQBvv48oislRP0LyvN1uB3J5sypqzcgoCyaOPDq6QvARyhFQanXFNVXRLiXSNZjiCaygcnIEJ8B6D3WZ6g9K9dfe41QZ6Xx6kiUPehJIZ4lN69MCL9Z5m6+J84dFUjIo1HLadece2fz2cOmzJ3OdIsMnj79mvkpu02esIw2caQ8l8uFGEVjoRxiJtFGBNAbH83ZslLGGTLey8a9MWpHFjdEdyEZRg7Zt0hkvMfVdcgwZ5/TuFffsuVZHA4wfj8t7k0+XkVNENo1cX4epjTpeL7azdw9zR4NT5aJ5zlDryy7Y6xG9HKDA4JHhC8wF7Zxv4jyMEb3iB28InPVXJ3dfaEfPUKFCIsY+ShW1Cx2LvVjucmMEKs6Y+82mxm55UBoRi+QNdCq+TLo61eEOoRmoPQblaydd2rmWXXfK6v2oB6FuO9HGfaom88cr6G4jSsAG9jLEnWO6YgGNTbfmuMlG0dQM22n8xK+fldnzHaFr8bEvhCPSHJSiepkdzNvELqfKuSlEWiPQyL09G79LUAFz4d/B6Dge20TldOcuBb2EjRNU2y78/VQmGP5HvIqiFvzENChRHc7OV0XACE5anbj2hzzvCHo7wDOXpcYVL53C32AqrMd+J4ciAFy0eVkmhGbygLh2qbzuRB2kAW6er09/YXEelCavbcoRS9ioReBQtlrvmChzlAalPd2GQG5Bo/KutdzfPFZ4UwOC4Oa9zCLggBBmgJKNVRXdJFZNHYZgv56oV+jPmbkmb7GRFqc48Cu+4tUl6ZLT7/92/+ZAx7OwLxvwVqrcis/L3bXSbfE3s0SBQaffpn3AE6cudZwl1djlEuL4WkCRf3ULJR13g2Nj0VNSVdwP/+SXmE+N0CaqlFNzKGOWOBsIsj+SNpFpLlmj3CTZ894LtQ1Vk1iNfQmVeBs2tSwtUZ8BFVj9tjOX4k8RlJxFaV7ZbpOpqXppQBb51YkPnDxCO7rmrEQ33sZW8beGSbRfkaeYT4fdwYtsppBDtf/ouuUHPkMat6jEd09XnFN2vUDfLeRgHBA7gUtjItmk1K0OQB7psIx9Ly8mcUAalf1zgRqcjhQ3ibOHZQx92toa6Uk6vPve1ycaiOVUmWZ5/cB1AmVBL0DUHqMOWbr/Dy23tsLanGo9rq/2c9U4O4Vvs1cmUn1OhvkMEhj0FVQkOUdhqBHKYaGrL+C5Is0H4qMKhBrFWvSq220uZF81XghhQEUej1HyVFzo9TmYZ3bvMumZW+sC8dJM3jdgmRBZr45Q3tM+EYTAMTGcedz/AYtZ4bVy1KPoCr/1dffq1RXwIvzagUm1x7Hp8219Ef+ctjBh4qKyF7dg0AbbvPXEjaAjnYP8tt9tWDvmaKdZT6Hb/+tk9jNIU+XGoqavQzbKFGL+pWzJHBWb7RP8t5x192KB679N2L3VdrT1O+JKb3Y1QdI91ZiTPmw8QXziNCtyAh0Xx9C3O0Rxnp/zNb7UarVfqzdHseqdNUMjNdWo6w05q/9R99in9qcsT2D3pgeq9jgPuNizDwXD9RjWDgeaBa12ouwMMz7eIGwG99wrppdzZo754LqoFnMQx+OJv4AZ77L594MW9g4pfkQuyydT+HV0xdmm816nvhesOm7aTBTw00QGVyV72S4SbMiQTXbUyK81kzlcv1KaTKnhpnyKpLF1Ocvgpn24z/R67lcrB/8DEAoYBmzQW5SlalOmt/PDNmGhO8X1yNdV2OHvKeA4nkGuZAPM9ga3ExrX1nkFbfz/l4RuajpVXFhHrC2LELUBg+r2WSuURN/yXELvQbl8gSvhZ1H2yzIgUyFeQbZESCcwTlA3l2cg2tc8C7R86YbuKAub36VgnaQzdQ256RwZObGUekhvNc1TWHSrBi++SGbt2zSO6lE9JclUPPXYEk/WfwaBJozvk3A16v0IXbhRXKJI0Imo3cAxPTI7wAotRH2seTHteudk/X0xzhELyB7Qa+67hLxJU/yHxenhm1q/FqC51V/R0HBx+OeuOrgGJEUKEDv29i1LbtbExr+nukYa6lDbReuB9SdV2m8BE3AEb2mQ6Ws63NiHCv0WYWy3LYuuDXTL+bnALTOfWCMLs0Z2cxcvxTb+siQGFbfYtSMvpekgxS1cv0uwfejhtfW/G8y32KlmaBtI+YB1VbEBmQ9r5q5NDyzqkbIPcvzXkx4zsDWR+wl5IQ0ZjVFYB1lcywVEciD0IO4Ay8nEo/22PuA1ntfwl22ha3530Sok01HFbtajN4l04A/k2MznCsXWFf1hV3hxsfbXXH7jG7V08w0jshVgesq1ZperHlLIaztMQKraQUbqVK4XAK+FQDTL2EGUjz4DoBFeX7w0U8VeHuqK5BnRd1zueaGoc5AP8jcXe2r69pfwvASkDWvO7VuxzwiQ47N+dyOedX4V+HUyDOaM3vQDP5j2iBr/YHeLSrg4A+VvjK9fL5tAm4aHKvSALYe01pzLOimF1jhD+EkOElonIMLm2g3MhC38+Ce3XmoOyC8LrZ3KIiF0DsAmrApZmN+NlQwptfyPsD6vCTwD2e6QbsS2/grkwsae6/wKeT5edOuDHBZwHBgGKZ4bYkmkzoWVPkqm3B9tACbpDAsyv7OePav8gtDctTsxz7lUVQHWMcLZHucf79yjXyKaMd5OJHbdW3vFxn/ePoZQYlrxGeu6Ge/fc81T2VblL02K8IU9kXvrZuiNx6RgsMhwnSyEXl++gy5UZVdHApKsdl7Z8D1ii0Su3KJCO4ONJcjjb1yoyJ7IYb2zUxT0PhKHeUhYKNzffwpDGoCqqfMwuvF4le7LH3TknK8anZthu1x9nkChJ7NJnhtoBo2q1cbS3M++o3m6swYgfxM9F6OcRR69dnUR57iM8lqEzkZTO2DSyqffkW/1Wd66/zxqYAlPMTpbwEKbhmAqoY6d88+1yRnPV+1ndJ+ieQnx+w6akCqwWrNCw/nwxG6qB6Tw31RtAHM7gLvdlgHLxIvmm7b07vBQDjjG2FPZhqh7ibvz73OstbcjT4PSQp/mETtWGsO5HMJSC8uRq3+6xm/lF4ViNvzTG5a1Zqe9o56H7kzjZrYVZo6tauQezgonf/BxivpgjvWGnT5tJfZtfyFdi2mpzMUQq5BHLgEK4j4HYB/oHE4d8wG4fwDKuUGAeea2AZ7DUX2GkRudlmU212fa8bcpbx4UJEvEL/YVmWdq9yc1Sozv1IVtfPpHIgYA2W5CTPPIsOE55hXlINJQ6xDghmUOo+P94zWlg24qLI57FfcY88uWZXyK9bbNMIeOg7UHIOxC3rjFQ4Z15rIth9Fld4M2DDYLkJ2qrkpqlgJJ2qyXzqyoSlL108KNcMBDo2rURvYT3K4xKxOZAB7lLP7IRpk3zKUz6VB3Ft0icQxZD/+eCae4S7AGmeXuxvXe0E932Cs0rvXlFDN2ymvllFdIlQvPoqZUdtH43m5iDLveMyySTty8DSP4UevCBv1K1kjKFX+TIIb+Ax0zaawGVSzEa+ttDwxf1QoIeh1Vq/XIqDexszP81wD4cbgssl8M/cHM+gkpMwjVzMM1ngHAK2giMYub/Sze8PEod6EtNDQ2NQj9AAFAqmH5HW8NMXs9OxccOjC0vW3FmomtebWHG6Gf7yoKMKBOtQu0kQekrGtjefrEAHnvQpLgFyCU8DetLmfMMocKy05am7KdwR+IYkLoUaMX3nf5uQpDIrm4ewxOvccINAumKMpAs7knnwGdSt4Diy964CL+14lbFZPJLGVAPtHoH1V+iOczdLAmTaD3wHofMtpvFa6ZoDa9sO2zv9o3YmyRl5aZ64S1eeItWaJlCWQRGIzltmjfF755jPvl5qISmeh2BqX4UAurnOSElXYMvgcwsiqPxsXr7rU0mguFQhHKNqYrt4TW4LPSqQUxkLXYzYwq31nNdNyZGR07LER3UDxu8tgXtTwWLjaqx642sY1NVt3h6Ai+OB6lxdHXWq6/ebRxu2dRiE0rqtVo6bQheMdmnG2OE+vzNUEvKgCVvPZKvz09Jlh974PHPkL1LO4mvwK7xZR6tm7Cjls1HVYmVfzDb1HRrmFswq0pxFng+p5pgKKDBzsSlM44Ui7h/VuWx0f3M2bMX3vPSNMHUPCCDoTBUVz1zF8cv5oLOL4TvEcFqLgqUSwVawxvmjrqN5YeU7PinqPqzUxCZF0jUbft64vhDFmYYzm6jMAvRGKBaLNxxpnpBFskQ8dYrxGdxsTTtO2bYT7aA+QhEssScFz0FVYqnmAQBMHypnQF4bLI/xahrpXtlepv3QcNypwi1jA1LyZmbSRn+zl7jNPzaYZlG4G+VguNX6MNZaPRRxjHujdVedYsf2xlLHnfbB4uwjvJ7nDwzPZ4RNMlf/jpBOovZh4oBoHXG6aXuQTp/jJ2VJzjoHq3sfRvBaeV1WsOdCuvLgajgv2kJvoppShfTHo3GcAinLEQEWXNe2rgRBpy048WwgvoBufbzWLGVmOc910j1CFPEYujGeaPTKXB8pkAMyYm9dTs/3Uc/M6HMLEcVRGyjeRMGzJ6q2D9epTW05ppq8rRLSC4TFKvQRjoMvlq0YZKasIlzAs6umYHuVMrQQCTBccvxBg0Hycid4EPKxcGE7M2520NQgb1C6bP8Z/77sKG+Ru373U/9JYU6W/NOIMmM+fJevhrHP7Afjm/FliDVCKriGrwrZsrn0HKYi53HfN28mM6lfGkup0ezJijRc51L09jWavStd83Yejv88g4wjlGiF4F7KQ5lg6DuuAtVBELAyOxS1ArNlBaoa3LwIieX4DEN4B6Pi2wkzqgNiMXLpPGZVOL9M+SZXlPkR8b1xFUTjfHop8odOx1I8QKMoVA0d5DK26jW1u3Qu2MZcDlKL7rdneAl/8PYv54WuSKerpNkUU1+8SnKQLPXcYNBPp0evhHNL3gh8CO+LUTP0I0Nfnc4fS+OS8Q6zJAdrFxPlPgj+g2S1S2FXDB6zJAUqDMqJLBZFNLE7tVdtskhG+O7rQdFRvs0tKoQ0MTnU1w1tFQs/+zwCIE3ACSsHzqf0qV1hVzcNnwEDaPO+vopWKqXsHS6cdbZUrzkidDQtiJvp8jjEK8Nncuh7WHM0YsXfmPVcCwOObv+ds56yKewHlhExnKgnjZr5+FaFNwWq4+9t+jmatQWzyFL3B1RT3Ojdq7TKMtdeOsmKt5vP6ipqTGVQDNpx/2dSLAwWUsZlNpp7j3hHlGecx2zHC2Lff6wUYw+fe4bz1KIPquU1GnHq+av5chTNFujKq97vNGRKn6ILXme2LwR5p5wzYA32VbX/WTe6qNxn3PqvtvIOvUuglcox5mjYT88RfGX2frWfpdjrnLJzDYZjm6z7QXK/s6iJDg4fnbq25TaitQAQeA0kvuF0hHGSOyh4rsSw+GxDi4VeBd38GwOMPk8yR3fqsgGixwmfhvlb/okbe9PJpYOLYSTNZkOg46ZLNnEtW3OB5HMOLcIPIt4Lcy3mv/a14X417SV4AqR9NZW32pulVYNcBpAfyrenjkcrndlReUhBH9kku4fJAl7A9DPI2Aw+XrnD8aioZE9Gc912gSHlv8yocjxupuvICIRKNMSDnR/oMwN/9fVak5+hadC0W9fWM9fWeABLEGm7YWZs/kKauwDy5MApdp/nK+Hn8JqwwZTaP36VoHetxH9u2e3uV3IXcy91ThgCbYtsk1INqGjeVu5g3EaSMbAdmbrxpAwOfLYVxbxQKswubdcQeNwWVfePbGyY4aRqscKxx7KrbRMCRSXOCac74dayRf+iraxg6j4hNbmOgWNuxpXov5zwTdGBT88FYoA57x2IQIiWejz9jy2uPHojlA7SxB9mVzvl3OCPPKCu7WjPOutcbcTwRGWOMpNGkLXp7gM0ZHqP0HLv6cIVYNgM0kHTaXcC5jjhvm0n1YDYLFY/DUXbAMlxVAbfcFAa1ct8DRVOR49bRCqHMpeheN3uliyBdG1XJAPW6Iy9lt44zarUqFuMH3y4Vt9EvAXvzFkKHG0L16FUs3NCFyuQVKgbJDLqOJRoBIcfmMcBH82pmBCVmn09A2cTto2VR8BFz51/09pp77Xs4L65vJtIc6Ben+jUReL0Vbk6Yhxqa+zO852jeOpaqh60EhIvyzEDLccbyRjY3IjBf+XnLG1XgPrBKM27ruD556q5aA6hx6caxakBoxoBNl1L5tHNChZzp+bTza0A9fH3lbH13F8B3ZxfPaHOgCAK5m23rrChjXP18PlbMSuxqzTxrXKnyuvRq5AaAbdV5PlppuR73snemXc8leZ1H9ugq78ykjIVy93nh/NyYj1VYenbjudS7rtkbhSLKhc1xRE/HI8LeR0d1jjPfzTaFcdxNdzdoXhvz3oHQ3El74zLAQddVuYyjxN4m+WiwKV/O2WcFQkv2XWBmjGo+Fx55NI0jw836NKIfusKqoCKgoJ5pm4/drd6IPmSs+QCvYmLsxekFKXDE3MfXBaXpeUlfNHshoC+iDCzrrvo9kzNoNX5P46PpBsUQuH6vEI9FUXacorw73pWtZvK4Vp6RIjqBKMT1TLG/a1ZE4yiXWcS+wFMcZqAGJIFdj5cC+iyN8WflCefV7wOEnCnym4AmICKbcZLR8pyMOHWoWnMuyEt7K8kLsxoM5oVRXrps++LPJz6o3r6QL2eNFL6CLFA/jFovkTigUb6w6grdI3BhoAeE6mXtpZaArf7unwIYxr+CgPMs9C/SfCgyXoFrWfk0EOy14M7ZBeDH0ZeMXgj+iLJ3FUo3/joEL3scBVciR8ixeTLr+xQTUcD5cKwL8z1Zrqb74byaaKWymTxC5qj2GQC8A9C0A1g4B3Lonq0blAIccI6BbfgsfGmT20+fCf/pN2x//MesTc/oAnEaNB/j88imy2GlYvWu9cbz0cMhDjjq3LdZh6JqvTPRmaB1drVmBueeNsVVgSL0uHdl3NojVgbnriQVUEtzGDfOw7xrL667JLlrT3PHYvK4PtZttGe6w4TgV5sKQDVdCcEtHTXWwZVRcPeoHMu93OVVcxijxV4hg5I/Hnk/8jrUgvOfEWKOUZ7xnbEBPZQ0DvT8GMX5PBPrrjbh1bM3z3v6Hk/VatWr44xUIeLKJjT8tQYFj9HjrA7mG2JEGJtqpGSD8e2FK/RFk+7D4+qYQ+wdrweipcsg47uSKy8RAFvP5L2xZvbNxvyZSWBiXkUYMR/zj+uZ+f3dowi8nB4VzzEHRxsI9QwHZhk3+w+6fL/Ltp3nPMk+/p4G8X2A52ebfoy95zMA0yWAYbbt5dfhPFQPajL0e+vsz7OvqTZh2i1p5YlITZQXi69OOraf+J7qggpTNO9QLUX0rQsILXk+wW9kxC8cFFSsWTRV/sJAt4Byki5cFQWAwozbq8BvjVNXw9M5H7oG72E251XPeFI/H30S8D5mtyhFwdwrc7tYt0P2XDwL11wubIbYNJinVEAVzYgz6IpmI7k5PMDV6j95Pv3276a/BagJ6AzClftsmJ/dJgqtzpZu8QF3GByvTH0GtmC/hKTz7M+/ZOzZs7ohz7pAXlB19bxnzvh7vrfTY7xAO57Tx2sbNec6fXHzIoypwn3m8WizqMe5zrqumHxdjwpsZifYZq3qiD1uRdzCbAWer9IBHHqP7rGkXLnkw0S0UQjXFBGLpqNN2hfumzWM9jEp14/jCl/Glxw3PK4Sb/IfU3KEOwg+OuNYlxDW6BQRVR9de1YU34NAKR6j0GwijJk36z922extVqPIaxPkpAE4XBjxWrSTqe11bw7HXpAZ+2I2wqXWzOD0bOKApnn7B7OtrqD3EKJ+NfPtyB+v7kfLeTnumwOvmEhhppl2iyFT0FXWReztJjD6u0KT9CrVuXcAmjgNbrir6Cnb5ueG2UEVEFfcj8Bcz+oIi7v5nK7X3ZieCoQ0lemxfN39FIkHc95birG99hvtgT3Lnn5XYXog0mPrBlEGMWeocKIKWfbq3cVExh7ugO+kS0zEg94h7iQ9mB2u3nyIyy1PFtDdXSgY9vQyQ6/+Cq8Xb4r2nblp/ij0+QpEtNc4M1+WM6K/LIFdE0AT9aqZMwg9KMsdog+IXdwVkjHx6bd/+w8MEa4kNaYHVLBWx/B8Ze27bsVMOj0ddfD89GvSDmxD35xI/k/1Zwwu/m6cOS7bVjPnr27jg4s6St4u6DaFg5UZzpNV1HnLlVtueNZZUT7XRSiugmwilIiH2/l6NgGifAhws2514oM4vSJsRomYzYhFtaN9LfdoFJYIBEvfqlcalyGIDzGH15N8D3JfZR2v8qrrzDZW0mviWfSQmyXtGbu+yAj6WrMY50q6phBSGTVjrW/mylzMtwDc1YzMOZR4xH0nyurN28nS+VjIz0cE7ilcBuw9NwNt+l5Vnx6rrr5fsa7LyY4YMconYefcx3Xu9t6Cp2Fq34mzupdHnJlR7tnfR4+KYW77O/Ob8/wSVs1d7BJkgGgsNj+nWnBIXkZi5nhYsN2sW3dmroAWGH6jD47k/H3f/CgYS714oA0ftFeq7Bye0d+ECiYQJ0zWDlVriweD4E2Gym+X4qT7KpawrkRcwe9sgIeoeB1rYSfkg5p7Xg/K7zFo3b9KJyPOuzct435Y7wsYE3g1HQfDFTEHZnu7HNaFJsK4t+kyVqoCXgQviGua7m7W7H1Y5TipAe3Djo55HsGh3oRmBbRrXL6DNGO9Kb+FCozn0rj34erToxsPTLB50mcAIC0dDdeGChlL645+8w+6oGz7pEJ1OjvqsroesuxotQtMMfNty6OlmzgbQ6BdxFbX5CbwW7RauoJEkX/LY8WkafBoyiLHGXqDOhxAm4nYtbnq2tIWziDlyE3XlvSu2vl5OBk0EpC8axTEc+YKvWDFCvKAnl+Tk1nc1mwHmgM1FMkmZk14F76n7EIRZRC6sESzJlPb3FSzi+0xwiqUb8fp+DyszfZSrRFeq2bruIS8ds3hog5e81dX4RfffYpK1s2ZcYENKu/vAADkDgNxo9L5Md9LMcil4HDyPZlxoEGvUzVhMYzf85NsdIf/YpJdF41+CGxpZ4v1M/qL5Nm/eFWdlWKN12sJ8aBzC7SGksa3Sw4t91epQ24xK8h1FV5lYuu8kEKR6SCpr6YCgxzrLt+dBnMgTpUa4T6a8xwGCSqFTYNepi87c85Hjwgn6xyheuV6NL2nDPI+B6QcpONex9I56X4s6ON7aQgu5KkRfC3VHsy3C2tyH6giF42stvchcLso81kURZintDljNw3asfYSon3jHQBqiwBle9Vt9+Q85+/v/92qr9fYAOy54coBfiXg+Xn6MwDDOIzCUtdngf34S8/MufJi3ZZArzvWx1gpjkAdfbMKbXZBC0ChnYcKqLtFp7HLc5NzdwyKMLqyJeXEtxxcMUMKBkeaGjh4RkFAx+o5JlFXe/NKyaj+w6uJyqiOGBkW4GNjL4t/ZkAlioCH5cEeXZD0EDNs3bgpDJB7XU0cKm0s9Lun8fpf1/6ijjh/ImftXwrSe0WYmSEFTQ8h36K32ayHyUGa9lPK4cyfQpgxuk+UzGS+pNmj+5ygTvC/8/HZJ4mOA0rswL3jXpG4X7jyzoI4xL3vRlX16tUJXh4RO289UQcEakpjzezBIRxvY4XX4EOwMWm6Nt4jGDutoyfbQEJiUKwd2NoKAOex/xbAEnKIM46ygHQksJgnUmIMPAddJcqg7SgQxlUYgMQugDhm1N9TviqXyPmS4kTAsYwUVEYJkscuJ3s9wVoAsitPRnH3ywEduRYUaz4iqj1vXId7XRpkOkh20PW60hyzRZp7d7G99jWBb6S2deKbmqsq87p2ZLA9P6l6tb2qpD38B9EjzbtlWs+uC4fvblmMBk7V5LxsvAOQkw3n1lm1YIazrvQOAPtqu8Vjkc5Z7SrgTKhdgEsWlm30RazYjJa1LGPRm/eqcdoaIUZCitS23tLW/DT6V10FDHNpRUVXSuorjuLT81pBqKGZbHLzigsAd6A1AuxWxeGHs18bZmphv9uNG3xvkdEKM8QqeG5ONr92dUnlx+E0W7yqY2MlklxyVnJxzll96tlHvBnRoREaZGY4u4uE+spcYXC4uZdMkenhuHIshmYTLbKNI6iqahv1AFxC9Gd4ETdG8a5JnNU+5c67hA7PC5BFQ/iSJ9753MW9aTzPHJVf6tzEOqzsVHWMVzNvzo0xyI16454Y5avC7R6IPRW+cxmLY8KuEtVzoHDfXajCf9XcAhsUjl2NdwBW8GooSCMUIBRAW1g0jErACZPSxdpH/ZpgFygP84klAw819xFCbP9zTxHSNoJG2Y13CecRdoUbGCu7gcHeLgC+SHbNoE3l3oxe3B4l1d+YyVVDeRWO2F6LNq7AjXpvmsJNwS8vSJOtlHEb434d+2DM6E1+q8AdKvC249yhyPtC9IYEx75nvUZP/w5APzDeAQBY/32A6jyvy8osq2/JlbkO15AltOnEc698jtuL5ggrwIjgFgeELRwlErc7gqwY56vX8tf3oqywQlVX+mFjfAWxrml9xlxrhgFnO4vcZ906q/zDaPNxa8u6eoXNi7AqOFzSbGZ6o+zqWL05XFvGZJv04AL92DGC7JUBPjhibMaFLxDiO3LNLBZW4Zg8iLvYd6QxsTFyPj53oDvqjbwqrwFDh5qxEXCdEXyB00PwEHQPNa9o3ldxFyZ1re6Z5LHoM14zNkWmvelRmMXm3r3jRq+2kdKmvJrtm9bZoFvPapbuLaN9XnT1m1F7q5o5XvPsY1QUqluBqbAFWMunLhycoKSrfgeg5VXrtkJZfx2sBtqnAaxHdmEeYuwy7p2PUlnO1iGNQ+V/UBHzmaWwM9SNYHeyOGIeiwP/onkE8ZDPS8U9RPaU090ynZyTMNu0bBrcLZFmuRF9F4Fdxs2Ik8q7BQIfj+UD5MIkW5kBR3/uVTQ9lkd0y1qATY/GjHsN+Kb5miqAudGbHl9TmsrlZKZj93Fvt5gH3bp4l3TclVQdTAcmHbnKzwDAGtfyq4dUnYNdvvZP36n53ghQRbxUMRNQVTkQNqY9DyKv3eHmAxTQMyUoXLxZBz2D5rA2V2rs0N8SdzusQQrmQNNInDsLX8fYbNm1jeanEdx1b5p35e8st4Si2jLfm9pWkNTfjOW+89d+BvTGITxWTxiM0SCoo01Gn4FyzEuESWKXxIogvXd4og24oSCR4aA+MhsYRGTJEbnu3QVVu79p7lyBxh5aXYeepyS0+L7cvO+M5fwxbQbtvI3zmZz2Xu16JyoQYABNbdbhLPNO52OoiwRPkFJhhnh14Rbz4ncAlo4JSqyzrf5hqxh1pApmwqTyeVAF8z9K7bDjjoDid77g5xH6pB0bBRHfvq31TBltYKyOJgq85XHvftXlHrPkvpl9fRndrX6TE3VmB9HsAvOTwxFnqWPerSAKFOMqHWhcgE00GHOL1XCQTZcB/iTIOMRb74tXwIc4zpAXZ/WwBMbT3osp/kUTFS40TbNO7s3ITWUH4F7qO3GqSxlnMHs/ru89lYOMwrmvRqVEo5mZ+mnAFeXz88gAhsjiJF3RDIZtUb7yKpMIHrtghRO3QNqFkCL7eXBgsk+MCC5HKshfRPfh3sv6+QMH6OlzHOIydu/+udJuTzvG63/P7jai13zbVBaf28Ohmf/5l5zrjc9yDNHP8B8CNzrj1Gp0D1VnfNNd1MKf+DYSnzPwGL/fEimfYhiBKrk3RuIp856NejExmjty65hZhQ8KzXxAnUxWfJqUEA15oevDHxh4XP+9/JVKfW3VmTTzUtbyrbfFXjw2dneP6JooaGTHY1rEje4n5S5yeGWfCdHFCc4zNjKft7z/pyZ8pJb5k48zy3yYrh7QxtMj1O+ION6n9iLGo+VeX9mLT8RZitZCrPdfWJ2r2Cpg/gzAoozHmSi32C26ecvFZ0Ja5tj0jOqgpgS5Zz2/+/j7YIWeoqBqmofd66PPAHiJILgccAqQ1AMtO/KbAMF+ILbgB+bqcqdAf9PpiEE70SNIL+3jJZOArf5emtfZ+CdHqCjLMTYnOYyDOsOx2Qv2nmF4xneQMkbkRsiDoC/StZnm2MCnbhRc3puRyo6ICurCXpxb2DeTaipvEf0N8/VWQJME2zhbiubrze61MG+Owhz58SFwDuP2VhexXE/MOGWRQtGEpjxGF78DAAd9BoDCUoMah33S7r/830ZbotWS2KR4FpjkZs7MwvWGCFKHiJqUuXzV4dcGsl0jCePzrPNgnn3i/ZV/zObpN4xXn0lf+uYk5fsuX5OYcyq/faLBOwMlfGvuvboQz/uFNzM6PpSZwtSzhieM7JRXYeSzAWiSC4PUbJ2dD+xnWA2GoOCQJmLQzuAH85V4zPeYl67eYRapvM6jzsi7zgvzhW3G6u5fmgPmM94vUnZmP7YsCMyXBTnW+9ouNM3eulYaKWzTiNuV+82jTeSjLGrkgt5MM47FPGCsTO/4M1/qmme9L0RuMXr0XUVsHU+i8cvI06zqCswTPuM7HyVZzmRU2cTRbEZcDWXTIiiBBvsas56ZURPlALZDjAioOTg0r7XvQJw45vTQVLG6CD176MX548Q7hwOQO3T15nNP36TUnFF7EDTFmjDNyVewKH4HIOPgiz312B65bYsi5IGm2GRO8dRkFmyepUdplW82XMsuALe676QDC/+7MCTqO1/iEHd3UXY7hGBRFI5v58nLMm4j7Ix8VQozsV7WxjP1Or8sn5tG92QVpWheFXoGdjCZ0QWEpoG69vJ0PrWwF+q126OAzcK+9ry+Hf6Ywz6NPWtpar0b9ITDjj3AY/oXnJOowIGd4kCpj1Xmq/BCgQ8WzNyKdwBYEpswa1hTpXIt55dJm552nLXYmbeukC1o+0ZjzQ81CJgdJLkkttGmulq/WdAGSAbc9M2G+58vhx6kMcMOV7yAUL03MuM6ZdOcUZtFaHoxXnW9x0moDo6Mpstu40Is2sDM7ZtCBGkaSHkYf4BZdzUq1q+Vuze8vG9SCFEuQLto+TWo+XjUasexfSxS7Rt7C3kG1q9GO7JXeOwOexi4VxG6aA4sx1EKnLoZCSjKSUAPkZDD3POueWEvmZjOfJTFMrD1cVx6vxkp5h7lqwrQHFYfO83DA7GasAdwLnHxI8MlaJsgqN616d961bGZ0QGDwerUZ9c87HrmDwGs9J9+Rez02YBgbkPDdwCe8vE+jFS2C6oew2za679ALxbOBcIdgg54j6M7zwHC7q5xyN1w5nAS8yZ5bmVyu6BCjtstLuy/HZ+TozND/s2mqMC45ujVX+01dizs79nE/NSfgmq6Dtjums/A6dkPQmymf8Z3E/yMgZLtpXwG+c33ZSuAMdWwxrkHGX9vw31maC6v3uWAZ7J7AN9z9Vj/DgCx8F+TfjT1y6DuNFuQEmDkN7B1piP/0DeAClZZtPO2dE9/1ul5gLOX0hq43wLuLR7IZDTQtwh5Bea11egNZz2WA8tdafVwCpA6zfXZf2H+rTcnqzouU13z2h6BNDfUNXCZpDRAaEavlSc1xXXBST6eXbRXccTHDSbpRZymyxhwcKUtom1GicZR1t7Xu6M6Ri/208MRY/RHk4scH43eJJ/xjIoghwexCBHnifBrTYy7V47jEuW9ONG+OD7ErstlcEape3vZ5eHuBtgci8OTKtMeAtjMG74DsP4dgDhTo5yD2XOjY0hi5cxGA6CymVbsCg3jreBb/UZMOBNo02m8lOHXkMPNaqe5gC2qhMfU1JgjMwMomzm8b85Kg6IRmSnmtQVSxBcZoAsnYVGTAlkVLmwGTbf3shSAA99H7vo6snjkCr8ItwPD6jP8RQh/U0EPjM7rrc+5eaVS+UF3bxl0AkAK65rjtiD7fPDEd1msHScIgOy0z9gQvYczr4hWYE9fvCx1FNe44IC1xruOCBfDbVG49mrEVrTj/dVwHYd6Qc+91b7dJy5esAjHQvuhwYUmznyF77yjNdmOlZrz43yFgFxmzDxccb1tl6/qVldvLwcnMxYGsBOvVrMvGM0KFFUqeMboxX4KtLo+hft20z4J8OmXNCzwt31vYPEIHG6Q1gLpM80FnxVnRjPOEwWrNQuJ/VIclyjvR1o8xjN/sbtCGnOeP55fweVKjHFeRyP53GwBWKfu/k/vA/yOZsFn9RmAAOETHFPeZz36o7yYw9odFu0V0iRsm1aLQB/Qe1yQ/wi7MG0FfHjd68pBbEdjcpuC3yJis/JQNvW3SesVo15epbsNcVH0yxMB/iW5AGQGp2fT0xfp72qer5WSGnMb9+4i7Ma3wHTwN2G+ApoA8/awfBu7XeV6M75vBXYfFMN8Xt4BCNMcgPh1L3zfPAy3wbctTpQjUB2hNDg077gyDDdO4KtvAVKntuqnvEgjFlf3OdEEHL4L4sJQyA2BUi0gTP/OwK3PxeO9gLoHEefQzvPCChyGuuDOSKt2OdAFoduMexHkZZv9vbXNa77y8/M5Rprns2kZd64YQvIy9KdHOTLp7Zs9fU0MmoVb3W1sn6tjxYpD9prcZ8UtOVXIGYzP45JGy6bseUW2UT4foo7rQeuuWY3VZP464iqj07NrTHIVa2w63XsGc+Drk2dzX+Aro9Vt/hjSjOsRp1NfGc4f61Zuw0aT59Dj+s5xbXu9J8eiSKOOUmsKlwubOib42uZC5AUqT77VLwQv3XafTzrSw1R/6BY12Y2O36O+JcpxKfIoUJxroZ9vOkI/ypJf32Y+4INZIjnlt2T5SAzrijvPuuumxD3uTaNE8DsnGEO/yZdX4G6jqUBXhcO0v//Mv7z4NaDyGqc27q0xNzWXA25GfDN4q8BbBd4qMKzA02//9h9waHr++Dtc80+H++fnd086XDVfScKRLJ5Hfvo1O6auT4Sz6vp8K2IOX4CeeeU+M5yKO6xE7gzpZZWHWXNjd62pM1pg1pIsdU+n7rFTNmCQ01o7xFZ1RadmEs0b34IfRmFleagxk7UYCn5+vFAKH5JVfaoK1MRjTaJcWDq+9PGKi+cVaRTuasYha8SaYNuE3aVsxI3+PQ6mn7+3WFEEXI/jBge59ZjMsM02xahl9fIcx9G1vXHk8A1ZTeXlYVqCELSnz1/1iXF1ZPBtKwh1cSqiuVmobZxhZXruSW++m9ftCs4zmPiV4l2p1fOhF3QX7AbV3F3H0siqv96Pst/Nnntj2tOfJyJk4Qzf4emFivtClHv2Pf14fIGMwdq86x028xzGEXs8e/p6Jvcs5/X+SjfvUljW1TiPWYS4pDnJCuOLUdO2GbeH09MXIEAeP1RP2XSODyuM9KldfHK1eCiNQpmaeAeAIDY/M1qarGhC0p87pz5vRyH7R91ZeQuzZngqIuBiRMg4GQqaUfqnAkfnEC+qX162ctybhpfcy+LCPak4jWZQUBobNL3elIcr4NUuJkPRjPjoUq/b1JpofzvZCewNUfCfdD8W7pjXJKXC7HCsYwXx6D6LoImyG7wJbxVoVgATb9eEOTzDm9HflHeogMZ31yjfgdWREJqsyKROxn4HIF/5zwbL5PZpC0/JJYR3gFjZt8l1zqFp5cw2g7wCg5dKplnZul41PThCOeleA85rFKUmMI8waTnORQSUNQCj8R24TabwjZvFQYml+FoHSLOxyHqQbGEZS9STB2g9l55+HP2qQM2a9ChB34w7pjpAG3Q1Aw3s37puXYG9o4wRjC57BzT67k3NYwGkoLEX6s1+VwW88tHrzFA6ThPZe+v3out3V8xYMJoXi/dKqumuYq9/B0BzPF3ylqe2K5+I3+2IRjeQhznfIN5XA1nPh83UVOtYcYz6AZzNQLWBotSxrp12NX7BxA1ccANpVJBrWXmIN2GyAqp/MUbe/MpGR1MuVubaBK9FizyvlTG+kaoP90wUN1YxtZ1x3GujQJHnXoQ3+5etgE8V0fDmHcbUYyF0lF+2IN9sdI34AwyETz0XJsYk2jIHnADw6Zm/AxBzggxTbQUb5VagT7+mQ+depZbDrM4pOyd4unIWZYfdVqY7oB7JFGkdftS+mh0O2DlD9f5rhFuO+jUM31BeqgI+N4qZCT615mVIXn13tad8yRErVsmRX6ZQe6KK6vkKCCcWYQ+Lh7e9eu49fMIjgvXL2ch62Dc58W43r+7zyjusgXWqEJPl2IZ7eQsdEHo8Tg7oRp2qT8h01tUrmNUv/vZ4Bw/76S99BsBzrYUe0BV6jzYHJnNsd/rNoS9WN4ZfAt1R0rgfzqxZ9Kg8jDxfgzuEmCcDy4JP0dwF9WZ8bQUwFhqOKFwb4qHQJueeV6MgH92jXJidafZCA/OSiBFEsYqI0eBMIod9X5zAYeZfn+OFYzEPNW+5q+CAvRHyLA2sLfzxwlScxz2EM5W/qE5rmDgQvQKsPfwdgGxuELDBtwDxu4Cyms/y1HbVkYw65ygRoiHXn5iuNQ23O6iQY1msqai7zsgPRZiiURsVg7arzvIdsN38zoSaz6SmDrqrwoyy9e0TCFEUJ3JTL2kEHP9Wk7FvxLlGfuVX8naP3YmqzX/Tzokge1yr6zp7nM/acgJvPWRz57odPdA2kqlzjBrIilUczYo5GV0Gh4VG+L4qYi5W1b68YlL1Lo4HpBedewf43s7F55vmQx1oNQqhO75i+vfwOFrPKwA0FhTnJ9jtXnl7GUmvvPjt8prcrSneQ4g1OSZ7NBWwaI4x4zg2LYE2Py4yFgF5YW64e29VDAPnfLRKCuIwjW/gxPcC0WgxyYmZ5onfF8R3AHD/T2GVfeTp2ahaRVPKZRujLdpbSSKzQelQ8PvmcYjirNNV5bkKZ5a32SHofeIWA+5NRIdcc5Ambnfl9Wb8VoF7VsAnsCa2T++ieVNKHvSmUc6D+079WgifT/nbQbhkwhd70+HqgcwmnzgJo3w46GWOvp+cR/SC7oEqnIrmHqRTthiUIjQ0+hvjFl5j43XvZIQ0u+gLD20lQMZVfnwL0N/+A/Xhd8KgtoTsN8KWK534jIA8jXXnfiP0yZmYjUfrqsbhKixnTgq7/l7ezfM8pyfLz7+kYjlj81S8XtlhidvX5J7yuWBVYNfI058HLwOhHdFU5CJ6w6el0tUO9Sz1qSyb4xg5VB4rhup1hj6NJBSFKqDGUQrjZnMXQp5uK6QdCPVeEDVRXkWYaNg++86+CXieT7SMci9ewyZwbvT2gDr6hPAH6x5eudwdK/BcBe/pZWS9vd9J2M0hYOKb7JuPiBnlprErZanmYD+lgWWEY/t4t3LkJAzrUBr78acax+JAQQ5V/eusa00dUZrastb0fGeY1L7KyK8Kw8CPY5Rrh6s0oW47cuxFF5p6OzMzuYa4XU0VJTKMcmXYeF2INg3fik/DJkDE3mI2BqttcffIRp5RrkMNe8W/uPYPMv//9q41vXEkR5ar6wSz04eeHzM/9w57tvl69gDbXVoAASAjX2SSoizbJXZXEgkEAo9MUrQty8MXJih1BKfFyue6PvI7aPjq6MPx6iQyW83W3heaYX+G4ORPawYSTR+r16RjCrs7ikOk13HhCA3nVPnpTwDi/0kK9rsC9CVO5d/4bNka6JXTR4QF5yOYo/JHckcMO/PqV4ZLJ1LOhRXpDcv+h3BppheQvU9LzyZ64TqcTeHl9+E78Kxdgus6x499KS2tImoBdCYvEb1A796B3IfvHnkccP1yyJ0mAo4UQuFfEqxzpuN7Cw9Ise/GSlH3JALfJi5PWV5JZo45wsQlsZ/o7e8A2FeOJRTDXSsq/HlgcR+Yiy+kBQi5HEOTYxGTgssr5mWJeUS+k20S9jGsk2ChzspCceaMzLcbc0kgJCfhtmOdqeHl8+rAqwMfowOvq/tjrMMrC+/A+ovXU17EZ+u0eB2tVzcLdKV+MekIea7hCLJe+LkokePZxxXkdyz2EXRTf7jevouE9wyIYFpHBiILU8F+LfhBz8RVoKOTM+2bxxjWPocftTyYfpxOswHGoAWt8Mj/2yWINf9foNyBbMfacf51zViBX7f+V+WfogOvq/tTLNPnS/KOjQXXOwie0K2rshWeLP8qzmk7+gCbjymbxp0gfajGQQD4v9EfnfaBdtJOc++5Ezs9d3CtuQ30Qz7rp3C5tShq99ALLMQa4LM9+9DptPKh0aROb8rp/L6a43ZLNjfGQ1uxu07PS+2hdTt5Xz4uDIzvkcErxqsD6x3Iq7HfuOskL+SrA4MO5N4a2LZU2IpfdUPilaCpDq1qlOgRlGd7udXnsW2YxBj6EK1UekkKzLNNKL9Vq4Bt0LjWMz7JJM66rD/l0V/+EBiobJ059USLwNHcmc33yRcQIj/O8kRK1gH1Yx6WT3DWLpeS1dTzWZY1hxyzbFfRWC+PfizXCp2pfaSkqgxPT7K0hgF6jF+v6qbY1/STdSD35Wz7frJ6npyudDGv8Wztk3N6r/Bc+zUxv+Se7Iva1QCQG+ua5jYswt7nUWP27DXaZos5n2AeBCPVOqEjF8oneohnfJLEO6McP6o/ALydesZMmBMl8VkhCYXgMCfSyuTSX0gb0yy9dGnCQ8/JNQzgb5Sj6QbHCH6lLkNzldsB0LkeI/qV34Jnx4wuyvUEBMyOTLgrL2SY3OOMnOEPy3j70zB2s3kBXh14RgcWroLD1/KVdeANpcaYV+OV/L8EFzqHmxjkT9DLlZ15fPXGd3LnoU+/mX3u1vGIv5ZHv7E2O77QHPEXUowL8HMQRNjw5bpY3nC53nQm8MBn8smc3yo9Ndw+1RM/AVhezFy1vS5IfsukwUW5hWrljFZkQyD0wU+wJ+csjV3AHQ+ys5in9bPGgFCsTYegOR2ud8xu9YvTgBPZ6K+eDuNEGzTL3UyvzugAH9ZnWMKQBUhUFzVWa57KoftHbsUw4UUl2rgI/kSwXO5H5NzvuoPboyd4RJqfkvNoazbwMB1cmoc3bSNhxD6RsHA2XtBkrMb68CK/fIC+42dKzvVpnGW5ZqYGOZ/uEuwC5tzPtRxJHJ3M7U+uIspbgG5//l1/CEB/B6CujT5ZPH1VML39LTHH69cZwvPv2j1ns8+1JT34M4q6kpU/uzrLSXq+/OXvn8mBT7r17zfI36tTlQ7+9ZDkWbNUXycpMACS0Bt5wYRRGCzd/tNk8ZnQ026Y++x7IX/+riF/6Odn3+I7FoikGc+8kBHGASY6adVY1qFJRyslZ0Xg6rYr2o0OQAby/lkm+FTyv37X3DjKoJaSWkpKuY30XWGfkZ9uI+FG0TnTCtvH6jWVA0+6zvM+n/HUeklMN8PwABImqgUKVJR1qeDMf5iy60/ETZcqblgpEbn6BNL/5GSmJ1eIA86+Y4DalY6/e9DRRF3ljoQS3r79ZgIy1KzyKiMOZ66KVfNGJqOqB7VQEIg9hjUsV66ln1IO8sw1yisoSq48fdLtjbpjbaWFXPy7rNxKeklJlJmYCckpM3S43yecauIHERnnMkWH5uZRdFdzPuFbehgaOoMNir5XBHSRo7PcI0e7qLS38vV9OOAQVYUkSKXXz/qQ9/vKP6xF4Ki3oRqfKzaD9Bpaa88KXNY33ga5M8exbL1udEXXOZfofJdGRNbUXmWPZSbj6FVds/7M9CW3eY3sy/I4nfndBngwQC41zrgGu4XrZXlGwRhcTvlU1rgwsjHlFBhMdZ+AEWNcDXj2GLyaJMvoKuDozmS9yr9+oMrt/ndW5qTglTjFdGzu1umnDOZgVt7nVfTxM/xt8GyPnthFIj8BkCPa7ROZ0m8Gm7IMvvBFMZMoygwy18+iZKaaI7tj3moVkS7l9Ui0cO7xrEnPFDhiRV0ZZvAKRHnVeszw6yFpAWVDnA0QfcriAhhrkkeFhqWyxaTH9JrAnj/3nL3mPPuVnpzXtLEWUJACyBFJpAv092SWmaTQsd0fpKMkBcdt6kJg2bqpJz8R2bW2nJ1FxAP+dmVxgltZdTYE1HBMIbONTGrkfqpd0JlLARZphN22opbEIFtbRE88TSPuqQ5e6QshWpHqqftpQ0ddVZHWKLNZRw/bwzifqKIFNxghaZAMgJyBetPlGsSKlFay20+B82e58dwwNchmes4RXuybMoRoQhPto00l2YdkCl5mb9rCpnFT4ABbj4Y19SkULiDKPKSZPuz3nB/JfU9ej/fNXWQtwEzEt7e3f/3zv4cP++kxTm7H3DodhMM9nTTT7pkqQqglraFsznv2Bh7TJm7DklaDy2zhWEMtEBlEEuKjTkgtmTFMDF6SEeDapJcCHwM9K0G0V3Jd7FMux7HyDP2sGrdTReENZpjqENk4Lk6H/Iu+z4KtlP8Z6zrUT2qCiMfKFTS5V2FhOkZHBIdTqX0x243Oye+CKcL1IurlfI7GeG7+R7Md4nPR7+nDkPlBSul55iwhGnk3KC8ZfJNBBDkYMGMDElbgWeNerOpJxSpKxTBOptDmWBJiDng3zgzwHOzUBGDTrrzByaZ7QuzmMARw9CFgoPT3tvwx6Gl8CtCRQnIRBqGmqmHee1HZCTJrIpbqUi/CiLWxM4rloOzO6Z+x6ihsr51BP7fX6IOznrbRYJpjnfRCMKITccV9EbYQewlCCS7hrwVl9BS2+QGTcaWToAJ4kX87+oOsi7kxbL38bMKDkn83WpQ/LJw78275PCWQVBodWC2aXMozApIXqmRJ4URd7+OLQu6JdaK0oQtywBjLMQS68iPkvJXfKVsWlYLQrHRjFi37mYSn2YQBextjRkxm0czkBDe+qU/fZEiBMUO5R/Ya+83SobcpxaH0Bd6Yh1b+4GwAe5YmXDNt8MzemLanG7SNqZlGDdv0Y2tmy5xMyPoxxZY2m9zSyFuA5AMZeFWcZqQzExim5q0sGhuYRMl1NpjOyIFZht8mE+LxCCdoxBV8ZZpdi6QUQx+b5Hh4BobOYMJI6qeJfSaoEHrIklwPQ8aNnvHcgga2US17CYynDfmQZD3Q0P2JSvvjG5k+14o2yBg3wvlyPDH/DJ01pGZFYK8sfujIyCHgcym/WDkHm6/Xt+x829G57PstYcRMPpjJc+Cc/HMy6KJ+wJS6HN9P0XeDN6tYd3ctM6TMJFIMeHIclgffZBhitpX3+G4zb1s5brarcikIswMkSm2TTpo3P1e+MSkcoZmdgUSQHrPO0/v2mp6Ni2N8j4S10TdTZjggj383wAm2PgUI4We9O5DBHnRYp8Q1fW9kDWR5E5MI8Cj5pqqJbzg8yANidjBhFIUKOQkCKIsae7XMgZN5JB+OH/XMqbO8ki/jWV7xBabx4ulMXif/2MjyfI9tRhuGS//YRVyR3a9V7RUd+7QcWGoeP20pr8R/jQ40m/Xczaohkc71mi/ZTm5XeSxrSk2QPkzlpAHdO30U715eGTeFPY+H2ukpI+LYTwBkIgm2S6SfP/BGv48fLu90rlvGqUPmsd04ZtOSahLP3JQwDX/9QWDqa2iOwnKhAq4J1Ewd/To9sQO8JFizJyZThdZ9Rd8Zxd7jdCv0/mTweVb7Ti/EqwOvDnykDny3V6H+U7n+rkluflfvI1XxyuVX68Dm51ZpM/Ac5W3Bq51M7AVv+DDlyC946j/zp9f0Zevr++jzNvc/57B+qPhL7yTyBUAuQRNK0TNbA338lFOfyZkFHqdymgJXA7k8eA1/hgBP+cLU9izicnS1t/OM9hI+QgdseZo1GnxdWN2ULO/U4Kb0wFqQHefI8gMDv6hfHTjTgdyeD780zmT3RXyyyV+knlcZv3QHcjvjniHTvHmk6QM9b37NtZKWW7PjLFX+0E+4l4ff3/7Qp6JcE63f3pDVN2L2/cWZXj7ZV5m772SAef+rlu3PeZ19Qn/mbVVxbix7wSgbn8n60zqk7t6l8tmrUPAYUaZft21/NUzWKiujXekM4jPyKp6ozM7IE6rJOg7whOz7s6Jhzh7PVsjcB6yifY17+w1/BcJA1p+bff8Mq/7NMN8Yg6vEvicvPvTVpH2i9ttPdez73GuQ1WCkdafPKTeg5M1Wcl7n5+8Ock9A1mugX+GfYXp9r5nFpRJd7H0587/+ppfm0uey43ul/9m6/3B0ZKj8e99h1QwjB5aZrZexh6Ffyf9YPpazbvvR/vG9Xue0zQ+r/AS48bUrSwZR327f1Sj3dpnjOuK9x9HAVr0KjPJUl6N6DgPZGP78m05m+bAT9hs063hGDqozun5vIBb7ciaQtzE7vr8rx/bu4mxZ7jNxzeQV/GjfZrFIb5sr8uA+kOz7MTXYi+E0uDOnSQSKxepK9tca+dQUOehVrALRJDMRHcsOmXRvJRMw9JysUTnuRZTUQJwhXf/H1n2SIzL1QL/bMV0wW8ThdVptgdHdQLzE++jfPbBY26vJK8Ky17vAwMg//0tn21dib+01zkmn2R2gursSvojUW2mh8fhPAHRByAoXKGypCofd+G0q5tZGsBQ72rRcITA75H7MOGLKjCGX0d5/hi44BkTpHA2CujMS7oCI+AccngTNcrN/9yZytPKjeM1Ps87Mu4TdsgtoOOiNipc1o8vtV1XIYqw0db5mfeOOYHvvuYZ5WZ572AvshnnJJKGkQzmaD8LLd3Bc6Ilg6PWp2QBMTFDrSAD/2drKGmboLy5Qd96j0geEewBl04kSoUgBYY3JRSESJvHNmvC58yyktoPjfBcdMryLYtf5/hhx79gNdTdgkutEPQ53CDymOKxFzAN3NnE4gD6czxkHyYdbp+nZ3wHAS0qXbafoYu4jOpcLFBIVzd0YEeYd8sscLijsRXFNB3iTG2On8DjN/pjBZlm5e8MyQ1+rR64SWoTFBI6Wlwkv8if+kJCFHPL6pcB7C5ctTOHR7WkyGm+QsfbRqb34P1UHbCc12+lcAYPtNlCd4355XdOBWJDBm3ApgGwHAV6yKYj1M4vo2319UY5oK5i0Iz+M2npdlN6qTuH6Z58sW98fvSzZZbsOZbpdLqz9eCjEu4M53ya4mPJAw3L6qQWua+8uUmMPlw338l1Pmb9zJ5HBSlwgD5cYFWUICNts601gtgxxIsmv6jLvMyzS6YT0AnclkVicBAsmNRDYayizLwDQVO7VZEjzmZVSsBTYNOJrl3z5ckX34nx5gFig17pc0lrs+UuoXiR3dKC/8SyQNddAmf6wZQUnj8IpU/m/e0dXvmdajHwM3g1m5sG7qeLKhHvyAOnKLq7HSnT9frtBdLxna3Z7AQ9Z/Z1/9H5xj2inygpfGisru4l8+6bW2+DdqKUz8psMeMeYRM8CmwyRqigpZ4Ti2iHzO9pv+s71t9usn0bhnbf3+zJbU4pMt62ez6Tema93D++5lGS7Aps0wANl83642jVm2Alw2OzDLENPQHgyvfKOQER5+z/9XZryuwRYKKyhuJe1dq7qxFaR1StyL4J5MBIUCMR0jBGaBODKBZJ3CDSz2sHA/IbU36PQHEsfvNa8P8DFteGfUZJWSeQH0IYTq0yxpnBMmKIsFt6jn/kLTBniumE8Yv32H7NurrsROD/k/fdTxrUAfLMPoWxG5L/Nn/0RGOoCnvVkYUh1bdZ4JqMO+dopieHxuzEys96XlUUKGD1ix19FFyhwWESdGlvV1TG/3S1H7531u8S/OZkiz6x9nsUnJGB4n1CPHJQaEXiHiywarL4IOIZVDzoQ+Obc59MAmilfF7N92EfvNQ1tTmdI1rOcjo2QaxGN8nPqh3goZ3W5i+wl+V0t5Xvr2RAmVy1XpwmX06P9d7w9OSCKZCtBEWjWmZkeacysfXXAz/Qztp5/yOArFK3hSkUnBfZevSa85Szv1UJXbPQ7gAYpXmhcjsDINDSzK52iuFg4h/efzoF7wr4A9hom6K29hvEsa0W3b3z/YWvsI9GhdXKHFOGG3xbIKGhPcVRI3HXF5keRQiO/AyAH9Dyq1uPpmRxTTEGxcaQSTkHBBAGNc7qEQs+iTF/WV0Tw7EfzhDpI5AyFkKmMdw2GtYqwMxGagZuRZ8gMNedKiAo5IRmPRO3PyhhZk8MSdjlTlqGtPQYzAQLLHtqvim7gWKnYuTJMJoaHU1uveWzwbZgi5Y23N1KLPLVNPjayHK1mHWTWSARMd/spsGEfsn1MC5k1gKWmF5JnUWhCNFPrcwap9rLwF4MF63yrFBwsJ/tQLtiGDOmW1g1BwGlNx0ZotsIQv71wcAGmIZdpw98DRAMGGYfRyaUh24OTZ7VY7jcva0B8rL6GQKaZOkw5LTk2PsWwKe15bdjZlHIKGTU1KYiJ5R4JDWNYTvyG0OObBRg0cIPOEm4YGN6HS+vMxHqW07HJkDCwkCJ9zghNnJYiw6TACPRkRjF0SXe2QuYRMMakowgz/cyrZ2YkrLO29rFSky6p4SRTbqwyhSb1owbWOoHWinYOq47KCmb3yDCZ0IKw4sQYyDwuBLkPwuErprZTZJS/R2tuApFzjPpcC1mgLvUk9kQU1n/943/U377CVmgPt6gTtQenxKZiXaU83koBOk4dYBA7CtzB3W/OSHWm9xOPGLBSMpaj60SnKNhKIhK0yhQpoq7KY2OCdSlbyrr/ppttNZ0N8gtMVtucR/PE/o590/QB3eBxRsZ9Y/xQnpFgh5fulfSZntqtRGLaPrTCcu0Uzm2vsdX7Y1eiy5ROq1ns7f51LRXILUgvAKwXkqubUhIe9lx9jWJqne8Bp85ORz/beisGjlNy67oFE5hSZjzkZGOTeNEx6TYQ8O9l8tedlIwZjzNj8LYMr9UR6yIhy1FNivr9Jb33WtRsDVbZvujkLiG1fJ3S2icrwl4DOXfp+CpDBLvTVt1AlqJC12FjOTUiICwE6NOaGbE+rb3ynKaJgjxz9BrQ+9SmT2oQO4uRaY9Z1dBdCPxdYcK0coh35H8wH2L3miwTlh2SHeDqik3itvszHuFGuZnOv8+pzOkbt903eU2/yWvIVl2I7rlSJawvzNoZ2cllvTqPVjFkBgOgNVtvaQnvnnvAiCQJyhGzVXYnkU7Eq8qu59EQTJjhoMymavKYuJRO4oGqJD95C9DNHu+Uxv8BqF6leESBomgNEkqNlsfejVK7KofB0inTpcemwCXIvDwWjByXYS43ZvgMcPaykI/kjdcAf1BVlyrOGcqJusQ6Ba1nvQYNEn2M/CLwWkWBBqWPlmoTJOgtKbv0BaD3JDpUg2k4Fw30bpZTIMhdxHzBKOqMFT0AZzKDCHWErN4ha8iQC2tIYvFkgEEFIQeqPs+sJZLhaVfrxldrHkmhQjygRCaJUsE83deK9HQJBM3KCCcE3xrRzbpvK/j65UHbnllZJSiopA7OMg+JY0HnGjuxleUKaZPWirlkJWk1R5hEHaJeBvYs1+BNLy+nygMMKnW5IY4pWJ3bmM0rWh0wj16hzWYa+GWGYnANIPACFWTsLchYC1hpZIayXuiQjeptDPqKISJzmsbvbVp/HN63mIpFo9MjWljyjIA5hUCMjaWeOr8ozUNjBUDlmHgONoUSlrCrj8qxKGw9IBt0zgOL5ZcParnTPHPFRBVFhkZGR1WCT9B5APSRRNV6eO1ikPXTC8DTKBhiB978qiE7GQkkvfCrMa4Iv8LsWcOeNIwG6cAnwquhsIRse0wzDatHLr6O9PQVGcXm1U3ZWvgqDjTdqAH96GKFQc4Ra45B7uriWIMCr1pep6ha9XEgeeKfdaCqyvkplvPYqUTPKCawnuVA6Rn6klX02/UEtX2EHUZXfDTWrLquoDK1iIIHU+Bs6YMVTtnKWg1j+oWxOQdFVOJmL9dOLjuCCDOCIFy2RbXrSHGWv2cslgHeSEnfYiydtDe581TDxZde0rfM2TFqllhICDpjhdv3H99+/K+90d/mZonMFIxLB1W6s2Lsvq2j16/OcvhMJSCsOzJVu+1/5Cc40aFjKtqB2Fh28LmGeFNTfFziE7xVo3jKxPKLnD0fdoSHazyWbcNSaVQkoKj25rcc9bPKjEA7bgK02kidpw424xCo681dW5Aa92ZmBFFEtdrmC7iNMocKIQUrQt8Ny8PjKWesqekXBu8PmLM6jWxsNlZ5hl7XJfECZ1kfprwNUUVJJdi0lpSNwKM6VFuuGjpYo7JlUPIUjTZJDhu1K8KgKvDkKBp5T7nqDWgu4UUxE688NrFBd6BqwECjuxZOAGtk5CxaNWOzGKHmQ2xw3h7Nz3JBJSV0WHCGHlxkQURStKJXHTm3GSqtPiGUFrcEPMcjtlVtamNlgMvYOf23uFooZ2WlzXqljtFnx3StQP9EnTWak1ZoR+vASNjKCCfMQRcs3bnnb5wrD5DVI5aogtk+4sF3u4IyoL02WI7J15CUqSK02+RsxjK3VRW25NLrzq490qQ1dSVEXqdh06tM5TffXKRHZ8Vqds9tcO04u8NLLJfEv8oQM/CEPH6VEQJve9WTvJdWfaiqjioG2aIcXiEJI3irz/CSrU790BUJjdaRtRBRjQnPPAu7BWiyYnvc9yQyBwfEnL0+00CR/iqwSmX5J0SWe8pJzSGKHDkkL3OmEqH8VaNGKAHiKtqJ9QQRv19kLuHHPQzfwpAxAy4KXwvSAIVV6kfnyMzU0f9B54A4gVhG5Aw133pZH06zM0XQSiX3shaWRTgGKdqK52PkwPm4rPsfO05+tUy/lZIYpbPbv5zji1UzanQ/zFf99UhtzCJDTcSOsqZ4vXC1nKiiouwkjiOy5m299Zez0mfNyKJXXYpKi9UiaxgwN6cufiisw8ImfiZGtNBodckZTkb+9v3nz58/5PX3zX+TT6zy0wCEJxp7JfXbvafrlSadC+aKRVZNhtb05DcspEWeDK5IywLJ6Qhvo8ropvNWhExrrqXhgEfM+DyCpE6AEUv7gBDpHRGhKE4iVchoGqu9j+aqYH968cUAgz74iM3cTRNbRFtutalnaYxmYIHNKU0iqFqteViHWWN+njbL5uHJdno1ai6+Xsk+EOAbBiLUVVcKMck/gWEMpJ9TbzmLg+qdpYEGiQOshc6MLxsU70HqrLz85DOrbmnvXaD1HBlAJ6P871FMTpIiAFqC+LwAUkI3rC0JAn9CWAgMLnO1WHZyMfnKzHyhD3em9BqiIuUL2SsFmplVxsrUG6LyjYmxyaQcmPSjIHQNYaiZi7NK39/w+9G1lmYS0x6s9EyHNys1GkOiyahAjVviJygEq0PXSz14R9rcUOItVFYBcMoIctj1rlc6HMx61gveqPWEQ/OxoxdwEwl7nm1NEt04Ux5gVaB1JOLWiVtC1hTrSgYpAhgrHPCAGF2DRnIywqtYi2RpZUpKgv8Uke4mKwf1E0ZDV0gLpQvtzMSjmsgkrMAlQ5gF6eFV0kOA2VPvoyrVwVIRncjw1ytc1KY35zKQEncDNTkQJ0G40HgpZTGJaDDd1KbW0AbRHS4q7YF5mFlzd6tkZ/tP61FZcOqLQXxEI7JcdBDVlAciGRw670AhcKhds5agKyy4lWwKmHQkMkBTwe5qsrndt60uaERp5droHq0jeJvREtLoeHSzNqBnEsjWzxuIuB5eSSwkQJmrkWt58KSc3MMA3SCR0G6zKLExgtaaLQYtB3JodK6x6kIxU711NY1ggx4ZWFD1ln8WERAYeRQjB0lKx/BcoRI3ElWEsGZsxDEyzoRkbFE4ZA62QcEion1Zr1Ekju1n64uQcpLpqwIypDwd6Xoy4CUICmSlUXw9mz5UIXxiPW0MfmVp/h7J22NZ6FYph2LwD2iMxT6UEpqNBrOAxWRHPtv7XMJ8//79/wGRj2TcDPLakQAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<PIL.Image.Image image mode=RGB size=1024x1024>"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model = model.to(torch_dtype=torch.float16, device=device)\n",
+    "\n",
+    "pipe = DiffusionPipeline.from_pretrained(\n",
+    "   model_id, unet=model, variant=\"fp16\", torch_dtype=torch.float16,\n",
+    ").to(device)\n",
+    "\n",
+    "prompt = \"toy_face of a hacker with a hoodie, pixel art\"\n",
+    "image = pipe(prompt, num_inference_steps=30, generator=torch.manual_seed(0)).images[0]\n",
+    "image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 1000,
+     "referenced_widgets": [
+      "8b88a1a63cf242de8a68962f50498c72",
+      "777c5583820248838f0c39e82362d9e3",
+      "491da86a94c44b7c87366b4bb72a3bd1",
+      "31c3a375a2964a06a2473925fe9b197b",
+      "0ba0a0fca31c482bb628a6739d341601",
+      "734e9a834ff74b64b17453013208a116",
+      "9784d9210d6e4214b78ab5f8c33e8044",
+      "490be826ebc14d5ab4e9f0e10ec79d5f",
+      "64ea3c5cc12841f59d1acba12deb6a88",
+      "fc1391aaeaad4eecad967e800a669ec1",
+      "272fceb4e9484b389067080872b1abf9",
+      "5ab5097f19cf4474945f96741c444d71",
+      "6d8fdd0303774305ae20dd39e2a1706c",
+      "031a326124f1496abe1f3bf8de720029",
+      "b9feee6f48bd49209e72e5c5e3136f67",
+      "a2d497a2ddb04d8fac8a4c0f8aa7f5dc",
+      "7bb3f4cda33947138c61aac74d952289",
+      "d3b73a841e68425994632d0f05cf4f16",
+      "71ad1e3dbe44437d8df985cfae207dcd",
+      "598fa824f517445394d08c37393f9f3d",
+      "daad0d12aff8470d990fbbbbe19d5891",
+      "16e18e872ab64b3f8bfb32f580c3371b"
+     ]
+    },
+    "id": "sQOnSrteuS-S",
+    "outputId": "44c5e61a-370b-44bf-a5e5-80b7787088e5"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading pipeline components...: 100%|██████████| 7/7 [00:00<00:00, 14.10it/s]\n",
+      "100%|██████████| 30/30 [00:03<00:00,  9.26it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/jpeg": "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",
+      "image/png": "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",
+      "text/plain": [
+       "<PIL.Image.Image image mode=RGB size=1024x1024>"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "del pipe\n",
+    "\n",
+    "pipe = DiffusionPipeline.from_pretrained(\n",
+    "    model_id, variant=\"fp16\", dtype=torch.float16,\n",
+    ").to(device)\n",
+    "\n",
+    "prompt = \"toy_face of a hacker with a hoodie, pixel art\"\n",
+    "image = pipe(prompt, num_inference_steps=30, generator=torch.manual_seed(0)).images[0]\n",
+    "image"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "gpuType": "A100",
+   "machine_shape": "hm",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  },
+  "widgets": {
+   "application/vnd.jupyter.widget-state+json": {
+    "0027f3aa006d4276983691ad985ce91b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "017dc44dbe1c4de491e003a1e279a218": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "01b20535e40b47068723073ac6c819ee": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "0204153b17ca4bb0b21fc033393ce9bd": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "031a326124f1496abe1f3bf8de720029": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_71ad1e3dbe44437d8df985cfae207dcd",
+      "max": 30,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_598fa824f517445394d08c37393f9f3d",
+      "value": 30
+     }
+    },
+    "0371aa5607604c06a868deb2a413cb31": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "04846af1def142ffad328d434ba228fe": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "05700817adac4fdda6c95dd00eaeae38": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "05791b70a24a42138755141602399c47": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5c838962c7854541b61877c6d42481c4",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4d54c07dd8e94557b82521772c1a2825",
+      "value": " 17/17 [01:04&lt;00:00, 14.56s/it]"
+     }
+    },
+    "061fcc6e5f3c44c48cde212c1ba515e5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "071e40d45ad14fc19b1480927d15d2ae": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "07da49088e8d480fad03a2e828357872": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0805d34df44f451d9b9910dbe5999245": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_babce0e85baf4279ae1d22d64006667f",
+      "placeholder": "​",
+      "style": "IPY_MODEL_5cf6cd09cda64d688f4a0f7c511533d0",
+      "value": "vae/config.json: 100%"
+     }
+    },
+    "08fddacdff4b4ae09adb5440fd86ae86": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "09172ff4be4e433483d27b576464d1df": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "0918b23f41e0404e82fccd08cadc6ccf": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "09638c8da74f4dddaf1d5d94dd8ad885": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "097fa44254ea4ecda7c8db995f370afc": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0b0a85e1133c4ca3ba716e2403511703": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_34fcd527a59748cf832c9efdb954fc0e",
+      "placeholder": "​",
+      "style": "IPY_MODEL_fd672cd5ba0c4695be4240707dcf4bf3",
+      "value": " 7/7 [00:01&lt;00:00,  9.61it/s]"
+     }
+    },
+    "0b53b908088648e3b2beadaeba0f5da1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a3ce5829f8a640e79a19d737663b8474",
+      "max": 565,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_62afb52a01924566b52f6c2d9ffb76f4",
+      "value": 565
+     }
+    },
+    "0b7ffee735044ece90f010c6771d2d69": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_27671f87d0f3400b89e34bc428daa53c",
+       "IPY_MODEL_33a018bf2ed547caa69f8ca91dcbb112",
+       "IPY_MODEL_a91df5ceea8647d98f4d49701bb00969"
+      ],
+      "layout": "IPY_MODEL_c8555cb30ade40b9bd9a3435d6deeb67"
+     }
+    },
+    "0ba0a0fca31c482bb628a6739d341601": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0bca833a6aa74ebaa8f69feb738806bf": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_47468a75637d436f849283c295a74ab6",
+      "placeholder": "​",
+      "style": "IPY_MODEL_af5003cf40ae4dfaa0660f247598856e",
+      "value": " 170M/170M [00:07&lt;00:00, 22.4MB/s]"
+     }
+    },
+    "0c68c6c65fb94650b15069a25d9e1699": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0cf822f588244e54b5264176f9611164": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0d786d8386ba49d0b53a5452d52e722d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0e49d820da754da785bec2e5940eb9f6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_33d459c0fbfe45389abe7eb43d2710a1",
+      "placeholder": "​",
+      "style": "IPY_MODEL_dd42a2ff90854b74ba5fde1de26b4e15",
+      "value": "text_encoder/config.json: 100%"
+     }
+    },
+    "0f60c0f123954744ad13b670ca6dce77": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d2ed1988cf8c4bcdb1793b3d5068efed",
+      "max": 1059962,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_6f113303101b4f448380a878d8900bf6",
+      "value": 1059962
+     }
+    },
+    "10690b309908402289e9891203714199": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "1074a274530e46c5b5a3e43653da43d0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5dd09616ba6544c499271054e8d8d2c5",
+      "placeholder": "​",
+      "style": "IPY_MODEL_fdb1fd279a0241429e5721ae2e92d217",
+      "value": "toy/adapter_config.json: 100%"
+     }
+    },
+    "10bc970e474a46249e2a5e9e43fec7be": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "13ac509e0d5f42e9bbb6deda62f77923": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "13f5160dd981465890ada8a2cef22d5e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "153a93d930df4ee396e03f1aaa6f04f1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_c8e40d44aeac47a78f6502771f1471b7",
+       "IPY_MODEL_270ddad8d7704f929a28c9fbbdabfa26",
+       "IPY_MODEL_e57d317b3dda43bba13ecd4514f776d3"
+      ],
+      "layout": "IPY_MODEL_22b55b5ee1af4ea7b1acfe511b194cd8"
+     }
+    },
+    "157c0c1e85ef40fb99e6cfe0e176be38": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "16e18e872ab64b3f8bfb32f580c3371b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "17691a346ca5407a99a5e385450c97eb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_bc07cdaad5b64fb3b0e1f8c214bba813",
+      "max": 170461008,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_9e2e87c131a140a2a37dfdf483d27ced",
+      "value": 170461008
+     }
+    },
+    "17c29bbcbc0c437c9c8bc83e0b085f1a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "18e3ba4a61784f04b3238cf273c90c3e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "19679186751b42e3ad2c44ea46c82a9c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1971fcd35a564c449b4f437dac46058f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_dc4391fe30694a788134fffdd2a23d1a",
+      "max": 1389382176,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_cfc6ec59d45d42d187f42061902abbfb",
+      "value": 1389382176
+     }
+    },
+    "1e6c1c848e364ce4841ddcaa1383cfba": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_fe19dcea6d9a44d28f077e065f1671c4",
+      "max": 460,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_08fddacdff4b4ae09adb5440fd86ae86",
+      "value": 460
+     }
+    },
+    "1e8747251a1f4cca970857911d1c4a98": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_dd9666d76af04b72b08f59023eb04ee3",
+      "placeholder": "​",
+      "style": "IPY_MODEL_2702528a2ca049fc800ad44c492690ae",
+      "value": "100%"
+     }
+    },
+    "222da37b5af14d60814c65cdd1ea20be": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "22a2ea45880f4b0da47f1b213882dcb0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_2d7e7e816a63428b8f30471a12b57bc4",
+      "placeholder": "​",
+      "style": "IPY_MODEL_e15aab8dd01f4d5582db80e6ad9931fc",
+      "value": " 30/30 [00:07&lt;00:00,  4.07it/s]"
+     }
+    },
+    "22b55b5ee1af4ea7b1acfe511b194cd8": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "22e894ba852e4072a1f63a83b3a98b16": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_95e24bbc8397455fabb724ed3c330511",
+       "IPY_MODEL_d35b3848508c4b6390c243866649439d",
+       "IPY_MODEL_c7cf10df8d7944aeb93947d5f4156c92"
+      ],
+      "layout": "IPY_MODEL_8e3b0b9f26a34ab8a932756b32834fd0"
+     }
+    },
+    "230bd59922e84b90b0a141b3ac1e681b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f8e6babf4fdd4c8e80d6dd24ff22d464",
+      "placeholder": "​",
+      "style": "IPY_MODEL_5e030e8a026b4513aa954203169f0a27",
+      "value": "text_encoder_2/config.json: 100%"
+     }
+    },
+    "23c0492f021a4b60b1d84b0b82d15378": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5405d8a1aa1d411b895b0523fb8e4ce7",
+      "placeholder": "​",
+      "style": "IPY_MODEL_04846af1def142ffad328d434ba228fe",
+      "value": " 5.12k/5.12k [00:00&lt;00:00, 358kB/s]"
+     }
+    },
+    "2460b9e05b58481e898b139b94532c14": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "24cbd9338ad94801aa11f4dcb2a867cb": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2671327d35e64f0da670a3a611fd0886": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "2702528a2ca049fc800ad44c492690ae": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "270ddad8d7704f929a28c9fbbdabfa26": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_13f5160dd981465890ada8a2cef22d5e",
+      "max": 170461008,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_cc06ed7338b74ae6a1c563212aeb9f94",
+      "value": 170461008
+     }
+    },
+    "272fceb4e9484b389067080872b1abf9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "27671f87d0f3400b89e34bc428daa53c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b28a2b59aab9478e9ac3ab24a1de6f9a",
+      "placeholder": "​",
+      "style": "IPY_MODEL_c08fca70486040069d4f8f1df46a1074",
+      "value": "model_index.json: 100%"
+     }
+    },
+    "28a5059a2cc445d783e94ad5d83a0748": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_faddc146c69545cdaeb81edc8a0cda70",
+       "IPY_MODEL_cd08b99de03c483a965248ff4df752ba",
+       "IPY_MODEL_d37c6ac25fd34a65bf307896443a5063"
+      ],
+      "layout": "IPY_MODEL_66da596ae59d474f8a82a600174adff6"
+     }
+    },
+    "29b67774c6944bc7ab93e7ba0eaf867f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_0805d34df44f451d9b9910dbe5999245",
+       "IPY_MODEL_2f2c0ea0fc914e7981e34d01751f74d8",
+       "IPY_MODEL_5f52ae61812544f29f774f80fcb7a09c"
+      ],
+      "layout": "IPY_MODEL_ca5dc8342ef946a49d9e67a21f1a67c8"
+     }
+    },
+    "2a0f746d6eab4680b6c44ec5cdbd8fd9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "2c352a90375443da835eef55b3e63303": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_db8fd6b2687c449fa0600d3e87c96999",
+       "IPY_MODEL_17691a346ca5407a99a5e385450c97eb",
+       "IPY_MODEL_0bca833a6aa74ebaa8f69feb738806bf"
+      ],
+      "layout": "IPY_MODEL_6bdb9b0b68c24b84a748c18ed927a8d3"
+     }
+    },
+    "2c75632d8fdc4458814055172d1d72c3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2d7e7e816a63428b8f30471a12b57bc4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2db944a049a04426bba181fddb2801b1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2e18ce21c01a4a3ca992622957e7d297": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "2ece04bc10934b3cb9d383abfc5ccd6e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2ef25bd6dd644347baac12366d7002fd": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2f016774e7854ef589442734d0bb2f08": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2f2c0ea0fc914e7981e34d01751f74d8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f668dd13af6f41d8be358f7db5261c54",
+      "max": 642,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_8a8ef60b3b72452fb9ccc31052ab3b4f",
+      "value": 642
+     }
+    },
+    "2ffbf400ff1f4cc9b358bb10c6b9d99f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "30bfac68f4224152b048d6ccf6013c5c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "31c3a375a2964a06a2473925fe9b197b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_fc1391aaeaad4eecad967e800a669ec1",
+      "placeholder": "​",
+      "style": "IPY_MODEL_272fceb4e9484b389067080872b1abf9",
+      "value": " 7/7 [00:01&lt;00:00,  4.28it/s]"
+     }
+    },
+    "32132ecbe71a4c2c903932513c2a1aa0": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "33a018bf2ed547caa69f8ca91dcbb112": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_bab2458ba3f54b229828ad9c8706aba4",
+      "max": 609,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_2a0f746d6eab4680b6c44ec5cdbd8fd9",
+      "value": 609
+     }
+    },
+    "33d459c0fbfe45389abe7eb43d2710a1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "34fcd527a59748cf832c9efdb954fc0e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "355efc45ddaf42498d72d6134a28c87b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "35c810f4bfe741f091f172cede413950": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "39e4bdf8d621451f984f6e7302fd6961": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3a017f1d0ebf4a4aab57ac3eb0788774": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3a0e9adc345f409cbcd79d1bd19219e6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_89ed71090d5c4366b21d25ad102e7da7",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4ab21d7b956e46348ad6f6542fd92c2d",
+      "value": " 30/30 [00:08&lt;00:00,  4.13it/s]"
+     }
+    },
+    "3c222a56d4404863a1dac60f1d03835b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_30bfac68f4224152b048d6ccf6013c5c",
+      "placeholder": "​",
+      "style": "IPY_MODEL_971f59d5f3e04697b3ab3c39ec0fc667",
+      "value": "tokenizer_2/vocab.json: 100%"
+     }
+    },
+    "3e1ec3a51e9b4fbbab489d34640cda90": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6466eff2786241eeb142f17758894bb2",
+      "placeholder": "​",
+      "style": "IPY_MODEL_c181408b9b2b437ca11d584e3d1e94e7",
+      "value": "100%"
+     }
+    },
+    "3e418e46c47841ac9d717a6981807f68": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "3ede828a0374453e9aac9a6695befae3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "3fe7e7f00ca746cc8cc762da6f365fde": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "40ff502d2d5c40378c25cf84dd3323c8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_230bd59922e84b90b0a141b3ac1e681b",
+       "IPY_MODEL_6d0f946764444df28cb0da0fd0a408eb",
+       "IPY_MODEL_c995197e66e04874a9f5d34db98b8890"
+      ],
+      "layout": "IPY_MODEL_f2596717405c40e1a39b721386e7a972"
+     }
+    },
+    "414f8301f76043758f69bbfb6960072d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7ba112dcece64386bdbac6837004891b",
+      "max": 5116,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_2ffbf400ff1f4cc9b358bb10c6b9d99f",
+      "value": 5116
+     }
+    },
+    "416f31db79fd431fb8dc06e994421b70": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a6295c7e7630444c9b7425b884ad9707",
+      "placeholder": "​",
+      "style": "IPY_MODEL_3ede828a0374453e9aac9a6695befae3",
+      "value": "model.fp16.safetensors: 100%"
+     }
+    },
+    "421b59f4021d4c4d930c51b6b4c7071f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "42a623abc5d84c0eb7de4e5323bb6546": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "439cf6c6f9e845cea4008e3219454ff4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "447d29db05384c55a57c5fb1bd121af4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "460c3c96d1724713b78bddcfc1f3eb97": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "47468a75637d436f849283c295a74ab6": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "484f694f734b4a92a14ecc4d048db0af": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_157c0c1e85ef40fb99e6cfe0e176be38",
+      "placeholder": "​",
+      "style": "IPY_MODEL_99717def9b6b4afe8a411a3bb83320c9",
+      "value": " 171M/171M [00:00&lt;00:00, 331MB/s]"
+     }
+    },
+    "486282a4ead148868005c592d74a4ed4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "48643ea67f2f4762bcd27de1d4cf0fd2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "48f51c96b7574946bf9542633eb39135": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "490be826ebc14d5ab4e9f0e10ec79d5f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "491da86a94c44b7c87366b4bb72a3bd1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_490be826ebc14d5ab4e9f0e10ec79d5f",
+      "max": 7,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_64ea3c5cc12841f59d1acba12deb6a88",
+      "value": 7
+     }
+    },
+    "49bb475a11104e9496f2623e3d5caebd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "4a4a50a17c014f189b52119901104d79": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "4ab21d7b956e46348ad6f6542fd92c2d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4abac6a83641414499f9b6b1514d1695": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4cae160456c74a5fa761f026d64b2e35": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4d327c9e91b34c7b84cedd8f9660e9fd": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4d54c07dd8e94557b82521772c1a2825": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4e77d8b6cdb94fc68974d27b24cfb3fd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6a8a634cd3844fa081a4622d224ec940",
+      "max": 246144152,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_2460b9e05b58481e898b139b94532c14",
+      "value": 246144152
+     }
+    },
+    "4f56214f69034077bafdfdabc1c2aebf": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4f6e7b21ba0747f19b9d63468861c988": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4fa4f545258b4d6ca014a4c84ec4b24a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_993e5303f107468f83dbf51026e64301",
+       "IPY_MODEL_1e6c1c848e364ce4841ddcaa1383cfba",
+       "IPY_MODEL_d432098a941c463599648b156abea24b"
+      ],
+      "layout": "IPY_MODEL_917139ad07a64e0cae89f2beeffae956"
+     }
+    },
+    "4fbaa1bd51bf4b1e90337a435604d2bd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "5161248cd0384d5887ed231ecd48c82e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_097fa44254ea4ecda7c8db995f370afc",
+      "placeholder": "​",
+      "style": "IPY_MODEL_9fb982789fbc4582bceb356e351db438",
+      "value": "unet/config.json: 100%"
+     }
+    },
+    "5269d405725946b3a657d3a8d7b25885": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "52c7e22284b0468c8bc0c3b1cad047fb": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5405d8a1aa1d411b895b0523fb8e4ce7": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "54417d8b9c5249d0a028d9e831dd8be6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "54ab158c643540abb8b3a96c1ae3ecab": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_55130e37444844f88286a87c8d153eba",
+       "IPY_MODEL_7e3048e0fac94dfdaca1bc862ecfce15",
+       "IPY_MODEL_643ba607008547ba9572fa4880a7d0f2"
+      ],
+      "layout": "IPY_MODEL_5738e5d103254c5485856f97d82954ab"
+     }
+    },
+    "550b3ad10fcb422eb66f71ad95988616": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "55130e37444844f88286a87c8d153eba": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_beedc3b275c24432a2e959dcf9dd418d",
+      "placeholder": "​",
+      "style": "IPY_MODEL_10690b309908402289e9891203714199",
+      "value": "scheduler/scheduler_config.json: 100%"
+     }
+    },
+    "55177afb435f44898df300143703e4d8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7049676db714446b98bba16b5f1b049e",
+      "placeholder": "​",
+      "style": "IPY_MODEL_09172ff4be4e433483d27b576464d1df",
+      "value": "tokenizer/tokenizer_config.json: 100%"
+     }
+    },
+    "556730e12d5d4e0ea51a0dd1b5aac331": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_2f016774e7854ef589442734d0bb2f08",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a15c3a32bfd347a98c2a50d27cd5b9f9",
+      "value": "diffusion_pytorch_model.fp16.safetensors: 100%"
+     }
+    },
+    "5738e5d103254c5485856f97d82954ab": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "577cc4b4f27941189c62951046db24ec": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "57b491647f1e49cea7ce34774a963936": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c040aa1f65514be28f0ca8ecdd1f69e4",
+      "max": 170543052,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_eec76868d92f45d7a6db2e232a45e0c2",
+      "value": 170543052
+     }
+    },
+    "584dd148b2344bdc92f1d0850399aed7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_67ef71b6521b47dd90e3dc0fd03016f2",
+      "max": 5135149760,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_989c54778eb7469fb91e4337d6f49b0b",
+      "value": 5135149760
+     }
+    },
+    "587bd0b90afa450ba82e49cf86ee135d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_cf42fc299989442f94f4a9df63005ab4",
+      "placeholder": "​",
+      "style": "IPY_MODEL_90b9300ba00e41e58170ec5634622985",
+      "value": " 725/725 [00:00&lt;00:00, 55.6kB/s]"
+     }
+    },
+    "598fa824f517445394d08c37393f9f3d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "5a4c6dc09a1049c0adfca9834b045a25": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_fd13a58d6b444a0f955832647f64df12",
+      "max": 472,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_8d492d53eb7f4225b516a65ef80f24e5",
+      "value": 472
+     }
+    },
+    "5a7d87338ddc45df84080e0096a31631": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "5ab5097f19cf4474945f96741c444d71": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_6d8fdd0303774305ae20dd39e2a1706c",
+       "IPY_MODEL_031a326124f1496abe1f3bf8de720029",
+       "IPY_MODEL_b9feee6f48bd49209e72e5c5e3136f67"
+      ],
+      "layout": "IPY_MODEL_a2d497a2ddb04d8fac8a4c0f8aa7f5dc"
+     }
+    },
+    "5b3bbc663d504fb99318ba186e6b8499": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5c3d142907404cef8fd624839a166530": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_abaecfe7f39a43bb8fbd655d1a3009f4",
+       "IPY_MODEL_d488374da5e74ec3a5973003590a7d69",
+       "IPY_MODEL_5d8ae9661dce4a1aac8d418d84f3a209"
+      ],
+      "layout": "IPY_MODEL_32132ecbe71a4c2c903932513c2a1aa0"
+     }
+    },
+    "5c838962c7854541b61877c6d42481c4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5ceb5c369f974b84ba850c9e81730a0e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "5cf6cd09cda64d688f4a0f7c511533d0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "5d8ae9661dce4a1aac8d418d84f3a209": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_887c5eae5b154eccb4a1caa3deef6e94",
+      "placeholder": "​",
+      "style": "IPY_MODEL_e87dffe17f1948e9ba794eddb605a908",
+      "value": " 47.3k/47.3k [00:00&lt;00:00, 3.39MB/s]"
+     }
+    },
+    "5dd09616ba6544c499271054e8d8d2c5": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5e030e8a026b4513aa954203169f0a27": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "5e677518051c43768dbf06243701c817": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_d727913663634e368ade4a7dc64fe74b",
+       "IPY_MODEL_eb73095c804a4272856fe348fa3cb1e9",
+       "IPY_MODEL_7e9b46b10fa24dfea489dfbc150d2a2e"
+      ],
+      "layout": "IPY_MODEL_c8156b0cc68e4b3693dcabc530a4ea9a"
+     }
+    },
+    "5f52ae61812544f29f774f80fcb7a09c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7d29b20296aa4e33837b8ad53fc4adba",
+      "placeholder": "​",
+      "style": "IPY_MODEL_6a94d1d176b844db96de0c0e3cd67701",
+      "value": " 642/642 [00:00&lt;00:00, 35.8kB/s]"
+     }
+    },
+    "60cc7415644d4e16b88f8fc5896b4b3b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "60e8e9f8e6ce40dd910ce1a9410b5e24": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "61db57127c5845759360bdf8b29dac2d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f46df85f441e4ada831f0e2b142f296a",
+      "placeholder": "​",
+      "style": "IPY_MODEL_d4f1dbe4ce244abc987b1089876e080f",
+      "value": "tokenizer_2/tokenizer_config.json: 100%"
+     }
+    },
+    "62afb52a01924566b52f6c2d9ffb76f4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "64029a1e70e040b49e38d38bd36823fd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_3e1ec3a51e9b4fbbab489d34640cda90",
+       "IPY_MODEL_ea0910fc31e44597968b2129272cc94d",
+       "IPY_MODEL_3a0e9adc345f409cbcd79d1bd19219e6"
+      ],
+      "layout": "IPY_MODEL_3fe7e7f00ca746cc8cc762da6f365fde"
+     }
+    },
+    "643ba607008547ba9572fa4880a7d0f2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_2ef25bd6dd644347baac12366d7002fd",
+      "placeholder": "​",
+      "style": "IPY_MODEL_0918b23f41e0404e82fccd08cadc6ccf",
+      "value": " 479/479 [00:00&lt;00:00, 40.5kB/s]"
+     }
+    },
+    "6466eff2786241eeb142f17758894bb2": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "64ea3c5cc12841f59d1acba12deb6a88": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "65b15618abfd4e6f9fafd64813e86ace": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_1e8747251a1f4cca970857911d1c4a98",
+       "IPY_MODEL_caa46820018f47abab4a962afe51cc34",
+       "IPY_MODEL_22a2ea45880f4b0da47f1b213882dcb0"
+      ],
+      "layout": "IPY_MODEL_0cf822f588244e54b5264176f9611164"
+     }
+    },
+    "65bf3df199b44763aa223fee96889e17": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_a32666723b0e4b9883a78f56295c4356",
+       "IPY_MODEL_c08373a044204308ac882dd8cf9cdd3e",
+       "IPY_MODEL_fa7876ade8e240fc89a35a1f8c7c7d3c"
+      ],
+      "layout": "IPY_MODEL_de583920d3b54774a486aef4c052e50d"
+     }
+    },
+    "66da596ae59d474f8a82a600174adff6": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6703a0417c474db5bf261fe8679051e9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "6715d91c6b62426aa49c344b65bcd8a2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_bd176c410a4e48a382a1b688e77aafcb",
+      "max": 7,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_6b586ad7a3054c83b14243d69484127f",
+      "value": 7
+     }
+    },
+    "67567eea233b423c8acd62773a4adb30": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_5161248cd0384d5887ed231ecd48c82e",
+       "IPY_MODEL_6f72ea2c284e4e40899375c7b07c517f",
+       "IPY_MODEL_d99a364420454ba5bfd510d1226b94af"
+      ],
+      "layout": "IPY_MODEL_d33c90e8ea0945d397659f6a90cf51b6"
+     }
+    },
+    "67a03631ebc54f99928f0feb18ab38af": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "67b7783351d340d99c44149635b9be84": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4cae160456c74a5fa761f026d64b2e35",
+      "placeholder": "​",
+      "style": "IPY_MODEL_819a26acd18f443882feb129f2c576d6",
+      "value": "tokenizer/vocab.json: 100%"
+     }
+    },
+    "67ef71b6521b47dd90e3dc0fd03016f2": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "683863a313034025ab99fab5810f39c7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "683db0ff105a47038c350cfc74b88345": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "685797f8907c47ffab4fe7a81ca22e63": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_222da37b5af14d60814c65cdd1ea20be",
+      "placeholder": "​",
+      "style": "IPY_MODEL_6a2b5bbd4afe4e0cabe39e95ccf528be",
+      "value": "README.md: 100%"
+     }
+    },
+    "68822f8f861a48859df630fad63f51c1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6926c8dd4e4e46d089bb387333691df7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_adf53d97af214cceaae895c8abfbd909",
+      "max": 170461008,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_9d74948f7bcb498c9295e41e690a0a8d",
+      "value": 170461008
+     }
+    },
+    "6a2b5bbd4afe4e0cabe39e95ccf528be": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "6a8a634cd3844fa081a4622d224ec940": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6a94d1d176b844db96de0c0e3cd67701": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "6b586ad7a3054c83b14243d69484127f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "6bdb9b0b68c24b84a748c18ed927a8d3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6d0f946764444df28cb0da0fd0a408eb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f9ca5d4810b34938b6f997ff66a8d541",
+      "max": 575,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_b418ff1733db4efbab1b00b632b894e2",
+      "value": 575
+     }
+    },
+    "6d492ddabcbe4d65b5d311834865ab92": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_ee8407365f5d42d9b98536152c9efe92",
+      "max": 524619,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_5ceb5c369f974b84ba850c9e81730a0e",
+      "value": 524619
+     }
+    },
+    "6d8fdd0303774305ae20dd39e2a1706c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7bb3f4cda33947138c61aac74d952289",
+      "placeholder": "​",
+      "style": "IPY_MODEL_d3b73a841e68425994632d0f05cf4f16",
+      "value": "100%"
+     }
+    },
+    "6f113303101b4f448380a878d8900bf6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "6f6a6cfd50404f1ea09f83e95b04550a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6f72ea2c284e4e40899375c7b07c517f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_0204153b17ca4bb0b21fc033393ce9bd",
+      "max": 1680,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_f02041b1d5e1485bb2ba02b00fc2c242",
+      "value": 1680
+     }
+    },
+    "7049676db714446b98bba16b5f1b049e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "70849993c0c94ecf87c56e430f06181d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "713dec1904ce46f6b2d5a9b7e3e0373a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "71ad1e3dbe44437d8df985cfae207dcd": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "734e9a834ff74b64b17453013208a116": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "75384779c5d540d28afb53a0e318b674": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7f63b3d80ecb4c3eb837bd0e616e1623",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4f6e7b21ba0747f19b9d63468861c988",
+      "value": " 167M/167M [00:07&lt;00:00, 24.0MB/s]"
+     }
+    },
+    "753f64d9069640d985f399a058fc9b5b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "766567be45eb4db6b8d7a3364566c1dc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_3c222a56d4404863a1dac60f1d03835b",
+       "IPY_MODEL_db862ffbb44d450db514173df4c7f301",
+       "IPY_MODEL_ddbeb13bb8174fc0b7d5543108d1c4f5"
+      ],
+      "layout": "IPY_MODEL_5b3bbc663d504fb99318ba186e6b8499"
+     }
+    },
+    "76a474e4aab14a5987cf25d1391d578c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_68822f8f861a48859df630fad63f51c1",
+      "placeholder": "​",
+      "style": "IPY_MODEL_2671327d35e64f0da670a3a611fd0886",
+      "value": " 1.39G/1.39G [01:02&lt;00:00, 24.3MB/s]"
+     }
+    },
+    "777c5583820248838f0c39e82362d9e3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_734e9a834ff74b64b17453013208a116",
+      "placeholder": "​",
+      "style": "IPY_MODEL_9784d9210d6e4214b78ab5f8c33e8044",
+      "value": "Loading pipeline components...: 100%"
+     }
+    },
+    "7a52c380a91c4f49bbfde658550248d3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7ba112dcece64386bdbac6837004891b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7bb3f4cda33947138c61aac74d952289": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7c6c4dff0a814bc6a7ac677980b45add": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7d282fda276343c3aff99b001253ecc1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7d29b20296aa4e33837b8ad53fc4adba": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7e3048e0fac94dfdaca1bc862ecfce15": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_0c68c6c65fb94650b15069a25d9e1699",
+      "max": 479,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_ad233dfd52034b9e8c6c2c5b86995717",
+      "value": 479
+     }
+    },
+    "7e9b46b10fa24dfea489dfbc150d2a2e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_2db944a049a04426bba181fddb2801b1",
+      "placeholder": "​",
+      "style": "IPY_MODEL_683863a313034025ab99fab5810f39c7",
+      "value": " 171M/171M [00:00&lt;00:00, 302MB/s]"
+     }
+    },
+    "7f63b3d80ecb4c3eb837bd0e616e1623": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "804e7ee768794bba88aec3137f418868": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7a52c380a91c4f49bbfde658550248d3",
+      "placeholder": "​",
+      "style": "IPY_MODEL_3e418e46c47841ac9d717a6981807f68",
+      "value": " 565/565 [00:00&lt;00:00, 16.6kB/s]"
+     }
+    },
+    "819a26acd18f443882feb129f2c576d6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "83afce4becac4f37ba916bf1901346ff": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "83f2d1dfaba54da38f0421b69930c3c1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "85f22e78d47641d19efb6e6d62f6a014": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_d8bbb7402f3e44b2899fc98f02cee87e",
+       "IPY_MODEL_8b41763280a048d485f06682ddc12ca2",
+       "IPY_MODEL_05791b70a24a42138755141602399c47"
+      ],
+      "layout": "IPY_MODEL_753f64d9069640d985f399a058fc9b5b"
+     }
+    },
+    "86cb336c1f684867bd13dae0370b4d36": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "8840288388ae4162884feef9c8e776f7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_67b7783351d340d99c44149635b9be84",
+       "IPY_MODEL_0f60c0f123954744ad13b670ca6dce77",
+       "IPY_MODEL_dfabe7aa70024d1aa868ef5e6650dc6d"
+      ],
+      "layout": "IPY_MODEL_7d282fda276343c3aff99b001253ecc1"
+     }
+    },
+    "887c5eae5b154eccb4a1caa3deef6e94": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "89ed71090d5c4366b21d25ad102e7da7": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8a8ef60b3b72452fb9ccc31052ab3b4f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "8b41763280a048d485f06682ddc12ca2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_9c6ab017f5fb46eda8e3c22e9dd2b838",
+      "max": 17,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_10bc970e474a46249e2a5e9e43fec7be",
+      "value": 17
+     }
+    },
+    "8b6464ce614c4aa29ac66ecce29b6cbf": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "8b88a1a63cf242de8a68962f50498c72": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_777c5583820248838f0c39e82362d9e3",
+       "IPY_MODEL_491da86a94c44b7c87366b4bb72a3bd1",
+       "IPY_MODEL_31c3a375a2964a06a2473925fe9b197b"
+      ],
+      "layout": "IPY_MODEL_0ba0a0fca31c482bb628a6739d341601"
+     }
+    },
+    "8d492d53eb7f4225b516a65ef80f24e5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "8e3b0b9f26a34ab8a932756b32834fd0": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "90558769855c4bb08ff2fe4af940c45b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b79d32186443469d94836b663bf156b5",
+      "max": 167335342,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_86cb336c1f684867bd13dae0370b4d36",
+      "value": 167335342
+     }
+    },
+    "90b9300ba00e41e58170ec5634622985": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "917139ad07a64e0cae89f2beeffae956": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "955ec2551f8b400dbbdba68d7449de76": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "95e24bbc8397455fabb724ed3c330511": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b1d427082b9f452eb6546c7d55016b36",
+      "placeholder": "​",
+      "style": "IPY_MODEL_061fcc6e5f3c44c48cde212c1ba515e5",
+      "value": "diffusion_pytorch_model.fp16.safetensors: 100%"
+     }
+    },
+    "971f59d5f3e04697b3ab3c39ec0fc667": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "9784d9210d6e4214b78ab5f8c33e8044": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "979c68bd2e224a40b939c27f32c25dac": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "9810873713024e79ae6d338dfeae5876": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "989c54778eb7469fb91e4337d6f49b0b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "993e5303f107468f83dbf51026e64301": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_83afce4becac4f37ba916bf1901346ff",
+      "placeholder": "​",
+      "style": "IPY_MODEL_071e40d45ad14fc19b1480927d15d2ae",
+      "value": "tokenizer_2/special_tokens_map.json: 100%"
+     }
+    },
+    "99717def9b6b4afe8a411a3bb83320c9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "9a37ffb9810f482b80f245f64947c371": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "9a9da0d0e3d84a19b5d188c9bd6a83bb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "9ad4192f6f244264aede1b3c8ac3c57a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_fdb799739700447d8a5198f1f4f9b17f",
+      "placeholder": "​",
+      "style": "IPY_MODEL_683db0ff105a47038c350cfc74b88345",
+      "value": "diffusion_pytorch_model.fp16.safetensors: 100%"
+     }
+    },
+    "9c6ab017f5fb46eda8e3c22e9dd2b838": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "9d74948f7bcb498c9295e41e690a0a8d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "9e2e87c131a140a2a37dfdf483d27ced": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "9fb982789fbc4582bceb356e351db438": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a0f8a1a3512443ac84799b95da70ca26": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a15c3a32bfd347a98c2a50d27cd5b9f9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a16016987b6145b69caaac6712d72835": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_c82cf8cf90ed4e93bccffcf75881a56d",
+       "IPY_MODEL_5a4c6dc09a1049c0adfca9834b045a25",
+       "IPY_MODEL_c4d83c2b37504473afe63209a178b4cd"
+      ],
+      "layout": "IPY_MODEL_fae9d16daace412492b048b012b8d6dc"
+     }
+    },
+    "a287f197e4fe4f908e3ee0a0e6cb35cf": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a2d497a2ddb04d8fac8a4c0f8aa7f5dc": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a32666723b0e4b9883a78f56295c4356": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_979c68bd2e224a40b939c27f32c25dac",
+      "placeholder": "​",
+      "style": "IPY_MODEL_0027f3aa006d4276983691ad985ce91b",
+      "value": "Loading pipeline components...: 100%"
+     }
+    },
+    "a3ce5829f8a640e79a19d737663b8474": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a48d3ad24e9744f7898d1f2c5a696ea2": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a6295c7e7630444c9b7425b884ad9707": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a65484354d254516936fcb425917a4b7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a6bb8206de044c74a03d1a64c801e742": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a6f2ce8830734be4b8efe5ca0e14e990": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_de31002ed7fc475c915b4a29253108af",
+      "placeholder": "​",
+      "style": "IPY_MODEL_fbf3d268f30344b7864ce691d5bcb1f3",
+      "value": " 47.3k/47.3k [00:00&lt;00:00, 3.74MB/s]"
+     }
+    },
+    "a708db5805424449afa269b714ebb3b3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_24cbd9338ad94801aa11f4dcb2a867cb",
+      "placeholder": "​",
+      "style": "IPY_MODEL_c88fcf0d20154b1fb9b7e8a00116b5e6",
+      "value": "tokenizer/merges.txt: 100%"
+     }
+    },
+    "a7767d5a440f4c819cdb87414f2187ff": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a91df5ceea8647d98f4d49701bb00969": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5269d405725946b3a657d3a8d7b25885",
+      "placeholder": "​",
+      "style": "IPY_MODEL_b4a697d8335c435ab21219716a1da022",
+      "value": " 609/609 [00:00&lt;00:00, 49.0kB/s]"
+     }
+    },
+    "a9ac3b2188594c19885bcdb9a659ecde": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_a708db5805424449afa269b714ebb3b3",
+       "IPY_MODEL_6d492ddabcbe4d65b5d311834865ab92",
+       "IPY_MODEL_e17e3253c16743a29f09b82d23c3b26d"
+      ],
+      "layout": "IPY_MODEL_e67a69c294334b01974f8bef36f133a0"
+     }
+    },
+    "aae194e7f71f4eba80ffd18f91f083a8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_9ad4192f6f244264aede1b3c8ac3c57a",
+       "IPY_MODEL_90558769855c4bb08ff2fe4af940c45b",
+       "IPY_MODEL_75384779c5d540d28afb53a0e318b674"
+      ],
+      "layout": "IPY_MODEL_a287f197e4fe4f908e3ee0a0e6cb35cf"
+     }
+    },
+    "ab9c869439a94bddbbc0c6098f4c5b2a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_13ac509e0d5f42e9bbb6deda62f77923",
+      "max": 725,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_4a4a50a17c014f189b52119901104d79",
+      "value": 725
+     }
+    },
+    "abaecfe7f39a43bb8fbd655d1a3009f4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_05700817adac4fdda6c95dd00eaeae38",
+      "placeholder": "​",
+      "style": "IPY_MODEL_5a7d87338ddc45df84080e0096a31631",
+      "value": "pixel/adapter_config.json: 100%"
+     }
+    },
+    "abf2248c725b4837b5c2babef7f4ff3e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d872c3900b8b4275b2224c9ec5e7d78f",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4fbaa1bd51bf4b1e90337a435604d2bd",
+      "value": " 170M/170M [00:12&lt;00:00, 18.9MB/s]"
+     }
+    },
+    "ad233dfd52034b9e8c6c2c5b86995717": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "adb2daf9d62f49f8ab1f0144b717d41e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_bba38c266ceb4f30bb4bc1eaf5e3aa96",
+       "IPY_MODEL_6926c8dd4e4e46d089bb387333691df7",
+       "IPY_MODEL_abf2248c725b4837b5c2babef7f4ff3e"
+      ],
+      "layout": "IPY_MODEL_39e4bdf8d621451f984f6e7302fd6961"
+     }
+    },
+    "adf53d97af214cceaae895c8abfbd909": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "aed53b6480de4dd4bc7463af04840952": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "aef81ec1a7e844f883beba8c5754a8af": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "af5003cf40ae4dfaa0660f247598856e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "b0abce2d8a2046dba320e788e33e9d66": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b1d427082b9f452eb6546c7d55016b36": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b25e822b3f77431fb72b4780067c90d9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_55177afb435f44898df300143703e4d8",
+       "IPY_MODEL_b79d3f5bd8024451bc7148ba2a5029bd",
+       "IPY_MODEL_eacd646e2b984e60ab603bfc6d631de8"
+      ],
+      "layout": "IPY_MODEL_d158a80f4186411a8a9c335a8d5a888e"
+     }
+    },
+    "b27ac2aaff694dd5999ab2cba91195da": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_556730e12d5d4e0ea51a0dd1b5aac331",
+       "IPY_MODEL_584dd148b2344bdc92f1d0850399aed7",
+       "IPY_MODEL_ccc5bdc185a84901994577ff7f1bc962"
+      ],
+      "layout": "IPY_MODEL_2c75632d8fdc4458814055172d1d72c3"
+     }
+    },
+    "b27c74f0c7bf493fa8bcb4c5b9c9c100": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b28a2b59aab9478e9ac3ab24a1de6f9a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b3eaa188cc2e48d081488eea4ed2971f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "b418ff1733db4efbab1b00b632b894e2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "b44f7154c55146a3bf5f4bd9e438086f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "b4a697d8335c435ab21219716a1da022": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "b600178b161d4a87a0b832a169d7caf2": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b79d32186443469d94836b663bf156b5": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b79d3f5bd8024451bc7148ba2a5029bd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_ea257c1c73524141b87ab3c1ef85c908",
+      "max": 737,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_c474ed5e340146baae6c38f62013afe3",
+      "value": 737
+     }
+    },
+    "b999b3e3af3744a79c0c90657ef37d4e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_713dec1904ce46f6b2d5a9b7e3e0373a",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a6bb8206de044c74a03d1a64c801e742",
+      "value": ""
+     }
+    },
+    "b9feee6f48bd49209e72e5c5e3136f67": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_daad0d12aff8470d990fbbbbe19d5891",
+      "placeholder": "​",
+      "style": "IPY_MODEL_16e18e872ab64b3f8bfb32f580c3371b",
+      "value": " 30/30 [00:03&lt;00:00,  8.40it/s]"
+     }
+    },
+    "ba9b002888b448738ba4b127e1046f5d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "bab2458ba3f54b229828ad9c8706aba4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "babce0e85baf4279ae1d22d64006667f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "bba38c266ceb4f30bb4bc1eaf5e3aa96": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4abac6a83641414499f9b6b1514d1695",
+      "placeholder": "​",
+      "style": "IPY_MODEL_bf6e103b43844f17968eadf223a42acb",
+      "value": "adapter_model.safetensors: 100%"
+     }
+    },
+    "bc07cdaad5b64fb3b0e1f8c214bba813": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "bcb3ec98d25b4c138c5e8f84c1e937c6": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "bd176c410a4e48a382a1b688e77aafcb": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "bd2740e191a74558a77a965b4f2d7f28": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_48f51c96b7574946bf9542633eb39135",
+      "placeholder": "​",
+      "style": "IPY_MODEL_35c810f4bfe741f091f172cede413950",
+      "value": " 0/0 [00:00&lt;?, ?it/s]"
+     }
+    },
+    "bdfe4e4109a14a41bcd2e1e4242d82bb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "beedc3b275c24432a2e959dcf9dd418d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "bf6e103b43844f17968eadf223a42acb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "c008577d922e436aabb8680ca0d13117": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "c040aa1f65514be28f0ca8ecdd1f69e4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c05842ed12c848c68c4a69de9aa742a8": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c08373a044204308ac882dd8cf9cdd3e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a0f8a1a3512443ac84799b95da70ca26",
+      "max": 7,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_e08d739f59874064994212363a307f6e",
+      "value": 7
+     }
+    },
+    "c08fca70486040069d4f8f1df46a1074": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "c181408b9b2b437ca11d584e3d1e94e7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "c212598c5a8747f783a6efc18816e868": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "c292a598350d4dd4bb9b70aab1320c29": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_cdd8f9b1592842b48e1ffa80f8ec8246",
+      "placeholder": "​",
+      "style": "IPY_MODEL_ba9b002888b448738ba4b127e1046f5d",
+      "value": " 246M/246M [00:00&lt;00:00, 345MB/s]"
+     }
+    },
+    "c474ed5e340146baae6c38f62013afe3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "c4d83c2b37504473afe63209a178b4cd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_70849993c0c94ecf87c56e430f06181d",
+      "placeholder": "​",
+      "style": "IPY_MODEL_e820c557697648378966ed0a073826c8",
+      "value": " 472/472 [00:00&lt;00:00, 10.4kB/s]"
+     }
+    },
+    "c68a5ad3bb664e8785e724085d208e96": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c6bdeef396174d51af9eee277752bec7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_685797f8907c47ffab4fe7a81ca22e63",
+       "IPY_MODEL_414f8301f76043758f69bbfb6960072d",
+       "IPY_MODEL_23c0492f021a4b60b1d84b0b82d15378"
+      ],
+      "layout": "IPY_MODEL_550b3ad10fcb422eb66f71ad95988616"
+     }
+    },
+    "c7cf10df8d7944aeb93947d5f4156c92": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_de0b54a59d9f47408d92915ad746cd5e",
+      "placeholder": "​",
+      "style": "IPY_MODEL_eb9a5f255fa0447eba6a33e1c30ba166",
+      "value": " 167M/167M [00:08&lt;00:00, 18.9MB/s]"
+     }
+    },
+    "c80901426c87439481078b9da2e0c772": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_416f31db79fd431fb8dc06e994421b70",
+       "IPY_MODEL_1971fcd35a564c449b4f437dac46058f",
+       "IPY_MODEL_76a474e4aab14a5987cf25d1391d578c"
+      ],
+      "layout": "IPY_MODEL_ff3bf3f1873c4b01b0a547dfe02923ce"
+     }
+    },
+    "c8156b0cc68e4b3693dcabc530a4ea9a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c82cf8cf90ed4e93bccffcf75881a56d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_421b59f4021d4c4d930c51b6b4c7071f",
+      "placeholder": "​",
+      "style": "IPY_MODEL_60cc7415644d4e16b88f8fc5896b4b3b",
+      "value": "tokenizer/special_tokens_map.json: 100%"
+     }
+    },
+    "c8555cb30ade40b9bd9a3435d6deeb67": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c88fcf0d20154b1fb9b7e8a00116b5e6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "c8e40d44aeac47a78f6502771f1471b7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a48d3ad24e9744f7898d1f2c5a696ea2",
+      "placeholder": "​",
+      "style": "IPY_MODEL_f29673e57d174839a0bde70bfa165715",
+      "value": "adapter_model.safetensors: 100%"
+     }
+    },
+    "c995197e66e04874a9f5d34db98b8890": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_83f2d1dfaba54da38f0421b69930c3c1",
+      "placeholder": "​",
+      "style": "IPY_MODEL_577cc4b4f27941189c62951046db24ec",
+      "value": " 575/575 [00:00&lt;00:00, 11.1kB/s]"
+     }
+    },
+    "c9f764b5036042af9f1505e3729cbc32": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_b999b3e3af3744a79c0c90657ef37d4e",
+       "IPY_MODEL_f3baef4fbf4b4ec08480522be921f841",
+       "IPY_MODEL_bd2740e191a74558a77a965b4f2d7f28"
+      ],
+      "layout": "IPY_MODEL_6f6a6cfd50404f1ea09f83e95b04550a"
+     }
+    },
+    "ca5dc8342ef946a49d9e67a21f1a67c8": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "caa46820018f47abab4a962afe51cc34": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_aed53b6480de4dd4bc7463af04840952",
+      "max": 30,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_447d29db05384c55a57c5fb1bd121af4",
+      "value": 30
+     }
+    },
+    "cb89ecd5a8c14051985495da1797a202": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_61db57127c5845759360bdf8b29dac2d",
+       "IPY_MODEL_ab9c869439a94bddbbc0c6098f4c5b2a",
+       "IPY_MODEL_587bd0b90afa450ba82e49cf86ee135d"
+      ],
+      "layout": "IPY_MODEL_955ec2551f8b400dbbdba68d7449de76"
+     }
+    },
+    "cb9a536bc56f4d0ebf285e7f73d4730e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "cc06ed7338b74ae6a1c563212aeb9f94": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "ccc5bdc185a84901994577ff7f1bc962": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_439cf6c6f9e845cea4008e3219454ff4",
+      "placeholder": "​",
+      "style": "IPY_MODEL_460c3c96d1724713b78bddcfc1f3eb97",
+      "value": " 5.14G/5.14G [00:14&lt;00:00, 393MB/s]"
+     }
+    },
+    "cd08b99de03c483a965248ff4df752ba": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c05842ed12c848c68c4a69de9aa742a8",
+      "max": 7,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_18e3ba4a61784f04b3238cf273c90c3e",
+      "value": 7
+     }
+    },
+    "cdd8f9b1592842b48e1ffa80f8ec8246": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "cf42fc299989442f94f4a9df63005ab4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "cfc6ec59d45d42d187f42061902abbfb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "d158a80f4186411a8a9c335a8d5a888e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d18c97fe685e4be080125ae770526255": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_e44c018bc76c48cd8738fee5966767ce",
+       "IPY_MODEL_57b491647f1e49cea7ce34774a963936",
+       "IPY_MODEL_484f694f734b4a92a14ecc4d048db0af"
+      ],
+      "layout": "IPY_MODEL_bcb3ec98d25b4c138c5e8f84c1e937c6"
+     }
+    },
+    "d1e4d2fd70e644f986104c998db7e53b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_f786a0f386f6486083c15e576f6eb3e7",
+       "IPY_MODEL_6715d91c6b62426aa49c344b65bcd8a2",
+       "IPY_MODEL_0b0a85e1133c4ca3ba716e2403511703"
+      ],
+      "layout": "IPY_MODEL_017dc44dbe1c4de491e003a1e279a218"
+     }
+    },
+    "d2cd2572973249baa8e130b5777f4147": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b27c74f0c7bf493fa8bcb4c5b9c9c100",
+      "placeholder": "​",
+      "style": "IPY_MODEL_09638c8da74f4dddaf1d5d94dd8ad885",
+      "value": "model.fp16.safetensors: 100%"
+     }
+    },
+    "d2ed1988cf8c4bcdb1793b3d5068efed": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d33c90e8ea0945d397659f6a90cf51b6": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d35b3848508c4b6390c243866649439d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d70508c304794bc79e80aab136eaf65a",
+      "max": 167335342,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_01b20535e40b47068723073ac6c819ee",
+      "value": 167335342
+     }
+    },
+    "d37c6ac25fd34a65bf307896443a5063": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_42a623abc5d84c0eb7de4e5323bb6546",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a65484354d254516936fcb425917a4b7",
+      "value": " 7/7 [00:01&lt;00:00,  6.68it/s]"
+     }
+    },
+    "d3b73a841e68425994632d0f05cf4f16": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "d432098a941c463599648b156abea24b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d62465d39d7e4265832901e9b9707993",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4f56214f69034077bafdfdabc1c2aebf",
+      "value": " 460/460 [00:00&lt;00:00, 33.3kB/s]"
+     }
+    },
+    "d488374da5e74ec3a5973003590a7d69": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_cb9a536bc56f4d0ebf285e7f73d4730e",
+      "max": 47271,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_49bb475a11104e9496f2623e3d5caebd",
+      "value": 47271
+     }
+    },
+    "d4baf7891f854c9c9898314633f97356": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "d4f1dbe4ce244abc987b1089876e080f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "d62465d39d7e4265832901e9b9707993": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d70508c304794bc79e80aab136eaf65a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d727913663634e368ade4a7dc64fe74b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d987907f09084d44b452f939aadff65e",
+      "placeholder": "​",
+      "style": "IPY_MODEL_e976b994189343f5ba7d762ef92c79e2",
+      "value": "toy_face_sdxl.safetensors: 100%"
+     }
+    },
+    "d74b1c667d42472b865ee1cbefc33a60": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_1074a274530e46c5b5a3e43653da43d0",
+       "IPY_MODEL_dfde3984062442869bc8091bb94f2c36",
+       "IPY_MODEL_a6f2ce8830734be4b8efe5ca0e14e990"
+      ],
+      "layout": "IPY_MODEL_07da49088e8d480fad03a2e828357872"
+     }
+    },
+    "d872c3900b8b4275b2224c9ec5e7d78f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d8bbb7402f3e44b2899fc98f02cee87e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_19679186751b42e3ad2c44ea46c82a9c",
+      "placeholder": "​",
+      "style": "IPY_MODEL_d4baf7891f854c9c9898314633f97356",
+      "value": "Fetching 17 files: 100%"
+     }
+    },
+    "d987907f09084d44b452f939aadff65e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d99a364420454ba5bfd510d1226b94af": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4d327c9e91b34c7b84cedd8f9660e9fd",
+      "placeholder": "​",
+      "style": "IPY_MODEL_b44f7154c55146a3bf5f4bd9e438086f",
+      "value": " 1.68k/1.68k [00:00&lt;00:00, 126kB/s]"
+     }
+    },
+    "daad0d12aff8470d990fbbbbe19d5891": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "db862ffbb44d450db514173df4c7f301": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_fe958df746be4dc1871bd58628697c3c",
+      "max": 1059962,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_54417d8b9c5249d0a028d9e831dd8be6",
+      "value": 1059962
+     }
+    },
+    "db8fd6b2687c449fa0600d3e87c96999": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_355efc45ddaf42498d72d6134a28c87b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_8b6464ce614c4aa29ac66ecce29b6cbf",
+      "value": "adapter_model.safetensors: 100%"
+     }
+    },
+    "dc4391fe30694a788134fffdd2a23d1a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "dd42a2ff90854b74ba5fde1de26b4e15": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "dd9666d76af04b72b08f59023eb04ee3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ddbeb13bb8174fc0b7d5543108d1c4f5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_9a37ffb9810f482b80f245f64947c371",
+      "placeholder": "​",
+      "style": "IPY_MODEL_bdfe4e4109a14a41bcd2e1e4242d82bb",
+      "value": " 1.06M/1.06M [00:00&lt;00:00, 42.3MB/s]"
+     }
+    },
+    "de0b54a59d9f47408d92915ad746cd5e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "de31002ed7fc475c915b4a29253108af": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "de583920d3b54774a486aef4c052e50d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "dfabe7aa70024d1aa868ef5e6650dc6d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_60e8e9f8e6ce40dd910ce1a9410b5e24",
+      "placeholder": "​",
+      "style": "IPY_MODEL_6703a0417c474db5bf261fe8679051e9",
+      "value": " 1.06M/1.06M [00:00&lt;00:00, 1.49MB/s]"
+     }
+    },
+    "dfde3984062442869bc8091bb94f2c36": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7c6c4dff0a814bc6a7ac677980b45add",
+      "max": 47271,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_9a9da0d0e3d84a19b5d188c9bd6a83bb",
+      "value": 47271
+     }
+    },
+    "e08d739f59874064994212363a307f6e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "e15aab8dd01f4d5582db80e6ad9931fc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "e17e3253c16743a29f09b82d23c3b26d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a7767d5a440f4c819cdb87414f2187ff",
+      "placeholder": "​",
+      "style": "IPY_MODEL_f0bc6b14a299445ca705b888b3047064",
+      "value": " 525k/525k [00:00&lt;00:00, 9.01MB/s]"
+     }
+    },
+    "e3a1a5e9f29d4d28b0b9496493dafa21": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e44c018bc76c48cd8738fee5966767ce": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b0abce2d8a2046dba320e788e33e9d66",
+      "placeholder": "​",
+      "style": "IPY_MODEL_aef81ec1a7e844f883beba8c5754a8af",
+      "value": "pixel-art-xl.safetensors: 100%"
+     }
+    },
+    "e57d317b3dda43bba13ecd4514f776d3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_3a017f1d0ebf4a4aab57ac3eb0788774",
+      "placeholder": "​",
+      "style": "IPY_MODEL_48643ea67f2f4762bcd27de1d4cf0fd2",
+      "value": " 170M/170M [00:07&lt;00:00, 24.6MB/s]"
+     }
+    },
+    "e67a69c294334b01974f8bef36f133a0": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e820c557697648378966ed0a073826c8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "e87dffe17f1948e9ba794eddb605a908": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "e976b994189343f5ba7d762ef92c79e2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "ea0910fc31e44597968b2129272cc94d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_0371aa5607604c06a868deb2a413cb31",
+      "max": 30,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_c212598c5a8747f783a6efc18816e868",
+      "value": 30
+     }
+    },
+    "ea257c1c73524141b87ab3c1ef85c908": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "eacd646e2b984e60ab603bfc6d631de8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_2ece04bc10934b3cb9d383abfc5ccd6e",
+      "placeholder": "​",
+      "style": "IPY_MODEL_67a03631ebc54f99928f0feb18ab38af",
+      "value": " 737/737 [00:00&lt;00:00, 41.5kB/s]"
+     }
+    },
+    "eb73095c804a4272856fe348fa3cb1e9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_9810873713024e79ae6d338dfeae5876",
+      "max": 170543292,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_2e18ce21c01a4a3ca992622957e7d297",
+      "value": 170543292
+     }
+    },
+    "eb9a5f255fa0447eba6a33e1c30ba166": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "ee8407365f5d42d9b98536152c9efe92": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "eec76868d92f45d7a6db2e232a45e0c2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "efd33121bdfc4ce195a07c9ef523a477": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_d2cd2572973249baa8e130b5777f4147",
+       "IPY_MODEL_4e77d8b6cdb94fc68974d27b24cfb3fd",
+       "IPY_MODEL_c292a598350d4dd4bb9b70aab1320c29"
+      ],
+      "layout": "IPY_MODEL_c68a5ad3bb664e8785e724085d208e96"
+     }
+    },
+    "f02041b1d5e1485bb2ba02b00fc2c242": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "f0bc6b14a299445ca705b888b3047064": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "f2596717405c40e1a39b721386e7a972": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f29673e57d174839a0bde70bfa165715": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "f2c67c29e1224df3b2def5a87eb8d368": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": "20px"
+     }
+    },
+    "f3baef4fbf4b4ec08480522be921f841": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f2c67c29e1224df3b2def5a87eb8d368",
+      "max": 1,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_486282a4ead148868005c592d74a4ed4",
+      "value": 0
+     }
+    },
+    "f46df85f441e4ada831f0e2b142f296a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f668dd13af6f41d8be358f7db5261c54": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f786a0f386f6486083c15e576f6eb3e7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e3a1a5e9f29d4d28b0b9496493dafa21",
+      "placeholder": "​",
+      "style": "IPY_MODEL_c008577d922e436aabb8680ca0d13117",
+      "value": "Loading pipeline components...: 100%"
+     }
+    },
+    "f8e6babf4fdd4c8e80d6dd24ff22d464": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f9ca5d4810b34938b6f997ff66a8d541": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "fa7876ade8e240fc89a35a1f8c7c7d3c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_52c7e22284b0468c8bc0c3b1cad047fb",
+      "placeholder": "​",
+      "style": "IPY_MODEL_17c29bbcbc0c437c9c8bc83e0b085f1a",
+      "value": " 7/7 [00:01&lt;00:00,  6.49it/s]"
+     }
+    },
+    "faddc146c69545cdaeb81edc8a0cda70": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b600178b161d4a87a0b832a169d7caf2",
+      "placeholder": "​",
+      "style": "IPY_MODEL_b3eaa188cc2e48d081488eea4ed2971f",
+      "value": "Loading pipeline components...: 100%"
+     }
+    },
+    "fae9d16daace412492b048b012b8d6dc": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "fbf3d268f30344b7864ce691d5bcb1f3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "fc1391aaeaad4eecad967e800a669ec1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "fd0ff16b68b2488d8c31ebe700dee9c9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_0e49d820da754da785bec2e5940eb9f6",
+       "IPY_MODEL_0b53b908088648e3b2beadaeba0f5da1",
+       "IPY_MODEL_804e7ee768794bba88aec3137f418868"
+      ],
+      "layout": "IPY_MODEL_0d786d8386ba49d0b53a5452d52e722d"
+     }
+    },
+    "fd13a58d6b444a0f955832647f64df12": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "fd672cd5ba0c4695be4240707dcf4bf3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "fdb1fd279a0241429e5721ae2e92d217": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "fdb799739700447d8a5198f1f4f9b17f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "fe19dcea6d9a44d28f077e065f1671c4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "fe958df746be4dc1871bd58628697c3c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ff3bf3f1873c4b01b0a547dfe02923ce": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    }
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/examples/multilayer_perceptron/README.md b/examples/multilayer_perceptron/README.md
new file mode 100644
index 0000000..fa3b05e
--- /dev/null
+++ b/examples/multilayer_perceptron/README.md
@@ -0,0 +1,5 @@
+# Fine-tuning a multilayer perceptron using LoRA and 🤗 PEFT
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/huggingface/peft/blob/main/examples/multilayer_perceptron/multilayer_perceptron_lora.ipynb)
+
+PEFT supports fine-tuning any type of model as long as the layers being used are supported. The model does not have to be a transformers model, for instance. To demonstrate this, the accompanying notebook `multilayer_perceptron_lora.ipynb` shows how to apply LoRA to a simple multilayer perceptron and use it to train a model to perform a classification task.
diff --git a/examples/multilayer_perceptron/multilayer_perceptron_lora.ipynb b/examples/multilayer_perceptron/multilayer_perceptron_lora.ipynb
new file mode 100644
index 0000000..d5ce302
--- /dev/null
+++ b/examples/multilayer_perceptron/multilayer_perceptron_lora.ipynb
@@ -0,0 +1,752 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "8e8743c8",
+   "metadata": {},
+   "source": [
+    "# Using PEFT with custom models"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c42c67e1",
+   "metadata": {},
+   "source": [
+    "`peft` allows us to fine-tune models efficiently with LoRA. In this short notebook, we will demonstrate how to train a simple multilayer perceptron (MLP) using `peft`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ce314af5",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b28b214d",
+   "metadata": {},
+   "source": [
+    "Make sure that you have the latest version of `peft` installed. To ensure that, run this in your Python environment:\n",
+    "    \n",
+    "    python -m pip install --upgrade peft"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "4d9da3d9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import copy\n",
+    "import os\n",
+    "\n",
+    "# ignore bnb warnings\n",
+    "os.environ[\"BITSANDBYTES_NOWELCOME\"] = \"1\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "44075f54",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.11/dist-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    }
+   ],
+   "source": [
+    "import peft\n",
+    "import torch\n",
+    "from torch import nn\n",
+    "import torch.nn.functional as F"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "f72acdfb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<torch._C.Generator at 0x7f6d9259a5d0>"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "torch.manual_seed(0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2b127a78",
+   "metadata": {},
+   "source": [
+    "## Data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f265da76",
+   "metadata": {},
+   "source": [
+    "We will create a toy dataset consisting of random data for a classification task. There is a little bit of signal in the data, so we should expect that the loss of the model can improve during training."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "b355567e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X = torch.rand((1000, 20))\n",
+    "y = (X.sum(1) > 10).long()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "a60a869d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_train = 800\n",
+    "batch_size = 64"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "8859572e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_dataloader = torch.utils.data.DataLoader(\n",
+    "    torch.utils.data.TensorDataset(X[:n_train], y[:n_train]),\n",
+    "    batch_size=batch_size,\n",
+    "    shuffle=True,\n",
+    ")\n",
+    "eval_dataloader = torch.utils.data.DataLoader(\n",
+    "    torch.utils.data.TensorDataset(X[n_train:], y[n_train:]),\n",
+    "    batch_size=batch_size,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "97bddd2c",
+   "metadata": {},
+   "source": [
+    "## Model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "db694a58",
+   "metadata": {},
+   "source": [
+    "As a model, we use a simple multilayer perceptron (MLP). For demonstration purposes, we use a very large number of hidden units. This is totally overkill for this task but it helps to demonstrate the advantages of `peft`. In more realistic settings, models will also be quite large on average, so this is not far-fetched."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "1b43cd8f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class MLP(nn.Module):\n",
+    "    def __init__(self, num_units_hidden=2000):\n",
+    "        super().__init__()\n",
+    "        self.seq = nn.Sequential(\n",
+    "            nn.Linear(20, num_units_hidden),\n",
+    "            nn.ReLU(),\n",
+    "            nn.Linear(num_units_hidden, num_units_hidden),\n",
+    "            nn.ReLU(),\n",
+    "            nn.Linear(num_units_hidden, 2),\n",
+    "            nn.LogSoftmax(dim=-1),\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, X):\n",
+    "        return self.seq(X)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1277bf00",
+   "metadata": {},
+   "source": [
+    "## Training"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "02caf26a",
+   "metadata": {},
+   "source": [
+    "Here are just a few training hyper-parameters and a simple function that performs the training and evaluation loop."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "5d14c0c4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lr = 0.002\n",
+    "batch_size = 64\n",
+    "max_epochs = 30\n",
+    "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "657d6b3e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def train(model, optimizer, criterion, train_dataloader, eval_dataloader, epochs):\n",
+    "    for epoch in range(epochs):\n",
+    "        model.train()\n",
+    "        train_loss = 0\n",
+    "        for xb, yb in train_dataloader:\n",
+    "            xb = xb.to(device)\n",
+    "            yb = yb.to(device)\n",
+    "            outputs = model(xb)\n",
+    "            loss = criterion(outputs, yb)\n",
+    "            train_loss += loss.detach().float()\n",
+    "            loss.backward()\n",
+    "            optimizer.step()\n",
+    "            optimizer.zero_grad()\n",
+    "\n",
+    "        model.eval()\n",
+    "        eval_loss = 0\n",
+    "        for xb, yb in eval_dataloader:\n",
+    "            xb = xb.to(device)\n",
+    "            yb = yb.to(device)\n",
+    "            with torch.no_grad():\n",
+    "                outputs = model(xb)\n",
+    "            loss = criterion(outputs, yb)\n",
+    "            eval_loss += loss.detach().float()\n",
+    "\n",
+    "        eval_loss_total = (eval_loss / len(eval_dataloader)).item()\n",
+    "        train_loss_total = (train_loss / len(train_dataloader)).item()\n",
+    "        print(f\"{epoch=:<2}  {train_loss_total=:.4f}  {eval_loss_total=:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b382dcbe",
+   "metadata": {},
+   "source": [
+    "### Training without peft"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b40d4873",
+   "metadata": {},
+   "source": [
+    "Let's start without using `peft` to see what we can expect from the model training."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "f059ced4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "module = MLP().to(device)\n",
+    "optimizer = torch.optim.Adam(module.parameters(), lr=lr)\n",
+    "criterion = nn.CrossEntropyLoss()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "17698863",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=0   train_loss_total=0.7970  eval_loss_total=0.6472\n",
+      "epoch=1   train_loss_total=0.5597  eval_loss_total=0.4898\n",
+      "epoch=2   train_loss_total=0.3696  eval_loss_total=0.3323\n",
+      "epoch=3   train_loss_total=0.2364  eval_loss_total=0.5454\n",
+      "epoch=4   train_loss_total=0.2428  eval_loss_total=0.2843\n",
+      "epoch=5   train_loss_total=0.1251  eval_loss_total=0.2514\n",
+      "epoch=6   train_loss_total=0.0952  eval_loss_total=0.2068\n",
+      "epoch=7   train_loss_total=0.0831  eval_loss_total=0.2395\n",
+      "epoch=8   train_loss_total=0.0655  eval_loss_total=0.2524\n",
+      "epoch=9   train_loss_total=0.0380  eval_loss_total=0.3650\n",
+      "epoch=10  train_loss_total=0.0363  eval_loss_total=0.3495\n",
+      "epoch=11  train_loss_total=0.0231  eval_loss_total=0.2360\n",
+      "epoch=12  train_loss_total=0.0162  eval_loss_total=0.2276\n",
+      "epoch=13  train_loss_total=0.0094  eval_loss_total=0.2716\n",
+      "epoch=14  train_loss_total=0.0065  eval_loss_total=0.2237\n",
+      "epoch=15  train_loss_total=0.0054  eval_loss_total=0.2366\n",
+      "epoch=16  train_loss_total=0.0035  eval_loss_total=0.2673\n",
+      "epoch=17  train_loss_total=0.0028  eval_loss_total=0.2630\n",
+      "epoch=18  train_loss_total=0.0023  eval_loss_total=0.2835\n",
+      "epoch=19  train_loss_total=0.0021  eval_loss_total=0.2727\n",
+      "epoch=20  train_loss_total=0.0018  eval_loss_total=0.2597\n",
+      "epoch=21  train_loss_total=0.0016  eval_loss_total=0.2553\n",
+      "epoch=22  train_loss_total=0.0014  eval_loss_total=0.2712\n",
+      "epoch=23  train_loss_total=0.0013  eval_loss_total=0.2637\n",
+      "epoch=24  train_loss_total=0.0012  eval_loss_total=0.2733\n",
+      "epoch=25  train_loss_total=0.0011  eval_loss_total=0.2738\n",
+      "epoch=26  train_loss_total=0.0010  eval_loss_total=0.2477\n",
+      "epoch=27  train_loss_total=0.0010  eval_loss_total=0.2584\n",
+      "epoch=28  train_loss_total=0.0009  eval_loss_total=0.2844\n",
+      "epoch=29  train_loss_total=0.0008  eval_loss_total=0.2633\n",
+      "CPU times: user 1.31 s, sys: 236 ms, total: 1.54 s\n",
+      "Wall time: 1.56 s\n"
+     ]
+    }
+   ],
+   "source": [
+    "%time train(module, optimizer, criterion, train_dataloader, eval_dataloader, epochs=max_epochs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4cef0029",
+   "metadata": {},
+   "source": [
+    "Okay, so we got an eval loss of ~0.26, which is much better than random."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4f106078",
+   "metadata": {},
+   "source": [
+    "### Training with peft"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8dd47aa4",
+   "metadata": {},
+   "source": [
+    "Now let's train with `peft`. First we check the names of the modules, so that we can configure `peft` to fine-tune the right modules."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "922db29b",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[('', __main__.MLP),\n",
+       " ('seq', torch.nn.modules.container.Sequential),\n",
+       " ('seq.0', torch.nn.modules.linear.Linear),\n",
+       " ('seq.1', torch.nn.modules.activation.ReLU),\n",
+       " ('seq.2', torch.nn.modules.linear.Linear),\n",
+       " ('seq.3', torch.nn.modules.activation.ReLU),\n",
+       " ('seq.4', torch.nn.modules.linear.Linear),\n",
+       " ('seq.5', torch.nn.modules.activation.LogSoftmax)]"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "[(n, type(m)) for n, m in MLP().named_modules()]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5efb275d",
+   "metadata": {},
+   "source": [
+    "Next we can define the LoRA config. There is nothing special going on here. We set the LoRA rank to 8 and select the layers `seq.0` and `seq.2` to be used for LoRA fine-tuning. As for `seq.4`, which is the output layer, we set it as `module_to_save`, which means it is also trained but no LoRA is applied."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cf2c608d",
+   "metadata": {},
+   "source": [
+    "*Note: Not all layers types can be fine-tuned with LoRA. At the moment, linear layers, embeddings, `Conv2D` and `transformers.pytorch_utils.Conv1D` are supported."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "b342438f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "config = peft.LoraConfig(\n",
+    "    r=8,\n",
+    "    target_modules=[\"seq.0\", \"seq.2\"],\n",
+    "    modules_to_save=[\"seq.4\"],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "829b4e2d",
+   "metadata": {},
+   "source": [
+    "Now let's create the `peft` model by passing our initial MLP, as well as the config we just defined, to `get_peft_model`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "602b6658",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "module = MLP().to(device)\n",
+    "module_copy = copy.deepcopy(module)  # we keep a copy of the original model for later\n",
+    "peft_model = peft.get_peft_model(module, config)\n",
+    "optimizer = torch.optim.Adam(peft_model.parameters(), lr=lr)\n",
+    "criterion = nn.CrossEntropyLoss()\n",
+    "peft_model.print_trainable_parameters()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2103737d",
+   "metadata": {},
+   "source": [
+    "Checking the numbers, we see that only ~1% of parameters are actually trained, which is what we like to see.\n",
+    "\n",
+    "Now let's start the training:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "9200cbc6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch=0   train_loss_total=0.6695  eval_loss_total=0.6388\n",
+      "epoch=1   train_loss_total=0.5614  eval_loss_total=0.5456\n",
+      "epoch=2   train_loss_total=0.3897  eval_loss_total=0.3035\n",
+      "epoch=3   train_loss_total=0.2529  eval_loss_total=0.2510\n",
+      "epoch=4   train_loss_total=0.1914  eval_loss_total=0.2191\n",
+      "epoch=5   train_loss_total=0.1236  eval_loss_total=0.2586\n",
+      "epoch=6   train_loss_total=0.1076  eval_loss_total=0.3205\n",
+      "epoch=7   train_loss_total=0.1834  eval_loss_total=0.3951\n",
+      "epoch=8   train_loss_total=0.1037  eval_loss_total=0.1646\n",
+      "epoch=9   train_loss_total=0.0724  eval_loss_total=0.1409\n",
+      "epoch=10  train_loss_total=0.0691  eval_loss_total=0.1725\n",
+      "epoch=11  train_loss_total=0.0641  eval_loss_total=0.1423\n",
+      "epoch=12  train_loss_total=0.0382  eval_loss_total=0.1490\n",
+      "epoch=13  train_loss_total=0.0214  eval_loss_total=0.1517\n",
+      "epoch=14  train_loss_total=0.0119  eval_loss_total=0.1717\n",
+      "epoch=15  train_loss_total=0.0060  eval_loss_total=0.2366\n",
+      "epoch=16  train_loss_total=0.0029  eval_loss_total=0.2069\n",
+      "epoch=17  train_loss_total=0.0021  eval_loss_total=0.2082\n",
+      "epoch=18  train_loss_total=0.0016  eval_loss_total=0.2119\n",
+      "epoch=19  train_loss_total=0.0011  eval_loss_total=0.1984\n",
+      "epoch=20  train_loss_total=0.0010  eval_loss_total=0.1821\n",
+      "epoch=21  train_loss_total=0.0009  eval_loss_total=0.1892\n",
+      "epoch=22  train_loss_total=0.0007  eval_loss_total=0.2062\n",
+      "epoch=23  train_loss_total=0.0006  eval_loss_total=0.2408\n",
+      "epoch=24  train_loss_total=0.0006  eval_loss_total=0.2038\n",
+      "epoch=25  train_loss_total=0.0005  eval_loss_total=0.2374\n",
+      "epoch=26  train_loss_total=0.0004  eval_loss_total=0.2139\n",
+      "epoch=27  train_loss_total=0.0004  eval_loss_total=0.2085\n",
+      "epoch=28  train_loss_total=0.0004  eval_loss_total=0.2395\n",
+      "epoch=29  train_loss_total=0.0003  eval_loss_total=0.2100\n",
+      "CPU times: user 1.41 s, sys: 48.9 ms, total: 1.46 s\n",
+      "Wall time: 1.46 s\n"
+     ]
+    }
+   ],
+   "source": [
+    "%time train(peft_model, optimizer, criterion, train_dataloader, eval_dataloader, epochs=max_epochs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "20f6f452",
+   "metadata": {},
+   "source": [
+    "In the end, we see that the eval loss is very similar to the one we saw earlier when we trained without `peft`. This is quite nice to see, given that we are training a much smaller number of parameters."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fa55d1d4",
+   "metadata": {},
+   "source": [
+    "#### Check which parameters were updated"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a6e2146b",
+   "metadata": {},
+   "source": [
+    "Finally, just to check that LoRA was applied as expected, we check what original weights were updated what weights stayed the same."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "c7dcde21",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "New parameter model.seq.0.lora_A.default.weight |   160 parameters | updated\n",
+      "New parameter model.seq.0.lora_B.default.weight | 16000 parameters | updated\n",
+      "New parameter model.seq.2.lora_A.default.weight | 16000 parameters | updated\n",
+      "New parameter model.seq.2.lora_B.default.weight | 16000 parameters | updated\n"
+     ]
+    }
+   ],
+   "source": [
+    "for name, param in peft_model.base_model.named_parameters():\n",
+    "    if \"lora\" not in name:\n",
+    "        continue\n",
+    "\n",
+    "    print(f\"New parameter {name:<13} | {param.numel():>5} parameters | updated\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "022e6c41",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Parameter seq.0.weight  |   40000 parameters | not updated\n",
+      "Parameter seq.0.bias    |    2000 parameters | not updated\n",
+      "Parameter seq.2.weight  | 4000000 parameters | not updated\n",
+      "Parameter seq.2.bias    |    2000 parameters | not updated\n",
+      "Parameter seq.4.weight  |    4000 parameters | not updated\n",
+      "Parameter seq.4.bias    |       2 parameters | not updated\n",
+      "Parameter seq.4.weight  |    4000 parameters | updated\n",
+      "Parameter seq.4.bias    |       2 parameters | updated\n"
+     ]
+    }
+   ],
+   "source": [
+    "params_before = dict(module_copy.named_parameters())\n",
+    "for name, param in peft_model.base_model.named_parameters():\n",
+    "    if \"lora\" in name:\n",
+    "        continue\n",
+    "\n",
+    "    name_before = (\n",
+    "        name.partition(\".\")[-1].replace(\"base_layer.\", \"\").replace(\"original_\", \"\").replace(\"module.\", \"\").replace(\"modules_to_save.default.\", \"\")\n",
+    "    )\n",
+    "    param_before = params_before[name_before]\n",
+    "    if torch.allclose(param, param_before):\n",
+    "        print(f\"Parameter {name_before:<13} | {param.numel():>7} parameters | not updated\")\n",
+    "    else:\n",
+    "        print(f\"Parameter {name_before:<13} | {param.numel():>7} parameters | updated\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4c09b43d",
+   "metadata": {},
+   "source": [
+    "So we can see that apart from the new LoRA weights that were added, only the last layer was updated. Since the LoRA weights and the last layer have comparitively few parameters, this gives us a big boost in efficiency."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b46c6198",
+   "metadata": {},
+   "source": [
+    "## Sharing the model through Hugging Face Hub"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6289e647",
+   "metadata": {},
+   "source": [
+    "### Pushing the model to HF Hub"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "06dcdfa0",
+   "metadata": {},
+   "source": [
+    "With the `peft` model, it is also very easy to push a model the Hugging Face Hub. Below, we demonstrate how it works. It is assumed that you have a valid Hugging Face account and are logged in:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "1b91a0af",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "user = \"BenjaminB\"  # put your user name here\n",
+    "model_name = \"peft-lora-with-custom-model\"\n",
+    "model_id = f\"{user}/{model_name}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1430fffd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "peft_model.push_to_hub(model_id);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "632bd799",
+   "metadata": {},
+   "source": [
+    "As we can see, the adapter size is only 211 kB."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4ff78c0c",
+   "metadata": {},
+   "source": [
+    "### Loading the model from HF Hub"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e5c7e87f",
+   "metadata": {},
+   "source": [
+    "Now, it only takes one step to load the model from HF Hub. To do this, we can use `PeftModel.from_pretrained`, passing our base model and the model ID:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ce0fcced",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "loaded = peft.PeftModel.from_pretrained(module_copy, model_id)\n",
+    "type(loaded)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cd4b4eac",
+   "metadata": {},
+   "source": [
+    "Let's check that the two models produce the same output:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f2cf6ac4",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "y_peft = peft_model(X.to(device))\n",
+    "y_loaded = loaded(X.to(device))\n",
+    "torch.allclose(y_peft, y_loaded)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eeeb653f",
+   "metadata": {},
+   "source": [
+    "### Clean up"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "61c60355",
+   "metadata": {},
+   "source": [
+    "Finally, as a clean up step, you may want to delete the repo."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "b747038f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from huggingface_hub import delete_repo"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "7e5ab237",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "delete_repo(model_id)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/oft_dreambooth/oft_dreambooth_inference.ipynb b/examples/oft_dreambooth/oft_dreambooth_inference.ipynb
new file mode 100644
index 0000000..24ed242
--- /dev/null
+++ b/examples/oft_dreambooth/oft_dreambooth_inference.ipynb
@@ -0,0 +1,116 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "acd7b15e",
+   "metadata": {},
+   "source": [
+    "# Dreambooth with OFT\n",
+    "This Notebook assumes that you already ran the train_dreambooth.py script to create your own adapter."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "acab479f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from diffusers import DiffusionPipeline\n",
+    "from diffusers.utils import check_min_version, get_logger\n",
+    "from peft import PeftModel\n",
+    "\n",
+    "# Will error if the minimal version of diffusers is not installed. Remove at your own risks.\n",
+    "check_min_version(\"0.10.0.dev0\")\n",
+    "\n",
+    "logger = get_logger(__name__)\n",
+    "\n",
+    "BASE_MODEL_NAME = \"stabilityai/stable-diffusion-2-1-base\"\n",
+    "ADAPTER_MODEL_PATH = \"INSERT MODEL PATH HERE\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading pipeline components...: 100%|██████████| 6/6 [00:00<00:00, 24.13it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "pipe = DiffusionPipeline.from_pretrained(\n",
+    "    BASE_MODEL_NAME,\n",
+    ")\n",
+    "pipe.to(device)\n",
+    "pipe.unet = PeftModel.from_pretrained(pipe.unet, ADAPTER_MODEL_PATH + \"/unet\", adapter_name=\"default\")\n",
+    "pipe.text_encoder = PeftModel.from_pretrained(\n",
+    "    pipe.text_encoder, ADAPTER_MODEL_PATH + \"/text_encoder\", adapter_name=\"default\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 50/50 [00:11<00:00,  4.46it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/jpeg": "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",
+      "image/png": "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",
+      "text/plain": [
+       "<PIL.Image.Image image mode=RGB size=512x512>"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "prompt = \"A photo of a sks dog\"\n",
+    "image = pipe(\n",
+    "    prompt,\n",
+    "    num_inference_steps=50,\n",
+    "    height=512,\n",
+    "    width=512,\n",
+    ").images[0]\n",
+    "image"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/oft_dreambooth/train_dreambooth.py b/examples/oft_dreambooth/train_dreambooth.py
new file mode 100644
index 0000000..6afee9e
--- /dev/null
+++ b/examples/oft_dreambooth/train_dreambooth.py
@@ -0,0 +1,1115 @@
+import argparse
+import gc
+import hashlib
+import itertools
+import logging
+import math
+import os
+import threading
+import warnings
+from contextlib import nullcontext
+from pathlib import Path
+
+import datasets
+import diffusers
+import numpy as np
+import psutil
+import torch
+import torch.nn.functional as F
+import torch.utils.checkpoint
+import transformers
+from accelerate import Accelerator
+from accelerate.logging import get_logger
+from accelerate.utils import set_seed
+from diffusers import (
+    AutoencoderKL,
+    DDPMScheduler,
+    DiffusionPipeline,
+    DPMSolverMultistepScheduler,
+    UNet2DConditionModel,
+)
+from diffusers.optimization import get_scheduler
+from diffusers.utils import check_min_version
+from diffusers.utils.import_utils import is_xformers_available
+from huggingface_hub import HfApi
+from PIL import Image
+from torch.utils.data import Dataset
+from torchvision import transforms
+from tqdm.auto import tqdm
+from transformers import AutoTokenizer, PretrainedConfig
+
+from peft import get_peft_model
+from peft.tuners.oft.config import OFTConfig
+
+
+# Will error if the minimal version of diffusers is not installed. Remove at your own risks.
+check_min_version("0.10.0.dev0")
+
+logger = get_logger(__name__)
+
+UNET_TARGET_MODULES = ["to_q", "to_v", "query", "value"]  # , "ff.net.0.proj"]
+TEXT_ENCODER_TARGET_MODULES = ["q_proj", "v_proj"]
+
+
+def import_model_class_from_model_name_or_path(pretrained_model_name_or_path: str, revision: str):
+    text_encoder_config = PretrainedConfig.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="text_encoder",
+        revision=revision,
+    )
+    model_class = text_encoder_config.architectures[0]
+
+    if model_class == "CLIPTextModel":
+        from transformers import CLIPTextModel
+
+        return CLIPTextModel
+    elif model_class == "RobertaSeriesModelWithTransformation":
+        from diffusers.pipelines.alt_diffusion.modeling_roberta_series import RobertaSeriesModelWithTransformation
+
+        return RobertaSeriesModelWithTransformation
+    else:
+        raise ValueError(f"{model_class} is not supported.")
+
+
+def parse_args(input_args=None):
+    parser = argparse.ArgumentParser(description="Simple example of a training script.")
+    parser.add_argument(
+        "--pretrained_model_name_or_path",
+        type=str,
+        default=None,
+        required=True,
+        help="Path to pretrained model or model identifier from huggingface.co/models.",
+    )
+    parser.add_argument(
+        "--revision",
+        type=str,
+        default=None,
+        required=False,
+        help="Revision of pretrained model identifier from huggingface.co/models.",
+    )
+    parser.add_argument(
+        "--tokenizer_name",
+        type=str,
+        default=None,
+        help="Pretrained tokenizer name or path if not the same as model_name",
+    )
+    parser.add_argument(
+        "--instance_data_dir",
+        type=str,
+        default=None,
+        required=True,
+        help="A folder containing the training data of instance images.",
+    )
+    parser.add_argument(
+        "--class_data_dir",
+        type=str,
+        default=None,
+        required=False,
+        help="A folder containing the training data of class images.",
+    )
+    parser.add_argument(
+        "--instance_prompt",
+        type=str,
+        default=None,
+        required=True,
+        help="The prompt with identifier specifying the instance",
+    )
+    parser.add_argument(
+        "--class_prompt",
+        type=str,
+        default=None,
+        help="The prompt to specify images in the same class as provided instance images.",
+    )
+    parser.add_argument(
+        "--with_prior_preservation",
+        default=False,
+        action="store_true",
+        help="Flag to add prior preservation loss.",
+    )
+    parser.add_argument("--prior_loss_weight", type=float, default=1.0, help="The weight of prior preservation loss.")
+    parser.add_argument(
+        "--num_class_images",
+        type=int,
+        default=100,
+        help=(
+            "Minimal class images for prior preservation loss. If there are not enough images already present in"
+            " class_data_dir, additional images will be sampled with class_prompt."
+        ),
+    )
+    parser.add_argument(
+        "--validation_prompt",
+        type=str,
+        default=None,
+        help="A prompt that is used during validation to verify that the model is learning.",
+    )
+    parser.add_argument(
+        "--num_validation_images",
+        type=int,
+        default=4,
+        help="Number of images that should be generated during validation with `validation_prompt`.",
+    )
+    parser.add_argument(
+        "--validation_steps",
+        type=int,
+        default=100,
+        help=(
+            "Run dreambooth validation every X steps. Dreambooth validation consists of running the prompt"
+            " `args.validation_prompt` multiple times: `args.num_validation_images`."
+        ),
+    )
+    parser.add_argument(
+        "--output_dir",
+        type=str,
+        default="text-inversion-model",
+        help="The output directory where the model predictions and checkpoints will be written.",
+    )
+    parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.")
+    parser.add_argument(
+        "--resolution",
+        type=int,
+        default=512,
+        help=(
+            "The resolution for input images, all the images in the train/validation dataset will be resized to this"
+            " resolution"
+        ),
+    )
+    parser.add_argument(
+        "--center_crop", action="store_true", help="Whether to center crop images before resizing to resolution"
+    )
+    parser.add_argument("--train_text_encoder", action="store_true", help="Whether to train the text encoder")
+
+    # oft args
+    parser.add_argument("--use_oft", action="store_true", help="Whether to use OFT for parameter efficient tuning")
+    parser.add_argument("--oft_r", type=int, default=0, help="OFT rank, only used if use_oft is True")
+    parser.add_argument("--oft_block_size", type=int, default=32, help="OFT block size, only used if use_oft is True")
+    parser.add_argument("--oft_dropout", type=float, default=0.0, help="OFT dropout, only used if use_oft is True")
+    parser.add_argument(
+        "--oft_use_coft", action="store_true", help="Using constrained OFT, only used if use_oft is True"
+    )
+    parser.add_argument(
+        "--oft_eps",
+        type=float,
+        default=0.0,
+        help="The control strength of COFT. Only has an effect if `oft_use_coft` is set to True.",
+    )
+
+    parser.add_argument(
+        "--oft_text_encoder_r",
+        type=int,
+        default=0,
+        help="OFT rank for text encoder, only used if `use_oft` and `train_text_encoder` are True",
+    )
+    parser.add_argument(
+        "--oft_text_encoder_block_size",
+        type=int,
+        default=32,
+        help="OFT block size for text encoder, only used if `use_oft` and `train_text_encoder` are True",
+    )
+    parser.add_argument(
+        "--oft_text_encoder_dropout",
+        type=float,
+        default=0.0,
+        help="OFT dropout for text encoder, only used if `use_oft` and `train_text_encoder` are True",
+    )
+    parser.add_argument(
+        "--oft_text_encoder_use_coft",
+        action="store_true",
+        help="Using constrained OFT on the text encoder, only used if use_oft is True",
+    )
+    parser.add_argument(
+        "--oft_text_encoder_eps",
+        type=float,
+        default=0.0,
+        help="The control strength of COFT on the text encoder. Only has an effect if `oft_text_encoder_use_coft` is set to True.",
+    )
+
+    parser.add_argument(
+        "--num_dataloader_workers", type=int, default=1, help="Num of workers for the training dataloader."
+    )
+
+    parser.add_argument(
+        "--no_tracemalloc",
+        default=False,
+        action="store_true",
+        help="Flag to stop memory allocation tracing during training. This could speed up training on Windows.",
+    )
+
+    parser.add_argument(
+        "--train_batch_size", type=int, default=4, help="Batch size (per device) for the training dataloader."
+    )
+    parser.add_argument(
+        "--sample_batch_size", type=int, default=4, help="Batch size (per device) for sampling images."
+    )
+    parser.add_argument("--num_train_epochs", type=int, default=1)
+    parser.add_argument(
+        "--max_train_steps",
+        type=int,
+        default=None,
+        help="Total number of training steps to perform.  If provided, overrides num_train_epochs.",
+    )
+    parser.add_argument(
+        "--checkpointing_steps",
+        type=int,
+        default=500,
+        help=(
+            "Save a checkpoint of the training state every X updates. These checkpoints can be used both as final"
+            " checkpoints in case they are better than the last checkpoint, and are also suitable for resuming"
+            " training using `--resume_from_checkpoint`."
+        ),
+    )
+    parser.add_argument(
+        "--resume_from_checkpoint",
+        type=str,
+        default=None,
+        help=(
+            "Whether training should be resumed from a previous checkpoint. Use a path saved by"
+            ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.'
+        ),
+    )
+    parser.add_argument(
+        "--gradient_accumulation_steps",
+        type=int,
+        default=1,
+        help="Number of updates steps to accumulate before performing a backward/update pass.",
+    )
+    parser.add_argument(
+        "--gradient_checkpointing",
+        action="store_true",
+        help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.",
+    )
+    parser.add_argument(
+        "--learning_rate",
+        type=float,
+        default=5e-6,
+        help="Initial learning rate (after the potential warmup period) to use.",
+    )
+    parser.add_argument(
+        "--scale_lr",
+        action="store_true",
+        default=False,
+        help="Scale the learning rate by the number of accelerators, gradient accumulation steps, and batch size.",
+    )
+    parser.add_argument(
+        "--lr_scheduler",
+        type=str,
+        default="constant",
+        help=(
+            'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",'
+            ' "constant", "constant_with_warmup"]'
+        ),
+    )
+    parser.add_argument(
+        "--lr_warmup_steps", type=int, default=500, help="Number of steps for the warmup in the lr scheduler."
+    )
+    parser.add_argument(
+        "--lr_num_cycles",
+        type=int,
+        default=1,
+        help="Number of hard resets of the lr in cosine_with_restarts scheduler.",
+    )
+    parser.add_argument("--lr_power", type=float, default=1.0, help="Power factor of the polynomial scheduler.")
+    parser.add_argument(
+        "--use_8bit_adam", action="store_true", help="Whether or not to use 8-bit Adam from bitsandbytes."
+    )
+    parser.add_argument("--adam_beta1", type=float, default=0.9, help="The beta1 parameter for the Adam optimizer.")
+    parser.add_argument("--adam_beta2", type=float, default=0.999, help="The beta2 parameter for the Adam optimizer.")
+    parser.add_argument("--adam_weight_decay", type=float, default=1e-2, help="Weight decay to use.")
+    parser.add_argument("--adam_epsilon", type=float, default=1e-08, help="Epsilon value for the Adam optimizer")
+    parser.add_argument("--max_grad_norm", default=1.0, type=float, help="Max gradient norm.")
+    parser.add_argument("--push_to_hub", action="store_true", help="Whether or not to push the model to the Hub.")
+    parser.add_argument("--hub_token", type=str, default=None, help="The token to use to push to the Model Hub.")
+    parser.add_argument(
+        "--hub_model_id",
+        type=str,
+        default=None,
+        help="The name of the repository to keep in sync with the local `output_dir`.",
+    )
+    parser.add_argument(
+        "--logging_dir",
+        type=str,
+        default="logs",
+        help=(
+            "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to"
+            " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***."
+        ),
+    )
+    parser.add_argument(
+        "--allow_tf32",
+        action="store_true",
+        help=(
+            "Whether or not to allow TF32 on Ampere GPUs. Can be used to speed up training. For more information, see"
+            " https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices"
+        ),
+    )
+    parser.add_argument(
+        "--report_to",
+        type=str,
+        default="tensorboard",
+        help=(
+            'The integration to report the results and logs to. Supported platforms are `"tensorboard"`'
+            ' (default), `"wandb"` and `"comet_ml"`. Use `"all"` to report to all integrations.'
+        ),
+    )
+    parser.add_argument(
+        "--wandb_key",
+        type=str,
+        default=None,
+        help=("If report to option is set to wandb, api-key for wandb used for login to wandb "),
+    )
+    parser.add_argument(
+        "--wandb_project_name",
+        type=str,
+        default=None,
+        help=("If report to option is set to wandb, project name in wandb for log tracking  "),
+    )
+    parser.add_argument(
+        "--mixed_precision",
+        type=str,
+        default=None,
+        choices=["no", "fp16", "bf16"],
+        help=(
+            "Whether to use mixed precision. Choose between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >="
+            " 1.10.and an Nvidia Ampere GPU or Intel XPU.  Default to the value of accelerate config of the current system or the"
+            " flag passed with the `accelerate.launch` command. Use this argument to override the accelerate config."
+        ),
+    )
+    parser.add_argument(
+        "--prior_generation_precision",
+        type=str,
+        default=None,
+        choices=["no", "fp32", "fp16", "bf16"],
+        help=(
+            "Choose prior generation precision between fp32, fp16 and bf16 (bfloat16). Bf16 requires PyTorch >="
+            " 1.10.and an Nvidia Ampere GPU or Intel XPU.  Default to fp16 if a GPU/XPU is available else fp32."
+        ),
+    )
+    parser.add_argument("--local_rank", type=int, default=-1, help="For distributed training: local_rank")
+    parser.add_argument(
+        "--enable_xformers_memory_efficient_attention", action="store_true", help="Whether or not to use xformers."
+    )
+
+    if input_args is not None:
+        args = parser.parse_args(input_args)
+    else:
+        args = parser.parse_args()
+
+    env_local_rank = int(os.environ.get("LOCAL_RANK", "-1"))
+    if env_local_rank != -1 and env_local_rank != args.local_rank:
+        args.local_rank = env_local_rank
+
+    if args.with_prior_preservation:
+        if args.class_data_dir is None:
+            raise ValueError("You must specify a data directory for class images.")
+        if args.class_prompt is None:
+            raise ValueError("You must specify prompt for class images.")
+    else:
+        # logger is not available yet
+        if args.class_data_dir is not None:
+            warnings.warn("You need not use --class_data_dir without --with_prior_preservation.")
+        if args.class_prompt is not None:
+            warnings.warn("You need not use --class_prompt without --with_prior_preservation.")
+
+    return args
+
+
+# Converting Bytes to Megabytes
+def b2mb(x):
+    return int(x / 2**20)
+
+
+# This context manager is used to track the peak memory usage of the process
+class TorchTracemalloc:
+    def __enter__(self):
+        self.device_type = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+        self.device_module = getattr(torch, self.device_type, torch.cuda)
+        gc.collect()
+        self.device_module.empty_cache()
+        self.device_module.reset_peak_memory_stats()  # reset the peak gauge to zero
+        self.begin = self.device_module.memory_allocated()
+        self.process = psutil.Process()
+
+        self.cpu_begin = self.cpu_mem_used()
+        self.peak_monitoring = True
+        peak_monitor_thread = threading.Thread(target=self.peak_monitor_func)
+        peak_monitor_thread.daemon = True
+        peak_monitor_thread.start()
+        return self
+
+    def cpu_mem_used(self):
+        """get resident set size memory for the current process"""
+        return self.process.memory_info().rss
+
+    def peak_monitor_func(self):
+        self.cpu_peak = -1
+
+        while True:
+            self.cpu_peak = max(self.cpu_mem_used(), self.cpu_peak)
+
+            # can't sleep or will not catch the peak right (this comment is here on purpose)
+            # time.sleep(0.001) # 1msec
+
+            if not self.peak_monitoring:
+                break
+
+    def __exit__(self, *exc):
+        self.peak_monitoring = False
+
+        gc.collect()
+        self.device_module.empty_cache()
+        self.end = self.device_module.memory_allocated()
+        self.peak = self.device_module.max_memory_allocated()
+        self.used = b2mb(self.end - self.begin)
+        self.peaked = b2mb(self.peak - self.begin)
+
+        self.cpu_end = self.cpu_mem_used()
+        self.cpu_used = b2mb(self.cpu_end - self.cpu_begin)
+        self.cpu_peaked = b2mb(self.cpu_peak - self.cpu_begin)
+        # print(f"delta used/peak {self.used:4d}/{self.peaked:4d}")
+
+
+class DreamBoothDataset(Dataset):
+    """
+    A dataset to prepare the instance and class images with the prompts for fine-tuning the model.
+    It pre-processes the images and the tokenizes prompts.
+    """
+
+    def __init__(
+        self,
+        instance_data_root,
+        instance_prompt,
+        tokenizer,
+        class_data_root=None,
+        class_prompt=None,
+        size=512,
+        center_crop=False,
+    ):
+        self.size = size
+        self.center_crop = center_crop
+        self.tokenizer = tokenizer
+
+        self.instance_data_root = Path(instance_data_root)
+        if not self.instance_data_root.exists():
+            raise ValueError("Instance images root doesn't exists.")
+
+        self.instance_images_path = list(Path(instance_data_root).iterdir())
+        self.num_instance_images = len(self.instance_images_path)
+        self.instance_prompt = instance_prompt
+        self._length = self.num_instance_images
+
+        if class_data_root is not None:
+            self.class_data_root = Path(class_data_root)
+            self.class_data_root.mkdir(parents=True, exist_ok=True)
+            self.class_images_path = list(self.class_data_root.iterdir())
+            self.num_class_images = len(self.class_images_path)
+            self._length = max(self.num_class_images, self.num_instance_images)
+            self.class_prompt = class_prompt
+        else:
+            self.class_data_root = None
+
+        self.image_transforms = transforms.Compose(
+            [
+                transforms.Resize(size, interpolation=transforms.InterpolationMode.BILINEAR),
+                transforms.CenterCrop(size) if center_crop else transforms.RandomCrop(size),
+                transforms.ToTensor(),
+                transforms.Normalize([0.5], [0.5]),
+            ]
+        )
+
+    def __len__(self):
+        return self._length
+
+    def __getitem__(self, index):
+        example = {}
+        instance_image = Image.open(self.instance_images_path[index % self.num_instance_images])
+        if instance_image.mode != "RGB":
+            instance_image = instance_image.convert("RGB")
+        example["instance_images"] = self.image_transforms(instance_image)
+        example["instance_prompt_ids"] = self.tokenizer(
+            self.instance_prompt,
+            truncation=True,
+            padding="max_length",
+            max_length=self.tokenizer.model_max_length,
+            return_tensors="pt",
+        ).input_ids
+
+        if self.class_data_root:
+            class_image = Image.open(self.class_images_path[index % self.num_class_images])
+            if class_image.mode != "RGB":
+                class_image = class_image.convert("RGB")
+            example["class_images"] = self.image_transforms(class_image)
+            example["class_prompt_ids"] = self.tokenizer(
+                self.class_prompt,
+                truncation=True,
+                padding="max_length",
+                max_length=self.tokenizer.model_max_length,
+                return_tensors="pt",
+            ).input_ids
+
+        return example
+
+
+def collate_fn(examples, with_prior_preservation=False):
+    input_ids = [example["instance_prompt_ids"] for example in examples]
+    pixel_values = [example["instance_images"] for example in examples]
+
+    # Concat class and instance examples for prior preservation.
+    # We do this to avoid doing two forward passes.
+    if with_prior_preservation:
+        input_ids += [example["class_prompt_ids"] for example in examples]
+        pixel_values += [example["class_images"] for example in examples]
+
+    pixel_values = torch.stack(pixel_values)
+    pixel_values = pixel_values.to(memory_format=torch.contiguous_format).float()
+
+    input_ids = torch.cat(input_ids, dim=0)
+
+    batch = {
+        "input_ids": input_ids,
+        "pixel_values": pixel_values,
+    }
+    return batch
+
+
+class PromptDataset(Dataset):
+    "A simple dataset to prepare the prompts to generate class images on multiple accelerators."
+
+    def __init__(self, prompt, num_samples):
+        self.prompt = prompt
+        self.num_samples = num_samples
+
+    def __len__(self):
+        return self.num_samples
+
+    def __getitem__(self, index):
+        example = {}
+        example["prompt"] = self.prompt
+        example["index"] = index
+        return example
+
+
+def main(args):
+    logging_dir = Path(args.output_dir, args.logging_dir)
+
+    accelerator = Accelerator(
+        gradient_accumulation_steps=args.gradient_accumulation_steps,
+        mixed_precision=args.mixed_precision,
+        log_with=args.report_to,
+        project_dir=logging_dir,
+    )
+    if args.report_to == "wandb":
+        import wandb
+
+        wandb.login(key=args.wandb_key)
+        wandb.init(project=args.wandb_project_name)
+    # Currently, it's not possible to do gradient accumulation when training two models with accelerate.accumulate
+    # This will be enabled soon in accelerate. For now, we don't allow gradient accumulation when training two models.
+    # TODO (patil-suraj): Remove this check when gradient accumulation with two models is enabled in accelerate.
+    if args.train_text_encoder and args.gradient_accumulation_steps > 1 and accelerator.num_processes > 1:
+        raise ValueError(
+            "Gradient accumulation is not supported when training the text encoder in distributed training. "
+            "Please set gradient_accumulation_steps to 1. This feature will be supported in the future."
+        )
+
+    # Make one log on every process with the configuration for debugging.
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        level=logging.INFO,
+    )
+    logger.info(accelerator.state, main_process_only=False)
+    if accelerator.is_local_main_process:
+        datasets.utils.logging.set_verbosity_warning()
+        transformers.utils.logging.set_verbosity_warning()
+        diffusers.utils.logging.set_verbosity_info()
+    else:
+        datasets.utils.logging.set_verbosity_error()
+        transformers.utils.logging.set_verbosity_error()
+        diffusers.utils.logging.set_verbosity_error()
+
+    # If passed along, set the training seed now.
+    if args.seed is not None:
+        set_seed(args.seed)
+
+    # Generate class images if prior preservation is enabled.
+    if args.with_prior_preservation:
+        class_images_dir = Path(args.class_data_dir)
+        if not class_images_dir.exists():
+            class_images_dir.mkdir(parents=True)
+        cur_class_images = len(list(class_images_dir.iterdir()))
+
+        if cur_class_images < args.num_class_images:
+            dtype = torch.float16 if accelerator.device.type in ["cuda", "xpu"] else torch.float32
+            if args.prior_generation_precision == "fp32":
+                dtype = torch.float32
+            elif args.prior_generation_precision == "fp16":
+                dtype = torch.float16
+            elif args.prior_generation_precision == "bf16":
+                dtype = torch.bfloat16
+            pipeline = DiffusionPipeline.from_pretrained(
+                args.pretrained_model_name_or_path,
+                dtype=dtype,
+                safety_checker=None,
+                revision=args.revision,
+            )
+            pipeline.set_progress_bar_config(disable=True)
+
+            num_new_images = args.num_class_images - cur_class_images
+            logger.info(f"Number of class images to sample: {num_new_images}.")
+
+            sample_dataset = PromptDataset(args.class_prompt, num_new_images)
+            sample_dataloader = torch.utils.data.DataLoader(sample_dataset, batch_size=args.sample_batch_size)
+
+            sample_dataloader = accelerator.prepare(sample_dataloader)
+            pipeline.to(accelerator.device)
+
+            for example in tqdm(
+                sample_dataloader, desc="Generating class images", disable=not accelerator.is_local_main_process
+            ):
+                images = pipeline(example["prompt"]).images
+
+                for i, image in enumerate(images):
+                    hash_image = hashlib.sha1(image.tobytes()).hexdigest()
+                    image_filename = class_images_dir / f"{example['index'][i] + cur_class_images}-{hash_image}.jpg"
+                    image.save(image_filename)
+
+            del pipeline
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+            elif torch.xpu.is_available():
+                torch.xpu.empty_cache()
+
+    # Handle the repository creation
+    if accelerator.is_main_process:
+        if args.push_to_hub:
+            api = HfApi(token=args.hub_token)
+
+            # Create repo (repo_name from args or inferred)
+            repo_name = args.hub_model_id
+            if repo_name is None:
+                repo_name = Path(args.output_dir).absolute().name
+            repo_id = api.create_repo(repo_name, exist_ok=True).repo_id
+
+            with open(os.path.join(args.output_dir, ".gitignore"), "w+") as gitignore:
+                if "step_*" not in gitignore:
+                    gitignore.write("step_*\n")
+                if "epoch_*" not in gitignore:
+                    gitignore.write("epoch_*\n")
+        elif args.output_dir is not None:
+            os.makedirs(args.output_dir, exist_ok=True)
+
+    # Load the tokenizer
+    if args.tokenizer_name:
+        tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name, revision=args.revision, use_fast=False)
+    elif args.pretrained_model_name_or_path:
+        tokenizer = AutoTokenizer.from_pretrained(
+            args.pretrained_model_name_or_path,
+            subfolder="tokenizer",
+            revision=args.revision,
+            use_fast=False,
+        )
+
+    # import correct text encoder class
+    text_encoder_cls = import_model_class_from_model_name_or_path(args.pretrained_model_name_or_path, args.revision)
+
+    # Load scheduler and models
+    noise_scheduler = DDPMScheduler(
+        beta_start=0.00085,
+        beta_end=0.012,
+        beta_schedule="scaled_linear",
+        num_train_timesteps=1000,
+    )  # DDPMScheduler.from_pretrained(args.pretrained_model_name_or_path, subfolder="scheduler")
+    text_encoder = text_encoder_cls.from_pretrained(
+        args.pretrained_model_name_or_path, subfolder="text_encoder", revision=args.revision
+    )
+    vae = AutoencoderKL.from_pretrained(args.pretrained_model_name_or_path, subfolder="vae", revision=args.revision)
+    unet = UNet2DConditionModel.from_pretrained(
+        args.pretrained_model_name_or_path, subfolder="unet", revision=args.revision
+    )
+
+    if args.use_oft:
+        config = OFTConfig(
+            r=args.oft_r,
+            oft_block_size=args.oft_block_size,
+            target_modules=UNET_TARGET_MODULES,
+            module_dropout=args.oft_dropout,
+            init_weights=True,
+            coft=args.oft_use_coft,
+            eps=args.oft_eps,
+        )
+        unet = get_peft_model(unet, config)
+        unet.print_trainable_parameters()
+        print(unet)
+
+    vae.requires_grad_(False)
+    if not args.train_text_encoder:
+        text_encoder.requires_grad_(False)
+    elif args.train_text_encoder and args.use_oft:
+        config = OFTConfig(
+            r=args.oft_text_encoder_r,
+            oft_block_size=args.oft_text_encoder_block_size,
+            target_modules=TEXT_ENCODER_TARGET_MODULES,
+            module_dropout=args.oft_text_encoder_dropout,
+            init_weights=True,
+            coft=args.oft_text_encoder_use_coft,
+            eps=args.oft_text_encoder_eps,
+        )
+        text_encoder = get_peft_model(text_encoder, config)
+        text_encoder.print_trainable_parameters()
+        print(text_encoder)
+
+    if args.enable_xformers_memory_efficient_attention:
+        if accelerator.device.type == "xpu":
+            logger.warning("XPU hasn't support xformers yet, ignore it.")
+        elif is_xformers_available():
+            unet.enable_xformers_memory_efficient_attention()
+        else:
+            raise ValueError("xformers is not available. Make sure it is installed correctly")
+
+    if args.gradient_checkpointing:
+        unet.enable_gradient_checkpointing()
+        # below fails when using oft so commenting it out
+        if args.train_text_encoder and not args.use_oft:
+            text_encoder.gradient_checkpointing_enable()
+
+    # Enable TF32 for faster training on Ampere GPUs,
+    # cf https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices
+    if args.allow_tf32 and torch.cuda.is_available():
+        torch.backends.cuda.matmul.allow_tf32 = True
+
+    if args.scale_lr:
+        args.learning_rate = (
+            args.learning_rate * args.gradient_accumulation_steps * args.train_batch_size * accelerator.num_processes
+        )
+
+    # Use 8-bit Adam for lower memory usage or to fine-tune the model in 16GB accelerators
+    if args.use_8bit_adam:
+        try:
+            import bitsandbytes as bnb
+        except ImportError:
+            raise ImportError(
+                "To use 8-bit Adam, please install the bitsandbytes library: `pip install bitsandbytes`."
+            )
+
+        optimizer_class = bnb.optim.AdamW8bit
+    else:
+        optimizer_class = torch.optim.AdamW
+
+    # Optimizer creation
+    params_to_optimize = (
+        itertools.chain(unet.parameters(), text_encoder.parameters()) if args.train_text_encoder else unet.parameters()
+    )
+    optimizer = optimizer_class(
+        params_to_optimize,
+        lr=args.learning_rate,
+        betas=(args.adam_beta1, args.adam_beta2),
+        weight_decay=args.adam_weight_decay,
+        eps=args.adam_epsilon,
+    )
+
+    # Dataset and DataLoaders creation:
+    train_dataset = DreamBoothDataset(
+        instance_data_root=args.instance_data_dir,
+        instance_prompt=args.instance_prompt,
+        class_data_root=args.class_data_dir if args.with_prior_preservation else None,
+        class_prompt=args.class_prompt,
+        tokenizer=tokenizer,
+        size=args.resolution,
+        center_crop=args.center_crop,
+    )
+
+    train_dataloader = torch.utils.data.DataLoader(
+        train_dataset,
+        batch_size=args.train_batch_size,
+        shuffle=True,
+        collate_fn=lambda examples: collate_fn(examples, args.with_prior_preservation),
+        num_workers=args.num_dataloader_workers,
+    )
+
+    # Scheduler and math around the number of training steps.
+    overrode_max_train_steps = False
+    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+    if args.max_train_steps is None:
+        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+        overrode_max_train_steps = True
+
+    lr_scheduler = get_scheduler(
+        args.lr_scheduler,
+        optimizer=optimizer,
+        num_warmup_steps=args.lr_warmup_steps * args.gradient_accumulation_steps,
+        num_training_steps=args.max_train_steps * args.gradient_accumulation_steps,
+        num_cycles=args.lr_num_cycles,
+        power=args.lr_power,
+    )
+
+    # Prepare everything with our `accelerator`.
+    if args.train_text_encoder:
+        unet, text_encoder, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
+            unet, text_encoder, optimizer, train_dataloader, lr_scheduler
+        )
+    else:
+        unet, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
+            unet, optimizer, train_dataloader, lr_scheduler
+        )
+
+    # For mixed precision training we cast the text_encoder and vae weights to half-precision
+    # as these models are only used for inference, keeping weights in full precision is not required.
+    weight_dtype = torch.float32
+    if accelerator.mixed_precision == "fp16":
+        weight_dtype = torch.float16
+    elif accelerator.mixed_precision == "bf16":
+        weight_dtype = torch.bfloat16
+
+    # Move vae and text_encoder to device and cast to weight_dtype
+    vae.to(accelerator.device, dtype=weight_dtype)
+    if not args.train_text_encoder:
+        text_encoder.to(accelerator.device, dtype=weight_dtype)
+
+    # We need to recalculate our total training steps as the size of the training dataloader may have changed.
+    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+    if overrode_max_train_steps:
+        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+    # Afterwards we recalculate our number of training epochs
+    args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch)
+
+    # We need to initialize the trackers we use, and also store our configuration.
+    # The trackers initializes automatically on the main process.
+    if accelerator.is_main_process:
+        accelerator.init_trackers("dreambooth", config=vars(args))
+
+    # Train!
+    total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps
+
+    logger.info("***** Running training *****")
+    logger.info(f"  Num examples = {len(train_dataset)}")
+    logger.info(f"  Num batches each epoch = {len(train_dataloader)}")
+    logger.info(f"  Num Epochs = {args.num_train_epochs}")
+    logger.info(f"  Instantaneous batch size per device = {args.train_batch_size}")
+    logger.info(f"  Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}")
+    logger.info(f"  Gradient Accumulation steps = {args.gradient_accumulation_steps}")
+    logger.info(f"  Total optimization steps = {args.max_train_steps}")
+    global_step = 0
+    first_epoch = 0
+
+    # Potentially load in the weights and states from a previous save
+    if args.resume_from_checkpoint:
+        if args.resume_from_checkpoint != "latest":
+            path = os.path.basename(args.resume_from_checkpoint)
+        else:
+            # Get the mos recent checkpoint
+            dirs = os.listdir(args.output_dir)
+            dirs = [d for d in dirs if d.startswith("checkpoint")]
+            dirs = sorted(dirs, key=lambda x: int(x.split("-")[1]))
+            path = dirs[-1]
+        accelerator.print(f"Resuming from checkpoint {path}")
+        accelerator.load_state(os.path.join(args.output_dir, path))
+        global_step = int(path.split("-")[1])
+
+        resume_global_step = global_step * args.gradient_accumulation_steps
+        first_epoch = resume_global_step // num_update_steps_per_epoch
+        resume_step = resume_global_step % num_update_steps_per_epoch
+
+    # Only show the progress bar once on each machine.
+    progress_bar = tqdm(range(global_step, args.max_train_steps), disable=not accelerator.is_local_main_process)
+    progress_bar.set_description("Steps")
+
+    for epoch in range(first_epoch, args.num_train_epochs):
+        unet.train()
+        if args.train_text_encoder:
+            text_encoder.train()
+        with TorchTracemalloc() if not args.no_tracemalloc else nullcontext() as tracemalloc:
+            for step, batch in enumerate(train_dataloader):
+                # Skip steps until we reach the resumed step
+                if args.resume_from_checkpoint and epoch == first_epoch and step < resume_step:
+                    if step % args.gradient_accumulation_steps == 0:
+                        progress_bar.update(1)
+                        if args.report_to == "wandb":
+                            accelerator.print(progress_bar)
+                    continue
+
+                with accelerator.accumulate(unet):
+                    # Convert images to latent space
+                    latents = vae.encode(batch["pixel_values"].to(dtype=weight_dtype)).latent_dist.sample()
+                    latents = latents * 0.18215
+
+                    # Sample noise that we'll add to the latents
+                    noise = torch.randn_like(latents)
+                    bsz = latents.shape[0]
+                    # Sample a random timestep for each image
+                    timesteps = torch.randint(
+                        0, noise_scheduler.config.num_train_timesteps, (bsz,), device=latents.device
+                    )
+                    timesteps = timesteps.long()
+
+                    # Add noise to the latents according to the noise magnitude at each timestep
+                    # (this is the forward diffusion process)
+                    noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps)
+
+                    # Get the text embedding for conditioning
+                    encoder_hidden_states = text_encoder(batch["input_ids"])[0]
+
+                    # Predict the noise residual
+                    model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample
+
+                    # Get the target for loss depending on the prediction type
+                    if noise_scheduler.config.prediction_type == "epsilon":
+                        target = noise
+                    elif noise_scheduler.config.prediction_type == "v_prediction":
+                        target = noise_scheduler.get_velocity(latents, noise, timesteps)
+                    else:
+                        raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}")
+
+                    if args.with_prior_preservation:
+                        # Chunk the noise and model_pred into two parts and compute the loss on each part separately.
+                        model_pred, model_pred_prior = torch.chunk(model_pred, 2, dim=0)
+                        target, target_prior = torch.chunk(target, 2, dim=0)
+
+                        # Compute instance loss
+                        loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
+
+                        # Compute prior loss
+                        prior_loss = F.mse_loss(model_pred_prior.float(), target_prior.float(), reduction="mean")
+
+                        # Add the prior loss to the instance loss.
+                        loss = loss + args.prior_loss_weight * prior_loss
+                    else:
+                        loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
+
+                    accelerator.backward(loss)
+                    if accelerator.sync_gradients:
+                        params_to_clip = (
+                            itertools.chain(unet.parameters(), text_encoder.parameters())
+                            if args.train_text_encoder
+                            else unet.parameters()
+                        )
+                        accelerator.clip_grad_norm_(params_to_clip, args.max_grad_norm)
+                    optimizer.step()
+                    lr_scheduler.step()
+                    optimizer.zero_grad()
+
+                # Checks if the accelerator has performed an optimization step behind the scenes
+                if accelerator.sync_gradients:
+                    progress_bar.update(1)
+                    if args.report_to == "wandb":
+                        accelerator.print(progress_bar)
+                    global_step += 1
+
+                logs = {"loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0]}
+                progress_bar.set_postfix(**logs)
+                accelerator.log(logs, step=global_step)
+
+                if (
+                    args.validation_prompt is not None
+                    and (step + num_update_steps_per_epoch * epoch) % args.validation_steps == 0
+                ):
+                    logger.info(
+                        f"Running validation... \n Generating {args.num_validation_images} images with prompt:"
+                        f" {args.validation_prompt}."
+                    )
+                    # create pipeline
+                    pipeline = DiffusionPipeline.from_pretrained(
+                        args.pretrained_model_name_or_path,
+                        safety_checker=None,
+                        revision=args.revision,
+                    )
+                    # set `keep_fp32_wrapper` to True because we do not want to remove
+                    # mixed precision hooks while we are still training
+                    pipeline.unet = accelerator.unwrap_model(unet, keep_fp32_wrapper=True)
+                    pipeline.text_encoder = accelerator.unwrap_model(text_encoder, keep_fp32_wrapper=True)
+                    pipeline.scheduler = DPMSolverMultistepScheduler.from_config(pipeline.scheduler.config)
+                    pipeline = pipeline.to(accelerator.device)
+                    pipeline.set_progress_bar_config(disable=True)
+
+                    # run inference
+                    if args.seed is not None:
+                        generator = torch.Generator(device=accelerator.device).manual_seed(args.seed)
+                    else:
+                        generator = None
+                    images = []
+                    for _ in range(args.num_validation_images):
+                        image = pipeline(args.validation_prompt, num_inference_steps=25, generator=generator).images[0]
+                        images.append(image)
+
+                    for tracker in accelerator.trackers:
+                        if tracker.name == "tensorboard":
+                            np_images = np.stack([np.asarray(img) for img in images])
+                            tracker.writer.add_images("validation", np_images, epoch, dataformats="NHWC")
+                        if tracker.name == "wandb":
+                            import wandb
+
+                            tracker.log(
+                                {
+                                    "validation": [
+                                        wandb.Image(image, caption=f"{i}: {args.validation_prompt}")
+                                        for i, image in enumerate(images)
+                                    ]
+                                }
+                            )
+
+                    del pipeline
+                    if torch.cuda.is_available():
+                        torch.cuda.empty_cache()
+                    elif torch.xpu.is_available():
+                        torch.xpu.empty_cache()
+
+                if global_step >= args.max_train_steps:
+                    break
+
+        # Printing the accelerator memory usage details such as allocated memory, peak memory, and total memory usage
+        if not args.no_tracemalloc:
+            accelerator.print(
+                f"{accelerator.device.type.upper()} Memory before entering the train : {b2mb(tracemalloc.begin)}"
+            )
+            accelerator.print(
+                f"{accelerator.device.type.upper()} Memory consumed at the end of the train (end-begin): {tracemalloc.used}"
+            )
+            accelerator.print(
+                f"{accelerator.device.type.upper()} Peak Memory consumed during the train (max-begin): {tracemalloc.peaked}"
+            )
+            accelerator.print(
+                f"{accelerator.device.type.upper()} Total Peak Memory consumed during the train (max): {tracemalloc.peaked + b2mb(tracemalloc.begin)}"
+            )
+
+            accelerator.print(f"CPU Memory before entering the train : {b2mb(tracemalloc.cpu_begin)}")
+            accelerator.print(f"CPU Memory consumed at the end of the train (end-begin): {tracemalloc.cpu_used}")
+            accelerator.print(f"CPU Peak Memory consumed during the train (max-begin): {tracemalloc.cpu_peaked}")
+            accelerator.print(
+                f"CPU Total Peak Memory consumed during the train (max): {tracemalloc.cpu_peaked + b2mb(tracemalloc.cpu_begin)}"
+            )
+
+    # Create the pipeline using using the trained modules and save it.
+    accelerator.wait_for_everyone()
+    if accelerator.is_main_process:
+        if args.use_oft:
+            unwarpped_unet = accelerator.unwrap_model(unet)
+            unwarpped_unet.save_pretrained(
+                os.path.join(args.output_dir, "unet"), state_dict=accelerator.get_state_dict(unet)
+            )
+            if args.train_text_encoder:
+                unwarpped_text_encoder = accelerator.unwrap_model(text_encoder)
+                unwarpped_text_encoder.save_pretrained(
+                    os.path.join(args.output_dir, "text_encoder"),
+                    state_dict=accelerator.get_state_dict(text_encoder),
+                )
+        else:
+            pipeline = DiffusionPipeline.from_pretrained(
+                args.pretrained_model_name_or_path,
+                unet=accelerator.unwrap_model(unet),
+                text_encoder=accelerator.unwrap_model(text_encoder),
+                revision=args.revision,
+            )
+            pipeline.save_pretrained(args.output_dir)
+
+        if args.push_to_hub:
+            api.upload_folder(
+                repo_id=repo_id,
+                folder_path=args.output_dir,
+                commit_message="End of training",
+                run_as_future=True,
+            )
+
+    accelerator.end_training()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    main(args)
diff --git a/examples/olora_finetuning/README.md b/examples/olora_finetuning/README.md
new file mode 100644
index 0000000..3b9bbf6
--- /dev/null
+++ b/examples/olora_finetuning/README.md
@@ -0,0 +1,96 @@
+# OLoRA: Orthonormal Low Rank Adaptation of Large Language Models
+
+## Introduction
+[OLoRA](https://huggingface.co/papers/2406.01775) is a novel approach that leverages orthonormal low rank adaptation through QR decomposition. Unlike the default LoRA implementation, OLoRA decomposes original weights into their $\mathbf{Q}$ and $\mathbf{R}$ parts, and then uses the first `rank` rows of $\mathbf{R}$ and the first `rank` columns of $\mathbf{Q}$ to initialize $\mathbf{A}$ and $\mathbf{B}$, respectively. This results in significantly faster convergence, more stable training, and superior performance.
+
+## Quick start
+```python
+import torch
+from peft import LoraConfig, get_peft_model
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from trl import SFTConfig, SFTTrainer
+from datasets import load_dataset
+
+model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m", dtype=torch.bfloat16, device_map="auto")
+tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m")
+dataset = load_dataset("imdb", split="train[:1%]")
+lora_config = LoraConfig(
+    init_lora_weights="olora"
+)
+peft_model = get_peft_model(model, lora_config)
+training_args = SFTConfig(dataset_text_field="text", max_length=128)
+trainer = SFTTrainer(
+    model=peft_model,
+    train_dataset=dataset,
+    processing_class=tokenizer,
+)
+trainer.train()
+peft_model.save_pretrained("olora-opt-350m")
+```
+
+There is no additional change needed to your standard LoRA procedure, except for specifying `init_lora_weights = "olora"` option in your lora configuration.
+
+Additionally you can refer to olora finetuning script.
+Run the script simply by running:
+```bash
+python3 examples/olora_finetuning/olora_finetuning.py --base_model facebook/opt-350m
+```
+OLoRA also supports quantization. To use 4-bit quantization try:
+```bash
+python3 examples/olora_finetuning/olora_finetuning.py --base_model facebook/opt-350m --quantize
+```
+or you can just pass a quantized model without the quantize flag.
+
+If you want to run DDP by [accelerate](https://huggingface.co/docs/accelerate/en/index), please run `accelerate config` to set your ddp config, and run:
+```bash
+accelerate launch examples/olora_finetuning/olora_finetuning.py --base_model facebook/opt-350m
+```
+please add `--device_map cpu` if you want to run finetune on CPU.
+
+If you want to train a quantized model like AWQ and GPTQ which do not support olora init method, please pass `--init_lora_weights gaussian`. For example:
+```bash
+python3 examples/olora_finetuning/olora_finetuning.py --base_model hugging-quants/Meta-Llama-3.1-8B-Instruct-AWQ-INT4 --init_lora_weights gaussian
+
+```
+
+
+## Use the model
+You can load and use the model as any other 🤗 PEFT model
+```python
+from peft import PeftModel
+model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m")
+tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m")
+olora_model = PeftModel.from_pretrained(model, "olora-opt-350m")
+```
+
+## OLoRA and LoRA
+OLoRA differs from LoRA in that it mutates the original weights. To utilize multiple adapters simultaneously, you can leverage the `path_initial_model_for_weight_conversion` option. Below is a simple template illustrating how to convert OLoRA to conventional LoRA:
+```python
+base_model = AutoModel.from_pretrained("facebook/opt-350m")
+olora_config = LoraConfig(
+    ...
+    init_lora_weights = "olora" # Initialize the model with OLoRA
+)
+olora_model = get_peft_model(base_model, olora_config)
+init_path = <path-to-untrained-olora-model>
+olora_model.save_pretrained(init_path) # Save the model *before* performing any training
+
+# Train the model
+train(olora_model) # Your training loop
+
+#Save the model after training
+olora_model.save_pretrained(output_dir, path_initial_model_for_weight_conversion=init_path) 
+```
+After completing training, you can save and convert your OLoRA model to a conventional LoRA model by setting `path_initial_model_for_weight_conversion` to `init_path`, that is the path of your untrained OLoRA model. This conversion enables you to use multiple adapters with your LoRA model. Note that this conversion is not supported if `rslora` is used in combination with `rank_pattern` or `alpha_pattern`.
+
+## Citation
+```
+@misc{büyükakyüz2024olora,
+      title={OLoRA: Orthonormal Low-Rank Adaptation of Large Language Models}, 
+      author={Kerim Büyükakyüz},
+      year={2024},
+      eprint={2406.01775},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
+}
+```
diff --git a/examples/olora_finetuning/olora_finetuning.py b/examples/olora_finetuning/olora_finetuning.py
new file mode 100644
index 0000000..32dca9b
--- /dev/null
+++ b/examples/olora_finetuning/olora_finetuning.py
@@ -0,0 +1,199 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+
+import os
+from typing import Optional
+
+import torch
+import transformers
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, set_seed
+
+from peft import (
+    LoraConfig,
+    get_peft_model,
+)
+
+
+def train(
+    base_model: str = "path/to/model",
+    data_path: str = "yahma/alpaca-cleaned",
+    output_dir: str = "olora",
+    batch_size: int = 16,
+    num_epochs: int = 1,
+    learning_rate: float = 3e-4,
+    cutoff_len: int = 256,
+    val_set_size: int = 16,
+    quantize: bool = False,
+    eval_step: int = 100,
+    save_step: int = 100,
+    device_map: str = "auto",
+    lora_r: int = 32,
+    lora_alpha: int = 16,
+    lora_dropout: float = 0.05,
+    lora_target_modules: Optional[list[str]] = None,
+    dtype: str = "float16",
+    init_lora_weights="olora",
+    seed: Optional[int] = None,
+):
+    # Set device_map to the right place when enabling DDP.
+    world_size = int(os.environ.get("WORLD_SIZE", "0")) or int(os.environ.get("PMI_SIZE", "0"))
+    if world_size > 1 and device_map != "cpu":
+        from accelerate import Accelerator
+
+        device_map = {"": Accelerator().process_index}
+    # Set seed
+    if seed is not None:
+        set_seed(seed)
+    model_kwargs = {"dtype": getattr(torch, dtype), "device_map": device_map}
+    if quantize:
+        model_kwargs["quantization_config"] = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_compute_dtype=torch.bfloat16,
+            bnb_4bit_use_double_quant=True,
+            bnb_4bit_quant_type="nf4",
+        )
+    model = AutoModelForCausalLM.from_pretrained(base_model, **model_kwargs)
+
+    tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
+    # For some tokenizer with no pad token like llama
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    def tokenize(prompt, add_eos_token=True):
+        result = tokenizer(
+            prompt,
+            truncation=True,
+            max_length=cutoff_len,
+            padding=False,
+            return_tensors=None,
+        )
+        if (
+            result["input_ids"][-1] != tokenizer.eos_token_id
+            and len(result["input_ids"]) < cutoff_len
+            and add_eos_token
+        ):
+            result["input_ids"].append(tokenizer.eos_token_id)
+            result["attention_mask"].append(1)
+
+        result["labels"] = result["input_ids"].copy()
+
+        return result
+
+    def generate_and_tokenize_prompt(example):
+        full_prompt = generate_prompt(example)
+        tokenized_full_prompt = tokenize(full_prompt)
+        return tokenized_full_prompt
+
+    config = LoraConfig(
+        r=lora_r,
+        lora_alpha=lora_alpha,
+        target_modules=lora_target_modules,
+        lora_dropout=lora_dropout,
+        bias="none",
+        task_type="CAUSAL_LM",
+        init_lora_weights=init_lora_weights,
+    )
+    model = get_peft_model(model, config)
+
+    data = load_dataset(data_path)
+
+    train_val = data["train"].train_test_split(test_size=val_set_size, shuffle=True, seed=42)
+    train_data = train_val["train"].shuffle().map(generate_and_tokenize_prompt)
+    val_data = train_val["test"].shuffle().map(generate_and_tokenize_prompt)
+
+    trainer = transformers.Trainer(
+        model=model,
+        train_dataset=train_data,
+        eval_dataset=val_data,
+        args=transformers.TrainingArguments(
+            per_device_train_batch_size=batch_size,
+            warmup_steps=100,
+            num_train_epochs=num_epochs,
+            learning_rate=learning_rate,
+            logging_steps=100,
+            optim="adamw_torch",
+            eval_strategy="steps",
+            save_strategy="steps",
+            eval_steps=eval_step,
+            save_steps=save_step,
+            output_dir=output_dir,
+            save_total_limit=3,
+            load_best_model_at_end=True,
+            ddp_find_unused_parameters=False if world_size > 1 else None,
+        ),
+        data_collator=transformers.DataCollatorForSeq2Seq(
+            tokenizer, pad_to_multiple_of=8, return_tensors="pt", padding=True
+        ),
+    )
+    trainer.train()
+    model.save_pretrained(output_dir)
+
+
+def generate_prompt(example):
+    return f"""Below is an instruction that describes a task. Write a response that appropriately completes the request.
+            ### Instruction:
+            {example["instruction"]}
+            ### Response:
+            {example["output"]}"""
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--base_model", type=str, default="path/to/model")
+    parser.add_argument("--data_path", type=str, default="yahma/alpaca-cleaned")
+    parser.add_argument("--output_dir", type=str, default="olora")
+    parser.add_argument("--batch_size", type=int, default=16)
+    parser.add_argument("--num_epochs", type=int, default=1)
+    parser.add_argument("--learning_rate", type=float, default=3e-4)
+    parser.add_argument("--cutoff_len", type=int, default=256)
+    parser.add_argument("--val_set_size", type=int, default=16)
+    parser.add_argument("--quantize", action="store_true")
+    parser.add_argument("--eval_step", type=int, default=100)
+    parser.add_argument("--save_step", type=int, default=100)
+    parser.add_argument("--device_map", type=str, default="auto")
+    parser.add_argument("--lora_r", type=int, default=32)
+    parser.add_argument("--lora_alpha", type=int, default=16)
+    parser.add_argument("--lora_dropout", type=float, default=0.05)
+    parser.add_argument("--lora_target_modules", type=str, default=None)
+    parser.add_argument("--dtype", type=str, default="float16")
+    parser.add_argument("--init_lora_weights", type=str, default="olora")
+    parser.add_argument("--seed", type=int, default=None)
+
+    args = parser.parse_args()
+
+    train(
+        base_model=args.base_model,
+        data_path=args.data_path,
+        output_dir=args.output_dir,
+        batch_size=args.batch_size,
+        num_epochs=args.num_epochs,
+        learning_rate=args.learning_rate,
+        cutoff_len=args.cutoff_len,
+        val_set_size=args.val_set_size,
+        quantize=args.quantize,
+        eval_step=args.eval_step,
+        save_step=args.save_step,
+        device_map=args.device_map,
+        lora_r=args.lora_r,
+        lora_alpha=args.lora_alpha,
+        lora_dropout=args.lora_dropout,
+        lora_target_modules=args.lora_target_modules,
+        dtype=args.dtype,
+        init_lora_weights=args.init_lora_weights,
+        seed=args.seed,
+    )
diff --git a/examples/orthogonal_subspace_learning/README.md b/examples/orthogonal_subspace_learning/README.md
new file mode 100644
index 0000000..6ad91bf
--- /dev/null
+++ b/examples/orthogonal_subspace_learning/README.md
@@ -0,0 +1,299 @@
+# Orthogonal Subspace Fine-tuning (OSF) - Continual Learning Example
+
+This example demonstrates OSF's ability to learn multiple tasks sequentially while preventing catastrophic forgetting, a key challenge in continual learning.
+
+## Introduction
+
+**Orthogonal Subspace Fine-tuning (OSF)** is a parameter-efficient fine-tuning method designed specifically for continual learning scenarios. Unlike traditional fine-tuning which suffers from catastrophic forgetting when learning new tasks, OSF constrains parameter updates to be orthogonal to previously important directions, effectively preserving knowledge from earlier tasks.
+
+### Key Features
+
+- **Prevents Catastrophic Forgetting**: Maintains performance on previous tasks while learning new ones
+- **Full Model Capacity**: Unlike LoRA-based methods, OSF allows full-rank updates within the trainable subspace
+- **Progressive Budget Allocation**: Gradually allocates more capacity to preserve previous knowledge
+- **No Additional Parameters**: Modifies weights in-place without adding extra parameters per task
+
+## Quick Start
+
+### Installation
+
+```bash
+pip install -e ".[dev]"
+```
+
+### Basic Usage
+
+Run the continual learning example with OSF:
+
+```bash
+python osf_continual_learning.py \
+    --model_name meta-llama/Llama-3.1-8B-Instruct \
+    --num_train 1000 \
+    --num_eval 200 \
+    --num_epochs 2 \
+    --output_dir ./outputs
+```
+
+To compare with full fine-tuning baseline:
+
+```bash
+python osf_continual_learning.py \
+    --model_name meta-llama/Llama-3.1-8B-Instruct \
+    --run_baseline \
+    --output_dir ./outputs
+```
+
+## Continual Learning Scenario
+
+This example trains a model on three different tasks sequentially:
+
+1. **ScienceQA** - Science question answering across natural, language, and social sciences
+2. **NumGLUE** - Mathematical reasoning and numerical understanding
+3. **FOMC** - Financial sentiment classification (Dovish/Hawkish/Neutral)
+
+### Progressive Capacity Allocation
+
+OSF uses a progressive budget allocation strategy where each task gets decreasing trainable capacity while preserving more knowledge from previous tasks:
+
+| Task | Effective Rank | Preserved | Trainable | Description |
+|------|----------------|-----------|-----------|-------------|
+| Task 1 (ScienceQA) | 0.3 | 30% | 70% | Maximum capacity for first task |
+| Task 2 (NumGLUE) | 0.5 | 50% | 50% | Balanced capacity allocation |
+| Task 3 (FOMC) | 0.7 | 70% | 30% | Minimal capacity, maximum preservation |
+
+This allocation ensures:
+- Early tasks get sufficient capacity to learn effectively
+- Later tasks can still learn new patterns
+- Previous knowledge is progressively protected from interference
+
+## How OSF Works
+
+OSF decomposes each weight matrix using SVD into high-rank (preserved) and low-rank (trainable) components:
+
+```
+W = U_high @ S_high @ V_high^T + U_low @ S_low @ V_low^T
+    └─────────┬─────────┘        └──────┬──────┘
+          frozen                    trainable
+     (previous tasks)              (current task)
+```
+
+During training:
+1. **Initialization**: Perform SVD on each weight matrix
+2. **Partitioning**: Split singular values based on `effective_rank`
+3. **Freezing**: Freeze top-k singular directions (high-rank subspace)
+4. **Training**: Update remaining directions (low-rank subspace)
+5. **Gradient Projection**: Ensure updates are orthogonal to frozen subspace
+
+Between tasks:
+1. **Unload**: Merge OSF components back into base model
+2. **Re-initialize**: Perform fresh SVD with increased `effective_rank`
+3. **Continue**: Train on next task with larger frozen subspace
+
+## Command Line Arguments
+
+```
+--model_name              Model to use (default: meta-llama/Llama-3.1-8B-Instruct)
+--num_train              Number of training samples per task (default: 1000)
+--num_eval               Number of evaluation samples per task (default: 200)
+--output_dir             Directory for outputs (default: ./osf_continual_learning_outputs)
+--num_epochs             Training epochs per task (default: 2)
+--learning_rate          Learning rate (default: 5e-6)
+--batch_size             Batch size per device (default: 32)
+--gradient_accumulation_steps  Gradient accumulation (default: 1)
+--max_length             Maximum sequence length (default: 512)
+--seed                   Random seed (default: 42)
+--run_baseline           Also run full fine-tuning baseline for comparison
+```
+
+## Expected Results
+
+### OSF Performance
+
+When using OSF (with 2 epochs per task), you should observe:
+- **Reduced catastrophic forgetting**: Performance on earlier tasks degrades less compared to full fine-tuning
+- **Continued learning**: Model successfully learns each new task
+- **Better retention**: OSF maintains higher average accuracy across all tasks
+
+### Full Fine-tuning Baseline
+
+Standard full fine-tuning typically shows:
+- **Catastrophic forgetting**: Significant performance degradation on earlier tasks
+- **Last task bias**: Model performs well only on the most recent task
+- **Task interference**: New task learning overwrites previous knowledge
+
+## Understanding the Results
+
+### Forgetting Analysis
+
+The script prints a forgetting analysis showing how much earlier task performance changes.
+
+**Example results from training with 2 epochs per task:**
+
+```
+SUMMARY METRICS
+================================================================================
+
+1. Average Accuracy Across All 3 Tasks (After Final Task):
+   OSF:     53.42%
+   Full FT: 46.26%
+   Difference: +7.17% (OSF better)
+
+2. Average Forgetting (Task 1 & 2):
+   Forgetting = Final Accuracy - Initial Accuracy (negative is worse)
+
+   ScienceQA:
+     OSF:     +30.50% (initial: 55.00% → final: 85.50%)
+     Full FT: -13.00% (initial: 84.50% → final: 71.50%)
+     Difference: +43.50% (OSF better)
+
+   NumGLUE:
+     OSF:     +30.00% (initial: 16.00% → final: 46.00%)
+     Full FT: +1.00% (initial: 37.50% → final: 38.50%)
+     Difference: +29.00% (OSF better)
+
+   Average Forgetting:
+     OSF:     +30.25%
+     Full FT: -6.00%
+     Difference: +36.25% (OSF better)
+```
+
+**Interpreting Forgetting Metrics:**
+- **Negative values** = Forgetting occurred (performance decreased)
+- **Positive values** = Backward transfer occurred (performance improved)
+- **Values closer to 0** = Better retention
+
+In this example, OSF shows significant positive backward transfer (+30.25% average), while Full FT shows slight forgetting (-6.00% average). This demonstrates OSF's ability to not only prevent catastrophic forgetting but also enable beneficial knowledge transfer across tasks.
+
+## Advanced Usage
+
+### Custom Task Configuration
+
+You can modify the tasks and capacity allocation in the script:
+
+```python
+tasks = [
+    {
+        "name": "Task1",
+        "train": task1_train,
+        "eval": task1_eval,
+        "effective_rank": 0.2,  # Freeze 20%, train 80%
+    },
+    {
+        "name": "Task2",
+        "train": task2_train,
+        "eval": task2_eval,
+        "effective_rank": 0.6,  # Freeze 60%, train 40%
+    },
+]
+```
+
+### Using Different Models
+
+OSF works with any transformer-based model:
+
+```bash
+# Smaller model for faster experimentation
+python osf_continual_learning.py --model_name gpt2
+
+# Different LLaMA variant
+python osf_continual_learning.py --model_name meta-llama/Llama-2-7b-hf
+```
+
+### Adjusting Target Modules
+
+In the script, you can modify which modules to apply OSF to:
+
+```python
+config = OSFConfig(
+    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],  # Attention only
+    effective_rank=task["effective_rank"],
+)
+```
+
+Common configurations:
+- **Attention only**: `["q_proj", "k_proj", "v_proj", "o_proj"]`
+- **Attention + MLP**: `["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]`
+- **All linear**: `target_modules="all-linear"`
+
+## Customization
+
+### Adding Your Own Tasks
+
+To add custom tasks, create data loading and formatting functions in `utils.py`:
+
+```python
+def load_my_task(num_train=1000, num_eval=200, seed=42):
+    """Load your custom dataset."""
+    dataset = load_dataset("your/dataset")
+    # ... split and return
+    return train_dataset, eval_dataset
+
+def format_my_task_for_llama(examples, tokenizer, max_length=512):
+    """Format your task for instruction following."""
+    prompts = []
+    labels_text = []
+
+    for i in range(len(examples)):
+        prompt = f"Your instruction template: {examples['input'][i]}"
+        label = examples['output'][i]
+
+        prompts.append(prompt)
+        labels_text.append(label)
+
+    # ... tokenization logic
+    return formatted_examples
+```
+
+Then add to the tasks list in `osf_continual_learning.py`.
+
+## Performance Tips
+
+### Memory Optimization
+
+For large models, consider:
+- Reducing `batch_size` and increasing `gradient_accumulation_steps`
+- Using smaller `max_length`
+- Enabling gradient checkpointing (add to model before OSF):
+  ```python
+  model.gradient_checkpointing_enable()
+  ```
+
+### Training Speed
+
+To speed up training:
+- Reduce `num_train` and `num_eval` for initial testing
+- Use smaller models (e.g., `gpt2` or `Llama-2-7b`)
+- Reduce `max_length` for shorter sequences
+
+### Better Results
+
+For improved continual learning performance:
+- Play around with `num_epochs` per task (try 2-3 epochs)
+- Adjust `learning_rate`
+- Experiment with different capacity allocation strategies
+
+## Citation
+
+If you use OSF in your research, please cite:
+
+```bibtex
+@misc{nayak2025sculptingsubspacesconstrainedfinetuning,
+      title={Sculpting Subspaces: Constrained Full Fine-Tuning in LLMs for Continual Learning}, 
+      author={Nikhil Shivakumar Nayak and Krishnateja Killamsetty and Ligong Han and Abhishek Bhandwaldar and Prateek Chanda and Kai Xu and Hao Wang and Aldo Pareja and Oleg Silkin and Mustafa Eyceoz and Akash Srivastava},
+      year={2025},
+      eprint={2504.07097},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG},
+      url={https://arxiv.org/abs/2504.07097}, 
+}
+```
+
+## Additional Resources
+
+- [OSF Documentation](../../docs/source/package_reference/osf.md)
+- [PEFT Documentation](https://huggingface.co/docs/peft)
+- [Original Paper](https://huggingface.co/papers/2504.07097)
+
+## License
+
+This example is licensed under Apache 2.0. See the PEFT repository for full license details.
diff --git a/examples/orthogonal_subspace_learning/osf_continual_learning.py b/examples/orthogonal_subspace_learning/osf_continual_learning.py
new file mode 100644
index 0000000..c4584d2
--- /dev/null
+++ b/examples/orthogonal_subspace_learning/osf_continual_learning.py
@@ -0,0 +1,693 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+"""
+OSF Continual Learning Example
+
+This script demonstrates OSF's ability to learn multiple tasks sequentially while preventing
+catastrophic forgetting, compared to standard full fine-tuning.
+
+Tasks:
+1. ScienceQA - Science question answering
+2. NumGLUE - Mathematical reasoning
+3. FOMC - Financial sentiment classification
+
+OSF Configuration:
+- Task 1: effective_rank=0.3 (train 70%, freeze 30%)
+- Task 2: effective_rank=0.5 (train 50%, freeze 50%)
+- Task 3: effective_rank=0.7 (train 30%, freeze 70%)
+"""
+
+import argparse
+import os
+import re
+
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer, Trainer, TrainingArguments
+from utils import (
+    DataCollatorForCompletionOnly,
+    format_fomc_for_llama,
+    format_numglue_for_llama,
+    format_scienceqa_for_llama,
+    load_fomc,
+    load_numglue,
+    load_scienceqa,
+)
+
+from peft import OSFConfig, get_peft_model
+
+
+def compute_accuracy_scienceqa(model, eval_dataset, tokenizer, data_collator):
+    """Compute accuracy for ScienceQA (extract predicted letter)."""
+    model.eval()
+    correct = 0
+    total = 0
+
+    # Create a simple dataloader
+    from torch.utils.data import DataLoader
+
+    dataloader = DataLoader(eval_dataset, batch_size=8, collate_fn=data_collator)
+
+    with torch.no_grad():
+        for batch in dataloader:
+            input_ids = batch["input_ids"].to(model.device)
+            attention_mask = batch["attention_mask"].to(model.device)
+            labels = batch["labels"]
+
+            # Generate predictions
+            outputs = model.generate(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                max_new_tokens=5,
+                pad_token_id=tokenizer.pad_token_id,
+                do_sample=False,
+            )
+
+            # Extract predictions and ground truth
+            for i in range(len(outputs)):
+                # Decode the generated text
+                generated_text = tokenizer.decode(outputs[i], skip_special_tokens=True)
+
+                # Extract the answer (last letter in the generated text)
+                # Look for single capital letters A, B, C, D
+                matches = re.findall(r"\b([A-D])\b", generated_text)
+                pred = matches[-1] if matches else "X"
+
+                # Get ground truth (find the label that's not -100)
+                label_ids = labels[i][labels[i] != -100]
+                if len(label_ids) > 0:
+                    gt = tokenizer.decode(label_ids, skip_special_tokens=True).strip()
+                    if pred == gt:
+                        correct += 1
+                    total += 1
+
+    accuracy = correct / total if total > 0 else 0.0
+    return accuracy
+
+
+def compute_accuracy_numglue(model, eval_dataset, tokenizer, data_collator):
+    """Compute accuracy for NumGLUE (extract predicted number)."""
+    model.eval()
+    correct = 0
+    total = 0
+
+    from torch.utils.data import DataLoader
+
+    dataloader = DataLoader(eval_dataset, batch_size=8, collate_fn=data_collator)
+
+    with torch.no_grad():
+        for batch in dataloader:
+            input_ids = batch["input_ids"].to(model.device)
+            attention_mask = batch["attention_mask"].to(model.device)
+            labels = batch["labels"]
+
+            outputs = model.generate(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                max_new_tokens=20,
+                pad_token_id=tokenizer.pad_token_id,
+                do_sample=False,
+            )
+
+            for i in range(len(outputs)):
+                generated_text = tokenizer.decode(outputs[i], skip_special_tokens=True)
+
+                # Extract number from generated text
+                numbers = re.findall(r"-?\d+\.?\d*", generated_text)
+                pred = numbers[-1] if numbers else "-999"
+
+                # Get ground truth
+                label_ids = labels[i][labels[i] != -100]
+                if len(label_ids) > 0:
+                    gt = tokenizer.decode(label_ids, skip_special_tokens=True).strip()
+                    if pred == gt:
+                        correct += 1
+                    total += 1
+
+    accuracy = correct / total if total > 0 else 0.0
+    return accuracy
+
+
+def compute_accuracy_fomc(model, eval_dataset, tokenizer, data_collator):
+    """Compute accuracy for FOMC (extract predicted sentiment)."""
+    model.eval()
+    correct = 0
+    total = 0
+
+    from torch.utils.data import DataLoader
+
+    dataloader = DataLoader(eval_dataset, batch_size=8, collate_fn=data_collator)
+
+    valid_labels = ["Dovish", "Hawkish", "Neutral"]
+
+    with torch.no_grad():
+        for batch in dataloader:
+            input_ids = batch["input_ids"].to(model.device)
+            attention_mask = batch["attention_mask"].to(model.device)
+            labels = batch["labels"]
+
+            outputs = model.generate(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                max_new_tokens=10,
+                pad_token_id=tokenizer.pad_token_id,
+                do_sample=False,
+            )
+
+            for i in range(len(outputs)):
+                generated_text = tokenizer.decode(outputs[i], skip_special_tokens=True)
+
+                # Extract sentiment label
+                pred = None
+                for label in valid_labels:
+                    if label in generated_text:
+                        pred = label
+                        break
+
+                # Get ground truth
+                label_ids = labels[i][labels[i] != -100]
+                if len(label_ids) > 0:
+                    gt = tokenizer.decode(label_ids, skip_special_tokens=True).strip()
+                    if pred == gt:
+                        correct += 1
+                    total += 1
+
+    accuracy = correct / total if total > 0 else 0.0
+    return accuracy
+
+
+def evaluate_model(model, eval_dataset, data_collator, tokenizer, task_name, task_type):
+    """Evaluate model on a dataset and return loss and accuracy."""
+    # Compute loss
+    trainer = Trainer(
+        model=model,
+        data_collator=data_collator,
+        eval_dataset=eval_dataset,
+        args=TrainingArguments(
+            label_names=["labels"],
+        ),
+    )
+    results = trainer.evaluate()
+    loss = results["eval_loss"]
+
+    # Compute accuracy based on task type
+    if task_type == "scienceqa":
+        accuracy = compute_accuracy_scienceqa(model, eval_dataset, tokenizer, data_collator)
+    elif task_type == "numglue":
+        accuracy = compute_accuracy_numglue(model, eval_dataset, tokenizer, data_collator)
+    elif task_type == "fomc":
+        accuracy = compute_accuracy_fomc(model, eval_dataset, tokenizer, data_collator)
+    else:
+        accuracy = 0.0
+
+    print(f"  {task_name}: Loss = {loss:.4f}, Accuracy = {accuracy * 100:.2f}%")
+    return loss, accuracy
+
+
+def train_with_osf(
+    model_name,
+    num_train,
+    num_eval,
+    output_dir,
+    num_epochs,
+    learning_rate,
+    batch_size,
+    gradient_accumulation_steps,
+    max_length,
+    seed,
+):
+    """Train using OSF with progressive rank allocation."""
+    print("\n" + "=" * 80)
+    print("TRAINING WITH OSF (Orthogonal Subspace Fine-tuning)")
+    print("=" * 80)
+
+    # Load tokenizer and base model
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    tokenizer.pad_token = tokenizer.eos_token
+
+    base_model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.bfloat16, device_map="auto")
+
+    # Load all datasets with task-specific sizes
+    # FOMC only has 496 samples total, so we use 350 train + 146 eval for it
+    print("\nLoading datasets...")
+    scienceqa_train, scienceqa_eval = load_scienceqa(1000, 200, seed)
+    numglue_train, numglue_eval = load_numglue(1000, 200, seed)
+    fomc_train, fomc_eval = load_fomc(350, 146, seed)
+
+    # Store original eval datasets for later
+    scienceqa_eval_original = scienceqa_eval
+    numglue_eval_original = numglue_eval
+    fomc_eval_original = fomc_eval
+
+    # Format datasets
+    scienceqa_train = scienceqa_train.map(
+        lambda x: format_scienceqa_for_llama(x, tokenizer, max_length),
+        batched=True,
+        remove_columns=scienceqa_train.column_names,
+    )
+    scienceqa_eval = scienceqa_eval.map(
+        lambda x: format_scienceqa_for_llama(x, tokenizer, max_length),
+        batched=True,
+        remove_columns=scienceqa_eval.column_names,
+    )
+
+    numglue_train = numglue_train.map(
+        lambda x: format_numglue_for_llama(x, tokenizer, max_length),
+        batched=True,
+        remove_columns=numglue_train.column_names,
+    )
+    numglue_eval = numglue_eval.map(
+        lambda x: format_numglue_for_llama(x, tokenizer, max_length),
+        batched=True,
+        remove_columns=numglue_eval.column_names,
+    )
+
+    fomc_train = fomc_train.map(
+        lambda x: format_fomc_for_llama(x, tokenizer, max_length), batched=True, remove_columns=fomc_train.column_names
+    )
+    fomc_eval = fomc_eval.map(
+        lambda x: format_fomc_for_llama(x, tokenizer, max_length), batched=True, remove_columns=fomc_eval.column_names
+    )
+
+    data_collator = DataCollatorForCompletionOnly(tokenizer, max_length)
+
+    # Task configurations
+    tasks = [
+        {
+            "name": "ScienceQA",
+            "train": scienceqa_train,
+            "eval": scienceqa_eval,
+            "eval_original": scienceqa_eval_original,
+            "effective_rank": 0.3,  # Freeze 30%, train 70%
+            "type": "scienceqa",
+        },
+        {
+            "name": "NumGLUE",
+            "train": numglue_train,
+            "eval": numglue_eval,
+            "eval_original": numglue_eval_original,
+            "effective_rank": 0.5,  # Freeze 50%, train 50%
+            "type": "numglue",
+        },
+        {
+            "name": "FOMC",
+            "train": fomc_train,
+            "eval": fomc_eval,
+            "eval_original": fomc_eval_original,
+            "effective_rank": 0.7,  # Freeze 70%, train 30%
+            "type": "fomc",
+        },
+    ]
+
+    # Store evaluation history: {task_name: [(loss, accuracy), ...]}
+    eval_history = {
+        "ScienceQA": [],
+        "NumGLUE": [],
+        "FOMC": [],
+    }
+
+    # Sequential task training
+    model = base_model
+    for task_idx, task in enumerate(tasks):
+        print(f"\n{'=' * 80}")
+        print(f"TASK {task_idx + 1}: {task['name']}")
+        print(f"Effective Rank: {task['effective_rank']} (preserving {task['effective_rank'] * 100:.0f}%)")
+        print(f"{'=' * 80}")
+
+        # Configure OSF for this task
+        config = OSFConfig(
+            target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
+            effective_rank=task["effective_rank"],
+        )
+
+        # Apply OSF to the model
+        model = get_peft_model(model, config)
+
+        # Training arguments
+        training_args = TrainingArguments(
+            output_dir=f"{output_dir}/osf_{task['name'].lower()}",
+            num_train_epochs=num_epochs,
+            per_device_train_batch_size=batch_size,
+            gradient_accumulation_steps=gradient_accumulation_steps,
+            learning_rate=learning_rate,
+            logging_steps=10,
+            save_strategy="no",
+            bf16=True,
+            remove_unused_columns=False,
+        )
+
+        # Train on current task
+        trainer = Trainer(
+            model=model,
+            args=training_args,
+            train_dataset=task["train"],
+            data_collator=data_collator,
+        )
+
+        print(f"\nTraining on {task['name']}...")
+        trainer.train()
+
+        # Evaluate on all tasks seen so far
+        print(f"\nEvaluating on all tasks after training on {task['name']}:")
+        for eval_task_idx in range(task_idx + 1):
+            eval_task = tasks[eval_task_idx]
+            loss, accuracy = evaluate_model(
+                model, eval_task["eval"], data_collator, tokenizer, eval_task["name"], eval_task["type"]
+            )
+            eval_history[eval_task["name"]].append((loss, accuracy))
+
+        # Unload OSF to get the updated base model for next task (if not last task)
+        if task_idx < len(tasks) - 1:
+            print("\nUnloading OSF adapter to prepare for next task...")
+            model = model.unload()
+
+    # Save final model
+    final_model_path = f"{output_dir}/osf_final"
+    model.save_pretrained(final_model_path)
+    print(f"\nFinal OSF model saved to {final_model_path}")
+
+    return eval_history
+
+
+def train_full_finetuning(
+    model_name,
+    num_train,
+    num_eval,
+    output_dir,
+    num_epochs,
+    learning_rate,
+    batch_size,
+    gradient_accumulation_steps,
+    max_length,
+    seed,
+):
+    """Train using standard full fine-tuning (baseline for comparison)."""
+    print("\n" + "=" * 80)
+    print("TRAINING WITH FULL FINE-TUNING (Baseline)")
+    print("=" * 80)
+
+    # Load tokenizer
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    tokenizer.pad_token = tokenizer.eos_token
+
+    # Load all datasets with task-specific sizes
+    # FOMC only has 496 samples total, so we use 350 train + 146 eval for it
+    print("\nLoading datasets...")
+    scienceqa_train, scienceqa_eval = load_scienceqa(1000, 200, seed)
+    numglue_train, numglue_eval = load_numglue(1000, 200, seed)
+    fomc_train, fomc_eval = load_fomc(350, 146, seed)
+
+    # Store original eval datasets
+    scienceqa_eval_original = scienceqa_eval
+    numglue_eval_original = numglue_eval
+    fomc_eval_original = fomc_eval
+
+    # Format datasets
+    scienceqa_train = scienceqa_train.map(
+        lambda x: format_scienceqa_for_llama(x, tokenizer, max_length),
+        batched=True,
+        remove_columns=scienceqa_train.column_names,
+    )
+    scienceqa_eval = scienceqa_eval.map(
+        lambda x: format_scienceqa_for_llama(x, tokenizer, max_length),
+        batched=True,
+        remove_columns=scienceqa_eval.column_names,
+    )
+
+    numglue_train = numglue_train.map(
+        lambda x: format_numglue_for_llama(x, tokenizer, max_length),
+        batched=True,
+        remove_columns=numglue_train.column_names,
+    )
+    numglue_eval = numglue_eval.map(
+        lambda x: format_numglue_for_llama(x, tokenizer, max_length),
+        batched=True,
+        remove_columns=numglue_eval.column_names,
+    )
+
+    fomc_train = fomc_train.map(
+        lambda x: format_fomc_for_llama(x, tokenizer, max_length), batched=True, remove_columns=fomc_train.column_names
+    )
+    fomc_eval = fomc_eval.map(
+        lambda x: format_fomc_for_llama(x, tokenizer, max_length), batched=True, remove_columns=fomc_eval.column_names
+    )
+
+    data_collator = DataCollatorForCompletionOnly(tokenizer, max_length)
+
+    tasks = [
+        {"name": "ScienceQA", "train": scienceqa_train, "eval": scienceqa_eval, "type": "scienceqa"},
+        {"name": "NumGLUE", "train": numglue_train, "eval": numglue_eval, "type": "numglue"},
+        {"name": "FOMC", "train": fomc_train, "eval": fomc_eval, "type": "fomc"},
+    ]
+
+    # Store evaluation history
+    eval_history = {
+        "ScienceQA": [],
+        "NumGLUE": [],
+        "FOMC": [],
+    }
+
+    # Load base model once
+    model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.bfloat16, device_map="auto")
+
+    # Sequential task training
+    for task_idx, task in enumerate(tasks):
+        print(f"\n{'=' * 80}")
+        print(f"TASK {task_idx + 1}: {task['name']}")
+        print(f"{'=' * 80}")
+
+        # Training arguments
+        training_args = TrainingArguments(
+            output_dir=f"{output_dir}/full_{task['name'].lower()}",
+            num_train_epochs=num_epochs,
+            per_device_train_batch_size=batch_size,
+            gradient_accumulation_steps=gradient_accumulation_steps,
+            learning_rate=learning_rate,
+            logging_steps=10,
+            save_strategy="no",
+            bf16=True,
+            remove_unused_columns=False,
+        )
+
+        # Train on current task
+        trainer = Trainer(
+            model=model,
+            args=training_args,
+            train_dataset=task["train"],
+            data_collator=data_collator,
+        )
+
+        print(f"\nTraining on {task['name']}...")
+        trainer.train()
+
+        # Evaluate on all tasks seen so far
+        print(f"\nEvaluating on all tasks after training on {task['name']}:")
+        for eval_task_idx in range(task_idx + 1):
+            eval_task = tasks[eval_task_idx]
+            loss, accuracy = evaluate_model(
+                model, eval_task["eval"], data_collator, tokenizer, eval_task["name"], eval_task["type"]
+            )
+            eval_history[eval_task["name"]].append((loss, accuracy))
+
+    # Save final model
+    final_model_path = f"{output_dir}/full_final"
+    model.save_pretrained(final_model_path)
+    print(f"\nFinal full fine-tuning model saved to {final_model_path}")
+
+    return eval_history
+
+
+def print_results_comparison(osf_history, full_history):
+    """Print comparison table of OSF vs Full Fine-tuning."""
+    print("\n" + "=" * 80)
+    print("RESULTS COMPARISON: OSF vs Full Fine-tuning")
+    print("=" * 80)
+
+    tasks = ["ScienceQA", "NumGLUE", "FOMC"]
+
+    # Print detailed results
+    print("\n" + "-" * 80)
+    print("DETAILED RESULTS (Accuracy %)")
+    print("-" * 80)
+    print(f"{'Task':<15} {'After Task':<15} {'OSF Acc %':<15} {'Full FT Acc %':<15} {'Difference':<15}")
+    print("-" * 80)
+
+    for task_idx, task in enumerate(tasks):
+        for eval_after_idx in range(task_idx, len(tasks)):
+            eval_after = tasks[eval_after_idx]
+            osf_acc = osf_history[task][eval_after_idx - task_idx][1] * 100
+            full_acc = full_history[task][eval_after_idx - task_idx][1] * 100
+            diff = osf_acc - full_acc
+
+            print(
+                f"{task:<15} {eval_after:<15} {osf_acc:<15.2f} {full_acc:<15.2f} {diff:+15.2f}{'  (OSF better)' if diff > 0 else ''}"
+            )
+
+    # Summary statistics
+    print("\n" + "=" * 80)
+    print("SUMMARY METRICS")
+    print("=" * 80)
+
+    # Final average accuracy across all 3 tasks
+    osf_final_accs = [osf_history[task][-1][1] * 100 for task in tasks]
+    full_final_accs = [full_history[task][-1][1] * 100 for task in tasks]
+
+    osf_avg_final = sum(osf_final_accs) / len(osf_final_accs)
+    full_avg_final = sum(full_final_accs) / len(full_final_accs)
+
+    print("\n1. Average Accuracy Across All 3 Tasks (After Final Task):")
+    print(f"   OSF:     {osf_avg_final:.2f}%")
+    print(f"   Full FT: {full_avg_final:.2f}%")
+    print(
+        f"   Difference: {osf_avg_final - full_avg_final:+.2f}% {'(OSF better)' if osf_avg_final > full_avg_final else '(Full FT better)'}"
+    )
+
+    # Average forgetting (for tasks 1 and 2 only, since task 3 is the final task)
+    print("\n2. Average Forgetting (Task 1 & 2):")
+    print("   Forgetting = Final Accuracy - Initial Accuracy (negative is worse)\n")
+
+    osf_forgetting_vals = []
+    full_forgetting_vals = []
+
+    for task_idx, task in enumerate(tasks[:-1]):  # Exclude last task
+        osf_initial_acc = osf_history[task][0][1] * 100  # Right after learning task
+        osf_final_acc = osf_history[task][-1][1] * 100  # After learning all tasks
+        osf_forgetting = osf_final_acc - osf_initial_acc
+
+        full_initial_acc = full_history[task][0][1] * 100
+        full_final_acc = full_history[task][-1][1] * 100
+        full_forgetting = full_final_acc - full_initial_acc
+
+        osf_forgetting_vals.append(osf_forgetting)
+        full_forgetting_vals.append(full_forgetting)
+
+        print(f"   {task}:")
+        print(f"     OSF:     {osf_forgetting:+.2f}% (initial: {osf_initial_acc:.2f}% → final: {osf_final_acc:.2f}%)")
+        print(
+            f"     Full FT: {full_forgetting:+.2f}% (initial: {full_initial_acc:.2f}% → final: {full_final_acc:.2f}%)"
+        )
+        print(
+            f"     Difference: {osf_forgetting - full_forgetting:+.2f}% {'(OSF better)' if osf_forgetting > full_forgetting else '(Full FT better)'}\n"
+        )
+
+    osf_avg_forgetting = sum(osf_forgetting_vals) / len(osf_forgetting_vals)
+    full_avg_forgetting = sum(full_forgetting_vals) / len(full_forgetting_vals)
+
+    print("   Average Forgetting:")
+    print(f"     OSF:     {osf_avg_forgetting:+.2f}%")
+    print(f"     Full FT: {full_avg_forgetting:+.2f}%")
+    print(
+        f"     Difference: {osf_avg_forgetting - full_avg_forgetting:+.2f}% {'(OSF better)' if osf_avg_forgetting > full_avg_forgetting else '(Full FT better)'}"
+    )
+
+    print("\n" + "=" * 80)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="OSF Continual Learning Example")
+    parser.add_argument(
+        "--model_name",
+        type=str,
+        default="meta-llama/Llama-3.1-8B-Instruct",
+        help="Model name or path",
+    )
+    parser.add_argument("--num_train", type=int, default=1000, help="Number of training samples per task")
+    parser.add_argument("--num_eval", type=int, default=200, help="Number of evaluation samples per task")
+    parser.add_argument("--output_dir", type=str, default="./osf_continual_learning_outputs", help="Output directory")
+    parser.add_argument("--num_epochs", type=int, default=2, help="Number of training epochs per task")
+    parser.add_argument("--learning_rate", type=float, default=5e-6, help="Learning rate")
+    parser.add_argument("--batch_size", type=int, default=32, help="Batch size per device")
+    parser.add_argument("--gradient_accumulation_steps", type=int, default=1, help="Gradient accumulation steps")
+    parser.add_argument("--max_length", type=int, default=512, help="Maximum sequence length")
+    parser.add_argument("--seed", type=int, default=42, help="Random seed")
+    parser.add_argument(
+        "--run_baseline",
+        action="store_true",
+        help="Also run full fine-tuning baseline for comparison",
+    )
+
+    args = parser.parse_args()
+
+    # Create output directory
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    # Train with OSF
+    osf_history = train_with_osf(
+        args.model_name,
+        args.num_train,
+        args.num_eval,
+        args.output_dir,
+        args.num_epochs,
+        args.learning_rate,
+        args.batch_size,
+        args.gradient_accumulation_steps,
+        args.max_length,
+        args.seed,
+    )
+
+    # Optionally train with full fine-tuning baseline
+    if args.run_baseline:
+        full_history = train_full_finetuning(
+            args.model_name,
+            args.num_train,
+            args.num_eval,
+            args.output_dir,
+            args.num_epochs,
+            args.learning_rate,
+            args.batch_size,
+            args.gradient_accumulation_steps,
+            args.max_length,
+            args.seed,
+        )
+
+        # Print comparison
+        print_results_comparison(osf_history, full_history)
+    else:
+        print("\n" + "=" * 80)
+        print("OSF TRAINING COMPLETE")
+        print("=" * 80)
+        print("\nTo compare with full fine-tuning baseline, run with --run_baseline flag")
+
+        # Print OSF-only summary
+        tasks = ["ScienceQA", "NumGLUE", "FOMC"]
+        print("\n" + "=" * 80)
+        print("OSF SUMMARY METRICS")
+        print("=" * 80)
+
+        # Final average accuracy
+        osf_final_accs = [osf_history[task][-1][1] * 100 for task in tasks]
+        osf_avg_final = sum(osf_final_accs) / len(osf_final_accs)
+
+        print(f"\n1. Average Accuracy Across All 3 Tasks (After Final Task): {osf_avg_final:.2f}%")
+        for task, acc in zip(tasks, osf_final_accs):
+            print(f"   {task}: {acc:.2f}%")
+
+        # Average forgetting
+        print("\n2. Average Forgetting (Task 1 & 2):")
+        osf_forgetting_vals = []
+        for task_idx, task in enumerate(tasks[:-1]):
+            osf_initial_acc = osf_history[task][0][1] * 100
+            osf_final_acc = osf_history[task][-1][1] * 100
+            osf_forgetting = osf_initial_acc - osf_final_acc
+            osf_forgetting_vals.append(osf_forgetting)
+
+            print(f"   {task}: {osf_forgetting:+.2f}% (initial: {osf_initial_acc:.2f}% → final: {osf_final_acc:.2f}%)")
+
+        osf_avg_forgetting = sum(osf_forgetting_vals) / len(osf_forgetting_vals)
+        print(f"   Average: {osf_avg_forgetting:+.2f}%")
+        print("\n" + "=" * 80)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/orthogonal_subspace_learning/utils.py b/examples/orthogonal_subspace_learning/utils.py
new file mode 100644
index 0000000..6dd8dde
--- /dev/null
+++ b/examples/orthogonal_subspace_learning/utils.py
@@ -0,0 +1,304 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+
+import torch
+from datasets import load_dataset
+
+
+def load_scienceqa(num_train=1000, num_eval=200, seed=42):
+    """
+    Load ScienceQA dataset for science question answering.
+
+    Args:
+        num_train: Number of training samples
+        num_eval: Number of evaluation samples
+        seed: Random seed for reproducibility
+
+    Returns:
+        train_dataset, eval_dataset
+    """
+    dataset = load_dataset("derek-thomas/ScienceQA", split="train")
+
+    # Shuffle and split
+    dataset = dataset.shuffle(seed=seed)
+    train_dataset = dataset.select(range(num_train))
+    eval_dataset = dataset.select(range(num_train, num_train + num_eval))
+
+    return train_dataset, eval_dataset
+
+
+def load_numglue(num_train=1000, num_eval=200, seed=42):
+    """
+    Load NumGLUE dataset for mathematical reasoning.
+
+    Args:
+        num_train: Number of training samples
+        num_eval: Number of evaluation samples
+        seed: Random seed for reproducibility
+
+    Returns:
+        train_dataset, eval_dataset
+    """
+    import json
+
+    from datasets import Dataset
+    from huggingface_hub import hf_hub_download
+
+    # Download the NumGLUE JSON file manually
+    json_path = hf_hub_download(repo_id="metaeval/num-glue", filename="NumGLUE_train.json", repo_type="dataset")
+
+    # Read and process the JSON file line by line
+    data = []
+    with open(json_path) as f:
+        for line in f:
+            if line.strip():  # Skip empty lines
+                item = json.loads(line)
+                # Extract the number from the answer JSON structure
+                answer = item.get("answer", "")
+                if isinstance(answer, dict):
+                    # NumGLUE answers are JSON with 'number' and 'date' fields
+                    # Extract just the number field
+                    answer_str = answer.get("number", "")
+                else:
+                    answer_str = str(answer)
+
+                data.append({"question": item.get("question", ""), "answer": answer_str})
+
+    # Create dataset from processed data
+    dataset = Dataset.from_list(data)
+
+    # Shuffle and split
+    dataset = dataset.shuffle(seed=seed)
+    train_dataset = dataset.select(range(min(num_train, len(dataset))))
+
+    # If not enough samples, use what's available
+    eval_start = min(num_train, len(dataset))
+    eval_end = min(num_train + num_eval, len(dataset))
+    eval_dataset = dataset.select(range(eval_start, eval_end))
+
+    return train_dataset, eval_dataset
+
+
+def load_fomc(num_train=1000, num_eval=200, seed=42):
+    """
+    Load FOMC dataset for financial sentiment classification.
+
+    Args:
+        num_train: Number of training samples
+        num_eval: Number of evaluation samples
+        seed: Random seed for reproducibility
+
+    Returns:
+        train_dataset, eval_dataset
+    """
+    dataset = load_dataset("TheFinAI/finben-fomc", split="test")
+
+    # Shuffle and split
+    dataset = dataset.shuffle(seed=seed)
+    train_dataset = dataset.select(range(min(num_train, len(dataset))))
+
+    eval_start = min(num_train, len(dataset))
+    eval_end = min(num_train + num_eval, len(dataset))
+    eval_dataset = dataset.select(range(eval_start, eval_end))
+
+    return train_dataset, eval_dataset
+
+
+def format_scienceqa_for_llama(examples, tokenizer, max_length=512):
+    """Format ScienceQA examples for Llama instruction following."""
+    prompts = []
+    labels_text = []
+
+    for i in range(len(examples["question"])):
+        # Build the question with choices
+        question = examples["question"][i]
+        choices = examples["choices"][i]
+
+        # Format choices
+        choices_text = "\n".join([f"{chr(65 + j)}. {choice}" for j, choice in enumerate(choices)])
+
+        prompt = f"""Answer the following science question by selecting the correct option.
+                    Question: {question}
+
+                    Choices:
+{choices_text}
+
+Answer (just the letter):"""
+
+        # Get the answer (convert index to letter)
+        answer_idx = examples["answer"][i]
+        answer = chr(65 + answer_idx)
+
+        prompts.append(prompt)
+        labels_text.append(answer)
+
+    # Tokenize
+    model_inputs = tokenizer(prompts, max_length=max_length, truncation=True, padding=False)
+
+    # Tokenize labels
+    labels = tokenizer(labels_text, max_length=10, truncation=True, padding=False)
+
+    # Combine input and label for training
+    combined_input_ids = []
+    combined_attention_mask = []
+    combined_labels = []
+
+    for i in range(len(model_inputs["input_ids"])):
+        input_ids = model_inputs["input_ids"][i]
+        label_ids = labels["input_ids"][i]
+
+        # Combine input and label
+        combined = input_ids + label_ids + [tokenizer.eos_token_id]
+        combined_input_ids.append(combined)
+
+        # Attention mask
+        combined_attention_mask.append([1] * len(combined))
+
+        # Labels (mask the prompt part, only train on answer)
+        label_masked = [-100] * len(input_ids) + label_ids + [tokenizer.eos_token_id]
+        combined_labels.append(label_masked)
+
+    return {
+        "input_ids": combined_input_ids,
+        "attention_mask": combined_attention_mask,
+        "labels": combined_labels,
+    }
+
+
+def format_numglue_for_llama(examples, tokenizer, max_length=512):
+    """Format NumGLUE examples for Llama instruction following."""
+    prompts = []
+    labels_text = []
+
+    for i in range(len(examples["question"])):
+        question = examples["question"][i]
+        answer = str(examples["answer"][i])
+
+        prompt = f"""Solve the following math problem and provide just the numerical answer.
+
+Question: {question}
+
+Answer:"""
+
+        prompts.append(prompt)
+        labels_text.append(answer)
+
+    # Tokenize
+    model_inputs = tokenizer(prompts, max_length=max_length, truncation=True, padding=False)
+    labels = tokenizer(labels_text, max_length=20, truncation=True, padding=False)
+
+    combined_input_ids = []
+    combined_attention_mask = []
+    combined_labels = []
+
+    for i in range(len(model_inputs["input_ids"])):
+        input_ids = model_inputs["input_ids"][i]
+        label_ids = labels["input_ids"][i]
+
+        combined = input_ids + label_ids + [tokenizer.eos_token_id]
+        combined_input_ids.append(combined)
+        combined_attention_mask.append([1] * len(combined))
+
+        label_masked = [-100] * len(input_ids) + label_ids + [tokenizer.eos_token_id]
+        combined_labels.append(label_masked)
+
+    return {
+        "input_ids": combined_input_ids,
+        "attention_mask": combined_attention_mask,
+        "labels": combined_labels,
+    }
+
+
+def format_fomc_for_llama(examples, tokenizer, max_length=512):
+    """Format FOMC examples for Llama instruction following."""
+    prompts = []
+    labels_text = []
+
+    for i in range(len(examples["text"])):
+        text = examples["text"][i]
+        # FOMC dataset has 'answer' column with values like 'dovish', 'hawkish', 'neutral'
+        label = examples["answer"][i].capitalize()  # Capitalize first letter
+
+        prompt = f"""Classify the sentiment of the following Federal Reserve statement as Dovish, Hawkish, or Neutral.
+
+Statement: {text}
+
+Sentiment:"""
+
+        prompts.append(prompt)
+        labels_text.append(label)
+
+    # Tokenize
+    model_inputs = tokenizer(prompts, max_length=max_length, truncation=True, padding=False)
+    labels = tokenizer(labels_text, max_length=10, truncation=True, padding=False)
+
+    combined_input_ids = []
+    combined_attention_mask = []
+    combined_labels = []
+
+    for i in range(len(model_inputs["input_ids"])):
+        input_ids = model_inputs["input_ids"][i]
+        label_ids = labels["input_ids"][i]
+
+        combined = input_ids + label_ids + [tokenizer.eos_token_id]
+        combined_input_ids.append(combined)
+        combined_attention_mask.append([1] * len(combined))
+
+        label_masked = [-100] * len(input_ids) + label_ids + [tokenizer.eos_token_id]
+        combined_labels.append(label_masked)
+
+    return {
+        "input_ids": combined_input_ids,
+        "attention_mask": combined_attention_mask,
+        "labels": combined_labels,
+    }
+
+
+class DataCollatorForCompletionOnly:
+    """Data collator that pads sequences for training."""
+
+    def __init__(self, tokenizer, max_length=512):
+        self.tokenizer = tokenizer
+        self.max_length = max_length
+
+    def __call__(self, features):
+        # Pad sequences
+        max_len = min(max(len(f["input_ids"]) for f in features), self.max_length)
+
+        input_ids = []
+        attention_mask = []
+        labels = []
+
+        for f in features:
+            # Truncate if needed
+            curr_input_ids = f["input_ids"][:max_len]
+            curr_attention_mask = f["attention_mask"][:max_len]
+            curr_labels = f["labels"][:max_len]
+
+            # Pad
+            padding_length = max_len - len(curr_input_ids)
+            curr_input_ids = curr_input_ids + [self.tokenizer.pad_token_id] * padding_length
+            curr_attention_mask = curr_attention_mask + [0] * padding_length
+            curr_labels = curr_labels + [-100] * padding_length
+
+            input_ids.append(curr_input_ids)
+            attention_mask.append(curr_attention_mask)
+            labels.append(curr_labels)
+
+        return {
+            "input_ids": torch.tensor(input_ids, dtype=torch.long),
+            "attention_mask": torch.tensor(attention_mask, dtype=torch.long),
+            "labels": torch.tensor(labels, dtype=torch.long),
+        }
diff --git a/examples/peanut_finetuning/README.md b/examples/peanut_finetuning/README.md
new file mode 100644
index 0000000..edd13a7
--- /dev/null
+++ b/examples/peanut_finetuning/README.md
@@ -0,0 +1,86 @@
+# PEANuT: Parameter-Efficient Adaptation with Weight-aware Neural Tweakers
+
+## Introduction
+[**PEANuT**](https://arxiv.org/abs/2410.01870) is a PEFT method that introduces a **weight-aware neural tweaker** to generate adapter updates from the base weight itself. Instead of directly learning a low-rank decomposition `Delta W = A @ B` as in LoRA, PEANuT transforms the target layer weight through a small neural network (the neural tweaker) to produce `Delta W`.
+
+PEANuT is built on three key ideas:
+
+- **Weight-aware adaptation**: `Delta W` is produced by transforming the base weight using `A`, `B`, and optional intermediate layers. Because PEANuT applies `A` on the output dimension of the base weight, `A` has shape `(out_features, r)` instead of LoRA's typical `(in_features, r)`. When `in_features > out_features`, PEANuT can use fewer parameters than LoRA at the same rank.
+- **Non-linearity inside the tweaker**: PEANuT inserts activation functions in the neural tweaker (default: `relu`) to increase expressiveness.
+- **Depth capacity increase**: Besides mandatory `A` and `B`, PEANuT can insert intermediate `r x r` layers in residual encoder/decoder pairs. Here, `depth` counts the number of residual pairs, so `depth=0` means only `A` and `B`.
+
+## Quick start
+
+With respect to your standard PEFT training procedure with LoRA, simply swap your `LoraConfig` for a `PeanutConfig`.
+
+```python
+import torch
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from trl import SFTConfig, SFTTrainer
+
+from peft import PeanutConfig
+
+model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.2-3B", dtype=torch.bfloat16, device_map="auto")
+tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-3B")
+dataset = load_dataset("timdettmers/openassistant-guanaco", split="train")
+peanut_config = PeanutConfig()
+
+trainer = SFTTrainer(
+    model=model,
+    train_dataset=dataset,
+    processing_class=tokenizer,
+    peft_config=peanut_config,
+    args=SFTConfig(
+        max_length=2048,
+        dataset_text_field="text",
+        per_device_train_batch_size=2,
+    ),
+)
+trainer.train()
+trainer.model.save_pretrained("peanut-llama-3.2-3b")
+```
+
+Run the finetuning script simply by running:
+```sh
+python examples/peanut_finetuning/peanut_finetuning.py --base_model meta-llama/Llama-3.2-3B --data_path timdettmers/openassistant-guanaco
+```
+
+## Use the model on Hugging Face
+You can load and use the model as any other Hugging Face model.
+
+```python
+import torch
+from peft import PeftModel
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained(
+    "meta-llama/Llama-3.2-3B", dtype=torch.bfloat16, device_map="auto"
+)
+peft_model = PeftModel.from_pretrained(model, "peanut-llama-3.2-3b")
+```
+
+## Additional Notes
+
+- `r` controls the hidden rank of the neural tweaker. Larger `r` increases capacity and trainable parameters.
+- `depth` controls the number of intermediate encoder/decoder residual pairs. It must be a non-negative integer.
+- `depth=0` means only `A` and `B`.
+- `depth=1` adds one encoder/decoder residual pair between `A` and `B`.
+- Larger depths add more `r x r` residual pairs.
+- `act_fn` controls the non-linearity inside PEANuT and defaults to `relu`.
+- `scaling` is a direct scalar multiplier on the adapter output before it is added to the frozen base layer output.
+- PEANuT can perform better than LoRA across a range of tasks. We also find it strong in very low-parameter regimes (for example around `0.2M` trainable parameters).
+- Compared with LoRA, PEANuT typically uses more GPU memory and runs slower because it explicitly constructs `Delta W` during forward passes. Adding intermediate layers (higher `depth`) increases this overhead further.
+
+## Citation
+```bibtex
+@misc{zhong2025peanutparameterefficientadaptationweightaware,
+      title={PEANuT: Parameter-Efficient Adaptation with Weight-aware Neural Tweakers}, 
+      author={Yibo Zhong and Haoxiang Jiang and Lincan Li and Ryumei Nakada and Tianci Liu and Linjun Zhang and Huaxiu Yao and Haoyu Wang},
+      year={2025},
+      eprint={2410.01870},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG},
+      url={https://arxiv.org/abs/2410.01870}, 
+}
+```
diff --git a/examples/peanut_finetuning/peanut_finetuning.py b/examples/peanut_finetuning/peanut_finetuning.py
new file mode 100644
index 0000000..a74ed74
--- /dev/null
+++ b/examples/peanut_finetuning/peanut_finetuning.py
@@ -0,0 +1,207 @@
+# This script is based on examples/lily_finetuning/lily_finetuning.py
+import os
+
+import torch
+from datasets import load_dataset
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    DataCollatorForLanguageModeling,
+    Trainer,
+    TrainingArguments,
+)
+
+from peft import PeanutConfig, get_peft_model
+
+
+def train_model(
+    base_model: str,
+    data_path: str,
+    output_dir: str,
+    batch_size: int,
+    num_epochs: int,
+    learning_rate: float,
+    cutoff_len: int,
+    val_set_size: int,
+    eval_step: int,
+    save_step: int,
+    device: str,
+    peanut_r: int,
+    peanut_depth: int,
+    peanut_scaling: float,
+    peanut_act_fn: str,
+    peanut_target_modules: str,
+    peanut_init_weights: bool,
+    hub_model_id: str,
+    push_to_hub: bool,
+):
+    os.environ["TOKENIZERS_PARALLELISM"] = "false"
+    hf_token = os.getenv("HF_TOKEN")
+
+    # Setup device
+    if device == "auto":
+        device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+    else:
+        device = torch.device(device)
+    print(f"Using device: {device}")
+
+    # load tokenizer
+    tokenizer = AutoTokenizer.from_pretrained(base_model, token=hf_token)
+
+    model = AutoModelForCausalLM.from_pretrained(base_model, token=hf_token)
+
+    # PEANuT config for the PEFT model
+    peanut_config = PeanutConfig(
+        r=peanut_r,
+        depth=peanut_depth,
+        scaling=peanut_scaling,
+        act_fn=peanut_act_fn,
+        init_weights=peanut_init_weights,
+        target_modules=(
+            peanut_target_modules.split(",")
+            if peanut_target_modules
+            else ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
+        ),
+    )
+
+    # get the peft model with PEANuT config
+    model = get_peft_model(model, peanut_config)
+    model.print_trainable_parameters()
+
+    model.to(device)
+    tokenizer.pad_token = tokenizer.eos_token
+
+    # Load the dataset
+    dataset = load_dataset(data_path)
+
+    def tokenize_function(examples):
+        inputs = tokenizer(examples["text"], padding="max_length", truncation=True, max_length=cutoff_len)
+        inputs["labels"] = inputs["input_ids"].copy()  # setting labels for a language modeling task
+        return inputs
+
+    # Tokenize the dataset and prepare for training
+    tokenized_datasets = dataset.map(tokenize_function, batched=True, remove_columns=dataset["train"].column_names)
+
+    # Data collator to dynamically pad the batched examples
+    data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)
+
+    # Define training arguments
+    training_args = TrainingArguments(
+        output_dir=output_dir,
+        num_train_epochs=num_epochs,
+        per_device_train_batch_size=batch_size,
+        per_device_eval_batch_size=batch_size,
+        warmup_steps=100,
+        weight_decay=0.01,
+        logging_steps=eval_step,
+        save_steps=save_step,
+        save_total_limit=2,
+        push_to_hub=push_to_hub,
+        hub_model_id=hub_model_id,
+        gradient_accumulation_steps=16,
+        fp16=True,
+        learning_rate=learning_rate,
+        hub_token=hf_token,
+    )
+
+    # Clear device cache to free memory
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+    elif torch.xpu.is_available():
+        torch.xpu.empty_cache()
+
+    # Initialize the Trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=tokenized_datasets["train"],
+        eval_dataset=tokenized_datasets["test"],
+        data_collator=data_collator,
+    )
+
+    # Start model training
+    trainer.train()
+
+    # Save and push the trained model and tokenizer
+    if push_to_hub:
+        trainer.push_to_hub(commit_message="Fine-tuned model with PEANuT")
+
+    # Save the model and tokenizer locally
+    model.save_pretrained(output_dir)
+    tokenizer.save_pretrained(output_dir)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Fine-tune LLaMA with PEANuT and PEFT")
+    parser.add_argument("--base_model", type=str, default="meta-llama/Llama-3.2-3B", help="Base model path or name")
+    parser.add_argument(
+        "--data_path", type=str, default="timdettmers/openassistant-guanaco", help="Dataset path or name"
+    )
+    parser.add_argument(
+        "--output_dir", type=str, default="path/to/output", help="Output directory for the fine-tuned model"
+    )
+    parser.add_argument("--batch_size", type=int, default=1, help="Batch size")
+    parser.add_argument("--num_epochs", type=int, default=1, help="Number of training epochs")
+    parser.add_argument("--learning_rate", type=float, default=1e-4, help="Learning rate")
+    parser.add_argument("--cutoff_len", type=int, default=512, help="Cutoff length for tokenization")
+    parser.add_argument("--val_set_size", type=int, default=500, help="Validation set size")
+    parser.add_argument("--eval_step", type=int, default=10, help="Evaluation step interval")
+    parser.add_argument("--save_step", type=int, default=100, help="Save step interval")
+    parser.add_argument("--device", type=str, default="auto", help="Device to use for training")
+    parser.add_argument("--peanut_r", type=int, default=32, help="PEANuT rank")
+    parser.add_argument(
+        "--peanut_depth",
+        type=int,
+        default=0,
+        help="Total number of PEANuT transforms including A and B (must be even and >= 2)",
+    )
+    parser.add_argument(
+        "--peanut_scaling", type=float, default=1.0, help="PEANuT scaling factor applied to adapter output"
+    )
+    parser.add_argument(
+        "--peanut_act_fn",
+        type=str,
+        default="relu",
+        help="Activation used inside PEANuT neural tweakers (must be a valid transformers ACT2FN key)",
+    )
+    parser.add_argument(
+        "--peanut_target_modules", type=str, default=None, help="Comma-separated list of target modules for PEANuT"
+    )
+    parser.add_argument(
+        "--peanut_init_weights",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Use PEANuT default init: zero-init B and Kaiming-init the other layers",
+    )
+    parser.add_argument(
+        "--hub_model_id",
+        type=str,
+        default="path/to/repo",
+        help="Repository name to push the model on the Hugging Face Hub",
+    )
+    parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to Hugging Face Hub")
+    args = parser.parse_args()
+
+    train_model(
+        base_model=args.base_model,
+        data_path=args.data_path,
+        output_dir=args.output_dir,
+        batch_size=args.batch_size,
+        num_epochs=args.num_epochs,
+        learning_rate=args.learning_rate,
+        cutoff_len=args.cutoff_len,
+        val_set_size=args.val_set_size,
+        eval_step=args.eval_step,
+        save_step=args.save_step,
+        device=args.device,
+        peanut_r=args.peanut_r,
+        peanut_depth=args.peanut_depth,
+        peanut_scaling=args.peanut_scaling,
+        peanut_act_fn=args.peanut_act_fn,
+        peanut_target_modules=args.peanut_target_modules,
+        peanut_init_weights=args.peanut_init_weights,
+        hub_model_id=args.hub_model_id,
+        push_to_hub=args.push_to_hub,
+    )
diff --git a/examples/pissa_finetuning/README.md b/examples/pissa_finetuning/README.md
new file mode 100644
index 0000000..44f9e23
--- /dev/null
+++ b/examples/pissa_finetuning/README.md
@@ -0,0 +1,131 @@
+# PiSSA: Principal Singular values and Singular vectors Adaptation
+## Introduction ([Paper](https://huggingface.co/papers/2404.02948), [code](https://github.com/GraphPKU/PiSSA))
+PiSSA represents a matrix $W\in\mathbb{R}^{m\times n}$ within the model by the product of two trainable matrices $A \in \mathbb{R}^{m\times r}$ and $B \in \mathbb{R}^{r\times n}$, where $r \ll \min(m, n)$, plus a residual matrix $W^{res}\in\mathbb{R}^{m\times n}$ for error correction. Singular value decomposition (SVD) is employed to factorize $W$, and the principal singular values and vectors of $W$ are utilized to initialize $A$ and $B$. The residual singular values and vectors initialize the residual matrix $W^{res}$, which keeps frozen during fine-tuning. This straightforward modification allows PiSSA to converge more rapidly than LoRA and ultimately attain superior performance. Moreover, PiSSA reduces the quantization error compared to QLoRA, leading to further enhancements.
+
+## Quick Start
+```python
+import torch
+from peft import LoraConfig, get_peft_model
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from trl import SFTConfig, SFTTrainer
+from datasets import load_dataset
+
+model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf", dtype=torch.bfloat16, device_map="auto")
+tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf")
+tokenizer.pad_token_id = tokenizer.eos_token_id
+lora_config = LoraConfig(
+    # init_lora_weights="pissa", # Configure the initialization method to "pissa", which may take several minutes to execute SVD on the pre-trained model.
+    init_lora_weights="pissa_niter_4", # Initialize the PiSSA with fast SVD, which completes in just a few seconds.
+)
+peft_model = get_peft_model(model, lora_config)
+
+peft_model.print_trainable_parameters()
+
+dataset = load_dataset("imdb", split="train[:1%]")
+
+training_args = SFTConfig(dataset_text_field="text", max_length=128)
+trainer = SFTTrainer(
+    model=peft_model,
+    args=training_args,
+    train_dataset=dataset,
+    processing_class=tokenizer,
+)
+trainer.train()
+peft_model.save_pretrained("pissa-llama-2-7b")
+```
+When utilizing fast SVD, reducing the rank and the number of iterations decreases the time required. However, this approach leads to higher errors in the computed matrices $A$ and $B$. To preserve the model's initial capabilities, we calculate the residual matrix by $W^{res} = W - BA$. Even with potential errors in $A$ and $B$, the sum of $W^{res}$ and $BA$ accurately equals $W$.
+
+
+To utilize the fine-tuned PiSSA modules, simply run the following command:
+```python
+import torch
+from peft import PeftModel
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained(
+    "meta-llama/Llama-2-7b-hf", dtype=torch.bfloat16, device_map="auto"
+)
+# Performs SVD again to initialize the residual model and loads the state_dict of the fine-tuned PiSSA modules.
+peft_model = PeftModel.from_pretrained(model, "pissa-llama-2-7b")
+```
+
+## Advanced Usage
+
+### Access the preprocessed models
+We recommend downloading decomposed models directly from the [Hugging Face Collections](https://huggingface.co/collections/fxmeng/pissa-661ce700721235e542a5d7a8) instead of performing SVD every time.
+If the existing models do not meet your needs, apply PiSSA initialization to a pre-trained model and store the decomposed model locally:
+```bash
+python preprocess.py \
+    --base_model_name_or_path meta-llama/Llama-2-7b-hf \
+    --init_lora_weights pissa \
+    --output_dir pissa-llama-2-7b-r32-alpha-32 \
+    --lora_r 32 \
+    --lora_alpha 32 \
+    --lora_dropout 0 \
+    --bits bf16
+```
+
+### Convert PiSSA to LoRA
+The main advantage of PiSSA is concentrated during the training phase. For a trained PiSSA adapter, we recommend converting it equivalently to the LoRA adapter for using and sharing.
+```python
+# The fine-tuned matrices $A$ and $B$ in PiSSA adapter is saved and should be combined with the residual model.
+peft_model.save_pretrained(output_dir) 
+# Given the matrices $A_0$ and $B_0$, initialized by PiSSA and untrained, and the trained matrices $A$ and $B$, 
+# we can convert these to LoRA by setting $\Delta W = A \times B - A_0 \times B_0 = [A \mid A_0] \times [B \mid -B_0]^T = A'B'$.
+peft_model.save_pretrained(output_dir, path_initial_model_for_weight_conversion="pissa_init")
+
+```
+This conversion enables the loading of LoRA on top of a standard base model:
+
+```python
+import torch
+from peft import PeftModel
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained(
+    "meta-llama/Llama-2-7b-hf", dtype=torch.bfloat16, device_map="auto"
+)
+# No SVD is performed during this step, and the base model remains unaltered.
+peft_model = PeftModel.from_pretrained(model, "pissa-llama-2-7b-lora")
+```
+Utilizing the converted LoRA does not require modifying the parameters of the base model. When multiple converted LoRAs are needed simultaneously, each adapter operates independently without interference, allowing for the adapters to be freely deleted or added.
+
+Note that this conversion is not supported if `rslora` is used in combination with `rank_pattern` or `alpha_pattern`.
+
+### Fine-tune in 4-bit or 8-bit
+If quantization fine-tuning is desired, it is necessary to first decompose the original model at full precision and then reload the residual model in either 4-bit or 8-bit configurations.
+```shell
+python pissa_finetuning.py \
+    --residual_model_name_or_path fxmeng/pissa-llama-2-7b-r16-alpha-16 \
+    --output_dir output/pissa-llama-2-7b-r16-alpha-16-metamath-10k \
+    --bits nf4 \
+    --data_path meta-math/MetaMathQA \
+    --dataset_split train[:100000] \
+    --dataset_field query response \
+    --bf16 True \
+    --num_train_epochs 1 \
+    --per_device_train_batch_size 32 \
+    --gradient_accumulation_steps 4 \
+    --save_strategy "steps" \
+    --save_steps 1000 \
+    --save_total_limit 1 \
+    --logging_steps 1 \
+    --learning_rate 2e-5 \
+    --weight_decay 0. \
+    --warmup_steps 0.03 \
+    --tf32 True \
+    --report_to none \
+    --convert_pissa_to_lora
+```
+
+This approach ensures the preservation of high-frequency, out-of-distribution parameters in the low-rank PiSSA modules, resulting in reduced quantization errors during the quantization of the residual model.
+
+## Citation
+```
+@article{meng2024pissa,
+  title={PiSSA: Principal Singular Values and Singular Vectors Adaptation of Large Language Models},
+  author={Meng, Fanxu and Wang, Zhaohui and Zhang, Muhan},
+  journal={arXiv preprint arXiv:2404.02948},
+  year={2024}
+}
+```
diff --git a/examples/pissa_finetuning/pissa_finetuning.py b/examples/pissa_finetuning/pissa_finetuning.py
new file mode 100644
index 0000000..259efb4
--- /dev/null
+++ b/examples/pissa_finetuning/pissa_finetuning.py
@@ -0,0 +1,150 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import os
+from dataclasses import dataclass, field
+from typing import Optional
+
+import torch
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, HfArgumentParser
+from trl import SFTConfig, SFTTrainer
+
+from peft import LoraConfig, PeftModel, get_peft_model, prepare_model_for_kbit_training
+
+
+@dataclass
+class ScriptArguments(SFTConfig):
+    # model configs
+    base_model_name_or_path: Optional[str] = field(
+        default=None, metadata={"help": "The name or path of the fp32/16 base model."}
+    )
+    residual_model_name_or_path: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "The name or path of the fp32/16 residual model. (`['fxmeng/pissa-llama-2-7b-r16-alpha-16']`)"
+        },
+    )
+    bits: str = field(default="fp32", metadata={"help": "(`['fp4', 'nf4', 'int8', 'bf16', 'fp16', fp32]`)"})
+    init_lora_weights: str = field(default="pissa", metadata={"help": "(`['gaussian', 'pissa', 'pissa_niter_4']`)"})
+    lora_r: int = field(default=16)
+    lora_alpha: int = field(default=16)
+    lora_dropout: float = field(default=0)
+    convert_pissa_to_lora: bool = field(default=False)
+    merge_and_save: bool = field(default=False)
+    # dataset configs
+    data_path: str = field(default="imdb", metadata={"help": "Path to the training data."})
+    dataset_split: str = field(default="train[:1%]", metadata={"help": "(`['train', 'test', 'eval']`):"})
+    dataset_field: list[str] = field(default=None, metadata={"help": "Fields of dataset input and output."})
+
+
+parser = HfArgumentParser(ScriptArguments)
+script_args = parser.parse_args_into_dataclasses()[0]
+print(script_args)
+
+print(f"Load pre-processed residual model in {script_args.bits} bits.")
+if script_args.bits in ["nf4", "fp4", "int8"]:
+    quantization_config = BitsAndBytesConfig(
+        load_in_4bit=(script_args.bits == "nf4" or script_args.bits == "fp4"),
+        load_in_8bit=script_args.bits == "int8",
+        bnb_4bit_quant_type=script_args.bits,
+        bnb_4bit_use_double_quant=True,
+        bnb_4bit_compute_dtype=torch.bfloat16,
+    )
+    res_model = AutoModelForCausalLM.from_pretrained(
+        script_args.residual_model_name_or_path, quantization_config=quantization_config, low_cpu_mem_usage=True
+    )
+    res_model = prepare_model_for_kbit_training(res_model)
+    print("Wrapping the residual model with PiSSA.")
+    peft_model = PeftModel.from_pretrained(
+        res_model, script_args.residual_model_name_or_path, subfolder="pissa_init", is_trainable=True
+    )
+    tokenizer = AutoTokenizer.from_pretrained(script_args.residual_model_name_or_path)
+
+elif script_args.residual_model_name_or_path is not None:
+    res_model = AutoModelForCausalLM.from_pretrained(
+        script_args.residual_model_name_or_path,
+        dtype=(
+            torch.float16
+            if script_args.bits == "fp16"
+            else (torch.bfloat16 if script_args.bits == "bf16" else torch.float32)
+        ),
+        device_map="auto",
+    )
+    print("Wrapping the residual model with PiSSA.")
+    peft_model = PeftModel.from_pretrained(
+        res_model, script_args.residual_model_name_or_path, subfolder="pissa_init", is_trainable=True
+    )
+    tokenizer = AutoTokenizer.from_pretrained(script_args.residual_model_name_or_path)
+
+elif script_args.base_model_name_or_path is not None:
+    print(
+        f"No available pre-processed model, manually initialize a PiSSA using {script_args.base_model_name_or_path}."
+    )
+    model = AutoModelForCausalLM.from_pretrained(
+        script_args.base_model_name_or_path,
+        dtype=(
+            torch.float16
+            if script_args.bits == "fp16"
+            else (torch.bfloat16 if script_args.bits == "bf16" else torch.float32)
+        ),
+        device_map="auto",
+    )
+    tokenizer = AutoTokenizer.from_pretrained(script_args.base_model_name_or_path)
+    tokenizer.pad_token_id = tokenizer.eos_token_id
+    lora_config = LoraConfig(
+        r=script_args.lora_r,
+        lora_alpha=script_args.lora_alpha,
+        init_lora_weights=script_args.init_lora_weights,
+        lora_dropout=script_args.lora_dropout,
+        target_modules=["q_proj", "o_proj", "k_proj", "v_proj", "gate_proj", "up_proj", "down_proj"],
+        bias="none",
+        task_type="CAUSAL_LM",
+    )
+    peft_model = get_peft_model(model, lora_config)
+
+print(peft_model)
+peft_model.print_trainable_parameters()
+
+print(f"Training PiSSA with trl on the {script_args.data_path}[{script_args.dataset_split}] dataset.")
+dataset = load_dataset(script_args.data_path, split=script_args.dataset_split)
+dataset = dataset.map(
+    lambda example: {
+        "text": f"### USER: {example[script_args.dataset_field[0]]}\n### ASSISTANT: {example[script_args.dataset_field[1]]}"
+    }
+)
+
+trainer = SFTTrainer(
+    model=peft_model,
+    args=script_args,
+    train_dataset=dataset,
+    processing_class=tokenizer,
+)
+trainer.train()
+trainer.save_state()
+############################## Upon training completion, convert and save PiSSA in LoRA format ##############################
+if script_args.convert_pissa_to_lora:
+    peft_model.save_pretrained(
+        os.path.join(script_args.output_dir, "pissa_lora"),
+        path_initial_model_for_weight_conversion=os.path.join(script_args.residual_model_name_or_path, "pissa_init"),
+    )
+else:
+    peft_model.save_pretrained(
+        os.path.join(script_args.output_dir, "pissa_ft"),
+    )
+
+if script_args.merge_and_save:
+    model = peft_model.merge_and_unload()
+    model.save_pretrained(os.path.join(script_args.output_dir, "pissa_merged"))
+    tokenizer.save_pretrained(os.path.join(script_args.output_dir, "pissa_merged"))
diff --git a/examples/pissa_finetuning/preprocess.py b/examples/pissa_finetuning/preprocess.py
new file mode 100644
index 0000000..9cac153
--- /dev/null
+++ b/examples/pissa_finetuning/preprocess.py
@@ -0,0 +1,69 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import argparse
+import os
+
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from peft import LoraConfig, get_peft_model
+
+
+parser = argparse.ArgumentParser(description="Merge Adapter to Base Model")
+parser.add_argument(
+    "--base_model_name_or_path",
+    help="The name or path of the fp32/16 base model.",
+)
+parser.add_argument("--output_dir", type=str, help="The directory to save the PiSSA model.")
+parser.add_argument("--bits", type=str, default="bf16", choices=["bf16", "fp16", "fp32"])
+parser.add_argument(
+    "--init_lora_weights", type=str, default="pissa", help="(`['pissa', 'pissa_niter_[number of iters]']`)"
+)
+parser.add_argument("--lora_r", type=int, default=128)
+parser.add_argument("--lora_alpha", type=int, default=128)
+parser.add_argument("--lora_dropout", type=int, default=0)
+script_args = parser.parse_args()
+print(script_args)
+
+model = AutoModelForCausalLM.from_pretrained(
+    script_args.base_model_name_or_path,
+    dtype=(
+        torch.float16
+        if script_args.bits == "fp16"
+        else (torch.bfloat16 if script_args.bits == "bf16" else torch.float32)
+    ),
+    device_map="auto",
+)
+tokenizer = AutoTokenizer.from_pretrained(script_args.base_model_name_or_path)
+tokenizer.pad_token_id = tokenizer.eos_token_id
+lora_config = LoraConfig(
+    r=script_args.lora_r,
+    lora_alpha=script_args.lora_alpha,
+    init_lora_weights=script_args.init_lora_weights,
+    lora_dropout=script_args.lora_dropout,
+    target_modules=["q_proj", "o_proj", "k_proj", "v_proj", "gate_proj", "up_proj", "down_proj"],
+    bias="none",
+    task_type="CAUSAL_LM",
+)
+peft_model = get_peft_model(model, lora_config)
+
+# Save PiSSA modules:
+peft_model.peft_config["default"].init_lora_weights = True
+peft_model.save_pretrained(os.path.join(script_args.output_dir, "pissa_init"))
+# Save residual model:
+peft_model = peft_model.unload()
+peft_model.save_pretrained(script_args.output_dir)
+# Save the tokenizer:
+tokenizer.save_pretrained(script_args.output_dir)
diff --git a/examples/poly/peft_poly_seq2seq_with_generate.ipynb b/examples/poly/peft_poly_seq2seq_with_generate.ipynb
new file mode 100644
index 0000000..d6768d0
--- /dev/null
+++ b/examples/poly/peft_poly_seq2seq_with_generate.ipynb
@@ -0,0 +1,14776 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "2edec24d8563b583",
+   "metadata": {
+    "collapsed": false,
+    "execution": {
+     "shell.execute_reply.end": "2023-12-22T03:34:15.998083Z",
+     "shell.execute_reply.started": "2023-12-22T03:34:15.994854Z",
+     "to_execute": "2023-12-22T03:34:15.875Z"
+    },
+    "libroFormatter": "formatter-string"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "env: CUDA_VISIBLE_DEVICES=0  # force using CUDA GPU device 0\n",
+      "env: ZE_AFFINITY_MASK=0  # force using Intel XPU device 0\n",
+      "env: TOKENIZERS_PARALLELISM=false\n"
+     ]
+    }
+   ],
+   "source": [
+    "%env CUDA_VISIBLE_DEVICES=0  # force using CUDA GPU device 0\n",
+    "%env ZE_AFFINITY_MASK=0  # force using Intel XPU device 0\n",
+    "%env TOKENIZERS_PARALLELISM=false"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "95b4cfd741795038",
+   "metadata": {
+    "id": "95b4cfd741795038",
+    "libroFormatter": "formatter-string"
+   },
+   "source": [
+    "## Initialize PolyModel"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1a5c7a99-5208-4d22-ac15-bacebe1b52f9",
+   "metadata": {
+    "execution": {
+     "shell.execute_reply.end": "2023-12-22T03:34:29.137789Z",
+     "shell.execute_reply.started": "2023-12-22T03:34:18.146604Z",
+     "to_execute": "2023-12-22T03:34:18.025Z"
+    },
+    "id": "1a5c7a99-5208-4d22-ac15-bacebe1b52f9",
+    "libroFormatter": "formatter-string"
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from transformers import (\n",
+    "    AutoModelForSeq2SeqLM,\n",
+    "    AutoTokenizer,\n",
+    "    default_data_collator,\n",
+    "    Seq2SeqTrainingArguments,\n",
+    "    Seq2SeqTrainer,\n",
+    ")\n",
+    "from datasets import load_dataset, concatenate_datasets\n",
+    "from peft import PolyConfig, get_peft_model, TaskType, PeftModel, PeftConfig\n",
+    "\n",
+    "model_name_or_path = \"google/flan-t5-xl\"\n",
+    "\n",
+    "r = 8  # rank of lora in poly\n",
+    "n_tasks = 4  # number of tasks\n",
+    "n_skills = 2  # number of skills (loras)\n",
+    "n_splits = 4  # number of heads\n",
+    "\n",
+    "batch_size = 8\n",
+    "lr = 5e-5\n",
+    "num_epochs = 8"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "89a1d2c6-0d35-4254-b9fb-035a426d86ae",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 241,
+     "referenced_widgets": [
+      "dc5d4672fcd149239cfe1a837094ce53",
+      "eded01d7629e4a4faad592e8e20a3ca3",
+      "5d1e94d40f514faaa5819096f167d29c",
+      "f98f73664a974ae7804e494425fbe20d",
+      "1c0bd751a3294b8ea0cf828866169121",
+      "6c3ed2de06fe40c09315ff72d43d5c8c",
+      "2e3d6b5d46db4295829002fc311a9c74",
+      "5ff0d4da7342457089f0961b189307f4",
+      "a08c4e6628bd440fb31eebbb2693f327",
+      "379357ab63f5479fad469c181b054bb0",
+      "f860e1c3467348f0802b733fbef45c15",
+      "567e165c27a4494bbf4810ecb7de40cf",
+      "015fd47fdbdf47c5a619eff218052b45",
+      "ec33a4325b6f4dcfb8a9fa4c80a5c704",
+      "3241189c875a471ab0831f0f4411d2d3",
+      "268fe971a0bc45c6b7c37586e0f9da49",
+      "8851d4a04cb9410c849b6606a812c52b",
+      "3b5ab7d9f27944d8ae1b172231c9c6fc",
+      "85f57b44dbe442a4952c65e1db4c1176",
+      "3f173a7293cd4ff8a54da8c8174cfb43",
+      "40ac1e38c100435fbe95b669c69a31c5",
+      "a634013728be457ba590aa333908addd",
+      "376242d1cfd74c88aaeaa76a6813d855",
+      "a17443b5713d4b60aeb85da3adce6cf2",
+      "91f821fb888046b6a2f8ade2cc58db2d",
+      "4bea407148e846babefdc88eff8a9131",
+      "26a75e6f6628472b91f3214505afa935",
+      "c7c0b0fd45dc448eb9456f58e36fb3bb",
+      "a14f26db56d04b8b840a9ce366e913e6",
+      "09fa4b156f174dbcacdf976f2b39a280",
+      "c9ca89486def4220967599e5b159b980",
+      "558b98eb76654045a5eae24170a5dc9c",
+      "7edf2ac4dd264843a7838a0130668757",
+      "c3aa97f46a60409091dc4d33a946c6d3",
+      "e6315c5d217b4922b461c9ac22528e62",
+      "04c34c92e4374c50bd0636c72953a8ba",
+      "32a6ac79c27e47c1a4b32098bfe25807",
+      "bb99715a25d94422b0048de94f2fe563",
+      "637bbd213f3345178742523d055993e6",
+      "6113f1920c5743aa8f2c6cc9739029e1",
+      "24bbd7b810b34c4c9baeed628961c64b",
+      "1c63e99470824a3aa0f98a94862733d5",
+      "98c677014f1a48ac804cec0714a22172",
+      "a4097270b9b947b0ad0b3b5d217eecc0",
+      "8eaed8cbbf1943328dc80fc43bd5b97c",
+      "6b1972a032af41de9bf99a6582c53f39",
+      "b4eb16a8153048ea9aa5c9d43b44820c",
+      "9bd66a63faf9416d9e774a5d8221c5f5",
+      "40b859a2fd68457db691bb5e7eb23591",
+      "533151b377d64d3484772b3173dab306",
+      "2cd302d306e3440dac4b70fc46741544",
+      "41b36d52e98249b1b506d369d2d8e994",
+      "ac83130fdd374b7c8f41e0f8f011ecae",
+      "66b0e949143e46faab77458a49a9fe1a",
+      "abd34fa3e94c49869ea7cf514dba6d1d",
+      "8ffe87ece7e54294a160540fbbbe124b",
+      "9c3c68da285449958a3d8745bbc50305",
+      "ae517eef5a004b16b4ae34cdf2aa851e",
+      "08a572aefb63488d8125ae3b881c0729",
+      "f2131e286f704514a61b5af0785dde8b",
+      "43d9b3de4a6949f787d9733d1ae4d18e",
+      "06716294f2244cc48f78af918cc063f2",
+      "e69b0005e91a478297d17e4089cda650",
+      "f92f9afc2c694f0cbcdf4ebcca98221e",
+      "7ffe5fd0a64c40cebc784eca83154069",
+      "d622b006621e4110a157fb4cb43c9762",
+      "874e05e0b861466ba57a08d8f5a5b7ee",
+      "8ebe69a07de64c3cb6dfd6433e222186",
+      "2aceeebfd0dc42fcbbc1b3a7e1f54c56",
+      "93c6f7c0d1ba49a295ae60a73bf509a9",
+      "6c3ebb812cfd493bb954a6b1d7455c72",
+      "a27edbdb4c824979b1b56e8fbd867595",
+      "5bdf79c178074ebf8757936190bc37b3",
+      "3c076081fd7942e184f8d4f171a17e1c",
+      "0a03bee83ddf4ad297bfdc9b4de3b075",
+      "6f59ae0a20cf4cc5859925e3259291a7",
+      "49ac9897f49843fd8c5fed4bcdfdbb56"
+     ]
+    },
+    "execution": {
+     "shell.execute_reply.end": "2023-12-22T03:35:33.229420Z",
+     "shell.execute_reply.started": "2023-12-22T03:34:37.266443Z",
+     "to_execute": "2023-12-22T03:34:37.242Z"
+    },
+    "id": "89a1d2c6-0d35-4254-b9fb-035a426d86ae",
+    "libroFormatter": "formatter-string",
+    "outputId": "fc90c2cc-9cab-40ed-bf4a-d76bec85b72f"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading checkpoint shards: 100%|██████████| 2/2 [00:00<00:00, 22.43it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, trust_remote_code=True)\n",
+    "base_model = AutoModelForSeq2SeqLM.from_pretrained(model_name_or_path, trust_remote_code=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "29d701a4-7a4f-4eae-84bd-9e3a02b7ffca",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "execution": {
+     "shell.execute_reply.end": "2023-12-22T03:35:33.396336Z",
+     "shell.execute_reply.started": "2023-12-22T03:35:33.250286Z",
+     "to_execute": "2023-12-22T03:35:33.272Z"
+    },
+    "id": "29d701a4-7a4f-4eae-84bd-9e3a02b7ffca",
+    "libroFormatter": "formatter-string",
+    "outputId": "63898f68-926e-40c4-ca13-ffd1df32fcce"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "trainable params: 9,441,792 || all params: 2,859,198,976 || trainable%: 0.3302\n"
+     ]
+    }
+   ],
+   "source": [
+    "peft_config = PolyConfig(\n",
+    "    task_type=TaskType.SEQ_2_SEQ_LM,\n",
+    "    poly_type=\"poly\",\n",
+    "    r=r,\n",
+    "    n_tasks=n_tasks,\n",
+    "    n_skills=n_skills,\n",
+    "    n_splits=n_splits,\n",
+    ")\n",
+    "\n",
+    "model = get_peft_model(base_model, peft_config)\n",
+    "model.print_trainable_parameters()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aa695c2d-cf9c-432c-ab74-7e89f816ba13",
+   "metadata": {
+    "id": "aa695c2d-cf9c-432c-ab74-7e89f816ba13",
+    "libroFormatter": "formatter-string"
+   },
+   "source": [
+    "## Prepare datasets\n",
+    "\n",
+    "For this example, we selected four `SuperGLUE` benchmark datasets: `boolq`, `multirc`, `rte`, and `wic`, each with a training set of 1,000 examples and an evaluation set of 100 examples."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "d0b36e7eff50657c",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 1000,
+     "referenced_widgets": [
+      "d6250bff76d7454a8216572ab28e4a72",
+      "384d10ea2a354f24bae33c3a1d564b82",
+      "a2deecc9aa3d42d381d78199f6e29d1c",
+      "17fc618034bf4aadaef811b0e7c80eed",
+      "6757bc0834fc4e69b7b588ae6de14ec9",
+      "b9ec517b4b084d548525ac41381ef69e",
+      "6f3679fe9b60498da864bda9ba6d899e",
+      "ef16f8bac38044c3b6a092caf5da320b",
+      "19e50ecdda3b493184611d97724ac1fc",
+      "c2ed87d5599a467bba084cddb9e40713",
+      "2cfc492ab0ed454dbf2c4da18cd24d02",
+      "91e6e0685a4c4d26b6154d3ed18418eb",
+      "ba1864322c0d49fd915e9dcc2469ef6f",
+      "67b108def57749edb2564b3e507959a3",
+      "c04a17f40c974f378c60858473f49fd0",
+      "4189c6e9c59e44d3a776b49c38cc8f06",
+      "7550307b4e894844b8d032df7eea6d82",
+      "bcf20733fb504a71be5cf0455928b587",
+      "cc6c1b2d4fcb4ffea016a139738e1ead",
+      "6bd3da08b5074e81bffbfe6d92b8ce8b",
+      "03d340641a414362b0356e8178148d9a",
+      "61fec3b2596c4803924ed1fb087d52d1",
+      "4fc54c5844aa44f2b335824c3544a334",
+      "736443c7e26642379ca66ed3e5dd34cb",
+      "3c3d747638004a08a898cff7c6f59acc",
+      "1cb2dcb242334f46b7f195929dd1f341",
+      "f577bbac4eab439b9ccea0a49eb99d86",
+      "8822d3a8fa794fc0addb5885a862d205",
+      "10436da727ec45c8a5e8b783696636d5",
+      "0622e1de75f34da590f241232613cf5e",
+      "5b868029728541dc9da977312da38cf0",
+      "33add0384c36462ab44fe3e0b03f63c7",
+      "e227fb95b00b4af8b82286c75db84611",
+      "54d4afa42e9346578c0a1a193ee8caea",
+      "2918f1fd9e104c09967d698e11728785",
+      "170853712c0c4a8d997696f74090d7c6",
+      "fcdb61acbf0d470f881ba8f283360e0f",
+      "4803c9aece3346488295338254217aff",
+      "d725549ca34a4d54ae684e7e4741be29",
+      "d94392afd01246ff942af838a995379e",
+      "7eaee1cd25d0442092846922cdd6c413",
+      "483b9c219aa94ea1952e3534a02395aa",
+      "10d7a41588744be1b29678b4a9dfdd27",
+      "c4fce7e5a2b44835ab8723e0022d1e50",
+      "ba3a7258734b4edb86b8eef074d65222",
+      "4b3dc87d00ed42b0956d0bfa39bd466f",
+      "2c5eaf38e66d492d8661852cacc4e527",
+      "b7f169f931074d1283cbfe912f11ba98",
+      "e86771ea303a4b1b86ecf5128f3ea421",
+      "b3a18689eefa4660997034094df0df04",
+      "91cb4404dd794d22b2bbaf31eee207b5",
+      "d8594695c03e4fb7965dcbe04074d4eb",
+      "f972a2e10dde405c8aec8f7cd1be4317",
+      "6c9a5a39cb4841ba8a0b93283be0cac2",
+      "2deb046362ed4570a3f550f4f288529e",
+      "2cdddd0398e045a6a13124bf6fd85506",
+      "a1f5618e59d148409d6ccf4bfffca2fa",
+      "c870763add1745d9acfc2762f468c984",
+      "be70aecc5b294c4c93b0dcc09d6d1cb3",
+      "37b18b2ae9504b6c91066798a19a1319",
+      "b17eef10573f44689ce6add6231eaa19",
+      "3e8f08e000f248b59331d2430bbc8e3c",
+      "d8886d5af17f4468a26554831c9c05f1",
+      "b1cad4191755493893bbb46dcf27e03b",
+      "589120da6f464686bbeff0d44643d17d",
+      "ea89ea173ff3482c8a9c91dfb15946b2",
+      "b38693117df44071b7baaf123215ea60",
+      "9d716c9e43e04a6c9496620633ca28be",
+      "4de322f2413f44bcb03d41dcc8ff1963",
+      "3087335b98964b9eb4da474487ca4864",
+      "c010fad90578489cbfeb0764e3a11286",
+      "627f32f04b544b4db834b79645f36733",
+      "7d39222af2474a68b0db99f407ccf380",
+      "775687d3962242d6aff3feb0627754a9",
+      "92bb9917ab194a1eb1dc6fc5c4c4195d",
+      "43717a0ae4c043f9947d8fd844d71997",
+      "3f0008931054433c838a6633ca1347e6",
+      "da0dfe11648d4ae8a70852ce1fac87b0",
+      "29ad37e81b7f44a9aafa982b52f05a7a",
+      "bb468a6fe3f04692a211d5519aec455a",
+      "b1ad08dbe61b4064985ecdaa119870d8",
+      "d91093e80b814a018edaabe49f529ef5",
+      "1e3f013edc6341a0837af33ff4866d0b",
+      "1ed6f4595ec540729d776a81db96c403",
+      "cd7371ff8504454292559c18adb76645",
+      "d4994c6d7fa240d0ac6bb31f5c835192",
+      "ee1a9269b6c843e28cc49f3b5f17da96",
+      "a12a6638b2a54e88a020be42c139646e",
+      "2f2dc993705b447aa771cf0cc13c3b1d",
+      "69dffb139cab46b1b93bef960f702655",
+      "e7dc30a09a64401393e43618b51059de",
+      "75c397c506a04d0d9ca62e8d7f990813",
+      "eb7e509acfea4e1bb2f59b2fde11603d",
+      "b75a3d92aaa64a3098c6e1aabbc50856",
+      "3b056671c3fd41aeb4d6da821d562b95",
+      "9ac87f9e5b7847aaa90e3208ad405c23",
+      "cb21cadacb294854b304af8df2157299",
+      "30b3667258174beaa01322ffa055759b",
+      "48cb432d95dc49deae6077fb5c76bec3",
+      "763eec2b33234fd5ac192f25489b2844",
+      "f7fde1c95e3946659c6208fc52c254e9",
+      "6e1cdd75ae2246278c80f8e5d4e340b7",
+      "6af159109303490eab7192815fce0d6b",
+      "315575253cb9433d81f7d26770907f29",
+      "daf61ecd65bd41d9829e8a1872b82f33",
+      "54823295494d441fb9f26a70fb2c3973",
+      "df13aabfde0140d68db8b5a69759091c",
+      "cadbbc94bfd24daa933bb7d188dcdf92",
+      "f271a7dc607b4c05b02f6c5621203bd6",
+      "4e60ffab53dd4aba9e094098ed5297e6",
+      "a91dd2c07c51483eb326d010a82e2920",
+      "4188c097387a408dae680f67bd97752b",
+      "2a6cf3f2b4c349a9adc26351c2f0b222",
+      "8efe1cb67f30446a8fdaaf96782e843d",
+      "bdecbe50f693451b87bd331fd9e684ba",
+      "ff00f4c2c63a467098b119ae2259f529",
+      "d6754db1364144e69e3ab320aa1faeb9",
+      "9f1feddbe0d449a0b93fc5b1027e4319",
+      "1507ea5f89534b10856b99488ed5da65",
+      "f69205c589cf42829eea248f378a1436",
+      "85843fd6df264d25a4642cbeee260459",
+      "c2a415c28fe0418bb6032d4b91efbb07",
+      "b02796bf6e5547cf9418d109ad772537",
+      "de7a527901014a6b8abf6b714bd09535",
+      "143eaab6e65f4c8eb7a4314cadf323ba",
+      "e0603f00ceb2468692a36abd7bafaba8",
+      "8abf122ed835496aa09945ba8edd4688",
+      "663b9bd2f1af4df4b757624f53c2f2b8",
+      "c352adea84b043db8d43eb1c36d4bd4f",
+      "8fda102684834d21b4efbb472823ced9",
+      "ee7eccaca57b4460becfe0d5d5afb3f9",
+      "554a1ef44aea4ff484f0944878bb58a2",
+      "8ae15293ec5e4296a625087e7d965249",
+      "db067e50373840b19d6925deb950a20a",
+      "ab409caa3be24c18becaf9146b1ae69c",
+      "63236709413940f59d2622f2927c8d55",
+      "3e6d67d246e54fa497f4398e3aeddb00",
+      "118967bdd4a348858cc7572d36c1b736",
+      "8cc3c0558720400e9ed89170883f6370",
+      "59ee159eec154095a368efceb9d1e042",
+      "f78c80dd733d48a687d8a47bfc792ea4",
+      "9da9d7eb9a97495194a3ac4a2786e1de",
+      "3f1d345037604e01911ef344f3b51742",
+      "eeff19b29a6a4c6d9ae34e365c78c310",
+      "a098c442cc8149a5aa562c86fc64528e",
+      "badae7117ab644ffa80d099c17397329",
+      "13ccc23d506248d5b66ffe7732ead149",
+      "16938b11881741af8e6633094a4402dc",
+      "8d796692add94119a4e9fdc6530a6878",
+      "9202902fd37446cda1678c0d83e0c641",
+      "2cd168e5e3c4481ba151aa8a655e7ce8",
+      "f773b949a9cf46ca9fd56476398a3191",
+      "c6a00e1b00684bb7930fb27d6499932e",
+      "4395227decf642f7b8fbc6616f9ec826",
+      "205a7844670249bf83d468fe3af0e139",
+      "28a78fb894a4413e960c1e40d7df8173",
+      "46bd38ac919e4e66a72226c1f0da67d6",
+      "9557a05279544cd8a5f2ba4d3429f576",
+      "2e0e7f437b5d4e4086b38ee6da51dc4f",
+      "73a0ea365433404babb83a2d1caa9c66",
+      "855a155046904aaa9b91b01dd6a86088",
+      "d49e405525ec467bb7a69a9aaedf82d9",
+      "b8ccdebb7b11490e8222ff79ecfc9a33",
+      "9edc1d5792644f79bc04d853b13dac46",
+      "1b78ff7e32254777abe2c802b6879b9c",
+      "32168837680e41eaad4e5e4cdf09877d",
+      "319bf5c6332f41958974d9c3af87a382",
+      "c1e065fa36344f509e7863c3ec0428b8",
+      "5b9510c694a24afbb1c8318fea1a1bc5",
+      "f12d118a6b3f46b580fbe2018f4cf5e9",
+      "726e82f2b6c94e8eb5620c18872aabb6",
+      "12bb708857e84e5b893ca3e9ff176082",
+      "53acddb088564a73aef61618797bfe85",
+      "fb208f3792174ac2bdfb077450b2218f",
+      "0fa8ddd8da924c089221611c98e7da6e",
+      "b4a5fdee693d455686507306da804b17",
+      "045c5ac6981440c996ac7dda054fc112",
+      "f6a6f03ea7f140189a277742ff7082f8",
+      "ecff5b6dfb784c96b69d1a39b7acb171",
+      "43a32f261eaf42af978a6bf98502b1fc",
+      "8b7bb3fb502f4c3185709d6c40638d70",
+      "bf1d0b17974049c6ac5653ac18f1169c",
+      "32672cb3395045bcb9c2d370032356cc",
+      "4728eddf9fcc49d68d71a30379f08335",
+      "8676e2232dc242c39d4f19b0eea90dff",
+      "167e67c018e441d8baab4127b25773c6",
+      "88405a75b92743e589f424ee8c4d4d79",
+      "b5e3536d816c45488bb83336eaa5d53f",
+      "b9bed2c861df4c019ab4fff46b11a1a3",
+      "35bf380a7c6243859a459560288ffe49",
+      "b65af12dbf9143778412adb7b4c0bfdd",
+      "cb2433a0096845468b26c4bbde625ed8",
+      "8d4df1cf62d2427b8e850b031164ff97",
+      "0fd8ca256b8b49e1906a2a8e21156164",
+      "9801a82eda354815b6b3abbc8d1e0140",
+      "b10768b6bc654da8b822b4878889639b",
+      "c56ea889f51848e4aed83bcc46c83395",
+      "c75508086f6f4406a0aa9ce5a391e0ee",
+      "d92dbe59ace74f598efc7fbedb4c5ee6",
+      "675c937cf0ef4bf582f4bf90df6fa28e",
+      "e1cf760846bd4ba988c29665a6593220",
+      "768735ea9663429ba9f24efd86682f71",
+      "4d2a10e9307a47f4a1cbf512380c65bc",
+      "e8738d4181b04545a0418c1dd5b6b1b5",
+      "2aab7297963040f1900f0bc1f24e7b2a",
+      "8182a23b5be640cc8a48c09a4ed9585c",
+      "c3e198ae77684d61bf5fc30a35d8fc11",
+      "aaa71d52156549a4b8d7aad390497ac3",
+      "6387cbc474144e59aac5e3b42e714887",
+      "efc4f9ade28a4bb2a67c0ae4ceecbf28",
+      "7c105cfe1f344bf7896c7ddc0fcdc322",
+      "c1f71dcbe98f4ee9847af6b800979e06",
+      "e12dbfa20e9d40448366c9528c1a2c02",
+      "b3d7aad60442432e96c8c8bd3ead8427",
+      "0d40464e81fe4c06ac3400204116f243",
+      "69a0d832b77e47b8a2adcf47efe3f7ab",
+      "947f13ea22654b4ca6fca7ebed29d64e",
+      "45becb2c72714dfcb721b3a20a92d28f",
+      "4ddb5f1d8260448981c67308bcedecbf",
+      "d43db93804c24908bb6d75f26b640199",
+      "71d656fe70004c6db5d23d86bc6b108b",
+      "9f2ecadf1f3f4e399aad1882f2fe9b00",
+      "8826a0177e334508932a43563d2ae97d",
+      "f9ecbb00f95548d5b0c5cad345b1e38a",
+      "ac78d9726bc541df9907425442d3a51a",
+      "854937001e534695b08ee25f6e443962",
+      "06b21316e1ef41c9b7c9d943a9ff91ec",
+      "d38618d4c0e64b7baa61c0eca47427e5",
+      "86e235a532f347c781d6654c3ac25ba3",
+      "1727de01c47144b2958babfb91e887cb",
+      "5ac310c605f64948ad744bc1f196441d",
+      "32c1cc0d5327462d9175c74b91d67c4d",
+      "910d8a34abaa4f92a899dd4f5ab03d74",
+      "fbd92ad5a793482aac5570387e917188",
+      "ac81634b0e0946d690fb7d8ad7aed911",
+      "01097fb41b9c4cbf91300e049d9f3617",
+      "abeae554ecff4bb0ad8c38fa2829f706",
+      "a2d84cfc801f4657bade62d42be7046f",
+      "06a2114630234393bc0f07b3a64455f8",
+      "c6f31bcf48de4d9fbc7f2a2d9984b247",
+      "d5eace6b280e446ead2d1517801e4612",
+      "e29da03f6e474f1ca97ecfa6cd09658c",
+      "35bfe48a1b744262a8ea68bf5b5d495d",
+      "eed4b0b927824444aa8d875281cca1c4",
+      "e77316215dbe41daa8e89d8b2cc0f032",
+      "11c60d67f2204518b007ef47c801fbff",
+      "da21830428b54f76aa31b03efce202b9",
+      "a90285006dda4eb8a3e77964294a76ea",
+      "8164a08b9b3f49288963539305eadabe",
+      "591e6dc92b5c44418260cf659c5807cf",
+      "2bd3c665eb784f149dc21853103e8ff0",
+      "1ff4bcdb97294287ae8f3e9f2dc6bafa",
+      "bc265b1f822348469e3c8df0ea608abb",
+      "3635aa8a2cee484b945ddf7379ff4102",
+      "94ce06b3df27425eb8ae1a0aade4244d",
+      "e8ab0bcb4d7f4a298b2b3555d866a11f",
+      "5570fad8913d4bb495681b5e1dbe3950",
+      "47735f6c830149db965660d6b2f200d7",
+      "61d980530bf0408c8e2ed9a7997ba615",
+      "8a9f0a924d53496c8a8f228738ec140d",
+      "60ab33e3e0d84395a1269604f0fae91f",
+      "64d829532bb94214b805c2de4cf529cc",
+      "438c02b8134e45d5b2760b2e1f72f004",
+      "0f09296d37ee44b89871fa22cdd0127f",
+      "0fd475cb9e064d10a8ed031957cf2044",
+      "d1d2687d51a4442d8555ed4071837da4",
+      "0d80cc1f4fcc49d59e3a80862678fd86",
+      "9e556858d4a44b5bbc3e3af87d138a55",
+      "d86eb0ba47884ab081128a8761e9654b",
+      "620e2fa48504435a85d95c2d4b264b6e",
+      "af9af54477cc4972bf0f0a99c1344974",
+      "0b5d06cb83334b53a91c929f8e308543",
+      "8b9f3c47205d474b97efc6e9c6fb5f68",
+      "b63d8ddcad7745f3b4d7e683d23f393a",
+      "b83993ef787047cb9a31652fdd7f9ee7",
+      "f4ee33b4a2d145bab3c5c2e14c73a3f8",
+      "bebb055c0ac14d59a8b617399d60e602",
+      "888e04dcb56f4c43954d49d3e392ab25",
+      "6058ac7bc0b345ee8f5d2f631b7b6940",
+      "ec94298c63ab4b0e83c074a9d2ed4fc9",
+      "0d56de85d9244f38a8a0b3d84ee5d7da",
+      "b0053efc5ecc411f902fcf3b19cd362e",
+      "1d69552268b74bfb824c4f783e362949",
+      "de35e43c6aea490b917084a93c4571fb",
+      "8fdc7615fa0b412283eb3beb36b97872",
+      "d5542140ebd34dfaa8c66f2f3e48fe92",
+      "9eaafbfddcec4cdb998770d2cefc8fb7",
+      "a9e2ae7f987b4d9d9636c3963530d8ed",
+      "283159e7918540efa39d255f475dd984",
+      "2f5aa471e247475691da674db1d8514c",
+      "c67e91be78c74ba9b816e40dd5c181ae",
+      "d02de13e2d7843298e61b8f47d8dee33",
+      "76d9a70692e34521a609b337755d9901",
+      "8a1465ca8728490dba4fd79730ea6a30",
+      "3d563f4f9d28464788cab663cc814cf4",
+      "6fe391246afa49e08eec5793a97690db",
+      "47cc4883459449af8f9b35cd74b84002",
+      "69da0360a8ae4737b6e1af2e790f2b85",
+      "d7cc01fb605b4dd58cac287c36b6afea",
+      "638f9ac5607b42d3a467295cb8f7c50d",
+      "8e885a254c6f4311a3774d816e5ef5ac",
+      "580addd60f83499386b626c6440c6fca",
+      "6bb5cbb9ce7645c4ad45cdf056af0445",
+      "2e3ea9571d364a40aa9917a6f49b45f7",
+      "665f8e9a73b94639aa42743d16726a96",
+      "34a2309f1b78432ab51a87c964946da8",
+      "078db166712a4daba8e99ccdf44eb16f",
+      "dde4b35063b64a28a2fd5412eb9474f0",
+      "4d9c96f9caa54ac69dbee2755cfd804d",
+      "aa9d3e82fed541cca0fffe35b55aaabf",
+      "3221446fbbc24420a923884c67e0b87c",
+      "abf0151dabeb49eab089f921c8f364b5",
+      "488797401b9e419ab393ad5b2438039e",
+      "4394b231af2f4e1499a308c93b0ff951",
+      "4f1a59e4dff4470fb123ab315ded6e4f",
+      "5ead730bc1c34a28b5b046ae270d04e6",
+      "13b77ec58e65475b95d0041f90639e9a",
+      "deb2a67f32e64ebf87758c3ace7916e8",
+      "c594b48ac5b347f78c099d581dc4cd96",
+      "68fd129101844ab18b2b107778873d54",
+      "d7e07795e63c4ab78ca92961ba089b07",
+      "d3450ca5684b4a5680c114d29a7ce8f5",
+      "61ed075433b94feda586eec035251768",
+      "c46be587d0fe4ef0b364f822f5ff903d",
+      "c7f7e4ee797749c0939c9a3926937b41",
+      "2a4d28248796477994a17db0fb8485dc",
+      "0dbdea008e964ad887f112336be78449",
+      "47977de9d961442682805f37f7217387",
+      "241f6ce34fd242ca9a46f8232a9fb838",
+      "846eac2286dd4d6991f80b6ae03ce804",
+      "72858c26d6154ef3b8f90ffb0339781e",
+      "4085f5c89ca94a31b346452cd8009dad",
+      "47c175c19d6b4268a2ade2966327de78",
+      "f3dc7118a9fa4b188cc3a9aaf366b125",
+      "9f07e155db5a473abdd7b7ae0617e770",
+      "05feab0298c54df4a2372152d4f3a891",
+      "abeb4c3be90344469c004e29465e1580",
+      "540e6158656d412591a5442eb89d1e65",
+      "51a0e1eb84eb4dd6a95f30268541ccbc",
+      "fe7d093f30854ee1b66f080c5b8fb68b",
+      "880e13da115f4e2e9d413b75b0eecdcb"
+     ]
+    },
+    "execution": {
+     "shell.execute_reply.end": "2023-12-22T03:35:36.853391Z",
+     "shell.execute_reply.started": "2023-12-22T03:35:33.398019Z",
+     "to_execute": "2023-12-22T03:35:33.384Z"
+    },
+    "id": "d0b36e7eff50657c",
+    "libroFormatter": "formatter-string",
+    "outputId": "4198784f-15c6-4812-f96a-c3f62914dbbb",
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "boolq example: \n",
+      "{'input': 'Persian language -- Persian (/ˈpɜːrʒən, -ʃən/), also known by its endonym Farsi (فارسی fārsi (fɒːɾˈsiː) ( listen)), is one of the Western Iranian languages within the Indo-Iranian branch of the Indo-European language family. It is primarily spoken in Iran, Afghanistan (officially known as Dari since 1958), and Tajikistan (officially known as Tajiki since the Soviet era), and some other regions which historically were Persianate societies and considered part of Greater Iran. It is written in the Persian alphabet, a modified variant of the Arabic script, which itself evolved from the Aramaic alphabet.\\nQuestion: do iran and afghanistan speak the same language\\nA. Yes\\nB. No\\nAnswer:', 'output': 'A', 'task_name': 'boolq'}\n",
+      "multirc example: \n",
+      "{'input': 'While this process moved along, diplomacy continued its rounds. Direct pressure on the Taliban had proved unsuccessful. As one NSC staff note put it, \"Under the Taliban, Afghanistan is not so much a state sponsor of terrorism as it is a state sponsored by terrorists.\" In early 2000, the United States began a high-level effort to persuade Pakistan to use its influence over the Taliban. In January 2000, Assistant Secretary of State Karl Inderfurth and the State Department\\'s counterterrorism coordinator, Michael Sheehan, met with General Musharraf in Islamabad, dangling before him the possibility of a presidential visit in March as a reward for Pakistani cooperation. Such a visit was coveted by Musharraf, partly as a sign of his government\\'s legitimacy. He told the two envoys that he would meet with Mullah Omar and press him on  Bin Laden. They left, however, reporting to Washington that Pakistan was unlikely in fact to do anything,\" given what it sees as the benefits of Taliban control of Afghanistan.\" President Clinton was scheduled to travel to India. The State Department felt that he should not visit India without also visiting Pakistan. The Secret Service and the CIA, however, warned in the strongest terms that visiting Pakistan would risk the President\\'s life. Counterterrorism officials also argued that Pakistan had not done enough to merit a presidential visit. But President Clinton insisted on including Pakistan in the itinerary for his trip to South Asia. His one-day stopover on March 25, 2000, was the first time a U.S. president had been there since 1969. At his meeting with Musharraf and others, President Clinton concentrated on tensions between Pakistan and India and the dangers of nuclear proliferation, but also discussed  Bin Laden. President Clinton told us that when he pulled Musharraf aside for a brief, one-on-one meeting, he pleaded with the general for help regarding  Bin Laden.\" I offered him the moon when I went to see him, in terms of better relations with the United States, if he\\'d help us get  Bin Laden and deal with another issue or two.\" The U.S. effort continued. \\nQuestion: What did the high-level effort to persuade Pakistan include?\\nAnswer: Children, Gerd, or Dorian Popa\\nIs it true?\\nA. Yes\\nB. No\\nAnswer:', 'output': 'B', 'task_name': 'multirc'}\n",
+      "rte example: \n",
+      "{'input': 'No Weapons of Mass Destruction Found in Iraq Yet.\\nWeapons of Mass Destruction Found in Iraq.\\nIs the sentence below entailed by the sentence above?\\nA. Yes\\nB. No\\nAnswer:', 'output': 'B', 'task_name': 'rte'}\n",
+      "wic example: \n",
+      "{'input': \"Sentence 1: Do you want to come over to my place later?\\nSentence 2: A political system with no place for the less prominent groups.\\nAre 'place' in the above two sentences the same?\\nA. Yes\\nB. No\\nAnswer:\", 'output': 'B', 'task_name': 'wic'}\n"
+     ]
+    }
+   ],
+   "source": [
+    "# boolq\n",
+    "boolq_dataset = (\n",
+    "    load_dataset(\"super_glue\", \"boolq\")\n",
+    "    .map(\n",
+    "        lambda x: {\n",
+    "            \"input\": f\"{x['passage']}\\nQuestion: {x['question']}\\nA. Yes\\nB. No\\nAnswer:\",\n",
+    "            # 0 - False\n",
+    "            # 1 - True\n",
+    "            \"output\": [\"B\", \"A\"][int(x[\"label\"])],\n",
+    "            \"task_name\": \"boolq\",\n",
+    "        }\n",
+    "    )\n",
+    "    .select_columns([\"input\", \"output\", \"task_name\"])\n",
+    ")\n",
+    "print(\"boolq example: \")\n",
+    "print(boolq_dataset[\"train\"][0])\n",
+    "\n",
+    "# multirc\n",
+    "multirc_dataset = (\n",
+    "    load_dataset(\"super_glue\", \"multirc\")\n",
+    "    .map(\n",
+    "        lambda x: {\n",
+    "            \"input\": (\n",
+    "                f\"{x['paragraph']}\\nQuestion: {x['question']}\\nAnswer: {x['answer']}\\nIs it\"\n",
+    "                \" true?\\nA. Yes\\nB. No\\nAnswer:\"\n",
+    "            ),\n",
+    "            # 0 - False\n",
+    "            # 1 - True\n",
+    "            \"output\": [\"B\", \"A\"][int(x[\"label\"])],\n",
+    "            \"task_name\": \"multirc\",\n",
+    "        }\n",
+    "    )\n",
+    "    .select_columns([\"input\", \"output\", \"task_name\"])\n",
+    ")\n",
+    "print(\"multirc example: \")\n",
+    "print(multirc_dataset[\"train\"][0])\n",
+    "\n",
+    "# rte\n",
+    "rte_dataset = (\n",
+    "    load_dataset(\"super_glue\", \"rte\")\n",
+    "    .map(\n",
+    "        lambda x: {\n",
+    "            \"input\": (\n",
+    "                f\"{x['premise']}\\n{x['hypothesis']}\\nIs the sentence below entailed by the\"\n",
+    "                \" sentence above?\\nA. Yes\\nB. No\\nAnswer:\"\n",
+    "            ),\n",
+    "            # 0 - entailment\n",
+    "            # 1 - not_entailment\n",
+    "            \"output\": [\"A\", \"B\"][int(x[\"label\"])],\n",
+    "            \"task_name\": \"rte\",\n",
+    "        }\n",
+    "    )\n",
+    "    .select_columns([\"input\", \"output\", \"task_name\"])\n",
+    ")\n",
+    "print(\"rte example: \")\n",
+    "print(rte_dataset[\"train\"][0])\n",
+    "\n",
+    "# wic\n",
+    "wic_dataset = (\n",
+    "    load_dataset(\"super_glue\", \"wic\")\n",
+    "    .map(\n",
+    "        lambda x: {\n",
+    "            \"input\": (\n",
+    "                f\"Sentence 1: {x['sentence1']}\\nSentence 2: {x['sentence2']}\\nAre '{x['word']}'\"\n",
+    "                \" in the above two sentences the same?\\nA. Yes\\nB. No\\nAnswer:\"\n",
+    "            ),\n",
+    "            # 0 - False\n",
+    "            # 1 - True\n",
+    "            \"output\": [\"B\", \"A\"][int(x[\"label\"])],\n",
+    "            \"task_name\": \"wic\",\n",
+    "        }\n",
+    "    )\n",
+    "    .select_columns([\"input\", \"output\", \"task_name\"])\n",
+    ")\n",
+    "print(\"wic example: \")\n",
+    "print(wic_dataset[\"train\"][0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "9fca2225-aaee-47aa-957a-5f8ed3177cdb",
+   "metadata": {
+    "execution": {
+     "shell.execute_reply.end": "2023-12-22T03:35:36.858952Z",
+     "shell.execute_reply.started": "2023-12-22T03:35:36.855329Z",
+     "to_execute": "2023-12-22T03:35:36.819Z"
+    },
+    "id": "9fca2225-aaee-47aa-957a-5f8ed3177cdb",
+    "libroFormatter": "formatter-string"
+   },
+   "outputs": [],
+   "source": [
+    "# define a task2id map\n",
+    "TASK2ID = {\n",
+    "    \"boolq\": 0,\n",
+    "    \"multirc\": 1,\n",
+    "    \"rte\": 2,\n",
+    "    \"wic\": 3,\n",
+    "}\n",
+    "\n",
+    "\n",
+    "def tokenize(examples):\n",
+    "    inputs, targets = examples[\"input\"], examples[\"output\"]\n",
+    "    features = tokenizer(inputs, max_length=512, padding=\"max_length\", truncation=True, return_tensors=\"pt\")\n",
+    "    labels = tokenizer(targets, max_length=2, padding=\"max_length\", truncation=True, return_tensors=\"pt\")\n",
+    "    labels = labels[\"input_ids\"]\n",
+    "    labels[labels == tokenizer.pad_token_id] = -100\n",
+    "    features[\"labels\"] = labels\n",
+    "    features[\"task_ids\"] = torch.tensor([[TASK2ID[t]] for t in examples[\"task_name\"]]).long()\n",
+    "    return features"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "0bf6c31c-73cd-4eed-931b-0cad5d7290fb",
+   "metadata": {
+    "execution": {
+     "shell.execute_reply.end": "2023-12-22T03:35:36.929414Z",
+     "shell.execute_reply.started": "2023-12-22T03:35:36.860477Z",
+     "to_execute": "2023-12-22T03:35:36.849Z"
+    },
+    "id": "0bf6c31c-73cd-4eed-931b-0cad5d7290fb",
+    "libroFormatter": "formatter-string",
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "def get_superglue_dataset(\n",
+    "    split=\"train\",\n",
+    "    n_samples=500,\n",
+    "):\n",
+    "    ds = concatenate_datasets(\n",
+    "        [\n",
+    "            boolq_dataset[split].shuffle().select(range(n_samples)),\n",
+    "            multirc_dataset[split].shuffle().select(range(n_samples)),\n",
+    "            rte_dataset[split].shuffle().select(range(n_samples)),\n",
+    "            wic_dataset[split].shuffle().select(range(n_samples)),\n",
+    "        ]\n",
+    "    )\n",
+    "    ds = ds.map(\n",
+    "        tokenize,\n",
+    "        batched=True,\n",
+    "        remove_columns=[\"input\", \"output\", \"task_name\"],\n",
+    "        load_from_cache_file=False,\n",
+    "    )\n",
+    "    return ds"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "oNvh2WGlLo4z",
+   "metadata": {
+    "id": "oNvh2WGlLo4z",
+    "libroFormatter": "formatter-string"
+   },
+   "source": [
+    "As a toy example, we only select 1,000 from each subdataset for training and 100 each for eval."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "1bf88dd1a6aaa6a5",
+   "metadata": {
+    "collapsed": false,
+    "execution": {
+     "shell.execute_reply.end": "2023-12-22T03:35:44.953151Z",
+     "shell.execute_reply.started": "2023-12-22T03:35:37.023791Z",
+     "to_execute": "2023-12-22T03:35:37.009Z"
+    },
+    "libroFormatter": "formatter-string"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Map:   0%|          | 0/4000 [00:00<?, ? examples/s]"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Map: 100%|██████████| 4000/4000 [00:02<00:00, 1880.98 examples/s]\n",
+      "Map: 100%|██████████| 400/400 [00:00<00:00, 2124.88 examples/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "superglue_train_dataset = get_superglue_dataset(split=\"train\", n_samples=1000)\n",
+    "superglue_eval_dataset = get_superglue_dataset(split=\"test\", n_samples=100)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "550abf92-b8ea-424b-aba0-10d8da941297",
+   "metadata": {
+    "id": "550abf92-b8ea-424b-aba0-10d8da941297",
+    "libroFormatter": "formatter-string"
+   },
+   "source": [
+    "## Train and evaluate"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b48135d6-0d83-4e8a-b1f0-c292663c84ec",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 134
+    },
+    "execution": {
+     "shell.execute_reply.end": "",
+     "shell.execute_reply.started": "2023-12-22T03:35:45.102182Z",
+     "to_execute": "2023-12-22T03:35:44.998Z"
+    },
+    "id": "b48135d6-0d83-4e8a-b1f0-c292663c84ec",
+    "libroFormatter": "formatter-string",
+    "outputId": "362dbaae-4a43-423b-d0d1-39839d721177"
+   },
+   "outputs": [],
+   "source": [
+    "# training and evaluation\n",
+    "def compute_metrics(eval_preds):\n",
+    "    preds, labels = eval_preds\n",
+    "    preds = [[i for i in seq if i != -100] for seq in preds]\n",
+    "    labels = [[i for i in seq if i != -100] for seq in labels]\n",
+    "    preds = tokenizer.batch_decode(preds, skip_special_tokens=True)\n",
+    "    labels = tokenizer.batch_decode(labels, skip_special_tokens=True)\n",
+    "\n",
+    "    correct = 0\n",
+    "    total = 0\n",
+    "    for pred, true in zip(preds, labels):\n",
+    "        if pred.strip() == true.strip():\n",
+    "            correct += 1\n",
+    "        total += 1\n",
+    "    accuracy = correct / total\n",
+    "    return {\"accuracy\": accuracy}\n",
+    "\n",
+    "\n",
+    "training_args = Seq2SeqTrainingArguments(\n",
+    "    \"output\",\n",
+    "    per_device_train_batch_size=batch_size,\n",
+    "    per_device_eval_batch_size=batch_size,\n",
+    "    learning_rate=lr,\n",
+    "    num_train_epochs=num_epochs,\n",
+    "    eval_strategy=\"epoch\",\n",
+    "    logging_strategy=\"epoch\",\n",
+    "    save_strategy=\"no\",\n",
+    "    report_to=[],\n",
+    "    predict_with_generate=True,\n",
+    "    generation_max_length=2,\n",
+    "    remove_unused_columns=False,\n",
+    ")\n",
+    "trainer = Seq2SeqTrainer(\n",
+    "    model=model,\n",
+    "    processing_class=tokenizer,\n",
+    "    args=training_args,\n",
+    "    train_dataset=superglue_train_dataset,\n",
+    "    eval_dataset=superglue_eval_dataset,\n",
+    "    data_collator=default_data_collator,\n",
+    "    compute_metrics=compute_metrics,\n",
+    ")\n",
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "6bdad1ae-ecf0-4df1-bf27-6474c48c16be",
+   "metadata": {
+    "execution": {
+     "shell.execute_reply.end": "2023-12-22T06:59:00.354149Z",
+     "shell.execute_reply.started": "2023-12-22T06:58:59.294716Z",
+     "to_execute": "2023-12-22T06:58:59.146Z"
+    },
+    "id": "6bdad1ae-ecf0-4df1-bf27-6474c48c16be",
+    "libroFormatter": "formatter-string"
+   },
+   "outputs": [],
+   "source": [
+    "# saving model\n",
+    "model_name_or_path = \"google/flan-t5-xl\"\n",
+    "peft_model_id = f\"{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\"\n",
+    "model.save_pretrained(peft_model_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "9e539e3d-0944-4f81-bcd6-dec16c66eeea",
+   "metadata": {
+    "execution": {
+     "shell.execute_reply.end": "2023-12-22T06:59:05.542802Z",
+     "shell.execute_reply.started": "2023-12-22T06:59:04.397500Z",
+     "to_execute": "2023-12-22T06:59:04.248Z"
+    },
+    "id": "9e539e3d-0944-4f81-bcd6-dec16c66eeea",
+    "libroFormatter": "formatter-string"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "total 37M\n",
+      "-rw-r--r-- 1 root root 5.1K Aug  4 20:25 README.md\n",
+      "-rw-r--r-- 1 root root  381 Aug  4 20:25 adapter_config.json\n",
+      "-rw-r--r-- 1 root root  37M Aug  4 20:25 adapter_model.safetensors\n"
+     ]
+    }
+   ],
+   "source": [
+    "!ls -lh $peft_model_id"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "52e37b18-d760-4af7-b1ab-40a6880eb92d",
+   "metadata": {
+    "id": "52e37b18-d760-4af7-b1ab-40a6880eb92d",
+    "libroFormatter": "formatter-string"
+   },
+   "source": [
+    "## Load and infer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "8eeb65376093b996",
+   "metadata": {
+    "collapsed": false,
+    "execution": {
+     "shell.execute_reply.end": "2023-12-22T06:59:13.768047Z",
+     "shell.execute_reply.started": "2023-12-22T06:59:13.765849Z",
+     "to_execute": "2023-12-22T06:59:13.627Z"
+    },
+    "libroFormatter": "formatter-string"
+   },
+   "outputs": [],
+   "source": [
+    "device_type = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "device = f\"{device_type}:0\" if device_type != \"cpu\" else \"cpu\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "70490c8e-d301-4e4e-a5a3-de87b53f1942",
+   "metadata": {
+    "execution": {
+     "shell.execute_reply.end": "2023-12-22T07:00:09.333267Z",
+     "shell.execute_reply.started": "2023-12-22T06:59:15.706883Z",
+     "to_execute": "2023-12-22T06:59:15.561Z"
+    },
+    "id": "70490c8e-d301-4e4e-a5a3-de87b53f1942",
+    "libroFormatter": "formatter-string"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading checkpoint shards: 100%|██████████| 2/2 [00:00<00:00, 22.17it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "peft_model_id = f\"{model_name_or_path}_{peft_config.peft_type}_{peft_config.task_type}\"\n",
+    "\n",
+    "config = PeftConfig.from_pretrained(peft_model_id)\n",
+    "model = AutoModelForSeq2SeqLM.from_pretrained(config.base_model_name_or_path)\n",
+    "model = PeftModel.from_pretrained(model, peft_model_id)\n",
+    "model = model.to(device)\n",
+    "model = model.eval()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "80ae512b-545d-470d-874d-969dba42055b",
+   "metadata": {
+    "execution": {
+     "shell.execute_reply.end": "2023-12-22T07:00:17.434446Z",
+     "shell.execute_reply.started": "2023-12-22T07:00:17.285745Z",
+     "to_execute": "2023-12-22T07:00:17.137Z"
+    },
+    "id": "80ae512b-545d-470d-874d-969dba42055b",
+    "libroFormatter": "formatter-string"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "In 1979, the leaders signed the Egypt-Israel peace treaty on the White House lawn. Both President Begin and Sadat received the Nobel Peace Prize for their work. The two nations have enjoyed peaceful relations to this day.\n",
+      "The Israel-Egypt Peace Agreement was signed in 1979.\n",
+      "Is the sentence below entailed by the sentence above?\n",
+      "A. Yes\n",
+      "B. No\n",
+      "Answer:\n",
+      "A\n",
+      "{'input_ids': tensor([[   86, 15393,     6,     8,  2440,  3814,     8, 10438,    18, 30387,\n",
+      "          3065,  2665,    63,    30,     8,  1945,  1384,  8652,     5,  2867,\n",
+      "          1661, 10129,    77,    11, 18875,   144,  1204,     8, 22232, 11128,\n",
+      "         11329,    21,    70,   161,     5,    37,   192,  9352,    43,  2994,\n",
+      "          9257,  5836,    12,    48,   239,     5,    37,  3352,    18,   427,\n",
+      "           122,    63,   102,    17, 11128,  7139,    47,  3814,    16, 15393,\n",
+      "             5,    27,     7,     8,  7142,   666,     3,   295, 10990,    57,\n",
+      "             8,  7142,   756,    58,    71,     5,  2163,   272,     5,   465,\n",
+      "         11801,    10,     1]], device='xpu:0'), 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
+      "         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
+      "         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
+      "         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], device='xpu:0'), 'task_ids': tensor([2], device='xpu:0')}\n",
+      "tensor([ 0, 71,  1], device='xpu:0')\n",
+      "A\n"
+     ]
+    }
+   ],
+   "source": [
+    "i = 5\n",
+    "inputs = tokenizer(rte_dataset[\"validation\"][\"input\"][i], return_tensors=\"pt\")\n",
+    "inputs[\"task_ids\"] = torch.LongTensor([TASK2ID[\"rte\"]])\n",
+    "inputs = {k: v.to(device) for k, v in inputs.items()}\n",
+    "print(rte_dataset[\"validation\"][\"input\"][i])\n",
+    "print(rte_dataset[\"validation\"][\"output\"][i])\n",
+    "print(inputs)\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    outputs = model.generate(**inputs, max_new_tokens=2)\n",
+    "    print(outputs[0])\n",
+    "    print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "gpuType": "T4",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  },
+  "widgets": {
+   "application/vnd.jupyter.widget-state+json": {
+    "01097fb41b9c4cbf91300e049d9f3617": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "015fd47fdbdf47c5a619eff218052b45": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8851d4a04cb9410c849b6606a812c52b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_3b5ab7d9f27944d8ae1b172231c9c6fc",
+      "value": "spiece.model: 100%"
+     }
+    },
+    "03d340641a414362b0356e8178148d9a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "045c5ac6981440c996ac7dda054fc112": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_f6a6f03ea7f140189a277742ff7082f8",
+       "IPY_MODEL_ecff5b6dfb784c96b69d1a39b7acb171",
+       "IPY_MODEL_43a32f261eaf42af978a6bf98502b1fc"
+      ],
+      "layout": "IPY_MODEL_8b7bb3fb502f4c3185709d6c40638d70"
+     }
+    },
+    "04c34c92e4374c50bd0636c72953a8ba": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_24bbd7b810b34c4c9baeed628961c64b",
+      "max": 2201,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_1c63e99470824a3aa0f98a94862733d5",
+      "value": 2201
+     }
+    },
+    "05feab0298c54df4a2372152d4f3a891": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0622e1de75f34da590f241232613cf5e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "06716294f2244cc48f78af918cc063f2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "06a2114630234393bc0f07b3a64455f8": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "06b21316e1ef41c9b7c9d943a9ff91ec": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "078db166712a4daba8e99ccdf44eb16f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "08a572aefb63488d8125ae3b881c0729": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7ffe5fd0a64c40cebc784eca83154069",
+      "placeholder": "​",
+      "style": "IPY_MODEL_d622b006621e4110a157fb4cb43c9762",
+      "value": " 3.13G/3.13G [00:17&lt;00:00, 255MB/s]"
+     }
+    },
+    "09fa4b156f174dbcacdf976f2b39a280": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0a03bee83ddf4ad297bfdc9b4de3b075": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "0b5d06cb83334b53a91c929f8e308543": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0d40464e81fe4c06ac3400204116f243": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0d56de85d9244f38a8a0b3d84ee5d7da": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0d80cc1f4fcc49d59e3a80862678fd86": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_0b5d06cb83334b53a91c929f8e308543",
+      "max": 396213,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_8b9f3c47205d474b97efc6e9c6fb5f68",
+      "value": 396213
+     }
+    },
+    "0dbdea008e964ad887f112336be78449": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0f09296d37ee44b89871fa22cdd0127f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "0fa8ddd8da924c089221611c98e7da6e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0fd475cb9e064d10a8ed031957cf2044": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_d1d2687d51a4442d8555ed4071837da4",
+       "IPY_MODEL_0d80cc1f4fcc49d59e3a80862678fd86",
+       "IPY_MODEL_9e556858d4a44b5bbc3e3af87d138a55"
+      ],
+      "layout": "IPY_MODEL_d86eb0ba47884ab081128a8761e9654b"
+     }
+    },
+    "0fd8ca256b8b49e1906a2a8e21156164": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "10436da727ec45c8a5e8b783696636d5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "10d7a41588744be1b29678b4a9dfdd27": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "118967bdd4a348858cc7572d36c1b736": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "11c60d67f2204518b007ef47c801fbff": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_1ff4bcdb97294287ae8f3e9f2dc6bafa",
+      "placeholder": "​",
+      "style": "IPY_MODEL_bc265b1f822348469e3c8df0ea608abb",
+      "value": " 277/277 [00:00&lt;00:00, 4133.48 examples/s]"
+     }
+    },
+    "12bb708857e84e5b893ca3e9ff176082": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "13b77ec58e65475b95d0041f90639e9a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "13ccc23d506248d5b66ffe7732ead149": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c6a00e1b00684bb7930fb27d6499932e",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4395227decf642f7b8fbc6616f9ec826",
+      "value": " 9693/9693 [00:01&lt;00:00, 7169.97 examples/s]"
+     }
+    },
+    "143eaab6e65f4c8eb7a4314cadf323ba": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_ee7eccaca57b4460becfe0d5d5afb3f9",
+      "placeholder": "​",
+      "style": "IPY_MODEL_554a1ef44aea4ff484f0944878bb58a2",
+      "value": " 27243/27243 [00:02&lt;00:00, 7447.56 examples/s]"
+     }
+    },
+    "1507ea5f89534b10856b99488ed5da65": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "167e67c018e441d8baab4127b25773c6": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "16938b11881741af8e6633094a4402dc": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "170853712c0c4a8d997696f74090d7c6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7eaee1cd25d0442092846922cdd6c413",
+      "max": 4118001,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_483b9c219aa94ea1952e3534a02395aa",
+      "value": 4118001
+     }
+    },
+    "1727de01c47144b2958babfb91e887cb": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "17fc618034bf4aadaef811b0e7c80eed": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c2ed87d5599a467bba084cddb9e40713",
+      "placeholder": "​",
+      "style": "IPY_MODEL_2cfc492ab0ed454dbf2c4da18cd24d02",
+      "value": " 30.7k/30.7k [00:00&lt;00:00, 1.12MB/s]"
+     }
+    },
+    "19e50ecdda3b493184611d97724ac1fc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "1b78ff7e32254777abe2c802b6879b9c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "1c0bd751a3294b8ea0cf828866169121": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1c63e99470824a3aa0f98a94862733d5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "1cb2dcb242334f46b7f195929dd1f341": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_33add0384c36462ab44fe3e0b03f63c7",
+      "placeholder": "​",
+      "style": "IPY_MODEL_e227fb95b00b4af8b82286c75db84611",
+      "value": " 14.8k/14.8k [00:00&lt;00:00, 947kB/s]"
+     }
+    },
+    "1d69552268b74bfb824c4f783e362949": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1e3f013edc6341a0837af33ff4866d0b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1e509cb019cd47f9b3746177fad205ee": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "1ed6f4595ec540729d776a81db96c403": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "1ff4bcdb97294287ae8f3e9f2dc6bafa": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "205a7844670249bf83d468fe3af0e139": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_28a78fb894a4413e960c1e40d7df8173",
+       "IPY_MODEL_46bd38ac919e4e66a72226c1f0da67d6",
+       "IPY_MODEL_9557a05279544cd8a5f2ba4d3429f576"
+      ],
+      "layout": "IPY_MODEL_2e0e7f437b5d4e4086b38ee6da51dc4f"
+     }
+    },
+    "241f6ce34fd242ca9a46f8232a9fb838": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "24bbd7b810b34c4c9baeed628961c64b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "268fe971a0bc45c6b7c37586e0f9da49": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "26a75e6f6628472b91f3214505afa935": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "283159e7918540efa39d255f475dd984": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8a1465ca8728490dba4fd79730ea6a30",
+      "max": 638,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_3d563f4f9d28464788cab663cc814cf4",
+      "value": 638
+     }
+    },
+    "28a78fb894a4413e960c1e40d7df8173": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_73a0ea365433404babb83a2d1caa9c66",
+      "placeholder": "​",
+      "style": "IPY_MODEL_855a155046904aaa9b91b01dd6a86088",
+      "value": "Map: 100%"
+     }
+    },
+    "2918f1fd9e104c09967d698e11728785": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d725549ca34a4d54ae684e7e4741be29",
+      "placeholder": "​",
+      "style": "IPY_MODEL_d94392afd01246ff942af838a995379e",
+      "value": "Downloading data: 100%"
+     }
+    },
+    "29ad37e81b7f44a9aafa982b52f05a7a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_1e3f013edc6341a0837af33ff4866d0b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_1ed6f4595ec540729d776a81db96c403",
+      "value": "Map: 100%"
+     }
+    },
+    "2a02922d16cb42499cbc48e1d34a8134": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2a4d28248796477994a17db0fb8485dc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "2a6cf3f2b4c349a9adc26351c2f0b222": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_9f1feddbe0d449a0b93fc5b1027e4319",
+      "max": 1116225,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_1507ea5f89534b10856b99488ed5da65",
+      "value": 1116225
+     }
+    },
+    "2aab7297963040f1900f0bc1f24e7b2a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "2aceeebfd0dc42fcbbc1b3a7e1f54c56": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_3c076081fd7942e184f8d4f171a17e1c",
+      "max": 147,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_0a03bee83ddf4ad297bfdc9b4de3b075",
+      "value": 147
+     }
+    },
+    "2bd3c665eb784f149dc21853103e8ff0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "2c5eaf38e66d492d8661852cacc4e527": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d8594695c03e4fb7965dcbe04074d4eb",
+      "max": 9427,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_f972a2e10dde405c8aec8f7cd1be4317",
+      "value": 9427
+     }
+    },
+    "2cd168e5e3c4481ba151aa8a655e7ce8": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2cd302d306e3440dac4b70fc46741544": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "2cdddd0398e045a6a13124bf6fd85506": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_a1f5618e59d148409d6ccf4bfffca2fa",
+       "IPY_MODEL_c870763add1745d9acfc2762f468c984",
+       "IPY_MODEL_be70aecc5b294c4c93b0dcc09d6d1cb3"
+      ],
+      "layout": "IPY_MODEL_37b18b2ae9504b6c91066798a19a1319"
+     }
+    },
+    "2cfc492ab0ed454dbf2c4da18cd24d02": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "2deb046362ed4570a3f550f4f288529e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "2e0e7f437b5d4e4086b38ee6da51dc4f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "2e3d6b5d46db4295829002fc311a9c74": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "2e3ea9571d364a40aa9917a6f49b45f7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "2f2dc993705b447aa771cf0cc13c3b1d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_69dffb139cab46b1b93bef960f702655",
+       "IPY_MODEL_e7dc30a09a64401393e43618b51059de",
+       "IPY_MODEL_75c397c506a04d0d9ca62e8d7f990813"
+      ],
+      "layout": "IPY_MODEL_eb7e509acfea4e1bb2f59b2fde11603d"
+     }
+    },
+    "2f5aa471e247475691da674db1d8514c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6fe391246afa49e08eec5793a97690db",
+      "placeholder": "​",
+      "style": "IPY_MODEL_47cc4883459449af8f9b35cd74b84002",
+      "value": " 638/638 [00:00&lt;00:00, 6235.59 examples/s]"
+     }
+    },
+    "3087335b98964b9eb4da474487ca4864": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_43717a0ae4c043f9947d8fd844d71997",
+      "placeholder": "​",
+      "style": "IPY_MODEL_3f0008931054433c838a6633ca1347e6",
+      "value": " 3245/3245 [00:00&lt;00:00, 15009.48 examples/s]"
+     }
+    },
+    "30b3667258174beaa01322ffa055759b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "315575253cb9433d81f7d26770907f29": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "319bf5c6332f41958974d9c3af87a382": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_726e82f2b6c94e8eb5620c18872aabb6",
+      "placeholder": "​",
+      "style": "IPY_MODEL_12bb708857e84e5b893ca3e9ff176082",
+      "value": "Map: 100%"
+     }
+    },
+    "32168837680e41eaad4e5e4cdf09877d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_319bf5c6332f41958974d9c3af87a382",
+       "IPY_MODEL_c1e065fa36344f509e7863c3ec0428b8",
+       "IPY_MODEL_5b9510c694a24afbb1c8318fea1a1bc5"
+      ],
+      "layout": "IPY_MODEL_f12d118a6b3f46b580fbe2018f4cf5e9"
+     }
+    },
+    "3221446fbbc24420a923884c67e0b87c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5ead730bc1c34a28b5b046ae270d04e6",
+      "max": 5428,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_13b77ec58e65475b95d0041f90639e9a",
+      "value": 5428
+     }
+    },
+    "3241189c875a471ab0831f0f4411d2d3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_40ac1e38c100435fbe95b669c69a31c5",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a634013728be457ba590aa333908addd",
+      "value": " 792k/792k [00:00&lt;00:00, 9.84MB/s]"
+     }
+    },
+    "32672cb3395045bcb9c2d370032356cc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "32a6ac79c27e47c1a4b32098bfe25807": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_98c677014f1a48ac804cec0714a22172",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a4097270b9b947b0ad0b3b5d217eecc0",
+      "value": " 2.20k/2.20k [00:00&lt;00:00, 117kB/s]"
+     }
+    },
+    "32c1cc0d5327462d9175c74b91d67c4d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_910d8a34abaa4f92a899dd4f5ab03d74",
+       "IPY_MODEL_fbd92ad5a793482aac5570387e917188",
+       "IPY_MODEL_ac81634b0e0946d690fb7d8ad7aed911"
+      ],
+      "layout": "IPY_MODEL_01097fb41b9c4cbf91300e049d9f3617"
+     }
+    },
+    "33add0384c36462ab44fe3e0b03f63c7": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "34a2309f1b78432ab51a87c964946da8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "35bf380a7c6243859a459560288ffe49": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_9801a82eda354815b6b3abbc8d1e0140",
+      "max": 750920,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_b10768b6bc654da8b822b4878889639b",
+      "value": 750920
+     }
+    },
+    "35bfe48a1b744262a8ea68bf5b5d495d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_eed4b0b927824444aa8d875281cca1c4",
+       "IPY_MODEL_e77316215dbe41daa8e89d8b2cc0f032",
+       "IPY_MODEL_11c60d67f2204518b007ef47c801fbff"
+      ],
+      "layout": "IPY_MODEL_da21830428b54f76aa31b03efce202b9"
+     }
+    },
+    "3635aa8a2cee484b945ddf7379ff4102": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_94ce06b3df27425eb8ae1a0aade4244d",
+       "IPY_MODEL_e8ab0bcb4d7f4a298b2b3555d866a11f",
+       "IPY_MODEL_5570fad8913d4bb495681b5e1dbe3950"
+      ],
+      "layout": "IPY_MODEL_47735f6c830149db965660d6b2f200d7"
+     }
+    },
+    "376242d1cfd74c88aaeaa76a6813d855": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_a17443b5713d4b60aeb85da3adce6cf2",
+       "IPY_MODEL_91f821fb888046b6a2f8ade2cc58db2d",
+       "IPY_MODEL_4bea407148e846babefdc88eff8a9131"
+      ],
+      "layout": "IPY_MODEL_26a75e6f6628472b91f3214505afa935"
+     }
+    },
+    "379357ab63f5479fad469c181b054bb0": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "37b18b2ae9504b6c91066798a19a1319": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "384d10ea2a354f24bae33c3a1d564b82": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b9ec517b4b084d548525ac41381ef69e",
+      "placeholder": "​",
+      "style": "IPY_MODEL_6f3679fe9b60498da864bda9ba6d899e",
+      "value": "Downloading builder script: 100%"
+     }
+    },
+    "3968997ad99444988e00d631ecca66cf": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3b056671c3fd41aeb4d6da821d562b95": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "3b5ab7d9f27944d8ae1b172231c9c6fc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "3c076081fd7942e184f8d4f171a17e1c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3c3d747638004a08a898cff7c6f59acc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_0622e1de75f34da590f241232613cf5e",
+      "max": 14813,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_5b868029728541dc9da977312da38cf0",
+      "value": 14813
+     }
+    },
+    "3d563f4f9d28464788cab663cc814cf4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "3e6d67d246e54fa497f4398e3aeddb00": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3e8f08e000f248b59331d2430bbc8e3c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "3f0008931054433c838a6633ca1347e6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "3f173a7293cd4ff8a54da8c8174cfb43": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "3f1d345037604e01911ef344f3b51742": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4085f5c89ca94a31b346452cd8009dad": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_05feab0298c54df4a2372152d4f3a891",
+      "placeholder": "​",
+      "style": "IPY_MODEL_abeb4c3be90344469c004e29465e1580",
+      "value": "Map: 100%"
+     }
+    },
+    "40ac1e38c100435fbe95b669c69a31c5": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "40b859a2fd68457db691bb5e7eb23591": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4188c097387a408dae680f67bd97752b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_ff00f4c2c63a467098b119ae2259f529",
+      "placeholder": "​",
+      "style": "IPY_MODEL_d6754db1364144e69e3ab320aa1faeb9",
+      "value": "Downloading data: 100%"
+     }
+    },
+    "4189c6e9c59e44d3a776b49c38cc8f06": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "41b36d52e98249b1b506d369d2d8e994": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "43717a0ae4c043f9947d8fd844d71997": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "438c02b8134e45d5b2760b2e1f72f004": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4394b231af2f4e1499a308c93b0ff951": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4395227decf642f7b8fbc6616f9ec826": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "43a32f261eaf42af978a6bf98502b1fc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_167e67c018e441d8baab4127b25773c6",
+      "placeholder": "​",
+      "style": "IPY_MODEL_88405a75b92743e589f424ee8c4d4d79",
+      "value": " 9693/9693 [00:00&lt;00:00, 10804.18 examples/s]"
+     }
+    },
+    "43d9b3de4a6949f787d9733d1ae4d18e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "45599b40bcbb4baf83bc87be0ae509d0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_cf0be710991a46ecb9beefe1feaa9e2f",
+      "placeholder": "​",
+      "style": "IPY_MODEL_5edd574de6a64f888506e22da4f11800",
+      "value": " 2000/2000 [00:04&lt;00:00, 531.72 examples/s]"
+     }
+    },
+    "45becb2c72714dfcb721b3a20a92d28f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "46bd38ac919e4e66a72226c1f0da67d6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d49e405525ec467bb7a69a9aaedf82d9",
+      "max": 27243,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_b8ccdebb7b11490e8222ff79ecfc9a33",
+      "value": 27243
+     }
+    },
+    "4728eddf9fcc49d68d71a30379f08335": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "47735f6c830149db965660d6b2f200d7": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "47977de9d961442682805f37f7217387": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "47c175c19d6b4268a2ade2966327de78": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_540e6158656d412591a5442eb89d1e65",
+      "max": 1400,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_51a0e1eb84eb4dd6a95f30268541ccbc",
+      "value": 1400
+     }
+    },
+    "47cc4883459449af8f9b35cd74b84002": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4803c9aece3346488295338254217aff": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "483b9c219aa94ea1952e3534a02395aa": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "488797401b9e419ab393ad5b2438039e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "48cb432d95dc49deae6077fb5c76bec3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "49ac9897f49843fd8c5fed4bcdfdbb56": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4b3dc87d00ed42b0956d0bfa39bd466f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b3a18689eefa4660997034094df0df04",
+      "placeholder": "​",
+      "style": "IPY_MODEL_91cb4404dd794d22b2bbaf31eee207b5",
+      "value": "Generating train split: 100%"
+     }
+    },
+    "4bea407148e846babefdc88eff8a9131": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_558b98eb76654045a5eae24170a5dc9c",
+      "placeholder": "​",
+      "style": "IPY_MODEL_7edf2ac4dd264843a7838a0130668757",
+      "value": " 2.42M/2.42M [00:00&lt;00:00, 6.18MB/s]"
+     }
+    },
+    "4d2a10e9307a47f4a1cbf512380c65bc": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4d9c96f9caa54ac69dbee2755cfd804d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_aa9d3e82fed541cca0fffe35b55aaabf",
+       "IPY_MODEL_3221446fbbc24420a923884c67e0b87c",
+       "IPY_MODEL_abf0151dabeb49eab089f921c8f364b5"
+      ],
+      "layout": "IPY_MODEL_488797401b9e419ab393ad5b2438039e"
+     }
+    },
+    "4ddb5f1d8260448981c67308bcedecbf": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4de322f2413f44bcb03d41dcc8ff1963": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_775687d3962242d6aff3feb0627754a9",
+      "max": 3245,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_92bb9917ab194a1eb1dc6fc5c4c4195d",
+      "value": 3245
+     }
+    },
+    "4e60ffab53dd4aba9e094098ed5297e6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4f1a59e4dff4470fb123ab315ded6e4f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4f769b69f76a4ae885505b5e2e6751bd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4fc54c5844aa44f2b335824c3544a334": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_736443c7e26642379ca66ed3e5dd34cb",
+       "IPY_MODEL_3c3d747638004a08a898cff7c6f59acc",
+       "IPY_MODEL_1cb2dcb242334f46b7f195929dd1f341"
+      ],
+      "layout": "IPY_MODEL_f577bbac4eab439b9ccea0a49eb99d86"
+     }
+    },
+    "51a0e1eb84eb4dd6a95f30268541ccbc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "533151b377d64d3484772b3173dab306": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "53acddb088564a73aef61618797bfe85": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "540e6158656d412591a5442eb89d1e65": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "54823295494d441fb9f26a70fb2c3973": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "54d4afa42e9346578c0a1a193ee8caea": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_2918f1fd9e104c09967d698e11728785",
+       "IPY_MODEL_170853712c0c4a8d997696f74090d7c6",
+       "IPY_MODEL_fcdb61acbf0d470f881ba8f283360e0f"
+      ],
+      "layout": "IPY_MODEL_4803c9aece3346488295338254217aff"
+     }
+    },
+    "554a1ef44aea4ff484f0944878bb58a2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "5570fad8913d4bb495681b5e1dbe3950": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_438c02b8134e45d5b2760b2e1f72f004",
+      "placeholder": "​",
+      "style": "IPY_MODEL_0f09296d37ee44b89871fa22cdd0127f",
+      "value": " 3000/3000 [00:00&lt;00:00, 13255.51 examples/s]"
+     }
+    },
+    "558b98eb76654045a5eae24170a5dc9c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "567e165c27a4494bbf4810ecb7de40cf": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_015fd47fdbdf47c5a619eff218052b45",
+       "IPY_MODEL_ec33a4325b6f4dcfb8a9fa4c80a5c704",
+       "IPY_MODEL_3241189c875a471ab0831f0f4411d2d3"
+      ],
+      "layout": "IPY_MODEL_268fe971a0bc45c6b7c37586e0f9da49"
+     }
+    },
+    "580addd60f83499386b626c6440c6fca": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "589120da6f464686bbeff0d44643d17d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "591e6dc92b5c44418260cf659c5807cf": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "59ee159eec154095a368efceb9d1e042": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5ac310c605f64948ad744bc1f196441d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "5b868029728541dc9da977312da38cf0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "5b90309f747446a3b17badf1c42539bb": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5b9510c694a24afbb1c8318fea1a1bc5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_0fa8ddd8da924c089221611c98e7da6e",
+      "placeholder": "​",
+      "style": "IPY_MODEL_b4a5fdee693d455686507306da804b17",
+      "value": " 4848/4848 [00:00&lt;00:00, 11682.45 examples/s]"
+     }
+    },
+    "5bdf79c178074ebf8757936190bc37b3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "5d1e94d40f514faaa5819096f167d29c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5ff0d4da7342457089f0961b189307f4",
+      "max": 2539,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_a08c4e6628bd440fb31eebbb2693f327",
+      "value": 2539
+     }
+    },
+    "5ead730bc1c34a28b5b046ae270d04e6": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5edd574de6a64f888506e22da4f11800": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "5ff0d4da7342457089f0961b189307f4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6058ac7bc0b345ee8f5d2f631b7b6940": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8fdc7615fa0b412283eb3beb36b97872",
+      "placeholder": "​",
+      "style": "IPY_MODEL_d5542140ebd34dfaa8c66f2f3e48fe92",
+      "value": " 5428/5428 [00:00&lt;00:00, 9975.95 examples/s]"
+     }
+    },
+    "60ab33e3e0d84395a1269604f0fae91f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6113f1920c5743aa8f2c6cc9739029e1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "61d980530bf0408c8e2ed9a7997ba615": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "61ed075433b94feda586eec035251768": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_241f6ce34fd242ca9a46f8232a9fb838",
+      "placeholder": "​",
+      "style": "IPY_MODEL_846eac2286dd4d6991f80b6ae03ce804",
+      "value": " 638/638 [00:00&lt;00:00, 4042.79 examples/s]"
+     }
+    },
+    "61fec3b2596c4803924ed1fb087d52d1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "620e2fa48504435a85d95c2d4b264b6e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "627f32f04b544b4db834b79645f36733": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "63236709413940f59d2622f2927c8d55": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_9da9d7eb9a97495194a3ac4a2786e1de",
+      "placeholder": "​",
+      "style": "IPY_MODEL_3f1d345037604e01911ef344f3b51742",
+      "value": " 4848/4848 [00:00&lt;00:00, 6905.86 examples/s]"
+     }
+    },
+    "637bbd213f3345178742523d055993e6": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6387cbc474144e59aac5e3b42e714887": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "638f9ac5607b42d3a467295cb8f7c50d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_665f8e9a73b94639aa42743d16726a96",
+      "max": 1400,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_34a2309f1b78432ab51a87c964946da8",
+      "value": 1400
+     }
+    },
+    "64d829532bb94214b805c2de4cf529cc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "663b9bd2f1af4df4b757624f53c2f2b8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "665f8e9a73b94639aa42743d16726a96": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "66b0e949143e46faab77458a49a9fe1a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6757bc0834fc4e69b7b588ae6de14ec9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "675c937cf0ef4bf582f4bf90df6fa28e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e8738d4181b04545a0418c1dd5b6b1b5",
+      "placeholder": "​",
+      "style": "IPY_MODEL_2aab7297963040f1900f0bc1f24e7b2a",
+      "value": "Generating train split: 100%"
+     }
+    },
+    "67b108def57749edb2564b3e507959a3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_cc6c1b2d4fcb4ffea016a139738e1ead",
+      "max": 38726,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_6bd3da08b5074e81bffbfe6d92b8ce8b",
+      "value": 38726
+     }
+    },
+    "68fd129101844ab18b2b107778873d54": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_d7e07795e63c4ab78ca92961ba089b07",
+       "IPY_MODEL_d3450ca5684b4a5680c114d29a7ce8f5",
+       "IPY_MODEL_61ed075433b94feda586eec035251768"
+      ],
+      "layout": "IPY_MODEL_c46be587d0fe4ef0b364f822f5ff903d"
+     }
+    },
+    "69a0d832b77e47b8a2adcf47efe3f7ab": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "69da0360a8ae4737b6e1af2e790f2b85": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_d7cc01fb605b4dd58cac287c36b6afea",
+       "IPY_MODEL_638f9ac5607b42d3a467295cb8f7c50d",
+       "IPY_MODEL_8e885a254c6f4311a3774d816e5ef5ac"
+      ],
+      "layout": "IPY_MODEL_580addd60f83499386b626c6440c6fca"
+     }
+    },
+    "69dffb139cab46b1b93bef960f702655": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b75a3d92aaa64a3098c6e1aabbc50856",
+      "placeholder": "​",
+      "style": "IPY_MODEL_3b056671c3fd41aeb4d6da821d562b95",
+      "value": "Map: 100%"
+     }
+    },
+    "6ad35d0858584acebc56da33960266e8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f8511ccf690540f088219ec747659465",
+      "max": 200,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_8aa8d5c2a96d4575b762b6ab0cbdc2c8",
+      "value": 200
+     }
+    },
+    "6af159109303490eab7192815fce0d6b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f271a7dc607b4c05b02f6c5621203bd6",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4e60ffab53dd4aba9e094098ed5297e6",
+      "value": " 3245/3245 [00:00&lt;00:00, 13400.68 examples/s]"
+     }
+    },
+    "6b1972a032af41de9bf99a6582c53f39": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_533151b377d64d3484772b3173dab306",
+      "placeholder": "​",
+      "style": "IPY_MODEL_2cd302d306e3440dac4b70fc46741544",
+      "value": "config.json: 100%"
+     }
+    },
+    "6bb5cbb9ce7645c4ad45cdf056af0445": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6bd3da08b5074e81bffbfe6d92b8ce8b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "6c3ebb812cfd493bb954a6b1d7455c72": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6c3ed2de06fe40c09315ff72d43d5c8c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6c9a5a39cb4841ba8a0b93283be0cac2": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6e1cdd75ae2246278c80f8e5d4e340b7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_df13aabfde0140d68db8b5a69759091c",
+      "max": 3245,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_cadbbc94bfd24daa933bb7d188dcdf92",
+      "value": 3245
+     }
+    },
+    "6f3679fe9b60498da864bda9ba6d899e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "6f59ae0a20cf4cc5859925e3259291a7": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6fe391246afa49e08eec5793a97690db": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "71d656fe70004c6db5d23d86bc6b108b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_9f2ecadf1f3f4e399aad1882f2fe9b00",
+       "IPY_MODEL_8826a0177e334508932a43563d2ae97d",
+       "IPY_MODEL_f9ecbb00f95548d5b0c5cad345b1e38a"
+      ],
+      "layout": "IPY_MODEL_ac78d9726bc541df9907425442d3a51a"
+     }
+    },
+    "726e82f2b6c94e8eb5620c18872aabb6": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "72858c26d6154ef3b8f90ffb0339781e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_4085f5c89ca94a31b346452cd8009dad",
+       "IPY_MODEL_47c175c19d6b4268a2ade2966327de78",
+       "IPY_MODEL_f3dc7118a9fa4b188cc3a9aaf366b125"
+      ],
+      "layout": "IPY_MODEL_9f07e155db5a473abdd7b7ae0617e770"
+     }
+    },
+    "736443c7e26642379ca66ed3e5dd34cb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8822d3a8fa794fc0addb5885a862d205",
+      "placeholder": "​",
+      "style": "IPY_MODEL_10436da727ec45c8a5e8b783696636d5",
+      "value": "Downloading readme: 100%"
+     }
+    },
+    "73a0ea365433404babb83a2d1caa9c66": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7550307b4e894844b8d032df7eea6d82": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "75c397c506a04d0d9ca62e8d7f990813": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_30b3667258174beaa01322ffa055759b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_48cb432d95dc49deae6077fb5c76bec3",
+      "value": " 3270/3270 [00:00&lt;00:00, 12552.74 examples/s]"
+     }
+    },
+    "763eec2b33234fd5ac192f25489b2844": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_f7fde1c95e3946659c6208fc52c254e9",
+       "IPY_MODEL_6e1cdd75ae2246278c80f8e5d4e340b7",
+       "IPY_MODEL_6af159109303490eab7192815fce0d6b"
+      ],
+      "layout": "IPY_MODEL_315575253cb9433d81f7d26770907f29"
+     }
+    },
+    "768735ea9663429ba9f24efd86682f71": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_aaa71d52156549a4b8d7aad390497ac3",
+      "placeholder": "​",
+      "style": "IPY_MODEL_6387cbc474144e59aac5e3b42e714887",
+      "value": " 2490/2490 [00:00&lt;00:00, 10655.89 examples/s]"
+     }
+    },
+    "76d9a70692e34521a609b337755d9901": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "775687d3962242d6aff3feb0627754a9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7aa2f62e351549058d0dc3047d3a6f37": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_a9e5b8334feb425f91ac1cf019b1569e",
+       "IPY_MODEL_6ad35d0858584acebc56da33960266e8",
+       "IPY_MODEL_ba1fc325e15743ba87a7ef20e13a67f7"
+      ],
+      "layout": "IPY_MODEL_3968997ad99444988e00d631ecca66cf"
+     }
+    },
+    "7c105cfe1f344bf7896c7ddc0fcdc322": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_0d40464e81fe4c06ac3400204116f243",
+      "placeholder": "​",
+      "style": "IPY_MODEL_69a0d832b77e47b8a2adcf47efe3f7ab",
+      "value": "Generating validation split: 100%"
+     }
+    },
+    "7d39222af2474a68b0db99f407ccf380": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "7eaee1cd25d0442092846922cdd6c413": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7ec62fad04ab4e208407902075157b33": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7edf2ac4dd264843a7838a0130668757": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "7ffe5fd0a64c40cebc784eca83154069": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8164a08b9b3f49288963539305eadabe": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "8182a23b5be640cc8a48c09a4ed9585c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "846eac2286dd4d6991f80b6ae03ce804": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "854937001e534695b08ee25f6e443962": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "855a155046904aaa9b91b01dd6a86088": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "85843fd6df264d25a4642cbeee260459": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "85f57b44dbe442a4952c65e1db4c1176": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8676e2232dc242c39d4f19b0eea90dff": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "86e235a532f347c781d6654c3ac25ba3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "874e05e0b861466ba57a08d8f5a5b7ee": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_8ebe69a07de64c3cb6dfd6433e222186",
+       "IPY_MODEL_2aceeebfd0dc42fcbbc1b3a7e1f54c56",
+       "IPY_MODEL_93c6f7c0d1ba49a295ae60a73bf509a9"
+      ],
+      "layout": "IPY_MODEL_6c3ebb812cfd493bb954a6b1d7455c72"
+     }
+    },
+    "87c361839c144bc693aa09641b06d173": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_2a02922d16cb42499cbc48e1d34a8134",
+      "max": 2000,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_1e509cb019cd47f9b3746177fad205ee",
+      "value": 2000
+     }
+    },
+    "880e13da115f4e2e9d413b75b0eecdcb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "8822d3a8fa794fc0addb5885a862d205": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8826a0177e334508932a43563d2ae97d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d38618d4c0e64b7baa61c0eca47427e5",
+      "max": 3000,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_86e235a532f347c781d6654c3ac25ba3",
+      "value": 3000
+     }
+    },
+    "88405a75b92743e589f424ee8c4d4d79": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "8851d4a04cb9410c849b6606a812c52b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "888e04dcb56f4c43954d49d3e392ab25": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_1d69552268b74bfb824c4f783e362949",
+      "max": 5428,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_de35e43c6aea490b917084a93c4571fb",
+      "value": 5428
+     }
+    },
+    "8a1465ca8728490dba4fd79730ea6a30": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8a9f0a924d53496c8a8f228738ec140d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "8aa8d5c2a96d4575b762b6ab0cbdc2c8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "8abf122ed835496aa09945ba8edd4688": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8ae15293ec5e4296a625087e7d965249": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_db067e50373840b19d6925deb950a20a",
+       "IPY_MODEL_ab409caa3be24c18becaf9146b1ae69c",
+       "IPY_MODEL_63236709413940f59d2622f2927c8d55"
+      ],
+      "layout": "IPY_MODEL_3e6d67d246e54fa497f4398e3aeddb00"
+     }
+    },
+    "8b7bb3fb502f4c3185709d6c40638d70": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8b9f3c47205d474b97efc6e9c6fb5f68": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "8cc3c0558720400e9ed89170883f6370": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "8d4df1cf62d2427b8e850b031164ff97": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8d796692add94119a4e9fdc6530a6878": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8e885a254c6f4311a3774d816e5ef5ac": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_078db166712a4daba8e99ccdf44eb16f",
+      "placeholder": "​",
+      "style": "IPY_MODEL_dde4b35063b64a28a2fd5412eb9474f0",
+      "value": " 1400/1400 [00:00&lt;00:00, 8015.40 examples/s]"
+     }
+    },
+    "8eaed8cbbf1943328dc80fc43bd5b97c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_6b1972a032af41de9bf99a6582c53f39",
+       "IPY_MODEL_b4eb16a8153048ea9aa5c9d43b44820c",
+       "IPY_MODEL_9bd66a63faf9416d9e774a5d8221c5f5"
+      ],
+      "layout": "IPY_MODEL_40b859a2fd68457db691bb5e7eb23591"
+     }
+    },
+    "8ebe69a07de64c3cb6dfd6433e222186": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a27edbdb4c824979b1b56e8fbd867595",
+      "placeholder": "​",
+      "style": "IPY_MODEL_5bdf79c178074ebf8757936190bc37b3",
+      "value": "generation_config.json: 100%"
+     }
+    },
+    "8efe1cb67f30446a8fdaaf96782e843d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f69205c589cf42829eea248f378a1436",
+      "placeholder": "​",
+      "style": "IPY_MODEL_85843fd6df264d25a4642cbeee260459",
+      "value": " 1.12M/1.12M [00:00&lt;00:00, 15.6MB/s]"
+     }
+    },
+    "8fda102684834d21b4efbb472823ced9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "8fdc7615fa0b412283eb3beb36b97872": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8ffe87ece7e54294a160540fbbbe124b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_9c3c68da285449958a3d8745bbc50305",
+       "IPY_MODEL_ae517eef5a004b16b4ae34cdf2aa851e",
+       "IPY_MODEL_08a572aefb63488d8125ae3b881c0729"
+      ],
+      "layout": "IPY_MODEL_f2131e286f704514a61b5af0785dde8b"
+     }
+    },
+    "910d8a34abaa4f92a899dd4f5ab03d74": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_abeae554ecff4bb0ad8c38fa2829f706",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a2d84cfc801f4657bade62d42be7046f",
+      "value": "Map: 100%"
+     }
+    },
+    "91cb4404dd794d22b2bbaf31eee207b5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "91e6e0685a4c4d26b6154d3ed18418eb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_ba1864322c0d49fd915e9dcc2469ef6f",
+       "IPY_MODEL_67b108def57749edb2564b3e507959a3",
+       "IPY_MODEL_c04a17f40c974f378c60858473f49fd0"
+      ],
+      "layout": "IPY_MODEL_4189c6e9c59e44d3a776b49c38cc8f06"
+     }
+    },
+    "91f821fb888046b6a2f8ade2cc58db2d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_09fa4b156f174dbcacdf976f2b39a280",
+      "max": 2424064,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_c9ca89486def4220967599e5b159b980",
+      "value": 2424064
+     }
+    },
+    "9202902fd37446cda1678c0d83e0c641": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "92bb9917ab194a1eb1dc6fc5c4c4195d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "93c6f7c0d1ba49a295ae60a73bf509a9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6f59ae0a20cf4cc5859925e3259291a7",
+      "placeholder": "​",
+      "style": "IPY_MODEL_49ac9897f49843fd8c5fed4bcdfdbb56",
+      "value": " 147/147 [00:00&lt;00:00, 9.05kB/s]"
+     }
+    },
+    "947f13ea22654b4ca6fca7ebed29d64e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "94ce06b3df27425eb8ae1a0aade4244d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_61d980530bf0408c8e2ed9a7997ba615",
+      "placeholder": "​",
+      "style": "IPY_MODEL_8a9f0a924d53496c8a8f228738ec140d",
+      "value": "Map: 100%"
+     }
+    },
+    "9557a05279544cd8a5f2ba4d3429f576": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_9edc1d5792644f79bc04d853b13dac46",
+      "placeholder": "​",
+      "style": "IPY_MODEL_1b78ff7e32254777abe2c802b6879b9c",
+      "value": " 27243/27243 [00:03&lt;00:00, 9231.48 examples/s]"
+     }
+    },
+    "96c4a19a95a94a2fa45118736d493545": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7ec62fad04ab4e208407902075157b33",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4f769b69f76a4ae885505b5e2e6751bd",
+      "value": "Map: 100%"
+     }
+    },
+    "9801a82eda354815b6b3abbc8d1e0140": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "98c677014f1a48ac804cec0714a22172": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "9ac87f9e5b7847aaa90e3208ad405c23": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "9bd66a63faf9416d9e774a5d8221c5f5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_66b0e949143e46faab77458a49a9fe1a",
+      "placeholder": "​",
+      "style": "IPY_MODEL_abd34fa3e94c49869ea7cf514dba6d1d",
+      "value": " 662/662 [00:00&lt;00:00, 25.8kB/s]"
+     }
+    },
+    "9be6c9c4f1164e0b98dfc2bc195ca959": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "9c3c68da285449958a3d8745bbc50305": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_43d9b3de4a6949f787d9733d1ae4d18e",
+      "placeholder": "​",
+      "style": "IPY_MODEL_06716294f2244cc48f78af918cc063f2",
+      "value": "model.safetensors: 100%"
+     }
+    },
+    "9d716c9e43e04a6c9496620633ca28be": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_627f32f04b544b4db834b79645f36733",
+      "placeholder": "​",
+      "style": "IPY_MODEL_7d39222af2474a68b0db99f407ccf380",
+      "value": "Generating test split: 100%"
+     }
+    },
+    "9da9d7eb9a97495194a3ac4a2786e1de": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "9e556858d4a44b5bbc3e3af87d138a55": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b63d8ddcad7745f3b4d7e683d23f393a",
+      "placeholder": "​",
+      "style": "IPY_MODEL_b83993ef787047cb9a31652fdd7f9ee7",
+      "value": " 396k/396k [00:00&lt;00:00, 9.65MB/s]"
+     }
+    },
+    "9eaafbfddcec4cdb998770d2cefc8fb7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_a9e2ae7f987b4d9d9636c3963530d8ed",
+       "IPY_MODEL_283159e7918540efa39d255f475dd984",
+       "IPY_MODEL_2f5aa471e247475691da674db1d8514c"
+      ],
+      "layout": "IPY_MODEL_c67e91be78c74ba9b816e40dd5c181ae"
+     }
+    },
+    "9edc1d5792644f79bc04d853b13dac46": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "9f07e155db5a473abdd7b7ae0617e770": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "9f1feddbe0d449a0b93fc5b1027e4319": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "9f2ecadf1f3f4e399aad1882f2fe9b00": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_854937001e534695b08ee25f6e443962",
+      "placeholder": "​",
+      "style": "IPY_MODEL_06b21316e1ef41c9b7c9d943a9ff91ec",
+      "value": "Generating test split: 100%"
+     }
+    },
+    "a08c4e6628bd440fb31eebbb2693f327": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "a098c442cc8149a5aa562c86fc64528e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8d796692add94119a4e9fdc6530a6878",
+      "placeholder": "​",
+      "style": "IPY_MODEL_9202902fd37446cda1678c0d83e0c641",
+      "value": "Generating test split: 100%"
+     }
+    },
+    "a12a6638b2a54e88a020be42c139646e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a14f26db56d04b8b840a9ce366e913e6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a17443b5713d4b60aeb85da3adce6cf2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c7c0b0fd45dc448eb9456f58e36fb3bb",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a14f26db56d04b8b840a9ce366e913e6",
+      "value": "tokenizer.json: 100%"
+     }
+    },
+    "a1f5618e59d148409d6ccf4bfffca2fa": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b17eef10573f44689ce6add6231eaa19",
+      "placeholder": "​",
+      "style": "IPY_MODEL_3e8f08e000f248b59331d2430bbc8e3c",
+      "value": "Generating validation split: 100%"
+     }
+    },
+    "a27edbdb4c824979b1b56e8fbd867595": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a2d84cfc801f4657bade62d42be7046f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a2deecc9aa3d42d381d78199f6e29d1c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_ef16f8bac38044c3b6a092caf5da320b",
+      "max": 30733,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_19e50ecdda3b493184611d97724ac1fc",
+      "value": 30733
+     }
+    },
+    "a3fd8764fe914321b0a208ea7f93e8ed": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a4097270b9b947b0ad0b3b5d217eecc0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a634013728be457ba590aa333908addd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a90285006dda4eb8a3e77964294a76ea": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a91dd2c07c51483eb326d010a82e2920": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_4188c097387a408dae680f67bd97752b",
+       "IPY_MODEL_2a6cf3f2b4c349a9adc26351c2f0b222",
+       "IPY_MODEL_8efe1cb67f30446a8fdaaf96782e843d"
+      ],
+      "layout": "IPY_MODEL_bdecbe50f693451b87bd331fd9e684ba"
+     }
+    },
+    "a9e2ae7f987b4d9d9636c3963530d8ed": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d02de13e2d7843298e61b8f47d8dee33",
+      "placeholder": "​",
+      "style": "IPY_MODEL_76d9a70692e34521a609b337755d9901",
+      "value": "Generating validation split: 100%"
+     }
+    },
+    "a9e5b8334feb425f91ac1cf019b1569e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c9bea25f8d074abf8e1b8642881f9682",
+      "placeholder": "​",
+      "style": "IPY_MODEL_af6003d8b5974787a290d25e058c09be",
+      "value": "Map: 100%"
+     }
+    },
+    "aa9d3e82fed541cca0fffe35b55aaabf": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4394b231af2f4e1499a308c93b0ff951",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4f1a59e4dff4470fb123ab315ded6e4f",
+      "value": "Map: 100%"
+     }
+    },
+    "aaa71d52156549a4b8d7aad390497ac3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ab409caa3be24c18becaf9146b1ae69c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_59ee159eec154095a368efceb9d1e042",
+      "max": 4848,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_f78c80dd733d48a687d8a47bfc792ea4",
+      "value": 4848
+     }
+    },
+    "abd34fa3e94c49869ea7cf514dba6d1d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "abeae554ecff4bb0ad8c38fa2829f706": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "abeb4c3be90344469c004e29465e1580": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "abf0151dabeb49eab089f921c8f364b5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_deb2a67f32e64ebf87758c3ace7916e8",
+      "placeholder": "​",
+      "style": "IPY_MODEL_c594b48ac5b347f78c099d581dc4cd96",
+      "value": " 5428/5428 [00:01&lt;00:00, 5428.26 examples/s]"
+     }
+    },
+    "ac78d9726bc541df9907425442d3a51a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ac81634b0e0946d690fb7d8ad7aed911": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d5eace6b280e446ead2d1517801e4612",
+      "placeholder": "​",
+      "style": "IPY_MODEL_e29da03f6e474f1ca97ecfa6cd09658c",
+      "value": " 2490/2490 [00:00&lt;00:00, 10598.83 examples/s]"
+     }
+    },
+    "ac83130fdd374b7c8f41e0f8f011ecae": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "ae517eef5a004b16b4ae34cdf2aa851e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e69b0005e91a478297d17e4089cda650",
+      "max": 3132668804,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_f92f9afc2c694f0cbcdf4ebcca98221e",
+      "value": 3132668804
+     }
+    },
+    "af6003d8b5974787a290d25e058c09be": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "af9af54477cc4972bf0f0a99c1344974": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "b0053efc5ecc411f902fcf3b19cd362e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "b02796bf6e5547cf9418d109ad772537": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8abf122ed835496aa09945ba8edd4688",
+      "placeholder": "​",
+      "style": "IPY_MODEL_663b9bd2f1af4df4b757624f53c2f2b8",
+      "value": "Generating train split: 100%"
+     }
+    },
+    "b10768b6bc654da8b822b4878889639b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "b17eef10573f44689ce6add6231eaa19": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b1ad08dbe61b4064985ecdaa119870d8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_ee1a9269b6c843e28cc49f3b5f17da96",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a12a6638b2a54e88a020be42c139646e",
+      "value": " 9427/9427 [00:00&lt;00:00, 15118.09 examples/s]"
+     }
+    },
+    "b1cad4191755493893bbb46dcf27e03b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "b38693117df44071b7baaf123215ea60": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_9d716c9e43e04a6c9496620633ca28be",
+       "IPY_MODEL_4de322f2413f44bcb03d41dcc8ff1963",
+       "IPY_MODEL_3087335b98964b9eb4da474487ca4864"
+      ],
+      "layout": "IPY_MODEL_c010fad90578489cbfeb0764e3a11286"
+     }
+    },
+    "b3a18689eefa4660997034094df0df04": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b3d7aad60442432e96c8c8bd3ead8427": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b4a5fdee693d455686507306da804b17": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "b4eb16a8153048ea9aa5c9d43b44820c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_41b36d52e98249b1b506d369d2d8e994",
+      "max": 662,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_ac83130fdd374b7c8f41e0f8f011ecae",
+      "value": 662
+     }
+    },
+    "b5e3536d816c45488bb83336eaa5d53f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_b9bed2c861df4c019ab4fff46b11a1a3",
+       "IPY_MODEL_35bf380a7c6243859a459560288ffe49",
+       "IPY_MODEL_b65af12dbf9143778412adb7b4c0bfdd"
+      ],
+      "layout": "IPY_MODEL_cb2433a0096845468b26c4bbde625ed8"
+     }
+    },
+    "b63d8ddcad7745f3b4d7e683d23f393a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b65af12dbf9143778412adb7b4c0bfdd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c56ea889f51848e4aed83bcc46c83395",
+      "placeholder": "​",
+      "style": "IPY_MODEL_c75508086f6f4406a0aa9ce5a391e0ee",
+      "value": " 751k/751k [00:00&lt;00:00, 10.1MB/s]"
+     }
+    },
+    "b75a3d92aaa64a3098c6e1aabbc50856": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b7f169f931074d1283cbfe912f11ba98": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6c9a5a39cb4841ba8a0b93283be0cac2",
+      "placeholder": "​",
+      "style": "IPY_MODEL_2deb046362ed4570a3f550f4f288529e",
+      "value": " 9427/9427 [00:00&lt;00:00, 14979.66 examples/s]"
+     }
+    },
+    "b83993ef787047cb9a31652fdd7f9ee7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "b8ccdebb7b11490e8222ff79ecfc9a33": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "b9bed2c861df4c019ab4fff46b11a1a3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8d4df1cf62d2427b8e850b031164ff97",
+      "placeholder": "​",
+      "style": "IPY_MODEL_0fd8ca256b8b49e1906a2a8e21156164",
+      "value": "Downloading data: 100%"
+     }
+    },
+    "b9ec517b4b084d548525ac41381ef69e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ba1864322c0d49fd915e9dcc2469ef6f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7550307b4e894844b8d032df7eea6d82",
+      "placeholder": "​",
+      "style": "IPY_MODEL_bcf20733fb504a71be5cf0455928b587",
+      "value": "Downloading metadata: 100%"
+     }
+    },
+    "ba1fc325e15743ba87a7ef20e13a67f7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a3fd8764fe914321b0a208ea7f93e8ed",
+      "placeholder": "​",
+      "style": "IPY_MODEL_9be6c9c4f1164e0b98dfc2bc195ca959",
+      "value": " 200/200 [00:00&lt;00:00, 971.10 examples/s]"
+     }
+    },
+    "ba3a7258734b4edb86b8eef074d65222": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_4b3dc87d00ed42b0956d0bfa39bd466f",
+       "IPY_MODEL_2c5eaf38e66d492d8661852cacc4e527",
+       "IPY_MODEL_b7f169f931074d1283cbfe912f11ba98"
+      ],
+      "layout": "IPY_MODEL_e86771ea303a4b1b86ecf5128f3ea421"
+     }
+    },
+    "badae7117ab644ffa80d099c17397329": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_2cd168e5e3c4481ba151aa8a655e7ce8",
+      "max": 9693,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_f773b949a9cf46ca9fd56476398a3191",
+      "value": 9693
+     }
+    },
+    "bb468a6fe3f04692a211d5519aec455a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_cd7371ff8504454292559c18adb76645",
+      "max": 9427,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_d4994c6d7fa240d0ac6bb31f5c835192",
+      "value": 9427
+     }
+    },
+    "bb99715a25d94422b0048de94f2fe563": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "bc265b1f822348469e3c8df0ea608abb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "bcf20733fb504a71be5cf0455928b587": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "bdecbe50f693451b87bd331fd9e684ba": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "be70aecc5b294c4c93b0dcc09d6d1cb3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_589120da6f464686bbeff0d44643d17d",
+      "placeholder": "​",
+      "style": "IPY_MODEL_ea89ea173ff3482c8a9c91dfb15946b2",
+      "value": " 3270/3270 [00:00&lt;00:00, 11997.91 examples/s]"
+     }
+    },
+    "bebb055c0ac14d59a8b617399d60e602": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_0d56de85d9244f38a8a0b3d84ee5d7da",
+      "placeholder": "​",
+      "style": "IPY_MODEL_b0053efc5ecc411f902fcf3b19cd362e",
+      "value": "Generating train split: 100%"
+     }
+    },
+    "bf1d0b17974049c6ac5653ac18f1169c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c010fad90578489cbfeb0764e3a11286": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c04a17f40c974f378c60858473f49fd0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_03d340641a414362b0356e8178148d9a",
+      "placeholder": "​",
+      "style": "IPY_MODEL_61fec3b2596c4803924ed1fb087d52d1",
+      "value": " 38.7k/38.7k [00:00&lt;00:00, 406kB/s]"
+     }
+    },
+    "c1e065fa36344f509e7863c3ec0428b8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_53acddb088564a73aef61618797bfe85",
+      "max": 4848,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_fb208f3792174ac2bdfb077450b2218f",
+      "value": 4848
+     }
+    },
+    "c1f71dcbe98f4ee9847af6b800979e06": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_947f13ea22654b4ca6fca7ebed29d64e",
+      "max": 277,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_45becb2c72714dfcb721b3a20a92d28f",
+      "value": 277
+     }
+    },
+    "c2a415c28fe0418bb6032d4b91efbb07": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_b02796bf6e5547cf9418d109ad772537",
+       "IPY_MODEL_de7a527901014a6b8abf6b714bd09535",
+       "IPY_MODEL_143eaab6e65f4c8eb7a4314cadf323ba"
+      ],
+      "layout": "IPY_MODEL_e0603f00ceb2468692a36abd7bafaba8"
+     }
+    },
+    "c2ed87d5599a467bba084cddb9e40713": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c352adea84b043db8d43eb1c36d4bd4f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c3aa97f46a60409091dc4d33a946c6d3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_e6315c5d217b4922b461c9ac22528e62",
+       "IPY_MODEL_04c34c92e4374c50bd0636c72953a8ba",
+       "IPY_MODEL_32a6ac79c27e47c1a4b32098bfe25807"
+      ],
+      "layout": "IPY_MODEL_bb99715a25d94422b0048de94f2fe563"
+     }
+    },
+    "c3e198ae77684d61bf5fc30a35d8fc11": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "c46be587d0fe4ef0b364f822f5ff903d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c4fce7e5a2b44835ab8723e0022d1e50": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "c56ea889f51848e4aed83bcc46c83395": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c594b48ac5b347f78c099d581dc4cd96": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "c67e91be78c74ba9b816e40dd5c181ae": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c6a00e1b00684bb7930fb27d6499932e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c6f31bcf48de4d9fbc7f2a2d9984b247": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "c75508086f6f4406a0aa9ce5a391e0ee": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "c7c0b0fd45dc448eb9456f58e36fb3bb": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c7f7e4ee797749c0939c9a3926937b41": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c870763add1745d9acfc2762f468c984": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d8886d5af17f4468a26554831c9c05f1",
+      "max": 3270,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_b1cad4191755493893bbb46dcf27e03b",
+      "value": 3270
+     }
+    },
+    "c9bea25f8d074abf8e1b8642881f9682": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c9ca89486def4220967599e5b159b980": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "cadbbc94bfd24daa933bb7d188dcdf92": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "cb21cadacb294854b304af8df2157299": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "cb2433a0096845468b26c4bbde625ed8": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "cc6c1b2d4fcb4ffea016a139738e1ead": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "cd7371ff8504454292559c18adb76645": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "cf0be710991a46ecb9beefe1feaa9e2f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d02de13e2d7843298e61b8f47d8dee33": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d190000c9f254975aafd134ca775d6ad": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_96c4a19a95a94a2fa45118736d493545",
+       "IPY_MODEL_87c361839c144bc693aa09641b06d173",
+       "IPY_MODEL_45599b40bcbb4baf83bc87be0ae509d0"
+      ],
+      "layout": "IPY_MODEL_5b90309f747446a3b17badf1c42539bb"
+     }
+    },
+    "d1d2687d51a4442d8555ed4071837da4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_620e2fa48504435a85d95c2d4b264b6e",
+      "placeholder": "​",
+      "style": "IPY_MODEL_af9af54477cc4972bf0f0a99c1344974",
+      "value": "Downloading data: 100%"
+     }
+    },
+    "d3450ca5684b4a5680c114d29a7ce8f5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_0dbdea008e964ad887f112336be78449",
+      "max": 638,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_47977de9d961442682805f37f7217387",
+      "value": 638
+     }
+    },
+    "d38618d4c0e64b7baa61c0eca47427e5": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d43db93804c24908bb6d75f26b640199": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "d4994c6d7fa240d0ac6bb31f5c835192": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "d49e405525ec467bb7a69a9aaedf82d9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d5542140ebd34dfaa8c66f2f3e48fe92": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "d5eace6b280e446ead2d1517801e4612": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d622b006621e4110a157fb4cb43c9762": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "d6250bff76d7454a8216572ab28e4a72": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_384d10ea2a354f24bae33c3a1d564b82",
+       "IPY_MODEL_a2deecc9aa3d42d381d78199f6e29d1c",
+       "IPY_MODEL_17fc618034bf4aadaef811b0e7c80eed"
+      ],
+      "layout": "IPY_MODEL_6757bc0834fc4e69b7b588ae6de14ec9"
+     }
+    },
+    "d6754db1364144e69e3ab320aa1faeb9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "d725549ca34a4d54ae684e7e4741be29": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d7cc01fb605b4dd58cac287c36b6afea": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6bb5cbb9ce7645c4ad45cdf056af0445",
+      "placeholder": "​",
+      "style": "IPY_MODEL_2e3ea9571d364a40aa9917a6f49b45f7",
+      "value": "Generating test split: 100%"
+     }
+    },
+    "d7e07795e63c4ab78ca92961ba089b07": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c7f7e4ee797749c0939c9a3926937b41",
+      "placeholder": "​",
+      "style": "IPY_MODEL_2a4d28248796477994a17db0fb8485dc",
+      "value": "Map: 100%"
+     }
+    },
+    "d8594695c03e4fb7965dcbe04074d4eb": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d86eb0ba47884ab081128a8761e9654b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d8886d5af17f4468a26554831c9c05f1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d91093e80b814a018edaabe49f529ef5": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d92dbe59ace74f598efc7fbedb4c5ee6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_675c937cf0ef4bf582f4bf90df6fa28e",
+       "IPY_MODEL_e1cf760846bd4ba988c29665a6593220",
+       "IPY_MODEL_768735ea9663429ba9f24efd86682f71"
+      ],
+      "layout": "IPY_MODEL_4d2a10e9307a47f4a1cbf512380c65bc"
+     }
+    },
+    "d94392afd01246ff942af838a995379e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "da0dfe11648d4ae8a70852ce1fac87b0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_29ad37e81b7f44a9aafa982b52f05a7a",
+       "IPY_MODEL_bb468a6fe3f04692a211d5519aec455a",
+       "IPY_MODEL_b1ad08dbe61b4064985ecdaa119870d8"
+      ],
+      "layout": "IPY_MODEL_d91093e80b814a018edaabe49f529ef5"
+     }
+    },
+    "da21830428b54f76aa31b03efce202b9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "daf61ecd65bd41d9829e8a1872b82f33": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "db067e50373840b19d6925deb950a20a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_118967bdd4a348858cc7572d36c1b736",
+      "placeholder": "​",
+      "style": "IPY_MODEL_8cc3c0558720400e9ed89170883f6370",
+      "value": "Generating validation split: 100%"
+     }
+    },
+    "dc5d4672fcd149239cfe1a837094ce53": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_eded01d7629e4a4faad592e8e20a3ca3",
+       "IPY_MODEL_5d1e94d40f514faaa5819096f167d29c",
+       "IPY_MODEL_f98f73664a974ae7804e494425fbe20d"
+      ],
+      "layout": "IPY_MODEL_1c0bd751a3294b8ea0cf828866169121"
+     }
+    },
+    "dde4b35063b64a28a2fd5412eb9474f0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "de35e43c6aea490b917084a93c4571fb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "de7a527901014a6b8abf6b714bd09535": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c352adea84b043db8d43eb1c36d4bd4f",
+      "max": 27243,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_8fda102684834d21b4efbb472823ced9",
+      "value": 27243
+     }
+    },
+    "deb2a67f32e64ebf87758c3ace7916e8": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "df13aabfde0140d68db8b5a69759091c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e0603f00ceb2468692a36abd7bafaba8": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e12dbfa20e9d40448366c9528c1a2c02": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4ddb5f1d8260448981c67308bcedecbf",
+      "placeholder": "​",
+      "style": "IPY_MODEL_d43db93804c24908bb6d75f26b640199",
+      "value": " 277/277 [00:00&lt;00:00, 5590.76 examples/s]"
+     }
+    },
+    "e1cf760846bd4ba988c29665a6593220": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8182a23b5be640cc8a48c09a4ed9585c",
+      "max": 2490,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_c3e198ae77684d61bf5fc30a35d8fc11",
+      "value": 2490
+     }
+    },
+    "e227fb95b00b4af8b82286c75db84611": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "e29da03f6e474f1ca97ecfa6cd09658c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "e6315c5d217b4922b461c9ac22528e62": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_637bbd213f3345178742523d055993e6",
+      "placeholder": "​",
+      "style": "IPY_MODEL_6113f1920c5743aa8f2c6cc9739029e1",
+      "value": "special_tokens_map.json: 100%"
+     }
+    },
+    "e69b0005e91a478297d17e4089cda650": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e77316215dbe41daa8e89d8b2cc0f032": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_591e6dc92b5c44418260cf659c5807cf",
+      "max": 277,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_2bd3c665eb784f149dc21853103e8ff0",
+      "value": 277
+     }
+    },
+    "e7dc30a09a64401393e43618b51059de": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_9ac87f9e5b7847aaa90e3208ad405c23",
+      "max": 3270,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_cb21cadacb294854b304af8df2157299",
+      "value": 3270
+     }
+    },
+    "e86771ea303a4b1b86ecf5128f3ea421": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e8738d4181b04545a0418c1dd5b6b1b5": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e8ab0bcb4d7f4a298b2b3555d866a11f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_60ab33e3e0d84395a1269604f0fae91f",
+      "max": 3000,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_64d829532bb94214b805c2de4cf529cc",
+      "value": 3000
+     }
+    },
+    "ea89ea173ff3482c8a9c91dfb15946b2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "eb7e509acfea4e1bb2f59b2fde11603d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ec33a4325b6f4dcfb8a9fa4c80a5c704": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_85f57b44dbe442a4952c65e1db4c1176",
+      "max": 791656,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_3f173a7293cd4ff8a54da8c8174cfb43",
+      "value": 791656
+     }
+    },
+    "ec94298c63ab4b0e83c074a9d2ed4fc9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ecff5b6dfb784c96b69d1a39b7acb171": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4728eddf9fcc49d68d71a30379f08335",
+      "max": 9693,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_8676e2232dc242c39d4f19b0eea90dff",
+      "value": 9693
+     }
+    },
+    "eded01d7629e4a4faad592e8e20a3ca3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6c3ed2de06fe40c09315ff72d43d5c8c",
+      "placeholder": "​",
+      "style": "IPY_MODEL_2e3d6b5d46db4295829002fc311a9c74",
+      "value": "tokenizer_config.json: 100%"
+     }
+    },
+    "ee1a9269b6c843e28cc49f3b5f17da96": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ee7eccaca57b4460becfe0d5d5afb3f9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "eed4b0b927824444aa8d875281cca1c4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a90285006dda4eb8a3e77964294a76ea",
+      "placeholder": "​",
+      "style": "IPY_MODEL_8164a08b9b3f49288963539305eadabe",
+      "value": "Map: 100%"
+     }
+    },
+    "eeff19b29a6a4c6d9ae34e365c78c310": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_a098c442cc8149a5aa562c86fc64528e",
+       "IPY_MODEL_badae7117ab644ffa80d099c17397329",
+       "IPY_MODEL_13ccc23d506248d5b66ffe7732ead149"
+      ],
+      "layout": "IPY_MODEL_16938b11881741af8e6633094a4402dc"
+     }
+    },
+    "ef16f8bac38044c3b6a092caf5da320b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "efc4f9ade28a4bb2a67c0ae4ceecbf28": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_7c105cfe1f344bf7896c7ddc0fcdc322",
+       "IPY_MODEL_c1f71dcbe98f4ee9847af6b800979e06",
+       "IPY_MODEL_e12dbfa20e9d40448366c9528c1a2c02"
+      ],
+      "layout": "IPY_MODEL_b3d7aad60442432e96c8c8bd3ead8427"
+     }
+    },
+    "f12d118a6b3f46b580fbe2018f4cf5e9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f2131e286f704514a61b5af0785dde8b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f271a7dc607b4c05b02f6c5621203bd6": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f3dc7118a9fa4b188cc3a9aaf366b125": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_fe7d093f30854ee1b66f080c5b8fb68b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_880e13da115f4e2e9d413b75b0eecdcb",
+      "value": " 1400/1400 [00:00&lt;00:00, 1642.54 examples/s]"
+     }
+    },
+    "f4ee33b4a2d145bab3c5c2e14c73a3f8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_bebb055c0ac14d59a8b617399d60e602",
+       "IPY_MODEL_888e04dcb56f4c43954d49d3e392ab25",
+       "IPY_MODEL_6058ac7bc0b345ee8f5d2f631b7b6940"
+      ],
+      "layout": "IPY_MODEL_ec94298c63ab4b0e83c074a9d2ed4fc9"
+     }
+    },
+    "f577bbac4eab439b9ccea0a49eb99d86": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f69205c589cf42829eea248f378a1436": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f6a6f03ea7f140189a277742ff7082f8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_bf1d0b17974049c6ac5653ac18f1169c",
+      "placeholder": "​",
+      "style": "IPY_MODEL_32672cb3395045bcb9c2d370032356cc",
+      "value": "Map: 100%"
+     }
+    },
+    "f773b949a9cf46ca9fd56476398a3191": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "f78c80dd733d48a687d8a47bfc792ea4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "f7fde1c95e3946659c6208fc52c254e9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_daf61ecd65bd41d9829e8a1872b82f33",
+      "placeholder": "​",
+      "style": "IPY_MODEL_54823295494d441fb9f26a70fb2c3973",
+      "value": "Map: 100%"
+     }
+    },
+    "f8511ccf690540f088219ec747659465": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f860e1c3467348f0802b733fbef45c15": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "f92f9afc2c694f0cbcdf4ebcca98221e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "f972a2e10dde405c8aec8f7cd1be4317": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "f98f73664a974ae7804e494425fbe20d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_379357ab63f5479fad469c181b054bb0",
+      "placeholder": "​",
+      "style": "IPY_MODEL_f860e1c3467348f0802b733fbef45c15",
+      "value": " 2.54k/2.54k [00:00&lt;00:00, 92.6kB/s]"
+     }
+    },
+    "f9ecbb00f95548d5b0c5cad345b1e38a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_1727de01c47144b2958babfb91e887cb",
+      "placeholder": "​",
+      "style": "IPY_MODEL_5ac310c605f64948ad744bc1f196441d",
+      "value": " 3000/3000 [00:00&lt;00:00, 10931.75 examples/s]"
+     }
+    },
+    "fb208f3792174ac2bdfb077450b2218f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "fbd92ad5a793482aac5570387e917188": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_06a2114630234393bc0f07b3a64455f8",
+      "max": 2490,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_c6f31bcf48de4d9fbc7f2a2d9984b247",
+      "value": 2490
+     }
+    },
+    "fcdb61acbf0d470f881ba8f283360e0f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_10d7a41588744be1b29678b4a9dfdd27",
+      "placeholder": "​",
+      "style": "IPY_MODEL_c4fce7e5a2b44835ab8723e0022d1e50",
+      "value": " 4.12M/4.12M [00:00&lt;00:00, 28.2MB/s]"
+     }
+    },
+    "fe7d093f30854ee1b66f080c5b8fb68b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ff00f4c2c63a467098b119ae2259f529": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    }
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/psoft_finetuning/README.md b/examples/psoft_finetuning/README.md
new file mode 100644
index 0000000..4bef1ba
--- /dev/null
+++ b/examples/psoft_finetuning/README.md
@@ -0,0 +1,77 @@
+# Efficient Orthogonal Fine-Tuning with Principal Subspace Adaptation (PSOFT) 
+## Introduction ([Paper](https://huggingface.co/papers/2505.11235), [code](https://github.com/fei407/PSOFT))
+PSOFT aims to preserve the geometric relationships among pre-trained weight column vectors—a core principle of OFT—while achieving a balanced trade-off across parameter, computation, and memory efficiency. Unlike existing OFT variants (e.g., OFTv2, BOFT, and GOFT) that rely on sparsity-based designs, PSOFT adopts a low-rank principal subspace perspective, bridging the gap between LoRA and OFT. PSOFT confines orthogonal fine-tuning to a principal subspace, offering theoretical guarantees via orthogonality constraints on the down-projection matrix, while enabling practical adaptability through two low-dimensional tunable vectors.
+
+
+## Quick Start
+```python
+import torch
+from peft import PsoftConfig, get_peft_model
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from trl import SFTConfig, SFTTrainer
+from datasets import load_dataset
+
+model_name = "facebook/opt-125m"
+
+model = AutoModelForCausalLM.from_pretrained(model_name)
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+tokenizer.pad_token_id = tokenizer.eos_token_id
+
+psoft_config = PsoftConfig(
+    r=32,
+    psoft_alpha=32,
+)
+
+peft_model = get_peft_model(model, psoft_config)
+peft_model.print_trainable_parameters()
+
+dataset = load_dataset("imdb", split="train[:1%]")
+
+training_args = SFTConfig(dataset_text_field="text", max_length=128)
+
+trainer = SFTTrainer(
+    model=peft_model,
+    args=training_args,
+    train_dataset=dataset,
+    processing_class=tokenizer,
+)
+
+trainer.train()
+peft_model.save_pretrained("psoft-opt-125m")
+```
+
+## Further examples on LLaMA-3.2-3B 
+```shell
+python psoft_finetuning.py \
+  --base_model_name_or_path meta-llama/Llama-3.2-3B \
+  --output_dir ./outputs/psoft-llama3.2-3b-imdb \
+  --data_path imdb \
+  --dataset_split "train[:1%]" \
+  --max_length 128 \
+  --num_train_epochs 1 \
+  --per_device_train_batch_size 1 \
+  --gradient_accumulation_steps 8 \
+  --learning_rate 5e-4 \
+  --bits bf16 \
+  --r 128 \
+  --psoft_alpha 128 \
+  --target_modules q_proj v_proj
+```
+
+## Best Practices
+1. **Rank Choice**: Smaller ranks (e.g., `32–128`) are suitable for simpler tasks, while larger ranks (e.g., `64–256`) provide greater expressiveness for more complex tasks at the cost of increased parameters and computation.
+2. **Scaling Factor**: The scaling factor is typically set to $r$ in PSOFT.
+3. **Learning Rate**: Use standard learning rates (e.g., `1e-4` to `5e-3`) for stable training.
+4. **SVD Initialization**: The `lowrank` option is more memory- and compute-efficient than `full`, making it more suitable for large models.
+5. **Cayley–Neumann Approximation**: When the rank is large, enabling the Cayley–Neumann approximation can significantly improve computational efficiency, while the benefit is less pronounced for small ranks. In practice, a small number of Neumann series terms (typically `5`) usually provides a good balance between accuracy and efficiency.
+
+## Citation
+```
+@inproceedings{wu2026efficient,
+title={Efficient Orthogonal Fine-Tuning with Principal Subspace Adaptation},
+author={Wu, Fei and Hu, Jia and Min, Geyong and Wang, Shiqiang},
+booktitle={The Fourteenth International Conference on Learning Representations},
+year={2026},
+url={https://openreview.net/forum?id=FSHrinMArK}
+}
+```
\ No newline at end of file
diff --git a/examples/psoft_finetuning/psoft_finetuning.py b/examples/psoft_finetuning/psoft_finetuning.py
new file mode 100644
index 0000000..642c64b
--- /dev/null
+++ b/examples/psoft_finetuning/psoft_finetuning.py
@@ -0,0 +1,182 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+import os
+from dataclasses import dataclass, field
+from typing import Optional
+
+import torch
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoTokenizer, HfArgumentParser
+from trl import SFTConfig, SFTTrainer
+
+from peft import PsoftConfig, get_peft_model
+
+
+@dataclass
+class ScriptArguments(SFTConfig):
+    # --- model ---
+    base_model_name_or_path: Optional[str] = field(
+        default=None, metadata={"help": "The name or path of the fp32/16 base model."}
+    )
+    bits: str = field(
+        default="fp32",
+        metadata={"help": "Precision to load the base model. Choices: ['bf16', 'fp16', 'fp32']."},
+    )
+
+    # --- PSOFT ---
+    r: int = field(default=32, metadata={"help": "Rank (r): dimension of trainable R."})
+    psoft_alpha: int = field(default=32, metadata={"help": "Scaling factor (typically set to r)."})
+    target_modules: list[str] = field(
+        default_factory=lambda: ["q_proj", "v_proj"],
+        metadata={"help": "Target module names, e.g. ['q_proj','k_proj','v_proj','o_proj', ...]."},
+    )
+
+    # SVD / init
+    ab_svd_init: str = field(
+        default="psoft_init",
+        metadata={"help": "Principal-subspace init identifier (e.g. 'psoft_init')."},
+    )
+    psoft_svd: str = field(
+        default="full",
+        metadata={"help": "SVD method. Typical choices: ['full', 'lowrank']."},
+    )
+    psoft_svd_lowrank_niter: Optional[int] = field(
+        default=None,
+        metadata={"help": "If psoft_svd='lowrank', number of iterations for lowrank SVD (optional)."},
+    )
+
+    # Orth / relaxation
+    psoft_orth: bool = field(default=True, metadata={"help": "Use orthogonal R (Cayley parameterization)."})
+    psoft_mag_a: bool = field(default=True, metadata={"help": "Enable tunable vector alpha (relaxed mode)."})
+    psoft_mag_b: bool = field(default=True, metadata={"help": "Enable tunable vector beta (relaxed mode)."})
+
+    # Cayley–Neumann approximation
+    use_cayley_neumann: bool = field(default=False, metadata={"help": "Enable Cayley-Neumann approximation."})
+    num_cayley_neumann_terms: int = field(default=5, metadata={"help": "Number of Neumann series terms."})
+    cayley_neumann_eps: Optional[float] = field(
+        default=None, metadata={"help": "Optional eps for numerical stability."}
+    )
+
+    # --- data ---
+    data_path: str = field(default="imdb", metadata={"help": "Dataset name/path for training."})
+    dataset_split: str = field(default="train[:1%]", metadata={"help": "Dataset split, e.g. 'train[:1%]'."})
+    dataset_field: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "Fields used to build SFT text. "
+                "If provided, will build: '### USER: <field0>\\n### ASSISTANT: <field1>'. "
+                "If None, must already have a 'text' column."
+            )
+        },
+    )
+
+
+def _dtype_from_bits(bits: str) -> torch.dtype:
+    bits = bits.lower()
+    if bits == "bf16":
+        return torch.bfloat16
+    if bits == "fp16":
+        return torch.float16
+    if bits == "fp32":
+        return torch.float32
+    raise ValueError(f"Unknown bits={bits}. Use one of: bf16, fp16, fp32.")
+
+
+def main():
+    parser = HfArgumentParser(ScriptArguments)
+    script_args = parser.parse_args_into_dataclasses()[0]
+    print(script_args)
+
+    if script_args.base_model_name_or_path is None:
+        raise ValueError("--base_model_name_or_path is required.")
+
+    # PSOFT does NOT support quantized layers (nf4/int8/etc.).
+    # We only allow fp16/bf16/fp32 here to avoid accidental quantized loading.
+    if script_args.bits.lower() not in {"bf16", "fp16", "fp32"}:
+        raise ValueError("PSOFT example only supports bits in ['bf16','fp16','fp32'] (no quantization).")
+
+    torch_dtype = _dtype_from_bits(script_args.bits)
+
+    # Load base model
+    model = AutoModelForCausalLM.from_pretrained(
+        script_args.base_model_name_or_path,
+        dtype=torch_dtype,
+        device_map="auto",
+    )
+    tokenizer = AutoTokenizer.from_pretrained(script_args.base_model_name_or_path)
+    if tokenizer.pad_token_id is None:
+        tokenizer.pad_token_id = tokenizer.eos_token_id
+
+    # Build PSOFT config
+    psoft_kwargs = {
+        "r": script_args.r,
+        "psoft_alpha": script_args.psoft_alpha,
+        "target_modules": script_args.target_modules,
+        "ab_svd_init": script_args.ab_svd_init,
+        "psoft_svd": script_args.psoft_svd,
+        "psoft_orth": script_args.psoft_orth,
+        "psoft_mag_a": script_args.psoft_mag_a,
+        "psoft_mag_b": script_args.psoft_mag_b,
+        "use_cayley_neumann": script_args.use_cayley_neumann,
+        "num_cayley_neumann_terms": script_args.num_cayley_neumann_terms,
+        "cayley_neumann_eps": script_args.cayley_neumann_eps,
+        "task_type": "CAUSAL_LM",
+    }
+    # Only pass lowrank_niter when user sets it (and typically when psoft_svd='lowrank')
+    if script_args.psoft_svd_lowrank_niter is not None:
+        psoft_kwargs["psoft_svd_lowrank_niter"] = script_args.psoft_svd_lowrank_niter
+
+    peft_config = PsoftConfig(**psoft_kwargs)
+    model = get_peft_model(model, peft_config)
+
+    model.print_trainable_parameters()
+
+    # Load dataset
+    dataset = load_dataset(script_args.data_path, split=script_args.dataset_split)
+
+    # Ensure a "text" field for SFTTrainer
+    if script_args.dataset_field is not None:
+        if len(script_args.dataset_field) != 2:
+            raise ValueError("dataset_field must be a list of exactly 2 field names: [input_field, output_field].")
+
+        in_f, out_f = script_args.dataset_field[0], script_args.dataset_field[1]
+
+        def to_sft_text(example):
+            return {"text": f"### USER: {example[in_f]}\n### ASSISTANT: {example[out_f]}"}
+
+        dataset = dataset.map(to_sft_text)
+    else:
+        if "text" not in dataset.column_names:
+            raise ValueError("dataset_field is None but dataset has no 'text' column. Provide dataset_field.")
+
+    # Train
+    trainer = SFTTrainer(
+        model=model,
+        args=script_args,
+        train_dataset=dataset,
+        processing_class=tokenizer,
+    )
+    trainer.train()
+    trainer.save_state()
+
+    # Save adapter (PSOFT)
+    os.makedirs(script_args.output_dir, exist_ok=True)
+    model.save_pretrained(os.path.join(script_args.output_dir, "psoft_ft"))
+    tokenizer.save_pretrained(os.path.join(script_args.output_dir, "psoft_ft"))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/pvera/README.md b/examples/pvera/README.md
new file mode 100644
index 0000000..3d5f7ed
--- /dev/null
+++ b/examples/pvera/README.md
@@ -0,0 +1,3 @@
+# Generating confidence intervals with PVeRA
+
+In normal mode, PVeRA samples from the learned distribution during training, and does a deterministic sample during inference at the learned latent distribution mean. Setting `sample_at_inference=True` enables to generate Monte Carlo confidence interval estimations by running multiple passes through each sample. The accompanying `examples/pvera/confidence_interval_generation.py` script shows an example of training a model on a simple dataset, saving the adapters, loading them with ```sample_at_inference=True```, and running a Monte Carlo confidence interval estimation on a sample.
\ No newline at end of file
diff --git a/examples/pvera/confidence_interval_generation.py b/examples/pvera/confidence_interval_generation.py
new file mode 100644
index 0000000..4e79fda
--- /dev/null
+++ b/examples/pvera/confidence_interval_generation.py
@@ -0,0 +1,75 @@
+import tempfile
+
+import numpy as np
+import scipy
+import torch
+from datasets import load_dataset
+from torch.nn import LazyLinear, Sequential, Softmax
+from torchvision.transforms import Compose, Normalize, Resize
+from tqdm import tqdm
+from transformers import AutoModel
+
+from peft import PeftModel, PveraConfig, get_peft_model
+
+
+# load the dataset
+device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+dataset = load_dataset("beans", split="train").with_format("torch")
+transform = Compose((Resize((224, 224)), Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))))
+num_classes = dataset.features["labels"].num_classes
+
+# load the model with adapters and create the linear probe
+base_model = AutoModel.from_pretrained("facebook/dinov2-base")
+config = PveraConfig(r=128, sample_at_inference=False)
+model = get_peft_model(base_model, config).to(device)
+linear_probe = Sequential(LazyLinear(num_classes), Softmax(-1)).to(device)
+
+# train the model
+criterion = torch.nn.CrossEntropyLoss()
+optimizer = torch.optim.Adam(list(model.parameters()) + list(linear_probe.parameters()), lr=1e-4)
+dataloader = torch.utils.data.DataLoader(dataset, batch_size=32, shuffle=True)
+for batch in tqdm(dataloader):
+    imgs, lbls = transform(batch["image"].float()), batch["labels"]
+    pred = linear_probe(model(imgs.to(device)).pooler_output)
+    loss = criterion(pred, lbls.to(device))
+    loss.backward()
+    optimizer.step()
+
+# save the model and load it with sample_at_inference=True
+model.eval()
+linear_probe.eval()
+with tempfile.TemporaryDirectory() as tmpdir:
+    # save the model and the linear probe
+    model.save_pretrained(tmpdir)
+    torch.save(linear_probe.state_dict(), tmpdir + "/linear_probe.bin")
+
+    # load the model with sample_at_inference=True
+    base_model = AutoModel.from_pretrained("facebook/dinov2-base")
+    config = PveraConfig.from_pretrained(tmpdir)
+    config.sample_at_inference = True
+    loaded_model = PeftModel.from_pretrained(base_model, tmpdir, config=config).to(device)
+    loaded_model.eval()
+
+    # load the linear probe
+    loaded_linear_probe = Sequential(LazyLinear(num_classes), Softmax(-1)).to(device)
+    loaded_linear_probe.load_state_dict(torch.load(tmpdir + "/linear_probe.bin"))
+    loaded_linear_probe.eval()
+
+# make multiple predictions on an image
+img = dataset[0]["image"].unsqueeze(0).to(device)
+with torch.no_grad():
+    all_preds = [loaded_linear_probe(loaded_model(img).pooler_output) for _ in range(16)]
+all_preds = torch.vstack(all_preds)
+top_pred = all_preds.argmax(-1).mode(0).values
+softmax_top_pred = all_preds[:, top_pred]
+
+
+def mean_confidence_interval(data, confidence=0.95):
+    a = 1.0 * np.array(data)
+    n = len(a)
+    m, se = np.mean(a), scipy.stats.sem(a)
+    h = se * scipy.stats.t.ppf((1 + confidence) / 2.0, n - 1)
+    return max(0, m - h), min(1, m + h)
+
+
+print(mean_confidence_interval(softmax_top_pred.cpu()))
diff --git a/examples/qalora_finetuning/README.md b/examples/qalora_finetuning/README.md
new file mode 100644
index 0000000..a1dfea1
--- /dev/null
+++ b/examples/qalora_finetuning/README.md
@@ -0,0 +1,157 @@
+# QALoRA: Quantization-Aware Low-Rank Adaptation
+
+## Introduction
+[QALoRA](https://huggingface.co/papers/2309.14717) is a quantization-aware version of Low-Rank Adaptation that enables efficient fine-tuning of quantized large language models. 
+QALoRA uses input feature pooling and a specialized grouping technique to work with quantized weights, significantly reducing memory requirements while preserving performance. 
+QALoRA enables fine-tuning of models that would otherwise be too large for consumer GPUs. In PEFT it only works for GPTQ.
+
+## Quick start
+```python
+import torch
+from peft import LoraConfig, get_peft_model
+from transformers import AutoTokenizer, AutoModelForCausalLM, Trainer
+from datasets import load_dataset
+
+# Load a quantized model (example with GPTQ quantization)
+model = AutoModelForCausalLM.from_pretrained(
+    "TheBloke/Llama-2-7b-GPTQ", 
+    revision="gptq-4bit-32g-actorder_True", 
+    device_map="auto"
+)
+tokenizer = AutoTokenizer.from_pretrained("TheBloke/Llama-2-7b-GPTQ")
+dataset = load_dataset("timdettmers/openassistant-guanaco", split="train")
+
+# Configure QALoRA parameters
+lora_config = LoraConfig(
+    use_qalora=True,
+    qalora_group_size=8,
+    r=16,
+    lora_alpha=32,
+    target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
+    lora_dropout=0.05,
+)
+
+# Create the PEFT model
+peft_model = get_peft_model(model, lora_config)
+
+# Set up trainer and train
+trainer = Trainer(
+    model=peft_model,
+    train_dataset=dataset,
+    args=TrainingArguments(
+        per_device_train_batch_size=1,
+        gradient_accumulation_steps=4,
+        num_train_epochs=3,
+        learning_rate=3e-4,
+        output_dir="qalora-llama-2-7b"
+    ),
+    data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+)
+trainer.train()
+peft_model.save_pretrained("qalora-llama-2-7b")
+```
+
+To use QALoRA, simply set `use_qalora = True` and specify a `qalora_group_size` in your LoRA configuration. The group size controls the memory/performance tradeoff - smaller values use less memory but may affect performance.
+
+## Command Line Examples
+
+Run the finetuning script with a GPTQ quantized model:
+
+You can customize the pooling group size (default is 16):
+```bash
+python examples/qalora_finetuning/qalora_gptq_finetuning.py \
+    --base_model TheBloke/Llama-2-7b-GPTQ \
+    --use_qalora \
+    --qalora_group_size 32
+```
+
+### Full example of the script 
+```bash
+python qalora_gptq_finetuning.py \
+    --base_model "TheBloke/Llama-2-13b-GPTQ" \
+    --output_dir "PATH_TO_OUTPUT_DIR" \
+    --batch_size 1 \
+    --num_epochs 3 \
+    --learning_rate 3e-4 \
+    --cutoff_len 512 \
+    --use_qalora \
+    --qalora_group_size 32 \
+    --eval_step 10 \
+    --save_step 100 \
+    --device "auto" \
+    --lora_r 16 \
+    --lora_alpha 32 \
+    --lora_dropout 0.05 \
+    --lora_target_modules "q_proj,k_proj,v_proj,o_proj,gate_proj,up_proj,down_proj" \
+    --push_to_hub
+```
+
+## Use the model on 🤗
+You can load and use the finetuned model like any other PEFT model:
+```python
+from peft import PeftModel, PeftConfig
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+# Load the base quantized model
+base_model = AutoModelForCausalLM.from_pretrained(
+    "TheBloke/Llama-2-7b-GPTQ",
+    device_map="auto"
+)
+tokenizer = AutoTokenizer.from_pretrained("TheBloke/Llama-2-7b-GPTQ")
+
+# Load the PEFT adapter
+peft_model_id = "YOUR_HF_REPO"
+model = PeftModel.from_pretrained(base_model, peft_model_id)
+
+# Generate text
+input_text = "Hello, I'm a language model"
+inputs = tokenizer(input_text, return_tensors="pt").to(model.device)
+outputs = model.generate(**inputs, max_length=100)
+print(tokenizer.decode(outputs[0], skip_special_tokens=True))
+```
+
+## QALoRA vs. LoRA
+
+QALoRA offers several advantages over standard LoRA:
+
+1. **Memory efficiency**: QALoRA works directly with quantized models, reducing memory usage by up to 60-70% compared to standard LoRA.
+
+2. **Hardware accessibility**: Enables fine-tuning of larger models (13B, 70B) on consumer GPUs that would be impossible with standard LoRA.
+
+3. **Performance preservation**: Despite quantization, QALoRA can achieve comparable performance to full-precision LoRA in many tasks.
+
+
+## Implementation Details: Merging with Quantized Models
+
+> **Note:** The current implementation differs from the original QA-LoRA paper's approach.
+
+While the QA-LoRA paper describes a direct weight modification technique using "beta shift" to modify quantized weights without full dequantization, this implementation uses a different approach:
+
+1. The quantized model is first dequantized to full precision
+2. The QALoRA adapter weights are then merged with the dequantized model
+3. The merged model must be re-quantized if quantization is still desired
+
+
+### Memory Considerations
+
+This process requires significant memory (enough to hold the full dequantized model) and additional computation for the re-quantization step. For large models, this may not be possible on consumer hardware.
+
+For most use cases, we recommend keeping the base quantized model and the QALoRA adapter separate, loading them with `PeftModel.from_pretrained()` as shown in the usage example above. This approach maintains the memory efficiency benefits of quantization throughout the deployment pipeline.
+
+
+## Citation
+```
+@article{dettmers2023qlora,
+  title={QLoRA: Efficient Finetuning of Quantized LLMs},
+  author={Dettmers, Tim and Pagnoni, Artidoro and Holtzman, Ari and Zettlemoyer, Luke},
+  journal={arXiv preprint arXiv:2305.14314},
+  year={2023}
+}
+
+@article{xu2023qalora,
+  title={QA-LoRA: Quantization-Aware Low-Rank Adaptation of Large Language Models},
+  author={Xu, Yuhui and Liu, Lingxi and Rao, Longhui and Zhao, Teng and Xiong, Zhiwei and Gao, Mingkui},
+  journal={arXiv preprint arXiv:2309.14717},
+  year={2023}
+}
+```
diff --git a/examples/qalora_finetuning/qalora_gptq_finetuning.py b/examples/qalora_finetuning/qalora_gptq_finetuning.py
new file mode 100644
index 0000000..1520c37
--- /dev/null
+++ b/examples/qalora_finetuning/qalora_gptq_finetuning.py
@@ -0,0 +1,356 @@
+"""
+Training script for fine-tuning language models with QALoRA using GPTQ quantization.
+This script supports cached quantization to avoid repeating expensive quantization processes.
+"""
+
+import argparse
+import os
+
+import torch
+from datasets import load_dataset
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    DataCollatorForLanguageModeling,
+    GPTQConfig,
+    Trainer,
+    TrainingArguments,
+)
+
+from peft import LoraConfig, get_peft_model
+
+
+def load_or_quantize_model(
+    base_model: str, tokenizer, bits: int = 4, cache_dir: str = "./quantized_models"
+) -> AutoModelForCausalLM:
+    """
+    Load a pre-quantized model from cache or quantize and cache a new one.
+    Automatically detects if the model is already GPTQ-quantized.
+
+    Args:
+        base_model: Model identifier or path
+        tokenizer: Tokenizer for the model
+        bits: Bit-width for quantization (default: 4)
+        cache_dir: Directory to store quantized models
+
+    Returns:
+        The loaded (quantized) model
+    """
+    # First, check if the model is already GPTQ-quantized by trying to load it
+    print(f"Checking if {base_model} is already GPTQ-quantized...")
+    try:
+        # Try to load the model and check if it has GPTQ quantization
+        test_model = AutoModelForCausalLM.from_pretrained(
+            base_model,
+            device_map="auto",
+            dtype=torch.float16,
+            trust_remote_code=True,  # Some GPTQ models might need this
+        )
+
+        # Check if the model has GPTQ quantization attributes
+        has_gptq = False
+        for module in test_model.modules():
+            if hasattr(module, "qweight") or hasattr(module, "qzeros") or "gptq" in str(type(module)).lower():
+                has_gptq = True
+                break
+
+        if has_gptq:
+            print(f"✅ Model {base_model} is already GPTQ-quantized. Using directly.")
+            return test_model
+        else:
+            print(f"Model {base_model} is not GPTQ-quantized. Will quantize it.")
+            # Clean up the test model to free memory
+            del test_model
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+            elif torch.xpu.is_available():
+                torch.xpu.empty_cache()
+
+    except Exception as e:
+        print(f"Could not load model {base_model} directly: {e}")
+        print("Will attempt to quantize it...")
+
+    # If we get here, the model needs to be quantized
+    os.makedirs(cache_dir, exist_ok=True)
+    model_id = base_model.replace("/", "_").replace("\\", "_")  # Handle Windows paths too
+    quantized_model_path = os.path.join(cache_dir, f"{model_id}_gptq_{bits}bit")
+
+    # Check if we already have a cached quantized version
+    if os.path.exists(quantized_model_path) and os.path.exists(os.path.join(quantized_model_path, "config.json")):
+        print(f"Loading pre-quantized model from cache: {quantized_model_path}")
+        return AutoModelForCausalLM.from_pretrained(quantized_model_path, device_map="auto")
+
+    print(f"Quantizing model and saving to cache: {quantized_model_path}")
+
+    # Configure GPTQ for first-time quantization
+    gptq_config = GPTQConfig(
+        bits=bits,
+        dataset="c4",
+        tokenizer=tokenizer,
+        group_size=128,
+        desc_act=False,
+        sym=False,
+    )
+
+    # Load and quantize the model
+    model = AutoModelForCausalLM.from_pretrained(
+        base_model, device_map="auto", quantization_config=gptq_config, dtype=torch.float16
+    )
+
+    # Save the quantized model to cache
+    print(f"Saving quantized model to {quantized_model_path}")
+    model.save_pretrained(quantized_model_path)
+    tokenizer.save_pretrained(quantized_model_path)
+
+    return model
+
+
+def tokenize_and_preprocess(examples, tokenizer, max_length: int = 128):
+    """
+    Tokenize text data and prepare it for language modeling.
+
+    Args:
+        examples: Dataset examples with 'text' field
+        tokenizer: Tokenizer to use
+        max_length: Maximum sequence length
+
+    Returns:
+        Processed examples with input_ids and labels
+    """
+    # Tokenize the text with truncation and padding
+    tokenized_output = tokenizer(examples["text"], truncation=True, padding="max_length", max_length=max_length)
+
+    # Preprocess labels (set pad tokens to -100 for loss masking)
+    labels = tokenized_output["input_ids"].copy()
+    labels = [[-100 if token == tokenizer.pad_token_id else token for token in seq] for seq in labels]
+    tokenized_output["labels"] = labels
+
+    return tokenized_output
+
+
+def train_model(
+    base_model: str,
+    data_path: str,
+    data_split: str,
+    output_dir: str,
+    batch_size: int,
+    num_epochs: int,
+    learning_rate: float,
+    cutoff_len: int,
+    use_qalora: bool,
+    eval_step: int,
+    save_step: int,
+    device: str,
+    lora_r: int,
+    lora_alpha: int,
+    lora_dropout: float,
+    lora_target_modules: str,
+    push_to_hub: bool,
+    qalora_group_size: int,
+    bits: int,
+) -> None:
+    """
+    Train a model with QALoRA and GPTQ quantization.
+
+    Args:
+        base_model: Base model to fine-tune
+        data_path: Dataset path
+        output_dir: Directory to save model outputs
+        batch_size: Training batch size
+        num_epochs: Number of training epochs
+        learning_rate: Learning rate
+        cutoff_len: Maximum sequence length
+        val_set_size: Validation set size
+        use_dora: Whether to use DoRA
+        use_qalora: Whether to use QALoRA
+        quantize: Whether to use quantization
+        eval_step: Steps between evaluations
+        save_step: Steps between saving checkpoints
+        device: Device to use (cuda:0, xpu:0, etc.)
+        lora_r: LoRA rank
+        lora_alpha: LoRA alpha
+        lora_dropout: LoRA dropout rate
+        lora_target_modules: Target modules for LoRA
+        push_to_hub: Whether to push to Hugging Face Hub
+    """
+    os.environ["TOKENIZERS_PARALLELISM"] = "false"
+    hf_token = os.getenv("HF_TOKEN")
+    device = torch.device(device)
+    print(f"Using device: {device}")
+
+    # Load tokenizer
+    tokenizer = AutoTokenizer.from_pretrained(base_model, token=hf_token)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    # Load or quantize model
+    model = load_or_quantize_model(base_model, tokenizer, bits=bits)
+
+    # Configure LoRA
+    target_modules = (
+        lora_target_modules.split(",")
+        if lora_target_modules
+        else ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
+    )
+
+    print("use_qalora", use_qalora)
+    lora_config = LoraConfig(
+        task_type="CAUSAL_LM",
+        use_qalora=use_qalora,
+        qalora_group_size=qalora_group_size,
+        r=lora_r,
+        lora_alpha=lora_alpha,
+        target_modules=target_modules,
+        lora_dropout=lora_dropout,
+        bias="none",
+    )
+
+    # Get PEFT model with adapters
+    model = get_peft_model(model, lora_config)
+
+    model.print_trainable_parameters()
+
+    # Move model to device if not already there
+    if not hasattr(model, "device") or model.device.type != device.type:
+        model = model.to(device)
+
+    # Load and prepare dataset
+    dataset = load_dataset(data_path, data_split)
+
+    tokenized_datasets = {
+        "train": dataset["train"].map(
+            lambda x: tokenize_and_preprocess(x, tokenizer, max_length=cutoff_len),
+            batched=True,
+            remove_columns=["text"],
+            load_from_cache_file=True,
+        ),
+        "test": dataset["test"].map(
+            lambda x: tokenize_and_preprocess(x, tokenizer, max_length=cutoff_len),
+            batched=True,
+            remove_columns=["text"],
+            load_from_cache_file=True,
+        ),
+    }
+
+    # Data collator for language modeling
+    data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)
+
+    # Configure training arguments
+    training_args = TrainingArguments(
+        output_dir=output_dir,
+        num_train_epochs=num_epochs,
+        per_device_train_batch_size=batch_size,
+        per_device_eval_batch_size=batch_size,
+        warmup_steps=100,
+        weight_decay=0.01,
+        logging_dir="./logs",
+        logging_steps=eval_step,
+        save_steps=save_step,
+        save_total_limit=2,
+        push_to_hub=push_to_hub,
+        gradient_accumulation_steps=16,
+        fp16=True,
+        learning_rate=learning_rate,
+        hub_token=hf_token,
+        label_names=["labels"],
+    )
+
+    # Clear accelerator cache to free memory
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+    elif torch.xpu.is_available():
+        torch.xpu.empty_cache()
+
+    # Initialize trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=tokenized_datasets["train"],
+        eval_dataset=tokenized_datasets["test"],
+        data_collator=data_collator,
+    )
+
+    # Start training
+    print("\nStarting training...")
+    trainer.train()
+
+    # Save the final model
+    if push_to_hub:
+        trainer.push_to_hub(commit_message="Fine-tuned model with QALoRA")
+
+    # Always save locally
+    model.save_pretrained(output_dir)
+    tokenizer.save_pretrained(output_dir)
+    print(f"\nTraining complete. Model saved to {output_dir}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Fine-tune LLMs with QALoRA and GPTQ quantization")
+
+    # Model and dataset parameters
+    parser.add_argument("--base_model", type=str, default="TheBloke/Llama-2-7b-GPTQ", help="Base model path or name")
+    parser.add_argument(
+        "--data_path", type=str, default="timdettmers/openassistant-guanaco", help="Dataset path or name"
+    )
+    parser.add_argument("--data_split", type=str, default="", help="Dataset path or name")
+
+    parser.add_argument(
+        "--output_dir", type=str, default="./qalora_output", help="Output directory for the fine-tuned model"
+    )
+    parser.add_argument("--bits", type=int, default=4, help="Init quantization bits")
+
+    # Training parameters
+    parser.add_argument("--batch_size", type=int, default=4, help="Batch size")
+    parser.add_argument("--num_epochs", type=int, default=1, help="Number of training epochs")
+    parser.add_argument("--learning_rate", type=float, default=3e-4, help="Learning rate")
+    parser.add_argument("--cutoff_len", type=int, default=128, help="Max sequence length")
+
+    # Adapter configuration
+    parser.add_argument("--use_qalora", action="store_true", help="Apply QALoRA")
+    parser.add_argument("--qalora_group_size", type=int, default=32, help="LoRA rank")
+    parser.add_argument("--lora_r", type=int, default=8, help="LoRA rank")
+    parser.add_argument("--lora_alpha", type=int, default=16, help="LoRA alpha")
+    parser.add_argument("--lora_dropout", type=float, default=0.05, help="LoRA dropout rate")
+    parser.add_argument(
+        "--lora_target_modules", type=str, default=None, help="Comma-separated list of target modules for LoRA"
+    )
+
+    # Training process options
+    parser.add_argument("--eval_step", type=int, default=100, help="Evaluation step interval")
+    parser.add_argument("--save_step", type=int, default=500, help="Save step interval")
+    parser.add_argument("--device", type=str, default="auto", help="Device to use for training")
+
+    # Hugging Face Hub options
+    parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to Hugging Face Hub")
+
+    args = parser.parse_args()
+
+    device = args.device
+    if args.device == "auto":
+        device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+
+    # If use_qalora isn't explicitly set in args but passed to train_model
+    if not args.use_qalora:
+        args.use_qalora = True  # Default to True as in the original code
+
+    train_model(
+        base_model=args.base_model,
+        data_path=args.data_path,
+        data_split=args.data_split,
+        output_dir=args.output_dir,
+        batch_size=args.batch_size,
+        num_epochs=args.num_epochs,
+        learning_rate=args.learning_rate,
+        cutoff_len=args.cutoff_len,
+        use_qalora=args.use_qalora,
+        eval_step=args.eval_step,
+        save_step=args.save_step,
+        device=device,
+        lora_r=args.lora_r,
+        lora_alpha=args.lora_alpha,
+        lora_dropout=args.lora_dropout,
+        lora_target_modules=args.lora_target_modules,
+        push_to_hub=args.push_to_hub,
+        qalora_group_size=args.qalora_group_size,
+        bits=args.bits,
+    )
diff --git a/examples/randlora_finetuning/README.md b/examples/randlora_finetuning/README.md
new file mode 100644
index 0000000..7ebf610
--- /dev/null
+++ b/examples/randlora_finetuning/README.md
@@ -0,0 +1,112 @@
+# RandLora: Full-rank parameter-efficient fine-tuning of large models 
+
+## Introduction
+[RandLora](https://huggingface.co/papers/2502.00987) is a parameter-efficient fine-tuning technique that is similar to LoRA and VeRA but performs full rank updates to improve performance. RandLora can be particularly useful when adapting large model to hard tasks that require complex updates while preserving the parameter efficiency of LoRA. The full rank update of RandLora is achieved by linearly scaling random bases. The random bases are a collection of multiple low rank matrices such that the summation of their ranks if greater or equal to the full rank of the parameter matrices. The trainable parameters of RandLora are two diagonal matrices (vectors) that get multiplied with the right hand low rank random bases, in a similar way to VeRA's update. To maintain low memory usage, RandLora uses a custom function that prevents storing unnecessary bases in memory for backpropagation.
+
+## Quick start
+```python
+import torch
+from peft import RandLoraConfig, get_peft_model
+from transformers import AutoTokenizer, AutoModelForCausalLM, Trainer
+from datasets import load_dataset
+
+model = AutoModelForCausalLM.from_pretrained("huggyllama/llama-7b", device_map="auto")
+tokenizer = AutoTokenizer.from_pretrained("huggyllama/llama-7b")
+dataset = load_dataset("timdettmers/openassistant-guanaco", split="train")
+randlora_config = RandLoraConfig()
+
+peft_model = get_peft_model(model, lora_config)
+trainer = transformers.Trainer(
+    model=peft_model,
+    train_dataset=dataset,
+    dataset_text_field="text",
+    max_length=2048,
+    processing_class=tokenizer,
+)
+trainer.train()
+peft_model.save_pretrained("randlora-llama-7b")
+```
+
+There is no additional change needed to your standard PEFT training procedure, simply swap your `LoraConfig` for a `RandLoraConfig`. Note however that RandLora's trainable parameter count is **inversely proportional** to the rank parameter `r`. Lower `r` to increase and increase it to reduce trainable parameters of RandLora.
+
+Run the finetuning script simply by running:
+```bash
+python examples/randlora_finetuning/randlora_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --data_path timdettmers/openassistant-guanaco
+```
+This 👆🏻 by default will load the model in peft set up with RandLora config. Now if you wanna quickly compare it with Lora, all you need to do is to input ` --use_lora` in the command line and reduce `--randlora_alpha` to 2x the rank. So same above example would be 👇🏻;
+
+```bash
+python examples/randlora_finetuning/randlora_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --data_path timdettmers/openassistant-guanaco --use_lora --rank 32 --randlora_alpha 64
+```
+
+RandLora can be made to use sparse or very sparse random bases. These sparse matrices can help reduce overfitting. Add `--very_sparse` to run with very sparse matrices or `--sparse` for sparse matrices:
+
+```bash
+python examples/randlora_finetuning/randlora_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --sparse
+```
+
+RandLora also supports quantization. To use 4-bit quantization try:
+
+```bash
+python examples/randlora_finetuning/randlora_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --quantize
+```
+
+By default the RandLora layers are the key and value layers of LLama model. Adding adapters on more layers will increase memory usage. If you wish to choose a different set of layers for RandLora to be applied on, you can simply define it using:
+```bash
+python examples/randlora_finetuning/randlora_finetuning.py --randlora_target_modules "q_proj,k_proj,v_proj" 
+```
+
+### Full example of the script 
+```bash
+python randlora_finetuning.py \
+    --base_model "PATH_TO_MODEL" \
+    --data_path "PATH_TO_DATASET" \
+    --output_dir "PATH_TO_OUTPUT_DIR" \
+    --batch_size 1 \
+    --num_epochs 3 \
+    --learning_rate 3e-4 \
+    --cutoff_len 512 \
+    --val_set_size 500 \
+    --quantize \
+    --eval_step 10 \
+    --save_step 100 \
+    --device "auto" \
+    --rank 32 \
+    --randlora_alpha 640 \
+    --randlora_dropout 0.05 \
+    --randlora_target_modules "k_proj,v_proj" \
+    --hub_model_id "YOUR_HF_REPO" \
+    --push_to_hub
+```
+
+## RandLora vs. LoRA
+RandLora differs from LoRA and other related low rank approximation algorithms by challenging the low rank paradigm. RandLora adapters learn **full-rank** updates as the [paper](https://huggingface.co/papers/2502.00987) shows that the low rank constraint of LoRA can constrain performance gains as trainable parameters increase (with higher ranks). As a result, using RandLora is specifically recommended for difficult tasks that are underfit by LoRA. RandLoRA however also often improves performance for common tasks. If increasing LoRA's rank improves performance for your task, RandLora will most likely outperform.
+
+RandLora is expected to increase performance over LoRA for equivalent amounts of trainable parameters, mostly for larger equivalent amounts (> LoRA rank 4).
+
+RandLora's performance increase comes with two limitations:
+
+1. Performance is dependent on using a large `randlora_alpha` scaling parameter (usually 20x the basis rank). This large parameter can sometimes make training the update unstable, reduce the learning rate or the scaling parameter if this is the case.
+
+2. Increase training time over LoRA when using very low RandLora basis ranks.
+
+## RandLora vs. VeRA
+RandLora shares similarities with VeRA in that both algorithms use random basis combinations to address some of LoRA's limitations. The limitations addressed by each algorithm is however different.
+VeRA aims to reduce trainable parameters beyond rank 1 LoRAs while RandLoRA reduces the performance limitation due to the low rank of the update as the trainable parameter count increases.
+
+RandLora is expected to:
+
+1. Improve performance over VeRA when more trainable parameters are required (hard tasks)
+
+2. Reduce memory usage over VeRA thanks to RandLora's random base sharing strategy
+
+
+## Citation
+```
+@inproceedings{2025_ICLR_RandLoRA,
+  title="{RandLoRA: Full rank parameter-efficient fine-tuning of large models}",
+  author="Albert, Paul and Zhang, Frederic Z. and Saratchandran, Hemanth and Rodriguez-Opazo, Cristian and van den Hengel, Anton and Abbasnejad, Ehsan",
+  booktitle="{International Conference on Learning Representations (ICLR)}",
+  year="2025"
+}
+```
diff --git a/examples/randlora_finetuning/qrandlora_finetuning.ipynb b/examples/randlora_finetuning/qrandlora_finetuning.ipynb
new file mode 100644
index 0000000..887cf1f
--- /dev/null
+++ b/examples/randlora_finetuning/qrandlora_finetuning.ipynb
@@ -0,0 +1,8100 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "CV_gQs58bsvM"
+   },
+   "source": [
+    "# Fine-tuning [Llama3-8b](https://huggingface.co/meta-llama/Meta-Llama-3-8B) on [timdettmers/openassistant-guanaco](https://huggingface.co/datasets/timdettmers/openassistant-guanaco) Dataset using QRandLora (quantized RandLora) on T4 Free Colab GPU."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "FuXIFTFapAMI",
+    "outputId": "b95d8260-65bd-405f-f1e2-8d353aa46814"
+   },
+   "outputs": [],
+   "source": [
+    "# Install the libraries\n",
+    "!pip install -q -U bitsandbytes\n",
+    "!pip install -q -U git+https://github.com/huggingface/transformers.git\n",
+    "!pip install -q -U git+https://github.com/huggingface/peft.git\n",
+    "!pip install -q -U git+https://github.com/huggingface/accelerate.git\n",
+    "!pip install -q datasets"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 145,
+     "referenced_widgets": [
+      "8cc86330c2af436c9af314e8c04c8c2b",
+      "e25f9ca445b14e3f8397779df071dfb4",
+      "8365680c634a44aa880317e36fa5e46e",
+      "0c4ac7c3db0b431397cc812f7c9e785c",
+      "c84f542c863043dea8a3675fa153e78d",
+      "b3b3f4ddd4ed4d938c923887939a0440",
+      "35186465f87341f683affb9399661540",
+      "791df472db174df69b8c9f0e200af254",
+      "6bb9c7182d2a464ea21809e59043562a",
+      "31c574113731403b88edc5bb0798bc6d",
+      "3b8bc5b9392e45758813a1db9db824a9",
+      "90661b333d6f496ca606b3046622660e",
+      "5f551f9b217e44cf8b5433f314b3844b",
+      "d2d81cc8296c4b10bf80b86c0a3302d3",
+      "7e3a386e672f4748882211227b7721a9",
+      "57f251691b4c453896b2508c431dfc2f",
+      "4bdb196cd1494f809829651ec5b6cbf8",
+      "7cd50bcc8fcc4b83abcda6d3604bd4cc",
+      "7a00aa4a97a34da39cc052c6926dbe13",
+      "14c73d88df9e46e3bbb6690fdb48ad07",
+      "0e2beab611114239b6ee48a3cbb09c49",
+      "006b78b5191b4fb888d98bdf6c20ec1e",
+      "5f6ffa1d929443a5bd9c7c550f0690f0",
+      "668a7f88506148a9ba2b48920afc028f",
+      "57b0096985ab44aea342e52795c4f999",
+      "a4c404e420cc4ce781ce569f9ab3f987",
+      "ee4e4af964ec4dd597cb04a90f0697f9",
+      "974e3687f18a4e1a975969b880d086aa",
+      "93a50117ece543d4857ba02505dc4514",
+      "71a3a56edbdb45669d382fef4b097e1b",
+      "53f287d4927541d08e2ae7d4d0b3c396",
+      "afa442ab223b46cb82569438c0047823"
+     ]
+    },
+    "id": "wAAPv5CRmg7e",
+    "outputId": "687f979a-04c1-4160-d71c-4de8ecdb07d9"
+   },
+   "outputs": [],
+   "source": [
+    "# Required when training models/data that are gated on HuggingFace, and required for pushing models to HuggingFace\n",
+    "from huggingface_hub import notebook_login\n",
+    "\n",
+    "notebook_login()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "MJ-5idQwzvg-"
+   },
+   "source": [
+    "### Loading the model and its tokenizer in quantized setup!\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 546,
+     "referenced_widgets": [
+      "5924b266e95a42039634a334ff561a82",
+      "eadeec171e7b4c0f9e26964f031cfb71",
+      "feae525923d5407bb69a922954c474f7",
+      "00371a48e64c45cd97020a78b710e64c",
+      "156f95b0012449e8a0c604e6e03bf35f",
+      "de3757d6125a4c07b502dd60816bafec",
+      "8c4d6f4eea3742289a2604e66b0c6182",
+      "bac377ed96ae4e8db9b298bb623888ec",
+      "02d6cc4c2717434c895798601bda7c86",
+      "3f9fa554747743f8a86b40a4f7530617",
+      "ffe561df8772443ebf40a3b8b656079f",
+      "800e9453214848b69bc4c6ca2d5e8f79",
+      "6b0ec8d5f7294d44a5fa15d8ef12471e",
+      "7d3a7be9ed6f48988a2c4a1a4a2271cf",
+      "c40f583823574e40b6b29d4914143c0e",
+      "a4368e6da8f046aaa32f3152b7d333d1",
+      "8ea89e52123643268857285e0e1db1c0",
+      "a8514e34378d47a28fbf0831a14ede8f",
+      "f86b969ef69b48119619e1a424b50460",
+      "7725e9d443e249ada02e5ac7056d00db",
+      "f81756eb9e554899b0778311f2c407c4",
+      "3b614b9712874fac990d2c557b0791a6",
+      "43d12a98d90a4bf7a96c033172c646e2",
+      "c35b16156253402f90a432f3f07c2e0a",
+      "1ae1d2702da5483a85504f59939ffa39",
+      "1b2abf90003e4165a3293acd6a5ea9ff",
+      "3e45aea9f7444a4db885c4cca4c9c4ff",
+      "6b6ed29053ec4aaa8fc5526a35f17c2b",
+      "e69cd88ccbae4bb7b238fa112a60f0f9",
+      "8cd63d3908e4411c9fcb42bc32c8dd16",
+      "64624b26145b42db82f7afc36c32e117",
+      "cffdf12fbe97462ab74e88ccca943aeb",
+      "bcaf4c81ba9d437bb6223dbb22d011ed",
+      "8800c351b6da450eace0c3890d36c8d7",
+      "7037c32dfce84e70ac86537dbbc6a495",
+      "31c10fa464e24f97b379675a204a09b5",
+      "6149752353fe4f9cbb7b26bcc25199a9",
+      "0b145e421f4840f2872c29256b49f168",
+      "0f4c664612364dc89acf78eb1c740980",
+      "0f60f9aa76b941809e013ffcae83604a",
+      "1d27ab2bc6ae463a806292b68b7891f8",
+      "2a57bb48e1c6475abba242994a79d44a",
+      "6cb8065803724d80b82b06dc95ded91e",
+      "8301c6302df54bbc9f15295f11cec208",
+      "0aad2d9d1cba40cbb64308ede3242ed7",
+      "0711e28e06a440c2a241acbc1f90d1e8",
+      "77704d2e27e94cd3a0c5f6b5ceeffd1c",
+      "3b82b8d41b134bec9bd77ed8d4f00eb4",
+      "25fef90e209f4b14a73f3e39d226d913",
+      "f4ca7b63d7d749ff83a848e250f03ec1",
+      "8c149bc655a34fe5b91853c66db458a9",
+      "0f54e8fda93144f6a95493e6ec535e9d",
+      "880124db7dc04aaea09edd75e1ec7921",
+      "14bf612f6ad7416c8ddd6085c72eee0e",
+      "f7e59b47f9b74523843f37268212d566",
+      "a34b3fd5859a441f89cbe7f6e6df9da9",
+      "8f5b8c513b164dab9e0892422163c483",
+      "5b2a671976fa446db408d58a215b8249",
+      "c934919f617447cfb9226929e7a68d79",
+      "124a70bfad434c5c946f611c04a91c8f",
+      "cd11fb7d54bb43ae821f2272d075a1b3",
+      "fbc6a2834c5442fbb6667f1b3612bb5b",
+      "63899ac621ff4e9cb8e215d5ab63bef8",
+      "6b2b59d2b62b4f7da8c60ff783138397",
+      "c27e8ce031884a90b41d8220b1870bc4",
+      "88024cd312ee42c2925ebfbe52077780",
+      "cf6d1be81b6c4ffc81ce8fdabfc5ad28",
+      "07e0aed682fd4cc88fa75c0592dc04a7",
+      "67b4473eb8a44a96ba34983762ab38fa",
+      "c7e06fd82f7f4f9fb81c68e8758f2de1",
+      "3d9d8278667d496aaea1eaaa4d24ae93",
+      "47944ad8cadf4a57b170193c46d4389c",
+      "db05b25cb38140bdb21e6f3b7fde7e66",
+      "6f474268da0f4337a2ccecc1ca2098a1",
+      "c2ceccfdb59b4336a24003cd6bc2403d",
+      "a8999d04e4114693bb6be358bdbe9b83",
+      "2540d57e3bf545e3812da1ee72b85fc8",
+      "c56d8289513441688f9bc5f4b52d60a0",
+      "a53b4776f95f4dd38197193e6c5f649e",
+      "b4ba435f6d1c448f99b533bc6df32e76",
+      "42eb041021214110a860924d28d73409",
+      "17c797e08bd2493fa685918129415309",
+      "aea74071600f483b9e6de1a61743c03a",
+      "21bf14b771c14d2dab9e98a326302e14",
+      "35c2c635c2024bcda3265bf95d330f63",
+      "ec014d847e394a309b6a82c30a6fdfc5",
+      "4c369386ba5f4862b11a50e50130663b",
+      "bbdf3bb657e64fc2b0a90e78e8886480",
+      "d7ef74cf4a914ad38a69c84c34fff393",
+      "8d0f1d547c384094b10aa00a3ede3c06",
+      "9bdebf06b6874bbb88404f4ad14e1dbc",
+      "a2249f364b914662b54045a1f8d6dfd1",
+      "7504986b8d8d4d0da58ad79e80a81948",
+      "082b6990ce5e4812adc0ad6a7b376dac",
+      "610e1ddfb7a44d51a54ebea6dad3a5f0",
+      "5f60910d1e744432bdf87518f0f45874",
+      "2ab86b3fbd49488bb02f8205a572e752",
+      "9f13437a44b8434b9cc3afab998e8d3c",
+      "8a7c82dcbd414b24b67ccfbc562b2e38",
+      "d1508f5cde9a43d8abc26dd2d0c34dbd",
+      "9a0b012915c54abeb100f466fa99d303",
+      "99529129d7f0435da0fdcfc9803a2f11",
+      "5b56ac3009714a5a84dd8749db4a7bce",
+      "546b76a22f1046cd856a8fa2f9ff2d9f",
+      "fffbf696c07744fc8e3d81ab51dc9c90",
+      "a153cc3ca0cc45c18a941bd57e363ec3",
+      "5a8ac674153248999007a713299b2644",
+      "1f82a5685eef4b47a2dbf7618362907c",
+      "51b3af446ace409dbcdf5de499552061",
+      "9a12124915994b70a71ebd64b99e93e9",
+      "57f87d4780634d36ae8159d987c22993",
+      "58ea619f81bf42ddb8b166db3deb0e86",
+      "8bb83ae3229e4f38b1733f92f536fad0",
+      "5c0104210ee34ca8a072ee5121f424a1",
+      "34e381adbd9242759b57f2a305c5d2e3",
+      "e4e1a4338c5e46b3ba5a3bb960da7107",
+      "9a5072b8d16d4a1eb0652da61bda0ac8",
+      "1f75d85e6c7e4eb6a91b03f0c8adb644",
+      "9da33f07ea354b5798e85298e132b017",
+      "604582e8cbff4dc9876551a3307b5b77",
+      "a98165ee656643ad85ac9ea1447cc775",
+      "5cf4a57d21a545029b6448258a5ebd84",
+      "0d2ae3466a3447c58e23ccd2b3733deb",
+      "ba7f32c41f9247ec9d4c40e6396b55a9",
+      "ea1bdb5f2da64332960bccd967a84b4a",
+      "b08631e4cffa445c912da0c8eac2ef23",
+      "921a1a037f7b47f8b57d1da8192a437a",
+      "892ff4e2f0e44c23bc5c2be7547cf0bd",
+      "4c8e98294bd240a6869cb199caee66e1",
+      "4e1f5423311b4dc0930c21c9ad5a88f5",
+      "347540dc03d34e65b7ffbb0f5fc569aa",
+      "7243d8e2e1cc4043a2ee310eabd0ac09"
+     ]
+    },
+    "id": "E0Nl5mWL0k2T",
+    "outputId": "a942d9b0-1f38-4a9b-ea20-e55bd7593920"
+   },
+   "outputs": [],
+   "source": [
+    "# setting up the config for 4-bit quantization of QRandLora\n",
+    "import torch\n",
+    "from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig\n",
+    "\n",
+    "model_id = \"meta-llama/Meta-Llama-3-8B\"\n",
+    "bnb_config = BitsAndBytesConfig(\n",
+    "    load_in_4bit=True, bnb_4bit_use_double_quant=True, bnb_4bit_quant_type=\"nf4\", bnb_4bit_compute_dtype=torch.bfloat16\n",
+    ")\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_id)\n",
+    "model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=bnb_config, device_map={\"\": 0})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Xpx2Fq-icX56"
+   },
+   "outputs": [],
+   "source": [
+    "print(model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Mp2gMi1ZzGET"
+   },
+   "source": [
+    "#### Prepare model for PEFT fine-tuning"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "id": "a9EUEDAl0ss3"
+   },
+   "outputs": [],
+   "source": [
+    "from peft import prepare_model_for_kbit_training\n",
+    "\n",
+    "model.gradient_checkpointing_enable()\n",
+    "model = prepare_model_for_kbit_training(model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "id": "gkIcwsSU01EB"
+   },
+   "outputs": [],
+   "source": [
+    "def print_trainable_parameters(model):\n",
+    "    \"\"\"\n",
+    "    Prints the number of trainable parameters in the model.\n",
+    "    \"\"\"\n",
+    "    trainable_params = 0\n",
+    "    all_param = 0\n",
+    "    for _, param in model.named_parameters():\n",
+    "        all_param += param.numel()\n",
+    "        if param.requires_grad:\n",
+    "            trainable_params += param.numel()\n",
+    "    print(\n",
+    "        f\"trainable params: {trainable_params} || all params: {all_param} || trainable%: {100 * trainable_params / all_param}\"\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "HVTAJuKyM0gX"
+   },
+   "source": [
+    "### Setup `RandLoraConfig`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "Ybeyl20n3dYH",
+    "outputId": "ea35ec70-13e4-4f23-9481-1b33b1b06dec"
+   },
+   "outputs": [],
+   "source": [
+    "from peft import RandLoraConfig, get_peft_model\n",
+    "\n",
+    "config = RandLoraConfig(\n",
+    "    r=32,\n",
+    "    randlora_alpha=640,\n",
+    "    target_modules=[\n",
+    "        \"q_proj\",\n",
+    "        \"k_proj\",\n",
+    "        \"v_proj\",\n",
+    "        \"o_proj\",\n",
+    "        \"gate_proj\",\n",
+    "        \"up_proj\",\n",
+    "        \"down_proj\",\n",
+    "    ],  # parameters specific to llama\n",
+    "    randlora_dropout=0.05,\n",
+    "    bias=\"none\",\n",
+    "    task_type=\"CAUSAL_LM\",\n",
+    ")\n",
+    "\n",
+    "model = get_peft_model(model, config)\n",
+    "print_trainable_parameters(model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "Ybeyl20n3dYH",
+    "outputId": "ea35ec70-13e4-4f23-9481-1b33b1b06dec"
+   },
+   "outputs": [],
+   "source": [
+    "print(model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "FCc64bfnmd3j"
+   },
+   "source": [
+    "## Step 2) Fine-tuning process 💥\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 277,
+     "referenced_widgets": [
+      "b2a19b6092c44b20886987b30f1bf48a",
+      "1f0efc167b3744b38ff832b71d529318",
+      "a06b2bd0236249999adffa44e53cf80e",
+      "23012118a7314a3f838870a2aee9ec90",
+      "dcff079d850c423a83eb70105b816ee4",
+      "64911f0e52e74067a1a986c5edfc7f59",
+      "b4a274fc9e324b80bf559c4dbd05e319",
+      "5fb4a4ef8afe4ea4af6655faea17f354",
+      "b1a03a5e9bae46129830daeeb23bf6ff",
+      "e297072ab5d64815b90bc89d22503378",
+      "67fbabb9082c4241b8f937b24e0cdd03",
+      "b1de7b283eeb41828e8093e60c83f2c4",
+      "bb640a5c858349d29c13ce5629e72f22",
+      "37523a6cac1047e9a261698212d47737",
+      "661f76474252493caae8f7d6aa8f99b7",
+      "849cdc1912aa4df4b0c721a8c63ca0f9",
+      "5962e77eea5a4d88ba6dbc5e9f51c709",
+      "f07c8a6ec12f46ea9e32a2208e70bccd",
+      "191caf3a38eb4191a35f623ce25238f9",
+      "30b74bd2db8d40d08408013cebcd7661",
+      "83c355e1418140a5bbad11bf0646b332",
+      "84d6d2a6afcd423f9b609cbb2d10f00e",
+      "51180cce01564821a170d1d4b8a9a918",
+      "03dd6c24f6d94fe7ab85b79d6f6cbeaf",
+      "f2ab2fa803e94328a237e84cd4ea0027",
+      "1bd0a270c7ee409c970763398e54fc36",
+      "e92b30d0b4234af6b5a33bff989b1b45",
+      "cc5ce633746949ed98418cae9f68afe3",
+      "4b1f795c4c004cacbf3660d935e52995",
+      "5690d92586494b9187147f32fa708405",
+      "317cda72329c4043ab0b224b46b259d3",
+      "076357d4bb9943bdaa1d6846897786af",
+      "7b3e136fc9e74a699497a947006f4f1d",
+      "7e2e097c703a4a0d8556733a0739469c",
+      "e0fd6d00f0ba4e59bdaa5779556ec4ea",
+      "cd318c6bfc8e421a9bfcdab16be5eaa7",
+      "4bc1fd9d480a4799954c69031c071b30",
+      "25fc6aaf37fc49fa822df29236bf2f90",
+      "7ac8e88f29f04b859f592a003d39836b",
+      "0ec2643d9fd44785addb37d9ecd23989",
+      "d10ba011d05045b18bbfeb9660e4d9d3",
+      "e56c22f77c884caaacfafd48dfa51a55",
+      "068eb104d5d346b1897f8cbe9860d267",
+      "b621c6a8c0e9440fa840d75a1b1b02fc",
+      "434fe18d50a14920b30fd2d0650297ac",
+      "353bf45a4bbc46d6a798175f152399cb",
+      "bfcbfe4184774fd3a8320f4f0e1baf54",
+      "99c5c846cc5e43429905f071670b4310",
+      "8d988c86648244788f6dc5aa0fea38fd",
+      "740604526cc44cd58b811827d4787d96",
+      "2558c2dd7d394ecf9fc67a69ce8fc97a",
+      "a2a7b715b16a41a288209dee1de5d2d1",
+      "bf77e5aaab0547f7b2beb015687552ef",
+      "a2c543008f444cf49972a4f35c32b8e3",
+      "bb7b8a9e42f6478f851236685a1392d6",
+      "9cfaf17064bc49a5aded0fc53dd7cd7f",
+      "ede66e196fa9482498f58dcdffd494a2",
+      "a26cc7fea1a64d7bac1769d33cc74e28",
+      "c2f24a8930be4b70b4bbbcf5d908b01d",
+      "1f59dd66813f419999336e59a3efc56a",
+      "026072374b7d47c194707a50f5c99099",
+      "63ac7dafeb27446cb30aaddf4cd27c9f",
+      "854e35df771f470b82a59f878a2a6a46",
+      "d1cbe0ab9379453588eb438d13fd272d",
+      "b0b7457a8b47496483da1506fb2505b3",
+      "c7dc386d978a44ff885763ecec94dc38",
+      "4a7c8dfd88db4bc893da2bced0560d47",
+      "27a587021d854b79a279a510a55f9d73",
+      "4227474e986546d1a7d31dce35a2410c",
+      "1561cd47c42e46368677d34e7b7084cd",
+      "8b9e961c837a464fb7a8c44756dc41e7",
+      "d4092198673141d3b4a824d629d73f64",
+      "d3cbfd564fe8485ba7afdb1cc54abed3",
+      "7e51e8e0612e46b1a3403d448b39aa50",
+      "061c45266c484ff6807dcaf4722fd73b",
+      "04188e0cec0542818894ebc6a534fb51",
+      "4a13203d132b45beadf140c02dc8a566"
+     ]
+    },
+    "id": "s6f4z8EYmcJ6",
+    "outputId": "8ece7a1a-cf27-4602-c70b-ce4f3d7e11bf"
+   },
+   "outputs": [],
+   "source": [
+    "# Load the dataset from HF\n",
+    "from datasets import load_dataset\n",
+    "\n",
+    "data = load_dataset(\"timdettmers/openassistant-guanaco\")\n",
+    "data = data.map(lambda samples: tokenizer(samples[\"text\"]), batched=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "_0MOtwf3zdZp"
+   },
+   "source": [
+    "## Training\n",
+    "\n",
+    "For the sake of the demo, we just ran it for 10 steps just to showcase how to use this integration with existing tools on the HF ecosystem."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 498
+    },
+    "id": "jq0nX33BmfaC",
+    "outputId": "94e17005-065b-48ab-9192-e3ab55c0c292"
+   },
+   "outputs": [],
+   "source": [
+    "import transformers\n",
+    "\n",
+    "tokenizer.pad_token = tokenizer.eos_token\n",
+    "\n",
+    "trainer = transformers.Trainer(\n",
+    "    model=model,\n",
+    "    train_dataset=data[\"train\"],\n",
+    "    args=transformers.TrainingArguments(\n",
+    "        per_device_train_batch_size=1,\n",
+    "        gradient_accumulation_steps=4,\n",
+    "        warmup_steps=2,\n",
+    "        max_steps=10,\n",
+    "        learning_rate=2e-4,\n",
+    "        fp16=True,\n",
+    "        logging_steps=1,\n",
+    "        output_dir=\"path/to/your/HF/repo\",  # change it to your desired repo!\n",
+    "        optim=\"paged_adamw_8bit\",\n",
+    "        label_names=[\"labels\"],\n",
+    "    ),\n",
+    "    data_collator=transformers.DataCollatorForLanguageModeling(tokenizer, mlm=False),\n",
+    ")\n",
+    "model.config.use_cache = False  # silence the warnings. Please re-enable for inference!\n",
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Mr3rLrHwqhf6"
+   },
+   "source": [
+    "## Usage Example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "9mrOJ9l8SMHv"
+   },
+   "outputs": [],
+   "source": [
+    "model.config.use_cache = True\n",
+    "model.eval();"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 122
+    },
+    "id": "AM6FNOFzqKfI",
+    "outputId": "fdbe28b1-e440-45d3-bd6d-c15e744ad23d"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import GenerationConfig\n",
+    "\n",
+    "max_new_tokens = 120\n",
+    "top_p = 0.9\n",
+    "temperature = 0.7\n",
+    "user_question = \"What is the purpose of quantization in LLMs?\"\n",
+    "\n",
+    "\n",
+    "prompt = (\n",
+    "    \"A chat between a curious human and an artificial intelligence assistant. \"\n",
+    "    \"The assistant gives helpful, detailed, and polite answers to the user's questions. \"\n",
+    "    \"### Human: {user_question}\"\n",
+    "    \"### Assistant: \"\n",
+    ")\n",
+    "\n",
+    "\n",
+    "def generate(model, user_question, max_new_tokens=max_new_tokens, top_p=top_p, temperature=temperature):\n",
+    "    device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "    inputs = tokenizer(prompt.format(user_question=user_question), return_tensors=\"pt\").to(device)\n",
+    "\n",
+    "    outputs = model.generate(\n",
+    "        **inputs,\n",
+    "        generation_config=GenerationConfig(\n",
+    "            do_sample=True,\n",
+    "            max_new_tokens=max_new_tokens,\n",
+    "            top_p=top_p,\n",
+    "            temperature=temperature,\n",
+    "        ),\n",
+    "    )\n",
+    "\n",
+    "    text = tokenizer.decode(outputs[0], skip_special_tokens=True)\n",
+    "    # print(text)\n",
+    "    return text\n",
+    "\n",
+    "\n",
+    "generate(model, user_question)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "T5t_gl2_f5OO"
+   },
+   "outputs": [],
+   "source": [
+    "# trainer.push_to_hub()"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "gpuType": "T4",
+   "provenance": []
+  },
+  "gpuClass": "standard",
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  },
+  "widgets": {
+   "application/vnd.jupyter.widget-state+json": {
+    "00371a48e64c45cd97020a78b710e64c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_3f9fa554747743f8a86b40a4f7530617",
+      "placeholder": "​",
+      "style": "IPY_MODEL_ffe561df8772443ebf40a3b8b656079f",
+      "value": " 50.6k/50.6k [00:00&lt;00:00, 3.65MB/s]"
+     }
+    },
+    "006b78b5191b4fb888d98bdf6c20ec1e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "LabelModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "LabelModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "LabelView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_ee4e4af964ec4dd597cb04a90f0697f9",
+      "placeholder": "​",
+      "style": "IPY_MODEL_974e3687f18a4e1a975969b880d086aa",
+      "value": "Your token has been saved in your configured git credential helpers (store)."
+     }
+    },
+    "026072374b7d47c194707a50f5c99099": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "02d6cc4c2717434c895798601bda7c86": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "03dd6c24f6d94fe7ab85b79d6f6cbeaf": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_cc5ce633746949ed98418cae9f68afe3",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4b1f795c4c004cacbf3660d935e52995",
+      "value": "Downloading data: 100%"
+     }
+    },
+    "04188e0cec0542818894ebc6a534fb51": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "061c45266c484ff6807dcaf4722fd73b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "068eb104d5d346b1897f8cbe9860d267": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0711e28e06a440c2a241acbc1f90d1e8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f4ca7b63d7d749ff83a848e250f03ec1",
+      "placeholder": "​",
+      "style": "IPY_MODEL_8c149bc655a34fe5b91853c66db458a9",
+      "value": "model.safetensors.index.json: 100%"
+     }
+    },
+    "076357d4bb9943bdaa1d6846897786af": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "07e0aed682fd4cc88fa75c0592dc04a7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_47944ad8cadf4a57b170193c46d4389c",
+      "placeholder": "​",
+      "style": "IPY_MODEL_db05b25cb38140bdb21e6f3b7fde7e66",
+      "value": "model-00001-of-00004.safetensors: 100%"
+     }
+    },
+    "082b6990ce5e4812adc0ad6a7b376dac": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0aad2d9d1cba40cbb64308ede3242ed7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_0711e28e06a440c2a241acbc1f90d1e8",
+       "IPY_MODEL_77704d2e27e94cd3a0c5f6b5ceeffd1c",
+       "IPY_MODEL_3b82b8d41b134bec9bd77ed8d4f00eb4"
+      ],
+      "layout": "IPY_MODEL_25fef90e209f4b14a73f3e39d226d913"
+     }
+    },
+    "0b145e421f4840f2872c29256b49f168": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0c4ac7c3db0b431397cc812f7c9e785c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "CheckboxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "CheckboxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "CheckboxView",
+      "description": "Add token as git credential?",
+      "description_tooltip": null,
+      "disabled": false,
+      "indent": true,
+      "layout": "IPY_MODEL_90661b333d6f496ca606b3046622660e",
+      "style": "IPY_MODEL_5f551f9b217e44cf8b5433f314b3844b",
+      "value": true
+     }
+    },
+    "0d2ae3466a3447c58e23ccd2b3733deb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_921a1a037f7b47f8b57d1da8192a437a",
+      "placeholder": "​",
+      "style": "IPY_MODEL_892ff4e2f0e44c23bc5c2be7547cf0bd",
+      "value": "generation_config.json: 100%"
+     }
+    },
+    "0e2beab611114239b6ee48a3cbb09c49": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "LabelModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "LabelModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "LabelView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_57b0096985ab44aea342e52795c4f999",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a4c404e420cc4ce781ce569f9ab3f987",
+      "value": "Token is valid (permission: write)."
+     }
+    },
+    "0ec2643d9fd44785addb37d9ecd23989": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "0f4c664612364dc89acf78eb1c740980": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0f54e8fda93144f6a95493e6ec535e9d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "0f60f9aa76b941809e013ffcae83604a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "124a70bfad434c5c946f611c04a91c8f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "14bf612f6ad7416c8ddd6085c72eee0e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "14c73d88df9e46e3bbb6690fdb48ad07": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "1561cd47c42e46368677d34e7b7084cd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_04188e0cec0542818894ebc6a534fb51",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4a13203d132b45beadf140c02dc8a566",
+      "value": " 518/518 [00:00&lt;00:00, 976.36 examples/s]"
+     }
+    },
+    "156f95b0012449e8a0c604e6e03bf35f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "17c797e08bd2493fa685918129415309": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "191caf3a38eb4191a35f623ce25238f9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1ae1d2702da5483a85504f59939ffa39": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8cd63d3908e4411c9fcb42bc32c8dd16",
+      "max": 73,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_64624b26145b42db82f7afc36c32e117",
+      "value": 73
+     }
+    },
+    "1b2abf90003e4165a3293acd6a5ea9ff": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_cffdf12fbe97462ab74e88ccca943aeb",
+      "placeholder": "​",
+      "style": "IPY_MODEL_bcaf4c81ba9d437bb6223dbb22d011ed",
+      "value": " 73.0/73.0 [00:00&lt;00:00, 4.75kB/s]"
+     }
+    },
+    "1bd0a270c7ee409c970763398e54fc36": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_076357d4bb9943bdaa1d6846897786af",
+      "placeholder": "​",
+      "style": "IPY_MODEL_7b3e136fc9e74a699497a947006f4f1d",
+      "value": " 1.11M/1.11M [00:00&lt;00:00, 8.23MB/s]"
+     }
+    },
+    "1d27ab2bc6ae463a806292b68b7891f8": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1f0efc167b3744b38ff832b71d529318": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_64911f0e52e74067a1a986c5edfc7f59",
+      "placeholder": "​",
+      "style": "IPY_MODEL_b4a274fc9e324b80bf559c4dbd05e319",
+      "value": "Downloading readme: 100%"
+     }
+    },
+    "1f59dd66813f419999336e59a3efc56a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1f75d85e6c7e4eb6a91b03f0c8adb644": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "1f82a5685eef4b47a2dbf7618362907c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "21bf14b771c14d2dab9e98a326302e14": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "23012118a7314a3f838870a2aee9ec90": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e297072ab5d64815b90bc89d22503378",
+      "placeholder": "​",
+      "style": "IPY_MODEL_67fbabb9082c4241b8f937b24e0cdd03",
+      "value": " 395/395 [00:00&lt;00:00, 16.6kB/s]"
+     }
+    },
+    "2540d57e3bf545e3812da1ee72b85fc8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "2558c2dd7d394ecf9fc67a69ce8fc97a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "25fc6aaf37fc49fa822df29236bf2f90": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "25fef90e209f4b14a73f3e39d226d913": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "27a587021d854b79a279a510a55f9d73": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d4092198673141d3b4a824d629d73f64",
+      "placeholder": "​",
+      "style": "IPY_MODEL_d3cbfd564fe8485ba7afdb1cc54abed3",
+      "value": "Map: 100%"
+     }
+    },
+    "2a57bb48e1c6475abba242994a79d44a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "2ab86b3fbd49488bb02f8205a572e752": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "30b74bd2db8d40d08408013cebcd7661": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "317cda72329c4043ab0b224b46b259d3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "31c10fa464e24f97b379675a204a09b5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_1d27ab2bc6ae463a806292b68b7891f8",
+      "max": 654,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_2a57bb48e1c6475abba242994a79d44a",
+      "value": 654
+     }
+    },
+    "31c574113731403b88edc5bb0798bc6d": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "347540dc03d34e65b7ffbb0f5fc569aa": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "34e381adbd9242759b57f2a305c5d2e3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "35186465f87341f683affb9399661540": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": "center",
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": "flex",
+      "flex": null,
+      "flex_flow": "column",
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": "50%"
+     }
+    },
+    "353bf45a4bbc46d6a798175f152399cb": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_740604526cc44cd58b811827d4787d96",
+      "placeholder": "​",
+      "style": "IPY_MODEL_2558c2dd7d394ecf9fc67a69ce8fc97a",
+      "value": "Generating test split: 100%"
+     }
+    },
+    "35c2c635c2024bcda3265bf95d330f63": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "37523a6cac1047e9a261698212d47737": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_191caf3a38eb4191a35f623ce25238f9",
+      "max": 20877686,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_30b74bd2db8d40d08408013cebcd7661",
+      "value": 20877686
+     }
+    },
+    "3b614b9712874fac990d2c557b0791a6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "3b82b8d41b134bec9bd77ed8d4f00eb4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_14bf612f6ad7416c8ddd6085c72eee0e",
+      "placeholder": "​",
+      "style": "IPY_MODEL_f7e59b47f9b74523843f37268212d566",
+      "value": " 23.9k/23.9k [00:00&lt;00:00, 1.51MB/s]"
+     }
+    },
+    "3b8bc5b9392e45758813a1db9db824a9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "3d9d8278667d496aaea1eaaa4d24ae93": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3e45aea9f7444a4db885c4cca4c9c4ff": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3f9fa554747743f8a86b40a4f7530617": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4227474e986546d1a7d31dce35a2410c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7e51e8e0612e46b1a3403d448b39aa50",
+      "max": 518,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_061c45266c484ff6807dcaf4722fd73b",
+      "value": 518
+     }
+    },
+    "42eb041021214110a860924d28d73409": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4c369386ba5f4862b11a50e50130663b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_bbdf3bb657e64fc2b0a90e78e8886480",
+      "value": " 5.00G/5.00G [00:24&lt;00:00, 249MB/s]"
+     }
+    },
+    "434fe18d50a14920b30fd2d0650297ac": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_353bf45a4bbc46d6a798175f152399cb",
+       "IPY_MODEL_bfcbfe4184774fd3a8320f4f0e1baf54",
+       "IPY_MODEL_99c5c846cc5e43429905f071670b4310"
+      ],
+      "layout": "IPY_MODEL_8d988c86648244788f6dc5aa0fea38fd"
+     }
+    },
+    "43d12a98d90a4bf7a96c033172c646e2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_c35b16156253402f90a432f3f07c2e0a",
+       "IPY_MODEL_1ae1d2702da5483a85504f59939ffa39",
+       "IPY_MODEL_1b2abf90003e4165a3293acd6a5ea9ff"
+      ],
+      "layout": "IPY_MODEL_3e45aea9f7444a4db885c4cca4c9c4ff"
+     }
+    },
+    "47944ad8cadf4a57b170193c46d4389c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4a13203d132b45beadf140c02dc8a566": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4a7c8dfd88db4bc893da2bced0560d47": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_27a587021d854b79a279a510a55f9d73",
+       "IPY_MODEL_4227474e986546d1a7d31dce35a2410c",
+       "IPY_MODEL_1561cd47c42e46368677d34e7b7084cd"
+      ],
+      "layout": "IPY_MODEL_8b9e961c837a464fb7a8c44756dc41e7"
+     }
+    },
+    "4b1f795c4c004cacbf3660d935e52995": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4bc1fd9d480a4799954c69031c071b30": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_068eb104d5d346b1897f8cbe9860d267",
+      "placeholder": "​",
+      "style": "IPY_MODEL_b621c6a8c0e9440fa840d75a1b1b02fc",
+      "value": " 9846/9846 [00:00&lt;00:00, 38881.08 examples/s]"
+     }
+    },
+    "4bdb196cd1494f809829651ec5b6cbf8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "4c369386ba5f4862b11a50e50130663b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4c8e98294bd240a6869cb199caee66e1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "4e1f5423311b4dc0930c21c9ad5a88f5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "51180cce01564821a170d1d4b8a9a918": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_03dd6c24f6d94fe7ab85b79d6f6cbeaf",
+       "IPY_MODEL_f2ab2fa803e94328a237e84cd4ea0027",
+       "IPY_MODEL_1bd0a270c7ee409c970763398e54fc36"
+      ],
+      "layout": "IPY_MODEL_e92b30d0b4234af6b5a33bff989b1b45"
+     }
+    },
+    "51b3af446ace409dbcdf5de499552061": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "53f287d4927541d08e2ae7d4d0b3c396": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "546b76a22f1046cd856a8fa2f9ff2d9f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5690d92586494b9187147f32fa708405": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "57b0096985ab44aea342e52795c4f999": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "57f251691b4c453896b2508c431dfc2f": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "57f87d4780634d36ae8159d987c22993": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_58ea619f81bf42ddb8b166db3deb0e86",
+       "IPY_MODEL_8bb83ae3229e4f38b1733f92f536fad0",
+       "IPY_MODEL_5c0104210ee34ca8a072ee5121f424a1"
+      ],
+      "layout": "IPY_MODEL_34e381adbd9242759b57f2a305c5d2e3"
+     }
+    },
+    "58ea619f81bf42ddb8b166db3deb0e86": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_e4e1a4338c5e46b3ba5a3bb960da7107",
+      "placeholder": "​",
+      "style": "IPY_MODEL_9a5072b8d16d4a1eb0652da61bda0ac8",
+      "value": "Loading checkpoint shards: 100%"
+     }
+    },
+    "5924b266e95a42039634a334ff561a82": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_eadeec171e7b4c0f9e26964f031cfb71",
+       "IPY_MODEL_feae525923d5407bb69a922954c474f7",
+       "IPY_MODEL_00371a48e64c45cd97020a78b710e64c"
+      ],
+      "layout": "IPY_MODEL_156f95b0012449e8a0c604e6e03bf35f"
+     }
+    },
+    "5962e77eea5a4d88ba6dbc5e9f51c709": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5a8ac674153248999007a713299b2644": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5b2a671976fa446db408d58a215b8249": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_63899ac621ff4e9cb8e215d5ab63bef8",
+      "max": 4,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_6b2b59d2b62b4f7da8c60ff783138397",
+      "value": 4
+     }
+    },
+    "5b56ac3009714a5a84dd8749db4a7bce": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_51b3af446ace409dbcdf5de499552061",
+      "placeholder": "​",
+      "style": "IPY_MODEL_9a12124915994b70a71ebd64b99e93e9",
+      "value": " 1.17G/1.17G [00:09&lt;00:00, 45.8MB/s]"
+     }
+    },
+    "5c0104210ee34ca8a072ee5121f424a1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_604582e8cbff4dc9876551a3307b5b77",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a98165ee656643ad85ac9ea1447cc775",
+      "value": " 4/4 [01:13&lt;00:00, 15.74s/it]"
+     }
+    },
+    "5cf4a57d21a545029b6448258a5ebd84": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_0d2ae3466a3447c58e23ccd2b3733deb",
+       "IPY_MODEL_ba7f32c41f9247ec9d4c40e6396b55a9",
+       "IPY_MODEL_ea1bdb5f2da64332960bccd967a84b4a"
+      ],
+      "layout": "IPY_MODEL_b08631e4cffa445c912da0c8eac2ef23"
+     }
+    },
+    "5f551f9b217e44cf8b5433f314b3844b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "5f60910d1e744432bdf87518f0f45874": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "5f6ffa1d929443a5bd9c7c550f0690f0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "LabelModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "LabelModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "LabelView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_93a50117ece543d4857ba02505dc4514",
+      "placeholder": "​",
+      "style": "IPY_MODEL_71a3a56edbdb45669d382fef4b097e1b",
+      "value": "Your token has been saved to /root/.cache/huggingface/token"
+     }
+    },
+    "5fb4a4ef8afe4ea4af6655faea17f354": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "604582e8cbff4dc9876551a3307b5b77": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "610e1ddfb7a44d51a54ebea6dad3a5f0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "6149752353fe4f9cbb7b26bcc25199a9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6cb8065803724d80b82b06dc95ded91e",
+      "placeholder": "​",
+      "style": "IPY_MODEL_8301c6302df54bbc9f15295f11cec208",
+      "value": " 654/654 [00:00&lt;00:00, 46.9kB/s]"
+     }
+    },
+    "63899ac621ff4e9cb8e215d5ab63bef8": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "63ac7dafeb27446cb30aaddf4cd27c9f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "64624b26145b42db82f7afc36c32e117": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "64911f0e52e74067a1a986c5edfc7f59": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "661f76474252493caae8f7d6aa8f99b7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_83c355e1418140a5bbad11bf0646b332",
+      "placeholder": "​",
+      "style": "IPY_MODEL_84d6d2a6afcd423f9b609cbb2d10f00e",
+      "value": " 20.9M/20.9M [00:00&lt;00:00, 44.7MB/s]"
+     }
+    },
+    "668a7f88506148a9ba2b48920afc028f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "LabelModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "LabelModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "LabelView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_53f287d4927541d08e2ae7d4d0b3c396",
+      "placeholder": "​",
+      "style": "IPY_MODEL_afa442ab223b46cb82569438c0047823",
+      "value": "Login successful"
+     }
+    },
+    "67b4473eb8a44a96ba34983762ab38fa": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6f474268da0f4337a2ccecc1ca2098a1",
+      "max": 4976698672,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_c2ceccfdb59b4336a24003cd6bc2403d",
+      "value": 4976698672
+     }
+    },
+    "67fbabb9082c4241b8f937b24e0cdd03": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "6b0ec8d5f7294d44a5fa15d8ef12471e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_8ea89e52123643268857285e0e1db1c0",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a8514e34378d47a28fbf0831a14ede8f",
+      "value": "tokenizer.json: 100%"
+     }
+    },
+    "6b2b59d2b62b4f7da8c60ff783138397": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "6b6ed29053ec4aaa8fc5526a35f17c2b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6bb9c7182d2a464ea21809e59043562a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "6cb8065803724d80b82b06dc95ded91e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "6f474268da0f4337a2ccecc1ca2098a1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7037c32dfce84e70ac86537dbbc6a495": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_0f4c664612364dc89acf78eb1c740980",
+      "placeholder": "​",
+      "style": "IPY_MODEL_0f60f9aa76b941809e013ffcae83604a",
+      "value": "config.json: 100%"
+     }
+    },
+    "71a3a56edbdb45669d382fef4b097e1b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "7243d8e2e1cc4043a2ee310eabd0ac09": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "740604526cc44cd58b811827d4787d96": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7504986b8d8d4d0da58ad79e80a81948": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7725e9d443e249ada02e5ac7056d00db": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "77704d2e27e94cd3a0c5f6b5ceeffd1c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_0f54e8fda93144f6a95493e6ec535e9d",
+      "max": 23950,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_880124db7dc04aaea09edd75e1ec7921",
+      "value": 23950
+     }
+    },
+    "791df472db174df69b8c9f0e200af254": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7a00aa4a97a34da39cc052c6926dbe13": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7ac8e88f29f04b859f592a003d39836b": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "7b3e136fc9e74a699497a947006f4f1d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "7cd50bcc8fcc4b83abcda6d3604bd4cc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "LabelModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "LabelModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "LabelView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7a00aa4a97a34da39cc052c6926dbe13",
+      "placeholder": "​",
+      "style": "IPY_MODEL_14c73d88df9e46e3bbb6690fdb48ad07",
+      "value": "Connecting..."
+     }
+    },
+    "7d3a7be9ed6f48988a2c4a1a4a2271cf": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f86b969ef69b48119619e1a424b50460",
+      "max": 9085698,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_7725e9d443e249ada02e5ac7056d00db",
+      "value": 9085698
+     }
+    },
+    "7e2e097c703a4a0d8556733a0739469c": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_e0fd6d00f0ba4e59bdaa5779556ec4ea",
+       "IPY_MODEL_cd318c6bfc8e421a9bfcdab16be5eaa7",
+       "IPY_MODEL_4bc1fd9d480a4799954c69031c071b30"
+      ],
+      "layout": "IPY_MODEL_25fc6aaf37fc49fa822df29236bf2f90"
+     }
+    },
+    "7e3a386e672f4748882211227b7721a9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ButtonStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ButtonStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "button_color": null,
+      "font_weight": ""
+     }
+    },
+    "7e51e8e0612e46b1a3403d448b39aa50": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "800e9453214848b69bc4c6ca2d5e8f79": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_6b0ec8d5f7294d44a5fa15d8ef12471e",
+       "IPY_MODEL_7d3a7be9ed6f48988a2c4a1a4a2271cf",
+       "IPY_MODEL_c40f583823574e40b6b29d4914143c0e"
+      ],
+      "layout": "IPY_MODEL_a4368e6da8f046aaa32f3152b7d333d1"
+     }
+    },
+    "8301c6302df54bbc9f15295f11cec208": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "8365680c634a44aa880317e36fa5e46e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "PasswordModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "PasswordModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "PasswordView",
+      "continuous_update": true,
+      "description": "Token:",
+      "description_tooltip": null,
+      "disabled": false,
+      "layout": "IPY_MODEL_31c574113731403b88edc5bb0798bc6d",
+      "placeholder": "​",
+      "style": "IPY_MODEL_3b8bc5b9392e45758813a1db9db824a9",
+      "value": ""
+     }
+    },
+    "83c355e1418140a5bbad11bf0646b332": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "849cdc1912aa4df4b0c721a8c63ca0f9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "84d6d2a6afcd423f9b609cbb2d10f00e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "854e35df771f470b82a59f878a2a6a46": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8800c351b6da450eace0c3890d36c8d7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_7037c32dfce84e70ac86537dbbc6a495",
+       "IPY_MODEL_31c10fa464e24f97b379675a204a09b5",
+       "IPY_MODEL_6149752353fe4f9cbb7b26bcc25199a9"
+      ],
+      "layout": "IPY_MODEL_0b145e421f4840f2872c29256b49f168"
+     }
+    },
+    "880124db7dc04aaea09edd75e1ec7921": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "88024cd312ee42c2925ebfbe52077780": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "892ff4e2f0e44c23bc5c2be7547cf0bd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "8a7c82dcbd414b24b67ccfbc562b2e38": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "8b9e961c837a464fb7a8c44756dc41e7": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8bb83ae3229e4f38b1733f92f536fad0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_1f75d85e6c7e4eb6a91b03f0c8adb644",
+      "max": 4,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_9da33f07ea354b5798e85298e132b017",
+      "value": 4
+     }
+    },
+    "8c149bc655a34fe5b91853c66db458a9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "8c4d6f4eea3742289a2604e66b0c6182": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "8cc86330c2af436c9af314e8c04c8c2b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "VBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "VBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "VBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_0e2beab611114239b6ee48a3cbb09c49",
+       "IPY_MODEL_006b78b5191b4fb888d98bdf6c20ec1e",
+       "IPY_MODEL_5f6ffa1d929443a5bd9c7c550f0690f0",
+       "IPY_MODEL_668a7f88506148a9ba2b48920afc028f"
+      ],
+      "layout": "IPY_MODEL_35186465f87341f683affb9399661540"
+     }
+    },
+    "8cd63d3908e4411c9fcb42bc32c8dd16": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8d0f1d547c384094b10aa00a3ede3c06": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_082b6990ce5e4812adc0ad6a7b376dac",
+      "placeholder": "​",
+      "style": "IPY_MODEL_610e1ddfb7a44d51a54ebea6dad3a5f0",
+      "value": "model-00003-of-00004.safetensors: 100%"
+     }
+    },
+    "8d988c86648244788f6dc5aa0fea38fd": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8ea89e52123643268857285e0e1db1c0": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "8f5b8c513b164dab9e0892422163c483": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_cd11fb7d54bb43ae821f2272d075a1b3",
+      "placeholder": "​",
+      "style": "IPY_MODEL_fbc6a2834c5442fbb6667f1b3612bb5b",
+      "value": "Downloading shards: 100%"
+     }
+    },
+    "90661b333d6f496ca606b3046622660e": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "921a1a037f7b47f8b57d1da8192a437a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "93a50117ece543d4857ba02505dc4514": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "974e3687f18a4e1a975969b880d086aa": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "99529129d7f0435da0fdcfc9803a2f11": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5a8ac674153248999007a713299b2644",
+      "max": 1168138808,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_1f82a5685eef4b47a2dbf7618362907c",
+      "value": 1168138808
+     }
+    },
+    "99c5c846cc5e43429905f071670b4310": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a2c543008f444cf49972a4f35c32b8e3",
+      "placeholder": "​",
+      "style": "IPY_MODEL_bb7b8a9e42f6478f851236685a1392d6",
+      "value": " 518/518 [00:00&lt;00:00, 13408.85 examples/s]"
+     }
+    },
+    "9a0b012915c54abeb100f466fa99d303": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_fffbf696c07744fc8e3d81ab51dc9c90",
+      "placeholder": "​",
+      "style": "IPY_MODEL_a153cc3ca0cc45c18a941bd57e363ec3",
+      "value": "model-00004-of-00004.safetensors: 100%"
+     }
+    },
+    "9a12124915994b70a71ebd64b99e93e9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "9a5072b8d16d4a1eb0652da61bda0ac8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "9bdebf06b6874bbb88404f4ad14e1dbc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5f60910d1e744432bdf87518f0f45874",
+      "max": 4915916176,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_2ab86b3fbd49488bb02f8205a572e752",
+      "value": 4915916176
+     }
+    },
+    "9cfaf17064bc49a5aded0fc53dd7cd7f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_ede66e196fa9482498f58dcdffd494a2",
+       "IPY_MODEL_a26cc7fea1a64d7bac1769d33cc74e28",
+       "IPY_MODEL_c2f24a8930be4b70b4bbbcf5d908b01d"
+      ],
+      "layout": "IPY_MODEL_1f59dd66813f419999336e59a3efc56a"
+     }
+    },
+    "9da33f07ea354b5798e85298e132b017": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "9f13437a44b8434b9cc3afab998e8d3c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a06b2bd0236249999adffa44e53cf80e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5fb4a4ef8afe4ea4af6655faea17f354",
+      "max": 395,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_b1a03a5e9bae46129830daeeb23bf6ff",
+      "value": 395
+     }
+    },
+    "a153cc3ca0cc45c18a941bd57e363ec3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a2249f364b914662b54045a1f8d6dfd1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_9f13437a44b8434b9cc3afab998e8d3c",
+      "placeholder": "​",
+      "style": "IPY_MODEL_8a7c82dcbd414b24b67ccfbc562b2e38",
+      "value": " 4.92G/4.92G [00:32&lt;00:00, 171MB/s]"
+     }
+    },
+    "a26cc7fea1a64d7bac1769d33cc74e28": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_854e35df771f470b82a59f878a2a6a46",
+      "max": 9846,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_d1cbe0ab9379453588eb438d13fd272d",
+      "value": 9846
+     }
+    },
+    "a2a7b715b16a41a288209dee1de5d2d1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a2c543008f444cf49972a4f35c32b8e3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a34b3fd5859a441f89cbe7f6e6df9da9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_8f5b8c513b164dab9e0892422163c483",
+       "IPY_MODEL_5b2a671976fa446db408d58a215b8249",
+       "IPY_MODEL_c934919f617447cfb9226929e7a68d79"
+      ],
+      "layout": "IPY_MODEL_124a70bfad434c5c946f611c04a91c8f"
+     }
+    },
+    "a4368e6da8f046aaa32f3152b7d333d1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a4c404e420cc4ce781ce569f9ab3f987": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a53b4776f95f4dd38197193e6c5f649e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_aea74071600f483b9e6de1a61743c03a",
+      "placeholder": "​",
+      "style": "IPY_MODEL_21bf14b771c14d2dab9e98a326302e14",
+      "value": "model-00002-of-00004.safetensors: 100%"
+     }
+    },
+    "a8514e34378d47a28fbf0831a14ede8f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "a8999d04e4114693bb6be358bdbe9b83": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "a98165ee656643ad85ac9ea1447cc775": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "aea74071600f483b9e6de1a61743c03a": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "afa442ab223b46cb82569438c0047823": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "b08631e4cffa445c912da0c8eac2ef23": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b0b7457a8b47496483da1506fb2505b3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "b1a03a5e9bae46129830daeeb23bf6ff": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "b1de7b283eeb41828e8093e60c83f2c4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_bb640a5c858349d29c13ce5629e72f22",
+       "IPY_MODEL_37523a6cac1047e9a261698212d47737",
+       "IPY_MODEL_661f76474252493caae8f7d6aa8f99b7"
+      ],
+      "layout": "IPY_MODEL_849cdc1912aa4df4b0c721a8c63ca0f9"
+     }
+    },
+    "b2a19b6092c44b20886987b30f1bf48a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_1f0efc167b3744b38ff832b71d529318",
+       "IPY_MODEL_a06b2bd0236249999adffa44e53cf80e",
+       "IPY_MODEL_23012118a7314a3f838870a2aee9ec90"
+      ],
+      "layout": "IPY_MODEL_dcff079d850c423a83eb70105b816ee4"
+     }
+    },
+    "b3b3f4ddd4ed4d938c923887939a0440": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_57f251691b4c453896b2508c431dfc2f",
+      "placeholder": "​",
+      "style": "IPY_MODEL_4bdb196cd1494f809829651ec5b6cbf8",
+      "value": "\n<b>Pro Tip:</b> If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks. </center>"
+     }
+    },
+    "b4a274fc9e324b80bf559c4dbd05e319": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "b4ba435f6d1c448f99b533bc6df32e76": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_35c2c635c2024bcda3265bf95d330f63",
+      "max": 4999802720,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_ec014d847e394a309b6a82c30a6fdfc5",
+      "value": 4999802720
+     }
+    },
+    "b621c6a8c0e9440fa840d75a1b1b02fc": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "ba7f32c41f9247ec9d4c40e6396b55a9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_4c8e98294bd240a6869cb199caee66e1",
+      "max": 177,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_4e1f5423311b4dc0930c21c9ad5a88f5",
+      "value": 177
+     }
+    },
+    "bac377ed96ae4e8db9b298bb623888ec": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "bb640a5c858349d29c13ce5629e72f22": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5962e77eea5a4d88ba6dbc5e9f51c709",
+      "placeholder": "​",
+      "style": "IPY_MODEL_f07c8a6ec12f46ea9e32a2208e70bccd",
+      "value": "Downloading data: 100%"
+     }
+    },
+    "bb7b8a9e42f6478f851236685a1392d6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "bbdf3bb657e64fc2b0a90e78e8886480": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "bcaf4c81ba9d437bb6223dbb22d011ed": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "bf77e5aaab0547f7b2beb015687552ef": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "bfcbfe4184774fd3a8320f4f0e1baf54": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a2a7b715b16a41a288209dee1de5d2d1",
+      "max": 518,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_bf77e5aaab0547f7b2beb015687552ef",
+      "value": 518
+     }
+    },
+    "c27e8ce031884a90b41d8220b1870bc4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c2ceccfdb59b4336a24003cd6bc2403d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "c2f24a8930be4b70b4bbbcf5d908b01d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_b0b7457a8b47496483da1506fb2505b3",
+      "placeholder": "​",
+      "style": "IPY_MODEL_c7dc386d978a44ff885763ecec94dc38",
+      "value": " 9846/9846 [00:09&lt;00:00, 1066.17 examples/s]"
+     }
+    },
+    "c35b16156253402f90a432f3f07c2e0a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_6b6ed29053ec4aaa8fc5526a35f17c2b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_e69cd88ccbae4bb7b238fa112a60f0f9",
+      "value": "special_tokens_map.json: 100%"
+     }
+    },
+    "c40f583823574e40b6b29d4914143c0e": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_f81756eb9e554899b0778311f2c407c4",
+      "placeholder": "​",
+      "style": "IPY_MODEL_3b614b9712874fac990d2c557b0791a6",
+      "value": " 9.09M/9.09M [00:00&lt;00:00, 19.3MB/s]"
+     }
+    },
+    "c56d8289513441688f9bc5f4b52d60a0": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_a53b4776f95f4dd38197193e6c5f649e",
+       "IPY_MODEL_b4ba435f6d1c448f99b533bc6df32e76",
+       "IPY_MODEL_42eb041021214110a860924d28d73409"
+      ],
+      "layout": "IPY_MODEL_17c797e08bd2493fa685918129415309"
+     }
+    },
+    "c7dc386d978a44ff885763ecec94dc38": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "c7e06fd82f7f4f9fb81c68e8758f2de1": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a8999d04e4114693bb6be358bdbe9b83",
+      "placeholder": "​",
+      "style": "IPY_MODEL_2540d57e3bf545e3812da1ee72b85fc8",
+      "value": " 4.98G/4.98G [00:34&lt;00:00, 232MB/s]"
+     }
+    },
+    "c84f542c863043dea8a3675fa153e78d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ButtonModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ButtonModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ButtonView",
+      "button_style": "",
+      "description": "Login",
+      "disabled": false,
+      "icon": "",
+      "layout": "IPY_MODEL_d2d81cc8296c4b10bf80b86c0a3302d3",
+      "style": "IPY_MODEL_7e3a386e672f4748882211227b7721a9",
+      "tooltip": ""
+     }
+    },
+    "c934919f617447cfb9226929e7a68d79": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_c27e8ce031884a90b41d8220b1870bc4",
+      "placeholder": "​",
+      "style": "IPY_MODEL_88024cd312ee42c2925ebfbe52077780",
+      "value": " 4/4 [01:41&lt;00:00, 22.30s/it]"
+     }
+    },
+    "cc5ce633746949ed98418cae9f68afe3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "cd11fb7d54bb43ae821f2272d075a1b3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "cd318c6bfc8e421a9bfcdab16be5eaa7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_d10ba011d05045b18bbfeb9660e4d9d3",
+      "max": 9846,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_e56c22f77c884caaacfafd48dfa51a55",
+      "value": 9846
+     }
+    },
+    "cf6d1be81b6c4ffc81ce8fdabfc5ad28": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_07e0aed682fd4cc88fa75c0592dc04a7",
+       "IPY_MODEL_67b4473eb8a44a96ba34983762ab38fa",
+       "IPY_MODEL_c7e06fd82f7f4f9fb81c68e8758f2de1"
+      ],
+      "layout": "IPY_MODEL_3d9d8278667d496aaea1eaaa4d24ae93"
+     }
+    },
+    "cffdf12fbe97462ab74e88ccca943aeb": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d10ba011d05045b18bbfeb9660e4d9d3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d1508f5cde9a43d8abc26dd2d0c34dbd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_9a0b012915c54abeb100f466fa99d303",
+       "IPY_MODEL_99529129d7f0435da0fdcfc9803a2f11",
+       "IPY_MODEL_5b56ac3009714a5a84dd8749db4a7bce"
+      ],
+      "layout": "IPY_MODEL_546b76a22f1046cd856a8fa2f9ff2d9f"
+     }
+    },
+    "d1cbe0ab9379453588eb438d13fd272d": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "d2d81cc8296c4b10bf80b86c0a3302d3": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d3cbfd564fe8485ba7afdb1cc54abed3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "d4092198673141d3b4a824d629d73f64": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "d7ef74cf4a914ad38a69c84c34fff393": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_8d0f1d547c384094b10aa00a3ede3c06",
+       "IPY_MODEL_9bdebf06b6874bbb88404f4ad14e1dbc",
+       "IPY_MODEL_a2249f364b914662b54045a1f8d6dfd1"
+      ],
+      "layout": "IPY_MODEL_7504986b8d8d4d0da58ad79e80a81948"
+     }
+    },
+    "db05b25cb38140bdb21e6f3b7fde7e66": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "dcff079d850c423a83eb70105b816ee4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "de3757d6125a4c07b502dd60816bafec": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e0fd6d00f0ba4e59bdaa5779556ec4ea": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_7ac8e88f29f04b859f592a003d39836b",
+      "placeholder": "​",
+      "style": "IPY_MODEL_0ec2643d9fd44785addb37d9ecd23989",
+      "value": "Generating train split: 100%"
+     }
+    },
+    "e25f9ca445b14e3f8397779df071dfb4": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_791df472db174df69b8c9f0e200af254",
+      "placeholder": "​",
+      "style": "IPY_MODEL_6bb9c7182d2a464ea21809e59043562a",
+      "value": "<center> <img\nsrc=https://huggingface.co/front/assets/huggingface_logo-noborder.svg\nalt='Hugging Face'> <br> Copy a token from <a\nhref=\"https://huggingface.co/settings/tokens\" target=\"_blank\">your Hugging Face\ntokens page</a> and paste it below. <br> Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file. </center>"
+     }
+    },
+    "e297072ab5d64815b90bc89d22503378": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e4e1a4338c5e46b3ba5a3bb960da7107": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "e56c22f77c884caaacfafd48dfa51a55": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "e69cd88ccbae4bb7b238fa112a60f0f9": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "e92b30d0b4234af6b5a33bff989b1b45": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "ea1bdb5f2da64332960bccd967a84b4a": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_347540dc03d34e65b7ffbb0f5fc569aa",
+      "placeholder": "​",
+      "style": "IPY_MODEL_7243d8e2e1cc4043a2ee310eabd0ac09",
+      "value": " 177/177 [00:00&lt;00:00, 11.4kB/s]"
+     }
+    },
+    "eadeec171e7b4c0f9e26964f031cfb71": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_de3757d6125a4c07b502dd60816bafec",
+      "placeholder": "​",
+      "style": "IPY_MODEL_8c4d6f4eea3742289a2604e66b0c6182",
+      "value": "tokenizer_config.json: 100%"
+     }
+    },
+    "ec014d847e394a309b6a82c30a6fdfc5": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": ""
+     }
+    },
+    "ede66e196fa9482498f58dcdffd494a2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_026072374b7d47c194707a50f5c99099",
+      "placeholder": "​",
+      "style": "IPY_MODEL_63ac7dafeb27446cb30aaddf4cd27c9f",
+      "value": "Map: 100%"
+     }
+    },
+    "ee4e4af964ec4dd597cb04a90f0697f9": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f07c8a6ec12f46ea9e32a2208e70bccd": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "f2ab2fa803e94328a237e84cd4ea0027": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_5690d92586494b9187147f32fa708405",
+      "max": 1105272,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_317cda72329c4043ab0b224b46b259d3",
+      "value": 1105272
+     }
+    },
+    "f4ca7b63d7d749ff83a848e250f03ec1": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f7e59b47f9b74523843f37268212d566": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "f81756eb9e554899b0778311f2c407c4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "f86b969ef69b48119619e1a424b50460": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "fbc6a2834c5442fbb6667f1b3612bb5b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "feae525923d5407bb69a922954c474f7": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_bac377ed96ae4e8db9b298bb623888ec",
+      "max": 50566,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_02d6cc4c2717434c895798601bda7c86",
+      "value": 50566
+     }
+    },
+    "ffe561df8772443ebf40a3b8b656079f": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "fffbf696c07744fc8e3d81ab51dc9c90": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    }
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/examples/randlora_finetuning/randlora_finetuning.py b/examples/randlora_finetuning/randlora_finetuning.py
new file mode 100644
index 0000000..41e9531
--- /dev/null
+++ b/examples/randlora_finetuning/randlora_finetuning.py
@@ -0,0 +1,230 @@
+# This script is based on examples/dora_finetuning/dora_finetuning.py
+import os
+
+import torch
+from datasets import load_dataset
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    BitsAndBytesConfig,
+    DataCollatorForLanguageModeling,
+    Trainer,
+    TrainingArguments,
+)
+
+from peft import LoraConfig, RandLoraConfig, get_peft_model, prepare_model_for_kbit_training
+
+
+def train_model(
+    base_model: str,
+    data_path: str,
+    output_dir: str,
+    batch_size: int,
+    num_epochs: int,
+    learning_rate: float,
+    cutoff_len: int,
+    val_set_size: int,
+    use_lora: bool,
+    quantize: bool,
+    eval_step: int,
+    save_step: int,
+    device: str,
+    rank: int,
+    randlora_alpha: int,
+    randlora_dropout: float,
+    randlora_target_modules: str,
+    hub_model_id: str,
+    push_to_hub: bool,
+    sparse: bool,
+    very_sparse: bool,
+):
+    os.environ["TOKENIZERS_PARALLELISM"] = "false"
+    hf_token = os.getenv("HF_TOKEN")
+
+    # Setup device
+    device = torch.device(device)
+    print(f"Using device: {device}")
+
+    # load tokenizer
+    tokenizer = AutoTokenizer.from_pretrained(base_model, token=hf_token)
+
+    # Compute type
+    device_type = device.type
+    device_module = getattr(torch, device_type, torch.cuda)
+    bf16_suppotrted = device_module.is_available() and device_module.is_bf16_supported()
+    dtype = torch.bfloat16 if bf16_suppotrted else torch.float16
+
+    # QRandLora (quantized randlora): IF YOU WANNA QUANTIZE THE MODEL
+    if quantize:
+        model = AutoModelForCausalLM.from_pretrained(
+            base_model,
+            token=hf_token,
+            quantization_config=BitsAndBytesConfig(
+                load_in_4bit=True,
+                bnb_4bit_compute_dtype=torch.bfloat16 if bf16_suppotrted else torch.float16,
+                bnb_4bit_use_double_quant=True,
+                bnb_4bit_quant_type="nf4",
+            ),
+            dtype=dtype,
+        )
+        # setup for quantized training
+        model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True)
+    else:
+        model = AutoModelForCausalLM.from_pretrained(
+            base_model,
+            dtype=dtype,
+            token=hf_token,
+        )
+    # LoRa config for the PEFT model
+    if use_lora:
+        peft_config = LoraConfig(
+            r=rank,  # Rank of matrix
+            lora_alpha=randlora_alpha,
+            target_modules=(randlora_target_modules.split(",") if randlora_target_modules else ["k_proj", "v_proj"]),
+            lora_dropout=randlora_dropout,
+            bias="none",
+        )
+    else:
+        peft_config = RandLoraConfig(
+            r=rank,  # Rank of random bases
+            randlora_alpha=randlora_alpha,
+            target_modules=(randlora_target_modules.split(",") if randlora_target_modules else ["k_proj", "v_proj"]),
+            randlora_dropout=randlora_dropout,
+            bias="none",
+            sparse=sparse,
+            very_sparse=very_sparse,
+        )
+
+    # get the peft model with RandLora config
+    model = get_peft_model(model, peft_config)
+
+    model.to(device)  # MODEL TO ACCELERATOR
+    tokenizer.pad_token = tokenizer.eos_token
+
+    # Load the dataset
+    dataset = load_dataset(data_path)
+
+    def tokenize_function(examples):
+        inputs = tokenizer(examples["text"], padding="max_length", truncation=True, max_length=cutoff_len)
+        inputs["labels"] = inputs["input_ids"].copy()  # setting labels for a language modeling task
+        return inputs
+
+    # Tokenize the dataset and prepare for training
+    tokenized_datasets = dataset.map(tokenize_function, batched=True, remove_columns=dataset["train"].column_names)
+
+    # Data collator to dynamically pad the batched examples
+    data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)
+
+    # Compute the total amount of training step for warmup
+    max_steps = int((len(dataset) // batch_size) * num_epochs)
+
+    # Define training arguments
+    training_args = TrainingArguments(
+        output_dir=output_dir,
+        num_train_epochs=num_epochs,
+        per_device_train_batch_size=batch_size,
+        per_device_eval_batch_size=batch_size,
+        warmup_steps=int(max_steps * 0.1),  # 10% of total training steps
+        weight_decay=0.01,
+        logging_dir="./logs",
+        logging_steps=eval_step,
+        save_steps=save_step,
+        save_total_limit=2,
+        push_to_hub=push_to_hub,
+        hub_model_id=hub_model_id,
+        gradient_accumulation_steps=16
+        // batch_size,  # Maintaining a minimum batch size of 16 post accumulation is recommended to ensure good performance
+        learning_rate=learning_rate,
+        hub_token=hf_token,
+        label_names=["labels"],
+    )
+
+    # Clear accelerator cache to free memory
+    device_module.empty_cache()
+
+    # Initialize the Trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=tokenized_datasets["train"],
+        eval_dataset=tokenized_datasets["test"],
+        data_collator=data_collator,
+    )
+
+    # Start model training
+    trainer.train()
+
+    # Save and push the trained model and tokenizer
+    if push_to_hub:
+        # Push the main model to the hub
+        trainer.push_to_hub(commit_message="Fine-tuned model")
+
+    # Save the model and tokenizer locally
+    model.save_pretrained(output_dir)
+    tokenizer.save_pretrained(output_dir)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Fine-tune LLaMA with DoRA and PEFT")
+    parser.add_argument("--base_model", type=str, default="huggyllama/llama-7b", help="Base model path or name")
+    parser.add_argument(
+        "--data_path", type=str, default="timdettmers/openassistant-guanaco", help="Dataset path or name"
+    )
+    parser.add_argument(
+        "--output_dir", type=str, default="path/to/output", help="Output directory for the fine-tuned model"
+    )
+    parser.add_argument("--batch_size", type=int, default=1, help="Batch size")
+    parser.add_argument("--num_epochs", type=int, default=1, help="Number of training epochs")
+    parser.add_argument("--learning_rate", type=float, default=3e-4, help="Learning rate")
+    parser.add_argument("--cutoff_len", type=int, default=512, help="Cutoff length for tokenization")
+    parser.add_argument("--val_set_size", type=int, default=500, help="Validation set size")
+    parser.add_argument("--use_lora", action="store_true", help="Apply Lora instead of RandLora")
+    parser.add_argument("--quantize", action="store_true", help="Use quantization")
+    parser.add_argument("--eval_step", type=int, default=10, help="Evaluation step interval")
+    parser.add_argument("--save_step", type=int, default=100, help="Save step interval")
+    parser.add_argument("--device", type=str, default="auto", help="Device to use for training")
+    parser.add_argument("--rank", type=int, default=32, help="RandLora basis rank")
+    parser.add_argument("--randlora_alpha", type=int, default=640, help="RandLora alpha")
+    parser.add_argument("--randlora_dropout", type=float, default=0.05, help="RandLora dropout rate")
+    parser.add_argument(
+        "--randlora_target_modules", type=str, default=None, help="Comma-separated list of target modules for RandLora"
+    )
+    parser.add_argument("--sparse", action="store_true", help="Use sparse matrix multiplication")
+    parser.add_argument("--very_sparse", action="store_true", help="Use very sparse matrix multiplication")
+    parser.add_argument(
+        "--hub_model_id",
+        type=str,
+        default="path/to/repo",
+        help="Repository name to push the model on the Hugging Face Hub",
+    )
+    parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to Hugging Face Hub")
+    args = parser.parse_args()
+
+    if args.device == "auto":
+        args.device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+
+    train_model(
+        base_model=args.base_model,
+        data_path=args.data_path,
+        output_dir=args.output_dir,
+        batch_size=args.batch_size,
+        num_epochs=args.num_epochs,
+        learning_rate=args.learning_rate,
+        cutoff_len=args.cutoff_len,
+        val_set_size=args.val_set_size,
+        use_lora=args.use_lora,
+        quantize=args.quantize,
+        eval_step=args.eval_step,
+        save_step=args.save_step,
+        device=args.device,
+        rank=args.rank,
+        randlora_alpha=args.randlora_alpha,
+        randlora_dropout=args.randlora_dropout,
+        randlora_target_modules=args.randlora_target_modules,
+        hub_model_id=args.hub_model_id,
+        push_to_hub=args.push_to_hub,
+        sparse=args.sparse,
+        very_sparse=args.very_sparse,
+    )
diff --git a/examples/road_finetuning/README.md b/examples/road_finetuning/README.md
new file mode 100644
index 0000000..3d87165
--- /dev/null
+++ b/examples/road_finetuning/README.md
@@ -0,0 +1,88 @@
+# RoAd: 3-in-1: 2D Rotary Adaptation for Efficient Finetuning, Efficient Batching and Composability
+
+
+## Introduction
+
+[RoAd](https://huggingface.co/papers/2409.00119) is a novel method that adapts LLMs using simple 2D rotations. It is highly parameter-efficient,
+achieving strong performance with less than 0.1% trainable parameters.
+RoAd also supports efficient serving of mixed-adapter requests within a batch, incurring only element-wise computation overhead rather than costly batch matrix multiplications.
+Additionally, it improves model interpretability through structured and composable transformations.
+
+## Quick start
+```python
+import torch
+from peft import RoadConfig, get_peft_model
+from transformers import AutoTokenizer, AutoModelForCausalLM, Trainer
+from datasets import load_dataset
+
+model = AutoModelForCausalLM.from_pretrained("huggyllama/llama-7b", device_map="cuda")
+tokenizer = AutoTokenizer.from_pretrained("huggyllama/llama-7b")
+dataset = load_dataset("timdettmers/openassistant-guanaco", split="train")
+road_config = RoadConfig(
+    variant="1",
+)
+peft_model = get_peft_model(model, road_config)
+trainer = transformers.Trainer(
+    model=peft_model,
+    train_dataset=dataset,
+    dataset_text_field="text",
+    max_length=2048,
+    tokenizer=tokenizer,
+)
+trainer.train()
+peft_model.save_pretrained("road-llama-3-8b")
+```
+
+RoAd requires a higher learning rate compared to LoRa and similar approaches, set it to around 1e-3.
+
+Run the finetuning script simply by running:
+
+```bash
+python examples/road_finetuning/road_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --data_path timdettmers/openassistant-guanaco
+```
+
+RoAd also supports quantization. To use 4-bit quantization try:
+
+```bash
+python examples/road_finetuning/road_finetuning.py --base_model meta-llama/Meta-Llama-3-8B --quantize
+```
+
+### Full example of the script 
+```bash
+python road_finetuning.py \
+    --base_model "PATH_TO_MODEL" \
+    --data_path "PATH_TO_DATASET" \
+    --output_dir "PATH_TO_OUTPUT_DIR" \
+    --batch_size 1 \
+    --num_epochs 3 \
+    --learning_rate 1e-3 \
+    --cutoff_len 512 \
+    --val_set_size 500 \
+    --quantize \
+    --eval_step 10 \
+    --save_step 100 \
+    --device "cuda:0" \
+    --variant 1 \
+    --road_target_modules "q_proj,k_proj,v_proj,o_proj" \
+    --hub_model_id "YOUR_HF_REPO" \
+    --push_to_hub
+```
+## Use the model on 🤗
+You can load and use the model as any other 🤗 models.
+```python
+from transformers import AutoModel
+model = AutoModel.from_pretrained("ppetrushkov/llama-2-7b-sql-road-test")
+```
+
+
+## Citation
+```
+@inproceedings{
+    liao2024in,
+    title={3-in-1: 2D Rotary Adaptation for Efficient Finetuning, Efficient Batching and Composability},
+    author={Baohao Liao and Christof Monz},
+    booktitle={The Thirty-eighth Annual Conference on Neural Information Processing Systems},
+    year={2024},
+    url={https://openreview.net/forum?id=rYjYwuM6yH}
+}
+```
diff --git a/examples/road_finetuning/road_finetuning.py b/examples/road_finetuning/road_finetuning.py
new file mode 100644
index 0000000..0469785
--- /dev/null
+++ b/examples/road_finetuning/road_finetuning.py
@@ -0,0 +1,203 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+import os
+
+import torch
+from datasets import load_dataset
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    BitsAndBytesConfig,
+    DataCollatorForLanguageModeling,
+    Trainer,
+    TrainingArguments,
+)
+
+from peft import RoadConfig, get_peft_model, prepare_model_for_kbit_training
+
+
+def train_model(
+    base_model: str,
+    data_path: str,
+    output_dir: str,
+    batch_size: int,
+    num_epochs: int,
+    learning_rate: float,
+    cutoff_len: int,
+    val_set_size: int,
+    quantize: bool,
+    eval_step: int,
+    save_step: int,
+    device: str,
+    variant: str,
+    road_target_modules: str,
+    hub_model_id: str,
+    push_to_hub: bool,
+):
+    os.environ["TOKENIZERS_PARALLELISM"] = "false"
+    hf_token = os.getenv("HF_TOKEN")
+
+    # Setup device
+    device = torch.device(device)
+    print(f"Using device: {device}")
+
+    # load tokenizer
+    tokenizer = AutoTokenizer.from_pretrained(base_model, token=hf_token)
+
+    # IF YOU WANNA QUANTIZE THE MODEL
+    if quantize:
+        model = AutoModelForCausalLM.from_pretrained(
+            base_model,
+            token=hf_token,
+            quantization_config=BitsAndBytesConfig(
+                load_in_4bit=True,
+                bnb_4bit_compute_dtype=(
+                    torch.bfloat16 if torch.cuda.is_available() and torch.cuda.is_bf16_supported() else torch.float16
+                ),
+                bnb_4bit_use_double_quant=True,
+                bnb_4bit_quant_type="nf4",
+            ),
+        )
+        # setup for quantized training
+        model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True)
+    else:
+        model = AutoModelForCausalLM.from_pretrained(base_model, token=hf_token, device_map="auto")
+    # RoAd config for the PEFT model
+    road_config = RoadConfig(
+        variant=variant,  # Rank of matrix
+        target_modules=(
+            road_target_modules.split(",")
+            if road_target_modules
+            else ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
+        ),
+    )
+
+    # get the peft model with RoAd config
+    model = get_peft_model(model, road_config)
+
+    model.to(device)  # MODEL TO GPU/CUDA
+    tokenizer.pad_token = tokenizer.eos_token
+
+    # Load the dataset
+    dataset = load_dataset(data_path)
+
+    def tokenize_function(examples):
+        inputs = tokenizer(examples["text"], padding="max_length", truncation=True, max_length=cutoff_len)
+        inputs["labels"] = inputs["input_ids"].copy()  # setting labels for a language modeling task
+        return inputs
+
+    # Tokenize the dataset and prepare for training
+    tokenized_datasets = dataset.map(tokenize_function, batched=True, remove_columns=dataset["train"].column_names)
+
+    # Data collator to dynamically pad the batched examples
+    data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)
+
+    # Define training arguments
+    training_args = TrainingArguments(
+        output_dir=output_dir,
+        num_train_epochs=num_epochs,
+        per_device_train_batch_size=batch_size,
+        per_device_eval_batch_size=batch_size,
+        warmup_steps=100,
+        weight_decay=0.01,
+        logging_dir="./logs",
+        logging_steps=eval_step,
+        save_steps=save_step,
+        save_total_limit=2,
+        push_to_hub=push_to_hub,
+        hub_model_id=hub_model_id,
+        gradient_accumulation_steps=16,
+        fp16=True,
+        learning_rate=learning_rate,
+        hub_token=hf_token,
+    )
+
+    # Clear CUDA cache to free memory
+    torch.cuda.empty_cache()
+
+    # Initialize the Trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=tokenized_datasets["train"],
+        eval_dataset=tokenized_datasets["test"],
+        data_collator=data_collator,
+    )
+
+    # Start model training
+    trainer.train()
+
+    # Save and push the trained model and tokenizer
+    if push_to_hub:
+        # Push the main model to the hub
+        trainer.push_to_hub(commit_message="Fine-tuned model")
+
+    # Save the model and tokenizer locally
+    model.save_pretrained(output_dir)
+    tokenizer.save_pretrained(output_dir)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Fine-tune LLaMA with DoRA and PEFT")
+    parser.add_argument("--base_model", type=str, default="huggyllama/llama-7b", help="Base model path or name")
+    parser.add_argument(
+        "--data_path", type=str, default="timdettmers/openassistant-guanaco", help="Dataset path or name"
+    )
+    parser.add_argument(
+        "--output_dir", type=str, default="path/to/output", help="Output directory for the fine-tuned model"
+    )
+    parser.add_argument("--batch_size", type=int, default=1, help="Batch size")
+    parser.add_argument("--num_epochs", type=int, default=1, help="Number of training epochs")
+    parser.add_argument("--learning_rate", type=float, default=3e-3, help="Learning rate")
+    parser.add_argument("--cutoff_len", type=int, default=512, help="Cutoff length for tokenization")
+    parser.add_argument("--val_set_size", type=int, default=500, help="Validation set size")
+    parser.add_argument("--quantize", action="store_true", help="Use quantization")
+    parser.add_argument("--eval_step", type=int, default=10, help="Evaluation step interval")
+    parser.add_argument("--save_step", type=int, default=100, help="Save step interval")
+    parser.add_argument("--device", type=str, default="cuda:0", help="Device to use for training")
+    parser.add_argument(
+        "--variant", type=str, default="road_1", choices=["road_1", "road_2", "road_4"], help="RoAD variant"
+    )
+    parser.add_argument(
+        "--road_target_modules", type=str, default=None, help="Comma-separated list of target modules for RoAd"
+    )
+    parser.add_argument(
+        "--hub_model_id",
+        type=str,
+        default="path/to/repo",
+        help="Repository name to push the model on the Hugging Face Hub",
+    )
+    parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to Hugging Face Hub")
+    args = parser.parse_args()
+    train_model(
+        base_model=args.base_model,
+        data_path=args.data_path,
+        output_dir=args.output_dir,
+        batch_size=args.batch_size,
+        num_epochs=args.num_epochs,
+        learning_rate=args.learning_rate,
+        cutoff_len=args.cutoff_len,
+        val_set_size=args.val_set_size,
+        quantize=args.quantize,
+        eval_step=args.eval_step,
+        save_step=args.save_step,
+        device=args.device,
+        variant=args.variant,
+        road_target_modules=args.road_target_modules,
+        hub_model_id=args.hub_model_id,
+        push_to_hub=args.push_to_hub,
+    )
diff --git a/examples/semantic_segmentation/README.md b/examples/semantic_segmentation/README.md
new file mode 100644
index 0000000..fa23cb0
--- /dev/null
+++ b/examples/semantic_segmentation/README.md
@@ -0,0 +1,7 @@
+# Fine-tuning for semantic segmentation using LoRA and 🤗 PEFT
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/huggingface/peft/blob/main/examples/semantic_segmentation/semantic_segmentation_peft_lora.ipynb) 
+
+We provide a notebook (`semantic_segmentation_peft_lora.ipynb`) where we learn how to use [LoRA](https://huggingface.co/papers/2106.09685) from 🤗 PEFT to fine-tune an semantic segmentation by ONLY using **14%%** of the original trainable parameters of the model. 
+
+LoRA adds low-rank "update matrices" to certain blocks in the underlying model (in this case the attention blocks) and ONLY trains those matrices during fine-tuning. During inference, these update matrices are _merged_ with the original model parameters. For more details, check out the [original LoRA paper](https://huggingface.co/papers/2106.09685). 
diff --git a/examples/semantic_segmentation/semantic_segmentation_peft_lora.ipynb b/examples/semantic_segmentation/semantic_segmentation_peft_lora.ipynb
new file mode 100644
index 0000000..e215032
--- /dev/null
+++ b/examples/semantic_segmentation/semantic_segmentation_peft_lora.ipynb
@@ -0,0 +1,1556 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "JAeWcsvLF2_6"
+   },
+   "source": [
+    "## Introduction\n",
+    "\n",
+    "In this notebook, we will learn how to use [LoRA](https://huggingface.co/papers/2106.09685) from 🤗 PEFT to fine-tune a SegFormer model variant for semantic segmentation by ONLY using **14%** of the original trainable parameters of the model. \n",
+    "\n",
+    "LoRA adds low-rank \"update matrices\" to certain blocks in the underlying model (in this case the attention blocks) and ONLY trains those matrices during fine-tuning. During inference, these update matrices are _merged_ with the original model parameters. For more details, check out the [original LoRA paper](https://huggingface.co/papers/2106.09685). \n",
+    "\n",
+    "Let's get started by installing the dependencies. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "lveGHtBcGNyc"
+   },
+   "source": [
+    "## Install dependencies\n",
+    "\n",
+    "Here we're installing `peft` from source to ensure we have access to all the bleeding edge features of `peft`. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "lbYTKXv4ZTwg",
+    "outputId": "5a033ebd-6bbd-4bf4-802c-a1bac6a48a07"
+   },
+   "outputs": [],
+   "source": [
+    "!pip install transformers accelerate evaluate datasets==3.6.0 git+https://github.com/huggingface/peft -q"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "B0fmCvTsGPah"
+   },
+   "source": [
+    "## Authentication\n",
+    "\n",
+    "We will share our fine-tuned model at the end of training. So, to do that we just authenticate using our 🤗 token. This token is available from [here](https://huggingface.co/settings/tokens). If you don't have a 🤗 account already, we highly encourage you to do so; it's free!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 331,
+     "referenced_widgets": [
+      "f2a722f371904cce80dc1c087b153ad6",
+      "6c88a55a635b4c9f946a1aa838d69f20",
+      "6c6d19cd893e4d82bae9972fa10c6d74",
+      "fc48ee28c2e44f1daa03149c8004c314",
+      "cb4053f102fc4207a1c9513f81ad6415",
+      "0dcc5a2866a349e0843673bef499dc66",
+      "b7431f99d93b4e9b8c8177ac4a7b4070",
+      "14ac809ba0bc4cd5bcd51f83105947b0",
+      "e7393e78f41b496495982490b72ef2a3",
+      "42a7b8268d8945b5bbe9d3f20bc8840c",
+      "554b55f29a5e4d5a81608d912d3635e8",
+      "3f69c7b15e5e48039777e4b6b1a51f53",
+      "5bcfe3da0ffb41ccbb9404ac35ae8945",
+      "21bf954f54db41e6ba78f76195721614",
+      "f83dd354396e4aa3acd214a6fd98efb2",
+      "24fde588dc1a49a397e379cda320ed71",
+      "9746875e74b845daab06619393b4d46b"
+     ]
+    },
+    "id": "OYhwMOj5ZTwm",
+    "outputId": "ff2d4cc4-4363-4093-8bdc-763761cbe3ef"
+   },
+   "outputs": [],
+   "source": [
+    "from huggingface_hub import notebook_login\n",
+    "\n",
+    "notebook_login()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "B9Cu7j_QGVbH"
+   },
+   "source": [
+    "## Load a dataset\n",
+    "\n",
+    "We're only loading the first 150 instances from the training set of the [SceneParse150 dataset](https://huggingface.co/datasets/scene_parse_150) to keep this example runtime short. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "sGJWDwtHZTwn",
+    "outputId": "260c874e-1844-42ba-9dc2-0f727e2930cc"
+   },
+   "outputs": [],
+   "source": [
+    "from datasets import load_dataset\n",
+    "\n",
+    "ds = load_dataset(\"scene_parse_150\", split=\"train[:150]\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "RpSPx8EHGeLM"
+   },
+   "source": [
+    "## Prepare train and test splits"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {
+    "id": "ydWKIqCUZTwo"
+   },
+   "outputs": [],
+   "source": [
+    "ds = ds.train_test_split(test_size=0.1)\n",
+    "train_ds = ds[\"train\"]\n",
+    "test_ds = ds[\"test\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "yHtqAQ2WGhlR"
+   },
+   "source": [
+    "## Prepare label mappers\n",
+    "\n",
+    "We create two dictionaries:\n",
+    "\n",
+    "* `label2id`: maps the semantic classes of the dataset to integer ids.\n",
+    "* `id2label`: `label2id` reversed. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "Hu8Y4dEIZTwq",
+    "outputId": "eba72235-c1a7-4c95-8c89-5ef5588d6581"
+   },
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "from huggingface_hub import hf_hub_download\n",
+    "\n",
+    "repo_id = \"huggingface/label-files\"\n",
+    "filename = \"ade20k-id2label.json\"\n",
+    "id2label = json.load(open(hf_hub_download(repo_id=repo_id, filename=filename, repo_type=\"dataset\"), \"r\"))\n",
+    "id2label = {int(k): v for k, v in id2label.items()}\n",
+    "label2id = {v: k for k, v in id2label.items()}\n",
+    "num_labels = len(id2label)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "5V8nhdt0HBsk"
+   },
+   "source": [
+    "## Prepare datasets for training and evaluation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "fNi_TKYpZTwq",
+    "outputId": "a28647b4-0deb-49cc-a1b8-c4a2ab99bb4d"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.11/dist-packages/transformers/image_processing_base.py:412: UserWarning: The following named arguments are not valid for `SegformerImageProcessor.__init__` and were ignored: 'reduce_labels'\n",
+      "  image_processor = cls(**image_processor_dict)\n"
+     ]
+    }
+   ],
+   "source": [
+    "from transformers import AutoImageProcessor\n",
+    "\n",
+    "checkpoint = \"nvidia/mit-b0\"\n",
+    "image_processor = AutoImageProcessor.from_pretrained(checkpoint, do_reduce_labels=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {
+    "id": "JAjiYzklZTwr"
+   },
+   "outputs": [],
+   "source": [
+    "from torchvision.transforms import ColorJitter\n",
+    "\n",
+    "jitter = ColorJitter(brightness=0.25, contrast=0.25, saturation=0.25, hue=0.1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {
+    "id": "_HaS12U0ZTwr"
+   },
+   "outputs": [],
+   "source": [
+    "from PIL import Image\n",
+    "import numpy as np\n",
+    "\n",
+    "\n",
+    "def handle_grayscale_image(image):\n",
+    "    np_image = np.array(image)\n",
+    "    if np_image.ndim == 2:\n",
+    "        tiled_image = np.tile(np.expand_dims(np_image, -1), 3)\n",
+    "        return Image.fromarray(tiled_image)\n",
+    "    else:\n",
+    "        return Image.fromarray(np_image)\n",
+    "\n",
+    "\n",
+    "def train_transforms(example_batch):\n",
+    "    images = [jitter(handle_grayscale_image(x)) for x in example_batch[\"image\"]]\n",
+    "    labels = [x for x in example_batch[\"annotation\"]]\n",
+    "    inputs = image_processor(images, labels)\n",
+    "    return inputs\n",
+    "\n",
+    "\n",
+    "def val_transforms(example_batch):\n",
+    "    images = [handle_grayscale_image(x) for x in example_batch[\"image\"]]\n",
+    "    labels = [x for x in example_batch[\"annotation\"]]\n",
+    "    inputs = image_processor(images, labels)\n",
+    "    return inputs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {
+    "id": "Qyjsvup2ZTws"
+   },
+   "outputs": [],
+   "source": [
+    "train_ds.set_transform(train_transforms)\n",
+    "test_ds.set_transform(val_transforms)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Lu8RjicxHJiO"
+   },
+   "source": [
+    "## Evaluation function\n",
+    "\n",
+    "Including a metric during training is often helpful for evaluating your model’s performance. You can quickly load a evaluation method with the [🤗 Evaluate](https://huggingface.co/docs/evaluate/index) library. For this task, load the [mean Intersection over Union (IoU)](https://huggingface.co/spaces/evaluate-metric/accuracy) metric (see the 🤗 Evaluate [quick tour](https://huggingface.co/docs/evaluate/a_quick_tour) to learn more about how to load and compute a metric):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {
+    "id": "TMSnlebfZTwt"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Downloading builder script: 12.9kB [00:00, 34.2MB/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "from torch import nn\n",
+    "import evaluate\n",
+    "\n",
+    "metric = evaluate.load(\"mean_iou\")\n",
+    "\n",
+    "\n",
+    "def compute_metrics(eval_pred):\n",
+    "    with torch.no_grad():\n",
+    "        logits, labels = eval_pred\n",
+    "        logits_tensor = torch.from_numpy(logits)\n",
+    "        # scale the logits to the size of the label\n",
+    "        logits_tensor = nn.functional.interpolate(\n",
+    "            logits_tensor,\n",
+    "            size=labels.shape[-2:],\n",
+    "            mode=\"bilinear\",\n",
+    "            align_corners=False,\n",
+    "        ).argmax(dim=1)\n",
+    "\n",
+    "        pred_labels = logits_tensor.detach().cpu().numpy()\n",
+    "        # currently using _compute instead of compute\n",
+    "        # see this issue for more info: https://github.com/huggingface/evaluate/pull/328#issuecomment-1286866576\n",
+    "        metrics = metric._compute(\n",
+    "            predictions=pred_labels,\n",
+    "            references=labels,\n",
+    "            num_labels=len(id2label),\n",
+    "            ignore_index=0,\n",
+    "            reduce_labels=image_processor.do_reduce_labels,\n",
+    "        )\n",
+    "\n",
+    "        # add per category metrics as individual key-value pairs\n",
+    "        per_category_accuracy = metrics.pop(\"per_category_accuracy\").tolist()\n",
+    "        per_category_iou = metrics.pop(\"per_category_iou\").tolist()\n",
+    "\n",
+    "        metrics.update({f\"accuracy_{id2label[i]}\": v for i, v in enumerate(per_category_accuracy)})\n",
+    "        metrics.update({f\"iou_{id2label[i]}\": v for i, v in enumerate(per_category_iou)})\n",
+    "\n",
+    "        return metrics"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "r304cnpxHxp5"
+   },
+   "source": [
+    "## Load a base model\n",
+    "\n",
+    "For this example, we use the [SegFormer B0 variant](https://huggingface.co/nvidia/mit-b0). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {
+    "id": "Krvppe44a_7y"
+   },
+   "outputs": [],
+   "source": [
+    "def print_trainable_parameters(model):\n",
+    "    \"\"\"\n",
+    "    Prints the number of trainable parameters in the model.\n",
+    "    \"\"\"\n",
+    "    trainable_params = 0\n",
+    "    all_param = 0\n",
+    "    for _, param in model.named_parameters():\n",
+    "        all_param += param.numel()\n",
+    "        if param.requires_grad:\n",
+    "            trainable_params += param.numel()\n",
+    "    print(\n",
+    "        f\"trainable params: {trainable_params} || all params: {all_param} || trainable%: {100 * trainable_params / all_param:.2f}\"\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "q_Wwl_ewID9I"
+   },
+   "source": [
+    "We pass the `label2id` and `id2label` dictionaries to let the `AutoModelForSemanticSegmentation` class know that we're interested in a custom base model where the decoder head should be randomly initialized w.r.t our custom dataset. Note, however, that the rest of the model parameters are pre-trained and will be fine-tuned in a regular transfer learning setup.\n",
+    "\n",
+    "We also notice that the 100% parameters in the `model` are trainable. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "kcdLdvIlZTwt",
+    "outputId": "a6b71dce-905e-4389-dcf6-46b43e769fcc"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Some weights of SegformerForSemanticSegmentation were not initialized from the model checkpoint at nvidia/mit-b0 and are newly initialized: ['decode_head.batch_norm.bias', 'decode_head.batch_norm.num_batches_tracked', 'decode_head.batch_norm.running_mean', 'decode_head.batch_norm.running_var', 'decode_head.batch_norm.weight', 'decode_head.classifier.bias', 'decode_head.classifier.weight', 'decode_head.linear_c.0.proj.bias', 'decode_head.linear_c.0.proj.weight', 'decode_head.linear_c.1.proj.bias', 'decode_head.linear_c.1.proj.weight', 'decode_head.linear_c.2.proj.bias', 'decode_head.linear_c.2.proj.weight', 'decode_head.linear_c.3.proj.bias', 'decode_head.linear_c.3.proj.weight', 'decode_head.linear_fuse.weight']\n",
+      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "trainable params: 3752694 || all params: 3752694 || trainable%: 100.00\n"
+     ]
+    }
+   ],
+   "source": [
+    "from transformers import AutoModelForSemanticSegmentation, TrainingArguments, Trainer\n",
+    "\n",
+    "model = AutoModelForSemanticSegmentation.from_pretrained(\n",
+    "    checkpoint, id2label=id2label, label2id=label2id, ignore_mismatched_sizes=True\n",
+    ")\n",
+    "print_trainable_parameters(model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "4yhyYVTCInF0"
+   },
+   "source": [
+    "## Wrap `model` as a `PeftModel` for LoRA training\n",
+    "\n",
+    "This involves two steps:\n",
+    "\n",
+    "* Defining a config with `LoraConfig`\n",
+    "* Wrapping the original `model` with `get_peft_model()` with the config defined in the step above. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "YPg4W5eFB__n",
+    "outputId": "9995eb44-1c30-43e7-cc4e-691ecb1b1878"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "trainable params: 566422 || all params: 4317068 || trainable%: 13.12\n"
+     ]
+    }
+   ],
+   "source": [
+    "from peft import LoraConfig, get_peft_model\n",
+    "\n",
+    "config = LoraConfig(\n",
+    "    r=32,\n",
+    "    lora_alpha=32,\n",
+    "    target_modules=[\"query\", \"value\"],\n",
+    "    lora_dropout=0.1,\n",
+    "    bias=\"lora_only\",\n",
+    "    modules_to_save=[\"decode_head\"],\n",
+    ")\n",
+    "lora_model = get_peft_model(model, config)\n",
+    "print_trainable_parameters(lora_model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "4M3wYekOI95X"
+   },
+   "source": [
+    " Let's unpack what's going on here. \n",
+    "\n",
+    "In order for LoRA to take effect, we need to specify the target modules to `LoraConfig` so that `PeftModel` knows which modules inside our model needs to be amended with LoRA matrices. In this case, we're only interested in targetting the query and value matrices of the attention blocks of the base model. Since the parameters corresponding to these matrices are \"named\" with `query` and `value` respectively, we specify them accordingly in the `target_modules` argument of `LoraConfig`. \n",
+    "\n",
+    "We also specify `modules_to_save`. After we wrap our base model `model` with `PeftModel` along with the `config`, we get a new model where only the LoRA parameters are trainable (so-called \"update matrices\") while the pre-trained parameters are kept frozen. These include the parameters of the randomly initialized classifier parameters too. This is NOT we want when fine-tuning the base model on our custom dataset. To ensure that the classifier parameters are also trained, we specify `modules_to_save`. This also ensures that these modules are serialized alongside the LoRA trainable parameters when using utilities like `save_pretrained()` and `push_to_hub()`.  \n",
+    "\n",
+    "Regarding the other parameters:\n",
+    "\n",
+    "* `r`: The dimension used by the LoRA update matrices.\n",
+    "* `alpha`: Scaling factor.\n",
+    "* `bias`: Specifying if the `bias` parameters should be trained. `lora_only` denotes only the LoRA `bias` parameters will be trained. \n",
+    "\n",
+    "`r` and `alpha` together control the total number of final trainable parameters when using LoRA giving us the flexbility to balance a trade-off between end performance and compute efficiency.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "XTF68xfjJEci"
+   },
+   "source": [
+    "We can also how many parameters we're actually training. Since we're interested in performing **parameter-efficient fine-tuning**, we should expect to notice a less number of trainable parameters from the `lora_model` in comparison to the original `model` which is indeed the case here. \n",
+    "\n",
+    "For sanity, let's also manually verify the modules that are actually trainable in `lora_model`. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "PUe1Gzvd1PEP",
+    "outputId": "7b8ba17f-01fd-4ab4-d703-9a0c01cff31b"
+   },
+   "outputs": [],
+   "source": [
+    "for name, param in lora_model.named_parameters():\n",
+    "    if param.requires_grad:\n",
+    "        print(name, param.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can confirm that only the LoRA parameters appended to the attention blocks and the `decode_head` parameters are trainable."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "rX75AyI7JYVC"
+   },
+   "source": [
+    "## Train!\n",
+    "\n",
+    "This is a two-step process: \n",
+    "\n",
+    "1. Define your training hyperparameters in [TrainingArguments](https://huggingface.co/docs/transformers/v4.26.0/en/main_classes/trainer#transformers.TrainingArguments). It is important you don’t remove unused columns because this’ll drop the image column. Without the image column, you can’t create `pixel_values`. Set `remove_unused_columns=False` to prevent this behavior! The only other required parameter is output_dir which specifies where to save your model. At the end of each epoch, the `Trainer` will evaluate the IoU metric and save the training checkpoint.\n",
+    "2. Pass the training arguments to [Trainer](https://huggingface.co/docs/transformers/v4.26.0/en/main_classes/trainer#transformers.Trainer) along with the model, dataset, tokenizer, data collator, and `compute_metrics` function.\n",
+    "3. Call `train()` to finetune your model.\n",
+    "\n",
+    "\n",
+    "**Note** that This example is meant to walk you through the workflow when using PEFT for semantic segmentation. We didn't perform extensive hyperparameter tuning to achieve optimal results. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 1000
+    },
+    "id": "K6HVcNkDZTwu",
+    "outputId": "1b28a072-0e16-4b1a-ec32-d78e93630ef3"
+   },
+   "outputs": [],
+   "source": [
+    "model_name = checkpoint.split(\"/\")[-1]\n",
+    "\n",
+    "training_args = TrainingArguments(\n",
+    "    output_dir=f\"{model_name}-scene-parse-150-lora\",\n",
+    "    learning_rate=5e-4,\n",
+    "    num_train_epochs=50,\n",
+    "    per_device_train_batch_size=4,\n",
+    "    per_device_eval_batch_size=2,\n",
+    "    save_total_limit=3,\n",
+    "    eval_strategy=\"epoch\",\n",
+    "    save_strategy=\"epoch\",\n",
+    "    logging_steps=5,\n",
+    "    remove_unused_columns=False,\n",
+    "    push_to_hub=True,\n",
+    "    label_names=[\"labels\"],\n",
+    ")\n",
+    "\n",
+    "trainer = Trainer(\n",
+    "    model=lora_model,\n",
+    "    args=training_args,\n",
+    "    train_dataset=train_ds,\n",
+    "    eval_dataset=test_ds,\n",
+    "    compute_metrics=compute_metrics,\n",
+    ")\n",
+    "\n",
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "dacaBLE6KLdu"
+   },
+   "source": [
+    "## Saving the model and inference \n",
+    "\n",
+    "Here we use the `save_pretrained()` method of the `lora_model` to save the *LoRA-only parameters* locally. However, you can also use thr `push_to_hub()` method to upload these parameters directly to the Hugging Face Hub (as shown [here](https://colab.research.google.com/github/huggingface/peft/blob/main/examples/image_classification/image_classification_peft_lora.ipynb)). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {
+    "id": "pvkLkrQo-6l6"
+   },
+   "outputs": [],
+   "source": [
+    "model_id = \"segformer-scene-parse-150-lora\"\n",
+    "lora_model.save_pretrained(model_id)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Ur8n41kBK4uj"
+   },
+   "source": [
+    "We can see that the LoRA-only parameters are just **2.2 MB in size**! This greatly improves the portability when using very large models. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "grzLeOT-__ht",
+    "outputId": "1ce26a27-2f38-43f3-9454-8ba11f2cfc59"
+   },
+   "outputs": [],
+   "source": [
+    "!ls -lh {model_id}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "KFYC6Z3FLB5F"
+   },
+   "source": [
+    "Let's now prepare our `inference_model` and run an inference. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "T7zeMQTaACur",
+    "outputId": "762b7fbc-07d4-4572-f107-c836e3e7928a"
+   },
+   "outputs": [],
+   "source": [
+    "from peft import PeftConfig, PeftModel\n",
+    "\n",
+    "config = PeftConfig.from_pretrained(model_id)\n",
+    "model = AutoModelForSemanticSegmentation.from_pretrained(\n",
+    "    checkpoint, id2label=id2label, label2id=label2id, ignore_mismatched_sizes=True\n",
+    ")\n",
+    "# Load the Lora model\n",
+    "inference_model = PeftModel.from_pretrained(model, model_id)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "2L1R0LDWLImd"
+   },
+   "source": [
+    "Fetch an image."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 444
+    },
+    "id": "lwjRvZOmA7Hh",
+    "outputId": "44ab267d-e2b9-4bda-a52b-91968eabce29"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "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",
+      "image/png": "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",
+      "text/plain": [
+       "<PIL.PngImagePlugin.PngImageFile image mode=RGB size=640x427>"
+      ]
+     },
+     "execution_count": 43,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import requests\n",
+    "\n",
+    "url = \"https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/semantic-seg-image.png\"\n",
+    "image = Image.open(requests.get(url, stream=True).raw)\n",
+    "image"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "kdK_bGhsLKKE"
+   },
+   "source": [
+    "Preprocess the image."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "G0z-3R-PBKc9",
+    "outputId": "56c91198-0116-4c2c-fc63-147dc7431b89"
+   },
+   "outputs": [],
+   "source": [
+    "# prepare image for the model\n",
+    "encoding = image_processor(image.convert(\"RGB\"), return_tensors=\"pt\")\n",
+    "print(encoding.pixel_values.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "hJRijta4LLu9"
+   },
+   "source": [
+    "Run an inference. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {
+    "id": "z1p-QDoiBP56"
+   },
+   "outputs": [],
+   "source": [
+    "with torch.no_grad():\n",
+    "    outputs = inference_model(pixel_values=encoding.pixel_values)\n",
+    "    logits = outputs.logits\n",
+    "\n",
+    "upsampled_logits = nn.functional.interpolate(\n",
+    "    logits,\n",
+    "    size=image.size[::-1],\n",
+    "    mode=\"bilinear\",\n",
+    "    align_corners=False,\n",
+    ")\n",
+    "\n",
+    "pred_seg = upsampled_logits.argmax(dim=1)[0]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "gmYIcfL4LNtj"
+   },
+   "source": [
+    "Visualize the results.\n",
+    "\n",
+    "We need a color palette to visualize the results. Here, we use [one provided by the TensorFlow Model Garden repository](https://github.com/tensorflow/models/blob/3f1ca33afe3c1631b733ea7e40c294273b9e406d/research/deeplab/utils/get_dataset_colormap.py#L51)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {
+    "id": "jy5c6vmzBqzC"
+   },
+   "outputs": [],
+   "source": [
+    "def ade_palette():\n",
+    "    \"\"\"Creates a label colormap used in ADE20K segmentation benchmark.\n",
+    "    Returns:\n",
+    "    A colormap for visualizing segmentation results.\n",
+    "    \"\"\"\n",
+    "    return np.asarray(\n",
+    "        [\n",
+    "            [0, 0, 0],\n",
+    "            [120, 120, 120],\n",
+    "            [180, 120, 120],\n",
+    "            [6, 230, 230],\n",
+    "            [80, 50, 50],\n",
+    "            [4, 200, 3],\n",
+    "            [120, 120, 80],\n",
+    "            [140, 140, 140],\n",
+    "            [204, 5, 255],\n",
+    "            [230, 230, 230],\n",
+    "            [4, 250, 7],\n",
+    "            [224, 5, 255],\n",
+    "            [235, 255, 7],\n",
+    "            [150, 5, 61],\n",
+    "            [120, 120, 70],\n",
+    "            [8, 255, 51],\n",
+    "            [255, 6, 82],\n",
+    "            [143, 255, 140],\n",
+    "            [204, 255, 4],\n",
+    "            [255, 51, 7],\n",
+    "            [204, 70, 3],\n",
+    "            [0, 102, 200],\n",
+    "            [61, 230, 250],\n",
+    "            [255, 6, 51],\n",
+    "            [11, 102, 255],\n",
+    "            [255, 7, 71],\n",
+    "            [255, 9, 224],\n",
+    "            [9, 7, 230],\n",
+    "            [220, 220, 220],\n",
+    "            [255, 9, 92],\n",
+    "            [112, 9, 255],\n",
+    "            [8, 255, 214],\n",
+    "            [7, 255, 224],\n",
+    "            [255, 184, 6],\n",
+    "            [10, 255, 71],\n",
+    "            [255, 41, 10],\n",
+    "            [7, 255, 255],\n",
+    "            [224, 255, 8],\n",
+    "            [102, 8, 255],\n",
+    "            [255, 61, 6],\n",
+    "            [255, 194, 7],\n",
+    "            [255, 122, 8],\n",
+    "            [0, 255, 20],\n",
+    "            [255, 8, 41],\n",
+    "            [255, 5, 153],\n",
+    "            [6, 51, 255],\n",
+    "            [235, 12, 255],\n",
+    "            [160, 150, 20],\n",
+    "            [0, 163, 255],\n",
+    "            [140, 140, 140],\n",
+    "            [250, 10, 15],\n",
+    "            [20, 255, 0],\n",
+    "            [31, 255, 0],\n",
+    "            [255, 31, 0],\n",
+    "            [255, 224, 0],\n",
+    "            [153, 255, 0],\n",
+    "            [0, 0, 255],\n",
+    "            [255, 71, 0],\n",
+    "            [0, 235, 255],\n",
+    "            [0, 173, 255],\n",
+    "            [31, 0, 255],\n",
+    "            [11, 200, 200],\n",
+    "            [255, 82, 0],\n",
+    "            [0, 255, 245],\n",
+    "            [0, 61, 255],\n",
+    "            [0, 255, 112],\n",
+    "            [0, 255, 133],\n",
+    "            [255, 0, 0],\n",
+    "            [255, 163, 0],\n",
+    "            [255, 102, 0],\n",
+    "            [194, 255, 0],\n",
+    "            [0, 143, 255],\n",
+    "            [51, 255, 0],\n",
+    "            [0, 82, 255],\n",
+    "            [0, 255, 41],\n",
+    "            [0, 255, 173],\n",
+    "            [10, 0, 255],\n",
+    "            [173, 255, 0],\n",
+    "            [0, 255, 153],\n",
+    "            [255, 92, 0],\n",
+    "            [255, 0, 255],\n",
+    "            [255, 0, 245],\n",
+    "            [255, 0, 102],\n",
+    "            [255, 173, 0],\n",
+    "            [255, 0, 20],\n",
+    "            [255, 184, 184],\n",
+    "            [0, 31, 255],\n",
+    "            [0, 255, 61],\n",
+    "            [0, 71, 255],\n",
+    "            [255, 0, 204],\n",
+    "            [0, 255, 194],\n",
+    "            [0, 255, 82],\n",
+    "            [0, 10, 255],\n",
+    "            [0, 112, 255],\n",
+    "            [51, 0, 255],\n",
+    "            [0, 194, 255],\n",
+    "            [0, 122, 255],\n",
+    "            [0, 255, 163],\n",
+    "            [255, 153, 0],\n",
+    "            [0, 255, 10],\n",
+    "            [255, 112, 0],\n",
+    "            [143, 255, 0],\n",
+    "            [82, 0, 255],\n",
+    "            [163, 255, 0],\n",
+    "            [255, 235, 0],\n",
+    "            [8, 184, 170],\n",
+    "            [133, 0, 255],\n",
+    "            [0, 255, 92],\n",
+    "            [184, 0, 255],\n",
+    "            [255, 0, 31],\n",
+    "            [0, 184, 255],\n",
+    "            [0, 214, 255],\n",
+    "            [255, 0, 112],\n",
+    "            [92, 255, 0],\n",
+    "            [0, 224, 255],\n",
+    "            [112, 224, 255],\n",
+    "            [70, 184, 160],\n",
+    "            [163, 0, 255],\n",
+    "            [153, 0, 255],\n",
+    "            [71, 255, 0],\n",
+    "            [255, 0, 163],\n",
+    "            [255, 204, 0],\n",
+    "            [255, 0, 143],\n",
+    "            [0, 255, 235],\n",
+    "            [133, 255, 0],\n",
+    "            [255, 0, 235],\n",
+    "            [245, 0, 255],\n",
+    "            [255, 0, 122],\n",
+    "            [255, 245, 0],\n",
+    "            [10, 190, 212],\n",
+    "            [214, 255, 0],\n",
+    "            [0, 204, 255],\n",
+    "            [20, 0, 255],\n",
+    "            [255, 255, 0],\n",
+    "            [0, 153, 255],\n",
+    "            [0, 41, 255],\n",
+    "            [0, 255, 204],\n",
+    "            [41, 0, 255],\n",
+    "            [41, 255, 0],\n",
+    "            [173, 0, 255],\n",
+    "            [0, 245, 255],\n",
+    "            [71, 0, 255],\n",
+    "            [122, 0, 255],\n",
+    "            [0, 255, 184],\n",
+    "            [0, 92, 255],\n",
+    "            [184, 255, 0],\n",
+    "            [0, 133, 255],\n",
+    "            [255, 214, 0],\n",
+    "            [25, 194, 194],\n",
+    "            [102, 255, 0],\n",
+    "            [92, 0, 255],\n",
+    "        ]\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 595
+    },
+    "id": "3KJFvgENBih0",
+    "outputId": "63d42e4f-3867-4d33-8ac0-83bebf8819ca"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x1000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "color_seg = np.zeros((pred_seg.shape[0], pred_seg.shape[1], 3), dtype=np.uint8)\n",
+    "palette = np.array(ade_palette())\n",
+    "\n",
+    "for label, color in enumerate(palette):\n",
+    "    color_seg[pred_seg == label, :] = color\n",
+    "color_seg = color_seg[..., ::-1]  # convert to BGR\n",
+    "\n",
+    "img = np.array(image) * 0.5 + color_seg * 0.5  # plot the image with the segmentation map\n",
+    "img = img.astype(np.uint8)\n",
+    "\n",
+    "plt.figure(figsize=(15, 10))\n",
+    "plt.imshow(img)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "q1aGuHYFLP7i"
+   },
+   "source": [
+    "The results are definitely not as expected and as mentioned above, this example is not meant to provide a state-of-the-art model. It exists to familiarize you with the end-to-end workflow. \n",
+    "\n",
+    "On the other hand, if you perform full fine-tuning on the same setup (same model variant, same dataset, same training schedule, etc.), the results would not have been any different. This is a crucial aspect of parameter-efficient fine-tuning -- to be able to match up to the results of the full fine-tuning but with a fraction of total trainable parameters. \n",
+    "\n",
+    "Here are some things that you can try to get better results:\n",
+    "\n",
+    "* Increase the number of training samples. \n",
+    "* Try a larger SegFormer model variant (know about the available model variants [here](https://huggingface.co/models?search=segformer)). \n",
+    "* Try different values for the arguments available in `LoraConfig`. \n",
+    "* Tune the learning rate and batch size. "
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "machine_shape": "hm",
+   "provenance": []
+  },
+  "gpuClass": "premium",
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  },
+  "widgets": {
+   "application/vnd.jupyter.widget-state+json": {
+    "0dcc5a2866a349e0843673bef499dc66": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_24fde588dc1a49a397e379cda320ed71",
+      "placeholder": "​",
+      "style": "IPY_MODEL_9746875e74b845daab06619393b4d46b",
+      "value": "\n<b>Pro Tip:</b> If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks. </center>"
+     }
+    },
+    "14ac809ba0bc4cd5bcd51f83105947b0": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "21bf954f54db41e6ba78f76195721614": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "24fde588dc1a49a397e379cda320ed71": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "3f69c7b15e5e48039777e4b6b1a51f53": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "42a7b8268d8945b5bbe9d3f20bc8840c": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "554b55f29a5e4d5a81608d912d3635e8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "5bcfe3da0ffb41ccbb9404ac35ae8945": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "6c6d19cd893e4d82bae9972fa10c6d74": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "PasswordModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "PasswordModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "PasswordView",
+      "continuous_update": true,
+      "description": "Token:",
+      "description_tooltip": null,
+      "disabled": false,
+      "layout": "IPY_MODEL_42a7b8268d8945b5bbe9d3f20bc8840c",
+      "placeholder": "​",
+      "style": "IPY_MODEL_554b55f29a5e4d5a81608d912d3635e8",
+      "value": ""
+     }
+    },
+    "6c88a55a635b4c9f946a1aa838d69f20": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_14ac809ba0bc4cd5bcd51f83105947b0",
+      "placeholder": "​",
+      "style": "IPY_MODEL_e7393e78f41b496495982490b72ef2a3",
+      "value": "<center> <img\nsrc=https://huggingface.co/front/assets/huggingface_logo-noborder.svg\nalt='Hugging Face'> <br> Copy a token from <a\nhref=\"https://huggingface.co/settings/tokens\" target=\"_blank\">your Hugging Face\ntokens page</a> and paste it below. <br> Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file. </center>"
+     }
+    },
+    "9746875e74b845daab06619393b4d46b": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "b7431f99d93b4e9b8c8177ac4a7b4070": {
+     "model_module": "@jupyter-widgets/base",
+     "model_module_version": "1.2.0",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": "center",
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": "flex",
+      "flex": null,
+      "flex_flow": "column",
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": "50%"
+     }
+    },
+    "cb4053f102fc4207a1c9513f81ad6415": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ButtonModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ButtonModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ButtonView",
+      "button_style": "",
+      "description": "Login",
+      "disabled": false,
+      "icon": "",
+      "layout": "IPY_MODEL_21bf954f54db41e6ba78f76195721614",
+      "style": "IPY_MODEL_f83dd354396e4aa3acd214a6fd98efb2",
+      "tooltip": ""
+     }
+    },
+    "e7393e78f41b496495982490b72ef2a3": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "f2a722f371904cce80dc1c087b153ad6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "VBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "VBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "VBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_6c88a55a635b4c9f946a1aa838d69f20",
+       "IPY_MODEL_6c6d19cd893e4d82bae9972fa10c6d74",
+       "IPY_MODEL_fc48ee28c2e44f1daa03149c8004c314",
+       "IPY_MODEL_cb4053f102fc4207a1c9513f81ad6415",
+       "IPY_MODEL_0dcc5a2866a349e0843673bef499dc66"
+      ],
+      "layout": "IPY_MODEL_b7431f99d93b4e9b8c8177ac4a7b4070"
+     }
+    },
+    "f83dd354396e4aa3acd214a6fd98efb2": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "ButtonStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ButtonStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "button_color": null,
+      "font_weight": ""
+     }
+    },
+    "fc48ee28c2e44f1daa03149c8004c314": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_module_version": "1.5.0",
+     "model_name": "CheckboxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "CheckboxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "CheckboxView",
+      "description": "Add token as git credential?",
+      "description_tooltip": null,
+      "disabled": false,
+      "indent": true,
+      "layout": "IPY_MODEL_3f69c7b15e5e48039777e4b6b1a51f53",
+      "style": "IPY_MODEL_5bcfe3da0ffb41ccbb9404ac35ae8945",
+      "value": true
+     }
+    }
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
diff --git a/examples/sequence_classification/C3A.ipynb b/examples/sequence_classification/C3A.ipynb
new file mode 100644
index 0000000..dbd8282
--- /dev/null
+++ b/examples/sequence_classification/C3A.ipynb
@@ -0,0 +1,512 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "d36e1e93-ae93-4a4e-93c6-68fd868d2882",
+   "metadata": {},
+   "source": [
+    "# Using C3A for sequence classification"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ddfc0610-55f6-4343-a950-125ccf0f45ac",
+   "metadata": {},
+   "source": [
+    "In this example, we fine-tune Roberta (base) on a sequence classification task using C3A."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "45addd81-d4f3-4dfd-960d-3920d347f0a6",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a9935ae2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#  To run this notebook, please run `pip install evaluate` to install additional dependencies not covered by PEFT.\n",
+    "import torch\n",
+    "from torch.optim import AdamW\n",
+    "from torch.utils.data import DataLoader\n",
+    "from peft import (\n",
+    "    get_peft_model,\n",
+    "    C3AConfig,\n",
+    "    PeftType,\n",
+    ")\n",
+    "from peft.utils import infer_device\n",
+    "\n",
+    "import evaluate\n",
+    "from datasets import load_dataset\n",
+    "from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed, AutoConfig\n",
+    "from tqdm import tqdm"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "62c959bf-7cc2-49e0-b97e-4c10ec3b9bf3",
+   "metadata": {},
+   "source": [
+    "## Parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e3b13308",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "batch_size = 32\n",
+    "model_name_or_path = \"roberta-base\"\n",
+    "task = \"mrpc\"\n",
+    "peft_type = PeftType.C3A\n",
+    "device = infer_device()\n",
+    "num_epochs = 5 # for better results, increase this number\n",
+    "block_size = 768  # for better results, increase this number\n",
+    "max_length = 512\n",
+    "torch.manual_seed(0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0526f571",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "peft_config = C3AConfig(\n",
+    "    task_type=\"SEQ_CLS\", \n",
+    "    block_size=block_size,\n",
+    "    target_modules=[\"query\", \"value\"],\n",
+    ")\n",
+    "head_lr = 4e-6  # the learning rate for the classification head for NLU tasks\n",
+    "ft_lr = 3e-1   # the learning rate for C3A parameters, a much larger LR than that is usually used, at least 1e-1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c075c5d2-a457-4f37-a7f1-94fd0d277972",
+   "metadata": {},
+   "source": [
+    "## Loading data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "7bb52cb4-d1c3-4b04-8bf0-f39ca88af139",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if any(k in model_name_or_path for k in (\"gpt\", \"opt\", \"bloom\")):\n",
+    "    padding_side = \"left\"\n",
+    "else:\n",
+    "    padding_side = \"right\"\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, padding_side=padding_side)\n",
+    "if getattr(tokenizer, \"pad_token_id\") is None:\n",
+    "    tokenizer.pad_token_id = tokenizer.eos_token_id"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "e69c5e1f-d27b-4264-a41e-fc9b99d025e6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "datasets = load_dataset(\"glue\", task)\n",
+    "metric = evaluate.load(\"glue\", task)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "0209f778-c93b-40eb-a4e0-24c25db03980",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def tokenize_function(examples):\n",
+    "    # max_length=None => use the model max length (it's actually the default)\n",
+    "    outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=max_length)\n",
+    "    return outputs\n",
+    "\n",
+    "\n",
+    "tokenized_datasets = datasets.map(\n",
+    "    tokenize_function,\n",
+    "    batched=True,\n",
+    "    remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n",
+    ")\n",
+    "\n",
+    "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n",
+    "# transformers library\n",
+    "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "7453954e-982c-46f0-b09c-589776e6d6cb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def collate_fn(examples):\n",
+    "    return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")\n",
+    "\n",
+    "\n",
+    "# Instantiate dataloaders.\n",
+    "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size)\n",
+    "eval_dataloader = DataLoader(\n",
+    "    tokenized_datasets[\"validation\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f3b9b2e8-f415-4d0f-9fb4-436f1a3585ea",
+   "metadata": {},
+   "source": [
+    "## Preparing the C3A model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "2ed5ac74",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-base and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
+      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "trainable params: 610,562 || all params: 125,257,732 || trainable%: 0.4874\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path, return_dict=True, max_length=None)\n",
+    "model = get_peft_model(model, peft_config)\n",
+    "model.print_trainable_parameters()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "0d2d0381",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "head_param = list(map(id, model.classifier.parameters()))\n",
+    "\n",
+    "others_param = filter(lambda p: id(p) not in head_param, model.parameters()) \n",
+    "\n",
+    "optimizer = AdamW([\n",
+    "    {\"params\": model.classifier.parameters(), \"lr\": head_lr},\n",
+    "    {\"params\": others_param, \"lr\": ft_lr}\n",
+    "],weight_decay=0.)\n",
+    "\n",
+    "\n",
+    "# Instantiate scheduler\n",
+    "lr_scheduler = get_linear_schedule_with_warmup(\n",
+    "    optimizer=optimizer,\n",
+    "    num_warmup_steps=0.06 * (len(train_dataloader) * num_epochs),\n",
+    "    num_training_steps=(len(train_dataloader) * num_epochs),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c0dd5aa8-977b-4ac0-8b96-884b17bcdd00",
+   "metadata": {},
+   "source": [
+    "## Training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "fa0e73be",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 0/115 [00:00<?, ?it/s]You're using a RobertaTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
+      "100%|██████████| 115/115 [00:04<00:00, 24.62it/s]\n",
+      "100%|██████████| 13/13 [00:00<00:00, 49.02it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 0: {'accuracy': 0.7990196078431373, 'f1': 0.8614864864864865}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:04<00:00, 26.18it/s]\n",
+      "100%|██████████| 13/13 [00:00<00:00, 49.86it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 1: {'accuracy': 0.8651960784313726, 'f1': 0.897196261682243}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:04<00:00, 26.21it/s]\n",
+      "100%|██████████| 13/13 [00:00<00:00, 49.86it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 2: {'accuracy': 0.8676470588235294, 'f1': 0.9018181818181819}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:04<00:00, 26.08it/s]\n",
+      "100%|██████████| 13/13 [00:00<00:00, 50.27it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 3: {'accuracy': 0.8725490196078431, 'f1': 0.9084507042253521}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:04<00:00, 26.15it/s]\n",
+      "100%|██████████| 13/13 [00:00<00:00, 49.68it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 4: {'accuracy': 0.8799019607843137, 'f1': 0.9126559714795008}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.to(device)\n",
+    "for epoch in range(num_epochs):\n",
+    "    model.train()\n",
+    "    for step, batch in enumerate(tqdm(train_dataloader)):\n",
+    "        batch.to(device)\n",
+    "        outputs = model(**batch)\n",
+    "        loss = outputs.loss\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        lr_scheduler.step()\n",
+    "        optimizer.zero_grad()\n",
+    "\n",
+    "    model.eval()\n",
+    "    for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+    "        batch.to(device)\n",
+    "        with torch.no_grad():\n",
+    "            outputs = model(**batch)\n",
+    "        predictions = outputs.logits.argmax(dim=-1)\n",
+    "        predictions, references = predictions, batch[\"labels\"]\n",
+    "        metric.add_batch(\n",
+    "            predictions=predictions,\n",
+    "            references=references,\n",
+    "        )\n",
+    "\n",
+    "    eval_metric = metric.compute()\n",
+    "    print(f\"epoch {epoch}:\", eval_metric)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f2b2caca",
+   "metadata": {},
+   "source": [
+    "## Share adapters on the 🤗 Hub"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7b23af6f-cf6e-486f-9d10-0eada95b631f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "account_id = \"Your-Hugging-Face-Hub-Account\"\n",
+    "token = \"Your-Hugging-Face-Hub-Token\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "990b3c93",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model.push_to_hub(f\"{account_id}/roberta-base-mrpc-peft-c3a\", token=token)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9d140b26",
+   "metadata": {},
+   "source": [
+    "## Load adapters from the Hub\n",
+    "\n",
+    "You can also directly load adapters from the Hub using the commands below:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "c283e028-b349-46b0-a20e-cde0ee5fbd7b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from peft import PeftModel, PeftConfig\n",
+    "from transformers import AutoTokenizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "320b10a0-4ea8-4786-9f3c-4670019c6b18",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-base and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
+      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+     ]
+    }
+   ],
+   "source": [
+    "peft_model_id = f\"{account_id}/roberta-base-mrpc-peft-c3a\"\n",
+    "config = PeftConfig.from_pretrained(peft_model_id)\n",
+    "inference_model = AutoModelForSequenceClassification.from_pretrained(config.base_model_name_or_path)\n",
+    "tokenizer = AutoTokenizer.from_pretrained(config.base_model_name_or_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "b3a94049-bc01-4f2e-8cf9-66daf24a4402",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load the FourierFT model\n",
+    "inference_model = PeftModel.from_pretrained(inference_model, peft_model_id, config=config)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "bd919fef-4e9a-4dc5-a957-7b879cfc5d38",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 0/13 [00:00<?, ?it/s]You're using a RobertaTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
+      "100%|██████████| 13/13 [00:00<00:00, 51.18it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'accuracy': 0.8799019607843137, 'f1': 0.9126559714795008}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "inference_model.to(device)\n",
+    "inference_model.eval()\n",
+    "for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+    "    batch.to(device)\n",
+    "    with torch.no_grad():\n",
+    "        outputs = inference_model(**batch)\n",
+    "    predictions = outputs.logits.argmax(dim=-1)\n",
+    "    predictions, references = predictions, batch[\"labels\"]\n",
+    "    metric.add_batch(\n",
+    "        predictions=predictions,\n",
+    "        references=references,\n",
+    "    )\n",
+    "\n",
+    "eval_metric = metric.compute()\n",
+    "print(eval_metric)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "peft",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/sequence_classification/FourierFT.ipynb b/examples/sequence_classification/FourierFT.ipynb
new file mode 100644
index 0000000..6c83a3b
--- /dev/null
+++ b/examples/sequence_classification/FourierFT.ipynb
@@ -0,0 +1,556 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "d36e1e93-ae93-4a4e-93c6-68fd868d2882",
+   "metadata": {},
+   "source": [
+    "# Using FourierFT for sequence classification"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ddfc0610-55f6-4343-a950-125ccf0f45ac",
+   "metadata": {},
+   "source": [
+    "In this example, we fine-tune Roberta (base) on a sequence classification task using FourierFT."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "45addd81-d4f3-4dfd-960d-3920d347f0a6",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "a9935ae2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/zgaoat/anaconda3/envs/pr2/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    }
+   ],
+   "source": [
+    "#  To run this notebook, please run `pip install evaluate` to install additional dependencies not covered by PEFT.\n",
+    "import torch\n",
+    "from torch.optim import AdamW\n",
+    "from torch.utils.data import DataLoader\n",
+    "from peft import (\n",
+    "    get_peft_model,\n",
+    "    FourierFTConfig,\n",
+    "    PeftType,\n",
+    ")\n",
+    "\n",
+    "import evaluate\n",
+    "from datasets import load_dataset\n",
+    "from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed, AutoConfig\n",
+    "from tqdm import tqdm"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "62c959bf-7cc2-49e0-b97e-4c10ec3b9bf3",
+   "metadata": {},
+   "source": [
+    "## Parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e3b13308",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<torch._C.Generator at 0x78e2a49744b0>"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "batch_size = 32\n",
+    "model_name_or_path = \"roberta-base\"\n",
+    "task = \"mrpc\"\n",
+    "peft_type = PeftType.FOURIERFT\n",
+    "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "num_epochs = 5  # for better results, increase this number\n",
+    "n_frequency = 1000        # for better results, increase this number\n",
+    "scaling = 150.0\n",
+    "max_length = 512\n",
+    "torch.manual_seed(0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "0526f571",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "peft_config = FourierFTConfig(\n",
+    "    task_type=\"SEQ_CLS\", \n",
+    "    n_frequency=n_frequency,\n",
+    "    target_modules=[\"query\", \"value\"],\n",
+    "    scaling = scaling,\n",
+    ")\n",
+    "head_lr = 6e-3  # the learning rate for the classification head for NLU tasks\n",
+    "fft_lr = 6e-2   # the learning rate for the parameters other than the classification head (q,v in this case)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c075c5d2-a457-4f37-a7f1-94fd0d277972",
+   "metadata": {},
+   "source": [
+    "## Loading data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "7bb52cb4-d1c3-4b04-8bf0-f39ca88af139",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if any(k in model_name_or_path for k in (\"gpt\", \"opt\", \"bloom\")):\n",
+    "    padding_side = \"left\"\n",
+    "else:\n",
+    "    padding_side = \"right\"\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, padding_side=padding_side)\n",
+    "if getattr(tokenizer, \"pad_token_id\") is None:\n",
+    "    tokenizer.pad_token_id = tokenizer.eos_token_id"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "e69c5e1f-d27b-4264-a41e-fc9b99d025e6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "datasets = load_dataset(\"glue\", task)\n",
+    "metric = evaluate.load(\"glue\", task)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "0209f778-c93b-40eb-a4e0-24c25db03980",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def tokenize_function(examples):\n",
+    "    # max_length=None => use the model max length (it's actually the default)\n",
+    "    outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=max_length)\n",
+    "    return outputs\n",
+    "\n",
+    "\n",
+    "tokenized_datasets = datasets.map(\n",
+    "    tokenize_function,\n",
+    "    batched=True,\n",
+    "    remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n",
+    ")\n",
+    "\n",
+    "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n",
+    "# transformers library\n",
+    "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "7453954e-982c-46f0-b09c-589776e6d6cb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def collate_fn(examples):\n",
+    "    return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")\n",
+    "\n",
+    "\n",
+    "# Instantiate dataloaders.\n",
+    "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size)\n",
+    "eval_dataloader = DataLoader(\n",
+    "    tokenized_datasets[\"validation\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f3b9b2e8-f415-4d0f-9fb4-436f1a3585ea",
+   "metadata": {},
+   "source": [
+    "## Preparing the FourierFT model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "2ed5ac74",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-base and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
+      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "trainable params: 616,130 || all params: 125,263,300 || trainable%: 0.4919\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path, return_dict=True, max_length=None)\n",
+    "model = get_peft_model(model, peft_config)\n",
+    "model.print_trainable_parameters()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "0d2d0381",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "head_param = list(map(id, model.classifier.parameters()))\n",
+    "\n",
+    "others_param = filter(lambda p: id(p) not in head_param, model.parameters()) \n",
+    "\n",
+    "optimizer = AdamW([\n",
+    "    {\"params\": model.classifier.parameters(), \"lr\": head_lr},\n",
+    "    {\"params\": others_param, \"lr\": fft_lr}\n",
+    "],weight_decay=0.)\n",
+    "\n",
+    "\n",
+    "# Instantiate scheduler\n",
+    "lr_scheduler = get_linear_schedule_with_warmup(\n",
+    "    optimizer=optimizer,\n",
+    "    num_warmup_steps=0.06 * (len(train_dataloader) * num_epochs),\n",
+    "    num_training_steps=(len(train_dataloader) * num_epochs),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c0dd5aa8-977b-4ac0-8b96-884b17bcdd00",
+   "metadata": {},
+   "source": [
+    "## Training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "fa0e73be",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 0/115 [00:00<?, ?it/s]You're using a RobertaTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
+      "100%|██████████| 115/115 [00:06<00:00, 19.03it/s]\n",
+      "100%|██████████| 13/13 [00:00<00:00, 41.72it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 0: {'accuracy': 0.8161764705882353, 'f1': 0.8709122203098106}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:05<00:00, 20.61it/s]\n",
+      "100%|██████████| 13/13 [00:00<00:00, 42.91it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 1: {'accuracy': 0.8480392156862745, 'f1': 0.8966666666666666}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:05<00:00, 20.63it/s]\n",
+      "100%|██████████| 13/13 [00:00<00:00, 42.65it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 2: {'accuracy': 0.8676470588235294, 'f1': 0.9075342465753424}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:05<00:00, 20.56it/s]\n",
+      "100%|██████████| 13/13 [00:00<00:00, 42.11it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 3: {'accuracy': 0.8504901960784313, 'f1': 0.8988391376451078}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:05<00:00, 20.50it/s]\n",
+      "100%|██████████| 13/13 [00:00<00:00, 43.15it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 4: {'accuracy': 0.8725490196078431, 'f1': 0.9103448275862069}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.to(device)\n",
+    "for epoch in range(num_epochs):\n",
+    "    model.train()\n",
+    "    for step, batch in enumerate(tqdm(train_dataloader)):\n",
+    "        batch.to(device)\n",
+    "        outputs = model(**batch)\n",
+    "        loss = outputs.loss\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        lr_scheduler.step()\n",
+    "        optimizer.zero_grad()\n",
+    "\n",
+    "    model.eval()\n",
+    "    for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+    "        batch.to(device)\n",
+    "        with torch.no_grad():\n",
+    "            outputs = model(**batch)\n",
+    "        predictions = outputs.logits.argmax(dim=-1)\n",
+    "        predictions, references = predictions, batch[\"labels\"]\n",
+    "        metric.add_batch(\n",
+    "            predictions=predictions,\n",
+    "            references=references,\n",
+    "        )\n",
+    "\n",
+    "    eval_metric = metric.compute()\n",
+    "    print(f\"epoch {epoch}:\", eval_metric)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f2b2caca",
+   "metadata": {},
+   "source": [
+    "## Share adapters on the 🤗 Hub"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "7b23af6f-cf6e-486f-9d10-0eada95b631f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "account_id = ...  # your Hugging Face Hub account ID"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "990b3c93",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/zgaoat/anaconda3/envs/pr2/lib/python3.11/site-packages/huggingface_hub/file_download.py:1132: FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "CommitInfo(commit_url='https://huggingface.co/zgaoat/roberta-base-mrpc-peft-fourierft/commit/064eb35cbb7a1073b4d8fafbeccee43a0a4e37c9', commit_message='Upload model', commit_description='', oid='064eb35cbb7a1073b4d8fafbeccee43a0a4e37c9', pr_url=None, pr_revision=None, pr_num=None)"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.push_to_hub(f\"{account_id}/roberta-base-mrpc-peft-fourierft\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9d140b26",
+   "metadata": {},
+   "source": [
+    "## Load adapters from the Hub\n",
+    "\n",
+    "You can also directly load adapters from the Hub using the commands below:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "c283e028-b349-46b0-a20e-cde0ee5fbd7b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from peft import PeftModel, PeftConfig\n",
+    "from transformers import AutoTokenizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "320b10a0-4ea8-4786-9f3c-4670019c6b18",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-base and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
+      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+     ]
+    }
+   ],
+   "source": [
+    "peft_model_id = f\"{account_id}/roberta-base-mrpc-peft-fourierft\"\n",
+    "config = PeftConfig.from_pretrained(peft_model_id)\n",
+    "inference_model = AutoModelForSequenceClassification.from_pretrained(config.base_model_name_or_path)\n",
+    "tokenizer = AutoTokenizer.from_pretrained(config.base_model_name_or_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "b3a94049-bc01-4f2e-8cf9-66daf24a4402",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load the FourierFT model\n",
+    "inference_model = PeftModel.from_pretrained(inference_model, peft_model_id, config=config)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "bd919fef-4e9a-4dc5-a957-7b879cfc5d38",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 0/13 [00:00<?, ?it/s]You're using a RobertaTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
+      "100%|██████████| 13/13 [00:00<00:00, 43.06it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'accuracy': 0.8725490196078431, 'f1': 0.9103448275862069}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "inference_model.to(device)\n",
+    "inference_model.eval()\n",
+    "for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+    "    batch.to(device)\n",
+    "    with torch.no_grad():\n",
+    "        outputs = inference_model(**batch)\n",
+    "    predictions = outputs.logits.argmax(dim=-1)\n",
+    "    predictions, references = predictions, batch[\"labels\"]\n",
+    "    metric.add_batch(\n",
+    "        predictions=predictions,\n",
+    "        references=references,\n",
+    "    )\n",
+    "\n",
+    "eval_metric = metric.compute()\n",
+    "print(eval_metric)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/sequence_classification/IA3.ipynb b/examples/sequence_classification/IA3.ipynb
new file mode 100644
index 0000000..d8166f8
--- /dev/null
+++ b/examples/sequence_classification/IA3.ipynb
@@ -0,0 +1,7789 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "id": "a9935ae2",
+      "metadata": {
+        "id": "a9935ae2"
+      },
+      "outputs": [],
+      "source": [
+        "import argparse\n",
+        "import os\n",
+        "\n",
+        "import torch\n",
+        "from torch.optim import AdamW\n",
+        "from torch.utils.data import DataLoader\n",
+        "import peft\n",
+        "\n",
+        "import evaluate\n",
+        "from datasets import load_dataset\n",
+        "from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed\n",
+        "from tqdm import tqdm"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "e3b13308",
+      "metadata": {
+        "id": "e3b13308"
+      },
+      "outputs": [],
+      "source": [
+        "batch_size = 8\n",
+        "model_name_or_path = \"roberta-large\"\n",
+        "task = \"mrpc\"\n",
+        "peft_type = peft.PeftType.IA3\n",
+        "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+        "num_epochs = 12"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "id": "0526f571",
+      "metadata": {
+        "id": "0526f571"
+      },
+      "outputs": [],
+      "source": [
+        "# peft_config = LoraConfig(task_type=\"SEQ_CLS\", inference_mode=False, r=8, lora_alpha=16, lora_dropout=0.1)\n",
+        "peft_config = peft.IA3Config(task_type=\"SEQ_CLS\", inference_mode=False)\n",
+        "lr = 1e-3"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "c2697d07",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 489,
+          "referenced_widgets": [
+            "6ea6ff70fa164264aef9efce9f921f10",
+            "ecc2102ede2d4c8b94ce66b247054c96",
+            "e64ca48867434ca2944dcb2b1c70c02c",
+            "7ac75048225f4a4bbedac97965cf9837",
+            "332971de5e894c8ca866c311cc6e180c",
+            "bdf0999dfddc43ca8e04ceaac628064c",
+            "c289713b179641bd915b3c334208197a",
+            "e3d36dd4ddcb4287b8d8c942a26dc478",
+            "0b20fa2eb59749e1b564df70f2378984",
+            "d8e645f1697d46e0ac23f70e14498fab",
+            "8dc1453856d549c4a1a688818447dd59",
+            "d267c0cf26a8466d9938861ff5272a1e",
+            "561f61d1cec94f5abbff3f8746c3fd96",
+            "a5c93fac02884914ae8e140e0c0d2a17",
+            "96c4ecd7376c43ee9a4ba270851d6fff",
+            "5062d6f6feb34835afaf6d452900d514",
+            "a05844fa4675494cb7bbe48f40f1aaac",
+            "b241da7afea94fc0a6b407a0a78a8355",
+            "74e056313e9e4a92bfaa22019ac1e58e",
+            "938a5b44d90140e29ba33628a2215f2a",
+            "1f27766bc2d941f6a1d03fc69a6026a3",
+            "1c5e43a201f0460f88b53739bc1eaa43",
+            "24e236a4360e416a8e5c20d887274bcc",
+            "7011752f7e0a422883bf0f218f6941c3",
+            "248fe45eee37449982520a890696e6d4",
+            "5ec5d0d9191047608f61cb78563f7641",
+            "d7c2b00fd90147528b00a29552f29b44",
+            "ea307bb7a9ad46a484330b1daf708169",
+            "27009ed667c242488773ce3fcc58360a",
+            "faf0c550adc5402bbee71b027822ce9c",
+            "9c57da41dfc04fe4a4437097285599bf",
+            "d4453448f8b04f0ea76c71887bd33a8c",
+            "ff5172169c794d40b6c433da642d54a9",
+            "788a143aad46467789acf08762fbf39f",
+            "32ba35144ab34b0ebb7cfb75b86ccdd4",
+            "3ef39b223ab74d788223970ec0da21e6",
+            "be40292e613949a0ba1bfd1846cdab92",
+            "a6ab0e37d063407fa4adc11f2f0299da",
+            "71c3a5a515a949bfb2290612bfb2d05f",
+            "1232101b618d43f5889e4ad81fa24514",
+            "2204ca891c3940879abde0f55fbadf03",
+            "58f2da1b793b44b09cedb5e0a3a1ef02",
+            "51ec9bdff1834e4f8390f0eaf7d4aeb8",
+            "71b4a798dc374a72817f6c118f2f05b8",
+            "a439e5ecb0a040ca8188c6d74ff643a9",
+            "710f512e4a2b40cb85805b33a7dc42e4",
+            "e5994b94b84143f4a06c49a45a078bd0",
+            "e4f935e4e8e84320b2381aaf3493962c",
+            "44eb5aeeb0004f799e79d3ed51cf37d4",
+            "0c488289ee494a8d99d1f02a13729382",
+            "49ccb14ddd874e798371494942725128",
+            "015132b18da54a8f89a83cd9bf6fd17c",
+            "39f26160766f48798761079527e14396",
+            "5408dfdfc5624ff5b1c0b2e494dd4b35",
+            "9c50277ed18a424a9da98707cf726d29",
+            "11ba7f922c58474d9cb8b8c7a22caddc",
+            "598fc42dfed04aadaeb38539dd259871",
+            "fb05d1ece2ba4963bcbf99f89296c709",
+            "e3fe73a6ffcf4d089911b4149b9b4512",
+            "45e1b59770f946dba06511f9b5d1ad23",
+            "2c512bc0a21a4f6684aa0593a969e6cb",
+            "376f00f38b46434e922c3f6f7dc4a85c",
+            "e815b0749289411eb680c56e4fd39dae",
+            "33e9821903f84551a2e56c0586a5332b",
+            "0b2e59615f80452cbe25dfd467099b84",
+            "45128b02652b4c20bf448db8495d76d2",
+            "d1997b08e5284008afce56a5ed6347be",
+            "730111ee99b4470c81ab4ade07b30352",
+            "562a55ffabef4d218c78c5dcc6665484",
+            "59e1d01621f4404ca2102d00e2b01f87",
+            "1896a8f160ea45e5ac2a88970feecdb9",
+            "7d6d21774fec4eb0bab3bc2bfa2708d6",
+            "9882a67915f8475c9f4b8a5b15d64e50",
+            "47ffc35023144c4fa6b93e73b7a2ee60",
+            "16f8d52980dc41e89ed3bfb9172420a6",
+            "2bc5432ab9464f7b9192aa1f5a26a1b2",
+            "80bcbdb92af34c9889b7d105affe34ba",
+            "6786c3895b594301b2a7d4ed2767cb35",
+            "bf35a5a5d9b840a18ef10938d23fce0c",
+            "ad4872e198ee44f8b83323d891347ffa",
+            "0f29f96aec7e44a1b97cda0fcbe17665",
+            "dbb4032fab4d49a5b250be57a4d51fb0",
+            "af185d9bedf64d54bc77f7f6e7c448f4",
+            "4d9d717d2226444094e9753fdc843849",
+            "3d323bc6e1fd4091a0ed2ffd521f2ec7",
+            "2616b6102108476f8bf9e3d35b63494d",
+            "844ea1050893482785c1b68150f4ab20",
+            "92d023972a204222b59c12fc4b4d3bcf",
+            "7900796766b946da886338653b495533",
+            "84b50ae864e0463d98efa792e149e712",
+            "802dc985a31e4febb8eafa4682e242ec",
+            "f31d9d6e2d3140eeb821153a7b69b90a",
+            "3f2d9eba845341da97fa1b957e72de5e",
+            "d3638a2985fc4fdfbf239914dbc32fe8",
+            "a9d237f2f62e4a839abdec541715a5de",
+            "b451310e94b74abda4e795a59cdda9ab",
+            "537c7d2f4260498a82132cb9fae5daa5",
+            "6f9efa5f778d4f029dca7b4d6817b4c4",
+            "d29a5f422214434c9be3886ce0d1e918",
+            "e0e903b3ae8044f4a58ecd70825f36ec",
+            "99e8679e71f4443c92f13971e8885d38",
+            "55a0ca0754c94f0bba6ede50b7fb7ea8",
+            "fae83f7a625448e788ffdb1a13d2d530",
+            "3086db94647a41569b6f091e4f11f3cb",
+            "24062742dc6749a2aab19cbfd1e11684",
+            "1b6c8de76fd948b5b0eba8346f6e0bec",
+            "276fc5825a624a3a9026301620682c6c",
+            "5c10a16929ce40e48361efa44e96a7f8",
+            "53f9d507f4024b2080591215d3c4bab4",
+            "c77cdd4479294ce7bf3f3ef271e95b1d",
+            "e66a0c2552ff46b5a41cf8d803114b8f",
+            "897708ca40da48f3ae846710b4e7f7f0",
+            "1aa34d9a0b16444baadf2ed7e43b72e5",
+            "01f39b548eff49aea6ba0efabb4486de",
+            "46fc201246804f28946fd0c59e09c4ac",
+            "e6c085b451a346b6a3b82c67d7b9e9e2",
+            "29a8cce77d2745038f2c742d17254139",
+            "326b48d7d2e94defa52858171177e7d7",
+            "9a3dcc1c2fe542b7b912419935d9dd9a",
+            "b82b0c29bd53432baa5596b4f1aaf076",
+            "a8ccd811bba848d2ad2f84d2cdf9ef03",
+            "9ae4e6a6543e4da6bba06175aeef3ea1",
+            "fa9675039cc443f791dcfbc0bdca065c",
+            "5b0a0578afad40868bb71707c05e0335",
+            "d1a82e42e866449cbb70c1f68ac1bc03",
+            "bd12886eee644913ba83fd4ebb6b62ee",
+            "fc11a9d0c0b7409cb2f61fcabac2bfa6",
+            "9cf73d46c2f04bf398a4564a56f03bd6",
+            "f46d3699775b4d7193adeebb4f18a34f",
+            "5997f14e0a3044249b9cabc2b307e3a4",
+            "5ba9f4bd64bd4e1e905887760f90ae3e",
+            "1a8e75c718d14f4c8f99de1c8efa84b5",
+            "786b2430a42942f1aeae253861820dcb",
+            "e2741973e91745ea930d3cc23070cf52",
+            "b9f18367c54b4203bee70c680ae9cdde",
+            "7db82bb6fa2949b3a6bc9eb152fc3af1",
+            "136a32dbeef646df944a8b59cb00c0c4",
+            "c2fa0ef9f45b447e9dfe5c576428c714",
+            "241dd21eeb5843ef8433e47b415c5b62",
+            "c9837f88650844ea94442ad1c5682972",
+            "963da028a1594c1bbd223e93832f44bd",
+            "d981db72ab2745a598ed45a8762d5fcd",
+            "73379eb4954d4be6ab90008addd7d3bd",
+            "007f2f512694405c9245edd5e1f58551",
+            "9aaeeb1213854768a6af51f8db54f6b6",
+            "e6e2192c0a904bb6850c6bc68b579995",
+            "608a68c6f651419d8fd210044b4561cf",
+            "ac9d6255521f428fa7fda5735d71dbec",
+            "a39ea243b7964c298eae71e9eaf32e17",
+            "bf7f7cb363df4384ade192666b77c715",
+            "841f3571fcec42ad8e1e43997567788c",
+            "a246e6c60c054b4383c510c31b255a87",
+            "da3e335ddc9846ea832c75d69684575f",
+            "daa8ce62f0204a11bde7cd9e31cc2fa1",
+            "6b937f0053b64c67af74d44bcb6e51b7",
+            "72f55658a145483cb90668bf7b6f6c8a",
+            "357c082907e140b58c807a394446d811",
+            "f127594b694f4d2fafb3872e8190b1d6",
+            "f9c8bd12201a4c8a86b2bb3c1a14d74e",
+            "dc55ec8e57984efcb0f269ef0ef41c02",
+            "cd07261ef21a4b859de53f244df33f2a",
+            "c47de12dd692434ab9497e8a0d2a19ba",
+            "963b22b2ef1e45f5ba8320f72ea6a83b",
+            "3e2ca33b7473499d8314238ec245cd90",
+            "e3313a7fb356432bada289ad346f1bdb",
+            "75ee099566ca46eb8a75475246aaab01",
+            "e94dd1ea928f43b880af21ced7f11d14",
+            "ad84cdcfa07f4f608dccd10395d35e79",
+            "8bd3a235ae654b1cbaae36aeb1a62e70",
+            "ebe2f83a5783401ab501cdaf9c4e2ad5",
+            "fe20644617844cf7a471e22a99ca7b5e",
+            "d5502b7dcf784d289fc748881924334c",
+            "6bf5b27d3c3c407eb10f8d9d6e8e8d22",
+            "47480982ce83440997297e605cdf8a31",
+            "32764784cc9644198c622f6706db6836",
+            "83bae5949ec448c6ad6f68a7b8d3d436",
+            "a018f7c156584eb3833b6aba3710b3c0",
+            "c2a078c69d3f45ca9895e0e7f95aaf2b",
+            "8c55316c54d44bd4b75a8457e2d8c595",
+            "1824b7b748ee4763b5098cd915107f63",
+            "87b93c14cdae477ab49522354631e82b",
+            "a8b5d642ed654c0f85f3a9610c68b754",
+            "8750ab964b5444d49db4fe8542964d8c",
+            "c994a28df165445bbf0d80c165bc5a0b",
+            "1a2897c84d454c1a9c115aef178f4fcf",
+            "b668d56ab549478984ad14c22e040e47",
+            "bac855f4c7044fe88bcd74170e13f103",
+            "f871eeaa54cf451b8a2de64eed90d5b6",
+            "39492d8b91f64e97bc8caead77957508",
+            "1487d054f1824f739c93c00621591bd0",
+            "cca43d628ff94369bc9713cbad616adb",
+            "6aa4308f0cb348419f1217e48ef2dbd7",
+            "d9db044ff31f4856a4d25e57fe9882bc",
+            "f76b651681d74b2eab0ab07f43983a2a",
+            "1e3adfe9c9e34d4abe74b65e298c0e7b",
+            "f91ed6a931c247b5903304a28998633d",
+            "34e576af7aab4ef795239b1d9a281b15",
+            "9d8e3a4fe5864a4ca229ba6e092181e4",
+            "e41888b1dea140d18be25efc6d99d0c3",
+            "d63577f0ae724938952f9b681a89512a",
+            "83623082d4e9457a9173db3129154f94",
+            "4c1798c3d0cb43949a1ed7519b57d3fc",
+            "6513f2b58d654a488b132abd8c83c9b6",
+            "c4aa7cee6e5d4a89a2c33b9ce2e9c489",
+            "b42e835e0ba24a08b5815234a22b4da6",
+            "e8a53956f6ad46d58ec3a9a039f2303e",
+            "91f07c6089354ceeb4e628ef1791d2d6",
+            "c137c84ae40049ffba7d1f4d77b21de2",
+            "81f8db0dcdbc4e5593fa3fbb6c2b9361"
+          ]
+        },
+        "id": "c2697d07",
+        "outputId": "c8318b3d-b6a0-4f0d-9903-54beb2baac75"
+      },
+      "outputs": [],
+      "source": [
+        "if any(k in model_name_or_path for k in (\"gpt\", \"opt\", \"bloom\")):\n",
+        "    padding_side = \"left\"\n",
+        "else:\n",
+        "    padding_side = \"right\"\n",
+        "\n",
+        "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, padding_side=padding_side)\n",
+        "if getattr(tokenizer, \"pad_token_id\") is None:\n",
+        "    tokenizer.pad_token_id = tokenizer.eos_token_id\n",
+        "\n",
+        "datasets = load_dataset(\"glue\", task)\n",
+        "metric = evaluate.load(\"glue\", task)\n",
+        "\n",
+        "\n",
+        "def tokenize_function(examples):\n",
+        "    # max_length=None => use the model max length (it's actually the default)\n",
+        "    outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=None)\n",
+        "    return outputs\n",
+        "\n",
+        "\n",
+        "tokenized_datasets = datasets.map(\n",
+        "    tokenize_function,\n",
+        "    batched=True,\n",
+        "    remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n",
+        ")\n",
+        "\n",
+        "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n",
+        "# transformers library\n",
+        "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")\n",
+        "\n",
+        "\n",
+        "def collate_fn(examples):\n",
+        "    return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")\n",
+        "\n",
+        "\n",
+        "# Instantiate dataloaders.\n",
+        "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size)\n",
+        "eval_dataloader = DataLoader(\n",
+        "    tokenized_datasets[\"validation\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size\n",
+        ")\n",
+        "test_dataloader = DataLoader(tokenized_datasets[\"test\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "id": "2ed5ac74",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000,
+          "referenced_widgets": [
+            "0cecb897c86c4892b94a1990ab08a926",
+            "b8af0294819e4280ad41fa1c11006adf",
+            "c7530d63b2f745e799713284abacbd2c",
+            "12a1e302a69543c5bc0e0a66be008ca0",
+            "9c372e9e9b20433faed8530ca0f4424c",
+            "b07f26a21325493cac19113f1aa1ee96",
+            "fbdf6c544fb54294903524a69384e773",
+            "6c6f2223243b4a7485aef7fbbfe07668",
+            "a93509d61ac94628a74bc0f98c0eec06",
+            "3a8de0eb7db44647a734590b6b351b44",
+            "64d8affd2e854a1c9043fec7ca8a2796"
+          ]
+        },
+        "id": "2ed5ac74",
+        "outputId": "18ea15ac-ed8d-4d80-b166-706681ee49ab"
+      },
+      "outputs": [
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "0cecb897c86c4892b94a1990ab08a926",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Downloading model.safetensors:   0%|          | 0.00/1.42G [00:00<?, ?B/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "Some weights of the model checkpoint at roberta-large were not used when initializing RobertaForSequenceClassification: ['lm_head.layer_norm.weight', 'lm_head.bias', 'lm_head.dense.bias', 'lm_head.dense.weight', 'lm_head.layer_norm.bias']\n",
+            "- This IS expected if you are initializing RobertaForSequenceClassification from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
+            "- This IS NOT expected if you are initializing RobertaForSequenceClassification from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
+            "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-large and are newly initialized: ['classifier.dense.weight', 'classifier.out_proj.weight', 'classifier.out_proj.bias', 'classifier.dense.bias']\n",
+            "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "trainable params: 2,275,332 || all params: 356,585,476 || trainable%: 0.6380888042675075\n"
+          ]
+        },
+        {
+          "data": {
+            "text/plain": [
+              "PeftModelForSequenceClassification(\n",
+              "  (base_model): IA3Model(\n",
+              "    (model): RobertaForSequenceClassification(\n",
+              "      (roberta): RobertaModel(\n",
+              "        (embeddings): RobertaEmbeddings(\n",
+              "          (word_embeddings): Embedding(50265, 1024, padding_idx=1)\n",
+              "          (position_embeddings): Embedding(514, 1024, padding_idx=1)\n",
+              "          (token_type_embeddings): Embedding(1, 1024)\n",
+              "          (LayerNorm): LayerNorm((1024,), eps=1e-05, elementwise_affine=True)\n",
+              "          (dropout): Dropout(p=0.1, inplace=False)\n",
+              "        )\n",
+              "        (encoder): RobertaEncoder(\n",
+              "          (layer): ModuleList(\n",
+              "            (0-23): 24 x RobertaLayer(\n",
+              "              (attention): RobertaAttention(\n",
+              "                (self): RobertaSelfAttention(\n",
+              "                  (query): Linear(in_features=1024, out_features=1024, bias=True)\n",
+              "                  (key): Linear(\n",
+              "                    in_features=1024, out_features=1024, bias=True\n",
+              "                    (ia3_l): ParameterDict(  (default): Parameter containing: [torch.FloatTensor of size 1024x1])\n",
+              "                  )\n",
+              "                  (value): Linear(\n",
+              "                    in_features=1024, out_features=1024, bias=True\n",
+              "                    (ia3_l): ParameterDict(  (default): Parameter containing: [torch.FloatTensor of size 1024x1])\n",
+              "                  )\n",
+              "                  (dropout): Dropout(p=0.1, inplace=False)\n",
+              "                )\n",
+              "                (output): RobertaSelfOutput(\n",
+              "                  (dense): Linear(\n",
+              "                    in_features=1024, out_features=1024, bias=True\n",
+              "                    (ia3_l): ParameterDict(  (default): Parameter containing: [torch.FloatTensor of size 1x1024])\n",
+              "                  )\n",
+              "                  (LayerNorm): LayerNorm((1024,), eps=1e-05, elementwise_affine=True)\n",
+              "                  (dropout): Dropout(p=0.1, inplace=False)\n",
+              "                )\n",
+              "              )\n",
+              "              (intermediate): RobertaIntermediate(\n",
+              "                (dense): Linear(in_features=1024, out_features=4096, bias=True)\n",
+              "                (intermediate_act_fn): GELUActivation()\n",
+              "              )\n",
+              "              (output): RobertaOutput(\n",
+              "                (dense): Linear(\n",
+              "                  in_features=4096, out_features=1024, bias=True\n",
+              "                  (ia3_l): ParameterDict(  (default): Parameter containing: [torch.FloatTensor of size 1x4096])\n",
+              "                )\n",
+              "                (LayerNorm): LayerNorm((1024,), eps=1e-05, elementwise_affine=True)\n",
+              "                (dropout): Dropout(p=0.1, inplace=False)\n",
+              "              )\n",
+              "            )\n",
+              "          )\n",
+              "        )\n",
+              "      )\n",
+              "      (classifier): ModulesToSaveWrapper(\n",
+              "        (original_module): RobertaClassificationHead(\n",
+              "          (dense): Linear(in_features=1024, out_features=1024, bias=True)\n",
+              "          (dropout): Dropout(p=0.1, inplace=False)\n",
+              "          (out_proj): Linear(in_features=1024, out_features=2, bias=True)\n",
+              "        )\n",
+              "        (modules_to_save): ModuleDict(\n",
+              "          (default): RobertaClassificationHead(\n",
+              "            (dense): Linear(in_features=1024, out_features=1024, bias=True)\n",
+              "            (dropout): Dropout(p=0.1, inplace=False)\n",
+              "            (out_proj): Linear(in_features=1024, out_features=2, bias=True)\n",
+              "          )\n",
+              "        )\n",
+              "      )\n",
+              "    )\n",
+              "  )\n",
+              ")"
+            ]
+          },
+          "execution_count": 6,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path, return_dict=True)\n",
+        "model = peft.get_peft_model(model, peft_config)\n",
+        "model.print_trainable_parameters()\n",
+        "model"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
+      "id": "0d2d0381",
+      "metadata": {
+        "id": "0d2d0381"
+      },
+      "outputs": [],
+      "source": [
+        "optimizer = AdamW(params=model.parameters(), lr=lr)\n",
+        "\n",
+        "# Instantiate scheduler\n",
+        "lr_scheduler = get_linear_schedule_with_warmup(\n",
+        "    optimizer=optimizer,\n",
+        "    num_warmup_steps=0.06 * (len(train_dataloader) * num_epochs),\n",
+        "    num_training_steps=(len(train_dataloader) * num_epochs),\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "id": "fa0e73be",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "fa0e73be",
+        "outputId": "bb17c146-8acc-477d-8f9f-65b8be794abb"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "  0%|          | 0/459 [00:00<?, ?it/s]You're using a RobertaTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
+            "100%|██████████| 459/459 [01:41<00:00,  4.52it/s]\n",
+            "100%|██████████| 51/51 [00:05<00:00,  8.89it/s]\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "epoch 0: {'accuracy': 0.7034313725490197, 'f1': 0.8212703101920238}\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 459/459 [01:45<00:00,  4.35it/s]\n",
+            "100%|██████████| 51/51 [00:05<00:00,  8.66it/s]\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "epoch 1: {'accuracy': 0.7794117647058824, 'f1': 0.8432055749128919}\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 459/459 [01:47<00:00,  4.26it/s]\n",
+            "100%|██████████| 51/51 [00:05<00:00,  8.50it/s]\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "epoch 2: {'accuracy': 0.8406862745098039, 'f1': 0.8794063079777366}\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 459/459 [01:49<00:00,  4.20it/s]\n",
+            "100%|██████████| 51/51 [00:06<00:00,  8.45it/s]\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "epoch 3: {'accuracy': 0.8480392156862745, 'f1': 0.8923611111111109}\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 459/459 [01:49<00:00,  4.18it/s]\n",
+            "100%|██████████| 51/51 [00:06<00:00,  7.52it/s]\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "epoch 4: {'accuracy': 0.8529411764705882, 'f1': 0.894736842105263}\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 459/459 [01:49<00:00,  4.19it/s]\n",
+            "100%|██████████| 51/51 [00:06<00:00,  8.47it/s]\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "epoch 5: {'accuracy': 0.8700980392156863, 'f1': 0.9090909090909091}\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 459/459 [01:49<00:00,  4.20it/s]\n",
+            "100%|██████████| 51/51 [00:06<00:00,  8.41it/s]\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "epoch 6: {'accuracy': 0.875, 'f1': 0.9090909090909091}\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 459/459 [01:49<00:00,  4.21it/s]\n",
+            "100%|██████████| 51/51 [00:06<00:00,  8.41it/s]\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "epoch 7: {'accuracy': 0.8676470588235294, 'f1': 0.9042553191489361}\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 459/459 [01:50<00:00,  4.17it/s]\n",
+            "100%|██████████| 51/51 [00:06<00:00,  8.45it/s]\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "epoch 8: {'accuracy': 0.8700980392156863, 'f1': 0.9068541300527241}\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 459/459 [01:49<00:00,  4.20it/s]\n",
+            "100%|██████████| 51/51 [00:06<00:00,  8.39it/s]\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "epoch 9: {'accuracy': 0.8676470588235294, 'f1': 0.9028776978417268}\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 459/459 [01:49<00:00,  4.20it/s]\n",
+            "100%|██████████| 51/51 [00:06<00:00,  8.39it/s]\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "epoch 10: {'accuracy': 0.875, 'f1': 0.9100529100529101}\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 459/459 [01:49<00:00,  4.18it/s]\n",
+            "100%|██████████| 51/51 [00:06<00:00,  8.41it/s]"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "epoch 11: {'accuracy': 0.8651960784313726, 'f1': 0.9012567324955117}\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "model.to(device)\n",
+        "for epoch in range(num_epochs):\n",
+        "    model.train()\n",
+        "    for step, batch in enumerate(tqdm(train_dataloader)):\n",
+        "        batch.to(device)\n",
+        "        outputs = model(**batch)\n",
+        "        loss = outputs.loss\n",
+        "        loss.backward()\n",
+        "        optimizer.step()\n",
+        "        lr_scheduler.step()\n",
+        "        optimizer.zero_grad()\n",
+        "\n",
+        "    model.eval()\n",
+        "    for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+        "        batch.to(device)\n",
+        "        with torch.no_grad():\n",
+        "            outputs = model(**batch)\n",
+        "        predictions = outputs.logits.argmax(dim=-1)\n",
+        "        predictions, references = predictions, batch[\"labels\"]\n",
+        "        metric.add_batch(\n",
+        "            predictions=predictions,\n",
+        "            references=references,\n",
+        "        )\n",
+        "\n",
+        "    eval_metric = metric.compute()\n",
+        "    print(f\"epoch {epoch}:\", eval_metric)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "f2b2caca",
+      "metadata": {
+        "id": "f2b2caca"
+      },
+      "source": [
+        "## Share adapters on the 🤗 Hub"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "990b3c93",
+      "metadata": {
+        "colab": {
+          "referenced_widgets": [
+            "ad8979af959541b2a5a67f389884f057",
+            "1c020005cfe04de6bdd404ef41e0dfef"
+          ]
+        },
+        "id": "990b3c93",
+        "outputId": "0e2f13c2-0285-4f47-ab9a-d3aefea7ee05"
+      },
+      "outputs": [
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "ad8979af959541b2a5a67f389884f057",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Upload 1 LFS files:   0%|          | 0/1 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "1c020005cfe04de6bdd404ef41e0dfef",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "adapter_model.bin:   0%|          | 0.00/4.93M [00:00<?, ?B/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "text/plain": [
+              "CommitInfo(commit_url='https://huggingface.co/SumanthRH/roberta-large-peft-ia3/commit/9968de770e53ecd24e8e689a10144b7f55059a75', commit_message='Upload model', commit_description='', oid='9968de770e53ecd24e8e689a10144b7f55059a75', pr_url='https://huggingface.co/SumanthRH/roberta-large-peft-ia3/discussions/3', pr_revision='refs/pr/3', pr_num=3)"
+            ]
+          },
+          "execution_count": 25,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "model.push_to_hub(\"SumanthRH/roberta-large-peft-ia3\", use_auth_token=True)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "9d140b26",
+      "metadata": {
+        "id": "9d140b26"
+      },
+      "source": [
+        "## Load adapters from the Hub\n",
+        "\n",
+        "You can also directly load adapters from the Hub using the commands below:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "4d55c87d",
+      "metadata": {
+        "colab": {
+          "referenced_widgets": [
+            "fd320d7b5d9a43df8abf044897e25cc7",
+            "0022338db24d43bba27d0e72773855e0"
+          ]
+        },
+        "id": "4d55c87d",
+        "outputId": "e6e232d7-22a3-4c85-c72e-90d8275c9762"
+      },
+      "outputs": [
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "fd320d7b5d9a43df8abf044897e25cc7",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Downloading (…)/adapter_config.json:   0%|          | 0.00/345 [00:00<?, ?B/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "Some weights of the model checkpoint at roberta-large were not used when initializing RobertaForSequenceClassification: ['lm_head.decoder.weight', 'roberta.pooler.dense.bias', 'roberta.pooler.dense.weight', 'lm_head.dense.weight', 'lm_head.layer_norm.bias', 'lm_head.layer_norm.weight', 'lm_head.dense.bias', 'lm_head.bias']\n",
+            "- This IS expected if you are initializing RobertaForSequenceClassification from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
+            "- This IS NOT expected if you are initializing RobertaForSequenceClassification from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
+            "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-large and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
+            "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "0022338db24d43bba27d0e72773855e0",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Downloading adapter_model.bin:   0%|          | 0.00/4.93M [00:00<?, ?B/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "  0%|                                                                                                                                                                  | 0/51 [00:00<?, ?it/s]You're using a RobertaTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
+            "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 51/51 [00:04<00:00, 10.57it/s]"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "{'accuracy': 0.8774509803921569, 'f1': 0.9116607773851589}\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "import torch\n",
+        "from peft import PeftModel, PeftConfig\n",
+        "from transformers import AutoModelForCausalLM, AutoTokenizer\n",
+        "\n",
+        "peft_model_id = \"SumanthRH/roberta-large-peft-ia3\"\n",
+        "config = PeftConfig.from_pretrained(peft_model_id)\n",
+        "inference_model = AutoModelForSequenceClassification.from_pretrained(config.base_model_name_or_path)\n",
+        "tokenizer = AutoTokenizer.from_pretrained(config.base_model_name_or_path)\n",
+        "\n",
+        "# Load the Lora model\n",
+        "inference_model = PeftModel.from_pretrained(inference_model, peft_model_id)\n",
+        "\n",
+        "inference_model.to(device)\n",
+        "inference_model.eval()\n",
+        "for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+        "    batch.to(device)\n",
+        "    with torch.no_grad():\n",
+        "        outputs = inference_model(**batch)\n",
+        "    predictions = outputs.logits.argmax(dim=-1)\n",
+        "    predictions, references = predictions, batch[\"labels\"]\n",
+        "    metric.add_batch(\n",
+        "        predictions=predictions,\n",
+        "        references=references,\n",
+        "    )\n",
+        "\n",
+        "eval_metric = metric.compute()\n",
+        "print(eval_metric)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "27c43da1",
+      "metadata": {
+        "id": "27c43da1"
+      },
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "T4",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.10.9"
+    },
+    "vscode": {
+      "interpreter": {
+        "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
+      }
+    },
+    "widgets": {
+      "application/vnd.jupyter.widget-state+json": {
+        "007f2f512694405c9245edd5e1f58551": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_9aaeeb1213854768a6af51f8db54f6b6",
+              "IPY_MODEL_e6e2192c0a904bb6850c6bc68b579995",
+              "IPY_MODEL_608a68c6f651419d8fd210044b4561cf"
+            ],
+            "layout": "IPY_MODEL_ac9d6255521f428fa7fda5735d71dbec"
+          }
+        },
+        "015132b18da54a8f89a83cd9bf6fd17c": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "01f39b548eff49aea6ba0efabb4486de": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_b82b0c29bd53432baa5596b4f1aaf076",
+            "placeholder": "​",
+            "style": "IPY_MODEL_a8ccd811bba848d2ad2f84d2cdf9ef03",
+            "value": " 441k/? [00:00&lt;00:00, 7.70MB/s]"
+          }
+        },
+        "0b20fa2eb59749e1b564df70f2378984": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "0b2e59615f80452cbe25dfd467099b84": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "0c488289ee494a8d99d1f02a13729382": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "0cecb897c86c4892b94a1990ab08a926": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_b8af0294819e4280ad41fa1c11006adf",
+              "IPY_MODEL_c7530d63b2f745e799713284abacbd2c",
+              "IPY_MODEL_12a1e302a69543c5bc0e0a66be008ca0"
+            ],
+            "layout": "IPY_MODEL_9c372e9e9b20433faed8530ca0f4424c"
+          }
+        },
+        "0f29f96aec7e44a1b97cda0fcbe17665": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_844ea1050893482785c1b68150f4ab20",
+            "placeholder": "​",
+            "style": "IPY_MODEL_92d023972a204222b59c12fc4b4d3bcf",
+            "value": " 3/3 [00:00&lt;00:00,  3.53it/s]"
+          }
+        },
+        "11ba7f922c58474d9cb8b8c7a22caddc": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_598fc42dfed04aadaeb38539dd259871",
+              "IPY_MODEL_fb05d1ece2ba4963bcbf99f89296c709",
+              "IPY_MODEL_e3fe73a6ffcf4d089911b4149b9b4512"
+            ],
+            "layout": "IPY_MODEL_45e1b59770f946dba06511f9b5d1ad23"
+          }
+        },
+        "1232101b618d43f5889e4ad81fa24514": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "12a1e302a69543c5bc0e0a66be008ca0": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_3a8de0eb7db44647a734590b6b351b44",
+            "placeholder": "​",
+            "style": "IPY_MODEL_64d8affd2e854a1c9043fec7ca8a2796",
+            "value": " 1.42G/1.42G [00:15&lt;00:00, 73.3MB/s]"
+          }
+        },
+        "136a32dbeef646df944a8b59cb00c0c4": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": "hidden",
+            "width": null
+          }
+        },
+        "1487d054f1824f739c93c00621591bd0": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_1e3adfe9c9e34d4abe74b65e298c0e7b",
+            "max": 408,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_f91ed6a931c247b5903304a28998633d",
+            "value": 408
+          }
+        },
+        "16f8d52980dc41e89ed3bfb9172420a6": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "1824b7b748ee4763b5098cd915107f63": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_b668d56ab549478984ad14c22e040e47",
+            "placeholder": "​",
+            "style": "IPY_MODEL_bac855f4c7044fe88bcd74170e13f103",
+            "value": " 3668/3668 [00:01&lt;00:00, 2847.65 examples/s]"
+          }
+        },
+        "1896a8f160ea45e5ac2a88970feecdb9": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "1a2897c84d454c1a9c115aef178f4fcf": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "1a8e75c718d14f4c8f99de1c8efa84b5": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "1aa34d9a0b16444baadf2ed7e43b72e5": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_326b48d7d2e94defa52858171177e7d7",
+            "max": 1,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_9a3dcc1c2fe542b7b912419935d9dd9a",
+            "value": 1
+          }
+        },
+        "1b6c8de76fd948b5b0eba8346f6e0bec": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "1c5e43a201f0460f88b53739bc1eaa43": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "1e3adfe9c9e34d4abe74b65e298c0e7b": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "1f27766bc2d941f6a1d03fc69a6026a3": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "2204ca891c3940879abde0f55fbadf03": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "24062742dc6749a2aab19cbfd1e11684": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "241dd21eeb5843ef8433e47b415c5b62": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "248fe45eee37449982520a890696e6d4": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_faf0c550adc5402bbee71b027822ce9c",
+            "max": 456318,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_9c57da41dfc04fe4a4437097285599bf",
+            "value": 456318
+          }
+        },
+        "24e236a4360e416a8e5c20d887274bcc": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_7011752f7e0a422883bf0f218f6941c3",
+              "IPY_MODEL_248fe45eee37449982520a890696e6d4",
+              "IPY_MODEL_5ec5d0d9191047608f61cb78563f7641"
+            ],
+            "layout": "IPY_MODEL_d7c2b00fd90147528b00a29552f29b44"
+          }
+        },
+        "2616b6102108476f8bf9e3d35b63494d": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "27009ed667c242488773ce3fcc58360a": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "276fc5825a624a3a9026301620682c6c": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "20px"
+          }
+        },
+        "29a8cce77d2745038f2c742d17254139": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "2bc5432ab9464f7b9192aa1f5a26a1b2": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "2c512bc0a21a4f6684aa0593a969e6cb": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "3086db94647a41569b6f091e4f11f3cb": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "326b48d7d2e94defa52858171177e7d7": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "20px"
+          }
+        },
+        "32764784cc9644198c622f6706db6836": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "32ba35144ab34b0ebb7cfb75b86ccdd4": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_71c3a5a515a949bfb2290612bfb2d05f",
+            "placeholder": "​",
+            "style": "IPY_MODEL_1232101b618d43f5889e4ad81fa24514",
+            "value": "Downloading (…)/main/tokenizer.json: 100%"
+          }
+        },
+        "332971de5e894c8ca866c311cc6e180c": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "33e9821903f84551a2e56c0586a5332b": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "34e576af7aab4ef795239b1d9a281b15": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "357c082907e140b58c807a394446d811": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_c47de12dd692434ab9497e8a0d2a19ba",
+            "max": 3,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_963b22b2ef1e45f5ba8320f72ea6a83b",
+            "value": 3
+          }
+        },
+        "376f00f38b46434e922c3f6f7dc4a85c": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "39492d8b91f64e97bc8caead77957508": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_d9db044ff31f4856a4d25e57fe9882bc",
+            "placeholder": "​",
+            "style": "IPY_MODEL_f76b651681d74b2eab0ab07f43983a2a",
+            "value": "Map: 100%"
+          }
+        },
+        "39f26160766f48798761079527e14396": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "3a8de0eb7db44647a734590b6b351b44": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "3d323bc6e1fd4091a0ed2ffd521f2ec7": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "3e2ca33b7473499d8314238ec245cd90": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "3ef39b223ab74d788223970ec0da21e6": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_2204ca891c3940879abde0f55fbadf03",
+            "max": 1355863,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_58f2da1b793b44b09cedb5e0a3a1ef02",
+            "value": 1355863
+          }
+        },
+        "3f2d9eba845341da97fa1b957e72de5e": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "44eb5aeeb0004f799e79d3ed51cf37d4": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "45128b02652b4c20bf448db8495d76d2": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "45e1b59770f946dba06511f9b5d1ad23": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "46fc201246804f28946fd0c59e09c4ac": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "47480982ce83440997297e605cdf8a31": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "47ffc35023144c4fa6b93e73b7a2ee60": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "49ccb14ddd874e798371494942725128": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "4c1798c3d0cb43949a1ed7519b57d3fc": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_c137c84ae40049ffba7d1f4d77b21de2",
+            "placeholder": "​",
+            "style": "IPY_MODEL_81f8db0dcdbc4e5593fa3fbb6c2b9361",
+            "value": " 1725/1725 [00:00&lt;00:00, 3028.59 examples/s]"
+          }
+        },
+        "4d9d717d2226444094e9753fdc843849": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "5062d6f6feb34835afaf6d452900d514": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "51ec9bdff1834e4f8390f0eaf7d4aeb8": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "537c7d2f4260498a82132cb9fae5daa5": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "53f9d507f4024b2080591215d3c4bab4": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "5408dfdfc5624ff5b1c0b2e494dd4b35": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "55a0ca0754c94f0bba6ede50b7fb7ea8": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_276fc5825a624a3a9026301620682c6c",
+            "max": 1,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_5c10a16929ce40e48361efa44e96a7f8",
+            "value": 1
+          }
+        },
+        "561f61d1cec94f5abbff3f8746c3fd96": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_a05844fa4675494cb7bbe48f40f1aaac",
+            "placeholder": "​",
+            "style": "IPY_MODEL_b241da7afea94fc0a6b407a0a78a8355",
+            "value": "Downloading (…)olve/main/vocab.json: 100%"
+          }
+        },
+        "562a55ffabef4d218c78c5dcc6665484": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_47ffc35023144c4fa6b93e73b7a2ee60",
+            "max": 27887,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_16f8d52980dc41e89ed3bfb9172420a6",
+            "value": 27887
+          }
+        },
+        "58f2da1b793b44b09cedb5e0a3a1ef02": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "598fc42dfed04aadaeb38539dd259871": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_2c512bc0a21a4f6684aa0593a969e6cb",
+            "placeholder": "​",
+            "style": "IPY_MODEL_376f00f38b46434e922c3f6f7dc4a85c",
+            "value": "Downloading metadata: 100%"
+          }
+        },
+        "5997f14e0a3044249b9cabc2b307e3a4": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "59e1d01621f4404ca2102d00e2b01f87": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_2bc5432ab9464f7b9192aa1f5a26a1b2",
+            "placeholder": "​",
+            "style": "IPY_MODEL_80bcbdb92af34c9889b7d105affe34ba",
+            "value": " 27.9k/27.9k [00:00&lt;00:00, 1.51MB/s]"
+          }
+        },
+        "5b0a0578afad40868bb71707c05e0335": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_f46d3699775b4d7193adeebb4f18a34f",
+            "max": 3668,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_5997f14e0a3044249b9cabc2b307e3a4",
+            "value": 3668
+          }
+        },
+        "5ba9f4bd64bd4e1e905887760f90ae3e": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "5c10a16929ce40e48361efa44e96a7f8": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "5ec5d0d9191047608f61cb78563f7641": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_d4453448f8b04f0ea76c71887bd33a8c",
+            "placeholder": "​",
+            "style": "IPY_MODEL_ff5172169c794d40b6c433da642d54a9",
+            "value": " 456k/456k [00:00&lt;00:00, 6.31MB/s]"
+          }
+        },
+        "608a68c6f651419d8fd210044b4561cf": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_da3e335ddc9846ea832c75d69684575f",
+            "placeholder": "​",
+            "style": "IPY_MODEL_daa8ce62f0204a11bde7cd9e31cc2fa1",
+            "value": " 880/1725 [00:00&lt;00:00, 4478.16 examples/s]"
+          }
+        },
+        "64d8affd2e854a1c9043fec7ca8a2796": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "6513f2b58d654a488b132abd8c83c9b6": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": "hidden",
+            "width": null
+          }
+        },
+        "6786c3895b594301b2a7d4ed2767cb35": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_bf35a5a5d9b840a18ef10938d23fce0c",
+              "IPY_MODEL_ad4872e198ee44f8b83323d891347ffa",
+              "IPY_MODEL_0f29f96aec7e44a1b97cda0fcbe17665"
+            ],
+            "layout": "IPY_MODEL_dbb4032fab4d49a5b250be57a4d51fb0"
+          }
+        },
+        "6aa4308f0cb348419f1217e48ef2dbd7": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": "hidden",
+            "width": null
+          }
+        },
+        "6b937f0053b64c67af74d44bcb6e51b7": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_72f55658a145483cb90668bf7b6f6c8a",
+              "IPY_MODEL_357c082907e140b58c807a394446d811",
+              "IPY_MODEL_f127594b694f4d2fafb3872e8190b1d6"
+            ],
+            "layout": "IPY_MODEL_f9c8bd12201a4c8a86b2bb3c1a14d74e"
+          }
+        },
+        "6bf5b27d3c3c407eb10f8d9d6e8e8d22": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "6c6f2223243b4a7485aef7fbbfe07668": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "6ea6ff70fa164264aef9efce9f921f10": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_ecc2102ede2d4c8b94ce66b247054c96",
+              "IPY_MODEL_e64ca48867434ca2944dcb2b1c70c02c",
+              "IPY_MODEL_7ac75048225f4a4bbedac97965cf9837"
+            ],
+            "layout": "IPY_MODEL_332971de5e894c8ca866c311cc6e180c"
+          }
+        },
+        "6f9efa5f778d4f029dca7b4d6817b4c4": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "7011752f7e0a422883bf0f218f6941c3": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_ea307bb7a9ad46a484330b1daf708169",
+            "placeholder": "​",
+            "style": "IPY_MODEL_27009ed667c242488773ce3fcc58360a",
+            "value": "Downloading (…)olve/main/merges.txt: 100%"
+          }
+        },
+        "710f512e4a2b40cb85805b33a7dc42e4": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_0c488289ee494a8d99d1f02a13729382",
+            "placeholder": "​",
+            "style": "IPY_MODEL_49ccb14ddd874e798371494942725128",
+            "value": "Downloading builder script: 100%"
+          }
+        },
+        "71b4a798dc374a72817f6c118f2f05b8": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "71c3a5a515a949bfb2290612bfb2d05f": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "72f55658a145483cb90668bf7b6f6c8a": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_dc55ec8e57984efcb0f269ef0ef41c02",
+            "placeholder": "​",
+            "style": "IPY_MODEL_cd07261ef21a4b859de53f244df33f2a",
+            "value": "100%"
+          }
+        },
+        "730111ee99b4470c81ab4ade07b30352": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_7d6d21774fec4eb0bab3bc2bfa2708d6",
+            "placeholder": "​",
+            "style": "IPY_MODEL_9882a67915f8475c9f4b8a5b15d64e50",
+            "value": "Downloading readme: 100%"
+          }
+        },
+        "73379eb4954d4be6ab90008addd7d3bd": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "74e056313e9e4a92bfaa22019ac1e58e": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "75ee099566ca46eb8a75475246aaab01": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_e94dd1ea928f43b880af21ced7f11d14",
+              "IPY_MODEL_ad84cdcfa07f4f608dccd10395d35e79",
+              "IPY_MODEL_8bd3a235ae654b1cbaae36aeb1a62e70"
+            ],
+            "layout": "IPY_MODEL_ebe2f83a5783401ab501cdaf9c4e2ad5"
+          }
+        },
+        "786b2430a42942f1aeae253861820dcb": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_e2741973e91745ea930d3cc23070cf52",
+              "IPY_MODEL_b9f18367c54b4203bee70c680ae9cdde",
+              "IPY_MODEL_7db82bb6fa2949b3a6bc9eb152fc3af1"
+            ],
+            "layout": "IPY_MODEL_136a32dbeef646df944a8b59cb00c0c4"
+          }
+        },
+        "788a143aad46467789acf08762fbf39f": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_32ba35144ab34b0ebb7cfb75b86ccdd4",
+              "IPY_MODEL_3ef39b223ab74d788223970ec0da21e6",
+              "IPY_MODEL_be40292e613949a0ba1bfd1846cdab92"
+            ],
+            "layout": "IPY_MODEL_a6ab0e37d063407fa4adc11f2f0299da"
+          }
+        },
+        "7900796766b946da886338653b495533": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_84b50ae864e0463d98efa792e149e712",
+              "IPY_MODEL_802dc985a31e4febb8eafa4682e242ec",
+              "IPY_MODEL_f31d9d6e2d3140eeb821153a7b69b90a"
+            ],
+            "layout": "IPY_MODEL_3f2d9eba845341da97fa1b957e72de5e"
+          }
+        },
+        "7ac75048225f4a4bbedac97965cf9837": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_d8e645f1697d46e0ac23f70e14498fab",
+            "placeholder": "​",
+            "style": "IPY_MODEL_8dc1453856d549c4a1a688818447dd59",
+            "value": " 482/482 [00:00&lt;00:00, 11.9kB/s]"
+          }
+        },
+        "7d6d21774fec4eb0bab3bc2bfa2708d6": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "7db82bb6fa2949b3a6bc9eb152fc3af1": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_d981db72ab2745a598ed45a8762d5fcd",
+            "placeholder": "​",
+            "style": "IPY_MODEL_73379eb4954d4be6ab90008addd7d3bd",
+            "value": " 332/408 [00:00&lt;00:00, 1442.21 examples/s]"
+          }
+        },
+        "802dc985a31e4febb8eafa4682e242ec": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_b451310e94b74abda4e795a59cdda9ab",
+            "max": 1,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_537c7d2f4260498a82132cb9fae5daa5",
+            "value": 1
+          }
+        },
+        "80bcbdb92af34c9889b7d105affe34ba": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "81f8db0dcdbc4e5593fa3fbb6c2b9361": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "83623082d4e9457a9173db3129154f94": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_e8a53956f6ad46d58ec3a9a039f2303e",
+            "max": 1725,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_91f07c6089354ceeb4e628ef1791d2d6",
+            "value": 1725
+          }
+        },
+        "83bae5949ec448c6ad6f68a7b8d3d436": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "841f3571fcec42ad8e1e43997567788c": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "844ea1050893482785c1b68150f4ab20": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "84b50ae864e0463d98efa792e149e712": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_d3638a2985fc4fdfbf239914dbc32fe8",
+            "placeholder": "​",
+            "style": "IPY_MODEL_a9d237f2f62e4a839abdec541715a5de",
+            "value": "Downloading data: "
+          }
+        },
+        "8750ab964b5444d49db4fe8542964d8c": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "87b93c14cdae477ab49522354631e82b": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": "hidden",
+            "width": null
+          }
+        },
+        "897708ca40da48f3ae846710b4e7f7f0": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_e6c085b451a346b6a3b82c67d7b9e9e2",
+            "placeholder": "​",
+            "style": "IPY_MODEL_29a8cce77d2745038f2c742d17254139",
+            "value": "Downloading data: "
+          }
+        },
+        "8bd3a235ae654b1cbaae36aeb1a62e70": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_32764784cc9644198c622f6706db6836",
+            "placeholder": "​",
+            "style": "IPY_MODEL_83bae5949ec448c6ad6f68a7b8d3d436",
+            "value": " 5.75k/5.75k [00:00&lt;00:00, 183kB/s]"
+          }
+        },
+        "8c55316c54d44bd4b75a8457e2d8c595": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_c994a28df165445bbf0d80c165bc5a0b",
+            "max": 3668,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_1a2897c84d454c1a9c115aef178f4fcf",
+            "value": 3668
+          }
+        },
+        "8dc1453856d549c4a1a688818447dd59": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "91f07c6089354ceeb4e628ef1791d2d6": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "92d023972a204222b59c12fc4b4d3bcf": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "938a5b44d90140e29ba33628a2215f2a": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "963b22b2ef1e45f5ba8320f72ea6a83b": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "963da028a1594c1bbd223e93832f44bd": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "96c4ecd7376c43ee9a4ba270851d6fff": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_1f27766bc2d941f6a1d03fc69a6026a3",
+            "placeholder": "​",
+            "style": "IPY_MODEL_1c5e43a201f0460f88b53739bc1eaa43",
+            "value": " 899k/899k [00:00&lt;00:00, 11.0MB/s]"
+          }
+        },
+        "9882a67915f8475c9f4b8a5b15d64e50": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "99e8679e71f4443c92f13971e8885d38": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_24062742dc6749a2aab19cbfd1e11684",
+            "placeholder": "​",
+            "style": "IPY_MODEL_1b6c8de76fd948b5b0eba8346f6e0bec",
+            "value": "Downloading data: "
+          }
+        },
+        "9a3dcc1c2fe542b7b912419935d9dd9a": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "9aaeeb1213854768a6af51f8db54f6b6": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_a39ea243b7964c298eae71e9eaf32e17",
+            "placeholder": "​",
+            "style": "IPY_MODEL_bf7f7cb363df4384ade192666b77c715",
+            "value": "Generating test split:  51%"
+          }
+        },
+        "9ae4e6a6543e4da6bba06175aeef3ea1": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_fa9675039cc443f791dcfbc0bdca065c",
+              "IPY_MODEL_5b0a0578afad40868bb71707c05e0335",
+              "IPY_MODEL_d1a82e42e866449cbb70c1f68ac1bc03"
+            ],
+            "layout": "IPY_MODEL_bd12886eee644913ba83fd4ebb6b62ee"
+          }
+        },
+        "9c372e9e9b20433faed8530ca0f4424c": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "9c50277ed18a424a9da98707cf726d29": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "9c57da41dfc04fe4a4437097285599bf": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "9cf73d46c2f04bf398a4564a56f03bd6": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "9d8e3a4fe5864a4ca229ba6e092181e4": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "a018f7c156584eb3833b6aba3710b3c0": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_c2a078c69d3f45ca9895e0e7f95aaf2b",
+              "IPY_MODEL_8c55316c54d44bd4b75a8457e2d8c595",
+              "IPY_MODEL_1824b7b748ee4763b5098cd915107f63"
+            ],
+            "layout": "IPY_MODEL_87b93c14cdae477ab49522354631e82b"
+          }
+        },
+        "a05844fa4675494cb7bbe48f40f1aaac": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "a246e6c60c054b4383c510c31b255a87": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "a39ea243b7964c298eae71e9eaf32e17": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "a439e5ecb0a040ca8188c6d74ff643a9": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_710f512e4a2b40cb85805b33a7dc42e4",
+              "IPY_MODEL_e5994b94b84143f4a06c49a45a078bd0",
+              "IPY_MODEL_e4f935e4e8e84320b2381aaf3493962c"
+            ],
+            "layout": "IPY_MODEL_44eb5aeeb0004f799e79d3ed51cf37d4"
+          }
+        },
+        "a5c93fac02884914ae8e140e0c0d2a17": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_74e056313e9e4a92bfaa22019ac1e58e",
+            "max": 898823,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_938a5b44d90140e29ba33628a2215f2a",
+            "value": 898823
+          }
+        },
+        "a6ab0e37d063407fa4adc11f2f0299da": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "a8b5d642ed654c0f85f3a9610c68b754": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "a8ccd811bba848d2ad2f84d2cdf9ef03": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "a93509d61ac94628a74bc0f98c0eec06": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "a9d237f2f62e4a839abdec541715a5de": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "ac9d6255521f428fa7fda5735d71dbec": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": "hidden",
+            "width": null
+          }
+        },
+        "ad4872e198ee44f8b83323d891347ffa": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_3d323bc6e1fd4091a0ed2ffd521f2ec7",
+            "max": 3,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_2616b6102108476f8bf9e3d35b63494d",
+            "value": 3
+          }
+        },
+        "ad84cdcfa07f4f608dccd10395d35e79": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_6bf5b27d3c3c407eb10f8d9d6e8e8d22",
+            "max": 5749,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_47480982ce83440997297e605cdf8a31",
+            "value": 5749
+          }
+        },
+        "af185d9bedf64d54bc77f7f6e7c448f4": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "b07f26a21325493cac19113f1aa1ee96": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "b241da7afea94fc0a6b407a0a78a8355": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "b42e835e0ba24a08b5815234a22b4da6": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "b451310e94b74abda4e795a59cdda9ab": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "20px"
+          }
+        },
+        "b668d56ab549478984ad14c22e040e47": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "b82b0c29bd53432baa5596b4f1aaf076": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "b8af0294819e4280ad41fa1c11006adf": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_b07f26a21325493cac19113f1aa1ee96",
+            "placeholder": "​",
+            "style": "IPY_MODEL_fbdf6c544fb54294903524a69384e773",
+            "value": "Downloading model.safetensors: 100%"
+          }
+        },
+        "b9f18367c54b4203bee70c680ae9cdde": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_c9837f88650844ea94442ad1c5682972",
+            "max": 408,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_963da028a1594c1bbd223e93832f44bd",
+            "value": 408
+          }
+        },
+        "bac855f4c7044fe88bcd74170e13f103": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "bd12886eee644913ba83fd4ebb6b62ee": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": "hidden",
+            "width": null
+          }
+        },
+        "bdf0999dfddc43ca8e04ceaac628064c": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "be40292e613949a0ba1bfd1846cdab92": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_51ec9bdff1834e4f8390f0eaf7d4aeb8",
+            "placeholder": "​",
+            "style": "IPY_MODEL_71b4a798dc374a72817f6c118f2f05b8",
+            "value": " 1.36M/1.36M [00:00&lt;00:00, 17.8MB/s]"
+          }
+        },
+        "bf35a5a5d9b840a18ef10938d23fce0c": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_af185d9bedf64d54bc77f7f6e7c448f4",
+            "placeholder": "​",
+            "style": "IPY_MODEL_4d9d717d2226444094e9753fdc843849",
+            "value": "Downloading data files: 100%"
+          }
+        },
+        "bf7f7cb363df4384ade192666b77c715": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "c137c84ae40049ffba7d1f4d77b21de2": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "c289713b179641bd915b3c334208197a": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "c2a078c69d3f45ca9895e0e7f95aaf2b": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_a8b5d642ed654c0f85f3a9610c68b754",
+            "placeholder": "​",
+            "style": "IPY_MODEL_8750ab964b5444d49db4fe8542964d8c",
+            "value": "Map: 100%"
+          }
+        },
+        "c2fa0ef9f45b447e9dfe5c576428c714": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "c47de12dd692434ab9497e8a0d2a19ba": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "c4aa7cee6e5d4a89a2c33b9ce2e9c489": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "c7530d63b2f745e799713284abacbd2c": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_6c6f2223243b4a7485aef7fbbfe07668",
+            "max": 1421700479,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_a93509d61ac94628a74bc0f98c0eec06",
+            "value": 1421700479
+          }
+        },
+        "c77cdd4479294ce7bf3f3ef271e95b1d": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "c9837f88650844ea94442ad1c5682972": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "c994a28df165445bbf0d80c165bc5a0b": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "cca43d628ff94369bc9713cbad616adb": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_34e576af7aab4ef795239b1d9a281b15",
+            "placeholder": "​",
+            "style": "IPY_MODEL_9d8e3a4fe5864a4ca229ba6e092181e4",
+            "value": " 408/408 [00:00&lt;00:00, 2109.25 examples/s]"
+          }
+        },
+        "cd07261ef21a4b859de53f244df33f2a": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "d1997b08e5284008afce56a5ed6347be": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_730111ee99b4470c81ab4ade07b30352",
+              "IPY_MODEL_562a55ffabef4d218c78c5dcc6665484",
+              "IPY_MODEL_59e1d01621f4404ca2102d00e2b01f87"
+            ],
+            "layout": "IPY_MODEL_1896a8f160ea45e5ac2a88970feecdb9"
+          }
+        },
+        "d1a82e42e866449cbb70c1f68ac1bc03": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_5ba9f4bd64bd4e1e905887760f90ae3e",
+            "placeholder": "​",
+            "style": "IPY_MODEL_1a8e75c718d14f4c8f99de1c8efa84b5",
+            "value": " 3610/3668 [00:00&lt;00:00, 4169.48 examples/s]"
+          }
+        },
+        "d267c0cf26a8466d9938861ff5272a1e": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_561f61d1cec94f5abbff3f8746c3fd96",
+              "IPY_MODEL_a5c93fac02884914ae8e140e0c0d2a17",
+              "IPY_MODEL_96c4ecd7376c43ee9a4ba270851d6fff"
+            ],
+            "layout": "IPY_MODEL_5062d6f6feb34835afaf6d452900d514"
+          }
+        },
+        "d29a5f422214434c9be3886ce0d1e918": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "d3638a2985fc4fdfbf239914dbc32fe8": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "d4453448f8b04f0ea76c71887bd33a8c": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "d5502b7dcf784d289fc748881924334c": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "d63577f0ae724938952f9b681a89512a": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_c4aa7cee6e5d4a89a2c33b9ce2e9c489",
+            "placeholder": "​",
+            "style": "IPY_MODEL_b42e835e0ba24a08b5815234a22b4da6",
+            "value": "Map: 100%"
+          }
+        },
+        "d7c2b00fd90147528b00a29552f29b44": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "d8e645f1697d46e0ac23f70e14498fab": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "d981db72ab2745a598ed45a8762d5fcd": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "d9db044ff31f4856a4d25e57fe9882bc": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "da3e335ddc9846ea832c75d69684575f": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "daa8ce62f0204a11bde7cd9e31cc2fa1": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "dbb4032fab4d49a5b250be57a4d51fb0": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "dc55ec8e57984efcb0f269ef0ef41c02": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "e0e903b3ae8044f4a58ecd70825f36ec": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_99e8679e71f4443c92f13971e8885d38",
+              "IPY_MODEL_55a0ca0754c94f0bba6ede50b7fb7ea8",
+              "IPY_MODEL_fae83f7a625448e788ffdb1a13d2d530"
+            ],
+            "layout": "IPY_MODEL_3086db94647a41569b6f091e4f11f3cb"
+          }
+        },
+        "e2741973e91745ea930d3cc23070cf52": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_c2fa0ef9f45b447e9dfe5c576428c714",
+            "placeholder": "​",
+            "style": "IPY_MODEL_241dd21eeb5843ef8433e47b415c5b62",
+            "value": "Generating validation split:  81%"
+          }
+        },
+        "e3313a7fb356432bada289ad346f1bdb": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "e3d36dd4ddcb4287b8d8c942a26dc478": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "e3fe73a6ffcf4d089911b4149b9b4512": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_0b2e59615f80452cbe25dfd467099b84",
+            "placeholder": "​",
+            "style": "IPY_MODEL_45128b02652b4c20bf448db8495d76d2",
+            "value": " 28.7k/28.7k [00:00&lt;00:00, 1.12MB/s]"
+          }
+        },
+        "e41888b1dea140d18be25efc6d99d0c3": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_d63577f0ae724938952f9b681a89512a",
+              "IPY_MODEL_83623082d4e9457a9173db3129154f94",
+              "IPY_MODEL_4c1798c3d0cb43949a1ed7519b57d3fc"
+            ],
+            "layout": "IPY_MODEL_6513f2b58d654a488b132abd8c83c9b6"
+          }
+        },
+        "e4f935e4e8e84320b2381aaf3493962c": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_5408dfdfc5624ff5b1c0b2e494dd4b35",
+            "placeholder": "​",
+            "style": "IPY_MODEL_9c50277ed18a424a9da98707cf726d29",
+            "value": " 28.8k/28.8k [00:00&lt;00:00, 1.29MB/s]"
+          }
+        },
+        "e5994b94b84143f4a06c49a45a078bd0": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_015132b18da54a8f89a83cd9bf6fd17c",
+            "max": 28751,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_39f26160766f48798761079527e14396",
+            "value": 28751
+          }
+        },
+        "e64ca48867434ca2944dcb2b1c70c02c": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_e3d36dd4ddcb4287b8d8c942a26dc478",
+            "max": 482,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_0b20fa2eb59749e1b564df70f2378984",
+            "value": 482
+          }
+        },
+        "e66a0c2552ff46b5a41cf8d803114b8f": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_897708ca40da48f3ae846710b4e7f7f0",
+              "IPY_MODEL_1aa34d9a0b16444baadf2ed7e43b72e5",
+              "IPY_MODEL_01f39b548eff49aea6ba0efabb4486de"
+            ],
+            "layout": "IPY_MODEL_46fc201246804f28946fd0c59e09c4ac"
+          }
+        },
+        "e6c085b451a346b6a3b82c67d7b9e9e2": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "e6e2192c0a904bb6850c6bc68b579995": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_841f3571fcec42ad8e1e43997567788c",
+            "max": 1725,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_a246e6c60c054b4383c510c31b255a87",
+            "value": 1725
+          }
+        },
+        "e815b0749289411eb680c56e4fd39dae": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "e8a53956f6ad46d58ec3a9a039f2303e": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "e94dd1ea928f43b880af21ced7f11d14": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_fe20644617844cf7a471e22a99ca7b5e",
+            "placeholder": "​",
+            "style": "IPY_MODEL_d5502b7dcf784d289fc748881924334c",
+            "value": "Downloading builder script: 100%"
+          }
+        },
+        "ea307bb7a9ad46a484330b1daf708169": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "ebe2f83a5783401ab501cdaf9c4e2ad5": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "ecc2102ede2d4c8b94ce66b247054c96": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_bdf0999dfddc43ca8e04ceaac628064c",
+            "placeholder": "​",
+            "style": "IPY_MODEL_c289713b179641bd915b3c334208197a",
+            "value": "Downloading (…)lve/main/config.json: 100%"
+          }
+        },
+        "f127594b694f4d2fafb3872e8190b1d6": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_3e2ca33b7473499d8314238ec245cd90",
+            "placeholder": "​",
+            "style": "IPY_MODEL_e3313a7fb356432bada289ad346f1bdb",
+            "value": " 3/3 [00:00&lt;00:00, 58.47it/s]"
+          }
+        },
+        "f31d9d6e2d3140eeb821153a7b69b90a": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_6f9efa5f778d4f029dca7b4d6817b4c4",
+            "placeholder": "​",
+            "style": "IPY_MODEL_d29a5f422214434c9be3886ce0d1e918",
+            "value": " 6.22k/? [00:00&lt;00:00, 101kB/s]"
+          }
+        },
+        "f46d3699775b4d7193adeebb4f18a34f": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "f76b651681d74b2eab0ab07f43983a2a": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "f871eeaa54cf451b8a2de64eed90d5b6": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_39492d8b91f64e97bc8caead77957508",
+              "IPY_MODEL_1487d054f1824f739c93c00621591bd0",
+              "IPY_MODEL_cca43d628ff94369bc9713cbad616adb"
+            ],
+            "layout": "IPY_MODEL_6aa4308f0cb348419f1217e48ef2dbd7"
+          }
+        },
+        "f91ed6a931c247b5903304a28998633d": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "f9c8bd12201a4c8a86b2bb3c1a14d74e": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "fa9675039cc443f791dcfbc0bdca065c": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_fc11a9d0c0b7409cb2f61fcabac2bfa6",
+            "placeholder": "​",
+            "style": "IPY_MODEL_9cf73d46c2f04bf398a4564a56f03bd6",
+            "value": "Generating train split:  98%"
+          }
+        },
+        "fae83f7a625448e788ffdb1a13d2d530": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_53f9d507f4024b2080591215d3c4bab4",
+            "placeholder": "​",
+            "style": "IPY_MODEL_c77cdd4479294ce7bf3f3ef271e95b1d",
+            "value": " 1.05M/? [00:00&lt;00:00, 12.7MB/s]"
+          }
+        },
+        "faf0c550adc5402bbee71b027822ce9c": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "fb05d1ece2ba4963bcbf99f89296c709": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_e815b0749289411eb680c56e4fd39dae",
+            "max": 28682,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_33e9821903f84551a2e56c0586a5332b",
+            "value": 28682
+          }
+        },
+        "fbdf6c544fb54294903524a69384e773": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "fc11a9d0c0b7409cb2f61fcabac2bfa6": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "fe20644617844cf7a471e22a99ca7b5e": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "ff5172169c794d40b6c433da642d54a9": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        }
+      }
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}
diff --git a/examples/sequence_classification/LoRA-torchao-8bit-dynamic-activation.ipynb b/examples/sequence_classification/LoRA-torchao-8bit-dynamic-activation.ipynb
new file mode 100644
index 0000000..da07eba
--- /dev/null
+++ b/examples/sequence_classification/LoRA-torchao-8bit-dynamic-activation.ipynb
@@ -0,0 +1,527 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "900b542d-0249-453c-a915-a061b80af69f",
+   "metadata": {},
+   "source": [
+    "# PyTorch AO (torchao) with int8_dynamic_activation_int8_weight"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "10e1acc3-50b8-4d40-bdf3-0133c113cc4b",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "a9935ae2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import argparse\n",
+    "import os\n",
+    "\n",
+    "import torch\n",
+    "from torch.optim import AdamW\n",
+    "from torch.utils.data import DataLoader\n",
+    "from torchao.quantization import Int8DynamicActivationInt8WeightConfig\n",
+    "from peft import (\n",
+    "    get_peft_config,\n",
+    "    get_peft_model,\n",
+    "    get_peft_model_state_dict,\n",
+    "    set_peft_model_state_dict,\n",
+    "    LoraConfig,\n",
+    "    PeftType,\n",
+    "    PrefixTuningConfig,\n",
+    "    PromptEncoderConfig,\n",
+    ")\n",
+    "\n",
+    "import evaluate\n",
+    "from datasets import load_dataset\n",
+    "from transformers import AutoModelForSequenceClassification, AutoTokenizer, TorchAoConfig, get_linear_schedule_with_warmup, set_seed\n",
+    "from tqdm import tqdm"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eafdd532-b1eb-4aac-8077-3386a84c7cdb",
+   "metadata": {},
+   "source": [
+    "## Parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e3b13308",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "batch_size = 16\n",
+    "model_name_or_path = \"google/gemma-2-2b\"\n",
+    "task = \"mrpc\"\n",
+    "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "num_epochs = 5\n",
+    "lr = 2e-5\n",
+    "\n",
+    "lora_rank = 16\n",
+    "lora_alpha = 32\n",
+    "lora_dropout = 0.1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c7fb69bf-0182-4111-b715-e2e659b42b1d",
+   "metadata": {},
+   "source": [
+    "## Data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "d2f4d25e-30b9-431f-95c3-adb390dc6fcd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if any(k in model_name_or_path for k in (\"gpt\", \"opt\", \"bloom\")):\n",
+    "    padding_side = \"left\"\n",
+    "else:\n",
+    "    padding_side = \"right\"\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, padding_side=padding_side)\n",
+    "if getattr(tokenizer, \"pad_token_id\") is None:\n",
+    "    tokenizer.pad_token_id = tokenizer.eos_token_id\n",
+    "\n",
+    "datasets = load_dataset(\"glue\", task)\n",
+    "metric = evaluate.load(\"glue\", task)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "1ea852bc-a040-4244-8fd3-516307cecd14",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def tokenize_function(examples):\n",
+    "    # max_length=None => use the model max length (it's actually the default)\n",
+    "    outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=None)\n",
+    "    return outputs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "cf5ef289-f42f-4582-bd5e-9852ad8beff2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tokenized_datasets = datasets.map(\n",
+    "    tokenize_function,\n",
+    "    batched=True,\n",
+    "    remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n",
+    ")\n",
+    "\n",
+    "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n",
+    "# transformers library\n",
+    "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "739b3655-9db0-48bc-8542-308c6d5e0b8b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def collate_fn(examples):\n",
+    "    return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "0288f311-8475-4a0e-99af-e4b909d10e01",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Instantiate dataloaders.\n",
+    "train_dataloader = DataLoader(\n",
+    "    tokenized_datasets[\"train\"],\n",
+    "    shuffle=True,\n",
+    "    collate_fn=collate_fn,\n",
+    "    batch_size=batch_size,\n",
+    ")\n",
+    "eval_dataloader = DataLoader(\n",
+    "    tokenized_datasets[\"validation\"],\n",
+    "    shuffle=False,\n",
+    "    collate_fn=collate_fn,\n",
+    "    batch_size=batch_size,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fcaf6f9e-c9d1-445a-9f08-18ef462f67ce",
+   "metadata": {},
+   "source": [
+    "## Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "e5dfff56-ea80-4561-aeaf-43216bbb9af7",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2ac42f98e60d412496fe77ed7eb5c6df",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Loading checkpoint shards:   0%|          | 0/3 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Some weights of Gemma2ForSequenceClassification were not initialized from the model checkpoint at google/gemma-2-2b and are newly initialized: ['score.weight']\n",
+      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+     ]
+    }
+   ],
+   "source": [
+    "quant_config = TorchAoConfig(quant_type=Int8DynamicActivationInt8WeightConfig())\n",
+    "model = AutoModelForSequenceClassification.from_pretrained(\n",
+    "    model_name_or_path, return_dict=True, device_map=0, dtype=torch.bfloat16, quantization_config=quant_config\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "0526f571",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "peft_config = LoraConfig(\n",
+    "    task_type=\"SEQ_CLS\",\n",
+    "    r=lora_rank,\n",
+    "    lora_alpha=lora_alpha,\n",
+    "    lora_dropout=lora_dropout,\n",
+    "    target_modules=[\"q_proj\", \"v_proj\"],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "ceeae329-e931-4d52-8a28-9c87e5cdb4cf",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "trainable params: 3,199,488 || all params: 2,617,545,984 || trainable%: 0.1222\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = get_peft_model(model, peft_config)\n",
+    "model.print_trainable_parameters()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1b3d2544-3028-4e2a-9c56-d4d7d9d674de",
+   "metadata": {},
+   "source": [
+    "## Training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "0d2d0381",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimizer = AdamW(params=model.parameters(), lr=lr)\n",
+    "\n",
+    "# Instantiate scheduler\n",
+    "lr_scheduler = get_linear_schedule_with_warmup(\n",
+    "    optimizer=optimizer,\n",
+    "    num_warmup_steps=0.06 * (len(train_dataloader) * num_epochs),\n",
+    "    num_training_steps=(len(train_dataloader) * num_epochs),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "f04c88ca-84eb-4184-afe6-3869b6f96b76",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "PeftModelForSequenceClassification(\n",
+       "  (base_model): LoraModel(\n",
+       "    (model): Gemma2ForSequenceClassification(\n",
+       "      (model): Gemma2Model(\n",
+       "        (embed_tokens): Embedding(256000, 2304, padding_idx=0)\n",
+       "        (layers): ModuleList(\n",
+       "          (0-25): 26 x Gemma2DecoderLayer(\n",
+       "            (self_attn): Gemma2Attention(\n",
+       "              (q_proj): lora.TorchaoLoraLinear(\n",
+       "                (base_layer): Linear(in_features=2304, out_features=2048, weight=LinearActivationQuantizedTensor(activation=<function _int8_symm_per_token_reduced_range_quant at 0x7a846f516520>, weight=AffineQuantizedTensor(shape=torch.Size([2048, 2304]), block_size=(1, 2304), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None)))\n",
+       "                (lora_dropout): ModuleDict(\n",
+       "                  (default): Dropout(p=0.1, inplace=False)\n",
+       "                )\n",
+       "                (lora_A): ModuleDict(\n",
+       "                  (default): Linear(in_features=2304, out_features=16, bias=False)\n",
+       "                )\n",
+       "                (lora_B): ModuleDict(\n",
+       "                  (default): Linear(in_features=16, out_features=2048, bias=False)\n",
+       "                )\n",
+       "                (lora_embedding_A): ParameterDict()\n",
+       "                (lora_embedding_B): ParameterDict()\n",
+       "                (lora_magnitude_vector): ModuleDict()\n",
+       "              )\n",
+       "              (k_proj): Linear(in_features=2304, out_features=1024, weight=LinearActivationQuantizedTensor(activation=<function _int8_symm_per_token_reduced_range_quant at 0x7a846f516520>, weight=AffineQuantizedTensor(shape=torch.Size([1024, 2304]), block_size=(1, 2304), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None)))\n",
+       "              (v_proj): lora.TorchaoLoraLinear(\n",
+       "                (base_layer): Linear(in_features=2304, out_features=1024, weight=LinearActivationQuantizedTensor(activation=<function _int8_symm_per_token_reduced_range_quant at 0x7a846f516520>, weight=AffineQuantizedTensor(shape=torch.Size([1024, 2304]), block_size=(1, 2304), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None)))\n",
+       "                (lora_dropout): ModuleDict(\n",
+       "                  (default): Dropout(p=0.1, inplace=False)\n",
+       "                )\n",
+       "                (lora_A): ModuleDict(\n",
+       "                  (default): Linear(in_features=2304, out_features=16, bias=False)\n",
+       "                )\n",
+       "                (lora_B): ModuleDict(\n",
+       "                  (default): Linear(in_features=16, out_features=1024, bias=False)\n",
+       "                )\n",
+       "                (lora_embedding_A): ParameterDict()\n",
+       "                (lora_embedding_B): ParameterDict()\n",
+       "                (lora_magnitude_vector): ModuleDict()\n",
+       "              )\n",
+       "              (o_proj): Linear(in_features=2048, out_features=2304, weight=LinearActivationQuantizedTensor(activation=<function _int8_symm_per_token_reduced_range_quant at 0x7a846f516520>, weight=AffineQuantizedTensor(shape=torch.Size([2304, 2048]), block_size=(1, 2048), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None)))\n",
+       "              (rotary_emb): Gemma2RotaryEmbedding()\n",
+       "            )\n",
+       "            (mlp): Gemma2MLP(\n",
+       "              (gate_proj): Linear(in_features=2304, out_features=9216, weight=LinearActivationQuantizedTensor(activation=<function _int8_symm_per_token_reduced_range_quant at 0x7a846f516520>, weight=AffineQuantizedTensor(shape=torch.Size([9216, 2304]), block_size=(1, 2304), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None)))\n",
+       "              (up_proj): Linear(in_features=2304, out_features=9216, weight=LinearActivationQuantizedTensor(activation=<function _int8_symm_per_token_reduced_range_quant at 0x7a846f516520>, weight=AffineQuantizedTensor(shape=torch.Size([9216, 2304]), block_size=(1, 2304), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None)))\n",
+       "              (down_proj): Linear(in_features=9216, out_features=2304, weight=LinearActivationQuantizedTensor(activation=<function _int8_symm_per_token_reduced_range_quant at 0x7a846f516520>, weight=AffineQuantizedTensor(shape=torch.Size([2304, 9216]), block_size=(1, 9216), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None)))\n",
+       "              (act_fn): PytorchGELUTanh()\n",
+       "            )\n",
+       "            (input_layernorm): Gemma2RMSNorm((2304,), eps=1e-06)\n",
+       "            (post_attention_layernorm): Gemma2RMSNorm((2304,), eps=1e-06)\n",
+       "            (pre_feedforward_layernorm): Gemma2RMSNorm((2304,), eps=1e-06)\n",
+       "            (post_feedforward_layernorm): Gemma2RMSNorm((2304,), eps=1e-06)\n",
+       "          )\n",
+       "        )\n",
+       "        (norm): Gemma2RMSNorm((2304,), eps=1e-06)\n",
+       "      )\n",
+       "      (score): ModulesToSaveWrapper(\n",
+       "        (original_module): Linear(in_features=2304, out_features=2, bias=False)\n",
+       "        (modules_to_save): ModuleDict(\n",
+       "          (default): Linear(in_features=2304, out_features=2, bias=False)\n",
+       "        )\n",
+       "      )\n",
+       "    )\n",
+       "  )\n",
+       ")"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.config.use_cache = False\n",
+    "model.to(device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "fa0e73be",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|                                                                                                                                                                                                                                                       | 0/230 [00:00<?, ?it/s]You're using a GemmaTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 230/230 [00:43<00:00,  5.27it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 26/26 [00:04<00:00,  5.33it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 1 | train loss 1.7618 | {'accuracy': 0.46568627450980393, 'f1': 0.5458333333333333}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 230/230 [00:43<00:00,  5.29it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 26/26 [00:04<00:00,  5.47it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 2 | train loss 1.1905 | {'accuracy': 0.5245098039215687, 'f1': 0.6325757575757576}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 230/230 [00:43<00:00,  5.32it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 26/26 [00:04<00:00,  5.34it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 3 | train loss 1.1478 | {'accuracy': 0.5318627450980392, 'f1': 0.6456400742115028}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 230/230 [00:43<00:00,  5.29it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 26/26 [00:04<00:00,  5.36it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 4 | train loss 1.1384 | {'accuracy': 0.5367647058823529, 'f1': 0.6506469500924215}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 230/230 [00:44<00:00,  5.21it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 26/26 [00:04<00:00,  5.43it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 5 | train loss 1.1365 | {'accuracy': 0.5367647058823529, 'f1': 0.6506469500924215}\n",
+      "CPU times: user 4min 2s, sys: 399 ms, total: 4min 2s\n",
+      "Wall time: 4min 2s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "for epoch in range(1, num_epochs + 1):\n",
+    "    model.train()\n",
+    "    train_losses = []\n",
+    "    for step, batch in enumerate(tqdm(train_dataloader)):\n",
+    "        batch.to(device)\n",
+    "        outputs = model(**batch)\n",
+    "        loss = outputs.loss\n",
+    "        if not torch.isfinite(loss):\n",
+    "            raise ValueError(\"non-finite loss encountered\")\n",
+    "\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        lr_scheduler.step()\n",
+    "        optimizer.zero_grad()\n",
+    "        train_losses.append(loss.item())\n",
+    "\n",
+    "    model.eval()\n",
+    "    for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+    "        batch.to(device)\n",
+    "        with torch.no_grad():\n",
+    "            outputs = model(**batch)\n",
+    "        predictions = outputs.logits.argmax(dim=-1)\n",
+    "        predictions, references = predictions, batch[\"labels\"]\n",
+    "        metric.add_batch(\n",
+    "            predictions=predictions,\n",
+    "            references=references,\n",
+    "        )\n",
+    "\n",
+    "    eval_metric = metric.compute()\n",
+    "    train_loss = sum(train_losses) / len(train_losses)\n",
+    "    print(f\"epoch {epoch} | train loss {train_loss:.4f} |\", eval_metric)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "6a1f937b-a0a5-40ec-8e41-5a5a18c6bff6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# memory: 4122MiB"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/sequence_classification/LoRA-torchao-8bit.ipynb b/examples/sequence_classification/LoRA-torchao-8bit.ipynb
new file mode 100644
index 0000000..22a4a65
--- /dev/null
+++ b/examples/sequence_classification/LoRA-torchao-8bit.ipynb
@@ -0,0 +1,527 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "412e41ee-72d3-4e71-bd3a-703b37429c57",
+   "metadata": {},
+   "source": [
+    "# PyTorch AO (torchao) with int8_weight_only"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "10e1acc3-50b8-4d40-bdf3-0133c113cc4b",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "a9935ae2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import argparse\n",
+    "import os\n",
+    "\n",
+    "import torch\n",
+    "from torch.optim import AdamW\n",
+    "from torch.utils.data import DataLoader\n",
+    "from torchao.quantization import Int8WeightOnlyConfig\n",
+    "from peft import (\n",
+    "    get_peft_config,\n",
+    "    get_peft_model,\n",
+    "    get_peft_model_state_dict,\n",
+    "    set_peft_model_state_dict,\n",
+    "    LoraConfig,\n",
+    "    PeftType,\n",
+    "    PrefixTuningConfig,\n",
+    "    PromptEncoderConfig,\n",
+    ")\n",
+    "\n",
+    "import evaluate\n",
+    "from datasets import load_dataset\n",
+    "from transformers import AutoModelForSequenceClassification, AutoTokenizer, TorchAoConfig, get_linear_schedule_with_warmup, set_seed\n",
+    "from tqdm import tqdm"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eafdd532-b1eb-4aac-8077-3386a84c7cdb",
+   "metadata": {},
+   "source": [
+    "## Parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e3b13308",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "batch_size = 16\n",
+    "model_name_or_path = \"google/gemma-2-2b\"\n",
+    "task = \"mrpc\"\n",
+    "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "num_epochs = 5\n",
+    "lr = 2e-5\n",
+    "\n",
+    "lora_rank = 16\n",
+    "lora_alpha = 32\n",
+    "lora_dropout = 0.1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c7fb69bf-0182-4111-b715-e2e659b42b1d",
+   "metadata": {},
+   "source": [
+    "## Data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "d2f4d25e-30b9-431f-95c3-adb390dc6fcd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if any(k in model_name_or_path for k in (\"gpt\", \"opt\", \"bloom\")):\n",
+    "    padding_side = \"left\"\n",
+    "else:\n",
+    "    padding_side = \"right\"\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, padding_side=padding_side)\n",
+    "if getattr(tokenizer, \"pad_token_id\") is None:\n",
+    "    tokenizer.pad_token_id = tokenizer.eos_token_id\n",
+    "\n",
+    "datasets = load_dataset(\"glue\", task)\n",
+    "metric = evaluate.load(\"glue\", task)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "1ea852bc-a040-4244-8fd3-516307cecd14",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def tokenize_function(examples):\n",
+    "    # max_length=None => use the model max length (it's actually the default)\n",
+    "    outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=None)\n",
+    "    return outputs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "cf5ef289-f42f-4582-bd5e-9852ad8beff2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tokenized_datasets = datasets.map(\n",
+    "    tokenize_function,\n",
+    "    batched=True,\n",
+    "    remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n",
+    ")\n",
+    "\n",
+    "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n",
+    "# transformers library\n",
+    "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "739b3655-9db0-48bc-8542-308c6d5e0b8b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def collate_fn(examples):\n",
+    "    return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "0288f311-8475-4a0e-99af-e4b909d10e01",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Instantiate dataloaders.\n",
+    "train_dataloader = DataLoader(\n",
+    "    tokenized_datasets[\"train\"],\n",
+    "    shuffle=True,\n",
+    "    collate_fn=collate_fn,\n",
+    "    batch_size=batch_size,\n",
+    ")\n",
+    "eval_dataloader = DataLoader(\n",
+    "    tokenized_datasets[\"validation\"],\n",
+    "    shuffle=False,\n",
+    "    collate_fn=collate_fn,\n",
+    "    batch_size=batch_size,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fcaf6f9e-c9d1-445a-9f08-18ef462f67ce",
+   "metadata": {},
+   "source": [
+    "## Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "e5dfff56-ea80-4561-aeaf-43216bbb9af7",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "512d9dc10a4d4ecc88b9440575b0973a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Loading checkpoint shards:   0%|          | 0/3 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Some weights of Gemma2ForSequenceClassification were not initialized from the model checkpoint at google/gemma-2-2b and are newly initialized: ['score.weight']\n",
+      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+     ]
+    }
+   ],
+   "source": [
+    "quant_config = TorchAoConfig(quant_type=Int8WeightOnlyConfig())\n",
+    "model = AutoModelForSequenceClassification.from_pretrained(\n",
+    "    model_name_or_path, return_dict=True, device_map=0, dtype=torch.bfloat16, quantization_config=quant_config\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "0526f571",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "peft_config = LoraConfig(\n",
+    "    task_type=\"SEQ_CLS\",\n",
+    "    r=lora_rank,\n",
+    "    lora_alpha=lora_alpha,\n",
+    "    lora_dropout=lora_dropout,\n",
+    "    target_modules=[\"q_proj\", \"v_proj\"],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "ceeae329-e931-4d52-8a28-9c87e5cdb4cf",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "trainable params: 3,199,488 || all params: 2,617,545,984 || trainable%: 0.1222\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = get_peft_model(model, peft_config)\n",
+    "model.print_trainable_parameters()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1b3d2544-3028-4e2a-9c56-d4d7d9d674de",
+   "metadata": {},
+   "source": [
+    "## Training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "0d2d0381",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimizer = AdamW(params=model.parameters(), lr=lr)\n",
+    "\n",
+    "# Instantiate scheduler\n",
+    "lr_scheduler = get_linear_schedule_with_warmup(\n",
+    "    optimizer=optimizer,\n",
+    "    num_warmup_steps=0.06 * (len(train_dataloader) * num_epochs),\n",
+    "    num_training_steps=(len(train_dataloader) * num_epochs),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "f04c88ca-84eb-4184-afe6-3869b6f96b76",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "PeftModelForSequenceClassification(\n",
+       "  (base_model): LoraModel(\n",
+       "    (model): Gemma2ForSequenceClassification(\n",
+       "      (model): Gemma2Model(\n",
+       "        (embed_tokens): Embedding(256000, 2304, padding_idx=0)\n",
+       "        (layers): ModuleList(\n",
+       "          (0-25): 26 x Gemma2DecoderLayer(\n",
+       "            (self_attn): Gemma2Attention(\n",
+       "              (q_proj): lora.TorchaoLoraLinear(\n",
+       "                (base_layer): Linear(in_features=2304, out_features=2048, weight=AffineQuantizedTensor(shape=torch.Size([2048, 2304]), block_size=(1, 2304), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None))\n",
+       "                (lora_dropout): ModuleDict(\n",
+       "                  (default): Dropout(p=0.1, inplace=False)\n",
+       "                )\n",
+       "                (lora_A): ModuleDict(\n",
+       "                  (default): Linear(in_features=2304, out_features=16, bias=False)\n",
+       "                )\n",
+       "                (lora_B): ModuleDict(\n",
+       "                  (default): Linear(in_features=16, out_features=2048, bias=False)\n",
+       "                )\n",
+       "                (lora_embedding_A): ParameterDict()\n",
+       "                (lora_embedding_B): ParameterDict()\n",
+       "                (lora_magnitude_vector): ModuleDict()\n",
+       "              )\n",
+       "              (k_proj): Linear(in_features=2304, out_features=1024, weight=AffineQuantizedTensor(shape=torch.Size([1024, 2304]), block_size=(1, 2304), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None))\n",
+       "              (v_proj): lora.TorchaoLoraLinear(\n",
+       "                (base_layer): Linear(in_features=2304, out_features=1024, weight=AffineQuantizedTensor(shape=torch.Size([1024, 2304]), block_size=(1, 2304), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None))\n",
+       "                (lora_dropout): ModuleDict(\n",
+       "                  (default): Dropout(p=0.1, inplace=False)\n",
+       "                )\n",
+       "                (lora_A): ModuleDict(\n",
+       "                  (default): Linear(in_features=2304, out_features=16, bias=False)\n",
+       "                )\n",
+       "                (lora_B): ModuleDict(\n",
+       "                  (default): Linear(in_features=16, out_features=1024, bias=False)\n",
+       "                )\n",
+       "                (lora_embedding_A): ParameterDict()\n",
+       "                (lora_embedding_B): ParameterDict()\n",
+       "                (lora_magnitude_vector): ModuleDict()\n",
+       "              )\n",
+       "              (o_proj): Linear(in_features=2048, out_features=2304, weight=AffineQuantizedTensor(shape=torch.Size([2304, 2048]), block_size=(1, 2048), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None))\n",
+       "              (rotary_emb): Gemma2RotaryEmbedding()\n",
+       "            )\n",
+       "            (mlp): Gemma2MLP(\n",
+       "              (gate_proj): Linear(in_features=2304, out_features=9216, weight=AffineQuantizedTensor(shape=torch.Size([9216, 2304]), block_size=(1, 2304), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None))\n",
+       "              (up_proj): Linear(in_features=2304, out_features=9216, weight=AffineQuantizedTensor(shape=torch.Size([9216, 2304]), block_size=(1, 2304), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None))\n",
+       "              (down_proj): Linear(in_features=9216, out_features=2304, weight=AffineQuantizedTensor(shape=torch.Size([2304, 9216]), block_size=(1, 9216), device=cuda:0, layout_type=PlainLayoutType(), layout_tensor_dtype=torch.int8, quant_min=None, quant_max=None))\n",
+       "              (act_fn): PytorchGELUTanh()\n",
+       "            )\n",
+       "            (input_layernorm): Gemma2RMSNorm((2304,), eps=1e-06)\n",
+       "            (post_attention_layernorm): Gemma2RMSNorm((2304,), eps=1e-06)\n",
+       "            (pre_feedforward_layernorm): Gemma2RMSNorm((2304,), eps=1e-06)\n",
+       "            (post_feedforward_layernorm): Gemma2RMSNorm((2304,), eps=1e-06)\n",
+       "          )\n",
+       "        )\n",
+       "        (norm): Gemma2RMSNorm((2304,), eps=1e-06)\n",
+       "      )\n",
+       "      (score): ModulesToSaveWrapper(\n",
+       "        (original_module): Linear(in_features=2304, out_features=2, bias=False)\n",
+       "        (modules_to_save): ModuleDict(\n",
+       "          (default): Linear(in_features=2304, out_features=2, bias=False)\n",
+       "        )\n",
+       "      )\n",
+       "    )\n",
+       "  )\n",
+       ")"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.config.use_cache = False\n",
+    "model.to(device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "fa0e73be",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|                                                                                                                                                                                                                                                       | 0/230 [00:00<?, ?it/s]You're using a GemmaTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 230/230 [00:31<00:00,  7.19it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 26/26 [00:01<00:00, 16.19it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 1 | train loss 1.0672 | {'accuracy': 0.6715686274509803, 'f1': 0.7751677852348994}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 230/230 [00:31<00:00,  7.26it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 26/26 [00:01<00:00, 16.19it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 2 | train loss 0.6261 | {'accuracy': 0.7377450980392157, 'f1': 0.8201680672268907}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 230/230 [00:31<00:00,  7.25it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 26/26 [00:01<00:00, 16.15it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 3 | train loss 0.4743 | {'accuracy': 0.7867647058823529, 'f1': 0.8502581755593803}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 230/230 [00:31<00:00,  7.30it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 26/26 [00:01<00:00, 16.17it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 4 | train loss 0.4006 | {'accuracy': 0.803921568627451, 'f1': 0.8586572438162544}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 230/230 [00:31<00:00,  7.26it/s]\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 26/26 [00:01<00:00, 16.10it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 5 | train loss 0.3585 | {'accuracy': 0.8235294117647058, 'f1': 0.8791946308724832}\n",
+      "CPU times: user 2min 8s, sys: 38 s, total: 2min 46s\n",
+      "Wall time: 2min 46s\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "for epoch in range(1, num_epochs + 1):\n",
+    "    model.train()\n",
+    "    train_losses = []\n",
+    "    for step, batch in enumerate(tqdm(train_dataloader)):\n",
+    "        batch.to(device)\n",
+    "        outputs = model(**batch)\n",
+    "        loss = outputs.loss\n",
+    "        if not torch.isfinite(loss):\n",
+    "            raise ValueError(\"non-finite loss encountered\")\n",
+    "\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        lr_scheduler.step()\n",
+    "        optimizer.zero_grad()\n",
+    "        train_losses.append(loss.item())\n",
+    "\n",
+    "    model.eval()\n",
+    "    for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+    "        batch.to(device)\n",
+    "        with torch.no_grad():\n",
+    "            outputs = model(**batch)\n",
+    "        predictions = outputs.logits.argmax(dim=-1)\n",
+    "        predictions, references = predictions, batch[\"labels\"]\n",
+    "        metric.add_batch(\n",
+    "            predictions=predictions,\n",
+    "            references=references,\n",
+    "        )\n",
+    "\n",
+    "    eval_metric = metric.compute()\n",
+    "    train_loss = sum(train_losses) / len(train_losses)\n",
+    "    print(f\"epoch {epoch} | train loss {train_loss:.4f} |\", eval_metric)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "6a1f937b-a0a5-40ec-8e41-5a5a18c6bff6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# memory: 18098MiB"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/sequence_classification/LoRA.ipynb b/examples/sequence_classification/LoRA.ipynb
new file mode 100644
index 0000000..1bea9ba
--- /dev/null
+++ b/examples/sequence_classification/LoRA.ipynb
@@ -0,0 +1,713 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "a9935ae2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "===================================BUG REPORT===================================\n",
+      "Welcome to bitsandbytes. For bug reports, please submit your error trace to: https://github.com/TimDettmers/bitsandbytes/issues\n",
+      "For effortless bug reporting copy-paste your error into this form: https://docs.google.com/forms/d/e/1FAIpQLScPB8emS3Thkp66nvqwmjTEgxp8Y9ufuWTzFyr9kJ5AoI47dQ/viewform?usp=sf_link\n",
+      "================================================================================\n",
+      "CUDA SETUP: CUDA runtime path found: /home/sourab/miniconda3/envs/ml/lib/libcudart.so\n",
+      "CUDA SETUP: Highest compute capability among GPUs detected: 7.5\n",
+      "CUDA SETUP: Detected CUDA version 117\n",
+      "CUDA SETUP: Loading binary /home/sourab/miniconda3/envs/ml/lib/python3.10/site-packages/bitsandbytes/libbitsandbytes_cuda117.so...\n"
+     ]
+    }
+   ],
+   "source": [
+    "import argparse\n",
+    "import os\n",
+    "\n",
+    "import torch\n",
+    "from torch.optim import AdamW\n",
+    "from torch.utils.data import DataLoader\n",
+    "from peft import (\n",
+    "    get_peft_config,\n",
+    "    get_peft_model,\n",
+    "    get_peft_model_state_dict,\n",
+    "    set_peft_model_state_dict,\n",
+    "    LoraConfig,\n",
+    "    PeftType,\n",
+    "    PrefixTuningConfig,\n",
+    "    PromptEncoderConfig,\n",
+    ")\n",
+    "\n",
+    "import evaluate\n",
+    "from datasets import load_dataset\n",
+    "from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed\n",
+    "from tqdm import tqdm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e3b13308",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "batch_size = 32\n",
+    "model_name_or_path = \"roberta-large\"\n",
+    "task = \"mrpc\"\n",
+    "peft_type = PeftType.LORA\n",
+    "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "num_epochs = 20"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "0526f571",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "peft_config = LoraConfig(task_type=\"SEQ_CLS\", inference_mode=False, r=8, lora_alpha=16, lora_dropout=0.1)\n",
+    "lr = 3e-4"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "c2697d07",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "0f74797387a941cbb0709487b8808eba",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading readme:   0%|          | 0.00/27.9k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Found cached dataset glue (/home/sourab/.cache/huggingface/datasets/glue/mrpc/1.0.0/dacbe3125aa31d7f70367a07a8a9e72a5a0bfeb5fc42e75c9db75b96da6053ad)\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "1a9ecc2f624343c3af8d1824afb66ac5",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/3 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "33b071c0e5794cb48b38bbf68f22b49b",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/4 [00:00<?, ?ba/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a977694036394d5c99adfb13c023e258",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/1 [00:00<?, ?ba/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "facc8d9092dc4abe9e553fc8e5b795b8",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/2 [00:00<?, ?ba/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "if any(k in model_name_or_path for k in (\"gpt\", \"opt\", \"bloom\")):\n",
+    "    padding_side = \"left\"\n",
+    "else:\n",
+    "    padding_side = \"right\"\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, padding_side=padding_side)\n",
+    "if getattr(tokenizer, \"pad_token_id\") is None:\n",
+    "    tokenizer.pad_token_id = tokenizer.eos_token_id\n",
+    "\n",
+    "datasets = load_dataset(\"glue\", task)\n",
+    "metric = evaluate.load(\"glue\", task)\n",
+    "\n",
+    "\n",
+    "def tokenize_function(examples):\n",
+    "    # max_length=None => use the model max length (it's actually the default)\n",
+    "    outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=None)\n",
+    "    return outputs\n",
+    "\n",
+    "\n",
+    "tokenized_datasets = datasets.map(\n",
+    "    tokenize_function,\n",
+    "    batched=True,\n",
+    "    remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n",
+    ")\n",
+    "\n",
+    "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n",
+    "# transformers library\n",
+    "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")\n",
+    "\n",
+    "\n",
+    "def collate_fn(examples):\n",
+    "    return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")\n",
+    "\n",
+    "\n",
+    "# Instantiate dataloaders.\n",
+    "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size)\n",
+    "eval_dataloader = DataLoader(\n",
+    "    tokenized_datasets[\"validation\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2ed5ac74",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path, return_dict=True)\n",
+    "model = get_peft_model(model, peft_config)\n",
+    "model.print_trainable_parameters()\n",
+    "model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "0d2d0381",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimizer = AdamW(params=model.parameters(), lr=lr)\n",
+    "\n",
+    "# Instantiate scheduler\n",
+    "lr_scheduler = get_linear_schedule_with_warmup(\n",
+    "    optimizer=optimizer,\n",
+    "    num_warmup_steps=0.06 * (len(train_dataloader) * num_epochs),\n",
+    "    num_training_steps=(len(train_dataloader) * num_epochs),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "fa0e73be",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|                                                                                                  | 0/115 [00:00<?, ?it/s]You're using a RobertaTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:28<00:00,  4.08it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  8.68it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 0: {'accuracy': 0.7009803921568627, 'f1': 0.8189910979228486}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:27<00:00,  4.18it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  8.64it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 1: {'accuracy': 0.7622549019607843, 'f1': 0.8482003129890453}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:27<00:00,  4.20it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  8.63it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 2: {'accuracy': 0.8651960784313726, 'f1': 0.9005424954792043}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:27<00:00,  4.21it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  8.62it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 3: {'accuracy': 0.8921568627450981, 'f1': 0.9228070175438596}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:27<00:00,  4.20it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  8.62it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 4: {'accuracy': 0.8970588235294118, 'f1': 0.9257950530035336}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:27<00:00,  4.16it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  8.01it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 5: {'accuracy': 0.8823529411764706, 'f1': 0.9169550173010381}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:30<00:00,  3.81it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  8.62it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 6: {'accuracy': 0.8799019607843137, 'f1': 0.9170896785109983}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:27<00:00,  4.16it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  8.61it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 7: {'accuracy': 0.8799019607843137, 'f1': 0.9150779896013865}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:27<00:00,  4.18it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  8.61it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 8: {'accuracy': 0.8921568627450981, 'f1': 0.9233449477351917}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:27<00:00,  4.18it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  8.59it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 9: {'accuracy': 0.8872549019607843, 'f1': 0.9217687074829931}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:27<00:00,  4.16it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  8.61it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 10: {'accuracy': 0.8774509803921569, 'f1': 0.9137931034482758}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:29<00:00,  3.90it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  6.81it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 11: {'accuracy': 0.9068627450980392, 'f1': 0.9321428571428573}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:28<00:00,  4.05it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  8.59it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 12: {'accuracy': 0.8946078431372549, 'f1': 0.925476603119584}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:27<00:00,  4.17it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  8.58it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 13: {'accuracy': 0.8897058823529411, 'f1': 0.922279792746114}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:27<00:00,  4.18it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  8.61it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 14: {'accuracy': 0.8970588235294118, 'f1': 0.9265734265734265}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:27<00:00,  4.18it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  8.60it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 15: {'accuracy': 0.8970588235294118, 'f1': 0.9263157894736843}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:27<00:00,  4.17it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  8.59it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 16: {'accuracy': 0.8921568627450981, 'f1': 0.9233449477351917}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:27<00:00,  4.18it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  8.58it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 17: {'accuracy': 0.8897058823529411, 'f1': 0.9220103986135182}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:30<00:00,  3.78it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  8.58it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 18: {'accuracy': 0.8921568627450981, 'f1': 0.9233449477351917}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:27<00:00,  4.16it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  8.60it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 19: {'accuracy': 0.8946078431372549, 'f1': 0.924693520140105}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.to(device)\n",
+    "for epoch in range(num_epochs):\n",
+    "    model.train()\n",
+    "    for step, batch in enumerate(tqdm(train_dataloader)):\n",
+    "        batch.to(device)\n",
+    "        outputs = model(**batch)\n",
+    "        loss = outputs.loss\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        lr_scheduler.step()\n",
+    "        optimizer.zero_grad()\n",
+    "\n",
+    "    model.eval()\n",
+    "    for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+    "        batch.to(device)\n",
+    "        with torch.no_grad():\n",
+    "            outputs = model(**batch)\n",
+    "        predictions = outputs.logits.argmax(dim=-1)\n",
+    "        predictions, references = predictions, batch[\"labels\"]\n",
+    "        metric.add_batch(\n",
+    "            predictions=predictions,\n",
+    "            references=references,\n",
+    "        )\n",
+    "\n",
+    "    eval_metric = metric.compute()\n",
+    "    print(f\"epoch {epoch}:\", eval_metric)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f2b2caca",
+   "metadata": {},
+   "source": [
+    "## Share adapters on the 🤗 Hub"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "990b3c93",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "CommitInfo(commit_url='https://huggingface.co/smangrul/roberta-large-peft-lora/commit/c2c661898b8b6a0c68ecd068931e598d0a79686b', commit_message='Upload model', commit_description='', oid='c2c661898b8b6a0c68ecd068931e598d0a79686b', pr_url=None, pr_revision=None, pr_num=None)"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.push_to_hub(\"smangrul/roberta-large-peft-lora\", use_auth_token=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9d140b26",
+   "metadata": {},
+   "source": [
+    "## Load adapters from the Hub\n",
+    "\n",
+    "You can also directly load adapters from the Hub using the commands below:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "4d55c87d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Some weights of the model checkpoint at roberta-large were not used when initializing RobertaForSequenceClassification: ['lm_head.bias', 'roberta.pooler.dense.weight', 'roberta.pooler.dense.bias', 'lm_head.layer_norm.weight', 'lm_head.decoder.weight', 'lm_head.dense.bias', 'lm_head.dense.weight', 'lm_head.layer_norm.bias']\n",
+      "- This IS expected if you are initializing RobertaForSequenceClassification from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
+      "- This IS NOT expected if you are initializing RobertaForSequenceClassification from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
+      "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-large and are newly initialized: ['classifier.dense.bias', 'classifier.out_proj.bias', 'classifier.dense.weight', 'classifier.out_proj.weight']\n",
+      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n",
+      "  0%|                                                                                                   | 0/13 [00:00<?, ?it/s]You're using a RobertaTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  8.45it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'accuracy': 0.8946078431372549, 'f1': 0.924693520140105}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "from peft import PeftModel, PeftConfig\n",
+    "from transformers import AutoModelForCausalLM, AutoTokenizer\n",
+    "\n",
+    "peft_model_id = \"smangrul/roberta-large-peft-lora\"\n",
+    "config = PeftConfig.from_pretrained(peft_model_id)\n",
+    "inference_model = AutoModelForSequenceClassification.from_pretrained(config.base_model_name_or_path)\n",
+    "tokenizer = AutoTokenizer.from_pretrained(config.base_model_name_or_path)\n",
+    "\n",
+    "# Load the Lora model\n",
+    "inference_model = PeftModel.from_pretrained(inference_model, peft_model_id)\n",
+    "\n",
+    "inference_model.to(device)\n",
+    "inference_model.eval()\n",
+    "for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+    "    batch.to(device)\n",
+    "    with torch.no_grad():\n",
+    "        outputs = inference_model(**batch)\n",
+    "    predictions = outputs.logits.argmax(dim=-1)\n",
+    "    predictions, references = predictions, batch[\"labels\"]\n",
+    "    metric.add_batch(\n",
+    "        predictions=predictions,\n",
+    "        references=references,\n",
+    "    )\n",
+    "\n",
+    "eval_metric = metric.compute()\n",
+    "print(eval_metric)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "27c43da1",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.5 (v3.10.5:f377153967, Jun  6 2022, 12:36:10) [Clang 13.0.0 (clang-1300.0.29.30)]"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/sequence_classification/P_Tuning.ipynb b/examples/sequence_classification/P_Tuning.ipynb
new file mode 100644
index 0000000..f6c4e3b
--- /dev/null
+++ b/examples/sequence_classification/P_Tuning.ipynb
@@ -0,0 +1,685 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "a825ba6b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "===================================BUG REPORT===================================\n",
+      "Welcome to bitsandbytes. For bug reports, please submit your error trace to: https://github.com/TimDettmers/bitsandbytes/issues\n",
+      "For effortless bug reporting copy-paste your error into this form: https://docs.google.com/forms/d/e/1FAIpQLScPB8emS3Thkp66nvqwmjTEgxp8Y9ufuWTzFyr9kJ5AoI47dQ/viewform?usp=sf_link\n",
+      "================================================================================\n",
+      "CUDA SETUP: CUDA runtime path found: /home/sourab/miniconda3/envs/ml/lib/libcudart.so\n",
+      "CUDA SETUP: Highest compute capability among GPUs detected: 7.5\n",
+      "CUDA SETUP: Detected CUDA version 117\n",
+      "CUDA SETUP: Loading binary /home/sourab/miniconda3/envs/ml/lib/python3.10/site-packages/bitsandbytes/libbitsandbytes_cuda117.so...\n"
+     ]
+    }
+   ],
+   "source": [
+    "import argparse\n",
+    "import os\n",
+    "\n",
+    "import torch\n",
+    "from torch.optim import AdamW\n",
+    "from torch.utils.data import DataLoader\n",
+    "from peft import (\n",
+    "    get_peft_config,\n",
+    "    get_peft_model,\n",
+    "    get_peft_model_state_dict,\n",
+    "    set_peft_model_state_dict,\n",
+    "    PeftType,\n",
+    "    PrefixTuningConfig,\n",
+    "    PromptEncoderConfig,\n",
+    ")\n",
+    "\n",
+    "import evaluate\n",
+    "from datasets import load_dataset\n",
+    "from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed\n",
+    "from tqdm import tqdm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2bd7cbb2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "batch_size = 32\n",
+    "model_name_or_path = \"roberta-large\"\n",
+    "task = \"mrpc\"\n",
+    "peft_type = PeftType.P_TUNING\n",
+    "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "num_epochs = 20"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "33d9b62e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "peft_config = PromptEncoderConfig(task_type=\"SEQ_CLS\", num_virtual_tokens=20, encoder_hidden_size=128)\n",
+    "lr = 1e-3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "152b6177",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Found cached dataset glue (/home/sourab/.cache/huggingface/datasets/glue/mrpc/1.0.0/dacbe3125aa31d7f70367a07a8a9e72a5a0bfeb5fc42e75c9db75b96da6053ad)\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a451b90675e0451489cc6426465afa32",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/3 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading cached processed dataset at /home/sourab/.cache/huggingface/datasets/glue/mrpc/1.0.0/dacbe3125aa31d7f70367a07a8a9e72a5a0bfeb5fc42e75c9db75b96da6053ad/cache-9fa7887f9eaa03ae.arrow\n",
+      "Loading cached processed dataset at /home/sourab/.cache/huggingface/datasets/glue/mrpc/1.0.0/dacbe3125aa31d7f70367a07a8a9e72a5a0bfeb5fc42e75c9db75b96da6053ad/cache-dc593149bbeafe80.arrow\n",
+      "Loading cached processed dataset at /home/sourab/.cache/huggingface/datasets/glue/mrpc/1.0.0/dacbe3125aa31d7f70367a07a8a9e72a5a0bfeb5fc42e75c9db75b96da6053ad/cache-140ebe5b70e09817.arrow\n"
+     ]
+    }
+   ],
+   "source": [
+    "if any(k in model_name_or_path for k in (\"gpt\", \"opt\", \"bloom\")):\n",
+    "    padding_side = \"left\"\n",
+    "else:\n",
+    "    padding_side = \"right\"\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, padding_side=padding_side)\n",
+    "if getattr(tokenizer, \"pad_token_id\") is None:\n",
+    "    tokenizer.pad_token_id = tokenizer.eos_token_id\n",
+    "\n",
+    "datasets = load_dataset(\"glue\", task)\n",
+    "metric = evaluate.load(\"glue\", task)\n",
+    "\n",
+    "\n",
+    "def tokenize_function(examples):\n",
+    "    # max_length=None => use the model max length (it's actually the default)\n",
+    "    outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=None)\n",
+    "    return outputs\n",
+    "\n",
+    "\n",
+    "tokenized_datasets = datasets.map(\n",
+    "    tokenize_function,\n",
+    "    batched=True,\n",
+    "    remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n",
+    ")\n",
+    "\n",
+    "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n",
+    "# transformers library\n",
+    "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")\n",
+    "\n",
+    "\n",
+    "def collate_fn(examples):\n",
+    "    return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")\n",
+    "\n",
+    "\n",
+    "# Instantiate dataloaders.\n",
+    "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size)\n",
+    "eval_dataloader = DataLoader(\n",
+    "    tokenized_datasets[\"validation\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f6bc8144",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path, return_dict=True)\n",
+    "model = get_peft_model(model, peft_config)\n",
+    "model.print_trainable_parameters()\n",
+    "model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "af41c571",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimizer = AdamW(params=model.parameters(), lr=lr)\n",
+    "\n",
+    "# Instantiate scheduler\n",
+    "lr_scheduler = get_linear_schedule_with_warmup(\n",
+    "    optimizer=optimizer,\n",
+    "    num_warmup_steps=0,  # 0.06*(len(train_dataloader) * num_epochs),\n",
+    "    num_training_steps=(len(train_dataloader) * num_epochs),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "90993c93",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|                                                                                                  | 0/115 [00:00<?, ?it/s]You're using a RobertaTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:32<00:00,  3.54it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  6.91it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 0: {'accuracy': 0.6985294117647058, 'f1': 0.8172362555720655}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:31<00:00,  3.61it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  6.87it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 1: {'accuracy': 0.6936274509803921, 'f1': 0.806201550387597}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:31<00:00,  3.61it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  6.88it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 2: {'accuracy': 0.7132352941176471, 'f1': 0.8224582701062216}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:31<00:00,  3.61it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  6.87it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 3: {'accuracy': 0.7083333333333334, 'f1': 0.8199697428139183}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:31<00:00,  3.61it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  6.90it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 4: {'accuracy': 0.7205882352941176, 'f1': 0.8246153846153846}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:31<00:00,  3.62it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  6.90it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 5: {'accuracy': 0.7009803921568627, 'f1': 0.8200589970501474}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:32<00:00,  3.59it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  6.89it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 6: {'accuracy': 0.7254901960784313, 'f1': 0.8292682926829268}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:31<00:00,  3.60it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  6.86it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 7: {'accuracy': 0.7230392156862745, 'f1': 0.8269525267993874}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:34<00:00,  3.34it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  6.88it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 8: {'accuracy': 0.7254901960784313, 'f1': 0.8297872340425533}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:31<00:00,  3.60it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  6.77it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 9: {'accuracy': 0.7230392156862745, 'f1': 0.828006088280061}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:32<00:00,  3.58it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  6.88it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 10: {'accuracy': 0.7181372549019608, 'f1': 0.8183254344391785}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:31<00:00,  3.60it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  6.87it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 11: {'accuracy': 0.7132352941176471, 'f1': 0.803361344537815}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:31<00:00,  3.59it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  6.85it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 12: {'accuracy': 0.7107843137254902, 'f1': 0.8206686930091186}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:32<00:00,  3.59it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  6.85it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 13: {'accuracy': 0.7181372549019608, 'f1': 0.8254931714719272}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:32<00:00,  3.59it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  6.87it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 14: {'accuracy': 0.7156862745098039, 'f1': 0.8253012048192772}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:32<00:00,  3.59it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  6.84it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 15: {'accuracy': 0.7230392156862745, 'f1': 0.8242612752721618}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:32<00:00,  3.49it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:02<00:00,  5.84it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 16: {'accuracy': 0.7181372549019608, 'f1': 0.8200312989045383}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:32<00:00,  3.49it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  6.84it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 17: {'accuracy': 0.7107843137254902, 'f1': 0.8217522658610272}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:31<00:00,  3.60it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  6.88it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 18: {'accuracy': 0.7254901960784313, 'f1': 0.8292682926829268}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:31<00:00,  3.61it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  6.89it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 19: {'accuracy': 0.7107843137254902, 'f1': 0.8206686930091186}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.to(device)\n",
+    "for epoch in range(num_epochs):\n",
+    "    model.train()\n",
+    "    for step, batch in enumerate(tqdm(train_dataloader)):\n",
+    "        batch.to(device)\n",
+    "        outputs = model(**batch)\n",
+    "        loss = outputs.loss\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        lr_scheduler.step()\n",
+    "        optimizer.zero_grad()\n",
+    "\n",
+    "    model.eval()\n",
+    "    for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+    "        batch.to(device)\n",
+    "        with torch.no_grad():\n",
+    "            outputs = model(**batch)\n",
+    "        predictions = outputs.logits.argmax(dim=-1)\n",
+    "        predictions, references = predictions, batch[\"labels\"]\n",
+    "        metric.add_batch(\n",
+    "            predictions=predictions,\n",
+    "            references=references,\n",
+    "        )\n",
+    "\n",
+    "    eval_metric = metric.compute()\n",
+    "    print(f\"epoch {epoch}:\", eval_metric)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a43bd9fb",
+   "metadata": {},
+   "source": [
+    "## Share adapters on the 🤗 Hub"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "871b75aa",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "CommitInfo(commit_url='https://huggingface.co/smangrul/roberta-large-peft-p-tuning/commit/fa7abe613f498c76df5e16c85d9c19c3019587a7', commit_message='Upload model', commit_description='', oid='fa7abe613f498c76df5e16c85d9c19c3019587a7', pr_url=None, pr_revision=None, pr_num=None)"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.push_to_hub(\"smangrul/roberta-large-peft-p-tuning\", use_auth_token=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1c6a9036",
+   "metadata": {},
+   "source": [
+    "## Load adapters from the Hub\n",
+    "\n",
+    "You can also directly load adapters from the Hub using the commands below:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "91b0b8f5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Some weights of the model checkpoint at roberta-large were not used when initializing RobertaForSequenceClassification: ['lm_head.decoder.weight', 'lm_head.layer_norm.bias', 'lm_head.dense.bias', 'roberta.pooler.dense.weight', 'lm_head.layer_norm.weight', 'roberta.pooler.dense.bias', 'lm_head.dense.weight', 'lm_head.bias']\n",
+      "- This IS expected if you are initializing RobertaForSequenceClassification from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
+      "- This IS NOT expected if you are initializing RobertaForSequenceClassification from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
+      "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-large and are newly initialized: ['classifier.dense.weight', 'classifier.dense.bias', 'classifier.out_proj.weight', 'classifier.out_proj.bias']\n",
+      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e650799d58ec4bd1b21b6bc28ddf2069",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading:   0%|          | 0.00/4.29M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|                                                                                                   | 0/13 [00:00<?, ?it/s]You're using a RobertaTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  7.18it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'accuracy': 0.7107843137254902, 'f1': 0.8206686930091186}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "from peft import PeftModel, PeftConfig\n",
+    "from transformers import AutoModelForCausalLM, AutoTokenizer\n",
+    "\n",
+    "peft_model_id = \"smangrul/roberta-large-peft-p-tuning\"\n",
+    "config = PeftConfig.from_pretrained(peft_model_id)\n",
+    "inference_model = AutoModelForSequenceClassification.from_pretrained(config.base_model_name_or_path)\n",
+    "tokenizer = AutoTokenizer.from_pretrained(config.base_model_name_or_path)\n",
+    "\n",
+    "# Load the Lora model\n",
+    "inference_model = PeftModel.from_pretrained(inference_model, peft_model_id)\n",
+    "\n",
+    "inference_model.to(device)\n",
+    "inference_model.eval()\n",
+    "for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+    "    batch.to(device)\n",
+    "    with torch.no_grad():\n",
+    "        outputs = inference_model(**batch)\n",
+    "    predictions = outputs.logits.argmax(dim=-1)\n",
+    "    predictions, references = predictions, batch[\"labels\"]\n",
+    "    metric.add_batch(\n",
+    "        predictions=predictions,\n",
+    "        references=references,\n",
+    "    )\n",
+    "\n",
+    "eval_metric = metric.compute()\n",
+    "print(eval_metric)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1a8d69d1",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.5 (v3.10.5:f377153967, Jun  6 2022, 12:36:10) [Clang 13.0.0 (clang-1300.0.29.30)]"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/sequence_classification/Prompt_Tuning.ipynb b/examples/sequence_classification/Prompt_Tuning.ipynb
new file mode 100644
index 0000000..b0aaa28
--- /dev/null
+++ b/examples/sequence_classification/Prompt_Tuning.ipynb
@@ -0,0 +1,692 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "9ff5004e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "===================================BUG REPORT===================================\n",
+      "Welcome to bitsandbytes. For bug reports, please submit your error trace to: https://github.com/TimDettmers/bitsandbytes/issues\n",
+      "For effortless bug reporting copy-paste your error into this form: https://docs.google.com/forms/d/e/1FAIpQLScPB8emS3Thkp66nvqwmjTEgxp8Y9ufuWTzFyr9kJ5AoI47dQ/viewform?usp=sf_link\n",
+      "================================================================================\n",
+      "CUDA SETUP: CUDA runtime path found: /home/sourab/miniconda3/envs/ml/lib/libcudart.so\n",
+      "CUDA SETUP: Highest compute capability among GPUs detected: 7.5\n",
+      "CUDA SETUP: Detected CUDA version 117\n",
+      "CUDA SETUP: Loading binary /home/sourab/miniconda3/envs/ml/lib/python3.10/site-packages/bitsandbytes/libbitsandbytes_cuda117.so...\n"
+     ]
+    }
+   ],
+   "source": [
+    "import argparse\n",
+    "import os\n",
+    "\n",
+    "import torch\n",
+    "from torch.optim import AdamW\n",
+    "from torch.utils.data import DataLoader\n",
+    "from peft import (\n",
+    "    get_peft_config,\n",
+    "    get_peft_model,\n",
+    "    get_peft_model_state_dict,\n",
+    "    set_peft_model_state_dict,\n",
+    "    PeftType,\n",
+    "    PrefixTuningConfig,\n",
+    "    PromptEncoderConfig,\n",
+    "    PromptTuningConfig,\n",
+    ")\n",
+    "\n",
+    "import evaluate\n",
+    "from datasets import load_dataset\n",
+    "from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed\n",
+    "from tqdm import tqdm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e32c4a9e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "batch_size = 32\n",
+    "model_name_or_path = \"roberta-large\"\n",
+    "task = \"mrpc\"\n",
+    "peft_type = PeftType.PROMPT_TUNING\n",
+    "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "num_epochs = 20"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "622fe9c8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "peft_config = PromptTuningConfig(task_type=\"SEQ_CLS\", num_virtual_tokens=10)\n",
+    "lr = 1e-3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "74e9efe0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Found cached dataset glue (/home/sourab/.cache/huggingface/datasets/glue/mrpc/1.0.0/dacbe3125aa31d7f70367a07a8a9e72a5a0bfeb5fc42e75c9db75b96da6053ad)\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "76198cec552441818ff107910275e5be",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/3 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading cached processed dataset at /home/sourab/.cache/huggingface/datasets/glue/mrpc/1.0.0/dacbe3125aa31d7f70367a07a8a9e72a5a0bfeb5fc42e75c9db75b96da6053ad/cache-9fa7887f9eaa03ae.arrow\n",
+      "Loading cached processed dataset at /home/sourab/.cache/huggingface/datasets/glue/mrpc/1.0.0/dacbe3125aa31d7f70367a07a8a9e72a5a0bfeb5fc42e75c9db75b96da6053ad/cache-dc593149bbeafe80.arrow\n",
+      "Loading cached processed dataset at /home/sourab/.cache/huggingface/datasets/glue/mrpc/1.0.0/dacbe3125aa31d7f70367a07a8a9e72a5a0bfeb5fc42e75c9db75b96da6053ad/cache-140ebe5b70e09817.arrow\n"
+     ]
+    }
+   ],
+   "source": [
+    "if any(k in model_name_or_path for k in (\"gpt\", \"opt\", \"bloom\")):\n",
+    "    padding_side = \"left\"\n",
+    "else:\n",
+    "    padding_side = \"right\"\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, padding_side=padding_side)\n",
+    "if getattr(tokenizer, \"pad_token_id\") is None:\n",
+    "    tokenizer.pad_token_id = tokenizer.eos_token_id\n",
+    "\n",
+    "datasets = load_dataset(\"glue\", task)\n",
+    "metric = evaluate.load(\"glue\", task)\n",
+    "\n",
+    "\n",
+    "def tokenize_function(examples):\n",
+    "    # max_length=None => use the model max length (it's actually the default)\n",
+    "    outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=None)\n",
+    "    return outputs\n",
+    "\n",
+    "\n",
+    "tokenized_datasets = datasets.map(\n",
+    "    tokenize_function,\n",
+    "    batched=True,\n",
+    "    remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n",
+    ")\n",
+    "\n",
+    "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n",
+    "# transformers library\n",
+    "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")\n",
+    "\n",
+    "\n",
+    "def collate_fn(examples):\n",
+    "    return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")\n",
+    "\n",
+    "\n",
+    "# Instantiate dataloaders.\n",
+    "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size)\n",
+    "eval_dataloader = DataLoader(\n",
+    "    tokenized_datasets[\"validation\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a3c15af0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path, return_dict=True)\n",
+    "model = get_peft_model(model, peft_config)\n",
+    "model.print_trainable_parameters()\n",
+    "model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "6d3c5edb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimizer = AdamW(params=model.parameters(), lr=lr)\n",
+    "\n",
+    "# Instantiate scheduler\n",
+    "lr_scheduler = get_linear_schedule_with_warmup(\n",
+    "    optimizer=optimizer,\n",
+    "    num_warmup_steps=0.06 * (len(train_dataloader) * num_epochs),\n",
+    "    num_training_steps=(len(train_dataloader) * num_epochs),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "4d279225",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|                                                                                                  | 0/115 [00:00<?, ?it/s]You're using a RobertaTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [02:09<00:00,  1.13s/it]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:08<00:00,  1.62it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 0: {'accuracy': 0.678921568627451, 'f1': 0.7956318252730109}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:50<00:00,  1.04it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:05<00:00,  2.22it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 1: {'accuracy': 0.696078431372549, 'f1': 0.8171091445427728}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:36<00:00,  1.19it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:06<00:00,  2.00it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 2: {'accuracy': 0.6985294117647058, 'f1': 0.8161434977578476}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:37<00:00,  1.18it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:06<00:00,  2.09it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 3: {'accuracy': 0.7058823529411765, 'f1': 0.7979797979797979}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [02:03<00:00,  1.07s/it]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:07<00:00,  1.71it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 4: {'accuracy': 0.696078431372549, 'f1': 0.8132530120481929}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:53<00:00,  1.01it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:05<00:00,  2.19it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 5: {'accuracy': 0.7107843137254902, 'f1': 0.8121019108280254}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:35<00:00,  1.20it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:05<00:00,  2.20it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 6: {'accuracy': 0.6911764705882353, 'f1': 0.7692307692307693}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:36<00:00,  1.20it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:05<00:00,  2.18it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 7: {'accuracy': 0.7156862745098039, 'f1': 0.8209876543209876}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:35<00:00,  1.20it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:05<00:00,  2.22it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 8: {'accuracy': 0.7205882352941176, 'f1': 0.8240740740740742}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:36<00:00,  1.19it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:05<00:00,  2.21it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 9: {'accuracy': 0.7205882352941176, 'f1': 0.8229813664596273}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:36<00:00,  1.20it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:05<00:00,  2.35it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 10: {'accuracy': 0.7156862745098039, 'f1': 0.8164556962025317}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:35<00:00,  1.20it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:05<00:00,  2.22it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 11: {'accuracy': 0.7058823529411765, 'f1': 0.8113207547169811}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:32<00:00,  1.24it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:05<00:00,  2.48it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 12: {'accuracy': 0.7009803921568627, 'f1': 0.7946127946127945}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:32<00:00,  1.24it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:05<00:00,  2.38it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 13: {'accuracy': 0.7230392156862745, 'f1': 0.8186195826645265}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:29<00:00,  1.29it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:05<00:00,  2.31it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 14: {'accuracy': 0.7058823529411765, 'f1': 0.8130841121495327}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:30<00:00,  1.27it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:05<00:00,  2.39it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 15: {'accuracy': 0.7181372549019608, 'f1': 0.8194662480376768}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:28<00:00,  1.29it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:05<00:00,  2.35it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 16: {'accuracy': 0.7254901960784313, 'f1': 0.8181818181818181}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:30<00:00,  1.27it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:05<00:00,  2.30it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 17: {'accuracy': 0.7205882352941176, 'f1': 0.820754716981132}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:30<00:00,  1.27it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:05<00:00,  2.36it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 18: {'accuracy': 0.7254901960784313, 'f1': 0.821656050955414}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:28<00:00,  1.29it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:05<00:00,  2.43it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 19: {'accuracy': 0.7303921568627451, 'f1': 0.8242811501597445}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.to(device)\n",
+    "for epoch in range(num_epochs):\n",
+    "    model.train()\n",
+    "    for step, batch in enumerate(tqdm(train_dataloader)):\n",
+    "        batch.to(device)\n",
+    "        outputs = model(**batch)\n",
+    "        loss = outputs.loss\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        lr_scheduler.step()\n",
+    "        optimizer.zero_grad()\n",
+    "\n",
+    "    model.eval()\n",
+    "    for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+    "        batch.to(device)\n",
+    "        with torch.no_grad():\n",
+    "            outputs = model(**batch)\n",
+    "        predictions = outputs.logits.argmax(dim=-1)\n",
+    "        predictions, references = predictions, batch[\"labels\"]\n",
+    "        metric.add_batch(\n",
+    "            predictions=predictions,\n",
+    "            references=references,\n",
+    "        )\n",
+    "\n",
+    "    eval_metric = metric.compute()\n",
+    "    print(f\"epoch {epoch}:\", eval_metric)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e1ff3f44",
+   "metadata": {},
+   "source": [
+    "## Share adapters on the 🤗 Hub"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "0bf79cb5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "CommitInfo(commit_url='https://huggingface.co/smangrul/roberta-large-peft-prompt-tuning/commit/893a909d8499aa8778d58c781d43c3a8d9360de8', commit_message='Upload model', commit_description='', oid='893a909d8499aa8778d58c781d43c3a8d9360de8', pr_url=None, pr_revision=None, pr_num=None)"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.push_to_hub(\"smangrul/roberta-large-peft-prompt-tuning\", use_auth_token=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "73870ad7",
+   "metadata": {},
+   "source": [
+    "## Load adapters from the Hub\n",
+    "\n",
+    "You can also directly load adapters from the Hub using the commands below:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "0654a552",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "24581bb98582444ca6114b9fa267847f",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading:   0%|          | 0.00/368 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Some weights of the model checkpoint at roberta-large were not used when initializing RobertaForSequenceClassification: ['lm_head.layer_norm.weight', 'lm_head.layer_norm.bias', 'roberta.pooler.dense.weight', 'roberta.pooler.dense.bias', 'lm_head.bias', 'lm_head.dense.weight', 'lm_head.decoder.weight', 'lm_head.dense.bias']\n",
+      "- This IS expected if you are initializing RobertaForSequenceClassification from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
+      "- This IS NOT expected if you are initializing RobertaForSequenceClassification from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
+      "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-large and are newly initialized: ['classifier.out_proj.weight', 'classifier.out_proj.bias', 'classifier.dense.bias', 'classifier.dense.weight']\n",
+      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f1584da4d1c54cc3873a515182674980",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading:   0%|          | 0.00/4.25M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|                                                                                                   | 0/13 [00:00<?, ?it/s]You're using a RobertaTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:05<00:00,  2.58it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'accuracy': 0.7303921568627451, 'f1': 0.8242811501597445}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "from peft import PeftModel, PeftConfig\n",
+    "from transformers import AutoModelForCausalLM, AutoTokenizer\n",
+    "\n",
+    "peft_model_id = \"smangrul/roberta-large-peft-prompt-tuning\"\n",
+    "config = PeftConfig.from_pretrained(peft_model_id)\n",
+    "inference_model = AutoModelForSequenceClassification.from_pretrained(config.base_model_name_or_path)\n",
+    "tokenizer = AutoTokenizer.from_pretrained(config.base_model_name_or_path)\n",
+    "\n",
+    "# Load the Lora model\n",
+    "inference_model = PeftModel.from_pretrained(inference_model, peft_model_id)\n",
+    "\n",
+    "inference_model.to(device)\n",
+    "inference_model.eval()\n",
+    "for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+    "    batch.to(device)\n",
+    "    with torch.no_grad():\n",
+    "        outputs = inference_model(**batch)\n",
+    "    predictions = outputs.logits.argmax(dim=-1)\n",
+    "    predictions, references = predictions, batch[\"labels\"]\n",
+    "    metric.add_batch(\n",
+    "        predictions=predictions,\n",
+    "        references=references,\n",
+    "    )\n",
+    "\n",
+    "eval_metric = metric.compute()\n",
+    "print(eval_metric)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.4"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/sequence_classification/VBLoRA.ipynb b/examples/sequence_classification/VBLoRA.ipynb
new file mode 100644
index 0000000..f8d84c4
--- /dev/null
+++ b/examples/sequence_classification/VBLoRA.ipynb
@@ -0,0 +1,787 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "d36e1e93-ae93-4a4e-93c6-68fd868d2882",
+   "metadata": {},
+   "source": [
+    "# Using VB-LoRA for sequence classification"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ddfc0610-55f6-4343-a950-125ccf0f45ac",
+   "metadata": {},
+   "source": [
+    "In this example, we fine-tune Roberta on a sequence classification task using VB-LoRA.\n",
+    "\n",
+    "This notebook is adapted from `examples/sequence_classification/VeRA.ipynb`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "45addd81-d4f3-4dfd-960d-3920d347f0a6",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a9935ae2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from torch.optim import AdamW\n",
+    "from torch.utils.data import DataLoader\n",
+    "from peft import (\n",
+    "    get_peft_model,\n",
+    "    VBLoRAConfig,\n",
+    "    PeftType,\n",
+    ")\n",
+    "\n",
+    "import evaluate\n",
+    "from datasets import load_dataset\n",
+    "from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup\n",
+    "from tqdm import tqdm"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "62c959bf-7cc2-49e0-b97e-4c10ec3b9bf3",
+   "metadata": {},
+   "source": [
+    "## Parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e3b13308",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<torch._C.Generator at 0x7f4fc7c3c750>"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "batch_size = 32\n",
+    "model_name_or_path = \"roberta-large\"\n",
+    "task = \"mrpc\"\n",
+    "peft_type = PeftType.VBLORA\n",
+    "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "num_epochs = 20\n",
+    "rank = 4\n",
+    "max_length = 128\n",
+    "num_vectors = 90\n",
+    "vector_length = 256\n",
+    "torch.manual_seed(0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "0526f571",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "peft_config = VBLoRAConfig(\n",
+    "    task_type=\"SEQ_CLS\", \n",
+    "    r=rank,\n",
+    "    topk=2,\n",
+    "    target_modules=['key', 'value', 'query', 'output.dense', 'intermediate.dense'],\n",
+    "    num_vectors=num_vectors,\n",
+    "    vector_length=vector_length,\n",
+    "    save_only_topk_weights=True, # Set to True to reduce storage space. Note that the saved parameters cannot be used to resume training from checkpoints.\n",
+    "    vblora_dropout=0.,\n",
+    ")\n",
+    "head_lr = 4e-3\n",
+    "vector_bank_lr = 1e-3\n",
+    "logits_lr = 1e-2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c075c5d2-a457-4f37-a7f1-94fd0d277972",
+   "metadata": {},
+   "source": [
+    "## Loading data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "7bb52cb4-d1c3-4b04-8bf0-f39ca88af139",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if any(k in model_name_or_path for k in (\"gpt\", \"opt\", \"bloom\")):\n",
+    "    padding_side = \"left\"\n",
+    "else:\n",
+    "    padding_side = \"right\"\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, padding_side=padding_side)\n",
+    "if getattr(tokenizer, \"pad_token_id\") is None:\n",
+    "    tokenizer.pad_token_id = tokenizer.eos_token_id"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "e69c5e1f-d27b-4264-a41e-fc9b99d025e6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "datasets = load_dataset(\"glue\", task)\n",
+    "metric = evaluate.load(\"glue\", task)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "0209f778-c93b-40eb-a4e0-24c25db03980",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def tokenize_function(examples):\n",
+    "    # max_length=None => use the model max length (it's actually the default)\n",
+    "    outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=max_length)\n",
+    "    return outputs\n",
+    "\n",
+    "\n",
+    "tokenized_datasets = datasets.map(\n",
+    "    tokenize_function,\n",
+    "    batched=True,\n",
+    "    remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n",
+    ")\n",
+    "\n",
+    "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n",
+    "# transformers library\n",
+    "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "7453954e-982c-46f0-b09c-589776e6d6cb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def collate_fn(examples):\n",
+    "    return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")\n",
+    "\n",
+    "\n",
+    "# Instantiate dataloaders.\n",
+    "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size)\n",
+    "eval_dataloader = DataLoader(\n",
+    "    tokenized_datasets[\"validation\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f3b9b2e8-f415-4d0f-9fb4-436f1a3585ea",
+   "metadata": {},
+   "source": [
+    "## Preparing the VB-LoRA model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "2ed5ac74",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-large and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
+      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "trainable params: 1,696,770 || all params: 357,058,564 || trainable%: 0.4752\n",
+      "VB-LoRA params to-be-saved (float32-equivalent): 33,408 || total params to-be-saved: 1,085,058\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path, return_dict=True, max_length=None)\n",
+    "model = get_peft_model(model, peft_config)\n",
+    "model.print_trainable_parameters()\n",
+    "model.print_savable_parameters()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "0d2d0381",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "from transformers.pytorch_utils import ALL_LAYERNORM_LAYERS\n",
+    "from transformers.trainer_pt_utils import get_parameter_names\n",
+    "\n",
+    "decay_parameters = get_parameter_names(model, ALL_LAYERNORM_LAYERS)\n",
+    "decay_parameters = [name for name in decay_parameters if \"bias\" not in name]\n",
+    "vector_bank_parameters = [name for name, _ in model.named_parameters() if \"vector_bank\" in name]\n",
+    "logits_parameters = [name for name, _ in model.named_parameters() if \"logits\" in name ]\n",
+    "\n",
+    "optimizer_grouped_parameters = [\n",
+    "    {\n",
+    "        \"params\": [p for n, p in model.named_parameters() if n in decay_parameters and \\\n",
+    "                    n not in logits_parameters and n not in vector_bank_parameters],\n",
+    "        \"weight_decay\": 0.1,\n",
+    "        \"lr\": head_lr,\n",
+    "    },\n",
+    "    {\n",
+    "        \"params\": [p for n, p in model.named_parameters() if n not in decay_parameters and \\\n",
+    "                    n not in logits_parameters and n not in vector_bank_parameters],\n",
+    "        \"weight_decay\": 0.0,\n",
+    "        \"lr\": head_lr,\n",
+    "    },\n",
+    "    {\n",
+    "        \"params\": [p for n, p in model.named_parameters() if n in vector_bank_parameters],\n",
+    "        \"lr\": vector_bank_lr,\n",
+    "        \"weight_decay\": 0.0,\n",
+    "    },\n",
+    "    {\n",
+    "        \"params\": [p for n, p in model.named_parameters() if n in logits_parameters],\n",
+    "        \"lr\": logits_lr,\n",
+    "        \"weight_decay\": 0.0,\n",
+    "    },\n",
+    "]\n",
+    "\n",
+    "optimizer = AdamW(optimizer_grouped_parameters)\n",
+    "lr_scheduler = get_linear_schedule_with_warmup(\n",
+    "    optimizer=optimizer,\n",
+    "    num_warmup_steps=0.06 * (len(train_dataloader) * num_epochs),\n",
+    "    num_training_steps=(len(train_dataloader) * num_epochs),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c0dd5aa8-977b-4ac0-8b96-884b17bcdd00",
+   "metadata": {},
+   "source": [
+    "## Training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "fa0e73be",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 0/115 [00:00<?, ?it/s]You're using a RobertaTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
+      "100%|██████████| 115/115 [00:34<00:00,  3.33it/s]\n",
+      "100%|██████████| 13/13 [00:01<00:00,  7.84it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 0: {'accuracy': 0.6691176470588235, 'f1': 0.786053882725832}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:34<00:00,  3.37it/s]\n",
+      "100%|██████████| 13/13 [00:01<00:00,  7.83it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 1: {'accuracy': 0.5833333333333334, 'f1': 0.6136363636363636}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:34<00:00,  3.34it/s]\n",
+      "100%|██████████| 13/13 [00:01<00:00,  7.82it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 2: {'accuracy': 0.7107843137254902, 'f1': 0.8238805970149253}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:34<00:00,  3.34it/s]\n",
+      "100%|██████████| 13/13 [00:01<00:00,  7.80it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 3: {'accuracy': 0.8284313725490197, 'f1': 0.8833333333333333}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:34<00:00,  3.34it/s]\n",
+      "100%|██████████| 13/13 [00:01<00:00,  7.79it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 4: {'accuracy': 0.8480392156862745, 'f1': 0.8847583643122676}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:34<00:00,  3.30it/s]\n",
+      "100%|██████████| 13/13 [00:01<00:00,  7.78it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 5: {'accuracy': 0.8676470588235294, 'f1': 0.898876404494382}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:34<00:00,  3.31it/s]\n",
+      "100%|██████████| 13/13 [00:01<00:00,  7.76it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 6: {'accuracy': 0.8602941176470589, 'f1': 0.9035532994923858}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:34<00:00,  3.32it/s]\n",
+      "100%|██████████| 13/13 [00:01<00:00,  7.76it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 7: {'accuracy': 0.8774509803921569, 'f1': 0.911660777385159}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:34<00:00,  3.33it/s]\n",
+      "100%|██████████| 13/13 [00:01<00:00,  7.79it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 8: {'accuracy': 0.8872549019607843, 'f1': 0.9172661870503597}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:34<00:00,  3.32it/s]\n",
+      "100%|██████████| 13/13 [00:01<00:00,  7.78it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 9: {'accuracy': 0.875, 'f1': 0.9113043478260869}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:34<00:00,  3.32it/s]\n",
+      "100%|██████████| 13/13 [00:01<00:00,  7.76it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 10: {'accuracy': 0.8823529411764706, 'f1': 0.9166666666666666}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:34<00:00,  3.33it/s]\n",
+      "100%|██████████| 13/13 [00:01<00:00,  7.76it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 11: {'accuracy': 0.8970588235294118, 'f1': 0.9252669039145908}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:34<00:00,  3.32it/s]\n",
+      "100%|██████████| 13/13 [00:01<00:00,  7.75it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 12: {'accuracy': 0.8946078431372549, 'f1': 0.9246935201401051}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:34<00:00,  3.33it/s]\n",
+      "100%|██████████| 13/13 [00:01<00:00,  7.76it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 13: {'accuracy': 0.9068627450980392, 'f1': 0.9316546762589928}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:34<00:00,  3.33it/s]\n",
+      "100%|██████████| 13/13 [00:01<00:00,  7.76it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 14: {'accuracy': 0.8946078431372549, 'f1': 0.9225225225225225}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:34<00:00,  3.33it/s]\n",
+      "100%|██████████| 13/13 [00:01<00:00,  7.76it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 15: {'accuracy': 0.8995098039215687, 'f1': 0.926391382405745}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:34<00:00,  3.30it/s]\n",
+      "100%|██████████| 13/13 [00:01<00:00,  7.76it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 16: {'accuracy': 0.9068627450980392, 'f1': 0.9316546762589928}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:34<00:00,  3.31it/s]\n",
+      "100%|██████████| 13/13 [00:01<00:00,  7.77it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 17: {'accuracy': 0.8921568627450981, 'f1': 0.9217081850533808}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:34<00:00,  3.33it/s]\n",
+      "100%|██████████| 13/13 [00:01<00:00,  7.77it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 18: {'accuracy': 0.8995098039215687, 'f1': 0.9266547406082289}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:34<00:00,  3.33it/s]\n",
+      "100%|██████████| 13/13 [00:01<00:00,  7.77it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 19: {'accuracy': 0.9044117647058824, 'f1': 0.9297297297297298}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.to(device)\n",
+    "\n",
+    "for epoch in range(num_epochs):\n",
+    "    model.train()\n",
+    "    for step, batch in enumerate(tqdm(train_dataloader)):\n",
+    "        batch.to(device)\n",
+    "        outputs = model(**batch)\n",
+    "        loss = outputs.loss\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        lr_scheduler.step()\n",
+    "        optimizer.zero_grad()\n",
+    "\n",
+    "    model.eval()\n",
+    "    for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+    "        batch.to(device)\n",
+    "        with torch.no_grad():\n",
+    "            outputs = model(**batch)\n",
+    "        predictions = outputs.logits.argmax(dim=-1)\n",
+    "        predictions, references = predictions, batch[\"labels\"]\n",
+    "        metric.add_batch(\n",
+    "            predictions=predictions,\n",
+    "            references=references,\n",
+    "        )\n",
+    "\n",
+    "    eval_metric = metric.compute()\n",
+    "    print(f\"epoch {epoch}:\", eval_metric)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f2b2caca",
+   "metadata": {},
+   "source": [
+    "## Share adapters on the 🤗 Hub"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "7b23af6f-cf6e-486f-9d10-0eada95b631f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "account_id = ...  # your Hugging Face Hub account ID"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "990b3c93",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model.push_to_hub(f\"{account_id}/roberta-large-peft-vblora\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9d140b26",
+   "metadata": {},
+   "source": [
+    "## Load adapters from the Hub\n",
+    "\n",
+    "You can also directly load adapters from the Hub using the commands below:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "c283e028-b349-46b0-a20e-cde0ee5fbd7b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from peft import PeftModel, PeftConfig\n",
+    "from transformers import AutoTokenizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "320b10a0-4ea8-4786-9f3c-4670019c6b18",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-large and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
+      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+     ]
+    }
+   ],
+   "source": [
+    "peft_model_id = f\"{account_id}/roberta-large-peft-vblora\"\n",
+    "config = PeftConfig.from_pretrained(peft_model_id)\n",
+    "inference_model = AutoModelForSequenceClassification.from_pretrained(config.base_model_name_or_path)\n",
+    "tokenizer = AutoTokenizer.from_pretrained(config.base_model_name_or_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "b3a94049-bc01-4f2e-8cf9-66daf24a4402",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load the model\n",
+    "inference_model = PeftModel.from_pretrained(inference_model, peft_model_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "bd919fef-4e9a-4dc5-a957-7b879cfc5d38",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 0/13 [00:00<?, ?it/s]You're using a RobertaTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
+      "100%|██████████| 13/13 [00:01<00:00,  7.81it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'accuracy': 0.9044117647058824, 'f1': 0.9297297297297298}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "inference_model.to(device)\n",
+    "inference_model.eval()\n",
+    "for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+    "    batch.to(device)\n",
+    "    with torch.no_grad():\n",
+    "        outputs = inference_model(**batch)\n",
+    "    predictions = outputs.logits.argmax(dim=-1)\n",
+    "    predictions, references = predictions, batch[\"labels\"]\n",
+    "    metric.add_batch(\n",
+    "        predictions=predictions,\n",
+    "        references=references,\n",
+    "    )\n",
+    "\n",
+    "eval_metric = metric.compute()\n",
+    "print(eval_metric)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.14"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/sequence_classification/VeRA.ipynb b/examples/sequence_classification/VeRA.ipynb
new file mode 100644
index 0000000..7981c01
--- /dev/null
+++ b/examples/sequence_classification/VeRA.ipynb
@@ -0,0 +1,531 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "d36e1e93-ae93-4a4e-93c6-68fd868d2882",
+   "metadata": {},
+   "source": [
+    "# Using VeRA for sequence classification"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ddfc0610-55f6-4343-a950-125ccf0f45ac",
+   "metadata": {},
+   "source": [
+    "In this example, we fine-tune Roberta on a sequence classification task using VeRA."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "45addd81-d4f3-4dfd-960d-3920d347f0a6",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "a9935ae2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from torch.optim import AdamW\n",
+    "from torch.utils.data import DataLoader\n",
+    "from peft import (\n",
+    "    get_peft_model,\n",
+    "    VeraConfig,\n",
+    "    PeftType,\n",
+    ")\n",
+    "\n",
+    "import evaluate\n",
+    "from datasets import load_dataset\n",
+    "from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed, AutoConfig\n",
+    "from tqdm import tqdm"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "62c959bf-7cc2-49e0-b97e-4c10ec3b9bf3",
+   "metadata": {},
+   "source": [
+    "## Parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "e3b13308",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<torch._C.Generator at 0x7b8246b7c850>"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "batch_size = 128\n",
+    "model_name_or_path = \"roberta-base\"\n",
+    "task = \"mrpc\"\n",
+    "peft_type = PeftType.VERA\n",
+    "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "num_epochs = 5  # for best results, increase this number\n",
+    "rank = 8        # for best results, increase this number\n",
+    "max_length = 128\n",
+    "torch.manual_seed(0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "0526f571",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "peft_config = VeraConfig(\n",
+    "    task_type=\"SEQ_CLS\", \n",
+    "    r=rank,\n",
+    "    d_initial=0.1,\n",
+    "    target_modules=[\"query\", \"value\", \"intermediate.dense\"],\n",
+    "    save_projection=True,\n",
+    ")\n",
+    "head_lr = 1e-2\n",
+    "vera_lr = 2e-2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c075c5d2-a457-4f37-a7f1-94fd0d277972",
+   "metadata": {},
+   "source": [
+    "## Loading data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "7bb52cb4-d1c3-4b04-8bf0-f39ca88af139",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if any(k in model_name_or_path for k in (\"gpt\", \"opt\", \"bloom\")):\n",
+    "    padding_side = \"left\"\n",
+    "else:\n",
+    "    padding_side = \"right\"\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, padding_side=padding_side)\n",
+    "if getattr(tokenizer, \"pad_token_id\") is None:\n",
+    "    tokenizer.pad_token_id = tokenizer.eos_token_id"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "e69c5e1f-d27b-4264-a41e-fc9b99d025e6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "datasets = load_dataset(\"glue\", task)\n",
+    "metric = evaluate.load(\"glue\", task)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "0209f778-c93b-40eb-a4e0-24c25db03980",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def tokenize_function(examples):\n",
+    "    # max_length=None => use the model max length (it's actually the default)\n",
+    "    outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=max_length)\n",
+    "    return outputs\n",
+    "\n",
+    "\n",
+    "tokenized_datasets = datasets.map(\n",
+    "    tokenize_function,\n",
+    "    batched=True,\n",
+    "    remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n",
+    ")\n",
+    "\n",
+    "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n",
+    "# transformers library\n",
+    "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "7453954e-982c-46f0-b09c-589776e6d6cb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def collate_fn(examples):\n",
+    "    return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")\n",
+    "\n",
+    "\n",
+    "# Instantiate dataloaders.\n",
+    "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size)\n",
+    "eval_dataloader = DataLoader(\n",
+    "    tokenized_datasets[\"validation\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f3b9b2e8-f415-4d0f-9fb4-436f1a3585ea",
+   "metadata": {},
+   "source": [
+    "## Preparing the VeRA model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "2ed5ac74",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-base and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
+      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "trainable params: 647,714 || all params: 125,294,884 || trainable%: 0.5170\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path, return_dict=True, max_length=None)\n",
+    "model = get_peft_model(model, peft_config)\n",
+    "model.print_trainable_parameters()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "0d2d0381",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimizer = AdamW(\n",
+    "    [\n",
+    "        {\"params\": [p for n, p in model.named_parameters() if \"vera_lambda_\" in n], \"lr\": vera_lr},\n",
+    "        {\"params\": [p for n, p in model.named_parameters() if \"classifier\" in n], \"lr\": head_lr},\n",
+    "    ]\n",
+    ")\n",
+    "\n",
+    "# Instantiate scheduler\n",
+    "lr_scheduler = get_linear_schedule_with_warmup(\n",
+    "    optimizer=optimizer,\n",
+    "    num_warmup_steps=0.06 * (len(train_dataloader) * num_epochs),\n",
+    "    num_training_steps=(len(train_dataloader) * num_epochs),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c0dd5aa8-977b-4ac0-8b96-884b17bcdd00",
+   "metadata": {},
+   "source": [
+    "## Training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "fa0e73be",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 0/29 [00:00<?, ?it/s]You're using a RobertaTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
+      "100%|██████████| 29/29 [00:18<00:00,  1.58it/s]\n",
+      "100%|██████████| 4/4 [00:01<00:00,  3.52it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 0: {'accuracy': 0.7475490196078431, 'f1': 0.8367670364500792}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 29/29 [00:17<00:00,  1.68it/s]\n",
+      "100%|██████████| 4/4 [00:01<00:00,  3.37it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 1: {'accuracy': 0.7671568627450981, 'f1': 0.8536209553158706}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 29/29 [00:17<00:00,  1.66it/s]\n",
+      "100%|██████████| 4/4 [00:01<00:00,  3.33it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 2: {'accuracy': 0.8553921568627451, 'f1': 0.8959435626102292}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 29/29 [00:17<00:00,  1.64it/s]\n",
+      "100%|██████████| 4/4 [00:01<00:00,  3.35it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 3: {'accuracy': 0.8823529411764706, 'f1': 0.9133574007220215}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 29/29 [00:17<00:00,  1.63it/s]\n",
+      "100%|██████████| 4/4 [00:01<00:00,  3.17it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 4: {'accuracy': 0.8897058823529411, 'f1': 0.9183303085299456}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.to(device)\n",
+    "for epoch in range(num_epochs):\n",
+    "    model.train()\n",
+    "    for step, batch in enumerate(tqdm(train_dataloader)):\n",
+    "        batch.to(device)\n",
+    "        outputs = model(**batch)\n",
+    "        loss = outputs.loss\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        lr_scheduler.step()\n",
+    "        optimizer.zero_grad()\n",
+    "\n",
+    "    model.eval()\n",
+    "    for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+    "        batch.to(device)\n",
+    "        with torch.no_grad():\n",
+    "            outputs = model(**batch)\n",
+    "        predictions = outputs.logits.argmax(dim=-1)\n",
+    "        predictions, references = predictions, batch[\"labels\"]\n",
+    "        metric.add_batch(\n",
+    "            predictions=predictions,\n",
+    "            references=references,\n",
+    "        )\n",
+    "\n",
+    "    eval_metric = metric.compute()\n",
+    "    print(f\"epoch {epoch}:\", eval_metric)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f2b2caca",
+   "metadata": {},
+   "source": [
+    "## Share adapters on the 🤗 Hub"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "7b23af6f-cf6e-486f-9d10-0eada95b631f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "account_id = ...  # your Hugging Face Hub account ID"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "990b3c93",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "CommitInfo(commit_url='https://huggingface.co/BenjaminB/roberta-large-peft-vera/commit/d720cdc67b97df9cd1453b14d3e0fb17efc8779b', commit_message='Upload model', commit_description='', oid='d720cdc67b97df9cd1453b14d3e0fb17efc8779b', pr_url=None, pr_revision=None, pr_num=None)"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.push_to_hub(f\"{account_id}/roberta-large-peft-vera\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9d140b26",
+   "metadata": {},
+   "source": [
+    "## Load adapters from the Hub\n",
+    "\n",
+    "You can also directly load adapters from the Hub using the commands below:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "c283e028-b349-46b0-a20e-cde0ee5fbd7b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from peft import PeftModel, PeftConfig\n",
+    "from transformers import AutoTokenizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "320b10a0-4ea8-4786-9f3c-4670019c6b18",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-base and are newly initialized: ['classifier.dense.bias', 'classifier.dense.weight', 'classifier.out_proj.bias', 'classifier.out_proj.weight']\n",
+      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+     ]
+    }
+   ],
+   "source": [
+    "peft_model_id = f\"{account_id}/roberta-large-peft-vera\"\n",
+    "config = PeftConfig.from_pretrained(peft_model_id)\n",
+    "inference_model = AutoModelForSequenceClassification.from_pretrained(config.base_model_name_or_path)\n",
+    "tokenizer = AutoTokenizer.from_pretrained(config.base_model_name_or_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "b3a94049-bc01-4f2e-8cf9-66daf24a4402",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load the Vera model\n",
+    "inference_model = PeftModel.from_pretrained(inference_model, peft_model_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "bd919fef-4e9a-4dc5-a957-7b879cfc5d38",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|                                                                                                                                                                                                                                                     | 0/4 [00:00<?, ?it/s]You're using a RobertaTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
+      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 4/4 [00:01<00:00,  3.14it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'accuracy': 0.8480392156862745, 'f1': 0.8938356164383561}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "inference_model.to(device)\n",
+    "inference_model.eval()\n",
+    "for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+    "    batch.to(device)\n",
+    "    with torch.no_grad():\n",
+    "        outputs = inference_model(**batch)\n",
+    "    predictions = outputs.logits.argmax(dim=-1)\n",
+    "    predictions, references = predictions, batch[\"labels\"]\n",
+    "    metric.add_batch(\n",
+    "        predictions=predictions,\n",
+    "        references=references,\n",
+    "    )\n",
+    "\n",
+    "eval_metric = metric.compute()\n",
+    "print(eval_metric)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "13cc0125-a052-4e26-b7ff-af0f763be34e",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/sequence_classification/peft_no_lora_accelerate.py b/examples/sequence_classification/peft_no_lora_accelerate.py
new file mode 100644
index 0000000..577b1a6
--- /dev/null
+++ b/examples/sequence_classification/peft_no_lora_accelerate.py
@@ -0,0 +1,214 @@
+import argparse
+
+import evaluate
+import torch
+from accelerate import Accelerator, DistributedDataParallelKwargs
+from datasets import load_dataset
+from torch.optim import AdamW
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed
+
+from peft import (
+    PrefixTuningConfig,
+    PromptEncoderConfig,
+    PromptTuningConfig,
+    get_peft_model,
+)
+from peft.utils.other import fsdp_auto_wrap_policy
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="PEFT a transformers model on a sequence classification task")
+    parser.add_argument(
+        "--num_virtual_tokens",
+        type=int,
+        default=20,
+        help="num_virtual_tokens if the number of virtual tokens used in prompt/prefix/P tuning.",
+    )
+    parser.add_argument(
+        "--encoder_hidden_size",
+        type=int,
+        default=128,
+        help="encoder_hidden_size if the encoder hidden size used in P tuninig/Prefix tuning.",
+    )
+    parser.add_argument(
+        "--model_name_or_path",
+        type=str,
+        help="Path to pretrained model or model identifier from huggingface.co/models.",
+        required=True,
+    )
+    parser.add_argument(
+        "--per_device_train_batch_size",
+        type=int,
+        default=8,
+        help="Batch size (per device) for the training dataloader.",
+    )
+    parser.add_argument(
+        "--per_device_eval_batch_size",
+        type=int,
+        default=8,
+        help="Batch size (per device) for the evaluation dataloader.",
+    )
+    parser.add_argument(
+        "--learning_rate",
+        type=float,
+        default=1e-3,
+        help="Initial learning rate (after the potential warmup period) to use.",
+    )
+    parser.add_argument("--num_train_epochs", type=int, default=3, help="Total number of training epochs to perform.")
+    parser.add_argument(
+        "--num_warmup_steps", type=int, default=0, help="Number of steps for the warmup in the lr scheduler."
+    )
+    parser.add_argument("--output_dir", type=str, default=None, help="Where to store the final model.")
+    parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.")
+    parser.add_argument(
+        "--peft_type",
+        type=str,
+        default="p_tuning",
+        help="The PEFT type to use.",
+        choices=["p_tuning", "prefix_tuning", "prompt_tuning"],
+    )
+    args = parser.parse_args()
+
+    assert args.output_dir is not None, "Need an `output_dir` to store the finetune model and verify."
+
+    return args
+
+
+def main():
+    args = parse_args()
+    ddp_scaler = DistributedDataParallelKwargs(find_unused_parameters=True)
+    accelerator = Accelerator(kwargs_handlers=[ddp_scaler])
+
+    task = "mrpc"
+
+    # If passed along, set the training seed now.
+    if args.seed is not None:
+        set_seed(args.seed)
+
+    if args.peft_type == "p_tuning":
+        peft_config = PromptEncoderConfig(
+            task_type="SEQ_CLS",
+            num_virtual_tokens=args.num_virtual_tokens,
+            encoder_hidden_size=args.encoder_hidden_size,
+        )
+    elif args.peft_type == "prefix_tuning":
+        peft_config = PrefixTuningConfig(
+            task_type="SEQ_CLS",
+            num_virtual_tokens=args.num_virtual_tokens,
+            encoder_hidden_size=args.encoder_hidden_size,
+        )
+    else:
+        peft_config = PromptTuningConfig(task_type="SEQ_CLS", num_virtual_tokens=args.num_virtual_tokens)
+
+    tokenizer_kwargs = {}
+
+    if any(k in args.model_name_or_path for k in ("gpt", "opt", "bloom")):
+        tokenizer_kwargs["padding_side"] = "left"
+    else:
+        tokenizer_kwargs["padding_side"] = "right"
+
+    tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path, **tokenizer_kwargs)
+    if tokenizer.pad_token_id is None:
+        tokenizer.pad_token_id = tokenizer.eos_token_id
+
+    datasets = load_dataset("glue", task)
+    metric = evaluate.load("glue", task)
+
+    def tokenize_function(examples):
+        # max_length=None => use the model max length (it's actually the default)
+        outputs = tokenizer(examples["sentence1"], examples["sentence2"], truncation=True, max_length=None)
+        return outputs
+
+    def collate_fn(examples):
+        return tokenizer.pad(examples, padding="longest", return_tensors="pt")
+
+    with accelerator.main_process_first():
+        tokenized_datasets = datasets.map(
+            tokenize_function,
+            batched=True,
+            remove_columns=["idx", "sentence1", "sentence2"],
+        )
+
+    # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the
+    # transformers library
+    tokenized_datasets = tokenized_datasets.rename_column("label", "labels")
+
+    # Instantiate dataloaders.
+    train_dataloader = DataLoader(
+        tokenized_datasets["train"], shuffle=True, collate_fn=collate_fn, batch_size=args.per_device_train_batch_size
+    )
+    eval_dataloader = DataLoader(
+        tokenized_datasets["validation"],
+        shuffle=False,
+        collate_fn=collate_fn,
+        batch_size=args.per_device_eval_batch_size,
+    )
+
+    model = AutoModelForSequenceClassification.from_pretrained(args.model_name_or_path)
+    model = get_peft_model(model, peft_config)
+    model.print_trainable_parameters()
+
+    if getattr(accelerator.state, "fsdp_plugin", None) is not None:
+        accelerator.state.fsdp_plugin.auto_wrap_policy = fsdp_auto_wrap_policy(model)
+        model = accelerator.prepare(model)
+
+    optimizer = AdamW(params=model.parameters(), lr=args.learning_rate)
+
+    # Instantiate scheduler
+    lr_scheduler = get_linear_schedule_with_warmup(
+        optimizer=optimizer,
+        num_warmup_steps=args.num_warmup_steps,
+        num_training_steps=(len(train_dataloader) * args.num_train_epochs),
+    )
+
+    if getattr(accelerator.state, "fsdp_plugin", None) is not None:
+        train_dataloader, eval_dataloader, optimizer, lr_scheduler = accelerator.prepare(
+            train_dataloader, eval_dataloader, optimizer, lr_scheduler
+        )
+    else:
+        model, train_dataloader, eval_dataloader, optimizer, lr_scheduler = accelerator.prepare(
+            model, train_dataloader, eval_dataloader, optimizer, lr_scheduler
+        )
+
+    for epoch in range(args.num_train_epochs):
+        model.train()
+        for step, batch in enumerate(tqdm(train_dataloader)):
+            outputs = model(**batch)
+            loss = outputs.loss
+            accelerator.backward(loss)
+            optimizer.step()
+            lr_scheduler.step()
+            optimizer.zero_grad()
+
+        model.eval()
+        samples_seen = 0
+        for step, batch in enumerate(tqdm(eval_dataloader)):
+            with torch.no_grad():
+                outputs = model(**batch)
+            predictions = outputs.logits.argmax(dim=-1)
+            predictions, references = accelerator.gather((predictions, batch["labels"]))
+            # If we are in a multiprocess environment, the last batch has duplicates
+            if accelerator.num_processes > 1:
+                if step == len(eval_dataloader) - 1:
+                    predictions = predictions[: len(eval_dataloader.dataset) - samples_seen]
+                    references = references[: len(eval_dataloader.dataset) - samples_seen]
+                else:
+                    samples_seen += references.shape[0]
+            metric.add_batch(
+                predictions=predictions,
+                references=references,
+            )
+        eval_metric = metric.compute()
+        accelerator.print(f"epoch {epoch}:", eval_metric)
+
+    accelerator.wait_for_everyone()
+    unwrapped_model = accelerator.unwrap_model(model)
+    unwrapped_model.save_pretrained(args.output_dir, state_dict=accelerator.get_state_dict(model))
+    if accelerator.is_main_process:
+        tokenizer.save_pretrained(args.output_dir)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/sequence_classification/prefix_tuning.ipynb b/examples/sequence_classification/prefix_tuning.ipynb
new file mode 100644
index 0000000..bd2fc1f
--- /dev/null
+++ b/examples/sequence_classification/prefix_tuning.ipynb
@@ -0,0 +1,710 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "a825ba6b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "===================================BUG REPORT===================================\n",
+      "Welcome to bitsandbytes. For bug reports, please submit your error trace to: https://github.com/TimDettmers/bitsandbytes/issues\n",
+      "For effortless bug reporting copy-paste your error into this form: https://docs.google.com/forms/d/e/1FAIpQLScPB8emS3Thkp66nvqwmjTEgxp8Y9ufuWTzFyr9kJ5AoI47dQ/viewform?usp=sf_link\n",
+      "================================================================================\n",
+      "CUDA SETUP: CUDA runtime path found: /home/sourab/miniconda3/envs/ml/lib/libcudart.so\n",
+      "CUDA SETUP: Highest compute capability among GPUs detected: 7.5\n",
+      "CUDA SETUP: Detected CUDA version 117\n",
+      "CUDA SETUP: Loading binary /home/sourab/miniconda3/envs/ml/lib/python3.10/site-packages/bitsandbytes/libbitsandbytes_cuda117.so...\n"
+     ]
+    }
+   ],
+   "source": [
+    "import argparse\n",
+    "import os\n",
+    "\n",
+    "import torch\n",
+    "from torch.optim import AdamW\n",
+    "from torch.utils.data import DataLoader\n",
+    "from peft import (\n",
+    "    get_peft_config,\n",
+    "    get_peft_model,\n",
+    "    get_peft_model_state_dict,\n",
+    "    set_peft_model_state_dict,\n",
+    "    PeftType,\n",
+    "    PrefixTuningConfig,\n",
+    "    PromptEncoderConfig,\n",
+    ")\n",
+    "\n",
+    "import evaluate\n",
+    "from datasets import load_dataset\n",
+    "from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed\n",
+    "from tqdm import tqdm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2bd7cbb2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "batch_size = 32\n",
+    "model_name_or_path = \"roberta-large\"\n",
+    "task = \"mrpc\"\n",
+    "peft_type = PeftType.PREFIX_TUNING\n",
+    "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "num_epochs = 20"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "33d9b62e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "peft_config = PrefixTuningConfig(task_type=\"SEQ_CLS\", num_virtual_tokens=20)\n",
+    "lr = 1e-2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "152b6177",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Found cached dataset glue (/home/sourab/.cache/huggingface/datasets/glue/mrpc/1.0.0/dacbe3125aa31d7f70367a07a8a9e72a5a0bfeb5fc42e75c9db75b96da6053ad)\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "be1eddbb9a7d4e6dae32fd026e167f96",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/3 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading cached processed dataset at /home/sourab/.cache/huggingface/datasets/glue/mrpc/1.0.0/dacbe3125aa31d7f70367a07a8a9e72a5a0bfeb5fc42e75c9db75b96da6053ad/cache-9fa7887f9eaa03ae.arrow\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b61574844b6c499b8960fd4d78c5e549",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/1 [00:00<?, ?ba/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading cached processed dataset at /home/sourab/.cache/huggingface/datasets/glue/mrpc/1.0.0/dacbe3125aa31d7f70367a07a8a9e72a5a0bfeb5fc42e75c9db75b96da6053ad/cache-7e7eacaa5160936d.arrow\n"
+     ]
+    }
+   ],
+   "source": [
+    "if any(k in model_name_or_path for k in (\"gpt\", \"opt\", \"bloom\")):\n",
+    "    padding_side = \"left\"\n",
+    "else:\n",
+    "    padding_side = \"right\"\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, padding_side=padding_side)\n",
+    "if getattr(tokenizer, \"pad_token_id\") is None:\n",
+    "    tokenizer.pad_token_id = tokenizer.eos_token_id\n",
+    "\n",
+    "datasets = load_dataset(\"glue\", task)\n",
+    "metric = evaluate.load(\"glue\", task)\n",
+    "\n",
+    "\n",
+    "def tokenize_function(examples):\n",
+    "    # max_length=None => use the model max length (it's actually the default)\n",
+    "    outputs = tokenizer(examples[\"sentence1\"], examples[\"sentence2\"], truncation=True, max_length=None)\n",
+    "    return outputs\n",
+    "\n",
+    "\n",
+    "tokenized_datasets = datasets.map(\n",
+    "    tokenize_function,\n",
+    "    batched=True,\n",
+    "    remove_columns=[\"idx\", \"sentence1\", \"sentence2\"],\n",
+    ")\n",
+    "\n",
+    "# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the\n",
+    "# transformers library\n",
+    "tokenized_datasets = tokenized_datasets.rename_column(\"label\", \"labels\")\n",
+    "\n",
+    "\n",
+    "def collate_fn(examples):\n",
+    "    return tokenizer.pad(examples, padding=\"longest\", return_tensors=\"pt\")\n",
+    "\n",
+    "\n",
+    "# Instantiate dataloaders.\n",
+    "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, collate_fn=collate_fn, batch_size=batch_size)\n",
+    "eval_dataloader = DataLoader(\n",
+    "    tokenized_datasets[\"validation\"], shuffle=False, collate_fn=collate_fn, batch_size=batch_size\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f6bc8144",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = AutoModelForSequenceClassification.from_pretrained(model_name_or_path, return_dict=True)\n",
+    "model = get_peft_model(model, peft_config)\n",
+    "model.print_trainable_parameters()\n",
+    "model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "af41c571",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimizer = AdamW(params=model.parameters(), lr=lr)\n",
+    "\n",
+    "# Instantiate scheduler\n",
+    "lr_scheduler = get_linear_schedule_with_warmup(\n",
+    "    optimizer=optimizer,\n",
+    "    num_warmup_steps=0.06 * (len(train_dataloader) * num_epochs),\n",
+    "    num_training_steps=(len(train_dataloader) * num_epochs),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "90993c93",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|                                                                                                  | 0/115 [00:00<?, ?it/s]You're using a RobertaTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:29<00:00,  3.87it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  8.32it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 0: {'accuracy': 0.7132352941176471, 'f1': 0.7876588021778584}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:26<00:00,  4.42it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  8.36it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 1: {'accuracy': 0.6838235294117647, 'f1': 0.8122270742358079}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:26<00:00,  4.41it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  8.35it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 2: {'accuracy': 0.8088235294117647, 'f1': 0.8717105263157895}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:26<00:00,  4.39it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  8.34it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 3: {'accuracy': 0.7549019607843137, 'f1': 0.8475609756097561}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:26<00:00,  4.37it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:01<00:00,  8.34it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 4: {'accuracy': 0.8480392156862745, 'f1': 0.8938356164383561}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [00:40<00:00,  2.87it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:06<00:00,  1.93it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 5: {'accuracy': 0.8651960784313726, 'f1': 0.9053356282271946}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:53<00:00,  1.01it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:07<00:00,  1.79it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 6: {'accuracy': 0.8700980392156863, 'f1': 0.9065255731922399}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:42<00:00,  1.12it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:05<00:00,  2.43it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 7: {'accuracy': 0.8676470588235294, 'f1': 0.9042553191489361}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:27<00:00,  1.31it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:05<00:00,  2.45it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 8: {'accuracy': 0.875, 'f1': 0.9103690685413005}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:29<00:00,  1.29it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:05<00:00,  2.48it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 9: {'accuracy': 0.8799019607843137, 'f1': 0.913884007029877}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:43<00:00,  1.11it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:06<00:00,  1.88it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 10: {'accuracy': 0.8725490196078431, 'f1': 0.902621722846442}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:53<00:00,  1.02it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:06<00:00,  2.02it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 11: {'accuracy': 0.875, 'f1': 0.9090909090909091}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:29<00:00,  1.28it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:04<00:00,  2.65it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 12: {'accuracy': 0.8823529411764706, 'f1': 0.9139784946236559}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:27<00:00,  1.31it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:05<00:00,  2.46it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 13: {'accuracy': 0.8602941176470589, 'f1': 0.9018932874354562}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:27<00:00,  1.31it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:05<00:00,  2.47it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 14: {'accuracy': 0.8700980392156863, 'f1': 0.9075043630017452}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:27<00:00,  1.31it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:05<00:00,  2.49it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 15: {'accuracy': 0.875, 'f1': 0.9087656529516995}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:27<00:00,  1.32it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:05<00:00,  2.49it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 16: {'accuracy': 0.8578431372549019, 'f1': 0.9003436426116839}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:27<00:00,  1.31it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:05<00:00,  2.22it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 17: {'accuracy': 0.8627450980392157, 'f1': 0.903448275862069}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:28<00:00,  1.31it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:04<00:00,  2.65it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 18: {'accuracy': 0.8700980392156863, 'f1': 0.9078260869565218}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████████████████████████████████████████████████████████████████████████████████████| 115/115 [01:27<00:00,  1.32it/s]\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:05<00:00,  2.45it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 19: {'accuracy': 0.8774509803921569, 'f1': 0.9125874125874125}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.to(device)\n",
+    "for epoch in range(num_epochs):\n",
+    "    model.train()\n",
+    "    for step, batch in enumerate(tqdm(train_dataloader)):\n",
+    "        batch.to(device)\n",
+    "        outputs = model(**batch)\n",
+    "        loss = outputs.loss\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        lr_scheduler.step()\n",
+    "        optimizer.zero_grad()\n",
+    "\n",
+    "    model.eval()\n",
+    "    for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+    "        batch.to(device)\n",
+    "        with torch.no_grad():\n",
+    "            outputs = model(**batch)\n",
+    "        predictions = outputs.logits.argmax(dim=-1)\n",
+    "        predictions, references = predictions, batch[\"labels\"]\n",
+    "        metric.add_batch(\n",
+    "            predictions=predictions,\n",
+    "            references=references,\n",
+    "        )\n",
+    "\n",
+    "    eval_metric = metric.compute()\n",
+    "    print(f\"epoch {epoch}:\", eval_metric)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7734299c",
+   "metadata": {},
+   "source": [
+    "## Share adapters on the 🤗 Hub"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "afaf42dd",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "CommitInfo(commit_url='https://huggingface.co/smangrul/roberta-large-peft-prefix-tuning/commit/a00e05a4c9a68e700221784f8e073c2e194637c3', commit_message='Upload model', commit_description='', oid='a00e05a4c9a68e700221784f8e073c2e194637c3', pr_url=None, pr_revision=None, pr_num=None)"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.push_to_hub(\"smangrul/roberta-large-peft-prefix-tuning\", use_auth_token=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "42b20e77",
+   "metadata": {},
+   "source": [
+    "## Load adapters from the Hub\n",
+    "\n",
+    "You can also directly load adapters from the Hub using the commands below:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "868e7580",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2ce57b4de8ae4f868115733abc2fb883",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading:   0%|          | 0.00/373 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Some weights of the model checkpoint at roberta-large were not used when initializing RobertaForSequenceClassification: ['roberta.pooler.dense.bias', 'lm_head.layer_norm.weight', 'lm_head.layer_norm.bias', 'lm_head.dense.weight', 'roberta.pooler.dense.weight', 'lm_head.bias', 'lm_head.decoder.weight', 'lm_head.dense.bias']\n",
+      "- This IS expected if you are initializing RobertaForSequenceClassification from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
+      "- This IS NOT expected if you are initializing RobertaForSequenceClassification from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
+      "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-large and are newly initialized: ['classifier.out_proj.weight', 'classifier.out_proj.bias', 'classifier.dense.bias', 'classifier.dense.weight']\n",
+      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ace158c926a44b31a9b0ea80411bd7a9",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading:   0%|          | 0.00/8.14M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|                                                                                                   | 0/13 [00:00<?, ?it/s]You're using a RobertaTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:06<00:00,  2.04it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'accuracy': 0.8774509803921569, 'f1': 0.9125874125874125}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "from peft import PeftModel, PeftConfig\n",
+    "from transformers import AutoModelForCausalLM, AutoTokenizer\n",
+    "\n",
+    "peft_model_id = \"smangrul/roberta-large-peft-prefix-tuning\"\n",
+    "config = PeftConfig.from_pretrained(peft_model_id)\n",
+    "inference_model = AutoModelForSequenceClassification.from_pretrained(config.base_model_name_or_path)\n",
+    "tokenizer = AutoTokenizer.from_pretrained(config.base_model_name_or_path)\n",
+    "\n",
+    "# Load the Lora model\n",
+    "inference_model = PeftModel.from_pretrained(inference_model, peft_model_id)\n",
+    "\n",
+    "inference_model.to(device)\n",
+    "inference_model.eval()\n",
+    "for step, batch in enumerate(tqdm(eval_dataloader)):\n",
+    "    batch.to(device)\n",
+    "    with torch.no_grad():\n",
+    "        outputs = inference_model(**batch)\n",
+    "    predictions = outputs.logits.argmax(dim=-1)\n",
+    "    predictions, references = predictions, batch[\"labels\"]\n",
+    "    metric.add_batch(\n",
+    "        predictions=predictions,\n",
+    "        references=references,\n",
+    "    )\n",
+    "\n",
+    "eval_metric = metric.compute()\n",
+    "print(eval_metric)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.5 (v3.10.5:f377153967, Jun  6 2022, 12:36:10) [Clang 13.0.0 (clang-1300.0.29.30)]"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/sequence_classification/requirements.txt b/examples/sequence_classification/requirements.txt
new file mode 100644
index 0000000..a59ab2e
--- /dev/null
+++ b/examples/sequence_classification/requirements.txt
@@ -0,0 +1,6 @@
+transformers
+accelerate
+evaluate
+tqdm
+datasets
+torchao
\ No newline at end of file
diff --git a/examples/sft/README.md b/examples/sft/README.md
new file mode 100644
index 0000000..3204a67
--- /dev/null
+++ b/examples/sft/README.md
@@ -0,0 +1,42 @@
+# Supervised Fine-tuning (SFT) with PEFT
+In this example, we'll see how to use [PEFT](https://github.com/huggingface/peft) to perform SFT using PEFT on various distributed setups.
+
+## Single GPU SFT with QLoRA
+QLoRA uses 4-bit quantization of the base model to drastically reduce the GPU memory consumed by the base model while using LoRA for parameter-efficient fine-tuning. The command to use QLoRA is present at [run_peft.sh](https://github.com/huggingface/peft/blob/main/examples/sft/run_peft.sh).
+
+Note: 
+1. At present, `use_reentrant` needs to be `True` when using gradient checkpointing with QLoRA or else QLoRA leads to high GPU memory consumption.
+
+
+## Single GPU SFT with QLoRA using Unsloth
+[Unsloth](https://github.com/unslothai/unsloth) enables finetuning Mistral/Llama 2-5x faster with 70% less memory. It achieves this by reducing data upcasting, using Flash Attention 2, custom Triton kernels for RoPE embeddings, RMS Layernorm & Cross Entropy Loss and manual clever autograd computation to reduce the FLOPs during QLoRA finetuning. Below is the list of the optimizations from the Unsloth blogpost [mistral-benchmark](https://unsloth.ai/blog/mistral-benchmark). The command to use QLoRA with Unsloth is present at [run_unsloth_peft.sh](https://github.com/huggingface/peft/blob/main/examples/sft/run_unsloth_peft.sh).
+
+<div class="flex justify-center">
+    <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/peft/Unsloth.png"/>
+</div>
+<small>Optimization in Unsloth to speed up QLoRA finetuning while reducing GPU memory usage</small>
+
+## Multi-GPU SFT with QLoRA
+To speed up QLoRA finetuning when you have access to multiple GPUs, look at the launch command at [run_peft_multigpu.sh](https://github.com/huggingface/peft/blob/main/examples/sft/run_peft_multigpu.sh). This example to performs DDP on 8 GPUs.
+
+Note: 
+1. At present, `use_reentrant` needs to be `False` when using gradient checkpointing with Multi-GPU QLoRA else it will lead to errors. However, this leads to huge GPU memory consumption. 
+
+## Multi-GPU SFT with LoRA and DeepSpeed
+When you have access to multiple GPUs, it would be better to use normal LoRA with DeepSpeed/FSDP. To use LoRA with DeepSpeed, refer to the docs at [PEFT with DeepSpeed](https://huggingface.co/docs/peft/accelerate/deepspeed).
+
+
+## Multi-GPU SFT with LoRA and FSDP
+When you have access to multiple GPUs, it would be better to use normal LoRA with DeepSpeed/FSDP. To use LoRA with FSDP, refer to the docs at [PEFT with FSDP](https://huggingface.co/docs/peft/accelerate/fsdp).
+
+Note: FSDP is currently not compatible with 8bit bitsandbytes quantization.
+
+
+## Multi-GPU SFT with LoRA and FSDP for GPT-QModel:
+As in [Multi-GPU SFT with LoRA and FSDP](https://github.com/huggingface/peft/blob/main/examples/sft/README.md#multi-gpu-sft-with-lora-and-fsdp), we also support other quantization methods like GPT-QModel. You may need to install [GPT-QModel](https://github.com/ModelCloud/GPTQModel) >= v7.0.0 or from source. Here is the launch command for reference: [run_peft_fsdp_gptq.sh]. For the `--model_name_or_path` argument, it is important to pass a model that is already quantized with GPT-QModel, like `"hugging-quants/Meta-Llama-3.1-8B-Instruct-GPTQ-INT4"`.
+
+Note: there is a bug in transformers v4.53.0 for this case, please skip this transformers version.
+
+## Tip
+
+Generally try to upgrade to the latest package versions for best results, especially when it comes to `bitsandbytes`, `accelerate`, `transformers`, `trl`, and `peft`.
diff --git a/examples/sft/configs/deepspeed_config.yaml b/examples/sft/configs/deepspeed_config.yaml
new file mode 100644
index 0000000..56eef6e
--- /dev/null
+++ b/examples/sft/configs/deepspeed_config.yaml
@@ -0,0 +1,23 @@
+compute_environment: LOCAL_MACHINE                                                                                                                                           
+debug: false
+deepspeed_config:
+  deepspeed_multinode_launcher: standard
+  gradient_accumulation_steps: 4
+  offload_optimizer_device: none
+  offload_param_device: none
+  zero3_init_flag: true
+  zero3_save_16bit_model: true
+  zero_stage: 3
+distributed_type: DEEPSPEED
+downcast_bf16: 'no'
+machine_rank: 0
+main_training_function: main
+mixed_precision: bf16
+num_machines: 1
+num_processes: 8
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false
\ No newline at end of file
diff --git a/examples/sft/configs/deepspeed_config_z3_qlora.yaml b/examples/sft/configs/deepspeed_config_z3_qlora.yaml
new file mode 100644
index 0000000..07dddce
--- /dev/null
+++ b/examples/sft/configs/deepspeed_config_z3_qlora.yaml
@@ -0,0 +1,22 @@
+compute_environment: LOCAL_MACHINE                                                                                                                                           
+debug: false
+deepspeed_config:
+  deepspeed_multinode_launcher: standard
+  offload_optimizer_device: none
+  offload_param_device: none
+  zero3_init_flag: true
+  zero3_save_16bit_model: true
+  zero_stage: 3
+distributed_type: DEEPSPEED
+downcast_bf16: 'no'
+machine_rank: 0
+main_training_function: main
+mixed_precision: bf16
+num_machines: 1
+num_processes: 2
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false
\ No newline at end of file
diff --git a/examples/sft/configs/fsdp_config.yaml b/examples/sft/configs/fsdp_config.yaml
new file mode 100644
index 0000000..7cccb74
--- /dev/null
+++ b/examples/sft/configs/fsdp_config.yaml
@@ -0,0 +1,25 @@
+compute_environment: LOCAL_MACHINE
+debug: false
+distributed_type: FSDP
+downcast_bf16: 'no'
+fsdp_config:
+  fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
+  fsdp_backward_prefetch: BACKWARD_PRE
+  fsdp_cpu_ram_efficient_loading: true
+  fsdp_forward_prefetch: false
+  fsdp_offload_params: false
+  fsdp_sharding_strategy: FULL_SHARD
+  fsdp_state_dict_type: SHARDED_STATE_DICT
+  fsdp_sync_module_states: true
+  fsdp_use_orig_params: false
+machine_rank: 0
+main_training_function: main
+mixed_precision: bf16
+num_machines: 1
+num_processes: 8
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false
\ No newline at end of file
diff --git a/examples/sft/configs/fsdp_config_qlora.yaml b/examples/sft/configs/fsdp_config_qlora.yaml
new file mode 100644
index 0000000..f28a0f1
--- /dev/null
+++ b/examples/sft/configs/fsdp_config_qlora.yaml
@@ -0,0 +1,25 @@
+compute_environment: LOCAL_MACHINE                                                                                                                                           
+debug: false                                                                                                                                                                 
+distributed_type: FSDP
+downcast_bf16: 'no'
+fsdp_config:
+  fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
+  fsdp_backward_prefetch: BACKWARD_PRE
+  fsdp_cpu_ram_efficient_loading: true
+  fsdp_forward_prefetch: false
+  fsdp_offload_params: true
+  fsdp_sharding_strategy: FULL_SHARD
+  fsdp_state_dict_type: SHARDED_STATE_DICT
+  fsdp_sync_module_states: true
+  fsdp_use_orig_params: false
+machine_rank: 0
+main_training_function: main
+mixed_precision: 'no'
+num_machines: 1
+num_processes: 2
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false
\ No newline at end of file
diff --git a/examples/sft/requirements.txt b/examples/sft/requirements.txt
new file mode 100644
index 0000000..752b697
--- /dev/null
+++ b/examples/sft/requirements.txt
@@ -0,0 +1,25 @@
+git+https://github.com/huggingface/transformers
+git+https://github.com/huggingface/accelerate
+git+https://github.com/huggingface/peft
+git+https://github.com/huggingface/trl
+git+https://github.com/huggingface/datatrove.git
+unsloth[conda]@git+https://github.com/unslothai/unsloth.git
+deepspeed
+PyGithub
+flash-attn
+huggingface-hub
+evaluate
+datasets
+bitsandbytes
+einops
+wandb
+tensorboard
+tiktoken
+pandas
+numpy
+scipy
+matplotlib
+sentencepiece
+nltk
+xformers
+hf_transfer
\ No newline at end of file
diff --git a/examples/sft/requirements_colab.txt b/examples/sft/requirements_colab.txt
new file mode 100644
index 0000000..b8c375d
--- /dev/null
+++ b/examples/sft/requirements_colab.txt
@@ -0,0 +1,25 @@
+git+https://github.com/huggingface/transformers
+git+https://github.com/huggingface/accelerate
+git+https://github.com/huggingface/peft
+git+https://github.com/huggingface/trl
+unsloth[colab_ampere] @ git+https://github.com/unslothai/unsloth.git
+datasets
+deepspeed
+PyGithub
+flash-attn
+huggingface-hub
+evaluate
+bitsandbytes
+einops
+wandb
+tensorboard
+tiktoken
+pandas
+numpy
+scipy
+matplotlib
+sentencepiece
+nltk
+xformers
+git+https://github.com/huggingface/datatrove.git
+hf_transfer
\ No newline at end of file
diff --git a/examples/sft/requirements_xpu.txt b/examples/sft/requirements_xpu.txt
new file mode 100644
index 0000000..9e5918b
--- /dev/null
+++ b/examples/sft/requirements_xpu.txt
@@ -0,0 +1,22 @@
+git+https://github.com/huggingface/transformers
+git+https://github.com/huggingface/accelerate
+git+https://github.com/huggingface/peft
+git+https://github.com/huggingface/trl
+git+https://github.com/huggingface/datatrove.git
+deepspeed
+PyGithub
+huggingface-hub
+evaluate
+datasets
+bitsandbytes
+einops
+wandb
+tensorboard
+tiktoken
+pandas
+numpy
+scipy
+matplotlib
+sentencepiece
+nltk
+hf_transfer
\ No newline at end of file
diff --git a/examples/sft/run_peft.sh b/examples/sft/run_peft.sh
new file mode 100644
index 0000000..daa29f1
--- /dev/null
+++ b/examples/sft/run_peft.sh
@@ -0,0 +1,41 @@
+python train.py \
+--seed 100 \
+--model_name_or_path "mistralai/Mistral-7B-v0.1" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_length 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "mistral-sft-lora" \
+--per_device_train_batch_size 8 \
+--per_device_eval_batch_size 8 \
+--gradient_accumulation_steps 8 \
+--gradient_checkpointing True \
+--use_reentrant True \
+--dataset_text_field "content" \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "all-linear" \
+--use_4bit_quantization True \
+--use_nested_quant True \
+--bnb_4bit_compute_dtype "bfloat16" \
+--use_flash_attn True
diff --git a/examples/sft/run_peft_deepspeed.sh b/examples/sft/run_peft_deepspeed.sh
new file mode 100644
index 0000000..8c2bcb1
--- /dev/null
+++ b/examples/sft/run_peft_deepspeed.sh
@@ -0,0 +1,39 @@
+accelerate launch --config_file "configs/deepspeed_config.yaml"  train.py \
+--seed 100 \
+--model_name_or_path "meta-llama/Llama-2-70b-hf" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_length 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "mistral-sft-lora-deepspeed" \
+--per_device_train_batch_size 8 \
+--per_device_eval_batch_size 8 \
+--gradient_accumulation_steps 4 \
+--gradient_checkpointing True \
+--use_reentrant False \
+--dataset_text_field "content" \
+--use_flash_attn True \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "all-linear" \
+--use_4bit_quantization False
diff --git a/examples/sft/run_peft_fsdp.sh b/examples/sft/run_peft_fsdp.sh
new file mode 100644
index 0000000..82c595d
--- /dev/null
+++ b/examples/sft/run_peft_fsdp.sh
@@ -0,0 +1,39 @@
+accelerate launch --config_file "configs/fsdp_config.yaml"  train.py \
+--seed 100 \
+--model_name_or_path "meta-llama/Llama-2-70b-hf" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_length 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "mistral-sft-lora-fsdp" \
+--per_device_train_batch_size 8 \
+--per_device_eval_batch_size 8 \
+--gradient_accumulation_steps 4 \
+--gradient_checkpointing True \
+--use_reentrant False \
+--dataset_text_field "content" \
+--use_flash_attn True \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "all-linear" \
+--use_4bit_quantization False
\ No newline at end of file
diff --git a/examples/sft/run_peft_fsdp_gptq.sh b/examples/sft/run_peft_fsdp_gptq.sh
new file mode 100644
index 0000000..9f0939e
--- /dev/null
+++ b/examples/sft/run_peft_fsdp_gptq.sh
@@ -0,0 +1,36 @@
+accelerate launch --config_file "configs/fsdp_config.yaml"  train.py \
+--seed 100 \
+--model_name_or_path "hugging-quants/Meta-Llama-3.1-8B-Instruct-GPTQ-INT4" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_length 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "llama3-8B-gptq-sft-lora-fsdp" \
+--per_device_train_batch_size 8 \
+--per_device_eval_batch_size 8 \
+--gradient_accumulation_steps 4 \
+--gradient_checkpointing True \
+--use_reentrant False \
+--dataset_text_field "content" \
+--use_flash_attn True \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "q_proj,k_proj,v_proj,o_proj,up_proj,gate_proj" \
+--use_4bit_quantization False
\ No newline at end of file
diff --git a/examples/sft/run_peft_multigpu.sh b/examples/sft/run_peft_multigpu.sh
new file mode 100644
index 0000000..797df71
--- /dev/null
+++ b/examples/sft/run_peft_multigpu.sh
@@ -0,0 +1,41 @@
+torchrun --nproc_per_node 8 --nnodes 1 train.py \
+--seed 100 \
+--model_name_or_path "mistralai/Mistral-7B-v0.1" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_length 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "mistral-sft-lora-multigpu" \
+--per_device_train_batch_size 8 \
+--per_device_eval_batch_size 8 \
+--gradient_accumulation_steps 8 \
+--gradient_checkpointing True \
+--use_reentrant False \
+--dataset_text_field "content" \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "all-linear" \
+--use_4bit_quantization True \
+--use_nested_quant True \
+--bnb_4bit_compute_dtype "bfloat16" \
+--use_flash_attn True
diff --git a/examples/sft/run_peft_qlora_deepspeed_stage3.sh b/examples/sft/run_peft_qlora_deepspeed_stage3.sh
new file mode 100644
index 0000000..9c0fa3a
--- /dev/null
+++ b/examples/sft/run_peft_qlora_deepspeed_stage3.sh
@@ -0,0 +1,42 @@
+accelerate launch --config_file "configs/deepspeed_config_z3_qlora.yaml"  train.py \
+--seed 100 \
+--model_name_or_path "meta-llama/Llama-2-70b-hf" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_length 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "llama-sft-qlora-dsz3" \
+--per_device_train_batch_size 2 \
+--per_device_eval_batch_size 2 \
+--gradient_accumulation_steps 2 \
+--gradient_checkpointing True \
+--use_reentrant True \
+--dataset_text_field "content" \
+--use_flash_attn True \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "all-linear" \
+--use_4bit_quantization True \
+--use_nested_quant True \
+--bnb_4bit_compute_dtype "bfloat16" \
+--bnb_4bit_quant_storage_dtype "bfloat16"
diff --git a/examples/sft/run_peft_qlora_fsdp.sh b/examples/sft/run_peft_qlora_fsdp.sh
new file mode 100644
index 0000000..ca448cf
--- /dev/null
+++ b/examples/sft/run_peft_qlora_fsdp.sh
@@ -0,0 +1,42 @@
+accelerate launch --config_file "configs/fsdp_config_qlora.yaml"  train.py \
+--seed 100 \
+--model_name_or_path "meta-llama/Llama-2-70b-hf" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_length 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "llama-sft-qlora-fsdp" \
+--per_device_train_batch_size 2 \
+--per_device_eval_batch_size 2 \
+--gradient_accumulation_steps 2 \
+--gradient_checkpointing True \
+--use_reentrant True \
+--dataset_text_field "content" \
+--use_flash_attn True \
+--use_peft_lora True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "all-linear" \
+--use_4bit_quantization True \
+--use_nested_quant True \
+--bnb_4bit_compute_dtype "bfloat16" \
+--bnb_4bit_quant_storage_dtype "bfloat16"
\ No newline at end of file
diff --git a/examples/sft/run_unsloth_peft.sh b/examples/sft/run_unsloth_peft.sh
new file mode 100644
index 0000000..608a1d9
--- /dev/null
+++ b/examples/sft/run_unsloth_peft.sh
@@ -0,0 +1,42 @@
+python train.py \
+--seed 100 \
+--model_name_or_path "mistralai/Mistral-7B-v0.1" \
+--dataset_name "smangrul/ultrachat-10k-chatml" \
+--chat_template_format "chatml" \
+--add_special_tokens False \
+--append_concat_token False \
+--splits "train,test" \
+--max_length 2048 \
+--num_train_epochs 1 \
+--logging_steps 5 \
+--log_level "info" \
+--logging_strategy "steps" \
+--eval_strategy "epoch" \
+--save_strategy "epoch" \
+--push_to_hub \
+--hub_private_repo True \
+--hub_strategy "every_save" \
+--bf16 True \
+--packing True \
+--learning_rate 1e-4 \
+--lr_scheduler_type "cosine" \
+--weight_decay 1e-4 \
+--warmup_steps 0 \
+--max_grad_norm 1.0 \
+--output_dir "mistral-sft-lora-unsloth" \
+--per_device_train_batch_size 8 \
+--per_device_eval_batch_size 8 \
+--gradient_accumulation_steps 8 \
+--gradient_checkpointing True \
+--use_reentrant True \
+--dataset_text_field "content" \
+--use_peft_lora True \
+--use_unsloth True \
+--lora_r 8 \
+--lora_alpha 16 \
+--lora_dropout 0.1 \
+--lora_target_modules "q_proj,k_proj,v_proj,o_proj,down_proj,up_proj,gate_proj" \
+--use_4bit_quantization True \
+--use_nested_quant True \
+--bnb_4bit_compute_dtype "bfloat16" \
+--use_flash_attn True
diff --git a/examples/sft/train.py b/examples/sft/train.py
new file mode 100644
index 0000000..921ae99
--- /dev/null
+++ b/examples/sft/train.py
@@ -0,0 +1,156 @@
+import os
+import sys
+from dataclasses import dataclass, field
+from typing import Optional
+
+from transformers import HfArgumentParser, set_seed
+from trl import SFTConfig, SFTTrainer
+from utils import create_and_prepare_model, create_datasets
+
+
+# Define and parse arguments.
+@dataclass
+class ModelArguments:
+    """
+    Arguments pertaining to which model/config/tokenizer we are going to fine-tune from.
+    """
+
+    model_name_or_path: str = field(
+        metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"}
+    )
+    chat_template_format: Optional[str] = field(
+        default="none",
+        metadata={
+            "help": "chatml|zephyr|none. Pass `none` if the dataset is already formatted with the chat template."
+        },
+    )
+    lora_alpha: Optional[int] = field(default=16)
+    lora_dropout: Optional[float] = field(default=0.1)
+    lora_r: Optional[int] = field(default=64)
+    lora_target_modules: Optional[str] = field(
+        default="q_proj,k_proj,v_proj,o_proj,down_proj,up_proj,gate_proj",
+        metadata={"help": "comma separated list of target modules to apply LoRA layers to"},
+    )
+    use_nested_quant: Optional[bool] = field(
+        default=False,
+        metadata={"help": "Activate nested quantization for 4bit base models"},
+    )
+    bnb_4bit_compute_dtype: Optional[str] = field(
+        default="float16",
+        metadata={"help": "Compute dtype for 4bit base models"},
+    )
+    bnb_4bit_quant_storage_dtype: Optional[str] = field(
+        default="uint8",
+        metadata={"help": "Quantization storage dtype for 4bit base models"},
+    )
+    bnb_4bit_quant_type: Optional[str] = field(
+        default="nf4",
+        metadata={"help": "Quantization type fp4 or nf4"},
+    )
+    use_flash_attn: Optional[bool] = field(
+        default=False,
+        metadata={"help": "Enables Flash attention for training."},
+    )
+    use_peft_lora: Optional[bool] = field(
+        default=False,
+        metadata={"help": "Enables PEFT LoRA for training."},
+    )
+    use_8bit_quantization: Optional[bool] = field(
+        default=False,
+        metadata={"help": "Enables loading model in 8bit."},
+    )
+    use_4bit_quantization: Optional[bool] = field(
+        default=False,
+        metadata={"help": "Enables loading model in 4bit."},
+    )
+    use_reentrant: Optional[bool] = field(
+        default=False,
+        metadata={"help": "Gradient Checkpointing param. Refer the related docs"},
+    )
+    use_unsloth: Optional[bool] = field(
+        default=False,
+        metadata={"help": "Enables UnSloth for training."},
+    )
+
+
+@dataclass
+class DataTrainingArguments:
+    dataset_name: Optional[str] = field(
+        default="timdettmers/openassistant-guanaco",
+        metadata={"help": "The preference dataset to use."},
+    )
+    append_concat_token: Optional[bool] = field(
+        default=False,
+        metadata={"help": "If True, appends `eos_token_id` at the end of each sample being packed."},
+    )
+    add_special_tokens: Optional[bool] = field(
+        default=False,
+        metadata={"help": "If True, tokenizers adds special tokens to each sample being packed."},
+    )
+    splits: Optional[str] = field(
+        default="train,test",
+        metadata={"help": "Comma separate list of the splits to use from the dataset."},
+    )
+
+
+def main(model_args, data_args, training_args):
+    # Set seed for reproducibility
+    set_seed(training_args.seed)
+
+    # model
+    model, peft_config, tokenizer = create_and_prepare_model(model_args, data_args, training_args)
+
+    # gradient ckpt
+    model.config.use_cache = not training_args.gradient_checkpointing
+    training_args.gradient_checkpointing = training_args.gradient_checkpointing and not model_args.use_unsloth
+    if training_args.gradient_checkpointing:
+        training_args.gradient_checkpointing_kwargs = {"use_reentrant": model_args.use_reentrant}
+
+    training_args.dataset_kwargs = {
+        "append_concat_token": data_args.append_concat_token,
+        "add_special_tokens": data_args.add_special_tokens,
+    }
+
+    # datasets
+    train_dataset, eval_dataset = create_datasets(
+        tokenizer,
+        data_args,
+        training_args,
+        apply_chat_template=model_args.chat_template_format != "none",
+    )
+
+    # trainer
+    trainer = SFTTrainer(
+        model=model,
+        processing_class=tokenizer,
+        args=training_args,
+        train_dataset=train_dataset,
+        eval_dataset=eval_dataset,
+        peft_config=peft_config,
+    )
+    trainer.accelerator.print(f"{trainer.model}")
+    if hasattr(trainer.model, "print_trainable_parameters"):
+        trainer.model.print_trainable_parameters()
+
+    # train
+    checkpoint = None
+    if training_args.resume_from_checkpoint is not None:
+        checkpoint = training_args.resume_from_checkpoint
+    trainer.train(resume_from_checkpoint=checkpoint)
+
+    # saving final model
+    if trainer.is_fsdp_enabled:
+        trainer.accelerator.state.fsdp_plugin.set_state_dict_type("FULL_STATE_DICT")
+    trainer.save_model()
+
+
+if __name__ == "__main__":
+    parser = HfArgumentParser((ModelArguments, DataTrainingArguments, SFTConfig))
+    if len(sys.argv) == 2 and sys.argv[1].endswith(".json"):
+        # If we pass only one argument to the script and it's the path to a json file,
+        # let's parse it to get our arguments.
+        model_args, data_args, training_args = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))
+    else:
+        model_args, data_args, training_args = parser.parse_args_into_dataclasses()
+    model_args.max_length = training_args.max_length
+    main(model_args, data_args, training_args)
diff --git a/examples/sft/utils.py b/examples/sft/utils.py
new file mode 100644
index 0000000..2fcb8da
--- /dev/null
+++ b/examples/sft/utils.py
@@ -0,0 +1,219 @@
+import os
+from enum import Enum
+
+import packaging.version
+import torch
+import transformers
+from datasets import DatasetDict, load_dataset, load_from_disk
+from datasets.builder import DatasetGenerationError
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    BitsAndBytesConfig,
+)
+
+from peft import LoraConfig
+
+
+DEFAULT_CHATML_CHAT_TEMPLATE = "{% for message in messages %}\n{{'<|im_start|>' + message['role'] + '\n' + message['content'] + '<|im_end|>' + '\n'}}{% if loop.last and add_generation_prompt %}{{'<|im_start|>assistant\n' }}{% endif %}{% endfor %}"
+DEFAULT_ZEPHYR_CHAT_TEMPLATE = "{% for message in messages %}\n{% if message['role'] == 'user' %}\n{{ '<|user|>\n' + message['content'] + eos_token }}\n{% elif message['role'] == 'system' %}\n{{ '<|system|>\n' + message['content'] + eos_token }}\n{% elif message['role'] == 'assistant' %}\n{{ '<|assistant|>\n'  + message['content'] + eos_token }}\n{% endif %}\n{% if loop.last and add_generation_prompt %}\n{{ '<|assistant|>' }}\n{% endif %}\n{% endfor %}"
+
+
+class ZephyrSpecialTokens(str, Enum):
+    user = "<|user|>"
+    assistant = "<|assistant|>"
+    system = "<|system|>"
+    eos_token = "</s>"
+    bos_token = "<s>"
+    pad_token = "<pad>"
+
+    @classmethod
+    def list(cls):
+        return [c.value for c in cls]
+
+
+class ChatmlSpecialTokens(str, Enum):
+    user = "<|im_start|>user"
+    assistant = "<|im_start|>assistant"
+    system = "<|im_start|>system"
+    eos_token = "<|im_end|>"
+    bos_token = "<s>"
+    pad_token = "<pad>"
+
+    @classmethod
+    def list(cls):
+        return [c.value for c in cls]
+
+
+def create_datasets(tokenizer, data_args, training_args, apply_chat_template=False):
+    def preprocess(samples):
+        batch = []
+        for conversation in samples["messages"]:
+            batch.append(tokenizer.apply_chat_template(conversation, tokenize=False))
+        return {"content": batch}
+
+    raw_datasets = DatasetDict()
+    for split in data_args.splits.split(","):
+        try:
+            # Try first if dataset on a Hub repo
+            dataset = load_dataset(data_args.dataset_name, split=split)
+        except DatasetGenerationError:
+            # If not, check local dataset
+            dataset = load_from_disk(os.path.join(data_args.dataset_name, split))
+
+        if "train" in split:
+            raw_datasets["train"] = dataset
+        elif "test" in split:
+            raw_datasets["test"] = dataset
+        else:
+            raise ValueError(f"Split type {split} not recognized as one of test or train.")
+
+    if apply_chat_template:
+        raw_datasets = raw_datasets.map(
+            preprocess,
+            batched=True,
+            remove_columns=raw_datasets["train"].column_names,
+        )
+
+    train_data = raw_datasets["train"]
+    valid_data = raw_datasets["test"]
+    print(f"Size of the train set: {len(train_data)}. Size of the validation set: {len(valid_data)}")
+    print(f"A sample of train dataset: {train_data[0]}")
+
+    return train_data, valid_data
+
+
+def create_and_prepare_model(args, data_args, training_args):
+    if args.use_unsloth:
+        from unsloth import FastLanguageModel
+    bnb_config = None
+    quant_storage_dtype = None
+
+    if (
+        torch.distributed.is_available()
+        and torch.distributed.is_initialized()
+        and torch.distributed.get_world_size() > 1
+        and args.use_unsloth
+    ):
+        raise NotImplementedError("Unsloth is not supported in distributed training")
+
+    if args.use_4bit_quantization and args.use_8bit_quantization:
+        raise ValueError("You configured 4bit and 8bit quantization at the same time, please choose only one of them.")
+    elif args.use_4bit_quantization:
+        compute_dtype = getattr(torch, args.bnb_4bit_compute_dtype)
+        quant_storage_dtype = getattr(torch, args.bnb_4bit_quant_storage_dtype)
+
+        bnb_config = BitsAndBytesConfig(
+            load_in_4bit=args.use_4bit_quantization,
+            bnb_4bit_quant_type=args.bnb_4bit_quant_type,
+            bnb_4bit_compute_dtype=compute_dtype,
+            bnb_4bit_use_double_quant=args.use_nested_quant,
+            bnb_4bit_quant_storage=quant_storage_dtype,
+        )
+
+        if compute_dtype == torch.float16 and args.use_4bit_quantization:
+            major, _ = torch.cuda.get_device_capability()
+            if major >= 8:
+                print("=" * 80)
+                print("Your GPU supports bfloat16, you can accelerate training with the argument --bf16")
+                print("=" * 80)
+    elif args.use_8bit_quantization:
+        bnb_config = BitsAndBytesConfig(load_in_8bit=args.use_8bit_quantization)
+
+    if args.use_unsloth:
+        if torch.xpu.is_available():
+            raise NotImplementedError("XPU hasn't supported unsloth yet")
+        # Load model
+        model, _ = FastLanguageModel.from_pretrained(
+            model_name=args.model_name_or_path,
+            max_seq_length=training_args.max_length,
+            dtype=None,
+            load_in_4bit=args.use_4bit_quantization,
+        )
+    else:
+        dtype = quant_storage_dtype if quant_storage_dtype and quant_storage_dtype.is_floating_point else torch.float32
+
+        # Prepare model loading arguments
+        model_kwargs = {
+            "trust_remote_code": True,
+            "dtype": dtype,
+        }
+        if args.use_flash_attn:
+            if torch.xpu.is_available():
+                print("XPU hasn't supported flash_attn yet, use eager implementation instead.")
+                model_kwargs["attn_implementation"] = "eager"
+            else:
+                model_kwargs["attn_implementation"] = "flash_attention_2"
+
+        # Only add quantization_config if bnb_config is not None
+        if bnb_config is not None:
+            model_kwargs["quantization_config"] = bnb_config
+
+        model = AutoModelForCausalLM.from_pretrained(args.model_name_or_path, **model_kwargs)
+
+    peft_config = None
+    chat_template = None
+    if args.use_peft_lora and not args.use_unsloth:
+        peft_config = LoraConfig(
+            lora_alpha=args.lora_alpha,
+            lora_dropout=args.lora_dropout,
+            r=args.lora_r,
+            bias="none",
+            task_type="CAUSAL_LM",
+            target_modules=args.lora_target_modules.split(",")
+            if args.lora_target_modules != "all-linear"
+            else args.lora_target_modules,
+        )
+
+    special_tokens = None
+    chat_template = None
+    if args.chat_template_format == "chatml":
+        special_tokens = ChatmlSpecialTokens
+        chat_template = DEFAULT_CHATML_CHAT_TEMPLATE
+    elif args.chat_template_format == "zephyr":
+        special_tokens = ZephyrSpecialTokens
+        chat_template = DEFAULT_ZEPHYR_CHAT_TEMPLATE
+
+    if special_tokens is not None:
+        tokenizer = AutoTokenizer.from_pretrained(
+            args.model_name_or_path,
+            pad_token=special_tokens.pad_token.value,
+            bos_token=special_tokens.bos_token.value,
+            eos_token=special_tokens.eos_token.value,
+            additional_special_tokens=special_tokens.list(),
+            trust_remote_code=True,
+        )
+        tokenizer.chat_template = chat_template
+
+        # make embedding resizing configurable?
+        # Transformers 4.46.0+ defaults uses mean_resizing by default, which fails with QLoRA + FSDP because the
+        # embedding could be on meta device, therefore, we set mean_resizing=False in that case (i.e. the status quo
+        # ante). See https://github.com/huggingface/accelerate/issues/1620.
+        uses_transformers_4_46 = packaging.version.parse(transformers.__version__) >= packaging.version.parse("4.46.0")
+        uses_fsdp = os.environ.get("ACCELERATE_USE_FSDP", "false").lower() == "true"
+        # Check if the model is quantized
+        is_quantized = (bnb_config is not None) or (getattr(model, "hf_quantizer", None) is not None)
+        if is_quantized and uses_fsdp and uses_transformers_4_46:
+            model.resize_token_embeddings(len(tokenizer), pad_to_multiple_of=8, mean_resizing=False)
+        else:
+            model.resize_token_embeddings(len(tokenizer), pad_to_multiple_of=8)
+    else:
+        tokenizer = AutoTokenizer.from_pretrained(args.model_name_or_path, trust_remote_code=True)
+        tokenizer.pad_token = tokenizer.eos_token
+
+    if args.use_unsloth:
+        # Do model patching and add fast LoRA weights
+        model = FastLanguageModel.get_peft_model(
+            model,
+            lora_alpha=args.lora_alpha,
+            lora_dropout=args.lora_dropout,
+            r=args.lora_r,
+            target_modules=args.lora_target_modules.split(",")
+            if args.lora_target_modules != "all-linear"
+            else args.lora_target_modules,
+            use_gradient_checkpointing=training_args.gradient_checkpointing,
+            random_state=training_args.seed,
+            max_seq_length=training_args.max_length,
+        )
+
+    return model, peft_config, tokenizer
diff --git a/examples/shira_finetuning/README.md b/examples/shira_finetuning/README.md
new file mode 100644
index 0000000..d8a30ec
--- /dev/null
+++ b/examples/shira_finetuning/README.md
@@ -0,0 +1,73 @@
+# Sparse High Rank Adapters
+
+## Introduction
+Sparse High Rank Adapters or [SHiRA](https://huggingface.co/papers/2406.13175) is an alternate type of adapter and has been found to have significant advantages over the low rank adapters. Specifically, SHiRA achieves better accuracy than LoRA for a variety of vision and language tasks. It also offers simpler and higher quality multi-adapter fusion by significantly reducing concept loss, a common problem faced by low rank adapters. SHiRA directly finetunes a small number of the base model's parameters to finetune the model on any adaptation task.
+
+## Quick start
+```python
+import torch
+from peft import ShiraConfig, get_peft_model
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from trl import SFTConfig, SFTTrainer
+from datasets import load_dataset
+
+model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m", dtype=torch.bfloat16, device_map="auto")
+tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m")
+dataset = load_dataset("imdb", split="train[:1%]")
+shira_config = ShiraConfig(
+    r=32,
+)
+peft_model = get_peft_model(model, shira_config)
+training_args = SFTConfig(dataset_text_field="text", max_length=128)
+trainer = SFTTrainer(
+    model=peft_model,
+    train_dataset=dataset,
+    processing_class=tokenizer,
+)
+trainer.train()
+peft_model.save_pretrained("shira-opt-350m")
+```
+
+For more options and a more detailed example code, you can refer to shira finetuning script.
+Run the script simply by running:
+```bash
+python3 examples/shira_finetuning/shira_finetuning.py --base_model facebook/opt-350m
+```
+
+If you want to run DDP by [accelerate](https://huggingface.co/docs/accelerate/en/index), please run `accelerate config` to set your ddp config, and run:
+```bash
+accelerate launch examples/shira_finetuning/shira_finetuning.py --base_model facebook/opt-350m
+```
+please add `--device_map cpu` if you want to run finetune on CPU.
+
+If you want to train SHiRA with a custom sparse mask function which requires custom keyword arguments, please see the definition of `custom_random_mask_function_with_custom_kwargs` function provided in the `shira_fintuning.py` script. You can run this code using the `--use_custom_random_mask_function_with_custom_kwargs` argument. Without this argument, SHiRA defaults to a random sparse mask. Please run the code as follows. :
+```bash
+python3 examples/shira_finetuning/shira_finetuning.py --base_model facebook/opt-350m --use_custom_random_mask_function_with_custom_kwargs
+
+```
+
+
+## Use the model
+You can load and use the model as any other 🤗 PEFT model
+```python
+from peft import PeftModel
+from transformers import AutoTokenizer, AutoModelForCausalLM
+model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m")
+tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m")
+shira_model = PeftModel.from_pretrained(model, "shira-opt-350m")
+```
+
+## Citation
+```
+@inproceedings{NEURIPS2024_18c0102c,
+ author = {Bhardwaj, Kartikeya and Pandey, Nilesh Prasad and Priyadarshi, Sweta and Ganapathy, Viswanath and Kadambi, Shreya and Esteves, Rafael and Borse, Shubhankar and Whatmough, Paul and Garrepalli, Risheek and Van Baalen, Mart and Teague, Harris and Nagel, Markus},
+ booktitle = {Advances in Neural Information Processing Systems},
+ editor = {A. Globerson and L. Mackey and D. Belgrave and A. Fan and U. Paquet and J. Tomczak and C. Zhang},
+ pages = {13685--13715},
+ publisher = {Curran Associates, Inc.},
+ title = {Sparse High Rank Adapters},
+ url = {https://proceedings.neurips.cc/paper_files/paper/2024/file/18c0102cb7f1a02c14f0929089b2e576-Paper-Conference.pdf},
+ volume = {37},
+ year = {2024}
+}
+```
diff --git a/examples/shira_finetuning/shira_finetuning.py b/examples/shira_finetuning/shira_finetuning.py
new file mode 100644
index 0000000..b6478fc
--- /dev/null
+++ b/examples/shira_finetuning/shira_finetuning.py
@@ -0,0 +1,217 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+
+import os
+from typing import Optional
+
+import torch
+import transformers
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoTokenizer, set_seed
+
+from peft import (
+    PeftModel,
+    ShiraConfig,
+    get_peft_model,
+)
+
+
+def train(
+    base_model: str = "path/to/model",
+    data_path: str = "yahma/alpaca-cleaned",
+    output_dir: str = "shira",
+    batch_size: int = 16,
+    num_epochs: int = 1,
+    learning_rate: float = 3e-4,
+    cutoff_len: int = 256,
+    val_set_size: int = 16,
+    eval_step: int = 100,
+    save_step: int = 100,
+    device_map: str = "auto",
+    shira_r: int = 32,
+    shira_target_modules: Optional[list[str]] = None,
+    dtype: str = "float16",
+    seed: Optional[int] = None,
+    use_custom_random_mask_function_with_custom_kwargs: Optional[bool] = False,
+):
+    # Set device_map to the right place when enabling DDP.
+    world_size = int(os.environ.get("WORLD_SIZE", "0")) or int(os.environ.get("PMI_SIZE", "0"))
+    if world_size > 1 and device_map != "cpu":
+        from accelerate import Accelerator
+
+        device_map = {"": Accelerator().process_index}
+    # Set seed
+    if seed is not None:
+        set_seed(seed)
+    model_kwargs = {"dtype": getattr(torch, dtype), "device_map": device_map}
+    model = AutoModelForCausalLM.from_pretrained(base_model, **model_kwargs)
+
+    tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
+    # For some tokenizer with no pad token like llama
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    def tokenize(prompt, add_eos_token=True):
+        result = tokenizer(
+            prompt,
+            truncation=True,
+            max_length=cutoff_len,
+            padding=False,
+            return_tensors=None,
+        )
+        if (
+            result["input_ids"][-1] != tokenizer.eos_token_id
+            and len(result["input_ids"]) < cutoff_len
+            and add_eos_token
+        ):
+            result["input_ids"].append(tokenizer.eos_token_id)
+            result["attention_mask"].append(1)
+
+        result["labels"] = result["input_ids"].copy()
+
+        return result
+
+    def generate_and_tokenize_prompt(example):
+        full_prompt = generate_prompt(example)
+        tokenized_full_prompt = tokenize(full_prompt)
+        return tokenized_full_prompt
+
+    def custom_random_mask_function_with_custom_kwargs(custom_arg):
+        def mask_fn(base_layer, r):
+            """
+            This mask function is similar to the random_mask provided in src/peft/tuners/shira/mask_functions.py except the seed is derived from custom_kwargs.
+            Please use this as an example to create your own custom sparse masks that may use custom_kwargs. Remember, for a pretrained weight with shape m, n,
+            mask_fn must return only one mask (shape: m, n) which must be binary 0 or 1 with num_shira_parameters = r(m+n) for linear layers. Device and dtype
+            of mask must be same as base layer's weight's device and dtype.
+            """
+            new_seed = custom_arg
+            shape = base_layer.weight.shape
+            num_shira_weights = r * (shape[0] + shape[1])
+            random_generator = torch.Generator()
+            random_generator.manual_seed(new_seed)
+
+            idx = (torch.randperm(base_layer.weight.numel(), generator=random_generator)[:num_shira_weights]).to(
+                base_layer.weight.device
+            )
+            val = torch.ones_like(idx.type(base_layer.weight.dtype))
+            mask = torch.zeros_like(base_layer.weight.view(1, -1))
+            mask = mask.scatter_(1, idx.unsqueeze(0), val.unsqueeze(0)).view(shape)
+
+            return mask
+
+        return mask_fn
+
+    mask_type = "random" if not use_custom_random_mask_function_with_custom_kwargs else "custom"
+    config = ShiraConfig(
+        r=shira_r,
+        mask_type=mask_type,
+        target_modules=shira_target_modules,
+        task_type="CAUSAL_LM",
+    )
+    if use_custom_random_mask_function_with_custom_kwargs:
+        custom_arg = 120
+        custom_mask_fn = custom_random_mask_function_with_custom_kwargs(custom_arg)
+        config.mask_fn = custom_mask_fn
+
+    model = get_peft_model(model, config)
+
+    data = load_dataset(data_path)
+
+    train_val = data["train"].train_test_split(test_size=val_set_size, shuffle=True, seed=42)
+    train_data = train_val["train"].shuffle().map(generate_and_tokenize_prompt)
+    val_data = train_val["test"].shuffle().map(generate_and_tokenize_prompt)
+
+    trainer = transformers.Trainer(
+        model=model,
+        train_dataset=train_data,
+        eval_dataset=val_data,
+        args=transformers.TrainingArguments(
+            per_device_train_batch_size=batch_size,
+            warmup_steps=100,
+            num_train_epochs=num_epochs,
+            learning_rate=learning_rate,
+            logging_steps=100,
+            optim="adamw_torch",
+            eval_strategy="steps",
+            save_strategy="steps",
+            eval_steps=eval_step,
+            save_steps=save_step,
+            output_dir=output_dir,
+            save_total_limit=3,
+            load_best_model_at_end=True,
+            ddp_find_unused_parameters=False if world_size > 1 else None,
+        ),
+        data_collator=transformers.DataCollatorForSeq2Seq(
+            tokenizer, pad_to_multiple_of=8, return_tensors="pt", padding=True
+        ),
+    )
+    trainer.train()
+    model.save_pretrained(output_dir)
+
+    # Delete the model and load it again from the checkpoint.
+    del model
+    model = AutoModelForCausalLM.from_pretrained(base_model, **model_kwargs)
+    model = PeftModel.from_pretrained(model, output_dir)
+
+
+def generate_prompt(example):
+    return f"""Below is an instruction that describes a task. Write a response that appropriately completes the request.
+            ### Instruction:
+            {example["instruction"]}
+            ### Response:
+            {example["output"]}"""
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--base_model", type=str, default="path/to/model")
+    parser.add_argument("--data_path", type=str, default="yahma/alpaca-cleaned")
+    parser.add_argument("--output_dir", type=str, default="shira")
+    parser.add_argument("--batch_size", type=int, default=16)
+    parser.add_argument("--num_epochs", type=int, default=1)
+    parser.add_argument("--learning_rate", type=float, default=3e-4)
+    parser.add_argument("--cutoff_len", type=int, default=256)
+    parser.add_argument("--val_set_size", type=int, default=16)
+    parser.add_argument("--eval_step", type=int, default=100)
+    parser.add_argument("--save_step", type=int, default=100)
+    parser.add_argument("--device_map", type=str, default="auto")
+    parser.add_argument("--shira_r", type=int, default=32)
+    parser.add_argument("--shira_target_modules", type=str, default=None)
+    parser.add_argument("--dtype", type=str, default="float16")
+    parser.add_argument("--seed", type=int, default=None)
+    parser.add_argument("--use_custom_random_mask_function_with_custom_kwargs", action="store_true")
+
+    args = parser.parse_args()
+
+    train(
+        base_model=args.base_model,
+        data_path=args.data_path,
+        output_dir=args.output_dir,
+        batch_size=args.batch_size,
+        num_epochs=args.num_epochs,
+        learning_rate=args.learning_rate,
+        cutoff_len=args.cutoff_len,
+        val_set_size=args.val_set_size,
+        eval_step=args.eval_step,
+        save_step=args.save_step,
+        device_map=args.device_map,
+        shira_r=args.shira_r,
+        shira_target_modules=args.shira_target_modules,
+        dtype=args.dtype,
+        seed=args.seed,
+        use_custom_random_mask_function_with_custom_kwargs=args.use_custom_random_mask_function_with_custom_kwargs,
+    )
diff --git a/examples/stable_diffusion/convert_sd_adapter_to_peft.py b/examples/stable_diffusion/convert_sd_adapter_to_peft.py
new file mode 100644
index 0000000..b692ba5
--- /dev/null
+++ b/examples/stable_diffusion/convert_sd_adapter_to_peft.py
@@ -0,0 +1,517 @@
+import argparse
+import json
+import logging
+import os
+from collections import Counter
+from dataclasses import dataclass
+from operator import attrgetter
+from typing import Optional, Union
+
+import safetensors
+import torch
+from diffusers import UNet2DConditionModel
+from torch import nn
+from transformers import CLIPTextModel
+
+from peft import LoHaConfig, LoKrConfig, LoraConfig, PeftType, get_peft_model, set_peft_model_state_dict
+from peft.tuners.lokr.layer import factorization
+
+
+logger = logging.getLogger(__name__)
+
+
+# Default kohya_ss LoRA replacement modules
+# https://github.com/kohya-ss/sd-scripts/blob/c924c47f374ac1b6e33e71f82948eb1853e2243f/networks/lora.py#L661
+UNET_TARGET_REPLACE_MODULE = ["Transformer2DModel", "Attention"]
+UNET_TARGET_REPLACE_MODULE_CONV2D_3X3 = ["ResnetBlock2D", "Downsample2D", "Upsample2D"]
+TEXT_ENCODER_TARGET_REPLACE_MODULE = ["CLIPAttention", "CLIPMLP"]
+PREFIX_UNET = "lora_unet"
+PREFIX_TEXT_ENCODER = "lora_te"
+
+
+@dataclass
+class LoRAInfo:
+    kohya_key: str
+    peft_key: str
+    alpha: Optional[float] = None
+    rank: Optional[int] = None
+    lora_A: Optional[torch.Tensor] = None
+    lora_B: Optional[torch.Tensor] = None
+
+    def peft_state_dict(self) -> dict[str, torch.Tensor]:
+        if self.lora_A is None or self.lora_B is None:
+            raise ValueError("At least one of lora_A or lora_B is None, they must both be provided")
+        return {
+            f"base_model.model.{self.peft_key}.lora_A.weight": self.lora_A,
+            f"base_model.model.{self.peft_key}.lora_B.weight": self.lora_B,
+        }
+
+
+@dataclass
+class LoHaInfo:
+    kohya_key: str
+    peft_key: str
+    alpha: Optional[float] = None
+    rank: Optional[int] = None
+    hada_w1_a: Optional[torch.Tensor] = None
+    hada_w1_b: Optional[torch.Tensor] = None
+    hada_w2_a: Optional[torch.Tensor] = None
+    hada_w2_b: Optional[torch.Tensor] = None
+    hada_t1: Optional[torch.Tensor] = None
+    hada_t2: Optional[torch.Tensor] = None
+
+    def peft_state_dict(self) -> dict[str, torch.Tensor]:
+        if self.hada_w1_a is None or self.hada_w1_b is None or self.hada_w2_a is None or self.hada_w2_b is None:
+            raise ValueError(
+                "At least one of hada_w1_a, hada_w1_b, hada_w2_a, hada_w2_b is missing, they all must be provided"
+            )
+        state_dict = {
+            f"base_model.model.{self.peft_key}.hada_w1_a": self.hada_w1_a,
+            f"base_model.model.{self.peft_key}.hada_w1_b": self.hada_w1_b,
+            f"base_model.model.{self.peft_key}.hada_w2_a": self.hada_w2_a,
+            f"base_model.model.{self.peft_key}.hada_w2_b": self.hada_w2_b,
+        }
+        if not (
+            (self.hada_t1 is None and self.hada_t2 is None) or (self.hada_t1 is not None and self.hada_t2 is not None)
+        ):
+            raise ValueError("hada_t1 and hada_t2 must be either both present or not present at the same time")
+        if self.hada_t1 is not None and self.hada_t2 is not None:
+            state_dict[f"base_model.model.{self.peft_key}.hada_t1"] = self.hada_t1
+            state_dict[f"base_model.model.{self.peft_key}.hada_t2"] = self.hada_t2
+        return state_dict
+
+
+@dataclass
+class LoKrInfo:
+    kohya_key: str
+    peft_key: str
+    alpha: Optional[float] = None
+    rank: Optional[int] = None
+    lokr_w1: Optional[torch.Tensor] = None
+    lokr_w1_a: Optional[torch.Tensor] = None
+    lokr_w1_b: Optional[torch.Tensor] = None
+    lokr_w2: Optional[torch.Tensor] = None
+    lokr_w2_a: Optional[torch.Tensor] = None
+    lokr_w2_b: Optional[torch.Tensor] = None
+    lokr_t2: Optional[torch.Tensor] = None
+
+    def peft_state_dict(self) -> dict[str, torch.Tensor]:
+        if (self.lokr_w1 is None) and ((self.lokr_w1_a is None) or (self.lokr_w1_b is None)):
+            raise ValueError("Either lokr_w1 or both lokr_w1_a and lokr_w1_b should be provided")
+
+        if (self.lokr_w2 is None) and ((self.lokr_w2_a is None) or (self.lokr_w2_b is None)):
+            raise ValueError("Either lokr_w2 or both lokr_w2_a and lokr_w2_b should be provided")
+
+        state_dict = {}
+
+        if self.lokr_w1 is not None:
+            state_dict[f"base_model.model.{self.peft_key}.lokr_w1"] = self.lokr_w1
+        elif self.lokr_w1_a is not None:
+            state_dict[f"base_model.model.{self.peft_key}.lokr_w1_a"] = self.lokr_w1_a
+            state_dict[f"base_model.model.{self.peft_key}.lokr_w1_b"] = self.lokr_w1_b
+
+        if self.lokr_w2 is not None:
+            state_dict[f"base_model.model.{self.peft_key}.lokr_w2"] = self.lokr_w2
+        elif self.lokr_w2_a is not None:
+            state_dict[f"base_model.model.{self.peft_key}.lokr_w2_a"] = self.lokr_w2_a
+            state_dict[f"base_model.model.{self.peft_key}.lokr_w2_b"] = self.lokr_w2_b
+
+        if self.lokr_t2 is not None:
+            state_dict[f"base_model.model.{self.peft_key}.lokr_t2"] = self.lokr_t2
+
+        return state_dict
+
+
+def construct_peft_loraconfig(info: dict[str, LoRAInfo], **kwargs) -> LoraConfig:
+    """Constructs LoraConfig from data extracted from adapter checkpoint
+
+    Args:
+        info (Dict[str, LoRAInfo]): Information extracted from adapter checkpoint
+
+    Returns:
+        LoraConfig: config for constructing LoRA
+    """
+
+    # Unpack all ranks and alphas
+    ranks = {key: val.rank for key, val in info.items()}
+    alphas = {x[0]: x[1].alpha or x[1].rank for x in info.items()}
+
+    # Determine which modules needs to be transformed
+    target_modules = sorted(info.keys())
+
+    # Determine most common rank and alpha
+    r = int(Counter(ranks.values()).most_common(1)[0][0])
+    lora_alpha = Counter(alphas.values()).most_common(1)[0][0]
+
+    # Determine which modules have different rank and alpha
+    rank_pattern = dict(sorted(filter(lambda x: x[1] != r, ranks.items()), key=lambda x: x[0]))
+    alpha_pattern = dict(sorted(filter(lambda x: x[1] != lora_alpha, alphas.items()), key=lambda x: x[0]))
+
+    config = LoraConfig(
+        r=r,
+        lora_alpha=lora_alpha,
+        target_modules=target_modules,
+        lora_dropout=0.0,
+        bias="none",
+        init_lora_weights=False,
+        rank_pattern=rank_pattern,
+        alpha_pattern=alpha_pattern,
+    )
+
+    return config
+
+
+def construct_peft_lohaconfig(info: dict[str, LoHaInfo], **kwargs) -> LoHaConfig:
+    """Constructs LoHaConfig from data extracted from adapter checkpoint
+
+    Args:
+        info (Dict[str, LoHaInfo]): Information extracted from adapter checkpoint
+
+    Returns:
+        LoHaConfig: config for constructing LoHA
+    """
+
+    # Unpack all ranks and alphas
+    ranks = {x[0]: x[1].rank for x in info.items()}
+    alphas = {x[0]: x[1].alpha or x[1].rank for x in info.items()}
+
+    # Determine which modules needs to be transformed
+    target_modules = sorted(info.keys())
+
+    # Determine most common rank and alpha
+    r = int(Counter(ranks.values()).most_common(1)[0][0])
+    alpha = Counter(alphas.values()).most_common(1)[0][0]
+
+    # Determine which modules have different rank and alpha
+    rank_pattern = dict(sorted(filter(lambda x: x[1] != r, ranks.items()), key=lambda x: x[0]))
+    alpha_pattern = dict(sorted(filter(lambda x: x[1] != alpha, alphas.items()), key=lambda x: x[0]))
+
+    # Determine whether any of modules have effective conv2d decomposition
+    use_effective_conv2d = any((val.hada_t1 is not None) or (val.hada_t2 is not None) for val in info.values())
+
+    config = LoHaConfig(
+        r=r,
+        alpha=alpha,
+        target_modules=target_modules,
+        rank_dropout=0.0,
+        module_dropout=0.0,
+        init_weights=False,
+        rank_pattern=rank_pattern,
+        alpha_pattern=alpha_pattern,
+        use_effective_conv2d=use_effective_conv2d,
+    )
+
+    return config
+
+
+def construct_peft_lokrconfig(info: dict[str, LoKrInfo], decompose_factor: int = -1, **kwargs) -> LoKrConfig:
+    """Constructs LoKrConfig from data extracted from adapter checkpoint
+
+    Args:
+        info (Dict[str, LoKrInfo]): Information extracted from adapter checkpoint
+
+    Returns:
+        LoKrConfig: config for constructing LoKr
+    """
+
+    # Unpack all ranks and alphas
+    ranks = {x[0]: x[1].rank for x in info.items()}
+    alphas = {x[0]: x[1].alpha or x[1].rank for x in info.items()}
+
+    # Determine which modules needs to be transformed
+    target_modules = sorted(info.keys())
+
+    # Determine most common rank and alpha
+    r = int(Counter(ranks.values()).most_common(1)[0][0])
+    alpha = Counter(alphas.values()).most_common(1)[0][0]
+
+    # Determine which modules have different rank and alpha
+    rank_pattern = dict(sorted(filter(lambda x: x[1] != r, ranks.items()), key=lambda x: x[0]))
+    alpha_pattern = dict(sorted(filter(lambda x: x[1] != alpha, alphas.items()), key=lambda x: x[0]))
+
+    # Determine whether any of modules have effective conv2d decomposition
+    use_effective_conv2d = any((val.lokr_t2 is not None) for val in info.values())
+
+    # decompose_both should be enabled if any w1 matrix in any layer is decomposed into 2
+    decompose_both = any((val.lokr_w1_a is not None and val.lokr_w1_b is not None) for val in info.values())
+
+    # Determining decompose factor is a bit tricky (but it is most often -1)
+    # Check that decompose_factor is equal to provided
+    for val in info.values():
+        # Determine shape of first matrix
+        if val.lokr_w1 is not None:
+            w1_shape = tuple(val.lokr_w1.shape)
+        else:
+            w1_shape = (val.lokr_w1_a.shape[0], val.lokr_w1_b.shape[1])
+
+        # Determine shape of second matrix
+        if val.lokr_w2 is not None:
+            w2_shape = tuple(val.lokr_w2.shape[:2])
+        elif val.lokr_t2 is not None:
+            w2_shape = (val.lokr_w2_a.shape[1], val.lokr_w2_b.shape[1])
+        else:
+            # We may iterate over Conv2d layer, for which second item in shape is multiplied by ksize^2
+            w2_shape = (val.lokr_w2_a.shape[0], val.lokr_w2_b.shape[1])
+
+        # We need to check, whether decompose_factor is really -1 or not
+        shape = (w1_shape[0], w2_shape[0])
+        if factorization(shape[0] * shape[1], factor=-1) != shape:
+            raise ValueError("Cannot infer decompose_factor, probably it is not equal to -1")
+
+    config = LoKrConfig(
+        r=r,
+        alpha=alpha,
+        target_modules=target_modules,
+        rank_dropout=0.0,
+        module_dropout=0.0,
+        init_weights=False,
+        rank_pattern=rank_pattern,
+        alpha_pattern=alpha_pattern,
+        use_effective_conv2d=use_effective_conv2d,
+        decompose_both=decompose_both,
+        decompose_factor=decompose_factor,
+    )
+
+    return config
+
+
+def combine_peft_state_dict(info: dict[str, Union[LoRAInfo, LoHaInfo]]) -> dict[str, torch.Tensor]:
+    result = {}
+    for key_info in info.values():
+        result.update(key_info.peft_state_dict())
+    return result
+
+
+def detect_adapter_type(keys: list[str]) -> PeftType:
+    # Detect type of adapter by keys
+    # Inspired by this:
+    # https://github.com/bmaltais/kohya_ss/blob/ed4e3b0239a40506de9a17e550e6cf2d0b867a4f/tools/lycoris_utils.py#L312
+    for key in keys:
+        if "alpha" in key:
+            continue
+        elif any(x in key for x in ["lora_down", "lora_up"]):
+            # LoRA
+            return PeftType.LORA
+        elif any(x in key for x in ["hada_w1", "hada_w2", "hada_t1", "hada_t2"]):
+            # LoHa may have the following keys:
+            # hada_w1_a, hada_w1_b, hada_w2_a, hada_w2_b, hada_t1, hada_t2
+            return PeftType.LOHA
+        elif any(x in key for x in ["lokr_w1", "lokr_w2", "lokr_t1", "lokr_t2"]):
+            # LoKr may have the following keys:
+            # lokr_w1, lokr_w2, lokr_w1_a, lokr_w1_b, lokr_w2_a, lokr_w2_b, lokr_t1, lokr_t2
+            return PeftType.LOKR
+        elif "diff" in key:
+            raise ValueError("Currently full diff adapters are not implemented")
+        else:
+            raise ValueError("Unknown adapter type, probably not implemented")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument("--sd_checkpoint", default=None, type=str, required=True, help="SD checkpoint to use")
+
+    parser.add_argument(
+        "--adapter_path",
+        default=None,
+        type=str,
+        required=True,
+        help="Path to downloaded adapter to convert",
+    )
+
+    parser.add_argument("--dump_path", default=None, type=str, required=True, help="Path to the output peft adapter.")
+
+    parser.add_argument("--half", action="store_true", help="Save weights in half precision.")
+    parser.add_argument(
+        "--loha_conv2d_weights_fix",
+        action="store_true",
+        help="""LoHa checkpoints trained with lycoris-lora<=1.9.0 contain a bug described in this PR https://github.com/KohakuBlueleaf/LyCORIS/pull/115.
+        This option fixes this bug during weight conversion (replaces hada_t2 with hada_t1 for Conv2d 3x3 layers).
+        The output results may differ from webui, but in general, they should be better in terms of quality.
+        This option should be set to True in case the provided checkpoint has been trained with lycoris-lora version for which the mentioned PR wasn't merged.
+        This option should be set to False in case the provided checkpoint has been trained with lycoris-lora version for which the mentioned PR is merged or full compatibility with webui outputs is required.""",
+    )
+    args = parser.parse_args()
+
+    # Load all models that we need to add adapter to
+    text_encoder = CLIPTextModel.from_pretrained(args.sd_checkpoint, subfolder="text_encoder")
+    unet = UNet2DConditionModel.from_pretrained(args.sd_checkpoint, subfolder="unet")
+
+    # Construct possible mapping from kohya keys to peft keys
+    models_keys = {}
+    for model, model_key, model_name in [
+        (text_encoder, PREFIX_TEXT_ENCODER, "text_encoder"),
+        (unet, PREFIX_UNET, "unet"),
+    ]:
+        models_keys.update(
+            {
+                f"{model_key}.{peft_key}".replace(".", "_"): peft_key
+                for peft_key in (x[0] for x in model.named_modules())
+            }
+        )
+
+    # Store conversion info (model_type -> peft_key -> LoRAInfo | LoHaInfo | LoKrInfo)
+    adapter_info: dict[str, dict[str, Union[LoRAInfo, LoHaInfo, LoKrInfo]]] = {
+        "text_encoder": {},
+        "unet": {},
+    }
+
+    # Store decompose_factor for LoKr
+    decompose_factor = -1
+
+    # Open adapter checkpoint
+    with safetensors.safe_open(args.adapter_path, framework="pt", device="cpu") as f:
+        # Extract information about adapter structure
+        metadata = f.metadata()
+
+        # It may be difficult to determine rank for LoKr adapters
+        # If checkpoint was trained with large rank it may not be utilized during weights creation at all
+        # So we need to get it from checkpoint metadata (along with decompose_factor)
+        rank, conv_rank = None, None
+        if metadata is not None:
+            rank = metadata.get("ss_network_dim", None)
+            rank = int(rank) if rank else None
+            if "ss_network_args" in metadata:
+                network_args = json.loads(metadata["ss_network_args"])
+                conv_rank = network_args.get("conv_dim", None)
+                conv_rank = int(conv_rank) if conv_rank else rank
+                decompose_factor = network_args.get("factor", -1)
+                decompose_factor = int(decompose_factor)
+
+        # Detect adapter type based on keys
+        adapter_type = detect_adapter_type(f.keys())
+        adapter_info_cls = {
+            PeftType.LORA: LoRAInfo,
+            PeftType.LOHA: LoHaInfo,
+            PeftType.LOKR: LoKrInfo,
+        }[adapter_type]
+
+        # Iterate through available info and unpack all the values
+        for key in f.keys():
+            kohya_key, kohya_type = key.split(".")[:2]
+
+            # Find which model this key belongs to
+            if kohya_key.startswith(PREFIX_TEXT_ENCODER):
+                model_type, model = "text_encoder", text_encoder
+            elif kohya_key.startswith(PREFIX_UNET):
+                model_type, model = "unet", unet
+            else:
+                raise ValueError(f"Cannot determine model for key: {key}")
+
+            # Find corresponding peft key
+            if kohya_key not in models_keys:
+                raise ValueError(f"Cannot find corresponding key for diffusers/transformers model: {kohya_key}")
+            peft_key = models_keys[kohya_key]
+
+            # Retrieve corresponding layer of model
+            layer = attrgetter(peft_key)(model)
+
+            # Create a corresponding adapter info
+            if peft_key not in adapter_info[model_type]:
+                adapter_info[model_type][peft_key] = adapter_info_cls(kohya_key=kohya_key, peft_key=peft_key)
+
+            tensor = f.get_tensor(key)
+            if kohya_type == "alpha":
+                adapter_info[model_type][peft_key].alpha = tensor.item()
+            elif kohya_type == "lora_down":
+                adapter_info[model_type][peft_key].lora_A = tensor
+                adapter_info[model_type][peft_key].rank = tensor.shape[0]
+            elif kohya_type == "lora_up":
+                adapter_info[model_type][peft_key].lora_B = tensor
+                adapter_info[model_type][peft_key].rank = tensor.shape[1]
+            elif kohya_type == "hada_w1_a":
+                adapter_info[model_type][peft_key].hada_w1_a = tensor
+            elif kohya_type == "hada_w1_b":
+                adapter_info[model_type][peft_key].hada_w1_b = tensor
+                adapter_info[model_type][peft_key].rank = tensor.shape[0]
+            elif kohya_type == "hada_w2_a":
+                adapter_info[model_type][peft_key].hada_w2_a = tensor
+            elif kohya_type == "hada_w2_b":
+                adapter_info[model_type][peft_key].hada_w2_b = tensor
+                adapter_info[model_type][peft_key].rank = tensor.shape[0]
+            elif kohya_type in {"hada_t1", "hada_t2"}:
+                if args.loha_conv2d_weights_fix:
+                    if kohya_type == "hada_t1":
+                        # This code block fixes a bug that exists for some LoHa checkpoints
+                        # that resulted in accidentally using hada_t1 weight instead of hada_t2, see
+                        # https://github.com/KohakuBlueleaf/LyCORIS/pull/115
+                        adapter_info[model_type][peft_key].hada_t1 = tensor
+                        adapter_info[model_type][peft_key].hada_t2 = tensor
+                        adapter_info[model_type][peft_key].rank = tensor.shape[0]
+                else:
+                    if kohya_type == "hada_t1":
+                        adapter_info[model_type][peft_key].hada_t1 = tensor
+                        adapter_info[model_type][peft_key].rank = tensor.shape[0]
+                    elif kohya_type == "hada_t2":
+                        adapter_info[model_type][peft_key].hada_t2 = tensor
+                        adapter_info[model_type][peft_key].rank = tensor.shape[0]
+            elif kohya_type == "lokr_t2":
+                adapter_info[model_type][peft_key].lokr_t2 = tensor
+                adapter_info[model_type][peft_key].rank = tensor.shape[0]
+            elif kohya_type == "lokr_w1":
+                adapter_info[model_type][peft_key].lokr_w1 = tensor
+                if isinstance(layer, nn.Linear) or (
+                    isinstance(layer, nn.Conv2d) and tuple(layer.weight.shape[2:]) == (1, 1)
+                ):
+                    adapter_info[model_type][peft_key].rank = rank
+                elif isinstance(layer, nn.Conv2d):
+                    adapter_info[model_type][peft_key].rank = conv_rank
+            elif kohya_type == "lokr_w2":
+                adapter_info[model_type][peft_key].lokr_w2 = tensor
+                if isinstance(layer, nn.Linear) or (
+                    isinstance(layer, nn.Conv2d) and tuple(layer.weight.shape[2:]) == (1, 1)
+                ):
+                    adapter_info[model_type][peft_key].rank = rank
+                elif isinstance(layer, nn.Conv2d):
+                    adapter_info[model_type][peft_key].rank = conv_rank
+            elif kohya_type == "lokr_w1_a":
+                adapter_info[model_type][peft_key].lokr_w1_a = tensor
+                adapter_info[model_type][peft_key].rank = tensor.shape[1]
+            elif kohya_type == "lokr_w1_b":
+                adapter_info[model_type][peft_key].lokr_w1_b = tensor
+                adapter_info[model_type][peft_key].rank = tensor.shape[0]
+            elif kohya_type == "lokr_w2_a":
+                adapter_info[model_type][peft_key].lokr_w2_a = tensor
+            elif kohya_type == "lokr_w2_b":
+                adapter_info[model_type][peft_key].lokr_w2_b = tensor
+            else:
+                raise ValueError(f"Unknown weight name in key: {key} - {kohya_type}")
+
+    # Get function which will create adapter config based on extracted info
+    construct_config_fn = {
+        PeftType.LORA: construct_peft_loraconfig,
+        PeftType.LOHA: construct_peft_lohaconfig,
+        PeftType.LOKR: construct_peft_lokrconfig,
+    }[adapter_type]
+
+    # Process each model sequentially
+    for model, model_name in [(text_encoder, "text_encoder"), (unet, "unet")]:
+        # Skip model if no data was provided
+        if len(adapter_info[model_name]) == 0:
+            continue
+
+        config = construct_config_fn(adapter_info[model_name], decompose_factor=decompose_factor)
+
+        # Output warning for LoHa with use_effective_conv2d
+        if (
+            isinstance(config, LoHaConfig)
+            and getattr(config, "use_effective_conv2d", False)
+            and args.loha_conv2d_weights_fix is False
+        ):
+            logger.warning(
+                'lycoris-lora<=1.9.0 LoHa implementation contains a bug, which can be fixed with "--loha_conv2d_weights_fix".\n'
+                "For more info, please refer to https://github.com/huggingface/peft/pull/1021 and https://github.com/KohakuBlueleaf/LyCORIS/pull/115"
+            )
+
+        model = get_peft_model(model, config)
+        missing_keys, unexpected_keys = set_peft_model_state_dict(
+            model, combine_peft_state_dict(adapter_info[model_name])
+        )
+        if len(unexpected_keys) > 0:
+            raise ValueError(f"Unexpected keys {unexpected_keys} found during conversion")
+
+        if args.half:
+            model.to(torch.float16)
+
+        # Save model to disk
+        model.save_pretrained(os.path.join(args.dump_path, model_name))
diff --git a/examples/stable_diffusion/inc_flux_lora_hpu.py b/examples/stable_diffusion/inc_flux_lora_hpu.py
new file mode 100644
index 0000000..79337b7
--- /dev/null
+++ b/examples/stable_diffusion/inc_flux_lora_hpu.py
@@ -0,0 +1,67 @@
+"""
+This example demonstrates loading of LoRA adapter (via PEFT) into an FP8 INC-quantized FLUX model.
+
+More info on Intel Neural Compressor (INC) FP8 quantization is available at:
+https://github.com/intel/neural-compressor/tree/master/examples/helloworld/fp8_example
+
+Requirements:
+pip install optimum-habana sentencepiece neural-compressor[pt] peft
+"""
+
+import importlib
+
+import torch
+from neural_compressor.torch.quantization import FP8Config, convert, finalize_calibration, prepare
+
+
+# Checks if HPU device is available
+# Adapted from https://github.com/huggingface/accelerate/blob/b451956fd69a135efc283aadaa478f0d33fcbe6a/src/accelerate/utils/imports.py#L435
+def is_hpu_available():
+    if (
+        importlib.util.find_spec("habana_frameworks") is None
+        or importlib.util.find_spec("habana_frameworks.torch") is None
+    ):
+        return False
+
+    import habana_frameworks.torch  # noqa: F401
+
+    return hasattr(torch, "hpu") and torch.hpu.is_available()
+
+
+# Ensure HPU device is available before proceeding
+if is_hpu_available():
+    from optimum.habana.diffusers import GaudiFluxPipeline
+else:
+    raise RuntimeError("HPU device not found. This code requires Intel Gaudi device to run.")
+
+# Example: FLUX model inference on HPU via optimum-habana pipeline
+hpu_configs = {
+    "use_habana": True,
+    "use_hpu_graphs": True,
+    "sdp_on_bf16": True,
+    "gaudi_config": "Habana/stable-diffusion",
+}
+pipe = GaudiFluxPipeline.from_pretrained("black-forest-labs/FLUX.1-dev", torch_dtype=torch.bfloat16, **hpu_configs)
+prompt = "A picture of sks dog in a bucket"
+
+# Quantize FLUX transformer to FP8 using INC (Intel Neural Compressor)
+quant_configs = {
+    "mode": "AUTO",
+    "observer": "maxabs",
+    "scale_method": "maxabs_hw",
+    "allowlist": {"types": [], "names": []},
+    "blocklist": {"types": [], "names": []},
+    "dump_stats_path": "/tmp/hqt_output/measure",
+}
+config = FP8Config(**quant_configs)
+pipe.transformer = prepare(pipe.transformer, config)
+pipe(prompt)
+finalize_calibration(pipe.transformer)
+pipe.transformer = convert(pipe.transformer)
+
+# Load LoRA weights with PEFT
+pipe.load_lora_weights("dsocek/lora-flux-dog", adapter_name="user_lora")
+
+# Run inference
+image = pipe(prompt).images[0]
+image.save("dog.png")
diff --git a/examples/stable_diffusion/train_dreambooth.py b/examples/stable_diffusion/train_dreambooth.py
new file mode 100644
index 0000000..33391c9
--- /dev/null
+++ b/examples/stable_diffusion/train_dreambooth.py
@@ -0,0 +1,1275 @@
+import argparse
+import gc
+import hashlib
+import itertools
+import logging
+import math
+import os
+import threading
+import warnings
+from pathlib import Path
+from typing import Union
+
+import datasets
+import diffusers
+import numpy as np
+import psutil
+import torch
+import torch.nn.functional as F
+import torch.utils.checkpoint
+import transformers
+from accelerate import Accelerator
+from accelerate.logging import get_logger
+from accelerate.utils import set_seed
+from diffusers import (
+    AutoencoderKL,
+    DDPMScheduler,
+    DiffusionPipeline,
+    DPMSolverMultistepScheduler,
+    UNet2DConditionModel,
+)
+from diffusers.optimization import get_scheduler
+from diffusers.utils import check_min_version
+from diffusers.utils.import_utils import is_xformers_available
+from huggingface_hub import HfApi
+from PIL import Image
+from torch.utils.data import Dataset
+from torchvision import transforms
+from tqdm.auto import tqdm
+from transformers import AutoTokenizer, PretrainedConfig
+
+from peft import LoHaConfig, LoKrConfig, LoraConfig, get_peft_model
+
+
+# Will error if the minimal version of diffusers is not installed. Remove at your own risks.
+check_min_version("0.10.0.dev0")
+
+logger = get_logger(__name__)
+
+UNET_TARGET_MODULES = [
+    "to_q",
+    "to_k",
+    "to_v",
+    "proj",
+    "proj_in",
+    "proj_out",
+    "conv",
+    "conv1",
+    "conv2",
+    "conv_shortcut",
+    "to_out.0",
+    "time_emb_proj",
+    "ff.net.2",
+]
+
+TEXT_ENCODER_TARGET_MODULES = ["fc1", "fc2", "q_proj", "k_proj", "v_proj", "out_proj"]
+
+
+def import_model_class_from_model_name_or_path(pretrained_model_name_or_path: str, revision: str):
+    text_encoder_config = PretrainedConfig.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="text_encoder",
+        revision=revision,
+    )
+    model_class = text_encoder_config.architectures[0]
+
+    if model_class == "CLIPTextModel":
+        from transformers import CLIPTextModel
+
+        return CLIPTextModel
+    elif model_class == "RobertaSeriesModelWithTransformation":
+        from diffusers.pipelines.alt_diffusion.modeling_roberta_series import RobertaSeriesModelWithTransformation
+
+        return RobertaSeriesModelWithTransformation
+    else:
+        raise ValueError(f"{model_class} is not supported.")
+
+
+def create_unet_adapter_config(args: argparse.Namespace) -> Union[LoraConfig, LoHaConfig, LoKrConfig]:
+    if args.adapter == "full":
+        raise ValueError("Cannot create unet adapter config for full parameter")
+
+    if args.adapter == "lora":
+        config = LoraConfig(
+            r=args.unet_r,
+            lora_alpha=args.unet_alpha,
+            target_modules=UNET_TARGET_MODULES,
+            lora_dropout=args.unet_dropout,
+            bias=args.unet_bias,
+            init_lora_weights=True,
+        )
+    elif args.adapter == "loha":
+        config = LoHaConfig(
+            r=args.unet_r,
+            alpha=args.unet_alpha,
+            target_modules=UNET_TARGET_MODULES,
+            rank_dropout=args.unet_rank_dropout,
+            module_dropout=args.unet_module_dropout,
+            use_effective_conv2d=args.unet_use_effective_conv2d,
+            init_weights=True,
+        )
+    elif args.adapter == "lokr":
+        config = LoKrConfig(
+            r=args.unet_r,
+            alpha=args.unet_alpha,
+            target_modules=UNET_TARGET_MODULES,
+            rank_dropout=args.unet_rank_dropout,
+            module_dropout=args.unet_module_dropout,
+            use_effective_conv2d=args.unet_use_effective_conv2d,
+            decompose_both=args.unet_decompose_both,
+            decompose_factor=args.unet_decompose_factor,
+            init_weights=True,
+        )
+    else:
+        raise ValueError(f"Unknown adapter type {args.adapter}")
+
+    return config
+
+
+def create_text_encoder_adapter_config(args: argparse.Namespace) -> Union[LoraConfig, LoHaConfig, LoKrConfig]:
+    if args.adapter == "full":
+        raise ValueError("Cannot create text_encoder adapter config for full parameter")
+
+    if args.adapter == "lora":
+        config = LoraConfig(
+            r=args.te_r,
+            lora_alpha=args.te_alpha,
+            target_modules=TEXT_ENCODER_TARGET_MODULES,
+            lora_dropout=args.te_dropout,
+            bias=args.te_bias,
+            init_lora_weights=True,
+        )
+    elif args.adapter == "loha":
+        config = LoHaConfig(
+            r=args.te_r,
+            alpha=args.te_alpha,
+            target_modules=TEXT_ENCODER_TARGET_MODULES,
+            rank_dropout=args.te_rank_dropout,
+            module_dropout=args.te_module_dropout,
+            init_weights=True,
+        )
+    elif args.adapter == "lokr":
+        config = LoKrConfig(
+            r=args.te_r,
+            alpha=args.te_alpha,
+            target_modules=TEXT_ENCODER_TARGET_MODULES,
+            rank_dropout=args.te_rank_dropout,
+            module_dropout=args.te_module_dropout,
+            decompose_both=args.te_decompose_both,
+            decompose_factor=args.te_decompose_factor,
+            init_weights=True,
+        )
+    else:
+        raise ValueError(f"Unknown adapter type {args.adapter}")
+
+    return config
+
+
+def parse_args(input_args=None):
+    parser = argparse.ArgumentParser(description="Simple example of a training script.")
+    parser.add_argument(
+        "--pretrained_model_name_or_path",
+        type=str,
+        default=None,
+        required=True,
+        help="Path to pretrained model or model identifier from huggingface.co/models.",
+    )
+    parser.add_argument(
+        "--revision",
+        type=str,
+        default=None,
+        required=False,
+        help="Revision of pretrained model identifier from huggingface.co/models.",
+    )
+    parser.add_argument(
+        "--tokenizer_name",
+        type=str,
+        default=None,
+        help="Pretrained tokenizer name or path if not the same as model_name",
+    )
+    parser.add_argument(
+        "--instance_data_dir",
+        type=str,
+        default=None,
+        required=True,
+        help="A folder containing the training data of instance images.",
+    )
+    parser.add_argument(
+        "--class_data_dir",
+        type=str,
+        default=None,
+        required=False,
+        help="A folder containing the training data of class images.",
+    )
+    parser.add_argument(
+        "--instance_prompt",
+        type=str,
+        default=None,
+        required=True,
+        help="The prompt with identifier specifying the instance",
+    )
+    parser.add_argument(
+        "--class_prompt",
+        type=str,
+        default=None,
+        help="The prompt to specify images in the same class as provided instance images.",
+    )
+    parser.add_argument(
+        "--with_prior_preservation",
+        default=False,
+        action="store_true",
+        help="Flag to add prior preservation loss.",
+    )
+    parser.add_argument("--prior_loss_weight", type=float, default=1.0, help="The weight of prior preservation loss.")
+    parser.add_argument(
+        "--num_class_images",
+        type=int,
+        default=100,
+        help=(
+            "Minimal class images for prior preservation loss. If there are not enough images already present in"
+            " class_data_dir, additional images will be sampled with class_prompt."
+        ),
+    )
+    parser.add_argument(
+        "--validation_prompt",
+        type=str,
+        default=None,
+        help="A prompt that is used during validation to verify that the model is learning.",
+    )
+    parser.add_argument(
+        "--num_validation_images",
+        type=int,
+        default=4,
+        help="Number of images that should be generated during validation with `validation_prompt`.",
+    )
+    parser.add_argument(
+        "--validation_steps",
+        type=int,
+        default=100,
+        help=(
+            "Run dreambooth validation every X steps. Dreambooth validation consists of running the prompt"
+            " `args.validation_prompt` multiple times: `args.num_validation_images`."
+        ),
+    )
+    parser.add_argument(
+        "--output_dir",
+        type=str,
+        default="text-inversion-model",
+        help="The output directory where the model predictions and checkpoints will be written.",
+    )
+    parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.")
+    parser.add_argument(
+        "--resolution",
+        type=int,
+        default=512,
+        help=(
+            "The resolution for input images, all the images in the train/validation dataset will be resized to this"
+            " resolution"
+        ),
+    )
+    parser.add_argument(
+        "--center_crop", action="store_true", help="Whether to center crop images before resizing to resolution"
+    )
+    parser.add_argument("--train_text_encoder", action="store_true", help="Whether to train the text encoder")
+
+    parser.add_argument(
+        "--train_batch_size", type=int, default=4, help="Batch size (per device) for the training dataloader."
+    )
+    parser.add_argument(
+        "--sample_batch_size", type=int, default=4, help="Batch size (per device) for sampling images."
+    )
+    parser.add_argument("--num_train_epochs", type=int, default=1)
+    parser.add_argument(
+        "--max_train_steps",
+        type=int,
+        default=None,
+        help="Total number of training steps to perform.  If provided, overrides num_train_epochs.",
+    )
+    parser.add_argument(
+        "--checkpointing_steps",
+        type=int,
+        default=500,
+        help=(
+            "Save a checkpoint of the training state every X updates. These checkpoints can be used both as final"
+            " checkpoints in case they are better than the last checkpoint, and are also suitable for resuming"
+            " training using `--resume_from_checkpoint`."
+        ),
+    )
+    parser.add_argument(
+        "--resume_from_checkpoint",
+        type=str,
+        default=None,
+        help=(
+            "Whether training should be resumed from a previous checkpoint. Use a path saved by"
+            ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.'
+        ),
+    )
+    parser.add_argument(
+        "--gradient_accumulation_steps",
+        type=int,
+        default=1,
+        help="Number of updates steps to accumulate before performing a backward/update pass.",
+    )
+    parser.add_argument(
+        "--gradient_checkpointing",
+        action="store_true",
+        help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.",
+    )
+    parser.add_argument(
+        "--learning_rate",
+        type=float,
+        default=5e-6,
+        help="Initial learning rate (after the potential warmup period) to use.",
+    )
+    parser.add_argument(
+        "--scale_lr",
+        action="store_true",
+        default=False,
+        help="Scale the learning rate by the number of accelerators, gradient accumulation steps, and batch size.",
+    )
+    parser.add_argument(
+        "--lr_scheduler",
+        type=str,
+        default="constant",
+        help=(
+            'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",'
+            ' "constant", "constant_with_warmup"]'
+        ),
+    )
+    parser.add_argument(
+        "--lr_warmup_steps", type=int, default=500, help="Number of steps for the warmup in the lr scheduler."
+    )
+    parser.add_argument(
+        "--lr_num_cycles",
+        type=int,
+        default=1,
+        help="Number of hard resets of the lr in cosine_with_restarts scheduler.",
+    )
+    parser.add_argument("--lr_power", type=float, default=1.0, help="Power factor of the polynomial scheduler.")
+    parser.add_argument(
+        "--use_8bit_adam", action="store_true", help="Whether or not to use 8-bit Adam from bitsandbytes."
+    )
+    parser.add_argument("--adam_beta1", type=float, default=0.9, help="The beta1 parameter for the Adam optimizer.")
+    parser.add_argument("--adam_beta2", type=float, default=0.999, help="The beta2 parameter for the Adam optimizer.")
+    parser.add_argument("--adam_weight_decay", type=float, default=1e-2, help="Weight decay to use.")
+    parser.add_argument("--adam_epsilon", type=float, default=1e-08, help="Epsilon value for the Adam optimizer")
+    parser.add_argument("--max_grad_norm", default=1.0, type=float, help="Max gradient norm.")
+    parser.add_argument("--push_to_hub", action="store_true", help="Whether or not to push the model to the Hub.")
+    parser.add_argument("--hub_token", type=str, default=None, help="The token to use to push to the Model Hub.")
+    parser.add_argument(
+        "--hub_model_id",
+        type=str,
+        default=None,
+        help="The name of the repository to keep in sync with the local `output_dir`.",
+    )
+    parser.add_argument(
+        "--logging_dir",
+        type=str,
+        default="logs",
+        help=(
+            "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to"
+            " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***."
+        ),
+    )
+    parser.add_argument(
+        "--allow_tf32",
+        action="store_true",
+        help=(
+            "Whether or not to allow TF32 on Ampere GPUs. Can be used to speed up training. For more information, see"
+            " https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices"
+        ),
+    )
+    parser.add_argument(
+        "--report_to",
+        type=str,
+        default="tensorboard",
+        help=(
+            'The integration to report the results and logs to. Supported platforms are `"tensorboard"`'
+            ' (default), `"wandb"` and `"comet_ml"`. Use `"all"` to report to all integrations.'
+        ),
+    )
+    parser.add_argument(
+        "--wandb_key",
+        type=str,
+        default=None,
+        help=("If report to option is set to wandb, api-key for wandb used for login to wandb "),
+    )
+    parser.add_argument(
+        "--wandb_project_name",
+        type=str,
+        default=None,
+        help=("If report to option is set to wandb, project name in wandb for log tracking  "),
+    )
+    parser.add_argument(
+        "--mixed_precision",
+        type=str,
+        default=None,
+        choices=["no", "fp16", "bf16"],
+        help=(
+            "Whether to use mixed precision. Choose between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >="
+            " 1.10. and an Nvidia Ampere GPU or Intel XPU.  Default to the value of accelerate config of the current system or the"
+            " flag passed with the `accelerate.launch` command. Use this argument to override the accelerate config."
+        ),
+    )
+    parser.add_argument(
+        "--prior_generation_precision",
+        type=str,
+        default=None,
+        choices=["no", "fp32", "fp16", "bf16"],
+        help=(
+            "Choose prior generation precision between fp32, fp16 and bf16 (bfloat16). Bf16 requires PyTorch >="
+            " 1.10. and an Nvidia Ampere GPU or Intel XPU. Default to fp16 if an accelerator is available else fp32."
+        ),
+    )
+    parser.add_argument("--local_rank", type=int, default=-1, help="For distributed training: local_rank")
+    parser.add_argument(
+        "--enable_xformers_memory_efficient_attention", action="store_true", help="Whether or not to use xformers."
+    )
+
+    # Adapter arguments
+    subparsers = parser.add_subparsers(dest="adapter")
+
+    # Dummy subparser to train whole model
+    subparsers.add_parser("full", help="Train full model without adapters")
+
+    # LoRA adapter
+    lora = subparsers.add_parser("lora", help="Use LoRA adapter")
+    lora.add_argument("--unet_r", type=int, default=8, help="LoRA rank for unet")
+    lora.add_argument("--unet_alpha", type=int, default=8, help="LoRA alpha for unet")
+    lora.add_argument("--unet_dropout", type=float, default=0.0, help="LoRA dropout probability for unet")
+    lora.add_argument(
+        "--unet_bias",
+        type=str,
+        default="none",
+        help="Bias type for LoRA. Can be 'none', 'all' or 'lora_only'",
+    )
+    lora.add_argument(
+        "--te_r", type=int, default=8, help="LoRA rank for text_encoder, only used if `train_text_encoder` is True"
+    )
+    lora.add_argument(
+        "--te_alpha",
+        type=int,
+        default=8,
+        help="LoRA alpha for text_encoder, only used if `train_text_encoder` is True",
+    )
+    lora.add_argument(
+        "--te_dropout",
+        type=float,
+        default=0.0,
+        help="LoRA dropout probability for text_encoder, only used if `train_text_encoder` is True",
+    )
+    lora.add_argument(
+        "--te_bias",
+        type=str,
+        default="none",
+        help="Bias type for LoRA. Can be 'none', 'all' or 'lora_only', only used if `train_text_encoder` is True",
+    )
+
+    # LoHa adapter
+    loha = subparsers.add_parser("loha", help="Use LoHa adapter")
+    loha.add_argument("--unet_r", type=int, default=8, help="LoHa rank for unet")
+    loha.add_argument("--unet_alpha", type=int, default=8, help="LoHa alpha for unet")
+    loha.add_argument("--unet_rank_dropout", type=float, default=0.0, help="LoHa rank_dropout probability for unet")
+    loha.add_argument(
+        "--unet_module_dropout", type=float, default=0.0, help="LoHa module_dropout probability for unet"
+    )
+    loha.add_argument(
+        "--unet_use_effective_conv2d",
+        action="store_true",
+        help="Use parameter effective decomposition in unet for Conv2d 3x3 with ksize > 1",
+    )
+    loha.add_argument(
+        "--te_r", type=int, default=8, help="LoHa rank for text_encoder, only used if `train_text_encoder` is True"
+    )
+    loha.add_argument(
+        "--te_alpha",
+        type=int,
+        default=8,
+        help="LoHa alpha for text_encoder, only used if `train_text_encoder` is True",
+    )
+    loha.add_argument(
+        "--te_rank_dropout",
+        type=float,
+        default=0.0,
+        help="LoHa rank_dropout probability for text_encoder, only used if `train_text_encoder` is True",
+    )
+    loha.add_argument(
+        "--te_module_dropout",
+        type=float,
+        default=0.0,
+        help="LoHa module_dropout probability for text_encoder, only used if `train_text_encoder` is True",
+    )
+
+    # LoKr adapter
+    lokr = subparsers.add_parser("lokr", help="Use LoKr adapter")
+    lokr.add_argument("--unet_r", type=int, default=8, help="LoKr rank for unet")
+    lokr.add_argument("--unet_alpha", type=int, default=8, help="LoKr alpha for unet")
+    lokr.add_argument("--unet_rank_dropout", type=float, default=0.0, help="LoKr rank_dropout probability for unet")
+    lokr.add_argument(
+        "--unet_module_dropout", type=float, default=0.0, help="LoKr module_dropout probability for unet"
+    )
+    lokr.add_argument(
+        "--unet_use_effective_conv2d",
+        action="store_true",
+        help="Use parameter effective decomposition in unet for Conv2d 3x3 with ksize > 1",
+    )
+    lokr.add_argument(
+        "--unet_decompose_both", action="store_true", help="Decompose left matrix in kronecker product for unet"
+    )
+    lokr.add_argument(
+        "--unet_decompose_factor", type=int, default=-1, help="Decompose factor in kronecker product for unet"
+    )
+    lokr.add_argument(
+        "--te_r", type=int, default=8, help="LoKr rank for text_encoder, only used if `train_text_encoder` is True"
+    )
+    lokr.add_argument(
+        "--te_alpha",
+        type=int,
+        default=8,
+        help="LoKr alpha for text_encoder, only used if `train_text_encoder` is True",
+    )
+    lokr.add_argument(
+        "--te_rank_dropout",
+        type=float,
+        default=0.0,
+        help="LoKr rank_dropout probability for text_encoder, only used if `train_text_encoder` is True",
+    )
+    lokr.add_argument(
+        "--te_module_dropout",
+        type=float,
+        default=0.0,
+        help="LoKr module_dropout probability for text_encoder, only used if `train_text_encoder` is True",
+    )
+    lokr.add_argument(
+        "--te_decompose_both",
+        action="store_true",
+        help="Decompose left matrix in kronecker product for text_encoder, only used if `train_text_encoder` is True",
+    )
+    lokr.add_argument(
+        "--te_decompose_factor",
+        type=int,
+        default=-1,
+        help="Decompose factor in kronecker product for text_encoder, only used if `train_text_encoder` is True",
+    )
+
+    if input_args is not None:
+        args = parser.parse_args(input_args)
+    else:
+        args = parser.parse_args()
+
+    env_local_rank = int(os.environ.get("LOCAL_RANK", "-1"))
+    if env_local_rank != -1 and env_local_rank != args.local_rank:
+        args.local_rank = env_local_rank
+
+    if args.with_prior_preservation:
+        if args.class_data_dir is None:
+            raise ValueError("You must specify a data directory for class images.")
+        if args.class_prompt is None:
+            raise ValueError("You must specify prompt for class images.")
+    else:
+        # logger is not available yet
+        if args.class_data_dir is not None:
+            warnings.warn("You need not use --class_data_dir without --with_prior_preservation.")
+        if args.class_prompt is not None:
+            warnings.warn("You need not use --class_prompt without --with_prior_preservation.")
+
+    return args
+
+
+# Converting Bytes to Megabytes
+def b2mb(x):
+    return int(x / 2**20)
+
+
+# This context manager is used to track the peak memory usage of the process
+class TorchTracemalloc:
+    def __enter__(self):
+        gc.collect()
+        self.device_type = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+        self.device_module = getattr(torch, self.device_type, torch.cuda)
+        self.device_module.empty_cache()
+        self.device_module.reset_peak_memory_stats()  # reset the peak gauge to zero
+        self.begin = self.device_module.memory_allocated()
+        self.process = psutil.Process()
+
+        self.cpu_begin = self.cpu_mem_used()
+        self.peak_monitoring = True
+        peak_monitor_thread = threading.Thread(target=self.peak_monitor_func)
+        peak_monitor_thread.daemon = True
+        peak_monitor_thread.start()
+        return self
+
+    def cpu_mem_used(self):
+        """get resident set size memory for the current process"""
+        return self.process.memory_info().rss
+
+    def peak_monitor_func(self):
+        self.cpu_peak = -1
+
+        while True:
+            self.cpu_peak = max(self.cpu_mem_used(), self.cpu_peak)
+
+            # can't sleep or will not catch the peak right (this comment is here on purpose)
+            # time.sleep(0.001) # 1msec
+
+            if not self.peak_monitoring:
+                break
+
+    def __exit__(self, *exc):
+        self.peak_monitoring = False
+
+        gc.collect()
+        self.device_module.empty_cache()
+        self.end = self.device_module.memory_allocated()
+        self.peak = self.device_module.max_memory_allocated()
+        self.used = b2mb(self.end - self.begin)
+        self.peaked = b2mb(self.peak - self.begin)
+
+        self.cpu_end = self.cpu_mem_used()
+        self.cpu_used = b2mb(self.cpu_end - self.cpu_begin)
+        self.cpu_peaked = b2mb(self.cpu_peak - self.cpu_begin)
+        # print(f"delta used/peak {self.used:4d}/{self.peaked:4d}")
+
+
+class DreamBoothDataset(Dataset):
+    """
+    A dataset to prepare the instance and class images with the prompts for fine-tuning the model.
+    It pre-processes the images and the tokenizes prompts.
+    """
+
+    def __init__(
+        self,
+        instance_data_root,
+        instance_prompt,
+        tokenizer,
+        class_data_root=None,
+        class_prompt=None,
+        size=512,
+        center_crop=False,
+    ):
+        self.size = size
+        self.center_crop = center_crop
+        self.tokenizer = tokenizer
+
+        self.instance_data_root = Path(instance_data_root)
+        if not self.instance_data_root.exists():
+            raise ValueError("Instance images root doesn't exists.")
+
+        self.instance_images_path = list(Path(instance_data_root).iterdir())
+        self.num_instance_images = len(self.instance_images_path)
+        self.instance_prompt = instance_prompt
+        self._length = self.num_instance_images
+
+        if class_data_root is not None:
+            self.class_data_root = Path(class_data_root)
+            self.class_data_root.mkdir(parents=True, exist_ok=True)
+            self.class_images_path = list(self.class_data_root.iterdir())
+            self.num_class_images = len(self.class_images_path)
+            self._length = max(self.num_class_images, self.num_instance_images)
+            self.class_prompt = class_prompt
+        else:
+            self.class_data_root = None
+
+        self.image_transforms = transforms.Compose(
+            [
+                transforms.Resize(size, interpolation=transforms.InterpolationMode.BILINEAR),
+                transforms.CenterCrop(size) if center_crop else transforms.RandomCrop(size),
+                transforms.ToTensor(),
+                transforms.Normalize([0.5], [0.5]),
+            ]
+        )
+
+    def __len__(self):
+        return self._length
+
+    def __getitem__(self, index):
+        example = {}
+        instance_image = Image.open(self.instance_images_path[index % self.num_instance_images])
+        if instance_image.mode != "RGB":
+            instance_image = instance_image.convert("RGB")
+        example["instance_images"] = self.image_transforms(instance_image)
+        example["instance_prompt_ids"] = self.tokenizer(
+            self.instance_prompt,
+            truncation=True,
+            padding="max_length",
+            max_length=self.tokenizer.model_max_length,
+            return_tensors="pt",
+        ).input_ids
+
+        if self.class_data_root:
+            class_image = Image.open(self.class_images_path[index % self.num_class_images])
+            if class_image.mode != "RGB":
+                class_image = class_image.convert("RGB")
+            example["class_images"] = self.image_transforms(class_image)
+            example["class_prompt_ids"] = self.tokenizer(
+                self.class_prompt,
+                truncation=True,
+                padding="max_length",
+                max_length=self.tokenizer.model_max_length,
+                return_tensors="pt",
+            ).input_ids
+
+        return example
+
+
+def collate_fn(examples, with_prior_preservation=False):
+    input_ids = [example["instance_prompt_ids"] for example in examples]
+    pixel_values = [example["instance_images"] for example in examples]
+
+    # Concat class and instance examples for prior preservation.
+    # We do this to avoid doing two forward passes.
+    if with_prior_preservation:
+        input_ids += [example["class_prompt_ids"] for example in examples]
+        pixel_values += [example["class_images"] for example in examples]
+
+    pixel_values = torch.stack(pixel_values)
+    pixel_values = pixel_values.to(memory_format=torch.contiguous_format).float()
+
+    input_ids = torch.cat(input_ids, dim=0)
+
+    batch = {
+        "input_ids": input_ids,
+        "pixel_values": pixel_values,
+    }
+    return batch
+
+
+class PromptDataset(Dataset):
+    "A simple dataset to prepare the prompts to generate class images on multiple accelerators."
+
+    def __init__(self, prompt, num_samples):
+        self.prompt = prompt
+        self.num_samples = num_samples
+
+    def __len__(self):
+        return self.num_samples
+
+    def __getitem__(self, index):
+        example = {}
+        example["prompt"] = self.prompt
+        example["index"] = index
+        return example
+
+
+def main(args):
+    logging_dir = Path(args.output_dir, args.logging_dir)
+
+    accelerator = Accelerator(
+        gradient_accumulation_steps=args.gradient_accumulation_steps,
+        mixed_precision=args.mixed_precision,
+        log_with=args.report_to,
+        project_dir=logging_dir,
+    )
+    if args.report_to == "wandb":
+        import wandb
+
+        wandb.login(key=args.wandb_key)
+        wandb.init(project=args.wandb_project_name)
+    # Currently, it's not possible to do gradient accumulation when training two models with accelerate.accumulate
+    # This will be enabled soon in accelerate. For now, we don't allow gradient accumulation when training two models.
+    # TODO (patil-suraj): Remove this check when gradient accumulation with two models is enabled in accelerate.
+    if args.train_text_encoder and args.gradient_accumulation_steps > 1 and accelerator.num_processes > 1:
+        raise ValueError(
+            "Gradient accumulation is not supported when training the text encoder in distributed training. "
+            "Please set gradient_accumulation_steps to 1. This feature will be supported in the future."
+        )
+
+    # Make one log on every process with the configuration for debugging.
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        level=logging.INFO,
+    )
+    logger.info(accelerator.state, main_process_only=False)
+    if accelerator.is_local_main_process:
+        datasets.utils.logging.set_verbosity_warning()
+        transformers.utils.logging.set_verbosity_warning()
+        diffusers.utils.logging.set_verbosity_info()
+    else:
+        datasets.utils.logging.set_verbosity_error()
+        transformers.utils.logging.set_verbosity_error()
+        diffusers.utils.logging.set_verbosity_error()
+
+    # If passed along, set the training seed now.
+    if args.seed is not None:
+        set_seed(args.seed)
+
+    # Generate class images if prior preservation is enabled.
+    if args.with_prior_preservation:
+        class_images_dir = Path(args.class_data_dir)
+        if not class_images_dir.exists():
+            class_images_dir.mkdir(parents=True)
+        cur_class_images = len(list(class_images_dir.iterdir()))
+
+        if cur_class_images < args.num_class_images:
+            dtype = torch.float16 if accelerator.device.type in ["cuda", "xpu"] else torch.float32
+            if args.prior_generation_precision == "fp32":
+                dtype = torch.float32
+            elif args.prior_generation_precision == "fp16":
+                dtype = torch.float16
+            elif args.prior_generation_precision == "bf16":
+                dtype = torch.bfloat16
+            pipeline = DiffusionPipeline.from_pretrained(
+                args.pretrained_model_name_or_path,
+                dtype=dtype,
+                safety_checker=None,
+                revision=args.revision,
+            )
+            pipeline.set_progress_bar_config(disable=True)
+
+            num_new_images = args.num_class_images - cur_class_images
+            logger.info(f"Number of class images to sample: {num_new_images}.")
+
+            sample_dataset = PromptDataset(args.class_prompt, num_new_images)
+            sample_dataloader = torch.utils.data.DataLoader(sample_dataset, batch_size=args.sample_batch_size)
+
+            sample_dataloader = accelerator.prepare(sample_dataloader)
+            pipeline.to(accelerator.device)
+
+            for example in tqdm(
+                sample_dataloader, desc="Generating class images", disable=not accelerator.is_local_main_process
+            ):
+                images = pipeline(example["prompt"]).images
+
+                for i, image in enumerate(images):
+                    hash_image = hashlib.sha1(image.tobytes()).hexdigest()
+                    image_filename = class_images_dir / f"{example['index'][i] + cur_class_images}-{hash_image}.jpg"
+                    image.save(image_filename)
+
+            del pipeline
+
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+            elif torch.xpu.is_available():
+                torch.xpu.empty_cache()
+
+    # Handle the repository creation
+    if accelerator.is_main_process:
+        if args.push_to_hub:
+            api = HfApi(token=args.hub_token)
+
+            # Create repo (repo_name from args or inferred)
+            repo_name = args.hub_model_id
+            if repo_name is None:
+                repo_name = Path(args.output_dir).absolute().name
+            repo_id = api.create_repo(repo_name, exist_ok=True).repo_id
+
+            with open(os.path.join(args.output_dir, ".gitignore"), "w+") as gitignore:
+                if "step_*" not in gitignore:
+                    gitignore.write("step_*\n")
+                if "epoch_*" not in gitignore:
+                    gitignore.write("epoch_*\n")
+        elif args.output_dir is not None:
+            os.makedirs(args.output_dir, exist_ok=True)
+
+    # Load the tokenizer
+    if args.tokenizer_name:
+        tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name, revision=args.revision, use_fast=False)
+    elif args.pretrained_model_name_or_path:
+        tokenizer = AutoTokenizer.from_pretrained(
+            args.pretrained_model_name_or_path,
+            subfolder="tokenizer",
+            revision=args.revision,
+            use_fast=False,
+        )
+
+    # import correct text encoder class
+    text_encoder_cls = import_model_class_from_model_name_or_path(args.pretrained_model_name_or_path, args.revision)
+
+    # Load scheduler and models
+    noise_scheduler = DDPMScheduler(
+        beta_start=0.00085,
+        beta_end=0.012,
+        beta_schedule="scaled_linear",
+        num_train_timesteps=1000,
+    )  # DDPMScheduler.from_pretrained(args.pretrained_model_name_or_path, subfolder="scheduler")
+    text_encoder = text_encoder_cls.from_pretrained(
+        args.pretrained_model_name_or_path, subfolder="text_encoder", revision=args.revision
+    )
+    vae = AutoencoderKL.from_pretrained(args.pretrained_model_name_or_path, subfolder="vae", revision=args.revision)
+    unet = UNet2DConditionModel.from_pretrained(
+        args.pretrained_model_name_or_path, subfolder="unet", revision=args.revision
+    )
+
+    if args.adapter != "full":
+        config = create_unet_adapter_config(args)
+        unet = get_peft_model(unet, config)
+        unet.print_trainable_parameters()
+        print(unet)
+
+    vae.requires_grad_(False)
+    if not args.train_text_encoder:
+        text_encoder.requires_grad_(False)
+    elif args.train_text_encoder and args.adapter != "full":
+        config = create_text_encoder_adapter_config(args)
+        text_encoder = get_peft_model(text_encoder, config)
+        text_encoder.print_trainable_parameters()
+        print(text_encoder)
+
+    if args.enable_xformers_memory_efficient_attention:
+        if accelerator.device.type == "xpu":
+            logger.warning("XPU hasn't support xformers yet, ignore it.")
+        elif is_xformers_available():
+            unet.enable_xformers_memory_efficient_attention()
+        else:
+            raise ValueError("xformers is not available. Make sure it is installed correctly")
+
+    if args.gradient_checkpointing:
+        unet.enable_gradient_checkpointing()
+        if args.train_text_encoder and args.adapter == "full":
+            text_encoder.gradient_checkpointing_enable()
+
+    # Enable TF32 for faster training on Ampere GPUs,
+    # cf https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices
+    if args.allow_tf32 and torch.cuda.is_available():
+        torch.backends.cuda.matmul.allow_tf32 = True
+
+    if args.scale_lr:
+        args.learning_rate = (
+            args.learning_rate * args.gradient_accumulation_steps * args.train_batch_size * accelerator.num_processes
+        )
+
+    # Use 8-bit Adam for lower memory usage or to fine-tune the model in 16GB accelerators
+    if args.use_8bit_adam:
+        try:
+            import bitsandbytes as bnb
+        except ImportError:
+            raise ImportError(
+                "To use 8-bit Adam, please install the bitsandbytes library: `pip install bitsandbytes`."
+            )
+
+        optimizer_class = bnb.optim.AdamW8bit
+    else:
+        optimizer_class = torch.optim.AdamW
+
+    # Optimizer creation
+    params_to_optimize = (
+        itertools.chain(unet.parameters(), text_encoder.parameters()) if args.train_text_encoder else unet.parameters()
+    )
+    optimizer = optimizer_class(
+        params_to_optimize,
+        lr=args.learning_rate,
+        betas=(args.adam_beta1, args.adam_beta2),
+        weight_decay=args.adam_weight_decay,
+        eps=args.adam_epsilon,
+    )
+
+    # Dataset and DataLoaders creation:
+    train_dataset = DreamBoothDataset(
+        instance_data_root=args.instance_data_dir,
+        instance_prompt=args.instance_prompt,
+        class_data_root=args.class_data_dir if args.with_prior_preservation else None,
+        class_prompt=args.class_prompt,
+        tokenizer=tokenizer,
+        size=args.resolution,
+        center_crop=args.center_crop,
+    )
+
+    train_dataloader = torch.utils.data.DataLoader(
+        train_dataset,
+        batch_size=args.train_batch_size,
+        shuffle=True,
+        collate_fn=lambda examples: collate_fn(examples, args.with_prior_preservation),
+        num_workers=1,
+    )
+
+    # Scheduler and math around the number of training steps.
+    overrode_max_train_steps = False
+    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+    if args.max_train_steps is None:
+        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+        overrode_max_train_steps = True
+
+    lr_scheduler = get_scheduler(
+        args.lr_scheduler,
+        optimizer=optimizer,
+        num_warmup_steps=args.lr_warmup_steps * args.gradient_accumulation_steps,
+        num_training_steps=args.max_train_steps * args.gradient_accumulation_steps,
+        num_cycles=args.lr_num_cycles,
+        power=args.lr_power,
+    )
+
+    # Prepare everything with our `accelerator`.
+    if args.train_text_encoder:
+        unet, text_encoder, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
+            unet, text_encoder, optimizer, train_dataloader, lr_scheduler
+        )
+    else:
+        unet, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
+            unet, optimizer, train_dataloader, lr_scheduler
+        )
+
+    # For mixed precision training we cast the text_encoder and vae weights to half-precision
+    # as these models are only used for inference, keeping weights in full precision is not required.
+    weight_dtype = torch.float32
+    if accelerator.mixed_precision == "fp16":
+        weight_dtype = torch.float16
+    elif accelerator.mixed_precision == "bf16":
+        weight_dtype = torch.bfloat16
+
+    # Move vae and text_encoder to device and cast to weight_dtype
+    vae.to(accelerator.device, dtype=weight_dtype)
+    if not args.train_text_encoder:
+        text_encoder.to(accelerator.device, dtype=weight_dtype)
+
+    # We need to recalculate our total training steps as the size of the training dataloader may have changed.
+    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+    if overrode_max_train_steps:
+        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+    # Afterwards we recalculate our number of training epochs
+    args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch)
+
+    # We need to initialize the trackers we use, and also store our configuration.
+    # The trackers initializes automatically on the main process.
+    if accelerator.is_main_process:
+        accelerator.init_trackers("dreambooth", config=vars(args))
+
+    # Train!
+    total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps
+
+    logger.info("***** Running training *****")
+    logger.info(f"  Num examples = {len(train_dataset)}")
+    logger.info(f"  Num batches each epoch = {len(train_dataloader)}")
+    logger.info(f"  Num Epochs = {args.num_train_epochs}")
+    logger.info(f"  Instantaneous batch size per device = {args.train_batch_size}")
+    logger.info(f"  Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}")
+    logger.info(f"  Gradient Accumulation steps = {args.gradient_accumulation_steps}")
+    logger.info(f"  Total optimization steps = {args.max_train_steps}")
+    global_step = 0
+    first_epoch = 0
+
+    # Potentially load in the weights and states from a previous save
+    if args.resume_from_checkpoint:
+        if args.resume_from_checkpoint != "latest":
+            path = os.path.basename(args.resume_from_checkpoint)
+        else:
+            # Get the mos recent checkpoint
+            dirs = os.listdir(args.output_dir)
+            dirs = [d for d in dirs if d.startswith("checkpoint")]
+            dirs = sorted(dirs, key=lambda x: int(x.split("-")[1]))
+            path = dirs[-1]
+        accelerator.print(f"Resuming from checkpoint {path}")
+        accelerator.load_state(os.path.join(args.output_dir, path))
+        global_step = int(path.split("-")[1])
+
+        resume_global_step = global_step * args.gradient_accumulation_steps
+        first_epoch = resume_global_step // num_update_steps_per_epoch
+        resume_step = resume_global_step % num_update_steps_per_epoch
+
+    # Only show the progress bar once on each machine.
+    progress_bar = tqdm(range(global_step, args.max_train_steps), disable=not accelerator.is_local_main_process)
+    progress_bar.set_description("Steps")
+
+    for epoch in range(first_epoch, args.num_train_epochs):
+        unet.train()
+        if args.train_text_encoder:
+            text_encoder.train()
+        with TorchTracemalloc() as tracemalloc:
+            for step, batch in enumerate(train_dataloader):
+                # Skip steps until we reach the resumed step
+                if args.resume_from_checkpoint and epoch == first_epoch and step < resume_step:
+                    if step % args.gradient_accumulation_steps == 0:
+                        progress_bar.update(1)
+                        if args.report_to == "wandb":
+                            accelerator.print(progress_bar)
+                    continue
+
+                with accelerator.accumulate(unet):
+                    # Convert images to latent space
+                    latents = vae.encode(batch["pixel_values"].to(dtype=weight_dtype)).latent_dist.sample()
+                    latents = latents * 0.18215
+
+                    # Sample noise that we'll add to the latents
+                    noise = torch.randn_like(latents)
+                    bsz = latents.shape[0]
+                    # Sample a random timestep for each image
+                    timesteps = torch.randint(
+                        0, noise_scheduler.config.num_train_timesteps, (bsz,), device=latents.device
+                    )
+                    timesteps = timesteps.long()
+
+                    # Add noise to the latents according to the noise magnitude at each timestep
+                    # (this is the forward diffusion process)
+                    noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps)
+
+                    # Get the text embedding for conditioning
+                    encoder_hidden_states = text_encoder(batch["input_ids"])[0]
+
+                    # Predict the noise residual
+                    model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample
+
+                    # Get the target for loss depending on the prediction type
+                    if noise_scheduler.config.prediction_type == "epsilon":
+                        target = noise
+                    elif noise_scheduler.config.prediction_type == "v_prediction":
+                        target = noise_scheduler.get_velocity(latents, noise, timesteps)
+                    else:
+                        raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}")
+
+                    if args.with_prior_preservation:
+                        # Chunk the noise and model_pred into two parts and compute the loss on each part separately.
+                        model_pred, model_pred_prior = torch.chunk(model_pred, 2, dim=0)
+                        target, target_prior = torch.chunk(target, 2, dim=0)
+
+                        # Compute instance loss
+                        loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
+
+                        # Compute prior loss
+                        prior_loss = F.mse_loss(model_pred_prior.float(), target_prior.float(), reduction="mean")
+
+                        # Add the prior loss to the instance loss.
+                        loss = loss + args.prior_loss_weight * prior_loss
+                    else:
+                        loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
+
+                    accelerator.backward(loss)
+                    if accelerator.sync_gradients:
+                        params_to_clip = (
+                            itertools.chain(unet.parameters(), text_encoder.parameters())
+                            if args.train_text_encoder
+                            else unet.parameters()
+                        )
+                        accelerator.clip_grad_norm_(params_to_clip, args.max_grad_norm)
+                    optimizer.step()
+                    lr_scheduler.step()
+                    optimizer.zero_grad()
+
+                # Checks if the accelerator has performed an optimization step behind the scenes
+                if accelerator.sync_gradients:
+                    progress_bar.update(1)
+                    if args.report_to == "wandb":
+                        accelerator.print(progress_bar)
+                    global_step += 1
+
+                    # if global_step % args.checkpointing_steps == 0:
+                    #     if accelerator.is_main_process:
+                    #         save_path = os.path.join(args.output_dir, f"checkpoint-{global_step}")
+                    #         accelerator.save_state(save_path)
+                    #         logger.info(f"Saved state to {save_path}")
+
+                logs = {"loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0]}
+                progress_bar.set_postfix(**logs)
+                accelerator.log(logs, step=global_step)
+
+                if (
+                    args.validation_prompt is not None
+                    and (step + num_update_steps_per_epoch * epoch) % args.validation_steps == 0
+                ):
+                    logger.info(
+                        f"Running validation... \n Generating {args.num_validation_images} images with prompt:"
+                        f" {args.validation_prompt}."
+                    )
+                    # create pipeline
+                    pipeline = DiffusionPipeline.from_pretrained(
+                        args.pretrained_model_name_or_path,
+                        safety_checker=None,
+                        revision=args.revision,
+                    )
+                    # set `keep_fp32_wrapper` to True because we do not want to remove
+                    # mixed precision hooks while we are still training
+                    pipeline.unet = accelerator.unwrap_model(unet, keep_fp32_wrapper=True)
+                    pipeline.text_encoder = accelerator.unwrap_model(text_encoder, keep_fp32_wrapper=True)
+                    pipeline.scheduler = DPMSolverMultistepScheduler.from_config(pipeline.scheduler.config)
+                    pipeline = pipeline.to(accelerator.device)
+                    pipeline.set_progress_bar_config(disable=True)
+
+                    # Set evaluation mode
+                    pipeline.unet.eval()
+                    pipeline.text_encoder.eval()
+
+                    # run inference
+                    if args.seed is not None:
+                        generator = torch.Generator(device=accelerator.device).manual_seed(args.seed)
+                    else:
+                        generator = None
+                    images = []
+                    for _ in range(args.num_validation_images):
+                        image = pipeline(args.validation_prompt, num_inference_steps=25, generator=generator).images[0]
+                        images.append(image)
+
+                    for tracker in accelerator.trackers:
+                        if tracker.name == "tensorboard":
+                            np_images = np.stack([np.asarray(img) for img in images])
+                            tracker.writer.add_images("validation", np_images, epoch, dataformats="NHWC")
+                        if tracker.name == "wandb":
+                            import wandb
+
+                            tracker.log(
+                                {
+                                    "validation": [
+                                        wandb.Image(image, caption=f"{i}: {args.validation_prompt}")
+                                        for i, image in enumerate(images)
+                                    ]
+                                }
+                            )
+
+                    # Set evaluation mode
+                    pipeline.unet.train()
+                    pipeline.text_encoder.train()
+
+                    del pipeline
+                    if torch.cuda.is_available():
+                        torch.cuda.empty_cache()
+                    elif torch.xpu.is_available():
+                        torch.xpu.empty_cache()
+
+                if global_step >= args.max_train_steps:
+                    break
+        # Printing the accelerator memory usage details such as allocated memory, peak memory, and total memory usage
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Memory before entering the train : {b2mb(tracemalloc.begin)}"
+        )
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Memory consumed at the end of the train (end-begin): {tracemalloc.used}"
+        )
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Peak Memory consumed during the train (max-begin): {tracemalloc.peaked}"
+        )
+        accelerator.print(
+            f"{accelerator.device.type.upper()} Total Peak Memory consumed during the train (max): {tracemalloc.peaked + b2mb(tracemalloc.begin)}"
+        )
+
+        accelerator.print(f"CPU Memory before entering the train : {b2mb(tracemalloc.cpu_begin)}")
+        accelerator.print(f"CPU Memory consumed at the end of the train (end-begin): {tracemalloc.cpu_used}")
+        accelerator.print(f"CPU Peak Memory consumed during the train (max-begin): {tracemalloc.cpu_peaked}")
+        accelerator.print(
+            f"CPU Total Peak Memory consumed during the train (max): {tracemalloc.cpu_peaked + b2mb(tracemalloc.cpu_begin)}"
+        )
+
+    # Create the pipeline using using the trained modules and save it.
+    accelerator.wait_for_everyone()
+    if accelerator.is_main_process:
+        if args.adapter != "full":
+            unwarpped_unet = accelerator.unwrap_model(unet)
+            unwarpped_unet.save_pretrained(
+                os.path.join(args.output_dir, "unet"), state_dict=accelerator.get_state_dict(unet)
+            )
+            if args.train_text_encoder:
+                unwarpped_text_encoder = accelerator.unwrap_model(text_encoder)
+                unwarpped_text_encoder.save_pretrained(
+                    os.path.join(args.output_dir, "text_encoder"),
+                    state_dict=accelerator.get_state_dict(text_encoder),
+                )
+        else:
+            pipeline = DiffusionPipeline.from_pretrained(
+                args.pretrained_model_name_or_path,
+                unet=accelerator.unwrap_model(unet),
+                text_encoder=accelerator.unwrap_model(text_encoder),
+                revision=args.revision,
+            )
+            pipeline.save_pretrained(args.output_dir)
+
+        if args.push_to_hub:
+            api.upload_folder(
+                repo_id=repo_id,
+                folder_path=args.output_dir,
+                commit_message="End of training",
+                run_as_future=True,
+            )
+
+    accelerator.end_training()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    main(args)
diff --git a/examples/token_classification/peft_lora_ner.ipynb b/examples/token_classification/peft_lora_ner.ipynb
new file mode 100644
index 0000000..e2a6c04
--- /dev/null
+++ b/examples/token_classification/peft_lora_ner.ipynb
@@ -0,0 +1,554 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Named Entity Recognition with Peft Model 🤗\n",
+    "\n",
+    "##### In this notebook, we will learn how to perform Named Entity Recognition(NER) on the CoNLL-2003 dataset using the Trainer class\n",
+    "\n",
+    "##### This notebook has been adapted from the main NLP course here - https://huggingface.co/learn/nlp-course/chapter7/2?fw=pt#fine-tuning-the-model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#install the required libraries\n",
+    "!pip install -q datasets evaluate transformers seqeval"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Import required libraries\n",
+    "from datasets import load_dataset\n",
+    "from transformers import AutoTokenizer, AutoModelForTokenClassification, DataCollatorForTokenClassification, TrainingArguments, Trainer, pipeline\n",
+    "from peft import get_peft_model, LoraConfig, TaskType\n",
+    "import evaluate\n",
+    "import numpy as np\n",
+    "from huggingface_hub import notebook_login"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "DatasetDict({\n",
+      "    train: Dataset({\n",
+      "        features: ['id', 'tokens', 'pos_tags', 'chunk_tags', 'ner_tags'],\n",
+      "        num_rows: 14041\n",
+      "    })\n",
+      "    validation: Dataset({\n",
+      "        features: ['id', 'tokens', 'pos_tags', 'chunk_tags', 'ner_tags'],\n",
+      "        num_rows: 3250\n",
+      "    })\n",
+      "    test: Dataset({\n",
+      "        features: ['id', 'tokens', 'pos_tags', 'chunk_tags', 'ner_tags'],\n",
+      "        num_rows: 3453\n",
+      "    })\n",
+      "})\n"
+     ]
+    }
+   ],
+   "source": [
+    "raw_datasets = load_dataset(\"conll2003\")\n",
+    "print(raw_datasets)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['EU', 'rejects', 'German', 'call', 'to', 'boycott', 'British', 'lamb', '.']"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Look at the tokens of the first training example\n",
+    "raw_datasets[\"train\"][0][\"tokens\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[3, 0, 7, 0, 0, 0, 7, 0, 0]"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Look at the NER tags of the first training example\n",
+    "raw_datasets[\"train\"][0][\"ner_tags\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['O', 'B-PER', 'I-PER', 'B-ORG', 'I-ORG', 'B-LOC', 'I-LOC', 'B-MISC', 'I-MISC']"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Get the label names for the NER tags\n",
+    "ner_feature = raw_datasets[\"train\"].features[\"ner_tags\"]\n",
+    "label_names = ner_feature.feature.names\n",
+    "label_names"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "EU    rejects German call to boycott British lamb . \n",
+      "B-ORG O       B-MISC O    O  O       B-MISC  O    O \n"
+     ]
+    }
+   ],
+   "source": [
+    "words = raw_datasets[\"train\"][0][\"tokens\"]\n",
+    "labels = raw_datasets[\"train\"][0][\"ner_tags\"]\n",
+    "line1 = \"\"\n",
+    "line2 = \"\"\n",
+    "for word, label in zip(words, labels):\n",
+    "    full_label = label_names[label]\n",
+    "    max_length = max(len(word), len(full_label))\n",
+    "    line1 += word + \" \" * (max_length - len(word) + 1)\n",
+    "    line2 += full_label + \" \" * (max_length - len(full_label) + 1)\n",
+    "\n",
+    "print(line1)\n",
+    "print(line2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load the tokenizer\n",
+    "model_checkpoint = \"bert-base-cased\"\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['[CLS]',\n",
+       " 'EU',\n",
+       " 'rejects',\n",
+       " 'German',\n",
+       " 'call',\n",
+       " 'to',\n",
+       " 'boycott',\n",
+       " 'British',\n",
+       " 'la',\n",
+       " '##mb',\n",
+       " '.',\n",
+       " '[SEP]']"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Tokenize the first training example\n",
+    "inputs = tokenizer(raw_datasets[\"train\"][0][\"tokens\"], is_split_into_words=True)\n",
+    "inputs.tokens()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def align_labels_with_tokens(labels, word_ids):\n",
+    "    new_labels = []\n",
+    "    current_word = None\n",
+    "    for word_id in word_ids:\n",
+    "        if word_id != current_word:\n",
+    "            # Start of a new word!\n",
+    "            current_word = word_id\n",
+    "            label = -100 if word_id is None else labels[word_id]\n",
+    "            new_labels.append(label)\n",
+    "        elif word_id is None:\n",
+    "            # Special token\n",
+    "            new_labels.append(-100)\n",
+    "        else:\n",
+    "            # Same word as previous token\n",
+    "            label = labels[word_id]\n",
+    "            # If the label is B-XXX we change it to I-XXX\n",
+    "            if label % 2 == 1:\n",
+    "                label += 1\n",
+    "            new_labels.append(label)\n",
+    "\n",
+    "    return new_labels"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[3, 0, 7, 0, 0, 0, 7, 0, 0]\n",
+      "[-100, 3, 0, 7, 0, 0, 0, 7, 0, 0, 0, -100]\n"
+     ]
+    }
+   ],
+   "source": [
+    "labels = raw_datasets[\"train\"][0][\"ner_tags\"]\n",
+    "word_ids = inputs.word_ids()\n",
+    "print(labels)\n",
+    "print(align_labels_with_tokens(labels, word_ids))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def tokenize_and_align_labels(examples):\n",
+    "    tokenized_inputs = tokenizer(\n",
+    "        examples[\"tokens\"], truncation=True, is_split_into_words=True\n",
+    "    )\n",
+    "    all_labels = examples[\"ner_tags\"]\n",
+    "    new_labels = []\n",
+    "    for i, labels in enumerate(all_labels):\n",
+    "        word_ids = tokenized_inputs.word_ids(i)\n",
+    "        new_labels.append(align_labels_with_tokens(labels, word_ids))\n",
+    "\n",
+    "    tokenized_inputs[\"labels\"] = new_labels\n",
+    "    return tokenized_inputs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tokenized_datasets = raw_datasets.map(\n",
+    "    tokenize_and_align_labels,\n",
+    "    batched=True,\n",
+    "    remove_columns=raw_datasets[\"train\"].column_names,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data_collator = DataCollatorForTokenClassification(tokenizer=tokenizer)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[-100, 3, 0, 7, 0, 0, 0, 7, 0, 0, 0, -100]\n",
+      "[-100, 1, 2, -100]\n"
+     ]
+    }
+   ],
+   "source": [
+    "for i in range(2):\n",
+    "    print(tokenized_datasets[\"train\"][i][\"labels\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "metric = evaluate.load(\"seqeval\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create label mappings\n",
+    "id2label = {i: label for i, label in enumerate(label_names)}\n",
+    "label2id = {v: k for k, v in id2label.items()}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load the pre-trained model\n",
+    "model = AutoModelForTokenClassification.from_pretrained(\n",
+    "    model_checkpoint,\n",
+    "    id2label=id2label,\n",
+    "    label2id=label2id,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "9"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.config.num_labels"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Configure LoRA (Low-Rank Adaptation) for fine-tuning\n",
+    "peft_config = LoraConfig(target_modules = [\"query\", \"key\"], task_type = TaskType.TOKEN_CLS)\n",
+    "\n",
+    "model = get_peft_model(model, peft_config)\n",
+    "model.print_trainable_parameters()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def compute_metrics(eval_preds):\n",
+    "    logits, labels = eval_preds\n",
+    "    predictions = np.argmax(logits, axis=-1)\n",
+    "\n",
+    "    # Remove ignored index (special tokens) and convert to labels\n",
+    "    true_labels = [[label_names[l] for l in label if l != -100] for label in labels]\n",
+    "    true_predictions = [\n",
+    "        [label_names[p] for (p, l) in zip(prediction, label) if l != -100]\n",
+    "        for prediction, label in zip(predictions, labels)\n",
+    "    ]\n",
+    "    all_metrics = metric.compute(predictions=true_predictions, references=true_labels)\n",
+    "    return {\n",
+    "        \"precision\": all_metrics[\"overall_precision\"],\n",
+    "        \"recall\": all_metrics[\"overall_recall\"],\n",
+    "        \"f1\": all_metrics[\"overall_f1\"],\n",
+    "        \"accuracy\": all_metrics[\"overall_accuracy\"],\n",
+    "    }"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "notebook_login()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "args = TrainingArguments(\n",
+    "    \"bert-finetuned-ner-lora\",\n",
+    "    eval_strategy=\"epoch\",\n",
+    "    per_device_train_batch_size=32, # decrease this for OOM error\n",
+    "    per_device_eval_batch_size=64,\n",
+    "    save_strategy=\"epoch\",\n",
+    "    learning_rate=2e-3,\n",
+    "    num_train_epochs=5,\n",
+    "    weight_decay=0.01,\n",
+    "    load_best_model_at_end=True,\n",
+    "    do_eval=True,\n",
+    "    do_predict=True,\n",
+    "    metric_for_best_model=\"accuracy\",\n",
+    "    label_names=[\"labels\"],\n",
+    "    push_to_hub=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "trainer = Trainer(\n",
+    "    model=model,\n",
+    "    args=args,\n",
+    "    train_dataset=tokenized_datasets[\"train\"],\n",
+    "    eval_dataset=tokenized_datasets[\"validation\"],\n",
+    "    data_collator=data_collator,\n",
+    "    processing_class=tokenizer,\n",
+    "    compute_metrics=compute_metrics\n",
+    ")\n",
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Some weights of BertForTokenClassification were not initialized from the model checkpoint at bert-base-cased and are newly initialized: ['classifier.bias', 'classifier.weight']\n",
+      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n",
+      "Device set to use xpu:0\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "entity_idx: 0, id2label: {0: 'O', 1: 'B-PER', 2: 'I-PER', 3: 'B-ORG', 4: 'I-ORG', 5: 'B-LOC', 6: 'I-LOC', 7: 'B-MISC', 8: 'I-MISC'}\n",
+      "entity_idx: 0, id2label: {0: 'O', 1: 'B-PER', 2: 'I-PER', 3: 'B-ORG', 4: 'I-ORG', 5: 'B-LOC', 6: 'I-LOC', 7: 'B-MISC', 8: 'I-MISC'}\n",
+      "entity_idx: 0, id2label: {0: 'O', 1: 'B-PER', 2: 'I-PER', 3: 'B-ORG', 4: 'I-ORG', 5: 'B-LOC', 6: 'I-LOC', 7: 'B-MISC', 8: 'I-MISC'}\n",
+      "entity_idx: 1, id2label: {0: 'O', 1: 'B-PER', 2: 'I-PER', 3: 'B-ORG', 4: 'I-ORG', 5: 'B-LOC', 6: 'I-LOC', 7: 'B-MISC', 8: 'I-MISC'}\n",
+      "entity_idx: 2, id2label: {0: 'O', 1: 'B-PER', 2: 'I-PER', 3: 'B-ORG', 4: 'I-ORG', 5: 'B-LOC', 6: 'I-LOC', 7: 'B-MISC', 8: 'I-MISC'}\n",
+      "entity_idx: 0, id2label: {0: 'O', 1: 'B-PER', 2: 'I-PER', 3: 'B-ORG', 4: 'I-ORG', 5: 'B-LOC', 6: 'I-LOC', 7: 'B-MISC', 8: 'I-MISC'}\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[{'entity_group': 'PER',\n",
+       "  'score': 0.9702984,\n",
+       "  'word': 'Jino',\n",
+       "  'start': 11,\n",
+       "  'end': 15}]"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from peft import PeftModel\n",
+    "\n",
+    "# Replace this with your own checkpoint\n",
+    "lora_checkpoint = \"./bert-finetuned-ner-lora\"\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)\n",
+    "base_model = AutoModelForTokenClassification.from_pretrained(\n",
+    "    model_checkpoint,\n",
+    "    id2label=id2label,\n",
+    "    label2id=label2id,\n",
+    ")\n",
+    "lora_model = PeftModel.from_pretrained(base_model, lora_checkpoint)\n",
+    "token_classifier = pipeline(\n",
+    "    \"token-classification\", model=lora_model, tokenizer=tokenizer, aggregation_strategy=\"simple\"\n",
+    ")\n",
+    "\n",
+    "token_classifier(\"My name is Jino.\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/token_classification/peft_lora_token_cls.ipynb b/examples/token_classification/peft_lora_token_cls.ipynb
new file mode 100644
index 0000000..0c6c686
--- /dev/null
+++ b/examples/token_classification/peft_lora_token_cls.ipynb
@@ -0,0 +1,1430 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "view-in-github"
+   },
+   "source": [
+    "<a href=\"https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/Fine_tuning_LayoutLMForTokenClassification_on_FUNSD.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "ngqdEv0rP01q"
+   },
+   "source": [
+    "## Introduction\n",
+    "\n",
+    "In this notebook, we are going to fine-tune the LayoutLM model by Microsoft Research on the [FUNSD](https://guillaumejaume.github.io/FUNSD/) dataset, which is a collection of annotated form documents. The goal of our model is to learn the annotations of a number of labels (\"question\", \"answer\", \"header\" and \"other\") on those forms, such that it can be used to annotate unseen forms in the future.\n",
+    "\n",
+    "* Original LayoutLM paper: https://huggingface.co/papers/1912.13318\n",
+    "\n",
+    "* Original FUNSD paper: https://huggingface.co/papers/1905.13538\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "6K4S2s33ebY0"
+   },
+   "source": [
+    "## Install libraries\n",
+    "\n",
+    "Currently you have to first install the `unilm` package, and then the `transformers` package (which updates the outdated `transformers` package that is included in the `unilm` package). The reason we also install the `unilm` package is because we need its preprocessing files. I've forked it, and removed some statements which introduced some issues."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 1000
+    },
+    "id": "5cngOTr6SqEf",
+    "outputId": "6c7a2f76-682b-4f93-a3db-59ab010e5ffe"
+   },
+   "outputs": [],
+   "source": [
+    "! rm -r unilm\n",
+    "! git clone https://github.com/microsoft/unilm.git"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "RGMkEG5aRB0D"
+   },
+   "source": [
+    "## Getting the data\n",
+    "\n",
+    "Here we download the data of the [FUNSD dataset](https://guillaumejaume.github.io/FUNSD/) from the web. This results in a directory called \"data\" being created, which has 2 subdirectories, one for training and one for testing. Each of those has 2 subdirectories in turn, one containing the images as png files and one containing the annotations in json format."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "DTFnEZagQm4v",
+    "outputId": "97ce03ba-a6bb-4444-8eba-77eceece44e0"
+   },
+   "outputs": [],
+   "source": [
+    "! wget https://guillaumejaume.github.io/FUNSD/dataset.zip\n",
+    "! unzip dataset.zip && mv dataset data && rm -rf dataset.zip __MACOSX"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "UrNMR64LsJXm"
+   },
+   "source": [
+    "Let's take a look at a training example. For this, we are going to use PIL (Python Image Library)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 1000
+    },
+    "id": "eG-eGcj3sNPs",
+    "outputId": "69ead0ea-15d6-4d5e-af61-a99a7533d31b"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "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",
+      "image/png": "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",
+      "text/plain": [
+       "<PIL.Image.Image image mode=RGB size=762x1000>"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from PIL import Image, ImageDraw, ImageFont\n",
+    "import os\n",
+    "\n",
+    "base_path = \"./data\"\n",
+    "\n",
+    "image = Image.open(os.path.join(base_path, \"training_data/images/0000971160.png\"))\n",
+    "image = image.convert(\"RGB\")\n",
+    "image"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "uAVffmnZyUvw"
+   },
+   "source": [
+    "Now let's plot its corresponding annotations. Basically, if you type `data['form']`, you get a list of all general annotations. Each general annotation has a label, a bounding box, and one or more words, which in also have their own bounding box. The bounding boxes are in [xleft, ytop, xright, ybottom] format.\n",
+    " "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "JPKkuJQ4sdZc",
+    "outputId": "c95bf306-98bb-4480-cc6b-ebb3aea548b3"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'box': [292, 91, 376, 175], 'text': 'R&D', 'label': 'other', 'words': [{'box': [292, 91, 376, 175], 'text': 'R&D'}], 'linking': [], 'id': 0}\n",
+      "{'box': [219, 316, 225, 327], 'text': ':', 'label': 'question', 'words': [{'box': [219, 316, 225, 327], 'text': ':'}], 'linking': [], 'id': 1}\n",
+      "{'box': [95, 355, 169, 370], 'text': 'Suggestion:', 'label': 'question', 'words': [{'box': [95, 355, 169, 370], 'text': 'Suggestion:'}], 'linking': [[2, 16]], 'id': 2}\n",
+      "{'box': [482, 268, 518, 282], 'text': 'Date:', 'label': 'question', 'words': [{'box': [482, 268, 518, 282], 'text': 'Date:'}], 'linking': [[3, 12]], 'id': 3}\n",
+      "{'box': [511, 309, 570, 323], 'text': 'Licensee', 'label': 'answer', 'words': [{'box': [511, 309, 570, 323], 'text': 'Licensee'}], 'linking': [[13, 4]], 'id': 4}\n",
+      "{'box': [211, 651, 217, 662], 'text': '', 'label': 'question', 'words': [{'box': [211, 651, 217, 662], 'text': ''}], 'linking': [], 'id': 5}\n",
+      "{'box': [461, 605, 483, 619], 'text': 'Yes', 'label': 'question', 'words': [{'box': [461, 605, 483, 619], 'text': 'Yes'}], 'linking': [[19, 6]], 'id': 6}\n",
+      "{'box': [545, 603, 563, 617], 'text': 'No', 'label': 'question', 'words': [{'box': [545, 603, 563, 617], 'text': 'No'}], 'linking': [[19, 7]], 'id': 7}\n",
+      "{'box': [525, 904, 641, 926], 'text': '597005708', 'label': 'other', 'words': [{'box': [525, 904, 641, 926], 'text': '597005708'}], 'linking': [], 'id': 8}\n",
+      "{'text': 'R&D QUALITY IMPROVEMENT SUGGESTION/ SOLUTION FORM', 'box': [256, 201, 423, 230], 'linking': [], 'label': 'header', 'words': [{'text': 'R&D', 'box': [257, 203, 279, 214]}, {'text': 'QUALITY', 'box': [285, 203, 334, 216]}, {'text': 'IMPROVEMENT', 'box': [341, 201, 418, 211]}, {'text': 'SUGGESTION/', 'box': [256, 215, 324, 229]}, {'text': '', 'box': [324, 216, 332, 230]}, {'text': 'SOLUTION', 'box': [331, 214, 387, 228]}, {'text': 'FORM', 'box': [395, 215, 423, 228]}], 'id': 9}\n",
+      "{'text': 'Name / Phone Ext. :', 'box': [89, 272, 204, 289], 'linking': [[10, 11]], 'label': 'question', 'words': [{'text': 'Name', 'box': [89, 274, 118, 289]}, {'text': '/', 'box': [117, 274, 127, 288]}, {'text': 'Phone', 'box': [128, 274, 163, 289]}, {'text': 'Ext.', 'box': [169, 272, 196, 287]}, {'text': ':', 'box': [196, 274, 204, 288]}], 'id': 10}\n",
+      "{'text': 'M. Hamann P. Harper, P. Martinez', 'box': [215, 271, 451, 287], 'linking': [[10, 11]], 'label': 'answer', 'words': [{'text': 'M.', 'box': [215, 272, 230, 287]}, {'text': 'Hamann', 'box': [237, 272, 287, 286]}, {'text': 'P.', 'box': [293, 272, 307, 286]}, {'text': 'Harper,', 'box': [314, 274, 363, 285]}, {'text': 'P.', 'box': [370, 272, 384, 285]}, {'text': 'Martinez', 'box': [390, 271, 451, 282]}], 'id': 11}\n",
+      "{'text': '9/ 3/ 92', 'box': [543, 264, 590, 279], 'linking': [[3, 12]], 'label': 'answer', 'words': [{'text': '9/', 'box': [543, 265, 560, 279]}, {'text': '3/', 'box': [560, 264, 575, 279]}, {'text': '92', 'box': [575, 264, 590, 279]}], 'id': 12}\n",
+      "{'text': 'R&D Group:', 'box': [420, 310, 491, 323], 'linking': [[13, 4]], 'label': 'question', 'words': [{'text': 'R&D', 'box': [420, 310, 442, 323]}, {'text': 'Group:', 'box': [448, 310, 491, 323]}], 'id': 13}\n",
+      "{'text': 'J. S. Wigand', 'box': [236, 313, 327, 327], 'linking': [[15, 14]], 'label': 'answer', 'words': [{'text': 'J.', 'box': [236, 313, 251, 327]}, {'text': 'S.', 'box': [256, 313, 273, 326]}, {'text': 'Wigand', 'box': [278, 313, 327, 327]}], 'id': 14}\n",
+      "{'text': 'Supervisor / Manager', 'box': [91, 316, 218, 331], 'linking': [[15, 14]], 'label': 'question', 'words': [{'text': 'Supervisor', 'box': [91, 316, 161, 330]}, {'text': '/', 'box': [163, 318, 169, 331]}, {'text': 'Manager', 'box': [169, 317, 218, 327]}], 'id': 15}\n",
+      "{'text': 'Discontinue coal retention analyses on licensee submitted product samples (Note : Coal Retention testing is not performed by most licensees. Other B&W physical measurements as ends stability and inspection for soft spots in ciparettes are thought to be sufficient measures to assure cigarette physical integrity. The proposed action will increase laboratory productivity . )', 'box': [190, 346, 594, 447], 'linking': [[2, 16]], 'label': 'answer', 'words': [{'text': 'Discontinue', 'box': [190, 355, 268, 366]}, {'text': 'coal', 'box': [274, 353, 303, 366]}, {'text': 'retention', 'box': [309, 352, 375, 365]}, {'text': 'analyses', 'box': [381, 351, 435, 365]}, {'text': 'on', 'box': [443, 352, 458, 363]}, {'text': 'licensee', 'box': [464, 348, 520, 362]}, {'text': 'submitted', 'box': [527, 346, 594, 361]}, {'text': 'product', 'box': [190, 369, 240, 383]}, {'text': 'samples', 'box': [247, 367, 301, 380]}, {'text': '(Note', 'box': [318, 365, 352, 379]}, {'text': ':', 'box': [352, 367, 359, 380]}, {'text': 'Coal', 'box': [373, 366, 402, 376]}, {'text': 'Retention', 'box': [408, 366, 472, 376]}, {'text': 'testing', 'box': [479, 365, 529, 376]}, {'text': 'is', 'box': [536, 363, 549, 374]}, {'text': 'not', 'box': [554, 363, 578, 374]}, {'text': 'performed', 'box': [190, 383, 256, 394]}, {'text': 'by', 'box': [261, 381, 275, 394]}, {'text': 'most', 'box': [282, 383, 311, 393]}, {'text': 'licensees.', 'box': [318, 380, 386, 391]}, {'text': 'Other', 'box': [401, 378, 437, 389]}, {'text': 'B&W', 'box': [443, 378, 465, 389]}, {'text': 'physical', 'box': [471, 377, 528, 391]}, {'text': 'measurements', 'box': [191, 398, 275, 406]}, {'text': 'as', 'box': [282, 397, 297, 405]}, {'text': 'ends', 'box': [304, 394, 332, 405]}, {'text': 'stability', 'box': [339, 394, 402, 405]}, {'text': 'and', 'box': [409, 392, 430, 402]}, {'text': 'inspection', 'box': [437, 392, 508, 403]}, {'text': 'for', 'box': [515, 391, 535, 402]}, {'text': 'soft', 'box': [542, 391, 571, 401]}, {'text': 'spots', 'box': [193, 411, 228, 422]}, {'text': 'in', 'box': [235, 409, 250, 420]}, {'text': 'ciparettes', 'box': [256, 409, 327, 419]}, {'text': 'are', 'box': [332, 408, 352, 418]}, {'text': 'thought', 'box': [360, 406, 410, 419]}, {'text': 'to', 'box': [415, 406, 430, 416]}, {'text': 'be', 'box': [436, 404, 453, 417]}, {'text': 'sufficient', 'box': [458, 405, 529, 415]}, {'text': 'measures', 'box': [535, 405, 592, 415]}, {'text': 'to', 'box': [193, 425, 208, 433]}, {'text': 'assure', 'box': [214, 423, 255, 431]}, {'text': 'cigarette', 'box': [261, 420, 325, 434]}, {'text': 'physical', 'box': [331, 419, 390, 432]}, {'text': 'integrity.', 'box': [395, 418, 463, 431]}, {'text': 'The', 'box': [478, 416, 500, 429]}, {'text': 'proposed', 'box': [506, 418, 566, 431]}, {'text': 'action', 'box': [193, 436, 236, 447]}, {'text': 'will', 'box': [240, 436, 269, 447]}, {'text': 'increase', 'box': [277, 434, 333, 445]}, {'text': 'laboratory', 'box': [339, 433, 410, 446]}, {'text': 'productivity', 'box': [418, 430, 502, 445]}, {'text': '.', 'box': [503, 433, 507, 444]}, {'text': ')', 'box': [508, 430, 514, 444]}], 'id': 16}\n",
+      "{'text': 'Suggested Solutions (s) :', 'box': [95, 486, 250, 504], 'linking': [[17, 18]], 'label': 'question', 'words': [{'text': 'Suggested', 'box': [95, 489, 159, 504]}, {'text': 'Solutions', 'box': [165, 487, 222, 501]}, {'text': '(s)', 'box': [223, 486, 241, 503]}, {'text': ':', 'box': [243, 489, 250, 503]}], 'id': 17}\n",
+      "{'text': 'Delete coal retention from the list of standard analyses performed on licensee submitted product samples. Special requests for coal retention testing could still be submitted on an exception basis.', 'box': [263, 483, 593, 553], 'linking': [[17, 18]], 'label': 'answer', 'words': [{'text': 'Delete', 'box': [263, 486, 306, 500]}, {'text': 'coal', 'box': [313, 486, 341, 499]}, {'text': 'retention', 'box': [348, 486, 412, 497]}, {'text': 'from', 'box': [416, 485, 447, 498]}, {'text': 'the', 'box': [453, 485, 475, 498]}, {'text': 'list', 'box': [480, 483, 508, 496]}, {'text': 'of', 'box': [515, 483, 532, 494]}, {'text': 'standard', 'box': [536, 483, 593, 494]}, {'text': 'analyses', 'box': [264, 501, 320, 514]}, {'text': 'performed', 'box': [324, 501, 392, 512]}, {'text': 'on', 'box': [397, 501, 412, 511]}, {'text': 'licensee', 'box': [419, 499, 475, 512]}, {'text': 'submitted', 'box': [482, 499, 546, 510]}, {'text': 'product', 'box': [264, 517, 314, 528]}, {'text': 'samples.', 'box': [320, 514, 374, 528]}, {'text': 'Special', 'box': [390, 513, 439, 526]}, {'text': 'requests', 'box': [446, 513, 502, 524]}, {'text': 'for', 'box': [508, 511, 530, 522]}, {'text': 'coal', 'box': [538, 510, 566, 523]}, {'text': 'retention', 'box': [263, 529, 330, 540]}, {'text': 'testing', 'box': [335, 527, 387, 540]}, {'text': 'could', 'box': [390, 527, 428, 538]}, {'text': 'still', 'box': [433, 525, 468, 536]}, {'text': 'be', 'box': [473, 525, 488, 535]}, {'text': 'submitted', 'box': [496, 524, 560, 537]}, {'text': 'on', 'box': [566, 524, 584, 537]}, {'text': 'an', 'box': [264, 543, 281, 553]}, {'text': 'exception', 'box': [286, 539, 350, 553]}, {'text': 'basis.', 'box': [355, 541, 397, 551]}], 'id': 18}\n",
+      "{'text': 'Have you contacted your Manager/ Supervisor?', 'box': [96, 608, 398, 624], 'linking': [[19, 6], [19, 7]], 'label': 'header', 'words': [{'text': 'Have', 'box': [96, 612, 127, 623]}, {'text': 'you', 'box': [131, 613, 156, 624]}, {'text': 'contacted', 'box': [161, 612, 225, 623]}, {'text': 'your', 'box': [229, 610, 260, 623]}, {'text': 'Manager/', 'box': [264, 609, 314, 622]}, {'text': '', 'box': [314, 608, 322, 622]}, {'text': 'Supervisor?', 'box': [323, 608, 398, 621]}], 'id': 19}\n",
+      "{'text': 'Manager Comments:', 'box': [98, 651, 211, 665], 'linking': [[20, 21], [20, 22]], 'label': 'question', 'words': [{'text': 'Manager', 'box': [98, 654, 150, 665]}, {'text': 'Comments:', 'box': [154, 651, 211, 664]}], 'id': 20}\n",
+      "{'text': 'Manager, please contact suggester and forward', 'box': [232, 644, 547, 662], 'linking': [[20, 21]], 'label': 'answer', 'words': [{'text': 'Manager,', 'box': [232, 648, 288, 662]}, {'text': 'please', 'box': [296, 649, 338, 662]}, {'text': 'contact', 'box': [344, 648, 394, 662]}, {'text': 'suggester', 'box': [401, 648, 464, 661]}, {'text': 'and', 'box': [469, 647, 491, 658]}, {'text': 'forward', 'box': [497, 644, 547, 657]}], 'id': 21}\n",
+      "{'text': 'comments to the Quality Council.', 'box': [99, 662, 323, 677], 'linking': [[20, 22]], 'label': 'answer', 'words': [{'text': 'comments', 'box': [99, 666, 155, 677]}, {'text': 'to', 'box': [162, 665, 177, 676]}, {'text': 'the', 'box': [183, 665, 205, 675]}, {'text': 'Quality', 'box': [211, 663, 261, 676]}, {'text': 'Council.', 'box': [267, 662, 323, 676]}], 'id': 22}\n",
+      "{'text': 'qip . wp', 'box': [102, 823, 145, 838], 'linking': [], 'label': 'other', 'words': [{'text': 'qip', 'box': [102, 824, 123, 837]}, {'text': '.', 'box': [124, 824, 130, 838]}, {'text': 'wp', 'box': [130, 823, 145, 837]}], 'id': 23}\n"
+     ]
+    }
+   ],
+   "source": [
+    "import json\n",
+    "\n",
+    "with open(os.path.join(base_path, \"training_data/annotations/0000971160.json\")) as f:\n",
+    "    data = json.load(f)\n",
+    "\n",
+    "for annotation in data[\"form\"]:\n",
+    "    print(annotation)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Hs4L3S5a2Gfb"
+   },
+   "source": [
+    "The PIL library has a handy ImageDraw module, which -you guessed it- allows to draw things (such as rectangles) on an image:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 1000
+    },
+    "id": "gWaHFM_LtKPP",
+    "outputId": "c498e560-035f-4170-b0b9-85ba3956711c"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "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",
+      "image/png": "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",
+      "text/plain": [
+       "<PIL.Image.Image image mode=RGB size=762x1000>"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "draw = ImageDraw.Draw(image, \"RGBA\")\n",
+    "\n",
+    "font = ImageFont.load_default()\n",
+    "\n",
+    "label2color = {\"question\": \"blue\", \"answer\": \"green\", \"header\": \"orange\", \"other\": \"violet\"}\n",
+    "\n",
+    "for annotation in data[\"form\"]:\n",
+    "    label = annotation[\"label\"]\n",
+    "    general_box = annotation[\"box\"]\n",
+    "    draw.rectangle(general_box, outline=label2color[label], width=2)\n",
+    "    draw.text((general_box[0] + 10, general_box[1] - 10), label, fill=label2color[label], font=font)\n",
+    "    words = annotation[\"words\"]\n",
+    "    for word in words:\n",
+    "        box = word[\"box\"]\n",
+    "        draw.rectangle(box, outline=label2color[label], width=1)\n",
+    "\n",
+    "image"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "uyWQNLSCRJN7"
+   },
+   "source": [
+    "## Preprocessing the data\n",
+    "\n",
+    "Next, we need to turn the document images into individual tokens and corresponding labels (BIOES format, see further). We do this both for the training and test datasets. Make sure to run this from the `/content` directory:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "4DWRyOR9RuY6",
+    "outputId": "4215a24b-8049-4b1a-a23f-5aaa48e14083"
+   },
+   "outputs": [],
+   "source": [
+    "! python unilm/layoutlm/deprecated/examples/seq_labeling/preprocess.py --data_dir data/training_data/annotations \\\n",
+    "                                                      --data_split train \\\n",
+    "                                                      --output_dir data \\\n",
+    "                                                      --model_name_or_path microsoft/layoutlm-base-uncased \\\n",
+    "                                                      --max_len 510\n",
+    "\n",
+    "! python unilm/layoutlm/deprecated/examples/seq_labeling/preprocess.py --data_dir data/testing_data/annotations \\\n",
+    "                                                      --data_split test \\\n",
+    "                                                      --output_dir data \\\n",
+    "                                                      --model_name_or_path microsoft/layoutlm-base-uncased \\\n",
+    "                                                      --max_len 510"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "gc4Cu0ZyO5M_"
+   },
+   "source": [
+    "Next, we create a labels.txt file that contains the unique labels of the FUNSD dataset:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "8iGOU0s3UR2u"
+   },
+   "outputs": [],
+   "source": [
+    "! cat data/train.txt | cut -d$'\\t' -f 2 | grep -v \"^$\"| sort | uniq > data/labels.txt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "mC9FhkG9U8yg"
+   },
+   "source": [
+    "## Define a PyTorch dataset\n",
+    "\n",
+    "First, we create a list containing the unique labels based on `data/labels.txt` (run this from the content directory):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {
+    "id": "675rRa0QXnMp"
+   },
+   "outputs": [],
+   "source": [
+    "from torch.nn import CrossEntropyLoss\n",
+    "\n",
+    "\n",
+    "def get_labels(path):\n",
+    "    with open(path, \"r\") as f:\n",
+    "        labels = f.read().splitlines()\n",
+    "    if \"O\" not in labels:\n",
+    "        labels = [\"O\"] + labels\n",
+    "    return labels\n",
+    "\n",
+    "\n",
+    "labels = get_labels(\"data/labels.txt\")\n",
+    "num_labels = len(labels)\n",
+    "label_map = {i: label for i, label in enumerate(labels)}\n",
+    "# Use cross entropy ignore index as padding label id so that only real label ids contribute to the loss later\n",
+    "pad_token_label_id = CrossEntropyLoss().ignore_index"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "kZ2LGEsez2u2"
+   },
+   "source": [
+    "We can see that the dataset uses the so-called BIOES annotation scheme to annotate the tokens. This means that a given token can be either at the beginning (B), inside (I), outside (O), at the end (E) or start (S) of a given entity. Entities include ANSWER, QUESTION, HEADER and OTHER: "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "_-qXLkP9Yq_L",
+    "outputId": "32ab46a4-4cf0-400c-816b-570f950035ec"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['B-ANSWER', 'B-HEADER', 'B-QUESTION', 'E-ANSWER', 'E-HEADER', 'E-QUESTION', 'I-ANSWER', 'I-HEADER', 'I-QUESTION', 'O', 'S-ANSWER', 'S-HEADER', 'S-QUESTION']\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(labels)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "9_ck0ZFfZInR"
+   },
+   "source": [
+    "Next, we can create a PyTorch dataset and corresponding dataloader (both for training and evaluation):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import logging\n",
+    "import os\n",
+    "\n",
+    "import torch\n",
+    "from torch.utils.data import Dataset\n",
+    "\n",
+    "logger = logging.getLogger(__name__)\n",
+    "\n",
+    "\n",
+    "class FunsdDataset(Dataset):\n",
+    "    def __init__(self, args, tokenizer, labels, pad_token_label_id, mode):\n",
+    "        if args.local_rank not in [-1, 0] and mode == \"train\":\n",
+    "            torch.distributed.barrier()  # Make sure only the first process in distributed training process the dataset, and the others will use the cache\n",
+    "\n",
+    "        # Load data features from cache or dataset file\n",
+    "        cached_features_file = os.path.join(\n",
+    "            args.data_dir,\n",
+    "            \"cached_{}_{}_{}\".format(\n",
+    "                mode,\n",
+    "                list(filter(None, args.model_name_or_path.split(\"/\"))).pop(),\n",
+    "                str(args.max_seq_length),\n",
+    "            ),\n",
+    "        )\n",
+    "        if os.path.exists(cached_features_file) and not args.overwrite_cache:\n",
+    "            logger.info(\"Loading features from cached file %s\", cached_features_file)\n",
+    "            features = torch.load(cached_features_file)\n",
+    "        else:\n",
+    "            logger.info(\"Creating features from dataset file at %s\", args.data_dir)\n",
+    "            examples = read_examples_from_file(args.data_dir, mode)\n",
+    "            features = convert_examples_to_features(\n",
+    "                examples,\n",
+    "                labels,\n",
+    "                args.max_seq_length,\n",
+    "                tokenizer,\n",
+    "                cls_token_at_end=bool(args.model_type in [\"xlnet\"]),\n",
+    "                # xlnet has a cls token at the end\n",
+    "                cls_token=tokenizer.cls_token,\n",
+    "                cls_token_segment_id=2 if args.model_type in [\"xlnet\"] else 0,\n",
+    "                sep_token=tokenizer.sep_token,\n",
+    "                sep_token_extra=bool(args.model_type in [\"roberta\"]),\n",
+    "                # roberta uses an extra separator b/w pairs of sentences, cf. github.com/pytorch/fairseq/commit/1684e166e3da03f5b600dbb7855cb98ddfcd0805\n",
+    "                pad_on_left=bool(args.model_type in [\"xlnet\"]),\n",
+    "                # pad on the left for xlnet\n",
+    "                pad_token=tokenizer.convert_tokens_to_ids([tokenizer.pad_token])[0],\n",
+    "                pad_token_segment_id=4 if args.model_type in [\"xlnet\"] else 0,\n",
+    "                pad_token_label_id=pad_token_label_id,\n",
+    "            )\n",
+    "            # if args.local_rank in [-1, 0]:\n",
+    "            # logger.info(\"Saving features into cached file %s\", cached_features_file)\n",
+    "            # torch.save(features, cached_features_file)\n",
+    "\n",
+    "        if args.local_rank == 0 and mode == \"train\":\n",
+    "            torch.distributed.barrier()  # Make sure only the first process in distributed training process the dataset, and the others will use the cache\n",
+    "\n",
+    "        self.features = features\n",
+    "        # Convert to Tensors and build dataset\n",
+    "        self.all_input_ids = torch.tensor([f.input_ids for f in features], dtype=torch.long)\n",
+    "        self.all_input_mask = torch.tensor([f.input_mask for f in features], dtype=torch.long)\n",
+    "        self.all_segment_ids = torch.tensor([f.segment_ids for f in features], dtype=torch.long)\n",
+    "        self.all_label_ids = torch.tensor([f.label_ids for f in features], dtype=torch.long)\n",
+    "        self.all_bboxes = torch.tensor([f.boxes for f in features], dtype=torch.long)\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        return len(self.features)\n",
+    "\n",
+    "    def __getitem__(self, index):\n",
+    "        return (\n",
+    "            self.all_input_ids[index],\n",
+    "            self.all_input_mask[index],\n",
+    "            self.all_segment_ids[index],\n",
+    "            self.all_label_ids[index],\n",
+    "            self.all_bboxes[index],\n",
+    "        )\n",
+    "\n",
+    "\n",
+    "class InputExample(object):\n",
+    "    \"\"\"A single training/test example for token classification.\"\"\"\n",
+    "\n",
+    "    def __init__(self, guid, words, labels, boxes, actual_bboxes, file_name, page_size):\n",
+    "        \"\"\"Constructs a InputExample.\n",
+    "\n",
+    "        Args:\n",
+    "            guid: Unique id for the example.\n",
+    "            words: list. The words of the sequence.\n",
+    "            labels: (Optional) list. The labels for each word of the sequence. This should be\n",
+    "            specified for train and dev examples, but not for test examples.\n",
+    "        \"\"\"\n",
+    "        self.guid = guid\n",
+    "        self.words = words\n",
+    "        self.labels = labels\n",
+    "        self.boxes = boxes\n",
+    "        self.actual_bboxes = actual_bboxes\n",
+    "        self.file_name = file_name\n",
+    "        self.page_size = page_size\n",
+    "\n",
+    "\n",
+    "class InputFeatures(object):\n",
+    "    \"\"\"A single set of features of data.\"\"\"\n",
+    "\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        input_ids,\n",
+    "        input_mask,\n",
+    "        segment_ids,\n",
+    "        label_ids,\n",
+    "        boxes,\n",
+    "        actual_bboxes,\n",
+    "        file_name,\n",
+    "        page_size,\n",
+    "    ):\n",
+    "        assert (\n",
+    "            0 <= all(boxes) <= 1000\n",
+    "        ), \"Error with input bbox ({}): the coordinate value is not between 0 and 1000\".format(boxes)\n",
+    "        self.input_ids = input_ids\n",
+    "        self.input_mask = input_mask\n",
+    "        self.segment_ids = segment_ids\n",
+    "        self.label_ids = label_ids\n",
+    "        self.boxes = boxes\n",
+    "        self.actual_bboxes = actual_bboxes\n",
+    "        self.file_name = file_name\n",
+    "        self.page_size = page_size\n",
+    "\n",
+    "\n",
+    "def read_examples_from_file(data_dir, mode):\n",
+    "    file_path = os.path.join(data_dir, \"{}.txt\".format(mode))\n",
+    "    box_file_path = os.path.join(data_dir, \"{}_box.txt\".format(mode))\n",
+    "    image_file_path = os.path.join(data_dir, \"{}_image.txt\".format(mode))\n",
+    "    guid_index = 1\n",
+    "    examples = []\n",
+    "    with open(file_path, encoding=\"utf-8\") as f, open(box_file_path, encoding=\"utf-8\") as fb, open(\n",
+    "        image_file_path, encoding=\"utf-8\"\n",
+    "    ) as fi:\n",
+    "        words = []\n",
+    "        boxes = []\n",
+    "        actual_bboxes = []\n",
+    "        file_name = None\n",
+    "        page_size = None\n",
+    "        labels = []\n",
+    "        for line, bline, iline in zip(f, fb, fi):\n",
+    "            if line.startswith(\"-DOCSTART-\") or line == \"\" or line == \"\\n\":\n",
+    "                if words:\n",
+    "                    examples.append(\n",
+    "                        InputExample(\n",
+    "                            guid=\"{}-{}\".format(mode, guid_index),\n",
+    "                            words=words,\n",
+    "                            labels=labels,\n",
+    "                            boxes=boxes,\n",
+    "                            actual_bboxes=actual_bboxes,\n",
+    "                            file_name=file_name,\n",
+    "                            page_size=page_size,\n",
+    "                        )\n",
+    "                    )\n",
+    "                    guid_index += 1\n",
+    "                    words = []\n",
+    "                    boxes = []\n",
+    "                    actual_bboxes = []\n",
+    "                    file_name = None\n",
+    "                    page_size = None\n",
+    "                    labels = []\n",
+    "            else:\n",
+    "                splits = line.split(\"\\t\")\n",
+    "                bsplits = bline.split(\"\\t\")\n",
+    "                isplits = iline.split(\"\\t\")\n",
+    "                assert len(splits) == 2\n",
+    "                assert len(bsplits) == 2\n",
+    "                assert len(isplits) == 4\n",
+    "                assert splits[0] == bsplits[0]\n",
+    "                words.append(splits[0])\n",
+    "                if len(splits) > 1:\n",
+    "                    labels.append(splits[-1].replace(\"\\n\", \"\"))\n",
+    "                    box = bsplits[-1].replace(\"\\n\", \"\")\n",
+    "                    box = [int(b) for b in box.split()]\n",
+    "                    boxes.append(box)\n",
+    "                    actual_bbox = [int(b) for b in isplits[1].split()]\n",
+    "                    actual_bboxes.append(actual_bbox)\n",
+    "                    page_size = [int(i) for i in isplits[2].split()]\n",
+    "                    file_name = isplits[3].strip()\n",
+    "                else:\n",
+    "                    # Examples could have no label for mode = \"test\"\n",
+    "                    labels.append(\"O\")\n",
+    "        if words:\n",
+    "            examples.append(\n",
+    "                InputExample(\n",
+    "                    guid=\"%s-%d\".format(mode, guid_index),\n",
+    "                    words=words,\n",
+    "                    labels=labels,\n",
+    "                    boxes=boxes,\n",
+    "                    actual_bboxes=actual_bboxes,\n",
+    "                    file_name=file_name,\n",
+    "                    page_size=page_size,\n",
+    "                )\n",
+    "            )\n",
+    "    return examples\n",
+    "\n",
+    "\n",
+    "def convert_examples_to_features(\n",
+    "    examples,\n",
+    "    label_list,\n",
+    "    max_seq_length,\n",
+    "    tokenizer,\n",
+    "    cls_token_at_end=False,\n",
+    "    cls_token=\"[CLS]\",\n",
+    "    cls_token_segment_id=1,\n",
+    "    sep_token=\"[SEP]\",\n",
+    "    sep_token_extra=False,\n",
+    "    pad_on_left=False,\n",
+    "    pad_token=0,\n",
+    "    cls_token_box=[0, 0, 0, 0],\n",
+    "    sep_token_box=[1000, 1000, 1000, 1000],\n",
+    "    pad_token_box=[0, 0, 0, 0],\n",
+    "    pad_token_segment_id=0,\n",
+    "    pad_token_label_id=-1,\n",
+    "    sequence_a_segment_id=0,\n",
+    "    mask_padding_with_zero=True,\n",
+    "):\n",
+    "    \"\"\"Loads a data file into a list of `InputBatch`s\n",
+    "    `cls_token_at_end` define the location of the CLS token:\n",
+    "        - False (Default, BERT/XLM pattern): [CLS] + A + [SEP] + B + [SEP]\n",
+    "        - True (XLNet/GPT pattern): A + [SEP] + B + [SEP] + [CLS]\n",
+    "    `cls_token_segment_id` define the segment id associated to the CLS token (0 for BERT, 2 for XLNet)\n",
+    "    \"\"\"\n",
+    "\n",
+    "    label_map = {label: i for i, label in enumerate(label_list)}\n",
+    "\n",
+    "    features = []\n",
+    "    for ex_index, example in enumerate(examples):\n",
+    "        file_name = example.file_name\n",
+    "        page_size = example.page_size\n",
+    "        width, height = page_size\n",
+    "        if ex_index % 10000 == 0:\n",
+    "            logger.info(\"Writing example %d of %d\", ex_index, len(examples))\n",
+    "\n",
+    "        tokens = []\n",
+    "        token_boxes = []\n",
+    "        actual_bboxes = []\n",
+    "        label_ids = []\n",
+    "        for word, label, box, actual_bbox in zip(example.words, example.labels, example.boxes, example.actual_bboxes):\n",
+    "            word_tokens = tokenizer.tokenize(word)\n",
+    "            tokens.extend(word_tokens)\n",
+    "            token_boxes.extend([box] * len(word_tokens))\n",
+    "            actual_bboxes.extend([actual_bbox] * len(word_tokens))\n",
+    "            # Use the real label id for the first token of the word, and padding ids for the remaining tokens\n",
+    "            label_ids.extend([label_map[label]] + [pad_token_label_id] * (len(word_tokens) - 1))\n",
+    "\n",
+    "        # Account for [CLS] and [SEP] with \"- 2\" and with \"- 3\" for RoBERTa.\n",
+    "        special_tokens_count = 3 if sep_token_extra else 2\n",
+    "        if len(tokens) > max_seq_length - special_tokens_count:\n",
+    "            tokens = tokens[: (max_seq_length - special_tokens_count)]\n",
+    "            token_boxes = token_boxes[: (max_seq_length - special_tokens_count)]\n",
+    "            actual_bboxes = actual_bboxes[: (max_seq_length - special_tokens_count)]\n",
+    "            label_ids = label_ids[: (max_seq_length - special_tokens_count)]\n",
+    "\n",
+    "        # The convention in BERT is:\n",
+    "        # (a) For sequence pairs:\n",
+    "        #  tokens:   [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]\n",
+    "        #  type_ids:   0   0  0    0    0     0       0   0   1  1  1  1   1   1\n",
+    "        # (b) For single sequences:\n",
+    "        #  tokens:   [CLS] the dog is hairy . [SEP]\n",
+    "        #  type_ids:   0   0   0   0  0     0   0\n",
+    "        #\n",
+    "        # Where \"type_ids\" are used to indicate whether this is the first\n",
+    "        # sequence or the second sequence. The embedding vectors for `type=0` and\n",
+    "        # `type=1` were learned during pre-training and are added to the wordpiece\n",
+    "        # embedding vector (and position vector). This is not *strictly* necessary\n",
+    "        # since the [SEP] token unambiguously separates the sequences, but it makes\n",
+    "        # it easier for the model to learn the concept of sequences.\n",
+    "        #\n",
+    "        # For classification tasks, the first vector (corresponding to [CLS]) is\n",
+    "        # used as as the \"sentence vector\". Note that this only makes sense because\n",
+    "        # the entire model is fine-tuned.\n",
+    "        tokens += [sep_token]\n",
+    "        token_boxes += [sep_token_box]\n",
+    "        actual_bboxes += [[0, 0, width, height]]\n",
+    "        label_ids += [pad_token_label_id]\n",
+    "        if sep_token_extra:\n",
+    "            # roberta uses an extra separator b/w pairs of sentences\n",
+    "            tokens += [sep_token]\n",
+    "            token_boxes += [sep_token_box]\n",
+    "            actual_bboxes += [[0, 0, width, height]]\n",
+    "            label_ids += [pad_token_label_id]\n",
+    "        segment_ids = [sequence_a_segment_id] * len(tokens)\n",
+    "\n",
+    "        if cls_token_at_end:\n",
+    "            tokens += [cls_token]\n",
+    "            token_boxes += [cls_token_box]\n",
+    "            actual_bboxes += [[0, 0, width, height]]\n",
+    "            label_ids += [pad_token_label_id]\n",
+    "            segment_ids += [cls_token_segment_id]\n",
+    "        else:\n",
+    "            tokens = [cls_token] + tokens\n",
+    "            token_boxes = [cls_token_box] + token_boxes\n",
+    "            actual_bboxes = [[0, 0, width, height]] + actual_bboxes\n",
+    "            label_ids = [pad_token_label_id] + label_ids\n",
+    "            segment_ids = [cls_token_segment_id] + segment_ids\n",
+    "\n",
+    "        input_ids = tokenizer.convert_tokens_to_ids(tokens)\n",
+    "\n",
+    "        # The mask has 1 for real tokens and 0 for padding tokens. Only real\n",
+    "        # tokens are attended to.\n",
+    "        input_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)\n",
+    "\n",
+    "        # Zero-pad up to the sequence length.\n",
+    "        padding_length = max_seq_length - len(input_ids)\n",
+    "        if pad_on_left:\n",
+    "            input_ids = ([pad_token] * padding_length) + input_ids\n",
+    "            input_mask = ([0 if mask_padding_with_zero else 1] * padding_length) + input_mask\n",
+    "            segment_ids = ([pad_token_segment_id] * padding_length) + segment_ids\n",
+    "            label_ids = ([pad_token_label_id] * padding_length) + label_ids\n",
+    "            token_boxes = ([pad_token_box] * padding_length) + token_boxes\n",
+    "        else:\n",
+    "            input_ids += [pad_token] * padding_length\n",
+    "            input_mask += [0 if mask_padding_with_zero else 1] * padding_length\n",
+    "            segment_ids += [pad_token_segment_id] * padding_length\n",
+    "            label_ids += [pad_token_label_id] * padding_length\n",
+    "            token_boxes += [pad_token_box] * padding_length\n",
+    "\n",
+    "        assert len(input_ids) == max_seq_length\n",
+    "        assert len(input_mask) == max_seq_length\n",
+    "        assert len(segment_ids) == max_seq_length\n",
+    "        assert len(label_ids) == max_seq_length\n",
+    "        assert len(token_boxes) == max_seq_length\n",
+    "\n",
+    "        if ex_index < 5:\n",
+    "            logger.info(\"*** Example ***\")\n",
+    "            logger.info(\"guid: %s\", example.guid)\n",
+    "            logger.info(\"tokens: %s\", \" \".join([str(x) for x in tokens]))\n",
+    "            logger.info(\"input_ids: %s\", \" \".join([str(x) for x in input_ids]))\n",
+    "            logger.info(\"input_mask: %s\", \" \".join([str(x) for x in input_mask]))\n",
+    "            logger.info(\"segment_ids: %s\", \" \".join([str(x) for x in segment_ids]))\n",
+    "            logger.info(\"label_ids: %s\", \" \".join([str(x) for x in label_ids]))\n",
+    "            logger.info(\"boxes: %s\", \" \".join([str(x) for x in token_boxes]))\n",
+    "            logger.info(\"actual_bboxes: %s\", \" \".join([str(x) for x in actual_bboxes]))\n",
+    "\n",
+    "        features.append(\n",
+    "            InputFeatures(\n",
+    "                input_ids=input_ids,\n",
+    "                input_mask=input_mask,\n",
+    "                segment_ids=segment_ids,\n",
+    "                label_ids=label_ids,\n",
+    "                boxes=token_boxes,\n",
+    "                actual_bboxes=actual_bboxes,\n",
+    "                file_name=file_name,\n",
+    "                page_size=page_size,\n",
+    "            )\n",
+    "        )\n",
+    "    return features"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {
+    "id": "HUJftzeBWh2S"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import LayoutLMTokenizer\n",
+    "\n",
+    "# from .unilm.layoutlm.data.funsd import FunsdDataset, InputFeatures\n",
+    "from torch.utils.data import DataLoader, RandomSampler, SequentialSampler\n",
+    "\n",
+    "batch_size = 16\n",
+    "args = {\n",
+    "    \"local_rank\": -1,\n",
+    "    \"overwrite_cache\": True,\n",
+    "    \"data_dir\": \"data/\",\n",
+    "    \"model_name_or_path\": \"microsoft/layoutlm-base-uncased\",\n",
+    "    \"max_seq_length\": 512,\n",
+    "    \"model_type\": \"layoutlm\",\n",
+    "}\n",
+    "\n",
+    "\n",
+    "# class to turn the keys of a dict into attributes (thanks Stackoverflow)\n",
+    "class AttrDict(dict):\n",
+    "    def __init__(self, *args, **kwargs):\n",
+    "        super(AttrDict, self).__init__(*args, **kwargs)\n",
+    "        self.__dict__ = self\n",
+    "\n",
+    "\n",
+    "args = AttrDict(args)\n",
+    "\n",
+    "tokenizer = LayoutLMTokenizer.from_pretrained(\"microsoft/layoutlm-base-uncased\")\n",
+    "\n",
+    "# the LayoutLM authors already defined a specific FunsdDataset, so we are going to use this here\n",
+    "train_dataset = FunsdDataset(args, tokenizer, labels, pad_token_label_id, mode=\"train\")\n",
+    "train_sampler = RandomSampler(train_dataset)\n",
+    "train_dataloader = DataLoader(train_dataset, sampler=train_sampler, batch_size=batch_size)\n",
+    "\n",
+    "eval_dataset = FunsdDataset(args, tokenizer, labels, pad_token_label_id, mode=\"test\")\n",
+    "eval_sampler = SequentialSampler(eval_dataset)\n",
+    "eval_dataloader = DataLoader(eval_dataset, sampler=eval_sampler, batch_size=batch_size)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "18NMUBzgOdqu",
+    "outputId": "eef47b70-3a9a-4b19-be6b-95900c58337b"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "10"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(train_dataloader)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "toFjxtn71B1U",
+    "outputId": "f4651896-cafc-449a-98b4-c81f41177e6d"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(eval_dataloader)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 137
+    },
+    "id": "RhINSBw9I24G",
+    "outputId": "28738ce2-617c-47d3-b8c9-f949d3066d60"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'[CLS] account agency ss : date 1 / 31 / 88 insert signed 91581919 4th new albany tribune advertisements. bookkeeper mar 08 reco affidavit of performance from newspaper new albany tribune harley davidson cigarettes lorillard media service state of county of indiana ) floyd ) before me a notary public, personally appeared holly inzer who being duly sworn, says that ( he ) ( she ) is of the abovementioned newspaper and that display ads for the above account were made through the aforesaid newspaper during the month of january, 1988 as follows : column inches exclusive advertising for harley davidson cigarettes we hereby certify charges shown above on dates per attached bill are true and correct as billed to the account in upper right hand corner of the affidavit and are exclusive sworn to and subscribed before me this day of march, 1988 in testimony whereof i have set my hand and seal the day and year aforesaid. my commission expires : 2 - 9 - 90 betty j. murphy ( notary public ) [SEP] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD]'"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "batch = next(iter(train_dataloader))\n",
+    "input_ids = batch[0][0]\n",
+    "tokenizer.decode(input_ids)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "66cEmLDoUFcm"
+   },
+   "source": [
+    "## Define and fine-tune the model\n",
+    "\n",
+    "As this is a sequence labeling task, we are going to load `LayoutLMForTokenClassification` (the base sized model) from the hub. We are going to fine-tune it on a downstream task, namely FUNSD."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "LoraConfig(task_type=<TaskType.TOKEN_CLS: 'TOKEN_CLS'>, peft_type=<PeftType.LORA: 'LORA'>, auto_mapping=None, base_model_name_or_path=None, revision=None, inference_mode=False, r=16, target_modules=None, exclude_modules=None, lora_alpha=16, lora_dropout=0.1, fan_in_fan_out=False, bias='all', use_rslora=False, modules_to_save=None, init_lora_weights=True, layers_to_transform=None, layers_pattern=None, rank_pattern={}, alpha_pattern={}, megatron_config=None, megatron_core='megatron.core', trainable_token_indices=None, loftq_config={}, eva_config=None, corda_config=None, use_dora=False, use_qalora=False, qalora_group_size=16, layer_replication=None, runtime_config=LoraRuntimeConfig(ephemeral_gpu_offload=False), lora_bias=False, target_parameters=None)"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from peft import get_peft_config, PeftModel, get_peft_model, LoraConfig, TaskType\n",
+    "\n",
+    "peft_config = LoraConfig(\n",
+    "    task_type=TaskType.TOKEN_CLS, inference_mode=False, r=16, lora_alpha=16, lora_dropout=0.1, bias=\"all\"\n",
+    ")\n",
+    "peft_config"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 1000,
+     "referenced_widgets": [
+      "da1094982d044ab28eb0effebbfcbb78",
+      "513e00b619924f5693259cd919a927ab",
+      "63e819a04f6e4829838c0e30e65516ed",
+      "d1c3e1a66db04227a74ef8d6481d6daf",
+      "c75f0da13a1e4dbe94800711d55390a6",
+      "31642aacae2a44879960da09f938ecc4",
+      "138a6b922e454ebbaeb315ecd5f476b8",
+      "a8126ba98376402888e9ba344cf1c538"
+     ]
+    },
+    "id": "xIdOsFBiTsuw",
+    "outputId": "95e8811c-025a-41a0-9d03-4285a17f2a9b"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import LayoutLMForTokenClassification\n",
+    "import torch\n",
+    "from transformers import set_seed\n",
+    "\n",
+    "seed = 100\n",
+    "set_seed(seed)\n",
+    "device = torch.accelerator.current_accelerator().type if hasattr(torch, \"accelerator\") else \"cuda\"\n",
+    "\n",
+    "model = LayoutLMForTokenClassification.from_pretrained(\"microsoft/layoutlm-base-uncased\", num_labels=num_labels)\n",
+    "model = get_peft_model(model, peft_config)\n",
+    "model.to(device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(model.model.layoutlm.encoder.layer[0].attention.self.query.weight)\n",
+    "print(model.model.layoutlm.encoder.layer[0].attention.self.query.lora_A.default.weight)\n",
+    "print(model.model.classifier.weight)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "3weFr_pz1mla"
+   },
+   "source": [
+    "Now we can start training:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "Yu0qePs2cRKo",
+    "outputId": "cdbb9a03-eb9b-4740-bbe3-da06b9192bae"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import get_linear_schedule_with_warmup\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "num_train_epochs = 100\n",
+    "\n",
+    "optimizer = torch.optim.AdamW(model.parameters(), lr=3e-3)\n",
+    "lr_scheduler = get_linear_schedule_with_warmup(\n",
+    "    optimizer=optimizer,\n",
+    "    num_warmup_steps=0.06 * (len(train_dataloader) * num_train_epochs),\n",
+    "    num_training_steps=(len(train_dataloader) * num_train_epochs),\n",
+    ")\n",
+    "\n",
+    "\n",
+    "global_step = 0\n",
+    "\n",
+    "t_total = len(train_dataloader) * num_train_epochs  # total number of training steps\n",
+    "\n",
+    "# put the model in training mode\n",
+    "model.train()\n",
+    "for epoch in range(num_train_epochs):\n",
+    "    for batch in tqdm(train_dataloader, desc=\"Training\"):\n",
+    "        input_ids = batch[0].to(device)\n",
+    "        bbox = batch[4].to(device)\n",
+    "        attention_mask = batch[1].to(device)\n",
+    "        token_type_ids = batch[2].to(device)\n",
+    "        labels = batch[3].to(device)\n",
+    "\n",
+    "        # forward pass\n",
+    "        outputs = model(\n",
+    "            input_ids=input_ids, bbox=bbox, attention_mask=attention_mask, token_type_ids=token_type_ids, labels=labels\n",
+    "        )\n",
+    "        loss = outputs.loss\n",
+    "\n",
+    "        # print loss every 100 steps\n",
+    "        if global_step % 10 == 0:\n",
+    "            print(f\"Loss after {global_step} steps: {loss.item()}\")\n",
+    "\n",
+    "        # backward pass to get the gradients\n",
+    "        loss.backward()\n",
+    "\n",
+    "        # print(\"Gradients on classification head:\")\n",
+    "        # print(model.classifier.weight.grad[6,:].sum())\n",
+    "\n",
+    "        # update\n",
+    "        optimizer.step()\n",
+    "        lr_scheduler.step()\n",
+    "        optimizer.zero_grad()\n",
+    "        global_step += 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "u1rNslap5Y3N",
+    "outputId": "877183d4-1d29-4d09-bd3a-0e5f88611dc8"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Evaluating: 100%|██████████| 4/4 [00:00<00:00, 10.90it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'loss': 1.467050313949585, 'precision': 0.7295341474445952, 'recall': 0.806903451725863, 'f1': 0.7662707838479811}\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "from seqeval.metrics import (\n",
+    "    classification_report,\n",
+    "    f1_score,\n",
+    "    precision_score,\n",
+    "    recall_score,\n",
+    ")\n",
+    "\n",
+    "eval_loss = 0.0\n",
+    "nb_eval_steps = 0\n",
+    "preds = None\n",
+    "out_label_ids = None\n",
+    "\n",
+    "# put model in evaluation mode\n",
+    "model.eval()\n",
+    "for batch in tqdm(eval_dataloader, desc=\"Evaluating\"):\n",
+    "    with torch.no_grad():\n",
+    "        input_ids = batch[0].to(device)\n",
+    "        bbox = batch[4].to(device)\n",
+    "        attention_mask = batch[1].to(device)\n",
+    "        token_type_ids = batch[2].to(device)\n",
+    "        labels = batch[3].to(device)\n",
+    "\n",
+    "        # forward pass\n",
+    "        outputs = model(\n",
+    "            input_ids=input_ids, bbox=bbox, attention_mask=attention_mask, token_type_ids=token_type_ids, labels=labels\n",
+    "        )\n",
+    "        # get the loss and logits\n",
+    "        tmp_eval_loss = outputs.loss\n",
+    "        logits = outputs.logits\n",
+    "\n",
+    "        eval_loss += tmp_eval_loss.item()\n",
+    "        nb_eval_steps += 1\n",
+    "\n",
+    "        # compute the predictions\n",
+    "        if preds is None:\n",
+    "            preds = logits.detach().cpu().numpy()\n",
+    "            out_label_ids = labels.detach().cpu().numpy()\n",
+    "        else:\n",
+    "            preds = np.append(preds, logits.detach().cpu().numpy(), axis=0)\n",
+    "            out_label_ids = np.append(out_label_ids, labels.detach().cpu().numpy(), axis=0)\n",
+    "\n",
+    "# compute average evaluation loss\n",
+    "eval_loss = eval_loss / nb_eval_steps\n",
+    "preds = np.argmax(preds, axis=2)\n",
+    "\n",
+    "out_label_list = [[] for _ in range(out_label_ids.shape[0])]\n",
+    "preds_list = [[] for _ in range(out_label_ids.shape[0])]\n",
+    "\n",
+    "for i in range(out_label_ids.shape[0]):\n",
+    "    for j in range(out_label_ids.shape[1]):\n",
+    "        if out_label_ids[i, j] != pad_token_label_id:\n",
+    "            out_label_list[i].append(label_map[out_label_ids[i][j]])\n",
+    "            preds_list[i].append(label_map[preds[i][j]])\n",
+    "\n",
+    "results = {\n",
+    "    \"loss\": eval_loss,\n",
+    "    \"precision\": precision_score(out_label_list, preds_list),\n",
+    "    \"recall\": recall_score(out_label_list, preds_list),\n",
+    "    \"f1\": f1_score(out_label_list, preds_list),\n",
+    "}\n",
+    "print(results)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "trainable params: 702,733 || all params: 113,237,786 || trainable%: 0.6206\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.print_trainable_parameters()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model.save_pretrained(\"peft_layoutlm\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2.8M\t./peft_layoutlm/adapter_model.safetensors\n"
+     ]
+    }
+   ],
+   "source": [
+    "!du -h ./peft_layoutlm/adapter_model.safetensors"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "collapsed_sections": [],
+   "include_colab_link": true,
+   "name": "Fine-tuning LayoutLMForTokenClassification on FUNSD.ipynb",
+   "provenance": [],
+   "toc_visible": true
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
+   }
+  },
+  "widgets": {
+   "application/vnd.jupyter.widget-state+json": {
+    "138a6b922e454ebbaeb315ecd5f476b8": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_name": "DescriptionStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "DescriptionStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "description_width": ""
+     }
+    },
+    "31642aacae2a44879960da09f938ecc4": {
+     "model_module": "@jupyter-widgets/base",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "513e00b619924f5693259cd919a927ab": {
+     "model_module": "@jupyter-widgets/base",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "63e819a04f6e4829838c0e30e65516ed": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_name": "FloatProgressModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "FloatProgressModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "ProgressView",
+      "bar_style": "success",
+      "description": "Downloading: 100%",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_31642aacae2a44879960da09f938ecc4",
+      "max": 453093832,
+      "min": 0,
+      "orientation": "horizontal",
+      "style": "IPY_MODEL_c75f0da13a1e4dbe94800711d55390a6",
+      "value": 453093832
+     }
+    },
+    "a8126ba98376402888e9ba344cf1c538": {
+     "model_module": "@jupyter-widgets/base",
+     "model_name": "LayoutModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/base",
+      "_model_module_version": "1.2.0",
+      "_model_name": "LayoutModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "LayoutView",
+      "align_content": null,
+      "align_items": null,
+      "align_self": null,
+      "border": null,
+      "bottom": null,
+      "display": null,
+      "flex": null,
+      "flex_flow": null,
+      "grid_area": null,
+      "grid_auto_columns": null,
+      "grid_auto_flow": null,
+      "grid_auto_rows": null,
+      "grid_column": null,
+      "grid_gap": null,
+      "grid_row": null,
+      "grid_template_areas": null,
+      "grid_template_columns": null,
+      "grid_template_rows": null,
+      "height": null,
+      "justify_content": null,
+      "justify_items": null,
+      "left": null,
+      "margin": null,
+      "max_height": null,
+      "max_width": null,
+      "min_height": null,
+      "min_width": null,
+      "object_fit": null,
+      "object_position": null,
+      "order": null,
+      "overflow": null,
+      "overflow_x": null,
+      "overflow_y": null,
+      "padding": null,
+      "right": null,
+      "top": null,
+      "visibility": null,
+      "width": null
+     }
+    },
+    "c75f0da13a1e4dbe94800711d55390a6": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_name": "ProgressStyleModel",
+     "state": {
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "ProgressStyleModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/base",
+      "_view_module_version": "1.2.0",
+      "_view_name": "StyleView",
+      "bar_color": null,
+      "description_width": "initial"
+     }
+    },
+    "d1c3e1a66db04227a74ef8d6481d6daf": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_name": "HTMLModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HTMLModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HTMLView",
+      "description": "",
+      "description_tooltip": null,
+      "layout": "IPY_MODEL_a8126ba98376402888e9ba344cf1c538",
+      "placeholder": "​",
+      "style": "IPY_MODEL_138a6b922e454ebbaeb315ecd5f476b8",
+      "value": " 453M/453M [00:15&lt;00:00, 30.0MB/s]"
+     }
+    },
+    "da1094982d044ab28eb0effebbfcbb78": {
+     "model_module": "@jupyter-widgets/controls",
+     "model_name": "HBoxModel",
+     "state": {
+      "_dom_classes": [],
+      "_model_module": "@jupyter-widgets/controls",
+      "_model_module_version": "1.5.0",
+      "_model_name": "HBoxModel",
+      "_view_count": null,
+      "_view_module": "@jupyter-widgets/controls",
+      "_view_module_version": "1.5.0",
+      "_view_name": "HBoxView",
+      "box_style": "",
+      "children": [
+       "IPY_MODEL_63e819a04f6e4829838c0e30e65516ed",
+       "IPY_MODEL_d1c3e1a66db04227a74ef8d6481d6daf"
+      ],
+      "layout": "IPY_MODEL_513e00b619924f5693259cd919a927ab"
+     }
+    }
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
diff --git a/examples/token_classification/requirements.txt b/examples/token_classification/requirements.txt
new file mode 100644
index 0000000..2cde65e
--- /dev/null
+++ b/examples/token_classification/requirements.txt
@@ -0,0 +1,7 @@
+transformers
+accelerate
+evaluate
+tqdm
+datasets
+Pillow
+torchvision
\ No newline at end of file
diff --git a/examples/unilora_finetuning/README.md b/examples/unilora_finetuning/README.md
new file mode 100644
index 0000000..5c16280
--- /dev/null
+++ b/examples/unilora_finetuning/README.md
@@ -0,0 +1,86 @@
+# UniLoRA: One Vector Is All You Need
+
+## Introduction ([Paper](https://huggingface.co/papers/2506.00799))
+
+UniLoRA shares a compact trainable vector bank across low-rank adapter weights. It keeps the familiar PEFT training
+flow while using deterministic projections into shared `theta_d` values to reduce the number of trained adapter
+parameters.
+
+## Quick Start
+
+```python
+import torch
+from datasets import load_dataset
+from peft import UniLoraConfig, get_peft_model
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from trl import SFTConfig, SFTTrainer
+
+model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.2-3B", dtype=torch.bfloat16, device_map="auto")
+tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-3B")
+tokenizer.pad_token_id = tokenizer.eos_token_id
+
+config = UniLoraConfig(
+    r=32,
+    theta_d_length=256,
+    proj_seed=42,
+    target_modules=["q_proj", "v_proj"],
+    unilora_dropout=0.0,
+    task_type="CAUSAL_LM",
+)
+peft_model = get_peft_model(model, config)
+peft_model.print_trainable_parameters()
+
+dataset = load_dataset("imdb", split="train[:1%]")
+
+training_args = SFTConfig(dataset_text_field="text", max_length=128)
+trainer = SFTTrainer(
+    model=peft_model,
+    args=training_args,
+    train_dataset=dataset,
+    processing_class=tokenizer,
+)
+trainer.train()
+peft_model.save_pretrained("unilora-llama-3.2-3b")
+```
+
+To load the fine-tuned UniLoRA adapter:
+
+```python
+import torch
+from peft import PeftModel
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained(
+    "meta-llama/Llama-3.2-3B", dtype=torch.bfloat16, device_map="auto"
+)
+peft_model = PeftModel.from_pretrained(model, "unilora-llama-3.2-3b")
+```
+
+## Fine-tune on MetaMathQA
+
+```shell
+python unilora_finetuning.py \
+    --base_model_name_or_path meta-llama/Llama-3.2-3B \
+    --output_dir output/unilora-llama-3.2-3b-metamath \
+    --unilora_r 32 \
+    --theta_d_length 256 \
+    --proj_seed 42 \
+    --unilora_dropout 0.0 \
+    --bits bf16 \
+    --data_path meta-math/MetaMathQA \
+    --dataset_split train[:100000] \
+    --dataset_field query response \
+    --bf16 True \
+    --num_train_epochs 1 \
+    --per_device_train_batch_size 2 \
+    --gradient_accumulation_steps 8 \
+    --save_strategy steps \
+    --save_steps 1000 \
+    --save_total_limit 1 \
+    --logging_steps 1 \
+    --learning_rate 1e-4 \
+    --weight_decay 0. \
+    --warmup_steps 0.03 \
+    --tf32 True \
+    --report_to none
+```
diff --git a/examples/unilora_finetuning/unilora_finetuning.py b/examples/unilora_finetuning/unilora_finetuning.py
new file mode 100644
index 0000000..fec9228
--- /dev/null
+++ b/examples/unilora_finetuning/unilora_finetuning.py
@@ -0,0 +1,124 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+import os
+from dataclasses import dataclass, field
+from typing import Optional
+
+import torch
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoTokenizer, HfArgumentParser
+from trl import SFTConfig, SFTTrainer
+
+from peft import get_peft_model
+
+
+@dataclass
+class ScriptArguments(SFTConfig):
+    base_model_name_or_path: Optional[str] = field(
+        default=None, metadata={"help": "The name or path of the fp32/fp16/bf16 base model."}
+    )
+    bits: str = field(default="bf16", metadata={"help": "Model dtype to load: bf16, fp16, or fp32."})
+    unilora_r: int = field(default=32, metadata={"help": "Rank of the UniLoRA adapter."})
+    theta_d_length: int = field(default=256, metadata={"help": "Length of the shared UniLoRA theta_d vector bank."})
+    proj_seed: int = field(default=42, metadata={"help": "Seed used for deterministic UniLoRA projection indices."})
+    unilora_dropout: float = field(default=0.0, metadata={"help": "Dropout probability for UniLoRA layers."})
+    init_weights: bool = field(default=True, metadata={"help": "Whether to apply UniLoRA-specific initialization."})
+    target_modules: Optional[list[str]] = field(
+        default_factory=lambda: ["q_proj", "o_proj", "k_proj", "v_proj", "gate_proj", "up_proj", "down_proj"],
+        metadata={"help": "Target module names for UniLoRA adapters."},
+    )
+    merge_and_save: bool = field(
+        default=False, metadata={"help": "Merge the adapter into the base model and save it."}
+    )
+    data_path: str = field(default="imdb", metadata={"help": "Path or Hub id of the training dataset."})
+    dataset_split: str = field(default="train[:1%]", metadata={"help": "Dataset split to train on."})
+    dataset_field: Optional[list[str]] = field(
+        default=None, metadata={"help": "Input and output field names for instruction data."}
+    )
+
+
+def get_dtype(bits: str) -> torch.dtype:
+    if bits == "fp16":
+        return torch.float16
+    if bits == "bf16":
+        return torch.bfloat16
+    if bits == "fp32":
+        return torch.float32
+    raise ValueError("UniLoRA example supports only bf16, fp16, and fp32 model loading.")
+
+
+def main() -> None:
+    parser = HfArgumentParser(ScriptArguments)
+    script_args = parser.parse_args_into_dataclasses()[0]
+    print(script_args)
+
+    if script_args.base_model_name_or_path is None:
+        raise ValueError("Please pass --base_model_name_or_path to load a base model.")
+
+    from peft import UniLoraConfig
+
+    model = AutoModelForCausalLM.from_pretrained(
+        script_args.base_model_name_or_path,
+        dtype=get_dtype(script_args.bits),
+        device_map="auto",
+    )
+    tokenizer = AutoTokenizer.from_pretrained(script_args.base_model_name_or_path)
+    tokenizer.pad_token_id = tokenizer.eos_token_id
+
+    config = UniLoraConfig(
+        r=script_args.unilora_r,
+        theta_d_length=script_args.theta_d_length,
+        proj_seed=script_args.proj_seed,
+        target_modules=script_args.target_modules,
+        unilora_dropout=script_args.unilora_dropout,
+        bias="none",
+        task_type="CAUSAL_LM",
+        init_weights=script_args.init_weights,
+    )
+    peft_model = get_peft_model(model, config)
+    peft_model.print_trainable_parameters()
+
+    dataset = load_dataset(script_args.data_path, split=script_args.dataset_split)
+    if script_args.dataset_field:
+        dataset = dataset.map(
+            lambda example: {
+                "text": (
+                    f"### USER: {example[script_args.dataset_field[0]]}\n"
+                    f"### ASSISTANT: {example[script_args.dataset_field[1]]}"
+                )
+            }
+        )
+
+    trainer = SFTTrainer(
+        model=peft_model,
+        args=script_args,
+        train_dataset=dataset,
+        processing_class=tokenizer,
+    )
+    trainer.train()
+    trainer.save_state()
+
+    adapter_dir = os.path.join(script_args.output_dir, "unilora_ft")
+    peft_model.save_pretrained(adapter_dir)
+
+    if script_args.merge_and_save:
+        merged_model = peft_model.merge_and_unload()
+        merged_dir = os.path.join(script_args.output_dir, "unilora_merged")
+        merged_model.save_pretrained(merged_dir)
+        tokenizer.save_pretrained(merged_dir)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/waveft_finetuning/README.md b/examples/waveft_finetuning/README.md
new file mode 100644
index 0000000..8b26ab1
--- /dev/null
+++ b/examples/waveft_finetuning/README.md
@@ -0,0 +1,64 @@
+
+
+# WaveFT: Wavelet Fine-Tuning
+
+## Introduction
+[WaveFT](https://huggingface.co/papers/2505.12532) is a novel parameter-efficient fine-tuning (PEFT) method that introduces sparse updates in the **wavelet domain** of residual matrices. Unlike LoRA, which is constrained by discrete low-rank choices, WaveFT enables fine-grained control over the number of trainable parameters by directly learning a sparse set of coefficients in the transformed space. These coefficients are then mapped back to the weight domain via the Inverse Discrete Wavelet Transform (IDWT), producing high-rank updates without incurring inference overhead.
+
+## Quick start
+```python
+import torch
+from peft import WaveFTConfig, get_peft_model
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from trl import SFTConfig, SFTTrainer
+from datasets import load_dataset
+
+model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m", dtype=torch.bfloat16, device_map="auto")
+tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m")
+dataset = load_dataset("imdb", split="train[:1%]")
+waveft_config = WaveFTConfig(
+    n_frequency=2592,
+)
+peft_model = get_peft_model(model, waveft_config)
+training_args = SFTConfig(dataset_text_field="text", max_length=128)
+trainer = SFTTrainer(
+    model=peft_model,
+    train_dataset=dataset,
+    processing_class=tokenizer,
+)
+trainer.train()
+peft_model.save_pretrained("waveft-opt-350m")
+```
+
+For more options and a more detailed example code, you can refer to waveft finetuning script.
+Run the script simply by running:
+```bash
+python3 examples/waveft_finetuning/waveft_finetuning.py --base_model facebook/opt-350m
+```
+
+If you want to run DDP by [accelerate](https://huggingface.co/docs/accelerate/en/index), please run `accelerate config` to set your ddp config, and run:
+```bash
+accelerate launch examples/waveft_finetuning/waveft_finetuning.py --base_model facebook/opt-350m
+```
+please add `--device_map cpu` if you want to run finetune on CPU.
+
+## Use the model
+You can load and use the model as any other 🤗 PEFT model
+```python
+from peft import PeftModel
+from transformers import AutoTokenizer, AutoModelForCausalLM
+model = AutoModelForCausalLM.from_pretrained("facebook/opt-350m")
+tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m")
+waveft_model = PeftModel.from_pretrained(model, "waveft-opt-350m")
+```
+
+## Citation
+@misc{bilican2025exploringsparsityparameterefficient,
+      title={Exploring Sparsity for Parameter Efficient Fine Tuning Using Wavelets}, 
+      author={Ahmet Bilican and M. Akın Yılmaz and A. Murat Tekalp and R. Gökberk Cinbiş},
+      year={2025},
+      eprint={2505.12532},
+      archivePrefix={arXiv},
+      primaryClass={cs.CV},
+      url={https://arxiv.org/abs/2505.12532}, 
+}
\ No newline at end of file
diff --git a/examples/waveft_finetuning/waveft_finetuning.py b/examples/waveft_finetuning/waveft_finetuning.py
new file mode 100644
index 0000000..dfdb6d4
--- /dev/null
+++ b/examples/waveft_finetuning/waveft_finetuning.py
@@ -0,0 +1,189 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+
+import os
+from typing import Optional
+
+import torch
+import transformers
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoTokenizer, set_seed
+
+from peft import (
+    WaveFTConfig,
+    get_peft_model,
+)
+
+
+def train(
+    base_model: str,
+    data_path: str = "yahma/alpaca-cleaned",
+    output_dir: str = "waveft",
+    batch_size: int = 16,
+    num_epochs: int = 1,
+    learning_rate: float = 3e-4,
+    cutoff_len: int = 256,
+    val_set_size: int = 16,
+    eval_step: int = 100,
+    save_step: int = 100,
+    device_map: str = "auto",
+    waveft_n_frequency: int = 2592,
+    waveft_target_modules: Optional[list[str]] = None,
+    waveft_scaling: float = 25.0,
+    waveft_wavelet_family: str = "db1",
+    waveft_use_idwt: bool = True,
+    dtype: str = "float16",
+    seed: Optional[int] = None,
+):
+    # Set device_map to the right place when enabling DDP.
+    world_size = int(os.environ.get("WORLD_SIZE", "0")) or int(os.environ.get("PMI_SIZE", "0"))
+    if world_size > 1 and device_map != "cpu":
+        from accelerate import Accelerator
+
+        device_map = {"": Accelerator().process_index}
+    # Set seed
+    if seed is not None:
+        set_seed(seed)
+    model_kwargs = {"dtype": getattr(torch, dtype), "device_map": device_map}
+    model = AutoModelForCausalLM.from_pretrained(base_model, **model_kwargs)
+
+    tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
+    # For some tokenizer with no pad token like llama
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    def tokenize(prompt, add_eos_token=True):
+        result = tokenizer(
+            prompt,
+            truncation=True,
+            max_length=cutoff_len,
+            padding=False,
+            return_tensors=None,
+        )
+        if (
+            result["input_ids"][-1] != tokenizer.eos_token_id
+            and len(result["input_ids"]) < cutoff_len
+            and add_eos_token
+        ):
+            result["input_ids"].append(tokenizer.eos_token_id)
+            result["attention_mask"].append(1)
+
+        result["labels"] = result["input_ids"].copy()
+
+        return result
+
+    def generate_and_tokenize_prompt(example):
+        full_prompt = generate_prompt(example)
+        tokenized_full_prompt = tokenize(full_prompt)
+        return tokenized_full_prompt
+
+    config = WaveFTConfig(
+        n_frequency=waveft_n_frequency,
+        scaling=waveft_scaling,
+        wavelet_family=waveft_wavelet_family,
+        use_idwt=waveft_use_idwt,
+        target_modules=waveft_target_modules,
+        task_type="CAUSAL_LM",
+    )
+
+    model = get_peft_model(model, config)
+
+    data = load_dataset(data_path)
+
+    train_val = data["train"].train_test_split(test_size=val_set_size, shuffle=True, seed=42)
+    train_data = train_val["train"].shuffle().map(generate_and_tokenize_prompt)
+    val_data = train_val["test"].shuffle().map(generate_and_tokenize_prompt)
+
+    trainer = transformers.Trainer(
+        model=model,
+        train_dataset=train_data,
+        eval_dataset=val_data,
+        args=transformers.TrainingArguments(
+            per_device_train_batch_size=batch_size,
+            warmup_steps=100,
+            num_train_epochs=num_epochs,
+            learning_rate=learning_rate,
+            logging_steps=100,
+            optim="adamw_torch",
+            eval_strategy="steps",
+            save_strategy="steps",
+            eval_steps=eval_step,
+            save_steps=save_step,
+            output_dir=output_dir,
+            save_total_limit=3,
+            load_best_model_at_end=True,
+            ddp_find_unused_parameters=False if world_size > 1 else None,
+        ),
+        data_collator=transformers.DataCollatorForSeq2Seq(
+            tokenizer, pad_to_multiple_of=8, return_tensors="pt", padding=True
+        ),
+    )
+    trainer.train()
+    model.save_pretrained(output_dir)
+
+
+def generate_prompt(example):
+    return f"""Below is an instruction that describes a task. Write a response that appropriately completes the request.
+            ### Instruction:
+            {example["instruction"]}
+            ### Response:
+            {example["output"]}"""
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--base_model", type=str)
+    parser.add_argument("--data_path", type=str, default="yahma/alpaca-cleaned")
+    parser.add_argument("--output_dir", type=str, default="waveft")
+    parser.add_argument("--batch_size", type=int, default=16)
+    parser.add_argument("--num_epochs", type=int, default=1)
+    parser.add_argument("--learning_rate", type=float, default=3e-4)
+    parser.add_argument("--cutoff_len", type=int, default=256)
+    parser.add_argument("--val_set_size", type=int, default=16)
+    parser.add_argument("--eval_step", type=int, default=100)
+    parser.add_argument("--save_step", type=int, default=100)
+    parser.add_argument("--device_map", type=str, default="auto")
+    parser.add_argument("--waveft_n_frequency", type=int, default=2592)
+    parser.add_argument("--waveft_target_modules", type=str, default=None)
+    parser.add_argument("--waveft_scaling", type=float, default=25.0)
+    parser.add_argument("--waveft_wavelet_family", type=str, default="db1")
+    parser.add_argument("--waveft_use_idwt", action="store_true", default=True)
+    parser.add_argument("--dtype", type=str, default="float16")
+    parser.add_argument("--seed", type=int, default=None)
+
+    args = parser.parse_args()
+
+    train(
+        base_model=args.base_model,
+        data_path=args.data_path,
+        output_dir=args.output_dir,
+        batch_size=args.batch_size,
+        num_epochs=args.num_epochs,
+        learning_rate=args.learning_rate,
+        cutoff_len=args.cutoff_len,
+        val_set_size=args.val_set_size,
+        eval_step=args.eval_step,
+        save_step=args.save_step,
+        device_map=args.device_map,
+        waveft_n_frequency=args.waveft_n_frequency,
+        waveft_target_modules=args.waveft_target_modules,
+        waveft_scaling=args.waveft_scaling,
+        waveft_wavelet_family=args.waveft_wavelet_family,
+        waveft_use_idwt=args.waveft_use_idwt,
+        dtype=args.dtype,
+        seed=args.seed,
+    )
diff --git a/examples/xlora/README.md b/examples/xlora/README.md
new file mode 100644
index 0000000..ae81cfc
--- /dev/null
+++ b/examples/xlora/README.md
@@ -0,0 +1,15 @@
+# X-LoRA examples
+
+## `xlora_inference_mistralrs.py`
+
+Perform inference of an X-LoRA model using the inference engine mistral.rs.
+
+Mistral.rs supports many base models besides Mistral, and can load models directly from saved LoRA checkpoints. Check out [adapter model docs](https://github.com/EricLBuehler/mistral.rs/blob/master/docs/ADAPTER_MODELS.md) and the [models support matrix](https://github.com/EricLBuehler/mistral.rs?tab=readme-ov-file#support-matrix).
+
+Mistral.rs features X-LoRA support and incorporates techniques such as a dual-KV cache, continuous batching, Paged Attention, and optional non granular scalings, will allow vastly improved throughput.    
+
+Links:
+
+- Installation: https://github.com/EricLBuehler/mistral.rs/blob/master/mistralrs-pyo3/README.md
+- Runnable example: https://github.com/EricLBuehler/mistral.rs/blob/master/examples/python/xlora_zephyr.py
+- Adapter model docs and making the ordering file: https://github.com/EricLBuehler/mistral.rs/blob/master/docs/ADAPTER_MODELS.md
\ No newline at end of file
diff --git a/examples/xlora/xlora_inference_mistralrs.py b/examples/xlora/xlora_inference_mistralrs.py
new file mode 100644
index 0000000..c9d165b
--- /dev/null
+++ b/examples/xlora/xlora_inference_mistralrs.py
@@ -0,0 +1,25 @@
+from mistralrs import ChatCompletionRequest, Runner, Which
+
+
+runner = Runner(
+    which=Which.XLora(
+        tok_model_id=None,  # Automatically determine from ordering file
+        model_id=...,  # Model ID of the base model (local path of HF model ID)
+        xlora_model_id=...,  # X-LoRA Model ID of the base model (local path of HF model ID)
+        order=...,  # Ordering file to ensure compatibility with PEFT
+        tgt_non_granular_index=3,  # Only generate scalings for the first 3 decoding tokens, and then use the last generated one
+    )
+)
+
+res = runner.send_chat_completion_request(
+    ChatCompletionRequest(
+        model="mistral",
+        messages=[{"role": "user", "content": "Tell me a story about 2 low rank matrices."}],
+        max_tokens=256,
+        presence_penalty=1.0,
+        top_p=0.1,
+        temperature=0.5,
+    )
+)
+print(res.choices[0].message.content)
+print(res.usage)
diff --git a/method_comparison/MetaMathQA/Makefile b/method_comparison/MetaMathQA/Makefile
new file mode 100644
index 0000000..baa5c00
--- /dev/null
+++ b/method_comparison/MetaMathQA/Makefile
@@ -0,0 +1,96 @@
+# Makefile for running MetaMathQA experiments.
+
+# --- Configuration ---
+PYTHON := python
+RUN_SCRIPT := run.py
+EXPERIMENTS_DIR := experiments
+RESULTS_DIR := results
+
+OPTIONAL_FLAGS =
+
+ifdef UPLOAD_BUCKET
+	OPTIONAL_FLAGS += --bucket_name "${UPLOAD_BUCKET}"
+endif
+
+# --- Automatic Experiment and Result Discovery ---
+
+# 1. Find all experiment directories by looking for adapter_config.json files.
+#    This gives us a list like: experiments/lora/llama-3.2-3B-rank32 ...
+EXPERIMENT_PATHS := $(shell find $(EXPERIMENTS_DIR) \
+		    -name "adapter_config.json" -or \
+		    -name "training_params.json" | xargs dirname | sort -u)
+
+# 2. Define a function to replace all occurrences of a character in a string.
+#    This is needed to replicate the result naming logic from run.py (e.g., "lora/foo" -> "lora-foo").
+#    Usage: $(call replace-all, string, char_to_replace, replacement_char)
+replace-all = $(if $(findstring $(2),$(1)),$(call replace-all,$(subst $(2),$(3),$(1)),$(2),$(3)),$(1))
+
+# 3. Define a function to convert an experiment path to its flat result file path.
+#    e.g., "experiments/lora/llama-3.2-3B-rank32" -> "results/lora-llama-3.2-3B-rank32.json"
+exp_to_res = $(RESULTS_DIR)/$(call replace-all,$(patsubst $(EXPERIMENTS_DIR)/%,%,$(1)),/,--).json
+
+# 4. Generate the list of all target result files we want to build.
+RESULT_FILES := $(foreach exp,$(EXPERIMENT_PATHS),$(call exp_to_res,$(exp)))
+
+
+# --- Main Rules ---
+
+# The default 'all' target depends on all possible result files.
+# Running `make` or `make all` will check and run any outdated or missing experiments.
+all: $(RESULT_FILES)
+
+
+# --- Dynamic Rule Generation ---
+
+# This is the core logic. We dynamically generate a specific Makefile rule for each experiment found.
+# This avoids a complex pattern rule and makes the logic clearer.
+define EXPERIMENT_template
+# Input $1: The full experiment path (e.g., experiments/lora/llama-3.2-3B-rank32)
+
+# Define the rule:
+# The target is the result file (e.g., results/lora-llama-3.2-3B-rank32.json).
+# The dependencies are its config files, code changes need to be audited manually since they can
+# vary in degree of importance. Note that we explicitly ignore when the script fails to run
+# so that the other experiments still have a chance to run.
+$(call exp_to_res,$(1)): $(wildcard $(1)/adapter_config.json) $(wildcard $(1)/training_params.json)
+	@echo "---"
+	@echo "Running experiment: $(1)"
+	-$(PYTHON) $(RUN_SCRIPT) $(OPTIONAL_FLAGS) -v $(1)
+	@echo "Finished: $$@"
+	@echo "---"
+
+endef
+
+# This command iterates through every found experiment path and evaluates the template,
+# effectively stamping out a unique, explicit rule for each one.
+$(foreach exp_path,$(EXPERIMENT_PATHS),$(eval $(call EXPERIMENT_template,$(exp_path))))
+
+
+# --- Utility Rules ---
+
+.PHONY: all clean list dump_rules
+
+# The 'clean' rule removes all generated results.
+clean:
+	@echo "Cleaning results directory..."
+	@([ -n "$(wildcard $(RESULTS_DIR)/*.json)" ] && rm $(RESULTS_DIR)/*.json) || exit 0
+
+# The 'list' rule is for debugging. It shows the discovered experiments
+# and the result files the Makefile expects to create for them.
+list:
+	@echo "Discovered experiment configurations:"
+	@$(foreach exp,$(EXPERIMENT_PATHS),echo "  - $(exp)/adapter_config.json";)
+	@echo "\nTarget result files:"
+	@$(foreach res,$(RESULT_FILES),echo "  - $(res)";)
+
+# The 'dump_rules' rule is for debugging. It dumps all dynamically defined rules.
+define newline
+
+
+endef
+define DUMPED_RULES
+	$(foreach exp_path,$(EXPERIMENT_PATHS),$(call EXPERIMENT_template,$(exp_path)))
+endef
+
+dump_rules:
+	@echo -e "$(subst $(newline),\n,${DUMPED_RULES})"
diff --git a/method_comparison/MetaMathQA/README.md b/method_comparison/MetaMathQA/README.md
new file mode 100644
index 0000000..ce89616
--- /dev/null
+++ b/method_comparison/MetaMathQA/README.md
@@ -0,0 +1,248 @@
+# PEFT method comparison on the MetaMathQA and GSM8K datasets
+
+## Goal
+
+This goal is to provide a benchmarking framework for the different PEFT methods that are implemented. It is important that evaluating different PEFT methods is reproducible, idempotent, and version-controlled. Results for more PEFT methods can be added over time.
+
+## Dataset
+
+This task trains on the [MetaMathQA]((https://huggingface.co/datasets/meta-math/MetaMathQA)) dataset and validates/tests on the [GSM8K](https://huggingface.co/datasets/openai/gsm8k) dataset ("main").
+
+For the model to attain good accuracy, it needs to learn to adhere to the output format and it must express basic chain of thought reasoning capabilities to get to the correct result in the first place. The task is challenging for models in the sub 7B parameter range.
+
+The train set uses the whole of MetaMathQA. The validation set is a random sample from the train set of GSM8K. The test set is the whole of the GSM8K test set.
+
+## Running
+
+Create an experiment in the `experiment/<peft-method>` folder of your choice and give it a name (the name itself does not matter but helps identify the experiment). An example would be `experiments/lora/llama-3.2-3B-rank32/`. Inside that directory, create 2 files:
+
+- `adapter_config.json`
+- Optional: `training_parameters.json`
+
+Once you created these two files, you can either
+
+- run the whole suite using by simply calling `make` (takes >24h)
+- run one specific experiment by calling `make results/<experiment_name>-<experiment_variation>.json`,
+  for example `results/vblora-llama-3.2-3B-default.json`
+
+You can get a list of all runnable experiments by running `make list`, e.g.:
+```
+% make list                                                                                                                                                              (git)-[method-comparison-results]  ⛓ peft
+Discovered experiment configurations:
+  - experiments/ptuning/llama-3.2-3B-default/adapter_config.json
+  [...]
+  - experiments/vblora/llama-3.2-3B-default/adapter_config.json
+
+Target result files:
+  - results/ptuning-llama-3.2-3B-default.json
+  [...]
+  - results/vblora-llama-3.2-3B-default.json
+```
+
+In case you want to force the execution of an experiment, you can simply `touch` the respective adapter config
+without modifying it. For example:
+
+    touch experiments/vblora/llama-3.2-3B-default/adapter_config.json
+    make
+
+to run the VBLoRA default experiment again.
+
+If you set `UPLOAD_BUCKET="your_user/bucket_name"` as an environment variable prior to starting experiments via `make`, all experiments will be called with the `--bucket_name $UPLOAD_BUCKET` parameter and therefore store the checkpoints in that bucket. _For maintainers_: The default bucket name should be `"peft-internal-testing/metamathqa-checkpoints"`.
+
+### `adapter_config.json`
+
+This must be a valid PEFT configuration. It is easiest to create it programmatically, e.g.:
+
+```python
+from peft import LoraConfig
+
+config = LoraConfig(...)
+config.save_pretrained(<path-to-experiment>)
+```
+
+### `training_parameters.json`
+
+There is a default file for the non-PEFT parameters: `default_training_params.json`. This contains all the other parameters that are relevant for training, e.g. the base model id, number of steps, batch size, learning rate, etc. If parameters that differ from the defaults are needed for a specific experiment, place a `training_parameters.json` into the experiment directory and adjust the parameters that need changing. The other parametes are taken from the aforementioned default config.
+
+For an overview of all possible arguments, you can also check the `TrainConfig` `dataclass` in `utils.py`.
+
+#### About `torch.compile`
+
+Right now, compilation is a simple on/off switch in `training_params.json`. There is probably room for optimization here.
+
+Due to the model being switched to `eval` mode for the validation metrics and then back to `train` mode, we will incur a re-compilation. This is acceptable to ensure that validation runs correctly. However, this prevents us from using `torch._dynamo.config.patch(error_on_recompile=True, inline_inbuilt_nn_modules=False)` to detect frequent recompilations. It should be noticeable from the duration of training steps, though, so we're fine with that.
+
+### Runtime performance
+
+Several factors should be considered to achieve a fast runtime performance. Besides the obvious factors like `max_steps` or the base model size, we found the following factors to have a significant impact:
+
+#### Eval batch size
+
+Regarding the `batch_size_eval` parameter, it is quite critical since evaluation takes up a significant portion of the training time and batching helps with reducing that. It should be possible to choose a value that is multiple times higher than the batch size used for training (`batch_size`). You should also pay attention to the size of the validation set -- e.g. if it's 50, don't choose a `batch_size_eval` of 40, as that results in a large batch of 30 and a small batch of 10. 25 might be a better choice. Also, ensure via a quick train run that the batch size does not lead to out of memory errors -- getting this error at the very end on evaluating the test set would be quite a loss of time.
+
+#### Generation length
+
+During testing, we discovered that the validation time is greatly inflated by just a few very long generations. Those can inflate the validation time by a factor of 3 or more. At the same time, we discovered that these long generations do not help with accuracy -- in fact, if they exceed the maximum configured length, they're just cut off mid sentence and would thus produce an accuracy of 0 anyway.
+
+To remedy this, we now set both `max_length` and `max_new_tokens` for the generation kwargs in the default training parameters. Normally, this is not possible when using transformers, as the latter argument overrides the former. However, we have added special logic inside of `get_generation_config` which takes both and chooses the smaller of the two. This way, we can get rid of these excessively long generations, thus considerably reducing eval times, while still guaranteeing a maximum total generation length to guard against OOM errors. Testing showed that this does not hamper test accuracy. It is therefore recommended not to change these settings.
+
+#### Bucketing
+
+The length of the sequences in the training data can vary a lot. Therefore, if samples are taken randomly from the training dataset, we will end up with batches containing very short and very long sequences. This is bad because the batch will be padded to the longest sequence, slowing down training. The obvious solution would be to sort the whole dataset by sequence length, but this is also bad because it introduces an order bias (e.g. first training on only short and then on only long answers).
+
+The solution is to find a trade off between the two factors. This is achieved by the `BucketIterator`. It first creates buckets that contain multiple batches, e.g. 20x the batch size. The bucket is then sorted by sequence length and then batches are yielded from the bucket. Therefore, we have a small order bias within a bucket but not between buckets, stricking a good balance between training speed and training loss.
+
+From practical experiments, for a batch size of 4, a bucket size of 80 provides a good balance with only slightly lower training loss but cutting training time by 25%. For eval, we don't use the iterator since there, the batch size is relatively big and thus there is little upside.
+
+### Start a run
+
+Once everything is set up properly, start a run by using the `run.py` script. Pass `-v` for verbose output to the console (recommended if observing the progress is desired). To save the resulting experiment checkpoints to a huggingface bucket, you can pass the bucket name via the `--bucket_name` parameter (e.g., `"user/my_bucket_name"`). As an example, for `experiments/lora/llama-3.2-3B-rank32/` the invocation would be:
+
+```sh
+python run.py -v experiments/lora/llama-3.2-3B-rank32/
+```
+
+By default, the adapter will be saved in a temporary file for further inspection if needed. The prevent this, add the `--clean` flag to the call.
+
+### Run status
+
+The run can be categorized 3 different states:
+
+1. Main run: You are on the `main` branch and the run ended successfully. The results are stored in the `results` folder and are used for further analysis.
+2. Test run: You are not on the `main` branch and the run ended successfully. The results are stored in the `temporary_results` folder and are not used for further analysis.
+3. The run was cancelled (`ctrl + c`). The results are stored in the `cancelled_results` folder and are not used for further analysis.
+
+## Outputs
+
+Results are stored in one of the result directories. An example output could look like so:
+
+```js
+{
+  "run_info": {
+    "created_at": "2025-03-05T13:50:05+00:00",
+    "total_time": 2711.0915009640157,
+    "experiment_name": "ia3/lr_0.001",
+    "peft_branch": "ben-method-comparison",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 51,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_kwargs": {
+        "lr": 0.001
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "generation_kwargs": {
+        "max_length": 800
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "IA3",
+      "auto_mapping": null,
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "target_modules": [
+        "v_proj",
+        "k_proj",
+        "down_proj"
+      ],
+      "exclude_modules": null,
+      "feedforward_modules": [
+        "down_proj"
+      ],
+      "fan_in_fan_out": false,
+      "modules_to_save": null,
+      "init_ia3_weights": true
+    }
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 14229219940,
+    "accelerator_memory_max": 24847056896,
+    "accelerator_memory_reserved_99th": 19115624366,
+    "train_time": 2238.65277833899,
+    "file_size": 1157064,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.0784313725490196,
+        "train loss": 1.1336498007774354,
+        "train samples": 1000
+      },
+      [...]
+      {
+        "step": 5000,
+        "valid accuracy": 0.21568627450980393,
+        "train loss": 0.6345920492410659,
+        "train samples": 20000
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.35129740518962077,
+        "train loss": 0.6345920492410659,
+        "train samples": 20000,
+        "train total tokens": 4197579
+      }
+    ]
+  },
+  "meta_info": {
+    "model_sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+    "model_created_at": "2024-09-18T15:23:48+00:00",
+    "dataset_sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+    "dataset_created_at": "2023-09-21T17:22:46+00:00",
+    "package_info": {
+      "transformers-version": "4.50.0.dev0",
+      "transformers-commit-hash": "752ef3fd4e70869626ec70657a770a85c0ad9219",
+      "peft-version": "0.14.1.dev0",
+      "peft-commit-hash": "a447a4e5ecd87b7d57733f4df9616a328cf130f4",
+      "datasets-version": "3.3.2",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.45.2",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.6.0+cu124",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.11.0-17-generic",
+      "version": "#17~24.04.2-Ubuntu SMP PREEMPT_DYNAMIC Mon Jan 20 22:48:29 UTC 2",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA GeForce RTX 4090"
+    },
+    "pytorch_info": "PyTorch built with: [...]"
+  }
+}
+```
+
+## Dependencies
+
+Apart from the normal PEFT dependencies, ensure that the packages in the `requirements.txt` are installed, e.g. via:
+
+```sh
+python -m pip install -r requirements.txt
+```
+
+Python 3.12+ is required.
+
+## Open tasks
+
+- consider using `DataLoader`
+- consider adding https://github.com/huggingface/Math-Verify
+- consider adding `weight` argument to cross entropy calculation to downweight the EOS token, but it would require calculating the loss manually instead of relying on transformers (see https://github.com/huggingface/transformers/blob/6a876462c308bd7cd7d3ca8e93abaa7d5b02e90e/src/transformers/loss/loss_utils.py#L24-L48)
+- do a sanity check against/comparison with transformers Trainer
+- consider using vLLM to potentially speed up generations, at least for the test set
+- AMP does not appear to help, investigate
+- packing of sequences (but this probably requires adjusting the attention matrix)
+- clean up what gets printed and where (stdout, stderr)
diff --git a/method_comparison/MetaMathQA/data.py b/method_comparison/MetaMathQA/data.py
new file mode 100644
index 0000000..3d060d3
--- /dev/null
+++ b/method_comparison/MetaMathQA/data.py
@@ -0,0 +1,117 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+"""
+All utilities related to data handling.
+"""
+
+from collections.abc import Callable
+from functools import partial
+
+import datasets
+import numpy as np
+from datasets import Dataset, load_dataset
+
+
+# with a token limit of 768 for query + response, we have to exclude all texts with length > 1304; this leaves 93.8% of
+# the dataset
+CHAR_LIMIT = 1300
+# train/valid/test split -- note that evaluation takes quite long, so don't choose too large sizes for the valid set,
+# since it's run multiple times during training; test is only run once at the end and thus can be larger
+VALID_SIZE = 50
+
+
+def get_filtered_dataset(*, ds: datasets.Dataset, print_fn: Callable[..., None]) -> Dataset:
+    """Return the filtered dataset, with long queries removed.
+
+    We determined that 99% of queries have 529 or fewer characters. Characters roughly correspond to tokens, so this is
+    a good proxy. We cannot use tokens directly, as that depends on the tokenizer, which can be different for each
+    model, but we want the same filter for each model.
+
+    """
+    char_lengths = [len(f"{q} {r}") for q, r in zip(ds["query"], ds["response"])]
+    idx_filtered = [i for i, length in enumerate(char_lengths) if length <= CHAR_LIMIT]
+    print_fn(f"Filtered dataset: {100 * len(idx_filtered) / len(ds):.1f}% of the original dataset")
+    return ds.select(idx_filtered)
+
+
+def get_train_valid_test_datasets(
+    *, tokenizer, query_template: str, print_fn: Callable[..., None]
+) -> tuple[Dataset, Dataset, Dataset]:
+    """
+    Return the indices of the train, valid, and test splits of the dataset.
+
+    We cannot use ds.train_test_split(..., stratify_by_column="type") as it gives:
+
+    > ValueError: Stratifying by column is only supported for ClassLabel column, and column type is Value.
+
+    even after calling ds_filtered.class_encode_column("type"). Thus, using sklearn's StratifiedKFold instead.
+    """
+    metamath = load_dataset("meta-math/MetaMathQA")["train"]
+    metamath = get_filtered_dataset(ds=metamath, print_fn=print_fn)
+
+    # gsmk8k does not need to be filtered as query and response are short enough
+    gsm8k = load_dataset("openai/gsm8k", "main")
+    gsm8k = gsm8k.rename_columns({"question": "query", "answer": "response"})
+    gsm8k_train = gsm8k["train"]
+    gsm8k_test = gsm8k["test"]
+
+    np.random.seed(0)
+    indices = np.arange(len(gsm8k_train))
+    np.random.shuffle(indices)
+    idx_valid = indices[:VALID_SIZE]
+
+    ds_train = metamath
+    ds_valid = gsm8k_train.select(idx_valid)
+    ds_test = gsm8k_test
+
+    print_fn(f"Train size: {len(ds_train)}")
+    print_fn(f"Valid size: {len(ds_valid)}")
+    print_fn(f"Test size: {len(ds_test)}")
+
+    tokenize_with_answer_ = partial(tokenize_with_answer, tokenizer=tokenizer, template=query_template)
+    tokenize_wo_answer_ = partial(tokenize_wo_answer, tokenizer=tokenizer, template=query_template)
+    ds_train = ds_train.map(tokenize_with_answer_, batched=True).remove_columns(["type", "query", "original_question"])
+    ds_valid = ds_valid.map(tokenize_wo_answer_, batched=True).remove_columns(["query"])
+    ds_test = ds_test.map(tokenize_wo_answer_, batched=True).remove_columns(["query"])
+
+    return ds_train, ds_valid, ds_test
+
+
+def tokenize_with_answer(samples, tokenizer, template):
+    queries = [template.format(query=sample) + answer for sample, answer in zip(samples["query"], samples["response"])]
+    tokenized = tokenizer(queries)
+    tokenized["input_ids"] = [input_ids[: tokenizer.model_max_length] for input_ids in tokenized["input_ids"]]
+    tokenized["attention_mask"] = [
+        input_ids[: tokenizer.model_max_length] for input_ids in tokenized["attention_mask"]
+    ]
+    return tokenized
+
+
+def tokenize_wo_answer(samples, tokenizer, template):
+    queries = [template.format(query=sample) for sample in samples["query"]]
+    tokenized = tokenizer(queries)
+    tokenized["input_ids"] = [input_ids[: tokenizer.model_max_length] for input_ids in tokenized["input_ids"]]
+    tokenized["attention_mask"] = [
+        input_ids[: tokenizer.model_max_length] for input_ids in tokenized["attention_mask"]
+    ]
+    return tokenized
+
+
+def get_wiki_small(num_samples: int = 100) -> list[str]:
+    # This way of loading the dataset avoid having to download whole shards
+    ds = load_dataset("HuggingFaceFW/finewiki", split="train", streaming=True)
+    dataset_head = ds.take(num_samples)
+    rows = [row["text"] for row in dataset_head]
+    return rows
diff --git a/method_comparison/MetaMathQA/default_training_params.json b/method_comparison/MetaMathQA/default_training_params.json
new file mode 100644
index 0000000..a10fa49
--- /dev/null
+++ b/method_comparison/MetaMathQA/default_training_params.json
@@ -0,0 +1,28 @@
+{
+  "model_id": "meta-llama/Llama-3.2-3B",
+  "dtype": "bfloat16",
+  "max_seq_length": 768,
+  "batch_size": 4,
+  "batch_size_eval": 50,
+  "max_steps": 5000,
+  "eval_steps": 250,
+  "compile": false,
+  "use_gc": false,
+  "seed": 0,
+  "grad_norm_clip": 1.0,
+  "optimizer_type": "AdamW",
+  "optimizer_kwargs": {
+    "lr": 1e-4,
+    "weight_decay": 0.1
+  },
+  "lr_scheduler": "cosine",
+  "use_amp": false,
+  "autocast_adapter_dtype": true,
+  "attn_implementation": null,
+  "generation_kwargs": {
+    "max_length": 800,
+    "max_new_tokens": 300
+  },
+  "query_template": "Question: {query} Think step by step.\nAnswer:",
+  "init_kv_cache_prefix": null
+}
diff --git a/method_comparison/MetaMathQA/experiments/adalora/llama-3.2-3B-rank32/adapter_config.json b/method_comparison/MetaMathQA/experiments/adalora/llama-3.2-3B-rank32/adapter_config.json
new file mode 100644
index 0000000..d20357b
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/adalora/llama-3.2-3B-rank32/adapter_config.json
@@ -0,0 +1,39 @@
+{
+  "alpha_pattern": {},
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "beta1": 0.85,
+  "beta2": 0.85,
+  "bias": "none",
+  "corda_config": null,
+  "deltaT": 1,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_lora_weights": true,
+  "init_r": 64,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 8,
+  "lora_bias": false,
+  "lora_dropout": 0.0,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "orth_reg_weight": 0.5,
+  "peft_type": "ADALORA",
+  "r": 8,
+  "rank_pattern": null,
+  "revision": null,
+  "target_modules": null,
+  "target_r": 32,
+  "task_type": null,
+  "tfinal": 500,
+  "tinit": 200,
+  "total_step": 5000,
+  "use_dora": false,
+  "use_rslora": false
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/adamss/llama-3.2-3B-rank32/adapter_config.json b/method_comparison/MetaMathQA/experiments/adamss/llama-3.2-3B-rank32/adapter_config.json
new file mode 100644
index 0000000..ddcbc40
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/adamss/llama-3.2-3B-rank32/adapter_config.json
@@ -0,0 +1,10 @@
+{
+  "peft_type": "ADAMSS",
+  "r": 100,
+  "num_subspaces": 32,
+  "subspace_rank": 1,
+  "target_modules": null,
+  "init_weights": "orthogonal",
+  "use_asa": false,
+  "task_type": "CAUSAL_LM"
+}
diff --git a/method_comparison/MetaMathQA/experiments/adamss/llama-3.2-3B-rank32/training_params.json b/method_comparison/MetaMathQA/experiments/adamss/llama-3.2-3B-rank32/training_params.json
new file mode 100644
index 0000000..e258e1c
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/adamss/llama-3.2-3B-rank32/training_params.json
@@ -0,0 +1,10 @@
+{
+  "model_id": "meta-llama/Llama-3.2-3B",
+  "max_steps": 5000,
+  "batch_size": 4,
+  "eval_steps": 250,
+  "optimizer_kwargs": {
+    "lr": 1e-4,
+    "weight_decay": 0.1
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/adaptionprompt/llama-3.2-3B-lr_0.0005/adapter_config.json b/method_comparison/MetaMathQA/experiments/adaptionprompt/llama-3.2-3B-lr_0.0005/adapter_config.json
new file mode 100644
index 0000000..367bea4
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/adaptionprompt/llama-3.2-3B-lr_0.0005/adapter_config.json
@@ -0,0 +1,11 @@
+{
+  "adapter_layers": 28,
+  "adapter_len": 100,
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "inference_mode": false,
+  "peft_type": "ADAPTION_PROMPT",
+  "revision": null,
+  "target_modules": null,
+  "task_type": "CAUSAL_LM"
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/adaptionprompt/llama-3.2-3B-lr_0.0005/training_params.json b/method_comparison/MetaMathQA/experiments/adaptionprompt/llama-3.2-3B-lr_0.0005/training_params.json
new file mode 100644
index 0000000..e8106a8
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/adaptionprompt/llama-3.2-3B-lr_0.0005/training_params.json
@@ -0,0 +1,6 @@
+{
+  "optimizer_kwargs": {
+    "lr": 5e-4
+  }
+}
+
diff --git a/method_comparison/MetaMathQA/experiments/adaptionprompt/llama-3.2-3B-lr_5e-3/adapter_config.json b/method_comparison/MetaMathQA/experiments/adaptionprompt/llama-3.2-3B-lr_5e-3/adapter_config.json
new file mode 100644
index 0000000..3ac7566
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/adaptionprompt/llama-3.2-3B-lr_5e-3/adapter_config.json
@@ -0,0 +1,12 @@
+{
+    "adapter_layers": 28,
+    "adapter_len": 100,
+    "auto_mapping": null,
+    "base_model_name_or_path": null,
+    "inference_mode": false,
+    "peft_type": "ADAPTION_PROMPT",
+    "peft_version": "0.19.2.dev0@UNKNOWN",
+    "revision": null,
+    "target_modules": null,
+    "task_type": null
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/adaptionprompt/llama-3.2-3B-lr_5e-3/training_params.json b/method_comparison/MetaMathQA/experiments/adaptionprompt/llama-3.2-3B-lr_5e-3/training_params.json
new file mode 100644
index 0000000..6ed46ad
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/adaptionprompt/llama-3.2-3B-lr_5e-3/training_params.json
@@ -0,0 +1,23 @@
+{
+    "model_id": "meta-llama/Llama-3.2-3B",
+    "dtype": "bfloat16",
+    "max_seq_length": 512,
+    "batch_size": 4,
+    "batch_size_eval": 64,
+    "max_steps": 3000,
+    "eval_steps": 500,
+    "compile": false,
+    "use_gc": true,
+    "use_amp": false,
+    "grad_norm_clip": 1.0,
+    "optimizer_type": "AdamW",
+    "optimizer_kwargs": {
+        "lr": 0.005,
+        "weight_decay": 0.1
+    },
+    "lr_scheduler": "cosine",
+    "generation_kwargs": {
+        "max_new_tokens": 256
+    },
+    "query_template": "Question: {query} Think step by step.\nAnswer:"
+    }
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/beft/llama-3.2-3B-target-v_proj/adapter_config.json b/method_comparison/MetaMathQA/experiments/beft/llama-3.2-3B-target-v_proj/adapter_config.json
new file mode 100644
index 0000000..658ca6c
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/beft/llama-3.2-3B-target-v_proj/adapter_config.json
@@ -0,0 +1,14 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "inference_mode": false,
+  "init_weights": true,
+  "modules_to_save": null,
+  "peft_type": "BEFT",
+  "peft_version": "0.19.2.dev0@UNKNOWN",
+  "revision": null,
+  "target_modules": [
+    "v_proj"
+  ],
+  "task_type": null
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/boft/llama-3.2-3B-default/adapter_config.json b/method_comparison/MetaMathQA/experiments/boft/llama-3.2-3B-default/adapter_config.json
new file mode 100644
index 0000000..44d5089
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/boft/llama-3.2-3B-default/adapter_config.json
@@ -0,0 +1,20 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "boft_block_num": 0,
+  "boft_block_size": 4,
+  "boft_dropout": 0.0,
+  "boft_n_butterfly_factor": 1,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "peft_type": "BOFT",
+  "revision": null,
+  "target_modules": null,
+  "task_type": null
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/c3a/llama-3.2-3B-default/adapter_config.json b/method_comparison/MetaMathQA/experiments/c3a/llama-3.2-3B-default/adapter_config.json
new file mode 100644
index 0000000..170c4bb
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/c3a/llama-3.2-3B-default/adapter_config.json
@@ -0,0 +1,21 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_weights": false,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "block_size": 64,
+  "block_size_pattern": {},
+  "peft_type": "C3A",
+  "revision": null,
+  "target_modules": [
+    "v_proj",
+    "q_proj"
+  ],
+  "task_type": null
+}
diff --git a/method_comparison/MetaMathQA/experiments/c3a/llama-3.2-3B-default/training_params.json b/method_comparison/MetaMathQA/experiments/c3a/llama-3.2-3B-default/training_params.json
new file mode 100644
index 0000000..a39b9dc
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/c3a/llama-3.2-3B-default/training_params.json
@@ -0,0 +1,6 @@
+{
+  "optimizer_kwargs": {
+    "lr": 3e-1,
+    "weight_decay": 1e-5
+  }
+}
diff --git a/method_comparison/MetaMathQA/experiments/deft/llama-3.2-3B-rank32-para/adapter_config.json b/method_comparison/MetaMathQA/experiments/deft/llama-3.2-3B-rank32-para/adapter_config.json
new file mode 100644
index 0000000..acb30de
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/deft/llama-3.2-3B-rank32-para/adapter_config.json
@@ -0,0 +1,23 @@
+{
+  "alpha": null,
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "decomposition_method": "qr",
+  "deft_dropout": 0.0,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_scale": 1.0,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "para": true,
+  "peft_type": "DEFT",
+  "peft_version": "0.19.2.dev0@UNKNOWN",
+  "r": 32,
+  "revision": null,
+  "target_modules": null,
+  "task_type": "CAUSAL_LM"
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/deft/llama-3.2-3B-rank32/adapter_config.json b/method_comparison/MetaMathQA/experiments/deft/llama-3.2-3B-rank32/adapter_config.json
new file mode 100644
index 0000000..3dfca2b
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/deft/llama-3.2-3B-rank32/adapter_config.json
@@ -0,0 +1,23 @@
+{
+  "alpha": 128,
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "decomposition_method": "relu",
+  "deft_dropout": 0.0,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_scale": 1.0,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "para": false,
+  "peft_type": "DEFT",
+  "peft_version": "0.19.2.dev0@UNKNOWN",
+  "r": 32,
+  "revision": null,
+  "target_modules": null,
+  "task_type": "CAUSAL_LM"
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/delora/llama-3.2-3B-rank32/adapter_config.json b/method_comparison/MetaMathQA/experiments/delora/llama-3.2-3B-rank32/adapter_config.json
new file mode 100644
index 0000000..6217e8f
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/delora/llama-3.2-3B-rank32/adapter_config.json
@@ -0,0 +1,20 @@
+{
+  "lambda_pattern": {},
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "exclude_modules": null,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "delora_lambda": 15,
+  "module_dropout": 0.0,
+  "modules_to_save": null,
+  "peft_type": "DELORA",
+  "r": 32,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": null,
+  "task_type": "CAUSAL_LM"
+}
diff --git a/method_comparison/MetaMathQA/experiments/delora/llama-3.2-3B-rank32/training_params.json b/method_comparison/MetaMathQA/experiments/delora/llama-3.2-3B-rank32/training_params.json
new file mode 100644
index 0000000..8a120ad
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/delora/llama-3.2-3B-rank32/training_params.json
@@ -0,0 +1,6 @@
+{
+  "optimizer_kwargs": {
+    "lr": 1e-3
+  }
+}
+
diff --git a/method_comparison/MetaMathQA/experiments/fourierft/llama-3.2-3B-default/adapter_config.json b/method_comparison/MetaMathQA/experiments/fourierft/llama-3.2-3B-default/adapter_config.json
new file mode 100644
index 0000000..a2a379f
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/fourierft/llama-3.2-3B-default/adapter_config.json
@@ -0,0 +1,23 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_weights": false,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "n_frequency": 1000,
+  "n_frequency_pattern": {},
+  "peft_type": "FOURIERFT",
+  "random_loc_seed": 777,
+  "revision": null,
+  "scaling": 300,
+  "target_modules": [
+    "v_proj",
+    "q_proj"
+  ],
+  "task_type": null
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/fourierft/llama-3.2-3B-n_frequency-5000/adapter_config.json b/method_comparison/MetaMathQA/experiments/fourierft/llama-3.2-3B-n_frequency-5000/adapter_config.json
new file mode 100644
index 0000000..40d4024
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/fourierft/llama-3.2-3B-n_frequency-5000/adapter_config.json
@@ -0,0 +1,23 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_weights": false,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "n_frequency": 5000,
+  "n_frequency_pattern": {},
+  "peft_type": "FOURIERFT",
+  "random_loc_seed": 777,
+  "revision": null,
+  "scaling": 300,
+  "target_modules": [
+    "v_proj",
+    "q_proj"
+  ],
+  "task_type": null
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/frod/llama-3.2-3B-default/adapter_config.json b/method_comparison/MetaMathQA/experiments/frod/llama-3.2-3B-default/adapter_config.json
new file mode 100644
index 0000000..4246f65
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/frod/llama-3.2-3B-default/adapter_config.json
@@ -0,0 +1,21 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "fan_in_fan_out": false,
+  "frod_dropout": 0.0,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "peft_type": "FROD",
+  "projection_prng_key": 0,
+  "regularization_alpha": 0.001,
+  "revision": null,
+  "runtime_offload_base_weight": true,
+  "save_projection": true,
+  "sparse_rate": 0.01,
+  "target_modules": null,
+  "task_type": "CAUSAL_LM"
+}
diff --git a/method_comparison/MetaMathQA/experiments/frod/llama-3.2-3B-sparse0.02-lr_0.001/adapter_config.json b/method_comparison/MetaMathQA/experiments/frod/llama-3.2-3B-sparse0.02-lr_0.001/adapter_config.json
new file mode 100644
index 0000000..6c136c6
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/frod/llama-3.2-3B-sparse0.02-lr_0.001/adapter_config.json
@@ -0,0 +1,21 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "fan_in_fan_out": false,
+  "frod_dropout": 0.0,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "peft_type": "FROD",
+  "projection_prng_key": 0,
+  "regularization_alpha": 0.001,
+  "revision": null,
+  "runtime_offload_base_weight": true,
+  "save_projection": true,
+  "sparse_rate": 0.02,
+  "target_modules": null,
+  "task_type": "CAUSAL_LM"
+}
diff --git a/method_comparison/MetaMathQA/experiments/frod/llama-3.2-3B-sparse0.02-lr_0.001/training_params.json b/method_comparison/MetaMathQA/experiments/frod/llama-3.2-3B-sparse0.02-lr_0.001/training_params.json
new file mode 100644
index 0000000..52d87e3
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/frod/llama-3.2-3B-sparse0.02-lr_0.001/training_params.json
@@ -0,0 +1,5 @@
+{
+  "optimizer_kwargs": {
+    "lr": 1e-3
+  }
+}
diff --git a/method_comparison/MetaMathQA/experiments/full-finetuning/llama-3.2-3B-lr_0.00001/training_params.json b/method_comparison/MetaMathQA/experiments/full-finetuning/llama-3.2-3B-lr_0.00001/training_params.json
new file mode 100644
index 0000000..6d6c3b0
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/full-finetuning/llama-3.2-3B-lr_0.00001/training_params.json
@@ -0,0 +1,6 @@
+{
+  "optimizer_kwargs": {
+    "lr": 1e-5
+  }
+}
+
diff --git a/method_comparison/MetaMathQA/experiments/glora/llama-3.2-3B-default/adapter_config.json b/method_comparison/MetaMathQA/experiments/glora/llama-3.2-3B-default/adapter_config.json
new file mode 100644
index 0000000..5fd38ee
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/glora/llama-3.2-3B-default/adapter_config.json
@@ -0,0 +1,18 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "config_A_B": "lora",
+  "config_C": "lora",
+  "config_D_E": "constant",
+  "inference_mode": false,
+  "init_weights": true,
+  "modules_to_save": null,
+  "peft_type": "GLORA",
+  "r": 8,
+  "target_modules": [
+    "q_proj",
+    "v_proj"
+  ],
+  "task_type": "CAUSAL_LM"
+}
diff --git a/method_comparison/MetaMathQA/experiments/glora/llama-3.2-3B-vector-paths/adapter_config.json b/method_comparison/MetaMathQA/experiments/glora/llama-3.2-3B-vector-paths/adapter_config.json
new file mode 100644
index 0000000..8214b91
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/glora/llama-3.2-3B-vector-paths/adapter_config.json
@@ -0,0 +1,18 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "config_A_B": "vector",
+  "config_C": "vector",
+  "config_D_E": "constant",
+  "inference_mode": false,
+  "init_weights": true,
+  "modules_to_save": null,
+  "peft_type": "GLORA",
+  "r": 8,
+  "target_modules": [
+    "q_proj",
+    "v_proj"
+  ],
+  "task_type": "CAUSAL_LM"
+}
diff --git a/method_comparison/MetaMathQA/experiments/glora/llama-3.2-3B-vector-paths/training_params.json b/method_comparison/MetaMathQA/experiments/glora/llama-3.2-3B-vector-paths/training_params.json
new file mode 100644
index 0000000..edb6199
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/glora/llama-3.2-3B-vector-paths/training_params.json
@@ -0,0 +1,6 @@
+{
+  "optimizer_kwargs": {
+    "lr": 5e-4,
+    "weight_decay": 0.0
+  }
+}
diff --git a/method_comparison/MetaMathQA/experiments/gralora/llama-3.2-3B-rank32/adapter_config.json b/method_comparison/MetaMathQA/experiments/gralora/llama-3.2-3B-rank32/adapter_config.json
new file mode 100644
index 0000000..edeb382
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/gralora/llama-3.2-3B-rank32/adapter_config.json
@@ -0,0 +1,21 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "fan_in_fan_out": false,
+  "alpha": 64,
+  "gralora_dropout": 0.0,
+  "gralora_k": 2,
+  "hybrid_r": 0,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "peft_type": "GRALORA",
+  "peft_version": "0.17.2.dev0@UNKNOWN",
+  "r": 32,
+  "revision": null,
+  "target_modules": null,
+  "task_type": null
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/gralora/llama-3.2-3B-rank32/training_params.json b/method_comparison/MetaMathQA/experiments/gralora/llama-3.2-3B-rank32/training_params.json
new file mode 100644
index 0000000..94cd6b2
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/gralora/llama-3.2-3B-rank32/training_params.json
@@ -0,0 +1,5 @@
+{
+  "optimizer_kwargs": {
+    "lr": 2e-4
+  }
+}
diff --git a/method_comparison/MetaMathQA/experiments/hira/llama-3.2-3B-rank32-lr4.5e-3/adapter_config.json b/method_comparison/MetaMathQA/experiments/hira/llama-3.2-3B-rank32-lr4.5e-3/adapter_config.json
new file mode 100644
index 0000000..f992b65
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/hira/llama-3.2-3B-rank32-lr4.5e-3/adapter_config.json
@@ -0,0 +1,20 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "hira_dropout": 0.0,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "peft_type": "HIRA",
+  "r": 32,
+  "rank_pattern": {},
+  "target_modules": [
+    "q_proj",
+    "v_proj"
+  ],
+  "task_type": "CAUSAL_LM"
+}
diff --git a/method_comparison/MetaMathQA/experiments/hira/llama-3.2-3B-rank32-lr4.5e-3/training_params.json b/method_comparison/MetaMathQA/experiments/hira/llama-3.2-3B-rank32-lr4.5e-3/training_params.json
new file mode 100644
index 0000000..951b2a4
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/hira/llama-3.2-3B-rank32-lr4.5e-3/training_params.json
@@ -0,0 +1,6 @@
+{
+  "optimizer_kwargs": {
+    "lr": 4.5e-3,
+    "weight_decay": 0.0
+  }
+}
diff --git a/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-all-attn-5k-lr0.005/adapter_config.json b/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-all-attn-5k-lr0.005/adapter_config.json
new file mode 100644
index 0000000..dbd23f7
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-all-attn-5k-lr0.005/adapter_config.json
@@ -0,0 +1,14 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "feedforward_modules": ["down_proj", "gate_proj", "up_proj"],
+  "inference_mode": false,
+  "init_ia3_weights": true,
+  "modules_to_save": null,
+  "peft_type": "IA3",
+  "revision": null,
+  "target_modules": ["q_proj", "k_proj", "v_proj", "o_proj", "down_proj", "gate_proj", "up_proj"],
+  "task_type": null
+}
diff --git a/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-all-attn-5k-lr0.005/training_params.json b/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-all-attn-5k-lr0.005/training_params.json
new file mode 100644
index 0000000..57801b4
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-all-attn-5k-lr0.005/training_params.json
@@ -0,0 +1,6 @@
+{
+  "optimizer_kwargs": {
+    "lr": 5e-3,
+    "weight_decay": 0.0
+  }
+}
diff --git a/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-default/adapter_config.json b/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-default/adapter_config.json
new file mode 100644
index 0000000..0c8e514
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-default/adapter_config.json
@@ -0,0 +1,14 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "feedforward_modules": null,
+  "inference_mode": false,
+  "init_ia3_weights": true,
+  "modules_to_save": null,
+  "peft_type": "IA3",
+  "revision": null,
+  "target_modules": null,
+  "task_type": null
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-lr_0.001/adapter_config.json b/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-lr_0.001/adapter_config.json
new file mode 100644
index 0000000..0c8e514
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-lr_0.001/adapter_config.json
@@ -0,0 +1,14 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "feedforward_modules": null,
+  "inference_mode": false,
+  "init_ia3_weights": true,
+  "modules_to_save": null,
+  "peft_type": "IA3",
+  "revision": null,
+  "target_modules": null,
+  "task_type": null
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-lr_0.001/training_params.json b/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-lr_0.001/training_params.json
new file mode 100644
index 0000000..8a120ad
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/ia3/llama-3.2-3B-lr_0.001/training_params.json
@@ -0,0 +1,6 @@
+{
+  "optimizer_kwargs": {
+    "lr": 1e-3
+  }
+}
+
diff --git a/method_comparison/MetaMathQA/experiments/lily/llama-3.2-3B-rank140-mlp-a2-b2-s8.0/adapter_config.json b/method_comparison/MetaMathQA/experiments/lily/llama-3.2-3B-rank140-mlp-a2-b2-s8.0/adapter_config.json
new file mode 100644
index 0000000..7544d9f
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/lily/llama-3.2-3B-rank140-mlp-a2-b2-s8.0/adapter_config.json
@@ -0,0 +1,19 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "exclude_modules": null,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "num_B": 2,
+  "peft_type": "LILY",
+  "peft_version": "0.18.2.dev0@UNKNOWN",
+  "r": 140,
+  "revision": null,
+  "scaling": 8.0,
+  "stride_A": 14,
+  "target_modules": ["gate_proj", "up_proj", "down_proj"],
+  "task_type": null
+}
diff --git a/method_comparison/MetaMathQA/experiments/lily/llama-3.2-3B-rank896-a2-b2-s2.0/adapter_config.json b/method_comparison/MetaMathQA/experiments/lily/llama-3.2-3B-rank896-a2-b2-s2.0/adapter_config.json
new file mode 100644
index 0000000..d4ab980
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/lily/llama-3.2-3B-rank896-a2-b2-s2.0/adapter_config.json
@@ -0,0 +1,22 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "exclude_modules": null,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "num_B": 2,
+  "peft_type": "LILY",
+  "peft_version": "0.18.2.dev0@UNKNOWN",
+  "r": 896,
+  "revision": null,
+  "scaling": 2.0,
+  "stride_A": 14,
+  "target_modules": [
+    "q_proj",
+    "v_proj"
+  ],
+  "task_type": null
+}
diff --git a/method_comparison/MetaMathQA/experiments/ln_tuning/llama-3.2-3B-default/adapter_config.json b/method_comparison/MetaMathQA/experiments/ln_tuning/llama-3.2-3B-default/adapter_config.json
new file mode 100644
index 0000000..70b7363
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/ln_tuning/llama-3.2-3B-default/adapter_config.json
@@ -0,0 +1,11 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "exclude_modules": null,
+  "inference_mode": false,
+  "modules_to_save": null,
+  "peft_type": "LN_TUNING",
+  "revision": null,
+  "target_modules": null,
+  "task_type": null
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/loha/llama-3.2-3B-rank32/adapter_config.json b/method_comparison/MetaMathQA/experiments/loha/llama-3.2-3B-rank32/adapter_config.json
new file mode 100644
index 0000000..1137259
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/loha/llama-3.2-3B-rank32/adapter_config.json
@@ -0,0 +1,24 @@
+{
+  "alpha": 64,
+  "alpha_pattern": {},
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "exclude_modules": null,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "module_dropout": 0.0,
+  "modules_to_save": null,
+  "peft_type": "LOHA",
+  "r": 32,
+  "rank_dropout": 0.0,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "q_proj",
+    "v_proj"
+  ],
+  "task_type": null,
+  "use_effective_conv2d": false
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/lokr/llama-3.2-3B-rank32/adapter_config.json b/method_comparison/MetaMathQA/experiments/lokr/llama-3.2-3B-rank32/adapter_config.json
new file mode 100644
index 0000000..7d30dd7
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/lokr/llama-3.2-3B-rank32/adapter_config.json
@@ -0,0 +1,27 @@
+{
+  "alpha": 64,
+  "alpha_pattern": {},
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "decompose_both": false,
+  "decompose_factor": -1,
+  "exclude_modules": null,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "module_dropout": 0.0,
+  "modules_to_save": null,
+  "peft_type": "LOKR",
+  "r": 32,
+  "rank_dropout": 0.0,
+  "rank_dropout_scale": false,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "q_proj",
+    "v_proj"
+  ],
+  "task_type": null,
+  "use_effective_conv2d": false
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank10-target-mlp/adapter_config.json b/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank10-target-mlp/adapter_config.json
new file mode 100644
index 0000000..2c04c5c
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank10-target-mlp/adapter_config.json
@@ -0,0 +1,30 @@
+{
+  "alpha_pattern": {},
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "corda_config": null,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 20,
+  "lora_bias": false,
+  "lora_dropout": 0.0,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "peft_type": "LORA",
+  "r": 10,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": ["gate_proj", "up_proj", "down_proj"],
+  "task_type": "CAUSAL_LM",
+  "use_dora": false,
+  "use_rslora": false
+}
diff --git a/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank14-target-mlp-bdlora/adapter_config.json b/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank14-target-mlp-bdlora/adapter_config.json
new file mode 100644
index 0000000..cbd929e
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank14-target-mlp-bdlora/adapter_config.json
@@ -0,0 +1,48 @@
+{
+    "alpha_pattern": {},
+    "auto_mapping": null,
+    "base_model_name_or_path": null,
+    "bias": "none",
+    "corda_config": null,
+    "eva_config": null,
+    "exclude_modules": null,
+    "fan_in_fan_out": false,
+    "inference_mode": false,
+    "init_lora_weights": true,
+    "layer_replication": null,
+    "layers_pattern": null,
+    "layers_to_transform": null,
+    "loftq_config": {},
+    "lora_alpha": 28,
+    "lora_bias": false,
+    "lora_dropout": 0.0,
+    "megatron_config": null,
+    "megatron_core": "megatron.core",
+    "modules_to_save": null,
+    "peft_type": "LORA",
+    "r": 14,
+    "rank_pattern": {},
+    "revision": null,
+    "target_modules": [
+        "gate_proj",
+        "up_proj",
+        "down_proj"
+    ],
+    "task_type": "CAUSAL_LM",
+    "use_dora": false,
+    "use_rslora": false,
+    "use_bdlora": {
+        "target_modules_bd_a": [
+            "o_proj",
+            "down_proj"
+        ],
+        "target_modules_bd_b": [
+            "q_proj",
+            "v_proj",
+            "k_proj",
+            "up_proj",
+            "gate_proj"
+        ],
+        "nblocks": 2
+    }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32-dora/adapter_config.json b/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32-dora/adapter_config.json
new file mode 100644
index 0000000..255d09d
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32-dora/adapter_config.json
@@ -0,0 +1,30 @@
+{
+  "alpha_pattern": {},
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "corda_config": null,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 64,
+  "lora_bias": false,
+  "lora_dropout": 0.0,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "peft_type": "LORA",
+  "r": 32,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": null,
+  "task_type": "CAUSAL_LM",
+  "use_dora": true,
+  "use_rslora": false
+}
diff --git a/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32-lorafa/adapter_config.json b/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32-lorafa/adapter_config.json
new file mode 100644
index 0000000..8832c10
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32-lorafa/adapter_config.json
@@ -0,0 +1,30 @@
+{
+  "alpha_pattern": {},
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "corda_config": null,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 64,
+  "lora_bias": false,
+  "lora_dropout": 0.0,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "peft_type": "LORA",
+  "r": 32,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": null,
+  "task_type": "CAUSAL_LM",
+  "use_dora": false,
+  "use_rslora": false
+}
diff --git a/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32-lorafa/training_params.json b/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32-lorafa/training_params.json
new file mode 100644
index 0000000..985db87
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32-lorafa/training_params.json
@@ -0,0 +1,9 @@
+{
+  "optimizer_type": "lora-fa",
+  "optimizer_kwargs": {
+    "r": 32,
+    "lora_alpha": 64,
+    "lr": 1e-4,
+    "weight_decay": 0.1
+  }
+}
diff --git a/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32-mica/adapter_config.json b/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32-mica/adapter_config.json
new file mode 100644
index 0000000..e62097f
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32-mica/adapter_config.json
@@ -0,0 +1,30 @@
+{
+  "alpha_pattern": {},
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "corda_config": null,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_lora_weights": "mica",
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 64,
+  "lora_bias": false,
+  "lora_dropout": 0.0,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "peft_type": "LORA",
+  "r": 32,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": null,
+  "task_type": "CAUSAL_LM",
+  "use_dora": false,
+  "use_rslora": false
+}
diff --git a/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32/adapter_config.json b/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32/adapter_config.json
new file mode 100644
index 0000000..8832c10
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank32/adapter_config.json
@@ -0,0 +1,30 @@
+{
+  "alpha_pattern": {},
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "corda_config": null,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 64,
+  "lora_bias": false,
+  "lora_dropout": 0.0,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "peft_type": "LORA",
+  "r": 32,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": null,
+  "task_type": "CAUSAL_LM",
+  "use_dora": false,
+  "use_rslora": false
+}
diff --git a/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank64-rslora/adapter_config.json b/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank64-rslora/adapter_config.json
new file mode 100644
index 0000000..dc1f803
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank64-rslora/adapter_config.json
@@ -0,0 +1,30 @@
+{
+  "alpha_pattern": {},
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "corda_config": null,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 64,
+  "lora_bias": false,
+  "lora_dropout": 0.0,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "peft_type": "LORA",
+  "r": 64,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": null,
+  "task_type": "CAUSAL_LM",
+  "use_dora": false,
+  "use_rslora": true
+}
diff --git a/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank64/adapter_config.json b/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank64/adapter_config.json
new file mode 100644
index 0000000..75890c9
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/lora/llama-3.2-3B-rank64/adapter_config.json
@@ -0,0 +1,30 @@
+{
+  "alpha_pattern": {},
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "corda_config": null,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 128,
+  "lora_bias": false,
+  "lora_dropout": 0.0,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "peft_type": "LORA",
+  "r": 64,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": null,
+  "task_type": "CAUSAL_LM",
+  "use_dora": false,
+  "use_rslora": false
+}
diff --git a/method_comparison/MetaMathQA/experiments/miss/llama-3.2-3B-bat/adapter_config.json b/method_comparison/MetaMathQA/experiments/miss/llama-3.2-3B-bat/adapter_config.json
new file mode 100644
index 0000000..a3267da
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/miss/llama-3.2-3B-bat/adapter_config.json
@@ -0,0 +1,18 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "exclude_modules": null,
+  "inference_mode": false,
+  "init_weights": "bat",
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "mini_r": 1,
+  "miss_dropout": 0.0,
+  "modules_to_save": null,
+  "peft_type": "MISS",
+  "r": 64,
+  "revision": null,
+  "target_modules": null,
+  "task_type": null
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/miss/llama-3.2-3B-default/adapter_config.json b/method_comparison/MetaMathQA/experiments/miss/llama-3.2-3B-default/adapter_config.json
new file mode 100644
index 0000000..02ee9f7
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/miss/llama-3.2-3B-default/adapter_config.json
@@ -0,0 +1,18 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "exclude_modules": null,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "mini_r": 1,
+  "miss_dropout": 0.0,
+  "modules_to_save": null,
+  "peft_type": "MISS",
+  "r": 64,
+  "revision": null,
+  "target_modules": null,
+  "task_type": null
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/miss/llama-3.2-3B-mini/adapter_config.json b/method_comparison/MetaMathQA/experiments/miss/llama-3.2-3B-mini/adapter_config.json
new file mode 100644
index 0000000..d732e18
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/miss/llama-3.2-3B-mini/adapter_config.json
@@ -0,0 +1,18 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "exclude_modules": null,
+  "inference_mode": false,
+  "init_weights": "mini",
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "mini_r": 64,
+  "miss_dropout": 0.0,
+  "modules_to_save": null,
+  "peft_type": "MISS",
+  "r": 64,
+  "revision": null,
+  "target_modules": null,
+  "task_type": null
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/oft/llama-3.2-3B-rank32/adapter_config.json b/method_comparison/MetaMathQA/experiments/oft/llama-3.2-3B-rank32/adapter_config.json
new file mode 100644
index 0000000..e8cdb86
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/oft/llama-3.2-3B-rank32/adapter_config.json
@@ -0,0 +1,27 @@
+{
+  "alpha_pattern": {},
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "block_share": false,
+  "coft": false,
+  "eps": 6e-05,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "module_dropout": 0.0,
+  "modules_to_save": null,
+  "oft_block_size": 0,
+  "peft_type": "OFT",
+  "r": 32,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "q_proj",
+    "v_proj"
+  ],
+  "task_type": null
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/osf/llama-3.2-3B-rank128/adapter_config.json b/method_comparison/MetaMathQA/experiments/osf/llama-3.2-3B-rank128/adapter_config.json
new file mode 100644
index 0000000..34d7bf1
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/osf/llama-3.2-3B-rank128/adapter_config.json
@@ -0,0 +1,28 @@
+{
+  "task_type": null,
+  "peft_type": "OSF",
+  "auto_mapping": null,
+  "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+  "revision": null,
+  "inference_mode": false,
+  "effective_rank": null,
+  "target_modules": [
+    "q_proj",
+    "k_proj",
+    "v_proj",
+    "o_proj",
+    "gate_proj",
+    "down_proj",
+    "up_proj"
+  ],
+  "rank_pattern": {
+    "q_proj": 2944,
+    "o_proj": 2944,
+    "k_proj": 896,
+    "v_proj": 896,
+    "gate_proj": 2944,
+    "down_proj": 2944,
+    "up_proj": 2944
+  }
+}
+
diff --git a/method_comparison/MetaMathQA/experiments/osf/llama-3.2-3B-rank128/training_params.json b/method_comparison/MetaMathQA/experiments/osf/llama-3.2-3B-rank128/training_params.json
new file mode 100644
index 0000000..51f6431
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/osf/llama-3.2-3B-rank128/training_params.json
@@ -0,0 +1,7 @@
+{
+  "autocast_adapter_dtype": false,
+  "optimizer_kwargs": {
+    "lr": 5e-5
+  }
+}
+
diff --git a/method_comparison/MetaMathQA/experiments/peanut/llama-3.2-3B-rank1-relu-depth0-s32.0/adapter_config.json b/method_comparison/MetaMathQA/experiments/peanut/llama-3.2-3B-rank1-relu-depth0-s32.0/adapter_config.json
new file mode 100644
index 0000000..a4007c1
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/peanut/llama-3.2-3B-rank1-relu-depth0-s32.0/adapter_config.json
@@ -0,0 +1,22 @@
+{
+  "act_fn": "relu",
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "depth": 0,
+  "exclude_modules": null,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "peft_type": "PEANUT",
+  "peft_version": "0.18.2.dev0@UNKNOWN",
+  "r": 1,
+  "revision": null,
+  "scaling": 32.0,
+  "target_modules": [
+    "q_proj",
+    "v_proj"
+  ],
+  "task_type": null
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/peanut/llama-3.2-3B-rank32-relu-depth0-s2.0/adapter_config.json b/method_comparison/MetaMathQA/experiments/peanut/llama-3.2-3B-rank32-relu-depth0-s2.0/adapter_config.json
new file mode 100644
index 0000000..ddb11ba
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/peanut/llama-3.2-3B-rank32-relu-depth0-s2.0/adapter_config.json
@@ -0,0 +1,22 @@
+{
+  "act_fn": "relu",
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "depth": 0,
+  "exclude_modules": null,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "peft_type": "PEANUT",
+  "peft_version": "0.18.2.dev0@UNKNOWN",
+  "r": 32,
+  "revision": null,
+  "scaling": 2.0,
+  "target_modules": [
+    "q_proj",
+    "v_proj"
+  ],
+  "task_type": null
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-lr_0.001/adapter_config.json b/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-lr_0.001/adapter_config.json
new file mode 100644
index 0000000..77bff7f
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-lr_0.001/adapter_config.json
@@ -0,0 +1,15 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "encoder_hidden_size": 3072,
+  "inference_mode": false,
+  "num_attention_heads": 24,
+  "num_layers": 28,
+  "num_transformer_submodules": 1,
+  "num_virtual_tokens": 200,
+  "peft_type": "PREFIX_TUNING",
+  "prefix_projection": false,
+  "revision": null,
+  "task_type": "CAUSAL_LM",
+  "token_dim": 3072
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-lr_0.001/training_params.json b/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-lr_0.001/training_params.json
new file mode 100644
index 0000000..8a120ad
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-lr_0.001/training_params.json
@@ -0,0 +1,6 @@
+{
+  "optimizer_kwargs": {
+    "lr": 1e-3
+  }
+}
+
diff --git a/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-lr_0.005_zero_init/adapter_config.json b/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-lr_0.005_zero_init/adapter_config.json
new file mode 100644
index 0000000..29cbe86
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-lr_0.005_zero_init/adapter_config.json
@@ -0,0 +1,16 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "encoder_hidden_size": 3072,
+  "inference_mode": false,
+  "num_attention_heads": 24,
+  "num_layers": 28,
+  "num_transformer_submodules": 1,
+  "num_virtual_tokens": 200,
+  "init_weights": "zero",
+  "peft_type": "PREFIX_TUNING",
+  "prefix_projection": false,
+  "revision": null,
+  "task_type": "CAUSAL_LM",
+  "token_dim": 3072
+}
diff --git a/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-lr_0.005_zero_init/training_params.json b/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-lr_0.005_zero_init/training_params.json
new file mode 100644
index 0000000..3c6ed9d
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-lr_0.005_zero_init/training_params.json
@@ -0,0 +1,5 @@
+{
+  "optimizer_kwargs": {
+    "lr": 0.005
+  }
+}
diff --git a/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-tokens50-init_prefix-lr_0.005/adapter_config.json b/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-tokens50-init_prefix-lr_0.005/adapter_config.json
new file mode 100644
index 0000000..382c384
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-tokens50-init_prefix-lr_0.005/adapter_config.json
@@ -0,0 +1,16 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "encoder_hidden_size": 3072,
+  "inference_mode": false,
+  "num_attention_heads": 24,
+  "num_layers": 28,
+  "num_transformer_submodules": 1,
+  "num_virtual_tokens": 50,
+  "init_weights": "zero",
+  "peft_type": "PREFIX_TUNING",
+  "prefix_projection": false,
+  "revision": null,
+  "task_type": "CAUSAL_LM",
+  "token_dim": 3072
+}
diff --git a/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-tokens50-init_prefix-lr_0.005/training_params.json b/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-tokens50-init_prefix-lr_0.005/training_params.json
new file mode 100644
index 0000000..54b4891
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/prefixtuning/llama-3.2-3B-tokens50-init_prefix-lr_0.005/training_params.json
@@ -0,0 +1,6 @@
+{
+  "init_kv_cache_prefix": "You are a helpful math assistant. Solve mathematical problems by thinking step by step. First, identify what the problem is asking. Then, break down the solution into clear logical steps. Show all your work and calculations. Finally, verify that your answer makes sense.",
+  "optimizer_kwargs": {
+    "lr": 0.005
+  }
+}
diff --git a/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-default/adapter_config.json b/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-default/adapter_config.json
new file mode 100644
index 0000000..efa055b
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-default/adapter_config.json
@@ -0,0 +1,17 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "inference_mode": false,
+  "num_attention_heads": 24,
+  "num_layers": 28,
+  "num_transformer_submodules": 1,
+  "num_virtual_tokens": 200,
+  "peft_type": "PROMPT_TUNING",
+  "prompt_tuning_init": "RANDOM",
+  "prompt_tuning_init_text": null,
+  "revision": null,
+  "task_type": "CAUSAL_LM",
+  "token_dim": 3072,
+  "tokenizer_kwargs": null,
+  "tokenizer_name_or_path": null
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-lr_0.001/adapter_config.json b/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-lr_0.001/adapter_config.json
new file mode 100644
index 0000000..efa055b
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-lr_0.001/adapter_config.json
@@ -0,0 +1,17 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "inference_mode": false,
+  "num_attention_heads": 24,
+  "num_layers": 28,
+  "num_transformer_submodules": 1,
+  "num_virtual_tokens": 200,
+  "peft_type": "PROMPT_TUNING",
+  "prompt_tuning_init": "RANDOM",
+  "prompt_tuning_init_text": null,
+  "revision": null,
+  "task_type": "CAUSAL_LM",
+  "token_dim": 3072,
+  "tokenizer_kwargs": null,
+  "tokenizer_name_or_path": null
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-lr_0.001/training_params.json b/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-lr_0.001/training_params.json
new file mode 100644
index 0000000..8a120ad
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-lr_0.001/training_params.json
@@ -0,0 +1,6 @@
+{
+  "optimizer_kwargs": {
+    "lr": 1e-3
+  }
+}
+
diff --git a/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-sample_vocab-lr_0.001/adapter_config.json b/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-sample_vocab-lr_0.001/adapter_config.json
new file mode 100644
index 0000000..8b9f142
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-sample_vocab-lr_0.001/adapter_config.json
@@ -0,0 +1,17 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "inference_mode": false,
+  "num_attention_heads": 24,
+  "num_layers": 28,
+  "num_transformer_submodules": 1,
+  "num_virtual_tokens": 200,
+  "peft_type": "PROMPT_TUNING",
+  "prompt_tuning_init": "SAMPLE_VOCAB",
+  "prompt_tuning_init_text": null,
+  "revision": null,
+  "task_type": "CAUSAL_LM",
+  "token_dim": 3072,
+  "tokenizer_kwargs": null,
+  "tokenizer_name_or_path": null
+}
diff --git a/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-sample_vocab-lr_0.001/training_params.json b/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-sample_vocab-lr_0.001/training_params.json
new file mode 100644
index 0000000..8a120ad
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/prompt_tuning/llama-3.2-3B-sample_vocab-lr_0.001/training_params.json
@@ -0,0 +1,6 @@
+{
+  "optimizer_kwargs": {
+    "lr": 1e-3
+  }
+}
+
diff --git a/method_comparison/MetaMathQA/experiments/psoft/llama-3.2-3B-default/adapter_config.json b/method_comparison/MetaMathQA/experiments/psoft/llama-3.2-3B-default/adapter_config.json
new file mode 100644
index 0000000..fb70b83
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/psoft/llama-3.2-3B-default/adapter_config.json
@@ -0,0 +1,26 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "r": 256,
+  "psoft_alpha": 256,
+  "psoft_dropout": 0.0,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "ab_svd_init": "psoft_init",
+  "psoft_svd": "full",
+  "psoft_svd_lowrank_niter": 10,
+  "psoft_orth": true,
+  "psoft_mag_a": true,
+  "psoft_mag_b": true,
+  "use_cayley_neumann": false,
+  "num_cayley_neumann_terms": 5,
+  "cayley_neumann_eps": null,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "peft_type": "PSOFT",
+  "revision": null,
+  "target_modules": null,
+  "task_type": null
+}
diff --git a/method_comparison/MetaMathQA/experiments/psoft/llama-3.2-3B-fast/adapter_config.json b/method_comparison/MetaMathQA/experiments/psoft/llama-3.2-3B-fast/adapter_config.json
new file mode 100644
index 0000000..290234d
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/psoft/llama-3.2-3B-fast/adapter_config.json
@@ -0,0 +1,26 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "r": 256,
+  "psoft_alpha": 256,
+  "psoft_dropout": 0.0,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "ab_svd_init": "psoft_init",
+  "psoft_svd": "lowrank",
+  "psoft_svd_lowrank_niter": 10,
+  "psoft_orth": true,
+  "psoft_mag_a": true,
+  "psoft_mag_b": true,
+  "use_cayley_neumann": true,
+  "num_cayley_neumann_terms": 5,
+  "cayley_neumann_eps": null,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "peft_type": "PSOFT",
+  "revision": null,
+  "target_modules": null,
+  "task_type": null
+}
diff --git a/method_comparison/MetaMathQA/experiments/ptuning/llama-3.2-3B-default/adapter_config.json b/method_comparison/MetaMathQA/experiments/ptuning/llama-3.2-3B-default/adapter_config.json
new file mode 100644
index 0000000..54469ed
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/ptuning/llama-3.2-3B-default/adapter_config.json
@@ -0,0 +1,17 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "encoder_dropout": 0.0,
+  "encoder_hidden_size": 3072,
+  "encoder_num_layers": 2,
+  "encoder_reparameterization_type": "MLP",
+  "inference_mode": false,
+  "num_attention_heads": 24,
+  "num_layers": 28,
+  "num_transformer_submodules": 1,
+  "num_virtual_tokens": 20,
+  "peft_type": "P_TUNING",
+  "revision": null,
+  "task_type": "CAUSAL_LM",
+  "token_dim": 3072
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/pvera/llama-3.2-3B-default/adapter_config.json b/method_comparison/MetaMathQA/experiments/pvera/llama-3.2-3B-default/adapter_config.json
new file mode 100644
index 0000000..4fd7ce5
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/pvera/llama-3.2-3B-default/adapter_config.json
@@ -0,0 +1,20 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "d_initial": 0.1,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "peft_type": "PVERA",
+  "projection_prng_key": 0,
+  "r": 256,
+  "revision": null,
+  "save_projection": true,
+  "target_modules": null,
+  "task_type": null,
+  "pvera_dropout": 0.0
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/pvera/llama-3.2-3B-default/training_params.json b/method_comparison/MetaMathQA/experiments/pvera/llama-3.2-3B-default/training_params.json
new file mode 100644
index 0000000..8bed6db
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/pvera/llama-3.2-3B-default/training_params.json
@@ -0,0 +1,6 @@
+{
+  "optimizer_kwargs": {
+    "lr": 3e-3
+  }
+}
+
diff --git a/method_comparison/MetaMathQA/experiments/pvera/llama-3.2-3B-rank64/adapter_config.json b/method_comparison/MetaMathQA/experiments/pvera/llama-3.2-3B-rank64/adapter_config.json
new file mode 100644
index 0000000..534a070
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/pvera/llama-3.2-3B-rank64/adapter_config.json
@@ -0,0 +1,20 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "d_initial": 0.1,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "peft_type": "PVERA",
+  "projection_prng_key": 0,
+  "r": 64,
+  "revision": null,
+  "save_projection": true,
+  "target_modules": null,
+  "task_type": null,
+  "pvera_dropout": 0.0
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/pvera/llama-3.2-3B-rank64/training_params.json b/method_comparison/MetaMathQA/experiments/pvera/llama-3.2-3B-rank64/training_params.json
new file mode 100644
index 0000000..21a6342
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/pvera/llama-3.2-3B-rank64/training_params.json
@@ -0,0 +1,5 @@
+{
+  "optimizer_kwargs": {
+    "lr": 3e-3
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/randlora/llama-3.2-3B-default/adapter_config.json b/method_comparison/MetaMathQA/experiments/randlora/llama-3.2-3B-default/adapter_config.json
new file mode 100644
index 0000000..3dbdfaa
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/randlora/llama-3.2-3B-default/adapter_config.json
@@ -0,0 +1,22 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "peft_type": "RANDLORA",
+  "projection_prng_key": 0,
+  "r": 32,
+  "randlora_alpha": 640,
+  "randlora_dropout": 0.0,
+  "revision": null,
+  "save_projection": true,
+  "sparse": false,
+  "target_modules": null,
+  "task_type": null,
+  "very_sparse": false
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/road/llama-3.2-3B-lr_0.001/adapter_config.json b/method_comparison/MetaMathQA/experiments/road/llama-3.2-3B-lr_0.001/adapter_config.json
new file mode 100644
index 0000000..d0f74c4
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/road/llama-3.2-3B-lr_0.001/adapter_config.json
@@ -0,0 +1,12 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "group_size": 64,
+  "inference_mode": false,
+  "init_weights": true,
+  "peft_type": "ROAD",
+  "revision": null,
+  "target_modules": null,
+  "task_type": null,
+  "variant": "road_2"
+}
diff --git a/method_comparison/MetaMathQA/experiments/road/llama-3.2-3B-lr_0.001/training_params.json b/method_comparison/MetaMathQA/experiments/road/llama-3.2-3B-lr_0.001/training_params.json
new file mode 100644
index 0000000..52d87e3
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/road/llama-3.2-3B-lr_0.001/training_params.json
@@ -0,0 +1,5 @@
+{
+  "optimizer_kwargs": {
+    "lr": 1e-3
+  }
+}
diff --git a/method_comparison/MetaMathQA/experiments/shira/llama-3.2-3B-lr_0.0003-random_seed_42/adapter_config.json b/method_comparison/MetaMathQA/experiments/shira/llama-3.2-3B-lr_0.0003-random_seed_42/adapter_config.json
new file mode 100644
index 0000000..0d4565e
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/shira/llama-3.2-3B-lr_0.0003-random_seed_42/adapter_config.json
@@ -0,0 +1,15 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_weights": true,
+  "mask_type": "random",
+  "modules_to_save": null,
+  "peft_type": "SHIRA",
+  "r": 32,
+  "random_seed": 42,
+  "revision": null,
+  "target_modules": null,
+  "task_type": null
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/shira/llama-3.2-3B-lr_0.0003-random_seed_42/training_params.json b/method_comparison/MetaMathQA/experiments/shira/llama-3.2-3B-lr_0.0003-random_seed_42/training_params.json
new file mode 100644
index 0000000..92f18b8
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/shira/llama-3.2-3B-lr_0.0003-random_seed_42/training_params.json
@@ -0,0 +1,6 @@
+{
+  "optimizer_kwargs": {
+    "lr": 3e-4
+  }
+}
+
diff --git a/method_comparison/MetaMathQA/experiments/tinylora/llama-3.2-3B-default/adapter_config.json b/method_comparison/MetaMathQA/experiments/tinylora/llama-3.2-3B-default/adapter_config.json
new file mode 100644
index 0000000..56ce209
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/tinylora/llama-3.2-3B-default/adapter_config.json
@@ -0,0 +1,21 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "peft_type": "TINYLORA",
+  "projection_seed": 42,
+  "r": 2,
+  "revision": null,
+  "save_projection": true,
+  "target_modules": null,
+  "task_type": null,
+  "tinylora_dropout": 0.0,
+  "u": 64,
+  "weight_tying": 0.0
+}
diff --git a/method_comparison/MetaMathQA/experiments/tinylora/llama-3.2-3B-default/training_params.json b/method_comparison/MetaMathQA/experiments/tinylora/llama-3.2-3B-default/training_params.json
new file mode 100644
index 0000000..52d87e3
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/tinylora/llama-3.2-3B-default/training_params.json
@@ -0,0 +1,5 @@
+{
+  "optimizer_kwargs": {
+    "lr": 1e-3
+  }
+}
diff --git a/method_comparison/MetaMathQA/experiments/tinylora/llama-3.2-3B-weight-tying/adapter_config.json b/method_comparison/MetaMathQA/experiments/tinylora/llama-3.2-3B-weight-tying/adapter_config.json
new file mode 100644
index 0000000..9332771
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/tinylora/llama-3.2-3B-weight-tying/adapter_config.json
@@ -0,0 +1,21 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "peft_type": "TINYLORA",
+  "projection_seed": 42,
+  "r": 2,
+  "revision": null,
+  "save_projection": true,
+  "target_modules": null,
+  "task_type": null,
+  "tinylora_dropout": 0.0,
+  "u": 64,
+  "weight_tying": 1.0
+}
diff --git a/method_comparison/MetaMathQA/experiments/tinylora/llama-3.2-3B-weight-tying/training_params.json b/method_comparison/MetaMathQA/experiments/tinylora/llama-3.2-3B-weight-tying/training_params.json
new file mode 100644
index 0000000..52d87e3
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/tinylora/llama-3.2-3B-weight-tying/training_params.json
@@ -0,0 +1,5 @@
+{
+  "optimizer_kwargs": {
+    "lr": 1e-3
+  }
+}
diff --git a/method_comparison/MetaMathQA/experiments/trainable_tokens/llama-3.2-3B-sos+eos/adapter_config.json b/method_comparison/MetaMathQA/experiments/trainable_tokens/llama-3.2-3B-sos+eos/adapter_config.json
new file mode 100644
index 0000000..bce0cd5
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/trainable_tokens/llama-3.2-3B-sos+eos/adapter_config.json
@@ -0,0 +1,7 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "peft_type": "TRAINABLE_TOKENS",
+  "token_indices": [128000, 128001],
+  "task_type": "CAUSAL_LM"
+}
diff --git a/method_comparison/MetaMathQA/experiments/trainable_tokens/llama-3.2-3B-sos+eos/training_params.json b/method_comparison/MetaMathQA/experiments/trainable_tokens/llama-3.2-3B-sos+eos/training_params.json
new file mode 100644
index 0000000..92e546e
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/trainable_tokens/llama-3.2-3B-sos+eos/training_params.json
@@ -0,0 +1,5 @@
+{
+  "optimizer_kwargs": {
+    "lr": 0.2
+  }
+}
diff --git a/method_comparison/MetaMathQA/experiments/unilora/llama-3.2-3B-default/adapter_config.json b/method_comparison/MetaMathQA/experiments/unilora/llama-3.2-3B-default/adapter_config.json
new file mode 100644
index 0000000..4276b4b
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/unilora/llama-3.2-3B-default/adapter_config.json
@@ -0,0 +1,24 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_theta_d_bound": 0.02,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "peft_type": "UNILORA",
+  "proj_seed": 42,
+  "r": 32,
+  "revision": null,
+  "target_modules": [
+    "q_proj",
+    "v_proj"
+  ],
+  "task_type": "CAUSAL_LM",
+  "theta_d_length": 256,
+  "unilora_dropout": 0.0
+}
diff --git a/method_comparison/MetaMathQA/experiments/vblora/llama-3.2-3B-default/adapter_config.json b/method_comparison/MetaMathQA/experiments/vblora/llama-3.2-3B-default/adapter_config.json
new file mode 100644
index 0000000..b6cbc59
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/vblora/llama-3.2-3B-default/adapter_config.json
@@ -0,0 +1,26 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_logits_std": 0.1,
+  "init_vector_bank_bound": 0.02,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "num_vectors": 256,
+  "peft_type": "VBLORA",
+  "r": 4,
+  "revision": null,
+  "save_only_topk_weights": false,
+  "target_modules": [
+    "v_proj",
+    "q_proj"
+  ],
+  "task_type": null,
+  "topk": 2,
+  "vblora_dropout": 0.0,
+  "vector_length": 256
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/vera/llama-3.2-3B-default/adapter_config.json b/method_comparison/MetaMathQA/experiments/vera/llama-3.2-3B-default/adapter_config.json
new file mode 100644
index 0000000..f4962c1
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/vera/llama-3.2-3B-default/adapter_config.json
@@ -0,0 +1,20 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "d_initial": 0.1,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "peft_type": "VERA",
+  "projection_prng_key": 0,
+  "r": 256,
+  "revision": null,
+  "save_projection": true,
+  "target_modules": null,
+  "task_type": null,
+  "vera_dropout": 0.0
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/experiments/vera/llama-3.2-3B-default/training_params.json b/method_comparison/MetaMathQA/experiments/vera/llama-3.2-3B-default/training_params.json
new file mode 100644
index 0000000..8a120ad
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/vera/llama-3.2-3B-default/training_params.json
@@ -0,0 +1,6 @@
+{
+  "optimizer_kwargs": {
+    "lr": 1e-3
+  }
+}
+
diff --git a/method_comparison/MetaMathQA/experiments/waveft/llama-3.2-3B-n_frequency-5000/adapter_config.json b/method_comparison/MetaMathQA/experiments/waveft/llama-3.2-3B-n_frequency-5000/adapter_config.json
new file mode 100644
index 0000000..6aad104
--- /dev/null
+++ b/method_comparison/MetaMathQA/experiments/waveft/llama-3.2-3B-n_frequency-5000/adapter_config.json
@@ -0,0 +1,26 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "n_frequency": 5000,
+  "n_frequency_pattern": {},
+  "peft_type": "WAVEFT",
+  "proportional_parameters": false,
+  "random_loc_seed": 777,
+  "revision": null,
+  "scaling": 25.0,
+  "target_modules": [
+    "q_proj",
+    "v_proj"
+  ],
+  "task_type": "CAUSAL_LM",
+  "use_idwt": true,
+  "wavelet_family": "db1"
+}
diff --git a/method_comparison/MetaMathQA/requirements.txt b/method_comparison/MetaMathQA/requirements.txt
new file mode 100644
index 0000000..ee25a1c
--- /dev/null
+++ b/method_comparison/MetaMathQA/requirements.txt
@@ -0,0 +1,4 @@
+bitsandbytes
+datasets
+numpy
+tqdm
diff --git a/method_comparison/MetaMathQA/results/.gitkeep b/method_comparison/MetaMathQA/results/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/method_comparison/MetaMathQA/results/adalora--llama-3.2-3B-rank32.json b/method_comparison/MetaMathQA/results/adalora--llama-3.2-3B-rank32.json
new file mode 100644
index 0000000..edfa5dc
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/adalora--llama-3.2-3B-rank32.json
@@ -0,0 +1,4080 @@
+{
+  "run_info": {
+    "created_at": "2026-01-09T17:02:52+00:00",
+    "total_time": 1339.9807203459786,
+    "experiment_name": "adalora/llama-3.2-3B-rank32",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "ADALORA",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 8,
+      "target_modules": [
+        "q_proj",
+        "v_proj"
+      ],
+      "exclude_modules": null,
+      "lora_alpha": 8,
+      "lora_dropout": 0.0,
+      "fan_in_fan_out": false,
+      "bias": "none",
+      "use_rslora": false,
+      "modules_to_save": null,
+      "init_lora_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "rank_pattern": {
+        "model.layers.0.self_attn.q_proj.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "model.layers.0.self_attn.v_proj.lora_E": [
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true
+        ],
+        "model.layers.1.self_attn.q_proj.lora_E": [
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false
+        ],
+        "model.layers.1.self_attn.v_proj.lora_E": [
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true
+        ],
+        "model.layers.2.self_attn.q_proj.lora_E": [
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false
+        ],
+        "model.layers.2.self_attn.v_proj.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true
+        ],
+        "model.layers.3.self_attn.q_proj.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "model.layers.3.self_attn.v_proj.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true
+        ],
+        "model.layers.4.self_attn.q_proj.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false
+        ],
+        "model.layers.4.self_attn.v_proj.lora_E": [
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true
+        ],
+        "model.layers.5.self_attn.q_proj.lora_E": [
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "model.layers.5.self_attn.v_proj.lora_E": [
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true
+        ],
+        "model.layers.6.self_attn.q_proj.lora_E": [
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false
+        ],
+        "model.layers.6.self_attn.v_proj.lora_E": [
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true
+        ],
+        "model.layers.7.self_attn.q_proj.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "model.layers.7.self_attn.v_proj.lora_E": [
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true
+        ],
+        "model.layers.8.self_attn.q_proj.lora_E": [
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true
+        ],
+        "model.layers.8.self_attn.v_proj.lora_E": [
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true
+        ],
+        "model.layers.9.self_attn.q_proj.lora_E": [
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false
+        ],
+        "model.layers.9.self_attn.v_proj.lora_E": [
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false
+        ],
+        "model.layers.10.self_attn.q_proj.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "model.layers.10.self_attn.v_proj.lora_E": [
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true
+        ],
+        "model.layers.11.self_attn.q_proj.lora_E": [
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false
+        ],
+        "model.layers.11.self_attn.v_proj.lora_E": [
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false
+        ],
+        "model.layers.12.self_attn.q_proj.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "model.layers.12.self_attn.v_proj.lora_E": [
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false
+        ],
+        "model.layers.13.self_attn.q_proj.lora_E": [
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false
+        ],
+        "model.layers.13.self_attn.v_proj.lora_E": [
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true
+        ],
+        "model.layers.14.self_attn.q_proj.lora_E": [
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true
+        ],
+        "model.layers.14.self_attn.v_proj.lora_E": [
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false
+        ],
+        "model.layers.15.self_attn.q_proj.lora_E": [
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true
+        ],
+        "model.layers.15.self_attn.v_proj.lora_E": [
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true
+        ],
+        "model.layers.16.self_attn.q_proj.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true
+        ],
+        "model.layers.16.self_attn.v_proj.lora_E": [
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false
+        ],
+        "model.layers.17.self_attn.q_proj.lora_E": [
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true
+        ],
+        "model.layers.17.self_attn.v_proj.lora_E": [
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true
+        ],
+        "model.layers.18.self_attn.q_proj.lora_E": [
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true
+        ],
+        "model.layers.18.self_attn.v_proj.lora_E": [
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true
+        ],
+        "model.layers.19.self_attn.q_proj.lora_E": [
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true
+        ],
+        "model.layers.19.self_attn.v_proj.lora_E": [
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true
+        ],
+        "model.layers.20.self_attn.q_proj.lora_E": [
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false
+        ],
+        "model.layers.20.self_attn.v_proj.lora_E": [
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true
+        ],
+        "model.layers.21.self_attn.q_proj.lora_E": [
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true
+        ],
+        "model.layers.21.self_attn.v_proj.lora_E": [
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "model.layers.22.self_attn.q_proj.lora_E": [
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true
+        ],
+        "model.layers.22.self_attn.v_proj.lora_E": [
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true
+        ],
+        "model.layers.23.self_attn.q_proj.lora_E": [
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true
+        ],
+        "model.layers.23.self_attn.v_proj.lora_E": [
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true
+        ],
+        "model.layers.24.self_attn.q_proj.lora_E": [
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true
+        ],
+        "model.layers.24.self_attn.v_proj.lora_E": [
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true
+        ],
+        "model.layers.25.self_attn.q_proj.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "model.layers.25.self_attn.v_proj.lora_E": [
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "model.layers.26.self_attn.q_proj.lora_E": [
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true
+        ],
+        "model.layers.26.self_attn.v_proj.lora_E": [
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false
+        ],
+        "model.layers.27.self_attn.q_proj.lora_E": [
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false
+        ],
+        "model.layers.27.self_attn.v_proj.lora_E": [
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true
+        ]
+      },
+      "alpha_pattern": {},
+      "megatron_config": null,
+      "megatron_core": "megatron.core",
+      "trainable_token_indices": null,
+      "loftq_config": {},
+      "eva_config": null,
+      "corda_config": null,
+      "use_dora": false,
+      "alora_invocation_tokens": null,
+      "use_qalora": false,
+      "qalora_group_size": 16,
+      "layer_replication": null,
+      "lora_bias": false,
+      "target_parameters": null,
+      "use_bdlora": null,
+      "arrow_config": null,
+      "ensure_weight_tying": false,
+      "target_r": 32,
+      "init_r": 64,
+      "tinit": 200,
+      "tfinal": 500,
+      "deltaT": 1,
+      "beta1": 0.85,
+      "beta2": 0.85,
+      "orth_reg_weight": 0.5,
+      "total_step": 5000
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 14915761654,
+    "accelerator_memory_max": 22796042240,
+    "accelerator_memory_reserved_99th": 20617101312,
+    "train_time": 1097.5522341161268,
+    "file_size": 35131056,
+    "num_trainable_params": 18353664,
+    "num_total_params": 3231103544,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.0,
+        "train loss": 1.3241328690052032,
+        "train samples": 1000,
+        "train time": 33.437529707327485,
+        "eval time": 12.192411294032354,
+        "tokens / sec": 6331.777552143872,
+        "mem allocated avg": 7294713141.248,
+        "mem reserved avg": 15068431384.576,
+        "elapsed time": 71.46285747201182
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.42,
+        "train loss": 1.0195916182994842,
+        "train samples": 2000,
+        "train time": 35.78730485920096,
+        "eval time": 12.20008662098553,
+        "tokens / sec": 5811.977203042275,
+        "mem allocated avg": 7287517972.48,
+        "mem reserved avg": 14679560683.52,
+        "elapsed time": 123.03286996803945
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.3,
+        "train loss": 0.788285866856575,
+        "train samples": 3000,
+        "train time": 36.553958278673235,
+        "eval time": 12.192845579993445,
+        "tokens / sec": 5865.329230982038,
+        "mem allocated avg": 7297823625.216,
+        "mem reserved avg": 14887958872.064,
+        "elapsed time": 175.27128310705302
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.34,
+        "train loss": 0.7407853524684906,
+        "train samples": 4000,
+        "train time": 36.186631593853235,
+        "eval time": 12.179883008997422,
+        "tokens / sec": 5757.264238857439,
+        "mem allocated avg": 7288626950.144,
+        "mem reserved avg": 14961325637.632,
+        "elapsed time": 227.3045465090545
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.32,
+        "train loss": 0.7283406076431275,
+        "train samples": 5000,
+        "train time": 35.77542787248967,
+        "eval time": 12.210806805000175,
+        "tokens / sec": 5829.084721034463,
+        "mem allocated avg": 7289293629.44,
+        "mem reserved avg": 14984788574.208,
+        "elapsed time": 278.867415188055
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.38,
+        "train loss": 0.7160038756132125,
+        "train samples": 6000,
+        "train time": 35.90073716780171,
+        "eval time": 12.185589247965254,
+        "tokens / sec": 5830.827345454697,
+        "mem allocated avg": 7291158284.288,
+        "mem reserved avg": 14897169563.648,
+        "elapsed time": 330.540843091032
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.34,
+        "train loss": 0.7057664946317673,
+        "train samples": 7000,
+        "train time": 35.91021893679863,
+        "eval time": 12.154321324953344,
+        "tokens / sec": 5829.95610158939,
+        "mem allocated avg": 7292672542.72,
+        "mem reserved avg": 15298061139.968,
+        "elapsed time": 382.3315215060138
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.34,
+        "train loss": 0.7058077181577682,
+        "train samples": 8000,
+        "train time": 35.90797309036134,
+        "eval time": 12.198829908971675,
+        "tokens / sec": 5784.119295103047,
+        "mem allocated avg": 7288192765.952,
+        "mem reserved avg": 14933509013.504,
+        "elapsed time": 434.1038082460291
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.36,
+        "train loss": 0.6997898343801499,
+        "train samples": 9000,
+        "train time": 36.599770584725775,
+        "eval time": 12.184865101007745,
+        "tokens / sec": 5872.932987446225,
+        "mem allocated avg": 7298940741.632,
+        "mem reserved avg": 15212841271.296,
+        "elapsed time": 486.43084904103307
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.36,
+        "train loss": 0.6983125779628754,
+        "train samples": 10000,
+        "train time": 35.72843996837037,
+        "eval time": 7.310388852027245,
+        "tokens / sec": 5764.791303016259,
+        "mem allocated avg": 7285925011.456,
+        "mem reserved avg": 14699911446.528,
+        "elapsed time": 533.0108368530055
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.32,
+        "train loss": 0.6912899543046951,
+        "train samples": 11000,
+        "train time": 36.1996374403825,
+        "eval time": 12.285541804973036,
+        "tokens / sec": 5853.124920075475,
+        "mem allocated avg": 7295115497.472,
+        "mem reserved avg": 15075444260.864,
+        "elapsed time": 585.0133225410245
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.36,
+        "train loss": 0.6850721148252488,
+        "train samples": 12000,
+        "train time": 35.86890918528661,
+        "eval time": 12.206184039998334,
+        "tokens / sec": 5819.2737036347135,
+        "mem allocated avg": 7291246731.264,
+        "mem reserved avg": 15016489123.84,
+        "elapsed time": 636.763230385026
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.34,
+        "train loss": 0.6939100304841995,
+        "train samples": 13000,
+        "train time": 36.13155907928012,
+        "eval time": 12.18468267400749,
+        "tokens / sec": 5837.030157963555,
+        "mem allocated avg": 7293795069.952,
+        "mem reserved avg": 14881256374.272,
+        "elapsed time": 688.5670087640174
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.36,
+        "train loss": 0.6824952847957612,
+        "train samples": 14000,
+        "train time": 35.909013247233815,
+        "eval time": 12.309029697033111,
+        "tokens / sec": 5841.151873371449,
+        "mem allocated avg": 7290872406.016,
+        "mem reserved avg": 14875896053.76,
+        "elapsed time": 740.3315773730283
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.32,
+        "train loss": 0.6794799867868423,
+        "train samples": 15000,
+        "train time": 36.30529697693419,
+        "eval time": 12.151031351007987,
+        "tokens / sec": 5968.908617871319,
+        "mem allocated avg": 7301860868.096,
+        "mem reserved avg": 15216507092.992,
+        "elapsed time": 792.3454526530113
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.3,
+        "train loss": 0.6966380437612534,
+        "train samples": 16000,
+        "train time": 35.68916123179952,
+        "eval time": 12.212951252993662,
+        "tokens / sec": 5726.472490418209,
+        "mem allocated avg": 7282899265.536,
+        "mem reserved avg": 14899249938.432,
+        "elapsed time": 843.872047640034
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.32,
+        "train loss": 0.6774853245019913,
+        "train samples": 17000,
+        "train time": 36.08229462581221,
+        "eval time": 12.197503683972172,
+        "tokens / sec": 5858.524303739224,
+        "mem allocated avg": 7294883461.12,
+        "mem reserved avg": 14887791099.904,
+        "elapsed time": 895.6108071450144
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.32,
+        "train loss": 0.6867766143083572,
+        "train samples": 18000,
+        "train time": 35.802349225094076,
+        "eval time": 12.20918653300032,
+        "tokens / sec": 5804.591165049559,
+        "mem allocated avg": 7287909275.648,
+        "mem reserved avg": 14847987154.944,
+        "elapsed time": 947.2645250619971
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.32,
+        "train loss": 0.6804986503124237,
+        "train samples": 19000,
+        "train time": 32.32421511563007,
+        "eval time": 12.151784093992319,
+        "tokens / sec": 6494.790337491783,
+        "mem allocated avg": 7071402708.992,
+        "mem reserved avg": 14653581164.544,
+        "elapsed time": 995.2198103830451
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.34,
+        "train loss": 0.6861251518726349,
+        "train samples": 20000,
+        "train time": 31.86748417984927,
+        "eval time": 12.234077127010096,
+        "tokens / sec": 6535.815592612781,
+        "mem allocated avg": 7067250501.632,
+        "mem reserved avg": 14337473249.28,
+        "elapsed time": 1042.8103677670006
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.38362395754359363,
+        "train loss": 0.6861251518726349,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.0754537582397461
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/adamss--llama-3.2-3B-rank32.json b/method_comparison/MetaMathQA/results/adamss--llama-3.2-3B-rank32.json
new file mode 100644
index 0000000..eb7f0a9
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/adamss--llama-3.2-3B-rank32.json
@@ -0,0 +1,363 @@
+{
+  "run_info": {
+    "created_at": "2026-04-14T13:52:52+00:00",
+    "total_time": 5544.705792816996,
+    "experiment_name": "adamss/llama-3.2-3B-rank32",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null,
+      "init_kv_cache_prefix": null
+    },
+    "peft_config": {
+      "task_type": "CAUSAL_LM",
+      "peft_type": "ADAMSS",
+      "auto_mapping": null,
+      "peft_version": "0.19.0",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 100,
+      "num_subspaces": 32,
+      "subspace_rank": 1,
+      "target_modules": [
+        "q_proj",
+        "v_proj"
+      ],
+      "init_weights": "orthogonal",
+      "modules_to_save": null,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "use_asa": false,
+      "asa_target_subspaces": 50,
+      "init_warmup": 50,
+      "final_warmup": 1000,
+      "mask_interval": 100,
+      "asa_importance_beta": 0.85,
+      "asa_uncertainty_beta": 0.85,
+      "asa_schedule_exponent": 3.0,
+      "use_dynamic_rank": false,
+      "svd_threshold": 0.1
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 13458967049,
+    "accelerator_memory_max": 20323500032,
+    "accelerator_memory_reserved_99th": 18486394880,
+    "train_time": 4596.08915475203,
+    "file_size": 70459192,
+    "num_trainable_params": 293888,
+    "num_total_params": 3213043712,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.0,
+        "train loss": 1.3170231812000275,
+        "train samples": 1000,
+        "train time": 164.87659186910605,
+        "eval time": 45.593037275990355,
+        "tokens / sec": 1284.1058733678926,
+        "mem allocated avg": 6859081226.24,
+        "mem reserved avg": 13558565830.656,
+        "elapsed time": 295.8943835730024
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.0,
+        "train loss": 1.1954840586185456,
+        "train samples": 2000,
+        "train time": 166.43435910790868,
+        "eval time": 44.427490632995614,
+        "tokens / sec": 1249.7119051309908,
+        "mem allocated avg": 6852174585.856,
+        "mem reserved avg": 13240302043.136,
+        "elapsed time": 509.59304542800237
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.24,
+        "train loss": 0.9188390662670135,
+        "train samples": 3000,
+        "train time": 165.89597663206223,
+        "eval time": 45.04990096799156,
+        "tokens / sec": 1292.3821562925316,
+        "mem allocated avg": 6861978892.288,
+        "mem reserved avg": 13438810062.848,
+        "elapsed time": 723.2884168320015
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.28,
+        "train loss": 0.8316707408428192,
+        "train samples": 4000,
+        "train time": 165.8942028221063,
+        "eval time": 44.705238544993335,
+        "tokens / sec": 1255.8365298840815,
+        "mem allocated avg": 6853364180.992,
+        "mem reserved avg": 13442173894.656,
+        "elapsed time": 936.7426501810114
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.34,
+        "train loss": 0.8031793196201324,
+        "train samples": 5000,
+        "train time": 166.34746922992053,
+        "eval time": 45.23661799800175,
+        "tokens / sec": 1253.628930848145,
+        "mem allocated avg": 6853527777.28,
+        "mem reserved avg": 13494325870.592,
+        "elapsed time": 1151.1076066460082
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.36,
+        "train loss": 0.7772162261009217,
+        "train samples": 6000,
+        "train time": 167.20215503200598,
+        "eval time": 45.08574113200302,
+        "tokens / sec": 1251.9635285796985,
+        "mem allocated avg": 6855708528.64,
+        "mem reserved avg": 13412318838.784,
+        "elapsed time": 1366.2412558400101
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.32,
+        "train loss": 0.7615521411895751,
+        "train samples": 7000,
+        "train time": 167.64521759089257,
+        "eval time": 45.147190629999386,
+        "tokens / sec": 1248.797925813145,
+        "mem allocated avg": 6856783118.336,
+        "mem reserved avg": 13761318486.016,
+        "elapsed time": 1581.863356398011
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.26,
+        "train loss": 0.7539848216772079,
+        "train samples": 8000,
+        "train time": 166.568618839985,
+        "eval time": 44.94827433799219,
+        "tokens / sec": 1246.9095406231604,
+        "mem allocated avg": 6852422844.416,
+        "mem reserved avg": 13454152826.88,
+        "elapsed time": 1796.2559075200115
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.38,
+        "train loss": 0.7444141312837601,
+        "train samples": 9000,
+        "train time": 166.63916836991848,
+        "eval time": 45.11883862000832,
+        "tokens / sec": 1289.9008204532192,
+        "mem allocated avg": 6863277742.08,
+        "mem reserved avg": 13692187967.488,
+        "elapsed time": 2010.7747859730007
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.34,
+        "train loss": 0.7402979242801666,
+        "train samples": 10000,
+        "train time": 167.3797131489846,
+        "eval time": 44.99307104799664,
+        "tokens / sec": 1230.53741773753,
+        "mem allocated avg": 6850039672.832,
+        "mem reserved avg": 13260275318.784,
+        "elapsed time": 2225.957470817011
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.3,
+        "train loss": 0.733423663854599,
+        "train samples": 11000,
+        "train time": 166.81764313385065,
+        "eval time": 45.51151215299615,
+        "tokens / sec": 1270.1354366335913,
+        "mem allocated avg": 6859437490.176,
+        "mem reserved avg": 13584763453.44,
+        "elapsed time": 2441.0304056930036
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.34,
+        "train loss": 0.7258533200025559,
+        "train samples": 12000,
+        "train time": 166.40352799696848,
+        "eval time": 45.112399252000614,
+        "tokens / sec": 1254.3664338883648,
+        "mem allocated avg": 6855105021.952,
+        "mem reserved avg": 13508292902.912,
+        "elapsed time": 2655.413832613005
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.28,
+        "train loss": 0.7344502800703049,
+        "train samples": 13000,
+        "train time": 167.75549283101282,
+        "eval time": 44.94758386199828,
+        "tokens / sec": 1257.1928134266784,
+        "mem allocated avg": 6858180347.904,
+        "mem reserved avg": 13389225000.96,
+        "elapsed time": 2870.820019774008
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.38,
+        "train loss": 0.7221226370334626,
+        "train samples": 14000,
+        "train time": 166.08321435720427,
+        "eval time": 45.384310558001744,
+        "tokens / sec": 1262.921125483995,
+        "mem allocated avg": 6854977140.736,
+        "mem reserved avg": 13403082981.376,
+        "elapsed time": 3085.1512631299993
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.36,
+        "train loss": 0.717872628569603,
+        "train samples": 15000,
+        "train time": 167.00246237695683,
+        "eval time": 45.29121434899571,
+        "tokens / sec": 1297.6036216212158,
+        "mem allocated avg": 6866502846.464,
+        "mem reserved avg": 13721313214.464,
+        "elapsed time": 3300.268306899001
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.36,
+        "train loss": 0.7365663632154464,
+        "train samples": 16000,
+        "train time": 167.08000112406444,
+        "eval time": 45.17965000300319,
+        "tokens / sec": 1223.2044447273126,
+        "mem allocated avg": 6847144562.688,
+        "mem reserved avg": 13416219541.504,
+        "elapsed time": 3515.3813499660027
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.44,
+        "train loss": 0.7155313398838044,
+        "train samples": 17000,
+        "train time": 167.22311856393935,
+        "eval time": 34.083910091008875,
+        "tokens / sec": 1264.1134899010594,
+        "mem allocated avg": 6859216920.576,
+        "mem reserved avg": 13421261094.912,
+        "elapsed time": 3719.3419795750087
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.28,
+        "train loss": 0.7270838797092438,
+        "train samples": 18000,
+        "train time": 167.84598211097182,
+        "eval time": 45.66838745299901,
+        "tokens / sec": 1238.1470046902914,
+        "mem allocated avg": 6853195386.88,
+        "mem reserved avg": 13379812982.784,
+        "elapsed time": 3935.711468303998
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.38,
+        "train loss": 0.7194143581390381,
+        "train samples": 19000,
+        "train time": 167.38743777899072,
+        "eval time": 45.20093128300505,
+        "tokens / sec": 1254.2100099363015,
+        "mem allocated avg": 6855967637.504,
+        "mem reserved avg": 13455318843.392,
+        "elapsed time": 4151.067342627008
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.38,
+        "train loss": 0.7252694470882416,
+        "train samples": 20000,
+        "train time": 167.5015109970991,
+        "eval time": 44.824427195999306,
+        "tokens / sec": 1243.4514695429054,
+        "mem allocated avg": 6852545486.848,
+        "mem reserved avg": 13145619824.64,
+        "elapsed time": 4366.147349254999
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.3366186504927976,
+        "train loss": 0.7252694470882416,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.1917562484741211
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "740312add88f781978c0658806c59bc2815b9866",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "5.5.4",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.0",
+      "peft-commit-hash": "6d5a6f4f2f902dbf13d21d2661d57c3c05df1dae",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/adaptionprompt--llama-3.2-3B-lr_0.0005.json b/method_comparison/MetaMathQA/results/adaptionprompt--llama-3.2-3B-lr_0.0005.json
new file mode 100644
index 0000000..2e673d8
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/adaptionprompt--llama-3.2-3B-lr_0.0005.json
@@ -0,0 +1,343 @@
+{
+  "run_info": {
+    "created_at": "2026-01-09T17:25:16+00:00",
+    "total_time": 1466.8854283409892,
+    "experiment_name": "adaptionprompt/llama-3.2-3B-lr_0.0005",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0005
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": "CAUSAL_LM",
+      "peft_type": "ADAPTION_PROMPT",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "target_modules": "self_attn",
+      "adapter_len": 100,
+      "adapter_layers": 28
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 14458868570,
+    "accelerator_memory_max": 22445817856,
+    "accelerator_memory_reserved_99th": 20222836736,
+    "train_time": 1180.5937879550038,
+    "file_size": 17210384,
+    "num_trainable_params": 8601628,
+    "num_total_params": 3221351452,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.0,
+        "train loss": 1.3200566630363464,
+        "train samples": 1000,
+        "train time": 34.53835600853199,
+        "eval time": 14.21398706396576,
+        "tokens / sec": 6129.967504756138,
+        "mem allocated avg": 6848584845.312,
+        "mem reserved avg": 14547960201.216,
+        "elapsed time": 71.65906680002809
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.08,
+        "train loss": 1.1533236474990844,
+        "train samples": 2000,
+        "train time": 34.522620833537076,
+        "eval time": 14.150563488015905,
+        "tokens / sec": 6024.890201787426,
+        "mem allocated avg": 6841784819.712,
+        "mem reserved avg": 14164156219.392,
+        "elapsed time": 123.70079839800019
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.2,
+        "train loss": 0.9019568083286286,
+        "train samples": 3000,
+        "train time": 35.55624677182641,
+        "eval time": 14.130223647051025,
+        "tokens / sec": 6029.910900772695,
+        "mem allocated avg": 6852599943.168,
+        "mem reserved avg": 14414614888.448,
+        "elapsed time": 176.709548267012
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.18,
+        "train loss": 0.8574914336204529,
+        "train samples": 4000,
+        "train time": 35.06597913411679,
+        "eval time": 14.383076103986241,
+        "tokens / sec": 5941.2571713220295,
+        "mem allocated avg": 6843962202.112,
+        "mem reserved avg": 14454611771.392,
+        "elapsed time": 229.6261993580265
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.22,
+        "train loss": 0.8493955388069153,
+        "train samples": 5000,
+        "train time": 35.032775730942376,
+        "eval time": 14.193959789990913,
+        "tokens / sec": 5952.6542116333285,
+        "mem allocated avg": 6843453933.568,
+        "mem reserved avg": 14489709707.264,
+        "elapsed time": 282.2174852700555
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.2,
+        "train loss": 0.8379271342754364,
+        "train samples": 6000,
+        "train time": 35.1143401027075,
+        "eval time": 14.287394939980004,
+        "tokens / sec": 5961.410619926743,
+        "mem allocated avg": 6845303027.712,
+        "mem reserved avg": 14413767639.04,
+        "elapsed time": 335.0856573909987
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.24,
+        "train loss": 0.8321145892143249,
+        "train samples": 7000,
+        "train time": 34.62294518906856,
+        "eval time": 14.048951104981825,
+        "tokens / sec": 6046.712631081982,
+        "mem allocated avg": 6846216781.824,
+        "mem reserved avg": 14785382973.44,
+        "elapsed time": 387.15798614604864
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.24,
+        "train loss": 0.836554151058197,
+        "train samples": 8000,
+        "train time": 34.390015198267065,
+        "eval time": 14.16389181703562,
+        "tokens / sec": 6039.427397824062,
+        "mem allocated avg": 6842828976.128,
+        "mem reserved avg": 14449343725.568,
+        "elapsed time": 439.18930962705053
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.2,
+        "train loss": 0.8322268238067627,
+        "train samples": 9000,
+        "train time": 35.45279946445953,
+        "eval time": 14.172650399035774,
+        "tokens / sec": 6062.934471944297,
+        "mem allocated avg": 6854121762.816,
+        "mem reserved avg": 14755116875.776,
+        "elapsed time": 492.21291138301603
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.24,
+        "train loss": 0.8304620375633239,
+        "train samples": 10000,
+        "train time": 35.034967973362654,
+        "eval time": 14.244871944014449,
+        "tokens / sec": 5878.897910127911,
+        "mem allocated avg": 6840198320.128,
+        "mem reserved avg": 14230501720.064,
+        "elapsed time": 544.8923244239995
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.22,
+        "train loss": 0.8325318789482117,
+        "train samples": 11000,
+        "train time": 35.15703216131078,
+        "eval time": 14.128618655027822,
+        "tokens / sec": 6026.703250371868,
+        "mem allocated avg": 6849819580.416,
+        "mem reserved avg": 14618449674.24,
+        "elapsed time": 597.5583866710076
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.16,
+        "train loss": 0.8273461208343506,
+        "train samples": 12000,
+        "train time": 35.226769833650906,
+        "eval time": 14.172337282972876,
+        "tokens / sec": 5925.3516852574585,
+        "mem allocated avg": 6844943210.496,
+        "mem reserved avg": 14524555984.896,
+        "elapsed time": 650.4424432980013
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.16,
+        "train loss": 0.832145271062851,
+        "train samples": 13000,
+        "train time": 34.82297695695888,
+        "eval time": 14.088282125012483,
+        "tokens / sec": 6056.374797039126,
+        "mem allocated avg": 6846756392.96,
+        "mem reserved avg": 14383988080.64,
+        "elapsed time": 702.644515115011
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.2,
+        "train loss": 0.8267167332172394,
+        "train samples": 14000,
+        "train time": 35.251085491792765,
+        "eval time": 14.197126877959818,
+        "tokens / sec": 5950.171379795793,
+        "mem allocated avg": 6845619677.184,
+        "mem reserved avg": 14408566702.08,
+        "elapsed time": 755.514794363
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.24,
+        "train loss": 0.8225111892223358,
+        "train samples": 15000,
+        "train time": 35.429980689892545,
+        "eval time": 14.131252312974539,
+        "tokens / sec": 6116.373641203281,
+        "mem allocated avg": 6856933664.768,
+        "mem reserved avg": 14748112388.096,
+        "elapsed time": 808.5010599610396
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.18,
+        "train loss": 0.8426167027950286,
+        "train samples": 16000,
+        "train time": 34.42210436682217,
+        "eval time": 14.11721703200601,
+        "tokens / sec": 5937.260483033845,
+        "mem allocated avg": 6838090446.848,
+        "mem reserved avg": 14423599087.616,
+        "elapsed time": 860.4732752880082
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.22,
+        "train loss": 0.8195950338840484,
+        "train samples": 17000,
+        "train time": 35.29558803292457,
+        "eval time": 14.072754080989398,
+        "tokens / sec": 5989.105488278345,
+        "mem allocated avg": 6848445681.664,
+        "mem reserved avg": 14423037050.88,
+        "elapsed time": 913.1631882850197
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.22,
+        "train loss": 0.8332238008975983,
+        "train samples": 18000,
+        "train time": 34.60890661936719,
+        "eval time": 14.16370828700019,
+        "tokens / sec": 6004.754853587451,
+        "mem allocated avg": 6843256502.272,
+        "mem reserved avg": 14372839620.608,
+        "elapsed time": 965.424148318998
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.2,
+        "train loss": 0.8247757973670959,
+        "train samples": 19000,
+        "train time": 34.65050247934414,
+        "eval time": 14.110966334003024,
+        "tokens / sec": 6058.7577373560125,
+        "mem allocated avg": 6846388692.992,
+        "mem reserved avg": 14453437366.272,
+        "elapsed time": 1017.51672834903
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.24,
+        "train loss": 0.8316655712127685,
+        "train samples": 20000,
+        "train time": 34.58433834684547,
+        "eval time": 14.152012452017516,
+        "tokens / sec": 6022.379202723645,
+        "mem allocated avg": 6842473314.304,
+        "mem reserved avg": 14115619733.504,
+        "elapsed time": 1069.6098215640523
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.21228203184230476,
+        "train loss": 0.8316655712127685,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": -0.9543380737304688
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/beft--llama-3.2-3B-target-v_proj.json b/method_comparison/MetaMathQA/results/beft--llama-3.2-3B-target-v_proj.json
new file mode 100644
index 0000000..a3f8d05
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/beft--llama-3.2-3B-target-v_proj.json
@@ -0,0 +1,348 @@
+{
+  "run_info": {
+    "created_at": "2026-05-27T17:05:39+00:00",
+    "total_time": 1164.475218601001,
+    "experiment_name": "beft/llama-3.2-3B-target-v_proj",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "use_gc": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null,
+      "init_kv_cache_prefix": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "BEFT",
+      "auto_mapping": null,
+      "peft_version": "0.19.2.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "target_modules": [
+        "v_proj"
+      ],
+      "modules_to_save": null,
+      "init_weights": true
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 13326048716,
+    "accelerator_memory_max": 20174602240,
+    "accelerator_memory_reserved_99th": 18364760064,
+    "train_time": 895.6792339479998,
+    "file_size": 118192,
+    "num_trainable_params": 28672,
+    "num_total_params": 3212778496,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.0,
+        "train loss": 1.2536958937644958,
+        "train samples": 1000,
+        "train time": 25.995308880001176,
+        "eval time": 11.279193141999713,
+        "tokens / sec": 8144.507956313632,
+        "mem allocated avg": 6780321925.12,
+        "mem reserved avg": 13421118488.576,
+        "elapsed time": 61.48009839899896
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.24,
+        "train loss": 0.9777627243995667,
+        "train samples": 2000,
+        "train time": 25.780909876006262,
+        "eval time": 11.061198373001389,
+        "tokens / sec": 8067.791284340064,
+        "mem allocated avg": 6773625614.336,
+        "mem reserved avg": 13099566366.72,
+        "elapsed time": 101.17452364900055
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.46,
+        "train loss": 0.8528003213405609,
+        "train samples": 3000,
+        "train time": 26.55431071399107,
+        "eval time": 11.05525916499937,
+        "tokens / sec": 8074.056310828482,
+        "mem allocated avg": 6783347279.872,
+        "mem reserved avg": 13318257377.28,
+        "elapsed time": 141.63149280499965
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.3,
+        "train loss": 0.809947411775589,
+        "train samples": 4000,
+        "train time": 26.26542209602667,
+        "eval time": 11.06809749599961,
+        "tokens / sec": 7931.949436727928,
+        "mem allocated avg": 6774604892.16,
+        "mem reserved avg": 13324137791.488,
+        "elapsed time": 181.8820559550004
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.32,
+        "train loss": 0.7861457334756852,
+        "train samples": 5000,
+        "train time": 26.317507632986235,
+        "eval time": 11.035170441000446,
+        "tokens / sec": 7923.926646405509,
+        "mem allocated avg": 6774791225.344,
+        "mem reserved avg": 13359990702.08,
+        "elapsed time": 222.1126937299996
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.28,
+        "train loss": 0.7697241091728211,
+        "train samples": 6000,
+        "train time": 26.55908623099276,
+        "eval time": 11.054187975998502,
+        "tokens / sec": 7881.709414976937,
+        "mem allocated avg": 6777222809.6,
+        "mem reserved avg": 13278612815.872,
+        "elapsed time": 262.6382690669998
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.26,
+        "train loss": 0.7580352199077606,
+        "train samples": 7000,
+        "train time": 26.747784329987553,
+        "eval time": 11.021172044000195,
+        "tokens / sec": 7827.003441376163,
+        "mem allocated avg": 6778111371.264,
+        "mem reserved avg": 13628283551.744,
+        "elapsed time": 303.3206812520002
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.34,
+        "train loss": 0.7508488984107972,
+        "train samples": 8000,
+        "train time": 26.545016925963864,
+        "eval time": 11.080554445999951,
+        "tokens / sec": 7824.293372246868,
+        "mem allocated avg": 6773797535.744,
+        "mem reserved avg": 13307318632.448,
+        "elapsed time": 343.8978338319994
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.34,
+        "train loss": 0.7441560583114624,
+        "train samples": 9000,
+        "train time": 27.327815797998483,
+        "eval time": 11.055995652999627,
+        "tokens / sec": 7865.538965457423,
+        "mem allocated avg": 6784505901.056,
+        "mem reserved avg": 13558280617.984,
+        "elapsed time": 385.14220218899936
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.3,
+        "train loss": 0.7427490262985229,
+        "train samples": 10000,
+        "train time": 26.416417789998377,
+        "eval time": 11.091206763001537,
+        "tokens / sec": 7796.931500605732,
+        "mem allocated avg": 6771203348.48,
+        "mem reserved avg": 13125269061.632,
+        "elapsed time": 425.5365456790005
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.26,
+        "train loss": 0.7366866612434387,
+        "train samples": 11000,
+        "train time": 27.10851580999406,
+        "eval time": 11.050364470000204,
+        "tokens / sec": 7816.031002401323,
+        "mem allocated avg": 6780755542.016,
+        "mem reserved avg": 13451804016.64,
+        "elapsed time": 466.5525102729989
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.4,
+        "train loss": 0.7303342999219894,
+        "train samples": 12000,
+        "train time": 26.899115040016113,
+        "eval time": 11.087409264999224,
+        "tokens / sec": 7759.772010695671,
+        "mem allocated avg": 6776335720.448,
+        "mem reserved avg": 13375073419.264,
+        "elapsed time": 507.4421382820001
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.36,
+        "train loss": 0.7387652082443237,
+        "train samples": 13000,
+        "train time": 26.94703685899003,
+        "eval time": 11.049139168000693,
+        "tokens / sec": 7826.500594615081,
+        "mem allocated avg": 6779590395.904,
+        "mem reserved avg": 13257020538.88,
+        "elapsed time": 548.2433796669993
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.36,
+        "train loss": 0.7276337064504623,
+        "train samples": 14000,
+        "train time": 26.94882840199716,
+        "eval time": 10.589796242000375,
+        "tokens / sec": 7783.269716632859,
+        "mem allocated avg": 6776255127.552,
+        "mem reserved avg": 13281758543.872,
+        "elapsed time": 588.7085180619997
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.28,
+        "train loss": 0.7233721593618393,
+        "train samples": 15000,
+        "train time": 27.595731332001378,
+        "eval time": 9.353614206000202,
+        "tokens / sec": 7852.772495603349,
+        "mem allocated avg": 6787800502.272,
+        "mem reserved avg": 13584134307.84,
+        "elapsed time": 628.6007220949996
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.28,
+        "train loss": 0.7426576368808746,
+        "train samples": 16000,
+        "train time": 26.120023386005414,
+        "eval time": 11.07476948799922,
+        "tokens / sec": 7824.380437174454,
+        "mem allocated avg": 6768310173.696,
+        "mem reserved avg": 13282731622.4,
+        "elapsed time": 668.7208018139991
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.36,
+        "train loss": 0.7218096262216568,
+        "train samples": 17000,
+        "train time": 26.7786224240117,
+        "eval time": 11.070321331999367,
+        "tokens / sec": 7893.946023543501,
+        "mem allocated avg": 6780493502.464,
+        "mem reserved avg": 13286196117.504,
+        "elapsed time": 709.3163593569989
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.3,
+        "train loss": 0.7325530879497528,
+        "train samples": 18000,
+        "train time": 27.066992443002164,
+        "eval time": 11.09822626499954,
+        "tokens / sec": 7677.912514204318,
+        "mem allocated avg": 6774668625.92,
+        "mem reserved avg": 13242130759.68,
+        "elapsed time": 750.4343246320004
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.32,
+        "train loss": 0.726402741074562,
+        "train samples": 19000,
+        "train time": 27.221641966965763,
+        "eval time": 6.558379473000969,
+        "tokens / sec": 7712.209287550213,
+        "mem allocated avg": 6777282058.24,
+        "mem reserved avg": 13315707240.448,
+        "elapsed time": 787.0632161579997
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.3,
+        "train loss": 0.732575830578804,
+        "train samples": 20000,
+        "train time": 26.564427542021804,
+        "eval time": 11.065521769000043,
+        "tokens / sec": 7840.5604513978515,
+        "mem allocated avg": 6773862078.464,
+        "mem reserved avg": 13023582355.456,
+        "elapsed time": 827.522590474
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.3290371493555724,
+        "train loss": 0.732575830578804,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": -0.029061317443847656
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "740312add88f781978c0658806c59bc2815b9866",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "5.5.4",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.2.dev0",
+      "peft-commit-hash": "51bd32da394265b5ff438123ebef37be35bd2c2d",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/boft--llama-3.2-3B-default.json b/method_comparison/MetaMathQA/results/boft--llama-3.2-3B-default.json
new file mode 100644
index 0000000..913c12e
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/boft--llama-3.2-3B-default.json
@@ -0,0 +1,356 @@
+{
+  "run_info": {
+    "created_at": "2026-01-09T17:49:47+00:00",
+    "total_time": 10059.440659368003,
+    "experiment_name": "boft/llama-3.2-3B-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "BOFT",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "boft_block_size": 4,
+      "boft_block_num": 0,
+      "boft_n_butterfly_factor": 1,
+      "target_modules": [
+        "v_proj",
+        "q_proj"
+      ],
+      "exclude_modules": null,
+      "boft_dropout": 0.0,
+      "fan_in_fan_out": false,
+      "bias": "none",
+      "modules_to_save": null,
+      "init_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 17188165936,
+    "accelerator_memory_max": 24410849280,
+    "accelerator_memory_reserved_99th": 22345154560,
+    "train_time": 7190.453845723998,
+    "file_size": 3225360,
+    "num_trainable_params": 802816,
+    "num_total_params": 3213552640,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.0,
+        "train loss": 1.2914534993171691,
+        "train samples": 1000,
+        "train time": 168.16101133066695,
+        "eval time": 142.30593162897276,
+        "tokens / sec": 1259.025491846513,
+        "mem allocated avg": 6795307169.792,
+        "mem reserved avg": 17261339344.896,
+        "elapsed time": 344.37489816197194
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.12,
+        "train loss": 1.065816521883011,
+        "train samples": 2000,
+        "train time": 169.6081039829878,
+        "eval time": 143.82841559901135,
+        "tokens / sec": 1226.3270157236266,
+        "mem allocated avg": 6787530438.656,
+        "mem reserved avg": 16960280592.384,
+        "elapsed time": 662.5959406199981
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.42,
+        "train loss": 0.8761289038658142,
+        "train samples": 3000,
+        "train time": 170.50346154812723,
+        "eval time": 143.55063587299082,
+        "tokens / sec": 1257.4583416271698,
+        "mem allocated avg": 6797964732.416,
+        "mem reserved avg": 17119546703.872,
+        "elapsed time": 981.3382467220072
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.44,
+        "train loss": 0.8187025270462036,
+        "train samples": 4000,
+        "train time": 170.603982186527,
+        "eval time": 143.48508089897223,
+        "tokens / sec": 1221.1672748190563,
+        "mem allocated avg": 6789360863.232,
+        "mem reserved avg": 17173468676.096,
+        "elapsed time": 1300.2320007149829
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.38,
+        "train loss": 0.7968714184761048,
+        "train samples": 5000,
+        "train time": 170.08946738566738,
+        "eval time": 143.52085828600684,
+        "tokens / sec": 1226.0488741913275,
+        "mem allocated avg": 6788928741.376,
+        "mem reserved avg": 17237641527.296,
+        "elapsed time": 1618.561195612012
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.42,
+        "train loss": 0.7768479048013687,
+        "train samples": 6000,
+        "train time": 171.03791188867763,
+        "eval time": 142.4387985090143,
+        "tokens / sec": 1223.8865505809376,
+        "mem allocated avg": 6790983270.4,
+        "mem reserved avg": 17204464582.656,
+        "elapsed time": 1936.8438452039845
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.34,
+        "train loss": 0.7638826340436935,
+        "train samples": 7000,
+        "train time": 169.5759706167737,
+        "eval time": 142.81106396700488,
+        "tokens / sec": 1234.5793996551745,
+        "mem allocated avg": 6792170039.296,
+        "mem reserved avg": 17521872732.16,
+        "elapsed time": 2253.9779722079984
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.3,
+        "train loss": 0.7574314765930176,
+        "train samples": 8000,
+        "train time": 169.80084089771844,
+        "eval time": 142.94605548703112,
+        "tokens / sec": 1223.1741545090943,
+        "mem allocated avg": 6788512305.152,
+        "mem reserved avg": 17193743941.632,
+        "elapsed time": 2571.564919157012
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.4,
+        "train loss": 0.747995015501976,
+        "train samples": 9000,
+        "train time": 169.89184381318046,
+        "eval time": 142.61838847299805,
+        "tokens / sec": 1265.2049396577568,
+        "mem allocated avg": 6799572060.16,
+        "mem reserved avg": 17437013573.632,
+        "elapsed time": 2888.81089515402
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.3,
+        "train loss": 0.7451818664073944,
+        "train samples": 10000,
+        "train time": 169.05202275590273,
+        "eval time": 142.17101406800793,
+        "tokens / sec": 1218.3645995020095,
+        "mem allocated avg": 6785213417.472,
+        "mem reserved avg": 17006149500.928,
+        "elapsed time": 3204.817744602973
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.26,
+        "train loss": 0.7368416948318481,
+        "train samples": 11000,
+        "train time": 169.79861720540794,
+        "eval time": 142.90656082698843,
+        "tokens / sec": 1247.837017092338,
+        "mem allocated avg": 6795389593.6,
+        "mem reserved avg": 17333305212.928,
+        "elapsed time": 3522.2434823570075
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.42,
+        "train loss": 0.7283624488115311,
+        "train samples": 12000,
+        "train time": 169.40914075018372,
+        "eval time": 142.4628674259875,
+        "tokens / sec": 1232.1117920537804,
+        "mem allocated avg": 6790662739.968,
+        "mem reserved avg": 17229924007.936,
+        "elapsed time": 3838.9266921749804
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.4,
+        "train loss": 0.7360379147529602,
+        "train samples": 13000,
+        "train time": 169.2894103731378,
+        "eval time": 142.70766545902006,
+        "tokens / sec": 1245.8014918661738,
+        "mem allocated avg": 6792828252.16,
+        "mem reserved avg": 17116644245.504,
+        "elapsed time": 4155.603474072996
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.38,
+        "train loss": 0.7245079389810563,
+        "train samples": 14000,
+        "train time": 169.62816236459184,
+        "eval time": 142.80769011599477,
+        "tokens / sec": 1236.528162989657,
+        "mem allocated avg": 6790204116.992,
+        "mem reserved avg": 17182729699.328,
+        "elapsed time": 4472.8496758749825
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.32,
+        "train loss": 0.7198032699823379,
+        "train samples": 15000,
+        "train time": 169.99743940570625,
+        "eval time": 143.21545482298825,
+        "tokens / sec": 1274.742729993885,
+        "mem allocated avg": 6802659770.368,
+        "mem reserved avg": 17454201831.424,
+        "elapsed time": 4790.820539581007
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.36,
+        "train loss": 0.7386080088615418,
+        "train samples": 16000,
+        "train time": 169.4405590199167,
+        "eval time": 142.85203308903147,
+        "tokens / sec": 1206.1633954829977,
+        "mem allocated avg": 6782729986.048,
+        "mem reserved avg": 17107366445.056,
+        "elapsed time": 5107.90697863797
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.4,
+        "train loss": 0.7167673094272613,
+        "train samples": 17000,
+        "train time": 169.4217613734072,
+        "eval time": 142.6639407540206,
+        "tokens / sec": 1247.7086667402577,
+        "mem allocated avg": 6793673689.088,
+        "mem reserved avg": 17128346353.664,
+        "elapsed time": 5424.600868158974
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.36,
+        "train loss": 0.7279775400161743,
+        "train samples": 18000,
+        "train time": 169.55897833802737,
+        "eval time": 142.51284795097308,
+        "tokens / sec": 1225.6384299845254,
+        "mem allocated avg": 6789383653.376,
+        "mem reserved avg": 17117466329.088,
+        "elapsed time": 5741.48882275197
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.4,
+        "train loss": 0.7207833558321,
+        "train samples": 19000,
+        "train time": 169.6458221563953,
+        "eval time": 142.71257099701324,
+        "tokens / sec": 1237.513528664789,
+        "mem allocated avg": 6791604719.616,
+        "mem reserved avg": 17139536756.736,
+        "elapsed time": 6058.54882254597
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.36,
+        "train loss": 0.7267992464303971,
+        "train samples": 20000,
+        "train time": 169.51394822495058,
+        "eval time": 142.66391144797672,
+        "tokens / sec": 1228.6894511099795,
+        "mem allocated avg": 6788474263.552,
+        "mem reserved avg": 16838276677.632,
+        "elapsed time": 6375.395246869011
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.36239575435936316,
+        "train loss": 0.7267992464303971,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.3084230422973633
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/c3a--llama-3.2-3B-default.json b/method_comparison/MetaMathQA/results/c3a--llama-3.2-3B-default.json
new file mode 100644
index 0000000..2072a27
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/c3a--llama-3.2-3B-default.json
@@ -0,0 +1,352 @@
+{
+  "run_info": {
+    "created_at": "2026-01-09T21:25:18+00:00",
+    "total_time": 1366.5376071679639,
+    "experiment_name": "c3a/llama-3.2-3B-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.3,
+        "weight_decay": 1e-05
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "C3A",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "block_size": 64,
+      "target_modules": [
+        "v_proj",
+        "q_proj"
+      ],
+      "bias": "none",
+      "modules_to_save": null,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "block_size_pattern": {},
+      "init_weights": false
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 14377058251,
+    "accelerator_memory_max": 22166896640,
+    "accelerator_memory_reserved_99th": 20061356032,
+    "train_time": 1153.291345822101,
+    "file_size": 22027512,
+    "num_trainable_params": 5505024,
+    "num_total_params": 3218254848,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.38,
+        "train loss": 0.8909596583843231,
+        "train samples": 1000,
+        "train time": 37.80949870531913,
+        "eval time": 11.432839135988615,
+        "tokens / sec": 5599.624624756394,
+        "mem allocated avg": 6869184182.272,
+        "mem reserved avg": 14482872991.744,
+        "elapsed time": 72.47078875597799
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.42,
+        "train loss": 0.7013351047039031,
+        "train samples": 2000,
+        "train time": 37.42838709271746,
+        "eval time": 8.331702384981327,
+        "tokens / sec": 5557.1456895739475,
+        "mem allocated avg": 6862181789.696,
+        "mem reserved avg": 14091510874.112,
+        "elapsed time": 121.3354702090146
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.46,
+        "train loss": 0.674084732890129,
+        "train samples": 3000,
+        "train time": 38.329594842216466,
+        "eval time": 9.41572032001568,
+        "tokens / sec": 5593.615087312568,
+        "mem allocated avg": 6872815554.56,
+        "mem reserved avg": 14353973641.216,
+        "elapsed time": 172.14090229501016
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.44,
+        "train loss": 0.6545811468362808,
+        "train samples": 4000,
+        "train time": 37.05278595397249,
+        "eval time": 13.860594167024828,
+        "tokens / sec": 5622.681119276645,
+        "mem allocated avg": 6864588425.216,
+        "mem reserved avg": 14391965646.848,
+        "elapsed time": 226.19000285398215
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.38,
+        "train loss": 0.6509714391231537,
+        "train samples": 5000,
+        "train time": 36.79460979660507,
+        "eval time": 8.696108918986283,
+        "tokens / sec": 5667.62363163425,
+        "mem allocated avg": 6863943450.624,
+        "mem reserved avg": 14405840404.48,
+        "elapsed time": 274.7266224689665
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.52,
+        "train loss": 0.6443188463449478,
+        "train samples": 6000,
+        "train time": 37.157257698476315,
+        "eval time": 9.571486864006147,
+        "tokens / sec": 5633.650408183485,
+        "mem allocated avg": 6865824692.224,
+        "mem reserved avg": 14339352297.472,
+        "elapsed time": 324.5449085899745
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.46,
+        "train loss": 0.6351410290002822,
+        "train samples": 7000,
+        "train time": 37.588308651640546,
+        "eval time": 13.673957422957756,
+        "tokens / sec": 5569.6839658376775,
+        "mem allocated avg": 6866604124.16,
+        "mem reserved avg": 14722149646.336,
+        "elapsed time": 378.88215018698247
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.42,
+        "train loss": 0.6367183820009231,
+        "train samples": 8000,
+        "train time": 37.49864329502452,
+        "eval time": 9.148618383973371,
+        "tokens / sec": 5538.760385700621,
+        "mem allocated avg": 6862256517.12,
+        "mem reserved avg": 14371757490.176,
+        "elapsed time": 428.6968064419925
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.4,
+        "train loss": 0.6258963789939881,
+        "train samples": 9000,
+        "train time": 38.2491970359697,
+        "eval time": 13.646375201002229,
+        "tokens / sec": 5619.673526685071,
+        "mem allocated avg": 6874371139.584,
+        "mem reserved avg": 14650997473.28,
+        "elapsed time": 483.6756669579772
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.48,
+        "train loss": 0.6206584950685501,
+        "train samples": 10000,
+        "train time": 37.62900273769628,
+        "eval time": 13.673765863000881,
+        "tokens / sec": 5473.623668311165,
+        "mem allocated avg": 6859448377.344,
+        "mem reserved avg": 14140047360.0,
+        "elapsed time": 538.0801370120025
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.5,
+        "train loss": 0.6105827242136002,
+        "train samples": 11000,
+        "train time": 37.365518155740574,
+        "eval time": 9.94396861596033,
+        "tokens / sec": 5670.495431560023,
+        "mem allocated avg": 6870005147.648,
+        "mem reserved avg": 14540318179.328,
+        "elapsed time": 588.4858504809672
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.48,
+        "train loss": 0.5981686524152756,
+        "train samples": 12000,
+        "train time": 36.890319129568525,
+        "eval time": 9.116078838997055,
+        "tokens / sec": 5658.151106442905,
+        "mem allocated avg": 6865474818.048,
+        "mem reserved avg": 14431375327.232,
+        "elapsed time": 637.5967296099989
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.58,
+        "train loss": 0.6065964109897614,
+        "train samples": 13000,
+        "train time": 36.91873880266212,
+        "eval time": 13.868325658957474,
+        "tokens / sec": 5712.573257914012,
+        "mem allocated avg": 6867266957.312,
+        "mem reserved avg": 14327809572.864,
+        "elapsed time": 691.4201774260146
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.54,
+        "train loss": 0.5876260681152343,
+        "train samples": 14000,
+        "train time": 37.31881154741859,
+        "eval time": 13.723029766988475,
+        "tokens / sec": 5620.4898093682405,
+        "mem allocated avg": 6864456710.144,
+        "mem reserved avg": 14320821862.4,
+        "elapsed time": 745.5659840449807
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.52,
+        "train loss": 0.5839207136631012,
+        "train samples": 15000,
+        "train time": 38.572791439597495,
+        "eval time": 8.601323624025099,
+        "tokens / sec": 5618.027420684421,
+        "mem allocated avg": 6877443866.624,
+        "mem reserved avg": 14659335749.632,
+        "elapsed time": 795.8486898440169
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.56,
+        "train loss": 0.5916516542434692,
+        "train samples": 16000,
+        "train time": 36.93544478120748,
+        "eval time": 8.182845938019454,
+        "tokens / sec": 5533.248650737345,
+        "mem allocated avg": 6857094844.416,
+        "mem reserved avg": 14323103563.776,
+        "elapsed time": 844.0624020369723
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.56,
+        "train loss": 0.5781249686479568,
+        "train samples": 17000,
+        "train time": 37.122223554353695,
+        "eval time": 9.616572241007816,
+        "tokens / sec": 5694.405662163205,
+        "mem allocated avg": 6869011593.216,
+        "mem reserved avg": 14312148041.728,
+        "elapsed time": 893.7695867909933
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.56,
+        "train loss": 0.5846204442977905,
+        "train samples": 18000,
+        "train time": 37.07799867092399,
+        "eval time": 8.460158887959551,
+        "tokens / sec": 5604.887195893012,
+        "mem allocated avg": 6863795603.456,
+        "mem reserved avg": 14295052058.624,
+        "elapsed time": 942.4601713569718
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.52,
+        "train loss": 0.5748073060512543,
+        "train samples": 19000,
+        "train time": 37.64343991095666,
+        "eval time": 8.636093506007455,
+        "tokens / sec": 5577.040793737192,
+        "mem allocated avg": 6865605898.24,
+        "mem reserved avg": 14353235443.712,
+        "elapsed time": 991.785048523976
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.5,
+        "train loss": 0.5811544748544692,
+        "train samples": 20000,
+        "train time": 37.4456382485223,
+        "eval time": 8.431857075018343,
+        "tokens / sec": 5562.1965532452705,
+        "mem allocated avg": 6862668220.416,
+        "mem reserved avg": 14027497406.464,
+        "elapsed time": 1040.7068556279992
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.5026535253980288,
+        "train loss": 0.5811544748544692,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.4295167922973633
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/delora--llama-3.2-3B-rank32.json b/method_comparison/MetaMathQA/results/delora--llama-3.2-3B-rank32.json
new file mode 100644
index 0000000..5320f2e
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/delora--llama-3.2-3B-rank32.json
@@ -0,0 +1,355 @@
+{
+  "run_info": {
+    "created_at": "2026-01-09T21:48:09+00:00",
+    "total_time": 1277.7959856730304,
+    "experiment_name": "delora/llama-3.2-3B-rank32",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.001
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": "CAUSAL_LM",
+      "peft_type": "DELORA",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 32,
+      "delora_lambda": 15,
+      "module_dropout": 0.0,
+      "target_modules": [
+        "v_proj",
+        "q_proj"
+      ],
+      "exclude_modules": null,
+      "bias": "none",
+      "init_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "rank_pattern": {},
+      "lambda_pattern": {},
+      "modules_to_save": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 14449004406,
+    "accelerator_memory_max": 22353543168,
+    "accelerator_memory_reserved_99th": 20126367744,
+    "train_time": 1058.4298028770136,
+    "file_size": 37417520,
+    "num_trainable_params": 9175096,
+    "num_total_params": 3221924920,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.36,
+        "train loss": 0.7511726866960525,
+        "train samples": 1000,
+        "train time": 33.47864836757071,
+        "eval time": 13.131931535026524,
+        "tokens / sec": 6324.000828094447,
+        "mem allocated avg": 6927743098.88,
+        "mem reserved avg": 14590045847.552,
+        "elapsed time": 69.13025180797558
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.46,
+        "train loss": 0.7057771706581115,
+        "train samples": 2000,
+        "train time": 33.688454272574745,
+        "eval time": 13.079983315023128,
+        "tokens / sec": 6174.073714308867,
+        "mem allocated avg": 6921407948.8,
+        "mem reserved avg": 14192392273.92,
+        "elapsed time": 119.17276985396165
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.38,
+        "train loss": 0.6696414754390717,
+        "train samples": 3000,
+        "train time": 33.589053718489595,
+        "eval time": 11.759635296999477,
+        "tokens / sec": 6383.061630640097,
+        "mem allocated avg": 6930950647.808,
+        "mem reserved avg": 14421644541.952,
+        "elapsed time": 167.67709576297784
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.36,
+        "train loss": 0.6491379799842835,
+        "train samples": 4000,
+        "train time": 33.53858558466891,
+        "eval time": 9.152838472975418,
+        "tokens / sec": 6211.830235775778,
+        "mem allocated avg": 6922103914.496,
+        "mem reserved avg": 14461423321.088,
+        "elapsed time": 213.7067174440017
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.36,
+        "train loss": 0.6447645363807678,
+        "train samples": 5000,
+        "train time": 33.239838396781124,
+        "eval time": 13.123246687988285,
+        "tokens / sec": 6273.736878943261,
+        "mem allocated avg": 6922382727.168,
+        "mem reserved avg": 14487830659.072,
+        "elapsed time": 263.2440371370176
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.46,
+        "train loss": 0.6379029039144516,
+        "train samples": 6000,
+        "train time": 33.83518080448266,
+        "eval time": 9.2000446600141,
+        "tokens / sec": 6186.78532293425,
+        "mem allocated avg": 6924438607.872,
+        "mem reserved avg": 14402577235.968,
+        "elapsed time": 309.58903181599453
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.5,
+        "train loss": 0.6294291808605194,
+        "train samples": 7000,
+        "train time": 33.638763133611064,
+        "eval time": 13.089110154949594,
+        "tokens / sec": 6223.623596636268,
+        "mem allocated avg": 6925751805.952,
+        "mem reserved avg": 14803384926.208,
+        "elapsed time": 359.6268992089899
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.42,
+        "train loss": 0.6335482016801834,
+        "train samples": 8000,
+        "train time": 33.628849623783026,
+        "eval time": 9.815332075988408,
+        "tokens / sec": 6176.125627952288,
+        "mem allocated avg": 6921476399.104,
+        "mem reserved avg": 14434068070.4,
+        "elapsed time": 406.38412045896985
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.42,
+        "train loss": 0.6242709509134292,
+        "train samples": 9000,
+        "train time": 33.97552239638753,
+        "eval time": 13.092339784023352,
+        "tokens / sec": 6326.55467345675,
+        "mem allocated avg": 6932143722.496,
+        "mem reserved avg": 14720891355.136,
+        "elapsed time": 456.67317382100737
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.46,
+        "train loss": 0.6215527185201645,
+        "train samples": 10000,
+        "train time": 33.24377211777028,
+        "eval time": 13.087968986015767,
+        "tokens / sec": 6195.656716401972,
+        "mem allocated avg": 6919181907.968,
+        "mem reserved avg": 14204631252.992,
+        "elapsed time": 506.2042880220106
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.44,
+        "train loss": 0.6135006090402603,
+        "train samples": 11000,
+        "train time": 33.8344249399961,
+        "eval time": 11.559464724035934,
+        "tokens / sec": 6262.290562814704,
+        "mem allocated avg": 6928519376.896,
+        "mem reserved avg": 14587529265.152,
+        "elapsed time": 554.7988454389852
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.5,
+        "train loss": 0.6046421718597412,
+        "train samples": 12000,
+        "train time": 33.518839641998056,
+        "eval time": 13.07255553000141,
+        "tokens / sec": 6227.274041386164,
+        "mem allocated avg": 6924324909.056,
+        "mem reserved avg": 14517383725.056,
+        "elapsed time": 604.7252621700172
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.5,
+        "train loss": 0.6123787004947663,
+        "train samples": 13000,
+        "train time": 33.85599415731849,
+        "eval time": 12.407609467976727,
+        "tokens / sec": 6229.354808487008,
+        "mem allocated avg": 6927248498.688,
+        "mem reserved avg": 14381471498.24,
+        "elapsed time": 654.1598190389923
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.46,
+        "train loss": 0.5954382091760635,
+        "train samples": 14000,
+        "train time": 33.584031070175115,
+        "eval time": 8.71236887795385,
+        "tokens / sec": 6245.52780938415,
+        "mem allocated avg": 6924072755.2,
+        "mem reserved avg": 14376438333.44,
+        "elapsed time": 699.7364873759798
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.52,
+        "train loss": 0.5923196750879288,
+        "train samples": 15000,
+        "train time": 34.014798398071434,
+        "eval time": 8.587440980016254,
+        "tokens / sec": 6370.844755977933,
+        "mem allocated avg": 6935308263.424,
+        "mem reserved avg": 14727753236.48,
+        "elapsed time": 745.567757465993
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.5,
+        "train loss": 0.6026594350337983,
+        "train samples": 16000,
+        "train time": 33.61519722332014,
+        "eval time": 10.390929970017169,
+        "tokens / sec": 6079.779887717532,
+        "mem allocated avg": 6916062009.344,
+        "mem reserved avg": 14388383711.232,
+        "elapsed time": 792.880163897993
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.46,
+        "train loss": 0.5877031481266022,
+        "train samples": 17000,
+        "train time": 33.592281938006636,
+        "eval time": 8.453822323994245,
+        "tokens / sec": 6292.784764968063,
+        "mem allocated avg": 6928201375.744,
+        "mem reserved avg": 14382436188.16,
+        "elapsed time": 838.0397840199876
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.5,
+        "train loss": 0.5929731521606445,
+        "train samples": 18000,
+        "train time": 33.91169841529336,
+        "eval time": 8.1252419599914,
+        "tokens / sec": 6128.20972441413,
+        "mem allocated avg": 6921858213.888,
+        "mem reserved avg": 14347757682.688,
+        "elapsed time": 883.4076476009795
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.52,
+        "train loss": 0.583827891588211,
+        "train samples": 19000,
+        "train time": 33.430834216298535,
+        "eval time": 8.106015269993804,
+        "tokens / sec": 6279.801414517154,
+        "mem allocated avg": 6925002395.648,
+        "mem reserved avg": 14434042904.576,
+        "elapsed time": 928.1137036280124
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.5,
+        "train loss": 0.591714503645897,
+        "train samples": 20000,
+        "train time": 33.46077763434732,
+        "eval time": 8.106805060000625,
+        "tokens / sec": 6224.601301142554,
+        "mem allocated avg": 6921049147.392,
+        "mem reserved avg": 14118002098.176,
+        "elapsed time": 972.8581771000172
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.5026535253980288,
+        "train loss": 0.591714503645897,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.515233039855957
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/fourierft--llama-3.2-3B-default.json b/method_comparison/MetaMathQA/results/fourierft--llama-3.2-3B-default.json
new file mode 100644
index 0000000..8575263
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/fourierft--llama-3.2-3B-default.json
@@ -0,0 +1,356 @@
+{
+  "run_info": {
+    "created_at": "2026-01-09T22:09:31+00:00",
+    "total_time": 2139.03748531203,
+    "experiment_name": "fourierft/llama-3.2-3B-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "FOURIERFT",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "n_frequency": 1000,
+      "scaling": 300,
+      "random_loc_seed": 777,
+      "fan_in_fan_out": false,
+      "target_modules": [
+        "q_proj",
+        "v_proj"
+      ],
+      "exclude_modules": null,
+      "bias": "none",
+      "modules_to_save": null,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "n_frequency_pattern": {},
+      "init_weights": false
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 15762228825,
+    "accelerator_memory_max": 23651680256,
+    "accelerator_memory_reserved_99th": 21596471296,
+    "train_time": 1726.894935239805,
+    "file_size": 231416,
+    "num_trainable_params": 56000,
+    "num_total_params": 3212805824,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.0,
+        "train loss": 1.3261459288597106,
+        "train samples": 1000,
+        "train time": 54.26436190091772,
+        "eval time": 20.152891070989426,
+        "tokens / sec": 3901.62148016375,
+        "mem allocated avg": 6780939091.968,
+        "mem reserved avg": 15867958001.664,
+        "elapsed time": 99.62701734097209
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.0,
+        "train loss": 1.3400139141082763,
+        "train samples": 2000,
+        "train time": 53.535696760285646,
+        "eval time": 20.12735749600688,
+        "tokens / sec": 3885.16471414073,
+        "mem allocated avg": 6773629601.792,
+        "mem reserved avg": 15486259560.448,
+        "elapsed time": 176.75905558397062
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.0,
+        "train loss": 1.3044390759468079,
+        "train samples": 3000,
+        "train time": 53.646198650298174,
+        "eval time": 20.156346999981906,
+        "tokens / sec": 3996.573949211373,
+        "mem allocated avg": 6783680942.08,
+        "mem reserved avg": 15731836059.648,
+        "elapsed time": 253.90234332997352
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.0,
+        "train loss": 1.311077395439148,
+        "train samples": 4000,
+        "train time": 52.92571030347608,
+        "eval time": 20.228597007051576,
+        "tokens / sec": 3936.3855261535678,
+        "mem allocated avg": 6776640890.88,
+        "mem reserved avg": 15724596690.944,
+        "elapsed time": 330.55366935697384
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.0,
+        "train loss": 1.2998026401996612,
+        "train samples": 5000,
+        "train time": 53.52640636928845,
+        "eval time": 20.14151435403619,
+        "tokens / sec": 3895.9835741868837,
+        "mem allocated avg": 6775686537.216,
+        "mem reserved avg": 15805932634.112,
+        "elapsed time": 407.61837184696924
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.0,
+        "train loss": 1.2868368306159974,
+        "train samples": 6000,
+        "train time": 53.88665995717747,
+        "eval time": 20.14792396198027,
+        "tokens / sec": 3884.6534590629794,
+        "mem allocated avg": 6777282525.184,
+        "mem reserved avg": 15735241834.496,
+        "elapsed time": 485.17054163996363
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.0,
+        "train loss": 1.2805588779449464,
+        "train samples": 7000,
+        "train time": 53.43724203767488,
+        "eval time": 20.139051661011763,
+        "tokens / sec": 3917.773298487193,
+        "mem allocated avg": 6777839691.776,
+        "mem reserved avg": 16100456660.992,
+        "elapsed time": 562.2017202629941
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.0,
+        "train loss": 1.2766080429553985,
+        "train samples": 8000,
+        "train time": 53.74037380289519,
+        "eval time": 20.10542684403481,
+        "tokens / sec": 3864.8037834975135,
+        "mem allocated avg": 6774405505.024,
+        "mem reserved avg": 15730795872.256,
+        "elapsed time": 639.6445371389855
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.0,
+        "train loss": 1.2596942813396454,
+        "train samples": 9000,
+        "train time": 55.60716101707658,
+        "eval time": 20.199656157987192,
+        "tokens / sec": 3865.473368330941,
+        "mem allocated avg": 6785559302.144,
+        "mem reserved avg": 16046719238.144,
+        "elapsed time": 718.9049943919526
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.0,
+        "train loss": 1.2683517651557923,
+        "train samples": 10000,
+        "train time": 53.73305493139196,
+        "eval time": 20.08102407801198,
+        "tokens / sec": 3833.152614586777,
+        "mem allocated avg": 6771125086.208,
+        "mem reserved avg": 15553687191.552,
+        "elapsed time": 796.1963960899739
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.0,
+        "train loss": 1.254921770811081,
+        "train samples": 11000,
+        "train time": 55.10060942819109,
+        "eval time": 20.137201737961732,
+        "tokens / sec": 3845.347668543126,
+        "mem allocated avg": 6781653977.088,
+        "mem reserved avg": 15920974004.224,
+        "elapsed time": 874.8866917559644
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.0,
+        "train loss": 1.2537723093032838,
+        "train samples": 12000,
+        "train time": 53.60143480350962,
+        "eval time": 20.126665371004492,
+        "tokens / sec": 3894.130833720389,
+        "mem allocated avg": 6776695320.576,
+        "mem reserved avg": 15812299587.584,
+        "elapsed time": 952.1623955519754
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.0,
+        "train loss": 1.2485535402297974,
+        "train samples": 13000,
+        "train time": 54.74126313335728,
+        "eval time": 20.236808118002955,
+        "tokens / sec": 3852.6878615536516,
+        "mem allocated avg": 6778833948.672,
+        "mem reserved avg": 15685539332.096,
+        "elapsed time": 1030.4662453850033
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.0,
+        "train loss": 1.247687777519226,
+        "train samples": 14000,
+        "train time": 53.67239992291434,
+        "eval time": 20.154386248032097,
+        "tokens / sec": 3907.9676016210988,
+        "mem allocated avg": 6776816490.496,
+        "mem reserved avg": 15717592203.264,
+        "elapsed time": 1107.7825586889521
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.0,
+        "train loss": 1.2286142303943635,
+        "train samples": 15000,
+        "train time": 55.43350543506676,
+        "eval time": 20.094228011963423,
+        "tokens / sec": 3909.2422227174457,
+        "mem allocated avg": 6788307730.432,
+        "mem reserved avg": 16017065508.864,
+        "elapsed time": 1186.77993246197
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.0,
+        "train loss": 1.2608506062030793,
+        "train samples": 16000,
+        "train time": 53.14804647688288,
+        "eval time": 20.161071109992918,
+        "tokens / sec": 3845.353000676958,
+        "mem allocated avg": 6769206956.032,
+        "mem reserved avg": 15759719792.64,
+        "elapsed time": 1263.6211953659658
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.0,
+        "train loss": 1.2272750456333161,
+        "train samples": 17000,
+        "train time": 54.87057439738419,
+        "eval time": 20.140905109001324,
+        "tokens / sec": 3852.502043610417,
+        "mem allocated avg": 6780253456.384,
+        "mem reserved avg": 15731970277.376,
+        "elapsed time": 1341.9455141729559
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.0,
+        "train loss": 1.2504476809501648,
+        "train samples": 18000,
+        "train time": 53.83008128858637,
+        "eval time": 20.128594986046664,
+        "tokens / sec": 3860.629503527497,
+        "mem allocated avg": 6775227097.088,
+        "mem reserved avg": 15675707883.52,
+        "elapsed time": 1419.423019112961
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.0,
+        "train loss": 1.234989553451538,
+        "train samples": 19000,
+        "train time": 53.29879065020941,
+        "eval time": 20.26173467701301,
+        "tokens / sec": 3938.9073830547627,
+        "mem allocated avg": 6777659713.536,
+        "mem reserved avg": 15754426580.992,
+        "elapsed time": 1496.3555859409971
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.0,
+        "train loss": 1.2481540043354034,
+        "train samples": 20000,
+        "train time": 53.355687880772166,
+        "eval time": 20.13233814504929,
+        "tokens / sec": 3903.6138089985725,
+        "mem allocated avg": 6774096742.4,
+        "mem reserved avg": 15385797591.04,
+        "elapsed time": 1573.2050500559853
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.000758150113722517,
+        "train loss": 1.2481540043354034,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": -0.012529373168945312
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/fourierft--llama-3.2-3B-n_frequency-5000.json b/method_comparison/MetaMathQA/results/fourierft--llama-3.2-3B-n_frequency-5000.json
new file mode 100644
index 0000000..1194935
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/fourierft--llama-3.2-3B-n_frequency-5000.json
@@ -0,0 +1,356 @@
+{
+  "run_info": {
+    "created_at": "2026-01-09T22:45:14+00:00",
+    "total_time": 2150.229806937976,
+    "experiment_name": "fourierft/llama-3.2-3B-n_frequency-5000",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "FOURIERFT",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "n_frequency": 5000,
+      "scaling": 300,
+      "random_loc_seed": 777,
+      "fan_in_fan_out": false,
+      "target_modules": [
+        "v_proj",
+        "q_proj"
+      ],
+      "exclude_modules": null,
+      "bias": "none",
+      "modules_to_save": null,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "n_frequency_pattern": {},
+      "init_weights": false
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 15765951270,
+    "accelerator_memory_max": 23674748928,
+    "accelerator_memory_reserved_99th": 21602762752,
+    "train_time": 1735.5117494451115,
+    "file_size": 1127472,
+    "num_trainable_params": 280000,
+    "num_total_params": 3213029824,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.0,
+        "train loss": 1.3799961261749267,
+        "train samples": 1000,
+        "train time": 54.63538205990335,
+        "eval time": 20.25719825399574,
+        "tokens / sec": 3875.126191446176,
+        "mem allocated avg": 6784255385.6,
+        "mem reserved avg": 15879072907.264,
+        "elapsed time": 99.3786606270005
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.0,
+        "train loss": 1.370254718542099,
+        "train samples": 2000,
+        "train time": 54.05832158756675,
+        "eval time": 20.27056284097489,
+        "tokens / sec": 3847.6037341092406,
+        "mem allocated avg": 6777261156.352,
+        "mem reserved avg": 15501593935.872,
+        "elapsed time": 177.16174678102834
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.0,
+        "train loss": 1.3024464647769929,
+        "train samples": 3000,
+        "train time": 54.38698652503081,
+        "eval time": 20.305425599042792,
+        "tokens / sec": 3942.1378844243395,
+        "mem allocated avg": 6787271151.616,
+        "mem reserved avg": 15726962278.4,
+        "elapsed time": 255.17251890699845
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.0,
+        "train loss": 1.2703465101718903,
+        "train samples": 4000,
+        "train time": 54.011514401237946,
+        "eval time": 20.39393692498561,
+        "tokens / sec": 3857.251593656943,
+        "mem allocated avg": 6780041570.304,
+        "mem reserved avg": 15735644487.68,
+        "elapsed time": 333.0673065180308
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.0,
+        "train loss": 1.2236051378250121,
+        "train samples": 5000,
+        "train time": 54.131226874596905,
+        "eval time": 20.295763457019348,
+        "tokens / sec": 3852.452863909948,
+        "mem allocated avg": 6779091253.248,
+        "mem reserved avg": 15815420149.76,
+        "elapsed time": 410.88266454002587
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.0,
+        "train loss": 1.1791759724617004,
+        "train samples": 6000,
+        "train time": 54.805071563867386,
+        "eval time": 20.344787555979565,
+        "tokens / sec": 3819.5552715601325,
+        "mem allocated avg": 6781132302.336,
+        "mem reserved avg": 15728438673.408,
+        "elapsed time": 489.5477928170003
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.0,
+        "train loss": 1.1484073193073272,
+        "train samples": 7000,
+        "train time": 54.526441418449394,
+        "eval time": 20.204474157013465,
+        "tokens / sec": 3839.5133545092,
+        "mem allocated avg": 6781927921.664,
+        "mem reserved avg": 16101270355.968,
+        "elapsed time": 567.73078815802
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.06,
+        "train loss": 1.1230360004901887,
+        "train samples": 8000,
+        "train time": 53.57974702503998,
+        "eval time": 20.231831898970995,
+        "tokens / sec": 3876.390082673128,
+        "mem allocated avg": 6778186371.072,
+        "mem reserved avg": 15751582842.88,
+        "elapsed time": 645.0985403700033
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.06,
+        "train loss": 1.0939874126911164,
+        "train samples": 9000,
+        "train time": 55.8729160525254,
+        "eval time": 20.28473745501833,
+        "tokens / sec": 3847.087554870596,
+        "mem allocated avg": 6789467377.664,
+        "mem reserved avg": 16052515766.272,
+        "elapsed time": 724.6561014120234
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.08,
+        "train loss": 1.077495297908783,
+        "train samples": 10000,
+        "train time": 52.74528944323538,
+        "eval time": 20.17585710203275,
+        "tokens / sec": 3904.93638719458,
+        "mem allocated avg": 6774599432.192,
+        "mem reserved avg": 15540391247.872,
+        "elapsed time": 801.0244456710061
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.08,
+        "train loss": 1.0567093884944916,
+        "train samples": 11000,
+        "train time": 53.79716244636802,
+        "eval time": 20.35781637695618,
+        "tokens / sec": 3938.516277902769,
+        "mem allocated avg": 6785299869.696,
+        "mem reserved avg": 15918188986.368,
+        "elapsed time": 878.562464024988
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.12,
+        "train loss": 1.0359035170078277,
+        "train samples": 12000,
+        "train time": 53.633092043863144,
+        "eval time": 20.22181941999588,
+        "tokens / sec": 3891.8323006492337,
+        "mem allocated avg": 6780504604.672,
+        "mem reserved avg": 15821015351.296,
+        "elapsed time": 955.9252954589901
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.1,
+        "train loss": 1.0238903017044068,
+        "train samples": 13000,
+        "train time": 54.95394577109255,
+        "eval time": 20.251423412002623,
+        "tokens / sec": 3837.7771976282793,
+        "mem allocated avg": 6782707699.712,
+        "mem reserved avg": 15711476908.032,
+        "elapsed time": 1034.4340154950041
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.22,
+        "train loss": 1.0096496410369873,
+        "train samples": 14000,
+        "train time": 54.10011919972021,
+        "eval time": 20.23786943597952,
+        "tokens / sec": 3877.0709400042274,
+        "mem allocated avg": 6780696848.384,
+        "mem reserved avg": 15717843861.504,
+        "elapsed time": 1112.2632181590307
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.26,
+        "train loss": 0.9940191543102265,
+        "train samples": 15000,
+        "train time": 55.7427657317603,
+        "eval time": 20.346782680018805,
+        "tokens / sec": 3887.5537866706554,
+        "mem allocated avg": 6792103485.44,
+        "mem reserved avg": 16009381543.936,
+        "elapsed time": 1191.7781133620301
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.16,
+        "train loss": 1.0120926787853242,
+        "train samples": 16000,
+        "train time": 53.314123046409804,
+        "eval time": 20.31927741097752,
+        "tokens / sec": 3833.3745042020823,
+        "mem allocated avg": 6772785229.824,
+        "mem reserved avg": 15762924240.896,
+        "elapsed time": 1268.9340723860078
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.16,
+        "train loss": 0.9847111780643463,
+        "train samples": 17000,
+        "train time": 54.80445172073087,
+        "eval time": 20.269200723967515,
+        "tokens / sec": 3857.1501650483247,
+        "mem allocated avg": 6784316258.304,
+        "mem reserved avg": 15734939844.608,
+        "elapsed time": 1347.3028064740356
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.16,
+        "train loss": 0.9993657054901123,
+        "train samples": 18000,
+        "train time": 54.06312520604115,
+        "eval time": 20.218144676997326,
+        "tokens / sec": 3843.9879161254607,
+        "mem allocated avg": 6778886414.336,
+        "mem reserved avg": 15662697152.512,
+        "elapsed time": 1425.0894955290132
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.2,
+        "train loss": 0.9890022552013398,
+        "train samples": 19000,
+        "train time": 54.60328221245436,
+        "eval time": 20.21068259398453,
+        "tokens / sec": 3844.8055042397323,
+        "mem allocated avg": 6781246834.688,
+        "mem reserved avg": 15759325528.064,
+        "elapsed time": 1503.2603250180255
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.24,
+        "train loss": 0.9977171268463135,
+        "train samples": 20000,
+        "train time": 53.51452894380782,
+        "eval time": 20.269856880011503,
+        "tokens / sec": 3892.0271580583562,
+        "mem allocated avg": 6777745672.192,
+        "mem reserved avg": 15388339339.264,
+        "elapsed time": 1580.3933992580278
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.11675511751326763,
+        "train loss": 0.9977171268463135,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.40204334259033203
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/full-finetuning--llama-3.2-3B-lr_0.00001.json b/method_comparison/MetaMathQA/results/full-finetuning--llama-3.2-3B-lr_0.00001.json
new file mode 100644
index 0000000..d04a085
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/full-finetuning--llama-3.2-3B-lr_0.00001.json
@@ -0,0 +1,332 @@
+{
+  "run_info": {
+    "created_at": "2026-01-09T23:21:09+00:00",
+    "total_time": 2347.218174619018,
+    "experiment_name": "full-finetuning/llama-3.2-3B-lr_0.00001",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 1e-05
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": null,
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 34309618532,
+    "accelerator_memory_max": 38549848064,
+    "accelerator_memory_reserved_99th": 37237492285,
+    "train_time": 2154.846133010811,
+    "file_size": 6425499648,
+    "num_trainable_params": 3212749824,
+    "num_total_params": 3212749824,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.3,
+        "train loss": 1.0749022269248962,
+        "train samples": 1000,
+        "train time": 91.49652248725761,
+        "eval time": 11.212762297014706,
+        "tokens / sec": 2313.956795784073,
+        "mem allocated avg": 26068575909.888,
+        "mem reserved avg": 34185951576.064,
+        "elapsed time": 124.61640950996662
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.4,
+        "train loss": 0.7238605138063431,
+        "train samples": 2000,
+        "train time": 91.91453206090955,
+        "eval time": 11.141172014991753,
+        "tokens / sec": 2262.917466219234,
+        "mem allocated avg": 26061334226.944,
+        "mem reserved avg": 34147850518.528,
+        "elapsed time": 230.16530759999296
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.42,
+        "train loss": 0.6648618532419205,
+        "train samples": 3000,
+        "train time": 92.5216026121634,
+        "eval time": 6.087067044980358,
+        "tokens / sec": 2317.3074606017867,
+        "mem allocated avg": 26070816337.92,
+        "mem reserved avg": 34269409837.056,
+        "elapsed time": 331.3244165930082
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.4,
+        "train loss": 0.6407386429309845,
+        "train samples": 4000,
+        "train time": 91.41802564635873,
+        "eval time": 11.26410798204597,
+        "tokens / sec": 2278.9378629322678,
+        "mem allocated avg": 26063015718.912,
+        "mem reserved avg": 34418341183.488,
+        "elapsed time": 436.4462315859855
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.46,
+        "train loss": 0.6343499521017074,
+        "train samples": 5000,
+        "train time": 91.51783608621918,
+        "eval time": 9.06717514997581,
+        "tokens / sec": 2278.6596462304447,
+        "mem allocated avg": 26061503963.136,
+        "mem reserved avg": 34260576632.832,
+        "elapsed time": 539.5919883140014
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.58,
+        "train loss": 0.624906349182129,
+        "train samples": 6000,
+        "train time": 91.87651025888044,
+        "eval time": 11.171614417049568,
+        "tokens / sec": 2278.395200363706,
+        "mem allocated avg": 26064701278.208,
+        "mem reserved avg": 34224690167.808,
+        "elapsed time": 645.2011065029656
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.54,
+        "train loss": 0.6175477323532105,
+        "train samples": 7000,
+        "train time": 90.95103025593562,
+        "eval time": 11.160093326005153,
+        "tokens / sec": 2301.843084249583,
+        "mem allocated avg": 26063144126.464,
+        "mem reserved avg": 34362062012.416,
+        "elapsed time": 749.8216157860006
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.42,
+        "train loss": 0.6184427078962326,
+        "train samples": 8000,
+        "train time": 90.84291155746905,
+        "eval time": 11.153122653020546,
+        "tokens / sec": 2286.3203792032505,
+        "mem allocated avg": 26060605181.952,
+        "mem reserved avg": 34304549715.968,
+        "elapsed time": 854.322792426974
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.46,
+        "train loss": 0.6107840378284455,
+        "train samples": 9000,
+        "train time": 92.96169786009705,
+        "eval time": 11.16127427702304,
+        "tokens / sec": 2312.221107702729,
+        "mem allocated avg": 26073147115.52,
+        "mem reserved avg": 34312711831.552,
+        "elapsed time": 960.9334694420104
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.54,
+        "train loss": 0.6089447345733643,
+        "train samples": 10000,
+        "train time": 90.26249368820572,
+        "eval time": 11.146873010031413,
+        "tokens / sec": 2281.8669370189687,
+        "mem allocated avg": 26057948864.512,
+        "mem reserved avg": 34399810748.416,
+        "elapsed time": 1064.9780696959933
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.56,
+        "train loss": 0.6021645392179489,
+        "train samples": 11000,
+        "train time": 91.39197911316296,
+        "eval time": 11.157545586000197,
+        "tokens / sec": 2318.376317659624,
+        "mem allocated avg": 26068202784.768,
+        "mem reserved avg": 34373529239.552,
+        "elapsed time": 1170.0117728059995
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.48,
+        "train loss": 0.5950663160085679,
+        "train samples": 12000,
+        "train time": 91.94340823084349,
+        "eval time": 6.359558377007488,
+        "tokens / sec": 2270.2116879976475,
+        "mem allocated avg": 26062483675.136,
+        "mem reserved avg": 34305480851.456,
+        "elapsed time": 1270.7611719949637
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.5,
+        "train loss": 0.6067559220790864,
+        "train samples": 13000,
+        "train time": 91.35254304017872,
+        "eval time": 6.207320767978672,
+        "tokens / sec": 2308.649469202422,
+        "mem allocated avg": 26064313700.352,
+        "mem reserved avg": 34178494103.552,
+        "elapsed time": 1370.8038186989725
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.46,
+        "train loss": 0.5922972733974456,
+        "train samples": 14000,
+        "train time": 91.81345162418438,
+        "eval time": 7.237666736007668,
+        "tokens / sec": 2284.523632316533,
+        "mem allocated avg": 26062809985.024,
+        "mem reserved avg": 34401211645.952,
+        "elapsed time": 1472.3757120459923
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.5,
+        "train loss": 0.5926397043466568,
+        "train samples": 15000,
+        "train time": 92.5030986299389,
+        "eval time": 11.144441604032181,
+        "tokens / sec": 2342.6566591777223,
+        "mem allocated avg": 26074840416.256,
+        "mem reserved avg": 34314205003.776,
+        "elapsed time": 1578.5238473899662
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.52,
+        "train loss": 0.6050900548696518,
+        "train samples": 16000,
+        "train time": 90.88473943283316,
+        "eval time": 11.175483218976296,
+        "tokens / sec": 2248.7053522449546,
+        "mem allocated avg": 26056039493.632,
+        "mem reserved avg": 34580459421.696,
+        "elapsed time": 1683.2547346790088
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.52,
+        "train loss": 0.5931364653110505,
+        "train samples": 17000,
+        "train time": 91.31777060282184,
+        "eval time": 7.878185064007994,
+        "tokens / sec": 2314.8725445720397,
+        "mem allocated avg": 26067197499.392,
+        "mem reserved avg": 34410673995.776,
+        "elapsed time": 1785.080884763971
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.48,
+        "train loss": 0.6010294594764709,
+        "train samples": 18000,
+        "train time": 91.71872854570393,
+        "eval time": 6.507075314002577,
+        "tokens / sec": 2265.8185879282355,
+        "mem allocated avg": 26062461708.288,
+        "mem reserved avg": 34202108035.072,
+        "elapsed time": 1885.7456577859703
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.5,
+        "train loss": 0.5937523410320282,
+        "train samples": 19000,
+        "train time": 91.9850392206572,
+        "eval time": 6.368945363035891,
+        "tokens / sec": 2282.31679606496,
+        "mem allocated avg": 26063243161.6,
+        "mem reserved avg": 34250082484.224,
+        "elapsed time": 1986.7437554029748
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.46,
+        "train loss": 0.5987640290260315,
+        "train samples": 20000,
+        "train time": 90.72794272896135,
+        "eval time": 11.154609176970553,
+        "tokens / sec": 2295.654389764034,
+        "mem allocated avg": 26061294045.184,
+        "mem reserved avg": 34290171641.856,
+        "elapsed time": 2091.1681218339945
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.49507202426080366,
+        "train loss": 0.5987640290260315,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.5911064147949219
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/gralora--llama-3.2-3B-rank32.json b/method_comparison/MetaMathQA/results/gralora--llama-3.2-3B-rank32.json
new file mode 100644
index 0000000..22f9af6
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/gralora--llama-3.2-3B-rank32.json
@@ -0,0 +1,355 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T00:00:21+00:00",
+    "total_time": 1289.217340779025,
+    "experiment_name": "gralora/llama-3.2-3B-rank32",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0002
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "GRALORA",
+      "auto_mapping": null,
+      "peft_version": "0.17.2.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 32,
+      "hybrid_r": 0,
+      "target_modules": [
+        "q_proj",
+        "v_proj"
+      ],
+      "alpha": 64,
+      "gralora_dropout": 0.0,
+      "gralora_k": 2,
+      "fan_in_fan_out": false,
+      "bias": "none",
+      "modules_to_save": null,
+      "init_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 14431023425,
+    "accelerator_memory_max": 22307405824,
+    "accelerator_memory_reserved_99th": 20126367744,
+    "train_time": 1078.0007609191234,
+    "file_size": 36714960,
+    "num_trainable_params": 9175040,
+    "num_total_params": 3221924864,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.36,
+        "train loss": 0.942215921163559,
+        "train samples": 1000,
+        "train time": 34.042564845993184,
+        "eval time": 13.884479815023951,
+        "tokens / sec": 6219.243495835461,
+        "mem allocated avg": 6927297665.024,
+        "mem reserved avg": 14540712443.904,
+        "elapsed time": 70.35818397701951
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.48,
+        "train loss": 0.707061094880104,
+        "train samples": 2000,
+        "train time": 33.86772509320872,
+        "eval time": 13.81671311397804,
+        "tokens / sec": 6141.392710244596,
+        "mem allocated avg": 6920123852.8,
+        "mem reserved avg": 14167075454.976,
+        "elapsed time": 121.25836294901092
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.42,
+        "train loss": 0.6730556710958481,
+        "train samples": 3000,
+        "train time": 34.94966330617899,
+        "eval time": 13.804657173983287,
+        "tokens / sec": 6134.5655356312,
+        "mem allocated avg": 6930530816.0,
+        "mem reserved avg": 14409984376.832,
+        "elapsed time": 173.17440196697135
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.38,
+        "train loss": 0.6534032428264618,
+        "train samples": 4000,
+        "train time": 34.35864242265234,
+        "eval time": 13.949590890028048,
+        "tokens / sec": 6063.56902689048,
+        "mem allocated avg": 6921228693.504,
+        "mem reserved avg": 14450920783.872,
+        "elapsed time": 224.78821431397228
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.4,
+        "train loss": 0.6493164491653443,
+        "train samples": 5000,
+        "train time": 33.983851948869415,
+        "eval time": 11.309890707023442,
+        "tokens / sec": 6136.3850193838225,
+        "mem allocated avg": 6921922877.44,
+        "mem reserved avg": 14466959802.368,
+        "elapsed time": 273.25096270401264
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.34,
+        "train loss": 0.6408532521724701,
+        "train samples": 6000,
+        "train time": 34.35372261068551,
+        "eval time": 9.27557178097777,
+        "tokens / sec": 6093.400775579672,
+        "mem allocated avg": 6923754981.376,
+        "mem reserved avg": 14382721400.832,
+        "elapsed time": 320.11889754998265
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.4,
+        "train loss": 0.6322305067777634,
+        "train samples": 7000,
+        "train time": 34.57727349648485,
+        "eval time": 9.888179413974285,
+        "tokens / sec": 6054.699484078268,
+        "mem allocated avg": 6925341489.152,
+        "mem reserved avg": 14776876924.928,
+        "elapsed time": 367.8946221729857
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.52,
+        "train loss": 0.6344789278507232,
+        "train samples": 8000,
+        "train time": 33.59021200949792,
+        "eval time": 8.374654100975022,
+        "tokens / sec": 6183.229803410356,
+        "mem allocated avg": 6920861077.504,
+        "mem reserved avg": 14419908100.096,
+        "elapsed time": 413.12702070496744
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.42,
+        "train loss": 0.6251693757772445,
+        "train samples": 9000,
+        "train time": 34.35726486198837,
+        "eval time": 13.802904761978425,
+        "tokens / sec": 6256.260527822477,
+        "mem allocated avg": 6931583428.608,
+        "mem reserved avg": 14699693342.72,
+        "elapsed time": 464.4872953959857
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.46,
+        "train loss": 0.6212710882425309,
+        "train samples": 10000,
+        "train time": 33.39420525066089,
+        "eval time": 13.795758826017845,
+        "tokens / sec": 6167.746722941514,
+        "mem allocated avg": 6918615058.432,
+        "mem reserved avg": 14201795903.488,
+        "elapsed time": 514.8732995300088
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.48,
+        "train loss": 0.6123416483402252,
+        "train samples": 11000,
+        "train time": 34.10195262962952,
+        "eval time": 7.583350939967204,
+        "tokens / sec": 6213.163284260355,
+        "mem allocated avg": 6927684456.448,
+        "mem reserved avg": 14572228444.16,
+        "elapsed time": 559.7389343840186
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.46,
+        "train loss": 0.6028379487991333,
+        "train samples": 12000,
+        "train time": 34.35880611848552,
+        "eval time": 7.6943675089860335,
+        "tokens / sec": 6075.036463147065,
+        "mem allocated avg": 6923840229.376,
+        "mem reserved avg": 14495858556.928,
+        "elapsed time": 605.0798396450118
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.54,
+        "train loss": 0.6112224916219712,
+        "train samples": 13000,
+        "train time": 34.423862263094634,
+        "eval time": 10.099462785990909,
+        "tokens / sec": 6126.593186671682,
+        "mem allocated avg": 6926499131.392,
+        "mem reserved avg": 14352186867.712,
+        "elapsed time": 652.7459372479934
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.5,
+        "train loss": 0.5940833052396775,
+        "train samples": 14000,
+        "train time": 34.00928645499516,
+        "eval time": 7.006814954045694,
+        "tokens / sec": 6167.433129700158,
+        "mem allocated avg": 6923424174.08,
+        "mem reserved avg": 14361095569.408,
+        "elapsed time": 696.9908059639856
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.52,
+        "train loss": 0.5911667649745941,
+        "train samples": 15000,
+        "train time": 34.607924775453284,
+        "eval time": 8.789539379009511,
+        "tokens / sec": 6261.6583168749585,
+        "mem allocated avg": 6934536548.352,
+        "mem reserved avg": 14719675006.976,
+        "elapsed time": 743.6320169619867
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.52,
+        "train loss": 0.601644613146782,
+        "train samples": 16000,
+        "train time": 33.85560346476268,
+        "eval time": 7.726654959958978,
+        "tokens / sec": 6036.607801503638,
+        "mem allocated avg": 6915689891.84,
+        "mem reserved avg": 14388962525.184,
+        "elapsed time": 788.4833239429863
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.6,
+        "train loss": 0.5881835660934448,
+        "train samples": 17000,
+        "train time": 34.50086922443006,
+        "eval time": 10.961278792994563,
+        "tokens / sec": 6127.063020496756,
+        "mem allocated avg": 6927453581.312,
+        "mem reserved avg": 14375817576.448,
+        "elapsed time": 837.071181916981
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.58,
+        "train loss": 0.5937378851175308,
+        "train samples": 18000,
+        "train time": 33.85475521400804,
+        "eval time": 9.431811225018464,
+        "tokens / sec": 6138.517283209049,
+        "mem allocated avg": 6921458198.528,
+        "mem reserved avg": 14334059085.824,
+        "elapsed time": 883.6634952509776
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.58,
+        "train loss": 0.586182700753212,
+        "train samples": 19000,
+        "train time": 34.06897705892334,
+        "eval time": 9.29696652397979,
+        "tokens / sec": 6162.1750379209825,
+        "mem allocated avg": 6924237260.8,
+        "mem reserved avg": 14424924487.68,
+        "elapsed time": 930.1821659649722
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.6,
+        "train loss": 0.592198490023613,
+        "train samples": 20000,
+        "train time": 34.439023942220956,
+        "eval time": 7.703576382948086,
+        "tokens / sec": 6047.7904469486575,
+        "mem allocated avg": 6920309841.92,
+        "mem reserved avg": 14079011848.192,
+        "elapsed time": 975.4882056199713
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.5011372251705838,
+        "train loss": 0.592198490023613,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.49779701232910156
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/hira--llama-3.2-3B-rank32-lr4.5e-3.json b/method_comparison/MetaMathQA/results/hira--llama-3.2-3B-rank32-lr4.5e-3.json
new file mode 100644
index 0000000..aae634d
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/hira--llama-3.2-3B-rank32-lr4.5e-3.json
@@ -0,0 +1,356 @@
+{
+  "run_info": {
+    "created_at": "2026-05-27T17:25:11+00:00",
+    "total_time": 1531.8886643749993,
+    "experiment_name": "hira/llama-3.2-3B-rank32-lr4.5e-3",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "use_gc": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0045,
+        "weight_decay": 0.0
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null,
+      "init_kv_cache_prefix": null
+    },
+    "peft_config": {
+      "task_type": "CAUSAL_LM",
+      "peft_type": "HIRA",
+      "auto_mapping": null,
+      "peft_version": "0.19.2.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 32,
+      "target_modules": [
+        "v_proj",
+        "q_proj"
+      ],
+      "exclude_modules": null,
+      "hira_dropout": 0.0,
+      "fan_in_fan_out": false,
+      "modules_to_save": null,
+      "init_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "rank_pattern": {}
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 15904586439,
+    "accelerator_memory_max": 23599251456,
+    "accelerator_memory_reserved_99th": 21544042496,
+    "train_time": 1301.0097959969953,
+    "file_size": 36714432,
+    "num_trainable_params": 9175040,
+    "num_total_params": 3221924864,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.34,
+        "train loss": 0.9646387231349945,
+        "train samples": 1000,
+        "train time": 44.795105522020094,
+        "eval time": 14.398763205999785,
+        "tokens / sec": 4726.386901710155,
+        "mem allocated avg": 6928853504.0,
+        "mem reserved avg": 16064704413.696,
+        "elapsed time": 83.38231655299933
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.42,
+        "train loss": 0.7001485234498978,
+        "train samples": 2000,
+        "train time": 44.47210852798344,
+        "eval time": 14.172539310000502,
+        "tokens / sec": 4676.976354047214,
+        "mem allocated avg": 6921406732.288,
+        "mem reserved avg": 15652429496.32,
+        "elapsed time": 146.02767726399907
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.46,
+        "train loss": 0.6692534967660904,
+        "train samples": 3000,
+        "train time": 44.12831132800966,
+        "eval time": 8.733457416001329,
+        "tokens / sec": 4858.581566974959,
+        "mem allocated avg": 6931221315.584,
+        "mem reserved avg": 15887100805.12,
+        "elapsed time": 202.82460330399954
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.34,
+        "train loss": 0.6510863740444184,
+        "train samples": 4000,
+        "train time": 43.63650290799524,
+        "eval time": 10.898971231999894,
+        "tokens / sec": 4774.351428648237,
+        "mem allocated avg": 6922076561.408,
+        "mem reserved avg": 15928246927.36,
+        "elapsed time": 261.4391995909991
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.42,
+        "train loss": 0.6459370242357254,
+        "train samples": 5000,
+        "train time": 45.27812863700092,
+        "eval time": 9.182208415000787,
+        "tokens / sec": 4605.711549429727,
+        "mem allocated avg": 6922847700.992,
+        "mem reserved avg": 15938682355.712,
+        "elapsed time": 319.86450736199913
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.3,
+        "train loss": 0.6377188638448715,
+        "train samples": 6000,
+        "train time": 45.01618960000269,
+        "eval time": 10.970070295999903,
+        "tokens / sec": 4650.127028965319,
+        "mem allocated avg": 6924574273.536,
+        "mem reserved avg": 15861398110.208,
+        "elapsed time": 379.9200502529984
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.42,
+        "train loss": 0.6288220664262771,
+        "train samples": 7000,
+        "train time": 46.05123153098066,
+        "eval time": 7.867290225000033,
+        "tokens / sec": 4546.132492877152,
+        "mem allocated avg": 6926381193.216,
+        "mem reserved avg": 16233189605.376,
+        "elapsed time": 437.92144187399936
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.5,
+        "train loss": 0.6291281726360322,
+        "train samples": 8000,
+        "train time": 44.33229007999216,
+        "eval time": 8.769623857000624,
+        "tokens / sec": 4684.982427599344,
+        "mem allocated avg": 6921614581.76,
+        "mem reserved avg": 15905505411.072,
+        "elapsed time": 495.1047526889997
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.52,
+        "train loss": 0.6146055881977082,
+        "train samples": 9000,
+        "train time": 46.350835926006766,
+        "eval time": 14.170944800000143,
+        "tokens / sec": 4637.413666997015,
+        "mem allocated avg": 6933249806.336,
+        "mem reserved avg": 16180425261.056,
+        "elapsed time": 559.6475988139991
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.48,
+        "train loss": 0.6090809844732284,
+        "train samples": 10000,
+        "train time": 42.66342017700299,
+        "eval time": 11.705780178001078,
+        "tokens / sec": 4827.718901707348,
+        "mem allocated avg": 6919446294.528,
+        "mem reserved avg": 15675011629.056,
+        "elapsed time": 617.9899970899987
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.46,
+        "train loss": 0.5963696502447128,
+        "train samples": 11000,
+        "train time": 43.971527898000204,
+        "eval time": 14.192596446000607,
+        "tokens / sec": 4818.595353145239,
+        "mem allocated avg": 6929060073.472,
+        "mem reserved avg": 16071524352.0,
+        "elapsed time": 680.1184260749997
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.42,
+        "train loss": 0.5840621807575226,
+        "train samples": 12000,
+        "train time": 45.096830839995164,
+        "eval time": 9.04414240799997,
+        "tokens / sec": 4628.507061628865,
+        "mem allocated avg": 6924373178.368,
+        "mem reserved avg": 15992000348.16,
+        "elapsed time": 738.3783920139995
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.38,
+        "train loss": 0.5902842267751693,
+        "train samples": 13000,
+        "train time": 43.88750884399451,
+        "eval time": 8.197046043000228,
+        "tokens / sec": 4805.490344637306,
+        "mem allocated avg": 6926799306.752,
+        "mem reserved avg": 15832902008.832,
+        "elapsed time": 794.3936956599991
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.5,
+        "train loss": 0.5697817602157593,
+        "train samples": 14000,
+        "train time": 43.706978787999105,
+        "eval time": 14.210280491999583,
+        "tokens / sec": 4799.004777186575,
+        "mem allocated avg": 6924453980.16,
+        "mem reserved avg": 15803005009.92,
+        "elapsed time": 856.3382452839996
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.48,
+        "train loss": 0.566146876335144,
+        "train samples": 15000,
+        "train time": 46.55487659299797,
+        "eval time": 14.219847387999835,
+        "tokens / sec": 4654.78626212475,
+        "mem allocated avg": 6935796723.712,
+        "mem reserved avg": 16152617025.536,
+        "elapsed time": 921.1417480579985
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.48,
+        "train loss": 0.5722691764831543,
+        "train samples": 16000,
+        "train time": 43.53928425200502,
+        "eval time": 11.240440765999665,
+        "tokens / sec": 4693.990806488475,
+        "mem allocated avg": 6916491333.632,
+        "mem reserved avg": 15871799984.128,
+        "elapsed time": 979.9782767429988
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.56,
+        "train loss": 0.5592831999063492,
+        "train samples": 17000,
+        "train time": 45.612762285994904,
+        "eval time": 11.231426884998655,
+        "tokens / sec": 4634.426625482088,
+        "mem allocated avg": 6927627460.608,
+        "mem reserved avg": 15827491356.672,
+        "elapsed time": 1040.7281391019987
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.54,
+        "train loss": 0.564842660665512,
+        "train samples": 18000,
+        "train time": 44.27341953097675,
+        "eval time": 9.525626223001382,
+        "tokens / sec": 4693.967671835155,
+        "mem allocated avg": 6922492237.824,
+        "mem reserved avg": 15790061387.776,
+        "elapsed time": 1098.604368541999
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.54,
+        "train loss": 0.5554016819000244,
+        "train samples": 19000,
+        "train time": 45.620715104994815,
+        "eval time": 10.54681388499921,
+        "tokens / sec": 4601.834923385817,
+        "mem allocated avg": 6925499830.272,
+        "mem reserved avg": 15869551837.184,
+        "elapsed time": 1158.7251368979996
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.48,
+        "train loss": 0.5626385962963104,
+        "train samples": 20000,
+        "train time": 44.44404913397739,
+        "eval time": 8.27008093800032,
+        "tokens / sec": 4686.341682598185,
+        "mem allocated avg": 6922057099.264,
+        "mem reserved avg": 15554081456.128,
+        "elapsed time": 1215.431550752999
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.5072024260803639,
+        "train loss": 0.5626385962963104,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.4813060760498047
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "740312add88f781978c0658806c59bc2815b9866",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "5.5.4",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.2.dev0",
+      "peft-commit-hash": "51bd32da394265b5ff438123ebef37be35bd2c2d",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/ia3--llama-3.2-3B-default.json b/method_comparison/MetaMathQA/results/ia3--llama-3.2-3B-default.json
new file mode 100644
index 0000000..5c70c56
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/ia3--llama-3.2-3B-default.json
@@ -0,0 +1,353 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T00:21:54+00:00",
+    "total_time": 1252.7159106170293,
+    "experiment_name": "ia3/llama-3.2-3B-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "IA3",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "target_modules": [
+        "k_proj",
+        "down_proj",
+        "v_proj"
+      ],
+      "exclude_modules": null,
+      "feedforward_modules": [
+        "down_proj"
+      ],
+      "fan_in_fan_out": false,
+      "modules_to_save": null,
+      "init_ia3_weights": true
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 14786832524,
+    "accelerator_memory_max": 23240638464,
+    "accelerator_memory_reserved_99th": 20933771264,
+    "train_time": 1015.700665248034,
+    "file_size": 1157064,
+    "num_trainable_params": 286720,
+    "num_total_params": 3213036544,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.0,
+        "train loss": 1.3155594708919525,
+        "train samples": 1000,
+        "train time": 29.70507554640062,
+        "eval time": 11.724285421019886,
+        "tokens / sec": 7127.367835482717,
+        "mem allocated avg": 6782600361.984,
+        "mem reserved avg": 14885492621.312,
+        "elapsed time": 63.95026855904143
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.0,
+        "train loss": 1.2050744531154634,
+        "train samples": 2000,
+        "train time": 29.590323601732962,
+        "eval time": 11.715296942042187,
+        "tokens / sec": 7029.155976780827,
+        "mem allocated avg": 6775425632.256,
+        "mem reserved avg": 14480272523.264,
+        "elapsed time": 108.9384753460181
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.12,
+        "train loss": 1.0194114191532135,
+        "train samples": 3000,
+        "train time": 30.585519072716124,
+        "eval time": 11.650421504979022,
+        "tokens / sec": 7009.885936225842,
+        "mem allocated avg": 6785668968.448,
+        "mem reserved avg": 14756492607.488,
+        "elapsed time": 154.82391193299554
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.3,
+        "train loss": 0.9196182670593261,
+        "train samples": 4000,
+        "train time": 29.49092253309209,
+        "eval time": 11.840653097024187,
+        "tokens / sec": 7064.411083316362,
+        "mem allocated avg": 6777244168.192,
+        "mem reserved avg": 14776985976.832,
+        "elapsed time": 199.8590077710105
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.3,
+        "train loss": 0.8686861591339111,
+        "train samples": 5000,
+        "train time": 29.44121315999655,
+        "eval time": 11.64985877397703,
+        "tokens / sec": 7083.1999641696975,
+        "mem allocated avg": 6777135923.2,
+        "mem reserved avg": 14839564992.512,
+        "elapsed time": 244.56394972099224
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.3,
+        "train loss": 0.8333434355258942,
+        "train samples": 6000,
+        "train time": 29.930749938997906,
+        "eval time": 11.69840682001086,
+        "tokens / sec": 6993.844137772663,
+        "mem allocated avg": 6779035060.224,
+        "mem reserved avg": 14722384527.36,
+        "elapsed time": 289.89695524802664
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.3,
+        "train loss": 0.8170836737155914,
+        "train samples": 7000,
+        "train time": 30.3804316627793,
+        "eval time": 11.654387208051048,
+        "tokens / sec": 6891.113408914859,
+        "mem allocated avg": 6779937654.784,
+        "mem reserved avg": 15161679151.104,
+        "elapsed time": 335.59190371102886
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.3,
+        "train loss": 0.8073079003095627,
+        "train samples": 8000,
+        "train time": 29.52141359890811,
+        "eval time": 11.679582766955718,
+        "tokens / sec": 7035.435457863099,
+        "mem allocated avg": 6776053977.088,
+        "mem reserved avg": 14763992023.04,
+        "elapsed time": 380.5167595850071
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.28,
+        "train loss": 0.795267580151558,
+        "train samples": 9000,
+        "train time": 30.315992950985674,
+        "eval time": 11.681108721997589,
+        "tokens / sec": 7090.25102187891,
+        "mem allocated avg": 6787896084.48,
+        "mem reserved avg": 15088715038.72,
+        "elapsed time": 426.1353191550006
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.3,
+        "train loss": 0.7891060090065003,
+        "train samples": 10000,
+        "train time": 29.285075834020972,
+        "eval time": 11.683325350983068,
+        "tokens / sec": 7033.17284091594,
+        "mem allocated avg": 6772744847.36,
+        "mem reserved avg": 14541761019.904,
+        "elapsed time": 470.7990039800061
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.3,
+        "train loss": 0.7823175694942475,
+        "train samples": 11000,
+        "train time": 30.584478964097798,
+        "eval time": 11.64602530299453,
+        "tokens / sec": 6927.729592801655,
+        "mem allocated avg": 6783104911.36,
+        "mem reserved avg": 14943508234.24,
+        "elapsed time": 516.6453109350405
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.26,
+        "train loss": 0.7710221862792969,
+        "train samples": 12000,
+        "train time": 29.543955663975794,
+        "eval time": 11.677449156995863,
+        "tokens / sec": 7065.099960683823,
+        "mem allocated avg": 6778547337.216,
+        "mem reserved avg": 14865569677.312,
+        "elapsed time": 561.5630381150404
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.3,
+        "train loss": 0.7756292035579682,
+        "train samples": 13000,
+        "train time": 29.600664581230376,
+        "eval time": 11.676535067963414,
+        "tokens / sec": 7124.873815628153,
+        "mem allocated avg": 6780569153.536,
+        "mem reserved avg": 14715774304.256,
+        "elapsed time": 606.3470957170357
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.32,
+        "train loss": 0.7658540964126587,
+        "train samples": 14000,
+        "train time": 29.628978170803748,
+        "eval time": 11.7645476309699,
+        "tokens / sec": 7079.218148896091,
+        "mem allocated avg": 6778699649.024,
+        "mem reserved avg": 14727702904.832,
+        "elapsed time": 651.4321867520339
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.36,
+        "train loss": 0.7585025093555451,
+        "train samples": 15000,
+        "train time": 30.480809888918884,
+        "eval time": 11.652502680022735,
+        "tokens / sec": 7109.489570314241,
+        "mem allocated avg": 6790036742.144,
+        "mem reserved avg": 15097195921.408,
+        "elapsed time": 697.2096698190435
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.34,
+        "train loss": 0.7766863429546356,
+        "train samples": 16000,
+        "train time": 29.984013571229298,
+        "eval time": 11.786360332975164,
+        "tokens / sec": 6816.065484845664,
+        "mem allocated avg": 6770827464.704,
+        "mem reserved avg": 14748657647.616,
+        "elapsed time": 742.6605575150461
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.32,
+        "train loss": 0.7541669148206711,
+        "train samples": 17000,
+        "train time": 30.13022418995388,
+        "eval time": 11.657879816018976,
+        "tokens / sec": 7015.845573113327,
+        "mem allocated avg": 6782400247.808,
+        "mem reserved avg": 14721461780.48,
+        "elapsed time": 787.9822572360281
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.3,
+        "train loss": 0.7659742934703827,
+        "train samples": 18000,
+        "train time": 30.020536605035886,
+        "eval time": 11.697008132992778,
+        "tokens / sec": 6922.527826006246,
+        "mem allocated avg": 6776485750.784,
+        "mem reserved avg": 14703325609.984,
+        "elapsed time": 833.4761402930017
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.32,
+        "train loss": 0.7579846435785293,
+        "train samples": 19000,
+        "train time": 30.37128037889488,
+        "eval time": 11.668571799993515,
+        "tokens / sec": 6912.4184881546,
+        "mem allocated avg": 6779605635.072,
+        "mem reserved avg": 14800801234.944,
+        "elapsed time": 879.1311652210425
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.34,
+        "train loss": 0.7657218432426453,
+        "train samples": 20000,
+        "train time": 29.584271008439828,
+        "eval time": 11.69853776000673,
+        "tokens / sec": 7040.227556750738,
+        "mem allocated avg": 6776251918.336,
+        "mem reserved avg": 14395312701.44,
+        "elapsed time": 924.0385756980395
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.35178165276724793,
+        "train loss": 0.7657218432426453,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.1822957992553711
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/ia3--llama-3.2-3B-lr_0.001.json b/method_comparison/MetaMathQA/results/ia3--llama-3.2-3B-lr_0.001.json
new file mode 100644
index 0000000..cdaec6e
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/ia3--llama-3.2-3B-lr_0.001.json
@@ -0,0 +1,352 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T00:42:51+00:00",
+    "total_time": 1158.928240164998,
+    "experiment_name": "ia3/llama-3.2-3B-lr_0.001",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.001
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "IA3",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "target_modules": [
+        "down_proj",
+        "k_proj",
+        "v_proj"
+      ],
+      "exclude_modules": null,
+      "feedforward_modules": [
+        "down_proj"
+      ],
+      "fan_in_fan_out": false,
+      "modules_to_save": null,
+      "init_ia3_weights": true
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 14786832524,
+    "accelerator_memory_max": 23240638464,
+    "accelerator_memory_reserved_99th": 20933771264,
+    "train_time": 969.7345388169051,
+    "file_size": 1157064,
+    "num_trainable_params": 286720,
+    "num_total_params": 3213036544,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.2,
+        "train loss": 1.16681476187706,
+        "train samples": 1000,
+        "train time": 29.673775453935377,
+        "eval time": 11.714410117012449,
+        "tokens / sec": 7134.885829700566,
+        "mem allocated avg": 6782600361.984,
+        "mem reserved avg": 14885492621.312,
+        "elapsed time": 64.35547732701525
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.34,
+        "train loss": 0.8284487807750702,
+        "train samples": 2000,
+        "train time": 29.442405258771032,
+        "eval time": 11.714618961967062,
+        "tokens / sec": 7064.470384532775,
+        "mem allocated avg": 6775425632.256,
+        "mem reserved avg": 14480272523.264,
+        "elapsed time": 109.20030425902223
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.34,
+        "train loss": 0.7387913703918457,
+        "train samples": 3000,
+        "train time": 30.728236329741776,
+        "eval time": 7.293018446012866,
+        "tokens / sec": 6977.328529346211,
+        "mem allocated avg": 6785668968.448,
+        "mem reserved avg": 14756492607.488,
+        "elapsed time": 150.8779634690145
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.36,
+        "train loss": 0.7031073143482208,
+        "train samples": 4000,
+        "train time": 29.568247662391514,
+        "eval time": 6.950251807982568,
+        "tokens / sec": 7045.936654034017,
+        "mem allocated avg": 6777244168.192,
+        "mem reserved avg": 14776985976.832,
+        "elapsed time": 191.10305509302998
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.3,
+        "train loss": 0.6952721246480942,
+        "train samples": 5000,
+        "train time": 29.136579907499254,
+        "eval time": 7.7922670019906946,
+        "tokens / sec": 7157.257326084655,
+        "mem allocated avg": 6777135923.2,
+        "mem reserved avg": 14839564992.512,
+        "elapsed time": 231.62949198303977
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.28,
+        "train loss": 0.6860846598148346,
+        "train samples": 6000,
+        "train time": 29.309486759477295,
+        "eval time": 8.780186134041287,
+        "tokens / sec": 7142.0902630549235,
+        "mem allocated avg": 6779035060.224,
+        "mem reserved avg": 14722384527.36,
+        "elapsed time": 273.4239038110245
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.34,
+        "train loss": 0.677450892329216,
+        "train samples": 7000,
+        "train time": 29.44055196386762,
+        "eval time": 9.34235847304808,
+        "tokens / sec": 7111.109881939079,
+        "mem allocated avg": 6779937654.784,
+        "mem reserved avg": 15161679151.104,
+        "elapsed time": 315.85002974100644
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.32,
+        "train loss": 0.6783282169103623,
+        "train samples": 8000,
+        "train time": 29.261146096221637,
+        "eval time": 8.788515535998158,
+        "tokens / sec": 7098.013157687588,
+        "mem allocated avg": 6776053977.088,
+        "mem reserved avg": 14763992023.04,
+        "elapsed time": 357.609911208041
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.48,
+        "train loss": 0.6720160303115845,
+        "train samples": 9000,
+        "train time": 30.398827165656257,
+        "eval time": 10.552425866015255,
+        "tokens / sec": 7070.930691788078,
+        "mem allocated avg": 6787896084.48,
+        "mem reserved avg": 15088715038.72,
+        "elapsed time": 402.1721519330167
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.44,
+        "train loss": 0.6704732036590576,
+        "train samples": 10000,
+        "train time": 29.788877881946974,
+        "eval time": 8.030864721979015,
+        "tokens / sec": 6914.224859903927,
+        "mem allocated avg": 6772744847.36,
+        "mem reserved avg": 14541761019.904,
+        "elapsed time": 443.68974046903895
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.44,
+        "train loss": 0.6629449647665023,
+        "train samples": 11000,
+        "train time": 30.050681999477092,
+        "eval time": 8.138099809992127,
+        "tokens / sec": 7050.7883982029725,
+        "mem allocated avg": 6783104911.36,
+        "mem reserved avg": 14943508234.24,
+        "elapsed time": 485.477781796013
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.38,
+        "train loss": 0.6557633522748947,
+        "train samples": 12000,
+        "train time": 29.61273902398534,
+        "eval time": 10.074375847005285,
+        "tokens / sec": 7048.689411369032,
+        "mem allocated avg": 6778547337.216,
+        "mem reserved avg": 14865569677.312,
+        "elapsed time": 528.8621876270045
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.48,
+        "train loss": 0.6654598761796952,
+        "train samples": 13000,
+        "train time": 29.63859097607201,
+        "eval time": 7.940114627999719,
+        "tokens / sec": 7115.756621840281,
+        "mem allocated avg": 6780569153.536,
+        "mem reserved avg": 14715774304.256,
+        "elapsed time": 569.9359965579933
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.46,
+        "train loss": 0.6528869969844818,
+        "train samples": 14000,
+        "train time": 30.20164098625537,
+        "eval time": 11.715904708020389,
+        "tokens / sec": 6944.986866622787,
+        "mem allocated avg": 6778699649.024,
+        "mem reserved avg": 14727702904.832,
+        "elapsed time": 615.5466552060097
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.48,
+        "train loss": 0.6514250497817993,
+        "train samples": 15000,
+        "train time": 31.03051795932697,
+        "eval time": 9.986055641958956,
+        "tokens / sec": 6983.544402450578,
+        "mem allocated avg": 6790036742.144,
+        "mem reserved avg": 15097195921.408,
+        "elapsed time": 660.206704717013
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.42,
+        "train loss": 0.6659475769996643,
+        "train samples": 16000,
+        "train time": 29.327483134518843,
+        "eval time": 11.69795022701146,
+        "tokens / sec": 6968.651181643686,
+        "mem allocated avg": 6770827464.704,
+        "mem reserved avg": 14748657647.616,
+        "elapsed time": 704.8852831150289
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.42,
+        "train loss": 0.6488557003736496,
+        "train samples": 17000,
+        "train time": 29.780065669328906,
+        "eval time": 11.67279983102344,
+        "tokens / sec": 7098.338947509905,
+        "mem allocated avg": 6782400247.808,
+        "mem reserved avg": 14721461780.48,
+        "elapsed time": 749.8611966730095
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.4,
+        "train loss": 0.6574098072052001,
+        "train samples": 18000,
+        "train time": 29.94875920598861,
+        "eval time": 7.102646674029529,
+        "tokens / sec": 6939.11886534666,
+        "mem allocated avg": 6776485750.784,
+        "mem reserved avg": 14703325609.984,
+        "elapsed time": 790.6740298850345
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.44,
+        "train loss": 0.6505107415914535,
+        "train samples": 19000,
+        "train time": 30.134280904079787,
+        "eval time": 7.6594287430052646,
+        "tokens / sec": 6966.783135401682,
+        "mem allocated avg": 6779605635.072,
+        "mem reserved avg": 14800801234.944,
+        "elapsed time": 832.055415440991
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.38,
+        "train loss": 0.6568637717962265,
+        "train samples": 20000,
+        "train time": 29.94096938223811,
+        "eval time": 9.314888863998931,
+        "tokens / sec": 6956.354596974339,
+        "mem allocated avg": 6776251918.336,
+        "mem reserved avg": 14395312701.44,
+        "elapsed time": 874.9385239290423
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.41243366186504926,
+        "train loss": 0.6568637717962265,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.2050151824951172
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/lily--llama-3.2-3B-rank140-mlp-a2-b2-s8.0.json b/method_comparison/MetaMathQA/results/lily--llama-3.2-3B-rank140-mlp-a2-b2-s8.0.json
new file mode 100644
index 0000000..1645873
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/lily--llama-3.2-3B-rank140-mlp-a2-b2-s8.0.json
@@ -0,0 +1,356 @@
+{
+  "run_info": {
+    "created_at": "2026-04-14T15:25:22+00:00",
+    "total_time": 1508.5701706959953,
+    "experiment_name": "lily/llama-3.2-3B-rank140-mlp-a2-b2-s8.0",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null,
+      "init_kv_cache_prefix": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "LILY",
+      "auto_mapping": null,
+      "peft_version": "0.18.2.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 140,
+      "stride_A": 14,
+      "num_B": 2,
+      "scaling": 8.0,
+      "target_modules": [
+        "gate_proj",
+        "up_proj",
+        "down_proj"
+      ],
+      "exclude_modules": null,
+      "modules_to_save": null,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "init_weights": true
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 15918990517,
+    "accelerator_memory_max": 25620905984,
+    "accelerator_memory_reserved_99th": 22953328640,
+    "train_time": 1277.8012849430233,
+    "file_size": 835056616,
+    "num_trainable_params": 9485280,
+    "num_total_params": 3222235104,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.38,
+        "train loss": 0.8256735709905625,
+        "train samples": 1000,
+        "train time": 42.6443230760342,
+        "eval time": 14.504582415000186,
+        "tokens / sec": 4964.763999712415,
+        "mem allocated avg": 6936251998.208,
+        "mem reserved avg": 16089031376.896,
+        "elapsed time": 81.28787563399237
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.34,
+        "train loss": 0.6826477601528168,
+        "train samples": 2000,
+        "train time": 42.2773666617868,
+        "eval time": 14.315907434996916,
+        "tokens / sec": 4919.77188796861,
+        "mem allocated avg": 6928928501.76,
+        "mem reserved avg": 15588214702.08,
+        "elapsed time": 141.77711231099966
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.34,
+        "train loss": 0.6573149716854095,
+        "train samples": 3000,
+        "train time": 43.28126011911081,
+        "eval time": 8.37400708500354,
+        "tokens / sec": 4953.668155917008,
+        "mem allocated avg": 6939525292.032,
+        "mem reserved avg": 15782100598.784,
+        "elapsed time": 197.20532249999815
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.32,
+        "train loss": 0.639818743944168,
+        "train samples": 4000,
+        "train time": 42.61807771808526,
+        "eval time": 8.229445117991418,
+        "tokens / sec": 4888.441974744235,
+        "mem allocated avg": 6930499950.592,
+        "mem reserved avg": 15902594564.096,
+        "elapsed time": 251.91880162298912
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.34,
+        "train loss": 0.6363241444826127,
+        "train samples": 5000,
+        "train time": 42.06402060594701,
+        "eval time": 10.332513002998894,
+        "tokens / sec": 4957.633554661128,
+        "mem allocated avg": 6930508310.528,
+        "mem reserved avg": 15943648411.648,
+        "elapsed time": 308.05530174900196
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.4,
+        "train loss": 0.6253738467693328,
+        "train samples": 6000,
+        "train time": 41.91525867798191,
+        "eval time": 11.934035009995569,
+        "tokens / sec": 4994.147873646825,
+        "mem allocated avg": 6931955746.816,
+        "mem reserved avg": 15847707901.952,
+        "elapsed time": 365.7262236300012
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.38,
+        "train loss": 0.6155040527582168,
+        "train samples": 7000,
+        "train time": 42.188536402158206,
+        "eval time": 10.358341593004297,
+        "tokens / sec": 4962.366980554703,
+        "mem allocated avg": 6933686202.368,
+        "mem reserved avg": 16351930351.616,
+        "elapsed time": 422.08481220700196
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.48,
+        "train loss": 0.6137498723268509,
+        "train samples": 8000,
+        "train time": 42.357142422086326,
+        "eval time": 12.660346331991605,
+        "tokens / sec": 4903.446930633849,
+        "mem allocated avg": 6928296169.472,
+        "mem reserved avg": 15882461904.896,
+        "elapsed time": 480.95308933599154
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.44,
+        "train loss": 0.597766970872879,
+        "train samples": 9000,
+        "train time": 42.931307530001504,
+        "eval time": 14.416990344994701,
+        "tokens / sec": 5006.78903967201,
+        "mem allocated avg": 6940560240.64,
+        "mem reserved avg": 16288529252.352,
+        "elapsed time": 542.1166483720008
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.54,
+        "train loss": 0.5919559133052826,
+        "train samples": 10000,
+        "train time": 41.70843030480319,
+        "eval time": 9.76289252899005,
+        "tokens / sec": 4938.258248867271,
+        "mem allocated avg": 6926012788.736,
+        "mem reserved avg": 15607357505.536,
+        "elapsed time": 597.4219364019955
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.46,
+        "train loss": 0.5769172513484955,
+        "train samples": 11000,
+        "train time": 43.127307615985046,
+        "eval time": 9.960909426998114,
+        "tokens / sec": 4912.919718676497,
+        "mem allocated avg": 6936733149.184,
+        "mem reserved avg": 16094047764.48,
+        "elapsed time": 654.2756872559985
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.52,
+        "train loss": 0.5612472039461136,
+        "train samples": 12000,
+        "train time": 42.239655314959236,
+        "eval time": 11.954717915010406,
+        "tokens / sec": 4941.588619594573,
+        "mem allocated avg": 6931731558.4,
+        "mem reserved avg": 15963353251.84,
+        "elapsed time": 712.3074494850007
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.54,
+        "train loss": 0.5673659546375275,
+        "train samples": 13000,
+        "train time": 42.33562183519825,
+        "eval time": 12.707640161999734,
+        "tokens / sec": 4981.644082635272,
+        "mem allocated avg": 6934144847.872,
+        "mem reserved avg": 15901453713.408,
+        "elapsed time": 770.994042773993
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.66,
+        "train loss": 0.545010736823082,
+        "train samples": 14000,
+        "train time": 42.281060568013345,
+        "eval time": 8.43354035000084,
+        "tokens / sec": 4960.850016110547,
+        "mem allocated avg": 6932022097.92,
+        "mem reserved avg": 15900908453.888,
+        "elapsed time": 825.5365358699928
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.58,
+        "train loss": 0.5402257640361786,
+        "train samples": 15000,
+        "train time": 42.802468458903604,
+        "eval time": 9.628816233001999,
+        "tokens / sec": 5062.862208708018,
+        "mem allocated avg": 6943652876.288,
+        "mem reserved avg": 16252055584.768,
+        "elapsed time": 881.6665664929897
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.56,
+        "train loss": 0.5433241729736328,
+        "train samples": 16000,
+        "train time": 41.81887960090535,
+        "eval time": 14.174946258994169,
+        "tokens / sec": 4887.098888119793,
+        "mem allocated avg": 6923834982.4,
+        "mem reserved avg": 15850375479.296,
+        "elapsed time": 941.5388599899889
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.54,
+        "train loss": 0.5326699557304382,
+        "train samples": 17000,
+        "train time": 42.274479638945195,
+        "eval time": 10.527029891003622,
+        "tokens / sec": 5000.392714597928,
+        "mem allocated avg": 6935376879.616,
+        "mem reserved avg": 15868905914.368,
+        "elapsed time": 998.0180430210021
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.6,
+        "train loss": 0.5365609186887741,
+        "train samples": 18000,
+        "train time": 42.545722530951025,
+        "eval time": 14.54571558299358,
+        "tokens / sec": 4884.580344094926,
+        "mem allocated avg": 6930109265.92,
+        "mem reserved avg": 15868159328.256,
+        "elapsed time": 1058.9818301439955
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.54,
+        "train loss": 0.5245453017950058,
+        "train samples": 19000,
+        "train time": 42.411762549993,
+        "eval time": 9.394262889007223,
+        "tokens / sec": 4950.018282134201,
+        "mem allocated avg": 6932563480.576,
+        "mem reserved avg": 15933733076.992,
+        "elapsed time": 1114.546965069996
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.62,
+        "train loss": 0.5315924286842346,
+        "train samples": 20000,
+        "train time": 42.75402231501357,
+        "eval time": 8.965857996998238,
+        "tokens / sec": 4871.588419573333,
+        "mem allocated avg": 6929910355.968,
+        "mem reserved avg": 15463241220.096,
+        "elapsed time": 1170.1189909499954
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.5489006823351024,
+        "train loss": 0.5315924286842346,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": -0.09576702117919922
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "740312add88f781978c0658806c59bc2815b9866",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "5.5.4",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.0",
+      "peft-commit-hash": "6d5a6f4f2f902dbf13d21d2661d57c3c05df1dae",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/lily--llama-3.2-3B-rank896-a2-b2-s2.0.json b/method_comparison/MetaMathQA/results/lily--llama-3.2-3B-rank896-a2-b2-s2.0.json
new file mode 100644
index 0000000..1789475
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/lily--llama-3.2-3B-rank896-a2-b2-s2.0.json
@@ -0,0 +1,355 @@
+{
+  "run_info": {
+    "created_at": "2026-04-14T15:50:36+00:00",
+    "total_time": 1449.8400646160007,
+    "experiment_name": "lily/llama-3.2-3B-rank896-a2-b2-s2.0",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null,
+      "init_kv_cache_prefix": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "LILY",
+      "auto_mapping": null,
+      "peft_version": "0.18.2.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 896,
+      "stride_A": 14,
+      "num_B": 2,
+      "scaling": 2.0,
+      "target_modules": [
+        "v_proj",
+        "q_proj"
+      ],
+      "exclude_modules": null,
+      "modules_to_save": null,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "init_weights": true
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 15175244788,
+    "accelerator_memory_max": 23517462528,
+    "accelerator_memory_reserved_99th": 21133000704,
+    "train_time": 1232.5725108610059,
+    "file_size": 1439071096,
+    "num_trainable_params": 18450432,
+    "num_total_params": 3231200256,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.36,
+        "train loss": 0.8951853168010712,
+        "train samples": 1000,
+        "train time": 42.645143303932855,
+        "eval time": 13.483017150007072,
+        "tokens / sec": 4964.668508464707,
+        "mem allocated avg": 7077320843.264,
+        "mem reserved avg": 15294512758.784,
+        "elapsed time": 79.54473755300569
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.38,
+        "train loss": 0.7073598281145096,
+        "train samples": 2000,
+        "train time": 41.90585757285589,
+        "eval time": 9.058929259001161,
+        "tokens / sec": 4963.387269629025,
+        "mem allocated avg": 7069815642.112,
+        "mem reserved avg": 14891658248.192,
+        "elapsed time": 134.19524280399492
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.36,
+        "train loss": 0.6779004307985306,
+        "train samples": 3000,
+        "train time": 43.049693761058734,
+        "eval time": 13.401617012001225,
+        "tokens / sec": 4980.314173429492,
+        "mem allocated avg": 7080050778.112,
+        "mem reserved avg": 15128745476.096,
+        "elapsed time": 194.21879527899728
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.3,
+        "train loss": 0.6569800573587418,
+        "train samples": 4000,
+        "train time": 41.5335750940867,
+        "eval time": 8.7474542229902,
+        "tokens / sec": 5016.086371761954,
+        "mem allocated avg": 7071607871.488,
+        "mem reserved avg": 15185737678.848,
+        "elapsed time": 248.1806672149978
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.42,
+        "train loss": 0.6520011286735534,
+        "train samples": 5000,
+        "train time": 41.65768492598727,
+        "eval time": 8.170601553007145,
+        "tokens / sec": 5005.9911003337575,
+        "mem allocated avg": 7072201093.12,
+        "mem reserved avg": 15218872680.448,
+        "elapsed time": 301.5600879370031
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.48,
+        "train loss": 0.6425405044555664,
+        "train samples": 6000,
+        "train time": 42.43562909694447,
+        "eval time": 11.146407181993709,
+        "tokens / sec": 4932.906721419918,
+        "mem allocated avg": 7073242789.888,
+        "mem reserved avg": 15118368768.0,
+        "elapsed time": 358.84500950199435
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.4,
+        "train loss": 0.6329075671434402,
+        "train samples": 7000,
+        "train time": 42.10086405201582,
+        "eval time": 13.399562666003476,
+        "tokens / sec": 4972.700791635556,
+        "mem allocated avg": 7074987571.2,
+        "mem reserved avg": 15549182509.056,
+        "elapsed time": 417.97980555999675
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.38,
+        "train loss": 0.6324304534196854,
+        "train samples": 8000,
+        "train time": 42.159079158023815,
+        "eval time": 13.448914284992497,
+        "tokens / sec": 4926.483313866945,
+        "mem allocated avg": 7069927809.024,
+        "mem reserved avg": 15162618675.2,
+        "elapsed time": 477.34609732399986
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.46,
+        "train loss": 0.6206917855739593,
+        "train samples": 9000,
+        "train time": 43.05002522098948,
+        "eval time": 9.909368462991551,
+        "tokens / sec": 4992.981976122046,
+        "mem allocated avg": 7082264524.8,
+        "mem reserved avg": 15461999706.112,
+        "elapsed time": 533.9334219529992
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.48,
+        "train loss": 0.6139078584909439,
+        "train samples": 10000,
+        "train time": 41.60877637399244,
+        "eval time": 8.158329568002955,
+        "tokens / sec": 4950.085485540489,
+        "mem allocated avg": 7068237475.84,
+        "mem reserved avg": 14934607921.152,
+        "elapsed time": 587.3544365129928
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.44,
+        "train loss": 0.6042117999792099,
+        "train samples": 11000,
+        "train time": 41.9166208460083,
+        "eval time": 10.863204982000752,
+        "tokens / sec": 5054.820634955295,
+        "mem allocated avg": 7077648775.168,
+        "mem reserved avg": 15347738476.544,
+        "elapsed time": 643.6914956859982
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.44,
+        "train loss": 0.5922493088245392,
+        "train samples": 12000,
+        "train time": 41.62047092492867,
+        "eval time": 11.62051810999401,
+        "tokens / sec": 5015.104235040746,
+        "mem allocated avg": 7073923039.232,
+        "mem reserved avg": 15243795234.816,
+        "elapsed time": 700.6200896990049
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.52,
+        "train loss": 0.5992187641859055,
+        "train samples": 13000,
+        "train time": 42.223515122939716,
+        "eval time": 8.044301860005362,
+        "tokens / sec": 4994.870734611555,
+        "mem allocated avg": 7075892357.12,
+        "mem reserved avg": 15047904460.8,
+        "elapsed time": 754.4190594569955
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.54,
+        "train loss": 0.5811601771116257,
+        "train samples": 14000,
+        "train time": 42.35961454302014,
+        "eval time": 13.508444199003861,
+        "tokens / sec": 4951.650345802352,
+        "mem allocated avg": 7073715894.272,
+        "mem reserved avg": 15114635837.44,
+        "elapsed time": 813.9558513039956
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.66,
+        "train loss": 0.5768540184497833,
+        "train samples": 15000,
+        "train time": 43.349727582142805,
+        "eval time": 8.491797911003232,
+        "tokens / sec": 4998.947215743685,
+        "mem allocated avg": 7084721074.176,
+        "mem reserved avg": 15481847152.64,
+        "elapsed time": 869.4534589090035
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.46,
+        "train loss": 0.5858272787332535,
+        "train samples": 16000,
+        "train time": 42.0340883720346,
+        "eval time": 9.063182918995153,
+        "tokens / sec": 4862.077611655066,
+        "mem allocated avg": 7065572147.2,
+        "mem reserved avg": 15137905836.032,
+        "elapsed time": 924.2474565089942
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.54,
+        "train loss": 0.5711492766141891,
+        "train samples": 17000,
+        "train time": 42.32160690399178,
+        "eval time": 8.440006308010197,
+        "tokens / sec": 4994.8245226024665,
+        "mem allocated avg": 7076573898.752,
+        "mem reserved avg": 15096801656.832,
+        "elapsed time": 978.4909052750008
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.48,
+        "train loss": 0.5774585075378418,
+        "train samples": 18000,
+        "train time": 41.511545921996,
+        "eval time": 8.886905466002645,
+        "tokens / sec": 5006.269831302093,
+        "mem allocated avg": 7070892578.816,
+        "mem reserved avg": 15101390225.408,
+        "elapsed time": 1032.6312066489918
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.5,
+        "train loss": 0.5683148888349533,
+        "train samples": 19000,
+        "train time": 42.38187334500253,
+        "eval time": 13.407011750998208,
+        "tokens / sec": 4953.509211143802,
+        "mem allocated avg": 7074292113.408,
+        "mem reserved avg": 15185276305.408,
+        "elapsed time": 1092.0027905040042
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.5,
+        "train loss": 0.5755550808906555,
+        "train samples": 20000,
+        "train time": 41.60871007213427,
+        "eval time": 8.621644578990526,
+        "tokens / sec": 5005.682695736511,
+        "mem allocated avg": 7070758524.928,
+        "mem reserved avg": 14801296162.816,
+        "elapsed time": 1145.8259893009963
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.4973464746019712,
+        "train loss": 0.5755550808906555,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.5971565246582031
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "740312add88f781978c0658806c59bc2815b9866",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "5.5.4",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.0",
+      "peft-commit-hash": "6d5a6f4f2f902dbf13d21d2661d57c3c05df1dae",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/ln_tuning--llama-3.2-3B-default.json b/method_comparison/MetaMathQA/results/ln_tuning--llama-3.2-3B-default.json
new file mode 100644
index 0000000..b52e20d
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/ln_tuning--llama-3.2-3B-default.json
@@ -0,0 +1,348 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T01:02:15+00:00",
+    "total_time": 1158.007769990014,
+    "experiment_name": "ln_tuning/llama-3.2-3B-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "LN_TUNING",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "target_modules": [
+        "norm",
+        "input_layernorm",
+        "post_attention_layernorm"
+      ],
+      "exclude_modules": null,
+      "modules_to_save": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 13811999938,
+    "accelerator_memory_max": 21179138048,
+    "accelerator_memory_reserved_99th": 19146997760,
+    "train_time": 933.4248713181005,
+    "file_size": 358288,
+    "num_trainable_params": 175104,
+    "num_total_params": 3212924928,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.0,
+        "train loss": 1.3265766797065734,
+        "train samples": 1000,
+        "train time": 27.05523074005032,
+        "eval time": 11.134952866006643,
+        "tokens / sec": 7825.436864102909,
+        "mem allocated avg": 6781727356.928,
+        "mem reserved avg": 13917774413.824,
+        "elapsed time": 59.58366395003395
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.0,
+        "train loss": 1.3412033476829528,
+        "train samples": 2000,
+        "train time": 27.19167830166407,
+        "eval time": 11.076495647954289,
+        "tokens / sec": 7649.215237563,
+        "mem allocated avg": 6774720333.824,
+        "mem reserved avg": 13569009647.616,
+        "elapsed time": 100.96434171200963
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.0,
+        "train loss": 1.2789963104724884,
+        "train samples": 3000,
+        "train time": 27.539981623878703,
+        "eval time": 11.047948513005394,
+        "tokens / sec": 7785.081447334822,
+        "mem allocated avg": 6784869052.416,
+        "mem reserved avg": 13769388326.912,
+        "elapsed time": 142.60399866703665
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.0,
+        "train loss": 1.2634205253124238,
+        "train samples": 4000,
+        "train time": 26.802510203735437,
+        "eval time": 11.213655479019508,
+        "tokens / sec": 7773.00329022781,
+        "mem allocated avg": 6775999932.416,
+        "mem reserved avg": 13779588874.24,
+        "elapsed time": 183.79537835903466
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.0,
+        "train loss": 1.2484288651943207,
+        "train samples": 5000,
+        "train time": 26.859816205396783,
+        "eval time": 11.04810167697724,
+        "tokens / sec": 7763.939946770734,
+        "mem allocated avg": 6776329017.344,
+        "mem reserved avg": 13803437686.784,
+        "elapsed time": 224.77404374204343
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.0,
+        "train loss": 1.231340999364853,
+        "train samples": 6000,
+        "train time": 27.544580540037714,
+        "eval time": 11.118913470010739,
+        "tokens / sec": 7599.716383254584,
+        "mem allocated avg": 6778265929.728,
+        "mem reserved avg": 13820894380.032,
+        "elapsed time": 266.58437842602143
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.0,
+        "train loss": 1.2306929278373717,
+        "train samples": 7000,
+        "train time": 27.029298119421583,
+        "eval time": 11.036927138979081,
+        "tokens / sec": 7745.484143725154,
+        "mem allocated avg": 6779571120.128,
+        "mem reserved avg": 14093188595.712,
+        "elapsed time": 307.76138371700654
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.0,
+        "train loss": 1.2307198526859284,
+        "train samples": 8000,
+        "train time": 26.702352902852,
+        "eval time": 11.090556368988473,
+        "tokens / sec": 7778.1909615094855,
+        "mem allocated avg": 6775307636.736,
+        "mem reserved avg": 13810257625.088,
+        "elapsed time": 348.7669416820281
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.0,
+        "train loss": 1.2245776391029357,
+        "train samples": 9000,
+        "train time": 27.69884210533928,
+        "eval time": 11.05135836795671,
+        "tokens / sec": 7760.179980901304,
+        "mem allocated avg": 6785839908.864,
+        "mem reserved avg": 14071948640.256,
+        "elapsed time": 390.5765162970056
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.0,
+        "train loss": 1.2369521839618682,
+        "train samples": 10000,
+        "train time": 27.172044244071003,
+        "eval time": 11.106051086972002,
+        "tokens / sec": 7580.10689773341,
+        "mem allocated avg": 6772880177.152,
+        "mem reserved avg": 13577423421.44,
+        "elapsed time": 431.9964616240468
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.0,
+        "train loss": 1.2313981459140777,
+        "train samples": 11000,
+        "train time": 27.588061350223143,
+        "eval time": 11.063589482975658,
+        "tokens / sec": 7680.1699586725845,
+        "mem allocated avg": 6782132961.28,
+        "mem reserved avg": 13968802316.288,
+        "elapsed time": 473.7305173620116
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.0,
+        "train loss": 1.2322822377681732,
+        "train samples": 12000,
+        "train time": 27.48076619656058,
+        "eval time": 11.10096250998322,
+        "tokens / sec": 7595.53057971594,
+        "mem allocated avg": 6777935728.64,
+        "mem reserved avg": 13851705737.216,
+        "elapsed time": 515.4748477530084
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.0,
+        "train loss": 1.231231040239334,
+        "train samples": 13000,
+        "train time": 27.788235317741055,
+        "eval time": 11.049090766988229,
+        "tokens / sec": 7589.578740372652,
+        "mem allocated avg": 6780943562.752,
+        "mem reserved avg": 13802355556.352,
+        "elapsed time": 557.366414040036
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.0,
+        "train loss": 1.2321618583202363,
+        "train samples": 14000,
+        "train time": 27.022960201604292,
+        "eval time": 11.094650793995243,
+        "tokens / sec": 7761.917955515015,
+        "mem allocated avg": 6777875570.688,
+        "mem reserved avg": 13817966755.84,
+        "elapsed time": 598.6570834580343
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.0,
+        "train loss": 1.215895681142807,
+        "train samples": 15000,
+        "train time": 27.39095462608384,
+        "eval time": 11.043718303029891,
+        "tokens / sec": 7911.4803758478065,
+        "mem allocated avg": 6788866940.928,
+        "mem reserved avg": 14072342904.832,
+        "elapsed time": 640.2053242530092
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.0,
+        "train loss": 1.2472150621414184,
+        "train samples": 16000,
+        "train time": 26.27257864776766,
+        "eval time": 11.109217509045266,
+        "tokens / sec": 7778.947119732583,
+        "mem allocated avg": 6769699028.992,
+        "mem reserved avg": 13815643111.424,
+        "elapsed time": 680.7284473860054
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.0,
+        "train loss": 1.21587810254097,
+        "train samples": 17000,
+        "train time": 26.962625220243353,
+        "eval time": 11.047069397987798,
+        "tokens / sec": 7840.074854480067,
+        "mem allocated avg": 6782053310.464,
+        "mem reserved avg": 13778800345.088,
+        "elapsed time": 721.68619730504
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.0,
+        "train loss": 1.241484440803528,
+        "train samples": 18000,
+        "train time": 26.840785892680287,
+        "eval time": 11.098841341969091,
+        "tokens / sec": 7742.61978881452,
+        "mem allocated avg": 6775733297.152,
+        "mem reserved avg": 13672147582.976,
+        "elapsed time": 762.8068605409935
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.0,
+        "train loss": 1.2253197972774506,
+        "train samples": 19000,
+        "train time": 27.470003902097233,
+        "eval time": 11.055242774018552,
+        "tokens / sec": 7642.481622799185,
+        "mem allocated avg": 6778600820.736,
+        "mem reserved avg": 13782675881.984,
+        "elapsed time": 804.4074719570344
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.0,
+        "train loss": 1.2366444897651672,
+        "train samples": 20000,
+        "train time": 26.569939231791068,
+        "eval time": 11.095670820039231,
+        "tokens / sec": 7838.93399917121,
+        "mem allocated avg": 6775143475.2,
+        "mem reserved avg": 13464646975.488,
+        "elapsed time": 845.1059082580032
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.0,
+        "train loss": 1.2366444897651672,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": -0.032855987548828125
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/loha--llama-3.2-3B-rank32.json b/method_comparison/MetaMathQA/results/loha--llama-3.2-3B-rank32.json
new file mode 100644
index 0000000..85e8cbd
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/loha--llama-3.2-3B-rank32.json
@@ -0,0 +1,357 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T01:21:37+00:00",
+    "total_time": 1723.7877959029865,
+    "experiment_name": "loha/llama-3.2-3B-rank32",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "LOHA",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "rank_pattern": {},
+      "alpha_pattern": {},
+      "r": 32,
+      "alpha": 64,
+      "rank_dropout": 0.0,
+      "module_dropout": 0.0,
+      "use_effective_conv2d": false,
+      "target_modules": [
+        "v_proj",
+        "q_proj"
+      ],
+      "exclude_modules": null,
+      "init_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "modules_to_save": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 16069747225,
+    "accelerator_memory_max": 23907532800,
+    "accelerator_memory_reserved_99th": 21843935232,
+    "train_time": 1444.0684821169707,
+    "file_size": 73429560,
+    "num_trainable_params": 18350080,
+    "num_total_params": 3231099904,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.0,
+        "train loss": 1.2914833612442016,
+        "train samples": 1000,
+        "train time": 48.783409356023185,
+        "eval time": 15.048279424023349,
+        "tokens / sec": 4339.979570818157,
+        "mem allocated avg": 7075144325.12,
+        "mem reserved avg": 16180198768.64,
+        "elapsed time": 89.06116562400712
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.36,
+        "train loss": 0.9051123208999634,
+        "train samples": 2000,
+        "train time": 49.313777334056795,
+        "eval time": 14.961491579946596,
+        "tokens / sec": 4217.786818296632,
+        "mem allocated avg": 7068229634.048,
+        "mem reserved avg": 15816938487.808,
+        "elapsed time": 157.51611204899382
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.32,
+        "train loss": 0.7515957379341125,
+        "train samples": 3000,
+        "train time": 49.29726693738485,
+        "eval time": 10.4420769319986,
+        "tokens / sec": 4349.1457705418525,
+        "mem allocated avg": 7078224801.792,
+        "mem reserved avg": 16001924071.424,
+        "elapsed time": 221.30589306500042
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.44,
+        "train loss": 0.7083757585287094,
+        "train samples": 4000,
+        "train time": 48.992843332118355,
+        "eval time": 15.014163143991027,
+        "tokens / sec": 4252.376180490441,
+        "mem allocated avg": 7069774227.456,
+        "mem reserved avg": 16085097119.744,
+        "elapsed time": 289.58009328099433
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.36,
+        "train loss": 0.6994501632452012,
+        "train samples": 5000,
+        "train time": 48.87461844785139,
+        "eval time": 15.003678467997815,
+        "tokens / sec": 4266.795457902294,
+        "mem allocated avg": 7069489561.6,
+        "mem reserved avg": 16102310543.36,
+        "elapsed time": 357.60247106896713
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.34,
+        "train loss": 0.688896736741066,
+        "train samples": 6000,
+        "train time": 48.57590564060956,
+        "eval time": 10.066342948994134,
+        "tokens / sec": 4309.358667417182,
+        "mem allocated avg": 7071214790.656,
+        "mem reserved avg": 16085852094.464,
+        "elapsed time": 420.47844035195885
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.4,
+        "train loss": 0.6796333414316177,
+        "train samples": 7000,
+        "train time": 49.9453335700091,
+        "eval time": 11.371492591046263,
+        "tokens / sec": 4191.682886781486,
+        "mem allocated avg": 7073070399.488,
+        "mem reserved avg": 16412395438.08,
+        "elapsed time": 485.994160362985
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.42,
+        "train loss": 0.6801165891885758,
+        "train samples": 8000,
+        "train time": 48.455957927857526,
+        "eval time": 15.107590888044797,
+        "tokens / sec": 4286.2840583860325,
+        "mem allocated avg": 7068561985.536,
+        "mem reserved avg": 16088888770.56,
+        "elapsed time": 553.8159226219868
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.38,
+        "train loss": 0.6730777739286423,
+        "train samples": 9000,
+        "train time": 50.08038655488053,
+        "eval time": 15.016238837968558,
+        "tokens / sec": 4292.059522432988,
+        "mem allocated avg": 7080170047.488,
+        "mem reserved avg": 16375955324.928,
+        "elapsed time": 623.1283458310063
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.44,
+        "train loss": 0.6711871980428695,
+        "train samples": 10000,
+        "train time": 48.26023929938674,
+        "eval time": 8.185648262035102,
+        "tokens / sec": 4267.840420812362,
+        "mem allocated avg": 7066054148.096,
+        "mem reserved avg": 15799381131.264,
+        "elapsed time": 683.6707712119678
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.44,
+        "train loss": 0.6645230972766876,
+        "train samples": 11000,
+        "train time": 50.41757245978806,
+        "eval time": 11.489728196000215,
+        "tokens / sec": 4202.522843974521,
+        "mem allocated avg": 7075331424.256,
+        "mem reserved avg": 16211597328.384,
+        "elapsed time": 749.7390187569545
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.4,
+        "train loss": 0.6566754117012024,
+        "train samples": 12000,
+        "train time": 48.205230054212734,
+        "eval time": 14.944865885016043,
+        "tokens / sec": 4330.048830080392,
+        "mem allocated avg": 7070783477.76,
+        "mem reserved avg": 16134405357.568,
+        "elapsed time": 817.0802311009611
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.42,
+        "train loss": 0.6666845008134842,
+        "train samples": 13000,
+        "train time": 48.50475694506895,
+        "eval time": 14.985318146995269,
+        "tokens / sec": 4348.047764445925,
+        "mem allocated avg": 7073913442.304,
+        "mem reserved avg": 16018088919.04,
+        "elapsed time": 884.7171556460089
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.44,
+        "train loss": 0.6538506431579589,
+        "train samples": 14000,
+        "train time": 48.627094919618685,
+        "eval time": 14.961251400003675,
+        "tokens / sec": 4313.438842001972,
+        "mem allocated avg": 7070698022.912,
+        "mem reserved avg": 16014808973.312,
+        "elapsed time": 952.4853859379655
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.44,
+        "train loss": 0.6510264467000961,
+        "train samples": 15000,
+        "train time": 50.97888733900618,
+        "eval time": 15.012431181967258,
+        "tokens / sec": 4250.838166767737,
+        "mem allocated avg": 7083094827.008,
+        "mem reserved avg": 16354790866.944,
+        "elapsed time": 1022.6562416799716
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.46,
+        "train loss": 0.6674902982711792,
+        "train samples": 16000,
+        "train time": 48.719796552322805,
+        "eval time": 15.030813960998785,
+        "tokens / sec": 4194.865628810926,
+        "mem allocated avg": 7063056650.24,
+        "mem reserved avg": 16042550099.968,
+        "elapsed time": 1090.629200581985
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.48,
+        "train loss": 0.6494669053554535,
+        "train samples": 17000,
+        "train time": 50.06373492471175,
+        "eval time": 15.01842499698978,
+        "tokens / sec": 4222.397715989367,
+        "mem allocated avg": 7074535757.824,
+        "mem reserved avg": 15991052435.456,
+        "elapsed time": 1159.7775298539782
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.5,
+        "train loss": 0.658131462097168,
+        "train samples": 18000,
+        "train time": 49.55814389558509,
+        "eval time": 14.973931148997508,
+        "tokens / sec": 4193.417744576054,
+        "mem allocated avg": 7069541146.624,
+        "mem reserved avg": 15961180602.368,
+        "elapsed time": 1228.5485400629696
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.48,
+        "train loss": 0.6511208745241165,
+        "train samples": 19000,
+        "train time": 50.09447881835513,
+        "eval time": 14.996958026022185,
+        "tokens / sec": 4190.861048005878,
+        "mem allocated avg": 7071928455.168,
+        "mem reserved avg": 16052733870.08,
+        "elapsed time": 1297.7279399959953
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.44,
+        "train loss": 0.6570172024965286,
+        "train samples": 20000,
+        "train time": 48.30597296968335,
+        "eval time": 14.95854680496268,
+        "tokens / sec": 4311.682121188528,
+        "mem allocated avg": 7068810864.64,
+        "mem reserved avg": 15664794304.512,
+        "elapsed time": 1365.0393339970033
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.4184988627748294,
+        "train loss": 0.6570172024965286,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.07485389709472656
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/lokr--llama-3.2-3B-rank32.json b/method_comparison/MetaMathQA/results/lokr--llama-3.2-3B-rank32.json
new file mode 100644
index 0000000..5e69d75
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/lokr--llama-3.2-3B-rank32.json
@@ -0,0 +1,360 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T01:50:25+00:00",
+    "total_time": 1535.4195199839887,
+    "experiment_name": "lokr/llama-3.2-3B-rank32",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "LOKR",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "rank_pattern": {},
+      "alpha_pattern": {},
+      "r": 32,
+      "alpha": 64,
+      "rank_dropout": 0.0,
+      "module_dropout": 0.0,
+      "use_effective_conv2d": false,
+      "decompose_both": false,
+      "decompose_factor": -1,
+      "rank_dropout_scale": false,
+      "target_modules": [
+        "q_proj",
+        "v_proj"
+      ],
+      "exclude_modules": null,
+      "init_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "modules_to_save": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 15792361544,
+    "accelerator_memory_max": 23571988480,
+    "accelerator_memory_reserved_99th": 21346910208,
+    "train_time": 1317.615543427004,
+    "file_size": 1131984,
+    "num_trainable_params": 279552,
+    "num_total_params": 3213029376,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.0,
+        "train loss": 1.2610098366737366,
+        "train samples": 1000,
+        "train time": 44.917080010229256,
+        "eval time": 13.230089190998115,
+        "tokens / sec": 4713.552171062408,
+        "mem allocated avg": 6785872599.04,
+        "mem reserved avg": 15919304671.232,
+        "elapsed time": 85.93055745301535
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.36,
+        "train loss": 0.9418223905563354,
+        "train samples": 2000,
+        "train time": 44.39176498691086,
+        "eval time": 13.134529082977679,
+        "tokens / sec": 4685.441096143134,
+        "mem allocated avg": 6778738747.392,
+        "mem reserved avg": 15563761909.76,
+        "elapsed time": 147.61094936099835
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.4,
+        "train loss": 0.7931550116539001,
+        "train samples": 3000,
+        "train time": 45.546711406088434,
+        "eval time": 13.15151729201898,
+        "tokens / sec": 4707.2772848171,
+        "mem allocated avg": 6788886910.976,
+        "mem reserved avg": 15770750812.16,
+        "elapsed time": 210.37875085603446
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.38,
+        "train loss": 0.7486971822977067,
+        "train samples": 4000,
+        "train time": 44.15514894755324,
+        "eval time": 13.2610618310282,
+        "tokens / sec": 4718.271933528252,
+        "mem allocated avg": 6779705090.048,
+        "mem reserved avg": 15782125764.608,
+        "elapsed time": 272.00523140100995
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.34,
+        "train loss": 0.7329185563325882,
+        "train samples": 5000,
+        "train time": 44.73619283729931,
+        "eval time": 13.166668922000099,
+        "tokens / sec": 4661.505299711804,
+        "mem allocated avg": 6780468045.824,
+        "mem reserved avg": 15823901032.448,
+        "elapsed time": 333.9785253200098
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.32,
+        "train loss": 0.7207690758705139,
+        "train samples": 6000,
+        "train time": 44.514215660397895,
+        "eval time": 13.139724303036928,
+        "tokens / sec": 4702.565166979489,
+        "mem allocated avg": 6781829281.792,
+        "mem reserved avg": 15757807190.016,
+        "elapsed time": 395.81570798699977
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.3,
+        "train loss": 0.7103254743814469,
+        "train samples": 7000,
+        "train time": 45.324679988552816,
+        "eval time": 13.146416853996925,
+        "tokens / sec": 4619.006688031214,
+        "mem allocated avg": 6783828615.168,
+        "mem reserved avg": 16158497439.744,
+        "elapsed time": 458.46547377400566
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.36,
+        "train loss": 0.7092406690120697,
+        "train samples": 8000,
+        "train time": 43.866437830845825,
+        "eval time": 13.131515079992823,
+        "tokens / sec": 4734.735945528569,
+        "mem allocated avg": 6779261771.776,
+        "mem reserved avg": 15762227986.432,
+        "elapsed time": 519.6737852150109
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.4,
+        "train loss": 0.7017901630401612,
+        "train samples": 9000,
+        "train time": 46.34161411313107,
+        "eval time": 9.606278705003206,
+        "tokens / sec": 4638.336495471652,
+        "mem allocated avg": 6790719053.824,
+        "mem reserved avg": 16063865552.896,
+        "elapsed time": 579.7241231160006
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.34,
+        "train loss": 0.7000315390825271,
+        "train samples": 10000,
+        "train time": 43.55846684699645,
+        "eval time": 13.126351199985947,
+        "tokens / sec": 4728.5181253849005,
+        "mem allocated avg": 6776950829.056,
+        "mem reserved avg": 15558267371.52,
+        "elapsed time": 640.5660474800388
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.36,
+        "train loss": 0.6941497979164124,
+        "train samples": 11000,
+        "train time": 45.54542878107168,
+        "eval time": 7.833579002006445,
+        "tokens / sec": 4652.080475923768,
+        "mem allocated avg": 6786488795.136,
+        "mem reserved avg": 15941710643.2,
+        "elapsed time": 698.0084676230326
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.38,
+        "train loss": 0.6868689198493958,
+        "train samples": 12000,
+        "train time": 44.477772765094414,
+        "eval time": 13.114933934004512,
+        "tokens / sec": 4692.928333043902,
+        "mem allocated avg": 6781943875.584,
+        "mem reserved avg": 15848840364.032,
+        "elapsed time": 759.7957223660196
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.36,
+        "train loss": 0.6960364075899124,
+        "train samples": 13000,
+        "train time": 45.38897958409507,
+        "eval time": 8.616416077013128,
+        "tokens / sec": 4646.524375134943,
+        "mem allocated avg": 6784858740.736,
+        "mem reserved avg": 15725200670.72,
+        "elapsed time": 817.8723878910532
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.4,
+        "train loss": 0.6833818035125733,
+        "train samples": 14000,
+        "train time": 43.60606637201272,
+        "eval time": 7.672805098001845,
+        "tokens / sec": 4810.110552292832,
+        "mem allocated avg": 6782173394.944,
+        "mem reserved avg": 15725863370.752,
+        "elapsed time": 873.291599542019
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.36,
+        "train loss": 0.6804632662534714,
+        "train samples": 15000,
+        "train time": 44.50026800244814,
+        "eval time": 8.241878828965127,
+        "tokens / sec": 4869.70100917321,
+        "mem allocated avg": 6793631014.912,
+        "mem reserved avg": 16037810536.448,
+        "elapsed time": 930.1443349370384
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.36,
+        "train loss": 0.6991109738349914,
+        "train samples": 16000,
+        "train time": 42.83764784556115,
+        "eval time": 7.653670433035586,
+        "tokens / sec": 4770.8735254747935,
+        "mem allocated avg": 6774149611.52,
+        "mem reserved avg": 15730233835.52,
+        "elapsed time": 984.7777602920542
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.38,
+        "train loss": 0.6788504232168198,
+        "train samples": 17000,
+        "train time": 44.51924567105016,
+        "eval time": 7.663433300971519,
+        "tokens / sec": 4748.261045614738,
+        "mem allocated avg": 6785154426.88,
+        "mem reserved avg": 15703524507.648,
+        "elapsed time": 1040.9056276420015
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.38,
+        "train loss": 0.6892099533081054,
+        "train samples": 18000,
+        "train time": 44.30832453438779,
+        "eval time": 9.274187314964365,
+        "tokens / sec": 4690.269880069872,
+        "mem allocated avg": 6780451182.592,
+        "mem reserved avg": 15700773044.224,
+        "elapsed time": 1098.7072390830144
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.4,
+        "train loss": 0.6815461959838868,
+        "train samples": 19000,
+        "train time": 43.495211453642696,
+        "eval time": 7.511790357995778,
+        "tokens / sec": 4826.715240222559,
+        "mem allocated avg": 6782852112.384,
+        "mem reserved avg": 15813943754.752,
+        "elapsed time": 1153.775285233045
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.36,
+        "train loss": 0.6875366779565811,
+        "train samples": 20000,
+        "train time": 43.26518003502861,
+        "eval time": 9.198009185027331,
+        "tokens / sec": 4814.032897387025,
+        "mem allocated avg": 6779266990.08,
+        "mem reserved avg": 15458820423.68,
+        "elapsed time": 1210.3138140790397
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.379833206974981,
+        "train loss": 0.6875366779565811,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.3052024841308594
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/lora--llama-3.2-3B-rank10-target-mlp.json b/method_comparison/MetaMathQA/results/lora--llama-3.2-3B-rank10-target-mlp.json
new file mode 100644
index 0000000..d5362fe
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/lora--llama-3.2-3B-rank10-target-mlp.json
@@ -0,0 +1,375 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T02:16:05+00:00",
+    "total_time": 1280.0792806840036,
+    "experiment_name": "lora/llama-3.2-3B-rank10-target-mlp",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": "CAUSAL_LM",
+      "peft_type": "LORA",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 10,
+      "target_modules": [
+        "up_proj",
+        "gate_proj",
+        "down_proj"
+      ],
+      "exclude_modules": null,
+      "lora_alpha": 20,
+      "lora_dropout": 0.0,
+      "fan_in_fan_out": false,
+      "bias": "none",
+      "use_rslora": false,
+      "modules_to_save": null,
+      "init_lora_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "rank_pattern": {},
+      "alpha_pattern": {},
+      "megatron_config": null,
+      "megatron_core": "megatron.core",
+      "trainable_token_indices": null,
+      "loftq_config": {},
+      "eva_config": null,
+      "corda_config": null,
+      "use_dora": false,
+      "alora_invocation_tokens": null,
+      "use_qalora": false,
+      "qalora_group_size": 16,
+      "layer_replication": null,
+      "lora_bias": false,
+      "target_parameters": null,
+      "use_bdlora": null,
+      "arrow_config": null,
+      "ensure_weight_tying": false
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 15498352577,
+    "accelerator_memory_max": 24693964800,
+    "accelerator_memory_reserved_99th": 22066233344,
+    "train_time": 1084.286043549073,
+    "file_size": 37868984,
+    "num_trainable_params": 9461760,
+    "num_total_params": 3222211584,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.28,
+        "train loss": 0.956905131816864,
+        "train samples": 1000,
+        "train time": 34.45501961914124,
+        "eval time": 8.187887417967431,
+        "tokens / sec": 6144.794063108907,
+        "mem allocated avg": 6931928963.072,
+        "mem reserved avg": 15621727191.04,
+        "elapsed time": 66.55439633503556
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.34,
+        "train loss": 0.6960876834392548,
+        "train samples": 2000,
+        "train time": 34.311293395468965,
+        "eval time": 12.610760554962326,
+        "tokens / sec": 6061.998234886334,
+        "mem allocated avg": 6925043042.304,
+        "mem reserved avg": 15157191245.824,
+        "elapsed time": 116.78655780700501
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.4,
+        "train loss": 0.6628184849023819,
+        "train samples": 3000,
+        "train time": 34.70101865468314,
+        "eval time": 7.451941114966758,
+        "tokens / sec": 6178.5217930789795,
+        "mem allocated avg": 6935014987.776,
+        "mem reserved avg": 15434812227.584,
+        "elapsed time": 162.2516898770118
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.42,
+        "train loss": 0.6416039798259735,
+        "train samples": 4000,
+        "train time": 34.48607983236434,
+        "eval time": 6.998231331992429,
+        "tokens / sec": 6041.162144630941,
+        "mem allocated avg": 6926214045.696,
+        "mem reserved avg": 15482434355.2,
+        "elapsed time": 207.0800661740359
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.38,
+        "train loss": 0.6370971938371658,
+        "train samples": 5000,
+        "train time": 34.169997635355685,
+        "eval time": 7.873161940020509,
+        "tokens / sec": 6102.956231528264,
+        "mem allocated avg": 6926345869.312,
+        "mem reserved avg": 15533814579.2,
+        "elapsed time": 252.415388560039
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.5,
+        "train loss": 0.6280006822347641,
+        "train samples": 6000,
+        "train time": 34.276999980502296,
+        "eval time": 8.087436428992078,
+        "tokens / sec": 6107.039709399109,
+        "mem allocated avg": 6927777204.224,
+        "mem reserved avg": 15449374851.072,
+        "elapsed time": 298.10151039704215
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.42,
+        "train loss": 0.6198004070520401,
+        "train samples": 7000,
+        "train time": 34.87267060915474,
+        "eval time": 12.61192423501052,
+        "tokens / sec": 6003.411735981022,
+        "mem allocated avg": 6928959924.224,
+        "mem reserved avg": 15878183714.816,
+        "elapsed time": 348.9116879070061
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.36,
+        "train loss": 0.62178213763237,
+        "train samples": 8000,
+        "train time": 34.02151767432224,
+        "eval time": 7.202711585967336,
+        "tokens / sec": 6104.842293874464,
+        "mem allocated avg": 6924543111.168,
+        "mem reserved avg": 15504924213.248,
+        "elapsed time": 393.50626342202304
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.52,
+        "train loss": 0.6131408748626709,
+        "train samples": 9000,
+        "train time": 34.81766810180852,
+        "eval time": 10.382788593007717,
+        "tokens / sec": 6173.532339141203,
+        "mem allocated avg": 6936508715.008,
+        "mem reserved avg": 15821845823.488,
+        "elapsed time": 441.9828996449942
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.48,
+        "train loss": 0.6092700402736664,
+        "train samples": 10000,
+        "train time": 33.81983969331486,
+        "eval time": 12.668855660012923,
+        "tokens / sec": 6090.123485733533,
+        "mem allocated avg": 6922254147.584,
+        "mem reserved avg": 15216221880.32,
+        "elapsed time": 491.83312584704254
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.52,
+        "train loss": 0.599810087800026,
+        "train samples": 11000,
+        "train time": 34.98453600978246,
+        "eval time": 12.589807912008837,
+        "tokens / sec": 6056.418754296279,
+        "mem allocated avg": 6932940275.712,
+        "mem reserved avg": 15688190132.224,
+        "elapsed time": 542.6733375560143
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.38,
+        "train loss": 0.5911425656080246,
+        "train samples": 12000,
+        "train time": 34.17171706445515,
+        "eval time": 10.20739641803084,
+        "tokens / sec": 6108.297092776719,
+        "mem allocated avg": 6927596806.144,
+        "mem reserved avg": 15592476114.944,
+        "elapsed time": 590.4343665740453
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.48,
+        "train loss": 0.5990802057981491,
+        "train samples": 13000,
+        "train time": 34.13041735702427,
+        "eval time": 9.451952209987212,
+        "tokens / sec": 6179.268123030882,
+        "mem allocated avg": 6930062843.904,
+        "mem reserved avg": 15432622800.896,
+        "elapsed time": 637.2517090940382
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.54,
+        "train loss": 0.5822520101070404,
+        "train samples": 14000,
+        "train time": 34.94589354854543,
+        "eval time": 12.59894744300982,
+        "tokens / sec": 6002.135836321477,
+        "mem allocated avg": 6928036900.864,
+        "mem reserved avg": 15451773992.96,
+        "elapsed time": 688.1364196360228
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.62,
+        "train loss": 0.5812049109935761,
+        "train samples": 15000,
+        "train time": 35.20199201494688,
+        "eval time": 12.605403171968646,
+        "tokens / sec": 6155.986851766434,
+        "mem allocated avg": 6939365515.264,
+        "mem reserved avg": 15827197755.392,
+        "elapsed time": 739.258546972007
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.48,
+        "train loss": 0.5900991085767746,
+        "train samples": 16000,
+        "train time": 33.90330129902577,
+        "eval time": 8.236152897006832,
+        "tokens / sec": 6028.115026245918,
+        "mem allocated avg": 6919923267.584,
+        "mem reserved avg": 15453300719.616,
+        "elapsed time": 784.7485570590361
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.52,
+        "train loss": 0.5774198567867279,
+        "train samples": 17000,
+        "train time": 34.68033379589906,
+        "eval time": 7.178619690006599,
+        "tokens / sec": 6095.356556948615,
+        "mem allocated avg": 6930677893.12,
+        "mem reserved avg": 15433386164.224,
+        "elapsed time": 829.8555172120105
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.5,
+        "train loss": 0.5839589636325836,
+        "train samples": 18000,
+        "train time": 33.97633226803737,
+        "eval time": 7.210191433026921,
+        "tokens / sec": 6116.551909150627,
+        "mem allocated avg": 6925906124.8,
+        "mem reserved avg": 15420786475.008,
+        "elapsed time": 874.4303943190025
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.52,
+        "train loss": 0.575189305305481,
+        "train samples": 19000,
+        "train time": 34.245364292524755,
+        "eval time": 10.291229791007936,
+        "tokens / sec": 6130.435588498806,
+        "mem allocated avg": 6928215662.592,
+        "mem reserved avg": 15476939816.96,
+        "elapsed time": 922.2494909689995
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.5,
+        "train loss": 0.5811728711128235,
+        "train samples": 20000,
+        "train time": 34.228812442102935,
+        "eval time": 8.269593706994783,
+        "tokens / sec": 6084.932112450577,
+        "mem allocated avg": 6926067277.824,
+        "mem reserved avg": 15089847500.8,
+        "elapsed time": 968.0756093530217
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.5109931766489765,
+        "train loss": 0.5811728711128235,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.4244680404663086
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/lora--llama-3.2-3B-rank14-target-mlp-bdlora.json b/method_comparison/MetaMathQA/results/lora--llama-3.2-3B-rank14-target-mlp-bdlora.json
new file mode 100644
index 0000000..a25edbd
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/lora--llama-3.2-3B-rank14-target-mlp-bdlora.json
@@ -0,0 +1,388 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T02:37:29+00:00",
+    "total_time": 1449.8443840030232,
+    "experiment_name": "lora/llama-3.2-3B-rank14-target-mlp-bdlora",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": "CAUSAL_LM",
+      "peft_type": "LORA",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 14,
+      "target_modules": [
+        "gate_proj",
+        "up_proj",
+        "down_proj"
+      ],
+      "exclude_modules": null,
+      "lora_alpha": 28,
+      "lora_dropout": 0.0,
+      "fan_in_fan_out": false,
+      "bias": "none",
+      "use_rslora": false,
+      "modules_to_save": null,
+      "init_lora_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "rank_pattern": {},
+      "alpha_pattern": {},
+      "megatron_config": null,
+      "megatron_core": "megatron.core",
+      "trainable_token_indices": null,
+      "loftq_config": {},
+      "eva_config": null,
+      "corda_config": null,
+      "use_dora": false,
+      "alora_invocation_tokens": null,
+      "use_qalora": false,
+      "qalora_group_size": 16,
+      "layer_replication": null,
+      "lora_bias": false,
+      "target_parameters": null,
+      "use_bdlora": {
+        "target_modules_bd_a": [
+          "o_proj",
+          "down_proj"
+        ],
+        "target_modules_bd_b": [
+          "q_proj",
+          "v_proj",
+          "k_proj",
+          "up_proj",
+          "gate_proj"
+        ],
+        "nblocks": 2
+      },
+      "arrow_config": null,
+      "ensure_weight_tying": false
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 15486387067,
+    "accelerator_memory_max": 24685576192,
+    "accelerator_memory_reserved_99th": 22066233344,
+    "train_time": 1247.0251060129958,
+    "file_size": 33740152,
+    "num_trainable_params": 8429568,
+    "num_total_params": 3221179392,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.38,
+        "train loss": 0.9585020205974579,
+        "train samples": 1000,
+        "train time": 40.947455714514945,
+        "eval time": 9.724019955960102,
+        "tokens / sec": 5170.504401448084,
+        "mem allocated avg": 6915241809.92,
+        "mem reserved avg": 15587350675.456,
+        "elapsed time": 76.15033562999452
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.34,
+        "train loss": 0.6961374168395996,
+        "train samples": 2000,
+        "train time": 40.97218767303275,
+        "eval time": 12.660414524958469,
+        "tokens / sec": 5076.492416266536,
+        "mem allocated avg": 6908625721.344,
+        "mem reserved avg": 15151772205.056,
+        "elapsed time": 133.12352299899794
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.32,
+        "train loss": 0.6627170724868774,
+        "train samples": 3000,
+        "train time": 41.68421668821247,
+        "eval time": 8.807691658032127,
+        "tokens / sec": 5143.45757301057,
+        "mem allocated avg": 6919140038.656,
+        "mem reserved avg": 15427161817.088,
+        "elapsed time": 186.93488279398298
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.44,
+        "train loss": 0.6412999538183213,
+        "train samples": 4000,
+        "train time": 40.972820968716405,
+        "eval time": 15.062458469008561,
+        "tokens / sec": 5084.736541793616,
+        "mem allocated avg": 6909692874.752,
+        "mem reserved avg": 15471554330.624,
+        "elapsed time": 246.33008374396013
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.4,
+        "train loss": 0.6367096021175385,
+        "train samples": 5000,
+        "train time": 40.94994170789141,
+        "eval time": 14.975786323018838,
+        "tokens / sec": 5092.510301664554,
+        "mem allocated avg": 6909957285.888,
+        "mem reserved avg": 15508665532.416,
+        "elapsed time": 305.5784399929689
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.5,
+        "train loss": 0.6278209384679795,
+        "train samples": 6000,
+        "train time": 40.83828021842055,
+        "eval time": 9.454851284972392,
+        "tokens / sec": 5125.852481554279,
+        "mem allocated avg": 6911538085.888,
+        "mem reserved avg": 15441019797.504,
+        "elapsed time": 359.22269572195364
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.42,
+        "train loss": 0.6189806928634644,
+        "train samples": 7000,
+        "train time": 41.167949416907504,
+        "eval time": 8.857150142022874,
+        "tokens / sec": 5085.388098393329,
+        "mem allocated avg": 6912511498.24,
+        "mem reserved avg": 15868285157.376,
+        "elapsed time": 412.59175090299686
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.4,
+        "train loss": 0.6215936172008515,
+        "train samples": 8000,
+        "train time": 39.99366526392987,
+        "eval time": 8.554796635988168,
+        "tokens / sec": 5193.222442338142,
+        "mem allocated avg": 6908099178.496,
+        "mem reserved avg": 15486578327.552,
+        "elapsed time": 464.5223481360008
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.44,
+        "train loss": 0.6134832800626755,
+        "train samples": 9000,
+        "train time": 40.83385715901386,
+        "eval time": 9.429859316034708,
+        "tokens / sec": 5263.965124895172,
+        "mem allocated avg": 6920264648.704,
+        "mem reserved avg": 15807736184.832,
+        "elapsed time": 518.1040934349876
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.42,
+        "train loss": 0.6091812270879745,
+        "train samples": 10000,
+        "train time": 39.71863999107154,
+        "eval time": 9.170394071028568,
+        "tokens / sec": 5185.650869372664,
+        "mem allocated avg": 6906021558.272,
+        "mem reserved avg": 15211985633.28,
+        "elapsed time": 570.3839986599633
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.52,
+        "train loss": 0.6002322329282761,
+        "train samples": 11000,
+        "train time": 40.94364706269698,
+        "eval time": 9.519503901014104,
+        "tokens / sec": 5174.942028870724,
+        "mem allocated avg": 6916685307.904,
+        "mem reserved avg": 15683366682.624,
+        "elapsed time": 624.1543187929783
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.44,
+        "train loss": 0.5916472736597062,
+        "train samples": 12000,
+        "train time": 41.149513348413166,
+        "eval time": 9.368373601988424,
+        "tokens / sec": 5072.50227317814,
+        "mem allocated avg": 6910862186.496,
+        "mem reserved avg": 15584163004.416,
+        "elapsed time": 678.0904719049577
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.52,
+        "train loss": 0.6005176463127136,
+        "train samples": 13000,
+        "train time": 41.157697485759854,
+        "eval time": 9.39710839802865,
+        "tokens / sec": 5124.217652675289,
+        "mem allocated avg": 6913147236.352,
+        "mem reserved avg": 15416206295.04,
+        "elapsed time": 731.8966049049632
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.54,
+        "train loss": 0.5828959219455719,
+        "train samples": 14000,
+        "train time": 40.61929137952393,
+        "eval time": 8.772685625997838,
+        "tokens / sec": 5163.802540034817,
+        "mem allocated avg": 6912162123.776,
+        "mem reserved avg": 15441204346.88,
+        "elapsed time": 784.6333682870027
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.54,
+        "train loss": 0.5827477180957794,
+        "train samples": 15000,
+        "train time": 41.78944715799298,
+        "eval time": 8.540672906965483,
+        "tokens / sec": 5185.591452806565,
+        "mem allocated avg": 6922672640.0,
+        "mem reserved avg": 15820361039.872,
+        "elapsed time": 838.2750829259749
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.56,
+        "train loss": 0.5919854927062989,
+        "train samples": 16000,
+        "train time": 40.357097996922676,
+        "eval time": 8.853416519996244,
+        "tokens / sec": 5064.115363686059,
+        "mem allocated avg": 6903590129.664,
+        "mem reserved avg": 15445197324.288,
+        "elapsed time": 890.848429523001
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.56,
+        "train loss": 0.5791787240505218,
+        "train samples": 17000,
+        "train time": 40.23014218133176,
+        "eval time": 8.847462174016982,
+        "tokens / sec": 5254.492988048452,
+        "mem allocated avg": 6914294579.2,
+        "mem reserved avg": 15425500872.704,
+        "elapsed time": 943.1942599099712
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.5,
+        "train loss": 0.585926919221878,
+        "train samples": 18000,
+        "train time": 39.97698019299423,
+        "eval time": 8.84911245398689,
+        "tokens / sec": 5198.441678104017,
+        "mem allocated avg": 6909213696.0,
+        "mem reserved avg": 15410191663.104,
+        "elapsed time": 995.4117041879799
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.52,
+        "train loss": 0.5774390150308609,
+        "train samples": 19000,
+        "train time": 40.493067349656485,
+        "eval time": 8.984108597971499,
+        "tokens / sec": 5184.566488559207,
+        "mem allocated avg": 6911982841.856,
+        "mem reserved avg": 15462503022.592,
+        "elapsed time": 1048.1989943929948
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.52,
+        "train loss": 0.5829407849311828,
+        "train samples": 20000,
+        "train time": 40.788713948684745,
+        "eval time": 11.74522749998141,
+        "tokens / sec": 5106.314463898809,
+        "mem allocated avg": 6909793161.216,
+        "mem reserved avg": 15076937433.088,
+        "elapsed time": 1104.0808472170029
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.513267626990144,
+        "train loss": 0.5829407849311828,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.38550758361816406
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/lora--llama-3.2-3B-rank32-dora.json b/method_comparison/MetaMathQA/results/lora--llama-3.2-3B-rank32-dora.json
new file mode 100644
index 0000000..e0683eb
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/lora--llama-3.2-3B-rank32-dora.json
@@ -0,0 +1,374 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T03:21:22+00:00",
+    "total_time": 1503.135829265986,
+    "experiment_name": "lora/llama-3.2-3B-rank32-dora",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": "CAUSAL_LM",
+      "peft_type": "LORA",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 32,
+      "target_modules": [
+        "q_proj",
+        "v_proj"
+      ],
+      "exclude_modules": null,
+      "lora_alpha": 64,
+      "lora_dropout": 0.0,
+      "fan_in_fan_out": false,
+      "bias": "none",
+      "use_rslora": false,
+      "modules_to_save": null,
+      "init_lora_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "rank_pattern": {},
+      "alpha_pattern": {},
+      "megatron_config": null,
+      "megatron_core": "megatron.core",
+      "trainable_token_indices": null,
+      "loftq_config": {},
+      "eva_config": null,
+      "corda_config": null,
+      "use_dora": true,
+      "alora_invocation_tokens": null,
+      "use_qalora": false,
+      "qalora_group_size": 16,
+      "layer_replication": null,
+      "lora_bias": false,
+      "target_parameters": null,
+      "use_bdlora": null,
+      "arrow_config": null,
+      "ensure_weight_tying": false
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 15412689371,
+    "accelerator_memory_max": 24547164160,
+    "accelerator_memory_reserved_99th": 22162702336,
+    "train_time": 1216.6712898398982,
+    "file_size": 37181760,
+    "num_trainable_params": 9289728,
+    "num_total_params": 3222039552,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.26,
+        "train loss": 0.9799610931873322,
+        "train samples": 1000,
+        "train time": 35.417795918125194,
+        "eval time": 17.352634231036063,
+        "tokens / sec": 5977.757636003882,
+        "mem allocated avg": 6925407713.28,
+        "mem reserved avg": 15541154611.2,
+        "elapsed time": 75.89598628797103
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.44,
+        "train loss": 0.7162615118026734,
+        "train samples": 2000,
+        "train time": 35.72266378562199,
+        "eval time": 17.35569141904125,
+        "tokens / sec": 5822.494124408378,
+        "mem allocated avg": 6918067554.304,
+        "mem reserved avg": 15118301659.136,
+        "elapsed time": 132.76655074994778
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.46,
+        "train loss": 0.6789851016998291,
+        "train samples": 3000,
+        "train time": 36.546013267710805,
+        "eval time": 11.214822898968123,
+        "tokens / sec": 5866.60433873995,
+        "mem allocated avg": 6928052195.328,
+        "mem reserved avg": 15356437463.04,
+        "elapsed time": 184.19187769596465
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.4,
+        "train loss": 0.6588249838352204,
+        "train samples": 4000,
+        "train time": 36.061139613215346,
+        "eval time": 13.717305009020492,
+        "tokens / sec": 5777.299393046663,
+        "mem allocated avg": 6919732948.992,
+        "mem reserved avg": 15453527212.032,
+        "elapsed time": 237.84873885498382
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.36,
+        "train loss": 0.6543591912984849,
+        "train samples": 5000,
+        "train time": 35.93075305066304,
+        "eval time": 17.338175220997073,
+        "tokens / sec": 5803.886150283504,
+        "mem allocated avg": 6919911497.728,
+        "mem reserved avg": 15469197131.776,
+        "elapsed time": 294.79154046898475
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.4,
+        "train loss": 0.6470256053209305,
+        "train samples": 6000,
+        "train time": 36.02197089209221,
+        "eval time": 17.308061218995135,
+        "tokens / sec": 5811.203407694546,
+        "mem allocated avg": 6921449252.864,
+        "mem reserved avg": 15339878350.848,
+        "elapsed time": 351.9409700029646
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.46,
+        "train loss": 0.6376578369140625,
+        "train samples": 7000,
+        "train time": 36.077694381529,
+        "eval time": 12.42961401498178,
+        "tokens / sec": 5802.892994935542,
+        "mem allocated avg": 6922675496.96,
+        "mem reserved avg": 15837507354.624,
+        "elapsed time": 404.2594750869903
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.38,
+        "train loss": 0.6405653357505798,
+        "train samples": 8000,
+        "train time": 36.009058863681275,
+        "eval time": 11.470333072997164,
+        "tokens / sec": 5767.881931773622,
+        "mem allocated avg": 6919334260.736,
+        "mem reserved avg": 15421482729.472,
+        "elapsed time": 455.6199949949514
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.46,
+        "train loss": 0.6328598493337632,
+        "train samples": 9000,
+        "train time": 36.205427291512024,
+        "eval time": 17.303009946015663,
+        "tokens / sec": 5936.899964453458,
+        "mem allocated avg": 6930608842.752,
+        "mem reserved avg": 15744427360.256,
+        "elapsed time": 512.8717058099573
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.42,
+        "train loss": 0.629319528579712,
+        "train samples": 10000,
+        "train time": 34.97963203344261,
+        "eval time": 17.334575710003264,
+        "tokens / sec": 5888.1980177230935,
+        "mem allocated avg": 6915153993.728,
+        "mem reserved avg": 15108914806.784,
+        "elapsed time": 568.9176407279447
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.34,
+        "train loss": 0.6210904417037963,
+        "train samples": 11000,
+        "train time": 35.76373431546381,
+        "eval time": 14.790576178987976,
+        "tokens / sec": 5924.4652175034535,
+        "mem allocated avg": 6926034331.648,
+        "mem reserved avg": 15580086140.928,
+        "elapsed time": 623.1745745909866
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.42,
+        "train loss": 0.6132080693244935,
+        "train samples": 12000,
+        "train time": 35.911868128867354,
+        "eval time": 14.77954756503459,
+        "tokens / sec": 5812.312499338176,
+        "mem allocated avg": 6920991168.512,
+        "mem reserved avg": 15530618519.552,
+        "elapsed time": 677.7459287579986
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.48,
+        "train loss": 0.6221653089523316,
+        "train samples": 13000,
+        "train time": 35.66093143681064,
+        "eval time": 17.444324638985563,
+        "tokens / sec": 5914.063135835525,
+        "mem allocated avg": 6923086110.72,
+        "mem reserved avg": 15357922246.656,
+        "elapsed time": 734.5032512069447
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.5,
+        "train loss": 0.6054375174045563,
+        "train samples": 14000,
+        "train time": 35.69942569779232,
+        "eval time": 10.496662761026528,
+        "tokens / sec": 5875.444657726555,
+        "mem allocated avg": 6920997902.336,
+        "mem reserved avg": 15300158291.968,
+        "elapsed time": 784.4919563499861
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.54,
+        "train loss": 0.6029420564174652,
+        "train samples": 15000,
+        "train time": 36.43003757862607,
+        "eval time": 12.152991220995318,
+        "tokens / sec": 5948.47039430841,
+        "mem allocated avg": 6933233727.488,
+        "mem reserved avg": 15711619514.368,
+        "elapsed time": 836.8070459629525
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.46,
+        "train loss": 0.616380462884903,
+        "train samples": 16000,
+        "train time": 35.82399892428657,
+        "eval time": 10.243308471050113,
+        "tokens / sec": 5704.918661703261,
+        "mem allocated avg": 6913596911.616,
+        "mem reserved avg": 15358928879.616,
+        "elapsed time": 886.7407023639535
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.5,
+        "train loss": 0.6010915513038635,
+        "train samples": 17000,
+        "train time": 36.03616644133581,
+        "eval time": 17.357441558968276,
+        "tokens / sec": 5866.023522344573,
+        "mem allocated avg": 6924514760.704,
+        "mem reserved avg": 15282240225.28,
+        "elapsed time": 943.718220997951
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.48,
+        "train loss": 0.6073519963026047,
+        "train samples": 18000,
+        "train time": 36.01844966417411,
+        "eval time": 10.97284383297665,
+        "tokens / sec": 5769.765271343896,
+        "mem allocated avg": 6919068428.288,
+        "mem reserved avg": 15324342648.832,
+        "elapsed time": 994.5949146979838
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.48,
+        "train loss": 0.59943410551548,
+        "train samples": 19000,
+        "train time": 36.32360130321467,
+        "eval time": 11.35271465400001,
+        "tokens / sec": 5779.685726850554,
+        "mem allocated avg": 6921889050.624,
+        "mem reserved avg": 15411919716.352,
+        "elapsed time": 1045.9306690069498
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.5,
+        "train loss": 0.6067105796337128,
+        "train samples": 20000,
+        "train time": 35.769867127528414,
+        "eval time": 10.729407122998964,
+        "tokens / sec": 5822.778129352014,
+        "mem allocated avg": 6918440036.352,
+        "mem reserved avg": 15005122560.0,
+        "elapsed time": 1096.1181151779601
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.4799090219863533,
+        "train loss": 0.6067105796337128,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.42719078063964844
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/lora--llama-3.2-3B-rank32-lorafa.json b/method_comparison/MetaMathQA/results/lora--llama-3.2-3B-rank32-lorafa.json
new file mode 100644
index 0000000..77839d7
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/lora--llama-3.2-3B-rank32-lorafa.json
@@ -0,0 +1,376 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T03:46:29+00:00",
+    "total_time": 1342.1041010030312,
+    "experiment_name": "lora/llama-3.2-3B-rank32-lorafa",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "lora-fa",
+      "optimizer_kwargs": {
+        "r": 32,
+        "lora_alpha": 64,
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": "CAUSAL_LM",
+      "peft_type": "LORA",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 32,
+      "target_modules": [
+        "v_proj",
+        "q_proj"
+      ],
+      "exclude_modules": null,
+      "lora_alpha": 64,
+      "lora_dropout": 0.0,
+      "fan_in_fan_out": false,
+      "bias": "none",
+      "use_rslora": false,
+      "modules_to_save": null,
+      "init_lora_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "rank_pattern": {},
+      "alpha_pattern": {},
+      "megatron_config": null,
+      "megatron_core": "megatron.core",
+      "trainable_token_indices": null,
+      "loftq_config": {},
+      "eva_config": null,
+      "corda_config": null,
+      "use_dora": false,
+      "alora_invocation_tokens": null,
+      "use_qalora": false,
+      "qalora_group_size": 16,
+      "layer_replication": null,
+      "lora_bias": false,
+      "target_parameters": null,
+      "use_bdlora": null,
+      "arrow_config": null,
+      "ensure_weight_tying": false
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 13388834091,
+    "accelerator_memory_max": 20206059520,
+    "accelerator_memory_reserved_99th": 18423480320,
+    "train_time": 1120.0941248898162,
+    "file_size": 36715216,
+    "num_trainable_params": 3670016,
+    "num_total_params": 3221924864,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.26,
+        "train loss": 1.1382666566371917,
+        "train samples": 1000,
+        "train time": 38.28122999728657,
+        "eval time": 12.03737130900845,
+        "tokens / sec": 5530.6216653698675,
+        "mem allocated avg": 6860955803.648,
+        "mem reserved avg": 13463397072.896,
+        "elapsed time": 74.45199455297552
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.34,
+        "train loss": 0.8058973848819733,
+        "train samples": 2000,
+        "train time": 38.396226758370176,
+        "eval time": 12.014686524984427,
+        "tokens / sec": 5417.068747638286,
+        "mem allocated avg": 6853930907.648,
+        "mem reserved avg": 13148698443.776,
+        "elapsed time": 127.58669048099546
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.34,
+        "train loss": 0.7258100744485855,
+        "train samples": 3000,
+        "train time": 38.67140380904311,
+        "eval time": 12.018376077001449,
+        "tokens / sec": 5544.174218724985,
+        "mem allocated avg": 6863542669.312,
+        "mem reserved avg": 13364780597.248,
+        "elapsed time": 181.01454636198469
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.36,
+        "train loss": 0.6959180034399033,
+        "train samples": 4000,
+        "train time": 38.689740434405394,
+        "eval time": 12.171833780012093,
+        "tokens / sec": 5384.786707298101,
+        "mem allocated avg": 6854990675.968,
+        "mem reserved avg": 13398603464.704,
+        "elapsed time": 234.65134076797403
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.4,
+        "train loss": 0.6883955686092377,
+        "train samples": 5000,
+        "train time": 37.8607366749784,
+        "eval time": 11.988320239004679,
+        "tokens / sec": 5508.028060579701,
+        "mem allocated avg": 6855320889.344,
+        "mem reserved avg": 13438013145.088,
+        "elapsed time": 287.2428716639988
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.36,
+        "train loss": 0.6802743972539902,
+        "train samples": 6000,
+        "train time": 37.84619458694942,
+        "eval time": 12.051020699029323,
+        "tokens / sec": 5531.097704395993,
+        "mem allocated avg": 6857234538.496,
+        "mem reserved avg": 13349186174.976,
+        "elapsed time": 339.8987459249911
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.44,
+        "train loss": 0.6713488042354584,
+        "train samples": 7000,
+        "train time": 38.03005455125822,
+        "eval time": 6.861379031033721,
+        "tokens / sec": 5504.9881592419,
+        "mem allocated avg": 6858592649.216,
+        "mem reserved avg": 13688270487.552,
+        "elapsed time": 387.54206994600827
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.34,
+        "train loss": 0.6732557244300842,
+        "train samples": 8000,
+        "train time": 37.907950733962934,
+        "eval time": 9.611344902019482,
+        "tokens / sec": 5478.956155071674,
+        "mem allocated avg": 6854296047.616,
+        "mem reserved avg": 13373387309.056,
+        "elapsed time": 437.8645573030226
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.4,
+        "train loss": 0.6658673313856125,
+        "train samples": 9000,
+        "train time": 39.20586472720606,
+        "eval time": 12.025575989042409,
+        "tokens / sec": 5482.54710094027,
+        "mem allocated avg": 6864924219.392,
+        "mem reserved avg": 13638182109.184,
+        "elapsed time": 491.79203153197886
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.4,
+        "train loss": 0.6645902947187424,
+        "train samples": 10000,
+        "train time": 37.9725074750022,
+        "eval time": 12.050091590033844,
+        "tokens / sec": 5424.108485213697,
+        "mem allocated avg": 6851850416.128,
+        "mem reserved avg": 13178209566.72,
+        "elapsed time": 544.5313534020097
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.48,
+        "train loss": 0.6584658966064453,
+        "train samples": 11000,
+        "train time": 38.62057857518084,
+        "eval time": 12.022568356012926,
+        "tokens / sec": 5486.220243633619,
+        "mem allocated avg": 6860907974.656,
+        "mem reserved avg": 13517839138.816,
+        "elapsed time": 597.8993249600171
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.44,
+        "train loss": 0.6503710049390793,
+        "train samples": 12000,
+        "train time": 38.213741579907946,
+        "eval time": 12.023225912998896,
+        "tokens / sec": 5462.197402563343,
+        "mem allocated avg": 6856872128.512,
+        "mem reserved avg": 13452542214.144,
+        "elapsed time": 650.9364468560088
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.48,
+        "train loss": 0.6599701564311982,
+        "train samples": 13000,
+        "train time": 37.91452166024828,
+        "eval time": 11.357707492948975,
+        "tokens / sec": 5562.538857535435,
+        "mem allocated avg": 6859697266.688,
+        "mem reserved avg": 13314373451.776,
+        "elapsed time": 702.8724391320138
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.46,
+        "train loss": 0.646973167181015,
+        "train samples": 14000,
+        "train time": 37.81747335771797,
+        "eval time": 11.383261173032224,
+        "tokens / sec": 5546.377940587435,
+        "mem allocated avg": 6856628082.688,
+        "mem reserved avg": 13340680126.464,
+        "elapsed time": 754.8501812759787
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.38,
+        "train loss": 0.6448353365659714,
+        "train samples": 15000,
+        "train time": 38.43758335191524,
+        "eval time": 11.972405905020423,
+        "tokens / sec": 5637.7894004411255,
+        "mem allocated avg": 6867760596.992,
+        "mem reserved avg": 13645018824.704,
+        "elapsed time": 808.0009117710288
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.42,
+        "train loss": 0.6610955271720886,
+        "train samples": 16000,
+        "train time": 37.65237786894431,
+        "eval time": 11.012930686993059,
+        "tokens / sec": 5427.890921294691,
+        "mem allocated avg": 6848820500.48,
+        "mem reserved avg": 13351971192.832,
+        "elapsed time": 859.4539053810295
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.44,
+        "train loss": 0.6431050715446472,
+        "train samples": 17000,
+        "train time": 38.30668486945797,
+        "eval time": 8.816615463001654,
+        "tokens / sec": 5518.331871326748,
+        "mem allocated avg": 6860700841.984,
+        "mem reserved avg": 13334833266.688,
+        "elapsed time": 909.1930963720079
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.44,
+        "train loss": 0.6520027537345886,
+        "train samples": 18000,
+        "train time": 38.130526454304345,
+        "eval time": 9.092709565011319,
+        "tokens / sec": 5450.173898045947,
+        "mem allocated avg": 6855184822.272,
+        "mem reserved avg": 13305347309.568,
+        "elapsed time": 959.1735217869864
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.44,
+        "train loss": 0.6446634820699692,
+        "train samples": 19000,
+        "train time": 38.61787147738505,
+        "eval time": 9.569177008001134,
+        "tokens / sec": 5436.317227451079,
+        "mem allocated avg": 6857516408.832,
+        "mem reserved avg": 13386364485.632,
+        "elapsed time": 1010.02847156598
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.46,
+        "train loss": 0.6510778307914734,
+        "train samples": 20000,
+        "train time": 38.292791458952706,
+        "eval time": 8.873381062003318,
+        "tokens / sec": 5439.143819621041,
+        "mem allocated avg": 6854407677.952,
+        "mem reserved avg": 13086983454.72,
+        "elapsed time": 1059.891814726987
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.42532221379833207,
+        "train loss": 0.6510778307914734,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.33704090118408203
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/lora--llama-3.2-3B-rank32.json b/method_comparison/MetaMathQA/results/lora--llama-3.2-3B-rank32.json
new file mode 100644
index 0000000..15d77e1
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/lora--llama-3.2-3B-rank32.json
@@ -0,0 +1,374 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T03:01:44+00:00",
+    "total_time": 1173.714544863964,
+    "experiment_name": "lora/llama-3.2-3B-rank32",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": "CAUSAL_LM",
+      "peft_type": "LORA",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 32,
+      "target_modules": [
+        "v_proj",
+        "q_proj"
+      ],
+      "exclude_modules": null,
+      "lora_alpha": 64,
+      "lora_dropout": 0.0,
+      "fan_in_fan_out": false,
+      "bias": "none",
+      "use_rslora": false,
+      "modules_to_save": null,
+      "init_lora_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "rank_pattern": {},
+      "alpha_pattern": {},
+      "megatron_config": null,
+      "megatron_core": "megatron.core",
+      "trainable_token_indices": null,
+      "loftq_config": {},
+      "eva_config": null,
+      "corda_config": null,
+      "use_dora": false,
+      "alora_invocation_tokens": null,
+      "use_qalora": false,
+      "qalora_group_size": 16,
+      "layer_replication": null,
+      "lora_bias": false,
+      "target_parameters": null,
+      "use_bdlora": null,
+      "arrow_config": null,
+      "ensure_weight_tying": false
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 14427567318,
+    "accelerator_memory_max": 22286434304,
+    "accelerator_memory_reserved_99th": 20122173440,
+    "train_time": 958.3276851720293,
+    "file_size": 36715216,
+    "num_trainable_params": 9175040,
+    "num_total_params": 3221924864,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.34,
+        "train loss": 0.9826480431556701,
+        "train samples": 1000,
+        "train time": 29.567459934856743,
+        "eval time": 12.036156770016532,
+        "tokens / sec": 7160.5406912349235,
+        "mem allocated avg": 6927427098.624,
+        "mem reserved avg": 14540435619.84,
+        "elapsed time": 63.864961831015535
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.46,
+        "train loss": 0.7163139179944992,
+        "train samples": 2000,
+        "train time": 29.46686314494582,
+        "eval time": 12.008591033983976,
+        "tokens / sec": 7058.606780670357,
+        "mem allocated avg": 6920238368.768,
+        "mem reserved avg": 14166437920.768,
+        "elapsed time": 108.54651641799137
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.36,
+        "train loss": 0.679160294175148,
+        "train samples": 3000,
+        "train time": 30.308068415150046,
+        "eval time": 9.108271537988912,
+        "tokens / sec": 7074.056883573211,
+        "mem allocated avg": 6930467016.704,
+        "mem reserved avg": 14381723156.48,
+        "elapsed time": 151.1071816039621
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.42,
+        "train loss": 0.6593781963586808,
+        "train samples": 4000,
+        "train time": 30.217666860786267,
+        "eval time": 12.128453835961409,
+        "tokens / sec": 6894.50978991232,
+        "mem allocated avg": 6921353275.392,
+        "mem reserved avg": 14449670881.28,
+        "elapsed time": 196.77825986297103
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.42,
+        "train loss": 0.6545941867828369,
+        "train samples": 5000,
+        "train time": 29.99424036074197,
+        "eval time": 11.980647846998181,
+        "tokens / sec": 6952.601482548144,
+        "mem allocated avg": 6922116595.712,
+        "mem reserved avg": 14466657812.48,
+        "elapsed time": 241.93410539499018
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.38,
+        "train loss": 0.647283132314682,
+        "train samples": 6000,
+        "train time": 30.01751733769197,
+        "eval time": 11.991809643048327,
+        "tokens / sec": 6973.628020101123,
+        "mem allocated avg": 6923839727.616,
+        "mem reserved avg": 14383426043.904,
+        "elapsed time": 287.2019039680017
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.42,
+        "train loss": 0.6378610955476761,
+        "train samples": 7000,
+        "train time": 30.147432959987782,
+        "eval time": 8.299405578000005,
+        "tokens / sec": 6944.372354285015,
+        "mem allocated avg": 6925383284.736,
+        "mem reserved avg": 14772699398.144,
+        "elapsed time": 328.93911194999237
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.36,
+        "train loss": 0.6409116793870926,
+        "train samples": 8000,
+        "train time": 30.117346432991326,
+        "eval time": 11.998839316016529,
+        "tokens / sec": 6896.225086167764,
+        "mem allocated avg": 6921043718.144,
+        "mem reserved avg": 14419597721.6,
+        "elapsed time": 374.35504649899667
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.42,
+        "train loss": 0.633124389886856,
+        "train samples": 9000,
+        "train time": 30.76248943991959,
+        "eval time": 11.96315730799688,
+        "tokens / sec": 6987.340878890907,
+        "mem allocated avg": 6931688802.304,
+        "mem reserved avg": 14696019132.416,
+        "elapsed time": 420.3003967599943
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.42,
+        "train loss": 0.6295496643781662,
+        "train samples": 10000,
+        "train time": 29.52961014426546,
+        "eval time": 12.078024981019553,
+        "tokens / sec": 6974.931229831966,
+        "mem allocated avg": 6918595411.968,
+        "mem reserved avg": 14198885056.512,
+        "elapsed time": 465.105449871975
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.4,
+        "train loss": 0.6213833647966385,
+        "train samples": 11000,
+        "train time": 30.2069385854993,
+        "eval time": 8.256086013978347,
+        "tokens / sec": 7014.3155818416,
+        "mem allocated avg": 6927818975.232,
+        "mem reserved avg": 14563151970.304,
+        "elapsed time": 506.76149754499784
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.48,
+        "train loss": 0.6133703490495682,
+        "train samples": 12000,
+        "train time": 30.294824214477558,
+        "eval time": 12.005937494977843,
+        "tokens / sec": 6889.988815325418,
+        "mem allocated avg": 6924054609.92,
+        "mem reserved avg": 14496630308.864,
+        "elapsed time": 552.3840983010014
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.44,
+        "train loss": 0.6224808418750762,
+        "train samples": 13000,
+        "train time": 29.94148239895003,
+        "eval time": 7.373289940995164,
+        "tokens / sec": 7043.772822931297,
+        "mem allocated avg": 6926655715.328,
+        "mem reserved avg": 14371212230.656,
+        "elapsed time": 592.8639876859961
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.5,
+        "train loss": 0.6059285970926285,
+        "train samples": 14000,
+        "train time": 30.129387284861878,
+        "eval time": 11.973128407029435,
+        "tokens / sec": 6961.6417359202715,
+        "mem allocated avg": 6923676155.904,
+        "mem reserved avg": 14364719448.064,
+        "elapsed time": 638.2131494429777
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.5,
+        "train loss": 0.6033647983074188,
+        "train samples": 15000,
+        "train time": 30.893273340305313,
+        "eval time": 7.364776138972957,
+        "tokens / sec": 7014.569081524799,
+        "mem allocated avg": 6934723543.04,
+        "mem reserved avg": 14704281911.296,
+        "elapsed time": 679.7110908210161
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.42,
+        "train loss": 0.6165854910612106,
+        "train samples": 16000,
+        "train time": 29.51253367715981,
+        "eval time": 12.00497411499964,
+        "tokens / sec": 6924.956096133736,
+        "mem allocated avg": 6915841265.664,
+        "mem reserved avg": 14385749688.32,
+        "elapsed time": 724.5038471769658
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.48,
+        "train loss": 0.601499475479126,
+        "train samples": 17000,
+        "train time": 29.835361877689138,
+        "eval time": 8.425500162993558,
+        "tokens / sec": 7085.183041070353,
+        "mem allocated avg": 6927651903.488,
+        "mem reserved avg": 14371388391.424,
+        "elapsed time": 765.8859701670008
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.48,
+        "train loss": 0.6076976944208146,
+        "train samples": 18000,
+        "train time": 29.980451503419317,
+        "eval time": 11.977038996003103,
+        "tokens / sec": 6931.7835315554885,
+        "mem allocated avg": 6921458522.112,
+        "mem reserved avg": 14316107464.704,
+        "elapsed time": 811.13678931701
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.54,
+        "train loss": 0.5996475745439529,
+        "train samples": 19000,
+        "train time": 30.189162221679,
+        "eval time": 7.3034177150111645,
+        "tokens / sec": 6954.11811889373,
+        "mem allocated avg": 6924435124.224,
+        "mem reserved avg": 14412157026.304,
+        "elapsed time": 851.8043771950179
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.5,
+        "train loss": 0.6068337166309357,
+        "train samples": 20000,
+        "train time": 29.628619944676757,
+        "eval time": 12.001391948957462,
+        "tokens / sec": 7029.689549796961,
+        "mem allocated avg": 6920384235.52,
+        "mem reserved avg": 14090395189.248,
+        "elapsed time": 896.6036795430118
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.49052312357846856,
+        "train loss": 0.6068337166309357,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.4156990051269531
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/lora--llama-3.2-3B-rank64-rslora.json b/method_comparison/MetaMathQA/results/lora--llama-3.2-3B-rank64-rslora.json
new file mode 100644
index 0000000..4e07d97
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/lora--llama-3.2-3B-rank64-rslora.json
@@ -0,0 +1,374 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T04:28:43+00:00",
+    "total_time": 1177.140506102005,
+    "experiment_name": "lora/llama-3.2-3B-rank64-rslora",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": "CAUSAL_LM",
+      "peft_type": "LORA",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 64,
+      "target_modules": [
+        "q_proj",
+        "v_proj"
+      ],
+      "exclude_modules": null,
+      "lora_alpha": 64,
+      "lora_dropout": 0.0,
+      "fan_in_fan_out": false,
+      "bias": "none",
+      "use_rslora": true,
+      "modules_to_save": null,
+      "init_lora_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "rank_pattern": {},
+      "alpha_pattern": {},
+      "megatron_config": null,
+      "megatron_core": "megatron.core",
+      "trainable_token_indices": null,
+      "loftq_config": {},
+      "eva_config": null,
+      "corda_config": null,
+      "use_dora": false,
+      "alora_invocation_tokens": null,
+      "use_qalora": false,
+      "qalora_group_size": 16,
+      "layer_replication": null,
+      "lora_bias": false,
+      "target_parameters": null,
+      "use_bdlora": null,
+      "arrow_config": null,
+      "ensure_weight_tying": false
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 14681817219,
+    "accelerator_memory_max": 22554869760,
+    "accelerator_memory_reserved_99th": 20363345920,
+    "train_time": 982.3692580849747,
+    "file_size": 73415408,
+    "num_trainable_params": 18350080,
+    "num_total_params": 3231099904,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.32,
+        "train loss": 0.8665798449516297,
+        "train samples": 1000,
+        "train time": 30.42884735291591,
+        "eval time": 12.067878839967307,
+        "tokens / sec": 6957.838315216747,
+        "mem allocated avg": 7074216630.272,
+        "mem reserved avg": 14794627219.456,
+        "elapsed time": 65.52868704096181
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.36,
+        "train loss": 0.6969451537132263,
+        "train samples": 2000,
+        "train time": 30.028659706760664,
+        "eval time": 6.849575296975672,
+        "tokens / sec": 6926.549570681369,
+        "mem allocated avg": 7067057743.872,
+        "mem reserved avg": 14420780515.328,
+        "elapsed time": 106.05690014996799
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.42,
+        "train loss": 0.6719447268247605,
+        "train samples": 3000,
+        "train time": 30.664972058671992,
+        "eval time": 12.004266217991244,
+        "tokens / sec": 6991.723311855027,
+        "mem allocated avg": 7077370155.008,
+        "mem reserved avg": 14632534147.072,
+        "elapsed time": 152.2843752449844
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.36,
+        "train loss": 0.652460936665535,
+        "train samples": 4000,
+        "train time": 30.48696271161316,
+        "eval time": 12.170594627968967,
+        "tokens / sec": 6833.609565200806,
+        "mem allocated avg": 7068219230.208,
+        "mem reserved avg": 14705993187.328,
+        "elapsed time": 198.70327374298358
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.4,
+        "train loss": 0.6479703410863876,
+        "train samples": 5000,
+        "train time": 30.378673091356177,
+        "eval time": 12.018067600030918,
+        "tokens / sec": 6864.618456931107,
+        "mem allocated avg": 7068962146.304,
+        "mem reserved avg": 14721814102.016,
+        "elapsed time": 244.72620570997242
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.46,
+        "train loss": 0.6393348515033722,
+        "train samples": 6000,
+        "train time": 30.843879525607917,
+        "eval time": 12.084749042987823,
+        "tokens / sec": 6786.792168157847,
+        "mem allocated avg": 7070648739.84,
+        "mem reserved avg": 14638833991.68,
+        "elapsed time": 291.3573861339828
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.48,
+        "train loss": 0.6295465973615646,
+        "train samples": 7000,
+        "train time": 31.083455514337402,
+        "eval time": 6.925516706018243,
+        "tokens / sec": 6735.255026695277,
+        "mem allocated avg": 7072147429.376,
+        "mem reserved avg": 15031110467.584,
+        "elapsed time": 333.1081438650144
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.48,
+        "train loss": 0.629354835152626,
+        "train samples": 8000,
+        "train time": 30.73974690376781,
+        "eval time": 11.996038755984046,
+        "tokens / sec": 6756.594341853298,
+        "mem allocated avg": 7067883671.552,
+        "mem reserved avg": 14674275860.48,
+        "elapsed time": 379.59074820997193
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.48,
+        "train loss": 0.6158513882160187,
+        "train samples": 9000,
+        "train time": 31.485766681085806,
+        "eval time": 12.010253109037876,
+        "tokens / sec": 6826.8307447353345,
+        "mem allocated avg": 7078482102.272,
+        "mem reserved avg": 14951896842.24,
+        "elapsed time": 426.7389918650151
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.54,
+        "train loss": 0.6116750190258026,
+        "train samples": 10000,
+        "train time": 30.16659908008296,
+        "eval time": 12.012144456035458,
+        "tokens / sec": 6827.650656052461,
+        "mem allocated avg": 7065497255.936,
+        "mem reserved avg": 14441743646.72,
+        "elapsed time": 472.54497441998683
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.52,
+        "train loss": 0.5988917994499207,
+        "train samples": 11000,
+        "train time": 30.42298925470095,
+        "eval time": 8.22808063303819,
+        "tokens / sec": 6964.503002191352,
+        "mem allocated avg": 7074708860.928,
+        "mem reserved avg": 14816605372.416,
+        "elapsed time": 514.8220539310132
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.46,
+        "train loss": 0.5868005758523941,
+        "train samples": 12000,
+        "train time": 30.30703110230388,
+        "eval time": 7.013154852029402,
+        "tokens / sec": 6887.213706133448,
+        "mem allocated avg": 7070749229.056,
+        "mem reserved avg": 14752096976.896,
+        "elapsed time": 555.8788702209713
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.62,
+        "train loss": 0.5923758454322815,
+        "train samples": 13000,
+        "train time": 30.638515021419153,
+        "eval time": 7.016375864041038,
+        "tokens / sec": 6883.525518536415,
+        "mem allocated avg": 7073382963.2,
+        "mem reserved avg": 14626209136.64,
+        "elapsed time": 597.1164690629812
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.54,
+        "train loss": 0.5735730677843094,
+        "train samples": 14000,
+        "train time": 30.935304028331302,
+        "eval time": 12.06780532200355,
+        "tokens / sec": 6780.279250137832,
+        "mem allocated avg": 7070430666.752,
+        "mem reserved avg": 14618080575.488,
+        "elapsed time": 643.7984791700146
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.54,
+        "train loss": 0.5689221447706223,
+        "train samples": 15000,
+        "train time": 31.092261793499347,
+        "eval time": 9.570651119982358,
+        "tokens / sec": 6969.676295640462,
+        "mem allocated avg": 7081445613.568,
+        "mem reserved avg": 14958674837.504,
+        "elapsed time": 688.1187267049681
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.64,
+        "train loss": 0.5762798600196838,
+        "train samples": 16000,
+        "train time": 30.104006341425702,
+        "eval time": 7.257788410002831,
+        "tokens / sec": 6788.897055165882,
+        "mem allocated avg": 7062573928.448,
+        "mem reserved avg": 14642197823.488,
+        "elapsed time": 729.1823095660075
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.66,
+        "train loss": 0.5624099019765854,
+        "train samples": 17000,
+        "train time": 30.637119862483814,
+        "eval time": 7.486830469977576,
+        "tokens / sec": 6899.767372025493,
+        "mem allocated avg": 7074448791.552,
+        "mem reserved avg": 14627375153.152,
+        "elapsed time": 770.8080390199902
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.64,
+        "train loss": 0.568421840429306,
+        "train samples": 18000,
+        "train time": 30.23169072222663,
+        "eval time": 7.723167017975356,
+        "tokens / sec": 6874.177230425627,
+        "mem allocated avg": 7068260964.352,
+        "mem reserved avg": 14572748537.856,
+        "elapsed time": 812.4831150689861
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.7,
+        "train loss": 0.5584498722553253,
+        "train samples": 19000,
+        "train time": 30.594949091493618,
+        "eval time": 7.525550253980327,
+        "tokens / sec": 6861.88427286417,
+        "mem allocated avg": 7071199416.32,
+        "mem reserved avg": 14665811755.008,
+        "elapsed time": 854.1516887749895
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.64,
+        "train loss": 0.5659015461206436,
+        "train samples": 20000,
+        "train time": 30.757398171175737,
+        "eval time": 7.549682089011185,
+        "tokens / sec": 6771.704122723533,
+        "mem allocated avg": 7067111507.968,
+        "mem reserved avg": 14342934233.088,
+        "elapsed time": 896.06547770201
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.5322213798332069,
+        "train loss": 0.5659015461206436,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.6632366180419922
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/lora--llama-3.2-3B-rank64.json b/method_comparison/MetaMathQA/results/lora--llama-3.2-3B-rank64.json
new file mode 100644
index 0000000..f81de42
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/lora--llama-3.2-3B-rank64.json
@@ -0,0 +1,374 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T04:08:56+00:00",
+    "total_time": 1182.5466393660172,
+    "experiment_name": "lora/llama-3.2-3B-rank64",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": "CAUSAL_LM",
+      "peft_type": "LORA",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 64,
+      "target_modules": [
+        "q_proj",
+        "v_proj"
+      ],
+      "exclude_modules": null,
+      "lora_alpha": 128,
+      "lora_dropout": 0.0,
+      "fan_in_fan_out": false,
+      "bias": "none",
+      "use_rslora": false,
+      "modules_to_save": null,
+      "init_lora_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "rank_pattern": {},
+      "alpha_pattern": {},
+      "megatron_config": null,
+      "megatron_core": "megatron.core",
+      "trainable_token_indices": null,
+      "loftq_config": {},
+      "eva_config": null,
+      "corda_config": null,
+      "use_dora": false,
+      "alora_invocation_tokens": null,
+      "use_qalora": false,
+      "qalora_group_size": 16,
+      "layer_replication": null,
+      "lora_bias": false,
+      "target_parameters": null,
+      "use_bdlora": null,
+      "arrow_config": null,
+      "ensure_weight_tying": false
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 14680829879,
+    "accelerator_memory_max": 22554869760,
+    "accelerator_memory_reserved_99th": 20369637376,
+    "train_time": 983.3214389311033,
+    "file_size": 73415408,
+    "num_trainable_params": 18350080,
+    "num_total_params": 3231099904,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.38,
+        "train loss": 0.9425716633796692,
+        "train samples": 1000,
+        "train time": 30.139569386141375,
+        "eval time": 7.757456969993655,
+        "tokens / sec": 7024.619273338111,
+        "mem allocated avg": 7074216630.272,
+        "mem reserved avg": 14794627219.456,
+        "elapsed time": 61.089543453999795
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.4,
+        "train loss": 0.707941146492958,
+        "train samples": 2000,
+        "train time": 30.18722614523722,
+        "eval time": 12.01657494698884,
+        "tokens / sec": 6890.166025831305,
+        "mem allocated avg": 7067018012.672,
+        "mem reserved avg": 14421703262.208,
+        "elapsed time": 106.94860831601545
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.46,
+        "train loss": 0.672982994556427,
+        "train samples": 3000,
+        "train time": 31.17097897437634,
+        "eval time": 8.986971779959276,
+        "tokens / sec": 6878.22478005087,
+        "mem allocated avg": 7077317242.88,
+        "mem reserved avg": 14631695286.272,
+        "elapsed time": 150.70241837605136
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.4,
+        "train loss": 0.6524584344625473,
+        "train samples": 4000,
+        "train time": 30.163662555685733,
+        "eval time": 12.034879773971625,
+        "tokens / sec": 6906.853556506502,
+        "mem allocated avg": 7068152137.728,
+        "mem reserved avg": 14705372430.336,
+        "elapsed time": 196.66190933802864
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.32,
+        "train loss": 0.6483220961093903,
+        "train samples": 5000,
+        "train time": 30.15837659779936,
+        "eval time": 11.979068343993276,
+        "tokens / sec": 6914.762116712108,
+        "mem allocated avg": 7068966111.232,
+        "mem reserved avg": 14721310785.536,
+        "elapsed time": 242.42918774002464
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.42,
+        "train loss": 0.6400836319923401,
+        "train samples": 6000,
+        "train time": 30.463665828632656,
+        "eval time": 12.046926526003517,
+        "tokens / sec": 6871.497382407956,
+        "mem allocated avg": 7070724999.168,
+        "mem reserved avg": 14636988497.92,
+        "elapsed time": 288.6348234670004
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.44,
+        "train loss": 0.6306325042247772,
+        "train samples": 7000,
+        "train time": 30.8206563887652,
+        "eval time": 6.342445521964692,
+        "tokens / sec": 6792.684664441944,
+        "mem allocated avg": 7072154179.584,
+        "mem reserved avg": 15031026581.504,
+        "elapsed time": 329.53624591004336
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.36,
+        "train loss": 0.633572401881218,
+        "train samples": 8000,
+        "train time": 30.76832819468109,
+        "eval time": 12.006199798022863,
+        "tokens / sec": 6750.318011620285,
+        "mem allocated avg": 7067827228.672,
+        "mem reserved avg": 14674108088.32,
+        "elapsed time": 376.048165582004
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.48,
+        "train loss": 0.6247809824943542,
+        "train samples": 9000,
+        "train time": 31.255851800669916,
+        "eval time": 11.957888349017594,
+        "tokens / sec": 6877.048220307755,
+        "mem allocated avg": 7078532499.456,
+        "mem reserved avg": 14951896842.24,
+        "elapsed time": 422.90829164604656
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.46,
+        "train loss": 0.6205553900003433,
+        "train samples": 10000,
+        "train time": 30.488378216978163,
+        "eval time": 12.01241706701694,
+        "tokens / sec": 6755.590557627709,
+        "mem allocated avg": 7065481543.68,
+        "mem reserved avg": 14441408102.4,
+        "elapsed time": 469.04079198202817
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.4,
+        "train loss": 0.6116848350763321,
+        "train samples": 11000,
+        "train time": 30.81134812964592,
+        "eval time": 12.024563168000896,
+        "tokens / sec": 6876.719548539758,
+        "mem allocated avg": 7074637836.288,
+        "mem reserved avg": 14815430967.296,
+        "elapsed time": 515.5033730530413
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.48,
+        "train loss": 0.6029672604799271,
+        "train samples": 12000,
+        "train time": 30.93273847439559,
+        "eval time": 6.518992024997715,
+        "tokens / sec": 6747.899161038586,
+        "mem allocated avg": 7070744289.28,
+        "mem reserved avg": 14750754799.616,
+        "elapsed time": 556.7073722220375
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.5,
+        "train loss": 0.6111509243249893,
+        "train samples": 13000,
+        "train time": 30.533708127739374,
+        "eval time": 12.115831910981797,
+        "tokens / sec": 6907.153206472158,
+        "mem allocated avg": 7073456336.896,
+        "mem reserved avg": 14612535705.6,
+        "elapsed time": 602.9381153370487
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.56,
+        "train loss": 0.593697448015213,
+        "train samples": 14000,
+        "train time": 30.537241372454446,
+        "eval time": 9.105283900978975,
+        "tokens / sec": 6868.662347123506,
+        "mem allocated avg": 7070424858.624,
+        "mem reserved avg": 14616318967.808,
+        "elapsed time": 646.2546505310456
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.56,
+        "train loss": 0.5907982959747314,
+        "train samples": 15000,
+        "train time": 31.559637603582814,
+        "eval time": 8.497839941002894,
+        "tokens / sec": 6866.460341591462,
+        "mem allocated avg": 7081439485.952,
+        "mem reserved avg": 14958674837.504,
+        "elapsed time": 689.9719419340254
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.58,
+        "train loss": 0.6027647771835327,
+        "train samples": 16000,
+        "train time": 29.910713088989723,
+        "eval time": 7.624095275008585,
+        "tokens / sec": 6832.769228602266,
+        "mem allocated avg": 7062505238.528,
+        "mem reserved avg": 14642030051.328,
+        "elapsed time": 731.2170849570539
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.52,
+        "train loss": 0.5883516261577606,
+        "train samples": 17000,
+        "train time": 30.172428335470613,
+        "eval time": 11.343407000007574,
+        "tokens / sec": 7006.0320518349445,
+        "mem allocated avg": 7074408183.808,
+        "mem reserved avg": 14628214013.952,
+        "elapsed time": 776.2375028960523
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.54,
+        "train loss": 0.5942763085365296,
+        "train samples": 18000,
+        "train time": 30.16442324745003,
+        "eval time": 7.2430568499839865,
+        "tokens / sec": 6889.506830453588,
+        "mem allocated avg": 7068303734.784,
+        "mem reserved avg": 14573755170.816,
+        "elapsed time": 817.3560434450046
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.54,
+        "train loss": 0.5860209344625473,
+        "train samples": 19000,
+        "train time": 30.54188258619979,
+        "eval time": 7.178718408977147,
+        "tokens / sec": 6873.806793261001,
+        "mem allocated avg": 7071201742.848,
+        "mem reserved avg": 14665811755.008,
+        "elapsed time": 858.6104542890098
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.54,
+        "train loss": 0.5927872058153153,
+        "train samples": 20000,
+        "train time": 30.322970695851836,
+        "eval time": 7.213035533030052,
+        "tokens / sec": 6868.720155723152,
+        "mem allocated avg": 7067111507.968,
+        "mem reserved avg": 14342934233.088,
+        "elapsed time": 899.7537731120246
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.48142532221379836,
+        "train loss": 0.5927872058153153,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.5590972900390625
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/miss--llama-3.2-3B-bat.json b/method_comparison/MetaMathQA/results/miss--llama-3.2-3B-bat.json
new file mode 100644
index 0000000..5a41505
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/miss--llama-3.2-3B-bat.json
@@ -0,0 +1,354 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T04:48:24+00:00",
+    "total_time": 1721.4078567399993,
+    "experiment_name": "miss/llama-3.2-3B-bat",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "MISS",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 64,
+      "miss_dropout": 0.0,
+      "mini_r": 1,
+      "target_modules": [
+        "v_proj",
+        "q_proj"
+      ],
+      "exclude_modules": null,
+      "init_weights": "bat",
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "bias": "none",
+      "modules_to_save": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 17293963899,
+    "accelerator_memory_max": 25209864192,
+    "accelerator_memory_reserved_99th": 23326621696,
+    "train_time": 1423.5636942129931,
+    "file_size": 29367552,
+    "num_trainable_params": 7340032,
+    "num_total_params": 3220089856,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.36,
+        "train loss": 0.8741254634857177,
+        "train samples": 1000,
+        "train time": 46.8061858395813,
+        "eval time": 14.096318043011706,
+        "tokens / sec": 4523.312382803929,
+        "mem allocated avg": 6899013533.696,
+        "mem reserved avg": 17451592974.336,
+        "elapsed time": 86.06038647796959
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.38,
+        "train loss": 0.6947710816860199,
+        "train samples": 2000,
+        "train time": 46.26122461789055,
+        "eval time": 9.15796463796869,
+        "tokens / sec": 4496.098011196235,
+        "mem allocated avg": 6892333068.288,
+        "mem reserved avg": 17059224223.744,
+        "elapsed time": 146.15365184500115
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.42,
+        "train loss": 0.6673551234006881,
+        "train samples": 3000,
+        "train time": 47.344122322043404,
+        "eval time": 9.78604631399503,
+        "tokens / sec": 4528.5663665196935,
+        "mem allocated avg": 6902329288.704,
+        "mem reserved avg": 17203441172.48,
+        "elapsed time": 207.85480376699707
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.38,
+        "train loss": 0.6479887133836746,
+        "train samples": 4000,
+        "train time": 45.87445053498959,
+        "eval time": 15.653570670983754,
+        "tokens / sec": 4541.438590988614,
+        "mem allocated avg": 6893856186.368,
+        "mem reserved avg": 17297435525.12,
+        "elapsed time": 274.1509896569769
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.38,
+        "train loss": 0.643939706325531,
+        "train samples": 5000,
+        "train time": 46.59595572971739,
+        "eval time": 9.941779709013645,
+        "tokens / sec": 4475.4527884273275,
+        "mem allocated avg": 6894185762.816,
+        "mem reserved avg": 17293979418.624,
+        "elapsed time": 335.32179716200335
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.42,
+        "train loss": 0.636546324968338,
+        "train samples": 6000,
+        "train time": 46.49660485459026,
+        "eval time": 10.256375792028848,
+        "tokens / sec": 4502.070649129005,
+        "mem allocated avg": 6895291287.552,
+        "mem reserved avg": 17267370754.048,
+        "elapsed time": 396.81466775399167
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.46,
+        "train loss": 0.6276157149076462,
+        "train samples": 7000,
+        "train time": 45.90664244216168,
+        "eval time": 17.122960125969257,
+        "tokens / sec": 4560.451143073005,
+        "mem allocated avg": 6897185751.04,
+        "mem reserved avg": 17666676883.456,
+        "elapsed time": 464.545704477001
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.4,
+        "train loss": 0.6279411467313767,
+        "train samples": 8000,
+        "train time": 46.310828003275674,
+        "eval time": 17.158595203014556,
+        "tokens / sec": 4484.825881007983,
+        "mem allocated avg": 6892809709.568,
+        "mem reserved avg": 17283250388.992,
+        "elapsed time": 532.7772233400028
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.44,
+        "train loss": 0.6160788837671279,
+        "train samples": 9000,
+        "train time": 46.55647217790829,
+        "eval time": 17.279317434004042,
+        "tokens / sec": 4616.930577957234,
+        "mem allocated avg": 6904810153.984,
+        "mem reserved avg": 17565350887.424,
+        "elapsed time": 601.2993231709697
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.46,
+        "train loss": 0.6119984414577484,
+        "train samples": 10000,
+        "train time": 45.34805366815999,
+        "eval time": 17.203243199037388,
+        "tokens / sec": 4541.914885855721,
+        "mem allocated avg": 6890310887.424,
+        "mem reserved avg": 17000260698.112,
+        "elapsed time": 668.4959828169667
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.46,
+        "train loss": 0.6004733507633209,
+        "train samples": 11000,
+        "train time": 46.389391683624126,
+        "eval time": 9.513812761986628,
+        "tokens / sec": 4567.44510566186,
+        "mem allocated avg": 6899632867.328,
+        "mem reserved avg": 17449630040.064,
+        "elapsed time": 729.0607163279783
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.54,
+        "train loss": 0.5900258921384811,
+        "train samples": 12000,
+        "train time": 45.66193583566928,
+        "eval time": 17.152980474988,
+        "tokens / sec": 4571.22538017645,
+        "mem allocated avg": 6895528245.248,
+        "mem reserved avg": 17372186411.008,
+        "elapsed time": 796.6476987909991
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.5,
+        "train loss": 0.5992479181289673,
+        "train samples": 13000,
+        "train time": 46.438706652319524,
+        "eval time": 17.12707888399018,
+        "tokens / sec": 4541.491682337064,
+        "mem allocated avg": 6898141349.888,
+        "mem reserved avg": 17236685225.984,
+        "elapsed time": 864.8241676180041
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.5,
+        "train loss": 0.580125424861908,
+        "train samples": 14000,
+        "train time": 45.41073746327311,
+        "eval time": 10.362589209980797,
+        "tokens / sec": 4618.951633842981,
+        "mem allocated avg": 6895632789.504,
+        "mem reserved avg": 17228648939.52,
+        "elapsed time": 925.2799343459774
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.46,
+        "train loss": 0.5769485214948654,
+        "train samples": 15000,
+        "train time": 47.041211065487005,
+        "eval time": 17.174327873974107,
+        "tokens / sec": 4606.662862023757,
+        "mem allocated avg": 6907387170.816,
+        "mem reserved avg": 17589401026.56,
+        "elapsed time": 994.1755958849681
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.48,
+        "train loss": 0.5861251219511032,
+        "train samples": 16000,
+        "train time": 44.97431876306655,
+        "eval time": 17.113029053027276,
+        "tokens / sec": 4544.2155794883,
+        "mem allocated avg": 6887367462.912,
+        "mem reserved avg": 17309741613.056,
+        "elapsed time": 1061.0027105140034
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.52,
+        "train loss": 0.5727652524709701,
+        "train samples": 17000,
+        "train time": 45.65709007618716,
+        "eval time": 17.11248146300204,
+        "tokens / sec": 4629.927129548971,
+        "mem allocated avg": 6898684106.752,
+        "mem reserved avg": 17259015700.48,
+        "elapsed time": 1128.2974988719798
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.48,
+        "train loss": 0.5792552961111068,
+        "train samples": 18000,
+        "train time": 46.35413060814608,
+        "eval time": 17.145976198022254,
+        "tokens / sec": 4483.268206598161,
+        "mem allocated avg": 6893984632.832,
+        "mem reserved avg": 17174450143.232,
+        "elapsed time": 1196.5402560840012
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.44,
+        "train loss": 0.5682005435228348,
+        "train samples": 19000,
+        "train time": 45.35197045758832,
+        "eval time": 17.11697928601643,
+        "tokens / sec": 4629.1042678361255,
+        "mem allocated avg": 6896390144.0,
+        "mem reserved avg": 17273217613.824,
+        "elapsed time": 1263.6123683289625
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.44,
+        "train loss": 0.5761626448631286,
+        "train samples": 20000,
+        "train time": 45.72992003214313,
+        "eval time": 17.19783457898302,
+        "tokens / sec": 4554.567334769052,
+        "mem allocated avg": 6893206769.664,
+        "mem reserved avg": 16897718353.92,
+        "elapsed time": 1331.1372104339534
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.5163002274450341,
+        "train loss": 0.5761626448631286,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.2831449508666992
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/miss--llama-3.2-3B-default.json b/method_comparison/MetaMathQA/results/miss--llama-3.2-3B-default.json
new file mode 100644
index 0000000..97d85d5
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/miss--llama-3.2-3B-default.json
@@ -0,0 +1,354 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T05:17:10+00:00",
+    "total_time": 1145.4119831069838,
+    "experiment_name": "miss/llama-3.2-3B-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "MISS",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 64,
+      "miss_dropout": 0.0,
+      "mini_r": 1,
+      "target_modules": [
+        "v_proj",
+        "q_proj"
+      ],
+      "exclude_modules": null,
+      "init_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "bias": "none",
+      "modules_to_save": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 13443749694,
+    "accelerator_memory_max": 20275265536,
+    "accelerator_memory_reserved_99th": 18498977792,
+    "train_time": 930.4467204429675,
+    "file_size": 29367496,
+    "num_trainable_params": 7340032,
+    "num_total_params": 3220089856,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.4,
+        "train loss": 0.8770495002269745,
+        "train samples": 1000,
+        "train time": 29.581142008537427,
+        "eval time": 11.88444348500343,
+        "tokens / sec": 7157.228748602595,
+        "mem allocated avg": 6897714161.664,
+        "mem reserved avg": 13519852404.736,
+        "elapsed time": 63.32356589497067
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.42,
+        "train loss": 0.6948347247838974,
+        "train samples": 2000,
+        "train time": 28.6214671752532,
+        "eval time": 11.315816484973766,
+        "tokens / sec": 7267.097760097966,
+        "mem allocated avg": 6890609534.976,
+        "mem reserved avg": 13203794821.12,
+        "elapsed time": 105.93744991498534
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.4,
+        "train loss": 0.6675079126358032,
+        "train samples": 3000,
+        "train time": 28.836697526625358,
+        "eval time": 8.011410179024097,
+        "tokens / sec": 7435.005336586838,
+        "mem allocated avg": 6900360769.536,
+        "mem reserved avg": 13417939206.144,
+        "elapsed time": 145.43328489601845
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.36,
+        "train loss": 0.6478000595569611,
+        "train samples": 4000,
+        "train time": 28.465044133423362,
+        "eval time": 7.135868438985199,
+        "tokens / sec": 7319.0120142963,
+        "mem allocated avg": 6891700822.016,
+        "mem reserved avg": 13453288800.256,
+        "elapsed time": 183.82717936398694
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.34,
+        "train loss": 0.644065090060234,
+        "train samples": 5000,
+        "train time": 28.294503198412713,
+        "eval time": 6.2051020989893,
+        "tokens / sec": 7370.265473037135,
+        "mem allocated avg": 6892015517.696,
+        "mem reserved avg": 13493218574.336,
+        "elapsed time": 220.99409208400175
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.5,
+        "train loss": 0.6371824450492859,
+        "train samples": 6000,
+        "train time": 28.5445017926977,
+        "eval time": 7.893026220030151,
+        "tokens / sec": 7333.496360183501,
+        "mem allocated avg": 6894076573.696,
+        "mem reserved avg": 13404207054.848,
+        "elapsed time": 260.1458303320105
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.46,
+        "train loss": 0.6281298241615295,
+        "train samples": 7000,
+        "train time": 28.726283402822446,
+        "eval time": 11.832006459997501,
+        "tokens / sec": 7287.925035907368,
+        "mem allocated avg": 6895286140.928,
+        "mem reserved avg": 13746437095.424,
+        "elapsed time": 303.4682386519853
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.4,
+        "train loss": 0.6284154652357101,
+        "train samples": 8000,
+        "train time": 28.592419658671133,
+        "eval time": 11.856868351984303,
+        "tokens / sec": 7264.023208928129,
+        "mem allocated avg": 6891065575.424,
+        "mem reserved avg": 13428383023.104,
+        "elapsed time": 346.6774228439899
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.44,
+        "train loss": 0.6165187916755677,
+        "train samples": 9000,
+        "train time": 29.799386566970497,
+        "eval time": 11.83944596600486,
+        "tokens / sec": 7213.168617311317,
+        "mem allocated avg": 6901582643.2,
+        "mem reserved avg": 13693672751.104,
+        "elapsed time": 391.026491408993
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.5,
+        "train loss": 0.6125160049200058,
+        "train samples": 10000,
+        "train time": 28.65632294554962,
+        "eval time": 8.679996104969177,
+        "tokens / sec": 7187.488792311613,
+        "mem allocated avg": 6888456951.808,
+        "mem reserved avg": 13231275900.928,
+        "elapsed time": 431.072143708996
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.46,
+        "train loss": 0.6009856187105179,
+        "train samples": 11000,
+        "train time": 28.90840060118353,
+        "eval time": 11.810368279984687,
+        "tokens / sec": 7329.391996571593,
+        "mem allocated avg": 6897535533.056,
+        "mem reserved avg": 13570335047.68,
+        "elapsed time": 474.47477067
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.44,
+        "train loss": 0.5904879401922226,
+        "train samples": 12000,
+        "train time": 28.64282536803512,
+        "eval time": 11.851109263021499,
+        "tokens / sec": 7287.374667756766,
+        "mem allocated avg": 6893574338.56,
+        "mem reserved avg": 13508544561.152,
+        "elapsed time": 517.7344847109634
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.52,
+        "train loss": 0.5999962613582611,
+        "train samples": 13000,
+        "train time": 28.622812291316222,
+        "eval time": 11.942176382988691,
+        "tokens / sec": 7368.283656179534,
+        "mem allocated avg": 6896400535.552,
+        "mem reserved avg": 13368513527.808,
+        "elapsed time": 560.9433922549943
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.54,
+        "train loss": 0.581193753361702,
+        "train samples": 14000,
+        "train time": 28.940197857038584,
+        "eval time": 8.767924475017935,
+        "tokens / sec": 7247.704422621507,
+        "mem allocated avg": 6893331273.728,
+        "mem reserved avg": 13393645797.376,
+        "elapsed time": 601.3920295889839
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.52,
+        "train loss": 0.5779475719928742,
+        "train samples": 15000,
+        "train time": 30.048772321257275,
+        "eval time": 11.848424528026953,
+        "tokens / sec": 7211.708940491347,
+        "mem allocated avg": 6904537260.032,
+        "mem reserved avg": 13701608374.272,
+        "elapsed time": 646.0380702709663
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.5,
+        "train loss": 0.5872079440355301,
+        "train samples": 16000,
+        "train time": 28.764328929479234,
+        "eval time": 11.874075043015182,
+        "tokens / sec": 7105.084930055418,
+        "mem allocated avg": 6885427052.544,
+        "mem reserved avg": 13412377559.04,
+        "elapsed time": 689.4377979059936
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.5,
+        "train loss": 0.5736851218938828,
+        "train samples": 17000,
+        "train time": 29.44270641100593,
+        "eval time": 11.804472424963024,
+        "tokens / sec": 7179.672855107539,
+        "mem allocated avg": 6897404037.12,
+        "mem reserved avg": 13391523479.552,
+        "elapsed time": 733.3348887860193
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.48,
+        "train loss": 0.5799340176582336,
+        "train samples": 18000,
+        "train time": 28.752423408732284,
+        "eval time": 11.81368973600911,
+        "tokens / sec": 7227.842921125195,
+        "mem allocated avg": 6891705860.096,
+        "mem reserved avg": 13364461830.144,
+        "elapsed time": 776.6694126090151
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.46,
+        "train loss": 0.569597121834755,
+        "train samples": 19000,
+        "train time": 28.624554165056907,
+        "eval time": 11.791828219022136,
+        "tokens / sec": 7334.2277678609435,
+        "mem allocated avg": 6894110355.456,
+        "mem reserved avg": 13432342446.08,
+        "elapsed time": 819.7075462730136
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.5,
+        "train loss": 0.5774972836971283,
+        "train samples": 20000,
+        "train time": 28.596162587520666,
+        "eval time": 11.84556078800233,
+        "tokens / sec": 7283.49474732995,
+        "mem allocated avg": 6891173048.32,
+        "mem reserved avg": 13139571638.272,
+        "elapsed time": 862.8139132329961
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.5072024260803639,
+        "train loss": 0.5774972836971283,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.2503843307495117
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/miss--llama-3.2-3B-mini.json b/method_comparison/MetaMathQA/results/miss--llama-3.2-3B-mini.json
new file mode 100644
index 0000000..a96fd99
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/miss--llama-3.2-3B-mini.json
@@ -0,0 +1,354 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T05:36:20+00:00",
+    "total_time": 1164.9662163450266,
+    "experiment_name": "miss/llama-3.2-3B-mini",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "MISS",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 64,
+      "miss_dropout": 0.0,
+      "mini_r": 64,
+      "target_modules": [
+        "v_proj",
+        "q_proj"
+      ],
+      "exclude_modules": null,
+      "init_weights": "mini",
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "bias": "none",
+      "modules_to_save": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 13360508698,
+    "accelerator_memory_max": 20208156672,
+    "accelerator_memory_reserved_99th": 18419286016,
+    "train_time": 965.1716879240121,
+    "file_size": 924568,
+    "num_trainable_params": 229376,
+    "num_total_params": 3212979200,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.36,
+        "train loss": 1.020440380334854,
+        "train samples": 1000,
+        "train time": 29.14442138321465,
+        "eval time": 12.024983258976135,
+        "tokens / sec": 7264.477726839923,
+        "mem allocated avg": 6783826952.192,
+        "mem reserved avg": 13450990321.664,
+        "elapsed time": 63.706338621035684
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.36,
+        "train loss": 0.7482323343753815,
+        "train samples": 2000,
+        "train time": 29.259688968246337,
+        "eval time": 11.94900638400577,
+        "tokens / sec": 7108.58547490794,
+        "mem allocated avg": 6776902322.176,
+        "mem reserved avg": 13124723802.112,
+        "elapsed time": 107.86160998500418
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.32,
+        "train loss": 0.7063661125898362,
+        "train samples": 3000,
+        "train time": 29.166292658483144,
+        "eval time": 7.974753042974044,
+        "tokens / sec": 7350.985691273331,
+        "mem allocated avg": 6786654785.536,
+        "mem reserved avg": 13338851409.92,
+        "elapsed time": 147.86676333699143
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.42,
+        "train loss": 0.688511967420578,
+        "train samples": 4000,
+        "train time": 28.6978243496269,
+        "eval time": 12.130904801015276,
+        "tokens / sec": 7259.644405855755,
+        "mem allocated avg": 6777901023.232,
+        "mem reserved avg": 13356089999.36,
+        "elapsed time": 191.68146110099042
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.3,
+        "train loss": 0.6866365925073624,
+        "train samples": 5000,
+        "train time": 28.645599797542673,
+        "eval time": 11.464701619988773,
+        "tokens / sec": 7279.931349801555,
+        "mem allocated avg": 6778335270.912,
+        "mem reserved avg": 13394157502.464,
+        "elapsed time": 234.6450296450057
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.36,
+        "train loss": 0.6822218251228332,
+        "train samples": 6000,
+        "train time": 29.08336391224293,
+        "eval time": 11.949963599035982,
+        "tokens / sec": 7197.619939414231,
+        "mem allocated avg": 6780129107.968,
+        "mem reserved avg": 13321201778.688,
+        "elapsed time": 278.6094037120347
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.24,
+        "train loss": 0.6754459946155548,
+        "train samples": 7000,
+        "train time": 29.193349240114912,
+        "eval time": 11.136245816014707,
+        "tokens / sec": 7171.325163072516,
+        "mem allocated avg": 6781609465.856,
+        "mem reserved avg": 13660596469.76,
+        "elapsed time": 321.90487952699186
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.34,
+        "train loss": 0.67962717461586,
+        "train samples": 8000,
+        "train time": 29.31439256318845,
+        "eval time": 7.02683376398636,
+        "tokens / sec": 7085.120373969961,
+        "mem allocated avg": 6777150697.472,
+        "mem reserved avg": 13345998503.936,
+        "elapsed time": 361.2144933200325
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.4,
+        "train loss": 0.6712153544425964,
+        "train samples": 9000,
+        "train time": 29.861825554224197,
+        "eval time": 8.035724240005948,
+        "tokens / sec": 7198.086386570357,
+        "mem allocated avg": 6787852380.16,
+        "mem reserved avg": 13611019796.48,
+        "elapsed time": 401.98816647101194
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.32,
+        "train loss": 0.6712795463800431,
+        "train samples": 10000,
+        "train time": 28.831970324506983,
+        "eval time": 7.130053625965957,
+        "tokens / sec": 7143.701858798371,
+        "mem allocated avg": 6774711887.872,
+        "mem reserved avg": 13150376165.376,
+        "elapsed time": 440.8588270440232
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.4,
+        "train loss": 0.663529386639595,
+        "train samples": 11000,
+        "train time": 29.773301075445488,
+        "eval time": 11.953038807027042,
+        "tokens / sec": 7116.476586290984,
+        "mem allocated avg": 6783670095.872,
+        "mem reserved avg": 13488831332.352,
+        "elapsed time": 485.4690147790243
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.3,
+        "train loss": 0.6546721721887588,
+        "train samples": 12000,
+        "train time": 29.324858280131593,
+        "eval time": 6.814812419994269,
+        "tokens / sec": 7117.886061240441,
+        "mem allocated avg": 6779918237.696,
+        "mem reserved avg": 13427518996.48,
+        "elapsed time": 524.5932486919919
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.38,
+        "train loss": 0.6654119681119919,
+        "train samples": 13000,
+        "train time": 29.492643706209492,
+        "eval time": 12.11322735704016,
+        "tokens / sec": 7150.969648597359,
+        "mem allocated avg": 6782518890.496,
+        "mem reserved avg": 13282119254.016,
+        "elapsed time": 569.0096655500238
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.38,
+        "train loss": 0.6504700319766998,
+        "train samples": 14000,
+        "train time": 29.362759083742276,
+        "eval time": 10.022665730968583,
+        "tokens / sec": 7143.402273669011,
+        "mem allocated avg": 6779553323.008,
+        "mem reserved avg": 13312653787.136,
+        "elapsed time": 611.3592632650398
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.34,
+        "train loss": 0.6487009708881378,
+        "train samples": 15000,
+        "train time": 29.566806230286602,
+        "eval time": 11.986386795993894,
+        "tokens / sec": 7329.2664182992285,
+        "mem allocated avg": 6790642272.256,
+        "mem reserved avg": 13618812813.312,
+        "elapsed time": 655.834033236024
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.32,
+        "train loss": 0.6651566809415818,
+        "train samples": 16000,
+        "train time": 28.500502578506712,
+        "eval time": 6.6941377419861965,
+        "tokens / sec": 7170.856002873622,
+        "mem allocated avg": 6771731691.52,
+        "mem reserved avg": 13326276886.528,
+        "elapsed time": 693.9715984800132
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.32,
+        "train loss": 0.6470119653940201,
+        "train samples": 17000,
+        "train time": 28.92905807477655,
+        "eval time": 9.46098636800889,
+        "tokens / sec": 7307.15115070793,
+        "mem allocated avg": 6783692464.128,
+        "mem reserved avg": 13309684219.904,
+        "elapsed time": 735.1370009399834
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.36,
+        "train loss": 0.655580215215683,
+        "train samples": 18000,
+        "train time": 29.20642664108891,
+        "eval time": 8.954324702965096,
+        "tokens / sec": 7115.48874341349,
+        "mem allocated avg": 6777984110.592,
+        "mem reserved avg": 13275827798.016,
+        "elapsed time": 776.2690268270089
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.34,
+        "train loss": 0.6466742227077484,
+        "train samples": 19000,
+        "train time": 29.03275447653141,
+        "eval time": 9.065798953990452,
+        "tokens / sec": 7231.108580128142,
+        "mem allocated avg": 6780332462.08,
+        "mem reserved avg": 13353162375.168,
+        "elapsed time": 817.2261539060273
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.3,
+        "train loss": 0.6535704051256179,
+        "train samples": 20000,
+        "train time": 28.70540242100833,
+        "eval time": 8.94265478203306,
+        "tokens / sec": 7255.777046608071,
+        "mem allocated avg": 6777309382.656,
+        "mem reserved avg": 13061280759.808,
+        "elapsed time": 857.7239665249945
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.39423805913570886,
+        "train loss": 0.6535704051256179,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.1832265853881836
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/oft--llama-3.2-3B-rank32.json b/method_comparison/MetaMathQA/results/oft--llama-3.2-3B-rank32.json
new file mode 100644
index 0000000..059b29d
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/oft--llama-3.2-3B-rank32.json
@@ -0,0 +1,360 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T05:55:49+00:00",
+    "total_time": 1348.0078762479825,
+    "experiment_name": "oft/llama-3.2-3B-rank32",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "OFT",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 32,
+      "oft_block_size": 0,
+      "module_dropout": 0.0,
+      "target_modules": [
+        "v_proj",
+        "q_proj"
+      ],
+      "fan_in_fan_out": false,
+      "bias": "none",
+      "exclude_modules": null,
+      "init_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "modules_to_save": null,
+      "coft": false,
+      "eps": 6e-05,
+      "block_share": false,
+      "use_cayley_neumann": true,
+      "num_cayley_neumann_terms": 5
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 14570148069,
+    "accelerator_memory_max": 22315794432,
+    "accelerator_memory_reserved_99th": 20145242112,
+    "train_time": 1118.0740923878038,
+    "file_size": 32693568,
+    "num_trainable_params": 8171520,
+    "num_total_params": 3220921344,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.36,
+        "train loss": 0.9629777348041535,
+        "train samples": 1000,
+        "train time": 34.88295750680845,
+        "eval time": 14.028832973039243,
+        "tokens / sec": 6069.410827871367,
+        "mem allocated avg": 6910183786.496,
+        "mem reserved avg": 14692730798.08,
+        "elapsed time": 71.68712687701918
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.32,
+        "train loss": 0.71439142203331,
+        "train samples": 2000,
+        "train time": 34.68627706926782,
+        "eval time": 8.79689448804129,
+        "tokens / sec": 5996.463661540789,
+        "mem allocated avg": 6902787000.32,
+        "mem reserved avg": 14280673984.512,
+        "elapsed time": 118.46906502003549
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.48,
+        "train loss": 0.6710897196531296,
+        "train samples": 3000,
+        "train time": 35.380497081787325,
+        "eval time": 12.356959308963269,
+        "tokens / sec": 6059.863983945164,
+        "mem allocated avg": 6913287290.88,
+        "mem reserved avg": 14527609438.208,
+        "elapsed time": 169.46450086700497
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.46,
+        "train loss": 0.6509144109487534,
+        "train samples": 4000,
+        "train time": 35.38656886102399,
+        "eval time": 14.169413066993002,
+        "tokens / sec": 5887.431494650181,
+        "mem allocated avg": 6904497004.544,
+        "mem reserved avg": 14534924304.384,
+        "elapsed time": 222.43686137301847
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.36,
+        "train loss": 0.645386314868927,
+        "train samples": 5000,
+        "train time": 34.42120103741763,
+        "eval time": 14.01571749499999,
+        "tokens / sec": 6058.417304303483,
+        "mem allocated avg": 6905021065.216,
+        "mem reserved avg": 14595632660.48,
+        "elapsed time": 274.1503414300387
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.46,
+        "train loss": 0.6368236445188522,
+        "train samples": 6000,
+        "train time": 34.666979860921856,
+        "eval time": 9.192593308980577,
+        "tokens / sec": 6038.339677693329,
+        "mem allocated avg": 6905748031.488,
+        "mem reserved avg": 14529454931.968,
+        "elapsed time": 321.3953521400108
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.5,
+        "train loss": 0.6279961000680924,
+        "train samples": 7000,
+        "train time": 34.723764617112465,
+        "eval time": 11.785299010982271,
+        "tokens / sec": 6029.15617901713,
+        "mem allocated avg": 6907708614.656,
+        "mem reserved avg": 14900634058.752,
+        "elapsed time": 371.2769475780078
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.4,
+        "train loss": 0.6302493048906326,
+        "train samples": 8000,
+        "train time": 34.55560137151042,
+        "eval time": 14.030101582000498,
+        "tokens / sec": 6010.487207762393,
+        "mem allocated avg": 6903469649.92,
+        "mem reserved avg": 14548564180.992,
+        "elapsed time": 423.27879621402826
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.44,
+        "train loss": 0.6211440742015839,
+        "train samples": 9000,
+        "train time": 35.52928709477419,
+        "eval time": 14.005440895038191,
+        "tokens / sec": 6049.882155716418,
+        "mem allocated avg": 6915304634.368,
+        "mem reserved avg": 14843717353.472,
+        "elapsed time": 476.20078854600433
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.42,
+        "train loss": 0.6180904031991958,
+        "train samples": 10000,
+        "train time": 35.02202940842835,
+        "eval time": 14.004316847014707,
+        "tokens / sec": 5881.069814601671,
+        "mem allocated avg": 6900778860.544,
+        "mem reserved avg": 14355215155.2,
+        "elapsed time": 528.5787644560332
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.46,
+        "train loss": 0.6097299265861511,
+        "train samples": 11000,
+        "train time": 35.6146717875381,
+        "eval time": 9.144496340013575,
+        "tokens / sec": 5949.261620716075,
+        "mem allocated avg": 6911029626.88,
+        "mem reserved avg": 14734220853.248,
+        "elapsed time": 576.7091627839836
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.42,
+        "train loss": 0.600579794883728,
+        "train samples": 12000,
+        "train time": 35.16766768670641,
+        "eval time": 14.045691164967138,
+        "tokens / sec": 5935.309724247127,
+        "mem allocated avg": 6906340362.24,
+        "mem reserved avg": 14634706796.544,
+        "elapsed time": 629.347200824006
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.56,
+        "train loss": 0.6099310213327408,
+        "train samples": 13000,
+        "train time": 35.43659597542137,
+        "eval time": 11.369511878991034,
+        "tokens / sec": 5951.502795197366,
+        "mem allocated avg": 6908234280.96,
+        "mem reserved avg": 14499599876.096,
+        "elapsed time": 679.4317268640152
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.5,
+        "train loss": 0.5943480662107468,
+        "train samples": 14000,
+        "train time": 34.85756022395799,
+        "eval time": 8.693275505036581,
+        "tokens / sec": 6017.345983263524,
+        "mem allocated avg": 6906331211.776,
+        "mem reserved avg": 14555694497.792,
+        "elapsed time": 726.3931989329867
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.52,
+        "train loss": 0.5926959769725799,
+        "train samples": 15000,
+        "train time": 35.249166297202464,
+        "eval time": 11.4140949450084,
+        "tokens / sec": 6147.748238153325,
+        "mem allocated avg": 6917726124.032,
+        "mem reserved avg": 14819759489.024,
+        "elapsed time": 776.4263785420335
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.52,
+        "train loss": 0.603757186293602,
+        "train samples": 16000,
+        "train time": 34.53601357748266,
+        "eval time": 8.989645537047181,
+        "tokens / sec": 5917.677775446856,
+        "mem allocated avg": 6898480144.384,
+        "mem reserved avg": 14544931913.728,
+        "elapsed time": 823.3236909009865
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.52,
+        "train loss": 0.5904598969221115,
+        "train samples": 17000,
+        "train time": 34.97911310993368,
+        "eval time": 9.157656271010637,
+        "tokens / sec": 6043.292159399201,
+        "mem allocated avg": 6909286631.424,
+        "mem reserved avg": 14509322272.768,
+        "elapsed time": 870.700260128011
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.54,
+        "train loss": 0.5976542398929596,
+        "train samples": 18000,
+        "train time": 35.34081694687484,
+        "eval time": 9.293714377039578,
+        "tokens / sec": 5880.396039299176,
+        "mem allocated avg": 6904009969.664,
+        "mem reserved avg": 14498240921.6,
+        "elapsed time": 918.7880094650318
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.52,
+        "train loss": 0.5886972019672394,
+        "train samples": 19000,
+        "train time": 35.23478025314398,
+        "eval time": 9.220501197036356,
+        "tokens / sec": 5958.288897836031,
+        "mem allocated avg": 6907173064.704,
+        "mem reserved avg": 14554260045.824,
+        "elapsed time": 966.5027436820092
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.54,
+        "train loss": 0.5947221873998642,
+        "train samples": 20000,
+        "train time": 35.268570395885035,
+        "eval time": 9.204281533020549,
+        "tokens / sec": 5905.541326514927,
+        "mem allocated avg": 6903379494.912,
+        "mem reserved avg": 14243067854.848,
+        "elapsed time": 1014.2827233370044
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.5034116755117514,
+        "train loss": 0.5947221873998642,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.5187549591064453
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/osf--llama-3.2-3B-rank128.json b/method_comparison/MetaMathQA/results/osf--llama-3.2-3B-rank128.json
new file mode 100644
index 0000000..0f28e13
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/osf--llama-3.2-3B-rank128.json
@@ -0,0 +1,362 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T13:52:04+00:00",
+    "total_time": 3564.558626318001,
+    "experiment_name": "osf/llama-3.2-3B-rank128",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 5e-05
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": false,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "OSF",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "effective_rank": null,
+      "target_modules": [
+        "q_proj",
+        "k_proj",
+        "v_proj",
+        "o_proj",
+        "gate_proj",
+        "down_proj",
+        "up_proj"
+      ],
+      "rank_pattern": {
+        "q_proj": 2944,
+        "o_proj": 2944,
+        "k_proj": 896,
+        "v_proj": 896,
+        "gate_proj": 2944,
+        "down_proj": 2944,
+        "up_proj": 2944
+      },
+      "init_weights": null,
+      "modules_to_save": null,
+      "target_svd_config": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 30265093547,
+    "accelerator_memory_max": 38600179712,
+    "accelerator_memory_reserved_99th": 36574330880,
+    "train_time": 2726.1649636220536,
+    "file_size": 389155304,
+    "num_trainable_params": 194535936,
+    "num_total_params": 3407285760,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.36,
+        "train loss": 1.1346645681858063,
+        "train samples": 1000,
+        "train time": 76.96098467695992,
+        "eval time": 44.08565193996765,
+        "tokens / sec": 2750.9913092806755,
+        "mem allocated avg": 16402297032.704,
+        "mem reserved avg": 30341083430.912,
+        "elapsed time": 154.4344606329687
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.4,
+        "train loss": 0.7762473058700562,
+        "train samples": 2000,
+        "train time": 75.26524780492764,
+        "eval time": 43.51324718899559,
+        "tokens / sec": 2763.4931932873073,
+        "mem allocated avg": 16396203208.704,
+        "mem reserved avg": 29951977848.832,
+        "elapsed time": 278.9545994399814
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.32,
+        "train loss": 0.6953379583358764,
+        "train samples": 3000,
+        "train time": 76.63530880311737,
+        "eval time": 42.7298935810104,
+        "tokens / sec": 2797.679077027202,
+        "mem allocated avg": 16407247548.416,
+        "mem reserved avg": 30196337999.872,
+        "elapsed time": 403.9367217730032
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.36,
+        "train loss": 0.6674225121736527,
+        "train samples": 4000,
+        "train time": 74.17853219044628,
+        "eval time": 43.0046770980116,
+        "tokens / sec": 2808.575390318014,
+        "mem allocated avg": 16398045169.664,
+        "mem reserved avg": 30316370591.744,
+        "elapsed time": 527.0352661089855
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.36,
+        "train loss": 0.6617556363344193,
+        "train samples": 5000,
+        "train time": 75.8016281768214,
+        "eval time": 43.36838999501197,
+        "tokens / sec": 2751.101856460739,
+        "mem allocated avg": 16396343963.648,
+        "mem reserved avg": 30267557281.792,
+        "elapsed time": 651.8875343019608
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.4,
+        "train loss": 0.6529131004810333,
+        "train samples": 6000,
+        "train time": 75.09193942596903,
+        "eval time": 30.097449911991134,
+        "tokens / sec": 2787.662718531506,
+        "mem allocated avg": 16399491280.896,
+        "mem reserved avg": 30184493285.376,
+        "elapsed time": 762.9776720659574
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.42,
+        "train loss": 0.6453723709583282,
+        "train samples": 7000,
+        "train time": 75.4158672678168,
+        "eval time": 29.512030549987685,
+        "tokens / sec": 2776.00732557432,
+        "mem allocated avg": 16399573282.816,
+        "mem reserved avg": 30614921150.464,
+        "elapsed time": 873.7585097869742
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.5,
+        "train loss": 0.6473421185016632,
+        "train samples": 8000,
+        "train time": 74.86789236118784,
+        "eval time": 32.70745619904483,
+        "tokens / sec": 2774.166514505374,
+        "mem allocated avg": 16395882827.776,
+        "mem reserved avg": 30363908833.28,
+        "elapsed time": 987.328368842951
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.46,
+        "train loss": 0.6403058428764343,
+        "train samples": 9000,
+        "train time": 76.38718391134171,
+        "eval time": 43.59695099998498,
+        "tokens / sec": 2813.927533308179,
+        "mem allocated avg": 16407910541.312,
+        "mem reserved avg": 30658625798.144,
+        "elapsed time": 1113.1452908439678
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.48,
+        "train loss": 0.6393621402978897,
+        "train samples": 10000,
+        "train time": 75.52950381772825,
+        "eval time": 34.47939619596582,
+        "tokens / sec": 2726.974090774518,
+        "mem allocated avg": 16392402880.512,
+        "mem reserved avg": 29978301300.736,
+        "elapsed time": 1228.9517676229589
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.46,
+        "train loss": 0.6332201733589172,
+        "train samples": 11000,
+        "train time": 76.26470051467186,
+        "eval time": 27.436079355014954,
+        "tokens / sec": 2778.2315877479673,
+        "mem allocated avg": 16403186505.728,
+        "mem reserved avg": 30425330221.056,
+        "elapsed time": 1338.4403797709965
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.48,
+        "train loss": 0.6263919055461884,
+        "train samples": 12000,
+        "train time": 74.40951175126247,
+        "eval time": 29.06353580096038,
+        "tokens / sec": 2805.1655640175404,
+        "mem allocated avg": 16398444703.744,
+        "mem reserved avg": 30332476719.104,
+        "elapsed time": 1447.7839398179785
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.48,
+        "train loss": 0.6381742950677872,
+        "train samples": 13000,
+        "train time": 74.72798433422577,
+        "eval time": 43.305307837959845,
+        "tokens / sec": 2822.2492802258867,
+        "mem allocated avg": 16399888216.064,
+        "mem reserved avg": 30181515329.536,
+        "elapsed time": 1571.4769958669785
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.48,
+        "train loss": 0.6243305860757827,
+        "train samples": 14000,
+        "train time": 76.08441733068321,
+        "eval time": 42.96766831201967,
+        "tokens / sec": 2756.806286474804,
+        "mem allocated avg": 16400161828.864,
+        "mem reserved avg": 30211395551.232,
+        "elapsed time": 1696.4063137219637
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.48,
+        "train loss": 0.6249194881916046,
+        "train samples": 15000,
+        "train time": 76.11614000686677,
+        "eval time": 29.9355729019735,
+        "tokens / sec": 2847.0045903595515,
+        "mem allocated avg": 16410507460.608,
+        "mem reserved avg": 30531127345.152,
+        "elapsed time": 1808.269276439969
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.5,
+        "train loss": 0.6388201580047608,
+        "train samples": 16000,
+        "train time": 76.0119633852737,
+        "eval time": 30.01086129399482,
+        "tokens / sec": 2688.695185573835,
+        "mem allocated avg": 16392468033.536,
+        "mem reserved avg": 30200129650.688,
+        "elapsed time": 1920.24236187496
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.48,
+        "train loss": 0.6239535554647445,
+        "train samples": 17000,
+        "train time": 75.46739184868056,
+        "eval time": 29.885257655987516,
+        "tokens / sec": 2801.064073127841,
+        "mem allocated avg": 16401088077.824,
+        "mem reserved avg": 30233021382.656,
+        "elapsed time": 2031.23209467798
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.48,
+        "train loss": 0.6330795180797577,
+        "train samples": 18000,
+        "train time": 75.55658065743046,
+        "eval time": 43.05317433399614,
+        "tokens / sec": 2750.4950355315286,
+        "mem allocated avg": 16396156147.712,
+        "mem reserved avg": 30183100776.448,
+        "elapsed time": 2155.806646246987
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.5,
+        "train loss": 0.6253060162067413,
+        "train samples": 19000,
+        "train time": 75.05370855727233,
+        "eval time": 30.0452861750382,
+        "tokens / sec": 2797.1835640846284,
+        "mem allocated avg": 16399268433.92,
+        "mem reserved avg": 30276214325.248,
+        "elapsed time": 2266.6352769299992
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.46,
+        "train loss": 0.6309190951585769,
+        "train samples": 20000,
+        "train time": 75.36505703715375,
+        "eval time": 29.40401862899307,
+        "tokens / sec": 2763.6149720860867,
+        "mem allocated avg": 16396532787.2,
+        "mem reserved avg": 29853982130.176,
+        "elapsed time": 2377.1134240519605
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.44579226686884005,
+        "train loss": 0.6309190951585769,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.3507108688354492
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "261366de2e40cde64b702d6b9c527081ad850549",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
diff --git a/method_comparison/MetaMathQA/results/peanut--llama-3.2-3B-rank1-relu-depth0-s32.0.json b/method_comparison/MetaMathQA/results/peanut--llama-3.2-3B-rank1-relu-depth0-s32.0.json
new file mode 100644
index 0000000..a625bf9
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/peanut--llama-3.2-3B-rank1-relu-depth0-s32.0.json
@@ -0,0 +1,355 @@
+{
+  "run_info": {
+    "created_at": "2026-04-14T16:14:51+00:00",
+    "total_time": 1532.0036416129878,
+    "experiment_name": "peanut/llama-3.2-3B-rank1-relu-depth0-s32.0",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null,
+      "init_kv_cache_prefix": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "PEANUT",
+      "auto_mapping": null,
+      "peft_version": "0.18.2.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 1,
+      "depth": 0,
+      "act_fn": "relu",
+      "scaling": 32.0,
+      "target_modules": [
+        "v_proj",
+        "q_proj"
+      ],
+      "exclude_modules": null,
+      "modules_to_save": null,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "init_weights": true
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 17181366550,
+    "accelerator_memory_max": 25142755328,
+    "accelerator_memory_reserved_99th": 22779265024,
+    "train_time": 1293.6483223879623,
+    "file_size": 932264,
+    "num_trainable_params": 229376,
+    "num_total_params": 3212979200,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.34,
+        "train loss": 1.0782873232364654,
+        "train samples": 1000,
+        "train time": 42.55134219395404,
+        "eval time": 13.958351688008406,
+        "tokens / sec": 4975.612732377743,
+        "mem allocated avg": 6785008205.824,
+        "mem reserved avg": 17304003805.184,
+        "elapsed time": 81.30933156199171
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.36,
+        "train loss": 0.755793830871582,
+        "train samples": 2000,
+        "train time": 41.34523496500333,
+        "eval time": 13.814105221012142,
+        "tokens / sec": 5030.688546722672,
+        "mem allocated avg": 6778270351.36,
+        "mem reserved avg": 16942278639.616,
+        "elapsed time": 141.31103577399335
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.34,
+        "train loss": 0.7086091032028198,
+        "train samples": 3000,
+        "train time": 42.28425140600302,
+        "eval time": 13.539051175990608,
+        "tokens / sec": 5070.469332456051,
+        "mem allocated avg": 6788110041.088,
+        "mem reserved avg": 17121434140.672,
+        "elapsed time": 201.85834894300206
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.42,
+        "train loss": 0.687263855099678,
+        "train samples": 4000,
+        "train time": 42.44843867281452,
+        "eval time": 11.434455522001372,
+        "tokens / sec": 4907.9779260155865,
+        "mem allocated avg": 6779349958.656,
+        "mem reserved avg": 17201360797.696,
+        "elapsed time": 260.675236547002
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.42,
+        "train loss": 0.6842224428653717,
+        "train samples": 5000,
+        "train time": 41.416183590044966,
+        "eval time": 12.598084267010563,
+        "tokens / sec": 5035.181465878121,
+        "mem allocated avg": 6779618480.128,
+        "mem reserved avg": 17183191072.768,
+        "elapsed time": 319.43940766299784
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.38,
+        "train loss": 0.6787137789726257,
+        "train samples": 6000,
+        "train time": 41.91785034920031,
+        "eval time": 9.889278128001024,
+        "tokens / sec": 4993.839098526042,
+        "mem allocated avg": 6781385140.224,
+        "mem reserved avg": 17173091188.736,
+        "elapsed time": 376.1354592169955
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.36,
+        "train loss": 0.6703564523458481,
+        "train samples": 7000,
+        "train time": 42.66953206398466,
+        "eval time": 13.807240802008891,
+        "tokens / sec": 4906.428307816074,
+        "mem allocated avg": 6782774999.04,
+        "mem reserved avg": 17526192865.28,
+        "elapsed time": 437.4318203169969
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.44,
+        "train loss": 0.6743507828712464,
+        "train samples": 8000,
+        "train time": 41.605423752000206,
+        "eval time": 8.617376164009329,
+        "tokens / sec": 4992.041452047821,
+        "mem allocated avg": 6778628939.776,
+        "mem reserved avg": 17182201217.024,
+        "elapsed time": 492.59606386999076
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.34,
+        "train loss": 0.6684295483827591,
+        "train samples": 9000,
+        "train time": 43.60937494493555,
+        "eval time": 10.983761402996606,
+        "tokens / sec": 4928.940171039126,
+        "mem allocated avg": 6790529105.92,
+        "mem reserved avg": 17474376433.664,
+        "elapsed time": 551.9724235679896
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.36,
+        "train loss": 0.6670271315574646,
+        "train samples": 10000,
+        "train time": 40.90206856712757,
+        "eval time": 13.784692518005613,
+        "tokens / sec": 5035.6132884079325,
+        "mem allocated avg": 6776260329.472,
+        "mem reserved avg": 16917104427.008,
+        "elapsed time": 611.4947228949895
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.5,
+        "train loss": 0.6589599785804748,
+        "train samples": 11000,
+        "train time": 42.355896609893534,
+        "eval time": 8.928344394007581,
+        "tokens / sec": 5002.396760750157,
+        "mem allocated avg": 6785940545.536,
+        "mem reserved avg": 17310001659.904,
+        "elapsed time": 667.5795067779982
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.34,
+        "train loss": 0.6532612586021423,
+        "train samples": 12000,
+        "train time": 41.950381183982245,
+        "eval time": 13.837643670005491,
+        "tokens / sec": 4975.663965592259,
+        "mem allocated avg": 6781165772.8,
+        "mem reserved avg": 17263159672.832,
+        "elapsed time": 728.2849911759986
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.44,
+        "train loss": 0.6626448401212692,
+        "train samples": 13000,
+        "train time": 42.59864776597533,
+        "eval time": 9.815955368991126,
+        "tokens / sec": 4950.884853402606,
+        "mem allocated avg": 6783855228.928,
+        "mem reserved avg": 17137053728.768,
+        "elapsed time": 785.4447581689892
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.4,
+        "train loss": 0.6481621752977371,
+        "train samples": 14000,
+        "train time": 42.129510829021456,
+        "eval time": 13.821907288001967,
+        "tokens / sec": 4978.695358017569,
+        "mem allocated avg": 6781411620.864,
+        "mem reserved avg": 17163662393.344,
+        "elapsed time": 846.3086622769915
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.4,
+        "train loss": 0.6454143435955048,
+        "train samples": 15000,
+        "train time": 43.71391549293185,
+        "eval time": 13.818641671998193,
+        "tokens / sec": 4957.300153884384,
+        "mem allocated avg": 6793252151.296,
+        "mem reserved avg": 17430436904.96,
+        "elapsed time": 908.7084292200016
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.42,
+        "train loss": 0.6614621320962906,
+        "train samples": 16000,
+        "train time": 41.143020007017185,
+        "eval time": 8.143757469995762,
+        "tokens / sec": 4967.379642163919,
+        "mem allocated avg": 6773322760.192,
+        "mem reserved avg": 17159862353.92,
+        "elapsed time": 962.8818788310018
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.44,
+        "train loss": 0.6446791313886643,
+        "train samples": 17000,
+        "train time": 42.63129717807169,
+        "eval time": 9.233205483993515,
+        "tokens / sec": 4958.5401803990235,
+        "mem allocated avg": 6784610023.424,
+        "mem reserved avg": 17104522706.944,
+        "elapsed time": 1019.3990020450001
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.38,
+        "train loss": 0.6513511871099472,
+        "train samples": 18000,
+        "train time": 42.117793060067925,
+        "eval time": 8.520607718994142,
+        "tokens / sec": 4934.209152497908,
+        "mem allocated avg": 6780054568.96,
+        "mem reserved avg": 17095957938.176,
+        "elapsed time": 1074.9711790169968
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.4,
+        "train loss": 0.6432328459024429,
+        "train samples": 19000,
+        "train time": 42.501656148029724,
+        "eval time": 13.760509013009141,
+        "tokens / sec": 4939.548691203937,
+        "mem allocated avg": 6782216679.424,
+        "mem reserved avg": 17137917755.392,
+        "elapsed time": 1135.984748848001
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.42,
+        "train loss": 0.6497887889146805,
+        "train samples": 20000,
+        "train time": 42.3493788199994,
+        "eval time": 11.90411888899689,
+        "tokens / sec": 4918.135892506651,
+        "mem allocated avg": 6778881710.08,
+        "mem reserved avg": 16799521308.672,
+        "elapsed time": 1195.0309052809898
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.39651250947687644,
+        "train loss": 0.6497887889146805,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.04330921173095703
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "740312add88f781978c0658806c59bc2815b9866",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "5.5.4",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.0",
+      "peft-commit-hash": "6d5a6f4f2f902dbf13d21d2661d57c3c05df1dae",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/peanut--llama-3.2-3B-rank32-relu-depth0-s2.0.json b/method_comparison/MetaMathQA/results/peanut--llama-3.2-3B-rank32-relu-depth0-s2.0.json
new file mode 100644
index 0000000..f4093ac
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/peanut--llama-3.2-3B-rank32-relu-depth0-s2.0.json
@@ -0,0 +1,355 @@
+{
+  "run_info": {
+    "created_at": "2026-04-14T16:40:28+00:00",
+    "total_time": 1573.527884997995,
+    "experiment_name": "peanut/llama-3.2-3B-rank32-relu-depth0-s2.0",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null,
+      "init_kv_cache_prefix": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "PEANUT",
+      "auto_mapping": null,
+      "peft_version": "0.18.2.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 32,
+      "depth": 0,
+      "act_fn": "relu",
+      "scaling": 2.0,
+      "target_modules": [
+        "q_proj",
+        "v_proj"
+      ],
+      "exclude_modules": null,
+      "modules_to_save": null,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "init_weights": true
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 17292783622,
+    "accelerator_memory_max": 25216155648,
+    "accelerator_memory_reserved_99th": 22913482752,
+    "train_time": 1324.3875514060055,
+    "file_size": 29375392,
+    "num_trainable_params": 7340032,
+    "num_total_params": 3220089856,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.34,
+        "train loss": 1.0151871349811554,
+        "train samples": 1000,
+        "train time": 44.021378575009294,
+        "eval time": 14.376052794992574,
+        "tokens / sec": 4809.458650624626,
+        "mem allocated avg": 6898786570.24,
+        "mem reserved avg": 17395422855.168,
+        "elapsed time": 85.73105101600231
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.36,
+        "train loss": 0.7329526348114014,
+        "train samples": 2000,
+        "train time": 44.562354755951674,
+        "eval time": 14.344671937011299,
+        "tokens / sec": 4667.504694020249,
+        "mem allocated avg": 6892317472.768,
+        "mem reserved avg": 17048168038.4,
+        "elapsed time": 149.5062317289994
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.38,
+        "train loss": 0.6915021198987961,
+        "train samples": 3000,
+        "train time": 45.2565884070209,
+        "eval time": 14.244411489999038,
+        "tokens / sec": 4737.453872389966,
+        "mem allocated avg": 6901853413.376,
+        "mem reserved avg": 17230175666.176,
+        "elapsed time": 213.76587189899874
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.46,
+        "train loss": 0.6705982208251953,
+        "train samples": 4000,
+        "train time": 43.60357639606809,
+        "eval time": 12.205957198995748,
+        "tokens / sec": 4777.956700331271,
+        "mem allocated avg": 6893099798.528,
+        "mem reserved avg": 17291538333.696,
+        "elapsed time": 274.51652191899484
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.4,
+        "train loss": 0.6671838570833206,
+        "train samples": 5000,
+        "train time": 44.5333500400302,
+        "eval time": 9.193823512992822,
+        "tokens / sec": 4682.737764227238,
+        "mem allocated avg": 6893480824.832,
+        "mem reserved avg": 17332801896.448,
+        "elapsed time": 333.0422079429991
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.38,
+        "train loss": 0.6596062692403794,
+        "train samples": 6000,
+        "train time": 43.14656171298702,
+        "eval time": 10.896760057003121,
+        "tokens / sec": 4851.626449228556,
+        "mem allocated avg": 6895295387.648,
+        "mem reserved avg": 17295741026.304,
+        "elapsed time": 391.9642643400002
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.44,
+        "train loss": 0.6502646441459656,
+        "train samples": 7000,
+        "train time": 43.222262079041684,
+        "eval time": 12.457048503987608,
+        "tokens / sec": 4843.684479473726,
+        "mem allocated avg": 6896549773.312,
+        "mem reserved avg": 17676307005.44,
+        "elapsed time": 452.51822785299737
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.4,
+        "train loss": 0.6535031509399414,
+        "train samples": 8000,
+        "train time": 43.33418614100083,
+        "eval time": 14.309704052997404,
+        "tokens / sec": 4792.890290455634,
+        "mem allocated avg": 6892434849.792,
+        "mem reserved avg": 17262002044.928,
+        "elapsed time": 515.1359422499954
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.4,
+        "train loss": 0.6466518994569779,
+        "train samples": 9000,
+        "train time": 45.30572651808325,
+        "eval time": 10.579045053993468,
+        "tokens / sec": 4744.389209037538,
+        "mem allocated avg": 6904245090.304,
+        "mem reserved avg": 17572732862.464,
+        "elapsed time": 575.8882168769924
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.38,
+        "train loss": 0.6441503465175629,
+        "train samples": 10000,
+        "train time": 42.67895923292963,
+        "eval time": 10.036433415007195,
+        "tokens / sec": 4825.961169200276,
+        "mem allocated avg": 6890186133.504,
+        "mem reserved avg": 17048050597.888,
+        "elapsed time": 633.4232634090004
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.48,
+        "train loss": 0.6352012549638748,
+        "train samples": 11000,
+        "train time": 44.22804318890849,
+        "eval time": 13.283268603001488,
+        "tokens / sec": 4790.6483019157295,
+        "mem allocated avg": 6899866554.368,
+        "mem reserved avg": 17445360238.592,
+        "elapsed time": 695.7300765889959
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.4,
+        "train loss": 0.6280081766843796,
+        "train samples": 12000,
+        "train time": 44.57390221796231,
+        "eval time": 10.617056177012273,
+        "tokens / sec": 4682.807418998777,
+        "mem allocated avg": 6895103715.328,
+        "mem reserved avg": 17359997763.584,
+        "elapsed time": 755.8395442329929
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.5,
+        "train loss": 0.6369541518688202,
+        "train samples": 13000,
+        "train time": 44.50311762790079,
+        "eval time": 11.93099128700851,
+        "tokens / sec": 4739.016303607856,
+        "mem allocated avg": 6897675378.688,
+        "mem reserved avg": 17245728145.408,
+        "elapsed time": 817.0161534090003
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.46,
+        "train loss": 0.6206858913898468,
+        "train samples": 14000,
+        "train time": 44.9908673119935,
+        "eval time": 9.960958727999241,
+        "tokens / sec": 4662.057269211292,
+        "mem allocated avg": 6895242215.424,
+        "mem reserved avg": 17262169817.088,
+        "elapsed time": 876.9033543609985
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.38,
+        "train loss": 0.6189992456436157,
+        "train samples": 15000,
+        "train time": 45.45867533796991,
+        "eval time": 14.245861356001114,
+        "tokens / sec": 4767.032879618386,
+        "mem allocated avg": 6907035766.784,
+        "mem reserved avg": 17541258805.248,
+        "elapsed time": 941.4479730729945
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.5,
+        "train loss": 0.6326132407188415,
+        "train samples": 16000,
+        "train time": 42.56708373287984,
+        "eval time": 11.076982978993328,
+        "tokens / sec": 4801.198063801993,
+        "mem allocated avg": 6887389437.952,
+        "mem reserved avg": 17258218782.72,
+        "elapsed time": 1000.0103693019919
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.38,
+        "train loss": 0.6174385570287705,
+        "train samples": 17000,
+        "train time": 44.078655502045876,
+        "eval time": 12.323570092994487,
+        "tokens / sec": 4795.722500886819,
+        "mem allocated avg": 6898492084.224,
+        "mem reserved avg": 17216485457.92,
+        "elapsed time": 1061.1080808269908
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.38,
+        "train loss": 0.6236197687387467,
+        "train samples": 18000,
+        "train time": 44.025015621009516,
+        "eval time": 14.296635860999231,
+        "tokens / sec": 4720.452612419417,
+        "mem allocated avg": 6893971208.192,
+        "mem reserved avg": 17208499503.104,
+        "elapsed time": 1124.3825900560041
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.36,
+        "train loss": 0.6151172000169755,
+        "train samples": 19000,
+        "train time": 44.508093398908386,
+        "eval time": 10.900150568995741,
+        "tokens / sec": 4716.872459990592,
+        "mem allocated avg": 6896253108.224,
+        "mem reserved avg": 17249184251.904,
+        "elapsed time": 1184.5931518430007
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.52,
+        "train loss": 0.6224583629369735,
+        "train samples": 20000,
+        "train time": 43.60898305509181,
+        "eval time": 14.021379313999205,
+        "tokens / sec": 4776.0801882694,
+        "mem allocated avg": 6892680140.8,
+        "mem reserved avg": 16915829358.592,
+        "elapsed time": 1246.993633168997
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.4533737680060652,
+        "train loss": 0.6224583629369735,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.3534202575683594
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "740312add88f781978c0658806c59bc2815b9866",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "5.5.4",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.0",
+      "peft-commit-hash": "6d5a6f4f2f902dbf13d21d2661d57c3c05df1dae",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/prefixtuning--llama-3.2-3B-lr_0.001.json b/method_comparison/MetaMathQA/results/prefixtuning--llama-3.2-3B-lr_0.001.json
new file mode 100644
index 0000000..6797029
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/prefixtuning--llama-3.2-3B-lr_0.001.json
@@ -0,0 +1,348 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T06:21:07+00:00",
+    "total_time": 1331.180568004027,
+    "experiment_name": "prefixtuning/llama-3.2-3B-lr_0.001",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.001
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": "CAUSAL_LM",
+      "peft_type": "PREFIX_TUNING",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "num_virtual_tokens": 200,
+      "token_dim": 1024,
+      "num_transformer_submodules": 1,
+      "num_attention_heads": 8,
+      "num_layers": 28,
+      "modules_to_save": null,
+      "encoder_hidden_size": 3072,
+      "prefix_projection": false
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 13976940104,
+    "accelerator_memory_max": 21969764352,
+    "accelerator_memory_reserved_99th": 19153289216,
+    "train_time": 1064.3996377468575,
+    "file_size": 45875328,
+    "num_trainable_params": 11468800,
+    "num_total_params": 3224218624,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.0,
+        "train loss": 7.371234140396118,
+        "train samples": 1000,
+        "train time": 28.751766396977473,
+        "eval time": 16.065947165014222,
+        "tokens / sec": 7363.686706297703,
+        "mem allocated avg": 7055800627.2,
+        "mem reserved avg": 14144568819.712,
+        "elapsed time": 65.96332754800096
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.02,
+        "train loss": 3.85315430355072,
+        "train samples": 2000,
+        "train time": 28.732399038621224,
+        "eval time": 15.995644349022768,
+        "tokens / sec": 7239.0404894634585,
+        "mem allocated avg": 7047734953.984,
+        "mem reserved avg": 13747594723.328,
+        "elapsed time": 113.22562833898701
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.0,
+        "train loss": 1.7292076191902161,
+        "train samples": 3000,
+        "train time": 28.82316682342207,
+        "eval time": 15.999323514988646,
+        "tokens / sec": 7438.495614082733,
+        "mem allocated avg": 7058484809.728,
+        "mem reserved avg": 13879262314.496,
+        "elapsed time": 160.49658835295122
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.06,
+        "train loss": 1.1542455520629882,
+        "train samples": 4000,
+        "train time": 28.307557759340852,
+        "eval time": 15.991954815981444,
+        "tokens / sec": 7359.730633464974,
+        "mem allocated avg": 7050851307.52,
+        "mem reserved avg": 13934467743.744,
+        "elapsed time": 207.3751138979569
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.12,
+        "train loss": 1.011209780216217,
+        "train samples": 5000,
+        "train time": 28.492442497052252,
+        "eval time": 16.001330196973868,
+        "tokens / sec": 7319.063643686383,
+        "mem allocated avg": 7049989021.696,
+        "mem reserved avg": 13963450384.384,
+        "elapsed time": 254.30183131998638
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.1,
+        "train loss": 0.9543534135818481,
+        "train samples": 6000,
+        "train time": 29.00675484893145,
+        "eval time": 9.917582978028804,
+        "tokens / sec": 7216.629405467993,
+        "mem allocated avg": 7052174501.888,
+        "mem reserved avg": 13851756068.864,
+        "elapsed time": 295.813073428988
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.18,
+        "train loss": 0.9020170977115631,
+        "train samples": 7000,
+        "train time": 28.937920498428866,
+        "eval time": 15.994958859984763,
+        "tokens / sec": 7234.624893359789,
+        "mem allocated avg": 7052584257.536,
+        "mem reserved avg": 14313834151.936,
+        "elapsed time": 343.2948918819893
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.12,
+        "train loss": 0.8851030931472779,
+        "train samples": 8000,
+        "train time": 28.514948888856452,
+        "eval time": 16.008299834036734,
+        "tokens / sec": 7283.7584527870895,
+        "mem allocated avg": 7048941596.672,
+        "mem reserved avg": 13972795293.696,
+        "elapsed time": 390.4364310989622
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.16,
+        "train loss": 0.8607603459358215,
+        "train samples": 9000,
+        "train time": 29.902237092261203,
+        "eval time": 10.535748619004153,
+        "tokens / sec": 7188.358494275642,
+        "mem allocated avg": 7059749308.416,
+        "mem reserved avg": 14222314438.656,
+        "elapsed time": 433.4298671329743
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.12,
+        "train loss": 0.8404140145778656,
+        "train samples": 10000,
+        "train time": 28.107242401398253,
+        "eval time": 16.000201146001928,
+        "tokens / sec": 7327.8978086357465,
+        "mem allocated avg": 7045691678.72,
+        "mem reserved avg": 13735917780.992,
+        "elapsed time": 480.0712110779714
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.16,
+        "train loss": 0.825820200920105,
+        "train samples": 11000,
+        "train time": 28.787353610619903,
+        "eval time": 16.014024466043338,
+        "tokens / sec": 7360.211114433085,
+        "mem allocated avg": 7056392456.192,
+        "mem reserved avg": 14160037412.864,
+        "elapsed time": 527.3567257059622
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.16,
+        "train loss": 0.8098397166728973,
+        "train samples": 12000,
+        "train time": 28.65236609155545,
+        "eval time": 9.67730041500181,
+        "tokens / sec": 7284.948102820664,
+        "mem allocated avg": 7051615287.296,
+        "mem reserved avg": 14045272866.816,
+        "elapsed time": 568.3316111429594
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.22,
+        "train loss": 0.8175026917457581,
+        "train samples": 13000,
+        "train time": 29.403707249381114,
+        "eval time": 16.004016032034997,
+        "tokens / sec": 7172.59895873977,
+        "mem allocated avg": 7053057355.776,
+        "mem reserved avg": 13961034465.28,
+        "elapsed time": 616.2441388620064
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.22,
+        "train loss": 0.7965447254180908,
+        "train samples": 14000,
+        "train time": 29.196881618758198,
+        "eval time": 10.013400638010353,
+        "tokens / sec": 7183.986383848656,
+        "mem allocated avg": 7052398039.04,
+        "mem reserved avg": 13956026466.304,
+        "elapsed time": 658.0585781059926
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.26,
+        "train loss": 0.7888746349811554,
+        "train samples": 15000,
+        "train time": 30.024835704127327,
+        "eval time": 16.018790416012052,
+        "tokens / sec": 7217.458311360924,
+        "mem allocated avg": 7062534557.696,
+        "mem reserved avg": 14256909058.048,
+        "elapsed time": 706.6880692789564
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.22,
+        "train loss": 0.8037197089195252,
+        "train samples": 16000,
+        "train time": 28.532692203647457,
+        "eval time": 11.774339078983758,
+        "tokens / sec": 7162.766083947526,
+        "mem allocated avg": 7044319064.064,
+        "mem reserved avg": 13979053195.264,
+        "elapsed time": 749.5904883489711
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.2,
+        "train loss": 0.7834680559635162,
+        "train samples": 17000,
+        "train time": 29.28171190287685,
+        "eval time": 8.626789060013834,
+        "tokens / sec": 7219.147592912134,
+        "mem allocated avg": 7055146299.392,
+        "mem reserved avg": 13931238129.664,
+        "elapsed time": 789.9725718589616
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.22,
+        "train loss": 0.7825182939767837,
+        "train samples": 18000,
+        "train time": 28.710874950978905,
+        "eval time": 9.622777467011474,
+        "tokens / sec": 7238.302571928913,
+        "mem allocated avg": 7049707819.008,
+        "mem reserved avg": 13845691105.28,
+        "elapsed time": 830.868794028007
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.24,
+        "train loss": 0.780375949382782,
+        "train samples": 19000,
+        "train time": 29.437492316938005,
+        "eval time": 8.954141772992443,
+        "tokens / sec": 7131.687636286989,
+        "mem allocated avg": 7052297474.048,
+        "mem reserved avg": 13998388936.704,
+        "elapsed time": 871.7168849699665
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.22,
+        "train loss": 0.7886579229831695,
+        "train samples": 20000,
+        "train time": 28.385062363231555,
+        "eval time": 8.572692813992035,
+        "tokens / sec": 7337.662230039503,
+        "mem allocated avg": 7048989648.896,
+        "mem reserved avg": 13639188742.144,
+        "elapsed time": 911.1826199819916
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.20090978013646701,
+        "train loss": 0.7886579229831695,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.5536785125732422
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/prefixtuning--llama-3.2-3B-lr_0.005_zero_init.json b/method_comparison/MetaMathQA/results/prefixtuning--llama-3.2-3B-lr_0.005_zero_init.json
new file mode 100644
index 0000000..74b9616
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/prefixtuning--llama-3.2-3B-lr_0.005_zero_init.json
@@ -0,0 +1,350 @@
+{
+  "run_info": {
+    "created_at": "2026-04-14T17:06:46+00:00",
+    "total_time": 1255.1344404510019,
+    "experiment_name": "prefixtuning/llama-3.2-3B-lr_0.005_zero_init",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.005
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null,
+      "init_kv_cache_prefix": null
+    },
+    "peft_config": {
+      "task_type": "CAUSAL_LM",
+      "peft_type": "PREFIX_TUNING",
+      "auto_mapping": null,
+      "peft_version": "0.19.0",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "num_virtual_tokens": 200,
+      "token_dim": 1024,
+      "num_transformer_submodules": 1,
+      "num_attention_heads": 8,
+      "num_layers": 28,
+      "modules_to_save": null,
+      "init_weights": "zero",
+      "encoder_hidden_size": 3072,
+      "prefix_projection": false
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 13987667876,
+    "accelerator_memory_max": 21969764352,
+    "accelerator_memory_reserved_99th": 19157483520,
+    "train_time": 970.3953097560006,
+    "file_size": 45875328,
+    "num_trainable_params": 11468800,
+    "num_total_params": 3224218624,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.2,
+        "train loss": 1.2678344011306764,
+        "train samples": 1000,
+        "train time": 27.194034429907333,
+        "eval time": 15.960887206005282,
+        "tokens / sec": 7785.494298233168,
+        "mem allocated avg": 7055727894.528,
+        "mem reserved avg": 14077342515.2,
+        "elapsed time": 65.7957478990138
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.36,
+        "train loss": 0.7902288379669189,
+        "train samples": 2000,
+        "train time": 27.01687965914607,
+        "eval time": 11.780722531999345,
+        "tokens / sec": 7698.705499085536,
+        "mem allocated avg": 7047839463.424,
+        "mem reserved avg": 13768356528.128,
+        "elapsed time": 107.10377580400382
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.24,
+        "train loss": 0.7467671196460723,
+        "train samples": 3000,
+        "train time": 27.93710034090327,
+        "eval time": 13.317983273998834,
+        "tokens / sec": 7674.418511003849,
+        "mem allocated avg": 7058360565.76,
+        "mem reserved avg": 13883792162.816,
+        "elapsed time": 150.8143266110128
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.28,
+        "train loss": 0.7247283264398575,
+        "train samples": 4000,
+        "train time": 28.07561205892125,
+        "eval time": 15.844377710003755,
+        "tokens / sec": 7420.532794183539,
+        "mem allocated avg": 7050874298.368,
+        "mem reserved avg": 13931053580.288,
+        "elapsed time": 197.35486783200759
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.28,
+        "train loss": 0.7230025169849396,
+        "train samples": 5000,
+        "train time": 27.4366716020304,
+        "eval time": 15.843770207007765,
+        "tokens / sec": 7600.703285910508,
+        "mem allocated avg": 7049694097.408,
+        "mem reserved avg": 13987190145.024,
+        "elapsed time": 243.09947748400737
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.3,
+        "train loss": 0.7165617660284043,
+        "train samples": 6000,
+        "train time": 27.41693946205487,
+        "eval time": 15.844231765004224,
+        "tokens / sec": 7635.097283185629,
+        "mem allocated avg": 7052062963.712,
+        "mem reserved avg": 13884471640.064,
+        "elapsed time": 288.92823548801243
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.38,
+        "train loss": 0.7077521693706512,
+        "train samples": 7000,
+        "train time": 27.86099931402714,
+        "eval time": 15.84966672999144,
+        "tokens / sec": 7514.267440313827,
+        "mem allocated avg": 7052561504.256,
+        "mem reserved avg": 14377218473.984,
+        "elapsed time": 335.2041009560053
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.42,
+        "train loss": 0.7111810308694839,
+        "train samples": 8000,
+        "train time": 27.7813215659844,
+        "eval time": 13.623913794013788,
+        "tokens / sec": 7476.102225975604,
+        "mem allocated avg": 7049145475.072,
+        "mem reserved avg": 14036481605.632,
+        "elapsed time": 379.2373954960058
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.38,
+        "train loss": 0.7035314469337464,
+        "train samples": 9000,
+        "train time": 28.324825873816735,
+        "eval time": 15.338107262999984,
+        "tokens / sec": 7588.678601505416,
+        "mem allocated avg": 7059892746.24,
+        "mem reserved avg": 14239712411.648,
+        "elapsed time": 425.4388579290098
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.3,
+        "train loss": 0.70130124771595,
+        "train samples": 10000,
+        "train time": 27.76416820794111,
+        "eval time": 15.847382225998444,
+        "tokens / sec": 7418.4466272283025,
+        "mem allocated avg": 7045819248.64,
+        "mem reserved avg": 13771493867.52,
+        "elapsed time": 471.59908634400927
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.38,
+        "train loss": 0.6942626680135727,
+        "train samples": 11000,
+        "train time": 27.77380103613541,
+        "eval time": 11.25709281899617,
+        "tokens / sec": 7628.808160767404,
+        "mem allocated avg": 7056581769.216,
+        "mem reserved avg": 14109697376.256,
+        "elapsed time": 513.1207982520136
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.34,
+        "train loss": 0.6865150318145752,
+        "train samples": 12000,
+        "train time": 27.40294734176132,
+        "eval time": 15.83896046000882,
+        "tokens / sec": 7617.1003577377915,
+        "mem allocated avg": 7051527202.816,
+        "mem reserved avg": 14113497415.68,
+        "elapsed time": 559.0147692530008
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.32,
+        "train loss": 0.6951180123090744,
+        "train samples": 13000,
+        "train time": 27.608605705041555,
+        "eval time": 15.836226497005555,
+        "tokens / sec": 7638.958745442468,
+        "mem allocated avg": 7052913205.248,
+        "mem reserved avg": 13957486084.096,
+        "elapsed time": 604.9435471830075
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.46,
+        "train loss": 0.6807289460897445,
+        "train samples": 14000,
+        "train time": 28.273788013044395,
+        "eval time": 15.85275076299149,
+        "tokens / sec": 7418.5319598219285,
+        "mem allocated avg": 7052796133.376,
+        "mem reserved avg": 13872937304.064,
+        "elapsed time": 651.6589886930014
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.38,
+        "train loss": 0.6770447121858597,
+        "train samples": 15000,
+        "train time": 28.624993037970853,
+        "eval time": 10.463159157996415,
+        "tokens / sec": 7570.412321587118,
+        "mem allocated avg": 7062565990.4,
+        "mem reserved avg": 14240719044.608,
+        "elapsed time": 693.3172026100074
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.44,
+        "train loss": 0.6930302439928054,
+        "train samples": 16000,
+        "train time": 27.629406421037856,
+        "eval time": 9.406142670995905,
+        "tokens / sec": 7396.937772951368,
+        "mem allocated avg": 7044787052.544,
+        "mem reserved avg": 13913278119.936,
+        "elapsed time": 732.9555247080134
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.46,
+        "train loss": 0.672576385140419,
+        "train samples": 17000,
+        "train time": 28.082130014998256,
+        "eval time": 10.856074246999924,
+        "tokens / sec": 7527.527288247017,
+        "mem allocated avg": 7054679074.816,
+        "mem reserved avg": 14022187417.6,
+        "elapsed time": 774.335282400003
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.36,
+        "train loss": 0.6801181032657623,
+        "train samples": 18000,
+        "train time": 27.873706766869873,
+        "eval time": 15.860146595994593,
+        "tokens / sec": 7455.700159944578,
+        "mem allocated avg": 7049662265.344,
+        "mem reserved avg": 13916012806.144,
+        "elapsed time": 820.668733826009
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.42,
+        "train loss": 0.6726169712543487,
+        "train samples": 19000,
+        "train time": 27.956917096104007,
+        "eval time": 15.841582774999551,
+        "tokens / sec": 7509.375918607867,
+        "mem allocated avg": 7052527755.264,
+        "mem reserved avg": 14004571340.8,
+        "elapsed time": 866.9247034900036
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.4,
+        "train loss": 0.6787571088075638,
+        "train samples": 20000,
+        "train time": 27.523053067998262,
+        "eval time": 10.57767208799487,
+        "tokens / sec": 7567.474418096891,
+        "mem allocated avg": 7049240582.144,
+        "mem reserved avg": 13645857685.504,
+        "elapsed time": 907.492314247007
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.36694465504169826,
+        "train loss": 0.6787571088075638,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 2.828566551208496
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "740312add88f781978c0658806c59bc2815b9866",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "5.5.4",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.0",
+      "peft-commit-hash": "6d5a6f4f2f902dbf13d21d2661d57c3c05df1dae",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/prefixtuning--llama-3.2-3B-tokens50-init_prefix-lr_0.005.json b/method_comparison/MetaMathQA/results/prefixtuning--llama-3.2-3B-tokens50-init_prefix-lr_0.005.json
new file mode 100644
index 0000000..38273b2
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/prefixtuning--llama-3.2-3B-tokens50-init_prefix-lr_0.005.json
@@ -0,0 +1,350 @@
+{
+  "run_info": {
+    "created_at": "2026-04-14T17:27:47+00:00",
+    "total_time": 1081.9605887679936,
+    "experiment_name": "prefixtuning/llama-3.2-3B-tokens50-init_prefix-lr_0.005",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.005
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null,
+      "init_kv_cache_prefix": "You are a helpful math assistant. Solve mathematical problems by thinking step by step. First, identify what the problem is asking. Then, break down the solution into clear logical steps. Show all your work and calculations. Finally, verify that your answer makes sense."
+    },
+    "peft_config": {
+      "task_type": "CAUSAL_LM",
+      "peft_type": "PREFIX_TUNING",
+      "auto_mapping": null,
+      "peft_version": "0.19.0",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "num_virtual_tokens": 50,
+      "token_dim": 1024,
+      "num_transformer_submodules": 1,
+      "num_attention_heads": 8,
+      "num_layers": 28,
+      "modules_to_save": null,
+      "init_weights": "zero",
+      "encoder_hidden_size": 3072,
+      "prefix_projection": false
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 13483572933,
+    "accelerator_memory_max": 20598226944,
+    "accelerator_memory_reserved_99th": 18910019584,
+    "train_time": 876.9671407810383,
+    "file_size": 11468928,
+    "num_trainable_params": 2867200,
+    "num_total_params": 3215617024,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.42,
+        "train loss": 0.8770561032295227,
+        "train samples": 1000,
+        "train time": 27.075058152986458,
+        "eval time": 12.278193292004289,
+        "tokens / sec": 7819.7061961489,
+        "mem allocated avg": 6850508638.208,
+        "mem reserved avg": 13529004376.064,
+        "elapsed time": 59.77307076699799
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.32,
+        "train loss": 0.7323095265626908,
+        "train samples": 2000,
+        "train time": 25.9315507930296,
+        "eval time": 12.18094836299133,
+        "tokens / sec": 8020.924072767335,
+        "mem allocated avg": 6844681697.28,
+        "mem reserved avg": 13250326429.696,
+        "elapsed time": 100.36647598700074
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.32,
+        "train loss": 0.7008617881536484,
+        "train samples": 3000,
+        "train time": 26.427966193965403,
+        "eval time": 12.173006537996116,
+        "tokens / sec": 8112.656056331592,
+        "mem allocated avg": 6853247197.184,
+        "mem reserved avg": 13445747441.664,
+        "elapsed time": 141.34405067499029
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.28,
+        "train loss": 0.6788400970697402,
+        "train samples": 4000,
+        "train time": 25.98687330308894,
+        "eval time": 8.224064269001246,
+        "tokens / sec": 8016.97062859948,
+        "mem allocated avg": 6846228791.296,
+        "mem reserved avg": 13453565624.32,
+        "elapsed time": 178.0648215330002
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.38,
+        "train loss": 0.6749719911813736,
+        "train samples": 5000,
+        "train time": 26.186906341084978,
+        "eval time": 9.531287125995732,
+        "tokens / sec": 7963.4454442150745,
+        "mem allocated avg": 6845613846.528,
+        "mem reserved avg": 13454270267.392,
+        "elapsed time": 216.16001013299683
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.46,
+        "train loss": 0.667180904507637,
+        "train samples": 6000,
+        "train time": 26.662186090034083,
+        "eval time": 10.567809118991136,
+        "tokens / sec": 7851.231676694535,
+        "mem allocated avg": 6847045138.432,
+        "mem reserved avg": 13407772213.248,
+        "elapsed time": 255.88970967099885
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.46,
+        "train loss": 0.6559479324817657,
+        "train samples": 7000,
+        "train time": 26.49516641102673,
+        "eval time": 12.163915039011044,
+        "tokens / sec": 7901.629933257217,
+        "mem allocated avg": 6848404830.208,
+        "mem reserved avg": 13917791191.04,
+        "elapsed time": 297.1118020349968
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.4,
+        "train loss": 0.6591078944206238,
+        "train samples": 8000,
+        "train time": 26.275470316875726,
+        "eval time": 8.645700470995507,
+        "tokens / sec": 7904.558795532,
+        "mem allocated avg": 6845511892.992,
+        "mem reserved avg": 13459672530.944,
+        "elapsed time": 334.5593292220001
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.4,
+        "train loss": 0.6502013274431229,
+        "train samples": 9000,
+        "train time": 27.61604808192351,
+        "eval time": 8.71540480099793,
+        "tokens / sec": 7783.445312752674,
+        "mem allocated avg": 6856188073.984,
+        "mem reserved avg": 13818822393.856,
+        "elapsed time": 373.383077571998
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.3,
+        "train loss": 0.6463649077415466,
+        "train samples": 10000,
+        "train time": 25.71797766610689,
+        "eval time": 12.1855976539955,
+        "tokens / sec": 8008.677924603652,
+        "mem allocated avg": 6841198448.64,
+        "mem reserved avg": 13211906605.056,
+        "elapsed time": 413.7216535589978
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.46,
+        "train loss": 0.6392199238538742,
+        "train samples": 11000,
+        "train time": 26.202791606934625,
+        "eval time": 7.22116273798747,
+        "tokens / sec": 8086.1994850932315,
+        "mem allocated avg": 6852461844.48,
+        "mem reserved avg": 13564337192.96,
+        "elapsed time": 449.5270742329885
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.48,
+        "train loss": 0.6317592755556106,
+        "train samples": 12000,
+        "train time": 25.93028078901989,
+        "eval time": 8.178787294003996,
+        "tokens / sec": 8049.700722422821,
+        "mem allocated avg": 6846777763.84,
+        "mem reserved avg": 13549866844.16,
+        "elapsed time": 486.16456745499454
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.42,
+        "train loss": 0.6396716977357865,
+        "train samples": 13000,
+        "train time": 25.985331026968197,
+        "eval time": 8.20254961399769,
+        "tokens / sec": 8116.155987434677,
+        "mem allocated avg": 6848086245.376,
+        "mem reserved avg": 13484653805.568,
+        "elapsed time": 522.7170732099912
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.34,
+        "train loss": 0.6240959404706955,
+        "train samples": 14000,
+        "train time": 26.13682606702787,
+        "eval time": 12.181133142992621,
+        "tokens / sec": 8025.0754036506305,
+        "mem allocated avg": 6847662497.792,
+        "mem reserved avg": 13383730462.72,
+        "elapsed time": 563.5027851319901
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.4,
+        "train loss": 0.622292353630066,
+        "train samples": 15000,
+        "train time": 27.131869087956147,
+        "eval time": 8.023930148992804,
+        "tokens / sec": 7987.028070107953,
+        "mem allocated avg": 6858720468.992,
+        "mem reserved avg": 13744801316.864,
+        "elapsed time": 601.1192357580003
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.54,
+        "train loss": 0.6341568591594696,
+        "train samples": 16000,
+        "train time": 26.46197854007187,
+        "eval time": 12.196425275004003,
+        "tokens / sec": 7723.2698110806095,
+        "mem allocated avg": 6839325679.616,
+        "mem reserved avg": 13483773001.728,
+        "elapsed time": 642.3214606379915
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.42,
+        "train loss": 0.6193043732643128,
+        "train samples": 17000,
+        "train time": 26.90304671296326,
+        "eval time": 8.022700519009959,
+        "tokens / sec": 7857.437198670216,
+        "mem allocated avg": 6851016419.328,
+        "mem reserved avg": 13403921842.176,
+        "elapsed time": 679.6091405869956
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.46,
+        "train loss": 0.6262495114803314,
+        "train samples": 18000,
+        "train time": 26.447085382867954,
+        "eval time": 12.189505065995036,
+        "tokens / sec": 7857.879119436789,
+        "mem allocated avg": 6844825409.536,
+        "mem reserved avg": 13365854339.072,
+        "elapsed time": 720.788875756989
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.38,
+        "train loss": 0.6178192925453186,
+        "train samples": 19000,
+        "train time": 26.904425678018015,
+        "eval time": 11.104270746989641,
+        "tokens / sec": 7803.139993117508,
+        "mem allocated avg": 6848209059.84,
+        "mem reserved avg": 13499510030.336,
+        "elapsed time": 761.1998116350005
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.46,
+        "train loss": 0.6229302062988281,
+        "train samples": 20000,
+        "train time": 26.149641662093927,
+        "eval time": 6.978471010006615,
+        "tokens / sec": 7964.927500399332,
+        "mem allocated avg": 6843759417.344,
+        "mem reserved avg": 13242130759.68,
+        "elapsed time": 796.7215869979991
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.400303260045489,
+        "train loss": 0.6229302062988281,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.5316238403320312
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "740312add88f781978c0658806c59bc2815b9866",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "5.5.4",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.0",
+      "peft-commit-hash": "6d5a6f4f2f902dbf13d21d2661d57c3c05df1dae",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/prompt_tuning--llama-3.2-3B-default.json b/method_comparison/MetaMathQA/results/prompt_tuning--llama-3.2-3B-default.json
new file mode 100644
index 0000000..bfd3cbb
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/prompt_tuning--llama-3.2-3B-default.json
@@ -0,0 +1,351 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T06:43:22+00:00",
+    "total_time": 1838.2831721020048,
+    "experiment_name": "prompt_tuning/llama-3.2-3B-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": "CAUSAL_LM",
+      "peft_type": "PROMPT_TUNING",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "num_virtual_tokens": 200,
+      "token_dim": 3072,
+      "num_transformer_submodules": 1,
+      "num_attention_heads": 24,
+      "num_layers": 28,
+      "modules_to_save": null,
+      "prompt_tuning_init": "RANDOM",
+      "prompt_tuning_init_text": null,
+      "tokenizer_name_or_path": null,
+      "tokenizer_kwargs": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 17625765642,
+    "accelerator_memory_max": 24427626496,
+    "accelerator_memory_reserved_99th": 22968008704,
+    "train_time": 1505.838819740049,
+    "file_size": 2457728,
+    "num_trainable_params": 614400,
+    "num_total_params": 3213364224,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.0,
+        "train loss": 3.462650680541992,
+        "train samples": 1000,
+        "train time": 48.139625351293944,
+        "eval time": 16.530633710033726,
+        "tokens / sec": 4398.019271130643,
+        "mem allocated avg": 7084412407.808,
+        "mem reserved avg": 17769940647.936,
+        "elapsed time": 87.74912454502191
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.0,
+        "train loss": 2.2589459805488588,
+        "train samples": 2000,
+        "train time": 48.43768710020231,
+        "eval time": 16.48010197596159,
+        "tokens / sec": 4294.073735802535,
+        "mem allocated avg": 7076015853.568,
+        "mem reserved avg": 17322089644.032,
+        "elapsed time": 155.9924284190056
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.0,
+        "train loss": 1.7582932782173157,
+        "train samples": 3000,
+        "train time": 48.9170593819581,
+        "eval time": 16.461432596028317,
+        "tokens / sec": 4382.94948038264,
+        "mem allocated avg": 7086598868.992,
+        "mem reserved avg": 17347867836.416,
+        "elapsed time": 224.63146157900337
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.0,
+        "train loss": 1.6029385833740235,
+        "train samples": 4000,
+        "train time": 48.4513027088251,
+        "eval time": 16.587105787999462,
+        "tokens / sec": 4299.905025299824,
+        "mem allocated avg": 7080125773.824,
+        "mem reserved avg": 17638306611.2,
+        "elapsed time": 293.0906825060374
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.0,
+        "train loss": 1.5049201951026916,
+        "train samples": 5000,
+        "train time": 47.84065633546561,
+        "eval time": 16.44257097603986,
+        "tokens / sec": 4359.012103381303,
+        "mem allocated avg": 7076596897.792,
+        "mem reserved avg": 17677858897.92,
+        "elapsed time": 360.6927552940324
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.0,
+        "train loss": 1.4373888688087464,
+        "train samples": 6000,
+        "train time": 48.565593625826295,
+        "eval time": 16.451919412997086,
+        "tokens / sec": 4310.273680844737,
+        "mem allocated avg": 7079910084.608,
+        "mem reserved avg": 17610313826.304,
+        "elapsed time": 429.08035932003986
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.0,
+        "train loss": 1.3829970264434814,
+        "train samples": 7000,
+        "train time": 47.46174641727703,
+        "eval time": 16.44140770897502,
+        "tokens / sec": 4411.026053685007,
+        "mem allocated avg": 7081518635.008,
+        "mem reserved avg": 17944507580.416,
+        "elapsed time": 496.28030893800315
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.0,
+        "train loss": 1.333943516254425,
+        "train samples": 8000,
+        "train time": 47.37612354574958,
+        "eval time": 16.461310581013095,
+        "tokens / sec": 4383.980462213941,
+        "mem allocated avg": 7076895195.136,
+        "mem reserved avg": 17455510454.272,
+        "elapsed time": 563.4433135589934
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.0,
+        "train loss": 1.2829430739879608,
+        "train samples": 9000,
+        "train time": 49.185617247305345,
+        "eval time": 16.46588272700319,
+        "tokens / sec": 4370.139321811113,
+        "mem allocated avg": 7088224200.704,
+        "mem reserved avg": 17821908074.496,
+        "elapsed time": 632.4641255650204
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.0,
+        "train loss": 1.246446587562561,
+        "train samples": 10000,
+        "train time": 48.255648160818964,
+        "eval time": 16.453739245946053,
+        "tokens / sec": 4268.246471658303,
+        "mem allocated avg": 7075521802.24,
+        "mem reserved avg": 17499282210.816,
+        "elapsed time": 700.5415165220038
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.0,
+        "train loss": 1.2048211748600006,
+        "train samples": 11000,
+        "train time": 48.75862841651542,
+        "eval time": 16.46915528498357,
+        "tokens / sec": 4345.507797923046,
+        "mem allocated avg": 7083802673.152,
+        "mem reserved avg": 18024199356.416,
+        "elapsed time": 769.1840648030047
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.06,
+        "train loss": 1.1679602472782136,
+        "train samples": 12000,
+        "train time": 48.22104389790911,
+        "eval time": 16.46740536397556,
+        "tokens / sec": 4328.6288128045,
+        "mem allocated avg": 7078835648.512,
+        "mem reserved avg": 17764907483.136,
+        "elapsed time": 837.2026147870347
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.04,
+        "train loss": 1.131537829875946,
+        "train samples": 13000,
+        "train time": 48.137974261830095,
+        "eval time": 16.45086403901223,
+        "tokens / sec": 4381.177297841325,
+        "mem allocated avg": 7080606814.208,
+        "mem reserved avg": 17735715127.296,
+        "elapsed time": 905.0784538229927
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.04,
+        "train loss": 1.1094365301132203,
+        "train samples": 14000,
+        "train time": 48.85280603397405,
+        "eval time": 16.464311491989065,
+        "tokens / sec": 4293.509770024922,
+        "mem allocated avg": 7081026895.872,
+        "mem reserved avg": 17464184274.944,
+        "elapsed time": 973.75803008402
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.02,
+        "train loss": 1.079718291759491,
+        "train samples": 15000,
+        "train time": 49.39224000740796,
+        "eval time": 16.467753204982728,
+        "tokens / sec": 4387.389597384091,
+        "mem allocated avg": 7091974598.656,
+        "mem reserved avg": 17988463886.336,
+        "elapsed time": 1042.9676414930145
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.02,
+        "train loss": 1.0901593000888825,
+        "train samples": 16000,
+        "train time": 48.37513752095401,
+        "eval time": 16.4682428810047,
+        "tokens / sec": 4224.752847709724,
+        "mem allocated avg": 7072683055.104,
+        "mem reserved avg": 17487336833.024,
+        "elapsed time": 1111.1566645530402
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.04,
+        "train loss": 1.0608918931484221,
+        "train samples": 17000,
+        "train time": 48.56447010586271,
+        "eval time": 16.604359342018142,
+        "tokens / sec": 4352.750056557934,
+        "mem allocated avg": 7082847784.96,
+        "mem reserved avg": 17545067233.28,
+        "elapsed time": 1179.6303421389894
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.06,
+        "train loss": 1.068639324426651,
+        "train samples": 18000,
+        "train time": 48.767977151903324,
+        "eval time": 16.501046893012244,
+        "tokens / sec": 4261.36190460976,
+        "mem allocated avg": 7077102155.776,
+        "mem reserved avg": 17491698909.184,
+        "elapsed time": 1248.2997376249987
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.02,
+        "train loss": 1.0587589330673217,
+        "train samples": 19000,
+        "train time": 48.74695514619816,
+        "eval time": 16.455141162965447,
+        "tokens / sec": 4306.710016458811,
+        "mem allocated avg": 7080302989.312,
+        "mem reserved avg": 17688931860.48,
+        "elapsed time": 1316.8433299760218
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.04,
+        "train loss": 1.0654818024635315,
+        "train samples": 20000,
+        "train time": 48.002736268914305,
+        "eval time": 16.48369751899736,
+        "tokens / sec": 4338.91932395692,
+        "mem allocated avg": 7078423576.576,
+        "mem reserved avg": 17237222096.896,
+        "elapsed time": 1384.6823478980223
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.053828658074298714,
+        "train loss": 1.0654818024635315,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 2.5893402099609375
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/prompt_tuning--llama-3.2-3B-lr_0.001.json b/method_comparison/MetaMathQA/results/prompt_tuning--llama-3.2-3B-lr_0.001.json
new file mode 100644
index 0000000..62aeb97
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/prompt_tuning--llama-3.2-3B-lr_0.001.json
@@ -0,0 +1,350 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T07:14:05+00:00",
+    "total_time": 1832.84551787097,
+    "experiment_name": "prompt_tuning/llama-3.2-3B-lr_0.001",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.001
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": "CAUSAL_LM",
+      "peft_type": "PROMPT_TUNING",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "num_virtual_tokens": 200,
+      "token_dim": 3072,
+      "num_transformer_submodules": 1,
+      "num_attention_heads": 24,
+      "num_layers": 28,
+      "modules_to_save": null,
+      "prompt_tuning_init": "RANDOM",
+      "prompt_tuning_init_text": null,
+      "tokenizer_name_or_path": null,
+      "tokenizer_kwargs": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 17625765642,
+    "accelerator_memory_max": 24427626496,
+    "accelerator_memory_reserved_99th": 22968008704,
+    "train_time": 1500.144346723042,
+    "file_size": 2457728,
+    "num_trainable_params": 614400,
+    "num_total_params": 3213364224,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.0,
+        "train loss": 2.454541881084442,
+        "train samples": 1000,
+        "train time": 48.05059277405962,
+        "eval time": 16.54681792098563,
+        "tokens / sec": 4406.168327527848,
+        "mem allocated avg": 7084412407.808,
+        "mem reserved avg": 17769940647.936,
+        "elapsed time": 87.42315325996606
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.0,
+        "train loss": 1.4034946029186248,
+        "train samples": 2000,
+        "train time": 47.981591070012655,
+        "eval time": 16.47515737899812,
+        "tokens / sec": 4334.891681613949,
+        "mem allocated avg": 7076015853.568,
+        "mem reserved avg": 17322089644.032,
+        "elapsed time": 155.20469547994435
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.14,
+        "train loss": 1.0518241834640503,
+        "train samples": 3000,
+        "train time": 48.23318296362413,
+        "eval time": 16.460273437958676,
+        "tokens / sec": 4445.093332565138,
+        "mem allocated avg": 7086598868.992,
+        "mem reserved avg": 17347867836.416,
+        "elapsed time": 223.13227264099987
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.14,
+        "train loss": 0.9424336891174316,
+        "train samples": 4000,
+        "train time": 48.76682744745631,
+        "eval time": 16.60897780803498,
+        "tokens / sec": 4272.084343080777,
+        "mem allocated avg": 7080125773.824,
+        "mem reserved avg": 17638306611.2,
+        "elapsed time": 291.9349672459648
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.2,
+        "train loss": 0.9085311102867126,
+        "train samples": 5000,
+        "train time": 47.41566651139874,
+        "eval time": 16.448816249030642,
+        "tokens / sec": 4398.082223517145,
+        "mem allocated avg": 7076596897.792,
+        "mem reserved avg": 17677858897.92,
+        "elapsed time": 359.1130418909597
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.18,
+        "train loss": 0.8753406238555909,
+        "train samples": 6000,
+        "train time": 48.10185396374436,
+        "eval time": 16.48715262202313,
+        "tokens / sec": 4351.828105373616,
+        "mem allocated avg": 7079910084.608,
+        "mem reserved avg": 17610313826.304,
+        "elapsed time": 427.0594008389744
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.24,
+        "train loss": 0.8501061711311341,
+        "train samples": 7000,
+        "train time": 48.353323488729075,
+        "eval time": 16.45508589997189,
+        "tokens / sec": 4329.692043790943,
+        "mem allocated avg": 7081518635.008,
+        "mem reserved avg": 17944507580.416,
+        "elapsed time": 495.1906558799674
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.3,
+        "train loss": 0.8353028309345245,
+        "train samples": 8000,
+        "train time": 47.772918620554265,
+        "eval time": 16.471650794963352,
+        "tokens / sec": 4347.567743341495,
+        "mem allocated avg": 7076895195.136,
+        "mem reserved avg": 17455510454.272,
+        "elapsed time": 562.7745764599531
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.26,
+        "train loss": 0.8205564830303193,
+        "train samples": 9000,
+        "train time": 49.30290105647873,
+        "eval time": 16.451010891993064,
+        "tokens / sec": 4359.743451075368,
+        "mem allocated avg": 7088224200.704,
+        "mem reserved avg": 17821908074.496,
+        "elapsed time": 631.8972226959886
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.3,
+        "train loss": 0.8072783839702606,
+        "train samples": 10000,
+        "train time": 47.070282332773786,
+        "eval time": 16.457994004013017,
+        "tokens / sec": 4375.73326082624,
+        "mem allocated avg": 7075521802.24,
+        "mem reserved avg": 17499282210.816,
+        "elapsed time": 698.7572857749765
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.22,
+        "train loss": 0.8001595716476441,
+        "train samples": 11000,
+        "train time": 49.0196822991129,
+        "eval time": 16.485916983976495,
+        "tokens / sec": 4322.365834750307,
+        "mem allocated avg": 7083802673.152,
+        "mem reserved avg": 18024199356.416,
+        "elapsed time": 767.6797842659871
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.26,
+        "train loss": 0.7877968080043792,
+        "train samples": 12000,
+        "train time": 48.047267597168684,
+        "eval time": 16.470330245036166,
+        "tokens / sec": 4344.284502294987,
+        "mem allocated avg": 7078835648.512,
+        "mem reserved avg": 17764907483.136,
+        "elapsed time": 835.5052842849982
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.28,
+        "train loss": 0.7942508835792541,
+        "train samples": 13000,
+        "train time": 48.499368979479186,
+        "eval time": 16.475236736994702,
+        "tokens / sec": 4348.5308043747,
+        "mem allocated avg": 7080606814.208,
+        "mem reserved avg": 17735715127.296,
+        "elapsed time": 903.7694554779446
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.32,
+        "train loss": 0.780822759628296,
+        "train samples": 14000,
+        "train time": 48.17758794862311,
+        "eval time": 16.458987591962796,
+        "tokens / sec": 4353.684128472325,
+        "mem allocated avg": 7081026895.872,
+        "mem reserved avg": 17464184274.944,
+        "elapsed time": 971.7567571739783
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.26,
+        "train loss": 0.7757164461612701,
+        "train samples": 15000,
+        "train time": 48.30266001843847,
+        "eval time": 16.458310062997043,
+        "tokens / sec": 4486.357478393083,
+        "mem allocated avg": 7091974598.656,
+        "mem reserved avg": 17988463886.336,
+        "elapsed time": 1039.8424308019457
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.34,
+        "train loss": 0.7912626936435699,
+        "train samples": 16000,
+        "train time": 47.030636349343695,
+        "eval time": 16.47025357297389,
+        "tokens / sec": 4345.529124503372,
+        "mem allocated avg": 7072683055.104,
+        "mem reserved avg": 17487336833.024,
+        "elapsed time": 1106.6578654039768
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.32,
+        "train loss": 0.7665636780261993,
+        "train samples": 17000,
+        "train time": 48.857000946998596,
+        "eval time": 16.620428661990445,
+        "tokens / sec": 4326.688005866765,
+        "mem allocated avg": 7082847784.96,
+        "mem reserved avg": 17545067233.28,
+        "elapsed time": 1175.4323937539593
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.32,
+        "train loss": 0.7785143363475799,
+        "train samples": 18000,
+        "train time": 47.66669207031373,
+        "eval time": 16.471256715012714,
+        "tokens / sec": 4359.815858282028,
+        "mem allocated avg": 7077102155.776,
+        "mem reserved avg": 17491698909.184,
+        "elapsed time": 1242.9420014299685
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.38,
+        "train loss": 0.7709136388301849,
+        "train samples": 19000,
+        "train time": 49.014523516292684,
+        "eval time": 16.465405926981475,
+        "tokens / sec": 4283.199854635232,
+        "mem allocated avg": 7080302989.312,
+        "mem reserved avg": 17688931860.48,
+        "elapsed time": 1311.757940771
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.34,
+        "train loss": 0.7789487948417664,
+        "train samples": 20000,
+        "train time": 47.309582717716694,
+        "eval time": 16.467871464032214,
+        "tokens / sec": 4402.490743635378,
+        "mem allocated avg": 7078423576.576,
+        "mem reserved avg": 17237222096.896,
+        "elapsed time": 1378.8721237509744
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.2517058377558757,
+        "train loss": 0.7789487948417664,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 3.673459053039551
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/prompt_tuning--llama-3.2-3B-sample_vocab-lr_0.001.json b/method_comparison/MetaMathQA/results/prompt_tuning--llama-3.2-3B-sample_vocab-lr_0.001.json
new file mode 100644
index 0000000..def3b78
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/prompt_tuning--llama-3.2-3B-sample_vocab-lr_0.001.json
@@ -0,0 +1,350 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T07:44:42+00:00",
+    "total_time": 1716.5059452480054,
+    "experiment_name": "prompt_tuning/llama-3.2-3B-sample_vocab-lr_0.001",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.001
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": "CAUSAL_LM",
+      "peft_type": "PROMPT_TUNING",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "num_virtual_tokens": 200,
+      "token_dim": 3072,
+      "num_transformer_submodules": 1,
+      "num_attention_heads": 24,
+      "num_layers": 28,
+      "modules_to_save": null,
+      "prompt_tuning_init": "SAMPLE_VOCAB",
+      "prompt_tuning_init_text": null,
+      "tokenizer_name_or_path": null,
+      "tokenizer_kwargs": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 17586373997,
+    "accelerator_memory_max": 24423432192,
+    "accelerator_memory_reserved_99th": 22726102220,
+    "train_time": 1432.4597771912813,
+    "file_size": 2457728,
+    "num_trainable_params": 614400,
+    "num_total_params": 3213364224,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.28,
+        "train loss": 1.231001257419586,
+        "train samples": 1000,
+        "train time": 49.07237136311596,
+        "eval time": 16.56022824399406,
+        "tokens / sec": 4314.423658750133,
+        "mem allocated avg": 7084323387.392,
+        "mem reserved avg": 17684527841.28,
+        "elapsed time": 88.38586634700187
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.28,
+        "train loss": 0.7781594865322113,
+        "train samples": 2000,
+        "train time": 48.241733307542745,
+        "eval time": 16.490848871006165,
+        "tokens / sec": 4311.515895874316,
+        "mem allocated avg": 7075966793.728,
+        "mem reserved avg": 17277822959.616,
+        "elapsed time": 156.45012381998822
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.4,
+        "train loss": 0.741938561797142,
+        "train samples": 3000,
+        "train time": 49.612739670265,
+        "eval time": 16.47905260400148,
+        "tokens / sec": 4321.490839347853,
+        "mem allocated avg": 7086541828.096,
+        "mem reserved avg": 17510808158.208,
+        "elapsed time": 225.8728333899635
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.42,
+        "train loss": 0.7171692438125611,
+        "train samples": 4000,
+        "train time": 48.20866126095643,
+        "eval time": 10.150423899991438,
+        "tokens / sec": 4321.547094458078,
+        "mem allocated avg": 7080115116.032,
+        "mem reserved avg": 17537341325.312,
+        "elapsed time": 287.67958221398294
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.26,
+        "train loss": 0.7132015836238861,
+        "train samples": 5000,
+        "train time": 48.86127889546333,
+        "eval time": 16.462877204001416,
+        "tokens / sec": 4267.960330022437,
+        "mem allocated avg": 7076709810.176,
+        "mem reserved avg": 17610590650.368,
+        "elapsed time": 356.37783604400465
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.38,
+        "train loss": 0.7038432757854461,
+        "train samples": 6000,
+        "train time": 47.56107051449362,
+        "eval time": 11.72161501395749,
+        "tokens / sec": 4401.309679020136,
+        "mem allocated avg": 7079892111.36,
+        "mem reserved avg": 17553254514.688,
+        "elapsed time": 418.98402368696406
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.28,
+        "train loss": 0.6960202144384384,
+        "train samples": 7000,
+        "train time": 47.92567691701697,
+        "eval time": 16.476755581970792,
+        "tokens / sec": 4368.326405957645,
+        "mem allocated avg": 7081680021.504,
+        "mem reserved avg": 17797270732.8,
+        "elapsed time": 486.68094182398636
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.36,
+        "train loss": 0.6972298842668533,
+        "train samples": 8000,
+        "train time": 48.42164681700524,
+        "eval time": 16.48074709100183,
+        "tokens / sec": 4289.321277835165,
+        "mem allocated avg": 7076841058.304,
+        "mem reserved avg": 17448875065.344,
+        "elapsed time": 554.9344664419768
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.44,
+        "train loss": 0.6904777873754502,
+        "train samples": 9000,
+        "train time": 48.16334705770714,
+        "eval time": 16.464009888994042,
+        "tokens / sec": 4462.895814579892,
+        "mem allocated avg": 7088048144.384,
+        "mem reserved avg": 17760679624.704,
+        "elapsed time": 622.9242907789885
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.3,
+        "train loss": 0.6871954158544541,
+        "train samples": 10000,
+        "train time": 47.13648067950271,
+        "eval time": 10.590642432973254,
+        "tokens / sec": 4369.58799279991,
+        "mem allocated avg": 7075573088.256,
+        "mem reserved avg": 17511076593.664,
+        "elapsed time": 684.0204358329647
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.4,
+        "train loss": 0.6794538542032241,
+        "train samples": 11000,
+        "train time": 49.06664197781356,
+        "eval time": 16.50549652200425,
+        "tokens / sec": 4318.229074975339,
+        "mem allocated avg": 7083983587.328,
+        "mem reserved avg": 17821639639.04,
+        "elapsed time": 752.9455686199944
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.4,
+        "train loss": 0.6709245092868805,
+        "train samples": 12000,
+        "train time": 48.61840220115846,
+        "eval time": 11.749490908987354,
+        "tokens / sec": 4293.2509204308335,
+        "mem allocated avg": 7078543196.16,
+        "mem reserved avg": 17548003246.08,
+        "elapsed time": 816.6363624369842
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.34,
+        "train loss": 0.6784907094240189,
+        "train samples": 13000,
+        "train time": 49.01847082650056,
+        "eval time": 16.607726505957544,
+        "tokens / sec": 4302.480196627877,
+        "mem allocated avg": 7080616044.544,
+        "mem reserved avg": 17588226621.44,
+        "elapsed time": 885.5438669619616
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.42,
+        "train loss": 0.6641751153469085,
+        "train samples": 14000,
+        "train time": 47.80453353270423,
+        "eval time": 10.248818032967392,
+        "tokens / sec": 4387.659171624487,
+        "mem allocated avg": 7081103153.152,
+        "mem reserved avg": 17553304846.336,
+        "elapsed time": 946.9957575129811
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.42,
+        "train loss": 0.6602498284578323,
+        "train samples": 15000,
+        "train time": 49.44991112826392,
+        "eval time": 16.504967942018993,
+        "tokens / sec": 4382.272789892635,
+        "mem allocated avg": 7091858644.992,
+        "mem reserved avg": 17967123267.584,
+        "elapsed time": 1016.2674351629685
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.42,
+        "train loss": 0.6744856735467911,
+        "train samples": 16000,
+        "train time": 47.36242724902695,
+        "eval time": 16.486980255984236,
+        "tokens / sec": 4315.087124344937,
+        "mem allocated avg": 7072767692.8,
+        "mem reserved avg": 17510019629.056,
+        "elapsed time": 1083.4467996029998
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.36,
+        "train loss": 0.6564534237384796,
+        "train samples": 17000,
+        "train time": 48.728701793181244,
+        "eval time": 11.983494354994036,
+        "tokens / sec": 4338.079863017822,
+        "mem allocated avg": 7083052060.672,
+        "mem reserved avg": 17659378794.496,
+        "elapsed time": 1147.4254322479828
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.42,
+        "train loss": 0.6627028694152832,
+        "train samples": 18000,
+        "train time": 47.626907504571136,
+        "eval time": 9.85688041697722,
+        "tokens / sec": 4363.457778148918,
+        "mem allocated avg": 7077199714.304,
+        "mem reserved avg": 17402955825.152,
+        "elapsed time": 1208.2546821089927
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.4,
+        "train loss": 0.655256854891777,
+        "train samples": 19000,
+        "train time": 47.39932202390628,
+        "eval time": 11.606938865967095,
+        "tokens / sec": 4429.1561785233,
+        "mem allocated avg": 7080305192.96,
+        "mem reserved avg": 17739850711.04,
+        "elapsed time": 1270.5360992229544
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.4,
+        "train loss": 0.6607183293104172,
+        "train samples": 20000,
+        "train time": 47.21705101500265,
+        "eval time": 11.613721745961811,
+        "tokens / sec": 4411.118346502019,
+        "mem allocated avg": 7078454282.24,
+        "mem reserved avg": 17244729901.056,
+        "elapsed time": 1332.6370788229979
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.3555724033358605,
+        "train loss": 0.6607183293104172,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 2.631608009338379
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/psoft--llama-3.2-3B-default.json b/method_comparison/MetaMathQA/results/psoft--llama-3.2-3B-default.json
new file mode 100644
index 0000000..9012ed1
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/psoft--llama-3.2-3B-default.json
@@ -0,0 +1,364 @@
+{
+  "run_info": {
+    "created_at": "2026-04-14T17:45:54+00:00",
+    "total_time": 1937.8156919419998,
+    "experiment_name": "psoft/llama-3.2-3B-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null,
+      "init_kv_cache_prefix": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "PSOFT",
+      "auto_mapping": null,
+      "peft_version": "0.19.0",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 256,
+      "target_modules": [
+        "q_proj",
+        "v_proj"
+      ],
+      "exclude_modules": null,
+      "psoft_alpha": 256,
+      "psoft_dropout": 0.0,
+      "fan_in_fan_out": false,
+      "ab_svd_init": "psoft_init",
+      "psoft_svd": "full",
+      "psoft_svd_lowrank_niter": 10,
+      "psoft_orth": true,
+      "psoft_mag_b": true,
+      "psoft_mag_a": true,
+      "use_cayley_neumann": false,
+      "num_cayley_neumann_terms": 5,
+      "cayley_neumann_eps": null,
+      "modules_to_save": null,
+      "init_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 15026516446,
+    "accelerator_memory_max": 21990735872,
+    "accelerator_memory_reserved_99th": 20199768064,
+    "train_time": 1505.385764200997,
+    "file_size": 7448144,
+    "num_trainable_params": 1856512,
+    "num_total_params": 3214606336,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.34,
+        "train loss": 1.01516472530365,
+        "train samples": 1000,
+        "train time": 43.33842796702811,
+        "eval time": 24.252313315009815,
+        "tokens / sec": 4885.248725705415,
+        "mem allocated avg": 8375423072.256,
+        "mem reserved avg": 15119048245.248,
+        "elapsed time": 90.0036859739921
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.32,
+        "train loss": 0.7340580285787582,
+        "train samples": 2000,
+        "train time": 43.51892344804946,
+        "eval time": 24.25320322001062,
+        "tokens / sec": 4779.415103139975,
+        "mem allocated avg": 8368352468.992,
+        "mem reserved avg": 14813082157.056,
+        "elapsed time": 160.662997152991
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.44,
+        "train loss": 0.6879250873327255,
+        "train samples": 3000,
+        "train time": 43.93279401304608,
+        "eval time": 23.87379320099717,
+        "tokens / sec": 4880.204066609842,
+        "mem allocated avg": 8378198431.744,
+        "mem reserved avg": 14968892162.048,
+        "elapsed time": 231.33524189700256
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.5,
+        "train loss": 0.6680566596984864,
+        "train samples": 4000,
+        "train time": 43.45829963689903,
+        "eval time": 24.127080324993585,
+        "tokens / sec": 4793.928932808698,
+        "mem allocated avg": 8369458450.432,
+        "mem reserved avg": 15005365829.632,
+        "elapsed time": 301.8884777850035
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.42,
+        "train loss": 0.6644437726736069,
+        "train samples": 5000,
+        "train time": 42.981003544147825,
+        "eval time": 19.512033010993036,
+        "tokens / sec": 4851.864377382458,
+        "mem allocated avg": 8369734297.6,
+        "mem reserved avg": 14974629969.92,
+        "elapsed time": 367.2329926319944
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.5,
+        "train loss": 0.656409296989441,
+        "train samples": 6000,
+        "train time": 43.40368786803447,
+        "eval time": 24.234126267998363,
+        "tokens / sec": 4822.885111432342,
+        "mem allocated avg": 8371589535.744,
+        "mem reserved avg": 14985442885.632,
+        "elapsed time": 437.7650993739953
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.4,
+        "train loss": 0.6492917109727859,
+        "train samples": 7000,
+        "train time": 43.8191164049349,
+        "eval time": 17.957069406998926,
+        "tokens / sec": 4777.709300784131,
+        "mem allocated avg": 8373423994.88,
+        "mem reserved avg": 15362972188.672,
+        "elapsed time": 502.5296421480016
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.4,
+        "train loss": 0.651351011633873,
+        "train samples": 8000,
+        "train time": 43.91826998388569,
+        "eval time": 19.85821281799872,
+        "tokens / sec": 4729.148030562382,
+        "mem allocated avg": 8368890132.48,
+        "mem reserved avg": 15046822330.368,
+        "elapsed time": 569.3082349729957
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.46,
+        "train loss": 0.6434478094577789,
+        "train samples": 9000,
+        "train time": 44.214122023113305,
+        "eval time": 24.340498196994304,
+        "tokens / sec": 4861.52365272874,
+        "mem allocated avg": 8379377248.256,
+        "mem reserved avg": 15277374832.64,
+        "elapsed time": 640.7805861020024
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.44,
+        "train loss": 0.6421752452850342,
+        "train samples": 10000,
+        "train time": 43.76370210298046,
+        "eval time": 24.20965617800539,
+        "tokens / sec": 4706.343158888583,
+        "mem allocated avg": 8365997271.04,
+        "mem reserved avg": 14821965692.928,
+        "elapsed time": 711.6298649300006
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.44,
+        "train loss": 0.634340330004692,
+        "train samples": 11000,
+        "train time": 43.842665812029736,
+        "eval time": 21.91094351799984,
+        "tokens / sec": 4832.758138120862,
+        "mem allocated avg": 8375715567.616,
+        "mem reserved avg": 15151327608.832,
+        "elapsed time": 780.2465031659958
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.4,
+        "train loss": 0.6267138615846634,
+        "train samples": 12000,
+        "train time": 43.95662597400951,
+        "eval time": 24.438440626996453,
+        "tokens / sec": 4748.567374652858,
+        "mem allocated avg": 8371726731.264,
+        "mem reserved avg": 15071677775.872,
+        "elapsed time": 851.6106786309974
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.46,
+        "train loss": 0.6364041697978974,
+        "train samples": 13000,
+        "train time": 43.44346187009069,
+        "eval time": 13.787291264001396,
+        "tokens / sec": 4854.608516942293,
+        "mem allocated avg": 8373763536.896,
+        "mem reserved avg": 14988026576.896,
+        "elapsed time": 911.682741933997
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.48,
+        "train loss": 0.6214166321754455,
+        "train samples": 14000,
+        "train time": 43.80178445095953,
+        "eval time": 17.285016585999983,
+        "tokens / sec": 4788.617692843908,
+        "mem allocated avg": 8371230976.0,
+        "mem reserved avg": 15019198644.224,
+        "elapsed time": 975.6572376149998
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.48,
+        "train loss": 0.6196781145334244,
+        "train samples": 15000,
+        "train time": 44.90675747311616,
+        "eval time": 17.868283932999475,
+        "tokens / sec": 4825.621180280746,
+        "mem allocated avg": 8381897398.272,
+        "mem reserved avg": 15295502614.528,
+        "elapsed time": 1041.3160545689898
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.46,
+        "train loss": 0.6325693914890289,
+        "train samples": 16000,
+        "train time": 43.95797020303144,
+        "eval time": 21.001378130997182,
+        "tokens / sec": 4649.282008610716,
+        "mem allocated avg": 8363390388.224,
+        "mem reserved avg": 15030305161.216,
+        "elapsed time": 1109.2579419859976
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.48,
+        "train loss": 0.6181137851476669,
+        "train samples": 17000,
+        "train time": 43.63497660578287,
+        "eval time": 14.508927531001973,
+        "tokens / sec": 4844.485237376865,
+        "mem allocated avg": 8374695139.328,
+        "mem reserved avg": 15006825447.424,
+        "elapsed time": 1170.2475494539976
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.44,
+        "train loss": 0.6251096996068954,
+        "train samples": 18000,
+        "train time": 43.71482467187161,
+        "eval time": 17.362020947999554,
+        "tokens / sec": 4753.9479240716455,
+        "mem allocated avg": 8369678581.76,
+        "mem reserved avg": 14920213069.824,
+        "elapsed time": 1234.2639348649973
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.4,
+        "train loss": 0.6170058059692383,
+        "train samples": 19000,
+        "train time": 44.26034616607649,
+        "eval time": 14.061754546011798,
+        "tokens / sec": 4743.275147741808,
+        "mem allocated avg": 8372185092.096,
+        "mem reserved avg": 14964882407.424,
+        "elapsed time": 1295.4217767660011
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.42,
+        "train loss": 0.6243607197999954,
+        "train samples": 20000,
+        "train time": 43.99801491193648,
+        "eval time": 15.62990901999001,
+        "tokens / sec": 4733.849934295434,
+        "mem allocated avg": 8368538847.232,
+        "mem reserved avg": 14706773327.872,
+        "elapsed time": 1357.9020721779962
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.4488248673237301,
+        "train loss": 0.6243607197999954,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.5123701095581055
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "740312add88f781978c0658806c59bc2815b9866",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "5.5.4",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.0",
+      "peft-commit-hash": "6d5a6f4f2f902dbf13d21d2661d57c3c05df1dae",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/psoft--llama-3.2-3B-fast.json b/method_comparison/MetaMathQA/results/psoft--llama-3.2-3B-fast.json
new file mode 100644
index 0000000..0b3cca0
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/psoft--llama-3.2-3B-fast.json
@@ -0,0 +1,364 @@
+{
+  "run_info": {
+    "created_at": "2026-04-14T18:18:17+00:00",
+    "total_time": 1468.6276556560042,
+    "experiment_name": "psoft/llama-3.2-3B-fast",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null,
+      "init_kv_cache_prefix": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "PSOFT",
+      "auto_mapping": null,
+      "peft_version": "0.19.0",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 256,
+      "target_modules": [
+        "v_proj",
+        "q_proj"
+      ],
+      "exclude_modules": null,
+      "psoft_alpha": 256,
+      "psoft_dropout": 0.0,
+      "fan_in_fan_out": false,
+      "ab_svd_init": "psoft_init",
+      "psoft_svd": "lowrank",
+      "psoft_svd_lowrank_niter": 10,
+      "psoft_orth": true,
+      "psoft_mag_b": true,
+      "psoft_mag_a": true,
+      "use_cayley_neumann": true,
+      "num_cayley_neumann_terms": 5,
+      "cayley_neumann_eps": null,
+      "modules_to_save": null,
+      "init_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 13830374345,
+    "accelerator_memory_max": 20770193408,
+    "accelerator_memory_reserved_99th": 18964545536,
+    "train_time": 1200.1861080279923,
+    "file_size": 7448144,
+    "num_trainable_params": 1856512,
+    "num_total_params": 3214606336,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.38,
+        "train loss": 1.0145607323646546,
+        "train samples": 1000,
+        "train time": 36.71533618000103,
+        "eval time": 15.666215841993107,
+        "tokens / sec": 5766.5003790793035,
+        "mem allocated avg": 7133637742.592,
+        "mem reserved avg": 13938871762.944,
+        "elapsed time": 74.23814530199161
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.36,
+        "train loss": 0.7338115975856782,
+        "train samples": 2000,
+        "train time": 37.135233334905934,
+        "eval time": 15.582825934994617,
+        "tokens / sec": 5601.015028616808,
+        "mem allocated avg": 7126403880.96,
+        "mem reserved avg": 13578312613.888,
+        "elapsed time": 130.02693150399136
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.4,
+        "train loss": 0.688268399477005,
+        "train samples": 3000,
+        "train time": 37.55874616494111,
+        "eval time": 11.907032759001595,
+        "tokens / sec": 5708.417396535211,
+        "mem allocated avg": 7136393115.648,
+        "mem reserved avg": 13794109554.688,
+        "elapsed time": 182.50203327499912
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.44,
+        "train loss": 0.6681705112457276,
+        "train samples": 4000,
+        "train time": 37.44897099403897,
+        "eval time": 15.572288518989808,
+        "tokens / sec": 5563.196917564501,
+        "mem allocated avg": 7127546568.704,
+        "mem reserved avg": 13830113460.224,
+        "elapsed time": 238.6246955839888
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.5,
+        "train loss": 0.66438540828228,
+        "train samples": 5000,
+        "train time": 37.498516489053145,
+        "eval time": 11.428519556997344,
+        "tokens / sec": 5561.233337347572,
+        "mem allocated avg": 7128205649.92,
+        "mem reserved avg": 13868633948.16,
+        "elapsed time": 290.5487072549877
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.34,
+        "train loss": 0.6563739287853241,
+        "train samples": 6000,
+        "train time": 37.84935744001996,
+        "eval time": 11.965642277995357,
+        "tokens / sec": 5530.635502378812,
+        "mem allocated avg": 7129830410.24,
+        "mem reserved avg": 13790418567.168,
+        "elapsed time": 343.42470807499194
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.46,
+        "train loss": 0.6491832717657089,
+        "train samples": 7000,
+        "train time": 37.42066152404004,
+        "eval time": 9.395735846002935,
+        "tokens / sec": 5594.6365316258425,
+        "mem allocated avg": 7131694694.4,
+        "mem reserved avg": 14133361639.424,
+        "elapsed time": 393.339392444992
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.42,
+        "train loss": 0.6512416273355484,
+        "train samples": 8000,
+        "train time": 37.458074163863785,
+        "eval time": 15.324161733005894,
+        "tokens / sec": 5544.759164377078,
+        "mem allocated avg": 7127220852.736,
+        "mem reserved avg": 13816918179.84,
+        "elapsed time": 449.26280711599975
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.42,
+        "train loss": 0.6431628746986389,
+        "train samples": 9000,
+        "train time": 38.11420117891976,
+        "eval time": 15.267252121004276,
+        "tokens / sec": 5639.57772566105,
+        "mem allocated avg": 7137530970.112,
+        "mem reserved avg": 14086007947.264,
+        "elapsed time": 505.74102219998895
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.36,
+        "train loss": 0.6422915599346161,
+        "train samples": 10000,
+        "train time": 37.665808972960804,
+        "eval time": 15.502652708993992,
+        "tokens / sec": 5468.274958540192,
+        "mem allocated avg": 7124247066.624,
+        "mem reserved avg": 13621077737.472,
+        "elapsed time": 561.9800479659898
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.48,
+        "train loss": 0.6344620395898819,
+        "train samples": 11000,
+        "train time": 37.729417049049516,
+        "eval time": 14.667384405009216,
+        "tokens / sec": 5615.803703633893,
+        "mem allocated avg": 7134092083.2,
+        "mem reserved avg": 13956924047.36,
+        "elapsed time": 617.4243246029946
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.44,
+        "train loss": 0.6265726834535599,
+        "train samples": 12000,
+        "train time": 37.67032070188725,
+        "eval time": 10.909270905001904,
+        "tokens / sec": 5540.993442870869,
+        "mem allocated avg": 7129951842.304,
+        "mem reserved avg": 13895787872.256,
+        "elapsed time": 669.1392444079975
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.4,
+        "train loss": 0.6364836758375167,
+        "train samples": 13000,
+        "train time": 37.44520631492196,
+        "eval time": 15.535097809988656,
+        "tokens / sec": 5632.256322111803,
+        "mem allocated avg": 7132112439.296,
+        "mem reserved avg": 13748290977.792,
+        "elapsed time": 725.1316548469913
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.42,
+        "train loss": 0.6213824005126953,
+        "train samples": 14000,
+        "train time": 37.835670114000095,
+        "eval time": 15.68471787100134,
+        "tokens / sec": 5543.710455451601,
+        "mem allocated avg": 7129427118.08,
+        "mem reserved avg": 13794428321.792,
+        "elapsed time": 781.7749934619933
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.44,
+        "train loss": 0.6196332731246948,
+        "train samples": 15000,
+        "train time": 38.61936162307393,
+        "eval time": 10.862610769996536,
+        "tokens / sec": 5611.252773026842,
+        "mem allocated avg": 7140212428.8,
+        "mem reserved avg": 14072191909.888,
+        "elapsed time": 834.3267648119945
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.46,
+        "train loss": 0.6326277133226395,
+        "train samples": 16000,
+        "train time": 37.171097063837806,
+        "eval time": 10.443736899003852,
+        "tokens / sec": 5498.169710972181,
+        "mem allocated avg": 7121660831.744,
+        "mem reserved avg": 13814359654.4,
+        "elapsed time": 885.054980269997
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.38,
+        "train loss": 0.618290886759758,
+        "train samples": 17000,
+        "train time": 37.33161400198878,
+        "eval time": 14.996235694008647,
+        "tokens / sec": 5662.4661336297595,
+        "mem allocated avg": 7132966852.608,
+        "mem reserved avg": 13792633159.68,
+        "elapsed time": 940.3594205099944
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.42,
+        "train loss": 0.6252515635490418,
+        "train samples": 18000,
+        "train time": 37.50360515809734,
+        "eval time": 11.315083836001577,
+        "tokens / sec": 5541.280608195885,
+        "mem allocated avg": 7127867189.248,
+        "mem reserved avg": 13762828435.456,
+        "elapsed time": 992.3431118549925
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.4,
+        "train loss": 0.6172080825567245,
+        "train samples": 19000,
+        "train time": 37.360017932980554,
+        "eval time": 9.651658456001314,
+        "tokens / sec": 5619.349551079063,
+        "mem allocated avg": 7130523303.936,
+        "mem reserved avg": 13808235970.56,
+        "elapsed time": 1042.3337350419897
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.42,
+        "train loss": 0.6243040920495987,
+        "train samples": 20000,
+        "train time": 37.632196523059974,
+        "eval time": 10.714210777005064,
+        "tokens / sec": 5534.622457457984,
+        "mem allocated avg": 7126828070.912,
+        "mem reserved avg": 13503981158.4,
+        "elapsed time": 1093.72050657199
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.44351781652767247,
+        "train loss": 0.6243040920495987,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.5018253326416016
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "740312add88f781978c0658806c59bc2815b9866",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "5.5.4",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.0",
+      "peft-commit-hash": "6d5a6f4f2f902dbf13d21d2661d57c3c05df1dae",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/ptuning--llama-3.2-3B-default.json b/method_comparison/MetaMathQA/results/ptuning--llama-3.2-3B-default.json
new file mode 100644
index 0000000..6af724b
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/ptuning--llama-3.2-3B-default.json
@@ -0,0 +1,351 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T08:13:23+00:00",
+    "total_time": 1162.917062154971,
+    "experiment_name": "ptuning/llama-3.2-3B-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": "CAUSAL_LM",
+      "peft_type": "P_TUNING",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "num_virtual_tokens": 20,
+      "token_dim": 3072,
+      "num_transformer_submodules": 1,
+      "num_attention_heads": 24,
+      "num_layers": 28,
+      "modules_to_save": null,
+      "encoder_reparameterization_type": "MLP",
+      "encoder_hidden_size": 3072,
+      "encoder_num_layers": 2,
+      "encoder_dropout": 0.0
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 14104160475,
+    "accelerator_memory_max": 20950548480,
+    "accelerator_memory_reserved_99th": 19218300928,
+    "train_time": 959.7272375969915,
+    "file_size": 245880,
+    "num_trainable_params": 28382208,
+    "num_total_params": 3241132032,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.12,
+        "train loss": 0.9454967255592346,
+        "train samples": 1000,
+        "train time": 29.694366472947877,
+        "eval time": 11.680081729020458,
+        "tokens / sec": 7129.938272731966,
+        "mem allocated avg": 7266438576.128,
+        "mem reserved avg": 14210964652.032,
+        "elapsed time": 62.83816469996236
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.36,
+        "train loss": 0.7915761218070984,
+        "train samples": 2000,
+        "train time": 30.064934794034343,
+        "eval time": 11.6559070070507,
+        "tokens / sec": 6918.192286958545,
+        "mem allocated avg": 7258846287.872,
+        "mem reserved avg": 13882106052.608,
+        "elapsed time": 107.20484153198777
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.32,
+        "train loss": 0.7556082547903061,
+        "train samples": 3000,
+        "train time": 30.023478755319957,
+        "eval time": 11.630144803028088,
+        "tokens / sec": 7141.111186591247,
+        "mem allocated avg": 7269281730.56,
+        "mem reserved avg": 14078433034.24,
+        "elapsed time": 151.32677704497473
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.28,
+        "train loss": 0.7297289679050446,
+        "train samples": 4000,
+        "train time": 29.457952680124436,
+        "eval time": 11.804060328984633,
+        "tokens / sec": 7072.317695063931,
+        "mem allocated avg": 7260512626.688,
+        "mem reserved avg": 14043024719.872,
+        "elapsed time": 195.22547230595956
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.38,
+        "train loss": 0.7234208507537842,
+        "train samples": 5000,
+        "train time": 29.54452143079834,
+        "eval time": 11.626074030995369,
+        "tokens / sec": 7058.43215258894,
+        "mem allocated avg": 7259926929.408,
+        "mem reserved avg": 14128538189.824,
+        "elapsed time": 238.97390070999973
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.36,
+        "train loss": 0.7123123975992203,
+        "train samples": 6000,
+        "train time": 30.126697142142802,
+        "eval time": 8.240376622998156,
+        "tokens / sec": 6948.355440768741,
+        "mem allocated avg": 7261799639.04,
+        "mem reserved avg": 14042739507.2,
+        "elapsed time": 279.96362110297196
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.42,
+        "train loss": 0.7047000522613526,
+        "train samples": 7000,
+        "train time": 29.664779813203495,
+        "eval time": 11.633714700001292,
+        "tokens / sec": 7057.358973108514,
+        "mem allocated avg": 7263532308.48,
+        "mem reserved avg": 14314966614.016,
+        "elapsed time": 323.87410058197565
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.44,
+        "train loss": 0.7051602005958557,
+        "train samples": 8000,
+        "train time": 29.419329382071737,
+        "eval time": 11.648401496990118,
+        "tokens / sec": 7059.848214166664,
+        "mem allocated avg": 7259382927.36,
+        "mem reserved avg": 14145265074.176,
+        "elapsed time": 367.623096796975
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.44,
+        "train loss": 0.6980359296798706,
+        "train samples": 9000,
+        "train time": 30.83813531260239,
+        "eval time": 11.641796185984276,
+        "tokens / sec": 6970.20094830957,
+        "mem allocated avg": 7271977609.216,
+        "mem reserved avg": 14313431498.752,
+        "elapsed time": 412.71304436796345
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.5,
+        "train loss": 0.6962304570674896,
+        "train samples": 10000,
+        "train time": 29.281850074534304,
+        "eval time": 7.721943242009729,
+        "tokens / sec": 7033.947632261268,
+        "mem allocated avg": 7256155267.072,
+        "mem reserved avg": 13909410971.648,
+        "elapsed time": 452.32350523298373
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.4,
+        "train loss": 0.6884069440364837,
+        "train samples": 11000,
+        "train time": 29.80504708213266,
+        "eval time": 11.643363915965892,
+        "tokens / sec": 7108.8966716317345,
+        "mem allocated avg": 7266777749.504,
+        "mem reserved avg": 14297912573.952,
+        "elapsed time": 496.34979761595605
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.34,
+        "train loss": 0.6823657184839249,
+        "train samples": 12000,
+        "train time": 29.4866174882045,
+        "eval time": 11.663472635962535,
+        "tokens / sec": 7078.838394519087,
+        "mem allocated avg": 7261770512.384,
+        "mem reserved avg": 14176470695.936,
+        "elapsed time": 540.1913515449851
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.32,
+        "train loss": 0.6892943847179412,
+        "train samples": 13000,
+        "train time": 30.05981874052668,
+        "eval time": 9.359989358054008,
+        "tokens / sec": 7016.043636872069,
+        "mem allocated avg": 7263956414.464,
+        "mem reserved avg": 14069599830.016,
+        "elapsed time": 582.1699139429838
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.34,
+        "train loss": 0.6757683880329132,
+        "train samples": 14000,
+        "train time": 29.95969556894852,
+        "eval time": 11.67419690900715,
+        "tokens / sec": 7001.072474761515,
+        "mem allocated avg": 7262049505.28,
+        "mem reserved avg": 14046656987.136,
+        "elapsed time": 626.462889155955
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.32,
+        "train loss": 0.6726086636781693,
+        "train samples": 15000,
+        "train time": 30.04007897916017,
+        "eval time": 11.621128266968299,
+        "tokens / sec": 7213.795947418589,
+        "mem allocated avg": 7273184010.24,
+        "mem reserved avg": 14348948865.024,
+        "elapsed time": 670.6827715289546
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.36,
+        "train loss": 0.687798623919487,
+        "train samples": 16000,
+        "train time": 28.8626030132873,
+        "eval time": 6.513009499001782,
+        "tokens / sec": 7080.892873934969,
+        "mem allocated avg": 7255382544.384,
+        "mem reserved avg": 14072502288.384,
+        "elapsed time": 708.7366754019749
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.34,
+        "train loss": 0.6694162834882736,
+        "train samples": 17000,
+        "train time": 29.575119761226233,
+        "eval time": 6.9559804140008055,
+        "tokens / sec": 7147.528115072473,
+        "mem allocated avg": 7265205653.504,
+        "mem reserved avg": 14095831007.232,
+        "elapsed time": 747.7560498069506
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.42,
+        "train loss": 0.6779570702314377,
+        "train samples": 18000,
+        "train time": 29.56798030581558,
+        "eval time": 6.977328688022681,
+        "tokens / sec": 7028.4814130211425,
+        "mem allocated avg": 7259650541.568,
+        "mem reserved avg": 14029410009.088,
+        "elapsed time": 786.97692555096
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.32,
+        "train loss": 0.6683919057846069,
+        "train samples": 19000,
+        "train time": 30.30186787992716,
+        "eval time": 6.962075466988608,
+        "tokens / sec": 6928.252767515686,
+        "mem allocated avg": 7262556618.752,
+        "mem reserved avg": 14063425814.528,
+        "elapsed time": 826.7863181569846
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.38,
+        "train loss": 0.6739522596597671,
+        "train samples": 20000,
+        "train time": 29.33842807688052,
+        "eval time": 7.4907851399620995,
+        "tokens / sec": 7099.221521146537,
+        "mem allocated avg": 7259827462.144,
+        "mem reserved avg": 13813571125.248,
+        "elapsed time": 866.1968886919785
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.3821076573161486,
+        "train loss": 0.6739522596597671,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 3.1548709869384766
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/pvera--llama-3.2-3B-default.json b/method_comparison/MetaMathQA/results/pvera--llama-3.2-3B-default.json
new file mode 100644
index 0000000..b71b93b
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/pvera--llama-3.2-3B-default.json
@@ -0,0 +1,357 @@
+{
+  "run_info": {
+    "created_at": "2026-04-14T18:42:51+00:00",
+    "total_time": 1291.4271428469947,
+    "experiment_name": "pvera/llama-3.2-3B-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.003
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null,
+      "init_kv_cache_prefix": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "PVERA",
+      "auto_mapping": null,
+      "peft_version": "0.19.0",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 256,
+      "target_modules": [
+        "v_proj",
+        "q_proj"
+      ],
+      "projection_prng_key": 0,
+      "save_projection": true,
+      "pvera_dropout": 0.0,
+      "d_initial": 0.1,
+      "fan_in_fan_out": false,
+      "bias": "none",
+      "modules_to_save": null,
+      "init_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "sample_at_inference": false
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 14228733401,
+    "accelerator_memory_max": 22152216576,
+    "accelerator_memory_reserved_99th": 20065550336,
+    "train_time": 1069.4061620029825,
+    "file_size": 10025160,
+    "num_trainable_params": 143360,
+    "num_total_params": 3212893184,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.0,
+        "train loss": 1.3202282037734985,
+        "train samples": 1000,
+        "train time": 32.67286523502844,
+        "eval time": 12.301227215008112,
+        "tokens / sec": 6479.964290766179,
+        "mem allocated avg": 6789406173.184,
+        "mem reserved avg": 14332498804.736,
+        "elapsed time": 67.55532218200096
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.34,
+        "train loss": 1.1538902192115783,
+        "train samples": 2000,
+        "train time": 32.96136713196756,
+        "eval time": 12.322236451000208,
+        "tokens / sec": 6310.266172129619,
+        "mem allocated avg": 6782129682.432,
+        "mem reserved avg": 13934107033.6,
+        "elapsed time": 116.44386823300738
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.34,
+        "train loss": 0.898421834230423,
+        "train samples": 3000,
+        "train time": 33.59121551607677,
+        "eval time": 12.133125199994538,
+        "tokens / sec": 6382.650842074696,
+        "mem allocated avg": 6792430583.808,
+        "mem reserved avg": 14168837062.656,
+        "elapsed time": 165.66208046700922
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.3,
+        "train loss": 0.8379638421535492,
+        "train samples": 4000,
+        "train time": 32.67811248412181,
+        "eval time": 8.892382420992362,
+        "tokens / sec": 6375.398827004766,
+        "mem allocated avg": 6784067207.168,
+        "mem reserved avg": 14229713190.912,
+        "elapsed time": 210.88579634900088
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.34,
+        "train loss": 0.8170157277584076,
+        "train samples": 5000,
+        "train time": 32.431128902884666,
+        "eval time": 12.215805946005275,
+        "tokens / sec": 6430.180109501248,
+        "mem allocated avg": 6784477261.824,
+        "mem reserved avg": 14274600632.32,
+        "elapsed time": 259.07680079800775
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.38,
+        "train loss": 0.7990756661891937,
+        "train samples": 6000,
+        "train time": 32.99714762700023,
+        "eval time": 11.58432873399579,
+        "tokens / sec": 6343.911975855541,
+        "mem allocated avg": 6785691637.76,
+        "mem reserved avg": 14198213967.872,
+        "elapsed time": 307.29504832200473
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.26,
+        "train loss": 0.7860628130435944,
+        "train samples": 7000,
+        "train time": 32.93966836592881,
+        "eval time": 12.32378633999906,
+        "tokens / sec": 6355.710618402783,
+        "mem allocated avg": 6786881329.152,
+        "mem reserved avg": 14573822279.68,
+        "elapsed time": 356.20853258200805
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.32,
+        "train loss": 0.7856944581270218,
+        "train samples": 8000,
+        "train time": 32.91093613029807,
+        "eval time": 12.19419355399441,
+        "tokens / sec": 6310.850568871951,
+        "mem allocated avg": 6783044034.56,
+        "mem reserved avg": 14224982016.0,
+        "elapsed time": 404.9654307870078
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.36,
+        "train loss": 0.7764198180437089,
+        "train samples": 9000,
+        "train time": 34.04934502001561,
+        "eval time": 10.626323529999354,
+        "tokens / sec": 6312.838025919286,
+        "mem allocated avg": 6793975109.632,
+        "mem reserved avg": 14508609241.088,
+        "elapsed time": 453.26413831600803
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.4,
+        "train loss": 0.7704147508144379,
+        "train samples": 10000,
+        "train time": 32.65568613614596,
+        "eval time": 12.24934491699969,
+        "tokens / sec": 6307.232349713792,
+        "mem allocated avg": 6780232609.792,
+        "mem reserved avg": 14000259596.288,
+        "elapsed time": 501.78799178201007
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.34,
+        "train loss": 0.7629369251728058,
+        "train samples": 11000,
+        "train time": 34.34300080695539,
+        "eval time": 12.220637089994852,
+        "tokens / sec": 6169.554058219874,
+        "mem allocated avg": 6790175119.36,
+        "mem reserved avg": 14390975791.104,
+        "elapsed time": 551.9675445120083
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.48,
+        "train loss": 0.7516447757482528,
+        "train samples": 12000,
+        "train time": 33.29613821301609,
+        "eval time": 12.233222769995336,
+        "tokens / sec": 6268.925202815355,
+        "mem allocated avg": 6786514487.296,
+        "mem reserved avg": 14305999192.064,
+        "elapsed time": 601.2189341290068
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.28,
+        "train loss": 0.7555468535423279,
+        "train samples": 13000,
+        "train time": 32.999268432031386,
+        "eval time": 12.178287804010324,
+        "tokens / sec": 6391.081076066669,
+        "mem allocated avg": 6787544530.944,
+        "mem reserved avg": 14133839790.08,
+        "elapsed time": 649.8716620650084
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.36,
+        "train loss": 0.7404804437160492,
+        "train samples": 14000,
+        "train time": 32.64920209176489,
+        "eval time": 12.186518534013885,
+        "tokens / sec": 6424.3530181984215,
+        "mem allocated avg": 6785403799.552,
+        "mem reserved avg": 14191570190.336,
+        "elapsed time": 698.362258417008
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.34,
+        "train loss": 0.7344836096763611,
+        "train samples": 15000,
+        "train time": 33.48411372501869,
+        "eval time": 8.465133406003588,
+        "tokens / sec": 6471.8153145586675,
+        "mem allocated avg": 6796390723.584,
+        "mem reserved avg": 14502049349.632,
+        "elapsed time": 743.888114567002
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.32,
+        "train loss": 0.7513675209283829,
+        "train samples": 16000,
+        "train time": 32.732514199859,
+        "eval time": 7.7433306710008765,
+        "tokens / sec": 6243.730583973302,
+        "mem allocated avg": 6777416720.384,
+        "mem reserved avg": 14199237378.048,
+        "elapsed time": 788.0349280920054
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.28,
+        "train loss": 0.7285181393623352,
+        "train samples": 17000,
+        "train time": 33.14160475527751,
+        "eval time": 7.952340036004898,
+        "tokens / sec": 6378.357401849654,
+        "mem allocated avg": 6788771710.976,
+        "mem reserved avg": 14182678265.856,
+        "elapsed time": 832.6118042430026
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.42,
+        "train loss": 0.7370574896335602,
+        "train samples": 18000,
+        "train time": 32.7690467388602,
+        "eval time": 7.387523283003247,
+        "tokens / sec": 6341.89946555731,
+        "mem allocated avg": 6783872323.584,
+        "mem reserved avg": 14155977326.592,
+        "elapsed time": 876.4409682330006
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.36,
+        "train loss": 0.7286350094079971,
+        "train samples": 19000,
+        "train time": 33.32835812299163,
+        "eval time": 12.151384285010863,
+        "tokens / sec": 6299.110181943622,
+        "mem allocated avg": 6786492006.4,
+        "mem reserved avg": 14207953141.76,
+        "elapsed time": 925.4097285200114
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.34,
+        "train loss": 0.7356556997299194,
+        "train samples": 20000,
+        "train time": 32.469325570142246,
+        "eval time": 8.883527666999726,
+        "tokens / sec": 6414.669733439971,
+        "mem allocated avg": 6782703605.76,
+        "mem reserved avg": 13858743779.328,
+        "elapsed time": 970.3014086380135
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.3305534495830174,
+        "train loss": 0.7356556997299194,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.29680824279785156
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "740312add88f781978c0658806c59bc2815b9866",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "5.5.4",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.0",
+      "peft-commit-hash": "6d5a6f4f2f902dbf13d21d2661d57c3c05df1dae",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/randlora--llama-3.2-3B-default.json b/method_comparison/MetaMathQA/results/randlora--llama-3.2-3B-default.json
new file mode 100644
index 0000000..c467642
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/randlora--llama-3.2-3B-default.json
@@ -0,0 +1,358 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T08:32:50+00:00",
+    "total_time": 1712.8715220090235,
+    "experiment_name": "randlora/llama-3.2-3B-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "RANDLORA",
+      "auto_mapping": null,
+      "peft_version": null,
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 32,
+      "target_modules": [
+        "v_proj",
+        "q_proj"
+      ],
+      "projection_prng_key": 0,
+      "save_projection": true,
+      "sparse": false,
+      "very_sparse": false,
+      "randlora_dropout": 0.0,
+      "fan_in_fan_out": false,
+      "randlora_alpha": 640,
+      "bias": "none",
+      "modules_to_save": null,
+      "init_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 15193692176,
+    "accelerator_memory_max": 22791847936,
+    "accelerator_memory_reserved_99th": 20508049408,
+    "train_time": 1465.4105980930617,
+    "file_size": 2211281240,
+    "num_trainable_params": 9289728,
+    "num_total_params": 3222039552,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.38,
+        "train loss": 0.9159073839187623,
+        "train samples": 1000,
+        "train time": 51.456300139427185,
+        "eval time": 8.755500879022293,
+        "tokens / sec": 4114.539899416034,
+        "mem allocated avg": 6994605942.784,
+        "mem reserved avg": 15311281586.176,
+        "elapsed time": 84.91182701400248
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.34,
+        "train loss": 0.7010563344955444,
+        "train samples": 2000,
+        "train time": 52.27174317778554,
+        "eval time": 14.115188423951622,
+        "tokens / sec": 3979.1096939807776,
+        "mem allocated avg": 6986201692.16,
+        "mem reserved avg": 14981995167.744,
+        "elapsed time": 154.25366032699822
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.36,
+        "train loss": 0.6810104308128357,
+        "train samples": 3000,
+        "train time": 52.0417874493869,
+        "eval time": 8.199473799031693,
+        "tokens / sec": 4119.785474480774,
+        "mem allocated avg": 6997675347.968,
+        "mem reserved avg": 15224560156.672,
+        "elapsed time": 217.4881883119815
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.28,
+        "train loss": 0.6662307423353195,
+        "train samples": 4000,
+        "train time": 51.765757714165375,
+        "eval time": 7.892937373020686,
+        "tokens / sec": 4024.5909496846825,
+        "mem allocated avg": 6988936497.152,
+        "mem reserved avg": 15255941939.2,
+        "elapsed time": 280.21508718596306
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.38,
+        "train loss": 0.6655746358633041,
+        "train samples": 5000,
+        "train time": 52.88386500120396,
+        "eval time": 14.099892683967482,
+        "tokens / sec": 3943.3199520355106,
+        "mem allocated avg": 6988741001.216,
+        "mem reserved avg": 15194075955.2,
+        "elapsed time": 350.0570412139641
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.38,
+        "train loss": 0.6581832259893418,
+        "train samples": 6000,
+        "train time": 52.76923948794138,
+        "eval time": 14.133205129997805,
+        "tokens / sec": 3966.9133387422708,
+        "mem allocated avg": 6991358814.208,
+        "mem reserved avg": 15142125305.856,
+        "elapsed time": 419.9533305739751
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.36,
+        "train loss": 0.6510355799198151,
+        "train samples": 7000,
+        "train time": 53.25456840818515,
+        "eval time": 13.085501310008112,
+        "tokens / sec": 3931.212030399676,
+        "mem allocated avg": 6991980468.224,
+        "mem reserved avg": 15527758004.224,
+        "elapsed time": 489.19832555996254
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.46,
+        "train loss": 0.6502977329492569,
+        "train samples": 8000,
+        "train time": 53.048176583775785,
+        "eval time": 14.269489981001243,
+        "tokens / sec": 3915.2335362931512,
+        "mem allocated avg": 6987123507.2,
+        "mem reserved avg": 15160764792.832,
+        "elapsed time": 559.521614014986
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.46,
+        "train loss": 0.6383942588567734,
+        "train samples": 9000,
+        "train time": 54.19255740486551,
+        "eval time": 14.067514252034016,
+        "tokens / sec": 3966.374910011196,
+        "mem allocated avg": 6999139655.68,
+        "mem reserved avg": 15462352027.648,
+        "elapsed time": 630.752589983982
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.42,
+        "train loss": 0.6331259000301361,
+        "train samples": 10000,
+        "train time": 51.30145365791395,
+        "eval time": 14.185831039969344,
+        "tokens / sec": 4014.837500968684,
+        "mem allocated avg": 6985442590.72,
+        "mem reserved avg": 15002463371.264,
+        "elapsed time": 699.3249540069955
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.5,
+        "train loss": 0.6209538959264755,
+        "train samples": 11000,
+        "train time": 52.28545083821518,
+        "eval time": 8.485180826974101,
+        "tokens / sec": 4052.3892708817802,
+        "mem allocated avg": 6994917660.672,
+        "mem reserved avg": 15347461652.48,
+        "elapsed time": 763.0090306919883
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.42,
+        "train loss": 0.608346626996994,
+        "train samples": 12000,
+        "train time": 50.35002116265241,
+        "eval time": 7.221828919020481,
+        "tokens / sec": 4145.599051998574,
+        "mem allocated avg": 6990200410.112,
+        "mem reserved avg": 15265429454.848,
+        "elapsed time": 823.5788191119791
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.5,
+        "train loss": 0.6135392972230911,
+        "train samples": 13000,
+        "train time": 50.94754268962424,
+        "eval time": 14.057202987954952,
+        "tokens / sec": 4139.571584145337,
+        "mem allocated avg": 6993134067.712,
+        "mem reserved avg": 15059187138.56,
+        "elapsed time": 891.3881165689672
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.52,
+        "train loss": 0.5913569860458374,
+        "train samples": 14000,
+        "train time": 51.22462305892259,
+        "eval time": 10.398285192961339,
+        "tokens / sec": 4094.710462949216,
+        "mem allocated avg": 6989725995.008,
+        "mem reserved avg": 15092934508.544,
+        "elapsed time": 955.9796246159822
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.46,
+        "train loss": 0.586094471335411,
+        "train samples": 15000,
+        "train time": 54.32701862248359,
+        "eval time": 7.748301387007814,
+        "tokens / sec": 3988.8623652599267,
+        "mem allocated avg": 7002481041.408,
+        "mem reserved avg": 15310149124.096,
+        "elapsed time": 1020.95719456597
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.48,
+        "train loss": 0.5912544637918472,
+        "train samples": 16000,
+        "train time": 51.06255231570685,
+        "eval time": 14.150051894015633,
+        "tokens / sec": 4002.4047120953414,
+        "mem allocated avg": 6982720993.28,
+        "mem reserved avg": 15162954219.52,
+        "elapsed time": 1089.1380827649846
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.5,
+        "train loss": 0.5755240997076034,
+        "train samples": 17000,
+        "train time": 52.308833500603214,
+        "eval time": 14.18892294500256,
+        "tokens / sec": 4041.1721281752975,
+        "mem allocated avg": 6993589919.744,
+        "mem reserved avg": 15129659834.368,
+        "elapsed time": 1158.4711514469818
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.56,
+        "train loss": 0.5807081238031387,
+        "train samples": 18000,
+        "train time": 50.61249336565379,
+        "eval time": 9.862378416000865,
+        "tokens / sec": 4106.0612939695175,
+        "mem allocated avg": 6988681547.776,
+        "mem reserved avg": 15200375799.808,
+        "elapsed time": 1221.9246637789765
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.52,
+        "train loss": 0.5690834984779358,
+        "train samples": 19000,
+        "train time": 51.20076460047858,
+        "eval time": 8.214846904971637,
+        "tokens / sec": 4100.309861349955,
+        "mem allocated avg": 6991610628.096,
+        "mem reserved avg": 15140388864.0,
+        "elapsed time": 1284.1992750130012
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.5,
+        "train loss": 0.5778189089298248,
+        "train samples": 20000,
+        "train time": 51.87798086879775,
+        "eval time": 8.667530598992016,
+        "tokens / sec": 4014.8054436958814,
+        "mem allocated avg": 6988335155.2,
+        "mem reserved avg": 14901984624.64,
+        "elapsed time": 1347.629596157989
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.49962092494313876,
+        "train loss": 0.5778189089298248,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.46999263763427734
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/road--llama-3.2-3B-lr_0.001.json b/method_comparison/MetaMathQA/results/road--llama-3.2-3B-lr_0.001.json
new file mode 100644
index 0000000..5b291e2
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/road--llama-3.2-3B-lr_0.001.json
@@ -0,0 +1,348 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T09:01:28+00:00",
+    "total_time": 1209.8416560290498,
+    "experiment_name": "road/llama-3.2-3B-lr_0.001",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.001
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "ROAD",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "variant": "road_2",
+      "group_size": 64,
+      "init_weights": true,
+      "target_modules": [
+        "v_proj",
+        "q_proj"
+      ],
+      "modules_to_save": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 14529478839,
+    "accelerator_memory_max": 22806528000,
+    "accelerator_memory_reserved_99th": 20495466496,
+    "train_time": 986.1049144260469,
+    "file_size": 931480,
+    "num_trainable_params": 229376,
+    "num_total_params": 3212979200,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.22,
+        "train loss": 1.1801395919322968,
+        "train samples": 1000,
+        "train time": 30.463671060162596,
+        "eval time": 12.11280647298554,
+        "tokens / sec": 6949.88465381854,
+        "mem allocated avg": 6785091975.168,
+        "mem reserved avg": 14651240742.912,
+        "elapsed time": 66.61390974500682
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.3,
+        "train loss": 0.8728977775573731,
+        "train samples": 2000,
+        "train time": 30.350360362324864,
+        "eval time": 12.122786874999292,
+        "tokens / sec": 6853.1311495791215,
+        "mem allocated avg": 6777472542.72,
+        "mem reserved avg": 14239108431.872,
+        "elapsed time": 112.51008765597362
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.42,
+        "train loss": 0.7738239982128143,
+        "train samples": 3000,
+        "train time": 31.060686238168273,
+        "eval time": 12.105645439994987,
+        "tokens / sec": 6902.648523474598,
+        "mem allocated avg": 6787427880.96,
+        "mem reserved avg": 14477940490.24,
+        "elapsed time": 159.04484326101374
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.36,
+        "train loss": 0.7328966956138611,
+        "train samples": 4000,
+        "train time": 31.1341793507454,
+        "eval time": 12.271532059996389,
+        "tokens / sec": 6691.552639077739,
+        "mem allocated avg": 6779240853.504,
+        "mem reserved avg": 14547599491.072,
+        "elapsed time": 205.96491558500566
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.32,
+        "train loss": 0.7226412436962127,
+        "train samples": 5000,
+        "train time": 30.673152873758227,
+        "eval time": 12.08470779901836,
+        "tokens / sec": 6798.714199948135,
+        "mem allocated avg": 6779142604.8,
+        "mem reserved avg": 14559075106.816,
+        "elapsed time": 252.09245199902216
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.38,
+        "train loss": 0.7143599749803543,
+        "train samples": 6000,
+        "train time": 31.072990959743038,
+        "eval time": 12.123655039002188,
+        "tokens / sec": 6736.750905994249,
+        "mem allocated avg": 6781227952.128,
+        "mem reserved avg": 14496538034.176,
+        "elapsed time": 298.79225073900307
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.38,
+        "train loss": 0.7038573758602142,
+        "train samples": 7000,
+        "train time": 30.712441952317022,
+        "eval time": 12.087091822992079,
+        "tokens / sec": 6816.618500249399,
+        "mem allocated avg": 6782587774.976,
+        "mem reserved avg": 14888504131.584,
+        "elapsed time": 345.02615644899197
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.3,
+        "train loss": 0.7051438037157058,
+        "train samples": 8000,
+        "train time": 30.437189053802285,
+        "eval time": 12.269888009992428,
+        "tokens / sec": 6823.757595777529,
+        "mem allocated avg": 6778266038.272,
+        "mem reserved avg": 14524782477.312,
+        "elapsed time": 391.30238440597896
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.4,
+        "train loss": 0.697867576956749,
+        "train samples": 9000,
+        "train time": 31.4548720899038,
+        "eval time": 12.078225647972431,
+        "tokens / sec": 6833.535974511012,
+        "mem allocated avg": 6789062723.584,
+        "mem reserved avg": 14819180675.072,
+        "elapsed time": 438.25679710297845
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.38,
+        "train loss": 0.6966045496463775,
+        "train samples": 10000,
+        "train time": 30.316960251017008,
+        "eval time": 12.1344860860263,
+        "tokens / sec": 6793.78797526677,
+        "mem allocated avg": 6775575060.48,
+        "mem reserved avg": 14285396770.816,
+        "elapsed time": 484.1519402990234
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.4,
+        "train loss": 0.6900997126102447,
+        "train samples": 11000,
+        "train time": 31.133579084766097,
+        "eval time": 12.133857114997227,
+        "tokens / sec": 6805.545852056406,
+        "mem allocated avg": 6784651790.336,
+        "mem reserved avg": 14683520106.496,
+        "elapsed time": 530.7991969200084
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.38,
+        "train loss": 0.6820800434350968,
+        "train samples": 12000,
+        "train time": 31.004261121852323,
+        "eval time": 6.647833172988612,
+        "tokens / sec": 6732.332668069386,
+        "mem allocated avg": 6781542193.152,
+        "mem reserved avg": 14604935626.752,
+        "elapsed time": 571.967426163028
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.4,
+        "train loss": 0.6917668293714523,
+        "train samples": 13000,
+        "train time": 30.61097677750513,
+        "eval time": 8.696813674003351,
+        "tokens / sec": 6889.718075085513,
+        "mem allocated avg": 6783328645.12,
+        "mem reserved avg": 14447456288.768,
+        "elapsed time": 614.5629294660175
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.44,
+        "train loss": 0.6792756502628327,
+        "train samples": 14000,
+        "train time": 30.631839248526376,
+        "eval time": 8.344476633996237,
+        "tokens / sec": 6847.450402773009,
+        "mem allocated avg": 6780746895.36,
+        "mem reserved avg": 14468931125.248,
+        "elapsed time": 657.0185567580047
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.4,
+        "train loss": 0.6768034971952438,
+        "train samples": 15000,
+        "train time": 31.22799357509939,
+        "eval time": 7.472214682027698,
+        "tokens / sec": 6939.3827521725525,
+        "mem allocated avg": 6791758675.968,
+        "mem reserved avg": 14830622736.384,
+        "elapsed time": 699.1621996440226
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.4,
+        "train loss": 0.693776785492897,
+        "train samples": 16000,
+        "train time": 30.5784999235766,
+        "eval time": 7.540951641974971,
+        "tokens / sec": 6683.552185711522,
+        "mem allocated avg": 6772682035.2,
+        "mem reserved avg": 14486186491.904,
+        "elapsed time": 740.7859192459728
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.42,
+        "train loss": 0.674255707025528,
+        "train samples": 17000,
+        "train time": 31.011587454471737,
+        "eval time": 12.230024265998509,
+        "tokens / sec": 6816.452086186856,
+        "mem allocated avg": 6784054867.968,
+        "mem reserved avg": 14463939903.488,
+        "elapsed time": 787.3081514210207
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.44,
+        "train loss": 0.6836280490159988,
+        "train samples": 18000,
+        "train time": 30.32553677726537,
+        "eval time": 12.078615510021336,
+        "tokens / sec": 6852.904254469726,
+        "mem allocated avg": 6778766051.328,
+        "mem reserved avg": 14435452190.72,
+        "elapsed time": 833.2261762300041
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.4,
+        "train loss": 0.676575911641121,
+        "train samples": 19000,
+        "train time": 30.607126664719544,
+        "eval time": 12.086251140979584,
+        "tokens / sec": 6859.154153859013,
+        "mem allocated avg": 6781519785.984,
+        "mem reserved avg": 14521225707.52,
+        "elapsed time": 879.2816601090017
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.42,
+        "train loss": 0.6835739253759384,
+        "train samples": 20000,
+        "train time": 30.988149417680688,
+        "eval time": 12.111999842978548,
+        "tokens / sec": 6721.279066802329,
+        "mem allocated avg": 6777674483.712,
+        "mem reserved avg": 14157940260.864,
+        "elapsed time": 925.7869706979836
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.3866565579984837,
+        "train loss": 0.6835739253759384,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.1559743881225586
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/shira--llama-3.2-3B-lr_0.0003-random_seed_42.json b/method_comparison/MetaMathQA/results/shira--llama-3.2-3B-lr_0.0003-random_seed_42.json
new file mode 100644
index 0000000..7f57aca
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/shira--llama-3.2-3B-lr_0.0003-random_seed_42.json
@@ -0,0 +1,350 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T09:21:42+00:00",
+    "total_time": 1266.219620509015,
+    "experiment_name": "shira/llama-3.2-3B-lr_0.0003-random_seed_42",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0003
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "SHIRA",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 32,
+      "mask_type": "random",
+      "random_seed": 42,
+      "target_modules": [
+        "q_proj",
+        "v_proj"
+      ],
+      "fan_in_fan_out": false,
+      "init_weights": true,
+      "modules_to_save": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 14575737398,
+    "accelerator_memory_max": 21678260224,
+    "accelerator_memory_reserved_99th": 19818086400,
+    "train_time": 1026.581762216112,
+    "file_size": 110115520,
+    "num_trainable_params": 9175040,
+    "num_total_params": 3221924864,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.38,
+        "train loss": 0.9357188229560852,
+        "train samples": 1000,
+        "train time": 31.005053431203123,
+        "eval time": 13.649991136044264,
+        "tokens / sec": 6828.5320155884165,
+        "mem allocated avg": 6998764658.688,
+        "mem reserved avg": 14655091113.984,
+        "elapsed time": 66.7176694990485
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.4,
+        "train loss": 0.7031368371248246,
+        "train samples": 2000,
+        "train time": 31.183240320475306,
+        "eval time": 8.634114325977862,
+        "tokens / sec": 6670.089376934567,
+        "mem allocated avg": 6991483916.288,
+        "mem reserved avg": 14325804695.552,
+        "elapsed time": 109.90105467604008
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.46,
+        "train loss": 0.6644203888177872,
+        "train samples": 3000,
+        "train time": 31.103451813396532,
+        "eval time": 13.64413362799678,
+        "tokens / sec": 6893.157752595665,
+        "mem allocated avg": 7001957066.752,
+        "mem reserved avg": 14535368900.608,
+        "elapsed time": 157.93175754504045
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.4,
+        "train loss": 0.6444325144290924,
+        "train samples": 4000,
+        "train time": 30.684549567697104,
+        "eval time": 13.796387184003834,
+        "tokens / sec": 6789.605939639536,
+        "mem allocated avg": 6993408995.328,
+        "mem reserved avg": 14586304528.384,
+        "elapsed time": 205.7778243360226
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.42,
+        "train loss": 0.6387022986412049,
+        "train samples": 5000,
+        "train time": 30.919842153030913,
+        "eval time": 13.635492319008335,
+        "tokens / sec": 6744.471688047026,
+        "mem allocated avg": 6993185427.456,
+        "mem reserved avg": 14606370078.72,
+        "elapsed time": 253.6162872450077
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.5,
+        "train loss": 0.6296824035644532,
+        "train samples": 6000,
+        "train time": 31.136358544055838,
+        "eval time": 13.624358916946221,
+        "tokens / sec": 6723.040515602067,
+        "mem allocated avg": 6995184592.896,
+        "mem reserved avg": 14538120364.032,
+        "elapsed time": 301.7656091070385
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.5,
+        "train loss": 0.6209747047424317,
+        "train samples": 7000,
+        "train time": 31.68197686993517,
+        "eval time": 13.656035805994179,
+        "tokens / sec": 6608.0156822117015,
+        "mem allocated avg": 6995961063.424,
+        "mem reserved avg": 14895399567.36,
+        "elapsed time": 350.47537555603776
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.46,
+        "train loss": 0.6227067719697952,
+        "train samples": 8000,
+        "train time": 30.87618053384358,
+        "eval time": 13.635997612960637,
+        "tokens / sec": 6726.738748412974,
+        "mem allocated avg": 6992352337.92,
+        "mem reserved avg": 14571960008.704,
+        "elapsed time": 398.4335696240305
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.42,
+        "train loss": 0.6115854290723801,
+        "train samples": 9000,
+        "train time": 31.98190122464439,
+        "eval time": 13.636252279975452,
+        "tokens / sec": 6720.926266708837,
+        "mem allocated avg": 7003833470.976,
+        "mem reserved avg": 14827611226.112,
+        "elapsed time": 447.4371414630441
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.48,
+        "train loss": 0.6084150255918502,
+        "train samples": 10000,
+        "train time": 31.10554581769975,
+        "eval time": 13.639432755007874,
+        "tokens / sec": 6621.552349767809,
+        "mem allocated avg": 6989386164.224,
+        "mem reserved avg": 14371598106.624,
+        "elapsed time": 495.53728479502024
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.48,
+        "train loss": 0.598827944278717,
+        "train samples": 11000,
+        "train time": 31.166906193597242,
+        "eval time": 10.745618918037508,
+        "tokens / sec": 6798.268608500117,
+        "mem allocated avg": 6999211896.832,
+        "mem reserved avg": 14710699196.416,
+        "elapsed time": 540.7916241060011
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.5,
+        "train loss": 0.5887291294336319,
+        "train samples": 12000,
+        "train time": 30.795661959215067,
+        "eval time": 12.80061661900254,
+        "tokens / sec": 6777.9351610118865,
+        "mem allocated avg": 6994559866.88,
+        "mem reserved avg": 14628163682.304,
+        "elapsed time": 587.7743918690248
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.58,
+        "train loss": 0.597461501955986,
+        "train samples": 13000,
+        "train time": 31.37682155967923,
+        "eval time": 9.411147411970887,
+        "tokens / sec": 6721.553985283782,
+        "mem allocated avg": 6997160384.512,
+        "mem reserved avg": 14501202100.224,
+        "elapsed time": 631.8334740100545
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.56,
+        "train loss": 0.5807107644081115,
+        "train samples": 14000,
+        "train time": 31.556804033578373,
+        "eval time": 9.451412087015342,
+        "tokens / sec": 6646.74406751752,
+        "mem allocated avg": 6994673545.216,
+        "mem reserved avg": 14552573935.616,
+        "elapsed time": 676.2394572110497
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.56,
+        "train loss": 0.5781861733198166,
+        "train samples": 15000,
+        "train time": 31.661963078950066,
+        "eval time": 8.377148772997316,
+        "tokens / sec": 6844.269240654614,
+        "mem allocated avg": 7006026270.72,
+        "mem reserved avg": 14834229837.824,
+        "elapsed time": 719.6216589460382
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.52,
+        "train loss": 0.5876536679267883,
+        "train samples": 16000,
+        "train time": 30.703147317806724,
+        "eval time": 13.655890587018803,
+        "tokens / sec": 6656.418571182472,
+        "mem allocated avg": 6986944800.768,
+        "mem reserved avg": 14532718100.48,
+        "elapsed time": 767.4079029310378
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.54,
+        "train loss": 0.5748379683494568,
+        "train samples": 17000,
+        "train time": 31.318038100958802,
+        "eval time": 8.131663441017736,
+        "tokens / sec": 6749.752309469485,
+        "mem allocated avg": 6997509144.576,
+        "mem reserved avg": 14515999604.736,
+        "elapsed time": 810.1378366760327
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.54,
+        "train loss": 0.5816982330083847,
+        "train samples": 18000,
+        "train time": 30.432493349188007,
+        "eval time": 9.551053533970844,
+        "tokens / sec": 6828.819368017539,
+        "mem allocated avg": 6992803389.44,
+        "mem reserved avg": 14505589342.208,
+        "elapsed time": 853.5443232820253
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.6,
+        "train loss": 0.5723524678945542,
+        "train samples": 19000,
+        "train time": 30.418727806943934,
+        "eval time": 8.29991272703046,
+        "tokens / sec": 6901.6364304386025,
+        "mem allocated avg": 6995412983.808,
+        "mem reserved avg": 14580717715.456,
+        "elapsed time": 895.5305709300446
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.56,
+        "train loss": 0.5786988343000412,
+        "train samples": 20000,
+        "train time": 30.267178804264404,
+        "eval time": 8.313903974951245,
+        "tokens / sec": 6881.38135856438,
+        "mem allocated avg": 6992403818.496,
+        "mem reserved avg": 14239225872.384,
+        "elapsed time": 937.4194786970038
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.5276724791508719,
+        "train loss": 0.5786988343000412,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.3599224090576172
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/tinylora--llama-3.2-3B-default.json b/method_comparison/MetaMathQA/results/tinylora--llama-3.2-3B-default.json
new file mode 100644
index 0000000..bd704f3
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/tinylora--llama-3.2-3B-default.json
@@ -0,0 +1,358 @@
+{
+  "run_info": {
+    "created_at": "2026-04-14T19:04:28+00:00",
+    "total_time": 1280.5890959829994,
+    "experiment_name": "tinylora/llama-3.2-3B-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.001
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null,
+      "init_kv_cache_prefix": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "TINYLORA",
+      "auto_mapping": null,
+      "peft_version": "0.19.0",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 2,
+      "u": 64,
+      "weight_tying": 0.0,
+      "projection_seed": 42,
+      "save_projection": true,
+      "init_v_bound": 0.02,
+      "target_modules": [
+        "v_proj",
+        "q_proj"
+      ],
+      "tinylora_dropout": 0.0,
+      "fan_in_fan_out": false,
+      "bias": "none",
+      "modules_to_save": null,
+      "init_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 13315370437,
+    "accelerator_memory_max": 20126367744,
+    "accelerator_memory_reserved_99th": 18343788544,
+    "train_time": 1005.6939271469892,
+    "file_size": 2391912,
+    "num_trainable_params": 3584,
+    "num_total_params": 3212753408,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.0,
+        "train loss": 1.2781277766227723,
+        "train samples": 1000,
+        "train time": 29.62463812986971,
+        "eval time": 12.268791488997522,
+        "tokens / sec": 7146.720208761961,
+        "mem allocated avg": 6782683836.416,
+        "mem reserved avg": 13404014116.864,
+        "elapsed time": 63.092878730007214
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.0,
+        "train loss": 1.2406480107307434,
+        "train samples": 2000,
+        "train time": 29.568441232899204,
+        "eval time": 12.359398319997126,
+        "tokens / sec": 7034.357961642402,
+        "mem allocated avg": 6775698290.688,
+        "mem reserved avg": 13079584702.464,
+        "elapsed time": 107.82620730499912
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.02,
+        "train loss": 1.1951167840957642,
+        "train samples": 3000,
+        "train time": 29.82903349219123,
+        "eval time": 12.353063451009803,
+        "tokens / sec": 7187.661647036831,
+        "mem allocated avg": 6785483120.64,
+        "mem reserved avg": 13268521320.448,
+        "elapsed time": 152.80012364900904
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.02,
+        "train loss": 1.196952908039093,
+        "train samples": 4000,
+        "train time": 29.21191224195354,
+        "eval time": 12.419155650000903,
+        "tokens / sec": 7131.885043143193,
+        "mem allocated avg": 6776640491.52,
+        "mem reserved avg": 13314843213.824,
+        "elapsed time": 197.2873525449977
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.0,
+        "train loss": 1.1898907599449158,
+        "train samples": 5000,
+        "train time": 29.00116592599079,
+        "eval time": 12.263450048994855,
+        "tokens / sec": 7190.676420809297,
+        "mem allocated avg": 6777077430.272,
+        "mem reserved avg": 13365250359.296,
+        "elapsed time": 241.3598588379973
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.0,
+        "train loss": 1.1793672075271606,
+        "train samples": 6000,
+        "train time": 29.21511149003345,
+        "eval time": 12.238495423996937,
+        "tokens / sec": 7165.1617715514085,
+        "mem allocated avg": 6779007174.656,
+        "mem reserved avg": 13277757177.856,
+        "elapsed time": 285.6396420480014
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.02,
+        "train loss": 1.1763010482788085,
+        "train samples": 7000,
+        "train time": 29.251842216108344,
+        "eval time": 12.174482814996736,
+        "tokens / sec": 7156.98513800655,
+        "mem allocated avg": 6780389603.328,
+        "mem reserved avg": 13619811057.664,
+        "elapsed time": 329.89888020399667
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.02,
+        "train loss": 1.1813358347415923,
+        "train samples": 8000,
+        "train time": 29.418175176848308,
+        "eval time": 12.335072386005777,
+        "tokens / sec": 7060.125203260529,
+        "mem allocated avg": 6776134410.24,
+        "mem reserved avg": 13301312389.12,
+        "elapsed time": 374.5338296889968
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.0,
+        "train loss": 1.172850294113159,
+        "train samples": 9000,
+        "train time": 29.904061377135804,
+        "eval time": 12.285082250004052,
+        "tokens / sec": 7187.919971443946,
+        "mem allocated avg": 6786565449.728,
+        "mem reserved avg": 13564848898.048,
+        "elapsed time": 419.51835140399635
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.02,
+        "train loss": 1.1793990023136138,
+        "train samples": 10000,
+        "train time": 29.20591944696207,
+        "eval time": 12.41826296299405,
+        "tokens / sec": 7052.234748987647,
+        "mem allocated avg": 6773510297.6,
+        "mem reserved avg": 13106612797.44,
+        "elapsed time": 463.9779940340086
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.0,
+        "train loss": 1.180105079650879,
+        "train samples": 11000,
+        "train time": 29.320615836040815,
+        "eval time": 12.377129669010174,
+        "tokens / sec": 7226.348900201356,
+        "mem allocated avg": 6782631518.208,
+        "mem reserved avg": 13437618880.512,
+        "elapsed time": 508.437297217999
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.0,
+        "train loss": 1.1744389948844909,
+        "train samples": 12000,
+        "train time": 29.53985286586976,
+        "eval time": 12.229440000999602,
+        "tokens / sec": 7066.081234316744,
+        "mem allocated avg": 6778503475.2,
+        "mem reserved avg": 13380526014.464,
+        "elapsed time": 553.0742953360023
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.02,
+        "train loss": 1.172437875032425,
+        "train samples": 13000,
+        "train time": 29.548683459026506,
+        "eval time": 12.297136758003035,
+        "tokens / sec": 7137.40767139235,
+        "mem allocated avg": 6781349326.848,
+        "mem reserved avg": 13244496347.136,
+        "elapsed time": 597.6882013260038
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.0,
+        "train loss": 1.1740667581558228,
+        "train samples": 14000,
+        "train time": 29.95824750296015,
+        "eval time": 12.355832200992154,
+        "tokens / sec": 7001.410879567464,
+        "mem allocated avg": 6778354403.328,
+        "mem reserved avg": 13265174265.856,
+        "elapsed time": 642.876650516002
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.0,
+        "train loss": 1.1586440045833588,
+        "train samples": 15000,
+        "train time": 30.502618752914714,
+        "eval time": 12.421693063995917,
+        "tokens / sec": 7104.40640377124,
+        "mem allocated avg": 6789483493.376,
+        "mem reserved avg": 13573707268.096,
+        "elapsed time": 688.6765086410014
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.06,
+        "train loss": 1.1851642508506774,
+        "train samples": 16000,
+        "train time": 29.493367298011435,
+        "eval time": 12.399896686998545,
+        "tokens / sec": 6929.456305715885,
+        "mem allocated avg": 6770658635.776,
+        "mem reserved avg": 13280558972.928,
+        "elapsed time": 733.4192178939993
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.0,
+        "train loss": 1.157331362247467,
+        "train samples": 17000,
+        "train time": 29.721664497148595,
+        "eval time": 12.352380377997179,
+        "tokens / sec": 7112.286730114998,
+        "mem allocated avg": 6782410606.592,
+        "mem reserved avg": 13262255030.272,
+        "elapsed time": 778.2037502510066
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.0,
+        "train loss": 1.1738232126235961,
+        "train samples": 18000,
+        "train time": 29.415511626095395,
+        "eval time": 12.387085970010958,
+        "tokens / sec": 7064.911963511059,
+        "mem allocated avg": 6776753987.584,
+        "mem reserved avg": 13233884758.016,
+        "elapsed time": 822.8698514100106
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.0,
+        "train loss": 1.1605148227214814,
+        "train samples": 19000,
+        "train time": 30.141289916908136,
+        "eval time": 12.342347552010324,
+        "tokens / sec": 6965.163089527634,
+        "mem allocated avg": 6779153461.248,
+        "mem reserved avg": 13314037907.456,
+        "elapsed time": 868.1438604020077
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.02,
+        "train loss": 1.1730116956233978,
+        "train samples": 20000,
+        "train time": 29.35209196503274,
+        "eval time": 12.416217063000659,
+        "tokens / sec": 7095.91671517399,
+        "mem allocated avg": 6776144590.848,
+        "mem reserved avg": 13012593278.976,
+        "elapsed time": 912.6687434610067
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.009855951478392721,
+        "train loss": 1.1730116956233978,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": -0.7508955001831055
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "740312add88f781978c0658806c59bc2815b9866",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "5.5.4",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.0",
+      "peft-commit-hash": "6d5a6f4f2f902dbf13d21d2661d57c3c05df1dae",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/tinylora--llama-3.2-3B-weight-tying.json b/method_comparison/MetaMathQA/results/tinylora--llama-3.2-3B-weight-tying.json
new file mode 100644
index 0000000..f1c826a
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/tinylora--llama-3.2-3B-weight-tying.json
@@ -0,0 +1,358 @@
+{
+  "run_info": {
+    "created_at": "2026-04-14T19:25:53+00:00",
+    "total_time": 1291.7770112069993,
+    "experiment_name": "tinylora/llama-3.2-3B-weight-tying",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.001
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null,
+      "init_kv_cache_prefix": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "TINYLORA",
+      "auto_mapping": null,
+      "peft_version": "0.19.0",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 2,
+      "u": 64,
+      "weight_tying": 1.0,
+      "projection_seed": 42,
+      "save_projection": true,
+      "init_v_bound": 0.02,
+      "target_modules": [
+        "q_proj",
+        "v_proj"
+      ],
+      "tinylora_dropout": 0.0,
+      "fan_in_fan_out": false,
+      "bias": "none",
+      "modules_to_save": null,
+      "init_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 13316334288,
+    "accelerator_memory_max": 20126367744,
+    "accelerator_memory_reserved_99th": 18335399936,
+    "train_time": 1014.8198497519916,
+    "file_size": 2372944,
+    "num_trainable_params": 64,
+    "num_total_params": 3212749888,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.0,
+        "train loss": 1.3195916001796721,
+        "train samples": 1000,
+        "train time": 29.320167769066757,
+        "eval time": 12.472152602000278,
+        "tokens / sec": 7220.934125191702,
+        "mem allocated avg": 6782729830.4,
+        "mem reserved avg": 13416806744.064,
+        "elapsed time": 62.99944108699856
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.0,
+        "train loss": 1.3382048671245574,
+        "train samples": 2000,
+        "train time": 29.643070286067086,
+        "eval time": 12.378917232999811,
+        "tokens / sec": 7016.648342859489,
+        "mem allocated avg": 6775546707.968,
+        "mem reserved avg": 13078989111.296,
+        "elapsed time": 107.84316255799786
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.0,
+        "train loss": 1.3136957421302795,
+        "train samples": 3000,
+        "train time": 30.28413043904584,
+        "eval time": 12.397852306006826,
+        "tokens / sec": 7079.648545020437,
+        "mem allocated avg": 6785373798.4,
+        "mem reserved avg": 13267313360.896,
+        "elapsed time": 153.33072755200556
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.0,
+        "train loss": 1.3295996901988982,
+        "train samples": 4000,
+        "train time": 29.893614863831317,
+        "eval time": 12.44242364699312,
+        "tokens / sec": 6969.247478064906,
+        "mem allocated avg": 6776612499.456,
+        "mem reserved avg": 13325463191.552,
+        "elapsed time": 198.5323697959975
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.0,
+        "train loss": 1.329271419763565,
+        "train samples": 5000,
+        "train time": 29.7562353319081,
+        "eval time": 12.420886085994425,
+        "tokens / sec": 7008.211814227093,
+        "mem allocated avg": 6776831610.88,
+        "mem reserved avg": 13364965146.624,
+        "elapsed time": 243.53589431100409
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.0,
+        "train loss": 1.32270361495018,
+        "train samples": 6000,
+        "train time": 29.733648805966368,
+        "eval time": 12.510866166005144,
+        "tokens / sec": 7040.205572011584,
+        "mem allocated avg": 6778860009.472,
+        "mem reserved avg": 13277211918.336,
+        "elapsed time": 288.61189743199793
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.0,
+        "train loss": 1.3246964557170868,
+        "train samples": 7000,
+        "train time": 29.924207624033443,
+        "eval time": 12.557893115998013,
+        "tokens / sec": 6996.175224765445,
+        "mem allocated avg": 6780314126.336,
+        "mem reserved avg": 13617286086.656,
+        "elapsed time": 333.9531167160021
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.0,
+        "train loss": 1.3275963261127472,
+        "train samples": 8000,
+        "train time": 32.08173063819413,
+        "eval time": 12.476057071995456,
+        "tokens / sec": 6473.964959756022,
+        "mem allocated avg": 6776051113.984,
+        "mem reserved avg": 13300733575.168,
+        "elapsed time": 381.4403149379941
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.0,
+        "train loss": 1.3165799739360808,
+        "train samples": 9000,
+        "train time": 30.135037008090876,
+        "eval time": 12.622973126999568,
+        "tokens / sec": 7132.82681359539,
+        "mem allocated avg": 6786442688.512,
+        "mem reserved avg": 13567432589.312,
+        "elapsed time": 427.01142006700684
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.0,
+        "train loss": 1.332935559272766,
+        "train samples": 10000,
+        "train time": 29.332992679148447,
+        "eval time": 12.479970840009628,
+        "tokens / sec": 7021.683817021951,
+        "mem allocated avg": 6773380962.304,
+        "mem reserved avg": 13105488723.968,
+        "elapsed time": 471.6480772560026
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.0,
+        "train loss": 1.3219903807640077,
+        "train samples": 11000,
+        "train time": 30.02839250290708,
+        "eval time": 12.423003805990447,
+        "tokens / sec": 7056.022062435995,
+        "mem allocated avg": 6782555439.104,
+        "mem reserved avg": 13428836007.936,
+        "elapsed time": 516.9036575339996
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.0,
+        "train loss": 1.3261709277629852,
+        "train samples": 12000,
+        "train time": 29.508888696116628,
+        "eval time": 12.425764952000463,
+        "tokens / sec": 7073.495791370449,
+        "mem allocated avg": 6778509414.4,
+        "mem reserved avg": 13381465538.56,
+        "elapsed time": 561.7012977739942
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.0,
+        "train loss": 1.3258510191440582,
+        "train samples": 13000,
+        "train time": 29.32331385197176,
+        "eval time": 12.37602518600761,
+        "tokens / sec": 7192.263502844805,
+        "mem allocated avg": 6781252022.272,
+        "mem reserved avg": 13241946210.304,
+        "elapsed time": 606.1447115960036
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.0,
+        "train loss": 1.3274540011882783,
+        "train samples": 14000,
+        "train time": 29.492625459082774,
+        "eval time": 12.444265147001715,
+        "tokens / sec": 7111.947367690312,
+        "mem allocated avg": 6778363799.552,
+        "mem reserved avg": 13280340869.12,
+        "elapsed time": 650.959727473004
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.0,
+        "train loss": 1.306462818145752,
+        "train samples": 15000,
+        "train time": 30.15356982103549,
+        "eval time": 12.43603616701148,
+        "tokens / sec": 7186.64494075343,
+        "mem allocated avg": 6789369143.296,
+        "mem reserved avg": 13572583194.624,
+        "elapsed time": 696.4128272789967
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.0,
+        "train loss": 1.3445083932876587,
+        "train samples": 16000,
+        "train time": 29.836878458983847,
+        "eval time": 12.350287249006215,
+        "tokens / sec": 6849.677665877395,
+        "mem allocated avg": 6770480697.344,
+        "mem reserved avg": 13279736889.344,
+        "elapsed time": 741.4584507380059
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.0,
+        "train loss": 1.3090761578083039,
+        "train samples": 17000,
+        "train time": 29.33308357889473,
+        "eval time": 12.378393848994165,
+        "tokens / sec": 7206.504540562358,
+        "mem allocated avg": 6782331011.072,
+        "mem reserved avg": 13263328772.096,
+        "elapsed time": 785.8608458889939
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.0,
+        "train loss": 1.3359132213592528,
+        "train samples": 18000,
+        "train time": 29.127323688036995,
+        "eval time": 12.45233793699299,
+        "tokens / sec": 7134.81273548499,
+        "mem allocated avg": 6776620081.152,
+        "mem reserved avg": 13231770828.8,
+        "elapsed time": 830.2824437300005
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.0,
+        "train loss": 1.3187625818252564,
+        "train samples": 19000,
+        "train time": 29.46111865786952,
+        "eval time": 12.408654205006314,
+        "tokens / sec": 7125.968380155927,
+        "mem allocated avg": 6779007021.056,
+        "mem reserved avg": 13310204313.6,
+        "elapsed time": 874.9263411550055
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.0,
+        "train loss": 1.3322124259471892,
+        "train samples": 20000,
+        "train time": 29.690198107098695,
+        "eval time": 12.44290265199379,
+        "tokens / sec": 7015.109809934272,
+        "mem allocated avg": 6776081250.304,
+        "mem reserved avg": 13014782705.664,
+        "elapsed time": 919.8232776560035
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.001516300227445034,
+        "train loss": 1.3322124259471892,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": -0.37198925018310547
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "740312add88f781978c0658806c59bc2815b9866",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "5.5.4",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.0",
+      "peft-commit-hash": "6d5a6f4f2f902dbf13d21d2661d57c3c05df1dae",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/trainable_tokens--llama-3.2-3B-sos+eos.json b/method_comparison/MetaMathQA/results/trainable_tokens--llama-3.2-3B-sos+eos.json
new file mode 100644
index 0000000..6a60214
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/trainable_tokens--llama-3.2-3B-sos+eos.json
@@ -0,0 +1,346 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T09:42:53+00:00",
+    "total_time": 1247.7475435149972,
+    "experiment_name": "trainable_tokens/llama-3.2-3B-sos+eos",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.2
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": "CAUSAL_LM",
+      "peft_type": "TRAINABLE_TOKENS",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "token_indices": [
+        128000,
+        128001
+      ],
+      "target_modules": "model.embed_tokens",
+      "init_weights": true
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 14425538114,
+    "accelerator_memory_max": 20967325696,
+    "accelerator_memory_reserved_99th": 18897436672,
+    "train_time": 997.0611474359757,
+    "file_size": 49424,
+    "num_trainable_params": 6144,
+    "num_total_params": 3212755968,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.1,
+        "train loss": 0.9905012159347534,
+        "train samples": 1000,
+        "train time": 29.634983344411012,
+        "eval time": 12.536395390983671,
+        "tokens / sec": 7144.225375106512,
+        "mem allocated avg": 6778851835.904,
+        "mem reserved avg": 14544495706.112,
+        "elapsed time": 65.80975040997146
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.3,
+        "train loss": 0.9729812822341919,
+        "train samples": 2000,
+        "train time": 29.16309229255421,
+        "eval time": 12.553540614026133,
+        "tokens / sec": 7132.131185316872,
+        "mem allocated avg": 6772151279.616,
+        "mem reserved avg": 14197677096.96,
+        "elapsed time": 110.11175278900191
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.04,
+        "train loss": 1.0480547146797181,
+        "train samples": 3000,
+        "train time": 29.716528838151135,
+        "eval time": 12.526994656014722,
+        "tokens / sec": 7214.873620257571,
+        "mem allocated avg": 6781906634.752,
+        "mem reserved avg": 14420948287.488,
+        "elapsed time": 154.87282191601116
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.22,
+        "train loss": 0.9436001698970795,
+        "train samples": 4000,
+        "train time": 29.420189953991212,
+        "eval time": 12.568019258033019,
+        "tokens / sec": 7081.395474529784,
+        "mem allocated avg": 6773335566.336,
+        "mem reserved avg": 14408482816.0,
+        "elapsed time": 199.46210629702546
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.14,
+        "train loss": 0.9967188131809235,
+        "train samples": 5000,
+        "train time": 29.337331054673996,
+        "eval time": 12.49918926099781,
+        "tokens / sec": 7108.281241104102,
+        "mem allocated avg": 6773163264.0,
+        "mem reserved avg": 14396453552.128,
+        "elapsed time": 243.82226993597578
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.24,
+        "train loss": 0.9018084218502045,
+        "train samples": 6000,
+        "train time": 29.38388642319478,
+        "eval time": 12.539064191980287,
+        "tokens / sec": 7124.006572349131,
+        "mem allocated avg": 6775546910.72,
+        "mem reserved avg": 14435041148.928,
+        "elapsed time": 288.2892293820041
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.08,
+        "train loss": 0.9539130289554596,
+        "train samples": 7000,
+        "train time": 28.713767355075106,
+        "eval time": 12.493294921994675,
+        "tokens / sec": 7291.101770489092,
+        "mem allocated avg": 6776510859.264,
+        "mem reserved avg": 14674661736.448,
+        "elapsed time": 332.0281024390133
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.28,
+        "train loss": 0.8857205002307892,
+        "train samples": 8000,
+        "train time": 28.366790932661388,
+        "eval time": 12.514002014009748,
+        "tokens / sec": 7321.8010628357615,
+        "mem allocated avg": 6772300070.912,
+        "mem reserved avg": 14436005838.848,
+        "elapsed time": 375.5168060029973
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.12,
+        "train loss": 0.8438295316696167,
+        "train samples": 9000,
+        "train time": 29.40557757782517,
+        "eval time": 12.504264893999789,
+        "tokens / sec": 7309.769700360958,
+        "mem allocated avg": 6783270096.896,
+        "mem reserved avg": 14682664468.48,
+        "elapsed time": 419.90326115401695
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.28,
+        "train loss": 0.9853150990009308,
+        "train samples": 10000,
+        "train time": 28.319882539799437,
+        "eval time": 12.528796100988984,
+        "tokens / sec": 7272.876210222398,
+        "mem allocated avg": 6769575254.016,
+        "mem reserved avg": 14188315410.432,
+        "elapsed time": 463.3294100689818
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.38,
+        "train loss": 0.8659319682121277,
+        "train samples": 11000,
+        "train time": 29.408809582469985,
+        "eval time": 12.51743244897807,
+        "tokens / sec": 7204.677884218004,
+        "mem allocated avg": 6779202121.728,
+        "mem reserved avg": 14528272138.24,
+        "elapsed time": 507.77231002697954
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.2,
+        "train loss": 0.8670841429233551,
+        "train samples": 12000,
+        "train time": 29.205915787781123,
+        "eval time": 12.515230823017191,
+        "tokens / sec": 7146.873993498494,
+        "mem allocated avg": 6774948583.424,
+        "mem reserved avg": 14482512281.6,
+        "elapsed time": 552.1565157959703
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.24,
+        "train loss": 0.8831028847694397,
+        "train samples": 13000,
+        "train time": 28.957690052688122,
+        "eval time": 12.505934452987276,
+        "tokens / sec": 7283.074016479509,
+        "mem allocated avg": 6777873250.304,
+        "mem reserved avg": 14402812116.992,
+        "elapsed time": 596.0801243850146
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.24,
+        "train loss": 0.8406728208065033,
+        "train samples": 14000,
+        "train time": 28.88564268813934,
+        "eval time": 12.525049041956663,
+        "tokens / sec": 7261.392874811295,
+        "mem allocated avg": 6774829201.408,
+        "mem reserved avg": 14323296501.76,
+        "elapsed time": 640.1019531330094
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.22,
+        "train loss": 0.8314566104412079,
+        "train samples": 15000,
+        "train time": 29.845886443858035,
+        "eval time": 12.519134696980473,
+        "tokens / sec": 7260.732577255891,
+        "mem allocated avg": 6787227551.744,
+        "mem reserved avg": 14711236067.328,
+        "elapsed time": 685.0585421550204
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.26,
+        "train loss": 0.8273813252449036,
+        "train samples": 16000,
+        "train time": 29.003598894923925,
+        "eval time": 12.54185038903961,
+        "tokens / sec": 7046.470361847695,
+        "mem allocated avg": 6767122819.072,
+        "mem reserved avg": 14423137714.176,
+        "elapsed time": 729.2252393189701
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.34,
+        "train loss": 0.7995920785665512,
+        "train samples": 17000,
+        "train time": 29.465179357444867,
+        "eval time": 9.66559061704902,
+        "tokens / sec": 7174.196954161389,
+        "mem allocated avg": 6778672529.408,
+        "mem reserved avg": 14360768413.696,
+        "elapsed time": 770.7659295659978
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.36,
+        "train loss": 0.7986028344631195,
+        "train samples": 18000,
+        "train time": 28.988296278985217,
+        "eval time": 12.561084756976925,
+        "tokens / sec": 7169.031184169855,
+        "mem allocated avg": 6773402359.808,
+        "mem reserved avg": 14380808798.208,
+        "elapsed time": 814.9140880479827
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.32,
+        "train loss": 0.7896175284385681,
+        "train samples": 19000,
+        "train time": 28.64752666564891,
+        "eval time": 12.497469249996357,
+        "tokens / sec": 7328.34643807965,
+        "mem allocated avg": 6775494619.136,
+        "mem reserved avg": 14341474615.296,
+        "elapsed time": 858.5426965900115
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.3,
+        "train loss": 0.7938800511360169,
+        "train samples": 20000,
+        "train time": 28.41598576674005,
+        "eval time": 12.515183010022156,
+        "tokens / sec": 7329.67709477757,
+        "mem allocated avg": 6772489893.888,
+        "mem reserved avg": 14171697577.984,
+        "elapsed time": 901.9474186989828
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.2721758908263836,
+        "train loss": 0.7938800511360169,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.20132732391357422
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/vblora--llama-3.2-3B-default.json b/method_comparison/MetaMathQA/results/vblora--llama-3.2-3B-default.json
new file mode 100644
index 0000000..fae961d
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/vblora--llama-3.2-3B-default.json
@@ -0,0 +1,359 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T10:03:45+00:00",
+    "total_time": 1442.0607667469885,
+    "experiment_name": "vblora/llama-3.2-3B-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "VBLORA",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 4,
+      "num_vectors": 256,
+      "vector_length": 256,
+      "topk": 2,
+      "target_modules": [
+        "q_proj",
+        "v_proj"
+      ],
+      "exclude_modules": null,
+      "save_only_topk_weights": false,
+      "vblora_dropout": 0.0,
+      "fan_in_fan_out": false,
+      "bias": "none",
+      "modules_to_save": null,
+      "init_vector_bank_bound": 0.02,
+      "init_logits_std": 0.1,
+      "layers_to_transform": null,
+      "layers_pattern": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 14315209883,
+    "accelerator_memory_max": 22168993792,
+    "accelerator_memory_reserved_99th": 20019412992,
+    "train_time": 1188.2950591499684,
+    "file_size": 4864912,
+    "num_trainable_params": 1212416,
+    "num_total_params": 3213962240,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.0,
+        "train loss": 1.3084168200492858,
+        "train samples": 1000,
+        "train time": 38.33692664222326,
+        "eval time": 13.785690262040589,
+        "tokens / sec": 5522.586668875496,
+        "mem allocated avg": 6799863355.392,
+        "mem reserved avg": 14422449848.32,
+        "elapsed time": 74.86309108795831
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.38,
+        "train loss": 1.0353211274147034,
+        "train samples": 2000,
+        "train time": 38.09402504004538,
+        "eval time": 13.701952785020694,
+        "tokens / sec": 5460.042612492392,
+        "mem allocated avg": 6792844609.536,
+        "mem reserved avg": 14055465025.536,
+        "elapsed time": 129.952204842004
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.3,
+        "train loss": 0.8149400570392609,
+        "train samples": 3000,
+        "train time": 38.48971955140587,
+        "eval time": 13.7833748270059,
+        "tokens / sec": 5570.344562101877,
+        "mem allocated avg": 6803264000.0,
+        "mem reserved avg": 14282477535.232,
+        "elapsed time": 185.41029871697538
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.3,
+        "train loss": 0.7666769211292267,
+        "train samples": 4000,
+        "train time": 38.318057818338275,
+        "eval time": 13.802792146976572,
+        "tokens / sec": 5437.018780745575,
+        "mem allocated avg": 6793968019.456,
+        "mem reserved avg": 14342078595.072,
+        "elapsed time": 240.8755328389816
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.34,
+        "train loss": 0.7546750259399414,
+        "train samples": 5000,
+        "train time": 38.47422462084796,
+        "eval time": 10.539507273002528,
+        "tokens / sec": 5420.200200395978,
+        "mem allocated avg": 6794672488.448,
+        "mem reserved avg": 14357513633.792,
+        "elapsed time": 293.10720169899287
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.34,
+        "train loss": 0.7437419641017914,
+        "train samples": 6000,
+        "train time": 38.40448851091787,
+        "eval time": 13.719243174011353,
+        "tokens / sec": 5450.691002966751,
+        "mem allocated avg": 6796510103.552,
+        "mem reserved avg": 14279759626.24,
+        "elapsed time": 348.5309307149728
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.4,
+        "train loss": 0.7351079850196839,
+        "train samples": 7000,
+        "train time": 38.52799471229082,
+        "eval time": 13.719382153009064,
+        "tokens / sec": 5433.8410696784495,
+        "mem allocated avg": 6797950621.696,
+        "mem reserved avg": 14646685728.768,
+        "elapsed time": 404.0734379639616
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.34,
+        "train loss": 0.7361109793186188,
+        "train samples": 8000,
+        "train time": 38.6812528463779,
+        "eval time": 13.746708846010733,
+        "tokens / sec": 5369.422775029082,
+        "mem allocated avg": 6793576230.912,
+        "mem reserved avg": 14290614484.992,
+        "elapsed time": 459.8579424939817
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.42,
+        "train loss": 0.7294788275957107,
+        "train samples": 9000,
+        "train time": 38.70111024065409,
+        "eval time": 9.169133496005088,
+        "tokens / sec": 5554.052549484873,
+        "mem allocated avg": 6804150888.448,
+        "mem reserved avg": 14586505854.976,
+        "elapsed time": 510.9330796489958
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.42,
+        "train loss": 0.7272682936191559,
+        "train samples": 10000,
+        "train time": 38.18993485230021,
+        "eval time": 13.75650224700803,
+        "tokens / sec": 5393.22732014544,
+        "mem allocated avg": 6791362646.016,
+        "mem reserved avg": 14089313058.816,
+        "elapsed time": 566.1566062810016
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.34,
+        "train loss": 0.7220834786891938,
+        "train samples": 11000,
+        "train time": 38.772894190915395,
+        "eval time": 13.813729731016792,
+        "tokens / sec": 5464.668150814606,
+        "mem allocated avg": 6800614600.704,
+        "mem reserved avg": 14463805685.76,
+        "elapsed time": 621.9531869380153
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.32,
+        "train loss": 0.7162344917058945,
+        "train samples": 12000,
+        "train time": 38.64312012627488,
+        "eval time": 13.718790433020331,
+        "tokens / sec": 5401.504829784076,
+        "mem allocated avg": 6796550658.048,
+        "mem reserved avg": 14397560848.384,
+        "elapsed time": 677.6688264649711
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.3,
+        "train loss": 0.7240759524106979,
+        "train samples": 13000,
+        "train time": 38.53601192642236,
+        "eval time": 8.802515299990773,
+        "tokens / sec": 5472.828906184632,
+        "mem allocated avg": 6799288741.888,
+        "mem reserved avg": 14244904960.0,
+        "elapsed time": 728.1590657840134
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.34,
+        "train loss": 0.7126485753059387,
+        "train samples": 14000,
+        "train time": 38.67533435986843,
+        "eval time": 10.104931714013219,
+        "tokens / sec": 5423.353242361304,
+        "mem allocated avg": 6796233105.408,
+        "mem reserved avg": 14249518694.4,
+        "elapsed time": 780.2666325760074
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.34,
+        "train loss": 0.7088012579679489,
+        "train samples": 15000,
+        "train time": 39.28342586872168,
+        "eval time": 13.906550085986964,
+        "tokens / sec": 5516.397697191264,
+        "mem allocated avg": 6807167205.376,
+        "mem reserved avg": 14590800822.272,
+        "elapsed time": 836.7359555650037
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.38,
+        "train loss": 0.7263217406272888,
+        "train samples": 16000,
+        "train time": 38.43631436518626,
+        "eval time": 13.765814298996702,
+        "tokens / sec": 5317.185150954824,
+        "mem allocated avg": 6788341315.584,
+        "mem reserved avg": 14278853656.576,
+        "elapsed time": 892.29195685999
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.34,
+        "train loss": 0.7048129771947861,
+        "train samples": 17000,
+        "train time": 38.582715313415974,
+        "eval time": 10.130817791970912,
+        "tokens / sec": 5478.85233796637,
+        "mem allocated avg": 6800143554.56,
+        "mem reserved avg": 14243218849.792,
+        "elapsed time": 944.1107314319815
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.28,
+        "train loss": 0.7155517739057541,
+        "train samples": 18000,
+        "train time": 38.19235976098571,
+        "eval time": 9.205565118987579,
+        "tokens / sec": 5441.3500841676305,
+        "mem allocated avg": 6793989150.72,
+        "mem reserved avg": 14201930121.216,
+        "elapsed time": 994.8280632529641
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.4,
+        "train loss": 0.7085129739046097,
+        "train samples": 19000,
+        "train time": 38.29387024784228,
+        "eval time": 13.80606703099329,
+        "tokens / sec": 5482.313452290169,
+        "mem allocated avg": 6796964847.616,
+        "mem reserved avg": 14314161307.648,
+        "elapsed time": 1050.1360529760132
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.38,
+        "train loss": 0.714538745880127,
+        "train samples": 20000,
+        "train time": 38.23504033399513,
+        "eval time": 13.824080880964175,
+        "tokens / sec": 5447.359233326512,
+        "mem allocated avg": 6793035892.736,
+        "mem reserved avg": 13966579335.168,
+        "elapsed time": 1105.3972024219693
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.354814253222138,
+        "train loss": 0.714538745880127,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": -0.010824203491210938
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/vera--llama-3.2-3B-default.json b/method_comparison/MetaMathQA/results/vera--llama-3.2-3B-default.json
new file mode 100644
index 0000000..8af5ac5
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/vera--llama-3.2-3B-default.json
@@ -0,0 +1,355 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T10:27:51+00:00",
+    "total_time": 1263.101585368975,
+    "experiment_name": "vera/llama-3.2-3B-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.001
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "VERA",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "r": 256,
+      "target_modules": [
+        "q_proj",
+        "v_proj"
+      ],
+      "projection_prng_key": 0,
+      "save_projection": true,
+      "vera_dropout": 0.0,
+      "d_initial": 0.1,
+      "fan_in_fan_out": false,
+      "bias": "none",
+      "modules_to_save": null,
+      "init_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 13999608640,
+    "accelerator_memory_max": 21617442816,
+    "accelerator_memory_reserved_99th": 19627245568,
+    "train_time": 1015.8542694449425,
+    "file_size": 6821968,
+    "num_trainable_params": 129024,
+    "num_total_params": 3212878848,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.0,
+        "train loss": 1.301754014492035,
+        "train samples": 1000,
+        "train time": 31.943585795292165,
+        "eval time": 12.187114808009937,
+        "tokens / sec": 6627.903371800015,
+        "mem allocated avg": 6789185892.352,
+        "mem reserved avg": 14110276190.208,
+        "elapsed time": 66.61339723097626
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.28,
+        "train loss": 1.0202444262504577,
+        "train samples": 2000,
+        "train time": 31.78171904978808,
+        "eval time": 12.214804693008773,
+        "tokens / sec": 6544.48551615986,
+        "mem allocated avg": 6782031269.888,
+        "mem reserved avg": 13716204552.192,
+        "elapsed time": 113.8828261839808
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.32,
+        "train loss": 0.8039965138435364,
+        "train samples": 3000,
+        "train time": 31.674388502840884,
+        "eval time": 12.142891115974635,
+        "tokens / sec": 6768.90731389401,
+        "mem allocated avg": 6791776645.12,
+        "mem reserved avg": 13949500129.28,
+        "elapsed time": 160.88182786101243
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.32,
+        "train loss": 0.7543835270404816,
+        "train samples": 4000,
+        "train time": 31.252004174282774,
+        "eval time": 12.184918653976638,
+        "tokens / sec": 6666.324464766307,
+        "mem allocated avg": 6783568500.736,
+        "mem reserved avg": 14006072901.632,
+        "elapsed time": 207.57197764096782
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.42,
+        "train loss": 0.7379774446487427,
+        "train samples": 5000,
+        "train time": 31.04683574225055,
+        "eval time": 12.13903358601965,
+        "tokens / sec": 6716.884185276503,
+        "mem allocated avg": 6783591102.464,
+        "mem reserved avg": 14041858703.36,
+        "elapsed time": 253.9649221689906
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.42,
+        "train loss": 0.725366308093071,
+        "train samples": 6000,
+        "train time": 31.466947606997564,
+        "eval time": 12.193409828003496,
+        "tokens / sec": 6652.408826379123,
+        "mem allocated avg": 6785737506.816,
+        "mem reserved avg": 13954449408.0,
+        "elapsed time": 300.88531206996413
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.38,
+        "train loss": 0.7149190576076507,
+        "train samples": 7000,
+        "train time": 32.161987620871514,
+        "eval time": 12.206813755037729,
+        "tokens / sec": 6509.392468770777,
+        "mem allocated avg": 6786781550.592,
+        "mem reserved avg": 14342623854.592,
+        "elapsed time": 348.52885854797205
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.42,
+        "train loss": 0.7139762370586396,
+        "train samples": 8000,
+        "train time": 31.66324118396733,
+        "eval time": 12.41653193399543,
+        "tokens / sec": 6559.530617641469,
+        "mem allocated avg": 6782663055.36,
+        "mem reserved avg": 13990637862.912,
+        "elapsed time": 395.93328011297854
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.38,
+        "train loss": 0.7068367917537689,
+        "train samples": 9000,
+        "train time": 32.87184925627662,
+        "eval time": 12.149466416973155,
+        "tokens / sec": 6538.968900843246,
+        "mem allocated avg": 6793174691.84,
+        "mem reserved avg": 14273040351.232,
+        "elapsed time": 444.18720530200517
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.4,
+        "train loss": 0.7048668594360351,
+        "train samples": 10000,
+        "train time": 31.740153488412034,
+        "eval time": 12.253064631018788,
+        "tokens / sec": 6489.162066440422,
+        "mem allocated avg": 6780151590.912,
+        "mem reserved avg": 13770160078.848,
+        "elapsed time": 491.48139633599203
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.36,
+        "train loss": 0.6994699697494506,
+        "train samples": 11000,
+        "train time": 31.831262842926662,
+        "eval time": 12.147469694027677,
+        "tokens / sec": 6656.380585512423,
+        "mem allocated avg": 6789358209.024,
+        "mem reserved avg": 14143369248.768,
+        "elapsed time": 538.6766653700033
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.38,
+        "train loss": 0.6912990446090699,
+        "train samples": 12000,
+        "train time": 31.59112943575019,
+        "eval time": 12.194770312984474,
+        "tokens / sec": 6607.266144900441,
+        "mem allocated avg": 6785734909.952,
+        "mem reserved avg": 14090034479.104,
+        "elapsed time": 585.7846582700149
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.42,
+        "train loss": 0.7005903688669205,
+        "train samples": 13000,
+        "train time": 32.01279983797576,
+        "eval time": 12.153572589973919,
+        "tokens / sec": 6588.021074926875,
+        "mem allocated avg": 6787881736.192,
+        "mem reserved avg": 13914804846.592,
+        "elapsed time": 633.0662019159645
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.4,
+        "train loss": 0.6888112008571625,
+        "train samples": 14000,
+        "train time": 31.394535964296665,
+        "eval time": 12.198143090994563,
+        "tokens / sec": 6681.098909649039,
+        "mem allocated avg": 6784882763.776,
+        "mem reserved avg": 13954659123.2,
+        "elapsed time": 680.0055505509954
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.36,
+        "train loss": 0.6853219895362854,
+        "train samples": 15000,
+        "train time": 32.20891197276069,
+        "eval time": 12.149777695012745,
+        "tokens / sec": 6728.044715800003,
+        "mem allocated avg": 6795943520.256,
+        "mem reserved avg": 14263871602.688,
+        "elapsed time": 727.6112716209609
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.38,
+        "train loss": 0.7033915517330169,
+        "train samples": 16000,
+        "train time": 31.605115150858182,
+        "eval time": 12.220193530025426,
+        "tokens / sec": 6466.453263165871,
+        "mem allocated avg": 6777292670.976,
+        "mem reserved avg": 13970463260.672,
+        "elapsed time": 774.7509838030091
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.34,
+        "train loss": 0.6845373644828796,
+        "train samples": 17000,
+        "train time": 31.9817577842623,
+        "eval time": 12.144686578016263,
+        "tokens / sec": 6609.6742219722855,
+        "mem allocated avg": 6788761931.776,
+        "mem reserved avg": 13960019443.712,
+        "elapsed time": 821.9710977289942
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.4,
+        "train loss": 0.6940178046226502,
+        "train samples": 18000,
+        "train time": 31.950214379117824,
+        "eval time": 12.20877941895742,
+        "tokens / sec": 6504.4320997053055,
+        "mem allocated avg": 6783152502.784,
+        "mem reserved avg": 13920844644.352,
+        "elapsed time": 869.4368790709996
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.36,
+        "train loss": 0.6864041843414307,
+        "train samples": 19000,
+        "train time": 31.99477967567509,
+        "eval time": 12.149096956010908,
+        "tokens / sec": 6561.664187974136,
+        "mem allocated avg": 6785828032.512,
+        "mem reserved avg": 13979548123.136,
+        "elapsed time": 916.7890869269613
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.38,
+        "train loss": 0.6927255519628525,
+        "train samples": 20000,
+        "train time": 30.892451956111472,
+        "eval time": 12.215222013997845,
+        "tokens / sec": 6742.099989210984,
+        "mem allocated avg": 6782438621.184,
+        "mem reserved avg": 13639734001.664,
+        "elapsed time": 963.0640164369834
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.37604245640636846,
+        "train loss": 0.6927255519628525,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": 0.1016998291015625
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/results/waveft--llama-3.2-3B-n_frequency-5000.json b/method_comparison/MetaMathQA/results/waveft--llama-3.2-3B-n_frequency-5000.json
new file mode 100644
index 0000000..28066dd
--- /dev/null
+++ b/method_comparison/MetaMathQA/results/waveft--llama-3.2-3B-n_frequency-5000.json
@@ -0,0 +1,359 @@
+{
+  "run_info": {
+    "created_at": "2026-01-10T10:48:59+00:00",
+    "total_time": 2531.969072496984,
+    "experiment_name": "waveft/llama-3.2-3B-n_frequency-5000",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "meta-llama/Llama-3.2-3B",
+      "dtype": "bfloat16",
+      "max_seq_length": 768,
+      "batch_size": 4,
+      "batch_size_eval": 50,
+      "max_steps": 5000,
+      "eval_steps": 250,
+      "compile": false,
+      "query_template": "Question: {query} Think step by step.\nAnswer:",
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.1
+      },
+      "lr_scheduler": "cosine",
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "generation_kwargs": {
+        "max_length": 800,
+        "max_new_tokens": 300
+      },
+      "attn_implementation": null
+    },
+    "peft_config": {
+      "task_type": "CAUSAL_LM",
+      "peft_type": "WAVEFT",
+      "auto_mapping": null,
+      "peft_version": "0.18.1.dev0@UNKNOWN",
+      "base_model_name_or_path": "meta-llama/Llama-3.2-3B",
+      "revision": null,
+      "inference_mode": false,
+      "n_frequency": 5000,
+      "scaling": 25.0,
+      "wavelet_family": "db1",
+      "use_idwt": true,
+      "random_loc_seed": 777,
+      "fan_in_fan_out": false,
+      "target_modules": [
+        "q_proj",
+        "v_proj"
+      ],
+      "exclude_modules": null,
+      "bias": "none",
+      "modules_to_save": null,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "n_frequency_pattern": {},
+      "proportional_parameters": false,
+      "init_weights": true
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 17216480005,
+    "accelerator_memory_max": 24895291392,
+    "accelerator_memory_reserved_99th": 23207084032,
+    "train_time": 2067.484345029923,
+    "file_size": 1127304,
+    "num_trainable_params": 280000,
+    "num_total_params": 3213029824,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 250,
+        "valid accuracy": 0.34,
+        "train loss": 1.0574276540279388,
+        "train samples": 1000,
+        "train time": 64.88644388166722,
+        "eval time": 29.24885773198912,
+        "tokens / sec": 3262.915754577488,
+        "mem allocated avg": 6785503729.664,
+        "mem reserved avg": 17346156560.384,
+        "elapsed time": 119.97641712299082
+      },
+      {
+        "step": 500,
+        "valid accuracy": 0.36,
+        "train loss": 0.7510680348873139,
+        "train samples": 2000,
+        "train time": 64.65898592909798,
+        "eval time": 29.2429800920072,
+        "tokens / sec": 3216.79959886902,
+        "mem allocated avg": 6777740601.344,
+        "mem reserved avg": 16956279226.368,
+        "elapsed time": 217.2935731979669
+      },
+      {
+        "step": 750,
+        "valid accuracy": 0.36,
+        "train loss": 0.696870755314827,
+        "train samples": 3000,
+        "train time": 65.85057329281699,
+        "eval time": 22.638891860027798,
+        "tokens / sec": 3255.87142645859,
+        "mem allocated avg": 6787450871.808,
+        "mem reserved avg": 17161649127.424,
+        "elapsed time": 309.1054733619676
+      },
+      {
+        "step": 1000,
+        "valid accuracy": 0.38,
+        "train loss": 0.6762536237239838,
+        "train samples": 4000,
+        "train time": 64.82745491992682,
+        "eval time": 26.79089952702634,
+        "tokens / sec": 3213.700125314671,
+        "mem allocated avg": 6780707246.08,
+        "mem reserved avg": 17234697125.888,
+        "elapsed time": 404.1986583190155
+      },
+      {
+        "step": 1250,
+        "valid accuracy": 0.42,
+        "train loss": 0.6723555997610092,
+        "train samples": 5000,
+        "train time": 64.86200350278523,
+        "eval time": 29.28087447199505,
+        "tokens / sec": 3215.102660081186,
+        "mem allocated avg": 6779905163.264,
+        "mem reserved avg": 17208071684.096,
+        "elapsed time": 501.6932976419921
+      },
+      {
+        "step": 1500,
+        "valid accuracy": 0.44,
+        "train loss": 0.668335919380188,
+        "train samples": 6000,
+        "train time": 65.25852178613422,
+        "eval time": 29.221144348965026,
+        "tokens / sec": 3207.718996241155,
+        "mem allocated avg": 6780988528.64,
+        "mem reserved avg": 17179751743.488,
+        "elapsed time": 599.6254665869637
+      },
+      {
+        "step": 1750,
+        "valid accuracy": 0.52,
+        "train loss": 0.6587805707454681,
+        "train samples": 7000,
+        "train time": 65.32939753873507,
+        "eval time": 20.71052837802563,
+        "tokens / sec": 3204.606316411679,
+        "mem allocated avg": 6782190442.496,
+        "mem reserved avg": 17551023144.96,
+        "elapsed time": 689.0983284820104
+      },
+      {
+        "step": 2000,
+        "valid accuracy": 0.34,
+        "train loss": 0.6639124175310135,
+        "train samples": 8000,
+        "train time": 64.99063060310436,
+        "eval time": 19.205011637997814,
+        "tokens / sec": 3195.783731787319,
+        "mem allocated avg": 6778450325.504,
+        "mem reserved avg": 17222315540.48,
+        "elapsed time": 776.8548289329628
+      },
+      {
+        "step": 2250,
+        "valid accuracy": 0.42,
+        "train loss": 0.6567040872573853,
+        "train samples": 9000,
+        "train time": 65.94732432649471,
+        "eval time": 18.143796648015268,
+        "tokens / sec": 3259.389250363315,
+        "mem allocated avg": 6790019246.08,
+        "mem reserved avg": 17537441988.608,
+        "elapsed time": 864.3628261939739
+      },
+      {
+        "step": 2500,
+        "valid accuracy": 0.5,
+        "train loss": 0.6553765784502029,
+        "train samples": 10000,
+        "train time": 64.10474358743522,
+        "eval time": 26.53317212499678,
+        "tokens / sec": 3212.975958933097,
+        "mem allocated avg": 6775553220.608,
+        "mem reserved avg": 16962285469.696,
+        "elapsed time": 958.4253370200167
+      },
+      {
+        "step": 2750,
+        "valid accuracy": 0.4,
+        "train loss": 0.6487860177755356,
+        "train samples": 11000,
+        "train time": 65.63589023012901,
+        "eval time": 21.08229285199195,
+        "tokens / sec": 3228.1271611783477,
+        "mem allocated avg": 6786175535.104,
+        "mem reserved avg": 17393409589.248,
+        "elapsed time": 1048.5621143350145
+      },
+      {
+        "step": 3000,
+        "valid accuracy": 0.42,
+        "train loss": 0.6410797102451324,
+        "train samples": 12000,
+        "train time": 64.99408569413936,
+        "eval time": 29.25125474098604,
+        "tokens / sec": 3211.5383695415485,
+        "mem allocated avg": 6781518624.768,
+        "mem reserved avg": 17271095296.0,
+        "elapsed time": 1146.3423907670076
+      },
+      {
+        "step": 3250,
+        "valid accuracy": 0.4,
+        "train loss": 0.6509387036561965,
+        "train samples": 13000,
+        "train time": 65.00038516824134,
+        "eval time": 18.81445889500901,
+        "tokens / sec": 3244.611542748896,
+        "mem allocated avg": 6782426165.248,
+        "mem reserved avg": 17123514515.456,
+        "elapsed time": 1233.4203302449896
+      },
+      {
+        "step": 3500,
+        "valid accuracy": 0.44,
+        "train loss": 0.6376135617494583,
+        "train samples": 14000,
+        "train time": 64.8011383570265,
+        "eval time": 18.342268240987323,
+        "tokens / sec": 3236.8258539590365,
+        "mem allocated avg": 6781259872.256,
+        "mem reserved avg": 17207123771.392,
+        "elapsed time": 1320.0369267839706
+      },
+      {
+        "step": 3750,
+        "valid accuracy": 0.4,
+        "train loss": 0.635018677353859,
+        "train samples": 15000,
+        "train time": 66.17575967306038,
+        "eval time": 19.382110312988516,
+        "tokens / sec": 3274.6582898423158,
+        "mem allocated avg": 6792251662.336,
+        "mem reserved avg": 17455057469.44,
+        "elapsed time": 1409.0309616610175
+      },
+      {
+        "step": 4000,
+        "valid accuracy": 0.42,
+        "train loss": 0.6503389171361923,
+        "train samples": 16000,
+        "train time": 64.66550021909643,
+        "eval time": 17.806172358978074,
+        "tokens / sec": 3160.464224471373,
+        "mem allocated avg": 6773483292.672,
+        "mem reserved avg": 17174861185.024,
+        "elapsed time": 1494.9754901370034
+      },
+      {
+        "step": 4250,
+        "valid accuracy": 0.4,
+        "train loss": 0.6333471950292587,
+        "train samples": 17000,
+        "train time": 64.98916661646217,
+        "eval time": 20.801376049988903,
+        "tokens / sec": 3252.680577480337,
+        "mem allocated avg": 6783976222.72,
+        "mem reserved avg": 17191504183.296,
+        "elapsed time": 1583.9985767480102
+      },
+      {
+        "step": 4500,
+        "valid accuracy": 0.46,
+        "train loss": 0.6411651639938355,
+        "train samples": 18000,
+        "train time": 64.85606565064518,
+        "eval time": 20.16082675504731,
+        "tokens / sec": 3204.295510607074,
+        "mem allocated avg": 6779666743.296,
+        "mem reserved avg": 17107123175.424,
+        "elapsed time": 1672.4678985319915
+      },
+      {
+        "step": 4750,
+        "valid accuracy": 0.42,
+        "train loss": 0.6345895240306855,
+        "train samples": 19000,
+        "train time": 65.05685202759923,
+        "eval time": 18.8133876810316,
+        "tokens / sec": 3227.0082774822404,
+        "mem allocated avg": 6781692170.24,
+        "mem reserved avg": 17216258965.504,
+        "elapsed time": 1759.7040043339948
+      },
+      {
+        "step": 5000,
+        "valid accuracy": 0.44,
+        "train loss": 0.63977869784832,
+        "train samples": 20000,
+        "train time": 64.65817459212849,
+        "eval time": 19.78138606599532,
+        "tokens / sec": 3221.24775890837,
+        "mem allocated avg": 6778381412.352,
+        "mem reserved avg": 16829980344.32,
+        "elapsed time": 1847.474526909995
+      },
+      {
+        "step": 5000,
+        "test accuracy": 0.4200151630022744,
+        "train loss": 0.63977869784832,
+        "train samples": 20000,
+        "train total tokens": 4198051,
+        "forgetting": -0.13996505737304688
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "13afe5124825b4f3751f836b40dafda64c1ed062",
+      "created_at": "2024-09-18T15:23:48+00:00"
+    },
+    "dataset_info": {
+      "metamath": {
+        "sha": "aa4f34d3d2d3231299b5b03d9b3e5a20da45aa18",
+        "created_at": "2023-09-21T17:22:46+00:00"
+      },
+      "gsm8k": {
+        "sha": "cc7b047b6e5bb11b4f1af84efc572db110a51b3c",
+        "created_at": "2022-04-12T10:22:10+00:00"
+      }
+    },
+    "package_info": {
+      "transformers-version": "4.57.1",
+      "transformers-commit-hash": null,
+      "peft-version": "0.18.1.dev0",
+      "peft-commit-hash": "8be1a16f5e06ca5e197d2af74bdfc5b3c8072d26",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "bitsandbytes-version": "0.46.0",
+      "bitsandbytes-commit-hash": null,
+      "torch-version": "2.9.0+cu128",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.14.0-1016-aws",
+      "version": "#16~24.04.1-Ubuntu SMP Tue Oct 14 02:15:09 UTC 2025",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 201703\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.7.1 (Git Hash 8d263e693366ef8db40acc569cc7d8edf644556d)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 12.8\n  - NVCC architecture flags: -gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1\n    - Built with CuDNN 90.8\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=0fabc3ba44823f257e70ce397d989c8de5e362c1, CUDA_VERSION=12.8, CUDNN_VERSION=9.8.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.9.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/MetaMathQA/run.py b/method_comparison/MetaMathQA/run.py
new file mode 100644
index 0000000..42e019f
--- /dev/null
+++ b/method_comparison/MetaMathQA/run.py
@@ -0,0 +1,530 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+"""
+Main entry point to run the experiments. Contains general setup and the proper training code.
+"""
+
+import argparse
+import datetime as dt
+import json
+import os
+import random
+import sys
+import textwrap
+import time
+from collections.abc import Callable
+from contextlib import AbstractContextManager, nullcontext
+from functools import partial
+from typing import Any, Literal, Optional
+
+import torch
+from torch import nn
+from torch.amp import GradScaler, autocast
+from tqdm import tqdm
+from transformers import GenerationConfig, set_seed
+from utils import (
+    FILE_NAME_TRAIN_PARAMS,
+    BucketIterator,
+    TrainResult,
+    TrainStatus,
+    get_accuracy,
+    get_base_model_info,
+    get_dataset_info,
+    get_file_size,
+    get_model,
+    get_optimizer_and_scheduler,
+    get_peft_branch,
+    get_tokenizer,
+    get_train_config,
+    init_accelerator,
+    log_results,
+    upload_checkpoint_to_bucket,
+    validate_experiment_path,
+)
+
+from data import get_train_valid_test_datasets, get_wiki_small
+from peft import AdaLoraConfig, AdamssConfig, PeftConfig, initialize_kv_prefix_from_text
+from peft.utils import CONFIG_NAME, infer_device
+
+
+# number of batches per bucket, increasing this further has diminishing returns
+BUCKET_FACTOR = 20
+# empty device cache every N steps; 10 is a good compromise between keeping memory down while lowering runtime overhead
+ACCELERATOR_EMPTY_CACHE_SCHEDULE = 10
+
+# disable torch inductor caching to keep total runtime numbers comparable when torch.compile is used
+os.environ["TORCHINDUCTOR_FORCE_DISABLE_CACHES"] = "1"
+
+
+def get_generation_config(*, seq_len, generate_kwargs) -> GenerationConfig:
+    # filter out None values so that we don't depend on setting correct defaults in the config
+    generate_kwargs = {k: v for k, v in generate_kwargs.items() if v is not None}
+    if ("max_length" in generate_kwargs) and ("max_new_tokens" in generate_kwargs):
+        # transformers does not support setting both max_length and max_new_tokens, but what we want in this case is to
+        # take the smaller of the two values
+        new_max_length = min(generate_kwargs["max_new_tokens"] + seq_len, generate_kwargs["max_length"])
+        del generate_kwargs["max_new_tokens"]
+        generate_kwargs["max_length"] = new_max_length
+    generation_config = GenerationConfig(**generate_kwargs)
+    return generation_config
+
+
+def evaluate(model, tokenizer, ds, batch_size, generate_kwargs, use_tqdm: bool = False) -> tuple[list[str], list[str]]:
+    generate_kwargs = generate_kwargs.copy()
+    generate_kwargs["pad_token_id"] = tokenizer.eos_token_id
+    with torch.inference_mode():
+        predictions = []
+        responses = []
+        pbar = range(0, len(ds), batch_size)
+        if use_tqdm:
+            pbar = tqdm(pbar)
+        for j in pbar:
+            sliced = ds[j : j + batch_size]
+            responses += sliced.pop("response")
+            batch = tokenizer.pad(sliced, return_tensors="pt", padding_side="left").to(model.device)
+            seq_len = batch["input_ids"].shape[1]
+            generation_config = get_generation_config(seq_len=seq_len, generate_kwargs=generate_kwargs)
+            outputs = model.generate(**batch, generation_config=generation_config)
+            predictions += tokenizer.batch_decode(outputs, skip_special_tokens=True)
+    return predictions, responses
+
+
+@torch.inference_mode()
+def calculate_mean_per_token_loss(model, tokenizer, rows: list[str], batch_size: int, max_length: int) -> float:
+    """Calculate the mean loss per token on the given dataset.
+
+    Useful to determine general model performance before and after training to get an estimate of the magnitude of
+    'forgetting'. Note that for Wikipedia data, since the information density is quite high, the loss can be
+    surprisingly large.
+
+    """
+    losses: list[float] = []
+    for j in range(0, len(rows), batch_size):
+        sliced = rows[j : j + batch_size]
+        batch = tokenizer(sliced, truncation=True, max_length=max_length)
+        batch = tokenizer.pad(batch, return_tensors="pt", padding_side="left").to(model.device)
+        outputs = model(**batch, pad_token_id=tokenizer.eos_token_id)
+        logits = outputs.logits
+        for logit, target, mask in zip(logits, batch["input_ids"], batch["attention_mask"]):
+            # calculate loss per token so that the mean is not skewed by sequence length of sample, padding from left
+            num_tokens = mask.sum()
+            token_losses = torch.nn.functional.cross_entropy(
+                logit[-num_tokens:], target[-num_tokens:], reduction="none"
+            )
+            losses.extend(loss.item() for loss in token_losses)
+    return torch.tensor(losses).mean().item()
+
+
+class DummyGradScaler:
+    # if no mixed precision is being used
+    def scale(self, loss):
+        return loss
+
+    def unscale_(self, optimizer):
+        pass
+
+    def step(self, optimizer):
+        optimizer.step()
+
+    def update(self):
+        pass
+
+
+def train(
+    *,
+    model: nn.Module,
+    max_steps: int,
+    batch_size: int,
+    batch_size_eval: int,
+    tokenizer: Any,
+    accelerator_memory_init: int,
+    eval_steps: int,
+    generation_kwargs: dict[str, Any],
+    grad_norm_clip: float,
+    optimizer_type: str,
+    optimizer_kwargs: dict[str, Any],
+    query_template: str,
+    lr_scheduler_arg: Optional[Literal["cosine"]],
+    use_amp: bool,
+    is_adalora: bool,
+    init_kv_cache_prefix: Optional[str],
+    is_adamss: bool,
+) -> TrainResult:
+    accelerator_memory_allocated_log = []
+    accelerator_memory_reserved_log = []
+    losses = []
+    durations = []
+    metrics = []
+    sample = 0  # keep count of the current sample
+    total_samples = 0  # total number of samples over all epochs
+    total_tokens = []  # total number of tokens over all epochs
+
+    device_type = infer_device()
+    torch_accelerator_module = getattr(torch, device_type, torch.cuda)
+    if use_amp:
+        grad_scaler: GradScaler | DummyGradScaler = GradScaler(device=device_type)
+        autocast_ctx: Callable[[], AbstractContextManager[Any]] = partial(autocast, device_type=device_type)
+    else:
+        grad_scaler = DummyGradScaler()
+        autocast_ctx = nullcontext
+
+    optimizer, lr_scheduler = get_optimizer_and_scheduler(
+        model,
+        optimizer_type=optimizer_type,
+        max_steps=max_steps,
+        lr_scheduler_arg=lr_scheduler_arg,
+        **optimizer_kwargs,
+    )
+
+    if init_kv_cache_prefix is not None:
+        initialize_kv_prefix_from_text(model, tokenizer, text=init_kv_cache_prefix)
+
+    # print this after getting the optimizer, in case it modifies requires_gard
+    if hasattr(model, "get_nb_trainable_parameters"):
+        num_trainable_params, num_params = model.get_nb_trainable_parameters()
+    else:
+        num_params = model.num_parameters()
+        num_trainable_params = num_params
+    print_verbose(
+        f"trainable params: {num_trainable_params:,d} || all params: {num_params:,d} || "
+        f"trainable: {100 * num_trainable_params / num_params:.4f}%"
+    )
+
+    status = TrainStatus.FAILED
+    tic_train = time.perf_counter()
+    eval_time = 0.0
+    error_msg = ""
+
+    rows_wiki = get_wiki_small()
+    model.eval()
+    # use small batch_size, not batch_size_eval, to prevent this from taking too much memory and affecting the max memory metric
+    wiki_loss_before = calculate_mean_per_token_loss(
+        model=model, tokenizer=tokenizer, rows=rows_wiki, batch_size=batch_size, max_length=768
+    )
+    model.train()
+
+    ds_train, ds_valid, ds_test = get_train_valid_test_datasets(
+        tokenizer=tokenizer, query_template=query_template, print_fn=print_verbose
+    )
+    # note: bucketing by length is only really worth it for the train dataset, since it's length is big compared to the
+    # batch size
+    iterator_train = BucketIterator(
+        ds_train,
+        batch_size=batch_size,
+        bucket_factor=BUCKET_FACTOR,
+        delete_cols=["response"],
+    )
+    try:
+        pbar = tqdm(range(1, max_steps + 1))
+        for step, batch in zip(pbar, iterator_train):
+            tic = time.perf_counter()
+
+            # create the batch
+            tokens_per_sample = [len(i) for i in batch["input_ids"]]
+            total_tokens.append(sum(tokens_per_sample) + len(tokens_per_sample))  # add EOS token
+            batch = tokenizer.pad(batch, return_tensors="pt").to(model.device)
+            actual_batch_size = len(batch["input_ids"])
+            total_samples += actual_batch_size
+            sample += batch_size
+            if sample >= len(ds_train):  # new epoch
+                sample = 0
+
+            # add labels, they are automatically shifted by transformers
+            labels = batch["input_ids"].clone()
+            # We want to ignore the padding tokens except for the first EOS token; if we don't ignore them, the loss
+            # will be dominated by padding tokens; if we ignore all, the model will not learn to predict the EOS token.
+            # TODO: Note that the longest sequence in the batch won't have any PAD/EOS token at the end, this is fine if
+            # the batch size is > 1 but should still be fixed eventually.
+            for i, num_tokens in enumerate(tokens_per_sample):
+                labels[i, num_tokens + 1 :] = -100
+            batch["labels"] = labels
+            num_items_in_batch = batch["attention_mask"].sum().item()
+
+            # train step
+            optimizer.zero_grad()
+            with autocast_ctx():
+                outputs = model(**batch, num_items_in_batch=num_items_in_batch)
+                loss = outputs.loss
+            grad_scaler.scale(loss).backward()
+            if grad_norm_clip:
+                grad_scaler.unscale_(optimizer)
+                torch.nn.utils.clip_grad_norm_(model.parameters(), grad_norm_clip)
+            grad_scaler.step(optimizer)
+            grad_scaler.update()
+            lr_scheduler.step()
+
+            if is_adalora or is_adamss:
+                model.base_model.update_and_allocate(step)
+
+            losses.append(loss.item())
+            pbar.set_postfix({"loss": loss.item()})
+            accelerator_memory_allocated_log.append(
+                torch_accelerator_module.memory_allocated() - accelerator_memory_init
+            )
+            accelerator_memory_reserved_log.append(
+                torch_accelerator_module.memory_reserved() - accelerator_memory_init
+            )
+            toc = time.perf_counter()
+            durations.append(toc - tic)
+
+            # every couple of steps, evaluate; this can be slow due to generation
+            if step % eval_steps == 0:
+                tic_eval = time.perf_counter()
+                loss_avg = sum(losses[-eval_steps:]) / eval_steps
+                memory_allocated_avg = sum(accelerator_memory_allocated_log[-eval_steps:]) / eval_steps
+                memory_reserved_avg = sum(accelerator_memory_reserved_log[-eval_steps:]) / eval_steps
+                token_sum = sum(total_tokens[-eval_steps:])
+                dur_train = sum(durations[-eval_steps:])
+                tokens_per_sec = token_sum / dur_train
+
+                model.eval()
+                predictions, responses = evaluate(
+                    model=model,
+                    tokenizer=tokenizer,
+                    ds=ds_valid,
+                    batch_size=batch_size_eval,
+                    generate_kwargs={**generation_kwargs},
+                )
+                model.train()
+
+                example = random.choice(predictions)
+                example = textwrap.shorten(example, width=750)
+                example = textwrap.indent(example, "    ")
+                print_verbose(f"\nExample prediction:\n{example}\n")
+                accuracy = get_accuracy(predictions=predictions, responses=responses)
+                num_tokens_generated = sum(sum(mask) for mask in tokenizer(predictions)["attention_mask"])
+
+                toc_eval = time.perf_counter()
+                dur_eval = toc_eval - tic_eval
+                eval_time += toc_eval - tic_eval
+                elapsed = time.perf_counter() - tic_train
+
+                metrics.append(
+                    {
+                        "step": step,
+                        "valid accuracy": accuracy,
+                        "train loss": loss_avg,
+                        "train samples": total_samples,
+                        "train time": dur_train,
+                        "eval time": dur_eval,
+                        "tokens / sec": tokens_per_sec,
+                        "mem allocated avg": memory_allocated_avg,
+                        "mem reserved avg": memory_reserved_avg,
+                        "elapsed time": elapsed,
+                    }
+                )
+
+                log_dict = {
+                    "step": f"{step:5d}",
+                    "samples": f"{total_samples:7d}",
+                    "lr": f"{lr_scheduler.get_last_lr()[0]:.2e}",
+                    "loss avg": f"{loss_avg:.4f}",
+                    "valid acc": f"{accuracy:.3f}",
+                    "gen valid tokens": num_tokens_generated,
+                    "train time": f"{dur_train:.1f}s",
+                    "eval time": f"{dur_eval:.1f}s",
+                    "train tokens / sec": f"{tokens_per_sec:.0f}",
+                    "mem allocated": f"{memory_allocated_avg:.0f}",
+                    "mem reserved": f"{memory_reserved_avg:.0f}",
+                    "elapsed time": f"{elapsed // 60:.0f}min {elapsed % 60:.0f}s",
+                }
+                print_verbose(json.dumps(log_dict))
+
+            if step % ACCELERATOR_EMPTY_CACHE_SCHEDULE == 0:
+                torch_accelerator_module.empty_cache()
+
+        print_verbose(f"Training finished after {max_steps} steps, evaluation on test set follows.")
+        # test set evaluation
+        model.eval()
+        predictions, responses = evaluate(
+            model=model,
+            tokenizer=tokenizer,
+            ds=ds_test,
+            batch_size=batch_size_eval,
+            generate_kwargs={**generation_kwargs, "pad_token_id": tokenizer.eos_token_id},
+            use_tqdm=len(ds_test) > 100,
+        )
+        accuracy = get_accuracy(predictions=predictions, responses=responses)
+        # use small batch_size, not batch_size_eval, to prevent this from taking too much memory and affecting the max memory metric
+        wiki_loss_after = calculate_mean_per_token_loss(
+            model=model, tokenizer=tokenizer, rows=rows_wiki, batch_size=batch_size, max_length=768
+        )
+        forgetting = wiki_loss_after - wiki_loss_before
+        metrics.append(
+            {
+                "step": step,
+                "test accuracy": accuracy,
+                "train loss": sum(losses[-eval_steps:]) / eval_steps,
+                "train samples": total_samples,
+                "train total tokens": sum(total_tokens),
+                "forgetting": forgetting,
+            }
+        )
+        print_verbose(f"Test accuracy: {accuracy:.3f}")
+
+    except KeyboardInterrupt:
+        print_verbose("canceled training")
+        status = TrainStatus.CANCELED
+        error_msg = "manually canceled"
+    except torch.OutOfMemoryError as exc:
+        # ouch, still let's try to log some results
+        print_verbose("out of memory error encountered")
+        status = TrainStatus.CANCELED
+        error_msg = str(exc)
+    except Exception as exc:
+        print_verbose(f"encountered an error: {exc}")
+        status = TrainStatus.CANCELED
+        error_msg = str(exc)
+
+    toc_train = time.perf_counter()
+    train_time = toc_train - tic_train - eval_time
+
+    if status != TrainStatus.CANCELED:
+        status = TrainStatus.SUCCESS
+    train_result = TrainResult(
+        status=status,
+        train_time=train_time,
+        accelerator_memory_reserved_log=accelerator_memory_reserved_log,
+        losses=losses,
+        metrics=metrics,
+        error_msg=error_msg,
+        num_trainable_params=num_trainable_params,
+        num_total_params=num_params,
+    )
+    return train_result
+
+
+def main(*, path_experiment: str, experiment_name: str, clean: bool, bucket_name: Optional[str]) -> None:
+    tic_total = time.perf_counter()
+    start_date = dt.datetime.now(tz=dt.timezone.utc).replace(microsecond=0).isoformat()
+
+    peft_branch = get_peft_branch()
+    if peft_branch == "main":
+        print_verbose("===== This experiment is categorized as a MAIN run because the PEFT branch is 'main' ======")
+    else:
+        print_verbose(
+            f"===== This experiment is categorized as a TEST run because the PEFT branch is '{peft_branch}' ======"
+        )
+
+    # load configs
+    peft_config: Optional[PeftConfig] = None
+    if os.path.exists(os.path.join(path_experiment, CONFIG_NAME)):
+        peft_config = PeftConfig.from_pretrained(path_experiment)
+    else:
+        print_verbose(f"Could not find PEFT config at {path_experiment}, performing FULL FINETUNING")
+    path_train_config = os.path.join(path_experiment, FILE_NAME_TRAIN_PARAMS)
+    train_config = get_train_config(path_train_config)
+    set_seed(train_config.seed)
+
+    # initialize objects
+    accelerator_memory_init = init_accelerator()
+    tokenizer = get_tokenizer(model_id=train_config.model_id, max_seq_length=train_config.max_seq_length)
+
+    model_info = get_base_model_info(train_config.model_id)
+    metamath_info = get_dataset_info("meta-math/MetaMathQA")
+    gsm8k_info = get_dataset_info("openai/gsm8k")
+    model = get_model(
+        model_id=train_config.model_id,
+        dtype=train_config.dtype,
+        compile=train_config.compile,
+        use_gc=train_config.use_gc,
+        attn_implementation=train_config.attn_implementation,
+        peft_config=peft_config,
+        autocast_adapter_dtype=train_config.autocast_adapter_dtype,
+    )
+    print_verbose(model)
+
+    # train model
+    train_result = train(
+        model=model,
+        max_steps=train_config.max_steps,
+        batch_size=train_config.batch_size,
+        batch_size_eval=train_config.batch_size_eval,
+        tokenizer=tokenizer,
+        accelerator_memory_init=accelerator_memory_init,
+        eval_steps=train_config.eval_steps,
+        generation_kwargs=train_config.generation_kwargs,
+        grad_norm_clip=train_config.grad_norm_clip,
+        optimizer_type=train_config.optimizer_type,
+        optimizer_kwargs=train_config.optimizer_kwargs,
+        query_template=train_config.query_template,
+        lr_scheduler_arg=train_config.lr_scheduler,
+        use_amp=train_config.use_amp,
+        is_adalora=isinstance(peft_config, AdaLoraConfig),
+        init_kv_cache_prefix=train_config.init_kv_cache_prefix,
+        is_adamss=isinstance(peft_config, AdamssConfig),
+    )
+
+    if train_result.status == TrainStatus.FAILED:
+        print_verbose("Training failed, not logging results")
+        sys.exit(1)
+
+    file_size = get_file_size(
+        model,
+        peft_config=peft_config,
+        clean=clean,
+        print_fn=print_verbose,
+    )
+
+    if bucket_name is not None:
+        upload_checkpoint_to_bucket(model, experiment_name, bucket_name)
+
+    time_total = time.perf_counter() - tic_total
+    # log results: print and save to file
+    log_results(
+        experiment_name=experiment_name,
+        train_result=train_result,
+        accelerator_memory_init=accelerator_memory_init,
+        time_total=time_total,
+        file_size=file_size,
+        model_info=model_info,
+        datasets_info={"metamath": metamath_info, "gsm8k": gsm8k_info},
+        start_date=start_date,
+        train_config=train_config,
+        peft_config=peft_config,
+        print_fn=print_verbose,
+    )
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-v", "--verbose", action="store_true", help="Enable verbose output")
+    parser.add_argument("path_experiment", type=str, help="Path to the experiment directory")
+    parser.add_argument(
+        "--clean",
+        action="store_true",
+        help="Delete training artifacts after run finishes (logs are still saved)",
+    )
+    parser.add_argument("--bucket_name", type=str, help="HF bucket to upload checkpoints to.")
+    args = parser.parse_args()
+
+    experiment_name = validate_experiment_path(args.path_experiment)
+
+    if args.verbose:
+
+        def print_verbose(*args, **kwargs) -> None:
+            kwargs["file"] = sys.stderr
+            print(*args, **kwargs)
+    else:
+
+        def print_verbose(*args, **kwargs) -> None:
+            pass
+
+    main(
+        path_experiment=args.path_experiment,
+        experiment_name=experiment_name,
+        clean=args.clean,
+        bucket_name=args.bucket_name,
+    )
diff --git a/method_comparison/MetaMathQA/utils.py b/method_comparison/MetaMathQA/utils.py
new file mode 100644
index 0000000..155885c
--- /dev/null
+++ b/method_comparison/MetaMathQA/utils.py
@@ -0,0 +1,727 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+"""
+All utilities not related to data handling.
+"""
+
+import enum
+import json
+import os
+import platform
+import subprocess
+import tempfile
+import warnings
+from collections.abc import Callable
+from dataclasses import asdict, dataclass
+from decimal import Decimal, DivisionByZero, InvalidOperation
+from typing import Any, Literal, Optional
+
+import bitsandbytes
+import datasets
+import huggingface_hub
+import numpy as np
+import torch
+import transformers
+from torch import nn
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    BitsAndBytesConfig,
+    PreTrainedModel,
+    get_cosine_schedule_with_warmup,
+)
+
+import peft
+from peft import PeftConfig, get_peft_model
+from peft.optimizers import create_lorafa_optimizer, create_loraplus_optimizer
+from peft.utils import SAFETENSORS_WEIGHTS_NAME, infer_device
+
+
+device = infer_device()
+
+if device not in ["cuda", "xpu"]:
+    raise RuntimeError("CUDA or XPU is not available, currently only CUDA or XPU is supported")
+
+ACCELERATOR_MEMORY_INIT_THRESHOLD = 500 * 2**20  # 500MB
+FILE_NAME_DEFAULT_TRAIN_PARAMS = os.path.join(os.path.dirname(__file__), "default_training_params.json")
+FILE_NAME_TRAIN_PARAMS = "training_params.json"  # specific params for this experiment
+# main results
+RESULT_PATH = os.path.join(os.path.dirname(__file__), "results")
+# testing results
+RESULT_PATH_TEST = os.path.join(os.path.dirname(__file__), "temporary_results")
+# cancelled results
+RESULT_PATH_CANCELLED = os.path.join(os.path.dirname(__file__), "cancelled_results")
+hf_api = huggingface_hub.HfApi()
+WARMUP_STEP_RATIO = 0.1
+
+
+@dataclass
+class TrainConfig:
+    """All configuration parameters associated with training the model
+
+    Args:
+        model_id: The model identifier
+        dtype: The data type to use for the model
+        max_seq_length: The maximum sequence length
+        batch_size: The batch size for training
+        batch_size_eval: The batch size for eval/test, can be much higher than for training
+        max_steps: The maximum number of steps to train for
+        eval_steps: The number of steps between evaluations
+        compile: Whether to compile the model
+        use_gc: Whether to use gradient checkpointing.
+        query_template: The template for the query
+        seed: The random seed
+        grad_norm_clip: The gradient norm clipping value (set to 0 to skip)
+        optimizer_type: The name of a torch optimizer (e.g. AdamW) or a PEFT method ("lora+", "lora-fa")
+        optimizer_kwargs: The optimizer keyword arguments (lr etc.)
+        lr_scheduler: The learning rate scheduler (currently only None or 'cosine' are supported)
+        use_amp: Whether to use automatic mixed precision
+        autocast_adapter_dtype: Whether to cast adapter dtype to float32, same argument as in PEFT
+        generation_kwargs: Arguments passed to transformers GenerationConfig (used in evaluation)
+        attn_implementation: The attention implementation to use (if any), see transformers docs
+    """
+
+    model_id: str
+    dtype: Literal["float32", "float16", "bfloat16", "int8", "int4"]
+    max_seq_length: int
+    batch_size: int
+    batch_size_eval: int
+    max_steps: int
+    eval_steps: int
+    compile: bool
+    use_gc: bool
+    query_template: str
+    seed: int
+    grad_norm_clip: float  # set to 0 to skip
+    optimizer_type: str
+    optimizer_kwargs: dict[str, Any]
+    lr_scheduler: Optional[Literal["cosine"]]
+    use_amp: bool
+    autocast_adapter_dtype: bool
+    generation_kwargs: dict[str, Any]
+    attn_implementation: Optional[str]
+    init_kv_cache_prefix: Optional[str]
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.model_id, str):
+            raise TypeError(f"Invalid model_id: {self.model_id}")
+        if self.dtype not in ["float32", "float16", "bfloat16", "int8", "int4"]:
+            raise ValueError(f"Invalid dtype: {self.dtype}")
+        if self.max_seq_length < 0:
+            raise ValueError(f"Invalid max_seq_length: {self.max_seq_length}")
+        if self.batch_size <= 0:
+            raise ValueError(f"Invalid batch_size: {self.batch_size}")
+        if self.batch_size_eval <= 0:
+            raise ValueError(f"Invalid eval batch_size: {self.batch_size_eval}")
+        if self.max_steps <= 0:
+            raise ValueError(f"Invalid max_steps: {self.max_steps}")
+        if self.eval_steps <= 0:
+            raise ValueError(f"Invalid eval_steps: {self.eval_steps}")
+        if self.eval_steps > self.max_steps:
+            raise ValueError(f"Invalid eval_steps: {self.eval_steps} > max_steps: {self.max_steps}")
+        if self.grad_norm_clip < 0:
+            raise ValueError(f"Invalid grad_norm_clip: {self.grad_norm_clip}")
+        if self.optimizer_type not in ["lora+", "lora-fa"] and not hasattr(torch.optim, self.optimizer_type):
+            raise ValueError(f"Invalid optimizer_type: {self.optimizer_type}")
+        if self.lr_scheduler not in [None, "cosine"]:
+            raise ValueError(f"Invalid lr_scheduler: {self.lr_scheduler}, must be None or 'cosine'")
+        if "{query}" not in self.query_template:
+            raise ValueError("Invalid query_template, must contain '{query}'")
+
+
+def validate_experiment_path(path: str) -> str:
+    # the experiment path should take the form of ./experiments/<peft-method>/<experiment-name>
+    # e.g. ./experiments/lora/rank32
+    # it should contain:
+    # - adapter_config.json
+    # - optional: training_params.json
+    if not os.path.exists(FILE_NAME_DEFAULT_TRAIN_PARAMS):
+        raise FileNotFoundError(
+            f"Missing default training params file '{FILE_NAME_DEFAULT_TRAIN_PARAMS}' in the ./experiments directory"
+        )
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"Path {path} does not exist")
+
+    # check path structure
+    path_parts = path.rstrip(os.path.sep).split(os.path.sep)
+    if (len(path_parts) != 3) or (path_parts[-3] != "experiments"):
+        raise ValueError(
+            f"Path {path} does not have the correct structure, should be ./experiments/<peft-method>/<experiment-name>"
+        )
+
+    experiment_name = os.path.join(*path_parts[-2:])
+    return experiment_name
+
+
+def get_train_config(path: str) -> TrainConfig:
+    # first, load the default params, then update with experiment-specific params
+    with open(FILE_NAME_DEFAULT_TRAIN_PARAMS) as f:
+        default_config_kwargs = json.load(f)
+
+    config_kwargs = {}
+    if os.path.exists(path):
+        with open(path) as f:
+            config_kwargs = json.load(f)
+
+    config_kwargs = {**default_config_kwargs, **config_kwargs}
+    return TrainConfig(**config_kwargs)
+
+
+def init_accelerator() -> int:
+    torch_accelerator_module = getattr(torch, device, torch.cuda)
+    torch.manual_seed(0)
+    torch_accelerator_module.reset_peak_memory_stats()
+    torch_accelerator_module.manual_seed_all(0)
+    # might not be necessary, but just to be sure
+    nn.Linear(1, 1).to(device)
+
+    accelerator_memory_init = torch_accelerator_module.max_memory_reserved()
+    if accelerator_memory_init > ACCELERATOR_MEMORY_INIT_THRESHOLD:
+        raise RuntimeError(
+            f"{device} memory usage at start is too high: {accelerator_memory_init // 2**20}MB, please ensure that no other "
+            f"processes are running on {device}."
+        )
+
+    torch_accelerator_module.reset_peak_memory_stats()
+    accelerator_memory_init = torch_accelerator_module.max_memory_reserved()
+    return accelerator_memory_init
+
+
+def get_tokenizer(*, model_id: str, max_seq_length: int):
+    tokenizer = AutoTokenizer.from_pretrained(model_id)
+    tokenizer.model_max_length = max_seq_length
+    if not tokenizer.pad_token:
+        tokenizer.pad_token = tokenizer.eos_token
+    return tokenizer
+
+
+def get_base_model(
+    *,
+    model_id: str,
+    dtype: Literal["float32", "float16", "bfloat16", "int8", "int4"],
+    attn_implementation: Optional[str],
+    use_gc: bool,
+) -> PreTrainedModel:
+    kwargs: dict[str, Any] = {
+        "pretrained_model_name_or_path": model_id,
+        "device_map": device,
+        "attn_implementation": attn_implementation,
+    }
+    if dtype == "int4":
+        quant_config = BitsAndBytesConfig(load_in_4bit=True)
+        kwargs["quantization_config"] = quant_config
+    elif dtype == "int8":
+        quant_config = BitsAndBytesConfig(load_in_8bit=True)
+        kwargs["quantization_config"] = quant_config
+    elif dtype == "bfloat16":
+        kwargs["dtype"] = torch.bfloat16
+    elif dtype == "float16":
+        kwargs["dtype"] = torch.float16
+    elif dtype != "float32":
+        raise ValueError(f"Invalid dtype: {dtype}")
+
+    model = AutoModelForCausalLM.from_pretrained(**kwargs)
+    if use_gc:
+        model.enable_input_require_grads()
+        model.gradient_checkpointing_enable()
+
+    return model
+
+
+def get_model(
+    *,
+    model_id: str,
+    dtype: Literal["float32", "float16", "bfloat16", "int8", "int4"],
+    compile: bool,
+    use_gc: bool,
+    attn_implementation: Optional[str],
+    peft_config: Optional[PeftConfig],
+    autocast_adapter_dtype: bool,
+) -> nn.Module:
+    base_model = get_base_model(model_id=model_id, dtype=dtype, attn_implementation=attn_implementation, use_gc=use_gc)
+    if peft_config is None:
+        model = base_model
+    else:
+        model = get_peft_model(base_model, peft_config, autocast_adapter_dtype=autocast_adapter_dtype)
+
+    if compile:
+        model = torch.compile(model, dynamic=True)
+
+    return model
+
+
+class DummyScheduler:
+    # if no lr scheduler is being used
+    def __init__(self, lr):
+        self.lr = lr
+
+    def get_last_lr(self):
+        return [self.lr]
+
+    def step(self):
+        pass
+
+
+def get_optimizer_and_scheduler(
+    model, *, optimizer_type: str, max_steps: int, lr_scheduler_arg: Optional[Literal["cosine"]], **optimizer_kwargs
+) -> tuple[torch.optim.Optimizer, Any]:
+    if optimizer_type == "lora+":
+        optimizer = create_loraplus_optimizer(model, optimizer_cls=torch.optim.AdamW, **optimizer_kwargs)
+    elif optimizer_type == "lora-fa":
+        optimizer = create_lorafa_optimizer(model, **optimizer_kwargs)
+    else:
+        cls = getattr(torch.optim, optimizer_type)
+        optimizer = cls(model.parameters(), **optimizer_kwargs)
+
+    if lr_scheduler_arg == "cosine":
+        warmup_steps = int(WARMUP_STEP_RATIO * max_steps)
+        lr_scheduler = get_cosine_schedule_with_warmup(
+            optimizer, num_warmup_steps=warmup_steps, num_training_steps=max_steps
+        )
+    elif lr_scheduler_arg is None:
+        lr_scheduler = DummyScheduler(optimizer_kwargs["lr"])
+    else:
+        raise ValueError(f"Invalid lr_scheduler argument: {lr_scheduler_arg}")
+
+    return optimizer, lr_scheduler
+
+
+class BucketIterator:
+    """
+    Iterator that yields batches of data from a torch Dataset, grouped in buckets by sequence length
+
+    The iterator will yield batches of size `batch_size`, where the samples in each batch are sorted by sequence length.
+    This is done to minimize the amount of padding required for each batch. To avoid sorting the entire dataset and thus
+    introducing a bias, the dataset is first split into buckets of size `batch_size * bucket_factor`.
+
+    Args:
+        ds: The torch Dataset to iterate over
+        batch_size: The batch size
+        bucket_factor: The factor by which to multiply the batch size to determine the bucket size
+        delete_cols: The columns to delete from the dataset before yielding a batch
+    """
+
+    def __init__(self, ds, *, batch_size: int, bucket_factor: int, delete_cols: list[str]) -> None:
+        self.ds = ds
+        self.batch_size = batch_size
+        self.bucket_factor = bucket_factor
+        self.delete_cols = set(delete_cols)
+
+        assert self.bucket_factor > 0, "bucket_factor must be greater than 0"
+
+    def _batch_iterator(self, bucket):
+        tokens_per_sample_bucket = torch.tensor([len(i) for i in bucket["input_ids"]])
+        # sort long to short instead to encounter possible OOM errors as early as possible
+        sorted = torch.argsort(tokens_per_sample_bucket, descending=True)
+        cls = type(bucket)  # conserve the type returned by the ds
+        bucket = {k: [v[i] for i in sorted] for k, v in bucket.items() if k not in self.delete_cols}
+        num_samples = len(bucket["input_ids"])
+        for j in range(0, num_samples, self.batch_size):
+            batch = {k: v[j : j + self.batch_size] for k, v in bucket.items()}
+            yield cls(batch)
+
+    def __iter__(self):
+        bucket_size = self.batch_size * self.bucket_factor
+        for i in range(0, len(self.ds), bucket_size):
+            bucket = self.ds[i : i + bucket_size]
+            yield from self._batch_iterator(bucket)
+
+        # if there is a remainder, we yield the last batch
+        if len(self.ds) % bucket_size != 0:
+            bucket = self.ds[-(len(self.ds) % bucket_size) :]
+            yield from self._batch_iterator(bucket)
+
+
+def upload_checkpoint_to_bucket(model: nn.Module, experiment_name: str, bucket_name: str):
+    try:
+        with tempfile.TemporaryDirectory(ignore_cleanup_errors=True, delete=True) as tmp_dir:
+            model.save_pretrained(tmp_dir)
+            huggingface_hub.batch_bucket_files(
+                bucket_name,
+                add=[(os.path.join(tmp_dir, fname), f"{experiment_name}/{fname}") for fname in os.listdir(tmp_dir)],
+            )
+    except Exception as exc:
+        print(f"Failed to upload model checkpoint to hub: {exc}")
+
+
+def get_file_size(
+    model: nn.Module, *, peft_config: Optional[PeftConfig], clean: bool, print_fn: Callable[..., None]
+) -> int:
+    file_size = 99999999  # set a default dummy value
+    if peft_config is not None:
+        try:
+            with tempfile.TemporaryDirectory(ignore_cleanup_errors=True, delete=clean) as tmp_dir:
+                model.save_pretrained(tmp_dir)
+                stat = os.stat(os.path.join(tmp_dir, SAFETENSORS_WEIGHTS_NAME))
+                file_size = stat.st_size
+                if not clean:
+                    print_fn(f"Saved PEFT checkpoint to {tmp_dir}")
+        except Exception as exc:
+            print(f"Failed to save PEFT checkpoint due to the following error: {exc}")
+    else:
+        print_fn("Not saving the fully fine-tuned model because it's too big, estimating the size instead")
+        try:
+            num_params = model.num_parameters()
+            dtype_size = next(model.parameters()).element_size()
+            file_size = num_params * dtype_size
+        except Exception as exc:
+            print(f"Failed to determine file size for fully finetuned model because of: {exc}")
+    return file_size
+
+
+##################
+# ANSWER PARSING #
+##################
+
+
+def parse_answer(text: str) -> Optional[str]:
+    """
+    A label/prediction can look like this:
+
+    Question: If the magnitude of vector v is equal to 4, what is the dot product of vector v with itself?. Think step
+    by step
+    Answer: The dot product of a vector with itself is equal to the square of its magnitude. So, the dot product of
+    vector v with itself is equal to $4^2 = \boxed{16}$.The answer is: 16
+
+    We want to extract '16' from this string.
+
+    """
+    # This implementation is based on sampling meta-llama/Llama-3.1-8B-Instruct. It may not work for other models.
+    candidate_delimiters = [
+        # MetaMath:
+        "The answer is: ",
+        "The answer is ",
+        "The final answer is: ",
+        "The final answer is ",
+        # GSM8K:
+        "#### ",
+    ]
+    text = text.strip()
+    text = text.rstrip(".!?")
+    for delimiter in candidate_delimiters:
+        if delimiter in text:
+            break
+    else:  # no match
+        return None
+
+    text = text.rpartition(delimiter)[-1].strip()
+    # if a new paragraph follows after the final answer, we want to remove it
+    text = text.split("\n", 1)[0]
+    # note: we can just remove % here since the GSM8K dataset just omits it, i.e. 50% -> 50, no need to divide by 100
+    text = text.strip(" .!?$%")
+    return text
+
+
+def convert_to_decimal(s: Optional[str]) -> Optional[Decimal]:
+    """
+    Converts a string representing a number to a Decimal.
+
+    The string may be:
+      - A simple number (e.g., "13", "65.33")
+      - A fraction (e.g., "20/14")
+    """
+    if s is None:
+        return None
+
+    try:
+        s = s.strip()
+        # Check if the string represents a fraction.
+        if "/" in s:
+            parts = s.split("/")
+            if len(parts) != 2:
+                return None
+            numerator = Decimal(parts[0].strip())
+            denominator = Decimal(parts[1].strip())
+            if denominator == 0:
+                return None
+            value = numerator / denominator
+        else:
+            # Parse as a regular decimal or integer string.
+            value = Decimal(s)
+        return value
+    except (DivisionByZero, InvalidOperation, ValueError):
+        return None
+
+
+def get_accuracy(*, predictions: list[str], responses: list[str]) -> float:
+    if len(predictions) != len(responses):
+        raise ValueError(f"Prediction length mismatch: {len(predictions)} != {len(responses)}")
+
+    y_true: list[str | float | None] = []
+    y_pred: list[str | float | None] = []
+
+    for prediction, response in zip(predictions, responses):
+        parsed_prediction = parse_answer(prediction)
+        parsed_response = parse_answer(response)
+        if parsed_response is None:
+            raise ValueError(f"Error encountered while trying to parse response: {response}")
+
+        decimal_prediction = convert_to_decimal(parsed_prediction)
+        decimal_answer = convert_to_decimal(parsed_response)
+        if decimal_prediction is not None:
+            y_pred.append(float(decimal_prediction))
+        elif parsed_prediction is not None:
+            y_pred.append(parsed_prediction)
+        else:
+            y_pred.append(None)
+
+        # we convert decimals to float so that stuff like this works:
+        # float(convert_to_decimal('20/35')) == float(convert_to_decimal('0.5714285714285714'))
+        if decimal_answer is not None:
+            y_true.append(float(decimal_answer))
+        elif parsed_prediction is not None:
+            y_true.append(parsed_response)
+        else:
+            y_true.append(None)
+
+    correct: list[bool] = []
+    for true, pred in zip(y_true, y_pred):
+        if (true is not None) and (pred is not None):
+            correct.append(true == pred)
+        else:
+            correct.append(False)
+
+    accuracy = sum(correct) / len(correct)
+    return accuracy
+
+
+###########
+# LOGGING #
+###########
+
+
+def get_base_model_info(model_id: str) -> Optional[huggingface_hub.ModelInfo]:
+    try:
+        return hf_api.model_info(model_id)
+    except Exception as exc:
+        warnings.warn(f"Could not retrieve model info, failed with error {exc}")
+        return None
+
+
+def get_dataset_info(dataset_id: str) -> Optional[huggingface_hub.DatasetInfo]:
+    try:
+        return hf_api.dataset_info(dataset_id)
+    except Exception as exc:
+        warnings.warn(f"Could not retrieve dataset info, failed with error {exc}")
+        return None
+
+
+def get_git_hash(module) -> Optional[str]:
+    if "site-packages" in module.__path__[0]:
+        return None
+
+    return subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=os.path.dirname(module.__file__)).decode().strip()
+
+
+def get_package_info() -> dict[str, Optional[str]]:
+    """Get the package versions and commit hashes of transformers, peft, datasets, bnb, and torch"""
+    package_info = {
+        "transformers-version": transformers.__version__,
+        "transformers-commit-hash": get_git_hash(transformers),
+        "peft-version": peft.__version__,
+        "peft-commit-hash": get_git_hash(peft),
+        "datasets-version": datasets.__version__,
+        "datasets-commit-hash": get_git_hash(datasets),
+        "bitsandbytes-version": bitsandbytes.__version__,
+        "bitsandbytes-commit-hash": get_git_hash(bitsandbytes),
+        "torch-version": torch.__version__,
+        "torch-commit-hash": get_git_hash(torch),
+    }
+    return package_info
+
+
+def get_system_info() -> dict[str, str]:
+    device = infer_device()
+    torch_accelerator_module = getattr(torch, device, torch.cuda)
+    system_info = {
+        "system": platform.system(),
+        "release": platform.release(),
+        "version": platform.version(),
+        "machine": platform.machine(),
+        "processor": platform.processor(),
+        "accelerator": torch_accelerator_module.get_device_name(0),
+    }
+    return system_info
+
+
+@dataclass
+class MetaInfo:
+    package_info: dict[str, Optional[str]]
+    system_info: dict[str, str]
+    pytorch_info: str
+
+
+def get_meta_info() -> MetaInfo:
+    meta_info = MetaInfo(
+        package_info=get_package_info(),
+        system_info=get_system_info(),
+        pytorch_info=torch.__config__.show(),
+    )
+    return meta_info
+
+
+def get_peft_branch() -> str:
+    return (
+        subprocess.check_output(["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd=os.path.dirname(peft.__file__))
+        .decode()
+        .strip()
+    )
+
+
+class TrainStatus(enum.Enum):
+    FAILED = "failed"
+    SUCCESS = "success"
+    CANCELED = "canceled"
+
+
+@dataclass
+class TrainResult:
+    status: TrainStatus
+    train_time: float
+    accelerator_memory_reserved_log: list[int]
+    losses: list[float]
+    metrics: list[Any]  # TODO
+    error_msg: str
+    num_trainable_params: int
+    num_total_params: int
+
+
+def log_to_console(log_data: dict[str, Any], print_fn: Callable[..., None]) -> None:
+    accelerator_memory_max = log_data["train_info"]["accelerator_memory_max"]
+    accelerator_memory_avg = log_data["train_info"]["accelerator_memory_reserved_avg"]
+    accelerator_memory_reserved_99th = log_data["train_info"]["accelerator_memory_reserved_99th"]
+    time_train = log_data["train_info"]["train_time"]
+    time_total = log_data["run_info"]["total_time"]
+    file_size = log_data["train_info"]["file_size"]
+
+    print_fn(f"accelerator memory max: {accelerator_memory_max // 2**20}MB")
+    print_fn(f"accelerator memory reserved avg: {accelerator_memory_avg // 2**20}MB")
+    print_fn(f"accelerator memory reserved 99th percentile: {accelerator_memory_reserved_99th // 2**20}MB")
+    print_fn(f"train time: {time_train}s")
+    print_fn(f"total time: {time_total:.2f}s")
+    print_fn(f"file size of checkpoint: {file_size / 2**20:.1f}MB")
+
+
+def log_to_file(
+    *, log_data: dict, save_dir: str, experiment_name: str, timestamp: str, print_fn: Callable[..., None]
+) -> None:
+    if save_dir.endswith(RESULT_PATH):
+        file_name = f"{experiment_name.replace(os.path.sep, '--')}.json"
+    else:
+        # For cancelled and temporary runs, we want to include the timestamp, as these runs are not tracked in git, thus
+        # we need unique names to avoid losing history.
+        file_name = f"{experiment_name.replace(os.path.sep, '--')}--{timestamp.replace(':', '-')}.json"
+    file_name = os.path.join(save_dir, file_name)
+    with open(file_name, "w") as f:
+        json.dump(log_data, f, indent=2)
+    print_fn(f"Saved log to: {file_name}")
+
+
+def log_results(
+    *,
+    experiment_name: str,
+    train_result: TrainResult,
+    accelerator_memory_init: int,
+    time_total: float,
+    file_size: int,
+    model_info: Optional[huggingface_hub.ModelInfo],
+    datasets_info: dict[str, Optional[huggingface_hub.DatasetInfo]],
+    start_date: str,
+    train_config: TrainConfig,
+    peft_config: Optional[PeftConfig],
+    print_fn: Callable[..., None],
+) -> None:
+    # collect results
+    device = infer_device()
+    torch_accelerator_module = getattr(torch, device, torch.cuda)
+    accelerator_memory_final = torch_accelerator_module.max_memory_reserved()
+    accelerator_memory_avg = int(
+        sum(train_result.accelerator_memory_reserved_log) / len(train_result.accelerator_memory_reserved_log)
+    )
+    accelerator_memory_reserved_99th = int(np.percentile(train_result.accelerator_memory_reserved_log, 99))
+
+    meta_info = get_meta_info()
+    if model_info is not None:
+        model_sha = model_info.sha
+        model_created_at = model_info.created_at.isoformat()
+    else:
+        model_sha = None
+        model_created_at = None
+
+    dataset_info_log = {}
+    for key, dataset_info in datasets_info.items():
+        if dataset_info is not None:
+            dataset_sha = dataset_info.sha
+            dataset_created_at = dataset_info.created_at.isoformat()
+        else:
+            dataset_sha = None
+            dataset_created_at = None
+        dataset_info_log[key] = {"sha": dataset_sha, "created_at": dataset_created_at}
+
+    peft_branch = get_peft_branch()
+
+    if train_result.status == TrainStatus.CANCELED:
+        save_dir = RESULT_PATH_CANCELLED
+        print_fn("Experiment run was categorized as canceled")
+    elif peft_branch != "main":
+        save_dir = RESULT_PATH_TEST
+        print_fn(f"Experiment run was categorized as a test run on branch {peft_branch}")
+    elif train_result.status == TrainStatus.SUCCESS:
+        save_dir = RESULT_PATH
+        print_fn("Experiment run was categorized as successful run")
+    else:
+        save_dir = tempfile.mkdtemp()
+        print_fn(f"Experiment could not be categorized, writing results to {save_dir}. Please open an issue on PEFT.")
+
+    if peft_config is None:
+        peft_config_dict: Optional[dict[str, Any]] = None
+    else:
+        peft_config_dict = peft_config.to_dict()
+        for key, value in peft_config_dict.items():
+            if isinstance(value, set):
+                peft_config_dict[key] = list(value)
+
+    log_data = {
+        "run_info": {
+            "created_at": start_date,
+            "total_time": time_total,
+            "experiment_name": experiment_name,
+            "peft_branch": peft_branch,
+            "train_config": asdict(train_config),
+            "peft_config": peft_config_dict,
+            "error_msg": train_result.error_msg,
+        },
+        "train_info": {
+            "accelerator_memory_reserved_avg": accelerator_memory_avg,
+            "accelerator_memory_max": (accelerator_memory_final - accelerator_memory_init),
+            "accelerator_memory_reserved_99th": accelerator_memory_reserved_99th,
+            "train_time": train_result.train_time,
+            "file_size": file_size,
+            "num_trainable_params": train_result.num_trainable_params,
+            "num_total_params": train_result.num_total_params,
+            "status": train_result.status.value,
+            "metrics": train_result.metrics,
+        },
+        "meta_info": {
+            "model_info": {"sha": model_sha, "created_at": model_created_at},
+            "dataset_info": dataset_info_log,
+            **asdict(meta_info),
+        },
+    }
+
+    log_to_console(log_data, print_fn=print)  # use normal print to be able to redirect if so desired
+    log_to_file(
+        log_data=log_data, save_dir=save_dir, experiment_name=experiment_name, timestamp=start_date, print_fn=print_fn
+    )
diff --git a/method_comparison/README.md b/method_comparison/README.md
new file mode 100644
index 0000000..c34fec0
--- /dev/null
+++ b/method_comparison/README.md
@@ -0,0 +1,116 @@
+---
+title: PEFT Method Comparison
+sdk: gradio
+app_file: app.py
+pinned: false
+emoji: ⚖️
+---
+
+# Comparison of PEFT Methods
+
+The goal of this project is to provide replicable experiments that produce outcomes allowing us to compare different PEFT methods with one another. This gives you more information to make an informed decision about which methods best fit your use case and what trade-offs to expect.
+
+Visit our [Gradio Space](https://huggingface.co/spaces/peft-internal-testing/PEFT-method-comparison) to check the results.
+
+## Community Contributions
+
+We envision the PEFT method comparison project as an ongoing endeavor with heavy involvement from the community. As maintainers, it is impossible for us to know all the perfect hyperparameters for each method or to predict all the use cases that PEFT users may have. As a consequence, community contributions are very welcome.
+
+Below, we outline all the ways you can contribute to this project.
+
+### Creating New Experiments
+
+Creating a new experiment requires setting up a new PEFT configuration for us to test. This will result in one more data point being added to the total comparison.
+
+Working on this is especially relevant if:
+
+1. You are the author of a paper whose method is introduced in PEFT, or worked on the PEFT integration, and know what hyperparameters work best.
+2. You have experience with a specific method and want to share your knowledge with the community.
+
+Of course, you can contribute even without meeting these criteria. Please follow the instructions below.
+
+#### How to Add New Experiments
+
+Start by navigating to one of the existing experiment folders, e.g. `peft/method_comparison/MetaMathQA`, if your experiment involves using the [MetaMathQA dataset](https://huggingface.co/datasets/meta-math/MetaMathQA). There, create a new directory inside the `experiments/<method-name>` folder using a descriptive name. For example, if you want to test LoRA with rank 123 using Llama-3.2 3B as the base model, you could name the folder `experiments/lora/llama-3.2-3B-rank123`.
+
+Inside this directory, you will find a default configuration file called `default_training_params.json`, which contains the default parameters used in the `run.py` training script. Create a new JSON file containing all the parameters you want to modify compared to the defaults, and save it as `training_params.json` in the newly created folder. If you are satisfied with all the default training parameters, you can skip this step.
+
+Finally, you need to create a PEFT configuration file for the PEFT method you want to add. This should be a JSON file called `adapter_config.json`, placed in the same directory. Below is an example of how this could look:
+
+```python
+from peft import LoraConfig
+config = LoraConfig(r=123)
+config.save_pretrained("experiments/lora/llama-3.2-3B-rank123/")
+```
+
+Once you've created the configuration files for your experiment, please [create a PR on PEFT](https://github.com/huggingface/peft/pulls). After it is reviewed and merged, we will run it on our hardware to ensure that the results are comparable. Of course, it is best if you run the experiment at least once on your hardware to verify that the proposed settings work well.
+
+#### Considerations When Adding New Experiments
+
+When adding a new experiment, please consider the following points:
+
+1. Avoid changing too many training parameters at once, as this would make it difficult to compare results with existing ones. For example, if all existing results were created with 5000 training steps but your result uses 10000 steps, it would be unclear whether an improvement in the test score is due to the PEFT method itself or simply due to longer training. Similarly, using a completely different base model, especially if it is significantly more capable, does not contribute to a fair comparison.
+2. Avoid suggesting configurations that are very close to existing ones. For example, if there is already an experiment with LoRA and rank 123, do not add an experiment with LoRA and rank 124.
+3. Experiments for less-tested methods are more valuable than additional experiments for widely tested methods.
+4. Do not edit existing experiments, always create new ones.
+5. If you found hyper parameters that work especially well with a given method but are not trivial to find out, consider updating the PEFT documentation of that method so that other users can benefit from your findings.
+
+### Updating the Training Script
+
+We provide a training script that includes features typically useful for improving training outcomes, such as AMP support, a cosine learning rate schedule, etc. However, there is always room for improvement. For example, at the time of writing, the script does not support gradient accumulation. Therefore, PRs that extend the training script are welcome.
+
+#### How to Update the Training Script
+
+Follow the same process as when contributing to PEFT in general (see the [contribution guidelines](https://huggingface.co/docs/peft/developer_guides/contributing)). If the same training script is used across multiple datasets, please ensure that all relevant scripts are updated accordingly.
+
+#### Considerations When Updating the Training Script
+
+1. Updates should be backward-compatible. By default, any new features should be disabled to ensure that existing results remain valid. For example, if you add gradient accumulation, ensure it is disabled by default so that new experiments must opt in.
+2. Before adding a bug fix that could invalidate existing results, consider whether the trade-off is worthwhile. If we already have many experimental results, rerunning all of them can be expensive. If the bug fix is not critical, it may not be worth invalidating previous results. However, if you discover a significant bug that could meaningfully impact outcomes, it should be addressed.
+3. Avoid unnecessary complexity. While we could add support for DeepSpeed, FSDP, etc., doing so would add significant complexity, exclude users with limited hardware, and is unlikely to alter the relative performance of different PEFT methods.
+4. Minimize reliance on specific training frameworks. For example, we deliberately avoid using the `Trainer` class from transformers or PyTorch Lightning. This ensures transparency, making it easier to understand the training process and replicate results over time. If a training framework were used, we would have to pin the version or risk future incompatibilities.
+
+### Adding a New Dataset
+
+Adding a new dataset increases the breadth and usefulness of the PEFT method comparison. The goal is not necessarily to outperform benchmarks or replicate paper results, but to fairly compare different PEFT methods in a way that is useful for PEFT users. If this involves replicating an experiment from a paper, that is great, but it is not a requirement.
+
+#### How to Add a New Dataset
+
+The easiest way to add support for a new dataset is to copy an existing setup, such as `method_comparison/MetaMathQA`, rename it, and modify `data.py`, as well as any other necessary parts of the code. Ideally, as much existing code as possible should be reused. The general folder structure and experiment logging format should remain consistent.
+
+After adding the dataset, ensure it functions correctly and produces meaningful results by running at least one experimental setup, such as using LoRA with default settings.
+
+#### Considerations When Adding a New Dataset
+
+1. Before beginning, it is best to open an [issue on PEFT](https://github.com/huggingface/peft/issues) to share your plans. This allows for early feedback and prevents wasted effort on impractical ideas.
+2. The most valuable new datasets are those that test different capabilities than those already present. Bonus points if the task is similar to what users may face in the real world. Task ideas that would be great to add:
+    - A task involving both language and  image modalities.
+    - An image generation task (like stable diffusion)
+    - A task involving audio (like whisper)
+    - A task that requires knowledge preservation (checked, for instance, via an auxiliary test set)
+    - Learning something completely new (e.g. a new language)
+    - A reinforcement learning task (e.g. using [trl](https://github.com/huggingface/trl))
+3. Training should be reasonably fast. Running dozens of experiments is impractical if each one takes multiple days and incurs high costs. Ideally, training should take a few hours at most on high-end consumer hardware.
+4. The chosen base model should not be too large, to avoid VRAM constraints. Morevoer, if the base model is too powerful, there is little room for improvement through further fine-tuning.
+5. Test scores should be informative and have a broad range:
+   - Besides loss, there should ideally be at least one additional metric, such as accuracy.
+   - Comparisons are not meaningful if all methods score near 0% or near 100%. The dataset should yield a range of scores to facilitate meaningful differentiation between methods.
+6. The dataset should be publicly available and have a track record as a useful dataset. The license should permit the intended usage.
+
+## Result dashboard
+
+For convenience, we included a [Gradio](https://www.gradio.app/) app that shows the results of the experiments. It allows you to filter down the task and base model and show the experiment results for this selection. Give it a try [here](https://huggingface.co/spaces/peft-internal-testing/PEFT-method-comparison).
+
+### Local deployment
+
+This app requires additional packages to be installed, please install the packages listed in `requirements-app.txt`, e.g. via:
+
+```sh
+python -m pip install -r requirements-app.txt
+```
+
+To launch the demo, run:
+
+```sh
+python app.py
+```
diff --git a/method_comparison/__init__.py b/method_comparison/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/method_comparison/app.py b/method_comparison/app.py
new file mode 100644
index 0000000..ec7bbff
--- /dev/null
+++ b/method_comparison/app.py
@@ -0,0 +1,609 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+"""Gradio app to show the results"""
+
+import functools
+import json
+import logging
+import os
+import re
+import tempfile
+from io import BytesIO
+from typing import Any
+
+import gradio as gr
+import plotly.express as px
+import plotly.graph_objects as go
+from datasets import load_dataset
+from huggingface_hub import HfFileSystem
+from PIL import Image
+from processing import (
+    filter_data,
+    get_model_ids,
+    get_metric_preferences,
+    get_task_columns,
+    _get_metric_explanation,
+    _TASK_PARETO_DEFAULTS,
+    compute_pareto_frontier,
+    format_df,
+    load_task_results,
+)
+from sanitizer import parse_and_filter
+
+
+logger = logging.getLogger(__name__)
+
+
+def generate_pareto_plot(df, metric_x, metric_y, metric_preferences):
+    if df.empty:
+        return {}
+
+    # Compute Pareto frontier and non-frontier points.
+    pareto_df = compute_pareto_frontier(df, metric_x, metric_y, metric_preferences)
+    non_pareto_df = df.drop(pareto_df.index)
+
+    # Create an empty figure.
+    fig = go.Figure()
+
+    # Draw the line connecting Pareto frontier points.
+    if not pareto_df.empty:
+        # Sort the Pareto frontier points by metric_x for a meaningful connection.
+        pareto_sorted = pareto_df.sort_values(by=metric_x)
+        line_trace = go.Scatter(
+            x=pareto_sorted[metric_x],
+            y=pareto_sorted[metric_y],
+            mode="lines",
+            line={"color": "rgba(0,0,255,0.3)", "width": 4},
+            name="Pareto Frontier",
+        )
+        fig.add_trace(line_trace)
+
+    # Add non-frontier points in gray with semi-transparency.
+    if not non_pareto_df.empty:
+        non_frontier_trace = go.Scatter(
+            x=non_pareto_df[metric_x],
+            y=non_pareto_df[metric_y],
+            mode="markers",
+            marker={"color": "rgba(128,128,128,0.5)", "size": 12},
+            hoverinfo="text",
+            text=non_pareto_df.apply(
+                lambda row: (
+                    f"experiment_name: {row['experiment_name']}<br>"
+                    f"peft_type: {row['peft_type']}<br>"
+                    f"{metric_x}: {row[metric_x]}<br>"
+                    f"{metric_y}: {row[metric_y]}"
+                ),
+                axis=1,
+            ),
+            showlegend=False,
+        )
+        fig.add_trace(non_frontier_trace)
+
+    # Add Pareto frontier points with legend
+    if not pareto_df.empty:
+        pareto_scatter = px.scatter(
+            pareto_df,
+            x=metric_x,
+            y=metric_y,
+            color="experiment_name",
+            hover_data={"experiment_name": True, "peft_type": True, metric_x: True, metric_y: True},
+        )
+        for trace in pareto_scatter.data:
+            trace.marker = {"size": 12}
+            fig.add_trace(trace)
+
+    # Update layout with axes labels.
+    fig.update_layout(
+        title=f"Pareto Frontier for {metric_x} vs {metric_y}",
+        template="seaborn",
+        height=700,
+        autosize=True,
+        xaxis_title=metric_x,
+        yaxis_title=metric_y,
+    )
+
+    return fig
+
+
+def compute_pareto_summary(filtered, pareto_df, metric_x, metric_y):
+    if filtered.empty:
+        return "No data available."
+
+    stats = filtered[[metric_x, metric_y]].agg(["min", "max", "mean"]).to_string()
+    total_points = len(filtered)
+    pareto_points = len(pareto_df)
+    excluded_points = total_points - pareto_points
+    summary_text = (
+        f"{stats}\n\n"
+        f"Total points: {total_points}\n"
+        f"Pareto frontier points: {pareto_points}\n"
+        f"Excluded points: {excluded_points}"
+    )
+    return summary_text
+
+
+def export_csv(df):
+    if df.empty:
+        return None
+    csv_data = df.to_csv(index=False)
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".csv", mode="w", encoding="utf-8") as tmp:
+        tmp.write(csv_data)
+        tmp_path = tmp.name
+    return tmp_path
+
+
+IMAGE_GEN_TASK = "image-gen"
+SAMPLE_IMAGE_BUCKET = "peft-internal-testing/image-gen-benchmark"
+SAMPLE_IMAGE_BUCKET_DIR = f"hf://buckets/{SAMPLE_IMAGE_BUCKET}/sample-images/results"
+SAMPLE_IMAGE_BUCKET_URL = f"https://huggingface.co/buckets/{SAMPLE_IMAGE_BUCKET}"
+GENERATED_VIEW = "Generated samples"
+DATASET_VIEW = "Training dataset"
+
+
+def _load_default_train_config_image_gen() -> dict[str, Any]:
+    # The default training params define the prompts and dataset used by the benchmark; load them once
+    # to caption generated images and to show the dataset images before an experiment is selected.
+    path = os.path.join(os.path.dirname(__file__), "image-gen", "default_training_params.json")
+    try:
+        with open(path) as f:
+            return json.load(f)
+    except (OSError, ValueError) as exc:
+        logger.warning("Could not load default training params from %r: %s", path, exc)
+        return {}
+
+
+DEFAULT_TRAIN_CONFIG_IMAGE_GEN = _load_default_train_config_image_gen()
+SAMPLE_IMAGE_PROMPTS = DEFAULT_TRAIN_CONFIG_IMAGE_GEN.get("sample_image_prompts", [])
+
+
+@functools.lru_cache(maxsize=1)
+def _get_bucket_fs() -> HfFileSystem:
+    # Anonymous read access to the public bucket. The listing cache is disabled so that newly uploaded sample images
+    # show up on a page refresh without having to redeploy the app.
+    return HfFileSystem(use_listings_cache=False)
+
+
+def get_sample_images(experiment_name: str) -> list[tuple[Image.Image, str]]:
+    """Fetch the sample images of an experiment from the storage bucket.
+
+    Returns a list of (PIL image, caption) tuples suitable for a gr.Gallery, or an empty list if no images are
+    found. Each image is captioned with the prompt that was used to generate it.
+    """
+    stem = experiment_name.replace("/", "--")
+    fs = _get_bucket_fs()
+    try:
+        paths = sorted(fs.glob(f"{SAMPLE_IMAGE_BUCKET_DIR}/{stem}_*.png"))
+    except Exception as exc:
+        logger.warning("Could not list sample images for %r: %s", experiment_name, exc)
+        return []
+
+    gallery = []
+    for path in paths:
+        try:
+            with fs.open(path, "rb") as f:
+                image = Image.open(BytesIO(f.read()))
+                image.load()
+        except Exception as exc:
+            logger.warning("Could not load sample image %r: %s", path, exc)
+            continue
+        match = re.search(r"_(\d+)\.png$", path)
+        prompt_idx = int(match.group(1)) - 1 if match else len(gallery)
+        caption = (
+            SAMPLE_IMAGE_PROMPTS[prompt_idx]
+            if 0 <= prompt_idx < len(SAMPLE_IMAGE_PROMPTS)
+            else os.path.basename(path)
+        )
+        gallery.append((image, caption))
+    return gallery
+
+
+@functools.lru_cache(maxsize=1)
+def _load_dataset_images(dataset_id: str, split: str, image_column: str) -> list[Image.Image]:
+    ds = load_dataset(dataset_id, split=split)
+    images = []
+    for image in ds[image_column]:
+        if not isinstance(image, Image.Image):
+            image = Image.fromarray(image)
+        images.append(image.convert("RGB"))
+    return images
+
+
+def get_dataset_images(config: dict[str, Any]) -> list[tuple[Image.Image, str]]:
+    """Fetch the training dataset images for a training configuration from the Hugging Face Hub."""
+    dataset_id = config.get("dataset_id") if config else None
+    if not dataset_id:
+        return []
+    split = config.get("dataset_split", "train")
+    image_column = config.get("image_column", "image")
+    try:
+        images = _load_dataset_images(dataset_id, split, image_column)
+    except Exception as exc:
+        logger.warning("Could not load dataset images for %r: %s", dataset_id, exc)
+        return []
+
+    prompts = config.get("instance_prompts", [])
+    if isinstance(prompts, str):
+        prompts = [prompts] * len(images)
+    gallery = []
+    for idx, image in enumerate(images):
+        gallery.append((image, prompts[idx]))
+    return gallery
+
+
+def render_image_gallery(image_view, selected):
+    """Return a gallery update with the contents for the selected experiment and image source view.
+
+    The dataset view falls back to the default dataset when no experiment is selected, so its images can be shown before
+    the user clicks a row. When generated samples are shown, the gallery label names the selected experiment.
+    """
+    if image_view == DATASET_VIEW:
+        if selected:
+            try:
+                config = json.loads(selected["train_config"])
+            except (TypeError, ValueError):
+                config = {}
+        else:
+            config = DEFAULT_TRAIN_CONFIG_IMAGE_GEN
+        return gr.update(value=get_dataset_images(config), label="Images")
+    if not selected:
+        return gr.update(value=None, label="Images")
+    return gr.update(
+        value=get_sample_images(selected["experiment_name"]),
+        label=f"Generated samples for {selected['experiment_name']}",
+    )
+
+
+def load_gallery_deferred(task_name, image_view, selected):
+    """Populate the image gallery in a chained event.
+
+    Fetching the images can take a while, so the event handlers that update multiple components only clear the
+    gallery and the images are loaded here in a follow-up event. Otherwise, the other components (e.g. the results
+    table) would not be updated until the images are loaded.
+    """
+    if task_name != IMAGE_GEN_TASK:
+        return gr.update()
+    return render_image_gallery(image_view, selected)
+
+
+def build_app(df):
+    task_names = sorted(df["task_name"].unique())
+    initial_task = "MetaMathQA" if "MetaMathQA" in task_names else task_names[0]
+    initial_prefs = get_metric_preferences(initial_task)
+    initial_x, initial_y = _TASK_PARETO_DEFAULTS.get(initial_task, (list(initial_prefs)[0], list(initial_prefs)[1]))
+
+    with gr.Blocks() as demo:
+        gr.Markdown("# PEFT method comparison")
+        gr.Markdown(
+            "Find more information [on the PEFT GitHub repo](https://github.com/huggingface/peft/tree/main/method_comparison)"
+        )
+
+        # Hidden state to store the current filter query.
+        filter_state = gr.State("")
+        # Hidden state to store the experiment selected for the image gallery.
+        selected_state = gr.State(None)
+
+        gr.Markdown("## Choose the task and base model")
+        with gr.Row():
+            task_dropdown = gr.Dropdown(
+                label="Select Task",
+                choices=task_names,
+                value=initial_task,
+            )
+            model_dropdown = gr.Dropdown(label="Select Model ID", choices=get_model_ids(initial_task, df))
+
+        task_info = gr.Markdown(_get_task_info(initial_task))
+
+        # Make dataframe columns all equal in width so that they are good enough for numbers but don't get hugely
+        # extended by columns like `train_config`. Tasks can have different column counts, so size the widths to the
+        # widest task; experiment_name is always the first column (see _TASK_IMPORTANT_COLUMNS) and holds long names, so
+        # it gets extra width.
+        initial_filtered = filter_data(initial_task, get_model_ids(initial_task, df)[0], df)
+        num_columns = max(len(get_task_columns(task)) for task in task_names)
+        column_widths = ["150px"] * num_columns
+        column_widths[0] = "300px"
+
+        data_table = gr.DataFrame(
+            label="Results",
+            value=format_df(initial_filtered),
+            interactive=False,
+            max_chars=100,
+            wrap=False,
+            column_widths=column_widths,
+        )
+
+        with gr.Row():
+            filter_textbox = gr.Textbox(
+                label="Filter DataFrame",
+                placeholder="Enter filter (e.g.: peft_type=='LORA')",
+                interactive=True,
+            )
+            apply_filter_button = gr.Button("Apply Filter")
+            reset_filter_button = gr.Button("Reset Filter")
+
+        metric_explanation = gr.Markdown(
+            _get_metric_explanation(initial_task),
+        )
+
+        with gr.Group(visible=initial_task == IMAGE_GEN_TASK) as sample_images_group:
+            gr.Markdown("## Images")
+            gr.Markdown(
+                "The training dataset images are shown by default. Click a row in the results table above to see the "
+                "sample images generated by that experiment, and use the selector to switch between the generated "
+                "samples and the training dataset. Each image is captioned with its prompt. The generated images are "
+                f"stored in [this bucket]({SAMPLE_IMAGE_BUCKET_URL})."
+            )
+            image_view_radio = gr.Radio(
+                choices=[GENERATED_VIEW, DATASET_VIEW],
+                value=DATASET_VIEW,
+                label="Image source",
+            )
+            # The gallery starts empty and is populated by load_gallery_deferred on page load so that fetching the
+            # images doesn't block the app startup.
+            sample_gallery = gr.Gallery(
+                label="Images",
+                value=None,
+                columns=3,
+                object_fit="contain",
+            )
+
+        gr.Markdown("## Pareto plot")
+        gr.Markdown(
+            "Select 2 criteria to plot the Pareto frontier. This will show the best PEFT methods along this axis and "
+            "the trade-offs with the other axis. The PEFT methods that Pareto-dominate are shown in colors. All other "
+            "methods are inferior with regard to these two metrics. Hover over a point to show details."
+        )
+
+        with gr.Row():
+            metric_x_dropdown = gr.Dropdown(
+                label="1st metric for Pareto plot",
+                choices=list(initial_prefs.keys()),
+                value=initial_x,
+            )
+            metric_y_dropdown = gr.Dropdown(
+                label="2nd metric for Pareto plot",
+                choices=list(initial_prefs.keys()),
+                value=initial_y,
+            )
+
+        pareto_plot = gr.Plot(label="Pareto Frontier Plot")
+        summary_box = gr.Textbox(label="Summary Statistics", lines=6)
+        csv_output = gr.File(label="Export Filtered Data as CSV")
+
+        def update_on_task(task_name, current_filter):
+            new_models = get_model_ids(task_name, df)
+            filtered = filter_data(task_name, new_models[0] if new_models else "", df)
+            if current_filter.strip():
+                try:
+                    mask = parse_and_filter(filtered, current_filter)
+                    df_queried = filtered[mask]
+                    if not df_queried.empty:
+                        filtered = df_queried
+                except Exception as exc:
+                    # invalid filter query
+                    logger.debug("Ignoring invalid filter query: %s", exc)
+
+            prefs = get_metric_preferences(task_name)
+            x_default, y_default = _TASK_PARETO_DEFAULTS.get(task_name, (list(prefs)[0], list(prefs)[1]))
+            metric_choices = list(prefs.keys())
+            explanation = _get_metric_explanation(task_name)
+
+            is_image_gen = task_name == IMAGE_GEN_TASK
+            return (
+                gr.update(choices=new_models, value=new_models[0] if new_models else None),
+                _get_task_info(task_name),
+                format_df(filtered),
+                gr.update(choices=metric_choices, value=x_default),
+                gr.update(choices=metric_choices, value=y_default),
+                explanation,
+                gr.update(visible=is_image_gen),
+                gr.update(value=DATASET_VIEW),
+                gr.update(value=None, label="Images"),
+                None,
+            )
+
+        task_dropdown.change(
+            fn=update_on_task,
+            inputs=[task_dropdown, filter_state],
+            outputs=[
+                model_dropdown,
+                task_info,
+                data_table,
+                metric_x_dropdown,
+                metric_y_dropdown,
+                metric_explanation,
+                sample_images_group,
+                image_view_radio,
+                sample_gallery,
+                selected_state,
+            ],
+        ).then(
+            fn=load_gallery_deferred,
+            inputs=[task_dropdown, image_view_radio, selected_state],
+            outputs=sample_gallery,
+        )
+
+        def update_on_model(task_name, model_id, current_filter):
+            filtered = filter_data(task_name, model_id, df)
+            if current_filter.strip():
+                try:
+                    mask = parse_and_filter(filtered, current_filter)
+                    filtered = filtered[mask]
+                except Exception as exc:
+                    logger.debug("Ignoring invalid filter query: %s", exc)
+            return format_df(filtered), gr.update(value=DATASET_VIEW), gr.update(value=None, label="Images"), None
+
+        model_dropdown.change(
+            fn=update_on_model,
+            inputs=[task_dropdown, model_dropdown, filter_state],
+            outputs=[data_table, image_view_radio, sample_gallery, selected_state],
+        ).then(
+            fn=load_gallery_deferred,
+            inputs=[task_dropdown, image_view_radio, selected_state],
+            outputs=sample_gallery,
+        )
+
+        def show_sample_images(task_name, model_id, evt: gr.SelectData):
+            if task_name != IMAGE_GEN_TASK or evt.index is None:
+                return None, gr.update(), gr.update()
+            # Look up the clicked row by its experiment name (always the first column) instead of by the row index:
+            # sorting the table happens client-side only, so the row index refers to the displayed order, not the order
+            # of the dataframe on the server.
+            experiment_name = evt.row_value[0]
+            rows = filter_data(task_name, model_id, df)
+            rows = rows[rows["experiment_name"] == experiment_name]
+            if rows.empty:
+                return None, gr.update(), gr.update()
+            row = rows.iloc[0]
+            selected = {"experiment_name": row["experiment_name"], "train_config": row["train_config"]}
+            # Clicking a row switches the view to the experiment's generated samples.
+            return selected, gr.update(value=GENERATED_VIEW), render_image_gallery(GENERATED_VIEW, selected)
+
+        data_table.select(
+            fn=show_sample_images,
+            inputs=[task_dropdown, model_dropdown],
+            outputs=[selected_state, image_view_radio, sample_gallery],
+        )
+
+        def update_image_view(image_view, selected):
+            return render_image_gallery(image_view, selected)
+
+        # Use the input event (user-only) so the programmatic radio updates above don't re-trigger this.
+        image_view_radio.input(
+            fn=update_image_view,
+            inputs=[image_view_radio, selected_state],
+            outputs=sample_gallery,
+        )
+
+        def update_pareto_plot_and_summary(task_name, model_id, metric_x, metric_y, current_filter):
+            prefs = get_metric_preferences(task_name)
+            filtered = filter_data(task_name, model_id, df)
+            if current_filter.strip():
+                try:
+                    mask = parse_and_filter(filtered, current_filter)
+                    filtered = filtered[mask]
+                except Exception as e:
+                    return generate_pareto_plot(filtered, metric_x, metric_y, prefs), f"Filter error: {e}"
+
+            pareto_df = compute_pareto_frontier(filtered, metric_x, metric_y, prefs)
+            fig = generate_pareto_plot(filtered, metric_x, metric_y, prefs)
+            summary = compute_pareto_summary(filtered, pareto_df, metric_x, metric_y)
+            return fig, summary
+
+        for comp in [model_dropdown, metric_x_dropdown, metric_y_dropdown]:
+            comp.change(
+                fn=update_pareto_plot_and_summary,
+                inputs=[task_dropdown, model_dropdown, metric_x_dropdown, metric_y_dropdown, filter_state],
+                outputs=[pareto_plot, summary_box],
+            )
+
+        def apply_filter(filter_query, task_name, model_id, metric_x, metric_y):
+            prefs = get_metric_preferences(task_name)
+            filtered = filter_data(task_name, model_id, df)
+            if filter_query.strip():
+                try:
+                    mask = parse_and_filter(filtered, filter_query)
+                    filtered = filtered[mask]
+                except Exception as e:
+                    # Update the table, plot, and summary even if there is a filter error.
+                    return (
+                        filter_query,
+                        filtered,
+                        generate_pareto_plot(filtered, metric_x, metric_y, prefs),
+                        f"Filter error: {e}",
+                    )
+
+            pareto_df = compute_pareto_frontier(filtered, metric_x, metric_y, prefs)
+            fig = generate_pareto_plot(filtered, metric_x, metric_y, prefs)
+            summary = compute_pareto_summary(filtered, pareto_df, metric_x, metric_y)
+            return filter_query, format_df(filtered), fig, summary
+
+        apply_filter_button.click(
+            fn=apply_filter,
+            inputs=[filter_textbox, task_dropdown, model_dropdown, metric_x_dropdown, metric_y_dropdown],
+            outputs=[filter_state, data_table, pareto_plot, summary_box],
+        )
+
+        def reset_filter(task_name, model_id, metric_x, metric_y):
+            prefs = get_metric_preferences(task_name)
+            filtered = filter_data(task_name, model_id, df)
+            pareto_df = compute_pareto_frontier(filtered, metric_x, metric_y, prefs)
+            fig = generate_pareto_plot(filtered, metric_x, metric_y, prefs)
+            summary = compute_pareto_summary(filtered, pareto_df, metric_x, metric_y)
+            # Return empty strings to clear the filter state and textbox.
+            return "", "", format_df(filtered), fig, summary
+
+        reset_filter_button.click(
+            fn=reset_filter,
+            inputs=[task_dropdown, model_dropdown, metric_x_dropdown, metric_y_dropdown],
+            outputs=[filter_state, filter_textbox, data_table, pareto_plot, summary_box],
+        )
+
+        gr.Markdown("## Export data")
+        # Export button for CSV download.
+        export_button = gr.Button("Export Filtered Data")
+        export_button.click(
+            fn=lambda task, model: export_csv(filter_data(task, model, df)),
+            inputs=[task_dropdown, model_dropdown],
+            outputs=csv_output,
+        )
+
+        demo.load(
+            fn=update_pareto_plot_and_summary,
+            inputs=[task_dropdown, model_dropdown, metric_x_dropdown, metric_y_dropdown, filter_state],
+            outputs=[pareto_plot, summary_box],
+        )
+        demo.load(
+            fn=load_gallery_deferred,
+            inputs=[task_dropdown, image_view_radio, selected_state],
+            outputs=sample_gallery,
+        )
+
+    return demo
+
+
+_TASK_DESCRIPTIONS = {
+    "MetaMathQA": (
+        "Trains on the MetaMathQA dataset and validates/tests on GSM8K, comparing how well PEFT methods teach "
+        "mathematical chain-of-thought reasoning."
+    ),
+    "image-gen": (
+        "DreamBooth-style fine-tuning on a "
+        "[cat plushy dataset](https://huggingface.co/datasets/peft-internal-testing/cat-image-dataset) image dataset."
+    ),
+}
+
+_TASK_CHECKPOINT_URLS = {
+    "MetaMathQA": "https://huggingface.co/buckets/peft-internal-testing/metamathqa-checkpoints",
+    "image-gen": "https://huggingface.co/buckets/peft-internal-testing/image-gen-benchmark/tree/checkpoints",
+}
+
+
+def _get_task_info(task_name):
+    description = _TASK_DESCRIPTIONS.get(task_name, "")
+    url = _TASK_CHECKPOINT_URLS.get(task_name)
+    if url:
+        description = f"{description} The trained PEFT checkpoints are available in [this bucket]({url})."
+    return description
+
+
+base_dir = os.path.dirname(__file__)
+_TASK_CONFIGS = {
+    "MetaMathQA": os.path.join(base_dir, "MetaMathQA", "results"),
+    "image-gen": os.path.join(base_dir, "image-gen", "results"),
+}
+
+df = load_task_results(_TASK_CONFIGS)
+demo = build_app(df)
+demo.launch(theme=gr.themes.Soft())
diff --git a/method_comparison/app_embed.py b/method_comparison/app_embed.py
new file mode 100644
index 0000000..6e67a16
--- /dev/null
+++ b/method_comparison/app_embed.py
@@ -0,0 +1,254 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+"""Gradio app to show the results embedded in the docs for each page.
+
+The difference to `app.py` is that there are way less things displayed
+and method-related data points can be highlighted via GET parameters.
+"""
+
+import os
+
+import gradio as gr
+import plotly.express as px
+import plotly.graph_objects as go
+from processing import (
+    get_model_ids,
+    filter_data,
+    compute_pareto_frontier,
+    _get_metric_explanation,
+    _TASK_PARETO_DEFAULTS,
+    get_metric_preferences,
+    format_df,
+    load_task_results,
+)
+
+
+def generate_pareto_plot(df, metric_x, metric_y, metric_preferences, highlight_type=""):
+    """Generates a pareto frontier plot for the given metrics.
+    If there is no highlight by (PEFT) type is given, the frontier
+    points are individually colored and put into the legend.
+
+    If a highlight by PEFT type is requested, all points are grayed
+    out with the exception of the points matching the PEFT type.
+    No points are added to the legend.
+
+    This is useful when embedding the plot in the docs, first mode
+    is good for general overviews while the second mode is good
+    for highlighting one specific method.
+    """
+    if df.empty:
+        return {}
+
+    # Compute Pareto frontier and non-frontier points.
+    pareto_df = compute_pareto_frontier(df, metric_x, metric_y, metric_preferences)
+    non_pareto_df = df.drop(pareto_df.index)
+
+    # Create an empty figure.
+    fig = go.Figure()
+
+    # Draw the line connecting Pareto frontier points.
+    if not pareto_df.empty:
+        # Sort the Pareto frontier points by metric_x for a meaningful connection.
+        pareto_sorted = pareto_df.sort_values(by=metric_x)
+        line_trace = go.Scatter(
+            x=pareto_sorted[metric_x],
+            y=pareto_sorted[metric_y],
+            mode="lines",
+            line={"color": "rgba(0,0,255,0.1)", "width": 4},
+            name="Pareto Frontier",
+        )
+        fig.add_trace(line_trace)
+
+    hover_data = {"experiment_name": True, "peft_type": True, metric_x: True, metric_y: True}
+
+    # we want to highlight the pareto points and plot a legend in case we
+    # don't highlight a specific method - this is useful when embedding the
+    # benchmark as an overview to highlight the best methods.
+    pareto_highlight_kwargs = {}
+    if not highlight_type:
+        pareto_highlight_kwargs = {"color": "experiment_name"}
+
+    # Add non-frontier points in gray with semi-transparency.
+    if not non_pareto_df.empty:
+        highlight_mask = non_pareto_df["peft_type"].str.lower() == highlight_type
+        no_pareto_df_no_highlight = non_pareto_df[~highlight_mask]
+        no_pareto_df_highlight = non_pareto_df[highlight_mask]
+
+        non_frontier_trace_no_highlight = go.Scatter(
+            x=no_pareto_df_no_highlight[metric_x],
+            y=no_pareto_df_no_highlight[metric_y],
+            mode="markers",
+            marker={"color": "rgba(128,128,128,0.5)", "size": 12},
+            hoverinfo="text",
+            text=no_pareto_df_no_highlight.apply(
+                lambda row: (
+                    f"experiment_name: {row['experiment_name']}<br>"
+                    f"peft_type: {row['peft_type']}<br>"
+                    f"{metric_x}: {row[metric_x]}<br>"
+                    f"{metric_y}: {row[metric_y]}"
+                ),
+                axis=1,
+            ),
+            showlegend=False,
+        )
+        fig.add_trace(non_frontier_trace_no_highlight)
+
+        if not no_pareto_df_highlight.empty:
+            pareto_scatter = px.scatter(
+                no_pareto_df_highlight,
+                x=metric_x,
+                y=metric_y,
+                hover_data=hover_data,
+            )
+            for trace in pareto_scatter.data:
+                trace.marker = {"size": 18, "color": "green"}
+                fig.add_trace(trace)
+
+    # Add Pareto frontier points with legend
+    if not pareto_df.empty:
+        highlight_mask = pareto_sorted["peft_type"].str.lower() == highlight_type
+        pareto_df_no_highlight = pareto_sorted[~highlight_mask]
+        pareto_df_highlight = pareto_sorted[highlight_mask]
+
+        if not pareto_df_no_highlight.empty:
+            pareto_scatter_no_highlight = px.scatter(
+                pareto_df_no_highlight,
+                x=metric_x,
+                y=metric_y,
+                hover_data=hover_data,
+                **pareto_highlight_kwargs,
+            )
+            for trace in pareto_scatter_no_highlight.data:
+                if pareto_highlight_kwargs:
+                    trace.marker = {"size": 12}
+                else:
+                    trace.marker = {"size": 12, "color": "rgba(128,128,128,0.5)"}
+                fig.add_trace(trace)
+
+        if not pareto_df_highlight.empty:
+            pareto_scatter_highlight = px.scatter(
+                pareto_df_highlight,
+                x=metric_x,
+                y=metric_y,
+                hover_data=hover_data,
+                **pareto_highlight_kwargs,
+            )
+            for trace in pareto_scatter_highlight.data:
+                trace.marker = {"size": 18, "color": "green"}
+                fig.add_trace(trace)
+
+    # Update layout with axes labels.
+    fig.update_layout(
+        title=f"{highlight_type} methods compared to Pareto Frontier for {metric_x} vs {metric_y}",
+        template="seaborn",
+        height=700,
+        autosize=True,
+        xaxis_title=metric_x,
+        yaxis_title=metric_y,
+    )
+
+    return fig
+
+
+def build_app(df):
+    task_names = sorted(df["task_name"].unique())
+    initial_task = "MetaMathQA" if "MetaMathQA" in task_names else task_names[0]
+    initial_prefs = get_metric_preferences(initial_task)
+    initial_x, initial_y = _TASK_PARETO_DEFAULTS.get(initial_task, (list(initial_prefs)[0], list(initial_prefs)[1]))
+
+    with gr.Blocks() as demo:
+        pareto_plot = gr.Plot(label="Pareto Frontier Plot")
+
+        with gr.Row():
+            metric_x_dropdown = gr.Dropdown(
+                label="1st metric for Pareto plot",
+                choices=list(initial_prefs.keys()),
+                value=initial_x,
+            )
+            metric_y_dropdown = gr.Dropdown(
+                label="2nd metric for Pareto plot",
+                choices=list(initial_prefs.keys()),
+                value=initial_y,
+            )
+
+        with gr.Row():
+            task_dropdown = gr.Dropdown(
+                label="Select Task",
+                choices=task_names,
+                value=initial_task,
+            )
+            model_dropdown = gr.Dropdown(label="Select Model ID", choices=get_model_ids(initial_task, df))
+
+        # Make dataframe columns all equal in width so that they are good enough for numbers but don't
+        # get hugely extended by columns like `train_config`.
+        initial_filtered = filter_data(initial_task, get_model_ids(initial_task, df)[0], df)
+        column_widths = ["150px" for _ in initial_filtered.columns]
+        column2index = dict(zip(initial_filtered.columns, range(len(initial_filtered.columns))))
+        column_widths[column2index["experiment_name"]] = "300px"
+
+        def update_on_task(task_name):
+            new_models = get_model_ids(task_name, df)
+            filtered = filter_data(task_name, new_models[0] if new_models else "", df)
+
+            prefs = get_metric_preferences(task_name)
+            x_default, y_default = _TASK_PARETO_DEFAULTS.get(task_name, (list(prefs)[0], list(prefs)[1]))
+            metric_choices = list(prefs.keys())
+
+            return (
+                gr.update(choices=new_models, value=new_models[0] if new_models else None),
+                format_df(filtered),
+                gr.update(choices=metric_choices, value=x_default),
+                gr.update(choices=metric_choices, value=y_default),
+            )
+
+        task_dropdown.change(
+            fn=update_on_task,
+            inputs=[task_dropdown],
+            outputs=[model_dropdown, metric_x_dropdown, metric_y_dropdown],
+        )
+
+        def update_pareto_plot(task_name, model_id, metric_x, metric_y, request: gr.Request):
+            highlight_type = request.query_params.get("highlight[type]", "").lower()
+
+            prefs = get_metric_preferences(task_name)
+            filtered = filter_data(task_name, model_id, df)
+            fig = generate_pareto_plot(filtered, metric_x, metric_y, prefs, highlight_type)
+            return fig
+
+        for comp in [model_dropdown, metric_x_dropdown, metric_y_dropdown]:
+            comp.change(
+                fn=update_pareto_plot,
+                inputs=[task_dropdown, model_dropdown, metric_x_dropdown, metric_y_dropdown],
+                outputs=[pareto_plot],
+            )
+
+        demo.load(
+            fn=update_pareto_plot,
+            inputs=[task_dropdown, model_dropdown, metric_x_dropdown, metric_y_dropdown],
+            outputs=[pareto_plot],
+        )
+
+    return demo
+
+
+base_dir = os.path.dirname(__file__)
+_TASK_CONFIGS = {
+    "MetaMathQA": os.path.join(base_dir, "MetaMathQA", "results"),
+    "image-gen": os.path.join(base_dir, "image-gen", "results"),
+}
+
+df = load_task_results(_TASK_CONFIGS)
+demo = build_app(df)
+demo.launch(theme=gr.themes.Soft())
diff --git a/method_comparison/image-gen/Makefile b/method_comparison/image-gen/Makefile
new file mode 100644
index 0000000..340b956
--- /dev/null
+++ b/method_comparison/image-gen/Makefile
@@ -0,0 +1,96 @@
+# Makefile for listing and running the image generation experiments.
+
+# --- Configuration ---
+PYTHON := python
+RUN_SCRIPT := run.py
+EXPERIMENTS_DIR := experiments
+RESULTS_DIR := results
+
+OPTIONAL_FLAGS =
+
+ifdef UPLOAD_BUCKET
+	OPTIONAL_FLAGS += --bucket_name "${UPLOAD_BUCKET_IMAGEGEN}"
+endif
+
+# --- Automatic Experiment and Result Discovery ---
+
+# 1. Find all experiment directories by looking for adapter_config.json files.
+#    This gives us a list like: experiments/lora/llama-3.2-3B-rank32 ...
+EXPERIMENT_PATHS := $(shell find $(EXPERIMENTS_DIR) \
+		    -name "adapter_config.json" -or \
+		    -name "training_params.json" | xargs dirname | sort -u)
+
+# 2. Define a function to replace all occurrences of a character in a string.
+#    This is needed to replicate the result naming logic from run.py (e.g., "lora/foo" -> "lora-foo").
+#    Usage: $(call replace-all, string, char_to_replace, replacement_char)
+replace-all = $(if $(findstring $(2),$(1)),$(call replace-all,$(subst $(2),$(3),$(1)),$(2),$(3)),$(1))
+
+# 3. Define a function to convert an experiment path to its flat result file path.
+#    e.g., "experiments/lora/llama-3.2-3B-rank32" -> "results/lora-llama-3.2-3B-rank32.json"
+exp_to_res = $(RESULTS_DIR)/$(call replace-all,$(patsubst $(EXPERIMENTS_DIR)/%,%,$(1)),/,--).json
+
+# 4. Generate the list of all target result files we want to build.
+RESULT_FILES := $(foreach exp,$(EXPERIMENT_PATHS),$(call exp_to_res,$(exp)))
+
+
+# --- Main Rules ---
+
+# The default 'all' target depends on all possible result files.
+# Running `make` or `make all` will check and run any outdated or missing experiments.
+all: $(RESULT_FILES)
+
+
+# --- Dynamic Rule Generation ---
+
+# This is the core logic. We dynamically generate a specific Makefile rule for each experiment found.
+# This avoids a complex pattern rule and makes the logic clearer.
+define EXPERIMENT_template
+# Input $1: The full experiment path (e.g., experiments/lora/llama-3.2-3B-rank32)
+
+# Define the rule:
+# The target is the result file (e.g., results/lora-llama-3.2-3B-rank32.json).
+# The dependencies are its config files, code changes need to be audited manually since they can
+# vary in degree of importance. Note that we explicitly ignore when the script fails to run
+# so that the other experiments still have a chance to run.
+$(call exp_to_res,$(1)): $(wildcard $(1)/adapter_config.json) $(wildcard $(1)/training_params.json)
+	@echo "---"
+	@echo "Running experiment: $(1)"
+	-$(PYTHON) $(RUN_SCRIPT) $(OPTIONAL_FLAGS) -v $(1)
+	@echo "Finished: $$@"
+	@echo "---"
+
+endef
+
+# This command iterates through every found experiment path and evaluates the template,
+# effectively stamping out a unique, explicit rule for each one.
+$(foreach exp_path,$(EXPERIMENT_PATHS),$(eval $(call EXPERIMENT_template,$(exp_path))))
+
+
+# --- Utility Rules ---
+
+.PHONY: all clean list dump_rules
+
+# The 'clean' rule removes all generated results.
+clean:
+	@echo "Cleaning results directory..."
+	@([ -n "$(wildcard $(RESULTS_DIR)/*.json)" ] && rm $(RESULTS_DIR)/*.json) || exit 0
+
+# The 'list' rule is for debugging. It shows the discovered experiments
+# and the result files the Makefile expects to create for them.
+list:
+	@echo "Discovered experiment configurations:"
+	@$(foreach exp,$(EXPERIMENT_PATHS),echo "  - $(exp)/adapter_config.json";)
+	@echo "\nTarget result files:"
+	@$(foreach res,$(RESULT_FILES),echo "  - $(res)";)
+
+# The 'dump_rules' rule is for debugging. It dumps all dynamically defined rules.
+define newline
+
+
+endef
+define DUMPED_RULES
+	$(foreach exp_path,$(EXPERIMENT_PATHS),$(call EXPERIMENT_template,$(exp_path)))
+endef
+
+dump_rules:
+	@echo -e "$(subst $(newline),\n,${DUMPED_RULES})"
diff --git a/method_comparison/image-gen/README.md b/method_comparison/image-gen/README.md
new file mode 100644
index 0000000..2df7f1c
--- /dev/null
+++ b/method_comparison/image-gen/README.md
@@ -0,0 +1,100 @@
+# PEFT method comparison on a DreamBooth-style image generation task
+
+## Goal
+
+This benchmark mirrors the structure of [`method_comparison/MetaMathQA`](https://github.com/huggingface/peft/tree/main/method_comparison/MetaMathQA) but targets DreamBooth-style fine-tuning for image generation. It is designed to compare PEFT methods along multiple dimensions like:
+
+- objective quality ([`DINOv2`](https://huggingface.co/facebook/dinov2-base) cosine similarity)
+- runtime
+- memory usage
+- checkpoint size
+
+Note that for max memory reserved, this benchmark measures the memory only for the training part, not the evaluation. This is because evaluation requires extra memory (for running the DINO model) which should not be attributed to the corresponding PEFT method.
+
+## Setup choices
+
+- Base model: [`black-forest-labs/FLUX.2-klein-base-4B`](https://huggingface.co/black-forest-labs/FLUX.2-klein-base-4B)
+- Dataset (default): [`cat pillow`](https://huggingface.co/datasets/peft-internal-testing/cat-image-dataset)
+
+## Running
+
+### Experiment settings
+
+Create an experiment under `experiments/<peft-method>/<experiment-name>/` or use one of the experiments there.
+
+Each experiment directory may contain:
+
+- `adapter_config.json` (optional; if missing, full fine-tuning is used)
+- `training_params.json` (optional; overrides `default_training_params.json`)
+
+### Running a single experiment
+
+Run one experiment:
+
+```sh
+python run.py -v experiments/lora/flux2-klein-rank16/
+```
+
+By default, the adapter will be saved in a temporary file for further inspection if needed. To prevent this, add the `--clean` flag to the call. To upload the model checkpoint and sample images to a Hugging Face Hub Bucket, pass the `--bucket_name your_user/my_bucket_name` argument.
+
+### Evaluating an existing checkpoint
+
+To run the evaluation (DINOv2 similarity and drift on the test set, sample images) on an already trained checkpoint without retraining, pass the directory containing the trained PEFT checkpoint to `evaluate.py`:
+
+```sh
+python evaluate.py -v /path/to/checkpoint/
+```
+
+The adapter is loaded on top of the same base model and the evaluation runs under the same conditions (seeds, settings) as at the end of a training run. By default, the training parameters are taken from `default_training_params.json`; if the checkpoint was trained with different parameters, place the corresponding `training_params.json` into the checkpoint directory.
+
+The results and sample images of such an evaluation run are always treated as temporary results, i.e. they are stored in `temporary_results/` and `sample-images/temporary_results/`, respectively. Note that evaluating full fine-tuning checkpoints is not supported.
+
+### Running all pending experiments
+
+The Makefile checks which experiments are missing a corresponding results file and runs those experiments. Note that running a whole sweep can easily take many hours.
+
+```sh
+make
+```
+
+If you set `UPLOAD_BUCKET_IMAGEGEN="your_user/bucket_name"` as an environment variable prior to starting experiments via `make`, all experiments will be called with the `--bucket_name $UPLOAD_BUCKET_IMAGEGEN` parameter and therefore store the checkpoints and sample images in that bucket. _For maintainers_: The default bucket name should be `"peft-internal-testing/image-gen-benchmark"`.
+
+List experiments to run:
+
+```sh
+make list
+```
+
+## Training configs
+
+### `adapter_config.json`
+
+This must be a valid PEFT configuration. It is easiest to create it programmatically, e.g.:
+
+```python
+from peft import LoraConfig
+
+config = LoraConfig(...)
+config.save_pretrained(<path-to-experiment>)
+```
+
+### `training_params.json`
+
+There is a default file for the non-PEFT parameters: `default_training_params.json`. This contains all the other parameters that are relevant for training, e.g. the base model id, number of steps, batch size, learning rate, etc. If parameters that differ from the defaults are needed for a specific experiment, place a `training_params.json` into the experiment directory and adjust the parameters that need changing. The other parameters are taken from the aforementioned default config.
+
+For an overview of all possible arguments, you can also check the `TrainConfig` `dataclass` in `utils.py`.
+
+## Dependencies
+
+Install additional dependencies from:
+
+```sh
+python -m pip install -r requirements.txt
+```
+
+Python 3.12+ is required.
+
+## TODO
+
+- Add further experiments (more PEFT methods) and explore better hyper-parameters.
+- Test images are already created but they're not uploaded anywhere.
diff --git a/method_comparison/image-gen/cancelled_results/.gitkeep b/method_comparison/image-gen/cancelled_results/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/method_comparison/image-gen/data.py b/method_comparison/image-gen/data.py
new file mode 100644
index 0000000..70f2d8e
--- /dev/null
+++ b/method_comparison/image-gen/data.py
@@ -0,0 +1,102 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+"""Data handling for the image generation benchmark."""
+
+import numpy as np
+import torchvision.transforms as T
+from datasets import load_dataset
+from PIL import Image
+from PIL.ImageOps import exif_transpose
+
+
+def _to_rgb(image) -> Image.Image:
+    if isinstance(image, Image.Image):
+        return image.convert("RGB")
+    return Image.fromarray(image).convert("RGB")
+
+
+def _build_train_pixel_values(images: list[Image.Image], resolution: int):
+    size = resolution, resolution  # hard-code square
+    train_augmentations = T.Compose(
+        [
+            T.Resize(size, interpolation=T.InterpolationMode.BILINEAR),
+            T.ToTensor(),
+            T.Normalize([0.5], [0.5]),
+        ]
+    )
+    return [train_augmentations(exif_transpose(image)) for image in images]
+
+
+def get_train_valid_test_datasets(*, train_config, print_fn=print):
+    ds = load_dataset(train_config.dataset_id, split=train_config.dataset_split)
+    image_column = train_config.image_column
+
+    train_size = len(ds) - train_config.valid_size - train_config.test_size
+
+    prompts = train_config.instance_prompts
+    if isinstance(prompts, str):
+        prompts = [prompts] * len(ds)
+    else:
+        if len(ds) != len(prompts):
+            raise ValueError(f"Need 1 instance prompt per sample image, found {len(prompts)} and {len(ds)} instead.")
+
+    train_size = len(ds) - train_config.valid_size - train_config.test_size
+    if train_size < 1:
+        raise ValueError(
+            f"Dataset too small: need at least {1 + train_config.valid_size + train_config.test_size} rows, "
+            f"found {len(ds)}"
+        )
+
+    np.random.seed(0)
+    indices = np.arange(len(ds))
+    np.random.shuffle(indices)
+
+    idx_train = indices[:train_size]
+    idx_valid = indices[train_size : train_size + train_config.valid_size]
+    idx_test = indices[
+        train_size + train_config.valid_size : train_size + train_config.valid_size + train_config.test_size
+    ]
+
+    ds_train = ds.select(idx_train)
+    ds_valid = ds.select(idx_valid)
+    ds_test = ds.select(idx_test)
+
+    train_images = [_to_rgb(img) for img in ds_train[image_column]]
+    valid_images = [_to_rgb(img) for img in ds_valid[image_column]]
+    test_images = [_to_rgb(img) for img in ds_test[image_column]]
+
+    train_prompts = [prompts[i] for i in idx_train]
+    valid_prompts = [prompts[i] for i in idx_valid]
+    test_prompts = [prompts[i] for i in idx_test]
+
+    train_dataset = {
+        "pixel_values": _build_train_pixel_values(train_images, train_config.resolution),
+        "prompts": train_prompts,
+        "repeats": train_config.repeats,
+    }
+    valid_dataset = [
+        {"raw_image": exif_transpose(image), "prompt": prompt} for image, prompt in zip(valid_images, valid_prompts)
+    ]
+    test_dataset = [
+        {"raw_image": exif_transpose(image), "prompt": prompt} for image, prompt in zip(test_images, test_prompts)
+    ]
+
+    print_fn(f"Dataset: {train_config.dataset_id}")
+    print_fn(f"Raw rows: {len(ds)}")
+    print_fn(f"Train rows: {len(train_dataset['prompts']) * train_dataset['repeats']}")
+    print_fn(f"Valid rows: {len(valid_dataset)}")
+    print_fn(f"Test rows: {len(test_dataset)}")
+
+    return train_dataset, valid_dataset, test_dataset
diff --git a/method_comparison/image-gen/default_training_params.json b/method_comparison/image-gen/default_training_params.json
new file mode 100644
index 0000000..c85f5ac
--- /dev/null
+++ b/method_comparison/image-gen/default_training_params.json
@@ -0,0 +1,78 @@
+{
+  "model_id": "black-forest-labs/FLUX.2-klein-base-4B",
+  "dataset_id": "peft-internal-testing/cat-image-dataset",
+  "dataset_split": "train",
+  "dtype": "bfloat16",
+  "resolution": 512,
+  "batch_size": 2,
+  "batch_size_eval": 1,
+  "repeats": 1000,
+  "max_steps": 750,
+  "eval_steps": 100,
+  "compile": false,
+  "use_gc": true,
+  "seed": 0,
+  "grad_norm_clip": 1.0,
+  "optimizer_type": "AdamW",
+  "optimizer_kwargs": {
+    "lr": 0.0001,
+    "weight_decay": 0.0001
+  },
+  "lr_scheduler": null,
+  "use_amp": false,
+  "autocast_adapter_dtype": true,
+  "image_column": "image",
+  "valid_size": 2,
+  "test_size": 4,
+  "num_inference_steps": 20,
+  "guidance_scale": 3.5,
+  "max_sequence_length": 512,
+  "text_encoder_out_layers": [10, 20, 30],
+  "weighting_scheme": "none",
+  "logit_mean": 0.0,
+  "logit_std": 1.0,
+  "mode_scale": 1.29,
+  "dino_model_id": "facebook/dinov2-base",
+  "dino_image_size": 224,
+  "instance_prompts": [
+    "sks cat sitting on a chair in front of a box of chocolates",
+    "sks cat playing on the Steam Deck",
+    "sks cat wearing a necklace while sitting in a box on a sofa",
+    "a box with four donuts in front of sks cat",
+    "sks cat wearing a pink veil with flowers on it and a dagger made out of yellow cardboard",
+    "sks cat between two pillows, with one pillow showing a polar bear and the other a fox",
+    "sks cat with an espresso reading the newspaper",
+    "a close up of a hand petting sks cat on the head",
+    "sks cat opens a white door",
+    "sks cat with a VIP \"all access\" pass",
+    "sks cat in front of a monitor showing the video game \"RimWorld\"",
+    "sks cat reads a newspaper about cannabis",
+    "sks cat reading the newspaper with the title \"DIE BOX\"",
+    "sks cat being fed sushi",
+    "sks cat in front of a box of tomatoes",
+    "a gingerbread house in front of sks cat",
+    "sks cat is wearing a Wednesday Addams costume",
+    "sks cat looks skeptical as he reads a magazine depicting a black cat",
+    "sks cat wearing a striped scarf",
+    "sleepy sks cat lying in bed covered by a blue blanket"
+  ],
+  "sample_image_prompts": [
+    "a photo of sks cat",
+    "a color drawing of sks cat",
+    "sks cat at the beach",
+    "a photo of sks dog",
+    "a photo of an orange cat"
+  ],
+  "drift_image_prompts": [
+    "a photo of cat",
+    "a color drawing of cat",
+    "cat sitting in a bathtub",
+    "cat looks into a mirror",
+    "a photo of cat next to a tree",
+    "the Mona Lisa but she looks angry",
+    "a dog holding a sign that says hello world",
+    "a photo of the Eiffel tower at night",
+    "an astronaut riding a horse",
+    "3d design concept of a chair that looks like an avocado"
+  ]
+}
diff --git a/method_comparison/image-gen/evaluate.py b/method_comparison/image-gen/evaluate.py
new file mode 100644
index 0000000..50a963b
--- /dev/null
+++ b/method_comparison/image-gen/evaluate.py
@@ -0,0 +1,255 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+"""Evaluate an existing checkpoint from the image generation method comparison.
+
+Loads a trained PEFT checkpoint on top of the same base model that was used for training and runs the same evaluation
+as at the end of a training run (test set DINOv2 similarity, drift), then generates the sample images. The results and
+sample images are always stored as temporary results.
+
+Example:
+
+python evaluate.py -v /path/to/checkpoint/
+
+The checkpoint directory must contain the trained PEFT adapter (i.e. an adapter_config.json and the adapter weights).
+This can e.g. be the temporary directory reported by run.py when called without the --clean flag or a checkpoint
+downloaded from the Hugging Face Hub bucket. The training parameters are taken from default_training_params.json; if
+the checkpoint was trained with different parameters, place the corresponding training_params.json into the checkpoint
+directory.
+"""
+
+import argparse
+import datetime as dt
+import os
+import sys
+import time
+from collections.abc import Callable
+
+import torch
+from run import evaluate, generate_sample_images, measure_drift
+from transformers import set_seed
+from utils import (
+    FILE_NAME_TRAIN_PARAMS,
+    RESULT_PATH_TEST,
+    SAMPLE_IMAGE_PATH_TEST,
+    TrainConfig,
+    TrainResult,
+    TrainStatus,
+    get_artifact_stem,
+    get_base_model_info,
+    get_dataset_info,
+    get_dino_encoder,
+    get_file_size,
+    get_pipeline,
+    get_train_config,
+    init_accelerator,
+    log_results,
+)
+
+from data import get_train_valid_test_datasets
+from peft import PeftConfig, PeftModel
+from peft.utils import CONFIG_NAME, infer_device
+
+
+def get_experiment_name(path_checkpoint: str) -> str:
+    if not os.path.isdir(path_checkpoint):
+        raise FileNotFoundError(f"Path {path_checkpoint} does not exist or is not a directory")
+    return os.path.basename(os.path.normpath(path_checkpoint))
+
+
+def evaluate_checkpoint(
+    *,
+    pipeline,
+    train_config: TrainConfig,
+    print_verbose: Callable[..., None],
+) -> TrainResult:
+    metrics = []
+    device_type = infer_device()
+    _, _, test_dataset = get_train_valid_test_datasets(train_config=train_config, print_fn=print_verbose)
+    processor, dino_model = get_dino_encoder(train_config.dino_model_id, train_config.dino_image_size)
+
+    torch_accelerator_module = getattr(torch, device_type, torch.cuda)
+    transformer = pipeline.transformer.to(device_type)
+    transformer.eval()
+
+    if hasattr(transformer, "get_nb_trainable_parameters"):
+        num_trainable_params, num_params = transformer.get_nb_trainable_parameters()
+    else:
+        num_params = sum(param.numel() for param in transformer.parameters())
+        num_trainable_params = sum(param.numel() for param in transformer.parameters() if param.requires_grad)
+    print_verbose(
+        f"trainable params: {num_trainable_params:,d} || all params: {num_params:,d} || "
+        f"trainable: {100 * num_trainable_params / num_params:.4f}%"
+    )
+
+    status = TrainStatus.FAILED
+    error_msg = ""
+    tic_eval_total = time.perf_counter()
+
+    torch_accelerator_module.empty_cache()
+    try:
+        print_verbose("Evaluation on test set follows.")
+        test_similarity = evaluate(
+            pipeline=pipeline,
+            ds_eval=test_dataset,
+            processor=processor,
+            dino_model=dino_model,
+            config=train_config,
+            num_repeats=3,
+        )
+        print_verbose("Calculating drift.")
+        test_drift = measure_drift(pipeline=pipeline, processor=processor, dino_model=dino_model, config=train_config)
+        metrics.append(
+            {
+                "test dino_similarity": test_similarity,
+                "drift": test_drift,
+                "eval time": time.perf_counter() - tic_eval_total,
+            }
+        )
+        print_verbose(f"Test DINOv2 similarity: {test_similarity:.4f}")
+        print_verbose(f"Test drift:             {test_drift:.4f}")
+
+    except KeyboardInterrupt:
+        print_verbose("canceled evaluation")
+        status = TrainStatus.CANCELED
+        error_msg = "manually canceled"
+    except torch.OutOfMemoryError as exc:
+        print_verbose("out of memory error encountered")
+        status = TrainStatus.CANCELED
+        error_msg = str(exc)
+    except Exception as exc:
+        print_verbose(f"encountered an error: {exc}")
+        status = TrainStatus.CANCELED
+        error_msg = str(exc)
+
+    if status != TrainStatus.CANCELED:
+        status = TrainStatus.SUCCESS
+    # the train-related attributes are set to empty/zero values, as no training is performed
+    eval_result = TrainResult(
+        status=status,
+        train_time=0.0,
+        accelerator_memory_reserved_log=[],
+        accelerator_memory_max_train=0,
+        losses=[],
+        metrics=metrics,
+        error_msg=error_msg,
+        num_trainable_params=num_trainable_params,
+        num_total_params=num_params,
+    )
+    return eval_result
+
+
+def main(*, path_checkpoint: str, experiment_name: str) -> None:
+    tic_total = time.perf_counter()
+    start_date = dt.datetime.now(tz=dt.timezone.utc).replace(microsecond=0).isoformat()
+
+    print_verbose("===== The results of this evaluation run are stored as temporary results ======")
+
+    if not os.path.exists(os.path.join(path_checkpoint, CONFIG_NAME)):
+        raise FileNotFoundError(
+            f"Could not find a PEFT config at {path_checkpoint}. Note that evaluating full fine-tuning checkpoints is "
+            "not supported."
+        )
+    peft_config = PeftConfig.from_pretrained(path_checkpoint)
+
+    path_train_config = os.path.join(path_checkpoint, FILE_NAME_TRAIN_PARAMS)
+    if not os.path.exists(path_train_config):
+        print_verbose(
+            f"Could not find {FILE_NAME_TRAIN_PARAMS} in {path_checkpoint}, using the default training parameters"
+        )
+    train_config = get_train_config(path_train_config)
+    init_accelerator()
+    set_seed(train_config.seed)
+
+    model_info = get_base_model_info(train_config.model_id)
+    dataset_info = get_dataset_info(train_config.dataset_id)
+    # create the pipeline with the plain base model first, then load the trained adapter onto it; compilation, if
+    # enabled, must come last, mirroring the order in get_pipeline
+    pipeline = get_pipeline(
+        model_id=train_config.model_id,
+        dtype=train_config.dtype,
+        compile=False,
+        peft_config=None,
+        autocast_adapter_dtype=train_config.autocast_adapter_dtype,
+        use_gc=train_config.use_gc,
+    )
+    pipeline.transformer = PeftModel.from_pretrained(
+        pipeline.transformer,
+        path_checkpoint,
+        is_trainable=True,  # to report the same number of trainable parameters as during training
+        autocast_adapter_dtype=train_config.autocast_adapter_dtype,
+    )
+    if train_config.compile:
+        pipeline.transformer = torch.compile(pipeline.transformer, dynamic=True)
+    print_verbose(pipeline.transformer)
+
+    eval_result = evaluate_checkpoint(
+        pipeline=pipeline,
+        train_config=train_config,
+        print_verbose=print_verbose,
+    )
+
+    file_size = get_file_size(pipeline.transformer, peft_config=peft_config, clean=True, print_fn=print_verbose)
+
+    time_total = time.perf_counter() - tic_total
+    log_results(
+        experiment_name=experiment_name,
+        train_result=eval_result,
+        time_total=time_total,
+        file_size=file_size,
+        model_info=model_info,
+        dataset_info=dataset_info,
+        start_date=start_date,
+        train_config=train_config,
+        peft_config=peft_config,
+        print_fn=print_verbose,
+        save_dir=RESULT_PATH_TEST,  # results of evaluation-only runs are always treated as temporary results
+    )
+
+    if (eval_result.status == TrainStatus.SUCCESS) and train_config.sample_image_prompts:
+        print_verbose("Generating sample images")
+        try:
+            file_stem = get_artifact_stem(experiment_name, start_date, SAMPLE_IMAGE_PATH_TEST)
+            generate_sample_images(
+                pipeline=pipeline,
+                train_config=train_config,
+                sample_image_dir=SAMPLE_IMAGE_PATH_TEST,
+                file_stem=file_stem,
+            )
+            print_verbose(f"Stored sample images in {SAMPLE_IMAGE_PATH_TEST}")
+        except Exception as exc:
+            print_verbose(f"Sample image generation failed: {exc}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-v", "--verbose", action="store_true", help="Enable verbose output")
+    parser.add_argument(
+        "path_checkpoint", type=str, help="Path to the directory containing the trained PEFT checkpoint"
+    )
+    args = parser.parse_args()
+
+    experiment_name = get_experiment_name(args.path_checkpoint)
+
+    if args.verbose:
+
+        def print_verbose(*args, **kwargs) -> None:
+            kwargs["file"] = sys.stderr
+            print(*args, **kwargs)
+    else:
+
+        def print_verbose(*args, **kwargs) -> None:
+            pass
+
+    main(path_checkpoint=args.path_checkpoint, experiment_name=experiment_name)
diff --git a/method_comparison/image-gen/experiments/adalora/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/adalora/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..3b08b63
--- /dev/null
+++ b/method_comparison/image-gen/experiments/adalora/flux2-klein-default/adapter_config.json
@@ -0,0 +1,61 @@
+{
+  "alora_invocation_tokens": null,
+  "alpha_pattern": {},
+  "arrow_config": null,
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "beta1": 0.85,
+  "beta2": 0.85,
+  "bias": "none",
+  "corda_config": null,
+  "deltaT": 1,
+  "ensure_weight_tying": false,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_lora_weights": true,
+  "init_r": 32,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 32,
+  "lora_bias": false,
+  "lora_dropout": 0.0,
+  "lora_ga_config": null,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "orth_reg_weight": 0.5,
+  "peft_type": "ADALORA",
+  "peft_version": "0.18.2.dev0@UNKNOWN",
+  "qalora_group_size": 16,
+  "r": 8,
+  "rank_pattern": null,
+  "revision": null,
+  "target_modules": [
+    "linear_in",
+    "add_q_proj",
+    "add_k_proj",
+    "to_qkv_mlp_proj",
+    "to_add_out",
+    "linear_out",
+    "to_k",
+    "to_out.0",
+    "to_q",
+    "to_v",
+    "add_v_proj"
+  ],
+  "target_parameters": null,
+  "target_r": 8,
+  "task_type": null,
+  "tfinal": 200,
+  "tinit": 100,
+  "total_step": 750,
+  "trainable_token_indices": null,
+  "use_bdlora": null,
+  "use_dora": false,
+  "use_qalora": false,
+  "use_rslora": false
+}
diff --git a/method_comparison/image-gen/experiments/boft/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/boft/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..e2a9875
--- /dev/null
+++ b/method_comparison/image-gen/experiments/boft/flux2-klein-default/adapter_config.json
@@ -0,0 +1,33 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "boft_block_num": 0,
+  "boft_block_size": 4,
+  "boft_dropout": 0.0,
+  "boft_n_butterfly_factor": 2,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "peft_type": "BOFT",
+  "peft_version": "0.18.2.dev0@UNKNOWN",
+  "revision": null,
+  "target_modules": [
+    "linear_in",
+    "add_q_proj",
+    "add_k_proj",
+    "to_qkv_mlp_proj",
+    "to_add_out",
+    "linear_out",
+    "to_k",
+    "to_out.0",
+    "to_q",
+    "to_v",
+    "add_v_proj"
+  ],
+  "task_type": null
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/experiments/c3a/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/c3a/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..7c7e69d
--- /dev/null
+++ b/method_comparison/image-gen/experiments/c3a/flux2-klein-default/adapter_config.json
@@ -0,0 +1,29 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "block_size": 256,
+  "block_size_pattern": {},
+  "inference_mode": false,
+  "init_weights": "xavier_uniform",
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "peft_type": "C3A",
+  "peft_version": "0.18.2.dev0@UNKNOWN",
+  "revision": null,
+  "target_modules": [
+    "to_q",
+    "add_q_proj",
+    "add_k_proj",
+    "add_v_proj",
+    "to_k",
+    "to_v",
+    "to_add_out",
+    "linear_in",
+    "linear_out",
+    "to_qkv_mlp_proj",
+    "to_out.0"
+  ],
+  "task_type": null
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/experiments/c3a/flux2-klein-default/training_params.json b/method_comparison/image-gen/experiments/c3a/flux2-klein-default/training_params.json
new file mode 100644
index 0000000..a39b9dc
--- /dev/null
+++ b/method_comparison/image-gen/experiments/c3a/flux2-klein-default/training_params.json
@@ -0,0 +1,6 @@
+{
+  "optimizer_kwargs": {
+    "lr": 3e-1,
+    "weight_decay": 1e-5
+  }
+}
diff --git a/method_comparison/image-gen/experiments/deft/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/deft/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..6da5c39
--- /dev/null
+++ b/method_comparison/image-gen/experiments/deft/flux2-klein-default/adapter_config.json
@@ -0,0 +1,35 @@
+{
+  "alpha": null,
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "decomposition_method": "qr",
+  "deft_dropout": 0.0,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_scale": 1.0,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "para": false,
+  "peft_type": "DEFT",
+  "peft_version": "0.19.2.dev0@UNKNOWN",
+  "r": 32,
+  "revision": null,
+  "target_modules": [
+    "to_v",
+    "linear_in",
+    "to_qkv_mlp_proj",
+    "to_k",
+    "add_k_proj",
+    "linear_out",
+    "to_q",
+    "add_q_proj",
+    "to_out.0",
+    "add_v_proj",
+    "to_add_out"
+  ],
+  "task_type": null
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/experiments/deft/flux2-klein-para/adapter_config.json b/method_comparison/image-gen/experiments/deft/flux2-klein-para/adapter_config.json
new file mode 100644
index 0000000..a36e9fb
--- /dev/null
+++ b/method_comparison/image-gen/experiments/deft/flux2-klein-para/adapter_config.json
@@ -0,0 +1,35 @@
+{
+  "alpha": null,
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "decomposition_method": "qr",
+  "deft_dropout": 0.0,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_scale": 1.0,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "para": true,
+  "peft_type": "DEFT",
+  "peft_version": "0.19.2.dev0@UNKNOWN",
+  "r": 32,
+  "revision": null,
+  "target_modules": [
+    "to_v",
+    "linear_in",
+    "to_qkv_mlp_proj",
+    "to_k",
+    "add_k_proj",
+    "linear_out",
+    "to_q",
+    "add_q_proj",
+    "to_out.0",
+    "add_v_proj",
+    "to_add_out"
+  ],
+  "task_type": null
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/experiments/delora/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/delora/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..2c09acb
--- /dev/null
+++ b/method_comparison/image-gen/experiments/delora/flux2-klein-default/adapter_config.json
@@ -0,0 +1,34 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "delora_lambda": 15,
+  "exclude_modules": null,
+  "inference_mode": false,
+  "init_weights": true,
+  "lambda_pattern": {},
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "module_dropout": 0.0,
+  "modules_to_save": null,
+  "peft_type": "DELORA",
+  "peft_version": "0.18.2.dev0@UNKNOWN",
+  "r": 32,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "to_out.0",
+    "to_add_out",
+    "to_qkv_mlp_proj",
+    "add_k_proj",
+    "add_q_proj",
+    "add_v_proj",
+    "to_add_out",
+    "to_k",
+    "to_q",
+    "to_v",
+    "linear_in",
+    "linear_out"
+  ],
+  "task_type": null
+}
diff --git a/method_comparison/image-gen/experiments/delora/flux2-klein-default/training_params.json b/method_comparison/image-gen/experiments/delora/flux2-klein-default/training_params.json
new file mode 100644
index 0000000..8a120ad
--- /dev/null
+++ b/method_comparison/image-gen/experiments/delora/flux2-klein-default/training_params.json
@@ -0,0 +1,6 @@
+{
+  "optimizer_kwargs": {
+    "lr": 1e-3
+  }
+}
+
diff --git a/method_comparison/image-gen/experiments/dora/flux2-klein-rank64/adapter_config.json b/method_comparison/image-gen/experiments/dora/flux2-klein-rank64/adapter_config.json
new file mode 100644
index 0000000..595e32f
--- /dev/null
+++ b/method_comparison/image-gen/experiments/dora/flux2-klein-rank64/adapter_config.json
@@ -0,0 +1,30 @@
+{
+    "alpha_pattern": {},
+    "auto_mapping": null,
+    "base_model_name_or_path": "black-forest-labs/FLUX.2-klein-base-4B",
+    "bias": "none",
+    "exclude_modules": null,
+    "fan_in_fan_out": false,
+    "inference_mode": false,
+    "init_lora_weights": true,
+    "layer_replication": null,
+    "layers_pattern": null,
+    "layers_to_transform": null,
+    "loftq_config": {},
+    "lora_alpha": 64,
+    "lora_bias": false,
+    "lora_dropout": 0.0,
+    "megatron_config": null,
+    "megatron_core": "megatron.core",
+    "modules_to_save": null,
+    "peft_type": "LORA",
+    "qalora_group_size": 16,
+    "r": 64,
+    "rank_pattern": {},
+    "revision": null,
+    "target_modules": ["to_out.0","to_add_out","to_qkv_mlp_proj","add_k_proj","add_q_proj","add_v_proj","to_k","to_q","to_v","linear_in","linear_out"],
+    "task_type": null,
+    "use_dora": true,
+    "use_qalora": false,
+    "use_rslora": false
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/experiments/fourierft/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/fourierft/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..b56aa79
--- /dev/null
+++ b/method_comparison/image-gen/experiments/fourierft/flux2-klein-default/adapter_config.json
@@ -0,0 +1,33 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_weights": false,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "n_frequency": 2000,
+  "n_frequency_pattern": {},
+  "peft_type": "FOURIERFT",
+  "peft_version": "0.18.2.dev0@UNKNOWN",
+  "random_loc_seed": 777,
+  "revision": null,
+  "scaling": 150.0,
+  "target_modules": [
+    "to_v",
+    "add_v_proj",
+    "to_qkv_mlp_proj",
+    "linear_out",
+    "to_k",
+    "to_add_out",
+    "add_q_proj",
+    "linear_in",
+    "add_k_proj",
+    "to_q",
+    "to_out.0"
+  ],
+  "task_type": null
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/experiments/frod/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/frod/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..3de07ac
--- /dev/null
+++ b/method_comparison/image-gen/experiments/frod/flux2-klein-default/adapter_config.json
@@ -0,0 +1,33 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "fan_in_fan_out": false,
+  "frod_dropout": 0.0,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "peft_type": "FROD",
+  "projection_prng_key": 0,
+  "regularization_alpha": 0.001,
+  "revision": null,
+  "runtime_offload_base_weight": true,
+  "save_projection": true,
+  "sparse_rate": 0.01,
+  "target_modules": [
+    "to_v",
+    "add_v_proj",
+    "to_qkv_mlp_proj",
+    "linear_out",
+    "to_k",
+    "to_add_out",
+    "add_q_proj",
+    "linear_in",
+    "add_k_proj",
+    "to_q",
+    "to_out.0"
+  ],
+  "task_type": null
+}
diff --git a/method_comparison/image-gen/experiments/frod/flux2-klein-default/training_params.json b/method_comparison/image-gen/experiments/frod/flux2-klein-default/training_params.json
new file mode 100644
index 0000000..663d43e
--- /dev/null
+++ b/method_comparison/image-gen/experiments/frod/flux2-klein-default/training_params.json
@@ -0,0 +1,5 @@
+{
+  "optimizer_kwargs": {
+    "lr": 0.001
+  }
+}
diff --git a/method_comparison/image-gen/experiments/full-finetuning/flux2-klein-default/training_params.json b/method_comparison/image-gen/experiments/full-finetuning/flux2-klein-default/training_params.json
new file mode 100644
index 0000000..eb78c48
--- /dev/null
+++ b/method_comparison/image-gen/experiments/full-finetuning/flux2-klein-default/training_params.json
@@ -0,0 +1,8 @@
+{
+  "max_steps": 300,
+  "eval_steps": 100,
+  "optimizer_kwargs": {
+    "lr": 0.00005,
+    "weight_decay": 0.01
+  }
+}
diff --git a/method_comparison/image-gen/experiments/glora/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/glora/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..c4eaf6a
--- /dev/null
+++ b/method_comparison/image-gen/experiments/glora/flux2-klein-default/adapter_config.json
@@ -0,0 +1,28 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "config_A_B": "lora",
+  "config_C": "lora",
+  "config_D_E": "constant",
+  "inference_mode": false,
+  "init_weights": true,
+  "modules_to_save": null,
+  "peft_type": "GLORA",
+  "r": 32,
+  "target_modules": [
+    "to_out.0",
+    "to_add_out",
+    "to_qkv_mlp_proj",
+    "add_k_proj",
+    "add_q_proj",
+    "add_v_proj",
+    "to_add_out",
+    "to_k",
+    "to_q",
+    "to_v",
+    "linear_in",
+    "linear_out"
+  ],
+  "task_type": null
+}
diff --git a/method_comparison/image-gen/experiments/gralora/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/gralora/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..c7e46d5
--- /dev/null
+++ b/method_comparison/image-gen/experiments/gralora/flux2-klein-default/adapter_config.json
@@ -0,0 +1,34 @@
+{
+  "alpha": 32,
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "fan_in_fan_out": false,
+  "gralora_dropout": 0.0,
+  "gralora_k": 2,
+  "hybrid_r": 0,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "peft_type": "GRALORA",
+  "peft_version": "0.18.2.dev0@UNKNOWN",
+  "r": 32,
+  "revision": null,
+  "target_modules": [
+    "to_out.0",
+    "to_add_out",
+    "to_qkv_mlp_proj",
+    "add_k_proj",
+    "add_q_proj",
+    "add_v_proj",
+    "to_add_out",
+    "to_k",
+    "to_q",
+    "to_v",
+    "linear_in",
+    "linear_out"
+  ],
+  "task_type": null
+}
diff --git a/method_comparison/image-gen/experiments/hra/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/hra/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..03f42e0
--- /dev/null
+++ b/method_comparison/image-gen/experiments/hra/flux2-klein-default/adapter_config.json
@@ -0,0 +1,31 @@
+{
+  "apply_GS": false,
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "exclude_modules": null,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "peft_type": "HRA",
+  "peft_version": "0.18.2.dev0@UNKNOWN",
+  "r": 32,
+  "revision": null,
+  "target_modules": [
+    "to_out.0",
+    "to_add_out",
+    "to_qkv_mlp_proj",
+    "add_k_proj",
+    "add_q_proj",
+    "add_v_proj",
+    "to_add_out",
+    "to_k",
+    "to_q",
+    "to_v",
+    "linear_in",
+    "linear_out"
+  ],
+  "task_type": null
+}
diff --git a/method_comparison/image-gen/experiments/ia3/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/ia3/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..39b09f0
--- /dev/null
+++ b/method_comparison/image-gen/experiments/ia3/flux2-klein-default/adapter_config.json
@@ -0,0 +1,39 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "feedforward_modules": [
+    "to_v",
+    "add_v_proj",
+    "to_qkv_mlp_proj",
+    "linear_out",
+    "to_k",
+    "to_add_out",
+    "add_q_proj",
+    "linear_in",
+    "add_k_proj",
+    "to_q",
+    "to_out.0"
+  ],
+  "inference_mode": false,
+  "init_ia3_weights": true,
+  "modules_to_save": null,
+  "peft_type": "IA3",
+  "peft_version": "0.18.2.dev0@UNKNOWN",
+  "revision": null,
+  "target_modules": [
+    "to_v",
+    "add_v_proj",
+    "to_qkv_mlp_proj",
+    "linear_out",
+    "to_k",
+    "to_add_out",
+    "add_q_proj",
+    "linear_in",
+    "add_k_proj",
+    "to_q",
+    "to_out.0"
+  ],
+  "task_type": null
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/experiments/ia3/flux2-klein-default/training_params.json b/method_comparison/image-gen/experiments/ia3/flux2-klein-default/training_params.json
new file mode 100644
index 0000000..8a120ad
--- /dev/null
+++ b/method_comparison/image-gen/experiments/ia3/flux2-klein-default/training_params.json
@@ -0,0 +1,6 @@
+{
+  "optimizer_kwargs": {
+    "lr": 1e-3
+  }
+}
+
diff --git a/method_comparison/image-gen/experiments/lily/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/lily/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..f970e30
--- /dev/null
+++ b/method_comparison/image-gen/experiments/lily/flux2-klein-default/adapter_config.json
@@ -0,0 +1,31 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "exclude_modules": null,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "num_B": 2,
+  "peft_type": "LILY",
+  "peft_version": "0.18.2.dev0@UNKNOWN",
+  "r": 32,
+  "revision": null,
+  "scaling": 1.0,
+  "stride_A": 1,
+  "target_modules": [
+    "to_v",
+    "add_v_proj",
+    "to_qkv_mlp_proj",
+    "linear_out",
+    "to_k",
+    "to_add_out",
+    "add_q_proj",
+    "linear_in",
+    "add_k_proj",
+    "to_q",
+    "to_out.0"
+  ],
+  "task_type": null
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/experiments/ln_tuning/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/ln_tuning/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..901d53c
--- /dev/null
+++ b/method_comparison/image-gen/experiments/ln_tuning/flux2-klein-default/adapter_config.json
@@ -0,0 +1,15 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "exclude_modules": null,
+  "inference_mode": false,
+  "modules_to_save": null,
+  "peft_type": "LN_TUNING",
+  "peft_version": "0.18.2.dev0@UNKNOWN",
+  "revision": null,
+  "target_modules": [
+      "norm_q",
+      "norm_k"
+  ],
+  "task_type": null
+}
diff --git a/method_comparison/image-gen/experiments/loha/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/loha/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..84c9e1d
--- /dev/null
+++ b/method_comparison/image-gen/experiments/loha/flux2-klein-default/adapter_config.json
@@ -0,0 +1,34 @@
+{
+  "alpha": 32,
+  "alpha_pattern": {},
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "exclude_modules": null,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "module_dropout": 0.0,
+  "modules_to_save": null,
+  "peft_type": "LOHA",
+  "peft_version": "0.18.2.dev0@UNKNOWN",
+  "r": 32,
+  "rank_dropout": 0.0,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "to_qkv_mlp_proj",
+    "to_add_out",
+    "to_out.0",
+    "linear_out",
+    "add_k_proj",
+    "to_v",
+    "add_q_proj",
+    "add_v_proj",
+    "to_k",
+    "to_q",
+    "linear_in"
+  ],
+  "task_type": null,
+  "use_effective_conv2d": false
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/experiments/lokr/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/lokr/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..f52a54c
--- /dev/null
+++ b/method_comparison/image-gen/experiments/lokr/flux2-klein-default/adapter_config.json
@@ -0,0 +1,37 @@
+{
+  "alpha": 32,
+  "alpha_pattern": {},
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "decompose_both": false,
+  "decompose_factor": -1,
+  "exclude_modules": null,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "module_dropout": 0.0,
+  "modules_to_save": null,
+  "peft_type": "LOKR",
+  "peft_version": "0.18.2.dev0@UNKNOWN",
+  "r": 32,
+  "rank_dropout": 0.0,
+  "rank_dropout_scale": false,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "to_qkv_mlp_proj",
+    "to_add_out",
+    "to_out.0",
+    "linear_out",
+    "add_k_proj",
+    "to_v",
+    "add_q_proj",
+    "add_v_proj",
+    "to_k",
+    "to_q",
+    "linear_in"
+  ],
+  "task_type": null,
+  "use_effective_conv2d": false
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/experiments/lora/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/lora/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..fd5daff
--- /dev/null
+++ b/method_comparison/image-gen/experiments/lora/flux2-klein-default/adapter_config.json
@@ -0,0 +1,43 @@
+{
+  "alpha_pattern": {},
+  "auto_mapping": null,
+  "base_model_name_or_path": "black-forest-labs/FLUX.2-klein-base-4B",
+  "bias": "none",
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 32,
+  "lora_bias": false,
+  "lora_dropout": 0.0,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "peft_type": "LORA",
+  "qalora_group_size": 16,
+  "r": 32,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "to_out.0",
+    "to_add_out",
+    "to_qkv_mlp_proj",
+    "add_k_proj",
+    "add_q_proj",
+    "add_v_proj",
+    "to_add_out",
+    "to_k",
+    "to_q",
+    "to_v",
+    "linear_in",
+    "linear_out"
+  ],
+  "task_type": null,
+  "use_dora": false,
+  "use_qalora": false,
+  "use_rslora": false
+}
diff --git a/method_comparison/image-gen/experiments/lora/flux2-klein-rank64/adapter_config.json b/method_comparison/image-gen/experiments/lora/flux2-klein-rank64/adapter_config.json
new file mode 100644
index 0000000..0689821
--- /dev/null
+++ b/method_comparison/image-gen/experiments/lora/flux2-klein-rank64/adapter_config.json
@@ -0,0 +1,30 @@
+{
+    "alpha_pattern": {},
+    "auto_mapping": null,
+    "base_model_name_or_path": "black-forest-labs/FLUX.2-klein-base-4B",
+    "bias": "none",
+    "exclude_modules": null,
+    "fan_in_fan_out": false,
+    "inference_mode": false,
+    "init_lora_weights": true,
+    "layer_replication": null,
+    "layers_pattern": null,
+    "layers_to_transform": null,
+    "loftq_config": {},
+    "lora_alpha": 64,
+    "lora_bias": false,
+    "lora_dropout": 0.0,
+    "megatron_config": null,
+    "megatron_core": "megatron.core",
+    "modules_to_save": null,
+    "peft_type": "LORA",
+    "qalora_group_size": 16,
+    "r": 64,
+    "rank_pattern": {},
+    "revision": null,
+    "target_modules": ["to_out.0","to_add_out","to_qkv_mlp_proj","add_k_proj","add_q_proj","add_v_proj","to_k","to_q","to_v","linear_in","linear_out"],
+    "task_type": null,
+    "use_dora": false,
+    "use_qalora": false,
+    "use_rslora": false
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/experiments/miss/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/miss/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..5018d99
--- /dev/null
+++ b/method_comparison/image-gen/experiments/miss/flux2-klein-default/adapter_config.json
@@ -0,0 +1,31 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "exclude_modules": null,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "mini_r": 1,
+  "miss_dropout": 0.0,
+  "modules_to_save": null,
+  "peft_type": "MISS",
+  "peft_version": "0.18.2.dev0@UNKNOWN",
+  "r": 32,
+  "revision": null,
+  "target_modules": [
+    "to_q",
+    "add_q_proj",
+    "add_k_proj",
+    "add_v_proj",
+    "to_k",
+    "to_v",
+    "to_add_out",
+    "linear_in",
+    "linear_out",
+    "to_qkv_mlp_proj",
+    "to_out.0"
+  ],
+  "task_type": null
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/experiments/oft/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/oft/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..320987b
--- /dev/null
+++ b/method_comparison/image-gen/experiments/oft/flux2-klein-default/adapter_config.json
@@ -0,0 +1,38 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "block_share": false,
+  "coft": false,
+  "eps": 6e-05,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "module_dropout": 0.0,
+  "modules_to_save": null,
+  "num_cayley_neumann_terms": 5,
+  "oft_block_size": 32,
+  "peft_type": "OFT",
+  "peft_version": "0.18.2.dev0@UNKNOWN",
+  "r": 0,
+  "revision": null,
+  "target_modules": [
+    "to_out.0",
+    "to_add_out",
+    "to_qkv_mlp_proj",
+    "add_k_proj",
+    "add_q_proj",
+    "add_v_proj",
+    "to_add_out",
+    "to_k",
+    "to_q",
+    "to_v",
+    "linear_in",
+    "linear_out"
+  ],
+  "task_type": null,
+  "use_cayley_neumann": true
+}
diff --git a/method_comparison/image-gen/experiments/osf/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/osf/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..f1ed132
--- /dev/null
+++ b/method_comparison/image-gen/experiments/osf/flux2-klein-default/adapter_config.json
@@ -0,0 +1,27 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "effective_rank": 32,
+  "inference_mode": false,
+  "init_weights": null,
+  "modules_to_save": null,
+  "peft_type": "OSF",
+  "peft_version": "0.18.2.dev0@UNKNOWN",
+  "rank_pattern": null,
+  "revision": null,
+  "target_modules": [
+    "to_out.0",
+    "to_add_out",
+    "to_qkv_mlp_proj",
+    "add_k_proj",
+    "add_q_proj",
+    "add_v_proj",
+    "to_k",
+    "to_q",
+    "to_v",
+    "linear_in",
+    "linear_out"
+  ],
+  "target_svd_config": null,
+  "task_type": null
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/experiments/peanut/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/peanut/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..f1a0806
--- /dev/null
+++ b/method_comparison/image-gen/experiments/peanut/flux2-klein-default/adapter_config.json
@@ -0,0 +1,31 @@
+{
+  "act_fn": "relu",
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "depth": 0,
+  "exclude_modules": null,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "peft_type": "PEANUT",
+  "peft_version": "0.18.2.dev0@UNKNOWN",
+  "r": 32,
+  "revision": null,
+  "scaling": 1.0,
+  "target_modules": [
+    "to_v",
+    "add_v_proj",
+    "to_qkv_mlp_proj",
+    "linear_out",
+    "to_k",
+    "to_add_out",
+    "add_q_proj",
+    "linear_in",
+    "add_k_proj",
+    "to_q",
+    "to_out.0"
+  ],
+  "task_type": null
+}
diff --git a/method_comparison/image-gen/experiments/psoft/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/psoft/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..a446956
--- /dev/null
+++ b/method_comparison/image-gen/experiments/psoft/flux2-klein-default/adapter_config.json
@@ -0,0 +1,40 @@
+{
+  "ab_svd_init": "psoft_init",
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "cayley_neumann_eps": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "num_cayley_neumann_terms": 5,
+  "peft_type": "PSOFT",
+  "peft_version": "0.18.2.dev0@UNKNOWN",
+  "psoft_alpha": 32,
+  "psoft_dropout": 0.0,
+  "psoft_mag_a": true,
+  "psoft_mag_b": true,
+  "psoft_orth": true,
+  "psoft_svd": "full",
+  "psoft_svd_lowrank_niter": 10,
+  "r": 32,
+  "revision": null,
+  "target_modules": [
+    "to_q",
+    "add_q_proj",
+    "add_k_proj",
+    "add_v_proj",
+    "to_k",
+    "to_v",
+    "to_add_out",
+    "linear_in",
+    "linear_out",
+    "to_qkv_mlp_proj",
+    "to_out.0"
+  ],
+  "task_type": null,
+  "use_cayley_neumann": false
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/experiments/pvera/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/pvera/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..dda2513
--- /dev/null
+++ b/method_comparison/image-gen/experiments/pvera/flux2-klein-default/adapter_config.json
@@ -0,0 +1,34 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "d_initial": 0.1,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "peft_type": "PVERA",
+  "peft_version": "0.18.2.dev0@UNKNOWN",
+  "projection_prng_key": 0,
+  "pvera_dropout": 0.0,
+  "r": 32,
+  "revision": null,
+  "sample_at_inference": false,
+  "save_projection": true,
+  "target_modules": [
+    "to_q",
+    "add_q_proj",
+    "add_k_proj",
+    "add_v_proj",
+    "to_k",
+    "to_v",
+    "to_add_out",
+    "linear_in",
+    "linear_out",
+    "to_qkv_mlp_proj",
+    "to_out.0"
+  ],
+  "task_type": null
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/experiments/pvera/flux2-klein-default/training_params.json b/method_comparison/image-gen/experiments/pvera/flux2-klein-default/training_params.json
new file mode 100644
index 0000000..8bed6db
--- /dev/null
+++ b/method_comparison/image-gen/experiments/pvera/flux2-klein-default/training_params.json
@@ -0,0 +1,6 @@
+{
+  "optimizer_kwargs": {
+    "lr": 3e-3
+  }
+}
+
diff --git a/method_comparison/image-gen/experiments/randlora/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/randlora/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..22eb300
--- /dev/null
+++ b/method_comparison/image-gen/experiments/randlora/flux2-klein-default/adapter_config.json
@@ -0,0 +1,35 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "peft_type": "RANDLORA",
+  "peft_version": null,
+  "projection_prng_key": 0,
+  "r": 32,
+  "randlora_alpha": 640,
+  "randlora_dropout": 0.0,
+  "revision": null,
+  "save_projection": true,
+  "sparse": false,
+  "target_modules": [
+    "to_v",
+    "add_v_proj",
+    "to_qkv_mlp_proj",
+    "linear_out",
+    "to_k",
+    "to_add_out",
+    "add_q_proj",
+    "linear_in",
+    "add_k_proj",
+    "to_q",
+    "to_out.0"
+  ],
+  "task_type": null,
+  "very_sparse": false
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/experiments/road/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/road/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..576b9ed
--- /dev/null
+++ b/method_comparison/image-gen/experiments/road/flux2-klein-default/adapter_config.json
@@ -0,0 +1,26 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "group_size": 64,
+  "inference_mode": false,
+  "init_weights": true,
+  "modules_to_save": null,
+  "peft_type": "ROAD",
+  "peft_version": "0.18.2.dev0@UNKNOWN",
+  "revision": null,
+  "target_modules": [
+    "linear_out",
+    "to_qkv_mlp_proj",
+    "to_k",
+    "add_k_proj",
+    "add_v_proj",
+    "to_v",
+    "add_q_proj",
+    "to_out.0",
+    "to_add_out",
+    "linear_in",
+    "to_q"
+  ],
+  "task_type": null,
+  "variant": "road_1"
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/experiments/road/flux2-klein-default/training_params.json b/method_comparison/image-gen/experiments/road/flux2-klein-default/training_params.json
new file mode 100644
index 0000000..52d87e3
--- /dev/null
+++ b/method_comparison/image-gen/experiments/road/flux2-klein-default/training_params.json
@@ -0,0 +1,5 @@
+{
+  "optimizer_kwargs": {
+    "lr": 1e-3
+  }
+}
diff --git a/method_comparison/image-gen/experiments/shira/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/shira/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..cf60935
--- /dev/null
+++ b/method_comparison/image-gen/experiments/shira/flux2-klein-default/adapter_config.json
@@ -0,0 +1,28 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_weights": true,
+  "mask_type": "random",
+  "modules_to_save": null,
+  "peft_type": "SHIRA",
+  "peft_version": "0.18.2.dev0@UNKNOWN",
+  "r": 32,
+  "random_seed": null,
+  "revision": null,
+  "target_modules": [
+    "to_q",
+    "add_q_proj",
+    "add_k_proj",
+    "add_v_proj",
+    "to_k",
+    "to_v",
+    "to_add_out",
+    "linear_in",
+    "linear_out",
+    "to_qkv_mlp_proj",
+    "to_out.0"
+  ],
+  "task_type": null
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/experiments/vblora/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/vblora/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..2a70ecb
--- /dev/null
+++ b/method_comparison/image-gen/experiments/vblora/flux2-klein-default/adapter_config.json
@@ -0,0 +1,36 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_logits_std": 0.1,
+  "init_vector_bank_bound": 0.02,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "num_vectors": 256,
+  "peft_type": "VBLORA",
+  "peft_version": "0.18.2.dev0@UNKNOWN",
+  "r": 32,
+  "revision": null,
+  "save_only_topk_weights": false,
+  "target_modules": [
+    "to_v",
+    "add_v_proj",
+    "to_qkv_mlp_proj",
+    "linear_out",
+    "to_k",
+    "to_add_out",
+    "add_q_proj",
+    "linear_in",
+    "add_k_proj",
+    "to_q",
+    "to_out.0"
+  ],
+  "task_type": null,
+  "topk": 2,
+  "vblora_dropout": 0.0,
+  "vector_length": 256
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/experiments/vera/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/vera/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..928905d
--- /dev/null
+++ b/method_comparison/image-gen/experiments/vera/flux2-klein-default/adapter_config.json
@@ -0,0 +1,33 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "d_initial": 0.1,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "peft_type": "VERA",
+  "peft_version": "0.18.2.dev0@UNKNOWN",
+  "projection_prng_key": 0,
+  "r": 32,
+  "revision": null,
+  "save_projection": true,
+  "target_modules": [
+    "to_v",
+    "add_v_proj",
+    "to_qkv_mlp_proj",
+    "linear_out",
+    "to_k",
+    "to_add_out",
+    "add_q_proj",
+    "linear_in",
+    "add_k_proj",
+    "to_q",
+    "to_out.0"
+  ],
+  "task_type": null,
+  "vera_dropout": 0.0
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/experiments/vera/flux2-klein-default/training_params.json b/method_comparison/image-gen/experiments/vera/flux2-klein-default/training_params.json
new file mode 100644
index 0000000..8a120ad
--- /dev/null
+++ b/method_comparison/image-gen/experiments/vera/flux2-klein-default/training_params.json
@@ -0,0 +1,6 @@
+{
+  "optimizer_kwargs": {
+    "lr": 1e-3
+  }
+}
+
diff --git a/method_comparison/image-gen/experiments/waveft/flux2-klein-default/adapter_config.json b/method_comparison/image-gen/experiments/waveft/flux2-klein-default/adapter_config.json
new file mode 100644
index 0000000..34600fe
--- /dev/null
+++ b/method_comparison/image-gen/experiments/waveft/flux2-klein-default/adapter_config.json
@@ -0,0 +1,37 @@
+{
+  "auto_mapping": null,
+  "base_model_name_or_path": null,
+  "bias": "none",
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": false,
+  "init_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "modules_to_save": null,
+  "n_frequency": 2592,
+  "n_frequency_pattern": {},
+  "peft_type": "WAVEFT",
+  "peft_version": "0.18.2.dev0@UNKNOWN",
+  "proportional_parameters": false,
+  "random_loc_seed": 777,
+  "revision": null,
+  "scaling": 25.0,
+  "target_modules": [
+    "to_out.0",
+    "to_add_out",
+    "to_qkv_mlp_proj",
+    "add_k_proj",
+    "add_q_proj",
+    "add_v_proj",
+    "to_add_out",
+    "to_k",
+    "to_q",
+    "to_v",
+    "linear_in",
+    "linear_out"
+  ],
+  "task_type": null,
+  "use_idwt": true,
+  "wavelet_family": "db1"
+}
diff --git a/method_comparison/image-gen/requirements.txt b/method_comparison/image-gen/requirements.txt
new file mode 100644
index 0000000..f0809c7
--- /dev/null
+++ b/method_comparison/image-gen/requirements.txt
@@ -0,0 +1,6 @@
+datasets
+diffusers>=0.37.0
+torchvision
+numpy
+tqdm
+pillow
diff --git a/method_comparison/image-gen/results/.gitkeep b/method_comparison/image-gen/results/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/method_comparison/image-gen/results/adalora--flux2-klein-default.json b/method_comparison/image-gen/results/adalora--flux2-klein-default.json
new file mode 100644
index 0000000..78791bb
--- /dev/null
+++ b/method_comparison/image-gen/results/adalora--flux2-klein-default.json
@@ -0,0 +1,3002 @@
+{
+  "run_info": {
+    "created_at": "2026-06-09T10:01:51+00:00",
+    "total_time": 826.7545559249997,
+    "experiment_name": "adalora/flux2-klein-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "black-forest-labs/FLUX.2-klein-base-4B",
+      "dataset_id": "peft-internal-testing/cat-image-dataset",
+      "dataset_split": "train",
+      "dtype": "bfloat16",
+      "resolution": 512,
+      "batch_size": 2,
+      "batch_size_eval": 1,
+      "repeats": 1000,
+      "max_steps": 750,
+      "eval_steps": 100,
+      "compile": false,
+      "use_gc": true,
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.0001
+      },
+      "lr_scheduler": null,
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "instance_prompts": [
+        "sks cat sitting on a chair in front of a box of chocolates",
+        "sks cat playing on the Steam Deck",
+        "sks cat wearing a necklace while sitting in a box on a sofa",
+        "a box with four donuts in front of sks cat",
+        "sks cat wearing a pink veil with flowers on it and a dagger made out of yellow cardboard",
+        "sks cat between two pillows, with one pillow showing a polar bear and the other a fox",
+        "sks cat with an espresso reading the newspaper",
+        "a close up of a hand petting sks cat on the head",
+        "sks cat opens a white door",
+        "sks cat with a VIP \"all access\" pass",
+        "sks cat in front of a monitor showing the video game \"RimWorld\"",
+        "sks cat reads a newspaper about cannabis",
+        "sks cat reading the newspaper with the title \"DIE BOX\"",
+        "sks cat being fed sushi",
+        "sks cat in front of a box of tomatoes",
+        "a gingerbread house in front of sks cat",
+        "sks cat is wearing a Wednesday Addams costume",
+        "sks cat looks skeptical as he reads a magazine depicting a black cat",
+        "sks cat wearing a striped scarf",
+        "sleepy sks cat lying in bed covered by a blue blanket"
+      ],
+      "image_column": "image",
+      "valid_size": 2,
+      "test_size": 4,
+      "num_inference_steps": 20,
+      "guidance_scale": 3.5,
+      "max_sequence_length": 512,
+      "text_encoder_out_layers": [
+        10,
+        20,
+        30
+      ],
+      "weighting_scheme": "none",
+      "logit_mean": 0.0,
+      "logit_std": 1.0,
+      "mode_scale": 1.29,
+      "dino_model_id": "facebook/dinov2-base",
+      "dino_image_size": 224,
+      "sample_image_prompts": [
+        "a photo of sks cat",
+        "a color drawing of sks cat",
+        "sks cat at the beach",
+        "a photo of sks dog",
+        "a photo of an orange cat"
+      ],
+      "drift_image_prompts": [
+        "a photo of cat",
+        "a color drawing of cat",
+        "cat sitting in a bathtub",
+        "cat looks into a mirror",
+        "a photo of cat next to a tree",
+        "the Mona Lisa but she looks angry",
+        "a dog holding a sign that says hello world",
+        "a photo of the Eiffel tower at night",
+        "an astronaut riding a horse",
+        "3d design concept of a chair that looks like an avocado"
+      ]
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "ADALORA",
+      "auto_mapping": null,
+      "peft_version": "0.18.2.dev0@UNKNOWN",
+      "base_model_name_or_path": null,
+      "revision": null,
+      "inference_mode": false,
+      "r": 8,
+      "target_modules": [
+        "add_v_proj",
+        "to_v",
+        "to_qkv_mlp_proj",
+        "to_add_out",
+        "add_q_proj",
+        "to_k",
+        "linear_out",
+        "add_k_proj",
+        "linear_in",
+        "to_q",
+        "to_out.0"
+      ],
+      "exclude_modules": null,
+      "lora_alpha": 32,
+      "lora_dropout": 0.0,
+      "fan_in_fan_out": false,
+      "bias": "none",
+      "use_rslora": false,
+      "modules_to_save": null,
+      "init_lora_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "rank_pattern": {
+        "transformer_blocks.0.attn.to_q.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.0.attn.to_k.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.0.attn.to_v.lora_E": [
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true
+        ],
+        "transformer_blocks.0.attn.to_out.0.lora_E": [
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false
+        ],
+        "transformer_blocks.0.attn.add_q_proj.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.0.attn.add_k_proj.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.0.attn.add_v_proj.lora_E": [
+          false,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.0.attn.to_add_out.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false
+        ],
+        "transformer_blocks.0.ff.linear_in.lora_E": [
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.0.ff.linear_out.lora_E": [
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.0.ff_context.linear_in.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.0.ff_context.linear_out.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.1.attn.to_q.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.1.attn.to_k.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.1.attn.to_v.lora_E": [
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false
+        ],
+        "transformer_blocks.1.attn.to_out.0.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.1.attn.add_q_proj.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.1.attn.add_k_proj.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.1.attn.add_v_proj.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.1.attn.to_add_out.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.1.ff.linear_in.lora_E": [
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true
+        ],
+        "transformer_blocks.1.ff.linear_out.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.1.ff_context.linear_in.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.1.ff_context.linear_out.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.2.attn.to_q.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.2.attn.to_k.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.2.attn.to_v.lora_E": [
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.2.attn.to_out.0.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.2.attn.add_q_proj.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.2.attn.add_k_proj.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.2.attn.add_v_proj.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.2.attn.to_add_out.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.2.ff.linear_in.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.2.ff.linear_out.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.2.ff_context.linear_in.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.2.ff_context.linear_out.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.3.attn.to_q.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.3.attn.to_k.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.3.attn.to_v.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true
+        ],
+        "transformer_blocks.3.attn.to_out.0.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false
+        ],
+        "transformer_blocks.3.attn.add_q_proj.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.3.attn.add_k_proj.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.3.attn.add_v_proj.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.3.attn.to_add_out.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.3.ff.linear_in.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.3.ff.linear_out.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.3.ff_context.linear_in.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.3.ff_context.linear_out.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.4.attn.to_q.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.4.attn.to_k.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.4.attn.to_v.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.4.attn.to_out.0.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.4.attn.add_q_proj.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.4.attn.add_k_proj.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.4.attn.add_v_proj.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.4.attn.to_add_out.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.4.ff.linear_in.lora_E": [
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true
+        ],
+        "transformer_blocks.4.ff.linear_out.lora_E": [
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "transformer_blocks.4.ff_context.linear_in.lora_E": [
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false
+        ],
+        "transformer_blocks.4.ff_context.linear_out.lora_E": [
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          false,
+          true,
+          false,
+          false,
+          false
+        ],
+        "single_transformer_blocks.0.attn.to_qkv_mlp_proj.lora_E": [
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true
+        ],
+        "single_transformer_blocks.1.attn.to_qkv_mlp_proj.lora_E": [
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true
+        ],
+        "single_transformer_blocks.2.attn.to_qkv_mlp_proj.lora_E": [
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true
+        ],
+        "single_transformer_blocks.3.attn.to_qkv_mlp_proj.lora_E": [
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true
+        ],
+        "single_transformer_blocks.4.attn.to_qkv_mlp_proj.lora_E": [
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true
+        ],
+        "single_transformer_blocks.5.attn.to_qkv_mlp_proj.lora_E": [
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true
+        ],
+        "single_transformer_blocks.6.attn.to_qkv_mlp_proj.lora_E": [
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true
+        ],
+        "single_transformer_blocks.7.attn.to_qkv_mlp_proj.lora_E": [
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true
+        ],
+        "single_transformer_blocks.8.attn.to_qkv_mlp_proj.lora_E": [
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true
+        ],
+        "single_transformer_blocks.9.attn.to_qkv_mlp_proj.lora_E": [
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true
+        ],
+        "single_transformer_blocks.10.attn.to_qkv_mlp_proj.lora_E": [
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true
+        ],
+        "single_transformer_blocks.11.attn.to_qkv_mlp_proj.lora_E": [
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true
+        ],
+        "single_transformer_blocks.12.attn.to_qkv_mlp_proj.lora_E": [
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false
+        ],
+        "single_transformer_blocks.13.attn.to_qkv_mlp_proj.lora_E": [
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false
+        ],
+        "single_transformer_blocks.14.attn.to_qkv_mlp_proj.lora_E": [
+          true,
+          true,
+          false,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true
+        ],
+        "single_transformer_blocks.15.attn.to_qkv_mlp_proj.lora_E": [
+          false,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          true,
+          true,
+          true
+        ],
+        "single_transformer_blocks.16.attn.to_qkv_mlp_proj.lora_E": [
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          false,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          false,
+          false,
+          false
+        ],
+        "single_transformer_blocks.17.attn.to_qkv_mlp_proj.lora_E": [
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true
+        ],
+        "single_transformer_blocks.18.attn.to_qkv_mlp_proj.lora_E": [
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true
+        ],
+        "single_transformer_blocks.19.attn.to_qkv_mlp_proj.lora_E": [
+          true,
+          true,
+          false,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true,
+          true,
+          false,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          false,
+          true,
+          true,
+          true,
+          true
+        ]
+      },
+      "alpha_pattern": {},
+      "megatron_config": null,
+      "megatron_core": "megatron.core",
+      "trainable_token_indices": null,
+      "loftq_config": {},
+      "eva_config": null,
+      "corda_config": null,
+      "lora_ga_config": null,
+      "use_dora": false,
+      "velora_config": null,
+      "alora_invocation_tokens": null,
+      "use_qalora": false,
+      "qalora_group_size": 16,
+      "monteclora_config": null,
+      "layer_replication": null,
+      "lora_bias": false,
+      "target_parameters": null,
+      "use_bdlora": null,
+      "arrow_config": null,
+      "ensure_weight_tying": false,
+      "target_r": 8,
+      "init_r": 32,
+      "tinit": 100,
+      "tfinal": 200,
+      "deltaT": 1,
+      "beta1": 0.85,
+      "beta2": 0.85,
+      "orth_reg_weight": 0.5,
+      "total_step": 750
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 11341912517,
+    "accelerator_memory_max": 11630804992,
+    "accelerator_memory_reserved_99th": 11630804992,
+    "train_time": 718.568363055,
+    "file_size": 68503160,
+    "num_trainable_params": 38341120,
+    "num_total_params": 3913885776,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 100,
+        "valid dino_similarity": 0.2403588593006134,
+        "train loss": 0.7758233547210693,
+        "train samples": 200,
+        "train time": 74.82625103800069,
+        "eval time": 14.179087730999981,
+        "mem allocated avg": 9360586147.84,
+        "mem reserved avg": 11376839884.8,
+        "elapsed time": 95.25955924200002
+      },
+      {
+        "step": 200,
+        "valid dino_similarity": 0.3903423249721527,
+        "train loss": 0.7664628624916077,
+        "train samples": 400,
+        "train time": 76.75432314899967,
+        "eval time": 14.377506751999817,
+        "mem allocated avg": 9360288409.6,
+        "mem reserved avg": 11519173591.04,
+        "elapsed time": 186.557391241
+      },
+      {
+        "step": 300,
+        "valid dino_similarity": 0.5515351295471191,
+        "train loss": 0.7849739193916321,
+        "train samples": 600,
+        "train time": 77.6881400490006,
+        "eval time": 14.412432120999938,
+        "mem allocated avg": 9361078855.68,
+        "mem reserved avg": 11575859609.6,
+        "elapsed time": 278.82249671499994
+      },
+      {
+        "step": 400,
+        "valid dino_similarity": 0.6130026578903198,
+        "train loss": 0.7502579092979431,
+        "train samples": 800,
+        "train time": 77.31088079400047,
+        "eval time": 14.293341033999923,
+        "mem allocated avg": 9358967367.68,
+        "mem reserved avg": 11613272801.28,
+        "elapsed time": 370.5930259940001
+      },
+      {
+        "step": 500,
+        "valid dino_similarity": 0.6123189926147461,
+        "train loss": 0.7551052570343018,
+        "train samples": 1000,
+        "train time": 77.86464323899986,
+        "eval time": 14.237591178000002,
+        "mem allocated avg": 9360278169.6,
+        "mem reserved avg": 11610567475.2,
+        "elapsed time": 462.86298072
+      },
+      {
+        "step": 600,
+        "valid dino_similarity": 0.708698570728302,
+        "train loss": 0.7753590941429138,
+        "train samples": 1200,
+        "train time": 75.90354586800004,
+        "eval time": 14.352316393000137,
+        "mem allocated avg": 9123236096.0,
+        "mem reserved avg": 11627407605.76,
+        "elapsed time": 553.286248141
+      },
+      {
+        "step": 700,
+        "valid dino_similarity": 0.6842397451400757,
+        "train loss": 0.7408015131950378,
+        "train samples": 1400,
+        "train time": 75.08988325900054,
+        "eval time": 14.239193459000035,
+        "mem allocated avg": 8893372672.0,
+        "mem reserved avg": 10498342912.0,
+        "elapsed time": 642.8109984099999
+      },
+      {
+        "step": 750,
+        "test dino_similarity": 0.6824255585670471,
+        "drift": 0.26671119034290314,
+        "train loss": 0.7460358142852783,
+        "train samples": 1500
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "a3b4f4849157f664bdbc776fd7453c2783562f4d",
+      "created_at": "2026-01-14T13:42:28+00:00"
+    },
+    "dataset_info": {
+      "sha": "37df3244ae3aa36e85178b6cf946338137fc3068",
+      "created_at": "2026-03-09T15:31:26+00:00"
+    },
+    "package_info": {
+      "transformers-version": "5.10.2",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.2.dev0",
+      "peft-commit-hash": "b2d61f5f80a7ac540fb572c077d8265a95986db8",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "diffusers-version": "0.38.0",
+      "diffusers-commit-hash": null,
+      "torch-version": "2.12.0+cu130",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 202002\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.11.2 (Git Hash 03c022d3ffdcee958cfacbe720048e725fdf644c)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 13.0\n  - NVCC architecture flags: -gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1  (built against CUDA 12.8)\n    - Built with CuDNN 92.0\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=7661cd9c6b841b62b7f411aa52ec51f05457263b, CUDA_FLAGS= -DLIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_OPERATIONS -Xfatbin -compress-all -DONNX_NAMESPACE=onnx_torch -gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_100,code=sm_100 -gencode arch=compute_120,code=sm_120 -Xcudafe --diag_suppress=cc_clobber_ignored,--diag_suppress=field_without_dll_interface,--diag_suppress=base_class_has_different_dll_interface,--diag_suppress=dll_interface_conflict_none_assumed,--diag_suppress=dll_interface_conflict_dllexport_assumed,--diag_suppress=bad_friend_decl --expt-relaxed-constexpr --expt-extended-lambda -Xfatbin -compress-all --threads 2 -compress-mode=size -Wno-deprecated-gpu-targets --expt-extended-lambda -DCUB_WRAPPED_NAMESPACE=at_cuda_detail -DDISABLE_CUSPARSE_DEPRECATED -DCUDA_HAS_FP16=1 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -DC10_NODEPRECATED, CUDA_VERSION=13.0, CUDNN_VERSION=9.20.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_MSLK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.12.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/results/boft--flux2-klein-default.json b/method_comparison/image-gen/results/boft--flux2-klein-default.json
new file mode 100644
index 0000000..bfa33a3
--- /dev/null
+++ b/method_comparison/image-gen/results/boft--flux2-klein-default.json
@@ -0,0 +1,251 @@
+{
+  "run_info": {
+    "created_at": "2026-06-09T10:16:24+00:00",
+    "total_time": 3001.757409892,
+    "experiment_name": "boft/flux2-klein-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "black-forest-labs/FLUX.2-klein-base-4B",
+      "dataset_id": "peft-internal-testing/cat-image-dataset",
+      "dataset_split": "train",
+      "dtype": "bfloat16",
+      "resolution": 512,
+      "batch_size": 2,
+      "batch_size_eval": 1,
+      "repeats": 1000,
+      "max_steps": 750,
+      "eval_steps": 100,
+      "compile": false,
+      "use_gc": true,
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.0001
+      },
+      "lr_scheduler": null,
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "instance_prompts": [
+        "sks cat sitting on a chair in front of a box of chocolates",
+        "sks cat playing on the Steam Deck",
+        "sks cat wearing a necklace while sitting in a box on a sofa",
+        "a box with four donuts in front of sks cat",
+        "sks cat wearing a pink veil with flowers on it and a dagger made out of yellow cardboard",
+        "sks cat between two pillows, with one pillow showing a polar bear and the other a fox",
+        "sks cat with an espresso reading the newspaper",
+        "a close up of a hand petting sks cat on the head",
+        "sks cat opens a white door",
+        "sks cat with a VIP \"all access\" pass",
+        "sks cat in front of a monitor showing the video game \"RimWorld\"",
+        "sks cat reads a newspaper about cannabis",
+        "sks cat reading the newspaper with the title \"DIE BOX\"",
+        "sks cat being fed sushi",
+        "sks cat in front of a box of tomatoes",
+        "a gingerbread house in front of sks cat",
+        "sks cat is wearing a Wednesday Addams costume",
+        "sks cat looks skeptical as he reads a magazine depicting a black cat",
+        "sks cat wearing a striped scarf",
+        "sleepy sks cat lying in bed covered by a blue blanket"
+      ],
+      "image_column": "image",
+      "valid_size": 2,
+      "test_size": 4,
+      "num_inference_steps": 20,
+      "guidance_scale": 3.5,
+      "max_sequence_length": 512,
+      "text_encoder_out_layers": [
+        10,
+        20,
+        30
+      ],
+      "weighting_scheme": "none",
+      "logit_mean": 0.0,
+      "logit_std": 1.0,
+      "mode_scale": 1.29,
+      "dino_model_id": "facebook/dinov2-base",
+      "dino_image_size": 224,
+      "sample_image_prompts": [
+        "a photo of sks cat",
+        "a color drawing of sks cat",
+        "sks cat at the beach",
+        "a photo of sks dog",
+        "a photo of an orange cat"
+      ],
+      "drift_image_prompts": [
+        "a photo of cat",
+        "a color drawing of cat",
+        "cat sitting in a bathtub",
+        "cat looks into a mirror",
+        "a photo of cat next to a tree",
+        "the Mona Lisa but she looks angry",
+        "a dog holding a sign that says hello world",
+        "a photo of the Eiffel tower at night",
+        "an astronaut riding a horse",
+        "3d design concept of a chair that looks like an avocado"
+      ]
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "BOFT",
+      "auto_mapping": null,
+      "peft_version": "0.18.2.dev0@UNKNOWN",
+      "base_model_name_or_path": null,
+      "revision": null,
+      "inference_mode": false,
+      "boft_block_size": 4,
+      "boft_block_num": 0,
+      "boft_n_butterfly_factor": 2,
+      "target_modules": [
+        "to_v",
+        "add_k_proj",
+        "to_qkv_mlp_proj",
+        "to_q",
+        "linear_in",
+        "add_v_proj",
+        "to_k",
+        "to_out.0",
+        "add_q_proj",
+        "linear_out",
+        "to_add_out"
+      ],
+      "exclude_modules": null,
+      "boft_dropout": 0.0,
+      "fan_in_fan_out": false,
+      "bias": "none",
+      "modules_to_save": null,
+      "init_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 17298115002,
+    "accelerator_memory_max": 17368612864,
+    "accelerator_memory_reserved_99th": 17368612864,
+    "train_time": 2524.314185989001,
+    "file_size": 8500008,
+    "num_trainable_params": 2119680,
+    "num_total_params": 3877664256,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 100,
+        "valid dino_similarity": 0.34351247549057007,
+        "train loss": 0.762182354927063,
+        "train samples": 200,
+        "train time": 243.34609632800084,
+        "eval time": 66.00437694799984,
+        "mem allocated avg": 14321960192.0,
+        "mem reserved avg": 17365215477.76,
+        "elapsed time": 315.7438521270001
+      },
+      {
+        "step": 200,
+        "valid dino_similarity": 0.47275498509407043,
+        "train loss": 0.7758499979972839,
+        "train samples": 400,
+        "train time": 240.73475723299862,
+        "eval time": 66.47240585000009,
+        "mem allocated avg": 14322012416.0,
+        "mem reserved avg": 17286823936.0,
+        "elapsed time": 623.094051045
+      },
+      {
+        "step": 300,
+        "valid dino_similarity": 0.44021278619766235,
+        "train loss": 0.7750328779220581,
+        "train samples": 600,
+        "train time": 241.62629119500025,
+        "eval time": 66.06956163099994,
+        "mem allocated avg": 14322063616.0,
+        "mem reserved avg": 17286823936.0,
+        "elapsed time": 930.936767403
+      },
+      {
+        "step": 400,
+        "valid dino_similarity": 0.5291547775268555,
+        "train loss": 0.7631975412368774,
+        "train samples": 800,
+        "train time": 239.96141395800169,
+        "eval time": 66.48263424800007,
+        "mem allocated avg": 14322114816.0,
+        "mem reserved avg": 17286823936.0,
+        "elapsed time": 1237.527966265
+      },
+      {
+        "step": 500,
+        "valid dino_similarity": 0.5172373056411743,
+        "train loss": 0.7812181711196899,
+        "train samples": 1000,
+        "train time": 241.2803780840004,
+        "eval time": 65.95611584100016,
+        "mem allocated avg": 14322166016.0,
+        "mem reserved avg": 17288061255.68,
+        "elapsed time": 1544.915679325
+      },
+      {
+        "step": 600,
+        "valid dino_similarity": 0.48621824383735657,
+        "train loss": 0.7532262206077576,
+        "train samples": 1200,
+        "train time": 240.039809554999,
+        "eval time": 66.08985766899968,
+        "mem allocated avg": 14322217216.0,
+        "mem reserved avg": 17288921088.0,
+        "elapsed time": 1851.1966522470002
+      },
+      {
+        "step": 700,
+        "valid dino_similarity": 0.6115512251853943,
+        "train loss": 0.7843080759048462,
+        "train samples": 1400,
+        "train time": 240.69034176499736,
+        "eval time": 66.11447335399953,
+        "mem allocated avg": 14322268416.0,
+        "mem reserved avg": 17288774287.36,
+        "elapsed time": 2158.1504945849997
+      },
+      {
+        "step": 750,
+        "test dino_similarity": 0.6449412306149801,
+        "drift": 0.2069137692451477,
+        "train loss": 0.7722759246826172,
+        "train samples": 1500
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "a3b4f4849157f664bdbc776fd7453c2783562f4d",
+      "created_at": "2026-01-14T13:42:28+00:00"
+    },
+    "dataset_info": {
+      "sha": "37df3244ae3aa36e85178b6cf946338137fc3068",
+      "created_at": "2026-03-09T15:31:26+00:00"
+    },
+    "package_info": {
+      "transformers-version": "5.10.2",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.2.dev0",
+      "peft-commit-hash": "b2d61f5f80a7ac540fb572c077d8265a95986db8",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "diffusers-version": "0.38.0",
+      "diffusers-commit-hash": null,
+      "torch-version": "2.12.0+cu130",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 202002\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.11.2 (Git Hash 03c022d3ffdcee958cfacbe720048e725fdf644c)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 13.0\n  - NVCC architecture flags: -gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1  (built against CUDA 12.8)\n    - Built with CuDNN 92.0\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=7661cd9c6b841b62b7f411aa52ec51f05457263b, CUDA_FLAGS= -DLIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_OPERATIONS -Xfatbin -compress-all -DONNX_NAMESPACE=onnx_torch -gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_100,code=sm_100 -gencode arch=compute_120,code=sm_120 -Xcudafe --diag_suppress=cc_clobber_ignored,--diag_suppress=field_without_dll_interface,--diag_suppress=base_class_has_different_dll_interface,--diag_suppress=dll_interface_conflict_none_assumed,--diag_suppress=dll_interface_conflict_dllexport_assumed,--diag_suppress=bad_friend_decl --expt-relaxed-constexpr --expt-extended-lambda -Xfatbin -compress-all --threads 2 -compress-mode=size -Wno-deprecated-gpu-targets --expt-extended-lambda -DCUB_WRAPPED_NAMESPACE=at_cuda_detail -DDISABLE_CUSPARSE_DEPRECATED -DCUDA_HAS_FP16=1 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -DC10_NODEPRECATED, CUDA_VERSION=13.0, CUDNN_VERSION=9.20.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_MSLK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.12.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/results/c3a--flux2-klein-default.json b/method_comparison/image-gen/results/c3a--flux2-klein-default.json
new file mode 100644
index 0000000..4aeab6d
--- /dev/null
+++ b/method_comparison/image-gen/results/c3a--flux2-klein-default.json
@@ -0,0 +1,247 @@
+{
+  "run_info": {
+    "created_at": "2026-06-09T11:09:19+00:00",
+    "total_time": 1277.0475058369993,
+    "experiment_name": "c3a/flux2-klein-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "black-forest-labs/FLUX.2-klein-base-4B",
+      "dataset_id": "peft-internal-testing/cat-image-dataset",
+      "dataset_split": "train",
+      "dtype": "bfloat16",
+      "resolution": 512,
+      "batch_size": 2,
+      "batch_size_eval": 1,
+      "repeats": 1000,
+      "max_steps": 750,
+      "eval_steps": 100,
+      "compile": false,
+      "use_gc": true,
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.3,
+        "weight_decay": 1e-05
+      },
+      "lr_scheduler": null,
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "instance_prompts": [
+        "sks cat sitting on a chair in front of a box of chocolates",
+        "sks cat playing on the Steam Deck",
+        "sks cat wearing a necklace while sitting in a box on a sofa",
+        "a box with four donuts in front of sks cat",
+        "sks cat wearing a pink veil with flowers on it and a dagger made out of yellow cardboard",
+        "sks cat between two pillows, with one pillow showing a polar bear and the other a fox",
+        "sks cat with an espresso reading the newspaper",
+        "a close up of a hand petting sks cat on the head",
+        "sks cat opens a white door",
+        "sks cat with a VIP \"all access\" pass",
+        "sks cat in front of a monitor showing the video game \"RimWorld\"",
+        "sks cat reads a newspaper about cannabis",
+        "sks cat reading the newspaper with the title \"DIE BOX\"",
+        "sks cat being fed sushi",
+        "sks cat in front of a box of tomatoes",
+        "a gingerbread house in front of sks cat",
+        "sks cat is wearing a Wednesday Addams costume",
+        "sks cat looks skeptical as he reads a magazine depicting a black cat",
+        "sks cat wearing a striped scarf",
+        "sleepy sks cat lying in bed covered by a blue blanket"
+      ],
+      "image_column": "image",
+      "valid_size": 2,
+      "test_size": 4,
+      "num_inference_steps": 20,
+      "guidance_scale": 3.5,
+      "max_sequence_length": 512,
+      "text_encoder_out_layers": [
+        10,
+        20,
+        30
+      ],
+      "weighting_scheme": "none",
+      "logit_mean": 0.0,
+      "logit_std": 1.0,
+      "mode_scale": 1.29,
+      "dino_model_id": "facebook/dinov2-base",
+      "dino_image_size": 224,
+      "sample_image_prompts": [
+        "a photo of sks cat",
+        "a color drawing of sks cat",
+        "sks cat at the beach",
+        "a photo of sks dog",
+        "a photo of an orange cat"
+      ],
+      "drift_image_prompts": [
+        "a photo of cat",
+        "a color drawing of cat",
+        "cat sitting in a bathtub",
+        "cat looks into a mirror",
+        "a photo of cat next to a tree",
+        "the Mona Lisa but she looks angry",
+        "a dog holding a sign that says hello world",
+        "a photo of the Eiffel tower at night",
+        "an astronaut riding a horse",
+        "3d design concept of a chair that looks like an avocado"
+      ]
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "C3A",
+      "auto_mapping": null,
+      "peft_version": "0.18.2.dev0@UNKNOWN",
+      "base_model_name_or_path": null,
+      "revision": null,
+      "inference_mode": false,
+      "block_size": 256,
+      "target_modules": [
+        "to_out.0",
+        "to_q",
+        "to_k",
+        "linear_in",
+        "to_qkv_mlp_proj",
+        "add_k_proj",
+        "to_add_out",
+        "add_q_proj",
+        "linear_out",
+        "add_v_proj",
+        "to_v"
+      ],
+      "bias": "none",
+      "modules_to_save": null,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "block_size_pattern": {},
+      "init_weights": "xavier_uniform"
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 11573343027,
+    "accelerator_memory_max": 11586764800,
+    "accelerator_memory_reserved_99th": 11586764800,
+    "train_time": 1141.61083238,
+    "file_size": 45722624,
+    "num_trainable_params": 11427840,
+    "num_total_params": 3886972416,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 100,
+        "valid dino_similarity": 0.6339882612228394,
+        "train loss": 0.7729708552360535,
+        "train samples": 200,
+        "train time": 126.76792103299704,
+        "eval time": 18.408813105000263,
+        "mem allocated avg": 8449062963.2,
+        "mem reserved avg": 11486101504.0,
+        "elapsed time": 151.55122113500056
+      },
+      {
+        "step": 200,
+        "valid dino_similarity": 0.7071419954299927,
+        "train loss": 0.7566680908203125,
+        "train samples": 400,
+        "train time": 127.38828747200114,
+        "eval time": 18.256091709999964,
+        "mem allocated avg": 8449085696.0,
+        "mem reserved avg": 11586764800.0,
+        "elapsed time": 297.32792809500006
+      },
+      {
+        "step": 300,
+        "valid dino_similarity": 0.6814765930175781,
+        "train loss": 0.756169319152832,
+        "train samples": 600,
+        "train time": 127.4125829329978,
+        "eval time": 18.345569841000724,
+        "mem allocated avg": 8449136896.0,
+        "mem reserved avg": 11586764800.0,
+        "elapsed time": 443.21960198000033
+      },
+      {
+        "step": 400,
+        "valid dino_similarity": 0.6476562023162842,
+        "train loss": 0.7269070148468018,
+        "train samples": 800,
+        "train time": 127.37037810699985,
+        "eval time": 18.1826386849998,
+        "mem allocated avg": 8449188096.0,
+        "mem reserved avg": 11586764800.0,
+        "elapsed time": 588.9073261430003
+      },
+      {
+        "step": 500,
+        "valid dino_similarity": 0.6309338808059692,
+        "train loss": 0.7188448905944824,
+        "train samples": 1000,
+        "train time": 126.82453791100033,
+        "eval time": 18.20408930099984,
+        "mem allocated avg": 8449239296.0,
+        "mem reserved avg": 11586764800.0,
+        "elapsed time": 734.0703636150001
+      },
+      {
+        "step": 600,
+        "valid dino_similarity": 0.6360106468200684,
+        "train loss": 0.7048215866088867,
+        "train samples": 1200,
+        "train time": 126.93692329100213,
+        "eval time": 18.391842403999362,
+        "mem allocated avg": 8449290496.0,
+        "mem reserved avg": 11586764800.0,
+        "elapsed time": 879.5345459230002
+      },
+      {
+        "step": 700,
+        "valid dino_similarity": 0.7343795299530029,
+        "train loss": 0.7161768674850464,
+        "train samples": 1400,
+        "train time": 126.55631682999501,
+        "eval time": 18.274556012000176,
+        "mem allocated avg": 8449341696.0,
+        "mem reserved avg": 11586764800.0,
+        "elapsed time": 1024.4985660860002
+      },
+      {
+        "step": 750,
+        "test dino_similarity": 0.6366289258003235,
+        "drift": 0.3616682291030884,
+        "train loss": 0.7171458005905151,
+        "train samples": 1500
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "a3b4f4849157f664bdbc776fd7453c2783562f4d",
+      "created_at": "2026-01-14T13:42:28+00:00"
+    },
+    "dataset_info": {
+      "sha": "37df3244ae3aa36e85178b6cf946338137fc3068",
+      "created_at": "2026-03-09T15:31:26+00:00"
+    },
+    "package_info": {
+      "transformers-version": "5.10.2",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.2.dev0",
+      "peft-commit-hash": "b2d61f5f80a7ac540fb572c077d8265a95986db8",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "diffusers-version": "0.38.0",
+      "diffusers-commit-hash": null,
+      "torch-version": "2.12.0+cu130",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 202002\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.11.2 (Git Hash 03c022d3ffdcee958cfacbe720048e725fdf644c)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 13.0\n  - NVCC architecture flags: -gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1  (built against CUDA 12.8)\n    - Built with CuDNN 92.0\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=7661cd9c6b841b62b7f411aa52ec51f05457263b, CUDA_FLAGS= -DLIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_OPERATIONS -Xfatbin -compress-all -DONNX_NAMESPACE=onnx_torch -gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_100,code=sm_100 -gencode arch=compute_120,code=sm_120 -Xcudafe --diag_suppress=cc_clobber_ignored,--diag_suppress=field_without_dll_interface,--diag_suppress=base_class_has_different_dll_interface,--diag_suppress=dll_interface_conflict_none_assumed,--diag_suppress=dll_interface_conflict_dllexport_assumed,--diag_suppress=bad_friend_decl --expt-relaxed-constexpr --expt-extended-lambda -Xfatbin -compress-all --threads 2 -compress-mode=size -Wno-deprecated-gpu-targets --expt-extended-lambda -DCUB_WRAPPED_NAMESPACE=at_cuda_detail -DDISABLE_CUSPARSE_DEPRECATED -DCUDA_HAS_FP16=1 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -DC10_NODEPRECATED, CUDA_VERSION=13.0, CUDNN_VERSION=9.20.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_MSLK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.12.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/results/delora--flux2-klein-default.json b/method_comparison/image-gen/results/delora--flux2-klein-default.json
new file mode 100644
index 0000000..9fa346c
--- /dev/null
+++ b/method_comparison/image-gen/results/delora--flux2-klein-default.json
@@ -0,0 +1,250 @@
+{
+  "run_info": {
+    "created_at": "2026-06-09T11:31:30+00:00",
+    "total_time": 738.2436320380002,
+    "experiment_name": "delora/flux2-klein-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "black-forest-labs/FLUX.2-klein-base-4B",
+      "dataset_id": "peft-internal-testing/cat-image-dataset",
+      "dataset_split": "train",
+      "dtype": "bfloat16",
+      "resolution": 512,
+      "batch_size": 2,
+      "batch_size_eval": 1,
+      "repeats": 1000,
+      "max_steps": 750,
+      "eval_steps": 100,
+      "compile": false,
+      "use_gc": true,
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.001
+      },
+      "lr_scheduler": null,
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "instance_prompts": [
+        "sks cat sitting on a chair in front of a box of chocolates",
+        "sks cat playing on the Steam Deck",
+        "sks cat wearing a necklace while sitting in a box on a sofa",
+        "a box with four donuts in front of sks cat",
+        "sks cat wearing a pink veil with flowers on it and a dagger made out of yellow cardboard",
+        "sks cat between two pillows, with one pillow showing a polar bear and the other a fox",
+        "sks cat with an espresso reading the newspaper",
+        "a close up of a hand petting sks cat on the head",
+        "sks cat opens a white door",
+        "sks cat with a VIP \"all access\" pass",
+        "sks cat in front of a monitor showing the video game \"RimWorld\"",
+        "sks cat reads a newspaper about cannabis",
+        "sks cat reading the newspaper with the title \"DIE BOX\"",
+        "sks cat being fed sushi",
+        "sks cat in front of a box of tomatoes",
+        "a gingerbread house in front of sks cat",
+        "sks cat is wearing a Wednesday Addams costume",
+        "sks cat looks skeptical as he reads a magazine depicting a black cat",
+        "sks cat wearing a striped scarf",
+        "sleepy sks cat lying in bed covered by a blue blanket"
+      ],
+      "image_column": "image",
+      "valid_size": 2,
+      "test_size": 4,
+      "num_inference_steps": 20,
+      "guidance_scale": 3.5,
+      "max_sequence_length": 512,
+      "text_encoder_out_layers": [
+        10,
+        20,
+        30
+      ],
+      "weighting_scheme": "none",
+      "logit_mean": 0.0,
+      "logit_std": 1.0,
+      "mode_scale": 1.29,
+      "dino_model_id": "facebook/dinov2-base",
+      "dino_image_size": 224,
+      "sample_image_prompts": [
+        "a photo of sks cat",
+        "a color drawing of sks cat",
+        "sks cat at the beach",
+        "a photo of sks dog",
+        "a photo of an orange cat"
+      ],
+      "drift_image_prompts": [
+        "a photo of cat",
+        "a color drawing of cat",
+        "cat sitting in a bathtub",
+        "cat looks into a mirror",
+        "a photo of cat next to a tree",
+        "the Mona Lisa but she looks angry",
+        "a dog holding a sign that says hello world",
+        "a photo of the Eiffel tower at night",
+        "an astronaut riding a horse",
+        "3d design concept of a chair that looks like an avocado"
+      ]
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "DELORA",
+      "auto_mapping": null,
+      "peft_version": "0.18.2.dev0@UNKNOWN",
+      "base_model_name_or_path": null,
+      "revision": null,
+      "inference_mode": false,
+      "r": 32,
+      "delora_lambda": 15,
+      "module_dropout": 0.0,
+      "target_modules": [
+        "to_add_out",
+        "add_v_proj",
+        "add_q_proj",
+        "add_k_proj",
+        "linear_out",
+        "to_v",
+        "linear_in",
+        "to_out.0",
+        "to_q",
+        "to_k",
+        "to_qkv_mlp_proj"
+      ],
+      "exclude_modules": null,
+      "bias": "none",
+      "init_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "rank_pattern": {},
+      "lambda_pattern": {},
+      "modules_to_save": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 10460353702,
+    "accelerator_memory_max": 10563354624,
+    "accelerator_memory_reserved_99th": 10563354624,
+    "train_time": 631.5103333749994,
+    "file_size": 154627416,
+    "num_trainable_params": 38338640,
+    "num_total_params": 3913883216,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 100,
+        "valid dino_similarity": 0.10348112881183624,
+        "train loss": 0.8093757629394531,
+        "train samples": 200,
+        "train time": 65.47692426100366,
+        "eval time": 13.483665005000148,
+        "mem allocated avg": 8890693683.2,
+        "mem reserved avg": 10387466485.76,
+        "elapsed time": 85.30604756000048
+      },
+      {
+        "step": 200,
+        "valid dino_similarity": 0.4578881859779358,
+        "train loss": 0.785163938999176,
+        "train samples": 400,
+        "train time": 66.71736136099753,
+        "eval time": 13.5600679879999,
+        "mem allocated avg": 8890464102.4,
+        "mem reserved avg": 10507507466.24,
+        "elapsed time": 165.76564696600053
+      },
+      {
+        "step": 300,
+        "valid dino_similarity": 0.6172184944152832,
+        "train loss": 0.7807518839836121,
+        "train samples": 600,
+        "train time": 65.2553221010021,
+        "eval time": 13.480145817000448,
+        "mem allocated avg": 8891472128.0,
+        "mem reserved avg": 10431234048.0,
+        "elapsed time": 244.68029177600056
+      },
+      {
+        "step": 400,
+        "valid dino_similarity": 0.5900638699531555,
+        "train loss": 0.749613881111145,
+        "train samples": 800,
+        "train time": 65.71304100099223,
+        "eval time": 13.520315671999924,
+        "mem allocated avg": 8891959797.76,
+        "mem reserved avg": 10559957237.76,
+        "elapsed time": 324.09557109900015
+      },
+      {
+        "step": 500,
+        "valid dino_similarity": 0.589127779006958,
+        "train loss": 0.6886972784996033,
+        "train samples": 1000,
+        "train time": 66.53621333100182,
+        "eval time": 13.61111054399953,
+        "mem allocated avg": 8889786705.92,
+        "mem reserved avg": 10464704593.92,
+        "elapsed time": 404.4248490400005
+      },
+      {
+        "step": 600,
+        "valid dino_similarity": 0.6107770204544067,
+        "train loss": 0.7403025031089783,
+        "train samples": 1200,
+        "train time": 65.57085778100463,
+        "eval time": 13.507120122000742,
+        "mem allocated avg": 8893251020.8,
+        "mem reserved avg": 10452079738.88,
+        "elapsed time": 483.68787908600007
+      },
+      {
+        "step": 700,
+        "valid dino_similarity": 0.6648523807525635,
+        "train loss": 0.7193997502326965,
+        "train samples": 1400,
+        "train time": 66.07636966899918,
+        "eval time": 13.67928217700046,
+        "mem allocated avg": 8892471224.32,
+        "mem reserved avg": 10433289256.96,
+        "elapsed time": 563.6287115940004
+      },
+      {
+        "step": 750,
+        "test dino_similarity": 0.5392374992370605,
+        "drift": 0.46095240488648415,
+        "train loss": 0.6807275414466858,
+        "train samples": 1500
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "a3b4f4849157f664bdbc776fd7453c2783562f4d",
+      "created_at": "2026-01-14T13:42:28+00:00"
+    },
+    "dataset_info": {
+      "sha": "37df3244ae3aa36e85178b6cf946338137fc3068",
+      "created_at": "2026-03-09T15:31:26+00:00"
+    },
+    "package_info": {
+      "transformers-version": "5.10.2",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.2.dev0",
+      "peft-commit-hash": "b2d61f5f80a7ac540fb572c077d8265a95986db8",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "diffusers-version": "0.38.0",
+      "diffusers-commit-hash": null,
+      "torch-version": "2.12.0+cu130",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 202002\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.11.2 (Git Hash 03c022d3ffdcee958cfacbe720048e725fdf644c)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 13.0\n  - NVCC architecture flags: -gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1  (built against CUDA 12.8)\n    - Built with CuDNN 92.0\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=7661cd9c6b841b62b7f411aa52ec51f05457263b, CUDA_FLAGS= -DLIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_OPERATIONS -Xfatbin -compress-all -DONNX_NAMESPACE=onnx_torch -gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_100,code=sm_100 -gencode arch=compute_120,code=sm_120 -Xcudafe --diag_suppress=cc_clobber_ignored,--diag_suppress=field_without_dll_interface,--diag_suppress=base_class_has_different_dll_interface,--diag_suppress=dll_interface_conflict_none_assumed,--diag_suppress=dll_interface_conflict_dllexport_assumed,--diag_suppress=bad_friend_decl --expt-relaxed-constexpr --expt-extended-lambda -Xfatbin -compress-all --threads 2 -compress-mode=size -Wno-deprecated-gpu-targets --expt-extended-lambda -DCUB_WRAPPED_NAMESPACE=at_cuda_detail -DDISABLE_CUSPARSE_DEPRECATED -DCUDA_HAS_FP16=1 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -DC10_NODEPRECATED, CUDA_VERSION=13.0, CUDNN_VERSION=9.20.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_MSLK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.12.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/results/fourierft--flux2-klein-default.json b/method_comparison/image-gen/results/fourierft--flux2-klein-default.json
new file mode 100644
index 0000000..2f0f435
--- /dev/null
+++ b/method_comparison/image-gen/results/fourierft--flux2-klein-default.json
@@ -0,0 +1,251 @@
+{
+  "run_info": {
+    "created_at": "2026-06-09T11:44:36+00:00",
+    "total_time": 3499.5996365359997,
+    "experiment_name": "fourierft/flux2-klein-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "black-forest-labs/FLUX.2-klein-base-4B",
+      "dataset_id": "peft-internal-testing/cat-image-dataset",
+      "dataset_split": "train",
+      "dtype": "bfloat16",
+      "resolution": 512,
+      "batch_size": 2,
+      "batch_size_eval": 1,
+      "repeats": 1000,
+      "max_steps": 750,
+      "eval_steps": 100,
+      "compile": false,
+      "use_gc": true,
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.0001
+      },
+      "lr_scheduler": null,
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "instance_prompts": [
+        "sks cat sitting on a chair in front of a box of chocolates",
+        "sks cat playing on the Steam Deck",
+        "sks cat wearing a necklace while sitting in a box on a sofa",
+        "a box with four donuts in front of sks cat",
+        "sks cat wearing a pink veil with flowers on it and a dagger made out of yellow cardboard",
+        "sks cat between two pillows, with one pillow showing a polar bear and the other a fox",
+        "sks cat with an espresso reading the newspaper",
+        "a close up of a hand petting sks cat on the head",
+        "sks cat opens a white door",
+        "sks cat with a VIP \"all access\" pass",
+        "sks cat in front of a monitor showing the video game \"RimWorld\"",
+        "sks cat reads a newspaper about cannabis",
+        "sks cat reading the newspaper with the title \"DIE BOX\"",
+        "sks cat being fed sushi",
+        "sks cat in front of a box of tomatoes",
+        "a gingerbread house in front of sks cat",
+        "sks cat is wearing a Wednesday Addams costume",
+        "sks cat looks skeptical as he reads a magazine depicting a black cat",
+        "sks cat wearing a striped scarf",
+        "sleepy sks cat lying in bed covered by a blue blanket"
+      ],
+      "image_column": "image",
+      "valid_size": 2,
+      "test_size": 4,
+      "num_inference_steps": 20,
+      "guidance_scale": 3.5,
+      "max_sequence_length": 512,
+      "text_encoder_out_layers": [
+        10,
+        20,
+        30
+      ],
+      "weighting_scheme": "none",
+      "logit_mean": 0.0,
+      "logit_std": 1.0,
+      "mode_scale": 1.29,
+      "dino_model_id": "facebook/dinov2-base",
+      "dino_image_size": 224,
+      "sample_image_prompts": [
+        "a photo of sks cat",
+        "a color drawing of sks cat",
+        "sks cat at the beach",
+        "a photo of sks dog",
+        "a photo of an orange cat"
+      ],
+      "drift_image_prompts": [
+        "a photo of cat",
+        "a color drawing of cat",
+        "cat sitting in a bathtub",
+        "cat looks into a mirror",
+        "a photo of cat next to a tree",
+        "the Mona Lisa but she looks angry",
+        "a dog holding a sign that says hello world",
+        "a photo of the Eiffel tower at night",
+        "an astronaut riding a horse",
+        "3d design concept of a chair that looks like an avocado"
+      ]
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "FOURIERFT",
+      "auto_mapping": null,
+      "peft_version": "0.18.2.dev0@UNKNOWN",
+      "base_model_name_or_path": null,
+      "revision": null,
+      "inference_mode": false,
+      "n_frequency": 2000,
+      "scaling": 150.0,
+      "random_loc_seed": 777,
+      "fan_in_fan_out": false,
+      "target_modules": [
+        "to_add_out",
+        "add_k_proj",
+        "to_out.0",
+        "to_v",
+        "to_qkv_mlp_proj",
+        "add_v_proj",
+        "to_q",
+        "add_q_proj",
+        "linear_in",
+        "linear_out",
+        "to_k"
+      ],
+      "exclude_modules": null,
+      "bias": "none",
+      "modules_to_save": null,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "n_frequency_pattern": {},
+      "init_weights": false
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 12409130800,
+    "accelerator_memory_max": 12935233536,
+    "accelerator_memory_reserved_99th": 12935233536,
+    "train_time": 2988.2643262210013,
+    "file_size": 651152,
+    "num_trainable_params": 160000,
+    "num_total_params": 3875704576,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 100,
+        "valid dino_similarity": 0.2357805371284485,
+        "train loss": 0.7708715796470642,
+        "train samples": 200,
+        "train time": 311.00991913199414,
+        "eval time": 59.386219692999475,
+        "mem allocated avg": 8250868992.0,
+        "mem reserved avg": 12907991531.52,
+        "elapsed time": 376.7466578980002
+      },
+      {
+        "step": 200,
+        "valid dino_similarity": 0.23251427710056305,
+        "train loss": 0.7887908220291138,
+        "train samples": 400,
+        "train time": 313.8828013089951,
+        "eval time": 60.34160304099987,
+        "mem allocated avg": 8250921216.0,
+        "mem reserved avg": 12331253760.0,
+        "elapsed time": 751.0870177549996
+      },
+      {
+        "step": 300,
+        "valid dino_similarity": 0.23842698335647583,
+        "train loss": 0.756524384021759,
+        "train samples": 600,
+        "train time": 312.6609532600032,
+        "eval time": 60.14295816699996,
+        "mem allocated avg": 8250972416.0,
+        "mem reserved avg": 12331253760.0,
+        "elapsed time": 1124.0208598790005
+      },
+      {
+        "step": 400,
+        "valid dino_similarity": 0.23674827814102173,
+        "train loss": 0.7978895902633667,
+        "train samples": 800,
+        "train time": 313.79746225400777,
+        "eval time": 59.768734195000434,
+        "mem allocated avg": 8251023616.0,
+        "mem reserved avg": 12331253760.0,
+        "elapsed time": 1497.7177288579996
+      },
+      {
+        "step": 500,
+        "valid dino_similarity": 0.2401944398880005,
+        "train loss": 0.7880873084068298,
+        "train samples": 1000,
+        "train time": 311.6997243270107,
+        "eval time": 60.002248251999845,
+        "mem allocated avg": 8251074816.0,
+        "mem reserved avg": 12333350912.0,
+        "elapsed time": 1869.5468078870008
+      },
+      {
+        "step": 600,
+        "valid dino_similarity": 0.23682618141174316,
+        "train loss": 0.7908548712730408,
+        "train samples": 1200,
+        "train time": 312.5675929590052,
+        "eval time": 60.16887710300034,
+        "mem allocated avg": 8251126016.0,
+        "mem reserved avg": 12333350912.0,
+        "elapsed time": 2242.4114284430007
+      },
+      {
+        "step": 700,
+        "valid dino_similarity": 0.23625794053077698,
+        "train loss": 0.8072803020477295,
+        "train samples": 1400,
+        "train time": 312.00779973801036,
+        "eval time": 59.32068106599945,
+        "mem allocated avg": 8251177216.0,
+        "mem reserved avg": 12333350912.0,
+        "elapsed time": 2613.8672108870005
+      },
+      {
+        "step": 750,
+        "test dino_similarity": 0.3470671971638997,
+        "drift": 0.020928651094436646,
+        "train loss": 0.7960677742958069,
+        "train samples": 1500
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "a3b4f4849157f664bdbc776fd7453c2783562f4d",
+      "created_at": "2026-01-14T13:42:28+00:00"
+    },
+    "dataset_info": {
+      "sha": "37df3244ae3aa36e85178b6cf946338137fc3068",
+      "created_at": "2026-03-09T15:31:26+00:00"
+    },
+    "package_info": {
+      "transformers-version": "5.10.2",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.2.dev0",
+      "peft-commit-hash": "b2d61f5f80a7ac540fb572c077d8265a95986db8",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "diffusers-version": "0.38.0",
+      "diffusers-commit-hash": null,
+      "torch-version": "2.12.0+cu130",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 202002\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.11.2 (Git Hash 03c022d3ffdcee958cfacbe720048e725fdf644c)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 13.0\n  - NVCC architecture flags: -gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1  (built against CUDA 12.8)\n    - Built with CuDNN 92.0\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=7661cd9c6b841b62b7f411aa52ec51f05457263b, CUDA_FLAGS= -DLIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_OPERATIONS -Xfatbin -compress-all -DONNX_NAMESPACE=onnx_torch -gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_100,code=sm_100 -gencode arch=compute_120,code=sm_120 -Xcudafe --diag_suppress=cc_clobber_ignored,--diag_suppress=field_without_dll_interface,--diag_suppress=base_class_has_different_dll_interface,--diag_suppress=dll_interface_conflict_none_assumed,--diag_suppress=dll_interface_conflict_dllexport_assumed,--diag_suppress=bad_friend_decl --expt-relaxed-constexpr --expt-extended-lambda -Xfatbin -compress-all --threads 2 -compress-mode=size -Wno-deprecated-gpu-targets --expt-extended-lambda -DCUB_WRAPPED_NAMESPACE=at_cuda_detail -DDISABLE_CUSPARSE_DEPRECATED -DCUDA_HAS_FP16=1 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -DC10_NODEPRECATED, CUDA_VERSION=13.0, CUDNN_VERSION=9.20.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_MSLK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.12.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/results/full-finetuning--flux2-klein-default.json b/method_comparison/image-gen/results/full-finetuning--flux2-klein-default.json
new file mode 100644
index 0000000..0fde0e9
--- /dev/null
+++ b/method_comparison/image-gen/results/full-finetuning--flux2-klein-default.json
@@ -0,0 +1,175 @@
+{
+  "run_info": {
+    "created_at": "2026-06-09T12:45:29+00:00",
+    "total_time": 332.58792443999846,
+    "experiment_name": "full-finetuning/flux2-klein-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "black-forest-labs/FLUX.2-klein-base-4B",
+      "dataset_id": "peft-internal-testing/cat-image-dataset",
+      "dataset_split": "train",
+      "dtype": "bfloat16",
+      "resolution": 512,
+      "batch_size": 2,
+      "batch_size_eval": 1,
+      "repeats": 1000,
+      "max_steps": 300,
+      "eval_steps": 100,
+      "compile": false,
+      "use_gc": true,
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 5e-05,
+        "weight_decay": 0.01
+      },
+      "lr_scheduler": null,
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "instance_prompts": [
+        "sks cat sitting on a chair in front of a box of chocolates",
+        "sks cat playing on the Steam Deck",
+        "sks cat wearing a necklace while sitting in a box on a sofa",
+        "a box with four donuts in front of sks cat",
+        "sks cat wearing a pink veil with flowers on it and a dagger made out of yellow cardboard",
+        "sks cat between two pillows, with one pillow showing a polar bear and the other a fox",
+        "sks cat with an espresso reading the newspaper",
+        "a close up of a hand petting sks cat on the head",
+        "sks cat opens a white door",
+        "sks cat with a VIP \"all access\" pass",
+        "sks cat in front of a monitor showing the video game \"RimWorld\"",
+        "sks cat reads a newspaper about cannabis",
+        "sks cat reading the newspaper with the title \"DIE BOX\"",
+        "sks cat being fed sushi",
+        "sks cat in front of a box of tomatoes",
+        "a gingerbread house in front of sks cat",
+        "sks cat is wearing a Wednesday Addams costume",
+        "sks cat looks skeptical as he reads a magazine depicting a black cat",
+        "sks cat wearing a striped scarf",
+        "sleepy sks cat lying in bed covered by a blue blanket"
+      ],
+      "image_column": "image",
+      "valid_size": 2,
+      "test_size": 4,
+      "num_inference_steps": 20,
+      "guidance_scale": 3.5,
+      "max_sequence_length": 512,
+      "text_encoder_out_layers": [
+        10,
+        20,
+        30
+      ],
+      "weighting_scheme": "none",
+      "logit_mean": 0.0,
+      "logit_std": 1.0,
+      "mode_scale": 1.29,
+      "dino_model_id": "facebook/dinov2-base",
+      "dino_image_size": 224,
+      "sample_image_prompts": [
+        "a photo of sks cat",
+        "a color drawing of sks cat",
+        "sks cat at the beach",
+        "a photo of sks dog",
+        "a photo of an orange cat"
+      ],
+      "drift_image_prompts": [
+        "a photo of cat",
+        "a color drawing of cat",
+        "cat sitting in a bathtub",
+        "cat looks into a mirror",
+        "a photo of cat next to a tree",
+        "the Mona Lisa but she looks angry",
+        "a dog holding a sign that says hello world",
+        "a photo of the Eiffel tower at night",
+        "an astronaut riding a horse",
+        "3d design concept of a chair that looks like an avocado"
+      ]
+    },
+    "peft_config": null,
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 39598955342,
+    "accelerator_memory_max": 39873150976,
+    "accelerator_memory_reserved_99th": 39873150976,
+    "train_time": 292.64274606599975,
+    "file_size": 7751089152,
+    "num_trainable_params": 3875544576,
+    "num_total_params": 3875544576,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 100,
+        "valid dino_similarity": 0.4664556384086609,
+        "train loss": 0.8419304490089417,
+        "train samples": 200,
+        "train time": 81.78444452700751,
+        "eval time": 10.999330701000872,
+        "mem allocated avg": 31504182528.0,
+        "mem reserved avg": 39868830842.88,
+        "elapsed time": 99.13223672999993
+      },
+      {
+        "step": 200,
+        "valid dino_similarity": 0.6875627636909485,
+        "train loss": 0.7423853278160095,
+        "train samples": 400,
+        "train time": 81.73474228500163,
+        "eval time": 10.876023070999508,
+        "mem allocated avg": 31504759040.0,
+        "mem reserved avg": 39500235407.36,
+        "elapsed time": 191.849609805
+      },
+      {
+        "step": 300,
+        "valid dino_similarity": 0.7013698816299438,
+        "train loss": 0.6884036064147949,
+        "train samples": 600,
+        "train time": 83.54427255299561,
+        "eval time": 11.215265328999521,
+        "mem allocated avg": 31504285952.0,
+        "mem reserved avg": 39427799777.28,
+        "elapsed time": 286.7287876620012
+      },
+      {
+        "step": 300,
+        "test dino_similarity": 0.5767437418301901,
+        "drift": NaN,
+        "train loss": 0.6884036064147949,
+        "train samples": 600
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "a3b4f4849157f664bdbc776fd7453c2783562f4d",
+      "created_at": "2026-01-14T13:42:28+00:00"
+    },
+    "dataset_info": {
+      "sha": "37df3244ae3aa36e85178b6cf946338137fc3068",
+      "created_at": "2026-03-09T15:31:26+00:00"
+    },
+    "package_info": {
+      "transformers-version": "5.10.2",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.2.dev0",
+      "peft-commit-hash": "b2d61f5f80a7ac540fb572c077d8265a95986db8",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "diffusers-version": "0.38.0",
+      "diffusers-commit-hash": null,
+      "torch-version": "2.12.0+cu130",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 202002\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.11.2 (Git Hash 03c022d3ffdcee958cfacbe720048e725fdf644c)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 13.0\n  - NVCC architecture flags: -gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1  (built against CUDA 12.8)\n    - Built with CuDNN 92.0\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=7661cd9c6b841b62b7f411aa52ec51f05457263b, CUDA_FLAGS= -DLIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_OPERATIONS -Xfatbin -compress-all -DONNX_NAMESPACE=onnx_torch -gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_100,code=sm_100 -gencode arch=compute_120,code=sm_120 -Xcudafe --diag_suppress=cc_clobber_ignored,--diag_suppress=field_without_dll_interface,--diag_suppress=base_class_has_different_dll_interface,--diag_suppress=dll_interface_conflict_none_assumed,--diag_suppress=dll_interface_conflict_dllexport_assumed,--diag_suppress=bad_friend_decl --expt-relaxed-constexpr --expt-extended-lambda -Xfatbin -compress-all --threads 2 -compress-mode=size -Wno-deprecated-gpu-targets --expt-extended-lambda -DCUB_WRAPPED_NAMESPACE=at_cuda_detail -DDISABLE_CUSPARSE_DEPRECATED -DCUDA_HAS_FP16=1 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -DC10_NODEPRECATED, CUDA_VERSION=13.0, CUDNN_VERSION=9.20.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_MSLK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.12.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/results/gralora--flux2-klein-default.json b/method_comparison/image-gen/results/gralora--flux2-klein-default.json
new file mode 100644
index 0000000..7fbc5ba
--- /dev/null
+++ b/method_comparison/image-gen/results/gralora--flux2-klein-default.json
@@ -0,0 +1,251 @@
+{
+  "run_info": {
+    "created_at": "2026-06-09T12:52:34+00:00",
+    "total_time": 842.1583462019989,
+    "experiment_name": "gralora/flux2-klein-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "black-forest-labs/FLUX.2-klein-base-4B",
+      "dataset_id": "peft-internal-testing/cat-image-dataset",
+      "dataset_split": "train",
+      "dtype": "bfloat16",
+      "resolution": 512,
+      "batch_size": 2,
+      "batch_size_eval": 1,
+      "repeats": 1000,
+      "max_steps": 750,
+      "eval_steps": 100,
+      "compile": false,
+      "use_gc": true,
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.0001
+      },
+      "lr_scheduler": null,
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "instance_prompts": [
+        "sks cat sitting on a chair in front of a box of chocolates",
+        "sks cat playing on the Steam Deck",
+        "sks cat wearing a necklace while sitting in a box on a sofa",
+        "a box with four donuts in front of sks cat",
+        "sks cat wearing a pink veil with flowers on it and a dagger made out of yellow cardboard",
+        "sks cat between two pillows, with one pillow showing a polar bear and the other a fox",
+        "sks cat with an espresso reading the newspaper",
+        "a close up of a hand petting sks cat on the head",
+        "sks cat opens a white door",
+        "sks cat with a VIP \"all access\" pass",
+        "sks cat in front of a monitor showing the video game \"RimWorld\"",
+        "sks cat reads a newspaper about cannabis",
+        "sks cat reading the newspaper with the title \"DIE BOX\"",
+        "sks cat being fed sushi",
+        "sks cat in front of a box of tomatoes",
+        "a gingerbread house in front of sks cat",
+        "sks cat is wearing a Wednesday Addams costume",
+        "sks cat looks skeptical as he reads a magazine depicting a black cat",
+        "sks cat wearing a striped scarf",
+        "sleepy sks cat lying in bed covered by a blue blanket"
+      ],
+      "image_column": "image",
+      "valid_size": 2,
+      "test_size": 4,
+      "num_inference_steps": 20,
+      "guidance_scale": 3.5,
+      "max_sequence_length": 512,
+      "text_encoder_out_layers": [
+        10,
+        20,
+        30
+      ],
+      "weighting_scheme": "none",
+      "logit_mean": 0.0,
+      "logit_std": 1.0,
+      "mode_scale": 1.29,
+      "dino_model_id": "facebook/dinov2-base",
+      "dino_image_size": 224,
+      "sample_image_prompts": [
+        "a photo of sks cat",
+        "a color drawing of sks cat",
+        "sks cat at the beach",
+        "a photo of sks dog",
+        "a photo of an orange cat"
+      ],
+      "drift_image_prompts": [
+        "a photo of cat",
+        "a color drawing of cat",
+        "cat sitting in a bathtub",
+        "cat looks into a mirror",
+        "a photo of cat next to a tree",
+        "the Mona Lisa but she looks angry",
+        "a dog holding a sign that says hello world",
+        "a photo of the Eiffel tower at night",
+        "an astronaut riding a horse",
+        "3d design concept of a chair that looks like an avocado"
+      ]
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "GRALORA",
+      "auto_mapping": null,
+      "peft_version": "0.18.2.dev0@UNKNOWN",
+      "base_model_name_or_path": null,
+      "revision": null,
+      "inference_mode": false,
+      "r": 32,
+      "hybrid_r": 0,
+      "target_modules": [
+        "add_q_proj",
+        "to_qkv_mlp_proj",
+        "add_v_proj",
+        "to_v",
+        "to_q",
+        "to_out.0",
+        "linear_out",
+        "linear_in",
+        "to_add_out",
+        "to_k",
+        "add_k_proj"
+      ],
+      "alpha": 32,
+      "gralora_dropout": 0.0,
+      "gralora_k": 2,
+      "fan_in_fan_out": false,
+      "bias": "none",
+      "modules_to_save": null,
+      "init_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 10697790455,
+    "accelerator_memory_max": 10729029632,
+    "accelerator_memory_reserved_99th": 10729029632,
+    "train_time": 727.7293240400013,
+    "file_size": 153376720,
+    "num_trainable_params": 38338560,
+    "num_total_params": 3913883136,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 100,
+        "valid dino_similarity": 0.6739842891693115,
+        "train loss": 0.7580073475837708,
+        "train samples": 200,
+        "train time": 75.19663646300069,
+        "eval time": 14.99915247699937,
+        "mem allocated avg": 8889542215.68,
+        "mem reserved avg": 10549471477.76,
+        "elapsed time": 96.50862428099936
+      },
+      {
+        "step": 200,
+        "valid dino_similarity": 0.749488115310669,
+        "train loss": 0.7516488432884216,
+        "train samples": 400,
+        "train time": 76.78479973799949,
+        "eval time": 15.036769996000658,
+        "mem allocated avg": 8889962752.0,
+        "mem reserved avg": 10691280896.0,
+        "elapsed time": 188.50273498299975
+      },
+      {
+        "step": 300,
+        "valid dino_similarity": 0.703209638595581,
+        "train loss": 0.7706764340400696,
+        "train samples": 600,
+        "train time": 75.92401531499308,
+        "eval time": 15.228682310000295,
+        "mem allocated avg": 8890134538.24,
+        "mem reserved avg": 10729029632.0,
+        "elapsed time": 279.82624012499946
+      },
+      {
+        "step": 400,
+        "valid dino_similarity": 0.6993591785430908,
+        "train loss": 0.7464877367019653,
+        "train samples": 800,
+        "train time": 76.98565732099814,
+        "eval time": 15.039624825998544,
+        "mem allocated avg": 8890196224.0,
+        "mem reserved avg": 10725632245.76,
+        "elapsed time": 372.02233766899917
+      },
+      {
+        "step": 500,
+        "valid dino_similarity": 0.6805363297462463,
+        "train loss": 0.6920386552810669,
+        "train samples": 1000,
+        "train time": 76.09401314199386,
+        "eval time": 15.003395664998607,
+        "mem allocated avg": 8890247424.0,
+        "mem reserved avg": 10725632245.76,
+        "elapsed time": 463.28952561299957
+      },
+      {
+        "step": 600,
+        "valid dino_similarity": 0.6731683611869812,
+        "train loss": 0.75179523229599,
+        "train samples": 1200,
+        "train time": 76.92855412300923,
+        "eval time": 15.160542954001357,
+        "mem allocated avg": 8890298624.0,
+        "mem reserved avg": 10725632245.76,
+        "elapsed time": 555.5492112809989
+      },
+      {
+        "step": 700,
+        "valid dino_similarity": 0.7281286120414734,
+        "train loss": 0.7341083884239197,
+        "train samples": 1400,
+        "train time": 77.00600361201577,
+        "eval time": 15.133347828999831,
+        "mem allocated avg": 8890349824.0,
+        "mem reserved avg": 10725632245.76,
+        "elapsed time": 647.8583568719987
+      },
+      {
+        "step": 750,
+        "test dino_similarity": 0.7006240288416544,
+        "drift": 0.2746447026729584,
+        "train loss": 0.7003306150436401,
+        "train samples": 1500
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "a3b4f4849157f664bdbc776fd7453c2783562f4d",
+      "created_at": "2026-01-14T13:42:28+00:00"
+    },
+    "dataset_info": {
+      "sha": "37df3244ae3aa36e85178b6cf946338137fc3068",
+      "created_at": "2026-03-09T15:31:26+00:00"
+    },
+    "package_info": {
+      "transformers-version": "5.10.2",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.2.dev0",
+      "peft-commit-hash": "b2d61f5f80a7ac540fb572c077d8265a95986db8",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "diffusers-version": "0.38.0",
+      "diffusers-commit-hash": null,
+      "torch-version": "2.12.0+cu130",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 202002\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.11.2 (Git Hash 03c022d3ffdcee958cfacbe720048e725fdf644c)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 13.0\n  - NVCC architecture flags: -gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1  (built against CUDA 12.8)\n    - Built with CuDNN 92.0\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=7661cd9c6b841b62b7f411aa52ec51f05457263b, CUDA_FLAGS= -DLIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_OPERATIONS -Xfatbin -compress-all -DONNX_NAMESPACE=onnx_torch -gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_100,code=sm_100 -gencode arch=compute_120,code=sm_120 -Xcudafe --diag_suppress=cc_clobber_ignored,--diag_suppress=field_without_dll_interface,--diag_suppress=base_class_has_different_dll_interface,--diag_suppress=dll_interface_conflict_none_assumed,--diag_suppress=dll_interface_conflict_dllexport_assumed,--diag_suppress=bad_friend_decl --expt-relaxed-constexpr --expt-extended-lambda -Xfatbin -compress-all --threads 2 -compress-mode=size -Wno-deprecated-gpu-targets --expt-extended-lambda -DCUB_WRAPPED_NAMESPACE=at_cuda_detail -DDISABLE_CUSPARSE_DEPRECATED -DCUDA_HAS_FP16=1 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -DC10_NODEPRECATED, CUDA_VERSION=13.0, CUDNN_VERSION=9.20.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_MSLK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.12.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/results/hra--flux2-klein-default.json b/method_comparison/image-gen/results/hra--flux2-klein-default.json
new file mode 100644
index 0000000..b7b4d17
--- /dev/null
+++ b/method_comparison/image-gen/results/hra--flux2-klein-default.json
@@ -0,0 +1,248 @@
+{
+  "run_info": {
+    "created_at": "2026-06-09T13:07:26+00:00",
+    "total_time": 11352.288050381001,
+    "experiment_name": "hra/flux2-klein-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "black-forest-labs/FLUX.2-klein-base-4B",
+      "dataset_id": "peft-internal-testing/cat-image-dataset",
+      "dataset_split": "train",
+      "dtype": "bfloat16",
+      "resolution": 512,
+      "batch_size": 2,
+      "batch_size_eval": 1,
+      "repeats": 1000,
+      "max_steps": 750,
+      "eval_steps": 100,
+      "compile": false,
+      "use_gc": true,
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.0001
+      },
+      "lr_scheduler": null,
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "instance_prompts": [
+        "sks cat sitting on a chair in front of a box of chocolates",
+        "sks cat playing on the Steam Deck",
+        "sks cat wearing a necklace while sitting in a box on a sofa",
+        "a box with four donuts in front of sks cat",
+        "sks cat wearing a pink veil with flowers on it and a dagger made out of yellow cardboard",
+        "sks cat between two pillows, with one pillow showing a polar bear and the other a fox",
+        "sks cat with an espresso reading the newspaper",
+        "a close up of a hand petting sks cat on the head",
+        "sks cat opens a white door",
+        "sks cat with a VIP \"all access\" pass",
+        "sks cat in front of a monitor showing the video game \"RimWorld\"",
+        "sks cat reads a newspaper about cannabis",
+        "sks cat reading the newspaper with the title \"DIE BOX\"",
+        "sks cat being fed sushi",
+        "sks cat in front of a box of tomatoes",
+        "a gingerbread house in front of sks cat",
+        "sks cat is wearing a Wednesday Addams costume",
+        "sks cat looks skeptical as he reads a magazine depicting a black cat",
+        "sks cat wearing a striped scarf",
+        "sleepy sks cat lying in bed covered by a blue blanket"
+      ],
+      "image_column": "image",
+      "valid_size": 2,
+      "test_size": 4,
+      "num_inference_steps": 20,
+      "guidance_scale": 3.5,
+      "max_sequence_length": 512,
+      "text_encoder_out_layers": [
+        10,
+        20,
+        30
+      ],
+      "weighting_scheme": "none",
+      "logit_mean": 0.0,
+      "logit_std": 1.0,
+      "mode_scale": 1.29,
+      "dino_model_id": "facebook/dinov2-base",
+      "dino_image_size": 224,
+      "sample_image_prompts": [
+        "a photo of sks cat",
+        "a color drawing of sks cat",
+        "sks cat at the beach",
+        "a photo of sks dog",
+        "a photo of an orange cat"
+      ],
+      "drift_image_prompts": [
+        "a photo of cat",
+        "a color drawing of cat",
+        "cat sitting in a bathtub",
+        "cat looks into a mirror",
+        "a photo of cat next to a tree",
+        "the Mona Lisa but she looks angry",
+        "a dog holding a sign that says hello world",
+        "a photo of the Eiffel tower at night",
+        "an astronaut riding a horse",
+        "3d design concept of a chair that looks like an avocado"
+      ]
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "HRA",
+      "auto_mapping": null,
+      "peft_version": "0.18.2.dev0@UNKNOWN",
+      "base_model_name_or_path": null,
+      "revision": null,
+      "inference_mode": false,
+      "r": 32,
+      "apply_GS": false,
+      "target_modules": [
+        "to_v",
+        "to_out.0",
+        "linear_in",
+        "add_v_proj",
+        "to_k",
+        "linear_out",
+        "to_qkv_mlp_proj",
+        "to_q",
+        "add_k_proj",
+        "to_add_out",
+        "add_q_proj"
+      ],
+      "exclude_modules": null,
+      "init_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "bias": "none",
+      "modules_to_save": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 33476879319,
+    "accelerator_memory_max": 47359983616,
+    "accelerator_memory_reserved_99th": 47326429184,
+    "train_time": 9824.567679766005,
+    "file_size": 39332240,
+    "num_trainable_params": 9830400,
+    "num_total_params": 3885374976,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 100,
+        "valid dino_similarity": 0.3935689628124237,
+        "train loss": 0.7713394165039062,
+        "train samples": 200,
+        "train time": 975.4857535669962,
+        "eval time": 214.68726077499923,
+        "mem allocated avg": 8422570690.56,
+        "mem reserved avg": 47323031797.76,
+        "elapsed time": 1196.5852056719996
+      },
+      {
+        "step": 200,
+        "valid dino_similarity": 0.40438196063041687,
+        "train loss": 0.7880617380142212,
+        "train samples": 400,
+        "train time": 1005.4165307220101,
+        "eval time": 216.22108728999956,
+        "mem allocated avg": 8422063237.12,
+        "mem reserved avg": 21243625472.0,
+        "elapsed time": 2418.4087825059996
+      },
+      {
+        "step": 300,
+        "valid dino_similarity": 0.505301833152771,
+        "train loss": 0.7538036704063416,
+        "train samples": 600,
+        "train time": 1004.786632051997,
+        "eval time": 215.93002987499858,
+        "mem allocated avg": 8422106572.8,
+        "mem reserved avg": 21628725493.76,
+        "elapsed time": 3639.32005733
+      },
+      {
+        "step": 400,
+        "valid dino_similarity": 0.6528792977333069,
+        "train loss": 0.7812439799308777,
+        "train samples": 800,
+        "train time": 983.9856222909948,
+        "eval time": 217.97808849899957,
+        "mem allocated avg": 8421809121.28,
+        "mem reserved avg": 47049605120.0,
+        "elapsed time": 4841.472134622001
+      },
+      {
+        "step": 500,
+        "valid dino_similarity": 0.680561363697052,
+        "train loss": 0.7429240345954895,
+        "train samples": 1000,
+        "train time": 1006.9375934079981,
+        "eval time": 215.31067393799822,
+        "mem allocated avg": 8422216837.12,
+        "mem reserved avg": 21628599664.64,
+        "elapsed time": 6063.907996018001
+      },
+      {
+        "step": 600,
+        "valid dino_similarity": 0.6747124791145325,
+        "train loss": 0.774470865726471,
+        "train samples": 1200,
+        "train time": 981.4495257950002,
+        "eval time": 217.85170519700114,
+        "mem allocated avg": 8421911521.28,
+        "mem reserved avg": 47049605120.0,
+        "elapsed time": 7263.395282030002
+      },
+      {
+        "step": 700,
+        "valid dino_similarity": 0.6752539873123169,
+        "train loss": 0.7347908020019531,
+        "train samples": 1400,
+        "train time": 1003.8321732119657,
+        "eval time": 214.7787208059999,
+        "mem allocated avg": 8422319237.12,
+        "mem reserved avg": 21628599664.64,
+        "elapsed time": 8482.191420154
+      },
+      {
+        "step": 750,
+        "test dino_similarity": 0.6441149314244589,
+        "drift": 0.2597343921661377,
+        "train loss": 0.741257905960083,
+        "train samples": 1500
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "a3b4f4849157f664bdbc776fd7453c2783562f4d",
+      "created_at": "2026-01-14T13:42:28+00:00"
+    },
+    "dataset_info": {
+      "sha": "37df3244ae3aa36e85178b6cf946338137fc3068",
+      "created_at": "2026-03-09T15:31:26+00:00"
+    },
+    "package_info": {
+      "transformers-version": "5.10.2",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.2.dev0",
+      "peft-commit-hash": "b2d61f5f80a7ac540fb572c077d8265a95986db8",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "diffusers-version": "0.38.0",
+      "diffusers-commit-hash": null,
+      "torch-version": "2.12.0+cu130",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 202002\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.11.2 (Git Hash 03c022d3ffdcee958cfacbe720048e725fdf644c)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 13.0\n  - NVCC architecture flags: -gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1  (built against CUDA 12.8)\n    - Built with CuDNN 92.0\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=7661cd9c6b841b62b7f411aa52ec51f05457263b, CUDA_FLAGS= -DLIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_OPERATIONS -Xfatbin -compress-all -DONNX_NAMESPACE=onnx_torch -gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_100,code=sm_100 -gencode arch=compute_120,code=sm_120 -Xcudafe --diag_suppress=cc_clobber_ignored,--diag_suppress=field_without_dll_interface,--diag_suppress=base_class_has_different_dll_interface,--diag_suppress=dll_interface_conflict_none_assumed,--diag_suppress=dll_interface_conflict_dllexport_assumed,--diag_suppress=bad_friend_decl --expt-relaxed-constexpr --expt-extended-lambda -Xfatbin -compress-all --threads 2 -compress-mode=size -Wno-deprecated-gpu-targets --expt-extended-lambda -DCUB_WRAPPED_NAMESPACE=at_cuda_detail -DDISABLE_CUSPARSE_DEPRECATED -DCUDA_HAS_FP16=1 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -DC10_NODEPRECATED, CUDA_VERSION=13.0, CUDNN_VERSION=9.20.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_MSLK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.12.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/results/ia3--flux2-klein-default.json b/method_comparison/image-gen/results/ia3--flux2-klein-default.json
new file mode 100644
index 0000000..81059fc
--- /dev/null
+++ b/method_comparison/image-gen/results/ia3--flux2-klein-default.json
@@ -0,0 +1,256 @@
+{
+  "run_info": {
+    "created_at": "2026-06-09T16:25:46+00:00",
+    "total_time": 567.5460167810015,
+    "experiment_name": "ia3/flux2-klein-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "black-forest-labs/FLUX.2-klein-base-4B",
+      "dataset_id": "peft-internal-testing/cat-image-dataset",
+      "dataset_split": "train",
+      "dtype": "bfloat16",
+      "resolution": 512,
+      "batch_size": 2,
+      "batch_size_eval": 1,
+      "repeats": 1000,
+      "max_steps": 750,
+      "eval_steps": 100,
+      "compile": false,
+      "use_gc": true,
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.001
+      },
+      "lr_scheduler": null,
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "instance_prompts": [
+        "sks cat sitting on a chair in front of a box of chocolates",
+        "sks cat playing on the Steam Deck",
+        "sks cat wearing a necklace while sitting in a box on a sofa",
+        "a box with four donuts in front of sks cat",
+        "sks cat wearing a pink veil with flowers on it and a dagger made out of yellow cardboard",
+        "sks cat between two pillows, with one pillow showing a polar bear and the other a fox",
+        "sks cat with an espresso reading the newspaper",
+        "a close up of a hand petting sks cat on the head",
+        "sks cat opens a white door",
+        "sks cat with a VIP \"all access\" pass",
+        "sks cat in front of a monitor showing the video game \"RimWorld\"",
+        "sks cat reads a newspaper about cannabis",
+        "sks cat reading the newspaper with the title \"DIE BOX\"",
+        "sks cat being fed sushi",
+        "sks cat in front of a box of tomatoes",
+        "a gingerbread house in front of sks cat",
+        "sks cat is wearing a Wednesday Addams costume",
+        "sks cat looks skeptical as he reads a magazine depicting a black cat",
+        "sks cat wearing a striped scarf",
+        "sleepy sks cat lying in bed covered by a blue blanket"
+      ],
+      "image_column": "image",
+      "valid_size": 2,
+      "test_size": 4,
+      "num_inference_steps": 20,
+      "guidance_scale": 3.5,
+      "max_sequence_length": 512,
+      "text_encoder_out_layers": [
+        10,
+        20,
+        30
+      ],
+      "weighting_scheme": "none",
+      "logit_mean": 0.0,
+      "logit_std": 1.0,
+      "mode_scale": 1.29,
+      "dino_model_id": "facebook/dinov2-base",
+      "dino_image_size": 224,
+      "sample_image_prompts": [
+        "a photo of sks cat",
+        "a color drawing of sks cat",
+        "sks cat at the beach",
+        "a photo of sks dog",
+        "a photo of an orange cat"
+      ],
+      "drift_image_prompts": [
+        "a photo of cat",
+        "a color drawing of cat",
+        "cat sitting in a bathtub",
+        "cat looks into a mirror",
+        "a photo of cat next to a tree",
+        "the Mona Lisa but she looks angry",
+        "a dog holding a sign that says hello world",
+        "a photo of the Eiffel tower at night",
+        "an astronaut riding a horse",
+        "3d design concept of a chair that looks like an avocado"
+      ]
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "IA3",
+      "auto_mapping": null,
+      "peft_version": "0.18.2.dev0@UNKNOWN",
+      "base_model_name_or_path": null,
+      "revision": null,
+      "inference_mode": false,
+      "target_modules": [
+        "to_add_out",
+        "to_q",
+        "linear_in",
+        "add_k_proj",
+        "to_out.0",
+        "to_v",
+        "add_q_proj",
+        "add_v_proj",
+        "linear_out",
+        "to_qkv_mlp_proj",
+        "to_k"
+      ],
+      "exclude_modules": null,
+      "feedforward_modules": [
+        "to_add_out",
+        "to_q",
+        "linear_in",
+        "add_k_proj",
+        "to_out.0",
+        "to_v",
+        "add_q_proj",
+        "add_v_proj",
+        "linear_out",
+        "to_qkv_mlp_proj",
+        "to_k"
+      ],
+      "fan_in_fan_out": false,
+      "modules_to_save": null,
+      "init_ia3_weights": true
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 9581568720,
+    "accelerator_memory_max": 9586081792,
+    "accelerator_memory_reserved_99th": 9586081792,
+    "train_time": 481.21032093000395,
+    "file_size": 1239104,
+    "num_trainable_params": 307200,
+    "num_total_params": 3875851776,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 100,
+        "valid dino_similarity": 0.49380284547805786,
+        "train loss": 0.7801996469497681,
+        "train samples": 200,
+        "train time": 48.581204912010435,
+        "eval time": 11.278404231998138,
+        "mem allocated avg": 8253162752.0,
+        "mem reserved avg": 9558630072.32,
+        "elapsed time": 66.27861895100068
+      },
+      {
+        "step": 200,
+        "valid dino_similarity": 0.5188440084457397,
+        "train loss": 0.7777436375617981,
+        "train samples": 400,
+        "train time": 49.7594184879963,
+        "eval time": 11.210596437998902,
+        "mem allocated avg": 8253214976.0,
+        "mem reserved avg": 9583984640.0,
+        "elapsed time": 127.42486473100143
+      },
+      {
+        "step": 300,
+        "valid dino_similarity": 0.5206876397132874,
+        "train loss": 0.7605413794517517,
+        "train samples": 600,
+        "train time": 48.28267652700015,
+        "eval time": 11.076319629002683,
+        "mem allocated avg": 8253266176.0,
+        "mem reserved avg": 9583984640.0,
+        "elapsed time": 186.9605119959997
+      },
+      {
+        "step": 400,
+        "valid dino_similarity": 0.4955529570579529,
+        "train loss": 0.7592432498931885,
+        "train samples": 800,
+        "train time": 48.46402570801001,
+        "eval time": 11.317557491998741,
+        "mem allocated avg": 8253317376.0,
+        "mem reserved avg": 9583984640.0,
+        "elapsed time": 246.91805185700287
+      },
+      {
+        "step": 500,
+        "valid dino_similarity": 0.5246289968490601,
+        "train loss": 0.7618659138679504,
+        "train samples": 1000,
+        "train time": 48.421547812991776,
+        "eval time": 11.279151833998185,
+        "mem allocated avg": 8253368576.0,
+        "mem reserved avg": 9586060820.48,
+        "elapsed time": 306.79395760400075
+      },
+      {
+        "step": 600,
+        "valid dino_similarity": 0.622121274471283,
+        "train loss": 0.7525745034217834,
+        "train samples": 1200,
+        "train time": 50.075348189999204,
+        "eval time": 11.385498521001864,
+        "mem allocated avg": 8253419776.0,
+        "mem reserved avg": 9586039848.96,
+        "elapsed time": 368.4307417400014
+      },
+      {
+        "step": 700,
+        "valid dino_similarity": 0.6554043292999268,
+        "train loss": 0.7743272185325623,
+        "train samples": 1400,
+        "train time": 49.96463180201317,
+        "eval time": 11.32795869599795,
+        "mem allocated avg": 8253470976.0,
+        "mem reserved avg": 9586039848.96,
+        "elapsed time": 429.8980503160019
+      },
+      {
+        "step": 750,
+        "test dino_similarity": 0.6476706067721049,
+        "drift": 0.22948315739631653,
+        "train loss": 0.7756149172782898,
+        "train samples": 1500
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "a3b4f4849157f664bdbc776fd7453c2783562f4d",
+      "created_at": "2026-01-14T13:42:28+00:00"
+    },
+    "dataset_info": {
+      "sha": "37df3244ae3aa36e85178b6cf946338137fc3068",
+      "created_at": "2026-03-09T15:31:26+00:00"
+    },
+    "package_info": {
+      "transformers-version": "5.10.2",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.2.dev0",
+      "peft-commit-hash": "b2d61f5f80a7ac540fb572c077d8265a95986db8",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "diffusers-version": "0.38.0",
+      "diffusers-commit-hash": null,
+      "torch-version": "2.12.0+cu130",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 202002\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.11.2 (Git Hash 03c022d3ffdcee958cfacbe720048e725fdf644c)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 13.0\n  - NVCC architecture flags: -gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1  (built against CUDA 12.8)\n    - Built with CuDNN 92.0\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=7661cd9c6b841b62b7f411aa52ec51f05457263b, CUDA_FLAGS= -DLIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_OPERATIONS -Xfatbin -compress-all -DONNX_NAMESPACE=onnx_torch -gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_100,code=sm_100 -gencode arch=compute_120,code=sm_120 -Xcudafe --diag_suppress=cc_clobber_ignored,--diag_suppress=field_without_dll_interface,--diag_suppress=base_class_has_different_dll_interface,--diag_suppress=dll_interface_conflict_none_assumed,--diag_suppress=dll_interface_conflict_dllexport_assumed,--diag_suppress=bad_friend_decl --expt-relaxed-constexpr --expt-extended-lambda -Xfatbin -compress-all --threads 2 -compress-mode=size -Wno-deprecated-gpu-targets --expt-extended-lambda -DCUB_WRAPPED_NAMESPACE=at_cuda_detail -DDISABLE_CUSPARSE_DEPRECATED -DCUDA_HAS_FP16=1 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -DC10_NODEPRECATED, CUDA_VERSION=13.0, CUDNN_VERSION=9.20.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_MSLK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.12.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/results/lily--flux2-klein-default.json b/method_comparison/image-gen/results/lily--flux2-klein-default.json
new file mode 100644
index 0000000..7053bca
--- /dev/null
+++ b/method_comparison/image-gen/results/lily--flux2-klein-default.json
@@ -0,0 +1,249 @@
+{
+  "run_info": {
+    "created_at": "2026-06-09T16:35:47+00:00",
+    "total_time": 778.9969721839989,
+    "experiment_name": "lily/flux2-klein-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "black-forest-labs/FLUX.2-klein-base-4B",
+      "dataset_id": "peft-internal-testing/cat-image-dataset",
+      "dataset_split": "train",
+      "dtype": "bfloat16",
+      "resolution": 512,
+      "batch_size": 2,
+      "batch_size_eval": 1,
+      "repeats": 1000,
+      "max_steps": 750,
+      "eval_steps": 100,
+      "compile": false,
+      "use_gc": true,
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.0001
+      },
+      "lr_scheduler": null,
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "instance_prompts": [
+        "sks cat sitting on a chair in front of a box of chocolates",
+        "sks cat playing on the Steam Deck",
+        "sks cat wearing a necklace while sitting in a box on a sofa",
+        "a box with four donuts in front of sks cat",
+        "sks cat wearing a pink veil with flowers on it and a dagger made out of yellow cardboard",
+        "sks cat between two pillows, with one pillow showing a polar bear and the other a fox",
+        "sks cat with an espresso reading the newspaper",
+        "a close up of a hand petting sks cat on the head",
+        "sks cat opens a white door",
+        "sks cat with a VIP \"all access\" pass",
+        "sks cat in front of a monitor showing the video game \"RimWorld\"",
+        "sks cat reads a newspaper about cannabis",
+        "sks cat reading the newspaper with the title \"DIE BOX\"",
+        "sks cat being fed sushi",
+        "sks cat in front of a box of tomatoes",
+        "a gingerbread house in front of sks cat",
+        "sks cat is wearing a Wednesday Addams costume",
+        "sks cat looks skeptical as he reads a magazine depicting a black cat",
+        "sks cat wearing a striped scarf",
+        "sleepy sks cat lying in bed covered by a blue blanket"
+      ],
+      "image_column": "image",
+      "valid_size": 2,
+      "test_size": 4,
+      "num_inference_steps": 20,
+      "guidance_scale": 3.5,
+      "max_sequence_length": 512,
+      "text_encoder_out_layers": [
+        10,
+        20,
+        30
+      ],
+      "weighting_scheme": "none",
+      "logit_mean": 0.0,
+      "logit_std": 1.0,
+      "mode_scale": 1.29,
+      "dino_model_id": "facebook/dinov2-base",
+      "dino_image_size": 224,
+      "sample_image_prompts": [
+        "a photo of sks cat",
+        "a color drawing of sks cat",
+        "sks cat at the beach",
+        "a photo of sks dog",
+        "a photo of an orange cat"
+      ],
+      "drift_image_prompts": [
+        "a photo of cat",
+        "a color drawing of cat",
+        "cat sitting in a bathtub",
+        "cat looks into a mirror",
+        "a photo of cat next to a tree",
+        "the Mona Lisa but she looks angry",
+        "a dog holding a sign that says hello world",
+        "a photo of the Eiffel tower at night",
+        "an astronaut riding a horse",
+        "3d design concept of a chair that looks like an avocado"
+      ]
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "LILY",
+      "auto_mapping": null,
+      "peft_version": "0.18.2.dev0@UNKNOWN",
+      "base_model_name_or_path": null,
+      "revision": null,
+      "inference_mode": false,
+      "r": 32,
+      "stride_A": 1,
+      "num_B": 2,
+      "scaling": 1.0,
+      "target_modules": [
+        "to_v",
+        "add_q_proj",
+        "to_k",
+        "linear_in",
+        "to_qkv_mlp_proj",
+        "to_out.0",
+        "linear_out",
+        "to_q",
+        "add_v_proj",
+        "to_add_out",
+        "add_k_proj"
+      ],
+      "exclude_modules": null,
+      "modules_to_save": null,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "init_weights": true
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 10353219993,
+    "accelerator_memory_max": 10624172032,
+    "accelerator_memory_reserved_99th": 10624172032,
+    "train_time": 672.2888688070016,
+    "file_size": 267441872,
+    "num_trainable_params": 14554112,
+    "num_total_params": 3890098688,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 100,
+        "valid dino_similarity": 0.6070808172225952,
+        "train loss": 0.7675283551216125,
+        "train samples": 200,
+        "train time": 70.0470120739883,
+        "eval time": 14.032050149999122,
+        "mem allocated avg": 8498626529.28,
+        "mem reserved avg": 10624172032.0,
+        "elapsed time": 90.47279821199845
+      },
+      {
+        "step": 200,
+        "valid dino_similarity": 0.4357416331768036,
+        "train loss": 0.7790729999542236,
+        "train samples": 400,
+        "train time": 70.63589557400337,
+        "eval time": 13.93063749599969,
+        "mem allocated avg": 8498938275.84,
+        "mem reserved avg": 10322182144.0,
+        "elapsed time": 175.20335154200075
+      },
+      {
+        "step": 300,
+        "valid dino_similarity": 0.6283349394798279,
+        "train loss": 0.7653467655181885,
+        "train samples": 600,
+        "train time": 69.96707829796651,
+        "eval time": 14.101693201999296,
+        "mem allocated avg": 8498989475.84,
+        "mem reserved avg": 10309599232.0,
+        "elapsed time": 259.4440229739994
+      },
+      {
+        "step": 400,
+        "valid dino_similarity": 0.666422426700592,
+        "train loss": 0.7454532384872437,
+        "train samples": 800,
+        "train time": 70.52299569199022,
+        "eval time": 13.968654183998297,
+        "mem allocated avg": 8499044608.0,
+        "mem reserved avg": 10309599232.0,
+        "elapsed time": 344.10800371499863
+      },
+      {
+        "step": 500,
+        "valid dino_similarity": 0.7739129662513733,
+        "train loss": 0.7524172067642212,
+        "train samples": 1000,
+        "train time": 69.86184318899177,
+        "eval time": 14.091436128001078,
+        "mem allocated avg": 8499095808.0,
+        "mem reserved avg": 10309599232.0,
+        "elapsed time": 428.2334366299983
+      },
+      {
+        "step": 600,
+        "valid dino_similarity": 0.7248525619506836,
+        "train loss": 0.7564569115638733,
+        "train samples": 1200,
+        "train time": 70.67204485599723,
+        "eval time": 14.046395477998885,
+        "mem allocated avg": 8499147008.0,
+        "mem reserved avg": 10309599232.0,
+        "elapsed time": 513.1228886579993
+      },
+      {
+        "step": 700,
+        "valid dino_similarity": 0.7019336223602295,
+        "train loss": 0.7319736480712891,
+        "train samples": 1400,
+        "train time": 70.33111688801364,
+        "eval time": 14.19260858800044,
+        "mem allocated avg": 8499198208.0,
+        "mem reserved avg": 10309599232.0,
+        "elapsed time": 597.816346222
+      },
+      {
+        "step": 750,
+        "test dino_similarity": 0.648700992266337,
+        "drift": 0.2646396607160568,
+        "train loss": 0.7380563020706177,
+        "train samples": 1500
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "a3b4f4849157f664bdbc776fd7453c2783562f4d",
+      "created_at": "2026-01-14T13:42:28+00:00"
+    },
+    "dataset_info": {
+      "sha": "37df3244ae3aa36e85178b6cf946338137fc3068",
+      "created_at": "2026-03-09T15:31:26+00:00"
+    },
+    "package_info": {
+      "transformers-version": "5.10.2",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.2.dev0",
+      "peft-commit-hash": "b2d61f5f80a7ac540fb572c077d8265a95986db8",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "diffusers-version": "0.38.0",
+      "diffusers-commit-hash": null,
+      "torch-version": "2.12.0+cu130",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 202002\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.11.2 (Git Hash 03c022d3ffdcee958cfacbe720048e725fdf644c)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 13.0\n  - NVCC architecture flags: -gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1  (built against CUDA 12.8)\n    - Built with CuDNN 92.0\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=7661cd9c6b841b62b7f411aa52ec51f05457263b, CUDA_FLAGS= -DLIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_OPERATIONS -Xfatbin -compress-all -DONNX_NAMESPACE=onnx_torch -gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_100,code=sm_100 -gencode arch=compute_120,code=sm_120 -Xcudafe --diag_suppress=cc_clobber_ignored,--diag_suppress=field_without_dll_interface,--diag_suppress=base_class_has_different_dll_interface,--diag_suppress=dll_interface_conflict_none_assumed,--diag_suppress=dll_interface_conflict_dllexport_assumed,--diag_suppress=bad_friend_decl --expt-relaxed-constexpr --expt-extended-lambda -Xfatbin -compress-all --threads 2 -compress-mode=size -Wno-deprecated-gpu-targets --expt-extended-lambda -DCUB_WRAPPED_NAMESPACE=at_cuda_detail -DDISABLE_CUSPARSE_DEPRECATED -DCUDA_HAS_FP16=1 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -DC10_NODEPRECATED, CUDA_VERSION=13.0, CUDNN_VERSION=9.20.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_MSLK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.12.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/results/ln_tuning--flux2-klein-default.json b/method_comparison/image-gen/results/ln_tuning--flux2-klein-default.json
new file mode 100644
index 0000000..41f1a08
--- /dev/null
+++ b/method_comparison/image-gen/results/ln_tuning--flux2-klein-default.json
@@ -0,0 +1,233 @@
+{
+  "run_info": {
+    "created_at": "2026-06-09T16:49:31+00:00",
+    "total_time": 543.2387640779998,
+    "experiment_name": "ln_tuning/flux2-klein-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "black-forest-labs/FLUX.2-klein-base-4B",
+      "dataset_id": "peft-internal-testing/cat-image-dataset",
+      "dataset_split": "train",
+      "dtype": "bfloat16",
+      "resolution": 512,
+      "batch_size": 2,
+      "batch_size_eval": 1,
+      "repeats": 1000,
+      "max_steps": 750,
+      "eval_steps": 100,
+      "compile": false,
+      "use_gc": true,
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.0001
+      },
+      "lr_scheduler": null,
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "instance_prompts": [
+        "sks cat sitting on a chair in front of a box of chocolates",
+        "sks cat playing on the Steam Deck",
+        "sks cat wearing a necklace while sitting in a box on a sofa",
+        "a box with four donuts in front of sks cat",
+        "sks cat wearing a pink veil with flowers on it and a dagger made out of yellow cardboard",
+        "sks cat between two pillows, with one pillow showing a polar bear and the other a fox",
+        "sks cat with an espresso reading the newspaper",
+        "a close up of a hand petting sks cat on the head",
+        "sks cat opens a white door",
+        "sks cat with a VIP \"all access\" pass",
+        "sks cat in front of a monitor showing the video game \"RimWorld\"",
+        "sks cat reads a newspaper about cannabis",
+        "sks cat reading the newspaper with the title \"DIE BOX\"",
+        "sks cat being fed sushi",
+        "sks cat in front of a box of tomatoes",
+        "a gingerbread house in front of sks cat",
+        "sks cat is wearing a Wednesday Addams costume",
+        "sks cat looks skeptical as he reads a magazine depicting a black cat",
+        "sks cat wearing a striped scarf",
+        "sleepy sks cat lying in bed covered by a blue blanket"
+      ],
+      "image_column": "image",
+      "valid_size": 2,
+      "test_size": 4,
+      "num_inference_steps": 20,
+      "guidance_scale": 3.5,
+      "max_sequence_length": 512,
+      "text_encoder_out_layers": [
+        10,
+        20,
+        30
+      ],
+      "weighting_scheme": "none",
+      "logit_mean": 0.0,
+      "logit_std": 1.0,
+      "mode_scale": 1.29,
+      "dino_model_id": "facebook/dinov2-base",
+      "dino_image_size": 224,
+      "sample_image_prompts": [
+        "a photo of sks cat",
+        "a color drawing of sks cat",
+        "sks cat at the beach",
+        "a photo of sks dog",
+        "a photo of an orange cat"
+      ],
+      "drift_image_prompts": [
+        "a photo of cat",
+        "a color drawing of cat",
+        "cat sitting in a bathtub",
+        "cat looks into a mirror",
+        "a photo of cat next to a tree",
+        "the Mona Lisa but she looks angry",
+        "a dog holding a sign that says hello world",
+        "a photo of the Eiffel tower at night",
+        "an astronaut riding a horse",
+        "3d design concept of a chair that looks like an avocado"
+      ]
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "LN_TUNING",
+      "auto_mapping": null,
+      "peft_version": "0.18.2.dev0@UNKNOWN",
+      "base_model_name_or_path": null,
+      "revision": null,
+      "inference_mode": false,
+      "target_modules": [
+        "norm_q",
+        "norm_k"
+      ],
+      "exclude_modules": null,
+      "modules_to_save": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 9507611956,
+    "accelerator_memory_max": 9609150464,
+    "accelerator_memory_reserved_99th": 9609150464,
+    "train_time": 458.36126944199714,
+    "file_size": 19856,
+    "num_trainable_params": 6400,
+    "num_total_params": 3875550976,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 100,
+        "valid dino_similarity": 0.23442742228507996,
+        "train loss": 0.7641636729240417,
+        "train samples": 200,
+        "train time": 46.04698378296962,
+        "eval time": 10.920204599999124,
+        "mem allocated avg": 8248349952.0,
+        "mem reserved avg": 9608018001.92,
+        "elapsed time": 63.40611588700267
+      },
+      {
+        "step": 200,
+        "valid dino_similarity": 0.23442742228507996,
+        "train loss": 0.7805964350700378,
+        "train samples": 400,
+        "train time": 45.210095621026994,
+        "eval time": 10.871550175001175,
+        "mem allocated avg": 8248402176.0,
+        "mem reserved avg": 9491647037.44,
+        "elapsed time": 119.66236585400111
+      },
+      {
+        "step": 300,
+        "valid dino_similarity": 0.23442742228507996,
+        "train loss": 0.7823051810264587,
+        "train samples": 600,
+        "train time": 45.0966384820058,
+        "eval time": 10.959132864001731,
+        "mem allocated avg": 8248453376.0,
+        "mem reserved avg": 9491709952.0,
+        "elapsed time": 175.895315683003
+      },
+      {
+        "step": 400,
+        "valid dino_similarity": 0.23442742228507996,
+        "train loss": 0.7721166014671326,
+        "train samples": 800,
+        "train time": 46.07233880298736,
+        "eval time": 11.31159036399913,
+        "mem allocated avg": 8248504576.0,
+        "mem reserved avg": 9491709952.0,
+        "elapsed time": 233.45644162700046
+      },
+      {
+        "step": 500,
+        "valid dino_similarity": 0.23442742228507996,
+        "train loss": 0.7923752665519714,
+        "train samples": 1000,
+        "train time": 47.02052211400223,
+        "eval time": 11.155478143999062,
+        "mem allocated avg": 8248555776.0,
+        "mem reserved avg": 9491709952.0,
+        "elapsed time": 291.80939455000043
+      },
+      {
+        "step": 600,
+        "valid dino_similarity": 0.23442742228507996,
+        "train loss": 0.7668710350990295,
+        "train samples": 1200,
+        "train time": 47.0293898890086,
+        "eval time": 11.291325976002554,
+        "mem allocated avg": 8248606976.0,
+        "mem reserved avg": 9491709952.0,
+        "elapsed time": 350.30722520700147
+      },
+      {
+        "step": 700,
+        "valid dino_similarity": 0.23442742228507996,
+        "train loss": 0.7979573011398315,
+        "train samples": 1400,
+        "train time": 47.517487015997176,
+        "eval time": 11.229091754001274,
+        "mem allocated avg": 8248658176.0,
+        "mem reserved avg": 9493744189.44,
+        "elapsed time": 409.2287362370007
+      },
+      {
+        "step": 750,
+        "test dino_similarity": 0.34151384234428406,
+        "drift": 0.0,
+        "train loss": 0.7861427664756775,
+        "train samples": 1500
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "a3b4f4849157f664bdbc776fd7453c2783562f4d",
+      "created_at": "2026-01-14T13:42:28+00:00"
+    },
+    "dataset_info": {
+      "sha": "37df3244ae3aa36e85178b6cf946338137fc3068",
+      "created_at": "2026-03-09T15:31:26+00:00"
+    },
+    "package_info": {
+      "transformers-version": "5.10.2",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.2.dev0",
+      "peft-commit-hash": "b2d61f5f80a7ac540fb572c077d8265a95986db8",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "diffusers-version": "0.38.0",
+      "diffusers-commit-hash": null,
+      "torch-version": "2.12.0+cu130",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 202002\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.11.2 (Git Hash 03c022d3ffdcee958cfacbe720048e725fdf644c)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 13.0\n  - NVCC architecture flags: -gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1  (built against CUDA 12.8)\n    - Built with CuDNN 92.0\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=7661cd9c6b841b62b7f411aa52ec51f05457263b, CUDA_FLAGS= -DLIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_OPERATIONS -Xfatbin -compress-all -DONNX_NAMESPACE=onnx_torch -gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_100,code=sm_100 -gencode arch=compute_120,code=sm_120 -Xcudafe --diag_suppress=cc_clobber_ignored,--diag_suppress=field_without_dll_interface,--diag_suppress=base_class_has_different_dll_interface,--diag_suppress=dll_interface_conflict_none_assumed,--diag_suppress=dll_interface_conflict_dllexport_assumed,--diag_suppress=bad_friend_decl --expt-relaxed-constexpr --expt-extended-lambda -Xfatbin -compress-all --threads 2 -compress-mode=size -Wno-deprecated-gpu-targets --expt-extended-lambda -DCUB_WRAPPED_NAMESPACE=at_cuda_detail -DDISABLE_CUSPARSE_DEPRECATED -DCUDA_HAS_FP16=1 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -DC10_NODEPRECATED, CUDA_VERSION=13.0, CUDNN_VERSION=9.20.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_MSLK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.12.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/results/loha--flux2-klein-default.json b/method_comparison/image-gen/results/loha--flux2-klein-default.json
new file mode 100644
index 0000000..5362d4d
--- /dev/null
+++ b/method_comparison/image-gen/results/loha--flux2-klein-default.json
@@ -0,0 +1,252 @@
+{
+  "run_info": {
+    "created_at": "2026-06-09T16:59:06+00:00",
+    "total_time": 2558.5494575390003,
+    "experiment_name": "loha/flux2-klein-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "black-forest-labs/FLUX.2-klein-base-4B",
+      "dataset_id": "peft-internal-testing/cat-image-dataset",
+      "dataset_split": "train",
+      "dtype": "bfloat16",
+      "resolution": 512,
+      "batch_size": 2,
+      "batch_size_eval": 1,
+      "repeats": 1000,
+      "max_steps": 750,
+      "eval_steps": 100,
+      "compile": false,
+      "use_gc": true,
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.0001
+      },
+      "lr_scheduler": null,
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "instance_prompts": [
+        "sks cat sitting on a chair in front of a box of chocolates",
+        "sks cat playing on the Steam Deck",
+        "sks cat wearing a necklace while sitting in a box on a sofa",
+        "a box with four donuts in front of sks cat",
+        "sks cat wearing a pink veil with flowers on it and a dagger made out of yellow cardboard",
+        "sks cat between two pillows, with one pillow showing a polar bear and the other a fox",
+        "sks cat with an espresso reading the newspaper",
+        "a close up of a hand petting sks cat on the head",
+        "sks cat opens a white door",
+        "sks cat with a VIP \"all access\" pass",
+        "sks cat in front of a monitor showing the video game \"RimWorld\"",
+        "sks cat reads a newspaper about cannabis",
+        "sks cat reading the newspaper with the title \"DIE BOX\"",
+        "sks cat being fed sushi",
+        "sks cat in front of a box of tomatoes",
+        "a gingerbread house in front of sks cat",
+        "sks cat is wearing a Wednesday Addams costume",
+        "sks cat looks skeptical as he reads a magazine depicting a black cat",
+        "sks cat wearing a striped scarf",
+        "sleepy sks cat lying in bed covered by a blue blanket"
+      ],
+      "image_column": "image",
+      "valid_size": 2,
+      "test_size": 4,
+      "num_inference_steps": 20,
+      "guidance_scale": 3.5,
+      "max_sequence_length": 512,
+      "text_encoder_out_layers": [
+        10,
+        20,
+        30
+      ],
+      "weighting_scheme": "none",
+      "logit_mean": 0.0,
+      "logit_std": 1.0,
+      "mode_scale": 1.29,
+      "dino_model_id": "facebook/dinov2-base",
+      "dino_image_size": 224,
+      "sample_image_prompts": [
+        "a photo of sks cat",
+        "a color drawing of sks cat",
+        "sks cat at the beach",
+        "a photo of sks dog",
+        "a photo of an orange cat"
+      ],
+      "drift_image_prompts": [
+        "a photo of cat",
+        "a color drawing of cat",
+        "cat sitting in a bathtub",
+        "cat looks into a mirror",
+        "a photo of cat next to a tree",
+        "the Mona Lisa but she looks angry",
+        "a dog holding a sign that says hello world",
+        "a photo of the Eiffel tower at night",
+        "an astronaut riding a horse",
+        "3d design concept of a chair that looks like an avocado"
+      ]
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "LOHA",
+      "auto_mapping": null,
+      "peft_version": "0.18.2.dev0@UNKNOWN",
+      "base_model_name_or_path": null,
+      "revision": null,
+      "inference_mode": false,
+      "rank_pattern": {},
+      "alpha_pattern": {},
+      "r": 32,
+      "alpha": 32,
+      "rank_dropout": 0.0,
+      "module_dropout": 0.0,
+      "use_effective_conv2d": false,
+      "target_modules": [
+        "to_k",
+        "to_v",
+        "to_add_out",
+        "add_q_proj",
+        "to_qkv_mlp_proj",
+        "linear_in",
+        "add_k_proj",
+        "linear_out",
+        "add_v_proj",
+        "to_q",
+        "to_out.0"
+      ],
+      "exclude_modules": null,
+      "init_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "modules_to_save": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 12691359924,
+    "accelerator_memory_max": 12691963904,
+    "accelerator_memory_reserved_99th": 12691963904,
+    "train_time": 2281.250607946,
+    "file_size": 306753024,
+    "num_trainable_params": 76677120,
+    "num_total_params": 3952221696,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 100,
+        "valid dino_similarity": 0.22847065329551697,
+        "train loss": 0.7626215219497681,
+        "train samples": 200,
+        "train time": 244.32984093400955,
+        "eval time": 37.908254496000154,
+        "mem allocated avg": 9512921958.4,
+        "mem reserved avg": 12687434055.68,
+        "elapsed time": 288.58306505499786
+      },
+      {
+        "step": 200,
+        "valid dino_similarity": 0.25594696402549744,
+        "train loss": 0.7775982618331909,
+        "train samples": 400,
+        "train time": 251.63487407098364,
+        "eval time": 38.95378195200101,
+        "mem allocated avg": 9512993843.2,
+        "mem reserved avg": 12691963904.0,
+        "elapsed time": 579.3490791219992
+      },
+      {
+        "step": 300,
+        "valid dino_similarity": 0.3154636323451996,
+        "train loss": 0.7827888131141663,
+        "train samples": 600,
+        "train time": 249.68287572700865,
+        "eval time": 38.7372632229999,
+        "mem allocated avg": 9513064704.0,
+        "mem reserved avg": 12691963904.0,
+        "elapsed time": 867.9467900079981
+      },
+      {
+        "step": 400,
+        "valid dino_similarity": 0.4358249008655548,
+        "train loss": 0.7898567318916321,
+        "train samples": 800,
+        "train time": 246.24643201201252,
+        "eval time": 38.25651693499822,
+        "mem allocated avg": 9513115904.0,
+        "mem reserved avg": 12691963904.0,
+        "elapsed time": 1152.6263369389999
+      },
+      {
+        "step": 500,
+        "valid dino_similarity": 0.5530052781105042,
+        "train loss": 0.7831920981407166,
+        "train samples": 1000,
+        "train time": 245.25568974099224,
+        "eval time": 38.31664991700018,
+        "mem allocated avg": 9513167104.0,
+        "mem reserved avg": 12691963904.0,
+        "elapsed time": 1436.374709202999
+      },
+      {
+        "step": 600,
+        "valid dino_similarity": 0.6406006813049316,
+        "train loss": 0.7784250378608704,
+        "train samples": 1200,
+        "train time": 251.48792899996988,
+        "eval time": 38.53936481599885,
+        "mem allocated avg": 9513218304.0,
+        "mem reserved avg": 12691963904.0,
+        "elapsed time": 1726.5780598949968
+      },
+      {
+        "step": 700,
+        "valid dino_similarity": 0.6465485692024231,
+        "train loss": 0.7613089084625244,
+        "train samples": 1400,
+        "train time": 246.61414608899577,
+        "eval time": 38.75038342699918,
+        "mem allocated avg": 9513269504.0,
+        "mem reserved avg": 12691963904.0,
+        "elapsed time": 2012.1220225299985
+      },
+      {
+        "step": 750,
+        "test dino_similarity": 0.6618489821751913,
+        "drift": 0.26028451323509216,
+        "train loss": 0.7578327059745789,
+        "train samples": 1500
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "a3b4f4849157f664bdbc776fd7453c2783562f4d",
+      "created_at": "2026-01-14T13:42:28+00:00"
+    },
+    "dataset_info": {
+      "sha": "37df3244ae3aa36e85178b6cf946338137fc3068",
+      "created_at": "2026-03-09T15:31:26+00:00"
+    },
+    "package_info": {
+      "transformers-version": "5.10.2",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.2.dev0",
+      "peft-commit-hash": "b2d61f5f80a7ac540fb572c077d8265a95986db8",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "diffusers-version": "0.38.0",
+      "diffusers-commit-hash": null,
+      "torch-version": "2.12.0+cu130",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 202002\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.11.2 (Git Hash 03c022d3ffdcee958cfacbe720048e725fdf644c)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 13.0\n  - NVCC architecture flags: -gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1  (built against CUDA 12.8)\n    - Built with CuDNN 92.0\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=7661cd9c6b841b62b7f411aa52ec51f05457263b, CUDA_FLAGS= -DLIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_OPERATIONS -Xfatbin -compress-all -DONNX_NAMESPACE=onnx_torch -gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_100,code=sm_100 -gencode arch=compute_120,code=sm_120 -Xcudafe --diag_suppress=cc_clobber_ignored,--diag_suppress=field_without_dll_interface,--diag_suppress=base_class_has_different_dll_interface,--diag_suppress=dll_interface_conflict_none_assumed,--diag_suppress=dll_interface_conflict_dllexport_assumed,--diag_suppress=bad_friend_decl --expt-relaxed-constexpr --expt-extended-lambda -Xfatbin -compress-all --threads 2 -compress-mode=size -Wno-deprecated-gpu-targets --expt-extended-lambda -DCUB_WRAPPED_NAMESPACE=at_cuda_detail -DDISABLE_CUSPARSE_DEPRECATED -DCUDA_HAS_FP16=1 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -DC10_NODEPRECATED, CUDA_VERSION=13.0, CUDNN_VERSION=9.20.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_MSLK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.12.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/results/lokr--flux2-klein-default.json b/method_comparison/image-gen/results/lokr--flux2-klein-default.json
new file mode 100644
index 0000000..99683d5
--- /dev/null
+++ b/method_comparison/image-gen/results/lokr--flux2-klein-default.json
@@ -0,0 +1,255 @@
+{
+  "run_info": {
+    "created_at": "2026-06-09T17:43:34+00:00",
+    "total_time": 2344.941187106,
+    "experiment_name": "lokr/flux2-klein-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "black-forest-labs/FLUX.2-klein-base-4B",
+      "dataset_id": "peft-internal-testing/cat-image-dataset",
+      "dataset_split": "train",
+      "dtype": "bfloat16",
+      "resolution": 512,
+      "batch_size": 2,
+      "batch_size_eval": 1,
+      "repeats": 1000,
+      "max_steps": 750,
+      "eval_steps": 100,
+      "compile": false,
+      "use_gc": true,
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.0001
+      },
+      "lr_scheduler": null,
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "instance_prompts": [
+        "sks cat sitting on a chair in front of a box of chocolates",
+        "sks cat playing on the Steam Deck",
+        "sks cat wearing a necklace while sitting in a box on a sofa",
+        "a box with four donuts in front of sks cat",
+        "sks cat wearing a pink veil with flowers on it and a dagger made out of yellow cardboard",
+        "sks cat between two pillows, with one pillow showing a polar bear and the other a fox",
+        "sks cat with an espresso reading the newspaper",
+        "a close up of a hand petting sks cat on the head",
+        "sks cat opens a white door",
+        "sks cat with a VIP \"all access\" pass",
+        "sks cat in front of a monitor showing the video game \"RimWorld\"",
+        "sks cat reads a newspaper about cannabis",
+        "sks cat reading the newspaper with the title \"DIE BOX\"",
+        "sks cat being fed sushi",
+        "sks cat in front of a box of tomatoes",
+        "a gingerbread house in front of sks cat",
+        "sks cat is wearing a Wednesday Addams costume",
+        "sks cat looks skeptical as he reads a magazine depicting a black cat",
+        "sks cat wearing a striped scarf",
+        "sleepy sks cat lying in bed covered by a blue blanket"
+      ],
+      "image_column": "image",
+      "valid_size": 2,
+      "test_size": 4,
+      "num_inference_steps": 20,
+      "guidance_scale": 3.5,
+      "max_sequence_length": 512,
+      "text_encoder_out_layers": [
+        10,
+        20,
+        30
+      ],
+      "weighting_scheme": "none",
+      "logit_mean": 0.0,
+      "logit_std": 1.0,
+      "mode_scale": 1.29,
+      "dino_model_id": "facebook/dinov2-base",
+      "dino_image_size": 224,
+      "sample_image_prompts": [
+        "a photo of sks cat",
+        "a color drawing of sks cat",
+        "sks cat at the beach",
+        "a photo of sks dog",
+        "a photo of an orange cat"
+      ],
+      "drift_image_prompts": [
+        "a photo of cat",
+        "a color drawing of cat",
+        "cat sitting in a bathtub",
+        "cat looks into a mirror",
+        "a photo of cat next to a tree",
+        "the Mona Lisa but she looks angry",
+        "a dog holding a sign that says hello world",
+        "a photo of the Eiffel tower at night",
+        "an astronaut riding a horse",
+        "3d design concept of a chair that looks like an avocado"
+      ]
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "LOKR",
+      "auto_mapping": null,
+      "peft_version": "0.18.2.dev0@UNKNOWN",
+      "base_model_name_or_path": null,
+      "revision": null,
+      "inference_mode": false,
+      "rank_pattern": {},
+      "alpha_pattern": {},
+      "r": 32,
+      "alpha": 32,
+      "rank_dropout": 0.0,
+      "module_dropout": 0.0,
+      "use_effective_conv2d": false,
+      "decompose_both": false,
+      "decompose_factor": -1,
+      "rank_dropout_scale": false,
+      "target_modules": [
+        "add_v_proj",
+        "to_qkv_mlp_proj",
+        "add_q_proj",
+        "add_k_proj",
+        "linear_out",
+        "to_out.0",
+        "to_add_out",
+        "to_q",
+        "linear_in",
+        "to_k",
+        "to_v"
+      ],
+      "exclude_modules": null,
+      "init_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "modules_to_save": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 10836252819,
+    "accelerator_memory_max": 10856955904,
+    "accelerator_memory_reserved_99th": 10856955904,
+    "train_time": 2097.732945282998,
+    "file_size": 3160032,
+    "num_trainable_params": 783360,
+    "num_total_params": 3876327936,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 100,
+        "valid dino_similarity": 0.2717839479446411,
+        "train loss": 0.7861625552177429,
+        "train samples": 200,
+        "train time": 226.08448054199835,
+        "eval time": 34.467968521999865,
+        "mem allocated avg": 8260781312.0,
+        "mem reserved avg": 10703779921.92,
+        "elapsed time": 267.13045755499843
+      },
+      {
+        "step": 200,
+        "valid dino_similarity": 0.2964618504047394,
+        "train loss": 0.7786422371864319,
+        "train samples": 400,
+        "train time": 233.80062450101832,
+        "eval time": 34.21527376499944,
+        "mem allocated avg": 8260833536.0,
+        "mem reserved avg": 10854858752.0,
+        "elapsed time": 535.2962461069983
+      },
+      {
+        "step": 300,
+        "valid dino_similarity": 0.3043278455734253,
+        "train loss": 0.7674496173858643,
+        "train samples": 600,
+        "train time": 227.4152560179973,
+        "eval time": 34.23601620100089,
+        "mem allocated avg": 8260884736.0,
+        "mem reserved avg": 10856955904.0,
+        "elapsed time": 797.0939649529973
+      },
+      {
+        "step": 400,
+        "valid dino_similarity": 0.4360045790672302,
+        "train loss": 0.7670822739601135,
+        "train samples": 800,
+        "train time": 234.25180878999527,
+        "eval time": 34.4731304550005,
+        "mem allocated avg": 8260935936.0,
+        "mem reserved avg": 10856955904.0,
+        "elapsed time": 1065.9664196150006
+      },
+      {
+        "step": 500,
+        "valid dino_similarity": 0.45682621002197266,
+        "train loss": 0.7763926386833191,
+        "train samples": 1000,
+        "train time": 231.7737344390116,
+        "eval time": 33.27490914699956,
+        "mem allocated avg": 8260987136.0,
+        "mem reserved avg": 10856955904.0,
+        "elapsed time": 1331.1625063399988
+      },
+      {
+        "step": 600,
+        "valid dino_similarity": 0.45767927169799805,
+        "train loss": 0.784383237361908,
+        "train samples": 1200,
+        "train time": 224.74212606196306,
+        "eval time": 33.40383356899838,
+        "mem allocated avg": 8261038336.0,
+        "mem reserved avg": 10856955904.0,
+        "elapsed time": 1589.4560237849983
+      },
+      {
+        "step": 700,
+        "valid dino_similarity": 0.4867386519908905,
+        "train loss": 0.7864697575569153,
+        "train samples": 1400,
+        "train time": 230.39455091498166,
+        "eval time": 35.423201106001216,
+        "mem allocated avg": 8261089536.0,
+        "mem reserved avg": 10856955904.0,
+        "elapsed time": 1855.4223228560004
+      },
+      {
+        "step": 750,
+        "test dino_similarity": 0.5805431207021078,
+        "drift": 0.16636252403259277,
+        "train loss": 0.7778511643409729,
+        "train samples": 1500
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "a3b4f4849157f664bdbc776fd7453c2783562f4d",
+      "created_at": "2026-01-14T13:42:28+00:00"
+    },
+    "dataset_info": {
+      "sha": "37df3244ae3aa36e85178b6cf946338137fc3068",
+      "created_at": "2026-03-09T15:31:26+00:00"
+    },
+    "package_info": {
+      "transformers-version": "5.10.2",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.2.dev0",
+      "peft-commit-hash": "b2d61f5f80a7ac540fb572c077d8265a95986db8",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "diffusers-version": "0.38.0",
+      "diffusers-commit-hash": null,
+      "torch-version": "2.12.0+cu130",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 202002\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.11.2 (Git Hash 03c022d3ffdcee958cfacbe720048e725fdf644c)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 13.0\n  - NVCC architecture flags: -gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1  (built against CUDA 12.8)\n    - Built with CuDNN 92.0\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=7661cd9c6b841b62b7f411aa52ec51f05457263b, CUDA_FLAGS= -DLIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_OPERATIONS -Xfatbin -compress-all -DONNX_NAMESPACE=onnx_torch -gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_100,code=sm_100 -gencode arch=compute_120,code=sm_120 -Xcudafe --diag_suppress=cc_clobber_ignored,--diag_suppress=field_without_dll_interface,--diag_suppress=base_class_has_different_dll_interface,--diag_suppress=dll_interface_conflict_none_assumed,--diag_suppress=dll_interface_conflict_dllexport_assumed,--diag_suppress=bad_friend_decl --expt-relaxed-constexpr --expt-extended-lambda -Xfatbin -compress-all --threads 2 -compress-mode=size -Wno-deprecated-gpu-targets --expt-extended-lambda -DCUB_WRAPPED_NAMESPACE=at_cuda_detail -DDISABLE_CUSPARSE_DEPRECATED -DCUDA_HAS_FP16=1 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -DC10_NODEPRECATED, CUDA_VERSION=13.0, CUDNN_VERSION=9.20.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_MSLK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.12.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/results/lora--flux2-klein-default.json b/method_comparison/image-gen/results/lora--flux2-klein-default.json
new file mode 100644
index 0000000..7306eb0
--- /dev/null
+++ b/method_comparison/image-gen/results/lora--flux2-klein-default.json
@@ -0,0 +1,272 @@
+{
+  "run_info": {
+    "created_at": "2026-06-09T09:44:03+00:00",
+    "total_time": 928.871436918,
+    "experiment_name": "lora/flux2-klein-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "black-forest-labs/FLUX.2-klein-base-4B",
+      "dataset_id": "peft-internal-testing/cat-image-dataset",
+      "dataset_split": "train",
+      "dtype": "bfloat16",
+      "resolution": 512,
+      "batch_size": 2,
+      "batch_size_eval": 1,
+      "repeats": 1000,
+      "max_steps": 750,
+      "eval_steps": 100,
+      "compile": false,
+      "use_gc": true,
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.0001
+      },
+      "lr_scheduler": null,
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "instance_prompts": [
+        "sks cat sitting on a chair in front of a box of chocolates",
+        "sks cat playing on the Steam Deck",
+        "sks cat wearing a necklace while sitting in a box on a sofa",
+        "a box with four donuts in front of sks cat",
+        "sks cat wearing a pink veil with flowers on it and a dagger made out of yellow cardboard",
+        "sks cat between two pillows, with one pillow showing a polar bear and the other a fox",
+        "sks cat with an espresso reading the newspaper",
+        "a close up of a hand petting sks cat on the head",
+        "sks cat opens a white door",
+        "sks cat with a VIP \"all access\" pass",
+        "sks cat in front of a monitor showing the video game \"RimWorld\"",
+        "sks cat reads a newspaper about cannabis",
+        "sks cat reading the newspaper with the title \"DIE BOX\"",
+        "sks cat being fed sushi",
+        "sks cat in front of a box of tomatoes",
+        "a gingerbread house in front of sks cat",
+        "sks cat is wearing a Wednesday Addams costume",
+        "sks cat looks skeptical as he reads a magazine depicting a black cat",
+        "sks cat wearing a striped scarf",
+        "sleepy sks cat lying in bed covered by a blue blanket"
+      ],
+      "image_column": "image",
+      "valid_size": 2,
+      "test_size": 4,
+      "num_inference_steps": 20,
+      "guidance_scale": 3.5,
+      "max_sequence_length": 512,
+      "text_encoder_out_layers": [
+        10,
+        20,
+        30
+      ],
+      "weighting_scheme": "none",
+      "logit_mean": 0.0,
+      "logit_std": 1.0,
+      "mode_scale": 1.29,
+      "dino_model_id": "facebook/dinov2-base",
+      "dino_image_size": 224,
+      "sample_image_prompts": [
+        "a photo of sks cat",
+        "a color drawing of sks cat",
+        "sks cat at the beach",
+        "a photo of sks dog",
+        "a photo of an orange cat"
+      ],
+      "drift_image_prompts": [
+        "a photo of cat",
+        "a color drawing of cat",
+        "cat sitting in a bathtub",
+        "cat looks into a mirror",
+        "a photo of cat next to a tree",
+        "the Mona Lisa but she looks angry",
+        "a dog holding a sign that says hello world",
+        "a photo of the Eiffel tower at night",
+        "an astronaut riding a horse",
+        "3d design concept of a chair that looks like an avocado"
+      ]
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "LORA",
+      "auto_mapping": null,
+      "peft_version": "0.19.2.dev0@UNKNOWN",
+      "base_model_name_or_path": null,
+      "revision": null,
+      "inference_mode": false,
+      "r": 32,
+      "target_modules": [
+        "to_k",
+        "add_q_proj",
+        "add_k_proj",
+        "add_v_proj",
+        "to_out.0",
+        "linear_out",
+        "to_q",
+        "to_qkv_mlp_proj",
+        "to_add_out",
+        "to_v",
+        "linear_in"
+      ],
+      "exclude_modules": null,
+      "lora_alpha": 32,
+      "lora_dropout": 0.0,
+      "fan_in_fan_out": false,
+      "bias": "none",
+      "use_rslora": false,
+      "modules_to_save": null,
+      "init_lora_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "rank_pattern": {},
+      "alpha_pattern": {},
+      "megatron_config": null,
+      "megatron_core": "megatron.core",
+      "trainable_token_indices": null,
+      "loftq_config": {},
+      "eva_config": null,
+      "corda_config": null,
+      "lora_ga_config": null,
+      "use_dora": false,
+      "velora_config": null,
+      "alora_invocation_tokens": null,
+      "use_qalora": false,
+      "qalora_group_size": 16,
+      "monteclora_config": null,
+      "layer_replication": null,
+      "lora_bias": false,
+      "target_parameters": null,
+      "use_bdlora": null,
+      "arrow_config": null,
+      "ensure_weight_tying": false
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 10687464079,
+    "accelerator_memory_max": 10708058112,
+    "accelerator_memory_reserved_99th": 10708058112,
+    "train_time": 759.1968001689999,
+    "file_size": 153377056,
+    "num_trainable_params": 38338560,
+    "num_total_params": 3913883136,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 100,
+        "valid dino_similarity": 0.721135139465332,
+        "train loss": 0.7727639079093933,
+        "train samples": 200,
+        "train time": 73.19364842100015,
+        "eval time": 14.36943373500003,
+        "mem allocated avg": 8889204049.92,
+        "mem reserved avg": 10553665781.76,
+        "elapsed time": 155.27759874499998
+      },
+      {
+        "step": 200,
+        "valid dino_similarity": 0.7029661536216736,
+        "train loss": 0.7529757022857666,
+        "train samples": 400,
+        "train time": 73.6351999069999,
+        "eval time": 14.332816114000025,
+        "mem allocated avg": 8889635072.0,
+        "mem reserved avg": 10708037140.48,
+        "elapsed time": 243.419710835
+      },
+      {
+        "step": 300,
+        "valid dino_similarity": 0.6750155091285706,
+        "train loss": 0.7658034563064575,
+        "train samples": 600,
+        "train time": 72.73937071999995,
+        "eval time": 14.15214280400005,
+        "mem allocated avg": 8889686272.0,
+        "mem reserved avg": 10708037140.48,
+        "elapsed time": 330.48199501199997
+      },
+      {
+        "step": 400,
+        "valid dino_similarity": 0.7188570499420166,
+        "train loss": 0.7448358535766602,
+        "train samples": 800,
+        "train time": 73.80015679300016,
+        "eval time": 14.307388027999991,
+        "mem allocated avg": 8889737472.0,
+        "mem reserved avg": 10708058112.0,
+        "elapsed time": 418.76125412199997
+      },
+      {
+        "step": 500,
+        "valid dino_similarity": 0.6683900356292725,
+        "train loss": 0.7334763407707214,
+        "train samples": 1000,
+        "train time": 73.93006410599992,
+        "eval time": 14.297873244000016,
+        "mem allocated avg": 8889788672.0,
+        "mem reserved avg": 10708037140.48,
+        "elapsed time": 507.16202161900003
+      },
+      {
+        "step": 600,
+        "valid dino_similarity": 0.7242463231086731,
+        "train loss": 0.737773597240448,
+        "train samples": 1200,
+        "train time": 73.78990692200023,
+        "eval time": 14.45131763500001,
+        "mem allocated avg": 8889839872.0,
+        "mem reserved avg": 10708058112.0,
+        "elapsed time": 595.577160797
+      },
+      {
+        "step": 700,
+        "valid dino_similarity": 0.6919602155685425,
+        "train loss": 0.723881721496582,
+        "train samples": 1400,
+        "train time": 74.0571738719998,
+        "eval time": 14.261170369999945,
+        "mem allocated avg": 8889891072.0,
+        "mem reserved avg": 10708058112.0,
+        "elapsed time": 684.069242217
+      },
+      {
+        "step": 750,
+        "test dino_similarity": 0.697154720624288,
+        "drift": 0.26200442016124725,
+        "train loss": 0.7348256707191467,
+        "train samples": 1500
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "a3b4f4849157f664bdbc776fd7453c2783562f4d",
+      "created_at": "2026-01-14T13:42:28+00:00"
+    },
+    "dataset_info": {
+      "sha": "37df3244ae3aa36e85178b6cf946338137fc3068",
+      "created_at": "2026-03-09T15:31:26+00:00"
+    },
+    "package_info": {
+      "transformers-version": "5.10.2",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.2.dev0",
+      "peft-commit-hash": "b2d61f5f80a7ac540fb572c077d8265a95986db8",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "diffusers-version": "0.38.0",
+      "diffusers-commit-hash": null,
+      "torch-version": "2.12.0+cu130",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 202002\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.11.2 (Git Hash 03c022d3ffdcee958cfacbe720048e725fdf644c)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 13.0\n  - NVCC architecture flags: -gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1  (built against CUDA 12.8)\n    - Built with CuDNN 92.0\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=7661cd9c6b841b62b7f411aa52ec51f05457263b, CUDA_FLAGS= -DLIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_OPERATIONS -Xfatbin -compress-all -DONNX_NAMESPACE=onnx_torch -gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_100,code=sm_100 -gencode arch=compute_120,code=sm_120 -Xcudafe --diag_suppress=cc_clobber_ignored,--diag_suppress=field_without_dll_interface,--diag_suppress=base_class_has_different_dll_interface,--diag_suppress=dll_interface_conflict_none_assumed,--diag_suppress=dll_interface_conflict_dllexport_assumed,--diag_suppress=bad_friend_decl --expt-relaxed-constexpr --expt-extended-lambda -Xfatbin -compress-all --threads 2 -compress-mode=size -Wno-deprecated-gpu-targets --expt-extended-lambda -DCUB_WRAPPED_NAMESPACE=at_cuda_detail -DDISABLE_CUSPARSE_DEPRECATED -DCUDA_HAS_FP16=1 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -DC10_NODEPRECATED, CUDA_VERSION=13.0, CUDNN_VERSION=9.20.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_MSLK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.12.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/results/miss--flux2-klein-default.json b/method_comparison/image-gen/results/miss--flux2-klein-default.json
new file mode 100644
index 0000000..069b242
--- /dev/null
+++ b/method_comparison/image-gen/results/miss--flux2-klein-default.json
@@ -0,0 +1,249 @@
+{
+  "run_info": {
+    "created_at": "2026-06-09T18:24:12+00:00",
+    "total_time": 727.3839446349994,
+    "experiment_name": "miss/flux2-klein-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "black-forest-labs/FLUX.2-klein-base-4B",
+      "dataset_id": "peft-internal-testing/cat-image-dataset",
+      "dataset_split": "train",
+      "dtype": "bfloat16",
+      "resolution": 512,
+      "batch_size": 2,
+      "batch_size_eval": 1,
+      "repeats": 1000,
+      "max_steps": 750,
+      "eval_steps": 100,
+      "compile": false,
+      "use_gc": true,
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.0001
+      },
+      "lr_scheduler": null,
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "instance_prompts": [
+        "sks cat sitting on a chair in front of a box of chocolates",
+        "sks cat playing on the Steam Deck",
+        "sks cat wearing a necklace while sitting in a box on a sofa",
+        "a box with four donuts in front of sks cat",
+        "sks cat wearing a pink veil with flowers on it and a dagger made out of yellow cardboard",
+        "sks cat between two pillows, with one pillow showing a polar bear and the other a fox",
+        "sks cat with an espresso reading the newspaper",
+        "a close up of a hand petting sks cat on the head",
+        "sks cat opens a white door",
+        "sks cat with a VIP \"all access\" pass",
+        "sks cat in front of a monitor showing the video game \"RimWorld\"",
+        "sks cat reads a newspaper about cannabis",
+        "sks cat reading the newspaper with the title \"DIE BOX\"",
+        "sks cat being fed sushi",
+        "sks cat in front of a box of tomatoes",
+        "a gingerbread house in front of sks cat",
+        "sks cat is wearing a Wednesday Addams costume",
+        "sks cat looks skeptical as he reads a magazine depicting a black cat",
+        "sks cat wearing a striped scarf",
+        "sleepy sks cat lying in bed covered by a blue blanket"
+      ],
+      "image_column": "image",
+      "valid_size": 2,
+      "test_size": 4,
+      "num_inference_steps": 20,
+      "guidance_scale": 3.5,
+      "max_sequence_length": 512,
+      "text_encoder_out_layers": [
+        10,
+        20,
+        30
+      ],
+      "weighting_scheme": "none",
+      "logit_mean": 0.0,
+      "logit_std": 1.0,
+      "mode_scale": 1.29,
+      "dino_model_id": "facebook/dinov2-base",
+      "dino_image_size": 224,
+      "sample_image_prompts": [
+        "a photo of sks cat",
+        "a color drawing of sks cat",
+        "sks cat at the beach",
+        "a photo of sks dog",
+        "a photo of an orange cat"
+      ],
+      "drift_image_prompts": [
+        "a photo of cat",
+        "a color drawing of cat",
+        "cat sitting in a bathtub",
+        "cat looks into a mirror",
+        "a photo of cat next to a tree",
+        "the Mona Lisa but she looks angry",
+        "a dog holding a sign that says hello world",
+        "a photo of the Eiffel tower at night",
+        "an astronaut riding a horse",
+        "3d design concept of a chair that looks like an avocado"
+      ]
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "MISS",
+      "auto_mapping": null,
+      "peft_version": "0.18.2.dev0@UNKNOWN",
+      "base_model_name_or_path": null,
+      "revision": null,
+      "inference_mode": false,
+      "r": 32,
+      "miss_dropout": 0.0,
+      "mini_r": 1,
+      "target_modules": [
+        "to_k",
+        "add_k_proj",
+        "linear_out",
+        "to_qkv_mlp_proj",
+        "to_out.0",
+        "to_add_out",
+        "add_q_proj",
+        "to_q",
+        "add_v_proj",
+        "linear_in",
+        "to_v"
+      ],
+      "exclude_modules": null,
+      "init_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "bias": "none",
+      "modules_to_save": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 10540641069,
+    "accelerator_memory_max": 10561257472,
+    "accelerator_memory_reserved_99th": 10561257472,
+    "train_time": 626.3718940060062,
+    "file_size": 114043792,
+    "num_trainable_params": 28508160,
+    "num_total_params": 3904052736,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 100,
+        "valid dino_similarity": 0.6181231737136841,
+        "train loss": 0.7515266537666321,
+        "train samples": 200,
+        "train time": 65.28438478298631,
+        "eval time": 13.507706291999057,
+        "mem allocated avg": 8715340974.08,
+        "mem reserved avg": 10406802227.2,
+        "elapsed time": 85.13473947999955
+      },
+      {
+        "step": 200,
+        "valid dino_similarity": 0.743149995803833,
+        "train loss": 0.7414279580116272,
+        "train samples": 400,
+        "train time": 65.07575083898337,
+        "eval time": 13.19248517899905,
+        "mem allocated avg": 8715440384.0,
+        "mem reserved avg": 10561257472.0,
+        "elapsed time": 163.56078837899986
+      },
+      {
+        "step": 300,
+        "valid dino_similarity": 0.67582106590271,
+        "train loss": 0.7245558500289917,
+        "train samples": 600,
+        "train time": 64.86194115402031,
+        "eval time": 13.26754924099805,
+        "mem allocated avg": 8715491584.0,
+        "mem reserved avg": 10561236500.48,
+        "elapsed time": 241.8458573909993
+      },
+      {
+        "step": 400,
+        "valid dino_similarity": 0.6854823231697083,
+        "train loss": 0.6924992799758911,
+        "train samples": 800,
+        "train time": 65.21861896301198,
+        "eval time": 13.507095736000338,
+        "mem allocated avg": 8715542784.0,
+        "mem reserved avg": 10561257472.0,
+        "elapsed time": 320.7283566879996
+      },
+      {
+        "step": 500,
+        "valid dino_similarity": 0.7285688519477844,
+        "train loss": 0.6820658445358276,
+        "train samples": 1000,
+        "train time": 65.4232205769913,
+        "eval time": 13.335626404001232,
+        "mem allocated avg": 8715593984.0,
+        "mem reserved avg": 10561257472.0,
+        "elapsed time": 399.6437398199996
+      },
+      {
+        "step": 600,
+        "valid dino_similarity": 0.6858096122741699,
+        "train loss": 0.6350104212760925,
+        "train samples": 1200,
+        "train time": 65.15856552698096,
+        "eval time": 13.465135365997412,
+        "mem allocated avg": 8715645184.0,
+        "mem reserved avg": 10561257472.0,
+        "elapsed time": 478.4228778400029
+      },
+      {
+        "step": 700,
+        "valid dino_similarity": 0.6534463167190552,
+        "train loss": 0.6463939547538757,
+        "train samples": 1400,
+        "train time": 65.64515108499108,
+        "eval time": 13.389221376000933,
+        "mem allocated avg": 8715696384.0,
+        "mem reserved avg": 10561257472.0,
+        "elapsed time": 557.6136061300022
+      },
+      {
+        "step": 750,
+        "test dino_similarity": 0.6565384666124979,
+        "drift": 0.3087518662214279,
+        "train loss": 0.6165896058082581,
+        "train samples": 1500
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "a3b4f4849157f664bdbc776fd7453c2783562f4d",
+      "created_at": "2026-01-14T13:42:28+00:00"
+    },
+    "dataset_info": {
+      "sha": "37df3244ae3aa36e85178b6cf946338137fc3068",
+      "created_at": "2026-03-09T15:31:26+00:00"
+    },
+    "package_info": {
+      "transformers-version": "5.10.2",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.2.dev0",
+      "peft-commit-hash": "b2d61f5f80a7ac540fb572c077d8265a95986db8",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "diffusers-version": "0.38.0",
+      "diffusers-commit-hash": null,
+      "torch-version": "2.12.0+cu130",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 202002\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.11.2 (Git Hash 03c022d3ffdcee958cfacbe720048e725fdf644c)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 13.0\n  - NVCC architecture flags: -gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1  (built against CUDA 12.8)\n    - Built with CuDNN 92.0\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=7661cd9c6b841b62b7f411aa52ec51f05457263b, CUDA_FLAGS= -DLIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_OPERATIONS -Xfatbin -compress-all -DONNX_NAMESPACE=onnx_torch -gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_100,code=sm_100 -gencode arch=compute_120,code=sm_120 -Xcudafe --diag_suppress=cc_clobber_ignored,--diag_suppress=field_without_dll_interface,--diag_suppress=base_class_has_different_dll_interface,--diag_suppress=dll_interface_conflict_none_assumed,--diag_suppress=dll_interface_conflict_dllexport_assumed,--diag_suppress=bad_friend_decl --expt-relaxed-constexpr --expt-extended-lambda -Xfatbin -compress-all --threads 2 -compress-mode=size -Wno-deprecated-gpu-targets --expt-extended-lambda -DCUB_WRAPPED_NAMESPACE=at_cuda_detail -DDISABLE_CUSPARSE_DEPRECATED -DCUDA_HAS_FP16=1 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -DC10_NODEPRECATED, CUDA_VERSION=13.0, CUDNN_VERSION=9.20.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_MSLK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.12.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/results/oft--flux2-klein-default.json b/method_comparison/image-gen/results/oft--flux2-klein-default.json
new file mode 100644
index 0000000..7bf590c
--- /dev/null
+++ b/method_comparison/image-gen/results/oft--flux2-klein-default.json
@@ -0,0 +1,255 @@
+{
+  "run_info": {
+    "created_at": "2026-06-09T18:37:04+00:00",
+    "total_time": 614.9160153599987,
+    "experiment_name": "oft/flux2-klein-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "black-forest-labs/FLUX.2-klein-base-4B",
+      "dataset_id": "peft-internal-testing/cat-image-dataset",
+      "dataset_split": "train",
+      "dtype": "bfloat16",
+      "resolution": 512,
+      "batch_size": 2,
+      "batch_size_eval": 1,
+      "repeats": 1000,
+      "max_steps": 750,
+      "eval_steps": 100,
+      "compile": false,
+      "use_gc": true,
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.0001
+      },
+      "lr_scheduler": null,
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "instance_prompts": [
+        "sks cat sitting on a chair in front of a box of chocolates",
+        "sks cat playing on the Steam Deck",
+        "sks cat wearing a necklace while sitting in a box on a sofa",
+        "a box with four donuts in front of sks cat",
+        "sks cat wearing a pink veil with flowers on it and a dagger made out of yellow cardboard",
+        "sks cat between two pillows, with one pillow showing a polar bear and the other a fox",
+        "sks cat with an espresso reading the newspaper",
+        "a close up of a hand petting sks cat on the head",
+        "sks cat opens a white door",
+        "sks cat with a VIP \"all access\" pass",
+        "sks cat in front of a monitor showing the video game \"RimWorld\"",
+        "sks cat reads a newspaper about cannabis",
+        "sks cat reading the newspaper with the title \"DIE BOX\"",
+        "sks cat being fed sushi",
+        "sks cat in front of a box of tomatoes",
+        "a gingerbread house in front of sks cat",
+        "sks cat is wearing a Wednesday Addams costume",
+        "sks cat looks skeptical as he reads a magazine depicting a black cat",
+        "sks cat wearing a striped scarf",
+        "sleepy sks cat lying in bed covered by a blue blanket"
+      ],
+      "image_column": "image",
+      "valid_size": 2,
+      "test_size": 4,
+      "num_inference_steps": 20,
+      "guidance_scale": 3.5,
+      "max_sequence_length": 512,
+      "text_encoder_out_layers": [
+        10,
+        20,
+        30
+      ],
+      "weighting_scheme": "none",
+      "logit_mean": 0.0,
+      "logit_std": 1.0,
+      "mode_scale": 1.29,
+      "dino_model_id": "facebook/dinov2-base",
+      "dino_image_size": 224,
+      "sample_image_prompts": [
+        "a photo of sks cat",
+        "a color drawing of sks cat",
+        "sks cat at the beach",
+        "a photo of sks dog",
+        "a photo of an orange cat"
+      ],
+      "drift_image_prompts": [
+        "a photo of cat",
+        "a color drawing of cat",
+        "cat sitting in a bathtub",
+        "cat looks into a mirror",
+        "a photo of cat next to a tree",
+        "the Mona Lisa but she looks angry",
+        "a dog holding a sign that says hello world",
+        "a photo of the Eiffel tower at night",
+        "an astronaut riding a horse",
+        "3d design concept of a chair that looks like an avocado"
+      ]
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "OFT",
+      "auto_mapping": null,
+      "peft_version": "0.18.2.dev0@UNKNOWN",
+      "base_model_name_or_path": null,
+      "revision": null,
+      "inference_mode": false,
+      "r": 0,
+      "oft_block_size": 32,
+      "module_dropout": 0.0,
+      "target_modules": [
+        "add_k_proj",
+        "linear_out",
+        "to_add_out",
+        "add_q_proj",
+        "to_v",
+        "add_v_proj",
+        "to_q",
+        "to_out.0",
+        "to_qkv_mlp_proj",
+        "to_k",
+        "linear_in"
+      ],
+      "fan_in_fan_out": false,
+      "bias": "none",
+      "exclude_modules": null,
+      "init_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "modules_to_save": null,
+      "coft": false,
+      "eps": 6e-05,
+      "block_share": false,
+      "use_cayley_neumann": true,
+      "num_cayley_neumann_terms": 5
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 9666981527,
+    "accelerator_memory_max": 9669967872,
+    "accelerator_memory_reserved_99th": 9669967872,
+    "train_time": 523.9673415769976,
+    "file_size": 19057488,
+    "num_trainable_params": 4761600,
+    "num_total_params": 3880306176,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 100,
+        "valid dino_similarity": 0.6627750992774963,
+        "train loss": 0.7570741772651672,
+        "train samples": 200,
+        "train time": 54.08489197699964,
+        "eval time": 11.890669825002988,
+        "mem allocated avg": 8325088512.0,
+        "mem reserved avg": 9648996352.0,
+        "elapsed time": 72.41434138899785
+      },
+      {
+        "step": 200,
+        "valid dino_similarity": 0.5399283766746521,
+        "train loss": 0.767706036567688,
+        "train samples": 400,
+        "train time": 53.16839128799256,
+        "eval time": 11.797631360001105,
+        "mem allocated avg": 8325140736.0,
+        "mem reserved avg": 9668793466.88,
+        "elapsed time": 137.55317595099768
+      },
+      {
+        "step": 300,
+        "valid dino_similarity": 0.6824833154678345,
+        "train loss": 0.7634817361831665,
+        "train samples": 600,
+        "train time": 53.23308719799388,
+        "eval time": 12.02888714099754,
+        "mem allocated avg": 8325191936.0,
+        "mem reserved avg": 9669716213.76,
+        "elapsed time": 202.98741005899865
+      },
+      {
+        "step": 400,
+        "valid dino_similarity": 0.585516095161438,
+        "train loss": 0.7495874762535095,
+        "train samples": 800,
+        "train time": 53.44557686398184,
+        "eval time": 11.837600922001002,
+        "mem allocated avg": 8325243136.0,
+        "mem reserved avg": 9669967872.0,
+        "elapsed time": 268.4425377129992
+      },
+      {
+        "step": 500,
+        "valid dino_similarity": 0.6400976777076721,
+        "train loss": 0.7673217058181763,
+        "train samples": 1000,
+        "train time": 53.27909925998392,
+        "eval time": 11.900888142998156,
+        "mem allocated avg": 8325294336.0,
+        "mem reserved avg": 9669967872.0,
+        "elapsed time": 333.7951165459999
+      },
+      {
+        "step": 600,
+        "valid dino_similarity": 0.7322559356689453,
+        "train loss": 0.7364460825920105,
+        "train samples": 1200,
+        "train time": 54.80706680797812,
+        "eval time": 11.8395791619987,
+        "mem allocated avg": 8325345536.0,
+        "mem reserved avg": 9669967872.0,
+        "elapsed time": 400.6122305289973
+      },
+      {
+        "step": 700,
+        "valid dino_similarity": 0.5392858982086182,
+        "train loss": 0.7687813639640808,
+        "train samples": 1400,
+        "train time": 53.31519266899704,
+        "eval time": 11.84427259900258,
+        "mem allocated avg": 8325396736.0,
+        "mem reserved avg": 9669967872.0,
+        "elapsed time": 465.9419832639978
+      },
+      {
+        "step": 750,
+        "test dino_similarity": 0.7077637513478597,
+        "drift": 0.26190416514873505,
+        "train loss": 0.7543298006057739,
+        "train samples": 1500
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "a3b4f4849157f664bdbc776fd7453c2783562f4d",
+      "created_at": "2026-01-14T13:42:28+00:00"
+    },
+    "dataset_info": {
+      "sha": "37df3244ae3aa36e85178b6cf946338137fc3068",
+      "created_at": "2026-03-09T15:31:26+00:00"
+    },
+    "package_info": {
+      "transformers-version": "5.10.2",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.2.dev0",
+      "peft-commit-hash": "b2d61f5f80a7ac540fb572c077d8265a95986db8",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "diffusers-version": "0.38.0",
+      "diffusers-commit-hash": null,
+      "torch-version": "2.12.0+cu130",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 202002\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.11.2 (Git Hash 03c022d3ffdcee958cfacbe720048e725fdf644c)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 13.0\n  - NVCC architecture flags: -gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1  (built against CUDA 12.8)\n    - Built with CuDNN 92.0\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=7661cd9c6b841b62b7f411aa52ec51f05457263b, CUDA_FLAGS= -DLIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_OPERATIONS -Xfatbin -compress-all -DONNX_NAMESPACE=onnx_torch -gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_100,code=sm_100 -gencode arch=compute_120,code=sm_120 -Xcudafe --diag_suppress=cc_clobber_ignored,--diag_suppress=field_without_dll_interface,--diag_suppress=base_class_has_different_dll_interface,--diag_suppress=dll_interface_conflict_none_assumed,--diag_suppress=dll_interface_conflict_dllexport_assumed,--diag_suppress=bad_friend_decl --expt-relaxed-constexpr --expt-extended-lambda -Xfatbin -compress-all --threads 2 -compress-mode=size -Wno-deprecated-gpu-targets --expt-extended-lambda -DCUB_WRAPPED_NAMESPACE=at_cuda_detail -DDISABLE_CUSPARSE_DEPRECATED -DCUDA_HAS_FP16=1 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -DC10_NODEPRECATED, CUDA_VERSION=13.0, CUDNN_VERSION=9.20.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_MSLK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.12.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/results/peanut--flux2-klein-default.json b/method_comparison/image-gen/results/peanut--flux2-klein-default.json
new file mode 100644
index 0000000..d23794b
--- /dev/null
+++ b/method_comparison/image-gen/results/peanut--flux2-klein-default.json
@@ -0,0 +1,249 @@
+{
+  "run_info": {
+    "created_at": "2026-06-09T19:00:31+00:00",
+    "total_time": 2214.468981156002,
+    "experiment_name": "peanut/flux2-klein-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "black-forest-labs/FLUX.2-klein-base-4B",
+      "dataset_id": "peft-internal-testing/cat-image-dataset",
+      "dataset_split": "train",
+      "dtype": "bfloat16",
+      "resolution": 512,
+      "batch_size": 2,
+      "batch_size_eval": 1,
+      "repeats": 1000,
+      "max_steps": 750,
+      "eval_steps": 100,
+      "compile": false,
+      "use_gc": true,
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.0001
+      },
+      "lr_scheduler": null,
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "instance_prompts": [
+        "sks cat sitting on a chair in front of a box of chocolates",
+        "sks cat playing on the Steam Deck",
+        "sks cat wearing a necklace while sitting in a box on a sofa",
+        "a box with four donuts in front of sks cat",
+        "sks cat wearing a pink veil with flowers on it and a dagger made out of yellow cardboard",
+        "sks cat between two pillows, with one pillow showing a polar bear and the other a fox",
+        "sks cat with an espresso reading the newspaper",
+        "a close up of a hand petting sks cat on the head",
+        "sks cat opens a white door",
+        "sks cat with a VIP \"all access\" pass",
+        "sks cat in front of a monitor showing the video game \"RimWorld\"",
+        "sks cat reads a newspaper about cannabis",
+        "sks cat reading the newspaper with the title \"DIE BOX\"",
+        "sks cat being fed sushi",
+        "sks cat in front of a box of tomatoes",
+        "a gingerbread house in front of sks cat",
+        "sks cat is wearing a Wednesday Addams costume",
+        "sks cat looks skeptical as he reads a magazine depicting a black cat",
+        "sks cat wearing a striped scarf",
+        "sleepy sks cat lying in bed covered by a blue blanket"
+      ],
+      "image_column": "image",
+      "valid_size": 2,
+      "test_size": 4,
+      "num_inference_steps": 20,
+      "guidance_scale": 3.5,
+      "max_sequence_length": 512,
+      "text_encoder_out_layers": [
+        10,
+        20,
+        30
+      ],
+      "weighting_scheme": "none",
+      "logit_mean": 0.0,
+      "logit_std": 1.0,
+      "mode_scale": 1.29,
+      "dino_model_id": "facebook/dinov2-base",
+      "dino_image_size": 224,
+      "sample_image_prompts": [
+        "a photo of sks cat",
+        "a color drawing of sks cat",
+        "sks cat at the beach",
+        "a photo of sks dog",
+        "a photo of an orange cat"
+      ],
+      "drift_image_prompts": [
+        "a photo of cat",
+        "a color drawing of cat",
+        "cat sitting in a bathtub",
+        "cat looks into a mirror",
+        "a photo of cat next to a tree",
+        "the Mona Lisa but she looks angry",
+        "a dog holding a sign that says hello world",
+        "a photo of the Eiffel tower at night",
+        "an astronaut riding a horse",
+        "3d design concept of a chair that looks like an avocado"
+      ]
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "PEANUT",
+      "auto_mapping": null,
+      "peft_version": "0.18.2.dev0@UNKNOWN",
+      "base_model_name_or_path": null,
+      "revision": null,
+      "inference_mode": false,
+      "r": 32,
+      "depth": 0,
+      "act_fn": "relu",
+      "scaling": 1.0,
+      "target_modules": [
+        "to_add_out",
+        "add_v_proj",
+        "linear_out",
+        "linear_in",
+        "to_q",
+        "to_qkv_mlp_proj",
+        "to_out.0",
+        "to_v",
+        "to_k",
+        "add_q_proj",
+        "add_k_proj"
+      ],
+      "exclude_modules": null,
+      "modules_to_save": null,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "init_weights": true
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 12309678260,
+    "accelerator_memory_max": 12398362624,
+    "accelerator_memory_reserved_99th": 12398362624,
+    "train_time": 1981.0113854429874,
+    "file_size": 228088552,
+    "num_trainable_params": 57016320,
+    "num_total_params": 3932560896,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 100,
+        "valid dino_similarity": 0.29342442750930786,
+        "train loss": 0.7701157927513123,
+        "train samples": 200,
+        "train time": 220.61202642404533,
+        "eval time": 32.581604375001916,
+        "mem allocated avg": 9173765294.08,
+        "mem reserved avg": 12337209671.68,
+        "elapsed time": 259.6033734379962
+      },
+      {
+        "step": 200,
+        "valid dino_similarity": 0.6713915467262268,
+        "train loss": 0.7749302387237549,
+        "train samples": 400,
+        "train time": 222.01833760199952,
+        "eval time": 32.08653341200261,
+        "mem allocated avg": 9172530391.04,
+        "mem reserved avg": 12285116416.0,
+        "elapsed time": 513.8566796279993
+      },
+      {
+        "step": 300,
+        "valid dino_similarity": 0.6325161457061768,
+        "train loss": 0.7520059943199158,
+        "train samples": 600,
+        "train time": 220.24150139700214,
+        "eval time": 31.800023492003675,
+        "mem allocated avg": 9172527851.52,
+        "mem reserved avg": 12285116416.0,
+        "elapsed time": 766.0446072559935
+      },
+      {
+        "step": 400,
+        "valid dino_similarity": 0.7564932107925415,
+        "train loss": 0.7296949625015259,
+        "train samples": 800,
+        "train time": 217.13644056901103,
+        "eval time": 31.475015178999456,
+        "mem allocated avg": 9172601333.76,
+        "mem reserved avg": 12285116416.0,
+        "elapsed time": 1014.8056414989987
+      },
+      {
+        "step": 500,
+        "valid dino_similarity": 0.6451616287231445,
+        "train loss": 0.7252581715583801,
+        "train samples": 1000,
+        "train time": 214.07800938798027,
+        "eval time": 32.86555565600429,
+        "mem allocated avg": 9173652613.12,
+        "mem reserved avg": 12303990784.0,
+        "elapsed time": 1261.8997030829996
+      },
+      {
+        "step": 600,
+        "valid dino_similarity": 0.6890438795089722,
+        "train loss": 0.7078382968902588,
+        "train samples": 1200,
+        "train time": 220.74659274697478,
+        "eval time": 32.74774398400041,
+        "mem allocated avg": 9173475747.84,
+        "mem reserved avg": 12341739520.0,
+        "elapsed time": 1515.542746866995
+      },
+      {
+        "step": 700,
+        "valid dino_similarity": 0.7170302867889404,
+        "train loss": 0.6873780488967896,
+        "train samples": 1400,
+        "train time": 215.9295358710151,
+        "eval time": 31.97658442700049,
+        "mem allocated avg": 9173844142.08,
+        "mem reserved avg": 12285116416.0,
+        "elapsed time": 1763.5993039349996
+      },
+      {
+        "step": 750,
+        "test dino_similarity": 0.7129100759824117,
+        "drift": 0.31749118864536285,
+        "train loss": 0.6619570851325989,
+        "train samples": 1500
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "a3b4f4849157f664bdbc776fd7453c2783562f4d",
+      "created_at": "2026-01-14T13:42:28+00:00"
+    },
+    "dataset_info": {
+      "sha": "37df3244ae3aa36e85178b6cf946338137fc3068",
+      "created_at": "2026-03-09T15:31:26+00:00"
+    },
+    "package_info": {
+      "transformers-version": "5.10.2",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.2.dev0",
+      "peft-commit-hash": "b2d61f5f80a7ac540fb572c077d8265a95986db8",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "diffusers-version": "0.38.0",
+      "diffusers-commit-hash": null,
+      "torch-version": "2.12.0+cu130",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 202002\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.11.2 (Git Hash 03c022d3ffdcee958cfacbe720048e725fdf644c)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 13.0\n  - NVCC architecture flags: -gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1  (built against CUDA 12.8)\n    - Built with CuDNN 92.0\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=7661cd9c6b841b62b7f411aa52ec51f05457263b, CUDA_FLAGS= -DLIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_OPERATIONS -Xfatbin -compress-all -DONNX_NAMESPACE=onnx_torch -gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_100,code=sm_100 -gencode arch=compute_120,code=sm_120 -Xcudafe --diag_suppress=cc_clobber_ignored,--diag_suppress=field_without_dll_interface,--diag_suppress=base_class_has_different_dll_interface,--diag_suppress=dll_interface_conflict_none_assumed,--diag_suppress=dll_interface_conflict_dllexport_assumed,--diag_suppress=bad_friend_decl --expt-relaxed-constexpr --expt-extended-lambda -Xfatbin -compress-all --threads 2 -compress-mode=size -Wno-deprecated-gpu-targets --expt-extended-lambda -DCUB_WRAPPED_NAMESPACE=at_cuda_detail -DDISABLE_CUSPARSE_DEPRECATED -DCUDA_HAS_FP16=1 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -DC10_NODEPRECATED, CUDA_VERSION=13.0, CUDNN_VERSION=9.20.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_MSLK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.12.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/results/psoft--flux2-klein-default.json b/method_comparison/image-gen/results/psoft--flux2-klein-default.json
new file mode 100644
index 0000000..028ccb0
--- /dev/null
+++ b/method_comparison/image-gen/results/psoft--flux2-klein-default.json
@@ -0,0 +1,258 @@
+{
+  "run_info": {
+    "created_at": "2026-06-09T19:39:00+00:00",
+    "total_time": 1357.3621943850012,
+    "experiment_name": "psoft/flux2-klein-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "black-forest-labs/FLUX.2-klein-base-4B",
+      "dataset_id": "peft-internal-testing/cat-image-dataset",
+      "dataset_split": "train",
+      "dtype": "bfloat16",
+      "resolution": 512,
+      "batch_size": 2,
+      "batch_size_eval": 1,
+      "repeats": 1000,
+      "max_steps": 750,
+      "eval_steps": 100,
+      "compile": false,
+      "use_gc": true,
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.0001
+      },
+      "lr_scheduler": null,
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "instance_prompts": [
+        "sks cat sitting on a chair in front of a box of chocolates",
+        "sks cat playing on the Steam Deck",
+        "sks cat wearing a necklace while sitting in a box on a sofa",
+        "a box with four donuts in front of sks cat",
+        "sks cat wearing a pink veil with flowers on it and a dagger made out of yellow cardboard",
+        "sks cat between two pillows, with one pillow showing a polar bear and the other a fox",
+        "sks cat with an espresso reading the newspaper",
+        "a close up of a hand petting sks cat on the head",
+        "sks cat opens a white door",
+        "sks cat with a VIP \"all access\" pass",
+        "sks cat in front of a monitor showing the video game \"RimWorld\"",
+        "sks cat reads a newspaper about cannabis",
+        "sks cat reading the newspaper with the title \"DIE BOX\"",
+        "sks cat being fed sushi",
+        "sks cat in front of a box of tomatoes",
+        "a gingerbread house in front of sks cat",
+        "sks cat is wearing a Wednesday Addams costume",
+        "sks cat looks skeptical as he reads a magazine depicting a black cat",
+        "sks cat wearing a striped scarf",
+        "sleepy sks cat lying in bed covered by a blue blanket"
+      ],
+      "image_column": "image",
+      "valid_size": 2,
+      "test_size": 4,
+      "num_inference_steps": 20,
+      "guidance_scale": 3.5,
+      "max_sequence_length": 512,
+      "text_encoder_out_layers": [
+        10,
+        20,
+        30
+      ],
+      "weighting_scheme": "none",
+      "logit_mean": 0.0,
+      "logit_std": 1.0,
+      "mode_scale": 1.29,
+      "dino_model_id": "facebook/dinov2-base",
+      "dino_image_size": 224,
+      "sample_image_prompts": [
+        "a photo of sks cat",
+        "a color drawing of sks cat",
+        "sks cat at the beach",
+        "a photo of sks dog",
+        "a photo of an orange cat"
+      ],
+      "drift_image_prompts": [
+        "a photo of cat",
+        "a color drawing of cat",
+        "cat sitting in a bathtub",
+        "cat looks into a mirror",
+        "a photo of cat next to a tree",
+        "the Mona Lisa but she looks angry",
+        "a dog holding a sign that says hello world",
+        "a photo of the Eiffel tower at night",
+        "an astronaut riding a horse",
+        "3d design concept of a chair that looks like an avocado"
+      ]
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "PSOFT",
+      "auto_mapping": null,
+      "peft_version": "0.18.2.dev0@UNKNOWN",
+      "base_model_name_or_path": null,
+      "revision": null,
+      "inference_mode": false,
+      "r": 32,
+      "target_modules": [
+        "linear_out",
+        "to_k",
+        "to_q",
+        "add_q_proj",
+        "to_out.0",
+        "add_k_proj",
+        "add_v_proj",
+        "to_add_out",
+        "to_v",
+        "linear_in",
+        "to_qkv_mlp_proj"
+      ],
+      "exclude_modules": null,
+      "psoft_alpha": 32,
+      "psoft_dropout": 0.0,
+      "fan_in_fan_out": false,
+      "ab_svd_init": "psoft_init",
+      "psoft_svd": "full",
+      "psoft_svd_lowrank_niter": 10,
+      "psoft_orth": true,
+      "psoft_mag_b": true,
+      "psoft_mag_a": true,
+      "use_cayley_neumann": false,
+      "num_cayley_neumann_terms": 5,
+      "cayley_neumann_eps": null,
+      "modules_to_save": null,
+      "init_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 10508918150,
+    "accelerator_memory_max": 10536091648,
+    "accelerator_memory_reserved_99th": 10536091648,
+    "train_time": 768.7374397489912,
+    "file_size": 211320,
+    "num_trainable_params": 44800,
+    "num_total_params": 3875589376,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 100,
+        "valid dino_similarity": 0.2855779528617859,
+        "train loss": 0.7623341679573059,
+        "train samples": 200,
+        "train time": 78.77100303703628,
+        "eval time": 16.26965157000086,
+        "mem allocated avg": 8412415232.0,
+        "mem reserved avg": 10519293460.48,
+        "elapsed time": 101.4285360540016
+      },
+      {
+        "step": 200,
+        "valid dino_similarity": 0.32477641105651855,
+        "train loss": 0.7769931554794312,
+        "train samples": 400,
+        "train time": 79.13769197095826,
+        "eval time": 16.34437730100035,
+        "mem allocated avg": 8412467456.0,
+        "mem reserved avg": 10482761072.64,
+        "elapsed time": 197.07398730400018
+      },
+      {
+        "step": 300,
+        "valid dino_similarity": 0.23470145463943481,
+        "train loss": 0.777502179145813,
+        "train samples": 600,
+        "train time": 80.56386206901516,
+        "eval time": 16.57895289800217,
+        "mem allocated avg": 8412518656.0,
+        "mem reserved avg": 10532757176.32,
+        "elapsed time": 294.3804629570004
+      },
+      {
+        "step": 400,
+        "valid dino_similarity": 0.41513872146606445,
+        "train loss": 0.7665997743606567,
+        "train samples": 800,
+        "train time": 80.04229699795542,
+        "eval time": 16.477963880999596,
+        "mem allocated avg": 8412569856.0,
+        "mem reserved avg": 10483348275.2,
+        "elapsed time": 391.0629991829992
+      },
+      {
+        "step": 500,
+        "valid dino_similarity": 0.42703813314437866,
+        "train loss": 0.7859480381011963,
+        "train samples": 1000,
+        "train time": 80.45795894099865,
+        "eval time": 16.47632352200162,
+        "mem allocated avg": 8412621056.0,
+        "mem reserved avg": 10533994496.0,
+        "elapsed time": 488.1569658119988
+      },
+      {
+        "step": 600,
+        "valid dino_similarity": 0.4445105791091919,
+        "train loss": 0.7589725255966187,
+        "train samples": 1200,
+        "train time": 80.06286906198511,
+        "eval time": 16.3954510140029,
+        "mem allocated avg": 8412672256.0,
+        "mem reserved avg": 10485760000.0,
+        "elapsed time": 584.7753636370035
+      },
+      {
+        "step": 700,
+        "valid dino_similarity": 0.395438015460968,
+        "train loss": 0.7900265455245972,
+        "train samples": 1400,
+        "train time": 80.21079930601991,
+        "eval time": 16.40045511900098,
+        "mem allocated avg": 8412723456.0,
+        "mem reserved avg": 10536091648.0,
+        "elapsed time": 681.5460075299998
+      },
+      {
+        "step": 750,
+        "test dino_similarity": 0.5984091758728027,
+        "drift": 0.15463966131210327,
+        "train loss": 0.7785661816596985,
+        "train samples": 1500
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "a3b4f4849157f664bdbc776fd7453c2783562f4d",
+      "created_at": "2026-01-14T13:42:28+00:00"
+    },
+    "dataset_info": {
+      "sha": "37df3244ae3aa36e85178b6cf946338137fc3068",
+      "created_at": "2026-03-09T15:31:26+00:00"
+    },
+    "package_info": {
+      "transformers-version": "5.10.2",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.2.dev0",
+      "peft-commit-hash": "b2d61f5f80a7ac540fb572c077d8265a95986db8",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "diffusers-version": "0.38.0",
+      "diffusers-commit-hash": null,
+      "torch-version": "2.12.0+cu130",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 202002\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.11.2 (Git Hash 03c022d3ffdcee958cfacbe720048e725fdf644c)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 13.0\n  - NVCC architecture flags: -gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1  (built against CUDA 12.8)\n    - Built with CuDNN 92.0\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=7661cd9c6b841b62b7f411aa52ec51f05457263b, CUDA_FLAGS= -DLIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_OPERATIONS -Xfatbin -compress-all -DONNX_NAMESPACE=onnx_torch -gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_100,code=sm_100 -gencode arch=compute_120,code=sm_120 -Xcudafe --diag_suppress=cc_clobber_ignored,--diag_suppress=field_without_dll_interface,--diag_suppress=base_class_has_different_dll_interface,--diag_suppress=dll_interface_conflict_none_assumed,--diag_suppress=dll_interface_conflict_dllexport_assumed,--diag_suppress=bad_friend_decl --expt-relaxed-constexpr --expt-extended-lambda -Xfatbin -compress-all --threads 2 -compress-mode=size -Wno-deprecated-gpu-targets --expt-extended-lambda -DCUB_WRAPPED_NAMESPACE=at_cuda_detail -DDISABLE_CUSPARSE_DEPRECATED -DCUDA_HAS_FP16=1 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -DC10_NODEPRECATED, CUDA_VERSION=13.0, CUDNN_VERSION=9.20.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_MSLK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.12.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/results/pvera--flux2-klein-default.json b/method_comparison/image-gen/results/pvera--flux2-klein-default.json
new file mode 100644
index 0000000..72cf798
--- /dev/null
+++ b/method_comparison/image-gen/results/pvera--flux2-klein-default.json
@@ -0,0 +1,252 @@
+{
+  "run_info": {
+    "created_at": "2026-06-09T20:02:23+00:00",
+    "total_time": 838.0967866440042,
+    "experiment_name": "pvera/flux2-klein-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "black-forest-labs/FLUX.2-klein-base-4B",
+      "dataset_id": "peft-internal-testing/cat-image-dataset",
+      "dataset_split": "train",
+      "dtype": "bfloat16",
+      "resolution": 512,
+      "batch_size": 2,
+      "batch_size_eval": 1,
+      "repeats": 1000,
+      "max_steps": 750,
+      "eval_steps": 100,
+      "compile": false,
+      "use_gc": true,
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.003
+      },
+      "lr_scheduler": null,
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "instance_prompts": [
+        "sks cat sitting on a chair in front of a box of chocolates",
+        "sks cat playing on the Steam Deck",
+        "sks cat wearing a necklace while sitting in a box on a sofa",
+        "a box with four donuts in front of sks cat",
+        "sks cat wearing a pink veil with flowers on it and a dagger made out of yellow cardboard",
+        "sks cat between two pillows, with one pillow showing a polar bear and the other a fox",
+        "sks cat with an espresso reading the newspaper",
+        "a close up of a hand petting sks cat on the head",
+        "sks cat opens a white door",
+        "sks cat with a VIP \"all access\" pass",
+        "sks cat in front of a monitor showing the video game \"RimWorld\"",
+        "sks cat reads a newspaper about cannabis",
+        "sks cat reading the newspaper with the title \"DIE BOX\"",
+        "sks cat being fed sushi",
+        "sks cat in front of a box of tomatoes",
+        "a gingerbread house in front of sks cat",
+        "sks cat is wearing a Wednesday Addams costume",
+        "sks cat looks skeptical as he reads a magazine depicting a black cat",
+        "sks cat wearing a striped scarf",
+        "sleepy sks cat lying in bed covered by a blue blanket"
+      ],
+      "image_column": "image",
+      "valid_size": 2,
+      "test_size": 4,
+      "num_inference_steps": 20,
+      "guidance_scale": 3.5,
+      "max_sequence_length": 512,
+      "text_encoder_out_layers": [
+        10,
+        20,
+        30
+      ],
+      "weighting_scheme": "none",
+      "logit_mean": 0.0,
+      "logit_std": 1.0,
+      "mode_scale": 1.29,
+      "dino_model_id": "facebook/dinov2-base",
+      "dino_image_size": 224,
+      "sample_image_prompts": [
+        "a photo of sks cat",
+        "a color drawing of sks cat",
+        "sks cat at the beach",
+        "a photo of sks dog",
+        "a photo of an orange cat"
+      ],
+      "drift_image_prompts": [
+        "a photo of cat",
+        "a color drawing of cat",
+        "cat sitting in a bathtub",
+        "cat looks into a mirror",
+        "a photo of cat next to a tree",
+        "the Mona Lisa but she looks angry",
+        "a dog holding a sign that says hello world",
+        "a photo of the Eiffel tower at night",
+        "an astronaut riding a horse",
+        "3d design concept of a chair that looks like an avocado"
+      ]
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "PVERA",
+      "auto_mapping": null,
+      "peft_version": "0.18.2.dev0@UNKNOWN",
+      "base_model_name_or_path": null,
+      "revision": null,
+      "inference_mode": false,
+      "r": 32,
+      "target_modules": [
+        "add_v_proj",
+        "to_v",
+        "to_add_out",
+        "to_q",
+        "to_k",
+        "linear_in",
+        "add_k_proj",
+        "to_qkv_mlp_proj",
+        "to_out.0",
+        "linear_out",
+        "add_q_proj"
+      ],
+      "projection_prng_key": 0,
+      "save_projection": true,
+      "pvera_dropout": 0.0,
+      "d_initial": 0.1,
+      "fan_in_fan_out": false,
+      "bias": "none",
+      "modules_to_save": null,
+      "init_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "sample_at_inference": false,
+      "generator_seed": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 10557155442,
+    "accelerator_memory_max": 10567548928,
+    "accelerator_memory_reserved_99th": 10567548928,
+    "train_time": 729.4813956100115,
+    "file_size": 9504248,
+    "num_trainable_params": 896000,
+    "num_total_params": 3876440576,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 100,
+        "valid dino_similarity": 0.25769221782684326,
+        "train loss": 0.7915690541267395,
+        "train samples": 200,
+        "train time": 76.76176030302304,
+        "eval time": 14.400904832000379,
+        "mem allocated avg": 8268563712.0,
+        "mem reserved avg": 10502474301.44,
+        "elapsed time": 97.58775338400301
+      },
+      {
+        "step": 200,
+        "valid dino_similarity": 0.2870693802833557,
+        "train loss": 0.7767768502235413,
+        "train samples": 400,
+        "train time": 77.93026918800024,
+        "eval time": 14.396406162995845,
+        "mem allocated avg": 8268615936.0,
+        "mem reserved avg": 10565451776.0,
+        "elapsed time": 190.06456187499862
+      },
+      {
+        "step": 300,
+        "valid dino_similarity": 0.3856334984302521,
+        "train loss": 0.7909408211708069,
+        "train samples": 600,
+        "train time": 77.87378783200984,
+        "eval time": 14.445942730002571,
+        "mem allocated avg": 8268667136.0,
+        "mem reserved avg": 10565451776.0,
+        "elapsed time": 282.53433472100005
+      },
+      {
+        "step": 400,
+        "valid dino_similarity": 0.4959363043308258,
+        "train loss": 0.7623284459114075,
+        "train samples": 800,
+        "train time": 77.9146170149761,
+        "eval time": 14.497627500997623,
+        "mem allocated avg": 8268718336.0,
+        "mem reserved avg": 10565451776.0,
+        "elapsed time": 375.100843496999
+      },
+      {
+        "step": 500,
+        "valid dino_similarity": 0.5209842324256897,
+        "train loss": 0.7953540682792664,
+        "train samples": 1000,
+        "train time": 77.01499478700862,
+        "eval time": 14.411549370997818,
+        "mem allocated avg": 8268769536.0,
+        "mem reserved avg": 10565451776.0,
+        "elapsed time": 466.67993758500234
+      },
+      {
+        "step": 600,
+        "valid dino_similarity": 0.638646125793457,
+        "train loss": 0.7682441473007202,
+        "train samples": 1200,
+        "train time": 77.85869830898446,
+        "eval time": 14.445731039995735,
+        "mem allocated avg": 8268820736.0,
+        "mem reserved avg": 10566206750.72,
+        "elapsed time": 559.1368453489995
+      },
+      {
+        "step": 700,
+        "valid dino_similarity": 0.6130639910697937,
+        "train loss": 0.7661926746368408,
+        "train samples": 1400,
+        "train time": 77.95663530901948,
+        "eval time": 14.545989138998266,
+        "mem allocated avg": 8268871936.0,
+        "mem reserved avg": 10565451776.0,
+        "elapsed time": 651.7932370070048
+      },
+      {
+        "step": 750,
+        "test dino_similarity": 0.6553937196731567,
+        "drift": 0.23013418912887573,
+        "train loss": 0.7605770230293274,
+        "train samples": 1500
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "a3b4f4849157f664bdbc776fd7453c2783562f4d",
+      "created_at": "2026-01-14T13:42:28+00:00"
+    },
+    "dataset_info": {
+      "sha": "37df3244ae3aa36e85178b6cf946338137fc3068",
+      "created_at": "2026-03-09T15:31:26+00:00"
+    },
+    "package_info": {
+      "transformers-version": "5.10.2",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.2.dev0",
+      "peft-commit-hash": "b2d61f5f80a7ac540fb572c077d8265a95986db8",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "diffusers-version": "0.38.0",
+      "diffusers-commit-hash": null,
+      "torch-version": "2.12.0+cu130",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 202002\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.11.2 (Git Hash 03c022d3ffdcee958cfacbe720048e725fdf644c)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 13.0\n  - NVCC architecture flags: -gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1  (built against CUDA 12.8)\n    - Built with CuDNN 92.0\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=7661cd9c6b841b62b7f411aa52ec51f05457263b, CUDA_FLAGS= -DLIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_OPERATIONS -Xfatbin -compress-all -DONNX_NAMESPACE=onnx_torch -gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_100,code=sm_100 -gencode arch=compute_120,code=sm_120 -Xcudafe --diag_suppress=cc_clobber_ignored,--diag_suppress=field_without_dll_interface,--diag_suppress=base_class_has_different_dll_interface,--diag_suppress=dll_interface_conflict_none_assumed,--diag_suppress=dll_interface_conflict_dllexport_assumed,--diag_suppress=bad_friend_decl --expt-relaxed-constexpr --expt-extended-lambda -Xfatbin -compress-all --threads 2 -compress-mode=size -Wno-deprecated-gpu-targets --expt-extended-lambda -DCUB_WRAPPED_NAMESPACE=at_cuda_detail -DDISABLE_CUSPARSE_DEPRECATED -DCUDA_HAS_FP16=1 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -DC10_NODEPRECATED, CUDA_VERSION=13.0, CUDNN_VERSION=9.20.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_MSLK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.12.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/results/randlora--flux2-klein-default.json b/method_comparison/image-gen/results/randlora--flux2-klein-default.json
new file mode 100644
index 0000000..0558e21
--- /dev/null
+++ b/method_comparison/image-gen/results/randlora--flux2-klein-default.json
@@ -0,0 +1,253 @@
+{
+  "run_info": {
+    "created_at": "2026-06-09T20:17:03+00:00",
+    "total_time": 2401.9957280300005,
+    "experiment_name": "randlora/flux2-klein-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "black-forest-labs/FLUX.2-klein-base-4B",
+      "dataset_id": "peft-internal-testing/cat-image-dataset",
+      "dataset_split": "train",
+      "dtype": "bfloat16",
+      "resolution": 512,
+      "batch_size": 2,
+      "batch_size_eval": 1,
+      "repeats": 1000,
+      "max_steps": 750,
+      "eval_steps": 100,
+      "compile": false,
+      "use_gc": true,
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.0001
+      },
+      "lr_scheduler": null,
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "instance_prompts": [
+        "sks cat sitting on a chair in front of a box of chocolates",
+        "sks cat playing on the Steam Deck",
+        "sks cat wearing a necklace while sitting in a box on a sofa",
+        "a box with four donuts in front of sks cat",
+        "sks cat wearing a pink veil with flowers on it and a dagger made out of yellow cardboard",
+        "sks cat between two pillows, with one pillow showing a polar bear and the other a fox",
+        "sks cat with an espresso reading the newspaper",
+        "a close up of a hand petting sks cat on the head",
+        "sks cat opens a white door",
+        "sks cat with a VIP \"all access\" pass",
+        "sks cat in front of a monitor showing the video game \"RimWorld\"",
+        "sks cat reads a newspaper about cannabis",
+        "sks cat reading the newspaper with the title \"DIE BOX\"",
+        "sks cat being fed sushi",
+        "sks cat in front of a box of tomatoes",
+        "a gingerbread house in front of sks cat",
+        "sks cat is wearing a Wednesday Addams costume",
+        "sks cat looks skeptical as he reads a magazine depicting a black cat",
+        "sks cat wearing a striped scarf",
+        "sleepy sks cat lying in bed covered by a blue blanket"
+      ],
+      "image_column": "image",
+      "valid_size": 2,
+      "test_size": 4,
+      "num_inference_steps": 20,
+      "guidance_scale": 3.5,
+      "max_sequence_length": 512,
+      "text_encoder_out_layers": [
+        10,
+        20,
+        30
+      ],
+      "weighting_scheme": "none",
+      "logit_mean": 0.0,
+      "logit_std": 1.0,
+      "mode_scale": 1.29,
+      "dino_model_id": "facebook/dinov2-base",
+      "dino_image_size": 224,
+      "sample_image_prompts": [
+        "a photo of sks cat",
+        "a color drawing of sks cat",
+        "sks cat at the beach",
+        "a photo of sks dog",
+        "a photo of an orange cat"
+      ],
+      "drift_image_prompts": [
+        "a photo of cat",
+        "a color drawing of cat",
+        "cat sitting in a bathtub",
+        "cat looks into a mirror",
+        "a photo of cat next to a tree",
+        "the Mona Lisa but she looks angry",
+        "a dog holding a sign that says hello world",
+        "a photo of the Eiffel tower at night",
+        "an astronaut riding a horse",
+        "3d design concept of a chair that looks like an avocado"
+      ]
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "RANDLORA",
+      "auto_mapping": null,
+      "peft_version": null,
+      "base_model_name_or_path": null,
+      "revision": null,
+      "inference_mode": false,
+      "r": 32,
+      "target_modules": [
+        "add_k_proj",
+        "to_add_out",
+        "add_q_proj",
+        "add_v_proj",
+        "to_k",
+        "to_qkv_mlp_proj",
+        "linear_in",
+        "linear_out",
+        "to_q",
+        "to_out.0",
+        "to_v"
+      ],
+      "projection_prng_key": 0,
+      "save_projection": true,
+      "sparse": false,
+      "very_sparse": false,
+      "randlora_dropout": 0.0,
+      "fan_in_fan_out": false,
+      "randlora_alpha": 640,
+      "bias": "none",
+      "modules_to_save": null,
+      "init_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 11311657604,
+    "accelerator_memory_max": 11456741376,
+    "accelerator_memory_reserved_99th": 11456741376,
+    "train_time": 2124.7402266980134,
+    "file_size": 99999999,
+    "num_trainable_params": 23838720,
+    "num_total_params": 3899383296,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 100,
+        "valid dino_similarity": 0.6218022108078003,
+        "train loss": 0.7680090069770813,
+        "train samples": 200,
+        "train time": 224.56330100700143,
+        "eval time": 38.93820964999759,
+        "mem allocated avg": 9691056670.72,
+        "mem reserved avg": 11264327680.0,
+        "elapsed time": 269.9678261020017
+      },
+      {
+        "step": 200,
+        "valid dino_similarity": 0.7159435749053955,
+        "train loss": 0.7397028207778931,
+        "train samples": 400,
+        "train time": 228.395642837997,
+        "eval time": 37.7776130179991,
+        "mem allocated avg": 9690448291.84,
+        "mem reserved avg": 11416874516.48,
+        "elapsed time": 536.2968212320047
+      },
+      {
+        "step": 300,
+        "valid dino_similarity": 0.7299408912658691,
+        "train loss": 0.7075288891792297,
+        "train samples": 600,
+        "train time": 235.1546070290351,
+        "eval time": 38.53865340599441,
+        "mem allocated avg": 9690802268.16,
+        "mem reserved avg": 11265858600.96,
+        "elapsed time": 810.1462682580022
+      },
+      {
+        "step": 400,
+        "valid dino_similarity": 0.7317898273468018,
+        "train loss": 0.6752651333808899,
+        "train samples": 800,
+        "train time": 230.55097187395586,
+        "eval time": 37.91794563899748,
+        "mem allocated avg": 9690845603.84,
+        "mem reserved avg": 11265900544.0,
+        "elapsed time": 1078.7743308600038
+      },
+      {
+        "step": 500,
+        "valid dino_similarity": 0.6655710339546204,
+        "train loss": 0.6499471664428711,
+        "train samples": 1000,
+        "train time": 230.8947472640357,
+        "eval time": 37.84093423200102,
+        "mem allocated avg": 9690908600.32,
+        "mem reserved avg": 11265879572.48,
+        "elapsed time": 1347.6682676870041
+      },
+      {
+        "step": 600,
+        "valid dino_similarity": 0.7108818292617798,
+        "train loss": 0.6446861624717712,
+        "train samples": 1200,
+        "train time": 227.82180542298738,
+        "eval time": 37.25759751300211,
+        "mem allocated avg": 9690944071.68,
+        "mem reserved avg": 11267871866.88,
+        "elapsed time": 1612.9048466910026
+      },
+      {
+        "step": 700,
+        "valid dino_similarity": 0.6809412240982056,
+        "train loss": 0.6387181878089905,
+        "train samples": 1400,
+        "train time": 228.2885742610015,
+        "eval time": 39.02297116599948,
+        "mem allocated avg": 9690806528.0,
+        "mem reserved avg": 11456720404.48,
+        "elapsed time": 1880.3739446149993
+      },
+      {
+        "step": 750,
+        "test dino_similarity": 0.6052322387695312,
+        "drift": 0.4385121874511242,
+        "train loss": 0.6244163513183594,
+        "train samples": 1500
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "a3b4f4849157f664bdbc776fd7453c2783562f4d",
+      "created_at": "2026-01-14T13:42:28+00:00"
+    },
+    "dataset_info": {
+      "sha": "37df3244ae3aa36e85178b6cf946338137fc3068",
+      "created_at": "2026-03-09T15:31:26+00:00"
+    },
+    "package_info": {
+      "transformers-version": "5.10.2",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.2.dev0",
+      "peft-commit-hash": "b2d61f5f80a7ac540fb572c077d8265a95986db8",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "diffusers-version": "0.38.0",
+      "diffusers-commit-hash": null,
+      "torch-version": "2.12.0+cu130",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 202002\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.11.2 (Git Hash 03c022d3ffdcee958cfacbe720048e725fdf644c)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 13.0\n  - NVCC architecture flags: -gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1  (built against CUDA 12.8)\n    - Built with CuDNN 92.0\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=7661cd9c6b841b62b7f411aa52ec51f05457263b, CUDA_FLAGS= -DLIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_OPERATIONS -Xfatbin -compress-all -DONNX_NAMESPACE=onnx_torch -gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_100,code=sm_100 -gencode arch=compute_120,code=sm_120 -Xcudafe --diag_suppress=cc_clobber_ignored,--diag_suppress=field_without_dll_interface,--diag_suppress=base_class_has_different_dll_interface,--diag_suppress=dll_interface_conflict_none_assumed,--diag_suppress=dll_interface_conflict_dllexport_assumed,--diag_suppress=bad_friend_decl --expt-relaxed-constexpr --expt-extended-lambda -Xfatbin -compress-all --threads 2 -compress-mode=size -Wno-deprecated-gpu-targets --expt-extended-lambda -DCUB_WRAPPED_NAMESPACE=at_cuda_detail -DDISABLE_CUSPARSE_DEPRECATED -DCUDA_HAS_FP16=1 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -DC10_NODEPRECATED, CUDA_VERSION=13.0, CUDNN_VERSION=9.20.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_MSLK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.12.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/results/road--flux2-klein-default.json b/method_comparison/image-gen/results/road--flux2-klein-default.json
new file mode 100644
index 0000000..bf58992
--- /dev/null
+++ b/method_comparison/image-gen/results/road--flux2-klein-default.json
@@ -0,0 +1,243 @@
+{
+  "run_info": {
+    "created_at": "2026-06-09T20:58:43+00:00",
+    "total_time": 1139.1241061659966,
+    "experiment_name": "road/flux2-klein-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "black-forest-labs/FLUX.2-klein-base-4B",
+      "dataset_id": "peft-internal-testing/cat-image-dataset",
+      "dataset_split": "train",
+      "dtype": "bfloat16",
+      "resolution": 512,
+      "batch_size": 2,
+      "batch_size_eval": 1,
+      "repeats": 1000,
+      "max_steps": 750,
+      "eval_steps": 100,
+      "compile": false,
+      "use_gc": true,
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.001
+      },
+      "lr_scheduler": null,
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "instance_prompts": [
+        "sks cat sitting on a chair in front of a box of chocolates",
+        "sks cat playing on the Steam Deck",
+        "sks cat wearing a necklace while sitting in a box on a sofa",
+        "a box with four donuts in front of sks cat",
+        "sks cat wearing a pink veil with flowers on it and a dagger made out of yellow cardboard",
+        "sks cat between two pillows, with one pillow showing a polar bear and the other a fox",
+        "sks cat with an espresso reading the newspaper",
+        "a close up of a hand petting sks cat on the head",
+        "sks cat opens a white door",
+        "sks cat with a VIP \"all access\" pass",
+        "sks cat in front of a monitor showing the video game \"RimWorld\"",
+        "sks cat reads a newspaper about cannabis",
+        "sks cat reading the newspaper with the title \"DIE BOX\"",
+        "sks cat being fed sushi",
+        "sks cat in front of a box of tomatoes",
+        "a gingerbread house in front of sks cat",
+        "sks cat is wearing a Wednesday Addams costume",
+        "sks cat looks skeptical as he reads a magazine depicting a black cat",
+        "sks cat wearing a striped scarf",
+        "sleepy sks cat lying in bed covered by a blue blanket"
+      ],
+      "image_column": "image",
+      "valid_size": 2,
+      "test_size": 4,
+      "num_inference_steps": 20,
+      "guidance_scale": 3.5,
+      "max_sequence_length": 512,
+      "text_encoder_out_layers": [
+        10,
+        20,
+        30
+      ],
+      "weighting_scheme": "none",
+      "logit_mean": 0.0,
+      "logit_std": 1.0,
+      "mode_scale": 1.29,
+      "dino_model_id": "facebook/dinov2-base",
+      "dino_image_size": 224,
+      "sample_image_prompts": [
+        "a photo of sks cat",
+        "a color drawing of sks cat",
+        "sks cat at the beach",
+        "a photo of sks dog",
+        "a photo of an orange cat"
+      ],
+      "drift_image_prompts": [
+        "a photo of cat",
+        "a color drawing of cat",
+        "cat sitting in a bathtub",
+        "cat looks into a mirror",
+        "a photo of cat next to a tree",
+        "the Mona Lisa but she looks angry",
+        "a dog holding a sign that says hello world",
+        "a photo of the Eiffel tower at night",
+        "an astronaut riding a horse",
+        "3d design concept of a chair that looks like an avocado"
+      ]
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "ROAD",
+      "auto_mapping": null,
+      "peft_version": "0.18.2.dev0@UNKNOWN",
+      "base_model_name_or_path": null,
+      "revision": null,
+      "inference_mode": false,
+      "variant": "road_1",
+      "group_size": 64,
+      "init_weights": true,
+      "target_modules": [
+        "add_q_proj",
+        "to_out.0",
+        "to_v",
+        "add_k_proj",
+        "linear_out",
+        "to_qkv_mlp_proj",
+        "add_v_proj",
+        "to_k",
+        "to_q",
+        "linear_in",
+        "to_add_out"
+      ],
+      "modules_to_save": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 11342871614,
+    "accelerator_memory_max": 11345592320,
+    "accelerator_memory_reserved_99th": 11345592320,
+    "train_time": 1011.2359452090022,
+    "file_size": 3584880,
+    "num_trainable_params": 890880,
+    "num_total_params": 3876435456,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 100,
+        "valid dino_similarity": 0.5963612794876099,
+        "train loss": 0.7565115094184875,
+        "train samples": 200,
+        "train time": 110.76231426098093,
+        "eval time": 17.264871418999974,
+        "mem allocated avg": 8262501632.0,
+        "mem reserved avg": 11341335101.44,
+        "elapsed time": 134.44107915000495
+      },
+      {
+        "step": 200,
+        "valid dino_similarity": 0.6380842328071594,
+        "train loss": 0.7663602232933044,
+        "train samples": 400,
+        "train time": 110.86184153203067,
+        "eval time": 17.133564679999836,
+        "mem allocated avg": 8262553856.0,
+        "mem reserved avg": 11341377044.48,
+        "elapsed time": 262.5899115220018
+      },
+      {
+        "step": 300,
+        "valid dino_similarity": 0.6356664896011353,
+        "train loss": 0.7627978920936584,
+        "train samples": 600,
+        "train time": 110.97850952997396,
+        "eval time": 17.10834584999975,
+        "mem allocated avg": 8262605056.0,
+        "mem reserved avg": 11341628702.72,
+        "elapsed time": 390.8290679740021
+      },
+      {
+        "step": 400,
+        "valid dino_similarity": 0.6554849743843079,
+        "train loss": 0.749195396900177,
+        "train samples": 800,
+        "train time": 111.18083769500663,
+        "eval time": 17.08279047600081,
+        "mem allocated avg": 8262656256.0,
+        "mem reserved avg": 11342845050.88,
+        "elapsed time": 519.2451625000031
+      },
+      {
+        "step": 500,
+        "valid dino_similarity": 0.6434327363967896,
+        "train loss": 0.7660223245620728,
+        "train samples": 1000,
+        "train time": 110.59274824299064,
+        "eval time": 17.166296190996945,
+        "mem allocated avg": 8262707456.0,
+        "mem reserved avg": 11342677278.72,
+        "elapsed time": 647.1563322540023
+      },
+      {
+        "step": 600,
+        "valid dino_similarity": 0.6683677434921265,
+        "train loss": 0.7344561815261841,
+        "train samples": 1200,
+        "train time": 111.48632575400552,
+        "eval time": 17.197563703004562,
+        "mem allocated avg": 8262758656.0,
+        "mem reserved avg": 11343474196.48,
+        "elapsed time": 775.9936918770036
+      },
+      {
+        "step": 700,
+        "valid dino_similarity": 0.6153469085693359,
+        "train loss": 0.7661228179931641,
+        "train samples": 1400,
+        "train time": 110.98712137102848,
+        "eval time": 17.114933734999795,
+        "mem allocated avg": 8262809856.0,
+        "mem reserved avg": 11345571348.48,
+        "elapsed time": 904.244964522004
+      },
+      {
+        "step": 750,
+        "test dino_similarity": 0.6731533209482828,
+        "drift": 0.2640690803527832,
+        "train loss": 0.7531635761260986,
+        "train samples": 1500
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "a3b4f4849157f664bdbc776fd7453c2783562f4d",
+      "created_at": "2026-01-14T13:42:28+00:00"
+    },
+    "dataset_info": {
+      "sha": "37df3244ae3aa36e85178b6cf946338137fc3068",
+      "created_at": "2026-03-09T15:31:26+00:00"
+    },
+    "package_info": {
+      "transformers-version": "5.10.2",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.2.dev0",
+      "peft-commit-hash": "b2d61f5f80a7ac540fb572c077d8265a95986db8",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "diffusers-version": "0.38.0",
+      "diffusers-commit-hash": null,
+      "torch-version": "2.12.0+cu130",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 202002\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.11.2 (Git Hash 03c022d3ffdcee958cfacbe720048e725fdf644c)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 13.0\n  - NVCC architecture flags: -gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1  (built against CUDA 12.8)\n    - Built with CuDNN 92.0\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=7661cd9c6b841b62b7f411aa52ec51f05457263b, CUDA_FLAGS= -DLIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_OPERATIONS -Xfatbin -compress-all -DONNX_NAMESPACE=onnx_torch -gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_100,code=sm_100 -gencode arch=compute_120,code=sm_120 -Xcudafe --diag_suppress=cc_clobber_ignored,--diag_suppress=field_without_dll_interface,--diag_suppress=base_class_has_different_dll_interface,--diag_suppress=dll_interface_conflict_none_assumed,--diag_suppress=dll_interface_conflict_dllexport_assumed,--diag_suppress=bad_friend_decl --expt-relaxed-constexpr --expt-extended-lambda -Xfatbin -compress-all --threads 2 -compress-mode=size -Wno-deprecated-gpu-targets --expt-extended-lambda -DCUB_WRAPPED_NAMESPACE=at_cuda_detail -DDISABLE_CUSPARSE_DEPRECATED -DCUDA_HAS_FP16=1 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -DC10_NODEPRECATED, CUDA_VERSION=13.0, CUDNN_VERSION=9.20.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_MSLK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.12.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/results/shira--flux2-klein-default.json b/method_comparison/image-gen/results/shira--flux2-klein-default.json
new file mode 100644
index 0000000..39f6364
--- /dev/null
+++ b/method_comparison/image-gen/results/shira--flux2-klein-default.json
@@ -0,0 +1,246 @@
+{
+  "run_info": {
+    "created_at": "2026-06-09T21:18:30+00:00",
+    "total_time": 1030.4824050800016,
+    "experiment_name": "shira/flux2-klein-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "black-forest-labs/FLUX.2-klein-base-4B",
+      "dataset_id": "peft-internal-testing/cat-image-dataset",
+      "dataset_split": "train",
+      "dtype": "bfloat16",
+      "resolution": 512,
+      "batch_size": 2,
+      "batch_size_eval": 1,
+      "repeats": 1000,
+      "max_steps": 750,
+      "eval_steps": 100,
+      "compile": false,
+      "use_gc": true,
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.0001
+      },
+      "lr_scheduler": null,
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "instance_prompts": [
+        "sks cat sitting on a chair in front of a box of chocolates",
+        "sks cat playing on the Steam Deck",
+        "sks cat wearing a necklace while sitting in a box on a sofa",
+        "a box with four donuts in front of sks cat",
+        "sks cat wearing a pink veil with flowers on it and a dagger made out of yellow cardboard",
+        "sks cat between two pillows, with one pillow showing a polar bear and the other a fox",
+        "sks cat with an espresso reading the newspaper",
+        "a close up of a hand petting sks cat on the head",
+        "sks cat opens a white door",
+        "sks cat with a VIP \"all access\" pass",
+        "sks cat in front of a monitor showing the video game \"RimWorld\"",
+        "sks cat reads a newspaper about cannabis",
+        "sks cat reading the newspaper with the title \"DIE BOX\"",
+        "sks cat being fed sushi",
+        "sks cat in front of a box of tomatoes",
+        "a gingerbread house in front of sks cat",
+        "sks cat is wearing a Wednesday Addams costume",
+        "sks cat looks skeptical as he reads a magazine depicting a black cat",
+        "sks cat wearing a striped scarf",
+        "sleepy sks cat lying in bed covered by a blue blanket"
+      ],
+      "image_column": "image",
+      "valid_size": 2,
+      "test_size": 4,
+      "num_inference_steps": 20,
+      "guidance_scale": 3.5,
+      "max_sequence_length": 512,
+      "text_encoder_out_layers": [
+        10,
+        20,
+        30
+      ],
+      "weighting_scheme": "none",
+      "logit_mean": 0.0,
+      "logit_std": 1.0,
+      "mode_scale": 1.29,
+      "dino_model_id": "facebook/dinov2-base",
+      "dino_image_size": 224,
+      "sample_image_prompts": [
+        "a photo of sks cat",
+        "a color drawing of sks cat",
+        "sks cat at the beach",
+        "a photo of sks dog",
+        "a photo of an orange cat"
+      ],
+      "drift_image_prompts": [
+        "a photo of cat",
+        "a color drawing of cat",
+        "cat sitting in a bathtub",
+        "cat looks into a mirror",
+        "a photo of cat next to a tree",
+        "the Mona Lisa but she looks angry",
+        "a dog holding a sign that says hello world",
+        "a photo of the Eiffel tower at night",
+        "an astronaut riding a horse",
+        "3d design concept of a chair that looks like an avocado"
+      ]
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "SHIRA",
+      "auto_mapping": null,
+      "peft_version": "0.18.2.dev0@UNKNOWN",
+      "base_model_name_or_path": null,
+      "revision": null,
+      "inference_mode": false,
+      "r": 32,
+      "mask_type": "random",
+      "random_seed": null,
+      "target_modules": [
+        "add_k_proj",
+        "to_q",
+        "to_v",
+        "linear_in",
+        "to_out.0",
+        "to_qkv_mlp_proj",
+        "add_v_proj",
+        "to_k",
+        "to_add_out",
+        "add_q_proj",
+        "linear_out"
+      ],
+      "fan_in_fan_out": false,
+      "init_weights": true,
+      "modules_to_save": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 11053786202,
+    "accelerator_memory_max": 11054088192,
+    "accelerator_memory_reserved_99th": 11054088192,
+    "train_time": 791.5365517199971,
+    "file_size": 460085512,
+    "num_trainable_params": 38338560,
+    "num_total_params": 3913883136,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 100,
+        "valid dino_similarity": 0.6328508853912354,
+        "train loss": 0.7553548216819763,
+        "train samples": 200,
+        "train time": 77.43554178798513,
+        "eval time": 20.00034182699892,
+        "mem allocated avg": 9198793492.48,
+        "mem reserved avg": 11051823267.84,
+        "elapsed time": 103.76552881600219
+      },
+      {
+        "step": 200,
+        "valid dino_similarity": 0.672196090221405,
+        "train loss": 0.7639323472976685,
+        "train samples": 400,
+        "train time": 77.33456317505625,
+        "eval time": 19.873502695001662,
+        "mem allocated avg": 9198833920.0,
+        "mem reserved avg": 11054088192.0,
+        "elapsed time": 201.13830677299848
+      },
+      {
+        "step": 300,
+        "valid dino_similarity": 0.704167366027832,
+        "train loss": 0.7580311894416809,
+        "train samples": 600,
+        "train time": 77.17752407102671,
+        "eval time": 19.98289902399847,
+        "mem allocated avg": 9198885120.0,
+        "mem reserved avg": 11054088192.0,
+        "elapsed time": 298.4634704700002
+      },
+      {
+        "step": 400,
+        "valid dino_similarity": 0.6893129348754883,
+        "train loss": 0.7440494894981384,
+        "train samples": 800,
+        "train time": 78.16344256099546,
+        "eval time": 19.923559913004283,
+        "mem allocated avg": 9198936320.0,
+        "mem reserved avg": 11054088192.0,
+        "elapsed time": 396.7141392699996
+      },
+      {
+        "step": 500,
+        "valid dino_similarity": 0.622692346572876,
+        "train loss": 0.7582421898841858,
+        "train samples": 1000,
+        "train time": 77.92251892403146,
+        "eval time": 19.98927991600067,
+        "mem allocated avg": 9198987520.0,
+        "mem reserved avg": 11054088192.0,
+        "elapsed time": 494.791013424001
+      },
+      {
+        "step": 600,
+        "valid dino_similarity": 0.6819298267364502,
+        "train loss": 0.7263849377632141,
+        "train samples": 1200,
+        "train time": 78.39599512299901,
+        "eval time": 19.919890109995322,
+        "mem allocated avg": 9199038720.0,
+        "mem reserved avg": 11054088192.0,
+        "elapsed time": 593.2705306089993
+      },
+      {
+        "step": 700,
+        "valid dino_similarity": 0.6813869476318359,
+        "train loss": 0.7554052472114563,
+        "train samples": 1400,
+        "train time": 77.13488083695847,
+        "eval time": 19.923660512002243,
+        "mem allocated avg": 9199089920.0,
+        "mem reserved avg": 11054088192.0,
+        "elapsed time": 690.4927471430055
+      },
+      {
+        "step": 750,
+        "test dino_similarity": 0.7041612068812052,
+        "drift": 0.2558731734752655,
+        "train loss": 0.741328775882721,
+        "train samples": 1500
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "a3b4f4849157f664bdbc776fd7453c2783562f4d",
+      "created_at": "2026-01-14T13:42:28+00:00"
+    },
+    "dataset_info": {
+      "sha": "37df3244ae3aa36e85178b6cf946338137fc3068",
+      "created_at": "2026-03-09T15:31:26+00:00"
+    },
+    "package_info": {
+      "transformers-version": "5.10.2",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.2.dev0",
+      "peft-commit-hash": "b2d61f5f80a7ac540fb572c077d8265a95986db8",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "diffusers-version": "0.38.0",
+      "diffusers-commit-hash": null,
+      "torch-version": "2.12.0+cu130",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 202002\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.11.2 (Git Hash 03c022d3ffdcee958cfacbe720048e725fdf644c)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 13.0\n  - NVCC architecture flags: -gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1  (built against CUDA 12.8)\n    - Built with CuDNN 92.0\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=7661cd9c6b841b62b7f411aa52ec51f05457263b, CUDA_FLAGS= -DLIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_OPERATIONS -Xfatbin -compress-all -DONNX_NAMESPACE=onnx_torch -gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_100,code=sm_100 -gencode arch=compute_120,code=sm_120 -Xcudafe --diag_suppress=cc_clobber_ignored,--diag_suppress=field_without_dll_interface,--diag_suppress=base_class_has_different_dll_interface,--diag_suppress=dll_interface_conflict_none_assumed,--diag_suppress=dll_interface_conflict_dllexport_assumed,--diag_suppress=bad_friend_decl --expt-relaxed-constexpr --expt-extended-lambda -Xfatbin -compress-all --threads 2 -compress-mode=size -Wno-deprecated-gpu-targets --expt-extended-lambda -DCUB_WRAPPED_NAMESPACE=at_cuda_detail -DDISABLE_CUSPARSE_DEPRECATED -DCUDA_HAS_FP16=1 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -DC10_NODEPRECATED, CUDA_VERSION=13.0, CUDNN_VERSION=9.20.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_MSLK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.12.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/results/vblora--flux2-klein-default.json b/method_comparison/image-gen/results/vblora--flux2-klein-default.json
new file mode 100644
index 0000000..c1d6de9
--- /dev/null
+++ b/method_comparison/image-gen/results/vblora--flux2-klein-default.json
@@ -0,0 +1,254 @@
+{
+  "run_info": {
+    "created_at": "2026-06-09T21:36:44+00:00",
+    "total_time": 806.8340942150026,
+    "experiment_name": "vblora/flux2-klein-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "black-forest-labs/FLUX.2-klein-base-4B",
+      "dataset_id": "peft-internal-testing/cat-image-dataset",
+      "dataset_split": "train",
+      "dtype": "bfloat16",
+      "resolution": 512,
+      "batch_size": 2,
+      "batch_size_eval": 1,
+      "repeats": 1000,
+      "max_steps": 750,
+      "eval_steps": 100,
+      "compile": false,
+      "use_gc": true,
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.0001
+      },
+      "lr_scheduler": null,
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "instance_prompts": [
+        "sks cat sitting on a chair in front of a box of chocolates",
+        "sks cat playing on the Steam Deck",
+        "sks cat wearing a necklace while sitting in a box on a sofa",
+        "a box with four donuts in front of sks cat",
+        "sks cat wearing a pink veil with flowers on it and a dagger made out of yellow cardboard",
+        "sks cat between two pillows, with one pillow showing a polar bear and the other a fox",
+        "sks cat with an espresso reading the newspaper",
+        "a close up of a hand petting sks cat on the head",
+        "sks cat opens a white door",
+        "sks cat with a VIP \"all access\" pass",
+        "sks cat in front of a monitor showing the video game \"RimWorld\"",
+        "sks cat reads a newspaper about cannabis",
+        "sks cat reading the newspaper with the title \"DIE BOX\"",
+        "sks cat being fed sushi",
+        "sks cat in front of a box of tomatoes",
+        "a gingerbread house in front of sks cat",
+        "sks cat is wearing a Wednesday Addams costume",
+        "sks cat looks skeptical as he reads a magazine depicting a black cat",
+        "sks cat wearing a striped scarf",
+        "sleepy sks cat lying in bed covered by a blue blanket"
+      ],
+      "image_column": "image",
+      "valid_size": 2,
+      "test_size": 4,
+      "num_inference_steps": 20,
+      "guidance_scale": 3.5,
+      "max_sequence_length": 512,
+      "text_encoder_out_layers": [
+        10,
+        20,
+        30
+      ],
+      "weighting_scheme": "none",
+      "logit_mean": 0.0,
+      "logit_std": 1.0,
+      "mode_scale": 1.29,
+      "dino_model_id": "facebook/dinov2-base",
+      "dino_image_size": 224,
+      "sample_image_prompts": [
+        "a photo of sks cat",
+        "a color drawing of sks cat",
+        "sks cat at the beach",
+        "a photo of sks dog",
+        "a photo of an orange cat"
+      ],
+      "drift_image_prompts": [
+        "a photo of cat",
+        "a color drawing of cat",
+        "cat sitting in a bathtub",
+        "cat looks into a mirror",
+        "a photo of cat next to a tree",
+        "the Mona Lisa but she looks angry",
+        "a dog holding a sign that says hello world",
+        "a photo of the Eiffel tower at night",
+        "an astronaut riding a horse",
+        "3d design concept of a chair that looks like an avocado"
+      ]
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "VBLORA",
+      "auto_mapping": null,
+      "peft_version": "0.18.2.dev0@UNKNOWN",
+      "base_model_name_or_path": null,
+      "revision": null,
+      "inference_mode": false,
+      "r": 32,
+      "num_vectors": 256,
+      "vector_length": 256,
+      "topk": 2,
+      "target_modules": [
+        "add_k_proj",
+        "linear_out",
+        "add_v_proj",
+        "add_q_proj",
+        "linear_in",
+        "to_k",
+        "to_out.0",
+        "to_qkv_mlp_proj",
+        "to_add_out",
+        "to_v",
+        "to_q"
+      ],
+      "exclude_modules": null,
+      "save_only_topk_weights": false,
+      "vblora_dropout": 0.0,
+      "fan_in_fan_out": false,
+      "bias": "none",
+      "modules_to_save": null,
+      "init_vector_bank_bound": 0.02,
+      "init_logits_std": 0.1,
+      "layers_to_transform": null,
+      "layers_pattern": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 10685652140,
+    "accelerator_memory_max": 10705960960,
+    "accelerator_memory_reserved_99th": 10705960960,
+    "train_time": 701.1592478580133,
+    "file_size": 153639928,
+    "num_trainable_params": 38404096,
+    "num_total_params": 3913948672,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 100,
+        "valid dino_similarity": 0.2781708240509033,
+        "train loss": 0.7584009170532227,
+        "train samples": 200,
+        "train time": 75.05911143900448,
+        "eval time": 13.788038845996198,
+        "mem allocated avg": 8887126558.72,
+        "mem reserved avg": 10553644810.24,
+        "elapsed time": 95.25946382099937
+      },
+      {
+        "step": 200,
+        "valid dino_similarity": 0.23606328666210175,
+        "train loss": 0.7662364840507507,
+        "train samples": 400,
+        "train time": 73.77076317497995,
+        "eval time": 13.690386187998229,
+        "mem allocated avg": 8888914176.0,
+        "mem reserved avg": 10705960960.0,
+        "elapsed time": 182.89198597300128
+      },
+      {
+        "step": 300,
+        "valid dino_similarity": 0.2260935753583908,
+        "train loss": 0.7698729038238525,
+        "train samples": 600,
+        "train time": 73.86279226998886,
+        "eval time": 13.75645619599527,
+        "mem allocated avg": 8888965376.0,
+        "mem reserved avg": 10705960960.0,
+        "elapsed time": 270.67992162500013
+      },
+      {
+        "step": 400,
+        "valid dino_similarity": 0.44671592116355896,
+        "train loss": 0.7781059145927429,
+        "train samples": 800,
+        "train time": 74.63758819001669,
+        "eval time": 14.069168159003311,
+        "mem allocated avg": 8889016576.0,
+        "mem reserved avg": 10705960960.0,
+        "elapsed time": 359.5552370150035
+      },
+      {
+        "step": 500,
+        "valid dino_similarity": 0.3002845048904419,
+        "train loss": 0.7713781595230103,
+        "train samples": 1000,
+        "train time": 74.14620477805875,
+        "eval time": 13.683874613998341,
+        "mem allocated avg": 8889067776.0,
+        "mem reserved avg": 10705960960.0,
+        "elapsed time": 447.5548311040038
+      },
+      {
+        "step": 600,
+        "valid dino_similarity": 0.4927564263343811,
+        "train loss": 0.7641171813011169,
+        "train samples": 1200,
+        "train time": 74.05809263796255,
+        "eval time": 13.785276431997772,
+        "mem allocated avg": 8889118976.0,
+        "mem reserved avg": 10705960960.0,
+        "elapsed time": 535.5670663220008
+      },
+      {
+        "step": 700,
+        "valid dino_similarity": 0.41077858209609985,
+        "train loss": 0.7518174648284912,
+        "train samples": 1400,
+        "train time": 75.09191375601222,
+        "eval time": 13.881663603999186,
+        "mem allocated avg": 8889170176.0,
+        "mem reserved avg": 10705960960.0,
+        "elapsed time": 624.7075319450014
+      },
+      {
+        "step": 750,
+        "test dino_similarity": 0.5697349011898041,
+        "drift": 0.1362656056880951,
+        "train loss": 0.7711056470870972,
+        "train samples": 1500
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "a3b4f4849157f664bdbc776fd7453c2783562f4d",
+      "created_at": "2026-01-14T13:42:28+00:00"
+    },
+    "dataset_info": {
+      "sha": "37df3244ae3aa36e85178b6cf946338137fc3068",
+      "created_at": "2026-03-09T15:31:26+00:00"
+    },
+    "package_info": {
+      "transformers-version": "5.10.2",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.2.dev0",
+      "peft-commit-hash": "b2d61f5f80a7ac540fb572c077d8265a95986db8",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "diffusers-version": "0.38.0",
+      "diffusers-commit-hash": null,
+      "torch-version": "2.12.0+cu130",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 202002\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.11.2 (Git Hash 03c022d3ffdcee958cfacbe720048e725fdf644c)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 13.0\n  - NVCC architecture flags: -gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1  (built against CUDA 12.8)\n    - Built with CuDNN 92.0\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=7661cd9c6b841b62b7f411aa52ec51f05457263b, CUDA_FLAGS= -DLIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_OPERATIONS -Xfatbin -compress-all -DONNX_NAMESPACE=onnx_torch -gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_100,code=sm_100 -gencode arch=compute_120,code=sm_120 -Xcudafe --diag_suppress=cc_clobber_ignored,--diag_suppress=field_without_dll_interface,--diag_suppress=base_class_has_different_dll_interface,--diag_suppress=dll_interface_conflict_none_assumed,--diag_suppress=dll_interface_conflict_dllexport_assumed,--diag_suppress=bad_friend_decl --expt-relaxed-constexpr --expt-extended-lambda -Xfatbin -compress-all --threads 2 -compress-mode=size -Wno-deprecated-gpu-targets --expt-extended-lambda -DCUB_WRAPPED_NAMESPACE=at_cuda_detail -DDISABLE_CUSPARSE_DEPRECATED -DCUDA_HAS_FP16=1 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -DC10_NODEPRECATED, CUDA_VERSION=13.0, CUDNN_VERSION=9.20.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_MSLK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.12.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/results/vera--flux2-klein-default.json b/method_comparison/image-gen/results/vera--flux2-klein-default.json
new file mode 100644
index 0000000..fca7070
--- /dev/null
+++ b/method_comparison/image-gen/results/vera--flux2-klein-default.json
@@ -0,0 +1,250 @@
+{
+  "run_info": {
+    "created_at": "2026-06-09T21:50:53+00:00",
+    "total_time": 827.5421581120027,
+    "experiment_name": "vera/flux2-klein-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "black-forest-labs/FLUX.2-klein-base-4B",
+      "dataset_id": "peft-internal-testing/cat-image-dataset",
+      "dataset_split": "train",
+      "dtype": "bfloat16",
+      "resolution": 512,
+      "batch_size": 2,
+      "batch_size_eval": 1,
+      "repeats": 1000,
+      "max_steps": 750,
+      "eval_steps": 100,
+      "compile": false,
+      "use_gc": true,
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.001
+      },
+      "lr_scheduler": null,
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "instance_prompts": [
+        "sks cat sitting on a chair in front of a box of chocolates",
+        "sks cat playing on the Steam Deck",
+        "sks cat wearing a necklace while sitting in a box on a sofa",
+        "a box with four donuts in front of sks cat",
+        "sks cat wearing a pink veil with flowers on it and a dagger made out of yellow cardboard",
+        "sks cat between two pillows, with one pillow showing a polar bear and the other a fox",
+        "sks cat with an espresso reading the newspaper",
+        "a close up of a hand petting sks cat on the head",
+        "sks cat opens a white door",
+        "sks cat with a VIP \"all access\" pass",
+        "sks cat in front of a monitor showing the video game \"RimWorld\"",
+        "sks cat reads a newspaper about cannabis",
+        "sks cat reading the newspaper with the title \"DIE BOX\"",
+        "sks cat being fed sushi",
+        "sks cat in front of a box of tomatoes",
+        "a gingerbread house in front of sks cat",
+        "sks cat is wearing a Wednesday Addams costume",
+        "sks cat looks skeptical as he reads a magazine depicting a black cat",
+        "sks cat wearing a striped scarf",
+        "sleepy sks cat lying in bed covered by a blue blanket"
+      ],
+      "image_column": "image",
+      "valid_size": 2,
+      "test_size": 4,
+      "num_inference_steps": 20,
+      "guidance_scale": 3.5,
+      "max_sequence_length": 512,
+      "text_encoder_out_layers": [
+        10,
+        20,
+        30
+      ],
+      "weighting_scheme": "none",
+      "logit_mean": 0.0,
+      "logit_std": 1.0,
+      "mode_scale": 1.29,
+      "dino_model_id": "facebook/dinov2-base",
+      "dino_image_size": 224,
+      "sample_image_prompts": [
+        "a photo of sks cat",
+        "a color drawing of sks cat",
+        "sks cat at the beach",
+        "a photo of sks dog",
+        "a photo of an orange cat"
+      ],
+      "drift_image_prompts": [
+        "a photo of cat",
+        "a color drawing of cat",
+        "cat sitting in a bathtub",
+        "cat looks into a mirror",
+        "a photo of cat next to a tree",
+        "the Mona Lisa but she looks angry",
+        "a dog holding a sign that says hello world",
+        "a photo of the Eiffel tower at night",
+        "an astronaut riding a horse",
+        "3d design concept of a chair that looks like an avocado"
+      ]
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "VERA",
+      "auto_mapping": null,
+      "peft_version": "0.18.2.dev0@UNKNOWN",
+      "base_model_name_or_path": null,
+      "revision": null,
+      "inference_mode": false,
+      "r": 32,
+      "target_modules": [
+        "linear_in",
+        "to_q",
+        "to_out.0",
+        "add_q_proj",
+        "add_v_proj",
+        "to_k",
+        "add_k_proj",
+        "to_qkv_mlp_proj",
+        "to_v",
+        "linear_out",
+        "to_add_out"
+      ],
+      "projection_prng_key": 0,
+      "save_projection": true,
+      "vera_dropout": 0.0,
+      "d_initial": 0.1,
+      "fan_in_fan_out": false,
+      "bias": "none",
+      "modules_to_save": null,
+      "init_weights": true,
+      "layers_to_transform": null,
+      "layers_pattern": null
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 10554717153,
+    "accelerator_memory_max": 10565451776,
+    "accelerator_memory_reserved_99th": 10565451776,
+    "train_time": 720.1334591520208,
+    "file_size": 8314200,
+    "num_trainable_params": 893440,
+    "num_total_params": 3876438016,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 100,
+        "valid dino_similarity": 0.2548936903476715,
+        "train loss": 0.7770729064941406,
+        "train samples": 200,
+        "train time": 76.26114018103544,
+        "eval time": 14.358162935997825,
+        "mem allocated avg": 8267384064.0,
+        "mem reserved avg": 10498217082.88,
+        "elapsed time": 97.08787109100376
+      },
+      {
+        "step": 200,
+        "valid dino_similarity": 0.290496289730072,
+        "train loss": 0.761107325553894,
+        "train samples": 400,
+        "train time": 77.10209777899581,
+        "eval time": 14.255118802997458,
+        "mem allocated avg": 8267436288.0,
+        "mem reserved avg": 10561236500.48,
+        "elapsed time": 188.5985622320004
+      },
+      {
+        "step": 300,
+        "valid dino_similarity": 0.3669188916683197,
+        "train loss": 0.7738956809043884,
+        "train samples": 600,
+        "train time": 76.83513159795984,
+        "eval time": 14.508328366995556,
+        "mem allocated avg": 8267487488.0,
+        "mem reserved avg": 10563291709.44,
+        "elapsed time": 280.09662032900087
+      },
+      {
+        "step": 400,
+        "valid dino_similarity": 0.5830528736114502,
+        "train loss": 0.766128659248352,
+        "train samples": 800,
+        "train time": 76.61364174698974,
+        "eval time": 14.172379085997818,
+        "mem allocated avg": 8267538688.0,
+        "mem reserved avg": 10563040051.2,
+        "elapsed time": 371.0382035780058
+      },
+      {
+        "step": 500,
+        "valid dino_similarity": 0.5715973973274231,
+        "train loss": 0.7333442568778992,
+        "train samples": 1000,
+        "train time": 76.8462980940385,
+        "eval time": 14.428190164995613,
+        "mem allocated avg": 8267589888.0,
+        "mem reserved avg": 10563333652.48,
+        "elapsed time": 462.46898859000066
+      },
+      {
+        "step": 600,
+        "valid dino_similarity": 0.6349660158157349,
+        "train loss": 0.7633798122406006,
+        "train samples": 1200,
+        "train time": 76.36024303699378,
+        "eval time": 14.18550631400285,
+        "mem allocated avg": 8267641088.0,
+        "mem reserved avg": 10563270737.92,
+        "elapsed time": 553.169474760005
+      },
+      {
+        "step": 700,
+        "valid dino_similarity": 0.6233590245246887,
+        "train loss": 0.760438084602356,
+        "train samples": 1400,
+        "train time": 76.26128900401818,
+        "eval time": 14.205917330997181,
+        "mem allocated avg": 8267692288.0,
+        "mem reserved avg": 10565263032.32,
+        "elapsed time": 643.7891587760023
+      },
+      {
+        "step": 750,
+        "test dino_similarity": 0.6626973748207092,
+        "drift": 0.23100578784942627,
+        "train loss": 0.7632827758789062,
+        "train samples": 1500
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "a3b4f4849157f664bdbc776fd7453c2783562f4d",
+      "created_at": "2026-01-14T13:42:28+00:00"
+    },
+    "dataset_info": {
+      "sha": "37df3244ae3aa36e85178b6cf946338137fc3068",
+      "created_at": "2026-03-09T15:31:26+00:00"
+    },
+    "package_info": {
+      "transformers-version": "5.10.2",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.2.dev0",
+      "peft-commit-hash": "b2d61f5f80a7ac540fb572c077d8265a95986db8",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "diffusers-version": "0.38.0",
+      "diffusers-commit-hash": null,
+      "torch-version": "2.12.0+cu130",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 202002\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.11.2 (Git Hash 03c022d3ffdcee958cfacbe720048e725fdf644c)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 13.0\n  - NVCC architecture flags: -gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1  (built against CUDA 12.8)\n    - Built with CuDNN 92.0\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=7661cd9c6b841b62b7f411aa52ec51f05457263b, CUDA_FLAGS= -DLIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_OPERATIONS -Xfatbin -compress-all -DONNX_NAMESPACE=onnx_torch -gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_100,code=sm_100 -gencode arch=compute_120,code=sm_120 -Xcudafe --diag_suppress=cc_clobber_ignored,--diag_suppress=field_without_dll_interface,--diag_suppress=base_class_has_different_dll_interface,--diag_suppress=dll_interface_conflict_none_assumed,--diag_suppress=dll_interface_conflict_dllexport_assumed,--diag_suppress=bad_friend_decl --expt-relaxed-constexpr --expt-extended-lambda -Xfatbin -compress-all --threads 2 -compress-mode=size -Wno-deprecated-gpu-targets --expt-extended-lambda -DCUB_WRAPPED_NAMESPACE=at_cuda_detail -DDISABLE_CUSPARSE_DEPRECATED -DCUDA_HAS_FP16=1 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -DC10_NODEPRECATED, CUDA_VERSION=13.0, CUDNN_VERSION=9.20.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_MSLK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.12.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/results/waveft--flux2-klein-default.json b/method_comparison/image-gen/results/waveft--flux2-klein-default.json
new file mode 100644
index 0000000..6378115
--- /dev/null
+++ b/method_comparison/image-gen/results/waveft--flux2-klein-default.json
@@ -0,0 +1,254 @@
+{
+  "run_info": {
+    "created_at": "2026-06-09T22:05:22+00:00",
+    "total_time": 3477.6579525330017,
+    "experiment_name": "waveft/flux2-klein-default",
+    "peft_branch": "main",
+    "train_config": {
+      "model_id": "black-forest-labs/FLUX.2-klein-base-4B",
+      "dataset_id": "peft-internal-testing/cat-image-dataset",
+      "dataset_split": "train",
+      "dtype": "bfloat16",
+      "resolution": 512,
+      "batch_size": 2,
+      "batch_size_eval": 1,
+      "repeats": 1000,
+      "max_steps": 750,
+      "eval_steps": 100,
+      "compile": false,
+      "use_gc": true,
+      "seed": 0,
+      "grad_norm_clip": 1.0,
+      "optimizer_type": "AdamW",
+      "optimizer_kwargs": {
+        "lr": 0.0001,
+        "weight_decay": 0.0001
+      },
+      "lr_scheduler": null,
+      "use_amp": false,
+      "autocast_adapter_dtype": true,
+      "instance_prompts": [
+        "sks cat sitting on a chair in front of a box of chocolates",
+        "sks cat playing on the Steam Deck",
+        "sks cat wearing a necklace while sitting in a box on a sofa",
+        "a box with four donuts in front of sks cat",
+        "sks cat wearing a pink veil with flowers on it and a dagger made out of yellow cardboard",
+        "sks cat between two pillows, with one pillow showing a polar bear and the other a fox",
+        "sks cat with an espresso reading the newspaper",
+        "a close up of a hand petting sks cat on the head",
+        "sks cat opens a white door",
+        "sks cat with a VIP \"all access\" pass",
+        "sks cat in front of a monitor showing the video game \"RimWorld\"",
+        "sks cat reads a newspaper about cannabis",
+        "sks cat reading the newspaper with the title \"DIE BOX\"",
+        "sks cat being fed sushi",
+        "sks cat in front of a box of tomatoes",
+        "a gingerbread house in front of sks cat",
+        "sks cat is wearing a Wednesday Addams costume",
+        "sks cat looks skeptical as he reads a magazine depicting a black cat",
+        "sks cat wearing a striped scarf",
+        "sleepy sks cat lying in bed covered by a blue blanket"
+      ],
+      "image_column": "image",
+      "valid_size": 2,
+      "test_size": 4,
+      "num_inference_steps": 20,
+      "guidance_scale": 3.5,
+      "max_sequence_length": 512,
+      "text_encoder_out_layers": [
+        10,
+        20,
+        30
+      ],
+      "weighting_scheme": "none",
+      "logit_mean": 0.0,
+      "logit_std": 1.0,
+      "mode_scale": 1.29,
+      "dino_model_id": "facebook/dinov2-base",
+      "dino_image_size": 224,
+      "sample_image_prompts": [
+        "a photo of sks cat",
+        "a color drawing of sks cat",
+        "sks cat at the beach",
+        "a photo of sks dog",
+        "a photo of an orange cat"
+      ],
+      "drift_image_prompts": [
+        "a photo of cat",
+        "a color drawing of cat",
+        "cat sitting in a bathtub",
+        "cat looks into a mirror",
+        "a photo of cat next to a tree",
+        "the Mona Lisa but she looks angry",
+        "a dog holding a sign that says hello world",
+        "a photo of the Eiffel tower at night",
+        "an astronaut riding a horse",
+        "3d design concept of a chair that looks like an avocado"
+      ]
+    },
+    "peft_config": {
+      "task_type": null,
+      "peft_type": "WAVEFT",
+      "auto_mapping": null,
+      "peft_version": "0.18.2.dev0@UNKNOWN",
+      "base_model_name_or_path": null,
+      "revision": null,
+      "inference_mode": false,
+      "n_frequency": 2592,
+      "scaling": 25.0,
+      "wavelet_family": "db1",
+      "use_idwt": true,
+      "random_loc_seed": 777,
+      "fan_in_fan_out": false,
+      "target_modules": [
+        "to_q",
+        "to_out.0",
+        "to_k",
+        "add_k_proj",
+        "to_add_out",
+        "to_v",
+        "linear_out",
+        "add_v_proj",
+        "to_qkv_mlp_proj",
+        "linear_in",
+        "add_q_proj"
+      ],
+      "exclude_modules": null,
+      "bias": "none",
+      "modules_to_save": null,
+      "layers_to_transform": null,
+      "layers_pattern": null,
+      "n_frequency_pattern": {},
+      "proportional_parameters": false,
+      "init_weights": true
+    },
+    "error_msg": ""
+  },
+  "train_info": {
+    "accelerator_memory_reserved_avg": 12209177143,
+    "accelerator_memory_max": 12985565184,
+    "accelerator_memory_reserved_99th": 12983468032,
+    "train_time": 2970.379196393995,
+    "file_size": 840360,
+    "num_trainable_params": 207360,
+    "num_total_params": 3875751936,
+    "status": "success",
+    "metrics": [
+      {
+        "step": 100,
+        "valid dino_similarity": 0.4115367829799652,
+        "train loss": 0.761562705039978,
+        "train samples": 200,
+        "train time": 311.36101362502086,
+        "eval time": 58.90403465399868,
+        "mem allocated avg": 8251688192.0,
+        "mem reserved avg": 12983447060.48,
+        "elapsed time": 376.6722902239999
+      },
+      {
+        "step": 200,
+        "valid dino_similarity": 0.4872303009033203,
+        "train loss": 0.7764377593994141,
+        "train samples": 400,
+        "train time": 311.1123860040025,
+        "eval time": 59.05476129800081,
+        "mem allocated avg": 8251740416.0,
+        "mem reserved avg": 12089934479.36,
+        "elapsed time": 746.963315771005
+      },
+      {
+        "step": 300,
+        "valid dino_similarity": 0.49630436301231384,
+        "train loss": 0.7759334444999695,
+        "train samples": 600,
+        "train time": 310.50355191199196,
+        "eval time": 59.009337094998045,
+        "mem allocated avg": 8251791616.0,
+        "mem reserved avg": 12090081280.0,
+        "elapsed time": 1116.6156664510054
+      },
+      {
+        "step": 400,
+        "valid dino_similarity": 0.5309604406356812,
+        "train loss": 0.764028787612915,
+        "train samples": 800,
+        "train time": 311.17428280299646,
+        "eval time": 59.01225832500495,
+        "mem allocated avg": 8251842816.0,
+        "mem reserved avg": 12090081280.0,
+        "elapsed time": 1486.942706478003
+      },
+      {
+        "step": 500,
+        "valid dino_similarity": 0.5134092569351196,
+        "train loss": 0.7827035188674927,
+        "train samples": 1000,
+        "train time": 310.62463505398046,
+        "eval time": 59.04519014900143,
+        "mem allocated avg": 8251894016.0,
+        "mem reserved avg": 12090081280.0,
+        "elapsed time": 1856.7519493460059
+      },
+      {
+        "step": 600,
+        "valid dino_similarity": 0.5065137147903442,
+        "train loss": 0.7549853324890137,
+        "train samples": 1200,
+        "train time": 311.15710882100393,
+        "eval time": 59.04701185799786,
+        "mem allocated avg": 8251945216.0,
+        "mem reserved avg": 12090081280.0,
+        "elapsed time": 2227.095077378006
+      },
+      {
+        "step": 700,
+        "valid dino_similarity": 0.6110469102859497,
+        "train loss": 0.7865440249443054,
+        "train samples": 1400,
+        "train time": 311.2895923420074,
+        "eval time": 58.762815926005715,
+        "mem allocated avg": 8251996416.0,
+        "mem reserved avg": 12090081280.0,
+        "elapsed time": 2597.2867958600036
+      },
+      {
+        "step": 750,
+        "test dino_similarity": 0.6139253179232279,
+        "drift": 0.20272931456565857,
+        "train loss": 0.7747591137886047,
+        "train samples": 1500
+      }
+    ]
+  },
+  "meta_info": {
+    "model_info": {
+      "sha": "a3b4f4849157f664bdbc776fd7453c2783562f4d",
+      "created_at": "2026-01-14T13:42:28+00:00"
+    },
+    "dataset_info": {
+      "sha": "37df3244ae3aa36e85178b6cf946338137fc3068",
+      "created_at": "2026-03-09T15:31:26+00:00"
+    },
+    "package_info": {
+      "transformers-version": "5.10.2",
+      "transformers-commit-hash": null,
+      "peft-version": "0.19.2.dev0",
+      "peft-commit-hash": "b2d61f5f80a7ac540fb572c077d8265a95986db8",
+      "datasets-version": "4.2.0",
+      "datasets-commit-hash": null,
+      "diffusers-version": "0.38.0",
+      "diffusers-commit-hash": null,
+      "torch-version": "2.12.0+cu130",
+      "torch-commit-hash": null
+    },
+    "system_info": {
+      "system": "Linux",
+      "release": "6.17.0-1009-aws",
+      "version": "#9~24.04.2-Ubuntu SMP Fri Mar  6 23:50:29 UTC 2026",
+      "machine": "x86_64",
+      "processor": "x86_64",
+      "accelerator": "NVIDIA L40S"
+    },
+    "pytorch_info": "PyTorch built with:\n  - GCC 13.3\n  - C++ Version: 202002\n  - Intel(R) oneAPI Math Kernel Library Version 2024.2-Product Build 20240605 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v3.11.2 (Git Hash 03c022d3ffdcee958cfacbe720048e725fdf644c)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 13.0\n  - NVCC architecture flags: -gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90;-gencode;arch=compute_100,code=sm_100;-gencode;arch=compute_120,code=sm_120\n  - CuDNN 90.7.1  (built against CUDA 12.8)\n    - Built with CuDNN 92.0\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, COMMIT_SHA=7661cd9c6b841b62b7f411aa52ec51f05457263b, CUDA_FLAGS= -DLIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_OPERATIONS -Xfatbin -compress-all -DONNX_NAMESPACE=onnx_torch -gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_90,code=sm_90 -gencode arch=compute_100,code=sm_100 -gencode arch=compute_120,code=sm_120 -Xcudafe --diag_suppress=cc_clobber_ignored,--diag_suppress=field_without_dll_interface,--diag_suppress=base_class_has_different_dll_interface,--diag_suppress=dll_interface_conflict_none_assumed,--diag_suppress=dll_interface_conflict_dllexport_assumed,--diag_suppress=bad_friend_decl --expt-relaxed-constexpr --expt-extended-lambda -Xfatbin -compress-all --threads 2 -compress-mode=size -Wno-deprecated-gpu-targets --expt-extended-lambda -DCUB_WRAPPED_NAMESPACE=at_cuda_detail -DDISABLE_CUSPARSE_DEPRECATED -DCUDA_HAS_FP16=1 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -DC10_NODEPRECATED, CUDA_VERSION=13.0, CUDNN_VERSION=9.20.0, CXX_COMPILER=/opt/rh/gcc-toolset-13/root/usr/bin/c++, CXX_FLAGS= -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DLIBKINETO_NOXPUPTI=ON -DUSE_FBGEMM -DUSE_MSLK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -DC10_NODEPRECATED -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=range-loop-construct -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-unknown-pragmas -Wno-unused-parameter -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wsuggest-override -Wno-psabi -Wno-error=old-style-cast -faligned-new -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-dangling-reference -Wno-error=dangling-reference -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, TORCH_VERSION=2.12.0, USE_CUDA=ON, USE_CUDNN=ON, USE_CUSPARSELT=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_GLOO=ON, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, USE_ROCM_KERNEL_ASSERT=OFF, USE_XCCL=OFF, USE_XPU=OFF, \n"
+  }
+}
\ No newline at end of file
diff --git a/method_comparison/image-gen/run.py b/method_comparison/image-gen/run.py
new file mode 100644
index 0000000..abcdbf8
--- /dev/null
+++ b/method_comparison/image-gen/run.py
@@ -0,0 +1,669 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+"""Main entry point for image generation method comparison experiments.
+
+Based on https://github.com/huggingface/diffusers/blob/bbbcdd87bd9d960fa372663a50b9edbdcb1391c6/examples/dreambooth/train_dreambooth_lora_flux2_klein.py
+"""
+
+import argparse
+import copy
+import datetime as dt
+import json
+import os
+import sys
+import time
+from collections.abc import Callable
+from contextlib import AbstractContextManager, nullcontext
+from functools import partial
+from typing import Any, Optional
+
+import huggingface_hub
+import torch
+from diffusers.training_utils import (
+    compute_density_for_timestep_sampling,
+    compute_loss_weighting_for_sd3,
+    offload_models,
+)
+from torch.amp import GradScaler, autocast
+from tqdm import tqdm
+from transformers import set_seed
+from utils import (
+    FILE_NAME_TRAIN_PARAMS,
+    TrainConfig,
+    TrainResult,
+    TrainStatus,
+    get_artifact_stem,
+    get_base_model_info,
+    get_dataset_info,
+    get_dino_embeddings,
+    get_dino_encoder,
+    get_file_size,
+    get_optimizer_and_scheduler,
+    get_peft_branch,
+    get_pipeline,
+    get_sample_image_save_dir,
+    get_torch_dtype,
+    get_train_config,
+    init_accelerator,
+    log_results,
+    upload_checkpoint_to_bucket,
+    upload_images_to_bucket,
+    validate_experiment_path,
+)
+
+from data import get_train_valid_test_datasets
+from peft import PeftConfig, PeftModel
+from peft.utils import CONFIG_NAME, infer_device
+
+
+os.environ["TORCHINDUCTOR_FORCE_DISABLE_CACHES"] = "1"
+
+
+def get_sigmas(timesteps, noise_scheduler, n_dim, dtype):
+    device = "cpu"
+    sigmas = noise_scheduler.sigmas.to(device=device, dtype=dtype)
+    schedule_timesteps = noise_scheduler.timesteps.to(device)
+    timesteps = timesteps.to(device)
+    step_indices = [(schedule_timesteps == t).nonzero().item() for t in timesteps]
+
+    sigma = sigmas[step_indices].flatten()
+    while len(sigma.shape) < n_dim:
+        sigma = sigma.unsqueeze(-1)
+    return sigma
+
+
+class DummyGradScaler:
+    def scale(self, loss):
+        return loss
+
+    def unscale_(self, optimizer):
+        pass
+
+    def step(self, optimizer):
+        optimizer.step()
+
+    def update(self):
+        pass
+
+
+def precompute_prompt_caches(
+    pipeline, prompts: list[str], device_type: str, train_config: TrainConfig
+) -> tuple[torch.Tensor, torch.Tensor]:
+    prompt_embeds_cache = []
+    text_ids_cache = []
+    with torch.no_grad(), offload_models(pipeline.text_encoder, device=device_type, offload=True):
+        for prompt in prompts:
+            prompt_embeds, text_ids = pipeline.encode_prompt(
+                prompt=prompt,
+                max_sequence_length=train_config.max_sequence_length,
+                text_encoder_out_layers=train_config.text_encoder_out_layers,
+            )
+            prompt_embeds_cache.append(prompt_embeds)
+            text_ids_cache.append(text_ids)
+    return torch.cat(prompt_embeds_cache, dim=0).to(device_type), torch.cat(text_ids_cache, dim=0).to(device_type)
+
+
+def precompute_latent_cache(
+    *,
+    pipeline,
+    vae,
+    pixel_values: list[torch.Tensor],
+    train_config: TrainConfig,
+    device_type: str,
+) -> torch.Tensor:
+    latents_cache = []
+    latents_bn_mean = vae.bn.running_mean.view(1, -1, 1, 1)
+    latents_bn_std = torch.sqrt(vae.bn.running_var.view(1, -1, 1, 1) + vae.config.batch_norm_eps)
+    with torch.no_grad(), offload_models(vae, device=device_type, offload=True):
+        latents_bn_mean = latents_bn_mean.to(vae.device)
+        latents_bn_std = latents_bn_std.to(vae.device)
+        for i in range(0, len(pixel_values), train_config.batch_size):
+            pixel_values_batch = torch.stack(pixel_values[i : i + train_config.batch_size]).to(
+                device=vae.device, dtype=get_torch_dtype(train_config.dtype)
+            )
+            latents = vae.encode(pixel_values_batch).latent_dist.mode()
+            latents = pipeline._patchify_latents(latents)
+            latents = (latents - latents_bn_mean) / latents_bn_std
+            latents_cache.append(latents.to(device_type))
+    return torch.cat(latents_cache, dim=0)
+
+
+def _generate_images(pipeline, *, generator, prompts: list[str], config: TrainConfig):
+    outputs = pipeline(
+        prompt=prompts,
+        num_inference_steps=config.num_inference_steps,
+        guidance_scale=config.guidance_scale,
+        height=config.resolution,  # hard-code square
+        width=config.resolution,
+        max_sequence_length=config.max_sequence_length,
+        text_encoder_out_layers=config.text_encoder_out_layers,
+        generator=generator,
+        output_type="pil",
+    )
+    return outputs
+
+
+@torch.inference_mode()
+def evaluate(
+    *,
+    pipeline,
+    ds_eval,
+    processor,
+    dino_model,
+    config: TrainConfig,
+    num_repeats: int = 1,
+) -> float:
+    with offload_models(pipeline.text_encoder, pipeline.vae, device=pipeline.transformer.device, offload=True):
+        # avoid reusing same seed as in training, which would bias samples toward memorized results
+        seed = config.seed + 100_000
+        generator = torch.Generator(device=pipeline.transformer.device).manual_seed(seed)
+        cosine_sim_scores = []
+        iter_ = range(num_repeats) if num_repeats <= 1 else tqdm(range(num_repeats))
+        for _ in iter_:
+            generated_images = []
+            reference_images = []
+            batch_size = config.batch_size_eval
+
+            for i in range(0, len(ds_eval), batch_size):
+                sliced = [ds_eval[j] for j in range(i, min(i + batch_size, len(ds_eval)))]
+                prompts = [sample["prompt"] for sample in sliced]
+                outputs = _generate_images(pipeline, generator=generator, prompts=prompts, config=config)
+                generated_images.extend(outputs.images)
+                reference_images.extend([sample["raw_image"] for sample in sliced])
+                if i + batch_size >= len(ds_eval):
+                    break
+
+            generated_embeddings = get_dino_embeddings(generated_images, processor, dino_model, batch_size=batch_size)
+            reference_embeddings = get_dino_embeddings(reference_images, processor, dino_model, batch_size=batch_size)
+            cosine_sim = (generated_embeddings * reference_embeddings).sum(dim=-1)
+            cosine_sim_scores.append(cosine_sim.mean().item())
+        mean_sim = sum(cosine_sim_scores) / num_repeats
+    return mean_sim
+
+
+@torch.inference_mode()
+def measure_drift(*, pipeline, processor, dino_model, config: TrainConfig) -> float:
+    # Measure the drift as 1 - the cosine similarity of the images generated by the base model vs the model with the
+    # trained adapter. The prompts are unrelated to the concept, so we expect the similarity to be high, hence the drift
+    # to be low.
+    if not isinstance(pipeline.transformer, PeftModel):
+        # in case of full fine-tuning, the adapter cannot be disabled and thus the drift cannot be measured, return
+        # dummy value
+        return float("nan")
+
+    batch_size = config.batch_size_eval
+    prompts = config.drift_image_prompts
+    pbar = tqdm(total=len(prompts) * 2)
+    with offload_models(pipeline.text_encoder, pipeline.vae, device=pipeline.transformer.device, offload=True):
+        # without adapter
+        # avoid reusing same seed as in training, which would bias samples toward memorized results
+        seed = config.seed + 100_000_000
+        generator = torch.Generator(device=pipeline.transformer.device).manual_seed(seed)
+        generated_base = []
+        with pipeline.transformer.disable_adapter():
+            for i in range(0, len(prompts), batch_size):
+                prompt_batch = prompts[i : i + batch_size]
+                outputs = _generate_images(pipeline, generator=generator, prompts=prompt_batch, config=config)
+                generated_base.extend(outputs.images)
+                pbar.update(1)
+
+        # with adapter
+        # avoid reusing same seed as in training, which would bias samples toward memorized results
+        seed = config.seed + 100_000_000
+        generator = torch.Generator(device=pipeline.transformer.device).manual_seed(seed)
+        generated_adapter = []
+        for i in range(0, len(prompts), batch_size):
+            prompt_batch = prompts[i : i + batch_size]
+            outputs = _generate_images(pipeline, generator=generator, prompts=prompt_batch, config=config)
+            generated_adapter.extend(outputs.images)
+            pbar.update(1)
+
+    # calculate drift
+    generated_embeddings = get_dino_embeddings(generated_adapter, processor, dino_model, batch_size=batch_size)
+    reference_embeddings = get_dino_embeddings(generated_base, processor, dino_model, batch_size=batch_size)
+    cosine_sim = (generated_embeddings * reference_embeddings).sum(dim=-1)  # dino embeddings are L2-normalized
+    drift = (1 - cosine_sim.mean().item()) / 2.0  # cos sim is in [-1, 1], normalized to [0, 1]
+    return drift
+
+
+def train(
+    *,
+    pipeline,
+    train_config: TrainConfig,
+    accelerator_memory_init: int,
+    is_adalora: bool,
+    print_verbose: Callable[..., None],
+) -> TrainResult:
+    accelerator_memory_allocated_log = []
+    accelerator_memory_reserved_log = []
+    losses = []
+    durations = []
+    metrics = []
+    total_samples = 0
+
+    device_type = infer_device()
+    train_dataset, valid_dataset, test_dataset = get_train_valid_test_datasets(
+        train_config=train_config, print_fn=print_verbose
+    )
+    train_size_base = len(train_dataset["prompts"])
+    gen = torch.Generator(device=device_type).manual_seed(train_config.seed)
+    train_indices = torch.cat(
+        [torch.randperm(train_size_base, generator=gen, device=device_type) for _ in range(train_dataset["repeats"])]
+    )
+    if train_config.max_steps > len(train_indices):
+        raise ValueError(
+            f"max_steps is too high ({train_config.max_steps}), there are only {len(train_indices)} training samples"
+        )
+
+    processor, dino_model = get_dino_encoder(train_config.dino_model_id, train_config.dino_image_size)
+
+    torch_accelerator_module = getattr(torch, device_type, torch.cuda)
+    if train_config.use_amp:
+        grad_scaler: GradScaler | DummyGradScaler = GradScaler(device=device_type)
+        autocast_ctx: Callable[[], AbstractContextManager[Any]] = partial(autocast, device_type=device_type)
+    else:
+        grad_scaler = DummyGradScaler()
+        autocast_ctx = nullcontext
+
+    vae = pipeline.vae  # CPU
+    transformer = pipeline.transformer.to(device_type)
+    noise_scheduler_copy = copy.deepcopy(pipeline.scheduler)  # prevent mutating it
+    optimizer, lr_scheduler = get_optimizer_and_scheduler(
+        transformer,
+        optimizer_type=train_config.optimizer_type,
+        max_steps=train_config.max_steps,
+        lr_scheduler_arg=train_config.lr_scheduler,
+        **train_config.optimizer_kwargs,
+    )
+
+    if hasattr(transformer, "get_nb_trainable_parameters"):
+        num_trainable_params, num_params = transformer.get_nb_trainable_parameters()
+    else:
+        num_params = sum(param.numel() for param in transformer.parameters())
+        num_trainable_params = sum(param.numel() for param in transformer.parameters() if param.requires_grad)
+    print_verbose(
+        f"trainable params: {num_trainable_params:,d} || all params: {num_params:,d} || "
+        f"trainable: {100 * num_trainable_params / num_params:.4f}%"
+    )
+
+    status = TrainStatus.FAILED
+    tic_train = time.perf_counter()
+    eval_time = 0.0
+    error_msg = ""
+
+    # pre-compute, since they don't change during training and we can keep the text encoder and VAE offloaded
+    prompt_embeds_cache, text_ids_cache = precompute_prompt_caches(
+        pipeline, train_dataset["prompts"], device_type, train_config=train_config
+    )
+    latents_cache = precompute_latent_cache(
+        pipeline=pipeline,
+        vae=vae,
+        pixel_values=train_dataset["pixel_values"],
+        train_config=train_config,
+        device_type=device_type,
+    )
+
+    torch_accelerator_module.empty_cache()
+    torch_accelerator_module.reset_peak_memory_stats()
+    accelerator_memory_max_train = 0
+    try:
+        torch_accelerator_module.reset_peak_memory_stats()
+        pbar = tqdm(range(1, train_config.max_steps + 1))
+        for step in pbar:
+            tic = time.perf_counter()
+            i_start = (step - 1) * train_config.batch_size
+            i_stop = min(step * train_config.batch_size, len(train_indices))
+            batch_indices = train_indices[i_start:i_stop].to(device=latents_cache.device, dtype=torch.long)
+            latents = latents_cache.index_select(0, batch_indices)
+            prompt_embeds = prompt_embeds_cache.index_select(0, batch_indices)
+            text_ids = text_ids_cache.index_select(0, batch_indices)
+
+            current_batch_size = latents.shape[0]
+            total_samples += current_batch_size
+
+            model_input_ids = pipeline._prepare_latent_ids(latents).to(latents.device)
+            noise = torch.randn_like(latents, generator=gen)
+
+            u = compute_density_for_timestep_sampling(
+                weighting_scheme=train_config.weighting_scheme,
+                batch_size=current_batch_size,
+                logit_mean=train_config.logit_mean,
+                logit_std=train_config.logit_std,
+                mode_scale=train_config.mode_scale,
+            )
+            indices = (u * noise_scheduler_copy.config.num_train_timesteps).long()
+            timesteps = noise_scheduler_copy.timesteps[indices].to(device=latents.device)
+            # Add noise according to flow matching. zt = (1 - texp) * x + texp * z1
+            sigmas = get_sigmas(timesteps, noise_scheduler_copy, n_dim=latents.ndim, dtype=latents.dtype).to(
+                device_type
+            )
+            noisy_latents = (1.0 - sigmas) * latents + sigmas * noise
+            # [B, C, H, W] -> [B, H*W, C]
+            packed_noisy_latents = pipeline._pack_latents(noisy_latents)
+
+            # handle guidance
+            if transformer.config.guidance_embeds:
+                guidance = torch.full([1], train_config.guidance_scale, device=device_type)
+                guidance = guidance.expand(current_batch_size)
+            else:
+                guidance = None
+
+            optimizer.zero_grad(set_to_none=True)
+            with autocast_ctx():
+                model_pred = transformer(
+                    hidden_states=packed_noisy_latents,
+                    timestep=timesteps / 1000,
+                    guidance=guidance,
+                    encoder_hidden_states=prompt_embeds,
+                    txt_ids=text_ids,  # B, text_seq_len, 4
+                    img_ids=model_input_ids,  # B, image_seq_len, 4
+                    return_dict=False,
+                )[0]
+                model_pred = model_pred[:, : packed_noisy_latents.size(1)]
+                model_pred = pipeline._unpack_latents_with_ids(model_pred, model_input_ids)
+                # these weighting schemes use a uniform timestep sampling and instead post-weight the loss
+                weighting = compute_loss_weighting_for_sd3(train_config.weighting_scheme, sigmas=sigmas)
+                target = noise - latents
+                loss = torch.mean(
+                    (weighting.float() * (model_pred.float() - target.float()) ** 2).reshape(target.shape[0], -1), 1
+                )
+                loss = loss.mean()
+
+            grad_scaler.scale(loss).backward()
+            if train_config.grad_norm_clip:
+                grad_scaler.unscale_(optimizer)
+                torch.nn.utils.clip_grad_norm_(transformer.parameters(), train_config.grad_norm_clip)
+            grad_scaler.step(optimizer)
+            grad_scaler.update()
+            lr_scheduler.step()
+
+            if is_adalora:
+                transformer.base_model.update_and_allocate(step)
+
+            losses.append(loss)
+            pbar.set_postfix({"loss": loss.item()})
+
+            accelerator_memory_allocated_log.append(
+                torch_accelerator_module.memory_allocated() - accelerator_memory_init
+            )
+            accelerator_memory_reserved_log.append(
+                torch_accelerator_module.memory_reserved() - accelerator_memory_init
+            )
+            toc = time.perf_counter()
+            durations.append(toc - tic)
+
+            if step % train_config.eval_steps == 0:
+                # Measure max memory _before_ executing the eval loop and reset stats _after_ the eval loop. This way
+                # the extra memory required for evaluation is not included in the max memory statistic. We want to
+                # measure only the training memory, as the eval requires extra memory (DINO model) not caused by the
+                # PEFT method.
+                accelerator_memory_max_train = max(
+                    accelerator_memory_max_train,
+                    torch_accelerator_module.max_memory_reserved() - accelerator_memory_init,
+                )
+
+                tic_eval = time.perf_counter()
+                loss_avg = sum(losses[-train_config.eval_steps :]) / train_config.eval_steps
+                loss_avg = loss_avg.item()
+                memory_allocated_avg = (
+                    sum(accelerator_memory_allocated_log[-train_config.eval_steps :]) / train_config.eval_steps
+                )
+                memory_reserved_avg = (
+                    sum(accelerator_memory_reserved_log[-train_config.eval_steps :]) / train_config.eval_steps
+                )
+                dur_train = sum(durations[-train_config.eval_steps :])
+
+                transformer.eval()
+                valid_similarity = evaluate(
+                    pipeline=pipeline,
+                    ds_eval=valid_dataset,
+                    processor=processor,
+                    dino_model=dino_model,
+                    config=train_config,
+                )
+                transformer.train()
+
+                toc_eval = time.perf_counter()
+                dur_eval = toc_eval - tic_eval
+                eval_time += dur_eval
+                elapsed = time.perf_counter() - tic_train
+
+                metrics.append(
+                    {
+                        "step": step,
+                        "valid dino_similarity": valid_similarity,
+                        "train loss": loss_avg,
+                        "train samples": total_samples,
+                        "train time": dur_train,
+                        "eval time": dur_eval,
+                        "mem allocated avg": memory_allocated_avg,
+                        "mem reserved avg": memory_reserved_avg,
+                        "elapsed time": elapsed,
+                    }
+                )
+
+                log_dict = {
+                    "step": f"{step:4d}",
+                    "samples": f"{total_samples:5d}",
+                    "lr": f"{lr_scheduler.get_last_lr()[0]:.2e}",
+                    "loss avg": f"{loss_avg:.4f}",
+                    "valid sim": f"{valid_similarity:.4f}",
+                    "train time": f"{dur_train:.1f}s",
+                    "eval time": f"{dur_eval:.1f}s",
+                    "mem allocated": f"{memory_allocated_avg:.0f}",
+                    "mem reserved": f"{memory_reserved_avg:.0f}",
+                    "elapsed time": f"{elapsed // 60:.0f}min {elapsed % 60:.0f}s",
+                }
+                print_verbose(json.dumps(log_dict))
+
+                torch_accelerator_module.empty_cache()
+                torch_accelerator_module.reset_peak_memory_stats()
+
+        accelerator_memory_max_train = max(
+            accelerator_memory_max_train,
+            torch_accelerator_module.max_memory_reserved() - accelerator_memory_init,
+        )
+        print_verbose(f"Training finished after {train_config.max_steps} steps, evaluation on test set follows.")
+        transformer.eval()
+        test_similarity = evaluate(
+            pipeline=pipeline,
+            ds_eval=test_dataset,
+            processor=processor,
+            dino_model=dino_model,
+            config=train_config,
+            num_repeats=3,
+        )
+        print_verbose("Calculating drift.")
+        test_drift = measure_drift(pipeline=pipeline, processor=processor, dino_model=dino_model, config=train_config)
+        metrics.append(
+            {
+                "step": step,
+                "test dino_similarity": test_similarity,
+                "drift": test_drift,
+                "train loss": (sum(losses[-train_config.eval_steps :]) / train_config.eval_steps).item(),
+                "train samples": total_samples,
+            }
+        )
+        print_verbose(f"Test DINOv2 similarity: {test_similarity:.4f}")
+        print_verbose(f"Test drift:             {test_drift:.4f}")
+
+    except KeyboardInterrupt:
+        print_verbose("canceled training")
+        status = TrainStatus.CANCELED
+        error_msg = "manually canceled"
+    except torch.OutOfMemoryError as exc:
+        print_verbose("out of memory error encountered")
+        status = TrainStatus.CANCELED
+        error_msg = str(exc)
+    except Exception as exc:
+        print_verbose(f"encountered an error: {exc}")
+        status = TrainStatus.CANCELED
+        error_msg = str(exc)
+
+    toc_train = time.perf_counter()
+    train_time = toc_train - tic_train - eval_time
+
+    if status != TrainStatus.CANCELED:
+        status = TrainStatus.SUCCESS
+    train_result = TrainResult(
+        status=status,
+        train_time=train_time,
+        accelerator_memory_reserved_log=accelerator_memory_reserved_log,
+        accelerator_memory_max_train=accelerator_memory_max_train,
+        losses=[loss.item() for loss in losses],
+        metrics=metrics,
+        error_msg=error_msg,
+        num_trainable_params=num_trainable_params,
+        num_total_params=num_params,
+    )
+    return train_result
+
+
+@torch.inference_mode()
+def generate_sample_images(
+    *,
+    pipeline,
+    train_config,
+    sample_image_dir: str,
+    file_stem: str,
+) -> None:
+    target_device = pipeline.transformer.device
+    with offload_models(pipeline.text_encoder, pipeline.vae, device=target_device, offload=True):
+        # avoid reusing same seed as in training, which would bias samples toward memorized results
+        seed = train_config.seed + 100_000
+        generator = torch.Generator(device=target_device).manual_seed(seed)
+        pbar = tqdm(
+            enumerate(train_config.sample_image_prompts, start=1), total=len(train_config.sample_image_prompts)
+        )
+        for idx, prompt in pbar:
+            image_path = os.path.join(sample_image_dir, f"{file_stem}_{idx:02d}.png")
+            outputs = _generate_images(pipeline, generator=generator, prompts=[prompt], config=train_config)
+            outputs.images[0].save(image_path)
+
+
+def main(*, path_experiment: str, experiment_name: str, clean: bool, bucket_name: Optional[str]) -> None:
+    tic_total = time.perf_counter()
+    start_date = dt.datetime.now(tz=dt.timezone.utc).replace(microsecond=0).isoformat()
+
+    peft_branch = get_peft_branch()
+    if peft_branch == "main":
+        print_verbose("===== This experiment is categorized as a MAIN run because the PEFT branch is 'main' ======")
+    else:
+        print_verbose(
+            f"===== This experiment is categorized as a TEST run because the PEFT branch is '{peft_branch}' ======"
+        )
+
+    peft_config: Optional[PeftConfig] = None
+    if os.path.exists(os.path.join(path_experiment, CONFIG_NAME)):
+        peft_config = PeftConfig.from_pretrained(path_experiment)
+    else:
+        print_verbose(f"Could not find PEFT config at {path_experiment}, performing FULL FINETUNING")
+
+    path_train_config = os.path.join(path_experiment, FILE_NAME_TRAIN_PARAMS)
+    train_config = get_train_config(path_train_config)
+    accelerator_memory_init = init_accelerator()
+    set_seed(train_config.seed)
+
+    model_info = get_base_model_info(train_config.model_id)
+    dataset_info = get_dataset_info(train_config.dataset_id)
+    pipeline = get_pipeline(
+        model_id=train_config.model_id,
+        dtype=train_config.dtype,
+        compile=train_config.compile,
+        peft_config=peft_config,
+        autocast_adapter_dtype=train_config.autocast_adapter_dtype,
+        use_gc=train_config.use_gc,
+    )
+    print_verbose(pipeline.transformer)
+
+    train_result = train(
+        pipeline=pipeline,
+        train_config=train_config,
+        accelerator_memory_init=accelerator_memory_init,
+        is_adalora=peft_config is not None and peft_config.peft_type == "ADALORA",
+        print_verbose=print_verbose,
+    )
+
+    if train_result.status == TrainStatus.FAILED:
+        print_verbose("Training failed, not logging results")
+        sys.exit(1)
+
+    file_size = get_file_size(pipeline.transformer, peft_config=peft_config, clean=clean, print_fn=print_verbose)
+
+    time_total = time.perf_counter() - tic_total
+    log_results(
+        experiment_name=experiment_name,
+        train_result=train_result,
+        time_total=time_total,
+        file_size=file_size,
+        model_info=model_info,
+        dataset_info=dataset_info,
+        start_date=start_date,
+        train_config=train_config,
+        peft_config=peft_config,
+        print_fn=print_verbose,
+    )
+
+    if (train_result.status == TrainStatus.SUCCESS) and train_config.sample_image_prompts:
+        print_verbose("Generating sample images")
+        try:
+            sample_image_dir = get_sample_image_save_dir(train_status=train_result.status, peft_branch=peft_branch)
+            file_stem = get_artifact_stem(experiment_name, start_date, sample_image_dir)
+            generate_sample_images(
+                pipeline=pipeline,
+                train_config=train_config,
+                sample_image_dir=sample_image_dir,
+                file_stem=file_stem,
+            )
+            print_verbose(f"Stored sample images in {sample_image_dir}")
+        except Exception as exc:
+            print_verbose(f"Sample image generation failed: {exc}")
+
+    if bucket_name:
+        huggingface_hub.create_bucket(bucket_name, exist_ok=True)
+        upload_checkpoint_to_bucket(pipeline.transformer, experiment_name, bucket_name)
+        upload_images_to_bucket(bucket_name)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-v", "--verbose", action="store_true", help="Enable verbose output")
+    parser.add_argument("path_experiment", type=str, help="Path to the experiment directory")
+    parser.add_argument(
+        "--clean",
+        action="store_true",
+        help="Delete training artifacts after run finishes (logs are still saved)",
+    )
+    parser.add_argument("--bucket_name", type=str, help="HF bucket to upload checkpoints and images to.")
+    args = parser.parse_args()
+
+    experiment_name = validate_experiment_path(args.path_experiment)
+
+    if args.verbose:
+
+        def print_verbose(*args, **kwargs) -> None:
+            kwargs["file"] = sys.stderr
+            print(*args, **kwargs)
+    else:
+
+        def print_verbose(*args, **kwargs) -> None:
+            pass
+
+    main(
+        path_experiment=args.path_experiment,
+        experiment_name=experiment_name,
+        clean=args.clean,
+        bucket_name=args.bucket_name,
+    )
diff --git a/method_comparison/image-gen/sample-images/cancelled_results/.gitkeep b/method_comparison/image-gen/sample-images/cancelled_results/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/method_comparison/image-gen/sample-images/results/.gitkeep b/method_comparison/image-gen/sample-images/results/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/method_comparison/image-gen/sample-images/temporary_results/.gitkeep b/method_comparison/image-gen/sample-images/temporary_results/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/method_comparison/image-gen/temporary_results/.gitkeep b/method_comparison/image-gen/temporary_results/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/method_comparison/image-gen/utils.py b/method_comparison/image-gen/utils.py
new file mode 100644
index 0000000..f02ef2e
--- /dev/null
+++ b/method_comparison/image-gen/utils.py
@@ -0,0 +1,596 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+"""Utilities for the image generation benchmark."""
+
+import copy
+import enum
+import json
+import os
+import platform
+import subprocess
+import tempfile
+import warnings
+from collections.abc import Callable
+from dataclasses import asdict, dataclass
+from typing import Any, Literal, Optional
+
+import datasets
+import diffusers
+import huggingface_hub
+import numpy as np
+import torch
+import transformers
+from diffusers import Flux2KleinPipeline
+from torch import nn
+from transformers import AutoImageProcessor, AutoModel, get_cosine_schedule_with_warmup
+
+import peft
+from peft import PeftConfig, get_peft_model
+from peft.optimizers import create_lorafa_optimizer, create_loraplus_optimizer
+from peft.utils import SAFETENSORS_WEIGHTS_NAME, infer_device
+
+
+device = infer_device()
+
+if device not in ["cuda", "xpu"]:
+    raise RuntimeError("CUDA or XPU is not available, currently only CUDA or XPU is supported")
+
+ACCELERATOR_MEMORY_INIT_THRESHOLD = 500 * 2**20  # 500MB
+FILE_NAME_DEFAULT_TRAIN_PARAMS = os.path.join(os.path.dirname(__file__), "default_training_params.json")
+FILE_NAME_TRAIN_PARAMS = "training_params.json"
+RESULT_PATH = os.path.join(os.path.dirname(__file__), "results")
+RESULT_PATH_TEST = os.path.join(os.path.dirname(__file__), "temporary_results")
+RESULT_PATH_CANCELLED = os.path.join(os.path.dirname(__file__), "cancelled_results")
+SAMPLE_IMAGE_PATH = os.path.join(os.path.dirname(__file__), "sample-images")
+SAMPLE_IMAGE_PATH_MAIN = os.path.join(SAMPLE_IMAGE_PATH, "results")
+SAMPLE_IMAGE_PATH_TEST = os.path.join(SAMPLE_IMAGE_PATH, "temporary_results")
+SAMPLE_IMAGE_PATH_CANCELLED = os.path.join(SAMPLE_IMAGE_PATH, "cancelled_results")
+hf_api = huggingface_hub.HfApi()
+WARMUP_STEP_RATIO = 0.1
+
+
+@dataclass
+class TrainConfig:
+    """All configuration parameters associated with training the model
+
+    Args:
+        model_id: The model identifier, should not be changed
+        dataset_id: The dataset identifier, should not be changed
+        dataset_split: The dataset split to use, should not be changed
+        dtype: The data type to use for the model
+        resolution: The image resolution
+        batch_size: The batch size for training
+        batch_size_eval: The batch size for eval/test
+        repeats: The number of repeats for the dataset (if there are more steps than train samples)
+        max_steps: The maximum number of steps to train
+        eval_steps: The number of steps between evaluations
+        compile: Whether to compile the model
+        use_gc: Whether to use gradient checkpointing.
+        seed: The random seed
+        grad_norm_clip: The gradient norm clipping value (set to 0 to skip)
+        optimizer_type: The name of a torch optimizer (e.g. AdamW) or a PEFT method ("lora+", "lora-fa")
+        optimizer_kwargs: The optimizer keyword arguments (lr etc.)
+        lr_scheduler: The learning rate scheduler (currently only None or 'cosine' are supported)
+        use_amp: Whether to use automatic mixed precision
+        autocast_adapter_dtype: Whether to cast adapter dtype to float32, same argument as in PEFT
+        instance_prompts: The prompt(s) used for training instances
+        image_column: The column name for images in the dataset
+        valid_size: The validation set size
+        test_size: The test set size
+        num_inference_steps: The number of inference steps for image generation
+        guidance_scale: The guidance scale for image generation
+        max_sequence_length: The maximum sequence length for the text encoder
+        text_encoder_out_layers: The output layers of the text encoder to use
+        weighting_scheme: The weighting scheme for the loss
+        logit_mean: The logit mean for logit_normal weighting
+        logit_std: The logit std for logit_normal weighting
+        mode_scale: The mode scale for mode weighting
+        dino_model_id: The DINO model identifier for evaluation
+        dino_image_size: The image size for the DINO model
+        sample_image_prompts: The prompts used for generating sample images, should not be changed
+        drift_image_prompts: The prompts used for measuring drift, should not be changed
+    """
+
+    model_id: str
+    dataset_id: str
+    dataset_split: str
+    dtype: Literal["float32", "float16", "bfloat16"]
+    resolution: int
+    batch_size: int
+    batch_size_eval: int
+    repeats: int
+    max_steps: int
+    eval_steps: int
+    compile: bool
+    use_gc: bool
+    seed: int
+    grad_norm_clip: float
+    optimizer_type: str
+    optimizer_kwargs: dict[str, Any]
+    lr_scheduler: Optional[Literal["cosine"]]
+    use_amp: bool
+    autocast_adapter_dtype: bool
+    instance_prompts: str | list[str]
+    image_column: str
+    valid_size: int
+    test_size: int
+    num_inference_steps: int
+    guidance_scale: float
+    max_sequence_length: int
+    text_encoder_out_layers: list[int]
+    weighting_scheme: Literal["none", "sigma_sqrt", "logit_normal", "mode"]
+    logit_mean: float
+    logit_std: float
+    mode_scale: float
+    dino_model_id: str
+    dino_image_size: int
+    sample_image_prompts: list[str]
+    drift_image_prompts: list[str]
+
+    def __post_init__(self) -> None:
+        if self.dtype not in ["float32", "float16", "bfloat16"]:
+            raise ValueError(f"Invalid dtype: {self.dtype}")
+        if self.batch_size <= 0:
+            raise ValueError(f"Invalid batch_size: {self.batch_size}")
+        if self.batch_size_eval <= 0:
+            raise ValueError(f"Invalid batch_size_eval: {self.batch_size_eval}")
+        if self.repeats <= 0:
+            raise ValueError(f"Invalid repeats: {self.repeats}")
+        if self.max_steps <= 0:
+            raise ValueError(f"Invalid max_steps: {self.max_steps}")
+        if self.eval_steps <= 0:
+            raise ValueError(f"Invalid eval_steps: {self.eval_steps}")
+        if self.eval_steps > self.max_steps:
+            raise ValueError(f"Invalid eval_steps: {self.eval_steps} > max_steps: {self.max_steps}")
+        if self.grad_norm_clip < 0:
+            raise ValueError(f"Invalid grad_norm_clip: {self.grad_norm_clip}")
+        if self.optimizer_type not in ["lora+", "lora-fa"] and not hasattr(torch.optim, self.optimizer_type):
+            raise ValueError(f"Invalid optimizer_type: {self.optimizer_type}")
+        if self.lr_scheduler not in [None, "cosine"]:
+            raise ValueError(f"Invalid lr_scheduler: {self.lr_scheduler}, must be None or 'cosine'")
+
+
+def validate_experiment_path(path: str) -> str:
+    if not os.path.exists(FILE_NAME_DEFAULT_TRAIN_PARAMS):
+        raise FileNotFoundError(f"Missing default training params file '{FILE_NAME_DEFAULT_TRAIN_PARAMS}'")
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"Path {path} does not exist")
+
+    path_parts = path.rstrip(os.path.sep).split(os.path.sep)
+    if (len(path_parts) != 3) or (path_parts[-3] != "experiments"):
+        raise ValueError(
+            f"Path {path} does not have the correct structure, should be ./experiments/<peft-method>/<experiment-name>"
+        )
+
+    experiment_name = os.path.join(*path_parts[-2:])
+    return experiment_name
+
+
+def get_train_config(path: str) -> TrainConfig:
+    with open(FILE_NAME_DEFAULT_TRAIN_PARAMS) as f:
+        default_config_kwargs = json.load(f)
+
+    config_kwargs = {}
+    if os.path.exists(path):
+        with open(path) as f:
+            config_kwargs = json.load(f)
+
+    config_kwargs = {**default_config_kwargs, **config_kwargs}
+    return TrainConfig(**config_kwargs)
+
+
+def init_accelerator() -> int:
+    torch_accelerator_module = getattr(torch, device, torch.cuda)
+    torch.manual_seed(0)
+    torch_accelerator_module.reset_peak_memory_stats()
+    torch_accelerator_module.manual_seed_all(0)
+    nn.Linear(1, 1).to(device)
+
+    accelerator_memory_init = torch_accelerator_module.max_memory_reserved()
+    if accelerator_memory_init > ACCELERATOR_MEMORY_INIT_THRESHOLD:
+        raise RuntimeError(
+            f"{device} memory usage at start is too high: {accelerator_memory_init // 2**20}MB, "
+            f"please ensure that no other processes are running on {device}."
+        )
+
+    torch_accelerator_module.reset_peak_memory_stats()
+    accelerator_memory_init = torch_accelerator_module.max_memory_reserved()
+    return accelerator_memory_init
+
+
+def get_torch_dtype(dtype: Literal["float32", "float16", "bfloat16"]) -> torch.dtype:
+    if dtype == "float32":
+        return torch.float32
+    if dtype == "float16":
+        return torch.float16
+    return torch.bfloat16
+
+
+def get_pipeline(
+    *,
+    model_id: str,
+    dtype: Literal["float32", "float16", "bfloat16"],
+    compile: bool,
+    peft_config: Optional[PeftConfig],
+    autocast_adapter_dtype: bool,
+    use_gc: bool,
+):
+    torch_dtype = get_torch_dtype(dtype)
+    pipeline = Flux2KleinPipeline.from_pretrained(model_id, torch_dtype=torch_dtype)
+    pipeline.set_progress_bar_config(disable=True)
+    if use_gc:
+        pipeline.transformer.enable_gradient_checkpointing()
+
+    pipeline.vae.requires_grad_(False)
+    pipeline.text_encoder.requires_grad_(False)
+
+    transformer = pipeline.transformer
+    if peft_config is None:
+        transformer.requires_grad_(True)
+    else:
+        transformer = get_peft_model(transformer, peft_config, autocast_adapter_dtype=autocast_adapter_dtype)
+        pipeline.transformer = transformer
+
+    if compile:
+        pipeline.transformer = torch.compile(pipeline.transformer, dynamic=True)
+
+    pipeline.transformer.train()
+    pipeline.vae.eval()
+    pipeline.text_encoder.eval()
+    return pipeline
+
+
+class DummyScheduler:
+    def __init__(self, lr):
+        self.lr = lr
+
+    def get_last_lr(self):
+        return [self.lr]
+
+    def step(self):
+        pass
+
+
+def get_optimizer_and_scheduler(
+    model, *, optimizer_type: str, max_steps: int, lr_scheduler_arg: Optional[Literal["cosine"]], **optimizer_kwargs
+) -> tuple[torch.optim.Optimizer, Any]:
+    if optimizer_type == "lora+":
+        optimizer = create_loraplus_optimizer(model, optimizer_cls=torch.optim.AdamW, **optimizer_kwargs)
+    elif optimizer_type == "lora-fa":
+        optimizer = create_lorafa_optimizer(model, **optimizer_kwargs)
+    else:
+        cls = getattr(torch.optim, optimizer_type)
+        optimizer = cls(model.parameters(), **optimizer_kwargs)
+
+    if lr_scheduler_arg == "cosine":
+        warmup_steps = int(WARMUP_STEP_RATIO * max_steps)
+        lr_scheduler = get_cosine_schedule_with_warmup(
+            optimizer, num_warmup_steps=warmup_steps, num_training_steps=max_steps
+        )
+    elif lr_scheduler_arg is None:
+        lr_scheduler = DummyScheduler(optimizer_kwargs["lr"])
+    else:
+        raise ValueError(f"Invalid lr_scheduler argument: {lr_scheduler_arg}")
+
+    return optimizer, lr_scheduler
+
+
+def upload_checkpoint_to_bucket(model: nn.Module, experiment_name: str, bucket_name: str):
+    """Uploads model checkpoint to Hugging Face Bucket"""
+    try:
+        with tempfile.TemporaryDirectory(ignore_cleanup_errors=True, delete=True) as tmp_dir:
+            model.save_pretrained(tmp_dir)
+            huggingface_hub.batch_bucket_files(
+                bucket_name,
+                add=[
+                    (os.path.join(tmp_dir, fname), f"checkpoints/{experiment_name}/{fname}")
+                    for fname in os.listdir(tmp_dir)
+                ],
+            )
+    except Exception as exc:
+        print(f"Failed to upload model checkpoint to hub: {exc}")
+
+
+def upload_images_to_bucket(bucket_name: str):
+    """Syncs test images (only main runs) with Hugging Face Bucket"""
+    try:
+        huggingface_hub.sync_bucket(SAMPLE_IMAGE_PATH, f"hf://buckets/{bucket_name}/sample-images", delete=False)
+    except Exception as exc:
+        print(f"Failed to upload sample images to hub: {exc}")
+
+
+def get_file_size(
+    transformer: nn.Module, *, peft_config: Optional[PeftConfig], clean: bool, print_fn: Callable[..., None]
+) -> int:
+    file_size = 99999999
+    if peft_config is not None:
+        try:
+            with tempfile.TemporaryDirectory(ignore_cleanup_errors=True, delete=clean) as tmp_dir:
+                transformer.save_pretrained(tmp_dir)
+                stat = os.stat(os.path.join(tmp_dir, SAFETENSORS_WEIGHTS_NAME))
+                file_size = stat.st_size
+                if not clean:
+                    print_fn(f"Saved PEFT checkpoint to {tmp_dir}")
+        except Exception as exc:
+            print(f"Failed to save PEFT checkpoint due to the following error: {exc}")
+    else:
+        print_fn("Not saving full model checkpoint because it is too large, estimating size instead")
+        try:
+            num_params = sum(param.numel() for param in transformer.parameters())
+            dtype_size = next(transformer.parameters()).element_size()
+            file_size = num_params * dtype_size
+        except Exception as exc:
+            print(f"Failed to determine file size for fully finetuned model because of: {exc}")
+    return file_size
+
+
+def get_base_model_info(model_id: str) -> Optional[huggingface_hub.ModelInfo]:
+    try:
+        return hf_api.model_info(model_id)
+    except Exception as exc:
+        warnings.warn(f"Could not retrieve model info, failed with error {exc}")
+        return None
+
+
+def get_dataset_info(dataset_id: str) -> Optional[huggingface_hub.DatasetInfo]:
+    try:
+        return hf_api.dataset_info(dataset_id)
+    except Exception as exc:
+        warnings.warn(f"Could not retrieve dataset info, failed with error {exc}")
+        return None
+
+
+def get_git_hash(module) -> Optional[str]:
+    module_path = module.__path__[0]
+    if "site-packages" in module_path:
+        return None
+    return subprocess.check_output("git rev-parse HEAD".split(), cwd=os.path.dirname(module.__file__)).decode().strip()
+
+
+def get_package_info() -> dict[str, Optional[str]]:
+    package_info = {
+        "transformers-version": transformers.__version__,
+        "transformers-commit-hash": get_git_hash(transformers),
+        "peft-version": peft.__version__,
+        "peft-commit-hash": get_git_hash(peft),
+        "datasets-version": datasets.__version__,
+        "datasets-commit-hash": get_git_hash(datasets),
+        "diffusers-version": diffusers.__version__,
+        "diffusers-commit-hash": get_git_hash(diffusers),
+        "torch-version": torch.__version__,
+        "torch-commit-hash": get_git_hash(torch),
+    }
+    return package_info
+
+
+def get_system_info() -> dict[str, str]:
+    torch_accelerator_module = getattr(torch, device, torch.cuda)
+    system_info = {
+        "system": platform.system(),
+        "release": platform.release(),
+        "version": platform.version(),
+        "machine": platform.machine(),
+        "processor": platform.processor(),
+        "accelerator": torch_accelerator_module.get_device_name(0),
+    }
+    return system_info
+
+
+@dataclass
+class MetaInfo:
+    package_info: dict[str, Optional[str]]
+    system_info: dict[str, str]
+    pytorch_info: str
+
+
+def get_meta_info() -> MetaInfo:
+    meta_info = MetaInfo(
+        package_info=get_package_info(),
+        system_info=get_system_info(),
+        pytorch_info=torch.__config__.show(),
+    )
+    return meta_info
+
+
+def get_peft_branch() -> str:
+    return (
+        subprocess.check_output("git rev-parse --abbrev-ref HEAD".split(), cwd=os.path.dirname(peft.__file__))
+        .decode()
+        .strip()
+    )
+
+
+class TrainStatus(enum.Enum):
+    FAILED = "failed"
+    SUCCESS = "success"
+    CANCELED = "canceled"
+
+
+@dataclass
+class TrainResult:
+    status: TrainStatus
+    train_time: float
+    accelerator_memory_reserved_log: list[int]
+    accelerator_memory_max_train: int
+    losses: list[float]
+    metrics: list[Any]
+    error_msg: str
+    num_trainable_params: int
+    num_total_params: int
+
+
+def get_dino_encoder(model_id: str, image_size: int):
+    processor = AutoImageProcessor.from_pretrained(model_id)
+    model = AutoModel.from_pretrained(model_id).to(device)
+    model.eval()
+    return processor, model
+
+
+@torch.inference_mode()
+def get_dino_embeddings(images, processor, model, batch_size: int):
+    embeddings = []
+    for i in range(0, len(images), batch_size):
+        batch_images = images[i : i + batch_size]
+        inputs = processor(images=batch_images, return_tensors="pt").to(model.device)
+        hidden_state = model(**inputs).last_hidden_state[:, 0]
+        hidden_state = torch.nn.functional.normalize(hidden_state, dim=-1)
+        embeddings.append(hidden_state)
+    return torch.cat(embeddings, dim=0)
+
+
+def log_to_console(log_data: dict[str, Any], print_fn: Callable[..., None]) -> None:
+    accelerator_memory_max = log_data["train_info"]["accelerator_memory_max"]
+    accelerator_memory_avg = log_data["train_info"]["accelerator_memory_reserved_avg"]
+    accelerator_memory_reserved_99th = log_data["train_info"]["accelerator_memory_reserved_99th"]
+    time_train = log_data["train_info"]["train_time"]
+    time_total = log_data["run_info"]["total_time"]
+    file_size = log_data["train_info"]["file_size"]
+
+    print_fn(f"accelerator memory max: {accelerator_memory_max // 2**20}MB")
+    print_fn(f"accelerator memory reserved avg: {accelerator_memory_avg // 2**20}MB")
+    print_fn(f"accelerator memory reserved 99th percentile: {accelerator_memory_reserved_99th // 2**20}MB")
+    print_fn(f"train time: {time_train}s")
+    print_fn(f"total time: {time_total:.2f}s")
+    print_fn(f"file size of checkpoint: {file_size / 2**20:.1f}MB")
+
+
+def log_to_file(
+    *, log_data: dict, save_dir: str, experiment_name: str, timestamp: str, print_fn: Callable[..., None]
+) -> None:
+    file_name = os.path.join(save_dir, f"{get_artifact_stem(experiment_name, timestamp, save_dir)}.json")
+    with open(file_name, "w") as f:
+        json.dump(log_data, f, indent=2)
+    print_fn(f"Saved log to: {file_name}")
+
+
+def get_result_save_dir(*, train_status: TrainStatus, peft_branch: str) -> str:
+    if train_status == TrainStatus.CANCELED:
+        return RESULT_PATH_CANCELLED
+    if peft_branch != "main":
+        return RESULT_PATH_TEST
+    if train_status == TrainStatus.SUCCESS:
+        return RESULT_PATH
+    return tempfile.mkdtemp()
+
+
+def get_sample_image_save_dir(*, train_status: TrainStatus, peft_branch: str) -> str:
+    if train_status == TrainStatus.CANCELED:
+        return SAMPLE_IMAGE_PATH_CANCELLED
+    if peft_branch != "main":
+        return SAMPLE_IMAGE_PATH_TEST
+    if train_status == TrainStatus.SUCCESS:
+        return SAMPLE_IMAGE_PATH_MAIN
+    return tempfile.mkdtemp()
+
+
+def get_artifact_stem(experiment_name: str, timestamp: str, save_dir: str) -> str:
+    experiment_name = experiment_name.replace(os.path.sep, "--")
+    if save_dir.endswith(RESULT_PATH) or save_dir.endswith(SAMPLE_IMAGE_PATH_MAIN):
+        return experiment_name
+    return f"{experiment_name}--{timestamp.replace(':', '-')}"
+
+
+def log_results(
+    *,
+    experiment_name: str,
+    train_result: TrainResult,
+    time_total: float,
+    file_size: int,
+    model_info: Optional[huggingface_hub.ModelInfo],
+    dataset_info: Optional[huggingface_hub.DatasetInfo],
+    start_date: str,
+    train_config: TrainConfig,
+    peft_config: Optional[PeftConfig],
+    print_fn: Callable[..., None],
+    save_dir: Optional[str] = None,
+) -> None:
+    if train_result.accelerator_memory_reserved_log:
+        accelerator_memory_avg = int(
+            sum(train_result.accelerator_memory_reserved_log) / len(train_result.accelerator_memory_reserved_log)
+        )
+        accelerator_memory_reserved_99th = int(np.percentile(train_result.accelerator_memory_reserved_log, 99))
+    else:
+        accelerator_memory_avg = 0
+        accelerator_memory_reserved_99th = 0
+
+    meta_info = get_meta_info()
+    if model_info is not None:
+        model_sha = model_info.sha
+        model_created_at = model_info.created_at.isoformat()
+    else:
+        model_sha = None
+        model_created_at = None
+
+    if dataset_info is not None:
+        dataset_sha = dataset_info.sha
+        dataset_created_at = dataset_info.created_at.isoformat()
+    else:
+        dataset_sha = None
+        dataset_created_at = None
+
+    peft_branch = get_peft_branch()
+
+    if save_dir is None:
+        save_dir = get_result_save_dir(train_status=train_result.status, peft_branch=peft_branch)
+
+    if save_dir == RESULT_PATH_CANCELLED:
+        print_fn("Experiment run was categorized as canceled")
+    elif save_dir == RESULT_PATH_TEST:
+        print_fn(f"Experiment run was categorized as a test run on branch {peft_branch}")
+    elif save_dir == RESULT_PATH:
+        print_fn("Experiment run was categorized as successful run")
+    else:
+        print_fn(f"Experiment could not be categorized, writing results to {save_dir}. Please open an issue on PEFT.")
+
+    if peft_config is None:
+        peft_config_dict: Optional[dict[str, Any]] = None
+    else:
+        peft_config_dict = copy.deepcopy(peft_config.to_dict())
+        for key, value in peft_config_dict.items():
+            if isinstance(value, set):
+                peft_config_dict[key] = list(value)
+
+    log_data = {
+        "run_info": {
+            "created_at": start_date,
+            "total_time": time_total,
+            "experiment_name": experiment_name,
+            "peft_branch": peft_branch,
+            "train_config": asdict(train_config),
+            "peft_config": peft_config_dict,
+            "error_msg": train_result.error_msg,
+        },
+        "train_info": {
+            "accelerator_memory_reserved_avg": accelerator_memory_avg,
+            "accelerator_memory_max": train_result.accelerator_memory_max_train,
+            "accelerator_memory_reserved_99th": accelerator_memory_reserved_99th,
+            "train_time": train_result.train_time,
+            "file_size": file_size,
+            "num_trainable_params": train_result.num_trainable_params,
+            "num_total_params": train_result.num_total_params,
+            "status": train_result.status.value,
+            "metrics": train_result.metrics,
+        },
+        "meta_info": {
+            "model_info": {"sha": model_sha, "created_at": model_created_at},
+            "dataset_info": {"sha": dataset_sha, "created_at": dataset_created_at},
+            **asdict(meta_info),
+        },
+    }
+
+    log_to_console(log_data, print_fn=print)
+    log_to_file(
+        log_data=log_data, save_dir=save_dir, experiment_name=experiment_name, timestamp=start_date, print_fn=print_fn
+    )
diff --git a/method_comparison/peft-shop/.gitignore b/method_comparison/peft-shop/.gitignore
new file mode 100644
index 0000000..07738b3
--- /dev/null
+++ b/method_comparison/peft-shop/.gitignore
@@ -0,0 +1,2 @@
+data.json
+method_capabilities.json
diff --git a/method_comparison/peft-shop/README.md b/method_comparison/peft-shop/README.md
new file mode 100644
index 0000000..1e47a92
--- /dev/null
+++ b/method_comparison/peft-shop/README.md
@@ -0,0 +1,37 @@
+---
+title: PEFT Shop
+sdk: gradio
+sdk_version: 6.2.0
+app_file: app.py
+pinned: false
+emoji: 🛍️
+---
+
+# PEFT Shop
+
+A Gradio app to browse PEFT methods like an online store: filter by capabilities (merging, multi-adapter support, quantization backends, targetable layer types, …) or by minimum customer rating ("★★★☆☆ & up"), and check benchmark results — star ratings for the benchmark-specific metrics (test accuracy and forgetting for MetaMathQA, DINO similarity and drift for image generation) as well as peak memory, checkpoint size, and train time, switchable between the benchmarks of the method comparison suite. Methods can be added to a cart 🛒, which shows usage code snippets and a feature comparison table for the collected methods — and checkout is, of course, free.
+
+## Running
+
+The app consumes a single data file, `data.json`, which it builds itself when missing. Building requires a repository checkout and a capability matrix, which has to be generated first in an environment with PEFT installed (the app itself only needs `gradio`):
+
+```sh
+# 1. generate the capability matrix from the PEFT code base
+python scripts/generate_method_capabilities.py --output method_capabilities.json
+
+# 2. launch the app; data.json is built on first run (--rebuild refreshes it, --build-only skips launching)
+python method_comparison/peft-shop/app.py
+```
+
+The directory can be deployed as-is as a Gradio Space; only `app.py`, `README.md` (the frontmatter is the Space config), `data.json`, and `requirements.txt` are needed. The official Space is deployed by `.github/workflows/deploy_peft_shop_app.yml`, which generates `method_capabilities.json` and `data.json` at deploy time.
+
+## Updating
+
+The deployment workflow redeploys the Space whenever the app, the benchmark results in `method_comparison/<benchmark>/results/`, or the capability script change on `main`; a monthly schedule and manual dispatch pick up everything else (e.g. newly added PEFT methods). Filter options and tile contents are derived from the data and update automatically — the steps above are only needed for local development (`--rebuild` refreshes a stale local `data.json`).
+
+To add a new benchmark, append a `BenchmarkSpec` entry to `BENCHMARKS` in `app.py` (pointing at the results directory and listing its metrics, the first of which serves as the headline score) and rebuild — the benchmark dropdown, the star ratings, and the cart's comparison table all derive from the spec. The only requirement is that the result files follow the common JSON layout of the method comparison suite.
+
+## Notes
+
+- Method descriptions and paper links are extracted from the official docs (and class docstrings), so they cannot drift from the documentation.
+- Benchmark numbers show each method's best run on the selected benchmark. The star ratings are quantile-based among the benchmarked PEFT methods (best 20% = five stars, next 20% = four, …); the score tooltip additionally states what full fine-tuning achieves, as a reference.
diff --git a/method_comparison/peft-shop/app.py b/method_comparison/peft-shop/app.py
new file mode 100644
index 0000000..886a23f
--- /dev/null
+++ b/method_comparison/peft-shop/app.py
@@ -0,0 +1,1330 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+"""The PEFT shop: a Gradio app to browse PEFT methods like an online store.
+
+Users can filter methods by their capabilities (merging, multi-adapter support, quantization backends, targetable layer
+types, ...) and by minimum star ratings, check benchmark results (switchable between the benchmarks of the method
+comparison suite, e.g. MetaMathQA or image generation), and jump to the PEFT docs. The app has three tabs: one to browse
+the shop, one for the cart, which shows usage code snippets and a feature comparison table for the collected methods,
+and an "About" page that puts the shop theme into perspective and calls for benchmark contributions. In keeping with the
+shop theme, every method has a (crossed-out) price tag, benchmark results double as customer star ratings, and checkout
+is free.
+
+The app reads a single `data.json` file. If that file does not exist (or --rebuild is passed), it is built by merging
+three sources from the PEFT repository checkout:
+
+1. The capability matrix produced by `scripts/generate_method_capabilities.py` (run that first; it needs an
+   environment with PEFT installed, which the app itself does not).
+2. The results of every benchmark registered in BENCHMARKS, aggregated to the best run (by benchmark score) per PEFT
+   method. Supporting a new benchmark only requires adding a BenchmarkSpec entry, provided its result files follow
+   the common JSON layout of the method comparison suite.
+3. Short method descriptions, extracted from the first paragraph of each method's documentation page. Sourcing the
+   descriptions from the docs instead of maintaining them here keeps them consistent with the official docs and
+   avoids drift; DESCRIPTION_OVERRIDES exists for cases where the extracted text reads poorly.
+
+A deployed Space therefore only needs `app.py`, `data.json`, and gradio, while a repository checkout can rebuild the
+data on the fly. The method cards live in a fixed pool of slots created once at startup, each consisting of a card body
+(HTML, since a catalog-style card look is not achievable with Gradio's native components) and a real gr.Button to add
+the method to the cart; filtering and sorting update the slots' content and visibility.
+
+Usage:
+
+    python app.py                # load data.json, build it first if missing
+    python app.py --rebuild      # force rebuilding data.json, then launch
+    python app.py --build-only   # only (re)build data.json, don't launch
+"""
+
+import argparse
+import hashlib
+import html
+import json
+import logging
+import math
+import re
+import textwrap
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import gradio as gr
+
+
+logger = logging.getLogger("peft-shop")
+
+HERE = Path(__file__).parent
+
+GIB = 1024**3
+
+# Version of the data.json layout produced by build_data; to be bumped when the layout changes, so that loading a
+# stale data.json fails loudly instead of crashing the app in odd places.
+DATA_SCHEMA_VERSION = 1
+
+
+@dataclass(frozen=True)
+class MetricSpec:
+    """One benchmark-specific metric, reported in the final "metrics" entry of a benchmark run."""
+
+    field: str  # key in the final "metrics" entry of a run
+    label: str  # display name
+    higher_is_better: bool
+    is_percent: bool = False  # whether the value is displayed as a percentage
+
+
+@dataclass(frozen=True)
+class BenchmarkSpec:
+    """Everything the app needs to know about one benchmark of the method comparison suite.
+
+    To add a new benchmark, append an entry to BENCHMARKS and rebuild data.json -- the benchmark dropdown, the star
+    ratings, and the cart's comparison table all derive from the spec. The only requirement is that the benchmark's
+    result files follow the common JSON layout of the method comparison suite (one file per run with run_info and
+    train_info, the final "metrics" entry holding the benchmark-specific metrics, full fine-tuning identified by a
+    missing peft_config).
+    """
+
+    key: str  # identifier used in data.json
+    label: str  # display name
+    model_name: str  # base model the benchmark runs on, for display
+    results_subdir: str  # location of the result files, relative to the method_comparison directory
+    # the benchmark-specific metrics; the first one is the headline score, used to pick each method's best run
+    metrics: tuple[MetricSpec, ...]
+
+
+BENCHMARKS: tuple[BenchmarkSpec, ...] = (
+    BenchmarkSpec(
+        key="metamathqa",
+        label="MetaMathQA",
+        model_name="Llama-3.2-3B",
+        results_subdir="MetaMathQA/results",
+        metrics=(
+            MetricSpec(field="test accuracy", label="test accuracy", higher_is_better=True, is_percent=True),
+            MetricSpec(field="forgetting", label="forgetting", higher_is_better=False),
+        ),
+    ),
+    BenchmarkSpec(
+        key="image-gen",
+        label="Image generation",
+        model_name="FLUX.2-klein-4B",
+        results_subdir="image-gen/results",
+        metrics=(
+            MetricSpec(field="test dino_similarity", label="DINO similarity", higher_is_better=True),
+            MetricSpec(field="drift", label="drift", higher_is_better=False),
+        ),
+    ),
+)
+BENCHMARKS_BY_KEY = {spec.key: spec for spec in BENCHMARKS}
+
+# Docs page slugs that differ from the lower-cased PEFT method name.
+DOCS_SLUG_OVERRIDES = {
+    "ADAPTION_PROMPT": "llama_adapter",
+    "CARTRIDGE": "cartridges",
+    "LN_TUNING": "layernorm_tuning",
+}
+DOCS_BASE_URL = "https://huggingface.co/docs/peft/main/en/package_reference"
+
+# Manual replacements for method descriptions where the text extracted from the docs is unsuitable. Maps the PEFT
+# method name (upper case) to the description.
+DESCRIPTION_OVERRIDES: dict[str, str] = {}
+
+BENCHMARK_SPACE_URL = "https://huggingface.co/spaces/peft-internal-testing/PEFT-method-comparison"
+
+
+# Sanity check: Minimum length, in characters, of an extracted paragraph for it to be accepted as a method description
+MIN_DESCRIPTION_LENGTH = 60
+
+
+def extract_description(docs_path: Path) -> str | None:
+    """Extract a short description from a method's documentation page.
+
+    The package_reference pages start with a license comment and a `# Title` heading, followed by a prose paragraph
+    describing the method. That paragraph, clipped to at most two sentences, makes a good card description. The title
+    is, however, frequently followed by other blocks first -- an image banner (a `<div>` wrapping an `<img>`), a
+    `<small>` caption, a doc-builder callout (`> [!TIP]`), or an `## Overview` subheading -- so the first block that
+    reads as prose is used: one that starts with a letter and is long enough to be a real sentence (a sanity check
+    against grabbing a markup leftover). Markdown links are flattened to their text.
+    """
+    try:
+        text = docs_path.read_text()
+    except OSError:
+        return None
+
+    # drop the HTML license comment, then take everything after the first heading
+    text = re.sub(r"<!--.*?-->", "", text, flags=re.DOTALL)
+    match = re.search(r"^# .+?$(.*)", text, flags=re.MULTILINE | re.DOTALL)
+    if match is None:
+        return None
+
+    # scan the blank-line-separated blocks and use the first one that reads as prose; non-prose blocks (image divs,
+    # captions, callouts, subheadings) start with a non-letter character or are too short to be a real description
+    for block in re.split(r"\n\s*\n", match.group(1)):
+        paragraph = " ".join(block.split())
+        paragraph = re.sub(r"\[([^\]]+)\]\([^)]*\)", r"\1", paragraph)  # [text](url) -> text
+        if not (paragraph[:1].isalpha() and len(paragraph) >= MIN_DESCRIPTION_LENGTH):
+            continue
+        # clip to at most two sentences to keep the cards compact
+        sentences = re.split(r"(?<=[.!?]) ", paragraph)
+        return " ".join(sentences[:2]).strip() or None
+    return None
+
+
+def load_benchmark_results(
+    results_dir: Path, spec: BenchmarkSpec
+) -> tuple[dict[str, dict[str, Any]], dict[str, Any] | None]:
+    """Aggregate one benchmark's runs to one entry per PEFT method.
+
+    Per method, the run with the best headline score is kept: a benchmark can contain multiple hyper-parameter settings
+    per method and users browsing methods are interested in what a method can achieve, not in its worst setting. The
+    full fine-tuning run is returned separately as a baseline for comparison.
+    """
+    score_field = spec.metrics[0].field
+    best_per_method: dict[str, dict[str, Any]] = {}
+    baseline: dict[str, Any] | None = None
+
+    for path in sorted(results_dir.glob("*.json")):
+        result = json.loads(path.read_text())
+        run_info = result["run_info"]
+        train_info = result["train_info"]
+        if train_info.get("status") != "success":
+            continue
+
+        metrics = train_info.get("metrics") or []
+        last = metrics[-1] if metrics else {}
+        if last.get(score_field) is None:
+            logger.warning(f"Skipping {path.name}: no '{score_field}' found")
+            continue
+
+        entry = {"experiment_name": run_info["experiment_name"]}
+        for metric in spec.metrics:
+            value = last.get(metric.field)
+            # e.g. the drift metric of the image generation benchmark is NaN for the full fine-tuning run; store null
+            # instead so that data.json remains valid JSON
+            if isinstance(value, float) and math.isnan(value):
+                value = None
+            entry[metric.field] = value
+        entry |= {
+            "peak_memory_bytes": train_info["accelerator_memory_max"],
+            "train_time_sec": train_info["train_time"],
+            "num_trainable_params": train_info["num_trainable_params"],
+            "adapter_file_size_bytes": train_info["file_size"],
+            "num_runs": 1,
+        }
+
+        peft_config = run_info.get("peft_config")
+        if not peft_config:  # full fine-tuning has no PEFT config
+            baseline = entry
+            continue
+
+        method = peft_config["peft_type"]
+        previous = best_per_method.get(method)
+        if previous is None:
+            best_per_method[method] = entry
+        else:
+            entry["num_runs"] = previous["num_runs"] + 1
+            if entry[score_field] >= previous[score_field]:
+                best_per_method[method] = entry
+            else:
+                previous["num_runs"] = entry["num_runs"]
+
+    return best_per_method, baseline
+
+
+def build_data(capabilities_path: Path, benchmarks_dir: Path, docs_dir: Path) -> dict[str, Any]:
+    capabilities = json.loads(capabilities_path.read_text())
+
+    baselines: dict[str, dict[str, Any] | None] = {}
+    method_benchmarks: dict[str, dict[str, Any]] = {}
+    for spec in BENCHMARKS:
+        best_per_method, baseline = load_benchmark_results(benchmarks_dir / spec.results_subdir, spec)
+        baselines[spec.key] = baseline
+        for method, entry in best_per_method.items():
+            method_benchmarks.setdefault(method, {})[spec.key] = entry
+
+    methods = {}
+    for name, info in sorted(capabilities["methods"].items()):
+        slug = DOCS_SLUG_OVERRIDES.get(name, name.lower())
+        docs_path = docs_dir / f"{slug}.md"
+        description = DESCRIPTION_OVERRIDES.get(name) or extract_description(docs_path)
+        if description is None:
+            logger.warning(f"No valid description found for {name} (looked at {docs_path})")
+            description = "See the PEFT documentation for details on this method."
+
+        # The paper link is determined by scripts/generate_method_capabilities.py (the "paper_url" feature). Older
+        # capability files may not contain it, and its value can be None or "unknown" -- only accept real URLs.
+        paper_value = info["features"].get("paper_url", {}).get("value")
+        paper_url = paper_value if isinstance(paper_value, str) and paper_value.startswith("http") else None
+
+        methods[name] = {
+            "config_class": info["config_class"],
+            "model_class": info["model_class"],
+            "features": info["features"],
+            "description": description,
+            # link to the index page when no dedicated docs page exists (e.g. brand-new methods)
+            "docs_url": f"{DOCS_BASE_URL}/{slug}" if docs_path.exists() else f"{DOCS_BASE_URL}/tuners",
+            "paper_url": paper_url,
+            "benchmarks": method_benchmarks.pop(name, {}),
+        }
+
+    for leftover in method_benchmarks:
+        logger.warning(f"Benchmark results for {leftover} have no matching capability entry, ignored")
+
+    return {
+        "schema_version": DATA_SCHEMA_VERSION,
+        "peft_version": capabilities["peft_version"],
+        "baselines": baselines,
+        "methods": methods,
+    }
+
+
+# Populated once at startup by _set_data; module-level state keeps the many small helpers below free of an explicit
+# `data` parameter.
+DATA: dict[str, Any] = {}
+METHODS: dict[str, Any] = {}
+
+
+def _set_data(data: dict[str, Any]) -> None:
+    global DATA, METHODS
+    DATA = data
+    METHODS = data["methods"]
+
+
+CATEGORY_LABELS = {
+    "adapter": "Adapter",
+    "prompt_learning": "Prompt learning",
+    "other": "Other",
+}
+
+# boolean capability features offered as filters; (label, feature key)
+CAPABILITIES = [
+    ("Mergeable into base weights", "merging"),
+    ("Multiple adapters", "multiple_adapters"),
+    ("Mixed adapter batches", "mixed_adapter_batches"),
+    ("Convertible to LoRA", "lora_conversion"),
+    ("Weighted adapter combination", "add_weighted_adapter"),
+    ("Hot-swappable", "hotswapping"),
+    ("Mixable with other methods", "peft_mixed_model"),
+    ("modules_to_save", "aux:modules_to_save"),
+    ("trainable_token_indices", "aux:trainable_token_indices"),
+]
+
+# the subset of capabilities rendered as badges on the cards, to keep them scannable
+SHORT_BADGES = [
+    ("merge", "merging"),
+    ("multi-adapter", "multiple_adapters"),
+    ("mixed batches", "mixed_adapter_batches"),
+    ("→ LoRA", "lora_conversion"),
+    ("weighted combine", "add_weighted_adapter"),
+    ("hotswap", "hotswapping"),
+]
+
+# Plain-language explanations of the capabilities, shown when hovering over the badges. Per capability: the text for a
+# supporting method, the text for a non-supporting method, and a neutral "whether ..." phrase for unknown support.
+CAPABILITY_EXPLAINERS: dict[str, tuple[str, str, str]] = {
+    "merging": (
+        "This method's adapter weights can be merged into the base model, eliminating the adapter's inference "
+        "overhead.",
+        "This method's adapter weights cannot be merged into the base model, so the adapter always incurs some "
+        "inference overhead.",
+        "whether the adapter weights can be merged into the base model",
+    ),
+    "multiple_adapters": (
+        "Several adapters of this method can be loaded on the same model at the same time and switched between.",
+        "Only a single adapter of this method can be loaded on a model at a time.",
+        "whether several adapters can be loaded on the same model",
+    ),
+    "mixed_adapter_batches": (
+        "A single inference batch can mix samples that use different adapters, via the adapter_names argument.",
+        "All samples in a batch must use the same adapter; the adapter_names argument is not supported.",
+        "whether one batch can mix samples that use different adapters",
+    ),
+    "lora_conversion": (
+        "A trained adapter of this method can be converted into an (approximately) equivalent LoRA adapter.",
+        "A trained adapter of this method cannot be converted into a LoRA adapter.",
+        "whether a trained adapter can be converted into a LoRA adapter",
+    ),
+    "add_weighted_adapter": (
+        "Several trained adapters can be combined into a new adapter via a weighted combination.",
+        "Combining several adapters into a new one (add_weighted_adapter) is not supported.",
+        "whether several adapters can be combined into a new one",
+    ),
+    "hotswapping": (
+        "Adapter weights can be swapped in-place without re-creating the model, e.g. to avoid torch.compile "
+        "recompilation.",
+        "Adapter weights cannot be hot-swapped; loading different weights requires re-creating the adapter.",
+        "whether adapter weights can be hot-swapped in-place",
+    ),
+    "peft_mixed_model": (
+        "This method can be combined with adapters of other PEFT method types on the same model (PeftMixedModel).",
+        "This method cannot be combined with other PEFT method types on the same model (PeftMixedModel).",
+        "whether the method can be combined with other PEFT method types",
+    ),
+    "aux:modules_to_save": (
+        "Additional base model layers (e.g. a classification head) can be made trainable and stored together with "
+        "the adapter (modules_to_save).",
+        "The modules_to_save option for training additional base model layers is not supported.",
+        "whether additional base model layers can be trained via modules_to_save",
+    ),
+    "aux:trainable_token_indices": (
+        "Selected token embeddings can be trained alongside the adapter without training the full embedding matrix "
+        "(trainable_token_indices).",
+        "The trainable_token_indices option for training selected token embeddings is not supported.",
+        "whether selected token embeddings can be trained via trainable_token_indices",
+    ),
+}
+
+
+def explain_capability(key: str, value: bool | None, note: str | None = None) -> str:
+    """The hover text for a capability badge, matching the badge's value."""
+    supported, unsupported, neutral = CAPABILITY_EXPLAINERS[key]
+    if value is True:
+        return supported
+    if value is False:
+        return unsupported
+    text = f"It could not be determined {neutral}."
+    if note:
+        text += f" Reason: {note}"
+    return text
+
+
+SORT_CHOICES = [
+    ("name", "name"),
+    ("benchmark score (best first)", "score"),
+    ("peak memory (lowest first)", "memory"),
+    ("trainable parameters (fewest first)", "params"),
+    ("checkpoint size (smallest first)", "size"),
+    ("train time (fastest first)", "time"),
+]
+
+
+def esc(text) -> str:
+    return html.escape(str(text), quote=True)
+
+
+def feature(method: str, key: str) -> dict:
+    return METHODS[method]["features"][key]
+
+
+def capability_value(method: str, key: str) -> bool | None:
+    """Return True/False for a boolean capability, None if unknown or not applicable."""
+    if key.startswith("aux:"):
+        aux = feature(method, "auxiliary_modules")["value"]
+        return bool(aux[key.removeprefix("aux:")]) if isinstance(aux, dict) else None
+    value = feature(method, key)["value"]
+    return value if isinstance(value, bool) else None
+
+
+def layer_types(method: str) -> dict[str, bool] | None:
+    value = feature(method, "target_layer_types")["value"]
+    return value if isinstance(value, dict) else None
+
+
+def quant_backends(method: str) -> list[str] | None:
+    """The supported quantization backends; None means "any".
+
+    Prompt learning methods report quantization as "not_applicable" because they don't wrap layers at all and therefore
+    work with (almost) any quantized base model -- treat that as supporting every backend.
+    """
+    value = feature(method, "quantization_backends")["value"]
+    if value == "not_applicable":
+        return None
+    return value if isinstance(value, list) else []
+
+
+def supports_quant(method: str, backend: str) -> bool:
+    backends = quant_backends(method)
+    return True if backends is None else backend in backends
+
+
+def fmt_bytes(num: float) -> str:
+    return f"{num / GIB:.1f} GB"
+
+
+def fmt_megabytes(num: float) -> str:
+    return f"{num / 1024**2:.1f} MB"
+
+
+def fmt_params(num: float) -> str:
+    if num >= 1e9:
+        return f"{num / 1e9:.1f}B"
+    if num >= 1e6:
+        return f"{num / 1e6:.1f}M"
+    return f"{num / 1e3:.0f}k"
+
+
+def fmt_minutes(seconds: float) -> str:
+    return f"{round(seconds / 60)} min"
+
+
+def fmt_metric(metric: MetricSpec, value: float) -> str:
+    return f"{100 * value:.1f}%" if metric.is_percent else f"{value:.3f}"
+
+
+# Deterministic tile "branding": separate bytes of a hash of the method name pick the colors and the gradient angle of
+# the card's product-image banner and its logo-like monogram. md5 is used instead of the builtin hash(), which is salted
+# per process and would not be stable between sessions. All colors are mid-tone so they work on light and dark
+# backgrounds; the banner applies them with low alpha, the monogram at full strength.
+TILE_COLORS: tuple[str, ...] = ("#e74c3c", "#e67e22", "#d4a017", "#10b981", "#06b6d4", "#3b82f6", "#8b5cf6", "#ec4899")
+
+
+def monogram(method: str) -> str:
+    """The 1-2 letter "logo" text of a method: initials of underscore-separated parts, else the first two letters."""
+    parts = method.split("_")
+    if len(parts) > 1:
+        return (parts[0][0] + parts[1][0]).upper()
+    if len(method) == 3:
+        return method.capitalize()
+    return method[:2].capitalize()
+
+
+def banner_html(method: str) -> str:
+    """The card's header banner: a hash-colored gradient strip with the logo-like monogram and the method name."""
+    digest = hashlib.md5(method.encode()).digest()
+    color = TILE_COLORS[digest[0] % len(TILE_COLORS)]
+    # the second gradient color is derived as an offset from the first, so the two always differ
+    second = TILE_COLORS[(digest[0] + 1 + digest[1] % (len(TILE_COLORS) - 1)) % len(TILE_COLORS)]
+    angle = digest[2] % 360
+    return (
+        f'<div class="banner" style="background: linear-gradient({angle}deg, {color}40, {second}40);">'
+        f'<span class="monogram" style="background: {color};">{esc(monogram(method))}</span>'
+        f"<h3>{esc(method)}</h3></div>"
+    )
+
+
+def fantasy_price(method: str) -> float:
+    """The shop-themed, hash-derived fantasy price of a method; always displayed crossed-out in favor of "FREE"."""
+    digest = hashlib.md5(method.encode()).digest()
+    return 9.99 + 10 * (digest[3] % 10)
+
+
+def price_html(method: str) -> str:
+    """The shop-themed price tag: the crossed-out fantasy price next to "FREE"."""
+    return f'<span class="price"><s>${fantasy_price(method):.2f}</s> <span class="free">FREE</span></span>'
+
+
+def _stars_span(n_stars: int, title: str) -> str:
+    return f'<span class="stars" title="{esc(title)}">{"★" * n_stars}{"☆" * (5 - n_stars)}</span>'
+
+
+def star_rating(spec: BenchmarkSpec, field: str, value: float, lower_is_better: bool = False) -> int:
+    """The customer star rating of one benchmark metric value, based on quantiles among the benchmarked PEFT methods.
+
+    The best 20% of the methods get five stars, the next 20% four, and so on; even the worst method keeps one star.
+    Quantiles are used instead of e.g. min-max scaling so that a single outlier cannot compress everyone else's
+    rating.
+    """
+    values = [info["benchmarks"][spec.key][field] for info in METHODS.values() if spec.key in info["benchmarks"]]
+    rank = sum(other < value if lower_is_better else other > value for other in values)
+    return 5 - int(5 * rank / len(values))
+
+
+def benchmark_stars(spec: BenchmarkSpec, field: str, value: float, title: str, lower_is_better: bool = False) -> str:
+    """A benchmark metric as a customer star rating (see star_rating), rendered as a hoverable span."""
+    return _stars_span(star_rating(spec, field, value, lower_is_better), title)
+
+
+def rated_metrics(spec: BenchmarkSpec) -> list[tuple[str, str, bool]]:
+    """(field, label, lower_is_better) of every star-rated metric of a benchmark, in card-row order.
+
+    This is the single source of truth for the rated rows: the cards, the rating filters, and their labels all derive
+    from it.
+    """
+    rows = [(metric.field, metric.label, not metric.higher_is_better) for metric in spec.metrics]
+    rows += [
+        ("peak_memory_bytes", "max memory allocated", True),
+        ("adapter_file_size_bytes", "checkpoint size", True),
+        ("train_time_sec", "train time", True),
+    ]
+    return rows
+
+
+# The five clickable stars of a minimum-rating filter (a gr.Radio restyled into a star bar via the .star-filter
+# CSS). Every choice renders as one star, the value is the minimum rating ("n stars & up"). The default of 1 filters
+# nothing, as even the worst-rated method keeps one star.
+RATING_CHOICES = [("★", n) for n in range(1, 6)]
+# Number of rating filter slots; for benchmarks with fewer rated metrics, the surplus slots are hidden.
+N_RATING_SLOTS = max(len(rated_metrics(spec)) for spec in BENCHMARKS)
+
+
+def badge(value: bool | None, label: str, title: str | None = None) -> str:
+    cls = "yes" if value is True else "no" if value is False else "unknown"
+    mark = "✓" if value is True else "✗" if value is False else "?"
+    return f'<span class="badge {cls}" title="{esc(title or "")}">{mark} {esc(label)}</span>'
+
+
+def render_card(method: str, spec: BenchmarkSpec) -> str:
+    """
+    The HTML content of a method's card on the shop page, based on its capabilities and benchmark results.
+    """
+    info = METHODS[method]
+    category = feature(method, "category")["value"]
+    bench = info["benchmarks"].get(spec.key)
+
+    # hovering over a badge explains what its value means; for "?" badges, the finding's note states why support
+    # could not be determined
+    badge_list = []
+    for label, key in SHORT_BADGES:
+        value = capability_value(method, key)
+        badge_list.append(badge(value, label, explain_capability(key, value, feature(method, key).get("note"))))
+    badges = "".join(badge_list)
+
+    backends = quant_backends(method)
+    if backends is None:
+        quant_html = '<span class="chip">any quantization</span>'
+    elif backends:
+        quant_html = "".join(f'<span class="chip">{esc(b)}</span>' for b in backends)
+    else:
+        quant_html = '<span class="chip muted">no quantized training</span>'
+
+    if bench:
+        baseline = DATA["baselines"][spec.key]
+        score = spec.metrics[0]
+        reference = (
+            f" (for reference, full fine-tuning reaches {fmt_metric(score, baseline[score.field])})"
+            if baseline
+            else ""
+        )
+
+        # per-field value formatting and hover-text description; the rows themselves come from rated_metrics
+        formatters = {metric.field: (lambda v, metric=metric: fmt_metric(metric, v)) for metric in spec.metrics}
+        formatters |= {
+            "peak_memory_bytes": fmt_bytes,
+            "adapter_file_size_bytes": fmt_megabytes,
+            "train_time_sec": fmt_minutes,
+        }
+        descriptions = {metric.field: f"{metric.label} on the PEFT {spec.label} benchmark" for metric in spec.metrics}
+        descriptions |= {
+            "peak_memory_bytes": f"Peak accelerator memory while training on the PEFT {spec.label} benchmark",
+            "adapter_file_size_bytes": f"Size of the saved checkpoint on the PEFT {spec.label} benchmark",
+            "train_time_sec": f"Training time on the PEFT {spec.label} benchmark",
+        }
+        # the hover text sits on the whole row (and, redundantly, on the stars span inside it), so hovering the
+        # metric name or the value explains the metric as well
+        row_html = []
+        for field, label, lower_is_better in rated_metrics(spec):
+            direction = "lower is better" if lower_is_better else "higher is better"
+            ref = reference if field == score.field else ""
+            title = f"{descriptions[field]}; {direction}{ref}. Stars rank the method among the other PEFT methods."
+            stars = benchmark_stars(spec, field, bench[field], title, lower_is_better=lower_is_better)
+            row_html.append(
+                f'<div class="bench-row" title="{esc(title)}"><span>{stars} {esc(label)}:</span>'
+                f"<strong>{esc(formatters[field](bench[field]))}</strong></div>"
+            )
+        bench_html = f"""
+        <div class="bench" title="Best of {bench["num_runs"]} run(s): {esc(bench["experiment_name"])}">
+          {"".join(row_html)}
+        </div>"""
+    else:
+        bench_html = f'<div class="bench muted">No reviews yet (no {esc(spec.label)} benchmark results).</div>'
+
+    # Overlong descriptions are truncated and get a "Show more" toggle that expands them in place. A hidden checkbox
+    # placed before the paragraph selects which of the two text spans is shown, and the toggle's text, through CSS
+    # sibling selectors (see the .more-toggle rules). Truncating by character count server-side (instead of a CSS line
+    # clamp) keeps the toggle and the truncation in sync: the toggle exists if and only if there is hidden text to
+    # reveal.
+    description = info["description"]
+    desc_html = esc(description)
+    toggle_html = ""
+    more_html = ""
+    if len(description) > 200:
+        short = textwrap.shorten(description, width=160, placeholder=" …")
+        desc_html = f'<span class="desc-short">{esc(short)}</span><span class="desc-full">{esc(description)}</span>'
+        toggle_html = f'<input type="checkbox" id="more-{esc(method)}" class="more-toggle">'
+        more_html = f'<label for="more-{esc(method)}" class="more-link"></label>'
+
+    paper_url = info.get("paper_url")  # .get: tolerate a data.json built before paper links were added
+    paper_html = (
+        f'<a class="cta secondary" href="{esc(paper_url)}" target="_blank" rel="noopener">Paper ↗</a>'
+        if paper_url
+        else ""
+    )
+
+    return f"""
+    <article class="card">
+      {banner_html(method)}
+      {toggle_html}
+      <p class="description">{desc_html}</p>
+      {more_html}
+      <div class="badges"><span class="chip category">{esc(CATEGORY_LABELS.get(category, category))}</span>{badges}</div>
+      <div class="quant-row">{quant_html}</div>
+      {bench_html}
+      <div class="card-footer">
+        <a class="cta" href="{esc(info["docs_url"])}" target="_blank" rel="noopener">Docs ↗</a>
+        {paper_html}
+        {price_html(method)}
+      </div>
+    </article>"""
+
+
+def matches_filters(
+    method: str,
+    search: str,
+    categories: list[str],
+    capabilities: list[str],
+    layers: list[str],
+    quant: list[str],
+    benchmarked_only: bool,
+    bench_key: str,
+    min_stars: tuple[int, ...],
+) -> bool:
+    """Filter semantics ("e-commerce" style):
+
+    - within "category" and "quantization": OR (any selected value matches)
+    - within "capabilities" and "layer types": AND (the method must support everything selected, like mandatory
+      product features)
+    - across filter groups: AND
+    - values reported as "unknown" by the capability script never match a positive filter: users filtering for a
+      feature should only see methods where support is established.
+    - min_stars holds the minimum-rating filters, one per rated metric (in rated_metrics order, 1 = no minimum);
+      they apply to the selected benchmark, so methods without results on it cannot match.
+    """
+    info = METHODS[method]
+    if search:
+        haystack = f"{method} {info['config_class']} {info['description']}".lower()
+        if search.lower() not in haystack:
+            return False
+
+    if categories and feature(method, "category")["value"] not in categories:
+        return False
+
+    if any(capability_value(method, key) is not True for key in capabilities):
+        return False
+
+    if layers:
+        supported = layer_types(method)
+        if supported is None or any(not supported.get(layer) for layer in layers):
+            return False
+
+    if quant and not any(supports_quant(method, backend) for backend in quant):
+        return False
+
+    if any(minimum > 1 for minimum in min_stars):
+        bench = info["benchmarks"].get(bench_key)
+        if bench is None:
+            return False
+        spec = BENCHMARKS_BY_KEY[bench_key]
+        for (field, _, lower_is_better), minimum in zip(rated_metrics(spec), min_stars):
+            if star_rating(spec, field, bench[field], lower_is_better) < minimum:
+                return False
+
+    return not (benchmarked_only and bench_key not in info["benchmarks"])
+
+
+def sort_key(sort_by: str, bench_key: str):
+    score_field = BENCHMARKS_BY_KEY[bench_key].metrics[0].field
+    metric = {
+        "score": lambda b: -b[score_field],
+        "memory": lambda b: b["peak_memory_bytes"],
+        "params": lambda b: b["num_trainable_params"],
+        "size": lambda b: b["adapter_file_size_bytes"],
+        "time": lambda b: b["train_time_sec"],
+    }.get(sort_by)
+    if metric is None:  # sort by name
+        return lambda method: (0, 0, method)
+
+    # methods without results on the selected benchmark sort last for metric-based sorts
+    def key(method: str):
+        bench = METHODS[method]["benchmarks"].get(bench_key)
+        return (bench is None, metric(bench) if bench else 0, method)
+
+    return key
+
+
+ADD_TO_CART_LABEL = "🛒 Add to cart"
+IN_CART_LABEL = "✅ In cart"
+
+
+def update_cards(
+    search, categories, capabilities, layers, quant, benchmarked_only, bench_key, sort_by, cart, *min_stars
+):
+    """Assign the filtered, sorted methods to the fixed pool of card slots.
+
+    The trailing arguments are the values of the rating filter slots (in rated_metrics order). Returns the count
+    markdown followed by (visibility, card HTML, method name, add button) for every slot; the button label shows whether
+    the slot's method is already in the cart. Slots beyond the number of matching methods are hidden and get an empty
+    method name, which add_to_cart treats as a no-op.
+    """
+    spec = BENCHMARKS_BY_KEY[bench_key]
+    cart = cart or []
+    selected = [
+        method
+        for method in METHODS
+        if matches_filters(
+            method, search, categories, capabilities, layers, quant, benchmarked_only, bench_key, min_stars
+        )
+    ]
+    selected.sort(key=sort_key(sort_by, bench_key))
+    count = f"**{len(selected)} of {len(METHODS)} items** — all free, all in stock"
+    if not selected:
+        count = f"**0 of {len(METHODS)} items** — no method matches the current filters."
+    # gr.update() is used here on purpose: updating layout blocks like Column through component constructors proved
+    # to be silently ignored
+    updates: list = [count]
+    for i in range(len(METHODS)):
+        if i < len(selected):
+            method = selected[i]
+            card = f'<div class="explorer">{render_card(method, spec)}</div>'
+            button_label = IN_CART_LABEL if method in cart else ADD_TO_CART_LABEL
+            updates.extend([gr.update(visible=True), card, method, gr.update(value=button_label)])
+        else:
+            updates.extend([gr.update(visible=False), "", "", gr.update(value=ADD_TO_CART_LABEL)])
+    return updates
+
+
+def reset_filters():
+    """Default values for all filter components, in the order of filter_inputs.
+
+    Programmatically resetting the components triggers their change listeners, which re-render the cards.
+    """
+    return ("", [], [], [], [], False, BENCHMARKS[0].key, "name") + (1,) * N_RATING_SLOTS
+
+
+def update_rating_filters(bench_key):
+    """Relabel the rating filter slots to the selected benchmark's rated metrics; surplus slots are hidden and
+    reset, so that a stale minimum cannot keep filtering invisibly."""
+    rows = rated_metrics(BENCHMARKS_BY_KEY[bench_key])
+    return [
+        gr.update(label=rows[i][1], visible=True) if i < len(rows) else gr.update(value=1, visible=False)
+        for i in range(N_RATING_SLOTS)
+    ]
+
+
+# Config arguments used in the cart's usage snippets. Methods not listed get generic arguments based on their
+# category; these are demo values and the snippet says so.
+SNIPPET_CONFIG_ARGS = {
+    "ADALORA": 'target_modules=["q_proj", "v_proj"], total_step=1000',
+    "ADAPTION_PROMPT": 'adapter_len=16, adapter_layers=8, task_type="CAUSAL_LM"',
+    "TRAINABLE_TOKENS": 'target_modules=["embed_tokens"], token_indices=[0, 1]',
+    "IA3": 'target_modules=["q_proj", "v_proj"], feedforward_modules=[]',
+}
+
+# Complete snippet replacements for methods whose usage does not follow the common pattern at all.
+SNIPPET_OVERRIDES = {
+    "XLORA": """\
+from transformers import AutoModelForCausalLM
+from peft import XLoraConfig, get_peft_model
+
+base_model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.2-3B", dtype="bfloat16")
+# X-LoRA learns to mix already trained LoRA adapters
+config = XLoraConfig(
+    task_type="CAUSAL_LM",
+    adapters={"adapter_0": "path/to/lora_0", "adapter_1": "path/to/lora_1"},
+)
+model = get_peft_model(base_model, config)""",
+}
+
+EMPTY_CART_SNIPPET = '# Your cart is empty - add PEFT methods in the "Browse the shop" tab to see how to use them.'
+
+
+def usage_snippet(method: str) -> str:
+    if method in SNIPPET_OVERRIDES:
+        return SNIPPET_OVERRIDES[method]
+    info = METHODS[method]
+    if method in SNIPPET_CONFIG_ARGS:
+        args = SNIPPET_CONFIG_ARGS[method]
+    elif feature(method, "category")["value"] == "prompt_learning":
+        args = 'task_type="CAUSAL_LM", num_virtual_tokens=20'
+    else:
+        args = 'target_modules=["q_proj", "v_proj"]'
+    return f"""\
+from transformers import AutoModelForCausalLM
+from peft import {info["config_class"]}, get_peft_model
+
+base_model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.2-3B", dtype="bfloat16")
+config = {info["config_class"]}({args})  # adjust the arguments to your needs
+model = get_peft_model(base_model, config)
+model.print_trainable_parameters()
+
+# train the model with your favorite training loop or trainer, then:
+model.save_pretrained("my-{method.lower()}-adapter")"""
+
+
+def build_comparison(methods: list[str]) -> str:
+    """The cart's feature comparison table: feature sets as rows, the collected methods as columns.
+
+    The results of all benchmarks are included, one labeled section each. The table is wrapped in a horizontally
+    scrollable container (see the .compare-scroll CSS), since any number of methods can be in the cart.
+    """
+    if not methods:
+        return '<div class="explorer"><p class="muted">Add methods to the cart to compare their features.</p></div>'
+
+    def row(label: str, cells: list[str]) -> str:
+        return f"<tr><th scope='row'>{esc(label)}</th>{''.join(f'<td>{c}</td>' for c in cells)}</tr>"
+
+    rows = [row("Category", [esc(CATEGORY_LABELS[feature(m, "category")["value"]]) for m in methods])]
+    for label, key in CAPABILITIES:
+        cells = []
+        for m in methods:
+            value = capability_value(m, key)
+            cells.append(badge(value, "", explain_capability(key, value)))
+        rows.append(row(label, cells))
+
+    def layers_cell(method: str) -> str:
+        supported = layer_types(method)
+        if supported is None:
+            return '<span class="muted">n/a</span>'
+        return ", ".join(esc(name) for name, ok in supported.items() if ok) or "—"
+
+    def quant_cell(method: str) -> str:
+        backends = quant_backends(method)
+        return "any" if backends is None else ", ".join(map(esc, backends)) or "—"
+
+    rows.append(row("Layer types", [layers_cell(m) for m in methods]))
+    rows.append(row("Quantization", [quant_cell(m) for m in methods]))
+
+    for spec in BENCHMARKS:
+        bench_rows = [
+            # the default argument binds the current metric, as default-less closures in a loop would all end up
+            # referring to the last one
+            (metric.label[0].upper() + metric.label[1:], lambda b, metric=metric: fmt_metric(metric, b[metric.field]))
+            for metric in spec.metrics
+        ]
+        bench_rows += [
+            ("Peak memory", lambda b: fmt_bytes(b["peak_memory_bytes"])),
+            ("Trainable params", lambda b: fmt_params(b["num_trainable_params"])),
+            ("Checkpoint size", lambda b: fmt_megabytes(b["adapter_file_size_bytes"])),
+            ("Train time", lambda b: fmt_minutes(b["train_time_sec"])),
+        ]
+        rows.append(f"<tr><th scope='row' class='section'>{esc(spec.label)} benchmark</th></tr>")
+        for label, fmt in bench_rows:
+            cells = [
+                esc(fmt(b)) if (b := METHODS[m]["benchmarks"].get(spec.key)) else '<span class="muted">—</span>'
+                for m in methods
+            ]
+            rows.append(row(label, cells))
+    rows.append(
+        row("Docs", [f'<a href="{esc(METHODS[m]["docs_url"])}" target="_blank" rel="noopener">↗</a>' for m in methods])
+    )
+
+    header = "".join(f"<th>{esc(m)}</th>" for m in methods)
+    return f"""
+    <div class="explorer compare-scroll">
+      <table class="compare-table">
+        <thead><tr><th></th>{header}</tr></thead>
+        <tbody>{"".join(rows)}</tbody>
+      </table>
+    </div>"""
+
+
+def build_receipt(methods: list[str]) -> str:
+    """The order confirmation opened by the pay button: a floating window (a native HTML popover, rendered in the
+    browser's top layer) showing a shop-style receipt with the crossed-out fantasy prices."""
+    if methods:
+        rows = "".join(
+            f"<tr><td>{esc(method)}</td><td><s>${fantasy_price(method):.2f}</s></td>"
+            f'<td><span class="free">FREE</span></td></tr>'
+            for method in methods
+        )
+        total = sum(fantasy_price(method) for method in methods)
+        body = f"""
+        <table class="receipt-table">{rows}</table>
+        <div class="receipt-total">
+          <span>Total ({len(methods)} item{"s" if len(methods) != 1 else ""})</span>
+          <span><s>${total:.2f}</s> $0.00</span>
+        </div>
+        <p>📦 Estimated delivery: today. For express delivery: <code>pip install peft</code></p>
+        <p class="muted">Thank you for shopping parameter-efficiently! 🤗</p>"""
+    else:
+        body = (
+            "<p>Your cart is empty — but don't worry, even a full one would be free. "
+            "Add methods in the “Browse the shop” tab.</p>"
+        )
+    return (
+        '<div class="explorer"><div popover id="pay-receipt" class="receipt-popover">'
+        f"<h4>🧾 Order receipt — PEFT Shop</h4>{body}</div></div>"
+    )
+
+
+def update_cart(methods: list[str]) -> tuple[str, str, str, dict]:
+    """Return the cart's code snippet, the feature comparison table, the (hidden) pay receipt, and the cart tab
+    label, which shows the number of collected methods."""
+    methods = methods or []
+    tab = gr.update(label=f"🛒 Cart ({len(methods)})" if methods else "🛒 Cart")
+    if not methods:
+        return EMPTY_CART_SNIPPET, build_comparison([]), build_receipt([]), tab
+    snippet = "\n\n\n".join(f"# ========== {method} ==========\n{usage_snippet(method)}" for method in methods)
+    return snippet, build_comparison(methods), build_receipt(methods), tab
+
+
+def add_to_cart(cart: list[str] | None, method: str) -> list[str]:
+    cart = list(cart or [])
+    if method and method not in cart:
+        cart.append(method)
+        gr.Info(f"{method} added to the cart 🛒")
+    return cart
+
+
+BENCHMARK_LIST = ", ".join(f"{spec.label} on {spec.model_name}" for spec in BENCHMARKS)
+
+ABOUT_MD = f"""
+## About the PEFT shop
+
+This is an official app of the 🤗 [PEFT](https://github.com/huggingface/peft) library — but please take its
+contents lightly: the shop is a playful way to explore the PEFT methods, not a buyer's guide. In particular, it
+does not endorse any PEFT method over any other. The prices are made up, and the star ratings compress a handful
+of benchmark runs into a coarse ranking; which method works best depends on your model, your task, and your
+compute budget.
+
+The capability data (the badges and filters) is generated directly from the PEFT source code, so it reflects what
+the library actually does. The benchmark numbers come from the [PEFT method comparison]({BENCHMARK_SPACE_URL}),
+where each method is represented by its best run.
+
+## Contribute to the benchmarks 🧪
+
+The benchmarks can always use more coverage, and contributions are very welcome, for example:
+
+- results for methods that have no reviews yet, or better hyper-parameter settings for existing entries
+- new benchmark tasks beyond the current ones
+
+Head over to the [method comparison directory](https://github.com/huggingface/peft/tree/main/method_comparison)
+to get started, and open an [issue](https://github.com/huggingface/peft/issues) to discuss new benchmark ideas or
+anything in the shop that looks off.
+"""
+
+
+# Styling for the HTML-rendered parts. The palette is mapped to Gradio's own theme CSS variables where possible, so
+# light and dark mode adapt automatically (a hand-rolled `.dark` override proved unreliable). The badge and chip
+# backgrounds use translucent colors that work on top of both light and dark surfaces.
+CSS = """
+.explorer, .method-card { --x-surface: var(--background-fill-primary);
+  --x-surface-2: var(--background-fill-secondary); --x-text: var(--body-text-color);
+  --x-muted: var(--body-text-color-subdued); --x-border: var(--border-color-primary);
+  --x-accent: var(--color-accent); --x-accent-soft: rgba(255, 157, 0, 0.16);
+  --x-yes: #22c55e; --x-yes-bg: rgba(34, 197, 94, 0.16); --x-no: #ef4444; --x-no-bg: rgba(239, 68, 68, 0.14);
+  --x-unknown: #9ca3af; --x-unknown-bg: rgba(156, 163, 175, 0.2); color: var(--x-text); }
+
+.explorer .card { display: flex; flex-direction: column; gap: 0.6rem; }
+.explorer .card h3 { margin: 0; font-size: 1.3rem; font-weight: 700; line-height: 1.15;
+  letter-spacing: 0.02em; min-width: 0; overflow-wrap: anywhere; }
+/* the header banner: a gradient strip carrying the method's logo-like monogram and its name (colors are set
+   inline per method) */
+.explorer .banner { min-height: 3.2rem; border-radius: 8px; display: flex; align-items: center; gap: 0.6rem;
+  padding: 0.4rem 0.7rem; }
+.explorer .monogram { width: 2.2rem; height: 2.2rem; flex-shrink: 0; border-radius: 8px; display: flex;
+  align-items: center; justify-content: center; color: #fff; font-weight: 800; font-size: 0.95rem;
+  text-shadow: 0 1px 2px rgba(0, 0, 0, 0.35); box-shadow: 0 2px 6px rgba(0, 0, 0, 0.25); }
+.explorer .description { margin: 0; color: var(--x-muted); font-size: 0.86rem; }
+.explorer .badges, .explorer .quant-row { display: flex; flex-wrap: wrap; gap: 0.3rem; }
+.explorer .badge { font-size: 0.74rem; padding: 0.12rem 0.45rem; border-radius: 999px; white-space: nowrap; }
+.explorer .badge.yes { color: var(--x-yes); background: var(--x-yes-bg); }
+.explorer .badge.no { color: var(--x-no); background: var(--x-no-bg); opacity: 0.85; }
+.explorer .badge.unknown { color: var(--x-unknown); background: var(--x-unknown-bg); }
+.explorer .chip { font-size: 0.72rem; padding: 0.1rem 0.45rem; border-radius: 6px; background: var(--x-surface-2);
+  border: 1px solid var(--x-border); white-space: nowrap; }
+.explorer .chip.category { background: var(--x-accent-soft); border-color: transparent; color: var(--x-accent);
+  font-weight: 600; }
+.explorer .stars { color: #f5b50a; letter-spacing: 0.05em; }
+.explorer .price { margin-left: auto; align-self: center; font-size: 0.85rem; color: var(--x-muted); }
+.explorer .free { color: var(--x-accent); font-weight: 800; margin-left: 0.2rem; }
+.explorer .muted { color: var(--x-muted); }
+.explorer .bench { background: var(--x-surface-2); border-radius: 8px; padding: 0.6rem 0.7rem; font-size: 0.84rem; }
+.explorer .bench-row { display: flex; justify-content: space-between; }
+.explorer .card-footer { margin-top: auto; display: flex; gap: 0.5rem; }
+.explorer .cta { display: inline-block; background: var(--x-accent); color: #1f2328; text-decoration: none;
+  font-weight: 600; font-size: 0.85rem; padding: 0.35rem 0.8rem; border-radius: 8px; }
+.explorer .cta.secondary { background: var(--x-surface-2); color: var(--x-text);
+  border: 1px solid var(--x-border); }
+
+/* The "Show more" toggle of overlong descriptions: a hidden checkbox before the description paragraph selects
+   which of the two text spans (truncated or full) is shown, and the label's text flips between "Show more" and
+   "Show less", like overlong YouTube comments. The checkbox is hidden via our own CSS instead of the `hidden`
+   attribute, which does not survive Gradio's HTML handling. */
+.explorer .more-toggle { display: none !important; }
+.explorer .more-link { color: var(--x-accent); cursor: pointer; font-size: 0.8rem; }
+.explorer .more-link::after { content: "Show more"; }
+.explorer .more-toggle:checked ~ .more-link::after { content: "Show less"; }
+.explorer .desc-full { display: none; }
+.explorer .more-toggle:checked ~ .description .desc-short { display: none; }
+.explorer .more-toggle:checked ~ .description .desc-full { display: inline; }
+
+/* The pay button's order receipt, a native popover in the browser's top layer. It is re-centered explicitly: the
+   browser stylesheet would center it via `margin: auto`, but Gradio's styles interfere with that, leaving the
+   popover stuck at the viewport edge. Centering via top/left/transform (with !important) depends on fewer
+   properties and survives the interference. */
+.explorer .receipt-popover { position: fixed !important; top: 50% !important; left: 50% !important;
+  bottom: auto !important; right: auto !important; margin: 0 !important; transform: translate(-50%, -50%);
+  max-height: 85vh; overflow-y: auto; min-width: min(480px, 92vw); padding: 1.6rem 2rem;
+  border: 1px solid var(--x-border); border-radius: 14px; background: var(--x-surface); color: var(--x-text);
+  font-size: 1rem; box-shadow: 0 18px 50px rgba(0, 0, 0, 0.4); }
+.explorer .receipt-popover::backdrop { background: rgba(0, 0, 0, 0.55); }
+.explorer .receipt-popover h4 { margin: 0 0 1rem; font-size: 1.5rem; }
+.explorer .receipt-popover s { color: var(--x-muted); }
+.explorer .receipt-popover p { margin: 0.9rem 0 0; }
+.explorer .receipt-table { width: 100%; border-collapse: collapse; font-size: 0.95rem; }
+.explorer .receipt-table td { padding: 0.25rem 0; }
+.explorer .receipt-table td:nth-child(n+2) { text-align: right; padding-left: 1.4rem; white-space: nowrap; }
+.explorer .receipt-total { display: flex; justify-content: space-between; gap: 1.2rem; font-weight: 700;
+  border-top: 1px solid var(--x-border); margin-top: 0.6rem; padding-top: 0.6rem; }
+
+/* The comparison table grows by one column per method in the cart, so its wrapper scrolls horizontally; the sticky
+   first column keeps the feature labels visible while scrolling. */
+.compare-scroll { overflow-x: auto; }
+.explorer .compare-table { border-collapse: collapse; width: max-content; min-width: 100%; font-size: 0.86rem; }
+.explorer .compare-table th, .explorer .compare-table td { border-top: 1px solid var(--x-border);
+  padding: 0.4rem 0.8rem; text-align: left; vertical-align: top; min-width: 8rem; max-width: 18rem; }
+.explorer .compare-table thead th { border-top: none; font-size: 0.95rem; }
+.explorer .compare-table tbody th, .explorer .compare-table thead th:first-child { position: sticky; left: 0;
+  background: var(--x-surface); z-index: 1; color: var(--x-muted); font-weight: 500; white-space: nowrap; }
+/* zebra striping for readability; the sticky label cells repeat the row shade with an opaque background so the
+   stripes stay consistent while scrolling horizontally */
+.explorer .compare-table tbody tr:nth-child(even) td { background: var(--x-surface-2); }
+.explorer .compare-table tbody tr:nth-child(even) th { background: var(--x-surface-2); }
+/* the divider row announcing which benchmark the metric rows below it belong to */
+.explorer .compare-table tbody th.section { padding-top: 1rem; color: var(--x-text); font-weight: 700; }
+/* The slot column is the visual tile: it carries the card chrome (instead of the HTML card body inside it), so that
+   the add-to-cart button -- a separate Gradio component below the card body -- appears inside the tile. */
+.method-card { background: var(--x-surface); border: 1px solid var(--x-border); border-radius: 12px;
+  padding: 0.9rem !important; gap: 0.5rem !important; transition: transform 0.12s ease, box-shadow 0.12s ease; }
+.method-card:hover { transform: translateY(-2px); box-shadow: 0 4px 14px rgba(0, 0, 0, 0.18); }
+/* Belt and braces: a slot whose card body is empty (i.e. not assigned a method by the current filter) is fully
+   hidden, independently of whether Gradio applies the visible=False update to the column. */
+.method-card:not(:has(.card)) { display: none !important; }
+
+/* The minimum-rating filters: a gr.Radio restyled into a clickable star bar. The radio circles are hidden and every
+   choice renders as one star; the stars up to the selected one stay gold, the ones after it are dimmed -- clicking
+   the n-th star therefore reads as "n stars & up". */
+.star-filter .wrap { display: flex; flex-direction: row; flex-wrap: nowrap; gap: 0.15rem; }
+.star-filter label { background: none !important; border: none !important; box-shadow: none !important;
+  padding: 0 !important; margin: 0 !important; cursor: pointer; }
+.star-filter label span { font-size: 1.5rem; line-height: 1; color: #f5b50a; padding: 0;
+  display: inline-block; transition: transform 0.1s ease; }
+.star-filter label:hover span { transform: scale(1.2); }
+.star-filter input[type="radio"] { display: none; }
+.star-filter label:has(input:checked) ~ label span { color: #9ca3af; opacity: 0.45; }
+
+/* Enlarge the tab labels (Browse the shop / Cart) so they are hard to miss. Tab buttons carry the ARIA role "tab";
+   the .tab-nav fallback covers Gradio versions that don't set it. */
+button[role="tab"], .tab-nav button { font-size: 1.3rem !important; font-weight: 600 !important;
+  padding: 0.5rem 1.4rem !important; }
+"""
+
+
+def build_demo() -> gr.Blocks:
+    # filter options for layer types and quantization are derived from the data, so new layer types/backends appear
+    # automatically
+    layer_names: list[str] = []
+    quant_names: set[str] = set()
+    for method in METHODS:
+        for name in layer_types(method) or {}:
+            if name not in layer_names:  # keep the original (probe) order rather than sorting alphabetically
+                layer_names.append(name)
+        quant_names.update(quant_backends(method) or [])
+
+    with gr.Blocks(title="PEFT Shop", css=CSS) as demo:
+        gr.Markdown(
+            "# 🤗 PEFT Shop\n"
+            "Your one-stop shop for parameter-efficient fine-tuning — every method free, always in stock. "
+            f"[Docs](https://huggingface.co/docs/peft/main/en/index) · "
+            f"[GitHub](https://github.com/huggingface/peft) · "
+            f"[Benchmarks]({BENCHMARK_SPACE_URL})"
+        )
+        # browsing, the cart, and the about page are top-level tabs; the tab labels are enlarged via CSS so they're hard
+        # to miss
+        with gr.Tabs():
+            with gr.Tab("🛍️ Browse the shop"):
+                with gr.Row():
+                    with gr.Column(scale=1, min_width=270):
+                        reset_button = gr.Button("Reset filters", size="sm")
+                        search = gr.Textbox(label="Search", placeholder="Search methods…")
+                        categories = gr.CheckboxGroup(
+                            choices=[(label, value) for value, label in CATEGORY_LABELS.items()], label="Category"
+                        )
+                        capabilities = gr.CheckboxGroup(
+                            choices=[(label, key) for label, key in CAPABILITIES],
+                            label="Capabilities (must support all selected)",
+                        )
+                        layers = gr.CheckboxGroup(
+                            choices=layer_names, label="Target layer types (must support all selected)"
+                        )
+                        quant = gr.CheckboxGroup(
+                            choices=sorted(quant_names), label="Quantization (any selected backend)"
+                        )
+                        # one minimum-rating filter per star-rated card row, like a shop's "customer rating" filter;
+                        # the labels follow the selected benchmark (see update_rating_filters)
+                        with gr.Accordion("⭐ Minimum customer rating", open=False):
+                            gr.Markdown(
+                                "<small>Click the lowest acceptable rating ('n stars & up'). Ratings refer to the "
+                                "selected benchmark; with a minimum above one star, methods without results on it "
+                                "are filtered out.</small>"
+                            )
+                            default_rows = rated_metrics(BENCHMARKS[0])
+                            rating_filters = [
+                                gr.Radio(
+                                    choices=RATING_CHOICES,
+                                    value=1,
+                                    label=default_rows[i][1] if i < len(default_rows) else "",
+                                    visible=i < len(default_rows),
+                                    elem_classes="star-filter",
+                                )
+                                for i in range(N_RATING_SLOTS)
+                            ]
+                        benchmarked_only = gr.Checkbox(label="Only methods with results on the selected benchmark")
+                    with gr.Column(scale=3):
+                        with gr.Row():
+                            count_md = gr.Markdown()
+                            benchmark = gr.Dropdown(
+                                choices=[(f"{spec.label} ({spec.model_name})", spec.key) for spec in BENCHMARKS],
+                                value=BENCHMARKS[0].key,
+                                label="Benchmark",
+                            )
+                            sort_by = gr.Dropdown(choices=SORT_CHOICES, value="name", label="Sort by")
+
+                        # The card grid is a fixed pool of slots, one per method, created once at startup: a column
+                        # with the card body (HTML), an "add to cart" button, and a State holding the method
+                        # currently displayed in the slot. Filtering and sorting update the slots' content and
+                        # visibility instead of re-creating components (e.g. via gr.render) -- event listeners on
+                        # components that are dynamically created proved unreliable, whereas listeners attached to
+                        # static components always work. Columns with min_width inside a row wrap automatically,
+                        # resulting in a responsive card grid.
+                        slots = []
+                        with gr.Row():
+                            for _ in range(len(METHODS)):
+                                with gr.Column(
+                                    min_width=340, visible=False, elem_classes="method-card"
+                                ) as slot_column:
+                                    slot_html = gr.HTML()
+                                    slot_method = gr.State("")
+                                    slot_button = gr.Button(ADD_TO_CART_LABEL, size="sm")
+                                slots.append((slot_column, slot_html, slot_method, slot_button))
+            with gr.Tab("🛒 Cart") as cart_tab:
+                cart_select = gr.Dropdown(
+                    choices=sorted(METHODS),
+                    multiselect=True,
+                    label="Cart contents (deselect to remove, or add directly)",
+                )
+                cart_code = gr.Code(value=EMPTY_CART_SNIPPET, language="python", label="How to use")
+                with gr.Row():
+                    copy_button = gr.Button("📋 Copy code")
+                    pay_button = gr.Button("Pay 💳", variant="primary")
+                    clear_button = gr.Button("Clear cart")
+                # the receipt popover is invisible until the pay button opens it
+                receipt_html = gr.HTML(build_receipt([]))
+                gr.Markdown("### Feature comparison")
+                compare_html = gr.HTML(build_comparison([]))
+            with gr.Tab("ℹ️ About"):
+                gr.Markdown(ABOUT_MD)
+        gr.Markdown(
+            f"<small>Capability data is generated from the PEFT code base (peft v{DATA['peft_version']}) by "
+            "`scripts/generate_method_capabilities.py`; values marked “?” could not be determined automatically. "
+            f"Benchmark numbers come from the [PEFT method comparison]({BENCHMARK_SPACE_URL}) ({BENCHMARK_LIST}); "
+            "each method shows its best run on the selected benchmark.</small>"
+        )
+
+        basic_filters = [search, categories, capabilities, layers, quant, benchmarked_only, benchmark, sort_by]
+        filter_inputs = basic_filters + rating_filters
+        # The cart is an extra input to the card rendering (for the "in cart" button labels) but deliberately not part
+        # of filter_inputs: resetting the filters must not clear the cart. It sits between the basic filters and the
+        # rating filters so that update_cards can take the latter as its variadic tail.
+        card_inputs = basic_filters + [cart_select] + rating_filters
+        slot_outputs = [count_md]
+        for slot_column, slot_html, slot_method, slot_button in slots:
+            slot_outputs.extend([slot_column, slot_html, slot_method, slot_button])
+        for component in filter_inputs:
+            # The search box needs both listeners: .input fires per keystroke but (in Gradio 6) not when characters are
+            # deleted, .change fires on any value change -- including deletions and programmatic ones like "reset
+            # filters" -- but might lag behind while typing. Double-firing is harmless, the render is
+            # idempotent. trigger_mode="always_last" makes sure the render runs again with the final value when events
+            # arrive while a previous render is still in flight -- the default "once" of .input would silently drop
+            # them, leaving the cards filtered by a stale prefix of the search query.
+            listeners = [component.change]
+            if isinstance(component, gr.Textbox):
+                listeners.append(component.input)
+            for listener in listeners:
+                listener(
+                    update_cards,
+                    inputs=card_inputs,
+                    outputs=slot_outputs,
+                    show_progress="hidden",
+                    trigger_mode="always_last",
+                )
+        demo.load(update_cards, inputs=card_inputs, outputs=slot_outputs, show_progress="hidden")
+        # the rating filters are labeled after the selected benchmark's metrics
+        benchmark.change(update_rating_filters, inputs=benchmark, outputs=rating_filters, show_progress="hidden")
+
+        for _, _, slot_method, slot_button in slots:
+            slot_button.click(
+                add_to_cart, inputs=[cart_select, slot_method], outputs=cart_select, show_progress="hidden"
+            )
+
+        # Updating cart_select programmatically (from the cards' add buttons or "clear cart") also triggers these
+        # listeners, so the code snippet, the comparison table, the pay receipt, the cart tab label, and the "in cart"
+        # button labels always follow along.
+        cart_outputs = [cart_code, compare_html, receipt_html, cart_tab]
+        cart_select.change(update_cart, inputs=cart_select, outputs=cart_outputs, show_progress="hidden")
+        cart_select.change(update_cards, inputs=card_inputs, outputs=slot_outputs, show_progress="hidden")
+        clear_button.click(list, outputs=cart_select, show_progress="hidden")
+        # the receipt is kept up to date by update_cart, so paying only needs to open the popover, which is a purely
+        # client-side affair (fn=None + js); same for writing to the clipboard, which only the browser can do
+        pay_button.click(None, js="() => document.getElementById('pay-receipt')?.togglePopover(true)")
+        copy_button.click(None, inputs=cart_code, js="(code) => { navigator.clipboard.writeText(code); }")
+        reset_button.click(reset_filters, outputs=filter_inputs, show_progress="hidden")
+
+    return demo
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="The PEFT shop; builds its data file on demand.")
+    parser.add_argument(
+        "--data", type=Path, default=HERE / "data.json", help="data file to load or build (default: %(default)s)"
+    )
+    parser.add_argument("--rebuild", action="store_true", help="rebuild the data file even if it exists")
+    parser.add_argument("--build-only", action="store_true", help="only (re)build the data file, don't launch the app")
+    parser.add_argument(
+        "--capabilities",
+        type=Path,
+        default=Path("method_capabilities.json"),
+        help="capability matrix produced by scripts/generate_method_capabilities.py, used when building "
+        "(default: %(default)s)",
+    )
+    parser.add_argument(
+        "--benchmarks-dir",
+        type=Path,
+        default=HERE.parent,
+        help="directory containing the benchmarks, i.e. one result folder per BENCHMARKS entry (default: the "
+        "method_comparison directory), used when building",
+    )
+    parser.add_argument(
+        "--docs-dir",
+        type=Path,
+        default=HERE.parent.parent / "docs" / "source" / "package_reference",
+        help="directory containing the package_reference docs pages (for the method descriptions), used when building",
+    )
+    return parser.parse_args(argv)
+
+
+def load_or_build_data(args: argparse.Namespace) -> dict[str, Any]:
+    if args.data.exists() and not (args.rebuild or args.build_only):
+        data = json.loads(args.data.read_text())
+        if data.get("schema_version") != DATA_SCHEMA_VERSION:
+            raise SystemExit(
+                f"{args.data} has schema version {data.get('schema_version')}, but this version of the app expects "
+                f"{DATA_SCHEMA_VERSION}. Rebuild the file with --rebuild."
+            )
+        return data
+
+    if not args.capabilities.exists():
+        raise SystemExit(
+            f"{args.data} does not exist and cannot be built because the capability matrix {args.capabilities} is "
+            "also missing. Generate it first with scripts/generate_method_capabilities.py or pass --capabilities."
+        )
+    data = build_data(args.capabilities, args.benchmarks_dir, args.docs_dir)
+    args.data.write_text(json.dumps(data, indent=2) + "\n")
+    logger.info(f"Wrote data for {len(data['methods'])} methods to {args.data}")
+    return data
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO, format="%(message)s")
+    args = parse_args()
+    data = load_or_build_data(args)
+    if not args.build_only:
+        _set_data(data)
+        build_demo().launch()
diff --git a/method_comparison/peft-shop/requirements.txt b/method_comparison/peft-shop/requirements.txt
new file mode 100644
index 0000000..c85a2db
--- /dev/null
+++ b/method_comparison/peft-shop/requirements.txt
@@ -0,0 +1 @@
+gradio>=6.2
diff --git a/method_comparison/processing.py b/method_comparison/processing.py
new file mode 100644
index 0000000..fc49f5f
--- /dev/null
+++ b/method_comparison/processing.py
@@ -0,0 +1,343 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+"""Data processing used for analyzing and presenting the results"""
+
+import json
+import os
+
+import pandas as pd
+
+
+_COMMON_METRIC_PREFERENCES = {
+    "accelerator_memory_reserved_avg": "lower",
+    "accelerator_memory_max": "lower",
+    "accelerator_memory_reserved_99th": "lower",
+    "total_time": "lower",
+    "train_time": "lower",
+    "file_size": "lower",
+    "train_loss": "lower",
+    "num_trainable_params": "lower",
+}
+
+_TASK_METRIC_PREFERENCES = {
+    "MetaMathQA": {
+        "test_accuracy": "higher",
+        "forgetting*": "lower",
+    },
+    "image-gen": {
+        "test_dino_similarity": "higher",
+        "drift*": "lower",
+    },
+}
+
+_TASK_PARETO_DEFAULTS = {
+    "MetaMathQA": ("accelerator_memory_max", "test_accuracy"),
+    "image-gen": ("accelerator_memory_max", "test_dino_similarity"),
+}
+
+_METRIC_EXPLANATIONS = {
+    "MetaMathQA": (
+        "*forgetting: This is the reduction in CE loss on a sample of Wikipedia data and reflects how much the "
+        "model 'forgot' during training. The lower the number, the better."
+    ),
+    "image-gen": (
+        "*drift: This measures how much the generated images drift from the base model's outputs on unrelated "
+        "prompts, reflecting how much the model 'forgot' during training. The lower the number, the better."
+    ),
+}
+
+
+def _get_metric_explanation(task_name):
+    return _METRIC_EXPLANATIONS.get(task_name, "")
+
+
+def _preprocess_common(row):
+    """Extract fields common to all tasks from a single result row.
+
+    Returns a tuple of metainfo dict and train metrics, or None if the row should be skipped.
+    """
+    run_info = row["run_info"]
+    train_info = row["train_info"]
+    meta_info = row["meta_info"]
+    if run_info["peft_config"]:
+        peft_type = run_info["peft_config"]["peft_type"]
+    else:
+        peft_type = "full-finetuning"
+    if train_info["status"] != "success":
+        return None
+
+    train_metrics = train_info["metrics"][-1]
+
+    dct = {
+        "experiment_name": run_info["experiment_name"],
+        "model_id": run_info["train_config"]["model_id"],
+        "train_config": json.dumps(run_info["train_config"]),
+        "peft_type": peft_type,
+        "peft_config": json.dumps(run_info["peft_config"]),
+        "accelerator_memory_reserved_avg": train_info["accelerator_memory_reserved_avg"],
+        "accelerator_memory_max": train_info["accelerator_memory_max"],
+        "accelerator_memory_reserved_99th": train_info["accelerator_memory_reserved_99th"],
+        "total_time": run_info["total_time"],
+        "train_time": train_info["train_time"],
+        "file_size": train_info["file_size"],
+        "num_trainable_params": train_info["num_trainable_params"],
+        "train_loss": train_metrics["train loss"],
+        "train_samples": train_metrics["train samples"],
+        "peft_version": meta_info["package_info"]["peft-version"],
+        "peft_branch": run_info["peft_branch"],
+        "transformers_version": meta_info["package_info"]["transformers-version"],
+        "datasets_version": meta_info["package_info"]["datasets-version"],
+        "torch_version": meta_info["package_info"]["torch-version"],
+        "package_info": json.dumps(meta_info["package_info"]),
+        "system_info": json.dumps(meta_info["system_info"]),
+        "created_at": run_info["created_at"],
+    }
+    return dct, train_metrics
+
+
+def _preprocess_metamathqa(dct, train_metrics, meta_info):
+    """Add MetaMathQA-specific fields."""
+    dct["test_accuracy"] = train_metrics["test accuracy"]
+    dct["train_total_tokens"] = train_metrics["train total tokens"]
+    dct["forgetting*"] = train_metrics.get("forgetting", 123)
+    dct["bitsandbytes_version"] = meta_info["package_info"]["bitsandbytes-version"]
+
+
+def _preprocess_image_gen(dct, train_metrics, meta_info):
+    """Add image-gen-specific fields."""
+    dct["test_dino_similarity"] = train_metrics["test dino_similarity"]
+    dct["drift*"] = train_metrics.get("drift", 123)
+    dct["diffusers_version"] = meta_info["package_info"]["diffusers-version"]
+
+
+_TASK_PREPROCESSORS = {
+    "MetaMathQA": _preprocess_metamathqa,
+    "image-gen": _preprocess_image_gen,
+}
+
+
+def format_df(df):
+    return df.style.format(precision=3, thousands=",", decimal=".")
+
+
+def preprocess(rows, task_name: str, print_fn=print):
+    task_preprocessor = _TASK_PREPROCESSORS.get(task_name)
+    if task_preprocessor is None:
+        raise ValueError(f"Unknown task_name: {task_name!r}. Choose from {list(_TASK_PREPROCESSORS)}")
+
+    results = []
+    skipped = 0
+    for row in rows:
+        common = _preprocess_common(row)
+        if common is None:
+            skipped += 1
+            continue
+
+        dct, train_metrics = common
+        dct["task_name"] = task_name
+        task_preprocessor(dct, train_metrics, row["meta_info"])
+        results.append(dct)
+
+    if skipped:
+        print_fn(f"Skipped {skipped} of {len(rows)} entries because the train status != success")
+
+    return results
+
+
+def load_jsons(path):
+    results = []
+    for fn in os.listdir(path):
+        if fn.endswith(".json"):
+            with open(os.path.join(path, fn)) as f:
+                row = json.load(f)
+                results.append(row)
+    return results
+
+
+_COMMON_DTYPES = {
+    "task_name": "string",
+    "experiment_name": "string",
+    "model_id": "string",
+    "train_config": "string",
+    "peft_type": "string",
+    "peft_config": "string",
+    "accelerator_memory_reserved_avg": int,
+    "accelerator_memory_max": int,
+    "accelerator_memory_reserved_99th": int,
+    "total_time": float,
+    "train_time": float,
+    "file_size": int,
+    "train_loss": float,
+    "train_samples": int,
+    "num_trainable_params": int,
+    "peft_version": "string",
+    "peft_branch": "string",
+    "transformers_version": "string",
+    "datasets_version": "string",
+    "torch_version": "string",
+    "package_info": "string",
+    "system_info": "string",
+    "created_at": "string",
+}
+
+_TASK_DTYPES = {
+    "MetaMathQA": {
+        "test_accuracy": float,
+        "train_total_tokens": int,
+        "forgetting*": float,
+        "bitsandbytes_version": "string",
+    },
+    "image-gen": {
+        "test_dino_similarity": float,
+        "drift*": float,
+        "diffusers_version": "string",
+    },
+}
+
+_TASK_IMPORTANT_COLUMNS = {
+    "MetaMathQA": [
+        "experiment_name",
+        "peft_type",
+        "total_time",
+        "train_time",
+        "test_accuracy",
+        "train_loss",
+        "accelerator_memory_max",
+        "accelerator_memory_reserved_99th",
+        "accelerator_memory_reserved_avg",
+        "num_trainable_params",
+        "file_size",
+        "created_at",
+        "task_name",
+        "forgetting*",
+    ],
+    "image-gen": [
+        "experiment_name",
+        "peft_type",
+        "total_time",
+        "train_time",
+        "test_dino_similarity",
+        "drift*",
+        "train_loss",
+        "accelerator_memory_max",
+        "accelerator_memory_reserved_99th",
+        "accelerator_memory_reserved_avg",
+        "num_trainable_params",
+        "file_size",
+        "created_at",
+        "task_name",
+    ],
+}
+
+
+def get_task_columns(task_name):
+    """Return the columns relevant to a task, ordered for display.
+
+    The important columns (including the task's own metrics) come first, followed by the remaining columns. Columns
+    belonging to other tasks are excluded.
+    """
+    relevant = list(_COMMON_DTYPES) + list(_TASK_DTYPES.get(task_name, {}))
+    important = _TASK_IMPORTANT_COLUMNS.get(task_name, ["experiment_name", "peft_type"])
+    ordered = [col for col in important if col in relevant]
+    ordered += [col for col in relevant if col not in ordered]
+    return ordered
+
+
+def load_df(path, task_name, print_fn=print):
+    jsons = load_jsons(path)
+    preprocessed = preprocess(jsons, task_name=task_name, print_fn=print_fn)
+    dtype_dict = {**_COMMON_DTYPES, **_TASK_DTYPES.get(task_name, {})}
+    if not preprocessed:
+        return pd.DataFrame(columns=dtype_dict.keys())
+    df = pd.DataFrame(preprocessed)
+    df = df.astype(dtype_dict)
+    df["created_at"] = pd.to_datetime(df["created_at"])
+    # round training time to nearest second
+    df["train_time"] = df["train_time"].round().astype(int)
+    df["total_time"] = df["total_time"].round().astype(int)
+
+    # reorder columns for better viewing, pinned_columns arg in Gradio seems not to work correctly
+    df = df[get_task_columns(task_name)]
+
+    columns = ["experiment_name", "model_id", "peft_type", "created_at"]
+    # we want to keep only the most recent run for each experiment
+    df = df.sort_values("created_at").drop_duplicates(columns, keep="last")
+    return df
+
+
+def get_metric_preferences(task_name):
+    prefs = dict(_COMMON_METRIC_PREFERENCES)
+    prefs.update(_TASK_METRIC_PREFERENCES.get(task_name, {}))
+    return prefs
+
+
+def get_model_ids(task_name, df):
+    filtered = df[df["task_name"] == task_name]
+    return sorted(filtered["model_id"].unique())
+
+
+def filter_data(task_name, model_id, df):
+    filtered = df[(df["task_name"] == task_name) & (df["model_id"] == model_id)]
+    # only show the columns relevant to the task, with the important ones first
+    return filtered[get_task_columns(task_name)]
+
+
+# Compute the Pareto frontier for two selected metrics.
+def compute_pareto_frontier(df, metric_x, metric_y, metric_preferences):
+    if df.empty:
+        return df
+
+    df = df.copy()
+    points = df[[metric_x, metric_y]].values
+    selected_indices = []
+
+    def dominates(a, b, metric_x, metric_y):
+        # Check for each metric whether b is as good or better than a
+        if metric_preferences[metric_x] == "higher":
+            cond_x = b[0] >= a[0]
+            better_x = b[0] > a[0]
+        else:
+            cond_x = b[0] <= a[0]
+            better_x = b[0] < a[0]
+        if metric_preferences[metric_y] == "higher":
+            cond_y = b[1] >= a[1]
+            better_y = b[1] > a[1]
+        else:
+            cond_y = b[1] <= a[1]
+            better_y = b[1] < a[1]
+        return cond_x and cond_y and (better_x or better_y)
+
+    for i, point in enumerate(points):
+        dominated = False
+        for j, other_point in enumerate(points):
+            if i == j:
+                continue
+            if dominates(point, other_point, metric_x, metric_y):
+                dominated = True
+                break
+        if not dominated:
+            selected_indices.append(i)
+    pareto_df = df.iloc[selected_indices]
+    return pareto_df
+
+
+def load_task_results(task_configs):
+    dfs = []
+    for task_name, path in task_configs.items():
+        if os.path.isdir(path):
+            task_df = load_df(path, task_name=task_name)
+            if not task_df.empty:
+                dfs.append(task_df)
+    return pd.concat(dfs, ignore_index=True)
diff --git a/method_comparison/requirements-app.txt b/method_comparison/requirements-app.txt
new file mode 100644
index 0000000..8a94ad3
--- /dev/null
+++ b/method_comparison/requirements-app.txt
@@ -0,0 +1,5 @@
+dash
+datasets
+gradio>=6.0.2
+huggingface_hub
+pandas
diff --git a/method_comparison/sanitizer.py b/method_comparison/sanitizer.py
new file mode 100644
index 0000000..71bc1bc
--- /dev/null
+++ b/method_comparison/sanitizer.py
@@ -0,0 +1,100 @@
+import ast
+
+import pandas as pd
+
+
+def _evaluate_node(df, node):
+    """
+    Recursively evaluates an AST node to generate a pandas boolean mask.
+    """
+    # Base Case: A simple comparison like 'price > 100'
+    if isinstance(node, ast.Compare):
+        if not isinstance(node.left, ast.Name):
+            raise TypeError("Left side of comparison must be a column name.")
+        col = node.left.id
+        if col not in df.columns:
+            raise ValueError(f"Column '{col}' not found in DataFrame.")
+
+        if len(node.ops) > 1:
+            raise ValueError("Chained comparisons like '10 < price < 100' are not supported.")
+
+        op_node = node.ops[0]
+        val_node = node.comparators[0]
+        try:
+            value = ast.literal_eval(val_node)
+        except ValueError:
+            raise ValueError("Right side of comparison must be a literal (number, string, list).")
+
+        operator_map = {
+            ast.Gt:    lambda c, v: df[c] > v,
+            ast.GtE:   lambda c, v: df[c] >= v,
+            ast.Lt:    lambda c, v: df[c] < v,
+            ast.LtE:   lambda c, v: df[c] <= v,
+            ast.Eq:    lambda c, v: df[c] == v,
+            ast.NotEq: lambda c, v: df[c] != v,
+            ast.In:    lambda c, v: df[c].isin(v),
+            ast.NotIn: lambda c, v: ~df[c].isin(v)
+        }
+        op_type = type(op_node)
+        if op_type not in operator_map:
+            raise ValueError(f"Unsupported operator '{op_type.__name__}'.")
+        return operator_map[op_type](col, value)
+
+    # Recursive Step: "Bitwise" operation & and | (the same as boolean operations)
+    elif isinstance(node, ast.BinOp):
+        if isinstance(node.op, ast.BitOr):
+            return _evaluate_node(df, node.left) | _evaluate_node(df, node.right)
+        elif isinstance(node.op, ast.BitAnd):
+            return _evaluate_node(df, node.left) & _evaluate_node(df, node.right)
+
+    # Recursive Step: A boolean operation like '... and ...' or '... or ...'
+    elif isinstance(node, ast.BoolOp):
+        op_type = type(node.op)
+        # Evaluate the first value in the boolean expression
+        result = _evaluate_node(df, node.values[0])
+        # Combine it with the rest of the values based on the operator
+        for i in range(1, len(node.values)):
+            if op_type is ast.And or op_type is ast.BitAnd:
+                result &= _evaluate_node(df, node.values[i])
+            elif op_type is ast.Or or op_type is ast.BitOr:
+                result |= _evaluate_node(df, node.values[i])
+        return result
+
+    elif isinstance(node, ast.UnaryOp):
+        if not isinstance(node.op, ast.Not):
+            raise TypeError("Only supported unary op is negation.")
+        return ~_evaluate_node(df, node.operand)
+
+    # If the node is not a comparison or boolean op, it's an unsupported expression type
+    else:
+        raise TypeError(f"Unsupported expression type: {type(node).__name__}")
+
+
+def parse_and_filter(df, filter_str):
+    """
+    Filters a pandas DataFrame using a string expression parsed by AST.
+    This is done to avoid the security vulnerables that `DataFrame.query`
+    brings (arbitrary code execution).
+
+    Args:
+        df (pd.DataFrame): The DataFrame to filter.
+        filter_str (str): A string representing a filter expression.
+                          e.g., "price > 100 and stock < 50"
+                          Supported operators: >, >=, <, <=, ==, !=, in, not in, and, or.
+
+    Returns:
+        pd.Series: A boolean Series representing the filter mask.
+    """
+    if not filter_str:
+        return pd.Series([True] * len(df), index=df.index)
+
+    try:
+        # 'eval' mode ensures the source is a single expression.
+        tree = ast.parse(filter_str, mode='eval')
+        expression_node = tree.body
+    except (SyntaxError, ValueError) as e:
+        raise ValueError(f"Invalid filter syntax: {e}")
+
+    # The recursive evaluation starts here
+    mask = _evaluate_node(df, expression_node)
+    return mask
diff --git a/method_comparison/test_sanitizer.py b/method_comparison/test_sanitizer.py
new file mode 100644
index 0000000..59c0dd1
--- /dev/null
+++ b/method_comparison/test_sanitizer.py
@@ -0,0 +1,38 @@
+import pandas as pd
+import pytest
+
+from .sanitizer import parse_and_filter
+
+
+@pytest.fixture
+def df_products():
+    data = {
+        'product_id': [101, 102, 103, 104, 105, 106],
+        'category': ['Electronics', 'Books', 'Electronics', 'Home Goods', 'Books', 'Electronics'],
+        'price': [799.99, 19.99, 49.50, 120.00, 24.99, 150.00],
+        'stock': [15, 300, 50, 25, 150, 0]
+    }
+    return pd.DataFrame(data)
+
+
+def test_exploit_fails(df_products):
+    with pytest.raises(ValueError) as e:
+        mask1 = parse_and_filter(df_products,
+            """price < 50 and @os.system("/bin/echo password")""")
+    assert 'Invalid filter syntax' in str(e)
+
+
+@pytest.mark.parametrize('expression,ids', [
+    ("price < 50", [102, 103, 105]),
+    ("product_id in [101, 102]", [101, 102]),
+    ("price < 50 and category == 'Electronics'", [103]),
+    ("stock < 100 or category == 'Home Goods'", [101, 103, 104, 106]),
+    ("(price > 100 and stock < 20) or category == 'Books'", [101, 102, 105, 106]),
+    ("not (price > 50 or stock > 100)", [103]),
+    ("not price > 50", [102, 103, 105]),
+    ("(price < 50) & (category == 'Electronics')", [103]),
+    ("(stock < 100) | (category == 'Home Goods')", [101, 103, 104, 106]),
+])
+def test_operations(df_products, expression, ids):
+    mask1 = parse_and_filter(df_products, expression)
+    assert sorted(df_products[mask1].product_id) == sorted(ids)
diff --git a/method_comparison/text_generation_benchmark/README.md b/method_comparison/text_generation_benchmark/README.md
new file mode 100644
index 0000000..9f727fb
--- /dev/null
+++ b/method_comparison/text_generation_benchmark/README.md
@@ -0,0 +1,179 @@
+## Base Model Inference Caching
+
+The benchmarking suite uses a separate script, `run_base.py`, to measure base model inference times and save results for reuse. This should be run once per model configuration to avoid redundant computations and ensure consistent baseline metrics for all PEFT experiments.
+
+**Usage:**
+```bash
+python run_base.py
+```
+This will cache the base model inference results for the specified configuration. Subsequent runs of `run.py` will automatically load these cached results.
+
+# PEFT Benchmarking Suite
+
+This directory contains a comprehensive benchmarking framework for Parameter-Efficient Fine-Tuning (PEFT) methods. For the task of text generation, the suite measures inference performance, memory usage, and other key metrics across different PEFT configurations.
+
+## Overview
+
+The benchmarking suite provides:
+- **Inference time measurement** across different prompt categories
+- **Memory usage during inference** (RAM and GPU)
+- **Parameter efficiency metrics** (trainable vs total parameters)
+- **Time per token analysis** for fair comparison across different generation lengths
+- **Structured result logging** with detailed metadata
+
+## Architecture
+
+The suite follows a clean separation between:
+1. **Default benchmark configuration** - shared settings for consistent comparison
+2. **Individual adapter configurations** - PEFT-specific parameters for each experiment
+
+This ensures that all experiments are comparable while allowing flexibility in adapter parameters.
+
+## Quick Start
+
+### Running a Single Experiment
+
+```bash
+# From the peft_bench directory
+python run.py experiments/lora/lora_r8 --verbose
+```
+
+## Configuration Structure
+
+The benchmarking suite uses a hierarchical configuration system:
+
+1. **Default benchmark parameters** (`default_benchmark_params.json`) - Base configuration shared by all experiments
+2. **Experiment-specific overrides** (`benchmark_params.json` in each experiment) - Optional overrides for specific experiments  
+3. **Adapter configuration** (`adapter_config.json` in each experiment) - PEFT method parameters
+
+This structure ensures consistent comparison while allowing flexibility where needed.
+
+### Default Configuration (`default_benchmark_params.json`)
+
+Contains shared benchmark settings that apply to all experiments. Here are the key configuration fields:
+
+- `model_id`: The Hugging Face model ID to use as the base model (e.g., "facebook/opt-350m")
+- `dtype`: Model precision ("float16", "float32", or "bfloat16")
+- `seed`: Random seed for reproducibility
+- `max_new_tokens`: Maximum number of tokens to generate during inference
+- `num_inference_runs`: Number of inference runs per prompt for statistical reliability
+- `use_4bit`: Whether to use 4-bit quantization (bool)
+- `use_8bit`: Whether to use 8-bit quantization (bool)
+
+Each experiment can override these settings by providing its own `benchmark_params.json` file.
+
+### Experiment Structure
+
+Each experiment directory should contain:
+
+1. `adapter_config.json`: PEFT adapter configuration. For details on available parameters and their meanings, refer to the [PEFT documentation](https://huggingface.co/docs/peft/main/en/developer_guides/adapters).
+
+2. (Optional) `benchmark_params.json`: Override specific benchmark parameters for this experiment.
+
+Example directory structure:
+```
+experiments/
+└── lora/
+    ├── lora_r8/                # LoRA rank 8 experiment
+    │   ├── adapter_config.json # PEFT adapter configuration
+    │   └── benchmark_params.json # Optional benchmark overrides
+    └── lora_r16/               # LoRA rank 16 experiment
+        └── adapter_config.json
+```
+
+### Experiment-Specific Overrides Example
+
+If an experiment needs different benchmark settings, create `benchmark_params.json`:
+```json
+{
+    "_comment": "Override settings for this specific experiment",
+    "max_new_tokens": 50,
+    "num_inference_runs": 15,
+    "num_prompt_samples": 2
+}
+```
+
+These parameters will override the defaults from `default_benchmark_params.json`. However, the defaults should generally not be changed to keep the results from the individual experiments comparable.
+
+### Create a New Experiment Adapter Configuration
+
+To create a new experiment, follow these steps:
+
+1. **Create the experiment directory**
+   ```bash
+   mkdir -p experiments/lora/lora_r8
+   ```
+
+2. **Generate the adapter configuration programmatically**
+   Use the PEFT library to create and save your adapter config:
+
+   ```python
+   from peft import LoraConfig
+
+   config = LoraConfig(
+       lora_alpha=16,
+       lora_dropout=0.1,
+       r=8,
+       target_modules=["q_proj", "v_proj"],
+       task_type="CAUSAL_LM"
+   )
+   config.save_pretrained("experiments/lora/lora_r8")
+   ```
+
+   This will create an `adapter_config.json` in your experiment directory. Adjust parameters as needed for your experiment.
+
+3. **(Optional) Add benchmark overrides**
+   If you need to override default benchmark settings, create a `benchmark_params.json` in the same directory.
+
+4. **Run the benchmark**
+   ```bash
+   python run.py experiments/lora/lora_r8 --verbose
+   ```
+
+## Prompt Categories
+
+The benchmark automatically runs across all prompt categories for consistent comparison:
+- **short** - Brief prompts (1-2 sentences)
+- **medium** - Moderate length prompts (paragraph-level)
+- **long** - Extended prompts (multiple paragraphs)
+
+Results are tracked separately for each category, allowing analysis of how different PEFT methods perform across varying input lengths.
+
+## Results Structure
+
+Results are saved in a structured JSON format with three main sections:
+
+### `run_info`
+- Execution metadata (timestamp, duration, status)
+- Hardware information (GPU type, CUDA version, etc.)
+- Error information (if applicable)
+- PEFT and benchmark configurations
+
+### `generation_info`
+- Memory usage logs at different stages
+- Per-category metrics (inference time, time per token, etc.)
+- Overall aggregated metrics
+- Individual sample results for detailed analysis
+
+### `meta_info`
+- Model information (ID, PEFT method)
+- Parameter counts (adapter, total, ratio)
+- Model size information (base model, adapter)
+- System and package information
+
+## Key Metrics
+
+### Inference Performance
+- **Inference Time**: Total time for generation per category
+- **Time Per Token**: Normalized time accounting for different generation lengths
+- **Inference Overhead**: Percentage increase compared to base model
+
+### Memory Usage
+- **Peak GPU Memory**: Maximum GPU memory during benchmark
+- **Peak RAM Memory**: Maximum RAM usage
+- **Memory Logs**: Detailed tracking at each stage
+
+### Parameter Efficiency
+- **Adapter Parameters**: Number of parameters in the PEFT adapter
+- **Parameter Ratio**: Percentage of total model parameters that are in the adapter
+- **Adapter Size**: Memory footprint of the adapter in MB
diff --git a/method_comparison/text_generation_benchmark/cancelled_results/.gitkeep b/method_comparison/text_generation_benchmark/cancelled_results/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/method_comparison/text_generation_benchmark/configs/prompts.json b/method_comparison/text_generation_benchmark/configs/prompts.json
new file mode 100644
index 0000000..7768b42
--- /dev/null
+++ b/method_comparison/text_generation_benchmark/configs/prompts.json
@@ -0,0 +1,23 @@
+{
+  "short": [
+    "Explain quantum computing in one paragraph.",
+    "Write a haiku about machine learning.",
+    "What's the difference between supervised and unsupervised learning?",
+    "Define parameter-efficient fine-tuning in one sentence.",
+    "List three applications of natural language processing."
+  ],
+  "medium": [
+    "Explain the concept of low-rank adaptation (LoRA) for large language models. Include its benefits and limitations.",
+    "Compare and contrast prompt tuning and prefix tuning approaches for adapting large language models.",
+    "What are the key differences between full fine-tuning and parameter-efficient methods? Explain with examples.",
+    "Describe the process of quantization for neural networks and how it affects model size and inference speed.",
+    "Explain how sparse expert models like Mixture of Experts work and their advantages over dense models."
+  ],
+  "long": [
+    "Analyze the evolution of parameter-efficient fine-tuning methods from 2020 to present. Include a detailed comparison of at least five different approaches, their theoretical foundations, and practical implications for deploying large language models.",
+    "Provide a comprehensive tutorial on implementing LoRA for a transformer-based language model. Include code examples, hyperparameter selection guidance, and best practices for training and deployment.",
+    "Compare the computational efficiency, parameter count, and performance characteristics of different PEFT methods (LoRA, Prefix Tuning, Prompt Tuning, IA3, AdaLoRA) across various downstream tasks. Include a discussion of when each method is most appropriate.",
+    "Explain the mathematical foundations of various parameter-efficient fine-tuning techniques. Discuss how each technique modifies the original neural network architecture and the optimization challenges involved.",
+    "Discuss the ethical implications of parameter-efficient fine-tuning methods in democratizing access to large language models. Include considerations about computational resources, environmental impact, and accessibility for researchers in resource-constrained settings."
+  ]
+} 
\ No newline at end of file
diff --git a/method_comparison/text_generation_benchmark/data.py b/method_comparison/text_generation_benchmark/data.py
new file mode 100644
index 0000000..ce3343f
--- /dev/null
+++ b/method_comparison/text_generation_benchmark/data.py
@@ -0,0 +1,119 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+"""
+Data handling utilities for PEFT benchmarking.
+"""
+
+import json
+import os
+from typing import Optional
+
+from transformers import PreTrainedTokenizer
+from utils import BenchmarkConfig
+
+
+DEFAULT_PROMPTS_PATH = os.path.join(os.path.dirname(__file__), "configs", "prompts.json")
+
+
+def load_test_prompts(config: dict) -> dict[str, list[str]]:
+    """
+    Load prompts from JSON file.
+
+    Args:
+        config: Configuration containing prompts file path
+
+    Returns:
+        dictionary with prompts by category
+    """
+    prompts_file = getattr(config, "prompts_file", DEFAULT_PROMPTS_PATH)
+
+    with open(prompts_file) as f:
+        prompts = json.load(f)
+
+    return prompts
+
+
+def truncate_prompt_for_model(
+    prompt: str,
+    tokenizer: PreTrainedTokenizer,
+    max_length: Optional[int] = None,
+    reserve_output_tokens: int = 50,
+) -> str:
+    """
+    Truncate a prompt to fit within the model's context window.
+
+    Args:
+        prompt: Input prompt
+        tokenizer: Model tokenizer
+        max_length: Maximum sequence length (if None, uses model's max_length)
+        reserve_output_tokens: Number of tokens to reserve for response
+
+    Returns:
+        Truncated prompt
+    """
+    if max_length is None:
+        if hasattr(tokenizer, "model_max_length"):
+            max_length = tokenizer.model_max_length
+        else:
+            max_length = 2048
+
+    max_prompt_length = max_length - reserve_output_tokens
+    input_ids = tokenizer.encode(prompt, return_tensors="pt")[0]
+
+    if len(input_ids) <= max_prompt_length:
+        return prompt
+
+    truncated_ids = input_ids[:max_prompt_length]
+    truncated_prompt = tokenizer.decode(truncated_ids, skip_special_tokens=True)
+
+    return truncated_prompt
+
+
+def prepare_benchmark_prompts(
+    config: BenchmarkConfig,
+    tokenizer: PreTrainedTokenizer,
+    max_input_length: Optional[int] = None,
+    seed: int = 42,
+) -> dict[str, list[str]]:
+    """
+    Prepare prompts for benchmarking, ensuring appropriate length and variety.
+    Always returns all prompt categories for consistent benchmarking.
+
+    Args:
+        config: Benchmark configuration
+        tokenizer: Model tokenizer
+        max_input_length: Maximum input length (overrides model default if provided)
+        seed: Random seed (kept for backwards compatibility)
+
+    Returns:
+        Dictionary with processed prompts by category (all categories included)
+    """
+    all_prompts = load_test_prompts(config)
+
+    processed_prompts = {}
+    for category, prompts in all_prompts.items():
+        truncated_prompts = [
+            truncate_prompt_for_model(
+                prompt,
+                tokenizer,
+                max_length=max_input_length,
+                reserve_output_tokens=getattr(config, "reserve_output_tokens", 50),
+            )
+            for prompt in prompts
+        ]
+
+        processed_prompts[category] = truncated_prompts
+
+    return processed_prompts
diff --git a/method_comparison/text_generation_benchmark/default_benchmark_params.json b/method_comparison/text_generation_benchmark/default_benchmark_params.json
new file mode 100644
index 0000000..c7d9a14
--- /dev/null
+++ b/method_comparison/text_generation_benchmark/default_benchmark_params.json
@@ -0,0 +1,12 @@
+{
+    "model_id": "meta-llama/Llama-3.2-3B",
+    "dtype": "float16",
+    "seed": 42,
+    "num_inference_runs": 10,
+    "max_new_tokens": 20,
+    "category_generation_params": {
+        "short": {"max_new_tokens": 20},
+        "medium": {"max_new_tokens": 50},
+        "long": {"max_new_tokens": 100}
+    }
+}
diff --git a/method_comparison/text_generation_benchmark/experiments/lora/lora_r8/adapter_config.json b/method_comparison/text_generation_benchmark/experiments/lora/lora_r8/adapter_config.json
new file mode 100644
index 0000000..f3fd261
--- /dev/null
+++ b/method_comparison/text_generation_benchmark/experiments/lora/lora_r8/adapter_config.json
@@ -0,0 +1,17 @@
+{
+    "base_model_name_or_path": null,
+    "bias": "none",
+    "fan_in_fan_out": false,
+    "inference_mode": false,
+    "init_lora_weights": true,
+    "lora_alpha": 16,
+    "lora_dropout": 0.1,
+    "modules_to_save": null,
+    "peft_type": "LORA",
+    "r": 8,
+    "target_modules": [
+        "q_proj",
+        "v_proj"
+    ],
+    "task_type": "CAUSAL_LM"
+}
diff --git a/method_comparison/text_generation_benchmark/results/.gitkeep b/method_comparison/text_generation_benchmark/results/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/method_comparison/text_generation_benchmark/run.py b/method_comparison/text_generation_benchmark/run.py
new file mode 100644
index 0000000..bd8c0a7
--- /dev/null
+++ b/method_comparison/text_generation_benchmark/run.py
@@ -0,0 +1,358 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+"""
+Main entry point to run the experiments. Contains general setup and the proper inference code.
+"""
+
+import argparse
+import gc
+import json
+import os
+import sys
+import time
+from typing import Optional
+
+import bitsandbytes
+import torch
+import transformers
+from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, set_seed
+from utils import (
+    BenchmarkConfig,
+    BenchmarkResult,
+    BenchmarkStatus,
+    get_memory_usage,
+    init_accelerator,
+    log_results,
+    validate_experiment_path,
+)
+
+import peft
+from data import prepare_benchmark_prompts
+from peft import PeftConfig, get_peft_model
+
+
+def load_base_results(model_id: str) -> Optional[dict]:
+    """Load base model results if they exist."""
+    base_results_dir = os.path.join(os.path.dirname(__file__), "base_results")
+    model_name = model_id.replace("/", "_").replace("-", "_")
+    filename = f"base_{model_name}.json"
+    filepath = os.path.join(base_results_dir, filename)
+
+    if os.path.exists(filepath):
+        with open(filepath) as f:
+            return json.load(f)
+    return None
+
+
+def measure_inference_time(model, tokenizer, prompts, max_new_tokens, num_runs, print_fn, category_generation_params):
+    """Measure inference time for each prompt category."""
+    inference_times = {}
+    time_per_token = {}
+    generated_tokens = {}
+    individual_samples = {}
+
+    for category, category_prompts in prompts.items():
+        print_fn(f"\nMeasuring inference time for {category} prompts...")
+        category_times = []
+        category_tokens = []
+        category_time_per_token = []
+        category_samples = []
+
+        for prompt in category_prompts:
+            prompt_times = []
+            prompt_tokens = []
+            prompt_time_per_token = []
+
+            inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+
+            cat_max_new_tokens = category_generation_params.get(category, {}).get("max_new_tokens", max_new_tokens)
+
+            for _ in range(num_runs):
+                start_time = time.perf_counter()
+                outputs = model.generate(
+                    **inputs,
+                    max_new_tokens=cat_max_new_tokens,
+                    min_new_tokens=cat_max_new_tokens,
+                    pad_token_id=tokenizer.pad_token_id,
+                )
+                end_time = time.perf_counter()
+
+                # Calculate metrics
+                inference_time = end_time - start_time
+                num_tokens = len(outputs[0]) - len(inputs["input_ids"][0])
+                time_per_token_val = inference_time / num_tokens if num_tokens > 0 else 0
+
+                prompt_times.append(inference_time)
+                prompt_tokens.append(num_tokens)
+                prompt_time_per_token.append(time_per_token_val)
+
+            # Calculate averages for this prompt
+            avg_time = sum(prompt_times) / len(prompt_times)
+            avg_tokens = sum(prompt_tokens) / len(prompt_tokens)
+            avg_time_per_token = sum(prompt_time_per_token) / len(prompt_time_per_token)
+
+            sample_result = {
+                "inference_time": avg_time,
+                "generated_tokens": avg_tokens,
+                "time_per_token": avg_time_per_token,
+                "individual_runs": [
+                    {"inference_time": t, "generated_tokens": tok, "time_per_token": tpt}
+                    for t, tok, tpt in zip(prompt_times, prompt_tokens, prompt_time_per_token)
+                ],
+            }
+            category_samples.append(sample_result)
+
+            category_times.append(avg_time)
+            category_tokens.append(avg_tokens)
+            category_time_per_token.append(avg_time_per_token)
+
+        if category_times:
+            avg_category_time = sum(category_times) / len(category_times)
+            avg_category_tokens = sum(category_tokens) / len(category_tokens)
+            avg_category_time_per_token = sum(category_time_per_token) / len(category_time_per_token)
+
+            inference_times[category] = avg_category_time
+            generated_tokens[category] = avg_category_tokens
+            time_per_token[category] = avg_category_time_per_token
+            individual_samples[category] = category_samples
+
+    return {
+        "inference_times": inference_times,
+        "time_per_token": time_per_token,
+        "generated_tokens": generated_tokens,
+        "individual_samples": individual_samples,
+    }
+
+
+def run_benchmark(
+    benchmark_config: BenchmarkConfig, experiment_name: str, experiment_path: str, print_fn=print
+) -> BenchmarkResult:
+    """Run benchmarks for the specified PEFT method configuration."""
+    result = BenchmarkResult(
+        experiment_name=experiment_name,
+        status=BenchmarkStatus.RUNNING,
+        model_id=benchmark_config.model_id,
+    )
+
+    result.save()
+
+    start_time = time.perf_counter()
+    e_main_benchmark: Optional[Exception] = None
+
+    try:
+        print_fn("Initializing accelerator...")
+        accelerator_allocated_init, accelerator_reserved_init = init_accelerator()
+        set_seed(benchmark_config.seed)
+
+        print_fn(f"Loading base model: {benchmark_config.model_id}")
+        tokenizer = AutoTokenizer.from_pretrained(benchmark_config.model_id)
+        if tokenizer.pad_token is None:
+            tokenizer.pad_token = tokenizer.eos_token
+
+        model_kwargs = {
+            "device_map": "auto" if (torch.cuda.is_available() or torch.xpu.is_available()) else None,
+        }
+
+        if benchmark_config.dtype == "float32":
+            model_kwargs["torch_dtype"] = torch.float32
+        elif benchmark_config.dtype == "float16":
+            model_kwargs["torch_dtype"] = torch.float16
+        elif benchmark_config.dtype == "bfloat16":
+            model_kwargs["torch_dtype"] = torch.bfloat16
+        else:
+            raise ValueError(f"Unsupported dtype: {benchmark_config.dtype}")
+
+        if benchmark_config.use_8bit:
+            model_kwargs["quantization_config"] = BitsAndBytesConfig(
+                load_in_8bit=True, llm_int8_enable_fp32_cpu_offload=True
+            )
+        elif benchmark_config.use_4bit:
+            model_kwargs["quantization_config"] = BitsAndBytesConfig(
+                load_in_4bit=True,
+                bnb_4bit_compute_dtype=model_kwargs.get("torch_dtype", torch.float16),
+                bnb_4bit_use_double_quant=True,
+                bnb_4bit_quant_type="nf4",
+            )
+
+        base_model = AutoModelForCausalLM.from_pretrained(benchmark_config.model_id, **model_kwargs)
+
+        base_results = load_base_results(benchmark_config.model_id)
+
+        print_fn("Preparing benchmark prompts...")
+        prompts = prepare_benchmark_prompts(
+            config=benchmark_config,
+            tokenizer=tokenizer,
+            max_input_length=None,
+            seed=benchmark_config.seed,
+        )
+
+        if base_results:
+            print_fn("Using cached base model results...")
+            base_inference_times = base_results["inference_results"]
+        else:
+            raise FileNotFoundError(
+                "No cached base results found. Please run `python run_base.py` first to generate base model results."
+            )
+
+        try:
+            print_fn(f"Loading PEFT config from {experiment_path}")
+            peft_config = PeftConfig.from_pretrained(experiment_path)
+            print_fn(f"Loaded PEFT config: {peft_config.peft_type}, with parameters: {vars(peft_config)}")
+            model = get_peft_model(base_model, peft_config)
+        except Exception as exc:
+            error_msg = f"Error loading PEFT config: {exc!s}"
+            print_fn(error_msg)
+
+        del base_model
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        elif torch.xpu.is_available():
+            torch.xpu.empty_cache()
+
+        ram, accelerator_allocated, accelerator_reserved = get_memory_usage()
+        result.add_memory_log("peft_model_loaded", ram, accelerator_allocated, accelerator_reserved)
+
+        # Calculate PEFT model metrics
+        trainable_params = model.get_nb_trainable_parameters()[0]
+        total_params = sum(p.numel() for p in model.parameters())
+        base_params = sum(p.numel() for p in model.base_model.parameters())
+        dtype_bytes = 2 if benchmark_config.dtype in ["float16", "bfloat16"] else 4
+        adapter_size_mb = trainable_params * dtype_bytes / (1024 * 1024)
+        base_model_size_mb = base_params * dtype_bytes / (1024 * 1024)
+        param_ratio = trainable_params / total_params if total_params > 0 else 0
+
+        result.update_meta_info(
+            param_counts={
+                "base_params": base_params,
+                "trainable_params": trainable_params,
+                "total_params": total_params,
+                "param_ratio": param_ratio,
+            },
+            size_info={"base_model_size_mb": base_model_size_mb, "adapter_size_mb": adapter_size_mb},
+            package_info={
+                "transformers-version": transformers.__version__,
+                "peft-version": peft.__version__,
+                "bitsandbytes-version": bitsandbytes.__version__ if hasattr(bitsandbytes, "__version__") else None,
+            },
+        )
+
+        print_fn("Measuring PEFT model inference times...")
+        peft_inference_times = measure_inference_time(
+            model,
+            tokenizer,
+            prompts,
+            max_new_tokens=benchmark_config.max_new_tokens,
+            num_runs=benchmark_config.num_inference_runs,
+            print_fn=print_fn,
+            category_generation_params=benchmark_config.category_generation_params,
+        )
+
+        # Calculate inference overhead for each category
+        inference_overhead = {
+            k: (peft_inference_times["inference_times"][k] - base_inference_times["inference_times"][k])
+            / base_inference_times["inference_times"][k]
+            * 100
+            for k in base_inference_times["inference_times"]
+        }
+
+        for category in prompts:
+            category_metrics = {
+                "inference_time": peft_inference_times["inference_times"][category],
+                "base_inference_time": base_inference_times["inference_times"][category],
+                "inference_overhead_pct": inference_overhead[category],
+                "time_per_token": peft_inference_times["time_per_token"][category],
+                "generated_tokens": peft_inference_times["generated_tokens"][category],
+            }
+            result.add_metrics_for_category(
+                category, category_metrics, individual_samples=peft_inference_times["individual_samples"][category]
+            )
+
+        result.update_generation_info(
+            memory_data={
+                "peak_accelerator_memory_mb": max(
+                    (log["accelerator_allocated_mb"] for log in result.generation_info["memory"]["memory_logs"]), default=0
+                ),
+                "peak_ram_memory_mb": max(
+                    (log["ram_mb"] for log in result.generation_info["memory"]["memory_logs"]), default=0
+                ),
+            }
+        )
+
+        ram, accelerator_allocated, accelerator_reserved = get_memory_usage()
+        result.add_memory_log("benchmark_complete", ram, accelerator_allocated, accelerator_reserved)
+
+        result.status = BenchmarkStatus.SUCCESS
+
+    except Exception as exc:
+        print_fn(f"Benchmark failed with error: {exc}")
+        result.status = BenchmarkStatus.FAILED
+        e_main_benchmark = exc
+    end_time = time.perf_counter()
+    error_message = str(e_main_benchmark) if e_main_benchmark is not None else None
+
+    peft_config_dict = peft_config.to_dict() if "peft_config" in locals() else None
+    if peft_config_dict:
+        for key, value in peft_config_dict.items():
+            if isinstance(value, set):
+                peft_config_dict[key] = list(value)
+
+    result.update_run_info(
+        duration=end_time - start_time,
+        status=result.status,
+        error=error_message,
+        peft_config=peft_config_dict,
+        benchmark_config=benchmark_config.to_dict(),
+    )
+
+    return result
+
+
+def main() -> None:
+    """Main entry point for the benchmark runner."""
+    parser = argparse.ArgumentParser(description="Run PEFT method benchmarks")
+    parser.add_argument("experiment_path", help="Path to experiment directory")
+    parser.add_argument("--verbose", "-v", action="store_true", help="Enable verbose output")
+    args = parser.parse_args()
+
+    print_fn = print if args.verbose else lambda *args, **kwargs: None
+
+    experiment_path = args.experiment_path
+    allowed_root = os.path.abspath(os.path.join(os.path.dirname(__file__)))
+    abs_experiment_path = os.path.abspath(experiment_path)
+    if not abs_experiment_path.startswith(allowed_root):
+        print(f"Experiment path must be inside {allowed_root}, got: {abs_experiment_path}. Skipping execution.")
+        return 0
+    if not os.path.exists(abs_experiment_path):
+        print(f"Experiment path not found: {abs_experiment_path}. Skipping execution.")
+        return 0
+    experiment_path = abs_experiment_path
+
+    experiment_name, benchmark_config = validate_experiment_path(experiment_path)
+
+    print_fn(f"Running benchmark for experiment: {experiment_name}")
+
+    result = run_benchmark(
+        benchmark_config=benchmark_config,
+        experiment_name=experiment_name,
+        experiment_path=experiment_path,
+        print_fn=print_fn,
+    )
+
+    log_results(experiment_name, result, print_fn=print)
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/method_comparison/text_generation_benchmark/run_base.py b/method_comparison/text_generation_benchmark/run_base.py
new file mode 100644
index 0000000..c98e083
--- /dev/null
+++ b/method_comparison/text_generation_benchmark/run_base.py
@@ -0,0 +1,186 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+import argparse
+import json
+import os
+import sys
+import time
+
+import torch
+from run import measure_inference_time
+from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, set_seed
+from utils import (
+    BenchmarkConfig,
+    get_memory_usage,
+    init_accelerator,
+)
+
+from data import prepare_benchmark_prompts
+
+
+def run_base_model_benchmark(benchmark_config: BenchmarkConfig, print_fn=print) -> dict:
+    """Run benchmark for base model only and return results."""
+
+    print_fn(f"Running base model benchmark for: {benchmark_config.model_id}")
+
+    print_fn("Initializing accelerator...")
+    init_accelerator()
+
+    set_seed(benchmark_config.seed)
+
+    print_fn(f"Loading base model: {benchmark_config.model_id}")
+    tokenizer = AutoTokenizer.from_pretrained(benchmark_config.model_id)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    model_kwargs = {
+        "device_map": "auto" if (torch.cuda.is_available() or torch.xpu.is_available()) else None,
+    }
+
+    if benchmark_config.dtype == "float32":
+        model_kwargs["torch_dtype"] = torch.float32
+    elif benchmark_config.dtype == "float16":
+        model_kwargs["torch_dtype"] = torch.float16
+    elif benchmark_config.dtype == "bfloat16":
+        model_kwargs["torch_dtype"] = torch.bfloat16
+
+    if benchmark_config.use_8bit:
+        model_kwargs["quantization_config"] = BitsAndBytesConfig(
+            load_in_8bit=True, llm_int8_enable_fp32_cpu_offload=True
+        )
+    elif benchmark_config.use_4bit:
+        model_kwargs["quantization_config"] = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_compute_dtype=model_kwargs.get("torch_dtype", torch.float16),
+            bnb_4bit_use_double_quant=True,
+            bnb_4bit_quant_type="nf4",
+        )
+
+    model = AutoModelForCausalLM.from_pretrained(benchmark_config.model_id, **model_kwargs)
+
+    ram, accelerator_allocated, accelerator_reserved = get_memory_usage()
+    print_fn(f"Memory after model load - RAM: {ram:.2f}MB, {model.device.type.upper()}: {accelerator_allocated:.2f}MB")
+
+    print_fn("Preparing benchmark prompts...")
+    prompts = prepare_benchmark_prompts(
+        config=benchmark_config.to_dict(),
+        tokenizer=tokenizer,
+        max_input_length=None,
+        seed=benchmark_config.seed,
+    )
+
+    # Measure base model inference for each prompt category
+    print_fn("Measuring base model inference times...")
+    base_inference_results = measure_inference_time(
+        model,
+        tokenizer,
+        prompts,
+        max_new_tokens=benchmark_config.max_new_tokens,
+        num_runs=benchmark_config.num_inference_runs,
+        print_fn=print_fn,
+        category_generation_params=benchmark_config.category_generation_params,
+    )
+
+    result = {
+        "model_id": benchmark_config.model_id,
+        "benchmark_config": benchmark_config.to_dict(),
+        "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
+        "inference_results": base_inference_results,
+        "memory_info": {
+            "ram_mb": ram,
+            "accelerator_allocated_mb": accelerator_allocated,
+            "accelerator_reserved_mb": accelerator_reserved,
+        },
+    }
+
+    return result
+
+
+def save_base_results(result: dict, model_id: str) -> str:
+    """Save base model results with a filename based on model and config."""
+    base_results_dir = os.path.join(os.path.dirname(__file__), "base_results")
+    os.makedirs(base_results_dir, exist_ok=True)
+
+    model_name = model_id.replace("/", "_").replace("-", "_")
+    filename = f"base_{model_name}.json"
+    filepath = os.path.join(base_results_dir, filename)
+
+    with open(filepath, "w") as f:
+        json.dump(result, f, indent=2)
+
+    return filepath
+
+
+def main():
+    """Main entry point for the base model benchmark runner."""
+    parser = argparse.ArgumentParser(description="Run base model benchmarks")
+    parser.add_argument("--verbose", "-v", action="store_true", help="Enable verbose output")
+    parser.add_argument("--force", "-f", action="store_true", help="Force re-run even if results exist")
+    args = parser.parse_args()
+
+    print_fn = print if args.verbose else lambda *args, **kwargs: None
+
+    default_config_path = os.path.join(os.path.dirname(__file__), "default_benchmark_params.json")
+    benchmark_config = BenchmarkConfig.from_json(default_config_path)
+
+    model_name = benchmark_config.model_id.replace("/", "_").replace("-", "_")
+    base_results_dir = os.path.join(os.path.dirname(__file__), "base_results")
+    filename = f"base_{model_name}.json"
+    filepath = os.path.join(base_results_dir, filename)
+
+    if os.path.exists(filepath) and not args.force:
+        print(f"Base results already exist at: {filepath}")
+        print("Use --force to re-run the benchmark")
+        return 0
+
+    print_fn(f"Running base model benchmark for: {benchmark_config.model_id}")
+
+    result = run_base_model_benchmark(benchmark_config, print_fn=print_fn)
+
+    saved_path = save_base_results(result, benchmark_config.model_id)
+    device_type = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+    print(f"Base model results saved to: {saved_path}")
+
+    print("\nBase Model Benchmark Summary:")
+    print(f"Model: {result['model_id']}")
+    print(
+        f"Memory Usage - RAM: {result['memory_info']['ram_mb']:.2f}MB, {device_type.upper()}: {result['memory_info']['accelerator_allocated_mb']:.2f}MB"
+    )
+
+    print("\nInference Times by Category:")
+    for category, time_val in result["inference_results"]["inference_times"].items():
+        time_per_token = result["inference_results"]["time_per_token"][category]
+        tokens = result["inference_results"]["generated_tokens"][category]
+        print(f"  {category}: {time_val:.4f}s ({time_per_token:.6f}s/token, {tokens:.1f} tokens)")
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/method_comparison/text_generation_benchmark/temporary_results/.gitkeep b/method_comparison/text_generation_benchmark/temporary_results/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/method_comparison/text_generation_benchmark/utils.py b/method_comparison/text_generation_benchmark/utils.py
new file mode 100644
index 0000000..a84a33e
--- /dev/null
+++ b/method_comparison/text_generation_benchmark/utils.py
@@ -0,0 +1,458 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+"""
+Utilities for PEFT benchmarking.
+"""
+
+import datetime
+import json
+import os
+import platform
+import subprocess
+from collections.abc import Callable
+from dataclasses import asdict, dataclass, field
+from enum import Enum
+from typing import Any, Optional
+
+import psutil
+import torch
+
+from peft.utils import infer_device
+
+
+FILE_NAME_BENCHMARK_PARAMS = "benchmark_params.json"
+FILE_NAME_DEFAULT_CONFIG = "default_benchmark_params.json"
+
+RESULT_PATH = os.path.join(os.path.dirname(__file__), "results")
+RESULT_PATH_TEMP = os.path.join(os.path.dirname(__file__), "temporary_results")
+RESULT_PATH_CANCELLED = os.path.join(os.path.dirname(__file__), "cancelled_results")
+
+
+class BenchmarkStatus(Enum):
+    """Status of a benchmark run."""
+
+    SUCCESS = "success"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+    RUNNING = "running"
+
+
+@dataclass
+class BenchmarkResult:
+    """Container for benchmark results."""
+
+    experiment_name: str
+    status: BenchmarkStatus
+
+    model_id: str
+
+    run_info: dict = field(default_factory=dict)
+    generation_info: dict = field(default_factory=dict)
+    meta_info: dict = field(default_factory=dict)
+
+    def __post_init__(self):
+        """Initialize structured data format."""
+        device = infer_device()
+        torch_accelerator_module = getattr(torch, device, torch.cuda)
+        self.run_info = {
+            "timestamp": datetime.datetime.now(tz=datetime.timezone.utc).isoformat(),
+            "duration": 0.0,
+            "status": self.status.value,
+            "hardware": {
+                "num_accelerators": torch_accelerator_module.device_count() if torch_accelerator_module.is_available() else 0,
+                "accelerator_type": torch_accelerator_module.get_device_name(0) if torch_accelerator_module.is_available() else "N/A",
+                "cuda_version": torch.version.cuda if torch.cuda.is_available() else "N/A",
+                "pytorch_version": torch.__version__,
+            },
+        }
+
+        self.meta_info = {
+            "model_id": self.model_id,
+            "parameters": {
+                "base_params": 0,
+                "trainable_params": 0,
+                "total_params": 0,
+                "param_ratio": 0.0,
+            },
+            "model_size": {
+                "base_model_size_mb": 0.0,
+                "adapter_size_mb": 0.0,
+            },
+            "package_info": {
+                "transformers-version": None,
+                "transformers-commit-hash": None,
+                "peft-version": None,
+                "peft-commit-hash": None,
+                "datasets-version": None,
+                "datasets-commit-hash": None,
+                "bitsandbytes-version": None,
+                "bitsandbytes-commit-hash": None,
+                "torch-version": torch.__version__,
+                "torch-commit-hash": None,
+            },
+            "system_info": {
+                "system": platform.system(),
+                "release": platform.release(),
+                "version": platform.version(),
+                "machine": platform.machine(),
+                "processor": platform.processor(),
+                "accelerator": torch_accelerator_module.get_device_name(0) if torch_accelerator_module.is_available() else "N/A",
+            },
+        }
+
+        self.generation_info = {
+            "memory": {
+                "peak_accelerator_memory_mb": 0.0,
+                "peak_ram_memory_mb": 0.0,
+                "memory_logs": [],
+            },
+            "by_category": {},
+            "overall": {},
+        }
+
+    def update_meta_info(self, param_counts: dict, size_info: dict, package_info: Optional[dict] = None):
+        """Update model metadata information."""
+        self.meta_info["parameters"].update(param_counts)
+        self.meta_info["model_size"].update(size_info)
+        if package_info:
+            self.meta_info["package_info"].update(package_info)
+
+    def update_generation_info(self, memory_data: Optional[dict] = None, performance_metrics: Optional[dict] = None):
+        """Update generation performance information, primarily for memory and high-level performance."""
+        if memory_data:
+            self.generation_info["memory"].update(memory_data)
+        if performance_metrics:  # For things like overall tokens/sec if calculated
+            self.generation_info.update(performance_metrics)
+
+    def add_memory_log(self, stage: str, ram_mb: float, accelerator_allocated_mb: float, accelerator_reserved_mb: float):
+        """Add a memory usage log entry to generation_info."""
+        self.generation_info["memory"]["memory_logs"].append(
+            {
+                "stage": stage,
+                "ram_mb": ram_mb,
+                "accelerator_allocated_mb": accelerator_allocated_mb,
+                "accelerator_reserved_mb": accelerator_reserved_mb,
+            }
+        )
+
+    def add_metrics_for_category(self, category: str, metrics: dict, individual_samples: Optional[list] = None):
+        """Add metrics for a specific prompt category under generation_info."""
+        category_data = {"metrics": metrics, "samples": individual_samples if individual_samples is not None else []}
+        self.generation_info["by_category"][category] = category_data
+
+    def update_run_info(
+        self,
+        duration: float,
+        status: BenchmarkStatus,
+        error: Optional[str] = None,
+        peft_config: Optional[dict] = None,
+        benchmark_config: Optional[dict] = None,
+    ):
+        """Update run information."""
+        self.run_info["duration"] = duration
+        self.run_info["status"] = status.value
+        if error:
+            self.run_info["error"] = error
+        if peft_config:
+            self.run_info["peft_config"] = peft_config
+        if benchmark_config:
+            self.run_info["benchmark_config"] = benchmark_config
+
+    def compute_overall_metrics(self):
+        """Compute overall metrics across all categories within generation_info."""
+        if not self.generation_info["by_category"]:
+            return
+
+        categories = self.generation_info["by_category"]
+        key_metrics = [
+            "inference_time",
+            "base_inference_time",
+            "inference_overhead_pct",
+            "time_per_token",
+            "generated_tokens",
+        ]
+
+        for metric in key_metrics:
+            values = []
+            for category_data in categories.values():
+                if "metrics" in category_data and metric in category_data["metrics"]:
+                    values.append(category_data["metrics"][metric])
+
+            if values:
+                self.generation_info["overall"][metric] = sum(values) / len(values)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert result to dictionary."""
+        self.compute_overall_metrics()
+        return {
+            "run_info": self.run_info,
+            "generation_info": self.generation_info,
+            "meta_info": self.meta_info,
+        }
+
+    def save(self, path: Optional[str] = None):
+        """Save result to JSON file."""
+        if path is None:
+            peft_branch = get_peft_branch()
+        if self.status == BenchmarkStatus.CANCELLED:
+            base_path = RESULT_PATH_CANCELLED
+        elif peft_branch != "main":
+            base_path = RESULT_PATH_TEMP
+        elif self.status == BenchmarkStatus.SUCCESS:
+            base_path = RESULT_PATH
+        elif self.status == BenchmarkStatus.FAILED:
+            base_path = RESULT_PATH_CANCELLED
+        else:
+            base_path = RESULT_PATH_TEMP
+
+        filename = f"{self.experiment_name}.json"
+        path = os.path.join(base_path, filename)
+
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+
+        with open(path, "w") as f:
+            json.dump(self.to_dict(), f, indent=2)
+
+        return path
+
+
+@dataclass
+class BenchmarkConfig:
+    """Configuration for benchmarking PEFT methods."""
+
+    model_id: str
+
+    seed: int
+    num_inference_runs: int
+    max_new_tokens: int
+
+    dtype: str = "float16"
+    use_4bit: bool = False
+    use_8bit: bool = False
+
+    category_generation_params: Optional[dict] = None
+
+    def __post_init__(self) -> None:
+        """Validate configuration."""
+        if not isinstance(self.model_id, str):
+            raise TypeError(f"Invalid model_id: {self.model_id}")
+
+        if self.seed < 0:
+            raise ValueError(f"Invalid seed: {self.seed}")
+
+        if self.num_inference_runs <= 0:
+            raise ValueError(f"Invalid num_inference_runs: {self.num_inference_runs}")
+
+        if self.max_new_tokens <= 0:
+            raise ValueError(f"Invalid max_new_tokens: {self.max_new_tokens}")
+
+    @classmethod
+    def from_dict(cls, config_dict: dict) -> "BenchmarkConfig":
+        """Create config from dictionary."""
+        valid_keys = set(cls.__dataclass_fields__.keys())
+        filtered_dict = {k: v for k, v in config_dict.items() if k in valid_keys}
+
+        return cls(**filtered_dict)
+
+    @classmethod
+    def from_json(cls, json_path: str) -> "BenchmarkConfig":
+        """Load config from JSON file."""
+        with open(json_path) as f:
+            config_dict = json.load(f)
+        return cls.from_dict(config_dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert config to dictionary."""
+        result = asdict(self)
+        return result
+
+    def save(self, path: str) -> None:
+        """Save config to JSON file."""
+        with open(path, "w") as f:
+            json.dump(self.to_dict(), f, indent=2)
+
+    def merge_from_dict(self, config_dict: dict) -> None:
+        """Merge settings from a dictionary into this config object.
+        Keys in config_dict will override existing attributes.
+        """
+        for key, value in config_dict.items():
+            if hasattr(self, key):
+                setattr(self, key, value)
+
+
+def validate_experiment_path(path: str) -> tuple[str, "BenchmarkConfig"]:
+    """Validate experiment path, load and merge configs, and return them."""
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"Experiment path not found: {path}")
+
+    path_parts = os.path.normpath(path).split(os.sep)
+
+    try:
+        experiments_idx = path_parts.index("experiments")
+    except ValueError:
+        experiment_name = os.path.basename(path.rstrip(os.sep))
+    else:
+        if experiments_idx + 1 < len(path_parts):
+            method_name = path_parts[experiments_idx + 1]
+            remaining_parts = path_parts[experiments_idx + 2 :]
+            if remaining_parts:
+                remaining_name = "-".join(remaining_parts)
+                experiment_name = f"{method_name}--{remaining_name}"
+            else:
+                experiment_name = method_name
+        else:
+            experiment_name = os.path.basename(path.rstrip(os.sep))
+
+    default_config_path = os.path.join(os.path.dirname(__file__), FILE_NAME_DEFAULT_CONFIG)
+    experiment_benchmark_params_path = os.path.join(path, FILE_NAME_BENCHMARK_PARAMS)
+
+    if not os.path.exists(default_config_path):
+        raise FileNotFoundError(f"Default configuration file not found: {default_config_path}. This is required.")
+    benchmark_config = BenchmarkConfig.from_json(default_config_path)
+    print(f"Loaded default configuration from {default_config_path}")
+
+    if os.path.exists(experiment_benchmark_params_path):
+        with open(experiment_benchmark_params_path) as f:
+            experiment_specific_params = json.load(f)
+
+        benchmark_config.merge_from_dict(experiment_specific_params)
+        print(f"Loaded and merged experiment-specific parameters from {experiment_benchmark_params_path}")
+    else:
+        print(f"No {FILE_NAME_BENCHMARK_PARAMS} found in {path}. Using only default configuration.")
+
+    return experiment_name, benchmark_config
+
+
+def get_memory_usage() -> tuple[float, float, float]:
+    """Get current memory usage (RAM and accelerator)."""
+    process = psutil.Process(os.getpid())
+    ram_usage_bytes = process.memory_info().rss
+    ram_usage_mb = ram_usage_bytes / (1024 * 1024)
+
+    if torch.cuda.is_available():
+        accelerator_allocated = torch.cuda.memory_allocated()
+        accelerator_reserved = torch.cuda.memory_reserved()
+        accelerator_allocated_mb = accelerator_allocated / (1024 * 1024)
+        accelerator_reserved_mb = accelerator_reserved / (1024 * 1024)
+    elif torch.xpu.is_available():
+        accelerator_allocated = torch.xpu.memory_allocated()
+        accelerator_reserved = torch.xpu.memory_reserved()
+        accelerator_allocated_mb = accelerator_allocated / (1024 * 1024)
+        accelerator_reserved_mb = accelerator_reserved / (1024 * 1024)
+    else:
+        accelerator_allocated_mb = 0.0
+        accelerator_reserved_mb = 0.0
+
+    return ram_usage_mb, accelerator_allocated_mb, accelerator_reserved_mb
+
+
+def init_accelerator() -> tuple[float, float]:
+    """Initialize accelerator and return initial memory usage."""
+    if torch.cuda.is_available():
+        torch.cuda.init()
+        torch.cuda.empty_cache()
+        _, accelerator_allocated, accelerator_reserved = get_memory_usage()
+    elif torch.xpu.is_available():
+        torch.xpu.init()
+        torch.xpu.empty_cache()
+        _, accelerator_allocated, accelerator_reserved = get_memory_usage()
+    else:
+        accelerator_allocated = 0.0
+        accelerator_reserved = 0.0
+    return accelerator_allocated, accelerator_reserved
+
+
+def get_model_size_mb(model: torch.nn.Module, dtype_bytes: int = 4) -> float:
+    """Calculate model size in MB."""
+    return sum(p.numel() * dtype_bytes for p in model.parameters()) / (1024 * 1024)
+
+
+def get_peft_branch() -> str:
+    repo_root = os.path.dirname(__file__)
+    return subprocess.check_output(["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd=repo_root).decode().strip()
+
+
+def log_results(
+    experiment_name: str,
+    benchmark_result: BenchmarkResult,
+    print_fn: Callable = print,
+) -> None:
+    """Log benchmark results to console."""
+    print_fn("\n" + "=" * 50)
+    print_fn(f"Benchmark Results: {experiment_name}")
+    print_fn("=" * 50)
+
+    print_fn(f"Status: {benchmark_result.run_info.get('status', 'N/A')}")
+    print_fn(f"Duration: {benchmark_result.run_info.get('duration', 0):.2f} seconds")
+
+    if benchmark_result.run_info.get("status") != BenchmarkStatus.SUCCESS.value:
+        print_fn(f"Error: {benchmark_result.run_info.get('error', 'Unknown error')}")
+        print_fn("=" * 50)
+        return
+
+    print_fn("\nModel Information:")
+    print_fn(f"  Base Model: {benchmark_result.meta_info.get('model_id', 'N/A')}")
+
+    print_fn("\nParameter Counts:")
+    params = benchmark_result.meta_info.get("parameters", {})
+    print_fn(f"  Base Parameters: {params.get('base_params', 0):,}")
+    print_fn(f"  Trainable Parameters: {params.get('trainable_params', 0):,}")
+    print_fn(f"  Parameter Ratio: {params.get('param_ratio', 0):.5%}")
+
+    print_fn("\nModel Size:")
+    size_info = benchmark_result.meta_info.get("model_size", {})
+    print_fn(f"  Base Model: {size_info.get('base_model_size_mb', 0):.2f} MB")
+    print_fn(f"  Adapter: {size_info.get('adapter_size_mb', 0):.2f} MB")
+
+    print_fn("\nMemory Usage (from generation_info):")
+    memory_data = benchmark_result.generation_info.get("memory", {})
+    print_fn(f"  Peak Accelerator Memory: {memory_data.get('peak_accelerator_memory_mb', 0):.2f} MB")
+    print_fn(f"  Peak RAM Memory: {memory_data.get('peak_ram_memory_mb', 0):.2f} MB")
+
+    print_fn("\nDetailed Metrics (from generation_info.by_category):")
+    if benchmark_result.generation_info.get("by_category"):
+        for category, cat_data in benchmark_result.generation_info["by_category"].items():
+            print_fn(f"  Category: {category}")
+            metrics = cat_data.get("metrics", {})
+            print_fn(f"    Inference Time: {metrics.get('inference_time', 0):.4f} seconds")
+            print_fn(f"    Base Inference Time: {metrics.get('base_inference_time', 0):.4f} seconds")
+            print_fn(f"    Inference Overhead: {metrics.get('inference_overhead_pct', 0):.2f}%")
+            print_fn(f"    Time Per Token: {metrics.get('time_per_token', 0):.6f} seconds/token")
+            print_fn(f"    Generated Tokens: {metrics.get('generated_tokens', 0):.1f}")
+
+            samples = cat_data.get("samples", [])
+            if samples:
+                print_fn(f"    Number of Samples: {len(samples)}")
+                print_fn(
+                    f"    Average Generated Tokens: {sum(s.get('generated_tokens', 0) for s in samples) / len(samples):.1f}"
+                )
+    else:
+        print_fn("  No per-category metrics available.")
+
+    benchmark_result.compute_overall_metrics()
+
+    print_fn("\nOverall Metrics (from generation_info.overall):")
+    overall = benchmark_result.generation_info.get("overall")
+    if overall:
+        print_fn(f"    Inference Time: {overall.get('inference_time', 0):.4f} seconds")
+        print_fn(f"    Base Inference Time: {overall.get('base_inference_time', 0):.4f} seconds")
+        print_fn(f"    Inference Overhead: {overall.get('inference_overhead_pct', 0):.2f}%")
+        print_fn(f"    Time Per Token: {overall.get('time_per_token', 0):.6f} seconds/token")
+        print_fn(f"    Generated Tokens: {overall.get('generated_tokens', 0):.1f}")
+    else:
+        print_fn("  No overall metrics computed.")
+
+    print_fn("\nSaved results to:", benchmark_result.save())
+    print_fn("=" * 50)
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..f321359
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,68 @@
+[tool.black]
+# Only used by `hf-doc-builder´.
+line-length = 119
+target-version = ['py310']
+
+[tool.ruff]
+target-version = "py310"
+line-length = 119
+extend-exclude = ["*.ipynb"]
+required-version = "~=0.15.12"
+
+[tool.ruff.lint]
+preview = true
+explicit-preview-rules = true
+extend-select = [
+    "C", # Complexity
+    "E", # PEP8 errors
+    "F", # PEP8 formatting
+    "I", # Import sorting
+    "UP", # Pyupgrade upgrades
+    "W", # PEP8 warnings
+    "PT009", # Pytest assertions
+    "RUF022", # Sorting of __all__
+    "RUF068", # Duplicates in __all__
+]
+ignore = [
+    "C901", # Function too complex
+    "E501", # Line length (handled by ruff-format)
+    "F841", # unused variable
+    "UP007", # X | Y style Unions
+    "C420", # dict.fromkeys
+    "UP045", # don't force replacing Optional[X] with X | None
+    "SIM118", # `for key in dct.keys()` is allowed
+    "PLC0206", # allow iterating over dict keys and pulling values later, can be more consistent
+    "RUF012", # allow mutable default values, contrary to popular belief, not always evil
+    "B018", # a "useless expression" is not useless when it tests for an AttributeError
+    "SIM117", # allow nesting of `with` statements: can be *more* readable of they are long
+    "BLE001", # allow catching bare `Exception`
+    "SIM102", # collapse multiple `if` statements: nice to have but requires too many changes
+    "PYI041", # considers type annotations like int|float as redundant and wants float only, but type can carry semantic meaning (e.g. total number vs fraction)
+]
+
+[tool.ruff.lint.isort]
+lines-after-imports = 2
+known-first-party = ["peft"]
+
+[tool.pytest]
+doctest_optionflags = [
+    "NORMALIZE_WHITESPACE",
+    "ELLIPSIS",
+    "NUMBER",
+]
+
+addopts = ["--cov=src/peft", "--cov-report=term-missing", "--durations=10"]
+
+markers = [
+    "single_gpu_tests: tests that run on a single GPU",
+    "multi_gpu_tests: tests that run on multiple GPUs",
+    "regression: whether to run regression suite test",
+    "bitsandbytes: select bitsandbytes integration tests",
+]
+
+filterwarnings = [
+    "error::DeprecationWarning:transformers",
+    # in sync with tests/conftest.py regarding BPE deprecation
+    "ignore:.*BPE.__init__ will not create from files anymore.*:DeprecationWarning:transformers",
+    "error::FutureWarning:transformers",
+]
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..dca857d
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,15 @@
+accelerate
+torch
+safetensors
+bitsandbytes
+scipy
+peft
+transformers
+tqdm
+packaging
+pytest
+numpy
+pyyaml
+datasets
+psutil
+setuptools
\ No newline at end of file
diff --git a/scripts/ci_clean_cache.py b/scripts/ci_clean_cache.py
new file mode 100644
index 0000000..ccedc68
--- /dev/null
+++ b/scripts/ci_clean_cache.py
@@ -0,0 +1,68 @@
+"""
+Utility to clean cache files that exceed a specific time in days according to their
+last access time recorded in the cache.
+
+Exit code:
+- 1 if no candidates are found
+- 0 if candidates are found
+
+Deletion can be enabled by passing `-d` parameter, otherwise it will only list the candidates.
+"""
+
+import sys
+from datetime import datetime as dt
+from datetime import timezone
+
+from huggingface_hub import scan_cache_dir
+
+
+def find_old_revisions(scan_results, max_age_days=30):
+    """Find commit hashes of objects in the cache. These objects need a last access time that
+    is above the passed `max_age_days` parameter. Returns an empty list if no objects are found.
+    Time measurement is based of the current time and the recorded last access tiem in the cache.
+    """
+    now = dt.now(timezone.utc)
+    revisions = [(i.revisions, i.last_accessed) for i in scan_results.repos]
+    revisions_ages = [(rev, (now - dt.fromtimestamp(ts_access, timezone.utc)).days) for rev, ts_access in revisions]
+    delete_candidates = [rev for rev, age in revisions_ages if age > max_age_days]
+    hashes = [n.commit_hash for rev in delete_candidates for n in rev]
+
+    return hashes
+
+
+def delete_old_revisions(scan_results, delete_candidates, do_delete=False):
+    delete_operation = scan_results.delete_revisions(*delete_candidates)
+    print(f"Would free {delete_operation.expected_freed_size_str}")
+    print(f"Candidates: {delete_candidates}")
+
+    if do_delete:
+        print("Deleting now.")
+        delete_operation.execute()
+    else:
+        print("Not deleting, pass the -d flag.")
+
+
+if __name__ == "__main__":
+    from argparse import ArgumentParser
+
+    parser = ArgumentParser()
+    parser.add_argument("-a", "--max-age", type=int, default=30, help="Max. age in days items in the cache may have.")
+    parser.add_argument(
+        "-d",
+        "--delete",
+        action="store_true",
+        help=(
+            "Delete mode; Really delete items if there are candidates. Exit code = 0 when we found something to delete, 1 "
+            "otherwise."
+        ),
+    )
+    args = parser.parse_args()
+
+    scan_results = scan_cache_dir()
+
+    delete_candidates = find_old_revisions(scan_results, args.max_age)
+    if not delete_candidates:
+        print("No delete candidates found, not deleting anything.")
+        sys.exit(1)
+
+    delete_old_revisions(scan_results, delete_candidates, do_delete=args.delete)
diff --git a/scripts/convert-bone-to-miss.py b/scripts/convert-bone-to-miss.py
new file mode 100644
index 0000000..4be799f
--- /dev/null
+++ b/scripts/convert-bone-to-miss.py
@@ -0,0 +1,69 @@
+# Copyright (c) 2025 Your Organization/Project. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Convert Bone checkpoint to MiSS format."""
+
+import argparse
+import json
+import os
+from pathlib import Path
+
+from safetensors import safe_open
+from safetensors.torch import save_file
+
+from peft.utils import CONFIG_NAME, SAFETENSORS_WEIGHTS_NAME
+
+
+def convert_bone_to_miss(bone_dir: Path, miss_dir: Path) -> None:
+    """Convert Bone checkpoint files to MiSS format."""
+    bone_config_path = bone_dir / CONFIG_NAME
+    miss_config_path = miss_dir / CONFIG_NAME
+    if not os.path.exists(miss_dir):
+        os.makedirs(miss_dir, exist_ok=True)
+    with open(bone_config_path, encoding="utf-8") as f:
+        config = json.load(f)
+
+    config["peft_type"] = "MISS"
+
+    with open(miss_config_path, "w", encoding="utf-8") as f:
+        json.dump(config, f, indent=2, ensure_ascii=False)
+
+    bone_weight_path = bone_dir / SAFETENSORS_WEIGHTS_NAME
+    miss_weight_path = miss_dir / SAFETENSORS_WEIGHTS_NAME
+
+    new_data = {}
+
+    with safe_open(bone_weight_path, framework="pt") as f:
+        for old_key in f.keys():
+            tensor = f.get_tensor(old_key)
+            new_key = old_key.replace(".bone_", ".miss_")
+            new_data[new_key] = tensor
+
+    save_file(new_data, miss_weight_path)
+
+    print(f"Converted checkpoint saved at {miss_weight_path}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Convert Bone checkpoint to MiSS format.")
+    parser.add_argument("bone_dir", type=Path, help="Directory containing Bone checkpoint files")
+    parser.add_argument("miss_dir", type=Path, help="Directory to save MiSS checkpoint files")
+    args = parser.parse_args()
+
+    args.miss_dir.mkdir(parents=True, exist_ok=True)
+    convert_bone_to_miss(args.bone_dir, args.miss_dir)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/evaluate-lora-conversion.py b/scripts/evaluate-lora-conversion.py
new file mode 100644
index 0000000..a94cedd
--- /dev/null
+++ b/scripts/evaluate-lora-conversion.py
@@ -0,0 +1,156 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+"""Script to evaluate a PEFT checkpoint converted into a LoRA on GSM8K
+
+To run this script, first train a PEFT model on MetaMathQA as described here:
+
+https://github.com/huggingface/peft/tree/main/method_comparison/MetaMathQA
+
+Call the script with the `-v` (verbose) option. When that run finishes, it will save a checkpoint of that model and
+print a message like this: "Saved PEFT checkpoint to ...". Use this path as the `--path` argument to this script.
+
+Example usage:
+
+```bash
+# Convert to LoRA with rank 8 and evaluate it
+python evaluate-lora-conversion.py --path /path/to/peft/checkpoint --rank 8
+# Convert to LoRA with dynamic rank (50% singular value threshold) and evaluate it
+python evaluate-lora-conversion.py --path /path/to/peft/checkpoint --rank 0.5
+# Evaluate the original PEFT model without LoRA conversion
+python evaluate-lora-conversion.py --path /path/to/peft/checkpoint
+```
+
+The script will report the evaluation accuracy, maximum CUDA memory reserved, and evaluation time for the converted LoRA
+model.
+
+"""
+
+import argparse
+import importlib.util
+import os
+import sys
+import time
+
+import torch
+from transformers import AutoModelForCausalLM
+
+from peft import PeftModel, convert_to_lora, get_peft_model, set_peft_model_state_dict
+
+
+root = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+
+spec = importlib.util.spec_from_file_location("data", os.path.join(root, "method_comparison", "MetaMathQA", "data.py"))
+mm_data = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(mm_data)
+sys.modules["data"] = mm_data
+
+spec = importlib.util.spec_from_file_location(
+    "utils", os.path.join(root, "method_comparison", "MetaMathQA", "utils.py")
+)
+mm_utils = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(mm_utils)
+sys.modules["utils"] = mm_utils
+
+spec = importlib.util.spec_from_file_location("run", os.path.join(root, "method_comparison", "MetaMathQA", "run.py"))
+mm_run = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(mm_run)
+
+
+def noop(*args, **kwargs):
+    pass
+
+
+def evaluate_model(model, tokenizer, ds_test):
+    torch.cuda.empty_cache()
+    torch.cuda.reset_peak_memory_stats()
+    tic = time.perf_counter()
+    predictions, responses = mm_run.evaluate(
+        model=model,
+        tokenizer=tokenizer,
+        ds=ds_test,
+        batch_size=50,
+        generate_kwargs={"max_length": 800, "max_new_tokens": 300, "pad_token_id": tokenizer.eos_token_id},
+        use_tqdm=True,
+    )
+    toc = time.perf_counter()
+    accuracy_peft = mm_utils.get_accuracy(predictions=predictions, responses=responses)
+    cuda_mem_reserved_max = torch.cuda.memory_reserved(0)
+    print(f"Evaluation Accuracy: {100 * accuracy_peft:.2f}%")
+    print(f"Max CUDA Memory Reserved: {cuda_mem_reserved_max / (1024**3):.2f} GB")
+    print(f"Evaluation Time: {toc - tic:.0f} seconds".format(toc - tic))
+
+
+def main(path_peft_model: str, rank: float | None) -> None:
+    model_id = "meta-llama/Llama-3.2-3B"
+    tokenizer = mm_utils.get_tokenizer(model_id=model_id, max_seq_length=768)
+    _, _, ds_test = mm_data.get_train_valid_test_datasets(
+        tokenizer=tokenizer, query_template="Question: {query} Think step by step.\nAnswer:", print_fn=noop
+    )
+
+    model = AutoModelForCausalLM.from_pretrained(model_id, dtype=torch.bfloat16).to(0)
+    model = PeftModel.from_pretrained(model, path_peft_model)
+    if rank is None:
+        print("Evaluating the original PEFT model without LoRA conversion...")
+        model.set_adapter("default")
+        model.print_trainable_parameters()
+        model.eval()
+        evaluate_model(model, tokenizer, ds_test)
+        return
+
+    print(f"Converting PEFT model to LoRA with rank={rank}...")
+    tic = time.perf_counter()
+    lora_config, lora_state_dict = convert_to_lora(model, rank=rank, progressbar=True)
+    toc = time.perf_counter()
+    print(f"Conversion completed in {toc - tic:.0f} seconds.".format(toc - tic))
+
+    del model
+    torch.cuda.empty_cache()
+    model = AutoModelForCausalLM.from_pretrained(model_id, dtype=torch.bfloat16).to(0)
+
+    model = get_peft_model(model, lora_config)
+    model.print_trainable_parameters()
+
+    load_result = set_peft_model_state_dict(model, lora_state_dict)
+    assert not load_result.unexpected_keys, (
+        f"Unexpected keys when loading LoRA state dict: {load_result.unexpected_keys}"
+    )
+
+    del lora_state_dict
+    model.eval()
+    evaluate_model(model, tokenizer, ds_test)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Evaluate a PEFT checkpoint converted into a LoRA on GSM8K")
+    parser.add_argument(
+        "--path",
+        type=str,
+        required=True,
+        help="Path to the input PEFT checkpoint",
+    )
+    parser.add_argument(
+        "--rank",
+        required=False,
+        default=None,
+        help="Rank for the LoRA decomposition (int, float, or None for no conversion)",
+    )
+
+    args = parser.parse_args()
+    if args.rank is not None:
+        if "." in str(args.rank):
+            args.rank = float(args.rank)
+        else:
+            args.rank = int(args.rank)
+    main(args.path, args.rank)
diff --git a/scripts/generate_method_capabilities.py b/scripts/generate_method_capabilities.py
new file mode 100644
index 0000000..bac7f1c
--- /dev/null
+++ b/scripts/generate_method_capabilities.py
@@ -0,0 +1,769 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+"""Generate a machine-readable capability matrix of all PEFT methods.
+
+For each registered PEFT method, a fixed set of checks ("tasks") determines which user-facing features the method
+supports, e.g. which quantization backends it integrates with, which layer types it can target, or whether its adapters
+can be merged into the base weights. The result is written as JSON and is intended as a generic data source, e.g. for
+documentation pages or the PEFT shop app (method_comparison/peft-shop).
+
+Each value is annotated with the *source* of the information:
+
+- "introspection": determined by statically inspecting the classes of the installed PEFT package
+- "file_check":    determined from the presence of integration modules in the PEFT source tree
+- "probe":         determined empirically by exercising the feature on a tiny model on CPU
+- "error":         the check itself failed; the value is "unknown" and the note contains the reason
+
+Values are never guessed: if a check cannot determine a feature, the value is reported as "unknown" together with a
+note. In particular, probing a method requires that its config can be instantiated with default arguments; methods that
+need more than that must have an entry in PROBE_CONFIG_OVERRIDES.
+
+The script requires PEFT to be installed (e.g. `pip install -e .`), runs on CPU, downloads nothing, and is idempotent:
+running it twice on the same environment produces identical output.
+
+Usage examples:
+
+    # check all methods, write JSON to method_capabilities.json
+    python scripts/generate_method_capabilities.py
+
+    # check only LoRA and IA3, write to a custom file
+    python scripts/generate_method_capabilities.py --methods lora ia3 --output capabilities.json
+
+    # show which checks would run, without running them
+    python scripts/generate_method_capabilities.py --dry-run
+
+Tasks are collected up-front before any of them runs (see `collect_tasks`). This makes `--dry-run` trivial and leaves
+the door open to run independent tasks in parallel later, should runtime ever become an issue.
+"""
+
+import argparse
+import dataclasses
+import enum
+import inspect
+import json
+import logging
+import re
+import sys
+import warnings
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from copy import deepcopy
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, ClassVar
+
+import torch
+from torch import nn
+from tqdm import tqdm
+from transformers import LlamaConfig, LlamaForCausalLM
+from transformers.pytorch_utils import Conv1D
+
+import peft
+from peft import get_peft_model
+from peft.config import PeftConfig, PromptLearningConfig
+from peft.mapping import PEFT_TYPE_TO_CONFIG_MAPPING, PEFT_TYPE_TO_MIXED_MODEL_MAPPING, PEFT_TYPE_TO_TUNER_MAPPING
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer
+from peft.utils.hotswap import CONFIG_KEYS_TO_CHECK
+from peft.utils.peft_types import PeftType
+
+
+logger = logging.getLogger("generate_method_capabilities")
+
+UNKNOWN = "unknown"
+NOT_APPLICABLE = "not_applicable"
+
+# Probe models use this hidden dimension throughout. It is chosen to be highly divisible, since several methods have
+# divisibility constraints between their block/rank settings and the layer dimensions (e.g. C3A, VBLoRA, RoAd).
+HIDDEN_DIM = 64
+
+# Quantization integration modules inside a tuner package, mapped to the backend names they provide. The bnb module
+# always contains both the 8-bit and the 4-bit integration.
+QUANT_FILE_BACKENDS: dict[str, tuple[str, ...]] = {
+    "aqlm": ("aqlm",),
+    "awq": ("awq",),
+    "bnb": ("bnb_8bit", "bnb_4bit"),
+    "eetq": ("eetq",),
+    "gptq": ("gptq",),
+    "hqq": ("hqq",),
+    "inc": ("inc",),
+    "torchao": ("torchao",),
+}
+
+# Backends covered by the generic quantization integration (peft.utils.quantization_utils). Methods that call
+# resolve_quantization_backend don't need per-backend integration modules; they support everything the resolver
+# handles (merging may still be unavailable for the forward-only backends, which is a property of the backend, not of
+# the PEFT method).
+GENERIC_QUANT_BACKENDS: tuple[str, ...] = (
+    "aqlm",
+    "awq",
+    "bnb_4bit",
+    "bnb_8bit",
+    "eetq",
+    "gptq",
+    "hqq",
+    "inc",
+    "torchao",
+)
+
+# Extra config arguments required to instantiate a method's config for probing, on top of the generic arguments
+# (target_modules for adapter methods, task_type/num_virtual_tokens for prompt learning). If probing a method reports
+# "unknown" because its config could not be instantiated, add an entry here.
+PROBE_CONFIG_OVERRIDES: dict[PeftType, dict[str, Any]] = {
+    # total_step is a required argument
+    PeftType.ADALORA: {"total_step": 10},
+    # IA3 needs feedforward_modules
+    PeftType.IA3: {"feedforward_modules": []},
+    # the default block_size of 256 does not divide HIDDEN_DIM
+    PeftType.C3A: {"block_size": 16},
+    # token_indices defaults to an empty list, which trains nothing
+    PeftType.TRAINABLE_TOKENS: {"token_indices": [0, 1]},
+    # the default vector_length of 256 does not divide HIDDEN_DIM
+    PeftType.VBLORA: {"num_vectors": 32, "vector_length": 16},
+    PeftType.ADAPTION_PROMPT: {"adapter_layers": 1, "adapter_len": 4, "task_type": "CAUSAL_LM"},
+}
+
+# Methods that cannot be probed on a self-contained tiny model. Probe-based checks report "unknown" for these.
+PROBE_SKIP: dict[PeftType, str] = {
+    PeftType.XLORA: "requires pre-trained LoRA adapter checkpoints to instantiate",
+}
+
+# Method-specific config switches that are worth surfacing as "extras". This is a curated list: reporting every config
+# field would drown the relevant information in noise. Note that target_parameters is not listed here, as it is
+# already covered by the target_layer_types check.
+NOTABLE_CONFIG_FIELDS: tuple[str, ...] = (
+    "alpha_pattern",
+    "layer_replication",
+    "rank_pattern",
+    "use_dora",
+    "use_rslora",
+)
+
+# Docs page slugs that differ from the lower-cased PEFT method name.
+DOCS_SLUG_OVERRIDES: dict[str, str] = {
+    "ADAPTION_PROMPT": "llama_adapter",
+    "CARTRIDGE": "cartridges",
+    "LN_TUNING": "layernorm_tuning",
+}
+
+# paper links as they appear in the docs intro paragraphs and in the config/model class docstrings
+PAPER_URL_RE = re.compile(
+    r"https://(?:huggingface\.co/papers/|arxiv\.org/(?:abs|pdf)/|openreview\.net/forum\?id=)[^\s)\"'>]+"
+)
+
+
+class Source(enum.StrEnum):
+    INTROSPECTION = "introspection"
+    FILE_CHECK = "file_check"
+    PROBE = "probe"
+    ERROR = "error"
+
+
+@dataclass(frozen=True)
+class Finding:
+    value: Any
+    source: Source
+    note: str | None = None
+
+    def to_json(self) -> dict[str, Any]:
+        result: dict[str, Any] = {"value": self.value, "source": str(self.source)}
+        if self.note:
+            result["note"] = self.note
+        return result
+
+
+@dataclass(frozen=True)
+class MethodInfo:
+    peft_type: PeftType
+    config_cls: type[PeftConfig]
+    model_cls: type | None
+    category: str  # "adapter", "prompt_learning", or "other"
+
+    @property
+    def name(self) -> str:
+        return self.peft_type.value
+
+    @classmethod
+    def from_peft_type(cls, peft_type: PeftType) -> "MethodInfo":
+        config_cls = PEFT_TYPE_TO_CONFIG_MAPPING[peft_type]
+        model_cls = PEFT_TYPE_TO_TUNER_MAPPING.get(peft_type)
+        if issubclass(config_cls, PromptLearningConfig):
+            category = "prompt_learning"
+        elif (model_cls is not None) and issubclass(model_cls, BaseTuner):
+            category = "adapter"
+        else:
+            # e.g. adaption prompt, whose model class manages adapters without subclassing BaseTuner
+            category = "other"
+        return cls(peft_type=peft_type, config_cls=config_cls, model_cls=model_cls, category=category)
+
+
+def _layer_classes(method: MethodInfo) -> list[type[BaseTunerLayer]]:
+    """Return the tuner layer classes defined in the method's main layer module.
+
+    Quantization-specific layer variants (bnb.py etc.) are deliberately not considered: importing them depends on the
+    installed quantization libraries, and the main layer module is what determines baseline support.
+    """
+    tuner_layer_cls = getattr(method.model_cls, "tuner_layer_cls", None)
+    if tuner_layer_cls is None:
+        return []
+    module = sys.modules[tuner_layer_cls.__module__]
+    return [
+        obj
+        for obj in vars(module).values()
+        if isinstance(obj, type) and issubclass(obj, BaseTunerLayer) and obj.__module__ == module.__name__
+    ]
+
+
+def _format_exception(exc: BaseException, limit: int = 250) -> str:
+    msg = f"{type(exc).__name__}: {exc}"
+    return msg if len(msg) <= limit else msg[: limit - 3] + "..."
+
+
+class ProbeError(Exception):
+    """Raised when a probe cannot be set up; results in an 'unknown' finding, never in a false positive/negative."""
+
+
+class SingleLayerModel(nn.Module):
+    """Minimal host model providing a single named module ("layer") for PEFT to target."""
+
+    def __init__(self, layer: nn.Module) -> None:
+        super().__init__()
+        self.layer = layer
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.layer(x)
+
+
+@dataclass(frozen=True)
+class LayerSpec:
+    label: str
+    build: Callable[[], nn.Module]
+
+
+# The layer types whose support is probed per method. Probing checks injection only (i.e. whether the layer gets
+# wrapped), no forward pass, since a successful wrap is the support signal and a broken forward would be a bug.
+LAYER_SPECS: tuple[LayerSpec, ...] = (
+    LayerSpec("Linear", lambda: nn.Linear(HIDDEN_DIM, HIDDEN_DIM)),
+    LayerSpec("Embedding", lambda: nn.Embedding(16, HIDDEN_DIM)),
+    LayerSpec("Conv1d", lambda: nn.Conv1d(HIDDEN_DIM, HIDDEN_DIM, 3)),
+    LayerSpec("Conv2d", lambda: nn.Conv2d(HIDDEN_DIM, HIDDEN_DIM, 3)),
+    LayerSpec("Conv3d", lambda: nn.Conv3d(HIDDEN_DIM, HIDDEN_DIM, 3)),
+    LayerSpec("LayerNorm", lambda: nn.LayerNorm(HIDDEN_DIM)),
+    LayerSpec("MultiheadAttention", lambda: nn.MultiheadAttention(HIDDEN_DIM, num_heads=4)),
+    LayerSpec("Conv1D (transformers)", lambda: Conv1D(HIDDEN_DIM, HIDDEN_DIM)),
+)
+
+
+class ProbeContext:
+    """Builds tiny throwaway models to exercise features on CPU.
+
+    The tiny transformer used for prompt learning methods is constructed from a config (no download) and cached; each
+    probe receives a deepcopy so that probes cannot contaminate each other.
+    """
+
+    def __init__(self) -> None:
+        self._tiny_lm: nn.Module | None = None
+
+    def make_config(self, method: MethodInfo, **kwargs: Any) -> PeftConfig:
+        if method.peft_type in PROBE_SKIP:
+            raise ProbeError(f"not probed: {PROBE_SKIP[method.peft_type]}")
+        kwargs = PROBE_CONFIG_OVERRIDES.get(method.peft_type, {}) | kwargs
+        try:
+            return method.config_cls(**kwargs)
+        except Exception as exc:
+            raise ProbeError(
+                f"could not instantiate {method.config_cls.__name__} for probing "
+                f"(consider adding an entry to PROBE_CONFIG_OVERRIDES): {_format_exception(exc)}"
+            ) from exc
+
+    def _probe_layer_and_input(self, method: MethodInfo) -> tuple[nn.Module, torch.Tensor]:
+        if method.peft_type == PeftType.TRAINABLE_TOKENS:
+            # trainable tokens only target embedding layers
+            return nn.Embedding(16, HIDDEN_DIM), torch.randint(0, 16, (2, 5))
+        return nn.Linear(HIDDEN_DIM, HIDDEN_DIM), torch.randn(2, HIDDEN_DIM)
+
+    def adapter_model(self, method: MethodInfo) -> tuple[nn.Module, torch.Tensor]:
+        """Return a PEFT model wrapping a single-layer host, plus a suitable example input."""
+        torch.manual_seed(0)
+        layer, example_input = self._probe_layer_and_input(method)
+        host = SingleLayerModel(layer)
+        config = self.make_config(method, target_modules=["layer"])
+        try:
+            return get_peft_model(host, config), example_input
+        except Exception as exc:
+            raise ProbeError(f"could not build probe model: {_format_exception(exc)}") from exc
+
+    def transformer_model(self, method: MethodInfo) -> nn.Module:
+        """Return a PEFT model on a tiny transformer, for methods that require one (prompt learning etc.)."""
+        if self._tiny_lm is None:
+            torch.manual_seed(0)
+            tiny_config = LlamaConfig(
+                vocab_size=64,
+                hidden_size=32,
+                intermediate_size=64,
+                num_hidden_layers=2,
+                num_attention_heads=4,
+                num_key_value_heads=4,
+                max_position_embeddings=64,
+            )
+            self._tiny_lm = LlamaForCausalLM(tiny_config)
+        kwargs: dict[str, Any] = {"task_type": "CAUSAL_LM"}
+        if method.category == "prompt_learning":
+            kwargs["num_virtual_tokens"] = 4
+        config = self.make_config(method, **kwargs)
+        try:
+            return get_peft_model(deepcopy(self._tiny_lm), config)
+        except Exception as exc:
+            raise ProbeError(f"could not build probe model: {_format_exception(exc)}") from exc
+
+    def second_config(self, method: MethodInfo) -> PeftConfig:
+        """A config suitable for adding a second adapter to a model built by this context."""
+        if method.category == "adapter":
+            return self.make_config(method, target_modules=["layer"])
+        kwargs: dict[str, Any] = {"task_type": "CAUSAL_LM"}
+        if method.category == "prompt_learning":
+            kwargs["num_virtual_tokens"] = 4
+        return self.make_config(method, **kwargs)
+
+
+class Task(ABC):
+    """A single feature check for a single method. Never raises; failures become 'unknown' findings."""
+
+    feature: ClassVar[str]
+    description: ClassVar[str]
+
+    def __init__(self, method: MethodInfo, probe: ProbeContext) -> None:
+        self.method = method
+        self.probe = probe
+
+    @abstractmethod
+    def check(self) -> Finding: ...
+
+    def run(self) -> Finding:
+        try:
+            # Probing emits plenty of warnings that are expected and irrelevant here (e.g. about adapter
+            # initialization or fan_in_fan_out). Suppression is re-asserted per task instead of once globally, since
+            # libraries imported lazily during probing may manipulate the global warning filters.
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore")
+                return self.check()
+        except ProbeError as exc:
+            return Finding(value=UNKNOWN, source=Source.PROBE, note=str(exc))
+        except Exception as exc:
+            return Finding(value=UNKNOWN, source=Source.ERROR, note=_format_exception(exc))
+
+
+class CategoryTask(Task):
+    feature = "category"
+    description = "whether the method is a layer-wrapping adapter, a prompt learning method, or something else"
+
+    def check(self) -> Finding:
+        return Finding(value=self.method.category, source=Source.INTROSPECTION)
+
+
+class TargetLayerTypesTask(Task):
+    feature = "target_layer_types"
+    description = (
+        "which layer types (incl. nn.Parameter) can be targeted, probed by injecting into single-layer models"
+    )
+
+    def check(self) -> Finding:
+        if self.method.category != "adapter":
+            return Finding(
+                value=NOT_APPLICABLE, source=Source.INTROSPECTION, note="method does not wrap target layers"
+            )
+
+        results: dict[str, bool] = {}
+        first_error: str | None = None
+        for spec in LAYER_SPECS:
+            torch.manual_seed(0)
+            host = SingleLayerModel(spec.build())
+            config = self.probe.make_config(self.method, target_modules=["layer"])
+            try:
+                model = get_peft_model(host, config)
+            except Exception as exc:
+                results[spec.label] = False
+                if first_error is None:
+                    first_error = f"{spec.label}: {_format_exception(exc)}"
+            else:
+                results[spec.label] = any(isinstance(module, BaseTunerLayer) for module in model.modules())
+
+        if not any(results.values()):
+            # if not even one layer type can be wrapped, the probe setup is likely at fault, not the method
+            raise ProbeError(f"no layer type could be wrapped, probe presumably mis-configured; {first_error}")
+
+        # Directly targeting nn.Parameter (crucial e.g. for MoE layers) is governed by the target_parameters config
+        # option; its presence is the support signal, no injection probe is needed.
+        field_names = {f.name for f in dataclasses.fields(self.method.config_cls)}
+        results["nn.Parameter"] = "target_parameters" in field_names
+        return Finding(
+            value=results,
+            source=Source.PROBE,
+            note="nn.Parameter support is based on the presence of the target_parameters config option",
+        )
+
+
+class QuantizationTask(Task):
+    feature = "quantization_backends"
+    description = "supported quantization backends, from integration modules and use of the generic backend resolver"
+
+    def check(self) -> Finding:
+        if self.method.category == "prompt_learning":
+            return Finding(
+                value=NOT_APPLICABLE,
+                source=Source.INTROSPECTION,
+                note="prompt learning does not wrap target layers and generally works regardless of quantization",
+            )
+        if self.method.category != "adapter":
+            return Finding(value=UNKNOWN, source=Source.INTROSPECTION, note="no known quantization signal")
+
+        backends: set[str] = set()
+        package_dir = Path(inspect.getfile(self.method.model_cls)).parent
+        for stem, names in QUANT_FILE_BACKENDS.items():
+            if (package_dir / f"{stem}.py").exists():
+                backends.update(names)
+
+        # methods using the generic quantization integration support all backends the resolver handles
+        module_names = {self.method.model_cls.__module__}
+        if (tuner_layer_cls := getattr(self.method.model_cls, "tuner_layer_cls", None)) is not None:
+            module_names.add(tuner_layer_cls.__module__)
+        for module_name in module_names:
+            if "resolve_quantization_backend" in inspect.getsource(sys.modules[module_name]):
+                backends.update(GENERIC_QUANT_BACKENDS)
+                break
+
+        return Finding(value=sorted(backends), source=Source.FILE_CHECK)
+
+
+class MultipleAdaptersTask(Task):
+    feature = "multiple_adapters"
+    description = "whether several adapters can be loaded on the same model, probed via add_adapter"
+
+    def check(self) -> Finding:
+        if self.method.category == "adapter":
+            model, _ = self.probe.adapter_model(self.method)
+        else:
+            model = self.probe.transformer_model(self.method)
+        try:
+            model.add_adapter("second", self.probe.second_config(self.method))
+            model.set_adapter("second")
+        except Exception as exc:
+            return Finding(value=False, source=Source.PROBE, note=_format_exception(exc))
+        return Finding(value=True, source=Source.PROBE)
+
+
+class MixedAdapterBatchesTask(Task):
+    feature = "mixed_adapter_batches"
+    description = "whether one batch can mix several adapters via the adapter_names argument"
+
+    def check(self) -> Finding:
+        if self.method.category != "adapter":
+            return Finding(
+                value=False, source=Source.INTROSPECTION, note="only supported by layer-wrapping adapter methods"
+            )
+        # Support requires both halves of the mechanism: the model must install the forward hooks that distribute
+        # adapter_names, and the tuner layers must implement _mixed_batch_forward (possibly inherited, e.g. from
+        # LoRA). Checking only one of them would over-report.
+        model_supports_hooks = hasattr(self.method.model_cls, "_enable_peft_forward_hooks")
+        layer_classes = _layer_classes(self.method)
+        layer_supports = any(hasattr(cls, "_mixed_batch_forward") for cls in layer_classes)
+        return Finding(value=model_supports_hooks and layer_supports, source=Source.INTROSPECTION)
+
+
+class MergeTask(Task):
+    feature = "merging"
+    description = "whether adapters can be merged into the base weights, verified via merge_and_unload"
+
+    def check(self) -> Finding:
+        if self.method.category == "prompt_learning":
+            return Finding(
+                value=False, source=Source.INTROSPECTION, note="virtual tokens cannot be merged into base weights"
+            )
+        if self.method.category != "adapter":
+            return Finding(value=False, source=Source.INTROSPECTION, note="method does not implement merging")
+
+        layer_classes = _layer_classes(self.method)
+        # BaseTunerLayer.merge raises NotImplementedError, so an unchanged merge attribute means no support
+        implemented = any(cls.merge is not BaseTunerLayer.merge for cls in layer_classes)
+        if not implemented:
+            return Finding(value=False, source=Source.INTROSPECTION, note="no tuner layer class implements merge()")
+
+        try:
+            model, example_input = self.probe.adapter_model(self.method)
+            model.eval()
+            with torch.no_grad():
+                output_before = model(example_input)
+                merged = model.merge_and_unload()
+                output_after = merged(example_input)
+        except ProbeError as exc:
+            return Finding(
+                value=True, source=Source.INTROSPECTION, note=f"merge() is implemented, but probing failed: {exc}"
+            )
+        except NotImplementedError as exc:
+            return Finding(value=False, source=Source.PROBE, note=_format_exception(exc))
+        except Exception as exc:
+            return Finding(
+                value=True,
+                source=Source.INTROSPECTION,
+                note=f"merge() is implemented, but probing failed: {_format_exception(exc)}",
+            )
+
+        note = None
+        if not torch.allclose(output_before, output_after, atol=1e-4):
+            note = "merged model outputs deviate from unmerged outputs beyond tolerance"
+        return Finding(value=True, source=Source.PROBE, note=note)
+
+
+class MixedMethodModelTask(Task):
+    feature = "peft_mixed_model"
+    description = "whether the method can be combined with other method types in a PeftMixedModel"
+
+    def check(self) -> Finding:
+        # filled by register_peft_method(..., is_mixed_compatible=True)
+        value = self.method.peft_type in PEFT_TYPE_TO_MIXED_MODEL_MAPPING
+        return Finding(value=value, source=Source.INTROSPECTION)
+
+
+class LoraConversionTask(Task):
+    feature = "lora_conversion"
+    description = "whether adapters of this method can be converted to a LoRA adapter"
+
+    def check(self) -> Finding:
+        if self.method.peft_type == PeftType.LORA:
+            return Finding(value=True, source=Source.INTROSPECTION, note="already a LoRA adapter")
+        if self.method.category != "adapter":
+            return Finding(value=False, source=Source.INTROSPECTION, note="method does not wrap target layers")
+
+        try:
+            model, _ = self.probe.adapter_model(self.method)
+        except ProbeError as exc:
+            # fall back to a static signal; an override does not guarantee support, hence the note
+            layer_classes = _layer_classes(self.method)
+            overridden = any(
+                cls.supports_lora_conversion is not BaseTunerLayer.supports_lora_conversion for cls in layer_classes
+            )
+            return Finding(
+                value=overridden,
+                source=Source.INTROSPECTION,
+                note=f"based on presence of a supports_lora_conversion override; probing failed: {exc}",
+            )
+
+        layer = next(module for module in model.modules() if isinstance(module, BaseTunerLayer))
+        return Finding(value=bool(layer.supports_lora_conversion("default")), source=Source.PROBE)
+
+
+class WeightedAdapterTask(Task):
+    feature = "add_weighted_adapter"
+    description = "whether several adapters can be combined into a new one, probed via add_weighted_adapter"
+
+    def check(self) -> Finding:
+        # Methods without the API don't support the feature; methods that inherit it but override it with a stub
+        # that raises (e.g. AdaLoRA) are caught by the probe below.
+        if getattr(self.method.model_cls, "add_weighted_adapter", None) is None:
+            return Finding(value=False, source=Source.INTROSPECTION)
+
+        model, _ = self.probe.adapter_model(self.method)
+        # combining several adapters requires loading several adapters in the first place; methods that already fail
+        # here cannot support add_weighted_adapter either
+        try:
+            model.add_adapter("second", self.probe.second_config(self.method))
+        except Exception as exc:
+            return Finding(
+                value=False,
+                source=Source.PROBE,
+                note=f"a second adapter could not be added: {_format_exception(exc)}",
+            )
+        try:
+            model.add_weighted_adapter(adapters=["default", "second"], weights=[0.5, 0.5], adapter_name="combined")
+        except Exception as exc:
+            return Finding(value=False, source=Source.PROBE, note=_format_exception(exc))
+        return Finding(value=True, source=Source.PROBE)
+
+
+class HotswapTask(Task):
+    feature = "hotswapping"
+    description = "whether adapters can be hot-swapped in place (peft.utils.hotswap)"
+
+    def check(self) -> Finding:
+        return Finding(value=self.method.peft_type in CONFIG_KEYS_TO_CHECK, source=Source.INTROSPECTION)
+
+
+class AuxiliaryModulesTask(Task):
+    feature = "auxiliary_modules"
+    description = "whether the config supports modules_to_save and trainable_token_indices"
+
+    def check(self) -> Finding:
+        field_names = {f.name for f in dataclasses.fields(self.method.config_cls)}
+        value = {
+            "modules_to_save": "modules_to_save" in field_names,
+            "trainable_token_indices": "trainable_token_indices" in field_names,
+        }
+        return Finding(value=value, source=Source.INTROSPECTION)
+
+
+class ExtrasTask(Task):
+    feature = "extras"
+    description = "notable method-specific config options (curated list)"
+
+    def check(self) -> Finding:
+        field_names = {f.name for f in dataclasses.fields(self.method.config_cls)}
+        value = sorted(field_names.intersection(NOTABLE_CONFIG_FIELDS))
+        return Finding(value=value, source=Source.INTROSPECTION)
+
+
+class PaperLinkTask(Task):
+    feature = "paper_url"
+    description = "link to the method's paper, from the docs intro or class docstrings (omitted when ambiguous)"
+
+    # default assumes the script lives in scripts/ of a repository checkout; can be overridden via --docs-dir
+    docs_dir: ClassVar[Path] = Path(__file__).parent.parent / "docs" / "source" / "package_reference"
+
+    def _docs_intro(self) -> str | None:
+        """The first paragraph after the first heading of the method's docs page (the pages start with a license
+        comment, a `# Title` heading, and a prose paragraph)."""
+        slug = DOCS_SLUG_OVERRIDES.get(self.method.name, self.method.name.lower())
+        try:
+            text = (self.docs_dir / f"{slug}.md").read_text()
+        except OSError:
+            return None
+        text = re.sub(r"<!--.*?-->", "", text, flags=re.DOTALL)
+        match = re.search(r"^# .+?$\s+(.+?)(?:\n\s*\n|$)", text, flags=re.MULTILINE | re.DOTALL)
+        return match.group(1) if match else None
+
+    def check(self) -> Finding:
+        # Sources in order of preference; the first one containing exactly one distinct paper URL wins. A source
+        # with no link, or with several different ones (e.g. docstrings that also cite related methods), is skipped
+        # as ambiguous -- a missing paper link is better than a wrong one.
+        sources: list[tuple[str, str | None]] = [
+            ("docs intro", self._docs_intro()),
+            ("config class docstring", self.method.config_cls.__doc__),
+            ("model class docstring", self.method.model_cls.__doc__ if self.method.model_cls is not None else None),
+        ]
+        for source_name, text in sources:
+            if not text:
+                continue
+            urls = set(PAPER_URL_RE.findall(text))
+            if len(urls) == 1:
+                return Finding(value=urls.pop(), source=Source.FILE_CHECK, note=f"from the {source_name}")
+        return Finding(
+            value=None,
+            source=Source.FILE_CHECK,
+            note="no unambiguous paper link in the docs intro or the config/model class docstrings",
+        )
+
+
+# the order here determines the order of the features in the output
+TASK_CLASSES: tuple[type[Task], ...] = (
+    CategoryTask,
+    TargetLayerTypesTask,
+    QuantizationTask,
+    MultipleAdaptersTask,
+    MixedAdapterBatchesTask,
+    MergeTask,
+    MixedMethodModelTask,
+    LoraConversionTask,
+    WeightedAdapterTask,
+    HotswapTask,
+    AuxiliaryModulesTask,
+    ExtrasTask,
+    PaperLinkTask,
+)
+
+
+def collect_methods(selected: list[str] | None) -> list[MethodInfo]:
+    registered = sorted(PEFT_TYPE_TO_CONFIG_MAPPING, key=lambda peft_type: peft_type.value)
+    if selected is not None:
+        valid = {peft_type.value for peft_type in registered}
+        requested = [name.upper() for name in selected]
+        if unknown := [name for name in requested if name not in valid]:
+            raise SystemExit(
+                f"Unknown PEFT method(s): {', '.join(unknown)}. Valid choices: {', '.join(sorted(valid))}"
+            )
+        registered = [peft_type for peft_type in registered if peft_type.value in requested]
+    return [MethodInfo.from_peft_type(peft_type) for peft_type in registered]
+
+
+def collect_tasks(methods: list[MethodInfo], probe: ProbeContext) -> list[Task]:
+    return [task_cls(method, probe) for method in methods for task_cls in TASK_CLASSES]
+
+
+def run_tasks(tasks: list[Task]) -> dict[str, dict[str, Any]]:
+    results: dict[str, dict[str, Any]] = {}
+    for task in tqdm(tasks, desc="Checking capabilities", unit="check"):
+        method = task.method
+        entry = results.setdefault(
+            method.name,
+            {
+                "config_class": method.config_cls.__name__,
+                "model_class": method.model_cls.__name__ if method.model_cls is not None else None,
+                "features": {},
+            },
+        )
+        entry["features"][task.feature] = task.run().to_json()
+    return results
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(
+        description="Generate a JSON capability matrix of all PEFT methods.",
+        epilog="Example: python scripts/generate_method_capabilities.py --methods lora ia3 --output capabilities.json",
+    )
+    parser.add_argument(
+        "--methods",
+        "-m",
+        nargs="+",
+        default=None,
+        metavar="METHOD",
+        help="restrict the analysis to these PEFT methods (case-insensitive, e.g. 'lora ia3'); default: all",
+    )
+    parser.add_argument(
+        "--output",
+        "-o",
+        type=Path,
+        default=Path("method_capabilities.json"),
+        help="output JSON file (default: %(default)s)",
+    )
+    parser.add_argument("--dry-run", action="store_true", help="only list the checks that would run")
+    parser.add_argument(
+        "--docs-dir",
+        type=Path,
+        default=PaperLinkTask.docs_dir,
+        help="directory containing the package_reference docs pages, used for the paper link check",
+    )
+    args = parser.parse_args(argv)
+    PaperLinkTask.docs_dir = args.docs_dir
+    logging.basicConfig(level=logging.INFO, format="%(message)s")  # logs to stderr
+
+    methods = collect_methods(args.methods)
+    probe = ProbeContext()
+    tasks = collect_tasks(methods, probe)
+
+    if args.dry_run:
+        for method in methods:
+            print(f"{method.name}: {', '.join(task_cls.feature for task_cls in TASK_CLASSES)}")
+        print(f"\n{len(methods)} methods x {len(TASK_CLASSES)} checks = {len(tasks)} tasks")
+        return
+
+    output = {
+        "schema_version": 1,
+        "peft_version": peft.__version__,
+        "methods": run_tasks(tasks),
+    }
+    # The results deliberately go to a file, not to stdout: probing can trigger subprocesses whose output is written
+    # directly to stdout (e.g. BOFT compiling its CUDA extension via ninja), which would interleave with the JSON.
+    args.output.write_text(json.dumps(output, indent=2) + "\n")
+    logger.info(f"Wrote capabilities of {len(methods)} methods to {args.output}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/launch_notebook_mp.py b/scripts/launch_notebook_mp.py
new file mode 100644
index 0000000..ce5439a
--- /dev/null
+++ b/scripts/launch_notebook_mp.py
@@ -0,0 +1,47 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+# This is a minimal example of launching PEFT with Accelerate. This used to cause issues because PEFT would eagerly
+# import bitsandbytes, which initializes CUDA, resulting in:
+# > RuntimeError: Cannot re-initialize CUDA in forked subprocess. To use CUDA with multiprocessing, you must use the
+# > 'spawn' start method
+# This script exists to ensure that this issue does not reoccur.
+
+import torch
+from accelerate import notebook_launcher
+
+import peft
+from peft.utils import infer_device
+
+
+def init():
+    class MyModule(torch.nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.linear = torch.nn.Linear(1, 2)
+
+        def forward(self, x):
+            return self.linear(x)
+
+    device = infer_device()
+    model = MyModule().to(device)
+    peft.get_peft_model(model, peft.LoraConfig(target_modules=["linear"]))
+
+
+def main():
+    notebook_launcher(init, (), num_processes=2)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/log_reports.py b/scripts/log_reports.py
new file mode 100644
index 0000000..2a61db8
--- /dev/null
+++ b/scripts/log_reports.py
@@ -0,0 +1,144 @@
+import argparse
+import json
+import os
+from datetime import UTC, datetime
+from pathlib import Path
+
+from tabulate import tabulate
+
+
+MAX_LEN_MESSAGE = 2900  # slack endpoint has a limit of 3001 characters
+
+parser = argparse.ArgumentParser()
+parser.add_argument(
+    "--slack_channel_name",
+    default="peft-ci-daily",
+)
+
+
+def main(slack_channel_name=None):
+    failed = []
+    passed = []
+
+    group_info = []
+
+    total_num_failed = 0
+    empty_file = False or len(list(Path().glob("*.log"))) == 0
+
+    total_empty_files = []
+
+    for log in Path().glob("*.log"):
+        section_num_failed = 0
+        i = 0
+        with open(log) as f:
+            for line in f:
+                line = json.loads(line)
+                i += 1
+                if line.get("nodeid", "") != "":
+                    test = line["nodeid"]
+                    if line.get("duration", None) is not None:
+                        duration = f"{line['duration']:.4f}"
+                        if line.get("outcome", "") == "failed":
+                            section_num_failed += 1
+                            failed.append([test, duration, log.name.split("_")[0]])
+                            total_num_failed += 1
+                        else:
+                            passed.append([test, duration, log.name.split("_")[0]])
+            empty_file = i == 0
+        group_info.append([str(log), section_num_failed, failed])
+        total_empty_files.append(empty_file)
+        os.remove(log)
+        failed = []
+    text = (
+        "🌞 There were no failures!"
+        if not any(total_empty_files)
+        else "Something went wrong there is at least one empty file - please check GH action results."
+    )
+    no_error_payload = {
+        "type": "section",
+        "text": {
+            "type": "plain_text",
+            "text": text,
+            "emoji": True,
+        },
+    }
+
+    message = ""
+    payload = [
+        {
+            "type": "header",
+            "text": {
+                "type": "plain_text",
+                "text": "🤗 Results of the {} PEFT scheduled tests.".format(os.environ.get("TEST_TYPE", "")),
+            },
+        },
+    ]
+    if total_num_failed > 0:
+        for i, (name, num_failed, failed_tests) in enumerate(group_info):
+            if num_failed > 0:
+                if num_failed == 1:
+                    message += f"*{name}: {num_failed} failed test*\n"
+                else:
+                    message += f"*{name}: {num_failed} failed tests*\n"
+                failed_table = []
+                for test in failed_tests:
+                    failed_table.append(test[0].split("::"))
+                failed_table = tabulate(
+                    failed_table,
+                    headers=["Test Location", "Test Case", "Test Name"],
+                    showindex="always",
+                    tablefmt="grid",
+                    maxcolwidths=[12, 12, 12],
+                )
+                message += "\n```\n" + failed_table + "\n```"
+
+            if total_empty_files[i]:
+                message += f"\n*{name}: Warning! Empty file - please check the GitHub action job *\n"
+        print(f"### {message}")
+    else:
+        payload.append(no_error_payload)
+
+    if os.environ.get("TEST_TYPE", "") != "":
+        from slack_sdk import WebClient
+
+        if len(message) > MAX_LEN_MESSAGE:
+            print(f"Truncating long message from {len(message)} to {MAX_LEN_MESSAGE}")
+            message = message[:MAX_LEN_MESSAGE] + "..."
+
+        if len(message) != 0:
+            md_report = {
+                "type": "section",
+                "text": {"type": "mrkdwn", "text": message},
+            }
+            payload.append(md_report)
+            action_button = {
+                "type": "section",
+                "text": {"type": "mrkdwn", "text": "*For more details:*"},
+                "accessory": {
+                    "type": "button",
+                    "text": {"type": "plain_text", "text": "Check Action results", "emoji": True},
+                    "url": f"https://github.com/huggingface/peft/actions/runs/{os.environ['GITHUB_RUN_ID']}",
+                },
+            }
+            payload.append(action_button)
+
+        date_report = {
+            "type": "context",
+            "elements": [
+                {
+                    "type": "plain_text",
+                    "text": f"Nightly {os.environ.get('TEST_TYPE')} test results for {datetime.now(UTC).date()}",
+                },
+            ],
+        }
+        payload.append(date_report)
+
+        print(payload)
+
+        client = WebClient(token=os.environ.get("SLACK_API_TOKEN"))
+        client.chat_postMessage(channel=f"#{slack_channel_name}", text=message, blocks=payload)
+
+
+if __name__ == "__main__":
+    args = parser.parse_args()
+    main(args.slack_channel_name)
diff --git a/scripts/stale.py b/scripts/stale.py
new file mode 100644
index 0000000..794ec84
--- /dev/null
+++ b/scripts/stale.py
@@ -0,0 +1,65 @@
+# Copyright 2023 The HuggingFace Team, the AllenNLP library authors. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Script to close stale issue. Taken in part from the AllenNLP repository.
+https://github.com/allenai/allennlp.
+"""
+
+import os
+from datetime import datetime as dt
+from datetime import timezone
+
+from github import Github
+
+
+LABELS_TO_EXEMPT = [
+    "good first issue",
+    "good second issue",
+    "good difficult issue",
+    "feature request",
+    "new model",
+    "wip",
+    "PRs welcome to address this",
+]
+
+
+def main():
+    g = Github(os.environ["GITHUB_TOKEN"])
+    repo = g.get_repo("huggingface/peft")
+    open_issues = repo.get_issues(state="open")
+
+    for issue in open_issues:
+        comments = sorted(issue.get_comments(), key=lambda i: i.created_at, reverse=True)
+        last_comment = comments[0] if len(comments) > 0 else None
+        if (
+            (last_comment is not None and last_comment.user.login == "github-actions[bot]")
+            and (dt.now(timezone.utc) - issue.updated_at).days > 7
+            and (dt.now(timezone.utc) - issue.created_at).days >= 30
+            and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels())
+        ):
+            issue.edit(state="closed")
+        elif (
+            (dt.now(timezone.utc) - issue.updated_at).days > 23
+            and (dt.now(timezone.utc) - issue.created_at).days >= 30
+            and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels())
+        ):
+            issue.create_comment(
+                "This issue has been automatically marked as stale because it has not had "
+                "recent activity. If you think this still needs to be addressed "
+                "please comment on this thread.\n\n"
+            )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/train_memory.py b/scripts/train_memory.py
new file mode 100644
index 0000000..e743bda
--- /dev/null
+++ b/scripts/train_memory.py
@@ -0,0 +1,276 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+"""This script trains a model on a small text dataset and measures the memory consumption, as well as a few other
+useful metrics.
+
+Example:
+
+Get help:
+
+```bash
+python train_memory.py --help
+```
+
+Train the google/gemma-2-2b model with a LoRA config json at the indicated location.
+
+```bash
+python train_memory.py "google/gemma-2-2b" --max_seq_length 256 --batch_size 1 --rank 32 --dtype bfloat16 --path_config <path-to-adapter-config.json>
+```
+
+Fully fine-tune the model (i.e. without LoRA) by setting the rank to 0:
+
+```bash
+python train_memory.py "google/gemma-2-2b" --rank 0
+```
+
+Get an estimate of the size of the hidden states by passing `--monitor_tensors`. This trains just for a single epoch. For realistic estimates, the batch size for this:
+
+```bash
+python train_memory.py "google/gemma-2-2b" --max_seq_length 256 --batch_size 32 --rank 32 --dtype bfloat16 --path_config configs/lora_rank-32_embedding-lora/ --monitor_tensors
+```
+
+"""
+
+import argparse
+import gc
+import os
+import sys
+import tempfile
+import time
+import warnings
+from collections import Counter
+from contextlib import nullcontext
+from functools import partial
+
+import torch
+from datasets import load_dataset
+from torch import nn
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    BitsAndBytesConfig,
+)
+
+from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+from peft.utils import CONFIG_NAME, SAFETENSORS_WEIGHTS_NAME
+
+
+# suppress all warnings
+warnings.filterwarnings("ignore")
+
+device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
+dtype_to_bytes_linear = {"float32": 4, "float16": 2, "bfloat16": 2, "int8": 1, "int4": 0.5}
+
+
+def init_accelerator():
+    torch.manual_seed(0)
+    if device == "cpu":
+        return
+
+    device_module = getattr(torch, device, torch.cuda)
+    device_module.reset_peak_memory_stats()
+    device_module.manual_seed_all(0)
+    # might not be necessary, but just to be sure
+    nn.Linear(1, 1).to(device)
+
+
+def get_data(tokenizer):
+    def tokenize(samples):
+        # For some reason, the max sequence length is not honored by the tokenizer, resulting in IndexErrors. Thus,
+        # manually ensure that sequences are not too long.
+        tokenized = tokenizer(samples["quote"])
+        tokenized["input_ids"] = [input_ids[: tokenizer.model_max_length] for input_ids in tokenized["input_ids"]]
+        tokenized["attention_mask"] = [
+            input_ids[: tokenizer.model_max_length] for input_ids in tokenized["attention_mask"]
+        ]
+        return tokenized
+
+    data = load_dataset("ybelkada/english_quotes_copy")
+    data = data.map(tokenize, batched=True)
+    # We need to manually remove unused columns. This is because we cannot use remove_unused_columns=True in the
+    # Trainer, as this leads to errors with torch.compile. We also cannot just leave them in, as they contain
+    # strings. Therefore, manually remove all unused columns.
+    data = data.remove_columns(["quote", "author", "tags"])
+    return data
+
+
+def train(model_id, rank, dtype, monitor_tensors, max_seq_length, batch_size, max_steps, path_config):
+    init_accelerator()
+    device_module = getattr(torch, device, torch.cuda)
+    accelerator_memory_init = device_module.max_memory_allocated()
+    accelerator_memory_log = []
+
+    tokenizer = AutoTokenizer.from_pretrained(model_id)
+    tokenizer.model_max_length = max_seq_length
+    if not tokenizer.pad_token:
+        tokenizer.pad_token = tokenizer.eos_token
+    data = get_data(tokenizer)
+
+    if dtype == "int4":
+        quant_config = BitsAndBytesConfig(load_in_4bit=True)
+        model = AutoModelForCausalLM.from_pretrained(model_id, device_map=device, quantization_config=quant_config)
+        model = prepare_model_for_kbit_training(model)
+    elif dtype == "int8":
+        quant_config = BitsAndBytesConfig(load_in_8bit=True)
+        model = AutoModelForCausalLM.from_pretrained(model_id, device_map=device, quantization_config=quant_config)
+        model = prepare_model_for_kbit_training(model)
+    elif dtype == "bfloat16":
+        model = AutoModelForCausalLM.from_pretrained(model_id, device_map=device, torch_dtype=torch.bfloat16)
+    elif dtype == "float16":
+        model = AutoModelForCausalLM.from_pretrained(model_id, device_map=device, torch_dtype=torch.float16)
+    elif dtype == "float32":
+        model = AutoModelForCausalLM.from_pretrained(model_id, device_map=device)
+    else:
+        raise ValueError(f"Invalid dtype: {dtype}")
+
+    if rank > 0:
+        if path_config is None:
+            raise RuntimeError("LoRA rank > 0 requires a path to a LoRA config")
+        if path_config.endswith(CONFIG_NAME):
+            path_config = path_config.removesuffix(CONFIG_NAME)
+        config = LoraConfig.from_pretrained(path_config)
+        model = get_peft_model(model, config)
+        model.print_trainable_parameters()
+    else:
+        print("Not using LoRA")
+
+    model.config.use_cache = False
+    storage = []
+
+    def pack(x):
+        storage.append(x)
+        return len(storage) - 1
+
+    def unpack(x):
+        return storage[x]
+
+    train_ctx = partial(torch.autograd.graph.saved_tensors_hooks, pack, unpack) if monitor_tensors else nullcontext
+
+    optimizer = torch.optim.AdamW(model.parameters(), lr=1e-5)
+    losses = []
+    sample = 0
+    tic_total = time.perf_counter()
+    for i in range(max_steps):
+        storage.clear()
+        tic = time.perf_counter()
+        try:
+            batch = tokenizer.pad(data["train"][sample : sample + batch_size], return_tensors="pt").to(model.device)
+            sample += batch_size
+
+            # add targets
+            batch["labels"] = batch["input_ids"].clone()
+            optimizer.zero_grad()
+
+            with train_ctx():
+                outputs = model(**batch)
+            loss = outputs.loss
+            loss.backward()
+            optimizer.step()
+            losses.append(loss.item())
+            accelerator_memory_log.append(device_module.memory_allocated() - accelerator_memory_init)
+            device_module.empty_cache()
+            gc.collect()
+            toc = time.perf_counter()
+            print(f"step {i:3d} loss {loss.item():.6f} time {toc - tic:.2f}s", file=sys.stderr)
+        except KeyboardInterrupt:
+            print("canceled training")
+            break
+
+        if monitor_tensors:
+            break
+
+    toc_total = time.perf_counter()
+
+    accelerator_memory_final = device_module.max_memory_allocated()
+    accelerator_memory_avg = int(sum(accelerator_memory_log) / len(accelerator_memory_log))
+    print(f"{model.device.type} memory avg: {accelerator_memory_avg // 2**20}MB")
+    print(f"{model.device.type} memory max: {(accelerator_memory_final - accelerator_memory_init) // 2**20}MB")
+    print(f"total time: {toc_total - tic_total:.2f}s")
+
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        model.save_pretrained(tmp_dir)
+        stat = os.stat(os.path.join(tmp_dir, SAFETENSORS_WEIGHTS_NAME))
+    file_size = stat.st_size
+    print(f"file size: {file_size / 2**20:.1f}MB")
+
+    if monitor_tensors:
+        dtype_counts = Counter(t.dtype for t in storage)
+        shape_counts = Counter(t.shape for t in storage)
+        param_shape_counts = Counter(p.shape for p in model.parameters())
+        param_shape_counts_copy = dict(param_shape_counts).copy()
+
+        # shape counts includes the params, so we need to subtract them; note that they can be transposed
+        # this is an approximation
+        diff_shape_counts = {}
+        for shape, count in shape_counts.items():
+            if shape in param_shape_counts_copy:
+                diff_count = count - param_shape_counts[shape]
+                if diff_count > 0:
+                    diff_shape_counts[shape] = diff_count
+                    param_shape_counts_copy[shape] = max(0, param_shape_counts_copy[shape] - diff_count)
+            elif shape[::-1] in param_shape_counts:
+                diff_count = count - param_shape_counts[shape[::-1]]
+                if diff_count > 0:
+                    diff_shape_counts[shape] = diff_count
+                    param_shape_counts_copy[shape[::-1]] = max(0, param_shape_counts_copy[shape[::-1]] - diff_count)
+            else:
+                diff_shape_counts[shape] = count
+
+        total_size = sum(t.numel() * t.element_size() for t in storage)
+        total_size_mb = f"{total_size // 2**20}MB"
+        diff_size = 0
+        for shape, count in diff_shape_counts.items():
+            diff_size += count * torch.zeros(shape).numel() * dtype_to_bytes_linear[dtype]
+        param_size = total_size - diff_size
+
+        diff_size_mb = f"{diff_size // 2**20}MB"
+        param_size_mb = f"{param_size // 2**20}MB"
+
+        print(f"Dtype counts: {dtype_counts.most_common()}")
+        print(f"Total size of tensors:     {total_size_mb: >12}")
+        print(f"Total size of activations: {diff_size_mb: >12}")
+        print(f"Total size of parameters:  {param_size_mb: >12}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("model_id", type=str, help="Model name on Hugging Face Hub")
+    parser.add_argument("--rank", type=int, default=8, help="Rank of LoRA, 0 => no LoRA, default 8")
+    parser.add_argument(
+        "--dtype",
+        type=str,
+        default="float32",
+        help="Data type, one of float32, float16, bfloat16, int8, int4, default float32",
+    )
+    parser.add_argument(
+        "--monitor_tensors",
+        action="store_true",
+        help="Monitor tensor sizes during training for a single training step, off by default",
+    )
+    parser.add_argument("--max_seq_length", type=int, default=128, help="Maximum sequence length, default 128")
+    parser.add_argument("--batch_size", type=int, default=1, help="Batch size, default 1")
+    parser.add_argument("--max_steps", type=int, default=50, help="Maximum number of training steps, default 50")
+    parser.add_argument("--path_config", type=str, default=None, help="Path to LoRA config")
+    args = parser.parse_args()
+    train(
+        model_id=args.model_id,
+        rank=args.rank,
+        dtype=args.dtype,
+        monitor_tensors=args.monitor_tensors,
+        max_seq_length=args.max_seq_length,
+        batch_size=args.batch_size,
+        max_steps=args.max_steps,
+        path_config=args.path_config,
+    )
diff --git a/setup.py b/setup.py
new file mode 100644
index 0000000..a20c5a4
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,117 @@
+# Copyright 2023 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from setuptools import find_packages, setup
+
+
+VERSION = "0.19.2.dev0"
+
+extras = {}
+extras["quality"] = [
+    "black",  # doc-builder has an implicit dependency on Black, see huggingface/doc-builder#434
+    "hf-doc-builder",
+    # when upgrading this, also upgrade required version in pyproject.toml and pre-commit-config.yaml
+    "ruff~=0.15.12",
+]
+extras["docs_specific"] = [
+    "black",  # doc-builder has an implicit dependency on Black, see huggingface/doc-builder#434
+    "requests",  # doc-builder has an implicit dependency on requests (setup.py doesn't mention it, pyproject does)
+    "hf-doc-builder",
+]
+extras["dev"] = extras["quality"] + extras["docs_specific"]
+extras["test"] = extras["dev"] + [
+    "pytest",
+    "pytest-cov",
+    "pytest-xdist",
+    "parameterized",
+    "datasets",
+    "diffusers",
+    "scipy",
+    "scikit-learn",
+    "protobuf",
+    "sentencepiece",
+    "torchvision",
+]
+
+with open("README.md", encoding="utf-8") as f:
+    long_description = f.read()
+
+setup(
+    name="peft",
+    version=VERSION,
+    description="Parameter-Efficient Fine-Tuning (PEFT)",
+    license_files=["LICENSE"],
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    keywords="deep learning",
+    license="Apache",
+    author="The HuggingFace team",
+    author_email="benjamin@huggingface.co",
+    url="https://github.com/huggingface/peft",
+    package_dir={"": "src"},
+    packages=find_packages("src"),
+    package_data={"peft": ["py.typed", "tuners/boft/fbd/fbd_cuda.cpp", "tuners/boft/fbd/fbd_cuda_kernel.cu"]},
+    entry_points={},
+    python_requires=">=3.10.0",
+    install_requires=[
+        "numpy>=1.17",
+        "packaging>=20.0",
+        "psutil",
+        "pyyaml",
+        "torch>=1.13.0",
+        "transformers",
+        "tqdm",
+        "accelerate>=0.21.0",
+        "safetensors",
+        "huggingface_hub>=0.25.0",
+    ],
+    extras_require=extras,
+    classifiers=[
+        "Development Status :: 5 - Production/Stable",
+        "Intended Audience :: Developers",
+        "Intended Audience :: Education",
+        "Intended Audience :: Science/Research",
+        "License :: OSI Approved :: Apache Software License",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
+        "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    ],
+)
+
+# Release checklist
+# 1. Change the version in __init__.py and setup.py to the release version, e.g. from "0.6.1.dev0" to "0.7.0"
+# 2. Check if there are any deprecations that need to be addressed for this release by searching for "# TODO" in the code
+# 3. Commit these changes with the message: "Release: VERSION", create a PR and merge it.
+# 4. Add a tag in git to mark the release: "git tag -a v<VERSION> -m 'Adds tag <VERSION> for pypi' "
+#    Push the tag to git:
+#      git push --tags origin main
+#    It is necessary to work on the original repository, not on a fork.
+# 5. Run the following commands in the top-level directory:
+#      python setup.py bdist_wheel
+#      python setup.py sdist
+#    Ensure that you are on the clean and up-to-date main branch (git status --untracked-files=no should not list any
+#    files and show the main branch)
+# 6. Upload the package to the pypi test server first:
+#      twine upload dist/* -r pypitest
+# 7. Check that you can install it in a virtualenv by running:
+#      pip install -i https://testpypi.python.org/pypi --extra-index-url https://pypi.org/simple peft
+# 8. Upload the final version to actual pypi:
+#      twine upload dist/* -r pypi
+# 9. Add release notes to the tag on https://github.com/huggingface/peft/releases once everything is looking hunky-dory.
+#      Check the notes here: https://docs.google.com/document/d/1k-sOIfykuKjWcOIALqjhFKz4amFEp-myeJUJEzNgjoU/edit?usp=sharing
+# 10. Update the version in __init__.py, setup.py to the bumped patch version + ".dev0" (e.g. from "0.7.0" to "0.7.1.dev0")
diff --git a/src/peft/__init__.py b/src/peft/__init__.py
new file mode 100644
index 0000000..b8ea1b3
--- /dev/null
+++ b/src/peft/__init__.py
@@ -0,0 +1,321 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+__version__ = "0.19.2.dev0"
+
+from .auto import (
+    MODEL_TYPE_TO_PEFT_MODEL_MAPPING,
+    AutoPeftModel,
+    AutoPeftModelForCausalLM,
+    AutoPeftModelForFeatureExtraction,
+    AutoPeftModelForQuestionAnswering,
+    AutoPeftModelForSeq2SeqLM,
+    AutoPeftModelForSequenceClassification,
+    AutoPeftModelForTokenClassification,
+)
+from .config import PeftConfig, PromptLearningConfig
+from .helpers import find_kappa_target_modules
+from .mapping import (
+    PEFT_TYPE_TO_CONFIG_MAPPING,
+    PEFT_TYPE_TO_MIXED_MODEL_MAPPING,
+    PEFT_TYPE_TO_TUNER_MAPPING,
+    get_peft_config,
+    inject_adapter_in_model,
+)
+from .mapping_func import get_peft_model
+from .mixed_model import PeftMixedModel
+from .peft_model import (
+    PeftModel,
+    PeftModelForCausalLM,
+    PeftModelForFeatureExtraction,
+    PeftModelForQuestionAnswering,
+    PeftModelForSeq2SeqLM,
+    PeftModelForSequenceClassification,
+    PeftModelForTokenClassification,
+    get_layer_status,
+    get_model_status,
+)
+from .tuners import (
+    AdaLoraConfig,
+    AdaLoraModel,
+    AdamssConfig,
+    AdamssModel,
+    AdaptionPromptConfig,
+    AdaptionPromptModel,
+    ArrowConfig,
+    BdLoraConfig,
+    BeftConfig,
+    BeftModel,
+    BOFTConfig,
+    BOFTModel,
+    C3AConfig,
+    C3AModel,
+    CartridgeConfig,
+    CartridgeEncoder,
+    CPTConfig,
+    CPTEmbedding,
+    DeftConfig,
+    DeftModel,
+    DeloraConfig,
+    DeloraModel,
+    EvaConfig,
+    FourierFTConfig,
+    FourierFTModel,
+    FrodConfig,
+    FrodModel,
+    GloraConfig,
+    GloraModel,
+    GraloraConfig,
+    GraloraModel,
+    HiraConfig,
+    HiraModel,
+    HRAConfig,
+    HRAModel,
+    IA3Config,
+    IA3Model,
+    LilyConfig,
+    LilyModel,
+    LNTuningConfig,
+    LNTuningModel,
+    LoftQConfig,
+    LoHaConfig,
+    LoHaModel,
+    LoKrConfig,
+    LoKrModel,
+    LoraConfig,
+    LoraGAConfig,
+    LoraModel,
+    LoraRuntimeConfig,
+    MissConfig,
+    MissModel,
+    MontecloraConfig,
+    MultitaskPromptTuningConfig,
+    MultitaskPromptTuningInit,
+    OFTConfig,
+    OFTModel,
+    OSFConfig,
+    OSFModel,
+    PeanutConfig,
+    PeanutModel,
+    PolyConfig,
+    PolyModel,
+    PrefixEncoder,
+    PrefixTuningConfig,
+    PromptEmbedding,
+    PromptEncoder,
+    PromptEncoderConfig,
+    PromptEncoderReparameterizationType,
+    PromptTuningConfig,
+    PromptTuningInit,
+    PsoftConfig,
+    PsoftModel,
+    PveraConfig,
+    PveraModel,
+    RandLoraConfig,
+    RandLoraModel,
+    RoadConfig,
+    RoadModel,
+    ShiraConfig,
+    ShiraModel,
+    TinyLoraConfig,
+    TinyLoraModel,
+    TrainableTokensConfig,
+    TrainableTokensModel,
+    UniLoraConfig,
+    UniLoraModel,
+    VBLoRAConfig,
+    VBLoRAModel,
+    VeloraConfig,
+    VeraConfig,
+    VeraModel,
+    WaveFTConfig,
+    WaveFTModel,
+    XLoraConfig,
+    XLoraModel,
+    convert_to_lora,
+    create_arrow_model,
+    get_eva_state_dict,
+    initialize_lora_eva_weights,
+    preprocess_loraga,
+    save_as_lora,
+)
+from .tuners.cartridge.utils import (
+    compose_cartridge_adapters,
+    initialize_kv_prefix_from_past_key_values,
+    initialize_kv_prefix_from_text,
+    prompt_embeddings_from_past_key_values,
+)
+from .utils import (
+    TRANSFORMERS_MODELS_TO_PREFIX_TUNING_POSTPROCESS_MAPPING,
+    PeftType,
+    PeftWarning,
+    TaskType,
+    bloom_model_postprocess_past_key_value,
+    cast_mixed_precision_params,
+    get_peft_model_state_dict,
+    load_peft_weights,
+    prepare_model_for_kbit_training,
+    replace_lora_weights_loftq,
+    set_peft_model_state_dict,
+    shift_tokens_right,
+)
+
+
+__all__ = [
+    "MODEL_TYPE_TO_PEFT_MODEL_MAPPING",
+    "PEFT_TYPE_TO_CONFIG_MAPPING",
+    "PEFT_TYPE_TO_MIXED_MODEL_MAPPING",
+    "PEFT_TYPE_TO_TUNER_MAPPING",
+    "TRANSFORMERS_MODELS_TO_PREFIX_TUNING_POSTPROCESS_MAPPING",
+    "AdaLoraConfig",
+    "AdaLoraModel",
+    "AdamssConfig",
+    "AdamssModel",
+    "AdaptionPromptConfig",
+    "AdaptionPromptModel",
+    "ArrowConfig",
+    "AutoPeftModel",
+    "AutoPeftModelForCausalLM",
+    "AutoPeftModelForFeatureExtraction",
+    "AutoPeftModelForQuestionAnswering",
+    "AutoPeftModelForSeq2SeqLM",
+    "AutoPeftModelForSequenceClassification",
+    "AutoPeftModelForTokenClassification",
+    "BOFTConfig",
+    "BOFTModel",
+    "BdLoraConfig",
+    "BeftConfig",
+    "BeftModel",
+    "C3AConfig",
+    "C3AModel",
+    "CPTConfig",
+    "CPTEmbedding",
+    "CartridgeConfig",
+    "CartridgeEncoder",
+    "DeftConfig",
+    "DeftModel",
+    "DeloraConfig",
+    "DeloraModel",
+    "EvaConfig",
+    "FourierFTConfig",
+    "FourierFTModel",
+    "FrodConfig",
+    "FrodModel",
+    "GloraConfig",
+    "GloraModel",
+    "GraloraConfig",
+    "GraloraModel",
+    "HRAConfig",
+    "HRAModel",
+    "HiraConfig",
+    "HiraModel",
+    "IA3Config",
+    "IA3Model",
+    "LNTuningConfig",
+    "LNTuningModel",
+    "LilyConfig",
+    "LilyModel",
+    "LoHaConfig",
+    "LoHaModel",
+    "LoKrConfig",
+    "LoKrModel",
+    "LoftQConfig",
+    "LoraConfig",
+    "LoraGAConfig",
+    "LoraModel",
+    "LoraRuntimeConfig",
+    "MissConfig",
+    "MissModel",
+    "MontecloraConfig",
+    "MultitaskPromptTuningConfig",
+    "MultitaskPromptTuningInit",
+    "OFTConfig",
+    "OFTModel",
+    "OSFConfig",
+    "OSFModel",
+    "PeanutConfig",
+    "PeanutModel",
+    "PeftConfig",
+    "PeftMixedModel",
+    "PeftModel",
+    "PeftModelForCausalLM",
+    "PeftModelForFeatureExtraction",
+    "PeftModelForQuestionAnswering",
+    "PeftModelForSeq2SeqLM",
+    "PeftModelForSequenceClassification",
+    "PeftModelForTokenClassification",
+    "PeftType",
+    "PeftWarning",
+    "PolyConfig",
+    "PolyModel",
+    "PrefixEncoder",
+    "PrefixTuningConfig",
+    "PromptEmbedding",
+    "PromptEncoder",
+    "PromptEncoderConfig",
+    "PromptEncoderReparameterizationType",
+    "PromptLearningConfig",
+    "PromptTuningConfig",
+    "PromptTuningInit",
+    "PsoftConfig",
+    "PsoftModel",
+    "PveraConfig",
+    "PveraModel",
+    "RandLoraConfig",
+    "RandLoraModel",
+    "RoadConfig",
+    "RoadModel",
+    "ShiraConfig",
+    "ShiraModel",
+    "TaskType",
+    "TinyLoraConfig",
+    "TinyLoraModel",
+    "TrainableTokensConfig",
+    "TrainableTokensModel",
+    "UniLoraConfig",
+    "UniLoraModel",
+    "VBLoRAConfig",
+    "VBLoRAModel",
+    "VeloraConfig",
+    "VeraConfig",
+    "VeraModel",
+    "WaveFTConfig",
+    "WaveFTModel",
+    "XLoraConfig",
+    "XLoraModel",
+    "bloom_model_postprocess_past_key_value",
+    "cast_mixed_precision_params",
+    "compose_cartridge_adapters",
+    "convert_to_lora",
+    "create_arrow_model",
+    "find_kappa_target_modules",
+    "get_eva_state_dict",
+    "get_layer_status",
+    "get_model_status",
+    "get_peft_config",
+    "get_peft_model",
+    "get_peft_model_state_dict",
+    "initialize_kv_prefix_from_past_key_values",
+    "initialize_kv_prefix_from_text",
+    "initialize_lora_eva_weights",
+    "inject_adapter_in_model",
+    "load_peft_weights",
+    "prepare_model_for_kbit_training",
+    "preprocess_loraga",
+    "prompt_embeddings_from_past_key_values",
+    "replace_lora_weights_loftq",
+    "save_as_lora",
+    "set_peft_model_state_dict",
+    "shift_tokens_right",
+]
diff --git a/src/peft/auto.py b/src/peft/auto.py
new file mode 100644
index 0000000..2cbe903
--- /dev/null
+++ b/src/peft/auto.py
@@ -0,0 +1,225 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+import importlib
+import os
+from typing import Optional
+
+from transformers import (
+    AutoModel,
+    AutoModelForCausalLM,
+    AutoModelForQuestionAnswering,
+    AutoModelForSeq2SeqLM,
+    AutoModelForSequenceClassification,
+    AutoModelForTokenClassification,
+    AutoTokenizer,
+)
+
+from .config import PeftConfig
+from .peft_model import (
+    PeftModel,
+    PeftModelForCausalLM,
+    PeftModelForFeatureExtraction,
+    PeftModelForQuestionAnswering,
+    PeftModelForSeq2SeqLM,
+    PeftModelForSequenceClassification,
+    PeftModelForTokenClassification,
+)
+from .utils.constants import TOKENIZER_CONFIG_NAME
+from .utils.other import check_file_exists_on_hf_hub
+
+
+MODEL_TYPE_TO_PEFT_MODEL_MAPPING: dict[str, type[PeftModel]] = {
+    "SEQ_CLS": PeftModelForSequenceClassification,
+    "SEQ_2_SEQ_LM": PeftModelForSeq2SeqLM,
+    "CAUSAL_LM": PeftModelForCausalLM,
+    "TOKEN_CLS": PeftModelForTokenClassification,
+    "QUESTION_ANS": PeftModelForQuestionAnswering,
+    "FEATURE_EXTRACTION": PeftModelForFeatureExtraction,
+}
+
+
+def get_default_import_allowlist():
+    return [
+        "diffusers",
+        "lerobot",
+        "megatron-core",
+        "transformers",
+    ]
+
+
+def check_import_allowlist(allowlist, parent_name):
+    """Ensure that the parent_name is in the allowlist or, at least, the prefix (e.g., "transformers.").
+    This is done because PEFT uses importlib.import_module on adapter config values. To prevent PEFT being used as a
+    means to execute code by importing a potentially malicious package (i.e. as a means to execute planted code), we
+    limit the possible packages to a known value.
+    """
+    if parent_name in allowlist:
+        return True
+
+    return any(parent_name.startswith(f"{allowed}.") for allowed in allowlist)
+
+
+class _BaseAutoPeftModel:
+    _target_class = None
+    _target_peft_class = None
+
+    def __init__(self, *args, **kwargs):
+        # For consistency with transformers: https://github.com/huggingface/transformers/blob/91d7df58b6537d385e90578dac40204cb550f706/src/transformers/models/auto/auto_factory.py#L400
+        raise EnvironmentError(  # noqa: UP024
+            f"{self.__class__.__name__} is designed to be instantiated "
+            f"using the `{self.__class__.__name__}.from_pretrained(pretrained_model_name_or_path)` or "
+            f"`{self.__class__.__name__}.from_config(config)` methods."
+        )
+
+    @classmethod
+    def from_pretrained(
+        cls,
+        pretrained_model_name_or_path,
+        adapter_name: str = "default",
+        is_trainable: bool = False,
+        config: Optional[PeftConfig] = None,
+        revision: Optional[str] = None,
+        import_allowlist: Optional[list[str]] = None,
+        **kwargs,
+    ):
+        r"""
+        A wrapper around all the preprocessing steps a user needs to perform in order to load a PEFT model. The kwargs
+        are passed along to `PeftConfig` that automatically takes care of filtering the kwargs of the Hub methods and
+        the config object init.
+
+        The parameters are equivalent to the ones of [`PeftModel.from_pretrained`]. Differences are documented below.
+
+        Args:
+            import_allowlist (`list[str]`, *optional*, defaults to `{get_default_import_allowlist()}`)
+                AutoPeftModel will attempt to instantiate the base model that is configured in the adapter config.
+                Since this operation needs to potentially import other packages, this allowlist is a safe-guard to
+                prevent importing malicious packages. You may need to specify your package's import name here if it is
+                not in the defaults.
+        """
+        peft_config = PeftConfig.from_pretrained(pretrained_model_name_or_path, revision=revision, **kwargs)
+        base_model_path = peft_config.base_model_name_or_path
+        base_model_revision = peft_config.revision
+
+        if import_allowlist is None:
+            import_allowlist = get_default_import_allowlist()
+
+        task_type = getattr(peft_config, "task_type", None)
+
+        if cls._target_class is not None:
+            target_class = cls._target_class
+        elif cls._target_class is None and task_type is not None:
+            # this is only in the case where we use `AutoPeftModel`
+            raise ValueError(
+                "Cannot use `AutoPeftModel` with a task type, please use a specific class for your task type. (e.g. `AutoPeftModelForCausalLM` for `task_type='CAUSAL_LM'`)"
+            )
+
+        if task_type is not None:
+            expected_target_class = MODEL_TYPE_TO_PEFT_MODEL_MAPPING[task_type]
+            if cls._target_peft_class.__name__ != expected_target_class.__name__:
+                raise ValueError(
+                    f"Expected target PEFT class: {expected_target_class.__name__}, but you have asked for: {cls._target_peft_class.__name__}"
+                    " make sure that you are loading the correct model for your task type."
+                )
+        elif task_type is None and getattr(peft_config, "auto_mapping", None) is not None:
+            auto_mapping = getattr(peft_config, "auto_mapping", None)
+            base_model_class = auto_mapping["base_model_class"]
+            parent_library_name = auto_mapping["parent_library"]
+
+            if not check_import_allowlist(import_allowlist, parent_library_name):
+                raise ValueError(
+                    f"The auto mapping wants to import '{parent_library_name}' which is not in the import allowlist. "
+                    "If you are sure that importing this library is safe, specify "
+                    f"`import_allowlist=['{parent_library_name}']` in `from_pretrained()`."
+                )
+
+            parent_library = importlib.import_module(parent_library_name)
+            target_class = getattr(parent_library, base_model_class)
+        else:
+            raise ValueError(
+                "Cannot infer the auto class from the config, please make sure that you are loading the correct model for your task type."
+            )
+
+        base_model = target_class.from_pretrained(base_model_path, revision=base_model_revision, **kwargs)
+
+        tokenizer_exists = False
+        if os.path.exists(os.path.join(pretrained_model_name_or_path, TOKENIZER_CONFIG_NAME)):
+            tokenizer_exists = True
+        else:
+            token = kwargs.get("token", None)
+            if token is None:
+                token = kwargs.get("use_auth_token", None)
+
+            tokenizer_exists = check_file_exists_on_hf_hub(
+                repo_id=pretrained_model_name_or_path,
+                filename=TOKENIZER_CONFIG_NAME,
+                revision=revision,
+                repo_type=kwargs.get("repo_type", None),
+                token=token,
+            )
+
+        if tokenizer_exists and hasattr(base_model, "get_input_embeddings"):
+            tokenizer = AutoTokenizer.from_pretrained(
+                pretrained_model_name_or_path, trust_remote_code=kwargs.get("trust_remote_code", False)
+            )
+            embedding_size = base_model.get_input_embeddings().weight.shape[0]
+            if len(tokenizer) > embedding_size:
+                # only resize if the tokenizer has a larger vocab size than there are embeddings
+                base_model.resize_token_embeddings(len(tokenizer))
+
+        return cls._target_peft_class.from_pretrained(
+            base_model,
+            pretrained_model_name_or_path,
+            adapter_name=adapter_name,
+            is_trainable=is_trainable,
+            config=config,
+            **kwargs,
+        )
+
+
+class AutoPeftModel(_BaseAutoPeftModel):
+    _target_class = None
+    _target_peft_class = PeftModel
+
+
+class AutoPeftModelForCausalLM(_BaseAutoPeftModel):
+    _target_class = AutoModelForCausalLM
+    _target_peft_class = PeftModelForCausalLM
+
+
+class AutoPeftModelForSeq2SeqLM(_BaseAutoPeftModel):
+    _target_class = AutoModelForSeq2SeqLM
+    _target_peft_class = PeftModelForSeq2SeqLM
+
+
+class AutoPeftModelForSequenceClassification(_BaseAutoPeftModel):
+    _target_class = AutoModelForSequenceClassification
+    _target_peft_class = PeftModelForSequenceClassification
+
+
+class AutoPeftModelForTokenClassification(_BaseAutoPeftModel):
+    _target_class = AutoModelForTokenClassification
+    _target_peft_class = PeftModelForTokenClassification
+
+
+class AutoPeftModelForQuestionAnswering(_BaseAutoPeftModel):
+    _target_class = AutoModelForQuestionAnswering
+    _target_peft_class = PeftModelForQuestionAnswering
+
+
+class AutoPeftModelForFeatureExtraction(_BaseAutoPeftModel):
+    _target_class = AutoModel
+    _target_peft_class = PeftModelForFeatureExtraction
diff --git a/src/peft/config.py b/src/peft/config.py
new file mode 100644
index 0000000..df28d9f
--- /dev/null
+++ b/src/peft/config.py
@@ -0,0 +1,408 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import importlib.metadata
+import inspect
+import json
+import os
+import warnings
+from dataclasses import asdict, dataclass, field
+from typing import Optional, Union
+
+import packaging.version
+from huggingface_hub import hf_hub_download
+from transformers.utils import PushToHubMixin, http_user_agent
+
+from peft import __version__
+
+from .utils import CONFIG_NAME, PeftType, TaskType
+
+
+# we expect at least these keys to be present in a PEFT adapter_config.json
+MIN_EXPECTED_CONFIG_KEYS = {"peft_type"}
+
+
+def _check_and_remove_unused_kwargs(cls, kwargs):
+    """Make PEFT configs forward-compatible by removing unused kwargs that were added in later PEFT versions.
+
+    This assumes that removing the unused kwargs will not affect the default behavior.
+
+    Returns the filtered kwargs and the set of removed keys.
+    """
+    # it's not pretty but eh
+    signature_parameters = inspect.signature(cls.__init__).parameters
+    unexpected_kwargs = set(kwargs.keys()) - set(signature_parameters.keys())
+    for key in unexpected_kwargs:
+        del kwargs[key]
+    return kwargs, unexpected_kwargs
+
+
+def _is_dev_version(version: str) -> bool:
+    # check if the given version is a dev version
+    return packaging.version.Version(version).dev is not None
+
+
+def _get_commit_hash(pkg_name: str) -> str | None:
+    # If PEFT was installed from a specific commit hash, try to get it. This works e.g. when installing PEFT with `pip
+    # install git+https://github.com/huggingface/peft.git@<HASH>`. This works not for other means, like editable
+    # installs.
+    try:
+        dist = importlib.metadata.distribution(pkg_name)
+    except importlib.metadata.PackageNotFoundError:
+        return None
+
+    # See: https://packaging.python.org/en/latest/specifications/direct-url/
+    for path in dist.files or []:
+        if path.name == "direct_url.json":
+            direct_url = json.loads((dist.locate_file(path)).read_text())
+            vcs_info = direct_url.get("vcs_info")
+            if vcs_info and "commit_id" in vcs_info:
+                return vcs_info["commit_id"]
+    return None
+
+
+@dataclass
+class PeftConfigMixin(PushToHubMixin):
+    r"""
+    This is the base configuration class for PEFT adapter models. It contains all the methods that are common to all
+    PEFT adapter models. This class inherits from [`~transformers.utils.PushToHubMixin`] which contains the methods to
+    push your model to the Hub. The method `save_pretrained` will save the configuration of your adapter model in a
+    directory. The method `from_pretrained` will load the configuration of your adapter model from a directory.
+
+    Args:
+        peft_type (Union[[`~peft.utils.config.PeftType`], `str`]): The type of Peft method to use.
+    """
+
+    task_type: Optional[TaskType] = field(default=None, metadata={"help": "The type of task."})
+    peft_type: Optional[PeftType] = field(default=None, metadata={"help": "The type of PEFT model."})
+    auto_mapping: Optional[dict] = field(
+        default=None, metadata={"help": "An auto mapping dict to help retrieve the base model class if needed."}
+    )
+    peft_version: Optional[str] = field(default=None, metadata={"help": "PEFT version, leave empty to auto-fill."})
+
+    def __post_init__(self):
+        # check for invalid task type
+        if (self.task_type is not None) and (self.task_type not in list(TaskType)):
+            raise ValueError(
+                f"Invalid task type: '{self.task_type}'. Must be one of the following task types: {', '.join(TaskType)}."
+            )
+        if self.peft_version is None:
+            self.peft_version = self._get_peft_version()
+
+    @staticmethod
+    def _get_peft_version() -> str:
+        # gets the current peft version; if it's a dev version, try to get the commit hash too, as the dev version is
+        # ambiguous
+        version = __version__
+        if not _is_dev_version(version):
+            return version
+
+        try:
+            git_hash = _get_commit_hash("peft")
+            if git_hash is None:
+                git_hash = "UNKNOWN"
+        except Exception:
+            # Broad exception: We never want to break user code just because the git_hash could not be determined
+            warnings.warn(
+                "A dev version of PEFT is used but there was an error while trying to determine the commit hash. "
+                "Please open an issue: https://github.com/huggingface/peft/issues"
+            )
+            git_hash = "UNKNOWN"
+        version = version + f"@{git_hash}"
+        return version
+
+    def to_dict(self) -> dict:
+        r"""
+        Returns the configuration for your adapter model as a dictionary.
+        """
+        return asdict(self)
+
+    def save_pretrained(self, save_directory: str, **kwargs) -> None:
+        r"""
+        This method saves the configuration of your adapter model in a directory.
+
+        Args:
+            save_directory (`str`):
+                The directory where the configuration will be saved.
+            kwargs (additional keyword arguments, *optional*):
+                Additional keyword arguments passed along to the [`~transformers.utils.PushToHubMixin.push_to_hub`]
+                method.
+        """
+        if os.path.isfile(save_directory):
+            raise AssertionError(f"Provided path ({save_directory}) should be a directory, not a file")
+
+        os.makedirs(save_directory, exist_ok=True)
+        auto_mapping_dict = kwargs.pop("auto_mapping_dict", None)
+
+        output_dict = self.to_dict()
+        # converting set type to list
+        for key, value in output_dict.items():
+            if isinstance(value, set):
+                output_dict[key] = list(value)
+
+        output_path = os.path.join(save_directory, CONFIG_NAME)
+
+        # Add auto mapping details for custom models.
+        if auto_mapping_dict is not None:
+            output_dict["auto_mapping"] = auto_mapping_dict
+
+        # save it
+        with open(output_path, "w") as writer:
+            writer.write(json.dumps(output_dict, indent=2, sort_keys=True))
+
+    @classmethod
+    def from_peft_type(cls, **kwargs):
+        r"""
+        This method loads the configuration of your adapter model from a set of kwargs.
+
+        The appropriate configuration type is determined by the `peft_type` argument. If `peft_type` is not provided,
+        the calling class type is instantiated.
+
+        Args:
+            kwargs (configuration keyword arguments):
+                Keyword arguments passed along to the configuration initialization.
+        """
+        # Avoid circular dependency .. TODO: fix this with a larger refactor
+        from peft.mapping import PEFT_TYPE_TO_CONFIG_MAPPING
+
+        # TODO: this hack is needed to fix the following issue (on commit 702f937):
+        # if someone saves a default config and loads it back with `PeftConfig` class it yields to
+        # not loading the correct config class.
+        #
+        # from peft import AdaLoraConfig, PeftConfig
+        # peft_config = AdaLoraConfig()
+        # print(peft_config)
+        # >>> AdaLoraConfig(peft_type=<PeftType.ADALORA: 'ADALORA'>, auto_mapping=None, base_model_name_or_path=None,
+        # revision=None, task_type=None, inference_mode=False, r=8, target_modules=None, lora_alpha=8, lora_dropout=0.0, ...
+        #
+        # peft_config.save_pretrained("./test_config")
+        # peft_config = PeftConfig.from_pretrained("./test_config")
+        # print(peft_config)
+        # >>> PeftConfig(peft_type='ADALORA', auto_mapping=None, base_model_name_or_path=None, revision=None, task_type=None, inference_mode=False)
+
+        if "peft_type" in kwargs:
+            peft_type = kwargs["peft_type"]
+            config_cls = PEFT_TYPE_TO_CONFIG_MAPPING[peft_type]
+        else:
+            config_cls = cls
+
+        try:
+            config = config_cls(**kwargs)
+        except TypeError as exc:
+            # Here we potentially handle forward compatibility. Sometimes new keywords are added to configs, which makes
+            # new configs incompatible with older PEFT versions. We catch these and remove them to allow the program to
+            # continue, but warn the user about it.
+
+            # First check if the error is due to unexpected keyword arguments, we don't want to accidentally catch
+            # other TypeErrors.
+            if "got an unexpected keyword argument" not in str(exc):
+                raise
+
+            filtered_kwargs, unexpected_kwargs = _check_and_remove_unused_kwargs(config_cls, kwargs)
+            if not MIN_EXPECTED_CONFIG_KEYS.issubset(set(filtered_kwargs.keys())):
+                raise TypeError(
+                    f"The {cls.__name__} config that is trying to be loaded is missing required keys: "
+                    f"{MIN_EXPECTED_CONFIG_KEYS}."
+                )
+
+            warnings.warn(
+                f"Unexpected keyword arguments {sorted(unexpected_kwargs)} for class {config_cls.__name__}, these are "
+                "ignored. This probably means that you're loading a configuration file that was saved using a "
+                "higher version of the library and additional parameters have been introduced since. It is "
+                "highly recommended to upgrade the PEFT version before continuing (e.g. by running `pip install "
+                "-U peft`)."
+            )
+            config = config_cls.from_peft_type(**filtered_kwargs)
+        return config
+
+    @classmethod
+    def from_pretrained(cls, pretrained_model_name_or_path: str, subfolder: Optional[str] = None, **kwargs):
+        r"""
+        This method loads the configuration of your adapter model from a directory.
+
+        Args:
+            pretrained_model_name_or_path (`str`):
+                The directory or the Hub repository id where the configuration is saved.
+            kwargs (additional keyword arguments, *optional*):
+                Additional keyword arguments passed along to the child class initialization.
+        """
+        path = (
+            os.path.join(pretrained_model_name_or_path, subfolder)
+            if subfolder is not None
+            else pretrained_model_name_or_path
+        )
+
+        hf_hub_download_kwargs, class_kwargs, _ = cls._split_kwargs(kwargs)
+        if "user_agent" not in hf_hub_download_kwargs:
+            hf_hub_download_kwargs["user_agent"] = http_user_agent()
+
+        if os.path.isfile(os.path.join(path, CONFIG_NAME)):
+            config_file = os.path.join(path, CONFIG_NAME)
+        else:
+            try:
+                config_file = hf_hub_download(
+                    pretrained_model_name_or_path, CONFIG_NAME, subfolder=subfolder, **hf_hub_download_kwargs
+                )
+            except Exception as exc:
+                raise ValueError(f"Can't find '{CONFIG_NAME}' at '{pretrained_model_name_or_path}'") from exc
+
+        loaded_attributes = cls.from_json_file(config_file)
+        kwargs = {**class_kwargs, **loaded_attributes}
+        kwargs = cls.check_kwargs(**kwargs)
+        return cls.from_peft_type(**kwargs)
+
+    @classmethod
+    def from_json_file(cls, path_json_file: str, **kwargs):
+        r"""
+        Loads a configuration file from a json file.
+
+        Args:
+            path_json_file (`str`):
+                The path to the json file.
+        """
+        with open(path_json_file) as file:
+            json_object = json.load(file)
+
+        # Sanity check that config does not contain a runtime_config
+        if "runtime_config" in json_object:
+            warnings.warn(
+                "The configuration file contains a `runtime_config` key. This is ignored. Runtime configurations are only valid at runtime."
+            )
+            del json_object["runtime_config"]
+
+        return json_object
+
+    @classmethod
+    def _split_kwargs(cls, kwargs):
+        hf_hub_download_kwargs = {}
+        class_kwargs = {}
+        other_kwargs = {}
+
+        for key, value in kwargs.items():
+            if key in inspect.signature(hf_hub_download).parameters:
+                hf_hub_download_kwargs[key] = value
+            elif key in list(cls.__annotations__):
+                class_kwargs[key] = value
+            else:
+                other_kwargs[key] = value
+
+        return hf_hub_download_kwargs, class_kwargs, other_kwargs
+
+    @classmethod
+    def _get_peft_type(
+        cls,
+        model_id: str,
+        **hf_hub_download_kwargs,
+    ):
+        subfolder = hf_hub_download_kwargs.get("subfolder", None)
+
+        path = os.path.join(model_id, subfolder) if subfolder is not None else model_id
+
+        if os.path.isfile(os.path.join(path, CONFIG_NAME)):
+            config_file = os.path.join(path, CONFIG_NAME)
+        else:
+            try:
+                config_file = hf_hub_download(
+                    model_id,
+                    CONFIG_NAME,
+                    **hf_hub_download_kwargs,
+                )
+            except Exception:
+                raise ValueError(f"Can't find '{CONFIG_NAME}' at '{model_id}'")
+
+        loaded_attributes = cls.from_json_file(config_file)
+        return loaded_attributes["peft_type"]
+
+    @classmethod
+    def check_kwargs(cls, **kwargs):
+        """Check kwargs before initializing the config instance.
+
+        Subclasses can override this method to add specific checks.
+
+        """
+        return kwargs
+
+    @property
+    def is_prompt_learning(self) -> bool:
+        r"""
+        Utility method to check if the configuration is for prompt learning.
+        """
+        return False
+
+    @property
+    def is_adaption_prompt(self) -> bool:
+        """Return True if this is an adaption prompt config."""
+        return False
+
+
+@dataclass
+class PeftConfig(PeftConfigMixin):
+    """
+    This is the base configuration class to store the configuration of a [`PeftModel`].
+
+    Args:
+        peft_type (Union[[`~peft.utils.config.PeftType`], `str`]): The type of Peft method to use.
+        task_type (Union[[`~peft.utils.config.TaskType`], `str`]): The type of task to perform.
+        inference_mode (`bool`, defaults to `False`): Whether to use the Peft model in inference mode.
+    """
+
+    base_model_name_or_path: Optional[str] = field(
+        default=None, metadata={"help": "The name of the base model to use."}
+    )
+    revision: Optional[str] = field(default=None, metadata={"help": "The specific base model version to use."})
+    peft_type: Optional[Union[str, PeftType]] = field(default=None, metadata={"help": "Peft type"})
+    task_type: Optional[Union[str, TaskType]] = field(default=None, metadata={"help": "Task type"})
+    inference_mode: bool = field(default=False, metadata={"help": "Whether to use inference mode"})
+
+
+@dataclass
+class PromptLearningConfig(PeftConfig):
+    """
+    This is the base configuration class to store the configuration of [`PrefixTuning`], [`PromptEncoder`], or
+    [`PromptTuning`].
+
+    Args:
+        num_virtual_tokens (`int`): The number of virtual tokens to use.
+        token_dim (`int`): The hidden embedding dimension of the base transformer model.
+        num_transformer_submodules (`int`): The number of transformer submodules in the base transformer model.
+        num_attention_heads (`int`): The number of attention heads in the base transformer model.
+        num_layers (`int`): The number of layers in the base transformer model.
+    """
+
+    num_virtual_tokens: int = field(default=None, metadata={"help": "Number of virtual tokens"})
+    token_dim: int = field(
+        default=None, metadata={"help": "The hidden embedding dimension of the base transformer model"}
+    )
+    num_transformer_submodules: Optional[int] = field(
+        default=None, metadata={"help": "Number of transformer submodules"}
+    )
+    num_attention_heads: Optional[int] = field(default=None, metadata={"help": "Number of attention heads"})
+    num_layers: Optional[int] = field(default=None, metadata={"help": "Number of transformer layers"})
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": "List of extra modules to be set as trainable and saved in the final checkpoint. "
+            "For example, in Sequence Classification or Token Classification tasks, "
+            "the final layer `classifier/score` are randomly initialized and as such need to be trainable and saved. "
+            "The module(s) will be fully fine-tuned."
+        },
+    )
+
+    @property
+    def is_prompt_learning(self) -> bool:
+        r"""
+        Utility method to check if the configuration is for prompt learning.
+        """
+        return True
diff --git a/src/peft/functional.py b/src/peft/functional.py
new file mode 100644
index 0000000..60df690
--- /dev/null
+++ b/src/peft/functional.py
@@ -0,0 +1,34 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+"""
+Functions that are useful for integration with non-PeftModel models, e.g. transformers or diffusers.
+
+The functions provided here can be considered "public API" of PEFT and hence are safe to be used by packages that
+provide PEFT integrations.
+"""
+
+from peft.mapping import inject_adapter_in_model
+from peft.tuners.tuners_utils import cast_adapter_dtype, delete_adapter, set_adapter, set_requires_grad
+from peft.utils import get_peft_model_state_dict, set_peft_model_state_dict
+
+
+__all__ = [
+    "cast_adapter_dtype",
+    "delete_adapter",
+    "get_peft_model_state_dict",
+    "inject_adapter_in_model",
+    "set_adapter",
+    "set_peft_model_state_dict",
+    "set_requires_grad",
+]
diff --git a/src/peft/helpers.py b/src/peft/helpers.py
new file mode 100644
index 0000000..2541e63
--- /dev/null
+++ b/src/peft/helpers.py
@@ -0,0 +1,577 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import inspect
+from contextlib import contextmanager
+from copy import deepcopy
+from functools import update_wrapper
+from types import MethodType
+from typing import Optional
+
+import torch
+from torch import nn
+
+
+try:
+    import bitsandbytes as bnb
+except ImportError:
+    bnb = None
+
+from tqdm.auto import tqdm
+
+from .peft_model import PeftConfig, PeftModel
+from .tuners.lora import LoraLayer, LoraModel, dora
+from .tuners.tuners_utils import BaseTunerLayer
+
+
+def update_forward_signature(model: PeftModel) -> None:
+    """
+    Updates the forward signature of the PeftModel to include parents class signature
+        model (`PeftModel`): Peft model to update the forward signature
+
+    Example:
+
+    ```python
+    >>> from transformers import WhisperForConditionalGeneration
+    >>> from peft import get_peft_model, LoraConfig
+    >>> from peft.helpers import update_forward_signature
+
+    >>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")
+    >>> peft_config = LoraConfig(r=8, lora_alpha=32, lora_dropout=0.1, target_modules=["q_proj", "v_proj"])
+
+    >>> peft_model = get_peft_model(model, peft_config)
+    >>> update_forward_signature(peft_model)
+    ```
+    """
+
+    # Only update signature when the current forward signature only has *args and **kwargs
+    current_signature = inspect.signature(model.forward)
+    if (
+        len(current_signature.parameters) == 2
+        and "args" in current_signature.parameters
+        and "kwargs" in current_signature.parameters
+    ):
+        forward = deepcopy(model.forward.__func__)
+        update_wrapper(
+            forward, type(model.get_base_model()).forward, assigned=("__doc__", "__name__", "__annotations__")
+        )
+        model.forward = MethodType(forward, model)
+
+
+def update_generate_signature(model: PeftModel) -> None:
+    """
+    Updates the generate signature of a PeftModel with overriding generate to include parents class signature
+        model (`PeftModel`): Peft model to update the generate signature
+
+    Example:
+
+    ```python
+    >>> from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
+    >>> from peft import get_peft_model, LoraConfig, TaskType
+    >>> from peft.helpers import update_generate_signature
+
+    >>> model_name_or_path = "bigscience/mt0-large"
+    >>> tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)
+    >>> model = AutoModelForSeq2SeqLM.from_pretrained(model_name_or_path)
+
+    >>> peft_config = LoraConfig(
+    ...     task_type=TaskType.SEQ_2_SEQ_LM, inference_mode=False, r=8, lora_alpha=32, lora_dropout=0.1
+    ... )
+    >>> peft_model = get_peft_model(model, peft_config)
+    >>> update_generate_signature(peft_model)
+    >>> help(peft_model.generate)
+    ```
+    """
+    if not hasattr(model, "generate"):
+        return
+    current_signature = inspect.signature(model.generate)
+    if (
+        len(current_signature.parameters) == 2
+        and "args" in current_signature.parameters
+        and "kwargs" in current_signature.parameters
+    ) or (len(current_signature.parameters) == 1 and "kwargs" in current_signature.parameters):
+        generate = deepcopy(model.generate.__func__)
+        update_wrapper(
+            generate,
+            type(model.get_base_model()).generate,
+            assigned=("__doc__", "__name__", "__annotations__"),
+        )
+        model.generate = MethodType(generate, model)
+
+
+def update_signature(model: PeftModel, method: str = "all") -> None:
+    """
+    Updates the signature of a PeftModel include parents class signature for forward or generate method
+        model (`PeftModel`): Peft model to update generate or forward signature method (`str`): method to update
+        signature choose one of "forward", "generate", "all"
+
+    Example:
+    ```python
+    >>> from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
+    >>> from peft import get_peft_model, LoraConfig, TaskType
+    >>> from peft.helpers import update_signature
+
+    >>> model_name_or_path = "bigscience/mt0-large"
+    >>> tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)
+    >>> model = AutoModelForSeq2SeqLM.from_pretrained(model_name_or_path)
+
+    >>> peft_config = LoraConfig(
+    ...     task_type=TaskType.SEQ_2_SEQ_LM, inference_mode=False, r=8, lora_alpha=32, lora_dropout=0.1
+    ... )
+    >>> peft_model = get_peft_model(model, peft_config)
+    >>> update_signature(peft_model)
+    >>> help(peft_model.generate)
+    ```
+    """
+    if method == "forward":
+        update_forward_signature(model)
+    elif method == "generate":
+        update_generate_signature(model)
+    elif method == "all":
+        update_forward_signature(model)
+        update_generate_signature(model)
+    else:
+        raise ValueError(f"method {method} is not supported please choose one of ['forward', 'generate', 'all']")
+
+
+def check_if_peft_model(model_name_or_path: str) -> bool:
+    """
+    Check if the model is a PEFT model.
+
+    Args:
+        model_name_or_path (`str`):
+            Model id to check, can be local or on the Hugging Face Hub.
+
+    Returns:
+        `bool`: True if the model is a PEFT model, False otherwise.
+    """
+    is_peft_model = True
+    try:
+        PeftConfig.from_pretrained(model_name_or_path)
+    except Exception:
+        # allow broad exceptions so that this works even if new exceptions are added on HF Hub side
+        is_peft_model = False
+
+    return is_peft_model
+
+
+@contextmanager
+def rescale_adapter_scale(model, multiplier):
+    """
+    Context manager to temporarily rescale the scaling of the LoRA adapter in a model.
+
+    The original scaling values are restored when the context manager exits. This context manager works with the
+    transformers and diffusers models that have directly loaded LoRA adapters.
+
+    For LoRA, applying this context manager with multiplier in [0, 1] is strictly equivalent to applying
+    [wise-ft](https://huggingface.co/papers/2109.01903) (see [#1940](https://github.com/huggingface/peft/issues/1940)
+    for details). It can improve the performances of the model if there is a distribution shiftbetween the training
+    data used for fine-tuning, and the test data used during inference.
+
+    Warning: It has been reported that when using Apple's MPS backend for PyTorch, it is necessary to add a short sleep
+        time after exiting the context before the scales are fully restored.
+
+    Args:
+        model: The model containing `LoraLayer` modules whose scaling is to be adjusted.
+        multiplier (float or int):
+            The multiplier that rescales the `scaling` attribute. Must be of type float or int.
+
+    Raises:
+        ValueError: If the model does not contain any `LoraLayer`
+            instances, indicating that the model does not support scaling.
+
+    Example:
+
+    ```python
+    >>> model = ModelWithLoraLayer()
+    >>> multiplier = 0.5
+    >>> with rescale_adapter_scale(model, multiplier):
+    ...     outputs = model(**inputs)  # Perform operations with the scaled model
+    >>> outputs = model(**inputs)  # The original scaling values are restored here
+    ```
+    """
+    # check if multiplier has a valid data type
+    if not isinstance(multiplier, (float, int)):
+        raise TypeError(f"Argument multiplier should be of type float, got {type(multiplier)}")
+
+    # iterate on the model's modules and grab the original scaling attribute
+    # from the lora layers if present
+    original_scaling = {}
+    for module in model.modules():
+        if isinstance(module, LoraLayer):
+            original_scaling[module] = module.scaling.copy()
+            module.scaling = {k: v * multiplier for k, v in module.scaling.items()}
+
+    # check whether scaling is prohibited on model
+    # the original scaling dictionary should be empty
+    # if there were no lora layers
+    if not original_scaling:
+        raise ValueError("scaling is only supported for models with `LoraLayer`s")
+    try:
+        yield
+
+    finally:
+        # restore original scaling values after exiting the context
+        for module, scaling in original_scaling.items():
+            module.scaling = scaling
+
+
+@contextmanager
+def disable_input_dtype_casting(model: nn.Module, active: bool = True):
+    """
+    Context manager disables input dtype casting to the dtype of the weight.
+
+    Parameters:
+        model (nn.Module):
+            The model containing PEFT modules whose input dtype casting is to be adjusted.
+        active (bool):
+            Whether the context manager is active (default) or inactive.
+
+    """
+    # Additional info: Normally, the dtype of the weight and input need to match, which is why the dtype is cast.
+    # However, in certain circumustances, this is handled by forward hooks, e.g. when using layerwise casting in
+    # diffusers. In that case, PEFT casting the dtype interferes with the layerwise casting, which is why the option to
+    # disable it is given.
+    if not active:
+        yield
+        return
+
+    original_values = {}
+    for name, module in model.named_modules():
+        if not isinstance(module, BaseTunerLayer):
+            continue
+        original_values[name] = module.cast_input_dtype_enabled
+        module.cast_input_dtype_enabled = False
+
+    try:
+        yield
+    finally:
+        for name, module in model.named_modules():
+            if not isinstance(module, BaseTunerLayer):
+                continue
+            if name in original_values:
+                module.cast_input_dtype_enabled = original_values[name]
+
+
+class MontecloraTrainerMixin:
+    """
+    Mixin class for adding Monteclora variational loss to the Trainer's compute_loss method.
+
+    This mixin can be used with any Trainer class (e.g., Trainer, SFTTrainer) to add support for Monteclora's
+    variational regularization during training.
+
+    Example:
+        ```python
+        from transformers import Trainer
+        from peft import get_peft_model, LoraConfig
+        from peft.helpers import MontecloraTrainerMixin
+
+
+        # custom trainer that supports Monteclora
+        class MontecloraTrainer(MontecloraTrainerMixin, Trainer):
+            pass
+
+
+        # Configure LoRA with Monteclora
+        monteclora_config = MontecloraConfig(
+            num_samples=8,
+            sample_scaler=1e-4,
+            kl_loss_weight=1e-5,
+        )
+        lora_config = LoraConfig(
+            r=16,
+            lora_alpha=32,
+            target_modules=["q_proj", "v_proj"],
+            monteclora_config=monteclora_config,
+        )
+
+        # Get PEFT model and train
+        model = get_peft_model(base_model, lora_config)
+        trainer = MontecloraTrainer(model=model, args=training_args)
+        trainer.train()
+        ```
+    """
+
+    def compute_loss(self, model, inputs, return_outputs=False, **kwargs):
+        """
+        Compute loss with Monteclora variational regularization.
+
+        This method extends the standard compute_loss by adding the variational loss (KL divergence + entropy) from
+        Monteclora samplers to the task loss.
+
+        Args:
+            model: The model being trained
+            inputs: Input batch
+            return_outputs: Whether to return model outputs along with loss
+            **kwargs: Additional arguments
+
+        Returns:
+            loss or (loss, outputs) depending on return_outputs
+        """
+        if return_outputs:
+            task_loss, outputs = super().compute_loss(model, inputs, return_outputs=True, **kwargs)
+        else:
+            task_loss = super().compute_loss(model, inputs, return_outputs=False, **kwargs)
+            outputs = None
+
+        # `_get_monteclora_loss` already normalizes by the number of samplers within a single LoraModel.
+        # In the typical case there is exactly one LoraModel (PeftModel.base_model) so this loop runs once
+        # and matches the original behavior. For unusual setups with multiple tuners we additionally average
+        # across the LoraModels so the regularization magnitude does not scale with the number of tuners.
+        # `_get_monteclora_loss` returns 0.0 when no MonteCLoRA samplers are present, so this is a no-op
+        # for plain LoRA training.
+        monteclora_loss = 0.0
+        num_lora_models = 0
+        for module in model.modules():
+            if isinstance(module, LoraModel):
+                monteclora_loss = monteclora_loss + module._get_monteclora_loss()
+                num_lora_models += 1
+        if num_lora_models > 1:
+            monteclora_loss = monteclora_loss / num_lora_models
+
+        total_loss = task_loss + monteclora_loss
+
+        return (total_loss, outputs) if return_outputs else total_loss
+
+
+class DoraCaching:
+    """Context manager to enable DoRA caching, which improves speed of DoRA inference at the expense of memory.
+
+    With active caching, the materialized LoRA weight (B @ A) and the weight norm (base weight + LoRA weight) are
+    cached.
+
+    Even within the caching context, if the model is in training mode, caching is disabled. When the model switches to
+    training mode, the cache will be cleared.
+
+    Example:
+
+        ```py
+        >>> from peft.helpers import DoraCaching
+
+        >>> model.eval()  # put in eval model for caching to work
+
+        >>> with DoraCaching():  # use as a context manager
+        ...     output = model(inputs)
+
+        >>> dora_caching = DoraCaching()
+        >>> dora_caching(enabled=True)  # permanently enable caching
+        >>> output = model(inputs)
+        >>> dora_caching(enabled=False)  # permanently disable caching
+        >>> output = model(inputs)
+        ```
+
+    """
+
+    def __init__(self, enabled: bool = True) -> None:
+        self.enabled = enabled
+        self.prev_value = None
+
+    def __enter__(self):
+        self.prev_value = dora.ENABLE_DORA_CACHING
+        dora.ENABLE_DORA_CACHING = self.enabled
+
+    def __exit__(self, type, value, traceback):
+        dora.ENABLE_DORA_CACHING = self.prev_value
+        self.prev_value = None
+
+    def __call__(self, enabled: bool = True):
+        dora.ENABLE_DORA_CACHING = enabled
+
+
+class KappaTuneSelector:
+    """
+    Lightweight utility to compute per-module / per-parameter condition numbers and return the best LoRA targets.
+
+    Supports:
+    - Classic nn.Linear modules (target_modules in LoraConfig)
+    - Modern fused MoE weights stored as 3D nn.Parameter (gate_up_proj / down_proj, gate_proj / up_proj, etc.) used in
+      Llama-4, Qwen2_MoE, Qwen3_MoE, Mixtral, OLMoE and similar models. These are returned via target_parameters.
+
+    Notes:
+    - Condition-number computation requires running SVD and can take several minutes on very large models. A progress
+    bar can be shown/disabled via `show_progress`.
+
+    """
+
+    def __init__(
+        self,
+        model: nn.Module,
+        max_dim_size_to_analyze: int = 16384,
+        moe_param_suffixes: Optional[tuple[str, ...]] = None,
+        show_progress: bool = True,
+    ):
+        self.model = model
+        self.max_dim_size_to_analyze = max_dim_size_to_analyze
+        self.show_progress = show_progress
+        self.moe_param_suffixes = moe_param_suffixes or (
+            ".gate_up_proj",
+            ".down_proj",
+            ".gate_proj",
+            ".up_proj",
+        )
+        self._condition_numbers: Optional[dict[str, float]] = None
+        self._parameter_condition_numbers: Optional[dict[str, float]] = None
+
+    def _compute_kappas(self) -> None:
+        if self._condition_numbers is not None:
+            return
+
+        # === 1. nn.Linear modules ===
+        condition_numbers: dict[str, float] = {}
+        linear_modules = [
+            (module_name, module)
+            for module_name, module in self.model.named_modules()
+            if isinstance(module, nn.Linear)
+        ]
+        linear_iter = (
+            tqdm(linear_modules, desc="Computing SVD (linear layers)", unit="layer")
+            if self.show_progress
+            else linear_modules
+        )
+        for module_name, module in linear_iter:
+            weight = module.weight
+            if bnb is not None:
+                if hasattr(weight, "quant_state"):  # 4-bit
+                    w = bnb.functional.dequantize_4bit(weight.data, weight.quant_state).float()
+                elif hasattr(weight, "state") and hasattr(weight.state, "CB"):  # int8
+                    w = bnb.functional.int8_vectorwise_dequant(weight.state.CB, weight.state.SCB).float()
+                else:
+                    w = weight.data.detach().float()
+            else:
+                w = weight.data.detach().float()
+
+            if any(dim > self.max_dim_size_to_analyze for dim in w.shape):
+                continue
+
+            S = torch.linalg.svdvals(w.view(w.size(0), -1))
+            kappa = (S[0] / (S[-1] + 1e-8)).item()
+            condition_numbers[module_name] = kappa
+
+        self._condition_numbers = condition_numbers
+
+        # === 2. fused MoE parameters (3D nn.Parameter) ===
+        parameter_condition_numbers: dict[str, float] = {}
+        moe_params = [
+            (param_name, param)
+            for param_name, param in self.model.named_parameters()
+            if any(param_name.endswith(s) for s in self.moe_param_suffixes) and param.dim() == 3
+        ]
+        moe_iter = (
+            tqdm(moe_params, desc="Computing SVD (MoE parameters)", unit="param") if self.show_progress else moe_params
+        )
+        for param_name, param in moe_iter:
+            w = param.data.detach().float()
+            num_experts, *expert_shape = w.shape
+
+            if any(dim > self.max_dim_size_to_analyze for dim in expert_shape):
+                continue
+
+            kappas = []
+            for expert_idx in range(num_experts):
+                expert_w = w[expert_idx]
+                S = torch.linalg.svdvals(expert_w)
+                kappa = (S[0] / (S[-1] + 1e-8)).item()
+                kappas.append(kappa)
+            kappa = sum(kappas) / len(kappas)
+            parameter_condition_numbers[param_name] = kappa
+
+        self._parameter_condition_numbers = parameter_condition_numbers
+
+    def get_best_targets(
+        self, top_p: Optional[float] = None, num_modules: Optional[int] = None, threshold: Optional[float] = None
+    ) -> list[str]:
+        self._compute_kappas()
+        if not self._condition_numbers:
+            return []
+
+        sorted_modules = sorted(self._condition_numbers.items(), key=lambda x: x[1])
+
+        if num_modules is not None:
+            k = min(num_modules, len(sorted_modules))
+            return [name for name, _ in sorted_modules[:k]]
+
+        if top_p is not None:
+            k = max(1, int(len(sorted_modules) * top_p))
+            return [name for name, _ in sorted_modules[:k]]
+
+        if threshold is not None:
+            return [name for name, kappa in sorted_modules if kappa <= threshold]
+
+        return [name for name, _ in sorted_modules]
+
+    def get_best_target_parameters(
+        self, top_p: Optional[float] = None, num_modules: Optional[int] = None, threshold: Optional[float] = None
+    ) -> list[str]:
+        self._compute_kappas()
+        if not self._parameter_condition_numbers:
+            return []
+
+        sorted_params = sorted(self._parameter_condition_numbers.items(), key=lambda x: x[1])
+
+        if num_modules is not None:
+            k = min(num_modules, len(sorted_params))
+            return [name for name, _ in sorted_params[:k]]
+
+        if top_p is not None:
+            k = max(1, int(len(sorted_params) * top_p))
+            return [name for name, _ in sorted_params[:k]]
+
+        if threshold is not None:
+            return [name for name, kappa in sorted_params if kappa <= threshold]
+
+        return [name for name, _ in sorted_params]
+
+
+def find_kappa_target_modules(
+    model: nn.Module,
+    top_p: float = 0.2,
+    max_dim_size_to_analyze: int = 16384,
+    moe_param_suffixes: Optional[tuple[str, ...]] = None,
+    show_progress: bool = True,
+) -> dict[str, Optional[list[str]]]:
+    """
+    One-liner convenience function for KappaTune target selection. Returns both target_modules and target_parameters.
+
+    Args:
+        model (nn.Module):
+            Base model whose weights will be analyzed for condition numbers.
+        top_p (float, optional):
+            Select the top fraction of candidate modules/parameters with the lowest condition numbers.
+        max_dim_size_to_analyze (int, optional):
+            Upper bound on the maximum matrix dimension analyzed via SVD. Defaults to 16384.
+        moe_param_suffixes (Optional[tuple[str, ...]], optional):
+            Parameter-name suffixes used to identify fused MoE tensors that should be returned via `target_parameters`.
+            If None, sensible defaults are used.
+        show_progress (bool, optional):
+            Whether to display a progress bar while computing condition numbers (SVD-based) across candidate
+            tensors/modules. Disable in CI or other non-interactive environments. Defaults to True.
+    """
+    selector = KappaTuneSelector(
+        model,
+        max_dim_size_to_analyze=max_dim_size_to_analyze,
+        moe_param_suffixes=moe_param_suffixes,
+        show_progress=show_progress,
+    )
+
+    target_modules = selector.get_best_targets(top_p=top_p)
+    target_parameters = selector.get_best_target_parameters(top_p=top_p)
+
+    # Return None when there are no MoE layers (PEFT convention)
+    if not target_parameters:
+        target_parameters = None
+
+    return {
+        "target_modules": target_modules,
+        "target_parameters": target_parameters,
+    }
diff --git a/src/peft/import_utils.py b/src/peft/import_utils.py
new file mode 100644
index 0000000..ff187a1
--- /dev/null
+++ b/src/peft/import_utils.py
@@ -0,0 +1,189 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+import importlib
+import importlib.metadata as importlib_metadata
+import platform
+from functools import lru_cache
+
+import packaging.version
+import torch
+import transformers
+
+
+is_transformers_ge_v5 = packaging.version.parse(transformers.__version__) >= packaging.version.parse("5.0.0.dev0")
+
+is_transformers_ge_v5_1_0 = packaging.version.parse(transformers.__version__) >= packaging.version.parse("5.1.0")
+
+is_transformers_ge_v5_4_0 = packaging.version.parse(transformers.__version__) >= packaging.version.parse("5.4.0")
+
+is_transformers_ge_v5_6_0 = packaging.version.parse(transformers.__version__) >= packaging.version.parse("5.6.0.dev0")
+
+is_transformers_le_4_53 = packaging.version.parse(transformers.__version__) < packaging.version.parse("4.54.0.dev0")
+
+
+@lru_cache
+def is_bnb_available() -> bool:
+    return importlib.util.find_spec("bitsandbytes") is not None
+
+
+@lru_cache
+def is_bnb_4bit_available() -> bool:
+    if not is_bnb_available():
+        return False
+
+    import bitsandbytes as bnb
+
+    return hasattr(bnb.nn, "Linear4bit")
+
+
+@lru_cache
+def is_gptqmodel_available() -> bool:
+    if importlib.util.find_spec("gptqmodel") is not None:
+        GPTQMODEL_MINIMUM_VERSION = packaging.version.parse("7.0.0")
+        OPTIMUM_MINIMUM_VERSION = packaging.version.parse("1.24.0")
+        version_gptqmodel = packaging.version.parse(importlib_metadata.version("gptqmodel"))
+        if GPTQMODEL_MINIMUM_VERSION <= version_gptqmodel:
+            if is_optimum_available():
+                try:
+                    version_optimum = packaging.version.parse(importlib_metadata.version("optimum"))
+                except importlib_metadata.PackageNotFoundError:
+                    # Same idea as in diffusers:
+                    # https://github.com/huggingface/diffusers/blob/9f06a0d1a4a998ac6a463c5be728c892f95320a8/src/diffusers/utils/import_utils.py#L351-L357
+                    # It's not clear under what circumstances `importlib_metadata.version("optimum")` can raise an error
+                    # even though `importlib.util.find_spec("optimum") is not None` but it has been observed, so adding
+                    # this for precaution. If we cannot detect it, we just optimistically assume it's high enough.
+                    return True
+
+                if OPTIMUM_MINIMUM_VERSION <= version_optimum:
+                    return True
+                else:
+                    raise ImportError(
+                        f"gptqmodel requires optimum version `{OPTIMUM_MINIMUM_VERSION}` or higher. Found version `{version_optimum}`, "
+                        f"but only versions above `{OPTIMUM_MINIMUM_VERSION}` are supported"
+                    )
+            else:
+                raise ImportError(
+                    f"gptqmodel requires optimum version `{OPTIMUM_MINIMUM_VERSION}` or higher to be installed."
+                )
+        else:
+            raise ImportError(
+                f"Found an incompatible version of gptqmodel. Found version `{version_gptqmodel}`, "
+                f"but only versions `{GPTQMODEL_MINIMUM_VERSION}` or higher are supported"
+            )
+
+
+@lru_cache
+def is_optimum_available() -> bool:
+    return importlib.util.find_spec("optimum") is not None
+
+
+@lru_cache
+def is_torch_tpu_available(check_device=True) -> bool:
+    "Checks if `torch_xla` is installed and potentially if a TPU is in the environment"
+    if importlib.util.find_spec("torch_xla") is not None:
+        if check_device:
+            # We need to check if `xla_device` can be found, will raise a RuntimeError if not
+            try:
+                import torch_xla.core.xla_model as xm
+
+                _ = xm.xla_device()
+                return True
+            except RuntimeError:
+                return False
+        return True
+    return False
+
+
+@lru_cache
+def is_aqlm_available() -> bool:
+    return importlib.util.find_spec("aqlm") is not None
+
+
+@lru_cache
+def is_eetq_available() -> bool:
+    return importlib.util.find_spec("eetq") is not None
+
+
+@lru_cache
+def is_hqq_available() -> bool:
+    return importlib.util.find_spec("hqq") is not None
+
+
+@lru_cache
+def is_inc_available() -> bool:
+    return importlib.util.find_spec("neural_compressor") is not None
+
+
+@lru_cache
+def is_torchao_available() -> bool:
+    if importlib.util.find_spec("torchao") is None:
+        return False
+
+    TORCHAO_MINIMUM_VERSION = packaging.version.parse("0.16.0")
+    try:
+        torchao_version = packaging.version.parse(importlib_metadata.version("torchao"))
+    except importlib_metadata.PackageNotFoundError:
+        # Same idea as in diffusers:
+        # https://github.com/huggingface/diffusers/blob/9f06a0d1a4a998ac6a463c5be728c892f95320a8/src/diffusers/utils/import_utils.py#L351-L357
+        # It's not clear under what circumstances `importlib_metadata.version("torchao")` can raise an error even
+        # though `importlib.util.find_spec("torchao") is not None` but it has been observed, so adding this for
+        # precaution.
+        return False
+
+    if torchao_version < TORCHAO_MINIMUM_VERSION:
+        raise ImportError(
+            f"Found an incompatible version of torchao. Found version {torchao_version}, "
+            f"but only versions above {TORCHAO_MINIMUM_VERSION} are supported"
+        )
+    return True
+
+
+@lru_cache
+def is_xpu_available(check_device=False) -> bool:
+    """
+    Checks if XPU acceleration is available and potentially if a XPU is in the environment
+    """
+
+    system = platform.system()
+    if system == "Darwin":
+        return False
+    else:
+        if check_device:
+            try:
+                # Will raise a RuntimeError if no XPU is found
+                _ = torch.xpu.device_count()
+                return torch.xpu.is_available()
+            except RuntimeError:
+                return False
+        return hasattr(torch, "xpu") and torch.xpu.is_available()
+
+
+@lru_cache
+def is_diffusers_available() -> bool:
+    return importlib.util.find_spec("diffusers") is not None
+
+
+@lru_cache
+def is_te_available() -> bool:
+    return importlib.util.find_spec("transformer_engine") is not None
+
+
+@lru_cache
+def is_te_pytorch_available() -> bool:
+    if not is_te_available():
+        return False
+
+    import transformer_engine
+
+    return hasattr(transformer_engine, "pytorch")
diff --git a/src/peft/mapping.py b/src/peft/mapping.py
new file mode 100644
index 0000000..82c6ec1
--- /dev/null
+++ b/src/peft/mapping.py
@@ -0,0 +1,92 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Optional
+
+import torch
+
+from .utils import PeftType
+
+
+if TYPE_CHECKING:
+    from .config import PeftConfig
+    from .tuners.tuners_utils import BaseTuner
+
+
+# these will be filled by the register_peft_method function
+PEFT_TYPE_TO_CONFIG_MAPPING: dict[PeftType, type[PeftConfig]] = {}
+PEFT_TYPE_TO_TUNER_MAPPING: dict[PeftType, type[BaseTuner]] = {}
+PEFT_TYPE_TO_MIXED_MODEL_MAPPING: dict[PeftType, type[BaseTuner]] = {}
+PEFT_TYPE_TO_PREFIX_MAPPING: dict[PeftType, str] = {}
+
+
+def get_peft_config(config_dict: dict[str, Any]) -> PeftConfig:
+    """
+    Returns a Peft config object from a dictionary.
+
+    Args:
+        config_dict (`Dict[str, Any]`): Dictionary containing the configuration parameters.
+    """
+
+    return PEFT_TYPE_TO_CONFIG_MAPPING[config_dict["peft_type"]](**config_dict)
+
+
+def inject_adapter_in_model(
+    peft_config: PeftConfig,
+    model: torch.nn.Module,
+    adapter_name: str = "default",
+    low_cpu_mem_usage: bool = False,
+    state_dict: Optional[dict[str, torch.Tensor]] = None,
+) -> torch.nn.Module:
+    r"""
+    Create PEFT layers and inject them into the model in-place.
+
+    Currently the API does not support prompt learning methods and adaption prompt.
+
+    This function is similar to [`get_peft_model`] but it does not return a [`PeftModel`] instance. Instead, it returns
+    the original, mutated instance of the passed model.
+
+    Args:
+        peft_config (`PeftConfig`):
+            Configuration object containing the parameters of the PEFT model.
+        model (`torch.nn.Module`):
+            The input model where the adapter will be injected.
+        adapter_name (`str`, `optional`, defaults to `"default"`):
+            The name of the adapter to be injected, if not provided, the default adapter name is used ("default").
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            Create empty adapter weights on meta device. Useful to speed up the loading process.
+        state_dict (`dict`, *optional*, defaults to `None`)
+            If a `state_dict` is passed here, the adapters will be injected based on the entries of the state_dict.
+            This can be useful when the exact `target_modules` of the PEFT method is unknown, for instance because the
+            checkpoint was created without meta data. Note that the values from the `state_dict` are not used, only the
+            keys are used to determine the correct layers that should be adapted.
+    """
+    if peft_config.is_prompt_learning or peft_config.is_adaption_prompt:
+        raise ValueError("`create_and_replace` does not support prompt learning and adaption prompt yet.")
+
+    if peft_config.peft_type not in PEFT_TYPE_TO_TUNER_MAPPING.keys():
+        raise ValueError(
+            f"`inject_adapter_in_model` does not support {peft_config.peft_type} yet. Please use `get_peft_model`."
+        )
+
+    tuner_cls = PEFT_TYPE_TO_TUNER_MAPPING[peft_config.peft_type]
+
+    # By instantiating a peft model we are injecting randomly initialized LoRA layers into the model's modules.
+    peft_model = tuner_cls(
+        model, peft_config, adapter_name=adapter_name, low_cpu_mem_usage=low_cpu_mem_usage, state_dict=state_dict
+    )
+
+    return peft_model.model
diff --git a/src/peft/mapping_func.py b/src/peft/mapping_func.py
new file mode 100644
index 0000000..fae6718
--- /dev/null
+++ b/src/peft/mapping_func.py
@@ -0,0 +1,128 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+import warnings
+from typing import Optional
+
+from transformers import PreTrainedModel
+
+from .auto import MODEL_TYPE_TO_PEFT_MODEL_MAPPING
+from .config import PeftConfig
+from .mapping import PEFT_TYPE_TO_CONFIG_MAPPING, PEFT_TYPE_TO_PREFIX_MAPPING
+from .mixed_model import PeftMixedModel
+from .peft_model import PeftModel
+from .tuners.tuners_utils import BaseTuner, BaseTunerLayer
+
+
+def get_peft_model(
+    model: PreTrainedModel,
+    peft_config: PeftConfig,
+    adapter_name: str = "default",
+    mixed: bool = False,
+    autocast_adapter_dtype: bool = True,
+    revision: Optional[str] = None,
+    low_cpu_mem_usage: bool = False,
+) -> PeftModel | PeftMixedModel:
+    """
+    Returns a Peft model object from a model and a config, where the model will be modified in-place.
+
+    Args:
+        model ([`transformers.PreTrainedModel`]):
+            Model to be wrapped.
+        peft_config ([`PeftConfig`]):
+            Configuration object containing the parameters of the Peft model.
+        adapter_name (`str`, `optional`, defaults to `"default"`):
+            The name of the adapter to be injected, if not provided, the default adapter name is used ("default").
+        mixed (`bool`, `optional`, defaults to `False`):
+            Whether to allow mixing different (compatible) adapter types.
+        autocast_adapter_dtype (`bool`, *optional*):
+            Whether to autocast the adapter dtype. Defaults to `True`. Right now, this will only cast adapter weights
+            using float16 or bfloat16 to float32, as this is typically required for stable training, and only affect
+            select PEFT tuners.
+        revision (`str`, `optional`, defaults to `main`):
+            The revision of the base model. If this isn't set, the saved peft model will load the `main` revision for
+            the base model
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            Create empty adapter weights on meta device. Useful to speed up the loading process. Leave this setting as
+            False if you intend on training the model, unless the adapter weights will be replaced by different weights
+            before training starts.
+    """
+    model_config = BaseTuner.get_model_config(model)
+    old_name = peft_config.base_model_name_or_path
+    new_name = model.__dict__.get("name_or_path", None)
+    peft_config.base_model_name_or_path = new_name
+
+    # Especially in notebook environments there could be a case that a user wants to experiment with different
+    # configuration values. However, it is likely that there won't be any changes for new configs on an already
+    # initialized PEFT model. The best we can do is warn the user about it.
+    if any(isinstance(module, BaseTunerLayer) for module in model.modules()):
+        warnings.warn(
+            "You are trying to modify a model with PEFT for a second time. If you want to reload the model with a "
+            "different config, make sure to call `.unload()` before."
+        )
+
+    if (old_name is not None) and (old_name != new_name):
+        warnings.warn(
+            f"The PEFT config's `base_model_name_or_path` was renamed from '{old_name}' to '{new_name}'. "
+            "Please ensure that the correct base model is loaded when loading this checkpoint."
+        )
+
+    if revision is not None:
+        if peft_config.revision is not None and peft_config.revision != revision:
+            warnings.warn(
+                f"peft config has already set base model revision to {peft_config.revision}, overwriting with revision {revision}"
+            )
+        peft_config.revision = revision
+
+    if (
+        (isinstance(peft_config, PEFT_TYPE_TO_CONFIG_MAPPING["LORA"]))
+        and (peft_config.init_lora_weights == "eva")
+        and not low_cpu_mem_usage
+    ):
+        warnings.warn(
+            "lora with eva initialization used with low_cpu_mem_usage=False. "
+            "Setting low_cpu_mem_usage=True can improve the maximum batch size possible for eva initialization."
+        )
+
+    prefix = PEFT_TYPE_TO_PREFIX_MAPPING.get(peft_config.peft_type)
+    if prefix and adapter_name in prefix:
+        warnings.warn(
+            f"Adapter name '{adapter_name}' should not be contained in the prefix '{prefix}'. "
+            "This may lead to reinitialization of the adapter weights during loading."
+        )
+
+    if mixed:
+        # note: PeftMixedModel does not support autocast_adapter_dtype, so don't pass it
+        return PeftMixedModel(model, peft_config, adapter_name=adapter_name)
+
+    # We explicitly exclude prompt learning here since prompt learning is specific to the task and needs special
+    # handling in the PEFT model's forward method.
+    if peft_config.task_type not in MODEL_TYPE_TO_PEFT_MODEL_MAPPING.keys() and not peft_config.is_prompt_learning:
+        return PeftModel(
+            model,
+            peft_config,
+            adapter_name=adapter_name,
+            autocast_adapter_dtype=autocast_adapter_dtype,
+            low_cpu_mem_usage=low_cpu_mem_usage,
+        )
+
+    return MODEL_TYPE_TO_PEFT_MODEL_MAPPING[peft_config.task_type](
+        model,
+        peft_config,
+        adapter_name=adapter_name,
+        autocast_adapter_dtype=autocast_adapter_dtype,
+        low_cpu_mem_usage=low_cpu_mem_usage,
+    )
diff --git a/src/peft/mixed_model.py b/src/peft/mixed_model.py
new file mode 100644
index 0000000..26409a6
--- /dev/null
+++ b/src/peft/mixed_model.py
@@ -0,0 +1,473 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+import os
+from contextlib import contextmanager
+from typing import Any, Optional, Union
+
+import torch
+from accelerate.hooks import remove_hook_from_submodules
+from torch import nn
+from transformers.utils import PushToHubMixin
+
+from peft.utils.constants import DUMMY_MODEL_CONFIG
+
+from .config import PeftConfig
+from .peft_model import PeftModel
+from .tuners import MixedModel
+from .utils import _set_adapter, _set_trainable
+
+
+def _prepare_model_for_gradient_checkpointing(model: nn.Module) -> None:
+    r"""
+    Prepares the model for gradient checkpointing if necessary
+    """
+    # Note: same as PeftModel._prepare_model_for_gradient_checkpointing
+    if not getattr(model, "is_gradient_checkpointing", True):
+        return model
+
+    if not (
+        getattr(model, "is_loaded_in_8bit", False)
+        or getattr(model, "is_loaded_in_4bit", False)
+        or getattr(model, "is_quantized", False)
+    ):
+        if hasattr(model, "enable_input_require_grads"):
+            model.enable_input_require_grads()
+        elif hasattr(model, "get_input_embeddings"):
+
+            def make_inputs_require_grad(module, input, output):
+                output.requires_grad_(True)
+
+            model.get_input_embeddings().register_forward_hook(make_inputs_require_grad)
+
+
+def _check_config_compatible(peft_config: PeftConfig) -> None:
+    from .tuners.mixed import COMPATIBLE_TUNER_TYPES
+
+    if peft_config.peft_type not in COMPATIBLE_TUNER_TYPES:
+        raise ValueError(
+            f"The provided `peft_type` '{peft_config.peft_type.value}' is not compatible with the `PeftMixedModel`. "
+            f"Compatible types are: {COMPATIBLE_TUNER_TYPES}"
+        )
+
+
+class PeftMixedModel(PushToHubMixin, torch.nn.Module):
+    """
+    PeftMixedModel for loading mixing different types of adapters for inference.
+
+    This class does not support loading/saving, and it shouldn't usually be initialized directly. Instead, use
+    `get_peft_model` with the argument `mixed=True`.
+
+    > [!TIP] > Read the [Mixed adapter types](https://huggingface.co/docs/peft/en/developer_guides/mixed_models) guide
+    to learn > more about using different adapter types.
+
+    Example:
+
+    ```py
+    >>> base_model = ...  # load the base model, e.g. from transformers
+    >>> peft_model = PeftMixedModel.from_pretrained(base_model, path_to_adapter1, "adapter1").eval()
+    >>> peft_model.load_adapter(path_to_adapter2, "adapter2")
+    >>> peft_model.set_adapter(["adapter1", "adapter2"])  # activate both adapters
+    >>> peft_model(data)  # forward pass using both adapters
+    ```
+
+    Args:
+        model (`torch.nn.Module`):
+            The model to be tuned.
+        config (`PeftConfig`):
+            The config of the model to be tuned. The adapter type must be compatible.
+        adapter_name (`str`, `optional`, defaults to `"default"`):
+            The name of the first adapter.
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            Create empty adapter weights on meta device. Useful to speed up the loading process.
+    """
+
+    def __init__(self, model: nn.Module, peft_config: PeftConfig, adapter_name: str = "default") -> None:
+        super().__init__()
+        _check_config_compatible(peft_config)
+        _prepare_model_for_gradient_checkpointing(model)
+        self.modules_to_save = None
+        self.base_model = MixedModel(model, {adapter_name: peft_config}, adapter_name)
+        self.set_modules_to_save(peft_config, adapter_name)
+
+        self.config = getattr(model, "config", DUMMY_MODEL_CONFIG)
+
+        # the `pretraining_tp` is set for some models to simulate Tensor Parallelism during inference to avoid
+        # numerical differences, https://github.com/pytorch/pytorch/issues/76232 - to avoid any unexpected
+        # behavior we disable that in this line.
+        if hasattr(self.base_model, "config") and hasattr(self.base_model.config, "pretraining_tp"):
+            self.base_model.config.pretraining_tp = 1
+
+    @property
+    def peft_config(self) -> dict[str, PeftConfig]:
+        return self.base_model.peft_config
+
+    @property
+    def active_adapter(self) -> str:
+        return self.base_model.active_adapter
+
+    @property
+    def active_adapters(self) -> list[str]:
+        return self.base_model.active_adapters
+
+    def get_nb_trainable_parameters(self):
+        r"""
+        Returns the number of trainable parameters and number of all parameters in the model.
+        """
+        # note: same as PeftModel.get_nb_trainable_parameters
+        trainable_params = 0
+        all_param = 0
+        for _, param in self.named_parameters():
+            num_params = param.numel()
+            # if using DS Zero 3 and the weights are initialized empty
+            if num_params == 0 and hasattr(param, "ds_numel"):
+                num_params = param.ds_numel
+
+            # Due to the design of 4bit linear layers from bitsandbytes
+            # one needs to multiply the number of parameters by 2 to get
+            # the correct number of parameters
+            if param.__class__.__name__ == "Params4bit":
+                num_params = num_params * 2
+
+            all_param += num_params
+            if param.requires_grad:
+                trainable_params += num_params
+
+        return trainable_params, all_param
+
+    def print_trainable_parameters(self):
+        """
+        Prints the number of trainable parameters in the model.
+
+        Note: print_trainable_parameters() uses get_nb_trainable_parameters() which is different from
+        num_parameters(only_trainable=True) from huggingface/transformers. get_nb_trainable_parameters() returns
+        (trainable parameters, all parameters) of the Peft Model which includes modified backbone transformer model.
+        For techniques like LoRA, the backbone transformer model is modified in place with LoRA modules. However, for
+        prompt tuning, the backbone transformer model is unmodified. num_parameters(only_trainable=True) returns number
+        of trainable parameters of the backbone transformer model which can be different.
+        """
+        # note: same as PeftModel.print_trainable_parameters
+        trainable_params, all_param = self.get_nb_trainable_parameters()
+
+        print(
+            f"trainable params: {trainable_params:,d} || "
+            f"all params: {all_param:,d} || "
+            f"trainable%: {100 * trainable_params / all_param:.4f}"
+        )
+
+    def __getattr__(self, name: str):
+        """Forward missing attributes to the wrapped module."""
+        try:
+            return super().__getattr__(name)  # defer to nn.Module's logic
+        except AttributeError:
+            if name == "base_model":  # see #1892: prevent infinite recursion if class is not initialized
+                raise
+            return getattr(self.base_model, name)
+
+    def forward(self, *args: Any, **kwargs: Any):
+        """
+        Forward pass of the model.
+        """
+        return self.base_model(*args, **kwargs)
+
+    def generate(self, *args: Any, **kwargs: Any):
+        """
+        Generate output.
+        """
+        return self.base_model.generate(*args, **kwargs)
+
+    @contextmanager
+    def disable_adapter(self):
+        """
+        Disables the adapter module.
+        """
+        try:
+            self.base_model.disable_adapter_layers()
+            yield
+        finally:
+            self.base_model.enable_adapter_layers()
+
+    def add_adapter(
+        self,
+        adapter_name: str,
+        peft_config: PeftConfig,
+        low_cpu_mem_usage: bool = False,
+        autocast_adapter_dtype: bool = True,
+    ) -> None:
+        """
+        Add an adapter to the model based on the passed configuration.
+
+        This adapter is not trained. To load a trained adapter, check out [`PeftModel.load_adapter`].
+
+        The name for the new adapter should be unique.
+
+        The new adapter is not automatically set as the active adapter. Use [`PeftModel.set_adapter`] to set the active
+        adapter.
+
+        Args:
+            adapter_name (`str`):
+                The name of the adapter to be added.
+            peft_config ([`PeftConfig`]):
+                The configuration of the adapter to be added.
+            low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+                Create empty adapter weights on meta device. Useful to speed up the process when loading saved
+                adapters.
+
+                > [!TIP] > Don't use `low_cpu_mem_usage=True` when creating a new PEFT adapter for training (training
+                is untested > and discouraged for PeftMixedModel in general).
+            autocast_adapter_dtype (`bool`, *optional*, defaults to `True`):
+                Whether to autocast the adapter dtype. Defaults to `True`. Right now, this will only cast adapter
+                weights using float16 and bfloat16 to float32, as this is typically required for stable training, and
+                only affect select PEFT tuners. If set to `False`, the dtypes will stay the same as those of the
+                corresponding layer.
+        """
+        _check_config_compatible(peft_config)
+
+        try:
+            self.peft_config[adapter_name] = peft_config
+            self.base_model.inject_adapter(self, adapter_name, low_cpu_mem_usage=low_cpu_mem_usage)
+        except Exception:  # something went wrong, roll back
+            if adapter_name in self.peft_config:
+                del self.peft_config[adapter_name]
+            raise
+
+        self.base_model._cast_adapter_dtype(adapter_name=adapter_name, autocast_adapter_dtype=autocast_adapter_dtype)
+
+        self.set_modules_to_save(peft_config, adapter_name)
+
+    def set_modules_to_save(self, peft_config: PeftConfig, adapter_name: str) -> None:
+        if (modules_to_save := getattr(peft_config, "modules_to_save", None)) is None:
+            return
+
+        if self.modules_to_save is None:
+            self.modules_to_save = set(modules_to_save)
+        else:
+            self.modules_to_save.update(modules_to_save)
+        _set_trainable(
+            self,
+            adapter_name,
+            module_names=getattr(peft_config, "modules_to_save", None),
+            inference_mode=peft_config.inference_mode,
+        )
+
+    def set_adapter(self, adapter_name: Union[str, list[str]], inference_mode: bool = False) -> None:
+        """
+        Sets the active adapter(s) for the model.
+
+        Note that the order in which the adapters are applied during the forward pass may not be the same as the order
+        in which they are passed to this function. Instead, the order during the forward pass is determined by the
+        order in which the adapters were loaded into the model. The active adapters only determine which adapters are
+        active during the forward pass, but not the order in which they are applied.
+
+        Additionally, this function will set the specified adapter to trainable (i.e., requires_grad=True) unless
+        inference_mode is True.
+
+        Args:
+            adapter_name (str, list[str]):
+                The name(s) of the adapter(s) to set as active
+            inference_mode (bool, optional):
+                 Whether the activated adapter should be frozen (i.e. `requires_grad=False`). Default is False.
+        """
+        if isinstance(adapter_name, str):
+            adapter_name = [adapter_name]
+
+        mismatched = set(adapter_name) - set(self.peft_config.keys())
+        if mismatched:
+            raise ValueError(
+                f"Adapter(s) {sorted(mismatched)} not found, available adapters: {sorted(self.peft_config.keys())}"
+            )
+
+        self.base_model.set_adapter(adapter_name, inference_mode=inference_mode)
+        _set_adapter(self, adapter_name, inference_mode=inference_mode)
+
+    def delete_adapter(self, adapter_name: Union[str, list[str]]) -> None:
+        if isinstance(adapter_name, str):
+            adapter_name = [adapter_name]
+
+        mismatched = set(adapter_name) - set(self.peft_config.keys())
+        if mismatched:
+            raise ValueError(
+                f"Adapter(s) {sorted(mismatched)} not found, available adapters: {sorted(self.peft_config.keys())}"
+            )
+
+        self.base_model.delete_adapter(adapter_name)
+
+    def merge_and_unload(self, *args: Any, **kwargs: Any):
+        r"""
+        This method merges the adapter layers into the base model. This is needed if someone wants to use the base
+        model as a standalone model.
+
+        Args:
+            progressbar (`bool`):
+                whether to show a progressbar indicating the unload and merge process
+            safe_merge (`bool`):
+                whether to activate the safe merging check to check if there is any potential Nan in the adapter
+                weights
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        return self.base_model.merge_and_unload(*args, **kwargs)
+
+    def unload(self, *args: Any, **kwargs: Any):
+        """
+        Gets back the base model by removing all the adapter modules without merging. This gives back the original base
+        model.
+        """
+        return self.base_model.unload(*args, **kwargs)
+
+    def get_layer_status(self):
+        raise TypeError(f"get_layer_status is not supported for {self.__class__.__name__}.")
+
+    def get_model_status(self):
+        raise TypeError(f"get_model_status is not supported for {self.__class__.__name__}.")
+
+    @classmethod
+    def _split_kwargs(cls, kwargs: dict[str, Any]):
+        return PeftModel._split_kwargs(kwargs)
+
+    def _check_new_adapter_config(self, peft_config: PeftConfig, is_trainable: bool) -> None:
+        return PeftModel._check_new_adapter_config(self, peft_config, is_trainable=is_trainable)
+
+    def load_adapter(self, model_id: str, adapter_name: str, *args: Any, **kwargs: Any):
+        """
+        Load a trained adapter into the model.
+
+        The name for the new adapter should be unique.
+
+        The new adapter is not automatically set as the active adapter. Use [`PeftModel.set_adapter`] to set the active
+        adapter.
+
+        Args:
+            adapter_name (`str`):
+                The name of the adapter to be added.
+            peft_config ([`PeftConfig`]):
+                The configuration of the adapter to be added.
+            is_trainable (`bool`, *optional*, defaults to `False`):
+                Whether the adapter should be trainable or not. If `False`, the adapter will be frozen and can only be
+                used for inference.
+            torch_device (`str`, *optional*, defaults to None):
+                The device to load the adapter on. If `None`, the device will be inferred.
+            autocast_adapter_dtype (`bool`, *optional*, defaults to `True`):
+                Whether to autocast the adapter dtype. Defaults to `True`. Right now, this will only cast adapter
+                weights using float16 and bfloat16 to float32, as this is typically required for stable training, and
+                only affect select PEFT tuners.
+            ephemeral_gpu_offload (`bool`, *optional*, defaults to `False`):
+                Whether to use ephemeral GPU offloading for partially loaded modules. Defaults to `False`.
+            low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+                Create empty adapter weights on meta device before loading the saved weights. Useful to speed up the
+                process.
+            kwargs: (`optional`):
+                Additional arguments to modify the way the adapter is loaded, e.g. the token for Hugging Face Hub.
+        """
+        # the low_cpu_mem_usage option is handled through kwargs
+        output = PeftModel.load_adapter(self, model_id, adapter_name, *args, **kwargs)
+        # TODO: not quite clear why this is necessary but tests fail without it
+        self.set_adapter(self.active_adapters)
+        return output
+
+    def create_or_update_model_card(self, output_dir: str):
+        raise NotImplementedError(f"Model card creation is not supported for {self.__class__.__name__} (yet).")
+
+    def save_pretrained(
+        self,
+        save_directory: str,
+        safe_serialization: bool = False,
+        selected_adapters: Optional[list[str]] = None,
+        **kwargs: Any,
+    ):
+        raise NotImplementedError(f"Saving is not supported for {self.__class__.__name__} (yet).")
+
+    @classmethod
+    def from_pretrained(
+        cls,
+        model: nn.Module,
+        model_id: str | os.PathLike,
+        adapter_name: str = "default",
+        is_trainable: bool = False,
+        config: Optional[PeftConfig] = None,
+        **kwargs: Any,
+    ):
+        r"""
+        Instantiate a PEFT mixed model from a pretrained model and loaded PEFT weights.
+
+        Note that the passed `model` may be modified inplace.
+
+        Args:
+            model (`nn.Module`):
+                The model to be adapted.
+            model_id (`str` or `os.PathLike`):
+                The name of the PEFT configuration to use. Can be either:
+                    - A string, the `model id` of a PEFT configuration hosted inside a model repo on the Hugging Face
+                      Hub.
+                    - A path to a directory containing a PEFT configuration file saved using the `save_pretrained`
+                      method (`./my_peft_config_directory/`).
+            adapter_name (`str`, *optional*, defaults to `"default"`):
+                The name of the adapter to be loaded. This is useful for loading multiple adapters.
+            is_trainable (`bool`, *optional*, defaults to `False`):
+                Whether the adapter should be trainable or not. If `False`, the adapter will be frozen and use for
+                inference
+            config ([`~peft.PeftConfig`], *optional*):
+                The configuration object to use instead of an automatically loaded configuration. This configuration
+                object is mutually exclusive with `model_id` and `kwargs`. This is useful when configuration is already
+                loaded before calling `from_pretrained`.
+            low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+                Create empty adapter weights on meta device before loading the saved weights. Useful to speed up the
+                process.
+            kwargs: (`optional`):
+                Additional keyword arguments passed along to the specific PEFT configuration class.
+        """
+        # note: adapted from PeftModel.from_pretrained
+        from .mapping import PEFT_TYPE_TO_CONFIG_MAPPING, PEFT_TYPE_TO_MIXED_MODEL_MAPPING
+
+        # load the config
+        if config is None:
+            hf_kwargs = {
+                "subfolder": kwargs.get("subfolder", None),
+                "revision": kwargs.get("revision", None),
+                "cache_dir": kwargs.get("cache_dir", None),
+                "token": kwargs.get("token", None),
+            }
+            if use_auth_token := kwargs.get("use_auth_token", None):
+                hf_kwargs["use_auth_token"] = use_auth_token
+            config = PEFT_TYPE_TO_CONFIG_MAPPING[PeftConfig._get_peft_type(model_id, **hf_kwargs)].from_pretrained(
+                model_id, **kwargs
+            )
+        elif isinstance(config, PeftConfig):
+            config.inference_mode = not is_trainable
+        else:
+            raise ValueError(f"The input config must be a PeftConfig, got {config.__class__}")
+
+        # note: this is different from PeftModel.from_pretrained
+        if config.peft_type not in PEFT_TYPE_TO_MIXED_MODEL_MAPPING:
+            raise ValueError(f"Adapter of type {config.peft_type} is not supported for mixed models.")
+
+        if (getattr(model, "hf_device_map", None) is not None) and len(
+            set(model.hf_device_map.values()).intersection({"cpu", "disk"})
+        ) > 0:
+            remove_hook_from_submodules(model)
+
+        if config.is_prompt_learning and is_trainable:
+            # note: should not be possible to reach, but just in case
+            raise ValueError("Cannot set a prompt learning adapter to trainable when loading pretrained adapter.")
+        else:
+            config.inference_mode = not is_trainable
+
+        # note: this is different from PeftModel.from_pretrained, we always return a PeftMixedModel
+        model = cls(model, config, adapter_name)
+        # the low_cpu_mem_usage option is handled through kwargs
+        model.load_adapter(model_id, adapter_name, is_trainable=is_trainable, **kwargs)
+        return model
diff --git a/src/peft/optimizers/__init__.py b/src/peft/optimizers/__init__.py
new file mode 100644
index 0000000..0e8821f
--- /dev/null
+++ b/src/peft/optimizers/__init__.py
@@ -0,0 +1,19 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from .lorafa import create_lorafa_optimizer
+from .loraplus import create_loraplus_optimizer
+
+
+__all__ = ["create_lorafa_optimizer", "create_loraplus_optimizer"]
diff --git a/src/peft/optimizers/lorafa.py b/src/peft/optimizers/lorafa.py
new file mode 100644
index 0000000..bbf282b
--- /dev/null
+++ b/src/peft/optimizers/lorafa.py
@@ -0,0 +1,255 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+"""
+This module contains the implementation of the LoRA-FA optimizer.
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Callable, Iterable
+
+import torch
+from accelerate.utils.imports import is_bf16_available
+from torch import autocast, nn
+from torch.optim import Optimizer
+
+from ..peft_model import PeftModel
+from ..utils.other import infer_device
+
+
+class LoraFAOptimizer(Optimizer):
+    """
+    Implements the LoRA-FA optimizer designed specifically for training Low-Rank Adaptation (LoRA) parameters
+    efficiently. Note that LoraFAOptimizer is based on adamw-hf in transformers, with only LoRA part modified. Without
+    LoRA it will fall back to adamw-hf.
+
+    Args:
+        params (Iterable[nn.parameter.Parameter]): Parameters to optimize.
+        lr (float, optional): Learning rate (default: 1e-3).
+        betas (Tuple[float, float], optional):
+            Coefficients for computing running averages of gradient and squared gradient (default: (0.9, 0.999)).
+        eps (float, optional): Term added to denominator to improve numerical stability (default: 1e-6).
+        weight_decay (float, optional): Weight decay (L2 penalty) (default: 0.0).
+        correct_bias (bool, optional): Whether to apply bias correction as in original Adam (default: True).
+
+    Args in sub-function step:
+        closure (Callable, optional): A closure that reevaluates the model and returns the loss.
+
+    Reference:
+        - LoRA-FA: https://huggingface.co/papers/2308.03303
+    """
+
+    def __init__(
+        self,
+        params: Iterable[nn.parameter.Parameter],
+        lr: float = 1e-3,
+        betas: tuple[float, float] = (0.9, 0.999),
+        eps: float = 1e-6,
+        weight_decay: float = 0.0,
+        correct_bias: bool = True,
+    ):
+        if lr < 0.0:
+            raise ValueError(f"Invalid learning rate: {lr} - should be >= 0.0")
+        if not 0.0 <= betas[0] < 1.0:
+            raise ValueError(f"Invalid beta parameter: {betas[0]} - should be in [0.0, 1.0)")
+        if not 0.0 <= betas[1] < 1.0:
+            raise ValueError(f"Invalid beta parameter: {betas[1]} - should be in [0.0, 1.0)")
+        if not 0.0 <= eps:
+            raise ValueError(f"Invalid epsilon value: {eps} - should be >= 0.0")
+        defaults = {
+            "lr": lr,
+            "betas": betas,
+            "eps": eps,
+            "weight_decay": weight_decay,
+            "correct_bias": correct_bias,
+        }
+        super().__init__(params, defaults)
+
+    @torch.no_grad()
+    def step(self, closure: Callable | None = None):
+        """
+        Performs a single optimization step.
+
+        Arguments:
+            closure (`Callable`, *optional*): A closure that reevaluates the model and returns the loss.
+        """
+        loss = None
+        if closure is not None:
+            loss = closure()
+
+        for group in self.param_groups:
+            scaling_factor = group["scaling_factor"]
+            param_list = []
+            name_list = []
+            for p, n in zip(group["params"], group["names"]):
+                # Skip non-lora no-grad module, since we need lora_A which is no-grad.
+                if "lora" not in n and p.grad is None:
+                    continue
+                grad = p.grad
+
+                if "lora" in n:
+                    param_list.append(p)
+                    name_list.append(n)
+                    if len(param_list) == 2:
+                        name = n[: n.find("lora")] + "lora"
+                    elif len(param_list) == 1:
+                        continue
+                else:
+                    name = n
+                # param_list contains a pair of A and B adapters
+                # i.e., param_list -> [A,B]
+
+                state = self.state[name]
+                # State initialization
+                if len(state) == 0:
+                    if len(param_list) == 2:
+                        state["step"] = 0
+                        # Exponential moving average of gradient values
+                        state["exp_avg_B"] = torch.zeros_like(param_list[1])
+                        # Exponential moving average of squared gradient values
+                        state["exp_avg_sq_B"] = torch.zeros_like(param_list[1])
+                    else:
+                        state["step"] = 0
+                        # Exponential moving average of gradient values
+                        state["exp_avg"] = torch.zeros_like(p)
+                        # Exponential moving average of squared gradient values
+                        state["exp_avg_sq"] = torch.zeros_like(p)
+
+                # Below is the LoRA-FA part
+                # 1. In this part, we optimize the gradient of B as:
+                #    g^B = \left(\frac{r}{\alpha}\right)^2 (A^\top A)^{-1} g_{\text{LoRA-FA}}^B
+                #    to min the func as described below:
+                #    \min_{g^B} \|\hat{g}_\text{LoRA-FA} - g\|_F^2
+                # 2. After the gradient of B is ready, update the optimizer state
+                if len(param_list) == 2:
+                    A = param_list[0]
+                    B = param_list[1]
+                    grad_B_orin = B.grad
+
+                    # projection
+                    delta = 1e-8
+
+                    # computing the inverse matrix
+                    AA_T = A @ A.T
+                    AA_T_inv = torch.linalg.pinv(AA_T + delta * torch.eye(A.shape[0]).to(A.device))
+
+                    device_type = infer_device()
+
+                    if is_bf16_available():
+                        with autocast(device_type=device_type, dtype=torch.bfloat16):
+                            grad_B = (1 / scaling_factor**2) * (grad_B_orin @ AA_T_inv)
+                    else:
+                        grad_B = (1 / scaling_factor**2) * (grad_B_orin @ AA_T_inv)
+
+                    if grad_B.dtype != B.grad.dtype:
+                        grad_B = grad_B.to(B.grad.dtype)
+
+                    exp_avg_B, exp_avg_sq_B = state["exp_avg_B"], state["exp_avg_sq_B"]
+                    beta1, beta2 = group["betas"]
+                    state["step"] += 1
+                    exp_avg_B.mul_(beta1).add_(grad_B, alpha=(1.0 - beta1))
+                    exp_avg_sq_B.mul_(beta2).addcmul_(grad_B, grad_B, value=1.0 - beta2)
+
+                    denom_B = exp_avg_sq_B.sqrt().add_(group["eps"])
+                    step_size = group["lr"]
+                    if group["correct_bias"]:  # No bias correction for Bert
+                        bias_correction1 = 1.0 - beta1 ** state["step"]
+                        bias_correction2 = 1.0 - beta2 ** state["step"]
+                        step_size = step_size * math.sqrt(bias_correction2) / bias_correction1
+                    B.addcdiv_(exp_avg_B, denom_B, value=-step_size)
+                    if group["weight_decay"] > 0.0:
+                        B.add_(B, alpha=(-group["lr"] * group["weight_decay"]))
+                    param_list = []
+                    name_list = []
+
+                # Below is the original AdamW
+                else:
+                    exp_avg, exp_avg_sq = state["exp_avg"], state["exp_avg_sq"]
+                    beta1, beta2 = group["betas"]
+
+                    state["step"] += 1
+
+                    # Decay the first and second moment running average coefficient
+                    # In-place operations to update the averages at the same time
+                    exp_avg.mul_(beta1).add_(grad, alpha=(1.0 - beta1))
+                    exp_avg_sq.mul_(beta2).addcmul_(grad, grad, value=1.0 - beta2)
+                    denom = exp_avg_sq.sqrt().add_(group["eps"])
+
+                    step_size = group["lr"]
+                    if group["correct_bias"]:  # No bias correction for Bert
+                        bias_correction1 = 1.0 - beta1 ** state["step"]
+                        bias_correction2 = 1.0 - beta2 ** state["step"]
+                        step_size = step_size * math.sqrt(bias_correction2) / bias_correction1
+
+                    p.addcdiv_(exp_avg, denom, value=-step_size)
+
+                    # Just adding the square of the weights to the loss function is *not*
+                    # the correct way of using L2 regularization/weight decay with Adam,
+                    # since that will interact with the m and v parameters in strange ways.
+                    #
+                    # Instead we want to decay the weights in a manner that doesn't interact
+                    # with the m/v parameters. This is equivalent to adding the square
+                    # of the weights to the loss with plain (non-momentum) SGD.
+                    # Add weight decay at the end (fixed version)
+                    if group["weight_decay"] > 0.0:
+                        p.add_(p, alpha=(-group["lr"] * group["weight_decay"]))
+
+        return loss
+
+
+def create_lorafa_optimizer(
+    model: PeftModel, r: int, lora_alpha: int, lr: float, weight_decay: float = 0.0, use_rslora: bool = False
+) -> Optimizer:
+    """
+    Helper function to instantiate a lorafa optimizer specifically configured for a given model using the LoRA method.
+
+    This function will:
+    - Disable gradient updates for the "lora_A" parameters (these are typically frozen during LoRA training).
+    - Compute the scaling factor based on provided `lora_alpha` and rank `r` for proper gradient projection.
+    - Create and configure parameter groups for the optimizer including specified learning rate, weight decay, and
+      additional optimizer options.
+
+    For hyper-params, LoRA-FA uses the same hyper-params as AdamW, except for the LoRA hyper-params (r, lora_alpha,
+    use_rslora). One can always use the same hyper-params such as lr and weight_decay, as AdamW in LoRA tuning.
+
+    Args:
+        model (PeftModel): The model containing LoRA-adapted parameters.
+        r (int): Rank of the LoRA decomposition.
+        lora_alpha (int): Scaling factor for LoRA parameterization.
+        lr (float): Learning rate for optimizer updates.
+        weight_decay (float): Weight decay for AdamW.
+        use_rslora (bool):
+            whether to use rslora. In rslora, the lora scaling factor becomes to lora_alpha / math.sqrt(r) instead of
+            lora_alpha / r.
+
+    Returns:
+        Optimizer: Configured lorafa optimizer instance ready for training.
+    """
+    for name, param in model.named_parameters():
+        if "lora_A" in name:
+            param.requires_grad_(False)
+    lora_scaling = lora_alpha / math.sqrt(r) if use_rslora else lora_alpha / r
+    param_groups = [
+        {
+            "params": model.parameters(),
+            "lr": lr,
+            "names": [name for name, _ in model.named_parameters()],
+            "scaling_factor": lora_scaling,
+            "betas": (0.9, 0.999),
+            "weight_decay": weight_decay,
+        }
+    ]
+    return LoraFAOptimizer(param_groups)
diff --git a/src/peft/optimizers/loraplus.py b/src/peft/optimizers/loraplus.py
new file mode 100644
index 0000000..bdb4215
--- /dev/null
+++ b/src/peft/optimizers/loraplus.py
@@ -0,0 +1,121 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+"""
+This module contains the implementation of the LoraPlus optimizer.
+"""
+
+from __future__ import annotations
+
+from operator import attrgetter
+
+from torch import nn
+from torch.optim import Optimizer
+from transformers.pytorch_utils import ALL_LAYERNORM_LAYERS
+from transformers.trainer_pt_utils import get_parameter_names
+
+from ..peft_model import PeftModel
+from ..tuners.lora.layer import Embedding
+
+
+def create_loraplus_optimizer(
+    model: PeftModel, optimizer_cls: type[Optimizer], *, lr: float, loraplus_lr_ratio: float, **kwargs
+) -> Optimizer:
+    """
+    Creates a LoraPlus optimizer.
+
+    Efficient Low Rank Adaptation of Large Models: https://huggingface.co/papers/2402.12354
+
+    Reference: https://github.com/nikhil-ghosh-berkeley/loraplus/
+
+    Args:
+        model (`torch.nn.Module`): The model to be optimized.
+        optimizer_cls (`torch.optim.Optimizer`): The optimizer class to be used.
+        lr (`float`): The learning rate to be used for the optimizer.
+        loraplus_lr_ratio (`float`):
+            The ratio of learning ηB/ηA where ηA (lr) is passed in as the optimizer learning rate. Should be ≥1. Should
+            be set in tandem with the optimizer learning rate (lr); should be larger when the task is more difficult
+            and the model needs to update its features to learn well. In this case, it helps to make the learning rate
+            slightly smaller (e.g., by a factor of 2) than typical vanilla LoRA learning rates
+        loraplus_lr_embedding (optional `float`):
+            If LoRA modules are added to embedding layers your can specify a different learning rate for them. Default
+            value 1e-6.
+        kwargs (`dict`): Additional keyword arguments to be passed to the optimizer.
+
+    Returns:
+        `torch.optim.Optimizer`: An instance of the specified optimizer class configured with the model's parameters
+        organized into groups with custom learning rates.
+    """
+
+    decay_parameters = get_parameter_names(model, ALL_LAYERNORM_LAYERS)
+    decay_parameters = [name for name in decay_parameters if "bias" not in name]
+    param_groups = {
+        "groupA": {},
+        "groupB": {},
+        "groupB_no_decay": {},
+        "embedding": {},
+    }
+
+    for name, param in model.named_parameters():
+        if not param.requires_grad:
+            continue
+
+        module = attrgetter(name)(model)
+        if isinstance(module, Embedding):
+            param_groups["embedding"][name] = param
+        elif "lora_B" in name or param.ndim == 1:
+            if name in decay_parameters:
+                param_groups["groupB"][name] = param
+            else:
+                param_groups["groupB_no_decay"][name] = param
+        else:
+            param_groups["groupA"][name] = param
+
+    kwargs["lr"] = lr
+    loraplus_weight_decay = kwargs.pop("loraplus_weight_decay", 0.0)
+    loraplus_lr_embedding = kwargs.pop("loraplus_lr_embedding", 1e-6)
+
+    optimizer_grouped_parameters = [
+        {
+            "params": list(param_groups["groupA"].values()),
+            "weight_decay": loraplus_weight_decay,
+            "lr": lr,
+        },
+        {
+            "params": list(param_groups["embedding"].values()),
+            "weight_decay": loraplus_weight_decay,
+            "lr": loraplus_lr_embedding,
+        },
+        {
+            "params": list(param_groups["groupB"].values()),
+            "weight_decay": loraplus_weight_decay,
+            "lr": lr * loraplus_lr_ratio,
+        },
+        {
+            "params": list(param_groups["groupB_no_decay"].values()),
+            "weight_decay": 0.0,
+            "lr": lr * loraplus_lr_ratio,
+        },
+    ]
+
+    optimizer = optimizer_cls(optimizer_grouped_parameters, **kwargs)
+    eight_bit_names = ["Adam8bit", "AdamW8bit", "PagedAdam8bit", "PagedAdamW8bit"]
+    if optimizer_cls.__name__ in eight_bit_names:
+        import bitsandbytes
+
+        manager = bitsandbytes.optim.GlobalOptimManager.get_instance()
+        for module in model.modules():
+            if isinstance(module, nn.Embedding):
+                manager.register_module_override(module, "weight", {"optim_bits": 32})
+    return optimizer
diff --git a/src/peft/peft_model.py b/src/peft/peft_model.py
new file mode 100644
index 0000000..7340dbf
--- /dev/null
+++ b/src/peft/peft_model.py
@@ -0,0 +1,3503 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+import collections
+import copy
+import inspect
+import os
+import warnings
+from collections.abc import Sequence
+from contextlib import contextmanager, nullcontext
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import Any, Literal, Optional, Union
+
+import packaging.version
+import torch
+import transformers
+from accelerate import dispatch_model, infer_auto_device_map
+from accelerate.hooks import AlignDevicesHook, add_hook_to_module, remove_hook_from_submodules
+from accelerate.utils import get_balanced_memory, named_module_tensors
+from huggingface_hub import HfFileSystem, ModelCard, ModelCardData, hf_hub_download
+from safetensors import safe_open
+from safetensors.torch import save_file as safe_save_file
+from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
+from transformers import Cache, DynamicCache, EncoderDecoderCache, PreTrainedModel
+from transformers.modeling_outputs import QuestionAnsweringModelOutput, SequenceClassifierOutput, TokenClassifierOutput
+from transformers.utils import PushToHubMixin
+
+from peft.tuners.lora.variants import get_alora_offsets_for_forward, get_alora_offsets_for_generate
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer
+from peft.utils import AuxiliaryTrainingWrapper
+from peft.utils.constants import DUMMY_MODEL_CONFIG
+from peft.utils.integrations import init_empty_weights
+from peft.utils.other import TrainableTokensWrapper, create_attention_mask, set_additional_trainable_modules
+
+from . import __version__
+from .config import PeftConfig
+from .mapping import PEFT_TYPE_TO_CONFIG_MAPPING, PEFT_TYPE_TO_PREFIX_MAPPING, PEFT_TYPE_TO_TUNER_MAPPING
+from .utils import (
+    SAFETENSORS_WEIGHTS_NAME,
+    TRANSFORMERS_MODELS_TO_PREFIX_TUNING_POSTPROCESS_MAPPING,
+    WEIGHTS_NAME,
+    PeftType,
+    TaskType,
+    _get_batch_size,
+    _prepare_prompt_learning_config,
+    _set_adapter,
+    _set_trainable,
+    get_peft_model_state_dict,
+    id_tensor_storage,
+    infer_device,
+    load_peft_weights,
+    map_cache_to_layer_device_map,
+    set_peft_model_state_dict,
+    shift_tokens_right,
+)
+
+
+def _get_layer_kv_target_shape(base_config, layer_idx: int) -> tuple[int, int] | None:
+    """Per-layer (num_kv_heads, head_dim) for prefix-tuning injection, or None for uniform models.
+
+    Models with heterogeneous attention (e.g. Gemma4) expose `global_head_dim` / `num_global_key_value_heads` alongside
+    the sliding-layer `head_dim` / `num_key_value_heads`. The provisioned prefix is sized for the global footprint;
+    this returns the shape each layer actually expects so the caller can slice down or skip layers that don't fit.
+    """
+    layer_types = getattr(base_config, "layer_types", None)
+    global_head_dim = getattr(base_config, "global_head_dim", None)
+    if not layer_types or global_head_dim is None:
+        return None
+
+    is_sliding = layer_types[layer_idx] == "sliding_attention"
+    head_dim = base_config.head_dim if is_sliding else global_head_dim
+    num_global_kv = getattr(base_config, "num_global_key_value_heads", None)
+    if not is_sliding and num_global_kv is not None:
+        num_kv_heads = num_global_kv
+    else:
+        num_kv_heads = base_config.num_key_value_heads
+    return num_kv_heads, head_dim
+
+
+class PeftModel(PushToHubMixin, torch.nn.Module):
+    """
+    Base model encompassing various Peft methods.
+
+    Args:
+        model ([`~transformers.PreTrainedModel`]): The base transformer model used for Peft.
+        peft_config ([`PeftConfig`]): The configuration of the Peft model.
+        adapter_name (`str`,  *optional*): The name of the adapter, defaults to `"default"`.
+        autocast_adapter_dtype (`bool`, *optional*, defaults to `True`):
+            Whether to autocast the adapter dtype. Defaults to `True`. Right now, this will only cast adapter weights
+            using float16 and bfloat16 to float32, as this is typically required for stable training, and only affect
+            select PEFT tuners. If set to `False`, the dtypes will stay the same as those of the corresponding layer.
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            Create empty adapter weights on meta device. Useful to speed up the loading loading process.
+
+            > [!TIP] > Don't use `low_cpu_mem_usage=True` when creating a new PEFT adapter for training.
+
+    **Attributes**:
+        - **base_model** ([`torch.nn.Module`]) -- The base transformer model used for Peft.
+        - **peft_config** ([`PeftConfig`]) -- The configuration of the Peft model.
+        - **modules_to_save** (`list` of `str`) -- The list of sub-module names to save when
+            saving the model.
+        - **prompt_encoder** ([`PromptEncoder`]) -- The prompt encoder used for Peft if
+            using [`PromptLearningConfig`].
+        - **prompt_tokens** (`torch.Tensor`) -- The virtual prompt tokens used for Peft if
+            using [`PromptLearningConfig`].
+        - **transformer_backbone_name** (`str`) -- The name of the transformer
+            backbone in the base model if using [`PromptLearningConfig`].
+        - **word_embeddings** (`torch.nn.Embedding`) -- The word embeddings of the transformer backbone
+            in the base model if using [`PromptLearningConfig`].
+    """
+
+    def __init__(
+        self,
+        model: PreTrainedModel,
+        peft_config: PeftConfig,
+        adapter_name: str = "default",
+        autocast_adapter_dtype: bool = True,
+        low_cpu_mem_usage: bool = False,
+    ) -> None:
+        super().__init__()
+        self.active_adapter = adapter_name
+        self.peft_type = peft_config.peft_type
+        # These args are special PEFT arguments that users can pass. They need to be removed before passing them to
+        # forward.
+        self.special_peft_forward_args = {"adapter_names", "alora_offsets"}
+
+        self._is_prompt_learning = peft_config.is_prompt_learning
+        if self._is_prompt_learning:
+            self._peft_config = {adapter_name: peft_config}
+            self.base_model = model
+            self.add_adapter(adapter_name, peft_config, low_cpu_mem_usage=low_cpu_mem_usage)
+        else:
+            self._peft_config = None
+            cls = PEFT_TYPE_TO_TUNER_MAPPING[peft_config.peft_type]
+            ctx = init_empty_weights if low_cpu_mem_usage else nullcontext
+            with ctx():
+                self.base_model = cls(model, {adapter_name: peft_config}, adapter_name)
+
+        if hasattr(self.base_model, "_cast_adapter_dtype"):
+            self.base_model._cast_adapter_dtype(
+                adapter_name=adapter_name, autocast_adapter_dtype=autocast_adapter_dtype
+            )
+
+        if getattr(model, "is_gradient_checkpointing", True):
+            model = self.prepare_model_for_gradient_checkpointing(model)
+
+        # the `pretraining_tp` is set for some models to simulate Tensor Parallelism during inference to avoid
+        # numerical differences, https://github.com/pytorch/pytorch/issues/76232 - to avoid any unexpected
+        # behavior we disable that in this line.
+        if hasattr(self.base_model, "config") and hasattr(self.base_model.config, "pretraining_tp"):
+            self.base_model.config.pretraining_tp = 1
+
+        self._adapters_disabled = False
+
+    @property
+    def peft_config(self) -> dict[str, PeftConfig]:
+        if self._is_prompt_learning:
+            return self._peft_config
+        return self.base_model.peft_config
+
+    @property
+    def active_adapters(self) -> list[str]:
+        try:
+            adapters = self.base_model.active_adapters
+            if not isinstance(adapters, list):
+                # Base model is probably a transformers model, see:
+                # https://github.com/huggingface/transformers/pull/30790#issuecomment-2253808249
+                # Unfortunately, transformers models also have an active_adapters method but it's 1) not a property and
+                # 2) calling it fails because the base model (usually) has no loaded adapter. The base model can be a
+                # transformers model for prompt learning, where the base model is not wrapped in a LoraModel or similar.
+                adapters = self.active_adapter
+                if isinstance(adapters, str):
+                    adapters = [adapters]
+        except AttributeError:
+            adapters = self.active_adapter
+            if isinstance(adapters, str):
+                adapters = [adapters]
+        return adapters
+
+    @property
+    def has_active_enabled_adapter(self) -> bool:
+        """Reflects whether the adapters are purposefully disabled (via disable_adapter) or if there
+        are no active adapters (enabled but inactive). They are two separate mechanisms but sometimes it is helpful to
+        know whether the model has any active/enabled adapter at all.
+        """
+        if self.peft_config[self.active_adapter].is_prompt_learning:
+            return not self._adapters_disabled
+
+        return not self._adapters_disabled or not self.active_adapters
+
+    @peft_config.setter
+    def peft_config(self, value: dict[str, PeftConfig]):
+        if self._is_prompt_learning:
+            self._peft_config = value
+        else:
+            self.base_model.peft_config = value
+
+    def save_pretrained(
+        self,
+        save_directory: str,
+        safe_serialization: bool = True,
+        selected_adapters: Optional[list[str]] = None,
+        save_embedding_layers: Union[str, bool] = "auto",
+        is_main_process: bool = True,
+        path_initial_model_for_weight_conversion: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
+        r"""
+        This function saves the adapter model and the adapter configuration files to a directory, so that it can be
+        reloaded using the [`PeftModel.from_pretrained`] class method, and also used by the [`PeftModel.push_to_hub`]
+        method.
+
+        Args:
+            save_directory (`str`):
+                Directory where the adapter model and configuration files will be saved (will be created if it does not
+                exist).
+            safe_serialization (`bool`, *optional*):
+                Whether to save the adapter files in safetensors format, defaults to `True`.
+            selected_adapters (`List[str]`,  *optional*):
+                A list of adapters to be saved. If `None`, will default to all adapters.
+            save_embedding_layers (`Union[bool, str]`, *optional*, defaults to `"auto"`):
+                If `True`, save the embedding layers in addition to adapter weights. If `auto`, checks the common
+                embedding layers `peft.utils.other.EMBEDDING_LAYER_NAMES` in config's `target_modules` when available.
+                and automatically sets the boolean flag. This only works for 🤗 transformers models.
+            is_main_process (`bool`, *optional*):
+                Whether the process calling this is the main process or not. Will default to `True`. Will not save the
+                checkpoint if not on the main process, which is important for multi device setups (e.g. DDP).
+            path_initial_model_for_weight_conversion (`str`, *optional*):
+                The path to the initialized adapter, which is obtained after initializing the model with
+                PiSSA/CorDA/OLoRA and before performing any training. When `path_initial_model_for_weight_conversion`
+                is not None, the difference in adapter before and after fine-tuning is calculated. This difference can
+                be represented as the parameters of a standard LoRA adapter. In contrast to PiSSA and friends, using
+                this converted adapter does not require changes to the base model, thus conveniently allowing the use
+                of multiple PiSSA/CorDA/OLoRA adapters with LoRA adapters, and the activation or deactivation of any
+                adapters. Note that this conversion is not supported if `rslora` is used in combination with
+                `rank_pattern` or `alpha_pattern`. See [`peft.tuners.lora.LoraModel.subtract_mutated_init`] for more
+                information.
+            kwargs (additional keyword arguments, *optional*):
+                Additional keyword arguments passed along to the `push_to_hub` method.
+
+        """
+        if os.path.isfile(save_directory):
+            raise ValueError(f"Provided path ({save_directory}) should be a directory, not a file")
+
+        if selected_adapters is None:
+            selected_adapters = list(self.peft_config.keys())
+        else:
+            if any(
+                selected_adapter_name not in list(self.peft_config.keys())
+                for selected_adapter_name in selected_adapters
+            ):
+                raise ValueError(
+                    f"You passed an invalid `selected_adapters` arguments, current supported adapter names are"
+                    f" {list(self.peft_config.keys())} - got {selected_adapters}."
+                )
+
+        def save_mutated_as_lora(peft_config, path_initial_model_for_weight_conversion, output_state_dict, kwargs):
+            if peft_config.use_rslora and (peft_config.rank_pattern or peft_config.alpha_pattern):
+                msg = (
+                    "Passing `path_initial_model_for_weight_conversion` to `save_pretrained` is not supported when "
+                    "using `rank_pattern` or `alpha_pattern` at the same time as `use_rslora=True`."
+                )
+                raise ValueError(msg)
+
+            if not any(
+                str(peft_config.init_lora_weights).lower().startswith(prefix)
+                for prefix in ["pissa", "corda", "olora", "lora_ga", "true"]
+            ):
+                warnings.warn(
+                    "`path_initial_model_for_weight_conversion` only works for converting a PiSSA/CorDA/OLoRA/LoRA-GA adapter to "
+                    "a LoRA adapter"
+                )
+            initial_adapter_name = os.path.basename(path_initial_model_for_weight_conversion)
+            try:
+                self.load_adapter(
+                    os.path.dirname(path_initial_model_for_weight_conversion),
+                    subfolder=initial_adapter_name,
+                    adapter_name=initial_adapter_name,
+                )
+                is_pissa = str(self.peft_config[initial_adapter_name].init_lora_weights).lower().startswith("pissa")
+                is_corda = str(self.peft_config[initial_adapter_name].init_lora_weights).lower() == "corda"
+                is_olora = str(self.peft_config[initial_adapter_name].init_lora_weights).lower() == "olora"
+                is_lora_ga = str(self.peft_config[initial_adapter_name].init_lora_weights).lower() == "lora_ga"
+                if is_pissa or is_corda or is_olora or is_lora_ga:
+                    raise ValueError(
+                        "The `init_lora_weights` parameter of the initial adapter should be set to `True`. "
+                        "Otherwise, `self.load_adapter` will subtract the decomposed values again based on the "
+                        "residual model."
+                    )
+                output_state_dict = self.base_model.subtract_mutated_init(
+                    output_state_dict, initial_adapter_name, kwargs
+                )
+            finally:
+                self.delete_adapter(initial_adapter_name)
+            return output_state_dict
+
+        if is_main_process:
+            os.makedirs(save_directory, exist_ok=True)
+            self.create_or_update_model_card(save_directory)
+
+        for adapter_name in selected_adapters:
+            peft_config = self.peft_config[adapter_name]
+            # save only the trainable weights
+            output_state_dict = get_peft_model_state_dict(
+                self,
+                state_dict=kwargs.get("state_dict", None),
+                adapter_name=adapter_name,
+                save_embedding_layers=save_embedding_layers,
+            )
+            output_dir = os.path.join(save_directory, adapter_name) if adapter_name != "default" else save_directory
+            os.makedirs(output_dir, exist_ok=True)
+
+            if is_main_process and safe_serialization:
+                # Section copied from: https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2111-L2134
+                # Safetensors does not allow tensor aliasing.
+                # We're going to remove aliases before saving
+                ptrs = collections.defaultdict(list)
+                for name, tensor in output_state_dict.items():
+                    # Sometimes in the state_dict we have non-tensor objects.
+                    # e.g. in bitsandbytes we have some `str` objects in the state_dict
+                    if isinstance(tensor, torch.Tensor):
+                        ptrs[id_tensor_storage(tensor)].append(name)
+                    else:
+                        # In the non-tensor case, fall back to the pointer of the object itself
+                        ptrs[id(tensor)].append(name)
+
+                # These are all the pointers of shared tensors.
+                shared_ptrs = {ptr: names for ptr, names in ptrs.items() if len(names) > 1}
+
+                for names in shared_ptrs.values():
+                    # Here we just clone the shared tensors to avoid tensor aliasing which is
+                    # not supported in safetensors.
+                    for shared_tensor_name in names[1:]:
+                        output_state_dict[shared_tensor_name] = output_state_dict[shared_tensor_name].clone()
+                if path_initial_model_for_weight_conversion is not None:
+                    peft_config = copy.deepcopy(peft_config)
+                    peft_config.init_lora_weights = True
+                    peft_config.save_pretrained(path_initial_model_for_weight_conversion)
+                    output_state_dict = save_mutated_as_lora(
+                        peft_config, path_initial_model_for_weight_conversion, output_state_dict, kwargs
+                    )
+
+                # Before exporting the parameters we need to make sure all the tensors are contiguous as saving
+                # non-contiguous parameters is not supported. Tensors can become non contigiuous
+                # if they are a transpose view of another tensor. This can happen
+                # during adapter tying or parameter sharing.
+                for k, v in output_state_dict.items():
+                    if not v.is_contiguous():
+                        output_state_dict[k] = v.contiguous()
+
+                safe_save_file(
+                    output_state_dict,
+                    os.path.join(output_dir, SAFETENSORS_WEIGHTS_NAME),
+                    metadata={"format": "pt"},
+                )
+            elif is_main_process:
+                if path_initial_model_for_weight_conversion is not None:
+                    peft_config = copy.deepcopy(peft_config)
+                    peft_config.init_lora_weights = True
+                    peft_config.save_pretrained(path_initial_model_for_weight_conversion)
+                    output_state_dict = save_mutated_as_lora(
+                        peft_config, path_initial_model_for_weight_conversion, output_state_dict, kwargs
+                    )
+                torch.save(output_state_dict, os.path.join(output_dir, WEIGHTS_NAME))
+
+            # save the config and change the inference mode to `True`
+            if peft_config.base_model_name_or_path is None:
+                peft_config.base_model_name_or_path = (
+                    self.base_model.__dict__.get("name_or_path", None)
+                    if peft_config.is_prompt_learning
+                    else self.base_model.model.__dict__.get("name_or_path", None)
+                )
+            inference_mode = peft_config.inference_mode
+            peft_config.inference_mode = True
+
+            if peft_config.task_type is None:
+                # deal with auto mapping
+                base_model_class = self._get_base_model_class(
+                    is_prompt_tuning=peft_config.is_prompt_learning,
+                )
+                parent_library = base_model_class.__module__
+
+                auto_mapping_dict = {
+                    "base_model_class": base_model_class.__name__,
+                    "parent_library": parent_library,
+                }
+            else:
+                auto_mapping_dict = None
+
+            if is_main_process:
+                if path_initial_model_for_weight_conversion is not None:
+                    peft_config.init_lora_weights = True
+                    peft_config.r *= 2
+                    if not peft_config.use_rslora:
+                        peft_config.lora_alpha *= 2
+                    else:
+                        # with rslora, we have scaling = alpha / sqrt(r), we thus adjust alpha to keep the same scaling
+                        peft_config.lora_alpha *= 2**0.5
+
+                    if peft_config.rank_pattern:
+                        peft_config.rank_pattern = {key: 2 * val for key, val in peft_config.rank_pattern.items()}
+                    if peft_config.alpha_pattern:
+                        peft_config.alpha_pattern = {key: 2 * val for key, val in peft_config.alpha_pattern.items()}
+
+                peft_config.save_pretrained(output_dir, auto_mapping_dict=auto_mapping_dict)
+            peft_config.inference_mode = inference_mode
+
+    @classmethod
+    def from_pretrained(
+        cls,
+        model: torch.nn.Module,
+        model_id: Union[str, os.PathLike],
+        adapter_name: str = "default",
+        is_trainable: bool = False,
+        config: Optional[PeftConfig] = None,
+        autocast_adapter_dtype: bool = True,
+        ephemeral_gpu_offload: bool = False,
+        low_cpu_mem_usage: bool = False,
+        key_mapping: Optional[dict[str, str]] = None,
+        **kwargs: Any,
+    ) -> PeftModel:
+        r"""
+        Instantiate a PEFT model from a pretrained model and loaded PEFT weights.
+
+        Note that the passed `model` may be modified inplace.
+
+        Args:
+            model ([`torch.nn.Module`]):
+                The model to be adapted. For 🤗 Transformers models, the model should be initialized with the
+                [`~transformers.PreTrainedModel.from_pretrained`].
+            model_id (`str` or `os.PathLike`):
+                The name of the PEFT configuration to use. Can be either:
+                    - A string, the `model id` of a PEFT configuration hosted inside a model repo on the Hugging Face
+                      Hub.
+                    - A path to a directory containing a PEFT configuration file saved using the `save_pretrained`
+                      method (`./my_peft_config_directory/`).
+            adapter_name (`str`, *optional*, defaults to `"default"`):
+                The name of the adapter to be loaded. This is useful for loading multiple adapters.
+            is_trainable (`bool`, *optional*, defaults to `False`):
+                Whether the adapter should be trainable or not. If `False`, the adapter will be frozen and can only be
+                used for inference.
+            config ([`~peft.PeftConfig`], *optional*):
+                The configuration object to use instead of an automatically loaded configuration. This configuration
+                object is mutually exclusive with `model_id` and `kwargs`. This is useful when configuration is already
+                loaded before calling `from_pretrained`.
+            autocast_adapter_dtype (`bool`, *optional*, defaults to `True`):
+                Whether to autocast the adapter dtype. Defaults to `True`. Right now, this will only cast adapter
+                weights using float16 and bfloat16 to float32, as this is typically required for stable training, and
+                only affect select PEFT tuners. If set to `False`, the dtypes will stay the same as those of the
+                corresponding layer.
+            ephemeral_gpu_offload (`bool`, *optional*):
+                Whether to use ephemeral GPU offloading for partially loaded modules. Defaults to `False`. This is
+                useful when parts of the model and/or components (such as adapters) are kept in CPU memory until they
+                are needed. Rather than perform expensive operations on small data, the data is transferred to the GPU
+                on-demand, the operation(s) performed, and the results moved back to CPU memory. This brings a slight
+                momentary VRAM overhead but gives orders of magnitude speedup in certain cases.
+            low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+                Create empty adapter weights on meta device before loading the saved weights. Useful to speed up the
+                process.
+            torch_device (`str`, *optional*, defaults to None):
+                The device to load the adapter on. If `None`, the device will be inferred.
+            key_mapping (dict, *optional*, defaults to None)
+                Extra mapping of PEFT `state_dict` keys applied before loading the `state_dict`. When this mapping is
+                applied, the PEFT-specific `"base_model.model"` prefix is removed beforehand and the adapter name (e.g.
+                `"default"`) is not inserted yet. Only pass this argument if you know what you're doing.
+            kwargs: (`optional`):
+                Additional keyword arguments passed along to the specific PEFT configuration class.
+
+        """
+        from .auto import MODEL_TYPE_TO_PEFT_MODEL_MAPPING
+        from .tuners import XLoraConfig, XLoraModel
+
+        # load the config
+        if config is None:
+            hf_kwargs = {
+                "subfolder": kwargs.get("subfolder", None),
+                "revision": kwargs.get("revision", None),
+                "cache_dir": kwargs.get("cache_dir", None),
+                "token": kwargs.get("token", None),
+            }
+            if use_auth_token := kwargs.get("use_auth_token", None):
+                hf_kwargs["use_auth_token"] = use_auth_token
+            config = PEFT_TYPE_TO_CONFIG_MAPPING[PeftConfig._get_peft_type(model_id, **hf_kwargs)].from_pretrained(
+                model_id, **kwargs
+            )
+        elif isinstance(config, PeftConfig):
+            config.inference_mode = not is_trainable
+        else:
+            raise ValueError(f"The input config must be a PeftConfig, got {config.__class__}")
+
+        # See discussion in https://github.com/huggingface/transformers/pull/38627
+        # Some transformers models can have a _checkpoint_conversion_mapping dict that is used to map state_dicts
+        # stemming from updated model architectures so that they still correspond to the initial architecture. When
+        # loading a PEFT state_dict created with the initial architecture on a model with the new architecture, we need
+        # to map it too according to the same rules. Note that we skip prompt learning methods. This is because they
+        # don't have the "base_model.model." prefix, which we need to remove before mapping. Instead just using
+        # "base_model.". This could be fine, we could only remove "base_model.", However, the subsequent sub-module
+        # could also be called "model", resulting in what looks like "base_model.model.". To avoid this confusion, we
+        # skip prompt learning. Since it applies itself directly to the pre-trained model (unlike LoRA et al that target
+        # sub-modules), skipping should be fine.
+        if (key_mapping is None) and (not config.is_prompt_learning):
+            key_mapping = getattr(model, "_checkpoint_conversion_mapping", {})
+
+        # Runtime configuration, if supported
+        if hasattr(config, "runtime_config"):
+            config.runtime_config.ephemeral_gpu_offload = ephemeral_gpu_offload
+        else:
+            if ephemeral_gpu_offload:
+                warnings.warn("Ephemeral GPU offloading is not supported for this model. Ignoring.")
+
+        if hasattr(model, "hf_device_map"):
+            weight_map = dict(named_module_tensors(model, recurse=True))
+
+            # recreate the offload_index for disk-offloaded modules: we need to know the location in storage of each weight
+            # before the offload hook is removed from the model
+            disk_modules = set()
+            index = None
+            for name, module in model.named_modules():
+                if hasattr(module, "_hf_hook") and hasattr(module._hf_hook, "original_devices"):
+                    if hasattr(module._hf_hook.weights_map, "dataset"):
+                        index = module._hf_hook.weights_map.dataset.index
+                    for key in module._hf_hook.original_devices.keys():
+                        if module._hf_hook.original_devices[key] == torch.device("meta"):
+                            disk_modules.add(str(name) + "." + str(key))
+
+            if disk_modules and not kwargs.get("use_safetensors", True):
+                raise ValueError("Disk offloading currently only supported for safetensors")
+
+            if index:
+                offload_index = {
+                    p: {
+                        "safetensors_file": index[p]["safetensors_file"],
+                        "weight_name": p,
+                        "dtype": str(weight_map[p].dtype).replace("torch.", ""),
+                    }
+                    for p in weight_map.keys()
+                    if p in disk_modules
+                }
+                kwargs["offload_index"] = offload_index
+
+        if (getattr(model, "hf_device_map", None) is not None) and len(
+            set(model.hf_device_map.values()).intersection({"cpu", "disk"})
+        ) > 0:
+            remove_hook_from_submodules(model)
+
+        if config.is_prompt_learning and is_trainable:
+            raise ValueError("Cannot set a prompt learning adapter to trainable when loading pretrained adapter.")
+        else:
+            config.inference_mode = not is_trainable
+        if isinstance(getattr(model, "base_model", None), XLoraModel):
+            if not isinstance(config, XLoraConfig):
+                raise TypeError(f"Expected 'XLoraConfig', got '{type(config)}' instead.")
+            if "adapters" in kwargs:
+                config.adapters = kwargs["adapters"]
+            else:
+                # If the path is on HF hub, then we get the adapter names to create a subfolders list which tells
+                # `load_adapter` where the adapters are.
+                if not os.path.exists(model_id):
+                    s = HfFileSystem()
+
+                    # The names of the adapters which must be in folders
+                    adapter_names = [
+                        file["name"][len(model_id) + 1 :] for file in s.ls(model_id) if file["type"] == "directory"
+                    ]
+                    # Prepare a dict of adapter paths, which really just point to the hf id; we will use the subfolders
+                    adapter_paths = {}
+                    for loaded_adapter_name in adapter_names:
+                        adapter_paths[loaded_adapter_name] = os.path.join(model_id, model_id)
+                    config.adapters = adapter_paths
+                    config._subfolders = adapter_names
+                else:
+                    if "adapters" not in kwargs:
+                        raise ValueError("If model_id is a local path, then `adapters` must be passed in kwargs.")
+
+        if config.task_type not in MODEL_TYPE_TO_PEFT_MODEL_MAPPING.keys():
+            model = cls(
+                model,
+                config,
+                adapter_name,
+                autocast_adapter_dtype=autocast_adapter_dtype,
+                low_cpu_mem_usage=low_cpu_mem_usage,
+            )
+        else:
+            model = MODEL_TYPE_TO_PEFT_MODEL_MAPPING[config.task_type](
+                model,
+                config,
+                adapter_name,
+                autocast_adapter_dtype=autocast_adapter_dtype,
+                low_cpu_mem_usage=low_cpu_mem_usage,
+            )
+
+        load_result = model.load_adapter(
+            model_id,
+            adapter_name,
+            is_trainable=is_trainable,
+            autocast_adapter_dtype=autocast_adapter_dtype,
+            low_cpu_mem_usage=low_cpu_mem_usage,
+            key_mapping=key_mapping,
+            **kwargs,
+        )
+
+        # Filter out shared parameters that are duplicated at layer level:
+        # 1. Remove VB-LoRA vector bank, since it's a shared parameter set via the VBLoRAModel
+        # 2. Remove the prompt encoder, as it does not need to be part of the checkpoint
+        # 3. Remove TinyLoRA layer-level tinylora_v references (they share with model-level tinylora_v)
+        def is_expected_missing_key(k):
+            # TinyLoRA: layer-level tinylora_v is a reference to model-level, exclude from warning
+            if "vblora_vector_bank" in k or "prompt_encoder" in k or ".tinylora_v." in k:
+                return False
+            if (
+                config.peft_type == PeftType.UNILORA
+                and ".unilora_theta_d." in k
+                and not k.startswith("base_model.unilora_theta_d.")
+            ):
+                return False
+            return not (
+                config.peft_type == PeftType.UNILORA
+                and not getattr(config, "save_indices", False)
+                and (".unilora_indices_" in k or ".unilora_scales_" in k)
+            )
+
+        missing_keys = [k for k in load_result.missing_keys if is_expected_missing_key(k)]
+        if missing_keys:
+            # Let's warn here since (in contrast to load_adapter) we don't return the load result, so it could be quite
+            # difficult for users to even notice that something might have gone wrong here. As we filter out non PEFT
+            # keys from the missing keys, this gives no false positives.
+
+            # careful: if the wording of the warning is changed, adjust the unit tests accordingly!
+            warn_message = f"Found missing adapter keys while loading the checkpoint: {missing_keys}."
+
+            prefix = PEFT_TYPE_TO_PREFIX_MAPPING.get(config.peft_type)
+            if prefix and adapter_name in prefix:
+                warn_message = (
+                    f"Adapter name '{adapter_name}' should not be contained in the prefix '{prefix}'. "
+                    "This could be the potential reason for missing adapter keys. "
+                ) + warn_message
+
+            warnings.warn(warn_message)
+
+        return model
+
+    def _setup_prompt_encoder(self, adapter_name: str):
+        config = self.peft_config[adapter_name]
+        if not hasattr(self, "prompt_encoder"):
+            self.prompt_encoder = torch.nn.ModuleDict({})
+            self.prompt_tokens = {}
+        transformer_backbone = None
+        for name, module in self.base_model.named_children():
+            for param in module.parameters():
+                param.requires_grad = False
+            if isinstance(module, PreTrainedModel):
+                # Make sure to freeze Transformers model
+                if transformer_backbone is None:
+                    transformer_backbone = module
+                    self.transformer_backbone_name = name
+        if transformer_backbone is None:
+            transformer_backbone = self.base_model
+
+        if config.num_transformer_submodules is None:
+            config.num_transformer_submodules = 2 if config.task_type == TaskType.SEQ_2_SEQ_LM else 1
+
+        # determine the word embeddings
+        word_embeddings = None
+        try:
+            # First try to find the word embeddings based on the module name, this should work for models like Bert,
+            # Roberta, Deberta, etc.
+            word_embeddings = self.base_model.get_submodule("embeddings.word_embeddings")
+        except AttributeError:
+            pass
+
+        if word_embeddings is None:
+            # Word embeddings could not be determined. Next try to guess them by checking which parameter has the size
+            # of the vocab.
+            for named_param, value in list(transformer_backbone.named_parameters()):
+                # for ZeRO-3, the tensor is sharded across accelerators and deepspeed modifies it to a tensor with shape
+                # [0] the actual unsharded shape is stored in "ds_shape" attribute special handling is needed in case
+                # the model is initialized in deepspeed.zero.Init() context or HfDeepSpeedConfig has been called before
+                # For reference refer to issue: https://github.com/huggingface/peft/issues/996
+                deepspeed_distributed_tensor_shape = getattr(value, "ds_shape", None)
+
+                # Handle VLM case with separate text and vision configs
+                if hasattr(self.base_model.config, "get_text_config"):
+                    vocab_size = self.base_model.config.get_text_config().vocab_size
+                # below: for older transformers versions before get_text_config was added
+                elif "text_config" in self.base_model.config:
+                    vocab_size = self.base_model.config.text_config.vocab_size
+                else:
+                    vocab_size = self.base_model.config.vocab_size
+
+                if value.shape[0] == vocab_size or (
+                    deepspeed_distributed_tensor_shape is not None
+                    and deepspeed_distributed_tensor_shape[0] == vocab_size
+                ):
+                    word_embeddings = transformer_backbone.get_submodule(named_param.replace(".weight", ""))
+                    break
+
+        self.word_embeddings = word_embeddings
+        model_cls = PEFT_TYPE_TO_TUNER_MAPPING[config.peft_type]
+
+        if config.peft_type in (PeftType.PROMPT_TUNING, PeftType.MULTITASK_PROMPT_TUNING, PeftType.CPT):
+            prompt_encoder = model_cls(config, self.word_embeddings)
+        elif config.peft_type == PeftType.P_TUNING:
+            prompt_encoder = model_cls(config)
+        elif config.peft_type in (PeftType.PREFIX_TUNING, PeftType.CARTRIDGE):
+            # prefix tuning now uses Cache but that won't work with gradient checkpointing
+            if any(getattr(module, "gradient_checkpointing", False) for module in self.get_base_model().modules()):
+                raise ValueError(f"{config.peft_type.value} does not work with gradient checkpointing.")
+            prompt_encoder = model_cls(config)
+        else:
+            raise ValueError("Not supported")
+
+        prompt_encoder = prompt_encoder.to(self.device)
+        self.prompt_encoder.update(torch.nn.ModuleDict({adapter_name: prompt_encoder}))
+        self.prompt_tokens[adapter_name] = torch.arange(
+            config.num_virtual_tokens * config.num_transformer_submodules
+        ).long()
+
+    def prepare_model_for_gradient_checkpointing(self, model: PreTrainedModel):
+        r"""
+        Prepares the model for gradient checkpointing if necessary
+        """
+        self._prepare_model_for_gradient_checkpointing(model)
+
+    def _prepare_model_for_gradient_checkpointing(self, model: PreTrainedModel):
+        if not (
+            getattr(model, "is_loaded_in_8bit", False)
+            or getattr(model, "is_loaded_in_4bit", False)
+            or getattr(model, "is_quantized", False)
+        ):
+            if hasattr(model, "enable_input_require_grads"):
+                model.enable_input_require_grads()
+            elif hasattr(model, "get_input_embeddings"):
+
+                def make_inputs_require_grad(module, input, output):
+                    output.requires_grad_(True)
+
+                model.get_input_embeddings().register_forward_hook(make_inputs_require_grad)
+        return model
+
+    def get_prompt_embedding_to_save(self, adapter_name: str) -> torch.Tensor:
+        """
+        Returns the prompt embedding to save when saving the model. Only applicable when using a prompt learning
+        method.
+        """
+        prompt_encoder = self.prompt_encoder[adapter_name]
+        prompt_tokens = (
+            self.prompt_tokens[adapter_name].unsqueeze(0).expand(1, -1).to(prompt_encoder.embedding.weight.device)
+        )
+        peft_type = self.peft_config[adapter_name].peft_type
+        if self.peft_config[adapter_name].peft_type in (PeftType.PREFIX_TUNING, PeftType.CARTRIDGE):
+            prompt_tokens = prompt_tokens[:, : self.peft_config[adapter_name].num_virtual_tokens]
+
+        if self.peft_config[adapter_name].peft_type == PeftType.MULTITASK_PROMPT_TUNING:
+            prompt_embedding_cls = PEFT_TYPE_TO_TUNER_MAPPING[peft_type]
+            prompt_embeddings = super(prompt_embedding_cls, prompt_encoder).forward(prompt_tokens)
+        else:
+            prompt_embeddings = prompt_encoder(prompt_tokens)
+
+        return prompt_embeddings[0].detach().cpu()
+
+    def get_prompt(
+        self, batch_size: int, task_ids: Optional[torch.Tensor] = None, max_cache_len: Optional[int] = None
+    ) -> torch.Tensor:
+        """
+        Returns the virtual prompts to use for Peft. Only applicable when using a prompt learning method.
+        """
+        peft_config = self.active_peft_config
+        prompt_encoder = self.prompt_encoder[self.active_adapter]
+        prompt_tokens = (
+            self.prompt_tokens[self.active_adapter]
+            .unsqueeze(0)
+            .expand(batch_size, -1)
+            .to(prompt_encoder.embedding.weight.device)
+        )
+        if peft_config.peft_type in (PeftType.PREFIX_TUNING, PeftType.CARTRIDGE):
+            prompt_tokens = prompt_tokens[:, : peft_config.num_virtual_tokens]
+            if peft_config.inference_mode:
+                past_key_values = prompt_encoder.embedding.weight.repeat(batch_size, 1, 1)
+            else:
+                past_key_values = prompt_encoder(prompt_tokens)
+            if self.base_model_torch_dtype is not None:
+                past_key_values = past_key_values.to(self.base_model_torch_dtype)
+            past_key_values = past_key_values.view(
+                batch_size,
+                peft_config.num_virtual_tokens,
+                peft_config.num_layers * 2,
+                peft_config.num_attention_heads,
+                peft_config.token_dim // peft_config.num_attention_heads,
+            )
+            if peft_config.num_transformer_submodules == 2:
+                past_key_values = torch.cat([past_key_values, past_key_values], dim=2)
+
+            # Transpose: 2 x [num_layers, batch_size, num_heads, num_virtual_tokens, head_dim]
+            past_key_values = past_key_values.permute([2, 0, 3, 1, 4]).split(
+                peft_config.num_transformer_submodules * 2
+            )
+
+            base_model = self.get_base_model()
+            model_config = getattr(base_model, "config", None)
+            model_type = getattr(model_config, "model_type", "")
+            if TRANSFORMERS_MODELS_TO_PREFIX_TUNING_POSTPROCESS_MAPPING.get(self.config.model_type, None) is not None:
+                post_process_fn = TRANSFORMERS_MODELS_TO_PREFIX_TUNING_POSTPROCESS_MAPPING[self.config.model_type]
+                past_key_values = post_process_fn(past_key_values)
+            elif ("gemma2" in model_type) or ("gemma3_text" in model_type) or ("gemma4" in model_type):
+                # TODO: remove this logic once transformers < 4.56 is dropped
+                transformers_lt_4_56 = packaging.version.parse(transformers.__version__) < packaging.version.parse(
+                    "4.56.0.dev0"
+                )
+                # Gemma2 and Gemma3 only support HybridCache (which does not have the from_legacy_cache method)
+                if transformers_lt_4_56 and ((max_cache_len is None) or (max_cache_len == -1)):
+                    raise ValueError(
+                        "max_cache_len is missing but it should have been passed. Something went wrong, please open an "
+                        "issue on GitHub with a reproducer: https://github.com/huggingface/peft/issues"
+                    )
+                base_config = base_model.config
+                if hasattr(base_config, "get_text_config"):
+                    base_config = base_config.get_text_config()
+                if transformers_lt_4_56:
+                    # HybridCache is deprecated, and will be removed in 4.60.0
+                    # see https://github.com/huggingface/transformers/pull/40276
+                    from transformers import HybridCache
+
+                    new_cache = HybridCache(
+                        config=base_config,
+                        max_batch_size=batch_size,
+                        max_cache_len=max_cache_len,
+                        dtype=past_key_values[0].dtype,
+                        device=past_key_values[0].device,
+                    )
+                else:
+                    # transformers 4.56+ uses DynamicCache for gemma
+                    new_cache = DynamicCache(config=base_config)
+                cache_position = torch.arange(peft_config.num_virtual_tokens, device=past_key_values[0].device)
+                # Layers from `num_hidden_layers - num_kv_shared_layers` onward share KV with an earlier layer (no own
+                # k_proj/v_proj) and never call `cache.update`; the prefix reaches them transitively via the source
+                # layer.
+                num_kv_shared_layers = getattr(base_config, "num_kv_shared_layers", 0)
+                first_kv_shared_layer_idx = (
+                    getattr(base_config, "num_hidden_layers", peft_config.num_layers) - num_kv_shared_layers
+                )
+                injected_layers: list[int] = []
+                skipped_layers: list[int] = []
+                # past_key_values is a tuple of `num_layers` per-layer tensors each shaped
+                # [2, batch, num_heads, num_virtual_tokens, head_dim], where dim 0 stacks K and V.
+                for layer_idx, layer_past_key_values in enumerate(past_key_values):
+                    if num_kv_shared_layers > 0 and layer_idx >= first_kv_shared_layer_idx:
+                        skipped_layers.append(layer_idx)
+                        continue
+                    key_states, value_states = layer_past_key_values
+                    shape_or_none = _get_layer_kv_target_shape(base_config, layer_idx)
+                    if shape_or_none is not None:  # e.g. gemma 4
+                        n_h, d = shape_or_none
+                        # Provisioned shape: [batch, num_heads, num_virtual_tokens, head_dim]. If a layer's KV is wider
+                        # than what we provisioned, we cannot slice up; skip rather than silently truncating to a shape
+                        # the model won't accept.
+                        if n_h > key_states.shape[1] or d > key_states.shape[3]:
+                            skipped_layers.append(layer_idx)
+                            continue
+                        key_states = key_states[:, :n_h, :, :d]
+                        value_states = value_states[:, :n_h, :, :d]
+                    new_cache.update(
+                        key_states, value_states, layer_idx, cache_kwargs={"cache_position": cache_position}
+                    )
+                    injected_layers.append(layer_idx)
+                past_key_values = new_cache
+
+                if not injected_layers:
+                    # raise if no layer was matched; similar logic as in target_modules not matching any layer
+                    raise ValueError(
+                        "Prefix tuning skipped every layer because no layer's KV shape matched the provisioned prefix "
+                        f"(num_attention_heads={peft_config.num_attention_heads}, "
+                        f"head_dim={peft_config.token_dim // peft_config.num_attention_heads}). Override `token_dim` "
+                        "and `num_attention_heads` in `PrefixTuningConfig` to match a layer that should receive the "
+                        "prefix."
+                    )
+                if skipped_layers:
+                    warnings.warn(
+                        f"Prefix tuning injected into layers {injected_layers}; skipped {skipped_layers} due to KV "
+                        "shape mismatch or shared-KV layers."
+                    )
+
+            elif peft_config.num_transformer_submodules == 1:
+                # Don't apply this to encoder-decoder models and not to models requiring special processing.
+                # TODO: remove from_legacy_cache once transformers < 4.56 is dropped
+                transformers_lt_4_56 = packaging.version.parse(transformers.__version__) < packaging.version.parse(
+                    "4.56.0.dev0"
+                )
+                if transformers_lt_4_56:
+                    past_key_values = DynamicCache.from_legacy_cache(past_key_values)
+                else:
+                    past_key_values = DynamicCache(past_key_values)
+
+            elif (peft_config.num_transformer_submodules == 2) and getattr(
+                self.base_model, "_supports_cache_class", True
+            ):
+                # Don't apply this to encoder-decoder models that don't support new Cache format yet
+                # If we don't apply this, prefix-tuning fails to update cross-attn cache
+                # TODO: remove check for _supports_cache_class once transformers 4.53 is no longer supported
+                # TODO: remove from_legacy_cache once transformers < 4.56 is dropped
+                transformers_lt_4_56 = packaging.version.parse(transformers.__version__) < packaging.version.parse(
+                    "4.56.0.dev0"
+                )
+                if transformers_lt_4_56:
+                    past_key_values = EncoderDecoderCache.from_legacy_cache(past_key_values)
+                else:
+                    past_key_values = EncoderDecoderCache(past_key_values)
+
+                past_key_values.cross_attention_cache = DynamicCache()
+                # invalidate the cross attention cache, since we add virtual tokens to the encoder
+                for key in past_key_values.is_updated.keys():
+                    past_key_values.is_updated[key] = False
+            map_cache_to_layer_device_map(self.get_base_model(), past_key_values)  # no-op if not a Cache instance
+            return past_key_values
+        else:
+            if peft_config.peft_type == PeftType.MULTITASK_PROMPT_TUNING:
+                prompts = prompt_encoder(prompt_tokens, task_ids)
+            else:
+                if peft_config.inference_mode:
+                    prompts = prompt_encoder.embedding.weight
+                else:
+                    # Take only one prompt token sample and expand the output instead of expanding the input, see:
+                    # https://github.com/huggingface/peft/issues/2043#issuecomment-2321522577
+                    prompt_tokens = prompt_tokens[:1]
+                    prompts = prompt_encoder(prompt_tokens)
+                prompts = prompts.repeat(batch_size, 1, 1)
+            return prompts
+
+    def get_nb_trainable_parameters(self) -> tuple[int, int]:
+        r"""
+        Returns the number of trainable parameters and the number of all parameters in the model.
+        """
+        trainable_params = 0
+        all_param = 0
+        for _, param in self.named_parameters():
+            num_params = param.numel()
+            # if using DS Zero 3 and the weights are initialized empty
+            if num_params == 0 and hasattr(param, "ds_numel"):
+                num_params = param.ds_numel
+
+            # Due to the design of 4bit linear layers from bitsandbytes
+            # one needs to multiply the number of parameters by 2 to get
+            # the correct number of parameters
+            if param.__class__.__name__ == "Params4bit":
+                if hasattr(param, "element_size"):
+                    num_bytes = param.element_size()
+                elif not hasattr(param, "quant_storage"):
+                    num_bytes = 1
+                else:
+                    num_bytes = param.quant_storage.itemsize
+                num_params = num_params * 2 * num_bytes
+
+            all_param += num_params
+            if param.requires_grad:
+                trainable_params += num_params
+
+        return trainable_params, all_param
+
+    def print_trainable_parameters(self) -> None:
+        """
+        Prints the number of trainable parameters in the model.
+
+        Note: print_trainable_parameters() uses get_nb_trainable_parameters() which is different from
+        num_parameters(only_trainable=True) from huggingface/transformers. get_nb_trainable_parameters() returns
+        (trainable parameters, all parameters) of the Peft Model which includes modified backbone transformer model.
+        For techniques like LoRA, the backbone transformer model is modified in place with LoRA modules. However, for
+        prompt tuning, the backbone transformer model is unmodified. num_parameters(only_trainable=True) returns number
+        of trainable parameters of the backbone transformer model which can be different.
+        """
+        trainable_params, all_param = self.get_nb_trainable_parameters()
+
+        print(
+            f"trainable params: {trainable_params:,d} || all params: {all_param:,d} || trainable%: {100 * trainable_params / all_param:.4f}"
+        )
+
+    def __getattr__(self, name: str):
+        """Forward missing attributes to the wrapped module."""
+        try:
+            return super().__getattr__(name)  # defer to nn.Module's logic
+        except AttributeError:
+            if name == "base_model":  # see #1892: prevent infinite recursion if class is not initialized
+                raise
+            return getattr(self.base_model, name)
+
+    @contextmanager
+    def _enable_peft_forward_hooks(self, *args, **kwargs):
+        # If the base model has a method called _enable_peft_forward_hooks, it is invoked as a context. Otherwise, this
+        # runs without any changes
+        if hasattr(self.base_model, "_enable_peft_forward_hooks") and self.has_active_enabled_adapter:
+            with self.base_model._enable_peft_forward_hooks(*args, **kwargs):
+                yield
+            return
+        else:
+            # nothing to enable
+            yield
+            return
+
+    def forward(self, *args: Any, **kwargs: Any):
+        """
+        Forward pass of the model.
+        """
+        with self._enable_peft_forward_hooks(*args, **kwargs):
+            kwargs = {k: v for k, v in kwargs.items() if k not in self.special_peft_forward_args}
+            return self.get_base_model()(*args, **kwargs)
+
+    def generate(self, *args, **kwargs):
+        with self._enable_peft_forward_hooks(*args, **kwargs):
+            kwargs = {k: v for k, v in kwargs.items() if k not in self.special_peft_forward_args}
+            return self.get_base_model().generate(*args, **kwargs)
+
+    def _get_base_model_class(self, is_prompt_tuning=False):
+        """
+        Returns the base model class.
+        """
+        if not is_prompt_tuning:
+            return self.base_model.model.__class__
+        return self.base_model.__class__
+
+    @contextmanager
+    def disable_adapter(self):
+        """
+        Context manager that disables the adapter module. Use this to run inference on the base model.
+
+        Example:
+
+        ```py
+        >>> with model.disable_adapter():
+        ...     model(inputs)
+        ```
+        """
+        if self.peft_config[self.active_adapter].is_prompt_learning:
+            try:
+                # TODO: consider replacing this patching of methods with a more robust mechanism: setting a flag and
+                # letting the underlying methods deal with it, same as how LoRA does it.
+                old_forward = self.forward
+                self.forward = self.base_model.forward
+                old_prepare_inputs_for_generation = self.prepare_inputs_for_generation
+                self.prepare_inputs_for_generation = self.base_model.prepare_inputs_for_generation
+                self._adapters_disabled = True
+                yield
+            finally:
+                self.forward = old_forward
+                self.prepare_inputs_for_generation = old_prepare_inputs_for_generation
+                self._adapters_disabled = False
+
+        elif self.peft_config[self.active_adapter].is_adaption_prompt:
+            try:
+                self.base_model.disable_adapter_layers()
+                self._adapters_disabled = True
+                yield
+            finally:
+                self.base_model.enable_adapter_layers()
+                self._adapters_disabled = False
+
+        else:  # LoRA, LoHa, etc.
+            model_status = self.get_model_status()
+            if model_status.enabled == "irregular":
+                warnings.warn(
+                    "The model contains some adapter layers that are enabled and others that are disabled. "
+                    "This is most likely unintentional. After exiting the disable_adapter context, all adapters "
+                    "will be enabled"
+                )
+            try:
+                self.base_model.disable_adapter_layers()
+                self._adapters_disabled = True
+                yield
+            finally:
+                if model_status.enabled is not False:
+                    # model_status.enabled is `True` or `"irregular"`
+                    self.base_model.enable_adapter_layers()
+                self._adapters_disabled = False
+
+    def get_base_model(self) -> torch.nn.Module:
+        """
+        Returns the base model.
+        """
+        return self.base_model if self.active_peft_config.is_prompt_learning else self.base_model.model
+
+    def add_adapter(
+        self,
+        adapter_name: str,
+        peft_config: PeftConfig,
+        low_cpu_mem_usage: bool = False,
+        autocast_adapter_dtype: bool = True,
+    ) -> None:
+        """
+        Add an adapter to the model based on the passed configuration.
+
+        This adapter is not trained. To load a trained adapter, check out [`PeftModel.load_adapter`].
+
+        The name for the new adapter should be unique.
+
+        The new adapter is not automatically set as the active adapter. Use [`PeftModel.set_adapter`] to set the active
+        adapter.
+
+        Args:
+            adapter_name (`str`):
+                The name of the adapter to be added.
+            peft_config ([`PeftConfig`]):
+                The configuration of the adapter to be added.
+            low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+                Create empty adapter weights on meta device. Useful to speed up the process when loading saved
+                adapters. Don't use this option when creating a new PEFT adapter for training.
+            autocast_adapter_dtype (`bool`, *optional*, defaults to `True`):
+                Whether to autocast the adapter dtype. Defaults to `True`. Right now, this will only cast adapter
+                weights using float16 and bfloat16 to float32, as this is typically required for stable training, and
+                only affect select PEFT tuners. If set to `False`, the dtypes will stay the same as those of the
+                corresponding layer.
+        """
+        prefix = PEFT_TYPE_TO_PREFIX_MAPPING.get(peft_config.peft_type)
+        if prefix and adapter_name in prefix:
+            warnings.warn(
+                f"Adapter name '{adapter_name}' should not be contained in the prefix '{prefix}'. "
+                "This may lead to reinitialization of the adapter weights during loading."
+            )
+
+        if peft_config.peft_type != self.peft_type:
+            raise ValueError(
+                f"Cannot combine adapters with different peft types. "
+                f"Found {self.peft_type} and {peft_config.peft_type}."
+            )
+
+        try:
+            if peft_config.is_prompt_learning:
+                self.peft_config[adapter_name] = peft_config
+                peft_config = _prepare_prompt_learning_config(peft_config, self.config)
+                self._setup_prompt_encoder(adapter_name)
+                set_additional_trainable_modules(
+                    model=self.base_model,
+                    peft_config=peft_config,
+                    model_config=BaseTuner.get_model_config(self),
+                    adapter_name=adapter_name,
+                )
+            elif peft_config.is_adaption_prompt:
+                self.base_model.add_adapter(adapter_name, peft_config)
+                set_additional_trainable_modules(
+                    model=self.base_model,
+                    peft_config=peft_config,
+                    model_config=BaseTuner.get_model_config(self),
+                    adapter_name=adapter_name,
+                )
+            else:
+                self.peft_config[adapter_name] = peft_config
+                self.base_model.inject_adapter(
+                    self.base_model.model, adapter_name, low_cpu_mem_usage=low_cpu_mem_usage
+                )
+        except Exception:  # something went wrong, roll back
+            if adapter_name in self.peft_config:
+                del self.peft_config[adapter_name]
+            raise
+
+        if hasattr(self.base_model, "_cast_adapter_dtype"):
+            self.base_model._cast_adapter_dtype(
+                adapter_name=adapter_name, autocast_adapter_dtype=autocast_adapter_dtype
+            )
+
+    def delete_adapter(self, adapter_name: str) -> None:
+        """
+        Deletes an existing adapter.
+
+        Args:
+            adapter_name (str): Name of the adapter to be deleted.
+        """
+        if adapter_name not in self.peft_config:
+            raise ValueError(f"Adapter {adapter_name} does not exist")
+
+        self.base_model.delete_adapter(adapter_name=adapter_name)
+        new_active_adapters = self.active_adapters
+        num_adapters = len(new_active_adapters)
+        # Note: PeftModel assumes that there is exactly one active adapter, so we should theoretically raise if
+        # num_adapters != 1. However, we have allowed this in the past (maybe inadvertently), so we let it slip and
+        # don't introduce a backwards incompatibility by raising an error.
+        if num_adapters == 1:
+            self.active_adapter = new_active_adapters[0]
+
+    @property
+    def modules_to_save(self) -> Optional[set[str]]:
+        modules: set[str] = set()
+        for config in self.peft_config.values():
+            if getattr(config, "modules_to_save", None) is not None:
+                # modules_to_save can only be a sequence of str, not a str
+                modules.update(config.modules_to_save)
+
+        if not modules:
+            # for backwards compatibility, as modules_to_save was initialized as None
+            return None
+        return modules
+
+    def get_layer_status(self) -> list[TunerLayerStatus]:
+        """Get the status of each adapter layer in the model.
+
+        This method returns a list of `TunerLayerStatus` dataclass instances, each of which contains the following
+        attributes:
+
+        - `name` (`str`):
+           The name of the adapter layer, e.g. `model.encoder.block.0.layer.0.SelfAttention.q`.
+        - `module_type` (`str`):
+           The type of the adapter layer, e.g. `lora.Linear`.
+        - `enabled` (`bool`):
+           Whether the adapter layer is enabled.
+        - `active_adapters` (`list[str]`):
+           The names of the active adapters, if any, e.g. `["default"]`.
+        - `merged_adapters` (`list[str]`):
+           The names of the merged adapters, if any, e.g. `["default"]`.
+        - `available_adapters` (`list[str]`):
+           The names of the available adapters, e.g. `["default"]`.
+        - `quantization_backend` (`str` or `None`):
+           The name of the quantization backend, e.g. `"bnb 4bit"`, or `None` if not quantized.
+
+        Returns:
+            list[`peft.peft_model.TunerLayerStatus`]:
+                A list of dataclasses, each containing the status of the corresponding adapter layer.
+
+        """
+        return get_layer_status(self)
+
+    def get_model_status(self) -> TunerModelStatus:
+        """Get the status of tuners of the model.
+
+        This method returns a `TunerModelStatus` dataclass instance, which contains the following attributes:
+
+        - `base_model_type` (`str`):
+           The type of the base model, e.g. `T5Model`.
+        - `adapter_model_type` (`str`):
+           The type of the adapter model, e.g. `LoraModel`.
+        - `peft_types` (`dict[str, str]`):
+           The mapping of adapter name to adapter type, e.g. `{"default": "LORA"}`.
+        - `trainable_params` (`int`):
+           The number of trainable parameters in the model.
+        - `total_params` (`int`):
+           The total number of parameters in the model.
+        - `num_adapter_layers` (`int`):
+           The number of adapter layers in the model.
+        - `enabled` (`bool`, `Literal["irregular"]`):
+           Whether all adapter layers are enabled. If some are enabled and some are not, this will be `"irregular"`.
+           This means that your model is in an inconsistent state and might not work as expected.
+        - `active_adapters` (`list[str]`, `Literal["irregular"]`):
+           The names of the active adapters. If the active adapters are not consistent across all layers, this will be
+           `"irregular"`, which means that your model is in an inconsistent state and might not work as expected.
+        - `merged_adapters` (`list[str]`, `Literal["irregular"]`):
+           The names of the merged adapters. If the merged adapters are not consistent across all layers, this will be
+           `"irregular"`, which means that your model is in an inconsistent state and might not work as expected.
+        - `available_adapters` (`list[str]`):
+           The names of the available adapters, e.g. `["default"]`.
+        - `quantization_backend` (`str`, `None`, `Literal["irregular"]`):
+           The name of the quantization backend, e.g. `"bnb 4bit"`, or `None` if not quantized. If the backend is not
+           consistent across all layers, this will be `"irregular"`.
+
+        Returns:
+            `peft.peft_model.TunerModelStatus`:
+                A dataclass containing the status of the model.
+
+        """
+        return get_model_status(self)
+
+    @classmethod
+    def _split_kwargs(cls, kwargs: dict[str, Any]):
+        _kwargs_not_in_hf_hub_download_signature = ("use_auth_token",)
+        hf_hub_download_kwargs = {}
+        other_kwargs = {}
+
+        for key, value in kwargs.items():
+            if key in inspect.signature(hf_hub_download).parameters or key in _kwargs_not_in_hf_hub_download_signature:
+                hf_hub_download_kwargs[key] = value
+            else:
+                other_kwargs[key] = value
+
+        return hf_hub_download_kwargs, other_kwargs
+
+    def _update_offload(self, offload_index: dict[str, dict[str, str]], adapters_weights: dict[str, torch.tensor]):
+        """
+        Update the offload_index and safetensors files for loading and mergine PeftModels with disk-offloaded modules.
+
+        Args:
+            offload_index (Dict[str: str]):
+                Dictionary of disk-offloaded modules with their metadata and safetensors filenames
+            adapters_weights (Dict[str: torch.tensor]):
+                Dictionary of Peft adapter module names and weights
+        """
+
+        if not offload_index:
+            return offload_index
+
+        prefix = "base_model.model."
+        # rename offload index weight and model names
+        adapter_names = list(self.peft_config.keys())
+        for adapter_name in adapter_names:
+            keys = list(offload_index.keys())
+            block_id = keys[0].split(".")[0] + "."  # for writing safetensors key,
+
+            # replace original offload index keys with PeftModel keys
+            for key in keys:
+                suffix_pos = key.rfind(".")
+                extended_prefix = prefix + key[:suffix_pos]
+                module = dict(self.named_modules())[extended_prefix]
+                if isinstance(module, BaseTunerLayer):
+                    new_key = prefix + key[:suffix_pos] + ".base_layer" + key[suffix_pos:]
+                else:
+                    new_key = prefix + key
+                offload_index[key]["weight_name"] = new_key
+                offload_index[new_key] = offload_index[key]
+                del offload_index[key]
+
+            files_seen = set()
+            # rename safetensors for dispatch
+            for new_key in list(offload_index.keys()):
+                fname = offload_index[new_key]["safetensors_file"]
+
+                # make a new file name
+                new_fname_list = list(fname.split(os.sep))
+                for i, name in enumerate(new_fname_list):
+                    if "--" in name:
+                        new_fname_list[i] += "-peft"
+                        break
+                new_fname = os.path.join(*new_fname_list)
+
+                if fname in files_seen:
+                    continue
+                safe_dict = {}
+                with safe_open(fname, framework="pt") as f:
+                    for safe_key in f.keys():
+                        safe_tensor = f.get_tensor(safe_key)
+                        metadata = f.metadata()
+                        suffix_pos = safe_key.rfind(".")
+                        extended_prefix = prefix + block_id + safe_key[:suffix_pos]
+                        safe_module = dict(self.named_modules())[extended_prefix]
+                        if isinstance(safe_module, BaseTunerLayer):
+                            final_key = extended_prefix + ".base_layer" + safe_key[suffix_pos:]
+                            lora_dict = {key: val for key, val in adapters_weights.items() if extended_prefix in key}
+
+                            # add LoRA keys and values to disk offload
+                            for lora_key, lora_val in lora_dict.items():
+                                divide = lora_key.rfind(".")
+                                new_key = lora_key[:divide] + f".{adapter_name}" + lora_key[divide:]
+                                safe_dict[new_key] = lora_val
+                        else:
+                            final_key = prefix + block_id + safe_key
+                        safe_dict[final_key] = safe_tensor
+                    files_seen.add(new_fname)
+
+                    # avoid overwriting original safetensors
+                    for key in safe_dict.keys():
+                        offload_index[key] = {"safetensors_file": new_fname, "weight_name": key}
+
+                    base_name = os.path.dirname(new_fname)
+                    if not os.path.exists(base_name):
+                        os.makedirs(base_name)
+                    safe_save_file(safe_dict, new_fname, metadata=metadata)
+
+    def _check_new_adapter_config(self, peft_config: PeftConfig, is_trainable: bool) -> None:
+        """Perform checks on newly added PEFT configs to ensure integrity."""
+        if peft_config.is_prompt_learning and is_trainable:
+            raise ValueError("Cannot set a prompt learning adapter to trainable when loading pretrained adapter.")
+
+        # Since PiSSA/CorDA/OLoRA modifies the base weights, it should not be combined with other adapters.
+        all_configs = [peft_config] + list(self.peft_config.values())
+        if len(all_configs) > 1:
+            if any(getattr(config, "init_lora_weights", None) == "pissa" for config in all_configs):
+                msg = (
+                    "PiSSA changes the base weights of the model and should thus not be used with other adapters. "
+                    "Consider converting the PiSSA adapter into a normal LoRA adapter: "
+                    "https://github.com/huggingface/peft/tree/main/examples/pissa_finetuning#convert-pissa-to-lora"
+                )
+                warnings.warn(msg)
+            elif any(getattr(config, "init_lora_weights", None) == "corda" for config in all_configs):
+                msg = (
+                    "CorDA changes the base weights of the model and should thus not be used with other adapters. "
+                    "Consider converting the CorDA adapter into a normal LoRA adapter: "
+                    "https://github.com/huggingface/peft/tree/main/examples/corda_finetuning#convert-corda-to-lora"
+                )
+                warnings.warn(msg)
+            elif any(getattr(config, "init_lora_weights", None) == "olora" for config in all_configs):
+                msg = (
+                    "OLoRA changes the base weights of the model and should thus not be used with other adapters. "
+                    "Consider converting the OLoRA adapter into a normal LoRA adapter: "
+                    "https://github.com/huggingface/peft/tree/main/examples/olora_finetuning#olora-and-lora"
+                )
+                warnings.warn(msg)
+
+    def load_adapter(
+        self,
+        model_id: Union[str, os.PathLike],
+        adapter_name: str,
+        is_trainable: bool = False,
+        torch_device: Optional[str] = None,
+        autocast_adapter_dtype: bool = True,
+        ephemeral_gpu_offload: bool = False,
+        low_cpu_mem_usage: bool = False,
+        key_mapping: Optional[dict[str, str]] = None,
+        **kwargs: Any,
+    ):
+        """
+        Load a trained adapter into the model.
+
+        The name for the new adapter should be unique.
+
+        The new adapter is not automatically set as the active adapter. Use [`PeftModel.set_adapter`] to set the active
+        adapter.
+
+        Args:
+            model_id (`str` or `os.PathLike`):
+                The name of the PEFT configuration to use. Can be either:
+                    - A string, the `model id` of a PEFT configuration hosted inside a model repo on the Hugging Face
+                      Hub.
+                    - A path to a directory containing a PEFT configuration file saved using the `save_pretrained`
+                      method (`./my_peft_config_directory/`).
+            adapter_name (`str`):
+                The name of the adapter to be added.
+            is_trainable (`bool`, *optional*, defaults to `False`):
+                Whether the adapter should be trainable or not. If `False`, the adapter will be frozen and can only be
+                used for inference.
+            torch_device (`str`, *optional*, defaults to None):
+                The device to load the adapter on. If `None`, the device will be inferred.
+            autocast_adapter_dtype (`bool`, *optional*, defaults to `True`):
+                Whether to autocast the adapter dtype. Defaults to `True`. Right now, this will only cast adapter
+                weights using float16 and bfloat16 to float32, as this is typically required for stable training, and
+                only affect select PEFT tuners. If set to `False`, the dtypes will stay the same as those of the
+                corresponding layer.
+            ephemeral_gpu_offload (`bool`, *optional*, defaults to `False`):
+                Whether to use ephemeral GPU offloading for partially loaded modules. Defaults to `False`.
+            low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+                Create empty adapter weights on meta device before loading the saved weights. Useful to speed up the
+                process.
+            key_mapping (dict, *optional*, defaults to None)
+                Extra mapping of PEFT `state_dict` keys applied before loading the `state_dict`. When this mapping is
+                applied, the PEFT-specific `"base_model.model"` prefix is removed beforehand and the adapter name (e.g.
+                `"default"`) is not inserted yet. Only pass this argument if you know what you're doing.
+            kwargs: (`optional`):
+                Additional arguments to modify the way the adapter is loaded, e.g. the token for Hugging Face Hub.
+        """
+        from .mapping import PEFT_TYPE_TO_CONFIG_MAPPING
+
+        hf_hub_download_kwargs, kwargs = self._split_kwargs(kwargs)
+        if torch_device is None:
+            torch_device = infer_device()
+
+        if adapter_name not in self.peft_config:
+            # load the config
+            peft_config = PEFT_TYPE_TO_CONFIG_MAPPING[
+                PeftConfig._get_peft_type(
+                    model_id,
+                    **hf_hub_download_kwargs,
+                )
+            ].from_pretrained(
+                model_id,
+                ephemeral_gpu_offload=ephemeral_gpu_offload,
+                **hf_hub_download_kwargs,
+            )
+            self._check_new_adapter_config(peft_config, is_trainable=is_trainable)
+            peft_config.inference_mode = not is_trainable
+            self.add_adapter(
+                adapter_name,
+                peft_config,
+                low_cpu_mem_usage=low_cpu_mem_usage,
+                autocast_adapter_dtype=autocast_adapter_dtype,
+            )
+
+        adapters_weights = load_peft_weights(
+            model_id, device=torch_device, key_mapping=key_mapping, **hf_hub_download_kwargs
+        )
+
+        # load the weights into the model
+        ignore_mismatched_sizes = kwargs.get("ignore_mismatched_sizes", False)
+        load_result = set_peft_model_state_dict(
+            self,
+            adapters_weights,
+            adapter_name=adapter_name,
+            ignore_mismatched_sizes=ignore_mismatched_sizes,
+            low_cpu_mem_usage=low_cpu_mem_usage,
+        )
+
+        tuner = self.peft_config[adapter_name].peft_type
+        tuner_prefix = PEFT_TYPE_TO_PREFIX_MAPPING.get(tuner, "")
+        adapter_missing_keys = []
+
+        # Filter missing keys specific to the current adapter and tuner prefix.
+        for key in load_result.missing_keys:
+            if tuner_prefix in key and adapter_name in key:
+                # TinyLoRA: layer-level tinylora_v is a reference to model-level, skip it
+                if ".tinylora_v." in key:
+                    continue
+                if (
+                    tuner == PeftType.UNILORA
+                    and ".unilora_theta_d." in key
+                    and not key.startswith("base_model.unilora_theta_d.")
+                ):
+                    continue
+                if (
+                    tuner == PeftType.UNILORA
+                    and not getattr(self.peft_config[adapter_name], "save_indices", False)
+                    and (".unilora_indices_" in key or ".unilora_scales_" in key)
+                ):
+                    continue
+                adapter_missing_keys.append(key)
+
+        load_result.missing_keys.clear()
+        load_result.missing_keys.extend(adapter_missing_keys)
+
+        if (
+            (getattr(self, "hf_device_map", None) is not None)
+            and (len(set(self.hf_device_map.values()).intersection({"cpu", "disk"})) > 0)
+            and len(self.peft_config) == 1
+        ):
+            device_map = kwargs.get("device_map", "auto")
+            max_memory = kwargs.get("max_memory", None)
+            offload_folder = kwargs.get("offload_folder", None)
+            offload_dir = kwargs.get("offload_dir", None)
+            offload_index = kwargs.get("offload_index", None)
+
+            if offload_dir is not None and offload_folder is not None:
+                # see https://github.com/huggingface/peft/issues/2541
+                raise ValueError("Cannot use `offload_folder` when `offload_dir` is specified.")
+            elif offload_dir is None:
+                # to keep backwards compatibility
+                offload_dir = offload_folder
+
+            dispatch_model_kwargs = {}
+            # Safety checker for previous `accelerate` versions
+            # `offload_index` was introduced in https://github.com/huggingface/accelerate/pull/873/
+            if "offload_index" in inspect.signature(dispatch_model).parameters:
+                dispatch_model_kwargs["offload_index"] = offload_index
+
+            no_split_module_classes = self._no_split_modules
+            if isinstance(no_split_module_classes, set):
+                no_split_module_classes = list(no_split_module_classes)
+
+            if device_map != "sequential":
+                max_memory = get_balanced_memory(
+                    self,
+                    max_memory=max_memory,
+                    no_split_module_classes=no_split_module_classes,
+                    low_zero=(device_map == "balanced_low_0"),
+                )
+
+            if isinstance(device_map, str):
+                device_map = infer_auto_device_map(
+                    self, max_memory=max_memory, no_split_module_classes=no_split_module_classes
+                )
+
+            self._update_offload(offload_index, adapters_weights)
+            dispatch_model_kwargs["offload_index"] = offload_index
+
+            dispatch_model(
+                self,
+                device_map=device_map,
+                offload_dir=offload_dir,
+                **dispatch_model_kwargs,
+            )
+
+            hook = AlignDevicesHook(io_same_device=True)
+            if self.peft_config[adapter_name].is_prompt_learning:
+                remove_hook_from_submodules(self.prompt_encoder)
+            add_hook_to_module(self.get_base_model(), hook)
+
+        if hasattr(self.base_model, "_cast_adapter_dtype"):
+            self.base_model._cast_adapter_dtype(
+                adapter_name=adapter_name, autocast_adapter_dtype=autocast_adapter_dtype
+            )
+
+        # Set model in evaluation mode to deactivate Dropout modules by default
+        if not is_trainable:
+            self.eval()
+        return load_result
+
+    def set_adapter(self, adapter_name: str, inference_mode: bool = False) -> None:
+        """
+        Sets the active adapter.
+
+        Only one adapter can be active at a time.
+
+        Additionally, this function will set the specified adapter to trainable (i.e., requires_grad=True) unless
+        inference_mode is True.
+
+        Args:
+            adapter_name (`str`):
+                The name of the adapter to be set as active. The adapter must be loaded first.
+            inference_mode (`bool`, optional):
+                Whether the activated adapter should be frozen (i.e. `requires_grad=False`). Default is False.
+        """
+        if adapter_name not in self.peft_config:
+            raise ValueError(f"Adapter {adapter_name} not found.")
+        self.active_adapter = adapter_name
+        if not self.peft_config[adapter_name].is_prompt_learning:
+            # _set_adapter does not need to be called, since it's called through the BaseTuner class.
+            self.base_model.set_adapter(adapter_name, inference_mode=inference_mode)
+        else:
+            # handle auxiliary modules
+            _set_adapter(self, adapter_name, inference_mode=inference_mode)
+
+    def set_requires_grad(self, adapter_names: str | Sequence[str], requires_grad: bool = True) -> None:
+        """
+        Enable or disable gradients on the given adapter(s).
+
+        Note: Not supported for prompt learning methods like prompt tuning.
+
+        Args:
+            adapter_names (`str` or `Sequence[str]`):
+                The name of the adapter(s) whose gradients should be enabled/disabled.
+            requires_grad (`bool`, *optional*)
+                Whether to enable (`True`, default) or disable (`False`).
+        """
+        if self.active_peft_config.is_prompt_learning:
+            raise TypeError(
+                "Setting `requires_grad` is not supported for prompt learning methods like "
+                f"{self.active_peft_config.peft_type.value}."
+            )
+
+        self.base_model.set_requires_grad(adapter_names=adapter_names, requires_grad=requires_grad)
+
+    @property
+    def base_model_torch_dtype(self):
+        return getattr(self.base_model, "dtype", None)
+
+    @property
+    def active_peft_config(self):
+        return self.peft_config[self.active_adapter]
+
+    def _adjust_prompt_learning_kwargs(
+        self,
+        peft_config: PeftConfig,
+        *,
+        kwargs: dict[str, Any],
+        remove_token_type_ids: bool = True,
+    ) -> None:
+        """Adjust prompt-learning kwargs for supported position and token ids"""
+        if kwargs.get("position_ids", None) is not None:
+            if peft_config.peft_type in (PeftType.PREFIX_TUNING, PeftType.CARTRIDGE):
+                # Offset position_ids by num_virtual_tokens to account for the KV cache prefix
+                kwargs["position_ids"] = kwargs["position_ids"] + peft_config.num_virtual_tokens
+            else:
+                warnings.warn("Position ids are not supported for parameter efficient tuning. Ignoring position ids.")
+                kwargs["position_ids"] = None
+
+        if remove_token_type_ids and kwargs.get("token_type_ids", None) is not None:
+            warnings.warn("Token type ids are not supported for parameter efficient tuning. Ignoring token type ids")
+            kwargs["token_type_ids"] = None
+
+    def _get_peft_specific_model_tags(self):
+        """Derive tags for the model card from the adapter's config. For example, setting the
+        base model is important for enabling support for HF inference providers but it also makes models more
+        searchable on the HF hub.
+        """
+        peft_method = self.active_peft_config.peft_type
+        if not isinstance(peft_method, str):
+            peft_method = peft_method.value
+
+        tags = []
+
+        if hasattr(self.base_model, "model") and isinstance(self.base_model.model, transformers.PreTrainedModel):
+            tags.append("transformers")
+
+        if peft_method == "LORA":
+            tags.append("lora")
+
+        if hasattr(self.base_model, "name_or_path"):
+            tags.append(f"base_model:adapter:{self.base_model.name_or_path}")
+
+        return tags
+
+    def create_or_update_model_card(self, output_dir: str):
+        """
+        Updates or create model card to include information about peft:
+        1. Adds `peft` library tag
+        2. Adds peft version
+        3. Adds base model info
+        4. Adds quantization information if it was used
+        """
+
+        filename = os.path.join(output_dir, "README.md")
+
+        card = ModelCard.load(filename) if os.path.exists(filename) else ModelCard.from_template(ModelCardData())
+
+        card.data["library_name"] = "peft"
+
+        tags = set()
+        base_model = self.get_base_model()
+        if hasattr(base_model, "model_tags"):
+            tags = tags.union(base_model.model_tags or [])
+
+        tags = tags.union(self._get_peft_specific_model_tags())
+        if tags:
+            card.data["tags"] = sorted(tags)
+
+        # One of the rare moments where we can select the pipeline tag with certainty, so let's do that.
+        # Makes it easier to deploy an adapter with auto inference since the user doesn't have to add any tags.
+        if not card.data.pipeline_tag and isinstance(self, PeftModelForCausalLM):
+            card.data.pipeline_tag = "text-generation"
+
+        model_config = BaseTuner.get_model_config(self)
+        model_config = None if model_config == DUMMY_MODEL_CONFIG else model_config
+        if model_config is not None and "_name_or_path" in model_config:
+            card.data["base_model"] = model_config["_name_or_path"]
+
+        lines = card.text.splitlines()
+
+        quantization_config = None
+        if hasattr(model_config, "quantization_config"):
+            quantization_config = self.config.quantization_config.to_dict()
+        training_config_text = ""
+        quantization_prefix = "The following `bitsandbytes` quantization config was used during training:"
+        # Adds quantization information if it was used
+        if quantization_config is not None:
+            training_config_text += f"\n{quantization_prefix}\n"
+            training_config_text += "\n".join([f"- {name}: {value}" for name, value in quantization_config.items()])
+            training_config_text += "\n"
+
+        training_procedure_heading = "## Training procedure"
+        if quantization_prefix not in lines and bool(training_config_text):
+            if training_procedure_heading in lines:
+                lines.insert(lines.index(training_procedure_heading) + 2, training_config_text)
+            else:
+                lines.append(f"{training_procedure_heading}\n{training_config_text}")
+
+        # Adds peft version
+        framework_block_heading = "### Framework versions"
+        if f"- PEFT {__version__}" not in lines:
+            if framework_block_heading in lines:
+                lines.insert(lines.index(framework_block_heading) + 2, f"- PEFT {__version__}")
+            else:
+                lines.append(f"{framework_block_heading}\n\n- PEFT {__version__}")
+
+        card.text = "\n".join(lines)
+        card.save(filename)
+
+    def supports_lora_conversion(self, adapter_name: str = "default") -> bool:
+        """
+        Whether it is possible for the adapter of this model to be converted to LoRA.
+
+        Normally, this works if the PEFT method is additive, i.e. W' = W_base + delta_weight.
+        """
+        peft_config = self.active_peft_config
+        if peft_config.is_prompt_learning:
+            return False
+
+        if not hasattr(self.base_model, "supports_lora_conversion"):
+            return False
+
+        return self.base_model.supports_lora_conversion()
+
+
+class PeftModelForSequenceClassification(PeftModel):
+    """
+    Peft model for sequence classification tasks.
+
+    Args:
+        model ([`~transformers.PreTrainedModel`]): Base transformer model.
+        peft_config ([`PeftConfig`]): Peft config.
+        adapter_name (`str`,  *optional*): The name of the adapter, defaults to `"default"`.
+        autocast_adapter_dtype (`bool`, *optional*, defaults to `True`):
+            Whether to autocast the adapter dtype. Defaults to `True`. Right now, this will only cast adapter weights
+            using float16 and bfloat16 to float32, as this is typically required for stable training, and only affect
+            select PEFT tuners. If set to `False`, the dtypes will stay the same as those of the corresponding layer.
+
+    **Attributes**:
+        - **config** ([`~transformers.PretrainedConfig`]) -- The configuration object of the base model.
+        - **cls_layer_name** (`str`) -- The name of the classification layer.
+
+    Example:
+
+        ```py
+        >>> from transformers import AutoModelForSequenceClassification
+        >>> from peft import PeftModelForSequenceClassification, get_peft_config
+
+        >>> config = {
+        ...     "peft_type": "PREFIX_TUNING",
+        ...     "task_type": "SEQ_CLS",
+        ...     "inference_mode": False,
+        ...     "num_virtual_tokens": 20,
+        ...     "token_dim": 768,
+        ...     "num_transformer_submodules": 1,
+        ...     "num_attention_heads": 12,
+        ...     "num_layers": 12,
+        ...     "encoder_hidden_size": 768,
+        ...     "prefix_projection": False,
+        ...     "postprocess_past_key_value_function": None,
+        ... }
+
+        >>> peft_config = get_peft_config(config)
+        >>> model = AutoModelForSequenceClassification.from_pretrained("bert-base-cased")
+        >>> peft_model = PeftModelForSequenceClassification(model, peft_config)
+        >>> peft_model.print_trainable_parameters()
+        trainable params: 370178 || all params: 108680450 || trainable%: 0.3406113979101117
+        ```
+    """
+
+    def __init__(
+        self, model: torch.nn.Module, peft_config: PeftConfig, adapter_name: str = "default", **kwargs
+    ) -> None:
+        classifier_module_names = ["classifier", "score"]
+
+        if hasattr(peft_config, "modules_to_save"):
+            if peft_config.modules_to_save is None:
+                peft_config.modules_to_save = classifier_module_names[:]
+            else:
+                peft_config.modules_to_save.extend(classifier_module_names)
+
+        # The modification of peft_config must happen before the init call as the `modules_to_save` information
+        # will be used to guard the target layer matching against matching `modules_to_save` layers. Only the
+        # config is relevant for this, the `modules_to_save` attribute can follow later.
+        super().__init__(model, peft_config, adapter_name, **kwargs)
+
+        if hasattr(peft_config, "modules_to_save"):
+            for name, _ in self.base_model.named_children():
+                if any(module_name in name for module_name in self.modules_to_save):
+                    self.cls_layer_name = name
+                    break
+
+        # to make sure classifier layer is trainable; this may add a new ModulesToSaveWrapper
+        _set_trainable(
+            self,
+            adapter_name,
+            module_names=getattr(peft_config, "modules_to_save", None),
+            inference_mode=peft_config.inference_mode,
+        )
+
+    def add_adapter(
+        self,
+        adapter_name: str,
+        peft_config: PeftConfig,
+        low_cpu_mem_usage: bool = False,
+        autocast_adapter_dtype: bool = True,
+    ) -> None:
+        """
+        Add an adapter to the model based on the passed configuration.
+
+        This adapter is not trained. To load a trained adapter, check out [`PeftModel.load_adapter`].
+
+        The name for the new adapter should be unique.
+
+        The new adapter is not automatically set as the active adapter. Use [`PeftModel.set_adapter`] to set the active
+        adapter.
+
+        Args:
+            adapter_name (`str`):
+                The name of the adapter to be added.
+            peft_config ([`PeftConfig`]):
+                The configuration of the adapter to be added.
+            low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+                Create empty adapter weights on meta device. Useful to speed up the process when loading saved
+                adapters. Don't use this option when creating a new PEFT adapter for training.
+            autocast_adapter_dtype (`bool`, *optional*, defaults to `True`):
+                Whether to autocast the adapter dtype. Defaults to `True`. Right now, this will only cast adapter
+                weights using float16 and bfloat16 to float32, as this is typically required for stable training, and
+                only affect select PEFT tuners. If set to `False`, the dtypes will stay the same as those of the
+                corresponding layer.
+        """
+        # ensure that additional adapters also add the classifier layer to modules_to_save
+        if hasattr(peft_config, "modules_to_save"):
+            classifier_module_names = ["classifier", "score"]
+            if peft_config.modules_to_save is None:
+                peft_config.modules_to_save = classifier_module_names[:]
+            else:
+                peft_config.modules_to_save.extend(classifier_module_names)
+
+        return super().add_adapter(adapter_name, peft_config, low_cpu_mem_usage=low_cpu_mem_usage)
+
+    def forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        inputs_embeds=None,
+        labels=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+        task_ids=None,
+        **kwargs,
+    ):
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        peft_config = self.active_peft_config
+        if not peft_config.is_prompt_learning:
+            with self._enable_peft_forward_hooks(**kwargs):
+                kwargs = {k: v for k, v in kwargs.items() if k not in self.special_peft_forward_args}
+                if peft_config.peft_type == PeftType.POLY:
+                    kwargs["task_ids"] = task_ids
+                return self.base_model(
+                    input_ids=input_ids,
+                    attention_mask=attention_mask,
+                    inputs_embeds=inputs_embeds,
+                    labels=labels,
+                    output_attentions=output_attentions,
+                    output_hidden_states=output_hidden_states,
+                    return_dict=return_dict,
+                    **kwargs,
+                )
+
+        batch_size = _get_batch_size(input_ids, inputs_embeds)
+        if attention_mask is not None:
+            # concat prompt attention mask
+            prefix_attention_mask = torch.ones(batch_size, peft_config.num_virtual_tokens).to(attention_mask.device)
+            attention_mask = torch.cat((prefix_attention_mask, attention_mask), dim=1)
+        self._adjust_prompt_learning_kwargs(peft_config, kwargs=kwargs, remove_token_type_ids=False)
+        kwargs.update(
+            {
+                "attention_mask": attention_mask,
+                "labels": labels,
+                "output_attentions": output_attentions,
+                "output_hidden_states": output_hidden_states,
+                "return_dict": return_dict,
+            }
+        )
+
+        if peft_config.peft_type in (PeftType.PREFIX_TUNING, PeftType.CARTRIDGE):
+            return self._prefix_tuning_forward(input_ids=input_ids, **kwargs)
+        else:
+            if kwargs.get("token_type_ids", None) is not None:
+                kwargs["token_type_ids"] = torch.cat(
+                    (
+                        torch.zeros(batch_size, peft_config.num_virtual_tokens).to(self.word_embeddings.weight.device),
+                        kwargs["token_type_ids"],
+                    ),
+                    dim=1,
+                ).long()
+            if inputs_embeds is None:
+                inputs_embeds = self.word_embeddings(input_ids)
+            prompts = self.get_prompt(batch_size=batch_size, task_ids=task_ids)
+            prompts = prompts.to(inputs_embeds.dtype)
+            inputs_embeds = torch.cat((prompts, inputs_embeds), dim=1)
+            return self.base_model(inputs_embeds=inputs_embeds, **kwargs)
+
+    def _prefix_tuning_forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        inputs_embeds=None,
+        labels=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+        **kwargs,
+    ):
+        batch_size = _get_batch_size(input_ids, inputs_embeds)
+        past_key_values = self.get_prompt(batch_size)
+        fwd_params = list(inspect.signature(self.base_model.forward).parameters.keys())
+        kwargs.update(
+            {
+                "input_ids": input_ids,
+                "attention_mask": attention_mask,
+                "inputs_embeds": inputs_embeds,
+                "output_attentions": output_attentions,
+                "output_hidden_states": output_hidden_states,
+                "return_dict": return_dict,
+                "past_key_values": past_key_values,
+            }
+        )
+        if "past_key_values" in fwd_params:
+            return self.base_model(labels=labels, **kwargs)
+        else:
+            transformer_backbone_name = self.base_model.get_submodule(self.transformer_backbone_name)
+            fwd_params = list(inspect.signature(transformer_backbone_name.forward).parameters.keys())
+            if "past_key_values" not in fwd_params:
+                raise ValueError("Model does not support past key values which are required for prefix tuning.")
+            outputs = transformer_backbone_name(**kwargs)
+            pooled_output = outputs[1] if len(outputs) > 1 else outputs[0]
+            if "dropout" in [name for name, _ in list(self.base_model.named_children())]:
+                pooled_output = self.base_model.dropout(pooled_output)
+            logits = self.base_model.get_submodule(self.cls_layer_name)(pooled_output)
+
+            loss = None
+            if labels is not None:
+                if self.config.problem_type is None:
+                    if self.base_model.num_labels == 1:
+                        self.config.problem_type = "regression"
+                    elif self.base_model.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
+                        self.config.problem_type = "single_label_classification"
+                    else:
+                        self.config.problem_type = "multi_label_classification"
+
+                if self.config.problem_type == "regression":
+                    loss_fct = MSELoss()
+                    if self.base_model.num_labels == 1:
+                        loss = loss_fct(logits.squeeze(), labels.squeeze())
+                    else:
+                        loss = loss_fct(logits, labels)
+                elif self.config.problem_type == "single_label_classification":
+                    loss_fct = CrossEntropyLoss()
+                    loss = loss_fct(logits.view(-1, self.base_model.num_labels), labels.view(-1))
+                elif self.config.problem_type == "multi_label_classification":
+                    loss_fct = BCEWithLogitsLoss()
+                    loss = loss_fct(logits, labels)
+            if not return_dict:
+                output = (logits,) + outputs[2:]
+                return ((loss,) + output) if loss is not None else output
+
+            return SequenceClassifierOutput(
+                loss=loss,
+                logits=logits,
+                hidden_states=outputs.hidden_states,
+                attentions=outputs.attentions,
+            )
+
+
+class PeftModelForCausalLM(PeftModel):
+    """
+    Peft model for causal language modeling.
+
+    Args:
+        model ([`~transformers.PreTrainedModel`]): Base transformer model.
+        peft_config ([`PeftConfig`]): Peft config.
+        adapter_name (`str`,  *optional*): The name of the adapter, defaults to `"default"`.
+        autocast_adapter_dtype (`bool`, *optional*, defaults to `True`):
+            Whether to autocast the adapter dtype. Defaults to `True`. Right now, this will only cast adapter weights
+            using float16 and bfloat16 to float32, as this is typically required for stable training, and only affect
+            select PEFT tuners. If set to `False`, the dtypes will stay the same as those of the corresponding layer.
+
+    Example:
+
+        ```py
+        >>> from transformers import AutoModelForCausalLM
+        >>> from peft import PeftModelForCausalLM, get_peft_config
+
+        >>> config = {
+        ...     "peft_type": "PREFIX_TUNING",
+        ...     "task_type": "CAUSAL_LM",
+        ...     "inference_mode": False,
+        ...     "num_virtual_tokens": 20,
+        ...     "token_dim": 1280,
+        ...     "num_transformer_submodules": 1,
+        ...     "num_attention_heads": 20,
+        ...     "num_layers": 36,
+        ...     "encoder_hidden_size": 1280,
+        ...     "prefix_projection": False,
+        ...     "postprocess_past_key_value_function": None,
+        ... }
+
+        >>> peft_config = get_peft_config(config)
+        >>> model = AutoModelForCausalLM.from_pretrained("gpt2-large")
+        >>> peft_model = PeftModelForCausalLM(model, peft_config)
+        >>> peft_model.print_trainable_parameters()
+        trainable params: 1843200 || all params: 775873280 || trainable%: 0.23756456724479544
+        ```
+    """
+
+    def __init__(
+        self, model: torch.nn.Module, peft_config: PeftConfig, adapter_name: str = "default", **kwargs
+    ) -> None:
+        super().__init__(model, peft_config, adapter_name, **kwargs)
+        self.base_model_prepare_inputs_for_generation = self.base_model.prepare_inputs_for_generation
+
+    def forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        inputs_embeds=None,
+        labels=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+        task_ids=None,
+        **kwargs,
+    ):
+        peft_config = self.active_peft_config
+
+        if not peft_config.is_prompt_learning:
+            # Adds alora_offsets to kwargs if relevant. No other modifications.
+            kwargs = get_alora_offsets_for_forward(self, input_ids, inputs_embeds, **kwargs)
+            if self.base_model.config.model_type == "mpt":
+                if inputs_embeds is not None:
+                    raise AssertionError("forward in MPTForCausalLM does not support inputs_embeds")
+                return self.base_model(
+                    input_ids=input_ids,
+                    attention_mask=attention_mask,
+                    labels=labels,
+                    output_attentions=output_attentions,
+                    output_hidden_states=output_hidden_states,
+                    return_dict=return_dict,
+                    **kwargs,
+                )
+
+            if peft_config.peft_type == PeftType.POLY:
+                kwargs["task_ids"] = task_ids
+
+            with self._enable_peft_forward_hooks(**kwargs):
+                kwargs = {k: v for k, v in kwargs.items() if k not in self.special_peft_forward_args}
+                return self.base_model(
+                    input_ids=input_ids,
+                    attention_mask=attention_mask,
+                    inputs_embeds=inputs_embeds,
+                    labels=labels,
+                    output_attentions=output_attentions,
+                    output_hidden_states=output_hidden_states,
+                    return_dict=return_dict,
+                    **kwargs,
+                )
+
+        batch_size = _get_batch_size(input_ids, inputs_embeds)
+        if attention_mask is not None:
+            # concat prompt attention mask
+            prefix_attention_mask = torch.ones(batch_size, peft_config.num_virtual_tokens).to(attention_mask.device)
+            attention_mask = torch.cat((prefix_attention_mask, attention_mask), dim=1)
+        self._adjust_prompt_learning_kwargs(
+            peft_config,
+            kwargs=kwargs,
+        )
+        kwargs.update(
+            {
+                "attention_mask": attention_mask,
+                "labels": labels,
+                "output_attentions": output_attentions,
+                "output_hidden_states": output_hidden_states,
+                "return_dict": return_dict,
+            }
+        )
+
+        if peft_config.peft_type in (PeftType.PREFIX_TUNING, PeftType.CARTRIDGE):
+            # overwrite past_kv in kwargs
+            # some archs require max_cache_len to re-initialize the cache
+            if input_ids is not None:
+                max_cache_len = input_ids.shape[1] + peft_config.num_virtual_tokens
+            else:
+                max_cache_len = inputs_embeds.shape[1] + peft_config.num_virtual_tokens
+            kwargs["past_key_values"] = self.get_prompt(batch_size, max_cache_len=max_cache_len)
+            return self.base_model(input_ids=input_ids, inputs_embeds=inputs_embeds, **kwargs)
+        elif peft_config.peft_type == PeftType.CPT:
+            return self._cpt_forward(input_ids, inputs_embeds, peft_config, task_ids, batch_size, **kwargs)
+        else:
+            if inputs_embeds is None:
+                inputs_embeds = self.word_embeddings(input_ids)
+            # concat prompt labels
+            if labels is not None:
+                prefix_labels = torch.full((batch_size, peft_config.num_virtual_tokens), -100).to(labels.device)
+                kwargs["labels"] = torch.cat((prefix_labels, labels), dim=1)
+            prompts = self.get_prompt(batch_size=batch_size, task_ids=task_ids)
+            prompts = prompts.to(inputs_embeds.dtype)
+            inputs_embeds = torch.cat((prompts, inputs_embeds), dim=1)
+            return self.base_model(inputs_embeds=inputs_embeds, **kwargs)
+
+    def _cpt_forward(self, input_ids, inputs_embeds, peft_config, task_ids, batch_size, **kwargs):
+        # Extract labels from kwargs
+        labels = kwargs.pop("labels")
+        device = next(i.device for i in [input_ids, inputs_embeds, labels] if i is not None)
+        # Extract input_type_mask from kwargs and move it to the same device as labels
+        if "input_type_mask" in kwargs.keys():
+            input_type_mask = kwargs.pop("input_type_mask").to(device)
+        else:
+            if input_ids is None:
+                N_tokens = inputs_embeds.shape[1]
+            else:
+                N_tokens = input_ids.shape[1]
+            input_type_mask = torch.ones((batch_size, N_tokens)).to(device) * 4
+
+        cpt_token_ids = peft_config.cpt_token_ids
+        cpt_tokens_type_mask = peft_config.cpt_tokens_type_mask
+
+        # Generate embeddings if not provided
+        if inputs_embeds is None:
+            inputs_embeds = self.word_embeddings(input_ids)
+        # Get prompt and concatenate with input embeddings
+        prompts = self.get_prompt(batch_size=batch_size, task_ids=task_ids)
+        prompts = prompts.to(inputs_embeds.dtype)
+        inputs_embeds = torch.cat((prompts, inputs_embeds), dim=1)
+        # If labels are provided, generate prefix labels and type mask
+        cpt_labels = None
+        if labels is not None:
+            # Generate prefix labels and concatenate with the input labels
+            prefix_labels = torch.Tensor(cpt_token_ids).long().view(1, -1)
+            prefix_labels = prefix_labels.repeat(batch_size, 1).to(labels.device)
+            cpt_labels = torch.cat((prefix_labels, labels), dim=1)
+            # Generate prefix type mask and shift input type mask values to avoid conflicts
+            prefix_type_mask = torch.Tensor(cpt_tokens_type_mask).long().view(1, -1)
+            prefix_type_mask = prefix_type_mask.repeat(batch_size, 1).to(labels.device)
+            adjusted_input_type_mask = input_type_mask
+            adjusted_input_type_mask[adjusted_input_type_mask > 0] += prefix_type_mask.max()
+            # Concatenate prefix and shifted input type masks
+            cpt_type_mask = torch.cat((prefix_type_mask, adjusted_input_type_mask), dim=1)
+            # Identify valid label positions and mask invalid ones with -100
+            labels_idx = (cpt_type_mask > 0) & (cpt_type_mask % 4 == 0)
+            cpt_labels[~labels_idx] = -100
+            # Update kwargs with the modified labels
+
+        kwargs["labels"] = cpt_labels
+        # Pass the modified inputs to the base model
+        base_model_output = self.base_model(inputs_embeds=inputs_embeds, **kwargs)
+        if labels is None:
+            return base_model_output
+        else:
+            # Calculate the loss using the custom CPT loss function
+            cpt_embedding = PEFT_TYPE_TO_TUNER_MAPPING[peft_config.peft_type]
+            base_model_output = cpt_embedding.calculate_loss(
+                base_model_output, cpt_labels, cpt_type_mask, self.peft_config["default"]
+            )
+            return base_model_output
+
+    def generate(self, *args, **kwargs):
+        peft_config = self.active_peft_config
+        self.base_model.prepare_inputs_for_generation = self.prepare_inputs_for_generation
+        if hasattr(self.base_model, "model"):
+            self.base_model.model.generation_config = self.generation_config
+        else:
+            self.base_model.generation_config = self.generation_config
+        try:
+            if not peft_config.is_prompt_learning:
+                # Adds alora_offsets to kwargs if relevant. No other changes.
+                kwargs = get_alora_offsets_for_generate(self, *args, **kwargs)
+                with self._enable_peft_forward_hooks(*args, **kwargs):
+                    kwargs = {k: v for k, v in kwargs.items() if k not in self.special_peft_forward_args}
+                    outputs = self.base_model.generate(*args, **kwargs)
+            else:
+                outputs = self.base_model.generate(*args, **kwargs)
+        except:
+            self.base_model.prepare_inputs_for_generation = self.base_model_prepare_inputs_for_generation
+            raise
+        else:
+            self.base_model.prepare_inputs_for_generation = self.base_model_prepare_inputs_for_generation
+            return outputs
+
+    def prepare_inputs_for_generation(self, *args, task_ids: Optional[torch.Tensor] = None, **kwargs):
+        peft_config = self.active_peft_config
+        model_kwargs = self.base_model_prepare_inputs_for_generation(*args, **kwargs)
+
+        # https://github.com/huggingface/transformers/pull/26681/ introduced new cache format
+        # for some architectures which requires a special fix for prompt tuning etc.
+        # TODO: starting with transformers 4.38, all architectures should support caching.
+        uses_transformers_4_38 = packaging.version.parse(transformers.__version__) >= packaging.version.parse("4.38.0")
+        uses_transformers_4_36 = packaging.version.parse(transformers.__version__) >= packaging.version.parse("4.36.0")
+        transformers_new_cache_archs = ["llama", "mistral", "persimmon", "phi"]
+        if packaging.version.parse(transformers.__version__) > packaging.version.parse("4.43.3"):
+            # https://github.com/huggingface/transformers/pull/31445
+            transformers_new_cache_archs.append("bloom")
+
+        uses_cache = uses_transformers_4_38 or (
+            uses_transformers_4_36 and self.base_model.config.model_type in transformers_new_cache_archs
+        )
+
+        # heuristic to determine if we're in 'prefill stage' (when the KV cache is filled with the values from the
+        # initial input)
+        is_prefill = (model_kwargs.get("cache_position") is not None) and (model_kwargs["cache_position"][0] == 0)
+
+        if peft_config.peft_type == PeftType.POLY:
+            model_kwargs["task_ids"] = task_ids
+        if peft_config.is_prompt_learning:
+            if uses_cache and (model_kwargs.get("past_key_values", None) is not None):
+                # change in the logic of `prepare_inputs_for_generation` makes the below code necessary
+                # In prompt learning methods, past key values are longer when compared to the `input_ids`.
+                # As such only consider the last input ids in the autogressive generation phase.
+                past_key_values = model_kwargs["past_key_values"]
+                if isinstance(past_key_values, (tuple, list)):
+                    seq_len = past_key_values[0][0].shape[-2]
+                else:  # using transformers kv cache
+                    seq_len = past_key_values.get_seq_length()
+                if seq_len >= model_kwargs["input_ids"].shape[1]:
+                    model_kwargs["input_ids"] = model_kwargs["input_ids"][:, -1:]
+
+            if (attention_mask := model_kwargs.get("attention_mask", None)) is not None:
+                if isinstance(attention_mask, dict):
+                    # see: https://github.com/huggingface/transformers/pull/37866
+                    # For now, just deal with the case of a single attention mask
+                    if len(attention_mask) != 1:
+                        raise ValueError(
+                            f"Expected a single attention mask, got {len(attention_mask)} instead, please open an "
+                            "issue (https://github.com/huggingface/peft/issues) and report the error."
+                        )
+                    attention_mask = next(iter(attention_mask.values()))
+
+                size = model_kwargs["input_ids"].shape[0], peft_config.num_virtual_tokens
+                prefix_attention_mask = torch.ones(size).to(model_kwargs["input_ids"].device)
+                if attention_mask.dim() == 4:
+                    # Transform the 4d attention mask to 2d, leave it up to the model to deal with it instead of trying
+                    # to create a 4d attention mask here.
+                    # from [batch_size, heads, input_ids_length, total_sequence_length]
+                    # to   [batch_size, total_sequence_length]
+                    bs = attention_mask.shape[0]
+                    total_seq_len = prefix_attention_mask.shape[1] + attention_mask.shape[2]
+                    attention_mask_2d = torch.ones((bs, total_seq_len), dtype=attention_mask.dtype)
+
+                    if is_prefill and (peft_config.peft_type not in (PeftType.PREFIX_TUNING, PeftType.CARTRIDGE)):
+                        # if in prefill stage, for prompt learning methods that are not prefix tuning, new tokens
+                        # (embeddings) are inserted, thus set cache_position to correspond to these tokens
+                        cache_position_ = torch.arange(total_seq_len, device=model_kwargs["input_ids"].device)
+                    else:
+                        # prefix tuning acts directly on the cache, no need to update cache_position
+                        cache_position_ = model_kwargs["cache_position"]
+
+                    attention_mask_new = create_attention_mask(
+                        self.get_base_model(),
+                        model_input=None,
+                        attention_mask=attention_mask_2d,
+                        past_key_values=model_kwargs.get("past_key_values"),
+                        cache_position=cache_position_,
+                        batch_size=bs,
+                        sequence_length=total_seq_len,
+                        position_ids=model_kwargs.get("position_ids", None),
+                    )
+                    model_kwargs["attention_mask"] = attention_mask_new
+                else:
+                    # 2d attention mask
+                    model_kwargs["attention_mask"] = torch.cat((prefix_attention_mask, attention_mask), dim=1)
+
+            self._adjust_prompt_learning_kwargs(
+                peft_config,
+                kwargs=model_kwargs,
+            )
+
+            cache: transformers.Cache | None = model_kwargs.get("past_key_values", None)
+            # no past_key_values or past_key_values empty cache
+            requires_prompt_injection = (cache is None) or (
+                isinstance(cache, transformers.Cache) and not cache.get_seq_length()
+            )
+
+            if requires_prompt_injection and peft_config.peft_type in (PeftType.PREFIX_TUNING, PeftType.CARTRIDGE):
+                # some archs require max_cache_len to re-initialize the cache, but DynamicCache has no max len
+                if isinstance(cache, transformers.Cache) and not isinstance(cache, transformers.DynamicCache):
+                    max_cache_len = cache.max_cache_len
+                else:
+                    max_cache_len = -1  # -1 means no max length
+                new_past_key_values = self.get_prompt(
+                    batch_size=model_kwargs["input_ids"].shape[0],
+                    max_cache_len=max_cache_len,
+                )
+                model_kwargs["past_key_values"] = new_past_key_values
+            elif requires_prompt_injection:
+                inputs_embeds = self.word_embeddings(model_kwargs["input_ids"])
+                prompts = self.get_prompt(batch_size=model_kwargs["input_ids"].shape[0], task_ids=task_ids)
+                prompts = prompts.to(inputs_embeds.dtype)
+                model_kwargs["inputs_embeds"] = torch.cat((prompts, inputs_embeds), dim=1)
+                model_kwargs["input_ids"] = None
+
+        # if we're in the prefill stage
+        if is_prefill and (peft_config.peft_type in (PeftType.PREFIX_TUNING, PeftType.CARTRIDGE)):
+            # for prefix tuning, the past_key_values have been prefilled
+            model_kwargs["cache_position"] += peft_config.num_virtual_tokens
+        elif peft_config.peft_type not in (
+            PeftType.PREFIX_TUNING,
+            PeftType.CARTRIDGE,
+        ):  # prefix-style needs cache_position
+            # For transformers>=4.38.0 - for some architectures such as Llama, `cache_position` is passed in the forward
+            # pass to keep track of the position ids of the cache. We have to pop that from `model_kwargs` as
+            # `cache_position` is properly created by the model, using the passed `inputs_embeds`:
+            # https://github.com/huggingface/transformers/blob/593230f0a1150ea9c0477b9d859f25daf73c8c33/src/transformers/models/llama/modeling_llama.py#L956
+            _ = model_kwargs.pop("cache_position", None)
+
+        return model_kwargs
+
+
+class PeftModelForSeq2SeqLM(PeftModel):
+    """
+    Peft model for sequence-to-sequence language modeling.
+
+    Args:
+        model ([`~transformers.PreTrainedModel`]): Base transformer model.
+        peft_config ([`PeftConfig`]): Peft config.
+        adapter_name (`str`,  *optional*): The name of the adapter, defaults to `"default"`.
+        autocast_adapter_dtype (`bool`, *optional*, defaults to `True`):
+            Whether to autocast the adapter dtype. Defaults to `True`. Right now, this will only cast adapter weights
+            using float16 and bfloat16 to float32, as this is typically required for stable training, and only affect
+            select PEFT tuners. If set to `False`, the dtypes will stay the same as those of the corresponding layer.
+
+    Example:
+
+        ```py
+        >>> from transformers import AutoModelForSeq2SeqLM
+        >>> from peft import PeftModelForSeq2SeqLM, get_peft_config
+
+        >>> config = {
+        ...     "peft_type": "LORA",
+        ...     "task_type": "SEQ_2_SEQ_LM",
+        ...     "inference_mode": False,
+        ...     "r": 8,
+        ...     "target_modules": ["q", "v"],
+        ...     "lora_alpha": 32,
+        ...     "lora_dropout": 0.1,
+        ...     "fan_in_fan_out": False,
+        ...     "enable_lora": None,
+        ...     "bias": "none",
+        ... }
+
+        >>> peft_config = get_peft_config(config)
+        >>> model = AutoModelForSeq2SeqLM.from_pretrained("t5-base")
+        >>> peft_model = PeftModelForSeq2SeqLM(model, peft_config)
+        >>> peft_model.print_trainable_parameters()
+        trainable params: 884736 || all params: 223843584 || trainable%: 0.3952474242013566
+        ```
+    """
+
+    def __init__(
+        self, model: torch.nn.Module, peft_config: PeftConfig, adapter_name: str = "default", **kwargs
+    ) -> None:
+        super().__init__(model, peft_config, adapter_name, **kwargs)
+        self.base_model_prepare_inputs_for_generation = self.base_model.prepare_inputs_for_generation
+        self.base_model_prepare_encoder_decoder_kwargs_for_generation = (
+            self.base_model._prepare_encoder_decoder_kwargs_for_generation
+        )
+
+    def forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        inputs_embeds=None,
+        decoder_input_ids=None,
+        decoder_attention_mask=None,
+        decoder_inputs_embeds=None,
+        labels=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+        task_ids=None,
+        **kwargs,
+    ):
+        peft_config = self.active_peft_config
+        if not peft_config.is_prompt_learning:
+            if peft_config.peft_type == PeftType.POLY:
+                kwargs["task_ids"] = task_ids
+
+            with self._enable_peft_forward_hooks(**kwargs):
+                kwargs = {k: v for k, v in kwargs.items() if k not in self.special_peft_forward_args}
+                return self.base_model(
+                    input_ids=input_ids,
+                    attention_mask=attention_mask,
+                    inputs_embeds=inputs_embeds,
+                    decoder_input_ids=decoder_input_ids,
+                    decoder_attention_mask=decoder_attention_mask,
+                    decoder_inputs_embeds=decoder_inputs_embeds,
+                    labels=labels,
+                    output_attentions=output_attentions,
+                    output_hidden_states=output_hidden_states,
+                    return_dict=return_dict,
+                    **kwargs,
+                )
+
+        batch_size = _get_batch_size(input_ids, inputs_embeds)
+        if decoder_attention_mask is not None:
+            # concat prompt attention mask
+            prefix_attention_mask = torch.ones(batch_size, peft_config.num_virtual_tokens).to(
+                decoder_attention_mask.device
+            )
+            if peft_config.peft_type not in [PeftType.PROMPT_TUNING, PeftType.P_TUNING]:
+                decoder_attention_mask = torch.cat((prefix_attention_mask, decoder_attention_mask), dim=1)
+
+        self._adjust_prompt_learning_kwargs(
+            peft_config,
+            kwargs=kwargs,
+        )
+        kwargs.update(
+            {
+                "attention_mask": attention_mask,
+                "decoder_attention_mask": decoder_attention_mask,
+                "labels": labels,
+                "output_attentions": output_attentions,
+                "output_hidden_states": output_hidden_states,
+                "return_dict": return_dict,
+            }
+        )
+
+        if peft_config.peft_type in (PeftType.PREFIX_TUNING, PeftType.CARTRIDGE):
+            # overwrite past_kv in kwargs
+            kwargs["past_key_values"] = self.get_prompt(batch_size)
+            return self.base_model(
+                input_ids=input_ids,
+                decoder_input_ids=decoder_input_ids,
+                decoder_inputs_embeds=decoder_inputs_embeds,
+                **kwargs,
+            )
+        elif peft_config.peft_type in [PeftType.PROMPT_TUNING, PeftType.P_TUNING]:
+            if inputs_embeds is None:
+                inputs_embeds = self.word_embeddings(input_ids)
+
+            if attention_mask is not None:
+                # concat prompt attention mask
+                prefix_attention_mask = torch.ones(batch_size, peft_config.num_virtual_tokens).to(
+                    attention_mask.device
+                )
+                kwargs["attention_mask"] = torch.cat((prefix_attention_mask, attention_mask), dim=1)
+
+            prompts = self.get_prompt(batch_size=batch_size)
+            prompts = prompts.to(inputs_embeds.dtype)
+            inputs_embeds = torch.cat((prompts[:, : peft_config.num_virtual_tokens], inputs_embeds), dim=1)
+
+            return self.base_model(
+                inputs_embeds=inputs_embeds,
+                decoder_input_ids=decoder_input_ids,
+                decoder_inputs_embeds=decoder_inputs_embeds,
+                **kwargs,
+            )
+        else:
+            if inputs_embeds is None:
+                inputs_embeds = self.word_embeddings(input_ids)
+            if decoder_inputs_embeds is None and decoder_input_ids is None:
+                decoder_input_ids = shift_tokens_right(
+                    labels, self.config.pad_token_id, self.config.decoder_start_token_id
+                )
+                decoder_inputs_embeds = self.word_embeddings(decoder_input_ids)
+
+            if attention_mask is not None:
+                # concat prompt attention mask
+                prefix_attention_mask = torch.ones(batch_size, peft_config.num_virtual_tokens).to(
+                    attention_mask.device
+                )
+                kwargs["attention_mask"] = torch.cat((prefix_attention_mask, attention_mask), dim=1)
+            # concat prompt labels
+            if labels is not None:
+                if peft_config.num_transformer_submodules == 1:
+                    kwargs["labels"] = labels
+                elif peft_config.num_transformer_submodules == 2:
+                    prefix_labels = torch.full((batch_size, peft_config.num_virtual_tokens), -100).to(labels.device)
+                    kwargs["labels"] = torch.cat((prefix_labels, labels), dim=1)
+            prompts = self.get_prompt(batch_size=batch_size, task_ids=task_ids)
+            prompts = prompts.to(inputs_embeds.dtype)
+            inputs_embeds = torch.cat((prompts[:, : peft_config.num_virtual_tokens], inputs_embeds), dim=1)
+            if peft_config.num_transformer_submodules == 1:
+                return self.base_model(inputs_embeds=inputs_embeds, **kwargs)
+            elif peft_config.num_transformer_submodules == 2:
+                decoder_inputs_embeds = torch.cat(
+                    (prompts[:, peft_config.num_virtual_tokens :], decoder_inputs_embeds), dim=1
+                )
+                return self.base_model(
+                    inputs_embeds=inputs_embeds, decoder_inputs_embeds=decoder_inputs_embeds, **kwargs
+                )
+
+    def generate(self, **kwargs):
+        peft_config = self.active_peft_config
+        self.base_model.prepare_inputs_for_generation = self.prepare_inputs_for_generation
+        self.base_model._prepare_encoder_decoder_kwargs_for_generation = (
+            self._prepare_encoder_decoder_kwargs_for_generation
+        )
+        try:
+            if not peft_config.is_prompt_learning:
+                with self._enable_peft_forward_hooks(**kwargs):
+                    kwargs = {k: v for k, v in kwargs.items() if k not in self.special_peft_forward_args}
+                    outputs = self.base_model.generate(**kwargs)
+            else:
+                if "input_ids" not in kwargs:
+                    raise ValueError("input_ids must be provided for Peft model generation")
+                self._adjust_prompt_learning_kwargs(
+                    peft_config,
+                    kwargs=kwargs,
+                )
+
+                if peft_config.peft_type in (PeftType.PREFIX_TUNING, PeftType.CARTRIDGE):
+                    outputs = self.base_model.generate(**kwargs)
+                elif peft_config.peft_type in [
+                    PeftType.PROMPT_TUNING,
+                    PeftType.P_TUNING,
+                    PeftType.MULTITASK_PROMPT_TUNING,
+                ]:
+                    kwargs = deepcopy(kwargs)
+
+                    if "encoder_outputs" in kwargs:
+                        del kwargs["encoder_outputs"]
+                        warnings.warn(
+                            "`encoder_outputs` should not be passed to `generate` when using prompt tuning. Ignoring it."
+                        )
+
+                    input_ids = kwargs.pop("input_ids")
+                    inputs_embeds = self.word_embeddings(input_ids)
+                    batch_size = inputs_embeds.shape[0]
+                    prompts = self.get_prompt(batch_size=batch_size, task_ids=kwargs.pop("task_ids", None))
+                    prompts = prompts.to(inputs_embeds.dtype)
+
+                    inputs_embeds = torch.cat((prompts[:, : peft_config.num_virtual_tokens], inputs_embeds), dim=1)
+                    kwargs["inputs_embeds"] = inputs_embeds
+
+                    if "attention_mask" in kwargs:
+                        prefix_attention_mask = torch.ones(batch_size, peft_config.num_virtual_tokens).to(
+                            kwargs["attention_mask"].device
+                        )
+                        kwargs["attention_mask"] = torch.cat((prefix_attention_mask, kwargs["attention_mask"]), dim=1)
+
+                    return self.base_model.generate(**kwargs)
+                else:
+                    raise NotImplementedError
+        except:
+            self.base_model.prepare_inputs_for_generation = self.base_model_prepare_inputs_for_generation
+            self.base_model._prepare_encoder_decoder_kwargs_for_generation = (
+                self.base_model_prepare_encoder_decoder_kwargs_for_generation
+            )
+            raise
+        else:
+            self.base_model.prepare_inputs_for_generation = self.base_model_prepare_inputs_for_generation
+            self.base_model._prepare_encoder_decoder_kwargs_for_generation = (
+                self.base_model_prepare_encoder_decoder_kwargs_for_generation
+            )
+            return outputs
+
+    def prepare_inputs_for_generation(self, *args, task_ids: torch.Tensor = None, **kwargs):
+        peft_config = self.active_peft_config
+        model_kwargs = self.base_model_prepare_inputs_for_generation(*args, **kwargs)
+        if peft_config.peft_type == PeftType.POLY:
+            model_kwargs["task_ids"] = task_ids
+        elif peft_config.peft_type in (PeftType.PREFIX_TUNING, PeftType.CARTRIDGE):
+            past_key_values = model_kwargs.get("past_key_values", None)
+            cache_position = model_kwargs.get("cache_position", [None])
+            # check prefill stage
+            is_prefill_stage = kwargs.get("is_first_iteration")
+            if is_prefill_stage is None:  # transformers < v5
+                is_prefill_stage = (
+                    # old cache implementation
+                    (past_key_values is None)
+                    # new cache implementation
+                    or (isinstance(past_key_values, Cache) and (past_key_values.get_seq_length() == 0))
+                )
+            if is_prefill_stage:
+                batch_size = model_kwargs["decoder_input_ids"].shape[0]
+                new_past_key_values = self.get_prompt(batch_size)
+                model_kwargs["past_key_values"] = new_past_key_values
+
+        return model_kwargs
+
+
+class PeftModelForTokenClassification(PeftModel):
+    """
+    Peft model for token classification tasks.
+
+    Args:
+        model ([`~transformers.PreTrainedModel`]): Base transformer model.
+        peft_config ([`PeftConfig`]): Peft config.
+        adapter_name (`str`,  *optional*): The name of the adapter, defaults to `"default"`.
+        autocast_adapter_dtype (`bool`, *optional*, defaults to `True`):
+            Whether to autocast the adapter dtype. Defaults to `True`. Right now, this will only cast adapter weights
+            using float16 and bfloat16 to float32, as this is typically required for stable training, and only affect
+            select PEFT tuners. If set to `False`, the dtypes will stay the same as those of the corresponding layer.
+
+    **Attributes**:
+        - **config** ([`~transformers.PretrainedConfig`]) -- The configuration object of the base model.
+        - **cls_layer_name** (`str`) -- The name of the classification layer.
+
+    Example:
+
+        ```py
+        >>> from transformers import AutoModelForSequenceClassification
+        >>> from peft import PeftModelForTokenClassification, get_peft_config
+
+        >>> config = {
+        ...     "peft_type": "PREFIX_TUNING",
+        ...     "task_type": "TOKEN_CLS",
+        ...     "inference_mode": False,
+        ...     "num_virtual_tokens": 20,
+        ...     "token_dim": 768,
+        ...     "num_transformer_submodules": 1,
+        ...     "num_attention_heads": 12,
+        ...     "num_layers": 12,
+        ...     "encoder_hidden_size": 768,
+        ...     "prefix_projection": False,
+        ...     "postprocess_past_key_value_function": None,
+        ... }
+
+        >>> peft_config = get_peft_config(config)
+        >>> model = AutoModelForTokenClassification.from_pretrained("bert-base-cased")
+        >>> peft_model = PeftModelForTokenClassification(model, peft_config)
+        >>> peft_model.print_trainable_parameters()
+        trainable params: 370178 || all params: 108680450 || trainable%: 0.3406113979101117
+        ```
+    """
+
+    def __init__(
+        self, model: torch.nn.Module, peft_config: PeftConfig = None, adapter_name: str = "default", **kwargs
+    ) -> None:
+        super().__init__(model, peft_config, adapter_name, **kwargs)
+
+        classifier_module_names = ["classifier", "score"]
+        if hasattr(peft_config, "modules_to_save"):
+            if peft_config.modules_to_save is None:
+                peft_config.modules_to_save = classifier_module_names[:]
+            else:
+                peft_config.modules_to_save.extend(classifier_module_names)
+
+        for name, _ in self.base_model.named_children():
+            if any(module_name in name for module_name in self.modules_to_save):
+                self.cls_layer_name = name
+                break
+
+        # to make sure classifier layer is trainable; this may add a new ModulesToSaveWrapper
+        _set_trainable(
+            self,
+            adapter_name,
+            module_names=getattr(peft_config, "modules_to_save", None),
+            inference_mode=peft_config.inference_mode,
+        )
+
+    def add_adapter(
+        self,
+        adapter_name: str,
+        peft_config: PeftConfig,
+        low_cpu_mem_usage: bool = False,
+        autocast_adapter_dtype: bool = True,
+    ) -> None:
+        """
+        Add an adapter to the model based on the passed configuration.
+
+        This adapter is not trained. To load a trained adapter, check out [`PeftModel.load_adapter`].
+
+        The name for the new adapter should be unique.
+
+        The new adapter is not automatically set as the active adapter. Use [`PeftModel.set_adapter`] to set the active
+        adapter.
+
+        Args:
+            adapter_name (`str`):
+                The name of the adapter to be added.
+            peft_config ([`PeftConfig`]):
+                The configuration of the adapter to be added.
+            low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+                Create empty adapter weights on meta device. Useful to speed up the process when loading saved
+                adapters. Don't use this option when creating a new PEFT adapter for training.
+            autocast_adapter_dtype (`bool`, *optional*, defaults to `True`):
+                Whether to autocast the adapter dtype. Defaults to `True`. Right now, this will only cast adapter
+                weights using float16 and bfloat16 to float32, as this is typically required for stable training, and
+                only affect select PEFT tuners. If set to `False`, the dtypes will stay the same as those of the
+                corresponding layer.
+
+        """
+        # ensure that additional adapters also add the classifier layer to modules_to_save
+        if hasattr(peft_config, "modules_to_save"):
+            classifier_module_names = ["classifier", "score"]
+            if peft_config.modules_to_save is None:
+                peft_config.modules_to_save = classifier_module_names[:]
+            else:
+                peft_config.modules_to_save.extend(classifier_module_names)
+
+        return super().add_adapter(adapter_name, peft_config, low_cpu_mem_usage=low_cpu_mem_usage)
+
+    def forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        inputs_embeds=None,
+        labels=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+        task_ids=None,
+        **kwargs,
+    ):
+        peft_config = self.active_peft_config
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        if not peft_config.is_prompt_learning:
+            with self._enable_peft_forward_hooks(**kwargs):
+                kwargs = {k: v for k, v in kwargs.items() if k not in self.special_peft_forward_args}
+                if peft_config.peft_type == PeftType.POLY:
+                    kwargs["task_ids"] = task_ids
+                return self.base_model(
+                    input_ids=input_ids,
+                    attention_mask=attention_mask,
+                    inputs_embeds=inputs_embeds,
+                    labels=labels,
+                    output_attentions=output_attentions,
+                    output_hidden_states=output_hidden_states,
+                    return_dict=return_dict,
+                    **kwargs,
+                )
+
+        batch_size = _get_batch_size(input_ids, inputs_embeds)
+        if attention_mask is not None:
+            # concat prompt attention mask
+            prefix_attention_mask = torch.ones(batch_size, peft_config.num_virtual_tokens).to(attention_mask.device)
+            attention_mask = torch.cat((prefix_attention_mask, attention_mask), dim=1)
+        self._adjust_prompt_learning_kwargs(peft_config, kwargs=kwargs, remove_token_type_ids=False)
+        kwargs.update(
+            {
+                "attention_mask": attention_mask,
+                "labels": labels,
+                "output_attentions": output_attentions,
+                "output_hidden_states": output_hidden_states,
+                "return_dict": return_dict,
+            }
+        )
+
+        if peft_config.peft_type in (PeftType.PREFIX_TUNING, PeftType.CARTRIDGE):
+            return self._prefix_tuning_forward(input_ids=input_ids, **kwargs)
+        else:
+            if kwargs.get("token_type_ids", None) is not None:
+                kwargs["token_type_ids"] = torch.cat(
+                    (
+                        torch.zeros(batch_size, peft_config.num_virtual_tokens).to(self.word_embeddings.weight.device),
+                        kwargs["token_type_ids"],
+                    ),
+                    dim=1,
+                ).long()
+            if inputs_embeds is None:
+                inputs_embeds = self.word_embeddings(input_ids)
+            prompts = self.get_prompt(batch_size=batch_size, task_ids=task_ids)
+            prompts = prompts.to(inputs_embeds.dtype)
+            inputs_embeds = torch.cat((prompts, inputs_embeds), dim=1)
+            return self.base_model(inputs_embeds=inputs_embeds, **kwargs)
+
+    def _prefix_tuning_forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        inputs_embeds=None,
+        labels=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+        **kwargs,
+    ):
+        batch_size = _get_batch_size(input_ids, inputs_embeds)
+        past_key_values = self.get_prompt(batch_size)
+        fwd_params = list(inspect.signature(self.base_model.forward).parameters.keys())
+        kwargs.update(
+            {
+                "input_ids": input_ids,
+                "attention_mask": attention_mask,
+                "inputs_embeds": inputs_embeds,
+                "output_attentions": output_attentions,
+                "output_hidden_states": output_hidden_states,
+                "return_dict": return_dict,
+                "past_key_values": past_key_values,
+            }
+        )
+        if "past_key_values" in fwd_params:
+            return self.base_model(labels=labels, **kwargs)
+        else:
+            transformer_backbone_name = self.base_model.get_submodule(self.transformer_backbone_name)
+            fwd_params = list(inspect.signature(transformer_backbone_name.forward).parameters.keys())
+            if "past_key_values" not in fwd_params:
+                raise ValueError("Model does not support past key values which are required for prefix tuning.")
+            outputs = transformer_backbone_name(**kwargs)
+            sequence_output = outputs[0]
+            if "dropout" in [name for name, _ in list(self.base_model.named_children())]:
+                sequence_output = self.base_model.dropout(sequence_output)
+            logits = self.base_model.get_submodule(self.cls_layer_name)(sequence_output)
+
+            loss = None
+            if labels is not None:
+                loss_fct = CrossEntropyLoss()
+                loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
+
+            if not return_dict:
+                output = (logits,) + outputs[2:]
+                return ((loss,) + output) if loss is not None else output
+
+            return TokenClassifierOutput(
+                loss=loss,
+                logits=logits,
+                hidden_states=outputs.hidden_states,
+                attentions=outputs.attentions,
+            )
+
+
+class PeftModelForQuestionAnswering(PeftModel):
+    """
+    Peft model for extractive question answering.
+
+    Args:
+        model ([`~transformers.PreTrainedModel`]): Base transformer model.
+        peft_config ([`PeftConfig`]): Peft config.
+        adapter_name (`str`,  *optional*): The name of the adapter, defaults to `"default"`.
+        autocast_adapter_dtype (`bool`, *optional*, defaults to `True`):
+            Whether to autocast the adapter dtype. Defaults to `True`. Right now, this will only cast adapter weights
+            using float16 and bfloat16 to float32, as this is typically required for stable training, and only affect
+            select PEFT tuners. If set to `False`, the dtypes will stay the same as those of the corresponding layer.
+
+    **Attributes**:
+        - **config** ([`~transformers.PretrainedConfig`]) -- The configuration object of the base model.
+        - **cls_layer_name** (`str`) -- The name of the classification layer.
+
+    Example:
+
+        ```py
+        >>> from transformers import AutoModelForQuestionAnswering
+        >>> from peft import PeftModelForQuestionAnswering, get_peft_config
+
+        >>> config = {
+        ...     "peft_type": "LORA",
+        ...     "task_type": "QUESTION_ANS",
+        ...     "inference_mode": False,
+        ...     "r": 16,
+        ...     "target_modules": ["query", "value"],
+        ...     "lora_alpha": 32,
+        ...     "lora_dropout": 0.05,
+        ...     "fan_in_fan_out": False,
+        ...     "bias": "none",
+        ... }
+
+        >>> peft_config = get_peft_config(config)
+        >>> model = AutoModelForQuestionAnswering.from_pretrained("bert-base-cased")
+        >>> peft_model = PeftModelForQuestionAnswering(model, peft_config)
+        >>> peft_model.print_trainable_parameters()
+        trainable params: 592900 || all params: 108312580 || trainable%: 0.5473971721475013
+        ```
+    """
+
+    def __init__(
+        self, model: torch.nn.Module, peft_config: PeftConfig, adapter_name: str = "default", **kwargs
+    ) -> None:
+        super().__init__(model, peft_config, adapter_name, **kwargs)
+
+        qa_module_names = ["qa_outputs"]
+        if hasattr(peft_config, "modules_to_save"):
+            if peft_config.modules_to_save is None:
+                peft_config.modules_to_save = qa_module_names[:]
+            else:
+                peft_config.modules_to_save.extend(qa_module_names)
+
+        for name, _ in self.base_model.named_children():
+            if any(module_name in name for module_name in self.modules_to_save):
+                self.cls_layer_name = name
+                break
+
+        # to make sure classifier layer is trainable; this may add a new ModulesToSaveWrapper
+        _set_trainable(
+            self,
+            adapter_name,
+            module_names=getattr(peft_config, "modules_to_save", None),
+            inference_mode=peft_config.inference_mode,
+        )
+
+    def add_adapter(
+        self,
+        adapter_name: str,
+        peft_config: PeftConfig,
+        low_cpu_mem_usage: bool = False,
+        autocast_adapter_dtype: bool = True,
+    ) -> None:
+        """
+        Add an adapter to the model based on the passed configuration.
+
+        This adapter is not trained. To load a trained adapter, check out [`PeftModel.load_adapter`].
+
+        The name for the new adapter should be unique.
+
+        The new adapter is not automatically set as the active adapter. Use [`PeftModel.set_adapter`] to set the active
+        adapter.
+
+        Args:
+            adapter_name (`str`):
+                The name of the adapter to be added.
+            peft_config ([`PeftConfig`]):
+                The configuration of the adapter to be added.
+            low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+                Create empty adapter weights on meta device. Useful to speed up the process when loading saved
+                adapters. Don't use this option when creating a new PEFT adapter for training.
+            autocast_adapter_dtype (`bool`, *optional*, defaults to `True`):
+                Whether to autocast the adapter dtype. Defaults to `True`. Right now, this will only cast adapter
+                weights using float16 and bfloat16 to float32, as this is typically required for stable training, and
+                only affect select PEFT tuners. If set to `False`, the dtypes will stay the same as those of the
+                corresponding layer.
+
+        """
+        # ensure that additional adapters also add the classifier layer to modules_to_save
+        if hasattr(peft_config, "modules_to_save"):
+            qa_module_names = ["qa_outputs"]
+            if peft_config.modules_to_save is None:
+                peft_config.modules_to_save = qa_module_names[:]
+            else:
+                peft_config.modules_to_save.extend(qa_module_names)
+
+        return super().add_adapter(adapter_name, peft_config, low_cpu_mem_usage=low_cpu_mem_usage)
+
+    def forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        token_type_ids=None,
+        position_ids=None,
+        inputs_embeds=None,
+        start_positions=None,
+        end_positions=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+        task_ids=None,
+        **kwargs,
+    ):
+        peft_config = self.active_peft_config
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        if not peft_config.is_prompt_learning:
+            if peft_config.peft_type == PeftType.POLY:
+                kwargs["task_ids"] = task_ids
+
+            with self._enable_peft_forward_hooks(**kwargs):
+                kwargs = {k: v for k, v in kwargs.items() if k not in self.special_peft_forward_args}
+                return self.base_model(
+                    input_ids=input_ids,
+                    attention_mask=attention_mask,
+                    inputs_embeds=inputs_embeds,
+                    start_positions=start_positions,
+                    end_positions=end_positions,
+                    output_attentions=output_attentions,
+                    output_hidden_states=output_hidden_states,
+                    return_dict=return_dict,
+                    **kwargs,
+                )
+
+        batch_size = _get_batch_size(input_ids, inputs_embeds)
+        if attention_mask is not None:
+            # concat prompt attention mask
+            prefix_attention_mask = torch.ones(batch_size, peft_config.num_virtual_tokens).to(attention_mask.device)
+            attention_mask = torch.cat((prefix_attention_mask, attention_mask), dim=1)
+        self._adjust_prompt_learning_kwargs(peft_config, kwargs=kwargs, remove_token_type_ids=False)
+        kwargs.update(
+            {
+                "attention_mask": attention_mask,
+                "start_positions": start_positions,
+                "end_positions": end_positions,
+                "output_attentions": output_attentions,
+                "output_hidden_states": output_hidden_states,
+                "return_dict": return_dict,
+            }
+        )
+
+        if peft_config.peft_type in (PeftType.PREFIX_TUNING, PeftType.CARTRIDGE):
+            return self._prefix_tuning_forward(input_ids=input_ids, **kwargs)
+        else:
+            if kwargs.get("token_type_ids", None) is not None:
+                kwargs["token_type_ids"] = torch.cat(
+                    (
+                        torch.zeros(batch_size, peft_config.num_virtual_tokens).to(self.word_embeddings.weight.device),
+                        kwargs["token_type_ids"],
+                    ),
+                    dim=1,
+                ).long()
+            if inputs_embeds is None:
+                inputs_embeds = self.word_embeddings(input_ids)
+            prompts = self.get_prompt(batch_size=batch_size)
+            prompts = prompts.to(inputs_embeds.dtype)
+            inputs_embeds = torch.cat((prompts, inputs_embeds), dim=1)
+            return self.base_model(inputs_embeds=inputs_embeds, **kwargs)
+
+    def _prefix_tuning_forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        inputs_embeds=None,
+        start_positions=None,
+        end_positions=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+        **kwargs,
+    ):
+        batch_size = _get_batch_size(input_ids, inputs_embeds)
+        past_key_values = self.get_prompt(batch_size)
+        fwd_params = list(inspect.signature(self.base_model.forward).parameters.keys())
+        kwargs.update(
+            {
+                "input_ids": input_ids,
+                "attention_mask": attention_mask,
+                "inputs_embeds": inputs_embeds,
+                "output_attentions": output_attentions,
+                "output_hidden_states": output_hidden_states,
+                "return_dict": return_dict,
+                "past_key_values": past_key_values,
+            }
+        )
+        if "past_key_values" in fwd_params:
+            return self.base_model(start_positions=start_positions, end_positions=end_positions, **kwargs)
+        else:
+            transformer_backbone_name = self.base_model.get_submodule(self.transformer_backbone_name)
+            fwd_params = list(inspect.signature(transformer_backbone_name.forward).parameters.keys())
+            if "past_key_values" not in fwd_params:
+                raise ValueError("Model does not support past key values which are required for prefix tuning.")
+            outputs = transformer_backbone_name(**kwargs)
+            sequence_output = outputs[0]
+            if "dropout" in [name for name, _ in list(self.base_model.named_children())]:
+                sequence_output = self.base_model.dropout(sequence_output)
+            logits = self.base_model.get_submodule(self.cls_layer_name)(sequence_output)
+            start_logits, end_logits = logits.split(1, dim=-1)
+            start_logits = start_logits.squeeze(-1).contiguous()
+            end_logits = end_logits.squeeze(-1).contiguous()
+
+            total_loss = None
+            if start_positions is not None and end_positions is not None:
+                # If we are on multi-GPU, split add a dimension
+                if len(start_positions.size()) > 1:
+                    start_positions = start_positions.squeeze(-1)
+                if len(end_positions.size()) > 1:
+                    end_positions = end_positions.squeeze(-1)
+                # sometimes the start/end positions are outside our model inputs, we ignore these terms
+                ignored_index = start_logits.size(1)
+                start_positions = start_positions.clamp(0, ignored_index)
+                end_positions = end_positions.clamp(0, ignored_index)
+
+                loss_fct = CrossEntropyLoss(ignore_index=ignored_index)
+                start_loss = loss_fct(start_logits, start_positions)
+                end_loss = loss_fct(end_logits, end_positions)
+                total_loss = (start_loss + end_loss) / 2
+
+            if not return_dict:
+                output = (start_logits, end_logits) + outputs[2:]
+                return ((total_loss,) + output) if total_loss is not None else output
+
+            return QuestionAnsweringModelOutput(
+                loss=total_loss,
+                start_logits=start_logits,
+                end_logits=end_logits,
+                hidden_states=outputs.hidden_states,
+                attentions=outputs.attentions,
+            )
+
+
+class PeftModelForFeatureExtraction(PeftModel):
+    """
+    Peft model for extracting features/embeddings from transformer models
+
+    Args:
+        model ([`~transformers.PreTrainedModel`]): Base transformer model.
+        peft_config ([`PeftConfig`]): Peft config.
+        adapter_name (`str`,  *optional*): The name of the adapter, defaults to `"default"`.
+        autocast_adapter_dtype (`bool`, *optional*, defaults to `True`):
+            Whether to autocast the adapter dtype. Defaults to `True`. Right now, this will only cast adapter weights
+            using float16 and bfloat16 to float32, as this is typically required for stable training, and only affect
+            select PEFT tuners. If set to `False`, the dtypes will stay the same as those of the corresponding layer.
+
+    **Attributes**:
+        - **config** ([`~transformers.PretrainedConfig`]) -- The configuration object of the base model.
+
+    Example:
+
+        ```py
+        >>> from transformers import AutoModel
+        >>> from peft import PeftModelForFeatureExtraction, get_peft_config
+
+        >>> config = {
+        ...     "peft_type": "LORA",
+        ...     "task_type": "FEATURE_EXTRACTION",
+        ...     "inference_mode": False,
+        ...     "r": 16,
+        ...     "target_modules": ["query", "value"],
+        ...     "lora_alpha": 32,
+        ...     "lora_dropout": 0.05,
+        ...     "fan_in_fan_out": False,
+        ...     "bias": "none",
+        ... }
+        >>> peft_config = get_peft_config(config)
+        >>> model = AutoModel.from_pretrained("bert-base-cased")
+        >>> peft_model = PeftModelForFeatureExtraction(model, peft_config)
+        >>> peft_model.print_trainable_parameters()
+        ```
+    """
+
+    def __init__(self, model: torch.nn.Module, peft_config: PeftConfig, adapter_name: str = "default", **kwargs):
+        super().__init__(model, peft_config, adapter_name, **kwargs)
+
+    def forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        inputs_embeds=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+        task_ids=None,
+        **kwargs,
+    ):
+        peft_config = self.active_peft_config
+        if not peft_config.is_prompt_learning:
+            if peft_config.peft_type == PeftType.POLY:
+                kwargs["task_ids"] = task_ids
+
+            with self._enable_peft_forward_hooks(**kwargs):
+                kwargs = {k: v for k, v in kwargs.items() if k not in self.special_peft_forward_args}
+                return self.base_model(
+                    input_ids=input_ids,
+                    attention_mask=attention_mask,
+                    inputs_embeds=inputs_embeds,
+                    output_attentions=output_attentions,
+                    output_hidden_states=output_hidden_states,
+                    return_dict=return_dict,
+                    **kwargs,
+                )
+
+        batch_size = _get_batch_size(input_ids, inputs_embeds)
+        if attention_mask is not None:
+            # concat prompt attention mask
+            prefix_attention_mask = torch.ones(batch_size, peft_config.num_virtual_tokens).to(attention_mask.device)
+            attention_mask = torch.cat((prefix_attention_mask, attention_mask), dim=1)
+        self._adjust_prompt_learning_kwargs(
+            peft_config,
+            kwargs=kwargs,
+        )
+        kwargs.update(
+            {
+                "attention_mask": attention_mask,
+                "output_attentions": output_attentions,
+                "output_hidden_states": output_hidden_states,
+                "return_dict": return_dict,
+            }
+        )
+
+        if peft_config.peft_type in (PeftType.PREFIX_TUNING, PeftType.CARTRIDGE):
+            # overwrite past_kv in kwargs
+            kwargs["past_key_values"] = self.get_prompt(batch_size)
+            return self.base_model(input_ids=input_ids, **kwargs)
+        else:
+            if inputs_embeds is None:
+                inputs_embeds = self.word_embeddings(input_ids)
+            prompts = self.get_prompt(batch_size=batch_size)
+            prompts = prompts.to(inputs_embeds.dtype)
+            inputs_embeds = torch.cat((prompts, inputs_embeds), dim=1)
+            return self.base_model(inputs_embeds=inputs_embeds, **kwargs)
+
+
+@dataclass
+class TunerLayerStatus:
+    name: str
+    module_type: str
+    enabled: bool
+    active_adapters: list[str]
+    merged_adapters: list[str]
+    requires_grad: dict[str, bool | Literal["irregular"]]
+    available_adapters: list[str]
+    devices: dict[str, list[str]]
+    quantization_backend: str | None
+
+
+def get_layer_status(model: torch.nn.Module) -> list[TunerLayerStatus]:
+    """Get the status of each adapter layer in the model.
+
+    This function returns a list of `TunerLayerStatus` dataclass instances, each of which contains the following
+    attributes:
+
+    - `name` (`str`):
+       The name of the adapter layer, e.g. `model.encoder.block.0.layer.0.SelfAttention.q`.
+    - `module_type` (`str`):
+       The type of the adapter layer, e.g. `lora.Linear`.
+    - `enabled` (`bool`):
+       Whether the adapter layer is enabled.
+    - `active_adapters` (`list[str]`):
+       The names of the active adapters, if any, e.g. `["default"]`.
+    - `merged_adapters` (`list[str]`):
+       The names of the merged adapters, if any, e.g. `["default"]`.
+    - requires_grad : dict[str, bool | Literal["irregular"]]
+       The requires_grad status of the parameters for each adapter module. Ideally, it should be either `True` or
+       `False`. If the requires_grad status is not consistent across all parameters, the value will be set to
+       `"irregular"`.
+    - `available_adapters` (`list[str]`):
+       The names of the available adapters, e.g. `["default"]`.
+    - `devices` (`dict[str, list[str]]`):
+       The devices where the parameters of the given adapter are stored, e.g. `["cuda"]`.
+    - `quantization_backend` (`str` or `None`):
+       The name of the quantization backend, e.g. `"bnb 4bit"`, or `None` if not quantized.
+
+    Args:
+        model ([Union[`~PeftModel`, `~transformers.PreTrainedModel`, `nn.Module`]]):
+            The model to get the adapter layer status from.
+
+    Returns:
+        list[`peft.peft_model.TunerLayerStatus`]:
+            A list of dataclasses, each containing the status of the corresponding adapter layer.
+
+    """
+    if isinstance(model, PeftModel):
+        base_model = model.base_model
+        if not isinstance(base_model, BaseTuner):
+            raise TypeError(
+                "get_layer_status() got an invalid PeftModel instance; prefix tuning and adaption prompt are not "
+                "supported."
+            )
+    else:
+        base_model = model
+
+    layer_status: list[TunerLayerStatus] = []
+    for name, module in base_model.named_modules():
+        if not isinstance(module, (BaseTunerLayer, AuxiliaryTrainingWrapper)):
+            continue
+        if isinstance(module, TrainableTokensWrapper):
+            # Skip TrainableTokensWrapper, since it wraps TrainableTokensLayer, which is the actual PEFT layer we're
+            # interested in.
+            continue
+
+        # determine if all submodules/parameters if this module require grad or not
+        mapping_requires_grad_list: dict[str, list[bool]] = collections.defaultdict(list)
+        for adapter_module_name in module.adapter_layer_names:
+            adapter_module = getattr(module, adapter_module_name)
+            if isinstance(adapter_module, torch.nn.ModuleDict):
+                for key, submodule in adapter_module.items():
+                    for param in submodule.parameters():
+                        mapping_requires_grad_list[key].append(param.requires_grad)
+            elif isinstance(adapter_module, torch.nn.ParameterDict):
+                for key, param in adapter_module.items():
+                    mapping_requires_grad_list[key].append(param.requires_grad)
+            else:
+                # strange, we don't know how to handle this, ignore for now
+                pass
+
+        def check_irrgular(vals: list[bool]) -> bool | Literal["irregular"]:
+            if all(vals):
+                return True
+            if not any(vals):
+                return False
+            return "irregular"
+
+        requires_grad = {key: check_irrgular(vals) for key, vals in mapping_requires_grad_list.items()}
+
+        devices_dd = collections.defaultdict(list)
+        for adapter_module_name in module.adapter_layer_names + module.other_param_names:
+            adapter_module = getattr(module, adapter_module_name)
+            if isinstance(adapter_module, torch.nn.ModuleDict):
+                for key, submodule in adapter_module.items():
+                    devices_dd[key].extend([param.device.type for param in submodule.parameters()])
+            elif isinstance(adapter_module, torch.nn.ParameterDict) or (
+                adapter_module.__class__.__name__ == "BufferDict"
+            ):  # VeRA
+                for key, param in adapter_module.items():
+                    devices_dd[key].append(param.device.type)
+        devices = {key: sorted(set(val)) for key, val in devices_dd.items()}
+
+        quantization_backend = getattr(module, "quantization_backend", None)
+        quantization_backend_name = quantization_backend.backend_name if quantization_backend is not None else None
+
+        status = TunerLayerStatus(
+            name=name,
+            module_type=repr(module).partition("(")[0],
+            enabled=not module.disable_adapters,
+            active_adapters=module.active_adapters,
+            merged_adapters=module.merged_adapters,
+            requires_grad=requires_grad,
+            available_adapters=sorted(module._get_available_adapters()),
+            devices=devices,
+            quantization_backend=quantization_backend_name,
+        )
+        layer_status.append(status)
+
+    if not layer_status:
+        raise ValueError(
+            "No adapter layers found in the model, please ensure that it's a PEFT model or that you have PEFT adapters "
+            "injected in the model."
+        )
+
+    return layer_status
+
+
+@dataclass
+class TunerModelStatus:
+    base_model_type: str
+    adapter_model_type: str
+    peft_types: dict[str, str]
+    trainable_params: int
+    total_params: int
+    num_adapter_layers: int
+    enabled: bool | Literal["irregular"]
+    active_adapters: list[str] | Literal["irregular"]
+    merged_adapters: list[str] | Literal["irregular"]
+    requires_grad: dict[str, bool | Literal["irregular"]]
+    available_adapters: list[str]
+    devices: dict[str, list[str]]
+    quantization_backend: str | None | Literal["irregular"]
+
+
+def get_model_status(model: torch.nn.Module) -> TunerModelStatus:
+    """Get the status of tuners of the model.
+
+    This function returns a `TunerModelStatus` dataclass instance, which contains the following attributes:
+
+    - `base_model_type` (`str`):
+       The type of the base model, e.g. `T5Model`.
+    - `adapter_model_type` (`str`):
+       The type of the adapter model, e.g. `LoraModel`.
+    - `peft_types` (`dict[str, str]`):
+       The mapping of adapter name to adapter type, e.g. `{"default": "LORA"}`.
+    - `trainable_params` (`int`):
+       The number of trainable parameters in the model.
+    - `total_params` (`int`):
+       The total number of parameters in the model.
+    - `num_adapter_layers` (`int`):
+       The number of adapter layers in the model.
+    - `enabled` (`bool`, `Literal["irregular"]`):
+       Whether all adapter layers are enabled. If some are enabled and some are not, this will be `"irregular"`. This
+       means that your model is in an inconsistent state and might not work as expected.
+    - `active_adapters` (`list[str]`, `Literal["irregular"]`):
+       The names of the active adapters. If the active adapters are not consistent across all layers, this will be
+       `"irregular"`, which means that your model is in an inconsistent state and might not work as expected.
+    - `merged_adapters` (`list[str]`, `Literal["irregular"]`):
+       The names of the merged adapters. If the merged adapters are not consistent across all layers, this will be
+       `"irregular"`, which means that your model is in an inconsistent state and might not work as expected.
+    - `requires_grad` (`dict[str, bool | Literal["irregular"]]`):
+       Whether for the given adapter, all adapter layers have `requires_grad` set to `True` or `False`. If there is a
+       mix, this will be set to `"irregular"`, which means that your model is in an inconsistent state and might not
+       work as expected.
+    - `available_adapters` (`list[str]`):
+       The names of the available adapters, e.g. `["default"]`.
+    - `devices` (`dict[str, list[str]]`):
+       The devices where the parameters of the given adapter are stored, e.g. `["cuda"]`.
+    - `quantization_backend` (`str`, `None`, `Literal["irregular"]`):
+       The name of the quantization backend, e.g. `"bnb 4bit"`, or `None` if not quantized. If the backend is not
+       consistent across all layers, this will be `"irregular"`.
+
+    Args:
+        model ([Union[`~PeftModel`, `~transformers.PreTrainedModel`, `nn.Module`]]):
+            The model to get the adapter layer status from.
+
+    Returns:
+        `peft.peft_model.TunerModelStatus`:
+            A dataclass containing the status of the model.
+
+    """
+    if isinstance(model, PeftModel):
+        if not isinstance(model.base_model, BaseTuner):
+            raise TypeError(
+                "get_model_status() got an invalid PeftModel instance; prefix tuning and adaption prompt are not "
+                "supported."
+            )
+        base_model_type = model.get_base_model().__class__.__name__
+        trainable_params, total_params = model.get_nb_trainable_parameters()
+        base_model = model.base_model
+        peft_types = {key: str(config.peft_type).partition(".")[-1] for key, config in base_model.peft_config.items()}
+        adapter_model_type = base_model.__class__.__name__
+    elif isinstance(model, PreTrainedModel):
+        base_model_type = model.__class__.__name__
+        trainable_params, total_params = PeftModel.get_nb_trainable_parameters(model)
+        base_model = model
+        peft_types = {}
+        adapter_model_type = "None"
+    else:
+        base_model_type = "other"
+        trainable_params, total_params = PeftModel.get_nb_trainable_parameters(model)
+        base_model = model
+        peft_types = {}
+        adapter_model_type = "None"
+
+    layer_status = get_layer_status(model)
+    num_adapter_layers = len(layer_status)
+
+    enabled_set: set[bool] = {status.enabled for status in layer_status}  # must be {True}, {False}, or {True, False}
+    enabled: bool | Literal["irregular"]
+    if len(enabled_set) == 1:
+        enabled = enabled_set.pop()
+    else:
+        enabled = "irregular"
+
+    available_adapters: list[str] = sorted(set().union(*(status.available_adapters for status in layer_status)))
+
+    # ideally, active adapters should be consistent across all layers of the model, but we cannot guarantee it
+    all_active_adapters: set[tuple[str, ...]] = {tuple(status.active_adapters) for status in layer_status}
+    active_adapters: list[str] | Literal["irregular"]
+    if not all_active_adapters:
+        active_adapters = []
+    elif len(all_active_adapters) == 1:
+        active_adapters = list(all_active_adapters.pop())
+    else:
+        active_adapters = "irregular"
+
+    # Here we determine what adapters are merged. This is not trivial because multiple adapters can be merged or not at
+    # the same time. Some layers may only have adapter A, some only adapter B, so it's not as easy as just checking
+    # which adapters are merged on each layer.
+
+    # First, determine all adapters that are merged on at least on module.
+    merged_all: set[str] = set()
+    for status in layer_status:
+        merged_all.update(status.merged_adapters)
+
+    # Next, check if on any layer, on of these adapters is not merged.
+    merged_adapters: list[str] | Literal["irregular"] = sorted(merged_all)
+    for status in layer_status:
+        unmerged = set(status.available_adapters) - set(status.merged_adapters)
+        if unmerged & merged_all:
+            # there is overlap between unmerged adapters and adapters that should be merged
+            merged_adapters = "irregular"
+            break
+
+    # check status of requires_grad
+    # first, merge the values for all layers
+    requires_grad_all: dict[str, list[bool | Literal["irregular"]]] = collections.defaultdict(list)
+    for status in layer_status:
+        for key, val in status.requires_grad.items():
+            requires_grad_all[key].append(val)
+
+    # then, check if the values are consistent
+    def check_irrgular(vals: list[bool | Literal["irregular"]]) -> bool | Literal["irregular"]:
+        if all(val is True for val in vals):
+            return True
+        if all(val is False for val in vals):
+            return False
+        return "irregular"
+
+    requires_grad = {key: check_irrgular(vals) for key, vals in requires_grad_all.items()}
+
+    devices_dd = collections.defaultdict(list)
+    for status in layer_status:
+        for key, val in status.devices.items():
+            devices_dd[key].extend(val)
+    devices = {key: sorted(set(val)) for key, val in devices_dd.items()}
+
+    # check quant backend consistency
+    quantization_backends_set: set[str | None] = {status.quantization_backend for status in layer_status}
+    quantization_backend: str | None | Literal["irregular"]
+    if len(quantization_backends_set) == 1:
+        quantization_backend = quantization_backends_set.pop()
+    else:
+        quantization_backend = "irregular"
+
+    adapter_model_status = TunerModelStatus(
+        base_model_type=base_model_type,
+        adapter_model_type=adapter_model_type,
+        peft_types=peft_types,
+        trainable_params=trainable_params,
+        total_params=total_params,
+        num_adapter_layers=num_adapter_layers,
+        enabled=enabled,
+        active_adapters=active_adapters,
+        merged_adapters=merged_adapters,
+        requires_grad=requires_grad,
+        available_adapters=available_adapters,
+        devices=devices,
+        quantization_backend=quantization_backend,
+    )
+    return adapter_model_status
diff --git a/src/peft/py.typed b/src/peft/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/src/peft/tuners/__init__.py b/src/peft/tuners/__init__.py
new file mode 100644
index 0000000..1751fb2
--- /dev/null
+++ b/src/peft/tuners/__init__.py
@@ -0,0 +1,183 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from .adalora import AdaLoraConfig, AdaLoraModel
+from .adamss import AdamssConfig, AdamssModel
+from .adaption_prompt import AdaptionPromptConfig, AdaptionPromptModel
+from .beft import BeftConfig, BeftModel
+from .boft import BOFTConfig, BOFTModel
+from .c3a import C3AConfig, C3AModel
+from .cartridge import CartridgeConfig, CartridgeEncoder
+from .cpt import CPTConfig, CPTEmbedding
+from .deft import DeftConfig, DeftModel
+from .delora import DeloraConfig, DeloraModel
+from .fourierft import FourierFTConfig, FourierFTModel
+from .frod import FrodConfig, FrodModel
+from .glora import GloraConfig, GloraModel
+from .gralora import GraloraConfig, GraloraModel
+from .hira import HiraConfig, HiraModel
+from .hra import HRAConfig, HRAModel
+from .ia3 import IA3Config, IA3Model
+from .lily import LilyConfig, LilyModel
+from .ln_tuning import LNTuningConfig, LNTuningModel
+from .loha import LoHaConfig, LoHaModel
+from .lokr import LoKrConfig, LoKrModel
+from .lora import (
+    ArrowConfig,
+    BdLoraConfig,
+    EvaConfig,
+    LoftQConfig,
+    LoraConfig,
+    LoraGAConfig,
+    LoraModel,
+    LoraRuntimeConfig,
+    MontecloraConfig,
+    VeloraConfig,
+    convert_to_lora,
+    create_arrow_model,
+    get_eva_state_dict,
+    initialize_lora_eva_weights,
+    preprocess_loraga,
+    save_as_lora,
+)
+from .miss import MissConfig, MissModel
+from .mixed import MixedModel
+from .multitask_prompt_tuning import MultitaskPromptEmbedding, MultitaskPromptTuningConfig, MultitaskPromptTuningInit
+from .oft import OFTConfig, OFTModel
+from .osf import OSFConfig, OSFModel
+from .p_tuning import PromptEncoder, PromptEncoderConfig, PromptEncoderReparameterizationType
+from .peanut import PeanutConfig, PeanutModel
+from .poly import PolyConfig, PolyModel
+from .prefix_tuning import PrefixEncoder, PrefixTuningConfig
+from .prompt_tuning import PromptEmbedding, PromptTuningConfig, PromptTuningInit
+from .psoft import PsoftConfig, PsoftModel
+from .pvera import PveraConfig, PveraModel
+from .randlora import RandLoraConfig, RandLoraModel
+from .road import RoadConfig, RoadModel
+from .shira import ShiraConfig, ShiraModel
+from .tinylora import TinyLoraConfig, TinyLoraModel
+from .trainable_tokens import TrainableTokensConfig, TrainableTokensModel
+from .unilora import UniLoraConfig, UniLoraModel
+from .vblora import VBLoRAConfig, VBLoRAModel
+from .vera import VeraConfig, VeraModel
+from .waveft import WaveFTConfig, WaveFTModel
+from .xlora import XLoraConfig, XLoraModel
+
+
+__all__ = [
+    "AdaLoraConfig",
+    "AdaLoraModel",
+    "AdamssConfig",
+    "AdamssModel",
+    "AdaptionPromptConfig",
+    "AdaptionPromptModel",
+    "ArrowConfig",
+    "BOFTConfig",
+    "BOFTModel",
+    "BdLoraConfig",
+    "BeftConfig",
+    "BeftModel",
+    "C3AConfig",
+    "C3AModel",
+    "CPTConfig",
+    "CPTEmbedding",
+    "CartridgeConfig",
+    "CartridgeEncoder",
+    "DeftConfig",
+    "DeftModel",
+    "DeloraConfig",
+    "DeloraModel",
+    "EvaConfig",
+    "FourierFTConfig",
+    "FourierFTModel",
+    "FrodConfig",
+    "FrodModel",
+    "GloraConfig",
+    "GloraModel",
+    "GraloraConfig",
+    "GraloraModel",
+    "HRAConfig",
+    "HRAModel",
+    "HiraConfig",
+    "HiraModel",
+    "IA3Config",
+    "IA3Model",
+    "LNTuningConfig",
+    "LNTuningModel",
+    "LilyConfig",
+    "LilyModel",
+    "LoHaConfig",
+    "LoHaModel",
+    "LoKrConfig",
+    "LoKrModel",
+    "LoftQConfig",
+    "LoraConfig",
+    "LoraGAConfig",
+    "LoraModel",
+    "LoraRuntimeConfig",
+    "MissConfig",
+    "MissModel",
+    "MixedModel",
+    "MontecloraConfig",
+    "MultitaskPromptEmbedding",
+    "MultitaskPromptTuningConfig",
+    "MultitaskPromptTuningInit",
+    "OFTConfig",
+    "OFTModel",
+    "OSFConfig",
+    "OSFModel",
+    "PeanutConfig",
+    "PeanutModel",
+    "PolyConfig",
+    "PolyModel",
+    "PrefixEncoder",
+    "PrefixTuningConfig",
+    "PromptEmbedding",
+    "PromptEncoder",
+    "PromptEncoderConfig",
+    "PromptEncoderReparameterizationType",
+    "PromptTuningConfig",
+    "PromptTuningInit",
+    "PsoftConfig",
+    "PsoftModel",
+    "PveraConfig",
+    "PveraModel",
+    "RandLoraConfig",
+    "RandLoraModel",
+    "RoadConfig",
+    "RoadModel",
+    "ShiraConfig",
+    "ShiraModel",
+    "TinyLoraConfig",
+    "TinyLoraModel",
+    "TrainableTokensConfig",
+    "TrainableTokensModel",
+    "UniLoraConfig",
+    "UniLoraModel",
+    "VBLoRAConfig",
+    "VBLoRAModel",
+    "VeloraConfig",
+    "VeraConfig",
+    "VeraModel",
+    "WaveFTConfig",
+    "WaveFTModel",
+    "XLoraConfig",
+    "XLoraModel",
+    "convert_to_lora",
+    "create_arrow_model",
+    "get_eva_state_dict",
+    "initialize_lora_eva_weights",
+    "preprocess_loraga",
+    "save_as_lora",
+]
diff --git a/src/peft/tuners/_buffer_dict.py b/src/peft/tuners/_buffer_dict.py
new file mode 100644
index 0000000..16e8fae
--- /dev/null
+++ b/src/peft/tuners/_buffer_dict.py
@@ -0,0 +1,159 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Adapted from https://botorch.org/api/_modules/botorch/utils/torch.html
+
+# TODO: To be removed once (if) https://github.com/pytorch/pytorch/pull/37385 lands
+
+from __future__ import annotations
+
+import collections
+from collections import OrderedDict
+
+import torch
+from torch.nn import Module
+
+
+class BufferDict(Module):
+    r"""
+    Holds buffers in a dictionary.
+
+    BufferDict can be indexed like a regular Python dictionary, but buffers it contains are properly registered, and
+    will be visible by all Module methods. `torch.nn.BufferDict` is an **ordered** dictionary that respects
+
+    * the order of insertion, and
+    * in `torch.nn.BufferDict.update`, the order of the merged `OrderedDict` or another `torch.nn.BufferDict` (the
+      argument to `torch.nn.BufferDict.update`).
+
+    Note that `torch.nn.BufferDict.update` with other unordered mapping types (e.g., Python's plain `dict`) does not
+    preserve the order of the merged mapping.
+
+    Args:
+        buffers (iterable, optional):
+            a mapping (dictionary) of (string : `torch.Tensor`) or an iterable of key-value pairs of type (string,
+            `torch.Tensor`)
+
+    ```python
+    class MyModule(nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.buffers = nn.BufferDict({"left": torch.randn(5, 10), "right": torch.randn(5, 10)})
+
+        def forward(self, x, choice):
+            x = self.buffers[choice].mm(x)
+            return x
+    ```
+    """
+
+    def __init__(self, buffers=None, persistent: bool = False):
+        r"""
+        Args:
+            buffers (`dict`):
+                A mapping (dictionary) from string to `torch.Tensor`, or an iterable of key-value pairs of type
+                (string, `torch.Tensor`).
+        """
+        super().__init__()
+        self.persistent = persistent
+
+        if buffers is not None:
+            self.update(buffers)
+
+    def __getitem__(self, key):
+        return self._buffers[key]
+
+    def __setitem__(self, key, buffer):
+        self.register_buffer(key, buffer, persistent=self.persistent)
+
+    def __delitem__(self, key):
+        del self._buffers[key]
+
+    def __len__(self):
+        return len(self._buffers)
+
+    def __iter__(self):
+        return iter(self._buffers.keys())
+
+    def __contains__(self, key):
+        return key in self._buffers
+
+    def clear(self):
+        """Remove all items from the BufferDict."""
+        self._buffers.clear()
+
+    def pop(self, key):
+        r"""Remove key from the BufferDict and return its buffer.
+
+        Args:
+            key (`str`):
+                Key to pop from the BufferDict
+        """
+        v = self[key]
+        del self[key]
+        return v
+
+    def keys(self):
+        r"""Return an iterable of the BufferDict keys."""
+        return self._buffers.keys()
+
+    def items(self):
+        r"""Return an iterable of the BufferDict key/value pairs."""
+        return self._buffers.items()
+
+    def values(self):
+        r"""Return an iterable of the BufferDict values."""
+        return self._buffers.values()
+
+    def update(self, buffers):
+        r"""
+        Update the `torch.nn.BufferDict` with the key-value pairs from a mapping or an iterable, overwriting existing
+        keys.
+
+        Note:
+            If `buffers` is an `OrderedDict`, a `torch.nn.BufferDict`, or an iterable of key-value pairs, the order of
+            new elements in it is preserved.
+
+        Args:
+            buffers (iterable):
+                a mapping (dictionary) from string to `torch.Tensor`, or an iterable of key-value pairs of type
+                (string, `torch.Tensor`).
+        """
+        if not isinstance(buffers, collections.abc.Iterable):
+            raise TypeError(
+                "BuffersDict.update should be called with an "
+                "iterable of key/value pairs, but got " + type(buffers).__name__
+            )
+
+        if isinstance(buffers, (OrderedDict, BufferDict)):
+            for key, buffer in buffers.items():
+                self[key] = buffer
+        elif isinstance(buffers, collections.abc.Mapping):
+            for key, buffer in sorted(buffers.items()):
+                self[key] = buffer
+        else:
+            for j, p in enumerate(buffers):
+                if not isinstance(p, collections.abc.Iterable):
+                    raise TypeError(
+                        "BufferDict update sequence element #" + str(j) + " should be Iterable; is" + type(p).__name__
+                    )
+                if not len(p) == 2:
+                    raise ValueError(
+                        "BufferDict update sequence element "
+                        "#" + str(j) + " has length " + str(len(p)) + "; 2 is required"
+                    )
+                self[p[0]] = p[1]
+
+    def extra_repr(self):
+        child_lines = []
+        for k, p in self._buffers.items():
+            size_str = "x".join(str(size) for size in p.size())
+            device_type = p.device.type
+            device_str = "" if device_type == "cpu" else f" ({device_type.upper()} {p.get_device()})"
+            parastr = f"Buffer containing: [{torch.typename(p)} of size {size_str}{device_str}]"
+            child_lines.append("  (" + k + "): " + parastr)
+        tmpstr = "\n".join(child_lines)
+        return tmpstr
+
+    def __call__(self, input):
+        raise RuntimeError("BufferDict should not be called.")
diff --git a/src/peft/tuners/adalora/__init__.py b/src/peft/tuners/adalora/__init__.py
new file mode 100644
index 0000000..f20fed9
--- /dev/null
+++ b/src/peft/tuners/adalora/__init__.py
@@ -0,0 +1,51 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+from peft.utils import register_peft_method
+
+from .config import AdaLoraConfig
+from .gptq import SVDQuantLinear
+from .layer import AdaLoraLayer, RankAllocator, SVDConv2d, SVDLinear
+from .model import AdaLoraModel
+
+
+__all__ = [
+    "AdaLoraConfig",
+    "AdaLoraLayer",
+    "AdaLoraModel",
+    "RankAllocator",
+    "SVDConv2d",
+    "SVDLinear",
+    "SVDQuantLinear",
+]
+
+
+register_peft_method(
+    name="adalora", config_cls=AdaLoraConfig, model_cls=AdaLoraModel, prefix="lora_", is_mixed_compatible=True
+)
+
+
+def __getattr__(name):
+    if (name == "SVDLinear8bitLt") and is_bnb_available():
+        from .bnb import SVDLinear8bitLt
+
+        return SVDLinear8bitLt
+
+    if (name == "SVDLinear4bit") and is_bnb_4bit_available():
+        from .bnb import SVDLinear4bit
+
+        return SVDLinear4bit
+
+    raise AttributeError(f"module {__name__} has no attribute {name}")
diff --git a/src/peft/tuners/adalora/bnb.py b/src/peft/tuners/adalora/bnb.py
new file mode 100644
index 0000000..52b43f0
--- /dev/null
+++ b/src/peft/tuners/adalora/bnb.py
@@ -0,0 +1,142 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from typing import Any
+
+import torch
+
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+
+from .config import AdaLoraConfig
+from .layer import AdaLoraLayer
+
+
+if is_bnb_available():
+
+    class SVDLinear8bitLt(torch.nn.Module, AdaLoraLayer):
+        # Low-rank matrix for SVD-based adaptation
+        def __init__(
+            self,
+            base_layer: torch.nn.Module,
+            adapter_name: str,
+            config: AdaLoraConfig,
+            r: int = 0,
+            lora_alpha: int = 1,
+            **kwargs,
+        ) -> None:
+            super().__init__()
+            AdaLoraLayer.__init__(self, base_layer)
+            # Freezing the pre-trained weight matrix
+            self.get_base_layer().weight.requires_grad = False
+
+            self._active_adapter = adapter_name
+            self.update_layer(adapter_name, r, lora_alpha, config=config)
+
+        def forward(self, x: torch.Tensor) -> torch.Tensor:
+            # note: no check for self.merged because merging is not supported (yet)
+            result = self.base_layer(x)
+
+            if self.disable_adapters:
+                return result
+
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.lora_A.keys():
+                    continue
+                requires_conversion = not torch.is_autocast_enabled()
+                if requires_conversion:
+                    expected_dtype = result.dtype
+                    if x.dtype != torch.float32:
+                        x = x.float()
+
+                lora_A = self.lora_A[active_adapter]
+                lora_B = self.lora_B[active_adapter]
+                lora_E = self.lora_E[active_adapter]
+                dropout = self.lora_dropout[active_adapter]
+                scaling = self.scaling[active_adapter]
+                ranknum = self.ranknum[active_adapter] + 1e-5
+
+                output = dropout(x) @ (lora_A * lora_E).T @ lora_B.T
+                if requires_conversion:
+                    output = output.to(expected_dtype)
+                output = output * scaling / ranknum
+                # inplace operation on view is forbidden for MatMul8bitLtBackward, so avoid it
+                result = result + output
+            return result
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return "adalora." + rep
+
+
+if is_bnb_4bit_available():
+
+    class SVDLinear4bit(torch.nn.Module, AdaLoraLayer):
+        # Low-rank matrix for SVD-based adaptation
+        def __init__(
+            self,
+            base_layer: torch.nn.Module,
+            adapter_name: str,
+            config: AdaLoraConfig,
+            r: int = 0,
+            lora_alpha: int = 1,
+            **kwargs,
+        ) -> None:
+            super().__init__()
+            AdaLoraLayer.__init__(self, base_layer)
+            # Freezing the pre-trained weight matrix
+            self.get_base_layer().weight.requires_grad = False
+
+            self._active_adapter = adapter_name
+            self.update_layer(adapter_name, r, lora_alpha, config=config)
+
+        def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+            # note: no check for self.merged because merging is not supported (yet)
+            result = self.base_layer(x, *args, **kwargs)
+
+            if self.disable_adapters:
+                return result
+
+            # As per Tim Dettmers, for 4bit, we need to defensively clone here.
+            # The reason is that in some cases, an error can occur that backprop
+            # does not work on a manipulated view. This issue may be solved with
+            # newer PyTorch versions but this would need extensive testing to be
+            # sure.
+            result = result.clone()
+
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.lora_A.keys():
+                    continue
+
+                lora_A = self.lora_A[active_adapter]
+                lora_B = self.lora_B[active_adapter]
+                lora_E = self.lora_E[active_adapter]
+                dropout = self.lora_dropout[active_adapter]
+                scaling = self.scaling[active_adapter]
+                ranknum = self.ranknum[active_adapter] + 1e-5
+
+                requires_conversion = not torch.is_autocast_enabled()
+                if requires_conversion:
+                    expected_dtype = result.dtype
+                    x = self._cast_input_dtype(x, lora_A.dtype)
+
+                output = dropout(x) @ (lora_A * lora_E).T @ lora_B.T
+                if requires_conversion:
+                    output = output.to(expected_dtype)
+                output = output * scaling / ranknum
+                result += output
+            return result
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return "adalora." + rep
diff --git a/src/peft/tuners/adalora/config.py b/src/peft/tuners/adalora/config.py
new file mode 100644
index 0000000..567108a
--- /dev/null
+++ b/src/peft/tuners/adalora/config.py
@@ -0,0 +1,108 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import warnings
+from dataclasses import dataclass, field
+from typing import Optional
+
+from peft.tuners.lora import LoraConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class AdaLoraConfig(LoraConfig):
+    """
+    This is the configuration class to store the configuration of a [`AdaLoraModel`].
+
+    AdaLoRA has three phases defined by `tinit`, `tfinal` and `total_step`.
+
+    The initial phase can be understood as a step for pre-training the adapters so that when reducing their rank, there
+    is already some information encoded that can be reduced instead of random matrices. This phase is defined by
+    supplying `tinit`.
+
+    After the initial phase is over (`tinit` steps have passed) and the final phase has not begun, AdaLoRA reduces the
+    budget of how much rank each layer is allowed to have with each step. This is where the reduction of rank is
+    happening. This goes on until `total_step - tfinal` steps are reached.
+
+    The last phase, beginning once `total_step - tfinal` steps are reached, does not change the layer ranks anymore but
+    fine-tunes the reduced-rank layers that resulted from the previous phase.
+
+    A practical example: `tinit` is 10, `tfinal` is 20, `total_step` is 100. We spend 10 steps doing pre-training
+    without rank reduction because our budget is constant (init phase), then we spend 80 (100-20) steps in the
+    reduction phase where our budget decreases step-wise and, finally, 20 steps in the final fine-tuning stage without
+    reduction.
+
+    Args:
+        target_r (`int`): The target average rank of incremental matrix.
+        init_r (`int`): The initial rank for each incremental matrix.
+        tinit (`int`): The steps of initial fine-tuning warmup.
+        tfinal (`int`): The number of steps of final fine-tuning.
+        deltaT (`int`): The time internval between two budget allocations.
+        beta1 (`float`): The hyperparameter of EMA for sensitivity smoothing.
+        beta2 (`float`): The hyperparameter of EMA for undertainty quantification.
+        orth_reg_weight (`float`): The coefficient of orthogonal regularization.
+        total_step (`int`): The total training steps that should be specified before training.
+        rank_pattern (`list`): The allocated rank for each weight matrix by RankAllocator.
+    """
+
+    target_r: int = field(default=8, metadata={"help": "Target Lora matrix dimension."})
+    init_r: int = field(default=12, metadata={"help": "Initial Lora matrix dimension."})
+    tinit: int = field(default=0, metadata={"help": "The steps of initial warmup."})
+    tfinal: int = field(default=0, metadata={"help": "The steps of final warmup."})
+    deltaT: int = field(default=1, metadata={"help": "Step interval of rank allocation."})
+    beta1: float = field(default=0.85, metadata={"help": "Hyperparameter of EMA."})
+    beta2: float = field(default=0.85, metadata={"help": "Hyperparameter of EMA."})
+    orth_reg_weight: float = field(default=0.5, metadata={"help": "The orthogonal regularization coefficient."})
+    total_step: Optional[int] = field(default=None, metadata={"help": "The total training steps."})
+    rank_pattern: Optional[dict] = field(default=None, metadata={"help": "The saved rank pattern."})
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.ADALORA
+
+        if self.use_dora:
+            raise ValueError(f"{self.peft_type} does not support DoRA.")
+
+        if self.loftq_config:
+            raise ValueError(f"{self.peft_type} does not support LOFTQ.")
+
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        self.exclude_modules = (
+            set(self.exclude_modules) if isinstance(self.exclude_modules, list) else self.exclude_modules
+        )
+        # if target_modules is a regex expression, then layers_to_transform should be None
+        if isinstance(self.target_modules, str) and self.layers_to_transform is not None:
+            raise ValueError("`layers_to_transform` cannot be used when `target_modules` is a str.")
+
+        # check for layers_to_transform and layers_pattern
+        if self.layers_pattern and not self.layers_to_transform:
+            raise ValueError("When `layers_pattern` is specified, `layers_to_transform` must also be specified. ")
+
+        # Check if 'r' has been set to a non-default value
+        if self.r != 8:  # 8 is the default value for 'r' in LoraConfig
+            warnings.warn(
+                "Note that `r` is not used in AdaLora and will be ignored."
+                "If you intended to set the initial rank, use `init_r` instead."
+            )
+
+        if self.total_step is None or self.total_step <= 0:
+            raise ValueError("AdaLoRA does not work when `total_step` is None, supply a value > 0.")
+
+        if self.tinit >= (self.total_step - self.tfinal):
+            raise ValueError(
+                "The supplied schedule values don't allow for a budgeting phase. Decrease `tfinal`/`tinit` or "
+                "increase `total_step`."
+            )
diff --git a/src/peft/tuners/adalora/gptq.py b/src/peft/tuners/adalora/gptq.py
new file mode 100644
index 0000000..cf7cb0e
--- /dev/null
+++ b/src/peft/tuners/adalora/gptq.py
@@ -0,0 +1,71 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+import torch
+
+from .config import AdaLoraConfig
+from .layer import AdaLoraLayer
+
+
+class SVDQuantLinear(torch.nn.Module, AdaLoraLayer):
+    def __init__(
+        self,
+        base_layer,
+        adapter_name,
+        config: AdaLoraConfig,
+        r: int = 0,
+        lora_alpha: int = 1,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        AdaLoraLayer.__init__(self, base_layer)
+
+        # self.base_layer and self.quant_linear_module are the same; we need the former for consistency and the latter
+        # for backwards compatibility
+        self.quant_linear_module = base_layer
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, lora_alpha=lora_alpha, config=config)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        result = self.quant_linear_module(x)
+
+        if self.disable_adapters:
+            return result
+
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self.lora_A.keys():
+                continue
+            lora_A = self.lora_A[active_adapter]
+            lora_B = self.lora_B[active_adapter]
+            lora_E = self.lora_E[active_adapter]
+            dropout = self.lora_dropout[active_adapter]
+            scaling = self.scaling[active_adapter]
+            ranknum = self.ranknum[active_adapter] + 1e-5
+
+            requires_conversion = not torch.is_autocast_enabled()
+            if requires_conversion:
+                expected_dtype = result.dtype
+                x = self._cast_input_dtype(x, torch.float32)
+
+            output = (dropout(x) @ (lora_A * lora_E).T @ lora_B.T) * scaling / ranknum
+            # TODO: here, the dtype conversion is applied on the *whole expression*,
+            # not the intermediate result, unlike for SVDLinear8bitLT and
+            # SVDLinear4bit, is that correct?
+            if requires_conversion:
+                output = output.to(expected_dtype)
+            result += output
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "adalora." + rep
diff --git a/src/peft/tuners/adalora/layer.py b/src/peft/tuners/adalora/layer.py
new file mode 100644
index 0000000..4cc7a62
--- /dev/null
+++ b/src/peft/tuners/adalora/layer.py
@@ -0,0 +1,515 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import warnings
+from typing import Any, Optional
+
+import packaging
+import torch
+import transformers
+from torch import nn
+
+from peft.tuners.lora import LoraLayer
+from peft.tuners.tuners_utils import check_adapters_to_merge
+from peft.utils import transpose
+from peft.utils.integrations import _skip_init_on_device
+
+from .config import AdaLoraConfig
+
+
+if packaging.version.parse(transformers.__version__) >= packaging.version.parse("4.33.0"):
+    from transformers.integrations import deepspeed_config
+else:
+    from transformers.deepspeed import deepspeed_config
+
+
+class AdaLoraLayer(LoraLayer):
+    # List all names of layers that may contain adapter weights
+    # Note: ranknum doesn't need to be included as it is not an nn.Module
+    adapter_layer_names = ("lora_A", "lora_B", "lora_E", "lora_embedding_A", "lora_embedding_B")
+    # All names of other parameters that may contain adapter-related parameters
+    other_param_names = ("r", "lora_alpha", "scaling", "lora_dropout", "ranknum")
+
+    def __init__(self, base_layer: nn.Module) -> None:
+        super().__init__(base_layer)
+        self.lora_E = nn.ParameterDict({})
+        self.lora_A = nn.ParameterDict({})
+        self.lora_B = nn.ParameterDict({})
+        self.ranknum = nn.ParameterDict({})
+
+    def update_layer(self, adapter_name: str, r: int, lora_alpha: int, config: AdaLoraConfig, **kwargs) -> None:
+        lora_dropout = config.lora_dropout
+        init_lora_weights = config.init_lora_weights
+        inference_mode = config.inference_mode
+        if r < 0:
+            # note: r == 0 is allowed for AdaLora, see #1539
+            raise ValueError(f"`r` should be a positive integer or 0, but the value passed is {r}")
+
+        self.r[adapter_name] = r
+        self.lora_alpha[adapter_name] = lora_alpha
+        if lora_dropout > 0.0:
+            lora_dropout_layer = nn.Dropout(p=lora_dropout)
+        else:
+            lora_dropout_layer = nn.Identity()
+
+        self.lora_dropout[adapter_name] = lora_dropout_layer
+        # Actual trainable parameters
+        # Right singular vectors
+        self.lora_A[adapter_name] = nn.Parameter(torch.randn(r, self.in_features))
+        # Singular values
+        self.lora_E[adapter_name] = nn.Parameter(torch.randn(r, 1))
+        # Left singular vectors
+        self.lora_B[adapter_name] = nn.Parameter(torch.randn(self.out_features, r))
+        # The current rank. ranknum is deterministic (always set to float(r)) and is not saved
+        # in the adapter state_dict, so under low_cpu_mem_usage=True it can't be restored from a
+        # checkpoint and must stay off the meta device. Two places need to skip the meta dispatch:
+        #   1) creation, otherwise the Parameter is registered on meta from the start;
+        #   2) the subsequent _move_adapter_to_device_of_base_layer call, because moving the
+        #      ParameterDict entry re-registers it via Module.__setattr__ → register_parameter,
+        #      which inside init_empty_weights would send the tensor back to meta.
+        with _skip_init_on_device():
+            self.ranknum[adapter_name] = nn.Parameter(torch.randn(1), requires_grad=False)
+            self.ranknum[adapter_name].data.fill_(float(r))
+            self.ranknum[adapter_name].requires_grad = False
+            self.scaling[adapter_name] = lora_alpha if lora_alpha > 0 else float(r)
+            if init_lora_weights:
+                self.reset_lora_parameters(adapter_name)
+
+            self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def reset_lora_parameters(self, adapter_name):
+        if adapter_name in self.lora_A.keys():
+            nn.init.zeros_(self.lora_E[adapter_name])
+            nn.init.normal_(self.lora_A[adapter_name], mean=0.0, std=0.02)
+            nn.init.normal_(self.lora_B[adapter_name], mean=0.0, std=0.02)
+
+
+class SVDLinear(nn.Module, AdaLoraLayer):
+    # SVD-based adaptation by a dense layer
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        adapter_name: str,
+        config: AdaLoraConfig,
+        r: int = 0,
+        lora_alpha: int = 1,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        AdaLoraLayer.__init__(self, base_layer)
+        # Freezing the pre-trained weight matrix
+        self.get_base_layer().weight.requires_grad = False
+
+        self.fan_in_fan_out = config.fan_in_fan_out
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, lora_alpha, config=config)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            base_layer = self.get_base_layer()
+            if active_adapter in self.lora_A.keys():
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    # because of the copy operation.
+                    orig_weights = base_layer.weight.data.clone()
+                    orig_weights += self.get_delta_weight(active_adapter)
+
+                    if not torch.isfinite(orig_weights).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = orig_weights
+                else:
+                    base_layer.weight.data += self.get_delta_weight(active_adapter)
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.lora_A.keys():
+                self.get_base_layer().weight.data -= self.get_delta_weight(active_adapter)
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        return (
+            transpose(self.lora_B[adapter] @ (self.lora_A[adapter] * self.lora_E[adapter]), self.fan_in_fan_out)
+            * self.scaling[adapter]
+            / (self.ranknum[adapter] + 1e-5)
+        )
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.lora_A.keys():
+                    continue
+                lora_A = self.lora_A[active_adapter]
+                lora_B = self.lora_B[active_adapter]
+                lora_E = self.lora_E[active_adapter]
+                dropout = self.lora_dropout[active_adapter]
+                scaling = self.scaling[active_adapter]
+                ranknum = self.ranknum[active_adapter] + 1e-5
+
+                x = self._cast_input_dtype(x, lora_A.dtype)
+                result += (dropout(x) @ (lora_A * lora_E).T @ lora_B.T) * scaling / ranknum
+
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "adalora." + rep
+
+
+class SVDConv2d(nn.Module, AdaLoraLayer):
+    # SVD-based adaptation by a Conv2d layer
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        adapter_name: str,
+        config: AdaLoraConfig,
+        r: int = 0,
+        lora_alpha: int = 1,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        AdaLoraLayer.__init__(self, base_layer)
+        self.get_base_layer().weight.requires_grad = False
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, lora_alpha, config=config)
+
+    def update_layer(self, adapter_name: str, r: int, lora_alpha: int, config: AdaLoraConfig, **kwargs) -> None:
+        lora_dropout = config.lora_dropout
+        init_lora_weights = config.init_lora_weights
+        inference_mode = config.inference_mode
+        if r < 0:
+            raise ValueError(f"`r` should be a positive integer or 0, but the value passed is {r}")
+
+        self.r[adapter_name] = r
+        self.lora_alpha[adapter_name] = lora_alpha
+        if lora_dropout > 0.0:
+            lora_dropout_layer = nn.Dropout(p=lora_dropout)
+        else:
+            lora_dropout_layer = nn.Identity()
+        self.lora_dropout[adapter_name] = lora_dropout_layer
+
+        base = self.get_base_layer()
+        k = base.kernel_size[0] * base.kernel_size[1]
+        # Right singular vectors: (r, in_channels * kH * kW)
+        self.lora_A[adapter_name] = nn.Parameter(torch.randn(r, self.in_features * k))
+        # Singular values: (r, 1)
+        self.lora_E[adapter_name] = nn.Parameter(torch.randn(r, 1))
+        # Left singular vectors: (out_channels, r)
+        self.lora_B[adapter_name] = nn.Parameter(torch.randn(self.out_features, r))
+        # Current rank — see note in AdaLoraLayer.update_layer about _skip_init_on_device.
+        with _skip_init_on_device():
+            self.ranknum[adapter_name] = nn.Parameter(torch.randn(1), requires_grad=False)
+            self.ranknum[adapter_name].data.fill_(float(r))
+            self.ranknum[adapter_name].requires_grad = False
+            self.scaling[adapter_name] = lora_alpha if lora_alpha > 0 else float(r)
+            if init_lora_weights:
+                self.reset_lora_parameters(adapter_name)
+
+            self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            return
+
+        for active_adapter in adapter_names:
+            base_layer = self.get_base_layer()
+            if active_adapter in self.lora_A.keys():
+                if safe_merge:
+                    orig_weights = base_layer.weight.data.clone()
+                    orig_weights += self.get_delta_weight(active_adapter)
+
+                    if not torch.isfinite(orig_weights).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = orig_weights
+                else:
+                    base_layer.weight.data += self.get_delta_weight(active_adapter)
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.lora_A.keys():
+                self.get_base_layer().weight.data -= self.get_delta_weight(active_adapter)
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        delta = (
+            self.lora_B[adapter]
+            @ (self.lora_A[adapter] * self.lora_E[adapter])
+            * self.scaling[adapter]
+            / (self.ranknum[adapter] + 1e-5)
+        )
+        return delta.reshape(self.get_base_layer().weight.shape)
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.lora_A.keys():
+                    continue
+                lora_A = self.lora_A[active_adapter]
+                lora_B = self.lora_B[active_adapter]
+                lora_E = self.lora_E[active_adapter]
+                dropout = self.lora_dropout[active_adapter]
+                scaling = self.scaling[active_adapter]
+                ranknum = self.ranknum[active_adapter] + 1e-5
+
+                x = self._cast_input_dtype(x, lora_A.dtype)
+                base = self.get_base_layer()
+                delta_w = (lora_B @ (lora_A * lora_E) * scaling / ranknum).reshape(base.weight.shape)
+                # Use in-place add so result keeps its original dtype (matches SVDLinear);
+                # otherwise result would be upcast to lora_A.dtype and break subsequent fp16/bf16 ops.
+                result += nn.functional.conv2d(
+                    dropout(x),
+                    delta_w,
+                    stride=base.stride,
+                    padding=base.padding,
+                    dilation=base.dilation,
+                    groups=base.groups,
+                )
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "adalora." + rep
+
+
+class RankAllocator:
+    """
+    The RankAllocator for AdaLoraModel. Paper: https://openreview.net/pdf?id=lq62uWRJjiY
+
+    Args:
+        config ([`AdaLoraConfig`]): The configuration of the AdaLora model.
+        model: the model that we apply AdaLoRA to.
+
+    """
+
+    def __init__(self, model, peft_config, adapter_name):
+        self.peft_config = peft_config
+        self.adapter_name = adapter_name
+        self.beta1 = peft_config.beta1
+        self.beta2 = peft_config.beta2
+        assert self.beta1 > 0 and self.beta1 < 1
+        assert self.beta2 > 0 and self.beta2 < 1
+
+        self.reset_ipt()
+        self._set_budget_scheduler(model)
+
+    def set_total_step(self, total_step):
+        self.peft_config.total_step = total_step
+
+    def reset_ipt(self):
+        self.ipt = {}
+        self.exp_avg_ipt = {}
+        self.exp_avg_unc = {}
+
+    def _set_budget_scheduler(self, model):
+        self.init_bgt = 0
+        self.name_set = set()
+        for n, p in model.named_parameters():
+            if f"lora_A.{self.adapter_name}" in n:
+                self.init_bgt += p.size(0)
+                self.name_set.add(n.replace("lora_A", "%s"))
+        self.name_set = sorted(self.name_set)
+        # The total final rank budget
+        self.target_bgt = self.peft_config.target_r * len(self.name_set)
+
+    def budget_schedule(self, step: int):
+        tinit = self.peft_config.tinit
+        tfinal = self.peft_config.tfinal
+        total_step = self.peft_config.total_step
+        # Initial warmup
+        if step <= tinit:
+            budget = self.init_bgt
+            mask_ind = False
+        # Final fine-tuning
+        elif step > total_step - tfinal:
+            budget = self.target_bgt
+            mask_ind = True
+        else:
+            # Budget decreasing with a cubic scheduler
+            mul_coeff = 1 - (step - tinit) / (total_step - tfinal - tinit)
+            budget = int((self.init_bgt - self.target_bgt) * (mul_coeff**3) + self.target_bgt)
+            mask_ind = step % self.peft_config.deltaT == 0
+        return budget, mask_ind
+
+    def update_ipt(self, model):
+        # Update the sensitivity and uncertainty for every weight
+        for n, p in model.named_parameters():
+            if "lora_" in n and self.adapter_name in n:
+                if n not in self.ipt:
+                    self.ipt[n] = torch.zeros_like(p)
+                    self.exp_avg_ipt[n] = torch.zeros_like(p)
+                    self.exp_avg_unc[n] = torch.zeros_like(p)
+                with torch.no_grad():
+                    if deepspeed_config() is not None:
+                        import deepspeed
+
+                        grad = deepspeed.utils.safe_get_full_grad(p)
+                        self.ipt[n] = (p * grad).abs().detach()
+                    else:
+                        self.ipt[n] = (p * p.grad).abs().detach()
+                    # Sensitivity smoothing
+                    self.exp_avg_ipt[n] = self.beta1 * self.exp_avg_ipt[n] + (1 - self.beta1) * self.ipt[n]
+                    # Uncertainty quantification
+                    self.exp_avg_unc[n] = (
+                        self.beta2 * self.exp_avg_unc[n] + (1 - self.beta2) * (self.ipt[n] - self.exp_avg_ipt[n]).abs()
+                    )
+
+    def _element_score(self, n):
+        return self.exp_avg_ipt[n] * self.exp_avg_unc[n]
+
+    def _combine_ipt(self, ipt_E, ipt_AB):
+        ipt_AB = ipt_AB.sum(dim=1, keepdim=False)
+        sum_ipt = ipt_E.view(-1) + ipt_AB.view(-1)
+        return sum_ipt
+
+    def mask_to_budget(self, model, budget):
+        value_ipt = {}
+        vector_ipt = {}
+        triplet_ipt = {}
+        # Get the importance score for A, E, B
+        for n, p in model.named_parameters():
+            if f"lora_A.{self.adapter_name}" in n:
+                entry_ipt = self._element_score(n)
+                comb_ipt = torch.mean(entry_ipt, dim=1, keepdim=True)
+                name_m = n.replace("lora_A", "%s")
+                if name_m not in vector_ipt:
+                    vector_ipt[name_m] = [comb_ipt]
+                else:
+                    vector_ipt[name_m].append(comb_ipt)
+            if f"lora_B.{self.adapter_name}" in n:
+                entry_ipt = self._element_score(n)
+                comb_ipt = torch.mean(entry_ipt, dim=0, keepdim=False).view(-1, 1)
+                name_m = n.replace("lora_B", "%s")
+                if name_m not in vector_ipt:
+                    vector_ipt[name_m] = [comb_ipt]
+                else:
+                    vector_ipt[name_m].append(comb_ipt)
+            if f"lora_E.{self.adapter_name}" in n:
+                entry_ipt = self._element_score(n)
+                name_m = n.replace("lora_E", "%s")
+                value_ipt[name_m] = entry_ipt
+
+        all_score = []
+        # Calculate the score for each triplet
+        for name_m in vector_ipt:
+            ipt_E = value_ipt[name_m]
+            ipt_AB = torch.cat(vector_ipt[name_m], dim=1)
+            sum_ipt = self._combine_ipt(ipt_E, ipt_AB)
+            name_E = name_m % "lora_E"
+            triplet_ipt[name_E] = sum_ipt.view(-1, 1)
+            all_score.append(sum_ipt.view(-1))
+
+        # Get the threshold by ranking ipt
+        mask_threshold = torch.kthvalue(
+            torch.cat(all_score),
+            k=self.init_bgt - budget,
+        )[0].item()
+
+        rank_pattern = {}
+        # Mask the unimportant triplets
+        with torch.no_grad():
+            for n, p in model.named_parameters():
+                if f"lora_E.{self.adapter_name}" in n:
+                    p.masked_fill_(triplet_ipt[n] <= mask_threshold, 0.0)
+                    rank_pattern[n] = (~(triplet_ipt[n] <= mask_threshold)).view(-1).tolist()
+        return rank_pattern
+
+    def update_and_allocate(self, model, global_step, force_mask=False):
+        # # Update the importance score and allocate the budget
+        if global_step < self.peft_config.total_step - self.peft_config.tfinal:
+            self.update_ipt(model)
+        budget, mask_ind = self.budget_schedule(global_step)
+        # Allocate the budget according to importance scores
+        if mask_ind or force_mask:
+            rank_pattern = self.mask_to_budget(model, budget)
+        else:
+            rank_pattern = None
+        return budget, rank_pattern
+
+    def mask_using_rank_pattern(self, model, rank_pattern):
+        # Mask the unimportant triplets
+        is_adapter_name_truncated = False
+        if self.adapter_name not in next(iter(rank_pattern.keys())):
+            is_adapter_name_truncated = True
+
+        with torch.no_grad():
+            for n, p in model.named_parameters():
+                if f"lora_E.{self.adapter_name}" in n:
+                    key = n if not is_adapter_name_truncated else n.replace(f".{self.adapter_name}", "")
+                    mask = torch.Tensor(rank_pattern[key]).unsqueeze(-1).to(p.device)
+                    p.masked_fill_(~mask.bool(), 0.0)
diff --git a/src/peft/tuners/adalora/model.py b/src/peft/tuners/adalora/model.py
new file mode 100644
index 0000000..7937ab7
--- /dev/null
+++ b/src/peft/tuners/adalora/model.py
@@ -0,0 +1,349 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import warnings
+
+import torch
+from transformers.pytorch_utils import Conv1D
+
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+from peft.tuners.lora import LoraConfig, LoraModel
+from peft.tuners.tuners_utils import BaseTunerLayer, get_device_map
+from peft.utils import (
+    TRANSFORMERS_MODELS_TO_ADALORA_TARGET_MODULES_MAPPING,
+    _freeze_adapter,
+    _get_submodules,
+    get_gptqmodel_quant_linear,
+    get_quantization_config,
+)
+from peft.utils.integrations import gather_params_ctx
+
+from .gptq import SVDQuantLinear
+from .layer import AdaLoraLayer, RankAllocator, SVDConv2d, SVDLinear
+
+
+class AdaLoraModel(LoraModel):
+    """
+    Creates AdaLoRA (Adaptive LoRA) model from a pretrained transformers model. Paper:
+    https://openreview.net/forum?id=lq62uWRJjiY
+
+    Args:
+        model ([`transformers.PreTrainedModel`]): The model to be adapted.
+        config ([`AdaLoraConfig`]): The configuration of the AdaLora model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            Create empty adapter weights on meta device. Useful to speed up the loading process.
+
+    Returns:
+        `torch.nn.Module`: The AdaLora model.
+
+    Example:
+        ```py
+        >>> from transformers import AutoModelForSeq2SeqLM
+        >>> from peft import AdaLoraConfig, get_peft_model
+
+        >>> config = AdaLoraConfig(
+        ...     peft_type="ADALORA",
+        ...     task_type="SEQ_2_SEQ_LM",
+        ...     init_r=12,
+        ...     lora_alpha=32,
+        ...     target_modules=["q", "v"],
+        ...     lora_dropout=0.01,
+        ...     total_step=1000,
+        ... )
+        >>> model = AutoModelForSeq2SeqLM.from_pretrained("t5-base")
+        >>> adalora_model = get_peft_model(model, config)
+        ```
+
+    **Attributes**:
+        - **model** ([`transformers.PreTrainedModel`]) -- The model to be adapted.
+        - **peft_config** ([`AdaLoraConfig`]): The configuration of the AdaLora model.
+    """
+
+    # Note: don't redefine prefix or tuner_layer_cls here, it should be inherited from LoraModel
+    target_module_mapping = TRANSFORMERS_MODELS_TO_ADALORA_TARGET_MODULES_MAPPING
+
+    def __init__(self, model, config, adapter_name, **kwargs):
+        super().__init__(model, config, adapter_name, **kwargs)
+
+        traininable_mode_counter = 0
+        for peft_config in self.peft_config.values():
+            if not peft_config.inference_mode:
+                traininable_mode_counter += 1
+
+        if traininable_mode_counter > 1:
+            raise ValueError(
+                "AdaLoraModel supports only 1 trainable adapter. "
+                "When using multiple adapters, set inference_mode to True for all adapters except the one you want to train."
+            )
+
+        if self.peft_config[adapter_name].inference_mode:
+            _freeze_adapter(self.model, adapter_name)
+        else:
+            self.trainable_adapter_name = adapter_name
+            self.rankallocator = RankAllocator(self.model, self.peft_config[adapter_name], self.trainable_adapter_name)
+
+    def _check_new_adapter_config(self, config: LoraConfig) -> None:
+        """
+        A helper method to check the config when a new adapter is being added.
+
+        Raise a ValueError if there is something wrong with the config or if it conflicts with existing adapters.
+
+        """
+        super()._check_new_adapter_config(config)
+
+        traininable_mode_counter = 0
+        for config_ in self.peft_config.values():
+            if not config_.inference_mode:
+                traininable_mode_counter += 1
+
+        if traininable_mode_counter > 1:
+            raise ValueError(
+                f"{self.__class__.__name__} supports only 1 trainable adapter. "
+                "When using multiple adapters, set inference_mode to True for all adapters except the one "
+                "you want to train."
+            )
+
+    def _create_and_replace(
+        self,
+        lora_config,
+        adapter_name,
+        target,
+        target_name,
+        parent,
+        current_key,
+    ):
+        kwargs = {
+            "r": lora_config.init_r,
+            "lora_alpha": lora_config.lora_alpha,
+            "loaded_in_8bit": getattr(self.model, "is_loaded_in_8bit", False),
+            "loaded_in_4bit": getattr(self.model, "is_loaded_in_4bit", False),
+        }
+        if (kwargs["loaded_in_8bit"] or kwargs["loaded_in_4bit"]) and not is_bnb_available():
+            raise ImportError(
+                "To use AdaLora with 8-bit quantization, please install the `bitsandbytes` package. "
+                "You can install it with `pip install bitsandbytes`."
+            )
+
+        quantization_config = get_quantization_config(self.model, method="gptq")
+        if quantization_config is not None:
+            kwargs["gptq_quantization_config"] = quantization_config
+
+        # If it is not an AdaLoraLayer, create a new module, else update it with new adapters
+        if not isinstance(target, AdaLoraLayer):
+            device_map = get_device_map(self.model)
+            new_module = self._create_new_module(lora_config, adapter_name, target, device_map=device_map, **kwargs)
+            if adapter_name not in self.active_adapters:
+                # adding an additional adapter: it is not automatically trainable
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+        else:
+            target.update_layer(
+                adapter_name,
+                lora_config.init_r,
+                lora_config.lora_alpha,
+                config=lora_config,
+            )
+
+    @staticmethod
+    def _create_new_module(lora_config, adapter_name, target, device_map=None, **kwargs):
+        # avoid eager bnb import
+        if is_bnb_available():
+            import bitsandbytes as bnb
+
+            from .bnb import SVDLinear8bitLt
+        if is_bnb_4bit_available():
+            from .bnb import SVDLinear4bit
+
+        gptq_quantization_config = kwargs.get("gptq_quantization_config", None)
+
+        QuantLinear = get_gptqmodel_quant_linear(gptq_quantization_config, device_map=device_map)
+
+        loaded_in_8bit = kwargs.pop("loaded_in_8bit", False)
+        loaded_in_4bit = kwargs.pop("loaded_in_4bit", False)
+
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        if loaded_in_8bit and isinstance(target_base_layer, bnb.nn.Linear8bitLt):
+            kwargs.update(
+                {
+                    "has_fp16_weights": target_base_layer.state.has_fp16_weights,
+                    "threshold": target_base_layer.state.threshold,
+                    "index": target_base_layer.index,
+                }
+            )
+            new_module = SVDLinear8bitLt(target, adapter_name, config=lora_config, **kwargs)
+        elif loaded_in_4bit and is_bnb_4bit_available() and isinstance(target_base_layer, bnb.nn.Linear4bit):
+            fourbit_kwargs = kwargs.copy()
+            fourbit_kwargs.update(
+                {
+                    "compute_dtype": target_base_layer.compute_dtype,
+                    "compress_statistics": target_base_layer.weight.compress_statistics,
+                    "quant_type": target_base_layer.weight.quant_type,
+                }
+            )
+            new_module = SVDLinear4bit(target, adapter_name, config=lora_config, **fourbit_kwargs)
+        elif QuantLinear is not None and isinstance(target, QuantLinear):
+            new_module = SVDQuantLinear(target, adapter_name, config=lora_config, **kwargs)
+        else:
+            if isinstance(target_base_layer, torch.nn.Linear):
+                if lora_config.fan_in_fan_out:
+                    warnings.warn(
+                        "fan_in_fan_out is set to True but the target module is `torch.nn.Linear`. "
+                        "Setting fan_in_fan_out to False."
+                    )
+                    lora_config.fan_in_fan_out = False
+            elif isinstance(target_base_layer, Conv1D):
+                if not lora_config.fan_in_fan_out:
+                    warnings.warn(
+                        "fan_in_fan_out is set to False but the target module is `Conv1D`. "
+                        "Setting fan_in_fan_out to True."
+                    )
+                    lora_config.fan_in_fan_out = True
+            elif not isinstance(target_base_layer, torch.nn.Conv2d):
+                raise ValueError(
+                    f"Target module {target} is not supported. "
+                    f"Currently, only `torch.nn.Linear`, `Conv1D`, and `torch.nn.Conv2d` are supported."
+                )
+            if isinstance(target_base_layer, torch.nn.Conv2d):
+                new_module = SVDConv2d(target, adapter_name, config=lora_config, **kwargs)
+            else:
+                new_module = SVDLinear(target, adapter_name, config=lora_config, **kwargs)
+
+        return new_module
+
+    def forward(self, *args, **kwargs):
+        outputs = self.model.forward(*args, **kwargs)
+
+        if (getattr(outputs, "loss", None) is not None) and isinstance(outputs.loss, torch.Tensor):
+            # Calculate the orthogonal regularization
+            orth_reg_weight = self.peft_config[self.trainable_adapter_name].orth_reg_weight
+
+            if orth_reg_weight <= 0:
+                raise ValueError("orth_reg_weight should be greater than 0. ")
+
+            regu_loss = 0
+            num_param = 0
+            for n, p in self.model.named_parameters():
+                if ("lora_A" in n or "lora_B" in n) and self.trainable_adapter_name in n:
+                    if p.shape == torch.Size([0]):
+                        with gather_params_ctx(p, fwd_module=self):
+                            para_cov = p @ p.T if "lora_A" in n else p.T @ p
+                    else:
+                        para_cov = p @ p.T if "lora_A" in n else p.T @ p
+                    I = torch.eye(*para_cov.size(), out=torch.empty_like(para_cov))  # noqa: E741
+                    I.requires_grad = False
+                    num_param += 1
+                    regu_loss += torch.norm(para_cov - I, p="fro")
+            if num_param > 0:
+                regu_loss = regu_loss / num_param
+            else:
+                regu_loss = 0
+            outputs.loss += orth_reg_weight * regu_loss
+        return outputs
+
+    def resize_modules_by_rank_pattern(self, rank_pattern, adapter_name):
+        lora_config = self.peft_config[adapter_name]
+        for name, rank_idx in rank_pattern.items():
+            if isinstance(rank_idx, list):
+                rank = sum(rank_idx)
+            elif isinstance(rank_idx, torch.Tensor):
+                rank_idx = rank_idx.view(-1)
+                rank = rank_idx.sum().item()
+            else:
+                raise TypeError("Unexpected type of rank_idx")
+            key = ".".join(name.split(".")[0:-2]) if adapter_name in name else ".".join(name.split(".")[0:-1])
+            _, target, _ = _get_submodules(self.model, key)
+            lora_E_weights = target.lora_E[adapter_name][rank_idx]
+            lora_A_weights = target.lora_A[adapter_name][rank_idx]
+            lora_B_weights = target.lora_B[adapter_name][:, rank_idx]
+            ranknum = target.ranknum[adapter_name]
+            target.update_layer(
+                adapter_name,
+                rank,
+                lora_config.lora_alpha,
+                config=lora_config,
+            )
+            with torch.no_grad():
+                if rank > 0:
+                    target.lora_E[adapter_name].copy_(lora_E_weights)
+                    target.lora_A[adapter_name].copy_(lora_A_weights)
+                    target.lora_B[adapter_name].copy_(lora_B_weights)
+                    # The scaling is exactly as the previous
+                    target.ranknum[adapter_name].copy_(ranknum)
+
+    def resize_state_dict_by_rank_pattern(self, rank_pattern, state_dict, adapter_name):
+        for name, rank_idx in rank_pattern.items():
+            rank = sum(rank_idx)
+            prefix = ".".join(name.split(".")[0:-2]) if adapter_name in name else ".".join(name.split(".")[0:-1])
+            for layer in ["lora_E", "lora_A", "lora_B"]:
+                key = f"base_model.model.{prefix}.{layer}.{adapter_name}"
+                if layer != "lora_B":
+                    state_dict[key] = (
+                        state_dict[key][rank_idx] if rank != state_dict[key].shape[0] else state_dict[key]
+                    )
+                else:
+                    state_dict[key] = (
+                        state_dict[key][:, rank_idx] if rank != state_dict[key].shape[1] else state_dict[key]
+                    )
+        return state_dict
+
+    def update_and_allocate(self, global_step):
+        """
+        This method updates Adalora budget and mask.
+
+        This should be called in every training step after `loss.backward()` and before `zero_grad()`.
+
+        `tinit`, `tfinal` and `deltaT` are handled with in the method.
+
+        Args:
+            global_step (`int`): The current training step, it is used to calculate adalora budget.
+
+        Example:
+
+        ```python
+        >>> loss = model(**input).loss
+        >>> loss.backward()
+        >>> optimizer.step()
+        >>> model.base_model.update_and_allocate(i_step)
+        >>> optimizer.zero_grad()
+        ```
+        """
+        lora_config = self.peft_config[self.trainable_adapter_name]
+        # Update the importance score and allocate the budget
+        if global_step < lora_config.total_step - lora_config.tfinal:
+            _, rank_pattern = self.rankallocator.update_and_allocate(self.model, global_step)
+            if rank_pattern:
+                lora_config.rank_pattern = rank_pattern
+        # Finalize the budget allocation
+        elif global_step == lora_config.total_step - lora_config.tfinal:
+            _, rank_pattern = self.rankallocator.update_and_allocate(self.model, global_step, force_mask=True)
+            # for some reason, this freezes the trainable parameters and nothing gets updates
+            # self.resize_modules_by_rank_pattern(rank_pattern, self.trainable_adapter_name)
+            lora_config.rank_pattern = rank_pattern
+            self.rankallocator.reset_ipt()
+        # Currently using inefficient way to mask the unimportant weights using the rank pattern
+        #  due to problem mentioned above
+        elif global_step > lora_config.total_step - lora_config.tfinal:
+            self.rankallocator.mask_using_rank_pattern(self.model, lora_config.rank_pattern)
+        # Pass the function and do forward propagation
+        else:
+            return
+
+    def add_weighted_adapter(self, *args, **kwargs):
+        """This method is not supported for AdaLoRA, use LoRA instead."""
+        raise TypeError(f"{self.__class__.__name__} does not support add_weighted_adapter method.")
diff --git a/src/peft/tuners/adamss/__init__.py b/src/peft/tuners/adamss/__init__.py
new file mode 100644
index 0000000..6aa764b
--- /dev/null
+++ b/src/peft/tuners/adamss/__init__.py
@@ -0,0 +1,32 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+from peft.utils import register_peft_method
+
+from .config import AdamssConfig
+from .layer import AdamssLayer, Linear
+from .model import AdamssModel
+
+
+__all__ = [
+    "AdamssConfig",
+    "AdamssLayer",
+    "AdamssModel",
+    "Linear",
+]
+
+# Register Adamss as a PEFT method
+register_peft_method(
+    name="adamss", config_cls=AdamssConfig, model_cls=AdamssModel, prefix="adamss_", is_mixed_compatible=False
+)
diff --git a/src/peft/tuners/adamss/asa_callback.py b/src/peft/tuners/adamss/asa_callback.py
new file mode 100644
index 0000000..2adfe56
--- /dev/null
+++ b/src/peft/tuners/adamss/asa_callback.py
@@ -0,0 +1,90 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+"""
+ASA (Adaptive Subspace Allocation) Callback for HuggingFace Trainer.
+
+This is a thin wrapper around [`AdamssModel.update_and_allocate`]. All ASA logic (importance accumulation, global top-K
+masking, importance reset) lives in [`AdamssModel.update_and_allocate`] so that users with custom training loops can
+call it directly without needing this callback.
+
+Important:
+    To avoid circular imports between peft and transformers, this callback is NOT exported from the top-level `peft`
+    package. Import it directly:
+
+    ```python
+    from peft.tuners.adamss.asa_callback import AdamssAsaCallback
+    ```
+"""
+
+from transformers import TrainerCallback, TrainerControl, TrainerState, TrainingArguments
+
+
+class AdamssAsaCallback(TrainerCallback):
+    """
+    Trainer callback for Adaptive Subspace Allocation (ASA).
+
+    This callback delegates to [`AdamssModel.update_and_allocate`] on every optimizer step so that ASA "just works"
+    with HuggingFace `Trainer`.
+
+    All ASA parameters (`asa_target_subspaces`, `init_warmup`, `final_warmup`, `mask_interval`, etc.) are read from the
+    [`AdamssConfig`] that was used to create the model – there is nothing to configure on the callback itself.
+
+    For custom training loops **without** Trainer, call `model.base_model.update_and_allocate(global_step)` directly
+    instead.
+
+    Example:
+
+    ```python
+    from peft import AdamssConfig, get_peft_model
+    from peft.tuners.adamss.asa_callback import AdamssAsaCallback
+    from transformers import Trainer
+
+    config = AdamssConfig(
+        r=100,
+        num_subspaces=10,
+        subspace_rank=3,
+        use_asa=True,
+        asa_target_subspaces=5,
+        init_warmup=50,
+        final_warmup=1000,
+        mask_interval=100,
+    )
+    model = get_peft_model(base_model, config)
+
+    trainer = Trainer(
+        model=model,
+        callbacks=[AdamssAsaCallback()],
+        # ...,
+    )
+    trainer.train()
+    ```
+    """
+
+    def on_optimizer_step(
+        self,
+        args: TrainingArguments,
+        state: TrainerState,
+        control: TrainerControl,
+        **kwargs,
+    ):
+        """Called after optimizer.step() – delegates to model.update_and_allocate()."""
+        model = kwargs.get("model")
+        if model is not None:
+            # Resolve to the AdamssModel (works for both PeftModel and raw base_model)
+            base_model = getattr(model, "base_model", model)
+            if hasattr(base_model, "update_and_allocate"):
+                base_model.update_and_allocate(state.global_step)
+
+        return super().on_optimizer_step(args=args, state=state, control=control)
diff --git a/src/peft/tuners/adamss/config.py b/src/peft/tuners/adamss/config.py
new file mode 100644
index 0000000..7a998fe
--- /dev/null
+++ b/src/peft/tuners/adamss/config.py
@@ -0,0 +1,349 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal, Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class AdamssConfig(PeftConfig):
+    """
+    Configuration class for Adamss (Adaptive Multi-Subspaces) method.
+
+    AdaMSS is a parameter-efficient fine-tuning method that decomposes weight matrices using SVD and clusters the
+    decomposed space into multiple trainable subspaces. It learns low-rank updates within these subspaces while keeping
+    the original weights frozen.
+
+    Args:
+        r (`int`):
+            Total rank for SVD decomposition (denoted as R in the paper). This determines how many singular vectors are
+            used to represent the weight matrix before clustering. Higher values capture more information from the
+            original weights but require more computation and memory. Lower values provide stronger regularization.
+            Typical values range from 50 to 500. Default is 100.
+
+        num_subspaces (`int`):
+            Number of subspaces (K) to cluster the SVD-decomposed space into. Each subspace learns independent low-rank
+            updates. Increasing this value allows finer-grained adaptation but increases the number of trainable
+            parameters proportionally. When using ASA (Adaptive Subspace Allocation), this determines the initial
+            number of subspaces before pruning. Typical values range from 3 to 10. Default is 5.
+
+        subspace_rank (`int`):
+            The rank (r_i) for each trainable subspace. This controls the capacity of each subspace to learn
+            adaptations. Higher values increase expressiveness but also increase trainable parameters. Total trainable
+            parameters scale as O(num_subspaces * subspace_rank * (in_dim + out_dim) / num_subspaces). For most tasks,
+            values of 1-4 work well. Default is 1.
+
+        target_modules (`Optional[Union[list[str], str]]`):
+            The names of the modules to apply AdaMSS to. If specified, only these modules will be adapted. Can be a
+            list of exact module names or a regex expression. For example, `['q_proj', 'v_proj']` for attention layers,
+            or `'.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'` for regex matching.
+
+        modules_to_save (`Optional[list[str]]`):
+            List of modules apart from AdaMSS layers to be set as trainable and saved in the final checkpoint. These
+            modules will be fully fine-tuned (not just low-rank). Required for randomly initialized heads like
+            `classifier` or `score` in classification tasks.
+
+        init_weights (`Literal["orthogonal"]`):
+            Initialization method for AdaMSS trainable weights. Currently only "orthogonal" is supported, which uses
+            orthogonal initialization for the B matrices (output projection). The A matrices are initialized to zero to
+            ensure the model starts from the pretrained weights. Set to None to skip initialization when loading from a
+            checkpoint. Default is "orthogonal".
+
+        layers_to_transform (`Optional[Union[list[int], int]]`):
+            Specific layer indices to apply AdaMSS to. If specified, only these layers will be adapted, useful for
+            experimenting with which layers benefit most from adaptation. Can be a single integer or a list of
+            integers.
+
+        layers_pattern (`Optional[Union[list[str], str]]`):
+            Pattern to match layer names when `layers_to_transform` is specified. Used to extract layer indices from
+            module names that don't follow the common pattern.
+
+        use_asa (`bool`):
+            Whether to enable Adaptive Subspace Allocation (ASA). When enabled, ASA dynamically prunes less important
+            subspaces during training based on gradient information, reducing the effective number of parameters while
+            maintaining performance. Requires integration with a training callback. Default is False.
+
+        asa_target_subspaces (`int`):
+            Target total number of active subspaces across all layers when ASA is enabled. ASA will progressively prune
+            subspaces until this target is reached. Lower values result in more aggressive pruning and fewer trainable
+            parameters. Should be less than `num_subspaces * num_target_modules`. Typical values range from 20 to 100
+            depending on model size. Default is 50.
+
+        init_warmup (`int`):
+            Number of training steps to wait before starting ASA pruning. During warmup, all subspaces remain active to
+            allow importance scores to stabilize. Higher values give more time for accurate importance estimation but
+            delay pruning. Typical values range from 50 to 200. Default is 50.
+
+        final_warmup (`int`):
+            Training step at which ASA completes pruning and reaches `asa_target_subspaces` active subspaces. The
+            pruning is distributed between `init_warmup` and `final_warmup`. Should be set based on total training
+            steps; typically 1/3 to 1/2 of total training steps. Default is 1000.
+
+        mask_interval (`int`):
+            Number of training steps between ASA mask updates. Lower values allow more frequent adaptation but increase
+            overhead. Higher values provide more stable importance estimates between updates. Typical values range from
+            50 to 200. Default is 100.
+
+        asa_importance_beta (`float`):
+            Exponential moving average (EMA) coefficient for smoothing subspace importance scores. Higher values
+            (closer to 1.0) give more weight to historical importance, providing stability. Lower values make
+            importance more responsive to recent gradients. Typical values range from 0.8 to 0.95. Default is 0.85.
+
+        asa_uncertainty_beta (`float`):
+            EMA coefficient for smoothing importance uncertainty estimates. Controls how quickly uncertainty adapts to
+            gradient variance. Similar to asa_importance_beta, higher values provide more stable estimates. Typical
+            values range from 0.8 to 0.95. Default is 0.85.
+
+        asa_schedule_exponent (`float`):
+            Schedule exponent controlling the decay rate from total subspaces to `asa_target_subspaces` during ASA
+            warmup. Higher values result in faster initial pruning (more aggressive early reduction), while lower
+            values provide a more gradual, linear-like decay. The formula is: current_active_subspaces =
+            asa_target_subspaces + (asa_total_subspaces - asa_target_subspaces) * (progress ** exponent). Typical
+            values range from 1.0 (linear) to 5.0 (aggressive). Default is 3.0.
+
+        use_dynamic_rank (`bool`):
+            Whether to dynamically determine subspace ranks based on singular value magnitudes. When True, each
+            subspace's rank is determined by counting singular values above a threshold, allowing different subspaces
+            to have different effective ranks. When False, all subspaces use the fixed `subspace_rank`. Default is
+            False.
+
+        svd_threshold (`float`):
+            Threshold ratio for dynamic rank selection, only used when `use_dynamic_rank=True`. A singular value is
+            considered significant if it exceeds `threshold * max_singular_value`. Higher values result in lower
+            effective ranks (more aggressive truncation). Typical values range from 0.05 to 0.2. Default is 0.1 (10% of
+            max).
+    """
+
+    r: int = field(
+        default=100,
+        metadata={
+            "help": (
+                "Total rank for SVD decomposition (R in the paper). Higher values capture more "
+                "information but require more computation. The actual rank is clamped to "
+                "min(r, in_features, out_features). Typical values: 50-500. Default: 100."
+            )
+        },
+    )
+    num_subspaces: int = field(
+        default=5,
+        metadata={
+            "help": (
+                "Number of subspaces (K) to cluster the SVD space into. Each subspace learns "
+                "independent low-rank updates. Increasing this allows finer-grained adaptation "
+                "but increases trainable parameters. Typical values: 3-10. Default: 5."
+            )
+        },
+    )
+    subspace_rank: int = field(
+        default=1,
+        metadata={
+            "help": (
+                "Rank (r_i) for each trainable subspace. Higher values increase expressiveness "
+                "but also increase parameters. For most tasks, values of 1-4 work well. Default: 1."
+            )
+        },
+    )
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of module names or regex expression of the module names to replace with AdaMSS. "
+                "For example, ['q_proj', 'v_proj'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'. "
+                "For Vision Transformers, typically ['query', 'value']."
+            )
+        },
+    )
+    init_weights: Optional[Literal["orthogonal"]] = field(
+        default="orthogonal",
+        metadata={
+            "help": (
+                "Initialization method for AdaMSS trainable weights. Currently only 'orthogonal' "
+                "is supported, which uses orthogonal initialization for B matrices. A matrices "
+                "are initialized to zero to start from pretrained weights. Set to None to skip "
+                "initialization when loading from a checkpoint. Default: 'orthogonal'."
+            )
+        },
+    )
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of modules apart from AdaMSS layers to be set as trainable and saved in the final checkpoint. "
+                "For example, in Sequence Classification or Token Classification tasks, "
+                "the final layer `classifier/score` are randomly initialized and as such need to be trainable and saved."
+            )
+        },
+    )
+    layers_to_transform: Optional[Union[list[int], int]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "Specific layer indices to apply AdaMSS to. If specified, only these layers will "
+                "be adapted, useful for experimenting with which layers benefit most. Can be a "
+                "single integer or a list of integers. Default: None (adapt all matching layers)."
+            )
+        },
+    )
+    layers_pattern: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "Pattern to match layer names when `layers_to_transform` is specified. Used to "
+                "extract layer indices from module names that don't follow common patterns."
+            )
+        },
+    )
+    # ASA (Adaptive Subspace Allocation) parameters
+    use_asa: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Whether to enable Adaptive Subspace Allocation (ASA). When enabled, ASA dynamically "
+                "prunes less important subspaces during training based on gradient information, "
+                "reducing parameters while maintaining performance. Requires a training callback. "
+                "Default: False."
+            )
+        },
+    )
+    asa_target_subspaces: int = field(
+        default=50,
+        metadata={
+            "help": (
+                "Target total number of active subspaces across all layers when ASA is enabled. "
+                "ASA progressively prunes subspaces until this target is reached. Lower values "
+                "result in more aggressive pruning. Typical values: 20-100. Default: 50."
+            )
+        },
+    )
+    init_warmup: int = field(
+        default=50,
+        metadata={
+            "help": (
+                "Training steps to wait before starting ASA pruning. During warmup, all subspaces "
+                "remain active to allow importance scores to stabilize. Higher values give more "
+                "time for accurate estimation. Typical values: 50-200. Default: 50."
+            )
+        },
+    )
+    final_warmup: int = field(
+        default=1000,
+        metadata={
+            "help": (
+                "Training step at which ASA completes pruning and reaches asa_target_subspaces. "
+                "Should be set based on total training steps; typically 1/3 to 1/2 of total steps. "
+                "Default: 1000."
+            )
+        },
+    )
+    mask_interval: int = field(
+        default=100,
+        metadata={
+            "help": (
+                "Training steps between ASA mask updates. Lower values allow more frequent "
+                "adaptation but increase overhead. Higher values provide more stable estimates. "
+                "Typical values: 50-200. Default: 100."
+            )
+        },
+    )
+    asa_importance_beta: float = field(
+        default=0.85,
+        metadata={
+            "help": (
+                "EMA coefficient for smoothing subspace importance scores during ASA. Higher "
+                "values (closer to 1.0) give more weight to historical importance, providing "
+                "stability. Lower values make importance more responsive to recent gradients. "
+                "Typical values: 0.8-0.95. Default: 0.85."
+            )
+        },
+    )
+    asa_uncertainty_beta: float = field(
+        default=0.85,
+        metadata={
+            "help": (
+                "EMA coefficient for smoothing importance uncertainty estimates during ASA. "
+                "Controls how quickly uncertainty adapts to gradient variance. Higher values "
+                "provide more stable estimates. Typical values: 0.8-0.95. Default: 0.85."
+            )
+        },
+    )
+    asa_schedule_exponent: float = field(
+        default=3.0,
+        metadata={
+            "help": (
+                "Schedule exponent controlling the decay rate from total subspaces to "
+                "asa_target_subspaces. Higher values result in faster initial pruning (aggressive "
+                "early reduction), lower values provide gradual linear-like decay. Formula: "
+                "current_active_subspaces = asa_target_subspaces + (total - target) * (progress ** exponent). "
+                "Typical values: 1.0 (linear) to 5.0 (aggressive). Default: 3.0."
+            )
+        },
+    )
+    # Dynamic rank selection parameters
+    use_dynamic_rank: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Whether to dynamically determine subspace ranks based on singular value magnitudes. "
+                "When True, each subspace's rank is determined by counting singular values above "
+                "a threshold, allowing different subspaces to have different effective ranks. "
+                "When False (default), all subspaces use the fixed subspace_rank. Default: False."
+            )
+        },
+    )
+    svd_threshold: float = field(
+        default=0.1,
+        metadata={
+            "help": (
+                "Threshold ratio for dynamic rank selection (only used when use_dynamic_rank=True). "
+                "A singular value is significant if it exceeds threshold * max_singular_value. "
+                "Higher values result in lower effective ranks (more aggressive truncation). "
+                "Typical values: 0.05-0.2. Default: 0.1 (10% of max)."
+            )
+        },
+    )
+    random_seed: int = field(
+        default=0,
+        metadata={
+            "help": (
+                "Seed used to deterministically create and rebuild the adapter weights, so that a saved adapter "
+                "reproduces its outputs after loading. Default: 0."
+            )
+        },
+    )
+
+    def __post_init__(self):
+        self.peft_type = PeftType.ADAMSS
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        super().__post_init__()
+
+        # Normalize init_weights: convert False to None for backward compatibility
+        if self.init_weights is False:
+            self.init_weights = None
+
+        # Validate initialization method
+        if self.init_weights not in ["orthogonal", None]:
+            raise ValueError(f"init_weights must be 'orthogonal' or None, got {self.init_weights}")
+
+        # Early check for scikit-learn availability
+        try:
+            import sklearn  # noqa: F401
+        except ImportError:
+            raise ImportError("scikit-learn is required for AdaMSS. Please install it with: pip install scikit-learn")
diff --git a/src/peft/tuners/adamss/layer.py b/src/peft/tuners/adamss/layer.py
new file mode 100644
index 0000000..a5263ce
--- /dev/null
+++ b/src/peft/tuners/adamss/layer.py
@@ -0,0 +1,669 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+import warnings
+from typing import Optional
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from peft.tuners._buffer_dict import BufferDict
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+
+from .config import AdamssConfig
+from .utils import clustering_Z, get_trainable_subspaces, seg_locations, slice_pca
+
+
+class AdamssLayer(BaseTunerLayer):
+    """
+    Base Adamss layer that stores adapter-specific information.
+    """
+
+    # All names of layers that may contain adapter weights (trainable or frozen)
+    # Use ModuleDict for proper state_dict key format that PEFT's save/load can handle
+    # Only include trainable parameter containers here (not buffers)
+    # adamss_newB is a buffer (frozen), not a trainable parameter
+    adapter_layer_names = ("adamss_A", "adamss_B")
+    # other_param_names specifies additional non-tensor metadata
+    other_param_names = (
+        "num_subspaces",
+        "train_subspace_index",
+        "seg_result",
+        "scatter_index",
+        "exp_avg_ipt_A",
+        "exp_avg_ipt_B",
+        "exp_avg_unc_A",
+        "exp_avg_unc_B",
+        "adamss_newB",
+    )
+
+    def __init__(self, base_layer: nn.Module, **kwargs) -> None:
+        self.base_layer = base_layer
+        # Adapter-specific attributes
+        # Use ModuleDict containing ParameterList for proper state_dict keys (e.g., adamss_A.default.0)
+        self.adamss_A = nn.ModuleDict({})  # Will contain ParameterList per adapter
+        self.adamss_B = nn.ModuleDict({})  # Will contain ParameterList per adapter
+        # Use BufferDict for frozen projection matrix (keys like adamss_newB.default)
+        self.adamss_newB = BufferDict(persistent=True)
+        self.num_subspaces = {}
+        self.train_subspace_index = {}
+        self.seg_result = {}
+        self.scatter_index = {}
+        # ASA importance tracking (per-adapter lists indexed by subspace)
+        self.exp_avg_ipt_A = {}
+        self.exp_avg_ipt_B = {}
+        self.exp_avg_unc_A = {}
+        self.exp_avg_unc_B = {}
+        self._disable_adapters = False
+        self.merged_adapters = []
+
+    def reset_importance(self, adapter_name: str) -> None:
+        """
+        Clear stored importance stats for an adapter.
+
+        Called after each masking interval to restart EMA accumulation for the next importance scoring window. Without
+        the reset the scores from early training steps would dominate later masking decisions.
+        """
+        if adapter_name in self.exp_avg_ipt_A:
+            n = len(self.exp_avg_ipt_A[adapter_name])
+            self.exp_avg_ipt_A[adapter_name] = [None] * n
+            self.exp_avg_ipt_B[adapter_name] = [None] * n
+            self.exp_avg_unc_A[adapter_name] = [None] * n
+            self.exp_avg_unc_B[adapter_name] = [None] * n
+
+    def update_importance(
+        self, adapter_name: str, importance_beta: float = 0.85, uncertainty_beta: float = 0.85
+    ) -> None:
+        """
+        Update importance scores using current gradients.
+
+        Called by [`AdamssModel.update_and_allocate`] (which is in turn called by [`AdamssAsaCallback`] when using
+        HuggingFace `Trainer`).
+
+        Args:
+            adapter_name: Name of the adapter to update importance for.
+            importance_beta: EMA coefficient for importance averaging (0.8-0.95 typical).
+            uncertainty_beta: EMA coefficient for uncertainty averaging (0.8-0.95 typical).
+        """
+        if adapter_name not in self.exp_avg_ipt_A:
+            return
+        if adapter_name not in self.adamss_A:
+            return
+
+        param_list_A = self.adamss_A[adapter_name]
+        param_list_B = self.adamss_B[adapter_name]
+
+        ipt_A = self.exp_avg_ipt_A[adapter_name]
+        ipt_B = self.exp_avg_ipt_B[adapter_name]
+        unc_A = self.exp_avg_unc_A[adapter_name]
+        unc_B = self.exp_avg_unc_B[adapter_name]
+
+        for i in range(self.num_subspaces[adapter_name]):
+            for param_list, ipt_list, unc_list in [
+                (param_list_A, ipt_A, unc_A),
+                (param_list_B, ipt_B, unc_B),
+            ]:
+                param = param_list[i]
+                if param.grad is not None:
+                    if ipt_list[i] is None:
+                        ipt_list[i] = torch.zeros_like(param, requires_grad=False)
+                        unc_list[i] = torch.zeros_like(param, requires_grad=False)
+
+                    # Calculate importance: |w * g|
+                    ipt = (param * param.grad).abs().detach()
+
+                    # Update uncertainty BEFORE updating importance (matches adamss_pkg)
+                    diff = (ipt - ipt_list[i]).abs()
+                    unc_list[i].mul_(uncertainty_beta).add_(diff, alpha=1 - uncertainty_beta)
+
+                    # Then update importance
+                    ipt_list[i].mul_(importance_beta).add_(ipt, alpha=1 - importance_beta)
+
+    def update_layer(
+        self,
+        adapter_name: str,
+        r: int,
+        config: AdamssConfig,
+        **kwargs,
+    ) -> None:
+        """
+        Update layer with Adamss adapter.
+
+        This method initializes the Adamss decomposition for the weight matrix using SVD, clustering, and QR
+        initialization.
+        """
+        num_subspaces = config.num_subspaces
+        subspace_rank = config.subspace_rank
+        init_weights = config.init_weights
+        use_asa = config.use_asa
+        inference_mode = config.inference_mode
+        use_dynamic_rank = config.use_dynamic_rank
+        svd_threshold = config.svd_threshold
+
+        # Get the base weight info
+        weight = self.get_base_layer().weight
+        bias = self.get_base_layer().bias
+        device = weight.device
+        dtype = weight.dtype
+        _, in_features = weight.shape
+
+        # Adjust in_features for bias column
+        if bias is not None:
+            in_features += 1
+
+        # Prepare weight tensor (add bias as extra column if present)
+        if bias is not None:
+            weight_with_bias = torch.cat((weight, bias.unsqueeze(1)), dim=1)
+        else:
+            weight_with_bias = weight
+
+        # Reshape to 4D tensor for slice_pca: (1, 1, out_features, in_features)
+        weight_tensor = weight_with_bias.unsqueeze(0).unsqueeze(0).to(torch.float32).to(device)
+
+        # Perform SVD decomposition with diagnostics in case of failure
+        try:
+            res = slice_pca(weight_tensor, r, device, torch.float32, random_seed=config.random_seed)
+        except Exception as e:
+            raise RuntimeError(
+                f"slice_pca raised an exception for layer {adapter_name} (shape={tuple(weight_tensor.shape)}, dtype={weight_tensor.dtype}, device={device}): {e}"
+            ) from e
+
+        VVT, UU = res
+
+        # Cluster the column space
+        cluster_idx, effective_num_subspaces = clustering_Z(UU[0, 0, :, :], num_subspaces, 10)
+
+        # Get segment locations
+        seg_result = seg_locations(cluster_idx)
+
+        # Get trainable subspace indices
+        train_subspace_index = get_trainable_subspaces(effective_num_subspaces)
+
+        # Store metadata
+        self.num_subspaces[adapter_name] = effective_num_subspaces
+        self.train_subspace_index[adapter_name] = train_subspace_index
+        self.seg_result[adapter_name] = seg_result
+
+        # Store projection matrix in BufferDict (frozen, device-aware)
+        self.adamss_newB[adapter_name] = VVT[0, 0, :, :].detach().to(dtype)
+
+        # Use user-specified subspace_rank
+        rank_per_subspace = subspace_rank
+
+        # Initialize trainable subspace parameters
+        # Collect parameters in lists, then create ParameterList for proper state_dict keys
+        A_params = []
+        B_params = []
+
+        for i in range(self.num_subspaces[adapter_name]):
+            subspace_idx = train_subspace_index[i]
+            seg_indices = seg_result[subspace_idx]
+
+            # Extract subspace data: use ALL r columns from SVD (not just r/K)
+            # This matches adamss_pkg where A matrices have shape (rank_i, r)
+            subspace_data = UU[0, 0, seg_indices, :r]
+            # subspace_data shape: (len(seg_indices), r)
+
+            # Determine actual rank based on configuration
+            if use_dynamic_rank:
+                # Compute Gram matrix Z = subspace_data @ subspace_data.T
+                Z_row = subspace_data @ subspace_data.T  # (len(seg_indices), len(seg_indices))
+
+                # Compute SVD to get row space decomposition
+                _U_row, S_row, _V_row = torch.svd_lowrank(Z_row, q=min(Z_row.shape), niter=2)
+
+                # Dynamic rank selection using SVD threshold
+                # Dynamically determine actual rank using configurable threshold
+                # Following adamss_pkg: num_ii_jj = min((S > threshold * S[0]).sum().item(), args.adamss_ri)
+                threshold_mask = S_row > svd_threshold * S_row[0]
+                actual_rank = min(threshold_mask.sum().item(), subspace_rank, len(S_row))
+
+                # Handle edge case: ensure at least rank 1
+                if actual_rank == 0:
+                    actual_rank = 1
+
+            else:
+                # Fixed rank: match adamss_pkg behavior exactly
+                # adamss_pkg uses: num_ii_jj = min(len(seg_result[indx]), args.adamss_ri)
+                actual_rank = min(len(seg_indices), subspace_rank)
+
+                # Ensure at least rank 1
+                if actual_rank == 0:
+                    actual_rank = 1
+
+            # Initialize A using QR decomposition to match adamss_pkg exactly
+            # adamss_pkg: Q, R = torch.linalg.qr((UU[seg_result[indx],:]).T @ A[i], mode='reduced')
+            # where A[i] is U from SVD of subspace Gram matrix
+
+            # First, compute Gram matrix for this subspace
+            Z_subspace = subspace_data @ subspace_data.T  # (len(seg_indices), len(seg_indices))
+
+            # SVD of Gram matrix to get A_intermediate
+            U_gram, _S_gram, _ = torch.svd_lowrank(Z_subspace, q=min(Z_subspace.shape[0], actual_rank), niter=2)
+            A_intermediate = U_gram[:, :actual_rank]  # (len(seg_indices), actual_rank)
+
+            # Now apply QR decomposition: (UU[seg_indices, :r]).T @ A_intermediate
+            # UU[0, 0, seg_indices, :r] is subspace_data with shape (len(seg_indices), r)
+            matrix_for_qr = subspace_data.T @ A_intermediate  # (r, actual_rank)
+            Q, _R = torch.linalg.qr(matrix_for_qr, mode="reduced")
+
+            # A_init is Q.T to match adamss_pkg
+            A_init = Q.T.contiguous()  # (actual_rank, r)
+
+            # Initialize B matrix
+            # When init_weights='orthogonal', use zeros for identity operation (standard training init)
+            # When init_weights=None/False, use random values so adapter produces non-zero effect
+            if init_weights == "orthogonal":
+                # Zero initialization - adapter produces identity at start
+                # Note: A parameters may not update in step 1 since ∂Loss/∂A ∝ B and B=0
+                # But after step 1, B becomes non-zero and A will get gradients in step 2+
+                B_init = torch.zeros(len(seg_indices), actual_rank, dtype=dtype, device=device)
+            else:
+                # Random initialization for testing - produces non-zero adapter output
+                B_init = torch.randn(len(seg_indices), actual_rank, dtype=dtype, device=device) * 0.01
+
+            # Collect A and B parameters
+            A_params.append(nn.Parameter(A_init.to(dtype)))
+            B_params.append(nn.Parameter(B_init.to(dtype)))
+
+        # Create ParameterLists and store in ModuleDict
+        # This creates state_dict keys like 'adamss_A.default.0', 'adamss_A.default.1', etc.
+        self.adamss_A[adapter_name] = nn.ParameterList(A_params)
+        self.adamss_B[adapter_name] = nn.ParameterList(B_params)
+
+        # Initialize ASA tracking if enabled
+        if use_asa:
+            n = effective_num_subspaces
+            self.exp_avg_ipt_A[adapter_name] = [None] * n
+            self.exp_avg_ipt_B[adapter_name] = [None] * n
+            self.exp_avg_unc_A[adapter_name] = [None] * n
+            self.exp_avg_unc_B[adapter_name] = [None] * n
+
+            # Hooks are not used; importance is updated explicitly via update_importance
+            # to match adamss_pkg behavior (using accumulated gradients).
+
+        # Compute scatter_index for forward pass
+        self.scatter_index[adapter_name] = torch.cat(
+            [
+                self.seg_result[adapter_name][self.train_subspace_index[adapter_name][i]]
+                for i in range(self.num_subspaces[adapter_name])
+            ],
+            dim=0,
+        ).long()
+
+        # Move adapter to device of base layer (important for low_cpu_mem_usage support)
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+
+        # Set requires_grad via parent class set_adapter (works with ParameterList)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+
+class Linear(nn.Module, AdamssLayer):
+    """
+    Adamss-adapted Linear layer.
+    """
+
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        adapter_name: str,
+        r: int,
+        config: AdamssConfig,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        AdamssLayer.__init__(self, base_layer, **kwargs)
+
+        # Set in_features and out_features from base layer (required for PEFT compatibility)
+        self.in_features = base_layer.in_features
+        self.out_features = base_layer.out_features
+
+        # Initialize the adapter
+        self.update_layer(
+            adapter_name,
+            r,
+            config=config,
+            **kwargs,
+        )
+        self._active_adapter = adapter_name
+        self.dtype = base_layer.weight.dtype
+
+    def _load_from_state_dict(
+        self, state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs
+    ):
+        """Handle shape mismatches that arise when loading checkpoints.
+
+        AdaMSS B parameter shapes depend on KMeans clustering of the weight matrix. KMeans uses a fixed `random_state`
+        so results should be deterministic, but this override acts as a safety net in case sklearn changes clustering
+        behaviour across versions. It detects shape mismatches and replaces placeholder parameters with
+        correctly-shaped tensors before the default `load_state_dict` logic runs.
+        """
+        for key, value in state_dict.items():
+            if not key.startswith(prefix):
+                continue
+            local_key = key[len(prefix) :]
+            parts = local_key.split(".")
+            try:
+                # Use get_submodule for the parent path
+                parent_path = ".".join(parts[:-1])
+                target = self.get_submodule(parent_path) if parent_path else self
+                last = parts[-1]
+                if last.isdigit():
+                    current = target[int(last)]
+                else:
+                    current = getattr(target, last)
+            except (AttributeError, IndexError, KeyError):
+                continue
+
+            if isinstance(current, (torch.Tensor, nn.Parameter)) and current.shape != value.shape:
+                new_param = nn.Parameter(torch.empty_like(value), requires_grad=current.requires_grad)
+                if last.isdigit():
+                    target[int(last)] = new_param
+                else:
+                    setattr(target, last, new_param)
+
+        super()._load_from_state_dict(
+            state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs
+        )
+
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        """
+        Forward pass with Adamss adaptation.
+        """
+        previous_dtype = x.dtype
+
+        if self._disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            # Adapter weights are already merged into base_layer.weight,
+            # so just call base_layer directly (no adapter delta needed).
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            # Cast input to layer dtype
+            x = x.to(self.dtype)
+
+            # Add bias column only when the base layer has a bias
+            # (update_layer concatenates bias into newB only when bias is not None)
+            if self.get_base_layer().bias is not None:
+                if x.dim() == 2:
+                    ones = torch.ones(x.shape[0], 1, device=x.device, dtype=self.dtype)
+                else:  # x.dim() == 3 or more
+                    ones = torch.ones(*x.shape[:-1], 1, device=x.device, dtype=self.dtype)
+                newx = torch.cat((x, ones), dim=-1)
+            else:
+                newx = x
+
+            # Base output from the frozen original weight
+            result = self.base_layer(x, *args, **kwargs)
+
+            # Iterate over all active adapters and add their deltas
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.adamss_A:
+                    continue
+
+                # Project input into low-rank space
+                projected = F.linear(newx, self.adamss_newB[active_adapter].to(self.dtype))  # (..., r)
+
+                # Apply A and B transformations per subspace
+                # TODO: if all subspaces have equal output dimensions, this loop could
+                # be replaced with a batched matmul/einsum for better performance.
+                # Currently B_i shapes vary per subspace (clustering-dependent), so we loop.
+                subspace_chunks = []
+                for i in range(self.num_subspaces[active_adapter]):
+                    A_i = self.adamss_A[active_adapter][i].to(self.dtype)  # (ri, r)
+                    B_i = self.adamss_B[active_adapter][i].to(self.dtype)  # (seg_len_i, ri)
+                    subspace_out = F.linear(projected, A_i)  # (..., ri)
+                    subspace_out = F.linear(subspace_out, B_i)  # (..., seg_len_i)
+                    subspace_chunks.append(subspace_out)
+
+                # Concatenate subspace results and scatter to output dimension order
+                adapter_delta = torch.cat(subspace_chunks, dim=-1)
+                scatter_index_tensor = self.scatter_index[active_adapter].to(adapter_delta.device)
+
+                if adapter_delta.dim() == 2:
+                    index = scatter_index_tensor.unsqueeze(0).expand(adapter_delta.shape[0], -1)
+                    adapter_delta = torch.zeros(
+                        adapter_delta.shape[0],
+                        result.shape[-1],
+                        device=adapter_delta.device,
+                        dtype=adapter_delta.dtype,
+                    ).scatter(1, index, adapter_delta)
+                else:
+                    index = scatter_index_tensor.unsqueeze(0).unsqueeze(0).expand(*adapter_delta.shape[:-1], -1)
+                    adapter_delta = torch.zeros(
+                        *adapter_delta.shape[:-1],
+                        result.shape[-1],
+                        device=adapter_delta.device,
+                        dtype=adapter_delta.dtype,
+                    ).scatter(-1, index, adapter_delta)
+
+                result = result + adapter_delta
+
+        # Cast back to original dtype
+        return result.to(previous_dtype)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights.
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. Defaults to `False`.
+            adapter_names (`list[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.adamss_A:
+                base_layer = self.get_base_layer()
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    # because of the copy operation.
+                    orig_weight = base_layer.weight.data.clone()
+                    orig_dtype = orig_weight.dtype
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    orig_weight += delta_weight.to(orig_dtype)
+
+                    if not torch.isfinite(orig_weight).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = orig_weight
+
+                    # Also update bias if present
+                    if base_layer.bias is not None:
+                        orig_bias = base_layer.bias.data.clone()
+                        delta_bias = self.get_delta_bias(active_adapter)
+                        orig_bias += delta_bias.to(orig_dtype)
+                        if not torch.isfinite(orig_bias).all():
+                            raise ValueError(
+                                f"NaNs detected in the merged bias. The adapter {active_adapter} seems to be broken"
+                            )
+                        base_layer.bias.data = orig_bias
+                else:
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    base_layer.weight.data += delta_weight
+
+                    # Also update bias if present
+                    if base_layer.bias is not None:
+                        delta_bias = self.get_delta_bias(active_adapter)
+                        base_layer.bias.data += delta_bias
+
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.adamss_A:
+                base_layer = self.get_base_layer()
+                weight = base_layer.weight
+                orig_dtype = weight.dtype
+                delta_weight = self.get_delta_weight(active_adapter)
+                weight.data -= delta_weight.to(orig_dtype)
+
+                # Also update bias if present
+                if base_layer.bias is not None:
+                    delta_bias = self.get_delta_bias(active_adapter)
+                    base_layer.bias.data -= delta_bias.to(orig_dtype)
+
+    def get_delta_weight(self, adapter_name: str) -> torch.Tensor:
+        """
+        Compute the delta weight for the given adapter.
+
+        For AdaMSS, the forward computes:
+            result = newx @ resW.T + scatter(newx @ newB.T @ A.T @ B.T)
+
+        Since resW = original_weight_with_bias, the delta is just the adapter path:
+            delta = scatter(B @ A @ newB)
+
+        We extract the weight portion (excluding bias column) as the delta to add to the base layer's weight.
+
+        Args:
+            adapter_name (str): The name of the adapter for which the delta weight should be computed.
+        """
+        device = self.get_base_layer().weight.device
+        dtype = self.get_base_layer().weight.dtype
+        base_weight = self.get_base_layer().weight
+
+        # Get buffers
+        newB = self.adamss_newB[adapter_name]  # Shape: (r, in_features + 1)
+
+        # Get parameter lists
+        param_list_A = self.adamss_A[adapter_name]
+        param_list_B = self.adamss_B[adapter_name]
+
+        # In case users wants to merge the adapter weights that are in
+        # (b)float16 while being on CPU, we need to cast the weights to float32
+        cast_to_fp32 = device.type == "cpu" and dtype in (torch.float16, torch.bfloat16)
+        compute_dtype = torch.float32 if cast_to_fp32 else dtype
+
+        newB = newB.to(device).to(compute_dtype)
+
+        # Compute the adapter contribution (scattered B @ A @ newB)
+        # delta_weight has shape (out_features, in_features + 1)
+        out_features = base_weight.shape[0]
+        in_features_plus_1 = newB.shape[1]
+
+        # Initialize delta weight for the adapter path only
+        delta_weight = torch.zeros(out_features, in_features_plus_1, device=device, dtype=compute_dtype)
+
+        # Compute the transformation for each subspace
+        # For subspace i: contribution = B_i @ A_i @ newB
+        # where A_i has shape (rank_i, r), B_i has shape (seg_len_i, rank_i)
+        chunks = []
+        for i in range(self.num_subspaces[adapter_name]):
+            A_i = param_list_A[i].to(device).to(compute_dtype)  # Shape: (rank_i, r)
+            B_i = param_list_B[i].to(device).to(compute_dtype)  # Shape: (seg_len_i, rank_i)
+
+            # B_i @ A_i @ newB gives shape (seg_len_i, in_features+1)
+            chunk = B_i @ A_i @ newB
+            chunks.append(chunk)
+
+        # Concatenate chunks and scatter to correct positions
+        if chunks:
+            combined = torch.cat(chunks, dim=0)  # Shape: (total_seg_len, in_features+1)
+            # Use scatter_index for assignment
+            scatter_idx = self.scatter_index[adapter_name].to(delta_weight.device)
+            delta_weight[scatter_idx] = combined
+
+        # Extract just the weight portion
+        if self.get_base_layer().bias is not None:
+            # delta_weight[:, :-1] is the weight delta (exclude bias column)
+            output_tensor = delta_weight[:, :-1]  # Shape: (out_features, in_features)
+        else:
+            # No bias column to strip
+            output_tensor = delta_weight  # Shape: (out_features, in_features)
+
+        if cast_to_fp32:
+            output_tensor = output_tensor.to(dtype=dtype)
+
+        return output_tensor
+
+    def get_delta_bias(self, adapter_name: str) -> torch.Tensor:
+        """
+        Compute the bias delta for the given adapter.
+
+        This is the last column of the adapter path contribution (B @ A @ newB).
+
+        Args:
+            adapter_name (str): The name of the adapter for which the bias delta should be computed.
+        """
+        device = self.get_base_layer().weight.device
+        dtype = self.get_base_layer().weight.dtype
+        base_weight = self.get_base_layer().weight
+
+        # Get buffers
+        newB = self.adamss_newB[adapter_name]  # Shape: (r, in_features + 1)
+
+        # Get parameter lists
+        param_list_A = self.adamss_A[adapter_name]
+        param_list_B = self.adamss_B[adapter_name]
+
+        cast_to_fp32 = device.type == "cpu" and dtype in (torch.float16, torch.bfloat16)
+        compute_dtype = torch.float32 if cast_to_fp32 else dtype
+
+        newB = newB.to(device).to(compute_dtype)
+
+        out_features = base_weight.shape[0]
+        in_features_plus_1 = newB.shape[1]
+
+        # Initialize delta weight for the adapter path only
+        delta_weight = torch.zeros(out_features, in_features_plus_1, device=device, dtype=compute_dtype)
+
+        # Compute the transformation for each subspace
+        chunks = []
+        for i in range(self.num_subspaces[adapter_name]):
+            A_i = param_list_A[i].to(device).to(compute_dtype)
+            B_i = param_list_B[i].to(device).to(compute_dtype)
+            chunk = B_i @ A_i @ newB
+            chunks.append(chunk)
+
+        if chunks:
+            combined = torch.cat(chunks, dim=0)
+            scatter_idx = self.scatter_index[adapter_name].to(delta_weight.device)
+            delta_weight[scatter_idx] = combined
+
+        # Extract the bias portion (last column)
+        if self.get_base_layer().bias is None:
+            # No bias — return zeros
+            output_tensor = torch.zeros(base_weight.shape[0], device=device, dtype=compute_dtype)
+        else:
+            output_tensor = delta_weight[:, -1]  # Shape: (out_features,)
+
+        if cast_to_fp32:
+            output_tensor = output_tensor.to(dtype=dtype)
+
+        return output_tensor
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "adamss." + rep
diff --git a/src/peft/tuners/adamss/model.py b/src/peft/tuners/adamss/model.py
new file mode 100644
index 0000000..ec9479c
--- /dev/null
+++ b/src/peft/tuners/adamss/model.py
@@ -0,0 +1,279 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+from typing import Optional
+
+import torch
+from torch import nn
+
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer, check_target_module_exists
+from peft.utils import (
+    TRANSFORMERS_MODELS_TO_ADAMSS_TARGET_MODULES_MAPPING,
+)
+
+from .config import AdamssConfig
+from .layer import AdamssLayer, Linear
+
+
+class AdamssModel(BaseTuner):
+    """
+    Creates Adamss (Adaptive Multi-Subspaces) model from a pretrained model.
+
+    The method decomposes weight matrices using SVD and clusters the decomposed space into multiple trainable subspaces
+    for parameter-efficient fine-tuning.
+
+    Args:
+        model (`torch.nn.Module`): The model to be adapted.
+        config (`AdamssConfig`): The configuration of the Adamss model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+
+    Returns:
+        `torch.nn.Module`: The Adamss model.
+
+    Example:
+        ```python
+        >>> from transformers import AutoModelForImageClassification
+        >>> from peft import AdamssConfig, get_peft_model
+
+        >>> config = AdamssConfig(
+        ...     r=500,
+        ...     num_subspaces=5,
+        ...     target_modules=["query", "value"],
+        ... )
+
+        >>> model = AutoModelForImageClassification.from_pretrained("google/vit-base-patch16-224")
+        >>> adamss_model = get_peft_model(model, config)
+        ```
+
+    **Attributes**:
+        - **model** ([`~torch.nn.Module`]) -- The model to be adapted.
+        - **peft_config** ([`AdamssConfig`]): The configuration of the Adamss model.
+    """
+
+    prefix: str = "adamss_"
+    tuner_layer_cls = AdamssLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_ADAMSS_TARGET_MODULES_MAPPING
+
+    def __init__(
+        self, model, config, adapter_name, low_cpu_mem_usage: bool = False, state_dict: Optional[dict] = None
+    ) -> None:
+        # Initialize ASA tracking before BaseTuner injects adapters so attribute exists.
+        self._asa_total_subspaces = {}
+        super().__init__(model, config, adapter_name, low_cpu_mem_usage=low_cpu_mem_usage, state_dict=state_dict)
+
+    @staticmethod
+    def _check_target_module_exists(adamss_config, key):
+        """Helper to check if target module matches the pattern."""
+        return check_target_module_exists(adamss_config, key)
+
+    def _create_and_replace(
+        self,
+        adamss_config: AdamssConfig,
+        adapter_name: str,
+        target: nn.Module,
+        target_name: str,
+        parent: nn.Module,
+        current_key: str,
+        **optional_kwargs,
+    ):
+        """
+        Create and replace target module with Adamss-adapted module.
+        """
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+
+        # Check if already an Adamss layer
+        if isinstance(target, AdamssLayer):
+            target.update_layer(
+                adapter_name,
+                adamss_config.r,
+                config=adamss_config,
+            )
+            # set_adapter is called inside update_layer, but we need to handle
+            # the case where adapter is not in active_adapters
+            if adapter_name not in self.active_adapters:
+                # Ensure the new adapter is frozen if not active
+                target.set_adapter(self.active_adapters, inference_mode=adamss_config.inference_mode)
+        else:
+            # Create new Adamss layer
+            new_module = self._create_new_module(adamss_config, adapter_name, target, **optional_kwargs)
+            self._record_asa_total_subspaces(adapter_name, adamss_config, new_module)
+            # requires_grad is handled inside _create_new_module via set_adapter
+            self._replace_module(parent, target_name, new_module, target)
+
+    def _record_asa_total_subspaces(self, adapter_name: str, adamss_config: AdamssConfig, module: AdamssLayer) -> None:
+        """Track total subspaces per adapter so the ASA schedule matches adamss_pkg."""
+        if not hasattr(module, "num_subspaces"):
+            return
+        layer_num_subspaces = module.num_subspaces.get(adapter_name, 0)
+        if layer_num_subspaces is None or layer_num_subspaces <= 0:
+            return
+        prev_total = self._asa_total_subspaces.get(adapter_name, 0)
+        self._asa_total_subspaces[adapter_name] = prev_total + layer_num_subspaces
+
+    def _create_new_module(
+        self,
+        adamss_config: AdamssConfig,
+        adapter_name: str,
+        target: nn.Module,
+        **kwargs,
+    ) -> nn.Module:
+        """
+        Create a new Adamss module based on the target module type.
+        """
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        if isinstance(target_base_layer, torch.nn.Linear):
+            new_module = Linear(
+                target,
+                adapter_name,
+                r=adamss_config.r,
+                config=adamss_config,
+                **kwargs,
+            )
+        else:
+            raise TypeError(
+                f"Target module {target} is not supported. Currently, only `torch.nn.Linear` is supported."
+            )
+
+        return new_module
+
+    def update_and_allocate(self, global_step: int) -> None:
+        """
+        Update importance scores and apply ASA masking (if enabled).
+
+        This method should be called in **every** training step after ``loss.backward()`` and before
+        ``optimizer.zero_grad()`` when ASA is enabled. Internally it:
+
+        1. Accumulates importance scores via EMA every step during the warmup period.
+        2. At mask intervals, applies global top-K masking and resets importance.
+
+        This is the single entry point for ASA – using the :class:`AdamssAsaCallback` with HuggingFace ``Trainer``
+        simply delegates to this method. For custom training loops, call this directly instead of the callback.
+
+        Args:
+            global_step (`int`): The current training step.
+
+        Example::
+
+            for step, batch in enumerate(dataloader):
+                loss = model(**batch).loss loss.backward() optimizer.step() model.base_model.update_and_allocate(step)
+                optimizer.zero_grad()
+        """
+        for adapter_name in self.active_adapters:
+            config = self.peft_config[adapter_name]
+            if not config.use_asa:
+                continue
+
+            within_warmup = config.init_warmup <= global_step <= config.final_warmup
+
+            # --- collect ASA layers once ---
+            asa_layers = [
+                m for m in self.model.modules() if isinstance(m, AdamssLayer) and adapter_name in m.exp_avg_ipt_A
+            ]
+            if not asa_layers:
+                continue
+
+            # Step 1: accumulate importance EVERY step during warmup
+            if within_warmup:
+                for module in asa_layers:
+                    module.update_importance(adapter_name, config.asa_importance_beta, config.asa_uncertainty_beta)
+
+            # Step 2: at mask intervals → schedule, global mask, then reset
+            is_mask_interval = global_step % config.mask_interval == 0
+            if within_warmup and is_mask_interval:
+                current_target = self._schedule_threshold(global_step, config)
+                if current_target is not None:
+                    self._global_mask_to_target(current_target, adapter_name, asa_layers)
+
+                # Reset importance AFTER masking for fresh accumulation
+                for module in asa_layers:
+                    module.reset_importance(adapter_name)
+
+    def _schedule_threshold(self, step: int, config) -> Optional[int]:
+        """Calculate current target subspaces based on warmup schedule."""
+        total = self._asa_total_subspaces.get(next(iter(self.active_adapters), "default"), 0)
+        if total == 0:
+            total = self._get_asa_total_subspaces()
+        if total == 0:
+            return None
+
+        if step < config.init_warmup:
+            return None
+        elif step <= config.final_warmup:
+            mul_coeff = 1.0 - (step - config.init_warmup) / (config.final_warmup - config.init_warmup)
+            mul_coeff = max(0.0, min(1.0, mul_coeff))
+            exponent = getattr(config, "asa_schedule_exponent", 3.0)
+            return int(config.asa_target_subspaces + (total - config.asa_target_subspaces) * (mul_coeff**exponent))
+        else:
+            return config.asa_target_subspaces
+
+    def _get_asa_total_subspaces(self) -> int:
+        """Get total number of subspaces from model (sum across all layers)."""
+        total = 0
+        for module in self.model.modules():
+            if isinstance(module, AdamssLayer) and module.num_subspaces:
+                total += next(iter(module.num_subspaces.values()))
+        return total
+
+    def _global_mask_to_target(self, target_subspaces: int, adapter_name: str, asa_layers: list) -> None:
+        """
+        Apply **global** top-K masking across all layers.
+
+        Collects importance scores from every subspace in every layer, ranks them globally, and keeps only the top
+        ``target_subspaces`` active.
+        """
+        # 1. Collect (module, subspace_idx, score) for every subspace
+        subspace_scores: list[tuple] = []
+        for module in asa_layers:
+            n_subspaces = module.num_subspaces.get(adapter_name, 0)
+            ipt_A = module.exp_avg_ipt_A[adapter_name]
+            ipt_B = module.exp_avg_ipt_B[adapter_name]
+            unc_A = module.exp_avg_unc_A[adapter_name]
+            unc_B = module.exp_avg_unc_B[adapter_name]
+
+            for i in range(n_subspaces):
+                if ipt_A[i] is None or ipt_B[i] is None:
+                    continue
+                score = (ipt_A[i] * unc_A[i]).mean() + (ipt_B[i] * unc_B[i]).mean()
+                subspace_scores.append((module, i, score))
+
+        if not subspace_scores:
+            return
+
+        # 2. Compute global threshold via kth-value
+        all_scores = torch.stack([s[2] for s in subspace_scores])
+        if target_subspaces >= len(subspace_scores):
+            threshold = float("-inf")
+        else:
+            threshold = -torch.kthvalue(-all_scores, target_subspaces)[0].item()
+
+        # 3. Apply masking
+        for module, idx, score in subspace_scores:
+            is_active = float(score) > threshold
+            param_A = module.adamss_A[adapter_name]
+            param_B = module.adamss_B[adapter_name]
+            if idx < len(param_A):
+                param_A[idx].requires_grad = is_active
+                if not is_active:
+                    param_A[idx].grad = None
+            if idx < len(param_B):
+                param_B[idx].requires_grad = is_active
+                if not is_active:
+                    param_B[idx].grad = None
diff --git a/src/peft/tuners/adamss/utils.py b/src/peft/tuners/adamss/utils.py
new file mode 100644
index 0000000..e8600cb
--- /dev/null
+++ b/src/peft/tuners/adamss/utils.py
@@ -0,0 +1,130 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+import torch
+
+
+def slice_pca(tensor, r, device, dtype=torch.float32, random_seed=0):
+    """
+    Perform slice-wise PCA (SVD) on 4D tensor.
+
+    Args:
+        tensor: 4D tensor of shape (B, C, H, W)
+        r: rank for low-rank approximation
+        device: computation device
+        dtype: data type
+        random_seed: seed for the random projection used by `torch.svd_lowrank`, so the decomposition is
+            deterministic and reproducible across save/load
+
+    Returns:
+        VVT: Right singular vectors (B, C, r, W) UU: Left singular vectors (B, C, H, r)
+    """
+    tensor = tensor.to(device)
+    B, C, H, W = tensor.shape
+
+    # Clamp r to the minimum dimension to avoid SVD errors
+    # SVD rank cannot exceed min(H, W)
+    effective_r = min(r, H, W)
+
+    UU = torch.zeros(B, C, H, effective_r, dtype=dtype, device=device)
+    VVT = torch.zeros(B, C, effective_r, W, dtype=dtype, device=device)
+
+    # torch.svd_lowrank draws a random projection internally, so its result (and hence the downstream
+    # clustering and scatter_index) depends on the RNG state. Seed a forked RNG with the configurable
+    # random_seed so the result is deterministic (torch.svd_lowrank does not accept a generator argument);
+    # fork_rng leaves the global RNG stream untouched.
+    fork_devices = [device] if torch.device(device).type == "cuda" else []
+    with torch.random.fork_rng(devices=fork_devices):
+        torch.manual_seed(random_seed)
+        for i in range(B):
+            for j in range(C):
+                U, _, V = torch.svd_lowrank(tensor[i, j, :, :], q=effective_r, niter=2, M=None)
+                UU[i, j, :, :] = U[:, 0:effective_r]
+                VVT[i, j, :, :] = V[:, 0:effective_r].T
+    # Return computed matrices (important: ensure callers receive VVT and UU)
+    return VVT, UU
+
+
+def clustering_Z(VT, num_subspaces, iternum):
+    """
+    Cluster the rows of VT into K subspaces using K-Means.
+
+    Args:
+        VT: Matrix to cluster (rows are clustered)
+        num_subspaces: Number of clusters (subspaces)
+        iternum: Maximum iterations for K-Means
+
+    Returns:
+        cluster_idx: Cluster assignments as a ``torch.LongTensor`` effective_num_subspaces: Actual number of subspaces
+        used (``int``)
+
+    Note:
+        This function requires scikit-learn to be installed. Install it with: pip install scikit-learn
+    """
+    # Local import with helpful error message
+    try:
+        from sklearn.cluster import KMeans
+    except ImportError:
+        raise ImportError(
+            "scikit-learn is required for AdaMSS initialization. Please install it with: pip install scikit-learn"
+        )
+
+    # Move to numpy for sklearn compatibility
+    # Note: We do NOT normalize row vectors here to match the original adamss_pkg behavior.
+    # Although normalization is generally recommended for cosine-similarity-like clustering,
+    # the reference implementation clusters raw singular vectors.
+    vt = VT.detach().cpu().numpy().astype("float32")
+
+    # Auto-clamp num_subspaces to available samples (output dimensions)
+    # Cannot cluster n samples into more than n clusters
+    effective_num_subspaces = min(num_subspaces, vt.shape[0])
+
+    kmeans = KMeans(
+        n_clusters=effective_num_subspaces, init="random", n_init=1, max_iter=iternum, random_state=123456789
+    )
+    idx = kmeans.fit_predict(vt)
+
+    return torch.from_numpy(idx).long(), effective_num_subspaces
+
+
+def seg_locations(index):
+    """
+    Segment indices into locations based on cluster assignments.
+
+    Args:
+        index: Cluster assignments as a ``torch.LongTensor``
+
+    Returns:
+        location: Dict mapping cluster id to ``torch.LongTensor`` of row indices.
+            Clusters are ordered by their smallest index so that KMeans label permutations do not affect downstream
+            ordering.
+    """
+    K = int(index.max().item()) + 1
+    location = {}
+    for i in range(K):
+        location[i] = torch.where(index == i)[0]
+    return location
+
+
+def get_trainable_subspaces(num_subspaces):
+    """
+    Get all trainable subspace indices.
+
+    Args:
+        num_subspaces: Number of subspaces
+
+    Returns:
+        List of trainable subspace indices (``list[int]``)
+    """
+    return list(range(num_subspaces))
diff --git a/src/peft/tuners/adaption_prompt/__init__.py b/src/peft/tuners/adaption_prompt/__init__.py
new file mode 100644
index 0000000..68882a2
--- /dev/null
+++ b/src/peft/tuners/adaption_prompt/__init__.py
@@ -0,0 +1,23 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+from peft.utils import register_peft_method
+
+from .config import AdaptionPromptConfig
+from .layer import AdaptedAttention
+from .model import AdaptionPromptModel
+
+
+__all__ = ["AdaptedAttention", "AdaptionPromptConfig", "AdaptionPromptModel"]
+
+register_peft_method(name="adaption_prompt", config_cls=AdaptionPromptConfig, model_cls=AdaptionPromptModel)
diff --git a/src/peft/tuners/adaption_prompt/config.py b/src/peft/tuners/adaption_prompt/config.py
new file mode 100644
index 0000000..4a9f780
--- /dev/null
+++ b/src/peft/tuners/adaption_prompt/config.py
@@ -0,0 +1,88 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from collections import namedtuple
+from dataclasses import dataclass, field
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+from .utils import gpt2_compute_query_states, llama_compute_query_states
+
+
+@dataclass
+class AdaptionPromptConfig(PeftConfig):
+    """Stores the configuration of an [`AdaptionPromptModel`]."""
+
+    target_modules: str = field(
+        default=None, metadata={"help": "Name of the attention submodules to insert adaption prompts into."}
+    )
+    adapter_len: int = field(default=None, metadata={"help": "Number of adapter tokens to insert"})
+    adapter_layers: int = field(default=None, metadata={"help": "Number of adapter layers (from the top)"})
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.ADAPTION_PROMPT
+
+    @property
+    def is_adaption_prompt(self) -> bool:
+        """Return True if this is an adaption prompt config."""
+        return True
+
+
+# Contains the config that is specific to a transformers model type.
+ModelTypeConfig = namedtuple(
+    "ModelTypeConfig", ["compute_query_states", "target_modules", "k_proj_layer", "v_proj_layer", "o_proj_layer"]
+)
+
+# Mapping of transformers model types to their specific configuration.
+TRANSFORMERS_MODEL_CONFIG = {
+    "llama": ModelTypeConfig(
+        compute_query_states=llama_compute_query_states,
+        target_modules="self_attn",
+        k_proj_layer="k_proj",
+        v_proj_layer="v_proj",
+        o_proj_layer="o_proj",
+    ),
+    "mistral": ModelTypeConfig(  # same as llama,
+        compute_query_states=llama_compute_query_states,
+        target_modules="self_attn",
+        k_proj_layer="k_proj",
+        v_proj_layer="v_proj",
+        o_proj_layer="o_proj",
+    ),
+    "gpt2": ModelTypeConfig(  # piggybacking of off the prior definitions, GPTs attention calculation is different
+        compute_query_states=gpt2_compute_query_states,
+        target_modules="attn",
+        k_proj_layer="c_attn",
+        v_proj_layer=None,
+        o_proj_layer=None,
+    ),
+}
+
+
+def prepare_config(
+    peft_config: AdaptionPromptConfig,
+    model,
+) -> AdaptionPromptConfig:
+    """Prepare the config based on the llama model type."""
+    if model.config.model_type not in TRANSFORMERS_MODEL_CONFIG:
+        raise ValueError(f"Unsupported model type for adaption prompt: '{model.config.model_type}'.")
+
+    model_config = TRANSFORMERS_MODEL_CONFIG[model.config.model_type]
+
+    if peft_config.target_modules is None:
+        peft_config.target_modules = model_config.target_modules
+
+    return peft_config
diff --git a/src/peft/tuners/adaption_prompt/layer.py b/src/peft/tuners/adaption_prompt/layer.py
new file mode 100644
index 0000000..f64067a
--- /dev/null
+++ b/src/peft/tuners/adaption_prompt/layer.py
@@ -0,0 +1,223 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import math
+from typing import Optional, Union
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from .config import TRANSFORMERS_MODEL_CONFIG
+
+
+class _BaseAdaptedAttention(nn.Module):
+    """Base module, which defines adaption prompts for multiple model types."""
+
+    def __init__(self, model_type: str, adapter_len: int, model, target_dtype=torch.float32):
+        """
+        Initialize object.
+
+        Args:
+            model_type: The transformer model type. This is used to retrieve the right method to
+                compute query states.
+            adapter_len: The length of the adaption prompt to insert.
+            model: The original transformer attention module that is being wrapped.
+        """
+        if isinstance(model, _BaseAdaptedAttention):
+            raise TypeError("Unable to stack multiple adaption prompts")
+        super().__init__()
+        self.model_type = model_type
+        self.model = model
+        self.adapter_len = adapter_len
+        # Assume all parameters of the attention model we are wrapping are on the same device.
+
+        device = next(model.parameters()).device
+        # Don't think this was specified in the paper, but we follow the official repo which used an Embedding
+        # which initializes the tokens with standard normal values.
+        # https://github.com/ZrrSkywalker/LLaMA-Adapter/blob/41c3546fe1997ab8a65809dc8d8f9252b19d9faf/llama/model.py#L234
+        # (bsz, adapter_len, hidden_size)
+
+        hidden_size = self.model.config.hidden_size
+        self.num_heads = self.model.config.num_attention_heads
+
+        self.adaption_prompt = nn.Parameter(
+            torch.empty(1, adapter_len, hidden_size, device=device, dtype=target_dtype).normal_()
+        )
+        # Initialize the gate to 0 as this is "zero-init".
+        self.adaption_gate = nn.Parameter(torch.zeros(1, device=device, dtype=target_dtype))
+
+
+class AdaptedAttentionGPT(_BaseAdaptedAttention):
+    """This module wraps a GPT2Attention module and injects adaption prompts"""
+
+    def __init__(self, model_type, adapter_len, model):
+        target_dtype = (
+            model.c_proj.weight.dtype if model.c_proj.weight.dtype not in [torch.int8, torch.uint8] else torch.float32
+        )
+        super().__init__(model_type, adapter_len, model, target_dtype=target_dtype)
+
+    def forward(
+        self,
+        hidden_states: Optional[tuple[torch.FloatTensor]],
+        layer_past: Optional[tuple[torch.Tensor]] = None,
+        attention_mask: Optional[torch.FloatTensor] = None,
+        head_mask: Optional[torch.FloatTensor] = None,
+        encoder_hidden_states: Optional[torch.Tensor] = None,
+        encoder_attention_mask: Optional[torch.FloatTensor] = None,
+        use_cache: Optional[bool] = False,
+        output_attentions: Optional[bool] = False,
+        **kwargs,
+    ) -> tuple[Union[torch.Tensor, tuple[torch.Tensor]], ...]:
+        attn_outputs = self.model(
+            hidden_states=hidden_states,
+            attention_mask=attention_mask,
+            head_mask=head_mask,
+            encoder_hidden_states=encoder_hidden_states,
+            encoder_attention_mask=encoder_attention_mask,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            **kwargs,
+        )
+        """
+        Forward pass for the adapter which wraps the GPT2Attention module
+        """
+
+        attn_output = attn_outputs[0]
+        add_outputs = attn_outputs[1:]
+
+        c_attn_layer = TRANSFORMERS_MODEL_CONFIG[self.model_type].k_proj_layer
+
+        bsz = attn_output.shape[0]
+        q_len = attn_output.shape[1]
+        embed_dim = attn_output.shape[2]
+
+        _, key, value = getattr(self.model, c_attn_layer)(self.adaption_prompt).split(embed_dim, dim=2)
+
+        adapter_k = (
+            key.view(1, self.adapter_len, self.num_heads, self.model.head_dim).repeat(bsz, 1, 1, 1).transpose(1, 2)
+        )
+        adapter_v = (
+            value.view(1, self.adapter_len, self.num_heads, self.model.head_dim).repeat(bsz, 1, 1, 1).transpose(1, 2)
+        )
+        # recompute query state since it is not returned by GPT2 forward
+        compute_query_states = TRANSFORMERS_MODEL_CONFIG[self.model_type].compute_query_states
+        query_states = compute_query_states(
+            self.model, hidden_states=hidden_states, encoder_hidden_states=encoder_hidden_states
+        )
+
+        previous_dtype = query_states.dtype
+
+        scores = torch.matmul(query_states, adapter_k.transpose(2, 3).to(previous_dtype)) / math.sqrt(
+            self.model.head_dim
+        )
+        # Upcast attention to fp32
+        # (bsz, num_heads, q_len, adapter_len)
+        scores = self.adaption_gate * F.softmax(scores, dim=-1, dtype=torch.float32).to(previous_dtype)
+        # (bsz, q_len, num_heads * head_dim)
+        adapter_output = torch.matmul(scores, adapter_v).transpose(1, 2).reshape(bsz, q_len, -1)
+
+        # Add adaption prompt output to original output.
+        hidden_state = attn_output + adapter_output
+
+        # Restore original dtype.
+        hidden_state = hidden_state.to(previous_dtype)
+
+        # add additional attention outputs (attention and cross attention)
+        output = (hidden_state,) + add_outputs
+        return output
+
+
+class AdaptedAttention(_BaseAdaptedAttention):
+    """This module wraps a LLamaAttention module and injects adaption prompts."""
+
+    def __init__(self, model_type, adapter_len, model):
+        target_dtype = (
+            model.q_proj.weight.dtype if model.q_proj.weight.dtype not in [torch.int8, torch.uint8] else torch.float32
+        )
+        super().__init__(model_type, adapter_len, model, target_dtype=target_dtype)
+
+    def forward(self, **kwargs):
+        """
+        Forward pass for the adapter which wraps the original LlamaAttention module.
+
+        "Official" paper implementation:
+        https://github.com/ZrrSkywalker/LLaMA-Adapter/blob/41c3546fe1997ab8a65809dc8d8f9252b19d9faf/llama/model.py#L141
+
+        Args:
+            kwargs: See the original LlamaAttention module.
+        """
+        if kwargs.get("output_attention", False):
+            raise NotImplementedError("output_attention is not currently supported.")
+
+        output, *_ = self.model(**kwargs)
+        bsz = output.shape[0]
+        q_len = output.shape[1]
+        embed_dim = output.shape[2]
+        k_proj_layer = TRANSFORMERS_MODEL_CONFIG[self.model_type].k_proj_layer
+        v_proj_layer = TRANSFORMERS_MODEL_CONFIG[self.model_type].v_proj_layer
+        o_proj_layer = TRANSFORMERS_MODEL_CONFIG[self.model_type].o_proj_layer
+        factor = (
+            self.model.k_proj.in_features // self.model.k_proj.out_features
+        )  # Mistral has different input and output dimension for k_proj and v_proj layers
+
+        if k_proj_layer == v_proj_layer:
+            _, key, value = getattr(self.model, k_proj_layer)(self.adaption_prompt).split(embed_dim, dim=2)
+        else:
+            key = getattr(self.model, k_proj_layer)(self.adaption_prompt)
+            value = getattr(self.model, v_proj_layer)(self.adaption_prompt)
+
+        num_heads = self.model.config.num_attention_heads
+        # (bsz, num_key_value_heads, adapter_len, head_dim)
+        adapter_k = (
+            key.view(1, self.adapter_len, (num_heads // factor), self.model.head_dim)
+            .repeat(bsz, 1, 1, 1)
+            .transpose(1, 2)
+        )
+        adapter_v = (
+            value.view(1, self.adapter_len, (num_heads // factor), self.model.head_dim)
+            .repeat(bsz, 1, 1, 1)
+            .transpose(1, 2)
+        )
+        # Below is taken from https://github.com/huggingface/transformers/blob/e547458c43dfdbbb8f6a7757237e234c44e20a8f/src/transformers/models/mistral/modeling_mistral.py#L181
+        # (bsz, num_heads, adapter_len, head_dim)
+        adapter_k = torch.repeat_interleave(adapter_k, repeats=factor, dim=1)
+        adapter_v = torch.repeat_interleave(adapter_v, repeats=factor, dim=1)
+        # Recompute query states.
+        compute_query_states = TRANSFORMERS_MODEL_CONFIG[self.model_type].compute_query_states
+        # (bsz, num_heads, q_len, head_dim)
+        query_states = compute_query_states(model=self.model, **kwargs)
+
+        previous_dtype = query_states.dtype
+
+        # (bsz, num_heads, q_len, adapter_len)
+        scores = torch.matmul(query_states, adapter_k.transpose(2, 3).to(previous_dtype)) / math.sqrt(
+            self.model.head_dim
+        )
+        # Upcast attention to fp32
+        # (bsz, num_heads, q_len, adapter_len)
+        scores = self.adaption_gate * F.softmax(scores, dim=-1, dtype=torch.float32).to(previous_dtype)
+        # (bsz, q_len, num_heads * head_dim)
+        adapter_output = torch.matmul(scores, adapter_v).transpose(1, 2).reshape(bsz, q_len, -1)
+
+        # (bsz, q_len, hidden_size)
+        if o_proj_layer is not None:
+            adapter_output = getattr(self.model, o_proj_layer)(adapter_output)
+
+        # Add adaption prompt output to original output.
+        output = output + adapter_output
+
+        # Restore original dtype.
+        output = output.to(previous_dtype)
+        return output, *_
diff --git a/src/peft/tuners/adaption_prompt/model.py b/src/peft/tuners/adaption_prompt/model.py
new file mode 100644
index 0000000..4e76ce6
--- /dev/null
+++ b/src/peft/tuners/adaption_prompt/model.py
@@ -0,0 +1,171 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+
+from torch import nn
+
+from peft.utils import _freeze_adapter, _get_submodules
+
+from .config import AdaptionPromptConfig, prepare_config
+from .layer import AdaptedAttention, AdaptedAttentionGPT
+from .utils import is_adaption_prompt_trainable
+
+
+class AdaptionPromptModel(nn.Module):
+    """
+    Implements adaption prompts as described in https://huggingface.co/papers/2303.16199.
+
+    The top L attention modules are replaced with AdaptedAttention modules that wrap the original ones, but insert
+    trainable prompts with gates (for zero init).
+
+    Notes on the multi-adapter pattern:
+    - We store the states of different adapters by keeping a dictionary of AdaptedAttention modules indexed by adapter
+      name.
+    - Every time we switch adapters, we remove the modules of the currently active adapter from the model, store them
+      in the dictionary, and replace them with the modules of the new adapter.
+    - To avoid duplicated and potentially inconsistent state, the currently active adapter is always removed from the
+      dictionary.
+    - Disabling the adapter would also result in the modules being removed from the model.
+    """
+
+    def __init__(self, model, configs: dict, adapter_name: str):
+        super().__init__()
+        self.model = model
+        # Store adapter configs by name.
+        self.peft_config: dict[str, AdaptionPromptConfig] = {}
+        # Store lists of the parents of the affected attention modules by adapter name.
+        # We keep references to the parents so we can swap the adapters in-and-out of the model.
+        self._parents: dict[str, list[nn.Module]] = {}
+        # Store lists of cached AdaptedAttention modules by name.
+        self._cached_adapters: dict[str, list] = {}
+        # The name of the currently active adapter.
+        self._active_adapter = None
+        # Whether the adapter is enabled.
+        self._enabled = True
+        self.forward = self.model.forward
+        self.add_adapter(adapter_name, configs[adapter_name])
+        self._mark_only_adaption_prompts_as_trainable(self.model)
+
+    def add_adapter(self, adapter_name: str, config: AdaptionPromptConfig) -> None:
+        """Add an adapter with the given name and config."""
+        config = prepare_config(config, self.model)
+        if adapter_name in self.peft_config:
+            raise ValueError(f"Adapter with name '{adapter_name}' already exists.")
+
+        parents = []
+        for name, _ in self.model.named_modules():
+            if name.endswith(f".{config.target_modules}"):
+                par, _, _ = _get_submodules(self.model, name)
+                parents.append(par)
+        if len(parents) < config.adapter_layers:
+            raise ValueError(
+                f"Config specifies more adapter layers '{config.adapter_layers}' than the model has '{len(parents)}'."
+            )
+        # Note that if the target modules are not in Sequential, ModuleList, or
+        # some other PyTorch ordered container, the behavior is undefined as we
+        # assume here that the order of the modules is the same as the order of
+        # the transformer decoder layers.
+        parents = parents[-config.adapter_layers :]
+        self._parents[adapter_name] = parents
+
+        # It is only None during initialization.
+        # If it is disabled, we don't have to remove the modules.
+        if self._active_adapter is not None and self._enabled:
+            self._remove_adapted_attentions(self._active_adapter)
+        self._active_adapter = adapter_name
+        self.peft_config[adapter_name] = config
+        self._create_adapted_attentions(config, parents)
+        if not self._enabled:
+            self._remove_adapted_attentions(self._active_adapter)
+
+        if config.inference_mode:
+            _freeze_adapter(self.model, adapter_name)
+
+    def set_adapter(self, adapter_name: str, inference_mode: bool = False) -> None:
+        """Set the model to use the adapter with the given name."""
+        if inference_mode:
+            raise ValueError("inference_mode is not supported for AdaptionPromptModel.")
+        if self._active_adapter == adapter_name:
+            return
+        if adapter_name not in self.peft_config:
+            raise ValueError(f"Adapter with name '{adapter_name}' does not exist.")
+
+        if self._enabled:
+            self._remove_adapted_attentions(self._active_adapter)
+            self._set_adapted_attentions(adapter_name)
+
+        self._active_adapter = adapter_name
+
+    def enable_adapter_layers(self):
+        """Enable adapter layers by swapping in cached AdaptedAttention modules."""
+        self._enabled = True
+        self._set_adapted_attentions(self._active_adapter)
+
+    def disable_adapter_layers(self):
+        """Disable adapter layers by swapping out AdaptedAttention modules."""
+        self._enabled = False
+        self._remove_adapted_attentions(self._active_adapter)
+
+    def _create_adapted_attentions(self, config: AdaptionPromptConfig, parents: list[nn.Module]) -> None:
+        """Wrap LlamaAttention modules with newly created AdaptedAttention modules."""
+        for par in parents:
+            if self.model.config.model_type == "gpt2":
+                attn = AdaptedAttentionGPT(
+                    model_type=self.model.config.model_type,
+                    adapter_len=config.adapter_len,
+                    model=getattr(par, config.target_modules),
+                )
+
+            else:
+                attn = AdaptedAttention(
+                    model_type=self.model.config.model_type,
+                    adapter_len=config.adapter_len,
+                    model=getattr(par, config.target_modules),
+                )
+            setattr(par, config.target_modules, attn)
+
+    def _set_adapted_attentions(self, adapter_name: str) -> None:
+        """Replace LlamaAttention modules with cached AdaptedAttention modules."""
+        cached = self._cached_adapters[adapter_name]
+        del self._cached_adapters[adapter_name]
+        config = self.peft_config[adapter_name]
+        for i, par in enumerate(self._parents[adapter_name]):
+            setattr(par, config.target_modules, cached[i])
+
+    def _remove_adapted_attentions(self, adapter_name: str) -> None:
+        """Remove AdaptedAttention modules from the model and store them in the cache."""
+        config = self.peft_config[adapter_name]
+        adapted_attentions = []
+        for par in self._parents[adapter_name]:
+            attn = getattr(par, config.target_modules)
+            adapted_attentions.append(attn)
+            setattr(par, config.target_modules, attn.model)
+        self._cached_adapters[adapter_name] = adapted_attentions
+
+    def _mark_only_adaption_prompts_as_trainable(self, model: nn.Module) -> None:
+        """Freeze all parameters of the model except the adaption prompts."""
+        for n, p in model.named_parameters():
+            if not is_adaption_prompt_trainable(n):
+                p.requires_grad = False
+
+    def __getattr__(self, name: str):
+        """Forward missing attributes to the wrapped module."""
+        try:
+            return super().__getattr__(name)  # defer to nn.Module's logic
+        except AttributeError:
+            # This is necessary as e.g. causal models have various methods that we
+            # don't want to re-implement here.
+            if name == "model":  # see #1892: prevent infinite recursion if class is not initialized
+                raise
+            return getattr(self.model, name)
diff --git a/src/peft/tuners/adaption_prompt/utils.py b/src/peft/tuners/adaption_prompt/utils.py
new file mode 100644
index 0000000..35af28e
--- /dev/null
+++ b/src/peft/tuners/adaption_prompt/utils.py
@@ -0,0 +1,154 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+import inspect
+from typing import Optional
+
+import torch
+from torch import nn
+
+
+def llama_rotate_half(x: torch.Tensor) -> torch.Tensor:
+    """
+    Rotate half the hidden dims of the input.
+
+    This function was duplicated verbatim from:
+    https://github.com/huggingface/transformers/blob/1de8ce9ee1191ba761a593ac15d9ccbf5851bfc5/src/transformers/models/llama/modeling_llama.py#L126
+
+    This was done to eliminate the Llama transformers implementation as a dependency of this file. Note that some other
+    functions were also adapted from the transformers implementation but were modified.
+    """
+    x1 = x[..., : x.shape[-1] // 2]
+    x2 = x[..., x.shape[-1] // 2 :]
+    return torch.cat((-x2, x1), dim=-1)
+
+
+def llama_apply_rotary_pos_emb(q, cos, sin, position_ids):
+    """
+    Apply rotary position embedding to query states in the Llama model.
+
+    This function was adapted from:
+    https://github.com/huggingface/transformers/blob/1de8ce9ee1191ba761a593ac15d9ccbf5851bfc5/src/transformers/models/llama/modeling_llama.py#L133
+
+    It was modified to remove unnecessary processing of key states. The method is compatible with transformers <=
+    4.34.2 and also with the latest version (>=4.35).
+    """
+    # In previous transformers version cos/sin cached had a shape of 4D
+    if len(cos.shape) == 4:
+        gather_indices = position_ids[:, None, :, None]  # [bs, 1, seq_len, 1]
+        gather_indices = gather_indices.repeat(1, cos.shape[1], 1, cos.shape[3])
+        cos = torch.gather(cos.repeat(gather_indices.shape[0], 1, 1, 1), 2, gather_indices)
+        sin = torch.gather(sin.repeat(gather_indices.shape[0], 1, 1, 1), 2, gather_indices)
+    # In the new version, it is 2D so we fall back to the new implementation
+    # https://github.com/huggingface/transformers/blame/eef7ea98c31a333bacdc7ae7a2372bde772be8e4/src/transformers/models/llama/modeling_llama.py#L222-L226
+    else:
+        cos = cos[position_ids].unsqueeze(1)
+        sin = sin[position_ids].unsqueeze(1)
+    q_embed = (q * cos) + (llama_rotate_half(q) * sin)
+    return q_embed
+
+
+def llama_compute_query_states(model: nn.Module, **kwargs) -> torch.Tensor:
+    """
+    Compute query states for Llama models specifically. They need to be recomputed as the forward() method of the
+    original LlamaModel in the transformers library does not return them. See the related discussion in the PR:
+    https://github.com/huggingface/peft/pull/268
+    """
+    hidden_states = kwargs.get("hidden_states")
+    position_ids = kwargs.get("position_ids")
+    past_key_value = kwargs.get("past_key_value")
+    bsz, q_len, _ = hidden_states.size()
+    num_heads = model.config.num_attention_heads
+    query_states = model.q_proj(hidden_states).view(bsz, q_len, num_heads, model.head_dim).transpose(1, 2)
+
+    factor = model.k_proj.in_features // model.k_proj.out_features
+    value_states = model.v_proj(hidden_states).view(bsz, q_len, (num_heads // factor), model.head_dim).transpose(1, 2)
+
+    seq_len = q_len
+
+    if past_key_value is not None:
+        if isinstance(past_key_value, tuple):
+            # for transformers <= 4.35
+            seq_len += past_key_value[0].shape[-2]
+        else:
+            # since transformers 4.36, this is a DynamicCache instance
+            seq_len += past_key_value.get_seq_length(model.layer_idx)
+
+    # model.rotary_emb is deprecated and will be removed in transformers > 4.47.0. Instead, the position embeddings are
+    # passed via the kwargs
+    if "position_embeddings" in kwargs:
+        cos, sin = kwargs["position_embeddings"]
+        cos = cos.unsqueeze(1)
+        sin = sin.unsqueeze(1)
+        return (query_states * cos) + (llama_rotate_half(query_states) * sin)
+
+    # For transformers > 4.37.2 `position_ids` became a required arguments in the rotary embedding's forward pass.
+    if "position_ids" not in inspect.signature(model.rotary_emb.forward).parameters:
+        # TODO we assume that position_ids is not None here, not sure if that is safe but the old code also did that
+        cos, sin = model.rotary_emb(value_states, seq_len=seq_len)
+        return llama_apply_rotary_pos_emb(query_states, cos, sin, position_ids)
+
+    past_seen_tokens = 0
+    if position_ids is None:
+        # Compute position_ids, since they are required for transformers > 4.37.2
+        if past_key_value is None:
+            new_cache_positions = torch.arange(q_len, q_len + q_len, device=value_states.device)
+        else:
+            past_seen_tokens = past_key_value.get_usable_length(q_len, model.layer_idx)
+            new_cache_positions = torch.arange(past_seen_tokens, past_seen_tokens + q_len, device=value_states.device)
+        position_ids = new_cache_positions.unsqueeze(0)
+
+    rotary_emb_kwargs = {"position_ids": position_ids}
+    # The `seq_len` argument has been officially removed in transformers >= 4.39.0
+    if "seq_len" in inspect.signature(model.rotary_emb.forward).parameters:
+        rotary_emb_kwargs["seq_len"] = q_len + past_seen_tokens
+
+    cos, sin = model.rotary_emb(value_states, **rotary_emb_kwargs)
+
+    # For batched inference unsqueeze it on the correct dim
+    # since: https://github.com/huggingface/transformers/pull/29109
+    if len(cos.shape) == 3:
+        cos = cos.unsqueeze(1)
+        sin = sin.unsqueeze(1)
+
+    return (query_states * cos) + (llama_rotate_half(query_states) * sin)
+
+
+def gpt2_compute_query_states(
+    model: nn.Module,
+    hidden_states: Optional[tuple[torch.FloatTensor]],
+    encoder_hidden_states: Optional[torch.Tensor] = None,
+) -> torch.Tensor:
+    """
+    Compute query states for GPT2 models. They need to be recomputed as the forward() method of the GPT@ in the
+    transformers library does not return them. See the related discussion in the PR:
+    """
+    if encoder_hidden_states is not None:
+        if not hasattr(model, "q_attn"):
+            raise ValueError(
+                f"If `{model.__class__.__name__}` is used as cross attention, the weights `q_attn` must be defined. "
+                f"Please make sure to instantiate it with `GPT2Attention(..., is_cross_attention=True)`."
+            )
+        query_states = model.q_attn(hidden_states)
+    else:
+        query_states, _, _ = model.c_attn(hidden_states).split(model.split_size, dim=2)
+
+    shape_q = (*query_states.shape[:-1], -1, model.head_dim)
+    query_states = query_states.view(shape_q).transpose(1, 2)
+
+    return query_states
+
+
+def is_adaption_prompt_trainable(params: str) -> bool:
+    """Return True if module is trainable under adaption prompt fine-tuning."""
+    return params.split(".")[-1].startswith("adaption_")
diff --git a/src/peft/tuners/beft/__init__.py b/src/peft/tuners/beft/__init__.py
new file mode 100644
index 0000000..185f8f5
--- /dev/null
+++ b/src/peft/tuners/beft/__init__.py
@@ -0,0 +1,24 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+
+from peft.utils import register_peft_method
+
+from .config import BeftConfig
+from .layer import BeftLayer, Linear
+from .model import BeftModel
+
+
+__all__ = ["BeftConfig", "BeftLayer", "BeftModel", "Linear"]
+register_peft_method(name="beft", config_cls=BeftConfig, model_cls=BeftModel, is_mixed_compatible=True)
diff --git a/src/peft/tuners/beft/config.py b/src/peft/tuners/beft/config.py
new file mode 100644
index 0000000..e6c8328
--- /dev/null
+++ b/src/peft/tuners/beft/config.py
@@ -0,0 +1,73 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class BeftConfig(PeftConfig):
+    """
+    This is the configuration class to store the configuration of a [`BeftModel`].
+
+    Args:
+        target_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to apply the adapter to. If this is specified, only the modules with the specified
+            names will be replaced. When passing a string, a regex match will be performed. When passing a list of
+            strings, either an exact match will be performed or it is checked if the name of the module ends with any
+            of the passed strings. If this is not specified, modules will be chosen according to the model
+            architecture. If the architecture is not known, an error will be raised -- in this case, you should specify
+            the target modules manually.
+        modules_to_save (`Optional[List[str]]`):
+            List of modules apart from BEFT layers to be set as trainable and saved in the final checkpoint.
+        init_weights (`bool`):
+            Whether to initialize the vectors in the BEFT layers, defaults to `True`. Setting this to `False` is
+            discouraged.
+    """
+
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of module names or regex expression of the module names to replace with BEFT."
+                "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'."
+                "If not specified, modules will be chosen according to the model architecture, If the architecture is "
+                "not known, an error will be raised -- in this case, you should specify the target modules manually."
+            ),
+        },
+    )
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": "List of modules apart from BEFT layers to be set as trainable and saved in the final checkpoint. "
+            "For example, in Sequence Classification or Token Classification tasks, "
+            "the final layer `classifier/score` are randomly initialized and as such need to be trainable and saved."
+        },
+    )
+    init_weights: bool = field(
+        default=True,
+        metadata={"help": "Whether to initialize the vectors in the BEFT layers."},
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.BEFT
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
diff --git a/src/peft/tuners/beft/layer.py b/src/peft/tuners/beft/layer.py
new file mode 100644
index 0000000..6666529
--- /dev/null
+++ b/src/peft/tuners/beft/layer.py
@@ -0,0 +1,166 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+import warnings
+from typing import Any, Optional
+
+import torch
+from torch import nn
+
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+
+from .config import BeftConfig
+
+
+class BeftLayer(BaseTunerLayer):
+    # All names of layers that may contain adapter weights
+    adapter_layer_names = ("beft_bias",)
+
+    def __init__(self, base_layer: nn.Module, **kwargs) -> None:
+        self.base_layer = base_layer
+        self.beft_bias = nn.ParameterDict({})
+        # Mark the weight as unmerged
+        self._disable_adapters = False
+        self.merged_adapters = []
+
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            in_features, out_features = base_layer.in_features, base_layer.out_features
+        else:
+            raise TypeError(f"Unsupported layer type {type(base_layer)}")
+        self.in_features = in_features
+        self.out_features = out_features
+
+    def update_layer(self, adapter_name: str, config: BeftConfig, **kwargs):
+        base_layer = self.get_base_layer()
+        if base_layer.bias is None:
+            warnings.warn(
+                "Detected that the base layer has no bias term. "
+                "Note you cannot merge the BEFT adapter into the base layer."
+            )
+        init_weights = config.init_weights
+        inference_mode = config.inference_mode
+        weight = torch.randn((1, self.out_features))
+        self.beft_bias[adapter_name] = nn.Parameter(weight)
+        if init_weights:
+            self.reset_beft_parameters(adapter_name)
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def reset_beft_parameters(self, adapter_name):
+        if adapter_name in self.beft_bias.keys():
+            nn.init.constant_(self.beft_bias[adapter_name], 0.0)
+
+
+class Linear(nn.Module, BeftLayer):
+    # BEFT implemented in a dense layer
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        adapter_name: str,
+        config: BeftConfig,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        BeftLayer.__init__(self, base_layer)
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, config=config)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter bias into the base bias
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original bias and check for NaNs before
+                merging the bias. This is useful if you want to check if the merge operation will produce NaNs.
+                Defaults to `False`.
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.beft_bias.keys():
+                base_layer = self.get_base_layer()
+
+                if base_layer.bias is None:
+                    raise ValueError(f"Base layer has no bias, cannot merge bias adapter {active_adapter}")
+
+                orig_dtype = base_layer.bias.data.dtype
+                beft_bias = self.beft_bias[active_adapter].data
+
+                if safe_merge:
+                    output_bias = (base_layer.bias.data + beft_bias.squeeze()).clone()
+
+                    if not torch.isfinite(output_bias).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.bias.data = output_bias.to(orig_dtype)
+                else:
+                    base_layer.bias.data.add_(beft_bias.squeeze()).to(orig_dtype)
+
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base bias.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.beft_bias.keys():
+                base_layer = self.get_base_layer()
+
+                if base_layer.bias is None:
+                    raise ValueError(f"Base layer has no bias, cannot unmerge bias adapter {active_adapter}")
+
+                orig_dtype = base_layer.bias.data.dtype
+                # minus BEFT bias.
+                beft_bias = self.beft_bias[active_adapter].data
+                base_layer.bias.data = (base_layer.bias.data - beft_bias.squeeze()).to(orig_dtype)
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            beft_bias = None
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.beft_bias.keys():
+                    continue
+                current_bias = self.beft_bias[active_adapter].flatten()
+                if beft_bias is None:
+                    beft_bias = current_bias
+                else:
+                    beft_bias = beft_bias + current_bias
+
+            result = self.base_layer(x, *args, **kwargs)
+            if beft_bias is not None:
+                orig_dtype = result.dtype
+                result = (result + beft_bias).to(orig_dtype)
+
+        return result
diff --git a/src/peft/tuners/beft/model.py b/src/peft/tuners/beft/model.py
new file mode 100644
index 0000000..ea041a9
--- /dev/null
+++ b/src/peft/tuners/beft/model.py
@@ -0,0 +1,103 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import torch
+
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer
+from peft.utils import (
+    TRANSFORMERS_MODELS_TO_BEFT_TARGET_MODULES_MAPPING,
+)
+
+from .layer import BeftLayer, Linear
+
+
+class BeftModel(BaseTuner):
+    """
+    Creates a Infused Adapter by only fine-tuning the added bias terms of value projections from a pretrained
+    transformers model in low-training-data regimes (BEFT). The method is described in detail in
+    https://arxiv.org/abs/2509.15974
+
+    Args:
+        model ([`~transformers.PreTrainedModel`]): The model to be adapted.
+        config ([`BeftConfig`]): The configuration of the (BEFT) model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            Create empty adapter weights on meta device. Useful to speed up the loading process.
+
+    Returns:
+        `torch.nn.Module`: The (BEFT) model.
+
+    Example:
+
+        ```py
+        >>> from transformers import AutoModelForSeq2SeqLM
+        >>> from peft import BeftModel, BeftConfig
+
+        >>> config = BeftConfig(
+        ...     peft_type="Beft",
+        ...     task_type="SEQ_2_SEQ_LM",
+        ...     target_modules=["v"],
+        ... )
+
+        >>> model = AutoModelForSeq2SeqLM.from_pretrained("t5-base")
+        >>> beft_model = BeftModel(model, config, adapter_name="default")
+        ```
+
+    **Attributes**:
+        - **model** ([`~transformers.PreTrainedModel`]) -- The model to be adapted.
+        - **peft_config** ([`BeftConfig`]): The configuration of the (BEFT) model.
+    """
+
+    prefix: str = "beft_"
+    tuner_layer_cls = BeftLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_BEFT_TARGET_MODULES_MAPPING
+
+    @staticmethod
+    def _create_new_module(beft_config, adapter_name, target, **kwargs):
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        if isinstance(target_base_layer, torch.nn.Linear):
+            new_module = Linear(target, adapter_name, config=beft_config, **kwargs)
+        else:
+            raise TypeError(
+                f"Target module {target} is not supported. Currently, only `torch.nn.Linear` is supported."
+            )
+        return new_module
+
+    def _create_and_replace(
+        self,
+        beft_config,
+        adapter_name,
+        target,
+        target_name,
+        parent,
+        current_key,
+    ):
+        kwargs = {}
+
+        if isinstance(target, BeftLayer):
+            target.update_layer(
+                adapter_name,
+                config=beft_config,
+            )
+        else:
+            new_module = self._create_new_module(beft_config, adapter_name, target, **kwargs)
+            if adapter_name not in self.active_adapters:
+                # adding an additional adapter: it is not automatically trainable
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
diff --git a/src/peft/tuners/boft/__init__.py b/src/peft/tuners/boft/__init__.py
new file mode 100644
index 0000000..c84b835
--- /dev/null
+++ b/src/peft/tuners/boft/__init__.py
@@ -0,0 +1,24 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from peft.utils import register_peft_method
+
+from .config import BOFTConfig
+from .layer import BOFTLayer
+from .model import BOFTModel
+
+
+__all__ = ["BOFTConfig", "BOFTLayer", "BOFTModel"]
+
+register_peft_method(name="boft", config_cls=BOFTConfig, model_cls=BOFTModel)
diff --git a/src/peft/tuners/boft/config.py b/src/peft/tuners/boft/config.py
new file mode 100644
index 0000000..9fdf4b7
--- /dev/null
+++ b/src/peft/tuners/boft/config.py
@@ -0,0 +1,170 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+# The implementation is based on "Parameter-Efficient Orthogonal Finetuning
+# via Butterfly Factorization" (https://huggingface.co/papers/2311.06243) in ICLR 2024.
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class BOFTConfig(PeftConfig):
+    """
+    This is the configuration class to store the configuration of a [`BOFTModel`].
+
+    Args:
+        boft_block_size (`int`): BOFT matrix block size across different layers, expressed in `int`. Bigger
+            block sizes results in more dense update matrices with more trainable parameters. Choose `boft_block_size`
+            to be divisible by most layer's input dimension (`in_features`), e.g., 4, 8, 16. Also, please only specify
+            either `boft_block_size` or `boft_block_num`, but not both simultaneously or leaving both to 0, because
+            `boft_block_size` x `boft_block_num` must equal the layer's input dimension.
+        boft_block_num (`int`): Number of BOFT blocks per injected layer. Bigger `boft_block_num` result in sparser
+            update matrices with **fewer** trainable parameters. **Note**, please choose `boft_block_num` to be
+            divisible by most layer's input dimension (`in_features`), e.g., 4, 8, 16. Only specify either
+            `boft_block_size` or `boft_block_num`, but not both simultaneously or leaving both to 0, because
+            `boft_block_size` x `boft_block_num` must equal the layer's input dimension.
+        boft_n_butterfly_factor (`int`): Number of butterfly factors across different layers. For
+            `boft_n_butterfly_factor=1`, BOFT is the same as vanilla OFT, for `boft_n_butterfly_factor=2`, the
+            effective block size of OFT becomes twice as big and the number of blocks become half.
+        target_modules (`Union[List[str],str]`): The names of the modules to apply the adapter to.
+        exclude_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to not apply the adapter. When passing a string, a regex match will be performed.
+            When passing a list of strings, either an exact match will be performed or it is checked if the name of the
+            module ends with any of the passed strings.
+        boft_dropout (`float`):
+            The multiplicative dropout probability, by setting OFT blocks to identity during training, similar to the
+            dropout layer in LoRA.
+        fan_in_fan_out (`bool`): Set this to True if the layer to replace stores weight like (fan_in, fan_out).
+            For example, gpt-2 uses `Conv1D` which stores weights like (fan_in, fan_out) and hence this should be set
+            to `True`.
+        bias (`str`): Bias type for BOFT. Can be 'none', 'all' or 'boft_only'. If 'all' or 'boft_only', the
+            corresponding biases will be updated during training. Be aware that this means that, even when disabling
+            the adapters, the model will not produce the same output as the base model would have without adaptation.
+        modules_to_save (`List[str]`):List of modules apart from BOFT layers to be set as trainable
+            and saved in the final checkpoint.
+        layers_to_transform (`Union[List[int],int]`):
+            The layer indexes to transform, if this argument is specified, it will apply the BOFT transformations on
+            the layer indexes that are specified in this list. If a single integer is passed, it will apply the BOFT
+            transformations on the layer at this index.
+        layers_pattern (`Optional[Union[List[str], str]]`):
+            The layer pattern name, used only if `layers_to_transform` is different from `None` and if the layer
+            pattern is not in the common layers pattern. This should target the `nn.ModuleList` of the model, which is
+            often called `'layers'` or `'h'`.
+    """
+
+    boft_block_size: int = field(
+        default=4,
+        metadata={
+            "help": "BOFT block size across different layers.",
+            "note": "You can only specify either boft_block_size or boft_block_num, but not both simultaneously, because boft_block_size x boft_block_num = layer dimension.",
+        },
+    )
+    boft_block_num: int = field(
+        default=0,
+        metadata={
+            "help": "Number of BOFT blocks per injected layer.",
+            "note": "You can only specify either boft_block_size or boft_block_num, but not both simultaneously, because boft_block_size x boft_block_num = layer dimension.",
+        },
+    )
+    boft_n_butterfly_factor: int = field(
+        default=1,
+        metadata={
+            "help": "Number of butterfly factors.",
+            "note": (
+                "for example, boft_n_butterfly_factor=2, the effective block size of OFT becomes twice as big and the number of blocks become half.",
+                "note: for boft_n_butterfly_factor=1, BOFT is the same as vanilla OFT.",
+            ),
+        },
+    )
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": "List of module names or regex expression of the module names to replace with BOFT.",
+            "example": "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$' ",
+        },
+    )
+    exclude_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={"help": "List of module names or regex expression of the module names to exclude from BOFT."},
+    )
+    boft_dropout: float = field(
+        default=0.0,
+        metadata={
+            "help": "BOFT multiplicative dropout, randomly setting blocks of OFT to be identity matrix, similar to the dropout layer in LoRA."
+        },
+    )
+    fan_in_fan_out: bool = field(
+        default=False,
+        metadata={"help": "Set this to True if the layer to replace stores weight like (fan_in, fan_out)"},
+    )
+    bias: str = field(default="none", metadata={"help": "Bias type for BOFT. Can be 'none', 'all' or 'boft_only'"})
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": "List of modules apart from BOFT layers to be set as trainable and saved in the final checkpoint. ",
+            "note": (
+                "For example, in Sequence Classification or Token Classification tasks, ",
+                "the final layer `classifier/score` are randomly initialized and as such need to be trainable and saved.",
+            ),
+        },
+    )
+    init_weights: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "Whether to initialize the weights of the BOFT layers with their default initialization. Don't change ",
+                "this setting, except if you know exactly what you're doing.",
+            ),
+        },
+    )
+    layers_to_transform: Optional[Union[list[int], int]] = field(
+        default=None,
+        metadata={
+            "help": "The layer indexes to transform, is this argument is specified, PEFT will transform only the layers indexes that are specified inside this list. If a single integer is passed, PEFT will transform only the layer at this index."
+        },
+    )
+    layers_pattern: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": "The layer pattern name, used only if `layers_to_transform` is different to None and if the layer pattern is not in the common layers pattern. "
+            "This should target the `nn.ModuleList` of the model, which is often called `'layers'` or `'h'`."
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.BOFT
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        self.exclude_modules = (
+            set(self.exclude_modules) if isinstance(self.exclude_modules, list) else self.exclude_modules
+        )
+        # check for layers_to_transform and layers_pattern
+        if self.layers_pattern and not self.layers_to_transform:
+            raise ValueError("When `layers_pattern` is specified, `layers_to_transform` must also be specified. ")
+        if self.boft_block_size == 0 and self.boft_block_num == 0:
+            raise ValueError(
+                f"Either `boft_block_size` or `boft_block_num` must be non-zero. Currently, boft_block_size = {self.boft_block_size} and boft_block_num = {self.boft_block_num}."
+            )
+        if not (self.boft_block_size != 0) ^ (self.boft_block_num != 0):
+            raise ValueError(
+                f"You can only specify either boft_block_size ({self.boft_block_size}) or boft_block_num ({self.boft_block_num}), but not both simultaneously, because boft_block_size x boft_block_num == in_features."
+            )
diff --git a/src/peft/tuners/boft/fbd/__init__.py b/src/peft/tuners/boft/fbd/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/peft/tuners/boft/fbd/fbd_cuda.cpp b/src/peft/tuners/boft/fbd/fbd_cuda.cpp
new file mode 100644
index 0000000..d63111b
--- /dev/null
+++ b/src/peft/tuners/boft/fbd/fbd_cuda.cpp
@@ -0,0 +1,28 @@
+#include <torch/torch.h>
+#include <vector>
+#include <iostream>
+#include <torch/extension.h>
+
+std::vector<at::Tensor> forward_fast_block_diag_cuda(
+        at::Tensor input);
+
+std::vector<at::Tensor> forward_fast_block_diag(
+        at::Tensor input
+        ) {
+    return forward_fast_block_diag_cuda(input);
+}
+
+std::vector<at::Tensor> backward_fast_block_diag_cuda(
+        at::Tensor grad_output, 
+        at::Tensor input);
+std::vector<at::Tensor> backward_fast_block_diag(
+        at::Tensor grad_output,
+        at::Tensor input
+        ) {
+    return backward_fast_block_diag_cuda(grad_output, input);
+}
+
+PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
+    m.def("forward", &forward_fast_block_diag, "FAST BLOCK DIAG (CUDA)");
+    m.def("backward", &backward_fast_block_diag, "FAST BLOCK DIAG backward (CUDA)");
+}
diff --git a/src/peft/tuners/boft/fbd/fbd_cuda_kernel.cu b/src/peft/tuners/boft/fbd/fbd_cuda_kernel.cu
new file mode 100644
index 0000000..9f30745
--- /dev/null
+++ b/src/peft/tuners/boft/fbd/fbd_cuda_kernel.cu
@@ -0,0 +1,109 @@
+// Author: Yao Feng
+// Date: 2023/08
+// Description: cuda kernel for fast block diag
+
+#include <ATen/ATen.h>
+
+#include <cuda.h>
+#include <cuda_runtime.h>
+#include <vector>
+
+namespace{
+template <typename scalar_t>
+__global__ void forward_fast_block_diag_cuda_kernel(
+        const scalar_t* __restrict__ input, //[z, N, b, b]
+        scalar_t*  output, //[z, Nxb, Nxb]
+        int z, int N, int b
+    ) {
+
+    const int i = blockIdx.x * blockDim.x + threadIdx.x;
+    if (i >= z*N*b*b) {
+        return;
+    }
+    const int zi = i/(N*b*b);
+    const int Ni = (i%(N*b*b))/(b*b);
+    const int x = ((i%(N*b*b))%(b*b))/b;
+    const int y = ((i%(N*b*b))%(b*b))%b;
+
+    output[zi*N*b*N*b + (Ni*b+x)*N*b + Ni*b + y] = input[zi*N*b*b + Ni*b*b + x*b + y];
+
+}
+
+template <typename scalar_t>
+__global__ void backward_fast_block_diag_cuda_kernel(
+        const scalar_t* __restrict__ grad_output, 
+        scalar_t*  grad_input, 
+        int z, int N, int b
+    ) {
+
+    const int i = blockIdx.x * blockDim.x + threadIdx.x;
+    if (i >= z*N*b*b) {
+        return;
+    }
+    const int zi = i/(N*b*b);
+    const int Ni = (i%(N*b*b))/(b*b);
+    const int x = ((i%(N*b*b))%(b*b))/b;
+    const int y = ((i%(N*b*b))%(b*b))%b;
+    
+    grad_input[zi*N*b*b + Ni*b*b + x*b + y] = grad_output[zi*N*b*N*b + (Ni*b+x)*N*b + Ni*b + y];
+
+} // namespace
+}
+
+std::vector<at::Tensor> forward_fast_block_diag_cuda(
+    at::Tensor input
+    ){
+    const auto z = input.size(0);
+    const auto N = input.size(1);
+    const auto b = input.size(2);
+
+    // print(channel_size)
+    const int threads = 512;
+    const dim3 blocks_1 ((z*N*b*b - 1) / threads +1);
+    // initlaize output
+    auto output = at::zeros({z, N*b, N*b}, input.options());
+
+    AT_DISPATCH_FLOATING_TYPES_AND_HALF(input.type(), "forward_fast_block_diag1", ([&] {
+        forward_fast_block_diag_cuda_kernel<scalar_t><<<blocks_1, threads>>>(
+        input.data_ptr<scalar_t>(),
+        output.data_ptr<scalar_t>(),
+        z, N, b);
+      }));
+
+   
+    cudaError_t err = cudaGetLastError();
+    if (err != cudaSuccess) 
+            printf("Error in forward_fast_block_diag_cuda_kernel: %s\n", cudaGetErrorString(err));
+
+    return {output};
+}
+
+std::vector<at::Tensor> backward_fast_block_diag_cuda(
+    at::Tensor grad_output,
+    at::Tensor input
+    ){
+
+    const auto z = input.size(0);
+    const auto N = input.size(1);
+    const auto b = input.size(2);
+    
+    // print(channel_size)
+    const int threads = 512;
+    const dim3 blocks_1 ((z*N*b*b - 1) / threads +1);
+    
+    // initialize grad input
+    auto grad_input = at::zeros_like(input);
+
+    AT_DISPATCH_FLOATING_TYPES_AND_HALF(grad_output.type(), "backward_fast_block_diag", ([&] {
+        backward_fast_block_diag_cuda_kernel<scalar_t><<<blocks_1, threads>>>(
+        grad_output.data_ptr<scalar_t>(),
+        grad_input.data_ptr<scalar_t>(),
+        z, N, b);
+      }));
+    
+    cudaError_t err = cudaGetLastError();
+    if (err != cudaSuccess) 
+            printf("Error in backward_fast_block_diag_cuda_kernel: %s\n", cudaGetErrorString(err));
+
+    return {grad_input};
+}
diff --git a/src/peft/tuners/boft/layer.py b/src/peft/tuners/boft/layer.py
new file mode 100644
index 0000000..febf80c
--- /dev/null
+++ b/src/peft/tuners/boft/layer.py
@@ -0,0 +1,1001 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+# The implementation is based on "Parameter-Efficient Orthogonal Finetuning
+# via Butterfly Factorization" (https://huggingface.co/papers/2311.06243) in ICLR 2024.
+
+from __future__ import annotations
+
+import math
+import os
+import warnings
+from contextlib import contextmanager
+from typing import Any, Optional
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+from torch.autograd import Function
+
+from peft.tuners.tuners_utils import BaseTunerLayer, _get_in_out_features, check_adapters_to_merge
+from peft.utils import quantization_extra_repr, resolve_quantization_backend
+
+from .config import BOFTConfig
+
+
+_FBD_CUDA = None
+
+
+# this function is a 1:1 copy from accelerate
+@contextmanager
+def patch_environment(**kwargs):
+    """
+    A context manager that will add each keyword argument passed to `os.environ` and remove them when exiting.
+
+    Will convert the values in `kwargs` to strings and upper-case all the keys.
+
+    Example:
+
+    ```python
+    >>> import os
+    >>> from accelerate.utils import patch_environment
+
+    >>> with patch_environment(FOO="bar"):
+    ...     print(os.environ["FOO"])  # prints "bar"
+    >>> print(os.environ["FOO"])  # raises KeyError
+    ```
+    """
+    existing_vars = {}
+    for key, value in kwargs.items():
+        key = key.upper()
+        if key in os.environ:
+            existing_vars[key] = os.environ[key]
+        os.environ[key] = str(value)
+
+    yield
+
+    for key in kwargs:
+        key = key.upper()
+        if key in existing_vars:
+            # restore previous value
+            os.environ[key] = existing_vars[key]
+        else:
+            os.environ.pop(key, None)
+
+
+def get_fbd_cuda():
+    global _FBD_CUDA
+
+    if _FBD_CUDA is not None:
+        return _FBD_CUDA
+
+    # This import initializes cuda context and should thus be local, see issue 1877
+    from torch.utils.cpp_extension import load
+
+    curr_dir = os.path.dirname(__file__)
+    # need ninja to build the extension
+    try:
+        with patch_environment(CC="gcc", CXX="gcc"):
+            fbd_cuda = load(
+                name="fbd_cuda",
+                sources=[f"{curr_dir}/fbd/fbd_cuda.cpp", f"{curr_dir}/fbd/fbd_cuda_kernel.cu"],
+                verbose=True,
+                # build_directory='/tmp/'  # for debugging
+            )
+            # extra_cuda_cflags = ['-std=c++14', '-ccbin=$$(which gcc-7)']) # cuda10.2 is not compatible with gcc9. Specify gcc 7
+    except Exception as e:
+        warnings.warn(f"Failed to load the CUDA extension: {e}, check if ninja is available.")
+        warnings.warn("Setting boft_n_butterfly_factor to 1 to speed up the finetuning process.")
+        fbd_cuda = None
+
+    _FBD_CUDA = fbd_cuda
+    return _FBD_CUDA
+
+
+class FastBlockDiag(Function):
+    """
+    Implements a custom autograd Function for a fast block diagonal operation using CUDA.
+
+    This function is optimized for 4D tensors where the last two dimensions are equal, representing block diagonal
+    matrices for efficient computation on CUDA devices.
+    """
+
+    @staticmethod
+    def forward(ctx, input):
+        """
+        The forward method for FastBlockDiag.
+
+        Computes the block diagonal operation on the input tensor using a CUDA-optimized function. This method assumes
+        that the input is a 4D tensor where the last two dimensions are equal, which represent the blocks to be
+        diagonalized.
+
+        Parameters:
+        ctx: A context object that can be used to stash information for backward computation.
+        input (Tensor): The input tensor of shape (N, D, H, H), where `N` is the batch size,
+                        `D` represents one additional dimension (In BOFT, the number of BOFT blocks), and `H` is the
+                        size of the square blocks along the last two dimensions (In BOFT, the block size).
+
+        Returns:
+        Tensor: The resulting tensor after applying the block diagonal operation,
+                will have the shape (N, DxH, DxH).
+        """
+        output = get_fbd_cuda().forward(input)[0]
+        ctx.save_for_backward(input)
+        return output
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        (input,) = ctx.saved_tensors
+        grad_input = get_fbd_cuda().backward(grad_output, input)[0]
+        return grad_input
+
+
+class MultiplicativeDropoutLayer(nn.Module):
+    """
+    Implements the multiplicative dropout layer for BOFT.
+    """
+
+    def __init__(self, p=0.0):
+        """
+        Initializes the multiplicative dropout layer.
+
+        Parameters:
+        p (float): The probability of dropping out a block. Defaults to 0.0.
+        """
+        super().__init__()
+        self.p = p
+
+    def forward(self, x):
+        """
+        Applies multiplicative dropout to the input tensor.
+
+        Parameters:
+        x (Tensor): The input tensor of shape (N, D, H, H), where `N` is the batch size, `D` represents
+                    one additional dimension (In BOFT, the number of BOFT blocks), and `H` is the size of the square
+                    blocks along the last two dimensions (In BOFT, the block size).
+        """
+        if self.training:
+            # Ensure the last two dimensions are the same
+            if x.shape[-1] != x.shape[-2]:
+                raise ValueError("The last two dimensions of input should be the same!")
+
+            N, D, H, _ = x.shape
+
+            # Randomly select one from N
+            n_random = torch.randint(0, N, (1,)).item()
+
+            # Create a mask with 1s for matrices to be replaced with identity and 0s otherwise
+            num_to_replace = int(self.p * D)
+            num_zeros = D - num_to_replace
+
+            # Generate a flat tensor with desired number of 1s and 0s
+            mask = torch.cat([torch.ones(num_to_replace, device=x.device), torch.zeros(num_zeros, device=x.device)])
+
+            # Shuffle and reshape the mask
+            mask = mask[torch.randperm(D)].view(1, D, 1, 1)
+
+            full_mask = torch.zeros(N, D, 1, 1, device=x.device)
+            full_mask[n_random] = mask
+
+            # Use the mask to combine original matrices and identity matrices
+            eye_matrix = torch.eye(H, device=x.device).repeat(N, D, 1, 1)
+            x = (1 - full_mask) * x + full_mask * eye_matrix
+        return x
+
+
+class BOFTLayer(BaseTunerLayer):
+    """
+    Implements the BOFT layer.
+    """
+
+    # All names of layers that may contain (trainable) adapter weights
+    adapter_layer_names = ("boft_R", "boft_s")
+    # All names of other parameters that may contain adapter-related parameters
+    other_param_names = ("boft_block_size", "boft_block_num", "boft_dropout")
+
+    def __init__(self, base_layer: nn.Module, **kwargs) -> None:
+        """
+        Initializes the BOFT layer.
+
+        Note, currently only support linear layer and convolutional layer, with further support for other layers to be
+        added soon.
+
+        Parameters:
+        base_layer: the pretrained model layer
+        """
+        self.base_layer = base_layer
+        self.quantization_backend = resolve_quantization_backend(
+            self.get_base_layer(), get_apply_tensor_subclass=kwargs.get("get_apply_tensor_subclass")
+        )
+        self.boft_block_size = {}
+        self.boft_block_num = {}
+        self.boft_dropout = nn.ModuleDict({})
+        self.boft_R = nn.ParameterDict({})
+        self.boft_s = nn.ParameterDict({})
+        # Mark the weight as unmerged
+        self._disable_adapters = False
+        self.merged_adapters = []
+        # flag to enable/disable casting of input to weight dtype during forward call
+        self.cast_input_dtype_enabled = True
+        self.kwargs = kwargs
+
+        base_layer = self.get_base_layer()
+
+        in_features, out_features = _get_in_out_features(base_layer)
+        if (in_features is None) or (out_features is None):
+            raise TypeError(f"Unsupported layer type {type(base_layer)}")
+
+        self.in_features = in_features
+        self.out_features = out_features
+
+    def set_scale(self, adapter, scale):
+        if adapter not in self.scaling:
+            # Ignore the case where the adapter is not in the layer
+            return
+
+        warnings.warn("Scaling operation for BOFT not supported! Automatically set scale to 1.")
+
+    def scale_layer(self, scale: float) -> None:
+        if scale == 1:
+            return
+
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self.boft_R.keys():
+                continue
+
+            warnings.warn("Scaling operation for BOFT not supported! Automatically set scale to 1.")
+
+    def unscale_layer(self, scale=None) -> None:
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self.boft_R.keys():
+                continue
+
+            warnings.warn("Unscaling operation for BOFT not supported! Keeping scale to 1.")
+
+    def update_layer(
+        self,
+        adapter_name: str,
+        config: BOFTConfig,
+        **kwargs,
+    ):
+        """
+        Update the linear layer with trainable BOFT weights. Override for other layer types.
+        """
+        boft_block_size = config.boft_block_size
+        boft_block_num = config.boft_block_num
+        boft_n_butterfly_factor = config.boft_n_butterfly_factor
+        boft_dropout = config.boft_dropout
+        init_weights = config.init_weights
+        inference_mode = config.inference_mode
+
+        # Attempt to load the CUDA extension during model initialization
+        if not get_fbd_cuda():
+            self.fbd_cuda_available = False
+            # If the CUDA extension is not available, set the butterfly factor to 1 to speed up the finetuning process
+            boft_n_butterfly_factor = 1
+        else:
+            self.fbd_cuda_available = True
+
+        # to be consistent with the paper notation
+        boft_n_butterfly_factor = boft_n_butterfly_factor - 1
+        if boft_n_butterfly_factor < 0:
+            raise ValueError(
+                f"You can only specify boft_n_butterfly_factor {boft_n_butterfly_factor + 1} to be a positive integer number."
+            )
+
+        # Initialize the MultiplicativeDropoutLayer for boft_dropout > 0.0.
+        if boft_dropout > 0.0:
+            boft_dropout_layer = MultiplicativeDropoutLayer(p=boft_dropout)
+        else:
+            boft_dropout_layer = nn.Identity()
+        self.boft_dropout.update(nn.ModuleDict({adapter_name: boft_dropout_layer}))
+
+        if boft_block_size == 0 and boft_block_num != 0:
+            if self.in_features % boft_block_num != 0:
+                raise ValueError(
+                    f"in_features ({self.in_features}) must be divisible by boft_block_num ({boft_block_num})!"
+                )
+
+            if boft_n_butterfly_factor != 0:
+                if boft_n_butterfly_factor > int(math.log2(boft_block_num)):
+                    raise ValueError(
+                        f"Invalid combination of boft_n_butterfly_factor ({boft_n_butterfly_factor + 1}) and boft_block_num ({boft_block_num})!"
+                    )
+                if boft_block_num % (2**boft_n_butterfly_factor) != 0:
+                    raise ValueError(
+                        f"boft_block_num ({boft_block_num}) must be a multiple of 2 raised to the power of boft_n_butterfly_factor ({boft_n_butterfly_factor + 1})!"
+                    )
+
+            boft_block_size = int(self.in_features // boft_block_num)
+
+        elif boft_block_size != 0 and boft_block_num == 0:
+            if self.in_features % boft_block_size != 0:
+                raise ValueError(
+                    f"in_features ({self.in_features}) must be divisible by boft_block_size ({boft_block_size})!"
+                )
+
+            if boft_n_butterfly_factor != 0:
+                if self.in_features < (boft_block_size * (2**boft_n_butterfly_factor)):
+                    raise ValueError(
+                        f"Invalid combination of in_features ({self.in_features}), boft_n_butterfly_factor ({boft_n_butterfly_factor + 1}) and boft_block_size ({boft_block_size})!"
+                    )
+                if self.in_features % (boft_block_size * (2**boft_n_butterfly_factor)) != 0:
+                    raise ValueError(
+                        f"Invalid combination of in_features ({self.in_features}), boft_n_butterfly_factor ({boft_n_butterfly_factor + 1}) and boft_block_size ({boft_block_size})!"
+                    )
+
+            boft_block_num = int(self.in_features // boft_block_size)
+
+        else:
+            raise ValueError(
+                "Something went wrong, please report this error: https://github.com/huggingface/peft/issues"
+            )
+
+        # In OFT you can specify the number of blocks to be 1
+        if boft_n_butterfly_factor != 0:
+            if boft_block_num % 2 != 0:
+                raise ValueError(f"boft_block_num ({boft_block_num}) must be an even number!")
+
+            if boft_block_size % 2 != 0:
+                raise ValueError(f"boft_block_size ({boft_block_size}) must be an even number!")
+
+        # If there is no butterfly factor, then permutation matrix P will be an identity matrix.
+        P = torch.empty((boft_n_butterfly_factor + 1, self.in_features, self.in_features))
+        for i in range(boft_n_butterfly_factor + 1):
+            perm = self.block_butterfly_perm(
+                self.in_features, int(boft_block_num / (2 ** (i))), int(boft_block_size / 2), boft_n_butterfly_factor
+            )
+            perm_mat = self.perm2mat(perm)
+            P[i] = perm_mat
+
+        self.register_buffer("boft_P", P, persistent=False)
+
+        self.boft_R[adapter_name] = nn.Parameter(
+            torch.zeros(boft_n_butterfly_factor + 1, boft_block_num, boft_block_size, boft_block_size)
+        )
+        self.boft_s[adapter_name] = nn.Parameter(torch.ones(int(self.out_features), 1))
+
+        self.reset_boft_parameters(adapter_name, init_weights)
+
+        # set the boft block size and number
+        self.boft_block_size[adapter_name] = boft_block_size
+        self.boft_block_num[adapter_name] = boft_block_num
+
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def reset_boft_parameters(self, adapter_name, init_weights):
+        """
+        Reset the BOFT parameters.
+        """
+        if init_weights is False:
+            nn.init.normal_(self.boft_R[adapter_name], mean=0.0, std=0.1)
+            nn.init.normal_(self.boft_s[adapter_name], mean=1.0, std=0.1)
+            return
+
+        if adapter_name in self.boft_R.keys():
+            if init_weights is True:
+                # initialize R to zero
+                nn.init.zeros_(self.boft_R[adapter_name])
+                nn.init.ones_(self.boft_s[adapter_name])
+            else:
+                raise ValueError(f"Unknown initialization {init_weights=}")
+
+    def perm2mat(self, indices):
+        """
+        Convert permutation indices to permutation matrix.
+
+        Args:
+        indices: A list of indices representing the permutation.
+        """
+        # Number of indices determines the size of the square matrix
+        n = len(indices)
+
+        # Initialize a matrix of zeros
+        perm_mat = torch.zeros((n, n))
+
+        # Set the 1s according to the indices
+        for i, idx in enumerate(indices):
+            perm_mat[i, idx] = 1
+
+        return perm_mat
+
+    def block_butterfly_perm(self, n, b, r=3, n_butterfly_factor=1):
+        """
+        Define the permutation matrix for the block butterfly permutation.
+
+        Args:
+        n: size of the permutation matrix
+        b: desired number of blocks after multiplying with the permutation matrix
+        r: base block size of the block diagonal matrix, e.g. 2x2, 3x3, 5x5 etc.
+        """
+
+        if n_butterfly_factor == 0:
+            return torch.arange(n)
+
+        if b * r * 2 > n:
+            raise ValueError("Invalid number of blocks!")
+
+        block_size = int(n // b)
+        indices = torch.arange(n)
+
+        def sort_block(b, r):
+            step = b / r
+            initial_order = torch.arange(b)
+            sorted_order = torch.empty(b, dtype=torch.long)
+
+            evens = torch.arange(0, step, 2)
+            odds = torch.arange(1, step, 2)
+            sorted_seq = torch.cat((evens, odds), dim=0)
+            for i, pos in enumerate(sorted_seq):
+                sorted_order[int(i * r) : int(i * r + r)] = initial_order[int(pos * r) : int(pos * r + r)]
+            return sorted_order
+
+        sorted_order = sort_block(block_size, r)
+
+        for i in range(0, n, block_size):
+            block_end = i + block_size
+            tmp_indices = indices[i:block_end]
+            indices[i:block_end] = tmp_indices[sorted_order]
+        return indices
+
+    def cayley_batch(self, data):
+        """
+        Perform the Cayley parametrization on a batch of skew-symmetric matrices.
+
+        Args:
+            data: A batch of skew-symmetric matrices of shape (b, r, c).
+        """
+        b, r, c = data.shape
+        # Ensure the input matrix is skew-symmetric
+        skew_mat = 0.5 * (data - data.transpose(1, 2))
+        id_mat = torch.eye(r, device=data.device).unsqueeze(0).expand(b, r, c)
+
+        # Perform the Cayley parametrization, must be in float32
+        Q = torch.linalg.solve(id_mat + skew_mat, id_mat - skew_mat, left=False)
+
+        return Q.to(data.dtype)
+
+
+class Linear(nn.Module, BOFTLayer):
+    """
+    BOFT implemented in a dense layer.
+    """
+
+    def __init__(
+        self,
+        base_layer,
+        adapter_name: str,
+        config: BOFTConfig,
+        is_target_conv_1d_layer: bool = False,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        BOFTLayer.__init__(self, base_layer, **kwargs)
+        self.fan_in_fan_out = config.fan_in_fan_out
+
+        self._active_adapter = adapter_name
+
+        self.update_layer(adapter_name, config=config)
+        self.is_target_conv_1d_layer = is_target_conv_1d_layer
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.boft_R.keys():
+                orig_weight = self.get_base_weight().clone()
+                orig_dtype = orig_weight.dtype
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    # because of the copy operation.
+                    butterfly_oft_mat, boft_s = self.get_delta_weight(active_adapter)
+                    orig_weight = torch.transpose(orig_weight, 0, 1)
+                    orig_weight = torch.mm(butterfly_oft_mat, orig_weight.to(butterfly_oft_mat.dtype))
+                    orig_weight = torch.transpose(orig_weight, 0, 1)
+                    orig_weight = orig_weight * boft_s
+
+                    if not torch.isfinite(orig_weight).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    self.set_base_weight(orig_weight.contiguous().to(orig_dtype))
+                else:
+                    butterfly_oft_mat, boft_s = self.get_delta_weight(active_adapter)
+                    orig_weight = torch.transpose(orig_weight, 0, 1)
+                    orig_weight = torch.mm(butterfly_oft_mat, orig_weight.to(butterfly_oft_mat.dtype))
+                    orig_weight = torch.transpose(orig_weight, 0, 1)
+                    orig_weight = orig_weight * boft_s
+
+                    self.set_base_weight(orig_weight.contiguous().to(orig_dtype))
+
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.boft_R.keys():
+                butterfly_oft_mat, boft_s = self.get_delta_weight(active_adapter)
+
+                orig_weight = self.get_base_weight().clone()
+                orig_dtype = orig_weight.dtype
+                orig_weight = torch.transpose(orig_weight, 0, 1)
+                orig_weight = torch.mm(butterfly_oft_mat.t(), orig_weight.to(butterfly_oft_mat.dtype))
+                orig_weight = torch.transpose(orig_weight, 0, 1)
+
+                self.set_base_weight((orig_weight * (1 / boft_s)).to(orig_dtype))
+
+    def get_delta_weight(self, adapter) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Compute the delta weight for the given adapter.
+
+        Args:
+            adapter (str):
+                The name of the adapter for which the delta weight should be computed.
+        """
+        boft_R = self.boft_R[adapter]
+        boft_s = self.boft_s[adapter]
+
+        N, D, H, _ = boft_R.shape
+        boft_R = boft_R.view(N * D, H, H)
+        orth_rotate_butterfly = self.cayley_batch(boft_R)
+        orth_rotate_butterfly = orth_rotate_butterfly.view(N, D, H, H)
+        if self.fbd_cuda_available:
+            block_diagonal_butterfly = FastBlockDiag.apply(orth_rotate_butterfly)
+        else:
+            orth_rotate_butterfly = orth_rotate_butterfly.squeeze(0)
+            block_diagonal_butterfly = torch.block_diag(*torch.unbind(orth_rotate_butterfly))
+            block_diagonal_butterfly = block_diagonal_butterfly.unsqueeze(0)
+
+        boft_P = self.boft_P.to(block_diagonal_butterfly.device, block_diagonal_butterfly.dtype)
+        butterfly_oft_mat_batch = torch.bmm(block_diagonal_butterfly, boft_P.permute(0, 2, 1))
+        butterfly_oft_mat_batch = torch.bmm(boft_P, butterfly_oft_mat_batch)
+        butterfly_oft_mat = butterfly_oft_mat_batch[0]
+
+        for i in range(1, butterfly_oft_mat_batch.shape[0]):
+            butterfly_oft_mat = butterfly_oft_mat_batch[i] @ butterfly_oft_mat
+
+        return butterfly_oft_mat, boft_s
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        previous_dtype = x.dtype
+
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            boft_rotation = torch.eye(self.in_features, device=x.device, dtype=previous_dtype)
+            boft_scale = torch.ones((int(self.out_features), 1), device=x.device, dtype=previous_dtype)
+
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.boft_R.keys():
+                    continue
+                boft_R = self.boft_R[active_adapter]
+                boft_s = self.boft_s[active_adapter]
+                dropout = self.boft_dropout[active_adapter]
+
+                N, D, H, _ = boft_R.shape
+                boft_R = boft_R.view(N * D, H, H)
+                orth_rotate_butterfly = self.cayley_batch(boft_R)
+                orth_rotate_butterfly = orth_rotate_butterfly.view(N, D, H, H)
+                orth_rotate_butterfly = dropout(orth_rotate_butterfly)
+                if self.fbd_cuda_available:
+                    block_diagonal_butterfly = FastBlockDiag.apply(orth_rotate_butterfly)
+                else:
+                    orth_rotate_butterfly = orth_rotate_butterfly.squeeze(0)
+                    block_diagonal_butterfly = torch.block_diag(*torch.unbind(orth_rotate_butterfly))
+                    block_diagonal_butterfly = block_diagonal_butterfly.unsqueeze(0)
+
+                # The BOFT author's cayley_batch, dropout and FastBlockDiag ONLY return fp32 outputs.
+                boft_P = self.boft_P.to(x)
+                block_diagonal_butterfly = block_diagonal_butterfly.to(x)
+                butterfly_oft_mat_batch = torch.bmm(block_diagonal_butterfly, boft_P.permute(0, 2, 1))
+                butterfly_oft_mat_batch = torch.bmm(boft_P, butterfly_oft_mat_batch)
+                butterfly_oft_mat = butterfly_oft_mat_batch[0]
+
+                for i in range(1, butterfly_oft_mat_batch.shape[0]):
+                    butterfly_oft_mat = butterfly_oft_mat_batch[i] @ butterfly_oft_mat
+
+                boft_rotation = butterfly_oft_mat @ boft_rotation
+                boft_scale = boft_s * boft_scale
+
+            boft_rotation = boft_rotation.to(previous_dtype)
+            x_rotated = x @ boft_rotation
+
+            result = self.base_layer(x_rotated, *args, **kwargs)
+            bias = self.base_layer.bias
+            if bias is not None:
+                result = result - bias
+            result = result * boft_scale.squeeze(-1)
+            if bias is not None:
+                result = result + bias
+
+        result = result.to(previous_dtype)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "boft." + rep
+
+    def extra_repr(self) -> str:
+        return quantization_extra_repr(self)
+
+
+class Conv2d(nn.Module, BOFTLayer):
+    """
+    BOFT implemented in a Conv2d layer.
+    """
+
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        adapter_name: str,
+        config: BOFTConfig,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        BOFTLayer.__init__(self, base_layer)
+
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, config=config)
+
+    def update_layer(
+        self,
+        adapter_name: str,
+        config: BOFTConfig,
+        **kwargs,
+    ):
+        """
+        Update the conv2d layer with trainable BOFT weights.
+        """
+        boft_block_size = config.boft_block_size
+        boft_block_num = config.boft_block_num
+        boft_n_butterfly_factor = config.boft_n_butterfly_factor
+        boft_dropout = config.boft_dropout
+        init_weights = config.init_weights
+        inference_mode = config.inference_mode
+
+        # Attempt to load the CUDA extension during model initialization
+        if not get_fbd_cuda():
+            self.fbd_cuda_available = False
+            # If the CUDA extension is not available, set the butterfly factor to 1 to speed up the finetuning process
+            boft_n_butterfly_factor = 1
+        else:
+            self.fbd_cuda_available = True
+
+        # to be consistent with the paper notation
+        boft_n_butterfly_factor = boft_n_butterfly_factor - 1
+        if boft_n_butterfly_factor < 0:
+            raise ValueError(
+                f"You can only specify boft_n_butterfly_factor {boft_n_butterfly_factor + 1} to be a positive integer number."
+            )
+
+        # Initialize the MultiplicativeDropoutLayer for boft_dropout > 0.0.
+        if boft_dropout > 0.0:
+            boft_dropout_layer = MultiplicativeDropoutLayer(p=boft_dropout)
+        else:
+            boft_dropout_layer = nn.Identity()
+        self.boft_dropout.update(nn.ModuleDict({adapter_name: boft_dropout_layer}))
+
+        # layer information from the base layer
+        base_layer = self.get_base_layer()
+        conv_filter_dim = self.in_features * base_layer.kernel_size[0] * base_layer.kernel_size[0]
+
+        # Initialize the BOFT parameters.
+        if boft_block_size == 0 and boft_block_num != 0:
+            if conv_filter_dim % boft_block_num != 0:
+                raise ValueError(
+                    f"Convolutional kernel dimension ({conv_filter_dim}) must be divisible by boft_block_num ({boft_block_num})!"
+                )
+
+            if boft_n_butterfly_factor != 0:
+                if boft_n_butterfly_factor > int(math.log2(boft_block_num)):
+                    raise ValueError(
+                        f"Invalid combination of boft_n_butterfly_factor ({boft_n_butterfly_factor + 1}) and boft_block_num ({boft_block_num})!"
+                    )
+                if boft_block_num % (2**boft_n_butterfly_factor) != 0:
+                    raise ValueError(
+                        f"boft_block_num ({boft_block_num}) must be a multiple of 2 raised to the power of boft_n_butterfly_factor ({boft_n_butterfly_factor + 1})!"
+                    )
+
+            boft_block_size = int(conv_filter_dim // boft_block_num)
+
+        elif boft_block_size != 0 and boft_block_num == 0:
+            if conv_filter_dim % boft_block_size != 0:
+                raise ValueError(
+                    f"Convolutional kernel dimension ({conv_filter_dim}) must be divisible by boft_block_size ({boft_block_size})!"
+                )
+
+            if boft_n_butterfly_factor != 0:
+                if conv_filter_dim < (boft_block_size * (2**boft_n_butterfly_factor)):
+                    raise ValueError(
+                        f"Invalid combination of convolutional kernel dimension ({conv_filter_dim}), boft_n_butterfly_factor ({boft_n_butterfly_factor + 1}) and boft_block_size ({boft_block_size})!"
+                    )
+                if conv_filter_dim % (boft_block_size * (2**boft_n_butterfly_factor)) != 0:
+                    raise ValueError(
+                        f"Invalid combination of convolutional kernel dimension ({conv_filter_dim}), boft_n_butterfly_factor ({boft_n_butterfly_factor + 1}) and boft_block_size ({boft_block_size})!"
+                    )
+
+            boft_block_num = int(conv_filter_dim // boft_block_size)
+
+        else:
+            raise ValueError(
+                "Something went wrong, please report this error: https://github.com/huggingface/peft/issues"
+            )
+
+        # In OFT you can specify the number of blocks to be 1
+        if boft_n_butterfly_factor != 0:
+            if boft_block_num % 2 != 0:
+                raise ValueError(f"boft_block_num ({boft_block_num}) must be an even number!")
+
+            if boft_block_size % 2 != 0:
+                raise ValueError(f"boft_block_size ({boft_block_size}) must be an even number!")
+
+        # If there is no butterfly factor, then permutation matrix P will be an identity matrix.
+        P = torch.empty((boft_n_butterfly_factor + 1, conv_filter_dim, conv_filter_dim))
+        for i in range(boft_n_butterfly_factor + 1):
+            perm = self.block_butterfly_perm(
+                conv_filter_dim, int(boft_block_num / (2 ** (i))), int(boft_block_size / 2), boft_n_butterfly_factor
+            )
+            perm_mat = self.perm2mat(perm)
+            P[i] = perm_mat
+
+        self.register_buffer("boft_P", P, persistent=False)
+
+        self.boft_R[adapter_name] = nn.Parameter(
+            torch.zeros(boft_n_butterfly_factor + 1, boft_block_num, boft_block_size, boft_block_size)
+        )
+        self.boft_s[adapter_name] = nn.Parameter(torch.ones(1, int(self.out_features)))
+
+        self.reset_boft_parameters(adapter_name, init_weights)
+
+        # set the boft block size and number
+        self.boft_block_size[adapter_name] = boft_block_size
+        self.boft_block_num[adapter_name] = boft_block_num
+
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.boft_R.keys():
+                base_layer = self.get_base_layer()
+                orig_weight = self.get_base_weight().clone()
+                orig_dtype = orig_weight.dtype
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    # because of the copy operation.
+                    butterfly_oft_mat, boft_s = self.get_delta_weight(active_adapter)
+
+                    orig_weight = orig_weight.view(
+                        self.out_features, self.in_features * base_layer.kernel_size[0] * base_layer.kernel_size[0]
+                    )
+                    orig_weight = torch.transpose(orig_weight, 0, 1)
+                    orig_weight = torch.mm(butterfly_oft_mat, orig_weight.to(butterfly_oft_mat.dtype))
+                    orig_weight = torch.transpose(orig_weight, 0, 1)
+                    orig_weight = orig_weight * boft_s
+                    orig_weight = orig_weight.view(
+                        self.out_features, self.in_features, base_layer.kernel_size[0], base_layer.kernel_size[0]
+                    )
+
+                    self.set_base_weight(orig_weight.contiguous().to(orig_dtype))
+                else:
+                    butterfly_oft_mat, boft_s = self.get_delta_weight(active_adapter)
+
+                    orig_weight = orig_weight.view(
+                        self.out_features, self.in_features * base_layer.kernel_size[0] * base_layer.kernel_size[0]
+                    )
+                    orig_weight = torch.transpose(orig_weight, 0, 1)
+                    orig_weight = torch.mm(butterfly_oft_mat, orig_weight.to(butterfly_oft_mat.dtype))
+                    orig_weight = torch.transpose(orig_weight, 0, 1)
+                    orig_weight = orig_weight * boft_s
+                    orig_weight = orig_weight.view(
+                        self.out_features, self.in_features, base_layer.kernel_size[0], base_layer.kernel_size[0]
+                    )
+
+                    self.set_base_weight(orig_weight.contiguous().to(orig_dtype))
+
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            base_layer = self.get_base_layer()
+            if active_adapter in self.boft_R.keys():
+                butterfly_oft_mat, boft_s = self.get_delta_weight(active_adapter)
+
+                orig_weight = self.get_base_weight().clone()
+                orig_dtype = orig_weight.dtype
+                orig_weight = orig_weight.view(
+                    self.out_features,
+                    self.in_features * base_layer.kernel_size[0] * base_layer.kernel_size[0],
+                )
+                orig_weight = torch.transpose(orig_weight, 0, 1)
+                orig_weight = torch.mm(butterfly_oft_mat.t(), orig_weight.to(butterfly_oft_mat.dtype))
+                orig_weight = torch.transpose(orig_weight, 0, 1)
+                orig_weight = orig_weight * (1 / boft_s)
+                orig_weight = orig_weight.view(
+                    self.out_features,
+                    self.in_features,
+                    base_layer.kernel_size[0],
+                    base_layer.kernel_size[0],
+                )
+
+                self.set_base_weight(orig_weight.to(orig_dtype))
+
+    def get_delta_weight(self, adapter) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Compute the delta weight for the given adapter.
+
+        Args:
+            adapter (str):
+                The name of the adapter for which the delta weight should be computed.
+        """
+
+        boft_R = self.boft_R[adapter]
+        boft_s = self.boft_s[adapter].transpose(0, 1)
+
+        N, D, H, _ = boft_R.shape
+        boft_R = boft_R.view(N * D, H, H)
+        orth_rotate_butterfly = self.cayley_batch(boft_R)
+        orth_rotate_butterfly = orth_rotate_butterfly.view(N, D, H, H)
+        if self.fbd_cuda_available:
+            block_diagonal_butterfly = FastBlockDiag.apply(orth_rotate_butterfly)
+        else:
+            orth_rotate_butterfly = orth_rotate_butterfly.squeeze(0)
+            block_diagonal_butterfly = torch.block_diag(*torch.unbind(orth_rotate_butterfly))
+            block_diagonal_butterfly = block_diagonal_butterfly.unsqueeze(0)
+
+        boft_P = self.boft_P.to(block_diagonal_butterfly.device, block_diagonal_butterfly.dtype)
+        butterfly_oft_mat_batch = torch.bmm(block_diagonal_butterfly, boft_P.permute(0, 2, 1))
+        butterfly_oft_mat_batch = torch.bmm(boft_P, butterfly_oft_mat_batch)
+        butterfly_oft_mat = butterfly_oft_mat_batch[0]
+
+        for i in range(1, butterfly_oft_mat_batch.shape[0]):
+            butterfly_oft_mat = butterfly_oft_mat_batch[i] @ butterfly_oft_mat
+
+        return butterfly_oft_mat, boft_s
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        previous_dtype = x.dtype
+
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            boft_rotation = torch.eye(
+                self.in_features * self.base_layer.kernel_size[0] * self.base_layer.kernel_size[0],
+                device=x.device,
+                dtype=x.dtype,
+            )
+            boft_scale = torch.ones((int(self.out_features), 1), device=x.device, dtype=x.dtype)
+
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.boft_R.keys():
+                    continue
+                boft_R = self.boft_R[active_adapter]
+                boft_s = self.boft_s[active_adapter].transpose(0, 1)
+                dropout = self.boft_dropout[active_adapter]
+
+                N, D, H, _ = boft_R.shape
+                boft_R = boft_R.view(N * D, H, H)
+                orth_rotate_butterfly = self.cayley_batch(boft_R)
+                orth_rotate_butterfly = orth_rotate_butterfly.view(N, D, H, H)
+                orth_rotate_butterfly = dropout(orth_rotate_butterfly)
+                if self.fbd_cuda_available:
+                    block_diagonal_butterfly = FastBlockDiag.apply(orth_rotate_butterfly)
+                else:
+                    orth_rotate_butterfly = orth_rotate_butterfly.squeeze(0)
+                    block_diagonal_butterfly = torch.block_diag(*torch.unbind(orth_rotate_butterfly))
+                    block_diagonal_butterfly = block_diagonal_butterfly.unsqueeze(0)
+
+                boft_P = self.boft_P.to(x)
+                block_diagonal_butterfly = block_diagonal_butterfly.to(x)
+                butterfly_oft_mat_batch = torch.bmm(block_diagonal_butterfly, boft_P.permute(0, 2, 1))
+                butterfly_oft_mat_batch = torch.bmm(boft_P, butterfly_oft_mat_batch)
+                butterfly_oft_mat = butterfly_oft_mat_batch[0]
+
+                for i in range(1, butterfly_oft_mat_batch.shape[0]):
+                    butterfly_oft_mat = butterfly_oft_mat_batch[i] @ butterfly_oft_mat
+
+                boft_rotation = butterfly_oft_mat @ boft_rotation
+                boft_scale = boft_s * boft_scale
+
+            orig_weight = self.get_base_weight()
+            x = x.to(orig_weight.dtype)
+
+            orig_weight = orig_weight.view(
+                self.out_features,
+                self.in_features * self.base_layer.kernel_size[0] * self.base_layer.kernel_size[0],
+            )
+            orig_weight = torch.transpose(orig_weight, 0, 1)
+            rotated_weight = torch.mm(boft_rotation, orig_weight)
+            rotated_weight = torch.transpose(rotated_weight, 0, 1)
+
+            scaled_rotated_weight = rotated_weight * boft_scale
+
+            scaled_rotated_weight = scaled_rotated_weight.view(
+                self.out_features, self.in_features, self.base_layer.kernel_size[0], self.base_layer.kernel_size[0]
+            )
+            x = self._cast_input_dtype(x, scaled_rotated_weight.dtype)
+            bias = self._cast_input_dtype(self.base_layer.bias, scaled_rotated_weight.dtype)
+            result = F.conv2d(
+                input=x,
+                weight=scaled_rotated_weight,
+                bias=bias,
+                padding=self.base_layer.padding[0],
+                stride=self.base_layer.stride[0],
+            )
+
+        result = result.to(previous_dtype)
+        return result
+
+    def extra_repr(self) -> str:
+        return quantization_extra_repr(self)
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "boft." + rep
diff --git a/src/peft/tuners/boft/model.py b/src/peft/tuners/boft/model.py
new file mode 100644
index 0000000..80f546a
--- /dev/null
+++ b/src/peft/tuners/boft/model.py
@@ -0,0 +1,141 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+# The implementation is based on "Parameter-Efficient Orthogonal Finetuning
+# via Butterfly Factorization" (https://huggingface.co/papers/2311.06243) in ICLR 2024.
+
+import warnings
+
+import torch
+
+from peft.tuners.tuners_utils import (
+    BaseTuner,
+    BaseTunerLayer,
+)
+from peft.utils import (
+    TRANSFORMERS_MODELS_TO_BOFT_TARGET_MODULES_MAPPING,
+    get_quantization_kwargs,
+    resolve_quantization_backend,
+)
+
+from .layer import BOFTLayer, Conv2d, Linear
+
+
+def _get_tuner_layer_class(target_base_layer: torch.nn.Module) -> type[BOFTLayer] | None:
+    layer_cls: type[BOFTLayer] | None = None
+    if isinstance(target_base_layer, torch.nn.Linear):
+        layer_cls = Linear
+    elif isinstance(target_base_layer, torch.nn.Conv2d):
+        layer_cls = Conv2d
+    elif (quant_backend := resolve_quantization_backend(target_base_layer)) is not None:
+        layer_cls = {"linear": Linear, "conv2d": Conv2d}.get(quant_backend.layer_type)
+
+    return layer_cls
+
+
+class BOFTModel(BaseTuner):
+    """
+    Creates BOFT and OFT model from a pretrained transformers model. Paper: https://huggingface.co/papers/2311.06243
+    https://huggingface.co/papers/2306.07280
+
+    Args:
+        model ([`transformers.PreTrainedModel`]): The model to be adapted.
+        config ([`BOFTConfig`]): The configuration of the BOFT model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            Create empty adapter weights on meta device. Useful to speed up the loading process.
+
+    Returns:
+        `torch.nn.Module`: The BOFT model.
+
+    Example:
+        ```py
+        >>> import transformers
+        >>> from peft import BOFTConfig, get_peft_model
+
+        >>> config = BOFTConfig(
+        ...     boft_block_size=8,
+        ...     boft_n_butterfly_factor=1,
+        ...     target_modules=["query", "value", "key", "output.dense", "mlp.fc1", "mlp.fc2"],
+        ...     boft_dropout=0.1,
+        ...     bias="boft_only",
+        ...     modules_to_save=["classifier"],
+        ... )
+
+        >>> model = transformers.Dinov2ForImageClassification.from_pretrained(
+        ...     "facebook/dinov2-large",
+        ...     num_labels=100,
+        ... )
+        >>> boft_model = get_peft_model(model, config)
+        ```
+
+    **Attributes**:
+        - **model** ([`transformers.PreTrainedModel`]) -- The model to be adapted.
+        - **peft_config** ([`BOFTConfig`]): The configuration of the BOFT model.
+    """
+
+    prefix: str = "boft_"
+    tuner_layer_cls = BOFTLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_BOFT_TARGET_MODULES_MAPPING
+
+    def _create_and_replace(
+        self,
+        boft_config,
+        adapter_name,
+        target,
+        target_name,
+        parent,
+        current_key,
+        **optional_kwargs,
+    ):
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+
+        kwargs = get_quantization_kwargs(self)
+
+        # If it is not a BOFTLayer, create a new module, else update it with new adapters
+        if not isinstance(target, BOFTLayer):
+            new_module = self._create_new_module(boft_config, adapter_name, target, **kwargs)
+            if adapter_name not in self.active_adapters:
+                # adding an additional adapter: it is not automatically trainable
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+        else:
+            target.update_layer(
+                adapter_name,
+                config=boft_config,
+            )
+
+    @staticmethod
+    def _create_new_module(boft_config, adapter_name, target, **kwargs):
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        layer_cls = _get_tuner_layer_class(target_base_layer)
+        if layer_cls is None:
+            raise TypeError(
+                f"Target module {target} is not supported. Currently, only `torch.nn.Linear` and `torch.nn.Conv2d` (optionally quantized) "
+                "are supported."
+            )
+
+        if (layer_cls == Linear) and boft_config.fan_in_fan_out:
+            warnings.warn(
+                "fan_in_fan_out is set to True but the target module is `torch.nn.Linear`. "
+                "Setting fan_in_fan_out to False."
+            )
+            boft_config.fan_in_fan_out = False
+        new_module = layer_cls(target, adapter_name, config=boft_config, **kwargs)
+        return new_module
diff --git a/src/peft/tuners/c3a/__init__.py b/src/peft/tuners/c3a/__init__.py
new file mode 100644
index 0000000..ba8a7cb
--- /dev/null
+++ b/src/peft/tuners/c3a/__init__.py
@@ -0,0 +1,23 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+from peft.utils import register_peft_method
+
+from .config import C3AConfig
+from .layer import C3ALayer, C3ALinear
+from .model import C3AModel
+
+
+__all__ = ["C3AConfig", "C3ALayer", "C3ALinear", "C3AModel"]
+
+register_peft_method(name="c3a", model_cls=C3AModel, config_cls=C3AConfig)
diff --git a/src/peft/tuners/c3a/config.py b/src/peft/tuners/c3a/config.py
new file mode 100644
index 0000000..2059c77
--- /dev/null
+++ b/src/peft/tuners/c3a/config.py
@@ -0,0 +1,137 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal, Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class C3AConfig(PeftConfig):
+    """This is the configuration class to store the configuration of a [`C3AModel`].
+
+    Args:
+        block_size (`int`):
+            block size for C3A, must be divisible by both the input size and the output size of the target layer. If
+            you have no idea what block_size you should use, set it to the greatest common divisor of all input &
+            output sizes of your target layers. Increasing this would result in less parameters.
+        target_modules (`Union[list[str],str]`): The names of the modules to apply C3A to.
+        bias (`str`): Bias type for C3A. Can be 'none', 'all' or 'c3a_only'. If 'all' or 'c3a_only', the
+            corresponding biases will be updated during training. Be aware that this means that, even when disabling
+            the adapters, the model will not produce the same output as the base model would have without adaptation.
+        modules_to_save (`list[str]`):list of modules apart from C3A layers to be set as trainable
+            and saved in the final checkpoint.
+        layers_to_transform (`Union[list[int],int]`):
+            The layer indexes to transform, if this argument is specified, it will apply C3A on the layer indexes that
+            are specified in this list. If a single integer is passed, it will apply C3A on the layer at this index.
+        layers_pattern (`str`):
+            The layer pattern name, used only if `layers_to_transform` is different from `None` and if the layer
+            pattern is not in the common layers pattern.
+        block_size_pattern (`dict`):
+            The mapping from layer names or regexp expression to block_size which are different from the default
+            specified. For example, `{"model.decoder.layers.0.encoder_attn.k_proj": 1280`}
+        init_weights (`Union[bool, Literal["gaussian", "kaiming_uniform", "xavier_uniform"]]`):
+            Defaults to 'xavier_uniform'. Setting this to `False` also uses 'xavier_uniform'. To set the weights to
+            zeros (thus making C3A a no-op), set the value to `True`.
+    """
+
+    block_size: int = field(
+        default=256,
+        metadata={
+            "help": (
+                "block size for C3A, must be divisible by both the input size and the output size of the target layer."
+                " If you have no idea what block_size you should use, set it to the greatest common divisor of all"
+                " input & output sizes of your target layers. Increasing this would result in less parameters."
+            )
+        },
+    )
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "list of module names or regex expression of the module names to replace with C3A."
+                " For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$' "
+            )
+        },
+    )
+    bias: str = field(default="none", metadata={"help": "Bias type for C3A. Can be 'none', 'all' or 'c3a_only'"})
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "list of modules apart from C3A layers to be set as trainable and saved in the final checkpoint."
+                " For example, in Sequence Classification or Token Classification tasks,"
+                " the final layer `classifier/score` are randomly initialized"
+                " and as such need to be trainable and saved."
+            )
+        },
+    )
+    layers_to_transform: Optional[Union[list[int], int]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The layer indexes to transform, is this argument is specified,"
+                " PEFT will transform only the layers indexes that are specified inside this list."
+                " If a single integer is passed, PEFT will transform only the layer at this index."
+                " This only works when target_modules is a list of str."
+            )
+        },
+    )
+    layers_pattern: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The layer pattern name, used only if `layers_to_transform` is different to None"
+                " and if the layer pattern is not in the common layers pattern."
+                " This only works when target_modules is a list of str."
+            )
+        },
+    )
+    block_size_pattern: Optional[dict] = field(
+        default_factory=dict,
+        metadata={
+            "help": (
+                "The mapping from layer names or regexp expression to block_size"
+                " which are different from the default specified."
+                " For example, `{model.decoder.layers.0.encoder_attn.k_proj: 1280`}"
+            )
+        },
+    )
+    init_weights: Optional[Union[bool, Literal["gaussian", "kaiming_uniform", "xavier_uniform"]]] = field(
+        default="xavier_uniform",
+        metadata={
+            "help": (
+                "Defaults to 'xavier_uniform'. Setting this to `False` also uses 'xavier_uniform'. To set the weights "
+                "to zeros (thus making C3A a no-op), set the value to `True`."
+            )
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.C3A
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        # if target_modules is a regex expression, then layers_to_transform should be None
+        if isinstance(self.target_modules, str) and self.layers_to_transform is not None:
+            raise ValueError("`layers_to_transform` cannot be used when `target_modules` is a str.")
+
+        # if target_modules is a regex expression, then layers_pattern should be None
+        if isinstance(self.target_modules, str) and self.layers_pattern is not None:
+            raise ValueError("`layers_pattern` cannot be used when `target_modules` is a str.")
diff --git a/src/peft/tuners/c3a/layer.py b/src/peft/tuners/c3a/layer.py
new file mode 100644
index 0000000..ee12489
--- /dev/null
+++ b/src/peft/tuners/c3a/layer.py
@@ -0,0 +1,209 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import math
+import warnings
+from typing import Any, Optional
+
+import torch
+from torch import nn
+
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+
+from .config import C3AConfig
+from .utils import BlockCircularConvolution, get_circulant_fast
+
+
+class C3ALayer(BaseTunerLayer):
+    # All names of layers that may contain (trainable) adapter weights
+    adapter_layer_names = ("c3a_kernel",)
+    # All names of other parameters that may contain adapter-related parameters
+    other_param_names = ("block_size",)
+
+    def __init__(self, base_layer: nn.Module, **kwargs) -> None:
+        self.base_layer = base_layer
+        self.block_size = {}
+        self.c3a_kernel = nn.ParameterDict({})
+        # Mark the weight as unmerged
+        self._disable_adapters = False
+        self.merged_adapters = []
+        self.kwargs = kwargs
+
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            self.in_features, self.out_features = base_layer.in_features, base_layer.out_features
+        else:
+            raise TypeError(f"Unsupported layer type {type(base_layer)}")
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        if adapter not in self.c3a_kernel.keys():
+            raise ValueError(f"Adapter {adapter} not found.")
+        base_layer_weight = self.get_base_layer().weight
+        base_layer_weight_dtype = base_layer_weight.dtype
+        c3a_kernel = self.c3a_kernel[adapter]
+
+        delta_weight = get_circulant_fast(c3a_kernel.to(torch.float32)).to(base_layer_weight_dtype)
+        return delta_weight / base_layer_weight.size(-1)
+
+    def update_layer(self, adapter_name: str, block_size: int, config: C3AConfig, **kwargs):
+        init_weights = config.init_weights
+        inference_mode = config.inference_mode
+
+        if block_size <= 0:
+            raise ValueError(f"`block_size` should be a positive integer value but the value passed is {block_size}")
+        if self.in_features % block_size != 0:
+            raise ValueError(
+                f"The block size should be a factor of the input size. However, the input size is {self.in_features} and the block size is {block_size}"
+            )
+        if self.out_features % block_size != 0:
+            raise ValueError(
+                f"The block size should be a factor of the output size. However, the output size is {self.out_features} and the block size is {block_size}"
+            )
+
+        self.block_size[adapter_name] = block_size
+
+        weight = self.get_base_layer().weight
+        self.c3a_kernel[adapter_name] = nn.Parameter(
+            torch.zeros(
+                self.out_features // block_size,
+                self.in_features // block_size,
+                block_size,
+                # Currently, only fp32 is widely supported for FFT (fp16 is only supported on GPU with shapes of powers
+                # of 2, bf16 lacks FFT support)
+                dtype=torch.float32,
+                device=weight.device,
+            )
+        )
+
+        self.reset_c3a_parameters(adapter_name, init_weights)
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    @torch.no_grad()
+    def reset_c3a_parameters(self, adapter_name, init_weights):
+        if init_weights is True:
+            return
+
+        if adapter_name in self.c3a_kernel.keys():
+            if init_weights == "gaussian":
+                nn.init.normal_(self.c3a_kernel[adapter_name])
+            elif init_weights in ["xavier_uniform", False]:
+                fan_in, fan_out = self.in_features, self.out_features
+                std = 1.0 * math.sqrt(2.0 / float(fan_in + fan_out))
+                a = math.sqrt(3.0) * std
+                nn.init.uniform_(self.c3a_kernel[adapter_name], -a, a)
+            elif init_weights == "kaiming_uniform":
+                fan_in = self.in_features
+                a = 1.0 * math.sqrt(1.0 / float(fan_in))
+                nn.init.uniform_(self.c3a_kernel[adapter_name], -a, a)
+            else:
+                raise ValueError(f"Unknown init_weights: {init_weights}")
+
+
+class C3ALinear(nn.Module, C3ALayer):
+    # Lora implemented in a dense layer
+    def __init__(
+        self,
+        base_layer,
+        adapter_name: str,
+        config: C3AConfig,
+        block_size: int,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        C3ALayer.__init__(self, base_layer, **kwargs)
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, block_size, config=config)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`list[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.c3a_kernel.keys():
+                base_layer = self.get_base_layer()
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    # because of the copy operation.
+                    orig_weights = base_layer.weight.data.clone()
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    orig_weights = orig_weights + delta_weight
+
+                    if not torch.isfinite(orig_weights).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = orig_weights
+                else:
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    base_layer.weight.data = base_layer.weight.data + delta_weight
+
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.c3a_kernel.keys():
+                self.get_base_layer().weight.data -= self.get_delta_weight(active_adapter)
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        previous_dtype = x.dtype
+
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+            x = x.to(torch.float32)
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.c3a_kernel.keys():
+                    continue
+                c3a_kernel = self.c3a_kernel[active_adapter].to(torch.float32)
+                x = BlockCircularConvolution.apply(x, c3a_kernel) / x.size(-1)
+                result += x.to(result.dtype)
+
+        result = result.to(previous_dtype)
+        return result
+
+    def supports_lora_conversion(self, adapter_name: str = "default") -> bool:
+        return True
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "c3a." + rep
diff --git a/src/peft/tuners/c3a/model.py b/src/peft/tuners/c3a/model.py
new file mode 100644
index 0000000..cb946df
--- /dev/null
+++ b/src/peft/tuners/c3a/model.py
@@ -0,0 +1,100 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import re
+from itertools import chain
+
+import torch
+
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer
+from peft.utils import (
+    TRANSFORMERS_MODELS_TO_C3A_TARGET_MODULES_MAPPING,
+)
+
+from .layer import C3ALayer, C3ALinear
+
+
+class C3AModel(BaseTuner):
+    """
+    Creates C3A model from a pretrained transformers model.
+
+    The method is described in detail in https://huggingface.co/papers/2407.19342.
+
+    Args:
+        model ([`torch.nn.Module`]): The model to be adapted.
+        config ([`C3AConfig`]): The configuration of the C3A model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+
+    Returns:
+        `torch.nn.Module`: The C3A model.
+
+    **Attributes**:
+        - **model** ([`~transformers.PreTrainedModel`]) -- The model to be adapted.
+        - **peft_config** ([`C3AConfig`]): The configuration of the C3A model.
+    """
+
+    prefix: str = "c3a_"
+    tuner_layer_cls = C3ALayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_C3A_TARGET_MODULES_MAPPING
+
+    def _create_and_replace(
+        self,
+        c3a_config,
+        adapter_name,
+        target,
+        target_name,
+        parent,
+        current_key,
+        **optional_kwargs,
+    ):
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+        # Regexp matching - Find key which matches current target_name in patterns provided
+        pattern_keys = list(chain(c3a_config.block_size_pattern.keys()))
+        target_name_key = next(filter(lambda key: re.match(rf".*\.{key}$", current_key), pattern_keys), current_key)
+
+        block_size = c3a_config.block_size_pattern.get(target_name_key, c3a_config.block_size)
+        kwargs = {
+            "block_size": block_size,
+        }
+
+        if isinstance(target, C3ALinear):
+            target.update_layer(
+                adapter_name,
+                block_size,
+                config=c3a_config,
+            )
+        else:
+            new_module = self._create_new_module(c3a_config, adapter_name, target, **kwargs)
+            if adapter_name != self.active_adapter:
+                # adding an additional adapter: it is not automatically trainable
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+    @staticmethod
+    def _create_new_module(c3a_config, adapter_name, target, **kwargs):
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        if isinstance(target_base_layer, torch.nn.Linear):
+            new_module = C3ALinear(target, adapter_name, config=c3a_config, **kwargs)
+        else:
+            raise TypeError(
+                f"Target module {target} is not supported. Currently, only `torch.nn.Linear` is supported."
+            )
+
+        return new_module
diff --git a/src/peft/tuners/c3a/utils.py b/src/peft/tuners/c3a/utils.py
new file mode 100644
index 0000000..7ad3bc5
--- /dev/null
+++ b/src/peft/tuners/c3a/utils.py
@@ -0,0 +1,48 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+import torch
+from torch.autograd import Function
+from torch.fft import fft, ifft
+
+
+def get_circulant_fast(w):
+    _, n, b = w.shape
+    x = torch.eye(n * b, dtype=w.dtype, device=w.device)
+    x = x.reshape(*x.shape[:-1], n, b)
+    x = torch.einsum("...nb,mnb->...mb", ifft(x), fft(w))
+    x = fft(x).real.flatten(start_dim=1).T
+    return x
+
+
+class BlockCircularConvolution(Function):
+    @staticmethod
+    def forward(ctx, x, w):
+        _, n, b = w.shape
+        x = x.reshape(*x.shape[:-1], n, b)
+        ctx.save_for_backward(x, w)
+        x = torch.einsum("...nb,mnb->...mb", ifft(x), fft(w))
+        x = fft(x).real
+        x = x.reshape(*x.shape[:-2], -1)
+        return x
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        x, w = ctx.saved_tensors
+        m, _, b = w.shape
+        grad_output = grad_output.reshape(*grad_output.shape[:-1], m, b)
+        grad_output_fft = fft(grad_output)
+        x_grad = fft(torch.einsum("...mb,mnb->...nb", grad_output_fft, ifft(w))).real
+        x_grad = x_grad.reshape(*x_grad.shape[:-2], -1)
+        w_grad = fft(torch.einsum("...mb,...nb->mnb", grad_output_fft, ifft(x))).real
+        return x_grad, w_grad
diff --git a/src/peft/tuners/cartridge/__init__.py b/src/peft/tuners/cartridge/__init__.py
new file mode 100644
index 0000000..78ecfa0
--- /dev/null
+++ b/src/peft/tuners/cartridge/__init__.py
@@ -0,0 +1,23 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from peft.utils import register_peft_method
+
+from .config import CartridgeConfig
+from .model import CartridgeEncoder
+
+
+__all__ = ["CartridgeConfig", "CartridgeEncoder"]
+
+register_peft_method(name="cartridge", config_cls=CartridgeConfig, model_cls=CartridgeEncoder)
diff --git a/src/peft/tuners/cartridge/config.py b/src/peft/tuners/cartridge/config.py
new file mode 100644
index 0000000..1eba07f
--- /dev/null
+++ b/src/peft/tuners/cartridge/config.py
@@ -0,0 +1,74 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from dataclasses import dataclass, field
+
+from peft.config import PromptLearningConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class CartridgeConfig(PromptLearningConfig):
+    """
+    Configuration for CARTRIDGE, a KV-cache-parameterized prefix adapter.
+
+    This is similar to prefix-tuning in how it is served (as `past_key_values`), but it stores the KV cache directly as
+    trainable parameters instead of learning it via an MLP projection.
+
+    Initialization:
+        The Cartridges paper discusses multiple initialization options. In PEFT, initialization is a *separate* step
+        from constructing the adapter config:
+
+        - **Random KV initialization (paper option 2)**: Create the adapter via `get_peft_model(...)`. The CARTRIDGE
+          prompt encoder parameters are randomly initialized by PyTorch.
+
+        - **KV derived from the first tokens of a prompt/corpus (paper option 3)**: Run a no-grad prefill on the *base
+          model* and copy the first `num_virtual_tokens` cached KV tokens into the adapter. PEFT provides utilities for
+          this (importable from `peft` or from `peft.tuners.cartridge.utils`):
+
+          - `initialize_kv_prefix_from_text(model, tokenizer, text=...)`
+          - `initialize_kv_prefix_from_past_key_values(model, past_key_values=...)`
+
+          If you already have a flattened KV-prefix tensor, you can load it directly via the prompt encoder’s
+          `load_prompt_embeddings(...)` method.
+
+    Args:
+        num_frozen_tokens (`int`, defaults to 1):
+            Number of *prefix* tokens at the start of the cartridge to keep frozen (no gradients). The Cartridges paper
+            recommends freezing the first token as an attention sink for stability (set this to `1`), as many LLMs use
+            early tokens as attention sinks and changing them can harm training.
+    """
+
+    num_frozen_tokens: int = field(
+        default=1,
+        metadata={
+            "help": (
+                "Number of initial virtual tokens to freeze (no gradients). The paper recommends freezing the first "
+                "token as an attention sink for stability."
+            )
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        if self.num_frozen_tokens < 0:
+            raise ValueError(f"`num_frozen_tokens` must be >= 0, got {self.num_frozen_tokens}.")
+        # `num_virtual_tokens` is required for prompt-learning configs. Validate the relationship early for a clearer
+        # error, even if the encoder also checks it.
+        if (self.num_virtual_tokens is not None) and (self.num_frozen_tokens > self.num_virtual_tokens):
+            raise ValueError(
+                f"`num_frozen_tokens` must be <= `num_virtual_tokens`, got num_frozen_tokens={self.num_frozen_tokens} "
+                f"and num_virtual_tokens={self.num_virtual_tokens}."
+            )
+        self.peft_type = PeftType.CARTRIDGE
diff --git a/src/peft/tuners/cartridge/model.py b/src/peft/tuners/cartridge/model.py
new file mode 100644
index 0000000..bd0ad07
--- /dev/null
+++ b/src/peft/tuners/cartridge/model.py
@@ -0,0 +1,116 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+import torch
+
+
+class CartridgeEncoder(torch.nn.Module):
+    """
+    A parameterized prefix KV cache.
+
+    The parameters are stored in the same flattened layout as `PrefixEncoder` output: `[num_virtual_tokens, num_layers
+    * 2 * token_dim]`, where `token_dim` is per-head hidden size times number of heads (after any GQA adjustment
+    performed by `_prepare_prompt_learning_config`).
+
+    If `num_frozen_tokens > 0`, the first `num_frozen_tokens` virtual tokens are stored as a non-trainable parameter,
+    and the remaining tokens are trainable.
+    """
+
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+
+        num_virtual_tokens = config.num_virtual_tokens
+        hidden = config.num_layers * 2 * config.token_dim
+        num_frozen_tokens = int(config.num_frozen_tokens)
+        if num_frozen_tokens < 0 or num_frozen_tokens > num_virtual_tokens:
+            raise ValueError(
+                f"`num_frozen_tokens` must be in [0, num_virtual_tokens], got {num_frozen_tokens} for "
+                f"num_virtual_tokens={num_virtual_tokens}."
+            )
+
+        self.num_frozen_tokens = num_frozen_tokens
+        self.num_trainable_tokens = num_virtual_tokens - num_frozen_tokens
+
+        if self.num_frozen_tokens:
+            frozen = torch.empty(self.num_frozen_tokens, hidden)
+            self.frozen_embedding = torch.nn.Parameter(frozen, requires_grad=False)
+        else:
+            self.frozen_embedding = None
+
+        trainable = torch.empty(self.num_trainable_tokens, hidden)
+        self.trainable_embedding = torch.nn.Parameter(trainable, requires_grad=not config.inference_mode)
+
+        self.reset_parameters()
+
+    @property
+    def embedding(self):
+        """
+        Expose a prefix-encoder compatible interface (`.embedding.weight`) for PEFT internals.
+        """
+
+        class _Proxy(torch.nn.Module):
+            def __init__(self, parent: CartridgeEncoder):
+                super().__init__()
+                self._parent = parent
+
+            @property
+            def weight(self):
+                return self._parent.weight
+
+        return _Proxy(self)
+
+    @property
+    def weight(self) -> torch.Tensor:
+        if self.frozen_embedding is None:
+            return self.trainable_embedding
+        return torch.cat([self.frozen_embedding, self.trainable_embedding], dim=0)
+
+    def reset_parameters(self):
+        # Match `torch.nn.Embedding` initialization (normal with std=1).
+        with torch.no_grad():
+            if self.frozen_embedding is not None:
+                torch.nn.init.normal_(self.frozen_embedding)
+            torch.nn.init.normal_(self.trainable_embedding)
+
+    def load_prompt_embeddings(self, prompt_embeddings: torch.Tensor) -> None:
+        """
+        Load the flattened prompt embeddings saved by PEFT (`prompt_embeddings`).
+
+        PEFT saves prompt-learning adapters as a single `prompt_embeddings` tensor. For CARTRIDGE, we split that tensor
+        into frozen and trainable segments according to `self.num_frozen_tokens`.
+        """
+        if prompt_embeddings.ndim != 2 or prompt_embeddings.shape[0] != (
+            self.num_frozen_tokens + self.num_trainable_tokens
+        ):
+            raise ValueError(
+                "Invalid `prompt_embeddings` shape. Expected "
+                f"({self.num_frozen_tokens + self.num_trainable_tokens}, hidden), got {tuple(prompt_embeddings.shape)}."
+            )
+        with torch.no_grad():
+            if self.frozen_embedding is not None:
+                self.frozen_embedding.copy_(
+                    prompt_embeddings[: self.num_frozen_tokens].to(self.frozen_embedding.device)
+                )
+                trainable_part = prompt_embeddings[self.num_frozen_tokens :]
+            else:
+                trainable_part = prompt_embeddings
+            self.trainable_embedding.copy_(trainable_part.to(self.trainable_embedding.device))
+
+    def forward(self, prefix_tokens: torch.Tensor) -> torch.Tensor:
+        batch_size = prefix_tokens.shape[0]
+        # Ignore token ids; they exist for prompt-learning uniformity.
+        return self.weight.unsqueeze(0).expand(batch_size, -1, -1)
diff --git a/src/peft/tuners/cartridge/utils.py b/src/peft/tuners/cartridge/utils.py
new file mode 100644
index 0000000..57b22e2
--- /dev/null
+++ b/src/peft/tuners/cartridge/utils.py
@@ -0,0 +1,237 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import replace
+from pathlib import Path
+from typing import Any, Optional
+
+import torch
+from safetensors.torch import save_file
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+from peft.utils.constants import SAFETENSORS_WEIGHTS_NAME, WEIGHTS_NAME
+from peft.utils.save_and_load import load_peft_weights
+
+
+def _to_legacy_past_key_values(past_key_values: Any):
+    # Support both legacy tuples and transformers.Cache-like objects.
+    if isinstance(past_key_values, (tuple, list)):
+        return past_key_values
+    to_legacy = getattr(past_key_values, "to_legacy_cache", None)
+    if callable(to_legacy):
+        return to_legacy()
+    if hasattr(past_key_values, "__iter__"):
+        legacy = list(past_key_values)
+        if legacy and isinstance(legacy[0], (tuple, list)) and len(legacy[0]) >= 2:
+            return [(layer[0], layer[1]) for layer in legacy]
+    raise TypeError(
+        "Unsupported `past_key_values` type. Expected a legacy tuple/list, an object with `to_legacy_cache()`, or an "
+        "iterable of (key, value) tuples."
+    )
+
+
+def prompt_embeddings_from_past_key_values(
+    past_key_values: Any,
+    *,
+    num_virtual_tokens: int,
+) -> torch.Tensor:
+    """
+    Convert a (legacy) `past_key_values` cache into the flattened prompt embeddings tensor saved by PEFT.
+
+    The output matches the layout expected by `PeftModel.get_prompt()` for prefix-style prompt learning: shape
+    `[num_virtual_tokens, num_layers * 2 * token_dim]`.
+    """
+    legacy = _to_legacy_past_key_values(past_key_values)
+    if len(legacy) == 0:
+        raise ValueError("Empty `past_key_values`.")
+
+    # Each layer: (key, value), where key/value are [batch, num_heads, seq_len, head_dim]
+    num_layers = len(legacy)
+    key0, _ = legacy[0]
+    if key0.ndim != 4:
+        raise ValueError(f"Expected key/value tensors with rank 4, got key.ndim={key0.ndim}.")
+    if key0.shape[0] != 1:
+        raise ValueError(
+            "This helper expects `past_key_values` from a single-sequence prefill (batch=1). "
+            f"Got batch={key0.shape[0]}."
+        )
+    num_heads = key0.shape[1]
+    seq_len = key0.shape[2]
+    head_dim = key0.shape[3]
+    if seq_len < num_virtual_tokens:
+        raise ValueError(f"Need at least {num_virtual_tokens} cached tokens, got {seq_len}.")
+
+    packed = torch.empty(
+        num_virtual_tokens,
+        num_layers * 2,
+        num_heads,
+        head_dim,
+        device=key0.device,
+        dtype=key0.dtype,
+    )
+    for layer_idx, (k, v) in enumerate(legacy):
+        if k.shape[:2] != (1, num_heads) or v.shape[:2] != (1, num_heads):
+            raise ValueError("Inconsistent head shapes across layers in `past_key_values`.")
+        if k.shape[2] < num_virtual_tokens or v.shape[2] < num_virtual_tokens:
+            raise ValueError("Not enough cached tokens in `past_key_values` for the requested cartridge length.")
+        if k.shape[3] != head_dim or v.shape[3] != head_dim:
+            raise ValueError("Inconsistent head_dim across layers in `past_key_values`.")
+        packed[:, 2 * layer_idx] = k[0, :, :num_virtual_tokens, :].transpose(0, 1).contiguous()
+        packed[:, 2 * layer_idx + 1] = v[0, :, :num_virtual_tokens, :].transpose(0, 1).contiguous()
+
+    return packed.reshape(num_virtual_tokens, -1)
+
+
+@torch.no_grad()
+def initialize_kv_prefix_from_past_key_values(
+    model,
+    *,
+    adapter_name: Optional[str] = None,
+    past_key_values: Any,
+    num_virtual_tokens: Optional[int] = None,
+) -> torch.Tensor:
+    """
+    Initialize a KV-prefix prompt-learning adapter from an existing cached prefix (`past_key_values`).
+
+    Returns the prompt embeddings tensor that was loaded into the adapter.
+    """
+    if adapter_name is None:
+        adapter_name = model.active_adapter
+    config = model.peft_config[adapter_name]
+    if config.peft_type not in (PeftType.CARTRIDGE, PeftType.PREFIX_TUNING):
+        raise ValueError(
+            f"Adapter '{adapter_name}' must be a CARTRIDGE or PREFIX_TUNING adapter (got {config.peft_type})."
+        )
+    if getattr(config, "prefix_projection", False):
+        raise ValueError(
+            "Initialization from KV cache is not supported for prefix tuning with `prefix_projection=True`."
+        )
+    if num_virtual_tokens is None:
+        num_virtual_tokens = config.num_virtual_tokens
+
+    prompt_embeddings = prompt_embeddings_from_past_key_values(past_key_values, num_virtual_tokens=num_virtual_tokens)
+    model.prompt_encoder[adapter_name].load_prompt_embeddings(prompt_embeddings)
+    return prompt_embeddings
+
+
+@torch.no_grad()
+def initialize_kv_prefix_from_text(
+    model,
+    tokenizer,
+    *,
+    text: str,
+    adapter_name: Optional[str] = None,
+    num_virtual_tokens: Optional[int] = None,
+    use_chat_template: bool = True,
+    max_length: Optional[int] = None,
+) -> torch.Tensor:
+    """
+    Convenience initializer: prefill the base model on `text` and load the resulting cache prefix into the adapter.
+    """
+    if adapter_name is None:
+        adapter_name = model.active_adapter
+    config = model.peft_config[adapter_name]
+    if config.peft_type not in (PeftType.CARTRIDGE, PeftType.PREFIX_TUNING):
+        raise ValueError(
+            f"Adapter '{adapter_name}' must be a CARTRIDGE or PREFIX_TUNING adapter (got {config.peft_type})."
+        )
+    if getattr(config, "prefix_projection", False):
+        raise ValueError(
+            "Initialization from KV cache is not supported for prefix tuning with `prefix_projection=True`."
+        )
+    if num_virtual_tokens is None:
+        num_virtual_tokens = config.num_virtual_tokens
+
+    def _tokenize_plain():
+        toks = tokenizer(text, return_tensors="pt", truncation=max_length is not None, max_length=max_length)
+        return toks["input_ids"]
+
+    if use_chat_template and hasattr(tokenizer, "apply_chat_template"):
+        try:
+            input_ids = tokenizer.apply_chat_template(
+                [{"role": "system", "content": text}],
+                tokenize=True,
+                add_generation_prompt=False,
+                return_dict=False,
+                return_tensors="pt",
+            )
+        except (TypeError, ValueError):
+            # Some tokenizers don't support the full signature or do not define a chat template.
+            input_ids = _tokenize_plain()
+        else:
+            if max_length is not None and input_ids.shape[1] > max_length:
+                input_ids = input_ids[:, :max_length]
+    else:
+        input_ids = _tokenize_plain()
+
+    input_ids = input_ids.to(model.device)
+    attention_mask = torch.ones_like(input_ids)
+    with model.disable_adapter():
+        outputs = model(input_ids=input_ids, attention_mask=attention_mask, use_cache=True)
+    return initialize_kv_prefix_from_past_key_values(
+        model,
+        adapter_name=adapter_name,
+        past_key_values=outputs.past_key_values,
+        num_virtual_tokens=num_virtual_tokens,
+    )
+
+
+def compose_cartridge_adapters(
+    adapter_paths: Sequence[str | Path],
+    *,
+    output_path: str | Path,
+    safe_serialization: bool = True,
+) -> None:
+    """
+    Compose multiple CARTRIDGE adapters by concatenating their prompt embeddings.
+
+    This implements the paper's "composition via concatenation" behavior at the adapter level (no runtime
+    multi-adapter).
+    """
+    adapter_paths = [Path(p) for p in adapter_paths]
+    if len(adapter_paths) < 2:
+        raise ValueError("Need at least 2 adapters to compose.")
+
+    configs = [PeftConfig.from_pretrained(str(p)) for p in adapter_paths]
+    for p, cfg in zip(adapter_paths, configs):
+        if cfg.peft_type != PeftType.CARTRIDGE:
+            raise ValueError(f"Adapter at '{p}' is not a CARTRIDGE adapter (got {cfg.peft_type}).")
+
+    base = configs[0]
+    for cfg in configs[1:]:
+        for attr in ("task_type", "token_dim", "num_layers", "num_attention_heads", "num_transformer_submodules"):
+            if getattr(cfg, attr, None) != getattr(base, attr, None):
+                raise ValueError(f"Incompatible CARTRIDGE configs for attribute '{attr}'.")
+
+    weights = [load_peft_weights(str(p), device="cpu") for p in adapter_paths]
+    prompt_embeddings = [w["prompt_embeddings"] for w in weights]
+    composed = torch.cat(prompt_embeddings, dim=0)
+
+    num_virtual_tokens = composed.shape[0]
+    # Preserve the "frozen prefix tokens" count of the first adapter only (matches a single attention-sink prefix).
+    num_frozen_tokens = base.num_frozen_tokens
+    out_cfg = replace(base, num_virtual_tokens=num_virtual_tokens, num_frozen_tokens=num_frozen_tokens)
+
+    output_path = Path(output_path)
+    output_path.mkdir(parents=True, exist_ok=True)
+    out_cfg.save_pretrained(str(output_path))
+
+    if safe_serialization:
+        save_file({"prompt_embeddings": composed}, str(output_path / SAFETENSORS_WEIGHTS_NAME))
+    else:
+        torch.save({"prompt_embeddings": composed}, str(output_path / WEIGHTS_NAME))
diff --git a/src/peft/tuners/cpt/__init__.py b/src/peft/tuners/cpt/__init__.py
new file mode 100644
index 0000000..fcd4de8
--- /dev/null
+++ b/src/peft/tuners/cpt/__init__.py
@@ -0,0 +1,24 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+
+from peft.utils import register_peft_method
+
+from .config import CPTConfig
+from .model import CPTEmbedding
+
+
+__all__ = ["CPTConfig", "CPTEmbedding"]
+
+register_peft_method(name="cpt", config_cls=CPTConfig, model_cls=CPTEmbedding)
diff --git a/src/peft/tuners/cpt/config.py b/src/peft/tuners/cpt/config.py
new file mode 100644
index 0000000..cde1597
--- /dev/null
+++ b/src/peft/tuners/cpt/config.py
@@ -0,0 +1,100 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+from dataclasses import dataclass, field
+from typing import Literal, Optional
+
+from peft.config import PromptLearningConfig
+from peft.utils import PeftType, TaskType
+
+
+@dataclass
+class CPTConfig(PromptLearningConfig):
+    """
+    CPT Configuration class extending PeftConfig for Context-aware Prompt Tuning (CPT).
+
+    This class introduces additional parameters required for CPT, such as:
+    - Token type masks
+    - Prompt tuning initialization
+    - Loss weighting
+    - Projection settings
+
+    For more details, see the paper: https://huggingface.co/papers/2410.17222
+    """
+
+    # Token-related configurations
+    cpt_token_ids: Optional[list[int]] = field(
+        default=None, metadata={"help": "Tensor of token IDs used for CPT prompts."}
+    )
+    cpt_mask: Optional[list[int]] = field(default=None, metadata={"help": "Tensor mask applied to CPT tokens."})
+    cpt_tokens_type_mask: Optional[list[int]] = field(
+        default=None, metadata={"help": "Mask indicating the type of each CPT token."}
+    )
+
+    # Loss-related configurations
+    opt_weighted_loss_type: Optional[Literal["none", "decay"]] = field(
+        default="none", metadata={"help": "Type of weighted loss: 'none' or 'decay'."}
+    )
+    opt_loss_decay_factor: Optional[float] = field(
+        default=1.0, metadata={"help": "Factor for exponential decay in loss weighting."}
+    )
+
+    # Projection-related configurations
+    opt_projection_epsilon: Optional[float] = field(
+        default=0.1, metadata={"help": "Epsilon value for input projection."}
+    )
+    opt_projection_format_epsilon: Optional[float] = field(
+        default=0.1, metadata={"help": "Epsilon value for format projection."}
+    )
+
+    # Tokenizer configuration
+    tokenizer_name_or_path: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "The tokenizer to use for prompt tuning initialization. Only used if prompt_tuning_init is `TEXT`"
+        },
+    )
+    # Need to define CPT-specific static attributes
+    is_prompt_learning = True  # Indicates that CPT is a prompt-learning method.
+
+    def __post_init__(self):
+        """
+        Post-initialization hook to set additional attributes after the config is initialized.
+        """
+        super().__post_init__()
+        # CPT-specific static attributes
+        self.is_prompt_learning = True  # Indicates that CPT is a prompt-learning method.
+        self.num_layers = None  # Number of layers (optional, not always required).
+        self.token_dim = None  # Dimension of token embeddings.
+        self.num_attention_heads = None  # Number of attention heads (if applicable).
+        self.num_transformer_submodules = 1  # Number of transformer submodules used.
+        self.peft_type = PeftType.CPT  # Specifies that the PEFT type is CPT.
+        if self.task_type != TaskType.CAUSAL_LM:
+            raise ValueError(f"{self.__class__.__name__} only supports task_type = {TaskType.CAUSAL_LM.value}.")
+
+        if self.cpt_token_ids is None:
+            self.cpt_token_ids = [0]
+
+        self.num_virtual_tokens = len(self.cpt_token_ids)
+
+        if self.cpt_mask is None:
+            self.cpt_mask = [1 for _ in self.cpt_token_ids]
+
+        if self.cpt_tokens_type_mask is None:
+            self.cpt_tokens_type_mask = [1 for _ in self.cpt_token_ids]
+
+        if not (
+            len(self.cpt_token_ids) == len(self.cpt_mask) == len(self.cpt_tokens_type_mask) == self.num_virtual_tokens
+        ):
+            raise ValueError("cpt_token_ids, cpt_mask and cpt_tokens_type_mask must have the same length.")
diff --git a/src/peft/tuners/cpt/model.py b/src/peft/tuners/cpt/model.py
new file mode 100644
index 0000000..6c4dc08
--- /dev/null
+++ b/src/peft/tuners/cpt/model.py
@@ -0,0 +1,202 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+import copy
+
+import torch
+from torch.nn import CrossEntropyLoss
+
+from peft.utils.integrations import gather_params_ctx
+
+
+class CPTEmbedding(torch.nn.Module):
+    """
+    CPTEmbedding is a custom embedding layer designed for Context-aware Prompt Tuning (CPT) in PEFT. It initializes
+    embeddings, applies prompt-specific projections, and computes loss using label masks.
+    """
+
+    def __init__(self, config, word_embeddings):
+        """
+        Initializes the CPTEmbedding module.
+
+        Args:
+            config (Namespace):
+                Configuration object containing model hyperparameters and CPT-specific settings.
+            word_embeddings (torch.nn.Embedding):
+                The base word embedding layer used to initialize CPT embeddings.
+        """
+        super().__init__()
+        self.config = copy.deepcopy(config)
+        num_virtual_tokens = config.num_virtual_tokens
+
+        # Initialize embeddings with virtual token dimensions
+        self.embedding = torch.nn.Embedding(num_virtual_tokens, config.token_dim)
+
+        # Initialize embeddings using text-based prompt tuning, if configured
+        if not config.inference_mode:
+            assert config.num_virtual_tokens == len(config.cpt_token_ids)
+
+            init_token_ids = torch.LongTensor(config.cpt_token_ids).to(word_embeddings.weight.device)
+            with gather_params_ctx(word_embeddings.parameters()):
+                word_embedding_weights = word_embeddings(init_token_ids).detach().clone()
+            word_embedding_weights = word_embedding_weights.to(torch.float32)
+            self.embedding.weight = torch.nn.Parameter(word_embedding_weights)
+
+        self.embedding.requires_grad_(False)
+
+        # Initialize delta embedding with zero weights
+        self.delta_embedding = torch.nn.Embedding(num_virtual_tokens, config.token_dim)
+        self.delta_embedding.weight.data = torch.zeros_like(self.delta_embedding.weight).to(torch.float32)
+
+        # Apply hook for backward gradient updates
+        self.set_updated_tokens()
+
+    def forward(self, indices):
+        """
+        Computes the prompt embeddings and applies delta adjustments.
+
+        Args:
+            indices (torch.Tensor):
+                Indices of the tokens to be embedded.
+
+        Returns:
+            torch.Tensor:
+                Sum of prompt embeddings and delta embeddings.
+        """
+        with torch.no_grad():
+            prompt_embeddings = self.embedding(indices)
+
+        self.delta_embedding.weight.data = self.get_projection()  # Apply epsilon-based projection
+
+        delta_prompt_embeddings = self.delta_embedding(indices)
+
+        return prompt_embeddings + delta_prompt_embeddings
+
+    def set_updated_tokens(self):
+        """
+        Sets up a backward hook to selectively update token gradients based on the CPT token type mask.
+        """
+        tensor_ICL_mask = torch.Tensor(self.config.cpt_tokens_type_mask).long()
+        mask_input_template = torch.remainder(tensor_ICL_mask, 4) == 1
+        mask_input = torch.remainder(tensor_ICL_mask, 4) == 2
+        mask_output_template = torch.remainder(tensor_ICL_mask, 4) == 3
+        mask = mask_input_template | mask_input | mask_output_template
+        mask = mask.view(-1, 1)
+
+        def backward_hook(grad):
+            grad = grad * mask.to(grad.device)  # Apply mask to gradients
+            return grad
+
+        self.delta_embedding.weight.register_hook(backward_hook)
+
+    def get_epsilon(self):
+        cpt_tokens_type_mask = self.config.cpt_tokens_type_mask
+
+        MIN_VALUE = 1e-10
+
+        # Calculate normalized epsilon values for input, output, and format tokens
+        normalized_format_eps = self.config.opt_projection_format_epsilon * torch.sqrt(
+            torch.Tensor([self.config.token_dim / 2048])
+        )
+        normalized_input_eps = self.config.opt_projection_epsilon * torch.sqrt(
+            torch.Tensor([self.config.token_dim / 2048])
+        )
+
+        epsilon = torch.ones_like(torch.Tensor(cpt_tokens_type_mask)).to(torch.float32) * MIN_VALUE
+        cpt_tokens_type_mask = torch.Tensor(cpt_tokens_type_mask).long()
+
+        epsilon[(cpt_tokens_type_mask > 0) & (torch.remainder(cpt_tokens_type_mask, 4) == 1)] = normalized_format_eps
+        epsilon[(cpt_tokens_type_mask > 0) & (torch.remainder(cpt_tokens_type_mask, 4) == 3)] = normalized_format_eps
+        epsilon[(cpt_tokens_type_mask > 0) & (torch.remainder(cpt_tokens_type_mask, 4) == 2)] = normalized_input_eps
+
+        return epsilon
+
+    def get_projection(self):
+        """
+        Applies epsilon-based projection to the delta embeddings to control their norm.
+        """
+
+        # Apply projection to control delta embedding norm
+        with torch.no_grad():
+            new_embeddings_weights = self.delta_embedding.weight.clone().to(self.delta_embedding.weight.device)
+            token_norm = torch.norm(new_embeddings_weights, p=2, dim=1)
+
+            projection_mask = token_norm > 0
+            if torch.any(projection_mask):
+                epsilon = self.get_epsilon().to(self.delta_embedding.weight.device)
+                new_embeddings_weights[projection_mask] *= (
+                    epsilon[projection_mask] / (token_norm[projection_mask].clamp(min=epsilon[projection_mask]))
+                ).view(-1, 1)
+            return new_embeddings_weights
+
+    @staticmethod
+    def calculate_loss(base_model_output, labels, cpt_type_mask, config):
+        """
+        Computes the loss for CPT models with optional exponential decay.
+
+        Args:
+            base_model_output (ModelOutput):
+                Output from the base model containing logits.
+            labels (torch.Tensor):
+                Ground-truth labels for the input tokens.
+            cpt_type_mask (torch.Tensor):
+                Token type mask used for filtering valid loss terms.
+            config (Namespace):
+                Configuration object containing loss-related hyperparameters.
+
+        Returns:
+            ModelOutput:
+                The base model output with computed loss.
+        """
+
+        device = base_model_output.logits.device
+
+        lm_logits = base_model_output.logits
+        labels = labels.to(device)
+
+        # Shift logits and labels for token prediction
+        shift_logits = lm_logits[..., :-1, :].contiguous()
+        shift_labels = labels[..., 1:].contiguous()
+        shift_cpt_type_mask = cpt_type_mask[..., 1:].contiguous()
+
+        shift_labels_bool = (shift_labels.clone().detach() != -100).bool()
+        batch_size, seq_length, vocab_size = shift_logits.shape
+
+        # Compute cross-entropy loss
+        loss_fct = CrossEntropyLoss(reduction="none", ignore_index=-100)
+        loss = loss_fct(
+            shift_logits.view(batch_size * seq_length, vocab_size), shift_labels.view(batch_size * seq_length)
+        )
+        loss = loss.view(batch_size, seq_length)
+        # Apply exponential decay weights to the loss
+        shift_labels_weights = shift_labels_bool.clone().detach().float()
+
+        for i in range(batch_size):
+            idx_labels = (shift_cpt_type_mask[i] > 0) & (shift_cpt_type_mask[i] % 4 == 0)
+            labels_ids = shift_cpt_type_mask[i][idx_labels].unique()
+
+            exponential_decay = torch.ones_like(shift_cpt_type_mask[i]).to(device=device).float()
+            decay_value = 1
+            for label_mask_idx in torch.flip(labels_ids, [0]):
+                exponential_decay[shift_cpt_type_mask[i] == label_mask_idx] = decay_value
+                decay_value *= config.opt_loss_decay_factor
+            if config.opt_weighted_loss_type == "decay":
+                shift_labels_weights[i] *= exponential_decay
+
+        # Compute the weighted mean loss
+        loss = (loss[shift_labels_bool] * shift_labels_weights[shift_labels_bool]).mean()
+
+        base_model_output.loss = loss
+
+        return base_model_output
diff --git a/src/peft/tuners/deft/__init__.py b/src/peft/tuners/deft/__init__.py
new file mode 100644
index 0000000..4307677
--- /dev/null
+++ b/src/peft/tuners/deft/__init__.py
@@ -0,0 +1,24 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+from peft.utils import register_peft_method
+
+from .config import DeftConfig
+from .layer import DeftLayer, DeftLinear
+from .model import DeftModel
+
+
+__all__ = ["DeftConfig", "DeftLayer", "DeftLinear", "DeftModel"]
+
+register_peft_method(name="deft", config_cls=DeftConfig, model_cls=DeftModel)
diff --git a/src/peft/tuners/deft/config.py b/src/peft/tuners/deft/config.py
new file mode 100644
index 0000000..4f460e8
--- /dev/null
+++ b/src/peft/tuners/deft/config.py
@@ -0,0 +1,209 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal, Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class DeftConfig(PeftConfig):
+    """
+    This is the configuration class to store the configuration of a [`DeftModel`].
+
+    DEFT (Decompositional Efficient Fine-Tuning) performs knowledge injection through a residual-projection update. For
+    a frozen base weight `W`, a low-rank projection direction `P` (shape `out_features x r`) and an injection matrix
+    `R` (shape `r x in_features`) are learned. The adapted weight is `W' = (I - P_proj) @ W + Q_P @ R`, where the
+    projector `P_proj` is derived from `P` according to `decomposition_method`:
+
+      - `"relu"` (default): `Q_P = P`, `P_proj = P @ relu(P).T` (non-orthogonal projection)
+      - `"qr"`: `Q_P = qr(P)`, `P_proj = Q_P @ Q_P.T` (orthogonal projection)
+
+    By default (`init_weights=True`) `R` is initialized so the update is an exact identity at init (the adapted weight
+    equals `W`), so training starts from the pretrained weights and learns the injection.
+
+    Args:
+        r (`int`):
+            The rank of the DEFT projection/injection across layers.
+        target_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to apply the adapter to. If this is specified, only the modules with the specified
+            names will be replaced. When passing a string, a regex match will be performed. When passing a list of
+            strings, either an exact match will be performed or it is checked if the name of the module ends with any
+            of the passed strings. If this is specified as 'all-linear', then all linear modules are chosen, excluding
+            the output layer. If this is not specified, modules will be chosen according to the model architecture. If
+            the architecture is not known, an error will be raised -- in this case, you should specify the target
+            modules manually.
+        exclude_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to not apply the adapter. When passing a string, a regex match will be performed.
+            When passing a list of strings, either an exact match will be performed or it is checked if the name of the
+            module ends with any of the passed strings.
+        decomposition_method (`str`):
+            How the projector `P_proj` is derived from `P`. Either `"relu"` (default, non-orthogonal `P @ relu(P).T`)
+            or `"qr"` (orthogonal `Q_P @ Q_P.T`).
+        init_scale (`float`):
+            Scaling applied to the standard deviation used to initialize the injection matrix `R` (only used when
+            `init_weights=False`). Smaller values keep the injected update closer to zero at initialization. Defaults
+            to `1.0`.
+        alpha (`Optional[int]`):
+            The scaling factor for the injection term, which is scaled by `alpha / r` (analogous to LoRA's alpha). If
+            `None`, no scaling is applied (factor `1.0`). The subspace-removal term is unaffected.
+        para (`bool`):
+            Whether to use the PaRa method: pure subspace removal (`delta = -P_proj @ W`) with no injection term. When
+            `True`, `R` is not created, `P` is the only trainable matrix, and the adapter cannot be an identity at
+            init. Defaults to `False` (full DEFT).
+        fan_in_fan_out (`bool`):
+            Set this to `True` if the layer to replace stores weight like (fan_in, fan_out). For example, gpt-2 uses
+            `Conv1D` which stores weights like (fan_in, fan_out) and hence this should be set to `True`.
+        deft_dropout (`float`):
+            The dropout probability applied to the layer input. Defaults to `0.0`.
+        init_weights (`bool`):
+            Whether to use DEFT's default (identity) initialization for the adapter weights, so the adapter is a no-op
+            at the start of training. Don't change this setting, except if you know exactly what you're doing. Defaults
+            to `True`.
+        layers_to_transform (`Union[List[int], int]`):
+            The layer indices to transform. If a list of ints is passed, it will apply the adapter to the layer indices
+            that are specified in this list. If a single integer is passed, it will apply the transformations on the
+            layer at this index.
+        layers_pattern (`Optional[Union[List[str], str]]`):
+            The layer pattern name, used only if `layers_to_transform` is different from `None`. This should target the
+            `nn.ModuleList` of the model, which is often called `'layers'` or `'h'`.
+        bias (`str`):
+            Bias type for DEFT. Can be `'none'`, `'all'` or `'deft_only'`.
+        modules_to_save (`List[str]`):
+            List of modules apart from adapter layers to be set as trainable and saved in the final checkpoint.
+    """
+
+    r: int = field(
+        default=8,
+        metadata={"help": "The rank of the DEFT projection/injection across layers."},
+    )
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": "List of module names or regex expression of the module names to replace with DEFT.",
+            "example": "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$' ",
+        },
+    )
+    exclude_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={"help": "List of module names or regex expression of the module names to exclude from DEFT."},
+    )
+    decomposition_method: Literal["relu", "qr"] = field(
+        default="relu",
+        metadata={
+            "help": (
+                "How the projector P_proj is derived from P. Either 'relu' (default, non-orthogonal P @ relu(P).T) or "
+                "'qr' (orthogonal Q_P @ Q_P.T)."
+            ),
+        },
+    )
+    init_scale: float = field(
+        default=1.0,
+        metadata={"help": "Scaling applied to the std used to initialize the injection matrix R."},
+    )
+    alpha: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": (
+                "Scaling factor for the injection term, scaled by `alpha / r` (analogous to LoRA's alpha). If None, no "
+                "scaling is applied (factor 1.0). The subspace-removal term is unaffected."
+            )
+        },
+    )
+    para: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Whether to use the PaRa method: pure subspace removal `delta = -P_proj @ W` with no injection term. "
+                "When True, R is not created, P is the only trainable matrix, and the adapter cannot be an identity at "
+                "init. Defaults to False (full DEFT)."
+            )
+        },
+    )
+    fan_in_fan_out: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Set this to True if the layer to replace stores weight like (fan_in, fan_out). For example, gpt-2 "
+                "uses `Conv1D` which stores weights like (fan_in, fan_out) and hence this should be set to True."
+            )
+        },
+    )
+    deft_dropout: float = field(
+        default=0.0,
+        metadata={"help": "The dropout probability applied to the layer input."},
+    )
+    init_weights: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "Whether to initialize the weights of the DEFT layers with their default initialization. Don't change "
+                "this setting, except if you know exactly what you're doing."
+            ),
+        },
+    )
+    layers_to_transform: Optional[Union[list[int], int]] = field(
+        default=None,
+        metadata={
+            "help": "The layer indexes to transform, if this argument is specified, PEFT will transform only the layers indexes that are specified inside this list. If a single integer is passed, PEFT will transform only the layer at this index."
+        },
+    )
+    layers_pattern: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": "The layer pattern name, used only if `layers_to_transform` is different to None and if the layer pattern is not in the common layers pattern. "
+            "This should target the `nn.ModuleList` of the model, which is often called `'layers'` or `'h'`."
+        },
+    )
+    bias: str = field(default="none", metadata={"help": "Bias type for DEFT. Can be 'none', 'all' or 'deft_only'"})
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": "List of modules apart from DEFT layers to be set as trainable and saved in the final checkpoint. "
+            "For example, in Sequence Classification or Token Classification tasks, "
+            "the final layer `classifier/score` are randomly initialized and as such need to be trainable and saved."
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.DEFT
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        self.exclude_modules = (
+            set(self.exclude_modules) if isinstance(self.exclude_modules, list) else self.exclude_modules
+        )
+
+        valid_methods = {"qr", "relu"}
+        if self.decomposition_method not in valid_methods:
+            raise ValueError(
+                f"Unknown decomposition_method '{self.decomposition_method}', must be one of {sorted(valid_methods)}."
+            )
+
+        # if target_modules is a regex expression, then layers_to_transform should be None
+        if isinstance(self.target_modules, str) and self.layers_to_transform is not None:
+            raise ValueError("`layers_to_transform` cannot be used when `target_modules` is a str.")
+
+        # if target_modules is a regex expression, then layers_pattern should be None
+        if isinstance(self.target_modules, str) and self.layers_pattern is not None:
+            raise ValueError("`layers_pattern` cannot be used when `target_modules` is a str.")
+
+        # check for layers_to_transform and layers_pattern
+        if self.layers_pattern and not self.layers_to_transform:
+            raise ValueError("When `layers_pattern` is specified, `layers_to_transform` must also be specified. ")
diff --git a/src/peft/tuners/deft/layer.py b/src/peft/tuners/deft/layer.py
new file mode 100644
index 0000000..0120a81
--- /dev/null
+++ b/src/peft/tuners/deft/layer.py
@@ -0,0 +1,349 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+import warnings
+from typing import Any, Optional
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+from transformers.pytorch_utils import Conv1D
+
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+from peft.utils.other import transpose
+
+from .config import DeftConfig
+
+
+class DeftLayer(BaseTunerLayer):
+    # All names of layers that may contain (trainable) adapter weights
+    adapter_layer_names = ("deft_P", "deft_R")
+    # All names of other parameters that may contain adapter-related parameters
+    other_param_names = (
+        "deft_r",
+        "deft_decomposition",
+        "deft_init_scale",
+        "deft_para",
+        "deft_scaling",
+        "deft_dropout",
+    )
+
+    def __init__(self, base_layer: nn.Module, **kwargs) -> None:
+        self.base_layer = base_layer
+        self.deft_r = {}
+        self.deft_decomposition = {}
+        self.deft_init_scale = {}
+        self.deft_para = {}
+        self.deft_scaling = {}
+        self.deft_P = nn.ParameterDict({})
+        self.deft_R = nn.ParameterDict({})
+        self.deft_dropout = nn.ModuleDict({})
+        # whether the base weight is stored transposed, i.e. (in_features, out_features) as in `Conv1D` (gpt-2)
+        self.fan_in_fan_out = False
+        # The residual projection (I - P_proj) @ W is not invertible, so unmerge cannot recover the delta from the
+        # merged weight. Rather than cache the full out x in delta, cache only its base-weight-dependent factor
+        # right.T @ W (shape r x in_features) per adapter; unmerge recomputes the exact delta from it (~r/out_features
+        # of the memory).
+        self._cached_merge_factor = {}
+        # Mark the weight as unmerged
+        self._disable_adapters = False
+        self.merged_adapters = []
+        # flag to enable/disable casting of input to weight dtype during forward call
+        self.cast_input_dtype_enabled = True
+        self.kwargs = kwargs
+
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            self.in_features, self.out_features = base_layer.in_features, base_layer.out_features
+        elif isinstance(base_layer, Conv1D):
+            # Conv1D (e.g. gpt-2) stores its weight transposed as (in_features, out_features)
+            self.in_features, self.out_features = (
+                base_layer.weight.ds_shape if hasattr(base_layer.weight, "ds_shape") else base_layer.weight.shape
+            )
+        else:
+            raise TypeError(f"Unsupported layer type {type(base_layer)}")
+
+    def update_layer(
+        self,
+        adapter_name: str,
+        r: int,
+        config: DeftConfig,
+        **kwargs,
+    ) -> None:
+        """Internal function to create the DEFT adapter.
+
+        Args:
+            adapter_name (`str`): Name for the adapter to add.
+            r (`int`): Rank for the added adapter.
+            config (`DeftConfig`): The adapter configuration for this layer.
+        """
+        if r <= 0:
+            raise ValueError(f"`r` should be a positive integer value but the value passed is {r}")
+
+        # The projection P_proj has rank at most out_features, so the effective rank is capped here (relevant for small
+        # output dimensions, e.g. r=8 on a layer with out_features=2). This keeps P and R shapes consistent with the
+        # qr decomposition, which can return at most out_features orthonormal columns.
+        r = min(r, self.out_features)
+        self.deft_r[adapter_name] = r
+        self.deft_decomposition[adapter_name] = config.decomposition_method
+        self.deft_init_scale[adapter_name] = config.init_scale
+        self.deft_para[adapter_name] = config.para
+        self.fan_in_fan_out = config.fan_in_fan_out
+        # injection scaling (analogous to LoRA's alpha/r); 1.0 = no scaling (backward compatible)
+        self.deft_scaling[adapter_name] = (config.alpha / r) if getattr(config, "alpha", None) else 1.0
+
+        if config.deft_dropout > 0.0:
+            self.deft_dropout[adapter_name] = nn.Dropout(p=config.deft_dropout)
+        else:
+            self.deft_dropout[adapter_name] = nn.Identity()
+
+        # P: projection direction (out_features x r); R: injection matrix (r x in_features, full DEFT only).
+        # With `para=True` the update is pure subspace removal `-P_proj @ W` (the PaRa method), and R is unused.
+        self.deft_P[adapter_name] = nn.Parameter(torch.empty(self.out_features, r))
+        if not config.para:
+            self.deft_R[adapter_name] = nn.Parameter(torch.empty(r, self.in_features))
+
+        self.reset_deft_parameters(adapter_name, init_weights=config.init_weights)
+
+        # Move new weights to device
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=config.inference_mode)
+
+    def reset_deft_parameters(self, adapter_name: str, init_weights: bool = True) -> None:
+        if adapter_name not in self.deft_P.keys():
+            return
+
+        nn.init.normal_(self.deft_P[adapter_name], mean=0.0, std=0.02)
+
+        if self.deft_para[adapter_name]:
+            # PaRa (para=True): no injection matrix R to initialize; the update is pure subspace removal and
+            # cannot be made an identity at init.
+            return
+
+        base_weight = self.get_base_layer().weight
+        R_param = self.deft_R[adapter_name]
+        if self.deft_P[adapter_name].is_meta or base_weight.is_meta or R_param.is_meta:
+            # tensors are on meta (e.g. low_cpu_mem_usage loading); the real values are loaded afterwards, so any
+            # (data-dependent) initialization is skipped here.
+            return
+
+        if init_weights:
+            # Identity initialization: choose R so that the delta is exactly zero at init, i.e. the adapted weight
+            # equals the base weight. With delta = Q_P @ (R - right.T @ W) (see `get_delta_weight`), delta == 0 holds
+            # for R = right.T @ W. This starts training from the pretrained weights and learns the injection,
+            # avoiding the immediate "forgetting" caused by removing a sub-space of W.
+            P = self.deft_P[adapter_name].detach().to(base_weight.device)
+            _, right = self._project(P, adapter_name)
+            # transpose for `Conv1D`, whose weight is stored as (in_features, out_features), to the logical (out, in)
+            W = transpose(base_weight.detach().to(torch.float32), self.fan_in_fan_out)
+            R_init = right.transpose(0, 1) @ W
+            # divide by the injection scaling so that (scaling * R_init) == right.T @ W, keeping delta == 0 at init
+            R_init = R_init / self.deft_scaling[adapter_name]
+            with torch.no_grad():
+                R_param.copy_(R_init.to(dtype=R_param.dtype, device=R_param.device))
+        else:
+            # Random initialization: reproduces the original DEFT behavior where a sub-space of W is replaced from the
+            # start (non-identity at init).
+            nn.init.normal_(R_param, mean=0.0, std=0.02 * self.deft_init_scale[adapter_name])
+
+    def scale_layer(self, scale: float) -> None:
+        if scale == 1:
+            return
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self.deft_P.keys():
+                continue
+            warnings.warn("Scaling operation for DEFT not supported! Automatically set scale to 1.")
+
+    def unscale_layer(self, scale=None) -> None:
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self.deft_P.keys():
+                continue
+            warnings.warn("Unscaling operation for DEFT not supported! Keeping scale at 1.")
+
+
+class DeftLinear(nn.Module, DeftLayer):
+    """DEFT implemented in a dense layer."""
+
+    def __init__(
+        self,
+        base_layer,
+        adapter_name: str,
+        config: DeftConfig,
+        r: int = 0,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        DeftLayer.__init__(self, base_layer, **kwargs)
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, config=config, **kwargs)
+
+    def _project(self, P: torch.Tensor, adapter_name: str):
+        """Return `(Q_P, right)` (both float32) such that the projector is `P_proj = Q_P @ right.T` and the injection
+        uses `Q_P`.
+
+          - `relu`: `Q_P = P`, `right = relu(P)` -> `P_proj = P @ relu(P).T` (non-orthogonal)
+          - `qr`: `Q_P = qr(P)`, `right = Q_P` -> `P_proj = Q_P @ Q_P.T` (orthogonal)
+        """
+        # float32 for numerical stability: the QR decomposition (and the projection math) are unreliable in
+        # half precision, so the projection is always computed in float32 and cast back by the caller.
+        P = P.to(torch.float32)
+        method = self.deft_decomposition[adapter_name]
+        if method == "relu":
+            Q_P = P
+            right = torch.relu(P)
+        elif method == "qr":
+            Q_P, _ = torch.linalg.qr(P)
+            right = Q_P
+        else:
+            raise ValueError(f"Unknown decomposition_method '{method}'.")
+        return Q_P, right
+
+    def _merge_factor(self, adapter_name: str) -> torch.Tensor:
+        """Return the only base-weight-dependent part of the merge delta: `right.T @ W` (shape `r x in_features`), in
+        float32. Caching this instead of the full `out x in` delta lets `unmerge` recompute the exact delta while
+        storing roughly `r / out_features` as much memory.
+        """
+        # computed in float32 for numerical stability (see `_project`); transpose handles `Conv1D` (fan_in_fan_out),
+        # whose weight is stored as (in_features, out_features), so `W` is always logical (out_features, in_features)
+        weight = transpose(self.get_base_layer().weight.to(torch.float32), self.fan_in_fan_out)
+        _, right = self._project(self.deft_P[adapter_name], adapter_name)
+        return right.transpose(0, 1) @ weight
+
+    def _delta_from_factor(self, adapter_name: str, factor: torch.Tensor) -> torch.Tensor:
+        """Reconstruct the additive delta from the cached factor `M = right.T @ W` (float32): `delta = Q_P @ (R - M)`,
+        or `-Q_P @ M` for PaRa. Exact even after the base weight changed, since `M` is taken from the original weight.
+        """
+        orig_dtype = self.get_base_layer().weight.dtype
+        Q_P, _ = self._project(self.deft_P[adapter_name], adapter_name)
+        if self.deft_para[adapter_name]:
+            # PaRa: pure subspace removal, delta = -P_proj @ W = -Q_P @ (right.T @ W)
+            delta = -(Q_P @ factor)
+        else:
+            R = self.deft_R[adapter_name].to(torch.float32) * self.deft_scaling[adapter_name]
+            delta = Q_P @ (R - factor)
+        # delta is logical (out_features, in_features); transpose back to the base layer's storage order (Conv1D)
+        return transpose(delta, self.fan_in_fan_out).to(orig_dtype)
+
+    def get_delta_weight(self, adapter_name: str) -> torch.Tensor:
+        """Return the additive delta such that `W + delta` equals the DEFT-adapted weight.
+
+        The adapted weight is `(I - P_proj) @ W + Q_P @ R`, so the delta is `-P_proj @ W + Q_P @ R`. Using `P_proj =
+        Q_P @ right.T` this factors into `delta = Q_P @ (R - right.T @ W)` (`-Q_P @ (right.T @ W)` for PaRa), which
+        only uses rank-`r` matmuls and never materializes the `out x out` projection matrix. The base-weight-dependent
+        part `right.T @ W` is produced by `_merge_factor`. Used by `merge`; the forward pass computes the equivalent
+        update directly on the activations instead.
+        """
+        return self._delta_from_factor(adapter_name, self._merge_factor(adapter_name))
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights.
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If `True`, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If `None`, all active adapters will be merged.
+                Defaults to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        base_layer = self.get_base_layer()
+        # The delta's removal term depends on the base weight, so every adapter's base-weight-dependent factor
+        # (right.T @ W) is computed from the original (unmerged) weight *before* mutating it. This makes merging a set
+        # of adapters equivalent to summing their independent deltas (matching `forward`) and keeps `unmerge` exact.
+        factors = {a: self._merge_factor(a) for a in adapter_names if a in self.deft_P.keys()}
+        for active_adapter, factor in factors.items():
+            delta_weight = self._delta_from_factor(active_adapter, factor)
+            if safe_merge:
+                new_weight = base_layer.weight.data.clone() + delta_weight
+                if not torch.isfinite(new_weight).all():
+                    raise ValueError(
+                        f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                    )
+                base_layer.weight.data = new_weight
+            else:
+                base_layer.weight.data = base_layer.weight.data + delta_weight
+            # cache only the small r x in_features factor (not the full out x in delta) for an exact unmerge
+            self._cached_merge_factor[active_adapter] = factor.to(base_layer.weight.dtype)
+            self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """Unmerge all merged adapter layers from the base weights."""
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter not in self.deft_P.keys():
+                continue
+            factor = self._cached_merge_factor.pop(active_adapter, None)
+            if factor is not None:
+                delta_weight = self._delta_from_factor(active_adapter, factor.to(torch.float32))
+            else:
+                # fall back to recomputation (only exact if the base weight is unchanged since merge)
+                delta_weight = self.get_delta_weight(active_adapter)
+            base_layer = self.get_base_layer()
+            base_layer.weight.data = base_layer.weight.data - delta_weight
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        previous_dtype = x.dtype
+
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        elif not any(active_adapter in self.deft_P.keys() for active_adapter in self.active_adapters):
+            # no active DEFT adapter on this layer
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            # Apply the update on the activations instead of materializing W + delta. For one adapter,
+            # delta = Q_P @ (R - right.T @ W), so x @ delta.T = [(x @ R.T) - (x @ W.T) @ right] @ Q_P.T
+            # (injection minus subspace-removal), where (x @ W.T) is the bias-free base product.
+            base_layer = self.get_base_layer()
+            bias = base_layer.bias
+
+            active_adapters = [a for a in self.active_adapters if a in self.deft_P.keys()]
+            base_out = self.base_layer(x, *args, **kwargs)
+            # the DEFT update is computed in float32 for numerical stability (see `_project`)
+            compute_dtype = torch.float32
+            result = base_out.to(compute_dtype)
+            # bias-free base product (x @ W.T), needed by the subspace-removal (correction) term
+            base_product = result if bias is None else result - bias.to(compute_dtype)
+
+            x = self._cast_input_dtype(x, compute_dtype)
+            for active_adapter in active_adapters:
+                Q_P, right = self._project(self.deft_P[active_adapter], active_adapter)
+                # subspace-removal (correction) term: (x @ W.T @ right) @ Q_P.T = P_proj @ W @ x
+                correction = (base_product @ right) @ Q_P.transpose(0, 1)
+                result = result - correction
+                if not self.deft_para[active_adapter]:
+                    R = self.deft_R[active_adapter].to(compute_dtype)
+                    R = R * self.deft_scaling[active_adapter]
+                    x_drop = self.deft_dropout[active_adapter](x)
+                    result = result + F.linear(x_drop, R) @ Q_P.transpose(0, 1)
+
+        result = result.to(previous_dtype)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "deft." + rep
diff --git a/src/peft/tuners/deft/model.py b/src/peft/tuners/deft/model.py
new file mode 100644
index 0000000..af52229
--- /dev/null
+++ b/src/peft/tuners/deft/model.py
@@ -0,0 +1,109 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+
+import warnings
+
+import torch
+from transformers.pytorch_utils import Conv1D
+
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer
+from peft.utils import TRANSFORMERS_MODELS_TO_DEFT_TARGET_MODULES_MAPPING
+
+from .layer import DeftLayer, DeftLinear
+
+
+class DeftModel(BaseTuner):
+    """
+    Creates a DEFT (Decompositional Efficient Fine-Tuning) model from a pretrained model.
+
+    DEFT freezes the base weights and learns, per target module, a low-rank projection direction `P` and an injection
+    matrix `R`. The effective weight becomes `(I - P_proj) @ W + Q_P @ R`, replacing a sub-space of `W` with newly
+    injected content (see [`DeftConfig`] for the available `decomposition_method` variants).
+
+    Args:
+        model (`torch.nn.Module`): The model to which the adapter tuner layers will be attached.
+        config ([`DeftConfig`]): The configuration of the DEFT model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            Create empty adapter weights on meta device. Useful to speed up the loading process.
+
+    Returns:
+        `torch.nn.Module`: The DEFT model.
+
+    **Attributes**:
+        - **model** ([`~torch.nn.Module`]) -- The model to be adapted.
+        - **peft_config** ([`DeftConfig`]): The configuration of the DEFT model.
+    """
+
+    prefix: str = "deft_"
+    tuner_layer_cls = DeftLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_DEFT_TARGET_MODULES_MAPPING
+
+    def _create_and_replace(
+        self,
+        deft_config,
+        adapter_name,
+        target,
+        target_name,
+        parent,
+        current_key,
+        **optional_kwargs,
+    ):
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+
+        # If it is not a DeftLayer, create a new module, else update it with new adapters
+        if not isinstance(target, DeftLayer):
+            new_module = self._create_new_module(deft_config, adapter_name, target, r=deft_config.r)
+            if adapter_name not in self.active_adapters:
+                # adding an additional adapter: it is not automatically trainable
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+        else:
+            target.update_layer(
+                adapter_name,
+                r=deft_config.r,
+                config=deft_config,
+            )
+
+    @staticmethod
+    def _create_new_module(deft_config, adapter_name, target, **kwargs):
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        if isinstance(target_base_layer, torch.nn.Linear):
+            if deft_config.fan_in_fan_out:
+                warnings.warn(
+                    "fan_in_fan_out is set to True but the target module is `torch.nn.Linear`. "
+                    "Setting fan_in_fan_out to False."
+                )
+                deft_config.fan_in_fan_out = False
+            new_module = DeftLinear(target, adapter_name, config=deft_config, **kwargs)
+        elif isinstance(target_base_layer, Conv1D):
+            if not deft_config.fan_in_fan_out:
+                warnings.warn(
+                    "fan_in_fan_out is set to False but the target module is `Conv1D`. Setting fan_in_fan_out to True."
+                )
+                deft_config.fan_in_fan_out = True
+            new_module = DeftLinear(target, adapter_name, config=deft_config, **kwargs)
+        else:
+            raise TypeError(
+                f"Target module {target} is not supported. Currently, only `torch.nn.Linear` and "
+                "`transformers.pytorch_utils.Conv1D` are supported."
+            )
+
+        return new_module
diff --git a/src/peft/tuners/delora/__init__.py b/src/peft/tuners/delora/__init__.py
new file mode 100644
index 0000000..982801c
--- /dev/null
+++ b/src/peft/tuners/delora/__init__.py
@@ -0,0 +1,23 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+from peft.utils import register_peft_method
+
+from .config import DeloraConfig
+from .layer import DeloraLayer, DeloraLinear
+from .model import DeloraModel
+
+
+__all__ = ["DeloraConfig", "DeloraLayer", "DeloraLinear", "DeloraModel"]
+
+register_peft_method(name="delora", model_cls=DeloraModel, config_cls=DeloraConfig)
diff --git a/src/peft/tuners/delora/config.py b/src/peft/tuners/delora/config.py
new file mode 100644
index 0000000..9535a9d
--- /dev/null
+++ b/src/peft/tuners/delora/config.py
@@ -0,0 +1,162 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal, Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class DeloraConfig(PeftConfig):
+    """
+    This is the configuration class to store the configuration of a [`DeloraModel`].
+
+    Args:
+        r (`int`):
+            The rank of the DeLoRA adapter.
+        delora_lambda (`int`):
+            The initial value of the boundary of the DeLoRA adapter. This variable sets an upper bound to the Frobenius
+            norm of the weight change, avoiding the finetuned model to deviate too much from the original model.
+        module_dropout (`float`):
+            The dropout probability for disabling DeLoRA modules during training.
+        target_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to apply the adapter to. If this is specified, only the modules with the specified
+            names will be replaced. When passing a string, a regex match will be performed. When passing a list of
+            strings, either an exact match will be performed or it is checked if the name of the module ends with any
+            of the passed strings. If this is specified as 'all-linear', then all linear/Conv1D modules are chosen,
+            excluding the output layer. If this is not specified, modules will be chosen according to the model
+            architecture. If the architecture is not known, an error will be raised -- in this case, you should specify
+            the target modules manually.
+        exclude_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to not apply the adapter. When passing a string, a regex match will be performed.
+            When passing a list of strings, either an exact match will be performed or it is checked if the name of the
+            module ends with any of the passed strings.
+        bias (`str`):
+            Bias type for DeLoRA. Can be 'none', 'all' or 'delora_only'. If 'all' or 'delora_only', the corresponding
+            biases will be updated during training. Be aware that this means that, even when disabling the adapters,
+            the model will not produce the same output as the base model would have without adaptation.
+        init_weights (`bool`):
+            Whether to perform initialization of adapter weights. If `True` (default): A is initialized with kaiming
+            uniform initialization, while B is initialized with zeros. If `False`: A and B are both initialized with
+            kaiming uniform, immediately contributing a non-zero delta. This is generally discouraged for normal use.
+        layers_to_transform (`Union[List[int], int]`):
+            The layer indices to transform. If a list of ints is passed, it will apply the adapter to the layer indices
+            that are specified in this list. If a single integer is passed, it will apply the transformations on the
+            layer at this index.
+        layers_pattern (`Optional[Union[List[str], str]]`):
+            The layer pattern name, used only if `layers_to_transform` is different from `None`. This should target the
+            `nn.ModuleList` of the model, which is often called `'layers'` or `'h'`.
+        rank_pattern (`dict`):
+            The mapping from layer names or regexp expression to ranks which are different from the default rank
+            specified by `r`. For example, `{'^model.decoder.layers.0.encoder_attn.k_proj': 16}`.
+        lambda_pattern (`dict`):
+            The mapping from layer names or regexp expression to lambdas which are different from the default lambda
+            specified by `delora_lambda`. For example, `{'^model.decoder.layers.0.encoder_attn.k_proj': 16}`.
+        modules_to_save (`Optional[List[str]]`):
+            List of modules apart from adapter layers to be set as trainable and saved in the final checkpoint.
+    """
+
+    r: int = field(default=8, metadata={"help": "DeLoRA rank"})
+    delora_lambda: int = field(
+        default=15,
+        metadata={
+            "help": "The initial value of the boundary of the DeLoRA adapter. This variable sets an upper bound to the "
+            "Frobenius norm of the weight change, avoiding the finetuned model to deviate too much from the original model."
+        },
+    )
+    module_dropout: float = field(
+        default=0.0, metadata={"help": "The dropout probability for disabling DeLoRA modules during training"}
+    )
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": "List of module names or regex expression of the module names to replace with DeLoRA."
+            "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$' "
+            "This can also be a wildcard 'all-linear' which matches all linear layers except the output layer."
+        },
+    )
+    exclude_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={"help": "List of module names or regex expression of the module names to exclude from DeLoRA."},
+    )
+    bias: Literal["none", "all", "delora_only"] = field(
+        default="none", metadata={"help": "Bias type for DeLoRA. Can be 'none', 'all' or 'delora_only'"}
+    )
+    init_weights: bool = field(
+        default=True,
+        metadata={
+            "help": "Whether to perform initialization of adapter weights. If `True` (default): A is initialized with kaiming uniform "
+            "initialization, while B is initialized with zeros. If `False`: A and B are both initialized with kaiming uniform, "
+            "immediately contributing a non-zero delta. This is generally discouraged for normal use."
+        },
+    )
+    layers_to_transform: Optional[Union[list[int], int]] = field(
+        default=None,
+        metadata={
+            "help": "The layer indexes to transform, is this argument is specified, PEFT will transform only the layers indexes that "
+            "are specified inside this list. If a single integer is passed, PEFT will transform only the layer at this index."
+        },
+    )
+    layers_pattern: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": "The layer pattern name, used only if `layers_to_transform` is different to None and if the layer pattern is not in the "
+            "common layers pattern. This should target the `nn.ModuleList` of the model, which is often called `'layers'` or `'h'`."
+        },
+    )
+    rank_pattern: Optional[dict] = field(
+        default_factory=dict,
+        metadata={
+            "help": "The mapping from layer names or regexp expression to ranks which are different from the default rank specified "
+            "by `r`. For example, `{'^model.decoder.layers.0.encoder_attn.k_proj': 16}`."
+        },
+    )
+    lambda_pattern: Optional[dict] = field(
+        default_factory=dict,
+        metadata={
+            "help": "The mapping from layer names or regexp expression to lambdas which are different from the default lambda specified by `delora_lambda`."
+        },
+    )
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": "List of modules apart from DeLoRA layers to be set as trainable and saved in the final checkpoint. "
+            "For example, in Sequence Classification or Token Classification tasks, the final layer `classifier/score` "
+            "are randomly initialized and as such need to be trainable and saved."
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        # PeftType enum members are uppercase; use DELORA
+        self.peft_type = PeftType.DELORA
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        self.exclude_modules = (
+            set(self.exclude_modules) if isinstance(self.exclude_modules, list) else self.exclude_modules
+        )
+        # if target_modules is a regex expression, then layers_to_transform should be None
+        if isinstance(self.target_modules, str) and self.layers_to_transform is not None:
+            raise ValueError("`layers_to_transform` cannot be used when `target_modules` is a str.")
+
+        # check for layers_to_transform and layers_pattern
+        if self.layers_pattern and not self.layers_to_transform:
+            raise ValueError("When `layers_pattern` is specified, `layers_to_transform` must also be specified. ")
+
+        if self.r <= 0:
+            raise ValueError(f"`r` must be a positive integer; got {self.r}.")
diff --git a/src/peft/tuners/delora/layer.py b/src/peft/tuners/delora/layer.py
new file mode 100644
index 0000000..789ee5b
--- /dev/null
+++ b/src/peft/tuners/delora/layer.py
@@ -0,0 +1,274 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import math
+import warnings
+from typing import Any, Optional
+
+import torch
+from torch import nn
+
+from peft.tuners._buffer_dict import BufferDict
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+
+from .config import DeloraConfig
+
+
+class DeloraLayer(BaseTunerLayer):
+    # All names of layers that may contain (trainable) adapter weights
+    adapter_layer_names = (
+        "delora_A",
+        "delora_B",
+        "delora_lambda",
+    )
+    # All names of other parameters that may contain adapter-related parameters
+    other_param_names = (
+        "r",
+        "delora_dropout",
+        "delora_w_norm",
+    )
+
+    def __init__(self, base_layer: nn.Module, **kwargs) -> None:
+        self.base_layer = base_layer
+        self.r = {}
+        self.delora_dropout = nn.ModuleDict({})
+        self.delora_A = nn.ParameterDict({})
+        self.delora_B = nn.ParameterDict({})
+        self.delora_lambda = nn.ParameterDict({})
+        # Use persistent buffers so they are included in state_dict and saved.
+        self.delora_w_norm = BufferDict({}, persistent=True)
+        # Mark the weight as unmerged
+        self._disable_adapters = False
+        self.merged_adapters = []
+        self.kwargs = kwargs
+
+        base_layer_mod = self.get_base_layer()
+        if isinstance(base_layer_mod, nn.Linear):
+            self.in_features, self.out_features = base_layer_mod.in_features, base_layer_mod.out_features
+        else:
+            raise TypeError(f"Unsupported layer type {type(base_layer_mod)}")
+
+    @staticmethod
+    def _compute_delta(
+        A: torch.Tensor, B: torch.Tensor, delora_lambda: torch.Tensor, r: int, w_norm: torch.Tensor
+    ) -> torch.Tensor:
+        """Compute delta = B @ diag(delora_lambda/r / (||A_i||*||B^j||)) @ A, scaled by provided w_norm (per-input channel)"""
+        An = torch.clamp(A.norm(dim=1), min=1e-4)
+        Bn = torch.clamp(B.norm(dim=0), min=1e-4)
+        diag = torch.diag_embed(delora_lambda / r / (An * Bn))
+        delta = B @ diag @ A
+        delta = delta * w_norm.unsqueeze(0)
+        return delta
+
+    def get_delta_weight(self, adapter: str) -> torch.Tensor:
+        if adapter not in self.delora_A or adapter not in self.delora_B:
+            raise ValueError(f"Adapter {adapter} not found.")
+
+        delta = self._compute_delta(
+            self.delora_A[adapter],
+            self.delora_B[adapter],
+            self.delora_lambda[adapter],
+            self.r[adapter],
+            self.delora_w_norm[adapter],
+        )
+        return delta
+
+    def update_layer(
+        self,
+        adapter_name: str,
+        r: int,
+        delora_lambda: float,
+        config: DeloraConfig,
+        **kwargs: Any,
+    ) -> None:
+        """Internal function to create delora adapter
+
+        Args:
+            adapter_name (`str`): Name for the adapter to add.
+            r (`int`): Rank for the added adapter.
+            delora_lambda (`float`): Boundary for the adapter's norm.
+            config (`DeloraConfig`): The adapter configuration for this layer.
+        """
+        module_dropout = config.module_dropout
+        init_weights = config.init_weights
+        inference_mode = config.inference_mode
+
+        if r <= 0:
+            raise ValueError(f"`r` should be a positive integer value but the value passed is {r}")
+
+        self.r[adapter_name] = r
+        self.delora_A[adapter_name] = nn.Parameter(torch.empty(r, self.in_features))
+        self.delora_B[adapter_name] = nn.Parameter(torch.empty(self.out_features, r))
+        self.delora_lambda[adapter_name] = nn.Parameter(torch.empty(1))
+        if module_dropout > 0.0:
+            module_dropout_layer = nn.Dropout(p=module_dropout)
+        else:
+            module_dropout_layer = nn.Identity()
+        self.delora_dropout.update(nn.ModuleDict({adapter_name: module_dropout_layer}))
+
+        # Initialize weights
+        self.reset_delora_parameters(adapter_name, init_weights, delora_lambda)
+
+        # Move new weights to device
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def reset_delora_parameters(
+        self,
+        adapter_name: str,
+        init_weights: bool = True,
+        delora_lambda: float = 15.0,
+    ) -> None:
+        if adapter_name not in self.delora_A.keys():
+            return
+
+        if init_weights is True:
+            nn.init.kaiming_uniform_(self.delora_A[adapter_name], a=math.sqrt(5))
+            nn.init.zeros_(self.delora_B[adapter_name])
+        else:
+            nn.init.kaiming_uniform_(self.delora_A[adapter_name], a=math.sqrt(5))
+            nn.init.kaiming_uniform_(self.delora_B[adapter_name], a=math.sqrt(5))
+
+        self.delora_lambda[adapter_name].data.fill_(float(delora_lambda))
+
+        # capture a fixed norm for this adapter to use for future delta computations
+        with torch.no_grad():
+            w = self.get_base_layer().weight
+            if w.device.type != "meta":
+                w_norm = torch.norm(w.data, dim=0).detach()
+            else:
+                # For meta tensors, we can't compute the norm, so use a default value
+                w_norm = torch.ones(w.shape[1], device=w.device)
+            self.delora_w_norm[adapter_name] = w_norm
+
+
+class DeloraLinear(nn.Module, DeloraLayer):
+    # DeLoRA implemented in a dense layer
+    def __init__(
+        self,
+        base_layer,
+        adapter_name: str,
+        config: DeloraConfig,
+        r: int,
+        delora_lambda: float,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        DeloraLayer.__init__(self, base_layer, **kwargs)
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, delora_lambda, config=config)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`list[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.delora_A.keys():
+                base_layer = self.get_base_layer()
+                delta_weight = (
+                    self.get_delta_weight(active_adapter)
+                    .detach()
+                    .to(dtype=base_layer.weight.dtype, device=base_layer.weight.device)
+                )
+                with torch.no_grad():
+                    if safe_merge:
+                        orig_weights = base_layer.weight.data.clone()
+                        orig_weights = orig_weights + delta_weight
+
+                        if not torch.isfinite(orig_weights).all():
+                            raise ValueError(
+                                f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                            )
+
+                        base_layer.weight.data = orig_weights
+                    else:
+                        base_layer.weight.data.add_(delta_weight)
+
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        Unmerge all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.delora_A.keys():
+                self.get_base_layer().weight.data -= self.get_delta_weight(active_adapter)
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        previous_dtype = x.dtype
+
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            if not self.active_adapters:
+                return self.base_layer(x, *args, **kwargs).to(previous_dtype)
+
+            base_out = self.base_layer(x, *args, **kwargs)
+            add_out = torch.zeros_like(base_out)
+
+            for adapter in self.active_adapters:
+                if adapter not in self.delora_A:
+                    continue
+
+                x_d = self.delora_dropout[adapter](x)
+
+                # Decomposed delta calculation
+                # 1. (x * w_norm) @ A.T
+                h = nn.functional.linear(x_d * self.delora_w_norm[adapter], self.delora_A[adapter])
+
+                # 2. h @ diag
+                An = torch.clamp(self.delora_A[adapter].norm(dim=1), min=1e-4)
+                Bn = torch.clamp(self.delora_B[adapter].norm(dim=0), min=1e-4)
+                scaling = (self.delora_lambda[adapter] / self.r[adapter]) / (An * Bn)
+
+                h = h * scaling
+
+                # 3. h @ B.T
+                h = nn.functional.linear(h, self.delora_B[adapter])
+
+                add_out += h
+
+            result = base_out + add_out.to(base_out.dtype)
+
+        result = result.to(previous_dtype)
+        return result
+
+    def supports_lora_conversion(self, adapter_name: str = "default") -> bool:
+        return True
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "delora." + rep
diff --git a/src/peft/tuners/delora/model.py b/src/peft/tuners/delora/model.py
new file mode 100644
index 0000000..b97998d
--- /dev/null
+++ b/src/peft/tuners/delora/model.py
@@ -0,0 +1,104 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import torch
+
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer
+from peft.utils import (
+    TRANSFORMERS_MODELS_TO_DELORA_TARGET_MODULES_MAPPING,
+)
+from peft.utils.other import get_pattern_key
+
+from .config import DeloraConfig
+from .layer import DeloraLayer, DeloraLinear
+
+
+class DeloraModel(BaseTuner):
+    """
+    Creates DeLoRA model from a pretrained transformers model.
+
+    The method is described in detail in [DeLoRA: Decoupled Low-rank
+    Adaptation](https://huggingface.co/papers/2503.18225).
+
+    Args:
+        model ([`torch.nn.Module`]): The model to be adapted.
+        config ([`DeloraConfig`]): The configuration of the DeLoRA model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+
+    Returns:
+        `torch.nn.Module`: The DeLoRA model.
+
+    **Attributes**:
+        - **model** ([`~transformers.PreTrainedModel`]) -- The model to be adapted.
+        - **peft_config** ([`DeloraConfig`]): The configuration of the DeLoRA model.
+    """
+
+    prefix: str = "delora_"
+    tuner_layer_cls = DeloraLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_DELORA_TARGET_MODULES_MAPPING
+
+    def _check_new_adapter_config(self, config: DeloraConfig) -> None:
+        """
+        A helper method to check the config when a new adapter is being added.
+
+        Raise a ValueError if there is something wrong with the config or if it conflicts with existing adapters.
+
+        """
+        super()._check_new_adapter_config(config)
+
+    def _create_and_replace(
+        self,
+        delora_config,
+        adapter_name,
+        target,
+        target_name,
+        parent,
+        current_key,
+        **optional_kwargs,
+    ):
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+
+        # Regexp matching - Find key which matches current target_name in patterns provided
+        r_key = get_pattern_key(delora_config.rank_pattern.keys(), current_key)
+        lambda_key = get_pattern_key(delora_config.lambda_pattern.keys(), current_key)
+        r = delora_config.rank_pattern.get(r_key, delora_config.r)
+        delora_lambda = delora_config.lambda_pattern.get(lambda_key, delora_config.delora_lambda)
+
+        kwargs = {
+            "r": r,
+            "delora_lambda": delora_lambda,
+        }
+
+        if isinstance(target, DeloraLinear):
+            target.update_layer(adapter_name, config=delora_config, **kwargs)
+        else:
+            new_module = self._create_new_module(delora_config, adapter_name, target, **kwargs)
+            if adapter_name != self.active_adapter:
+                # adding an additional adapter: it is not automatically trainable
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+    @staticmethod
+    def _create_new_module(delora_config, adapter_name, target, **kwargs):
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        if isinstance(target_base_layer, torch.nn.Linear):
+            new_module = DeloraLinear(target, adapter_name, config=delora_config, **kwargs)
+
+        return new_module
diff --git a/src/peft/tuners/fourierft/__init__.py b/src/peft/tuners/fourierft/__init__.py
new file mode 100644
index 0000000..dfe3f5d
--- /dev/null
+++ b/src/peft/tuners/fourierft/__init__.py
@@ -0,0 +1,24 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+from peft.utils import register_peft_method
+
+from .config import FourierFTConfig
+from .layer import FourierFTLayer, FourierFTLinear
+from .model import FourierFTModel
+
+
+__all__ = ["FourierFTConfig", "FourierFTLayer", "FourierFTLinear", "FourierFTModel"]
+
+register_peft_method(name="fourierft", model_cls=FourierFTModel, config_cls=FourierFTConfig)
diff --git a/src/peft/tuners/fourierft/config.py b/src/peft/tuners/fourierft/config.py
new file mode 100644
index 0000000..dbbb80d
--- /dev/null
+++ b/src/peft/tuners/fourierft/config.py
@@ -0,0 +1,206 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class FourierFTConfig(PeftConfig):
+    """
+    This is the configuration class to store the configuration of a [`FourierFTModel`].
+
+    Args:
+        n_frequency (`int`):
+            Num of learnable frequencies for the Discrete Fourier Transform. 'n_frequency' is an integer that is
+            greater than 0 and less than or equal to d^2 (assuming the weight W has dimensions of d by d).
+            Additionally, it is the number of trainable parameters required to update each delta W weight.
+            'n_frequency' will affect the performance and efficiency for PEFT. Specifically, it has little impact on
+            training speed, but higher values of it (typically) result in larger GPU memory costs and better accuracy.
+            With the same `target_modules`, the number of parameters of LoRA is (2*d*r/n_frequency) times that of
+            FourierFT. The following examples of settings regarding 'n_frequency' can be used as reference for users.
+            For NLU tasks with the RoBERTa-large model, adopting 'n_frequency': 1000 can almost achieve similar results
+            as 'r': 8 in LoRA. At this time, the number of parameters of LoRA is about 16 times that of FourierFT. For
+            image classification tasks with Vit-large models, adopting 'n_frequency': 3000 can almost achieve similar
+            results as 'r': 16 in LoRA, where the number of parameters of LoRA is about 11 times that of FourierFT.
+        scaling (`float`):
+            The scaling value for the delta W matrix. This is an important hyperparameter used for scaling, similar to
+            the 'lora_alpha' parameter in the LoRA method. 'scaling' can be determined during the hyperparameter search
+            process. However, if users want to skip this process, one can refer to the settings in the following
+            scenarios. This parameter can be set to 100.0 or 150.0 for both RoBERTa-base and RoBERTa-large models
+            across all NLU (GLUE) tasks. This parameter can be set to 300.0 for both LLaMA family models for all
+            instruction tuning. This parameter can be set to 300.0 for both ViT-base and ViT-large models across all
+            image classification tasks.
+        random_loc_seed (`int`):
+            Seed for the random location of the frequencies, i.e., the spectral entry matrix.
+        target_modules (`Union[list[str],str]`):
+            List of module names or regex expression of the module names to replace with FourierFT. For example, ['q',
+            'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'. Only linear layers are supported.
+        exclude_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to not apply the adapter. When passing a string, a regex match will be performed.
+            When passing a list of strings, either an exact match will be performed or it is checked if the name of the
+            module ends with any of the passed strings.
+        fan_in_fan_out (`bool`):
+            Set this to True if the layer to replace stores weight like (fan_in, fan_out).
+        bias (`str`):
+            Bias type for FourierFT. Can be 'none', 'all' or 'fourier_only'.
+        modules_to_save (`list[str]`):
+            List of modules apart from FourierFT layers to be set as trainable and saved in the final checkpoint. For
+            example, in Sequence Classification or Token Classification tasks, the final layer `classifier/score` are
+            randomly initialized and as such need to be trainable and saved.
+        layers_to_transform (`Union[list[int],int]`):
+            The layer indexes to transform, is this argument is specified, PEFT will transform only the layers indexes
+            that are specified inside this list. If a single integer is passed, PEFT will transform only the layer at
+            this index.
+        layers_pattern (`Optional[Union[List[str], str]]`):
+            The layer pattern name, used only if `layers_to_transform` is different to None and if the layer pattern is
+            not in the common layers pattern. This should target the `nn.ModuleList` of the model, which is often
+            called `'layers'` or `'h'`.
+        n_frequency_pattern (`dict`):
+            The mapping from layer names or regexp expression to n_frequency which are different from the default
+            specified. For example, `{model.decoder.layers.0.encoder_attn.k_proj: 1000`}.
+        init_weights (`bool`):
+            The initialization of the Fourier weights. Set this to False (the default) if the spectrum are initialized
+            to a standard normal distribution. Set this to True if the spectrum are initialized to zeros.
+    """
+
+    n_frequency: int = field(
+        default=1000,
+        metadata={
+            "help": (
+                "Num of learnable frequencies for the Discrete Fourier Transform. 'n_frequency' is an integer that is"
+                "greater than 0 and less than or equal to d^2 (assuming the weight W has dimensions of d by d)."
+                "Additionally, it is the number of trainable parameters required to update each delta W weight."
+                "'n_frequency' will affect the performance and efficiency for PEFT. Specifically, it has little impact on"
+                "training speed, but higher values of it (typically) result in larger GPU memory costs and better accuracy."
+                "With the same `target_modules`, the number of parameters of LoRA is (2*d*r/n_frequency) times that of FourierFT."
+                "The following examples of settings regarding 'n_frequency' can be used as reference for users. For NLU"
+                "tasks with the RoBERTa-large model, adopting 'n_frequency': 1000 can almost achieve similar results as"
+                "'r': 8 in LoRA. At this time, the number of parameters of LoRA is about 16 times that of FourierFT."
+                "For image classification tasks with Vit-large models, adopting 'n_frequency': 3000 can almost achieve"
+                "similar results as 'r': 16 in LoRA, where the number of parameters of LoRA is about 11 times that of FourierFT."
+            )
+        },
+    )
+    scaling: float = field(
+        default=150.0,
+        metadata={
+            "help": (
+                "The scaling value for the delta W matrix. This is an important hyperparameter used for scaling, similar to the"
+                "'lora_alpha' parameter in the LoRA method. 'scaling' can be determined during the hyperparameter search process."
+                "However, if users want to skip this process, one can refer to the settings in the following scenarios."
+                "This parameter can be set to 100.0 or 150.0 for both RoBERTa-base and RoBERTa-large models across all NLU (GLUE) tasks."
+                "This parameter can be set to 300.0 for both LLaMA family models for all instruction tuning."
+                "This parameter can be set to 300.0 for both ViT-base and ViT-large models across all image classification tasks."
+            )
+        },
+    )
+    random_loc_seed: Optional[int] = field(
+        default=777, metadata={"help": "Seed for the random location of the frequencies."}
+    )
+    fan_in_fan_out: bool = field(
+        default=False,
+        metadata={"help": "Set this to True if the layer to replace stores weight like (fan_in, fan_out)"},
+    )
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of module names or regex expression of the module names to replace with FourierFT."
+                "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'. "
+                "Only linear layers are supported."
+            )
+        },
+    )
+    exclude_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={"help": "List of module names or regex expression of the module names to exclude from fourierft."},
+    )
+    bias: str = field(
+        default="none", metadata={"help": "Bias type for FourierFT. Can be 'none', 'all' or 'fourier_only'."}
+    )
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of modules apart from FourierFT layers to be set as trainable and saved in the final checkpoint. For"
+                " example, in Sequence Classification or Token Classification tasks, the final layer"
+                " `classifier/score` are randomly initialized and as such need to be trainable and saved."
+            )
+        },
+    )
+    layers_to_transform: Optional[Union[list[int], int]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The layer indexes to transform, is this argument is specified, PEFT will transform only the layers"
+                " indexes that are specified inside this list. If a single integer is passed, PEFT will transform only"
+                " the layer at this index."
+            )
+        },
+    )
+    layers_pattern: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The layer pattern name, used only if `layers_to_transform` is different to None and if the layer"
+                " pattern is not in the common layers pattern. This should target the `nn.ModuleList` of the "
+                "model, which is often called `'layers'` or `'h'`."
+            )
+        },
+    )
+    n_frequency_pattern: Optional[dict] = field(
+        default_factory=dict,
+        metadata={
+            "help": (
+                "The mapping from layer names or regexp expression to n_frequency which are different from the default specified."
+                "For example, `{model.decoder.layers.0.encoder_attn.k_proj: 500`}."
+            )
+        },
+    )
+    init_weights: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "The initialization of the Fourier weights. Set this to False (the default) if the spectrum should be "
+                "initialized to a standard normal distribution. Set this to True if the spectrum should be initialized "
+                "to zeros."
+            )
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.FOURIERFT
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        self.exclude_modules = (
+            set(self.exclude_modules) if isinstance(self.exclude_modules, list) else self.exclude_modules
+        )
+        # if target_modules is a regex expression, then layers_to_transform should be None
+        if isinstance(self.target_modules, str) and self.layers_to_transform is not None:
+            raise ValueError("`layers_to_transform` cannot be used when `target_modules` is a str.")
+
+        # if target_modules is a regex expression, then layers_pattern should be None
+        if isinstance(self.target_modules, str) and self.layers_pattern is not None:
+            raise ValueError("`layers_pattern` cannot be used when `target_modules` is a str.")
+        # check for layers_to_transform and layers_pattern
+        if self.layers_pattern and not self.layers_to_transform:
+            raise ValueError("When `layers_pattern` is specified, `layers_to_transform` must also be specified. ")
diff --git a/src/peft/tuners/fourierft/layer.py b/src/peft/tuners/fourierft/layer.py
new file mode 100644
index 0000000..b1c45b1
--- /dev/null
+++ b/src/peft/tuners/fourierft/layer.py
@@ -0,0 +1,200 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+import warnings
+from typing import Any, Optional
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+from transformers.pytorch_utils import Conv1D
+
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+from peft.utils.other import transpose
+
+from .config import FourierFTConfig
+
+
+class FourierFTLayer(BaseTunerLayer):
+    # All names of layers that may contain (trainable) adapter weights
+    adapter_layer_names = ("fourierft_spectrum",)
+    # All names of other parameters that may contain adapter-related parameters
+    other_param_names = ("fourierft_n_frequency", "fourierft_scaling", "fourierft_random_loc_seed", "indices")
+
+    def __init__(self, base_layer: nn.Module, **kwargs) -> None:
+        self.base_layer = base_layer
+        self.fourierft_n_frequency = {}
+        self.fourierft_scaling = {}
+        self.fourierft_spectrum = nn.ParameterDict({})
+        self.indices = {}
+        self.fourierft_random_loc_seed = {}
+        # Mark the weight as unmerged
+        self._disable_adapters = False
+        self.merged_adapters = []
+        self.kwargs = kwargs
+
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            self.in_features, self.out_features = base_layer.in_features, base_layer.out_features
+        elif isinstance(base_layer, Conv1D):
+            self.in_features, self.out_features = (
+                base_layer.weight.ds_shape if hasattr(base_layer.weight, "ds_shape") else base_layer.weight.shape
+            )
+        else:
+            raise TypeError(f"Unsupported layer type {type(base_layer)}")
+
+    def update_layer(self, adapter_name: str, n_frequency: int, config: FourierFTConfig, **kwargs):
+        scaling = config.scaling
+        init_weights = config.init_weights
+        random_loc_seed = config.random_loc_seed
+        inference_mode = config.inference_mode
+
+        if n_frequency <= 0:
+            raise ValueError(f"`n_frequency` should be a positive integer value but the value passed is {n_frequency}")
+        if n_frequency > self.in_features * self.out_features:
+            raise ValueError(
+                f"`n_frequency` should be less than or equal to the product of the input and output dimensions "
+                f"but the value passed is {n_frequency} and the product is {self.in_features * self.out_features}"
+            )
+        self.fourierft_n_frequency[adapter_name] = n_frequency
+        self.fourierft_random_loc_seed[adapter_name] = random_loc_seed
+        self.indices[adapter_name] = torch.randperm(
+            self.out_features * self.in_features,
+            generator=torch.Generator().manual_seed(self.fourierft_random_loc_seed[adapter_name]),
+        )[:n_frequency]
+        self.indices[adapter_name] = torch.stack(
+            [self.indices[adapter_name] // self.in_features, self.indices[adapter_name] % self.in_features], dim=0
+        )
+        self.fourierft_scaling[adapter_name] = scaling
+        # Actual trainable parameters
+        self.fourierft_spectrum[adapter_name] = nn.Parameter(torch.randn(n_frequency), requires_grad=True)
+
+        if init_weights:
+            self.reset_fourier_parameters(adapter_name)
+
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    @torch.no_grad()
+    def reset_fourier_parameters(self, adapter_name):
+        if adapter_name in self.fourierft_spectrum.keys():
+            nn.init.zeros_(self.fourierft_spectrum[adapter_name])
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        # careful: ifft2 does not work with float16 or bfloat16
+        spectrum = self.fourierft_spectrum[adapter]
+        indices = self.indices[adapter].to(spectrum.device)
+        dense_spectrum = torch.zeros(self.out_features, self.in_features, device=spectrum.device)
+        dense_spectrum[indices[0, :], indices[1, :]] = spectrum.float()
+        delta_weight = torch.fft.ifft2(dense_spectrum).real * self.fourierft_scaling[adapter]
+        return delta_weight.to(spectrum.dtype)
+
+
+class FourierFTLinear(nn.Module, FourierFTLayer):
+    # FourierFT implemented in a dense layer
+    def __init__(
+        self,
+        base_layer,
+        adapter_name: str,
+        config: FourierFTConfig,
+        n_frequency: int = 1000,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        FourierFTLayer.__init__(self, base_layer, **kwargs)
+        self.fan_in_fan_out = config.fan_in_fan_out
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, n_frequency, config=config)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.fourierft_spectrum.keys():
+                base_layer = self.get_base_layer()
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    # because of the copy operation.
+                    orig_weights = base_layer.weight.data.clone()
+                    orig_weights += transpose(self.get_delta_weight(active_adapter), self.fan_in_fan_out)
+
+                    if not torch.isfinite(orig_weights).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = orig_weights
+                else:
+                    base_layer.weight.data += transpose(self.get_delta_weight(active_adapter), self.fan_in_fan_out)
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.fourierft_spectrum.keys():
+                self.get_base_layer().weight.data -= transpose(
+                    self.get_delta_weight(active_adapter), self.fan_in_fan_out
+                )
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        previous_dtype = x.dtype
+
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.fourierft_spectrum.keys():
+                    continue
+
+                delta_w = self.get_delta_weight(active_adapter)
+                x = x.to(delta_w.dtype)
+                result = result + F.linear(x, delta_w)
+
+        result = result.to(previous_dtype)
+        return result
+
+    def supports_lora_conversion(self, adapter_name: str = "default") -> bool:
+        # get_delta_weight does not transpose Conv1D because it is used in forward, therefore, it has the wrong
+        # shape for conversion
+        return not isinstance(self.get_base_layer(), Conv1D)
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "fourierft." + rep
diff --git a/src/peft/tuners/fourierft/model.py b/src/peft/tuners/fourierft/model.py
new file mode 100644
index 0000000..98b1680
--- /dev/null
+++ b/src/peft/tuners/fourierft/model.py
@@ -0,0 +1,118 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import re
+import warnings
+from itertools import chain
+
+import torch
+from transformers.pytorch_utils import Conv1D
+
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer
+from peft.utils import (
+    TRANSFORMERS_MODELS_TO_FOURIERFT_TARGET_MODULES_MAPPING,
+)
+
+from .layer import FourierFTLayer, FourierFTLinear
+
+
+class FourierFTModel(BaseTuner):
+    """
+    Creates FourierFT model from a pretrained transformers model.
+
+    The method is described in detail in https://huggingface.co/papers/2405.03003.
+
+    Args:
+        model ([`torch.nn.Module`]): The model to be adapted.
+        config ([`FourierFTConfig`]): The configuration of the FourierFT model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            Create empty adapter weights on meta device. Useful to speed up the loading process.
+
+    Returns:
+        `torch.nn.Module`: The FourierFT model.
+
+    **Attributes**:
+        - **model** ([`~transformers.PreTrainedModel`]) -- The model to be adapted.
+        - **peft_config** ([`FourierFTConfig`]): The configuration of the Fourier model.
+    """
+
+    prefix: str = "fourierft_"
+    tuner_layer_cls = FourierFTLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_FOURIERFT_TARGET_MODULES_MAPPING
+
+    def _create_and_replace(
+        self,
+        fourierft_config,
+        adapter_name,
+        target,
+        target_name,
+        parent,
+        current_key,
+        **optional_kwargs,
+    ):
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+        # Regexp matching - Find key which matches current target_name in patterns provided
+        pattern_keys = list(chain(fourierft_config.n_frequency_pattern.keys()))
+        target_name_key = next(filter(lambda key: re.match(rf".*\.{key}$", current_key), pattern_keys), current_key)
+
+        n_frequency = fourierft_config.n_frequency_pattern.get(target_name_key, fourierft_config.n_frequency)
+        kwargs = {
+            "n_frequency": n_frequency,
+        }
+        if isinstance(target, FourierFTLayer):
+            target.update_layer(
+                adapter_name,
+                n_frequency,
+                config=fourierft_config,
+            )
+        else:
+            new_module = self._create_new_module(fourierft_config, adapter_name, target, **kwargs)
+            if adapter_name != self.active_adapter:
+                # adding an additional adapter: it is not automatically trainable
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+    @staticmethod
+    def _create_new_module(fourierft_config, adapter_name, target, **kwargs):
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        if isinstance(target_base_layer, torch.nn.Linear):
+            if fourierft_config.fan_in_fan_out:
+                warnings.warn(
+                    "fan_in_fan_out is set to True but the target module is `torch.nn.Linear`. "
+                    "Setting fan_in_fan_out to False."
+                )
+                fourierft_config.fan_in_fan_out = False
+        elif isinstance(target_base_layer, Conv1D):
+            kwargs["is_target_conv_1d_layer"] = True
+            if not fourierft_config.fan_in_fan_out:
+                warnings.warn(
+                    "fan_in_fan_out is set to False but the target module is `Conv1D`. Setting fan_in_fan_out to True."
+                )
+                fourierft_config.fan_in_fan_out = True
+        else:
+            raise TypeError(
+                f"Target module {target} is not supported. Currently, only the following modules are supported: "
+                "`torch.nn.Linear`."
+            )
+
+        new_module = FourierFTLinear(target, adapter_name, config=fourierft_config, **kwargs)
+
+        return new_module
diff --git a/src/peft/tuners/frod/__init__.py b/src/peft/tuners/frod/__init__.py
new file mode 100644
index 0000000..b26001a
--- /dev/null
+++ b/src/peft/tuners/frod/__init__.py
@@ -0,0 +1,24 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+from peft.utils import register_peft_method
+
+from .config import FrodConfig
+from .layer import FrodLayer, Linear
+from .model import FrodModel
+
+
+__all__ = ["FrodConfig", "FrodLayer", "FrodModel", "Linear"]
+
+register_peft_method(name="frod", config_cls=FrodConfig, model_cls=FrodModel, prefix="frod_")
diff --git a/src/peft/tuners/frod/config.py b/src/peft/tuners/frod/config.py
new file mode 100644
index 0000000..9b61e43
--- /dev/null
+++ b/src/peft/tuners/frod/config.py
@@ -0,0 +1,192 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class FrodConfig(PeftConfig):
+    """
+    This is the configuration class to store the configuration of a [`FrodModel`].
+
+    Paper: https://doi.org/10.1609/aaai.v40i31.39813.
+
+    Args:
+        target_modules (`Union[List[str], str]`):
+            The names of the modules to apply FRoD to. Only linear layers are supported.
+        projection_prng_key (`int`):
+            Random seed used when initializing the sparse FRoD COO pattern.
+        save_projection (`bool`):
+            Whether to save the FRoD projection tensors in the state dict. This increases checkpoint size but makes
+            adapter reloading independent of local cache regeneration. Defaults to `True`.
+        frod_dropout (`float`):
+            The dropout probability for FRoD layers.
+        fan_in_fan_out (`bool`):
+            Set this to True if the layer to replace stores weight like (fan_in, fan_out). For example, gpt-2 uses
+            `Conv1D` which stores weights like (fan_in, fan_out) and hence this should be set to `True`.
+        bias (`str`):
+            Bias type for FRoD. Can be 'none', 'all' or 'frod_only'. If 'all' or 'frod_only', the corresponding biases
+            will be updated during training. Be aware that this means that, even when disabling the adapters, the model
+            will not produce the same output as the base model would have without adaptation.
+        modules_to_save (`List[str]`):
+            List of modules apart from FRoD layers to be set as trainable and saved in the final checkpoint.
+        init_weights (`bool`):
+            Whether to initialize the weights of the FRoD layers with their default initialization. Don't change this
+            setting, except if you know exactly what you're doing.
+        layers_to_transform (`Union[List[int],int]`):
+            The layer indexes to transform, if this argument is specified, it will apply the FRoD transformations on
+            the layer indexes that are specified in this list. If a single integer is passed, it will apply the FRoD
+            transformations on the layer at this index.
+        layers_pattern (`Optional[Union[List[str], str]]`):
+            The layer pattern name, used only if `layers_to_transform` is different from `None`. This should target the
+            `nn.ModuleList` of the model, which is often called `'layers'` or `'h'`.
+        sparse_rate (`float`):
+            Fraction of off-diagonal entries in the sparse trainable rotation matrix. Higher values increase capacity
+            and trainable parameters; lower values are cheaper. Defaults to `0.01`.
+        regularization_alpha (`float`):
+            Small positive value used while building the shared basis from base weights. It stabilizes the matrix
+            inverse when layers in the same category have correlated weights. Defaults to `1e-3`.
+        progressbar (`bool`):
+            Whether to show a progress bar while building the FRoD projections. Projection initialization can be slow
+            on large models because it runs matrix decompositions over the target module categories. Defaults to
+            `True`.
+        runtime_offload_base_weight (`bool`):
+            Whether to keep target base weights on CPU when the active FRoD path does not need them. This can reduce
+            GPU memory because FRoD reconstructs the adapted weight directly, but it changes the usual PEFT convention
+            that all base parameters stay on the accelerator after moving the model or running forward. Defaults to
+            `False`.
+    """
+
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of module names or regex expression of the module names to replace with FRoD."
+                "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'. "
+                "Only linear layers are supported."
+            )
+        },
+    )
+    projection_prng_key: int = field(
+        default=0,
+        metadata={"help": "Random seed used when initializing the FRoD sparse COO structure."},
+    )
+    save_projection: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "Whether to save the FRoD projection tensors in the state dict. This increases checkpoint size but "
+                "guarantees that we can reload the adapter on all system configurations."
+            )
+        },
+    )
+    frod_dropout: float = field(default=0.0, metadata={"help": "Dropout in the FRoD adapter layers"})
+    fan_in_fan_out: bool = field(
+        default=False,
+        metadata={"help": "Set this to True if the layer to replace stores weight like (fan_in, fan_out)"},
+    )
+    bias: str = field(default="none", metadata={"help": "Bias type for FRoD. Can be 'none', 'all' or 'frod_only'"})
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of modules apart from FRoD layers to be set as trainable and saved in the final checkpoint. For"
+                " example, in Sequence Classification or Token Classification tasks, the final layer"
+                " `classifier/score` are randomly initialized and as such need to be trainable and saved."
+            )
+        },
+    )
+    init_weights: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "Whether to initialize the weights of the FRoD layers with their default initialization. Don't change "
+                "this setting, except if you know exactly what you're doing."
+            ),
+        },
+    )
+    layers_to_transform: Optional[Union[list[int], int]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The layer indexes to transform, is this argument is specified, PEFT will transform only the layers"
+                " indexes that are specified inside this list. If a single integer is passed, PEFT will transform only"
+                " the layer at this index."
+            )
+        },
+    )
+    layers_pattern: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The layer pattern name, used only if `layers_to_transform` is different to None and if the layer "
+                "pattern is not in the common layers pattern. This should target the `nn.ModuleList` of the "
+                "model, which is often called `'layers'` or `'h'`."
+            )
+        },
+    )
+    sparse_rate: float = field(
+        default=0.01,
+        metadata={
+            "help": (
+                "Fraction of off-diagonal entries in the sparse trainable rotation matrix. Higher values increase "
+                "capacity and trainable parameters; lower values are cheaper."
+            )
+        },
+    )
+    regularization_alpha: float = field(
+        default=1e-3,
+        metadata={
+            "help": (
+                "Small positive value used while building the shared basis from base weights. It stabilizes matrix "
+                "inverses for correlated layers."
+            ),
+        },
+    )
+    progressbar: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "Whether to show a progress bar while building FRoD projections. Initialization can be slow on large "
+                "models because it runs matrix decompositions over the target module categories."
+            )
+        },
+    )
+    runtime_offload_base_weight: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Whether to keep target base weights on CPU when the active FRoD path does not need them. This reduces "
+                "GPU memory but does not preserve the usual PEFT invariant that all base parameters stay on the "
+                "accelerator after moving the model or running forward."
+            )
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.FROD
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        # check for layers_to_transform and layers_pattern
+        if self.layers_pattern and not self.layers_to_transform:
+            raise ValueError("When `layers_pattern` is specified, `layers_to_transform` must also be specified. ")
+        if self.sparse_rate < 0 or self.sparse_rate > 1:
+            raise ValueError(f"`sparse_rate` should be between 0 and 1, got {self.sparse_rate}.")
diff --git a/src/peft/tuners/frod/layer.py b/src/peft/tuners/frod/layer.py
new file mode 100644
index 0000000..077592b
--- /dev/null
+++ b/src/peft/tuners/frod/layer.py
@@ -0,0 +1,433 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+import warnings
+from typing import Optional
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from peft.tuners.tuners_utils import BaseTunerLayer, _get_in_out_features, check_adapters_to_merge
+from peft.utils.other import transpose
+
+from .._buffer_dict import BufferDict
+from .config import FrodConfig
+
+
+class FrodLayer(BaseTunerLayer):
+    adapter_layer_names = ("frod_lambda_l", "frod_lambda_s_values")
+    other_param_names = (
+        "r",
+        "frod_V",
+        "frod_U",
+        "frod_s_indices",
+        "frod_s_size",
+        "runtime_offload_base_weight",
+        "frod_dropout",
+    )
+
+    def __init__(self, base_layer: nn.Module, **kwargs):
+        self.base_layer = base_layer
+        self.r = {}
+        self.frod_dropout = nn.ModuleDict({})
+        self.runtime_offload_base_weight = {}
+
+        # Sparse S is parameterized by its COO values only.
+        self.frod_lambda_l = nn.ParameterDict({})
+        self.frod_lambda_s_values = nn.ParameterDict({})
+
+        # These are references to tuner-level projection buffers. Registering per-layer copies would duplicate the
+        # same shared V/S tensors on device when `model.to(...)` is called.
+        self.frod_s_indices: Optional[BufferDict] = None
+        self.frod_s_size: Optional[BufferDict] = None
+        self.frod_V: Optional[BufferDict] = None
+        self.frod_U: BufferDict = BufferDict({}, persistent=False)
+
+        self._disable_adapters = False
+        self.merged_adapters = []
+        self._frod_merged_delta = {}
+
+        self.in_features, self.out_features = _get_in_out_features(self.get_base_layer())
+        self.kwargs = kwargs
+
+    def update_layer(
+        self,
+        adapter_name,
+        frod_V: BufferDict,
+        frod_s_indices: BufferDict,
+        frod_s_size: BufferDict,
+        config: FrodConfig,
+    ):
+        frod_dropout = config.frod_dropout
+        init_weights = config.init_weights
+        base_layer = self.get_base_layer()
+        weight = base_layer.weight.T if self.fan_in_fan_out else base_layer.weight
+        device, dtype = self._get_adapter_target_device_dtype(base_layer.weight)
+
+        self.r[adapter_name] = self.out_features
+        self.runtime_offload_base_weight[adapter_name] = config.runtime_offload_base_weight
+        if frod_dropout > 0.0:
+            frod_dropout_layer = nn.Dropout(p=frod_dropout)
+        else:
+            frod_dropout_layer = nn.Identity()
+
+        self.frod_dropout[adapter_name] = frod_dropout_layer
+
+        if frod_V is None or frod_s_indices is None or frod_s_size is None:
+            raise ValueError("The FRoD projection buffers are missing. This should not happen.")
+        if adapter_name not in frod_V:
+            # FRoD projection buffers are shared across adapters for the same module category.
+            reference_adapter = next(iter(frod_V))
+            frod_V[adapter_name] = frod_V[reference_adapter].to(device="cpu")
+            frod_s_indices[adapter_name] = frod_s_indices[reference_adapter].to(device="cpu", dtype=torch.long)
+            frod_s_size[adapter_name] = frod_s_size[reference_adapter].to(device="cpu", dtype=torch.long)
+
+        frod_v = frod_V[adapter_name].to(dtype=dtype, device="cpu")
+        frod_s_index = frod_s_indices[adapter_name].to(device="cpu", dtype=torch.long)
+
+        nnz = frod_s_index.shape[1]
+        self.frod_lambda_s_values[adapter_name] = nn.Parameter(torch.zeros(nnz, device=device, dtype=dtype))
+
+        self._set_shared_projection_buffers(frod_V, frod_s_indices, frod_s_size)
+
+        U, L = self._calculate_frod_u_and_lambda(frod_v, weight)
+        U = U.to(dtype)
+        L = L.to(device=device, dtype=dtype)
+        self.frod_lambda_l[adapter_name] = nn.Parameter(L, requires_grad=True)
+        if init_weights:
+            self.reset_frod_parameters(adapter_name)
+        else:
+            with torch.no_grad():
+                nn.init.normal_(self.frod_lambda_s_values[adapter_name], std=0.1)
+                self.frod_lambda_l[adapter_name].add_(torch.randn_like(self.frod_lambda_l[adapter_name]) * 0.1)
+
+        # U is frozen but used in every active forward. Register it as a non-persistent buffer so it follows
+        # model.to(device) once instead of being repeatedly copied from CPU and retained in CUDA's allocation cache.
+        self.frod_U[adapter_name] = U.cpu()
+        self._move_adapter_to_device_of_base_layer(adapter_name, device=device)
+        self.set_adapter(self.active_adapters)
+
+    def _set_shared_projection_buffers(
+        self,
+        frod_V: BufferDict,
+        frod_s_indices: BufferDict,
+        frod_s_size: BufferDict,
+    ) -> None:
+        # FRoD owns projection buffers in FrodModel by module category. Unlike VeRA's single global projection dict,
+        # assigning these category-level BufferDicts as normal layer attributes would register them on every wrapped
+        # layer. Keep plain references so FrodModel remains the only registered owner.
+        object.__setattr__(self, "frod_V", frod_V)
+        object.__setattr__(self, "frod_s_indices", frod_s_indices)
+        object.__setattr__(self, "frod_s_size", frod_s_size)
+
+    def _calculate_frod_u_and_lambda(self, V, W):
+        w = W.detach().to(torch.float64).cpu()
+        v = V.detach().to(torch.float64).cpu()
+        try:
+            bi = torch.linalg.solve(v, w.T).T
+        except RuntimeError:
+            bi = w @ torch.linalg.pinv(v, rtol=1e-6).T
+        lambda_l = torch.linalg.norm(bi, dim=0)
+        u = torch.zeros_like(bi)
+        nonzero = lambda_l > 1e-12
+        u[:, nonzero] = bi[:, nonzero] / lambda_l[nonzero]
+        return u.float(), lambda_l.float()
+
+    def reset_frod_parameters(self, adapter_name):
+        if adapter_name in self.frod_lambda_s_values:
+            with torch.no_grad():
+                nn.init.zeros_(self.frod_lambda_s_values[adapter_name])
+
+
+class Linear(nn.Linear, FrodLayer):
+    def __init__(
+        self,
+        base_layer,
+        frod_V: BufferDict,
+        frod_s_indices: BufferDict,
+        frod_s_size: BufferDict,
+        adapter_name: str,
+        config: FrodConfig,
+        is_target_conv_1d_layer: bool = False,
+        **kwargs,
+    ) -> None:
+        super(nn.Linear, self).__init__()
+        FrodLayer.__init__(self, base_layer, **kwargs)
+        self.fan_in_fan_out = config.fan_in_fan_out
+
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, frod_V, frod_s_indices, frod_s_size, config=config)
+        self.is_target_conv_1d_layer = is_target_conv_1d_layer
+
+    def _apply(self, fn, recurse=True):
+        result = super()._apply(fn, recurse=recurse)
+        if any(self.runtime_offload_base_weight.values()):
+            self._offload_base_weight_to_cpu()
+        return result
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            return
+
+        base_layer = self.get_base_layer()
+        adapter_deltas = []
+        # FRoD deltas are computed against the current base weight, so compute all deltas before mutating it.
+        for active_adapter in adapter_names:
+            if active_adapter in self.frod_lambda_l.keys():
+                adapter_deltas.append((active_adapter, self.get_delta_weight(active_adapter)))
+
+        for active_adapter, delta_weight in adapter_deltas:
+            delta_weight = delta_weight.to(device=base_layer.weight.device, dtype=base_layer.weight.dtype)
+            if safe_merge:
+                orig_weights = base_layer.weight.data.clone()
+                orig_weights += delta_weight
+                if not torch.isfinite(orig_weights).all():
+                    raise ValueError(
+                        f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                    )
+                base_layer.weight.data = orig_weights
+            else:
+                base_layer.weight.data += delta_weight
+            self._frod_merged_delta[active_adapter] = delta_weight
+            self.merged_adapters.append(active_adapter)
+
+    def unload_and_optionally_merge_module(
+        self, merge: bool, safe_merge: bool, adapter_names: Optional[list[str]]
+    ) -> nn.Module:
+        if merge:
+            self.merge(safe_merge=safe_merge, adapter_names=adapter_names)
+        # The runtime offload path can keep the target base weight on CPU during active FRoD training. After unloading,
+        # the returned plain base layer must be back on the adapter/model device so the model remains usable.
+        self._move_base_weight_to_device_of_adapter(self.active_adapters[0] if self.active_adapters else None)
+        return self.get_base_layer()
+
+    def unmerge(self) -> None:
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.frod_lambda_l.keys():
+                delta_weight = self._frod_merged_delta.pop(active_adapter, None)
+                if delta_weight is None:
+                    delta_weight = self.get_delta_weight(active_adapter)
+                base_weight = self.get_base_layer().weight
+                delta_weight = delta_weight.to(device=base_weight.device, dtype=base_weight.dtype)
+                base_weight.data -= delta_weight
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        self._move_base_weight_to_device_of_adapter(adapter)
+        weight = self.get_base_layer().weight
+        device = weight.device
+        dtype = weight.dtype
+        base_weight = transpose(weight, self.fan_in_fan_out)
+        U, V, S_sparse, lambda_l = self._get_frod_tensors(adapter, device=device, dtype=dtype)
+        S = S_sparse.to_dense()
+        L = torch.diag_embed(lambda_l)
+        frod_weight = U @ (S + L) @ V.T
+
+        # FRoD parameterizes the adapted weight itself. Return only the difference so PEFT merge/unmerge and
+        # disable-adapter behavior preserve the base model while the active adapter still replaces the base weight.
+        return transpose(frod_weight - base_weight, self.fan_in_fan_out)
+
+    def _get_frod_tensors(
+        self, adapter: str, *, device: torch.device, dtype: torch.dtype
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        if self.frod_V is None or self.frod_s_indices is None or self.frod_s_size is None:
+            raise ValueError("FRoD projection buffers are missing. This should not happen.")
+
+        U = self.frod_U[adapter].to(device=device, dtype=dtype)
+        V = self.frod_V[adapter].to(device=device, dtype=dtype)
+        indices = self.frod_s_indices[adapter].to(device=device, dtype=torch.long)
+        size = tuple(int(dim) for dim in self.frod_s_size[adapter].tolist())
+        values = self.frod_lambda_s_values[adapter].to(device=device, dtype=dtype)
+        lambda_l = self.frod_lambda_l[adapter].to(device=device, dtype=dtype)
+        S_sparse = torch.sparse_coo_tensor(indices, values, size).coalesce()
+        return U, V, S_sparse, lambda_l
+
+    def _sparse_activation_mm(self, z_flat: torch.Tensor, S_sparse: torch.Tensor) -> torch.Tensor:
+        if S_sparse._nnz() == 0:
+            return torch.zeros_like(z_flat)
+        if z_flat.dtype in (torch.float16, torch.bfloat16):
+            # CUDA sparse addmm is not implemented for fp16/bf16 in some PyTorch builds. Densifying only the sparse S
+            # factor keeps the trainable COO parameterization while using the much faster dense GEMM kernel.
+            return z_flat @ S_sparse.to_dense().t()
+        return torch.sparse.mm(S_sparse, z_flat.t()).t()
+
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        previous_dtype = x.dtype
+
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            self._move_base_weight_to_device(x.device)
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            self._move_base_weight_to_device(x.device)
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            target_dtype = x.dtype
+            base_layer = self.get_base_layer()
+            bias = base_layer.bias
+            active_adapters = [
+                active_adapter
+                for active_adapter in self.active_adapters
+                if active_adapter in self.frod_lambda_s_values
+            ]
+            skip_base_layer = len(active_adapters) == 1 and (
+                isinstance(self.frod_dropout[active_adapters[0]], nn.Identity)
+                or not self.frod_dropout[active_adapters[0]].training
+            )
+            # With one active adapter and no stochastic dropout, FRoD computes the reconstructed adapted weight
+            # directly, so the target base linear result is not needed for the forward pass.
+            if skip_base_layer:
+                if self.runtime_offload_base_weight.get(active_adapters[0], False):
+                    self._offload_base_weight_to_cpu()
+                result = None
+                base_out = None
+            else:
+                self._move_base_weight_to_device(x.device)
+                result = self.base_layer(x, *args, **kwargs)
+                base_out = result if bias is None else result - bias
+
+            base_weight = None
+            for active_adapter in active_adapters:
+                U, V, S_sparse, lambda_l = self._get_frod_tensors(active_adapter, device=x.device, dtype=target_dtype)
+
+                dropout = self.frod_dropout[active_adapter]
+                h = dropout(x)
+
+                batch_shape = h.shape[:-1]
+                h_flat = h.reshape(-1, h.shape[-1])
+                z_flat = torch.matmul(h_flat, V)
+
+                z_S_flat = self._sparse_activation_mm(z_flat, S_sparse)
+                z_L_flat = z_flat * lambda_l
+
+                out_add_flat = F.linear(z_S_flat + z_L_flat, U)
+                out_add = out_add_flat.reshape(*batch_shape, out_add_flat.shape[-1])
+                # FRoD reconstructs the adapted weight directly, so subtract the base-weight contribution and only
+                # accumulate the adapter delta.
+                if skip_base_layer:
+                    adapter_base_out = None
+                elif isinstance(dropout, nn.Identity) or not dropout.training:
+                    adapter_base_out = base_out
+                else:
+                    if base_weight is None:
+                        base_weight = transpose(base_layer.weight, self.fan_in_fan_out).to(
+                            device=x.device, dtype=target_dtype
+                        )
+                    adapter_base_out = F.linear(h, base_weight)
+
+                if adapter_base_out is None:
+                    result = out_add if bias is None else out_add + bias
+                else:
+                    result = result + out_add - adapter_base_out
+
+            if result is None:
+                self._move_base_weight_to_device(x.device)
+                result = self.base_layer(x, *args, **kwargs)
+
+        result = result.to(previous_dtype)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "frod." + rep
+
+    def _move_adapter_to_device_of_base_layer(self, adapter_name: str, device: Optional[torch.device] = None) -> None:
+        """Move trainable FRoD parameters while keeping shared projection buffers on CPU."""
+        base_layer = self.get_base_layer()
+        base_device, base_dtype = self._get_base_layer_device_and_dtype(base_layer)
+
+        target_device = device if device is not None else base_device
+        adapter_device, adapter_dtype = self._get_existing_adapter_device_dtype(adapter_name)
+        if (target_device is None or target_device.type == "cpu") and adapter_device is not None:
+            target_device = adapter_device
+            if base_dtype is None:
+                base_dtype = adapter_dtype
+        if target_device is None:
+            return
+
+        target_dtype = None
+        if base_dtype is not None and (base_dtype.is_floating_point or base_dtype.is_complex):
+            target_dtype = base_dtype
+
+        for adapter_layer_name in self.adapter_layer_names:
+            adapter_layer = getattr(self, adapter_layer_name, None)
+            if not isinstance(adapter_layer, nn.ParameterDict):
+                continue
+            if adapter_name not in adapter_layer:
+                continue
+            param = adapter_layer[adapter_name]
+            if param.is_meta:
+                continue
+            if target_dtype is not None:
+                adapter_layer[adapter_name] = param.to(target_device, dtype=target_dtype)
+            else:
+                adapter_layer[adapter_name] = param.to(target_device)
+
+    def _get_existing_adapter_device_dtype(
+        self, adapter_name: Optional[str] = None
+    ) -> tuple[Optional[torch.device], Optional[torch.dtype]]:
+        adapter_names = [adapter_name] if adapter_name is not None else []
+        adapter_names.extend(name for name in self.frod_lambda_l.keys() if name != adapter_name)
+
+        for name in adapter_names:
+            for adapter_layer_name in self.adapter_layer_names:
+                adapter_layer = getattr(self, adapter_layer_name, None)
+                if not isinstance(adapter_layer, nn.ParameterDict) or name not in adapter_layer:
+                    continue
+                param = adapter_layer[name]
+                if param.is_meta:
+                    continue
+                return param.device, param.dtype
+        return None, None
+
+    def _get_adapter_target_device_dtype(self, weight: torch.Tensor) -> tuple[torch.device, torch.dtype]:
+        if weight.device.type != "cpu":
+            return weight.device, weight.dtype
+
+        adapter_device, adapter_dtype = self._get_existing_adapter_device_dtype()
+        if adapter_device is not None:
+            return adapter_device, adapter_dtype
+        return weight.device, weight.dtype
+
+    def _move_base_weight_to_device(self, device: torch.device) -> None:
+        weight = self.get_base_layer().weight
+        if weight.is_meta or weight.device == device:
+            return
+        weight.data = weight.data.to(device=device)
+        if weight.grad is not None:
+            weight.grad = weight.grad.to(device=device)
+
+    def _move_base_weight_to_device_of_adapter(self, adapter_name: Optional[str]) -> None:
+        adapter_device, _ = self._get_existing_adapter_device_dtype(adapter_name)
+        bias = getattr(self.get_base_layer(), "bias", None)
+        bias_device = getattr(bias, "device", None)
+        if bias_device is not None and (adapter_device is None or adapter_device.type == "cpu"):
+            adapter_device = bias_device
+        if adapter_device is not None:
+            self._move_base_weight_to_device(adapter_device)
+
+    def _offload_base_weight_to_cpu(self) -> None:
+        weight = self.get_base_layer().weight
+        if weight.is_meta or weight.device.type == "cpu":
+            return
+        weight.data = weight.data.cpu()
+        if weight.grad is not None:
+            weight.grad = weight.grad.cpu()
diff --git a/src/peft/tuners/frod/model.py b/src/peft/tuners/frod/model.py
new file mode 100644
index 0000000..98907f7
--- /dev/null
+++ b/src/peft/tuners/frod/model.py
@@ -0,0 +1,317 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+import warnings
+from collections import defaultdict
+
+import torch
+from torch import nn
+from tqdm import tqdm
+from transformers.pytorch_utils import Conv1D
+
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer
+from peft.utils import TRANSFORMERS_MODELS_TO_FROD_TARGET_MODULES_MAPPING
+
+from .._buffer_dict import BufferDict
+from ..tuners_utils import _maybe_include_all_linear_layers
+from .config import FrodConfig
+from .layer import FrodLayer, Linear
+
+
+def _category_from_key(key: str) -> str:
+    """Infer the projection-sharing category from a dotted module key.
+
+    FRoD shares projection buffers across modules that play the same role in different transformer blocks. This helper
+    assumes keys follow the dotted paths returned by `named_modules()` and derives the role from the final path
+    components. For example, `encoder.layer.0.attention.self.query` maps to `self_query`, while
+    `vision_model.encoder.layers.0.self_attn.q_proj` maps to `self_attn_q_proj`. The BERT-style attention output key
+    `encoder.layer.0.attention.output.dense` is normalized to `attention_output` so it does not collide with MLP
+    `output.dense` modules.
+    """
+    parts = key.split(".")
+    if len(parts) == 1:
+        return parts[0]
+    if parts[-2].isdigit():
+        return parts[-1]
+    category = f"{parts[-2]}_{parts[-1]}"
+    if (category == "output_dense") and (len(parts) >= 3) and (parts[-3] == "attention"):
+        return "attention_output"
+    return category
+
+
+def _layer_index_from_key(key: str, fallback: int) -> int:
+    """Infer the transformer block index from a dotted module key.
+
+    Many decoder and vision models use paths like `model.layers.3.self_attn.q_proj`, so the first preference is the
+    integer immediately after a `layers` path component. Encoder models often use paths like
+    `encoder.layer.11.attention.self.query`; for those, the first numeric path component is used. If no numeric layer
+    id is present, e.g. for `classifier.dense`, `fallback` keeps the projection initialization order deterministic.
+    """
+    parts = key.split(".")
+    if "layers" in parts:
+        try:
+            return int(parts[parts.index("layers") + 1])
+        except (ValueError, IndexError):
+            pass
+    for part in parts:
+        if part.isdigit():
+            return int(part)
+    return fallback
+
+
+def _projection_from_weights(matrices: list[torch.Tensor], regularization_alpha: float) -> torch.Tensor:
+    stacked = torch.cat(matrices, dim=0)
+    if stacked.shape[0] < stacked.shape[1]:
+        _, _, vh = torch.linalg.svd(stacked, full_matrices=True)
+        return vh.T
+
+    q_matrix, r_matrix = torch.linalg.qr(stacked)
+    q_slices = []
+    start = 0
+    for matrix in matrices:
+        rows = matrix.shape[0]
+        q_slices.append(q_matrix[start : start + rows, :])
+        start += rows
+
+    dim = r_matrix.shape[1]
+    t_pi = torch.zeros((dim, dim), dtype=r_matrix.dtype)
+    # Layers of the same projection category can be highly correlated; this ridge term keeps the inverse stable.
+    for q_slice in q_slices:
+        q_term = q_slice.T @ q_slice + regularization_alpha * torch.eye(dim, dtype=r_matrix.dtype)
+        t_pi += torch.linalg.inv(q_term)
+    t_pi /= len(q_slices)
+
+    _, eigenvectors = torch.linalg.eigh(t_pi)
+    return r_matrix.T @ eigenvectors
+
+
+class FrodModel(BaseTuner):
+    prefix: str = "frod_"
+    tuner_layer_cls = FrodLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_FROD_TARGET_MODULES_MAPPING
+
+    def _init_frod_projections(self, config: FrodConfig, adapter_name: str) -> None:
+        weights = defaultdict(dict)
+        model_config = self.get_model_config(self.model)
+        peft_config = self._prepare_adapter_config(config, model_config)
+        peft_config = _maybe_include_all_linear_layers(peft_config, self.model)
+
+        fallback_index = 0
+        for key, module in self.model.named_modules():
+            if not self._check_target_module_exists(peft_config, key):
+                continue
+
+            if isinstance(module, nn.Linear):
+                weight = module.weight
+            elif isinstance(module, Conv1D):
+                weight = module.weight.T
+            else:
+                continue
+
+            category = _category_from_key(key)
+            layer_idx = _layer_index_from_key(key, fallback_index)
+            fallback_index += 1
+            weights[layer_idx][category] = weight
+
+        if not weights:
+            raise ValueError(
+                "No layer types compatible with FRoD were found. Please check `peft_config.target_modules`."
+            )
+
+        # BaseTuner.__init__() enters the pre-injection flow before a FrodModel subclass
+        # could assign ModuleDicts after super().__init__(), so create these containers lazily here.
+        if not hasattr(self, "frod_V"):
+            self.frod_V = nn.ModuleDict()
+            self.frod_s_indices = nn.ModuleDict()
+            self.frod_s_size = nn.ModuleDict()
+
+        generator = torch.Generator(device="cpu").manual_seed(config.projection_prng_key)
+        categories = sorted({category for layer_dict in weights.values() for category in layer_dict})
+        progress_bar = tqdm(
+            categories,
+            disable=not config.progressbar,
+            desc="FRoD hierarchical joint decomposition",
+            unit="category",
+        )
+        for category in progress_bar:
+            matrices = [
+                layer_dict[category].detach().to(torch.float32).cpu()
+                for _, layer_dict in sorted(weights.items())
+                if category in layer_dict
+            ]
+            if not matrices:
+                continue
+            progress_bar.set_postfix(category=category, layers=len(matrices), dim=matrices[0].shape[1])
+
+            v_matrix = _projection_from_weights(matrices, config.regularization_alpha)
+            example_weight = next(layer_dict[category] for layer_dict in weights.values() if category in layer_dict)
+            v_tensor = v_matrix.to(dtype=example_weight.dtype, device="cpu")
+
+            if category not in self.frod_V:
+                self.frod_V[category] = BufferDict({}, persistent=config.save_projection)
+            self.frod_V[category][adapter_name] = v_tensor
+
+            in_dim = v_tensor.shape[0]
+            rows, cols = torch.meshgrid(torch.arange(in_dim), torch.arange(in_dim), indexing="ij")
+            mask_indices = torch.stack([rows.flatten(), cols.flatten()], dim=1)
+            non_diag_indices = mask_indices[mask_indices[:, 0] != mask_indices[:, 1]]
+            nnz = min(int(in_dim * in_dim * config.sparse_rate), non_diag_indices.shape[0])
+            if (config.sparse_rate > 0) and (non_diag_indices.shape[0] > 0):
+                nnz = max(1, nnz)
+            if nnz:
+                perm = torch.randperm(non_diag_indices.shape[0], generator=generator)[:nnz]
+                indices = non_diag_indices[perm].t().contiguous()
+            else:
+                indices = torch.empty(2, 0, dtype=torch.long)
+            size = torch.tensor([in_dim, in_dim], dtype=torch.long)
+
+            if category not in self.frod_s_indices:
+                self.frod_s_indices[category] = BufferDict({}, persistent=config.save_projection)
+            self.frod_s_indices[category][adapter_name] = indices.to(torch.long)
+            if category not in self.frod_s_size:
+                self.frod_s_size[category] = BufferDict({}, persistent=config.save_projection)
+            self.frod_s_size[category][adapter_name] = size
+
+    def _pre_injection_hook(self, model: nn.Module, config: FrodConfig, adapter_name: str) -> None:
+        self._init_frod_projections(config, adapter_name)
+
+    def _cast_adapter_dtype(self, adapter_name: str, autocast_adapter_dtype: bool = True) -> None:
+        super()._cast_adapter_dtype(adapter_name, autocast_adapter_dtype)
+
+        if not autocast_adapter_dtype:
+            return
+
+        for module in self.model.modules():
+            if not isinstance(module, FrodLayer) or adapter_name not in module.frod_U:
+                continue
+            _, base_dtype = module._get_base_layer_device_and_dtype(module.get_base_layer())
+            if base_dtype is not None and (base_dtype.is_floating_point or base_dtype.is_complex):
+                module.frod_U[adapter_name] = module.frod_U[adapter_name].to(dtype=base_dtype)
+
+    def _check_new_adapter_config(self, config: FrodConfig) -> None:
+        super()._check_new_adapter_config(config)
+
+        for existing_config in self.peft_config.values():
+            if existing_config is config:
+                continue
+            if existing_config.projection_prng_key != config.projection_prng_key:
+                raise ValueError(
+                    f"FRoD projection initialization key must be the same for all adapters. Got "
+                    f"{config.projection_prng_key=} but previous config had "
+                    f"{existing_config.projection_prng_key}."
+                )
+
+        save_projection_values = sorted({config.save_projection for config in self.peft_config.values()})
+        if len(save_projection_values) > 1:
+            raise ValueError(
+                "FRoD projection weights must be saved for all adapters or none, but got multiple different values: "
+                f"{save_projection_values}"
+            )
+
+        runtime_offload_values = sorted({config.runtime_offload_base_weight for config in self.peft_config.values()})
+        if len(runtime_offload_values) > 1:
+            raise ValueError(
+                "FRoD runtime base-weight offloading must be enabled for all adapters or none, but got multiple "
+                f"different values: {runtime_offload_values}"
+            )
+
+    def _create_and_replace(
+        self,
+        frod_config: FrodConfig,
+        adapter_name,
+        target,
+        target_name,
+        parent,
+        current_key,
+        **optional_kwargs,
+    ):
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+
+        category = _category_from_key(current_key)
+        if category not in self.frod_V:
+            self._init_frod_projections(frod_config, adapter_name)
+        bias = hasattr(target, "bias") and target.bias is not None
+
+        if isinstance(target, Linear):
+            target.update_layer(
+                adapter_name,
+                self.frod_V[category],
+                self.frod_s_indices[category],
+                self.frod_s_size[category],
+                config=frod_config,
+            )
+        else:
+            new_module = self._create_new_module(
+                frod_config,
+                self.frod_V[category],
+                self.frod_s_indices[category],
+                self.frod_s_size[category],
+                adapter_name,
+                target,
+                bias=bias,
+            )
+            if adapter_name not in self.active_adapters:
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+    @staticmethod
+    def _create_new_module(
+        frod_config: FrodConfig,
+        frod_V,
+        frod_s_indices,
+        frod_s_size,
+        adapter_name,
+        target,
+        **kwargs,
+    ):
+        bias = kwargs.pop("bias", False)
+
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        if isinstance(target_base_layer, torch.nn.Linear):
+            if frod_config.fan_in_fan_out:
+                warnings.warn(
+                    "fan_in_fan_out is set to True but the target module is `torch.nn.Linear`. "
+                    "Setting fan_in_fan_out to False."
+                )
+                frod_config.fan_in_fan_out = False
+        elif isinstance(target_base_layer, Conv1D):
+            kwargs["is_target_conv_1d_layer"] = True
+            if not frod_config.fan_in_fan_out:
+                warnings.warn(
+                    "fan_in_fan_out is set to False but the target module is `Conv1D`. Setting fan_in_fan_out to True."
+                )
+                frod_config.fan_in_fan_out = True
+        else:
+            raise TypeError(
+                f"Target module {target} is not supported. Currently, only the following modules are supported: "
+                "`torch.nn.Linear`, `transformers.pytorch_utils.Conv1D`."
+            )
+
+        return Linear(
+            target,
+            frod_V,
+            frod_s_indices,
+            frod_s_size,
+            adapter_name,
+            config=frod_config,
+            bias=bias,
+            **kwargs,
+        )
diff --git a/src/peft/tuners/glora/__init__.py b/src/peft/tuners/glora/__init__.py
new file mode 100644
index 0000000..5a67244
--- /dev/null
+++ b/src/peft/tuners/glora/__init__.py
@@ -0,0 +1,24 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+from peft.utils import register_peft_method
+
+from .config import GloraConfig
+from .layer import GloraLayer, GloraLinear
+from .model import GloraModel
+
+
+__all__ = ["GloraConfig", "GloraLayer", "GloraLinear", "GloraModel"]
+
+register_peft_method(name="glora", config_cls=GloraConfig, model_cls=GloraModel)
diff --git a/src/peft/tuners/glora/config.py b/src/peft/tuners/glora/config.py
new file mode 100644
index 0000000..ca30455
--- /dev/null
+++ b/src/peft/tuners/glora/config.py
@@ -0,0 +1,152 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+from dataclasses import dataclass, field
+from typing import Literal, Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class GloraConfig(PeftConfig):
+    """
+    This is the configuration class to store the configuration of a [`GloraModel`].
+
+    Glora modifies a frozen linear layer W0 as: `W_eff = W0 + W0 * A + B` and `b_eff = b0 + b0 * D + E + W0 @ C`.
+
+    Each matrix (A, B, C, D, E) can be parameterized independently. The config values control how many parameters are
+    used and what shapes they can express:
+
+    - `lora`: Low-rank decomposition `Xd @ Xu` with shapes `(out, r)` and `(r, in)`. Uses `r * (out + in)` parameters
+      and can express any rank-r correction. Like standard LoRA.
+    - `vector`: A single column vector of shape `(out, 1)`, broadcast across the full matrix. Uses `out` parameters;
+      only per-output-channel scaling or shifts.
+    - `constant`: A single scalar shared across all elements. Uses 1 parameter; most constrained.
+    - `none`: Zeros, no trainable parameters. Effectively disables this path.
+
+    Args:
+        r (`int`): Rank of the low-rank decomposition used when a config is set to `lora`.
+        target_modules (`Optional[Union[List[str], str]]`): The names of the modules to apply Glora to.
+        config_A_B (`str`): Parameterization for the A and B matrices (weight multiplicative and additive
+            corrections). Valid values: `lora`, `vector`, `constant`, `none`.
+        config_C (`str`): Parameterization for the C matrix (weight-to-bias coupling: b += W0 @ C).
+            Valid values: `lora`, `vector`, `none`.
+        config_D_E (`str`): Parameterization for the D and E scalars (bias multiplicative and additive
+            corrections). Does not support `lora` since D and E are bias-sized vectors, not matrices. Valid values:
+            `vector`, `constant`, `none`.
+        init_weights (`bool`): If True (default), initialize GLoRA as a no-op (zeros). If False,
+            use kaiming initialization so the adapter is not a no-op.
+    """
+
+    r: int = field(
+        default=8, metadata={"help": "Default rank of the LoRA matrices if the config contains lora parametrization."}
+    )
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": "List of module names or regex expression of the module names to replace with Glora."
+            "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$' "
+        },
+    )
+    bias: str = field(
+        default="none",
+        metadata={
+            "help": (
+                "Bias handling: 'none', 'all', or 'glora_only' (train bias on GLoRA layers when adapters are active)."
+            )
+        },
+    )
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of modules apart from GLoRA layers to be set as trainable and saved in the final checkpoint."
+            )
+        },
+    )
+
+    config_A_B: Literal["lora", "vector", "constant", "none"] = field(
+        default="lora",
+        metadata={
+            "help": (
+                "Parameterization for A and B (weight multiplicative and additive corrections: "
+                "W_eff = W0 + W0*A + B). "
+                "'lora': low-rank Xd@Xu (out x r and r x in), r*(out+in) params, most expressive. "
+                "'vector': per-output-channel scalar (out params). "
+                "'constant': single scalar (1 param). "
+                "'none': disabled (0 params). "
+            )
+        },
+    )
+
+    config_C: Literal["lora", "vector", "none"] = field(
+        default="lora",
+        metadata={
+            "help": (
+                "Parameterization for C (weight-to-bias coupling: b += W0 @ C). "
+                "'lora': low-rank column Xd@Xu (in x r and r x 1), couples bias to a rank-r projection of W0. "
+                "'vector': single (in x 1) column, couples each bias element to a weighted sum of W0 rows. "
+                "'none': disabled (0 params). "
+            )
+        },
+    )
+
+    config_D_E: Literal["vector", "constant", "none"] = field(
+        default="constant",
+        metadata={
+            "help": (
+                "Parameterization for D and E (bias multiplicative and additive corrections: "
+                "b_eff = b0 + b0*D + E). "
+                "'vector': per-output-channel value (out params). "
+                "'constant': single scalar shared across all bias elements (1 param). "
+                "'none': disabled (0 params). "
+                "Does not support 'lora' since D and E are bias-length vectors, not matrices. "
+            )
+        },
+    )
+
+    init_weights: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "If True, initialize GLoRA as a no-op (zeros for down-projection). "
+                "If False, use kaiming initialization so the adapter output is not identity."
+            )
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.GLORA
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+
+        valid_A_B = {"lora", "vector", "constant", "none"}
+        valid_C = {"lora", "vector", "none"}
+        valid_D_E = {"vector", "constant", "none"}
+
+        if self.config_A_B not in valid_A_B:
+            raise ValueError(
+                f"Invalid config_A_B value: {self.config_A_B!r}. Valid values are: {', '.join(sorted(valid_A_B))}."
+            )
+        if self.config_C not in valid_C:
+            raise ValueError(
+                f"Invalid config_C value: {self.config_C!r}. Valid values are: {', '.join(sorted(valid_C))}."
+            )
+        if self.config_D_E not in valid_D_E:
+            raise ValueError(
+                f"Invalid config_D_E value: {self.config_D_E!r}. Valid values are: {', '.join(sorted(valid_D_E))}."
+            )
diff --git a/src/peft/tuners/glora/layer.py b/src/peft/tuners/glora/layer.py
new file mode 100644
index 0000000..fe435e2
--- /dev/null
+++ b/src/peft/tuners/glora/layer.py
@@ -0,0 +1,393 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+import math
+from typing import Any, Optional
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+
+from .config import GloraConfig
+
+
+class GloraPath(nn.Module):
+    def forward(self):
+        raise NotImplementedError
+
+    def reset_parameters(self, init_weights: bool = True):
+        raise NotImplementedError
+
+
+class GloraLoraPath(GloraPath):
+    def __init__(self, out_features, in_features, r, init_weights: bool = True):
+        super().__init__()
+        self.Xd = nn.Parameter(torch.zeros(out_features, r))
+        self.Xu = nn.Parameter(torch.zeros(r, in_features))
+        self.reset_parameters(init_weights)
+
+    def reset_parameters(self, init_weights: bool = True):
+        nn.init.kaiming_uniform_(self.Xu, a=math.sqrt(5))
+        if init_weights:
+            nn.init.zeros_(self.Xd)
+        else:
+            nn.init.kaiming_uniform_(self.Xd, a=math.sqrt(5))
+
+    def forward(self):
+        return self.Xd @ self.Xu
+
+
+class GloraVectorPath(GloraPath):
+    def __init__(self, features, is_column=True, init_weights: bool = True):
+        super().__init__()
+        shape = (features, 1) if is_column else (features,)
+        self.X = nn.Parameter(torch.zeros(*shape))
+        self.reset_parameters(init_weights)
+
+    def reset_parameters(self, init_weights: bool = True):
+        if init_weights:
+            nn.init.zeros_(self.X)
+        else:
+            nn.init.kaiming_uniform_(self.X.unsqueeze(0) if self.X.dim() == 1 else self.X, a=math.sqrt(5))
+
+    def forward(self):
+        return self.X
+
+
+class GloraScalarPath(GloraPath):
+    def __init__(self, init_weights: bool = True):
+        super().__init__()
+        self.X = nn.Parameter(torch.zeros(1))
+        self.reset_parameters(init_weights)
+
+    def reset_parameters(self, init_weights: bool = True):
+        if init_weights:
+            nn.init.zeros_(self.X)
+        else:
+            nn.init.normal_(self.X, mean=0.0, std=0.02)
+
+    def forward(self):
+        return self.X[0]
+
+
+class GloraEmptyPath(GloraPath):
+    def __init__(self, shape=None):
+        super().__init__()
+        if shape is not None:
+            self.register_buffer("zeros", torch.zeros(shape))
+        else:
+            self.zeros = 0.0
+
+    def forward(self):
+        return self.zeros
+
+    def reset_parameters(self, init_weights: bool = True):
+        pass
+
+
+class GloraLayer(BaseTunerLayer):
+    adapter_layer_names = (
+        "glora_A",
+        "glora_B",
+        "glora_C",
+        "glora_D",
+        "glora_E",
+    )
+    other_param_names = ("r",)
+
+    def __init__(self, base_layer: nn.Module, **kwargs) -> None:
+        self.base_layer = base_layer
+        self.in_features: int
+        self.out_features: int
+        base = self.get_base_layer()
+        self.in_features = base.in_features
+        self.out_features = base.out_features
+
+        base.weight.requires_grad = False
+        if getattr(base, "bias", None) is not None:
+            base.bias.requires_grad = False
+
+        self.r: dict[str, int] = {}
+        self.glora_A: nn.ModuleDict = nn.ModuleDict()
+        self.glora_B: nn.ModuleDict = nn.ModuleDict()
+        self.glora_C: nn.ModuleDict = nn.ModuleDict()
+        self.glora_D: nn.ModuleDict = nn.ModuleDict()
+        self.glora_E: nn.ModuleDict = nn.ModuleDict()
+        self.merged_adapters: list[str] = []
+        self._disable_adapters: bool = False
+        self._active_adapter: str | list[str] = []
+        self.kwargs: dict[str, Any] = dict(kwargs)
+
+    def update_layer(self, adapter_name: str, r: int, config: GloraConfig, **kwargs) -> None:
+        config_A_B = config.config_A_B
+        config_C = config.config_C
+        config_D_E = config.config_D_E
+        init_weights = config.init_weights
+
+        self.r[adapter_name] = r
+
+        if config_A_B == "lora":
+            self.glora_A[adapter_name] = GloraLoraPath(self.out_features, self.in_features, r, init_weights)
+            self.glora_B[adapter_name] = GloraLoraPath(self.out_features, self.in_features, r, init_weights)
+        elif config_A_B == "vector":
+            self.glora_A[adapter_name] = GloraVectorPath(self.out_features, is_column=True, init_weights=init_weights)
+            self.glora_B[adapter_name] = GloraVectorPath(self.out_features, is_column=True, init_weights=init_weights)
+        elif config_A_B == "constant":
+            self.glora_A[adapter_name] = GloraScalarPath(init_weights=init_weights)
+            self.glora_B[adapter_name] = GloraScalarPath(init_weights=init_weights)
+        else:
+            self.glora_A[adapter_name] = GloraEmptyPath(shape=(self.out_features, self.in_features))
+            self.glora_B[adapter_name] = GloraEmptyPath(shape=(self.out_features, self.in_features))
+
+        base = self.get_base_layer()
+        has_bias = getattr(base, "bias", None) is not None
+
+        if has_bias and config_C == "lora":
+            self.glora_C[adapter_name] = GloraLoraPath(self.in_features, 1, r, init_weights)
+        elif has_bias and config_C == "vector":
+            self.glora_C[adapter_name] = GloraVectorPath(self.in_features, is_column=True, init_weights=init_weights)
+        else:
+            self.glora_C[adapter_name] = GloraEmptyPath(shape=(self.in_features, 1))
+
+        if has_bias and config_D_E == "vector":
+            self.glora_D[adapter_name] = GloraVectorPath(self.out_features, is_column=False, init_weights=init_weights)
+            self.glora_E[adapter_name] = GloraVectorPath(self.out_features, is_column=False, init_weights=init_weights)
+        elif has_bias and config_D_E == "constant":
+            self.glora_D[adapter_name] = GloraScalarPath(init_weights=init_weights)
+            self.glora_E[adapter_name] = GloraScalarPath(init_weights=init_weights)
+        else:
+            self.glora_D[adapter_name] = GloraEmptyPath(shape=(self.out_features,))
+            self.glora_E[adapter_name] = GloraEmptyPath(shape=(self.out_features,))
+
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=config.inference_mode)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        # we unmerge any previously merged adapters and re-merge all active adapters
+        # check https://github.com/huggingface/peft/pull/3098#discussion_r3117924518
+        # for details on why we do this instead of merging directly on top of already merged weights
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            return
+
+        # Unmerge any already-merged adapters so we start from the original W0,
+        # then re-merge them all together. This avoids the sequential composition
+        # problem where adapter 2's delta would be computed against the already-
+        # modified weight instead of the original W0.
+        previously_merged: list[str] = list(self.merged_adapters)
+        if previously_merged:
+            self.unmerge()
+        all_adapters = previously_merged + [name for name in adapter_names if name in self.glora_A]
+
+        base_layer = self.get_base_layer()
+        weight = self.weight
+        bias = self.bias
+        device, dtype = weight.device, weight.dtype
+
+        # Read the original weights directly as the reference for the merge math. The base layer
+        # is only reassigned at the very end (after the safe_merge check), so it stays untouched
+        # until then and needs no defensive clone here.
+        w0 = weight.data
+        b0 = bias.data if bias is not None else None
+
+        # The accumulator must be a separate tensor from `w0`: each adapter's update reads the
+        # original weights (`w0 * A`), so accumulating in place on `w0` would feed the next adapter
+        # the already-merged weights and corrupt multi-adapter merges.
+        new_weight = w0.clone()
+        new_bias = b0.clone() if b0 is not None else None
+
+        for adapter_name in all_adapters:
+            A = self.glora_A[adapter_name]().to(device=device, dtype=dtype)
+            B = self.glora_B[adapter_name]().to(device=device, dtype=dtype)
+            new_weight += w0 * A + B
+            if b0 is not None:
+                C = self.glora_C[adapter_name]().to(device=device, dtype=dtype)
+                D = self.glora_D[adapter_name]().to(device=device, dtype=dtype)
+                E = self.glora_E[adapter_name]().to(device=device, dtype=dtype)
+                new_bias += b0 * D + E + torch.matmul(w0, C).squeeze(-1)
+
+        if safe_merge:
+            if not torch.isfinite(new_weight).all():
+                raise ValueError(
+                    f"NaNs detected in the merged weights. The adapter {', '.join(all_adapters)} seems to be broken"
+                )
+            if new_bias is not None and not torch.isfinite(new_bias).all():
+                raise ValueError(
+                    f"NaNs detected in the merged weights. The adapter {', '.join(all_adapters)} seems to be broken"
+                )
+
+        base_layer.weight.data = new_weight
+        if new_bias is not None:
+            base_layer.bias.data = new_bias
+
+        for adapter_name in all_adapters:
+            self.merged_adapters.append(adapter_name)
+
+    def unmerge(self, adapter_names: Optional[list[str]] = None) -> None:
+        if adapter_names is None:
+            adapter_names = list(self.merged_adapters)
+
+        adapters_to_unmerge = [name for name in adapter_names if name in self.merged_adapters and name in self.glora_A]
+        if not adapters_to_unmerge:
+            return
+
+        # Recover W0 by subtracting all merged adapter contributions.
+        # W_merged = W0 * (1 + sum(Ai)) + sum(Bi), so:
+        # W0 = (W_merged - sum(Bi)) / (1 + sum(Ai))
+        base_layer = self.get_base_layer()
+        weight = self.weight
+        bias = self.bias
+        device, dtype = weight.device, weight.dtype
+
+        all_merged = [name for name in self.merged_adapters if name in self.glora_A]
+        sum_A = torch.zeros_like(weight.data)
+        sum_B = torch.zeros_like(weight.data)
+        sum_D = torch.zeros_like(bias.data) if bias is not None else None
+        sum_E = torch.zeros_like(bias.data) if bias is not None else None
+        sum_WC = torch.zeros_like(bias.data) if bias is not None else None
+
+        for adapter_name in all_merged:
+            A = self.glora_A[adapter_name]().to(device=device, dtype=dtype)
+            B = self.glora_B[adapter_name]().to(device=device, dtype=dtype)
+            sum_A += A
+            sum_B += B
+
+        w0 = (weight.data - sum_B) / (1.0 + sum_A)
+
+        if bias is not None:
+            for adapter_name in all_merged:
+                C = self.glora_C[adapter_name]().to(device=device, dtype=dtype)
+                D = self.glora_D[adapter_name]().to(device=device, dtype=dtype)
+                E = self.glora_E[adapter_name]().to(device=device, dtype=dtype)
+                sum_D += D
+                sum_E += E
+                sum_WC += torch.matmul(w0, C).squeeze(-1)
+            b0 = (bias.data - sum_E - sum_WC) / (1.0 + sum_D)
+
+        # Set weights back to W0
+        base_layer.weight.data = w0
+        if bias is not None:
+            base_layer.bias.data = b0
+
+        for adapter_name in adapters_to_unmerge:
+            self.merged_adapters.remove(adapter_name)
+
+        # Re-merge the remaining adapters against W0
+        remaining = [name for name in self.merged_adapters if name in self.glora_A]
+        if remaining:
+            # Clear merged_adapters and re-merge from scratch
+            self.merged_adapters.clear()
+            self.merge(adapter_names=remaining)
+
+
+class GloraLinear(nn.Module, GloraLayer):
+    """GLoRA adapter wrapping a dense [`~torch.nn.Linear`] `base_layer`."""
+
+    def __init__(self, base_layer: nn.Module, adapter_name: str, config, **kwargs) -> None:
+        super().__init__()
+        GloraLayer.__init__(self, base_layer, **kwargs)
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, config.r, config=config)
+
+    def _check_forward_args(self, x, *args, **kwargs):
+        adapter_names = kwargs.get("adapter_names", None)
+        if adapter_names is None:
+            return
+
+        if len(x) != len(adapter_names):
+            msg = (
+                "Length of `adapter_names` should be the same as the number of inputs, but got "
+                f"{len(adapter_names)} and {len(x)} respectively."
+            )
+            raise ValueError(msg)
+
+        if self.merged:
+            msg = "Cannot pass `adapter_names` when there are merged adapters, please call `unmerge_adapter` first."
+            raise ValueError(msg)
+
+    def _mixed_batch_forward(
+        self, x: torch.Tensor, *args: Any, adapter_names: list[str], **kwargs: Any
+    ) -> torch.Tensor:
+        result = self.base_layer(x, *args, **kwargs)
+        base_result = result.clone()
+        unique_adapters = set(adapter_names)
+        sub_batch_indices_list = [
+            [i for i, a in enumerate(adapter_names) if a == adapter] for adapter in unique_adapters
+        ]
+        device, dtype = self.weight.device, self.weight.dtype
+        for i, active_adapter in enumerate(unique_adapters):
+            if active_adapter not in self.glora_A:
+                continue
+            A = self.glora_A[active_adapter]().to(device=device, dtype=dtype)
+            B = self.glora_B[active_adapter]().to(device=device, dtype=dtype)
+            C = self.glora_C[active_adapter]().to(device=device, dtype=dtype)
+            D = self.glora_D[active_adapter]().to(device=device, dtype=dtype)
+            E = self.glora_E[active_adapter]().to(device=device, dtype=dtype)
+            idx = sub_batch_indices_list[i]
+            sub_batch = x[idx]
+            weight_eff = self.weight + self.weight * A + B
+            if self.bias is not None:
+                bias_eff = self.bias + self.bias * D + E + torch.matmul(self.weight, C).squeeze(-1)
+                adapted = F.linear(sub_batch, weight_eff, bias=bias_eff)
+            else:
+                adapted = F.linear(sub_batch, weight_eff)
+            result[idx] = result[idx] + (adapted - base_result[idx])
+        return result
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        self._check_forward_args(x, *args, **kwargs)
+        adapter_names = kwargs.pop("adapter_names", None)
+
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif adapter_names is not None:
+            result = self._mixed_batch_forward(x, *args, adapter_names=adapter_names, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            base_result = self.base_layer(x, *args, **kwargs)
+            torch_result_dtype = base_result.dtype
+            result = base_result
+            device, dtype = self.weight.device, self.weight.dtype
+            num_active_adapters = 0
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.glora_A:
+                    continue
+                num_active_adapters += 1
+                A = self.glora_A[active_adapter]().to(device=device, dtype=dtype)
+                B = self.glora_B[active_adapter]().to(device=device, dtype=dtype)
+                C = self.glora_C[active_adapter]().to(device=device, dtype=dtype)
+                D = self.glora_D[active_adapter]().to(device=device, dtype=dtype)
+                E = self.glora_E[active_adapter]().to(device=device, dtype=dtype)
+                weight_eff = self.weight + self.weight * A + B
+                if self.bias is not None:
+                    bias_eff = self.bias + self.bias * D + E + torch.matmul(self.weight, C).squeeze(-1)
+                    adapted = F.linear(x, weight_eff, bias=bias_eff)
+                else:
+                    adapted = F.linear(x, weight_eff)
+                result = result + adapted
+            if num_active_adapters > 0:
+                result = result - num_active_adapters * base_result
+            result = result.to(torch_result_dtype)
+
+        return result
+
+    def __repr__(self) -> str:
+        return "glora." + super().__repr__()
diff --git a/src/peft/tuners/glora/model.py b/src/peft/tuners/glora/model.py
new file mode 100644
index 0000000..57e628b
--- /dev/null
+++ b/src/peft/tuners/glora/model.py
@@ -0,0 +1,115 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+from contextlib import contextmanager
+from functools import partial
+from typing import Any
+
+from torch import nn
+
+from peft.tuners.glora.layer import GloraLayer
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer
+from peft.utils import TRANSFORMERS_MODELS_TO_GLORA_TARGET_MODULES_MAPPING
+
+from .config import GloraConfig
+from .layer import GloraLinear
+
+
+def _adapter_names_pre_forward_hook(target, args, kwargs, adapter_names):
+    kwargs["adapter_names"] = adapter_names
+    return args, kwargs
+
+
+class GloraModel(BaseTuner):
+    """
+    Creates Generalized Low Rank Adapter (GLoRA) model from a pretrained transformers model.
+    """
+
+    prefix: str = "glora_"
+    tuner_layer_cls = GloraLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_GLORA_TARGET_MODULES_MAPPING
+
+    def _create_and_replace(
+        self,
+        peft_config: GloraConfig,
+        adapter_name: str,
+        target: nn.Module,
+        target_name: str,
+        parent: nn.Module,
+        current_key: str,
+        **optional_kwargs: Any,
+    ) -> None:
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+
+        if isinstance(target, GloraLinear):
+            target.update_layer(adapter_name, peft_config.r, config=peft_config)
+            if adapter_name not in self.active_adapters:
+                target.requires_grad_(False)
+        else:
+            new_module = self._create_new_module(peft_config, adapter_name, target)
+            if adapter_name not in self.active_adapters:
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+    @staticmethod
+    def _create_new_module(
+        peft_config: GloraConfig,
+        adapter_name: str,
+        target: nn.Module,
+        **optional_kwargs: Any,
+    ) -> GloraLinear:
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        if type(target_base_layer) is not nn.Linear:
+            raise ValueError(
+                f"Target module {target} is not a plain torch.nn.Linear (after unwrapping); "
+                "GLoRA does not support this layer type."
+            )
+
+        return GloraLinear(target, adapter_name, config=peft_config)
+
+    @contextmanager
+    def _enable_peft_forward_hooks(self, *args, **kwargs):
+        adapter_names = kwargs.pop("adapter_names", None)
+        if adapter_names is None:
+            yield
+            return
+
+        if self.training:
+            raise ValueError("Cannot pass `adapter_names` when the model is in training mode.")
+
+        expected_adapters = set()
+        for layer in self.modules():
+            if isinstance(layer, GloraLayer):
+                expected_adapters |= layer.glora_A.keys()
+        unique_adapters = {name for name in adapter_names if name != "__base__"}
+        unexpected_adapters = unique_adapters - expected_adapters
+        if unexpected_adapters:
+            raise ValueError(f"Trying to infer with non-existing adapter(s): {', '.join(sorted(unexpected_adapters))}")
+
+        hook_handles = []
+        for module in self.modules():
+            if isinstance(module, GloraLayer):
+                pre_forward = partial(_adapter_names_pre_forward_hook, adapter_names=adapter_names)
+                handle = module.register_forward_pre_hook(pre_forward, with_kwargs=True)
+                hook_handles.append(handle)
+
+        yield
+
+        for handle in hook_handles:
+            handle.remove()
diff --git a/src/peft/tuners/gralora/__init__.py b/src/peft/tuners/gralora/__init__.py
new file mode 100644
index 0000000..830e0a4
--- /dev/null
+++ b/src/peft/tuners/gralora/__init__.py
@@ -0,0 +1,24 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from peft.utils import register_peft_method
+
+from .config import GraloraConfig
+from .layer import GraloraLayer
+from .model import GraloraModel
+
+
+__all__ = ["GraloraConfig", "GraloraLayer", "GraloraModel"]
+
+register_peft_method(name="gralora", config_cls=GraloraConfig, model_cls=GraloraModel)
diff --git a/src/peft/tuners/gralora/config.py b/src/peft/tuners/gralora/config.py
new file mode 100644
index 0000000..224d1a3
--- /dev/null
+++ b/src/peft/tuners/gralora/config.py
@@ -0,0 +1,186 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from dataclasses import dataclass, field
+from typing import Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class GraloraConfig(PeftConfig):
+    """
+    This is the configuration class to store the configuration of a [`GraloraModel`].
+
+    Args:
+        r (`int`):
+            GraLoRA attention dimension determines the rank of the GraLoRA adapter. The total parameter count of the
+            GraLoRA adapter is same as LoRA with same rank r, while the expressivitiy is multiplied by gralora_k.
+        hybrid_r (`int`):
+            Hybrid GraLoRA rank determines the rank allocated to vanilla LoRA method when using Hybrid GraLoRA method.
+            Hybrid GraLoRA, a combination of GraLoRA and vanilla LoRA, becomes available when hybrid_r > 0. The
+            parameter count of the GraLoRA adapter is r + hybrid_r.
+        target_modules (`Union[List[str], str]`):
+            List of module names or regex expression of the module names to replace with GraLoRA. " For example, ['q',
+            'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'. " This can also be a wildcard 'all-linear'
+            which matches all linear/Conv1D " "(if the model is a PreTrainedModel, the output layer excluded). " If not
+            specified, modules will be chosen according to the model architecture, If the architecture is " not known,
+            an error will be raised -- in this case, you should specify the target modules manually. " To avoid
+            targeting any modules (because you want to apply `target_parameters`), set " `target_modules=[]`.
+        alpha (`int`): GraLoRA alpha.
+            GraLoRA alpha is the scaling factor for the GraLoRA adapter. Scale becomes alpha / (r + hybrid_r).
+        gralora_dropout (`float`):
+            GraLoRA dropout is the dropout probability for the GraLoRA adapter. It is used to prevent overfitting and
+            improve the generalization of the GraLoRA adapter.
+        gralora_k (`int`):
+            GraLoRA k determines the number of subblocks in the GraLoRA adapter. The rank r must be divisible by
+            gralora_k for the GraLoRA adapter to be valid. The total parameter count is preserved regardless of
+            gralora_k. The entire rank of the GraLoRA adapter is increased by gralora_k, while the rank of each
+            subblock is reduced by gralora_k. gralora_k=2 is recommended for rank 32 or lower, and gralora_k=4 is
+            recommended for rank 64 or higher.
+        fan_in_fan_out (`bool`):
+            Set this to True if the layer to replace stores weight like (fan_in, fan_out). For example, gpt-2 uses
+            `Conv1D` which stores weights like (fan_in, fan_out) and hence this should be set to `True`.
+        bias (`str`):
+            Bias type for gralora. Can be 'none', 'all' or 'gralora_only'. If 'all' or 'gralora_only', the
+            corresponding biases will be updated during training. Be aware that this means that, even when disabling
+            the adapters, the model will not produce the same output as the base model would have without adaptation.
+        modules_to_save (`Optional[list[str]]`):
+            List of modules apart from gralora layers to be set as trainable and saved in the final checkpoint. For
+            example, in Sequence Classification or Token Classification tasks, the final layer `classifier/score` are
+            randomly initialized and as such need to be trainable and saved.
+        init_weights (`bool`):
+            Whether to initialize the weights of the GraLoRA layers with their default initialization. Don't change
+            this setting, except if you know exactly what you're doing.
+        layers_to_transform (`Union[List[int], int]`):
+            The layer indexes to transform, is this argument is specified, PEFT will transform only the layers indexes
+            that are specified inside this list. If a single integer is passed, PEFT will transform only the layer at
+            this index. This only works when target_modules is a list of str.
+        layers_pattern (`Optional[Union[List[str], str]]`):
+            The layer pattern name, used only if `layers_to_transform` is different to None and if the layer pattern is
+            not in the common layers pattern. This only works when target_modules is a list of str. This should target
+            the `nn.ModuleList` of the model, which is often called `'layers'` or `'h'`.
+    """
+
+    r: int = field(
+        default=32,
+        metadata={
+            "help": (
+                "GraLoRA attention dimension determines the rank of the GraLoRA adapter. "
+                "The total parameter count of the GraLoRA adapter is same as LoRA with same rank r, while the expressivitiy is multiplied by gralora_k."
+            )
+        },
+    )
+    hybrid_r: int = field(
+        default=0,
+        metadata={
+            "help": (
+                "hybrid_r is the rank allocated to vanilla LoRA method when using Hybrid GraLoRA method. "
+                "Hybrid GraLoRA, a combination of GraLoRA and vanilla LoRA, becomes available when hybrid_r > 0. "
+                "r + hybrid_r determines the parameter count of the GraLoRA adapter."
+            )
+        },
+    )
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of module names or regex expression of the module names to replace with LoRA. "
+                "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'. "
+                "This can also be a wildcard 'all-linear' which matches all linear/Conv1D "
+                "(if the model is a PreTrainedModel, the output layer excluded). "
+                "If not specified, modules will be chosen according to the model architecture, If the architecture is "
+                "not known, an error will be raised -- in this case, you should specify the target modules manually. "
+                "To avoid targeting any modules (because you want to apply `target_parameters`), set "
+                "`target_modules=[]`."
+            )
+        },
+    )
+    alpha: int = field(
+        default=64,
+        metadata={
+            "help": (
+                "gralora alpha is the scaling factor for the GraLoRA adapter. Scale becomes alpha / (r + hybrid_r). "
+            )
+        },
+    )
+    gralora_dropout: float = field(default=0.0, metadata={"help": "gralora dropout"})
+    gralora_k: int = field(
+        default=2,
+        metadata={
+            "help": (
+                "gralora_k determines the number of subblocks in the GraLoRA adapter. "
+                "The rank r must be divisible by gralora_k for the GraLoRA adapter to be valid. "
+                "The total parameter count is preserved regardless of gralora_k. "
+                "The entire rank of the GraLoRA adapter is increased by gralora_k, while the rank of each subblock is reduced by gralora_k. "
+                "gralora_k=2 is recommended for rank 32 or lower, and gralora_k=4 is recommended for rank 64 or higher. "
+            )
+        },
+    )
+    fan_in_fan_out: bool = field(
+        default=False,
+        metadata={"help": "Set this to True if the layer to replace stores weight like (fan_in, fan_out)"},
+    )
+    bias: str = field(
+        default="none", metadata={"help": "Bias type for gralora. Can be 'none', 'all' or 'gralora_only'"}
+    )
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of modules apart from gralora layers to be set as trainable and saved in the final checkpoint. For"
+                " example, in Sequence Classification or Token Classification tasks, the final layer"
+                " `classifier/score` are randomly initialized and as such need to be trainable and saved."
+            )
+        },
+    )
+    init_weights: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "Whether to initialize the weights of the GraLoRA layers with their default initialization. "
+                "Don't change this setting, except if you know exactly what you're doing."
+            )
+        },
+    )
+    layers_to_transform: Optional[Union[list[int], int]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The layer indexes to transform, is this argument is specified, PEFT will transform only the layers indexes that are specified inside this list. "
+                "If a single integer is passed, PEFT will transform only the layer at this index. "
+                "This only works when target_modules is a list of str."
+            )
+        },
+    )
+    layers_pattern: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The layer pattern name, used only if `layers_to_transform` is different to None and if the layer pattern is not in the common layers pattern. "
+                "This only works when target_modules is a list of str. This should target the `nn.ModuleList` of the "
+                "model, which is often called `'layers'` or `'h'`."
+            )
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.GRALORA
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        if self.r % self.gralora_k != 0:
+            raise ValueError(f"r should be divisible by gralora_k, but got {self.r} and {self.gralora_k}")
diff --git a/src/peft/tuners/gralora/layer.py b/src/peft/tuners/gralora/layer.py
new file mode 100644
index 0000000..2edae5d
--- /dev/null
+++ b/src/peft/tuners/gralora/layer.py
@@ -0,0 +1,394 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+import math
+import warnings
+from typing import Optional
+
+import torch
+from torch import nn
+from transformers.pytorch_utils import Conv1D
+
+from peft.tuners.tuners_utils import BaseTunerLayer
+from peft.utils.other import transpose
+
+from .config import GraloraConfig
+
+
+class GraloraLayer(BaseTunerLayer):
+    # List all names of layers that may contain adapter weight
+    adapter_layer_names = ("gralora_A", "gralora_B", "gralora_A_general", "gralora_B_general")
+    other_param_names = ("r", "hybrid_r", "alpha", "scaling", "gralora_dropout", "gralora_k")
+
+    def __init__(self, base_layer: nn.Module, **kwargs):
+        self.base_layer = base_layer
+        self.r = {}
+        self.alpha = {}
+        self.gralora_k = {}
+        self.hybrid_r = {}
+        self.scaling = {}
+        self.gralora_dropout = nn.ModuleDict({})
+
+        self.gralora_A = nn.ParameterDict({})
+        self.gralora_B = nn.ParameterDict({})
+        self.gralora_A_general = nn.ModuleDict({})
+        self.gralora_B_general = nn.ModuleDict({})
+
+        # Mark the weight as unmerged
+        self._disable_adapters = False
+        self.merged_adapters = []
+
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            in_features, out_features = base_layer.in_features, base_layer.out_features
+        elif isinstance(base_layer, Conv1D):
+            in_features, out_features = (
+                base_layer.weight.ds_shape if hasattr(base_layer.weight, "ds_shape") else base_layer.weight.shape
+            )
+        else:
+            raise NotImplementedError(f"Unsupported layer type {type(base_layer)}")
+
+        self.in_features = in_features
+        self.out_features = out_features
+        self.kwargs = kwargs
+
+    def update_layer(
+        self,
+        adapter_name: str,
+        module_name: str,
+        r: int,
+        config: GraloraConfig,
+    ):
+        alpha = config.alpha
+        gralora_dropout = config.gralora_dropout
+        gralora_k = config.gralora_k
+        hybrid_r = config.hybrid_r
+        init_weights = config.init_weights
+
+        if r <= 0:
+            raise ValueError(f"`r` should be a positive integer value but the value passed is {r}")
+        elif hybrid_r < 0:
+            raise ValueError(f"`hybrid_r` should be a non-negative integer value but the value passed is {hybrid_r}")
+
+        self.r[adapter_name] = r
+        self.alpha[adapter_name] = alpha
+        self.gralora_k[adapter_name] = gralora_k
+        self.hybrid_r[adapter_name] = hybrid_r
+
+        if gralora_dropout > 0.0:
+            gralora_dropout_layer = nn.Dropout(p=gralora_dropout)
+        else:
+            gralora_dropout_layer = nn.Identity()
+
+        self.gralora_dropout.update(nn.ModuleDict({adapter_name: gralora_dropout_layer}))
+
+        # Actual trainable parameters
+        if self.in_features % gralora_k != 0:
+            raise ValueError(
+                f"in_features should be divisible by gralora_k, but got {self.in_features} and {gralora_k}"
+            )
+        if self.out_features % gralora_k != 0:
+            raise ValueError(
+                f"out_features should be divisible by gralora_k, but got {self.out_features} and {gralora_k}"
+            )
+        subblock_in_features = self.in_features // gralora_k
+        subblock_out_features = self.out_features // gralora_k
+
+        # gralora_r is the rank allocated to GraLoRA method; hybrid_r is the rank allocated to vanilla LoRA
+        gralora_r = r
+
+        gralora_A = []
+        gralora_B = []
+        for _ in range(gralora_k):
+            new_A = nn.Parameter(torch.empty(gralora_r, subblock_in_features))
+            new_B = nn.Parameter(torch.empty(subblock_out_features, gralora_r))
+            if init_weights:
+                # Initialize to identity: A is random, B is zero
+                nn.init.kaiming_uniform_(new_A, a=math.sqrt(5))
+                nn.init.zeros_(new_B)
+            else:
+                # Initialize to random: both A and B are random (for testing)
+                nn.init.kaiming_uniform_(new_A, a=math.sqrt(5))
+                nn.init.kaiming_uniform_(new_B, a=math.sqrt(5))
+            gralora_A.append(new_A)
+            gralora_B.append(new_B)
+        # stack A and B and transpose to get the final shape
+        gralora_A = torch.stack(tuple(gralora_A), dim=0)  # [N, gralora_r, in_features//N]
+        gralora_A = gralora_A.transpose(1, 2).contiguous()  # [N, in_features//N, gralora_r]
+
+        gralora_B = torch.stack(tuple(gralora_B), dim=0)  # [N, out_features//N, gralora_r]
+        gralora_B = gralora_B.transpose(1, 2).contiguous()  # [N, gralora_r, out_features//N]
+
+        if hybrid_r > 0:
+            general_gralora_A = nn.Linear(self.in_features, hybrid_r, bias=False)
+            general_gralora_B = nn.Linear(hybrid_r, self.out_features, bias=False)
+            if init_weights:
+                # Initialize to identity: A is random, B is zero
+                nn.init.kaiming_uniform_(general_gralora_A.weight, a=math.sqrt(5))
+                nn.init.zeros_(general_gralora_B.weight)
+            else:
+                # Initialize to random: both A and B are random (for testing)
+                nn.init.kaiming_uniform_(general_gralora_A.weight, a=math.sqrt(5))
+                nn.init.kaiming_uniform_(general_gralora_B.weight, a=math.sqrt(5))
+        else:
+            general_gralora_A = nn.Identity()
+            general_gralora_B = nn.Identity()
+
+        self.gralora_A[adapter_name] = gralora_A
+        self.gralora_B[adapter_name] = gralora_B
+        self.gralora_A_general[adapter_name] = general_gralora_A
+        self.gralora_B_general[adapter_name] = general_gralora_B
+
+        self.module_name = module_name
+
+        self.scaling[adapter_name] = alpha / (gralora_r + hybrid_r)
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters)
+
+
+class Linear(nn.Linear, GraloraLayer):
+    # Gralora implemented in a dense layer
+    def __init__(
+        self,
+        base_layer,
+        adapter_name: str,
+        module_name,
+        config: GraloraConfig,
+        r: int = 0,
+        **kwargs,
+    ) -> None:
+        # this gets the init from nn.Linear's super perspective, i.e. nn.Module.__init__, which should always be called
+        super(nn.Linear, self).__init__()
+        GraloraLayer.__init__(self, base_layer, **kwargs)
+        self.fan_in_fan_out = config.fan_in_fan_out
+
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, module_name, r, config=config)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`list[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        from peft.tuners.tuners_utils import check_adapters_to_merge
+
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.gralora_A.keys():
+                base_layer = self.get_base_layer()
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    # because of the copy operation.
+                    orig_weights = base_layer.weight.data.clone()
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    orig_weights += delta_weight
+
+                    if not torch.isfinite(orig_weights).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = orig_weights
+                else:
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    base_layer.weight.data += delta_weight
+
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.gralora_A.keys():
+                delta_weight = self.get_delta_weight(active_adapter)
+                self.get_base_layer().weight.data -= delta_weight
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        """
+        Compute the delta weight for GraLoRA adapter.
+
+        GraLoRA applies block-wise low-rank adaptation with information exchange. This method computes the equivalent
+        weight matrix that would be added to the base weight during merge.
+
+        Args:
+            adapter (str): The name of the adapter
+
+        Returns:
+            torch.Tensor: The delta weight matrix with shape [out_features, in_features]
+        """
+        gralora_A = self.gralora_A[adapter]  # [N, in_features//N, rank]
+        gralora_B = self.gralora_B[adapter]  # [N, rank, out_features//N]
+        gralora_A_general = self.gralora_A_general[adapter]
+        gralora_B_general = self.gralora_B_general[adapter]
+
+        device = gralora_A.device
+        dtype = gralora_A.dtype
+
+        gralora_k = self.gralora_k[adapter]
+        hybrid_r = self.hybrid_r[adapter]
+        r = self.r[adapter]
+
+        # Handle CPU fp16/bf16 casting
+        cast_to_fp32 = device.type == "cpu" and (dtype == torch.float16 or dtype == torch.bfloat16)
+
+        if cast_to_fp32:
+            gralora_A = gralora_A.float()
+            gralora_B = gralora_B.float()
+
+        # Get dimensions
+        in_features = self.in_features
+        out_features = self.out_features
+        gralora_rank = r
+        subblock_gralora_rank = gralora_rank // gralora_k
+
+        # scatter gralora_A to get the scattered weight matrix
+        l_indices = torch.arange(in_features, device=device)
+        n_indices = l_indices // (in_features // gralora_k)
+        i_indices = l_indices % (in_features // gralora_k)
+        gralora_A_scattered = torch.zeros(
+            in_features, gralora_k, gralora_rank, device=device, dtype=torch.float32 if cast_to_fp32 else dtype
+        )
+        gralora_A_scattered.scatter_(
+            1,
+            n_indices.unsqueeze(1).unsqueeze(2).expand(-1, 1, gralora_rank),
+            gralora_A[n_indices, i_indices, :].unsqueeze(1),
+        )
+
+        # compute the delta weight
+        delta_weight = (
+            torch.einsum(
+                "ikr, kro -> iko",
+                gralora_A_scattered.view(in_features, gralora_k, gralora_k, subblock_gralora_rank)
+                .permute(0, 2, 1, 3)
+                .reshape(in_features, gralora_k, gralora_rank),
+                gralora_B,
+            )
+            .reshape(in_features, out_features)
+            .T
+        )
+
+        # Add hybrid LoRA component if present
+        if hybrid_r > 0:
+            weight_A_general = gralora_A_general.weight  # [hybrid_r, in_features]
+            weight_B_general = gralora_B_general.weight  # [out_features, hybrid_r]
+
+            if cast_to_fp32:
+                weight_A_general = weight_A_general.float()
+                weight_B_general = weight_B_general.float()
+
+            # Compute delta for hybrid part: [out_features, hybrid_r] @ [hybrid_r, in_features]
+            delta_weight += weight_B_general @ weight_A_general
+
+        # Apply scaling and transpose if needed
+        delta_weight = transpose(delta_weight, self.fan_in_fan_out) * self.scaling[adapter]
+
+        # Cast back if needed
+        if cast_to_fp32:
+            delta_weight = delta_weight.to(dtype=dtype)
+
+        return delta_weight
+
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        previous_dtype = x.dtype
+
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+            torch_result_dtype = result.dtype
+
+            # Handle 2D input: [batch, features] -> [batch, 1, features]
+            # This is common for MLPs and other non-sequence models
+            x_is_2d = x.ndim == 2
+            if x_is_2d:
+                x = x.unsqueeze(1)  # [B, F] -> [B, 1, F]
+
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.gralora_A.keys():
+                    continue
+                gralora_A = self.gralora_A[active_adapter]
+                gralora_B = self.gralora_B[active_adapter]
+
+                gralora_A_general = self.gralora_A_general[active_adapter]
+                gralora_B_general = self.gralora_B_general[active_adapter]
+
+                r = self.r[active_adapter]
+                gralora_rank = r
+                gralora_k = self.gralora_k[active_adapter]
+                hybrid_r = self.hybrid_r[active_adapter]
+
+                dropout = self.gralora_dropout[active_adapter]
+                scaling = self.scaling[active_adapter]
+
+                gralora_dtype = gralora_A.dtype
+
+                B, L, in_features = x.shape
+                N = gralora_k
+                subblock_gralora_rank = gralora_rank // N
+
+                output = torch.einsum(
+                    "bljr, jro -> bljo",
+                    torch.einsum(
+                        "blni, nir -> blnr",
+                        dropout(x.to(gralora_dtype)).view(B, L, N, in_features // N),
+                        gralora_A,
+                    )
+                    .view(B, L, N, N, subblock_gralora_rank)
+                    .permute(0, 1, 3, 2, 4)
+                    .reshape(B, L, N, N * subblock_gralora_rank),
+                    gralora_B,
+                ).reshape(B, L, -1)
+
+                # Squeeze back to 2D if input was 2D
+                if x_is_2d:
+                    output = output.squeeze(1)  # [B, 1, F] -> [B, F]
+
+                result += scaling * output.to(torch_result_dtype)
+                if hybrid_r > 0:
+                    hybrid_output = gralora_B_general(gralora_A_general(dropout(x.to(gralora_dtype))))
+                    if x_is_2d:
+                        hybrid_output = hybrid_output.squeeze(1)
+                    result += scaling * hybrid_output.to(torch_result_dtype)
+
+        result = result.to(previous_dtype)
+        return result
+
+    def supports_lora_conversion(self, adapter_name: str = "default") -> bool:
+        return True
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "gralora." + rep
diff --git a/src/peft/tuners/gralora/model.py b/src/peft/tuners/gralora/model.py
new file mode 100644
index 0000000..c371268
--- /dev/null
+++ b/src/peft/tuners/gralora/model.py
@@ -0,0 +1,125 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+import warnings
+
+import torch
+from transformers.pytorch_utils import Conv1D
+
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer
+from peft.utils import TRANSFORMERS_MODELS_TO_GRALORA_TARGET_MODULES_MAPPING
+
+from .layer import GraloraLayer, Linear
+
+
+class GraloraModel(BaseTuner):
+    """
+    Creates Vector-based Random Matrix Adaptation (Gralora) model from a pretrained transformers model.
+
+    Args:
+        model ([`~transformers.PreTrainedModel`]): The model to be adapted.
+        config ([`GraloraConfig`]): The configuration of the Gralora model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+
+    Returns:
+        `torch.nn.Module`: The Gralora model.
+
+    Example:
+
+        ```py
+        >>> from transformers import AutoModelForCausalLM
+        >>> from peft import GraloraConfig, get_peft_model
+
+        >>> base_model = AutoModelForCausalLM.from_pretrained("facebook/opt-125m")
+        >>> config = GraloraConfig(r=128)
+        >>> model = get_peft_model(base_model, config)
+        ```
+
+    **Attributes**:
+        - **model** ([`~transformers.PreTrainedModel`]) -- The model to be adapted.
+        - **peft_config** ([`GraloraConfig`]): The configuration of the Gralora model.
+    """
+
+    # The unique prefix for GraLoRA method
+    prefix: str = "gralora_"
+    # The class of tuner layer for GraLoRA method
+    tuner_layer_cls = GraloraLayer
+
+    target_module_mapping = TRANSFORMERS_MODELS_TO_GRALORA_TARGET_MODULES_MAPPING
+
+    def _create_and_replace(
+        self,
+        gralora_config,
+        adapter_name,
+        target,
+        target_name,
+        parent,
+        current_key,
+        **optional_kwargs,
+    ):
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+
+        r = gralora_config.r
+        if isinstance(target, Linear):
+            target.update_layer(
+                adapter_name,
+                current_key,
+                r=r,
+                config=gralora_config,
+            )
+        else:
+            new_module = self._create_new_module(gralora_config, adapter_name, target, current_key, r=r)
+            if adapter_name not in self.active_adapters:
+                # adding an additional adapter: it is not automatically trainable
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+    @staticmethod
+    def _create_new_module(gralora_config, adapter_name, target, module_name, **kwargs):
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        if isinstance(target_base_layer, torch.nn.Linear):
+            if gralora_config.fan_in_fan_out:
+                warnings.warn(
+                    "fan_in_fan_out is set to True but the target module is `torch.nn.Linear`. "
+                    "Setting fan_in_fan_out to False."
+                )
+                gralora_config.fan_in_fan_out = False
+        elif isinstance(target_base_layer, Conv1D):
+            kwargs["is_target_conv_1d_layer"] = True
+            if not gralora_config.fan_in_fan_out:
+                warnings.warn(
+                    "fan_in_fan_out is set to False but the target module is `Conv1D`. Setting fan_in_fan_out to True."
+                )
+                gralora_config.fan_in_fan_out = True
+        else:
+            raise TypeError(
+                f"Target module {target} is not supported. Currently, only the following modules are supported: "
+                "`torch.nn.Linear`, `transformers.pytorch_utils.Conv1D`."
+            )
+        new_module = Linear(
+            target,
+            adapter_name,
+            module_name,
+            config=gralora_config,
+            **kwargs,
+        )
+
+        return new_module
diff --git a/src/peft/tuners/hira/__init__.py b/src/peft/tuners/hira/__init__.py
new file mode 100644
index 0000000..5f2b5a6
--- /dev/null
+++ b/src/peft/tuners/hira/__init__.py
@@ -0,0 +1,45 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+from peft.utils import register_peft_method
+
+from .config import HiraConfig
+from .layer import Conv2d, Conv3d, Embedding, HiraLayer, Linear
+from .model import HiraModel
+
+
+__all__ = [
+    "Conv2d",
+    "Conv3d",
+    "Embedding",
+    "HiraConfig",
+    "HiraLayer",
+    "HiraModel",
+    "Linear",
+]
+
+register_peft_method(name="hira", config_cls=HiraConfig, model_cls=HiraModel, is_mixed_compatible=True)
+
+
+def __getattr__(name):
+    if (name == "Linear8bitLt") and is_bnb_available():
+        from .bnb import Linear8bitLt
+
+        return Linear8bitLt
+
+    if (name == "Linear4bit") and is_bnb_4bit_available():
+        from .bnb import Linear4bit
+
+        return Linear4bit
diff --git a/src/peft/tuners/hira/bnb.py b/src/peft/tuners/hira/bnb.py
new file mode 100644
index 0000000..51c1521
--- /dev/null
+++ b/src/peft/tuners/hira/bnb.py
@@ -0,0 +1,471 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import warnings
+from typing import Any, Optional
+
+import bitsandbytes as bnb
+import torch
+import torch.nn.functional as F
+
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+from peft.utils.integrations import dequantize_bnb_weight
+from peft.utils.other import transpose
+
+from .config import HiraConfig
+from .layer import HiraLayer
+
+
+if is_bnb_available():
+
+    class Linear8bitLt(torch.nn.Module, HiraLayer):
+        # HiRA implemented in a dense layer
+        def __init__(
+            self,
+            base_layer: torch.nn.Module,
+            adapter_name: str,
+            config: HiraConfig,
+            r: int = 0,
+            **kwargs,
+        ) -> None:
+            super().__init__()
+            HiraLayer.__init__(self, base_layer)
+            self.fan_in_fan_out = False
+
+            self._active_adapter = adapter_name
+            self.update_layer(adapter_name, r, config=config)
+
+        def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+            """
+            Merge the active adapter weights into the base weights
+
+            Args:
+                safe_merge (`bool`, *optional*):
+                    If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                    before merging the weights. This is useful if you want to check if the merge operation will produce
+                    NaNs. Defaults to `False`.
+                adapter_names (`list[str]`, *optional*):
+                    The list of adapter names that should be merged. If None, all active adapters will be merged.
+                    Defaults to `None`.
+            """
+            adapter_names = check_adapters_to_merge(self, adapter_names)
+            if not adapter_names:
+                # no adapter to merge
+                return
+
+            for active_adapter in adapter_names:
+                if active_adapter not in self.hira_A.keys():
+                    continue
+
+                warnings.warn(
+                    "Merge hira module to 8-bit linear may get different generations due to rounding errors."
+                )
+
+                weight = self.get_base_layer().weight
+                state = self.get_base_layer().state
+                if state.SCB is None:
+                    state.SCB = weight.SCB
+
+                # Dequantize the result of identity matrix and int8 weight because bitsandbytes does not support int8
+                # dequantization directly
+                output = dequantize_bnb_weight(weight, state=state)
+                hira_data = self.get_delta_weight(active_adapter)
+                hira_data = output.to(hira_data.dtype).to(hira_data.device) * hira_data
+                w_data = output.to(hira_data.dtype).to(hira_data.device) + hira_data
+
+                if safe_merge and not torch.isfinite(w_data).all():
+                    raise ValueError(
+                        f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                    )
+
+                self.get_base_layer().weight = bnb.nn.Int8Params(
+                    w_data.to("cpu"), requires_grad=False, has_fp16_weights=weight.has_fp16_weights
+                ).to(weight.device)
+
+                state.reset_grads()
+                self.merged_adapters.append(active_adapter)
+
+        def unmerge(self) -> None:
+            """
+            This method unmerges all merged adapter layers from the base weights.
+            """
+            if not self.merged:
+                warnings.warn("Already unmerged. Nothing to do.")
+                return
+
+            while len(self.merged_adapters) > 0:
+                active_adapter = self.merged_adapters.pop()
+                if active_adapter not in self.hira_A.keys():
+                    continue
+                warnings.warn(
+                    "Unmerge hira module to 8-bit linear may get different generations due to rounding errors."
+                )
+
+                weight = self.get_base_layer().weight
+                state = self.get_base_layer().state
+                if state.SCB is None:
+                    state.SCB = weight.SCB
+                output = dequantize_bnb_weight(weight, state=state)
+
+                hira_data = self.get_delta_weight(active_adapter)
+                w_data = output.to(hira_data.dtype).to(hira_data.device) / (1 + hira_data)
+                self.get_base_layer().weight = bnb.nn.Int8Params(
+                    w_data.to("cpu"), requires_grad=False, has_fp16_weights=weight.has_fp16_weights
+                ).to(weight.device)
+
+                state.reset_grads()
+
+        def get_delta_weight(self, adapter):
+            return transpose(
+                self.hira_B[adapter] @ self.hira_A[adapter],
+                False,
+            )
+
+        def _mixed_batch_forward(
+            self, x: torch.Tensor, *args: Any, adapter_names: list[str], **kwargs: Any
+        ) -> torch.Tensor:
+            # This is a special method that handles the case when users pass the argument `adapter_names`. This is an
+            # extra argument that allows mixing different adapters in the same batch at inference time.
+            result = self.base_layer(x, *args, **kwargs)
+
+            unique_adapters = set(adapter_names)
+            sub_batch_indices_list = []
+            for adapter in unique_adapters:
+                sub_batch_indices_list.append([index for index, item in enumerate(adapter_names) if item == adapter])
+
+            # dequantitize
+            weight = self.get_base_layer().weight
+            state = self.get_base_layer().state
+            if state.SCB is None:
+                state.SCB = weight.SCB
+            # Dequantize the result of identity matrix and int8 weight because bitsandbytes does not support int8
+            # dequantization directly
+            dequant_w = dequantize_bnb_weight(weight, state=state)
+            for i, active_adapter in enumerate(unique_adapters):
+                if active_adapter == "__base__":
+                    continue
+                if active_adapter not in self.hira_A.keys():
+                    continue
+
+                hira_A = self.hira_A[active_adapter]
+                hira_B = self.hira_B[active_adapter]
+                dropout = self.hira_dropout[active_adapter]
+
+                requires_conversion = not torch.is_autocast_enabled()
+                if requires_conversion:
+                    expected_dtype = result.dtype
+                    x = self._cast_input_dtype(x, hira_A.dtype)
+
+                # getting the sub-batch, passing it to HiRA layers and updating the corresponding indices of the linear
+                # layer output
+                sub_batch = x[sub_batch_indices_list[i]]
+                sub_batch = dropout(sub_batch)
+                prod_AB = torch.mm(hira_A.T, hira_B.T)
+
+                eff_weight = transpose(dequant_w.to(prod_AB.dtype).to(prod_AB.device), self.fan_in_fan_out) * prod_AB.T
+                hira_out = F.linear(sub_batch, eff_weight)
+                if requires_conversion:
+                    hira_out = hira_out.to(expected_dtype)
+                result[sub_batch_indices_list[i]] += hira_out
+
+            return result
+
+        def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+            adapter_names = kwargs.pop("adapter_names", None)
+
+            if self.disable_adapters:
+                if self.merged:
+                    self.unmerge()
+                result = self.base_layer(x, *args, **kwargs)
+            elif adapter_names is not None:
+                result = self._mixed_batch_forward(x, *args, adapter_names=adapter_names, **kwargs)
+            elif self.merged:
+                result = self.base_layer(x, *args, **kwargs)
+            else:
+                # 2) now compute the HiRA “delta” in float32 and add it:
+                # dequantize once per forward
+                raw_weight = self.get_base_layer().weight
+                state = self.get_base_layer().state
+                dequant_w = dequantize_bnb_weight(raw_weight, state=state)  # float32 tensor [out, in]
+                result = self.base_layer(x, *args, **kwargs)
+                for active_adapter in self.active_adapters:
+                    if active_adapter not in self.hira_A.keys():
+                        continue
+                    hira_A = self.hira_A[active_adapter]
+                    hira_B = self.hira_B[active_adapter]
+                    dropout = self.hira_dropout[active_adapter]
+
+                    requires_conversion = not torch.is_autocast_enabled()
+                    if requires_conversion:
+                        expected_dtype = result.dtype
+                        x = self._cast_input_dtype(x, hira_A.dtype)
+                    dropout_sub = dropout(x)
+                    # compute Δ = B @ A  → shape (out, in)
+                    prod_AB = hira_B @ hira_A
+                    # effective weight = W₀ ⊙ Δ
+                    eff_w = dequant_w * prod_AB
+                    hira_out = F.linear(dropout_sub, eff_w)
+                    if requires_conversion:
+                        hira_out = hira_out.to(expected_dtype)
+                    result = result + hira_out
+                    if requires_conversion:
+                        result = result.to(expected_dtype)
+
+            return result
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return "hira." + rep
+
+    def dispatch_bnb_8bit(target: torch.nn.Module, adapter_name: str, hira_config, **kwargs):
+        new_module = None
+
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        loaded_in_8bit = kwargs.get("loaded_in_8bit", False)
+        if loaded_in_8bit and isinstance(target_base_layer, bnb.nn.Linear8bitLt):
+            eightbit_kwargs = kwargs.copy()
+            eightbit_kwargs.update(
+                {
+                    "has_fp16_weights": target.state.has_fp16_weights,
+                    "threshold": target.state.threshold,
+                    "index": target.index,
+                }
+            )
+            new_module = Linear8bitLt(target, adapter_name, config=hira_config, **eightbit_kwargs)
+
+        return new_module
+
+
+if is_bnb_4bit_available():
+
+    class Linear4bit(torch.nn.Module, HiraLayer):
+        # HiRA implemented in a dense layer
+        def __init__(
+            self,
+            base_layer: torch.nn.Module,
+            adapter_name: str,
+            config: HiraConfig,
+            r: int = 0,
+            **kwargs,
+        ) -> None:
+            super().__init__()
+            HiraLayer.__init__(self, base_layer)
+            self.fan_in_fan_out = False
+
+            self._active_adapter = adapter_name
+            self.update_layer(adapter_name, r, config=config)
+
+        def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+            """
+            Merge the active adapter weights into the base weights
+
+            Args:
+                safe_merge (`bool`, *optional*):
+                    If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                    before merging the weights. This is useful if you want to check if the merge operation will produce
+                    NaNs. Defaults to `False`.
+                adapter_names (`list[str]`, *optional*):
+                    The list of adapter names that should be merged. If None, all active adapters will be merged.
+                    Defaults to `None`.
+            """
+            adapter_names = check_adapters_to_merge(self, adapter_names)
+            if not adapter_names:
+                # no adapter to merge
+                return
+
+            for active_adapter in adapter_names:
+                if active_adapter not in self.hira_A.keys():
+                    continue
+
+                warnings.warn(
+                    "Merge hira module to 4-bit linear may get different generations due to rounding errors."
+                )
+                # Refer to https://gist.github.com/ChrisHayduk/1a53463331f52dca205e55982baf9930
+                weight = self.get_base_layer().weight
+                kwargs = weight.__dict__
+
+                output = dequantize_bnb_weight(weight, state=weight.quant_state)
+                hira_data = self.get_delta_weight(active_adapter)
+                w_data = output * (1 + hira_data)
+
+                if safe_merge and not torch.isfinite(w_data).all():
+                    raise ValueError(
+                        f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                    )
+
+                if "bnb_quantized" in kwargs:
+                    kwargs["bnb_quantized"] = False
+                kwargs["requires_grad"] = False
+                kwargs.pop("data", None)
+                # torch.compile can introduce attributes preceded by '_', remove them
+                kwargs = {k: v for k, v in kwargs.items() if not k.startswith("_")}
+                self.get_base_layer().weight = bnb.nn.Params4bit(w_data.to("cpu"), **kwargs).to(weight.device)
+
+                self.merged_adapters.append(active_adapter)
+
+        def unmerge(self) -> None:
+            """
+            This method unmerges all merged adapter layers from the base weights.
+            """
+            if not self.merged:
+                warnings.warn("Already unmerged. Nothing to do.")
+                return
+
+            while len(self.merged_adapters) > 0:
+                active_adapter = self.merged_adapters.pop()
+                if active_adapter not in self.hira_A.keys():
+                    continue
+                warnings.warn(
+                    "Unmerge hira module to 4-bit linear may get different generations due to rounding errors."
+                )
+
+                weight = self.get_base_layer().weight
+                kwargs = weight.__dict__
+                output = dequantize_bnb_weight(weight, state=weight.quant_state)
+
+                hira_data = self.get_delta_weight(active_adapter)
+                w_data = output / (1 + hira_data)
+
+                if "bnb_quantized" in kwargs:
+                    kwargs["bnb_quantized"] = False
+                kwargs["requires_grad"] = False
+                kwargs.pop("data", None)
+                self.get_base_layer().weight = bnb.nn.Params4bit(w_data.to("cpu"), **kwargs).to(weight.device)
+
+        def get_delta_weight(self, adapter):
+            return transpose(
+                self.hira_B[adapter] @ self.hira_A[adapter],
+                False,
+            )
+
+        def _mixed_batch_forward(
+            self, x: torch.Tensor, *args: Any, adapter_names: list[str], **kwargs: Any
+        ) -> torch.Tensor:
+            # This is a special method that handles the case when users pass the argument `adapter_names`. This is an
+            # extra argument that allows mixing different adapters in the same batch at inference time.
+            result = self.base_layer(x, *args, **kwargs)
+
+            unique_adapters = set(adapter_names)
+            sub_batch_indices_list = []
+            for adapter in unique_adapters:
+                sub_batch_indices_list.append([index for index, item in enumerate(adapter_names) if item == adapter])
+            weight = self.get_base_layer().weight
+            dequant_w = dequantize_bnb_weight(weight, state=weight.quant_state)
+            for i, active_adapter in enumerate(unique_adapters):
+                if active_adapter == "__base__":
+                    continue
+                if active_adapter not in self.hira_A.keys():
+                    continue
+
+                hira_A = self.hira_A[active_adapter]
+                hira_B = self.hira_B[active_adapter]
+                dropout = self.hira_dropout[active_adapter]
+
+                requires_conversion = not torch.is_autocast_enabled()
+                if requires_conversion:
+                    expected_dtype = result.dtype
+                    x = self._cast_input_dtype(x, hira_A.dtype)
+
+                # getting the sub-batch, passing it to HiRA layers and updating the corresponding indices of the linear
+                # layer output
+                sub_batch = x[sub_batch_indices_list[i]]
+                prod_AB = torch.mm(hira_A.T, hira_B.T)
+                sub_batch = dropout(sub_batch)
+                eff_weight = transpose(dequant_w.to(prod_AB.dtype).to(prod_AB.device), self.fan_in_fan_out) * prod_AB.T
+                hira_out = F.linear(sub_batch, eff_weight)
+                if requires_conversion:
+                    hira_out = hira_out.to(expected_dtype)
+                result[sub_batch_indices_list[i]] += hira_out
+
+            return result
+
+        def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+            adapter_names = kwargs.pop("adapter_names", None)
+
+            if self.disable_adapters:
+                if self.merged:
+                    self.unmerge()
+                result = self.base_layer(x, *args, **kwargs)
+            elif adapter_names is not None:
+                result = self._mixed_batch_forward(x, *args, adapter_names=adapter_names, **kwargs)
+            elif self.merged:
+                result = self.base_layer(x, *args, **kwargs)
+            else:
+                result = self.base_layer(x, *args, **kwargs)
+                # As per Tim Dettmers, for 4bit, we need to defensively clone here.
+                # The reason is that in some cases, an error can occur that backprop
+                # does not work on a manipulated view. This issue may be solved with
+                # newer PyTorch versions but this would need extensive testing to be
+                # sure.
+                result = result.clone()
+                # dequanted w
+                weight = self.get_base_layer().weight
+                dequant_w = dequantize_bnb_weight(weight, state=weight.quant_state)
+                for active_adapter in self.active_adapters:
+                    if active_adapter not in self.hira_A.keys():
+                        continue
+                    hira_A = self.hira_A[active_adapter]
+                    hira_B = self.hira_B[active_adapter]
+                    dropout = self.hira_dropout[active_adapter]
+
+                    requires_conversion = not torch.is_autocast_enabled()
+                    if requires_conversion:
+                        expected_dtype = result.dtype
+                        x = self._cast_input_dtype(x, hira_A.dtype)
+
+                    dropout_sub = dropout(x)
+                    # compute Δ = B @ A  → shape (out, in)
+                    prod_AB = hira_B @ hira_A
+                    # effective weight = W₀ ⊙ Δ
+                    eff_w = dequant_w * prod_AB
+                    hira_out = F.linear(dropout_sub, eff_w)
+                    if requires_conversion:
+                        hira_out = hira_out.to(expected_dtype)
+                    result = result + hira_out
+                    if requires_conversion:
+                        result = result.to(expected_dtype)
+
+            return result
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return "hira." + rep
+
+    def dispatch_bnb_4bit(target: torch.nn.Module, adapter_name: str, hira_config, **kwargs):
+        new_module = None
+
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        loaded_in_4bit = kwargs.get("loaded_in_4bit", False)
+        if loaded_in_4bit and is_bnb_4bit_available() and isinstance(target_base_layer, bnb.nn.Linear4bit):
+            fourbit_kwargs = kwargs.copy()
+            fourbit_kwargs.update(
+                {
+                    "compute_dtype": target_base_layer.compute_dtype,
+                    "compress_statistics": target_base_layer.weight.compress_statistics,
+                    "quant_type": target_base_layer.weight.quant_type,
+                }
+            )
+            new_module = Linear4bit(target, adapter_name, config=hira_config, **fourbit_kwargs)
+
+        return new_module
diff --git a/src/peft/tuners/hira/config.py b/src/peft/tuners/hira/config.py
new file mode 100644
index 0000000..651d39b
--- /dev/null
+++ b/src/peft/tuners/hira/config.py
@@ -0,0 +1,157 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal, Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class HiraConfig(PeftConfig):
+    """
+    This is the configuration class to store the configuration of a [`HiraModel`].
+
+    Args:
+        r (`int`):
+            Rank of the low-rank component in HiRA. Although HiRA achieves a high-rank adaptation through Hadamard
+            fusion, this value defines the dimension of the underlying low-rank factorization (matrices A and B).
+        target_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to apply the adapter to. If this is specified, only the modules with the specified
+            names will be replaced. When passing a string, a regex match will be performed. When passing a list of
+            strings, either an exact match will be performed or it is checked if the name of the module ends with any
+            of the passed strings. If this is specified as 'all-linear', then all linear/Conv1D modules are chosen (if
+            the model is a PreTrainedModel, the output layer excluded). If this is not specified, modules will be
+            chosen according to the model architecture. If the architecture is not known, an error will be raised -- in
+            this case, you should specify the target modules manually.
+        exclude_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to not apply the adapter. When passing a string, a regex match will be performed.
+            When passing a list of strings, either an exact match will be performed or it is checked if the name of the
+            module ends with any of the passed strings.
+        hira_dropout (`float`):
+            The dropout probability for HiRA layers.
+        fan_in_fan_out (`bool`):
+            Set this to True if the layer to replace stores weight like (fan_in, fan_out). For example, gpt-2 uses
+            `Conv1D` which stores weights like (fan_in, fan_out) and hence this should be set to `True`.
+        modules_to_save (`List[str]`):
+            List of modules apart from adapter layers to be set as trainable and saved in the final checkpoint.
+        init_weights (`bool` | `Literal["gaussian"]`):
+            How to initialize the weights of the HiRA layers. Passing True (default) results in the default
+            initialization, with the HiRA B weight being set to 0. This means that without further training, the HiRA
+            adapter will be a no-op. Setting the initialization to False leads to random initialization of HiRA A and
+            B, meaning that HiRA is not a no-op before training; this setting is intended for debugging purposes.
+            Passing `'gaussian'` results in Gaussian initialization scaled by the HiRA rank for linear and layers.
+        layers_to_transform (`Union[List[int], int]`):
+            The layer indices to transform. If a list of ints is passed, it will apply the adapter to the layer indices
+            that are specified in this list. If a single integer is passed, it will apply the transformations on the
+            layer at this index.
+        layers_pattern (`Optional[Union[List[str], str]]`):
+            The layer pattern name, used only if `layers_to_transform` is different from `None`. This should target the
+            `nn.ModuleList` of the model, which is often called `'layers'` or `'h'`.
+        rank_pattern (`dict`):
+            The mapping from layer names or regexp expression to ranks which are different from the default r specified
+            by `r`. For example, `{'^model.decoder.layers.0.encoder_attn.k_proj': 16}`.
+    """
+
+    r: int = field(default=32, metadata={"help": "HiRA intermediate r configuration"})
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of module names or regex expression of the module names to replace with HiRA."
+                "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'."
+                "This can also be a wildcard 'all-linear' which matches all linear/Conv1D "
+                "(if the model is a PreTrainedModel, the output layer excluded)."
+                "If not specified, modules will be chosen according to the model architecture, If the architecture is "
+                "not known, an error will be raised -- in this case, you should specify the target modules manually."
+            ),
+        },
+    )
+    exclude_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={"help": "List of module names or regex expression of the module names to exclude from HiRA."},
+    )
+    hira_dropout: float = field(default=0.0, metadata={"help": "HiRA dropout"})
+    fan_in_fan_out: bool = field(
+        default=False,
+        metadata={"help": "Set this to True if the layer to replace stores weight like (fan_in, fan_out)"},
+    )
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": "List of modules apart from HiRA layers to be set as trainable and saved in the final checkpoint. "
+            "For example, in Sequence Classification or Token Classification tasks, "
+            "the final layer `classifier/score` are randomly initialized and as such need to be trainable and saved."
+        },
+    )
+    init_weights: bool | Literal["gaussian"] | None = field(
+        default=True,
+        metadata={
+            "help": (
+                "How to initialize the weights of the HiRA layers. "
+                "Passing True (default) results in the default initialization"
+                ", with the HiRA B weight being set to 0. This means that without further training, the HiRA "
+                "adapter will be a no-op. "
+                "Setting the initialization to False leads to random initialization of HiRA A and B, meaning that HiRA "
+                "is not a no-op before training; this setting is intended for debugging purposes. "
+                "Passing `'gaussian'` results in Gaussian initialization scaled by the HiRA rank for linear and layers. "
+            ),
+        },
+        repr=False,
+    )
+    layers_to_transform: Optional[Union[list[int], int]] = field(
+        default=None,
+        metadata={
+            "help": "The layer indexes to transform, is this argument is specified, PEFT will transform only the layers indexes that are specified inside this list. If a single integer is passed, PEFT will transform only the layer at this index. "
+            "This only works when target_modules is a list of str."
+        },
+    )
+    layers_pattern: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": "The layer pattern name, used only if `layers_to_transform` is different to None and if the layer pattern is not in the common layers pattern."
+            "This only works when target_modules is a list of str. This should target the `nn.ModuleList` of the "
+            "model, which is often called `'layers'` or `'h'`."
+        },
+    )
+    rank_pattern: Optional[dict] = field(
+        default_factory=dict,
+        metadata={
+            "help": (
+                "The mapping from layer names or regexp expression to rank of AB which are different from the default rank specified by `rank` of AB. "
+                "For example, `{'^model.decoder.layers.0.encoder_attn.k_proj': 16}`."
+            )
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.HIRA
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        self.exclude_modules = (
+            set(self.exclude_modules) if isinstance(self.exclude_modules, list) else self.exclude_modules
+        )
+
+        # if target_modules is a regex expression, then layers_to_transform should be None
+        if isinstance(self.target_modules, str) and self.layers_to_transform is not None:
+            raise ValueError("`layers_to_transform` cannot be used when `target_modules` is a str.")
+
+        # if target_modules is a regex expression, then layers_pattern should be None
+        if isinstance(self.target_modules, str) and self.layers_pattern is not None:
+            raise ValueError("`layers_pattern` cannot be used when `target_modules` is a str.")
diff --git a/src/peft/tuners/hira/layer.py b/src/peft/tuners/hira/layer.py
new file mode 100644
index 0000000..34efe03
--- /dev/null
+++ b/src/peft/tuners/hira/layer.py
@@ -0,0 +1,789 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import math
+import warnings
+from typing import Any, Optional
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+from transformers.pytorch_utils import Conv1D
+
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+from peft.utils.other import transpose
+
+from .config import HiraConfig
+
+
+class HiraLayer(BaseTunerLayer):
+    # All names of layers that may contain (trainable) adapter weights
+    adapter_layer_names: tuple[str, ...] = ("hira_A", "hira_B", "hira_embedding_A", "hira_embedding_B")
+    # All names of other parameters that may contain adapter-related parameters
+    other_param_names: tuple[str, ...] = ("r", "hira_dropout")
+
+    def __init__(self, base_layer: nn.Module, ephemeral_gpu_offload: bool = False, **kwargs) -> None:
+        self.base_layer = base_layer
+        self.r = {}
+        self.hira_dropout = nn.ModuleDict({})
+        self.hira_A = nn.ParameterDict({})
+        self.hira_B = nn.ParameterDict({})
+        # For Embedding layer
+        self.hira_embedding_A = nn.ParameterDict({})
+        self.hira_embedding_B = nn.ParameterDict({})
+        # Mark the weight as unmerged
+        self._disable_adapters = False
+        self.merged_adapters = []
+        self._caches: dict[str, Any] = {}
+        self.ephemeral_gpu_offload: bool = ephemeral_gpu_offload
+        # flag to enable/disable casting of input to weight dtype during forward call
+        self.cast_input_dtype_enabled: bool = True
+        self.kwargs = kwargs
+
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            in_features, out_features = base_layer.in_features, base_layer.out_features
+        elif isinstance(base_layer, (nn.Conv1d, nn.Conv2d, nn.Conv3d)):
+            in_features, out_features = base_layer.in_channels, base_layer.out_channels
+        elif isinstance(base_layer, nn.Embedding):
+            in_features, out_features = base_layer.num_embeddings, base_layer.embedding_dim
+        elif isinstance(base_layer, Conv1D):
+            in_features, out_features = (
+                base_layer.weight.ds_shape if hasattr(base_layer.weight, "ds_shape") else base_layer.weight.shape
+            )
+        else:
+            # possibly support user provided custom layer types using dynamic dispatch
+            if hasattr(base_layer, "in_features") and hasattr(base_layer, "out_features"):
+                in_features, out_features = base_layer.in_features, base_layer.out_features
+            else:
+                in_features, out_features = None, None
+            warnings.warn(
+                f"Unsupported layer type '{type(base_layer)}' encountered, proceed at your own risk.", UserWarning
+            )
+
+        self.in_features = in_features
+        self.out_features = out_features
+
+    def update_layer(
+        self,
+        adapter_name,
+        r,
+        config: HiraConfig,
+        **kwargs,
+    ):
+        # This code works for linear layers, override for other layer types
+        if r <= 0:
+            raise ValueError(f"`r` should be a positive integer value but the value passed is {r}")
+
+        hira_dropout = config.hira_dropout
+        init_weights = config.init_weights
+
+        self.r[adapter_name] = r
+        if hira_dropout > 0.0:
+            hira_dropout_layer = nn.Dropout(p=hira_dropout)
+        else:
+            hira_dropout_layer = nn.Identity()
+
+        self.hira_dropout.update(nn.ModuleDict({adapter_name: hira_dropout_layer}))
+        # Actual trainable parameters
+        self.hira_A.update(nn.ParameterDict({adapter_name: nn.Parameter(torch.randn(r, self.in_features))}))
+        self.hira_B.update(nn.ParameterDict({adapter_name: nn.Parameter(torch.randn(self.out_features, r))}))
+
+        # for inits that require access to the base weight, use gather_param_ctx so that the weight is gathered when using DeepSpeed
+        if init_weights:
+            self.reset_hira_parameters(adapter_name, init_weights)
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+
+        self.set_adapter(self.active_adapters)
+
+    def reset_hira_parameters(self, adapter_name, init_weights):
+        if init_weights is False:
+            return
+
+        if adapter_name in self.hira_A.keys():
+            if init_weights is True:
+                # initialize A the same way as the default for nn.Linear and B to zero
+                nn.init.kaiming_uniform_(self.hira_A[adapter_name], a=math.sqrt(5))
+            elif init_weights.lower() == "gaussian":
+                nn.init.normal_(self.hira_A[adapter_name], std=1 / self.r[adapter_name])
+            else:
+                raise ValueError(f"Unknown initialization {init_weights=}")
+            nn.init.zeros_(self.hira_B[adapter_name])
+        if adapter_name in self.hira_embedding_A.keys():
+            # Initialize A to zeros and B the same way as the default for nn.Embedding, see:
+            nn.init.zeros_(self.hira_embedding_A[adapter_name])
+            nn.init.normal_(self.hira_embedding_B[adapter_name])
+
+
+class Linear(nn.Module, HiraLayer):
+    # HiRA implemented in a dense layer
+    def __init__(
+        self,
+        base_layer,
+        adapter_name: str,
+        config: HiraConfig,
+        r: int = 0,
+        fan_in_fan_out: bool = False,  # Set this to True if the layer to replace stores weight like (fan_in, fan_out)
+        is_target_conv_1d_layer: bool = False,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        HiraLayer.__init__(self, base_layer, **kwargs)
+        self.fan_in_fan_out = fan_in_fan_out
+
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, config=config)
+        self.is_target_conv_1d_layer = is_target_conv_1d_layer
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`list[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        base_layer = self.get_base_layer()
+        orig_dtype = base_layer.weight.data.dtype
+
+        merged_delta = torch.zeros_like(base_layer.weight.data, dtype=orig_dtype)
+        for active_adapter in adapter_names:
+            if active_adapter in self.hira_A.keys():
+                merged_delta = merged_delta + self.get_delta_weight(active_adapter).to(orig_dtype)
+                self.merged_adapters.append(active_adapter)
+
+        if safe_merge:
+            orig_weight = base_layer.weight.data.clone()
+            merged_weight = orig_weight * (1 + merged_delta)
+
+            if not torch.isfinite(merged_weight).all():
+                raise ValueError(
+                    f"NaNs detected in the merged weights. The adapter {','.join(adapter_names)} seems to be broken"
+                )
+
+            base_layer.weight.data = merged_weight
+        else:
+            base_layer.weight.data *= 1 + merged_delta
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+        weight = self.get_base_layer().weight
+        orig_dtype = weight.dtype
+        merged_delta = torch.zeros_like(weight.data, dtype=torch.float32)
+
+        for active_adapter in self.merged_adapters:
+            if active_adapter in self.hira_A.keys():
+                merged_delta = merged_delta + self.get_delta_weight(active_adapter).to(torch.float32)
+
+        # avoid NaN error, cast to fp32
+        w32 = weight.data.to(torch.float32)
+        den32 = 1 + merged_delta
+        tiny = torch.finfo(den32.dtype).tiny  # ~1e-45 for float32
+        den32 = torch.where(den32 == 0, tiny, den32)
+        w32 = w32 / den32
+        weight.data.copy_(w32.to(orig_dtype))
+
+        self.merged_adapters.clear()
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        """
+        Compute the delta weight for the given adapter.
+
+        Args:
+            adapter (str):
+                The name of the adapter for which the delta weight should be computed.
+        """
+        device = self.hira_B[adapter].device
+        dtype = self.hira_B[adapter].dtype
+
+        # In case users wants to merge the adapter weights that are in
+        # (b)float16 while being on CPU, we need to cast the weights to float32, perform the merge and then cast back to
+        # (b)float16 because some CPUs have slow bf16/fp16 matmuls.
+        cast_to_fp32 = device.type == "cpu" and (dtype == torch.float16 or dtype == torch.bfloat16)
+
+        weight_A = self.hira_A[adapter]
+        weight_B = self.hira_B[adapter]
+
+        if cast_to_fp32:
+            weight_A = weight_A.float()
+            weight_B = weight_B.float()
+        output_tensor = transpose((weight_B @ weight_A), self.fan_in_fan_out)
+        if cast_to_fp32:
+            output_tensor = output_tensor.to(dtype=dtype)
+
+            # cast back the weights
+            self.hira_A[adapter].data = weight_A.to(dtype)
+            self.hira_B[adapter].data = weight_B.to(dtype)
+
+        return output_tensor
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+            torch_result_dtype = result.dtype
+
+            hira_A_keys = self.hira_A.keys()
+            for active_adapter in self.active_adapters:
+                if active_adapter not in hira_A_keys:
+                    continue
+                hira_A = self.hira_A[active_adapter]
+                hira_B = self.hira_B[active_adapter]
+                _prod_AB = torch.mm(hira_A.T, hira_B.T)
+                x = self._cast_input_dtype(x, hira_A.dtype)
+                dropout = self.hira_dropout[active_adapter]
+                dropout_sub = dropout(x)
+                hira_result = F.linear(
+                    dropout_sub, transpose(self.get_base_layer().weight, self.fan_in_fan_out) * _prod_AB.T
+                )
+                result = result + hira_result
+
+            result = result.to(torch_result_dtype)
+
+        return result
+
+    def supports_lora_conversion(self, adapter_name: str = "default") -> bool:
+        # The generic LoRA conversion path only works for additive adapters, i.e. adapters that can be written as
+        # W' = W + Delta and expose that additive residual via get_delta_weight(). HiRA is different: its effective
+        # update is multiplicative, W' = W * (1 + Delta_hira), so the actual additive residual would be
+        # W * Delta_hira and depends on the current base weight. Returning Delta_hira from get_delta_weight() is
+        # sufficient for HiRA merge/unmerge, but it is not the quantity that the generic LoRA converter factorizes.
+        # Mark conversion as unsupported to avoid producing a LoRA adapter that does not preserve HiRA behavior.
+        return False
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "hira." + rep
+
+
+class Embedding(nn.Module, HiraLayer):
+    # HiRA implemented in a Embedding layer
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        adapter_name: str,
+        config: HiraConfig,
+        r: int = 0,
+        fan_in_fan_out: bool = False,  # Set this to True if the layer to replace stores weight like (fan_in, fan_out)
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        HiraLayer.__init__(self, base_layer)
+        self.fan_in_fan_out = fan_in_fan_out
+
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, config=config)
+
+    def update_layer(self, adapter_name, r, config: HiraConfig, **kwargs) -> None:
+        if r <= 0:
+            raise ValueError(f"`r` should be a positive integer value but the value passed is {r}")
+
+        hira_dropout = config.hira_dropout
+        init_weights = config.init_weights
+
+        self.r[adapter_name] = r
+        if hira_dropout > 0.0:
+            hira_dropout_layer = nn.Dropout(p=hira_dropout)
+        else:
+            hira_dropout_layer = nn.Identity()
+
+        self.hira_dropout[adapter_name] = hira_dropout_layer
+        # Actual trainable parameters
+        weight_A = torch.randn((r, self.in_features))
+        weight_B = torch.randn((self.out_features, r))
+        self.hira_embedding_A[adapter_name] = nn.Parameter(weight_A)
+        self.hira_embedding_B[adapter_name] = nn.Parameter(weight_B)
+        self.reset_hira_parameters(adapter_name, init_weights)
+
+        # call this before init of the hira variants
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+
+        self.set_adapter(self.active_adapters)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`list[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        base_layer = self.get_base_layer()
+        orig_dtype = base_layer.weight.dtype
+        merged_delta = torch.zeros_like(base_layer.weight.data, dtype=orig_dtype)
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.hira_embedding_A.keys():
+                merged_delta = merged_delta + self.get_delta_weight(active_adapter).to(orig_dtype)
+                self.merged_adapters.append(active_adapter)
+
+        if safe_merge:
+            orig_weight = base_layer.weight.data.clone()
+            merged_weight = orig_weight * (1 + merged_delta)
+            if not torch.isfinite(merged_weight).all():
+                raise ValueError(
+                    f"NaNs detected in the merged weights. The adapter {','.join(adapter_names)} seems to be broken"
+                )
+            base_layer.weight.data = merged_weight
+        else:
+            base_layer.weight.data *= 1 + merged_delta
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+        weight = self.get_base_layer().weight
+        orig_dtype = weight.dtype
+        merged_delta = torch.zeros_like(weight.data, dtype=torch.float32)
+
+        for active_adapter in self.merged_adapters:
+            if active_adapter in self.hira_embedding_A.keys():
+                merged_delta = merged_delta + self.get_delta_weight(active_adapter).to(torch.float32)
+
+        w32 = weight.data.to(torch.float32)
+        den32 = 1 + merged_delta
+        tiny = torch.finfo(den32.dtype).tiny  # ~1e-45 for float32
+        den32 = torch.where(den32 == 0, tiny, den32)
+        w32 = w32 / den32
+        weight.data.copy_(w32.to(orig_dtype))
+
+        self.merged_adapters.clear()
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        """
+        Compute the delta weight for the given adapter.
+
+        Args:
+            adapter (str):
+                The name of the adapter for which the delta weight should be computed.
+        """
+        device = self.hira_embedding_B[adapter].device
+        dtype = self.hira_embedding_A[adapter].dtype
+
+        # In case users wants to merge the adapter weights that are in
+        # (b)float16 while being on CPU, we need to cast the weights to float32, perform the merge and then cast back to
+        # (b)float16 because some CPUs have slow bf16/fp16 matmuls.
+        cast_to_fp32 = device.type == "cpu" and (dtype == torch.float16 or dtype == torch.bfloat16)
+
+        weight_A = self.hira_embedding_A[adapter]
+        weight_B = self.hira_embedding_B[adapter]
+
+        if cast_to_fp32:
+            weight_A = weight_A.float()
+            weight_B = weight_B.float()
+        output_tensor = transpose(weight_B @ weight_A, True)
+
+        if cast_to_fp32:
+            output_tensor = output_tensor.to(dtype=dtype)
+
+            # cast back the weights
+            self.hira_embedding_A[adapter].data = weight_A.to(dtype)
+            self.hira_embedding_B[adapter].data = weight_B.to(dtype)
+
+        return output_tensor
+
+    def _embed(self, input: torch.Tensor, weight: torch.Tensor) -> torch.Tensor:
+        base_layer = self.get_base_layer()
+        return F.embedding(
+            input,
+            weight,
+            padding_idx=base_layer.padding_idx,
+            max_norm=base_layer.max_norm,
+            norm_type=base_layer.norm_type,
+            scale_grad_by_freq=base_layer.scale_grad_by_freq,
+            sparse=base_layer.sparse,
+        )
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        """
+        HiRA forward for Embedding layer. Supports mixed adapters per batch or single adapter.
+        """
+
+        # Adapter disabled or after merge: use base embedding
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            return self.base_layer(x, *args, **kwargs)
+        if self.merged:
+            return self.base_layer(x, *args, **kwargs)
+
+        # Single adapter active: compute base embedding + HiRA residual
+        result = self.base_layer(x, *args, **kwargs)
+        torch_result_dtype = result.dtype
+        base_weight = self.get_base_layer().weight  # (num_embeddings, embedding_dim)
+
+        for adapter in self.active_adapters:
+            if adapter not in self.hira_embedding_A:
+                continue
+            # HiRA factors
+            hira_A = self.hira_embedding_A[adapter]  # (r, num_embeddings)
+            hira_B = self.hira_embedding_B[adapter]  # (embedding_dim, r)
+
+            # Compute modulation matrix: B @ A -> (embedding_dim, num_embeddings)
+            mod_matrix = torch.mm(hira_B, hira_A)
+            # Element-wise modulated embedding weight
+            eff_weight = base_weight * mod_matrix.T  # (num_embeddings, embedding_dim)
+
+            # Compute HiRA residual via embedding lookup
+            hira_out = F.embedding(x, eff_weight)
+            result = result + hira_out
+
+        return result.to(torch_result_dtype)
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "hira." + rep
+
+
+class _ConvNd(nn.Module, HiraLayer):
+    # HiRA implemented in a conv(2,3)d layer
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        adapter_name: str,
+        config: HiraConfig,
+        r: int = 0,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        HiraLayer.__init__(self, base_layer)
+
+        if base_layer.groups > 1:
+            warnings.warn("HiRA adapter added to ConvNd layer with groups > 1. Merging is not supported.")
+
+        self._active_adapter = adapter_name
+        self._kernel_dim = base_layer.weight.dim()
+
+        self.update_layer(adapter_name, r, config=config)
+
+    def update_layer(self, adapter_name, r, config: HiraConfig, **kwargs):
+        if r <= 0:
+            raise ValueError(f"`r` should be a positive integer value but the value passed is {r}")
+
+        hira_dropout = config.hira_dropout
+        init_weights = config.init_weights
+
+        self.r[adapter_name] = r
+        if hira_dropout > 0.0:
+            hira_dropout_layer = nn.Dropout(p=hira_dropout)
+        else:
+            hira_dropout_layer = nn.Identity()
+
+        self.hira_dropout[adapter_name] = hira_dropout_layer
+        # Determine base conv parameters
+        base = self.get_base_layer()
+        conv_cls = type(base)
+        in_channels = base.in_channels
+        out_channels = base.out_channels
+        kernel_size = base.kernel_size
+        stride = base.stride
+        padding = base.padding
+        dilation = getattr(base, "dilation", (1,) * (base.weight.dim() - 2))
+        groups = getattr(base, "groups", 1)
+        # Spatial dims for B: 1 in each spatial dimension
+        spatial_ones = (1,) * (base.weight.dim() - 2)
+
+        # HiRA factor A: conv from in_channels to r
+        weight_shape_A = (r, in_channels, *kernel_size)
+        weight_shape_B = (out_channels, r, *spatial_ones)
+
+        self.hira_A[adapter_name] = nn.Parameter(torch.randn(weight_shape_A))
+        self.hira_B[adapter_name] = nn.Parameter(torch.randn(weight_shape_B))
+
+        # Initialize HiRA parameters (A with Kaiming, B zeros)
+        if init_weights:
+            # A: same init as base conv weight
+            nn.init.kaiming_uniform_(self.hira_A[adapter_name], a=math.sqrt(5))
+            # B: initialize to zero
+            nn.init.zeros_(self.hira_B[adapter_name])
+
+        # Place adapters on correct device and register
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights inside the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`list[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        base_layer = self.get_base_layer()
+        orig_dtype = base_layer.weight.dtype
+
+        if base_layer.groups > 1:
+            # https://github.com/huggingface/peft/pull/2403
+            raise NotImplementedError("Merging is not supported for _ConvNd layers with groups > 1!")
+
+        merged_delta = torch.zeros_like(base_layer.weight.data, dtype=orig_dtype)
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.hira_A.keys():
+                merged_delta = merged_delta + self.get_delta_weight(active_adapter).to(orig_dtype)
+                self.merged_adapters.append(active_adapter)
+
+        if safe_merge:
+            orig_weight = base_layer.weight.data.clone()
+            merged_weight = orig_weight * (1 + merged_delta)
+
+            if not torch.isfinite(merged_weight).all():
+                raise ValueError(
+                    f"NaNs detected in the merged weights. The adapter {','.join(adapter_names)} seems to be broken"
+                )
+
+            base_layer.weight.data = merged_weight
+
+        else:
+            base_layer.weight.data *= 1 + merged_delta.to(orig_dtype)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+        weight = self.get_base_layer().weight
+        orig_dtype = weight.dtype
+        merged_delta = torch.zeros_like(weight.data, dtype=torch.float32)
+
+        for active_adapter in self.merged_adapters:
+            if active_adapter in self.hira_A.keys():
+                merged_delta = merged_delta + self.get_delta_weight(active_adapter).to(torch.float32)
+
+        w32 = weight.data.to(torch.float32)
+        den32 = 1 + merged_delta
+        tiny = torch.finfo(den32.dtype).tiny  # ~1e-45 for float32
+        den32 = torch.where(den32 == 0, tiny, den32)
+        w32 = w32 / den32
+        weight.data.copy_(w32.to(orig_dtype))
+
+        self.merged_adapters.clear()
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        """
+        Compute the delta weight for the given adapter.
+
+        Args:
+            adapter (str):
+                The name of the adapter for which the delta weight should be computed.
+        """
+        device = self.hira_B[adapter].device
+        dtype = self.hira_A[adapter].dtype
+
+        # In case users wants to merge the adapter weights that are in
+        # (b)float16 while being on CPU, we need to cast the weights to float32, perform the merge and then cast back to
+        # (b)float16 because some CPUs have slow bf16/fp16 matmuls.
+        cast_to_fp32 = device.type == "cpu" and (dtype == torch.float16 or dtype == torch.bfloat16)
+
+        weight_A = self.hira_A[adapter]
+        weight_B = self.hira_B[adapter]
+
+        if cast_to_fp32:
+            weight_A = weight_A.float()
+            weight_B = weight_B.float()
+
+        if self.get_base_layer().weight.size()[2:4] == (1, 1):
+            # conv2d 1x1
+            output_tensor = (weight_B.squeeze(3).squeeze(2) @ weight_A.squeeze(3).squeeze(2)).unsqueeze(2).unsqueeze(3)
+        else:
+            output_tensor = self.conv_fn(weight_A.transpose(0, 1), weight_B)
+
+            if self.get_base_layer().groups <= 1:
+                output_tensor = output_tensor.transpose(0, 1)
+
+        if cast_to_fp32:
+            output_tensor = output_tensor.to(dtype=dtype)
+
+            # cast back the weights
+            self.hira_A[adapter].data = weight_A.to(dtype)
+            self.hira_B[adapter].data = weight_B.to(dtype)
+
+        return output_tensor
+
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+            torch_result_dtype = result.dtype
+            base = self.get_base_layer()
+            # Determine which convolution function to use
+            if isinstance(base, nn.Conv1d):
+                conv_fn = F.conv1d
+            elif isinstance(base, nn.Conv2d):
+                conv_fn = F.conv2d
+            elif isinstance(base, nn.Conv3d):
+                conv_fn = F.conv3d
+            else:
+                raise TypeError(f"Unsupported conv layer {type(base)} for HiRA.")
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.hira_A.keys():
+                    continue
+                hira_A = self.hira_A[active_adapter]
+                dropout = self.hira_dropout[active_adapter]
+                x = self._cast_input_dtype(x, hira_A.dtype)
+                x_in = self._cast_input_dtype(x, hira_A.dtype)
+                x_drop = dropout(x_in)
+                # low-rank factor B@A
+                bia = self.get_delta_weight(active_adapter)  # now returns (B@A) tensor
+                # element-wise modulate base weight: W0 ⊙ (B@A)
+                base_weight = base.weight
+                eff_weight = base_weight * bia
+                hira_out = conv_fn(
+                    x_drop,
+                    eff_weight,
+                    bias=None,
+                    stride=base.stride,
+                    padding=base.padding,
+                    dilation=getattr(base, "dilation", 1),
+                    groups=base.groups,
+                )
+                result = result + hira_out
+
+            result = result.to(torch_result_dtype)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "hira." + rep
+
+
+class Conv2d(_ConvNd):
+    # HiRA implemented in a conv2d layer
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if not self._kernel_dim == 4:
+            raise ValueError(f"Conv2d layer kernel must have 4 dimensions, not {self._kernel_dim}")
+        self.conv_fn = F.conv2d
+
+
+class Conv1d(_ConvNd):
+    # HiRA implemented in a conv1d layer
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if not self._kernel_dim == 3:
+            raise ValueError(f"Conv1d layer kernel must have 3 dimensions, not {self._kernel_dim}")
+        self.conv_fn = F.conv1d
+
+
+class Conv3d(_ConvNd):
+    # HiRA implemented in a conv3d layer
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if not self._kernel_dim == 5:
+            raise ValueError(f"Conv3d layer kernel must have 5 dimensions, not {self._kernel_dim}")
+        self.conv_fn = F.conv3d
+
+
+def dispatch_default(
+    target: torch.nn.Module,
+    adapter_name: str,
+    hira_config: HiraConfig,
+    **kwargs,
+) -> Optional[torch.nn.Module]:
+    """
+    Dispatch function for HiRA adapters that avoids LoFT-Q related config.
+    """
+    # Determine the base module (unwrap BaseTunerLayer)
+    if isinstance(target, BaseTunerLayer):
+        base = target.get_base_layer()
+    else:
+        base = target
+
+    r = hira_config.r
+    fan_in_fan_out = hira_config.fan_in_fan_out
+
+    new_module = None
+    # Embedding
+    if isinstance(base, nn.Embedding):
+        new_module = Embedding(target, adapter_name, config=hira_config, r=r)
+    # Conv layers
+    elif isinstance(base, nn.Conv2d):
+        new_module = Conv2d(target, adapter_name, config=hira_config, r=r)
+    elif isinstance(base, nn.Conv3d):
+        new_module = Conv3d(target, adapter_name, config=hira_config, r=r)
+    elif isinstance(base, nn.Conv1d):
+        new_module = Conv1d(target, adapter_name, config=hira_config, r=r)
+    # Linear layers
+    elif isinstance(base, nn.Linear):
+        # Linear always uses fan_in_fan_out=False
+        if fan_in_fan_out:
+            warnings.warn(
+                "fan_in_fan_out is set to True but the target module is `torch.nn.Linear`. "
+                "Setting fan_in_fan_out to False."
+            )
+        new_module = Linear(target, adapter_name, config=hira_config, r=r, fan_in_fan_out=False)
+    # HuggingFace Conv1D
+    elif isinstance(base, Conv1D):
+        # Conv1D expects fan_in_fan_out=True
+        if not fan_in_fan_out:
+            warnings.warn(
+                "fan_in_fan_out is set to False but the target module is `Conv1D`. Setting fan_in_fan_out to True."
+            )
+        new_module = Linear(
+            target, adapter_name, config=hira_config, r=r, fan_in_fan_out=True, is_target_conv_1d_layer=True
+        )
+
+    return new_module
diff --git a/src/peft/tuners/hira/model.py b/src/peft/tuners/hira/model.py
new file mode 100644
index 0000000..a95cb80
--- /dev/null
+++ b/src/peft/tuners/hira/model.py
@@ -0,0 +1,225 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import operator
+
+import torch
+from torch import nn
+
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+from peft.tuners.tuners_utils import BaseTuner
+from peft.utils.other import get_pattern_key
+
+from ...utils.constants import TRANSFORMERS_MODELS_TO_HIRA_TARGET_MODULES_MAPPING
+from .config import HiraConfig
+from .layer import HiraLayer, dispatch_default
+
+
+def _adapter_names_pre_forward_hook(target, args, kwargs, adapter_names):
+    # pre-forward hook to inject the adapter_names argument when using mixed adapter batches inference
+    kwargs["adapter_names"] = adapter_names
+    return args, kwargs
+
+
+def _get_encoder(model: nn.Module) -> nn.Module | None:
+    """Check if the model has an encoder and if it has, returns it; otherwise returns None"""
+    if not hasattr(model, "get_encoder"):
+        return None
+
+    encoder = model.get_encoder()
+    # https://github.com/huggingface/transformers/pull/42156
+    # new logic in transformers v5: all PretrainedModels return a model here, but it is self if there is no encoder
+    if encoder is model:
+        return None
+    return encoder
+
+
+class HiraModel(BaseTuner):
+    """
+    Creates HiRA Adapter model from a pretrained transformers model.
+
+    The method is described in detail in https://openreview.net/pdf?id=TwJrTz9cRS.
+
+    Args:
+        model ([`torch.nn.Module`]): The model to be adapted.
+        config ([`HiraConfig`]): The configuration of the HiRA model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            Create empty adapter weights on meta device. Useful to speed up the loading process.
+
+    Returns:
+        `torch.nn.Module`: The HiRA model.
+
+    Example:
+
+        ```py
+        >>> from transformers import AutoModelForSeq2SeqLM
+        >>> from peft import HiraModel, HiraConfig
+
+        >>> config = HiraConfig(
+        ...     task_type="SEQ_2_SEQ_LM",
+        ...     r=32,
+        ...     target_modules=["q", "v"],
+        ...     hira_dropout=0.01,
+        ... )
+
+        >>> model = AutoModelForSeq2SeqLM.from_pretrained("t5-base")
+        >>> hira_model = HiraModel(model, config, "default")
+        ```
+
+        ```py
+        >>> import torch
+        >>> import transformers
+        >>> from peft import HiraConfig, PeftModel, get_peft_model, prepare_model_for_kbit_training
+
+        >>> rank = ...
+        >>> target_modules = ["q_proj", "k_proj", "v_proj", "out_proj", "fc_in", "fc_out", "wte"]
+        >>> config = HiraConfig(r=32, target_modules=target_modules, hira_dropout=0.1, task_type="CAUSAL_LM")
+        >>> quantization_config = transformers.BitsAndBytesConfig(load_in_8bit=True)
+
+        >>> tokenizer = transformers.AutoTokenizer.from_pretrained(
+        ...     "kakaobrain/kogpt",
+        ...     revision="KoGPT6B-ryan1.5b-float16",  # or float32 version: revision=KoGPT6B-ryan1.5b
+        ...     bos_token="[BOS]",
+        ...     eos_token="[EOS]",
+        ...     unk_token="[UNK]",
+        ...     pad_token="[PAD]",
+        ...     mask_token="[MASK]",
+        ... )
+        >>> model = transformers.GPTJForCausalLM.from_pretrained(
+        ...     "kakaobrain/kogpt",
+        ...     revision="KoGPT6B-ryan1.5b-float16",  # or float32 version: revision=KoGPT6B-ryan1.5b
+        ...     pad_token_id=tokenizer.eos_token_id,
+        ...     use_cache=False,
+        ...     device_map={"": rank},
+        ...     torch_dtype=torch.float16,
+        ...     quantization_config=quantization_config,
+        ... )
+        >>> model = prepare_model_for_kbit_training(model)
+        >>> hira_model = get_peft_model(model, config)
+        ```
+
+    **Attributes**:
+        - **model** ([`~transformers.PreTrainedModel`]) -- The model to be adapted.
+        - **peft_config** ([`HiraConfig`]): The configuration of the HiRA model.
+    """
+
+    prefix: str = "hira_"
+    tuner_layer_cls = HiraLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_HIRA_TARGET_MODULES_MAPPING
+
+    def _create_and_replace(
+        self,
+        hira_config,
+        adapter_name,
+        target,
+        target_name,
+        parent,
+        current_key,
+    ) -> None:
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+
+        # Regexp matching - Find key which matches current target_name in patterns provided
+        r_key = get_pattern_key(hira_config.rank_pattern.keys(), current_key)
+        r = hira_config.rank_pattern.get(r_key, hira_config.r)
+
+        kwargs = {
+            "r": r,
+            "fan_in_fan_out": hira_config.fan_in_fan_out,
+            "loaded_in_8bit": getattr(self.model, "is_loaded_in_8bit", False),
+            "loaded_in_4bit": getattr(self.model, "is_loaded_in_4bit", False),
+        }
+        # for torchao merging, we need the get_apply_tensor_subclass from the quantization config
+        try:
+            kwargs["get_apply_tensor_subclass"] = operator.attrgetter(
+                "hf_quantizer.quantization_config.get_apply_tensor_subclass"
+            )(self.model)
+        except AttributeError:
+            pass
+
+        if isinstance(target, HiraLayer):
+            target.update_layer(adapter_name, r, config=hira_config)
+        else:
+            device_map = self.model.hf_device_map if hasattr(self.model, "hf_device_map") else None
+            new_module = self._create_new_module(hira_config, adapter_name, target, device_map=device_map, **kwargs)
+            if adapter_name not in self.active_adapters:
+                # adding an additional adapter: it is not automatically trainable
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+    def _replace_module(self, parent, child_name, new_module, child):
+        setattr(parent, child_name, new_module)
+        # It's not necessary to set requires_grad here, as that is handled by
+        # _mark_only_adapters_as_trainable
+
+        # child layer wraps the original module, unpack it
+        if hasattr(child, "base_layer"):
+            child = child.base_layer
+
+        meta = torch.device("meta")
+        # dispatch to correct device
+        for name, module in new_module.named_modules():
+            if (self.prefix in name) or ("ranknum" in name):
+                if hasattr(child, "qweight"):
+                    weight = child.qweight
+                elif hasattr(child, "W_q"):
+                    weight = child.W_q
+                elif hasattr(child, "weight"):
+                    weight = child.weight
+                elif getattr(child, "in_proj_weight", None) is not None:  # MHA
+                    weight = child.in_proj_weight
+                else:
+                    weight = next(child.parameters())
+                if not any(p.device == meta for p in module.parameters()):
+                    module.to(weight.device)
+
+    @staticmethod
+    def _create_new_module(hira_config: HiraConfig, adapter_name, target, **kwargs):
+        # Collect dispatcher functions to decide what backend to use for the replaced HiRA layer. The order matters,
+        # because the first match is always used. Therefore, the default layers should be checked last.
+        dispatchers = []
+
+        # avoid eager bnb import
+        if is_bnb_available():
+            from .bnb import dispatch_bnb_8bit
+
+            dispatchers.append(dispatch_bnb_8bit)
+
+        if is_bnb_4bit_available():
+            from .bnb import dispatch_bnb_4bit
+
+            dispatchers.append(dispatch_bnb_4bit)
+        dispatchers.extend(
+            [
+                dispatch_default,
+            ]
+        )
+
+        new_module = None
+        for dispatcher in dispatchers:
+            new_module = dispatcher(target, adapter_name, hira_config=hira_config, **kwargs)
+            if new_module is not None:  # first match wins
+                break
+
+        if new_module is None:
+            # no module could be matched
+            raise ValueError(
+                f"Target module {target} is not supported. Currently, only the following modules are supported: "
+                "`torch.nn.Linear`, `torch.nn.Embedding`, `torch.nn.Conv1d`, `torch.nn.Conv2d`, `torch.nn.Conv3d`, "
+                "`transformers.pytorch_utils.Conv1D`."
+            )
+
+        return new_module
diff --git a/src/peft/tuners/hra/__init__.py b/src/peft/tuners/hra/__init__.py
new file mode 100644
index 0000000..8f5f6a5
--- /dev/null
+++ b/src/peft/tuners/hra/__init__.py
@@ -0,0 +1,24 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+from peft.utils import register_peft_method
+
+from .config import HRAConfig
+from .layer import HRAConv2d, HRALayer, HRALinear
+from .model import HRAModel
+
+
+__all__ = ["HRAConfig", "HRAConv2d", "HRALayer", "HRALinear", "HRAModel"]
+
+register_peft_method(name="hra", config_cls=HRAConfig, model_cls=HRAModel)
diff --git a/src/peft/tuners/hra/config.py b/src/peft/tuners/hra/config.py
new file mode 100644
index 0000000..f29c9c8
--- /dev/null
+++ b/src/peft/tuners/hra/config.py
@@ -0,0 +1,135 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class HRAConfig(PeftConfig):
+    """
+    This is the configuration class to store the configuration of a [`HRAModel`].
+
+    Args:
+        r (`int`):
+            The rank of HRA across different layers. It is best to set 'r' to an even number; otherwise, the default
+            initialization method will not work.
+        apply_GS (`bool`):
+            Whether to apply Gram-Schmidt orthogonalization.
+        target_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to apply the adapter to. If this is specified, only the modules with the specified
+            names will be replaced. When passing a string, a regex match will be performed. When passing a list of
+            strings, either an exact match will be performed or it is checked if the name of the module ends with any
+            of the passed strings. If this is specified as 'all-linear', then all linear modules are chosen, excluding
+            the output layer. If this is not specified, modules will be chosen according to the model architecture. If
+            the architecture is not known, an error will be raised -- in this case, you should specify the target
+            modules manually.
+        exclude_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to not apply the adapter. When passing a string, a regex match will be performed.
+            When passing a list of strings, either an exact match will be performed or it is checked if the name of the
+            module ends with any of the passed strings.
+        init_weights (`bool`):
+            Whether to perform initialization of HRA weights.
+        layers_to_transform (`Union[List[int], int]`):
+            The layer indices to transform. If a list of ints is passed, it will apply the adapter to the layer indices
+            that are specified in this list. If a single integer is passed, it will apply the transformations on the
+            layer at this index.
+        layers_pattern (`Optional[Union[List[str], str]]`):
+            The layer pattern name, used only if `layers_to_transform` is different from `None`. This should target the
+            `nn.ModuleList` of the model, which is often called `'layers'` or `'h'`.
+        bias (`str`):
+            Bias type for HRA. Can be `'none'`, `'all'` or `'hra_only'`.
+        modules_to_save (`List[str]`):
+            List of modules apart from adapter layers to be set as trainable and saved in the final checkpoint.
+    """
+
+    r: int = field(
+        default=8,
+        metadata={
+            "help": "The rank of HRA across different layers.",
+            "note": "It is best to set 'r' to an even number; otherwise, the default initialization method will not work.",
+        },
+    )
+    apply_GS: bool = field(
+        default=False,
+        metadata={"help": "Whether to apply Gram-Schmidt orthogonalization or not."},
+    )
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": "List of module names or regex expression of the module names to replace with HRA.",
+            "example": "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$' ",
+        },
+    )
+    exclude_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={"help": "List of module names or regex expression of the module names to exclude from HRA."},
+    )
+    init_weights: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "Whether to initialize the weights of the HRA layers with their default initialization. Don't change "
+                "this setting, except if you know exactly what you're doing."
+            ),
+        },
+    )
+    layers_to_transform: Optional[Union[list[int], int]] = field(
+        default=None,
+        metadata={
+            "help": "The layer indexes to transform, is this argument is specified, PEFT will transform only the layers indexes that are specified inside this list. If a single integer is passed, PEFT will transform only the layer at this index."
+        },
+    )
+    layers_pattern: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": "The layer pattern name, used only if `layers_to_transform` is different to None and if the layer pattern is not in the common layers pattern. "
+            "This should target the `nn.ModuleList` of the model, which is often called `'layers'` or `'h'`."
+        },
+    )
+    bias: str = field(default="none", metadata={"help": "Bias type for HRA. Can be 'none', 'all' or 'hra_only'"})
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": "List of modules apart from HRA layers to be set as trainable and saved in the final checkpoint. "
+            "For example, in Sequence Classification or Token Classification tasks, "
+            "the final layer `classifier/score` are randomly initialized and as such need to be trainable and saved."
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.HRA
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        self.exclude_modules = (
+            set(self.exclude_modules) if isinstance(self.exclude_modules, list) else self.exclude_modules
+        )
+        # if target_modules is a regex expression, then layers_to_transform should be None
+        if isinstance(self.target_modules, str) and self.layers_to_transform is not None:
+            raise ValueError("`layers_to_transform` cannot be used when `target_modules` is a str.")
+
+        # if target_modules is a regex expression, then layers_pattern should be None
+        if isinstance(self.target_modules, str) and self.layers_pattern is not None:
+            raise ValueError("`layers_pattern` cannot be used when `target_modules` is a str.")
+
+        # check for layers_to_transform and layers_pattern
+        if self.layers_pattern and not self.layers_to_transform:
+            raise ValueError("When `layers_pattern` is specified, `layers_to_transform` must also be specified. ")
diff --git a/src/peft/tuners/hra/layer.py b/src/peft/tuners/hra/layer.py
new file mode 100644
index 0000000..5adb8d9
--- /dev/null
+++ b/src/peft/tuners/hra/layer.py
@@ -0,0 +1,462 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+import math
+import warnings
+from typing import Any, Optional
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+
+from .config import HRAConfig
+
+
+class HRALayer(BaseTunerLayer):
+    # All names of layers that may contain (trainable) adapter weights
+    adapter_layer_names = ("hra_u",)
+    # All names of other parameters that may contain adapter-related parameters
+    other_param_names = ("hra_r", "hra_apply_GS")
+
+    def __init__(self, base_layer: nn.Module, **kwargs) -> None:
+        self.base_layer = base_layer
+        self.hra_r = {}
+        self.hra_apply_GS = {}
+        self.hra_u = nn.ParameterDict({})
+        # Mark the weight as unmerged
+        self._disable_adapters = False
+        self.merged_adapters = []
+        # flag to enable/disable casting of input to weight dtype during forward call
+        self.cast_input_dtype_enabled = True
+        self.kwargs = kwargs
+
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            self.in_features, self.out_features = base_layer.in_features, base_layer.out_features
+        elif isinstance(base_layer, nn.Conv2d):
+            self.in_features, self.out_features = base_layer.in_channels, base_layer.out_channels
+        else:
+            raise TypeError(f"Unsupported layer type {type(base_layer)}")
+
+    def update_layer(
+        self,
+        adapter_name: str,
+        r: int,
+        config: HRAConfig,
+        **kwargs,
+    ) -> None:
+        """Internal function to create hra adapter
+
+        Args:
+            adapter_name (`str`): Name for the adapter to add.
+            r (`int`): Rank for the added adapter.
+            config (`HRAConfig`): The adapter configuration for this layer.
+        """
+        apply_GS = config.apply_GS
+        init_weights = config.init_weights
+        inference_mode = config.inference_mode
+
+        if r <= 0:
+            raise ValueError(f"`r` should be a positive integer value but the value passed is {r}")
+
+        self.hra_r[adapter_name] = r
+        self.hra_apply_GS[adapter_name] = apply_GS
+
+        # Determine shape of HRA weights
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            self.hra_u[adapter_name] = nn.Parameter(torch.empty(self.in_features, r), requires_grad=True)
+        elif isinstance(base_layer, nn.Conv2d):
+            self.hra_u[adapter_name] = nn.Parameter(
+                torch.empty(self.in_features * base_layer.kernel_size[0] * base_layer.kernel_size[0], r),
+                requires_grad=True,
+            )
+        else:
+            raise TypeError(f"HRA is not implemented for base layers of type {type(base_layer).__name__}")
+
+        # Initialize weights
+        if init_weights:
+            self.reset_hra_parameters(adapter_name)
+        else:
+            self.reset_hra_parameters_random(adapter_name)
+
+        # Move new weights to device
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def reset_hra_parameters(self, adapter_name: str):
+        if self.hra_r[adapter_name] % 2 != 0:
+            warnings.warn("The symmetric initialization can NOT be performed when r is odd!")
+            nn.init.kaiming_uniform_(self.hra_u[adapter_name], a=math.sqrt(5))
+        else:
+            shape = self.hra_u[adapter_name].shape
+            half_u = torch.zeros(shape[0], shape[1] // 2)
+            nn.init.kaiming_uniform_(half_u, a=math.sqrt(5))
+            self.hra_u[adapter_name] = nn.Parameter(torch.repeat_interleave(half_u, 2, dim=1))
+
+    def reset_hra_parameters_random(self, adapter_name: str):
+        nn.init.kaiming_uniform_(self.hra_u[adapter_name], a=math.sqrt(5))
+
+    def scale_layer(self, scale: float) -> None:
+        if scale == 1:
+            return
+
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self.hra_u.keys():
+                continue
+
+            warnings.warn("Scaling operation for HRA not supported! Automatically set scale to 1.")
+
+    def unscale_layer(self, scale=None) -> None:
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self.hra_u.keys():
+                continue
+
+            warnings.warn("Unscaling operation for HRA not supported! Keeping scale at 1.")
+
+
+class HRALinear(nn.Module, HRALayer):
+    """
+    HRA implemented in a dense layer.
+    """
+
+    def __init__(
+        self,
+        base_layer,
+        adapter_name: str,
+        config: HRAConfig,
+        r: int = 0,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        HRALayer.__init__(self, base_layer, **kwargs)
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, config=config, **kwargs)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If `True`, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If `None`, all active adapters will be merged.
+                Defaults to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.hra_u.keys():
+                base_layer = self.get_base_layer()
+                orig_dtype = base_layer.weight.dtype
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    # because of the copy operation.
+                    orig_weight = base_layer.weight.data.clone()
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    orig_weight = torch.mm(orig_weight.to(delta_weight.dtype), delta_weight)
+
+                    if not torch.isfinite(orig_weight).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = orig_weight.to(orig_dtype)
+                else:
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    new_weight = torch.mm(base_layer.weight.data.to(delta_weight.dtype), delta_weight)
+                    base_layer.weight.data = new_weight.to(orig_dtype)
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            base_layer = self.get_base_layer()
+            orig_dtype = base_layer.weight.dtype
+            if active_adapter in self.hra_u.keys():
+                orig_weight = base_layer.weight.data.clone()
+                delta_weight = self.get_delta_weight(active_adapter, reverse=True)
+                new_weight = torch.mm(orig_weight.to(delta_weight.dtype), delta_weight)
+                base_layer.weight.data = new_weight.to(orig_dtype)
+
+    def get_delta_weight(self, adapter_name: str, reverse: bool = False) -> torch.Tensor:
+        rank = self.hra_r[adapter_name]
+        apply_GS = self.hra_apply_GS[adapter_name]
+        opt_u = self.hra_u[adapter_name]
+        shape = opt_u.shape
+
+        if apply_GS:
+            weight = [(opt_u[:, 0] / opt_u[:, 0].norm()).view(-1, 1)]
+            for i in range(1, rank):
+                ui = opt_u[:, i].view(-1, 1)
+                for j in range(i):
+                    ui = ui - (weight[j].t() @ ui) * weight[j]
+                weight.append((ui / ui.norm()).view(-1, 1))
+            weight = torch.cat(weight, dim=1)
+            weight = torch.eye(shape[0], device=opt_u.device, dtype=opt_u.dtype) - 2 * weight @ weight.t()
+
+        else:
+            opt_u = opt_u / opt_u.norm(dim=0)
+            weight = torch.eye(shape[0], device=opt_u.device, dtype=opt_u.dtype)
+            if reverse:
+                indices = range(rank - 1, -1, -1)
+            else:
+                indices = range(rank)
+
+            for i in indices:
+                ui = opt_u[:, i].view(-1, 1)
+                weight = weight - 2 * weight @ ui @ ui.t()
+
+        return weight
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        previous_dtype = x.dtype
+
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            new_weight = torch.eye(self.in_features, device=x.device)
+
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.hra_u.keys():
+                    continue
+                delta_weight = self.get_delta_weight(active_adapter)
+                new_weight = torch.mm(new_weight.to(delta_weight.dtype), delta_weight)
+
+            orig_weight = self.get_base_layer().weight.data
+            orig_weight = self._cast_input_dtype(orig_weight, new_weight.dtype)
+            new_weight = torch.mm(orig_weight, new_weight)
+            bias = self._cast_input_dtype(self.base_layer.bias, new_weight.dtype)
+
+            if self.cast_input_dtype_enabled:
+                x = self._cast_input_dtype(x, new_weight.dtype)
+            else:
+                x = x.to(self.get_base_layer().weight.data.dtype)
+            result = F.linear(input=x, weight=new_weight, bias=bias)
+
+        result = result.to(previous_dtype)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "hra." + rep
+
+
+class HRAConv2d(nn.Module, HRALayer):
+    """HRA implemented in Conv2d layer"""
+
+    def __init__(
+        self,
+        base_layer,
+        adapter_name: str,
+        config: HRAConfig,
+        r: int = 0,
+        **kwargs,
+    ):
+        super().__init__()
+        HRALayer.__init__(self, base_layer)
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, config=config, **kwargs)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If `True`, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If `None`, all active adapters will be merged.
+                Defaults to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.hra_u.keys():
+                base_layer = self.get_base_layer()
+                orig_dtype = base_layer.weight.dtype
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    # because of the copy operation.
+                    orig_weight = base_layer.weight.data.clone()
+                    orig_weight = orig_weight.view(
+                        self.out_features,
+                        self.in_features * base_layer.kernel_size[0] * self.base_layer.kernel_size[0],
+                    )
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    orig_weight = torch.mm(orig_weight.to(delta_weight.dtype), delta_weight)
+                    orig_weight = orig_weight.view(
+                        self.out_features,
+                        self.in_features,
+                        base_layer.kernel_size[0],
+                        base_layer.kernel_size[0],
+                    )
+
+                    if not torch.isfinite(orig_weight).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = orig_weight.to(orig_dtype)
+                else:
+                    orig_weight = base_layer.weight.data
+                    orig_weight = orig_weight.view(
+                        self.out_features,
+                        self.in_features * self.base_layer.kernel_size[0] * self.base_layer.kernel_size[0],
+                    )
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    orig_weight = torch.mm(orig_weight.to(delta_weight.dtype), delta_weight)
+                    orig_weight = orig_weight.view(
+                        self.out_features,
+                        self.in_features,
+                        base_layer.kernel_size[0],
+                        base_layer.kernel_size[0],
+                    )
+
+                    base_layer.weight.data = orig_weight.to(orig_dtype)
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            base_layer = self.get_base_layer()
+            orig_dtype = base_layer.weight.dtype
+            if active_adapter in self.hra_u.keys():
+                orig_weight = base_layer.weight.data.clone()
+                orig_weight = orig_weight.view(
+                    self.out_features,
+                    self.in_features * base_layer.kernel_size[0] * base_layer.kernel_size[0],
+                )
+                delta_weight = self.get_delta_weight(active_adapter, reverse=True)
+                orig_weight = torch.mm(orig_weight.to(delta_weight.dtype), delta_weight)
+                orig_weight = orig_weight.view(
+                    self.out_features, self.in_features, base_layer.kernel_size[0], base_layer.kernel_size[0]
+                )
+
+                base_layer.weight.data = orig_weight.to(orig_dtype)
+
+    def get_delta_weight(self, adapter_name: str, reverse: bool = False) -> torch.Tensor:
+        rank = self.hra_r[adapter_name]
+        apply_GS = self.hra_apply_GS[adapter_name]
+        opt_u = self.hra_u[adapter_name]
+        shape = opt_u.shape
+
+        if apply_GS:
+            weight = [(opt_u[:, 0] / opt_u[:, 0].norm()).view(-1, 1)]
+            for i in range(1, rank):
+                ui = opt_u[:, i].view(-1, 1)
+                for j in range(i):
+                    ui = ui - (weight[j].t() @ ui) * weight[j]
+                weight.append((ui / ui.norm()).view(-1, 1))
+            weight = torch.cat(weight, dim=1)
+            weight = torch.eye(shape[0], device=opt_u.device, dtype=opt_u.dtype) - 2 * weight @ weight.t()
+
+        else:
+            opt_u = opt_u / opt_u.norm(dim=0)
+            weight = torch.eye(shape[0], device=opt_u.device, dtype=opt_u.dtype)
+            if reverse:
+                indices = range(rank - 1, -1, -1)
+            else:
+                indices = range(rank)
+
+            for i in indices:
+                ui = opt_u[:, i].view(-1, 1)
+                weight = weight - 2 * weight @ ui @ ui.t()
+
+        return weight
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        previous_dtype = x.dtype
+
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            new_weight = torch.eye(
+                self.in_features * self.base_layer.kernel_size[0] * self.base_layer.kernel_size[0],
+                device=x.device,
+            )
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.hra_u.keys():
+                    continue
+                delta_weight = self.get_delta_weight(active_adapter)
+                new_weight = torch.mm(new_weight.to(delta_weight.dtype), delta_weight)
+
+            orig_weight = self.base_layer.weight.data
+            orig_weight = orig_weight.view(
+                self.out_features,
+                self.in_features * self.base_layer.kernel_size[0] * self.base_layer.kernel_size[0],
+            )
+            orig_weight = self._cast_input_dtype(orig_weight, new_weight.dtype)
+            bias = self._cast_input_dtype(self.base_layer.bias, new_weight.dtype)
+
+            new_weight = torch.mm(orig_weight, new_weight)
+            new_weight = new_weight.view(
+                self.out_features,
+                self.in_features,
+                self.base_layer.kernel_size[0],
+                self.base_layer.kernel_size[0],
+            )
+
+            if self.cast_input_dtype_enabled:
+                x = self._cast_input_dtype(x, new_weight.dtype)
+            else:
+                x = x.to(self.get_base_layer().weight.data.dtype)
+            result = F.conv2d(
+                input=x,
+                weight=new_weight,
+                bias=bias,
+                padding=self.base_layer.padding[0],
+                stride=self.base_layer.stride[0],
+            )
+
+        result = result.to(previous_dtype)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "hra." + rep
diff --git a/src/peft/tuners/hra/model.py b/src/peft/tuners/hra/model.py
new file mode 100644
index 0000000..8eb57bc
--- /dev/null
+++ b/src/peft/tuners/hra/model.py
@@ -0,0 +1,122 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+
+import torch
+
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer
+from peft.utils import TRANSFORMERS_MODELS_TO_HRA_TARGET_MODULES_MAPPING
+
+from .layer import HRAConv2d, HRALayer, HRALinear
+
+
+class HRAModel(BaseTuner):
+    """
+    Creates Householder reflection adaptation (HRA) model from a pretrained model. The method is described in
+    https://huggingface.co/papers/2405.17484
+
+    Args:
+        model (`torch.nn.Module`): The model to which the adapter tuner layers will be attached.
+        config ([`HRAConfig`]): The configuration of the HRA model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            Create empty adapter weights on meta device. Useful to speed up the loading process.
+
+    Returns:
+        `torch.nn.Module`: The HRA model.
+
+    Example:
+        ```py
+        >>> from diffusers import StableDiffusionPipeline
+        >>> from peft import HRAModel, HRAConfig
+
+        >>> config_te = HRAConfig(
+        ...     r=8,
+        ...     target_modules=["k_proj", "q_proj", "v_proj", "out_proj", "fc1", "fc2"],
+        ...     init_weights=True,
+        ... )
+        >>> config_unet = HRAConfig(
+        ...     r=8,
+        ...     target_modules=[
+        ...         "proj_in",
+        ...         "proj_out",
+        ...         "to_k",
+        ...         "to_q",
+        ...         "to_v",
+        ...         "to_out.0",
+        ...         "ff.net.0.proj",
+        ...         "ff.net.2",
+        ...     ],
+        ...     init_weights=True,
+        ... )
+
+        >>> model = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
+        >>> model.text_encoder = HRAModel(model.text_encoder, config_te, "default")
+        >>> model.unet = HRAModel(model.unet, config_unet, "default")
+        ```
+
+    **Attributes**:
+        - **model** ([`~torch.nn.Module`]) -- The model to be adapted.
+        - **peft_config** ([`HRAConfig`]): The configuration of the HRA model.
+    """
+
+    prefix: str = "hra_"
+    tuner_layer_cls = HRALayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_HRA_TARGET_MODULES_MAPPING
+
+    def _create_and_replace(
+        self,
+        hra_config,
+        adapter_name,
+        target,
+        target_name,
+        parent,
+        current_key,
+        **optional_kwargs,
+    ):
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+
+        # If it is not a HRALayer, create a new module, else update it with new adapters
+        if not isinstance(target, HRALayer):
+            new_module = self._create_new_module(hra_config, adapter_name, target, r=hra_config.r)
+            if adapter_name not in self.active_adapters:
+                # adding an additional adapter: it is not automatically trainable
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+        else:
+            target.update_layer(
+                adapter_name,
+                r=hra_config.r,
+                config=hra_config,
+            )
+
+    @staticmethod
+    def _create_new_module(hra_config, adapter_name, target, **kwargs):
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        if isinstance(target_base_layer, torch.nn.Linear):
+            new_module = HRALinear(target, adapter_name, config=hra_config, **kwargs)
+        elif isinstance(target_base_layer, torch.nn.Conv2d):
+            new_module = HRAConv2d(target, adapter_name, config=hra_config, **kwargs)
+        else:
+            raise TypeError(
+                f"Target module {target} is not supported. "
+                "Currently, only `torch.nn.Linear` and `torch.nn.Conv2d` are supported."
+            )
+
+        return new_module
diff --git a/src/peft/tuners/ia3/__init__.py b/src/peft/tuners/ia3/__init__.py
new file mode 100644
index 0000000..21cab4d
--- /dev/null
+++ b/src/peft/tuners/ia3/__init__.py
@@ -0,0 +1,39 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+from peft.utils import register_peft_method
+
+from .config import IA3Config
+from .layer import Conv2d, Conv3d, IA3Layer, Linear
+from .model import IA3Model
+
+
+__all__ = ["Conv2d", "Conv3d", "IA3Config", "IA3Layer", "IA3Model", "Linear"]
+
+register_peft_method(name="ia3", config_cls=IA3Config, model_cls=IA3Model, is_mixed_compatible=True)
+
+
+def __getattr__(name):
+    if (name == "Linear8bitLt") and is_bnb_available():
+        from .bnb import Linear8bitLt
+
+        return Linear8bitLt
+
+    if (name == "Linear4bit") and is_bnb_4bit_available():
+        from .bnb import Linear4bit
+
+        return Linear4bit
+
+    raise AttributeError(f"module {__name__} has no attribute {name}")
diff --git a/src/peft/tuners/ia3/bnb.py b/src/peft/tuners/ia3/bnb.py
new file mode 100644
index 0000000..ce0a8b4
--- /dev/null
+++ b/src/peft/tuners/ia3/bnb.py
@@ -0,0 +1,130 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from typing import Any
+
+import torch
+
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+
+from .config import IA3Config
+from .layer import IA3Layer
+
+
+if is_bnb_available():
+
+    class Linear8bitLt(torch.nn.Module, IA3Layer):
+        # (IA)^3 implemented in a dense layer
+        def __init__(
+            self,
+            base_layer: torch.nn.Module,
+            adapter_name: str,
+            config: IA3Config,
+            is_feedforward: bool,
+            **kwargs,
+        ) -> None:
+            super().__init__()
+            IA3Layer.__init__(self, base_layer, is_feedforward=is_feedforward)
+
+            # Freezing the pre-trained weight matrix
+            self.get_base_layer().weight.requires_grad = False
+            self._active_adapter = adapter_name
+            self.update_layer(adapter_name, config=config)
+
+        def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+            # note: no check for self.merged because merging is not supported (yet)
+            if self.disable_adapters:
+                return self.base_layer(x)
+
+            ia3_scaling = 1
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.ia3_l.keys():
+                    continue
+                ia3_scaling *= self.ia3_l[active_adapter].flatten()
+
+            requires_conversion = (not torch.is_autocast_enabled()) and (x.dtype != torch.float32)
+            if requires_conversion:
+                x = x.float()
+            if self.is_feedforward:
+                result = self.base_layer(x * ia3_scaling)
+                expected_dtype = result.dtype
+            else:
+                result = self.base_layer(x)
+                expected_dtype = result.dtype
+                result = result * ia3_scaling
+
+            if requires_conversion:
+                result = result.to(expected_dtype)
+
+            return result
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return "ia3." + rep
+
+
+if is_bnb_4bit_available():
+
+    class Linear4bit(torch.nn.Module, IA3Layer):
+        # IA3 implemented in a dense layer
+        def __init__(
+            self,
+            base_layer: torch.nn.Module,
+            adapter_name: str,
+            config: IA3Config,
+            is_feedforward: bool,
+            **kwargs,
+        ) -> None:
+            super().__init__()
+            IA3Layer.__init__(self, base_layer, is_feedforward=is_feedforward)
+
+            # Freezing the pre-trained weight matrix
+            self.get_base_layer().weight.requires_grad = False
+            self._active_adapter = adapter_name
+            self.update_layer(adapter_name, config=config)
+
+        def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+            # note: no check for self.merged because merging is not supported (yet)
+            if self.disable_adapters:
+                return self.base_layer(x)
+
+            ia3_scaling = 1
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.ia3_l.keys():
+                    continue
+                ia3_scaling *= self.ia3_l[active_adapter].flatten()
+
+            requires_conversion = (not torch.is_autocast_enabled()) and (x.dtype != torch.float32)
+            if requires_conversion:
+                x = x.float()
+            if self.is_feedforward:
+                result = self.base_layer(x * ia3_scaling)
+                expected_dtype = result.dtype
+            else:
+                result = self.base_layer(x)
+                expected_dtype = result.dtype
+                result = result * ia3_scaling
+
+            result = result.clone()
+            # adalora.py and lora.py both suggest that this is necessary for 4-bit training on older versions of Pytorch.
+            # This has been duplicated here.
+
+            if requires_conversion:
+                result = result.to(expected_dtype)
+
+            return result
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return "ia3." + rep
diff --git a/src/peft/tuners/ia3/config.py b/src/peft/tuners/ia3/config.py
new file mode 100644
index 0000000..1c4161e
--- /dev/null
+++ b/src/peft/tuners/ia3/config.py
@@ -0,0 +1,112 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class IA3Config(PeftConfig):
+    """
+    This is the configuration class to store the configuration of a [`IA3Model`].
+
+    Args:
+        target_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to apply the adapter to. If this is specified, only the modules with the specified
+            names will be replaced. When passing a string, a regex match will be performed. When passing a list of
+            strings, either an exact match will be performed or it is checked if the name of the module ends with any
+            of the passed strings. If this is specified as 'all-linear', then all linear/Conv1D modules are chosen,
+            excluding the output layer. If this is not specified, modules will be chosen according to the model
+            architecture. If the architecture is not known, an error will be raised -- in this case, you should specify
+            the target modules manually.
+        exclude_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to not apply the adapter. When passing a string, a regex match will be performed.
+            When passing a list of strings, either an exact match will be performed or it is checked if the name of the
+            module ends with any of the passed strings.
+        feedforward_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to be treated as feedforward modules, as in the original paper. These modules will
+            have (IA)³ vectors multiplied to the input, instead of the output. `feedforward_modules` must be a name or
+            a subset of names present in `target_modules`.
+        fan_in_fan_out (`bool`):
+            Set this to True if the layer to replace stores weight like (fan_in, fan_out). For example, gpt-2 uses
+            `Conv1D` which stores weights like (fan_in, fan_out) and hence this should be set to `True`.
+        modules_to_save (`Optional[List[str]]`):
+            List of modules apart from (IA)³ layers to be set as trainable and saved in the final checkpoint.
+        init_ia3_weights (`bool`):
+            Whether to initialize the vectors in the (IA)³ layers, defaults to `True`. Setting this to `False` is
+            discouraged.
+    """
+
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of module names or regex expression of the module names to replace with (IA)³."
+                "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'."
+                "This can also be a wildcard 'all-linear' which matches all linear/Conv1D layers except the output layer."
+                "If not specified, modules will be chosen according to the model architecture, If the architecture is "
+                "not known, an error will be raised -- in this case, you should specify the target modules manually."
+            ),
+        },
+    )
+    exclude_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={"help": "List of module names or regex expression of the module names to exclude from (IA)³."},
+    )
+    feedforward_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": "List of module names or a regex expression of module names which are feedforward"
+            "For example, ['output.dense']"
+        },
+    )
+    fan_in_fan_out: bool = field(
+        default=False,
+        metadata={"help": "Set this to True if the layer to replace stores weight like (fan_in, fan_out)"},
+    )
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": "List of modules apart from (IA)^3 layers to be set as trainable and saved in the final checkpoint. "
+            "For example, in Sequence Classification or Token Classification tasks, "
+            "the final layer `classifier/score` are randomly initialized and as such need to be trainable and saved."
+        },
+    )
+    init_ia3_weights: bool = field(
+        default=True,
+        metadata={"help": "Whether to initialize the vectors in the (IA)^3 layers."},
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.IA3
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        self.exclude_modules = (
+            set(self.exclude_modules) if isinstance(self.exclude_modules, list) else self.exclude_modules
+        )
+        self.feedforward_modules = (
+            set(self.feedforward_modules) if isinstance(self.feedforward_modules, list) else self.feedforward_modules
+        )
+
+        # check if feedforward_modules is a subset of target_modules. run the check only if both are sets
+        if isinstance(self.feedforward_modules, set) and isinstance(self.target_modules, set):
+            if not self.feedforward_modules.issubset(self.target_modules):
+                raise ValueError("`feedforward_modules` should be a subset of `target_modules`")
diff --git a/src/peft/tuners/ia3/layer.py b/src/peft/tuners/ia3/layer.py
new file mode 100644
index 0000000..7f989ec
--- /dev/null
+++ b/src/peft/tuners/ia3/layer.py
@@ -0,0 +1,336 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import warnings
+from typing import Any, Optional
+
+import torch
+from torch import nn
+from transformers.pytorch_utils import Conv1D
+
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+from peft.utils import transpose
+
+from .config import IA3Config
+
+
+class IA3Layer(BaseTunerLayer):
+    # All names of layers that may contain adapter weights
+    adapter_layer_names = ("ia3_l",)
+
+    def __init__(self, base_layer: nn.Module, is_feedforward: bool, **kwargs) -> None:
+        self.base_layer = base_layer
+        self.ia3_l = nn.ParameterDict({})
+        # Mark the weight as unmerged
+        self._disable_adapters = False
+        self.merged_adapters = []
+        self.is_feedforward = is_feedforward
+
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            in_features, out_features = base_layer.in_features, base_layer.out_features
+        elif isinstance(base_layer, (nn.Conv2d, nn.Conv3d)):
+            in_features, out_features = base_layer.in_channels, base_layer.out_channels
+        elif isinstance(base_layer, nn.Embedding):
+            in_features, out_features = base_layer.num_embeddings, base_layer.embedding_dim
+        elif isinstance(base_layer, Conv1D):
+            in_features, out_features = (
+                base_layer.weight.ds_shape if hasattr(base_layer.weight, "ds_shape") else base_layer.weight.shape
+            )
+        else:
+            raise TypeError(f"Unsupported layer type {type(base_layer)}")
+        self.in_features = in_features
+        self.out_features = out_features
+
+    def update_layer(self, adapter_name: str, config: IA3Config, **kwargs):
+        init_ia3_weights = config.init_ia3_weights
+        inference_mode = config.inference_mode
+
+        # This code works for linear layers, override for other layer types
+        # Actual trainable parameters
+        if self.is_feedforward:
+            weight = torch.randn((1, self.in_features))
+        else:
+            weight = torch.randn((self.out_features, 1))
+        self.ia3_l[adapter_name] = nn.Parameter(weight)
+        if init_ia3_weights:
+            self.reset_ia3_parameters(adapter_name)
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def reset_ia3_parameters(self, adapter_name):
+        if adapter_name in self.ia3_l.keys():
+            # initialize learned vector with torch.ones
+            nn.init.constant_(self.ia3_l[adapter_name], 1.0)
+
+
+class Linear(nn.Module, IA3Layer):
+    # (IA)^3 implemented in a dense layer
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        adapter_name: str,
+        config: IA3Config,
+        is_feedforward: bool = False,  # Set to True if the layer is treated as a feedforward layer
+        is_target_conv_1d_layer: bool = False,  # whether target module is a conv1d layer. useful while unloading later
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        IA3Layer.__init__(self, base_layer, is_feedforward=is_feedforward)
+        self.fan_in_fan_out = config.fan_in_fan_out
+        self.is_target_conv_1d_layer = is_target_conv_1d_layer
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, config=config)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.ia3_l.keys():
+                base_layer = self.get_base_layer()
+                ia3_l = transpose(self.ia3_l[active_adapter].data, self.fan_in_fan_out)
+                orig_dtype = base_layer.weight.data.dtype
+                if safe_merge:
+                    orig_weights = base_layer.weight.data
+                    orig_weights = torch.mul(orig_weights, ia3_l)
+
+                    if not torch.isfinite(orig_weights).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+                    base_layer.weight.data = orig_weights.to(orig_dtype)
+                else:
+                    base_layer.weight.data = torch.mul(base_layer.weight.data, ia3_l).to(orig_dtype)
+
+                if not self.is_feedforward and (base_layer.bias is not None):
+                    scaling = self.ia3_l[active_adapter].reshape(base_layer.bias.shape)
+                    orig_dtype = base_layer.bias.data.dtype
+                    base_layer.bias.data = torch.mul(base_layer.bias.data, scaling.data).to(orig_dtype)
+
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+
+        warnings.warn("Unmerge result can be inaccurate for (IA)^3.")
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.ia3_l.keys():
+                base_layer = self.get_base_layer()
+                # Add tolerace to avoid division by zero
+                ia3_l = transpose(self.ia3_l[active_adapter].data, self.fan_in_fan_out) + 1e-8
+                orig_dtype = base_layer.weight.data.dtype
+                base_layer.weight.data = torch.div(base_layer.weight.data, ia3_l).to(orig_dtype)
+
+                if not self.is_feedforward and (base_layer.bias is not None):
+                    scaling = self.ia3_l[active_adapter].reshape(base_layer.bias.shape)
+                    orig_dtype = base_layer.bias.data.dtype
+                    base_layer.bias.data = torch.div(base_layer.bias.data, scaling.data + 1e-8).to(orig_dtype)
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        dtype = previous_dtype = x.dtype
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            ia3_scaling = 1
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.ia3_l.keys():
+                    continue
+                dtype = self.ia3_l[active_adapter].dtype
+                ia3_scaling *= self.ia3_l[active_adapter].flatten()
+
+            if self.is_feedforward:
+                x = x.to(dtype)
+                # TODO: weight.dtype can be != self.ia3_l[self.active_adapters].dtype
+                # e.g. bf16 vs fp32. Is that okay?
+                interm = (x * ia3_scaling).to(previous_dtype)
+                result = self.base_layer(interm, *args, **kwargs)
+            else:
+                result = self.base_layer(x, *args, **kwargs)
+                result_dtype = result.dtype
+                result = (result * ia3_scaling).to(result_dtype)
+
+        return result
+
+
+class _ConvNd(nn.Module, IA3Layer):
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        adapter_name: str,
+        config: IA3Config,
+        is_feedforward: bool = False,  # Set to True if the layer is treated as a feedforward layer
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        IA3Layer.__init__(self, base_layer, is_feedforward=is_feedforward)
+        self.fan_in_fan_out = config.fan_in_fan_out
+        self._active_adapter = adapter_name
+        self._kernel_dim = base_layer.weight.dim()
+
+        self.update_layer(adapter_name, config=config)
+
+    def update_layer(self, adapter_name: str, config: IA3Config, **kwargs):
+        init_ia3_weights = config.init_ia3_weights
+        inference_mode = config.inference_mode
+
+        # Actual trainable parameters
+        num_features = self.in_features if self.is_feedforward else self.out_features
+        weights_size = (1, num_features) + (1,) * (self._kernel_dim - 2)
+        weight = torch.randn(weights_size)
+        self.ia3_l[adapter_name] = nn.Parameter(weight)
+        if init_ia3_weights:
+            self.reset_ia3_parameters(adapter_name)
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.ia3_l.keys():
+                base_layer = self.get_base_layer()
+                orig_dtype = base_layer.weight.data.dtype
+                ia3_scaling = self.ia3_l[active_adapter].data
+                if not self.is_feedforward:
+                    ia3_scaling = ia3_scaling.transpose(0, 1)
+
+                if safe_merge:
+                    output_weight = torch.mul(base_layer.weight.data, ia3_scaling).clone()
+
+                    if not torch.isfinite(output_weight).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = output_weight.to(orig_dtype)
+                else:
+                    base_layer.weight.data = torch.mul(base_layer.weight.data, ia3_scaling).to(orig_dtype)
+
+                if not self.is_feedforward and (base_layer.bias is not None):
+                    scaling = self.ia3_l[active_adapter].reshape(base_layer.bias.shape)
+                    base_layer.bias.data = torch.mul(base_layer.bias.data, scaling.data).to(orig_dtype)
+
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+
+        warnings.warn("Unmerge result can be inaccurate for (IA)^3.")
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.ia3_l.keys():
+                base_layer = self.get_base_layer()
+                orig_dtype = base_layer.weight.data.dtype
+                # divide by (IA)^3 vector. Add tolerace to avoid division by zero
+                ia3_scaling = self.ia3_l[active_adapter].data
+                if not self.is_feedforward:
+                    ia3_scaling = ia3_scaling.transpose(0, 1)
+                base_layer.weight.data = torch.div(base_layer.weight.data, ia3_scaling + 1e-8).to(orig_dtype)
+
+                if not self.is_feedforward and (base_layer.bias is not None):
+                    scaling = self.ia3_l[active_adapter].reshape(base_layer.bias.shape)
+                    orig_dtype = base_layer.bias.data.dtype
+                    base_layer.bias.data = torch.div(base_layer.bias.data, scaling.data + 1e-8).to(orig_dtype)
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        dtype = previous_dtype = x.dtype
+
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            ia3_scaling = 1
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.ia3_l.keys():
+                    continue
+                dtype = self.ia3_l[active_adapter].dtype
+                ia3_scaling *= self.ia3_l[active_adapter]
+
+            if self.is_feedforward:
+                x = x.to(dtype)
+                # TODO: weight.dtype can be != self.ia3_l[self.active_adapters].dtype
+                # e.g. bf16 vs fp32. Is that okay?
+                interm = (x * ia3_scaling).to(self.get_base_layer().weight.dtype)
+                result = self.base_layer(interm, *args, **kwargs)
+            else:
+                result = self.base_layer(x, *args, **kwargs)
+                result = result.to(dtype) * ia3_scaling
+
+        result = result.to(previous_dtype)
+        return result
+
+
+class Conv2d(_ConvNd):
+    # IA3 implemented in a 2D convolutional layer
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if not self._kernel_dim == 4:
+            raise ValueError(f"Conv2d layer kernel must have 4 dimensions, not {self._kernel_dim}")
+
+
+class Conv3d(_ConvNd):
+    # IA3 implemented in a 3D convolutional layer
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if not self._kernel_dim == 5:
+            raise ValueError(f"Conv2d layer kernel must have 5 dimensions, not {self._kernel_dim}")
diff --git a/src/peft/tuners/ia3/model.py b/src/peft/tuners/ia3/model.py
new file mode 100644
index 0000000..edf1bbb
--- /dev/null
+++ b/src/peft/tuners/ia3/model.py
@@ -0,0 +1,322 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import re
+import warnings
+from dataclasses import replace
+
+import torch
+from transformers.pytorch_utils import Conv1D
+
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer
+from peft.utils import (
+    TRANSFORMERS_MODELS_TO_IA3_FEEDFORWARD_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_IA3_TARGET_MODULES_MAPPING,
+    ModulesToSaveWrapper,
+    _freeze_adapter,
+    _get_submodules,
+)
+
+from .layer import Conv2d, Conv3d, IA3Layer, Linear
+
+
+class IA3Model(BaseTuner):
+    """
+    Creates a Infused Adapter by Inhibiting and Amplifying Inner Activations ((IA)^3) model from a pretrained
+    transformers model. The method is described in detail in https://huggingface.co/papers/2205.05638
+
+    Args:
+        model ([`~transformers.PreTrainedModel`]): The model to be adapted.
+        config ([`IA3Config`]): The configuration of the (IA)^3 model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            Create empty adapter weights on meta device. Useful to speed up the loading process.
+
+    Returns:
+        `torch.nn.Module`: The (IA)^3 model.
+
+    Example:
+
+        ```py
+        >>> from transformers import AutoModelForSeq2SeqLM
+        >>> from peft import IA3Config, get_peft_model
+
+        >>> config = IA3Config(
+        ...     peft_type="IA3",
+        ...     task_type="SEQ_2_SEQ_LM",
+        ...     target_modules=["k", "v", "w0"],
+        ...     feedforward_modules=["w0"],
+        ... )
+
+        >>> model = AutoModelForSeq2SeqLM.from_pretrained("t5-base")
+        >>> ia3_model = get_peft_model(model, config)
+        ```
+
+    **Attributes**:
+        - **model** ([`~transformers.PreTrainedModel`]) -- The model to be adapted.
+        - **peft_config** ([`IA3Config`]): The configuration of the (IA)^3 model.
+    """
+
+    prefix: str = "ia3_"
+    tuner_layer_cls = IA3Layer
+
+    @staticmethod
+    def _create_new_module(ia3_config, adapter_name, target, **kwargs):
+        # avoid eager bnb import
+        if is_bnb_available():
+            import bitsandbytes as bnb
+
+            from .bnb import Linear8bitLt
+
+        if is_bnb_4bit_available():
+            from .bnb import Linear4bit
+
+        loaded_in_8bit = kwargs.pop("loaded_in_8bit", False)
+        loaded_in_4bit = kwargs.pop("loaded_in_4bit", False)
+        is_feedforward = kwargs.pop("is_feedforward", False)
+
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        if loaded_in_8bit and isinstance(target_base_layer, bnb.nn.Linear8bitLt):
+            eightbit_kwargs = kwargs.copy()
+            eightbit_kwargs.update(
+                {
+                    "has_fp16_weights": target_base_layer.state.has_fp16_weights,
+                    "threshold": target_base_layer.state.threshold,
+                    "index": target_base_layer.index,
+                }
+            )
+            new_module = Linear8bitLt(
+                target, adapter_name, config=ia3_config, is_feedforward=is_feedforward, **eightbit_kwargs
+            )
+        elif loaded_in_4bit and isinstance(target_base_layer, bnb.nn.Linear4bit):
+            fourbit_kwargs = kwargs.copy()
+            fourbit_kwargs.update(
+                {
+                    "compute_dtype": target_base_layer.compute_dtype,
+                    "compress_statistics": target_base_layer.weight.compress_statistics,
+                    "quant_type": target_base_layer.weight.quant_type,
+                }
+            )
+            new_module = Linear4bit(
+                target, adapter_name, config=ia3_config, is_feedforward=is_feedforward, **fourbit_kwargs
+            )
+        elif isinstance(target, torch.nn.Conv2d):
+            new_module = Conv2d(target, adapter_name, config=ia3_config, is_feedforward=is_feedforward, **kwargs)
+        elif isinstance(target, torch.nn.Conv3d):
+            new_module = Conv3d(target, adapter_name, config=ia3_config, is_feedforward=is_feedforward, **kwargs)
+        elif isinstance(target_base_layer, torch.nn.Linear):
+            if ia3_config.fan_in_fan_out:
+                warnings.warn(
+                    "fan_in_fan_out is set to True but the target module is `torch.nn.Linear`. "
+                    "Setting fan_in_fan_out to False."
+                )
+                ia3_config.fan_in_fan_out = False
+            new_module = Linear(target, adapter_name, config=ia3_config, is_feedforward=is_feedforward, **kwargs)
+        elif isinstance(target_base_layer, Conv1D):
+            if not ia3_config.fan_in_fan_out:
+                warnings.warn(
+                    "fan_in_fan_out is set to False but the target module is `Conv1D`. Setting fan_in_fan_out to True."
+                )
+                ia3_config.fan_in_fan_out = True
+            new_module = Linear(
+                target,
+                adapter_name,
+                config=ia3_config,
+                is_feedforward=is_feedforward,
+                is_target_conv_1d_layer=True,
+                **kwargs,
+            )
+        else:
+            raise ValueError(
+                f"Target module {target} is not supported. "
+                f"Currently, only `torch.nn.Linear`, `torch.nn.Conv2d`, and `Conv1D` are supported."
+            )
+        return new_module
+
+    def _create_and_replace(
+        self,
+        ia3_config,
+        adapter_name,
+        target,
+        target_name,
+        parent,
+        current_key,
+    ):
+        # check if target module is in feedforward_modules
+        is_feedforward = self._check_target_module_feedforward(ia3_config, current_key)
+
+        kwargs = {
+            "is_feedforward": is_feedforward,
+            "loaded_in_8bit": getattr(self.model, "is_loaded_in_8bit", False),
+            "loaded_in_4bit": getattr(self.model, "is_loaded_in_4bit", False),
+        }
+
+        if isinstance(target, IA3Layer):
+            target.update_layer(
+                adapter_name,
+                config=ia3_config,
+            )
+        else:
+            new_module = self._create_new_module(ia3_config, adapter_name, target, **kwargs)
+            if adapter_name not in self.active_adapters:
+                # adding an additional adapter: it is not automatically trainable
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+    @staticmethod
+    def _check_target_module_feedforward(ia3_config, key) -> bool:
+        """
+        A helper private method that checks if the target module `key` matches with a feedforward module specified in
+        `ia3_config`
+        """
+        if isinstance(ia3_config.feedforward_modules, str):
+            is_feedforward = bool(re.fullmatch(ia3_config.feedforward_modules, key))
+        else:
+            is_feedforward = any(key.endswith(target_key) for target_key in ia3_config.feedforward_modules)
+        return is_feedforward
+
+    @staticmethod
+    def _prepare_adapter_config(peft_config, model_config):
+        if peft_config.target_modules is None:
+            if model_config["model_type"] not in TRANSFORMERS_MODELS_TO_IA3_TARGET_MODULES_MAPPING:
+                raise ValueError("Please specify `target_modules` in `peft_config`")
+            peft_config.target_modules = set(
+                TRANSFORMERS_MODELS_TO_IA3_TARGET_MODULES_MAPPING[model_config["model_type"]]
+            )
+        if peft_config.feedforward_modules is None:
+            if model_config["model_type"] not in TRANSFORMERS_MODELS_TO_IA3_FEEDFORWARD_MODULES_MAPPING:
+                raise ValueError("Please specify `feedforward_modules` in `peft_config`")
+            peft_config.feedforward_modules = set(
+                TRANSFORMERS_MODELS_TO_IA3_FEEDFORWARD_MODULES_MAPPING[model_config["model_type"]]
+            )
+        return peft_config
+
+    def _unload_and_optionally_merge(self, *args, **kwargs):
+        r"""
+        This method merges the (IA)^3 layers into the base model. This is needed if someone wants to use the base model
+        as a standalone model.
+
+        Args:
+            safe_merge (`bool`, `optional`, defaults to `False`):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        if getattr(self.model, "is_loaded_in_8bit", False):
+            raise ValueError("Cannot merge ia3 layers when the model is loaded in 8-bit mode")
+
+        if getattr(self.model, "is_loaded_in_4bit", False):
+            raise ValueError("Cannot merge ia3 layers when the model is loaded in 4-bit mode")
+
+        return super()._unload_and_optionally_merge(*args, **kwargs)
+
+    def _check_add_weighted_adapter(self, adapters: list[str]) -> tuple[str, str]:
+        """
+        Helper function to check if the arguments to add_weighted_adapter are valid and compatible with the underlying
+        model.
+        """
+        # Validate existence of adapters
+        for adapter in adapters:
+            if adapter not in self.peft_config:
+                raise ValueError(f"Adapter {adapter} does not exist")
+
+        # Check for conflicting modules_to_save
+        modules_to_save_wrappers = [module for module in self.modules() if isinstance(module, ModulesToSaveWrapper)]
+        if any(
+            sum(adapter in wrapper.modules_to_save for adapter in adapters) > 1 for wrapper in modules_to_save_wrappers
+        ):
+            raise ValueError("Cannot add weighted adapters targeting the same module with modules_to_save.")
+
+        # Ensure all adapters have compatible target and feedforward module types
+        target_module_types = {type(self.peft_config[adapter].target_modules) for adapter in adapters}
+        feedforward_module_types = {type(self.peft_config[adapter].feedforward_modules) for adapter in adapters}
+        if len(target_module_types) > 1 or len(feedforward_module_types) > 1:
+            raise ValueError("All adapter configs should have the same type for target and feedforward modules.")
+
+        # Combine target and feedforward modules
+        if str in target_module_types:
+            new_target_modules = "|".join(f"({self.peft_config[adapter].target_modules})" for adapter in adapters)
+        else:
+            new_target_modules = set.union(*(self.peft_config[adapter].target_modules for adapter in adapters))
+
+        if str in feedforward_module_types:
+            new_feedforward_modules = "|".join(
+                f"({self.peft_config[adapter].feedforward_modules})" for adapter in adapters
+            )
+        else:
+            new_feedforward_modules = set.union(
+                *(self.peft_config[adapter].feedforward_modules for adapter in adapters)
+            )
+
+        return new_target_modules, new_feedforward_modules
+
+    def add_weighted_adapter(
+        self,
+        adapters: list[str],
+        weights: list[float],
+        adapter_name: str,
+    ) -> None:
+        """
+        This method adds a new adapter by merging the given adapters with the given weights.
+
+        Args:
+            adapters (`list`):
+                List of adapter names to be merged.
+            weights (`list`):
+                List of weights for each adapter.
+            adapter_name (`str`):
+                Name of the new adapter.
+        """
+        if adapter_name in list(self.peft_config.keys()):
+            return
+
+        new_target_modules, new_feedforward_modules = self._check_add_weighted_adapter(
+            adapters=adapters,
+        )
+
+        self.peft_config[adapter_name] = replace(
+            self.peft_config[adapters[0]],
+            target_modules=new_target_modules,
+            feedforward_modules=new_feedforward_modules,
+        )
+        self.inject_adapter(self.model, adapter_name)
+
+        # Do we really need that?
+        _freeze_adapter(self.model, adapter_name)
+
+        key_list = [key for key, _ in self.model.named_modules() if self.prefix not in key]
+        for key in key_list:
+            _, target, _ = _get_submodules(self.model, key)
+            if isinstance(target, IA3Layer):
+                if adapter_name in target.ia3_l:
+                    target_ia3_l = target.ia3_l[adapter_name]
+                else:
+                    continue
+
+                target_ia3_l.data = target_ia3_l.data.zero_()
+                for adapter, weight in zip(adapters, weights):
+                    if adapter in target.ia3_l:
+                        current_adapter_ia3_l = target.ia3_l[adapter]
+                    else:
+                        continue
+                    target_ia3_l.data += current_adapter_ia3_l.data * weight
diff --git a/src/peft/tuners/lily/__init__.py b/src/peft/tuners/lily/__init__.py
new file mode 100644
index 0000000..df75b8a
--- /dev/null
+++ b/src/peft/tuners/lily/__init__.py
@@ -0,0 +1,26 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+from peft.utils import register_peft_method
+
+from .config import LilyConfig
+from .layer import LilyLayer, Linear
+from .model import LilyModel
+
+
+__all__ = ["LilyConfig", "LilyLayer", "LilyModel", "Linear"]
+
+register_peft_method(
+    name="lily", config_cls=LilyConfig, model_cls=LilyModel, prefix="lily_", is_mixed_compatible=False
+)
diff --git a/src/peft/tuners/lily/config.py b/src/peft/tuners/lily/config.py
new file mode 100644
index 0000000..97db3f8
--- /dev/null
+++ b/src/peft/tuners/lily/config.py
@@ -0,0 +1,237 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class LilyConfig(PeftConfig):
+    """
+    This is the configuration class to store the configuration of a [`LilyModel`].
+
+    Args:
+        r (`int`):
+            Lily's rank. Determines the inner hidden dimension of each adapter and the rank of the weight update `A @
+            B`. In Lily, since the number of adapters is typically smaller than in LoRA, each adapter needs to carry
+            more capacity, so it is recommended to use a larger `r` than in LoRA — typically `2x`, `3x`, or `4x` the
+            LoRA rank you would normally use. The total number of trainable parameters scales with `r * (total_layers /
+            stride_A + num_B)`, so increasing `r` while keeping `stride_A` large and `num_B` small is the recommended
+            trade-off.
+        stride_A (`int`):
+            The number of consecutive layers that share one A adapter. For example, if `stride_A=4`, every 4 adjacent
+            layers share the same A adapter, resulting in `total_layers / stride_A` distinct A adapters in total. The A
+            adapter compresses the input into a low-rank representation of size `r`. `stride_A` should be no less than
+            1. Suggested values: `2`, `3`, or `4` (i.e. sharing every 2, 3, or 4 layers). Keeping `stride_A` large
+            (fewer distinct A adapters) and increasing `r` instead leads to better performance than the opposite
+            trade-off (small `stride_A`, small `r`). Setting `stride_A=1` means every layer has its own A adapter.
+            NOTE: the A sharing happens within each target (layers with the same target suffix). For example, if your
+            target_modules are `['q_proj', 'v_proj']` and you set `stride_A=2`, then every 2 adjacent q_proj layers
+            will share an A adapter, and every 2 adjacent v_proj layers will share another A adapter, but the q_proj
+            and v_proj layers will not share A adapters with each other since they have different suffixes.
+        num_B (`int`):
+            The number of shared B adapters. Unlike A adapters (which are grouped by layer), all B adapters are shared
+            globally across every layer. For each forward pass, a router computes a weighted combination of all `num_B`
+            B adapters (using softmax-normalized weights) to produce a single combined B adapter, which then projects
+            the low-rank representation back to the original dimension. It is recommended to set `num_B` to a similar
+            order as `total_layers / stride_A`. Suggested values: `total_layers / 2`, `total_layers / 3`, or
+            `total_layers / 4`. Similar to `stride_A`, prefer smaller `num_B` with larger `r` over larger `num_B` with
+            smaller `r`. NOTE: to train the router, you need at least 2 B adapters (i.e. `num_B >= 2`), since the
+            router learns to compute a weighted combination of the B adapters. NOTE: the B sharing happens within each
+            target (layers with the same target suffix). For example, if your target_modules are `['q_proj', 'v_proj']`
+            and you set `num_B=4`, then there will be 4 B adapters shared across all q_proj layers, and another 4 B
+            adapters shared across all v_proj layers, but the q_proj and v_proj layers will not share B adapters with
+            each other since they have different suffixes.
+        target_modules (`Union[List[str], str]`, *optional*):
+            The names of the modules to apply Lily to. Can be a list of module name strings (e.g. `['q_proj',
+            'v_proj']`) or a regex pattern (e.g. `'.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'`). If not
+            specified, Lily will be applied to all supported linear layers.
+        scaling (`float`):
+            A scalar multiplier applied to the combined adapter output (`scaling * A @ combined_B`) before adding it to
+            the frozen weight's forward pass. Unlike LoRA, Lily does not use an `alpha / r` formulation; instead,
+            `scaling` is a direct multiplier. This design makes it straightforward to sweep over values on a log scale
+            (e.g. `0.01`, `0.1`, `1.0`, `10.0`). The optimal value is task-dependent and should be treated as a
+            hyperparameter. We recommend starting with `1.0`.
+        modules_to_save (`List[str]`, *optional*):
+            List of modules apart from Lily layers to be set as trainable and saved in the final checkpoint. For
+            example, in Sequence Classification or Token Classification tasks, the final layer `classifier/score` are
+            randomly initialized and as such need to be trainable and saved.
+        exclude_modules (`Union[List[str], str]`, *optional*):
+            The names of the modules to not apply the adapter. When passing a string, a regex match will be performed.
+            When passing a list of strings, either an exact match will be performed or it is checked if the name of the
+            module ends with any of the passed strings.
+        layers_to_transform (`Union[list[int], int]`, *optional*):
+            The layer indexes to transform, if this argument is specified, PEFT will transform only the layers indexes
+            that are specified inside this list. If a single integer is passed, PEFT will transform only the layer at
+            this index.
+        layers_pattern (`Optional[Union[List[str], str]]`, *optional*):
+            The layer pattern name, used only if `layers_to_transform` is different to None and if the layer pattern is
+            not in the common layers pattern. This should target the `nn.ModuleList` of the model, which is often
+            called `'layers'` or `'h'`.
+        init_weights (`bool`):
+            Whether to initialize Lily adapter weights using the default initialization scheme: A matrices are
+            initialized with Kaiming uniform, and B matrices are initialized to zero, ensuring that the adapter output
+            is zero at the start of training and does not disturb the pretrained model. It is strongly recommended to
+            keep this as `True` unless you have a specific reason to change it.
+    """
+
+    r: int = field(
+        default=32,
+        metadata={
+            "help": (
+                "Lily's rank. Determines the inner hidden dimension of each adapter and the rank of the "
+                "weight update `A @ B`. In Lily, since the number of adapters is typically smaller than in LoRA, "
+                "each adapter needs to carry more capacity, so it is recommended to use a larger `r` than "
+                "in LoRA — typically `2x`, `3x`, or `4x` the LoRA rank you would normally use. "
+                "The total number of trainable parameters scales with `r * (total_layers / stride_A + num_B)`, "
+                "so increasing `r` while keeping `stride_A` large and `num_B` small is the recommended trade-off."
+            )
+        },
+    )
+    stride_A: int = field(
+        default=1,
+        metadata={
+            "help": (
+                "The number of consecutive layers that share one A adapter. For example, if `stride_A=4`, "
+                "every 4 adjacent layers share the same A adapter, resulting in `total_layers / stride_A` "
+                "distinct A adapters in total."
+                "The A adapter compresses the input into a low-rank representation of size `r`. "
+                "`stride_A` should be no less than 1."
+                "Suggested values: `2`, `3`, or `4` (i.e. sharing every 2, 3, or 4 layers). "
+                "Keeping `stride_A` large (fewer distinct A adapters) and increasing `r` instead leads to "
+                "better performance than the opposite trade-off (small `stride_A`, small `r`). "
+                "Setting `stride_A=1` means every layer has its own A adapter."
+                "Note: A sharing happens within each target module type independently. For example, if "
+                "`target_modules=['q_proj', 'v_proj']` and `stride_A=2`, then every 2 adjacent `q_proj` "
+                "layers share one A adapter and every 2 adjacent `v_proj` layers share another A adapter, "
+                "but `q_proj` and `v_proj` layers never share A adapters with each other."
+            )
+        },
+    )
+    num_B: int = field(
+        default=2,
+        metadata={
+            "help": (
+                "The number of shared B adapters. Unlike A adapters (which are grouped by layer), "
+                "all B adapters are shared globally across every layer. For each forward pass, a router "
+                "computes a weighted combination of all `num_B` B adapters (using softmax-normalized "
+                "weights) to produce a single combined B adapter, which then projects the low-rank "
+                "representation back to the original dimension. It is recommended to set `num_B` to a "
+                "similar order as `total_layers / stride_A`. Suggested values: `total_layers / 2`, "
+                "`total_layers / 3`, or `total_layers / 4`. Similar to `stride_A`, prefer smaller `num_B` "
+                "with larger `r` over larger `num_B` with smaller `r`. "
+                "NOTE: to train the router, you need at least 2 B adapters (i.e. `num_B >= 2`), since the "
+                "router learns to compute a weighted combination of the B adapters."
+                "Note: B sharing happens within each target module type independently. For example, if "
+                "`target_modules=['q_proj', 'v_proj']` and `num_B=4`, then there will be 4 B adapters "
+                "shared across all `q_proj` layers and another 4 B adapters shared across all `v_proj` "
+                "layers, but `q_proj` and `v_proj` layers never share B adapters with each other."
+            )
+        },
+    )
+    scaling: float = field(
+        default=1.0,
+        metadata={
+            "help": (
+                "A scalar multiplier applied to the combined adapter output (`scaling * A @ combined_B`) "
+                "before adding it to the frozen weight's forward pass. Unlike LoRA, Lily does not use an "
+                "`alpha / r` formulation; instead, `scaling` is a direct multiplier. This design "
+                "makes it straightforward to sweep over values on a log scale (e.g. `0.01`, `0.1`, "
+                "`1.0`, `10.0`). The optimal value is task-dependent and should be treated as a "
+                "hyperparameter. We recommend starting with `1.0`."
+            )
+        },
+    )
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of module names or regex expression of the module names to replace with Lily. "
+                "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'. "
+                "If not specified, Lily will be applied to all supported linear layers."
+            )
+        },
+    )
+    exclude_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of module names or regex expression of the module names to exclude from Lily. "
+                "When passing a string, a regex match will be performed. When passing a list of strings, "
+                "either an exact match will be performed or it is checked if the name of the module ends "
+                "with any of the passed strings."
+            )
+        },
+    )
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of modules apart from Lily layers to be set as trainable and saved in the final checkpoint. "
+                "For example, in Sequence Classification or Token Classification tasks, "
+                "the final layer `classifier/score` are randomly initialized and as such need to be trainable and saved."
+            )
+        },
+    )
+    layers_to_transform: Optional[Union[list[int], int]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The layer indexes to transform, if this argument is specified, PEFT will transform only the layers "
+                "indexes that are specified inside this list. If a single integer is passed, PEFT will transform only "
+                "the layer at this index."
+            )
+        },
+    )
+    layers_pattern: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The layer pattern name, used only if `layers_to_transform` is different to None and if the layer "
+                "pattern is not in the common layers pattern. This should target the `nn.ModuleList` of the model, "
+                "which is often called `'layers'` or `'h'`."
+            )
+        },
+    )
+    init_weights: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "Whether to initialize Lily adapter weights using the default initialization scheme: A matrices are "
+                "initialized with Kaiming uniform, and B matrices are initialized to zero, ensuring that the adapter "
+                "output is zero at the start of training and does not disturb the pretrained model. It is strongly "
+                "recommended to keep this as `True` unless you have a specific reason to change it."
+            )
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.LILY
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        self.exclude_modules = (
+            set(self.exclude_modules) if isinstance(self.exclude_modules, list) else self.exclude_modules
+        )
+        if self.layers_pattern and not self.layers_to_transform:
+            raise ValueError("When `layers_pattern` is specified, `layers_to_transform` must also be specified.")
+        if self.stride_A < 1:
+            raise ValueError("`stride_A` must be at least 1.")
+        if self.num_B < 2:
+            raise ValueError("`num_B` must be at least 2 for the router to be trained.")
diff --git a/src/peft/tuners/lily/layer.py b/src/peft/tuners/lily/layer.py
new file mode 100644
index 0000000..b9f472a
--- /dev/null
+++ b/src/peft/tuners/lily/layer.py
@@ -0,0 +1,183 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+import math
+import warnings
+from typing import Any, Optional
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from peft.tuners.tuners_utils import BaseTunerLayer
+
+from .config import LilyConfig
+
+
+class LilyLayer(BaseTunerLayer):
+    # All names of layers that may contain (trainable) adapter weights
+    adapter_layer_names: tuple[str, ...] = ("lily_A", "lily_B", "lily_router")
+    # All names of other parameters that may contain adapter-related parameters
+    other_param_names: tuple[str, ...] = ("r", "scaling", "stride_A", "num_B")
+
+    def __init__(self, base_layer: nn.Module, **kwargs) -> None:
+        self.base_layer = base_layer
+        self.r = {}
+        self.scaling = {}
+        self.stride_A = {}
+        self.num_B = {}
+        self.lily_A = nn.ModuleDict({})
+        self.lily_B = nn.ModuleDict({})
+        self.lily_router = nn.ModuleDict({})
+        self.kwargs = kwargs
+
+        self._disable_adapters = False
+        self.merged_adapters = []
+
+        base_layer = self.get_base_layer()
+
+        if isinstance(base_layer, nn.Linear):
+            in_features, out_features = base_layer.in_features, base_layer.out_features
+        else:
+            # possibly support user provided custom layer types using dynamic dispatch
+            if hasattr(base_layer, "in_features") and hasattr(base_layer, "out_features"):
+                in_features, out_features = base_layer.in_features, base_layer.out_features
+            else:
+                in_features, out_features = None, None
+            warnings.warn(
+                f"Unsupported layer type '{type(base_layer)}' encountered, proceed at your own risk.", UserWarning
+            )
+
+        self.in_features = in_features
+        self.out_features = out_features
+
+    def update_layer(
+        self,
+        adapter_name: str,
+        r: int,
+        config: LilyConfig,
+        lily_A: Optional[nn.Linear] = None,
+        lily_B: Optional[nn.Linear] = None,
+    ) -> None:
+        # collect the kwargs
+        scaling = config.scaling
+        stride_A = config.stride_A
+        num_B = config.num_B
+        init_weights = config.init_weights
+        inference_mode = config.inference_mode
+
+        if r <= 0:
+            raise ValueError(f"`r` should be a positive integer value but the value passed is {r}")
+
+        self.r[adapter_name] = r
+        self.scaling[adapter_name] = scaling
+
+        # Actual trainble parameters
+        self.lily_A[adapter_name] = lily_A if lily_A is not None else nn.Linear(self.in_features, r, bias=False)
+        self.lily_B[adapter_name] = (
+            lily_B if lily_B is not None else nn.Linear(self.out_features, num_B * r, bias=False)
+        )
+        self.lily_router[adapter_name] = nn.Linear(r, num_B, bias=False)
+
+        self.stride_A[adapter_name] = stride_A
+        self.num_B[adapter_name] = num_B
+        self.reset_lily_parameters(adapter_name, init_weights=init_weights)  # initialize the parameters
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def reset_lily_parameters(self, adapter_name, init_weights: bool = True):
+        if adapter_name in self.lily_A:
+            nn.init.kaiming_uniform_(self.lily_A[adapter_name].weight, a=math.sqrt(5))
+            nn.init.kaiming_uniform_(self.lily_router[adapter_name].weight, a=math.sqrt(5))
+            if not init_weights:
+                nn.init.kaiming_uniform_(self.lily_B[adapter_name].weight, a=math.sqrt(5))
+            else:
+                nn.init.zeros_(self.lily_B[adapter_name].weight)
+
+
+class Linear(nn.Module, LilyLayer):
+    # Lily implemented in a dense layer
+    def __init__(
+        self,
+        base_layer,
+        adapter_name: str,
+        r: int,
+        config: LilyConfig,
+        lily_A: Optional[nn.Linear] = None,
+        lily_B: Optional[nn.Linear] = None,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        LilyLayer.__init__(self, base_layer, **kwargs)
+
+        self._active_adapter = adapter_name
+
+        self.update_layer(
+            adapter_name,
+            r,
+            config=config,
+            lily_A=lily_A,
+            lily_B=lily_B,
+        )
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        """
+        Compute the delta weight for the given adapter.
+
+        Args:
+            adapter (str):
+                The name of the adapter for which the delta weight should be computed.
+        """
+        raise NotImplementedError("This method is not supported for Lily.")
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        raise NotImplementedError("This method is not supported for Lily.")
+
+    def unmerge(self) -> None:
+        raise NotImplementedError("This method is not supported for Lily.")
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        result = self.base_layer(x, *args, **kwargs)
+
+        if self.disable_adapters or not self.active_adapters:
+            return result
+
+        torch_result_dtype = result.dtype
+
+        lily_A_keys = self.lily_A.keys()
+
+        for active_adapter in self.active_adapters:
+            if active_adapter not in lily_A_keys:
+                continue
+
+            lily_A = self.lily_A[active_adapter]
+            lily_B = self.lily_B[active_adapter]
+            router = self.lily_router[active_adapter]
+            num_B = self.num_B[active_adapter]
+            B = lily_B.weight.reshape(num_B, -1, lily_B.weight.shape[1])
+            scaling = self.scaling[active_adapter]
+            x = self._cast_input_dtype(x, lily_A.weight.dtype)
+            hidden = lily_A(x)
+            router_logits = router(hidden)  # [B, N, num_of_experts]
+            router_probability = F.softmax(router_logits, dim=-1)  # [B, N, num_of_experts]
+            expert_probabilities = router_probability.reshape(-1, num_B).mean(dim=0)
+            combined_B = torch.einsum("e,eio->io", expert_probabilities, B)
+            delta = torch.matmul(hidden, combined_B)
+            result = result + (delta * scaling).to(torch_result_dtype)
+
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "lily." + rep
diff --git a/src/peft/tuners/lily/model.py b/src/peft/tuners/lily/model.py
new file mode 100644
index 0000000..ba3b96b
--- /dev/null
+++ b/src/peft/tuners/lily/model.py
@@ -0,0 +1,163 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+import torch
+from torch import nn
+
+from peft.tuners.tuners_utils import (
+    BaseTuner,
+    BaseTunerLayer,
+)
+from peft.utils import TRANSFORMERS_MODELS_TO_LILY_TARGET_MODULES_MAPPING
+
+from .config import LilyConfig
+from .layer import LilyLayer, Linear
+
+
+class LilyModel(BaseTuner):
+    """
+    Creates a Low-Rank Interconnected Adaptation Across Layers (Lily) model from a pretrained transformers model.
+
+    The method is described in detail in https://arxiv.org/abs/2407.09946.
+
+    Args:
+        model ([`torch.nn.Module`]): The model to be adapted.
+        config ([`LilyConfig`]): The configuration of the Lily model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+
+    Returns:
+        `torch.nn.Module`: The Lily PEFT model.
+
+    **Attributes**:
+        - **model** ([`~transformers.PreTrainedModel`]) -- The model to be adapted.
+        - **peft_config** ([`LilyConfig`]): The configuration of the Lily model.
+    """
+
+    prefix: str = "lily_"
+    tuner_layer_cls = LilyLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_LILY_TARGET_MODULES_MAPPING
+
+    def _create_and_replace(
+        self,
+        lily_config,
+        adapter_name,
+        target,
+        target_name,
+        parent,
+        current_key,
+        **optional_kwargs,
+    ):
+        """
+        Create a new Lily layer with independent A and B for each layer. Sharing of A/B across layers is deferred to
+        _post_injection_hook.
+        """
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+
+        if isinstance(target, LilyLayer):
+            target.update_layer(
+                adapter_name,
+                lily_config.r,
+                config=lily_config,
+            )
+        else:
+            new_module = self._create_new_module(lily_config, adapter_name, target)
+            if adapter_name not in self.active_adapters:
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+    @staticmethod
+    def _create_new_module(lily_config, adapter_name, target):
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        if isinstance(target_base_layer, torch.nn.Linear):
+            return Linear(
+                target,
+                adapter_name,
+                r=lily_config.r,
+                config=lily_config,
+            )
+
+        raise NotImplementedError(f"Lily does not support target modules of type {type(target_base_layer)} yet.")
+
+    def _post_injection_hook(self, model: nn.Module, config: LilyConfig, adapter_name: str) -> None:
+        """
+        After all layers have been independently initialized, apply A/B sharing across layers.
+
+        A sharing: for each (target_module_suffix, weight_shape) group, consecutive blocks of `stride_A` layers share
+        the same A. The first layer in each block keeps its own A; subsequent layers in the block have their lily_A
+        replaced by the group leader's.
+
+        B sharing: all layers in the same (target_module_suffix, weight_shape) group share the B from the very first
+        layer in that group.
+
+        Both lily_A and lily_B are nn.Linear modules, so they move correctly with model.to(device) via standard
+        nn.Module parameter propagation.
+
+        Note: (target_module_suffix, weight_shape) is used as the group key rather than target_module_suffix alone, to
+        correctly handle architectures like UNet where the same target key can appear with different shapes across
+        layers.
+        """
+        stride_A = config.stride_A
+
+        # Collect all adapted LilyLayer modules in traversal order, grouped by
+        # (target_module_suffix, weight_shape).
+        # Maps (target_suffix, weight_shape) -> list of LilyLayer in traversal order.
+        target_to_layers: dict[tuple[str, torch.Size], list[LilyLayer]] = {}
+
+        for key, module in model.named_modules():
+            if not isinstance(module, LilyLayer):
+                continue
+            if adapter_name not in module.lily_A:
+                continue
+
+            base = module.get_base_layer()
+            shape = base.weight.shape  # (out_features, in_features)
+
+            # Find the longest matching target suffix for this key
+            matched_suffix = None
+            if isinstance(config.target_modules, str):
+                matched_suffix = config.target_modules
+            else:
+                for suffix in config.target_modules:
+                    if key.endswith(suffix):
+                        matched_suffix = suffix
+
+            if matched_suffix is None:
+                # Should not happen since inject_adapter already matched this layer
+                continue
+
+            group_key = (matched_suffix, shape)
+            if group_key not in target_to_layers:
+                target_to_layers[group_key] = []
+            target_to_layers[group_key].append(module)
+
+        # Apply A and B sharing for each (target_suffix, shape) group.
+        for (target_suffix, shape), layers in target_to_layers.items():
+            # B sharing: all layers share the first layer's B
+            shared_B = layers[0].lily_B[adapter_name]
+            for i, layer in enumerate(layers):
+                if i != 0:
+                    layer.lily_B[adapter_name] = shared_B
+
+                # A sharing: layers within the same stride_A block share the group leader's A.
+                # Group leader is the first layer in each block of stride_A consecutive layers.
+                group_idx = (i // stride_A) * stride_A
+                if i != group_idx:
+                    layer.lily_A[adapter_name] = layers[group_idx].lily_A[adapter_name]
diff --git a/src/peft/tuners/ln_tuning/__init__.py b/src/peft/tuners/ln_tuning/__init__.py
new file mode 100644
index 0000000..8f90a8f
--- /dev/null
+++ b/src/peft/tuners/ln_tuning/__init__.py
@@ -0,0 +1,23 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+from peft.utils import register_peft_method
+
+from .config import LNTuningConfig
+from .model import LNTuningModel
+
+
+__all__ = ["LNTuningConfig", "LNTuningModel"]
+
+register_peft_method(name="ln_tuning", config_cls=LNTuningConfig, model_cls=LNTuningModel)
diff --git a/src/peft/tuners/ln_tuning/config.py b/src/peft/tuners/ln_tuning/config.py
new file mode 100644
index 0000000..718417a
--- /dev/null
+++ b/src/peft/tuners/ln_tuning/config.py
@@ -0,0 +1,70 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class LNTuningConfig(PeftConfig):
+    """
+    This is the configuration class to store the configuration of a :class:`~peft.tuners.LNTuningModel`.
+
+    Args:
+        target_modules (`Optional[Union[List[str], str]]`):
+            List of module names or regex expression of the module names to replace with LNTuning. For example,
+            '.*decoder.*' or '.*encoder.*'. If this is not specified, modules will be chosen according to the model
+            architecture. If the architecture is not known, an error will be raised -- in this case, you should specify
+            the target modules manually.
+        exclude_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to not apply the adapter. When passing a string, a regex match will be performed.
+            When passing a list of strings, either an exact match will be performed or it is checked if the name of the
+            module ends with any of the passed strings.
+        modules_to_save (`Optional[Union[List[str], str]]`):
+            List of modules to be set as trainable and saved in the final checkpoint. For example, in Sequence
+            Classification or Token Classification tasks, the final layer `classifier/score` are randomly initialized
+            and as such need to be trainable and saved.
+    """
+
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of module names or regex expression of the module names to replace with LNTuning."
+                "For example, '.*decoder.*' or '.*encoder.*'. "
+                "If not specified, modules will be chosen according to the model architecture, If the architecture is "
+                "not known, an error will be raised -- in this case, you should specify the target modules manually."
+            ),
+        },
+    )
+    exclude_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={"help": "List of module names or regex expression of the module names to exclude from LNTuning."},
+    )
+    modules_to_save: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": "List of modules to be set as trainable and saved in the final checkpoint. "
+            "For example, in Sequence Classification or Token Classification tasks, "
+            "the final layer `classifier/score` are randomly initialized and as such need to be trainable and saved."
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.LN_TUNING
diff --git a/src/peft/tuners/ln_tuning/layer.py b/src/peft/tuners/ln_tuning/layer.py
new file mode 100644
index 0000000..e255370
--- /dev/null
+++ b/src/peft/tuners/ln_tuning/layer.py
@@ -0,0 +1,126 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+import warnings
+from copy import deepcopy
+from typing import Optional
+
+import torch
+from torch import nn
+
+from peft.tuners.tuners_utils import BaseTunerLayer, _get_in_out_features, check_adapters_to_merge
+
+from .config import LNTuningConfig
+
+
+class LNTuningLayer(nn.Module, BaseTunerLayer):
+    """
+    Selects a layer from the model.
+    """
+
+    adapter_layer_names = ("ln_tuning_layers",)
+
+    def __init__(self, base_layer: nn.Module, adapter_name: str, config: LNTuningConfig):
+        super().__init__()
+        self.base_layer = base_layer
+        self.ln_tuning_layers = nn.ModuleDict({})
+        self.update_layer(self.base_layer, adapter_name, config=config)
+        self._active_adapter = adapter_name
+        self.merged_adapters = []
+
+        in_features, out_features = _get_in_out_features(self.get_base_layer())
+        self.in_features = in_features
+        self.out_features = out_features
+
+    def update_layer(self, layer: nn.Module, adapter_name: str, config: LNTuningConfig, **kwargs):
+        inference_mode = config.inference_mode
+        self.ln_tuning_layers[adapter_name] = deepcopy(layer)
+        self.set_adapter(adapter_name, inference_mode=inference_mode)
+
+    def enable_adapters(self, enabled: bool) -> None:
+        """Toggle the enabling and disabling of adapters
+
+        Takes care of setting the requires_grad flag for the adapter weights.
+
+        Args:
+            enabled (bool): True to enable adapters, False to disable adapters
+        """
+        if enabled:
+            self.set_adapter(self.active_adapters)
+            self._disable_adapters = False
+        else:
+            if self.merged:
+                self.unmerge()
+            # disable grads on all adapter layers
+            for layer_name in self.adapter_layer_names:
+                layer = getattr(self, layer_name)
+                layer.requires_grad_(False)
+            self._disable_adapters = True
+
+    def merge(self, adapter_names: Optional[list[str]] = None, safe_merge: bool = False):
+        # note that there is no actual merging, so whether safe_merge is True or False is irrelevant
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        if len(adapter_names) > 1:
+            raise ValueError(
+                f"Trying to merge {len(adapter_names)} adapters, but LN "
+                f"tuning does not allow merging more than one adapter at a time"
+            )
+        merged_adapters = set(self.merged_adapters)
+        if merged_adapters:
+            warnings.warn(f"Already merged with {merged_adapters}. Unmerging first.")
+            self.unmerge()
+
+        self.base_layer, self.ln_tuning_layers[adapter_names[0]] = (
+            self.ln_tuning_layers[adapter_names[0]],
+            self.base_layer,
+        )
+        self.merged_adapters.append(adapter_names[0])
+
+    def unmerge(self):
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+        # popping one element is sufficient because LN
+        # tuning does not allow merging more than one adapter at a time.
+        merged_name = self.merged_adapters.pop()
+        self.base_layer, self.ln_tuning_layers[merged_name] = (
+            self.ln_tuning_layers[merged_name],
+            self.base_layer,
+        )
+
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged or (len(self.active_adapters) == 0):
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            if len(self.active_adapters) != 1:
+                raise ValueError(
+                    f"Trying to run forward with {len(self.active_adapters)} active "
+                    f"adapters, but LN tuning does not allow inference with more than one adapter at a time"
+                )
+            active_adapter = self.active_adapters[0]
+            result = self.ln_tuning_layers[active_adapter](x, *args, **kwargs)
+
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "ln_tuning." + rep
diff --git a/src/peft/tuners/ln_tuning/model.py b/src/peft/tuners/ln_tuning/model.py
new file mode 100644
index 0000000..b73dc5b
--- /dev/null
+++ b/src/peft/tuners/ln_tuning/model.py
@@ -0,0 +1,137 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+from typing import Optional
+
+from torch.nn.modules import Module
+from tqdm import tqdm
+
+from peft.config import PeftConfig
+from peft.tuners.tuners_utils import BaseTuner, _get_submodules
+from peft.utils import TRANSFORMERS_MODELS_TO_LNTUNING_TARGET_MODULES_MAPPING
+
+from .layer import LNTuningLayer
+
+
+class LNTuningModel(BaseTuner):
+    """
+    Creates LayerNorm tuning from a pretrained transformer model.
+
+    The method is described in detail in https://huggingface.co/papers/2312.11420.
+
+    Args:
+        model ([`torch.nn.Module`]): The model to be adapted.
+        config ([`LNTuningConfig`]): The configuration of the LN tuning model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            This option has no effect on LN tuning but exists for consistency with other PEFT methods.
+
+    Returns:
+        'torch.nn.Module': The adapted model with LayerNorm tuned on.
+
+    Example:
+
+        ```py
+        >>> from transformers import AutoModelForCausalLM
+        >>> from peft import get_peft_model, TaskType, LNTuningConfig
+
+        >>> peft_config = LNTuningConfig(
+        ...     task_type=TaskType.CAUSAL_LM,
+        ... )
+
+        >>> model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf")
+        >>> model = get_peft_model(model, peft_config)
+        >>> model.print_trainable_parameters()
+        ```
+
+    **Attributes**:
+        - **model** ([`~transformers.PreTrainedModel`]) -- The model to be adapted.
+        - **peft_config** ([`LNTuningConfig`]): The configuration of the LN tuning model.
+    """
+
+    prefix: str = "ln_tuning_"
+    tuner_layer_cls = LNTuningLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_LNTUNING_TARGET_MODULES_MAPPING
+
+    def _create_and_replace(
+        self,
+        peft_config: PeftConfig,
+        adapter_name: str,
+        target: Module,
+        target_name: str,
+        parent: Module,
+        current_key: str,
+    ) -> None:
+        # replace the original module with a same new module
+        new_module = self._create_new_module(peft_config, target, adapter_name)
+        if adapter_name != self.active_adapter:
+            new_module.requires_grad_(False)
+        self._replace_module(parent, target_name, new_module, target)
+
+    def _create_new_module(
+        self,
+        peft_config: PeftConfig,
+        target: Module,
+        adapter_name: str,
+    ) -> Module:
+        if not isinstance(target, LNTuningLayer):
+            new_module = LNTuningLayer(target, adapter_name, config=peft_config)
+        else:
+            new_module = target
+            new_module.update_layer(target.base_layer, adapter_name, config=peft_config)
+        return new_module
+
+    def _unloading_checks(self, adapter_names: Optional[list[str]]):
+        adapters_to_consider = adapter_names or self.active_adapters
+        is_modules_to_save_available = any(
+            self.peft_config[adapter].modules_to_save for adapter in adapters_to_consider
+        )
+        if is_modules_to_save_available and len(adapters_to_consider) > 1:
+            raise ValueError("Cannot unload multiple adapters that specify `modules_to_save`.")
+
+    def _unload_and_optionally_merge(
+        self,
+        merge=True,
+        progressbar: bool = False,
+        safe_merge: bool = False,
+        adapter_names: Optional[list[str]] = None,
+    ):
+        self._unloading_checks(adapter_names)
+        key_list = [key for key, _ in self.model.named_modules() if self.prefix not in key]
+        desc = "Unloading adapters " + ("and merging " if merge else "") + "model"
+
+        for key in tqdm(key_list, disable=not progressbar, desc=desc):
+            try:
+                parent, target, target_name = _get_submodules(self.model, key)
+            except AttributeError:
+                continue
+
+            if hasattr(target, "base_layer"):
+                if merge:
+                    target.merge(adapter_names)
+                self._replace_module(parent, target_name, target.get_base_layer(), target)
+
+        # Clean up peft_config from the model since all PEFT modules have been removed.
+        # This prevents spurious warnings when re-wrapping the model with get_peft_model().
+        if hasattr(self.model, "peft_config"):
+            del self.model.peft_config
+
+        return self.model
+
+    def _cast_adapter_dtype(self, adapter_name: str, autocast_adapter_dtype: bool = True) -> None:
+        # Note: LN Tuning does not add adapter layers, instead it creates copies of the original layer. For this reason,
+        # we need to skip adapter autocasting, otherwise we would change the dtype of copies of the original layer,
+        # resulting in dtype errors down the line.
+        pass
diff --git a/src/peft/tuners/loha/__init__.py b/src/peft/tuners/loha/__init__.py
new file mode 100644
index 0000000..70dd154
--- /dev/null
+++ b/src/peft/tuners/loha/__init__.py
@@ -0,0 +1,24 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from peft.utils import register_peft_method
+
+from .config import LoHaConfig
+from .layer import Conv2d, Linear, LoHaLayer
+from .model import LoHaModel
+
+
+__all__ = ["Conv2d", "Linear", "LoHaConfig", "LoHaLayer", "LoHaModel"]
+
+register_peft_method(name="loha", config_cls=LoHaConfig, model_cls=LoHaModel, prefix="hada_", is_mixed_compatible=True)
diff --git a/src/peft/tuners/loha/config.py b/src/peft/tuners/loha/config.py
new file mode 100644
index 0000000..79c1f63
--- /dev/null
+++ b/src/peft/tuners/loha/config.py
@@ -0,0 +1,143 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Optional, Union
+
+from peft.tuners.lycoris_utils import LycorisConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class LoHaConfig(LycorisConfig):
+    """
+    This is the configuration class to store the configuration of a [`LoHaModel`].
+
+    Args:
+        r (`int`):
+            LoHa rank.
+        alpha (`int`):
+            The alpha parameter for LoHa scaling.
+        rank_dropout (`float`):
+            The dropout probability for rank dimension during training.
+        module_dropout (`float`):
+            The dropout probability for disabling LoHa modules during training.
+        use_effective_conv2d (`bool`):
+            Use parameter effective decomposition for Conv2d (and Conv1d) with ksize > 1 ("Proposition 3" from FedPara
+            paper).
+        target_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to apply the adapter to. If this is specified, only the modules with the specified
+            names will be replaced. When passing a string, a regex match will be performed. When passing a list of
+            strings, either an exact match will be performed or it is checked if the name of the module ends with any
+            of the passed strings. If this is specified as 'all-linear', then all linear/Conv1D modules are chosen,
+            excluding the output layer. If this is not specified, modules will be chosen according to the model
+            architecture. If the architecture is not known, an error will be raised -- in this case, you should specify
+            the target modules manually.
+        exclude_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to not apply the adapter. When passing a string, a regex match will be performed.
+            When passing a list of strings, either an exact match will be performed or it is checked if the name of the
+            module ends with any of the passed strings.
+        init_weights (`bool`):
+            Whether to perform initialization of adapter weights. This defaults to `True`, passing `False` is
+            discouraged.
+        layers_to_transform (`Union[List[int], int]`):
+            The layer indices to transform. If a list of ints is passed, it will apply the adapter to the layer indices
+            that are specified in this list. If a single integer is passed, it will apply the transformations on the
+            layer at this index.
+        layers_pattern (`Optional[Union[List[str], str]]`):
+            The layer pattern name, used only if `layers_to_transform` is different from `None`. This should target the
+            `nn.ModuleList` of the model, which is often called `'layers'` or `'h'`.
+        rank_pattern (`dict`):
+            The mapping from layer names or regexp expression to ranks which are different from the default rank
+            specified by `r`. For example, `{'^model.decoder.layers.0.encoder_attn.k_proj': 16}`.
+        alpha_pattern (`dict`):
+            The mapping from layer names or regexp expression to alphas which are different from the default alpha
+            specified by `alpha`. For example, `{'^model.decoder.layers.0.encoder_attn.k_proj': 16}`.
+        modules_to_save (`Optional[List[str]]`):
+            List of modules apart from adapter layers to be set as trainable and saved in the final checkpoint.
+    """
+
+    r: int = field(default=8, metadata={"help": "LoHa rank"})
+    alpha: int = field(default=8, metadata={"help": "LoHa alpha"})
+    rank_dropout: float = field(
+        default=0.0, metadata={"help": "The dropout probability for rank dimension during training"}
+    )
+    module_dropout: float = field(
+        default=0.0, metadata={"help": "The dropout probability for disabling LoHa modules during training"}
+    )
+    use_effective_conv2d: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Use parameter effective decomposition for Conv2d (and Conv1d) with ksize > 1 "
+                '("Proposition 3" from FedPara paper)'
+            )
+        },
+    )
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": "List of module names or regex expression of the module names to replace with LoHa."
+            "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$' "
+            "This can also be a wildcard 'all-linear' which matches all linear/Conv1D layers except the output layer."
+        },
+    )
+    exclude_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={"help": "List of module names or regex expression of the module names to exclude from LoHa."},
+    )
+    init_weights: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "Whether to initialize the weights of the LoHa layers with their default initialization. Don't change "
+                "this setting, except if you know exactly what you're doing."
+            ),
+        },
+    )
+    layers_to_transform: Optional[Union[list[int], int]] = field(
+        default=None,
+        metadata={
+            "help": "The layer indexes to transform, is this argument is specified, PEFT will transform only the layers indexes that are specified inside this list. If a single integer is passed, PEFT will transform only the layer at this index."
+        },
+    )
+    layers_pattern: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": "The layer pattern name, used only if `layers_to_transform` is different to None and if the layer pattern is not in the common layers pattern. "
+            "This should target the `nn.ModuleList` of the model, which is often called `'layers'` or `'h'`."
+        },
+    )
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": "List of modules apart from LoHA layers to be set as trainable and saved in the final checkpoint. "
+            "For example, in Sequence Classification or Token Classification tasks, "
+            "the final layer `classifier/score` are randomly initialized and as such need to be trainable and saved."
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.LOHA
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        self.exclude_modules = (
+            set(self.exclude_modules) if isinstance(self.exclude_modules, list) else self.exclude_modules
+        )
+        # check for layers_to_transform and layers_pattern
+        if self.layers_pattern and not self.layers_to_transform:
+            raise ValueError("When `layers_pattern` is specified, `layers_to_transform` must also be specified. ")
diff --git a/src/peft/tuners/loha/layer.py b/src/peft/tuners/loha/layer.py
new file mode 100644
index 0000000..7b3a5c2
--- /dev/null
+++ b/src/peft/tuners/loha/layer.py
@@ -0,0 +1,435 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import math
+from typing import Any
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from peft.tuners.lycoris_utils import LycorisLayer
+
+from .config import LoHaConfig
+
+
+class LoHaLayer(nn.Module, LycorisLayer):
+    # All names of layers that may contain adapter weights
+    adapter_layer_names = ("hada_w1_a", "hada_w1_b", "hada_w2_a", "hada_w2_b", "hada_t1", "hada_t2")
+    # other_param_names is defined on parent class
+
+    def __init__(self, base_layer: nn.Module):
+        super().__init__()
+        LycorisLayer.__init__(self, base_layer)
+
+        # LoHa info
+        self.hada_w1_a = nn.ParameterDict({})
+        self.hada_w1_b = nn.ParameterDict({})
+        self.hada_w2_a = nn.ParameterDict({})
+        self.hada_w2_b = nn.ParameterDict({})
+        self.hada_t1 = nn.ParameterDict({})
+        self.hada_t2 = nn.ParameterDict({})
+
+    @property
+    def _available_adapters(self) -> set[str]:
+        return {*self.hada_w1_a, *self.hada_w1_b, *self.hada_w2_a, *self.hada_w2_b, *self.hada_t1, *self.hada_t2}
+
+    def create_adapter_parameters(self, adapter_name: str, r: int, shape: tuple[int, ...]):
+        # https://github.com/KohakuBlueleaf/LyCORIS/blob/eb460098187f752a5d66406d3affade6f0a07ece/lycoris/modules/loha.py#L130C9-L143C75
+        if len(shape) == 4:  # Conv2d
+            self.hada_t1[adapter_name] = nn.Parameter(torch.empty(r, r, shape[2], shape[3]))
+            self.hada_w1_a[adapter_name] = nn.Parameter(torch.empty(r, shape[0]))  # out_dim, 1-mode
+            self.hada_w1_b[adapter_name] = nn.Parameter(torch.empty(r, shape[1]))  # in_dim , 2-mode
+
+            self.hada_t2[adapter_name] = nn.Parameter(torch.empty(r, r, shape[2], shape[3]))
+            self.hada_w2_a[adapter_name] = nn.Parameter(torch.empty(r, shape[0]))  # out_dim, 1-mode
+            self.hada_w2_b[adapter_name] = nn.Parameter(torch.empty(r, shape[1]))  # in_dim , 2-mode
+        elif len(shape) == 3:  # Conv1d
+            self.hada_t1[adapter_name] = nn.Parameter(torch.empty(r, r, shape[2], 1))
+            self.hada_w1_a[adapter_name] = nn.Parameter(torch.empty(r, shape[0]))  # out_dim, 1-mode
+            self.hada_w1_b[adapter_name] = nn.Parameter(torch.empty(r, shape[1]))  # in_dim , 2-mode
+
+            self.hada_t2[adapter_name] = nn.Parameter(torch.empty(r, r, shape[2], 1))
+            self.hada_w2_a[adapter_name] = nn.Parameter(torch.empty(r, shape[0]))  # out_dim, 1-mode
+            self.hada_w2_b[adapter_name] = nn.Parameter(torch.empty(r, shape[1]))  # in_dim , 2-mode
+        else:  # Linear
+            self.hada_w1_a[adapter_name] = nn.Parameter(torch.empty(shape[0], r))
+            self.hada_w1_b[adapter_name] = nn.Parameter(torch.empty(r, shape[1]))
+
+            self.hada_w2_a[adapter_name] = nn.Parameter(torch.empty(shape[0], r))
+            self.hada_w2_b[adapter_name] = nn.Parameter(torch.empty(r, shape[1]))
+
+    def reset_adapter_parameters(self, adapter_name: str):
+        # Original implementation performs initialization with normal distribution
+        # https://github.com/KohakuBlueleaf/LyCORIS/blob/3549fdef8f564761d68b695a08ef88b1122fdedc/lycoris/modules/loha.py#L158
+
+        # FedPara paper proposes to perform He initialization, let's stick with it
+        # It is enough to initialize only single matrix with zeros to make adapter do nothing after initialization
+        if adapter_name in self.hada_w1_a.keys():
+            nn.init.kaiming_uniform_(self.hada_w1_a[adapter_name], a=math.sqrt(5))
+            nn.init.kaiming_uniform_(self.hada_w1_b[adapter_name], a=math.sqrt(5))
+            nn.init.kaiming_uniform_(self.hada_w2_a[adapter_name], a=math.sqrt(5))
+            nn.init.zeros_(self.hada_w2_b[adapter_name])
+        if adapter_name in self.hada_t1.keys():
+            nn.init.kaiming_uniform_(self.hada_t1[adapter_name], a=math.sqrt(5))
+            nn.init.kaiming_uniform_(self.hada_t2[adapter_name], a=math.sqrt(5))
+
+    def reset_adapter_parameters_random(self, adapter_name: str):
+        # Original implementation performs initialization with normal distribution
+        # https://github.com/KohakuBlueleaf/LyCORIS/blob/3549fdef8f564761d68b695a08ef88b1122fdedc/lycoris/modules/loha.py#L158
+
+        # FedPara paper proposes to perform He initialization, let's stick with it
+        # It is enough to initialize only single matrix with zeros to make adapter do nothing after initialization
+        if adapter_name in self.hada_w1_a.keys():
+            nn.init.kaiming_uniform_(self.hada_w1_a[adapter_name], a=math.sqrt(5))
+            nn.init.kaiming_uniform_(self.hada_w1_b[adapter_name], a=math.sqrt(5))
+            nn.init.kaiming_uniform_(self.hada_w2_a[adapter_name], a=math.sqrt(5))
+            nn.init.kaiming_uniform_(self.hada_w2_b[adapter_name], a=math.sqrt(5))
+        if adapter_name in self.hada_t1.keys():
+            nn.init.kaiming_uniform_(self.hada_t1[adapter_name], a=math.sqrt(5))
+            nn.init.kaiming_uniform_(self.hada_t2[adapter_name], a=math.sqrt(5))
+
+    def update_layer(
+        self,
+        adapter_name: str,
+        r: int,
+        alpha: float,
+        config: LoHaConfig,
+        **kwargs,
+    ) -> None:
+        """Internal function to create loha adapter
+
+        Args:
+            adapter_name (`str`): Name for the adapter to add.
+            r (`int`): Rank for the added adapter.
+            alpha (`float`): Alpha for the added adapter.
+            config (`LoHaConfig`): The adapter configuration for this layer.
+        """
+        rank_dropout = config.rank_dropout
+        module_dropout = config.module_dropout
+        init_weights = config.init_weights
+        use_effective_conv2d = config.use_effective_conv2d
+        inference_mode = config.inference_mode
+
+        if r <= 0:
+            raise ValueError(f"`r` should be a positive integer value but the value passed is {r}")
+
+        self.r[adapter_name] = r
+        self.alpha[adapter_name] = alpha
+        self.scaling[adapter_name] = alpha / r
+        self.rank_dropout[adapter_name] = rank_dropout
+        self.module_dropout[adapter_name] = module_dropout
+
+        # Determine shape of LoHa weights
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            shape = tuple(base_layer.weight.shape)
+        elif isinstance(base_layer, nn.Conv2d):
+            # For 1x1 convolutions, disable effective_conv2d to avoid unnecessary tensor reshaping overhead.
+            # Since 1x1 convolutions are essentially pointwise operations (matrix multiplications),
+            # they can be more efficiently handled with the flattened weight representation,
+            # similar to how Linear layers work. This optimization reduces computational cost
+            # without affecting the mathematical equivalence of the operation.
+            use_effective_conv2d = use_effective_conv2d and base_layer.kernel_size != (1, 1)
+            if use_effective_conv2d:
+                shape = (base_layer.out_channels, base_layer.in_channels, *base_layer.kernel_size)
+            else:
+                shape = (
+                    base_layer.out_channels,
+                    base_layer.in_channels * base_layer.kernel_size[0] * base_layer.kernel_size[1],
+                )
+        elif isinstance(base_layer, nn.Conv1d):
+            # For Conv1d with kernel_size=1, disable effective_conv2d for the same optimization reasons
+            # as 1x1 Conv2d. Kernel size 1 means no spatial/temporal context, making it equivalent
+            # to a Linear layer applied across the channel dimension. Using flattened representation
+            # avoids unnecessary reshaping and improves computational efficiency.
+            use_effective_conv2d = use_effective_conv2d and base_layer.kernel_size[0] != 1
+            if use_effective_conv2d:
+                shape = (base_layer.out_channels, base_layer.in_channels, base_layer.kernel_size[0])
+            else:
+                shape = (
+                    base_layer.out_channels,
+                    base_layer.in_channels * base_layer.kernel_size[0],
+                )
+        else:
+            raise TypeError(f"LoHa is not implemented for base layers of type {type(base_layer).__name__}")
+
+        # Create weights with provided shape
+        self.create_adapter_parameters(adapter_name, r, shape)
+
+        # Initialize weights
+        if init_weights:
+            self.reset_adapter_parameters(adapter_name)
+        else:
+            self.reset_adapter_parameters_random(adapter_name)
+
+        # Move new weights to device
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def get_delta_weight(self, adapter_name: str) -> torch.Tensor:
+        # https://github.com/KohakuBlueleaf/LyCORIS/blob/eb460098187f752a5d66406d3affade6f0a07ece/lycoris/modules/loha.py#L178
+        if adapter_name in self.hada_t1.keys():
+            weight = make_weight_cp(
+                self.hada_t1[adapter_name],
+                self.hada_w1_a[adapter_name],
+                self.hada_w1_b[adapter_name],
+                self.hada_t2[adapter_name],
+                self.hada_w2_a[adapter_name],
+                self.hada_w2_b[adapter_name],
+                scale=torch.tensor(self.scaling[adapter_name]),
+            )
+        else:
+            weight = make_weight(
+                self.hada_w1_a[adapter_name],
+                self.hada_w1_b[adapter_name],
+                self.hada_w2_a[adapter_name],
+                self.hada_w2_b[adapter_name],
+                scale=torch.tensor(self.scaling[adapter_name]),
+            )
+
+        base_layer = self.get_base_layer()
+
+        # Reshape to match base layer shape
+        weight = weight.reshape(base_layer.weight.shape)
+
+        # Perform rank dropout during training - drop rows of addition weights
+        rank_dropout = self.rank_dropout[adapter_name]
+        if self.training and rank_dropout:
+            drop = (torch.rand(weight.size(0)) > rank_dropout).to(weight.dtype)
+            drop = drop.view(-1, *[1] * len(weight.shape[1:])).to(weight.device)
+            # TODO: Investigate if there should be a scaler like in normal dropout during training
+            # Original implementation doesn't have it
+            # https://github.com/KohakuBlueleaf/LyCORIS/blob/eb460098187f752a5d66406d3affade6f0a07ece/lycoris/modules/loha.py#L193
+            drop /= drop.mean()
+            weight *= drop
+
+        return weight
+
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        previous_dtype = x.dtype
+
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+
+            # Execute all the adapters
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self._available_adapters:
+                    continue
+
+                module_dropout = self.module_dropout[active_adapter]
+
+                # Modify current execution weights
+                if (not self.training) or (self.training and torch.rand(1) > module_dropout):
+                    result = result + self._get_delta_activations(active_adapter, x, *args, **kwargs)
+
+        result = result.to(previous_dtype)
+        return result
+
+
+class Linear(LoHaLayer):
+    """LoHa implemented in Linear layer"""
+
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        adapter_name: str,
+        config: LoHaConfig,
+        r: int = 0,
+        alpha: float = 0.0,
+        **kwargs,
+    ):
+        super().__init__(base_layer)
+
+        # Create adapter and set it active
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, alpha, config=config, **kwargs)
+
+    def _get_delta_activations(
+        self, adapter_name: str, input: torch.Tensor, *args: Any, **kwargs: Any
+    ) -> torch.Tensor:
+        delta_weight = self.get_delta_weight(adapter_name)
+        input = self._cast_input_dtype(input, delta_weight.dtype)
+        # don't add bias here, because the bias is already included in the output of the base_layer
+        return F.linear(input, delta_weight)
+
+    def supports_lora_conversion(self, adapter_name: str = "default") -> bool:
+        return True
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "loha." + rep
+
+
+class Conv2d(LoHaLayer):
+    """LoHa implemented in Conv2d layer"""
+
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        adapter_name: str,
+        config: LoHaConfig,
+        r: int = 0,
+        alpha: float = 0.0,
+        **kwargs,
+    ):
+        super().__init__(base_layer)
+
+        # Create adapter and set it active
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, alpha, config=config, **kwargs)
+
+    def _get_delta_activations(
+        self, adapter_name: str, input: torch.Tensor, *args: Any, **kwargs: Any
+    ) -> torch.Tensor:
+        delta_weight = self.get_delta_weight(adapter_name)
+        input = self._cast_input_dtype(input, delta_weight.dtype)
+        # don't add bias here, because the bias is already included in the output of the base_layer
+        base_layer = self.get_base_layer()
+        return F.conv2d(
+            input,
+            delta_weight,
+            stride=base_layer.stride,
+            padding=base_layer.padding,
+            dilation=base_layer.dilation,
+            groups=base_layer.groups,
+        )
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "loha." + rep
+
+
+class Conv1d(LoHaLayer):
+    """LoHa implemented in Conv1d layer"""
+
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        adapter_name: str,
+        config: LoHaConfig,
+        r: int = 0,
+        alpha: float = 0.0,
+        **kwargs,
+    ):
+        super().__init__(base_layer)
+
+        # Create adapter and set it active
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, alpha, config=config, **kwargs)
+
+    def _get_delta_activations(
+        self, adapter_name: str, input: torch.Tensor, *args: Any, **kwargs: Any
+    ) -> torch.Tensor:
+        delta_weight = self.get_delta_weight(adapter_name)
+        input = self._cast_input_dtype(input, delta_weight.dtype)
+        # don't add bias here, because the bias is already included in the output of the base_layer
+        base_layer = self.get_base_layer()
+        return F.conv1d(
+            input,
+            delta_weight,
+            stride=base_layer.stride,
+            padding=base_layer.padding,
+            dilation=base_layer.dilation,
+            groups=base_layer.groups,
+        )
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "loha." + rep
+
+
+# Below code is a direct copy from https://github.com/KohakuBlueleaf/LyCORIS/blob/eb460098187f752a5d66406d3affade6f0a07ece/lycoris/modules/loha.py#L9
+
+
+class HadaWeight(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, w1a, w1b, w2a, w2b, scale=torch.tensor(1)):  # noqa: B008
+        ctx.save_for_backward(w1a, w1b, w2a, w2b, scale)
+        diff_weight = ((w1a @ w1b) * (w2a @ w2b)) * scale
+        return diff_weight
+
+    @staticmethod
+    def backward(ctx, grad_out):
+        (w1a, w1b, w2a, w2b, scale) = ctx.saved_tensors
+        grad_out = grad_out * scale
+        temp = grad_out * (w2a @ w2b)
+        grad_w1a = temp @ w1b.T
+        grad_w1b = w1a.T @ temp
+
+        temp = grad_out * (w1a @ w1b)
+        grad_w2a = temp @ w2b.T
+        grad_w2b = w2a.T @ temp
+
+        del temp
+        return grad_w1a, grad_w1b, grad_w2a, grad_w2b, None
+
+
+class HadaWeightCP(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, t1, w1a, w1b, t2, w2a, w2b, scale=torch.tensor(1)):  # noqa: B008
+        ctx.save_for_backward(t1, w1a, w1b, t2, w2a, w2b, scale)
+
+        rebuild1 = torch.einsum("i j k l, j r, i p -> p r k l", t1, w1b, w1a)
+        rebuild2 = torch.einsum("i j k l, j r, i p -> p r k l", t2, w2b, w2a)
+
+        return rebuild1 * rebuild2 * scale
+
+    @staticmethod
+    def backward(ctx, grad_out):
+        (t1, w1a, w1b, t2, w2a, w2b, scale) = ctx.saved_tensors
+        grad_out = grad_out * scale
+
+        temp = torch.einsum("i j k l, j r -> i r k l", t2, w2b)
+        rebuild = torch.einsum("i j k l, i r -> r j k l", temp, w2a)
+
+        grad_w = rebuild * grad_out
+        del rebuild
+
+        grad_w1a = torch.einsum("r j k l, i j k l -> r i", temp, grad_w)
+        grad_temp = torch.einsum("i j k l, i r -> r j k l", grad_w, w1a.T)
+        del grad_w, temp
+
+        grad_w1b = torch.einsum("i r k l, i j k l -> r j", t1, grad_temp)
+        grad_t1 = torch.einsum("i j k l, j r -> i r k l", grad_temp, w1b.T)
+        del grad_temp
+
+        temp = torch.einsum("i j k l, j r -> i r k l", t1, w1b)
+        rebuild = torch.einsum("i j k l, i r -> r j k l", temp, w1a)
+
+        grad_w = rebuild * grad_out
+        del rebuild
+
+        grad_w2a = torch.einsum("r j k l, i j k l -> r i", temp, grad_w)
+        grad_temp = torch.einsum("i j k l, i r -> r j k l", grad_w, w2a.T)
+        del grad_w, temp
+
+        grad_w2b = torch.einsum("i r k l, i j k l -> r j", t2, grad_temp)
+        grad_t2 = torch.einsum("i j k l, j r -> i r k l", grad_temp, w2b.T)
+        del grad_temp
+        return grad_t1, grad_w1a, grad_w1b, grad_t2, grad_w2a, grad_w2b, None
+
+
+def make_weight(w1a, w1b, w2a, w2b, scale):
+    return HadaWeight.apply(w1a, w1b, w2a, w2b, scale)
+
+
+def make_weight_cp(t1, w1a, w1b, t2, w2a, w2b, scale):
+    return HadaWeightCP.apply(t1, w1a, w1b, t2, w2a, w2b, scale)
diff --git a/src/peft/tuners/loha/model.py b/src/peft/tuners/loha/model.py
new file mode 100644
index 0000000..0efd7c4
--- /dev/null
+++ b/src/peft/tuners/loha/model.py
@@ -0,0 +1,117 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from typing import Union
+
+import torch
+from torch import nn
+
+from peft.tuners.lycoris_utils import LycorisConfig, LycorisTuner
+from peft.utils import TRANSFORMERS_MODELS_TO_LOHA_TARGET_MODULES_MAPPING
+from peft.utils.other import get_pattern_key
+
+from .layer import Conv1d, Conv2d, Linear, LoHaLayer
+
+
+class LoHaModel(LycorisTuner):
+    """
+    Creates Low-Rank Hadamard Product model from a pretrained model. The method is partially described in
+    https://huggingface.co/papers/2108.06098 Current implementation heavily borrows from
+    https://github.com/KohakuBlueleaf/LyCORIS/blob/eb460098187f752a5d66406d3affade6f0a07ece/lycoris/modules/loha.py
+
+    Args:
+        model (`torch.nn.Module`): The model to which the adapter tuner layers will be attached.
+        config ([`LoHaConfig`]): The configuration of the LoHa model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            Create empty adapter weights on meta device. Useful to speed up the loading process.
+
+    Returns:
+        `torch.nn.Module`: The LoHa model.
+
+    Example:
+        ```py
+        >>> from diffusers import StableDiffusionPipeline
+        >>> from peft import LoHaModel, LoHaConfig
+
+        >>> config_te = LoHaConfig(
+        ...     r=8,
+        ...     lora_alpha=32,
+        ...     target_modules=["k_proj", "q_proj", "v_proj", "out_proj", "fc1", "fc2"],
+        ...     rank_dropout=0.0,
+        ...     module_dropout=0.0,
+        ...     init_weights=True,
+        ... )
+        >>> config_unet = LoHaConfig(
+        ...     r=8,
+        ...     lora_alpha=32,
+        ...     target_modules=[
+        ...         "proj_in",
+        ...         "proj_out",
+        ...         "to_k",
+        ...         "to_q",
+        ...         "to_v",
+        ...         "to_out.0",
+        ...         "ff.net.0.proj",
+        ...         "ff.net.2",
+        ...     ],
+        ...     rank_dropout=0.0,
+        ...     module_dropout=0.0,
+        ...     init_weights=True,
+        ...     use_effective_conv2d=True,
+        ... )
+
+        >>> model = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
+        >>> model.text_encoder = LoHaModel(model.text_encoder, config_te, "default")
+        >>> model.unet = LoHaModel(model.unet, config_unet, "default")
+        ```
+
+    **Attributes**:
+        - **model** ([`~torch.nn.Module`]) -- The model to be adapted.
+        - **peft_config** ([`LoHaConfig`]): The configuration of the LoHa model.
+    """
+
+    prefix: str = "hada_"
+    tuner_layer_cls = LoHaLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_LOHA_TARGET_MODULES_MAPPING
+    layers_mapping: dict[type[torch.nn.Module], type[LoHaLayer]] = {
+        torch.nn.Conv2d: Conv2d,
+        torch.nn.Conv1d: Conv1d,
+        torch.nn.Linear: Linear,
+    }
+
+    def _create_and_replace(
+        self,
+        config: LycorisConfig,
+        adapter_name: str,
+        target: Union[LoHaLayer, nn.Module],
+        target_name: str,
+        parent: nn.Module,
+        current_key: str,
+    ) -> None:
+        """
+        A private method to create and replace the target module with the adapter module.
+        """
+        r_key = get_pattern_key(config.rank_pattern.keys(), current_key)
+        alpha_key = get_pattern_key(config.alpha_pattern.keys(), current_key)
+        kwargs = {
+            "r": config.rank_pattern.get(r_key, config.r),
+            "alpha": config.alpha_pattern.get(alpha_key, config.alpha),
+        }
+
+        if isinstance(target, LoHaLayer):
+            target.update_layer(adapter_name, config=config, **kwargs)
+        else:
+            new_module = self._create_new_module(config, adapter_name, target, **kwargs)
+            self._replace_module(parent, target_name, new_module, target)
diff --git a/src/peft/tuners/lokr/__init__.py b/src/peft/tuners/lokr/__init__.py
new file mode 100644
index 0000000..f4fe0e9
--- /dev/null
+++ b/src/peft/tuners/lokr/__init__.py
@@ -0,0 +1,24 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from peft.utils import register_peft_method
+
+from .config import LoKrConfig
+from .layer import Conv2d, Linear, LoKrLayer
+from .model import LoKrModel
+
+
+__all__ = ["Conv2d", "Linear", "LoKrConfig", "LoKrLayer", "LoKrModel"]
+
+register_peft_method(name="lokr", config_cls=LoKrConfig, model_cls=LoKrModel, is_mixed_compatible=True)
diff --git a/src/peft/tuners/lokr/config.py b/src/peft/tuners/lokr/config.py
new file mode 100644
index 0000000..6d25dc5
--- /dev/null
+++ b/src/peft/tuners/lokr/config.py
@@ -0,0 +1,155 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal, Optional, Union
+
+from peft.tuners.lycoris_utils import LycorisConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class LoKrConfig(LycorisConfig):
+    """
+    Configuration class of [`LoKrModel`].
+
+    Args:
+        r (`int`):
+            LoKr rank.
+        alpha (`int`):
+            The alpha parameter for LoKr scaling.
+        rank_dropout (`float`):
+            The dropout probability for rank dimension during training.
+        module_dropout (`float`):
+            The dropout probability for disabling LoKr modules during training.
+        use_effective_conv2d (`bool`):
+            Use parameter effective decomposition for Conv2d (and Conv1d) with ksize > 1 ("Proposition 3" from FedPara
+            paper).
+        decompose_both (`bool`):
+            Perform rank decomposition of left kronecker product matrix.
+        decompose_factor (`int`):
+            Kronecker product decomposition factor.
+        rank_dropout_scale ('bool)
+            Whether to scale the rank dropout while training, defaults to `False`.
+        target_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to apply the adapter to. If this is specified, only the modules with the specified
+            names will be replaced. When passing a string, a regex match will be performed. When passing a list of
+            strings, either an exact match will be performed or it is checked if the name of the module ends with any
+            of the passed strings. If this is specified as 'all-linear', then all linear/Conv1D modules are chosen,
+            excluding the output layer. If this is not specified, modules will be chosen according to the model
+            architecture. If the architecture is not known, an error will be raised -- in this case, you should specify
+            the target modules manually.
+        exclude_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to not apply the adapter. When passing a string, a regex match will be performed.
+            When passing a list of strings, either an exact match will be performed or it is checked if the name of the
+            module ends with any of the passed strings.
+        init_weights (`bool`):
+            Whether to perform initialization of adapter weights. This defaults to `True`. Use "lycoris" to initialize
+            weights in the style of the LYCORIS repository. Passing `False` is discouraged.
+        layers_to_transform (`Union[List[int], int]`):
+            The layer indices to transform. If a list of ints is passed, it will apply the adapter to the layer indices
+            that are specified in this list. If a single integer is passed, it will apply the transformations on the
+            layer at this index.
+        layers_pattern (`Optional[Union[List[str], str]]`):
+            The layer pattern name, used only if `layers_to_transform` is different from `None`. This should target the
+            `nn.ModuleList` of the model, which is often called `'layers'` or `'h'`.
+        rank_pattern (`dict`):
+            The mapping from layer names or regexp expression to ranks which are different from the default rank
+            specified by `r`. For example, `{'^model.decoder.layers.0.encoder_attn.k_proj': 16}`.
+        alpha_pattern (`dict`):
+            The mapping from layer names or regexp expression to alphas which are different from the default alpha
+            specified by `alpha`. For example, `{'^model.decoder.layers.0.encoder_attn.k_proj': 16}`.
+        modules_to_save (`Optional[List[str]]`):
+            List of modules apart from adapter layers to be set as trainable and saved in the final checkpoint.
+    """
+
+    r: int = field(default=8, metadata={"help": "LoKr rank"})
+    alpha: int = field(default=8, metadata={"help": "LoKr alpha"})
+    rank_dropout: float = field(
+        default=0.0, metadata={"help": "The dropout probability for rank dimension during training"}
+    )
+    module_dropout: float = field(
+        default=0.0, metadata={"help": "The dropout probability for disabling LoKr modules during training"}
+    )
+    use_effective_conv2d: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Use parameter effective decomposition for Conv2d (and Conv1d) with ksize > 1 "
+                '("Proposition 3" from FedPara paper)'
+            )
+        },
+    )
+    decompose_both: bool = field(
+        default=False,
+        metadata={"help": "Perform rank decomposition of left kronecker product matrix."},
+    )
+    decompose_factor: int = field(default=-1, metadata={"help": "Kronecker product decomposition factor."})
+    rank_dropout_scale: bool = field(default=False, metadata={"help": "Rank dropout scale"})
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": "List of module names or regex expression of the module names to replace with LoKr."
+            "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$' "
+            "This can also be a wildcard 'all-linear' which matches all linear/Conv1D layers except the output layer."
+        },
+    )
+    exclude_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={"help": "List of module names or regex expression of the module names to exclude from LoKr."},
+    )
+    init_weights: Union[bool, Literal["lycoris"]] = field(
+        default=True,
+        metadata={
+            "help": (
+                "Whether to initialize the weights of the LoKr layers with their default initialization. Can be True, False or 'lycoris'."
+                "Default is True. Don't change this setting to False, except if you know exactly what you're doing."
+            ),
+        },
+    )
+    layers_to_transform: Optional[Union[list[int], int]] = field(
+        default=None,
+        metadata={
+            "help": "The layer indexes to transform, is this argument is specified, PEFT will transform only the layers indexes that are specified inside this list. If a single integer is passed, PEFT will transform only the layer at this index."
+        },
+    )
+    layers_pattern: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": "The layer pattern name, used only if `layers_to_transform` is different to None and if the layer pattern is not in the common layers pattern. "
+            "This should target the `nn.ModuleList` of the model, which is often called `'layers'` or `'h'`."
+        },
+    )
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": "List of modules apart from LoKr layers to be set as trainable and saved in the final checkpoint. "
+            "For example, in Sequence Classification or Token Classification tasks, "
+            "the final layer `classifier/score` are randomly initialized and as such need to be trainable and saved."
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.LOKR
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        self.exclude_modules = (
+            set(self.exclude_modules) if isinstance(self.exclude_modules, list) else self.exclude_modules
+        )
+        # check for layers_to_transform and layers_pattern
+        if self.layers_pattern and not self.layers_to_transform:
+            raise ValueError("When `layers_pattern` is specified, `layers_to_transform` must also be specified. ")
diff --git a/src/peft/tuners/lokr/layer.py b/src/peft/tuners/lokr/layer.py
new file mode 100644
index 0000000..ecc2696
--- /dev/null
+++ b/src/peft/tuners/lokr/layer.py
@@ -0,0 +1,501 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import math
+from typing import Any, Optional, Union
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from peft.tuners.lycoris_utils import LycorisLayer
+
+from .config import LoKrConfig
+
+
+class LoKrLayer(nn.Module, LycorisLayer):
+    # All names of layers that may contain adapter weights
+    adapter_layer_names = (
+        "lokr_w1",
+        "lokr_w1_a",
+        "lokr_w1_b",
+        "lokr_w2",
+        "lokr_w2_a",
+        "lokr_w2_b",
+        "lokr_t2",
+    )
+    # other_param_names is defined on parent class
+
+    def __init__(self, base_layer: nn.Module) -> None:
+        super().__init__()
+        LycorisLayer.__init__(self, base_layer)
+
+        # LoKr info
+        self.lokr_w1 = nn.ParameterDict({})
+        self.lokr_w1_a = nn.ParameterDict({})
+        self.lokr_w1_b = nn.ParameterDict({})
+        self.lokr_w2 = nn.ParameterDict({})
+        self.lokr_w2_a = nn.ParameterDict({})
+        self.lokr_w2_b = nn.ParameterDict({})
+        self.lokr_t2 = nn.ParameterDict({})
+
+    @property
+    def _available_adapters(self) -> set[str]:
+        return {
+            *self.lokr_w1,
+            *self.lokr_w1_a,
+            *self.lokr_w1_b,
+            *self.lokr_w2,
+            *self.lokr_w2_a,
+            *self.lokr_w2_b,
+            *self.lokr_t2,
+        }
+
+    def create_adapter_parameters(
+        self,
+        adapter_name: str,
+        r: int,
+        shape,
+        use_w1: bool,
+        use_w2: bool,
+        use_effective_conv2d: bool,
+    ):
+        if use_w1:
+            self.lokr_w1[adapter_name] = nn.Parameter(torch.empty(shape[0][0], shape[1][0]))
+        else:
+            self.lokr_w1_a[adapter_name] = nn.Parameter(torch.empty(shape[0][0], r))
+            self.lokr_w1_b[adapter_name] = nn.Parameter(torch.empty(r, shape[1][0]))
+
+        # Handle both Conv2d and Conv1d
+        if len(shape) == 4:  # Conv2d
+            if use_w2:
+                self.lokr_w2[adapter_name] = nn.Parameter(torch.empty(shape[0][1], shape[1][1], *shape[2:]))
+            elif use_effective_conv2d:
+                self.lokr_t2[adapter_name] = nn.Parameter(torch.empty(r, r, shape[2], shape[3]))
+                self.lokr_w2_a[adapter_name] = nn.Parameter(torch.empty(r, shape[0][1]))  # b, 1-mode
+                self.lokr_w2_b[adapter_name] = nn.Parameter(torch.empty(r, shape[1][1]))  # d, 2-mode
+            else:
+                self.lokr_w2_a[adapter_name] = nn.Parameter(torch.empty(shape[0][1], r))
+                self.lokr_w2_b[adapter_name] = nn.Parameter(torch.empty(r, shape[1][1] * shape[2] * shape[3]))
+        elif len(shape) == 3:  # Conv1d
+            if use_w2:
+                self.lokr_w2[adapter_name] = nn.Parameter(torch.empty(shape[0][1], shape[1][1], shape[2]))
+            elif use_effective_conv2d:  # Even for Conv1d, use the effective parameter for kernel dimension
+                # We pass (r, r, kernel_size, 1) in order to be compatible with the 2d assumptions made
+                # in make_weight_cp (only relevant for the effective conv2d case).
+                self.lokr_t2[adapter_name] = nn.Parameter(torch.empty(r, r, shape[2], 1))
+                self.lokr_w2_a[adapter_name] = nn.Parameter(torch.empty(r, shape[0][1]))  # b, 1-mode
+                self.lokr_w2_b[adapter_name] = nn.Parameter(torch.empty(r, shape[1][1]))  # d, 2-mode
+            else:
+                self.lokr_w2_a[adapter_name] = nn.Parameter(torch.empty(shape[0][1], r))
+                self.lokr_w2_b[adapter_name] = nn.Parameter(torch.empty(r, shape[1][1] * shape[2]))
+        else:
+            # Linear
+            if use_w2:
+                self.lokr_w2[adapter_name] = nn.Parameter(torch.empty(shape[0][1], shape[1][1]))
+            else:
+                self.lokr_w2_a[adapter_name] = nn.Parameter(torch.empty(shape[0][1], r))
+                self.lokr_w2_b[adapter_name] = nn.Parameter(torch.empty(r, shape[1][1]))
+
+    def reset_adapter_parameters(self, adapter_name: str):
+        if adapter_name in self.lokr_w1:
+            nn.init.zeros_(self.lokr_w1[adapter_name])
+        else:
+            nn.init.zeros_(self.lokr_w1_a[adapter_name])
+            nn.init.kaiming_uniform_(self.lokr_w1_b[adapter_name], a=math.sqrt(5))
+
+        if adapter_name in self.lokr_w2:
+            nn.init.kaiming_uniform_(self.lokr_w2[adapter_name], a=math.sqrt(5))
+        else:
+            nn.init.kaiming_uniform_(self.lokr_w2_a[adapter_name], a=math.sqrt(5))
+            nn.init.kaiming_uniform_(self.lokr_w2_b[adapter_name], a=math.sqrt(5))
+
+        if adapter_name in self.lokr_t2:
+            nn.init.kaiming_uniform_(self.lokr_t2[adapter_name], a=math.sqrt(5))
+
+    def reset_adapter_parameters_random(self, adapter_name: str):
+        if adapter_name in self.lokr_w1:
+            nn.init.kaiming_uniform_(self.lokr_w1[adapter_name], a=math.sqrt(5))
+        else:
+            nn.init.kaiming_uniform_(self.lokr_w1_a[adapter_name], a=math.sqrt(5))
+            nn.init.kaiming_uniform_(self.lokr_w1_b[adapter_name], a=math.sqrt(5))
+
+        if adapter_name in self.lokr_w2:
+            nn.init.kaiming_uniform_(self.lokr_w2[adapter_name], a=math.sqrt(5))
+        else:
+            nn.init.kaiming_uniform_(self.lokr_w2_a[adapter_name], a=math.sqrt(5))
+            nn.init.kaiming_uniform_(self.lokr_w2_b[adapter_name], a=math.sqrt(5))
+
+        if adapter_name in self.lokr_t2:
+            nn.init.kaiming_uniform_(self.lokr_t2[adapter_name], a=math.sqrt(5))
+
+    # Initializes weight matrices similar to the way initialized in the LyCORIS repository.
+    def reset_adapter_parameters_lycoris_way(self, adapter_name):
+        if adapter_name in self.lokr_w1:
+            nn.init.kaiming_uniform_(self.lokr_w1[adapter_name], a=math.sqrt(5))
+        else:
+            nn.init.kaiming_uniform_(self.lokr_w1_a[adapter_name], a=math.sqrt(5))
+            nn.init.kaiming_uniform_(self.lokr_w1_b[adapter_name], a=math.sqrt(5))
+
+        if adapter_name in self.lokr_w2:
+            nn.init.zeros_(self.lokr_w2[adapter_name])
+        else:
+            nn.init.zeros_(self.lokr_w2_b[adapter_name])
+            nn.init.kaiming_uniform_(self.lokr_w2_a[adapter_name], a=math.sqrt(5))
+
+        if adapter_name in self.lokr_t2:
+            nn.init.kaiming_uniform_(self.lokr_t2[adapter_name], a=math.sqrt(5))
+
+    def update_layer(
+        self,
+        adapter_name: str,
+        r: int,
+        alpha: float,
+        config: LoKrConfig,
+        **kwargs,
+    ) -> None:
+        """Internal function to create lokr adapter
+
+        Args:
+            adapter_name (`str`): Name for the adapter to add.
+            r (`int`): Rank for the added adapter.
+            alpha (`float`): Alpha for the added adapter.
+            config (`LoKrConfig`): The adapter configuration for this layer.
+        """
+        rank_dropout = config.rank_dropout
+        module_dropout = config.module_dropout
+        init_weights = config.init_weights
+        use_effective_conv2d = config.use_effective_conv2d
+        decompose_both = config.decompose_both
+        decompose_factor = config.decompose_factor
+        inference_mode = config.inference_mode
+
+        if r <= 0:
+            raise ValueError(f"`r` should be a positive integer value but the value passed is {r}")
+
+        self.r[adapter_name] = r
+        self.alpha[adapter_name] = alpha
+        self.scaling[adapter_name] = alpha / r
+        self.rank_dropout[adapter_name] = rank_dropout
+        self.module_dropout[adapter_name] = module_dropout
+        self.rank_dropout_scale[adapter_name] = config.rank_dropout_scale
+        base_layer = self.get_base_layer()
+
+        # Determine shape of LoKr weights
+        if isinstance(base_layer, nn.Linear):
+            in_dim, out_dim = base_layer.in_features, base_layer.out_features
+
+            in_m, in_n = factorization(in_dim, decompose_factor)
+            out_l, out_k = factorization(out_dim, decompose_factor)
+            shape = ((out_l, out_k), (in_m, in_n))  # ((a, b), (c, d)), out_dim = a*c, in_dim = b*d
+
+            use_w1 = not (decompose_both and r < max(shape[0][0], shape[1][0]) / 2)
+            use_w2 = not (r < max(shape[0][1], shape[1][1]) / 2)
+            use_effective_conv2d = False
+        elif isinstance(base_layer, nn.Conv2d):
+            in_dim, out_dim = base_layer.in_channels, base_layer.out_channels
+            k_size = base_layer.kernel_size
+
+            in_m, in_n = factorization(in_dim, decompose_factor)
+            out_l, out_k = factorization(out_dim, decompose_factor)
+            shape = ((out_l, out_k), (in_m, in_n), *k_size)  # ((a, b), (c, d), *k_size)
+
+            use_w1 = not (decompose_both and r < max(shape[0][0], shape[1][0]) / 2)
+            use_w2 = r >= max(shape[0][1], shape[1][1]) / 2
+            # For 1x1 convolutions, disable effective_conv2d to avoid unnecessary tensor reshaping overhead.
+            # Since 1x1 convolutions are essentially pointwise operations (matrix multiplications),
+            # they can be more efficiently handled with the flattened weight representation,
+            # similar to how Linear layers work. This optimization reduces computational cost
+            # without affecting the mathematical equivalence of the operation.
+            use_effective_conv2d = use_effective_conv2d and base_layer.kernel_size != (1, 1)
+        elif isinstance(base_layer, nn.Conv1d):
+            in_dim, out_dim = base_layer.in_channels, base_layer.out_channels
+            k_size = (base_layer.kernel_size[0],)  # Convert to a tuple with single element
+
+            in_m, in_n = factorization(in_dim, decompose_factor)
+            out_l, out_k = factorization(out_dim, decompose_factor)
+            shape = ((out_l, out_k), (in_m, in_n), *k_size)  # ((a, b), (c, d), k)
+
+            use_w1 = not (decompose_both and r < max(shape[0][0], shape[1][0]) / 2)
+            use_w2 = r >= max(shape[0][1], shape[1][1]) / 2
+            # For Conv1d with kernel_size=1, disable effective_conv2d for the same optimization reasons
+            # as 1x1 Conv2d. Kernel size 1 means no spatial/temporal context, making it equivalent
+            # to a Linear layer applied across the channel dimension. Using flattened representation
+            # avoids unnecessary reshaping and improves computational efficiency.
+            use_effective_conv2d = use_effective_conv2d and base_layer.kernel_size[0] != 1
+        else:
+            raise TypeError(f"LoKr is not implemented for base layers of type {type(base_layer).__name__}")
+
+        # Create weights with provided shape
+        self.create_adapter_parameters(adapter_name, r, shape, use_w1, use_w2, use_effective_conv2d)
+
+        # Initialize weights
+        if init_weights:
+            if init_weights == "lycoris":
+                self.reset_adapter_parameters_lycoris_way(adapter_name)
+            else:
+                self.reset_adapter_parameters(adapter_name)
+        else:
+            self.reset_adapter_parameters_random(adapter_name)
+
+        # Move new weights to device
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def get_delta_weight(self, adapter_name: str) -> torch.Tensor:
+        # https://github.com/KohakuBlueleaf/LyCORIS/blob/e4259b870d3354a9615a96be61cb5d07455c58ea/lycoris/modules/lokr.py#L224
+        if adapter_name in self.lokr_w1:
+            w1 = self.lokr_w1[adapter_name]
+        else:
+            w1 = self.lokr_w1_a[adapter_name] @ self.lokr_w1_b[adapter_name]
+
+        if adapter_name in self.lokr_w2:
+            w2 = self.lokr_w2[adapter_name]
+        elif adapter_name in self.lokr_t2:
+            w2 = make_weight_cp(self.lokr_t2[adapter_name], self.lokr_w2_a[adapter_name], self.lokr_w2_b[adapter_name])
+        else:
+            w2 = self.lokr_w2_a[adapter_name] @ self.lokr_w2_b[adapter_name]
+
+        # Make weights with Kronecker product
+        weight = make_kron(w1, w2, self.scaling[adapter_name])
+
+        # Get base layer for reshaping
+        base_layer = self.get_base_layer()
+
+        # Regular reshape to match base layer shape
+        weight = weight.reshape(base_layer.weight.shape)
+
+        # Perform rank dropout during training - drop rows of addition weights
+        rank_dropout = self.rank_dropout[adapter_name]
+        if self.training and rank_dropout:
+            drop = (torch.rand(weight.size(0)) > rank_dropout).float()
+            drop = drop.view(-1, *[1] * len(weight.shape[1:])).to(weight.device)
+            if self.rank_dropout_scale[adapter_name]:
+                drop /= drop.mean()
+            weight *= drop
+
+        return weight
+
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        previous_dtype = x.dtype
+
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+
+            # Execute all the adapters
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self._available_adapters:
+                    continue
+
+                module_dropout = self.module_dropout[active_adapter]
+
+                # Modify current execution weights
+                if (not self.training) or (self.training and torch.rand(1) > module_dropout):
+                    result = result + self._get_delta_activations(active_adapter, x, *args, **kwargs)
+
+        result = result.to(previous_dtype)
+        return result
+
+
+class Linear(LoKrLayer):
+    """LoKr implemented in Linear layer"""
+
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        adapter_name: str,
+        config: LoKrConfig,
+        device: Optional[Union[str, torch.device]] = None,
+        dtype: Optional[torch.dtype] = None,
+        r: int = 0,
+        alpha: float = 0.0,
+        **kwargs,
+    ):
+        super().__init__(base_layer)
+
+        # Create adapter and set it active
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, alpha, config=config, **kwargs)
+
+    def _get_delta_activations(
+        self, adapter_name: str, input: torch.Tensor, *args: Any, **kwargs: Any
+    ) -> torch.Tensor:
+        delta_weight = self.get_delta_weight(adapter_name)
+        input = self._cast_input_dtype(input, delta_weight.dtype)
+        # don't add bias here, because the bias is already included in the output of the base_layer
+        return F.linear(input, delta_weight)
+
+    def supports_lora_conversion(self, adapter_name: str = "default") -> bool:
+        return True
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "lokr." + rep
+
+
+class Conv2d(LoKrLayer):
+    """LoKr implemented in Conv2d layer"""
+
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        adapter_name: str,
+        config: LoKrConfig,
+        device: Optional[Union[str, torch.device]] = None,
+        dtype: Optional[torch.dtype] = None,
+        r: int = 0,
+        alpha: float = 0.0,
+        **kwargs,
+    ):
+        super().__init__(base_layer)
+
+        # Create adapter and set it active
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, alpha, config=config, **kwargs)
+
+    def _get_delta_activations(
+        self, adapter_name: str, input: torch.Tensor, *args: Any, **kwargs: Any
+    ) -> torch.Tensor:
+        delta_weight = self.get_delta_weight(adapter_name)
+        input = self._cast_input_dtype(input, delta_weight.dtype)
+        # don't add bias here, because the bias is already included in the output of the base_layer
+        base_layer = self.get_base_layer()
+        return F.conv2d(
+            input,
+            delta_weight,
+            stride=base_layer.stride,
+            padding=base_layer.padding,
+            dilation=base_layer.dilation,
+            groups=base_layer.groups,
+        )
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "lokr." + rep
+
+
+class Conv1d(LoKrLayer):
+    """LoKr implemented in Conv1d layer"""
+
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        adapter_name: str,
+        config: LoKrConfig,
+        device: Optional[Union[str, torch.device]] = None,
+        dtype: Optional[torch.dtype] = None,
+        r: int = 0,
+        alpha: float = 0.0,
+        **kwargs,
+    ):
+        super().__init__(base_layer)
+
+        # Create adapter and set it active
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, alpha, config=config, **kwargs)
+
+    def _get_delta_activations(
+        self, adapter_name: str, input: torch.Tensor, *args: Any, **kwargs: Any
+    ) -> torch.Tensor:
+        delta_weight = self.get_delta_weight(adapter_name)
+        input = self._cast_input_dtype(input, delta_weight.dtype)
+        # don't add bias here, because the bias is already included in the output of the base_layer
+        base_layer = self.get_base_layer()
+        return F.conv1d(
+            input,
+            delta_weight,
+            stride=base_layer.stride,
+            padding=base_layer.padding,
+            dilation=base_layer.dilation,
+            groups=base_layer.groups,
+        )
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "lokr." + rep
+
+
+# Below code is a direct copy from https://github.com/KohakuBlueleaf/LyCORIS/blob/eb460098187f752a5d66406d3affade6f0a07ece/lycoris/modules/lokr.py#L11
+
+
+def factorization(dimension: int, factor: int = -1) -> tuple[int, int]:
+    """Factorizes the provided number into the product of two numbers
+
+    Args:
+        dimension (`int`): The number that needs to be factorized.
+        factor (`int`, optional):
+            Factorization divider. The algorithm will try to output two numbers, one of each will be as close to the
+            factor as possible. If -1 is provided, the decomposition algorithm would try to search dividers near the
+            square root of the dimension. Defaults to -1.
+
+    Returns:
+        Tuple[`int`, `int`]: A tuple of two numbers, whose product is equal to the provided number. The first number is
+        always less than or equal to the second.
+
+    Example:
+        ```py
+        >>> factorization(256, factor=-1)
+        (16, 16)
+
+        >>> factorization(128, factor=-1)
+        (8, 16)
+
+        >>> factorization(127, factor=-1)
+        (1, 127)
+
+        >>> factorization(128, factor=4)
+        (4, 32)
+        ```
+    """
+
+    if factor > 0 and (dimension % factor) == 0:
+        m = factor
+        n = dimension // factor
+        return m, n
+    if factor == -1:
+        factor = dimension
+    m, n = 1, dimension
+    length = m + n
+    while m < n:
+        new_m = m + 1
+        while dimension % new_m != 0:
+            new_m += 1
+        new_n = dimension // new_m
+        if new_m + new_n > length or new_m > factor:
+            break
+        else:
+            m, n = new_m, new_n
+    if m > n:
+        n, m = m, n
+    return m, n
+
+
+def make_weight_cp(t, wa, wb):
+    rebuild2 = torch.einsum("i j k l, i p, j r -> p r k l", t, wa, wb)  # [c, d, k1, k2]
+    return rebuild2
+
+
+def make_kron(w1, w2, scale=1.0):
+    if len(w2.shape) == 4:
+        w1 = w1.unsqueeze(2).unsqueeze(2)
+    w2 = w2.contiguous()
+    rebuild = torch.kron(w1, w2)
+
+    return rebuild * scale
diff --git a/src/peft/tuners/lokr/model.py b/src/peft/tuners/lokr/model.py
new file mode 100644
index 0000000..7cca898
--- /dev/null
+++ b/src/peft/tuners/lokr/model.py
@@ -0,0 +1,118 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from typing import Union
+
+import torch
+from torch import nn
+
+from peft.tuners.lycoris_utils import LycorisConfig, LycorisTuner
+from peft.utils import TRANSFORMERS_MODELS_TO_LOKR_TARGET_MODULES_MAPPING
+from peft.utils.other import get_pattern_key
+
+from .layer import Conv1d, Conv2d, Linear, LoKrLayer
+
+
+class LoKrModel(LycorisTuner):
+    """
+    Creates Low-Rank Kronecker Product model from a pretrained model. The original method is partially described in
+    https://huggingface.co/papers/2108.06098 and in https://huggingface.co/papers/2309.14859 Current implementation
+    heavily borrows from
+    https://github.com/KohakuBlueleaf/LyCORIS/blob/eb460098187f752a5d66406d3affade6f0a07ece/lycoris/modules/lokr.py
+
+    Args:
+        model (`torch.nn.Module`): The model to which the adapter tuner layers will be attached.
+        config ([`LoKrConfig`]): The configuration of the LoKr model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            Create empty adapter weights on meta device. Useful to speed up the loading process.
+
+    Returns:
+        `torch.nn.Module`: The LoKr model.
+
+    Example:
+        ```py
+        >>> from diffusers import StableDiffusionPipeline
+        >>> from peft import LoKrModel, LoKrConfig
+
+        >>> config_te = LoKrConfig(
+        ...     r=8,
+        ...     lora_alpha=32,
+        ...     target_modules=["k_proj", "q_proj", "v_proj", "out_proj", "fc1", "fc2"],
+        ...     rank_dropout=0.0,
+        ...     module_dropout=0.0,
+        ...     init_weights=True,
+        ... )
+        >>> config_unet = LoKrConfig(
+        ...     r=8,
+        ...     lora_alpha=32,
+        ...     target_modules=[
+        ...         "proj_in",
+        ...         "proj_out",
+        ...         "to_k",
+        ...         "to_q",
+        ...         "to_v",
+        ...         "to_out.0",
+        ...         "ff.net.0.proj",
+        ...         "ff.net.2",
+        ...     ],
+        ...     rank_dropout=0.0,
+        ...     module_dropout=0.0,
+        ...     init_weights=True,
+        ...     use_effective_conv2d=True,
+        ... )
+
+        >>> model = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
+        >>> model.text_encoder = LoKrModel(model.text_encoder, config_te, "default")
+        >>> model.unet = LoKrModel(model.unet, config_unet, "default")
+        ```
+
+    **Attributes**:
+        - **model** ([`~torch.nn.Module`]) -- The model to be adapted.
+        - **peft_config** ([`LoKrConfig`]): The configuration of the LoKr model.
+    """
+
+    prefix: str = "lokr_"
+    tuner_layer_cls = LoKrLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_LOKR_TARGET_MODULES_MAPPING
+    layers_mapping: dict[type[torch.nn.Module], type[LoKrLayer]] = {
+        torch.nn.Conv2d: Conv2d,
+        torch.nn.Conv1d: Conv1d,
+        torch.nn.Linear: Linear,
+    }
+
+    def _create_and_replace(
+        self,
+        config: LycorisConfig,
+        adapter_name: str,
+        target: Union[LoKrLayer, nn.Module],
+        target_name: str,
+        parent: nn.Module,
+        current_key: str,
+    ) -> None:
+        """
+        A private method to create and replace the target module with the adapter module.
+        """
+        r_key = get_pattern_key(config.rank_pattern.keys(), current_key)
+        alpha_key = get_pattern_key(config.alpha_pattern.keys(), current_key)
+        kwargs = {
+            "r": config.rank_pattern.get(r_key, config.r),
+            "alpha": config.alpha_pattern.get(alpha_key, config.alpha),
+        }
+
+        if isinstance(target, LoKrLayer):
+            target.update_layer(adapter_name, config=config, **kwargs)
+        else:
+            new_module = self._create_new_module(config, adapter_name, target, **kwargs)
+            self._replace_module(parent, target_name, new_module, target)
diff --git a/src/peft/tuners/lora/__init__.py b/src/peft/tuners/lora/__init__.py
new file mode 100644
index 0000000..94d6e16
--- /dev/null
+++ b/src/peft/tuners/lora/__init__.py
@@ -0,0 +1,83 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available, is_eetq_available
+from peft.utils import register_peft_method
+
+from .arrow import create_arrow_model
+from .config import (
+    ArrowConfig,
+    BdLoraConfig,
+    EvaConfig,
+    LoftQConfig,
+    LoraConfig,
+    LoraGAConfig,
+    LoraRuntimeConfig,
+    MontecloraConfig,
+    VeloraConfig,
+)
+from .conversion import convert_to_lora, save_as_lora
+from .eva import get_eva_state_dict, initialize_lora_eva_weights
+from .gptq import GPTQLoraLinear
+from .layer import Conv2d, Conv3d, Embedding, Linear, LoraLayer, ParamWrapper
+from .loraga import preprocess_loraga
+from .model import LoraModel
+
+
+__all__ = [
+    "ArrowConfig",
+    "BdLoraConfig",
+    "Conv2d",
+    "Conv3d",
+    "Embedding",
+    "EvaConfig",
+    "GPTQLoraLinear",
+    "Linear",
+    "LoftQConfig",
+    "LoraConfig",
+    "LoraGAConfig",
+    "LoraLayer",
+    "LoraModel",
+    "LoraRuntimeConfig",
+    "MontecloraConfig",
+    "ParamWrapper",
+    "VeloraConfig",
+    "convert_to_lora",
+    "create_arrow_model",
+    "get_eva_state_dict",
+    "initialize_lora_eva_weights",
+    "preprocess_loraga",
+    "save_as_lora",
+]
+
+register_peft_method(name="lora", config_cls=LoraConfig, model_cls=LoraModel, is_mixed_compatible=True)
+
+
+def __getattr__(name):
+    if (name == "Linear8bitLt") and is_bnb_available():
+        from .bnb import Linear8bitLt
+
+        return Linear8bitLt
+
+    if (name == "Linear4bit") and is_bnb_4bit_available():
+        from .bnb import Linear4bit
+
+        return Linear4bit
+
+    if (name == "EetqLoraLinear") and is_eetq_available():
+        from .eetq import EetqLoraLinear
+
+        return EetqLoraLinear
+
+    raise AttributeError(f"module {__name__} has no attribute {name}")
diff --git a/src/peft/tuners/lora/aqlm.py b/src/peft/tuners/lora/aqlm.py
new file mode 100644
index 0000000..0218ff7
--- /dev/null
+++ b/src/peft/tuners/lora/aqlm.py
@@ -0,0 +1,105 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+from typing import Any, Optional
+
+import torch
+
+from peft.import_utils import is_aqlm_available
+from peft.tuners.lora.layer import LoraLayer
+from peft.tuners.tuners_utils import BaseTunerLayer
+
+from .config import LoraConfig
+
+
+if is_aqlm_available():
+    from aqlm import QuantizedLinear
+
+
+class AqlmLoraLinear(torch.nn.Module, LoraLayer):
+    def __init__(
+        self,
+        base_layer,
+        adapter_name: str,
+        config: LoraConfig,
+        r: int = 0,
+        lora_alpha: int = 1,
+        **kwargs,
+    ):
+        if config.use_dora:
+            raise ValueError(f"{self.__class__.__name__} does not support DoRA yet, please set it to False")
+        if config.velora_config is not None:
+            raise ValueError(f"{self.__class__.__name__} does not support VeLoRA yet, please set it to False")
+
+        super().__init__()
+        LoraLayer.__init__(self, base_layer)
+
+        self._active_adapter = adapter_name
+        self.update_layer(
+            adapter_name,
+            r,
+            lora_alpha=lora_alpha,
+            config=config,
+        )
+
+    def forward(self, x: torch.Tensor):
+        # note: logic differs from default Linear because merging is not supported
+        result = self.base_layer(x)
+
+        if self.disable_adapters:
+            return result
+
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self.lora_A.keys():
+                continue
+            lora_A = self.lora_A[active_adapter]
+            lora_B = self.lora_B[active_adapter]
+            dropout = self.lora_dropout[active_adapter]
+            scaling = self.scaling[active_adapter]
+
+            requires_conversion = not torch.is_autocast_enabled()
+            if requires_conversion:
+                expected_dtype = result.dtype
+                x = self._cast_input_dtype(x, lora_A.weight.dtype)
+
+            output = lora_B(lora_A(dropout(x)))
+            if requires_conversion:
+                output = output.to(expected_dtype)
+            output = output * scaling
+            result += output
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "lora." + rep
+
+
+def dispatch_aqlm(
+    target: torch.nn.Module,
+    adapter_name: str,
+    config: LoraConfig,
+    **kwargs: Any,
+) -> Optional[torch.nn.Module]:
+    new_module = None
+
+    if isinstance(target, BaseTunerLayer):
+        target_base_layer = target.get_base_layer()
+    else:
+        target_base_layer = target
+
+    if is_aqlm_available() and isinstance(target_base_layer, QuantizedLinear):
+        new_module = AqlmLoraLinear(target, adapter_name, config=config, **kwargs)
+        target.qweight = target_base_layer.codes
+
+    return new_module
diff --git a/src/peft/tuners/lora/arrow.py b/src/peft/tuners/lora/arrow.py
new file mode 100644
index 0000000..40f5135
--- /dev/null
+++ b/src/peft/tuners/lora/arrow.py
@@ -0,0 +1,474 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import os
+from typing import Any
+
+import torch
+from torch import nn
+from transformers import PreTrainedModel
+
+from .config import ArrowConfig
+
+
+TASK_ADAPTER_PREFIX = "task_"
+GKS_ADAPTER_PREFIX = "gks_"
+
+
+class ArrowLoraLinearLayer(nn.Module):
+    """
+    This class represent the main logic of the arrow routing algorithm for linear layers.
+    """
+
+    def __init__(self, in_features, arrow_config):
+        super().__init__()
+        # extra parameters needed for arrow
+        self.in_features = in_features
+        self._protos_ready = False
+        self.top_k = arrow_config.top_k
+        self.temperature = arrow_config.router_temperature
+        self.rng_seed = arrow_config.rng_seed
+        self.task_adapter_names = (
+            arrow_config.task_adapter_names.copy()
+        )  # Set in create_arrow_model() with this format: task_0, task_1, ...
+        self.gks_adapter_names = (
+            arrow_config.gks_adapter_names
+        )  # Set in create_arrow_model() with this format: gks_0, gks_1, ...
+        self.use_gks = arrow_config.use_gks
+        self.gks_done = False
+        self.gks_added_adapter_names = []
+        self.in_features = in_features
+        self.cast_input_dtype_enabled = True
+
+    @torch.no_grad()
+    def on_adapter_change(self, lora_A, lora_B):
+        """
+        Called when adapters are added/removed/renamed so Arrow can refresh its internal state before the next forward
+        pass.
+        """
+        all_ts_adapter_names = [
+            k
+            for k in lora_A.keys()
+            if k in lora_B and k != "arrow_router" and not (k.startswith("gks_") and k[len("gks_") :].isdigit())
+        ]
+
+        if sorted(self.task_adapter_names) == sorted(all_ts_adapter_names):  # No changes in the ts_adapters
+            return
+
+        # Getting the name(s) of added adapter(s)
+        if len(self.task_adapter_names) < len(all_ts_adapter_names):  # Adapter(s) are added.
+            self.gks_added_adapter_names = [x for x in all_ts_adapter_names if x not in self.task_adapter_names]
+
+        # Updating the task_adapter_names
+        self.task_adapter_names = all_ts_adapter_names.copy()
+        # Invalidate caches so they’ll be rebuilt lazily on next forward()
+        self._protos_ready = False
+        # GKS will be handled by self.gks_added_adapter_names
+
+    def top_right_singular_vec_from_BA(self, A, B, iters=15, eps=1e-8):
+        """
+        Computes the top *right* singular vector of ΔW = B @ A without forming ΔW.
+
+        Theory:
+            For any matrix M, the right singular vectors are the eigenvectors of Mᵀ M. If ΔW = B @ A (with A ∈
+            ℝ^{r×in}, B ∈ ℝ^{out×r}), then
+                ΔWᵀ ΔW = (B @ A)ᵀ (B @ A) = Aᵀ (Bᵀ B) A ∈ ℝ^{in×in}.
+            Therefore, the dominant right singular vector of ΔW is the dominant eigenvector of M := Aᵀ (Bᵀ B) A. We
+            find it by *power iteration* on the linear operator
+                v ↦ Aᵀ (Bᵀ B) (A v),
+            which avoids materializing ΔW (out×in) or M (in×in). The result lives in the input/token space (size =
+            in_features), which is exactly what Arrow needs. (Right singular vectors ≡ eigenvectors of MᵀM; power
+            iteration converges to the dominant eigenvector under mild conditions.)
+        =============================== Practical notes:
+            - We perform all iteration in float32 for numerical stability, then cast back
+            to the LoRA dtype/device before storing/using the prototype.
+            - Convergence is checked with a simple fixed-iter cap (`iters`) and/or
+            `allclose` tolerance (`tol`).
+            - The returned vector is unique up to sign (±), as with any singular vector.
+            Downstream code should be sign-invariant.
+        """
+
+        # A: (r, in), B: (out, r)
+        A32 = A.to(torch.float32)
+        B32 = B.to(torch.float32)
+        C = B32.T @ B32  # (r, r)
+
+        # Private RNG on A's device
+        gen = None
+        if self.rng_seed is not None:
+            gen = torch.Generator(device=A32.device.type)
+            gen.manual_seed(int(self.rng_seed))
+
+        # init vector in input space
+        v = torch.randn(A32.size(1), dtype=A32.dtype, device=A32.device, generator=gen)
+        v = v / (v.norm() + eps)
+
+        for _ in range(iters):
+            # w = (ΔWᵀΔW) v = Aᵀ (BᵀB) (A v)
+            w = A32.T @ (C @ (A32 @ v))
+            v = w / (w.norm() + eps)
+
+        return v  # fp32
+
+    @torch.no_grad()
+    def build_prototypes(self, lora_A, lora_B):
+        """
+        Computes a prototype vector for each LoRA module in every layer by applying Singular Value Decomposition (SVD)
+        to the `lora_A` matrix and extracting the top right singular vector.
+
+        These prototypes are later used to calculate the cosine similarity between each input token and each expert.
+        The resulting similarity scores serve as coefficients to compute a weighted average of the corresponding LoRA
+        modules, effectively routing each token through its most relevant experts.
+
+        ** This prototype computation is done is done once for all experts and is re-done on newly added adapters.**
+
+        Args:
+            lora_A : Matrices A in LoRA layer.
+            lora_B (optional): Matrices B in LoRA layer. Defaults to None.
+        """
+
+        if self._protos_ready:
+            return
+        protos = []
+        for name in self.task_adapter_names:
+            A = lora_A[name].weight  # (r, in_features)
+            B = lora_B[name].weight  # (out_features, r)
+
+            # Efficiently computing right singular vector of A @ B
+            proto32 = self.top_right_singular_vec_from_BA(A, B)
+
+            proto = proto32.to(dtype=A.dtype, device=A.device)
+            protos.append(proto)
+
+        proto_stack = torch.stack(protos, dim=0)  # (E, in_features)
+
+        # Register the prototypes buffer with correct dtype/device consistent with A and B weights
+        self.register_buffer("prototypes", proto_stack, persistent=False)
+        self._protos_ready = True
+
+    @torch.no_grad()
+    def gen_know_sub(self, lora_A, lora_B):
+        """
+        This function performs General Knowledge Subtraction. It takes an average of provided general_adapters, and
+        subtract it from each task_adapter. This subtraction tries to purify the task adapters, based on
+        "forgetting-via-negation" principle. Forgetting-via-negation is a task-arithmetic operation, explained in:
+        https://huggingface.co/papers/2212.04089 The task adapters will be more focused and isolated, enhancing the
+        performance on new tasks.
+
+        Args:
+            lora_A : Matrices A in LoRA layer.
+            lora_B : Matrices A in LoRA layer.
+        """
+        if not self.use_gks or self.gks_done and not self.gks_added_adapter_names:
+            return
+        else:
+            # 1) compute average A/B over gks_adapter_names
+            avg_A = torch.stack([lora_A[n].weight for n in self.gks_adapter_names], dim=0).mean(
+                0
+            )  # shape (r, in_features)
+            avg_B = torch.stack([lora_B[n].weight for n in self.gks_adapter_names], dim=0).mean(
+                0
+            )  # shape (out_features, r)
+
+            # 2) Subtract the average from task-specific experts
+            if self.gks_done is False:  # GKS is done for all the experts, since it hasn't been done yet.
+                for name in self.task_adapter_names:
+                    lora_A[name].weight.data.sub_(avg_A)
+                    lora_B[name].weight.data.sub_(avg_B)
+            else:  # GKS is only done on new added experts, since GKS has been done previously.
+                for name in self.gks_added_adapter_names:
+                    lora_A[name].weight.data.sub_(avg_A)
+                    lora_B[name].weight.data.sub_(avg_B)
+
+            # 3) Set gks_done flag as true, so we won't do it again in ArrowLinearVariant.forward().
+            self.gks_done = True
+            # Clearing the self.gks_added_adapter_names
+            self.gks_added_adapter_names = []
+
+    def _cast_input_dtype(self, x, dtype: torch.dtype):
+        """
+        Whether to cast the dtype of the input of the forward method.
+
+        Usually, we want to enable this to align the input dtype with the dtype of the weight, but by setting
+        layer.cast_input_dtype=False, this can be disabled if necessary.
+
+        Enabling or disabling can be managed via the peft.helpers.disable_input_dtype_casting context manager.
+        """
+        if x is None:  # useful e.g. if x is the bias, which can be None
+            return None
+
+        cast_input_dtype_enabled = getattr(self, "cast_input_dtype_enabled", True)
+        if (not cast_input_dtype_enabled) or (x.dtype == dtype):
+            return x
+        return x.to(dtype=dtype)
+
+    def forward(self, x, lora_A, lora_B, dropout, scaling):
+        """
+        Applies Arrow routing inside a LoRA layer.
+
+        Steps:
+        1. Compute cosine similarity between each token representation and all adapter prototypes.
+        2. Select the top-k experts per token and normalize their scores with a softmax.
+        3. Project tokens into each selected expert’s low-rank space (A weights).
+        4. Map back to the output space (B weights).
+        5. Aggregate expert outputs via the weighted sum of their contributions.
+        6. Apply dropout, scaling, and return the reshaped delta.
+
+        - Conceptually, this is a Mixture-of-Experts (MoE) over LoRA adapters,
+        where coefficients are derived from prototype similarity.
+
+        Returns:
+            delta: LoRA output adjustment computed by Arrow routing.
+        """
+        x = self._cast_input_dtype(x, lora_A[self.task_adapter_names[0]].weight.dtype)
+        B, *rest, F_in = x.shape
+        tok = x.view(-1, F_in)  # (t, F_in)
+        t, E = tok.size(0), self.prototypes.size(0)
+
+        # We now turn scaling, which is a dict, to tensors in order to use them later
+        scales_tens = torch.tensor(
+            [scaling[n] for n in self.task_adapter_names],
+            device=tok.device,
+            dtype=tok.dtype,
+        )  # shape (E,)
+
+        # 1) similarity   — sign-agnostic
+        sim = torch.abs(tok @ self.prototypes.T)  # (t, E)
+
+        # 2) top-k + softmax over full E (non-top-k = -inf)
+        top_v, idx = torch.topk(sim, self.top_k, dim=1)
+        full_score = tok.new_full((t, E), float("-inf"))
+        full_score.scatter_(1, idx, top_v)
+        coeff = torch.softmax(full_score / self.temperature, dim=1)  # (t, E)
+
+        # 3) stack all A and B weights once
+        #   A_stack: (E, r, in_features), B_stack: (E, out_features, r)
+        A_stack = torch.stack([lora_A[n].weight for n in self.task_adapter_names], dim=0)
+        B_stack = torch.stack([lora_B[n].weight for n in self.task_adapter_names], dim=0)
+
+        # 4) project tokens into each expert’s low‑rank space:
+        #    z[e] = tok @ A_e.T   → shape (t, E, r)
+        z = torch.einsum("tf, erf -> ter", tok, A_stack)
+
+        # 5) lift back each expert’s output:
+        #    y[e] = z[e] @ B_e.T  → shape (t, E, out_features)
+        y = torch.einsum("ter, eor -> teo", z, B_stack)
+
+        # 6) apply per-expert scaling before the weighted sum
+        # y_scaled[t, e, o] = scales[e] * y[t, e, o]
+        y = y * scales_tens.view(1, -1, 1)
+
+        # 6) weighted sum over experts:
+        #    delta_flat[t,o] = Σ_e coeff[t,e] * y[t,e,o]
+        delta_flat = torch.einsum("te, teo -> to", coeff, y)  # (t, out_features)
+
+        # 7) dropout, scale, and reshape
+        delta = dropout(delta_flat)
+        out_dim = delta_flat.size(-1)
+        return delta.view(B, *rest, out_dim)
+
+
+def check_loaded_lora_compatibility_arrow(model, adapter_names: list[str]):
+    """
+    After loading all adapters into `model`, check they share:
+      - the same LoRA rank (r)
+      - identical weight shapes
+      - identical sets of target_modules
+    Returns (sorted list of target module names, agreed rank r).
+    """
+    reference = None  # {'r':…, 'shapes':(Ashape,Bshape), 'modules':set([...])}
+
+    for name in adapter_names:
+        curr_modules = set()
+        curr_r = None
+        curr_shapes = None
+
+        for full_name, module in model.named_modules():
+            if hasattr(module, "lora_A") and name in module.lora_A:
+                A = module.lora_A[name].weight
+                B = module.lora_B[name].weight
+                mod_name = full_name.split(".")[-1]
+                curr_modules.add(mod_name)
+                # A has shape (r, in_features); B has shape (out_features, r)
+                curr_r = A.shape[0]
+                curr_shapes = (A.shape, B.shape)
+
+        if reference is None:
+            reference = {"r": curr_r, "shapes": curr_shapes, "modules": curr_modules}
+        else:
+            if curr_r != reference["r"]:
+                raise ValueError(f"[{name}] rank mismatch: {curr_r} != {reference['r']}")
+            if curr_shapes != reference["shapes"]:
+                raise ValueError(f"[{name}] shape mismatch: {curr_shapes} != {reference['shapes']}")
+            if curr_modules != reference["modules"]:
+                raise ValueError(
+                    f"[{name}] target_modules mismatch:\n"
+                    f"  this adapter -> {sorted(curr_modules)}\n"
+                    f"  reference   -> {sorted(reference['modules'])}"
+                )
+
+    agreed_modules = sorted(reference["modules"])
+    return agreed_modules, int(reference["r"])
+
+
+def ensure_adapters_target_linear_layers_only(model, adapter_names: list[str]):
+    """
+    Validate that every module holding LoRA weights for any of `adapter_names` is Linear-like: nn.Linear,
+    bitsandbytes.nn.Linear4bit, nn.Conv1d, or transformers.models.gpt2.modeling_gpt2.Conv1D. If not, raise.
+    """
+    from torch import nn
+
+    Linear4bit = None
+    try:
+        import bitsandbytes as bnb  # type: ignore
+
+        Linear4bit = bnb.nn.Linear4bit
+    except ImportError:
+        pass
+
+    HFConv1D = None
+    try:
+        from transformers.models.gpt2.modeling_gpt2 import Conv1D as HFConv1D  # type: ignore
+    except ImportError:
+        pass
+
+    allowed_types = (nn.Linear, nn.Conv1d)
+    if Linear4bit is not None:
+        allowed_types = allowed_types + (Linear4bit,)
+    if HFConv1D is not None:
+        allowed_types = allowed_types + (HFConv1D,)
+
+    offenders = []
+
+    for full_name, module in model.named_modules():
+        if hasattr(module, "lora_A"):
+            for name in adapter_names:
+                if name in getattr(module, "lora_A", {}):
+                    base = getattr(module, "base_layer", None) or getattr(module, "original_module", None)
+                    layer_to_check = base if base is not None else module
+
+                    if not isinstance(layer_to_check, allowed_types):
+                        offenders.append((name, full_name, type(layer_to_check).__name__))
+
+    if offenders:
+        lines = [
+            "LoRA adapters must only target Linear-like layers "
+            "(nn.Linear, nn.Conv1d, HF Conv1D, or bitsandbytes.nn.Linear4bit). Found:"
+        ]
+        for name, full_name, tname in offenders:
+            lines.append(f"  - adapter '{name}' on module '{full_name}' of type {tname}")
+        raise TypeError("\n".join(lines))
+
+
+def _resolve_adapter_source(path: str) -> tuple[str, str | None]:
+    """
+    Resolve a user-provided adapter `path` into (model_id, subfolder).
+
+    Supports:
+      - Local path to a folder that contains `adapter_config.json`
+      - Hub path with subfolder, e.g. "user/repo/ts_expert_0[/more/...]", which becomes:
+            model_id="user/repo", subfolder="ts_expert_0[/more/...]"
+      - Plain Hub repo id "user/repo" (no subfolder)
+    """
+    if os.path.isdir(path):
+        if not os.path.isfile(os.path.join(path, "adapter_config.json")):
+            raise ValueError(f"Local adapter path '{path}' does not contain 'adapter_config.json'.")
+        return path, None
+
+    parts = path.strip("/").split("/")
+    if len(parts) >= 2:
+        model_id = "/".join(parts[:2])
+        if len(parts) > 2:
+            subfolder = "/".join(parts[2:])
+            return model_id, subfolder
+        return model_id, None
+
+    return path, None
+
+
+def create_arrow_model(
+    base_model: PreTrainedModel,
+    task_specific_adapter_paths: list[str],
+    arrow_config: ArrowConfig,
+    general_adapter_paths: list[str] | None = None,
+    **adapter_kwargs: Any,
+):
+    if task_specific_adapter_paths is None or len(task_specific_adapter_paths) == 0:
+        raise ValueError("`task_specific_adapter_paths` should contain at least one adapter path")
+
+    from peft import LoraConfig, PeftModel
+
+    model_id0, sub0 = _resolve_adapter_source(task_specific_adapter_paths[0])
+    initial_ts_expert_name = f"{TASK_ADAPTER_PREFIX}0"
+
+    first_kwargs = dict(adapter_kwargs)
+    if sub0 is not None and "subfolder" not in first_kwargs:
+        first_kwargs["subfolder"] = sub0
+
+    model = PeftModel.from_pretrained(
+        base_model,
+        model_id=model_id0,
+        adapter_name=initial_ts_expert_name,
+        **first_kwargs,
+    )
+
+    for i in range(1, len(task_specific_adapter_paths)):
+        ts_expert_name = f"{TASK_ADAPTER_PREFIX}{i}"
+        mid, sub = _resolve_adapter_source(task_specific_adapter_paths[i])
+        more_kwargs = dict(adapter_kwargs)
+        if sub is not None and "subfolder" not in more_kwargs:
+            more_kwargs["subfolder"] = sub
+        model.load_adapter(
+            model_id=mid,
+            adapter_name=ts_expert_name,
+            **more_kwargs,
+        )
+    arrow_config.task_adapter_names = [f"{TASK_ADAPTER_PREFIX}{i}" for i in range(len(task_specific_adapter_paths))]
+
+    if arrow_config.use_gks:
+        if general_adapter_paths is None or len(general_adapter_paths) == 0:
+            raise ValueError("You should provide general LoRA paths if you want to use GenKnowSub.")
+        for i in range(len(general_adapter_paths)):
+            gen_expert_name = f"{GKS_ADAPTER_PREFIX}{i}"
+            mid, sub = _resolve_adapter_source(general_adapter_paths[i])
+            gks_kwargs = dict(adapter_kwargs)
+            if sub is not None and "subfolder" not in gks_kwargs:
+                gks_kwargs["subfolder"] = sub
+            model.load_adapter(
+                model_id=mid,
+                adapter_name=gen_expert_name,
+                **gks_kwargs,
+            )
+        arrow_config.gks_adapter_names = [f"{GKS_ADAPTER_PREFIX}{i}" for i in range(len(general_adapter_paths))]
+    else:
+        arrow_config.gks_adapter_names = []
+
+    target_modules, r = check_loaded_lora_compatibility_arrow(
+        model, adapter_names=arrow_config.task_adapter_names + arrow_config.gks_adapter_names
+    )
+
+    ensure_adapters_target_linear_layers_only(
+        model, adapter_names=arrow_config.task_adapter_names + arrow_config.gks_adapter_names
+    )
+
+    router_cfg = LoraConfig(
+        arrow_config=arrow_config,
+        target_modules=target_modules,
+        r=r,
+    )
+    model.add_adapter(adapter_name="arrow_router", peft_config=router_cfg)
+    model.set_adapter("arrow_router")
+
+    return model
diff --git a/src/peft/tuners/lora/awq.py b/src/peft/tuners/lora/awq.py
new file mode 100644
index 0000000..5ea9962
--- /dev/null
+++ b/src/peft/tuners/lora/awq.py
@@ -0,0 +1,104 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+from typing import Any, Optional
+
+import torch
+
+from peft.import_utils import is_gptqmodel_available
+from peft.tuners.lora.layer import LoraLayer
+from peft.tuners.tuners_utils import BaseTunerLayer
+from peft.utils.other import is_gptqmodel_awq_layer
+
+from .config import LoraConfig
+
+
+class AwqLoraLinear(torch.nn.Module, LoraLayer):
+    def __init__(
+        self,
+        base_layer,
+        adapter_name,
+        config: LoraConfig,
+        r: int = 0,
+        lora_alpha: int = 1,
+        **kwargs,
+    ):
+        if config.use_dora:
+            raise ValueError(f"{self.__class__.__name__} does not support DoRA yet, please set it to False")
+        if config.velora_config is not None:
+            raise ValueError(f"{self.__class__.__name__} does not support VeLoRA yet, please set it to False")
+
+        super().__init__()
+        LoraLayer.__init__(self, base_layer)
+
+        # self.base_layer and self.quant_linear_module are the same; we need the former for consistency and the latter
+        # for backwards compatibility
+        self.quant_linear_module = base_layer
+
+        self._active_adapter = adapter_name
+        self.update_layer(
+            adapter_name,
+            r,
+            lora_alpha=lora_alpha,
+            config=config,
+        )
+
+    def forward(self, x: torch.Tensor):
+        result = self.quant_linear_module(x)
+
+        if self.disable_adapters:
+            return result
+
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self.lora_A.keys():
+                continue
+            lora_A = self.lora_A[active_adapter]
+            lora_B = self.lora_B[active_adapter]
+            dropout = self.lora_dropout[active_adapter]
+            scaling = self.scaling[active_adapter]
+
+            requires_conversion = not torch.is_autocast_enabled()
+            if requires_conversion:
+                expected_dtype = result.dtype
+                x = self._cast_input_dtype(x, lora_A.weight.dtype)
+
+            output = lora_B(lora_A(dropout(x)))
+            if requires_conversion:
+                output = output.to(expected_dtype)
+            output = output * scaling
+            result = result + output
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "lora." + rep
+
+
+def dispatch_awq(
+    target: torch.nn.Module,
+    adapter_name: str,
+    config: LoraConfig,
+    **kwargs: Any,
+) -> Optional[torch.nn.Module]:
+    new_module = None
+
+    if isinstance(target, BaseTunerLayer):
+        target_base_layer = target.get_base_layer()
+    else:
+        target_base_layer = target
+
+    if is_gptqmodel_available() and is_gptqmodel_awq_layer(target_base_layer):
+        new_module = AwqLoraLinear(target, adapter_name, config=config, **kwargs)
+        target.qweight = target_base_layer.qweight
+
+    return new_module
diff --git a/src/peft/tuners/lora/bnb.py b/src/peft/tuners/lora/bnb.py
new file mode 100644
index 0000000..15c9d20
--- /dev/null
+++ b/src/peft/tuners/lora/bnb.py
@@ -0,0 +1,591 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import warnings
+from typing import Any, Optional
+
+import bitsandbytes as bnb
+import torch
+
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+from peft.utils.integrations import dequantize_bnb_weight
+from peft.utils.other import transpose
+
+from .config import LoraConfig
+from .layer import LoraLayer, LoraVariant
+
+
+VARIANT_KWARG_KEYS = ["alora_offsets"]
+
+if is_bnb_available():
+
+    class Linear8bitLt(torch.nn.Module, LoraLayer):
+        # Lora implemented in a dense layer
+        def __init__(
+            self,
+            base_layer: torch.nn.Module,
+            adapter_name: str,
+            config: LoraConfig,
+            r: int = 0,
+            lora_alpha: int = 1,
+            **kwargs,
+        ) -> None:
+            super().__init__()
+            LoraLayer.__init__(self, base_layer)
+            self.fan_in_fan_out = False
+
+            self._active_adapter = adapter_name
+            self.update_layer(
+                adapter_name,
+                r,
+                lora_alpha=lora_alpha,
+                config=config,
+            )
+
+        def resolve_lora_variant(self, *, config, **kwargs) -> Optional[LoraVariant]:
+            if config.velora_config is not None:
+                raise ValueError(f"{self.__class__.__name__} does not support VeLoRA.")
+            if config.arrow_config is not None:
+                from .variants import ArrowLinearVariant
+
+                return ArrowLinearVariant()
+
+            use_alora = config.alora_invocation_tokens is not None
+            if not config.use_dora and not use_alora:
+                return None
+
+            from .variants import ALoraLinearVariant, DoraLinearVariant
+
+            if use_alora:
+                return ALoraLinearVariant()
+            else:
+                return DoraLinearVariant()
+
+        def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+            """
+            Merge the active adapter weights into the base weights
+
+            Args:
+                safe_merge (`bool`, *optional*):
+                    If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                    before merging the weights. This is useful if you want to check if the merge operation will produce
+                    NaNs. Defaults to `False`.
+                adapter_names (`list[str]`, *optional*):
+                    The list of adapter names that should be merged. If None, all active adapters will be merged.
+                    Defaults to `None`.
+            """
+            adapter_names = check_adapters_to_merge(self, adapter_names)
+            if not adapter_names:
+                # no adapter to merge
+                return
+
+            for active_adapter in adapter_names:
+                if active_adapter not in self.lora_A.keys():
+                    continue
+
+                warnings.warn(
+                    "Merge lora module to 8-bit linear may get different generations due to rounding errors."
+                )
+
+                weight = self.get_base_layer().weight
+                state = self.get_base_layer().state
+                if state.SCB is None:
+                    state.SCB = weight.SCB
+
+                # Dequantize the result of identity matrix and int8 weight because bitsandbytes does not support int8
+                # dequantization directly
+                output = dequantize_bnb_weight(weight, state=state)
+                if active_adapter not in self.lora_variant:  # vanilla LoRA
+                    lora_data = self.get_delta_weight(active_adapter)
+                    w_data = output.to(lora_data.dtype).to(lora_data.device) + lora_data
+                else:
+                    w_data = self.lora_variant[active_adapter].merge_safe(self, active_adapter, output)
+
+                if safe_merge and not torch.isfinite(w_data).all():
+                    raise ValueError(
+                        f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                    )
+
+                self.get_base_layer().weight = bnb.nn.Int8Params(
+                    w_data.to("cpu"), requires_grad=False, has_fp16_weights=weight.has_fp16_weights
+                ).to(weight.device)
+
+                if self.lora_bias[active_adapter]:
+                    bias_data = self.get_base_layer().bias.data + self.lora_B[active_adapter].bias
+                    if safe_merge and not torch.isfinite(bias_data):
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+                    self.get_base_layer().bias.data = bias_data
+
+                state.reset_grads()
+                self.merged_adapters.append(active_adapter)
+
+        def unmerge(self) -> None:
+            """
+            This method unmerges all merged adapter layers from the base weights.
+            """
+            if not self.merged:
+                warnings.warn("Already unmerged. Nothing to do.")
+                return
+
+            while len(self.merged_adapters) > 0:
+                active_adapter = self.merged_adapters.pop()
+                if active_adapter not in self.lora_A.keys():
+                    continue
+                warnings.warn(
+                    "Unmerge lora module to 8-bit linear may get different generations due to rounding errors."
+                )
+
+                weight = self.get_base_layer().weight
+                state = self.get_base_layer().state
+                if state.SCB is None:
+                    state.SCB = weight.SCB
+                output = dequantize_bnb_weight(weight, state=state)
+
+                if active_adapter not in self.lora_variant:  # vanilla LoRA
+                    lora_data = self.get_delta_weight(active_adapter)
+                    w_data = output.to(lora_data.dtype).to(lora_data.device) - lora_data
+                else:
+                    w_data = self.lora_variant[active_adapter].unmerge(self, active_adapter, output)
+
+                self.get_base_layer().weight = bnb.nn.Int8Params(
+                    w_data.to("cpu"), requires_grad=False, has_fp16_weights=weight.has_fp16_weights
+                ).to(weight.device)
+
+                if self.lora_bias[active_adapter]:
+                    self.get_base_layer().bias.data -= self.lora_B[active_adapter].bias
+                state.reset_grads()
+
+        def get_delta_weight(self, adapter):
+            return (
+                transpose(
+                    self.lora_B[adapter].weight @ self.lora_A[adapter].weight,
+                    False,
+                )
+                * self.scaling[adapter]
+            )
+
+        def _mixed_batch_forward(
+            self, x: torch.Tensor, *args: Any, adapter_names: list[str], **kwargs: Any
+        ) -> torch.Tensor:
+            # This is a special method that handles the case when users pass the argument `adapter_names`. This is an
+            # extra argument that allows mixing different adapters in the same batch at inference time.
+            variant_kwargs = {k: kwargs.pop(k, None) for k in VARIANT_KWARG_KEYS}  # don't pass these to base_layer
+            result = self.base_layer(x, *args, **kwargs)
+
+            unique_adapters = set(adapter_names)
+            sub_batch_indices_list = []
+            for adapter in unique_adapters:
+                sub_batch_indices_list.append([index for index, item in enumerate(adapter_names) if item == adapter])
+
+            for i, active_adapter in enumerate(unique_adapters):
+                if active_adapter == "__base__":
+                    continue
+                if active_adapter not in self.lora_A.keys():
+                    continue
+
+                lora_A = self.lora_A[active_adapter]
+                lora_B = self.lora_B[active_adapter]
+                dropout = self.lora_dropout[active_adapter]
+                scaling = self.scaling[active_adapter]
+
+                requires_conversion = not torch.is_autocast_enabled()
+                if requires_conversion:
+                    expected_dtype = result.dtype
+                    x = self._cast_input_dtype(x, lora_A.weight.dtype)
+
+                # getting the sub-batch, passing it to LoRA layers and updating the corresponding indices of the linear
+                # layer output
+                sub_batch = x[sub_batch_indices_list[i]]
+                if active_adapter not in self.lora_variant:  # vanilla LoRA:
+                    output = lora_B(lora_A(dropout(sub_batch))) * scaling
+                    if requires_conversion:
+                        output = output.to(expected_dtype)
+                    result[sub_batch_indices_list[i]] += output
+                else:
+                    alora_offsets = variant_kwargs.get("alora_offsets", None)
+                    if alora_offsets is not None:
+                        variant_kwargs["alora_offsets"] = [alora_offsets[j] for j in sub_batch_indices_list[i]]
+                    output = self.lora_variant[active_adapter].forward(
+                        self,
+                        active_adapter=active_adapter,
+                        x=sub_batch,
+                        result=result[sub_batch_indices_list[i]],
+                        **variant_kwargs,
+                        **kwargs,
+                    )
+                    if requires_conversion:
+                        output = output.to(expected_dtype)
+                    result[sub_batch_indices_list[i]] = output
+
+            return result
+
+        def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+            self._check_forward_args(x, *args, **kwargs)
+            adapter_names = kwargs.pop("adapter_names", None)
+            variant_kwargs = {k: kwargs.pop(k, None) for k in VARIANT_KWARG_KEYS}  # don't pass these to base_layer
+
+            if self.disable_adapters:
+                if self.merged:
+                    self.unmerge()
+                result = self.base_layer(x, *args, **kwargs)
+            elif adapter_names is not None:
+                result = self._mixed_batch_forward(x, *args, adapter_names=adapter_names, **variant_kwargs, **kwargs)
+            elif self.merged:
+                result = self.base_layer(x, *args, **kwargs)
+            else:
+                result = self.base_layer(x, *args, **kwargs)
+                for active_adapter in self.active_adapters:
+                    if active_adapter not in self.lora_A.keys():
+                        continue
+                    lora_A = self.lora_A[active_adapter]
+                    lora_B = self.lora_B[active_adapter]
+                    dropout = self.lora_dropout[active_adapter]
+                    scaling = self.scaling[active_adapter]
+
+                    requires_conversion = not torch.is_autocast_enabled()
+                    if requires_conversion:
+                        expected_dtype = result.dtype
+                        x = self._cast_input_dtype(x, lora_A.weight.dtype)
+
+                    if active_adapter not in self.lora_variant:  # vanilla LoRA
+                        output = lora_B(lora_A(dropout(x))) * scaling
+                        if requires_conversion:
+                            output = output.to(expected_dtype)
+                        result = result + output
+                    else:
+                        result = self.lora_variant[active_adapter].forward(
+                            self,
+                            active_adapter=active_adapter,
+                            x=x,
+                            result=result,
+                            **variant_kwargs,
+                            **kwargs,
+                        )
+                        if requires_conversion:
+                            result = result.to(expected_dtype)
+
+            return result
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return "lora." + rep
+
+    def dispatch_bnb_8bit(target: torch.nn.Module, adapter_name: str, config: LoraConfig, **kwargs):
+        new_module = None
+
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        loaded_in_8bit = kwargs.get("loaded_in_8bit", False)
+        if loaded_in_8bit and isinstance(target_base_layer, bnb.nn.Linear8bitLt):
+            eightbit_kwargs = kwargs.copy()
+            eightbit_kwargs.update(
+                {
+                    "has_fp16_weights": target.state.has_fp16_weights,
+                    "threshold": target.state.threshold,
+                    "index": target.index,
+                }
+            )
+            new_module = Linear8bitLt(target, adapter_name, config=config, **eightbit_kwargs)
+
+        return new_module
+
+
+if is_bnb_4bit_available():
+
+    class Linear4bit(torch.nn.Module, LoraLayer):
+        # Lora implemented in a dense layer
+        def __init__(
+            self,
+            base_layer: torch.nn.Module,
+            adapter_name: str,
+            config: LoraConfig,
+            r: int = 0,
+            lora_alpha: int = 1,
+            **kwargs,
+        ) -> None:
+            super().__init__()
+            LoraLayer.__init__(self, base_layer)
+            self.fan_in_fan_out = False
+
+            self._active_adapter = adapter_name
+            self.update_layer(
+                adapter_name,
+                r,
+                lora_alpha=lora_alpha,
+                config=config,
+            )
+
+        def resolve_lora_variant(self, *, config: LoraConfig, **kwargs) -> Optional[LoraVariant]:
+            if config.velora_config is not None:
+                raise ValueError(f"{self.__class__.__name__} does not support VeLoRA.")
+            if config.arrow_config is not None:
+                from .variants import ArrowLinearVariant
+
+                return ArrowLinearVariant()
+
+            use_alora = config.alora_invocation_tokens is not None
+            if not config.use_dora and not use_alora:
+                return None
+
+            from .variants import ALoraLinearVariant, DoraLinearVariant
+
+            if use_alora:
+                return ALoraLinearVariant()
+            else:
+                return DoraLinearVariant()
+
+        def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+            """
+            Merge the active adapter weights into the base weights
+
+            Args:
+                safe_merge (`bool`, *optional*):
+                    If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                    before merging the weights. This is useful if you want to check if the merge operation will produce
+                    NaNs. Defaults to `False`.
+                adapter_names (`list[str]`, *optional*):
+                    The list of adapter names that should be merged. If None, all active adapters will be merged.
+                    Defaults to `None`.
+            """
+            adapter_names = check_adapters_to_merge(self, adapter_names)
+            if not adapter_names:
+                # no adapter to merge
+                return
+
+            for active_adapter in adapter_names:
+                if active_adapter not in self.lora_A.keys():
+                    continue
+
+                warnings.warn(
+                    "Merge lora module to 4-bit linear may get different generations due to rounding errors."
+                )
+                # Refer to https://gist.github.com/ChrisHayduk/1a53463331f52dca205e55982baf9930
+                weight = self.get_base_layer().weight
+                kwargs = weight.__dict__
+
+                output = dequantize_bnb_weight(weight, state=weight.quant_state)
+                if active_adapter not in self.lora_variant:  # vanilla LoRA
+                    lora_data = self.get_delta_weight(active_adapter)
+                    w_data = output + lora_data
+                else:
+                    w_data = self.lora_variant[active_adapter].merge_safe(self, active_adapter, output)
+
+                if safe_merge and not torch.isfinite(w_data).all():
+                    raise ValueError(
+                        f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                    )
+
+                if "bnb_quantized" in kwargs:
+                    kwargs["bnb_quantized"] = False
+                kwargs["requires_grad"] = False
+                kwargs.pop("data", None)
+                # torch.compile can introduce attributes preceded by '_', remove them
+                kwargs = {k: v for k, v in kwargs.items() if not k.startswith("_")}
+                self.get_base_layer().weight = bnb.nn.Params4bit(w_data.to("cpu"), **kwargs).to(weight.device)
+
+                if self.lora_bias[active_adapter]:
+                    bias_data = self.get_base_layer().bias.data + self.lora_B[active_adapter].bias
+                    if safe_merge and not torch.isfinite(bias_data):
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+                    self.get_base_layer().bias.data = bias_data
+
+                self.merged_adapters.append(active_adapter)
+
+        def unmerge(self) -> None:
+            """
+            This method unmerges all merged adapter layers from the base weights.
+            """
+            if not self.merged:
+                warnings.warn("Already unmerged. Nothing to do.")
+                return
+
+            while len(self.merged_adapters) > 0:
+                active_adapter = self.merged_adapters.pop()
+                if active_adapter not in self.lora_A.keys():
+                    continue
+                warnings.warn(
+                    "Unmerge lora module to 4-bit linear may get different generations due to rounding errors."
+                )
+
+                weight = self.get_base_layer().weight
+                kwargs = weight.__dict__
+                output = dequantize_bnb_weight(weight, state=weight.quant_state)
+
+                if active_adapter not in self.lora_variant:  # vanilla LoRA
+                    lora_data = self.get_delta_weight(active_adapter)
+                    w_data = output - lora_data
+                else:
+                    w_data = self.lora_variant[active_adapter].unmerge(self, active_adapter, output)
+
+                if "bnb_quantized" in kwargs:
+                    kwargs["bnb_quantized"] = False
+                kwargs["requires_grad"] = False
+                kwargs.pop("data", None)
+                self.get_base_layer().weight = bnb.nn.Params4bit(w_data.to("cpu"), **kwargs).to(weight.device)
+
+                if self.lora_bias[active_adapter]:
+                    self.get_base_layer().bias.data -= self.lora_B[active_adapter].bias
+
+        def get_delta_weight(self, adapter):
+            return (
+                transpose(
+                    self.lora_B[adapter].weight @ self.lora_A[adapter].weight,
+                    False,
+                )
+                * self.scaling[adapter]
+            )
+
+        def _mixed_batch_forward(
+            self, x: torch.Tensor, *args: Any, adapter_names: list[str], **kwargs: Any
+        ) -> torch.Tensor:
+            # This is a special method that handles the case when users pass the argument `adapter_names`. This is an
+            # extra argument that allows mixing different adapters in the same batch at inference time.
+            variant_kwargs = {k: kwargs.pop(k, None) for k in VARIANT_KWARG_KEYS}  # don't pass these to base_layer
+            result = self.base_layer(x, *args, **kwargs)
+
+            unique_adapters = set(adapter_names)
+            sub_batch_indices_list = []
+            for adapter in unique_adapters:
+                sub_batch_indices_list.append([index for index, item in enumerate(adapter_names) if item == adapter])
+
+            for i, active_adapter in enumerate(unique_adapters):
+                if active_adapter == "__base__":
+                    continue
+                if active_adapter not in self.lora_A.keys():
+                    continue
+
+                lora_A = self.lora_A[active_adapter]
+                lora_B = self.lora_B[active_adapter]
+                dropout = self.lora_dropout[active_adapter]
+                scaling = self.scaling[active_adapter]
+
+                requires_conversion = not torch.is_autocast_enabled()
+                if requires_conversion:
+                    expected_dtype = result.dtype
+                    x = self._cast_input_dtype(x, lora_A.weight.dtype)
+
+                # getting the sub-batch, passing it to LoRA layers and updating the corresponding indices of the linear
+                # layer output
+                sub_batch = x[sub_batch_indices_list[i]]
+                if active_adapter not in self.lora_variant:  # vanilla LoRA
+                    output = lora_B(lora_A(dropout(sub_batch))) * scaling
+                    if requires_conversion:
+                        output = output.to(expected_dtype)
+                    result[sub_batch_indices_list[i]] += output
+                else:
+                    alora_offsets = variant_kwargs.get("alora_offsets", None)
+                    if alora_offsets is not None:
+                        variant_kwargs["alora_offsets"] = [alora_offsets[j] for j in sub_batch_indices_list[i]]
+                    output = self.lora_variant[active_adapter].forward(
+                        self,
+                        active_adapter=active_adapter,
+                        x=sub_batch,
+                        result=result[sub_batch_indices_list[i]],
+                        **variant_kwargs,
+                        **kwargs,
+                    )
+                    if requires_conversion:
+                        output = output.to(expected_dtype)
+                    result[sub_batch_indices_list[i]] = output
+
+            return result
+
+        def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+            self._check_forward_args(x, *args, **kwargs)
+            adapter_names = kwargs.pop("adapter_names", None)
+            variant_kwargs = {k: kwargs.pop(k, None) for k in VARIANT_KWARG_KEYS}  # don't pass these to base_layer
+
+            if self.disable_adapters:
+                if self.merged:
+                    self.unmerge()
+                result = self.base_layer(x, *args, **kwargs)
+            elif adapter_names is not None:
+                result = self._mixed_batch_forward(x, *args, adapter_names=adapter_names, **variant_kwargs, **kwargs)
+            elif self.merged:
+                result = self.base_layer(x, *args, **kwargs)
+            else:
+                result = self.base_layer(x, *args, **kwargs)
+                # As per Tim Dettmers, for 4bit, we need to defensively clone here.
+                # The reason is that in some cases, an error can occur that backprop
+                # does not work on a manipulated view. This issue may be solved with
+                # newer PyTorch versions but this would need extensive testing to be
+                # sure.
+                result = result.clone()
+
+                for active_adapter in self.active_adapters:
+                    if active_adapter not in self.lora_A.keys():
+                        continue
+                    lora_A = self.lora_A[active_adapter]
+                    lora_B = self.lora_B[active_adapter]
+                    dropout = self.lora_dropout[active_adapter]
+                    scaling = self.scaling[active_adapter]
+
+                    requires_conversion = not torch.is_autocast_enabled()
+                    if requires_conversion:
+                        expected_dtype = result.dtype
+                        x = self._cast_input_dtype(x, lora_A.weight.dtype)
+
+                    if active_adapter not in self.lora_variant:  # vanilla LoRA
+                        output = lora_B(lora_A(dropout(x))) * scaling
+                        if requires_conversion:
+                            output = output.to(expected_dtype)
+                        result = result + output
+                    else:
+                        result = self.lora_variant[active_adapter].forward(
+                            self,
+                            active_adapter=active_adapter,
+                            x=x,
+                            result=result,
+                            **variant_kwargs,
+                            **kwargs,
+                        )
+                        if requires_conversion:
+                            result = result.to(expected_dtype)
+
+            return result
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return "lora." + rep
+
+    def dispatch_bnb_4bit(target: torch.nn.Module, adapter_name: str, config: LoraConfig, **kwargs):
+        new_module = None
+
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        loaded_in_4bit = kwargs.get("loaded_in_4bit", False)
+        if loaded_in_4bit and is_bnb_4bit_available() and isinstance(target_base_layer, bnb.nn.Linear4bit):
+            fourbit_kwargs = kwargs.copy()
+            fourbit_kwargs.update(
+                {
+                    "compute_dtype": target_base_layer.compute_dtype,
+                    "compress_statistics": target_base_layer.weight.compress_statistics,
+                    "quant_type": target_base_layer.weight.quant_type,
+                }
+            )
+            new_module = Linear4bit(target, adapter_name, config=config, **fourbit_kwargs)
+
+        return new_module
diff --git a/src/peft/tuners/lora/config.py b/src/peft/tuners/lora/config.py
new file mode 100644
index 0000000..81b2798
--- /dev/null
+++ b/src/peft/tuners/lora/config.py
@@ -0,0 +1,1159 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+import importlib
+import warnings
+from dataclasses import dataclass, field
+from typing import Literal, Optional, Union
+
+from torch import nn
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class LoraRuntimeConfig:
+    """
+    This is the sub-configuration class to store the runtime configurations for the model.
+
+    Args:
+        ephemeral_gpu_offload (`bool`):
+            Whether to use ephemeral GPU offloading for models partially kept in CPU memory.
+    """
+
+    ephemeral_gpu_offload: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Whether to use ephemeral GPU offloading for models partially kept in CPU memory. Ephemeral GPU offloading result in "
+                "the data involved in intense operations being momentarily copied over to the GPU, and the results copied "
+                "back to CPU. There is a momentary VRAM overhead, but operations are generally orders of magnitude faster "
+                "compared to performing them on the CPU. This is useful when parts of the model and/or components (such "
+                "as adapters) are kept in CPU memory until they are needed. Rather than perform expensive operations on "
+                "small data, the data is transferred to the GPU on-demand, the operation(s) performed, and the results "
+                "moved back to CPU memory. Currently only affects DoRA initialization."
+            )
+        },
+    )
+
+
+@dataclass
+class VeloraConfig:
+    """
+    This is the sub-configuration class to store the configuration for VeLoRA. Original paper can be found
+    [here](https://arxiv.org/abs/2405.17991).
+
+    Args:
+        num_groups (`int`):
+            Number of feature groups used by VeLoRA to split the input activation depth before compression. Increase
+            this parameter to reduce the reconstruction error of input activations at the cost of increased memory
+            consumption.
+        scale (`float`):
+            Scale applied to the reconstructed activations in the VeLoRA backward pass.
+        init_type (`str`):
+            Projection initialization strategy for VeLoRA. Supported values are `'batch_average_once'`,
+            `'batch_average'`, and `'random'`.
+    """
+
+    num_groups: int = field(
+        default=64,
+        metadata={
+            "help": "Number of feature groups used by VeLoRA to split the input activation depth before compression."
+        },
+    )
+    scale: float = field(
+        default=1.0,
+        metadata={"help": "Scale applied to the reconstructed activations in the VeLoRA backward pass."},
+    )
+    init_type: Literal["batch_average", "batch_average_once", "random"] = field(
+        default="batch_average",
+        metadata={
+            "help": "Projection initialization strategy for VeLoRA. Supported values are "
+            "`'batch_average_once'`, `'batch_average'`, and `'random'`."
+            "batch_average uses the batch statistics during each forward pass for the projection."
+            "batch_average_once only updates the projection weights once in the first pass to reduce training time at the cost of less exact gradient approximations."
+        },
+    )
+
+    def __post_init__(self):
+        if self.num_groups <= 0:
+            raise ValueError(f"`num_groups` should be positive, got {self.num_groups}.")
+        if self.scale <= 0:
+            raise ValueError(f"`scale` should be positive, got {self.scale}.")
+        if self.init_type not in {"batch_average_once", "batch_average", "random"}:
+            raise ValueError(
+                "Unsupported `init_type` "
+                f"{self.init_type!r}. Supported values are 'batch_average_once', "
+                "'batch_average', and 'random'."
+            )
+
+
+@dataclass
+class LoftQConfig:
+    """
+    This is the sub-configuration class to store the configuration of a [`LoraModel`].
+
+    Args:
+        loftq_bits (`int`): Quantization bits for LoftQ.
+        loftq_iter (`int`): Alternating iterations for LoftQ.
+    """
+
+    loftq_bits: int = field(default=4, metadata={"help": "Quantization bits for LoftQ"})
+    loftq_iter: int = field(default=1, metadata={"help": "Alternating iterations for LoftQ"})
+
+
+@dataclass
+class ArrowConfig:
+    """
+    This is the sub-configuration class to store the configuration for Arrow and GenKnowSub algorithm. Arrow is a
+    routing algorithm to combine the trained LoRA modules to solve new tasks, proposed in
+    'https://huggingface.co/papers/2405.11157'. GenKnowSub is a refinement on the trained modules before being combined
+    via Arrow, introduced in 'https://aclanthology.org/2025.acl-short.54/'
+    """
+
+    top_k: int = field(
+        default=3,
+        metadata={"help": "Number of top LoRA modules to combine in Arrow routing."},
+    )
+
+    router_temperature: float = field(
+        default=1.0,
+        metadata={"help": "Softmax temperature for computing Arrow expert coefficients."},
+    )
+
+    use_gks: bool = field(
+        default=False,
+        metadata={"help": "Enable GenKnowSub."},
+    )
+
+    task_adapter_names: Optional[list[str]] = field(
+        default=None,
+        init=False,
+        metadata={"help": "list of task-specific LoRA adapter names. It will be set in create_arrow_model()."},
+    )
+
+    gks_adapter_names: Optional[list[str]] = field(
+        default=None,
+        init=False,
+        metadata={
+            "help": "list of general LoRA adapter names for GenKnowSub. It will be set in create_arrow_model()."
+        },
+    )
+
+    rng_seed: Optional[int] = field(
+        default=None,
+        metadata={"help": "Optional RNG seed for reproducibility. If None, sampling is non-deterministic."},
+    )
+
+    def __post_init__(self):
+        if self.top_k <= 0:
+            raise ValueError("top_k cannot be negative.")
+        if self.router_temperature <= 0:
+            raise ValueError("router_temperature must be greater than 0.")
+
+
+@dataclass
+class BdLoraConfig:
+    """
+    Configuration for BD-LoRA (Block-Diagonal LoRA). BD-LoRA is a LoRA variant that can be used for efficient
+    multi-LoRA serving in inference engines. The speedup results from reduced inter-GPU communication by setting
+    certain LoRA modules to be block-diagonal.
+
+    To determine which LoRA factors should be set as block-diagonal, follow these guidelines:
+    - For attention, set
+      - Q,K,V projections to be LoRA-B block-diagonal
+      - Out projection to be LoRA-A block-diagonal
+    - For MLPs, set
+      - Up, Gate projection to be LoRA-B block-diagonal
+      - Down projection to be LoRA-A block-diagonal
+
+    For other modules and/or architectures, look into the code of your target inference engine. Modules that are
+    row-sharded should have LoRA-A block-diagonal, modules that are column-sharded should have LoRA-B block-diagonal.
+
+    Args:
+        target_modules_bd_a:
+            Modules where the LoRA-A is block-diagonal. Matches each pattern in the list against the module name via
+            `pattern is in target_name`. Example: ['up_proj', 'q_proj', 'v_proj', 'k_proj']
+        target_modules_bd_b:
+            Modules where the LoRA-B is block-diagonal. Matches each pattern in the list against the module name via
+            `pattern is in target_name`. Example: ['out_proj', 'down_proj']
+        nblocks: Number of blocks in block-diagonal matrices
+        match_strict:
+            If set to true, requires each target_module to have either a block-diagonal LoRA-A or LoRA-B, and raises an
+            error otherwise. You can set this to False to mix LoRA and BD-LoRA training, e.g. if some layers in your
+            module do not benefit from BD-LoRA.
+    """
+
+    target_modules_bd_a: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": "Modules where the LoRA-A is block-diagonal. Matches each pattern in the list against the "
+            "module name via `pattern is in target_name`. "
+            "Usually one should specify the q,k,v,up and gate projections here. "
+            "Example: ['up_proj', 'q_proj', 'v_proj', 'k_proj']"
+        },
+    )
+    target_modules_bd_b: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": "Modules where the LoRA-B is block-diagonal. Matches each pattern in the list against the module "
+            "name via `pattern is in target_name`. Usually, one should specify out and down projections here. "
+            "Example: ['out_proj', 'down_proj']"
+        },
+    )
+    nblocks: int = (
+        field(
+            default=1,
+            metadata={
+                "help": "Number of blocks each block-diagonal matrix has. If using BD-LoRA to speed up inference, "
+                "set it to be equal to the desired sharding degree during serving."
+            },
+        ),
+    )
+    match_strict: bool = field(
+        default=True,
+        metadata={
+            "help": "If set to true, requires each target_module to have either a block-diagonal LoRA-A or LoRA-B, "
+            "and raises an error otherwise. You can set this to False to mix LoRA and BD-LoRA training, "
+            "e.g. if some layers in your module do not benefit from BD-LoRA."
+        },
+    )
+
+    def __post_init__(self):
+        overlap = set(self.target_modules_bd_a or []) & set(self.target_modules_bd_b or [])
+        if overlap:
+            raise ValueError(
+                "Found overlapping modules in target_modules_bd lists:"
+                f"{self.target_modules_bd_a} (A) and {self.target_modules_bd_b} (B)."
+            )
+
+
+@dataclass
+class EvaConfig:
+    """
+    This is the sub-configuration class to store the configuration for a data-driven initialization via EVA. EVA was
+    introduced in <a href='https://huggingface.co/papers/2410.07170'>Explained Variance Adaptation</a>.
+
+    Args:
+        rho (`float`):
+            Rho value for EVA redistribution (>= 1.0). The maximum rank for a layer is lora_r * rho. Default is 2.0,
+            meaning the maximum rank allowed for a layer is 2r. Increasing rho will allow for a higher degree of
+            redistribution of ranks across layers. Some pre-trained models might be more sensitive to a rank
+            redistribution. It can therefore be beneficial to try rho=1.0 (no redistribution) if the performance is
+            lower than expected.
+        tau (`float`):
+            Cosine similarity threshold for early stopping. Compares the cosine similarity of right-singular vectors
+            between two consecutive SVD steps. If the cosine similarity is above this threshold, the SVD iteration is
+            stopped. Default is 0.99.
+        use_label_mask (`bool`):
+            Use label mask for EVA initialization. This means that positions where labels=label_mask_value are ignored
+            for the SVD computation. Setting use_label_mask=True is preferred in most cases and can be especially
+            beneficial for multi-turn conversations. The default value is True. Filtering out items based on the label
+            mask can sometimes lead to a small batch size and as a result instabilities in the SVD computation. For
+            cases where a large share of batch items would be filtered out, set use_label_mask=False.
+        label_mask_value (`int`):
+            If use_label_mask=True the value to look for to mask out ignored tokens. Default is -100.
+        whiten (`bool`): Apply whitening to singular vectors. Default is False.
+            Whitening has been shown to be beneficial for EVA in the vision domain.
+        adjust_scaling_factors (`bool`):
+            Adjust LoRA scaling factors after the rank redistribution. Setting this to True means the scaling factors
+            are adjusted so that all LoRA gradients have the same scale regardless of their rank. Default is True.
+    """
+
+    rho: float = field(default=2.0, metadata={"help": "Rho value for EVA redistribution"})
+    tau: float = field(default=0.99, metadata={"help": "Cosine similarity threshold for early stopping"})
+    use_label_mask: bool = field(default=True, metadata={"help": "Use label mask for EVA initialization"})
+    label_mask_value: int = field(
+        default=-100, metadata={"help": "if use_label_mask=True the value to look for to mask out ignored tokens"}
+    )
+    whiten: bool = field(default=False, metadata={"help": "Apply whitening to singular vectors"})
+    adjust_scaling_factors: bool = field(
+        default=True,
+        metadata={"help": "Adjust LoRA scaling factors after the rank redistribution"},
+    )
+
+    def __post_init__(self):
+        if self.rho < 1.0:
+            raise ValueError("`rho` must be >= 1.0")
+        if self.tau < 0.0 or self.tau > 1.0:
+            raise ValueError("`tau` must be between 0.0 and 1.0.")
+
+
+@dataclass
+class CordaConfig:
+    """
+    This is the sub-configuration class to store the configuration of a [`LoraModel`].
+
+    Args:
+        cache_file (`Optional[str]`):
+            File to store the SVD cache. The SVD cache is much smaller than the residual model (for example, residual
+            model of Llama-3-8b is 15GB, while SVD cache is 1.4GB), but with SVD cache and original model weights,
+            residual model weights can be built quickly. If you need to reuse residual model weights with limited
+            storage, you can store the SVD cache instead.
+        covariance_file (`Optional[str]`):
+            File to store the covariance matrix. If you wish to train multiple models with different ranks, but they
+            sample from the same dataset, you can store the covariance matrix and reuse it for different ranks. Note
+            that covariance file is usually large (comparable to model size), so you will need sufficient storage.
+        corda_method (`Literal["ipm", "kpm"]`):
+            Method to build adapter. The KPM (Knowledge-Preserved Mode) not only achieves better performance than LoRA
+            on fine-tuning tasks, but also mitigates the catastrophic forgetting of pre-trained world knowledge. When
+            preserving pre-trained knowledge is not a concern, the IPM (Instruction-Previewed Mode) is favored because
+            it can further accelerate convergence and enhance the fine-tuning performance. Defaults to `'ipm'`.
+        verbose (`bool`):
+            If true, prints the progress of CorDA initialization. Defaults to `False`.
+        use_float16_for_covariance (`bool`):
+            If true, uses float16 for the covariance matrix. This can reduce the memory usage of the covariance matrix
+            by half, but may lead to numerical instability. Defaults to `False`.
+        prune_temporary_fields (`bool`):
+            If true, temporary fields generated in CorDA preprocessing will be pruned. Defaults to `True`.
+    """
+
+    cache_file: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": (
+                "File to store the SVD cache. The SVD cache is much smaller than the residual model (for example, "
+                "residual model of Llama-3-8b is 15GB, while SVD cache is 1.4GB), but with SVD cache and original model "
+                "weights, residual model weights can be built quickly. If you need to reuse residual model weights with "
+                "limited storage, you can store the SVD cache instead."
+            )
+        },
+    )
+    covariance_file: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": (
+                "File to store the covariance matrix. If you wish to train multiple models with different ranks, but "
+                "they sample from the same dataset, you can store the covariance matrix and reuse it for different ranks. "
+                "Note that covariance file is usually large (comparable to model size), so you will need sufficient storage."
+            )
+        },
+    )
+    corda_method: Literal["ipm", "kpm"] = field(
+        default="ipm",
+        metadata={
+            "help": (
+                "Method to build adapter. The KPM not only achieves better performance than LoRA on fine-tuning tasks, but "
+                "also mitigates the catastrophic forgetting of pre-trained world knowledge. When preserving pre-trained "
+                "knowledge is not a concern, the IPM is favored because it can further accelerate convergence and enhance "
+                "the fine-tuning performance."
+            )
+        },
+    )
+    verbose: bool = field(default=False, metadata={"help": "If true, prints the progress of CorDA initialization."})
+    use_float16_for_covariance: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "If true, uses float16 for the covariance matrix. This can reduce the memory usage of the covariance matrix "
+                "by half, but may lead to numerical instability."
+            )
+        },
+    )
+    prune_temporary_fields: bool = field(
+        default=True, metadata={"help": "If true, temporary fields generated in CorDA preprocessing will be pruned."}
+    )
+
+
+@dataclass
+class LoraConfig(PeftConfig):
+    """
+    This is the configuration class to store the configuration of a [`LoraModel`].
+
+    Args:
+        r (`int`):
+            Lora attention dimension (the "rank").
+        target_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to apply the adapter to. If this is specified, only the modules with the specified
+            names will be replaced. When passing a string, a regex match will be performed. When passing a list of
+            strings, either an exact match will be performed or it is checked if the name of the module ends with any
+            of the passed strings. If this is specified as 'all-linear', then all linear/Conv1D modules are chosen (if
+            the model is a PreTrainedModel, the output layer excluded). If this is not specified, modules will be
+            chosen according to the model architecture. If the architecture is not known, an error will be raised -- in
+            this case, you should specify the target modules manually. To avoid targeting any modules (because you want
+            to apply `target_parameters`), set `target_modules=[]`.
+        exclude_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to not apply the adapter. When passing a string, a regex match will be performed.
+            When passing a list of strings, either an exact match will be performed or it is checked if the name of the
+            module ends with any of the passed strings.
+        lora_alpha (`int`):
+            The alpha parameter for Lora scaling.
+        lora_dropout (`float`):
+            The dropout probability for Lora layers.
+        fan_in_fan_out (`bool`):
+            Set this to True if the layer to replace stores weight like (fan_in, fan_out). For example, gpt-2 uses
+            `Conv1D` which stores weights like (fan_in, fan_out) and hence this should be set to `True`.
+        bias (`str`):
+            Bias type for LoRA. Can be 'none', 'all' or 'lora_only'. If 'all' or 'lora_only', the corresponding biases
+            will be updated during training. Be aware that this means that, even when disabling the adapters, the model
+            will not produce the same output as the base model would have without adaptation.
+        use_rslora (`bool`):
+            When set to True, uses [Rank-Stabilized LoRA](https://huggingface.co/papers/2312.03732) which sets the
+            adapter scaling factor to `lora_alpha/math.sqrt(r)`, since it was proven to work better. Otherwise, it will
+            use the original default value of `lora_alpha/r`.
+        modules_to_save (`List[str]`):
+            List of modules apart from adapter layers to be set as trainable and saved in the final checkpoint.
+        init_lora_weights (`bool` | `Literal["gaussian", "eva", "olora", "pissa", "pissa_niter_[number of iters]", "corda", "loftq", "orthogonal", "mica"]`):
+            How to initialize the weights of the adapter layers. Passing True (default) results in the default
+            initialization from the reference implementation from Microsoft, with the LoRA B weight being set to 0.
+            This means that without further training, the LoRA adapter will be a no-op. Setting the initialization to
+            False leads to random initialization of LoRA A and B, meaning that LoRA is not a no-op before training;
+            this setting is intended for debugging purposes. Passing 'gaussian' results in Gaussian initialization
+            scaled by the LoRA rank for linear and layers. Pass `'loftq'` to use LoftQ initialization. Passing `'eva'`
+            results in a data-driven initialization of <a href='https://huggingface.co/papers/2410.07170' >Explained
+            Variance Adaptation</a>. EVA initializes LoRA based on the SVD of layer input activations and achieves SOTA
+            performance due to its ability to adapt to the finetuning data. Pass `'olora'` to use OLoRA initialization.
+            Passing `'pissa'` results in the initialization of <a href='https://huggingface.co/papers/2404.02948'
+            >Principal Singular values and Singular vectors Adaptation (PiSSA)</a>, which converges more rapidly than
+            LoRA and ultimately achieves superior performance. Moreover, PiSSA reduces the quantization error compared
+            to QLoRA, leading to further enhancements. Passing `'pissa_niter_[number of iters]'` initiates
+            Fast-SVD-based PiSSA initialization, where `[number of iters]` indicates the number of subspace iterations
+            to perform FSVD, and must be a nonnegative integer. When `[number of iters]` is set to 16, it can complete
+            the initialization of a 7B model within seconds, and the training effect is approximately equivalent to
+            using SVD. Passing `'corda'` results in the initialization of <a
+            href='https://huggingface.co/papers/2406.05223' >Context-Oriented Decomposition Adaptation</a>, which
+            converges even more rapidly than PiSSA in Instruction-Previewed Mode, and preserves world knowledge better
+            than LoRA in Knowledge-Preserved Mode. Passing `"orthogonal"` results in LoRA A and B being initialized
+            orthogonally; in this, it resembles `"olora"`, but the base weights are left untouched (requires `r` to be
+            even, only supported for linear layers for now). Passing `"mica"` results in the initialization of <a
+            href='https://arxiv.org/abs/2604.01694' >Minor Component Adaptation (MiCA)</a>, which initializes B from
+            the r left singular vectors of the base weight associated with the smallest singular values, sets A to
+            zero, and freezes B during training; only A is updated. Currently supported for linear and embedding
+            layers.
+        layers_to_transform (`Union[List[int], int]`):
+            The layer indices to transform. If a list of ints is passed, it will apply the adapter to the layer indices
+            that are specified in this list. If a single integer is passed, it will apply the transformations on the
+            layer at this index.
+        layers_pattern (`Optional[Union[List[str], str]]`):
+            The layer pattern name, used only if `layers_to_transform` is different from `None`. This should target the
+            `nn.ModuleList` of the model, which is often called `'layers'` or `'h'`.
+        rank_pattern (`dict`):
+            The mapping from layer names or regexp expression to ranks which are different from the default rank
+            specified by `r`. For example, `{'^model.decoder.layers.0.encoder_attn.k_proj': 16}`.
+        alpha_pattern (`dict`):
+            The mapping from layer names or regexp expression to alphas which are different from the default alpha
+            specified by `lora_alpha`. For example, `{'^model.decoder.layers.0.encoder_attn.k_proj': 16}`.
+        megatron_config (`Optional[dict]`):
+            The TransformerConfig arguments for Megatron. It is used to create LoRA's parallel linear layer. You can
+            get it like this, `core_transformer_config_from_args(get_args())`, these two functions being from Megatron.
+            The arguments will be used to initialize the TransformerConfig of Megatron. You need to specify this
+            parameter when you want to apply LoRA to the ColumnParallelLinear and RowParallelLinear layers of megatron.
+        megatron_core (`Optional[str]`):
+            The core module from Megatron to use, defaults to `"megatron.core"`.
+        trainable_token_indices (`Optional[Union[List[int], dict[str, List[int]]]]`)
+            Lets you specify which token indices to selectively fine-tune without requiring to re-train the whole
+            embedding matrix using the `peft.TrainableTokensModel` method. You can specify token indices in two ways.
+            Either you specify a list of indices which will then target the model's input embedding layer (or, if not
+            found, `embed_tokens`). Alternatively, you can specify a dictionary where the key is the name of the
+            embedding module and the values are the list of token indices, e.g. `{'embed_tokens': [0, 1, ...]}`. Note
+            that training with FSDP requires `use_orig_params=True` to avoid issues with non-uniform `requires_grad`.
+        loftq_config (`Optional[LoftQConfig]`):
+            The configuration of LoftQ. If this is not None, then LoftQ will be used to quantize the backbone weights
+            and initialize Lora layers. Also pass `init_lora_weights='loftq'`. Note that you should not pass a
+            quantized model in this case, as LoftQ will quantize the model itself.
+        eva_config (`Optional[EvaConfig]`):
+            The configuration of EVA. At a minimum the dataset argument needs to be set (use the same dataset as for
+            finetuning).
+        corda_config (`Optional[CordaConfig]`):
+            The configuration of CorDA. If this is not None, then CorDA will be used to build the adapter layers. Also
+            pass `init_lora_weights='corda'`.
+        lora_ga_config (`Optional[LoraGAConfig]`):
+            The configuration of LoRA-GA. If this is passed, then LoRA-GA will be used to initialize the adapter
+            layers. Also set `init_lora_weights='lora_ga'` in this case.
+        use_dora (`bool`):
+            Enable 'Weight-Decomposed Low-Rank Adaptation' (DoRA). This technique decomposes the updates of the weights
+            into two parts, magnitude and direction. Direction is handled by normal LoRA, whereas the magnitude is
+            handled by a separate learnable parameter. This can improve the performance of LoRA especially at low
+            ranks. Right now, DoRA only supports linear and Conv2D layers. DoRA introduces a bigger overhead than pure
+            LoRA, so it is recommended to merge weights for inference. For more information, see
+            https://huggingface.co/papers/2402.09353.
+        velora_config (`Optional[VeloraConfig]`):
+            Enable VeLoRA by providing a VeloraConfig. VeLoRA swaps in a custom backward pass for the LoRA A projection
+            that stores compressed activations instead of the full input activations.
+        alora_invocation_tokens (`List[int]`):
+            If not None, enable <a href='https://huggingface.co/papers/2504.12397'>'Activated LoRA' (aLoRA)</a>, with
+            alora_invocation_tokens being the tokenized invocation string for the adapter (must be present in all model
+            input strings). This technique selectively activates the adapter weights only on tokens during and after
+            the alora_invocation_tokens. When used in a CausalLM, this means that the KV cache prior to invocation is
+            interchangeable with that of the base model (and other aLoRA adapters operating this way). As a result, in
+            inference pipelines involving switching between base model inference and adapter inference (e.g. agentic
+            pipelines, see paper for examples), significant savings are realized (relative to LoRA) by saving prefill
+            operations. Overall adapter inference speedups of an order of magnitude or more can occur on vLLM,
+            depending on the length of the shared context. Note that merging is not possible due to the selective
+            application of the weights.
+        use_qalora (`bool`):
+            It is only implemented in GPTQ for now. Enable <a
+            href='https://huggingface.co/papers/2309.14717'>Quantization-Aware Low-Rank Adaptation (QALoRA)</a>. This
+            technique combines quantization-aware training with LoRA to improve performance for quantized models. This
+            can improve the performance of LoRA, especially at low ranks. Right now, QALoRA only supports linear
+            layers.
+        qalora_group_size (`int`):
+            Group size parameter for QALoRA pooling, controlling the dimension reduction factor. Input dimensions are
+            pooled into groups of this size, reducing the computational cost. Higher values provide more compression
+            but may reduce model quality. This parameter determines how many original features are averaged together to
+            create one pooled feature. Only used when `use_qalora=True`.
+        monteclora_config (`Optional[MontecloraConfig]`):
+            The configuration of Monteclora (Monte Carlo Low-Rank Adaptation). If passed, Monteclora will be used to
+            add variational Monte Carlo sampling on top of the LoRA adapters. See `MontecloraConfig` for details on the
+            individual hyperparameters.
+        layer_replication (`List[Tuple[int, int]]`):
+            Build a new stack of layers by stacking the original model layers according to the ranges specified. This
+            allows expanding (or shrinking) the model without duplicating the base model weights. The new layers will
+            all have separate LoRA adapters attached to them.
+        runtime_config (`LoraRuntimeConfig`):
+            Runtime configurations (which are not saved or restored).
+        lora_bias (`bool`):
+            Defaults to `False`. Whether to enable the bias term for the LoRA B parameter. Typically, this should be
+            disabled. The main use case for this is when the LoRA weights were extracted from fully fine-tuned
+            parameters so the bias of those parameters can be taken into account.
+        target_parameters (`List[str]`, *optional*)
+            List of parameter names of the parameter names to replace with LoRA. This argument behaves similarly to
+            `target_modules`, except that the parameter name should be passed. Generally, you should use
+            `target_modules` to target the module (e.g. `nn.Linear`). However, in some circumstances, this is not
+            possible. E.g., in many mixture of expert (MoE) layers in HF Transformers, instead of using `nn.Linear`, an
+            `nn.Parameter` is used. PEFT normally overwrites the `forward` method for LoRA, but for `nn.Parameter`,
+            there is none. Therefore, to apply LoRA to that parameter, it needs to be targeted with
+            `target_parameters`. As an example, for Llama4, you can pass:
+            `target_parameters=['feed_forward.experts.gate_up_proj', 'feed_forward.experts.down_proj]`. Passing a
+            string for regex matching is not implemented yet. Note that when the model is compiled and uses
+            `target_parameters`, re-compilation and/or graph breaks are expected. It is recommended not to use both at
+            the same time.
+        use_bdlora (`Optional[BdLoraConfig]`):
+            Enable BD-LoRA (Block-Diagonal LoRA) by providing a BdLoraConfig. This technique uses block-diagonal
+            matrices for LoRA-A or LoRA-B factors to enable faster multi-LoRA serving by eliminating communication
+            overheads in distributed settings.
+        arrow_config (`Optional[ArrowConfig]`):
+            The necessary config to apply arrow routing on the model.
+        ensure_weight_tying (`bool`, *optional*)
+            Whether to tie weights or not after peft initialization. This will ensure that the adapters added to the
+            tied layers are also tied. This is only applicable for layers passed via `modules_to_save` and
+            `target_modules`.
+
+    """
+
+    r: int = field(default=8, metadata={"help": "Lora attention dimension"})
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of module names of the module names to replace with LoRA. "
+                "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'. "
+                "This can also be a wildcard 'all-linear' which matches all linear/Conv1D "
+                "(if the model is a PreTrainedModel, the output layer excluded). "
+                "If not specified, modules will be chosen according to the model architecture, If the architecture is "
+                "not known, an error will be raised -- in this case, you should specify the target modules manually. "
+                "To avoid targeting any modules (because you want to apply `target_parameters`), set "
+                "`target_modules=[]`."
+            ),
+        },
+    )
+    exclude_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={"help": "List of module names or regex expression of the module names to exclude from Lora."},
+    )
+    lora_alpha: int = field(default=8, metadata={"help": "Lora alpha"})
+    lora_dropout: float = field(default=0.0, metadata={"help": "Lora dropout"})
+    fan_in_fan_out: bool = field(
+        default=False,
+        metadata={"help": "Set this to True if the layer to replace stores weight like (fan_in, fan_out)"},
+    )
+    bias: Literal["none", "all", "lora_only"] = field(
+        default="none", metadata={"help": "Bias type for Lora. Can be 'none', 'all' or 'lora_only'"}
+    )
+    use_rslora: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "When set to True, uses [Rank-Stabilized LoRA](https://huggingface.co/papers/2312.03732)"
+                " which sets the adapter scaling factor to `lora_alpha/math.sqrt(r)`, since it"
+                " was proven to work better. Otherwise, it will use the original default"
+                " value of `lora_alpha/r`."
+            )
+        },
+    )
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": "List of modules apart from LoRA layers to be set as trainable and saved in the final checkpoint. "
+            "For example, in Sequence Classification or Token Classification tasks, "
+            "the final layer `classifier/score` are randomly initialized and as such need to be trainable and saved."
+        },
+    )
+    init_lora_weights: (
+        bool
+        | Literal[
+            "gaussian",
+            "eva",
+            "olora",
+            "pissa",
+            "pissa_niter_[number of iters]",
+            "corda",
+            "loftq",
+            "orthogonal",
+            "mica",
+        ]
+    ) = field(
+        default=True,
+        metadata={
+            "help": (
+                "How to initialize the weights of the LoRA layers. "
+                "Passing True (default) results in the default initialization from the reference implementation from "
+                "Microsoft, with the LoRA B weight being set to 0. This means that without further training, the LoRA "
+                "adapter will be a no-op. "
+                "Setting the initialization to False leads to random initialization of LoRA A and B, meaning that LoRA "
+                "is not a no-op before training; this setting is intended for debugging purposes. "
+                "Passing `'gaussian'` results in Gaussian initialization scaled by the LoRA rank for linear and layers. "
+                "Passing `'eva'` results in a data-driven initialization of Explained Variance Adaptation. "
+                "Passing `'olora'` results in OLoRA initialization. "
+                "Passing `'pissa'` results in PiSSA initialization. "
+                "Passing `'pissa_niter_[number of iters]'` initiates Fast-SVD-based PiSSA initialization, where "
+                "[number of iters] indicates the number of subspace iterations to perform fsvd, and must be a "
+                "nonnegative integer. "
+                "Passing `'corda'` results in CorDA initialization. "
+                "Pass `'loftq'` to use LoftQ initialization. "
+                "Pass `'orthogonal'` for orthogonal initialization of LoRA A and B. "
+                "Pass `'mica'` to use MiCA initialization, where B is set to the r left singular vectors of the "
+                "base weight associated with the smallest singular values, A is set to zero, and B is frozen during "
+                "training (only A is updated)."
+            ),
+            # lora_variants: lists the string values (or prefixes) of init_lora_weights
+            # that activate a LoRA variant (e.g. "mica" activates MiCALinearVariant).
+            "lora_variants": ["mica"],
+        },
+    )
+    layers_to_transform: Optional[Union[list[int], int]] = field(
+        default=None,
+        metadata={
+            "help": "The layer indexes to transform, is this argument is specified, PEFT will transform only the layers indexes that are specified inside this list. If a single integer is passed, PEFT will transform only the layer at this index. "
+            "This only works when target_modules is a list of str."
+        },
+    )
+    layers_pattern: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": "The layer pattern name, used only if `layers_to_transform` is different to None and if the layer pattern is not in the common layers pattern."
+            "This only works when target_modules is a list of str. This should target the `nn.ModuleList` of the "
+            "model, which is often called `'layers'` or `'h'`."
+        },
+    )
+    rank_pattern: Optional[dict] = field(
+        default_factory=dict,
+        metadata={
+            "help": (
+                "The mapping from layer names or regexp expression to ranks which are different from the default rank specified by `r`. "
+                "For example, `{'^model.decoder.layers.0.encoder_attn.k_proj': 16}`."
+            )
+        },
+    )
+    alpha_pattern: Optional[dict] = field(
+        default_factory=dict,
+        metadata={
+            "help": (
+                "The mapping from layer names or regexp expression to alphas which are different from the default alpha specified by `lora_alpha`. "
+                "For example, `{'^model.decoder.layers.0.encoder_attn.k_proj': 16}`."
+            )
+        },
+    )
+    megatron_config: Optional[dict] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The TransformerConfig from Megatron. It is used to create LoRA's parallel linear layer."
+                "You can get it like this, `core_transformer_config_from_args(get_args())`, "
+                "these two functions being from Megatron."
+                "You need to specify this parameter when you want to apply LoRA to the ColumnParallelLinear and "
+                "RowParallelLinear layers of megatron."
+                "It should be noted that we may not be able to use the `save_pretrained` and `from_pretrained` "
+                "functions, because TransformerConfig may not necessarily be serialized."
+                "But when using megatron, we can use `get_peft_model_state_dict` function and "
+                "megatron's framework, they can also save and load models and configurations."
+            )
+        },
+    )
+    megatron_core: Optional[str] = field(
+        default="megatron.core",
+        metadata={
+            "help": (
+                "The core module from Megatron, it is used to create LoRA's parallel linear layer. "
+                "It only needs to be passed in when you need to use your own modified megatron core module. "
+                "Otherwise, it will use the default value `megatron.core`. "
+            )
+        },
+    )
+    trainable_token_indices: Optional[Union[list[int], dict[str, list[int]]]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "Lets you specify which token indices to selectively fine-tune without requiring to re-train the "
+                "whole embedding matrix using the `peft.TrainableTokensModel` method. You can specify token indices "
+                "in two ways. Either you specify a list of indices which will then target the model's input embedding "
+                "layer (or, if not found, `embed_tokens`). Alternatively, you can specify a dictionary where the key "
+                "is the name of the embedding module and the values are the list of token indices, e.g. "
+                "`{'embed_tokens': [0, 1, ...]}`. Note that training with FSDP requires `use_orig_params=True` to "
+                "avoid issues with non-uniform `requires_grad`."
+            )
+        },
+    )
+    # dict type is used when loading config.json
+    loftq_config: Union[LoftQConfig, dict] = field(
+        default_factory=dict,
+        metadata={
+            "help": (
+                "The configuration of LoftQ. If this is passed, then LoftQ will be used to quantize the backbone "
+                "weights and initialize Lora layers. Also set `init_lora_weights='loftq'` in this case."
+            )
+        },
+    )
+    eva_config: Optional[EvaConfig] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The configuration of EVA. If this is passed, then EVA will be used to initialize the LoRA layers. "
+                "Also set `init_lora_weights='eva'` in this case. "
+            )
+        },
+    )
+    corda_config: Optional[CordaConfig] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The configuration of CorDA. If this is passed, then CorDA will be used to build the adapter layers. "
+                "Also set `init_lora_weights='corda'` in this case."
+            )
+        },
+    )
+    lora_ga_config: Optional[LoraGAConfig] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The configuration of LoRA-GA. If this is passed, then LoRA-GA will be used to initialize the adapter layers. "
+                "Also set `init_lora_weights='lora_ga'` in this case."
+            )
+        },
+    )
+    use_dora: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Enable <a href='https://huggingface.co/papers/2402.09353'>'Weight-Decomposed Low-Rank Adaptation' (DoRA)</a>. This technique decomposes the updates of the "
+                "weights into two parts, magnitude and direction. Direction is handled by normal LoRA, whereas the "
+                "magnitude is handled by a separate learnable parameter. This can improve the performance of LoRA, "
+                "especially at low ranks. Right now, DoRA only supports linear and Conv2D layers. DoRA introduces a bigger"
+                "overhead than pure LoRA, so it is recommended to merge weights for inference."
+            ),
+            "is_lora_variant": True,
+        },
+    )
+    velora_config: Optional[Union[VeloraConfig, dict]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "Enable VeLoRA as a LoRA variant by providing a VeloraConfig. VeLoRA swaps in a custom backward pass "
+                "for the LoRA A projection that stores compressed activations instead of the full input activations."
+            ),
+            "is_lora_variant": True,
+        },
+    )
+    alora_invocation_tokens: Optional[list[int]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "If not None, enable <a href='https://huggingface.co/papers/2504.12397'>'Activated LoRA' (aLoRA)</a>, with "
+                "alora_invocation_tokens being the tokenized invocation string for the adapter (must be present in all model "
+                "input strings). This technique selectively activates the adapter weights only on tokens during and after "
+                "the alora_invocation_tokens. When used in a CausalLM, this means that the KV cache prior to invocation is "
+                "interchangeable with that of the base model (and other aLoRA adapters operating this way). As a result, in "
+                "inference pipelines involving switching between base model inference and adapter inference (e.g. agentic "
+                "pipelines, see paper for examples), significant savings are realized (relative to LoRA) by saving prefill "
+                "operations. Overall adapter inference speedups of an order of magnitude or more can occur on vLLM, "
+                "depending on the length of the shared context. Note that merging is not possible due to the selective "
+                "application of the weights."
+            ),
+            "is_lora_variant": True,
+        },
+    )
+    use_qalora: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "It is only implemented in GPTQ for now. Enable <a href='https://huggingface.co/papers/2309.14717'>Quantization-Aware Low-Rank Adaptation (QALoRA)</a>."
+                "This technique combines quantization-aware training "
+                "with LoRA to improve performance for quantized models. This can improve the performance of LoRA, "
+                "especially at low ranks. Right now, QALoRA only supports linear layers."
+            )
+        },
+    )
+    qalora_group_size: int = field(
+        default=16,
+        metadata={
+            "help": (
+                "Group size parameter for QALoRA pooling, controlling the dimension reduction factor. "
+                "Input dimensions are pooled into groups of this size, reducing the computational cost. "
+                "Higher values provide more compression but may reduce model quality. "
+                "This parameter determines how many original features are averaged together to create "
+                "one pooled feature. Only used when `use_qalora=True`."
+            )
+        },
+    )
+
+    monteclora_config: Optional[MontecloraConfig] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The configuration of Monteclora (Monte Carlo Low-Rank Adaptation). If passed, Monteclora will be "
+                "used to add variational Monte Carlo sampling on top of the LoRA adapters. See `MontecloraConfig` "
+                "for details on the individual hyperparameters."
+            ),
+            "is_lora_variant": True,
+        },
+    )
+    # Enables replicating layers in a model to expand it to a larger model.
+    layer_replication: Optional[list[tuple[int, int]]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "This enables using LoRA to effectively expand a transformer model to a larger size by repeating some layers. "
+                "The transformation handles models (currently Llama, Bert or Falcon compatible architectures) with "
+                "a module list in the model which it modifies to expand the number of modules. "
+                "Base weights are shared so the memory usage is close to the original model. The intended use is these base weights "
+                "remain fixed during finetuning but each layer has a separate LoRA adapter so the layers can be specialed via "
+                "the adapter layers fit during fine tuning."
+                "The format is a list of [start, end) pairs which specify the layer ranges to stack. For example:\n"
+                "   Original model has 5 layers labelled by their position in the model: `[0, 1, 2, 3, 4]`\n"
+                "   layer_replication: `[[0, 4], [2, 5]]`\n"
+                "   Final model will have this arrangement of original layers: `[0, 1, 2, 3, 2, 3, 4]`\n"
+                "This format is based on what is used for pass-through merges in mergekit. It makes it simple to select sequential "
+                "ranges of a model and stack them while reusing layers at either end of each sequence."
+            )
+        },
+    )
+    runtime_config: LoraRuntimeConfig = field(
+        default_factory=LoraRuntimeConfig, metadata={"help": "Runtime configurations"}
+    )
+    lora_bias: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Whether to enable the bias term for the LoRA B parameter. Typically, this should be disabled. The "
+                "main use case for this is when the LoRA weights were extracted from fully fine-tuned parameters so "
+                "the bias of those parameters can be taken into account."
+            )
+        },
+    )
+    target_parameters: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of parameter names or regex expression of the parameter names to replace with LoRA. "
+                "This argument behaves similarly to `target_modules`, except that the parameter name should be passed. "
+                "Generally, you should use `target_modules` to target the module (e.g. `nn.Linear`). However, in some "
+                "circumstances, this is not possible. E.g., in many mixture of expert (MoE) layers in HF Transformers, "
+                "instead of using `nn.Linear`, an `nn.Parameter` is used. PEFT normally overwrites the `forward` "
+                "method for LoRA, but for `nn.Parameter`, there is none. Therefore, to apply LoRA to that parameter, "
+                "it needs to be targeted with `target_parameters`. As an example, for Llama4, you can pass: "
+                "`target_parameters=['feed_forward.experts.gate_up_proj', 'feed_forward.experts.down_proj]`. Passing a "
+                "string for regex matching is not implemented yet. Note that when the model is compiled and uses "
+                "`target_parameters`, re-compilation and/or graph breaks are expected. It is recommended not to use "
+                "both at the same time."
+            )
+        },
+    )
+    use_bdlora: Optional[BdLoraConfig] = field(
+        default=None,
+        metadata={
+            "help": (
+                "Enable BD-LoRA (Block-Diagonal LoRA) by providing a BdLoraConfig. This technique uses block-diagonal matrices for LoRA-A or LoRA-B "
+                "factors to enable faster multi-LoRA serving by eliminating communication overheads in distributed settings."
+            ),
+            "is_lora_variant": True,
+        },
+    )
+    arrow_config: Optional[ArrowConfig] = field(
+        default=None,
+        metadata={
+            "help": "The necessary config to apply arrow routing on the model.",
+            "is_lora_variant": True,
+        },
+    )
+    ensure_weight_tying: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Whether to tie weights or not after peft initialization. "
+                "This will ensure that the adapters added to the tied layers "
+                "are also tied. This is only applicable for layers passed via "
+                "`modules_to_save`, `target_modules` and `trainable_token_indices`."
+            )
+        },
+    )
+
+    def to_dict(self):
+        """
+        Returns the configuration for your adapter model as a dictionary. Removes runtime configurations.
+        """
+        rv = super().to_dict()
+        rv.pop("runtime_config")
+        return rv
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.LORA
+        if isinstance(self.monteclora_config, dict):
+            self.monteclora_config = MontecloraConfig(**self.monteclora_config)
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        self.exclude_modules = (
+            set(self.exclude_modules) if isinstance(self.exclude_modules, list) else self.exclude_modules
+        )
+
+        if self.ensure_weight_tying:
+            self.modules_to_tie = None
+            self.target_modules_to_tie = None
+
+        if isinstance(self.velora_config, dict):
+            self.velora_config = VeloraConfig(**self.velora_config)
+        elif self.velora_config is not None and not isinstance(self.velora_config, VeloraConfig):
+            raise TypeError("`velora_config` must be a `VeloraConfig`, a dict, or None.")
+
+        if isinstance(self.target_parameters, str):
+            raise TypeError("`target_parameters` must be a list of strings or None.")
+
+        # if target_modules is a regex expression, then layers_to_transform should be None
+        if isinstance(self.target_modules, str) and self.layers_to_transform is not None:
+            raise ValueError("`layers_to_transform` cannot be used when `target_modules` is a str.")
+
+        # if target_modules is a regex expression, then layers_pattern should be None
+        if isinstance(self.target_modules, str) and self.layers_pattern is not None:
+            raise ValueError("`layers_pattern` cannot be used when `target_modules` is a str.")
+
+        # check for layers_to_transform and layers_pattern
+        if self.layers_pattern and not self.layers_to_transform:
+            raise ValueError("When `layers_pattern` is specified, `layers_to_transform` must also be specified. ")
+
+        if self.use_dora and self.megatron_config:
+            raise ValueError("DoRA does not support megatron_core, please set `use_dora=False`.")
+
+        # handle init_lora_weights and loftq_config
+        if self.init_lora_weights == "loftq":
+            if not importlib.util.find_spec("scipy"):
+                raise ImportError("The required package 'scipy' is not installed. Please install it to continue.")
+            if not self.loftq_config:
+                raise ValueError("`loftq_config` must be specified when `init_lora_weights` is 'loftq'.")
+            if not isinstance(self.loftq_config, dict):
+                # convert loftq_config to dict
+                self.loftq_config = vars(self.loftq_config)
+        elif self.loftq_config:
+            self.loftq_config = {}
+            warnings.warn("`loftq_config` specified but will be ignored when `init_lora_weights` is not 'loftq'.")
+
+        elif self.init_lora_weights == "eva" and self.eva_config is None:
+            warnings.warn("`init_lora_weights` is 'eva' but `eva_config` is not specified. Using default EVA config.")
+            self.eva_config = EvaConfig()
+        elif self.init_lora_weights != "eva" and self.eva_config is not None:
+            warnings.warn("`eva_config` specified but will be ignored when `init_lora_weights` is not 'eva'.")
+
+        elif self.init_lora_weights == "corda" and self.corda_config is None:
+            warnings.warn(
+                "`init_lora_weights` is 'corda' but `corda_config` is not specified. Using default CorDA config."
+            )
+            self.corda_config = CordaConfig()
+        elif self.init_lora_weights != "corda" and self.corda_config is not None:
+            warnings.warn("`corda_config` specified but will be ignored when `init_lora_weights` is not 'corda'.")
+
+        if self.lora_bias:
+            if self.init_lora_weights not in (True, False):
+                raise ValueError(
+                    f"The argument lora_bias=True is only supported with init_lora_weights=True or False, got "
+                    f"init_lora_weights={self.init_lora_weights} instead."
+                )
+            if self.use_dora:
+                raise ValueError("The argument lora_bias=True is not supported for DoRA, please pass use_dora=False")
+
+        if self.alora_invocation_tokens is not None and self.task_type != "CAUSAL_LM":
+            warnings.warn("aLoRA is currently only supported for CAUSAL_LM task.")
+
+        # Using post training conversion of modified base weights to restore their initial values PiSSA/CorDA/OLoRA/LoRA-GA cannot
+        # be correctly done when using rslora + rank_pattern/alpha_pattern. We can't really know if the user intends
+        # this when they'll eventually call save_pretrained (i.e. if they'll pass
+        # path_initial_model_for_weight_conversionl). Therefore, we only warn but don't raise an error here.
+        if (
+            self.use_rslora
+            and (self.rank_pattern or self.alpha_pattern)
+            and (
+                (isinstance(self.init_lora_weights, str) and (self.init_lora_weights.startswith("pissa")))
+                or (self.init_lora_weights == "olora")
+                or (self.init_lora_weights == "corda")
+                or (self.init_lora_weights == "lora_ga")
+            )
+        ):
+            msg = (
+                "Using Rank-Stabilized LoRA with rank_pattern/alpha_pattern and post-training conversion of modified "
+                "base weights PiSSA/CorDA/OLoRA/LoRA-GA means that you won't be able to pass "
+                "`path_initial_model_for_weight_conversion` to `save_pretrained` to restore the initial values of the "
+                "base weights; if you intend to do this, please ensure not to use rslora or rank_pattern/alpha_pattern."
+            )
+            warnings.warn(msg)
+
+        self._custom_modules: Optional[dict[type[nn.Module], type[nn.Module]]] = None
+
+    def _register_custom_module(self, mapping: dict[type[nn.Module], type[nn.Module]]) -> None:
+        """
+        Experimental API to support providing custom LoRA layers.
+
+        This API is subject to change, you should carefully read the docs before deciding to use it:
+
+        https://huggingface.co/docs/peft/developer_guides/custom_models
+
+        To register custom LoRA module types, call this method with a `mapping` argument that is a dict that maps from
+        the target layer type to the custom LoRA layer type. The dict can contain multiple items if you wish to target
+        multiple layer types. The target layer type can be any nn.Module that we currently don't support in PEFT,
+        whether that is an official PyTorch layer type or a custom layer type. The custom LoRA module class has to be
+        implemented by the user and follow the PEFT conventions for LoRA layers.
+
+        """
+        if self._custom_modules is None:
+            self._custom_modules = {}
+        self._custom_modules.update(mapping)
+
+
+@dataclass
+class LoraGAConfig:
+    """
+    This is the sub-configuration class to store the configuration for LoRA-GA initialization.
+
+    LoRA-GA (Low-Rank Adaptation with Gradient Approximation) uses gradient information during initialization to
+    achieve faster convergence (2-4x speedup) by aligning the initial adapter weights with the direction of full
+    fine-tuning gradients.
+
+    Reference: https://arxiv.org/abs/2407.05000
+
+    Args:
+        direction (`Literal["ArBr", "A2rBr", "ArB2r", "random"]`):
+            Strategy for distributing gradient SVD components to lora_A and lora_B matrices.
+            - "ArBr": Alternating indices (A takes odd, B takes even)
+            - "A2rBr": A takes indices [r:2r], B takes indices [:r]
+            - "ArB2r": A takes indices [:r], B takes indices [r:2r] (recommended)
+            - "random": Random selection of indices
+            Default: "ArB2r"
+        scale (`Literal["stable", "weight_svd", "gd_scale", "unit"]`):
+            Scaling strategy for adapter initialization.
+            - "stable": Stable scaling with gamma parameter
+            - "weight_svd": Scale based on weight matrix singular values
+            - "gd_scale": Gradient descent based scaling
+            - "unit": No additional scaling
+            Default: "stable"
+        stable_gamma (`int`):
+            Gamma parameter for stable scaling method. Default: 16
+    """
+
+    direction: Literal["ArBr", "A2rBr", "ArB2r", "random"] = field(
+        default="ArB2r", metadata={"help": "Component distribution strategy from gradient SVD"}
+    )
+    scale: Literal["stable", "weight_svd", "gd_scale", "unit"] = field(
+        default="stable", metadata={"help": "Scaling strategy for initialization"}
+    )
+    stable_gamma: int = field(default=16, metadata={"help": "Gamma parameter for stable scaling"})
+
+
+@dataclass
+class MontecloraConfig:
+    """
+    This is the sub-configuration class to store the configuration for Monteclora (Monte Carlo Low-Rank Adaptation).
+    Monteclora introduces variational inference into LoRA by adding Monte Carlo sampling to the adapter weights.
+
+    In practice you can think of Monteclora as adding stochastic, learned perturbations on top of the LoRA weights to
+    obtain a better-calibrated and better-regularized adapter. The arguments below let you trade off stability,
+    regularization strength, and compute cost.
+
+    Args:
+        num_samples (`int`):
+            Number of Monte Carlo samples to draw per forward pass. Higher values usually give smoother training and
+            better uncertainty estimates but increase compute and memory usage. Lower this if training is too slow or
+            memory constrained; increase it if training is stable and you want stronger Monte Carlo averaging.
+        use_entropy (`bool`):
+            Whether to add an entropy regularization term that keeps the Monte Carlo weights from collapsing to a
+            single sample. Turn this on if you observe the sampler becoming very peaky or want stronger regularization;
+            leave it off to mimic standard LoRA more closely.
+        dirichlet_prior (`float`):
+            Concentration parameter for the Dirichlet prior over sample/expert weights. Larger values push the weights
+            towards being more uniform (stronger regularization, less sparsity), while smaller positive values
+            encourage sparser, more peaked weights. Increase if the sampler overfits; decrease (but keep > 0) if it is
+            too conservative.
+        sample_scaler (`float`):
+            Overall scaling factor for the sampled perturbations applied to the LoRA weights. Increasing this makes the
+            Monte Carlo noise stronger (more regularization and exploration, but also more training instability);
+            decreasing it moves the behavior closer to standard deterministic LoRA. Setting it very close to 0 largely
+            disables the effect of Monteclora.
+        kl_loss_weight (`float`):
+            Weight of the KL-divergence term between the variational distribution and its prior. Larger values put more
+            emphasis on matching the prior (stronger regularization, potentially underfitting); smaller values rely
+            more on the data likelihood (weaker regularization, potentially overfitting). Tune this if you find
+            Monteclora over- or under-regularizing the adapter.
+        buffer_size (`int`):
+            Size of the internal buffer used by the Monte Carlo sampler (e.g. for storing recent statistics). Larger
+            values can stabilize the estimated variational parameters at the cost of additional memory; reduce this if
+            you are memory constrained.
+    """
+
+    num_samples: int = field(
+        default=8,
+        metadata={
+            "help": (
+                "Number of Monte Carlo samples to draw per forward pass. Higher values usually give smoother "
+                "training and better uncertainty estimates but increase compute and memory usage. Lower this if "
+                "training is too slow or memory constrained; increase it if training is stable and you want "
+                "stronger Monte Carlo averaging."
+            )
+        },
+    )
+    use_entropy: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Whether to add an entropy regularization term that keeps the Monte Carlo weights from collapsing "
+                "to a single sample. Turn this on if you observe the sampler becoming very peaky or want stronger "
+                "regularization."
+            )
+        },
+    )
+    dirichlet_prior: float = field(
+        default=0.1,
+        metadata={"help": "Prior parameter for Dirichlet distribution used in expert weight sampling."},
+    )
+    sample_scaler: float = field(
+        default=1e-4,
+        metadata={
+            "help": "Scaling factor for the Monte Carlo samples. Controls the magnitude of variational perturbations."
+        },
+    )
+    kl_loss_weight: float = field(
+        default=1e-5,
+        metadata={"help": "Weight for the KL divergence loss component in the variational objective."},
+    )
+    buffer_size: int = field(
+        default=150,
+        metadata={"help": "Size of the buffer for the Monte Carlo sampler."},
+    )
+
+    def __post_init__(self):
+        if self.num_samples <= 0:
+            raise ValueError("`num_samples` must be greater than 0.")
+        if self.dirichlet_prior <= 0:
+            raise ValueError("`dirichlet_prior` must be greater than 0.")
+        if self.buffer_size <= 0:
+            raise ValueError("`buffer_size` must be greater than 0.")
diff --git a/src/peft/tuners/lora/conversion.py b/src/peft/tuners/lora/conversion.py
new file mode 100644
index 0000000..6408e6f
--- /dev/null
+++ b/src/peft/tuners/lora/conversion.py
@@ -0,0 +1,440 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+import copy
+import os
+import pathlib
+import warnings
+
+import torch
+from safetensors.torch import save_file
+from tqdm import tqdm
+from transformers.pytorch_utils import Conv1D
+
+from peft.tuners.tuners_utils import BaseTunerLayer
+from peft.utils import SAFETENSORS_WEIGHTS_NAME
+from peft.utils.other import ModulesToSaveWrapper
+
+from .config import LoraConfig
+
+
+def _find_cutoff_index(S: torch.Tensor, threshold: float) -> int:
+    # assumes that the singular values are sorted
+    if S.dim() != 1:
+        raise ValueError("Input vector must be 1d.")
+
+    energy = S**2
+    cs = torch.cumsum(energy, dim=0)
+    total = cs[-1]
+
+    cutoff = threshold * total
+    # smallest index i with cs[i] >= cutoff
+    k = torch.searchsorted(cs, cutoff).item()
+    # k is the index of the first item that surpasses the threshold; since we want to include it, add + 1
+    return k + 1
+
+
+@torch.no_grad()
+def _convert_miss_module_to_lora(
+    module, rank: int | float, adapter_name: str = "default"
+) -> tuple[torch.Tensor, torch.Tensor, int]:
+    """Convert a single MiSS layer to LoRA A and B matrices.
+
+    For standard and mini modes, the MiSS forward pass (reshape+sum @ miss) is already a rank-r factorization, so the
+    exact factors are returned directly without SVD.
+
+    For bat mode, the delta weight depends on the base weight, so SVD is used.
+    """
+    miss_fn = module.miss_fn
+    miss_block = module.miss_block[adapter_name]
+    in_features = module.in_features
+    out_features = module.out_features
+    r_miss = module.miss_r[adapter_name]
+    orig_dtype = miss_block.dtype
+    device = miss_block.device
+
+    if miss_fn == "bat":
+        base_weight = module.get_base_layer().weight.data.clone()
+        delta_weight = module.get_delta_weight(adapter_name, base_weight).float()
+
+        U, S, V = torch.linalg.svd(delta_weight, full_matrices=False)
+
+        if isinstance(rank, int):
+            effective_rank = rank
+        else:
+            effective_rank = _find_cutoff_index(S, threshold=rank)
+
+        if effective_rank > U.shape[1]:
+            raise ValueError(
+                f"The chosen rank {effective_rank} is larger than the weight shape ({U.shape[1]}), please choose a "
+                "lower rank."
+            )
+
+        lora_B = U[:, :effective_rank] * S[:effective_rank]
+        lora_A = V[:effective_rank]
+        return lora_A.to(orig_dtype).contiguous(), lora_B.to(orig_dtype).contiguous(), effective_rank
+
+    # Standard or mini: exact conversion using the native rank r
+    miss = miss_block.float()
+    r = miss.size(0)
+
+    if miss_fn == "mini":
+        mini_r = module.miss_mini_r[adapter_name]
+        miss = miss.repeat(1, out_features // mini_r)
+
+    # lora_A: structured summation matrix, shape (r, in_features)
+    # lora_A[j, i] = 1 if i % r == j
+    lora_A = torch.zeros(r, in_features, device=device, dtype=torch.float32)
+    indices = torch.arange(in_features, device=device)
+    lora_A[indices % r, indices] = 1.0
+
+    # lora_B = miss.T, shape (out_features, r)
+    lora_B = miss.T
+
+    return lora_A.to(orig_dtype).contiguous(), lora_B.to(orig_dtype).contiguous(), r
+
+
+@torch.no_grad()
+def _convert_module_to_lora(
+    module: BaseTunerLayer, rank: float, adapter_name: str = "default"
+) -> tuple[torch.Tensor, torch.Tensor, int]:
+    """Convert a single BaseTunerLayer's adapter weight to a LoRA weight, return A, B, and the effective rank."""
+    from peft.tuners.miss.layer import MissLinear
+
+    if isinstance(module, MissLinear):
+        return _convert_miss_module_to_lora(module, rank, adapter_name)
+
+    delta_weight = module.get_delta_weight(adapter_name)
+    # Note: Explore different algorithms (truncated, randomized, ...) to see if they are more efficient
+
+    orig_dtype = delta_weight.dtype
+    delta_weight = delta_weight.float()  # SVD not implemented for half-precision types
+    U, S, V = torch.linalg.svd(delta_weight, full_matrices=False)
+    if isinstance(rank, int):
+        effective_rank = rank
+    else:
+        # float => interpret as threshold
+        effective_rank = _find_cutoff_index(S, threshold=rank)
+
+    if effective_rank > U.shape[1]:
+        raise ValueError(
+            f"The chosen rank {effective_rank} is larger than the weight shape ({U.shape[1]}), please choose a lower "
+            "rank."
+        )
+
+    lora_B = U[:, :effective_rank] * S[:effective_rank]
+    lora_A = V[:effective_rank]
+    lora_A, lora_B = lora_A.to(orig_dtype), lora_B.to(orig_dtype)
+
+    if isinstance(module.get_base_layer(), Conv1D):
+        # Conv1D => original weight is transposed compared to Linear
+        return lora_B.T.contiguous(), lora_A.T.contiguous(), effective_rank
+    return lora_A.contiguous(), lora_B.contiguous(), effective_rank
+
+
+def convert_to_lora(
+    model: torch.nn.Module,
+    rank: float,
+    adapter_name: str = "default",
+    progressbar: bool = False,
+    compile_kwargs=None,
+) -> tuple[LoraConfig, dict[str, torch.Tensor]]:
+    """
+    Convert a non-LoRA model with PEFT layers to a LoRA checkpoint.
+
+    This is only supported for some specific PEFT methods that allow an equivalent conversion. Essentially, this comes
+    down to PEFT methods that work by updating the base weight with a delta weight. Also, right now, only linear layers
+    are supported.
+
+    The LoRA adapter will try to approximate the initial adapter as close as possible. The higher the rank, the better
+    the approximation. It is expected that the approximation will never reach the full performance of the original
+    adapter, and that the parameter efficiency of the LoRA adapter will be less than that of the original adapter (i.e.
+    for a similar performance, it will require more parameters). The conversion can still be useful in many situations:
+
+    - In PEFT, LoRA supports more features than most other methods, e.g. mixed adapter batches. Thus the converted
+      adapter can be used with those features.
+    - Some downstream packages support LoRA adapters, but not other PEFT methods, e.g. Diffusers. The conversion allows
+      to use a non-LoRA adapter with those packages.
+
+    The LoRA scaling factor is already baked into the LoRA weights, thus the scaling will always be one (i.e. rank and
+    alpha are chosen to be identical).
+
+    Note: This function does not support sharded models (yet).
+
+    Args:
+        model:
+            The model to be converted. Should be a model that has PEFT layers that support conversion.
+        rank (`int` or `float`):
+            The desired rank for the returned LoRA adapter. A higher rank results in a LoRA adapter that more
+            accurately mirrors the original adapter. It will, however, also require more memory, compute, and disk
+            space. Therefore, choose a value that represents the best trade off for your use case and validate the
+            final adapter. If a float is passed, it is interpreted as an explained variance / energy threshold: we pick
+            the smallest rank k such that the top k singular values account for at least that fraction of the total
+            squared singular values. This effectively results in lower ranks being assigned if a few singular can
+            capture the adaptation of this layer. A lower float means the rank is lower and vice versa. Be aware that
+            dynamic ranks can lead to very unequal ranks per layer, which means that some layers may require a
+            disproportionally high amount of memory for activations. Choosing a fixed (int) rank is better to achieve
+            predictable memory requirement.
+        adapter_name (`str`, *optional*):
+            The name of the adapter to be converted. Can only convert a single adapter at a time. Defaults to
+            `"default"`.
+        progressbar (`bool`):
+            whether to show a progressbar indicating the progress of the conversion (it can take a few minutes for big
+            models).
+        compile_kwargs (`dict`, *optional*):
+            If provided, compile the function to convert individual modules to LoRA with the given kwargs being passed
+            to `torch.compile`. This can potentially speed up the conversion on large models.
+
+    Returns:
+        lora_config (`LoraConfig`)
+            The `LoraConfig` that corresponds to the converted LoRA adapter.
+        state_dict (`dict[str, torch.Tensor]`)
+            The `state_dict` containing the LoRA weights.
+
+    Raises
+        TypeError:
+            If the provided model does not have any layers that can be converted to LoRA, a `TypeError` is raised.
+        ValueError:
+            If an invalid rank was chosen (too high or too low).
+    """
+    from peft import PeftType  # local to avoid circular import
+
+    ##########
+    # CHECKS #
+    ##########
+
+    if isinstance(rank, float) and not (0 < rank <= 1):
+        raise ValueError(
+            f"If rank is a float, it is interpreted as a threshold. It must be between 0 and 1 but got {rank}."
+        )
+    elif rank == 0:
+        raise ValueError("Passing a rank of 0 doesn't make sense, please pass a valid value.")
+
+    # check if LoRA conversion is supported at all
+    modules_not_supporting_lora = []
+    num_modules_with_support = 0
+    num_modules_total = 0
+    for module in model.modules():
+        num_modules_total += 1
+        if not isinstance(module, BaseTunerLayer):
+            continue
+
+        if module.supports_lora_conversion(adapter_name):
+            num_modules_with_support += 1
+        else:
+            modules_not_supporting_lora.append(module)
+
+    unsupported = {repr(type(module)) for module in modules_not_supporting_lora}
+    if unsupported:
+        raise TypeError(f"Some module types on this model do not support LoRA conversion: {', '.join(unsupported)}.")
+
+    if num_modules_with_support == 0:
+        raise TypeError("Could not detect any layer that supports LoRA conversion.")
+
+    peft_config = getattr(model, "peft_config", {}).get(adapter_name)
+    if (peft_config is not None) and (peft_config.peft_type == PeftType.LORA):
+        warnings.warn(
+            "Converting a PEFT adapter to LoRA that is already a LoRA adapter. There is typically no need for that."
+        )
+
+    config_bias = getattr(peft_config, "bias", getattr(peft_config, "lora_bias", "none"))
+    if config_bias != "none":
+        # TODO: remove if/when we remove support for bias completely
+        raise ValueError(f"The adapter's config sets bias={config_bias}, this is not supported right now.")
+
+    ###############
+    # PREPARATION #
+    ###############
+
+    peft_prefix = "base_model.model."
+    config_kwargs = {
+        "rank_pattern": {},
+        "alpha_pattern": {},
+        "exclude_modules": set(),
+    }
+
+    if peft_config is not None:
+        # use the model's PEFT config, if it exists, to initialize the new LoraConfig
+        peft_config = model.peft_config[adapter_name]
+        config_kwargs["target_modules"] = copy.copy(peft_config.target_modules)
+        config_kwargs["base_model_name_or_path"] = peft_config.base_model_name_or_path
+        if hasattr(peft_config, "layers_pattern"):
+            # those two go hand in hand
+            config_kwargs["layers_pattern"] = peft_config.layers_pattern
+            config_kwargs["layers_to_transform"] = peft_config.layers_to_transform
+        if isinstance(rank, int):
+            # hard-coded rank
+            lora_config = LoraConfig(r=rank, lora_alpha=rank, **config_kwargs)
+        else:
+            # r and lora_alpha shouldn't matter, as the rank will be determined by rank/alpha pattern
+            lora_config = LoraConfig(r=1, lora_alpha=1, **config_kwargs)
+    else:
+        # create a new LoraConfig from scratch, inferring the target modules from the model
+        lora_config = LoraConfig(
+            r=rank if isinstance(rank, int) else 1,  # 1 is a dummy value, actual values will come from rank_pattern
+            target_modules=[],
+            **config_kwargs,
+        )
+
+    if compile_kwargs is not None:
+        convert_module_to_lora = torch.compile(_convert_module_to_lora, **compile_kwargs)
+    else:
+        convert_module_to_lora = _convert_module_to_lora
+
+    ##############
+    # CONVERSION #
+    ##############
+
+    state_dict = {}
+    for name, module in tqdm(
+        model.named_modules(), disable=not progressbar, desc="Converting to LoRA", total=num_modules_total
+    ):
+        if not isinstance(module, BaseTunerLayer):
+            continue
+        if not hasattr(module, "get_delta_weight"):
+            # if we arrive here, it means that the layer actually does not support LoRA conversion, which should not
+            # happen
+            raise TypeError(
+                f"Module of type {type(module)} does not have a get_delta_weight method, which is required for "
+                "conversion. Please open an issue: https://github.com/huggingface/peft/issues"
+            )
+
+        lora_A, lora_B, effective_rank = convert_module_to_lora(module, rank=rank, adapter_name=adapter_name)
+        if effective_rank == 0:
+            # This shouldn't really happen, as we ensure that the rank is greater than 0 (int) or, for thresholds
+            # (float), at least one SV is included. But better be safe than sorry, as, in principle, it is fine to
+            # exclude some layers. Also makes this more future proof.
+            lora_config.exclude_modules.add(name.removeprefix(peft_prefix))
+            continue
+
+        # the rank was dynamically adjusted, store it in rank and alpha pattern
+        if (effective_rank != rank) or isinstance(lora_config.target_modules, str):
+            # we need to add an entry to rank/alpha pattern iff:
+            #   1) The effective rank differs from the general rank
+            #   2) target modules is a string, as we cannot simply append the name to target_modules regex
+            lora_config.rank_pattern[name.removeprefix(peft_prefix)] = effective_rank
+            lora_config.alpha_pattern[name.removeprefix(peft_prefix)] = effective_rank
+        else:
+            # effective rank is the same and target_modules are a set, just add the name
+            lora_config.target_modules.add(name.removeprefix(peft_prefix))
+
+        # don't include adapter_name in key
+        state_dict[f"{name}.lora_A.weight"] = lora_A
+        state_dict[f"{name}.lora_B.weight"] = lora_B
+
+    if not state_dict:
+        # no layer was converted, which should not happen
+        raise ValueError(
+            "Did not convert a single layer, this means that something went wrong. Please open an issue: "
+            "https://github.com/huggingface/peft/issues"
+        )
+
+    ##################
+    # NON-LORA PARTS #
+    ##################
+
+    if (peft_config is not None) and getattr(peft_config, "modules_to_save", None):
+        # logic to take care of modules_to_save; might not cover all edge cases, like sharded model
+        lora_config.modules_to_save = copy.copy(peft_config.modules_to_save)
+
+        for module_name, module in model.named_modules():
+            if isinstance(module, ModulesToSaveWrapper):
+                for param_name, param in module.modules_to_save.named_parameters():
+                    # it is expected that '.modules_to_save.' is not part of the key
+                    prefix, _, _ = module_name.partition(".modules_to_save.")
+                    # remove the adapter name
+                    _, _, suffix = param_name.rpartition(".")
+                    state_dict[f"{prefix}.{suffix}"] = param.data
+
+    return lora_config, state_dict
+
+
+def save_as_lora(
+    path: str | os.PathLike,
+    model: torch.nn.Module,
+    rank: float,
+    adapter_name: str = "default",
+    progressbar: bool = False,
+    compile_kwargs=None,
+) -> None:
+    """
+    Convert a non-LoRA model with PEFT layers to a LoRA, then save the checkpoint file and PEFT config.
+
+    This is only supported for some specific PEFT methods that allow an equivalent conversion. Essentially, this comes
+    down to PEFT methods that work by updating the base weight with a delta weight. Also, right now, only linear layers
+    are supported.
+
+    The LoRA adapter will try to approximate the initial adapter as close as possible. The higher the rank, the better
+    the approximation. It is expected that the approximation will never reach the full performance of the original
+    adapter, and that the parameter efficiency of the LoRA adapter will be less than that of the original adapter (i.e.
+    for a similar performance, it will require more parameters). The conversion can still be useful in many situations:
+
+    - In PEFT, LoRA supports more features than most other methods, e.g. mixed adapter batches. Thus the converted
+      adapter can be used with those features.
+    - Some downstream packages support LoRA adapters, but not other PEFT methods, e.g. Diffusers. The conversion allows
+      to use a non-LoRA adapter with those packages.
+
+    The LoRA scaling factor is already baked into the LoRA weights, thus the scaling will always be one (i.e. rank and
+    alpha are chosen to be identical).
+
+    You can load the converted LoRA weight like this:
+
+    ```py
+    >>> lora_path = ...
+    >>> save_as_lora(lora_path, model, rank=...)
+    >>> base_model = AutoModel.from_pretrained(...)
+    >>> lora_model = PeftModel.from_pretrained(base_model, lora_path)
+    ```
+
+    Note: This function does not support sharded models (yet).
+
+    Args:
+        model:
+            The model to be converted. Should be a model that has PEFT layers that support conversion.
+        rank (`int` or `float`):
+            The desired rank for the returned LoRA adapter. A higher rank results in a LoRA adapter that more
+            accurately mirrors the original adapter. It will, however, also require more memory, compute, and disk
+            space. Therefore, choose a value that represents the best trade off for your use case and validate the
+            final adapter. If a float is passed, it is interpreted as an explained variance / energy threshold: we pick
+            the smallest rank k such that the top k singular values account for at least that fraction of the total
+            squared singular values. This effectively results in lower ranks being assigned if a few singular can
+            capture the adaptation of this layer. A lower float means the rank is lower and vice versa. Be aware that
+            dynamic ranks can lead to very unequal ranks per layer, which means that some layers may require a
+            disproportionally high amount of memory for activations. Choosing a fixed (int) rank is better to achieve
+            predictable memory requirement.
+        adapter_name (`str`, *optional*):
+            The name of the adapter to be converted. Can only convert a single adapter at a time. Defaults to
+            `"default"`.
+        progressbar (`bool`):
+            whether to show a progressbar indicating the progress of the conversion (it can take a few minutes for big
+            models).
+        compile_kwargs (`dict`, *optional*):
+            If provided, compile the function to convert individual modules to LoRA with the given kwargs being passed
+            to `torch.compile`. This can potentially speed up the conversion on large models.
+
+    Raises
+        TypeError:
+            If the provided model does not have any layers that can be converted to LoRA, a `TypeError` is raised.
+        ValueError:
+            If an invalid rank was chosen (too high or too low).
+    """
+    path = pathlib.Path(path)
+    if not path.exists():
+        os.makedirs(path)
+
+    lora_config, state_dict = convert_to_lora(
+        model, rank=rank, adapter_name=adapter_name, progressbar=progressbar, compile_kwargs=compile_kwargs
+    )
+    save_file(state_dict, path / SAFETENSORS_WEIGHTS_NAME)
+    lora_config.save_pretrained(str(path))
diff --git a/src/peft/tuners/lora/corda.py b/src/peft/tuners/lora/corda.py
new file mode 100644
index 0000000..9a28abe
--- /dev/null
+++ b/src/peft/tuners/lora/corda.py
@@ -0,0 +1,370 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+# Reference code: https://github.com/iboing/CorDA/blob/main/cordalib/decomposition.py
+# Reference paper: https://huggingface.co/papers/2406.05223
+
+import os
+from collections.abc import Callable, Iterable
+from typing import Any, Optional
+
+import torch
+from attr import dataclass
+from torch import nn
+from tqdm import tqdm
+from transformers.pytorch_utils import Conv1D
+
+from peft.tuners.lora.config import LoraConfig
+from peft.tuners.lora.model import LoraModel
+from peft.utils.other import get_pattern_key
+
+
+@dataclass
+class CordaEigens:
+    S_WC: torch.Tensor
+    U_WC: torch.Tensor
+    V_WC: torch.Tensor
+
+
+def target_modules(model: nn.Module, config: LoraConfig) -> Iterable[nn.Module]:
+    """
+    Iterate over CorDA target name and modules of a model. A module is a target if its name is in
+    `config.target_modules` and is `nn.Linear` or `Conv1D`.
+    """
+    for name, module in model.named_modules():
+        if LoraModel._check_target_module_exists(config, name) and isinstance(module, (nn.Linear, Conv1D)):
+            yield name, module
+
+
+def get_model_device(model: nn.Module) -> str:
+    if hasattr(model, "module"):  # Handle DeepSpeed/DataParallel
+        model = model.module
+    return next(iter(model.parameters())).device.type
+
+
+@torch.no_grad()
+def preprocess_corda(
+    model: nn.Module,
+    lora_config: LoraConfig,
+    run_model: Optional[Callable[[], None]] = None,
+    hooked_model: Optional[nn.Module] = None,
+):
+    """
+    Build necessary CorDA fields for a model.
+
+    For each `M * N` linear layer, a `M * M` covariance matrix will be built temporarily during the preprocessing
+    process, consuming roughly another `2 * MODEL_SIZE` memory for typical LLMs if model weight is FP16 and covariance
+    is FP32. If that's too much, consider specifying `use_float16_for_covariance` in `lora_config.corda_config`.
+
+    Args:
+        model (`nn.Module`):
+            Model to preprocess.
+        lora_config (`LoraConfig`):
+            Lora configuration of the model. `lora_config.corda_config` should be set.
+        run_model (`Optional[Callable[[], None]]`):
+            Callback to run the model when building covariance. Typically you should run model inference on your sample
+            dataset in this callback. Experiments have shown that when token count per sample is 2048, hidden dimension
+            is 4096, collecting 256 distinct samples is enough. If you collect too few or too repetitive samples, the
+            covariance matrix may be low-ranked and unstabilize preprocessing. You can estimate sample count as
+            `HIDDEN_DIM / TOKEN_PER_SAMPLE * 128`. `run_model` can be `None` only if covariance file in
+            `lora_config.corda_config` is already created.
+        hooked_model (`Optional[nn.Module]`):
+            Model to hook when building covariance. If none, original model will be hooked. This is only useful when
+            you want to hook a different model than the one you are training, typically you should leave this `None`.
+
+    Upon completion, the following fields are set for each target module:
+        eigens.S_WC (`torch.Tensor`):
+            Singular values of the weight matrix.
+        eigens.U_WC (`torch.Tensor`):
+            Left singular vectors of the weight matrix.
+        eigens.V_WC (`torch.Tensor`):
+            Right singular vectors of the weight matrix, multiplied by inverse of covariance matrix.
+    """
+    cache_file = lora_config.corda_config.cache_file
+    covariance_file = lora_config.corda_config.covariance_file
+    corda_method = lora_config.corda_config.corda_method
+    verbose = lora_config.corda_config.verbose
+    prune_temporary_fields = lora_config.corda_config.prune_temporary_fields
+
+    # If cache exists, skip building
+    if cache_file is not None and os.path.exists(cache_file) and os.path.getsize(cache_file) > 0:
+        cache = torch.load(cache_file, map_location=get_model_device(model))
+        for name, module in target_modules(model, lora_config):
+            module.eigens = CordaEigens(
+                S_WC=cache[f"{name}.eigens.S_WC"],
+                U_WC=cache[f"{name}.eigens.U_WC"],
+                V_WC=cache[f"{name}.eigens.V_WC"],
+            )
+    else:
+        # Specify CorDA method for each layer
+        if corda_method is None:
+            raise ValueError("corda_method is required when cache_file is not provided.")
+        for name, module in target_modules(model, lora_config):
+            module.corda_method = corda_method
+
+        # Specify CorDA rank for each layer
+        for name, module in target_modules(model, lora_config):
+            r_key = get_pattern_key(lora_config.rank_pattern.keys(), name)
+            module.rank = lora_config.rank_pattern.get(r_key, lora_config.r)
+
+        # Calculate covariance matrix
+        calib_cov_distribution(model, lora_config, run_model, hooked_model, covariance_file)
+
+        # Calculate eigens
+        collect_eigens(model, lora_config, verbose)
+
+        # Crop CorDA eigens so that there's less to save
+        crop_corda_eigens(model, lora_config)
+
+        # Remove redundant fields if exist
+        if prune_temporary_fields:
+            for name, module in target_modules(model, lora_config):
+                if hasattr(module, "sample_count"):
+                    del module.sample_count
+                if hasattr(module, "covariance_matrix"):
+                    del module.covariance_matrix
+                if hasattr(module, "corda_method"):
+                    del module.corda_method
+                if hasattr(module, "rank"):
+                    del module.rank
+
+        # Save cache to disk
+        if cache_file is not None:
+            cache: dict[str, Any] = {}
+            for name, module in target_modules(model, lora_config):
+                cache[f"{name}.eigens.S_WC"] = module.eigens.S_WC
+                cache[f"{name}.eigens.U_WC"] = module.eigens.U_WC
+                cache[f"{name}.eigens.V_WC"] = module.eigens.V_WC
+
+            os.makedirs(os.path.dirname(cache_file), exist_ok=True)
+            torch.save(cache, cache_file)
+
+
+@torch.no_grad()
+def calib_cov_distribution(
+    model: nn.Module,
+    config: LoraConfig,
+    run_model: Optional[Callable[[], None]],
+    hooked_model: Optional[nn.Module],
+    covariance_file: Optional[str],
+):
+    if covariance_file is not None and os.path.exists(covariance_file) and os.path.getsize(covariance_file) > 0:
+        all_covariance_matrix = torch.load(covariance_file, map_location=get_model_device(model))
+        for name, module in target_modules(model, config):
+            module.covariance_matrix = all_covariance_matrix[name]
+        return
+
+    if run_model is None:
+        raise ValueError("run_model must be specified when covariance file and cache file aren't built.")
+    if hooked_model is None:
+        hooked_model = model
+    hooked_model.eval()
+
+    def hook(module, input, output):
+        input = input[0].detach().squeeze(0).data  ## (context_length = 2048, dim)
+        if not config.corda_config.use_float16_for_covariance:
+            input = input.float()
+        input = input / torch.max(input).abs()
+
+        # check if input is valid
+        if torch.isnan(input).any() or torch.isinf(input).any():
+            raise ValueError("Invalid value found in input, please check your input data.")
+
+        # calculate covariance and check if it's valid
+        covariance = input.t().matmul(input)
+        if torch.isnan(covariance).any() or torch.isinf(covariance).any():
+            raise ValueError(
+                "Invalid value found in covariance. Please file an issue at https://github.com/huggingface/peft/issues."
+            )
+
+        # add to module
+        module.sample_count += 1
+        module.covariance_matrix += covariance
+
+        # free memory
+        del covariance, input
+
+    handles = []
+    for name, module in target_modules(hooked_model, config):
+        module.sample_count = 0
+        module.covariance_matrix = 0
+        handles.append(module.register_forward_hook(hook))
+
+    run_model()
+
+    # Clear the hooks
+    for handle in handles:
+        handle.remove()
+
+    # In some edge cases you might need to hook a model different from the model to add adapters,
+    # this case you would specify `hooked_model` and set it to a different model from `model`.
+    if hooked_model is not model:
+        targets = {}
+        for name, module in target_modules(model, config):
+            targets[name] = module
+        for name, module in target_modules(hooked_model, config):
+            # There can be modules used only in inference, but not training
+            # Exclude modules not in target model to prevent KeyError in this case
+            if name in targets:
+                targets[name].sample_count = module.sample_count
+                targets[name].covariance_matrix = module.covariance_matrix
+
+    # Divide by sample count
+    for name, module in target_modules(model, config):
+        module.covariance_matrix /= module.sample_count
+
+    # Save covariance to disk
+    if covariance_file is not None:
+        all_covariance_matrix = {}
+        for name, module in target_modules(model, config):
+            all_covariance_matrix[name] = module.covariance_matrix
+        os.makedirs(os.path.dirname(covariance_file), exist_ok=True)
+        torch.save(all_covariance_matrix, covariance_file)
+
+
+@torch.no_grad()
+def collect_eigens(
+    model: nn.Module,
+    config: LoraConfig,
+    verbose: bool,
+):
+    """Call collect_eigens_for_layer and store result in key `eigens` of each layer."""
+    linear_modules = []
+    for name, module in target_modules(model, config):
+        linear_modules.append((name, module))
+    if verbose:
+        linear_modules = tqdm(linear_modules, desc="Collecting eigens")
+    for name, module in linear_modules:
+        module.eigens = collect_eigens_for_layer(module, config)
+
+
+@torch.no_grad()
+def collect_eigens_for_layer(
+    linear: nn.Module,
+    config: LoraConfig,
+) -> CordaEigens:
+    w = linear.weight.data.float()
+    # Conv1D stores weights as (in_features, out_features), transposed compared to Linear
+    # We need to transpose it to match Linear's (out_features, in_features) layout for SVD
+    if isinstance(linear, Conv1D):
+        w = w.T
+    out_dim = w.size(0)
+    in_dim = w.size(1)
+    min_dim = min(in_dim, out_dim)
+
+    if not hasattr(linear, "covariance_matrix"):
+        raise ValueError(
+            "Covariance matrix not found in linear module. Please do not call this function directly, "
+            "instead call `preprocess_corda`. If your usage is correct but this error still encounters, "
+            "please file an issue at https://github.com/huggingface/peft/issues."
+        )
+    covariance_matrix = linear.covariance_matrix.float()
+
+    damp = 0.01
+    while True:
+        compensate = torch.diag(
+            torch.ones(covariance_matrix.size(0)).to(covariance_matrix.device)
+            * torch.mean(torch.diag(covariance_matrix))
+            * damp
+        )
+        fix_covariance_matrix = covariance_matrix + compensate
+        cov_inv = torch.linalg.inv(fix_covariance_matrix)
+        inv_error = torch.dist(
+            fix_covariance_matrix @ cov_inv, torch.eye(covariance_matrix.size(0)).to(get_model_device(linear))
+        ).item()
+        if inv_error < 0.05:
+            break
+        else:
+            damp = damp * 2
+    w = w @ fix_covariance_matrix  ## w: out_dim, in_dim; covariance_matrix: in_dim, in_dim
+
+    U, S, Vh = torch.linalg.svd(w, full_matrices=False)
+    V = (Vh @ cov_inv).transpose(0, 1)
+
+    # Sanity check, temporarily U and V are large, they will be crop after rank search
+    r = min_dim
+    if U.size(0) != out_dim or U.size(1) != r:
+        raise ValueError(
+            f"Matrix U size mismatch: {U.size()} vs. ({out_dim}, {r}), "
+            "please file an issue at https://github.com/huggingface/peft/issues."
+        )
+    if S.size(0) != r:
+        raise ValueError(
+            f"Matrix S size mismatch: {S.size()} vs. ({r},), "
+            "please file an issue at https://github.com/huggingface/peft/issues."
+        )
+    if V.size(0) != in_dim or V.size(1) != r:
+        raise ValueError(
+            f"Matrix V size mismatch: {V.size()} vs. ({in_dim}, {r}), "
+            "please file an issue at https://github.com/huggingface/peft/issues."
+        )
+
+    # Offload U and V to CPU, they consume too much memory
+    U = U.cpu()
+    V = V.cpu()
+    return CordaEigens(
+        S_WC=S,
+        U_WC=U,
+        V_WC=V,
+    )
+
+
+@torch.no_grad()
+def crop_corda_eigens(model: nn.Module, config: LoraConfig):
+    for name, module in target_modules(model, config):
+        # We don't expect saving sliced tensor writes the whole tensor to disk,
+        # so it's necessary to copy the tensors.
+        # Reference: https://github.com/pytorch/pytorch/issues/40157
+        if module.corda_method == "ipm":
+            module.eigens.S_WC = module.eigens.S_WC[: module.rank].clone()
+            module.eigens.U_WC = module.eigens.U_WC[:, : module.rank].clone().to(get_model_device(model))
+            module.eigens.V_WC = module.eigens.V_WC[:, : module.rank].clone().to(get_model_device(model))
+        elif module.corda_method == "kpm":
+            module.eigens.S_WC = module.eigens.S_WC[-module.rank :].clone()
+            module.eigens.U_WC = module.eigens.U_WC[:, -module.rank :].clone().to(get_model_device(model))
+            module.eigens.V_WC = module.eigens.V_WC[:, -module.rank :].clone().to(get_model_device(model))
+        else:
+            raise ValueError(f"Invalid corda_method found: {module.corda_method}, it should be 'ipm' or 'kpm'.")
+
+        # Sanity check
+        # For Conv1D, weight is stored as (in_features, out_features), transposed compared to Linear
+        # But U and V are computed on the transposed weight, so we need to account for this
+        weight_out_dim = module.weight.size(1) if isinstance(module, Conv1D) else module.weight.size(0)
+        weight_in_dim = module.weight.size(0) if isinstance(module, Conv1D) else module.weight.size(1)
+
+        if module.eigens.S_WC.size(0) != module.rank:
+            raise ValueError(
+                f"rank mismatch: {module.eigens.S_WC.size(0)} vs. {module.rank},"
+                "please file an issue at https://github.com/huggingface/peft/issues."
+            )
+        if module.eigens.U_WC.size(0) != weight_out_dim:
+            raise ValueError(
+                f"U size mismatch: {module.eigens.U_WC.size(0)} vs. {weight_out_dim},"
+                "please file an issue at https://github.com/huggingface/peft/issues."
+            )
+        if module.eigens.U_WC.size(1) != module.rank:
+            raise ValueError(
+                f"U size mismatch: {module.eigens.U_WC.size(1)} vs. {module.rank},"
+                "please file an issue at https://github.com/huggingface/peft/issues."
+            )
+        if module.eigens.V_WC.size(0) != weight_in_dim:
+            raise ValueError(
+                f"V size mismatch: {module.eigens.V_WC.size(0)} vs. {weight_in_dim},"
+                "please file an issue at https://github.com/huggingface/peft/issues."
+            )
+        if module.eigens.V_WC.size(1) != module.rank:
+            raise ValueError(
+                f"V size mismatch: {module.eigens.V_WC.size(1)} vs. {module.rank},"
+                "please file an issue at https://github.com/huggingface/peft/issues."
+            )
diff --git a/src/peft/tuners/lora/dora.py b/src/peft/tuners/lora/dora.py
new file mode 100644
index 0000000..f7a397f
--- /dev/null
+++ b/src/peft/tuners/lora/dora.py
@@ -0,0 +1,287 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+from copy import deepcopy
+from functools import wraps
+from typing import Any, Optional
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from peft.utils.integrations import dequantize_module_weight, gather_params_ctx
+from peft.utils.other import transpose
+
+
+ENABLE_DORA_CACHING = False
+"""Whether to enable DoRA caching, which makes it faster at inference but requires more memory"""
+
+
+def cache_decorator(cache_key: str):
+    """Caching decorator for DoRA
+
+    Caching is only enabled if ENABLE_DORA_CACHING is set to True (default: False), when in eval mode, and when the
+    adapter_name is passed (e.g. not during layer initialization).
+
+    """
+
+    def cache_value(func):
+        @wraps(func)
+        def wrapper(self, *args, **kwargs):
+            # if adapter_name is not passed, no caching
+            adapter_name = kwargs.get("adapter_name")
+            if (not ENABLE_DORA_CACHING) or self.training or (adapter_name is None):
+                self._cache_clear()
+                return func(self, *args, **kwargs)
+
+            cache_key_adapter = f"{cache_key}-{adapter_name}"
+            output = self._cache_get(cache_key_adapter, None)
+            if output is not None:
+                return output
+
+            output = func(self, *args, **kwargs)
+            self._cache_store(cache_key_adapter, output)
+            return output
+
+        return wrapper
+
+    return cache_value
+
+
+class DoraLinearLayer(nn.Module):
+    def __init__(self, fan_in_fan_out):
+        super().__init__()
+        self.fan_in_fan_out = fan_in_fan_out
+        self._dora_cache: dict[str, Any] = {}  # small ad hoc cache; values are not part of the state_dict
+
+    def _cache_store(self, key: str, value: Any) -> None:
+        # cache intermediate values, e.g. weight norm of DoRA
+        self._dora_cache[key] = value
+
+    def _cache_get(self, key: str, default: Optional[Any]) -> Optional[Any]:
+        # retrieve from ad hoc cache
+        return self._dora_cache.get(key, default)
+
+    def _cache_clear(self) -> None:
+        self._dora_cache.clear()
+
+    def train(self, mode: bool = True):
+        if mode:
+            self._cache_clear()
+        super().train(mode=mode)
+        return self
+
+    @cache_decorator("weight-norm")
+    def get_weight_norm(self, weight, lora_weight, scaling, adapter_name: Optional[str] = None) -> torch.Tensor:
+        # calculate L2 norm of weight matrix, column-wise
+        weight = transpose(weight, self.fan_in_fan_out)
+        weight = weight + scaling * lora_weight
+        weight_norm = torch.linalg.norm(weight, dim=1).to(weight.dtype)
+        return weight_norm
+
+    @cache_decorator("lora-weight")
+    def get_lora_weight(self, lora_A, lora_B, adapter_name: Optional[str] = None):
+        # Don't use `lora_weight = lora_B.weight @ lora_A.weight` because this causes errors with FSDP. Instead,
+        # calculate the same but using forward.
+        x_eye = torch.eye(lora_A.weight.shape[1], device=lora_A.weight.device, dtype=lora_A.weight.dtype)
+        lora_weight = lora_B(lora_A(x_eye)).T
+        return lora_weight
+
+    def update_layer(self, *, base_layer, lora_A, lora_B, scaling, place_on_cpu=False) -> None:
+        # temporarily convert fp16 to fp32, as fp16 can cause trouble on CPU with PyTorch < 2.2
+        dtype_is_fp16 = lora_A.dtype == torch.float16
+        if dtype_is_fp16:
+            lora_A = lora_A.float()
+            lora_B = lora_B.float()
+
+        with gather_params_ctx(base_layer.parameters()):
+            if base_layer.__class__.__name__ == "Linear4bit":
+                # We have to create a copy of the base layer, otherwise, FSDP will throw an error. 8bit does not work
+                # yet because Int8Params cannot be correctly deep-copied (attributes vanish)
+                base_layer = deepcopy(base_layer)
+
+            weight = dequantize_module_weight(base_layer)
+            if weight.data.ndim >= 3:  # For handling LoRAs applied to Conv layers.
+                r = lora_A.shape[0]
+                lora_weight = torch.mm(lora_B.view([-1, r]), lora_A.view([r, -1]))
+                lora_weight = lora_weight.reshape(weight.shape)
+            else:
+                lora_weight = lora_B @ lora_A
+
+            if dtype_is_fp16:
+                lora_weight = lora_weight.half()
+            weight_norm = self.get_weight_norm(
+                weight=weight.to(lora_A.device), lora_weight=lora_weight, scaling=scaling
+            )
+
+        if place_on_cpu:
+            weight_norm = weight_norm.to("cpu")
+        self.weight = nn.Parameter(weight_norm, requires_grad=True)
+
+    def forward(self, x, *, lora_A, lora_B, scaling, base_layer, base_result=None, adapter_name="default"):
+        """
+        For DoRA, calculate the extra output from LoRA with DoRA applied. This should be added on top of the base layer
+        output.
+        """
+        lora_weight = self.get_lora_weight(lora_A=lora_A, lora_B=lora_B, adapter_name=adapter_name)
+        lora_weight = lora_weight.to(x.dtype)
+
+        magnitude = self.weight
+        weight = dequantize_module_weight(base_layer)
+        weight = weight.to(x.dtype)
+        weight_norm = self.get_weight_norm(
+            weight=weight, lora_weight=lora_weight.detach(), scaling=scaling, adapter_name=adapter_name
+        )
+        # see section 4.3 of DoRA (https://huggingface.co/papers/2402.09353)
+        # "[...] we suggest treating ||V +∆V ||_c in
+        # Eq. (5) as a constant, thereby detaching it from the gradient
+        # graph. This means that while ||V + ∆V ||_c dynamically
+        # reflects the updates of ∆V , it won’t receive any gradient
+        # during backpropagation"
+        weight_norm = weight_norm.detach()
+        mag_norm_scale = (magnitude / weight_norm).view(1, -1)
+
+        lora_result = lora_B(lora_A(x))
+
+        bias = None
+        if base_result is not None:
+            bias = base_layer.bias
+            if bias is not None:
+                base_result = base_result - bias
+        else:
+            base_result = F.linear(x, transpose(weight, self.fan_in_fan_out))
+
+        result_dora = (mag_norm_scale - 1) * base_result + mag_norm_scale * lora_result * scaling
+        return result_dora
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "lora.dora." + rep
+
+
+class DoraEmbeddingLayer(DoraLinearLayer):
+    @cache_decorator("lora-weight")
+    def get_lora_weight(self, lora_A, lora_B, adapter_name: Optional[str] = None):
+        return (lora_A @ lora_B).T
+
+    def forward(self, x, *, lora_A, lora_B, scaling, base_layer, embed_fn, adapter_name="default"):
+        """
+        For DoRA, calculate the extra output from LoRA with DoRA applied. This should be added on top of the base layer
+        output.
+        """
+        lora_weight = self.get_lora_weight(lora_A=lora_A, lora_B=lora_B, adapter_name=adapter_name)
+        magnitude = self.weight
+        weight = base_layer.weight
+        weight_norm = self.get_weight_norm(
+            weight=weight, lora_weight=lora_weight.detach(), scaling=scaling, adapter_name=adapter_name
+        )
+        # see section 4.3 of DoRA (https://huggingface.co/papers/2402.09353)
+        # "[...] we suggest treating ||V +∆V ||_c in
+        # Eq. (5) as a constant, thereby detaching it from the gradient
+        # graph. This means that while ||V + ∆V ||_c dynamically
+        # reflects the updates of ∆V , it won’t receive any gradient
+        # during backpropagation"
+        weight_norm = weight_norm.detach()
+        mag_norm_scale = magnitude / weight_norm
+        result_dora = mag_norm_scale * (embed_fn(x, lora_A) @ lora_B) * scaling
+        return mag_norm_scale, result_dora
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "lora.dora." + rep
+
+
+class _DoraConvNdLayer(DoraLinearLayer):
+    @cache_decorator("weight-norm")
+    def get_weight_norm(self, weight, lora_weight, scaling, adapter_name: Optional[str] = None) -> torch.Tensor:
+        # calculate L2 norm of weight matrix, column-wise
+        weight = weight + scaling * lora_weight
+        # the following is needed to have compatibility with the 4/5D weight tensors of Conv2D/3D
+        dim = tuple(range(1, weight.dim()))
+        weight_norm = weight.norm(p=2, dim=dim, keepdim=True).transpose(1, 0)
+        return weight_norm
+
+    @cache_decorator("lora-weight")
+    def get_lora_weight(self, lora_A, lora_B, adapter_name: Optional[str] = None) -> torch.Tensor:
+        # Don't use `lora_weight = lora_B.weight @ lora_A.weight` because this causes errors with FSDP. Instead,
+        # calculate the same but using forward.
+        r = lora_A.weight.shape[0]
+        lora_weight = torch.mm(lora_B.weight.view([-1, r]), lora_A.weight.view([r, -1]))
+        return lora_weight
+
+    def forward(
+        self, x, *, lora_A, lora_B, scaling, base_layer, base_result=None, adapter_name: str = "default"
+    ) -> torch.Tensor:
+        """
+        For DoRA, calculate the extra output from LoRA with DoRA applied. This should be added on top of the base layer
+        output.
+        """
+        weight = base_layer.weight
+        lora_weight = self.get_lora_weight(lora_A=lora_A, lora_B=lora_B, adapter_name=adapter_name).reshape(
+            weight.shape
+        )
+        magnitude = self.weight
+        weight_norm = self.get_weight_norm(
+            weight=weight, lora_weight=lora_weight.detach(), scaling=scaling, adapter_name=adapter_name
+        )
+        # see section 4.3 of DoRA (https://huggingface.co/papers/2402.09353)
+        # "[...] we suggest treating ||V +∆V ||_c in
+        # Eq. (5) as a constant, thereby detaching it from the gradient
+        # graph. This means that while ||V + ∆V ||_c dynamically
+        # reflects the updates of ∆V , it won’t receive any gradient
+        # during backpropagation"
+        weight_norm = weight_norm.detach()
+        mag_norm_scale = magnitude / weight_norm
+
+        if base_result is None:
+            base_result = self.conv_fn(
+                x,
+                weight,
+                bias=None,
+                stride=base_layer.stride,
+                padding=base_layer.padding,
+                dilation=base_layer.dilation,
+                groups=base_layer.groups,
+            )
+        else:
+            bias = base_layer.bias
+            if bias is not None:
+                # reshape bias to (1, -1, 1, ...)
+                bias_shape = (1, -1) + (1,) * (base_result.dim() - 2)
+                base_result = base_result - bias.view(*bias_shape)
+
+        result_dora = (mag_norm_scale - 1) * base_result + mag_norm_scale * lora_B(lora_A(x)) * scaling
+        return result_dora
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "lora.dora." + rep
+
+
+class DoraConv1dLayer(_DoraConvNdLayer):
+    def __init__(self, fan_in_fan_out):
+        super().__init__(fan_in_fan_out)
+        self.conv_fn = F.conv1d
+
+
+class DoraConv2dLayer(_DoraConvNdLayer):
+    def __init__(self, fan_in_fan_out):
+        super().__init__(fan_in_fan_out)
+        self.conv_fn = F.conv2d
+
+
+class DoraConv3dLayer(_DoraConvNdLayer):
+    def __init__(self, fan_in_fan_out):
+        super().__init__(fan_in_fan_out)
+        self.conv_fn = F.conv3d
diff --git a/src/peft/tuners/lora/eetq.py b/src/peft/tuners/lora/eetq.py
new file mode 100644
index 0000000..fe182fb
--- /dev/null
+++ b/src/peft/tuners/lora/eetq.py
@@ -0,0 +1,123 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+from typing import Any, Optional
+
+import torch
+
+from peft.import_utils import is_eetq_available
+from peft.tuners.lora.layer import LoraLayer
+from peft.tuners.tuners_utils import BaseTunerLayer
+
+from .config import LoraConfig
+
+
+if is_eetq_available():
+    from eetq import EetqLinear
+
+    try:
+        from transformers.integrations.eetq import EetqLinear as TransformersEetqLinear
+
+        # in newer transformers versions, EETQ quantization uses a transformers-specific class
+        eetq_classes = (EetqLinear, TransformersEetqLinear)
+    except ImportError:
+        eetq_classes = (EetqLinear,)
+
+    class EetqLoraLinear(torch.nn.Module, LoraLayer):
+        def __init__(
+            self,
+            base_layer,
+            adapter_name,
+            config: LoraConfig,
+            r: int = 0,
+            lora_alpha: int = 1,
+            **kwargs,
+        ):
+            if config.use_dora:
+                raise ValueError(f"{self.__class__.__name__} does not support DoRA yet, please set it to False")
+            if config.velora_config is not None:
+                raise ValueError(f"{self.__class__.__name__} does not support VeLoRA yet, please set it to False")
+
+            super().__init__()
+            LoraLayer.__init__(self, base_layer)
+
+            # self.base_layer and self.quant_linear_module are the same; we need the former for consistency and the latter
+            # for backwards compatibility
+            self.quant_linear_module = base_layer
+
+            self._active_adapter = adapter_name
+            self.update_layer(
+                adapter_name,
+                r,
+                lora_alpha=lora_alpha,
+                config=config,
+            )
+
+        def forward(self, x: torch.Tensor):
+            result = self.quant_linear_module(x)
+
+            if self.disable_adapters:
+                return result
+
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.lora_A.keys():
+                    continue
+                lora_A = self.lora_A[active_adapter]
+                lora_B = self.lora_B[active_adapter]
+                dropout = self.lora_dropout[active_adapter]
+                scaling = self.scaling[active_adapter]
+
+                requires_conversion = not torch.is_autocast_enabled()
+                if requires_conversion:
+                    expected_dtype = result.dtype
+                    x = self._cast_input_dtype(x, lora_A.weight.dtype)
+
+                output = lora_B(lora_A(dropout(x)))
+                if requires_conversion:
+                    output = output.to(expected_dtype)
+                output = output * scaling
+                result = result + output
+            return result
+
+        def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+            raise AttributeError("Merging LoRA layers is not supported for Eetq layers.")
+
+        def unmerge(self) -> None:
+            raise AttributeError("Unmerging LoRA layers is not supported for Eetq layers.")
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return "lora." + rep
+
+
+def dispatch_eetq(
+    target: torch.nn.Module,
+    adapter_name: str,
+    config: LoraConfig,
+    **kwargs: Any,
+) -> Optional[torch.nn.Module]:
+    new_module = None
+
+    if isinstance(target, BaseTunerLayer):
+        target_base_layer = target.get_base_layer()
+    else:
+        target_base_layer = target
+
+    if is_eetq_available() and isinstance(target_base_layer, eetq_classes):
+        new_module = EetqLoraLinear(target, adapter_name, config=config, **kwargs)
+        target.weight = target_base_layer.weight
+
+        if hasattr(target, "bias"):
+            target.bias = target_base_layer.bias
+
+    return new_module
diff --git a/src/peft/tuners/lora/eva.py b/src/peft/tuners/lora/eva.py
new file mode 100644
index 0000000..bc895d1
--- /dev/null
+++ b/src/peft/tuners/lora/eva.py
@@ -0,0 +1,734 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+import warnings
+from collections import Counter, defaultdict
+from collections.abc import Callable, Iterable, Mapping
+from contextlib import nullcontext
+from copy import copy, deepcopy
+from functools import partial
+from itertools import cycle
+from typing import Optional, Union
+
+import torch
+import torch.distributed as dist
+from tqdm import tqdm
+from transformers.pytorch_utils import Conv1D
+
+from peft.tuners.tuners_utils import _find_minimal_target_modules, check_target_module_exists
+from peft.utils.constants import MIN_TARGET_MODULES_FOR_OPTIMIZATION
+from peft.utils.incremental_pca import IncrementalPCA
+from peft.utils.other import _get_submodules, get_pattern_key
+
+from .config import LoraConfig
+from .layer import Embedding, LoraLayer, MultiheadAttention, _ConvNd
+
+
+UNSUPPORTED_LORA_MODULES = (Embedding, MultiheadAttention, _ConvNd)
+
+
+class _Hook:
+    """
+    A base class for hooks that prepares layer inputs for EVA.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        prepare_layer_inputs_fn: Optional[Callable] = None,
+        gather_distributed_inputs: bool = True,
+    ):
+        self.name = name
+        self.gather_distributed_inputs = gather_distributed_inputs
+        if prepare_layer_inputs_fn is None:
+            self._prepare_layer_inputs_fn = self._prepare_layer_inputs_fn_default
+        else:
+            self._prepare_layer_inputs_fn = prepare_layer_inputs_fn
+        self.model_input = None
+
+    @staticmethod
+    def _prepare_layer_inputs_fn_default(layer_input, model_input, layer_name) -> torch.Tensor:
+        if isinstance(layer_input, torch.Tensor):
+            pass
+        elif isinstance(layer_input, (tuple, list)):
+            layer_input = layer_input[0]
+        else:
+            raise TypeError(
+                f"unsupported input type {type(layer_input)} for prepare_layer_inputs_fn in layer {layer_name}, "
+                "please provide a custom prepare_layer_inputs_fn"
+            )
+        # if the input has more than 2 dimensions, we flatten all but the last dimension
+        if layer_input.ndim > 2:
+            layer_input = layer_input.view(-1, layer_input.size(-1))
+        return layer_input
+
+    @torch.no_grad()
+    def prepare_layer_inputs(self, layer_input):
+        return self._prepare_layer_inputs_fn(layer_input, self.model_input, self.name)
+
+    def gather_layer_inputs(self, layer_input):
+        if dist.is_initialized() and self.gather_distributed_inputs:
+            world_size = dist.get_world_size()
+
+            # First gather sizes from all processes more efficiently
+            local_size = torch.tensor([layer_input.shape[0]], device=layer_input.device)
+            all_sizes = torch.empty(world_size, dtype=local_size.dtype, device=layer_input.device)
+            dist.all_gather_into_tensor(all_sizes, local_size)
+            all_sizes = all_sizes.tolist()
+
+            # Find maximum size and pad tensors
+            padded_input = layer_input.new_zeros((max(all_sizes), *layer_input.shape[1:]))
+            padded_input[: layer_input.shape[0]] = layer_input
+
+            # Gather padded tensors
+            gathered_inputs = [torch.zeros_like(padded_input) for _ in range(world_size)]
+            dist.all_gather(gathered_inputs, padded_input.contiguous())
+
+            # Remove padding for each gathered tensor
+            gathered_inputs = [tensor[:size] for tensor, size in zip(gathered_inputs, all_sizes)]
+
+            # Concatenate along batch dimension
+            return torch.cat(gathered_inputs, dim=0)
+        return layer_input
+
+
+class SVDHook(_Hook):
+    """
+    A forward hook for calculating incremental SVD on layer inputs. The hook is designed to be registered to a PyTorch
+    module using the `register_forward_hook` method.
+
+    This hook performs a step of incremental Singular Value Decomposition (SVD) on the inputs of a specified layer
+    during the forward pass of a neural network. The hook also tracks convergence of the computed components using
+    cosine similarity between the current and previous components.
+
+    Args:
+        name (str): Name of the layer to which this hook is attached.
+        n_components (int): Number of principal components to compute.
+        sim_thresh (Union[float, torch.Tensor]): Similarity threshold for convergence.
+        prepare_layer_inputs_fn (Optional[Callable]): Function to prepare layer inputs for SVD.
+    """
+
+    def __init__(
+        self,
+        n_components: int,
+        sim_thresh: Union[float, torch.Tensor],
+        **base_class_kwargs,
+    ):
+        super().__init__(**base_class_kwargs)
+        self.n_components = n_components
+        self.sim_thresh = sim_thresh
+        if isinstance(sim_thresh, torch.Tensor) and len(sim_thresh.shape) > 0:
+            check1 = sim_thresh.size(0) == n_components or sim_thresh.size(0) == 1
+            check2 = len(sim_thresh.shape) == 1
+            if not (check1 and check2):
+                raise ValueError(
+                    "if sim_thresh is a tensor with more than 0 dimensions it must have shape (n_components,) or (1,)"
+                )
+        self.svd = IncrementalPCA(
+            n_components=n_components,
+            copy=True,
+            lowrank=True,
+            lowrank_seed=42,
+        )
+        self.model_input = None
+        self.converged = torch.zeros((n_components,), dtype=torch.bool)
+
+    @torch.no_grad()
+    def __call__(self, model, input, output):
+        previous_components = None
+        if hasattr(self.svd, "components_"):
+            previous_components = self.svd.components_.clone().detach()
+        states = self.prepare_layer_inputs(input)
+        states = self.gather_layer_inputs(states)
+        # check if batch sizes is more than the number of components
+        if states.size(0) < self.n_components:
+            print(f"skipping SVD for {self.name} because there are less than {self.n_components} examples")
+            return
+        self.svd.partial_fit(states.to(torch.float32))
+        # add if statement to check if we are in the first step where previous_components is None
+        if previous_components is None:
+            return
+        components = self.svd.components_
+        if len(components.shape) == 1:
+            components = components.reshape(1, -1)
+            previous_components = previous_components.reshape(1, -1)
+        # consider as converged if enough components have converged via cossim
+        sim = torch.nn.functional.cosine_similarity(components, previous_components)
+        self.converged = sim >= self.sim_thresh
+
+
+# This is used to determine if inputs of two different layers are equal. For such cases, SVD
+# needs to be done for only for one of the equal inputs.
+class HashHook(_Hook):
+    """
+    A forward hook for hashing layer inputs. The hook is designed to be registered to a PyTorch module using the
+    `register_forward_hook` method.
+
+    This hook hashes the inputs of a specified layer during the forward pass of a neural network and stores the hash
+    values for later analysis or comparison.
+
+    Args:
+        name (str): Name of the layer to which this hook is attached. hashed_inputs (list): List of hashed inputs.
+        prepare_layer_inputs_fn (Optional[Callable]): Function to prepare layer inputs for hashing.
+    """
+
+    def __init__(self, **base_class_kwargs):
+        super().__init__(**base_class_kwargs)
+        self.hashed_inputs = []
+
+    @staticmethod
+    def hash_fn(tensor):
+        return hash(tuple(tensor.view(-1).tolist()))
+
+    @torch.no_grad()
+    def __call__(self, model, input, output):
+        x = self.prepare_layer_inputs(input)
+        x = self.gather_layer_inputs(x)
+        self.hashed_inputs.append(self.hash_fn(x.cpu()))
+
+
+def find_equal_values(dictionary: dict) -> dict:
+    """
+    Find keys in a dictionary that have the same value.
+
+    This function takes a dictionary and returns a new dictionary containing keys that have the same value. The keys in
+    the output dictionary are the values from the input dictionary, and the values are lists of keys that share the
+    same value.
+    """
+    value_dict = defaultdict(list)
+    for k, v in dictionary.items():
+        value_dict[v].append(k)
+    return {k: v for k, v in value_dict.items() if len(v) > 1}
+
+
+def get_device_with_meta_params(model: torch.nn.Module) -> torch.device:
+    """
+    Get the device of the model's parameters. Useful if some parameters are on meta device.
+    """
+    devices = list({p.device for p in model.parameters() if p.device.type != "meta"})
+    if len(devices) > 1:
+        warnings.warn(f"Could not determine device, model has multiple devices: {devices}")
+        return
+    return devices[0]
+
+
+def move_inputs_to_device(inputs, device: Union[str, torch.device]):
+    """
+    Move the inputs to the specified device. Adapted from hf.Trainer.
+    """
+    if hasattr(inputs, "to"):
+        return inputs.to(device)
+    if isinstance(inputs, Mapping):
+        return type(inputs)({k: move_inputs_to_device(v, device) for k, v in inputs.items()})
+    elif isinstance(inputs, (tuple, list)):
+        return type(inputs)(move_inputs_to_device(v, device) for v in inputs)
+    else:
+        warnings.warn(f"input of type {type(inputs)} could not be moved to the correct device")
+        return inputs
+
+
+def prepare_model_inputs_fn_language_modeling(model_input, peft_config: LoraConfig):
+    """
+    Get the indices of the items that should be used for SVD.
+
+    Attributes:
+        model_input (dict): The model inputs.
+        peft_config (LoraConfig): The configuration for the LoRA layers.
+    """
+    if not isinstance(model_input, dict):
+        raise TypeError("When using `prepare_model_inputs_fn_language_modeling` inputs must be a dictionary")
+    mask = model_input.get("attention_mask", torch.ones_like(model_input["input_ids"])).bool()
+    if peft_config.eva_config.use_label_mask and ("labels" in model_input):
+        mask = torch.logical_and(mask, model_input["labels"] != peft_config.eva_config.label_mask_value)
+    return mask.nonzero()
+
+
+def prepare_layer_inputs_fn_language_modeling(layer_input, model_input, layer_name) -> torch.Tensor:
+    """
+    if not all items in the input should be used for SVD, this function can be used to get the indices of the items
+    that should be used.
+
+    Attributes:
+        layer_input (torch.Tensor): The layer inputs.
+        model_input (torch.Tensor):
+            The model inputs or if `prepare_model_inputs_fn` is not None the output of this function.
+        layer_name (str): The name of the layer.
+
+    Returns:
+        torch.Tensor: The input to the SVD.
+    """
+    # if layer inputs are not a tensor, we simply get the first item
+    if isinstance(layer_input, torch.Tensor):
+        pass
+    elif isinstance(layer_input, (tuple, list)):
+        layer_input = layer_input[0]
+    else:
+        raise TypeError(
+            f"unsupported input type {type(layer_input)} for prepare_layer_inputs_fn in layer {layer_name}, "
+            "please provide a custom prepare_layer_inputs_fn"
+        )
+    # in this case model_input is the output of `prepare_model_inputs_fn_language_modeling`
+    return layer_input[model_input.T.unbind()]
+
+
+def forward_fn_dict(model, inputs):
+    return model(**inputs)
+
+
+def _get_eva_state_dict(
+    model: torch.nn.Module,
+    dataloader: Iterable,
+    peft_config: Optional[LoraConfig],
+    target_module_check_fn: Callable,
+    forward_fn: Optional[Callable],
+    prepare_model_inputs_fn: Optional[Callable],
+    prepare_layer_inputs_fn: Union[Callable, dict[str, Callable], None],
+    gather_distributed_inputs: bool,
+    show_progress_bar: bool,
+) -> dict:
+    # Computes the rank distribution for each layer based on the explained variance ratio.
+    # when rank_pattern flag is False, all values in max_components are the same
+    def _get_rank_distribution(hooks, layer_hook_map, equal_inputs_map, rank_budget, max_components):
+        exp_vars = {k: h[0].svd.explained_variance_ratio_[: max_components[k]] for k, h in hooks.items()}
+        keys, values = zip(*[(k, c) for k, name in layer_hook_map.items() for c in exp_vars[name]])
+        idx = torch.stack(values).argsort(descending=True)
+        counts = Counter([keys[i] for i in idx[:rank_budget]])
+        counts = {k: counts.get(k, 0) for k in layer_hook_map.keys()}  # add layers with 0 rank
+        for k, k_hook in equal_inputs_map.items():
+            # ensure hook layers have the highest rank if they are equal to another layer
+            rank, rank_hook = counts[k], counts[k_hook]
+            if rank_hook >= rank:
+                continue
+            counts[k_hook], counts[k] = rank, rank_hook
+        return counts
+
+    # dataloader is not empty
+    if len(dataloader) == 0:
+        raise ValueError("dataloader is empty")
+
+    # check if dist is initialized
+    if dist.is_initialized() and gather_distributed_inputs:
+        warnings.warn(
+            "torch.distributed is initialized and `gather_distributed_inputs` is True, "
+            "therefore EVA initialization will gather tensors from all ranks. "
+            "Ensure the model does not receive the same inputs on different ranks."
+        )
+
+    # for unusually high rho values, define an upper limit
+    rho_threshold = 1000
+    rho = peft_config.eva_config.rho
+    if rho > rho_threshold:
+        max_dim = max(max(p.shape) for p in model.parameters())
+        rho_ceil = max_dim // peft_config.r
+        rho = min(rho, rho_ceil)
+
+    training = model.training
+    device = get_device_with_meta_params(model)
+    model.eval()
+
+    # get model inputs
+    inputs = next(iter(dataloader))
+    if device is not None:
+        inputs = move_inputs_to_device(inputs, device)
+    if prepare_model_inputs_fn is not None:
+        model_inputs_for_hooks = prepare_model_inputs_fn(inputs, peft_config)
+    else:
+        model_inputs_for_hooks = deepcopy(inputs)
+
+    hooks = {}
+    max_components = {}
+    rank_budget = 0
+    for name, module in model.named_modules():
+        if not target_module_check_fn(name, module):
+            continue
+        if isinstance(prepare_layer_inputs_fn, Mapping):
+            fn = prepare_layer_inputs_fn.pop(name, None)
+        else:
+            fn = prepare_layer_inputs_fn
+        hook = HashHook(name=name, prepare_layer_inputs_fn=fn, gather_distributed_inputs=gather_distributed_inputs)
+        hook.model_input = model_inputs_for_hooks
+        handle = module.register_forward_hook(hook)
+        hooks[name] = (hook, handle)
+        layer_rank = peft_config.rank_pattern.get(
+            get_pattern_key(peft_config.rank_pattern.keys(), name), peft_config.r
+        )
+        max_components[name] = round(layer_rank * rho)
+        rank_budget += layer_rank
+    if isinstance(prepare_layer_inputs_fn, Mapping) and len(prepare_layer_inputs_fn) > 0:
+        raise ValueError(
+            "prepare_layer_inputs_fn is a mapping but the following module names were not found in the model: "
+            f"{prepare_layer_inputs_fn.keys()}"
+        )
+
+    # forward for one batch to check which layer inputs are equal to avoid unneeded svd calculations
+    forward_fn(model, inputs)
+    hash_dict = {k: h[0].hashed_inputs[0] for k, h in hooks.items()}
+    # equal input maps groups layers which receive the same input. One layer is defined as the key and receives an svd
+    # hook. For the remaining layers the svd results can be skipped.
+    equal_inputs = list(find_equal_values(hash_dict).values())
+    equal_inputs_map = {vv: v[0] for v in equal_inputs for vv in v[1:]}
+    # for layers with equal inputs we need to make sure that the max_components are the same
+    for names in equal_inputs:
+        max_value = max(max_components[n] for n in names)
+        for n in names:
+            max_components[n] = max_value
+
+    # initialize svd hooks
+    for name in list(hooks.keys()):
+        hook, handle = hooks.pop(name)
+        handle.remove()
+        if name in equal_inputs_map:
+            continue
+        hook = SVDHook(
+            n_components=max_components[name],
+            sim_thresh=peft_config.eva_config.tau,
+            name=name,
+            prepare_layer_inputs_fn=hook._prepare_layer_inputs_fn,
+            gather_distributed_inputs=gather_distributed_inputs,
+        )
+        module = model.get_submodule(name)
+        handle = module.register_forward_hook(hook)
+        hooks[name] = (hook, handle)  # adding the old handle here so we dont get errors in the first forward pass
+    layer_hook_map = {**dict(zip(hooks.keys(), hooks.keys())), **equal_inputs_map}
+
+    # start svd calculation
+    if show_progress_bar and (not dist.is_initialized() or dist.get_rank() == 0):
+        pbar = tqdm(iter(cycle(dataloader)), position=0, leave=False)
+        use_tqdm = True
+    else:
+        pbar = iter(cycle(dataloader))
+        use_tqdm = False
+    convergence_dict = {k: False for k in hooks.keys()}
+    rank_dist = max_components.copy()
+    for inputs in pbar:
+        if device is not None:
+            inputs = move_inputs_to_device(inputs, device)
+        if prepare_model_inputs_fn is not None:
+            model_inputs_for_hooks = prepare_model_inputs_fn(inputs, peft_config)
+        else:
+            model_inputs_for_hooks = deepcopy(inputs)
+
+        for name in list(hooks.keys()):
+            hook, handle = hooks[name]
+            # check if all components that are needed for the rank distribution have converged
+            converged = torch.all(hook.converged[: rank_dist[name]])
+            # if a layer has switched from not converged to converged in the current step
+            if (not convergence_dict[name]) and converged and handle:
+                handle.remove()
+                handle = None
+                convergence_dict[name] = True
+                continue
+            # if a layer has switched from converged to not converged in the current step
+            elif convergence_dict[name] and not converged:
+                module = model.get_submodule(name)
+                handle = module.register_forward_hook(hook)
+                convergence_dict[name] = False
+            hook.model_input = model_inputs_for_hooks
+            hooks[name] = (hook, handle)
+
+        if use_tqdm:
+            layer_converged = list(convergence_dict.values()) + [
+                convergence_dict[v] for v in equal_inputs_map.values()
+            ]
+            pbar.set_description(f"{sum(layer_converged)}/{len(layer_converged)} layers have converged")
+
+        if all(convergence_dict.values()):
+            break
+
+        forward_fn(model, inputs)
+
+        # in case some hooks have to skip the svd calculation because the number of tokens is less than the number of
+        # components
+        if not all(hasattr(h[0].svd, "components_") for h in hooks.values()):
+            continue
+
+        rank_dist = _get_rank_distribution(hooks, layer_hook_map, equal_inputs_map, rank_budget, max_components)
+
+    # check all custom hooks have been removed
+    remaining_hooks = {n for n, m in model.named_modules() for v in m._forward_hooks.values() if isinstance(v, _Hook)}
+    if len(remaining_hooks) > 0:
+        raise ValueError(
+            f"Found active hooks added by EVA that weren't properly removed: {remaining_hooks}. "
+            "Please report this issue at https://github.com/huggingface/peft/issues"
+        )
+
+    eva_state_dict = {}
+    for name, rank in rank_dist.items():
+        hook = hooks[layer_hook_map[name]][0]
+        if not torch.all(hook.converged[:rank]):
+            raise ValueError(
+                f"Layer {name} has not converged but was assigned rank {rank}. "
+                "Please report this issue at https://github.com/huggingface/peft/issues"
+            )
+        u = hook.svd.components_[:rank]
+        if peft_config.eva_config.whiten:
+            u /= hook.svd.singular_values_[:rank].sqrt().reshape(-1, 1)
+        eva_state_dict[name] = u
+
+    # restore model state
+    model.train(training)
+
+    # move tensors to device
+    if device is not None:
+        eva_state_dict = {k: v.to(device) for k, v in eva_state_dict.items()}
+
+    return eva_state_dict
+
+
+def _load_eva_state_dict(
+    model: torch.nn.Module,
+    eva_state_dict: dict,
+    adapter_name: str,
+):
+    peft_config = copy(model.peft_config[adapter_name])
+    missing_eva_inits = []
+    new_target_modules = []
+    other_module_names = []
+    rank_pattern = {}
+    alpha_pattern = {}
+    for name, module in model.named_modules():
+        name_in_base_model = name.replace("base_model.model.", "")
+        if not isinstance(module, LoraLayer):
+            other_module_names.append(name_in_base_model)
+            continue
+        # Regexp matching - Find key which matches current target_name in patterns provided
+        r = peft_config.rank_pattern.get(get_pattern_key(peft_config.rank_pattern.keys(), name), peft_config.r)
+        alpha = peft_config.alpha_pattern.get(
+            get_pattern_key(peft_config.alpha_pattern.keys(), name), peft_config.lora_alpha
+        )
+        if name in eva_state_dict:
+            w = eva_state_dict.pop(name)
+            new_rank = w.size(0)
+            if new_rank == 0:
+                parent, _, target_name = _get_submodules(model, name)
+                setattr(parent, target_name, module.get_base_layer())
+                continue
+            elif new_rank != r:
+                if peft_config.eva_config.adjust_scaling_factors:
+                    alpha *= new_rank / r
+            if new_rank != r or module.lora_A[adapter_name].weight.device.type == "meta":
+                peft_config.init_lora_weights = "eva"
+                module.update_layer(adapter_name=adapter_name, r=new_rank, lora_alpha=alpha, config=peft_config)
+            module.lora_A[adapter_name].weight.copy_(w)
+            new_target_modules.append(name_in_base_model)
+        else:
+            peft_config.init_lora_weights = True
+            module.update_layer(adapter_name=adapter_name, r=r, lora_alpha=alpha, config=peft_config)
+            missing_eva_inits.append(name_in_base_model)
+            new_rank = r
+        # update rank pattern and alpha pattern
+        if new_rank != peft_config.r:
+            rank_pattern[name_in_base_model] = new_rank
+        if alpha != peft_config.lora_alpha:
+            alpha_pattern[name_in_base_model] = alpha
+
+    # update target modules if some lora layers have been removed due to their EVA rank being 0
+    new_target_modules = new_target_modules + missing_eva_inits
+    if len(new_target_modules) >= MIN_TARGET_MODULES_FOR_OPTIMIZATION:
+        new_target_modules = _find_minimal_target_modules(new_target_modules, other_module_names)
+    model.peft_config[adapter_name].target_modules = new_target_modules
+
+    # set rank pattern obtained from EVA
+    model.peft_config[adapter_name].rank_pattern = rank_pattern
+
+    # when adjust_scaling_factors is True, lora scaling factors have been adjusted after the rank redistribution
+    model.peft_config[adapter_name].alpha_pattern = alpha_pattern
+
+    if missing_eva_inits:
+        warnings.warn(
+            "the following layers were initialized with init_lora_weights=True because they "
+            f"were not found in the eva state_dict: {missing_eva_inits}\ncurrently the "
+            f"following lora modules are not supported by EVA: {UNSUPPORTED_LORA_MODULES}"
+        )
+
+
+@torch.no_grad()
+def get_eva_state_dict(
+    model: torch.nn.Module,
+    dataloader: Iterable,
+    peft_config: Optional[LoraConfig] = None,
+    forward_fn: Optional[Callable] = forward_fn_dict,
+    prepare_model_inputs_fn: Optional[Callable] = prepare_model_inputs_fn_language_modeling,
+    prepare_layer_inputs_fn: Union[Callable, dict[str, Callable], None] = prepare_layer_inputs_fn_language_modeling,
+    adapter_name: str = "default",
+    gather_distributed_inputs: bool = True,
+    show_progress_bar: bool = True,
+) -> dict:
+    """
+    Compute the SVD for each layer in the model.
+
+    This function computes the Singular Value Decomposition (SVD) for each layer in the model. It uses the incremental
+    PCA method to compute the SVD components. The function also checks for convergence of the computed components using
+    cosine similarity. The rank distribution for each layer is determined based on the explained variance ratio.
+
+    Args:
+        model (torch.nn.Module): The model to compute the SVD for. Does not need to be a PeftModel.
+        dataloader (Iterable): The dataloader to use for the forward pass.
+        peft_config (Optional[LoraConfig]):
+            The configuration for the LoRA layers. Only required if `model` is not a PeftModel.
+        forward_fn (Callable):
+            The forward function to use for the forward pass. Takes two arguments: `model` and `inputs`. Default
+            behavior is `return model(**inputs)`
+        prepare_model_inputs_fn (Optional[Callable]):
+            This function receives the model inputs and the peft_config and passes the output to
+            `prepare_layer_inputs_fn`. Can be used to modify the input to the SVD computation based on the original
+            model inputs. For example for language modeling the attention mask is used to determine which indices are
+            padding tokens and should not be used for SVD. Any function defined here expects two arguments:
+            `model_input` and `peft_config`. `peft.tuners.lora.eva.prepare_model_inputs_fn_language_modeling` is used
+            by default.
+        prepare_layer_inputs_fn (Union[Callable, Dict[str, Callable], None]):
+            This function receives the layer inputs, the model inputs (potentially modified by
+            `prepare_model_inputs_fn`) and the name of the layer and returns the inputs that should be used for SVD for
+            that particular layer. Any custom function defined here expects three arguments: `layer_input`,
+            `model_input`, and `layer_name` and should return a 2d tensor. The default logic can be found in
+            peft.tuners.lora.eva.prepare_layer_inputs_fn_language_modeling and works for language modeling. In this
+            case model_inputs is the mask used to determine which indices should be used for SVD (created by
+            `prepare_model_inputs_fn_language_modeling`).
+        adapter_name (str): The name of the adapter to compute the SVD for.
+        gather_distributed_inputs (bool):
+            Whether to gather the layer inputs from all ranks. Default is True meaning in a distributed setting the
+            layer inputs will be gathered from all ranks for the SVD computation. For non-distributed settings this
+            argument is ignored. Set to False if you are using a non-distributed dataloader in a distributed setting.
+        show_progress_bar (bool): Whether to show a progress bar. Default is True.
+
+    Returns:
+        eva_state_dict (dict): The state dictionary containing the SVD components for each layer.
+    """
+
+    def target_module_check_fn_peft_model(name, module, unsupported_lora_modules):
+        "check if a module is an adapter module via base_layer attribute"
+        return hasattr(module, "base_layer") and not isinstance(module, unsupported_lora_modules)
+
+    def target_module_check_fn_default(name, module, peft_config):
+        "check if a module is an adapter module via target_modules"
+        is_target_module = True
+        if peft_config.target_modules is not None:
+            is_target_module = check_target_module_exists(peft_config, name)
+        # Conv1D for GPT2 support
+        return isinstance(module, (torch.nn.Linear, Conv1D)) and is_target_module
+
+    is_peft_model = hasattr(model, "peft_config")
+
+    # get peft_config
+    if is_peft_model and peft_config is None:
+        peft_config = model.peft_config[adapter_name]
+    elif peft_config is None:
+        raise ValueError("peft_config is required if model is not a PeftModel")
+
+    # setup context and target module check function
+    if is_peft_model:
+        ctx = model.disable_adapter()
+        target_module_check_fn = partial(
+            target_module_check_fn_peft_model, unsupported_lora_modules=UNSUPPORTED_LORA_MODULES
+        )
+    else:
+        ctx = nullcontext()
+        target_module_check_fn = partial(target_module_check_fn_default, peft_config=peft_config)
+
+    with ctx:
+        eva_state_dict = _get_eva_state_dict(
+            model=model,
+            dataloader=dataloader,
+            peft_config=peft_config,
+            target_module_check_fn=target_module_check_fn,
+            forward_fn=forward_fn,
+            prepare_model_inputs_fn=prepare_model_inputs_fn,
+            prepare_layer_inputs_fn=prepare_layer_inputs_fn,
+            gather_distributed_inputs=gather_distributed_inputs,
+            show_progress_bar=show_progress_bar,
+        )
+    return eva_state_dict
+
+
+@torch.no_grad()
+def initialize_lora_eva_weights(
+    model: torch.nn.Module,
+    dataloader: Optional[Iterable] = None,
+    eva_state_dict: Optional[dict] = None,
+    forward_fn: Optional[Callable] = forward_fn_dict,
+    prepare_model_inputs_fn: Optional[Callable] = prepare_model_inputs_fn_language_modeling,
+    prepare_layer_inputs_fn: Union[Callable, dict[str, Callable], None] = prepare_layer_inputs_fn_language_modeling,
+    adapter_name: str = "default",
+    gather_distributed_inputs: bool = True,
+    show_progress_bar: bool = True,
+):
+    """
+    Initialize the weights of the LoRA layers using the EVA method.
+
+    This function initializes the weights of the LoRA layers using the EVA method. It computes the SVD for each adapter
+    layer and updates the weights accordingly.
+
+    Args:
+        model (PeftModel): The peft model to compute the SVD for.
+        dataloader (Optional[Iterable]):
+            The dataloader to use for the forward pass. If None, eva_state_dict needs to be provided.
+        eva_state_dict (Optional[dict]):
+            The state_dict to load into the model. If None, a dataloader needs to be provided and the state_dict will
+            be computed using `get_eva_state_dict`.
+        forward_fn (Callable):
+            The forward function to use for the forward pass. Takes two arguments: `model` and `inputs`. Default
+            behavior is `return model(**inputs)`
+        prepare_model_inputs_fn (Optional[Callable]):
+            This function receives the model inputs and the peft_config and passes the output to
+            `prepare_layer_inputs_fn`. Can be used to modify the input to the SVD computation based on the original
+            model inputs. For example for language modeling the attention mask is used to determine which indices are
+            padding tokens and should not be used for SVD. Any function defined here expects two arguments:
+            `model_input` and `peft_config`. `peft.tuners.lora.eva.prepare_model_inputs_fn_language_modeling` is used
+            by default.
+        prepare_layer_inputs_fn (Union[Callable, Dict[str, Callable], None]):
+            This function receives the layer inputs, the model inputs (potentially modified by
+            `prepare_model_inputs_fn`) and the name of the layer and returns the inputs that should be used for SVD for
+            that particular layer. Any custom function defined here expects three arguments: `layer_input`,
+            `model_input`, and `layer_name` and should return a 2d tensor. The default logic can be found in
+            peft.tuners.lora.eva.prepare_layer_inputs_fn_language_modeling and works for language modeling. In this
+            case model_inputs is the mask used to determine which indices should be used for SVD (created by
+            `prepare_model_inputs_fn_language_modeling`).
+        adapter_name (str): The name of the adapter to initialize the weights for.
+        gather_distributed_inputs (bool):
+            Whether to gather the layer inputs from all ranks. Default is True meaning in a distributed setting the
+            layer inputs will be gathered from all ranks for the SVD computation. For non-distributed settings this
+            argument is ignored. Set to False if you are using a non-distributed dataloader in a distributed setting.
+        show_progress_bar (bool): Whether to show a progress bar. Default is True.
+
+    Returns:
+        model (torch.nn.Module): The model with the initialized LoRA weights.
+    """
+    if not hasattr(model, "peft_config"):
+        raise ValueError("model must be a PeftModel")
+
+    # eva currently only works with a single active adapter
+    # Important: when removing this requirement, make sure eva init works correctly if the new rank is 0.
+    if len(model.active_adapters) > 1:
+        raise ValueError("`initialize_lora_eva_weights` currently only works with a single active adapter")
+
+    # initialize_lora_eva_weights only works with `init_lora_weights='eva'`
+    if model.peft_config[adapter_name].init_lora_weights != "eva":
+        raise ValueError("`initialize_lora_eva_weights` can only be used with `init_lora_weights='eva'`")
+
+    # compute svd
+    if eva_state_dict is None:
+        if dataloader is None:
+            raise ValueError("dataloader is required if eva_state_dict is not provided")
+        eva_state_dict = get_eva_state_dict(
+            model=model,
+            dataloader=dataloader,
+            forward_fn=forward_fn,
+            prepare_model_inputs_fn=prepare_model_inputs_fn,
+            prepare_layer_inputs_fn=prepare_layer_inputs_fn,
+            adapter_name=adapter_name,
+            gather_distributed_inputs=gather_distributed_inputs,
+            show_progress_bar=show_progress_bar,
+        )
+
+    _load_eva_state_dict(model, eva_state_dict, adapter_name)
diff --git a/src/peft/tuners/lora/gptq.py b/src/peft/tuners/lora/gptq.py
new file mode 100644
index 0000000..7f78718
--- /dev/null
+++ b/src/peft/tuners/lora/gptq.py
@@ -0,0 +1,133 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+from typing import Any, Optional
+
+import torch
+
+from peft.tuners.lora.layer import LoraLayer
+from peft.tuners.tuners_utils import BaseTunerLayer
+
+from ...import_utils import is_gptqmodel_available
+from .config import LoraConfig
+from .layer import LoraVariant
+
+
+class GPTQLoraLinear(torch.nn.Module, LoraLayer):
+    def __init__(
+        self,
+        base_layer,
+        adapter_name: str,
+        config: LoraConfig,
+        r: int = 0,
+        lora_alpha: int = 1,
+        **kwargs,
+    ):
+        super().__init__()
+        LoraLayer.__init__(self, base_layer)
+
+        if config.use_dora:
+            raise ValueError(f"{self.__class__.__name__} does not support DoRA yet, please set it to False")
+        if config.velora_config is not None:
+            raise ValueError(f"{self.__class__.__name__} does not support VeLoRA yet, please set it to False")
+
+        # self.base_layer and self.quant_linear_module are the same; we need the former for consistency and the latter
+        # for backwards compatibility
+        self.quant_linear_module = base_layer
+        self._active_adapter = adapter_name
+        self.update_layer(
+            adapter_name,
+            r,
+            lora_alpha=lora_alpha,
+            config=config,
+        )
+
+    def resolve_lora_variant(self, *, config: LoraConfig, **kwargs) -> Optional[LoraVariant]:
+        if config.velora_config is not None:
+            raise ValueError(f"{self.__class__.__name__} does not support VeLoRA.")
+        if config.use_dora and config.use_qalora:
+            raise NotImplementedError(
+                f"DoRA and QA-LoRA at the same time is not supported for {self.__class__.__name__} (yet)."
+            )
+        elif config.use_dora:
+            from .variants import DoraLinearVariant
+
+            variant = DoraLinearVariant()
+        elif config.use_qalora:
+            from .variants import QALoraLinearVariant
+
+            variant = QALoraLinearVariant()
+        else:
+            variant = None
+        return variant
+
+    def forward(self, x: torch.Tensor):
+        # note: logic differs from default Linear because merging is not supported
+        result = self.quant_linear_module(x)
+
+        if self.disable_adapters:
+            return result
+
+        lora_A_keys = self.lora_A.keys()
+
+        for active_adapter in self.active_adapters:
+            if active_adapter not in lora_A_keys:
+                continue
+            torch_result_dtype = result.dtype
+
+            lora_A = self.lora_A[active_adapter]
+            lora_B = self.lora_B[active_adapter]
+            dropout = self.lora_dropout[active_adapter]
+            scaling = self.scaling[active_adapter]
+
+            x = self._cast_input_dtype(x, lora_A.weight.dtype)
+
+            if active_adapter not in self.lora_variant:  # vanilla LoRA
+                result = result + lora_B(lora_A(dropout(x))) * scaling
+            else:
+                result = self.lora_variant[active_adapter].forward(
+                    self,
+                    active_adapter=active_adapter,
+                    x=x,
+                    result=result,
+                )
+
+            result = result.to(torch_result_dtype)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "lora." + rep
+
+
+def dispatch_gptq(
+    target: torch.nn.Module,
+    adapter_name: str,
+    config: LoraConfig,
+    **kwargs: Any,
+) -> Optional[torch.nn.Module]:
+    new_module = None
+
+    if isinstance(target, BaseTunerLayer):
+        target_base_layer = target.get_base_layer()
+    else:
+        target_base_layer = target
+
+    if is_gptqmodel_available():
+        from gptqmodel.nn_modules.qlinear import BaseQuantLinear
+
+        if isinstance(target_base_layer, BaseQuantLinear):
+            new_module = GPTQLoraLinear(target, adapter_name, config=config, **kwargs)
+            target.qweight = target_base_layer.qweight
+
+    return new_module
diff --git a/src/peft/tuners/lora/hqq.py b/src/peft/tuners/lora/hqq.py
new file mode 100644
index 0000000..0e29127
--- /dev/null
+++ b/src/peft/tuners/lora/hqq.py
@@ -0,0 +1,246 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import copy
+import warnings
+from typing import Any, Optional
+
+import torch
+
+from peft.import_utils import is_hqq_available
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+from peft.utils.other import transpose
+
+from .config import LoraConfig
+from .layer import LoraLayer, LoraVariant
+
+
+if is_hqq_available():
+    from hqq.core.quantize import HQQLinear
+
+    class HqqLoraLinear(torch.nn.Module, LoraLayer):
+        # Lora implemented in a dense layer
+        def __init__(
+            self,
+            base_layer: torch.nn.Module,
+            adapter_name: str,
+            config: LoraConfig,
+            r: int = 0,
+            lora_alpha: int = 1,
+            **kwargs,
+        ) -> None:
+            if config.lora_bias:
+                raise ValueError(f"{self.__class__.__name__} does not support lora_bias yet, set it to False")
+
+            super().__init__()
+            LoraLayer.__init__(self, base_layer)
+            self.fan_in_fan_out = False
+
+            self._active_adapter = adapter_name
+            self.update_layer(
+                adapter_name,
+                r,
+                lora_alpha=lora_alpha,
+                config=config,
+            )
+
+        def resolve_lora_variant(self, *, config: LoraConfig, **kwargs) -> Optional[LoraVariant]:
+            if config.velora_config is not None:
+                raise ValueError(f"{self.__class__.__name__} does not support VeLoRA.")
+            if not config.use_dora:
+                return None
+
+            from .variants import DoraLinearVariant
+
+            return DoraLinearVariant()
+
+        def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+            """
+            Merge the active adapter weights into the base weights
+
+            Args:
+                safe_merge (`bool`, *optional*):
+                    If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                    before merging the weights. This is useful if you want to check if the merge operation will produce
+                    NaNs. Defaults to `False`.
+                adapter_names (`list[str]`, *optional*):
+                    The list of adapter names that should be merged. If None, all active adapters will be merged.
+                    Defaults to `None`.
+            """
+            adapter_names = check_adapters_to_merge(self, adapter_names)
+            if not adapter_names:
+                # no adapter to merge
+                return
+
+            for active_adapter in adapter_names:
+                if active_adapter not in self.lora_A.keys():
+                    continue
+
+                layer = self.get_base_layer()
+                quant_config = {**copy.deepcopy(layer.quant_config), "offload_meta": layer.offload_meta}
+
+                output = layer.dequantize()
+                if active_adapter not in self.lora_variant:  # vanilla LoRA
+                    lora_data = self.get_delta_weight(active_adapter)
+                    w_data = output + lora_data
+                else:
+                    w_data = self.lora_variant[active_adapter].merge_safe(self, active_adapter, output)
+
+                if safe_merge and not torch.isfinite(w_data).all():
+                    raise ValueError(
+                        f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                    )
+
+                new_hqq_layer = HQQLinear(None, quant_config, compute_dtype=layer.compute_dtype, device=layer.device)
+                quant_config.pop("offload_meta", None)
+                new_hqq_layer.quantize(w_data, **quant_config)
+                self.base_layer = new_hqq_layer
+                self.merged_adapters.append(active_adapter)
+
+        def unmerge(self) -> None:
+            """
+            This method unmerges all merged adapter layers from the base weights.
+            """
+            if not self.merged:
+                warnings.warn("Already unmerged. Nothing to do.")
+                return
+
+            while len(self.merged_adapters) > 0:
+                active_adapter = self.merged_adapters.pop()
+                if active_adapter not in self.lora_A.keys():
+                    continue
+
+                layer = self.get_base_layer()
+                quant_config = {**copy.deepcopy(layer.quant_config), "offload_meta": layer.offload_meta}
+                output = layer.dequantize()
+
+                if active_adapter not in self.lora_variant:  # vanilla LoRA
+                    lora_data = self.get_delta_weight(active_adapter)
+                    w_data = output.to(lora_data.dtype).to(lora_data.device) - lora_data
+                else:
+                    w_data = self.lora_variant[active_adapter].unmerge(self, active_adapter, output)
+
+                new_hqq_layer = HQQLinear(None, quant_config, compute_dtype=layer.compute_dtype, device=layer.device)
+                quant_config.pop("offload_meta", None)
+                new_hqq_layer.quantize(w_data, **quant_config)
+                self.base_layer = new_hqq_layer
+
+        def get_delta_weight(self, adapter):
+            return (
+                transpose(
+                    self.lora_B[adapter].weight @ self.lora_A[adapter].weight,
+                    False,
+                )
+                * self.scaling[adapter]
+            )
+
+        def _mixed_batch_forward(
+            self, x: torch.Tensor, *args: Any, adapter_names: list[str], **kwargs: Any
+        ) -> torch.Tensor:
+            # This is a special method that handles the case when users pass the argument `adapter_names`. This is an
+            # extra argument that allows mixing different adapters in the same batch at inference time.
+            result = self.base_layer(x, *args, **kwargs)
+
+            unique_adapters = set(adapter_names)
+            sub_batch_indices_list = []
+            for adapter in unique_adapters:
+                sub_batch_indices_list.append([index for index, item in enumerate(adapter_names) if item == adapter])
+
+            for i, active_adapter in enumerate(unique_adapters):
+                if active_adapter == "__base__":
+                    continue
+                if active_adapter not in self.lora_A.keys():
+                    continue
+
+                lora_A = self.lora_A[active_adapter]
+                lora_B = self.lora_B[active_adapter]
+                dropout = self.lora_dropout[active_adapter]
+                scaling = self.scaling[active_adapter]
+
+                requires_conversion = not torch.is_autocast_enabled()
+                if requires_conversion:
+                    expected_dtype = result.dtype
+                    x = self._cast_input_dtype(x, lora_A.weight.dtype)
+
+                # getting the sub-batch, passing it to LoRA layers and updating the corresponding indices of the linear
+                # layer output
+                sub_batch = x[sub_batch_indices_list[i]]
+                output = lora_B(lora_A(dropout(sub_batch))) * scaling
+                if requires_conversion:
+                    output = output.to(expected_dtype)
+                result[sub_batch_indices_list[i]] += output
+
+            return result
+
+        def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+            self._check_forward_args(x, *args, **kwargs)
+            adapter_names = kwargs.pop("adapter_names", None)
+
+            if self.disable_adapters:
+                if self.merged:
+                    self.unmerge()
+                result = self.base_layer(x, *args, **kwargs)
+            elif adapter_names is not None:
+                result = self._mixed_batch_forward(x, *args, adapter_names=adapter_names, **kwargs)
+            elif self.merged:
+                result = self.base_layer(x, *args, **kwargs)
+            else:
+                result = self.base_layer(x, *args, **kwargs)
+
+                for active_adapter in self.active_adapters:
+                    if active_adapter not in self.lora_A.keys():
+                        continue
+                    lora_A = self.lora_A[active_adapter]
+                    lora_B = self.lora_B[active_adapter]
+                    dropout = self.lora_dropout[active_adapter]
+                    scaling = self.scaling[active_adapter]
+
+                    requires_conversion = not torch.is_autocast_enabled()
+                    if requires_conversion:
+                        expected_dtype = result.dtype
+                        x = self._cast_input_dtype(x, lora_A.weight.dtype)
+
+                    if active_adapter not in self.lora_variant:  # vanilla LoRA
+                        result = result + lora_B(lora_A(dropout(x))) * scaling
+                    else:
+                        result = self.lora_variant[active_adapter].forward(
+                            self,
+                            active_adapter=active_adapter,
+                            x=x,
+                            result=result,
+                        )
+
+                    if requires_conversion:
+                        result = result.to(expected_dtype)
+
+            return result
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return "lora." + rep
+
+
+def dispatch_hqq(target: torch.nn.Module, adapter_name: str, config: LoraConfig, **kwargs):
+    new_module = None
+
+    if isinstance(target, BaseTunerLayer):
+        target_base_layer = target.get_base_layer()
+    else:
+        target_base_layer = target
+
+    if is_hqq_available() and isinstance(target_base_layer, HQQLinear):
+        new_module = HqqLoraLinear(target_base_layer, adapter_name, config=config, **kwargs)
+
+    return new_module
diff --git a/src/peft/tuners/lora/inc.py b/src/peft/tuners/lora/inc.py
new file mode 100644
index 0000000..60d92ea
--- /dev/null
+++ b/src/peft/tuners/lora/inc.py
@@ -0,0 +1,80 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+# NOTE: PEFT tests related to INC are handled under Optimum-Habana repository:
+# - LLMs: https://github.com/huggingface/optimum-habana/blob/main/tests/test_peft_inference.py
+# - Diffusers: https://github.com/huggingface/optimum-habana/blob/main/tests/test_diffusers.py
+
+from typing import Optional
+
+import torch
+
+from peft.import_utils import is_inc_available
+from peft.tuners.tuners_utils import BaseTunerLayer
+
+from .config import LoraConfig
+from .layer import Linear
+
+
+if is_inc_available():
+
+    class IncLoraLinear(Linear):
+        def __init__(
+            self,
+            base_layer: torch.nn.Module,
+            adapter_name: str,
+            config: LoraConfig,
+            **kwargs,
+        ):
+            super().__init__(base_layer, adapter_name, config=config, **kwargs)
+
+        def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+            """
+            Merge the active adapter weights into the base weights
+
+            Args:
+                safe_merge (`bool`, *optional*):
+                    If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                    before merging the weights. This is useful if you want to check if the merge operation will produce
+                    NaNs. Defaults to `False`.
+                adapter_names (`list[str]`, *optional*):
+                    The list of adapter names that should be merged. If None, all active adapters will be merged.
+                    Defaults to `None`.
+            """
+            raise NotImplementedError("Merging LoRA with INC layers is not yet implemented")
+
+        def unmerge(self) -> None:
+            """
+            This method unmerges all merged adapter layers from the base weights.
+            """
+            raise NotImplementedError("Unmerging LoRA from INC layers is not yet implemented")
+
+
+def dispatch_inc(target: torch.nn.Module, adapter_name: str, config: LoraConfig, **kwargs):
+    new_module = None
+
+    if isinstance(target, BaseTunerLayer):
+        target_base_layer = target.get_base_layer()
+    else:
+        target_base_layer = target
+
+    if is_inc_available():
+        from neural_compressor.torch.algorithms.fp8_quant._quant_common.helper_modules import (
+            PatchedLinear,
+        )
+
+        if isinstance(target_base_layer, PatchedLinear):
+            new_module = IncLoraLinear(target, adapter_name, config=config, **kwargs)
+
+    return new_module
diff --git a/src/peft/tuners/lora/intruders.py b/src/peft/tuners/lora/intruders.py
new file mode 100644
index 0000000..c3e5d4d
--- /dev/null
+++ b/src/peft/tuners/lora/intruders.py
@@ -0,0 +1,165 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+import torch
+
+from .layer import LoraLayer
+
+
+def reduce_intruder_dimension(
+    peft_model,
+    old_adapter_name="default",
+    new_adapter_name="intruder_reduced",
+    top_k=10,
+    threshold_epsilon=0.5,
+    mitigation_lambda=0.75,
+    logging_sink=print,
+):
+    """
+    Intruder dimension mitigation based on https://huggingface.co/papers/2410.21228 ("LoRA vs Full Fine-tuning: An
+    Illusion of Equivalence").
+
+    This method can recover previous knowledge (i.e. mitigate forgetting) by post-processing already trained low-rank
+    adapters. This comes at a cost of task accuracy - tuning the `migration_lambda` value can be used to trade between
+    these two factors.
+
+    After mitigation is done there will be a new adapter with the name set in `new_adapter_name` which is also set to
+    be the currently active adapter. Inference on the mitigated model will therefore use the modified adapter. To
+    switch back to the original adapter you can use `peft_model.set_adapter(<old_adapter_name>)`.
+
+    Currently only LoRA is supported as it is not clear whether this method generalizes to other delta-weight methods.
+
+    Parameters:
+        peft_model:
+            The PEFT model with a loaded LoRA adapter with the name provided in `old_adapter_name`. Currently mixed
+            models are not supported.
+
+        top_k (default: 10)
+            Consider the top-k dimensions for intruder detection. The larger the value, the more dimensions will be
+            considered for intruder detection analysis (and the more false-postiives there can be). Operates on the
+            cosine similarity between base weights and adapter weights roughly sorted by influence of dimension
+            (determined by singular value decomposition), so a top-k of 10 will look at the 10 most 'important'
+            dimensions.
+
+        threshold_epsilon (default: 0.5)
+            Threshold value when to consider a cosine similarity between base weight and adapter weight as intruder.
+            According to the paper, intruder dimensions show near-zero absolute cosine similarity with pre-trained
+            singular vectors. The lower this value, the less potential intruder dimensions are identified. The higher
+            the value, the more potential false-positives are considered as intruders.
+
+        mitigation_lambda (default: 0.75)
+            The relative portion of the intruder dimensions that is subtracted from the adapter's delta weight. The
+            higher the value the more of the intruder dimension is subtracted but the more information is lost. Refer
+            to Figure 8 in the paper for a trade-off analysis.
+
+        logging_sink (default: print)
+            Function that prints information about the mitigation process. Set to None if you don't want any output.
+    """
+    # Note that this function currently doesn't support `compile_kwargs` similar to the LoRA conversion tooling
+    # since there's was no clear way how `torch.compile` can be used to improve performance at the time of
+    # implementation. See discussion: https://github.com/huggingface/peft/pull/2999#discussion_r2717989613
+
+    def no_logging_sink(*args, **kwargs):
+        pass
+
+    if logging_sink is None:
+        logging_sink = no_logging_sink
+
+    if peft_model.peft_type != "LORA":
+        raise ValueError("The provided model is not using LoRA and is therefore not supported.")
+
+    peft_model.add_adapter(new_adapter_name, peft_model.peft_config[old_adapter_name])
+
+    # apply mitigation on the old adapter's weights and move them to the new adapter's weights
+    for layer_name, layer in peft_model.named_modules():
+        if not isinstance(layer, LoraLayer):
+            continue
+
+        W = layer.get_base_layer().weight.data
+        dW = layer.get_delta_weight(old_adapter_name)
+        W_merged = W + dW
+        is_embedding = old_adapter_name not in layer.lora_B
+
+        # torch.linalg.svd below does not support half precision, so upcast fp16/bf16 inputs to
+        # fp32 for the decomposition; the resulting factors are cast back to W_dtype at the end.
+        cast_to_fp32 = W.dtype in (torch.float16, torch.bfloat16)
+
+        if cast_to_fp32:
+            W_dtype = W.dtype
+            W = W.float()
+            W_merged = W_merged.float()
+
+        # compare base weights and adapter weights using cosine similarity.
+        # based on this similarity we can find intruder dimensions using threshold_epsilon
+        # on the top_k dimensions
+        U_base, _S_base, _V_base = torch.linalg.svd(W, full_matrices=False)
+        U_merged, S_merged, V_merged = torch.linalg.svd(W_merged, full_matrices=False)
+
+        cos_sim = (U_merged.T @ U_base).abs().max(dim=1).values
+        intruder_idcs = torch.where(cos_sim[:top_k] < threshold_epsilon)[0].tolist()
+
+        if not intruder_idcs:
+            logging_sink(f"{layer_name}: No intruders")
+
+            # we're not modifying the weights since there are no intruders but we make sure to copy the
+            # adapter weights unmodified to the new adapter, otherwise these weights will be
+            # initialized randomly
+            if is_embedding:
+                layer.lora_embedding_B[new_adapter_name].data = layer.lora_embedding_B[old_adapter_name].data.clone()
+                layer.lora_embedding_A[new_adapter_name].data = layer.lora_embedding_A[old_adapter_name].data.clone()
+            else:
+                layer.lora_B[new_adapter_name].weight.data = layer.lora_B[old_adapter_name].weight.data.clone()
+                layer.lora_A[new_adapter_name].weight.data = layer.lora_A[old_adapter_name].weight.data.clone()
+            continue
+        else:
+            logging_sink(f"{layer_name}: Intruders: {len(intruder_idcs)}")
+
+        # the paper computes the intruder dimensions that are subtracted on (W + dW), so we do the same. experiments
+        # showed that this achieves better knowledge recovery than on dW alone.
+        B_intruder = U_merged[:, intruder_idcs] @ torch.diag(S_merged)[intruder_idcs, :].sqrt()
+        A_intruder = (torch.diag(S_merged)[:, intruder_idcs]).sqrt() @ V_merged[intruder_idcs, :]
+
+        # apply mitigation and recover dW = (B@A).
+        # (W+dW+mitigation)-W = dW+mitigation, so we can convert dW back to A/B using SVD
+        # since we know the effective rank from the adapter config.
+        #
+        # note that we also remove the scaling from dW which is applied in get_delta_weight() since
+        # it impacts mitigation performance both in task accuracy and forgetting.
+        W_mitigated = W_merged + (mitigation_lambda - 1) * (B_intruder @ A_intruder)
+        dW_mitigated = W_mitigated - W
+        dW_mitigated /= layer.scaling[old_adapter_name]
+
+        U_dW, S_dW, V_dW = torch.linalg.svd(dW_mitigated, full_matrices=False)
+
+        # Note: share scaling by S equally between B and A to avoid one matrix having a significantly
+        # different norm and avoid possibly weird training dynamics.
+        effective_rank = layer.r[old_adapter_name]
+        B_new = U_dW[:, :effective_rank] @ torch.diag(S_dW[:effective_rank]).sqrt()
+        A_new = torch.diag(S_dW[:effective_rank]).sqrt() @ V_dW[:effective_rank]
+
+        # cast the new adapter weights back from float32 to whatever the base layer's weights
+        # were before, so the new adapter's dtype matches the old adapter's and the base model's
+        if cast_to_fp32:
+            B_new = B_new.to(W_dtype)
+            A_new = A_new.to(W_dtype)
+
+        if is_embedding:
+            layer.lora_embedding_B[new_adapter_name].data = B_new
+            layer.lora_embedding_A[new_adapter_name].data = A_new
+        else:
+            layer.lora_B[new_adapter_name].weight.data = B_new
+            layer.lora_A[new_adapter_name].weight.data = A_new
+
+    logging_sink(f"Enabling new adapter {new_adapter_name}")
+    peft_model.set_adapter(new_adapter_name)
diff --git a/src/peft/tuners/lora/layer.py b/src/peft/tuners/lora/layer.py
new file mode 100644
index 0000000..81f3bf0
--- /dev/null
+++ b/src/peft/tuners/lora/layer.py
@@ -0,0 +1,2637 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import copy
+import dataclasses
+import math
+import warnings
+from collections.abc import Callable
+from contextlib import contextmanager
+from typing import Any, Optional, Union
+
+import torch
+import torch.distributed as dist
+import torch.nn.functional as F
+from torch import nn, svd_lowrank
+from transformers.pytorch_utils import Conv1D
+
+from peft.import_utils import is_transformers_ge_v5_4_0
+from peft.tuners._buffer_dict import BufferDict
+from peft.tuners.tuners_utils import (
+    BaseTunerLayer,
+    _get_in_out_features,
+    check_adapters_to_merge,
+)
+from peft.utils import ALLOWED_COMPUTE_DTYPES, UPCAST_DTYPES
+from peft.utils.integrations import (
+    dequantize_module_weight,
+    gather_params_ctx,
+    get_bnb_param_type,
+    skip_init_on_device,
+)
+from peft.utils.loftq_utils import loftq_init
+from peft.utils.other import transpose
+from peft.utils.warning import PeftWarning
+
+from .config import LoraConfig
+
+
+VARIANT_KWARG_KEYS = ["alora_offsets"]
+
+
+class LoraVariant:
+    """
+    Base class for LoRA variants, e.g. DoRA.
+
+    This class should be subclassed and the methods below should be implemented accordingly. The methods should be
+    implemented as static methods, this makes it easier to combine variants.
+
+    Note for developers: These methods are prone to change and should thus considered to be "private". Use at your own
+    discretion.
+    """
+
+    @staticmethod
+    def init(module: LoraLayer, adapter_name: str) -> None:
+        """Initialization code for the LoRA variant, it's called within `update_layer`"""
+        raise NotImplementedError
+
+    @staticmethod
+    def merge_safe(module: LoraLayer, active_adapter: str, orig_weight: torch.Tensor) -> torch.Tensor:
+        """Safe merging of the weights from `merge(..., safe_merge=True)`, should return a new tensor"""
+        raise NotImplementedError
+
+    @staticmethod
+    def merge_unsafe(module: LoraLayer, active_adapter: str, orig_weight: torch.Tensor) -> None:
+        """Unsafe merging of the weights from `merge(..., safe_merge=False)`, should modify the weight in-place"""
+
+    @staticmethod
+    def unmerge(module: LoraLayer, active_adapter: str, orig_weight: torch.Tensor) -> torch.Tensor:
+        """Remove the adapter weights from the original weights, then return them"""
+
+    @staticmethod
+    def forward(
+        module: LoraLayer,
+        active_adapter: str,
+        x: torch.Tensor,
+        result: torch.Tensor,
+        **kwargs,
+    ) -> torch.Tensor:
+        """
+        The forward pass of the LoRA variant, should return the overall result (not just the diff)
+
+        Args:
+            module (LoraLayer): The module on which the forward pass is called
+            active_adapter (str): The name of the active adapter
+            x (torch.Tensor): The input to the forward call
+            result (torch.Tensor): The result from the base model
+            **kwargs: Additional arguments passed from [`LoraLayer.forward`].
+        """
+        raise NotImplementedError
+
+
+class LoraLayer(BaseTunerLayer):
+    # All names of layers that may contain (trainable) adapter weights
+    adapter_layer_names: tuple[str, ...] = (
+        "lora_A",
+        "lora_B",
+        "lora_embedding_A",
+        "lora_embedding_B",
+        "lora_magnitude_vector",
+    )
+    # All names of other parameters that may contain adapter-related parameters
+    other_param_names: tuple[str, ...] = (
+        "r",
+        "lora_alpha",
+        "scaling",
+        "lora_dropout",
+        "use_dora",
+        "use_rslora",
+        "lora_bias",
+    )
+
+    def __init__(self, base_layer: nn.Module, ephemeral_gpu_offload: bool = False, **kwargs) -> None:
+        self.base_layer = base_layer
+        self.r = {}
+        self.lora_alpha = {}
+        self.scaling = {}
+        self.lora_dropout = nn.ModuleDict({})
+        self.lora_A = nn.ModuleDict({})
+        self.lora_B = nn.ModuleDict({})
+        # For Embedding layer
+        self.lora_embedding_A = nn.ParameterDict({})
+        self.lora_embedding_B = nn.ParameterDict({})
+        # Mark the weight as unmerged
+        self._disable_adapters = False
+        self.merged_adapters = []
+        self.use_dora: dict[str, bool] = {}  # not actively used anymore after #2443, keep it for BC
+        self.use_rslora: dict[str, bool] = {}
+        self.lora_bias: dict[str, bool] = {}
+        self.lora_magnitude_vector = torch.nn.ModuleDict()  # for DoRA
+        self._caches: dict[str, Any] = {}  # small ad hoc cache; values are not part of the state_dict
+        self.ephemeral_gpu_offload: bool = ephemeral_gpu_offload
+        # flag to enable/disable casting of input to weight dtype during forward call
+        self.cast_input_dtype_enabled: bool = True
+        self.lora_variant: dict[str, LoraVariant] = {}
+        self.kwargs = kwargs
+
+        base_layer = self.get_base_layer()
+        in_features, out_features = self._get_in_out_features(base_layer)
+        self.in_features = in_features
+        self.out_features = out_features
+
+    def delete_adapter(self, adapter_name: str) -> None:
+        super().delete_adapter(adapter_name)
+        self.lora_variant.pop(adapter_name, None)
+
+    def _get_in_out_features(self, module: nn.Module) -> tuple[int, int] | tuple[None, None]:
+        return _get_in_out_features(module)
+
+    @property
+    def lora_variants(self):
+        """
+        A dictionary mapping the active LoRA variants to their respective classes.
+
+        To extend this, subclasses should override this property and return a dictionary where the keys are tuples of
+        variant field names (from LoraConfig) and the values are the specific LoraVariant subclasses.
+
+        Tuples are used as keys because they are immutable and hashable, allowing us to safely map combinations of
+        active variants (e.g., DoRA + another variant) to a specific composed variant class.
+        """
+        return {(): None}
+
+    def resolve_lora_variant(self, *, config: LoraConfig, **kwargs) -> Optional[LoraVariant]:
+        """Resolves the appropriate LoRA variant class based on the given configuration.
+        This method inspects the LoraConfig to identify active variants (such as matching the string value of
+        init_lora_weights to the registered metadata) and retrieves the corresponding class from the layer's variant
+        registry."""
+        # mapping from declared variant to the LoraVariant class, keys are tuples to allow for multi variants
+        lora_variant_mapping = self.lora_variants
+        if any(tuple(sorted(k)) != k for k in lora_variant_mapping.keys()):
+            raise ValueError("Keys in lora_variants must be sorted tuples (e.g ('a', 'b'), not ('b', 'a')).")
+
+        # for each LoRA variant, determine if they are configured as active or not
+        requested_lora_variants: dict[str, bool] = {}
+        for field in dataclasses.fields(config):
+            # for init_lora_weights, we collect the field's lora_variants and check the value to determine if the
+            # variant is requested
+            if field.name == "init_lora_weights":
+                for init_variant_option in field.metadata["lora_variants"]:
+                    requested_lora_variants[init_variant_option] = config.init_lora_weights == init_variant_option
+            # for all other fields, if the metadata declares them as is_lora_variant and we check if the value is truthy
+            # to determine if the variant is requested
+            elif field.metadata.get("is_lora_variant"):
+                requested_lora_variants[field.name] = bool(getattr(config, field.name))
+
+        # sanity check: each mapping key must be present in the LoraConfig
+        all_variant_names = {name for variant_keys in lora_variant_mapping.keys() for name in variant_keys}
+        missing_variants = all_variant_names - requested_lora_variants.keys()
+        if missing_variants:
+            raise ValueError(
+                f"variant(s) {sorted(missing_variants)} found in lora_variants but neither tagged with "
+                f"'is_lora_variant' in LoraConfig, nor declared as a LoRA variant in init_lora_weights."
+            )
+
+        # collect active variants: keys are sorted tuples of strings
+        requested_keys = tuple(sorted(k for k, v in requested_lora_variants.items() if v))
+        if requested_keys not in lora_variant_mapping:
+            raise ValueError(f"Invalid or unsupported variant combination: {requested_keys}")
+
+        # return the found variant or None for vanilla LoRA
+        variant_class = lora_variant_mapping[requested_keys]
+        return variant_class() if variant_class else None
+
+    def update_layer(
+        self,
+        adapter_name: str,
+        r: int,
+        lora_alpha: int,
+        config: LoraConfig,
+        **kwargs,
+    ) -> None:
+        # collect the kwargs
+        lora_dropout = config.lora_dropout
+        init_lora_weights = config.init_lora_weights
+        use_rslora = config.use_rslora
+        lora_bias = config.lora_bias
+        inference_mode = config.inference_mode
+
+        target_name = kwargs.get("target_name", "")  # preserve target_name before overwriting kwargs
+        kwargs["target_name"] = target_name  # restore target_name
+        tied_adapter = kwargs.get("tied_adapter", None)
+
+        # This code works for linear layers, override for other layer types
+        if r <= 0:
+            raise ValueError(f"`r` should be a positive integer value but the value passed is {r}")
+
+        if lora_bias and (getattr(self.get_base_layer(), "bias", None) is None):
+            warnings.warn(
+                f"`lora_bias=True` was passed but the targeted layer of type {type(self.get_base_layer()).__name__} "
+                "has no bias. This means that merging LoRA weights won't be possible.",
+                PeftWarning,
+            )
+
+        lora_variant = self.resolve_lora_variant(config=config)
+        if lora_variant is not None:
+            self.lora_variant[adapter_name] = lora_variant
+
+        self.r[adapter_name] = r
+        self.lora_alpha[adapter_name] = lora_alpha
+        if lora_dropout > 0.0:
+            lora_dropout_layer = nn.Dropout(p=lora_dropout)
+        else:
+            lora_dropout_layer = nn.Identity()
+
+        self.lora_dropout.update(nn.ModuleDict({adapter_name: lora_dropout_layer}))
+
+        # Actual trainable parameters
+        self.lora_A[adapter_name] = nn.Linear(self.in_features, r, bias=False)
+        self.lora_B[adapter_name] = nn.Linear(r, self.out_features, bias=lora_bias)
+
+        # Tying adapters is only implemented for Linear layers
+        # where the source is the embedding layer.
+        # Currently, this is the most prevalent way of tying layers (weight tying)
+        if tied_adapter:
+            lora_A_params = tied_adapter["lora_A"]
+            lora_B_params = tied_adapter["lora_B"]
+
+            self.lora_A[adapter_name].weight = torch.nn.Parameter(lora_A_params)
+            self.lora_B[adapter_name].weight = torch.nn.Parameter(lora_B_params)
+
+        self.lora_bias[adapter_name] = lora_bias
+
+        if use_rslora:
+            self.scaling[adapter_name] = lora_alpha / math.sqrt(r)
+        else:
+            self.scaling[adapter_name] = lora_alpha / r
+
+        self.use_rslora[adapter_name] = use_rslora
+
+        self.use_dora[adapter_name] = config.use_dora
+
+        # for inits that require access to the base weight, use gather_param_ctx so that the weight is gathered when using DeepSpeed
+        if isinstance(init_lora_weights, str) and init_lora_weights.startswith("pissa"):
+            with gather_params_ctx(self.get_base_layer().weight):
+                self.pissa_init(adapter_name, init_lora_weights)
+        elif isinstance(init_lora_weights, str) and init_lora_weights.startswith("corda"):
+            with gather_params_ctx(self.get_base_layer().weight):
+                self.corda_init(adapter_name, init_lora_weights)
+        elif isinstance(init_lora_weights, str) and init_lora_weights.lower() == "olora":
+            with gather_params_ctx(self.get_base_layer().weight):
+                self.olora_init(adapter_name)
+        elif isinstance(init_lora_weights, str) and init_lora_weights.lower() == "mica":
+            with gather_params_ctx(self.get_base_layer().weight):
+                self.mica_init(adapter_name)
+        elif init_lora_weights == "loftq":
+            with gather_params_ctx(self.get_base_layer().weight):
+                self.loftq_init(adapter_name, config)
+        elif init_lora_weights == "eva":
+            nn.init.zeros_(self.lora_B[adapter_name].weight)
+        elif init_lora_weights == "orthogonal":
+            with gather_params_ctx(self.get_base_layer().weight):
+                self.orthogonal_init(adapter_name)
+        elif init_lora_weights == "lora_ga":
+            with gather_params_ctx(self.get_base_layer().weight):
+                self.lora_ga_init(adapter_name, config.lora_ga_config)
+        elif init_lora_weights:
+            self.reset_lora_parameters(adapter_name, init_lora_weights)
+        # call this before init of the lora variants
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+
+        if adapter_name in self.lora_variant:
+            self.lora_variant[adapter_name].init(self, adapter_name=adapter_name, config=config, **kwargs)
+
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+        # Check for adapters that were added or removed from the arrow_model.
+        # The arrow model may be modified after creation by adding new experts
+        # (pre-trained or trainable) or by removing existing ones. Whenever such
+        # a change occurs, on_adapter_change() is called to update the set of
+        # active task-specific experts and, if needed, to handle recomputing prototypes
+        # and doing general knowledge subtraction (GKS) again.
+        if hasattr(self, "lora_arrow"):
+            for adapter in self.lora_variant:
+                if adapter in self.lora_arrow:
+                    self.lora_arrow[adapter].on_adapter_change(self.lora_A, self.lora_B)
+
+    def reset_lora_parameters(self, adapter_name, init_lora_weights):
+        if init_lora_weights is not False:
+            if adapter_name in self.lora_A.keys():
+                if init_lora_weights is True:
+                    # initialize A the same way as the default for nn.Linear and B to zero
+                    # https://github.com/microsoft/LoRA/blob/a0a92e0f26c067cf94747bdbf1ce73793fa44d19/loralib/layers.py#L124
+                    nn.init.kaiming_uniform_(self.lora_A[adapter_name].weight, a=math.sqrt(5))
+                elif init_lora_weights.lower() == "gaussian":
+                    nn.init.normal_(self.lora_A[adapter_name].weight, std=1 / self.r[adapter_name])
+                else:
+                    raise ValueError(f"Unknown initialization {init_lora_weights=}")
+                nn.init.zeros_(self.lora_B[adapter_name].weight)
+                if self.lora_bias[adapter_name]:
+                    nn.init.zeros_(self.lora_B[adapter_name].bias)
+            if adapter_name in self.lora_embedding_A.keys():
+                # Initialize A to zeros and B the same way as the default for nn.Embedding, see:
+                # https://github.com/microsoft/LoRA/blob/4c0333854cb905966f8cc4e9a74068c1e507c7b7/loralib/layers.py#L59-L60
+                nn.init.zeros_(self.lora_embedding_A[adapter_name])
+                nn.init.normal_(self.lora_embedding_B[adapter_name])
+                if self.lora_bias[adapter_name]:
+                    # embeddings are not supported at the moment, but still adding this for consistency
+                    nn.init.zeros_(self.lora_embedding_B[adapter_name].bias)
+
+        # Always synchronize non-sharded LoRA weights across TP ranks, regardless of
+        # init_lora_weights, since each rank initializes weights independently.
+        # We could skip some broadcast, for instance when the lora weights are initialized to zero,
+        # but this is a minor optimization and would add extra complexity to the code.
+        if dist.is_available() and dist.is_initialized():
+            base_layer = self.get_base_layer()
+            tp_plan = getattr(base_layer, "_hf_tp_plan", None)
+            device_mesh = getattr(base_layer, "_hf_device_mesh", None)
+            if device_mesh is not None:
+                if tp_plan not in ["colwise", "rowwise", "embedding_rowwise"]:
+                    warnings.warn(
+                        f'tp_plan "{tp_plan}" found on the base layer is not supported for LoRA weight '
+                        'synchronization. Expected one of "colwise", "rowwise", "embedding_rowwise". '
+                        "LoRA weights may not be synchronized across ranks."
+                    )
+                pg = device_mesh.get_group()
+                src = dist.get_global_rank(pg, 0)
+                if tp_plan == "colwise" and adapter_name in self.lora_A:
+                    # The adapter weights need to be on device for broadcasting
+                    self._move_adapter_to_device_of_base_layer(adapter_name)
+                    dist.broadcast(self.lora_A[adapter_name].weight.data, src=src, group=pg)
+                elif tp_plan == "rowwise" and adapter_name in self.lora_B:
+                    # The adapter weights need to be on device for broadcasting
+                    self._move_adapter_to_device_of_base_layer(adapter_name)
+                    dist.broadcast(self.lora_B[adapter_name].weight.data, src=src, group=pg)
+                elif tp_plan == "embedding_rowwise" and adapter_name in self.lora_embedding_B:
+                    self._move_adapter_to_device_of_base_layer(adapter_name)
+                    dist.broadcast(self.lora_embedding_B[adapter_name].data, src=src, group=pg)
+
+    def olora_init(self, adapter_name):
+        base_layer = self.get_base_layer()
+        orig_weight = base_layer.weight
+        bnb_param_type = get_bnb_param_type(orig_weight)
+        dtype = orig_weight.dtype
+
+        if bnb_param_type:
+            # check without importing bitsandbytes and robust to bnb_4bit_quant_storage=float*
+            weight_tensor = dequantize_module_weight(base_layer)
+        elif dtype in [torch.float32, torch.float16, torch.bfloat16]:
+            weight_tensor = orig_weight
+        else:
+            raise TypeError(f"Unsupported data type for the base layer. Got {dtype}.")
+
+        scale_factor = self.scaling[adapter_name]
+        r = self.r[adapter_name]
+        weight_tensor = weight_tensor.to(torch.float32)
+        Q, R = torch.linalg.qr(weight_tensor.data)
+
+        Qr, Rr = Q[:, :r], R[:r]
+
+        self.lora_A[adapter_name].weight.data = Rr.contiguous()
+        self.lora_B[adapter_name].weight.data = Qr.contiguous()
+
+        weight_tensor.data -= scale_factor * self.lora_B[adapter_name].weight @ self.lora_A[adapter_name].weight
+        if bnb_param_type == "4bit":
+            weight_tensor = orig_weight.__class__(
+                weight_tensor,
+                quant_type=orig_weight.quant_type,
+                quant_storage=orig_weight.quant_storage,
+                compress_statistics=orig_weight.compress_statistics,
+                module=orig_weight.module,
+            ).to(orig_weight.device)
+            base_layer.weight = weight_tensor
+        elif bnb_param_type == "8bit":
+            weight_tensor = orig_weight.__class__(
+                weight_tensor,
+                requires_grad=orig_weight.requires_grad,
+                has_fp16_weights=orig_weight.has_fp16_weights,
+            ).to(orig_weight.device)
+            base_layer.weight = weight_tensor
+        else:
+            weight_tensor = weight_tensor.to(dtype)
+            base_layer.weight.data = weight_tensor
+
+    def pissa_init(self, adapter_name, init_lora_weights):
+        weight = self.get_base_layer().weight
+        dtype = weight.dtype
+        if dtype not in [torch.float32, torch.float16, torch.bfloat16]:
+            raise TypeError(
+                "Please initialize PiSSA under float32, float16, or bfloat16. "
+                "Subsequently, re-quantize the residual model to help minimize quantization errors."
+            )
+        weight = transpose(weight.to(torch.float32), self.fan_in_fan_out)
+        if init_lora_weights == "pissa":
+            # USV^T = W <-> VSU^T = W^T, where W^T = weight.data in R^{out_channel, in_channel},
+            V, S, Uh = torch.linalg.svd(weight.data, full_matrices=False)
+            Vr = V[:, : self.r[adapter_name]]
+            Sr = S[: self.r[adapter_name]]
+            Sr /= self.scaling[adapter_name]
+            Uhr = Uh[: self.r[adapter_name]]
+        elif len(init_lora_weights.split("_niter_")) == 2:
+            Vr, Sr, Ur = svd_lowrank(
+                weight.data, self.r[adapter_name], niter=int(init_lora_weights.split("_niter_")[-1])
+            )
+            Sr /= self.scaling[adapter_name]
+            Uhr = Ur.t()
+        else:
+            raise ValueError(
+                f"init_lora_weights should be 'pissa' or 'pissa_niter_[number of iters]', got {init_lora_weights} instead."
+            )
+
+        lora_A = torch.diag(torch.sqrt(Sr)) @ Uhr
+        lora_B = Vr @ torch.diag(torch.sqrt(Sr))
+        self.lora_A[adapter_name].weight.data = lora_A
+        self.lora_B[adapter_name].weight.data = lora_B
+        weight = weight.data - self.scaling[adapter_name] * lora_B @ lora_A
+        weight = transpose(weight.to(dtype), self.fan_in_fan_out)
+        self.get_base_layer().weight.data = weight
+
+    def mica_init(self, adapter_name):
+        """Minor Component Adaptation (MiCA) initialization (https://arxiv.org/abs/2604.01694).
+
+        Initializes `lora_B` from the `r` left singular vectors of the base weight associated with the smallest
+        singular values, and sets `lora_A` to zero. The `lora_B` matrix is frozen during training (see
+        `MiCALinearVariant.init`); only `lora_A` is updated. Because `lora_A == 0` at init, the adapter contribution `B
+        @ A == 0` and the base weight does not need to be modified to preserve the forward output.
+        """
+        # When the adapter is being created under `init_empty_weights` (e.g. low_cpu_mem_usage=True), its parameters
+        # live on the meta device and will be filled in from a checkpoint after creation. Skip the SVD in that case.
+        if self.lora_B[adapter_name].weight.device.type == "meta":
+            return
+
+        weight = self.get_base_layer().weight
+        dtype = weight.dtype
+        if dtype not in [torch.float32, torch.float16, torch.bfloat16]:
+            raise TypeError("Please initialize MiCA under float32, float16, or bfloat16.")
+
+        weight = transpose(weight.to(torch.float32), self.fan_in_fan_out)
+        # weight has shape (out_features, in_features) once transposed for fan_in_fan_out, matching nn.Linear.weight.
+        # SVD: weight = U @ diag(S) @ Vh, with U: (out, k), Vh: (k, in), S sorted descending.
+        # MiCA selects the LAST r left singular vectors (smallest singular values) for B and zeroes A.
+        r = self.r[adapter_name]
+        max_r = min(weight.shape)
+        if r > max_r:
+            raise ValueError(
+                f"MiCA requires `r` <= min(in_features, out_features) but got r={r} for a layer with "
+                f"weight shape {tuple(weight.shape)} (max usable r is {max_r})."
+            )
+        U, _, _ = torch.linalg.svd(weight.data, full_matrices=False)
+        lora_B = U[:, -r:].contiguous()
+        lora_A = torch.zeros(r, weight.shape[1], device=weight.device)
+        self.lora_B[adapter_name].weight.data = lora_B.to(dtype)
+        self.lora_A[adapter_name].weight.data = lora_A.to(dtype)
+
+    def corda_init(self, adapter_name, init_lora_weights):
+        linear = self.get_base_layer()
+        weight = linear.weight
+        dtype = weight.dtype
+        if dtype not in [torch.float32, torch.float16, torch.bfloat16]:
+            raise TypeError(
+                "Please initialize CorDA under float32, float16, or bfloat16. "
+                "Subsequently, re-quantize the residual model to help minimize quantization errors."
+            )
+        weight = weight.to(torch.float32)
+        # For Conv1D, weight is stored as (in_features, out_features), transposed compared to Linear
+        if isinstance(linear, Conv1D):
+            out_dim = weight.data.size(1)
+            in_dim = weight.data.size(0)
+        else:
+            out_dim = weight.data.size(0)
+            in_dim = weight.data.size(1)
+
+        # Calculate WC from covariance matrix
+        if not hasattr(linear, "eigens"):
+            raise ValueError(
+                "`eigens` attribute not found for layer, please run `preprocess_corda` first. "
+                "More information can be found at examples/corda_finetuning/README.md."
+            )
+        eigens = linear.eigens
+        U = eigens.U_WC
+        S = eigens.S_WC
+        V = eigens.V_WC
+        r = self.r[adapter_name]
+
+        # nan or inf check
+        if torch.isnan(S).any() or torch.isinf(S).any():
+            raise ValueError(
+                "Invalid value found in matrix S. Please file an issue at https://github.com/huggingface/peft/issues."
+            )
+        if torch.isnan(U).any() or torch.isinf(U).any():
+            raise ValueError(
+                "Invalid value found in matrix U. Please file an issue at https://github.com/huggingface/peft/issues."
+            )
+        if torch.isnan(V).any() or torch.isinf(V).any():
+            raise ValueError(
+                "Invalid value found in matrix V. Please file an issue at https://github.com/huggingface/peft/issues."
+            )
+
+        # Sanity check
+        if U.size(0) != out_dim or U.size(1) != r:
+            raise ValueError(
+                f"Matrix U size mismatch: {U.size()} vs. ({out_dim}, {r}). Please make sure the `lora_config` and "
+                "`model` argument of `preprocess_corda` is consistent with `get_peft_model`. If you're using cache "
+                "in `preprocess_corda`, please make sure the cache is built with the same model and LoRA rank."
+            )
+        if S.size(0) != r:
+            raise ValueError(
+                f"Matrix S size mismatch: {S.size()} vs. ({r},). Please make sure the `lora_config` and `model` argument "
+                "of `preprocess_corda` is consistent with `get_peft_model`. If you're using cache in `preprocess_corda`, "
+                "please make sure the cache is built with the same model and LoRA rank."
+            )
+        if V.size(0) != in_dim or V.size(1) != r:
+            raise ValueError(
+                f"Matrix V size mismatch: {V.size()} vs. ({in_dim}, {r}). Please make sure the `lora_config` and "
+                "`model` argument of `preprocess_corda` is consistent with `get_peft_model`. If you're using cache "
+                "in `preprocess_corda`, please make sure the cache is built with the same model and LoRA rank."
+            )
+
+        # Apply alpha
+        S /= self.scaling[adapter_name]
+
+        # Init lora_A and lora_B weights
+        lora_A = V.t().mul(S.sqrt().view(-1, 1)).contiguous()
+        lora_B = U.mul(S.sqrt()).contiguous()
+        self.lora_A[adapter_name].weight.data = lora_A
+        self.lora_B[adapter_name].weight.data = lora_B
+
+        # For Conv1D, lora_B @ lora_A gives (out_dim, in_dim) but weight is (in_dim, out_dim)
+        # So we need to transpose before subtraction
+        delta = self.scaling[adapter_name] * lora_B @ lora_A
+        delta = transpose(delta, fan_in_fan_out=self.fan_in_fan_out)
+        weight = weight.data - delta
+        weight = weight.to(dtype)
+        self.get_base_layer().weight.data = weight
+
+        # Remove redundant fields
+        del linear.eigens
+
+    def loftq_init(self, adapter_name, config: LoraConfig):
+        weight = self.get_base_layer().weight
+        kwargs = {
+            "num_bits": config.loftq_config["loftq_bits"],
+            "reduced_rank": self.r[adapter_name],
+            "num_iter": config.loftq_config["loftq_iter"],
+        }
+
+        qweight, lora_A, lora_B = loftq_init(weight, **kwargs)
+        if adapter_name in self.lora_A.keys():
+            # initialize A the same way as the default for nn.Linear and B to zero
+            self.lora_A[adapter_name].weight.data = lora_A
+            self.lora_B[adapter_name].weight.data = lora_B
+        if adapter_name in self.lora_embedding_A.keys():
+            # initialize a the same way as the default for nn.linear and b to zero
+            self.lora_embedding_A[adapter_name].weight.data = lora_A
+            self.lora_embedding_B[adapter_name].weight.data = lora_B
+        self.get_base_layer().weight.data = qweight
+
+    @torch.no_grad()
+    def orthogonal_init(self, adapter_name):
+        # https://datta0.github.io/posts/rethink-lora-init/#orthogonal-initialisation
+        rank = self.r[adapter_name]
+        if rank % 2 != 0:
+            raise ValueError(f"Orthogonal initialization requires the LoRA rank to be even, got {rank} instead.")
+
+        X = torch.randn(rank, rank)
+        Q, _ = torch.linalg.qr(X)
+        q_odd = Q[0::2, :]  # Odd rows
+        q_even = Q[1::2, :]  # Even rows
+        dtype = self.get_base_layer().weight.dtype
+        lora_A = torch.randn(self.in_features, rank // 2).mm(q_odd).T / 10.0
+        lora_B = torch.randn(rank // 2, self.out_features).T.mm(q_even) / 10.0
+        self.lora_A[adapter_name].weight = nn.Parameter(lora_A.contiguous().to(dtype))
+        self.lora_B[adapter_name].weight = nn.Parameter(lora_B.contiguous().to(dtype))
+
+    def lora_ga_init(self, adapter_name, lora_ga_config):
+        """
+        Initialize LoRA weights using gradient approximation.
+
+        Uses SVD on the gradient matrix to initialize adapters in a way that aligns with the direction of full
+        fine-tuning.
+
+        Expects that `preprocess_loraga` has been called before this, which attaches the `loraga_grad` attribute to the
+        base layer.
+
+        If gradients are not available (e.g., when loading from a saved adapter), falls back to gaussian
+        initialization. The weights will be overwritten by the state_dict anyway.
+        """
+        base_layer = self.get_base_layer()
+
+        # Check for gradient attached by preprocess_loraga
+        if not hasattr(base_layer, "_peft_loraga_grad"):
+            # When loading from saved adapter, gradients won't be available
+            # Fall back to gaussian initialization (weights will be overwritten by state_dict)
+            self.reset_lora_parameters(adapter_name, init_lora_weights=True)
+            return
+
+        grad = base_layer._peft_loraga_grad
+
+        # Check for lora_ga_config
+        if lora_ga_config is None:
+            raise ValueError(
+                "lora_ga_config must be provided when init_lora_weights='lora_ga'. "
+                "Please pass lora_ga_config=LoraGAConfig(...) to LoraConfig."
+            )
+        direction = lora_ga_config.direction
+        scale = lora_ga_config.scale
+        stable_gamma = lora_ga_config.stable_gamma
+        dtype = self.get_base_layer().weight.dtype
+
+        grad = grad.to(torch.float32)
+        weight = self.get_base_layer().weight
+
+        grad = transpose(grad, self.fan_in_fan_out)
+
+        r = self.r[adapter_name]
+
+        # torch.svd_lowrank returns (U, S, V) where grad ≈ U @ diag(S) @ V.T
+        # So V is shape (in_features, k) and we need V.T which is (k, in_features) for lora_A
+        U, S, V = torch.svd_lowrank(grad, q=min(4 * r, min(grad.shape)), niter=4)
+
+        # V is (in_features, k), we need Vh = V.T which is (k, in_features)
+        Vh = V.t()
+
+        U = U[:, : 2 * r]
+        S = S[: 2 * r]
+        Vh = Vh[: 2 * r, :]
+
+        if direction == "ArBr":
+            # Alternating: A takes rows at odd indices [1,3,5,7], B takes columns at even indices [0,2,4,6]
+            lora_A_weight = Vh[1 : 2 * r : 2, :]  # Shape: (r, in_features)
+            lora_B_weight = U[:, 0 : 2 * r : 2]  # Shape: (out_features, r)
+            S_B = S[0 : 2 * r : 2]
+            lora_B_weight = lora_B_weight @ torch.diag(S_B)
+
+        elif direction == "A2rBr":
+            # A takes second half rows [r:2r], B takes first half columns [:r]
+            lora_A_weight = Vh[r : 2 * r, :]  # Shape: (r, in_features)
+            lora_B_weight = U[:, :r]  # Shape: (out_features, r)
+            S_B = S[:r]
+            lora_B_weight = lora_B_weight @ torch.diag(S_B)
+
+        elif direction == "ArB2r":
+            # A takes first half rows [:r], B takes second half columns [r:2r]
+            lora_A_weight = Vh[:r, :]  # Shape: (r, in_features)
+            lora_B_weight = U[:, r : 2 * r]  # Shape: (out_features, r)
+            S_B = S[r : 2 * r]
+            lora_B_weight = lora_B_weight @ torch.diag(S_B)
+
+        elif direction == "random":
+            indices = torch.randperm(2 * r)[:r]
+            lora_A_weight = Vh[indices, :]  # Shape: (r, in_features)
+            S_B = S[indices]
+            lora_B_weight = U[:, indices] @ torch.diag(S_B)  # Shape: (out_features, r)
+
+        scaling_factor = self.scaling[adapter_name]
+        out_features = weight.shape[0]
+
+        if scale == "stable":
+            scale_factor = (out_features**0.25) / (stable_gamma**0.5)
+            lora_B_weight = lora_B_weight * scale_factor
+
+        elif scale == "weight_svd":
+            weight_data = transpose(weight.data.to(torch.float32), self.fan_in_fan_out)
+            _, weight_S, _ = torch.svd_lowrank(weight_data, q=r, niter=4)
+            if S_B[0] > 0:
+                scale_factor = weight_S[0] / S_B[0]
+                lora_B_weight = lora_B_weight * scale_factor
+
+        elif scale == "gd_scale":
+            lora_A_weight = lora_A_weight / scaling_factor
+            lora_B_weight = lora_B_weight / scaling_factor
+
+        # Convert to target dtype first to ensure weight offset matches adapter precision
+        lora_A_weight = lora_A_weight.to(dtype)
+        lora_B_weight = lora_B_weight.to(dtype)
+
+        # Assign LoRA weights
+        # lora_A should be (r, in_features), lora_B should be (out_features, r)
+        self.lora_A[adapter_name].weight.data = lora_A_weight.contiguous()
+        self.lora_B[adapter_name].weight.data = lora_B_weight.contiguous()
+
+        # Modify base weights: W_new = W_old - scaling * (B @ A)
+        # Important: compute offset in fp32 using dtype-converted weights to match forward pass precision
+        weight_data = transpose(weight.data.to(torch.float32), self.fan_in_fan_out)
+        weight_offset = scaling_factor * (lora_B_weight.float() @ lora_A_weight.float())
+        weight_data = weight_data - weight_offset
+        weight_data = transpose(weight_data.to(dtype), self.fan_in_fan_out)
+        self.get_base_layer().weight.data = weight_data
+
+        # Remove redundant fields
+        del base_layer._peft_loraga_grad
+
+    def _cache_store(self, key: str, value: Any) -> None:
+        # cache intermediate values, e.g. weight norm of DoRA
+        self._caches[key] = value
+
+    def _cache_pop(self, key: str) -> Any:
+        # retrieve and remove from ad hoc cache
+        value = self._caches.pop(key)
+        return value
+
+    def set_scale(self, adapter: str, scale: float) -> None:
+        """Set the scale of the given adapter to the initial scale multiplied by the provided factor
+
+        The initial scale is determined by the configured `r` (rank) and `lora_alpha`.
+        """
+        if adapter not in self.scaling:
+            # Ignore the case where the adapter is not in the layer
+            return
+        if self.use_rslora.get(adapter, False):
+            self.scaling[adapter] = scale * self.lora_alpha[adapter] / math.sqrt(self.r[adapter])
+        else:
+            self.scaling[adapter] = scale * self.lora_alpha[adapter] / self.r[adapter]
+
+    def scale_layer(self, scale: float) -> None:
+        """Multiply the current scale of all active adapters by the provided factor"""
+        if scale == 1:
+            return
+
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self.lora_A.keys():
+                continue
+
+            self.scaling[active_adapter] *= scale
+
+    def unscale_layer(self, scale: Optional[float | int] = None) -> None:
+        """Divide the current scale of all active adapters by the provided factor. If `scale=None` is passed, reset to
+        initial scale
+
+        The initial scale is determined by the configured `r` (rank) and `lora_alpha`.
+
+        """
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self.lora_A.keys():
+                continue
+
+            if scale is None:
+                if self.use_rslora.get(active_adapter, False):
+                    self.scaling[active_adapter] = self.lora_alpha[active_adapter] / math.sqrt(self.r[active_adapter])
+                else:
+                    self.scaling[active_adapter] = self.lora_alpha[active_adapter] / self.r[active_adapter]
+            else:
+                self.scaling[active_adapter] = self.scaling[active_adapter] / scale
+
+    def _check_forward_args(self, x, *args, **kwargs):
+        """Check if the arguments are compatible with the configs and state of the model"""
+        adapter_names = kwargs.get("adapter_names", None)
+        if adapter_names is None:
+            return
+
+        if len(x) != len(adapter_names):
+            msg = (
+                "Length of `adapter_names` should be the same as the number of inputs, but got "
+                f"{len(adapter_names)} and {len(x)} respectively."
+            )
+            raise ValueError(msg)
+
+        if self.merged:
+            # It is unclear what would be the right thing to do if users pass adapter_names and there are merged
+            # adapters. Therefore, it is better to raise an error in this case.
+            msg = "Cannot pass `adapter_names` when there are merged adapters, please call `unmerge_adapter` first."
+            raise ValueError(msg)
+
+        # DoRA is not supported (yet), check that it's not being used. Don't check "__base__", as this is the
+        # placeholder for the base model.
+        unique_adapters = {name for name in adapter_names if name != "__base__"}
+        for adapter_name in unique_adapters:
+            if self.use_dora.get(adapter_name, False):
+                msg = "Cannot pass `adapter_names` when DoRA is enabled."
+                raise ValueError(msg)
+
+    def _mixed_batch_forward(
+        self, x: torch.Tensor, *args: Any, adapter_names: list[str], **kwargs: Any
+    ) -> torch.Tensor:
+        # This is a special method that handles the case when users pass the argument `adapter_names`. This is an
+        # extra argument that allows mixing different adapters in the same batch at inference time.
+        variant_kwargs = {k: kwargs.pop(k, None) for k in VARIANT_KWARG_KEYS}  # don't pass these to base_layer
+        result = self.base_layer(x, *args, **kwargs)
+        torch_result_dtype = result.dtype
+
+        unique_adapters = set(adapter_names)
+        sub_batch_indices_list = []
+        for adapter in unique_adapters:
+            sub_batch_indices_list.append([index for index, item in enumerate(adapter_names) if item == adapter])
+        alora_offsets = variant_kwargs.get("alora_offsets", None)
+        for i, active_adapter in enumerate(unique_adapters):
+            if active_adapter == "__base__":
+                continue
+            if active_adapter not in self.lora_A.keys():
+                continue
+
+            lora_A = self.lora_A[active_adapter]
+            lora_B = self.lora_B[active_adapter]
+            dropout = self.lora_dropout[active_adapter]
+            scaling = self.scaling[active_adapter]
+
+            # getting the sub-batch, passing it to LoRA layers and updating the corresponding indices of the linear
+            # layer output
+            sub_batch = x[sub_batch_indices_list[i]].to(lora_A.weight.dtype)
+            if active_adapter not in self.lora_variant:  # vanilla LoRA
+                lora_output = lora_B(lora_A(dropout(sub_batch))) * scaling
+                result[sub_batch_indices_list[i]] += lora_output.to(torch_result_dtype)
+            else:
+                if alora_offsets is not None:
+                    variant_kwargs["alora_offsets"] = [alora_offsets[j] for j in sub_batch_indices_list[i]]
+                lora_output = self.lora_variant[active_adapter].forward(
+                    self,
+                    active_adapter=active_adapter,
+                    x=sub_batch,
+                    result=result[sub_batch_indices_list[i]],
+                    **variant_kwargs,
+                    **kwargs,
+                )
+                result[sub_batch_indices_list[i]] = lora_output.to(torch_result_dtype)
+
+        return result
+
+
+# Below code is based on https://github.com/microsoft/LoRA/blob/main/loralib/layers.py
+# and modified to work with PyTorch FSDP
+
+
+#  ------------------------------------------------------------------------------------------
+#  Copyright (c) Microsoft Corporation. All rights reserved.
+#  Licensed under the MIT License (MIT). See LICENSE in the repo root for license information.
+#  ------------------------------------------------------------------------------------------
+
+
+class Linear(nn.Module, LoraLayer):
+    # Lora implemented in a dense layer
+    def __init__(
+        self,
+        base_layer,
+        adapter_name: str,
+        config: LoraConfig,
+        r: int = 0,
+        lora_alpha: int = 1,
+        is_target_conv_1d_layer: bool = False,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        LoraLayer.__init__(self, base_layer, **kwargs)
+        self.fan_in_fan_out = config.fan_in_fan_out
+
+        self._active_adapter = adapter_name
+        self.update_layer(
+            adapter_name,
+            r,
+            lora_alpha=lora_alpha,
+            config=config,
+            **kwargs,
+        )
+        self.is_target_conv_1d_layer = is_target_conv_1d_layer
+
+    @property
+    def lora_variants(self):
+        from . import variants
+
+        return {
+            (): None,
+            ("use_dora",): variants.DoraLinearVariant,
+            ("arrow_config",): variants.ArrowLinearVariant,
+            ("use_bdlora",): variants.BdLoraLinearVariant,
+            ("alora_invocation_tokens",): variants.ALoraLinearVariant,
+            ("velora_config",): variants.VeloraLinearVariant,
+            ("monteclora_config",): variants.MontecloraLinearVariant,
+            ("mica",): variants.MiCALinearVariant,
+        }
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`list[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.lora_A.keys():
+                base_layer = self.get_base_layer()
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    # because of the copy operation.
+                    orig_weight = base_layer.weight.data.clone()
+                    orig_dtype = orig_weight.dtype
+                    if active_adapter not in self.lora_variant:  # vanilla LoRA
+                        delta_weight = self.get_delta_weight(active_adapter)
+                        orig_weight += delta_weight.to(orig_dtype)
+                    else:
+                        orig_weight = self.lora_variant[active_adapter].merge_safe(self, active_adapter, orig_weight)
+
+                    if not torch.isfinite(orig_weight).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = orig_weight
+
+                    if self.lora_bias[active_adapter]:
+                        if getattr(base_layer, "bias", None) is None:
+                            raise RuntimeError(
+                                "Impossible to merge LoRA with `lora_bias=True` because the base layer has no bias."
+                            )
+                        new_bias = base_layer.bias + self.lora_B[active_adapter].bias * self.scaling[active_adapter]
+                        if not torch.isfinite(new_bias).all():
+                            raise ValueError(
+                                f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                            )
+                        base_layer.bias.data = new_bias.to(orig_dtype)
+
+                else:
+                    if active_adapter not in self.lora_variant:  # vanilla LoRA
+                        delta_weight = self.get_delta_weight(active_adapter)
+                        base_layer.weight.data += delta_weight
+                    else:
+                        self.lora_variant[active_adapter].merge_unsafe(self, active_adapter, base_layer.weight)
+
+                    if self.lora_bias[active_adapter]:
+                        if getattr(base_layer, "bias", None) is None:
+                            raise RuntimeError(
+                                "Impossible to merge LoRA with `lora_bias=True` because the base layer has no bias."
+                            )
+                        base_layer.bias.data += self.lora_B[active_adapter].bias * self.scaling[active_adapter]
+
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.lora_A.keys():
+                weight = self.get_base_layer().weight
+                if active_adapter not in self.lora_variant:  # vanilla LoRA
+                    orig_dtype = weight.dtype
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    weight.data -= delta_weight.to(orig_dtype)
+                else:
+                    unmerged = self.lora_variant[active_adapter].unmerge(self, active_adapter, weight)
+                    weight.data = unmerged
+
+                if self.lora_bias[active_adapter]:
+                    self.get_base_layer().bias.data -= self.lora_B[active_adapter].bias * self.scaling[active_adapter]
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        """
+        Compute the delta weight for the given adapter.
+
+        Args:
+            adapter (str):
+                The name of the adapter for which the delta weight should be computed.
+        """
+        device = self.lora_B[adapter].weight.device
+        dtype = self.lora_B[adapter].weight.dtype
+
+        # In case users wants to merge the adapter weights that are in
+        # (b)float16 while being on CPU, we need to cast the weights to float32, perform the merge and then cast back to
+        # (b)float16 because some CPUs have slow bf16/fp16 matmuls.
+        cast_to_fp32 = device.type == "cpu" and (dtype == torch.float16 or dtype == torch.bfloat16)
+
+        weight_A = self.lora_A[adapter].weight
+        weight_B = self.lora_B[adapter].weight
+
+        if cast_to_fp32:
+            weight_A = weight_A.float()
+            weight_B = weight_B.float()
+
+        output_tensor = transpose(weight_B @ weight_A, self.fan_in_fan_out) * self.scaling[adapter]
+
+        if cast_to_fp32:
+            output_tensor = output_tensor.to(dtype=dtype)
+
+        return output_tensor
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        self._check_forward_args(x, *args, **kwargs)
+        adapter_names = kwargs.pop("adapter_names", None)
+        variant_kwargs = {k: kwargs.pop(k, None) for k in VARIANT_KWARG_KEYS}  # don't pass these to base_layer
+
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif adapter_names is not None:
+            result = self._mixed_batch_forward(x, *args, adapter_names=adapter_names, **variant_kwargs, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+            torch_result_dtype = result.dtype
+
+            lora_A_keys = self.lora_A.keys()
+            for active_adapter in self.active_adapters:
+                if active_adapter not in lora_A_keys:
+                    continue
+
+                lora_A = self.lora_A[active_adapter]
+                lora_B = self.lora_B[active_adapter]
+                dropout = self.lora_dropout[active_adapter]
+                scaling = self.scaling[active_adapter]
+                x = self._cast_input_dtype(x, lora_A.weight.dtype)
+                if active_adapter not in self.lora_variant:  # vanilla LoRA
+                    result = result + lora_B(lora_A(dropout(x))) * scaling
+                else:
+                    result = self.lora_variant[active_adapter].forward(
+                        self,
+                        active_adapter=active_adapter,
+                        x=x,
+                        result=result,
+                        **variant_kwargs,
+                        **kwargs,
+                    )
+
+            result = result.to(torch_result_dtype)
+
+        return result
+
+    def supports_lora_conversion(self, adapter_name: str = "default") -> bool:
+        return True
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "lora." + rep
+
+
+class _LoraEmbeddingAHolder(nn.Module):
+    """
+    A "fake" module to hold the lora_embedding_A weights for the TP hooks.
+    """
+
+    def __init__(self, lora_embedding_A_weight):
+        super().__init__()
+        self.weight = lora_embedding_A_weight.T  # lora_embedding_A shape is (r, vocab_size)
+
+
+class Embedding(nn.Module, LoraLayer):
+    # LoRA implemented in a Embedding layer
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        adapter_name: str,
+        config: LoraConfig,
+        r: int = 0,
+        lora_alpha: int = 1,
+        init_lora_weights: Union[bool, str] = True,
+        **kwargs,
+    ) -> None:
+        if config.lora_bias:
+            # lora_bias=True is not supported (yet) for embedding layers, as they use nn.Parameter
+            raise ValueError(f"lora_bias={config.lora_bias} is not supported for {self.__class__.__name__}.")
+
+        super().__init__()
+        LoraLayer.__init__(self, base_layer)
+        self.fan_in_fan_out = config.fan_in_fan_out
+
+        tp_plan = getattr(base_layer, "_hf_tp_plan", None)
+
+        self.device_mesh = getattr(base_layer, "_hf_device_mesh", None)
+        self.tp_layer = None
+
+        self.input_fns = {}
+        self.output_fns = {}
+
+        if tp_plan is not None:
+            if not is_transformers_ge_v5_4_0:
+                raise RuntimeError("Tensor Parallel with LoRA is only supported for transformers v5.4.0 and above. ")
+
+            if tp_plan != "embedding_rowwise":
+                raise ValueError(
+                    f'Unsupported tensor parallel plan {tp_plan} for embedding layers. Only "embedding_rowwise" is '
+                    "supported."
+                )
+
+            from transformers.integrations.tensor_parallel import ALL_PARALLEL_STYLES
+
+            self.tp_layer = copy.deepcopy(ALL_PARALLEL_STYLES[tp_plan])
+
+        self._active_adapter = adapter_name
+        self.update_layer(
+            adapter_name,
+            r,
+            lora_alpha=lora_alpha,
+            config=config,
+        )
+
+    @property
+    def lora_variants(self):
+        from . import variants
+
+        return {
+            (): None,
+            ("use_dora",): variants.DoraEmbeddingVariant,
+            ("mica",): variants.MiCAEmbeddingVariant,
+        }
+
+    def update_layer(
+        self,
+        adapter_name: str,
+        r: int,
+        lora_alpha: int,
+        config: LoraConfig,
+        **kwargs,
+    ) -> None:
+        lora_dropout = config.lora_dropout
+        init_lora_weights = config.init_lora_weights
+        use_rslora = config.use_rslora
+        lora_bias = config.lora_bias
+        inference_mode = config.inference_mode
+
+        if r <= 0:
+            raise ValueError(f"`r` should be a positive integer value but the value passed is {r}")
+
+        lora_variant = self.resolve_lora_variant(config=config)
+        if lora_variant is not None:
+            self.lora_variant[adapter_name] = lora_variant
+
+        self.r[adapter_name] = r
+        self.lora_alpha[adapter_name] = lora_alpha
+        if lora_dropout > 0.0:
+            lora_dropout_layer = nn.Dropout(p=lora_dropout)
+        else:
+            lora_dropout_layer = nn.Identity()
+
+        self.lora_dropout[adapter_name] = lora_dropout_layer
+        # Actual trainable parameters
+        weight_A = torch.randn((r, self.in_features))
+        weight_B = torch.randn((self.out_features, r))
+        self.lora_embedding_A[adapter_name] = nn.Parameter(weight_A)
+        self.lora_embedding_B[adapter_name] = nn.Parameter(weight_B)
+        self.lora_bias[adapter_name] = lora_bias
+
+        if use_rslora:
+            self.scaling[adapter_name] = lora_alpha / math.sqrt(r)
+        else:
+            self.scaling[adapter_name] = lora_alpha / r
+
+        self.use_rslora[adapter_name] = use_rslora
+
+        self.use_dora[adapter_name] = config.use_dora
+
+        if isinstance(init_lora_weights, str) and init_lora_weights.lower() == "mica":
+            with gather_params_ctx(self.get_base_layer().weight):
+                self.mica_init(adapter_name)
+        elif init_lora_weights == "loftq":
+            self.loftq_init(adapter_name)
+        elif init_lora_weights == "lora_ga":
+            # Embedding layers don't support LoRA-GA, fall back to standard initialization
+            self.reset_lora_parameters(adapter_name, True)
+        elif init_lora_weights:
+            self.reset_lora_parameters(adapter_name, init_lora_weights)
+
+        # call this before init of the lora variants
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+
+        if adapter_name in self.lora_variant:
+            self.lora_variant[adapter_name].init(self, adapter_name=adapter_name, config=config, **kwargs)
+
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+        # If there is tensor parallelism, we register the hooks for `self._embed`.
+        if self.tp_layer is not None:
+            mod = _LoraEmbeddingAHolder(self.lora_embedding_A[adapter_name])
+
+            def input_fn(inputs):
+                return self.tp_layer._prepare_input_fn(mod, inputs, self.device_mesh)
+
+            def output_fn(outputs):
+                return self.tp_layer._prepare_output_fn(mod, outputs, self.device_mesh)
+
+            self.input_fns[adapter_name] = input_fn
+            self.output_fns[adapter_name] = output_fn
+
+    def mica_init(self, adapter_name):
+        """Minor Component Adaptation (MiCA) initialization for embedding layers.
+
+        The effective embedding projection has shape `(embedding_dim, num_embeddings)`, so MiCA initializes
+        `lora_embedding_B` from the minor left singular vectors of `base_layer.weight.T` and sets `lora_embedding_A` to
+        zero.
+        """
+        if self.lora_embedding_B[adapter_name].device.type == "meta":
+            return
+
+        weight = self.get_base_layer().weight
+        dtype = weight.dtype
+        if dtype not in [torch.float32, torch.float16, torch.bfloat16]:
+            raise TypeError("Please initialize MiCA under float32, float16, or bfloat16.")
+
+        weight = weight.to(torch.float32).T
+        r = self.r[adapter_name]
+        max_r = min(weight.shape)
+        if r > max_r:
+            raise ValueError(
+                f"MiCA requires `r` <= min(num_embeddings, embedding_dim) but got r={r} for an embedding layer with "
+                f"weight shape {tuple(self.get_base_layer().weight.shape)} (max usable r is {max_r})."
+            )
+
+        U, _, _ = torch.linalg.svd(weight.data, full_matrices=False)
+        lora_embedding_B = U[:, -r:].contiguous()
+        lora_embedding_A = torch.zeros(r, weight.shape[1], device=weight.device)
+        self.lora_embedding_B[adapter_name].data = lora_embedding_B.to(dtype)
+        self.lora_embedding_A[adapter_name].data = lora_embedding_A.to(dtype)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`list[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.lora_embedding_A.keys():
+                base_layer = self.get_base_layer()
+                orig_dtype = base_layer.weight.dtype
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    # because of the copy operation.
+                    orig_weight = base_layer.weight.data.clone()
+                    if active_adapter not in self.lora_variant:  # vanilla LoRA
+                        orig_weight += self.get_delta_weight(active_adapter).to(orig_dtype)
+                    else:
+                        orig_weight = self.lora_variant[active_adapter].merge_safe(self, active_adapter, orig_weight)
+
+                    if not torch.isfinite(orig_weight).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = orig_weight
+                else:
+                    if active_adapter not in self.lora_variant:  # vanilla LoRA
+                        base_layer.weight.data += self.get_delta_weight(active_adapter).to(orig_dtype)
+                    else:
+                        self.lora_variant[active_adapter].merge_unsafe(self, active_adapter, base_layer.weight)
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            orig_dtype = self.get_base_layer().weight.dtype
+            if active_adapter in self.lora_embedding_A.keys():
+                weight = self.get_base_layer().weight
+                if active_adapter not in self.lora_variant:  # vanilla LoRA
+                    weight.data -= self.get_delta_weight(active_adapter).to(orig_dtype)
+                else:
+                    unmerged = self.lora_variant[active_adapter].unmerge(self, active_adapter, weight)
+                    weight.data = unmerged
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        """
+        Compute the delta weight for the given adapter.
+
+        Args:
+            adapter (str):
+                The name of the adapter for which the delta weight should be computed.
+        """
+        device = self.lora_embedding_B[adapter].device
+        dtype = self.lora_embedding_A[adapter].dtype
+
+        # In case users wants to merge the adapter weights that are in
+        # (b)float16 while being on CPU, we need to cast the weights to float32, perform the merge and then cast back to
+        # (b)float16 because some CPUs have slow bf16/fp16 matmuls.
+        cast_to_fp32 = device.type == "cpu" and (dtype == torch.float16 or dtype == torch.bfloat16)
+
+        weight_A = self.lora_embedding_A[adapter]
+        weight_B = self.lora_embedding_B[adapter]
+
+        if cast_to_fp32:
+            weight_A = weight_A.float()
+            weight_B = weight_B.float()
+
+        output_tensor = transpose(weight_B @ weight_A, True) * self.scaling[adapter]
+
+        if cast_to_fp32:
+            output_tensor = output_tensor.to(dtype=dtype)
+
+        return output_tensor
+
+    def _mixed_batch_forward(
+        self, x: torch.Tensor, *args: Any, adapter_names: list[str], **kwargs: Any
+    ) -> torch.Tensor:
+        # This is a special method that handles the case when users pass the argument `adapter_names`. This is an
+        # extra argument that allows mixing different adapters in the same batch at inference time.
+        result = self.base_layer(x, *args, **kwargs)
+
+        # Some embedding layers (e.g., Gemma3TextScaledWordEmbedding) apply scaling in their forward method.
+        # Since base_layer(x) already includes this scaling, we need to apply it to LoRA contributions too.
+        embed_scale = self._get_embed_scale()
+
+        unique_adapters = set(adapter_names)
+        sub_batch_indices_list = []
+        for adapter in unique_adapters:
+            sub_batch_indices_list.append([index for index, item in enumerate(adapter_names) if item == adapter])
+
+        for i, active_adapter in enumerate(unique_adapters):
+            if active_adapter == "__base__":
+                continue
+            if active_adapter not in self.lora_embedding_A.keys():
+                continue
+
+            embedding_A = self.lora_embedding_A[active_adapter].T
+            embedding_B = self.lora_embedding_B[active_adapter].T
+            scaling = self.scaling[active_adapter]
+
+            # getting the sub-batch, passing it to LoRA layers and updating the corresponding indices of the linear
+            # layer output
+            sub_batch = x[sub_batch_indices_list[i]]
+            after_A = self._embed(sub_batch, embedding_A)
+            adapter_output = (after_A @ embedding_B) * scaling
+
+            # Apply embed_scale to match the base layer's scaling
+            if embed_scale is not None:
+                adapter_output = adapter_output * embed_scale.to(adapter_output.dtype)
+
+            result[sub_batch_indices_list[i]] += adapter_output
+
+        return result
+
+    def _embed(
+        self,
+        input: torch.Tensor,
+        weight: torch.Tensor,
+        input_fn: Callable[[tuple[torch.Tensor]], torch.Tensor] | None = None,
+        output_fn: Callable[[torch.Tensor], torch.Tensor] | None = None,
+    ) -> torch.Tensor:
+        base_layer = self.get_base_layer()
+        if input_fn is not None:
+            input = input_fn((input,))
+        output = F.embedding(
+            input,
+            weight,
+            padding_idx=base_layer.padding_idx,
+            max_norm=base_layer.max_norm,
+            norm_type=base_layer.norm_type,
+            scale_grad_by_freq=base_layer.scale_grad_by_freq,
+            sparse=base_layer.sparse,
+        )
+        if output_fn is not None:
+            output = output_fn(output)
+        return output
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        # TODO: no dtype conversion here, unlike in Linear, is that correct?
+        self._check_forward_args(x, *args, **kwargs)
+        adapter_names = kwargs.pop("adapter_names", None)
+        variant_kwargs = {k: kwargs.pop(k, None) for k in VARIANT_KWARG_KEYS}  # don't pass these to base_layer
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif adapter_names is not None:
+            result = self._mixed_batch_forward(x, *args, adapter_names=adapter_names, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+            torch_result_dtype = result.dtype
+
+            # Some embedding layers (e.g., Gemma3TextScaledWordEmbedding) apply scaling in their forward method.
+            # Since base_layer(x) already includes this scaling, we need to apply it to LoRA contributions too.
+            embed_scale = self._get_embed_scale()
+
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.lora_embedding_A:
+                    continue
+
+                if active_adapter not in self.lora_variant:  # vanilla LoRA
+                    embedding_A = self.lora_embedding_A[active_adapter].T
+                    embedding_B = self.lora_embedding_B[active_adapter].T
+                    scaling = self.scaling[active_adapter]
+                    # input and output function hooks for TP support.
+                    input_fn = self.input_fns.get(active_adapter, None)
+                    output_fn = self.output_fns.get(active_adapter, None)
+                    after_A = self._embed(x, embedding_A, input_fn=input_fn, output_fn=output_fn)
+                    adapter_output = (after_A @ embedding_B) * scaling
+
+                    # Apply embed_scale to match the base layer's scaling
+                    if embed_scale is not None:
+                        adapter_output = adapter_output * embed_scale.to(adapter_output.dtype)
+
+                    result = result + adapter_output
+                else:
+                    result = self.lora_variant[active_adapter].forward(
+                        self,
+                        active_adapter=active_adapter,
+                        x=x,
+                        result=result,
+                        **variant_kwargs,
+                        **kwargs,
+                    )
+            result = result.to(torch_result_dtype)
+
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "lora." + rep
+
+
+class _ConvNd(nn.Module, LoraLayer):
+    # Lora implemented in a conv(2,3)d layer
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        adapter_name: str,
+        config: LoraConfig,
+        r: int = 0,
+        lora_alpha: int = 1,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        LoraLayer.__init__(self, base_layer)
+        if kwargs.get("use_alora", False):
+            raise ValueError("aLoRA does not support adapting conv layers.")
+        if config.velora_config is not None:
+            raise ValueError("VeLoRA does not support adapting conv layers.")
+        if base_layer.groups > 1:
+            warnings.warn("LoRA adapter added to ConvNd layer with groups > 1. Merging is not supported.")
+
+        if r % base_layer.groups != 0:
+            raise ValueError(
+                f"Targeting a {base_layer.__class__.__name__} with groups={base_layer.groups} and rank {r}. "
+                "Currently, support is limited to conv layers where the rank is divisible by groups. "
+                "Either choose a different rank or do not target this specific layer."
+            )
+
+        self._active_adapter = adapter_name
+        self._kernel_dim = base_layer.weight.dim()
+
+        self.update_layer(
+            adapter_name,
+            r,
+            lora_alpha=lora_alpha,
+            config=config,
+        )
+
+    def update_layer(
+        self,
+        adapter_name: str,
+        r: int,
+        lora_alpha: int,
+        config: LoraConfig,
+        **kwargs,
+    ) -> None:
+        lora_dropout = config.lora_dropout
+        init_lora_weights = config.init_lora_weights
+        use_rslora = config.use_rslora
+        lora_bias = config.lora_bias
+        inference_mode = config.inference_mode
+
+        if r <= 0:
+            raise ValueError(f"`r` should be a positive integer value but the value passed is {r}")
+
+        if lora_bias and (getattr(self.get_base_layer(), "bias", None) is None):
+            warnings.warn(
+                f"`lora_bias=True` was passed but the targeted layer of type {type(self.get_base_layer()).__name__} "
+                "has no bias. This means that merging LoRA weights won't be possible.",
+                PeftWarning,
+            )
+
+        lora_variant = self.resolve_lora_variant(config=config)
+        if lora_variant is not None:
+            self.lora_variant[adapter_name] = lora_variant
+
+        self.r[adapter_name] = r
+        self.lora_alpha[adapter_name] = lora_alpha
+        if lora_dropout > 0.0:
+            lora_dropout_layer = nn.Dropout(p=lora_dropout)
+        else:
+            lora_dropout_layer = nn.Identity()
+
+        self.lora_dropout[adapter_name] = lora_dropout_layer
+        # Actual trainable parameters
+        base_layer = self.get_base_layer()
+        kernel_size = base_layer.kernel_size
+        stride = base_layer.stride
+        padding = base_layer.padding
+        conv_layer = type(base_layer)
+        out_kernel = out_stride = (1,) * (self._kernel_dim - 2)
+        self.lora_A[adapter_name] = conv_layer(self.in_features, r, kernel_size, stride, padding, bias=False)
+        self.lora_B[adapter_name] = conv_layer(
+            r, self.out_features, out_kernel, out_stride, groups=base_layer.groups, bias=lora_bias
+        )
+        self.lora_bias[adapter_name] = lora_bias
+
+        if use_rslora:
+            self.scaling[adapter_name] = lora_alpha / math.sqrt(r)
+        else:
+            self.scaling[adapter_name] = lora_alpha / r
+
+        self.use_rslora[adapter_name] = use_rslora
+
+        self.use_dora[adapter_name] = config.use_dora
+
+        if init_lora_weights == "loftq":
+            self.loftq_init(adapter_name)
+        elif init_lora_weights == "lora_ga":
+            # Conv layers don't support LoRA-GA, fall back to standard initialization
+            self.reset_lora_parameters(adapter_name, True)
+        elif init_lora_weights:
+            self.reset_lora_parameters(adapter_name, init_lora_weights)
+
+        # call this before init of the lora variants
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+
+        if adapter_name in self.lora_variant:
+            self.lora_variant[adapter_name].init(self, adapter_name=adapter_name, config=config, **kwargs)
+
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def _get_dora_factor_view(self):
+        return (-1,) + (1,) * (self._kernel_dim - 1)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights inside the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`list[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.lora_A.keys():
+                base_layer = self.get_base_layer()
+                orig_dtype = base_layer.weight.dtype
+
+                if base_layer.groups > 1:
+                    # https://github.com/huggingface/peft/pull/2403
+                    raise NotImplementedError("Merging is not supported for _ConvNd layers with groups > 1!")
+
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    # because of the copy operation.
+                    orig_weight = base_layer.weight.data.clone()
+                    if active_adapter not in self.lora_variant:  # vanilla LoRA
+                        delta_weight = self.get_delta_weight(active_adapter)
+                        orig_weight += delta_weight.to(orig_dtype)
+                    else:
+                        orig_weight = self.lora_variant[active_adapter].merge_safe(self, active_adapter, orig_weight)
+
+                    if not torch.isfinite(orig_weight).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = orig_weight
+
+                    if self.lora_bias[active_adapter]:
+                        if getattr(base_layer, "bias", None) is None:
+                            raise RuntimeError(
+                                "Impossible to merge LoRA with `lora_bias=True` because the base layer has no bias."
+                            )
+                        new_bias = base_layer.bias + self.lora_B[active_adapter].bias * self.scaling[active_adapter]
+                        if not torch.isfinite(new_bias).all():
+                            raise ValueError(
+                                f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                            )
+                        base_layer.bias.data = new_bias.to(orig_dtype)
+
+                else:
+                    if active_adapter not in self.lora_variant:  # vanilla LoRA
+                        delta_weight = self.get_delta_weight(active_adapter)
+                        base_layer.weight.data += delta_weight
+                    else:
+                        self.lora_variant[active_adapter].merge_unsafe(self, active_adapter, base_layer.weight)
+
+                    if self.lora_bias[active_adapter]:
+                        if getattr(base_layer, "bias", None) is None:
+                            raise RuntimeError(
+                                "Impossible to merge LoRA with `lora_bias=True` because the base layer has no bias."
+                            )
+                        base_layer.bias.data += self.lora_B[active_adapter].bias * self.scaling[active_adapter]
+
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.lora_A.keys():
+                weight = self.get_base_layer().weight
+                if active_adapter not in self.lora_variant:  # vanilla LoRA
+                    orig_dtype = weight.dtype
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    weight.data -= delta_weight.to(orig_dtype)
+                else:
+                    unmerged = self.lora_variant[active_adapter].unmerge(self, active_adapter, weight)
+                    weight.data = unmerged
+
+                if self.lora_bias[active_adapter]:
+                    self.get_base_layer().bias.data -= self.lora_B[active_adapter].bias * self.scaling[active_adapter]
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        """
+        Compute the delta weight for the given adapter.
+
+        Args:
+            adapter (str):
+                The name of the adapter for which the delta weight should be computed.
+        """
+        device = self.lora_B[adapter].weight.device
+        dtype = self.lora_A[adapter].weight.dtype
+
+        # In case users wants to merge the adapter weights that are in
+        # (b)float16 while being on CPU, we need to cast the weights to float32, perform the merge and then cast back to
+        # (b)float16 because some CPUs have slow bf16/fp16 matmuls.
+        cast_to_fp32 = device.type == "cpu" and (dtype == torch.float16 or dtype == torch.bfloat16)
+
+        weight_A = self.lora_A[adapter].weight
+        weight_B = self.lora_B[adapter].weight
+
+        if cast_to_fp32:
+            weight_A = weight_A.float()
+            weight_B = weight_B.float()
+
+        # https://github.com/bmaltais/kohya_ss/blob/feb6728762a8f463d15ba936d189d4c3abfaa1ab/networks/lora.py#L117
+        if self.get_base_layer().weight.size()[2:4] == (1, 1):
+            # conv2d 1x1
+            output_tensor = (weight_B.squeeze(3).squeeze(2) @ weight_A.squeeze(3).squeeze(2)).unsqueeze(2).unsqueeze(
+                3
+            ) * self.scaling[adapter]
+        else:
+            output_tensor = self.conv_fn(weight_A.transpose(0, 1), weight_B)
+
+            if self.get_base_layer().groups > 1:
+                output_tensor = output_tensor * self.scaling[adapter]
+            else:
+                output_tensor = output_tensor.transpose(0, 1) * self.scaling[adapter]
+
+        if cast_to_fp32:
+            output_tensor = output_tensor.to(dtype=dtype)
+
+        return output_tensor
+
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        self._check_forward_args(x, *args, **kwargs)
+        adapter_names = kwargs.pop("adapter_names", None)
+        variant_kwargs = {k: kwargs.pop(k, None) for k in VARIANT_KWARG_KEYS}  # don't pass these to base_layer
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif adapter_names is not None:
+            result = self._mixed_batch_forward(x, *args, adapter_names=adapter_names, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+            torch_result_dtype = result.dtype
+
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.lora_A.keys():
+                    continue
+                lora_A = self.lora_A[active_adapter]
+                lora_B = self.lora_B[active_adapter]
+                dropout = self.lora_dropout[active_adapter]
+                scaling = self.scaling[active_adapter]
+                x = self._cast_input_dtype(x, lora_A.weight.dtype)
+
+                if active_adapter not in self.lora_variant:  # vanilla LoRA
+                    result = result + lora_B(lora_A(dropout(x))) * scaling
+                else:
+                    result = self.lora_variant[active_adapter].forward(
+                        self,
+                        active_adapter=active_adapter,
+                        x=x,
+                        result=result,
+                        **variant_kwargs,
+                        **kwargs,
+                    )
+
+            result = result.to(torch_result_dtype)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "lora." + rep
+
+
+class Conv2d(_ConvNd):
+    # Lora implemented in a conv2d layer
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if not self._kernel_dim == 4:
+            raise ValueError(f"Conv2d layer kernel must have 4 dimensions, not {self._kernel_dim}")
+        self.conv_fn = F.conv2d
+
+    @property
+    def lora_variants(self):
+        from . import variants
+
+        return {
+            (): None,
+            ("use_dora",): variants.DoraConv2dVariant,
+        }
+
+
+class Conv1d(_ConvNd):
+    # Lora implemented in a conv1d layer
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if not self._kernel_dim == 3:
+            raise ValueError(f"Conv1d layer kernel must have 3 dimensions, not {self._kernel_dim}")
+        self.conv_fn = F.conv1d
+
+    @property
+    def lora_variants(self):
+        from . import variants
+
+        return {
+            (): None,
+            ("use_dora",): variants.DoraConv1dVariant,
+        }
+
+
+class Conv3d(_ConvNd):
+    # Lora implemented in a conv3d layer
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if not self._kernel_dim == 5:
+            raise ValueError(f"Conv3d layer kernel must have 5 dimensions, not {self._kernel_dim}")
+        self.conv_fn = F.conv3d
+
+    @property
+    def lora_variants(self):
+        from . import variants
+
+        return {
+            (): None,
+            ("use_dora",): variants.DoraConv3dVariant,
+        }
+
+
+class MultiheadAttention(nn.Module, LoraLayer):
+    """LoRA implemented in a multihead attention layer
+
+    This is currently only implemented for the case of `_qkv_same_embed_dim = True`, i.e. query, key, and value having
+    the same dimension.
+
+    Note: LoRA is applied to both the in_proj (query/key/value) and out_proj. There is currently no way to specify only
+    one of them. Don't try to apply LoRA to the out_proj of MultiheadAttention by targeting that layer specifically,
+    since the forward method of that layer is not being used, hence the LoRA adapter would be ignored.
+
+    This is a little bit hacky because of the way that MultiheadAttention is implemented in PyTorch: There are no
+    `nn.Linear` layers which we can hook onto or, in case of output projection, `.forward` is not used. This
+    implementation works around these problems by merging the weights before the forward call and unmerging them after
+    the forward call.
+    """
+
+    def __init__(
+        self,
+        base_layer,
+        adapter_name: str,
+        config: LoraConfig,
+        r: int = 0,
+        lora_alpha: int = 1,
+        **kwargs,
+    ) -> None:
+        # TODO work with separate weights
+        if not getattr(base_layer, "_qkv_same_embed_dim", True):
+            # default for this value appears to be True:
+            # https://github.com/pytorch/pytorch/blob/701ba5203fe68d55d655bd4d6c008be94cf34ea5/torch/nn/modules/activation.py#L1128-L1130
+            raise ValueError(
+                f"Only same embed for query/key/value is supported as of now for {self.__class__.__name__}."
+            )
+        if config.use_dora:
+            # TODO: probably not so hard to implement
+            raise ValueError(f"{self.__class__.__name__} does not support DoRA (yet), please set use_dora to False")
+        if config.velora_config is not None:
+            raise ValueError(f"{self.__class__.__name__} does not support VeLoRA, please set `velora_config=None`.")
+        if kwargs.get("use_alora", False):
+            raise ValueError(f"{self.__class__.__name__} does not support aLoRA (yet), please set use_alora to False")
+        super().__init__()
+        LoraLayer.__init__(self, base_layer, **kwargs)
+
+        # Note: LoRA is applied to both in_proj and out_proj. There is currently no way to only specify one of them.
+        if isinstance(base_layer.out_proj, nn.Linear):
+            self.base_layer.out_proj = Linear(
+                base_layer.out_proj,
+                adapter_name,
+                r=r,
+                lora_alpha=lora_alpha,
+                config=config,
+                **kwargs,
+            )
+        else:
+            raise TypeError(f"out_proj must be an instance of nn.Linear for {self.__class__.__name__}.")
+
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, lora_alpha=lora_alpha, config=config)
+
+    @property
+    def embed_dim(self) -> int:
+        return self.get_base_layer().embed_dim
+
+    @property
+    def kdim(self) -> Optional[int]:
+        return self.get_base_layer().kdim
+
+    @property
+    def vdim(self) -> Optional[int]:
+        return self.get_base_layer().vdim
+
+    @property
+    def _qkv_same_embed_dim(self) -> bool:
+        return self.get_base_layer()._qkv_same_embed_dim
+
+    @property
+    def num_heads(self) -> int:
+        return self.get_base_layer().num_heads
+
+    @property
+    def dropout(self) -> float:
+        return self.get_base_layer().dropout
+
+    @property
+    def batch_first(self) -> bool:
+        return self.get_base_layer().batch_first
+
+    @property
+    def head_dim(self) -> int:
+        return self.get_base_layer().head_dim
+
+    @property
+    def in_proj_weight(self) -> nn.Parameter:
+        return self.get_base_layer().in_proj_weight
+
+    @property
+    def in_proj_bias(self) -> nn.Parameter:
+        return self.get_base_layer().in_proj_bias
+
+    @property
+    def out_proj(self) -> nn.Module:
+        return self.get_base_layer().out_proj.get_base_layer()
+
+    @property
+    def bias_k(self) -> Optional[nn.Parameter]:
+        return self.get_base_layer().bias_k
+
+    @property
+    def bias_v(self) -> Optional[nn.Parameter]:
+        return self.get_base_layer().bias_v
+
+    def merge_masks(self, *args, **kwargs) -> tuple[Optional[torch.Tensor], Optional[int]]:
+        return self.get_base_layer().merge_masks(*args, **kwargs)
+
+    @property
+    def add_zero_attn(self) -> bool:
+        return self.get_base_layer().add_zero_attn
+
+    def update_layer(self, *args, **kwargs) -> None:
+        super().update_layer(*args, **kwargs)
+        # Note: LoRA is applied to both in_proj and out_proj. There is currently no way to only specify one of them.
+        self.base_layer.out_proj.update_layer(*args, **kwargs)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        # Implementation follows this:
+        # https://github.com/Baijiong-Lin/LoRA-Torch/blob/4bfed6820b64fcf47064c30f30606a190a4f0d2e/loratorch/layers.py#L73-L79
+        # Notably, instead of mutating the weight, we delete the original weight and replace it by the merged weight
+        # TODO: work with separate weights
+        for active_adapter in adapter_names:
+            if active_adapter in self.lora_A.keys():
+                base_layer = self.get_base_layer()
+                orig_dtype = base_layer.out_proj.weight.dtype
+                if safe_merge:
+                    # TODO: work with separate weights
+                    # merging in_proj (nn.Parameter)
+                    orig_weight_in = base_layer.in_proj_weight.data.detach().clone()
+                    orig_weight_in += self.get_delta_weight(active_adapter).to(orig_dtype)
+                    if not torch.isfinite(orig_weight_in).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    # merging out_proj (subclass of nn.Linear)
+                    orig_weight_out = base_layer.out_proj.weight.data.detach().clone()
+                    orig_weight_out += base_layer.out_proj.get_delta_weight(active_adapter).to(orig_dtype)
+                    if not torch.isfinite(orig_weight_out).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    # unregister parameter implicitly and overwrite using merged weights; gradients are computed after
+                    # forward and, thus, after unmerging (see forward()), therefore this is safe to do.
+                    del base_layer.in_proj_weight
+                    base_layer.in_proj_weight = orig_weight_in
+
+                    del base_layer.out_proj.get_base_layer().weight
+                    base_layer.out_proj.get_base_layer().weight = orig_weight_out
+                    base_layer.out_proj.merge(adapter_names=[active_adapter])
+                else:
+                    # merging in_proj (nn.Parameter)
+                    # TODO: work with separate weights
+                    delta_weight = self.get_delta_weight(active_adapter).to(orig_dtype)
+                    weight_merged = base_layer.in_proj_weight.data.detach() + delta_weight
+
+                    # unregister parameter implicitly and overwrite using merged weights; gradients are computed after
+                    # forward and, thus, after unmerging (see forward()), therefore this is safe to do.
+                    del base_layer.in_proj_weight
+                    base_layer.in_proj_weight = weight_merged
+
+                    # merging out_proj (subclass of nn.Linear)
+                    delta_weight = base_layer.out_proj.get_delta_weight(active_adapter).to(orig_dtype)
+                    weight_merged = base_layer.out_proj.weight.data.detach() + delta_weight
+                    del base_layer.out_proj.get_base_layer().weight
+                    base_layer.out_proj.get_base_layer().weight = weight_merged
+                    base_layer.out_proj.merge(adapter_names=[active_adapter])
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+
+        # TODO work with separate weights
+        base_layer = self.get_base_layer()
+        orig_dtype = base_layer.out_proj.base_layer.weight.dtype
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.lora_A.keys():
+                # Ensure that requires_grad=False for the base weights after unmerging. This may not matter since
+                # requires_grad was False when the optimizer was initialized, but still let's try to be correct here.
+
+                # in_proj
+                delta_weight = self.get_delta_weight(active_adapter).to(orig_dtype)
+                old_weight = base_layer.in_proj_weight.data - delta_weight
+                del base_layer.in_proj_weight
+                base_layer.register_parameter("in_proj_weight", nn.Parameter(old_weight, requires_grad=False))
+
+                # out_proj
+                delta_weight = base_layer.out_proj.get_delta_weight(active_adapter).to(orig_dtype)
+                old_weight = base_layer.out_proj.base_layer.weight.data - delta_weight
+                del base_layer.out_proj.base_layer.weight
+                base_layer.out_proj.base_layer.register_parameter(
+                    "weight", nn.Parameter(old_weight, requires_grad=False)
+                )
+
+        self.get_base_layer().out_proj.unmerge()
+
+    def unload_and_optionally_merge_module(
+        self, merge: bool, safe_merge: bool, adapter_names: Optional[list[str]]
+    ) -> nn.MultiheadAttention:
+        """
+        Merging and unloading of the MultiheadAttention module
+
+        This requires an extra step for MultiheadAttention, which is why there is this special method instead of
+        relying on the normal merge_and_unload code path.
+        """
+        if merge:
+            self.merge(safe_merge=safe_merge, adapter_names=adapter_names)
+        base_layer = self.get_base_layer()
+
+        # extra steps: re-register weights, take care of out_proj layer
+        # in_proj
+        weight = base_layer.in_proj_weight
+        del base_layer.in_proj_weight
+        base_layer.register_parameter("in_proj_weight", nn.Parameter(weight.data, requires_grad=weight.requires_grad))
+
+        # out_proj
+        out_proj_layer = base_layer.out_proj.get_base_layer()
+        weight = out_proj_layer.weight
+        del out_proj_layer.weight
+        out_proj_layer.register_parameter("weight", nn.Parameter(weight.data, requires_grad=weight.requires_grad))
+
+        base_layer.out_proj = out_proj_layer
+        return base_layer
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        """
+        Compute the delta weight for the given adapter.
+
+        Args:
+            adapter (str):
+                The name of the adapter for which the delta weight should be computed.
+        """
+        device = self.lora_B[adapter].weight.device
+        dtype = self.lora_B[adapter].weight.dtype
+
+        # In case users wants to merge the adapter weights that are in
+        # (b)float16 while being on CPU, we need to cast the weights to float32, perform the merge and then cast back to
+        # (b)float16 because some CPUs have slow bf16/fp16 matmuls.
+        cast_to_fp32 = device.type == "cpu" and (dtype == torch.float16 or dtype == torch.bfloat16)
+
+        weight_A = self.lora_A[adapter].weight
+        weight_B = self.lora_B[adapter].weight
+
+        if cast_to_fp32:
+            weight_A = weight_A.float()
+            weight_B = weight_B.float()
+
+        output_tensor = (weight_B @ weight_A) * self.scaling[adapter]
+
+        if cast_to_fp32:
+            output_tensor = output_tensor.to(dtype=dtype)
+
+            # cast back the weights
+            self.lora_A[adapter].weight.data = weight_A.to(dtype)
+            self.lora_B[adapter].weight.data = weight_B.to(dtype)
+
+        return output_tensor
+
+    def _check_forward_args(self, x, *args, **kwargs):
+        if "adapter_names" in kwargs:
+            raise TypeError(f"lora.{self.__class__.__name__} does not support mixed adapter batches.")
+        super()._check_forward_args(x, *args, **kwargs)
+
+    def forward(self, query: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        previous_dtype = query.dtype
+        self._check_forward_args(query, *args, **kwargs)
+
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(query, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(query, *args, **kwargs)
+        else:
+            out_proj = self.get_base_layer().out_proj
+            if out_proj.active_adapters != self.active_adapters:
+                # We have a case that in_proj and out_proj have diverging merged adapters. We cannot
+                # really deal with this correctly, thus it's better to raise than possibly create a hard to debug mess
+                cls_name = self.get_base_layer().__class__.__name__
+                raise ValueError(
+                    f"The out_proj layer of {cls_name} has merged layers but {cls_name} itself doesn't; please ensure "
+                    "that either both or none have merged layers"
+                )
+
+            # Merge all adapters that are active for this module, i.e. the LoRA weights for in_proj and out_proj.
+            # in_proj uses nn.Parameters, therefore, there is no forward method to be used and we have to explicitly
+            # merge for the LoRA weights to have an effect:
+            # https://github.com/pytorch/pytorch/blob/6ebb26d572d5fcdc6ac0d1297bdf8d1eb5d20722/torch/nn/modules/activation.py#L1020
+            # For out_proj, we have an nn.Linear (or rather: NonDynamicallyQuantizableLinear), but its forward method
+            # is not used:
+            # https://github.com/pytorch/pytorch/blob/6ebb26d572d5fcdc6ac0d1297bdf8d1eb5d20722/torch/nn/modules/activation.py#L1267-L1271
+            # Therefore, its LoRA weights also need to be merged to have an effect.
+            active_adapters = [a for a in self.active_adapters if a in self.lora_A]
+            try:
+                self.merge(adapter_names=active_adapters)
+                result = self.base_layer(query, *args, **kwargs)
+            finally:
+                # it's safe to call unmerge(), which unmerges all adapters, because we checked that not self.merged,
+                # i.e. there is was no merged layer before
+                self.unmerge()
+
+        result = (result[0].to(previous_dtype), result[1].to(previous_dtype) if result[1] is not None else result[1])
+        return result
+
+    # The decorator is needed in case low_cpu_mem_usage=True is used, as we don't want the base layer weights to be
+    # moved to meta device. This requires the use of PEFT's implementation of init_empty_weight instead of using the one
+    # from accelerate.
+    @skip_init_on_device
+    def _restore_weights(self):
+        # Restore the weights as registered parameters on the base layer.
+        # This is necessary because the way that weights are merged/unmerged (which is necessary for forward to work
+        # correctly), the Module "forgets" these attributes. Therefore, we need to call register_parameter explicitly.
+        # We cannot call register_parameter for merging/unmerging because that cuts them off from the autograd graph.
+        # Note that this is hacky, since we need to ensure that _restore_weights is called by each method that needs it.
+
+        # in_proj
+        # TODO work with separate weights
+        base_layer = self.get_base_layer()
+        weight = base_layer.in_proj_weight
+        del base_layer.in_proj_weight
+        base_layer.register_parameter("in_proj_weight", nn.Parameter(weight.data, requires_grad=weight.requires_grad))
+
+        # out_proj
+        base_layer = base_layer.out_proj.get_base_layer()
+        weight = base_layer.weight
+        del base_layer.weight
+        base_layer.register_parameter("weight", nn.Parameter(weight.data, requires_grad=weight.requires_grad))
+
+    def state_dict(self, *args, **kwargs):
+        self._restore_weights()
+        return super().state_dict(*args, **kwargs)
+
+    def named_modules(self, *args, **kwargs):
+        # Note: no need to also implement modules(), as modules() calls named_modules() under the hood
+        self._restore_weights()
+        return super().named_modules(*args, **kwargs)
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "lora." + rep
+
+
+class _LoraParameterProxy(nn.Module):
+    """This proxies an `nn.Parameter` that is targeted with LoRA.
+    Intended to be used in conjunction with `nn.utils.parametrize`, see `ParamWrapper`.
+    """
+
+    def __init__(self, delta_weight):
+        super().__init__()
+        self.delta_weight = delta_weight
+
+    @staticmethod
+    def _low_prec_add(x, y):
+        # addition in fp8 is not directly supported, need to use a higher precision
+        orig_dtype = x.dtype
+        upcast_dtype = y.dtype
+        if upcast_dtype not in ALLOWED_COMPUTE_DTYPES:
+            raise RuntimeError(
+                f"There is an attempt to upcast the targeted parameter to {upcast_dtype} "
+                f"but the only supported are: {ALLOWED_COMPUTE_DTYPES}."
+            )
+
+        # this operation can be quite costly
+        x = x.to(upcast_dtype)
+        z = x + y
+        # clamp to valid range before casting down, as this is *not* performed automatically and can thus result in NANs
+        info = torch.finfo(orig_dtype)
+        z = z.clamp(min=info.min, max=info.max)
+        return z.to(orig_dtype)
+
+    def forward(self, W):
+        if any(getattr(torch, dtype_name, None) == W.dtype for dtype_name in UPCAST_DTYPES):
+            return self._low_prec_add(W, self.delta_weight)
+        return W + self.delta_weight
+
+
+# copied from:
+# https://github.com/pytorch/pytorch/blob/5e386eec9426f174eea130c0c012d9f65ebe65fb/torch/nn/utils/parametrize.py#L75-L79
+def _register_parameter_or_buffer(module, name, X):
+    if isinstance(X, nn.Parameter):
+        module.register_parameter(name, X)
+    else:
+        module.register_buffer(name, X)
+
+
+class ParamWrapper(nn.Module, LoraLayer):
+    """A LoRA wrapper for `nn.Parameter`. This layer is dispatched if users target a parameter directly with
+    `lora_config.target_parameters`.
+
+    Note:
+        - When accessing the wrapped nn.Parameter directly, e.g. via `module.weight`, the LoRA weights are *not*
+          applied.
+        - Each `ParamWrapper` adapts exactly one `nn.Parameter`. To target multiple parameters on the same module, the
+          wrappers are nested, i.e. a `ParamWrapper` wraps another `ParamWrapper`.
+        - Multiple adapters are supported, but all adapters on the model that use `target_parameters` must target the
+          same set of parameters.
+    """
+
+    def __init__(
+        self,
+        base_layer,
+        adapter_name: str,
+        parameter_name: str,
+        config: LoraConfig,
+        r: int = 0,
+        lora_alpha: int = 1,
+        is_target_conv_1d_layer: bool = False,
+        **kwargs,
+    ) -> None:
+        self.parameter_name = parameter_name
+        super().__init__()
+        LoraLayer.__init__(self, base_layer, **kwargs)
+
+        if config.lora_dropout:
+            # It's not possible to factor out x from lora_B(lora_A(dropout(x))), so dropout can't be correctly
+            # implemented
+            raise ValueError(f"lora.{self.__class__.__name__} does not work with lora_dropout != 0.")
+        if config.fan_in_fan_out:
+            raise ValueError(f"lora.{self.__class__.__name__} does not work with fan_in_fan_out.")
+        if config.lora_bias:
+            raise ValueError(f"lora.{self.__class__.__name__} does not work with lora_bias=True.")
+        if config.use_dora:
+            raise ValueError(f"lora.{self.__class__.__name__} does not work with use_dora=True.")
+        if config.velora_config is not None:
+            raise ValueError(f"lora.{self.__class__.__name__} does not work when `velora_config` is set.")
+        if is_target_conv_1d_layer:
+            raise ValueError(f"lora.{self.__class__.__name__} does not work with is_target_conv_1d_layer=True.")
+
+        self.fan_in_fan_out = config.fan_in_fan_out
+        self._did_swap_in_out_features = False  # ensure we swap only once
+        self._active_adapter = adapter_name
+        self.update_layer(
+            adapter_name,
+            r,
+            lora_alpha=lora_alpha,
+            config=config,
+        )
+
+    def _get_in_out_features(self, module: nn.Module) -> tuple[int, int] | tuple[None, None]:
+        # For ParamWrapper, we don't derive the in_features and out_features based on the base layer type, but directly
+        # from the targeted parameter.
+        param = self.get_param()
+        if param.ndim == 3:
+            num_experts, in_features, out_features = param.shape
+        else:
+            num_experts, in_features, out_features = 1, param.shape[1], param.shape[0]
+        if param.ndim not in (2, 3):
+            raise ValueError(
+                f"lora.{self.__class__.__name__} was initialized with {param.ndim} dimensional Parameter, but only 2d "
+                "and 3d are supported."
+            )
+        # we have to store the num_experts attribute here, as the parent class only stores in_features and out_features.
+        self.num_experts = num_experts
+        return in_features, out_features
+
+    def update_layer(
+        self,
+        adapter_name: str,
+        r: int,
+        lora_alpha: int,
+        config: LoraConfig,
+        **kwargs,
+    ) -> None:
+        # same method as in lora.Linear but taking into account that there can be multiple experts (3d parameter)
+        lora_dropout = config.lora_dropout
+        init_lora_weights = config.init_lora_weights
+        use_rslora = config.use_rslora
+        lora_bias = config.lora_bias
+        inference_mode = config.inference_mode
+        # This code works for linear layers, override for other layer types
+        if r <= 0:
+            raise ValueError(f"`r` should be a positive integer value but the value passed is {r}")
+
+        lora_variant = self.resolve_lora_variant(config=config)
+        if lora_variant is not None:
+            raise ValueError(f"lora.{self.__class__.__name__} does not work with LoRA variants like DoRA.")
+
+        # for some MoE layers, the order is (experts, out_features, in_features)
+        is_transposed = getattr(self.get_base_layer(), "is_transposed", False)
+        swap_in_out_features = (self.get_param().ndim == 3) and not is_transposed
+        if swap_in_out_features and not self._did_swap_in_out_features:
+            self.in_features, self.out_features = self.out_features, self.in_features
+            self._did_swap_in_out_features = True
+
+        self.r[adapter_name] = r
+        self.lora_alpha[adapter_name] = lora_alpha
+        if lora_dropout > 0.0:
+            # It's not possible to factor out x from lora_B(lora_A(dropout(x))), so dropout can't be correctly
+            # implemented
+            raise ValueError(f"lora.{self.__class__.__name__} does not work with lora_dropout != 0.")
+        else:
+            lora_dropout_layer = nn.Identity()
+
+        self.lora_dropout.update(nn.ModuleDict({adapter_name: lora_dropout_layer}))
+        # Actual trainable parameters
+        # Difference to normal update_layer: consider experts. LoRA layers still use nn.Linear for consistency with
+        # lora.Linear.
+        self.lora_A[adapter_name] = nn.Linear(self.in_features, r * self.num_experts, bias=False)
+        self.lora_B[adapter_name] = nn.Linear(r * self.num_experts, self.out_features, bias=lora_bias)
+        self.lora_bias[adapter_name] = lora_bias
+
+        if use_rslora:
+            self.scaling[adapter_name] = lora_alpha / math.sqrt(r)
+        else:
+            self.scaling[adapter_name] = lora_alpha / r
+
+        self.use_rslora[adapter_name] = use_rslora
+
+        self.use_dora[adapter_name] = config.use_dora
+
+        # for inits that require access to the base weight, use gather_param_ctx so that the weight is gathered when using DeepSpeed
+        if isinstance(init_lora_weights, str) and init_lora_weights.startswith("pissa"):
+            with gather_params_ctx(self.get_base_layer().weight):
+                self.pissa_init(adapter_name, init_lora_weights)
+        elif isinstance(init_lora_weights, str) and init_lora_weights.startswith("corda"):
+            with gather_params_ctx(self.get_base_layer().weight):
+                self.corda_init(adapter_name, init_lora_weights)
+        elif isinstance(init_lora_weights, str) and init_lora_weights.lower() == "olora":
+            with gather_params_ctx(self.get_base_layer().weight):
+                self.olora_init(adapter_name)
+        elif init_lora_weights == "loftq":
+            with gather_params_ctx(self.get_base_layer().weight):
+                self.loftq_init(adapter_name)
+        elif init_lora_weights == "eva":
+            nn.init.zeros_(self.lora_B[adapter_name].weight)
+        elif init_lora_weights == "orthogonal":
+            with gather_params_ctx(self.get_base_layer().weight):
+                self.orthogonal_init(adapter_name)
+        elif init_lora_weights == "lora_ga":
+            with gather_params_ctx(self.get_base_layer().weight):
+                self.lora_ga_init(adapter_name, config.lora_ga_config)
+        elif init_lora_weights:
+            self.reset_lora_parameters(adapter_name, init_lora_weights)
+        # call this before init of the lora variants
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+
+        if adapter_name in self.lora_variant:
+            self.lora_variant[adapter_name].init(self, config=config, **kwargs)
+
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def _move_adapter_to_device_of_base_layer(self, adapter_name: str, device: Optional[torch.device] = None) -> None:
+        """
+        Move the adapter of the given name to the device of the base layer. Needs special handling for nn.Parameter
+        """
+        device = self.get_param().device
+        meta = torch.device("meta")
+        param = self.get_param()
+
+        for adapter_layer_name in self.adapter_layer_names + self.other_param_names:
+            adapter_layer = getattr(self, adapter_layer_name, None)
+            if not isinstance(adapter_layer, (nn.ModuleDict, nn.ParameterDict, BufferDict)):
+                continue
+            if adapter_name not in adapter_layer:
+                continue
+            if any(p.device == meta for p in adapter_layer.parameters()):
+                continue
+
+            if param.dtype.is_floating_point or param.dtype.is_complex:
+                adapter_layer[adapter_name] = adapter_layer[adapter_name].to(device, dtype=param.dtype)
+            else:
+                adapter_layer[adapter_name] = adapter_layer[adapter_name].to(device)
+
+    def get_param(self):
+        param = getattr(self.get_base_layer(), self.parameter_name)
+        return param
+
+    def get_delta_weight(self, adapter_name, *args, **kwargs):
+        if self.num_experts == 1:
+            # could actually be a normal layer or experts stacked block-diagonally, acting like a single layer
+            delta_weight = Linear.get_delta_weight(self, adapter_name, *args, **kwargs)
+        else:
+            weight_A = self.lora_A[adapter_name].weight
+            weight_B = self.lora_B[adapter_name].weight
+            # shape: experts x rank x in_features
+            weight_A = weight_A.reshape(self.num_experts, -1, weight_A.shape[-1])
+            # shape: out_features x rank x experts
+            weight_B = weight_B.reshape(weight_B.shape[0], -1, self.num_experts)
+            # fan_in_fan_out must be False, so no transpose call here
+            if not self._did_swap_in_out_features:
+                delta_weight = torch.einsum("o r e, e r i -> e i o", weight_B, weight_A) * self.scaling[adapter_name]
+            else:
+                # for some MoE layers, the order is (experts, out_features, in_features)
+                delta_weight = torch.einsum("o r e, e r i -> e o i", weight_B, weight_A) * self.scaling[adapter_name]
+
+        param = self.get_param()
+        if param.dtype in ALLOWED_COMPUTE_DTYPES:
+            delta_weight = delta_weight.to(param.device, param.dtype)
+        else:
+            # don't cast dW to weight dtype if it is in torch.float8_e4m3fn etc. as these low precision dtypes because
+            # we want to perform the W+dW addition in high precision before downcasting, see _low_prec_add.
+            delta_weight = delta_weight.to(param.device)
+        return delta_weight
+
+    @contextmanager
+    def _activate_lora(self, active_adapters: list[str]):
+        if not active_adapters or not any(adapter in self.lora_A for adapter in active_adapters):
+            # no active adapters for this layer
+            yield
+            return
+
+        delta_weight = None
+        for active_adapter in active_adapters:
+            if active_adapter not in self.lora_A:
+                continue
+            if delta_weight is None:
+                delta_weight = self.get_delta_weight(active_adapter)
+            else:
+                delta_weight = delta_weight + self.get_delta_weight(active_adapter)
+
+        base_layer = self.get_base_layer()
+        requires_grad_before = self.get_param().requires_grad
+        nn.utils.parametrize.register_parametrization(
+            base_layer, self.parameter_name, _LoraParameterProxy(delta_weight)
+        )
+        # set requires_grad, as it defaults to False
+        base_layer.parametrizations[self.parameter_name].original.requires_grad_(requires_grad_before)
+        try:
+            with nn.utils.parametrize.cached():
+                yield
+        finally:
+            self._remove_parametrizations()
+
+    def _remove_parametrizations(self):
+        # Remove the parametrization of this specific parameter
+        base_layer = self.get_base_layer()
+        parameter_name = self.parameter_name
+        if parameter_name not in base_layer.parametrizations:
+            raise ValueError(
+                "Something went wrong, please report this issue on PEFT: https://github.com/huggingface/peft/issues"
+            )
+
+        param_list = base_layer.parametrizations[parameter_name]
+        if len(param_list) == 1:
+            # last parametrization, we can safely remove it completely
+            nn.utils.parametrize.remove_parametrizations(base_layer, parameter_name, leave_parametrized=False)
+            return
+
+        # If there are multiple parametrizations for the same parameter_name, we only want to remove the LoRA proxy.
+        # Unfortunately, PyTorch does not support this directly, so we need to take care of it manually. To achieve
+        # this, we check the ParameterList from the back until we find the _LoraParameterProxy instance and then remove
+        # it.
+        reversed_indices = reversed(range(len(param_list)))
+        for i in reversed_indices:
+            module = param_list[i]
+            if isinstance(module, _LoraParameterProxy):
+                del param_list[i]
+                break
+        else:  # no break encountered
+            # this should not happen, but raising an error is probably not necessary
+            warnings.warn(
+                f"Could not find any LoRA parametrization on {self}, please open an issue on "
+                "https://github.com/huggingface/peft/issues and report this warning."
+            )
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        # same as lora.Linear.merge but not hard-coding base_layer.weight and without special cases like variants removed
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.lora_A.keys():
+                base_layer = self.get_base_layer()
+                param = getattr(base_layer, self.parameter_name)
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    # because of the copy operation.
+                    orig_weight = param.data.clone()
+                    orig_dtype = orig_weight.dtype
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    orig_weight += delta_weight.to(orig_dtype)
+
+                    if not torch.isfinite(orig_weight).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    param.data = orig_weight
+
+                else:
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    param.data += delta_weight
+
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        # same as lora.Linear.unmerge but not hard-coding base_layer.weight and without special cases like variants removed
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.lora_A.keys():
+                param = getattr(self.get_base_layer(), self.parameter_name)
+                orig_dtype = param.dtype
+                delta_weight = self.get_delta_weight(active_adapter)
+                param.data -= delta_weight.to(orig_dtype)
+
+    def _check_forward_args(self, x, *args, **kwargs):
+        """Check if the arguments are compatible with the configs and state of the model"""
+        if kwargs.get("adapter_names", None):
+            raise ValueError(f"lora.{self.__class__.__name__} does not support mixed adapter batches yet.")
+        super()._check_forward_args(x, *args, **kwargs)
+
+    def unload_and_optionally_merge_module(self, merge: bool, safe_merge: bool, adapter_names: Optional[list[str]]):
+        base_layer = self.base_layer
+        # ParamWrappers can be nested, so merge and retrieve base layer recursively
+        if merge:
+            self.merge(safe_merge=safe_merge, adapter_names=adapter_names)
+            while isinstance(base_layer, ParamWrapper):
+                base_layer.merge(safe_merge=safe_merge, adapter_names=adapter_names)
+                base_layer = base_layer.base_layer
+        else:
+            base_layer = self.get_base_layer()
+        return base_layer
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        self._check_forward_args(x, *args, **kwargs)
+        adapter_names = kwargs.pop("adapter_names", None)
+
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif adapter_names is not None:
+            raise ValueError(f"lora.{self.__class__.__name__} does not support mixed batch inference")
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            with self._activate_lora(self.active_adapters):
+                result = self.base_layer(x, *args, **kwargs)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        idx = rep.find("(") + 1
+        # insert the name of the parameter to allow the repr to be disambiguous when multiple parameters on the same
+        # module are being targeted
+        rep = f"{rep[:idx]}\n  parameter_name='{self.parameter_name}',{rep[idx:]}"
+        return "lora." + rep
+
+
+def dispatch_default(
+    target: torch.nn.Module,
+    adapter_name: str,
+    config: LoraConfig,
+    parameter_name: Optional[str] = None,
+    **kwargs,
+) -> Optional[torch.nn.Module]:
+    new_module = None
+
+    if isinstance(target, BaseTunerLayer):
+        target_base_layer = target.get_base_layer()
+    else:
+        target_base_layer = target
+
+    if parameter_name is not None:
+        new_module = ParamWrapper(target, adapter_name, parameter_name=parameter_name, config=config, **kwargs)
+    elif isinstance(target_base_layer, torch.nn.Embedding):
+        new_module = Embedding(target, adapter_name, config=config, **kwargs)
+    elif isinstance(target_base_layer, torch.nn.Conv2d):
+        new_module = Conv2d(target, adapter_name, config=config, **kwargs)
+    elif isinstance(target_base_layer, torch.nn.Conv3d):
+        new_module = Conv3d(target, adapter_name, config=config, **kwargs)
+    elif isinstance(target_base_layer, nn.Conv1d):
+        new_module = Conv1d(target, adapter_name, config=config, **kwargs)
+    elif isinstance(target_base_layer, torch.nn.MultiheadAttention):
+        new_module = MultiheadAttention(target, adapter_name, config=config, **kwargs)
+    elif isinstance(target_base_layer, torch.nn.Linear):
+        if config.fan_in_fan_out:
+            warnings.warn(
+                "fan_in_fan_out is set to True but the target module is `torch.nn.Linear`. "
+                "Setting fan_in_fan_out to False."
+            )
+            config.fan_in_fan_out = False
+        new_module = Linear(target, adapter_name, config=config, **kwargs)
+    elif isinstance(target_base_layer, Conv1D):
+        if not config.fan_in_fan_out:
+            warnings.warn(
+                "fan_in_fan_out is set to False but the target module is `Conv1D`. Setting fan_in_fan_out to True."
+            )
+            config.fan_in_fan_out = True
+        new_module = Linear(target, adapter_name, is_target_conv_1d_layer=True, config=config, **kwargs)
+
+    return new_module
diff --git a/src/peft/tuners/lora/loraga.py b/src/peft/tuners/lora/loraga.py
new file mode 100644
index 0000000..bb0926e
--- /dev/null
+++ b/src/peft/tuners/lora/loraga.py
@@ -0,0 +1,191 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+# Reference code: https://github.com/Outsider565/LoRA-GA
+# Reference paper: https://arxiv.org/abs/2407.05000
+
+import os
+from collections.abc import Callable
+from typing import Any, Optional
+
+import torch
+from torch import nn
+from transformers.pytorch_utils import Conv1D
+
+from peft.tuners.lora.config import LoraConfig
+from peft.tuners.lora.model import LoraModel
+
+
+def get_target_modules(model: nn.Module, config: LoraConfig):
+    """
+    Iterate over LoRA-GA target name and modules of a model. A module is a target if its name is in
+    `config.target_modules` and is `nn.Linear` or `Conv1D`.
+    """
+    for name, module in model.named_modules():
+        if LoraModel._check_target_module_exists(config, name) and isinstance(module, (nn.Linear, Conv1D)):
+            yield name, module
+
+
+def get_model_device(model: nn.Module) -> str:
+    if hasattr(model, "module"):  # Handle DeepSpeed/DataParallel
+        model = model.module
+    return next(iter(model.parameters())).device
+
+
+@torch.no_grad()
+def preprocess_loraga(
+    model: nn.Module,
+    lora_config: LoraConfig,
+    train_step: Callable[[], None],
+    cache_file: Optional[str] = None,
+):
+    """
+    Build necessary LoRA-GA fields for a model by estimating gradients.
+
+    For each linear layer, gradients will be estimated by running the provided train_step callback. These gradients are
+    then attached to the modules and used during initialization.
+
+    Args:
+        model (`nn.Module`):
+            Model to preprocess.
+        lora_config (`LoraConfig`):
+            Lora configuration of the model. `lora_config.lora_ga_config` should be set.
+        train_step (`Callable[[], None]`):
+            Callback to run gradient estimation. Typically you should run model forward and backward passes in this
+            callback. The gradients will be accumulated across all calls within this callback.
+        cache_file (`Optional[str]`):
+            Optional path to cache file for saving/loading gradients. If provided and the file exists, gradients will
+            be loaded from cache. Otherwise, gradients will be estimated and saved to this path.
+
+    Upon completion, the following fields are set for each target module:
+        _peft_loraga_grad (`torch.Tensor`):
+            Accumulated gradient for the weight matrix.
+    """
+    if lora_config.lora_ga_config is None:
+        raise ValueError(
+            "If you want to use LoRA-GA, please initialize the LoraConfig with "
+            "init_lora_weights='lora_ga' and lora_ga_config=LoraGAConfig(...)."
+        )
+
+    # Populate target_modules from defaults if empty
+    # This logic mirrors BaseTuner._prepare_adapter_config which runs after get_peft_model.
+    # Since preprocess_loraga is called before get_peft_model, we need to handle this ourselves.
+    if lora_config.target_modules is None:
+        model_config = LoraModel.get_model_config(model)
+        target_modules = LoraModel.target_module_mapping.get(model_config["model_type"])
+        if target_modules is None:
+            raise ValueError("Please specify `target_modules` in `peft_config`")
+        lora_config.target_modules = set(target_modules)
+
+    # Check for quantized models - LoRA-GA requires full-precision gradients
+    for name, module in get_target_modules(model, lora_config):
+        if hasattr(module, "quant_state"):
+            raise ValueError(
+                f"LoRA-GA does not support quantized models. Found quantized module: '{name}'. "
+                "LoRA-GA requires full-precision gradients during preprocessing."
+            )
+
+    # If cache exists, load from cache
+    if cache_file is not None and os.path.exists(cache_file) and os.path.getsize(cache_file) > 0:
+        cache = torch.load(cache_file, map_location=get_model_device(model))
+        for name, module in get_target_modules(model, lora_config):
+            module._peft_loraga_grad = cache[f"{name}._peft_loraga_grad"]
+    else:
+        # Estimate gradients by running train_step
+        estimate_gradients(model, lora_config, train_step)
+
+        # Save cache to disk if specified
+        if cache_file is not None:
+            cache: dict[str, Any] = {}
+            for name, module in get_target_modules(model, lora_config):
+                cache[f"{name}._peft_loraga_grad"] = module._peft_loraga_grad
+
+            os.makedirs(os.path.dirname(cache_file), exist_ok=True)
+            torch.save(cache, cache_file)
+
+
+def estimate_gradients(
+    model: nn.Module,
+    lora_config: LoraConfig,
+    train_step: Callable[[], None],
+):
+    """
+    Estimate gradients for LoRA-GA initialization.
+
+    This function enables gradient computation ONLY on target module weights and runs the train_step callback. This is
+    more memory-efficient than enabling gradients globally.
+    """
+    # Remember original training state
+    was_training = model.training
+    model.train()
+
+    # Get target modules list once for efficiency
+    target_module_list = list(get_target_modules(model, lora_config))
+
+    # Check if any supported layers were found
+    if not target_module_list:
+        raise ValueError(
+            "No supported layers found for LoRA-GA initialization. "
+            "LoRA-GA only supports nn.Linear and Conv1D layers. "
+            "Please ensure your model contains at least one of these layer types in target_modules."
+        )
+
+    # Initialize gradient storage and count for each target module
+    for name, module in target_module_list:
+        module._peft_loraga_grad_count = 0
+
+    # Memory-efficient gradient computation: disable gradients for all parameters first,
+    # then enable only for target module weights
+    original_requires_grad = {}
+    for name, param in model.named_parameters():
+        original_requires_grad[name] = param.requires_grad
+        param.requires_grad = False
+
+    # Enable gradients ONLY for target module weights
+    for name, module in target_module_list:
+        module.weight.requires_grad = True
+
+    # Register backward hooks to count gradient computations
+    hooks = []
+
+    def backward_hook(module, grad_input, grad_output):
+        module._peft_loraga_grad_count += 1
+
+    for name, module in target_module_list:
+        hook = module.register_full_backward_hook(backward_hook)
+        hooks.append(hook)
+
+    # Enable gradient computation and run train_step
+    with torch.enable_grad():
+        train_step()
+
+    # Remove hooks
+    for hook in hooks:
+        hook.remove()
+
+    # Restore original requires_grad state for all parameters
+    for name, param in model.named_parameters():
+        if name in original_requires_grad:
+            param.requires_grad = original_requires_grad[name]
+
+    # Average gradients and clean up temporary fields
+    for name, module in target_module_list:
+        if module._peft_loraga_grad_count > 0:
+            module._peft_loraga_grad = module.weight.grad.detach() / module._peft_loraga_grad_count
+        module.weight.grad = None
+        del module._peft_loraga_grad_count
+
+    # Restore original training state
+    if not was_training:
+        model.eval()
diff --git a/src/peft/tuners/lora/model.py b/src/peft/tuners/lora/model.py
new file mode 100644
index 0000000..b242c6e
--- /dev/null
+++ b/src/peft/tuners/lora/model.py
@@ -0,0 +1,1099 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import math
+import operator
+import re
+import warnings
+from contextlib import contextmanager
+from dataclasses import replace
+from functools import partial, reduce
+from typing import Literal, Optional, Union
+
+import packaging.version
+import torch
+import transformers
+from torch import nn
+
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available, is_transformers_ge_v5_4_0
+from peft.tuners.tuners_utils import (
+    BaseTuner,
+    BaseTunerLayer,
+    find_parameter_name_by_module,
+    get_device_map,
+    replicate_layers,
+)
+from peft.utils import (
+    TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING,
+    AuxiliaryTrainingWrapper,
+    ModulesToSaveWrapper,
+    _freeze_adapter,
+    _get_submodules,
+    get_peft_model_state_dict,
+    get_quantization_config,
+)
+from peft.utils.integrations import TpInfo
+from peft.utils.merge_utils import dare_linear, dare_ties, magnitude_prune, task_arithmetic, ties
+from peft.utils.other import get_pattern_key
+
+from .aqlm import dispatch_aqlm
+from .awq import dispatch_awq
+from .config import LoraConfig
+from .eetq import dispatch_eetq
+from .gptq import dispatch_gptq
+from .hqq import dispatch_hqq
+from .inc import dispatch_inc
+from .layer import Conv2d, LoraLayer, ParamWrapper, dispatch_default
+from .te import dispatch_transformer_engine
+from .torchao import dispatch_torchao
+from .tp_layer import dispatch_megatron
+
+
+def _adapter_names_pre_forward_hook(target, args, kwargs, adapter_names):
+    # pre-forward hook to inject the adapter_names argument when using mixed adapter batches inference
+    kwargs["adapter_names"] = adapter_names
+    return args, kwargs
+
+
+def _alora_offsets_pre_forward_hook(target, args, kwargs, alora_offsets):
+    kwargs["alora_offsets"] = alora_offsets
+    return args, kwargs
+
+
+def _get_encoder(model: nn.Module) -> nn.Module | None:
+    """Check if the model has an encoder and if it has, returns it; otherwise returns None"""
+    if not hasattr(model, "get_encoder"):
+        return None
+
+    encoder = model.get_encoder()
+    # https://github.com/huggingface/transformers/pull/42156
+    # new logic in transformers v5: all PretrainedModels return a model here, but it is self if there is no encoder
+    if encoder is model:
+        return None
+    return encoder
+
+
+class LoraModel(BaseTuner):
+    """
+    Creates Low Rank Adapter (LoRA) model from a pretrained transformers model.
+
+    The method is described in detail in https://huggingface.co/papers/2106.09685.
+
+    Args:
+        model ([`torch.nn.Module`]): The model to be adapted.
+        config ([`LoraConfig`]): The configuration of the Lora model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            Create empty adapter weights on meta device. Useful to speed up the loading process.
+
+    Returns:
+        `torch.nn.Module`: The Lora model.
+
+    Example:
+
+        ```py
+        >>> from transformers import AutoModelForSeq2SeqLM
+        >>> from peft import LoraModel, LoraConfig
+
+        >>> config = LoraConfig(
+        ...     task_type="SEQ_2_SEQ_LM",
+        ...     r=8,
+        ...     lora_alpha=32,
+        ...     target_modules=["q", "v"],
+        ...     lora_dropout=0.01,
+        ... )
+
+        >>> model = AutoModelForSeq2SeqLM.from_pretrained("t5-base")
+        >>> lora_model = LoraModel(model, config, "default")
+        ```
+
+        ```py
+        >>> import torch
+        >>> import transformers
+        >>> from peft import LoraConfig, PeftModel, get_peft_model, prepare_model_for_kbit_training
+
+        >>> rank = ...
+        >>> target_modules = ["q_proj", "k_proj", "v_proj", "out_proj", "fc_in", "fc_out", "wte"]
+        >>> config = LoraConfig(
+        ...     r=4, lora_alpha=16, target_modules=target_modules, lora_dropout=0.1, bias="none", task_type="CAUSAL_LM"
+        ... )
+        >>> quantization_config = transformers.BitsAndBytesConfig(load_in_8bit=True)
+
+        >>> tokenizer = transformers.AutoTokenizer.from_pretrained(
+        ...     "kakaobrain/kogpt",
+        ...     revision="KoGPT6B-ryan1.5b-float16",  # or float32 version: revision=KoGPT6B-ryan1.5b
+        ...     bos_token="[BOS]",
+        ...     eos_token="[EOS]",
+        ...     unk_token="[UNK]",
+        ...     pad_token="[PAD]",
+        ...     mask_token="[MASK]",
+        ... )
+        >>> model = transformers.GPTJForCausalLM.from_pretrained(
+        ...     "kakaobrain/kogpt",
+        ...     revision="KoGPT6B-ryan1.5b-float16",  # or float32 version: revision=KoGPT6B-ryan1.5b
+        ...     pad_token_id=tokenizer.eos_token_id,
+        ...     use_cache=False,
+        ...     device_map={"": rank},
+        ...     torch_dtype=torch.float16,
+        ...     quantization_config=quantization_config,
+        ... )
+        >>> model = prepare_model_for_kbit_training(model)
+        >>> lora_model = get_peft_model(model, config)
+        ```
+
+    **Attributes**:
+        - **model** ([`~transformers.PreTrainedModel`]) -- The model to be adapted.
+        - **peft_config** ([`LoraConfig`]): The configuration of the Lora model.
+    """
+
+    prefix: str = "lora_"
+    tuner_layer_cls = LoraLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING
+
+    def _prepare_model(self, peft_config: LoraConfig, model: nn.Module):
+        r"""
+        A private method to modify the model structure before adapter is applied.
+
+        Args:
+            peft_config (`PeftConfig`):
+                The prepared adapter config.
+            model (`nn.Module`):
+                The model that is going to be adapted.
+        """
+        if peft_config.layer_replication:
+            replicate_layers(model, peft_config.layer_replication)
+
+    def _check_new_adapter_config(self, config: LoraConfig) -> None:
+        super()._check_new_adapter_config(config)
+
+        # Multiple adapters that use `target_parameters` are supported, but they must all target the same set of
+        # parameters. The reason is that the targeted parameters are wrapped with (possibly nested) lora.ParamWrapper
+        # layers, and which parameter a LoRA weight belongs to is encoded by its position in that nesting. If different
+        # adapters targeted different parameters, the nesting (and thus the state_dict keys) would differ between
+        # adapters, which is not supported.
+        target_parameters = getattr(config, "target_parameters", None)
+        if not target_parameters:
+            return
+
+        target_parameters = set(target_parameters)  # set is okay as we don't support str for this arg
+        for adapter_name, other_conf in self.peft_config.items():
+            if other_conf is config:
+                continue
+            other_target_parameters = getattr(other_conf, "target_parameters", None)
+            if other_target_parameters and (set(other_target_parameters) != target_parameters):
+                raise ValueError(
+                    "When using multiple adapters with `target_parameters`, all adapters must target the same set of "
+                    f"parameters, but got {sorted(target_parameters)} for the new adapter and "
+                    f"{sorted(other_target_parameters)} for adapter '{adapter_name}'."
+                )
+
+    def _create_and_replace(
+        self,
+        lora_config,
+        adapter_name,
+        target,
+        target_name,
+        parent,
+        current_key,
+        *,
+        parameter_name: Optional[str] = None,
+    ) -> None:
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+
+        # Regexp matching - Find key which matches current target_name in patterns provided
+        r_key = get_pattern_key(lora_config.rank_pattern.keys(), current_key)
+        alpha_key = get_pattern_key(lora_config.alpha_pattern.keys(), current_key)
+        r = lora_config.rank_pattern.get(r_key, lora_config.r)
+        alpha = lora_config.alpha_pattern.get(alpha_key, lora_config.lora_alpha)
+
+        # Checks if the target is marked as a tied layer
+        # If true, we add the reference to lora adapters of embedding layer in `tied_adapter`
+        is_tied = target_name in (getattr(lora_config, "target_modules_to_tie", []) or [])
+        tied_adapter = {}
+        if is_tied:
+            tied_module = self.model.get_input_embeddings()
+            emb_A = tied_module.lora_embedding_A[adapter_name]
+            emb_B = tied_module.lora_embedding_B[adapter_name]
+
+            tied_adapter = {"lora_A": emb_B.t(), "lora_B": emb_A.t()}
+
+        kwargs = {
+            "r": r,
+            "lora_alpha": alpha,
+            "target_name": current_key,
+            "loaded_in_8bit": getattr(self.model, "is_loaded_in_8bit", False),
+            "loaded_in_4bit": getattr(self.model, "is_loaded_in_4bit", False),
+            "ephemeral_gpu_offload": lora_config.runtime_config.ephemeral_gpu_offload,
+            "parameter_name": parameter_name,
+            "tied_adapter": tied_adapter,
+        }
+
+        # for torchao merging, we need the get_apply_tensor_subclass from the quantization config
+        try:
+            kwargs["get_apply_tensor_subclass"] = operator.attrgetter(
+                "hf_quantizer.quantization_config.get_apply_tensor_subclass"
+            )(self.model)
+        except AttributeError:
+            pass
+
+        quant_methods = ["gptq", "aqlm", "awq"]
+        for quant_method in quant_methods:
+            quantization_config = get_quantization_config(self.model, method=quant_method)
+            if quantization_config is not None:
+                kwargs[f"{quant_method}_quantization_config"] = quantization_config
+
+        # note: AdaLoraLayer is a subclass of LoraLayer, we need to exclude it
+        from peft.tuners.adalora import AdaLoraLayer
+
+        # if the target is a ParamWrapper, we nest it to allow targeting multiple nn.Parameter on the same module
+        wrap_target_param = isinstance(target, ParamWrapper) and (adapter_name in target.lora_A)
+        if isinstance(target, LoraLayer) and not isinstance(target, AdaLoraLayer) and not wrap_target_param:
+            target.update_layer(
+                adapter_name,
+                r,
+                lora_alpha=alpha,
+                target_name=current_key,
+                config=lora_config,
+            )
+
+            base_layer = target.get_base_layer()
+            lora_module = target
+        else:
+            if isinstance(target, ParamWrapper) and (parameter_name == target.parameter_name):
+                raise ValueError(
+                    "Trying to target the same nn.Parameter twice, this should not happen. Please open an issue on the "
+                    "PEFT repo: https://github.com/huggingface/peft/issues"
+                )
+            device_map = get_device_map(self.model)
+            new_module = self._create_new_module(lora_config, adapter_name, target, device_map=device_map, **kwargs)
+            if adapter_name not in self.active_adapters:
+                # adding an additional adapter: it is not automatically trainable
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+            base_layer = target
+            lora_module = new_module
+
+        tp_plan = getattr(base_layer, "_hf_tp_plan", None)
+        device_mesh = getattr(base_layer, "_hf_device_mesh", None)
+
+        # If the module has a tp_plan, we add hooks to the LoRA layers to make sure they respect the plan
+        if tp_plan is not None:
+            if not is_transformers_ge_v5_4_0:
+                raise RuntimeError(
+                    "The base model is tensor-parallel sharded but the installed version of Transformers does not "
+                    "support LoRA with Tensor Parallelism. Please upgrade to transformers >= 5.4.0."
+                )
+            from transformers.integrations.tensor_parallel import (
+                add_tensor_parallel_hooks_to_module,
+            )
+
+            _SUPPORTED_TP_PLANS = ("colwise", "rowwise", "embedding_rowwise")
+
+            if tp_plan not in _SUPPORTED_TP_PLANS:
+                warnings.warn(
+                    f'TP plan "{tp_plan}" on the base layer is not supported for LoRA. '
+                    "LoRA adapters will be created without tensor parallel hooks."
+                )
+            else:
+                tp_plan_keys = []
+                tp_plans = []
+                generic_key = re.sub(r"\d+", "*", current_key)
+                if tp_plan in ["colwise", "rowwise"]:
+                    if tp_plan == "colwise":
+                        tp_plan_keys.append(f"{generic_key}.lora_B.{adapter_name}.weight")
+                        tp_module = lora_module.lora_B[adapter_name]
+                        tp_layer_name = (f"{current_key}.lora_B.{adapter_name}",)
+                    else:  # rowwise
+                        tp_plan_keys.append(f"{generic_key}.lora_A.{adapter_name}.weight")
+                        tp_module = lora_module.lora_A[adapter_name]
+                        tp_layer_name = (f"{current_key}.lora_A.{adapter_name}",)
+                    tp_plans.append(tp_plan)
+                    add_tensor_parallel_hooks_to_module(
+                        self.model,
+                        tp_module,
+                        tp_plan,
+                        tp_layer_name,
+                        device_mesh,
+                    )
+                else:  # embedding_rowwise
+                    # TP hooks are  handled in the `_embed` method in lora/layer.py where they are explicitly called.
+                    # Here we simply register the TP plans.
+                    tp_plan_keys.append(f"{generic_key}.base_layer.weight")
+                    tp_plan_keys.append(f"{generic_key}.lora_embedding_A.{adapter_name}")
+                    tp_plans.append(tp_plan)
+                    # Because lora_embedding_A is transposed compared to nn.Embedding, we set the TP plan
+                    # to embedding_colwise so that the gathering happens on the correct dimension at save time.
+                    tp_plans.append("embedding_colwise")
+
+                lora_module._tp_info = TpInfo(
+                    tp_plan=dict(zip(tp_plan_keys, tp_plans)),
+                    device_mesh=device_mesh,
+                    tp_size=self.model._tp_size,
+                )
+
+    def _replace_module(self, parent, child_name, new_module, child):
+        # override in LoraModel to handle quantized weights properly
+
+        setattr(parent, child_name, new_module)
+        # It's not necessary to set requires_grad here, as that is handled by
+        # _mark_only_adapters_as_trainable
+
+        # child layer wraps the original module, unpack it
+        if hasattr(child, "base_layer"):
+            child = child.base_layer
+
+        meta = torch.device("meta")
+        # dispatch to correct device
+        for name, module in new_module.named_modules():
+            if (self.prefix in name) or ("ranknum" in name):
+                if hasattr(child, "qweight"):
+                    weight = child.qweight
+                elif hasattr(child, "W_q"):
+                    weight = child.W_q
+                elif hasattr(child, "weight"):
+                    weight = child.weight
+                elif getattr(child, "in_proj_weight", None) is not None:  # MHA
+                    weight = child.in_proj_weight
+                else:
+                    weight = next(child.parameters())
+                if not any(p.device == meta for p in module.parameters()):
+                    module.to(weight.device)
+
+    @staticmethod
+    def _create_new_module(lora_config, adapter_name, target, **kwargs):
+        # Collect dispatcher functions to decide what backend to use for the replaced LoRA layer. The order matters,
+        # because the first match is always used. Therefore, the default layers should be checked last.
+        dispatchers = []
+
+        if lora_config._custom_modules:
+            # Experimental custom LoRA module support. Allows users to pass a custom mapping for unsupported layer
+            # types by implementing their own LoRA layers.
+            def dynamic_dispatch_func(target, adapter_name, config, **kwargs):
+                new_module = None
+
+                if isinstance(target, BaseTunerLayer):
+                    target_base_layer = target.get_base_layer()
+                else:
+                    target_base_layer = target
+
+                for key, custom_cls in config._custom_modules.items():
+                    if isinstance(target_base_layer, key):
+                        new_module = custom_cls(target, adapter_name, config=config, **kwargs)
+                        break
+
+                return new_module
+
+            dispatchers.append(dynamic_dispatch_func)
+
+        # avoid eager bnb import
+        if is_bnb_available():
+            from .bnb import dispatch_bnb_8bit
+
+            dispatchers.append(dispatch_bnb_8bit)
+
+        if is_bnb_4bit_available():
+            from .bnb import dispatch_bnb_4bit
+
+            dispatchers.append(dispatch_bnb_4bit)
+
+        dispatchers.extend(
+            [
+                dispatch_eetq,
+                dispatch_aqlm,
+                dispatch_awq,
+                dispatch_gptq,
+                dispatch_hqq,
+                dispatch_inc,
+                dispatch_torchao,
+                dispatch_megatron,
+                dispatch_transformer_engine,
+                dispatch_default,
+            ]
+        )
+
+        new_module = None
+        for dispatcher in dispatchers:
+            new_module = dispatcher(target, adapter_name, config=lora_config, **kwargs)
+            if new_module is not None:  # first match wins
+                break
+
+        if new_module is None:
+            # no module could be matched
+            raise ValueError(
+                f"Target module {target} is not supported. Currently, only the following modules are supported: "
+                "`torch.nn.Linear`, `torch.nn.Embedding`, `torch.nn.Conv1d`, `torch.nn.Conv2d`, `torch.nn.Conv3d`, "
+                "`transformers.pytorch_utils.Conv1D`, `torch.nn.MultiheadAttention.`."
+            )
+
+        return new_module
+
+    @contextmanager
+    def _enable_peft_forward_hooks(self, *args, **kwargs):
+        # If adapter_names is passed as an argument, we inject it into the forward arguments.
+        adapter_names = kwargs.pop("adapter_names", None)
+        alora_offsets = kwargs.pop("alora_offsets", None)
+
+        if adapter_names is None and alora_offsets is None:
+            # nothing to do
+            yield
+            return
+        hook_handles = []
+
+        if alora_offsets is not None:
+            # TODO: remove once transformers 4.52 is no longer supported. Note that 4.52.0 is yanked, so 4.52.1
+            # is the first 4.52 release.
+            transformers_lt_4_52 = packaging.version.parse(transformers.__version__) < packaging.version.parse(
+                "4.52.1"
+            )
+            if transformers_lt_4_52:
+                raise ValueError("Using aLoRA requires transformers >= 4.52.1.")
+
+            from transformers.modeling_layers import GradientCheckpointingLayer
+
+            for n, layer in self.named_modules():
+                # gradient checkpointing layer are executed concurrently to the 'normal' forward call
+                # (in the backward step the gradient checkpointing layer's forward will be executed again).
+                # this means that when the gradient checkpointing layer is called, the _enable_peft_forward_hooks
+                # context manager is long gone. to be consistent with the normal forward we need to register the pre
+                # hooks for this concurrent forward call as well.
+                #
+                # Note that this will lead to double application of whatever the callbacks do in normal forward.
+                # Make sure that whatever change is done, can be applied more than once without harm (idempotency).
+                if isinstance(layer, GradientCheckpointingLayer) and layer.gradient_checkpointing:
+
+                    def forward_pre_hook(name, module, inputs, **kwargs):
+                        for submodule in module.modules():
+                            if isinstance(submodule, LoraLayer):
+                                handle = submodule.register_forward_pre_hook(
+                                    partial(_alora_offsets_pre_forward_hook, alora_offsets=kwargs["alora_offsets"]),
+                                    with_kwargs=True,
+                                )
+                                module._peft_gradient_checkpointing_forward_hooks.append(handle)
+
+                    def backward_hook(name, module, *grad_output, **kwargs):
+                        while module._peft_gradient_checkpointing_forward_hooks:
+                            module._peft_gradient_checkpointing_forward_hooks.pop().remove()
+
+                    if getattr(layer, "_peft_gradient_checkpointing_forward_hooks", []):
+                        raise ValueError(
+                            "Multiple invocations of PEFT forward hooks before .backward() with enabled gradient "
+                            "checkpointing. Disable gradient checkpointing or only call forward once per backward."
+                        )
+                    layer._peft_gradient_checkpointing_forward_hooks = []
+                    handle = layer.register_forward_pre_hook(partial(forward_pre_hook, n, alora_offsets=alora_offsets))
+                    layer._peft_gradient_checkpointing_forward_hooks.append(handle)
+                    handle = layer.register_full_backward_hook(partial(backward_hook, n))
+                    layer._peft_gradient_checkpointing_forward_hooks.append(handle)
+                if isinstance(layer, LoraLayer):
+                    pre_forward = partial(_alora_offsets_pre_forward_hook, alora_offsets=alora_offsets)
+                    handle = layer.register_forward_pre_hook(pre_forward, with_kwargs=True)
+                    hook_handles.append(handle)
+        num_beams = kwargs.get("num_beams", None)
+        uses_beam_search = isinstance(num_beams, int) and (num_beams > 1)
+        if uses_beam_search:
+            if alora_offsets is not None:
+                raise ValueError("Beam search not yet supported for aLoRA.")
+        if adapter_names is not None:
+            if self.training:
+                raise ValueError("Cannot pass `adapter_names` when the model is in training mode.")
+
+            # Check that users only passed actually existing adapters.
+            # Note: We cannot do this on the layer level, as each individual layer may not have each adapter. Still, we want
+            # to check that there is at least one layer with the given name, or else something like typos can easily slip.
+            expected_adapters = set()
+            for layer in self.modules():
+                if isinstance(layer, LoraLayer):
+                    expected_adapters |= layer.lora_A.keys()
+                    expected_adapters |= layer.lora_embedding_A.keys()
+            unique_adapters = {name for name in adapter_names if name != "__base__"}
+            unexpected_adapters = unique_adapters - expected_adapters
+            if unexpected_adapters:
+                raise ValueError(
+                    f"Trying to infer with non-existing adapter(s): {', '.join(sorted(unexpected_adapters))}"
+                )
+
+            # deal with beam search
+            original_adapter_names = adapter_names[:]
+            if uses_beam_search:
+                if not isinstance(adapter_names, (list, tuple)):
+                    raise TypeError(f"Got adapter names of type {type(adapter_names)}, expected a list of str.")
+                # When there is beam search, the inputs are repeated n times, thus we repeat each adapter name n times and
+                # then flatten the nested list. For encoder-decoder models, this extended list should not be applied to the
+                # encoder part. Further below, the original argument is thus restored for the encoder.
+                adapter_names = [n for n in adapter_names for _ in range(kwargs["num_beams"])]
+
+            for module in self.modules():
+                if isinstance(module, (LoraLayer, AuxiliaryTrainingWrapper)):
+                    pre_forward = partial(_adapter_names_pre_forward_hook, adapter_names=adapter_names)
+                    handle = module.register_forward_pre_hook(pre_forward, with_kwargs=True)
+                    hook_handles.append(handle)
+
+            encoder = _get_encoder(self.model)
+            if uses_beam_search and (encoder is not None):
+                # For encoder-decoder models, even when applying beam search, the encoder part of the model should not use
+                # the extended adapter_names. This is because the encoder still uses the original, non-extended samples.
+                for module in encoder.modules():
+                    if isinstance(module, (LoraLayer, AuxiliaryTrainingWrapper)):
+                        # Add another hook to overwrite the kwargs with the original adapter names -- this is easier than
+                        # trying to exclude the encoder.
+                        pre_forward = partial(_adapter_names_pre_forward_hook, adapter_names=original_adapter_names)
+                        handle = module.register_forward_pre_hook(pre_forward, with_kwargs=True)
+                        hook_handles.append(handle)
+
+        yield
+
+        for handle in hook_handles:
+            handle.remove()
+
+    def _check_merge_allowed(self):
+        """Verify that the configuration supports merging.
+
+        Currently gptq quantization and replicated layers do not support merging.
+        """
+        super()._check_merge_allowed()
+        if getattr(self.model, "quantization_method", None) == "gptq":
+            raise ValueError("Cannot merge LORA layers when the model is gptq quantized")
+        if self.peft_config.get("layer_replication"):
+            raise ValueError("Cannot merge LORA layers when base model layers are replicated")
+
+    def _prepare_adapter_config(self, peft_config, model_config):
+        if peft_config.target_modules is None:
+            target_modules = self.target_module_mapping.get(model_config["model_type"])
+            if target_modules is not None:
+                if isinstance(target_modules, str):
+                    peft_config.target_modules = target_modules
+                else:
+                    peft_config.target_modules = set(target_modules)
+            elif not peft_config.target_parameters:
+                raise ValueError("Please specify `target_modules` or `target_parameters`in `peft_config`")
+        return peft_config
+
+    def _check_add_weighted_adapter(
+        self, adapters: list[str], combination_type: str, svd_rank: int | None
+    ) -> tuple[str, int, str]:
+        """
+        Helper function to check if the arguments to add_weighted_adapter are valid and compatible with the underlying
+        model.
+        """
+        for adapter in adapters:
+            if adapter not in list(self.peft_config.keys()):
+                raise ValueError(f"Adapter {adapter} does not exist")
+
+        for adapter in adapters:
+            if self.peft_config[adapter].target_parameters:
+                raise ValueError(
+                    f"add_weighted_adapter does not support targeting nn.Parameter (problematic adapter '{adapter}')"
+                )
+
+        # If more than one of the adapters targets the same module with modules_to_save, raise an error, as these
+        # modules cannot be merged. First, find the ModulesToSaveWrapper instances in the model, then check if they
+        # have modules for the adapters to be merged.
+        modules_to_save_wrappers = [module for module in self.modules() if isinstance(module, ModulesToSaveWrapper)]
+        problematic_wrappers = [
+            wrapper
+            for wrapper in modules_to_save_wrappers
+            if sum(adapter in wrapper.modules_to_save for adapter in adapters) > 1
+        ]
+        if problematic_wrappers:
+            raise ValueError(
+                "Cannot add weighted adapters if they target the same module with modules_to_save, but found "
+                f"{len(problematic_wrappers)} such instance(s)."
+            )
+
+        # if there is only one adapter, we can only use linear merging
+        combination_type = "linear" if len(adapters) == 1 else combination_type
+
+        adapters_ranks: list[int] = [
+            # When allocating tensors for the new adapter, we need the maximum possible rank to not overflow
+            config.r if not config.rank_pattern else max(config.r, *config.rank_pattern.values())
+            for config in (self.peft_config[adapter] for adapter in adapters)
+        ]
+
+        if combination_type in ("linear", "ties", "dare_ties", "dare_linear", "magnitude_prune"):
+            # all adapters ranks should be same, new rank is just this value
+            if len(set(adapters_ranks)) != 1:
+                raise ValueError(
+                    "All adapters must have the same r value when using combination_type linear, ties, dare_ties or "
+                    "dare_linear."
+                )
+            new_rank = adapters_ranks[0]
+        elif combination_type == "cat":
+            # adapters ranks may be different, new rank is sum of all ranks
+            # be careful, because output adapter rank may be really big if mixing a lot of adapters
+            new_rank = sum(adapters_ranks)
+        elif combination_type.endswith("svd"):
+            # new rank is the max of all ranks of the adapters if not provided
+            new_rank = svd_rank or max(adapters_ranks)
+        else:
+            raise ValueError(f"Invalid combination_type: {combination_type}")
+
+        target_module_types = [type(self.peft_config[adapter].target_modules) for adapter in adapters]
+        if not target_module_types:
+            raise ValueError(f"Found no adapter matching the names in {adapters}")
+        if len(set(target_module_types)) > 1:
+            raise ValueError(
+                "all adapter configs should follow the same target modules type. "
+                "Combining adapters with `target_modules` type being a mix of list/set and string is not supported."
+            )
+
+        if target_module_types[0] is str:
+            new_target_modules = "|".join(f"({self.peft_config[adapter].target_modules})" for adapter in adapters)
+        elif target_module_types[0] is set:
+            new_target_modules = reduce(
+                operator.or_, (self.peft_config[adapter].target_modules for adapter in adapters)
+            )
+        else:
+            raise TypeError(f"Invalid type {target_module_types[0]} found in target_modules")
+
+        return combination_type, new_rank, new_target_modules
+
+    def add_weighted_adapter(
+        self,
+        adapters: list[str],
+        weights: list[float],
+        adapter_name: str,
+        combination_type: str = "svd",
+        svd_rank: int | None = None,
+        svd_clamp: int | None = None,
+        svd_full_matrices: bool = True,
+        svd_driver: str | None = None,
+        density: float | None = None,
+        majority_sign_method: Literal["total", "frequency"] = "total",
+    ) -> None:
+        """
+        This method adds a new adapter by merging the given adapters with the given weights.
+
+        When using the `cat` combination_type you should be aware that rank of the resulting adapter will be equal to
+        the sum of all adapters ranks. So it's possible that the mixed adapter may become too big and result in OOM
+        errors.
+
+        Args:
+            adapters (`list`):
+                List of adapter names to be merged.
+            weights (`list`):
+                List of weights for each adapter. Weights can be positive or negative, allowing for both addition and
+                subtraction of adapter effects.
+            adapter_name (`str`):
+                Name of the new adapter.
+            combination_type (`str`):
+                The merging type can be one of [`svd`, `linear`, `cat`, `ties`, `ties_svd`, `dare_ties`, `dare_linear`,
+                `dare_ties_svd`, `dare_linear_svd`, `magnitude_prune`, `magnitude_prune_svd`]. When using the `cat`
+                combination_type, the rank of the resulting adapter is equal to the sum of all adapters ranks (the
+                mixed adapter may be too big and result in OOM errors).
+            svd_rank (`int`, *optional*):
+                Rank of output adapter for svd. If None provided, will use max rank of merging adapters.
+            svd_clamp (`float`, *optional*):
+                A quantile threshold for clamping SVD decomposition output. If None is provided, do not perform
+                clamping. Defaults to None.
+            svd_full_matrices (`bool`, *optional*):
+                Controls whether to compute the full or reduced SVD, and consequently, the shape of the returned
+                tensors U and Vh. Defaults to True.
+            svd_driver (`str`, *optional*):
+                Name of the cuSOLVER method to be used. This keyword argument only works when merging on CUDA. Can be
+                one of [None, `gesvd`, `gesvdj`, `gesvda`]. For more info please refer to `torch.linalg.svd`
+                documentation. Defaults to None.
+            density (`float`, *optional*):
+                Value between 0 and 1. 0 means all values are pruned and 1 means no values are pruned. Should be used
+                with [`ties`, `ties_svd`, `dare_ties`, `dare_linear`, `dare_ties_svd`, `dare_linear_svd`,
+                `magnintude_prune`, `magnitude_prune_svd`]
+            majority_sign_method (`str`):
+                The method, should be one of ["total", "frequency"], to use to get the magnitude of the sign values.
+                Should be used with [`ties`, `ties_svd`, `dare_ties`, `dare_ties_svd`]
+        """
+
+        if adapter_name in list(self.peft_config.keys()):
+            return
+
+        combination_type, new_rank, new_target_modules = self._check_add_weighted_adapter(
+            adapters=adapters,
+            combination_type=combination_type,
+            svd_rank=svd_rank,
+        )
+
+        self.peft_config[adapter_name] = replace(
+            self.peft_config[adapters[0]],
+            r=new_rank,
+            lora_alpha=new_rank,
+            target_modules=new_target_modules,
+            alpha_pattern={},
+            rank_pattern={},
+        )
+        self.inject_adapter(self.model, adapter_name)
+
+        # Do we really need that?
+        _freeze_adapter(self.model, adapter_name)
+
+        key_list = [key for key, _ in self.model.named_modules() if self.prefix not in key]
+        for key in key_list:
+            _, target, _ = _get_submodules(self.model, key)
+            if isinstance(target, LoraLayer):
+                if adapter_name in target.lora_A:
+                    target_lora_A = target.lora_A[adapter_name].weight
+                    target_lora_B = target.lora_B[adapter_name].weight
+                elif adapter_name in target.lora_embedding_A:
+                    target_lora_A = target.lora_embedding_A[adapter_name]
+                    target_lora_B = target.lora_embedding_B[adapter_name]
+                else:
+                    continue
+
+                target_lora_A.data = target_lora_A.data * 0.0
+                target_lora_B.data = target_lora_B.data * 0.0
+                if combination_type == "cat":
+                    loras_A, loras_B = [], []
+                    for adapter, weight in zip(adapters, weights):
+                        if adapter in target.lora_A:
+                            current_adapter_lora_A = target.lora_A[adapter].weight
+                            current_adapter_lora_B = target.lora_B[adapter].weight
+                        elif adapter in target.lora_embedding_A:
+                            current_adapter_lora_A = target.lora_embedding_A[adapter]
+                            current_adapter_lora_B = target.lora_embedding_B[adapter]
+                        else:
+                            continue
+                        loras_A.append(current_adapter_lora_A.data * weight * target.scaling[adapter])
+                        loras_B.append(current_adapter_lora_B.data)
+
+                    if len(loras_A) == 0:
+                        raise ValueError("No matching LoRAs found. Please raise an issue on GitHub.")
+                    loras_A = torch.cat(loras_A, dim=0)
+                    loras_B = torch.cat(loras_B, dim=1)
+                    target_lora_A.data[: loras_A.shape[0], :] = loras_A
+                    target_lora_B.data[:, : loras_B.shape[1]] = loras_B
+                elif combination_type in [
+                    "svd",
+                    "ties_svd",
+                    "dare_linear_svd",
+                    "dare_ties_svd",
+                    "magnitude_prune_svd",
+                ]:
+                    target_lora_A.data, target_lora_B.data = self._svd_generalized_task_arithmetic_weighted_adapter(
+                        combination_type,
+                        adapters,
+                        weights,
+                        new_rank,
+                        target,
+                        target_lora_A,
+                        target_lora_B,
+                        density,
+                        majority_sign_method,
+                        svd_clamp,
+                        full_matrices=svd_full_matrices,
+                        driver=svd_driver,
+                    )
+                elif combination_type in ["linear", "ties", "dare_linear", "dare_ties", "magnitude_prune"]:
+                    target_lora_A.data, target_lora_B.data = self._generalized_task_arithmetic_weighted_adapter(
+                        combination_type, adapters, weights, target, density, majority_sign_method
+                    )
+
+    def _svd_generalized_task_arithmetic_weighted_adapter(
+        self,
+        combination_type,
+        adapters,
+        weights,
+        new_rank,
+        target,
+        target_lora_A,
+        target_lora_B,
+        density,
+        majority_sign_method,
+        clamp=None,
+        full_matrices=True,
+        driver=None,
+    ):
+        valid_adapters = []
+        valid_weights = []
+        is_embedding = any(adapter in target.lora_embedding_A for adapter in adapters)
+        for adapter, weight in zip(adapters, weights):
+            if adapter in target.lora_A or adapter in target.lora_embedding_A:
+                valid_adapters.append(adapter)
+                valid_weights.append(weight * target.scaling[adapter])
+
+        # if no valid adapter, nothing to do
+        if len(valid_adapters) == 0:
+            raise ValueError("No matching LoRAs found. Please raise an issue on Github.")
+        delta_weight = [target.get_delta_weight(adapter) for adapter in valid_adapters]
+        valid_weights = torch.tensor(valid_weights).to(delta_weight[0].device)
+        if combination_type == "svd":
+            delta_weight = task_arithmetic(delta_weight, valid_weights)
+        elif combination_type == "ties_svd":
+            delta_weight = ties(delta_weight, valid_weights, density, majority_sign_method)
+        elif combination_type == "dare_linear_svd":
+            delta_weight = dare_linear(delta_weight, valid_weights, density)
+        elif combination_type == "dare_ties_svd":
+            delta_weight = dare_ties(delta_weight, valid_weights, density, majority_sign_method)
+        elif combination_type == "magnitude_prune_svd":
+            delta_weight = magnitude_prune(delta_weight, valid_weights, density)
+        else:
+            raise ValueError(f"Invalid value passed to combination type: {combination_type}")
+
+        conv2d = isinstance(target, Conv2d)
+        if conv2d:
+            conv2d_1x1 = target.weight.size()[2:4] == (1, 1)
+            if not conv2d_1x1:
+                delta_weight = delta_weight.flatten(start_dim=1)
+            else:
+                delta_weight = delta_weight.squeeze()
+        if (hasattr(target, "fan_in_fan_out") and target.fan_in_fan_out) or is_embedding:
+            delta_weight = delta_weight.T
+
+        # based on https://github.com/kohya-ss/sd-scripts/blob/main/networks/svd_merge_lora.py#L114-L131
+        U, S, Vh = torch.linalg.svd(delta_weight, full_matrices=full_matrices, driver=driver)
+        U = U[:, :new_rank]
+        S = S[:new_rank]
+        U = U @ torch.diag(S)
+        Vh = Vh[:new_rank, :]
+        if clamp is not None:
+            dist = torch.cat([U.flatten(), Vh.flatten()])
+            hi_val = torch.quantile(dist, clamp)
+            low_val = -hi_val
+            U = U.clamp(low_val, hi_val)
+            Vh = Vh.clamp(low_val, hi_val)
+        if conv2d:
+            U = U.reshape(target_lora_B.data.shape)
+            Vh = Vh.reshape(target_lora_A.data.shape)
+        return Vh, U
+
+    def _generalized_task_arithmetic_weighted_adapter(
+        self,
+        combination_type,
+        adapters,
+        weights,
+        target,
+        density,
+        majority_sign_method,
+    ):
+        # account weights for LoRA A and B layers.
+        valid_weights_A = []
+        valid_weights_B = []
+        lora_A_deltas = []
+        lora_B_deltas = []
+        for adapter, weight in zip(adapters, weights):
+            if adapter in target.lora_A:
+                current_adapter_lora_A = target.lora_A[adapter].weight
+                current_adapter_lora_B = target.lora_B[adapter].weight
+            elif adapter in target.lora_embedding_A:
+                current_adapter_lora_A = target.lora_embedding_A[adapter]
+                current_adapter_lora_B = target.lora_embedding_B[adapter]
+            else:
+                continue
+            # Support negative weights: take absolute value for sqrt, then apply sign
+            weight_with_scaling = weight * target.scaling[adapter]
+            sign = 1 if weight_with_scaling >= 0 else -1
+            # apply sign only on one side of the weights, otherwise negative signs negate
+            valid_weights_A.append(math.sqrt(abs(weight_with_scaling)) * sign)
+            valid_weights_B.append(math.sqrt(abs(weight_with_scaling)))
+            lora_A_deltas.append(current_adapter_lora_A.data)
+            lora_B_deltas.append(current_adapter_lora_B.data)
+        valid_weights_A = torch.tensor(valid_weights_A).to(lora_A_deltas[0].device)
+        valid_weights_B = torch.tensor(valid_weights_B).to(lora_B_deltas[0].device)
+        valid_weights = [valid_weights_A, valid_weights_B]
+        lora_deltas = [lora_A_deltas, lora_B_deltas]
+        dtype = lora_A_deltas[0].dtype
+        for i, task_tensors in enumerate(lora_deltas):
+            if combination_type == "linear":
+                lora_deltas[i] = task_arithmetic(task_tensors, valid_weights[i])
+            elif combination_type == "ties":
+                lora_deltas[i] = ties(task_tensors, valid_weights[i], density, majority_sign_method)
+            elif combination_type == "dare_linear":
+                lora_deltas[i] = dare_linear(task_tensors, valid_weights[i], density)
+            elif combination_type == "dare_ties":
+                lora_deltas[i] = dare_ties(task_tensors, valid_weights[i], density, majority_sign_method)
+            elif combination_type == "magnitude_prune":
+                lora_deltas[i] = magnitude_prune(task_tensors, valid_weights[i], density)
+            else:
+                raise ValueError("Invalid combination type")
+        lora_deltas = [delta.to(dtype) for delta in lora_deltas]
+        return lora_deltas
+
+    def subtract_mutated_init(self, output_state_dict: dict[str, torch.Tensor], adapter_name: str, kwargs=None):
+        r"""
+        This function can calculate the updates of PiSSA/CorDA/OLoRA by comparing the parameters of the
+        PiSSA/CorDA/OLoRA adapter in `output_state_dict` with the initial values of PiSSA/CorDA/OLoRA in
+        `adapter_name`, thus converting PiSSA/CorDA/OLoRA to LoRA.
+
+        Methods like PiSSA remove a portion of the model base weights for training and therefore are not easily
+        swapped. But if you know both the initial pre-training and the post-training weights, you can compute the
+        \Delta W and use that as a LoRA adapter.
+
+        Compute steps:
+
+        - $W = W_{res} + A_0 B_0$ (PiSSA init)
+        - $W + \Delta W = W_{res} + A B$ (PiSSA after training)
+        - $\Delta W = W_{res} + AB - W = W_{res} + AB - W_{res} - A_0 B_0$ (Deriving dW for LoRA)
+        - $\Delta W = AB - A_0 B_0$
+        """
+        for name, param in self.model.named_parameters():
+            if (
+                param.data.dtype != torch.float32
+                and param.data.dtype != torch.float16
+                and param.data.dtype != torch.bfloat16
+            ) and adapter_name.startswith("pissa"):
+                warnings.warn(
+                    r"Note that Quant(W_res) + AB != Quant(W) + \Delta(AB); "
+                    "the converted LoRA, when combined with W or Quant(W), may introduce a certain gap in the fine-tuned model. "
+                    "Therefore, we recommend directly using the Quant(W_res) in conjunction with the PiSSA adapter. "
+                )
+        mutated_init_state_dict = get_peft_model_state_dict(
+            self,
+            state_dict=kwargs.get("state_dict", None),
+            adapter_name=adapter_name,
+        )
+        tensors_lora = {}
+        for name in output_state_dict.keys():
+            ## W = W^{res} + A_0 \times B_0,
+            ## W + \Delta W = W^{res} + A \times B,
+            ## \Delta W = A \times B - A_0 \times B_0 = [A | A_0] \times [B | -B_0]^T = A'B'.
+            if "lora_A" in name:
+                tensors_lora[name] = torch.cat(
+                    [output_state_dict[name], mutated_init_state_dict[".".join(name.split(".")[1:])]], dim=0
+                )
+            elif "lora_B" in name:
+                tensors_lora[name] = torch.cat(
+                    [output_state_dict[name], -mutated_init_state_dict[".".join(name.split(".")[1:])]], dim=1
+                )
+
+        return tensors_lora
+
+    def _get_monteclora_loss(self, adapter_names: Optional[Union[str, list[str]]] = None) -> torch.Tensor | float:
+        """
+        Compute the MonteCLoRA variational regularization loss.
+
+        Iterates over all `LoraLayer` modules in the model and, for each layer, collects the KL-divergence and entropy
+        components from the `MontecloraSampler`s that correspond to the requested adapters. The aggregated loss is
+        normalized by the number of contributing samplers. Returns `0.0` if no matching MonteCLoRA samplers are present
+        (e.g. MonteCLoRA is not used, or none of the requested adapters use MonteCLoRA).
+
+        Only samplers belonging to `adapter_names` are considered. This matters when multiple LoRA adapters are
+        attached to the model but only a subset is active: the regularization loss is then computed only for those
+        adapters. By default (`adapter_names=None`) the model's currently active adapters are used.
+
+        Typical usage during training (after computing the task loss):
+
+        ```py
+        task_loss = ...  # standard loss from the model
+        monteclora_loss = model._get_monteclora_loss()
+        total_loss = task_loss + monteclora_loss
+        ```
+
+        Args:
+            adapter_names (`str` or `list[str]`, *optional*):
+                Name(s) of the adapter(s) to include in the loss computation. If `None` (the default), the model's
+                currently active adapters (`self.active_adapters`) are used.
+
+        Returns:
+            The normalized variational loss as a tensor (or `0.0` if no matching MonteCLoRA samplers are present).
+        """
+        if adapter_names is None:
+            adapter_names = self.active_adapters
+        elif isinstance(adapter_names, str):
+            adapter_names = [adapter_names]
+
+        var_loss_sum: torch.Tensor | float = 0.0
+        num_monte_layers = 0
+        for module in self.modules():
+            if not isinstance(module, LoraLayer):
+                continue
+            samplers = getattr(module, "lora_monteclora_sampler", None)
+            if samplers is None:
+                continue
+            for adapter_name in adapter_names:
+                if adapter_name not in samplers:
+                    continue
+                kl_loss, entropy_loss = samplers[adapter_name].get_variational_loss()
+                var_loss_sum = var_loss_sum + kl_loss + entropy_loss
+                num_monte_layers += 1
+
+        if num_monte_layers == 0:
+            return 0.0
+        return var_loss_sum / num_monte_layers
+
+    def _add_modules_to_save_to_tie(self, peft_config: LoraConfig, tied_weight_keys: list[str]):
+        """
+        Add embedding layer to `modules_to_save` and remove rest of the tied layers from `module_to_save`. Maintain a
+        separate set for layers to be tied in `peft_config.tied_weights_keys`.
+
+        Args:
+            peft_config (LoraConfig) -- The configuration of the Lora model.
+            tied_weight_keys (list[str]) -- Contains the layers tied to the embedding layer.
+        """
+        tied_weight_keys = set(tied_weight_keys)
+        peft_config.modules_to_tie = tied_weight_keys
+
+        modules_to_save = getattr(peft_config, "modules_to_save", []) or []
+        embed_layer_name = find_parameter_name_by_module(self.model, self.model.get_input_embeddings())
+
+        # the layer may already be included but we assume that adding the same module twice is not a problem
+        if embed_layer_name not in modules_to_save:
+            modules_to_save.append(embed_layer_name)
+
+        # Iterate over `tied_weight_keys` which are
+        # fully qualified keys and remove matching keys from
+        # `modules_to_save`. It will only remove first encounter
+        # in `module_to_save`, which should be safe, because `tied_weight_keys`
+        # is a unique set of keys. These keys are removed because all the
+        # tied keys are handled in a separate flow
+        # outside of the usual `modules_to_save` flow
+        # See: peft.utils.other.set_additional_trainable_modules for details
+        for key in tied_weight_keys:
+            for m in modules_to_save:
+                if re.match(rf"(^|.*\.){m}($|\..*)", key):
+                    modules_to_save.remove(m)
+                    break
+
+        peft_config.modules_to_save = modules_to_save
+
+    def _add_targets_to_tie(self, peft_config: LoraConfig, tied_weight_keys: list[str]):
+        """
+        Add embedding layer to `target_modules` and remove rest of the tied layers from `target_modules`. Maintain a
+        separate set for layers to be tied in `peft_config.target_modules_to_tie`
+
+        Args:
+            peft_config (LoraConfig) -- The configuration of the Lora model.
+            tied_weight_keys (list[str]) -- Contains the layers tied to the embedding layer.
+        """
+        tied_weight_keys = set(tied_weight_keys)
+        peft_config.target_modules_to_tie = tied_weight_keys
+
+        raw_target_modules = getattr(peft_config, "target_modules", None)
+
+        embed_layer_name = find_parameter_name_by_module(self.model, self.model.get_input_embeddings())
+
+        if isinstance(raw_target_modules, str):
+            # The way weight tying is handled for adapters, we always want to add
+            # lora adapters to the input embedding layer (embed_tokens)
+            # instead of output embedding layer.
+            raw_target_modules = rf"(?:{raw_target_modules}|^{re.escape(embed_layer_name)}$)"
+            peft_config.target_modules = raw_target_modules
+            return
+
+        target_modules = set(raw_target_modules or [])
+        target_modules.add(embed_layer_name)
+
+        # Iterate over `tied_weight_keys` which are
+        # fully qualified keys and remove matching keys from
+        # `target_modules`. It will only remove first encounter
+        # in `target_modules`, which should be safe, because `tied_weight_keys`
+        # is a unique set of keys. These keys are removed because all the
+        # tied keys are handled in a separate flow
+        # outside of the usual `target_modules` flow
+        # See: peft.tuners.tuners_utils.BaseTuner.inject_adapter for details
+        for key in tied_weight_keys:
+            for m in target_modules:
+                if re.match(rf"(^|.*\.){m}($|\..*)", key):
+                    target_modules.remove(m)
+                    break
+
+        peft_config.target_modules = target_modules
diff --git a/src/peft/tuners/lora/monteclora.py b/src/peft/tuners/lora/monteclora.py
new file mode 100644
index 0000000..a0562dd
--- /dev/null
+++ b/src/peft/tuners/lora/monteclora.py
@@ -0,0 +1,238 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+from typing import Optional
+
+import torch
+from torch import nn
+from torch.distributions.wishart import Wishart
+
+from peft.utils import infer_device
+
+
+class BufferedMontecloraSampler:
+    """
+    A buffered sampler for Monteclora that pre-generates samples to improve training efficiency.
+    """
+
+    def __init__(self, model: MontecloraSampler, buffer_size: int = 150, device: Optional[str] = None) -> None:
+        self.model = model
+        self.device = device if device is not None else infer_device()
+        self.buffer_size = buffer_size
+        self.buffer: list[dict[str, torch.Tensor]] = []
+        self.index = 0
+
+        # Pre-create Wishart sampler.
+        # scale_tril must be a lower triangular matrix.
+        self.wish_sampler = Wishart(
+            df=self.model.out_features, scale_tril=torch.eye(self.model.out_features, device=self.device)
+        )
+
+        self._refill_buffer()
+
+    def _refill_buffer(self) -> None:
+        """Generates a batch of samples to refill the internal buffer."""
+        # Note: We generate on self.device (which might be CPU initially).
+        # We will cast to the correct accelerator in the forward pass of the main module.
+        sample_dtype = self.model.dtype
+        with torch.no_grad():
+            z_mvn_bulk = torch.randn(
+                (self.buffer_size, self.model.num_samples, self.model.in_features, self.model.out_features),
+                device=self.device,
+                dtype=sample_dtype,
+            )
+
+            z_dirichlet_bulk = torch.randn(
+                (self.buffer_size, self.model.num_samples), device=self.device, dtype=sample_dtype
+            )
+
+            self.buffer = []
+            for i in range(self.buffer_size):
+                # Wishart sampling is numerically unstable in low precision; sample in fp32 then cast.
+                z_wishart = self.wish_sampler._bartlett_sampling(torch.Size()).to(self.device)
+                if sample_dtype is not None:
+                    z_wishart = z_wishart.to(sample_dtype)
+
+                sample = {"z_mvn": z_mvn_bulk[i], "z_wishart": z_wishart, "z_dirichlet": z_dirichlet_bulk[i]}
+                self.buffer.append(sample)
+
+        self.index = 0
+
+    def get(self) -> dict[str, torch.Tensor]:
+        """
+        Retrieves a single sample set from the buffer. Refills buffer if empty.
+        """
+        if self.index >= self.buffer_size:
+            self._refill_buffer()
+
+        sample = self.buffer[self.index]
+        self.index += 1
+        return sample
+
+
+class MontecloraSampler(nn.Module):
+    """
+    The main module responsible for maintaining the variational parameters.
+    """
+
+    def __init__(
+        self,
+        in_features: int,
+        out_features: int,
+        num_samples: int,
+        use_entropy: bool = True,
+        dirichlet_prior: float = 1.0,
+        sample_scaler: float = 3e-4,
+        kl_loss_weight: float = 1e-5,
+        buffer_size: int = 10,
+        device: Optional[str] = None,
+        dtype: Optional[torch.dtype] = None,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        self.in_features = in_features
+        self.out_features = out_features
+        self.num_samples = num_samples
+        self.use_entropy = use_entropy
+        # Initial device, might change if model.to() is called.
+        self.device = device if device is not None else infer_device()
+        self.dtype = dtype
+        self.sample_scaler = sample_scaler
+        self.kl_loss_weight = kl_loss_weight
+        self.dirichlet_prior = dirichlet_prior
+
+        # Variational Parameters. The dtype is matched to the parent LoRA layer dtype so that PEFT's
+        # adapter dtype handling (e.g. `autocast_adapter_dtype`) treats these parameters consistently
+        # with the rest of the LoRA adapter.
+        self.std_prior = nn.Parameter(torch.rand(out_features, dtype=dtype))
+        self.expert_weights_prior = nn.Parameter(torch.rand(num_samples, dtype=dtype))
+
+        # Buffers for state tracking
+        self.register_buffer("gaussian_var_prior", torch.eye(out_features, dtype=dtype))
+        self.register_buffer("expert_weights", torch.ones(num_samples, dtype=dtype) / num_samples)
+
+        self.sampler = BufferedMontecloraSampler(self, buffer_size=buffer_size, device=self.device)
+
+        # Move to initial device
+        self.to(self.device)
+
+    def wishart_reparameterization(self, std: torch.Tensor, z_wishart: torch.Tensor) -> torch.Tensor:
+        eps = 1e-3
+        # z_wishart and std must be on the same device
+        updated_var = std @ z_wishart @ std.T
+        updated_var = torch.diag(torch.clip(updated_var.diag(), min=eps))
+        return updated_var
+
+    def multivariate_reparameterization(self, z_mvn: torch.Tensor, cov_matrix: torch.Tensor) -> torch.Tensor:
+        eps = 1e-3
+        # Cholesky decomposition is numerically unstable in low precision (fp16/bf16) and can produce NaNs or
+        # negative-definite errors when autocast downcasts the inputs. We force the decomposition to run in fp32
+        # and cast back to the original dtype afterwards.
+        with torch.amp.autocast("cuda", enabled=False):
+            L = torch.linalg.cholesky(cov_matrix.float())
+        L = L.to(cov_matrix.dtype)
+
+        varsum = torch.einsum("eio,op->eip", z_mvn, L)
+        varsum = torch.nan_to_num(varsum, nan=eps)
+        return self.sample_scaler * varsum
+
+    def dirichlet_reparameterization(self, alpha: torch.Tensor, z_dirichlet: torch.Tensor) -> torch.Tensor:
+        eps = 1e-6
+        alpha = torch.clamp(alpha, min=eps)
+
+        mu = torch.log(alpha) - torch.log(alpha).mean()
+        # Dirichlet approximation via Normal distribution in log-space
+        diag_term = 1 / alpha * (1 - 2 / self.num_samples) + 1 / (self.num_samples**2) * (1 / alpha).sum()
+        diag_term = torch.clamp(diag_term, min=eps)
+        sigma = torch.diag(diag_term)
+        sigma = sigma + eps * torch.eye(len(alpha), device=self.expert_weights_prior.device)
+
+        # As above, force Cholesky to run in fp32 to avoid NaNs / "matrix is not positive-definite" errors caused
+        # by autocast downcasting `sigma` to fp16/bf16.
+        with torch.amp.autocast("cuda", enabled=False):
+            try:
+                L = torch.linalg.cholesky(sigma.float())
+            except torch.linalg.LinAlgError:
+                # Fallback for numerical stability
+                sigma = sigma + 1e-4 * torch.eye(len(alpha), device=self.expert_weights_prior.device)
+                L = torch.linalg.cholesky(sigma.float())
+
+        L = L.to(sigma.dtype)
+        return L @ z_dirichlet + mu
+
+    def dirichlet_kl(self, alpha2: torch.Tensor) -> torch.Tensor:
+        current_device = self.expert_weights_prior.device
+        alpha1 = torch.tensor([self.dirichlet_prior] * self.num_samples, device=current_device)
+
+        def custom_gamma(x: torch.Tensor) -> torch.Tensor:
+            return torch.lgamma(x).exp()
+
+        return (
+            torch.log(custom_gamma(alpha2.sum()) / custom_gamma(alpha1.sum()))
+            + (torch.log(custom_gamma(alpha2) / custom_gamma(alpha1))).sum()
+            + ((alpha2 - alpha1) * (torch.digamma(alpha2) - torch.digamma(alpha2.sum()))).sum()
+        )
+
+    def wishart_kl(self, std: torch.Tensor) -> torch.Tensor:
+        var = std @ std.T
+        var = torch.diag(var.diag())
+        return 0.5 * (
+            -torch.log(var).trace() * self.out_features + var.trace() * self.out_features - self.out_features**2
+        )
+
+    def multivariate_kl(self, var: torch.Tensor) -> torch.Tensor:
+        var = torch.clamp(var, min=1e-6)
+        return self.num_samples * 0.5 * (var.trace() - torch.log(var).trace() - self.out_features)
+
+    def get_variational_loss(self) -> tuple[torch.Tensor | float, torch.Tensor | float]:
+        """Calculates the KL divergence and entropy loss components."""
+        if self.training:
+            kl1 = self.dirichlet_kl(torch.exp(self.expert_weights_prior))
+            kl2 = self.wishart_kl(torch.diag(torch.exp(self.std_prior)))
+            kl3 = self.multivariate_kl(self.gaussian_var_prior)
+            entropy = (self.expert_weights**2).sum() if self.use_entropy else 0
+
+            return self.kl_loss_weight * (kl1 + kl2 + kl3), entropy
+        return 0.0, 0.0
+
+    def forward(self) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Returns:
+            tuple: (variational_noise, expert_weights)
+        """
+        # Use std_prior (nn.Parameter) as the source of truth for the current device/dtype.
+        current_device = self.std_prior.device
+        current_dtype = self.std_prior.dtype
+
+        sample = self.sampler.get()
+        z_mvn = sample["z_mvn"].to(device=current_device, dtype=current_dtype)
+        z_wishart = sample["z_wishart"].to(device=current_device, dtype=current_dtype)
+        z_dirichlet = sample["z_dirichlet"].to(device=current_device, dtype=current_dtype)
+
+        std = torch.diag(torch.exp(self.std_prior))
+
+        gaussian_var = self.wishart_reparameterization(std, z_wishart)
+
+        self.gaussian_var_prior = gaussian_var
+
+        var = self.multivariate_reparameterization(z_mvn, gaussian_var)
+
+        # Calculate Weights
+        expert_weights_logits = self.dirichlet_reparameterization(torch.exp(self.expert_weights_prior), z_dirichlet)
+        expert_weights = torch.softmax(expert_weights_logits, dim=-1)
+        self.expert_weights = expert_weights
+
+        return var, self.expert_weights
diff --git a/src/peft/tuners/lora/te.py b/src/peft/tuners/lora/te.py
new file mode 100644
index 0000000..22323ea
--- /dev/null
+++ b/src/peft/tuners/lora/te.py
@@ -0,0 +1,134 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-Apache2
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Any, Optional
+
+import torch
+
+from peft.import_utils import is_te_pytorch_available
+from peft.tuners.lora.layer import LoraLayer
+from peft.tuners.tuners_utils import BaseTunerLayer
+
+from .config import LoraConfig
+
+
+if is_te_pytorch_available():
+    import transformer_engine as te
+
+
+class TeLinear(torch.nn.Module, LoraLayer):
+    """LoRA layer for TransformerEngine linear modules.
+
+    Supports ``te.pytorch.Linear``, ``te.pytorch.LayerNormLinear``, and ``te.pytorch.LayerNormMLP`` as base layers.
+
+    Note:
+        Adapter weight merging (``merge`` / ``unmerge``) is **not supported** yet.
+    """
+
+    def __init__(
+        self,
+        base_layer,
+        adapter_name: str,
+        config: LoraConfig,
+        r: int = 0,
+        lora_alpha: int = 1,
+        **kwargs,
+    ):
+        if config.use_dora:
+            raise ValueError(f"{self.__class__.__name__} does not support DoRA yet, please set it to False")
+        if config.velora_config is not None:
+            raise ValueError(
+                f"{self.__class__.__name__} does not support VeLoRA yet, please set `velora_config=None`."
+            )
+
+        super().__init__()
+        LoraLayer.__init__(self, base_layer=base_layer, **kwargs)
+
+        self._active_adapter = adapter_name
+        self.update_layer(
+            adapter_name,
+            r,
+            lora_alpha=lora_alpha,
+            config=config,
+        )
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """Not supported yet for TransformerEngine layers.
+
+        Raises:
+            NotImplementedError: Always.
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} does not support merge yet.")
+
+    def unmerge(self) -> None:
+        """Not supported yet for TransformerEngine layers.
+
+        Raises:
+            NotImplementedError: Always.
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} does not support unmerge yet.")
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        self._check_forward_args(x, *args, **kwargs)
+        adapter_names = kwargs.pop("adapter_names", None)
+
+        if self.disable_adapters:
+            result = self.base_layer(x, *args, **kwargs)
+        elif adapter_names is not None:
+            raise ValueError(f"{self.__class__.__name__} does not support mixed_batch_forward yet.")
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+            torch_result_dtype = result.dtype
+
+            lora_A_keys = self.lora_A.keys()
+            for active_adapter in self.active_adapters:
+                if active_adapter not in lora_A_keys:
+                    continue
+
+                lora_A = self.lora_A[active_adapter]
+                lora_B = self.lora_B[active_adapter]
+                dropout = self.lora_dropout[active_adapter]
+                scaling = self.scaling[active_adapter]
+                x = self._cast_input_dtype(x, lora_A.weight.dtype)
+                result = result + lora_B(lora_A(dropout(x))) * scaling
+
+            result = result.to(torch_result_dtype)
+
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "lora." + rep
+
+
+def dispatch_transformer_engine(
+    target: torch.nn.Module,
+    adapter_name: str,
+    config: LoraConfig,
+    **kwargs: Any,
+) -> Optional[torch.nn.Module]:
+    new_module = None
+
+    if isinstance(target, BaseTunerLayer):
+        target_base_layer = target.get_base_layer()
+    else:
+        target_base_layer = target
+
+    if is_te_pytorch_available() and isinstance(
+        target_base_layer, (te.pytorch.LayerNormLinear, te.pytorch.LayerNormMLP, te.pytorch.Linear)
+    ):
+        new_module = TeLinear(target, adapter_name, config=config, **kwargs)
+
+    return new_module
diff --git a/src/peft/tuners/lora/torchao.py b/src/peft/tuners/lora/torchao.py
new file mode 100644
index 0000000..9d09bff
--- /dev/null
+++ b/src/peft/tuners/lora/torchao.py
@@ -0,0 +1,168 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import warnings
+from typing import Any, Optional
+
+import torch
+
+# from torch import nn
+from peft.import_utils import is_torchao_available
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+
+from .config import LoraConfig
+from .layer import Linear
+
+
+class TorchaoLoraLinear(Linear):
+    """LoRA layer implementation for Linear layers using torchao data"""
+
+    def __init__(self, *args, get_apply_tensor_subclass=None, **kwargs):
+        if kwargs["config"].lora_bias:
+            raise ValueError(f"{self.__class__.__name__} does not support lora_bias yet, set it to False")
+
+        super().__init__(*args, **kwargs)
+        self.get_apply_tensor_subclass = get_apply_tensor_subclass
+        if get_apply_tensor_subclass is None:
+            warnings.warn(
+                f"{type(self).__name__} was instantiated without `get_apply_tensor_subclass`. "
+                "Forward and training will work, but `merge()` / `unmerge()` will raise an error. "
+                "To enable merging, load the base model via Transformers with a `TorchAoConfig` "
+                "(e.g. `AutoModelForCausalLM.from_pretrained(..., quantization_config=TorchAoConfig(quant_type=Int8WeightOnlyConfig()))`) "
+                "so PEFT can recover the requantization subclass automatically."
+            )
+        self._check_dtype_supported()
+
+    def _check_dtype_supported(self):
+        # TODO: Not required once int4_weight_only is properly supported by torchao
+        from torchao.quantization import Int4Tensor
+
+        base_layer = self.get_base_layer()
+        weight = base_layer.weight
+        if isinstance(weight, Int4Tensor):
+            raise TypeError(f"{type(self).__name__} only supports int8 weights for now.")
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        from torchao import quantize_
+
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        if self.get_apply_tensor_subclass is None:
+            raise ValueError(
+                f"{type(self).__name__} was instantiated without `get_apply_tensor_subclass`, which is "
+                "required to re-quantize the base layer after merging."
+            )
+
+        self._check_dtype_supported()
+
+        base_layer = self.get_base_layer()
+        weight = base_layer.weight
+
+        for active_adapter in adapter_names:
+            try:
+                weight = weight.dequantize()
+            except NotImplementedError as exc:
+                msg = (
+                    f"Weights of type {type(weight).__name__} do not support dequantization (yet), which is needed to "
+                    "support merging."
+                )
+                raise NotImplementedError(msg) from exc
+
+            if safe_merge and not torch.isfinite(weight).all():
+                raise ValueError(
+                    f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                )
+
+            weight += self.get_delta_weight(active_adapter)
+            # TODO: once (if) torchao supports directly mutating the data, use that instead.
+            del base_layer.weight
+            base_layer.weight = weight
+            quantize_(base_layer, self.get_apply_tensor_subclass())
+            del weight
+
+            self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        from torchao import quantize_
+
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+
+        if self.get_apply_tensor_subclass is None:
+            raise ValueError(
+                f"{type(self).__name__} was instantiated without `get_apply_tensor_subclass`, which is "
+                "required to re-quantize the base layer after unmerging."
+            )
+
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter not in self.lora_A.keys():
+                continue
+
+            base_layer = self.get_base_layer()
+            weight = base_layer.weight
+            try:
+                weight = weight.dequantize()
+            except NotImplementedError as exc:
+                msg = (
+                    f"Weights of type {type(weight).__name__} do not support dequantization (yet), which is needed to "
+                    "support unmerging."
+                )
+                raise NotImplementedError(msg) from exc
+
+            weight -= self.get_delta_weight(active_adapter)
+            # We go through a dummy module because overriding the weight.data does not work, the tensor retains the old
+            # data. Therefore, we need to go through quantize_, which takes a module as input, and we need to delete and
+            # re-assign the weight.
+            # TODO: once (if) torchao supports directly mutating the data, use that instead.
+            del base_layer.weight
+            base_layer.weight = weight
+            quantize_(base_layer, self.get_apply_tensor_subclass())
+            del weight
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return rep.replace("lora.Linear", f"lora.{self.__class__.__name__}")
+
+
+def dispatch_torchao(
+    target: torch.nn.Module,
+    adapter_name: str,
+    config: LoraConfig,
+    **kwargs: Any,
+) -> Optional[torch.nn.Module]:
+    new_module = None
+
+    if isinstance(target, BaseTunerLayer):
+        target_base_layer = target.get_base_layer()
+    else:
+        target_base_layer = target
+
+    if not hasattr(target_base_layer, "weight"):
+        return new_module
+
+    if not is_torchao_available():
+        return new_module
+
+    from torchao.utils import TorchAOBaseTensor
+
+    if isinstance(target_base_layer.weight, TorchAOBaseTensor):
+        new_module = TorchaoLoraLinear(target, adapter_name, config=config, **kwargs)
+
+    return new_module
diff --git a/src/peft/tuners/lora/tp_layer.py b/src/peft/tuners/lora/tp_layer.py
new file mode 100644
index 0000000..c68988c
--- /dev/null
+++ b/src/peft/tuners/lora/tp_layer.py
@@ -0,0 +1,362 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import importlib
+import math
+import warnings
+from typing import Any, Optional
+
+import torch
+from torch import nn
+from torch.nn import init
+
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+from peft.utils import transpose
+from peft.utils.integrations import gather_params_ctx
+
+from .config import LoraConfig
+from .layer import LoraLayer
+
+
+def get_default_module_allowlist():
+    """Allowed module names that config.megatron_core can reference for import"""
+    return [
+        "megatron",
+    ]
+
+
+class LoraParallelLinear(nn.Module, LoraLayer):
+    """
+    When the target layer parallel_linear is RowParallelLinear, in order to keep the input and output shapes
+    consistent, we need to split the lora matrix A into rows, and the lora_B at this time should be a complete linear
+    layer; In the same way, when the target layer is ColumnParallelLinear, we perform column segmentation on lora_B,
+    while lora_A is still a complete linear layer.
+    """
+
+    def __init__(
+        self,
+        base_layer,
+        adapter_name: str,
+        config: LoraConfig,
+        backend,
+        r: int = 0,
+        lora_alpha: int = 1,
+        is_target_conv_1d_layer: bool = False,
+        **kwargs,
+    ):
+        if config.lora_bias:
+            raise ValueError(f"{self.__class__.__name__} does not support lora_bias yet, set it to False")
+
+        super().__init__()
+        LoraLayer.__init__(self, base_layer=base_layer, **kwargs)
+
+        if config.use_dora:
+            raise ValueError(f"{self.__class__.__name__} does not support DoRA yet, please set it to False")
+        if config.velora_config is not None:
+            raise ValueError(
+                f"{self.__class__.__name__} does not support VeLoRA yet, please set `velora_config=None`."
+            )
+
+        self.backend = backend
+        self.is_parallel_a = isinstance(base_layer, backend.RowParallelLinear)
+        self.fan_in_fan_out = config.fan_in_fan_out
+        self._active_adapter = adapter_name
+
+        megatron_config = kwargs["megatron_config"]
+        parallel_linear_kwargs = {"megatron_config": megatron_config}
+        init_method = init.xavier_normal_
+        if hasattr(megatron_config, "init_method"):
+            init_method = megatron_config.init_method
+        input_is_parallel = True
+        gather_output = False
+        if self.is_parallel_a:
+            input_is_parallel = base_layer.input_is_parallel
+        else:
+            gather_output = base_layer.gather_output
+        self.update_layer(
+            adapter_name,
+            r,
+            lora_alpha=lora_alpha,
+            config=config,
+            init_method=init_method,
+            input_is_parallel=input_is_parallel,
+            gather_output=gather_output,
+            **parallel_linear_kwargs,
+        )
+
+        if is_target_conv_1d_layer:
+            raise ValueError(
+                f"{self.__class__.__name__} does not support target_conv_1d_layer yet, please set it to False"
+            )
+        self.is_target_conv_1d_layer = False
+
+    def update_layer(
+        self,
+        adapter_name: str,
+        r: int,
+        lora_alpha: int,
+        config: LoraConfig,
+        init_method=init.xavier_normal_,
+        input_is_parallel: bool = True,
+        gather_output: bool = False,
+        inference_mode: bool = False,
+        **parallel_linear_kwargs,
+    ) -> None:
+        lora_dropout = config.lora_dropout
+        init_lora_weights = config.init_lora_weights
+        use_rslora = config.use_rslora
+        use_dora = config.use_dora
+
+        if r <= 0:
+            raise ValueError(f"`r` should be a positive integer value but the value passed is {r}")
+        self.r[adapter_name] = r
+        self.lora_alpha[adapter_name] = lora_alpha
+        if lora_dropout > 0.0:
+            lora_dropout_layer = nn.Dropout(p=lora_dropout)
+        else:
+            lora_dropout_layer = nn.Identity()
+
+        self.lora_dropout[adapter_name] = lora_dropout_layer
+
+        megatron_config = parallel_linear_kwargs["megatron_config"]
+        # lora needs to be forced to upgrade to 32-bit precision, otherwise it will overflow
+        megatron_config.params_dtype = torch.float32
+        if self.is_parallel_a:
+            lora_a = self.backend.RowParallelLinear(
+                input_size=self.in_features,
+                output_size=r,
+                bias=False,
+                input_is_parallel=input_is_parallel,
+                skip_bias_add=True,
+                init_method=init_method,
+                config=megatron_config,
+            )
+            lora_b = nn.Linear(in_features=r, out_features=self.out_features, bias=False, dtype=torch.float32)
+        else:
+            lora_a = nn.Linear(in_features=self.in_features, out_features=r, bias=False, dtype=torch.float32)
+            lora_b = self.backend.ColumnParallelLinear(
+                input_size=r,
+                output_size=self.out_features,
+                bias=False,
+                gather_output=gather_output,
+                init_method=init_method,
+                config=megatron_config,
+            )
+        self.lora_A[adapter_name] = lora_a
+        self.lora_B[adapter_name] = lora_b
+        if use_rslora:
+            self.scaling[adapter_name] = lora_alpha / math.sqrt(r)
+        else:
+            self.scaling[adapter_name] = lora_alpha / r
+
+        self.use_dora[adapter_name] = use_dora
+
+        # for inits that require access to the base weight, use gather_param_ctx so that the weight is gathered when using DeepSpeed
+        if isinstance(init_lora_weights, str) and init_lora_weights.startswith("pissa"):
+            with gather_params_ctx(self.get_base_layer().weight):
+                self.pissa_init(adapter_name, init_lora_weights)
+        elif isinstance(init_lora_weights, str) and init_lora_weights.startswith("corda"):
+            with gather_params_ctx(self.get_base_layer().weight):
+                self.corda_init(adapter_name, init_lora_weights)
+        elif isinstance(init_lora_weights, str) and init_lora_weights.lower() == "olora":
+            with gather_params_ctx(self.get_base_layer().weight):
+                self.olora_init(adapter_name)
+        elif init_lora_weights == "loftq":
+            with gather_params_ctx(self.get_base_layer().weight):
+                self.loftq_init(adapter_name)
+        elif init_lora_weights:
+            self.reset_lora_parameters(adapter_name, init_lora_weights)
+
+        # call this before dora_init
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+
+        if adapter_name in self.lora_variant:
+            self.lora_variant[adapter_name].init(self, adapter_name=adapter_name, config=config)
+
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any):
+        self._check_forward_args(x, *args, **kwargs)
+        adapter_names = kwargs.pop("adapter_names", None)
+        # If weight is used for matrix multiplication here, the final aggregation operation of the original
+        # parallel_linear layer will be missing, so we need to directly call its forward function to obtain the
+        # output of the original parallel_linear layer.
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result, bias = self.base_layer(x, *args, **kwargs)
+        elif adapter_names is not None:
+            raise ValueError(f"{self.__class__.__name__} does not support mixed_batch_forward yet.")
+        elif self.merged:
+            result, bias = self.base_layer(x, *args, **kwargs)
+        else:
+            result, bias = self.base_layer(x, *args, **kwargs)
+            torch_result_dtype = result.dtype
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.lora_A.keys():
+                    continue
+                lora_A = self.lora_A[active_adapter]
+                lora_B = self.lora_B[active_adapter]
+                dropout = self.lora_dropout[active_adapter]
+                scaling = self.scaling[active_adapter]
+                x = self._cast_input_dtype(x, lora_A.weight.dtype)
+                result = result + lora_B(lora_A(dropout(x))) * scaling
+
+            result = result.to(torch_result_dtype)
+        return result, bias
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`list[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.lora_A.keys():
+                base_layer = self.get_base_layer()
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    # because of the copy operation.
+                    orig_weights = base_layer.weight.data.clone()
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    orig_weights = orig_weights + delta_weight
+
+                    if not torch.isfinite(orig_weights).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = orig_weights
+                else:
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    base_layer.weight.data = base_layer.weight.data + delta_weight
+
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.lora_A.keys():
+                weight = self.get_base_layer().weight
+                delta_weight = self.get_delta_weight(active_adapter)
+                weight.data -= delta_weight
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        """
+        Compute the delta weight for the given adapter.
+
+        Args:
+            adapter (str):
+                The name of the adapter for which the delta weight should be computed.
+        """
+        device = self.lora_B[adapter].weight.device
+        dtype = self.lora_B[adapter].weight.dtype
+
+        # In case users wants to merge the adapter weights that are in
+        # (b)float16 while being on CPU, we need to cast the weights to float32, perform the merge and then cast back to
+        # (b)float16 because some CPUs have slow bf16/fp16 matmuls.
+        cast_to_fp32 = device.type == "cpu" and (dtype == torch.float16 or dtype == torch.bfloat16)
+
+        weight_A = self.lora_A[adapter].weight
+        weight_B = self.lora_B[adapter].weight
+
+        if cast_to_fp32:
+            weight_A = weight_A.float()
+            weight_B = weight_B.float()
+
+        output_tensor = transpose(weight_B @ weight_A, self.fan_in_fan_out) * self.scaling[adapter]
+
+        if cast_to_fp32:
+            output_tensor = output_tensor.to(dtype=dtype)
+
+            # cast back the weights
+            self.lora_A[adapter].weight.data = weight_A.to(dtype)
+            self.lora_B[adapter].weight.data = weight_B.to(dtype)
+
+        return output_tensor
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "lora." + rep
+
+
+def dispatch_megatron(
+    target: torch.nn.Module,
+    adapter_name: str,
+    config: LoraConfig,
+    **kwargs: Any,
+) -> Optional[torch.nn.Module]:
+    new_module = None
+
+    if isinstance(target, BaseTunerLayer):
+        target_base_layer = target.get_base_layer()
+    else:
+        target_base_layer = target
+
+    if config.megatron_config:
+        if not any(config.megatron_core.startswith(f"{prefix}.") for prefix in get_default_module_allowlist()):
+            raise ValueError(
+                f"{config.megatron_core=} does not start with a valid prefix ({get_default_module_allowlist()}) "
+                "which is unsupported due to being a potential security risk. If you think it should be supported, "
+                "please raise an issue in PEFT."
+            )
+        megatron_core = importlib.import_module(config.megatron_core)
+    else:
+        megatron_core = None
+
+    if megatron_core and isinstance(
+        target_base_layer,
+        (megatron_core.tensor_parallel.ColumnParallelLinear, megatron_core.tensor_parallel.RowParallelLinear),
+    ):
+        megatron_kwargs = kwargs.copy()
+        megatron_config = config.megatron_config
+        if isinstance(megatron_config, dict):
+            transformer_config_class = megatron_core.transformer.transformer_config.TransformerConfig
+            megatron_config = transformer_config_class(**config.megatron_config)
+        megatron_kwargs["megatron_config"] = megatron_config
+        if megatron_kwargs["fan_in_fan_out"]:
+            warnings.warn(
+                "fan_in_fan_out is set to True but the target module is `ColumnParallelLinear` "
+                "or `RowParallelLinear`. "
+                "Setting fan_in_fan_out to False."
+            )
+            megatron_kwargs["fan_in_fan_out"] = config.fan_in_fan_out = False
+        new_module = LoraParallelLinear(
+            base_layer=target,
+            adapter_name=adapter_name,
+            config=config,
+            backend=megatron_core.tensor_parallel,
+            **megatron_kwargs,
+        )
+
+    return new_module
diff --git a/src/peft/tuners/lora/variants.py b/src/peft/tuners/lora/variants.py
new file mode 100644
index 0000000..dfd1ec8
--- /dev/null
+++ b/src/peft/tuners/lora/variants.py
@@ -0,0 +1,1312 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import collections
+import warnings
+from typing import Any, Optional
+
+import torch
+import torch.nn.functional as F
+from accelerate.utils.imports import is_xpu_available
+from torch import nn
+
+from peft.tuners._buffer_dict import BufferDict
+from peft.tuners.lora.config import BdLoraConfig, MontecloraConfig
+from peft.utils.other import transpose
+
+from .arrow import ArrowLoraLinearLayer
+from .config import LoraConfig, PeftConfig
+from .dora import DoraConv1dLayer, DoraConv2dLayer, DoraConv3dLayer, DoraEmbeddingLayer, DoraLinearLayer
+from .layer import Conv1d, Conv2d, Conv3d, Embedding, Linear, LoraLayer, LoraVariant, _ConvNd
+from .monteclora import MontecloraSampler
+from .velora import VeloraFunction, _get_group_dim, _normalize_projection, _reshape_to_grouped_subtokens
+
+
+class ArrowLinearVariant(LoraVariant):
+    @staticmethod
+    def init(module: Linear, adapter_name: str, config: LoraConfig, **kwargs):
+        """
+        Initialise the ArrowLoraLinearLayer() inside lora_arrow. lora_arrow is nn.ModuleDict(), serving as a container
+        for ArrowLoraLinearLayer(). A layer of the base model with LoRA adapter loaded on it will be like:
+        ----------------------------------------------------
+             (qkv_proj): lora.Linear4bit or lora.Linear(
+                (base_layer): Linear4bit or Linear (lora_dropout): ModuleDict( ... ) (lora_A): ModuleDict( ... )
+                (lora_B): ModuleDict( ... ) (lora_embedding_A): ParameterDict( ... ) (lora_embedding_B): ParameterDict(
+                ... ) (lora_magnitude_vector): ModuleDict( ... ) (lora_arrow): ModuleDict(
+                    (arrow_router): ArrowLoraLinearLayer() )
+            )
+        ----------------------------------------------------
+
+        Args:
+            module (Linear): LoRA Layer of the model, containing base_layer, lora_A, lora_B, etc.
+            adapter_name (str): name of the adapter that will be put in lora_arrow.
+            The adapter_name is "arrow_router" by default, set in create_arrow_model() in ./arrow.py
+        """
+        # Checking for arrow necessary config
+        arrow_config = config.arrow_config
+        if arrow_config is None:
+            raise ValueError("ArrowLinearVariant.init() did not receive an arrow_config")
+
+        # 1-a) build the ArrowLoRALayer
+        arrow_layer = ArrowLoraLinearLayer(
+            in_features=module.in_features,
+            arrow_config=arrow_config,
+        ).to(module.weight.device)
+
+        # 1-b) register a container if it doesn’t exist yet
+        if not hasattr(module, "lora_arrow"):
+            module.lora_arrow = nn.ModuleDict()
+
+        module.lora_arrow[adapter_name] = arrow_layer
+
+    @staticmethod
+    def forward(
+        module: Linear,
+        *,
+        active_adapter: str,
+        x: torch.Tensor,
+        result: torch.Tensor,
+        **kwargs,
+    ) -> torch.Tensor:
+        """
+        Parameters mirror those in PEFT’s `LoraVariant.forward`. Called every time the host Linear does a fwd pass.
+
+        build_prototypes() and gen_know_sub() should run only once before routing. Both are implemented in
+        ArrowLoraLinearLayer (see ./arrow.py). They are lazily invoked in the forward pass below. Attributes of
+        ArrowLoraLinearLayer() class ensure they execute only a single time.
+
+        Args:
+            module (Linear): LoRA Layer of the model
+            active_adapter (str): name of the arrow route, which should be active to perform arrow.
+            x (torch.Tensor): input to the layer
+            result (torch.Tensor): output of the base layer.
+
+        Return value:
+            output of the base model + delta weight computed by arrow layer.
+        """
+        arrow = module.lora_arrow[active_adapter]  # ArrowLoraLinearLayer
+        # Apply GenKnowSub the 1st time if applicable. By calling arrow/on_adapter_change(),
+        # gen_know_sub() is redone for newly added adapters after arrow.create_arrow_model().
+        arrow.gen_know_sub(module.lora_A, module.lora_B)
+        # lazily build prototypes the 1st time after GenKnowSub. By calling arrow/on_adapter_change(),
+        # build_prototypes() is redone for newly added adapters after arrow.create_arrow_model().
+        arrow.build_prototypes(module.lora_A, module.lora_B)
+
+        # A forward path of ArrowLoraLinearLayer is called so routing performs.
+        # Accept and ignore extra variant kwargs (e.g., 'alora_offsets') for compatibility
+        delta = arrow(
+            x,
+            lora_A=module.lora_A,
+            lora_B=module.lora_B,
+            dropout=module.lora_dropout[active_adapter],
+            scaling=module.scaling,
+        )
+        return result + delta
+
+    """
+    Since Arrow is a Mixture-of-Experts (MoE) approach, merging adapters is not meaningful or even possible: for each
+    token, the top-k LoRA experts are dynamically selected and routed. Because of this per-token routing, there is no
+    single set of weights that can represent a merged adapter.
+    """
+
+    @staticmethod
+    def merge_safe(module: Linear, active_adapter: str, orig_weight: torch.Tensor) -> torch.Tensor:
+        raise RuntimeError("Cannot merge an active Arrow router adapter. Remove it first.")
+
+    @staticmethod
+    def merge_unsafe(module: Linear, active_adapter: str, orig_weight: torch.Tensor) -> None:
+        raise RuntimeError("Cannot merge an active Arrow router adapter. Remove it first.")
+
+    @staticmethod
+    def unmerge(module: Linear, active_adapter: str, orig_weight: torch.Tensor) -> torch.Tensor:
+        raise RuntimeError("Cannot unmerge an active Arrow router adapter. Remove it first.")
+
+
+class DoraLinearVariant(LoraVariant):
+    @staticmethod
+    def init(module: Linear, adapter_name: str, **kwargs: Any) -> None:
+        if not module.lora_magnitude_vector:
+            # first dora layer being added, add lora_magnitude_vector to the list of learnable parameters
+            module.adapter_layer_names = module.adapter_layer_names[:] + ("lora_magnitude_vector",)
+
+        dora_layer = DoraLinearLayer(fan_in_fan_out=getattr(module, "fan_in_fan_out", False))
+        lora_A = module.lora_A[adapter_name].weight
+        lora_B = module.lora_B[adapter_name].weight
+        place_on_cpu = module.ephemeral_gpu_offload and (lora_A.device.type == "cpu" or lora_B.device.type == "cpu")
+        if module.ephemeral_gpu_offload:
+            if lora_A.device.type in ["cuda", "xpu"]:
+                lora_B = lora_B.to(lora_A.device)
+            else:
+                if lora_B.device.type not in ["cuda", "xpu"]:
+                    if is_xpu_available():
+                        lora_B = lora_B.to("xpu")
+                    else:
+                        lora_B = lora_B.to("cuda")
+                lora_A = lora_A.to(lora_B.device)
+        scaling = module.scaling[adapter_name]
+        dora_layer.update_layer(
+            base_layer=module.get_base_layer(),
+            lora_A=lora_A,
+            lora_B=lora_B,
+            scaling=scaling,
+            place_on_cpu=place_on_cpu,
+        )
+        module.lora_magnitude_vector[adapter_name] = dora_layer
+
+    @staticmethod
+    def merge_safe(module: Linear, active_adapter: str, orig_weight: torch.Tensor) -> torch.Tensor:
+        orig_dtype = orig_weight.dtype
+        delta_weight = module.get_delta_weight(active_adapter)
+
+        # since delta_weight already includes scaling, set it to 1 here
+        weight_norm = (
+            module.lora_magnitude_vector[active_adapter]
+            .get_weight_norm(orig_weight, transpose(delta_weight, module.fan_in_fan_out), scaling=1)
+            .detach()
+        )
+        # We need to cache weight_norm because it has to be based on the original weights. We
+        # cannot calculate it on the fly based on the merged weights when unmerging because its a
+        # different value
+        module._cache_store(f"{active_adapter}-weight_norm", weight_norm)
+        dora_factor = module.lora_magnitude_vector[active_adapter].weight / weight_norm
+        dora_factor = transpose(dora_factor.view(-1, 1), module.fan_in_fan_out)
+        new_weight = dora_factor * (orig_weight + delta_weight)
+        new_weight = new_weight.to(orig_dtype)
+        return new_weight
+
+    @staticmethod
+    def merge_unsafe(module: Linear, active_adapter: str, orig_weight: torch.Tensor) -> None:
+        orig_dtype = orig_weight.dtype
+        delta_weight = module.get_delta_weight(active_adapter)
+        weight_norm = (
+            module.lora_magnitude_vector[active_adapter]
+            .get_weight_norm(orig_weight, transpose(delta_weight, module.fan_in_fan_out), scaling=1)
+            .detach()
+        )
+        # We need to cache weight_norm because it has to be based on the original weights. We
+        # cannot calculate it on the fly based on the merged weights when unmerging because its a
+        # different value
+        module._cache_store(f"{active_adapter}-weight_norm", weight_norm)
+        dora_factor = module.lora_magnitude_vector[active_adapter].weight / weight_norm
+        dora_factor = transpose(dora_factor.view(-1, 1), module.fan_in_fan_out)
+        new_weight = dora_factor * (orig_weight.data + delta_weight)
+        new_weight = new_weight.to(orig_dtype)
+        orig_weight.data = new_weight
+
+    @staticmethod
+    def unmerge(module: Linear, active_adapter: str, orig_weight: torch.Tensor) -> torch.Tensor:
+        orig_dtype = orig_weight.dtype
+        delta_weight = module.get_delta_weight(active_adapter)
+        weight_norm = module._cache_pop(f"{active_adapter}-weight_norm")
+        dora_factor = module.lora_magnitude_vector[active_adapter].weight / weight_norm
+        new_weight = orig_weight.data / dora_factor.view(-1, 1) - delta_weight
+        new_weight = new_weight.to(orig_dtype)
+        return new_weight
+
+    @staticmethod
+    def forward(
+        module: Linear,
+        active_adapter: str,
+        x: torch.Tensor,
+        result: torch.Tensor,
+        **kwargs,
+    ) -> torch.Tensor:
+        lora_A = module.lora_A[active_adapter]
+        lora_B = module.lora_B[active_adapter]
+        dropout = module.lora_dropout[active_adapter]
+        scaling = module.scaling[active_adapter]
+
+        if isinstance(dropout, nn.Identity) or not module.training:
+            base_result = result
+        else:
+            x = dropout(x)
+            base_result = None
+
+        result = result + module.lora_magnitude_vector[active_adapter](
+            x,
+            lora_A=lora_A,
+            lora_B=lora_B,
+            scaling=scaling,
+            base_layer=module.get_base_layer(),
+            base_result=base_result,
+            adapter_name=active_adapter,
+        )
+        return result
+
+
+class DoraEmbeddingVariant(DoraLinearVariant):
+    @staticmethod
+    def init(module: Embedding, adapter_name: str, **kwargs: Any) -> None:
+        if module.lora_magnitude_vector is None:
+            # first dora layer being added, add lora_magnitude_vector to the list of learnable parameters
+            module.adapter_layer_names = module.adapter_layer_names[:] + ("lora_magnitude_vector",)
+
+        dora_layer = DoraEmbeddingLayer(fan_in_fan_out=True)
+        lora_embedding_A = module.lora_embedding_A[adapter_name]
+        lora_embedding_B = module.lora_embedding_B[adapter_name]
+        scaling = module.scaling[adapter_name]
+        dora_layer.update_layer(
+            base_layer=module.get_base_layer(), lora_A=lora_embedding_A, lora_B=lora_embedding_B, scaling=scaling
+        )
+        module.lora_magnitude_vector[adapter_name] = dora_layer
+
+    @staticmethod
+    def merge_safe(module: Embedding, active_adapter: str, orig_weight: torch.Tensor) -> torch.Tensor:
+        orig_dtype = orig_weight.dtype
+        delta_weight = module.get_delta_weight(active_adapter)
+
+        # since delta_weight already includes scaling, set it to 1 here
+        weight_norm = (
+            module.lora_magnitude_vector[active_adapter]
+            .get_weight_norm(orig_weight, delta_weight.T, scaling=1)
+            .detach()
+        )
+        # We need to cache weight_norm because it has to be based on the original weights. We
+        # cannot calculate it on the fly based on the merged weights when unmerging because its a
+        # different value
+        module._cache_store(f"{active_adapter}-weight_norm", weight_norm)
+        dora_factor = module.lora_magnitude_vector[active_adapter].weight / weight_norm
+        dora_factor = dora_factor.view(1, -1)
+        new_weight = dora_factor * (orig_weight + delta_weight)
+        new_weight = new_weight.to(orig_dtype)
+        return new_weight
+
+    @staticmethod
+    def merge_unsafe(module: Embedding, active_adapter: str, orig_weight: torch.Tensor) -> None:
+        orig_dtype = orig_weight.dtype
+        delta_weight = module.get_delta_weight(active_adapter)
+        weight_norm = (
+            module.lora_magnitude_vector[active_adapter]
+            .get_weight_norm(orig_weight, delta_weight.T, scaling=1)
+            .detach()
+        )
+        # We need to cache weight_norm because it has to be based on the original weights. We
+        # cannot calculate it on the fly based on the merged weights when unmerging because its a
+        # different value
+        module._cache_store(f"{active_adapter}-weight_norm", weight_norm)
+        dora_factor = module.lora_magnitude_vector[active_adapter].weight / weight_norm
+        dora_factor = dora_factor.view(1, -1)
+        new_weight = dora_factor * (orig_weight.data + delta_weight)
+        new_weight = new_weight.to(orig_dtype)
+        orig_weight.data = new_weight
+
+    @staticmethod
+    def unmerge(module: Embedding, active_adapter: str, orig_weight: torch.Tensor) -> torch.Tensor:
+        orig_dtype = orig_weight.dtype
+        delta_weight = module.get_delta_weight(active_adapter)
+        weight_norm = module._cache_pop(f"{active_adapter}-weight_norm")
+        dora_factor = module.lora_magnitude_vector[active_adapter].weight / weight_norm
+        new_weight = orig_weight.data / dora_factor.view(1, -1) - delta_weight
+        new_weight = new_weight.to(orig_dtype)
+        return new_weight
+
+    @staticmethod
+    def forward(
+        module: Embedding,
+        active_adapter: str,
+        x: torch.Tensor,
+        result: torch.Tensor,
+        **kwargs,
+    ) -> torch.Tensor:
+        embedding_A = module.lora_embedding_A[active_adapter].T
+        embedding_B = module.lora_embedding_B[active_adapter].T
+        scaling = module.scaling[active_adapter]
+
+        mag_norm_scale, dora_result = module.lora_magnitude_vector[active_adapter](
+            x,
+            lora_A=embedding_A,
+            lora_B=embedding_B,
+            scaling=scaling,
+            base_layer=module.get_base_layer(),
+            embed_fn=module._embed,
+            adapter_name=active_adapter,
+        )
+
+        # Some embedding layers (e.g., Gemma3TextScaledWordEmbedding) apply scaling in their forward method.
+        # Since base_layer(x) already includes this scaling, we need to apply it to DoRA contributions too.
+        # Note: embed_scale is applied AFTER weight norm calculation to preserve DoRA's weight geometry semantics.
+        embed_scale = module._get_embed_scale()
+        if embed_scale is not None:
+            dora_result = dora_result * embed_scale.to(dora_result.dtype)
+
+        result = mag_norm_scale * result + dora_result
+        return result
+
+
+class _DoraConvNdVariant(LoraVariant):
+    @staticmethod
+    def init_convd_variant(module: _ConvNd, adapter_name: str, dora_layer: nn.Module) -> None:
+        if module.lora_magnitude_vector is None:
+            # first dora layer being added, add lora_magnitude_vector to the list of learnable parameters
+            module.adapter_layer_names = module.adapter_layer_names[:] + ("lora_magnitude_vector",)
+
+        lora_A = module.lora_A[adapter_name].weight
+        lora_B = module.lora_B[adapter_name].weight
+        scaling = module.scaling[adapter_name]
+        dora_layer.update_layer(base_layer=module.get_base_layer(), lora_A=lora_A, lora_B=lora_B, scaling=scaling)
+        module.lora_magnitude_vector[adapter_name] = dora_layer
+
+    @staticmethod
+    def merge_safe(module: _ConvNd, active_adapter: str, orig_weight: torch.Tensor) -> torch.Tensor:
+        orig_dtype = orig_weight.dtype
+        delta_weight = module.get_delta_weight(active_adapter)
+
+        # since delta_weight already includes scaling, set it to 1 here
+        weight_norm = (
+            module.lora_magnitude_vector[active_adapter].get_weight_norm(orig_weight, delta_weight, scaling=1).detach()
+        )
+        # We need to cache weight_norm because it has to be based on the original weights. We
+        # cannot calculate it on the fly based on the merged weights when unmerging because its a
+        # different value
+        module._cache_store(f"{active_adapter}-weight_norm", weight_norm)
+        dora_factor = module.lora_magnitude_vector[active_adapter].weight / weight_norm
+        new_weight = dora_factor.view(*module._get_dora_factor_view()) * (orig_weight + delta_weight)
+        new_weight = new_weight.to(orig_dtype)
+        return new_weight
+
+    @staticmethod
+    def merge_unsafe(module: _ConvNd, active_adapter: str, orig_weight: torch.Tensor) -> None:
+        orig_dtype = orig_weight.dtype
+        delta_weight = module.get_delta_weight(active_adapter)
+        # since delta_weight already includes scaling, set it to 1 here
+        weight_norm = (
+            module.lora_magnitude_vector[active_adapter].get_weight_norm(orig_weight, delta_weight, scaling=1).detach()
+        )
+        # We need to cache weight_norm because it has to be based on the original weights. We
+        # cannot calculate it on the fly based on the merged weights when unmerging because its a
+        # different value
+        module._cache_store(f"{active_adapter}-weight_norm", weight_norm)
+        dora_factor = module.lora_magnitude_vector[active_adapter].weight / weight_norm
+        new_weight = dora_factor.view(*module._get_dora_factor_view()) * (orig_weight.data + delta_weight)
+        new_weight = new_weight.to(orig_dtype)
+        orig_weight.data = new_weight
+
+    @staticmethod
+    def unmerge(module: _ConvNd, active_adapter: str, orig_weight: torch.Tensor) -> torch.Tensor:
+        orig_dtype = orig_weight.dtype
+        delta_weight = module.get_delta_weight(active_adapter)
+        weight_norm = module._cache_pop(f"{active_adapter}-weight_norm")
+        dora_factor = module.lora_magnitude_vector[active_adapter].weight / weight_norm
+        new_weight = orig_weight.data / dora_factor.view(*module._get_dora_factor_view()) - delta_weight
+        new_weight = new_weight.to(orig_dtype)
+        return new_weight
+
+    @staticmethod
+    def forward(
+        module: _ConvNd,
+        active_adapter: str,
+        x: torch.Tensor,
+        result: torch.Tensor,
+        **kwargs,
+    ) -> torch.Tensor:
+        lora_A = module.lora_A[active_adapter]
+        lora_B = module.lora_B[active_adapter]
+        dropout = module.lora_dropout[active_adapter]
+        scaling = module.scaling[active_adapter]
+
+        if isinstance(dropout, nn.Identity) or not module.training:
+            base_result = result
+        else:
+            x = dropout(x)
+            base_result = None
+
+        result = result + module.lora_magnitude_vector[active_adapter](
+            x,
+            lora_A=lora_A,
+            lora_B=lora_B,
+            scaling=scaling,
+            base_layer=module.get_base_layer(),
+            base_result=base_result,
+            adapter_name=active_adapter,
+        )
+        return result
+
+
+class DoraConv1dVariant(_DoraConvNdVariant):
+    @staticmethod
+    def init(module: Conv1d, adapter_name: str, config: LoraConfig, **kwargs: Any) -> None:
+        dora_layer = DoraConv1dLayer(fan_in_fan_out=False)
+        _DoraConvNdVariant.init_convd_variant(module, adapter_name, dora_layer=dora_layer)
+
+
+class DoraConv2dVariant(_DoraConvNdVariant):
+    @staticmethod
+    def init(module: Conv2d, adapter_name: str, config: LoraConfig, **kwargs: Any) -> None:
+        dora_layer = DoraConv2dLayer(fan_in_fan_out=False)
+        _DoraConvNdVariant.init_convd_variant(module, adapter_name, dora_layer=dora_layer)
+
+
+class DoraConv3dVariant(_DoraConvNdVariant):
+    @staticmethod
+    def init(module: Conv3d, adapter_name: str, config: LoraConfig, **kwargs: Any) -> None:
+        dora_layer = DoraConv3dLayer(fan_in_fan_out=False)
+        _DoraConvNdVariant.init_convd_variant(module, adapter_name, dora_layer=dora_layer)
+
+
+class QALoraLinearVariant(LoraVariant):
+    @staticmethod
+    def init(module: Linear, adapter_name: str, config: LoraConfig, **kwargs: Any) -> None:
+        """
+        Initializes QALoRA specific parameters for a given adapter.
+
+        Args:
+            module (Linear): The linear module to be adapted.
+            adapter_name (str): The name of the adapter.
+            config (LoraConfig): The config of the LoRA adapter.
+            **kwargs: Additional keyword arguments.
+        """
+        qalora_group_size = config.qalora_group_size
+        if module.in_features is not None and module.in_features % qalora_group_size != 0:
+            raise ValueError(
+                f"`use_qalora=True` requires `module.in_features` ({module.in_features}) to be"
+                f"divisible by 'qalora_group_size' ({qalora_group_size})"
+            )
+
+        if "qalora_group_size" not in module.other_param_names:
+            module.other_param_names = module.other_param_names + ("qalora_group_size",)
+
+        if not hasattr(module, "qalora_group_size"):
+            module.qalora_group_size = {}
+        module.qalora_group_size[adapter_name] = qalora_group_size
+
+        old_lora_A_layer = module.lora_A[adapter_name]
+        r = old_lora_A_layer.out_features
+        device = old_lora_A_layer.weight.device
+        dtype = old_lora_A_layer.weight.dtype
+
+        new_lora_A_layer = nn.Linear(
+            old_lora_A_layer.in_features // module.qalora_group_size[adapter_name],
+            r,
+            bias=False,
+            device=device,
+            dtype=dtype,
+        )
+        module.lora_A[adapter_name] = new_lora_A_layer
+
+    @staticmethod
+    def get_delta_weight(module: Linear, active_adapter: str) -> torch.Tensor:
+        raise NotImplementedError("QALoRA for GPTQ layers does not support 'get_delta_weight'.")
+
+    @staticmethod
+    def merge_safe(module: Linear, active_adapter: str, orig_weight: torch.Tensor) -> torch.Tensor:
+        raise NotImplementedError("QALoRA for GPTQ layers does not support 'safe_merge'.")
+
+    @staticmethod
+    def merge_unsafe(module: Linear, active_adapter: str, orig_weight: torch.Tensor) -> None:
+        raise NotImplementedError("QALoRA for GPTQ layers does not support 'merge_unsafe'.")
+
+    @staticmethod
+    def unmerge(module: Linear, active_adapter: str, orig_weight: torch.Tensor) -> torch.Tensor:
+        raise NotImplementedError("QALoRA for GPTQ layers does not support 'unmerge'.")
+
+    @staticmethod
+    def forward(
+        module: Linear,
+        active_adapter: str,
+        x: torch.Tensor,
+        result: torch.Tensor,
+        **kwargs,
+    ) -> torch.Tensor:
+        lora_A_weight = module.lora_A[active_adapter].weight
+        lora_B_weight = module.lora_B[active_adapter].weight
+        dropout = module.lora_dropout[active_adapter]
+        scaling = module.scaling[active_adapter]
+        group_size = module.qalora_group_size[active_adapter]
+
+        x_dropped = dropout(x) if module.training and not isinstance(dropout, nn.Identity) else x
+        orig_shape = x_dropped.shape
+
+        # Reshape to 2D
+        if len(orig_shape) > 2:
+            x_flat = x_dropped.view(-1, module.in_features)
+        else:
+            x_flat = x_dropped
+
+        batch_size, in_features = x_flat.shape
+        pooled_features = in_features // group_size
+
+        x_pooled = x_flat.view(batch_size, pooled_features, group_size).mean(dim=2)
+
+        x_pooled_scaled = x_pooled * pooled_features
+
+        # LoRA computation
+        delta = x_pooled_scaled @ lora_A_weight.t() @ lora_B_weight.t() * scaling
+
+        # Reshape back
+        if len(orig_shape) > 2:
+            delta = delta.view(orig_shape[:-1] + (delta.size(-1),))
+
+        return result + delta
+
+
+class ALoraLinearVariant(LoraVariant):
+    @staticmethod
+    def init(module: Linear, adapter_name: str, config: LoraConfig, **kwargs: Any) -> None:
+        pass
+
+    @staticmethod
+    def merge_safe(module: Linear, active_adapter: str, orig_weight: torch.Tensor) -> torch.Tensor:
+        raise NotImplementedError("aLoRA does not support safe merging.")
+
+    @staticmethod
+    def merge_unsafe(module: Linear, active_adapter: str, orig_weight: torch.Tensor) -> None:
+        raise NotImplementedError("aLoRA does not support merging.")
+
+    @staticmethod
+    def unmerge(module: Linear, active_adapter: str, orig_weight: torch.Tensor) -> torch.Tensor:
+        raise NotImplementedError("aLoRA does not support unmerging.")
+
+    @staticmethod
+    def forward(
+        module: Linear,
+        active_adapter: str,
+        x: torch.Tensor,
+        result: torch.Tensor,
+        **kwargs,
+    ) -> torch.Tensor:
+        alora_offsets = kwargs.get("alora_offsets", None)
+        lora_A = module.lora_A[active_adapter]
+        lora_B = module.lora_B[active_adapter]
+        dropout = module.lora_dropout[active_adapter]
+        scaling = module.scaling[active_adapter]
+        x = x.to(lora_A.weight.dtype)
+        result_shape = result.shape
+        B = result_shape[0]  # batch
+        if len(result_shape) == 3:
+            T = result_shape[1]  # tokens
+        else:
+            T = 1
+        D = result_shape[-1]  # dimensions
+        Dx = x.shape[-1]
+        device = result.device
+        if alora_offsets is None:  # use base model only, but ensure 0 gradient
+            mask = torch.zeros((B, T), dtype=torch.bool)
+        else:
+            # If alora_offsets[i] is None, this means that the invocation sequence was not found in the
+            # input. As a result, the weights should not be activated anywhere (equivalent to base model).
+            # Convert None -> 0 and clip to T
+            offsets = torch.tensor(
+                [0 if o is None else min(int(o), T) for o in alora_offsets],
+                device=device,
+                dtype=torch.long,
+            )
+            # Mask True on the last `offsets[i]` positions for each row i
+            pos = torch.arange(T, device=device).unsqueeze(0)  # [1, T]
+            mask = pos >= (T - offsets).unsqueeze(1)
+
+        # Flatten for vectorization
+        x_flat = x.view(-1, Dx)
+        res_flat = result.view(-1, D)
+        mask_flat = mask.view(-1)
+
+        # Compute adapter on the selected tokens only
+        res_flat[mask_flat] += lora_B(lora_A(dropout(x_flat[mask_flat]))) * scaling
+        return result
+
+
+def calculate_alora_offsets(
+    peft_config: PeftConfig, active_adapter: str, input_ids: torch.Tensor, adapter_names: Optional[list[str]] = None
+) -> list[int]:
+    """
+    This is a helper function for Activated LoRA (aLoRA) that searches each input token sequence for the last
+    occurrence of the appropriate "alora_invocation_tokens" invocation sequence. The calculated alora_offset is the
+    location of the *start* of the invocation tokens, counting backward from the end (will therefore always be >=
+    len(alora_invocation_tokens). If adapter_names is passed, then each input uses the appropriate invocation sequence
+    for the specified adapter for that row. Logic is provided to handle mixed collections of adapters for which not all
+    are aLoRAs (e.g. some base model, some LoRA).
+    """
+    if input_ids is None:
+        return []
+
+    batch_size = input_ids.shape[0]
+    alora_offsets = [None] * batch_size
+
+    cached_invocation_tensors = {}
+    adapters_to_process_indices = collections.defaultdict(list)
+
+    for i in range(batch_size):
+        current_adapter_name = adapter_names[i] if adapter_names and i < len(adapter_names) else active_adapter
+
+        if current_adapter_name == "__base__":
+            alora_offsets[i] = None
+            continue
+
+        if current_adapter_name not in peft_config:
+            warnings.warn(f"Adapter '{current_adapter_name}' not found in peft_config. Using base model for row {i}.")
+            alora_offsets[i] = None
+            continue
+
+        current_peft_config = peft_config[current_adapter_name]
+
+        invocation_tokens = getattr(current_peft_config, "alora_invocation_tokens", None)
+        if invocation_tokens is None:
+            alora_offsets[i] = None  # Not an aLoRA adapter or wrong type
+            continue
+
+        if current_adapter_name not in cached_invocation_tensors:
+            cached_invocation_tensors[current_adapter_name] = torch.tensor(
+                invocation_tokens, dtype=torch.long, device=input_ids.device
+            )
+
+        adapters_to_process_indices[current_adapter_name].append(i)
+
+    for adapter_name_to_process, indices in adapters_to_process_indices.items():
+        current_invocation_ids_tensor = cached_invocation_tensors[adapter_name_to_process]
+        invocation_len = len(current_invocation_ids_tensor)
+
+        for i in indices:
+            sequence = input_ids[i]
+            seq_len = len(sequence)
+            best_match_start_idx = -1
+
+            possible_starts = (sequence == current_invocation_ids_tensor[0]).nonzero(as_tuple=True)[0]
+
+            for start_idx_tensor in possible_starts:
+                idx = start_idx_tensor.item()
+                if idx + invocation_len <= seq_len:
+                    if torch.equal(sequence[idx : idx + invocation_len], current_invocation_ids_tensor):
+                        best_match_start_idx = max(best_match_start_idx, idx)
+
+            if best_match_start_idx != -1:
+                offset_val = seq_len - best_match_start_idx
+                alora_offsets[i] = offset_val if offset_val > 0 else None
+            else:  # Invocation sequence not found in input
+                alora_offsets[i] = None
+    return alora_offsets
+
+
+def is_alora_relevant_in_batch(model: nn.Module, adapter_names: Optional[list[str]] = None):
+    """
+    Helper function to determine if the current batch has any aLoRA adapters.
+    """
+    is_alora_relevant = False
+    if getattr(model.active_peft_config, "alora_invocation_tokens", None):
+        is_alora_relevant = True
+    elif adapter_names:
+        for name in adapter_names:
+            if name == "__base__":
+                continue
+            config_ = model.peft_config.get(name)
+            if config_ and getattr(config_, "alora_invocation_tokens", None):
+                is_alora_relevant = True
+                break
+
+    return is_alora_relevant
+
+
+def get_alora_offsets_for_forward(
+    model: nn.Module, input_ids: torch.Tensor = None, inputs_embeds: torch.Tensor = None, **kwargs
+):
+    """
+    Wrapper around calculate_alora_offsets, for the .forward of the model. It only calculates alora_offsets if the
+    batch contains aLoRA adapters.
+    """
+    adapter_names_for_offset_calc = kwargs.get("adapter_names", None)
+    if not is_alora_relevant_in_batch(model, adapter_names_for_offset_calc):
+        # Nothing to compute
+        return kwargs
+    alora_offsets = kwargs.get("alora_offsets")
+    if alora_offsets is None:
+        if input_ids is None and inputs_embeds is not None:
+            warnings.warn(
+                "Cannot calculate aLoRA offsets when only inputs_embeds are provided. Disabling aLoRA for this forward pass."
+            )
+            kwargs["alora_offsets"] = None
+        elif input_ids is not None:
+            kwargs["alora_offsets"] = calculate_alora_offsets(
+                model.peft_config,
+                model.active_adapter,
+                input_ids,
+                adapter_names=adapter_names_for_offset_calc,
+            )
+        else:
+            kwargs["alora_offsets"] = None
+    return kwargs
+
+
+def get_alora_offsets_for_generate(model: nn.module, *args, **kwargs):
+    """
+    Wrapper around calculate_alora_offsets, for the .generate of the model. It only calculates alora_offsets if the
+    batch contains aLoRA adapters.
+    """
+    adapter_names_for_offset_calc = kwargs.get("adapter_names")
+    if not is_alora_relevant_in_batch(model, adapter_names_for_offset_calc):
+        # Nothing to compute
+        return kwargs
+    alora_offsets_from_kwargs = kwargs.get("alora_offsets")
+    if alora_offsets_from_kwargs is None:
+        current_input_ids = kwargs.get("input_ids")
+        if current_input_ids is None:  # args[0] is usually input_ids
+            if args and isinstance(args[0], torch.Tensor):
+                current_input_ids = args[0]
+            else:
+                current_input_ids = None
+
+        if current_input_ids is not None:
+            if current_input_ids.ndim == 1:
+                current_input_ids = current_input_ids.unsqueeze(0)
+            calculated_offsets = calculate_alora_offsets(
+                model.peft_config,
+                model.active_adapter,
+                current_input_ids,
+                adapter_names=adapter_names_for_offset_calc,
+            )
+            kwargs["alora_offsets"] = calculated_offsets
+
+        else:
+            warnings.warn(
+                "Cannot calculate aLoRA offsets during generate as input_ids are not available. Disabling aLoRA."
+            )
+
+            kwargs["alora_offsets"] = None
+    return kwargs
+
+
+class VeloraLinearVariant(LoraVariant):
+    @staticmethod
+    def init(module: Linear, adapter_name: str, config: LoraConfig, **kwargs: Any) -> None:
+        if not hasattr(module, "lora_velora_embed"):
+            module.lora_velora_embed = BufferDict({}, persistent=True)
+        if not hasattr(module, "lora_velora_initialized"):
+            module.lora_velora_initialized = {}
+        if not hasattr(module, "lora_velora_num_groups"):
+            module.lora_velora_num_groups = {}
+        if not hasattr(module, "lora_velora_init_type"):
+            module.lora_velora_init_type = {}
+        if not hasattr(module, "lora_velora_scale"):
+            module.lora_velora_scale = {}
+
+        velora_param_names = (
+            "lora_velora_embed",
+            "lora_velora_initialized",
+            "lora_velora_num_groups",
+            "lora_velora_init_type",
+            "lora_velora_scale",
+        )
+        for param_name in velora_param_names:
+            if param_name not in module.other_param_names:
+                module.other_param_names = module.other_param_names + (param_name,)
+
+        module.lora_velora_num_groups[adapter_name] = config.velora_config.num_groups
+        module.lora_velora_init_type[adapter_name] = config.velora_config.init_type
+        module.lora_velora_scale[adapter_name] = config.velora_config.scale
+
+        group_dim = _get_group_dim(module.in_features, config.velora_config.num_groups)
+        base_layer = module.get_base_layer()
+        dtype = base_layer.weight.dtype
+        device = base_layer.weight.device
+
+        if config.velora_config.init_type == "random":
+            embed = _normalize_projection(torch.randn(group_dim, device=device, dtype=dtype)).to(dtype=dtype)
+            initialized = True
+        else:
+            embed = torch.zeros(group_dim, device=device, dtype=dtype)
+            initialized = False
+
+        module.lora_velora_embed[adapter_name] = embed
+        module.lora_velora_initialized[adapter_name] = initialized
+        module._move_adapter_to_device_of_base_layer(adapter_name)
+
+    @staticmethod
+    def merge_safe(module: Linear, active_adapter: str, orig_weight: torch.Tensor) -> torch.Tensor:
+        orig_dtype = orig_weight.dtype
+        delta_weight = module.get_delta_weight(active_adapter)
+        return orig_weight + delta_weight.to(orig_dtype)
+
+    @staticmethod
+    def merge_unsafe(module: Linear, active_adapter: str, orig_weight: torch.Tensor) -> None:
+        orig_weight.data += module.get_delta_weight(active_adapter)
+
+    @staticmethod
+    def unmerge(module: Linear, active_adapter: str, orig_weight: torch.Tensor) -> torch.Tensor:
+        orig_dtype = orig_weight.dtype
+        delta_weight = module.get_delta_weight(active_adapter)
+        return orig_weight - delta_weight.to(orig_dtype)
+
+    @staticmethod
+    def _maybe_update_embed(module: Linear, adapter_name: str, x: torch.Tensor) -> None:
+        if adapter_name not in module.lora_velora_initialized:
+            return
+
+        init_type = module.lora_velora_init_type[adapter_name]
+        if init_type == "random":
+            return
+        if init_type == "batch_average_once":
+            initialized = module.lora_velora_initialized[adapter_name]
+            if initialized:
+                return
+
+        num_groups = module.lora_velora_num_groups[adapter_name]
+        with torch.no_grad():
+            subtokens = _reshape_to_grouped_subtokens(x.detach(), num_groups)
+            subtokens = subtokens.reshape(-1, subtokens.shape[-1])
+            embed = _normalize_projection(subtokens.mean(dim=0))
+            target = module.lora_velora_embed[adapter_name]
+            module.lora_velora_embed[adapter_name] = embed.to(device=target.device, dtype=target.dtype)
+            module.lora_velora_initialized[adapter_name] = True
+
+    @staticmethod
+    def forward(
+        module: Linear,
+        active_adapter: str,
+        x: torch.Tensor,
+        result: torch.Tensor,
+        **kwargs,
+    ) -> torch.Tensor:
+        lora_A = module.lora_A[active_adapter]
+        lora_B = module.lora_B[active_adapter]
+        dropout = module.lora_dropout[active_adapter]
+        scaling = module.scaling[active_adapter]
+
+        x = dropout(x)
+
+        if module.training and torch.is_grad_enabled():
+            VeloraLinearVariant._maybe_update_embed(module, active_adapter, x)
+            after_A = VeloraFunction.apply(
+                x,
+                lora_A.weight,
+                lora_A.bias,
+                module.lora_velora_embed[active_adapter],
+                module.lora_velora_num_groups[active_adapter],
+                module.lora_velora_scale[active_adapter],
+            )
+        else:
+            after_A = lora_A(x)
+
+        result = result + lora_B(after_A) * scaling
+        return result
+
+
+class BlockDiagonalLinear(nn.Module):
+    def __init__(
+        self,
+        in_features: int,
+        out_features: int,
+        nblocks: int,
+        init_zero: bool = False,
+        dtype: torch.dtype = torch.float32,
+        device: torch.device | None = None,
+    ):
+        super().__init__()
+        self.in_features = in_features
+        self.out_features = out_features
+        self.nblocks = nblocks
+        device = device or torch.device("cpu")
+        if self.in_features % nblocks != 0 or self.out_features % nblocks != 0:
+            raise ValueError(
+                f"self.in_features={self.in_features} or self.out_features={self.out_features} not divisible by {self.nblocks}"
+            )
+        # Create weight with specified dtype and device
+        self.weight = nn.Parameter(torch.empty(out_features, in_features // nblocks, dtype=dtype, device=device))
+
+        if init_zero:
+            torch.nn.init.zeros_(self.weight)
+        else:
+            torch.nn.init.kaiming_uniform_(self.weight)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        first_dims = x.shape[:-1]
+        if x.dim() != 2:
+            x = x.reshape(-1, x.shape[-1])
+        B = x.shape[0]
+        nb = self.nblocks
+        m = x.shape[-1] // nb
+        n = self.out_features // nb
+        x = x.reshape(B, nb, m)
+        w = self.weight.view(nb, n, m)
+        out = torch.einsum("bim,inm->bin", x, w)
+        return out.reshape(*first_dims, -1)
+
+    def weight_as_blockdiagonal_matrix(self):
+        """Returns weight in a format similar to a vanilla LoRA adapter. For this, we stack the blocks on the diagonal,
+        leaving the off-diagonals padded with zero."""
+        return torch.block_diag(*torch.chunk(self.weight, self.nblocks, dim=0))
+
+
+class BdLoraLinearVariant(LoraVariant):
+    @staticmethod
+    def init(module: Linear, adapter_name: str, config: LoraConfig, **kwargs) -> None:
+        use_bdlora = config.use_bdlora
+        target_name = kwargs.get("target_name", "")
+
+        # Handle case where use_bdlora is a dict (from saved config) instead of BdLoraConfig object
+        if isinstance(use_bdlora, dict):
+            use_bdlora = BdLoraConfig(**use_bdlora)
+
+        lora_a_blockdiagonal_pattern = use_bdlora.target_modules_bd_a or []
+        lora_b_blockdiagonal_pattern = use_bdlora.target_modules_bd_b or []
+        nblocks = use_bdlora.nblocks
+
+        has_lora_a_blockdiagonal = any(pattern in target_name for pattern in lora_a_blockdiagonal_pattern)
+        has_lora_b_blockdiagonal = any(pattern in target_name for pattern in lora_b_blockdiagonal_pattern)
+
+        if has_lora_a_blockdiagonal and has_lora_b_blockdiagonal:
+            raise ValueError(f"Target {target_name} matches both A and B block-diagonal patterns")
+        if use_bdlora.match_strict and not (has_lora_a_blockdiagonal or has_lora_b_blockdiagonal):
+            raise ValueError(
+                f"Target {target_name} matches neither A nor B block-diagonal patterns."
+                "If this is intentional, set match_strict=False in BdLoraConfig during initialization. "
+            )
+
+        if has_lora_a_blockdiagonal:
+            r = module.lora_A[adapter_name].out_features
+            base_layer = module.get_base_layer()
+            layer = BlockDiagonalLinear(
+                base_layer.in_features,
+                r,
+                nblocks=nblocks,
+                init_zero=False,
+                dtype=base_layer.weight.dtype,
+                device=base_layer.weight.device,
+            )
+            module.lora_A[adapter_name] = layer
+        elif has_lora_b_blockdiagonal:
+            r = module.lora_B[adapter_name].in_features
+            base_layer = module.get_base_layer()
+            layer = BlockDiagonalLinear(
+                r,
+                base_layer.out_features,
+                nblocks=nblocks,
+                init_zero=True,
+                dtype=base_layer.weight.dtype,
+                device=base_layer.weight.device,
+            )
+            module.lora_B[adapter_name] = layer
+
+    @staticmethod
+    def forward(module: Linear, active_adapter: str, x: torch.Tensor, result: torch.Tensor, **kwargs) -> torch.Tensor:
+        lora_A = module.lora_A[active_adapter]
+        lora_B = module.lora_B[active_adapter]
+        dropout = module.lora_dropout[active_adapter]
+        scaling = module.scaling[active_adapter]
+        x = dropout(x)
+        # Cast input dtype to match lora_A weight dtype
+        x = module._cast_input_dtype(x, lora_A.weight.dtype)
+        result += lora_B(lora_A(x)) * scaling
+        return result
+
+    @staticmethod
+    def _get_weight_from_module_maybe_blockdiagonal(module: nn.Module) -> torch.Tensor:
+        if isinstance(module, BlockDiagonalLinear):
+            return module.weight_as_blockdiagonal_matrix()
+        else:
+            return module.weight  # type: ignore
+
+    @staticmethod
+    def _get_bdlora_delta_weight(module: Linear, adapter: str) -> torch.Tensor:
+        """Similar to get_delta_weight for a linear module, but we have to eventually reshape the blocks
+        of the weights."""
+        device = module.lora_B[adapter].weight.device
+        # Use base layer dtype to ensure compatibility with merge/unmerge operations
+        base_layer = module.get_base_layer()
+        dtype = base_layer.weight.dtype
+        cast_to_fp32 = device.type == "cpu" and (dtype == torch.float16 or dtype == torch.bfloat16)
+
+        weight_A = BdLoraLinearVariant._get_weight_from_module_maybe_blockdiagonal(module.lora_A[adapter])
+        weight_B = BdLoraLinearVariant._get_weight_from_module_maybe_blockdiagonal(module.lora_B[adapter])
+
+        if cast_to_fp32:
+            weight_A = weight_A.float()
+            weight_B = weight_B.float()
+
+        output_tensor = transpose(weight_B @ weight_A, module.fan_in_fan_out) * module.scaling[adapter]
+
+        if cast_to_fp32:
+            output_tensor = output_tensor.to(dtype=dtype)
+
+        # Ensure output tensor matches base layer dtype
+        return output_tensor.to(dtype=dtype)
+
+    @staticmethod
+    def merge_safe(module: Linear, active_adapter: str, orig_weight: torch.Tensor) -> torch.Tensor:
+        return orig_weight + BdLoraLinearVariant._get_bdlora_delta_weight(module, active_adapter)
+
+    @staticmethod
+    def merge_unsafe(module: Linear, active_adapter: str, orig_weight: torch.Tensor) -> None:
+        orig_weight.data += BdLoraLinearVariant._get_bdlora_delta_weight(module, active_adapter)
+
+    @staticmethod
+    def unmerge(module: Linear, active_adapter: str, orig_weight: torch.Tensor) -> torch.Tensor:
+        return orig_weight - BdLoraLinearVariant._get_bdlora_delta_weight(module, active_adapter)
+
+
+class MontecloraLinearVariant(LoraVariant):
+    """
+    Monteclora (Monte Carlo Low-Rank Adaptation) variant implementation.
+
+    This variant adds variational inference to LoRA by introducing Monte Carlo sampling to the adapter weights during
+    training. The sampling is controlled by a MontecloraSampler that maintains variational parameters and produces
+    perturbations to the LoRA weights.
+    """
+
+    @staticmethod
+    def init(module: Linear, adapter_name: str, config: LoraConfig, **kwargs: Any) -> None:
+        """
+        Initialize Monteclora for a LoRA layer.
+
+        This adds a MontecloraSampler to the layer that will be used during forward passes to sample variational
+        perturbations for the LoRA A matrix.
+
+        Args:
+            module: The Linear LoRA layer to add Monteclora to
+            adapter_name: Name of the adapter
+            config: The `LoraConfig` which carries the `monteclora_config`.
+        """
+        monteclora_config = config.monteclora_config
+
+        if not hasattr(module, "lora_monteclora_sampler"):
+            module.adapter_layer_names = module.adapter_layer_names[:] + ("lora_monteclora_sampler",)
+            module.lora_monteclora_sampler = nn.ModuleDict()
+        if not hasattr(module, "_lora_monteclora_config"):
+            module._lora_monteclora_config = {}
+        module._lora_monteclora_config[adapter_name] = monteclora_config
+
+        lora_A = module.lora_A[adapter_name]
+        # When low_cpu_mem_usage=True, adapters can be initialized on meta device.
+        # Defer sampler creation until first forward on a concrete device.
+        if lora_A.weight.device.type != "meta":
+            module.lora_monteclora_sampler[adapter_name] = MontecloraLinearVariant._create_sampler(
+                module, adapter_name, monteclora_config
+            )
+
+    @staticmethod
+    def _create_sampler(module: Linear, adapter_name: str, monteclora_config: MontecloraConfig) -> MontecloraSampler:
+        lora_A = module.lora_A[adapter_name]
+        return MontecloraSampler(
+            in_features=module.in_features,
+            out_features=lora_A.out_features,
+            num_samples=monteclora_config.num_samples,
+            use_entropy=monteclora_config.use_entropy,
+            dirichlet_prior=monteclora_config.dirichlet_prior,
+            sample_scaler=monteclora_config.sample_scaler,
+            kl_loss_weight=monteclora_config.kl_loss_weight,
+            buffer_size=monteclora_config.buffer_size,
+            device=lora_A.weight.device,
+            dtype=lora_A.weight.dtype,
+        )
+
+    @staticmethod
+    def merge_safe(module: Linear, active_adapter: str, orig_weight: torch.Tensor) -> torch.Tensor:
+        """
+        Safely merge Monteclora adapter weights into base weights.
+
+        For merging, we ignore the MC sampling and just use the base LoRA weights (lora_A and lora_B). This is
+        equivalent to merging a standard LoRA adapter.
+
+        Args:
+            module: The Linear LoRA layer
+            active_adapter: Name of the adapter to merge
+            orig_weight: Original base layer weight
+
+        Returns:
+            New weight with adapter merged
+        """
+        orig_dtype = orig_weight.dtype
+        delta_weight = module.get_delta_weight(active_adapter)
+        new_weight = orig_weight + delta_weight.to(orig_dtype)
+        return new_weight
+
+    @staticmethod
+    def merge_unsafe(module: Linear, active_adapter: str, orig_weight: torch.Tensor) -> None:
+        """
+        Merge Monteclora adapter weights into base weights (in-place).
+
+        For merging, we ignore the MC sampling and just use the base LoRA weights (lora_A and lora_B). This is
+        equivalent to merging a standard LoRA adapter.
+
+        Args:
+            module: The Linear LoRA layer
+            active_adapter: Name of the adapter to merge
+            orig_weight: Original base layer weight (modified in-place)
+        """
+        delta_weight = module.get_delta_weight(active_adapter)
+        orig_weight.data += delta_weight
+
+    @staticmethod
+    def unmerge(module: Linear, active_adapter: str, orig_weight: torch.Tensor) -> torch.Tensor:
+        """
+        Unmerge Monteclora adapter weights from base weights.
+
+        For unmerging, we ignore the MC sampling and just use the base LoRA weights (lora_A and lora_B). This is
+        equivalent to unmerging a standard LoRA adapter.
+
+        Args:
+            module: The Linear LoRA layer
+            active_adapter: Name of the adapter to unmerge
+            orig_weight: Current weight with adapter merged
+
+        Returns:
+            Weight with adapter unmerged
+        """
+        orig_dtype = orig_weight.dtype
+        delta_weight = module.get_delta_weight(active_adapter)
+        new_weight = orig_weight - delta_weight.to(orig_dtype)
+        return new_weight
+
+    @staticmethod
+    def forward(
+        module: Linear,
+        active_adapter: str,
+        x: torch.Tensor,
+        result: torch.Tensor,
+        **kwargs,
+    ) -> torch.Tensor:
+        """
+        Forward pass with Monteclora sampling.
+
+        This samples variational perturbations from the MontecloraSampler and applies them to the LoRA A weights before
+        computing the LoRA update.
+
+        Args:
+            module: The Linear LoRA layer
+            active_adapter: Name of the active adapter
+            x: Input tensor
+            result: Output from the base layer
+            **kwargs: Additional arguments (unused)
+
+        Returns:
+            result + LoRA update with Monteclora sampling applied
+        """
+        lora_A = module.lora_A[active_adapter]
+        lora_B = module.lora_B[
+            active_adapter
+        ]  # lora_B is zero in the beginning. test for stochasticity of outputs might fail because of this
+        dropout = module.lora_dropout[active_adapter]
+        scaling = module.scaling[active_adapter]
+        if active_adapter not in module.lora_monteclora_sampler:
+            # Sampler creation was deferred in `init` because the LoRA weights were on the meta device
+            # (e.g. when `low_cpu_mem_usage=True`). Now that we have a real tensor at forward time, we can
+            # finally create the sampler on the correct device.
+            monteclora_config = module._lora_monteclora_config[active_adapter]
+            module.lora_monteclora_sampler[active_adapter] = MontecloraLinearVariant._create_sampler(
+                module, active_adapter, monteclora_config
+            )
+        sampler = module.lora_monteclora_sampler[active_adapter]
+
+        x = x.to(lora_A.weight.dtype)
+        if isinstance(dropout, nn.Identity) or not module.training:
+            x_dropped = x
+        else:
+            x_dropped = dropout(x)
+
+        current_weight_A = lora_A.weight
+
+        if module.training:
+            lora_A_vars, lora_A_wts = sampler()
+            if torch.isnan(lora_A_vars).any() or torch.isnan(lora_A_wts).any():
+                warnings.warn("Monteclora sampling produced NaNs, using base weights.")
+            else:
+                noise = torch.nan_to_num(lora_A_vars, nan=0.0)
+                base_w = lora_A.weight.T
+                perturbed_w = base_w + noise
+                averaged_w = torch.einsum("n,nij->ij", lora_A_wts, perturbed_w)
+                current_weight_A = averaged_w.T
+        out_A = F.linear(x_dropped, current_weight_A)
+        result = result + lora_B(out_A) * scaling
+        return result
+
+
+def _register_frozen_peft_weight(module: LoraLayer, adapter_name: str, weight_name: str) -> None:
+    """Register an adapter weight that should stay frozen for this PEFT layer."""
+    frozen_peft_weight_names = module.frozen_peft_weight_names.copy()
+    frozen_peft_weight_names.setdefault(adapter_name, ())
+
+    if weight_name not in frozen_peft_weight_names[adapter_name]:
+        frozen_peft_weight_names[adapter_name] += (weight_name,)
+
+    module.frozen_peft_weight_names = frozen_peft_weight_names
+    module._freeze_non_trainable_peft_weights(adapter_name)
+
+
+class MiCALinearVariant(LoraVariant):
+    """Variant for Minor Component Adaptation (MiCA), https://arxiv.org/abs/2604.01694.
+
+    The actual SVD-based initialization is performed in `LoraLayer.mica_init` (called from `update_layer`); this
+    variant declares `lora_B` as frozen. Forward and merge semantics are identical to vanilla LoRA, since `delta_W =
+    scaling * B @ A` and only `A` is updated.
+    """
+
+    @staticmethod
+    def init(module: Linear, adapter_name: str, **kwargs: Any) -> None:
+        _register_frozen_peft_weight(module, adapter_name, "lora_B")
+
+    @staticmethod
+    def merge_safe(module: Linear, active_adapter: str, orig_weight: torch.Tensor) -> torch.Tensor:
+        return orig_weight + module.get_delta_weight(active_adapter).to(orig_weight.dtype)
+
+    @staticmethod
+    def merge_unsafe(module: Linear, active_adapter: str, orig_weight: torch.Tensor) -> None:
+        orig_weight.data += module.get_delta_weight(active_adapter).to(orig_weight.dtype)
+
+    @staticmethod
+    def unmerge(module: Linear, active_adapter: str, orig_weight: torch.Tensor) -> torch.Tensor:
+        return orig_weight - module.get_delta_weight(active_adapter).to(orig_weight.dtype)
+
+    @staticmethod
+    def forward(
+        module: Linear,
+        active_adapter: str,
+        x: torch.Tensor,
+        result: torch.Tensor,
+        **kwargs,
+    ) -> torch.Tensor:
+        lora_A = module.lora_A[active_adapter]
+        lora_B = module.lora_B[active_adapter]
+        dropout = module.lora_dropout[active_adapter]
+        scaling = module.scaling[active_adapter]
+        return result + lora_B(lora_A(dropout(x))) * scaling
+
+
+class MiCAEmbeddingVariant(LoraVariant):
+    """Embedding variant for Minor Component Adaptation (MiCA), https://arxiv.org/abs/2604.01694."""
+
+    @staticmethod
+    def init(module: Embedding, adapter_name: str, **kwargs: Any) -> None:
+        _register_frozen_peft_weight(module, adapter_name, "lora_embedding_B")
+
+    @staticmethod
+    def merge_safe(module: Embedding, active_adapter: str, orig_weight: torch.Tensor) -> torch.Tensor:
+        return orig_weight + module.get_delta_weight(active_adapter).to(orig_weight.dtype)
+
+    @staticmethod
+    def merge_unsafe(module: Embedding, active_adapter: str, orig_weight: torch.Tensor) -> None:
+        orig_weight.data += module.get_delta_weight(active_adapter).to(orig_weight.dtype)
+
+    @staticmethod
+    def unmerge(module: Embedding, active_adapter: str, orig_weight: torch.Tensor) -> torch.Tensor:
+        return orig_weight - module.get_delta_weight(active_adapter).to(orig_weight.dtype)
+
+    @staticmethod
+    def forward(
+        module: Embedding,
+        active_adapter: str,
+        x: torch.Tensor,
+        result: torch.Tensor,
+        **kwargs,
+    ) -> torch.Tensor:
+        embedding_A = module.lora_embedding_A[active_adapter].T
+        embedding_B = module.lora_embedding_B[active_adapter].T
+        scaling = module.scaling[active_adapter]
+        input_fn = module.input_fns.get(active_adapter, None)
+        output_fn = module.output_fns.get(active_adapter, None)
+
+        after_A = module._embed(x, embedding_A, input_fn=input_fn, output_fn=output_fn)
+        adapter_output = (after_A @ embedding_B) * scaling
+
+        embed_scale = module._get_embed_scale()
+        if embed_scale is not None:
+            adapter_output = adapter_output * embed_scale.to(adapter_output.dtype)
+
+        return result + adapter_output
diff --git a/src/peft/tuners/lora/velora.py b/src/peft/tuners/lora/velora.py
new file mode 100644
index 0000000..f3f9f53
--- /dev/null
+++ b/src/peft/tuners/lora/velora.py
@@ -0,0 +1,112 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+from typing import Optional
+
+import torch
+import torch.nn.functional as F
+
+
+def _get_group_dim(in_features: int, num_groups: int) -> int:
+    return (in_features + num_groups - 1) // num_groups
+
+
+def _reshape_to_grouped_subtokens(x: torch.Tensor, num_groups: int) -> torch.Tensor:
+    group_dim = _get_group_dim(x.shape[-1], num_groups)
+    padded_features = num_groups * group_dim
+    if x.shape[-1] != padded_features:
+        x = F.pad(x, (0, padded_features - x.shape[-1]))
+    return x.reshape(-1, num_groups, group_dim)
+
+
+def _compress_activations(x: torch.Tensor, embed: torch.Tensor, num_groups: int) -> torch.Tensor:
+    grouped = _reshape_to_grouped_subtokens(x, num_groups)
+    return torch.einsum("tgd,d->tg", grouped, embed)
+
+
+def _reconstruct_activations(
+    compressed: torch.Tensor,
+    embed: torch.Tensor,
+    in_features: int,
+    velora_scale: float,
+) -> torch.Tensor:
+    grouped = compressed.unsqueeze(-1) * embed.view(1, 1, -1)
+    reconstructed = grouped.reshape(-1, compressed.shape[-1] * embed.numel())
+    return reconstructed[:, :in_features] * velora_scale
+
+
+def _normalize_projection(embed: torch.Tensor) -> torch.Tensor:
+    embed = embed.float()
+    norm = torch.linalg.vector_norm(embed)
+    if norm == 0:
+        embed = torch.ones_like(embed)
+        norm = torch.linalg.vector_norm(embed)
+    return embed / norm
+
+
+class VeloraFunction(torch.autograd.Function):
+    @staticmethod
+    def forward(
+        ctx,
+        input: torch.Tensor,
+        weight: torch.Tensor,
+        bias: Optional[torch.Tensor],
+        embed: torch.Tensor,
+        num_groups: int,
+        velora_scale: float,
+    ) -> torch.Tensor:
+        output = F.linear(input, weight, bias)
+
+        ctx.input_shape = tuple(input.shape)
+        ctx.input_dtype = input.dtype
+        ctx.in_features = input.shape[-1]
+        ctx.num_groups = num_groups
+        ctx.velora_scale = velora_scale
+        ctx.bias_dtype = None if bias is None else bias.dtype
+
+        compressed = _compress_activations(input, embed.to(dtype=input.dtype), num_groups)
+        ctx.save_for_backward(compressed, weight, embed)
+        return output
+
+    @staticmethod
+    def backward(ctx, grad_output: torch.Tensor):
+        compressed, weight, embed = ctx.saved_tensors
+        compute_dtype = grad_output.dtype
+
+        grad_output_2d = grad_output.reshape(-1, grad_output.shape[-1]).to(compute_dtype)
+        weight_compute = weight.to(compute_dtype)
+
+        grad_input = grad_weight = grad_bias = None
+
+        if ctx.needs_input_grad[0]:
+            grad_input = grad_output_2d @ weight_compute
+            grad_input = grad_input.reshape(ctx.input_shape).to(dtype=ctx.input_dtype)
+
+        if ctx.needs_input_grad[1]:
+            reconstructed = _reconstruct_activations(
+                compressed.to(compute_dtype),
+                embed.to(compute_dtype),
+                ctx.in_features,
+                ctx.velora_scale,
+            )
+            grad_weight = grad_output_2d.transpose(0, 1) @ reconstructed
+            grad_weight = grad_weight.to(dtype=weight.dtype)
+
+        if ctx.needs_input_grad[2]:
+            grad_bias = grad_output_2d.sum(dim=0)
+            grad_bias = grad_bias.to(dtype=ctx.bias_dtype)
+
+        return grad_input, grad_weight, grad_bias, None, None, None
diff --git a/src/peft/tuners/lycoris_utils.py b/src/peft/tuners/lycoris_utils.py
new file mode 100644
index 0000000..b25a17a
--- /dev/null
+++ b/src/peft/tuners/lycoris_utils.py
@@ -0,0 +1,261 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import warnings
+from abc import abstractmethod
+from dataclasses import dataclass, field
+from typing import Any, Optional, Union
+
+import torch
+from torch import nn
+
+from peft.config import PeftConfig
+
+from .tuners_utils import (
+    BaseTuner,
+    BaseTunerLayer,
+    _get_in_out_features,
+    check_adapters_to_merge,
+)
+
+
+@dataclass
+class LycorisConfig(PeftConfig):
+    r"""
+    A base config for LyCORIS like adapters
+    """
+
+    rank_pattern: Optional[dict] = field(
+        default_factory=dict,
+        metadata={
+            "help": (
+                "The mapping from layer names or regexp expression to ranks which are different from the default rank specified by `r`. "
+                "For example, `{'^model.decoder.layers.0.encoder_attn.k_proj': 16}`."
+            )
+        },
+    )
+    alpha_pattern: Optional[dict] = field(
+        default_factory=dict,
+        metadata={
+            "help": (
+                "The mapping from layer names or regexp expression to alphas which are different from the default alpha specified by `alpha`. "
+                "For example, `{'^model.decoder.layers.0.encoder_attn.k_proj': 16}`."
+            )
+        },
+    )
+
+
+class LycorisLayer(BaseTunerLayer):
+    r"""
+    A base layer for LyCORIS like adapters
+    """
+
+    # adapter_layer_names needs to be defined on the child class
+    other_param_names = ("r", "alpha", "scaling", "rank_dropout", "rank_dropout_scale", "module_dropout")
+
+    def __init__(self, base_layer: nn.Module) -> None:
+        self.base_layer = base_layer
+        self.r = {}
+        self.alpha = {}
+        self.scaling = {}
+        self.rank_dropout = {}
+        self.rank_dropout_scale = {}
+        self.module_dropout = {}
+
+        # Tuner info
+        self._disable_adapters = False
+        self.merged_adapters = []
+        # flag to enable/disable casting of input to weight dtype during forward call
+        self.cast_input_dtype_enabled = True
+
+        in_features, out_features = _get_in_out_features(self.get_base_layer())
+        self.in_features = in_features
+        self.out_features = out_features
+
+    @property
+    @abstractmethod
+    def _available_adapters(self) -> set[str]: ...
+
+    def _init_empty_weights(self, cls, *args, **kwargs) -> None:
+        # A helper method that allows to initialize the layer of the given class without spending time to initialize the
+        # model weights. The implementation is inspired by
+        # https://pytorch.org/docs/stable/generated/torch.nn.utils.skip_init.html but this function cannot be used
+        # directly.
+        # Instead of this approach, it would be possible to bypass the __init__ of the class but that runs the risk of
+        # omitting important logic inside that __init__.
+        kwargs = kwargs.copy()
+        final_device = kwargs.pop("device", "cpu")
+        cls.__init__(self, *args, device="meta", **kwargs)
+        self.to_empty(device=final_device)
+
+    @abstractmethod
+    def create_adapter_parameters(self, adapter_name: str, r: int, **kwargs): ...
+
+    # TODO: refactor LoRA to use the same approach
+    @abstractmethod
+    def _get_delta_activations(self, adapter_name: str, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        """Activations added on top of the base layer output (i.e. after the base layer forward pass)"""
+
+    @abstractmethod
+    def get_delta_weight(self, adapter_name: str) -> torch.Tensor: ...
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If `True`, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If `None`, all active adapters will be merged.
+                Defaults to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self._available_adapters:
+                base_layer = self.get_base_layer()
+                if safe_merge:
+                    orig_weights = base_layer.weight.data.clone()
+                    orig_weights += self.get_delta_weight(active_adapter)
+
+                    if not torch.isfinite(orig_weights).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = orig_weights
+                else:
+                    base_layer.weight.data += self.get_delta_weight(active_adapter)
+                self.merged_adapters.append(active_adapter)
+
+    @abstractmethod
+    def reset_adapter_parameters(self, adapter_name: str): ...
+
+    def set_scale(self, adapter, scale):
+        if adapter not in self._available_adapters:
+            # Ignore the case where the adapter is not in the layer
+            return
+        self.scaling[adapter] = scale * self.alpha[adapter] / self.r[adapter]
+
+    def scale_layer(self, scale: float) -> None:
+        if scale == 1:
+            return
+
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self._available_adapters:
+                continue
+
+            self.scaling[active_adapter] *= scale
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self._available_adapters:
+                self.get_base_layer().weight.data -= self.get_delta_weight(active_adapter)
+
+    def unscale_layer(self, scale=None) -> None:
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self._available_adapters:
+                continue
+
+            if scale is None:
+                self.scaling[active_adapter] = self.alpha[active_adapter] / self.r[active_adapter]
+            else:
+                self.scaling[active_adapter] /= scale
+
+    @abstractmethod
+    def update_layer(self, adapter_name: str, r: int, alpha: float, **kwargs): ...
+
+
+class LycorisTuner(BaseTuner):
+    r"""
+    A base tuner for LyCORIS like adapters
+
+    Args:
+        model ([`torch.nn.Module`]): The model to be adapted.
+        config ([`LoraConfig`]): The configuration of the Lora model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            Create empty adapter weights on meta device. Useful to speed up the loading process.
+
+    """
+
+    prefix: str
+    tuner_layer_cls = LycorisLayer
+    layers_mapping: dict[type[torch.nn.Module], type[LycorisLayer]]
+
+    @abstractmethod
+    def _create_and_replace(
+        self,
+        config: LycorisConfig,
+        adapter_name: str,
+        target: Union[LycorisLayer, nn.Module],
+        target_name,
+        parent,
+        current_key,
+    ): ...
+
+    @classmethod
+    def _create_new_module(cls, config: LycorisConfig, adapter_name: str, target: nn.Module, **kwargs) -> LycorisLayer:
+        # Find corresponding subtype of provided target module
+        new_module_cls = None
+        for subtype, target_cls in cls.layers_mapping.items():
+            if (
+                hasattr(target, "base_layer")
+                and isinstance(target.get_base_layer(), subtype)
+                and isinstance(target, BaseTunerLayer)
+            ):
+                # nested tuner layers are allowed
+                new_module_cls = target_cls
+                break
+            elif isinstance(target, subtype):
+                new_module_cls = target_cls
+                break
+
+        # We didn't find corresponding type, so adapter for this layer is not supported
+        if new_module_cls is None:
+            supported_modules = ", ".join(layer.__name__ for layer in cls.layers_mapping.keys())
+            raise TypeError(
+                f"Target module of type {type(target)} not supported, "
+                f"currently only adapters for {supported_modules} are supported"
+            )
+
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        if isinstance(target_base_layer, (torch.nn.Conv2d, torch.nn.Conv1d, torch.nn.Linear)):
+            new_module = new_module_cls(target, adapter_name=adapter_name, config=config, **kwargs)
+        else:
+            supported_modules = ", ".join(layer.__name__ for layer in cls.layers_mapping.keys())
+            raise TypeError(
+                f"Target module of type {type(target)} not supported, "
+                f"currently only adapters for {supported_modules} are supported"
+            )
+
+        return new_module
diff --git a/src/peft/tuners/miss/__init__.py b/src/peft/tuners/miss/__init__.py
new file mode 100644
index 0000000..ca8acee
--- /dev/null
+++ b/src/peft/tuners/miss/__init__.py
@@ -0,0 +1,24 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from peft.utils import register_peft_method
+
+from .config import MissConfig
+from .layer import MissLayer, MissLinear
+from .model import MissModel
+
+
+__all__ = ["MissConfig", "MissLayer", "MissLinear", "MissModel"]
+
+register_peft_method(name="miss", config_cls=MissConfig, model_cls=MissModel)
diff --git a/src/peft/tuners/miss/config.py b/src/peft/tuners/miss/config.py
new file mode 100644
index 0000000..302c745
--- /dev/null
+++ b/src/peft/tuners/miss/config.py
@@ -0,0 +1,142 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal, Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class MissConfig(PeftConfig):
+    """
+    This is the configuration class to store the configuration of a [`MissModel`].
+
+    Args:
+        r (`int`):
+            The rank of MiSS across different layers. It is best to set 'r' to an even number; otherwise, the default
+            initialization method will not work. The rank of MiSS corresponds to a low-rank decomposition along the
+            in_features dimension.
+        miss_dropout (`float`):
+            The dropout probability for MiSS layers.
+        mini_r (`int`):
+            The rank of MiSS corresponds to a low-rank decomposition along the out_features dimension. When you set
+            `init_weights=mini`, you need to set `mini_r`. Please make sure that `out_features` is divisible by
+            `mini_r`.
+        target_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to apply the adapter to. If this is specified, only the modules with the specified
+            names will be replaced. When passing a string, a regex match will be performed. When passing a list of
+            strings, either an exact match will be performed or it is checked if the name of the module ends with any
+            of the passed strings. If this is specified as 'all-linear', then all linear modules are chosen, excluding
+            the output layer. If this is not specified, modules will be chosen according to the model architecture. If
+            the architecture is not known, an error will be raised -- in this case, you should specify the target
+            modules manually.
+        exclude_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to not apply the adapter. When passing a string, a regex match will be performed.
+            When passing a list of strings, either an exact match will be performed or it is checked if the name of the
+            module ends with any of the passed strings.
+        init_weights (bool | Literal["bat", "mini"]):
+            Different initializations correspond to different MiSS variants. By default(balance), the most efficient
+            and general method in MiSS will be used. 'bat': In this mode, you can enable nonlinear updates across
+            different shards. 'mini': In this mode, you can set a smaller rank to use fewer trainable parameters, but
+            it is recommended to keep `out_features % mini_r == 0`.
+        layers_to_transform (`Union[List[int], int]`):
+            The layer indices to transform. If a list of ints is passed, it will apply the adapter to the layer indices
+            that are specified in this list. If a single integer is passed, it will apply the transformations on the
+            layer at this index.
+        layers_pattern (`str`):
+            The layer pattern name, used only if `layers_to_transform` is different from `None`.
+        bias (`str`):
+            Bias type for MiSS. Can be `'none'`, `'all'` or `'MiSS_only'`.
+        modules_to_save (`List[str]`):
+            List of modules apart from adapter layers to be set as trainable and saved in the final checkpoint.
+    """
+
+    r: int = field(
+        default=64,
+        metadata={
+            "help": "The rank of MiSS corresponds to a low-rank decomposition along the in_features dimension.",
+            "note": "It is best to set 'r' to an even number; otherwise, the default initialization method will not work.",
+        },
+    )
+    miss_dropout: float = field(default=0.0, metadata={"help": "MiSS dropout"})
+    mini_r: int = field(
+        default=1,
+        metadata={
+            "help": "The rank of MiSS corresponds to a low-rank decomposition along the out_features dimension.",
+            "note": "It is recommended that mini_r be divisible by out_features. When mini_r == out_features, the mini method is equivalent to the default efficient MiSS.",
+        },
+    )
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": "List of module names or regex expression of the module names to replace with MiSS.",
+            "example": "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$' ",
+        },
+    )
+    exclude_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={"help": "List of module names or regex expression of the module names to exclude from MiSS."},
+    )
+    init_weights: bool | Literal["bat", "mini"] = field(
+        default=True,
+        metadata={
+            "help": (
+                "True -> MiSS balance; `bat` -> Bat; `mini` -> smaller rank and efficiency"
+                "Whether to initialize the weights of the MiSS layers with their default initialization. Don't change "
+                "this setting, except if you know exactly what you're doing."
+            ),
+        },
+    )
+    layers_to_transform: Optional[Union[list[int], int]] = field(
+        default=None,
+        metadata={
+            "help": "The layer indexes to transform, is this argument is specified, PEFT will transform only the layers indexes that are specified inside this list. If a single integer is passed, PEFT will transform only the layer at this index."
+        },
+    )
+    layers_pattern: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "The layer pattern name, used only if `layers_to_transform` is different to None and if the layer pattern is not in the common layers pattern."
+        },
+    )
+    bias: str = field(default="none", metadata={"help": "Bias type for MiSS. Can be 'none', 'all' or 'MiSS_only'"})
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": "List of modules apart from MiSS layers to be set as trainable and saved in the final checkpoint. "
+            "For example, in Sequence Classification or Token Classification tasks, "
+            "the final layer `classifier/score` are randomly initialized and as such need to be trainable and saved."
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.MISS
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        self.exclude_modules = (
+            set(self.exclude_modules) if isinstance(self.exclude_modules, list) else self.exclude_modules
+        )
+        # if target_modules is a regex expression, then layers_to_transform should be None
+        if isinstance(self.target_modules, str) and self.layers_to_transform is not None:
+            raise ValueError("`layers_to_transform` cannot be used when `target_modules` is a str.")
+
+        # if target_modules is a regex expression, then layers_pattern should be None
+        if isinstance(self.target_modules, str) and self.layers_pattern is not None:
+            raise ValueError("`layers_pattern` cannot be used when `target_modules` is a str.")
diff --git a/src/peft/tuners/miss/layer.py b/src/peft/tuners/miss/layer.py
new file mode 100644
index 0000000..3bfa61a
--- /dev/null
+++ b/src/peft/tuners/miss/layer.py
@@ -0,0 +1,377 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import math
+import warnings
+from typing import Any, Optional
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from peft.tuners.tuners_utils import BaseTunerLayer, _get_in_out_features, check_adapters_to_merge
+from peft.utils import quantization_extra_repr, resolve_quantization_backend
+
+from .config import MissConfig
+
+
+class MissLayer(BaseTunerLayer):
+    # All names of layers that may contain (trainable) adapter weights
+    adapter_layer_names = ("miss_block",)
+    # All names of other parameters that may contain adapter-related parameters
+    other_param_names = ("miss_r", "miss_dropout", "miss_mini_r")
+
+    def __init__(self, base_layer: nn.Module, **kwargs) -> None:
+        self.base_layer = base_layer
+        self.quantization_backend = resolve_quantization_backend(
+            self.get_base_layer(), get_apply_tensor_subclass=kwargs.get("get_apply_tensor_subclass")
+        )
+        self.miss_r = {}
+        self.miss_dropout = nn.ModuleDict({})
+        self.miss_mini_r = {}
+        self.miss_block = nn.ParameterDict({})
+        # Mark the weight as unmerged
+        self._disable_adapters = False
+        self.merged_adapters = []
+        # flag to enable/disable casting of input to weight dtype during forward call
+        self.cast_input_dtype_enabled = True
+        self.kwargs = kwargs
+
+        base_layer = self.get_base_layer()
+        in_features, out_features = _get_in_out_features(base_layer)
+        if (in_features is None) or (out_features is None):
+            raise TypeError(f"Unsupported layer type {type(base_layer)}")
+        self.in_features, self.out_features = in_features, out_features
+
+    def update_layer(
+        self,
+        adapter_name: str,
+        r: int,
+        config: MissConfig,
+        inference_mode: bool = False,
+        **kwargs,
+    ) -> None:
+        """Internal function to create miss adapter
+
+        Args:
+            adapter_name (`str`): Name for the adapter to add.
+            r (`int`): Rank for the added adapter.
+            init_weights (`bool`): Whether to initialize weights.
+        """
+        mini_r = config.mini_r
+        miss_dropout = config.miss_dropout
+        init_weights = config.init_weights
+
+        if r <= 0:
+            raise ValueError(f"`r` should be a positive integer value but the value passed is {r}")
+
+        self.miss_r[adapter_name] = r
+        self.miss_mini_r[adapter_name] = mini_r
+        if miss_dropout > 0.0:
+            miss_dropout_layer = nn.Dropout(p=miss_dropout)
+        else:
+            miss_dropout_layer = nn.Identity()
+
+        self.miss_dropout[adapter_name] = miss_dropout_layer
+
+        # Determine shape of MiSS weights; supportedness was already validated in __init__ and the model dispatcher.
+        self.miss_block[adapter_name] = nn.Parameter(torch.zeros(r, self.out_features), requires_grad=True)
+
+        # Initialize weights
+        if init_weights == "bat":
+            if self.in_features % r != 0 or self.out_features % r != 0:
+                raise ValueError("The weight matrix must be fully divisible into [r, r] blocks.")
+            self.reset_bat_parameters(adapter_name, r)
+        elif init_weights == "mini":
+            if self.out_features % mini_r != 0:
+                raise ValueError(
+                    "mini_r is divided along the out_features dimension. For optimal performance and implementation simplicity,"
+                    "it is recommended that out_features be divisible by mini_r."
+                    "Error: {self.out_features} % mini_r != 0"
+                )
+            self.reset_mini_parameters(adapter_name, r, mini_r)
+        elif init_weights:
+            self.reset_miss_parameters(adapter_name, r)
+        else:
+            self.reset_miss_parameters_random(adapter_name)
+        # Move new weights to device
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def reset_miss_parameters(self, adapter_name: str, r):
+        self.miss_block[adapter_name] = nn.Parameter(torch.zeros(r, self.out_features), requires_grad=True)
+
+    def reset_bat_parameters(self, adapter_name: str, r):
+        self.miss_block[adapter_name] = nn.Parameter(torch.zeros(self.out_features // r, r, r), requires_grad=True)
+
+    def reset_mini_parameters(self, adapter_name: str, r, mini_r):
+        self.miss_block[adapter_name] = nn.Parameter(torch.zeros(r, mini_r), requires_grad=True)
+
+    def reset_miss_parameters_random(self, adapter_name: str):
+        nn.init.kaiming_uniform_(self.miss_block[adapter_name], a=math.sqrt(5))
+
+    def scale_layer(self, scale: float) -> None:
+        if scale == 1:
+            return
+
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self.miss_block.keys():
+                continue
+
+            warnings.warn("Scaling operation for MiSS not supported! Automatically set scale to 1.")
+
+    def unscale_layer(self, scale=None) -> None:
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self.miss_block.keys():
+                continue
+
+            warnings.warn("Unscaling operation for MiSS not supported! Keeping scale at 1.")
+
+
+class MissLinear(nn.Module, MissLayer):
+    """
+    MiSS implemented in a dense layer.
+    """
+
+    def __init__(
+        self,
+        base_layer,
+        adapter_name: str,
+        config: MissConfig,
+        r: int = 0,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        MissLayer.__init__(self, base_layer, **kwargs)
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, r, config=config, **kwargs)
+        self.miss_fn = config.init_weights
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If `True`, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If `None`, all active adapters will be merged.
+                Defaults to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.miss_block.keys():
+                base_layer = self.get_base_layer()
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    # because of the copy operation.
+                    weight = self.get_base_weight().clone()
+                    orig_dtype = weight.dtype
+                    if self.miss_fn == "bat":
+                        weight += self.get_delta_weight(active_adapter, weight)
+                    else:
+                        weight = self.get_delta_weight_miss(active_adapter, weight)
+
+                    if not torch.isfinite(weight).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    self.set_base_weight(weight.to(orig_dtype))
+                else:
+                    weight = self.get_base_weight()
+                    orig_dtype = weight.dtype
+                    if self.miss_fn == "bat":
+                        weight += self.get_delta_weight(active_adapter, weight)
+                    else:
+                        weight = self.get_delta_weight_miss(active_adapter, weight)
+                    self.set_base_weight(weight.to(orig_dtype))
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            base_layer = self.get_base_layer()
+            if active_adapter in self.miss_block.keys():
+                weight = self.get_base_weight()
+                orig_dtype = weight.dtype
+                if self.miss_fn == "bat":
+                    weight = self.get_delta_weight(active_adapter, weight, reverse=True)
+                elif self.miss_fn == "mini":
+                    weight = self.get_delta_weight_miss(active_adapter, weight, reverse=True)
+                else:
+                    weight = self.get_delta_weight_miss(active_adapter, weight, reverse=True)
+
+                self.set_base_weight(weight.to(orig_dtype))
+
+    def get_delta_weight(self, adapter, orig_weight, reverse: bool = False) -> torch.Tensor:
+        """
+        Compute the delta weight for the given adapter.
+
+        Args:
+            adapter (`str`):
+                The name of the adapter for which the delta weight should be computed.
+            reverse (bool):
+                If True, reverse the merge (unmerge). If False, apply the merge (forward).
+        """
+        device = self.miss_block[adapter].device
+        dtype = self.miss_block[adapter].dtype
+        # In case users wants to merge the adapter weights that are in
+        # (b)float16 while being on CPU, we need to cast the weights to float32, perform the merge and then cast back to
+        # (b)float16 because some CPUs have slow bf16/fp16 matmuls.
+        cast_to_fp32 = device.type == "cpu" and (dtype == torch.float16 or dtype == torch.bfloat16)
+
+        miss_B = self.miss_block[adapter]
+
+        if cast_to_fp32:
+            miss_B = miss_B.float()
+        orig_weight = orig_weight.to(miss_B.dtype)
+
+        r = miss_B.size(-1)
+        W = orig_weight.reshape(orig_weight.size(0) // r, r, orig_weight.size(1) // r, r).permute(2, 0, 1, 3)
+
+        if reverse:
+            eye = torch.eye(r, device=miss_B.device, dtype=torch.float32)
+            inv_I_plus_miss_B = torch.inverse(eye + miss_B.float()).to(miss_B.dtype)
+            result = (W - miss_B) @ inv_I_plus_miss_B
+        else:
+            result = W @ miss_B + miss_B
+
+        output_tensor = result.permute(1, 2, 0, 3).reshape(*orig_weight.shape)
+
+        if cast_to_fp32:
+            output_tensor = output_tensor.to(dtype=dtype)
+            self.miss_block[adapter].data = miss_B.to(dtype)
+
+        return output_tensor
+
+    def get_delta_weight_miss(self, adapter, orig_weight, reverse: bool = False) -> torch.Tensor:
+        """
+        Compute the *full* weight for the given adapter (not the weight delta!)
+
+        Args:
+            adapter (str):
+                The name of the adapter for which the delta weight should be computed.
+            reverse (bool):
+                If True, reverse the merge (unmerge). If False, apply the merge (forward).
+        """
+        device = self.miss_block[adapter].device
+        dtype = self.miss_block[adapter].dtype
+        # In case users wants to merge the adapter weights that are in
+        # (b)float16 while being on CPU, we need to cast the weights to float32, perform the merge and then cast back to
+        # (b)float16 because some CPUs have slow bf16/fp16 matmuls.
+        cast_to_fp32 = device.type == "cpu" and (dtype == torch.float16 or dtype == torch.bfloat16)
+
+        miss_B = self.miss_block[adapter]
+
+        if cast_to_fp32:
+            miss_B = miss_B.float()
+
+        in_features = orig_weight.size(-1)
+        out_features = orig_weight.size(0)
+        r = miss_B.size(0)
+        if self.miss_fn == "mini":
+            miss_B = miss_B.repeat(1, out_features // self.miss_mini_r[adapter])
+
+        sign = -1 if reverse else 1
+
+        if in_features % r != 0:
+            remainder = in_features % r
+            n_blocks = in_features // r
+            aligned_size = n_blocks * r
+
+            W_aligned = orig_weight[:, :aligned_size].reshape(-1, n_blocks, r).permute(1, 2, 0)
+            orig_weight[:, :aligned_size] = (
+                (W_aligned + sign * miss_B).permute(2, 0, 1).reshape(*orig_weight[:, :aligned_size].shape)
+            )
+            orig_weight[:, aligned_size:] = (
+                orig_weight[:, aligned_size:] + sign * miss_B.transpose(0, 1)[:, :remainder]
+            )
+            output_tensor = orig_weight
+        else:
+            W_blocks = orig_weight.reshape(-1, orig_weight.size(1) // r, r).permute(1, 2, 0)
+            output_tensor = (W_blocks + sign * miss_B).permute(2, 0, 1).reshape(*orig_weight.shape)
+
+        if cast_to_fp32:
+            output_tensor = output_tensor.to(dtype=dtype)
+            self.miss_block[adapter].data = miss_B.to(dtype)
+
+        return output_tensor
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        previous_dtype = x.dtype
+
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            if self.miss_fn == "bat":
+                orig_weight = self.get_base_weight().clone()
+                for active_adapter in self.active_adapters:
+                    if active_adapter not in self.miss_block.keys():
+                        continue
+                    delta_weight = self.get_delta_weight(active_adapter, orig_weight)
+                    orig_weight = orig_weight + delta_weight
+
+                x = self._cast_input_dtype(x, orig_weight.dtype)
+                bias = self._cast_input_dtype(self.base_layer.bias, orig_weight.dtype)
+                result = F.linear(input=x, weight=orig_weight, bias=bias)
+            else:
+                result = self.base_layer(x, *args, **kwargs)
+                if self.quantization_backend is not None:
+                    result = self.quantization_backend.maybe_clone_base_result(result)
+                for active_adapter in self.active_adapters:
+                    if active_adapter not in self.miss_block.keys():
+                        continue
+                    miss = self.miss_block[active_adapter]
+                    if self.miss_fn == "mini":
+                        miss = miss.repeat(1, self.base_layer.out_features // self.miss_mini_r[active_adapter])
+
+                    dropout = self.miss_dropout[active_adapter]
+                    r = miss.size(0)
+                    if x.size(-1) % r != 0:
+                        padding_size = (r - x.size(-1) % r) % r
+                        x = F.pad(x, (0, padding_size))
+                    x = self._cast_input_dtype(x, miss.dtype)
+                    result = result + torch.sum(dropout(x).reshape(*x.shape[:-1], x.size(-1) // r, r), dim=-2) @ miss
+
+        result = result.to(previous_dtype)
+        return result
+
+    def supports_lora_conversion(self, adapter_name: str = "default") -> bool:
+        return True
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "miss." + rep
+
+    def extra_repr(self) -> str:
+        return quantization_extra_repr(self)
diff --git a/src/peft/tuners/miss/model.py b/src/peft/tuners/miss/model.py
new file mode 100644
index 0000000..3401011
--- /dev/null
+++ b/src/peft/tuners/miss/model.py
@@ -0,0 +1,141 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+
+import torch
+
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer
+from peft.utils import (
+    TRANSFORMERS_MODELS_TO_MISS_TARGET_MODULES_MAPPING,
+    get_quantization_kwargs,
+    resolve_quantization_backend,
+)
+
+from .layer import MissLayer, MissLinear
+
+
+def _get_tuner_layer_class(target_base_layer: torch.nn.Module) -> type[MissLayer] | None:
+    layer_cls: type[MissLayer] | None = None
+    if isinstance(target_base_layer, torch.nn.Linear):
+        layer_cls = MissLinear
+    elif (quant_backend := resolve_quantization_backend(target_base_layer)) is not None:
+        layer_cls = {"linear": MissLinear}.get(quant_backend.layer_type)
+
+    return layer_cls
+
+
+class MissModel(BaseTuner):
+    """
+    Creates Householder reflection adaptation (MiSS) model from a pretrained model. The method is described in
+    https://huggingface.co/papers/2409.15371
+
+    Args:
+        model (`torch.nn.Module`): The model to which the adapter tuner layers will be attached.
+        config ([`MissConfig`]): The configuration of the MiSS model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            Create empty adapter weights on meta device. Useful to speed up the loading process.
+
+    Returns:
+        `torch.nn.Module`: The MiSS model.
+
+    Example:
+        ```py
+        >>> from diffusers import StableDiffusionPipeline
+        >>> from peft import MissModel, MissConfig
+
+        >>> config_te = MissConfig(
+        ...     r=8,
+        ...     target_modules=["k_proj", "q_proj", "v_proj", "out_proj", "fc1", "fc2"],
+        ...     init_weights=True,
+        ... )
+        >>> config_unet = MissConfig(
+        ...     r=8,
+        ...     target_modules=[
+        ...         "proj_in",
+        ...         "proj_out",
+        ...         "to_k",
+        ...         "to_q",
+        ...         "to_v",
+        ...         "to_out.0",
+        ...         "ff.net.0.proj",
+        ...         "ff.net.2",
+        ...     ],
+        ...     init_weights=True,
+        ... )
+
+        >>> model = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
+        >>> model.text_encoder = MissModel(model.text_encoder, config_te, "default")
+        >>> model.unet = MissModel(model.unet, config_unet, "default")
+        ```
+
+    **Attributes**:
+        - **model** ([`~torch.nn.Module`]) -- The model to be adapted.
+        - **peft_config** ([`MissConfig`]): The configuration of the MiSS model.
+    """
+
+    prefix: str = "miss_"
+    tuner_layer_cls = MissLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_MISS_TARGET_MODULES_MAPPING
+
+    def _create_and_replace(
+        self,
+        miss_config,
+        adapter_name,
+        target,
+        target_name,
+        parent,
+        current_key,
+        **optional_kwargs,
+    ):
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+
+        bias = hasattr(target, "bias") and target.bias is not None
+        kwargs = {
+            "r": miss_config.r,
+            "bias": bias,
+        }
+        kwargs.update(get_quantization_kwargs(self))
+
+        # If it is not a MissLayer, create a new module, else update it with new adapters
+        if not isinstance(target, MissLayer):
+            new_module = self._create_new_module(miss_config, adapter_name, target, **kwargs)
+            if adapter_name not in self.active_adapters:
+                # adding an additional adapter: it is not automatically trainable
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+        else:
+            target.update_layer(
+                adapter_name,
+                config=miss_config,
+                **kwargs,
+            )
+
+    @staticmethod
+    def _create_new_module(miss_config, adapter_name, target, **kwargs):
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        layer_cls = _get_tuner_layer_class(target_base_layer)
+        if layer_cls is None:
+            raise TypeError(
+                f"Target module {target} is not supported. Currently, only `torch.nn.Linear` (optionally quantized) "
+                "is supported."
+            )
+
+        new_module = layer_cls(target, adapter_name, config=miss_config, **kwargs)
+        return new_module
diff --git a/src/peft/tuners/mixed/__init__.py b/src/peft/tuners/mixed/__init__.py
new file mode 100644
index 0000000..2955d72
--- /dev/null
+++ b/src/peft/tuners/mixed/__init__.py
@@ -0,0 +1,18 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from .model import COMPATIBLE_TUNER_TYPES, MixedModel
+
+
+__all__ = ["COMPATIBLE_TUNER_TYPES", "MixedModel"]
diff --git a/src/peft/tuners/mixed/model.py b/src/peft/tuners/mixed/model.py
new file mode 100644
index 0000000..e249385
--- /dev/null
+++ b/src/peft/tuners/mixed/model.py
@@ -0,0 +1,313 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import warnings
+from itertools import pairwise
+from typing import Any, Optional, Union
+
+import torch
+from torch import nn
+from tqdm import tqdm
+
+from peft.tuners import adalora, loha, lokr, lora, oft, shira
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer, _delete_auxiliary_adapter
+from peft.utils import (
+    TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING,
+    ModulesToSaveWrapper,
+    PeftType,
+    _get_submodules,
+)
+from peft.utils.other import _set_adapter
+
+
+# Collection of constants used for all tuners
+COMPATIBLE_TUNER_TYPES = (PeftType.LORA, PeftType.LOHA, PeftType.LOKR, PeftType.ADALORA, PeftType.OFT, PeftType.SHIRA)
+PREFIXES = [
+    lora.LoraModel.prefix,
+    lokr.LoKrModel.prefix,
+    loha.LoHaModel.prefix,
+    oft.OFTModel.prefix,
+    shira.ShiraModel.prefix,
+]
+Configs = Union[
+    lora.LoraConfig, loha.LoHaConfig, lokr.LoKrConfig, adalora.AdaLoraConfig, oft.OFTConfig, shira.ShiraConfig
+]
+Layers = (
+    lora.layer.LoraLayer,
+    loha.layer.LoHaLayer,
+    lokr.layer.LoKrLayer,
+    adalora.layer.AdaLoraLayer,
+    oft.OFTLayer,
+    shira.ShiraLayer,
+)
+
+
+class MixedModel(BaseTuner):
+    """
+    A class that allows to mix different types of adapters in a single model.
+
+    Note: This class should usually not be initialized directly. Instead, use `get_peft_model` with the argument
+    `mixed=True`.
+
+    Args:
+        model (:obj:`nn.Module`):
+            The model to be tuned.
+        config (:obj:`PeftConfig`):
+            The config of the model to be tuned. The adapter type must be compatible.
+        adapter_name (:obj:`str`):
+            The name of the first adapter.
+    """
+
+    def __init__(self, model: nn.Module, config: Configs, adapter_name: str) -> None:
+        super().__init__(model, config, adapter_name)
+
+    def _check_new_adapter_config(self, config: Configs) -> None:
+        """
+        A helper method to check the config when a new adapter is being added.
+
+        Raise a ValueError if there is something wrong with the config or if it conflicts with existing adapters.
+
+        """
+        if not isinstance(config, Configs.__args__):
+            raise TypeError(
+                f"{self.__class__.__name__} only supports {COMPATIBLE_TUNER_TYPES} configs, but got {type(config)}."
+            )
+
+        super()._check_new_adapter_config(config)
+
+    def _create_and_replace(
+        self,
+        config: Configs,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        if isinstance(config, adalora.AdaLoraConfig):
+            adalora.AdaLoraModel._create_and_replace(self, config, *args, **kwargs)
+        elif isinstance(config, lora.LoraConfig):
+            lora.LoraModel._create_and_replace(self, config, *args, **kwargs)
+        elif isinstance(config, loha.LoHaConfig):
+            loha.LoHaModel._create_and_replace(self, config, *args, **kwargs)
+        elif isinstance(config, lokr.LoKrConfig):
+            lokr.LoKrModel._create_and_replace(self, config, *args, **kwargs)
+        elif isinstance(config, oft.OFTConfig):
+            oft.OFTModel._create_and_replace(self, config, *args, **kwargs)
+        elif isinstance(config, shira.ShiraConfig):
+            shira.ShiraModel._create_and_replace(self, config, *args, **kwargs)
+        else:
+            raise TypeError(f"Unsupported config type {type(config)}, should be one of {COMPATIBLE_TUNER_TYPES}.")
+
+    def _replace_module(self, parent, child_name, new_module, child) -> None:
+        setattr(parent, child_name, new_module)
+        # It's not necessary to set requires_grad here, as that is handled by
+        # _mark_only_adapters_as_trainable
+
+        # child layer wraps the original module, unpack it
+        if hasattr(child, "base_layer"):
+            child = child.get_base_layer()
+        elif hasattr(child, "quant_linear_module"):
+            # TODO maybe not necessary to have special treatment?
+            child = child.quant_linear_module
+
+        if not hasattr(new_module, "base_layer"):
+            new_module.weight = child.weight
+            if hasattr(child, "bias"):
+                new_module.bias = child.bias
+
+        if getattr(child, "state", None) is not None:
+            if hasattr(new_module, "base_layer"):
+                new_module.base_layer.state = child.state
+            else:
+                new_module.state = child.state
+            new_module.to(child.weight.device)
+
+        meta = torch.device("meta")
+        # dispatch to correct device
+        for name, module in new_module.named_modules():
+            if any(prefix in name for prefix in PREFIXES):
+                if hasattr(child, "qweight"):
+                    weight = child.qweight
+                elif hasattr(child, "W_q"):
+                    weight = child.W_q
+                elif hasattr(child, "weight"):
+                    weight = child.weight
+                elif getattr(child, "in_proj_weight", None) is not None:  # MHA
+                    weight = child.in_proj_weight
+                else:
+                    weight = next(child.parameters())
+
+                if not any(p.device == meta for p in module.parameters()):
+                    module.to(weight.device)
+
+    def _mark_only_adapters_as_trainable(self, model: nn.Module) -> None:
+        for n, p in model.named_parameters():
+            if not any(prefix in n for prefix in PREFIXES):
+                p.requires_grad = False
+
+        for active_adapter in self.active_adapters:
+            bias = getattr(self.peft_config[active_adapter], "bias", "none")
+            if bias == "none":
+                continue
+
+            if bias == "all":
+                for n, p in model.named_parameters():
+                    if "bias" in n:
+                        p.requires_grad = True
+            elif bias.endswith("_only"):  # e.g. "lora_only" or "oft_only"
+                for m in model.modules():
+                    if isinstance(m, Layers) and hasattr(m, "bias") and m.bias is not None:
+                        m.bias.requires_grad = True
+            else:
+                raise ValueError(f"Requested bias: {bias}, is not implemented.")
+
+    @staticmethod
+    def _create_new_module(config, adapter_name, target, **kwargs):
+        gptq_quantization_config = kwargs.get("gptq_quantization_config", None)
+        if gptq_quantization_config is not None:
+            raise ValueError(f"GPTQ quantization not supported for {config.peft_type.value} (yet).")
+
+        loaded_in_8bit = kwargs.pop("loaded_in_8bit", False)
+        loaded_in_4bit = kwargs.pop("loaded_in_4bit", False)
+        if loaded_in_8bit or loaded_in_4bit:
+            raise ValueError(f"8bit and 4bit quantization not supported for {config.peft_type.value} (yet).")
+
+        if isinstance(config, adalora.AdaLoraConfig):
+            new_module = adalora.AdaLoraModel._create_new_module(config, adapter_name, target, **kwargs)
+        elif isinstance(config, lora.LoraConfig):
+            new_module = lora.LoraModel._create_new_module(config, adapter_name, target, **kwargs)
+        elif isinstance(config, loha.LoHaConfig):
+            new_module = loha.LoHaModel._create_new_module(config, adapter_name, target, **kwargs)
+        elif isinstance(config, lokr.LoKrConfig):
+            new_module = lokr.LoKrModel._create_new_module(config, adapter_name, target, **kwargs)
+        elif isinstance(config, oft.OFTConfig):
+            new_module = oft.OFTModel._create_new_module(config, adapter_name, target, **kwargs)
+        elif isinstance(config, shira.ShiraConfig):
+            new_module = shira.ShiraModel._create_new_module(config, adapter_name, target, **kwargs)
+        else:
+            raise TypeError(f"Unknown config type {type(config)}, should be one of {COMPATIBLE_TUNER_TYPES}.")
+        return new_module
+
+    def set_adapter(self, adapter_name: Union[str, list[str]], inference_mode: bool = False) -> None:
+        _set_adapter(self, adapter_name, inference_mode=inference_mode)  # handle auxiliary modules
+        for module in self.model.modules():
+            if isinstance(module, Layers):
+                if module.merged:
+                    warnings.warn("Adapter cannot be set when the model is merged. Unmerging the model first.")
+                    module.unmerge()
+                module.set_adapter(adapter_name, inference_mode=inference_mode)
+        self.active_adapter = adapter_name
+
+    @staticmethod
+    def _prepare_adapter_config(peft_config, model_config):
+        if peft_config.target_modules is None:
+            if model_config["model_type"] not in TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING:
+                raise ValueError("Please specify `target_modules` in `peft_config`")
+
+            peft_config.target_modules = set(
+                TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING[model_config["model_type"]]
+            )
+        return peft_config
+
+    def _unload_and_optionally_merge(
+        self,
+        merge=True,
+        progressbar: bool = False,
+        safe_merge: bool = False,
+        adapter_names: Optional[list[str]] = None,
+    ):
+        if merge:
+            if getattr(self.model, "quantization_method", None) == "gptq":
+                raise ValueError("Cannot merge layers when the model is gptq quantized")
+
+        def merge_recursively(module):
+            # helper function to recursively merge the base_layer of the target
+            path = []
+            layer = module
+            while hasattr(layer, "base_layer"):
+                path.append(layer)
+                layer = layer.base_layer
+            for layer_before, layer_after in pairwise(path):
+                layer_after.merge(safe_merge=safe_merge, adapter_names=adapter_names)
+                layer_before.base_layer = layer_after.base_layer
+            module.merge(safe_merge=safe_merge, adapter_names=adapter_names)
+
+        key_list = [key for key, _ in self.model.named_modules() if not any(prefix in key for prefix in PREFIXES)]
+        desc = "Unloading " + ("and merging " if merge else "") + "model"
+
+        for key in tqdm(key_list, disable=not progressbar, desc=desc):
+            try:
+                parent, target, target_name = _get_submodules(self.model, key)
+            except AttributeError:
+                continue
+
+            if hasattr(target, "base_layer"):
+                if merge:
+                    merge_recursively(target)
+                self._replace_module(parent, target_name, target.get_base_layer(), target)
+            elif isinstance(target, ModulesToSaveWrapper):
+                # save any additional trainable modules part of `modules_to_save`
+                new_module = target.modules_to_save[target.active_adapter]
+                if hasattr(new_module, "base_layer"):
+                    # check if the module is itself a tuner layer
+                    if merge:
+                        new_module.merge(safe_merge=safe_merge, adapter_names=adapter_names)
+                    new_module = new_module.get_base_layer()
+                setattr(parent, target_name, new_module)
+
+        # Clean up peft_config from the model since all PEFT modules have been removed.
+        # This prevents spurious warnings when re-wrapping the model with get_peft_model().
+        if hasattr(self.model, "peft_config"):
+            del self.model.peft_config
+
+        return self.model
+
+    def add_weighted_adapter(self, *args: Any, **kwargs: Any) -> None:
+        raise NotImplementedError(f"Weighted adapters are not supported for {self.__class__.__name__} (yet).")
+
+    def delete_adapter(self, adapter_name: Union[str, list[str]]) -> None:
+        """
+        Deletes an existing adapter.
+
+        Args:
+            adapter_name (Union[str, list[str]]): Name of the adapter(s) to delete.
+        """
+        if isinstance(adapter_name, str):
+            adapter_names = [adapter_name]
+        else:
+            adapter_names = adapter_name
+
+        mismatched = set(adapter_names) - set(self.peft_config.keys())
+        if mismatched:
+            raise ValueError(
+                f"Adapter(s) {sorted(mismatched)} not found, available adapters: {sorted(self.peft_config.keys())}"
+            )
+
+        for adapter_to_delete in adapter_names:
+            del self.peft_config[adapter_to_delete]
+
+            key_list = [key for key, _ in self.model.named_modules() if not any(prefix in key for prefix in PREFIXES)]
+            new_adapter = None
+            for key in key_list:
+                _, target, _ = _get_submodules(self.model, key)
+                if isinstance(target, BaseTunerLayer):
+                    target.delete_adapter(adapter_to_delete)
+                    if new_adapter is None:
+                        new_adapter = target.active_adapters[:]
+
+        self.active_adapter = new_adapter or []
+        if adapter_to_delete in adapter_names:
+            _delete_auxiliary_adapter(self.model, adapter_to_delete, new_active_adapters=new_adapter)
+
+    def generate(self, *args: Any, **kwargs: Any):
+        return self.model.generate(*args, **kwargs)
diff --git a/src/peft/tuners/multitask_prompt_tuning/__init__.py b/src/peft/tuners/multitask_prompt_tuning/__init__.py
new file mode 100644
index 0000000..fe692a9
--- /dev/null
+++ b/src/peft/tuners/multitask_prompt_tuning/__init__.py
@@ -0,0 +1,25 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from peft.utils import register_peft_method
+
+from .config import MultitaskPromptTuningConfig, MultitaskPromptTuningInit
+from .model import MultitaskPromptEmbedding
+
+
+__all__ = ["MultitaskPromptEmbedding", "MultitaskPromptTuningConfig", "MultitaskPromptTuningInit"]
+
+register_peft_method(
+    name="multitask_prompt_tuning", config_cls=MultitaskPromptTuningConfig, model_cls=MultitaskPromptEmbedding
+)
diff --git a/src/peft/tuners/multitask_prompt_tuning/config.py b/src/peft/tuners/multitask_prompt_tuning/config.py
new file mode 100644
index 0000000..6cb2795
--- /dev/null
+++ b/src/peft/tuners/multitask_prompt_tuning/config.py
@@ -0,0 +1,62 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import enum
+from dataclasses import dataclass, field
+from typing import Optional, Union
+
+from peft.tuners.prompt_tuning import PromptTuningConfig
+from peft.utils import PeftType
+
+
+class MultitaskPromptTuningInit(str, enum.Enum):
+    # initialize prompt with text
+    TEXT = "TEXT"
+    # initialize prompt with random matrix
+    RANDOM = "RANDOM"
+    # average the prefix and column matrices obtained during source training
+    AVERAGE_SOURCE_TASKS = "AVERAGE_SOURCE_TASKS"
+    # pick prefix and column matrices for a particular task obtained during source training
+    EXACT_SOURCE_TASK = "EXACT_SOURCE_TASK"
+    # only use the prompt embeddings trained during source training
+    ONLY_SOURCE_SHARED = "ONLY_SOURCE_SHARED"
+
+
+@dataclass
+class MultitaskPromptTuningConfig(PromptTuningConfig):
+    prompt_tuning_init: Union[MultitaskPromptTuningInit, str] = field(
+        default=MultitaskPromptTuningInit.RANDOM,
+        metadata={
+            "help": (
+                "How to initialize the prompt tuning parameters. Can be one of TEXT, RANDOM, AVERAGE_SOURCE_TASKS, "
+                "EXACT_SOURCE_TASK, ONLY_SOURCE_SHARED."
+            ),
+        },
+    )
+    prompt_tuning_init_state_dict_path: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The path of source state dict. This is required when training the downstream target prompt from "
+                "the pretrained source prompt"
+            ),
+        },
+    )
+    prompt_tuning_init_task: Optional[int] = field(default=0, metadata={"help": "source task id for initialization"})
+    num_ranks: Optional[int] = field(default=1, metadata={"help": "ranks"})
+    num_tasks: Optional[int] = field(default=1, metadata={"help": "number of tasks"})
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.MULTITASK_PROMPT_TUNING
diff --git a/src/peft/tuners/multitask_prompt_tuning/model.py b/src/peft/tuners/multitask_prompt_tuning/model.py
new file mode 100644
index 0000000..20d9d49
--- /dev/null
+++ b/src/peft/tuners/multitask_prompt_tuning/model.py
@@ -0,0 +1,120 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import torch
+
+from peft.tuners.prompt_tuning import PromptEmbedding
+from peft.utils import TaskType
+from peft.utils.save_and_load import torch_load
+
+from .config import MultitaskPromptTuningConfig, MultitaskPromptTuningInit
+
+
+# This code is adapted for the paper: https://huggingface.co/papers/2303.02861 and
+# constitutes the work done at MIT-IBM Watson Research Lab.
+
+
+class MultitaskPromptEmbedding(PromptEmbedding):
+    def __init__(self, config: MultitaskPromptTuningConfig, word_embeddings):
+        super().__init__(config, word_embeddings)
+
+        self.num_tasks = config.num_tasks
+        self.num_ranks = config.num_ranks
+        self.num_virtual_tokens = config.num_virtual_tokens
+
+        self.num_transformer_submodules = config.num_transformer_submodules
+        if self.num_transformer_submodules is None:
+            self.num_transformer_submodules = 2 if config.task_type == TaskType.SEQ_2_SEQ_LM else 1
+
+        self.token_dim = config.token_dim
+
+        total_virtual_tokens = self.num_virtual_tokens * self.num_transformer_submodules
+
+        self.prefix_task_cols = torch.nn.Parameter(
+            torch.normal(
+                mean=0,
+                std=0.02,
+                size=(self.num_tasks, total_virtual_tokens, self.num_ranks),
+            )
+        )
+        self.prefix_task_rows = torch.nn.Parameter(
+            torch.normal(
+                mean=0,
+                std=0.02,
+                size=(self.num_tasks, self.num_ranks, self.token_dim),
+            )
+        )
+
+        if config.prompt_tuning_init in [
+            MultitaskPromptTuningInit.AVERAGE_SOURCE_TASKS,
+            MultitaskPromptTuningInit.EXACT_SOURCE_TASK,
+            MultitaskPromptTuningInit.ONLY_SOURCE_SHARED,
+        ]:
+            if config.prompt_tuning_init_state_dict_path is None:
+                raise ValueError(
+                    f"prompt_tuning_init_state_dict_path needs to be specified with {config.prompt_tuning_init} "
+                    "init method"
+                )
+
+            if config.prompt_tuning_init_state_dict_path.endswith(".safetensors"):
+                from safetensors.torch import load_file
+
+                state_dict: dict = load_file(config.prompt_tuning_init_state_dict_path)
+            else:
+                state_dict: dict = torch_load(
+                    config.prompt_tuning_init_state_dict_path,
+                    map_location=word_embeddings.weight.device,
+                )
+
+        if config.prompt_tuning_init in [
+            MultitaskPromptTuningInit.AVERAGE_SOURCE_TASKS,
+            MultitaskPromptTuningInit.EXACT_SOURCE_TASK,
+        ]:
+            prefix_task_cols_: torch.Tensor = state_dict["prefix_task_cols"]
+            prefix_task_rows_: torch.Tensor = state_dict["prefix_task_rows"]
+
+            if config.prompt_tuning_init == MultitaskPromptTuningInit.AVERAGE_SOURCE_TASKS:
+                prefix_task_cols_ = prefix_task_cols_.mean(0, keepdim=True)
+                prefix_task_rows_ = prefix_task_rows_.mean(0, keepdim=True)
+            elif config.prompt_tuning_init == MultitaskPromptTuningInit.EXACT_SOURCE_TASK:
+                prefix_task_cols_ = prefix_task_cols_[config.prompt_tuning_init_task, ...].unsqueeze(0)
+                prefix_task_rows_ = prefix_task_rows_[config.prompt_tuning_init_task, ...].unsqueeze(0)
+
+            state_dict = {
+                "embedding.weight": state_dict["prompt_embeddings"],
+                "prefix_task_cols": prefix_task_cols_,
+                "prefix_task_rows": prefix_task_rows_,
+            }
+
+            self.load_state_dict(state_dict, strict=True)
+        elif config.prompt_tuning_init == MultitaskPromptTuningInit.ONLY_SOURCE_SHARED:
+            state_dict = {
+                "embedding.weight": state_dict["prompt_embeddings"],
+            }
+
+            self.load_state_dict(state_dict, strict=False)
+
+    def forward(self, indices, task_ids):
+        if task_ids is None:
+            raise ValueError("task_ids cannot be None")
+
+        prompt_embeddings = self.embedding(indices)
+
+        task_cols = torch.index_select(self.prefix_task_cols, 0, task_ids)
+        task_rows = torch.index_select(self.prefix_task_rows, 0, task_ids)
+        task_prompts = torch.matmul(task_cols, task_rows)
+
+        prompt_embeddings *= task_prompts
+
+        return prompt_embeddings
diff --git a/src/peft/tuners/oft/__init__.py b/src/peft/tuners/oft/__init__.py
new file mode 100644
index 0000000..32e21e3
--- /dev/null
+++ b/src/peft/tuners/oft/__init__.py
@@ -0,0 +1,52 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available, is_eetq_available
+from peft.utils import register_peft_method
+
+from .config import OFTConfig
+from .gptq import GPTQOFTLinear
+from .layer import Conv2d, Linear, OFTLayer
+from .model import OFTModel
+
+
+__all__ = [
+    "Conv2d",
+    "GPTQOFTLinear",
+    "Linear",
+    "OFTConfig",
+    "OFTLayer",
+    "OFTModel",
+]
+
+register_peft_method(name="oft", config_cls=OFTConfig, model_cls=OFTModel)
+
+
+def __getattr__(name):
+    if (name == "Linear8bitLt") and is_bnb_available():
+        from .bnb import Linear8bitLt
+
+        return Linear8bitLt
+
+    if (name == "Linear4bit") and is_bnb_4bit_available():
+        from .bnb import Linear4bit
+
+        return Linear4bit
+
+    if (name == "EetqOFTLinear") and is_eetq_available():
+        from .eetq import EetqOFTLinear
+
+        return EetqOFTLinear
+
+    raise AttributeError(f"module {__name__} has no attribute {name}")
diff --git a/src/peft/tuners/oft/aqlm.py b/src/peft/tuners/oft/aqlm.py
new file mode 100644
index 0000000..42d967b
--- /dev/null
+++ b/src/peft/tuners/oft/aqlm.py
@@ -0,0 +1,92 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from typing import Any, Optional
+
+import torch
+
+from peft.import_utils import is_aqlm_available
+from peft.tuners.oft.layer import OFTLayer
+from peft.tuners.tuners_utils import BaseTunerLayer
+
+from .config import OFTConfig
+
+
+if is_aqlm_available():
+    from aqlm import QuantizedLinear
+
+
+class AqlmOFTLinear(torch.nn.Module, OFTLayer):
+    def __init__(
+        self,
+        base_layer,
+        adapter_name: str,
+        config: OFTConfig,
+        r: int = 0,
+        **kwargs,
+    ):
+        super().__init__()
+        OFTLayer.__init__(self, base_layer)
+
+        self._active_adapter = adapter_name
+        self.update_layer(
+            adapter_name,
+            r,
+            config=config,
+        )
+
+    def forward(self, x: torch.Tensor):
+        # note: logic differs from default Linear because merging is not supported
+        if self.disable_adapters:
+            return self.base_layer(x)
+
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self.oft_R.keys():
+                continue
+            oft_R = self.oft_R[active_adapter]
+
+            requires_conversion = not torch.is_autocast_enabled()
+            if requires_conversion:
+                expected_dtype = x.dtype
+                x = self._cast_input_dtype(x, oft_R.weight.dtype)
+
+            x = oft_R(x)
+
+        result = self.base_layer(x)
+        if requires_conversion:
+            result = result.to(expected_dtype)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "oft." + rep
+
+
+def dispatch_aqlm(
+    target: torch.nn.Module,
+    adapter_name: str,
+    **kwargs: Any,
+) -> Optional[torch.nn.Module]:
+    new_module = None
+
+    if isinstance(target, BaseTunerLayer):
+        target_base_layer = target.get_base_layer()
+    else:
+        target_base_layer = target
+
+    if is_aqlm_available() and isinstance(target_base_layer, QuantizedLinear):
+        new_module = AqlmOFTLinear(target, adapter_name, **kwargs)
+        target.qweight = target_base_layer.codes
+
+    return new_module
diff --git a/src/peft/tuners/oft/awq.py b/src/peft/tuners/oft/awq.py
new file mode 100644
index 0000000..78f30f9
--- /dev/null
+++ b/src/peft/tuners/oft/awq.py
@@ -0,0 +1,92 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+from typing import Any, Optional
+
+import torch
+
+from peft.import_utils import is_gptqmodel_available
+from peft.tuners.oft.layer import OFTLayer
+from peft.tuners.tuners_utils import BaseTunerLayer
+from peft.utils.other import is_gptqmodel_awq_layer
+
+from .config import OFTConfig
+
+
+class AwqOFTLinear(torch.nn.Module, OFTLayer):
+    def __init__(
+        self,
+        base_layer,
+        adapter_name: str,
+        config: OFTConfig,
+        r: int = 0,
+        **kwargs,
+    ):
+        super().__init__()
+        OFTLayer.__init__(self, base_layer)
+
+        # self.base_layer and self.quant_linear_module are the same; we need the former for consistency and the latter
+        # for backwards compatibility
+        self.quant_linear_module = base_layer
+
+        self._active_adapter = adapter_name
+        self.update_layer(
+            adapter_name,
+            r,
+            config=config,
+        )
+
+    def forward(self, x: torch.Tensor):
+        if self.disable_adapters:
+            result = self.quant_linear_module(x)
+            return result
+
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self.oft_R.keys():
+                continue
+            oft_R = self.oft_R[active_adapter]
+
+            requires_conversion = not torch.is_autocast_enabled()
+            if requires_conversion:
+                expected_dtype = x.dtype
+                x = self._cast_input_dtype(x, oft_R.weight.dtype)
+
+            x = oft_R(x)
+            if requires_conversion:
+                x = x.to(expected_dtype)
+
+        result = self.quant_linear_module(x)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "oft." + rep
+
+
+def dispatch_awq(
+    target: torch.nn.Module,
+    adapter_name: str,
+    **kwargs: Any,
+) -> Optional[torch.nn.Module]:
+    new_module = None
+
+    if isinstance(target, BaseTunerLayer):
+        target_base_layer = target.get_base_layer()
+    else:
+        target_base_layer = target
+
+    if is_gptqmodel_available() and is_gptqmodel_awq_layer(target_base_layer):
+        new_module = AwqOFTLinear(target, adapter_name, **kwargs)
+        target.qweight = target_base_layer.qweight
+
+    return new_module
diff --git a/src/peft/tuners/oft/bnb.py b/src/peft/tuners/oft/bnb.py
new file mode 100644
index 0000000..7fdf3a8
--- /dev/null
+++ b/src/peft/tuners/oft/bnb.py
@@ -0,0 +1,361 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import warnings
+from typing import Optional
+
+import bitsandbytes as bnb
+import torch
+
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+from peft.utils.integrations import dequantize_bnb_weight
+
+from .config import OFTConfig
+from .layer import OFTLayer
+
+
+if is_bnb_available():
+
+    class Linear8bitLt(torch.nn.Module, OFTLayer):
+        # OFT implemented in a dense layer
+        def __init__(
+            self,
+            base_layer: torch.nn.Module,
+            adapter_name: str,
+            config: OFTConfig,
+            r: int = 8,
+            **kwargs,
+        ) -> None:
+            super().__init__()
+            OFTLayer.__init__(self, base_layer)
+            self.fan_in_fan_out = False
+
+            self._active_adapter = adapter_name
+            self.update_layer(
+                adapter_name,
+                r,
+                config=config,
+            )
+
+        def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+            """
+            Merge the active adapter weights into the base weights
+
+            Args:
+                safe_merge (`bool`, *optional*):
+                    If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                    before merging the weights. This is useful if you want to check if the merge operation will produce
+                    NaNs. Defaults to `False`.
+                adapter_names (`list[str]`, *optional*):
+                    The list of adapter names that should be merged. If None, all active adapters will be merged.
+                    Defaults to `None`.
+            """
+            adapter_names = check_adapters_to_merge(self, adapter_names)
+            if not adapter_names:
+                # no adapter to merge
+                return
+
+            for active_adapter in adapter_names:
+                if active_adapter not in self.oft_R.keys():
+                    continue
+
+                warnings.warn("Merge oft module to 8-bit linear may get different generations due to rounding errors.")
+
+                weight = self.get_base_layer().weight
+                state = self.get_base_layer().state
+                if state.SCB is None:
+                    state.SCB = weight.SCB
+
+                # Dequantize the result of identity matrix and int8 weight because bitsandbytes does not support int8
+                # dequantization directly
+                output = dequantize_bnb_weight(weight, state=state)
+                oft_data = self.get_delta_weight(active_adapter)
+
+                output = torch.transpose(output, 0, 1)
+                w_data = torch.mm(oft_data, output.to(oft_data.dtype))
+                w_data = torch.transpose(w_data, 0, 1)
+                w_data = output.to(oft_data.dtype).to(oft_data.device)
+
+                if safe_merge and not torch.isfinite(w_data).all():
+                    raise ValueError(
+                        f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                    )
+
+                self.get_base_layer().weight = bnb.nn.Int8Params(
+                    w_data.to("cpu"), requires_grad=False, has_fp16_weights=weight.has_fp16_weights
+                ).to(weight.device)
+
+                state.reset_grads()
+                self.merged_adapters.append(active_adapter)
+
+        def unmerge(self) -> None:
+            """
+            This method unmerges all merged adapter layers from the base weights.
+            """
+            if not self.merged:
+                warnings.warn("Already unmerged. Nothing to do.")
+                return
+
+            while len(self.merged_adapters) > 0:
+                active_adapter = self.merged_adapters.pop()
+                if active_adapter not in self.oft_R.keys():
+                    continue
+                warnings.warn(
+                    "Unmerge oft module to 8-bit linear may get different generations due to rounding errors."
+                )
+
+                weight = self.get_base_layer().weight
+                state = self.get_base_layer().state
+                if state.SCB is None:
+                    state.SCB = weight.SCB
+                output = dequantize_bnb_weight(weight, state=state)
+
+                oft_data = self.get_delta_weight(active_adapter)
+
+                output = torch.transpose(output, 0, 1)
+                w_data = torch.mm(oft_data.t(), output.to(oft_data.dtype))
+                w_data = torch.transpose(w_data, 0, 1)
+                w_data = w_data.to(oft_data.dtype).to(oft_data.device)
+
+                self.get_base_layer().weight = bnb.nn.Int8Params(
+                    w_data.to("cpu"), requires_grad=False, has_fp16_weights=weight.has_fp16_weights
+                ).to(weight.device)
+
+                state.reset_grads()
+
+        def get_delta_weight(self, adapter):
+            return self.oft_R[adapter].get_weight()
+
+        def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+            if self.disable_adapters:
+                if self.merged:
+                    self.unmerge()
+                result = self.base_layer(x, *args, **kwargs)
+            elif self.merged:
+                result = self.base_layer(x, *args, **kwargs)
+            else:
+                for active_adapter in self.active_adapters:
+                    if active_adapter not in self.oft_R.keys():
+                        continue
+                    oft_R = self.oft_R[active_adapter]
+
+                    requires_conversion = not torch.is_autocast_enabled()
+                    if requires_conversion:
+                        expected_dtype = x.dtype
+                        x = self._cast_input_dtype(x, oft_R.weight.dtype)
+
+                    x = oft_R(x)
+                    if requires_conversion:
+                        x = x.to(expected_dtype)
+
+                result = self.base_layer(x, *args, **kwargs)
+
+            return result
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return "oft." + rep
+
+    def dispatch_bnb_8bit(target: torch.nn.Module, adapter_name: str, **kwargs):
+        new_module = None
+
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        loaded_in_8bit = kwargs.get("loaded_in_8bit", False)
+        if loaded_in_8bit and isinstance(target_base_layer, bnb.nn.Linear8bitLt):
+            eightbit_kwargs = kwargs.copy()
+            eightbit_kwargs.update(
+                {
+                    "has_fp16_weights": target.state.has_fp16_weights,
+                    "threshold": target.state.threshold,
+                    "index": target.index,
+                }
+            )
+            new_module = Linear8bitLt(target, adapter_name, **eightbit_kwargs)
+
+        return new_module
+
+
+if is_bnb_4bit_available():
+
+    class Linear4bit(torch.nn.Module, OFTLayer):
+        # OFT implemented in a dense layer
+        def __init__(
+            self,
+            base_layer: torch.nn.Module,
+            adapter_name: str,
+            config: OFTConfig,
+            r: int = 8,
+            **kwargs,
+        ) -> None:
+            super().__init__()
+            OFTLayer.__init__(self, base_layer)
+            self.fan_in_fan_out = False
+
+            self._active_adapter = adapter_name
+            self.update_layer(
+                adapter_name,
+                r,
+                config=config,
+            )
+
+        def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+            """
+            Merge the active adapter weights into the base weights
+
+            Args:
+                safe_merge (`bool`, *optional*):
+                    If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                    before merging the weights. This is useful if you want to check if the merge operation will produce
+                    NaNs. Defaults to `False`.
+                adapter_names (`list[str]`, *optional*):
+                    The list of adapter names that should be merged. If None, all active adapters will be merged.
+                    Defaults to `None`.
+            """
+            adapter_names = check_adapters_to_merge(self, adapter_names)
+            if not adapter_names:
+                # no adapter to merge
+                return
+
+            for active_adapter in adapter_names:
+                if active_adapter not in self.oft_R.keys():
+                    continue
+
+                warnings.warn("Merge oft module to 4-bit linear may get different generations due to rounding errors.")
+                # Refer to https://gist.github.com/ChrisHayduk/1a53463331f52dca205e55982baf9930
+                weight = self.get_base_layer().weight
+                kwargs = weight.__dict__
+
+                output = dequantize_bnb_weight(weight, state=weight.quant_state)
+
+                oft_data = self.get_delta_weight(active_adapter)
+                output = torch.transpose(output, 0, 1)
+                w_data = torch.mm(oft_data, output.to(oft_data.dtype))
+                w_data = torch.transpose(w_data, 0, 1)
+                w_data = output.to(oft_data.dtype).to(oft_data.device)
+
+                if safe_merge and not torch.isfinite(w_data).all():
+                    raise ValueError(
+                        f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                    )
+
+                if "bnb_quantized" in kwargs:
+                    kwargs["bnb_quantized"] = False
+                kwargs["requires_grad"] = False
+                kwargs.pop("data", None)
+                # torch.compile can introduce attributes preceded by '_', remove them
+                kwargs = {k: v for k, v in kwargs.items() if not k.startswith("_")}
+                self.get_base_layer().weight = bnb.nn.Params4bit(w_data.to("cpu"), **kwargs).to(weight.device)
+
+                self.merged_adapters.append(active_adapter)
+
+        def unmerge(self) -> None:
+            """
+            This method unmerges all merged adapter layers from the base weights.
+            """
+            if not self.merged:
+                warnings.warn("Already unmerged. Nothing to do.")
+                return
+
+            while len(self.merged_adapters) > 0:
+                active_adapter = self.merged_adapters.pop()
+                if active_adapter not in self.oft_R.keys():
+                    continue
+                warnings.warn(
+                    "Unmerge oft module to 4-bit linear may get different generations due to rounding errors."
+                )
+
+                weight = self.get_base_layer().weight
+                kwargs = weight.__dict__
+                output = dequantize_bnb_weight(weight, state=weight.quant_state)
+
+                oft_data = self.get_delta_weight(active_adapter)
+
+                output = torch.transpose(output, 0, 1)
+                w_data = torch.mm(oft_data.t(), output.to(oft_data.dtype))
+                w_data = torch.transpose(w_data, 0, 1)
+                w_data = output.to(oft_data.dtype).to(oft_data.device)
+
+                if "bnb_quantized" in kwargs:
+                    kwargs["bnb_quantized"] = False
+                kwargs["requires_grad"] = False
+                kwargs.pop("data", None)
+                self.get_base_layer().weight = bnb.nn.Params4bit(w_data.to("cpu"), **kwargs).to(weight.device)
+
+        def get_delta_weight(self, adapter):
+            return self.oft_R[adapter].get_weight()
+
+        def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+            if self.disable_adapters:
+                if self.merged:
+                    self.unmerge()
+                result = self.base_layer(x, *args, **kwargs)
+            elif self.merged:
+                result = self.base_layer(x, *args, **kwargs)
+            else:
+                # As per Tim Dettmers, for 4bit, we need to defensively clone here.
+                # The reason is that in some cases, an error can occur that backprop
+                # does not work on a manipulated view. This issue may be solved with
+                # newer PyTorch versions but this would need extensive testing to be
+                # sure.
+                # result = result.clone()
+
+                for active_adapter in self.active_adapters:
+                    if active_adapter not in self.oft_R.keys():
+                        continue
+                    oft_R = self.oft_R[active_adapter]
+
+                    requires_conversion = not torch.is_autocast_enabled()
+                    if requires_conversion:
+                        expected_dtype = x.dtype
+                        x = self._cast_input_dtype(x, oft_R.weight.dtype)
+
+                    x = oft_R(x)
+                    if requires_conversion:
+                        x = x.to(expected_dtype)
+
+                result = self.base_layer(x, *args, **kwargs)
+
+            return result
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return "oft." + rep
+
+    def dispatch_bnb_4bit(target: torch.nn.Module, adapter_name: str, **kwargs):
+        new_module = None
+
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        loaded_in_4bit = kwargs.get("loaded_in_4bit", False)
+        if loaded_in_4bit and is_bnb_4bit_available() and isinstance(target_base_layer, bnb.nn.Linear4bit):
+            fourbit_kwargs = kwargs.copy()
+            fourbit_kwargs.update(
+                {
+                    "compute_dtype": target_base_layer.compute_dtype,
+                    "compress_statistics": target_base_layer.weight.compress_statistics,
+                    "quant_type": target_base_layer.weight.quant_type,
+                }
+            )
+            new_module = Linear4bit(target, adapter_name, **fourbit_kwargs)
+
+        return new_module
diff --git a/src/peft/tuners/oft/config.py b/src/peft/tuners/oft/config.py
new file mode 100644
index 0000000..d5ab510
--- /dev/null
+++ b/src/peft/tuners/oft/config.py
@@ -0,0 +1,227 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+import warnings
+from dataclasses import dataclass, field
+from typing import Literal, Optional, Union
+
+import packaging.version
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class OFTConfig(PeftConfig):
+    """
+    This is the configuration class to store the configuration of a [`OFTModel`].
+
+    Args:
+        r (`int`):
+            OFT rank, number of OFT blocks per injected layer. Bigger `r` results in more sparse update matrices with
+            fewer trainable parameters. You can only specify either `r` or `oft_block_size`, but not both
+            simultaneously, because `r` × `oft_block_size` = layer dimension. For simplicity, we let you specify either
+            `r` or `oft_block_size` and infer the other one. Default set to `r = 0`, the user is advised to set the
+            `oft_block_size` instead for better clarity.
+        oft_block_size (`int`): OFT block size across different layers. Bigger `oft_block_size` results in more dense
+            update matrices with more trainable parameters. Choose `oft_block_size` to be divisible by layer's input
+            dimension (`in_features`), e.g., 4, 8, 16. You can only specify either `r` or `oft_block_size`, but not
+            both simultaneously, because `r` × `oft_block_size` = layer dimension. For simplicity, we let you specify
+            either `r` or `oft_block_size` and infer the other one. Default set to `oft_block_size = 32`.
+        use_cayley_neumann (bool): Specifies whether to use the Cayley-Neumann parameterization (efficient but
+            approximate) or the vanilla Cayley parameterization (exact but computationally expensive because of matrix
+            inverse). We recommend to set it to `True` for better efficiency, but performance may be slightly worse
+            because of the approximation error. Please test both settings (`True` and `False`) depending on your needs.
+            Default is `False`.
+        module_dropout (`float`):
+            The multiplicative dropout probability, by setting OFT blocks to identity during training, similar to the
+            dropout layer in LoRA.
+        target_modules (`Optional[Union[list[str], str]]`):
+            The names of the modules to apply the adapter to. If this is specified, only the modules with the specified
+            names will be replaced. When passing a string, a regex match will be performed. When passing a list of
+            strings, either an exact match will be performed or it is checked if the name of the module ends with any
+            of the passed strings. If this is specified as 'all-linear', then all linear modules are chosen, excluding
+            the output layer. If this is not specified, modules will be chosen according to the model architecture. If
+            the architecture is not known, an error will be raised -- in this case, you should specify the target
+            modules manually.
+        fan_in_fan_out (`bool`): Set this to True if the layer to replace stores weight like (fan_in, fan_out).
+        bias (`str`): Bias type for OFT. Can be 'none', 'all' or 'oft_only'. If 'all' or 'oft_only', the
+            corresponding biases will be updated during training. Be aware that this means that, even when disabling
+            the adapters, the model will not produce the same output as the base model would have without adaptation.
+        exclude_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to not apply the adapter. When passing a string, a regex match will be performed.
+            When passing a list of strings, either an exact match will be performed or it is checked if the name of the
+            module ends with any of the passed strings.
+        init_weights (`bool`):
+            Whether to perform initialization of OFT weights.
+        layers_to_transform (`Union[List[int], int]`):
+            The layer indices to transform. If a list of ints is passed, it will apply the adapter to the layer indices
+            that are specified in this list. If a single integer is passed, it will apply the transformations on the
+            layer at this index.
+        layers_pattern (`Optional[Union[List[str], str]]`):
+            The layer pattern name, used only if `layers_to_transform` is different from `None`. This should target the
+            `nn.ModuleList` of the model, which is often called `'layers'` or `'h'`.
+        modules_to_save (`List[str]`):
+            List of modules apart from adapter layers to be set as trainable and saved in the final checkpoint.
+        coft (`bool`):
+            Whether to use the constrained variant of OFT or not, off by default.
+        eps (`float`):
+            The control strength of COFT. The freedom of rotation. Only has an effect if `coft` is set to True.
+        block_share (`bool`):
+            Whether to share the OFT parameters between blocks or not. This is `False` by default.
+    """
+
+    r: int = field(default=0, metadata={"help": "OFT rank, number of OFT blocks per injected layer."})
+    oft_block_size: int = field(
+        default=32,
+        metadata={
+            "help": "OFT block size across different layers.",
+            "note": "You can only specify either r or oft_block_size, but not both simultaneously, because r x oft_block_size = layer dimension.",
+        },
+    )
+    module_dropout: float = field(
+        default=0.0,
+        metadata={
+            "help": "OFT multiplicative dropout, randomly setting blocks of OFT to be identity matrix, similar to the dropout layer in LoRA."
+        },
+    )
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": "List of module names or regex expression of the module names to replace with OFT."
+            "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$' "
+            "This can also be a wildcard 'all-linear' which matches all linear/Conv1D layers except the output layer."
+        },
+    )
+    fan_in_fan_out: bool = field(
+        default=False,
+        metadata={"help": "Set this to True if the layer to replace stores weight like (fan_in, fan_out)"},
+    )
+    bias: Literal["none", "all", "oft_only"] = field(
+        default="none", metadata={"help": "Bias type for OFT. Can be 'none', 'all' or 'oft_only'"}
+    )
+    exclude_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={"help": "List of module names or regex expression of the module names to exclude from OFT."},
+    )
+    init_weights: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "Whether to initialize the weights of the OFT layers with their default initialization. Don't change "
+                "this setting, except if you know exactly what you're doing."
+            ),
+        },
+    )
+    layers_to_transform: Optional[Union[list[int], int]] = field(
+        default=None,
+        metadata={
+            "help": "The layer indexes to transform, is this argument is specified, PEFT will transform only the layers indexes that are specified inside this list. If a single integer is passed, PEFT will transform only the layer at this index."
+        },
+    )
+    layers_pattern: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": "The layer pattern name, used only if `layers_to_transform` is different to None and if the layer pattern is not in the common layers pattern. "
+            "This should target the `nn.ModuleList` of the model, which is often called `'layers'` or `'h'`."
+        },
+    )
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": "List of modules apart from OFT layers to be set as trainable and saved in the final checkpoint. "
+            "For example, in Sequence Classification or Token Classification tasks, "
+            "the final layer `classifier/score` are randomly initialized and as such need to be trainable and saved."
+        },
+    )
+    coft: bool = field(
+        default=False,
+        metadata={"help": "Whether to use the constrained variant of OFT or not."},
+    )
+    eps: float = field(
+        default=6e-5,
+        metadata={
+            "help": "The control strength of COFT. The freedom of rotation. Only has an effect if `coft` is set to True."
+        },
+    )
+    block_share: bool = field(
+        default=False,
+        metadata={"help": "Whether to share the OFT parameters between blocks or not."},
+    )
+    use_cayley_neumann: bool = field(
+        default=True,
+        metadata={
+            "help": "Whether to use the Cayley-Neumann Formulation of OFT or not. Set to True to improve computational efficiency but comes at costs of bigger approximation error for orthogonality."
+        },
+    )
+    num_cayley_neumann_terms: int = field(
+        default=5,
+        metadata={
+            "help": "Number of Cayley-Neumann terms to use. Higher number results in less approximation error for orthogonality."
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.OFT
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        self.exclude_modules = (
+            set(self.exclude_modules) if isinstance(self.exclude_modules, list) else self.exclude_modules
+        )
+        # check for layers_to_transform and layers_pattern
+        if self.layers_pattern and not self.layers_to_transform:
+            raise ValueError("When `layers_pattern` is specified, `layers_to_transform` must also be specified. ")
+        if self.r == 0 and self.oft_block_size == 0:
+            raise ValueError(
+                f"Either `r` or `oft_block_size` must be non-zero. Currently, r = {self.r} and oft_block_size = {self.oft_block_size}."
+            )
+        if not (self.r != 0) ^ (self.oft_block_size != 0):
+            raise ValueError(
+                f"You can only specify either r ({self.r}) or oft_block_size ({self.oft_block_size}), but not both simultaneously, because r x oft_block_size == in_features."
+            )
+
+    @classmethod
+    def check_kwargs(cls, **kwargs):
+        r"""
+        Check if the kwargs are valid for the configuration.
+
+        Args:
+            kwargs (additional keyword arguments, *optional*):
+                Additional keyword arguments passed along to the child class initialization.
+        """
+        if "oft_block_size" not in kwargs:
+            raise ValueError(
+                "OFT has been updated since PEFT 0.14.0. Your trained adapter weights are incompatible "
+                "with the latest version of OFT. Please retrain your adapter weights with newer PEFT versions. "
+                "Alternatively, downgrade PEFT to version 0.13.0 to use the old adapter weights."
+            )
+        if kwargs.get("use_cayley_neumann", False):
+            peft_version = kwargs.get("peft_version", "0.0.0")  # if not present, set a low dummy version
+            # remove commit hash, if present
+            peft_version = peft_version.partition("@")[0]
+            parsed_version = packaging.version.Version(peft_version)
+            min_version = packaging.version.Version("0.18.0")
+            # note: config.peft_version was added in 0.18.0, so if it's missing, it means we're below min version
+            if parsed_version < min_version:
+                msg = (
+                    "The cayley-neumann parameterization has been slightly changed to be more numerically stable in "
+                    "PEFT 0.18.0. Please retrain your adapter weights with newer PEFT versions. Alternatively, "
+                    "downgrade PEFT to version 0.17.0 to use the old parameterization."
+                )
+                warnings.warn(msg)
+        return super().check_kwargs(**kwargs)
diff --git a/src/peft/tuners/oft/eetq.py b/src/peft/tuners/oft/eetq.py
new file mode 100644
index 0000000..f118166
--- /dev/null
+++ b/src/peft/tuners/oft/eetq.py
@@ -0,0 +1,102 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+from typing import Any, Optional
+
+import torch
+
+from peft.import_utils import is_eetq_available
+from peft.tuners.oft.layer import OFTLayer
+from peft.tuners.tuners_utils import BaseTunerLayer
+
+from .config import OFTConfig
+
+
+if is_eetq_available():
+    from eetq import EetqLinear
+
+    class EetqOFTLinear(torch.nn.Module, OFTLayer):
+        def __init__(
+            self,
+            base_layer,
+            adapter_name: str,
+            config: OFTConfig,
+            r: int = 0,
+            **kwargs,
+        ):
+            super().__init__()
+            OFTLayer.__init__(self, base_layer)
+
+            # self.base_layer and self.quant_linear_module are the same; we need the former for consistency and the latter
+            # for backwards compatibility
+            self.quant_linear_module = base_layer
+
+            self._active_adapter = adapter_name
+            self.update_layer(
+                adapter_name,
+                r,
+                config=config,
+            )
+
+        def forward(self, x: torch.Tensor):
+            if self.disable_adapters:
+                return self.quant_linear_module(x)
+
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.oft_R.keys():
+                    continue
+                oft_R = self.oft_R[active_adapter]
+
+                requires_conversion = not torch.is_autocast_enabled()
+                if requires_conversion:
+                    expected_dtype = x.dtype
+                    x = self._cast_input_dtype(x, oft_R.weight.dtype)
+
+                x = oft_R(x)
+
+            result = self.quant_linear_module(x)
+            if requires_conversion:
+                result = result.to(expected_dtype)
+            return result
+
+        def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+            raise AttributeError("Merging LoRA layers is not supported for Eetq layers.")
+
+        def unmerge(self) -> None:
+            raise AttributeError("Unmerging LoRA layers is not supported for Eetq layers.")
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return "oft." + rep
+
+
+def dispatch_eetq(
+    target: torch.nn.Module,
+    adapter_name: str,
+    **kwargs: Any,
+) -> Optional[torch.nn.Module]:
+    new_module = None
+
+    if isinstance(target, BaseTunerLayer):
+        target_base_layer = target.get_base_layer()
+    else:
+        target_base_layer = target
+
+    if is_eetq_available() and isinstance(target_base_layer, EetqLinear):
+        new_module = EetqOFTLinear(target, adapter_name, **kwargs)
+        target.weight = target_base_layer.weight
+
+        if hasattr(target, "bias"):
+            target.bias = target_base_layer.bias
+
+    return new_module
diff --git a/src/peft/tuners/oft/gptq.py b/src/peft/tuners/oft/gptq.py
new file mode 100644
index 0000000..530b8c0
--- /dev/null
+++ b/src/peft/tuners/oft/gptq.py
@@ -0,0 +1,94 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+from typing import Any, Optional
+
+import torch
+
+from peft.import_utils import is_gptqmodel_available
+from peft.tuners.oft.layer import OFTLayer
+from peft.tuners.tuners_utils import BaseTunerLayer
+
+from .config import OFTConfig
+
+
+class GPTQOFTLinear(torch.nn.Module, OFTLayer):
+    def __init__(
+        self,
+        base_layer,
+        adapter_name: str,
+        config: OFTConfig,
+        r: int = 8,
+        **kwargs,
+    ):
+        super().__init__()
+        OFTLayer.__init__(self, base_layer)
+
+        # self.base_layer and self.quant_linear_module are the same; we need the former for consistency and the latter
+        # for backwards compatibility
+        self.quant_linear_module = base_layer
+        self._active_adapter = adapter_name
+        self.update_layer(
+            adapter_name,
+            r,
+            config=config,
+        )
+
+    def forward(self, x: torch.Tensor):
+        # note: logic differs from default Linear because merging is not supported
+        if self.disable_adapters:
+            return self.quant_linear_module(x)
+
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self.oft_R.keys():
+                continue
+
+            oft_R = self.oft_R[active_adapter]
+            requires_conversion = not torch.is_autocast_enabled()
+            if requires_conversion:
+                expected_dtype = x.dtype
+                x = self._cast_input_dtype(x, oft_R.weight.dtype)
+
+            x = oft_R(x)
+            if requires_conversion:
+                x = x.to(expected_dtype)
+
+        result = self.quant_linear_module(x)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "oft." + rep
+
+
+def dispatch_gptq(
+    target: torch.nn.Module,
+    adapter_name: str,
+    oft_config: OFTConfig,
+    **kwargs: Any,
+) -> Optional[torch.nn.Module]:
+    new_module = None
+
+    if isinstance(target, BaseTunerLayer):
+        target_base_layer = target.get_base_layer()
+    else:
+        target_base_layer = target
+
+    if is_gptqmodel_available():
+        from gptqmodel.nn_modules.qlinear import BaseQuantLinear
+
+        if isinstance(target_base_layer, BaseQuantLinear):
+            new_module = GPTQOFTLinear(target, adapter_name, config=oft_config, **kwargs)
+            target.qweight = target_base_layer.qweight
+
+    return new_module
diff --git a/src/peft/tuners/oft/hqq.py b/src/peft/tuners/oft/hqq.py
new file mode 100644
index 0000000..140e48b
--- /dev/null
+++ b/src/peft/tuners/oft/hqq.py
@@ -0,0 +1,173 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import copy
+import warnings
+from typing import Optional
+
+import torch
+
+from peft.import_utils import is_hqq_available
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+
+from .config import OFTConfig
+from .layer import OFTLayer
+
+
+if is_hqq_available():
+    from hqq.core.quantize import HQQLinear
+
+    class HqqOFTLinear(torch.nn.Module, OFTLayer):
+        # Lora implemented in a dense layer
+        def __init__(
+            self,
+            base_layer: torch.nn.Module,
+            adapter_name: str,
+            config: OFTConfig,
+            r: int = 8,
+            **kwargs,
+        ) -> None:
+            super().__init__()
+            OFTLayer.__init__(self, base_layer)
+            self.fan_in_fan_out = False
+
+            self._active_adapter = adapter_name
+            self.update_layer(
+                adapter_name,
+                r,
+                config=config,
+            )
+
+        def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+            """
+            Merge the active adapter weights into the base weights
+
+            Args:
+                safe_merge (`bool`, *optional*):
+                    If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                    before merging the weights. This is useful if you want to check if the merge operation will produce
+                    NaNs. Defaults to `False`.
+                adapter_names (`list[str]`, *optional*):
+                    The list of adapter names that should be merged. If None, all active adapters will be merged.
+                    Defaults to `None`.
+            """
+            adapter_names = check_adapters_to_merge(self, adapter_names)
+            if not adapter_names:
+                # no adapter to merge
+                return
+
+            for active_adapter in adapter_names:
+                if active_adapter not in self.lora_A.keys():
+                    continue
+
+                layer = self.get_base_layer()
+                quant_config = {**copy.deepcopy(layer.quant_config), "offload_meta": layer.offload_meta}
+
+                output = layer.dequantize()
+                oft_data = self.get_delta_weight(active_adapter)
+
+                output = torch.transpose(output, 0, 1)
+                w_data = torch.mm(oft_data, output.to(oft_data.dtype))
+                w_data = torch.transpose(w_data, 0, 1)
+                w_data = output.to(oft_data.dtype).to(oft_data.device)
+
+                if safe_merge and not torch.isfinite(w_data).all():
+                    raise ValueError(
+                        f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                    )
+
+                new_hqq_layer = HQQLinear(None, quant_config, compute_dtype=layer.compute_dtype, device=layer.device)
+                quant_config.pop("offload_meta", None)
+                new_hqq_layer.quantize(w_data, **quant_config)
+                self.base_layer = new_hqq_layer
+                self.merged_adapters.append(active_adapter)
+
+        def unmerge(self) -> None:
+            """
+            This method unmerges all merged adapter layers from the base weights.
+            """
+            if not self.merged:
+                warnings.warn("Already unmerged. Nothing to do.")
+                return
+
+            while len(self.merged_adapters) > 0:
+                active_adapter = self.merged_adapters.pop()
+                if active_adapter not in self.oft_R.keys():
+                    continue
+
+                layer = self.get_base_layer()
+                quant_config = {**copy.deepcopy(layer.quant_config), "offload_meta": layer.offload_meta}
+                output = layer.dequantize()
+
+                oft_data = self.get_delta_weight(active_adapter)
+
+                output = torch.transpose(output, 0, 1)
+                w_data = torch.mm(oft_data.t(), output.to(oft_data.dtype))
+                w_data = torch.transpose(w_data, 0, 1)
+                w_data = w_data.to(oft_data.dtype).to(oft_data.device)
+
+                new_hqq_layer = HQQLinear(None, quant_config, compute_dtype=layer.compute_dtype, device=layer.device)
+                quant_config.pop("offload_meta", None)
+                new_hqq_layer.quantize(w_data, **quant_config)
+                self.base_layer = new_hqq_layer
+
+        def get_delta_weight(self, adapter):
+            return self.oft_R[adapter].get_weight()
+
+        def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+            self._check_forward_args(x, *args, **kwargs)
+            adapter_names = kwargs.pop("adapter_names", None)
+
+            if self.disable_adapters:
+                if self.merged:
+                    self.unmerge()
+                result = self.base_layer(x, *args, **kwargs)
+            elif self.merged:
+                result = self.base_layer(x, *args, **kwargs)
+            else:
+                for active_adapter in self.active_adapters:
+                    if active_adapter not in self.oft_R.keys():
+                        continue
+                    oft_R = self.oft_R[active_adapter]
+
+                    requires_conversion = not torch.is_autocast_enabled()
+                    if requires_conversion:
+                        expected_dtype = x.dtype
+                        x = self._cast_input_dtype(x, oft_R.weight.dtype)
+
+                    x = oft_R(x)
+
+            result = self.base_layer(x, *args, **kwargs)
+            if requires_conversion:
+                result = result.to(expected_dtype)
+            return result
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return "oft." + rep
+
+
+def dispatch_hqq(target: torch.nn.Module, adapter_name: str, **kwargs):
+    new_module = None
+
+    if isinstance(target, BaseTunerLayer):
+        target_base_layer = target.get_base_layer()
+    else:
+        target_base_layer = target
+
+    if is_hqq_available() and isinstance(target_base_layer, HQQLinear):
+        new_module = HqqOFTLinear(target_base_layer, adapter_name, **kwargs)
+
+    return new_module
diff --git a/src/peft/tuners/oft/inc.py b/src/peft/tuners/oft/inc.py
new file mode 100644
index 0000000..6ed855b
--- /dev/null
+++ b/src/peft/tuners/oft/inc.py
@@ -0,0 +1,78 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+# NOTE: PEFT tests related to INC are handled under Optimum-Habana repository:
+# - LLMs: https://github.com/huggingface/optimum-habana/blob/main/tests/test_peft_inference.py
+# - Diffusers: https://github.com/huggingface/optimum-habana/blob/main/tests/test_diffusers.py
+
+from typing import Optional
+
+import torch
+
+from peft.import_utils import is_inc_available
+from peft.tuners.tuners_utils import BaseTunerLayer
+
+from .layer import Linear
+
+
+if is_inc_available():
+
+    class IncOFTLinear(Linear):
+        def __init__(
+            self,
+            base_layer: torch.nn.Module,
+            adapter_name: str,
+            **kwargs,
+        ):
+            super().__init__(base_layer, adapter_name, **kwargs)
+
+        def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+            """
+            Merge the active adapter weights into the base weights
+
+            Args:
+                safe_merge (`bool`, *optional*):
+                    If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                    before merging the weights. This is useful if you want to check if the merge operation will produce
+                    NaNs. Defaults to `False`.
+                adapter_names (`list[str]`, *optional*):
+                    The list of adapter names that should be merged. If None, all active adapters will be merged.
+                    Defaults to `None`.
+            """
+            raise NotImplementedError("Merging OFT with INC layers is not yet implemented")
+
+        def unmerge(self) -> None:
+            """
+            This method unmerges all merged adapter layers from the base weights.
+            """
+            raise NotImplementedError("Unmerging OFT from INC layers is not yet implemented")
+
+
+def dispatch_inc(target: torch.nn.Module, adapter_name: str, **kwargs):
+    new_module = None
+
+    if isinstance(target, BaseTunerLayer):
+        target_base_layer = target.get_base_layer()
+    else:
+        target_base_layer = target
+
+    if is_inc_available():
+        from neural_compressor.torch.algorithms.fp8_quant._quant_common.helper_modules import (
+            PatchedLinear,
+        )
+
+        if isinstance(target_base_layer, PatchedLinear):
+            new_module = IncOFTLinear(target, adapter_name, **kwargs)
+
+    return new_module
diff --git a/src/peft/tuners/oft/layer.py b/src/peft/tuners/oft/layer.py
new file mode 100644
index 0000000..a42476a
--- /dev/null
+++ b/src/peft/tuners/oft/layer.py
@@ -0,0 +1,1189 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import warnings
+from typing import Any, Optional
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+from peft.utils.other import is_gptqmodel_quant_linear
+
+from .config import OFTConfig
+
+
+class MultiplicativeDropoutLayer(nn.Module):
+    """
+    Implements the multiplicative dropout layer for OFT.
+    """
+
+    def __init__(self, p=0.0):
+        """
+        Initializes the multiplicative dropout layer.
+
+        Parameters:
+        p (float): The probability of dropping out a block. Defaults to 0.0.
+        """
+        super().__init__()
+        self.p = p
+
+    def forward(self, x):
+        """
+        Applies multiplicative dropout to the input tensor.
+
+        Parameters:
+        x (Tensor): The input tensor of shape (D, H, H), where `D` represents
+                    the number of OFT blocks, and `H` is the size of the square blocks along the last two dimensions,
+                    the block size in OFT.
+        """
+        if self.training and self.p > 0:
+            # Ensure the last two dimensions are the same
+            if x.shape[-1] != x.shape[-2]:
+                raise ValueError("The last two dimensions of input should be the same!")
+
+            D, H, _ = x.shape
+
+            # If block share, skip the multiplicative dropout
+            if D == 1:
+                return x
+
+            num_to_replace = int(self.p * D)
+            num_zeros = D - num_to_replace
+            mask = torch.cat([torch.ones(num_to_replace, device=x.device), torch.zeros(num_zeros, device=x.device)])
+            mask = mask[torch.randperm(D)].view(D, 1, 1)
+            eye_matrix = torch.eye(H, device=x.device).repeat(D, 1, 1)
+            x = (1 - mask) * x + mask * eye_matrix
+        return x
+
+
+class OFTRotationModule(nn.Module):
+    def __init__(
+        self,
+        r,
+        n_elements,
+        block_size,
+        in_features,
+        coft=False,
+        eps=6e-5,
+        block_share=False,
+        kernel_size=(0, 0),
+        use_cayley_neumann=True,
+        num_cayley_neumann_terms=5,
+    ):
+        super().__init__()
+        self.r = r
+        self.n_elements = n_elements
+        self.block_size = block_size
+        self.in_features = in_features
+        self.weight = nn.Parameter(torch.empty(r, n_elements))
+        self.coft = coft
+        self.eps = eps
+        self.block_share = block_share
+        # Conv2d specific parameters
+        self.kernel_size = kernel_size
+        self.use_cayley_neumann = use_cayley_neumann
+        self.num_cayley_neumann_terms = num_cayley_neumann_terms
+        # Create indices for upper triangle (excluding diagonal)
+        rows, cols = torch.triu_indices(block_size, block_size, 1)
+        self.register_buffer("rows", rows, persistent=False)
+        self.register_buffer("cols", cols, persistent=False)
+
+    def _pytorch_skew_symmetric(self, vec, block_size):
+        batch_size = vec.shape[0]
+        matrix = torch.zeros(batch_size, block_size, block_size, device=vec.device, dtype=vec.dtype)
+
+        matrix[:, self.rows, self.cols] = vec
+        matrix = matrix - matrix.transpose(-2, -1)
+        return matrix
+
+    def _pytorch_skew_symmetric_inv(self, matrix, block_size):
+        batch_size = matrix.shape[0]
+
+        # Extract the upper triangular elements
+        vec = matrix[:, self.rows, self.cols]
+        return vec
+
+    def _cayley_batch(
+        self, Q: torch.Tensor, block_size: int, use_cayley_neumann: bool = True, num_neumann_terms: int = 5
+    ) -> torch.Tensor:
+        """
+        Perform the Cayley parametrization on a batch of skew-symmetric matrices.
+
+        Args:
+            data: A batch of skew-symmetric matrices of shape (b, r, c).
+        """
+
+        b, _ = Q.shape
+        previous_dtype = Q.dtype
+
+        # Q_skew = SkewSymmetric.apply(Q, block_size)
+        Q_skew = self._pytorch_skew_symmetric(Q, block_size)
+
+        if use_cayley_neumann:
+            R = torch.eye(block_size, device=Q.device, dtype=Q.dtype).repeat(b, 1, 1)
+            if num_neumann_terms > 1:
+                R.add_(Q_skew, alpha=2.0)
+                if num_neumann_terms > 2:
+                    Q_squared = torch.bmm(Q_skew, Q_skew)
+                    R.add_(Q_squared, alpha=2.0)
+
+                    Q_power = Q_squared
+                    for _ in range(3, num_neumann_terms - 1):
+                        Q_power = torch.bmm(Q_power, Q_skew)
+                        R.add_(Q_power, alpha=2.0)
+                    Q_power = torch.bmm(Q_power, Q_skew)
+                    R.add_(Q_power)
+        else:
+            id_mat = (
+                torch.eye(Q_skew.shape[-1], device=Q_skew.device)
+                .unsqueeze(0)
+                .expand(b, Q_skew.shape[-1], Q_skew.shape[-1])
+            )
+            R = torch.linalg.solve(id_mat + Q_skew, id_mat - Q_skew, left=False)
+
+        return R.to(previous_dtype)
+
+    # Copied from https://github.com/Zeju1997/oft/blob/84cebb965df69781e3d9c3c875f5980b421eaf24/oft-control/oft.py#L52
+    def _project_batch(self, Q, eps=1e-5):
+        oft_R = self._pytorch_skew_symmetric(Q, self.block_size)
+        # scaling factor for each of the smaller block matrix
+        eps = eps * 1 / torch.sqrt(torch.tensor(oft_R.shape[0]))
+        I = (  # noqa: E741
+            torch.zeros((oft_R.size(1), oft_R.size(1)), device=oft_R.device, dtype=oft_R.dtype)
+            .unsqueeze(0)
+            .expand_as(oft_R)
+        )
+        diff = oft_R - I
+        norm_diff = torch.norm(oft_R - I, dim=(1, 2), keepdim=True)
+        mask = (norm_diff <= eps).bool()
+        out = torch.where(mask, oft_R, I + eps * (diff / norm_diff))
+
+        return self._pytorch_skew_symmetric_inv(out, self.block_size)
+
+    # Copied from https://github.com/Zeju1997/oft/blob/84cebb965df69781e3d9c3c875f5980b421eaf24/oft-control/oft.py#L155
+    def _block_diagonal(self, oft_R: torch.Tensor, rank: int) -> torch.Tensor:
+        if oft_R.shape[0] == 1:
+            # block share
+            blocks = [oft_R[0, ...] for i in range(rank)]
+        else:
+            blocks = [oft_R[i, ...] for i in range(rank)]
+
+        # Use torch.block_diag to create the block diagonal matrix
+        A = torch.block_diag(*blocks)
+
+        return A
+
+    def _unfold(self, x):
+        """
+        Unfold with stride=1, padding=0 to preserve spatial dimensions. Only use kernel_size from base layer to define
+        patch size.
+        """
+        batch_size, _, in_height, in_width = x.shape
+
+        if isinstance(self.kernel_size, int):
+            kernel_height, kernel_width = self.kernel_size, self.kernel_size
+        else:
+            kernel_height, kernel_width = self.kernel_size
+
+        stride_h = stride_w = 1
+        pad_h = pad_w = 0
+
+        # output dimensions
+        out_height = (in_height + 2 * pad_h - kernel_height) // stride_h + 1
+        out_width = (in_width + 2 * pad_w - kernel_width) // stride_w + 1
+
+        # Reshape input from [B, C, H, W] to [B, C, H_out, W_out, K_H, K_W]
+        x_unfolded = x.unfold(2, kernel_height, stride_h).unfold(3, kernel_width, stride_w)
+        x_unfolded = x_unfolded.permute(0, 2, 3, 1, 4, 5).contiguous()
+        x_unfolded = x_unfolded.view(batch_size * out_height * out_width, -1)
+
+        return x_unfolded
+
+    def _fold(self, x_unfolded, orig_shape):
+        """
+        Fold back to preserve spatial dimensions.
+        """
+        batch_size, in_channels, in_height, in_width = orig_shape
+
+        if isinstance(self.kernel_size, int):
+            kernel_height, kernel_width = self.kernel_size, self.kernel_size
+        else:
+            kernel_height, kernel_width = self.kernel_size
+
+        # With stride=1, padding=0:
+        out_height = in_height - kernel_height + 1
+        out_width = in_width - kernel_width + 1
+
+        # Reshape: [B*H_out*W_out, C*K_H*K_W] -> [B, H_out, W_out, C, K_H, K_W]
+        x_reshaped = x_unfolded.view(batch_size, out_height, out_width, in_channels, kernel_height, kernel_width)
+
+        # Permute to: [B, C, H_out, W_out, K_H, K_W]
+        x_reshaped = x_reshaped.permute(0, 3, 1, 2, 4, 5).contiguous()
+
+        # Use F.fold to reconstruct 4D tensor
+        x_folded = F.fold(
+            x_reshaped.view(batch_size, in_channels * kernel_height * kernel_width, out_height * out_width),
+            output_size=(in_height, in_width),
+            kernel_size=(kernel_height, kernel_width),
+            stride=(1, 1),
+        )
+
+        return x_folded
+
+    def forward(self, x):
+        # This module doesn't need to implement the orthogonal transform
+        # It's primarily a container for the parameter
+        # The actual transformation logic stays in your OFTLayer
+
+        required_dtype = x.dtype
+        if required_dtype != self.weight.dtype:
+            x = x.to(self.weight.dtype)
+
+        orig_shape = x.shape
+
+        if self.coft:
+            with torch.no_grad():
+                self.weight.copy_(self._project_batch(self.weight, eps=self.eps))
+
+        orth_rotate = self._cayley_batch(
+            self.weight, self.block_size, self.use_cayley_neumann, self.num_cayley_neumann_terms
+        )
+
+        # Unfold the input for Conv2d layer
+        if len(orig_shape) == 4:
+            x = self._unfold(x)
+
+        folded_shape = x.shape
+        rank = self.in_features // self.block_size if self.block_share else self.r
+        batch_dims = x.shape[:-1]
+        x_reshaped = x.reshape(*batch_dims, rank, self.block_size)
+
+        if self.block_share:
+            orth_rotate = orth_rotate.repeat(rank, 1, 1)
+            x_rotated_reshaped = torch.einsum("...rk,rkc->...rc", x_reshaped, orth_rotate)
+        else:
+            x_rotated_reshaped = torch.einsum("...rk,rkc->...rc", x_reshaped, orth_rotate)
+
+        x_rotated = x_rotated_reshaped.reshape(*folded_shape)
+
+        if len(orig_shape) == 4:
+            x_rotated = self._fold(x_rotated, orig_shape)
+
+        return x_rotated.to(required_dtype)
+
+    def get_weight(self):
+        """
+        Compute the delta weight for the given adapter.
+
+        Args:
+            adapter (str):
+                The name of the adapter for which the delta weight should be computed.
+        """
+        weight = self.weight
+
+        if self.coft:
+            with torch.no_grad():
+                weight = self._project_batch(weight, eps=self.eps)
+                self.weight.copy_(weight)
+
+        orth_rotate = self._cayley_batch(
+            weight, self.block_size, self.use_cayley_neumann, self.num_cayley_neumann_terms
+        )
+
+        rank = self.r if not self.block_share else self.in_features // self.block_size
+        return self._block_diagonal(orth_rotate, rank)
+
+
+class OFTLayer(BaseTunerLayer):
+    """
+    Implements the OFT layer.
+    """
+
+    # All names of layers that may contain (trainable) adapter weights
+    adapter_layer_names: tuple[str, ...] = ("oft_R", "oft_embedding_R")
+    # All names of other parameters that may contain adapter-related parameters
+    other_param_names: tuple[str, ...] = ("r", "oft_block_size", "oft_dropout")
+
+    def __init__(self, base_layer: nn.Module, **kwargs) -> None:
+        """
+        Initializes the OFT layer.
+
+        Note, currently only support linear layer and convolutional layer, with further support for other layers to be
+        added soon.
+
+        Parameters:
+        base_layer: the pretrained model layer
+        """
+        self.base_layer = base_layer
+        self.oft_R = nn.ModuleDict({})
+        # For Embedding layer
+        self.oft_embedding_R = nn.ModuleDict({})
+        self.oft_block_size = {}
+        self.r = {}
+        self.oft_block_size = {}
+        self.oft_dropout = nn.ModuleDict({})
+        # Mark the weight as unmerged
+        self._disable_adapters = False
+        self.merged_adapters = []
+        # flag to enable/disable casting of input to weight dtype during forward call
+        self.cast_input_dtype_enabled = True
+        self.kwargs = kwargs
+
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            in_features, out_features = base_layer.in_features, base_layer.out_features
+        elif isinstance(base_layer, nn.Conv2d):
+            in_features, out_features = base_layer.in_channels, base_layer.out_channels
+        elif isinstance(base_layer, nn.Embedding):
+            in_features, out_features = base_layer.embedding_dim, base_layer.num_embeddings
+        elif hasattr(base_layer, "infeatures") and hasattr(base_layer, "outfeatures"):
+            # QuantLinear
+            in_features, out_features = base_layer.infeatures, base_layer.outfeatures
+        elif hasattr(base_layer, "input_size") and hasattr(base_layer, "output_size"):
+            # Megatron ColumnParallelLinear,RowParallelLinear
+            in_features, out_features = base_layer.input_size, base_layer.output_size
+        elif hasattr(base_layer, "codebooks") and base_layer.__class__.__name__ == "QuantizedLinear":
+            # AQLM QuantLinear
+            in_features, out_features = base_layer.in_features, base_layer.out_features
+        elif is_gptqmodel_quant_linear(base_layer):
+            # GPT-QModel quantized linears
+            in_features, out_features = base_layer.in_features, base_layer.out_features
+        elif base_layer.__class__.__name__ == "EetqLinear":
+            # Eetq layers
+            in_features, out_features = base_layer.in_features, base_layer.out_features
+        elif hasattr(base_layer, "W_q") and base_layer.__class__.__name__ == "HQQLinear":
+            # HQQ layers
+            in_features, out_features = base_layer.in_features, base_layer.out_features
+        else:
+            # possibly support user provided custom layer types using dynamic dispatch
+            if hasattr(base_layer, "in_features") and hasattr(base_layer, "out_features"):
+                in_features, out_features = base_layer.in_features, base_layer.out_features
+            else:
+                in_features, out_features = None, None
+            warnings.warn(
+                f"Unsupported layer type '{type(base_layer)}' encountered, proceed at your own risk.", UserWarning
+            )
+
+        self.in_features = in_features
+        self.out_features = out_features
+
+    def set_scale(self, adapter, scale):
+        if adapter not in self.scaling:
+            # Ignore the case where the adapter is not in the layer
+            return
+
+        warnings.warn("Scaling operation for OFT not supported! Automatically set scale to 1.")
+
+    def scale_layer(self, scale: float) -> None:
+        if scale == 1:
+            return
+
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self.oft_R.keys():
+                continue
+
+            warnings.warn("Scaling operation for OFT not supported! Automatically set scale to 1.")
+
+    def unscale_layer(self, scale=None) -> None:
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self.oft_R.keys():
+                continue
+
+            warnings.warn("Unscaling operation for OFT not supported! Keeping scale to 1.")
+
+    def update_layer(
+        self,
+        adapter_name,
+        r,
+        config: OFTConfig,
+        inference_mode: bool = False,
+        **kwargs,
+    ):
+        """
+        Update the linear layer with trainable OFT weights. Override for other layer types.
+        """
+        """Internal function to create oft adapter
+
+        Args:
+            adapter_name (`str`): Name for the adapter to add.
+            r (`int`): Rank for the added adapter.
+            oft_block_size (`int`): The block size for added adapter.
+            module_dropout (`float`):
+                The multiplicative dropout probability for disabling adapter blocks during training.
+            coft (`bool`): Whether to use the constrained variant of OFT or not.
+            eps (`float`):
+                The control strength of COFT. The freedom of rotation. Only has an effect if `coft` is set to True.
+            block_share (`bool`): Whether to share the OFT parameters between blocks or not.
+            init_weights (`bool`): Whether to initialize weights.
+        """
+        oft_block_size = config.oft_block_size
+        module_dropout = config.module_dropout
+        coft = config.coft
+        eps = config.eps
+        block_share = config.block_share
+        init_weights = config.init_weights
+        use_cayley_neumann = config.use_cayley_neumann
+        num_cayley_neumann_terms = config.num_cayley_neumann_terms
+
+        # Initialize the MultiplicativeDropoutLayer for module_dropout > 0.0.
+        if module_dropout > 0.0:
+            oft_dropout_layer = MultiplicativeDropoutLayer(p=module_dropout)
+        else:
+            oft_dropout_layer = nn.Identity()
+        self.oft_dropout.update(nn.ModuleDict({adapter_name: oft_dropout_layer}))
+
+        if r == 0 and oft_block_size != 0:
+            if self.in_features % oft_block_size != 0 or oft_block_size > self.in_features:
+                old_oft_block_size = oft_block_size
+                oft_block_size = self.adjust_oft_parameters(self.in_features, oft_block_size)
+                warnings.warn(
+                    f"Invalid `oft_block_size` ({old_oft_block_size})! Adjusted `oft_block_size` to ({oft_block_size})."
+                )
+            r = int(self.in_features // oft_block_size)
+        elif r != 0 and oft_block_size == 0:
+            if self.in_features % r != 0 or r > self.in_features:
+                old_r = r
+                r = self.adjust_oft_parameters(self.in_features, r)
+                warnings.warn(f"Invalid `r` ({old_r})! Adjusted `r` to ({r}).")
+            oft_block_size = int(self.in_features // r)
+        else:
+            raise ValueError(
+                "Something went wrong, please report this error: https://github.com/huggingface/peft/issues"
+            )
+
+        # Create weights with provided shape
+        n_elements = oft_block_size * (oft_block_size - 1) // 2
+        self.oft_R[adapter_name] = OFTRotationModule(
+            r if not block_share else 1,
+            n_elements,
+            oft_block_size,
+            self.in_features,
+            coft=coft,
+            eps=eps,
+            block_share=block_share,
+            use_cayley_neumann=use_cayley_neumann,
+            num_cayley_neumann_terms=num_cayley_neumann_terms,
+        )
+
+        # Initialize weights
+        self.reset_oft_parameters(adapter_name, init_weights)
+
+        # set oft r and block size
+        self.r[adapter_name] = r
+        self.oft_block_size[adapter_name] = oft_block_size
+
+        # Move new weights to device
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def reset_oft_parameters(self, adapter_name, init_weights):
+        """
+        Reset the OFT parameters.
+        """
+        if init_weights is False:
+            if adapter_name in self.oft_R.keys():
+                nn.init.normal_(self.oft_R[adapter_name].weight, mean=0.0, std=0.1)
+                return
+            if adapter_name in self.oft_embedding_R.keys():
+                nn.init.normal_(self.oft_embedding_R[adapter_name].weight, mean=0.0, std=0.1)
+                return
+
+        if adapter_name in self.oft_R.keys():
+            if init_weights is True:
+                # initialize oft_R to zero
+                nn.init.zeros_(self.oft_R[adapter_name].weight)
+            else:
+                raise ValueError(f"Unknown initialization {init_weights=}")
+        if adapter_name in self.oft_embedding_R.keys():
+            if init_weights is True:
+                # initialize oft_embedding_R to zero
+                nn.init.zeros_(self.oft_embedding_R[adapter_name].weight)
+            else:
+                raise ValueError(f"Unknown initialization {init_weights=}")
+
+    def adjust_oft_parameters(self, in_features, params):
+        """
+        Adjust the OFT parameters to be divisible by the in_features dimension.
+        """
+        if params < in_features:
+            higher_params = params
+            while higher_params <= in_features and in_features % higher_params != 0:
+                higher_params += 1
+        else:
+            return in_features
+
+        lower_params = params
+        while lower_params > 1 and in_features % lower_params != 0:
+            lower_params -= 1
+
+        if (params - lower_params) <= (higher_params - params):
+            return lower_params
+        else:
+            return higher_params
+
+
+class Linear(nn.Module, OFTLayer):
+    """OFT implemented in Linear layer"""
+
+    def __init__(
+        self,
+        base_layer,
+        adapter_name: str,
+        config: OFTConfig,
+        r: int = 8,
+        fan_in_fan_out: bool = False,  # Set this to True if the layer to replace stores weight like (fan_in, fan_out)
+        is_target_conv_1d_layer: bool = False,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        OFTLayer.__init__(self, base_layer, **kwargs)
+        self.fan_in_fan_out = fan_in_fan_out
+
+        self._active_adapter = adapter_name
+
+        self.update_layer(
+            adapter_name,
+            r,
+            config=config,
+        )
+        self.is_target_conv_1d_layer = is_target_conv_1d_layer
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If `True`, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If `None`, all active adapters will be merged.
+                Defaults to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.oft_R.keys():
+                base_layer = self.get_base_layer()
+                orig_dtype = base_layer.weight.dtype
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    orig_weights = base_layer.weight.data
+                    oft_mat = self.get_delta_weight(active_adapter)
+                    orig_weights = torch.transpose(orig_weights, 0, 1)
+                    orig_weights = torch.mm(oft_mat, orig_weights.to(oft_mat.dtype))
+                    orig_weights = torch.transpose(orig_weights, 0, 1)
+
+                    if not torch.isfinite(orig_weights).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = orig_weights.contiguous().to(orig_dtype)
+                else:
+                    orig_weights = base_layer.weight.data
+                    oft_mat = self.get_delta_weight(active_adapter)
+                    orig_weights = torch.transpose(orig_weights, 0, 1)
+                    orig_weights = torch.mm(oft_mat, orig_weights.to(oft_mat.dtype))
+                    orig_weights = torch.transpose(orig_weights, 0, 1)
+
+                    base_layer.weight.data = orig_weights.contiguous().to(orig_dtype)
+
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+
+        base_layer = self.get_base_layer()
+        orig_dtype = base_layer.weight.dtype
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.oft_R.keys():
+                oft_mat = self.get_delta_weight(active_adapter)
+
+                previous_dtype = oft_mat.dtype
+                if previous_dtype != torch.float32:
+                    oft_mat = oft_mat.to(torch.float32)
+
+                orig_weights = self.get_base_layer().weight.data
+                orig_weights = torch.transpose(orig_weights, 0, 1)
+                orig_weights = torch.mm(torch.linalg.inv(oft_mat).to(previous_dtype), orig_weights.to(previous_dtype))
+                orig_weights = torch.transpose(orig_weights, 0, 1)
+
+                base_layer.weight.data = orig_weights.to(orig_dtype)
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        """
+        Compute the delta weight for the given adapter.
+
+        Args:
+            adapter (str):
+                The name of the adapter for which the delta weight should be computed.
+        """
+        device = self.oft_R[adapter].weight.device
+        dtype = self.oft_R[adapter].weight.dtype
+
+        # In case users wants to merge the adapter weights that are in
+        # (b)float16 while being on CPU, we need to cast the weights to float32, perform the merge and then cast back to
+        # (b)float16 because some CPUs have slow bf16/fp16 matmuls.
+        cast_to_fp32 = device.type == "cpu" and (dtype == torch.float16 or dtype == torch.bfloat16)
+
+        oft_R_module = self.oft_R[adapter]
+
+        if cast_to_fp32:
+            # Temporarily work in fp32 for faster CPU matmul
+            original_weight = oft_R_module.weight.data
+            oft_R_module.weight.data = oft_R_module.weight.data.float()
+            oft_mat = oft_R_module.get_weight()
+            oft_R_module.weight.data = original_weight  # restore
+            return oft_mat.to(dtype)
+        else:
+            return oft_R_module.get_weight()
+
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        previous_dtype = x.dtype
+
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.oft_R.keys():
+                    continue
+                oft_R = self.oft_R[active_adapter]
+
+                x = self._cast_input_dtype(x, oft_R.weight.dtype)
+                x = oft_R(x)
+
+            result = self.base_layer(x.to(previous_dtype), *args, **kwargs)
+
+        result = result.to(previous_dtype)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "oft." + rep
+
+
+class Conv2d(nn.Module, OFTLayer):
+    """OFT implemented in Conv2d layer"""
+
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        adapter_name: str,
+        config: OFTConfig,
+        r: int = 8,
+        fan_in_fan_out: bool = False,  # Set this to True if the layer to replace stores weight like (fan_in, fan_out)
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        OFTLayer.__init__(self, base_layer)
+        self.fan_in_fan_out = fan_in_fan_out
+
+        self._active_adapter = adapter_name
+
+        # Create adapter and set it active
+        self.update_layer(
+            adapter_name,
+            r,
+            config=config,
+        )
+
+    def update_layer(
+        self,
+        adapter_name,
+        r,
+        config: OFTConfig,
+        inference_mode: bool = False,
+        **kwargs,
+    ):
+        """
+        Update the conv2d layer with trainable OFT weights.
+        """
+        oft_block_size = config.oft_block_size
+        module_dropout = config.module_dropout
+        coft = config.coft
+        eps = config.eps
+        block_share = config.block_share
+        init_weights = config.init_weights
+        use_cayley_neumann = config.use_cayley_neumann
+        num_cayley_neumann_terms = config.num_cayley_neumann_terms
+
+        # Initialize the MultiplicativeDropoutLayer for module_dropout > 0.0.
+        if module_dropout > 0.0:
+            oft_dropout_layer = MultiplicativeDropoutLayer(p=module_dropout)
+        else:
+            oft_dropout_layer = nn.Identity()
+        self.oft_dropout.update(nn.ModuleDict({adapter_name: oft_dropout_layer}))
+
+        # layer information from the base layer
+        base_layer = self.get_base_layer()
+        if base_layer.dilation[0] > 1:
+            raise ValueError("Conv2d with dilation > 1 is not supported by OFT.")
+
+        conv_filter_dim = self.in_features * base_layer.kernel_size[0] * base_layer.kernel_size[0]
+
+        if r == 0 and oft_block_size != 0:
+            if conv_filter_dim % oft_block_size != 0 or oft_block_size > conv_filter_dim:
+                old_oft_block_size = oft_block_size
+                oft_block_size = self.adjust_oft_parameters(conv_filter_dim, oft_block_size)
+                warnings.warn(
+                    f"Invalid `oft_block_size` ({old_oft_block_size})! Adjusted `oft_block_size` to ({oft_block_size})."
+                )
+            r = int(conv_filter_dim // oft_block_size)
+        elif r != 0 and oft_block_size == 0:
+            if conv_filter_dim % r != 0 or r > conv_filter_dim:
+                old_r = r
+                r = self.adjust_oft_parameters(conv_filter_dim, r)
+                warnings.warn(f"Invalid `r` ({old_r})! Adjusted `r` to ({r}).")
+            oft_block_size = int(conv_filter_dim // r)
+        else:
+            raise ValueError(
+                "Something went wrong, please report this error: https://github.com/huggingface/peft/issues"
+            )
+
+        # Create weights with provided shape
+        n_elements = oft_block_size * (oft_block_size - 1) // 2
+        self.oft_R[adapter_name] = OFTRotationModule(
+            r if not block_share else 1,
+            n_elements,
+            oft_block_size,
+            conv_filter_dim,
+            coft=coft,
+            eps=eps,
+            block_share=block_share,
+            kernel_size=base_layer.kernel_size,
+            use_cayley_neumann=use_cayley_neumann,
+            num_cayley_neumann_terms=num_cayley_neumann_terms,
+        )
+
+        # Initialize weights
+        self.reset_oft_parameters(adapter_name, init_weights)
+
+        # set oft r and block size
+        self.r[adapter_name] = r
+        self.oft_block_size[adapter_name] = oft_block_size
+
+        # Move new weights to device
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.oft_R.keys():
+                base_layer = self.get_base_layer()
+                orig_dtype = base_layer.weight.dtype
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    # because of the copy operation.
+                    orig_weights = base_layer.weight.data.clone()
+                    oft_mat = self.get_delta_weight(active_adapter)
+
+                    orig_weights = orig_weights.view(
+                        self.out_features, self.in_features * base_layer.kernel_size[0] * base_layer.kernel_size[0]
+                    )
+                    orig_weights = torch.transpose(orig_weights, 0, 1)
+                    orig_weights = torch.mm(oft_mat, orig_weights.to(oft_mat.dtype))
+                    orig_weights = torch.transpose(orig_weights, 0, 1)
+                    orig_weights = orig_weights.view(
+                        self.out_features, self.in_features, base_layer.kernel_size[0], base_layer.kernel_size[0]
+                    )
+
+                    base_layer.weight.data = orig_weights.contiguous().to(orig_dtype)
+                else:
+                    oft_mat = self.get_delta_weight(active_adapter)
+
+                    orig_weights = base_layer.weight.data.clone()
+                    orig_weights = orig_weights.view(
+                        self.out_features, self.in_features * base_layer.kernel_size[0] * base_layer.kernel_size[0]
+                    )
+                    orig_weights = torch.transpose(orig_weights, 0, 1)
+                    orig_weights = torch.mm(oft_mat, orig_weights.to(oft_mat.dtype))
+                    orig_weights = torch.transpose(orig_weights, 0, 1)
+                    orig_weights = orig_weights.view(
+                        self.out_features, self.in_features, base_layer.kernel_size[0], base_layer.kernel_size[0]
+                    )
+
+                    base_layer.weight.data = orig_weights.contiguous().to(orig_dtype)
+
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+
+        base_layer = self.get_base_layer()
+        orig_dtype = base_layer.weight.dtype
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.oft_R.keys():
+                oft_mat = self.get_delta_weight(active_adapter)
+
+                previous_dtype = oft_mat.dtype
+                if previous_dtype != torch.float32:
+                    oft_mat = oft_mat.to(torch.float32)
+
+                orig_weights = self.get_base_layer().weight.data.clone()
+                orig_weights = orig_weights.view(
+                    self.out_features,
+                    self.in_features * self.get_base_layer().kernel_size[0] * self.get_base_layer().kernel_size[0],
+                )
+                orig_weights = torch.transpose(orig_weights, 0, 1)
+                orig_weights = torch.mm(torch.linalg.inv(oft_mat).to(previous_dtype), orig_weights.to(previous_dtype))
+                orig_weights = torch.transpose(orig_weights, 0, 1)
+                orig_weights = orig_weights.view(
+                    self.out_features,
+                    self.in_features,
+                    self.get_base_layer().kernel_size[0],
+                    self.get_base_layer().kernel_size[0],
+                )
+
+                base_layer.weight.data = orig_weights.to(orig_dtype)
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        """
+        Compute the delta weight for the given adapter.
+
+        Args:
+            adapter (str):
+                The name of the adapter for which the delta weight should be computed.
+        """
+        device = self.oft_R[adapter].weight.device
+        dtype = self.oft_R[adapter].weight.dtype
+
+        # In case users wants to merge the adapter weights that are in
+        # (b)float16 while being on CPU, we need to cast the weights to float32, perform the merge and then cast back to
+        # (b)float16 because some CPUs have slow bf16/fp16 matmuls.
+        cast_to_fp32 = device.type == "cpu" and (dtype == torch.float16 or dtype == torch.bfloat16)
+
+        oft_R_module = self.oft_R[adapter]
+
+        if cast_to_fp32:
+            # Temporarily work in fp32 for faster CPU matmul
+            original_weight = oft_R_module.weight.data
+            oft_R_module.weight.data = oft_R_module.weight.data.float()
+            oft_mat = oft_R_module.get_weight()
+            oft_R_module.weight.data = original_weight  # restore
+            return oft_mat.to(dtype)
+        else:
+            return oft_R_module.get_weight()
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        previous_dtype = x.dtype
+
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.oft_R.keys():
+                    continue
+
+                oft_R = self.oft_R[active_adapter]
+                x = self._cast_input_dtype(x, oft_R.weight.dtype)
+                x = oft_R(x)
+
+            result = self.base_layer(x.to(previous_dtype), *args, **kwargs)
+
+        result = result.to(previous_dtype)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "oft." + rep
+
+
+class Embedding(nn.Module, OFTLayer):
+    # OFT implemented in a Embedding layer
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        adapter_name: str,
+        config: OFTConfig,
+        r: int = 8,
+        fan_in_fan_out: bool = False,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        OFTLayer.__init__(self, base_layer)
+        self.fan_in_fan_out = fan_in_fan_out
+
+        self._active_adapter = adapter_name
+        self.update_layer(
+            adapter_name,
+            r,
+            config=config,
+        )
+
+    def update_layer(
+        self,
+        adapter_name: str,
+        r: int,
+        config: OFTConfig,
+        inference_mode: bool = False,
+        **kwargs,
+    ):
+        oft_block_size = config.oft_block_size
+        coft = config.coft
+        eps = config.eps
+        block_share = config.block_share
+        init_weights = config.init_weights
+        use_cayley_neumann = config.use_cayley_neumann
+        num_cayley_neumann_terms = config.num_cayley_neumann_terms
+
+        if r == 0 and oft_block_size != 0:
+            if self.in_features % oft_block_size != 0 or oft_block_size > self.in_features:
+                old_oft_block_size = oft_block_size
+                oft_block_size = self.adjust_oft_parameters(self.in_features, oft_block_size)
+                warnings.warn(
+                    f"Invalid `oft_block_size` ({old_oft_block_size})! Adjusted `oft_block_size` to ({oft_block_size})."
+                )
+            r = int(self.in_features // oft_block_size)
+        elif r != 0 and oft_block_size == 0:
+            if self.in_features % r != 0 or r > self.in_features:
+                old_r = r
+                r = self.adjust_oft_parameters(self.in_features, r)
+                warnings.warn(f"Invalid `r` ({old_r})! Adjusted `r` to ({r}).")
+            oft_block_size = int(self.in_features // r)
+        else:
+            raise ValueError(
+                "Something went wrong, please report this error: https://github.com/huggingface/peft/issues"
+            )
+
+        # Create weights with provided shape
+        n_elements = oft_block_size * (oft_block_size - 1) // 2
+        self.oft_embedding_R[adapter_name] = OFTRotationModule(
+            r if not block_share else 1,
+            n_elements,
+            oft_block_size,
+            self.in_features,
+            coft=coft,
+            eps=eps,
+            block_share=block_share,
+            use_cayley_neumann=use_cayley_neumann,
+            num_cayley_neumann_terms=num_cayley_neumann_terms,
+        )
+
+        # Initialize weights
+        self.reset_oft_parameters(adapter_name, init_weights)
+
+        # set oft r and block size
+        self.r[adapter_name] = r
+        self.oft_block_size[adapter_name] = oft_block_size
+
+        # Move new weights to device
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`list[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.oft_embedding_R.keys():
+                base_layer = self.get_base_layer()
+                orig_dtype = base_layer.weight.dtype
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    orig_weights = base_layer.weight.data
+                    oft_mat = self.get_delta_weight(active_adapter)
+                    orig_weights = torch.mm(orig_weights.to(oft_mat.dtype), oft_mat)
+
+                    if not torch.isfinite(orig_weights).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = orig_weights.contiguous().to(orig_dtype)
+                else:
+                    orig_weights = base_layer.weight.data
+                    oft_mat = self.get_delta_weight(active_adapter)
+                    orig_weights = torch.mm(orig_weights.to(oft_mat.dtype), oft_mat)
+
+                    base_layer.weight.data = orig_weights.contiguous().to(orig_dtype)
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+
+        base_layer = self.get_base_layer()
+        orig_dtype = base_layer.weight.dtype
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.oft_embedding_R.keys():
+                oft_mat = self.get_delta_weight(active_adapter)
+
+                previous_dtype = oft_mat.dtype
+                if previous_dtype != torch.float32:
+                    oft_mat = oft_mat.to(torch.float32)
+
+                orig_weights = self.get_base_layer().weight.data
+                orig_weights = torch.mm(orig_weights.to(oft_mat.dtype), torch.linalg.inv(oft_mat))
+
+                base_layer.weight.data = orig_weights.to(orig_dtype)
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        """
+        Compute the delta weight for the given adapter.
+
+        Args:
+            adapter (str):
+                The name of the adapter for which the delta weight should be computed.
+        """
+        device = self.oft_embedding_R[adapter].weight.device
+        dtype = self.oft_embedding_R[adapter].weight.dtype
+
+        # In case users wants to merge the adapter weights that are in
+        # (b)float16 while being on CPU, we need to cast the weights to float32, perform the merge and then cast back to
+        # (b)float16 because some CPUs have slow bf16/fp16 matmuls.
+        cast_to_fp32 = device.type == "cpu" and (dtype == torch.float16 or dtype == torch.bfloat16)
+
+        oft_R_module = self.oft_embedding_R[adapter]
+
+        if cast_to_fp32:
+            # Temporarily work in fp32 for faster CPU matmul
+            original_weight = oft_R_module.weight.data
+            oft_R_module.weight.data = oft_R_module.weight.data.float()
+            oft_mat = oft_R_module.get_weight()
+            oft_R_module.weight.data = original_weight  # restore
+            return oft_mat.to(dtype)
+        else:
+            return oft_R_module.get_weight()
+
+    def _embed(self, input: torch.Tensor, weight: torch.Tensor) -> torch.Tensor:
+        base_layer = self.get_base_layer()
+        return F.embedding(
+            input,
+            weight,
+            padding_idx=base_layer.padding_idx,
+            max_norm=base_layer.max_norm,
+            norm_type=base_layer.norm_type,
+            scale_grad_by_freq=base_layer.scale_grad_by_freq,
+            sparse=base_layer.sparse,
+        )
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        # x is token ids (usually LongTensor); rotation is applied to embedding outputs
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            return self.base_layer(x, *args, **kwargs)
+        if self.merged:
+            return self.base_layer(x, *args, **kwargs)
+
+        result = self.base_layer(x, *args, **kwargs)
+        out_dtype = result.dtype
+
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self.oft_embedding_R:
+                continue
+            oft_embedding_R = self.oft_embedding_R[active_adapter]
+            result = self._cast_input_dtype(result, oft_embedding_R.weight.dtype)
+            result = oft_embedding_R(result)
+
+        return result.to(out_dtype)
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "oft." + rep
+
+
+def dispatch_default(
+    target: torch.nn.Module,
+    adapter_name: str,
+    oft_config: OFTConfig,
+    **kwargs,
+) -> Optional[torch.nn.Module]:
+    new_module = None
+
+    if isinstance(target, BaseTunerLayer):
+        target_base_layer = target.get_base_layer()
+    else:
+        target_base_layer = target
+
+    if isinstance(target_base_layer, torch.nn.Conv2d):
+        new_module = Conv2d(target, adapter_name, config=oft_config, **kwargs)
+    elif isinstance(target_base_layer, torch.nn.Linear):
+        if kwargs["fan_in_fan_out"]:
+            warnings.warn(
+                "fan_in_fan_out is set to True but the target module is `torch.nn.Linear`. "
+                "Setting fan_in_fan_out to False."
+            )
+            kwargs["fan_in_fan_out"] = oft_config.fan_in_fan_out = False
+        new_module = Linear(target, adapter_name, config=oft_config, **kwargs)
+    elif isinstance(target_base_layer, torch.nn.Embedding):
+        embedding_kwargs = kwargs.copy()
+        embedding_kwargs.pop("fan_in_fan_out", None)
+        new_module = Embedding(target, adapter_name, config=oft_config, **embedding_kwargs)
+
+    return new_module
diff --git a/src/peft/tuners/oft/model.py b/src/peft/tuners/oft/model.py
new file mode 100644
index 0000000..9ac738e
--- /dev/null
+++ b/src/peft/tuners/oft/model.py
@@ -0,0 +1,185 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+from peft.tuners.tuners_utils import (
+    BaseTuner,
+    get_device_map,
+)
+from peft.utils import (
+    TRANSFORMERS_MODELS_TO_OFT_TARGET_MODULES_MAPPING,
+    get_quantization_config,
+)
+
+from .aqlm import dispatch_aqlm
+from .awq import dispatch_awq
+from .eetq import dispatch_eetq
+from .gptq import dispatch_gptq
+from .hqq import dispatch_hqq
+from .inc import dispatch_inc
+from .layer import OFTLayer, dispatch_default
+
+
+class OFTModel(BaseTuner):
+    """
+    Creates Orthogonal Finetuning model from a pretrained model. The method is described in
+    https://huggingface.co/papers/2306.07280
+
+    Args:
+        model (`torch.nn.Module`): The model to which the adapter tuner layers will be attached.
+        config ([`OFTConfig`]): The configuration of the OFT model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            Create empty adapter weights on meta device. Useful to speed up the loading process.
+
+    Returns:
+        `torch.nn.Module`: The OFT model.
+
+    Example:
+        ```py
+        >>> from diffusers import StableDiffusionPipeline
+        >>> from peft import OFTModel, OFTConfig
+
+        >>> config_te = OFTConfig(
+        ...     r=8,
+        ...     target_modules=["k_proj", "q_proj", "v_proj", "out_proj", "fc1", "fc2"],
+        ...     module_dropout=0.0,
+        ...     init_weights=True,
+        ... )
+        >>> config_unet = OFTConfig(
+        ...     r=8,
+        ...     target_modules=[
+        ...         "proj_in",
+        ...         "proj_out",
+        ...         "to_k",
+        ...         "to_q",
+        ...         "to_v",
+        ...         "to_out.0",
+        ...         "ff.net.0.proj",
+        ...         "ff.net.2",
+        ...     ],
+        ...     module_dropout=0.0,
+        ...     init_weights=True,
+        ... )
+
+        >>> model = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
+        >>> model.text_encoder = OFTModel(model.text_encoder, config_te, "default")
+        >>> model.unet = OFTModel(model.unet, config_unet, "default")
+        ```
+
+    **Attributes**:
+        - **model** ([`~torch.nn.Module`]) -- The model to be adapted.
+        - **peft_config** ([`OFTConfig`]): The configuration of the OFT model.
+    """
+
+    prefix: str = "oft_"
+    tuner_layer_cls = OFTLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_OFT_TARGET_MODULES_MAPPING
+
+    def _create_and_replace(
+        self,
+        oft_config,
+        adapter_name,
+        target,
+        target_name,
+        parent,
+        current_key,
+        **optional_kwargs,
+    ):
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+
+        kwargs = {
+            "r": oft_config.r,
+            "fan_in_fan_out": oft_config.fan_in_fan_out,
+            "loaded_in_8bit": getattr(self.model, "is_loaded_in_8bit", False),
+            "loaded_in_4bit": getattr(self.model, "is_loaded_in_4bit", False),
+        }
+
+        quant_methods = ["gptq", "aqlm", "awq"]
+        for quant_method in quant_methods:
+            quantization_config = get_quantization_config(self.model, method=quant_method)
+            if quantization_config is not None:
+                kwargs[f"{quant_method}_quantization_config"] = quantization_config
+
+        # If it is not a OFTLayer, create a new module, else update it with new adapters
+        if not isinstance(target, OFTLayer):
+            device_map = get_device_map(self.model)
+            new_module = self._create_new_module(oft_config, adapter_name, target, device_map=device_map, **kwargs)
+            if adapter_name not in self.active_adapters:
+                # adding an additional adapter: it is not automatically trainable
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+        else:
+            target.update_layer(
+                adapter_name,
+                r=oft_config.r,
+                config=oft_config,
+            )
+
+    @staticmethod
+    def _create_new_module(oft_config, adapter_name, target, **kwargs):
+        # Collect dispatcher functions to decide what backend to use for the replaced OFT layer. The order matters,
+        # because the first match is always used. Therefore, the default layers should be checked last.
+        dispatchers = []
+
+        # avoid eager bnb import
+        if is_bnb_available():
+            from .bnb import dispatch_bnb_8bit
+
+            dispatchers.append(dispatch_bnb_8bit)
+
+        if is_bnb_4bit_available():
+            from .bnb import dispatch_bnb_4bit
+
+            dispatchers.append(dispatch_bnb_4bit)
+
+        dispatchers.extend(
+            [
+                dispatch_eetq,
+                dispatch_aqlm,
+                dispatch_awq,
+                dispatch_gptq,
+                dispatch_hqq,
+                dispatch_inc,
+                dispatch_default,
+            ]
+        )
+
+        new_module = None
+        for dispatcher in dispatchers:
+            new_module = dispatcher(target, adapter_name, oft_config=oft_config, **kwargs)
+            if new_module is not None:  # first match wins
+                break
+
+        if new_module is None:
+            # no module could be matched
+            raise ValueError(
+                f"Target module {target} is not supported. Currently, only the following modules are supported: "
+                "`torch.nn.Linear`, `torch.nn.Conv2d`."
+            )
+
+        return new_module
+
+    def _check_merge_allowed(self):
+        """Verify that the configuration supports merging.
+
+        Currently gptq quantization and replicated layers do not support merging.
+        """
+        super()._check_merge_allowed()
+        if getattr(self.model, "quantization_method", None) == "gptq":
+            raise ValueError("Cannot merge OFT layers when the model is gptq quantized")
+        if self.peft_config.get("layer_replication"):
+            raise ValueError("Cannot merge OFT layers when base model layers are replicated")
diff --git a/src/peft/tuners/osf/__init__.py b/src/peft/tuners/osf/__init__.py
new file mode 100644
index 0000000..801e93f
--- /dev/null
+++ b/src/peft/tuners/osf/__init__.py
@@ -0,0 +1,15 @@
+from peft.utils import register_peft_method
+
+from .config import OSFConfig
+from .layer import Linear, OSFLayer
+from .model import OSFModel
+
+
+__all__ = ["Linear", "OSFConfig", "OSFLayer", "OSFModel"]
+
+register_peft_method(
+    name="osf",
+    config_cls=OSFConfig,
+    model_cls=OSFModel,
+    is_mixed_compatible=False,
+)
diff --git a/src/peft/tuners/osf/config.py b/src/peft/tuners/osf/config.py
new file mode 100644
index 0000000..77a0896
--- /dev/null
+++ b/src/peft/tuners/osf/config.py
@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class OSFConfig(PeftConfig):
+    """
+    Configuration for Orthogonal Subspace Fine-tuning (OSF).
+
+    Args:
+        effective_rank (`int` or `float`, *optional*):
+            Preserved SVD rank ("high" subspace). The top-``effective_rank`` singular directions are frozen and
+            retained across tasks; the remaining dimensions form the trainable low-rank subspace. If `None`, defaults
+            to 50% of the smaller weight dimension per target module. Note: This differs from LoRA's `r` (trainable
+            rank). In OSF, the trainable rank is `min(weight.shape) - effective_rank`.
+        target_modules (`Union[list[str], str]`, *optional*):
+            The names of the modules to apply OSF to. Can be a list of module names or `"all-linear"`.
+        rank_pattern (`dict[str, int|float]`, *optional*):
+            A dictionary of regex patterns to override `effective_rank` for specific modules. Values can be absolute
+            integers or fractions in (0, 1], interpreted as a fraction of the smaller matrix dimension per target.
+    """
+
+    effective_rank: Optional[Union[int, float]] = field(
+        default=None,
+        metadata={
+            "help": (
+                'Preserved SVD rank ("high" subspace). The top-`effective_rank` singular directions are frozen '
+                "and retained across tasks; the remaining dimensions form the trainable low-rank subspace. "
+                "Trainable rank equals min(weight.shape) - effective_rank. If None, defaults to 50% of the smaller "
+                "weight dimension per target module. Floats in (0, 1] are interpreted as a fraction of the smaller "
+                "matrix dimension per target."
+            )
+        },
+    )
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={"help": "The names of the modules to apply OSF to. Can be a list of module names or 'all-linear'."},
+    )
+    rank_pattern: Optional[dict[str, Union[int, float]]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "A dictionary of regex patterns to override effective_rank per module. Values can be absolute "
+                "integers or fractions in (0, 1], interpreted as a fraction of the smaller matrix dimension."
+            )
+        },
+    )
+
+    # Additional optional fields for compatibility with generic test harnesses
+    init_weights: Optional[bool] = field(
+        default=None,
+        metadata={
+            "help": (
+                "If provided, toggles custom weight initialization behavior for certain methods. OSF ignores this "
+                "flag but accepts it for config compatibility."
+            )
+        },
+    )
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={"help": "Optional list of module names to save separately (ignored by OSF but accepted)."},
+    )
+    target_svd_config: Optional[dict[str, int]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "Optional per-parameter SVD target rank mapping (e.g., {'lin0.weight': 8}). OSF currently ignores "
+                "this field but accepts it for forward compatibility."
+            )
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.OSF
diff --git a/src/peft/tuners/osf/layer.py b/src/peft/tuners/osf/layer.py
new file mode 100644
index 0000000..aef0f0b
--- /dev/null
+++ b/src/peft/tuners/osf/layer.py
@@ -0,0 +1,289 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import warnings
+from functools import partial
+from typing import Any, Optional
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from peft.tuners._buffer_dict import BufferDict
+from peft.tuners.tuners_utils import BaseTunerLayer
+
+from .config import OSFConfig
+from .utils import (
+    decompose_weight_matrix,
+    reconstruct_weight_matrix,
+)
+
+
+class OSFLayer(BaseTunerLayer):
+    # All names of layers that may contain (trainable) adapter weights
+    adapter_layer_names: tuple[str, ...] = ("osf_svd_params",)
+    # All names of other parameters that may contain adapter-related parameters
+    other_param_names: tuple[str, ...] = ("_osf_U_high", "_osf_S_high", "_osf_V_high", "effective_rank")
+
+    def __init__(self, base_layer: nn.Module, **kwargs) -> None:
+        self.base_layer = base_layer
+        self.effective_rank = {}
+        # Map adapter_name -> ParameterDict{"U_low", "S_low", "V_low"}
+        self.osf_svd_params = nn.ModuleDict({})
+        # Store high-rank (frozen) components as buffers that track device moves
+        self._osf_U_high = BufferDict({})
+        self._osf_S_high = BufferDict({})
+        self._osf_V_high = BufferDict({})
+        # Track hook handles for cleanup
+        self.hook_handles = []
+        # Mark the weight as unmerged
+        self._disable_adapters = False
+        self.merged_adapters = []
+
+        # Get layer dimensions
+        base_layer = self.get_base_layer()
+        # Prefer the universally available weight shape when possible.
+        if (
+            hasattr(base_layer, "weight")
+            and isinstance(base_layer.weight, torch.Tensor)
+            and base_layer.weight.ndim == 2
+        ):
+            # For Linear-like modules, weight is [out_features, in_features]
+            out_features, in_features = base_layer.weight.shape
+        elif isinstance(base_layer, nn.Linear):
+            in_features, out_features = base_layer.in_features, base_layer.out_features
+        elif hasattr(base_layer, "infeatures") and hasattr(base_layer, "outfeatures"):
+            # QuantLinear
+            in_features, out_features = base_layer.infeatures, base_layer.outfeatures
+        elif hasattr(base_layer, "input_size") and hasattr(base_layer, "output_size"):
+            # Megatron ColumnParallelLinear, RowParallelLinear
+            in_features, out_features = base_layer.input_size, base_layer.output_size
+        elif hasattr(base_layer, "in_features") and hasattr(base_layer, "out_features"):
+            in_features, out_features = base_layer.in_features, base_layer.out_features
+        else:
+            in_features, out_features = None, None
+            warnings.warn(
+                f"Unsupported layer type '{type(base_layer)}' encountered; could not infer in/out features.",
+                UserWarning,
+            )
+
+        self.in_features = in_features
+        self.out_features = out_features
+
+    def update_layer(self, adapter_name: str, effective_rank: int, config: OSFConfig, **kwargs):
+        """Update layer to add a new OSF adapter."""
+        if effective_rank <= 0:
+            raise ValueError(
+                f"`effective_rank` should be a positive integer value but the value passed is {effective_rank}"
+            )
+
+        # Store the rank for this adapter
+        self.effective_rank[adapter_name] = effective_rank
+
+        # Perform SVD decomposition on the base layer weight
+        base_layer = self.get_base_layer()
+        weight = base_layer.weight.data
+        svd_dict = decompose_weight_matrix(weight, top_k=effective_rank)
+
+        # Store high-rank (frozen) components as buffers
+        self._osf_U_high[adapter_name] = svd_dict["U_high"]
+        self._osf_S_high[adapter_name] = svd_dict["S_high"]
+        self._osf_V_high[adapter_name] = svd_dict["V_high"]
+
+        # Create ParameterDict for trainable low-rank components
+        svd_params = nn.ParameterDict(
+            {
+                "U_low": svd_dict["U_low"],
+                "S_low": svd_dict["S_low"],
+                "V_low": svd_dict["V_low"],
+            }
+        )
+        self.osf_svd_params[adapter_name] = svd_params
+
+        # Attach gradient hooks for orthogonal projection
+        self._attach_hooks(adapter_name)
+
+        # Set the adapter as active
+        self.set_adapter(self.active_adapters)
+
+    def _attach_hooks(self, adapter_name: str):
+        """Attach gradient hooks for the given adapter."""
+        if adapter_name not in self.osf_svd_params:
+            return
+
+        svd_module = self.osf_svd_params[adapter_name]
+
+        def hook(grad, name: str, adapter: str, layer: OSFLayer):
+            # Project gradient to be orthogonal to high-rank subspace for U_low/V_low
+            # Access buffers dynamically to ensure they're on the correct device
+            if name == "U_low":
+                U_high = layer._osf_U_high[adapter]
+                proj = U_high @ (U_high.transpose(0, 1) @ grad)
+                return grad - proj
+            elif name == "V_low":
+                V_high = layer._osf_V_high[adapter]
+                proj = (grad @ V_high.transpose(0, 1)) @ V_high
+                return grad - proj
+            return grad
+
+        # Store hook handles for later cleanup
+        handle_u = svd_module["U_low"].register_hook(partial(hook, name="U_low", adapter=adapter_name, layer=self))
+        handle_v = svd_module["V_low"].register_hook(partial(hook, name="V_low", adapter=adapter_name, layer=self))
+
+        self.hook_handles.extend([handle_u, handle_v])
+
+    def _detach_hooks(self):
+        """Remove all gradient hooks."""
+        for handle in self.hook_handles:
+            handle.remove()
+        self.hook_handles.clear()
+
+    def _reconstruct_weight(self, adapter_name: str) -> torch.Tensor:
+        """Reconstruct weight matrix from SVD components for given adapter."""
+        if adapter_name not in self.osf_svd_params:
+            return self.get_base_layer().weight
+
+        svd_module = self.osf_svd_params[adapter_name]
+        svd_dict = {
+            "U_high": self._osf_U_high[adapter_name],
+            "S_high": self._osf_S_high[adapter_name],
+            "V_high": self._osf_V_high[adapter_name],
+            "U_low": svd_module["U_low"],
+            "S_low": svd_module["S_low"],
+            "V_low": svd_module["V_low"],
+        }
+        return reconstruct_weight_matrix(svd_dict)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`list[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        if adapter_names is None:
+            adapter_names = self.active_adapters
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.osf_svd_params.keys():
+                base_layer = self.get_base_layer()
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    # because of the copy operation.
+                    orig_weight = base_layer.weight.data.clone()
+                    new_weight = self._reconstruct_weight(active_adapter)
+
+                    if not torch.isfinite(new_weight).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = new_weight.to(orig_weight.dtype)
+                else:
+                    new_weight = self._reconstruct_weight(active_adapter)
+                    base_layer.weight.data = new_weight
+
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+
+        # For OSF, unmerging means restoring the original weight
+        # Since we modify the weight in-place, we need to store the original weight
+        # This is a limitation of the current OSF implementation
+        warnings.warn("OSF does not support unmerging. Original weights are permanently modified.")
+
+    def __del__(self):
+        """Cleanup hooks on deletion."""
+        self._detach_hooks()
+
+
+class Linear(nn.Module, OSFLayer):
+    # OSF implemented in a dense layer
+    def __init__(
+        self,
+        base_layer,
+        adapter_name: str,
+        config: OSFConfig,
+        effective_rank: Optional[int] = None,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        OSFLayer.__init__(self, base_layer, **kwargs)
+
+        # Set default effective_rank if not provided
+        if effective_rank is None:
+            # Default to 50% of min dimension
+            effective_rank = min(self.in_features, self.out_features) // 2
+
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, effective_rank, config=config, **kwargs)
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        if self.disable_adapters or self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            # Use reconstructed weight for forward pass
+            base_layer = self.get_base_layer()
+            bias = base_layer.bias
+
+            # Use the active adapter's reconstructed weight
+            active_adapter = self.active_adapters[0] if self.active_adapters else None
+            if active_adapter and active_adapter in self.osf_svd_params:
+                weight = self._reconstruct_weight(active_adapter)
+                orig_dtype = x.dtype  # assume that the intended dtype is that of the input
+                x = self._cast_input_dtype(x, weight.dtype)
+                if bias is not None:
+                    bias = bias.to(weight.dtype)
+                result = F.linear(x, weight, bias)
+                result = result.to(orig_dtype)
+            else:
+                result = self.base_layer(x, *args, **kwargs)
+
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "osf." + rep
+
+
+def dispatch_default(
+    target: torch.nn.Module,
+    adapter_name: str,
+    osf_config: OSFConfig,
+    **kwargs,
+) -> Optional[torch.nn.Module]:
+    new_module = None
+
+    if isinstance(target, BaseTunerLayer):
+        target_base_layer = target.get_base_layer()
+    else:
+        target_base_layer = target
+
+    if isinstance(target_base_layer, torch.nn.Linear):
+        new_module = Linear(target, adapter_name, config=osf_config, **kwargs)
+
+    return new_module
diff --git a/src/peft/tuners/osf/model.py b/src/peft/tuners/osf/model.py
new file mode 100644
index 0000000..9a55351
--- /dev/null
+++ b/src/peft/tuners/osf/model.py
@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+import re
+
+import torch
+from torch import nn
+
+from peft.tuners.tuners_utils import BaseTuner
+from peft.utils.constants import TRANSFORMERS_MODELS_TO_OSF_TARGET_MODULES_MAPPING
+
+from .layer import OSFLayer, dispatch_default
+
+
+class OSFModel(BaseTuner):
+    """A minimal tuner implementing Orthogonal Subspace Fine-tuning."""
+
+    prefix: str = "osf_"
+    tuner_layer_cls = OSFLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_OSF_TARGET_MODULES_MAPPING
+
+    def __init__(
+        self,
+        model,
+        config,
+        adapter_name,
+        low_cpu_mem_usage: bool = False,
+        state_dict: dict[str, torch.Tensor] | None = None,
+    ):
+        # Pass state_dict through for compatibility with BaseTuner
+        super().__init__(
+            model,
+            config,
+            adapter_name,
+            low_cpu_mem_usage=low_cpu_mem_usage,
+            state_dict=state_dict,
+        )
+
+    def __getattr__(self, name: str):
+        """Forward missing attributes to the wrapped base model.
+
+        This mirrors the behavior of other tuners (e.g., LoRA), ensuring attributes like `device` resolve to the
+        underlying transformers model.
+        """
+        try:
+            return super().__getattr__(name)  # defer to nn.Module's logic
+        except AttributeError:
+            if name == "model":  # avoid infinite recursion during init
+                raise
+            return getattr(self.model, name)
+
+    def _prepare_adapter_config(self, peft_config, model_config):
+        # If target_modules is unspecified, try mapping; else fall back to all linear layers for custom models
+        if peft_config.target_modules is None:
+            target_modules = self.target_module_mapping.get(model_config["model_type"])
+            if target_modules is not None:
+                peft_config = super()._prepare_adapter_config(peft_config, model_config)
+            else:
+                from peft.utils.constants import INCLUDE_LINEAR_LAYERS_SHORTHAND
+
+                peft_config.target_modules = INCLUDE_LINEAR_LAYERS_SHORTHAND
+        return peft_config
+
+    def _create_and_replace(
+        self,
+        osf_config,
+        adapter_name: str,
+        target: nn.Module,
+        target_name: str,
+        parent: nn.Module,
+        current_key: str,
+        *,
+        parameter_name: str | None = None,
+    ) -> None:
+        # OSF only works on 2D weight matrices
+        if not hasattr(target, "weight") or len(target.weight.shape) != 2:
+            return
+
+        # Determine effective rank for this target (supports int or fractional in (0,1])
+        def _resolve_rank(value, min_dim: int) -> int:
+            if value is None:
+                return max(min_dim // 2, 0)
+            # floats in (0,1] => fraction of min_dim
+            if isinstance(value, float) and 0 < value <= 1:
+                r = int(min_dim * value)
+            else:
+                r = int(value)
+            return max(min(min_dim, r), 0)
+
+        min_dim = min(target.weight.shape)
+        effective_rank = _resolve_rank(getattr(osf_config, "effective_rank", None), min_dim)
+
+        # Check for per-module rank overrides (allow int or fractional)
+        if hasattr(osf_config, "rank_pattern") and osf_config.rank_pattern:
+            for pattern, rank in osf_config.rank_pattern.items():
+                if re.search(pattern, current_key):
+                    effective_rank = _resolve_rank(rank, min_dim)
+                    break
+
+        kwargs = {
+            "effective_rank": effective_rank,
+        }
+
+        # Create a new or update an existing OSF layer in place
+        if isinstance(target, OSFLayer):
+            target.update_layer(adapter_name, config=osf_config, **kwargs)
+        else:
+            new_module = dispatch_default(target, adapter_name, osf_config, **kwargs)
+            if new_module is None:
+                return
+            # If adding an additional adapter, keep it frozen initially
+            if adapter_name not in self.active_adapters:
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+    def _mark_only_adapters_as_trainable(self, model: nn.Module) -> None:
+        for n, p in model.named_parameters():
+            # Only OSF adapter parameters (in osf_svd_params) should be trainable
+            if "osf_svd_params" not in n:
+                p.requires_grad = False
+
+    # Use BaseTuner's merge and merge_and_unload implementations.
+    # Explicitly disallow unmerging at the model level for OSF.
+    def unmerge_adapter(self, *args, **kwargs):
+        raise NotImplementedError("OSF models do not support unmerging")
diff --git a/src/peft/tuners/osf/utils.py b/src/peft/tuners/osf/utils.py
new file mode 100644
index 0000000..0030e22
--- /dev/null
+++ b/src/peft/tuners/osf/utils.py
@@ -0,0 +1,133 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+"""Utilities for Orthogonal Subspace Learning with Adaptive OSF."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import torch
+import torch.distributed as dist
+from torch import nn
+
+
+# Note: OSF now relies on OSFLayer + BaseTuner; no model-level helpers required here.
+
+
+__all__ = [
+    "decompose_weight_matrix",
+    "project_gradient_to_orthogonal_space",
+    "reconstruct_weight_matrix",
+]
+
+
+def _wait_if_async(tensor):
+    """Wait for AsyncCollectiveTensor if needed, otherwise return tensor as-is."""
+    if hasattr(tensor, "wait"):
+        return tensor.wait()
+    return tensor
+
+
+def decompose_weight_matrix(weight: torch.Tensor, top_k: int) -> dict[str, Any]:
+    """Perform an SVD of ``weight`` and split it into frozen and trainable parts."""
+    device_local = weight.device
+    orig_dtype = weight.dtype
+    W = weight.to(torch.float32)
+    U, S, Vt = torch.linalg.svd(W, full_matrices=False)
+    k = min(top_k, S.shape[0])
+
+    svd = {
+        "U_high": U[:, :k].contiguous().detach().to(device=device_local, dtype=orig_dtype),
+        "S_high": S[:k].contiguous().detach().to(device=device_local, dtype=orig_dtype),
+        "V_high": Vt[:k, :].contiguous().detach().to(device=device_local, dtype=orig_dtype),
+        "U_low": nn.Parameter(U[:, k:].contiguous().detach().to(device=device_local, dtype=orig_dtype)),
+        "S_low": nn.Parameter(S[k:].contiguous().detach().to(device=device_local, dtype=orig_dtype)),
+        "V_low": nn.Parameter(Vt[k:, :].contiguous().detach().to(device=device_local, dtype=orig_dtype)),
+        "rank_high": k,
+    }
+    return svd
+
+
+def reconstruct_weight_matrix(svd_dict: dict[str, torch.Tensor]) -> torch.Tensor:
+    """Reconstruct a weight matrix from its SVD components."""
+    U_high = svd_dict["U_high"]
+    S_high = svd_dict["S_high"]
+    V_high = svd_dict["V_high"]
+    U_low = svd_dict["U_low"]
+    S_low = svd_dict["S_low"]
+    V_low = svd_dict["V_low"]
+
+    high_part = (
+        torch.mm(U_high * S_high.unsqueeze(0), V_high)
+        if U_high.numel() > 0 and S_high.numel() > 0
+        else torch.zeros(U_low.size(0), V_low.size(1), device=U_high.device)
+    )
+    low_part = (
+        torch.mm(U_low * S_low.unsqueeze(0), V_low)
+        if U_low.numel() > 0 and S_low.numel() > 0
+        else torch.zeros(U_high.size(0), V_high.size(1), device=U_low.device)
+    )
+    return high_part + low_part
+
+
+def project_gradient_to_orthogonal_space(svd_dict: dict[str, Any]) -> None:
+    """Project gradients of ``U_low`` and ``V_low`` to be orthogonal to the high rank space."""
+    if svd_dict["U_low"].grad is None and svd_dict["S_low"].grad is None and svd_dict["V_low"].grad is None:
+        return
+
+    U_high = svd_dict["U_high"]
+    V_high = svd_dict["V_high"]
+
+    # Project U_low gradients to space orthogonal to U_high
+    if svd_dict["U_low"].grad is not None:
+        dU = svd_dict["U_low"].grad
+        # Support distributed tensors by operating on the local shard
+        local_U_high = getattr(U_high, "to_local", lambda: U_high)()
+        local_dU = getattr(dU, "to_local", lambda: dU)()
+
+        # Perform projection computation using memory-efficient operations
+        # Memory-optimized projection: dU = dU - U_high @ (U_high.T @ dU)
+        # Use addmm_ for efficient in-place operation
+        # Compute local contribution to (U_high^T @ dU); all-reduce to get global projection
+        proj_coeff = torch.mm(local_U_high.transpose(0, 1), local_dU)
+        if dist.is_available() and dist.is_initialized() and dist.get_world_size() > 1:
+            dist.all_reduce(proj_coeff, op=dist.ReduceOp.SUM)
+        # Apply projection using only local rows of U_high
+        local_dU.addmm_(local_U_high, proj_coeff, alpha=-1.0)
+
+        if hasattr(dU, "_local_tensor"):
+            dU._local_tensor.copy_(local_dU)
+        else:
+            dU.copy_(local_dU)
+
+    # Repeat projection for V_low using V_high
+    if svd_dict["V_low"].grad is not None:
+        dV = svd_dict["V_low"].grad
+        local_V_high = getattr(V_high, "to_local", lambda: V_high)()
+        local_dV = getattr(dV, "to_local", lambda: dV)()
+
+        # Compute Gram matrix G = V_high^T @ V_high for global projection across row-sharded V_high
+        # Assumes column dimension is consistent across ranks (row sharding over singular vectors)
+        G_local = torch.mm(local_V_high.transpose(0, 1), local_V_high)
+        if dist.is_available() and dist.is_initialized() and dist.get_world_size() > 1:
+            dist.all_reduce(G_local, op=dist.ReduceOp.SUM)
+
+        # Apply projection: dV = dV - dV @ G (use local shard of dV)
+        update = torch.mm(local_dV, G_local)
+        local_dV.add_(update, alpha=-1.0)
+
+        if hasattr(dV, "_local_tensor"):
+            dV._local_tensor.copy_(local_dV)
+        else:
+            dV.copy_(local_dV)
diff --git a/src/peft/tuners/p_tuning/__init__.py b/src/peft/tuners/p_tuning/__init__.py
new file mode 100644
index 0000000..9195c0d
--- /dev/null
+++ b/src/peft/tuners/p_tuning/__init__.py
@@ -0,0 +1,23 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from peft.utils import register_peft_method
+
+from .config import PromptEncoderConfig, PromptEncoderReparameterizationType
+from .model import PromptEncoder
+
+
+__all__ = ["PromptEncoder", "PromptEncoderConfig", "PromptEncoderReparameterizationType"]
+
+register_peft_method(name="p_tuning", config_cls=PromptEncoderConfig, model_cls=PromptEncoder)
diff --git a/src/peft/tuners/p_tuning/config.py b/src/peft/tuners/p_tuning/config.py
new file mode 100644
index 0000000..a69c13d
--- /dev/null
+++ b/src/peft/tuners/p_tuning/config.py
@@ -0,0 +1,60 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import enum
+from dataclasses import dataclass, field
+from typing import Union
+
+from peft.config import PromptLearningConfig
+from peft.utils import PeftType
+
+
+class PromptEncoderReparameterizationType(str, enum.Enum):
+    MLP = "MLP"
+    LSTM = "LSTM"
+
+
+@dataclass
+class PromptEncoderConfig(PromptLearningConfig):
+    """
+    This is the configuration class to store the configuration of a [`PromptEncoder`].
+
+    Args:
+        encoder_reparameterization_type (Union[[`PromptEncoderReparameterizationType`], `str`]):
+            The type of reparameterization to use.
+        encoder_hidden_size (`int`): The hidden size of the prompt encoder.
+        encoder_num_layers (`int`): The number of layers of the prompt encoder.
+        encoder_dropout (`float`): The dropout probability of the prompt encoder.
+    """
+
+    encoder_reparameterization_type: Union[str, PromptEncoderReparameterizationType] = field(
+        default=PromptEncoderReparameterizationType.MLP,
+        metadata={"help": "How to reparameterize the prompt encoder"},
+    )
+    encoder_hidden_size: int = field(
+        default=None,
+        metadata={"help": "The hidden size of the prompt encoder"},
+    )
+    encoder_num_layers: int = field(
+        default=2,
+        metadata={"help": "The number of layers of the prompt encoder"},
+    )
+    encoder_dropout: float = field(
+        default=0.0,
+        metadata={"help": "The dropout of the prompt encoder"},
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.P_TUNING
diff --git a/src/peft/tuners/p_tuning/model.py b/src/peft/tuners/p_tuning/model.py
new file mode 100644
index 0000000..ade2b11
--- /dev/null
+++ b/src/peft/tuners/p_tuning/model.py
@@ -0,0 +1,130 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+# Based on https://github.com/NVIDIA/NeMo/blob/main/nemo/collections/nlp/modules/common/prompt_encoder.py
+# with some refactor
+import warnings
+
+import torch
+
+from .config import PromptEncoderConfig, PromptEncoderReparameterizationType
+
+
+class PromptEncoder(torch.nn.Module):
+    """
+    The prompt encoder network that is used to generate the virtual token embeddings for p-tuning.
+
+    Args:
+        config ([`PromptEncoderConfig`]): The configuration of the prompt encoder.
+
+    Example:
+
+    ```py
+    >>> from peft import PromptEncoder, PromptEncoderConfig
+
+    >>> config = PromptEncoderConfig(
+    ...     peft_type="P_TUNING",
+    ...     task_type="SEQ_2_SEQ_LM",
+    ...     num_virtual_tokens=20,
+    ...     token_dim=768,
+    ...     num_transformer_submodules=1,
+    ...     num_attention_heads=12,
+    ...     num_layers=12,
+    ...     encoder_reparameterization_type="MLP",
+    ...     encoder_hidden_size=768,
+    ... )
+
+    >>> prompt_encoder = PromptEncoder(config)
+    ```
+
+    **Attributes**:
+        - **embedding** (`torch.nn.Embedding`) -- The embedding layer of the prompt encoder.
+        - **mlp_head** (`torch.nn.Sequential`) -- The MLP head of the prompt encoder if `inference_mode=False`.
+        - **lstm_head** (`torch.nn.LSTM`) -- The LSTM head of the prompt encoder if `inference_mode=False` and
+        `encoder_reparameterization_type="LSTM"`.
+        - **token_dim** (`int`) -- The hidden embedding dimension of the base transformer model.
+        - **input_size** (`int`) -- The input size of the prompt encoder.
+        - **output_size** (`int`) -- The output size of the prompt encoder.
+        - **hidden_size** (`int`) -- The hidden size of the prompt encoder.
+        - **total_virtual_tokens** (`int`): The total number of virtual tokens of the
+        prompt encoder.
+        - **encoder_type** (Union[[`PromptEncoderReparameterizationType`], `str`]): The encoder type of the prompt
+          encoder.
+
+
+    Input shape: (`batch_size`, `total_virtual_tokens`)
+
+    Output shape: (`batch_size`, `total_virtual_tokens`, `token_dim`)
+    """
+
+    def __init__(self, config):
+        super().__init__()
+        self.token_dim = config.token_dim
+        self.input_size = self.token_dim
+        self.output_size = self.token_dim
+        self.hidden_size = config.encoder_hidden_size
+        self.total_virtual_tokens = config.num_virtual_tokens * config.num_transformer_submodules
+        self.encoder_type = config.encoder_reparameterization_type
+
+        # embedding
+        self.embedding = torch.nn.Embedding(self.total_virtual_tokens, self.token_dim)
+        if not config.inference_mode:
+            if self.encoder_type == PromptEncoderReparameterizationType.LSTM:
+                lstm_dropout = config.encoder_dropout
+                num_layers = config.encoder_num_layers
+                # LSTM
+                self.lstm_head = torch.nn.LSTM(
+                    input_size=self.input_size,
+                    hidden_size=self.hidden_size,
+                    num_layers=num_layers,
+                    dropout=lstm_dropout,
+                    bidirectional=True,
+                    batch_first=True,
+                )
+
+                self.mlp_head = torch.nn.Sequential(
+                    torch.nn.Linear(self.hidden_size * 2, self.hidden_size * 2),
+                    torch.nn.ReLU(),
+                    torch.nn.Linear(self.hidden_size * 2, self.output_size),
+                )
+
+            elif self.encoder_type == PromptEncoderReparameterizationType.MLP:
+                encoder_num_layers_default = PromptEncoderConfig.encoder_num_layers
+                if config.encoder_num_layers != encoder_num_layers_default:
+                    warnings.warn(
+                        f"for {self.encoder_type.value}, the argument `encoder_num_layers` is ignored. "
+                        f"Exactly {encoder_num_layers_default} MLP layers are used."
+                    )
+                layers = [
+                    torch.nn.Linear(self.input_size, self.hidden_size),
+                    torch.nn.ReLU(),
+                    torch.nn.Linear(self.hidden_size, self.hidden_size),
+                    torch.nn.ReLU(),
+                    torch.nn.Linear(self.hidden_size, self.output_size),
+                ]
+                self.mlp_head = torch.nn.Sequential(*layers)
+
+            else:
+                raise ValueError("Prompt encoder type not recognized. Please use one of MLP (recommended) or LSTM.")
+
+    def forward(self, indices):
+        input_embeds = self.embedding(indices)
+        if self.encoder_type == PromptEncoderReparameterizationType.LSTM:
+            output_embeds = self.mlp_head(self.lstm_head(input_embeds)[0])
+        elif self.encoder_type == PromptEncoderReparameterizationType.MLP:
+            output_embeds = self.mlp_head(input_embeds)
+        else:
+            raise ValueError("Prompt encoder type not recognized. Please use one of MLP (recommended) or LSTM.")
+
+        return output_embeds
diff --git a/src/peft/tuners/peanut/__init__.py b/src/peft/tuners/peanut/__init__.py
new file mode 100644
index 0000000..cd278f2
--- /dev/null
+++ b/src/peft/tuners/peanut/__init__.py
@@ -0,0 +1,27 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+from peft.utils import PeftType, register_peft_method
+
+from .config import PeanutConfig
+from .layer import Linear, PeanutLayer
+from .model import PeanutModel
+
+
+__all__ = ["Linear", "PeanutConfig", "PeanutLayer", "PeanutModel"]
+
+if "PEANUT" in PeftType.__members__:
+    register_peft_method(
+        name="peanut", config_cls=PeanutConfig, model_cls=PeanutModel, prefix="peanut_", is_mixed_compatible=False
+    )
diff --git a/src/peft/tuners/peanut/config.py b/src/peft/tuners/peanut/config.py
new file mode 100644
index 0000000..c3d1697
--- /dev/null
+++ b/src/peft/tuners/peanut/config.py
@@ -0,0 +1,192 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Optional, Union
+
+from transformers.activations import ACT2FN
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class PeanutConfig(PeftConfig):
+    """
+    This is the configuration class to store the configuration of a [`PeanutModel`].
+
+    Args:
+        r (`int`):
+            PEANuT rank. This is the hidden dimension used by the adapters. Similar to LoRA rank, larger `r` increases
+            adapter capacity and trainable parameters.
+        depth (`int`):
+            Number of hidden adapter layers per encoder/decoder side in PEANuT. The input projection `A` and output
+            projection `B` are always present in addition to these hidden layers. Therefore, `depth` must be a
+            non-negative integer.
+
+            - `depth=0`: `A`, `B`.
+            - `depth=1`: `A`, one encoder, one decoder, `B`.
+            - `depth=2`: `A`, two encoders, two decoders, `B`.
+            - `depth=3`: `A`, three encoders, three decoders, `B`, etc.
+        act_fn (`str`):
+            Non-linear activation applied in the PEANuT network. This corresponds to `non_linear` in the vanilla
+            PyTorch implementation. Default is `"relu"`. Any activation key available in
+            `transformers.activations.ACT2FN` is supported and may perform better on different tasks.
+        scaling (`float`):
+            A scalar multiplier applied to the PEANuT output before adding it to the frozen base layer output. The
+            final adapter contribution is `scaling * (x @ delta_w)`.
+        target_modules (`Union[List[str], str]`, *optional*):
+            The names of the modules to apply PEANuT to. Can be a list of module name strings (e.g. `['q_proj',
+            'v_proj']`) or a regex pattern.
+        modules_to_save (`List[str]`, *optional*):
+            List of modules apart from PEANuT layers to be set as trainable and saved in the final checkpoint.
+        exclude_modules (`Union[List[str], str]`, *optional*):
+            The names of the modules to not apply the adapter. When passing a string, a regex match will be performed.
+            When passing a list of strings, either an exact match will be performed or it is checked if the name of the
+            module ends with any of the passed strings.
+        layers_to_transform (`Union[list[int], int]`, *optional*):
+            The layer indexes to transform. If this argument is specified, PEFT will transform only the layer indexes
+            that are specified in this list. If a single integer is passed, PEFT will transform only the layer at this
+            index.
+        layers_pattern (`Optional[Union[List[str], str]]`, *optional*):
+            The layer pattern name, used only if `layers_to_transform` is not None and if the layer pattern is not in
+            the common layers pattern.
+        init_weights (`bool`):
+            Whether to initialize PEANuT adapter weights using the default initialization scheme:
+
+            - If `True`: all weights except `B` are initialized with Kaiming uniform, and `B` is initialized to zero.
+            - If `False`: all weights (including `B`) are initialized with Kaiming uniform.
+
+            Initializing `B` to zero makes the adapter start as an exact no-op.
+
+    Notes:
+        PEANuT uses a weight-aware pathway, where the delta weight is conditioned on the base weight. The `A` adapter
+        is applied over the base weight's output dimension, so `A` has shape `(out_dim -> r)` rather than the usual
+        `(in_dim -> r)` used by LoRA-like methods.
+    """
+
+    r: int = field(
+        default=32,
+        metadata={
+            "help": (
+                "PEANuT rank. This is the hidden dimension used by the adapter stack. Similar to LoRA rank, larger "
+                "`r` increases adapter capacity and trainable parameters."
+            )
+        },
+    )
+    depth: int = field(
+        default=0,
+        metadata={
+            "help": (
+                "Number of hidden adapter layers per encoder/decoder side in PEANuT. The input projection `A` and "
+                "output projection `B` are added automatically, so `depth` must be a non-negative integer."
+            )
+        },
+    )
+    act_fn: str = field(
+        default="relu",
+        metadata={
+            "help": (
+                "Non-linear activation applied in the PEANuT pathway. This corresponds to `non_linear` in the "
+                "vanilla implementation. Must be a key in `transformers.activations.ACT2FN`."
+            )
+        },
+    )
+    scaling: float = field(
+        default=1.0,
+        metadata={
+            "help": (
+                "A scalar multiplier applied to the PEANuT output before adding it to the frozen base layer output. "
+                "The final adapter contribution is `scaling * (x @ delta_w)`."
+            )
+        },
+    )
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of module names or regex expression of the module names to replace with PEANuT. "
+                "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'. "
+                "If not specified, PEANuT will use architecture-specific default target modules."
+            )
+        },
+    )
+    exclude_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of module names or regex expression of the module names to exclude from PEANuT. "
+                "When passing a string, a regex match will be performed. When passing a list of strings, "
+                "either an exact match will be performed or it is checked if the name of the module ends "
+                "with any of the passed strings."
+            )
+        },
+    )
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of modules apart from PEANuT layers to be set as trainable and saved in the final checkpoint."
+            )
+        },
+    )
+    layers_to_transform: Optional[Union[list[int], int]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The layer indexes to transform, if this argument is specified, PEFT will transform only the layers "
+                "indexes that are specified inside this list. If a single integer is passed, PEFT will transform only "
+                "the layer at this index."
+            )
+        },
+    )
+    layers_pattern: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The layer pattern name, used only if `layers_to_transform` is different to None and if the layer "
+                "pattern is not in the common layers pattern. This should target the `nn.ModuleList` of the model, "
+                "which is often called `'layers'` or `'h'`."
+            )
+        },
+    )
+    init_weights: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "Whether to initialize PEANuT adapter weights using the default initialization scheme: if `True`, "
+                "all weights except `B` are initialized with Kaiming uniform and `B` is initialized to zero; if "
+                "`False`, all weights including `B` are initialized with Kaiming uniform."
+            )
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.PEANUT
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        self.exclude_modules = (
+            set(self.exclude_modules) if isinstance(self.exclude_modules, list) else self.exclude_modules
+        )
+        if self.layers_pattern and not self.layers_to_transform:
+            raise ValueError("When `layers_pattern` is specified, `layers_to_transform` must also be specified.")
+        if self.r <= 0:
+            raise ValueError("`r` must be a positive integer.")
+        if self.depth < 0:
+            raise ValueError("`depth` can only be a non-negative integer.")
+        if self.act_fn not in ACT2FN:
+            raise ValueError(f"Unsupported `act_fn`: {self.act_fn}. Must be one of {sorted(ACT2FN.keys())}.")
diff --git a/src/peft/tuners/peanut/layer.py b/src/peft/tuners/peanut/layer.py
new file mode 100644
index 0000000..ca61fcd
--- /dev/null
+++ b/src/peft/tuners/peanut/layer.py
@@ -0,0 +1,242 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+import math
+import warnings
+from typing import Any, Optional
+
+import torch
+from torch import nn
+from transformers.activations import ACT2FN
+
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+
+from .config import PeanutConfig
+
+
+class PeanutLayer(BaseTunerLayer):
+    # All names of layers that may contain (trainable) adapter weights
+    adapter_layer_names: tuple[str, ...] = ("peanut_A", "peanut_B", "peanut_encoders", "peanut_decoders")
+    # All names of other parameters that may contain adapter-related parameters
+    other_param_names: tuple[str, ...] = ("r", "depth", "scaling", "act_fn", "res_num")
+
+    def __init__(self, base_layer: nn.Module, **kwargs) -> None:
+        self.base_layer = base_layer
+        self.r = {}
+        self.depth = {}
+        self.res_num = {}
+        self.scaling = {}
+        self.act_fn = {}
+        self.peanut_A = nn.ModuleDict({})
+        self.peanut_B = nn.ModuleDict({})
+        self.peanut_encoders = nn.ModuleDict({})
+        self.peanut_decoders = nn.ModuleDict({})
+        self.kwargs = kwargs
+
+        self._disable_adapters = False
+        self.merged_adapters = []
+        self._cached_delta_weights = {}
+
+        base_layer = self.get_base_layer()
+
+        if isinstance(base_layer, nn.Linear):
+            in_features, out_features = base_layer.in_features, base_layer.out_features
+        else:
+            if hasattr(base_layer, "in_features") and hasattr(base_layer, "out_features"):
+                in_features, out_features = base_layer.in_features, base_layer.out_features
+            else:
+                in_features, out_features = None, None
+            warnings.warn(
+                f"Unsupported layer type '{type(base_layer)}' encountered, proceed at your own risk.", UserWarning
+            )
+
+        self.in_features = in_features
+        self.out_features = out_features
+
+    def update_layer(
+        self,
+        adapter_name: str,
+        r: int,
+        config: PeanutConfig,
+    ) -> None:
+        depth = config.depth
+        scaling = config.scaling
+        act_fn = config.act_fn
+        init_weights = config.init_weights
+        inference_mode = config.inference_mode
+
+        self.r[adapter_name] = r
+        self.depth[adapter_name] = depth
+        self.res_num[adapter_name] = depth
+        self.scaling[adapter_name] = scaling
+        self.act_fn[adapter_name] = act_fn
+
+        self.peanut_A[adapter_name] = nn.Linear(self.out_features, r, bias=False)
+        self.peanut_encoders[adapter_name] = nn.ModuleList([nn.Linear(r, r, bias=False) for _ in range(depth)])
+        self.peanut_decoders[adapter_name] = nn.ModuleList([nn.Linear(r, r, bias=False) for _ in range(depth)])
+
+        self.peanut_B[adapter_name] = nn.Linear(r, self.out_features, bias=False)
+
+        self.reset_peanut_parameters(adapter_name, init_weights=init_weights)
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def reset_peanut_parameters(self, adapter_name: str, init_weights: bool = True):
+        if adapter_name not in self.peanut_A:
+            return
+
+        nn.init.kaiming_uniform_(self.peanut_A[adapter_name].weight, a=math.sqrt(5))
+        for encoder in self.peanut_encoders[adapter_name]:
+            nn.init.kaiming_uniform_(encoder.weight, a=math.sqrt(5))
+        for decoder in self.peanut_decoders[adapter_name]:
+            nn.init.kaiming_uniform_(decoder.weight, a=math.sqrt(5))
+
+        if init_weights:
+            nn.init.zeros_(self.peanut_B[adapter_name].weight)
+        else:
+            nn.init.kaiming_uniform_(self.peanut_B[adapter_name].weight, a=math.sqrt(5))
+
+
+class Linear(nn.Module, PeanutLayer):
+    # PEANuT implemented in a dense layer
+    def __init__(
+        self,
+        base_layer,
+        adapter_name: str,
+        r: int,
+        config: PeanutConfig,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        PeanutLayer.__init__(self, base_layer, **kwargs)
+
+        self._active_adapter = adapter_name
+
+        self.update_layer(adapter_name, r, config=config)
+
+    def _compute_delta_weight(self, adapter: str, base_weight: torch.Tensor) -> torch.Tensor:
+        if adapter not in self.peanut_A:
+            raise ValueError(f"Adapter {adapter} not found.")
+
+        peanut_A = self.peanut_A[adapter]
+        peanut_B = self.peanut_B[adapter]
+        non_linear = ACT2FN[self.act_fn[adapter]]
+        scaling = self.scaling[adapter]
+        res_num = self.res_num[adapter]
+        peanut_encoders = self.peanut_encoders[adapter]
+        peanut_decoders = self.peanut_decoders[adapter]
+
+        base_weight_t = base_weight.transpose(0, 1).to(peanut_A.weight.dtype)
+        delta_w = non_linear(torch.matmul(base_weight_t, peanut_A.weight.t()))
+
+        residuals = []
+        for i in range(res_num):
+            residuals.append(delta_w)
+            encoder = peanut_encoders[i]
+            delta_w = non_linear(encoder(delta_w))
+
+        for i in range(res_num):
+            decoder = peanut_decoders[i]
+            delta_w = non_linear(decoder(delta_w))
+            delta_w = delta_w + residuals[res_num - 1 - i]
+
+        delta_w = peanut_B(delta_w)
+        return (delta_w * scaling).transpose(0, 1)
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        base_weight = self.get_base_layer().weight
+        return self._compute_delta_weight(adapter, base_weight)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            return
+
+        base_layer = self.get_base_layer()
+        merge_base_weight = base_layer.weight.data.detach().clone()
+
+        for active_adapter in adapter_names:
+            if active_adapter not in self.peanut_A:
+                continue
+
+            with torch.no_grad():
+                delta_weight = self._compute_delta_weight(active_adapter, merge_base_weight)
+                delta_weight = delta_weight.to(dtype=base_layer.weight.dtype, device=base_layer.weight.device)
+
+                if safe_merge:
+                    orig_weights = base_layer.weight.data.clone()
+                    orig_weights = orig_weights + delta_weight
+
+                    if not torch.isfinite(orig_weights).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = orig_weights
+                else:
+                    base_layer.weight.data.add_(delta_weight)
+
+            if delta_weight.device.type != "cpu":
+                cached_delta_weight = delta_weight.detach().to("cpu")
+            else:
+                cached_delta_weight = delta_weight.detach()
+            self._cached_delta_weights[active_adapter] = cached_delta_weight
+            self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+
+        base_layer = self.get_base_layer()
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter not in self.peanut_A:
+                continue
+
+            delta_weight = self._cached_delta_weights.pop(active_adapter, None)
+            if delta_weight is None:
+                raise ValueError(f"Cached delta weight for adapter '{active_adapter}' is missing; cannot unmerge.")
+
+            base_layer.weight.data.sub_(
+                delta_weight.to(dtype=base_layer.weight.dtype, device=base_layer.weight.device)
+            )
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+
+            if self.active_adapters:
+                torch_result_dtype = result.dtype
+
+                for active_adapter in self.active_adapters:
+                    if active_adapter not in self.peanut_A:
+                        continue
+
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    x_cast = self._cast_input_dtype(x, delta_weight.dtype)
+                    delta = torch.matmul(x_cast, delta_weight.transpose(0, 1))
+                    result = result + delta.to(torch_result_dtype)
+
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "peanut." + rep
diff --git a/src/peft/tuners/peanut/model.py b/src/peft/tuners/peanut/model.py
new file mode 100644
index 0000000..5d24d9f
--- /dev/null
+++ b/src/peft/tuners/peanut/model.py
@@ -0,0 +1,91 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+import torch
+
+from peft.tuners.tuners_utils import (
+    BaseTuner,
+    BaseTunerLayer,
+)
+from peft.utils import TRANSFORMERS_MODELS_TO_PEANUT_TARGET_MODULES_MAPPING
+
+from .layer import Linear, PeanutLayer
+
+
+class PeanutModel(BaseTuner):
+    """
+    Creates a PEANuT model from a pretrained transformers model.
+
+    The method is described in detail in https://arxiv.org/abs/2410.01870.
+
+    Args:
+        model ([`torch.nn.Module`]): The model to be adapted.
+        config ([`PeanutConfig`]): The configuration of the PEANuT model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+
+    Returns:
+        `torch.nn.Module`: The PEANuT PEFT model.
+
+    **Attributes**:
+        - **model** ([`~transformers.PreTrainedModel`]) -- The model to be adapted.
+        - **peft_config** ([`PeanutConfig`]): The configuration of the PEANuT model.
+    """
+
+    prefix: str = "peanut_"
+    tuner_layer_cls = PeanutLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_PEANUT_TARGET_MODULES_MAPPING
+
+    def _create_and_replace(
+        self,
+        peanut_config,
+        adapter_name,
+        target,
+        target_name,
+        parent,
+        current_key,
+        **optional_kwargs,
+    ):
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+
+        if isinstance(target, PeanutLayer):
+            target.update_layer(
+                adapter_name,
+                peanut_config.r,
+                config=peanut_config,
+            )
+        else:
+            new_module = self._create_new_module(peanut_config, adapter_name, target)
+            if adapter_name not in self.active_adapters:
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+    @staticmethod
+    def _create_new_module(peanut_config, adapter_name, target):
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        if isinstance(target_base_layer, torch.nn.Linear):
+            return Linear(
+                target,
+                adapter_name,
+                r=peanut_config.r,
+                config=peanut_config,
+            )
+
+        raise NotImplementedError(f"PEANuT does not support target modules of type {type(target_base_layer)} yet.")
diff --git a/src/peft/tuners/poly/__init__.py b/src/peft/tuners/poly/__init__.py
new file mode 100644
index 0000000..1c18933
--- /dev/null
+++ b/src/peft/tuners/poly/__init__.py
@@ -0,0 +1,24 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from peft.utils import register_peft_method
+
+from .config import PolyConfig
+from .layer import Linear, PolyLayer
+from .model import PolyModel
+
+
+__all__ = ["Linear", "PolyConfig", "PolyLayer", "PolyModel"]
+
+register_peft_method(name="poly", config_cls=PolyConfig, model_cls=PolyModel)
diff --git a/src/peft/tuners/poly/config.py b/src/peft/tuners/poly/config.py
new file mode 100644
index 0000000..c4a77bc
--- /dev/null
+++ b/src/peft/tuners/poly/config.py
@@ -0,0 +1,103 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal, Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class PolyConfig(PeftConfig):
+    """
+    This is the configuration class to store the configuration of a [`PolyModel`].
+        - [Polytropon (Poly)](https://huggingface.co/papers/2202.13914)
+        - [Multi-Head Routing (MHR)](https://huggingface.co/papers/2211.03831)
+
+    Args:
+        r (`int`): Attention dimension of each Lora in Poly.
+        target_modules (`Union[List[str],str]`): The names of the modules to apply Poly to.
+        exclude_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to not apply the adapter. When passing a string, a regex match will be performed.
+            When passing a list of strings, either an exact match will be performed or it is checked if the name of the
+            module ends with any of the passed strings.
+        modules_to_save (`List[str]`): List of modules apart from Poly layers to be set as trainable
+            and saved in the final checkpoint.
+        init_weights (bool): Whether to perform initialization of Poly weights.
+        poly_type (`Literal["poly"]`): The variant of the Poly module to use. Currently, only "poly"
+            is supported.
+        n_tasks (`int`): The number of tasks in a multitasking scenario.
+        n_skills (`int`): The number of skills (LoRA) in each Poly layer.
+        n_splits (`int`): The number of splits within each LoRA of a Poly layer. A value greater
+            than 1 indicates the use of Multi-Head Routing (MHR).
+    """
+
+    r: int = field(default=8, metadata={"help": "Lora attention dimension"})
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": "List of module names or regex expression of the module names to replace with Poly."
+            "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$' "
+        },
+    )
+    exclude_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={"help": "List of module names or regex expression of the module names to exclude from Poly."},
+    )
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": "List of modules apart from Poly layers to be set as trainable and saved in the final checkpoint. "
+            "For example, in Sequence Classification or Token Classification tasks, "
+            "the final layer `classifier/score` are randomly initialized and as such need to be trainable and saved."
+        },
+    )
+    init_weights: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "Whether to initialize the weights of the Poly layers with their default initialization. Don't change "
+                "this setting, except if you know exactly what you're doing."
+            ),
+        },
+    )
+    poly_type: Literal["poly"] = field(
+        default="poly",
+        metadata={"help": 'Type of Poly modules to be used. Currently only "poly" is supported.'},
+    )
+    n_tasks: int = field(
+        default=1,
+        metadata={"help": "Number of tasks in multitasking scenario."},
+    )
+    n_skills: int = field(
+        default=4,
+        metadata={"help": "Number of skills (LoRA) in each Poly layer."},
+    )
+    n_splits: int = field(
+        default=1,
+        metadata={"help": "Number of splits within each LoRA of a Poly layer."},
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.POLY
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        self.exclude_modules = (
+            set(self.exclude_modules) if isinstance(self.exclude_modules, list) else self.exclude_modules
+        )
diff --git a/src/peft/tuners/poly/layer.py b/src/peft/tuners/poly/layer.py
new file mode 100644
index 0000000..4acd2d7
--- /dev/null
+++ b/src/peft/tuners/poly/layer.py
@@ -0,0 +1,165 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import math
+from typing import Any
+
+import torch
+from torch import nn
+
+from peft.tuners.tuners_utils import BaseTunerLayer
+
+from .config import PolyConfig
+from .router import get_router
+
+
+class PolyLayer(BaseTunerLayer):
+    # All names of layers that may contain (trainable) adapter weights
+    adapter_layer_names = ("poly_lora_A", "poly_lora_B", "poly_router")
+    # All names of other parameters that may contain adapter-related parameters
+    other_param_names = ("r", "n_tasks", "n_skills", "n_splits", "poly_type")
+
+    def __init__(self, base_layer: nn.Module, **kwargs):
+        self.base_layer = base_layer
+        self.r = {}
+        self.n_tasks = {}
+        self.n_skills = {}
+        self.n_splits = {}
+        self.poly_type = {}
+        self.poly_router = nn.ModuleDict()
+        self.poly_lora_A = nn.ParameterDict()
+        self.poly_lora_B = nn.ParameterDict()
+        self.kwargs = kwargs
+
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            in_features, out_features = base_layer.in_features, base_layer.out_features
+        else:
+            raise TypeError(f"Unsupported layer type {type(base_layer)}")
+
+        self.in_features = in_features
+        self.out_features = out_features
+
+    def update_layer(self, adapter_name, config: PolyConfig, inference_mode: bool = False, **kwargs):
+        if config.r <= 0:
+            raise ValueError(f"`r` should be a positive integer value but the value passed is {config.r}")
+
+        self.r[adapter_name] = config.r
+        self.n_tasks[adapter_name] = config.n_tasks
+        self.n_skills[adapter_name] = config.n_skills
+        self.n_splits[adapter_name] = config.n_splits
+        self.poly_type[adapter_name] = config.poly_type
+
+        self.poly_lora_A[adapter_name] = nn.Parameter(
+            torch.empty(
+                config.n_splits,
+                config.n_skills,
+                self.in_features // config.n_splits,
+                config.r,
+            )
+        )
+        self.poly_lora_B[adapter_name] = nn.Parameter(
+            torch.empty(
+                config.n_splits,
+                config.n_skills,
+                config.r,
+                self.out_features // config.n_splits,
+            )
+        )
+        self.poly_router[adapter_name] = get_router(config)
+
+        self.reset_poly_parameters(adapter_name, init_weights=config.init_weights)
+
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def reset_poly_parameters(self, adapter_name, init_weights):
+        if adapter_name in self.poly_lora_A.keys():
+            # initialize A the same way as the default for nn.Linear
+            # https://github.com/microsoft/mttl/blob/ce4ca51dbca73be656feb9b3e5233633e3c5dec7/mttl/models/poly.py#L269
+            n_splits, n_skills, d, r = self.poly_lora_A[adapter_name].shape
+            for skill in range(n_skills):
+                for split in range(n_splits):
+                    param = torch.empty((r, d))
+                    torch.nn.init.kaiming_uniform_(param, a=math.sqrt(5))
+                    self.poly_lora_A[adapter_name].data[split, skill, :, :] = param.T
+
+            if init_weights:
+                # initialize B to zero
+                torch.nn.init.zeros_(self.poly_lora_B[adapter_name])
+            else:
+                # initialize B the same way as the default for nn.Linear
+                n_splits, n_skills, r, d = self.poly_lora_B[adapter_name].shape
+                for skill in range(n_skills):
+                    for split in range(n_splits):
+                        param = torch.empty((d, r))
+                        torch.nn.init.kaiming_uniform_(param, a=math.sqrt(5))
+                        self.poly_lora_B[adapter_name].data[split, skill, :, :] = param.T
+
+            # initialized router
+            self.poly_router[adapter_name].reset()
+
+
+class Linear(nn.Module, PolyLayer):
+    # Lora implemented in a dense layer
+    def __init__(
+        self,
+        base_layer,
+        adapter_name: str,
+        poly_config: PolyConfig,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        PolyLayer.__init__(self, base_layer, **kwargs)
+
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, config=poly_config)
+
+    def forward(self, x: torch.Tensor, *args: Any, task_ids: torch.Tensor = None, **kwargs: Any) -> torch.Tensor:
+        previous_dtype = x.dtype
+        if self.disable_adapters:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.poly_lora_A.keys():
+                    continue
+
+                r = self.r[active_adapter]
+                poly_router = self.poly_router[active_adapter]
+                poly_lora_A = self.poly_lora_A[active_adapter]
+                poly_lora_B = self.poly_lora_B[active_adapter]
+
+                # Combine the output of LoRAs
+                # https://github.com/microsoft/mttl/blob/ce4ca51dbca73be656feb9b3e5233633e3c5dec7/mttl/models/poly.py#L293
+                mixing_weights = poly_router(task_ids=task_ids, input_ids=x)
+                bs, _, _ = mixing_weights.size()
+
+                # A is    n_splits, n_skills, D // n_splits, rank
+                # we want bs,       n_splits, D // n_splits, rank
+                A = torch.einsum("bqs,qsdr->bqdr", (mixing_weights, poly_lora_A))
+                B = torch.einsum("bqs,qsrd->bqrd", (mixing_weights, poly_lora_B))
+
+                A = A.reshape(bs, self.in_features, r)
+                B = B.transpose(1, 2).reshape(bs, r, self.out_features)
+
+                x = x.to(A.dtype)
+                result += x.bmm(A).bmm(B) / r
+
+        result = result.to(previous_dtype)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "poly." + rep
diff --git a/src/peft/tuners/poly/model.py b/src/peft/tuners/poly/model.py
new file mode 100644
index 0000000..7a831f5
--- /dev/null
+++ b/src/peft/tuners/poly/model.py
@@ -0,0 +1,104 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from contextlib import contextmanager
+from typing import Any
+
+import torch
+from torch import nn
+
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer
+from peft.utils import TRANSFORMERS_MODELS_TO_POLY_TARGET_MODULES_MAPPING
+
+from .config import PolyConfig
+from .layer import Linear, PolyLayer
+
+
+class PolyModel(BaseTuner):
+    prefix: str = "poly_"
+    tuner_layer_cls = PolyLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_POLY_TARGET_MODULES_MAPPING
+
+    def _create_and_replace(
+        self,
+        poly_config: PolyConfig,
+        adapter_name: str,
+        target: nn.Module,
+        target_name: str,
+        parent: nn.Module,
+        **optional_kwargs: Any,
+    ):
+        if isinstance(target, PolyLayer):
+            target.update_layer(adapter_name, config=poly_config)
+        else:
+            new_module = self._create_new_module(
+                poly_config,
+                adapter_name,
+                target,
+            )
+            if adapter_name not in self.active_adapters:
+                # adding an additional adapter: it is not automatically trainable
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+    @staticmethod
+    def _create_new_module(poly_config, adapter_name, target, **kwargs):
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        if isinstance(target_base_layer, torch.nn.Linear):
+            return Linear(target, adapter_name, poly_config, **kwargs)
+        else:
+            raise TypeError(
+                f"Target module {target} is not supported. Currently, only the following modules are supported: "
+                "`torch.nn.Linear`."
+            )
+
+    def _register_pre_hooks(self, task_ids):
+        """Helper method to register pre hooks."""
+        if task_ids is None:
+            return []
+
+        def pre_hook(_, args, kwargs):
+            kwargs["task_ids"] = task_ids
+            return args, kwargs
+
+        handles = []
+
+        for module in self.model.modules():
+            if isinstance(module, Linear):
+                handle = module.register_forward_pre_hook(pre_hook, with_kwargs=True)
+                handles.append(handle)
+
+        return handles
+
+    @contextmanager
+    def _manage_pre_hooks(self, task_ids):
+        """Context manager to handle the lifecycle of pre hooks."""
+        handles = self._register_pre_hooks(task_ids)
+        try:
+            yield
+        finally:
+            for handle in handles:
+                handle.remove()
+
+    def forward(self, *args, task_ids=None, **kwargs):
+        with self._manage_pre_hooks(task_ids):
+            return self.model(*args, **kwargs)
+
+    def generate(self, *args, task_ids=None, **kwargs):
+        with self._manage_pre_hooks(task_ids):
+            return self.model.generate(*args, **kwargs)
diff --git a/src/peft/tuners/poly/router.py b/src/peft/tuners/poly/router.py
new file mode 100644
index 0000000..3dda3e7
--- /dev/null
+++ b/src/peft/tuners/poly/router.py
@@ -0,0 +1,81 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from abc import ABC, abstractmethod
+
+import torch
+from torch import nn
+from torch.distributions.relaxed_bernoulli import RelaxedBernoulli
+
+from .config import PolyConfig
+
+
+EPS = 1e-12
+
+
+def get_router(poly_config: PolyConfig) -> nn.Module:
+    if poly_config.poly_type == "poly":
+        return PolyRouter(poly_config)
+    else:
+        raise ValueError(
+            f"Unsupported poly_type: {poly_config.poly_type}. "
+            "Currently, only the following types are supported: "
+            "`poly`."
+        )
+
+
+class Router(nn.Module, ABC):
+    @abstractmethod
+    def reset(self): ...
+
+    @abstractmethod
+    def forward(self, task_ids: torch.Tensor, input_ids: torch.Tensor): ...
+
+
+class PolyRouter(Router):
+    # It's a simplified implementation of
+    # https://github.com/microsoft/mttl/blob/ce4ca51dbca73be656feb9b3e5233633e3c5dec7/mttl/models/poly.py#L138
+    def __init__(self, poly_config: PolyConfig):
+        super().__init__()
+
+        self.poly_type = poly_config.poly_type
+        self.n_tasks = poly_config.n_tasks
+        self.n_skills = poly_config.n_skills
+        self.n_splits = poly_config.n_splits
+
+        self.module_logits = nn.Parameter(torch.empty((self.n_tasks, self.n_splits * self.n_skills)))
+
+    def reset(self):
+        torch.nn.init.uniform_(self.module_logits, -1e-3, 1e-3)
+
+    def forward(self, task_ids: torch.Tensor, input_ids: torch.Tensor):
+        if task_ids is None:
+            raise ValueError("task_ids should not be None.")
+        if task_ids.max().item() >= self.n_tasks:
+            raise ValueError(f"Only {self.n_tasks} tasks available. Found task id = {task_ids.max().item()}")
+
+        # move task id to input's device
+        task_ids = task_ids.to(self.module_logits.device)
+
+        module_logits = self.module_logits[task_ids]
+        module_logits = module_logits.view(-1, self.n_splits, self.n_skills)
+
+        if self.training:
+            module_logits = RelaxedBernoulli(temperature=1.0, logits=module_logits).rsample()
+        else:
+            module_logits = torch.sigmoid(module_logits)
+
+        module_weights = module_logits / (module_logits.sum(dim=-1, keepdim=True) + EPS)
+
+        return module_weights
diff --git a/src/peft/tuners/prefix_tuning/__init__.py b/src/peft/tuners/prefix_tuning/__init__.py
new file mode 100644
index 0000000..939f74d
--- /dev/null
+++ b/src/peft/tuners/prefix_tuning/__init__.py
@@ -0,0 +1,23 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from peft.utils import register_peft_method
+
+from .config import PrefixTuningConfig
+from .model import PrefixEncoder
+
+
+__all__ = ["PrefixEncoder", "PrefixTuningConfig"]
+
+register_peft_method(name="prefix_tuning", config_cls=PrefixTuningConfig, model_cls=PrefixEncoder)
diff --git a/src/peft/tuners/prefix_tuning/config.py b/src/peft/tuners/prefix_tuning/config.py
new file mode 100644
index 0000000..37a7ac5
--- /dev/null
+++ b/src/peft/tuners/prefix_tuning/config.py
@@ -0,0 +1,52 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from dataclasses import dataclass, field
+from typing import Literal
+
+from peft.config import PromptLearningConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class PrefixTuningConfig(PromptLearningConfig):
+    """
+    This is the configuration class to store the configuration of a [`PrefixEncoder`].
+
+    Args:
+        init_weights (`Optional[str]`): If not set, weights are initialized at random, if set to "zero"
+            the weights are initialized so that the activations will be a no-op (zero).
+        encoder_hidden_size (`int`): The hidden size of the prompt encoder.
+        prefix_projection (`bool`): Whether to project the prefix embeddings.
+    """
+
+    init_weights: Literal["zero"] | None = field(
+        default=None,
+        metadata={
+            "help": 'If not set, weights are initialized at random, if set to "zero" the '
+            "weights are initialized so that the activations will be a no-op (zero)."
+        },
+    )
+    encoder_hidden_size: int = field(
+        default=None,
+        metadata={"help": "The hidden size of the encoder"},
+    )
+    prefix_projection: bool = field(
+        default=False,
+        metadata={"help": "Whether to project the prefix tokens"},
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.PREFIX_TUNING
diff --git a/src/peft/tuners/prefix_tuning/model.py b/src/peft/tuners/prefix_tuning/model.py
new file mode 100644
index 0000000..5ff6dbe
--- /dev/null
+++ b/src/peft/tuners/prefix_tuning/model.py
@@ -0,0 +1,108 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+# Based on https://github.com/THUDM/P-tuning-v2/blob/main/model/prefix_encoder.py
+# with some refactor
+import torch
+
+
+class PrefixEncoder(torch.nn.Module):
+    r"""
+    The `torch.nn` model to encode the prefix.
+
+    Args:
+        config ([`PrefixTuningConfig`]): The configuration of the prefix encoder.
+
+    Example:
+
+    ```py
+    >>> from peft import PrefixEncoder, PrefixTuningConfig
+
+    >>> config = PrefixTuningConfig(
+    ...     peft_type="PREFIX_TUNING",
+    ...     task_type="SEQ_2_SEQ_LM",
+    ...     num_virtual_tokens=20,
+    ...     token_dim=768,
+    ...     num_transformer_submodules=1,
+    ...     num_attention_heads=12,
+    ...     num_layers=12,
+    ...     encoder_hidden_size=768,
+    ... )
+    >>> prefix_encoder = PrefixEncoder(config)
+    ```
+
+    **Attributes**:
+        - **embedding** (`torch.nn.Embedding`) -- The embedding layer of the prefix encoder.
+        - **transform** (`torch.nn.Sequential`) -- The two-layer MLP to transform the prefix embeddings if
+          `prefix_projection` is `True`.
+        - **prefix_projection** (`bool`) -- Whether to project the prefix embeddings.
+
+    Input shape: (`batch_size`, `num_virtual_tokens`)
+
+    Output shape: (`batch_size`, `num_virtual_tokens`, `2*layers*hidden`)
+    """
+
+    def __init__(self, config):
+        super().__init__()
+        self.prefix_projection = config.prefix_projection
+        token_dim = config.token_dim
+        num_layers = config.num_layers
+        encoder_hidden_size = config.encoder_hidden_size
+        num_virtual_tokens = config.num_virtual_tokens
+        init_weights = config.init_weights
+        if self.prefix_projection and not config.inference_mode:
+            # Use a two-layer MLP to encode the prefix
+            self.embedding = torch.nn.Embedding(num_virtual_tokens, token_dim)
+            self.transform = torch.nn.Sequential(
+                torch.nn.Linear(token_dim, encoder_hidden_size),
+                torch.nn.Tanh(),
+                torch.nn.Linear(encoder_hidden_size, num_layers * 2 * token_dim),
+            )
+
+            if init_weights == "zero":
+                torch.nn.init.zeros_(self.transform[-1].weight.data)
+                torch.nn.init.zeros_(self.transform[-1].bias.data)
+        else:
+            self.embedding = torch.nn.Embedding(num_virtual_tokens, num_layers * 2 * token_dim)
+            if init_weights == "zero":
+                torch.nn.init.zeros_(self.embedding.weight.data)
+
+    def forward(self, prefix: torch.Tensor):
+        if self.prefix_projection:
+            prefix_tokens = self.embedding(prefix)
+            past_key_values = self.transform(prefix_tokens)
+        else:
+            past_key_values = self.embedding(prefix)
+        return past_key_values
+
+    def load_prompt_embeddings(self, prompt_embeddings: torch.Tensor) -> None:
+        """
+        Load the flattened prompt embeddings saved by PEFT (`prompt_embeddings`).
+
+        For prefix tuning, this is only supported when `prefix_projection=False`, because in that case the learned
+        parameters are the KV prefix itself (`embedding.weight` has shape `[num_virtual_tokens,
+        num_layers*2*token_dim]`).
+
+        If `prefix_projection=True`, the parameters are (virtual token embeddings + an MLP) and there is no general way
+        to invert the projection to recover those parameters from a flattened KV prefix.
+        """
+        if self.prefix_projection:
+            raise ValueError("Cannot load flattened prompt embeddings when `prefix_projection=True`.")
+        if prompt_embeddings.shape != self.embedding.weight.shape:
+            raise ValueError(
+                "Invalid `prompt_embeddings` shape. Expected "
+                f"{tuple(self.embedding.weight.shape)}, got {tuple(prompt_embeddings.shape)}."
+            )
+        with torch.no_grad():
+            self.embedding.weight.copy_(prompt_embeddings.to(self.embedding.weight.device))
diff --git a/src/peft/tuners/prompt_tuning/__init__.py b/src/peft/tuners/prompt_tuning/__init__.py
new file mode 100644
index 0000000..c99ca6a
--- /dev/null
+++ b/src/peft/tuners/prompt_tuning/__init__.py
@@ -0,0 +1,23 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from peft.utils import register_peft_method
+
+from .config import PromptTuningConfig, PromptTuningInit
+from .model import PromptEmbedding
+
+
+__all__ = ["PromptEmbedding", "PromptTuningConfig", "PromptTuningInit"]
+
+register_peft_method(name="prompt_tuning", config_cls=PromptTuningConfig, model_cls=PromptEmbedding)
diff --git a/src/peft/tuners/prompt_tuning/config.py b/src/peft/tuners/prompt_tuning/config.py
new file mode 100644
index 0000000..b41669e
--- /dev/null
+++ b/src/peft/tuners/prompt_tuning/config.py
@@ -0,0 +1,91 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import enum
+from dataclasses import dataclass, field
+from typing import Optional, Union
+
+from peft.config import PromptLearningConfig
+from peft.utils import PeftType
+
+
+class PromptTuningInit(str, enum.Enum):
+    TEXT = "TEXT"
+    SAMPLE_VOCAB = "SAMPLE_VOCAB"
+    RANDOM = "RANDOM"
+
+
+@dataclass
+class PromptTuningConfig(PromptLearningConfig):
+    """
+    This is the configuration class to store the configuration of a [`PromptEmbedding`].
+
+    Args:
+        prompt_tuning_init (Union[[`PromptTuningInit`], `str`]):
+            The initialization of the prompt embedding. `TEXT` will initialize with your text. `SAMPLE_VOCAB` will
+            initialize with randomly sampled tokens from the model's vocabulary. `RANDOM` will initialize with randomly
+            sampled continuous, soft tokens (warning: sampled soft tokens may fall outside of embedding manifold)
+        prompt_tuning_init_text (`str`, *optional*):
+            The text to initialize the prompt embedding. Only used if `prompt_tuning_init` is `TEXT`.
+        tokenizer_name_or_path (`str`, *optional*):
+            The name or path of the tokenizer. Only used if `prompt_tuning_init` is `TEXT`.
+        tokenizer_kwargs (`dict`, *optional*):
+            The keyword arguments to pass to `AutoTokenizer.from_pretrained`. Only used if `prompt_tuning_init` is
+            `TEXT`.
+    """
+
+    prompt_tuning_init: Union[PromptTuningInit, str] = field(
+        default=PromptTuningInit.RANDOM,
+        metadata={"help": "How to initialize the prompt tuning parameters"},
+    )
+    prompt_tuning_init_text: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "The text to use for prompt tuning initialization. Only used if prompt_tuning_init is `TEXT`"
+        },
+    )
+    tokenizer_name_or_path: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "The tokenizer to use for prompt tuning initialization. Only used if prompt_tuning_init is `TEXT`"
+        },
+    )
+
+    tokenizer_kwargs: Optional[dict] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The keyword arguments to pass to `AutoTokenizer.from_pretrained`. Only used if prompt_tuning_init is "
+                "`TEXT`"
+            ),
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.PROMPT_TUNING
+        if (self.prompt_tuning_init == PromptTuningInit.TEXT) and not self.tokenizer_name_or_path:
+            raise ValueError(
+                f"When prompt_tuning_init='{PromptTuningInit.TEXT.value}', "
+                f"tokenizer_name_or_path can't be {self.tokenizer_name_or_path}."
+            )
+        if (self.prompt_tuning_init == PromptTuningInit.TEXT) and self.prompt_tuning_init_text is None:
+            raise ValueError(
+                f"When prompt_tuning_init='{PromptTuningInit.TEXT.value}', "
+                f"prompt_tuning_init_text can't be {self.prompt_tuning_init_text}."
+            )
+        if self.tokenizer_kwargs and (self.prompt_tuning_init != PromptTuningInit.TEXT):
+            raise ValueError(
+                f"tokenizer_kwargs only valid when using prompt_tuning_init='{PromptTuningInit.TEXT.value}'."
+            )
diff --git a/src/peft/tuners/prompt_tuning/model.py b/src/peft/tuners/prompt_tuning/model.py
new file mode 100644
index 0000000..3c6fc50
--- /dev/null
+++ b/src/peft/tuners/prompt_tuning/model.py
@@ -0,0 +1,105 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import math
+
+import torch
+
+from peft.utils.integrations import gather_params_ctx
+
+from .config import PromptTuningInit
+
+
+class PromptEmbedding(torch.nn.Module):
+    """
+    The model to encode virtual tokens into prompt embeddings.
+
+    Args:
+        config ([`PromptTuningConfig`]): The configuration of the prompt embedding.
+        word_embeddings (`torch.nn.Module`): The word embeddings of the base transformer model.
+
+    **Attributes**:
+        - **embedding** (`torch.nn.Embedding`) -- The embedding layer of the prompt embedding.
+
+    Example:
+
+    ```py
+    >>> from peft import PromptEmbedding, PromptTuningConfig
+
+    >>> config = PromptTuningConfig(
+    ...     peft_type="PROMPT_TUNING",
+    ...     task_type="SEQ_2_SEQ_LM",
+    ...     num_virtual_tokens=20,
+    ...     token_dim=768,
+    ...     num_transformer_submodules=1,
+    ...     num_attention_heads=12,
+    ...     num_layers=12,
+    ...     prompt_tuning_init="TEXT",
+    ...     prompt_tuning_init_text="Predict if sentiment of this review is positive, negative or neutral",
+    ...     tokenizer_name_or_path="t5-base",
+    ... )
+
+    >>> # t5_model.shared is the word embeddings of the base model
+    >>> prompt_embedding = PromptEmbedding(config, t5_model.shared)
+    ```
+
+    Input Shape: (`batch_size`, `total_virtual_tokens`)
+
+    Output Shape: (`batch_size`, `total_virtual_tokens`, `token_dim`)
+    """
+
+    def __init__(self, config, word_embeddings):
+        super().__init__()
+
+        total_virtual_tokens = config.num_virtual_tokens * config.num_transformer_submodules
+        self.embedding = torch.nn.Embedding(total_virtual_tokens, config.token_dim)
+        if config.prompt_tuning_init == PromptTuningInit.SAMPLE_VOCAB and not config.inference_mode:
+            # Randomly sample tokens from the tokenizer's vocab
+            vocab_size = word_embeddings.num_embeddings
+            init_token_ids = torch.randint(0, vocab_size, (total_virtual_tokens,), dtype=torch.long).to(
+                word_embeddings.weight.device
+            )
+            with gather_params_ctx(word_embeddings.parameters()):
+                word_embedding_weights = word_embeddings(init_token_ids).detach().clone()
+            word_embedding_weights = word_embedding_weights.to(torch.float32)
+            self.embedding.weight = torch.nn.Parameter(word_embedding_weights)
+
+        elif config.prompt_tuning_init == PromptTuningInit.TEXT and not config.inference_mode:
+            from transformers import AutoTokenizer
+
+            tokenizer_kwargs = config.tokenizer_kwargs or {}
+            # security: disallow trust_remote_code, as this could allow code execution when loading a prompt tuning
+            # checkpoint
+            tokenizer_kwargs.pop("trust_remote_code", None)
+            tokenizer = AutoTokenizer.from_pretrained(config.tokenizer_name_or_path, **tokenizer_kwargs)
+            init_text = config.prompt_tuning_init_text
+            init_token_ids = tokenizer(init_text)["input_ids"]
+            # Trim or iterate until num_text_tokens matches total_virtual_tokens
+            num_text_tokens = len(init_token_ids)
+            if num_text_tokens > total_virtual_tokens:
+                init_token_ids = init_token_ids[:total_virtual_tokens]
+            elif num_text_tokens < total_virtual_tokens:
+                num_reps = math.ceil(total_virtual_tokens / num_text_tokens)
+                init_token_ids = init_token_ids * num_reps
+            init_token_ids = init_token_ids[:total_virtual_tokens]
+            init_token_ids = torch.LongTensor(init_token_ids).to(word_embeddings.weight.device)
+            with gather_params_ctx(word_embeddings.parameters()):
+                word_embedding_weights = word_embeddings(init_token_ids).detach().clone()
+            word_embedding_weights = word_embedding_weights.to(torch.float32)
+            self.embedding.weight = torch.nn.Parameter(word_embedding_weights)
+
+    def forward(self, indices):
+        # Just get embeddings
+        prompt_embeddings = self.embedding(indices)
+        return prompt_embeddings
diff --git a/src/peft/tuners/psoft/__init__.py b/src/peft/tuners/psoft/__init__.py
new file mode 100644
index 0000000..2901fba
--- /dev/null
+++ b/src/peft/tuners/psoft/__init__.py
@@ -0,0 +1,24 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+from peft.utils import register_peft_method
+
+from .config import PsoftConfig
+from .layer import Linear, PsoftLayer
+from .model import PsoftModel
+
+
+__all__ = ["Linear", "PsoftConfig", "PsoftLayer", "PsoftModel"]
+
+register_peft_method(name="psoft", config_cls=PsoftConfig, model_cls=PsoftModel, prefix="psoft_")
diff --git a/src/peft/tuners/psoft/config.py b/src/peft/tuners/psoft/config.py
new file mode 100644
index 0000000..41d4e3c
--- /dev/null
+++ b/src/peft/tuners/psoft/config.py
@@ -0,0 +1,323 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+import warnings
+from dataclasses import dataclass, field
+from typing import Literal, Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class PsoftConfig(PeftConfig):
+    """
+    Configuration for PSOFT (Efficient Orthogonal Fine-Tuning with Principal Subspace Adaptation).
+
+    PSOFT inserts an r*r orthogonal transformation R between low-rank matrices A and B, so the low-rank update is ΔW =
+    B @ (R-I) @ A. Only R (and optional tunable vectors) are trained; A and B are initialized with psoft_init
+    (SVD-based, row-orthogonal A) and frozen.
+
+    Args:
+        r (`int`):
+            Defaults to 32. PSOFT rank (r) controls the adapter capacity through an r*r transformation R. Smaller ranks
+            32-128 are typically sufficient for simple tasks, More complex tasks may benefit from 64-256, increasing
+            expressiveness at the cost of additional parameters and computation. See the paper for empirically
+            validated settings: https://openreview.net/forum?id=FSHrinMArK.
+        target_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to apply the adapter to. If this is specified, only the modules with the specified
+            names will be replaced. When passing a string, a regex match will be performed. When passing a list of
+            strings, either an exact match will be performed or it is checked if the name of the module ends with any
+            of the passed strings. If this is specified as 'all-linear', then all linear/Conv1D modules are chosen (if
+            the model is a PreTrainedModel, the output layer excluded). If this is not specified, modules will be
+            chosen according to the model architecture. If the architecture is not known, an error will be raised -- in
+            this case, you should specify the target modules manually.
+        exclude_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to not apply the adapter. When passing a string, a regex match will be performed.
+            When passing a list of strings, either an exact match will be performed or it is checked if the name of the
+            module ends with any of the passed strings.
+        psoft_alpha (`int`): Defaults to 32. It controls PSOFT scaling factor. Same semantics as LoRA alpha.
+        psoft_dropout (`float`): Defaults to 0.0. Dropout for PSOFT path. Same semantics as LoRA dropout.
+        fan_in_fan_out (`bool`):
+            Set this to True if the layer to replace stores weight like (fan_in, fan_out). For example, gpt-2 uses
+            `Conv1D` which stores weights like (fan_in, fan_out) and hence this should be set to `True`.
+        ab_svd_init (`Literal["psoft_init", "pissa_init"]`):
+            Defaults to 'psoft_init'. Initialization strategy for A and B used to construct the principal subspace in
+            PSOFT. 'psoft_init': SVD-based initialization with row-orthogonal A, ensuring strict orthogonality (PSOFT).
+            'pissa_init': SVD-based initialization with symmetric A and B (standard PiSSA).
+        psoft_svd (`Literal["full", "lowrank"]`):
+            Defaults to 'full'. SVD backend for initialization: 'full' uses torch.linalg.svd; 'lowrank' uses
+            torch.svd_lowrank.
+        psoft_svd_lowrank_niter (`int`):
+            Only used when psoft_svd='lowrank'. Defaults to 10. Number of power iterations used by torch.svd_lowrank
+            when psoft_svd='lowrank'.
+        psoft_orth (`bool`):
+            Defaults to 'True'. If True, constrains R to be orthogonal via Cayley parameterization, preserving the
+            geometric relationships among column of the pre-trained weight vectors. If False, R is a free matrix
+            without orthogonality constraints.
+        psoft_mag_b (`bool`):
+            Defaults to 'True'. If True, learns a diagonal scaling vector on the 'output' side of R. Commonly paired
+            with psoft_mag_a to increase task adaptability, with slight distortion to the pre-trained geometry.
+        psoft_mag_a (`bool`):
+            Defaults to 'True'. If True, learns a diagonal scaling vector on the 'input' side of R. Commonly paired
+            with psoft_mag_b to increase task adaptability, with slight distortion to the pre-trained geometry.
+        use_cayley_neumann (`bool`):
+            Defaults to 'False'. Whether to use the Cayley-Neumann formulation of PSOFT or not. Set to True to improve
+            computational efficiency but comes at costs of bigger approximation error for orthogonality.
+        num_cayley_neumann_terms (`int`):
+            Defaults to 5. Only used when use_cayley_neumann=True. Number of Cayley-Neumann terms to use. Higher number
+            results in less approximation error for orthogonality.
+        cayley_neumann_eps (`optional[float]`):
+            Defaults to 'None'. Only used when use_cayley_neumann=True. Optional Frobenius-norm bound for the generator
+            matrix Q in the Cayley-Neumann approximation. If None (default), no rescaling is applied. If set to a value
+            in (0, 1) (e.g., 0.9), Q is rescaled whenever ||Q||_F exceeds the threshold to improve numerical stability.
+            See https://spherelab.ai/oftv2/ for details.
+        init_weights (`bool`):
+            Defaults to 'True'. Whether to initialize the weights of the PSOFT layers with their default
+            initialization. Don't change this setting, except if you know exactly what you're doing.
+        modules_to_save (`List[str]`):
+            List of modules apart from adapter layers to be set as trainable and saved in the final checkpoint.
+        layers_to_transform (`Union[List[int], int]`):
+            The layer indices to transform. If a list of ints is passed, it will apply the adapter to the layer indices
+            that are specified in this list. If a single integer is passed, it will apply the transformations on the
+            layer at this index.
+        layers_pattern (`Optional[Union[List[str], str]]`):
+            The layer pattern name, used only if `layers_to_transform` is different from `None`. This should target the
+            `nn.ModuleList` of the model, which is often called `'layers'` or `'h'`.
+    """
+
+    r: int = field(
+        default=32,
+        metadata={
+            "help": (
+                "PSOFT rank (r) controls the adapter capacity through an r*r transformation R. "
+                "Smaller ranks 32-128 are typically sufficient for simple tasks, More complex tasks may benefit from 64-256, "
+                "increasing expressiveness at the cost of additional parameters and computation. "
+                "See the paper for empirically validated settings: https://openreview.net/forum?id=FSHrinMArK. "
+            )
+        },
+    )
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of module names or regex expression of the module names to replace with PSOFT. "
+                "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'. "
+                "This can also be a wildcard 'all-linear' which matches all linear/Conv1D "
+                "(if the model is a PreTrainedModel, the output layer excluded). "
+                "If not specified, modules will be chosen according to the model architecture, If the architecture is "
+                "not known, an error will be raised -- in this case, you should specify the target modules manually. "
+            ),
+        },
+    )
+    exclude_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={"help": "List of module names or regex expression of the module names to exclude from PSOFT. "},
+    )
+    psoft_alpha: int = field(
+        default=32, metadata={"help": "It controls PSOFT scaling factor. Same semantics as LoRA alpha. "}
+    )
+    psoft_dropout: float = field(
+        default=0.0, metadata={"help": "Dropout for PSOFT path. Same semantics as LoRA dropout. "}
+    )
+    fan_in_fan_out: bool = field(
+        default=False,
+        metadata={"help": "Set this to True if the layer to replace stores weight like (fan_in, fan_out). "},
+    )
+    ab_svd_init: Literal["psoft_init", "pissa_init"] = field(
+        default="psoft_init",
+        metadata={
+            "help": (
+                "Initialization strategy for A and B used to construct the principal subspace in PSOFT. "
+                "- 'psoft_init': SVD-based initialization with row-orthogonal A (asymmetric A and B), ensuring strict orthogonality (PSOFT). "
+                "- 'pissa_init': SVD-based initialization with symmetric A and B, without strict orthogonality constraint (standard PiSSA). "
+            )
+        },
+    )
+    psoft_svd: Literal["full", "lowrank"] = field(
+        default="full",
+        metadata={
+            "help": "SVD backend for initialization: 'full' uses torch.linalg.svd; 'lowrank' uses torch.svd_lowrank. "
+        },
+    )
+    psoft_svd_lowrank_niter: int = field(
+        default=10,
+        metadata={
+            "help": "Number of power iterations used by torch.svd_lowrank when psoft_svd='lowrank'. Only used when psoft_svd='lowrank'. "
+        },
+    )
+    random_seed: int = field(
+        default=0,
+        metadata={
+            "help": (
+                "Seed used to deterministically create and rebuild the adapter weights when psoft_svd='lowrank', so "
+                "that a saved adapter reproduces its outputs after loading. Only used when psoft_svd='lowrank'. "
+                "Default: 0."
+            )
+        },
+    )
+    psoft_orth: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "If True, constrains R to be orthogonal via Cayley parameterization, preserving the geometric relationships among column of the pre-trained weight vectors. "
+                "If False, R is a free matrix without orthogonality constraints. "
+            )
+        },
+    )
+    psoft_mag_b: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "If True, learns a diagonal scaling vector on the 'output' side of R. "
+                "Commonly paired with psoft_mag_a to increase task adaptability, with slight distortion to the pre-trained geometry. "
+            )
+        },
+    )
+    psoft_mag_a: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "If True, learns a diagonal scaling vector on the 'input' side of R. "
+                "Commonly paired with psoft_mag_b to increase task adaptability, with slight distortion to the pre-trained geometry. "
+            )
+        },
+    )
+    use_cayley_neumann: bool = field(
+        default=False,
+        metadata={
+            "help": "Whether to use the Cayley-Neumann Formulation of PSOFT or not. Set to True to improve computational efficiency but comes at costs of bigger approximation error for orthogonality. "
+        },
+    )
+    num_cayley_neumann_terms: int = field(
+        default=5,
+        metadata={
+            "help": "Number of Cayley-Neumann terms to use. Higher number results in less approximation error for orthogonality. Only used when use_cayley_neumann=True."
+        },
+    )
+    cayley_neumann_eps: Optional[float] = field(
+        default=None,
+        metadata={
+            "help": (
+                "Optional Frobenius-norm bound for the generator matrix Q in the Cayley-Neumann approximation. Only used when use_cayley_neumann=True. "
+                "If None (default), no rescaling is applied. "
+                "If set to a value in (0, 1) (e.g., 0.9), Q is rescaled whenever ||Q||_F exceeds the threshold to improve numerical stability. "
+                "See https://spherelab.ai/oftv2/ for details. "
+            )
+        },
+    )
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of modules apart from PSOFT layers to be set as trainable and saved in the final checkpoint. "
+                "For example, in Sequence Classification or Token Classification tasks, "
+                "the final layer `classifier/score` are randomly initialized and as such need to be trainable and saved. "
+            )
+        },
+    )
+    init_weights: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "Whether to initialize the weights of the PSOFT layers with their default initialization. "
+                "Don't change this setting, except if you know exactly what you're doing. "
+            )
+        },
+    )
+    layers_to_transform: Optional[Union[list[int], int]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The layer indexes to transform, is this argument is specified, PEFT will transform only the layers indexes that are specified inside this list. If a single integer is passed, PEFT will transform only the layer at this index. "
+                "This only works when target_modules is a list of str."
+            )
+        },
+    )
+    layers_pattern: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The layer pattern name, used only if `layers_to_transform` is different to None and if the layer pattern is not in the common layers pattern. "
+                "This only works when target_modules is a list of str. This should target the `nn.ModuleList` of the "
+                "model, which is often called `'layers'` or `'h'`. "
+            )
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.PSOFT
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        self.exclude_modules = (
+            set(self.exclude_modules) if isinstance(self.exclude_modules, list) else self.exclude_modules
+        )
+
+        # if target_modules is a regex expression, then layers_to_transform should be None
+        if isinstance(self.target_modules, str) and self.layers_to_transform is not None:
+            raise ValueError("`layers_to_transform` cannot be used when `target_modules` is a str.")
+
+        # if target_modules is a regex expression, then layers_pattern should be None
+        if isinstance(self.target_modules, str) and self.layers_pattern is not None:
+            raise ValueError("`layers_pattern` cannot be used when `target_modules` is a str.")
+
+        # check for layers_to_transform and layers_pattern
+        if self.layers_pattern and not self.layers_to_transform:
+            raise ValueError("When `layers_pattern` is specified, `layers_to_transform` must also be specified. ")
+
+        if self.r <= 0:
+            raise ValueError(f"`r` must be a positive integer; got {self.r}.")
+
+        allowed_inits = {"psoft_init", "pissa_init"}
+        if self.ab_svd_init not in allowed_inits:
+            raise ValueError(f"`ab_svd_init` must be one of {sorted(allowed_inits)}; got {self.ab_svd_init!r}.")
+
+        allowed_svd_backends = {"full", "lowrank"}
+        if self.psoft_svd not in allowed_svd_backends:
+            raise ValueError(f"`psoft_svd` must be one of {sorted(allowed_svd_backends)}; got {self.psoft_svd!r}.")
+
+        DEFAULT_LOW_RANK_NITER = self.__dataclass_fields__["psoft_svd_lowrank_niter"].default
+        if self.psoft_svd != "lowrank" and self.psoft_svd_lowrank_niter != DEFAULT_LOW_RANK_NITER:
+            warnings.warn(
+                "`psoft_svd_lowrank_niter` is only used when `psoft_svd='lowrank'`. "
+                f"Got psoft_svd={self.psoft_svd!r}, so psoft_svd_lowrank_niter="
+                f"{self.psoft_svd_lowrank_niter} will be ignored.",
+                UserWarning,
+            )
+
+        DEFAULT_NUM_CAYLEY_NEUMANN_TERMS = self.__dataclass_fields__["num_cayley_neumann_terms"].default
+        if self.use_cayley_neumann:
+            if self.num_cayley_neumann_terms <= 0:
+                raise ValueError(
+                    f"`num_cayley_neumann_terms` must be a positive integer; got {self.num_cayley_neumann_terms}."
+                )
+            if self.cayley_neumann_eps is not None and not (0.0 < self.cayley_neumann_eps < 1.0):
+                raise ValueError(f"`cayley_neumann_eps` must be in (0, 1) when set; got {self.cayley_neumann_eps}.")
+        else:
+            if self.num_cayley_neumann_terms != DEFAULT_NUM_CAYLEY_NEUMANN_TERMS:
+                warnings.warn(
+                    "`num_cayley_neumann_terms` is only used when `use_cayley_neumann=True`. "
+                    f"Since `use_cayley_neumann=False`, `num_cayley_neumann_terms={self.num_cayley_neumann_terms}` will be ignored.",
+                    UserWarning,
+                )
+            if self.cayley_neumann_eps is not None:
+                warnings.warn(
+                    "`cayley_neumann_eps` is only used when `use_cayley_neumann=True`. "
+                    f"Since `use_cayley_neumann=False`, `cayley_neumann_eps={self.cayley_neumann_eps}` will be ignored.",
+                    UserWarning,
+                )
diff --git a/src/peft/tuners/psoft/layer.py b/src/peft/tuners/psoft/layer.py
new file mode 100644
index 0000000..d288593
--- /dev/null
+++ b/src/peft/tuners/psoft/layer.py
@@ -0,0 +1,500 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+import warnings
+from typing import Any, Optional
+
+import torch
+from torch import nn, svd_lowrank
+
+from peft.tuners._buffer_dict import BufferDict
+from peft.tuners.tuners_utils import BaseTunerLayer, _get_in_out_features, check_adapters_to_merge
+from peft.utils.integrations import gather_params_ctx
+from peft.utils.other import transpose
+
+from .config import PsoftConfig
+
+
+class OrthLayer(nn.Module):
+    """
+    r*r orthogonal transformation R used in PSOFT between A and B. Forward: output = input @ R.T
+    """
+
+    def __init__(
+        self,
+        size: int,
+        orth: bool = True,
+        mag_b: bool = True,
+        mag_a: bool = True,
+        use_cayley_neumann: bool = False,
+        num_cayley_neumann_terms: int = 5,
+        cayley_neumann_eps: Optional[float] = None,
+    ):
+        super().__init__()
+        self.size = size
+        self.orth = orth
+        self.mag_b = mag_b
+        self.mag_a = mag_a
+        self.use_cayley_neumann = use_cayley_neumann
+        self.num_cayley_neumann_terms = num_cayley_neumann_terms
+        self.cayley_neumann_eps = cayley_neumann_eps
+
+        if orth:
+            self.weight = nn.Parameter(torch.empty((size * (size - 1)) // 2))
+            rows, cols = torch.triu_indices(size, size, 1)
+            self.register_buffer("rows", rows, persistent=False)
+            self.register_buffer("cols", cols, persistent=False)
+        else:
+            self.weight = nn.Parameter(torch.empty(size, size))
+
+        self.vector_b = nn.Parameter(torch.empty(size)) if mag_b else None
+        self.vector_a = nn.Parameter(torch.empty(size)) if mag_a else None
+
+    def reset_parameters(self, init_weights: bool = True) -> None:
+        params = [self.weight]
+        if self.vector_b is not None:
+            params.append(self.vector_b)
+        if self.vector_a is not None:
+            params.append(self.vector_a)
+
+        if any(p.is_meta for p in params):
+            return
+
+        with torch.no_grad():
+            if init_weights:
+                if self.orth:
+                    self.weight.zero_()
+                else:
+                    nn.init.eye_(self.weight)
+
+                if self.vector_b is not None:
+                    self.vector_b.fill_(1.0)
+                if self.vector_a is not None:
+                    self.vector_a.fill_(1.0)
+            else:
+                if self.orth:
+                    nn.init.normal_(self.weight, mean=0.0, std=0.1)
+                else:
+                    nn.init.eye_(self.weight)
+                    self.weight.add_(torch.randn_like(self.weight) * 0.1)
+
+                if self.vector_b is not None:
+                    self.vector_b.fill_(1.0)
+                if self.vector_a is not None:
+                    self.vector_a.fill_(1.0)
+
+    def forward(self, input: torch.Tensor) -> torch.Tensor:
+        R = self.get_matrix()
+
+        if input.device.type == "cpu" and input.dtype in (torch.float16, torch.bfloat16):
+            compute_dtype = torch.float32
+        else:
+            compute_dtype = input.dtype
+
+        return (input.to(compute_dtype) @ R.to(compute_dtype).t()).to(input.dtype)
+
+    # Adapted from the Cayley/Neumann-based orthogonal parametrization used in OFT v2
+    # (PEFT implementation: https://github.com/huggingface/peft/blob/main/src/peft/tuners/oft/layer.py) #L104
+    def _skew_symmetric(self) -> torch.Tensor:
+        Q = torch.zeros((self.size, self.size), device=self.weight.device, dtype=self.weight.dtype)
+        Q = Q.index_put((self.rows, self.cols), self.weight)
+        return Q - Q.transpose(0, 1)
+
+    # Adapted from the Cayley/Neumann-based orthogonal parametrization used in OFT v2
+    # (PEFT implementation: https://github.com/huggingface/peft/blob/main/src/peft/tuners/oft/layer.py) #L160
+    def _project_Q(self, Q: torch.Tensor, eps: float = 0.9) -> torch.Tensor:
+        norm = torch.linalg.norm(Q, ord="fro")
+        if torch.isfinite(norm) and norm > eps:
+            Q = Q * (eps / (norm + 1e-12))
+        return Q
+
+    # R = (I+Q)(I-Q)^(-1)
+    def get_matrix(self) -> torch.Tensor:
+        cast_to_fp32 = False
+        orig_dtype = None
+
+        if not self.orth:
+            R = self.weight
+        else:
+            Q = self._skew_symmetric()
+            orig_dtype = Q.dtype
+
+            id_mat = torch.eye(self.size, device=Q.device, dtype=Q.dtype)
+
+            if self.use_cayley_neumann:
+                if self.cayley_neumann_eps is not None:
+                    Q = self._project_Q(Q, eps=self.cayley_neumann_eps)
+                t = int(self.num_cayley_neumann_terms)
+
+                R = id_mat.clone()
+                if t > 1:
+                    R.add_(Q, alpha=2.0)
+                    if t > 2:
+                        Q_squared = Q @ Q
+                        R.add_(Q_squared, alpha=2.0)
+
+                        Q_power = Q_squared
+                        for _ in range(3, t - 1):
+                            Q_power = Q_power @ Q
+                            R.add_(Q_power, alpha=2.0)
+
+                        Q_power = Q_power @ Q
+                        R.add_(Q_power)
+            else:
+                cast_to_fp32 = orig_dtype in (torch.float16, torch.bfloat16)
+                if cast_to_fp32:
+                    Q = Q.float()  # solver requires float32
+                R = torch.linalg.solve(id_mat - Q, id_mat + Q, left=False)
+
+        # Apply scaling vectors to R
+        if self.vector_b is not None:
+            R = self.vector_b[:, None] * R
+        if self.vector_a is not None:
+            R = R * self.vector_a[None, :]
+
+        if cast_to_fp32:
+            R = R.to(orig_dtype)
+
+        return R
+
+    def __repr__(self) -> str:
+        return (
+            f"psoft.{self.__class__.__name__}("
+            f"size={self.size}, orth={self.orth}, "
+            f"use_cayley_neumann={self.use_cayley_neumann}, "
+            f"num_cayley_neumann_terms={int(self.num_cayley_neumann_terms)}, "
+            f"cayley_neumann_eps={self.cayley_neumann_eps}, "
+            f"mag_a={self.mag_a}, mag_b={self.mag_b}"
+            f")"
+        )
+
+
+class PsoftLayer(BaseTunerLayer):
+    adapter_layer_names: tuple[str, ...] = ("psoft_R",)
+    other_param_names: tuple[str, ...] = (
+        "r",
+        "psoft_alpha",
+        "scaling",
+        "psoft_dropout",
+        "psoft_svd",
+        "psoft_svd_lowrank_niter",
+        "random_seed",
+        "ab_svd_init",
+        "_psoft_A_cache",
+        "_psoft_B_cache",
+    )
+
+    def __init__(self, base_layer: nn.Module, **kwargs) -> None:
+        super().__init__()
+        self.base_layer = base_layer
+
+        # per-adapter hyperparams
+        self.r: dict[str, int] = {}
+        self.psoft_alpha: dict[str, float] = {}
+        self.scaling: dict[str, float] = {}
+        self.psoft_dropout = nn.ModuleDict({})
+        self.psoft_svd: dict[str, str] = {}
+        self.psoft_svd_lowrank_niter: dict[str, int] = {}
+        self.random_seed: dict[str, int] = {}
+        self.ab_svd_init: dict[str, Optional[str]] = {}
+
+        # per-adapter trainable module
+        self.psoft_R = nn.ModuleDict({})
+
+        # per-adapter cache state
+        self._psoft_A_cache = BufferDict(persistent=False)
+        self._psoft_B_cache = BufferDict(persistent=False)
+
+        self.merged_adapters: list[str] = []
+        self._disable_adapters = False
+        self.kwargs = kwargs
+
+        self.fan_in_fan_out = False
+
+        base_layer = self.get_base_layer()
+        in_features, out_features = _get_in_out_features(base_layer)
+        self.in_features = in_features
+        self.out_features = out_features
+
+    def _get_psoft_ab_cache_buffers(self, adapter_name: str):
+        return self._psoft_A_cache[adapter_name], self._psoft_B_cache[adapter_name]
+
+    def _set_psoft_ab_cache_buffers(self, adapter_name: str, A: torch.Tensor, B: torch.Tensor) -> None:
+        self._psoft_A_cache[adapter_name] = A
+        self._psoft_B_cache[adapter_name] = B
+
+    def update_layer(self, adapter_name: str, config: PsoftConfig, **kwargs: Any) -> None:
+        ab_svd_init = config.ab_svd_init
+        init_weights = config.init_weights
+
+        r = int(config.r)
+
+        self.fan_in_fan_out = config.fan_in_fan_out
+
+        self.r[adapter_name] = r
+        self.psoft_alpha[adapter_name] = config.psoft_alpha
+        self.scaling[adapter_name] = config.psoft_alpha / r
+
+        self.psoft_dropout[adapter_name] = (
+            nn.Dropout(p=config.psoft_dropout) if config.psoft_dropout > 0.0 else nn.Identity()
+        )
+
+        self.ab_svd_init[adapter_name] = config.ab_svd_init
+        self.psoft_svd[adapter_name] = config.psoft_svd
+        self.psoft_svd_lowrank_niter[adapter_name] = config.psoft_svd_lowrank_niter
+        self.random_seed[adapter_name] = config.random_seed
+
+        self.psoft_R[adapter_name] = OrthLayer(
+            size=r,
+            orth=config.psoft_orth,
+            mag_b=config.psoft_mag_b,
+            mag_a=config.psoft_mag_a,
+            use_cayley_neumann=config.use_cayley_neumann,
+            num_cayley_neumann_terms=config.num_cayley_neumann_terms,
+            cayley_neumann_eps=config.cayley_neumann_eps,
+        )
+
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.psoft_R[adapter_name].reset_parameters(init_weights=init_weights)
+        self.psoft_R[adapter_name].requires_grad_(True)
+
+        with gather_params_ctx(self.get_base_layer().weight):
+            self._build_psoft_ab_cache_buffers(adapter_name, ab_svd_init)
+
+        self.set_adapter([adapter_name])
+
+    # Adapted from the asymmetric SVD used in PiSSA
+    # (PEFT implementation: https://github.com/huggingface/peft/blob/main/src/peft/tuners/lora/layer.py) #L316
+    def _build_psoft_ab_cache_buffers(self, adapter_name: str, init_type: str) -> None:
+        with torch.no_grad():
+            base = self.get_base_layer()
+            weight = base.weight
+            dtype = weight.dtype
+            if dtype not in (torch.float32, torch.float16, torch.bfloat16):
+                raise TypeError("PSOFT init requires float32/float16/bfloat16. Re-quantize after init if needed.")
+
+            # W: (out, in) fp32
+            W = transpose(weight.to(torch.float32), self.fan_in_fan_out)
+
+            r = self.r[adapter_name]
+            Vr, Sr, Uhr = self._compute_svd_factors(
+                W,
+                r,
+                svd_mode=self.psoft_svd[adapter_name],
+                niter=self.psoft_svd_lowrank_niter[adapter_name],
+                random_seed=self.random_seed[adapter_name],
+            )
+
+            Sr_scaled = Sr / self.scaling[adapter_name]
+
+            if init_type == "psoft_init":
+                A = Uhr  # (r, in)
+                B = Vr @ torch.diag(Sr_scaled)  # (out, r)
+            elif init_type == "pissa_init":
+                s_sqrt = torch.sqrt(Sr_scaled)
+                A = torch.diag(s_sqrt) @ Uhr  # (r, in)
+                B = Vr @ torch.diag(s_sqrt)  # (out, r)
+            else:
+                raise ValueError(f"Unknown ab_svd_init: {init_type}")
+
+            A = A.contiguous().detach()
+            B = B.contiguous().detach()
+
+            self._set_psoft_ab_cache_buffers(adapter_name, A, B)
+
+    def _compute_svd_factors(self, weight: torch.Tensor, r: int, *, svd_mode: str, niter: int, random_seed: int = 0):
+        # weight: (out, in) fp32
+        if svd_mode == "full":
+            U, S, Vh = torch.linalg.svd(weight.data, full_matrices=False)
+            Vr = U[:, :r]  # (out, r)
+            Sr = S[:r]  # (r,)
+            Uhr = Vh[:r, :]  # (r, in)
+        elif svd_mode == "lowrank":
+            # torch.svd_lowrank uses a random projection, so the A/B initialization it produces depends on the
+            # RNG state. Seed a forked RNG with the configurable random_seed to make it deterministic
+            # (torch.svd_lowrank does not accept a generator argument); fork_rng leaves the global RNG untouched.
+            fork_devices = [weight.device] if weight.device.type == "cuda" else []
+            with torch.random.fork_rng(devices=fork_devices):
+                torch.manual_seed(random_seed)
+                U, S, V = svd_lowrank(weight.data, q=r, niter=niter)  # V: (in, r)
+            Vr = U[:, :r]
+            Sr = S[:r]
+            Uhr = V[:, :r].t()  # (r, in)
+        else:
+            raise ValueError(f"Unknown svd_mode: {svd_mode}")
+        return Vr, Sr, Uhr
+
+
+class Linear(nn.Module, PsoftLayer):
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        adapter_name: str,
+        config: PsoftConfig,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__()
+        PsoftLayer.__init__(self, base_layer, **kwargs)
+
+        self.fan_in_fan_out = config.fan_in_fan_out
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, config=config, **kwargs)
+
+    def _get_R_matrix(self, adapter_name: str) -> torch.Tensor:
+        return self.psoft_R[adapter_name].get_matrix()
+
+    def get_delta_weight(self, adapter_name: str) -> torch.Tensor:
+        """
+        ΔW = scaling * B (R - id_mat) A Returns in base weight layout (respecting fan_in_fan_out).
+        """
+
+        A, B = self._get_psoft_ab_cache_buffers(adapter_name)
+        base_w = self.get_base_layer().weight
+        device = base_w.device
+        out_dtype = base_w.dtype
+
+        R = self._get_R_matrix(adapter_name)
+        r = self.r[adapter_name]
+
+        compute_dtype = (
+            torch.float32 if (device.type == "cpu" and out_dtype in (torch.float16, torch.bfloat16)) else out_dtype
+        )
+
+        A_c = A.to(device=device, dtype=compute_dtype)
+        B_c = B.to(device=device, dtype=compute_dtype)
+        R_c = R.to(device=device, dtype=compute_dtype)
+
+        id_mat = torch.eye(r, device=device, dtype=compute_dtype)
+        delta = B_c @ (R_c - id_mat) @ A_c  # (out, in)
+        delta = transpose(delta, self.fan_in_fan_out)
+        delta = delta * self.scaling[adapter_name]
+
+        return delta.to(dtype=out_dtype)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            return
+
+        base_layer = self.get_base_layer()
+
+        for active_adapter in adapter_names:
+            if active_adapter not in self.psoft_R:
+                continue
+
+            if safe_merge:
+                orig_weight = base_layer.weight.data.clone()
+                orig_dtype = orig_weight.dtype
+
+                delta_weight = self.get_delta_weight(active_adapter)
+                orig_weight += delta_weight.to(orig_dtype)
+
+                if not torch.isfinite(orig_weight).all():
+                    raise ValueError(
+                        f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                    )
+
+                base_layer.weight.data = orig_weight
+            else:
+                delta_weight = self.get_delta_weight(active_adapter)
+                base_layer.weight.data += delta_weight.to(base_layer.weight.dtype)
+
+            self.merged_adapters.append(active_adapter)
+
+    def supports_lora_conversion(self, adapter_name: str = "default") -> bool:
+        return True
+
+    def unmerge(self) -> None:
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.", UserWarning)
+            return
+
+        weight = self.get_base_layer().weight
+
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+
+            if active_adapter not in self.psoft_R:
+                continue
+
+            orig_dtype = weight.dtype
+            delta_weight = self.get_delta_weight(active_adapter)
+            weight.data -= delta_weight.to(orig_dtype)
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+            torch_result_dtype = result.dtype
+
+            psoft_keys = self.psoft_R.keys()
+            for active_adapter in self.active_adapters:
+                if active_adapter not in psoft_keys:
+                    continue
+
+                A, B = self._get_psoft_ab_cache_buffers(active_adapter)
+
+                dropout = self.psoft_dropout[active_adapter]
+                scaling = self.scaling[active_adapter]
+                R_layer = self.psoft_R[active_adapter]
+
+                x_cast = self._cast_input_dtype(x, A.dtype)
+                x_d = dropout(x_cast)
+
+                A_c = A.to(device=x_d.device, dtype=x_d.dtype)
+                B_c = B.to(device=x_d.device, dtype=x_d.dtype)
+
+                xa = x_d @ A_c.t()
+                xr = R_layer(xa)
+
+                delta_y = (xr - xa) @ B_c.t()
+                result = result + (delta_y * scaling)
+
+            result = result.to(torch_result_dtype)
+
+        return result
+
+    def __repr__(self) -> str:
+        return "psoft." + super().__repr__()
+
+
+def dispatch_default(
+    target: nn.Module,
+    adapter_name: str,
+    config: PsoftConfig,
+    **kwargs,
+) -> Optional[nn.Module]:
+    new_module = None
+
+    if isinstance(target, BaseTunerLayer):
+        target_base_layer = target.get_base_layer()
+    else:
+        target_base_layer = target
+
+    if isinstance(target_base_layer, torch.nn.Linear):
+        if config.fan_in_fan_out:
+            warnings.warn(
+                "fan_in_fan_out=True is not compatible with `torch.nn.Linear`. Setting fan_in_fan_out=False."
+            )
+            config.fan_in_fan_out = False
+        new_module = Linear(target, adapter_name, config=config, **kwargs)
+
+    return new_module
diff --git a/src/peft/tuners/psoft/model.py b/src/peft/tuners/psoft/model.py
new file mode 100644
index 0000000..27e0306
--- /dev/null
+++ b/src/peft/tuners/psoft/model.py
@@ -0,0 +1,84 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+from typing import Optional
+
+from torch import nn
+
+from peft.tuners.tuners_utils import BaseTuner, get_device_map
+from peft.utils import TRANSFORMERS_MODELS_TO_PSOFT_TARGET_MODULES_MAPPING
+
+from .config import PsoftConfig
+from .layer import PsoftLayer, dispatch_default
+
+
+class PsoftModel(BaseTuner):
+    """
+    PSOFT (Efficient Orthogonal Fine-Tuning with Principal Subspace Adaptation) model.
+
+    Inserts an r*r orthogonal (or scaled) transformation R between low-rank A and B: ΔW = B @ (R-I) @ A. Use
+    ab_svd_init="psoft_init" to initialize A/B from SVD and freeze them, training only R (and optional magnitude
+    vectors).
+
+    Args:
+        model: The model to adapt.
+        config: PsoftConfig.
+        adapter_name: Adapter name, default "default".
+        low_cpu_mem_usage: Create empty adapter weights on meta device.
+    """
+
+    prefix: str = "psoft_"
+    tuner_layer_cls = PsoftLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_PSOFT_TARGET_MODULES_MAPPING
+
+    def _create_and_replace(
+        self,
+        peft_config: PsoftConfig,
+        adapter_name: str,
+        target: nn.Module,
+        target_name: str,
+        parent: nn.Module,
+        current_key: str,
+        *,
+        parameter_name: Optional[str] = None,
+    ) -> None:
+        if current_key is None:
+            raise ValueError("Current key must not be None.")
+
+        kwargs = {
+            "target_name": current_key,
+            "parameter_name": parameter_name,
+        }
+
+        if isinstance(target, PsoftLayer):
+            target.update_layer(adapter_name, config=peft_config, **kwargs)
+            return
+
+        device_map = get_device_map(self.model)
+        new_module = self._create_new_module(peft_config, adapter_name, target, device_map=device_map, **kwargs)
+
+        if adapter_name not in self.active_adapters:
+            new_module.requires_grad_(False)
+        self._replace_module(parent, target_name, new_module, target)
+
+    @staticmethod
+    def _create_new_module(psoft_config: PsoftConfig, adapter_name: str, target: nn.Module, **kwargs) -> nn.Module:
+        new_module = dispatch_default(target, adapter_name, config=psoft_config, **kwargs)
+        if new_module is None:
+            raise ValueError(
+                f"Target module {target} is not supported by minimal PSOFT. Only torch.nn.Linear is supported."
+            )
+        return new_module
diff --git a/src/peft/tuners/pvera/__init__.py b/src/peft/tuners/pvera/__init__.py
new file mode 100644
index 0000000..2cc9e19
--- /dev/null
+++ b/src/peft/tuners/pvera/__init__.py
@@ -0,0 +1,26 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+
+from peft.utils import register_peft_method
+
+from .config import PveraConfig
+from .layer import Linear, PveraLayer
+from .model import PveraModel
+
+
+__all__ = ["Linear", "PveraConfig", "PveraLayer", "PveraModel"]
+
+
+register_peft_method(name="pvera", config_cls=PveraConfig, model_cls=PveraModel, prefix="pvera_lambda_")
diff --git a/src/peft/tuners/pvera/bnb.py b/src/peft/tuners/pvera/bnb.py
new file mode 100644
index 0000000..20d03c1
--- /dev/null
+++ b/src/peft/tuners/pvera/bnb.py
@@ -0,0 +1,413 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import warnings
+from typing import Optional
+
+import bitsandbytes as bnb
+import torch
+import torch.nn.functional as F
+
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+from peft.tuners.tuners_utils import check_adapters_to_merge
+from peft.utils.integrations import dequantize_bnb_weight
+from peft.utils.other import transpose
+
+from .config import PveraConfig
+from .layer import PveraLayer
+
+
+if is_bnb_available():
+
+    class Linear8bitLt(torch.nn.Module, PveraLayer):
+        def __init__(
+            self,
+            base_layer: torch.nn.Module,
+            adapter_name: str,
+            pvera_A,
+            pvera_B,
+            r: int,
+            config: PveraConfig,
+            **kwargs,
+        ) -> None:
+            super().__init__()
+            PveraLayer.__init__(self, base_layer)
+            self.fan_in_fan_out = config.fan_in_fan_out
+            self.sample_at_inference = config.sample_at_inference
+
+            self._active_adapter = adapter_name
+            self.update_layer(
+                adapter_name,
+                pvera_A,
+                pvera_B,
+                r,
+                config=config,
+            )
+
+        def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+            if self.merged:
+                warnings.warn(
+                    f"Already following adapters were merged {','.join(self.merged_adapters)}. "
+                    f"You are now additionally merging {','.join(self.active_adapters)}."
+                )
+
+            adapter_names = check_adapters_to_merge(self, adapter_names)
+            if not adapter_names:
+                return
+
+            for active_adapter in adapter_names:
+                if active_adapter not in self.pvera_lambda_d.keys():
+                    continue
+
+                warnings.warn(
+                    "Merge pvera module to 8-bit linear may get different generations due to rounding errors."
+                )
+                pvera_data = self.get_delta_weight(active_adapter)
+
+                weight = self.get_base_layer().weight
+                state = self.get_base_layer().state
+                if state.SCB is None:
+                    state.SCB = weight.SCB
+
+                output = dequantize_bnb_weight(weight, state)
+                w_data = output.to(pvera_data.dtype).to(pvera_data.device) + pvera_data
+
+                if safe_merge and not torch.isfinite(w_data).all():
+                    raise ValueError(
+                        f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                    )
+
+                self.get_base_layer().weight = bnb.nn.Int8Params(
+                    w_data.to("cpu"), requires_grad=False, has_fp16_weights=weight.has_fp16_weights
+                ).to(weight.device)
+                state.reset_grads()
+                self.merged_adapters.append(active_adapter)
+
+        def unmerge(self) -> None:
+            if not self.merged:
+                warnings.warn("Already unmerged. Nothing to do")
+                return
+
+            while len(self.merged_adapters) > 0:
+                active_adapter = self.merged_adapters.pop()
+                if active_adapter not in self.pvera_lambda_d.keys():
+                    continue
+                warnings.warn(
+                    "Unmerge pvera module to 8-bit linear may get different generations due to rounding errors."
+                )
+                pvera_data = self.get_delta_weight(active_adapter)
+
+                weight = self.get_base_layer().weight
+                state = self.get_base_layer().state
+                if state.SCB is None:
+                    state.SCB = weight.SCB
+                output = dequantize_bnb_weight(weight, state=state)
+
+                w_data = output.to(pvera_data.dtype).to(pvera_data.device) - pvera_data
+
+                self.get_base_layer().weight = bnb.nn.Int8Params(
+                    w_data.to("cpu"), requires_grad=False, has_fp16_weights=weight.has_fp16_weights
+                ).to(weight.device)
+                state.reset_grads()
+
+        def get_delta_weight(self, adapter) -> torch.Tensor:
+            """
+            Compute the delta weight for the given adapter.
+
+            Args:
+                adapter (str): The name of the adapter for which the delta weight should be computed.
+
+            Returns:
+                torch.Tensor: The computed delta weight for the PVeRA adapter.
+
+            Note:
+                This method implements the PVeRA-specific weight update. Unlike LoRA, PVeRA uses shared projection
+                matrices (pvera_A and pvera_B) across all layers, along with per-layer trainable parameters (lambda_d
+                and lambda_b).
+            """
+            # Retrieve shared projection matrices
+            pvera_A = self.pvera_A[adapter]
+            pvera_B = self.pvera_B[adapter]
+
+            # Retrieve per-layer trainable parameters
+            device = pvera_B.device
+            dtype = pvera_B.dtype
+
+            # In case users wants to merge the adapter weights that are in
+            # (b)float16 while being on CPU, we need to cast the weights to float32, perform the merge and then cast back to
+            # (b)float16 because some CPUs have slow bf16/fp16 matmuls.
+            cast_to_fp32 = device.type == "cpu" and (dtype == torch.float16 or dtype == torch.bfloat16)
+
+            lambda_d = self.pvera_lambda_d[adapter]
+            lambda_b = self.pvera_lambda_b[adapter]
+
+            if cast_to_fp32:
+                pvera_A = pvera_A.float()
+                pvera_B = pvera_B.float()
+                lambda_d = lambda_d.float()
+                lambda_b = lambda_b.float()
+
+            sliced_A = pvera_A[:, : self.in_features].to(lambda_d.device)
+            sliced_B = pvera_B[: self.out_features, :].to(lambda_d.device)
+            lambda_b = lambda_b.unsqueeze(-1)
+            lambda_d = lambda_d.unsqueeze(-1)
+
+            # In PVeRA, the first half of the lambda_d and sliced_A vector corresponds to the mean (mu) and the second half to the log-variance (logvar). When merging, we can only do mean sampling, and therefore only need the first half
+            lambda_d = lambda_d[: lambda_d.size(0) // 2, :]
+            sliced_A = sliced_A[: sliced_A.size(0) // 2, :]
+
+            # PVeRA-specific computation:
+            # 1. Apply lambda_d to the input projection (pvera_A)
+            # 2. Apply lambda_b to the output projection (pvera_B)
+            # 3. Compute the outer product of the scaled projections
+            output_tensor = transpose((lambda_b * sliced_B) @ (lambda_d * sliced_A), self.fan_in_fan_out)
+
+            if cast_to_fp32:
+                output_tensor = output_tensor.to(dtype=dtype)
+
+            return output_tensor
+
+        def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+            """
+            Perform the forward pass using the PVeRA adapter.
+
+            Args:
+                x (torch.Tensor): Input tensor.
+
+            Returns:
+                torch.Tensor: Output tensor after applying the PVeRA adaptation.
+
+            Note:
+                This method implements the PVeRA-specific forward pass. It applies the shared projections (pvera_A and
+                pvera_B) along with the per-layer trainable parameters (lambda_d and lambda_b) to compute the adapter
+                output.
+            """
+            if self.disable_adapters:
+                if self.merged:
+                    self.unmerge()
+                result = self.base_layer(x, *args, **kwargs)
+            elif self.merged:
+                result = self.base_layer(x, *args, **kwargs)
+            else:
+                result = self.base_layer(x, *args, **kwargs)
+                for active_adapter in self.active_adapters:
+                    if active_adapter not in self.pvera_lambda_d.keys():
+                        continue
+
+                    lambda_d = self.pvera_lambda_d[active_adapter]
+                    lambda_b = self.pvera_lambda_b[active_adapter]
+
+                    pvera_A = self.pvera_A[active_adapter]
+                    pvera_B = self.pvera_B[active_adapter]
+
+                    dropout = self.pvera_dropout[active_adapter]
+
+                    requires_conversion = not torch.is_autocast_enabled()
+                    if requires_conversion:
+                        expected_dtype = result.dtype
+                        compute_dtype = lambda_d.dtype
+                        if x.dtype != compute_dtype:
+                            x = x.to(compute_dtype)
+
+                    sliced_A = pvera_A[:, : self.in_features].to(x.device)
+                    sliced_B = pvera_B[: self.out_features, :].to(x.device)
+
+                    x_temp = dropout(x.to(lambda_d.dtype))
+                    mu, logvar = (lambda_d * F.linear(x_temp, sliced_A)).chunk(2, dim=-1)
+                    adapter_output = lambda_b * F.linear(
+                        self._reparametrize(mu, logvar, self.sample_at_inference), sliced_B
+                    )
+
+                    if requires_conversion:
+                        adapter_output = adapter_output.to(expected_dtype)
+
+                    result = result + adapter_output
+
+            # Ensure the output tensor has the same dtype as the input tensor
+            return result.to(x.dtype)
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return "pvera." + rep
+
+
+if is_bnb_4bit_available():
+
+    class Linear4bit(torch.nn.Module, PveraLayer):
+        def __init__(
+            self,
+            base_layer: torch.nn.Module,
+            adapter_name: str,
+            pvera_A,
+            pvera_B,
+            r: int,
+            config: PveraConfig,
+            **kwargs,
+        ) -> None:
+            super().__init__()
+            PveraLayer.__init__(self, base_layer)
+            self.fan_in_fan_out = config.fan_in_fan_out
+            self.sample_at_inference = config.sample_at_inference
+
+            self._active_adapter = adapter_name
+            self.update_layer(
+                adapter_name,
+                pvera_A,
+                pvera_B,
+                r,
+                config=config,
+            )
+
+        def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+            if self.merged:
+                warnings.warn(
+                    f"Already following adapters were merged {','.join(self.merged_adapters)}. "
+                    f"You are now additionally merging {','.join(self.active_adapters)}."
+                )
+
+            adapter_names = check_adapters_to_merge(self, adapter_names)
+            if not adapter_names:
+                return
+
+            for active_adapter in adapter_names:
+                if active_adapter not in self.pvera_lambda_d.keys():
+                    continue
+
+                warnings.warn(
+                    "Merge pvera module to 4-bit linear may get different generations due to rounding errors."
+                )
+                pvera_data = self.get_delta_weight(active_adapter)
+
+                weight = self.get_base_layer().weight
+                kwargs = weight.__dict__
+                # torch.compile can introduce attributes preceded by '_', remove them
+                kwargs = {k: v for k, v in kwargs.items() if not k.startswith("_")}
+                w_data = bnb.functional.dequantize_4bit(weight.data, weight.quant_state) + pvera_data
+
+                if safe_merge and not torch.isfinite(w_data).all():
+                    raise ValueError(
+                        f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                    )
+
+                self.get_base_layer().weight = bnb.nn.Params4bit(w_data.to("cpu"), requires_grad=False, **kwargs).to(
+                    weight.device
+                )
+                self.merged_adapters.append(active_adapter)
+
+        def unmerge(self) -> None:
+            if not self.merged:
+                warnings.warn("Already unmerged. Nothing to do")
+                return
+
+            while len(self.merged_adapters) > 0:
+                active_adapter = self.merged_adapters.pop()
+                if active_adapter not in self.pvera_lambda_d.keys():
+                    continue
+                warnings.warn(
+                    "Unmerge pvera module to 4-bit linear may get different generations due to rounding errors."
+                )
+                pvera_data = self.get_delta_weight(active_adapter)
+
+                weight = self.get_base_layer().weight
+                kwargs = weight.__dict__
+                w_data = bnb.functional.dequantize_4bit(weight.data, weight.quant_state) - pvera_data
+
+                self.get_base_layer().weight = bnb.nn.Params4bit(w_data.to("cpu"), requires_grad=False, **kwargs).to(
+                    weight.device
+                )
+
+        def get_delta_weight(self, adapter) -> torch.Tensor:
+            pvera_A = self.pvera_A[adapter]
+            pvera_B = self.pvera_B[adapter]
+
+            device = pvera_B.device
+            dtype = pvera_B.dtype
+
+            cast_to_fp32 = device.type == "cpu" and (dtype == torch.float16 or dtype == torch.bfloat16)
+
+            lambda_d = self.pvera_lambda_d[adapter]
+            lambda_b = self.pvera_lambda_b[adapter]
+
+            if cast_to_fp32:
+                pvera_A = pvera_A.float()
+                pvera_B = pvera_B.float()
+                lambda_d = lambda_d.float()
+                lambda_b = lambda_b.float()
+
+            sliced_A = pvera_A[:, : self.in_features].to(lambda_d.device)
+            sliced_B = pvera_B[: self.out_features, :].to(lambda_d.device)
+            lambda_b = lambda_b.unsqueeze(-1)
+            lambda_d = lambda_d.unsqueeze(-1)
+
+            # In PVeRA, the first half of the lambda_d and sliced_A vector corresponds to the mean (mu) and the second half to the log-variance (logvar). When merging, we can only do mean sampling, and therefore only need the first half
+            lambda_d = lambda_d[: lambda_d.size(0) // 2, :]
+            sliced_A = sliced_A[: sliced_A.size(0) // 2, :]
+
+            output_tensor = transpose((lambda_b * sliced_B) @ (lambda_d * sliced_A), self.fan_in_fan_out)
+
+            if cast_to_fp32:
+                output_tensor = output_tensor.to(dtype=dtype)
+
+            return output_tensor
+
+        def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+            if self.disable_adapters:
+                if self.merged:
+                    self.unmerge()
+                result = self.base_layer(x, *args, **kwargs)
+            elif self.merged:
+                result = self.base_layer(x, *args, **kwargs)
+            else:
+                result = self.base_layer(x, *args, **kwargs)
+                result = result.clone()
+                for active_adapter in self.active_adapters:
+                    if active_adapter not in self.pvera_lambda_d.keys():
+                        continue
+
+                    lambda_d = self.pvera_lambda_d[active_adapter]
+                    lambda_b = self.pvera_lambda_b[active_adapter]
+
+                    pvera_A = self.pvera_A[active_adapter]
+                    pvera_B = self.pvera_B[active_adapter]
+
+                    dropout = self.pvera_dropout[active_adapter]
+
+                    requires_conversion = not torch.is_autocast_enabled()
+                    if requires_conversion:
+                        expected_dtype = result.dtype
+                        compute_dtype = lambda_d.dtype
+                        if x.dtype != compute_dtype:
+                            x = x.to(compute_dtype)
+
+                    sliced_A = pvera_A[:, : self.in_features].to(x.device)
+                    sliced_B = pvera_B[: self.out_features, :].to(x.device)
+
+                    x_temp = dropout(x.to(lambda_d.dtype))
+                    mu, logvar = (lambda_d * F.linear(x_temp, sliced_A)).chunk(2, dim=-1)
+                    adapter_output = lambda_b * F.linear(
+                        self._reparametrize(mu, logvar, self.sample_at_inference), sliced_B
+                    )
+
+                    if requires_conversion:
+                        adapter_output = adapter_output.to(expected_dtype)
+
+                    result = result + adapter_output
+
+            # Ensure the output tensor has the same dtype as the input tensor
+            return result.to(x.dtype)
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return "pvera." + rep
diff --git a/src/peft/tuners/pvera/config.py b/src/peft/tuners/pvera/config.py
new file mode 100644
index 0000000..8d13ec4
--- /dev/null
+++ b/src/peft/tuners/pvera/config.py
@@ -0,0 +1,210 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import warnings
+from dataclasses import dataclass, field
+from typing import Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class PveraConfig(PeftConfig):
+    """
+    This is the configuration class to store the configuration of a [`PveraModel`].
+
+    Paper: https://www.arxiv.org/abs/2512.07703.
+
+    Args:
+        r (`int`, *optional*, defaults to `256`):
+            PVeRA parameter dimension ("rank"). Choose higher values than LoRA ranks here, since PVeRA shares
+            parameters across layers and therefore uses far fewer parameters than LoRA.
+        target_modules (`Union[List[str], str]`):
+            The names of the modules to apply PVeRA to. Only linear layers are supported. When passing a string, a
+            regex match will be performed. If this is specified as 'all-linear', then all linear/Conv1D modules are
+            chosen. If this is not specified, modules will bechosen according to the model architecture. If the
+            architecture is not known, an error will be raised.
+        projection_prng_key (`int`):
+            PVeRA PRNG init key. Used for initialising pvera_A and pvera_B for new models or when loading a checkpoint
+            that did not include these projections. Defaults to `0`.
+        save_projection (`bool`):
+            Whether to save the pvera_A / pvera_B projections in the state dict alongside per layer lambda_b / lambda_d
+            weights. This will increase the size of the checkpoint, but guarantee that we can reload the checkpoint on
+            all system configurations. Defaults to `True`.
+        pvera_dropout (`float`):
+            The dropout probability for PVeRA layers.
+        d_initial (`float`, *optional*, defaults to `0.1`):
+            Initial value for `pvera_lambda_d` vector used when initializing the PVeRA parameters. Small values (<=0.1)
+            are recommended.
+        fan_in_fan_out (`bool`):
+            Set this to True if the layer to replace stores weight like (fan_in, fan_out). For example, gpt-2 uses
+            `Conv1D` which stores weights like (fan_in, fan_out) and hence this should be set to `True`.
+        bias (`str`):
+            Bias type for PVeRA. Can be 'none', 'all' or 'pvera_only'. If 'all' or 'pvera_only', the corresponding
+            biases will be updated during training. Be aware that this means that, even when disabling the adapters,
+            the model will not produce the same output as the base model would have without adaptation.
+        modules_to_save (`List[str]`):
+            List of modules apart from PVeRA layers to be set as trainable and saved in the final checkpoint.
+        init_weights (`bool`):
+            Whether to initialize the weights of the PVeRA layers with their default initialization. Don't change this
+            setting, except if you know exactly what you're doing.
+        layers_to_transform (`Union[List[int],int]`):
+            The layer indexes to transform, if this argument is specified, it will apply the PVeRA transformations on
+            the layer indexes that are specified in this list. If a single integer is passed, it will apply the PVeRA
+            transformations on the layer at this index.
+        layers_pattern (`Optional[Union[List[str], str]]`):
+            The layer pattern name, used only if `layers_to_transform` is different from `None`. This should target the
+            `nn.ModuleList` of the model, which is often called `'layers'` or `'h'`.
+        sample_at_inference (`bool` | `dict`, defaults to `False`):
+            Whether to sample from the learned PVeRA distribution at inference. If false, the learned mean is used. The
+            default is False (indicating false for all adapters). If True is provided, then the value will be true for
+            all adapters. If a dict is provided, then a specific value can be specified per adapter (with False by
+            default for non-specified adapters). For example
+            `sample_at_inference={'encoder.layer.0.attention.attention.query': True}` will only sample at inference for
+            one specific adapter.
+        generator_seed (`int`, defaults to None):
+            Random seed for the generator for sampling from the learned distribution.
+    """
+
+    r: int = field(
+        default=256,
+        metadata={
+            "help": (
+                "PVeRA parameter dimension ('rank'). Choose higher values than LoRA ranks here, since PVeRA shares "
+                "parameters across layers and therefore uses far fewer parameters than LoRA."
+            )
+        },
+    )
+
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The names of the modules to apply PVeRA to. Only linear layers are supported. When passing a string, a "
+                "regex match will be performed. If this is specified as 'all-linear', then all linear/Conv1D modules are "
+                "chosen. If this is not specified, modules will bechosen according to the model architecture. If the "
+                "architecture is not known, an error will be raised."
+            )
+        },
+    )
+    projection_prng_key: int = field(
+        default=0,
+        metadata={
+            "help": (
+                "PVeRA PRNG init key. Used for initialising pvera_A and pvera_B for new models or when loading a checkpoint "
+                "that did not include these projections. Defaults to `0`."
+            )
+        },
+    )
+    save_projection: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "Whether to save the pvera_A / pvera_B projections in the state dict alongside per layer lambda_b / lambda_d "
+                "weights. This will increase the size of the checkpoint, but guarantee that we can reload the checkpoint on "
+                "all system configurations. Defaults to `True`."
+            )
+        },
+    )
+    pvera_dropout: float = field(default=0.0, metadata={"help": "The dropout probability for PVeRA layers."})
+    d_initial: float = field(default=0.1, metadata={"help": "Initial value for d vector. Default is 0.1."})
+    fan_in_fan_out: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Set this to True if the layer to replace stores weight like (fan_in, fan_out). For example, gpt-2 uses "
+                "`Conv1D` which stores weights like (fan_in, fan_out) and hence this should be set to `True`."
+            )
+        },
+    )
+    bias: str = field(
+        default="none",
+        metadata={
+            "help": (
+                "Bias type for PVeRA. Can be 'none', 'all' or 'pvera_only'. If 'all' or 'pvera_only', the corresponding "
+                "biases will be updated during training. Be aware that this means that, even when disabling the adapters, "
+                "the model will not produce the same output as the base model would have without adaptation."
+            )
+        },
+    )
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of modules apart from PVeRA layers to be set as trainable and saved in the final checkpoint."
+            )
+        },
+    )
+    init_weights: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "Whether to initialize the weights of the PVeRA layers with their default initialization. Don't change this "
+                "setting, except if you know exactly what you're doing."
+            ),
+        },
+    )
+    layers_to_transform: Optional[Union[list[int], int]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The layer indexes to transform, if this argument is specified, it will apply the PVeRA transformations on "
+                "the layer indexes that are specified in this list. If a single integer is passed, it will apply the PVeRA "
+                "transformations on the layer at this index."
+            )
+        },
+    )
+    layers_pattern: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The layer pattern name, used only if `layers_to_transform` is different from `None`. This should target the "
+                "`nn.ModuleList` of the model, which is often called `'layers'` or `'h'`."
+            )
+        },
+    )
+    sample_at_inference: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Whether to sample from the learned PVeRA distribution at inference. If false, the learned mean is used. The "
+                "default is False (indicating false for all adapters). If True is provided, then the value will be true for "
+                "all adapters. If a dict is provided, then a specific value can be specified per adapter (with False by "
+                "default for non-specified adapters). For example "
+                "`sample_at_inference={'encoder.layer.0.attention.attention.query': True}` will only sample at inference for "
+                "one specific adapter."
+            ),
+        },
+    )
+    generator_seed: int = field(
+        default=None, metadata={"help": "Random seed for the generator for sampling from the learned distribution."}
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.PVERA
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        # check for layers_to_transform and layers_pattern
+        if self.layers_pattern and not self.layers_to_transform:
+            raise ValueError("When `layers_pattern` is specified, `layers_to_transform` must also be specified. ")
+        if not self.save_projection:
+            warnings.warn(
+                "Specified to not save pvera_A and pvera_B within the state dictionary, instead they will be restored "
+                "using the PRNG key store in `config.projection_prng_key`. Consider setting `config.save_projection` "
+                "to `True` to guarantee restoring the checkpoint correctly on all system configurations."
+            )
diff --git a/src/peft/tuners/pvera/layer.py b/src/peft/tuners/pvera/layer.py
new file mode 100644
index 0000000..1d784b8
--- /dev/null
+++ b/src/peft/tuners/pvera/layer.py
@@ -0,0 +1,316 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+import warnings
+from typing import Optional
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+from transformers.pytorch_utils import Conv1D
+
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+from peft.utils.other import transpose
+
+from .._buffer_dict import BufferDict
+from .config import PveraConfig
+
+
+class PveraLayer(BaseTunerLayer):
+    # List all names of layers that may contain adapter weights
+    adapter_layer_names = ("pvera_lambda_b", "pvera_lambda_d")
+    other_param_names = ("pvera_A", "pvera_B", "pvera_dropout", "r")
+
+    def __init__(self, base_layer: nn.Module, **kwargs):
+        self.base_layer = base_layer
+        self.r = {}
+        self.pvera_dropout = nn.ModuleDict({})
+
+        # For storing vector scale
+        self.pvera_lambda_b = nn.ParameterDict({})
+        self.pvera_lambda_d = nn.ParameterDict({})
+
+        # Stores a reference to the pvera_A/B BufferDict.
+        # Set to `None` otherwise to avoid computation with random weights
+        self.pvera_A: Optional[BufferDict] = None
+        self.pvera_B: Optional[BufferDict] = None
+
+        # Mark the weight as unmerged
+        self._disable_adapters = False
+        self.merged_adapters = []
+
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            in_features, out_features = base_layer.in_features, base_layer.out_features
+        elif isinstance(base_layer, Conv1D):
+            in_features, out_features = (
+                base_layer.weight.ds_shape if hasattr(base_layer.weight, "ds_shape") else base_layer.weight.shape
+            )
+
+        self.in_features = in_features
+        self.out_features = out_features
+        self.kwargs = kwargs
+
+    @property
+    def merged(self) -> bool:
+        return bool(self.merged_adapters)
+
+    def update_layer(
+        self,
+        adapter_name: str,
+        pvera_A: BufferDict,
+        pvera_B: BufferDict,
+        r: int,
+        config: PveraConfig,
+        **kwargs,
+    ) -> None:
+        if r <= 0:
+            raise ValueError(f"`r` should be a positive integer value but the value passed is {r}")
+
+        pvera_dropout = config.pvera_dropout
+        init_weights = config.init_weights
+        d_initial = config.d_initial
+        inference_mode = config.inference_mode
+
+        self.r[adapter_name] = r
+        if pvera_dropout > 0.0:
+            pvera_dropout_layer = nn.Dropout(p=pvera_dropout)
+        else:
+            pvera_dropout_layer = nn.Identity()
+
+        if config.generator_seed is not None:
+            self.generator = torch.Generator()
+            self.generator.manual_seed(config.generator_seed)
+        else:
+            self.generator = None
+
+        self.pvera_dropout.update(nn.ModuleDict({adapter_name: pvera_dropout_layer}))
+        # Actual trainable parameters
+        self.pvera_lambda_b[adapter_name] = nn.Parameter(torch.ones(self.out_features), requires_grad=True)
+        self.pvera_lambda_d[adapter_name] = nn.Parameter(torch.randn(r * 2), requires_grad=True)
+
+        # non trainable references to pvera_A/B buffers
+        self.pvera_A = pvera_A
+        self.pvera_B = pvera_B
+        if adapter_name not in pvera_A:
+            # This means that this is not the first PVeRA adapter. We have to add an entry in the dict for this adapter.
+            if len(self.pvera_A) < 1:
+                raise ValueError(
+                    "The `pvera_A` and `pvera_B` buffers are empty. This should not happen. Please report this issue."
+                )
+            # we can take any of the existing adapter's parameters, as they should all be identical
+            pvera_A_param = next(iter(self.pvera_A.values()))
+            pvera_B_param = next(iter(self.pvera_B.values()))
+
+            error_tmpl = (
+                "{} has a size of {} but {} or greater is required; this probably happened because an additional PVeRA "
+                "adapter was added after the first one with incompatible shapes."
+            )
+            # check input size
+            if pvera_A_param.shape[1] < self.in_features:
+                raise ValueError(error_tmpl.format("pvera_A", pvera_A_param.shape[1], self.in_features))
+            # check output size
+            if pvera_B_param.shape[0] < self.out_features:
+                raise ValueError(error_tmpl.format("pvera_B", pvera_B_param.shape[0], self.out_features))
+            # check r
+            error_tmpl = (
+                "{} has a size of {} but {} or greater is required; this probably happened because an additional PVeRA "
+                "adapter with a lower rank was added after the first one; loading the adapters "
+                "in reverse order may solve this."
+            )
+            if pvera_A_param.shape[0] < self.r[adapter_name]:
+                raise ValueError(error_tmpl.format("pvera_A", pvera_A_param.shape[0], self.r[adapter_name]))
+            if pvera_B_param.shape[1] < self.r[adapter_name]:
+                raise ValueError(error_tmpl.format("pvera_B", pvera_B_param.shape[1], self.r[adapter_name]))
+
+            self.pvera_A[adapter_name] = pvera_A_param
+            self.pvera_B[adapter_name] = pvera_B_param
+
+        if init_weights:
+            self.reset_pvera_parameters(adapter_name, d_initial=d_initial)
+
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def reset_pvera_parameters(self, adapter_name, d_initial: float = 0.1):
+        if adapter_name in self.pvera_lambda_d.keys():
+            with torch.no_grad():
+                nn.init.zeros_(self.pvera_lambda_d[adapter_name]).fill_(d_initial)
+                nn.init.zeros_(self.pvera_lambda_b[adapter_name])
+
+    def _reparametrize(self, mu, logvar, sample_at_inference):
+        if self.training or (not self.training and sample_at_inference):
+            std = torch.exp(0.5 * logvar)
+            eps = torch.randn_like(std, generator=self.generator)
+            z = mu + eps * std
+        else:
+            z = mu
+        return z
+
+
+class Linear(nn.Linear, PveraLayer):
+    # PVeRA implemented in a dense layer
+    def __init__(
+        self,
+        base_layer,
+        pvera_A: BufferDict,
+        pvera_B: BufferDict,
+        adapter_name: str,
+        r: int,
+        config: PveraConfig,
+        is_target_conv_1d_layer: bool = False,
+        **kwargs,
+    ) -> None:
+        # this gets the init from nn.Linear's super perspective, i.e. nn.Module.__init__, which should always be called
+        super(nn.Linear, self).__init__()
+        PveraLayer.__init__(self, base_layer, **kwargs)
+        self.fan_in_fan_out = config.fan_in_fan_out
+        self.sample_at_inference = config.sample_at_inference
+
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, pvera_A, pvera_B, r, config=config)
+        self.is_target_conv_1d_layer = is_target_conv_1d_layer
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.pvera_lambda_d.keys():
+                base_layer = self.get_base_layer()
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    # because of the copy operation.
+                    orig_weights = base_layer.weight.data.clone()
+
+                    orig_weights += self.get_delta_weight(active_adapter)
+
+                    if not torch.isfinite(orig_weights).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = orig_weights
+                else:
+                    base_layer.weight.data += self.get_delta_weight(active_adapter)
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.pvera_lambda_d.keys():
+                self.get_base_layer().weight.data -= self.get_delta_weight(active_adapter)
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        """
+        Compute the delta weight for the given adapter.
+
+        Args:
+            adapter (str):
+                The name of the adapter for which the delta weight should be computed.
+        """
+        pvera_A = self.pvera_A[adapter]
+        pvera_B = self.pvera_B[adapter]
+
+        device = pvera_B.device
+        dtype = pvera_B.dtype
+
+        # In case users wants to merge the adapter weights that are in
+        # (b)float16 while being on CPU, we need to cast the weights to float32, perform the merge and then cast back to
+        # (b)float16 because some CPUs have slow bf16/fp16 matmuls.
+        cast_to_fp32 = device.type == "cpu" and (dtype == torch.float16 or dtype == torch.bfloat16)
+
+        lambda_d = self.pvera_lambda_d[adapter]
+        lambda_b = self.pvera_lambda_b[adapter]
+
+        if cast_to_fp32:
+            pvera_A = pvera_A.float()
+            pvera_B = pvera_B.float()
+            lambda_d = lambda_d.float()
+            lambda_b = lambda_b.float()
+
+        sliced_A = pvera_A[:, : self.in_features].to(lambda_d.device)
+        sliced_B = pvera_B[: self.out_features, :].to(lambda_d.device)
+        lambda_b = lambda_b.unsqueeze(-1)
+        lambda_d = lambda_d.unsqueeze(-1)
+
+        # In PVeRA, the first half of the lambda_d and sliced_A vector corresponds to the mean (mu) and the second half to the log-variance (logvar). When merging, we can only do mean sampling, and therefore only need the first half
+        lambda_d = lambda_d[: lambda_d.size(0) // 2, :]
+        sliced_A = sliced_A[: sliced_A.size(0) // 2, :]
+
+        output_tensor = transpose((lambda_b * sliced_B) @ (lambda_d * sliced_A), self.fan_in_fan_out)
+
+        if cast_to_fp32:
+            output_tensor = output_tensor.to(dtype=dtype)
+
+        return output_tensor
+
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        previous_dtype = x.dtype
+
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.pvera_lambda_d.keys():
+                    continue
+
+                lambda_d = self.pvera_lambda_d[active_adapter]
+                lambda_b = self.pvera_lambda_b[active_adapter]
+
+                pvera_A = self.pvera_A[active_adapter]
+                pvera_B = self.pvera_B[active_adapter]
+
+                # As adapted layers may have different shapes and PVeRA contains a single shared pair of A and B matrices,
+                # we initialize these matrices with the largest required size for each dimension.
+                # During the forward pass, required submatrices are sliced out from the shared pvera_A and pvera_B.
+                sliced_A = pvera_A[:, : self.in_features].to(x.device)
+                sliced_B = pvera_B[: self.out_features, :].to(x.device)
+
+                dropout = self.pvera_dropout[active_adapter]
+                x = x.to(lambda_d.dtype)
+                mu, logvar = (lambda_d * F.linear(dropout(x), sliced_A)).chunk(2, dim=-1)
+                result = result + lambda_b * F.linear(
+                    self._reparametrize(mu, logvar, self.sample_at_inference), sliced_B
+                )
+
+        result = result.to(previous_dtype)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "pvera." + rep
diff --git a/src/peft/tuners/pvera/model.py b/src/peft/tuners/pvera/model.py
new file mode 100644
index 0000000..943cce7
--- /dev/null
+++ b/src/peft/tuners/pvera/model.py
@@ -0,0 +1,263 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+import warnings
+
+import torch
+from torch import nn
+from transformers.pytorch_utils import Conv1D
+
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer
+from peft.utils import (
+    TRANSFORMERS_MODELS_TO_PVERA_TARGET_MODULES_MAPPING,
+)
+
+from .._buffer_dict import BufferDict
+from ..tuners_utils import _maybe_include_all_linear_layers
+from .config import PveraConfig
+from .layer import Linear, PveraLayer
+
+
+class PveraModel(BaseTuner):
+    """
+    Creates Probabilistic Vector-based Random Matrix Adaptation (PVeRA) model from a pretrained transformers model.
+
+    Args:
+        model ([`~transformers.PreTrainedModel`]): The model to be adapted.
+        config ([`PveraConfig`]): The configuration of the PVeRA model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            Create empty adapter weights on meta device. Useful to speed up the loading process.
+
+    Returns:
+        `torch.nn.Module`: The PVeRA model.
+
+    Example:
+
+        ```py
+        >>> from transformers import AutoModel
+        >>> from peft import PveraConfig, get_peft_model
+
+        >>> base_model = AutoModel.from_pretrained("facebook/dinov2-base")
+        >>> config = PveraConfig(r=128, sample_at_inference=False)
+        >>> model = get_peft_model(base_model, config)
+        ```
+
+    **Attributes**:
+        - **model** ([`~transformers.PreTrainedModel`]) -- The model to be adapted.
+        - **peft_config** ([`PveraConfig`]): The configuration of the PVeRA model.
+    """
+
+    prefix: str = "pvera_lambda_"
+    tuner_layer_cls = PveraLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_PVERA_TARGET_MODULES_MAPPING
+
+    def _find_dim(self, config) -> tuple[int, int]:
+        """
+        Finds the largest input and output dimensions across linear layers that have been wrapped with PVeRA.
+
+        This will be used for determining the size of the shared pvera_A and pvera_B matrices.
+        """
+        model_config = self.get_model_config(self.model)
+
+        peft_config = self._prepare_adapter_config(config, model_config)
+        peft_config = _maybe_include_all_linear_layers(peft_config, self.model)
+
+        largest_shape = None
+        for key, module in self.model.named_modules():
+            if not self._check_target_module_exists(peft_config, key):
+                continue
+
+            if isinstance(module, nn.Linear):
+                module_shape = module.out_features, module.in_features
+            elif isinstance(module, Conv1D):
+                module_shape = module.weight.ds_shape if hasattr(module.weight, "ds_shape") else module.weight.shape
+                module_shape = module_shape[::-1]
+            else:
+                continue
+
+            if largest_shape is None:
+                largest_shape = module_shape
+                continue
+
+            if module_shape != largest_shape:
+                largest_shape = tuple(max(a, b) for a, b in zip(largest_shape, module_shape))
+
+        if largest_shape is None:
+            msg = "No layers types compatible with PVeRA were found. Please check `peft_config.target_modules`."
+            raise ValueError(msg)
+
+        return largest_shape
+
+    def _init_pvera_A_pvera_B(self, config: PveraConfig, adapter_name: str) -> None:
+        linear_out_dim, linear_in_dim = self._find_dim(config)
+
+        # use of persistent to exclude pvera_A and pvera_B from the state dict if we choose not to save them.
+        self.pvera_A = BufferDict({}, persistent=config.save_projection)
+        self.pvera_B = BufferDict({}, persistent=config.save_projection)
+
+        # deterministic init of pvera_A and pvera_B if we know the key
+        generator = torch.Generator(device="cpu").manual_seed(config.projection_prng_key)
+        pvera_A = torch.nn.init.kaiming_uniform_(torch.empty(config.r * 2, linear_in_dim), generator=generator)
+        pvera_B = torch.nn.init.kaiming_uniform_(torch.empty(linear_out_dim, config.r), generator=generator)
+
+        self.pvera_A[adapter_name] = pvera_A
+        self.pvera_B[adapter_name] = pvera_B
+
+    def _pre_injection_hook(self, model: nn.Module, config: PveraConfig, adapter_name: str) -> None:
+        self._init_pvera_A_pvera_B(config, adapter_name)
+
+    def _check_new_adapter_config(self, config: PveraConfig) -> None:
+        """
+        A helper method to check the config when a new adapter is being added.
+
+        Raise a ValueError if there is something wrong with the config or if it conflicts with existing adapters.
+
+        """
+        super()._check_new_adapter_config(config)
+
+        for existing_config in self.peft_config.values():
+            if existing_config is config:
+                # skip the current config
+                continue
+
+            if existing_config.projection_prng_key != config.projection_prng_key:
+                raise ValueError(
+                    f"PVeRA PRNG initialisation key must be the same for all adapters. Got {config.projection_prng_key=} but "
+                    f"previous config had {existing_config.projection_prng_key}."
+                )
+
+        save_project_unique_values = {config.save_projection for config in self.peft_config.values()}
+        if len(save_project_unique_values) > 1:
+            raise ValueError(
+                "PVeRA projection weights must be saved for all adapters or none, but got multiple different values: "
+                f"{save_project_unique_values}"
+            )
+
+    def _create_and_replace(
+        self,
+        pvera_config,
+        adapter_name,
+        target,
+        target_name,
+        parent,
+        current_key,
+        **optional_kwargs,
+    ):
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+
+        r = pvera_config.r
+        bias = hasattr(target, "bias") and target.bias is not None
+        kwargs = {
+            "r": r,
+            "loaded_in_8bit": getattr(self.model, "is_loaded_in_8bit", False),
+            "loaded_in_4bit": getattr(self.model, "is_loaded_in_4bit", False),
+        }
+        kwargs["bias"] = bias
+
+        if isinstance(target, Linear):
+            target.update_layer(
+                adapter_name,
+                pvera_A=self.pvera_A,
+                pvera_B=self.pvera_B,
+                r=r,
+                config=pvera_config,
+            )
+        else:
+            new_module = self._create_new_module(
+                pvera_config, self.pvera_A, self.pvera_B, adapter_name, target, current_key, **kwargs
+            )
+            if adapter_name not in self.active_adapter:
+                # adding an additional adapter: it is not automatically trainable
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+    @staticmethod
+    def _create_new_module(pvera_config, pvera_A, pvera_B, adapter_name, target, current_key, **kwargs):
+        # avoid eager bnb import
+        if is_bnb_available():
+            import bitsandbytes as bnb
+
+            from .bnb import Linear8bitLt
+
+        if is_bnb_4bit_available():
+            from .bnb import Linear4bit
+
+        bias = kwargs.pop("bias", False)
+        loaded_in_8bit = kwargs.get("loaded_in_8bit", False)
+        loaded_in_4bit = kwargs.get("loaded_in_4bit", False)
+
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        if loaded_in_8bit and isinstance(target_base_layer, bnb.nn.Linear8bitLt):
+            eightbit_kwargs = kwargs.copy()
+            eightbit_kwargs.update(
+                {
+                    "has_fp16_weights": target_base_layer.state.has_fp16_weights,
+                    "threshold": target_base_layer.state.threshold,
+                    "index": target_base_layer.index,
+                }
+            )
+            return Linear8bitLt(target, adapter_name, pvera_A, pvera_B, config=pvera_config, **eightbit_kwargs)
+        elif loaded_in_4bit and isinstance(target_base_layer, bnb.nn.Linear4bit):
+            fourbit_kwargs = kwargs.copy()
+            fourbit_kwargs.update(
+                {
+                    "compute_dtype": target_base_layer.compute_dtype,
+                    "compress_statistics": target_base_layer.weight.compress_statistics,
+                    "quant_type": target_base_layer.weight.quant_type,
+                }
+            )
+            return Linear4bit(target, adapter_name, pvera_A, pvera_B, config=pvera_config, **fourbit_kwargs)
+        elif isinstance(target_base_layer, torch.nn.Linear):
+            if pvera_config.fan_in_fan_out:
+                warnings.warn(
+                    "fan_in_fan_out is set to True but the target module is `torch.nn.Linear`. "
+                    "Setting fan_in_fan_out to False."
+                )
+                pvera_config.fan_in_fan_out = False
+        elif isinstance(target_base_layer, Conv1D):
+            if not pvera_config.fan_in_fan_out:
+                warnings.warn(
+                    "fan_in_fan_out is set to False but the target module is `Conv1D`. Setting fan_in_fan_out to True."
+                )
+                pvera_config.fan_in_fan_out = True
+        else:
+            raise ValueError(
+                f"Target module {target} is not supported. Currently, only the following modules are supported: "
+                "`torch.nn.Linear`, `transformers.pytorch_utils.Conv1D`."
+            )
+
+        if isinstance(pvera_config.sample_at_inference, bool):
+            module_sample_at_inference = pvera_config.sample_at_inference
+        else:
+            module_sample_at_inference = pvera_config.sample_at_inference.get(current_key, False)
+
+        new_module = Linear(
+            target,
+            pvera_A,
+            pvera_B,
+            adapter_name,
+            config=pvera_config,
+            **kwargs,
+        )
+
+        return new_module
diff --git a/src/peft/tuners/randlora/__init__.py b/src/peft/tuners/randlora/__init__.py
new file mode 100644
index 0000000..fbad681
--- /dev/null
+++ b/src/peft/tuners/randlora/__init__.py
@@ -0,0 +1,40 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+from peft.utils import register_peft_method
+
+from .config import RandLoraConfig
+from .layer import Linear, RandLoraLayer
+from .model import RandLoraModel
+
+
+__all__ = ["Linear", "RandLoraConfig", "RandLoraLayer", "RandLoraModel"]
+
+register_peft_method(name="randlora", config_cls=RandLoraConfig, model_cls=RandLoraModel, prefix="randlora_")
+
+
+def __getattr__(name):
+    if (name == "Linear8bitLt") and is_bnb_available():
+        from .bnb import Linear8bitLt
+
+        return Linear8bitLt
+
+    if (name == "Linear4bit") and is_bnb_4bit_available():
+        from .bnb import Linear4bit
+
+        return Linear4bit
+
+    raise AttributeError(f"module {__name__} has no attribute {name}")
diff --git a/src/peft/tuners/randlora/bnb.py b/src/peft/tuners/randlora/bnb.py
new file mode 100644
index 0000000..7df7e57
--- /dev/null
+++ b/src/peft/tuners/randlora/bnb.py
@@ -0,0 +1,451 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import warnings
+from typing import Optional
+
+import bitsandbytes as bnb
+import torch
+
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+from peft.tuners.tuners_utils import check_adapters_to_merge
+from peft.utils.integrations import dequantize_bnb_weight
+from peft.utils.other import transpose
+
+from .config import RandLoraConfig
+from .layer import RandLoraLayer, UniqueBaseGrad
+
+
+if is_bnb_available():
+
+    class Linear8bitLt(torch.nn.Module, RandLoraLayer):
+        def __init__(
+            self,
+            base_layer: torch.nn.Module,
+            adapter_name: str,
+            config: RandLoraConfig,
+            randlora_A,
+            randlora_B,
+            r: int = 0,
+            randlora_alpha: int = 0,
+            init_weights: bool = True,
+            **kwargs,
+        ) -> None:
+            super().__init__()
+            RandLoraLayer.__init__(self, base_layer)
+            self.fan_in_fan_out = config.fan_in_fan_out
+
+            self._active_adapter = adapter_name
+            self.update_layer(
+                adapter_name,
+                randlora_A,
+                randlora_B,
+                r,
+                config=config,
+            )
+
+        def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+            """
+            Merge the active adapter weights into the base weights
+
+            Args:
+                safe_merge (`bool`, *optional*):
+                    If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                    before merging the weights. This is useful if you want to check if the merge operation will produce
+                    NaNs. Defaults to `False`.
+                adapter_names (`list[str]`, *optional*):
+                    The list of adapter names that should be merged. If None, all active adapters will be merged.
+                    Defaults to `None`.
+            """
+
+            adapter_names = check_adapters_to_merge(self, adapter_names)
+            if not adapter_names:
+                return
+
+            for active_adapter in adapter_names:
+                if active_adapter not in self.randlora_lambda.keys():
+                    continue
+
+                warnings.warn(
+                    "Merge RandLora module to 8-bit linear may get different generations due to rounding errors."
+                )
+                randlora_data = self.get_delta_weight(active_adapter)
+
+                weight = self.get_base_layer().weight
+                state = self.get_base_layer().state
+                if state.SCB is None:
+                    state.SCB = weight.SCB
+
+                output = dequantize_bnb_weight(weight, state)
+                w_data = output.to(randlora_data.dtype).to(randlora_data.device) + randlora_data
+
+                if safe_merge and not torch.isfinite(w_data).all():
+                    raise ValueError(
+                        f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                    )
+
+                self.get_base_layer().weight = bnb.nn.Int8Params(
+                    w_data.to("cpu"), requires_grad=False, has_fp16_weights=weight.has_fp16_weights
+                ).to(weight.device)
+                state.reset_grads()
+                self.merged_adapters.append(active_adapter)
+
+        def unmerge(self) -> None:
+            """
+            This method unmerges all merged adapter layers from the base weights.
+            """
+            if not self.merged:
+                warnings.warn("Already unmerged. Nothing to do")
+                return
+
+            while len(self.merged_adapters) > 0:
+                active_adapter = self.merged_adapters.pop()
+                if active_adapter not in self.randlora_lambda.keys():
+                    continue
+                warnings.warn(
+                    "Unmerge randlora module to 8-bit linear may get different generations due to rounding errors."
+                )
+                randlora_data = self.get_delta_weight(active_adapter)
+
+                weight = self.get_base_layer().weight
+                state = self.get_base_layer().state
+                if state.SCB is None:
+                    state.SCB = weight.SCB
+                output = dequantize_bnb_weight(weight, state=state)
+
+                w_data = output.to(randlora_data.dtype).to(randlora_data.device) - randlora_data
+
+                self.get_base_layer().weight = bnb.nn.Int8Params(
+                    w_data.to("cpu"), requires_grad=False, has_fp16_weights=weight.has_fp16_weights
+                ).to(weight.device)
+                state.reset_grads()
+
+        def get_scaled_bases(self, adapter, device=None) -> list[torch.Tensor, torch.Tensor]:
+            """
+            Performs scaling on the smallest random base (randlora_A) and returns randlora_A and randlora_B in the
+            correct order to fit the target layers' dimensions
+
+            Args:
+                adapter (str):
+                    The name of the adapter for which the delta weight should be computed.
+            """
+
+            randlora_A = self.randlora_A[adapter]
+            randlora_B = self.randlora_B[adapter]
+
+            if device is None:
+                device = randlora_B.device
+            dtype = randlora_B.dtype
+
+            # In case users wants to merge the adapter weights that are in
+            # (b)float16 while being on CPU, we need to cast the weights to float32, perform the merge and then cast back to
+            # (b)float16 because some CPUs have slow bf16/fp16 matmuls.
+            cast_to_fp32 = device.type == "cpu" and (dtype == torch.float16 or dtype == torch.bfloat16)
+
+            randlora_lambda = self.randlora_lambda[adapter].to(device)
+            randlora_gamma = self.randlora_gamma[adapter].to(device)
+
+            if cast_to_fp32:
+                randlora_A = randlora_A.float()
+                randlora_B = randlora_B.float()
+                randlora_lambda = randlora_lambda.float()
+                randlora_gamma = randlora_gamma.float()
+
+            # The trainable parameters are always applied to randlora_A, the smallest basis.
+            min_dim, max_dim = min(self.out_features, self.in_features), max(self.out_features, self.in_features)
+
+            # As adapted layers may have different shapes and RandLora contains a single shared pair of A and B matrices,
+            # we initialize these matrices with the largest required size for each dimension.
+            # During the forward pass, required submatrices are sliced out from the shared randlora_A and randlora_B.
+            sliced_A = randlora_A[:, : self.num_bases, :min_dim].to(device)
+            sliced_B = randlora_B[:max_dim, : self.num_bases, :].to(device)
+
+            # Flattening the matrices over the rank and number of bases dimensions is more memory efficient
+            update_B = sliced_B.flatten(start_dim=1)
+            update_A = UniqueBaseGrad.apply(sliced_A, randlora_lambda, randlora_gamma).flatten(end_dim=1)
+            if min_dim == self.in_features:
+                return update_A, update_B
+
+            return update_B.T, update_A.T
+
+        def get_delta_weight(self, adapter) -> torch.Tensor:
+            """
+            Compute the delta weight for the given adapter.
+
+            Args:
+                adapter (str):
+                    The name of the adapter for which the delta weight should be computed.
+            """
+
+            update_B, update_A = self.get_scaled_bases(adapter)
+
+            update = update_B @ update_A
+            output_tensor = transpose(update, self.fan_in_fan_out)
+
+            scaling = self.scaling[adapter]
+
+            return output_tensor * scaling
+
+        def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+            """
+            Perform the forward pass using the RandLora adapter.
+
+            Args:
+                x (torch.Tensor): Input tensor.
+
+            Returns:
+                torch.Tensor: Output tensor after applying the RandLora adaptation.
+
+            Note:
+                This method implements the RandLora-specific forward pass. It applies the shared projections
+                (randlora_A and randlora_B) along with the per-layer trainable parameters (lambda and gamma) to compute
+                the adapter output.
+            """
+            if self.disable_adapters:
+                if self.merged:
+                    self.unmerge()
+                result = self.base_layer(x, *args, **kwargs)
+            elif self.merged:
+                result = self.base_layer(x, *args, **kwargs)
+            else:
+                result = self.base_layer(x, *args, **kwargs)
+                for active_adapter in self.active_adapters:
+                    if active_adapter not in self.randlora_lambda.keys():
+                        continue
+
+                    update_B, update_A = self.get_scaled_bases(active_adapter, device=x.device)
+
+                    requires_conversion = not torch.is_autocast_enabled()
+                    if requires_conversion:
+                        expected_dtype = result.dtype
+                        compute_dtype = update_A.dtype
+                        if x.dtype != compute_dtype:
+                            x = x.to(compute_dtype)
+
+                    dropout = self.randlora_dropout[active_adapter]
+                    x_temp = dropout(x.to(update_A.dtype))
+
+                    adapter_output = torch.nn.functional.linear(torch.nn.functional.linear(x_temp, update_B), update_A)
+
+                    if requires_conversion:
+                        adapter_output = adapter_output.to(expected_dtype)
+
+                    scaling = self.scaling[active_adapter]
+                    result = result + adapter_output * scaling
+
+            # Ensure the output tensor has the same dtype as the input tensor
+            return result.to(x.dtype)
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return "randlora." + rep
+
+
+if is_bnb_4bit_available():
+
+    class Linear4bit(torch.nn.Module, RandLoraLayer):
+        def __init__(
+            self,
+            base_layer: torch.nn.Module,
+            adapter_name: str,
+            config: RandLoraConfig,
+            randlora_A,
+            randlora_B,
+            r: int = 0,
+            randlora_alpha: int = 0,
+            init_weights: bool = True,
+            **kwargs,
+        ) -> None:
+            super().__init__()
+            RandLoraLayer.__init__(self, base_layer)
+            self.fan_in_fan_out = config.fan_in_fan_out
+            self._active_adapter = adapter_name
+            self.update_layer(
+                adapter_name,
+                randlora_A,
+                randlora_B,
+                r,
+                config=config,
+            )
+
+        def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+            """
+            Merge the active adapter weights into the base weights
+
+            Args:
+                safe_merge (`bool`, *optional*):
+                    If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                    before merging the weights. This is useful if you want to check if the merge operation will produce
+                    NaNs. Defaults to `False`.
+                adapter_names (`list[str]`, *optional*):
+                    The list of adapter names that should be merged. If None, all active adapters will be merged.
+                    Defaults to `None`.
+            """
+
+            adapter_names = check_adapters_to_merge(self, adapter_names)
+            if not adapter_names:
+                return
+
+            for active_adapter in adapter_names:
+                if active_adapter not in self.randlora_lambda.keys():
+                    continue
+
+                warnings.warn(
+                    "Merge RandLora module to 4-bit linear may get different generations due to rounding errors."
+                )
+                randlora_data = self.get_delta_weight(active_adapter)
+
+                weight = self.get_base_layer().weight
+                kwargs = weight.__dict__
+                w_data = bnb.functional.dequantize_4bit(weight.data, weight.quant_state) + randlora_data
+
+                if safe_merge and not torch.isfinite(w_data).all():
+                    raise ValueError(
+                        f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                    )
+
+                self.get_base_layer().weight = bnb.nn.Params4bit(w_data.to("cpu"), requires_grad=False, **kwargs).to(
+                    weight.device
+                )
+                self.merged_adapters.append(active_adapter)
+
+        def unmerge(self) -> None:
+            """
+            This method unmerges all merged adapter layers from the base weights.
+            """
+            if not self.merged:
+                warnings.warn("Already unmerged. Nothing to do")
+                return
+
+            while len(self.merged_adapters) > 0:
+                active_adapter = self.merged_adapters.pop()
+                if active_adapter not in self.randlora_lambda.keys():
+                    continue
+                warnings.warn(
+                    "Unmerge RandLora module to 4-bit linear may get different generations due to rounding errors."
+                )
+                randlora_data = self.get_delta_weight(active_adapter)
+
+                weight = self.get_base_layer().weight
+                kwargs = weight.__dict__
+                w_data = bnb.functional.dequantize_4bit(weight.data, weight.quant_state) - randlora_data
+
+                self.get_base_layer().weight = bnb.nn.Params4bit(w_data.to("cpu"), requires_grad=False, **kwargs).to(
+                    weight.device
+                )
+
+        def get_scaled_bases(self, adapter, device=None) -> list[torch.Tensor, torch.Tensor]:
+            """
+            Performs scaling on the smallest random base (randlora_A) and returns randlora_A and randlora_B in the
+            correct order to fit the target layers' dimensions
+
+            Args:
+                adapter (str):
+                    The name of the adapter for which the delta weight should be computed.
+            """
+
+            randlora_A = self.randlora_A[adapter]
+            randlora_B = self.randlora_B[adapter]
+            if device is None:
+                device = randlora_B.device
+            dtype = randlora_B.dtype
+
+            # In case users wants to merge the adapter weights that are in
+            # (b)float16 while being on CPU, we need to cast the weights to float32, perform the merge and then cast back to
+            # (b)float16 because some CPUs have slow bf16/fp16 matmuls.
+            cast_to_fp32 = device.type == "cpu" and (dtype == torch.float16 or dtype == torch.bfloat16)
+
+            randlora_lambda = self.randlora_lambda[adapter].to(device)
+            randlora_gamma = self.randlora_gamma[adapter].to(device)
+
+            if cast_to_fp32:
+                randlora_A = randlora_A.float()
+                randlora_B = randlora_B.float()
+                randlora_lambda = randlora_lambda.float()
+                randlora_gamma = randlora_gamma.float()
+
+            # The trainable parameters are always applied to randlora_A, the smallest basis.
+            min_dim, max_dim = min(self.out_features, self.in_features), max(self.out_features, self.in_features)
+
+            # As adapted layers may have different shapes and RandLora contains a single shared pair of A and B matrices,
+            # we initialize these matrices with the largest required size for each dimension.
+            # During the forward pass, required submatrices are sliced out from the shared randlora_A and randlora_B.
+            sliced_A = randlora_A[:, : self.num_bases, :min_dim].to(device)
+            sliced_B = randlora_B[:max_dim, : self.num_bases, :].to(device)
+            # Flattening the matrices over the rank and number of bases dimensions is more memory efficient
+            update_B = sliced_B.flatten(start_dim=1)
+            update_A = UniqueBaseGrad.apply(sliced_A, randlora_lambda, randlora_gamma).flatten(end_dim=1)
+            if min_dim == self.in_features:
+                return update_A, update_B
+
+            return update_B.T, update_A.T
+
+        def get_delta_weight(self, adapter) -> torch.Tensor:
+            """
+            Compute the delta weight for the given adapter.
+
+            Args:
+                adapter (str):
+                    The name of the adapter for which the delta weight should be computed.
+            """
+            update_B, update_A = self.get_scaled_bases(adapter)
+
+            update = update_B @ update_A
+            output_tensor = transpose(update, self.fan_in_fan_out)
+
+            scaling = self.scaling[adapter]
+
+            return output_tensor * scaling
+
+        def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+            if self.disable_adapters:
+                if self.merged:
+                    self.unmerge()
+                result = self.base_layer(x, *args, **kwargs)
+            elif self.merged:
+                result = self.base_layer(x, *args, **kwargs)
+            else:
+                result = self.base_layer(x, *args, **kwargs)
+                result = result.clone()
+                for active_adapter in self.active_adapters:
+                    if active_adapter not in self.randlora_lambda.keys():
+                        continue
+
+                    update_B, update_A = self.get_scaled_bases(active_adapter, device=x.device)
+
+                    requires_conversion = not torch.is_autocast_enabled()
+                    if requires_conversion:
+                        expected_dtype = result.dtype
+                        compute_dtype = update_A.dtype
+                        if x.dtype != compute_dtype:
+                            x = x.to(compute_dtype)
+
+                    dropout = self.randlora_dropout[active_adapter]
+                    x_temp = dropout(x.to(update_A.dtype))
+
+                    adapter_output = torch.nn.functional.linear(torch.nn.functional.linear(x_temp, update_B), update_A)
+
+                    if requires_conversion:
+                        adapter_output = adapter_output.to(expected_dtype)
+
+                    scaling = self.scaling[active_adapter]
+                    result = result + adapter_output * scaling
+
+            # Ensure the output tensor has the same dtype as the input tensor
+            return result.to(x.dtype)
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return "randlora." + rep
diff --git a/src/peft/tuners/randlora/config.py b/src/peft/tuners/randlora/config.py
new file mode 100644
index 0000000..45a3ef1
--- /dev/null
+++ b/src/peft/tuners/randlora/config.py
@@ -0,0 +1,200 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+import warnings
+from dataclasses import dataclass, field
+from typing import Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class RandLoraConfig(PeftConfig):
+    """
+    This is the configuration class to store the configuration of a [`RandLoraModel`].
+
+    Paper: https://huggingface.co/papers/2502.00987.
+
+    Args:
+        r (`int`, *optional*, defaults to `32`):
+            RandLora's random basis rank dimension. Contrary to Lora, this parameter is inversely proportional to the
+            amount of trainable parameters as reducing it increases trainable parameters.
+        target_modules (`Union[list[str], str]`):
+            The names of the modules to apply RandLora to. Only linear layers are supported.
+        projection_prng_key (`int`):
+            RandLora PRNG init key. Used for initialising basis_A and basis_B for new models or when loading a
+            checkpoint that did not include these projections. Defaults to `0`.
+        save_projection (`bool`):
+            Whether to save the global basis_A / basis_B random basis in the state dict alongside per layer lambda /
+            gamma diagonal matrices. This will increase the size of the checkpoint, but guarantee that we can reload
+            the checkpoint on all system configurations. Defaults to `True`.
+        sparse (`bool`):
+            Whether to use sparse random bases as described in the RandLora paper. The bases are ternary sparse bases
+            (only containing -1, 0 and 1) where the attribution probability is 1/6 for -1 and 1 and 2/3 for 0. These
+            sparse matrices aim to be used for matmul free computation in the future, see
+            https://huggingface.co/papers/2406.02528v1 The current implementation is a proof of concept however where
+            the sparseness is not used to improve speed or memory usage. Using sparse matrices typically does not
+            reduce performance and can even help reduce overfitting. Defaults to `False`.
+        very_sparse (`bool`):
+            Whether to use highly sparse random bases as described in the RandLora paper. The very sparse bases are
+            ternary sparse bases (only containing -1, 0 and 1) given a matrix with smallest dimension d, the
+            attribution probability is 1/√D for -1 and 1 and 1- 2/√D for 0. Using these sparse matrices can further
+            reduce overfitting over the `sparse` alternatives but will most likely decrease performance as a results.
+            Use carefully. Defaults to `False`.
+        randlora_dropout (`float`):
+            The dropout probability for RandLora layers.
+        randlora_alpha (`float`):
+            The scaling coefficient for RandLora layers, this would typically be 20 times the rank. Because the
+            `randlora_alpha` coefficient is large by default, it can lead to numerical instabilities especially when
+            learning rates are high. If training is unstable, consider reducing the learning rate or the
+            `randlora_alpha` coefficient.
+        fan_in_fan_out (`bool`):
+            Set this to True if the layer to replace stores weight like (fan_in, fan_out). For example, gpt-2 uses
+            `Conv1D` which stores weights like (fan_in, fan_out) and hence this should be set to `True`.
+        bias (`str`):
+            Bias type. Can be 'none', 'all' or 'randlora_only'. If 'all' or 'randlora_only', the corresponding biases
+            will be updated during training. Be aware that this means that, even when disabling the adapters, the model
+            will not produce the same output as the base model would have without adaptation.
+        modules_to_save (`list[str]`):
+            list of modules apart from RandLora layers to be set as trainable and saved in the final checkpoint.
+        init_weights (`bool`):
+            Whether to initialize the weights of the RandLora layers with their default initialization. Don't change
+            this setting, except if you know exactly what you're doing.
+        layers_to_transform (`Union[list[int],int]`):
+            The layer indexes to transform, if this argument is specified, it will apply the RandLora transformations
+            on the layer indexes that are specified in this list. If a single integer is passed, it will apply the
+            RandLora transformations on the layer at this index.
+        layers_pattern (`str`):
+            The layer pattern name, used only if `layers_to_transform` is different from `None` and if the layer
+            pattern is not in the common layers pattern.
+    """
+
+    r: int = field(default=32, metadata={"help": "RandLora random basis rank"})
+
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "list of module names or regex expression of the module names to replace with RandLora."
+                "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'. "
+                "Only linear layers are supported."
+            )
+        },
+    )
+    projection_prng_key: int = field(
+        default=0,
+        metadata={
+            "help": (
+                "RandLora PRNG init key. Used for initialising basis_A and basis_B for new models or when loading a "
+                "checkpoint that did not include these projections."
+            )
+        },
+    )
+    save_projection: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "Whether to save the basis_A / basis_B projections in the state dict alongside per layer lambda / "
+                "gamma weights. This will increase the size of the checkpoint, but guarantee that we can reload "
+                "the checkpoint on all system configurations."
+            )
+        },
+    )
+    sparse: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Whether to use sparse random bases as described in the RandLora paper."
+                "The current implementation is a proof of concept where the sparseness"
+                "is not used to improve speed or memory usage."
+            )
+        },
+    )
+    very_sparse: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Whether to use very sparse random bases."
+                "The current implementation is a proof of concept where the sparseness"
+                "is not used to improve speed or memory usage."
+            )
+        },
+    )
+    randlora_dropout: float = field(default=0.0, metadata={"help": "Dropout in the adapter layers"})
+    fan_in_fan_out: bool = field(
+        default=False,
+        metadata={"help": "Set this to True if the layer to replace stores weight like (fan_in, fan_out)"},
+    )
+    randlora_alpha: int = field(
+        default=640,
+        metadata={
+            "help": "Scaling coefficient in the adapter layers, typically 20 times the rank of the random bases."
+        },
+    )
+    bias: str = field(
+        default="none", metadata={"help": "Bias type for RandLora. Can be 'none', 'all' or 'randlora_only'"}
+    )
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "list of modules apart from RandLora layers to be set as trainable and saved in the final checkpoint. For"
+                " example, in Sequence Classification or Token Classification tasks, the final layer"
+                " `classifier/score` are randomly initialized and as such need to be trainable and saved."
+            )
+        },
+    )
+    init_weights: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "Whether to initialize the weights of the RandLora layers with their default initialization. Don't change "
+                "this setting, except if you know exactly what you're doing."
+            ),
+        },
+    )
+    layers_to_transform: Optional[Union[list[int], int]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The layer indexes to transform, is this argument is specified, PEFT will transform only the layers"
+                " indexes that are specified inside this list. If a single integer is passed, PEFT will transform only"
+                " the layer at this index."
+            )
+        },
+    )
+    layers_pattern: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The layer pattern name, used only if `layers_to_transform` is different to None and if the layer"
+                " pattern is not in the common layers pattern."
+            )
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.RANDLORA
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+
+        if not self.save_projection:
+            warnings.warn(
+                "Specified to not save basis_A and basis_B within the state dictionary, instead they will be restored "
+                "using the PRNG key store in `config.projection_prng_key`. Consider setting `config.save_projection` "
+                "to `True` to guarantee restoring the checkpoint correctly on all system configurations."
+            )
diff --git a/src/peft/tuners/randlora/layer.py b/src/peft/tuners/randlora/layer.py
new file mode 100644
index 0000000..0270363
--- /dev/null
+++ b/src/peft/tuners/randlora/layer.py
@@ -0,0 +1,353 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+import warnings
+from typing import Optional
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+from transformers.pytorch_utils import Conv1D
+
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+from peft.utils.other import transpose
+
+from .._buffer_dict import BufferDict
+from .config import RandLoraConfig
+
+
+class UniqueBaseGrad(torch.autograd.Function):
+    # Memory efficient for a unique base
+    @staticmethod
+    def forward(ctx, randlora_A, randlora_lambda, randlora_gamma):
+        out = randlora_lambda[:, :, None] * randlora_A * randlora_gamma[None,]
+        ctx.save_for_backward(randlora_A, randlora_lambda, randlora_gamma)
+        return out
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        randlora_A, randlora_lambda, randlora_gamma = ctx.saved_tensors
+        randlora_A, randlora_lambda, randlora_gamma = (
+            randlora_A.to(grad_output.dtype),
+            randlora_lambda.to(grad_output.dtype),
+            randlora_gamma.to(grad_output.dtype),
+        )
+        grad_randlora_lambda = torch.einsum("kbj,kvj,bj->kb", grad_output, randlora_A, randlora_gamma)
+        grad_randlora_gamma = torch.einsum("kbj,kvj,kb->bj", grad_output, randlora_A, randlora_lambda)
+        return None, grad_randlora_lambda, grad_randlora_gamma
+
+
+class RandLoraLayer(BaseTunerLayer):
+    # List all names of layers that may contain adapter weights
+    adapter_layer_names = ("randlora_lambda", "randlora_gamma")
+    other_param_names = ("randlora_A", "randlora_B", "randlora_dropout", "r", "scaling")
+
+    def __init__(self, base_layer: nn.Module, **kwargs):
+        self.base_layer = base_layer
+        self.r = {}
+        self.scaling = {}
+        self.randlora_dropout = nn.ModuleDict({})
+
+        # For storing vector scale
+        self.randlora_lambda = nn.ParameterDict({})
+        self.randlora_gamma = nn.ParameterDict({})
+
+        # Stores a reference to the randlora_A/B BufferDict.
+        # Set to `None` otherwise to avoid computation with random weights
+        self.randlora_A: Optional[BufferDict] = None
+        self.randlora_B: Optional[BufferDict] = None
+
+        # Mark the weight as unmerged
+        self._disable_adapters = False
+        self.merged_adapters = []
+
+        # flag to enable/disable casting of input to weight dtype during forward call
+        self.cast_input_dtype_enabled = True
+
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            in_features, out_features = base_layer.in_features, base_layer.out_features
+        elif isinstance(base_layer, Conv1D):
+            in_features, out_features = (
+                base_layer.weight.ds_shape if hasattr(base_layer.weight, "ds_shape") else base_layer.weight.shape
+            )
+
+        self.in_features = in_features
+        self.out_features = out_features
+        self.kwargs = kwargs
+
+    @property
+    def merged(self) -> bool:
+        return bool(self.merged_adapters)
+
+    def update_layer(
+        self,
+        adapter_name,
+        randlora_A: BufferDict,
+        randlora_B: BufferDict,
+        r,
+        config: RandLoraConfig,
+        inference_mode: bool = False,
+        **kwargs,
+    ):
+        randlora_alpha = config.randlora_alpha
+        randlora_dropout = config.randlora_dropout
+        init_weights = config.init_weights
+
+        if r <= 0:
+            raise ValueError(f"`r` should be a positive integer value but the value passed is {r}")
+        self.r[adapter_name] = r
+        if randlora_dropout > 0.0:
+            randlora_dropout_layer = nn.Dropout(p=randlora_dropout)
+        else:
+            randlora_dropout_layer = nn.Identity()
+
+        self.randlora_dropout.update(nn.ModuleDict({adapter_name: randlora_dropout_layer}))
+
+        # Actual trainable parameters
+        num_bases = min(self.in_features, self.out_features) / r
+        self.num_bases = int(num_bases) if num_bases.is_integer() else int(num_bases) + 1  # Full rank
+        self.randlora_lambda[adapter_name] = nn.Parameter(torch.randn(r, self.num_bases), requires_grad=True)
+        self.randlora_gamma[adapter_name] = nn.Parameter(
+            torch.ones(self.num_bases, min(self.out_features, self.in_features))
+            / max(self.out_features, self.in_features),
+            requires_grad=True,
+        )
+
+        self.scaling[adapter_name] = randlora_alpha / r
+
+        # non trainable references to randlora_A/B buffers
+        self.randlora_A = randlora_A
+        self.randlora_B = randlora_B
+        if adapter_name not in randlora_A:
+            # This means that this is not the first RandLora adapter. We have to add an entry in the dict for this adapter.
+            if len(self.randlora_A) < 1:
+                raise ValueError(
+                    "The `randlora_A` and `randlora_B` buffers are empty. This should not happen. Please report this issue."
+                )
+            # we can take any of the existing adapter's parameters, as they should all be identical
+            randlora_A_param = next(iter(self.randlora_A.values()))
+            randlora_B_param = next(iter(self.randlora_B.values()))
+
+            error_tmpl = (
+                "{} has a size of {} but {} or greater is required; this probably happened because an additional RandLora "
+                "adapter was added after the first one with incompatible shapes."
+            )
+            max_dim, min_dim = max(self.in_features, self.out_features), min(self.in_features, self.out_features)
+            # check input size
+            if randlora_B_param.shape[0] < max_dim:
+                raise ValueError(error_tmpl.format("randlora_B", randlora_B_param.shape[0], max_dim))
+            # check output size
+            if randlora_A_param.shape[-1] < min_dim:
+                raise ValueError(error_tmpl.format("randlora_A", randlora_A_param.shape[1], min_dim))
+
+            # check r
+            error_tmpl = (
+                "{} has a size of {} but {} or greater is required; this probably happened because an additional RandLora "
+                "adapter with a lower rank was added after the first one; loading the adapters "
+                "in reverse order may solve this."
+            )
+            if randlora_A_param.shape[0] < self.r[adapter_name]:
+                raise ValueError(error_tmpl.format("randlora_A", randlora_A_param.shape[0], self.r[adapter_name]))
+
+            if randlora_B_param.shape[-1] < self.r[adapter_name]:
+                raise ValueError(error_tmpl.format("randlora_B", randlora_B_param.shape[-1], self.r[adapter_name]))
+
+            self.randlora_A[adapter_name] = randlora_A_param
+            self.randlora_B[adapter_name] = randlora_B_param
+
+        if init_weights:
+            self.reset_randlora_parameters(adapter_name)
+
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def reset_randlora_parameters(self, adapter_name):
+        if adapter_name in self.randlora_lambda.keys():
+            with torch.no_grad():
+                nn.init.zeros_(self.randlora_lambda[adapter_name])
+                nn.init.constant_(self.randlora_gamma[adapter_name], 1 / max(self.randlora_gamma[adapter_name].shape))
+
+
+class Linear(nn.Linear, RandLoraLayer):
+    # RandLora implemented in a dense layer
+    def __init__(
+        self,
+        base_layer,
+        randlora_A: BufferDict,
+        randlora_B: BufferDict,
+        adapter_name: str,
+        config: RandLoraConfig,
+        r: int = 0,
+        is_target_conv_1d_layer: bool = False,
+        **kwargs,
+    ) -> None:
+        # this gets the init from nn.Linear's super perspective, i.e. nn.Module.__init__, which should always be called
+        super(nn.Linear, self).__init__()
+        RandLoraLayer.__init__(self, base_layer, **kwargs)
+        self.fan_in_fan_out = config.fan_in_fan_out
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, randlora_A, randlora_B, r, config=config)
+        self.is_target_conv_1d_layer = is_target_conv_1d_layer
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`list[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.randlora_lambda.keys():
+                base_layer = self.get_base_layer()
+                orig_dtype = base_layer.weight.dtype
+
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    # because of the copy operation.
+                    orig_weights = base_layer.weight.data.clone()
+
+                    orig_weights += self.get_delta_weight(active_adapter)
+
+                    if not torch.isfinite(orig_weights).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = orig_weights.to(orig_dtype)
+                else:
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    base_layer.weight.data += delta_weight.to(orig_dtype)
+
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+
+        while len(self.merged_adapters) > 0:
+            base_layer = self.get_base_layer()
+            orig_dtype = base_layer.weight.dtype
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.randlora_lambda.keys():
+                delta_weight = self.get_delta_weight(active_adapter)
+                base_layer.weight.data -= delta_weight.to(orig_dtype)
+
+    def get_scaled_bases(self, adapter, device=None) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Performs scaling on the smallest random base (randlora_A) and returns randlora_A and randlora_B in the correct
+        order to fit the target layers' dimensions
+
+        Args:
+            adapter (str):
+                The name of the adapter for which the delta weight should be computed.
+        """
+
+        randlora_A = self.randlora_A[adapter]
+        randlora_B = self.randlora_B[adapter]
+        if device is None:
+            device = randlora_B.device
+        dtype = randlora_B.dtype
+
+        # In case users wants to merge the adapter weights that are in
+        # (b)float16 while being on CPU, we need to cast the weights to float32, perform the merge and then cast back to
+        # (b)float16 because some CPUs have slow bf16/fp16 matmuls.
+        cast_to_fp32 = device.type == "cpu" and (dtype == torch.float16 or dtype == torch.bfloat16)
+
+        randlora_lambda = self.randlora_lambda[adapter].to(device)
+        randlora_gamma = self.randlora_gamma[adapter].to(device)
+
+        if cast_to_fp32:
+            randlora_A = randlora_A.float()
+            randlora_B = randlora_B.float()
+            randlora_lambda = randlora_lambda.float()
+            randlora_gamma = randlora_gamma.float()
+
+        # The trainable parameters are always applied to randlora_A, the smallest basis.
+        min_dim, max_dim = min(self.out_features, self.in_features), max(self.out_features, self.in_features)
+
+        # As adapted layers may have different shapes and RandLora contains a single shared pair of A and B matrices,
+        # we initialize these matrices with the largest required size for each dimension.
+        # During the forward pass, required submatrices are sliced out from the shared randlora_A and randlora_B.
+        sliced_A = randlora_A[:, : self.num_bases, :min_dim].to(device)
+        sliced_B = randlora_B[:max_dim, : self.num_bases, :].to(device)
+
+        # Flattening the matrices over the rank and number of bases dimensions is more memory efficient
+        update_B = sliced_B.flatten(start_dim=1)
+        update_A = UniqueBaseGrad.apply(sliced_A, randlora_lambda, randlora_gamma).flatten(end_dim=1)
+
+        # Since update_A is applied on the smallest dimension, test whether update_A or update_B should be applied first. This is done to reduce trainable parameters.
+        if min_dim == self.in_features:
+            return update_A, update_B
+        return update_B.T, update_A.T
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        """
+        Compute the delta weight for the given adapter.
+
+        Args:
+            adapter (str):
+                The name of the adapter for which the delta weight should be computed.
+        """
+
+        update_B, update_A = self.get_scaled_bases(adapter)
+
+        update = (update_B.T @ update_A.T).T
+        output_tensor = transpose(update, self.fan_in_fan_out)
+
+        scaling = self.scaling[adapter]
+        return output_tensor * scaling
+
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        previous_dtype = x.dtype
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.randlora_lambda.keys():
+                    continue
+                dropout = self.randlora_dropout[active_adapter]
+                update_B, update_A = self.get_scaled_bases(active_adapter, device=x.device)
+                x = x.to(update_A.dtype)
+                scaling = self.scaling[active_adapter]
+                result = result + F.linear(F.linear(dropout(x), update_B), update_A) * scaling
+        result = result.to(previous_dtype)
+        return result
+
+    def supports_lora_conversion(self, adapter_name: str = "default") -> bool:
+        return True
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "randlora." + rep
diff --git a/src/peft/tuners/randlora/model.py b/src/peft/tuners/randlora/model.py
new file mode 100644
index 0000000..6d1140d
--- /dev/null
+++ b/src/peft/tuners/randlora/model.py
@@ -0,0 +1,366 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+import math
+import warnings
+from typing import Union
+
+import torch
+from accelerate.utils.imports import is_bf16_available
+from torch import nn
+from transformers.pytorch_utils import Conv1D
+
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer
+from peft.utils import (
+    TRANSFORMERS_MODELS_TO_RANDLORA_TARGET_MODULES_MAPPING,
+)
+
+from .._buffer_dict import BufferDict
+from ..tuners_utils import _maybe_include_all_linear_layers
+from .config import RandLoraConfig
+from .layer import Linear, RandLoraLayer
+
+
+def _kaiming_init(
+    tensor_or_shape: Union[torch.Tensor, tuple[int, ...]],
+    generator: torch.Generator,
+) -> torch.Tensor:
+    """
+    Kaiming Uniform Initialisation adapted to accept a `torch.Generator` object for PRNG.
+
+    Args:
+        tensor_or_shape (`Union[torch.Tensor, tuple[int, ...]]`):
+            Tensor to initialise, or shape of new tensor to create and then initialise.
+        generator: (`torch.Generator`):
+            Generator object that manages the state of the PRNG algorithm in use.
+
+    Returns:
+        `torch.Tensor`: The initialised tensor.
+    """
+    if isinstance(tensor_or_shape, tuple):
+        tensor = torch.empty(
+            tensor_or_shape,
+            dtype=torch.bfloat16 if is_bf16_available() else torch.float16,
+        )
+    else:
+        tensor = tensor_or_shape
+
+    with torch.no_grad():
+        basis = torch.nn.init.kaiming_uniform_(tensor, a=math.sqrt(5), generator=generator)
+        return basis
+
+
+class RandLoraModel(BaseTuner):
+    """
+    Creates a RandLoRA model from a pretrained transformers model.
+
+    Args:
+        model ([`~transformers.PreTrainedModel`]): The model to be adapted.
+        config ([`RandLoraConfig`]): The configuration of the RandLora model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            Create empty adapter weights on meta device. Useful to speed up the loading process.
+
+    Returns:
+        `torch.nn.Module`: The RandLora model.
+
+    Example:
+
+        ```py
+        >>> from transformers import AutoModelForCausalLM
+        >>> from peft import RandLoraConfig, get_peft_model
+
+        >>> base_model = AutoModelForCausalLM.from_pretrained("facebook/opt-125m")
+        >>> config = RandLoraConfig(r=32)
+        >>> model = get_peft_model(base_model, config)
+        ```
+
+    **Attributes**:
+        - **model** ([`~transformers.PreTrainedModel`]) -- The model to be adapted.
+        - **peft_config** ([`RandLoraConfig`]): The configuration of the RandLora model.
+    """
+
+    prefix: str = "randlora_"
+    tuner_layer_cls = RandLoraLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_RANDLORA_TARGET_MODULES_MAPPING
+
+    def _find_dim(self, config) -> tuple[int, int]:
+        """
+        Finds the largest input and output dimensions across linear layers that have been wrapped with RandLora.
+
+        This will be used for determining the size of the shared randlora_A and randlora_B matrices.
+        """
+        model_config = self.get_model_config(self.model)
+
+        peft_config = self._prepare_adapter_config(config, model_config)
+        peft_config = _maybe_include_all_linear_layers(peft_config, self.model)
+
+        largest_shape = None
+        for key, module in self.model.named_modules():
+            if not self._check_target_module_exists(peft_config, key):
+                continue
+
+            if isinstance(module, nn.Linear):
+                module_shape = module.out_features, module.in_features
+            elif isinstance(module, Conv1D):
+                module_shape = module.weight.ds_shape if hasattr(module.weight, "ds_shape") else module.weight.shape
+                module_shape = module_shape[::-1]
+            else:
+                continue
+
+            if largest_shape is None:
+                largest_shape = module_shape
+                continue
+
+            if module_shape != largest_shape:
+                largest_shape = tuple(max(a, b) for a, b in zip(largest_shape, module_shape))
+
+        if largest_shape is None:
+            msg = "No layers types compatible with RandLora were found. Please check `peft_config.target_modules`."
+            raise ValueError(msg)
+
+        return largest_shape
+
+    def _init_randlora_A_randlora_B_sparse(self, config: RandLoraConfig, adapter_name: str, sparsity: int = 3) -> None:
+        """
+        Sparse random projections as described in https://cs-people.bu.edu/evimaria/cs565/kdd-rp.pdf
+        """
+
+        linear_out_dim, linear_in_dim = self._find_dim(config)
+        max_dim, min_dim = max(linear_out_dim, linear_in_dim), min(linear_out_dim, linear_in_dim)
+
+        # use of persistent to exclude randlora_A and randlora_B from the state dict if we choose not to save them.
+        self.randlora_A = BufferDict({}, persistent=config.save_projection)
+        self.randlora_B = BufferDict({}, persistent=config.save_projection)
+
+        # deterministic init of randlora_A and randlora_B if we know the key
+        generator = torch.Generator(device="cpu").manual_seed(config.projection_prng_key)
+
+        # The gamma matrix is applied on A meaning it can be unique (shared) across the n scaling matrices.
+        # We also set randlora_A as the smallest matrix to reduce trainable parameters.
+        randlora_A = torch.rand((config.r, 1, min_dim), generator=generator)
+
+        # Number of bases to ensure full rank
+        num_bases = min_dim / config.r
+        num_bases = int(num_bases) if num_bases.is_integer() else int(num_bases) + 1  # Ensure full rank
+        randlora_B = torch.rand((max_dim, num_bases, config.r), generator=generator)
+
+        # The current implementation is a proof of concept and does take into consideration
+        # the sparsity to reduce memory usage or speed up compute
+        randlora_B_sparse = torch.zeros(randlora_B.shape)
+        randlora_A_sparse = torch.zeros(randlora_A.shape)
+        randlora_B_sparse[randlora_B < 1 / (2 * sparsity)] = -1
+        randlora_B_sparse[randlora_B > 1 - 1 / (2 * sparsity)] = 1
+        randlora_A_sparse[randlora_A < 1 / (2 * sparsity)] = -1
+        randlora_A_sparse[randlora_A > 1 - 1 / (2 * sparsity)] = 1
+
+        # Std normalization is empirically found to be the best
+        randlora_A, randlora_B = (
+            randlora_A_sparse / randlora_A_sparse.std(),
+            randlora_B_sparse / randlora_B_sparse.std(),
+        )
+        self.randlora_A[adapter_name] = randlora_A
+        self.randlora_B[adapter_name] = randlora_B
+
+    def _init_randlora_A_randlora_B(self, config: RandLoraConfig, adapter_name: str) -> None:
+        linear_out_dim, linear_in_dim = self._find_dim(config)
+        max_dim, min_dim = max(linear_out_dim, linear_in_dim), min(linear_out_dim, linear_in_dim)
+
+        # use of persistent to exclude randlora_A and randlora_B from the state dict if we choose not to save them.
+        self.randlora_A = BufferDict({}, persistent=config.save_projection)
+        self.randlora_B = BufferDict({}, persistent=config.save_projection)
+
+        # deterministic init of randlora_A and randlora_B if we know the key
+        generator = torch.Generator(device="cpu").manual_seed(config.projection_prng_key)
+
+        # The gamma matrix is applied on A meaning it can be unique (shared) across the n scaling matrices.
+        # We also set randlora_A as the smallest matrix to reduce trainable parameters.
+        randlora_A = _kaiming_init((config.r, 1, min_dim), generator=generator)
+
+        # Ensure full rank
+        num_bases = min(linear_out_dim, linear_in_dim) / config.r
+        num_bases = int(num_bases) if num_bases.is_integer() else int(num_bases) + 1
+        randlora_B = torch.cat(
+            [_kaiming_init((max_dim, 1, config.r), generator=generator) for _ in range(num_bases)], dim=1
+        )
+
+        # Std normalization is empirically found to be the best
+        randlora_A, randlora_B = randlora_A / randlora_A.std(), randlora_B / randlora_B.std()
+        self.randlora_A[adapter_name] = randlora_A
+        self.randlora_B[adapter_name] = randlora_B
+
+    def _pre_injection_hook(self, model: nn.Module, config: RandLoraConfig, adapter_name: str) -> None:
+        if config.very_sparse:
+            linear_out_dim, linear_in_dim = self._find_dim(config)
+            self._init_randlora_A_randlora_B_sparse(
+                config, adapter_name, sparsity=math.sqrt(min(linear_out_dim, linear_in_dim))
+            )
+        elif config.sparse:
+            self._init_randlora_A_randlora_B_sparse(config, adapter_name, sparsity=3)
+        else:
+            self._init_randlora_A_randlora_B(config, adapter_name)
+
+    def _check_new_adapter_config(self, config: RandLoraConfig) -> None:
+        """
+        A helper method to check the config when a new adapter is being added.
+
+        Raise a ValueError if there is something wrong with the config or if it conflicts with existing adapters.
+
+        """
+        super()._check_new_adapter_config(config)
+
+        for existing_config in self.peft_config.values():
+            if existing_config is config:
+                # skip the current config
+                continue
+
+            if existing_config.projection_prng_key != config.projection_prng_key:
+                raise ValueError(
+                    f"RandLora PRNG initialisation key must be the same for all adapters. Got {config.projection_prng_key=} but "
+                    f"previous config had {existing_config.projection_prng_key}."
+                )
+
+        save_project_unique_values = sorted({config.save_projection for config in self.peft_config.values()})
+        if len(save_project_unique_values) > 1:
+            raise ValueError(
+                "RandLora projection weights must be saved for all adapters or none, but got multiple different values: "
+                f"{save_project_unique_values}"
+            )
+
+    def _create_and_replace(
+        self,
+        randlora_config,
+        adapter_name,
+        target,
+        target_name,
+        parent,
+        current_key,
+        **optional_kwargs,
+    ):
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+
+        r = randlora_config.r
+        bias = hasattr(target, "bias") and target.bias is not None
+        kwargs = {
+            "r": r,
+            "fan_in_fan_out": randlora_config.fan_in_fan_out,
+            "loaded_in_8bit": getattr(self.model, "is_loaded_in_8bit", False),
+            "loaded_in_4bit": getattr(self.model, "is_loaded_in_4bit", False),
+        }
+        kwargs["bias"] = bias
+        if isinstance(target, Linear):
+            target.update_layer(
+                adapter_name,
+                self.randlora_A,
+                self.randlora_B,
+                r,
+                config=randlora_config,
+            )
+        else:
+            new_module = self._create_new_module(
+                randlora_config, self.randlora_A, self.randlora_B, adapter_name, target, **kwargs
+            )
+            if adapter_name not in self.active_adapter:
+                # adding an additional adapter: it is not automatically trainable
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+    @staticmethod
+    def _create_new_module(randlora_config, randlora_A, randlora_B, adapter_name, target, **kwargs):
+        # avoid eager bnb import
+        if is_bnb_available():
+            import bitsandbytes as bnb
+
+            from .bnb import Linear8bitLt
+
+        if is_bnb_4bit_available():
+            from .bnb import Linear4bit
+
+        bias = kwargs.pop("bias", False)
+        loaded_in_8bit = kwargs.get("loaded_in_8bit", False)
+        loaded_in_4bit = kwargs.get("loaded_in_4bit", False)
+
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        if loaded_in_8bit and isinstance(target_base_layer, bnb.nn.Linear8bitLt):
+            eightbit_kwargs = kwargs.copy()
+            eightbit_kwargs.update(
+                {
+                    "has_fp16_weights": target_base_layer.state.has_fp16_weights,
+                    "threshold": target_base_layer.state.threshold,
+                    "index": target_base_layer.index,
+                }
+            )
+            return Linear8bitLt(
+                target,
+                adapter_name,
+                config=randlora_config,
+                randlora_A=randlora_A,
+                randlora_B=randlora_B,
+                **eightbit_kwargs,
+            )
+        elif loaded_in_4bit and isinstance(target_base_layer, bnb.nn.Linear4bit):
+            fourbit_kwargs = kwargs.copy()
+            fourbit_kwargs.update(
+                {
+                    "compute_dtype": target_base_layer.compute_dtype,
+                    "compress_statistics": target_base_layer.weight.compress_statistics,
+                    "quant_type": target_base_layer.weight.quant_type,
+                }
+            )
+            return Linear4bit(
+                target,
+                adapter_name,
+                config=randlora_config,
+                randlora_A=randlora_A,
+                randlora_B=randlora_B,
+                **fourbit_kwargs,
+            )
+        elif isinstance(target_base_layer, torch.nn.Linear):
+            if randlora_config.fan_in_fan_out:
+                warnings.warn(
+                    "fan_in_fan_out is set to True but the target module is `torch.nn.Linear`. "
+                    "Setting fan_in_fan_out to False."
+                )
+                randlora_config.fan_in_fan_out = False
+        elif isinstance(target_base_layer, Conv1D):
+            kwargs["is_target_conv_1d_layer"] = True
+            if not randlora_config.fan_in_fan_out:
+                warnings.warn(
+                    "fan_in_fan_out is set to False but the target module is `Conv1D`. Setting fan_in_fan_out to True."
+                )
+                randlora_config.fan_in_fan_out = True
+        else:
+            raise ValueError(
+                f"Target module {target} is not supported. Currently, only the following modules are supported: "
+                "`torch.nn.Linear`, `transformers.pytorch_utils.Conv1D`."
+            )
+        new_module = Linear(
+            target,
+            randlora_A,
+            randlora_B,
+            adapter_name,
+            config=randlora_config,
+            bias=bias,
+            **kwargs,
+        )
+
+        return new_module
diff --git a/src/peft/tuners/road/__init__.py b/src/peft/tuners/road/__init__.py
new file mode 100644
index 0000000..97b2f0f
--- /dev/null
+++ b/src/peft/tuners/road/__init__.py
@@ -0,0 +1,47 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+
+# Based on implementation made available in https://github.com/ppetrushkov/peft/tree/road (not from paper authors)
+
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+from peft.utils import register_peft_method
+
+from .config import RoadConfig
+from .layer import Linear, RoadLayer
+from .model import RoadModel
+
+
+__all__ = [
+    "Linear",
+    "RoadConfig",
+    "RoadLayer",
+    "RoadModel",
+]
+
+register_peft_method(name="road", config_cls=RoadConfig, model_cls=RoadModel, is_mixed_compatible=True)
+
+
+def __getattr__(name):
+    if (name == "Linear8bitLt") and is_bnb_available():
+        from .bnb import Linear8bitLt
+
+        return Linear8bitLt
+
+    if (name == "Linear4bit") and is_bnb_4bit_available():
+        from .bnb import Linear4bit
+
+        return Linear4bit
+
+    raise AttributeError(f"module {__name__} has no attribute {name}")
diff --git a/src/peft/tuners/road/bnb.py b/src/peft/tuners/road/bnb.py
new file mode 100644
index 0000000..4de2e38
--- /dev/null
+++ b/src/peft/tuners/road/bnb.py
@@ -0,0 +1,405 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import warnings
+from typing import Any, Optional
+
+import bitsandbytes as bnb
+import torch
+
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+from peft.utils.integrations import dequantize_bnb_weight
+
+from .config import RoadConfig, RoadVariant
+from .layer import RoadLayer, _apply_road, _get_delta_weight
+
+
+if is_bnb_available():
+
+    class Linear8bitLt(torch.nn.Module, RoadLayer):
+        # Road implemented in a dense layer
+        def __init__(
+            self,
+            base_layer: torch.nn.Module,
+            adapter_name: str,
+            config: RoadConfig,
+            variant: RoadVariant = "road_1",
+            group_size: int = 64,
+            init_weights: bool = True,
+            **kwargs,
+        ) -> None:
+            super().__init__()
+            RoadLayer.__init__(self, base_layer)
+
+            self._active_adapter = adapter_name
+            self.update_layer(
+                adapter_name,
+                config=config,
+            )
+
+        def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+            """
+            Merge the active adapter weights into the base weights
+
+            Args:
+                safe_merge (`bool`, *optional*):
+                    If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                    before merging the weights. This is useful if you want to check if the merge operation will produce
+                    NaNs. Defaults to `False`.
+                adapter_names (`list[str]`, *optional*):
+                    The list of adapter names that should be merged. If None, all active adapters will be merged.
+                    Defaults to `None`.
+            """
+            adapter_names = check_adapters_to_merge(self, adapter_names)
+            if not adapter_names:
+                # no adapter to merge
+                return
+
+            for active_adapter in adapter_names:
+                if active_adapter in self._available_adapters:
+                    warnings.warn(
+                        "Merge road module to 8-bit linear may get different generations due to rounding errors."
+                    )
+
+                    weight = self.get_base_layer().weight
+                    state = self.get_base_layer().state
+                    if state.SCB is None:
+                        state.SCB = weight.SCB
+
+                    # Dequantize the result of identity matrix and int8 weight because bitsandbytes does not support int8
+                    # dequantization directly
+                    output = dequantize_bnb_weight(weight, state=state)
+                    road_R = _get_delta_weight(
+                        self.variant[active_adapter],
+                        self.group_size[active_adapter],
+                        self.road_theta[active_adapter].data,
+                        self.road_alpha[active_adapter].data,
+                    )
+
+                    w_data = torch.matmul(road_R, output.to(road_R.dtype))
+                    w_data = w_data.to(road_R.dtype).to(road_R.device).contiguous()
+
+                    if safe_merge and not torch.isfinite(w_data).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    self.get_base_layer().weight = bnb.nn.Int8Params(
+                        w_data.to("cpu"), requires_grad=False, has_fp16_weights=weight.has_fp16_weights
+                    ).to(weight.device)
+
+                    if self.get_base_layer().bias is not None:
+                        bias = self.get_base_layer().bias
+                        orig_dtype = bias.dtype
+                        bias_data = bias.data
+                        new_bias = torch.matmul(road_R, bias_data.to(road_R.dtype))
+                        bias.data = new_bias.to(orig_dtype)
+
+                    state.reset_grads()
+                    self.merged_adapters.append(active_adapter)
+
+        def unmerge(self) -> None:
+            """
+            This method unmerges all merged adapter layers from the base weights.
+            """
+            if not self.merged:
+                warnings.warn("Already unmerged. Nothing to do.")
+                return
+
+            while len(self.merged_adapters) > 0:
+                active_adapter = self.merged_adapters.pop()
+                if active_adapter in self._available_adapters:
+                    warnings.warn(
+                        "Unmerge road module to 8-bit linear may get different generations due to rounding errors."
+                    )
+
+                    weight = self.get_base_layer().weight
+                    state = self.get_base_layer().state
+                    if state.SCB is None:
+                        state.SCB = weight.SCB
+                    output = dequantize_bnb_weight(weight, state=state)
+
+                    road_R = _get_delta_weight(
+                        self.variant[active_adapter],
+                        self.group_size[active_adapter],
+                        self.road_theta[active_adapter].data,
+                        self.road_alpha[active_adapter].data,
+                    )
+                    inv_road_R = torch.linalg.inv(road_R.to(torch.float32)).to(road_R.dtype)
+
+                    w_data = torch.matmul(inv_road_R, output.to(road_R.dtype))
+                    w_data = w_data.to(road_R.dtype).to(road_R.device).contiguous()
+
+                    self.get_base_layer().weight = bnb.nn.Int8Params(
+                        w_data.to("cpu"), requires_grad=False, has_fp16_weights=weight.has_fp16_weights
+                    ).to(weight.device)
+
+                    if self.get_base_layer().bias is not None:
+                        bias = self.get_base_layer().bias
+                        orig_dtype = bias.dtype
+                        bias_data = bias.data
+                        new_bias = torch.matmul(inv_road_R, bias_data)
+                        bias.data = new_bias.to(orig_dtype)
+
+                    state.reset_grads()
+
+        def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+            if self.disable_adapters:
+                if self.merged:
+                    self.unmerge()
+                result = self.base_layer(x, *args, **kwargs)
+            elif self.merged:
+                result = self.base_layer(x, *args, **kwargs)
+            else:
+                result = self.base_layer(x, *args, **kwargs)
+
+                for active_adapter in self.active_adapters:
+                    if active_adapter not in self._available_adapters:
+                        continue
+
+                    requires_conversion = not torch.is_autocast_enabled()
+                    if requires_conversion:
+                        expected_dtype = result.dtype
+                        result = self._cast_input_dtype(result, self.road_theta[active_adapter].dtype)
+
+                    result = _apply_road(
+                        self.variant[active_adapter],
+                        self.group_size[active_adapter],
+                        self.road_theta[active_adapter],
+                        self.road_alpha[active_adapter],
+                        result,
+                    )
+
+                    if requires_conversion:
+                        x = x.to(expected_dtype)
+
+            return result
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return "road." + rep
+
+    def dispatch_bnb_8bit(target: torch.nn.Module, adapter_name: str, road_config: RoadConfig, **kwargs):
+        new_module = None
+
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        loaded_in_8bit = kwargs.get("loaded_in_8bit", False)
+        if loaded_in_8bit and isinstance(target_base_layer, bnb.nn.Linear8bitLt):
+            eightbit_kwargs = kwargs.copy()
+            eightbit_kwargs.update(
+                {
+                    "has_fp16_weights": target.state.has_fp16_weights,
+                    "threshold": target.state.threshold,
+                    "index": target.index,
+                }
+            )
+            new_module = Linear8bitLt(target, adapter_name, config=road_config, **eightbit_kwargs)
+
+        return new_module
+
+
+if is_bnb_4bit_available():
+
+    class Linear4bit(torch.nn.Module, RoadLayer):
+        # OFT implemented in a dense layer
+        def __init__(
+            self,
+            base_layer: torch.nn.Module,
+            adapter_name: str,
+            config: RoadConfig,
+            variant: RoadVariant = "road_1",
+            group_size: int = 64,
+            init_weights: bool = True,
+            **kwargs,
+        ) -> None:
+            super().__init__()
+            RoadLayer.__init__(self, base_layer)
+
+            self._active_adapter = adapter_name
+            self.update_layer(
+                adapter_name,
+                config=config,
+            )
+
+        def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+            """
+            Merge the active adapter weights into the base weights
+
+            Args:
+                safe_merge (`bool`, *optional*):
+                    If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                    before merging the weights. This is useful if you want to check if the merge operation will produce
+                    NaNs. Defaults to `False`.
+                adapter_names (`list[str]`, *optional*):
+                    The list of adapter names that should be merged. If None, all active adapters will be merged.
+                    Defaults to `None`.
+            """
+            adapter_names = check_adapters_to_merge(self, adapter_names)
+            if not adapter_names:
+                # no adapter to merge
+                return
+
+            for active_adapter in adapter_names:
+                if active_adapter in self._available_adapters:
+                    warnings.warn(
+                        "Merge oft module to 4-bit linear may get different generations due to rounding errors."
+                    )
+                    # Refer to https://gist.github.com/ChrisHayduk/1a53463331f52dca205e55982baf9930
+                    weight = self.get_base_layer().weight
+                    kwargs = weight.__dict__
+
+                    output = dequantize_bnb_weight(weight, state=weight.quant_state)
+
+                    road_R = _get_delta_weight(
+                        self.variant[active_adapter],
+                        self.group_size[active_adapter],
+                        self.road_theta[active_adapter].data,
+                        self.road_alpha[active_adapter].data,
+                    )
+                    w_data = torch.matmul(road_R, output.to(road_R.dtype))
+                    w_data = w_data.to(road_R.dtype).to(road_R.device)
+
+                    if safe_merge and not torch.isfinite(w_data).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    if "bnb_quantized" in kwargs:
+                        kwargs["bnb_quantized"] = False
+                    kwargs["requires_grad"] = False
+                    kwargs.pop("data", None)
+                    # torch.compile can introduce attributes preceded by '_', remove them
+                    kwargs = {k: v for k, v in kwargs.items() if not k.startswith("_")}
+                    self.get_base_layer().weight = bnb.nn.Params4bit(w_data.to("cpu"), **kwargs).to(weight.device)
+
+                    if self.get_base_layer().bias is not None:
+                        bias = self.get_base_layer().bias
+                        orig_dtype = bias.dtype
+                        bias_data = bias.data
+                        new_bias = torch.matmul(road_R, bias_data.to(road_R.dtype))
+                        bias.data = new_bias.to(orig_dtype)
+
+                    self.merged_adapters.append(active_adapter)
+
+        def unmerge(self) -> None:
+            """
+            This method unmerges all merged adapter layers from the base weights.
+            """
+            if not self.merged:
+                warnings.warn("Already unmerged. Nothing to do.")
+                return
+
+            while len(self.merged_adapters) > 0:
+                active_adapter = self.merged_adapters.pop()
+                if active_adapter in self._available_adapters:
+                    warnings.warn(
+                        "Unmerge oft module to 4-bit linear may get different generations due to rounding errors."
+                    )
+
+                    weight = self.get_base_layer().weight
+                    kwargs = weight.__dict__
+                    output = dequantize_bnb_weight(weight, state=weight.quant_state)
+
+                    road_R = _get_delta_weight(
+                        self.variant[active_adapter],
+                        self.group_size[active_adapter],
+                        self.road_theta[active_adapter].data,
+                        self.road_alpha[active_adapter].data,
+                    )
+                    inv_road_R = torch.linalg.inv(road_R.to(torch.float32)).to(road_R.dtype)
+
+                    w_data = torch.matmul(inv_road_R, output.to(road_R.dtype))
+                    w_data = w_data.to(road_R.dtype).to(road_R.device)
+
+                    if "bnb_quantized" in kwargs:
+                        kwargs["bnb_quantized"] = False
+                    kwargs["requires_grad"] = False
+                    kwargs.pop("data", None)
+                    self.get_base_layer().weight = bnb.nn.Params4bit(w_data.to("cpu"), **kwargs).to(weight.device)
+
+                    if self.get_base_layer().bias is not None:
+                        bias = self.get_base_layer().bias
+                        orig_dtype = bias.dtype
+                        bias_data = bias.data
+                        new_bias = torch.matmul(inv_road_R, bias_data)
+                        bias.data = new_bias.to(orig_dtype)
+
+        def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+            if self.disable_adapters:
+                if self.merged:
+                    self.unmerge()
+                result = self.base_layer(x, *args, **kwargs)
+            elif self.merged:
+                result = self.base_layer(x, *args, **kwargs)
+            else:
+                result = self.base_layer(x, *args, **kwargs)
+                # As per Tim Dettmers, for 4bit, we need to defensively clone here.
+                # The reason is that in some cases, an error can occur that backprop
+                # does not work on a manipulated view. This issue may be solved with
+                # newer PyTorch versions but this would need extensive testing to be
+                # sure.
+                # result = result.clone()
+
+                for active_adapter in self.active_adapters:
+                    if active_adapter not in self._available_adapters:
+                        continue
+
+                    requires_conversion = not torch.is_autocast_enabled()
+                    if requires_conversion:
+                        expected_dtype = result.dtype
+                        result = self._cast_input_dtype(result, self.road_theta[active_adapter].dtype)
+
+                    result = _apply_road(
+                        self.variant[active_adapter],
+                        self.group_size[active_adapter],
+                        self.road_theta[active_adapter],
+                        self.road_alpha[active_adapter],
+                        result,
+                    )
+                    if requires_conversion:
+                        x = x.to(expected_dtype)
+
+            return result
+
+        def __repr__(self) -> str:
+            rep = super().__repr__()
+            return "oft." + rep
+
+    def dispatch_bnb_4bit(target: torch.nn.Module, adapter_name: str, road_config: RoadConfig, **kwargs):
+        new_module = None
+
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        loaded_in_4bit = kwargs.get("loaded_in_4bit", False)
+        if loaded_in_4bit and is_bnb_4bit_available() and isinstance(target_base_layer, bnb.nn.Linear4bit):
+            fourbit_kwargs = kwargs.copy()
+            fourbit_kwargs.update(
+                {
+                    "compute_dtype": target_base_layer.compute_dtype,
+                    "compress_statistics": target_base_layer.weight.compress_statistics,
+                    "quant_type": target_base_layer.weight.quant_type,
+                }
+            )
+            new_module = Linear4bit(target, adapter_name, config=road_config, **fourbit_kwargs)
+
+        return new_module
diff --git a/src/peft/tuners/road/config.py b/src/peft/tuners/road/config.py
new file mode 100644
index 0000000..5839a9a
--- /dev/null
+++ b/src/peft/tuners/road/config.py
@@ -0,0 +1,126 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal, Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+RoadVariant = Literal["road_1", "road_2", "road_4"]
+
+
+@dataclass
+class RoadConfig(PeftConfig):
+    """
+    This is the configuration class to store the configuration of a [`RoadModel`]. RoAd adapter is proposed in
+    https://huggingface.co/papers/2409.00119.
+
+    Args:
+        variant (Union[`RoadVariant`, `str`]):
+            The variant of the Road model to use. It can be one of road_1, road_2, or road_4. Refer to the paper for
+            more details.
+            - road_1: Uses the same scale and angle for all pairs of elements.
+            This variant has lowest number of parameters, it stores a number equal to the output hidden size of
+            parameters for each layer that RoAd is applied to.
+            - road_2: Uses the same scale and angle for each element.
+            This variant has 2x the number of parameters compared to road_1.
+            - road_4: Uses two different scales and angles for each element.
+            This variant has 4x the number of parameters compared to road_1.
+        group_size (`int`):
+            Group size defines how elements are grouped together into 2D vectors for rotation. Within each group
+            element 0 is paired with element group_size/2, then element 1 is paired with element group_size/2+1 and so
+            on. This has no effect on the model performance, since elements are unordered, however it has some effect
+            on inference speed when used in e.g. VLLM. For best speed group size of at least 32 or 64 (the default) is
+            recommended. Note that model hidden size (or hidden size per partition when used with tensor parallelism)
+            must be divisible by group_size, so for very small models you might need to reduce this parameter.
+        init_weights (`bool`):
+            Whether to perform initialization of RoAd weights.
+        target_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to apply the adapter to. If this is specified, only the modules with the specified
+            names will be replaced. When passing a string, a regex match will be performed. When passing a list of
+            strings, either an exact match will be performed or it is checked if the name of the module ends with any
+            of the passed strings. If this is specified as 'all-linear', then all linear/Conv1D modules are chosen (if
+            the model is a PreTrainedModel, the output layer excluded). If this is not specified, modules will be
+            chosen according to the model architecture. If the architecture is not known, an error will be raised -- in
+            this case, you should specify the target modules manually.
+        modules_to_save (`List[str]`):
+            List of modules apart from Road layers to be set as trainable and saved in the final checkpoint.
+    """
+
+    variant: Union[str, RoadVariant] = field(
+        default="road_1",
+        metadata={"help": ("Variant of the Road model to use.")},
+    )
+    group_size: int = field(
+        default=64,
+        metadata={
+            "help": (
+                "Group size defines how elements are grouped together into 2D vectors for rotation. "
+                "Within each group element 0 is paired with element group_size/2, "
+                "then element 1 is paired with element group_size/2+1 and so on. "
+                "This has no effect on the model performance, since elements are unordered, "
+                "however it has some effect on inference speed when used in e.g. VLLM. "
+                "For best speed group size of at least 64 is recommended. "
+                "Note that model hidden size (or hidden size per partition when used with tensor parallelism) "
+                "must be divisible by group_size, so for very small models you might need to reduce this parameter."
+            )
+        },
+    )
+    init_weights: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "Whether to initialize the weights of the RoAd layers with their default initialization. Don't change "
+                "this setting, except if you know exactly what you're doing."
+            ),
+        },
+    )
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of module names or regex expression of the module names to replace with Road."
+                "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'."
+                "This can also be a wildcard 'all-linear' which matches all linear/Conv1D "
+                "(if the model is a PreTrainedModel, the output layer excluded)."
+                "If not specified, modules will be chosen according to the model architecture, If the architecture is "
+                "not known, an error will be raised -- in this case, you should specify the target modules manually."
+            ),
+        },
+    )
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of modules apart from RoAd layers to be set as trainable and saved in the final checkpoint. For"
+                " example, in Sequence Classification or Token Classification tasks, the final layer"
+                " `classifier/score` are randomly initialized and as such need to be trainable and saved."
+            )
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.ROAD
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        if self.variant not in ["road_1", "road_2", "road_4"]:
+            raise ValueError(f"Invalid variant {self.variant} specified. Please choose from road_1, road_2 or road_4")
+        if self.group_size <= 0 or self.group_size % 2 != 0:
+            raise ValueError(f"The group_size must be divisible by 2 when using RoadLayer, but got {self.group_size}.")
diff --git a/src/peft/tuners/road/layer.py b/src/peft/tuners/road/layer.py
new file mode 100644
index 0000000..8af05a3
--- /dev/null
+++ b/src/peft/tuners/road/layer.py
@@ -0,0 +1,416 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+import warnings
+from typing import Any, Optional
+
+import torch
+from torch import nn
+
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+
+from .config import RoadConfig, RoadVariant
+
+
+class RoadLayer(BaseTunerLayer):
+    """
+    Road layer.
+
+    Generally the idea of RoAD is to split the input vector into many 2D vectors and rotate each 2D vector with its own
+    2D rotation matrix. For additional flexibility, each rotation matrix is multiplied by a trainable scale.
+
+    when applied to vector R @ x each pair of elements of x is transformed like this: `y₀ = x₀ * α * cosθ - xₙ * α *
+    sinθ` and `yₙ = x₀ * α * sinθ + xₙ * α * cosθ`
+
+    The scales α and angles θ are learned for each pair of elements and, moreover, each of the 4 instances in the
+    rotation matrix may actually be different (when using variant 2 or 4).
+
+    Note that instead of using two consecutive elements x₀ x₁ we first split the whole vector into groups and pair
+    elements from the first with the second half of the same group, which allows for more efficient inference
+    implementation.
+
+    The adapter needs to only store the angles θ and scales α, rather than the full matrix R and the inference
+    implementation only needs to do elementwise vector multiplications.
+
+    For merging the weights, we make use of the following formula: R @ (W @ x + b) = (R @ W) @ x + R @ b. The lhs part
+    is how it is used in unmerged state (using efficient elementwise implementation instead of matrix multiplication)
+    and the rhs part is how it is used in merged state where (R @ W) becomes the new weight matrix and R @ b becomes
+    the new bias.
+
+    """
+
+    adapter_layer_names: tuple[str, ...] = ("road_theta", "road_alpha")
+    other_param_names: tuple[str, ...] = ("variant", "group_size")
+
+    def __init__(self, base_layer: nn.Module, ephemeral_gpu_offload: bool = False, **kwargs) -> None:
+        self.base_layer = base_layer
+        self.variant = {}
+        self.group_size = {}
+        self.road_theta = nn.ParameterDict({})
+        self.road_alpha = nn.ParameterDict({})
+
+        self._disable_adapters = False
+        self.merged_adapters = []
+
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            in_features, out_features = base_layer.in_features, base_layer.out_features
+        else:
+            raise TypeError(f"Unsupported layer type '{type(base_layer)}' encountered, cannot apply RoAd adapter.")
+        self.in_features = in_features
+        self.out_features = out_features
+
+    @property
+    def _available_adapters(self) -> set[str]:
+        return {*self.road_theta}
+
+    def update_layer(
+        self,
+        adapter_name,
+        config: RoadConfig,
+        inference_mode: bool = False,
+    ):
+        variant = config.variant
+        group_size = config.group_size
+        init_weights = config.init_weights
+
+        self.variant[adapter_name] = variant
+        self.group_size[adapter_name] = group_size
+
+        if self.out_features % group_size != 0:
+            raise ValueError(
+                f"The out_features of the base layer must be divisible by group_size ({group_size}) when using RoadLayer."
+            )
+
+        # Actual trainable parameters
+        if variant == "road_1":
+            size = self.out_features // 2
+        elif variant == "road_2":
+            size = self.out_features
+        elif variant == "road_4":
+            size = self.out_features * 2
+        else:
+            raise ValueError(
+                f"Unsupported variant {variant} for RoadLayer. Supported variants are road_1, road_2, and road_4."
+            )
+        self.road_theta[adapter_name] = nn.Parameter(torch.empty(size))
+        self.road_alpha[adapter_name] = nn.Parameter(torch.empty(size))
+
+        self.reset_parameters(adapter_name, init_weights)
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def reset_parameters(self, adapter_name, init_weights):
+        if init_weights is False:
+            nn.init.normal_(self.road_theta[adapter_name].data, mean=0.0, std=0.5)
+            nn.init.normal_(self.road_alpha[adapter_name].data, mean=1.0, std=0.5)
+            return
+        nn.init.zeros_(self.road_theta[adapter_name].data)
+        nn.init.ones_(self.road_alpha[adapter_name].data)
+
+
+class Linear(nn.Module, RoadLayer):
+    # Road implemented in a dense layer
+    def __init__(
+        self,
+        base_layer,
+        adapter_name: str,
+        config: RoadConfig,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        RoadLayer.__init__(self, base_layer, **kwargs)
+
+        self._active_adapter = adapter_name
+
+        self.update_layer(
+            adapter_name,
+            config=config,
+        )
+
+    def _check_forward_args(self, x, *args, **kwargs):
+        """Check if the arguments are compatible with the configs and state of the model"""
+        adapter_names = kwargs.get("adapter_names", None)
+        if adapter_names is None:
+            return
+
+        if len(x) != len(adapter_names):
+            msg = (
+                "Length of `adapter_names` should be the same as the number of inputs, but got "
+                f"{len(adapter_names)} and {len(x)} respectively."
+            )
+            raise ValueError(msg)
+
+        if self.merged:
+            # It is unclear what would be the right thing to do if users pass adapter_names and there are merged
+            # adapters. Therefore, it is better to raise an error in this case.
+            msg = "Cannot pass `adapter_names` when there are merged adapters, please call `unmerge_adapter` first."
+            raise ValueError(msg)
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        self._check_forward_args(x, *args, **kwargs)
+        adapter_names = kwargs.pop("adapter_names", None)
+
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        elif adapter_names is not None:
+            result = self._mixed_batch_forward(x, *args, adapter_names=adapter_names, **kwargs)
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+            torch_result_dtype = result.dtype
+
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self._available_adapters:
+                    continue
+
+                result = self._cast_input_dtype(result, self.road_theta[active_adapter].dtype)
+                result = _apply_road(
+                    self.variant[active_adapter],
+                    self.group_size[active_adapter],
+                    self.road_theta[active_adapter],
+                    self.road_alpha[active_adapter],
+                    result,
+                )
+
+            result = result.to(torch_result_dtype)
+
+        return result
+
+    def _mixed_batch_forward(
+        self, x: torch.Tensor, *args: Any, adapter_names: list[str], **kwargs: Any
+    ) -> torch.Tensor:
+        # This is a special method that handles the case when users pass the argument `adapter_names`. This is an
+        # extra argument that allows mixing different adapters in the same batch at inference time.
+        result = self.base_layer(x, *args, **kwargs)
+
+        unique_adapters = set(adapter_names)
+        sub_batch_indices_list = []
+        for adapter in unique_adapters:
+            sub_batch_indices_list.append([index for index, item in enumerate(adapter_names) if item == adapter])
+
+        for i, active_adapter in enumerate(unique_adapters):
+            if active_adapter == "__base__":
+                continue
+            if active_adapter not in self._available_adapters:
+                continue
+
+            dtype = self.road_theta[active_adapter].data.dtype
+
+            # getting the sub-batch, passing it to Road layers and updating the corresponding indices of the linear
+            # layer output
+            sub_batch = result[sub_batch_indices_list[i]].to(dtype)
+            result[sub_batch_indices_list[i]] = _apply_road(
+                self.variant[active_adapter],
+                self.group_size[active_adapter],
+                self.road_theta[active_adapter],
+                self.road_alpha[active_adapter],
+                sub_batch,
+            )
+
+        return result
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If `True`, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If `None`, all active adapters will be merged.
+                Defaults to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self._available_adapters:
+                base_layer = self.get_base_layer()
+                orig_dtype = base_layer.weight.dtype
+                road_R = _get_delta_weight(
+                    self.variant[active_adapter],
+                    self.group_size[active_adapter],
+                    self.road_theta[active_adapter].data,
+                    self.road_alpha[active_adapter].data,
+                )
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    # because of the copy operation.
+                    orig_weight = base_layer.weight.data.clone()
+                    orig_weight = torch.matmul(road_R.to(orig_dtype), orig_weight)
+
+                    if not torch.isfinite(orig_weight).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = orig_weight.contiguous().to(orig_dtype)
+
+                    if base_layer.bias is not None:
+                        orig_bias = base_layer.bias.clone()
+                        orig_bias = torch.matmul(road_R.to(orig_dtype), orig_bias)
+
+                        if not torch.isfinite(orig_bias).all():
+                            raise ValueError(
+                                f"NaNs detected in the merged bias. The adapter {active_adapter} seems to be broken"
+                            )
+
+                        base_layer.bias.data = orig_bias.contiguous().to(orig_dtype)
+                else:
+                    orig_weight = base_layer.weight.data
+                    orig_weight = torch.matmul(road_R.to(orig_dtype), orig_weight)
+                    base_layer.weight.data = orig_weight.contiguous().to(orig_dtype)
+
+                    if base_layer.bias is not None:
+                        orig_bias = base_layer.bias.data
+                        orig_bias = torch.matmul(road_R.to(orig_dtype), orig_bias)
+                        base_layer.bias.data = orig_bias.contiguous().to(orig_dtype)
+
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+        while len(self.merged_adapters) > 0:
+            # Going in reverse order
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self._available_adapters:
+                weight = self.get_base_layer().weight
+                orig_dtype = weight.dtype
+                road_R = _get_delta_weight(
+                    self.variant[active_adapter],
+                    self.group_size[active_adapter],
+                    self.road_theta[active_adapter].data,
+                    self.road_alpha[active_adapter].data,
+                )
+                # Since our matrix are not necessarily orthogonal we need inverse instead of transpose.
+                # In practice we expect this to basically always work since we start from block diagonal rotation matrix.
+                inv_road_R = torch.linalg.inv(road_R.to(torch.float32)).to(orig_dtype)
+                orig_weight = torch.matmul(inv_road_R, weight.data)
+                weight.data = orig_weight.contiguous()
+
+                if self.get_base_layer().bias is not None:
+                    orig_bias = torch.matmul(inv_road_R, self.get_base_layer().bias.data)
+                    self.get_base_layer().bias.data = orig_bias.contiguous()
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "road." + rep
+
+
+def _get_delta_weight(variant: RoadVariant, group_size: int, road_theta: torch.Tensor, road_alpha: torch.Tensor):
+    first_col, second_col = _prepare_cols(variant, group_size, road_theta, road_alpha)
+
+    # To help understand the logic below consider how rope embeddings work
+    # here it is similar, but done in groups.
+    # https://discuss.huggingface.co/t/is-llama-rotary-embedding-implementation-correct/44509/3
+
+    # First column is simply put on the main diagonal
+    output_tensor = torch.diag(first_col)
+    # For second column we need to swap each half groups and add minus sign
+    size = second_col.shape[0]
+    swapped_second_col = second_col.reshape(-1, 2, group_size // 2)[:, [1, 0], :].flatten()
+    rotated_diag_second_col = torch.diag(swapped_second_col).reshape(-1, 2, group_size // 2, size)[:, [1, 0], :, :]
+    rotated_diag_second_col[:, 0, :, :] *= -1
+    rotated_diag_second_col = rotated_diag_second_col.reshape(size, size)
+    output_tensor += rotated_diag_second_col
+
+    return output_tensor
+
+
+def _prepare_cols(
+    variant: RoadVariant, group_size: int, road_theta: torch.Tensor, road_alpha: torch.Tensor
+) -> tuple[torch.Tensor, torch.Tensor]:
+    # In inference mode, this can be cached
+    if variant == "road_1":
+        # In each group there are only group_size // 2 parameters that are reused
+        road_theta = road_theta.reshape(-1, group_size // 2).repeat_interleave(2, dim=0).flatten()
+        road_alpha = road_alpha.reshape(-1, group_size // 2).repeat_interleave(2, dim=0).flatten()
+
+        theta_cos = road_theta.cos()
+        theta_sin = road_theta.sin()
+
+        first_col = road_alpha * theta_cos
+        second_col = road_alpha * theta_sin
+    elif variant == "road_2":
+        # Each group has exactly group_size parameters
+        theta_cos = road_theta.cos()
+        theta_sin = road_theta.sin()
+
+        first_col = road_alpha * theta_cos
+        second_col = road_alpha * theta_sin
+    elif variant == "road_4":
+        # Each group has 2*group_size parameters, first half used for first column, second half for second column
+        road_theta = road_theta.reshape(-1, 2, group_size)
+        theta_cos = road_theta[:, 0, :].cos().flatten()
+        theta_sin = road_theta[:, 1, :].sin().flatten()
+        road_alpha = road_alpha.reshape(-1, 2, group_size)
+        alpha_1 = road_alpha[:, 0, :].flatten()
+        alpha_2 = road_alpha[:, 1, :].flatten()
+
+        first_col = alpha_1 * theta_cos
+        second_col = alpha_2 * theta_sin
+    else:
+        raise ValueError(
+            f"Unsupported variant {variant} for RoadLayer. Supported variants are road_1, road_2, and road_4."
+        )
+
+    return first_col, second_col
+
+
+def _apply_road(
+    variant: RoadVariant, group_size: int, road_theta: torch.Tensor, road_alpha: torch.Tensor, x: torch.Tensor
+):
+    first_col, second_col = _prepare_cols(variant, group_size, road_theta, road_alpha)
+
+    # Split in half groups and join back
+    # See equation 4 in the RoAD paper
+    x_grouped = x.reshape(-1, 2, group_size // 2)
+    x1 = x_grouped[:, 0, :]
+    x2 = x_grouped[:, 1, :]
+    rotate_half_x = torch.stack((-x2, x1), dim=1).reshape(x.shape)
+    result = x * first_col + rotate_half_x * second_col
+    return result
+
+
+def dispatch_default(
+    target: torch.nn.Module,
+    adapter_name: str,
+    road_config: RoadConfig,
+    **kwargs,
+) -> Optional[torch.nn.Module]:
+    new_module = None
+
+    if isinstance(target, BaseTunerLayer):
+        target_base_layer = target.get_base_layer()
+    else:
+        target_base_layer = target
+
+    if isinstance(target_base_layer, torch.nn.Linear):
+        new_module = Linear(target, adapter_name, config=road_config, **kwargs)
+
+    return new_module
diff --git a/src/peft/tuners/road/model.py b/src/peft/tuners/road/model.py
new file mode 100644
index 0000000..6beeb5a
--- /dev/null
+++ b/src/peft/tuners/road/model.py
@@ -0,0 +1,153 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import operator
+from contextlib import contextmanager
+from functools import partial
+
+from torch import nn
+
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available
+from peft.tuners.road.config import RoadConfig
+from peft.tuners.tuners_utils import (
+    BaseTuner,
+    get_device_map,
+)
+from peft.utils import TRANSFORMERS_MODELS_TO_ROAD_TARGET_MODULES_MAPPING
+
+from .layer import RoadLayer, dispatch_default
+
+
+def _adapter_names_pre_forward_hook(target, args, kwargs, adapter_names):
+    # pre-forward hook to inject the adapter_names argument when using mixed adapter batches inference
+    kwargs["adapter_names"] = adapter_names
+    return args, kwargs
+
+
+class RoadModel(BaseTuner):
+    prefix: str = "road_"
+    tuner_layer_cls = RoadLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_ROAD_TARGET_MODULES_MAPPING
+
+    def _create_and_replace(
+        self,
+        road_config: RoadConfig,
+        adapter_name: str,
+        target: nn.Module,
+        target_name: str,
+        parent: nn.Module,
+        current_key,
+    ) -> None:
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+
+        kwargs = {
+            "loaded_in_8bit": getattr(self.model, "is_loaded_in_8bit", False),
+            "loaded_in_4bit": getattr(self.model, "is_loaded_in_4bit", False),
+        }
+        # for torchao merging, we need the get_apply_tensor_subclass from the quantization config
+        try:
+            kwargs["get_apply_tensor_subclass"] = operator.attrgetter(
+                "hf_quantizer.quantization_config.get_apply_tensor_subclass"
+            )(self.model)
+        except AttributeError:
+            pass
+
+        if isinstance(target, RoadLayer):
+            target.update_layer(
+                adapter_name,
+                config=road_config,
+            )
+        else:
+            device_map = get_device_map(self.model)
+            new_module = self._create_new_module(road_config, adapter_name, target, device_map=device_map, **kwargs)
+            if adapter_name not in self.active_adapters:
+                # adding an additional adapter: it is not automatically trainable
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+    @staticmethod
+    def _create_new_module(road_config: RoadConfig, adapter_name, target, **kwargs):
+        dispatchers = []
+
+        # avoid eager bnb import
+        if is_bnb_available():
+            from .bnb import dispatch_bnb_8bit
+
+            dispatchers.append(dispatch_bnb_8bit)
+
+        if is_bnb_4bit_available():
+            from .bnb import dispatch_bnb_4bit
+
+            dispatchers.append(dispatch_bnb_4bit)
+
+        dispatchers.extend(
+            [
+                dispatch_default,
+            ]
+        )
+
+        new_module = None
+        for dispatcher in dispatchers:
+            new_module = dispatcher(target, adapter_name, road_config=road_config, **kwargs)
+            if new_module is not None:  # first match wins
+                break
+
+        if new_module is None:
+            # no module could be matched
+            raise ValueError(
+                f"Target module {target} is not supported. Currently, only the following modules are supported: "
+                "`torch.nn.Linear`."
+            )
+
+        return new_module
+
+    @contextmanager
+    def _enable_peft_forward_hooks(self, *args, **kwargs):
+        # If adapter_names is passed as an argument, we inject it into the forward arguments.
+        adapter_names = kwargs.pop("adapter_names", None)
+        if adapter_names is None:
+            # nothing to do
+            yield
+            return
+
+        if self.training:
+            raise ValueError("Cannot pass `adapter_names` when the model is in training mode.")
+
+        # Check that users only passed actually existing adapters.
+        # Note: We cannot do this on the layer level, as each individual layer may not have each adapter. Still, we want
+        # to check that there is at least one layer with the given name, or else something like typos can easily slip.
+        expected_adapters = set()
+        for layer in self.modules():
+            if isinstance(layer, RoadLayer):
+                expected_adapters |= layer.road_theta.keys()
+        unique_adapters = {name for name in adapter_names if name != "__base__"}
+        unexpected_adapters = unique_adapters - expected_adapters
+        if unexpected_adapters:
+            raise ValueError(f"Trying to infer with non-existing adapter(s): {', '.join(sorted(unexpected_adapters))}")
+
+        hook_handles = []
+        for module in self.modules():
+            if isinstance(module, RoadLayer):
+                pre_forward = partial(_adapter_names_pre_forward_hook, adapter_names=adapter_names)
+                handle = module.register_forward_pre_hook(pre_forward, with_kwargs=True)
+                hook_handles.append(handle)
+
+        # TODO LoRA also has hooks for beam search, ignore this for now
+
+        yield
+
+        for handle in hook_handles:
+            handle.remove()
diff --git a/src/peft/tuners/shira/__init__.py b/src/peft/tuners/shira/__init__.py
new file mode 100644
index 0000000..d5391b9
--- /dev/null
+++ b/src/peft/tuners/shira/__init__.py
@@ -0,0 +1,27 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from peft.utils import register_peft_method
+
+from .config import ShiraConfig
+from .layer import Linear, ShiraLayer
+from .model import ShiraModel
+
+
+__all__ = ["Linear", "ShiraConfig", "ShiraLayer", "ShiraModel"]
+
+
+register_peft_method(
+    name="shira", config_cls=ShiraConfig, model_cls=ShiraModel, prefix="shira_", is_mixed_compatible=True
+)
diff --git a/src/peft/tuners/shira/config.py b/src/peft/tuners/shira/config.py
new file mode 100644
index 0000000..d868e51
--- /dev/null
+++ b/src/peft/tuners/shira/config.py
@@ -0,0 +1,129 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+import warnings
+from dataclasses import dataclass, field
+from typing import Literal, Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+from .mask_functions import random_mask
+
+
+@dataclass
+class ShiraConfig(PeftConfig):
+    """
+    This is the configuration class to store the configuration of a [`ShiraModel`].
+
+    Args:
+        r (`int`, *optional*, defaults to `32`):
+            For a given target module, the number of SHiRA parameters is computed as r(m+n), where the original tensor
+            dimensions are m x n. This means the number of SHiRA parameters is the same as that for a LoRA adapter.
+            SHiRA is a high rank adapter. Setting this r parameter does not restrict the rank to this value.
+        mask_type (`str`, defaults to `random`):
+            Type of mask function. Defaults to a random sparse mask. An optional user-defined mask_fn to compute the
+            mask value can also be supplied by instantiating `config = ShiraConfig(...)` and then setting
+            `config.mask_fn = <your custom mask function>`. For a pretrained weight with shape m x n, the custom mask
+            function must return only one mask (shape: m x n) which must be binary 0 or 1 with num_shira_parameters =
+            r(m + n) for linear layers. Device and dtype of mask must be same as base layer's weight's device and
+            dtype. Please see mask_functions.py for more details and to see the default random sparse mask
+            implementation.
+        random_seed (`int`, *optional*, defaults to `None`):
+            random seed for the torch generator for random_mask.
+        target_modules (`Union[List[str], str]`):
+            List of module names or regex expression of the module names to replace with SHiRA. For example, ['q', 'v']
+            or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'. Only linear layers are supported.
+        fan_in_fan_out (`bool`):
+            Set this to True if the layer to replace stores weight like (fan_in, fan_out). For example, gpt-2 uses
+            `Conv1D` which stores weights like (fan_in, fan_out) and hence this should be set to `True`.
+        init_weights (`bool`, defaults to `True`):
+            Initialize SHiRA weight to have zero values. If set to False, SHiRA weights are initialized to randn values
+            instead of zeros and this is used only for testing.
+        modules_to_save (`List[str]`):
+            List of modules apart from SHiRA layers to be set as trainable and saved in the final checkpoint.
+    """
+
+    r: int = field(
+        default=32,
+        metadata={
+            "help": (
+                "For a given target module, the number of SHiRA parameters is computed as r(m+n), where the original "
+                "tensor dimensions are m x n. This means the number of SHiRA parameters is the same as that for a LoRA adapter. "
+                "SHiRA is a high rank adapter. Setting this r parameter does not restrict the rank to this value."
+            )
+        },
+    )
+    mask_type: Literal["random"] = field(
+        default="random",
+        metadata={
+            "help": (
+                "Type of mask function. Defaults to a random sparse mask. "
+                "An optional user-defined mask_fn to compute the mask value can also be supplied by instantiating `config = ShiraConfig(...)` and then setting "
+                "`config.mask_fn = <your custom mask function>`. For a pretrained weight with shape m x n, the custom mask function must return only one mask (shape: m x n) "
+                "which must be binary 0 or 1 with num_shira_parameters = r(m + n) for linear layers. Device and dtype of mask must be same as base layer's weight's device and dtype. "
+                "Please see mask_functions.py for more details and to see the default random sparse mask implementation."
+            )
+        },
+    )
+    random_seed: Optional[int] = field(
+        default=None, metadata={"help": "random seed for the torch generator for random_mask"}
+    )
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of module names or regex expression of the module names to replace with SHiRA."
+                "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'. "
+                "Only linear layers are supported."
+            )
+        },
+    )
+    fan_in_fan_out: bool = field(
+        default=False,
+        metadata={"help": "Set this to True if the layer to replace stores weight like (fan_in, fan_out)"},
+    )
+    init_weights: bool = field(
+        default=True,
+        metadata={
+            "help": "Initialize SHiRA weight to have zero values. If set to False, SHiRA weights are initialized to randn values instead of zeros and this is used only for testing."
+        },
+    )
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of modules apart from SHiRA layers to be set as trainable and saved in the final checkpoint. For"
+                " example, in Sequence Classification or Token Classification tasks, the final layer"
+                " `classifier/score` are randomly initialized and as such need to be trainable and saved."
+            )
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.SHIRA
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        if self.mask_type == "random":
+            self.mask_fn = random_mask
+        else:
+            if not self.inference_mode:
+                warnings.warn(
+                    f"Argument {self.mask_type=} is not recognized, please supply your own masking function by calling `config.mask_fn = my_mask_fn`."
+                )
+            self.mask_fn = None
diff --git a/src/peft/tuners/shira/layer.py b/src/peft/tuners/shira/layer.py
new file mode 100644
index 0000000..db80e73
--- /dev/null
+++ b/src/peft/tuners/shira/layer.py
@@ -0,0 +1,224 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+import copy
+import warnings
+from typing import Optional
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+
+from .config import ShiraConfig
+
+
+class ShiraLayer(BaseTunerLayer):
+    # List all names of layers that may contain trainable adapter weights
+    adapter_layer_names = ("shira_weight",)
+    # All names of other adapter-related parameters
+    other_param_names = ("r", "scaling", "shira_indices")
+
+    def __init__(self, base_layer: nn.Module, **kwargs):
+        self.base_layer = base_layer
+        self.r = {}
+        self.scaling = {}
+        self.shira_weight = nn.ParameterDict({})
+        self.shira_indices = {}
+        self.weight_shape = base_layer.weight.shape  # Assumes SHiRA is on some layer with "weight" parameter
+
+        # Mark the weight as unmerged
+        self._disable_adapters = False
+        self.merged_adapters = []
+
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            in_features, out_features = base_layer.in_features, base_layer.out_features
+        else:
+            raise NotImplementedError("Only nn.Linear layers supported currently")
+
+        self.in_features = in_features
+        self.out_features = out_features
+        self.kwargs = kwargs
+
+    def update_layer(
+        self,
+        adapter_name,
+        mask,
+        r,
+        config: ShiraConfig,
+        inference_mode: bool = False,
+        **kwargs,
+    ):
+        init_weights = config.init_weights
+
+        if r <= 0:
+            raise ValueError(f"`r` should be a positive integer value but the value passed is {r}")
+        self.r[adapter_name] = r
+        self.scaling[adapter_name] = (
+            1.0  # Default scale during training. Can be set to any (non-negative) value during inference.
+        )
+        # The number of shira weights in this layer is determined by r such that the total number of weights is the same as a LoRA Layer (for direct comparisons)
+        num_shira_weight = r * (self.in_features + self.out_features)
+        if num_shira_weight > self.in_features * self.out_features:
+            raise ValueError(
+                f"The set rank {r} results in more shira params than the total number of params in the base layer {self.in_features * self.out_features} and this is not allowed."
+            )
+
+        # Actual trainable parameters
+        # We have used a vector parameter with fixed indices that we use inside a torch.sparse_coo_tensor in get_delta_weight function.
+        # Directly using a torch.sparse_coo_tensor as a parameter could have been possible but we ran into some issues similar to:
+        # https://github.com/pytorch/pytorch/issues/79542.
+        shira_init_weight = torch.zeros(num_shira_weight) if init_weights else torch.randn(num_shira_weight)
+        self.shira_weight[adapter_name] = nn.Parameter(
+            shira_init_weight.to(self.base_layer.weight.dtype).to(self.base_layer.weight.device),
+            requires_grad=True,
+        )
+
+        if mask is not None:
+            # Compute the shira_indices from the mask. Make sure the mask is formed using r*(self.in_features + self.out_features) and not some other K.
+            mask_indices = torch.where(mask == 1.0)
+            self.shira_indices[adapter_name] = torch.cat(
+                [mask_indices[0].unsqueeze(0), mask_indices[1].unsqueeze(0)], 0
+            ).to(torch.int)
+            self.shira_indices[adapter_name] = self.shira_indices[adapter_name].to(self.base_layer.weight.device)
+
+            if self.shira_indices[adapter_name].shape[1] != self.shira_weight[adapter_name].shape[0]:
+                raise ValueError(
+                    f"The SHiRA indices and weights are not the same dimensions for adapter {adapter_name} in layer {self.base_layer}"
+                )
+
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def reset_shira_parameters(self, adapter_name):
+        nn.init.zeros_(self.shira_weight[adapter_name])
+
+    def set_scale(self, adapter, scale):
+        if adapter not in self.scaling:
+            # Ignore the case where the adapter is not in the layer
+            return
+        self.scaling[adapter] = scale
+
+
+class Linear(nn.Module, ShiraLayer):
+    # SHiRA implemented in a dense layer
+    def __init__(
+        self,
+        base_layer,
+        mask,
+        adapter_name: str,
+        config: ShiraConfig,
+        r: int = 0,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        ShiraLayer.__init__(self, base_layer, **kwargs)
+        self.fan_in_fan_out = config.fan_in_fan_out
+        if self.base_layer is not self.get_base_layer():
+            raise ValueError("SHiRA does not support nested base layers")
+
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, mask, r, config=config)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.shira_weight.keys():
+                base_layer = self.get_base_layer()
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    # because of the copy operation.
+                    orig_weights = base_layer.weight.data.clone()
+
+                    orig_weights += self.get_delta_weight(active_adapter)
+
+                    if not torch.isfinite(orig_weights).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = orig_weights
+                else:
+                    base_layer.weight.data += self.get_delta_weight(active_adapter)
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.shira_weight.keys():
+                self.get_base_layer().weight.data -= self.get_delta_weight(active_adapter)
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        """
+        Compute the delta weight for the given adapter.
+
+        Args:
+            adapter (str):
+                The name of the adapter for which the delta weight should be computed.
+        """
+
+        # In multi-gpu environment, the indices are at the wrong gpu.  This is needed to correct this.
+        self.shira_indices[adapter] = self.shira_indices[adapter].to(self.shira_weight[adapter].device)
+        return torch.sparse_coo_tensor(
+            self.shira_indices[adapter], self.shira_weight[adapter] * self.scaling[adapter], self.weight_shape
+        )
+
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            new_weight = copy.deepcopy(self.base_layer.weight.data)
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.shira_weight.keys():
+                    continue
+                new_weight += self.get_delta_weight(active_adapter)
+
+            result = F.linear(x, new_weight, bias=self.base_layer.bias)
+
+        return result
+
+    def supports_lora_conversion(self, adapter_name: str = "default") -> bool:
+        # delta weight is sparse, which does not work with SVD
+        return False
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "shira." + rep
diff --git a/src/peft/tuners/shira/mask_functions.py b/src/peft/tuners/shira/mask_functions.py
new file mode 100644
index 0000000..3304989
--- /dev/null
+++ b/src/peft/tuners/shira/mask_functions.py
@@ -0,0 +1,72 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+"""
+This module is intended to store mask functions for use inside SHiRA construction. The mask functions are required to
+have a specific signature as shown below.
+
+Required positional arguments:
+    base_layer - This is the linear layer where the shira adapter will be attached. r - This parameter is used to
+    determine the number of parameters in the
+                 shira adapter in a way that is consistent with LoRA sizing. SHiRA is a high rank adapter. Setting this
+                 parameter does not restrict the adapter rank.
+Keyword arguments can be provided as needed by the particular mask function implementation.
+
+Return:
+    mask - this is a torch.tensor of the same shape as base_layer.weight that contains 0s and 1s with the same
+           dtype and device as base_layer.weight
+
+If you would like to attach SHiRA adapters to a model using PEFT methods (such as get_peft_model()), using more
+arguments than the provided positional arguments, you can create the mask function reference like the following:
+
+```
+    def create_mask_function_reference(**my_kwargs):
+        def mask_fn(base_layer, r):
+            ... your implementation here that might use my_kwargs ...
+            return mask
+        return mask_fn
+```
+Then, you can create your peft model with custom SHiRA mask as follows:
+```
+    model = ...
+    my_kwargs = ...
+    mask_fn = create_mask_function_reference(**my_kwargs)
+    peft_config = ShiraConfig(r=4, mask_type='my_custom_mask')
+    peft_config.mask_fn = mask_fn
+    peft_model = get_peft_model(model, peft_config)
+```
+
+Complete training examples are provided in the examples/shira/ directory.
+"""
+
+from typing import Optional
+
+import torch
+from torch import nn
+
+
+def random_mask(base_layer: nn.Module, r: int, random_seed: Optional[int] = None, **kwargs) -> torch.tensor:
+    shape = base_layer.weight.shape
+    num_shira_weights = r * (shape[0] + shape[1])
+    random_generator = torch.Generator()
+    if random_seed is not None:
+        random_generator.manual_seed(random_seed)
+    idx = (torch.randperm(base_layer.weight.numel(), generator=random_generator)[:num_shira_weights]).to(
+        base_layer.weight.device
+    )
+    val = torch.ones_like(idx.type(base_layer.weight.dtype))
+    mask = torch.zeros_like(base_layer.weight.view(1, -1))
+    mask = mask.scatter_(1, idx.unsqueeze(0), val.unsqueeze(0)).view(shape)
+
+    return mask
diff --git a/src/peft/tuners/shira/model.py b/src/peft/tuners/shira/model.py
new file mode 100644
index 0000000..d07b9a2
--- /dev/null
+++ b/src/peft/tuners/shira/model.py
@@ -0,0 +1,139 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+import warnings
+
+import torch
+
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer
+from peft.utils import (
+    TRANSFORMERS_MODELS_TO_SHIRA_TARGET_MODULES_MAPPING,
+)
+
+from .layer import Linear, ShiraLayer
+
+
+class ShiraModel(BaseTuner):
+    """
+    Creates a Sparse High Rank Adapter (SHiRA) Model from a pretrained model.
+
+    Args:
+        model ([`~transformers.PreTrainedModel`]): The model to be adapted.
+        config ([`ShiraConfig`]): The configuration of the SHiRA model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+
+    Returns:
+        `torch.nn.Module`: The SHiRA model.
+
+    Example:
+
+        ```py
+        >>> from transformers import AutoModelForCausalLM
+        >>> from peft import ShiraConfig, get_peft_model
+
+        >>> base_model = AutoModelForCausalLM.from_pretrained("facebook/opt-125m")
+        >>> config = ShiraConfig(r=32)
+        >>> model = get_peft_model(base_model, config)
+        ```
+
+    **Attributes**:
+        - **model** ([`~transformers.PreTrainedModel`]) -- The model to be adapted.
+        - **peft_config** ([`ShiraConfig`]): The configuration of the SHiRA model.
+    """
+
+    prefix: str = "shira_"
+    tuner_layer_cls = ShiraLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_SHIRA_TARGET_MODULES_MAPPING
+
+    def _create_and_replace(
+        self,
+        shira_config,
+        adapter_name,
+        target,
+        target_name,
+        parent,
+        current_key,
+        **optional_kwargs,
+    ):
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+
+        bias = hasattr(target, "bias") and target.bias is not None
+        kwargs = {}
+        kwargs["bias"] = bias
+        if shira_config.mask_type == "random":
+            kwargs["random_seed"] = shira_config.random_seed
+
+        for k, v in optional_kwargs.items():
+            kwargs[k] = v
+
+        if isinstance(target, Linear):
+            mask = (
+                shira_config.mask_fn(target.base_layer, shira_config.r, **kwargs)
+                if shira_config.mask_fn is not None
+                else None
+            )
+            target.update_layer(
+                adapter_name,
+                mask,
+                shira_config.r,
+                config=shira_config,
+            )
+        else:
+            new_module = self._create_new_module(shira_config, adapter_name, target, **kwargs)
+            if adapter_name not in self.active_adapter:
+                # adding an additional adapter: it is not automatically trainable
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+    @staticmethod
+    def _create_new_module(shira_config, adapter_name, target, **kwargs):
+        _ = kwargs.pop("bias", False)
+
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        if isinstance(target_base_layer, torch.nn.Linear):
+            if shira_config.fan_in_fan_out:
+                warnings.warn(
+                    "fan_in_fan_out is set to True but the target module is `torch.nn.Linear`. "
+                    "Setting fan_in_fan_out to False."
+                )
+                shira_config.fan_in_fan_out = False
+        else:
+            raise TypeError(
+                f"Target module {target} is not supported. Currently, only the following modules are supported: "
+                "`torch.nn.Linear`."
+            )
+
+        mask = (
+            shira_config.mask_fn(target_base_layer, shira_config.r, **kwargs)
+            if shira_config.mask_fn is not None
+            else None
+        )
+
+        new_module = Linear(
+            target,
+            mask,
+            adapter_name,
+            config=shira_config,
+            r=shira_config.r,
+            **kwargs,
+        )
+
+        return new_module
diff --git a/src/peft/tuners/tinylora/__init__.py b/src/peft/tuners/tinylora/__init__.py
new file mode 100644
index 0000000..d8287a4
--- /dev/null
+++ b/src/peft/tuners/tinylora/__init__.py
@@ -0,0 +1,25 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+from peft.utils import register_peft_method
+
+from .config import TinyLoraConfig
+from .layer import Embedding, Linear, TinyLoraLayer
+from .model import TinyLoraModel
+
+
+__all__ = ["Embedding", "Linear", "TinyLoraConfig", "TinyLoraLayer", "TinyLoraModel"]
+
+
+register_peft_method(name="tinylora", config_cls=TinyLoraConfig, model_cls=TinyLoraModel, prefix="tinylora_")
diff --git a/src/peft/tuners/tinylora/config.py b/src/peft/tuners/tinylora/config.py
new file mode 100644
index 0000000..24a9e90
--- /dev/null
+++ b/src/peft/tuners/tinylora/config.py
@@ -0,0 +1,202 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import warnings
+from dataclasses import dataclass, field
+from typing import Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class TinyLoraConfig(PeftConfig):
+    """
+    This is the configuration class to store the configuration of a [`TinyLoraModel`].
+
+    TinyLoRA is an extremely parameter-efficient fine-tuning method based on the paper "Learning to Reason in 13
+    Parameters" (arXiv:2602.04118). It uses SVD decomposition of frozen weights and projects a tiny trainable vector
+    through fixed random tensors.
+
+    Paper: https://arxiv.org/abs/2602.04118
+
+    Args:
+        r (`int`, *optional*, defaults to `2`):
+            SVD rank for the frozen U, Sigma, V decomposition. The paper recommends r=2.
+        u (`int`, *optional*, defaults to `64`):
+            Trainable vector dimension per group. This controls the expressivity of the adaptation. Can be as low as
+            1-13 for extreme parameter efficiency.
+        weight_tying (`float`, *optional*, defaults to `0.0`):
+            Degree of weight tying across target modules, as a ratio between 0.0 and 1.0. Controls how many modules
+            share the same trainable vector v. 0.0 means no sharing (each module has its own v). 1.0 means full sharing
+            (all modules share one v). Values in between give partial sharing.
+        projection_seed (`int`, *optional*, defaults to `42`):
+            Random seed for generating the fixed projection matrices P.
+        save_projection (`bool`, *optional*, defaults to `True`):
+            Whether to save the projection tensors P in the state dict. If False, they will be regenerated from the
+            seed when loading.
+        init_v_bound (`float`, *optional*, defaults to `0.02`):
+            Uniform initialization bound for the trainable vector v. Values are initialized in [-init_v_bound,
+            init_v_bound].
+        target_modules (`Union[List[str], str]`, *optional*):
+            The names of the modules to apply TinyLoRA to. This can be a list of module names (e.g. `['q_proj',
+            'v_proj']`), a regex pattern (e.g. `'.*decoder.*(q|v)_proj$'`), or the special keyword `"all-linear"` to
+            target all linear modules. Only `nn.Linear`, `nn.Embedding`, and `transformers.pytorch_utils.Conv1D` layers
+            are supported.
+        tinylora_dropout (`float`, *optional*, defaults to `0.0`):
+            The dropout probability for TinyLoRA layers.
+        fan_in_fan_out (`bool`, *optional*, defaults to `False`):
+            Set this to True if the layer to replace stores weight like (fan_in, fan_out). For example, gpt-2 uses
+            `Conv1D` which stores weights like (fan_in, fan_out).
+        bias (`str`, *optional*, defaults to `"none"`):
+            Bias type for TinyLoRA. Can be 'none', 'all' or 'tinylora_only'.
+        modules_to_save (`List[str]`, *optional*):
+            List of modules apart from TinyLoRA layers to be set as trainable and saved.
+        init_weights (`bool` | `Literal["uniform"]`, *optional*, defaults to `True`):
+            How to initialize the trainable vector v. Passing `True` (default) initializes v to zeros, making the
+            adapter a no-op (identity operation). Passing `"uniform"` initializes v with uniform random values in
+            `[-init_v_bound, init_v_bound]`. Passing `False` leaves v uninitialized (for advanced use cases).
+        layers_to_transform (`Union[List[int], int]`, *optional*):
+            The layer indexes to transform. If specified, only these layers will be adapted.
+        layers_pattern (`Optional[Union[List[str], str]]`, *optional*):
+            The layer pattern name, used only if `layers_to_transform` is different from `None`.
+
+    Example:
+        ```python
+        from peft import get_peft_model, TinyLoraConfig
+
+        config = TinyLoraConfig(
+            r=2,  # SVD rank (paper recommends 2)
+            u=64,  # Trainable vector dimension
+            weight_tying=0.0,  # No weight tying (0.0 = none, 1.0 = full)
+            target_modules=["q_proj", "v_proj"],
+            projection_seed=42,
+        )
+        model = get_peft_model(base_model, config)
+        ```
+    """
+
+    r: int = field(default=2, metadata={"help": "TinyLoRA SVD rank (frozen)"})
+    u: int = field(default=64, metadata={"help": "Trainable vector dimension per group"})
+    weight_tying: float = field(
+        default=0.0,
+        metadata={
+            "help": (
+                "Degree of weight tying across target modules (0.0 to 1.0). "
+                "0.0 = no sharing, 1.0 = full sharing (all modules share one v)."
+            )
+        },
+    )
+    projection_seed: int = field(
+        default=42,
+        metadata={
+            "help": (
+                "Random seed for generating the fixed projection matrices P. Used for initialising "
+                "projections for new models or when loading a checkpoint that did not include these projections."
+            )
+        },
+    )
+    save_projection: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "Whether to save the projection tensors P in the state dict. If False, they will be "
+                "regenerated from the seed when loading. Setting to True increases checkpoint size but "
+                "guarantees reproducibility across system configurations."
+            )
+        },
+    )
+    init_v_bound: float = field(default=0.02, metadata={"help": "Uniform init bound for v in [-bound, bound]"})
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of module names, regex expression, or the keyword 'all-linear' to replace with TinyLoRA. "
+                "For example, ['q_proj', 'v_proj'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'. "
+                "Only nn.Linear, nn.Embedding, and transformers.pytorch_utils.Conv1D layers are supported."
+            )
+        },
+    )
+    tinylora_dropout: float = field(default=0.0, metadata={"help": "TinyLoRA dropout"})
+    fan_in_fan_out: bool = field(
+        default=False,
+        metadata={"help": "Set this to True if the layer to replace stores weight like (fan_in, fan_out)"},
+    )
+    bias: str = field(
+        default="none", metadata={"help": "Bias type for TinyLoRA. Can be 'none', 'all' or 'tinylora_only'"}
+    )
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of modules apart from TinyLoRA layers to be set as trainable and saved in the final checkpoint. "
+                "For example, in Sequence Classification or Token Classification tasks, the final layer "
+                "`classifier/score` are randomly initialized and as such need to be trainable and saved."
+            )
+        },
+    )
+    init_weights: Union[bool, str] = field(
+        default=True,
+        metadata={
+            "help": (
+                "How to initialize the trainable vector v. True (default) initializes v to zeros, making the "
+                "adapter a no-op. 'uniform' initializes v with uniform random values. False leaves v uninitialized."
+            ),
+        },
+    )
+    layers_to_transform: Optional[Union[list[int], int]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The layer indexes to transform. If this argument is specified, PEFT will transform only the layers "
+                "indexes that are specified inside this list. If a single integer is passed, PEFT will transform only "
+                "the layer at this index."
+            )
+        },
+    )
+    layers_pattern: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The layer pattern name, used only if `layers_to_transform` is different to None and if the layer "
+                "pattern is not in the common layers pattern. This should target the `nn.ModuleList` of the "
+                "model, which is often called `'layers'` or `'h'`."
+            )
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.TINYLORA
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        # check for layers_to_transform and layers_pattern
+        if self.layers_pattern and not self.layers_to_transform:
+            raise ValueError("When `layers_pattern` is specified, `layers_to_transform` must also be specified.")
+        if not self.save_projection:
+            warnings.warn(
+                "Specified to not save projection tensors P within the state dictionary. They will be restored "
+                "using the PRNG key stored in `config.projection_seed`. Consider setting `config.save_projection` "
+                "to `True` to guarantee restoring the checkpoint correctly on all system configurations."
+            )
+        if self.r <= 0:
+            raise ValueError(f"`r` should be a positive integer value but the value passed is {self.r}")
+        if self.u <= 0:
+            raise ValueError(f"`u` should be a positive integer value but the value passed is {self.u}")
+        if not (0.0 <= self.weight_tying <= 1.0):
+            raise ValueError(
+                f"`weight_tying` should be a float between 0.0 and 1.0 but the value passed is {self.weight_tying}"
+            )
diff --git a/src/peft/tuners/tinylora/layer.py b/src/peft/tuners/tinylora/layer.py
new file mode 100644
index 0000000..a533820
--- /dev/null
+++ b/src/peft/tuners/tinylora/layer.py
@@ -0,0 +1,608 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+import warnings
+from typing import Optional
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from peft.tuners.tuners_utils import BaseTunerLayer, _get_in_out_features, check_adapters_to_merge
+from peft.utils.other import transpose
+
+from .._buffer_dict import BufferDict
+from .config import TinyLoraConfig
+
+
+class TinyLoraLayer(BaseTunerLayer):
+    """
+    TinyLoRA layer implementation.
+
+    TinyLoRA is based on LoRA-XS and uses SVD decomposition of frozen weights. The key innovation is replacing the
+    trainable r×r matrix R with:
+        R = sum_i(v[i] * P[i])
+    where v is a tiny trainable vector and P_i are fixed random projection matrices.
+
+    The forward pass computes:
+        result += lora_B(R(lora_A(x)))
+    where lora_A and lora_B are frozen SVD components.
+    """
+
+    # List all names of layers that may contain adapter weights
+    # Note: tinylora_v is a reference to the per-adapter ParameterDict (shared across layers in the same group)
+    adapter_layer_names = ("tinylora_v",)
+    other_param_names = ("tinylora_A", "tinylora_B", "tinylora_P")
+
+    def __init__(self, base_layer: nn.Module, layer_idx: int, **kwargs):
+        self.base_layer = base_layer
+        self.r = {}
+        self.u = {}
+        self.tinylora_dropout = nn.ModuleDict({})
+        self._layer_idx = layer_idx  # used for deterministic seeding of projection matrices
+
+        # Reference to the model-level ModuleDict (set during update_layer).
+        # PyTorch won't double-register the same ModuleDict object across layers.
+        self.tinylora_v: Optional[nn.ModuleDict] = None
+
+        # Direct references to this adapter's v parameter, cached for O(1) forward pass access.
+        # Plain dict to avoid PyTorch double-registering the same Parameter.
+        self._tinylora_v_ref: dict[str, nn.Parameter] = {}
+
+        # Frozen SVD components as buffers (following LoRA-XS convention)
+        # tinylora_A corresponds to V from SVD (shape: r x in_features)
+        # tinylora_B corresponds to U @ diag(S) from SVD (shape: out_features x r)
+        self.tinylora_A = BufferDict({}, persistent=True)
+        self.tinylora_B = BufferDict({}, persistent=True)
+
+        # Fixed random projection tensors P ∈ R^{u×r×r}
+        self.tinylora_P = BufferDict({}, persistent=True)
+
+        # Mark the weight as unmerged
+        self._disable_adapters = False
+        self.merged_adapters = []
+
+        self.in_features, self.out_features = _get_in_out_features(self.get_base_layer())
+        self.kwargs = kwargs
+
+    def _all_available_adapter_names(self) -> list[str]:
+        """Return a sorted list of all available adapter names."""
+        adapter_names = set()
+        adapter_names.update(self._tinylora_v_ref.keys())
+        for name in self.other_param_names:
+            attr = getattr(self, name, None)
+            if attr is not None and hasattr(attr, "keys"):
+                adapter_names.update(attr.keys())
+        return sorted(adapter_names)
+
+    def delete_adapter(self, adapter_name: str) -> None:
+        """Delete an adapter from the layer."""
+        # Delete direct v reference
+        if adapter_name in self._tinylora_v_ref:
+            del self._tinylora_v_ref[adapter_name]
+
+        # Delete from other params that use adapter name directly
+        for attr in self.other_param_names:
+            param_dict = getattr(self, attr, None)
+            if param_dict is not None and adapter_name in param_dict:
+                del param_dict[adapter_name]
+
+        # Delete r and u tracking
+        if adapter_name in self.r:
+            del self.r[adapter_name]
+        if adapter_name in self.u:
+            del self.u[adapter_name]
+
+        # Delete dropout layer
+        if adapter_name in self.tinylora_dropout:
+            del self.tinylora_dropout[adapter_name]
+
+        # Handle active adapters
+        if adapter_name in self.active_adapters:
+            active_adapters = self.active_adapters[:]
+            active_adapters.remove(adapter_name)
+            if active_adapters:
+                self.set_adapter(active_adapters)
+            else:
+                remaining_adapters = self._all_available_adapter_names()
+                if not remaining_adapters:
+                    self.set_adapter([])
+                else:
+                    new_active_adapter = remaining_adapters[0]
+                    warnings.warn(
+                        f"Adapter {adapter_name} was active which is now deleted. Setting active adapter to "
+                        f"{new_active_adapter}."
+                    )
+                    self.set_adapter(new_active_adapter)
+
+    def supports_lora_conversion(self, adapter_name: str = "default") -> bool:
+        return True
+
+    def _get_layer_seed(self, adapter_name: str, base_seed: int) -> int:
+        """Get a deterministic seed for this layer's projection matrices."""
+        return base_seed + self._layer_idx
+
+    def update_layer(
+        self,
+        adapter_name: str,
+        tinylora_v: nn.ModuleDict,
+        v_key: str,
+        r: int,
+        config: TinyLoraConfig,
+        **kwargs,
+    ) -> None:
+        """Initialize layer with SVD decomposition and projection tensors."""
+        # Extract config values
+        u = config.u
+        tinylora_dropout = config.tinylora_dropout
+        projection_seed = config.projection_seed
+        inference_mode = config.inference_mode
+        fan_in_fan_out = config.fan_in_fan_out
+
+        if r <= 0:
+            raise ValueError(f"`r` should be a positive integer value but the value passed is {r}")
+        if u <= 0:
+            raise ValueError(f"`u` should be a positive integer value but the value passed is {u}")
+
+        self.u[adapter_name] = u
+
+        if tinylora_dropout > 0.0:
+            tinylora_dropout_layer = nn.Dropout(p=tinylora_dropout)
+        else:
+            tinylora_dropout_layer = nn.Identity()
+
+        self.tinylora_dropout.update(nn.ModuleDict({adapter_name: tinylora_dropout_layer}))
+
+        # Store reference to model-level ModuleDict (for base class parameter management)
+        self.tinylora_v = tinylora_v
+        # Cache direct reference to this adapter's v parameter for O(1) forward pass access
+        self._tinylora_v_ref[adapter_name] = tinylora_v[adapter_name][v_key]
+
+        # Compute truncated SVD of base weights (following LoRA-XS convention)
+        # actual_r may be less than r if matrix dimensions are smaller
+        self._init_svd(adapter_name, r, fan_in_fan_out)
+
+        # Initialize random projection tensors P using the actual rank
+        self._init_projection(adapter_name, u, projection_seed)
+
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def _init_svd(self, adapter_name: str, r: int, fan_in_fan_out: bool) -> None:
+        """
+        Compute truncated SVD of base weights and store as frozen buffers.
+
+        Compute truncated SVD and distribute singular values to both A and B:
+        - W = U @ S @ V^T (full SVD)
+        - We store: tinylora_A = diag(sqrt(S[:r])) @ V[:r, :] (shape: r x in_features)
+        - We store: tinylora_B = U[:, :r] @ diag(sqrt(S[:r])) (shape: out_features x r)
+
+        Distributing S equally avoids imbalanced norms between A and B. This allows: delta_W = tinylora_B @ R @
+        tinylora_A.
+        """
+        base_layer = self.get_base_layer()
+        weight = base_layer.weight.data
+
+        # Handle Conv1D which stores weights as (in, out)
+        weight = transpose(weight, fan_in_fan_out)
+
+        dtype = weight.dtype
+
+        # Compute SVD in float32 for numerical stability
+        # W has shape (out_features, in_features)
+        weight_fp32 = weight.float()
+        U, S, Vh = torch.linalg.svd(weight_fp32, full_matrices=False)
+
+        # The actual rank is limited by the matrix dimensions
+        max_rank = min(weight.shape[0], weight.shape[1])
+        actual_r = min(r, max_rank)
+
+        # Truncate to actual rank
+        U_r = U[:, :actual_r].to(dtype)
+        S_r = S[:actual_r].to(dtype)
+        V_r = Vh[:actual_r, :].to(dtype)
+        sqrt_S_r = torch.sqrt(S_r)
+
+        # Distribute singular values equally to both A and B via sqrt(S_r)
+        # tinylora_A = diag(sqrt(S_r)) @ V_r (actual_r x in_features)
+        # tinylora_B = U_r @ diag(sqrt(S_r)) (out_features x actual_r)
+        # Use .contiguous() to ensure tensors can be saved with safetensors
+        self.tinylora_A[adapter_name] = (sqrt_S_r.unsqueeze(1) * V_r).contiguous()
+        self.tinylora_B[adapter_name] = (U_r * sqrt_S_r.unsqueeze(0)).contiguous()
+        self.r[adapter_name] = actual_r
+
+    def _init_projection(self, adapter_name: str, u: int, base_seed: int):
+        """Initialize fixed random projection tensors P ∈ R^{u×r×r}."""
+        seed = self._get_layer_seed(adapter_name, base_seed)
+        gen = torch.Generator().manual_seed(seed)
+        r = self.r[adapter_name]
+
+        # P has shape (u, r, r)
+        # Note: The paper describes P as "fixed random matrices" but does not specify the distribution.
+        # We sample from N(0, 1/r) which is standard for random projections
+        # (see Johnson-Lindenstrauss lemma: https://en.wikipedia.org/wiki/Johnson-Lindenstrauss_lemma).
+        P = torch.normal(mean=0.0, std=1.0 / (r**0.5), size=(u, r, r), generator=gen)
+        self.tinylora_P[adapter_name] = P
+
+    def _compute_R(self, adapter_name: str) -> torch.Tensor:
+        """Reconstruct R matrix from v and P: R = sum_i(v[i] * P[i])."""
+        v = self._tinylora_v_ref[adapter_name]  # Shape: (u,)
+        P = self.tinylora_P[adapter_name]  # Shape: (u, r, r)
+
+        # Move P to same device/dtype as v
+        P = P.to(device=v.device, dtype=v.dtype)
+
+        # R = sum over i of v[i] * P[i]
+        R = torch.einsum("i,ijk->jk", v, P)  # Shape: (r, r)
+        return R
+
+    def get_delta_weight(self, adapter_name: str) -> torch.Tensor:
+        """
+        Compute delta_W = tinylora_B @ R @ tinylora_A for merging.
+
+        Returns weight update in the same shape as the base layer weight. For Conv1D layers (fan_in_fan_out=True), the
+        result is transposed to match the (in_features, out_features) convention.
+        """
+        A = self.tinylora_A[adapter_name]  # (r, in_features)
+        B = self.tinylora_B[adapter_name]  # (out_features, r)
+        R = self._compute_R(adapter_name)  # (r, r)
+
+        device = A.device
+        dtype = A.dtype
+
+        # Move components to same device/dtype
+        B = B.to(device=device, dtype=dtype)
+        R = R.to(device=device, dtype=dtype)
+
+        # In case users wants to merge the adapter weights that are in
+        # (b)float16 while being on CPU, we need to cast the weights to float32
+        cast_to_fp32 = device.type == "cpu" and (dtype == torch.float16 or dtype == torch.bfloat16)
+
+        if cast_to_fp32:
+            A = A.float()
+            B = B.float()
+            R = R.float()
+
+        # delta_W = B @ R @ A
+        # B: (out, r), R: (r, r), A: (r, in)
+        # Result: (out, in)
+        delta = B @ R @ A
+
+        # Transpose for Conv1D layers which store weights as (in, out)
+        fan_in_fan_out = getattr(self, "fan_in_fan_out", False)
+        delta = transpose(delta, fan_in_fan_out)
+
+        if cast_to_fp32:
+            delta = delta.to(dtype=dtype)
+
+        return delta
+
+
+class Linear(nn.Linear, TinyLoraLayer):
+    """TinyLoRA implemented in a dense layer."""
+
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        tinylora_v: nn.ModuleDict,
+        v_key: str,
+        adapter_name: str,
+        config: TinyLoraConfig,
+        **kwargs,
+    ) -> None:
+        # this gets the init from nn.Linear's super perspective, i.e. nn.Module.__init__
+        super(nn.Linear, self).__init__()
+        TinyLoraLayer.__init__(self, base_layer, **kwargs)
+
+        self.fan_in_fan_out = config.fan_in_fan_out
+
+        self._active_adapter = adapter_name
+        self.update_layer(
+            adapter_name,
+            tinylora_v,
+            v_key,
+            config.r,
+            config,
+        )
+        self.is_target_conv_1d_layer = kwargs.get("is_target_conv_1d_layer", False)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights.
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.tinylora_A.keys():
+                base_layer = self.get_base_layer()
+                if safe_merge:
+                    orig_weights = base_layer.weight.data.clone()
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    orig_weights += delta_weight
+
+                    if not torch.isfinite(orig_weights).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = orig_weights
+                else:
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    base_layer.weight.data += delta_weight
+
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """Unmerge all merged adapters from the base weights."""
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.tinylora_A.keys():
+                delta_weight = self.get_delta_weight(active_adapter)
+                self.get_base_layer().weight.data -= delta_weight
+
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        previous_dtype = x.dtype
+
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.tinylora_A.keys():
+                    continue
+
+                A = self.tinylora_A[active_adapter]  # (r, in_features)
+                B = self.tinylora_B[active_adapter]  # (out_features, r)
+                R = self._compute_R(active_adapter)  # (r, r)
+
+                dropout = self.tinylora_dropout[active_adapter]
+                x_dropped = dropout(x)
+                x_dropped = x_dropped.to(A.dtype)
+
+                # Move components to input device
+                device = x_dropped.device
+                A = A.to(device)
+                B = B.to(device)
+                R = R.to(device)
+
+                # Forward computation following LoRA-XS pattern:
+                # delta = x @ A^T @ R^T @ B^T
+                # Using F.linear(x, W) = x @ W^T:
+                # h = F.linear(x, A) -> x @ A^T -> (batch, seq, r)
+                # h = F.linear(h, R) -> h @ R^T -> (batch, seq, r)
+                # delta = F.linear(h, B) -> h @ B^T -> (batch, seq, out)
+                h = F.linear(x_dropped, A)  # (batch, seq, r)
+                h = F.linear(h, R)  # (batch, seq, r)
+                delta = F.linear(h, B)  # (batch, seq, out)
+
+                result = result + delta
+
+        result = result.to(previous_dtype)
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "tinylora." + rep
+
+
+class Embedding(nn.Module, TinyLoraLayer):
+    """TinyLoRA implemented in an Embedding layer."""
+
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        tinylora_v: nn.ModuleDict,
+        v_key: str,
+        adapter_name: str,
+        config: TinyLoraConfig,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        TinyLoraLayer.__init__(self, base_layer, **kwargs)
+
+        self._active_adapter = adapter_name
+        self.update_layer(
+            adapter_name,
+            tinylora_v,
+            v_key,
+            config.r,
+            config,
+        )
+
+    def update_layer(
+        self,
+        adapter_name: str,
+        tinylora_v: nn.ModuleDict,
+        v_key: str,
+        r: int,
+        config,
+        **kwargs,
+    ) -> None:
+        """Initialize layer with SVD decomposition and projection tensors."""
+        # Extract config values
+        u = config.u
+        tinylora_dropout = config.tinylora_dropout
+        projection_seed = config.projection_seed
+        inference_mode = config.inference_mode
+
+        if r <= 0:
+            raise ValueError(f"`r` should be a positive integer value but the value passed is {r}")
+        if u <= 0:
+            raise ValueError(f"`u` should be a positive integer value but the value passed is {u}")
+
+        self.u[adapter_name] = u
+
+        if tinylora_dropout > 0.0:
+            tinylora_dropout_layer = nn.Dropout(p=tinylora_dropout)
+        else:
+            tinylora_dropout_layer = nn.Identity()
+
+        self.tinylora_dropout.update(nn.ModuleDict({adapter_name: tinylora_dropout_layer}))
+
+        # Store reference to model-level ModuleDict (for base class parameter management)
+        self.tinylora_v = tinylora_v
+        # Cache direct reference to this adapter's v parameter for O(1) forward pass access
+        self._tinylora_v_ref[adapter_name] = tinylora_v[adapter_name][v_key]
+
+        # Compute truncated SVD of embedding weights
+        self._init_svd_embedding(adapter_name, r)
+
+        # Initialize random projection tensors P using the actual rank
+        self._init_projection(adapter_name, u, projection_seed)
+
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def _init_svd_embedding(self, adapter_name: str, r: int) -> None:
+        """
+        Compute truncated SVD of embedding weights and store as frozen buffers.
+
+        Embedding weight shape: (num_embeddings, embedding_dim) We treat this as W where:
+        - W = U @ S @ V^T (full SVD)
+        - tinylora_A = diag(sqrt(S[:r])) @ V[:r, :] (shape: r x embedding_dim)
+        - tinylora_B = U[:, :r] @ diag(sqrt(S[:r])) (shape: num_embeddings x r)
+        """
+        base_layer = self.get_base_layer()
+        weight = base_layer.weight.data  # (num_embeddings, embedding_dim)
+
+        dtype = weight.dtype
+
+        # Compute SVD in float32 for numerical stability
+        weight_fp32 = weight.float()
+        U, S, Vh = torch.linalg.svd(weight_fp32, full_matrices=False)
+
+        # The actual rank is limited by the matrix dimensions
+        max_rank = min(weight.shape[0], weight.shape[1])
+        actual_r = min(r, max_rank)
+
+        # Truncate to actual rank
+        U_r = U[:, :actual_r].to(dtype)
+        S_r = S[:actual_r].to(dtype)
+        V_r = Vh[:actual_r, :].to(dtype)
+        sqrt_S_r = torch.sqrt(S_r)
+
+        # Distribute singular values equally to both A and B via sqrt(S_r)
+        self.tinylora_A[adapter_name] = (sqrt_S_r.unsqueeze(1) * V_r).contiguous()
+        self.tinylora_B[adapter_name] = (U_r * sqrt_S_r.unsqueeze(0)).contiguous()
+        self.r[adapter_name] = actual_r
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """Merge the active adapter weights into the base weights."""
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.tinylora_A.keys():
+                base_layer = self.get_base_layer()
+                if safe_merge:
+                    orig_weights = base_layer.weight.data.clone()
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    orig_weights += delta_weight
+
+                    if not torch.isfinite(orig_weights).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = orig_weights
+                else:
+                    delta_weight = self.get_delta_weight(active_adapter)
+                    base_layer.weight.data += delta_weight
+
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """Unmerge all merged adapters from the base weights."""
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.tinylora_A.keys():
+                delta_weight = self.get_delta_weight(active_adapter)
+                self.get_base_layer().weight.data -= delta_weight
+
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            return self.base_layer(x, *args, **kwargs)
+
+        if self.merged:
+            return self.base_layer(x, *args, **kwargs)
+
+        result = self.base_layer(x, *args, **kwargs)
+
+        for active_adapter in self.active_adapters:
+            if active_adapter not in self.tinylora_A.keys():
+                continue
+
+            A = self.tinylora_A[active_adapter]  # (r, embedding_dim)
+            B = self.tinylora_B[active_adapter]  # (num_embeddings, r)
+            R = self._compute_R(active_adapter)  # (r, r)
+
+            dropout = self.tinylora_dropout[active_adapter]
+
+            # Move components to input device
+            device = result.device
+            dtype = result.dtype
+            A = A.to(device=device, dtype=dtype)
+            B = B.to(device=device, dtype=dtype)
+            R = R.to(device=device, dtype=dtype)
+
+            # For embedding, we need to:
+            # 1. Look up B[x] to get the low-rank representation (batch, seq, r)
+            # 2. Multiply by R to get (batch, seq, r)
+            # 3. Multiply by A to get the delta (batch, seq, embedding_dim)
+            # delta = B[x] @ R @ A
+
+            # B[x]: embedding lookup in the low-rank space
+            after_B = F.embedding(x, B)  # (batch, seq, r)
+            after_B = dropout(after_B)
+
+            # Multiply by R and A
+            after_R = after_B @ R  # (batch, seq, r)
+            delta = after_R @ A  # (batch, seq, embedding_dim)
+
+            result = result + delta
+
+        return result
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "tinylora." + rep
diff --git a/src/peft/tuners/tinylora/model.py b/src/peft/tuners/tinylora/model.py
new file mode 100644
index 0000000..bf10cf6
--- /dev/null
+++ b/src/peft/tuners/tinylora/model.py
@@ -0,0 +1,306 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+import warnings
+
+import torch
+from torch import nn
+from transformers.pytorch_utils import Conv1D
+
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer
+from peft.utils import (
+    TRANSFORMERS_MODELS_TO_TINYLORA_TARGET_MODULES_MAPPING,
+)
+
+from ..tuners_utils import _maybe_include_all_linear_layers
+from .config import TinyLoraConfig
+from .layer import Embedding, Linear, TinyLoraLayer
+
+
+class TinyLoraModel(BaseTuner):
+    """
+    Creates TinyLoRA model from a pretrained transformers model.
+
+    TinyLoRA is an extremely parameter-efficient fine-tuning method that uses SVD decomposition of frozen weights and
+    projects a tiny trainable vector through fixed random tensors. Based on the paper "Learning to Reason in 13
+    Parameters" (arXiv:2602.04118).
+
+    Args:
+        model ([`~transformers.PreTrainedModel`]): The model to be adapted.
+        config ([`TinyLoraConfig`]): The configuration of the TinyLoRA model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+        low_cpu_mem_usage (`bool`, *optional*, defaults to `False`):
+            Create empty adapter weights on meta device. Useful to speed up the loading process.
+
+    Returns:
+        `torch.nn.Module`: The TinyLoRA model.
+
+    Example:
+        ```python
+        >>> from transformers import AutoModelForCausalLM
+        >>> from peft import TinyLoraConfig, get_peft_model
+
+        >>> base_model = AutoModelForCausalLM.from_pretrained("facebook/opt-125m")
+        >>> config = TinyLoraConfig(r=2, u=64, target_modules=["q_proj", "v_proj"])
+        >>> model = get_peft_model(base_model, config)
+        ```
+
+    **Attributes**:
+        - **model** ([`~transformers.PreTrainedModel`]) -- The model to be adapted.
+        - **peft_config** ([`TinyLoraConfig`]): The configuration of the TinyLoRA model.
+    """
+
+    prefix: str = "tinylora_"
+    tuner_layer_cls = TinyLoraLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_TINYLORA_TARGET_MODULES_MAPPING
+
+    def __init__(self, model, config, adapter_name, low_cpu_mem_usage=False, **kwargs):
+        super().__init__(model, config, adapter_name, low_cpu_mem_usage, **kwargs)
+
+    def _init_tinylora_v(self, config: TinyLoraConfig, adapter_name: str) -> None:
+        """Re-initialize the tinylora_v vectors with uniform random values."""
+        if adapter_name in self.tinylora_v:
+            for v in self.tinylora_v[adapter_name].values():
+                nn.init.uniform_(v, -config.init_v_bound, config.init_v_bound)
+
+    def _pre_injection_hook(self, model: nn.Module, config: TinyLoraConfig, adapter_name: str) -> None:
+        """Initialize shared trainable vectors on first adapter creation."""
+        # Nested structure: tinylora_v[adapter_name][str(group_idx)] = nn.Parameter
+        if not hasattr(self, "tinylora_v"):
+            self.tinylora_v = nn.ModuleDict({})
+
+    def _build_target_key_mapping(self, config: TinyLoraConfig) -> dict[str, int]:
+        """Build an ordered mapping from target module key to index.
+
+        Iterates the model in the same order as ``inject_adapter`` to assign each target module a deterministic index
+        used for group assignment (weight_tying) and projection seeding.
+        """
+        model_config = self.get_model_config(self.model)
+        peft_config = self._prepare_adapter_config(config, model_config)
+        peft_config = _maybe_include_all_linear_layers(peft_config, self.model)
+
+        # Also match TinyLoraLayer since modules may already be wrapped when adding a second adapter
+        target_types = (nn.Linear, Conv1D, nn.Embedding, TinyLoraLayer)
+
+        mapping: dict[str, int] = {}
+        idx = 0
+        for key, module in self.model.named_modules():
+            if not self._check_target_module_exists(peft_config, key):
+                continue
+            if isinstance(module, target_types):
+                mapping[key] = idx
+                idx += 1
+
+        return mapping
+
+    def _check_new_adapter_config(self, config: TinyLoraConfig) -> None:
+        """Check the config when a new adapter is being added."""
+        super()._check_new_adapter_config(config)
+
+        save_projection_unique_values = sorted({c.save_projection for c in self.peft_config.values()})
+        if len(save_projection_unique_values) > 1:
+            raise TypeError(
+                "TinyLoRA projection tensors must be saved for all adapters or none, but got multiple different values: "
+                f"{save_projection_unique_values}"
+            )
+
+    def _create_and_replace(
+        self,
+        tinylora_config: TinyLoraConfig,
+        adapter_name: str,
+        target: nn.Module,
+        target_name: str,
+        parent: nn.Module,
+        current_key: str,
+        **optional_kwargs,
+    ):
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+
+        # Build the target key mapping lazily on first call per injection cycle.
+        # This is needed because add_adapter calls inject_adapter directly without _pre_injection_hook.
+        if not hasattr(self, "_target_key_to_idx") or current_key not in self._target_key_to_idx:
+            self._target_key_to_idx = self._build_target_key_mapping(tinylora_config)
+
+        # Look up the deterministic index for this module
+        layer_idx = self._target_key_to_idx[current_key]
+        num_target_layers = len(self._target_key_to_idx)
+
+        # Determine the group for this layer based on weight_tying
+        # weight_tying=0.0 → num_groups = num_target_layers (no sharing)
+        # weight_tying=1.0 → num_groups = 1 (full sharing)
+        num_groups = max(1, round(num_target_layers * (1.0 - tinylora_config.weight_tying)))
+        group_size = max(1, num_target_layers // num_groups)
+        group_idx = min(layer_idx // group_size, num_groups - 1)
+        v_key = str(group_idx)
+
+        # Initialize the adapter's ParameterDict if not present
+        if adapter_name not in self.tinylora_v:
+            self.tinylora_v[adapter_name] = nn.ParameterDict({})
+
+        # Initialize v for this group if not already done
+        if v_key not in self.tinylora_v[adapter_name]:
+            # Get dtype from target layer's weight
+            if hasattr(target, "weight"):
+                dtype = target.weight.dtype
+            else:
+                dtype = None  # Will default to float32
+            v = nn.Parameter(torch.empty(tinylora_config.u, dtype=dtype))
+            if tinylora_config.init_weights is True:
+                # Default: initialize to zeros for identity/no-op operation
+                nn.init.zeros_(v)
+            elif tinylora_config.init_weights == "uniform":
+                nn.init.uniform_(v, -tinylora_config.init_v_bound, tinylora_config.init_v_bound)
+            # If init_weights is False, leave v uninitialized
+            self.tinylora_v[adapter_name][v_key] = v
+
+        if isinstance(target, TinyLoraLayer):
+            target.update_layer(
+                adapter_name,
+                self.tinylora_v,
+                v_key,
+                tinylora_config.r,
+                tinylora_config,
+            )
+        else:
+            new_module = self._create_new_module(
+                tinylora_config, self.tinylora_v, v_key, adapter_name, target, layer_idx=layer_idx
+            )
+
+            if adapter_name not in self.active_adapter:
+                # adding an additional adapter: it is not automatically trainable
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+        # Ensure the shared v parameters remain trainable for the active adapter,
+        # but only if the adapter is not in inference mode
+        if adapter_name in self.active_adapter:
+            inference_mode = getattr(tinylora_config, "inference_mode", False)
+            if not inference_mode:
+                for param in self.tinylora_v[adapter_name].values():
+                    param.requires_grad = True
+
+    @staticmethod
+    def _create_new_module(
+        tinylora_config: TinyLoraConfig,
+        tinylora_v: nn.ModuleDict,
+        v_key: str,
+        adapter_name: str,
+        target: nn.Module,
+        **kwargs,
+    ):
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        if isinstance(target_base_layer, torch.nn.Linear):
+            if tinylora_config.fan_in_fan_out:
+                warnings.warn(
+                    "fan_in_fan_out is set to True but the target module is `torch.nn.Linear`. "
+                    "Setting fan_in_fan_out to False."
+                )
+                tinylora_config.fan_in_fan_out = False
+            new_module = Linear(
+                target,
+                tinylora_v,
+                v_key,
+                adapter_name,
+                tinylora_config,
+                **kwargs,
+            )
+        elif isinstance(target_base_layer, Conv1D):
+            kwargs["is_target_conv_1d_layer"] = True
+            if not tinylora_config.fan_in_fan_out:
+                warnings.warn(
+                    "fan_in_fan_out is set to False but the target module is `Conv1D`. Setting fan_in_fan_out to True."
+                )
+                tinylora_config.fan_in_fan_out = True
+            new_module = Linear(
+                target,
+                tinylora_v,
+                v_key,
+                adapter_name,
+                tinylora_config,
+                **kwargs,
+            )
+        elif isinstance(target_base_layer, torch.nn.Embedding):
+            new_module = Embedding(
+                target,
+                tinylora_v,
+                v_key,
+                adapter_name,
+                tinylora_config,
+                **kwargs,
+            )
+        else:
+            raise TypeError(
+                f"Target module {target} is not supported. Currently, only the following modules are supported: "
+                "`torch.nn.Linear`, `torch.nn.Embedding`, `transformers.pytorch_utils.Conv1D`."
+            )
+
+        return new_module
+
+    def _cast_adapter_dtype(self, adapter_name: str, autocast_adapter_dtype: bool = True) -> None:
+        """
+        Cast the adapter weights to the correct dtype.
+
+        Override to also handle the model-level tinylora_v parameters.
+        """
+        # Call parent implementation for layer-level parameters
+        super()._cast_adapter_dtype(adapter_name, autocast_adapter_dtype)
+
+        if not autocast_adapter_dtype:
+            return
+
+        # Handle model-level tinylora_v parameters
+        dtypes_to_convert_to_fp32 = {torch.float16, torch.bfloat16}
+        if adapter_name in self.tinylora_v:
+            for param in self.tinylora_v[adapter_name].values():
+                if param.dtype in dtypes_to_convert_to_fp32:
+                    param.data = param.data.to(torch.float32)
+
+    def delete_adapter(self, adapter_name: str) -> None:
+        """Delete an adapter and clean up the model-level shared v parameters."""
+        super().delete_adapter(adapter_name)
+
+        # Remove the adapter's shared v parameters from the model-level ModuleDict
+        if adapter_name in self.tinylora_v:
+            del self.tinylora_v[adapter_name]
+
+    def _mark_only_adapters_as_trainable(self, model: nn.Module) -> None:
+        """
+        Mark only the adapter layers as trainable.
+
+        Override the base class method to manage the shared tinylora_v parameters which are stored at the model level
+        and thus invisible to the base class's per-layer logic.
+        """
+        # First, call the parent implementation
+        super()._mark_only_adapters_as_trainable(model)
+
+        # Freeze all tinylora_v parameters first, then selectively unfreeze for active non-inference adapters
+        for adapter_params in self.tinylora_v.values():
+            for param in adapter_params.values():
+                param.requires_grad = False
+
+        for active_adapter in self.active_adapters:
+            if active_adapter in self.peft_config:
+                inference_mode = getattr(self.peft_config[active_adapter], "inference_mode", False)
+                if inference_mode:
+                    continue
+            if active_adapter in self.tinylora_v:
+                for param in self.tinylora_v[active_adapter].values():
+                    param.requires_grad = True
diff --git a/src/peft/tuners/trainable_tokens/__init__.py b/src/peft/tuners/trainable_tokens/__init__.py
new file mode 100644
index 0000000..4aa7bf8
--- /dev/null
+++ b/src/peft/tuners/trainable_tokens/__init__.py
@@ -0,0 +1,33 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from peft.utils import register_peft_method
+
+from .config import TrainableTokensConfig
+from .layer import TrainableTokensLayer
+from .model import TrainableTokensModel
+
+
+__all__ = [
+    "TrainableTokensConfig",
+    "TrainableTokensLayer",
+    "TrainableTokensModel",
+]
+
+register_peft_method(
+    name="trainable_tokens",
+    config_cls=TrainableTokensConfig,
+    model_cls=TrainableTokensModel,
+    is_mixed_compatible=False,
+)
diff --git a/src/peft/tuners/trainable_tokens/config.py b/src/peft/tuners/trainable_tokens/config.py
new file mode 100644
index 0000000..7412d7f
--- /dev/null
+++ b/src/peft/tuners/trainable_tokens/config.py
@@ -0,0 +1,89 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class TrainableTokensConfig(PeftConfig):
+    """
+    Configuration for the `TrainableTokens` method.
+
+    Allows for training new tokens (and re-training existing ones) without training the full embedding matrix. By
+    marking a few select tokens (identified by their indices) trainable and leaving the rest untouched, this method can
+    be used to add new tokens or changing the embedding of existing tokens while saving on memory. Both storage as well
+    as working memory usage are reduced in contrast to training the embedding matrix fully.
+
+    Note that training with FSDP/DeepSpeed might not yet be fully supported.
+
+    Args:
+        token_indices (`list[int]`):
+            List of integers, signifying the indices of the tokens you want to be trainable. To find the index of a
+            token with a tokenizer, you can tokenize the string and look at the returned `input_ids`. The closer the
+            amount of indices is to the total amount of tokens, the less efficient this method gets.
+        target_modules (`Optional[Union[list[str], str]]`):
+            List of module names or regex expression of the module names to replace with our `TrainableTokensLayer`. If
+            not defined, it will attempt to get the model's input embedding layer if the model has a
+            `get_input_embeddings` method (transformer models usually do), if that fails the default is 'embed_tokens'.
+            Other example targets are `embedding`, `encoder.embeddings` or `decoder.embeddings`.
+        init_weights (`bool`):
+            By default the new token weights are initialized to be the same as the respective token embeddings. This
+            makes TrainableTokens a no-op when not trained. If set to `False` the weights will be random values. Do not
+            change this setting unless you know exactly what you're doing.
+    """
+
+    token_indices: list[int] = field(
+        default_factory=list,
+        metadata={
+            "help": (
+                "List of integers, signifying the indices of the tokens you want to be trainable. "
+                "To find the index of a token with a tokenizer, you can tokenize the string and "
+                "look at the returned `input_ids`. The closer the amount of indices is to the total amount of "
+                "tokens, the less efficient this method gets."
+            )
+        },
+    )
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of module names or regex expression of the module names to replace with our "
+                "`TrainableTokensLayer`. If not defined, it will default to the model's input embedding layer if "
+                "the model has a `get_input_embeddings` method (transformer models usually do), if that fails the "
+                "default is 'embed_tokens'. Other example targets could be `embedding`, `encoder.embeddings` or "
+                "`decoder.embeddings`."
+            ),
+        },
+    )
+
+    init_weights: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "By default the new token weights are initialized to be the same as the respective token embeddings. "
+                "This makes TrainableTokens a no-op when not trained. If set to `False` the weights will be random "
+                "values. Do not change this setting unless you know exactly what you're doing. "
+            )
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.TRAINABLE_TOKENS
diff --git a/src/peft/tuners/trainable_tokens/layer.py b/src/peft/tuners/trainable_tokens/layer.py
new file mode 100644
index 0000000..add1885
--- /dev/null
+++ b/src/peft/tuners/trainable_tokens/layer.py
@@ -0,0 +1,274 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+import warnings
+from typing import Optional
+
+import torch
+import torch.distributed as dist
+import torch.nn.functional as F
+from torch import nn
+
+from peft.tuners._buffer_dict import BufferDict
+from peft.tuners.tuners_utils import BaseTunerLayer, _get_in_out_features, check_adapters_to_merge
+from peft.utils.integrations import check_deepspeed_zero3_enabled, gather_params_ctx
+
+from .config import TrainableTokensConfig
+
+
+class TrainableTokensLayer(nn.Module, BaseTunerLayer):
+    # All names of layers that may contain (trainable) adapter weights
+    adapter_layer_names = ("trainable_tokens_delta",)
+
+    # All names of other parameters that may contain adapter-related parameters
+    other_param_names = ("token_indices", "trainable_tokens_original")
+
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        adapter_name: str,
+        config: TrainableTokensConfig | dict | None = None,
+        tied_adapter: Optional[TrainableTokensLayer] = None,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+
+        self.base_layer = base_layer
+        self._active_adapter = adapter_name
+        self.kwargs = kwargs
+
+        # wrap the tied adapter in a list so that it is excluded from .(named_)modules() and, therefore,
+        # not included in the state dict since it would be a copy of the tied adapter anyway.
+        self._tied_adapter = [tied_adapter] if tied_adapter else []
+
+        # we store the updated weights of particular tokens and their originals. we assume
+        # that the count of new tokens is far smaller than the number of total tokens.
+        #
+        # In case we have weight tying with another token adapter, we'll have no actual
+        # references on our own but use everything from the tied adapter.
+        if not self.tied_adapter:
+            self.trainable_tokens_delta = nn.ParameterDict({})
+            self.trainable_tokens_original = BufferDict({})
+            self.token_indices = {}
+        else:
+            self.trainable_tokens_delta = self.tied_adapter.trainable_tokens_delta
+            self.trainable_tokens_original = self.tied_adapter.trainable_tokens_original
+            self.token_indices = self.tied_adapter.token_indices
+
+        # Mark the weight as unmerged
+        self.merged_adapters = []
+
+        in_features, out_features = _get_in_out_features(self.get_base_layer())
+        self.in_features = in_features
+        self.out_features = out_features
+
+    @property
+    def tied_adapter(self):
+        if self._tied_adapter:
+            return self._tied_adapter[0]
+        return None
+
+    def _collect_token_weights(self, weight: torch.Tensor, rows: torch.Tensor, embed_dim: int) -> torch.Tensor:
+        """DeepSpeed zero3 specific code to initialize trainable tokens.
+
+        Ensures that only the necessary weights are collected to a single rank, initialized, and then shared with all
+        ranks.
+        """
+        src_rank = 0
+        # right now, only CUDA is implemented
+        device = torch.device("cuda", torch.cuda.current_device())
+
+        with gather_params_ctx([weight], modifier_rank=None):
+            if dist.is_available() and dist.is_initialized() and dist.get_rank() == src_rank:
+                token_weights = weight[rows].clone()
+            else:
+                # build an empty tensor with correct shape/type/device
+                token_weights = torch.empty(
+                    (len(rows), embed_dim),
+                    dtype=weight.dtype,
+                    device=device,
+                )
+
+        # share the weights with all ranks
+        dist.broadcast(token_weights, src=src_rank)
+        return token_weights
+
+    def update_layer(
+        self,
+        adapter_name,
+        config: TrainableTokensConfig | None = None,
+        tied_adapter: nn.Module | None = None,
+        **kwargs,
+    ):
+        # config can be None when update_layer is called through _set_trainable, in which case the relevant
+        # arguments should be in kwargs
+        if tied_adapter is not None:
+            # as a tied adapter, we're just following whatever the adapter we're tied to does, we don't update anything.
+            return
+
+        token_indices = config.token_indices if (config is not None) else kwargs["token_indices"]
+        init_weights = config.init_weights if (config is not None) else kwargs.get("init_weights", True)
+
+        self.token_indices[adapter_name] = token_indices
+
+        # we initialize the delta embedding weights from the base embedding matrix and replace values instead of
+        # adding/subtracting deltas. we do it this way and use `embedding.weight.index_copy()` to write the updated
+        # values during `forward()` to avoid that the user resizing the embedding matrix, effectively filling the new
+        # token space with random values, training the model with TrainableTokensLayer, initializing the model anew -
+        # thus re-initializing the new embeddings again with new random variables. If we would add/subtract deltas
+        # onto the new values, we would get undefined behavior. By replacing the specific token values we always
+        # get defined behavior.
+        weight = self.get_base_layer().weight
+
+        if hasattr(self.get_base_layer(), "embedding_dim"):
+            embed_dim = self.get_base_layer().embedding_dim
+        else:
+            # lm_head doesn't have embedding_dim attribute
+            embed_dim = self.get_base_layer().in_features
+
+        if init_weights:
+            if check_deepspeed_zero3_enabled():
+                values = self._collect_token_weights(weight, self.token_indices[adapter_name], embed_dim)
+            else:
+                values = self.weight[self.token_indices[adapter_name]]
+        else:
+            # random init with matching dtype/device
+            values = torch.randn(
+                (len(self.token_indices[adapter_name]), embed_dim),
+                dtype=weight.dtype,
+                device=weight.device,
+            )
+
+        self.trainable_tokens_delta[adapter_name] = nn.Parameter(values.clone(), requires_grad=True)
+        self.trainable_tokens_original[adapter_name] = values.clone()
+
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+
+    def _check_overlapping_tokens(self, adapter_names):
+        """Raises an error if the token indices of the given adapter names are overlapping.
+        This is currently not supported and can lead to undefined behavior of the model if no specific merging between
+        the overlapping indices' values is applied.
+        """
+        if len(adapter_names) <= 1:
+            return
+
+        indices = set()
+
+        # we take already merged adapters into account as well since they can be overridden by new adapters as well.
+        for adapter_name in set(adapter_names + self.merged_adapters):
+            index_set = set(self.token_indices[adapter_name])
+            if len(indices.intersection(index_set)):
+                raise ValueError(
+                    f"Token indices of adapter {adapter_name} are already defined and would result in "
+                    "undefined merging behavior. Only disjunct token indices are currently supported."
+                )
+            indices.update(index_set)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        self._check_overlapping_tokens(adapter_names)
+
+        merged = self.base_layer.weight.data
+
+        for adapter_name in adapter_names:
+            index = torch.tensor(self.token_indices[adapter_name]).to(merged.device)
+            deltas = self.trainable_tokens_delta[adapter_name].to(merged)
+            merged = merged.index_copy(dim=0, index=index, source=deltas)
+
+            if safe_merge and not torch.isfinite(merged).all():
+                raise ValueError(f"NaNs detected in the merged weights. The adapter {adapter_name} seems to be broken")
+
+        self.base_layer.weight.data = merged
+        self.merged_adapters.extend(adapter_names)
+
+    def unmerge(self) -> None:
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+
+        while len(self.merged_adapters) > 0:
+            adapter_name = self.merged_adapters.pop()
+
+            index = torch.tensor(self.token_indices[adapter_name]).to(self.base_layer.weight.device)
+            originals = self.trainable_tokens_original[adapter_name].to(self.base_layer.weight)
+            self.base_layer.weight.data.index_copy_(dim=0, index=index, source=originals)
+
+    def get_merged_weights(self, active_adapters) -> torch.Tensor:
+        W = self.base_layer.weight
+
+        for adapter_name in active_adapters:
+            index = torch.tensor(self.token_indices[adapter_name]).to(W.device)
+            deltas = self.trainable_tokens_delta[adapter_name].to(W)
+            W = W.index_copy(dim=0, index=index, source=deltas)
+
+        # Note: the return type is a Tensor, not an nn.Parameter. This can lead to some errors, e.g. torch's
+        # model.get_parameter fails as it does a type check. But we cannot return an nn.Parameter here, as it can lead
+        # to other failures, as this is not a true nn.Parameter of the model.
+        return W
+
+    def forward_adapters(self, x: torch.Tensor, active_adapters, *args, **kwargs) -> torch.Tensor:
+        if self.disable_adapters or not active_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            self._check_overlapping_tokens(active_adapters)
+
+            W = self.get_merged_weights(active_adapters)
+
+            # Normally it should be very clear that we're wrapping Embedding layers but there are cases, such as
+            # tying weights with an LM head where the layer we wrap is a Linear layer. Therefore we must choose
+            # accordingly.
+            #
+            # TODO: the isinstance checks, especially the one for nn.Linear, may not hold for quantized layers;
+            # TODO: we may need to find a better way to detect quantized layers.
+            if isinstance(self.base_layer, torch.nn.Embedding):
+                result = F.embedding(
+                    input=x,
+                    weight=W,
+                    padding_idx=self.base_layer.padding_idx,
+                    max_norm=self.base_layer.max_norm,
+                    norm_type=self.base_layer.norm_type,
+                    scale_grad_by_freq=self.base_layer.scale_grad_by_freq,
+                    sparse=self.base_layer.sparse,
+                )
+                # Some embedding layers (e.g., Gemma3TextScaledWordEmbedding) apply scaling in their forward method.
+                # Since we're using F.embedding directly, we need to apply this scaling manually.
+                embed_scale = self._get_embed_scale()
+                if embed_scale is not None:
+                    result = result * embed_scale.to(result.dtype)
+            elif isinstance(self.base_layer, torch.nn.Linear):
+                # Probably a tied adapter that wraps an LM head.
+                result = F.linear(
+                    input=x,
+                    weight=W,
+                )
+            else:
+                raise ValueError(
+                    "TrainableTokensLayer wraps an unknown layer type, maybe you are targeting the wrong layer?"
+                )
+
+        return result
+
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        return self.forward_adapters(x, self.active_adapters, *args, **kwargs)
diff --git a/src/peft/tuners/trainable_tokens/model.py b/src/peft/tuners/trainable_tokens/model.py
new file mode 100644
index 0000000..2fcff41
--- /dev/null
+++ b/src/peft/tuners/trainable_tokens/model.py
@@ -0,0 +1,135 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+from torch import nn
+
+from peft.config import PeftConfig
+from peft.tuners.tuners_utils import BaseTuner
+from peft.utils import _get_input_embeddings_name, _get_submodules
+
+from .layer import TrainableTokensLayer
+
+
+class TrainableTokensModel(BaseTuner):
+    prefix: str = "trainable_tokens_"
+    tuner_layer_cls = TrainableTokensLayer
+
+    def _prepare_adapter_config(self, peft_config, model_config):
+        # target_modules can be none which prompts us to infer the embedding layer name ourselves.
+        if peft_config.target_modules is None:
+            peft_config.target_modules = _get_input_embeddings_name(self.model, "embed_tokens")
+
+        return peft_config
+
+    def inject_adapter(
+        self,
+        model: nn.Module,
+        adapter_name: str,
+        autocast_adapter_dtype: bool = True,
+        low_cpu_mem_usage: bool = False,
+        **kwargs,
+    ) -> None:
+        super().inject_adapter(
+            model=model,
+            adapter_name=adapter_name,
+            autocast_adapter_dtype=autocast_adapter_dtype,
+            low_cpu_mem_usage=low_cpu_mem_usage,
+            **kwargs,
+        )
+
+        model_config = self.get_model_config(self)
+
+        # In case of weight-tying we need to adapt the tied weights as well and use tie the embedding adapter.
+        #
+        # The TrainableTokensLayer supports being tied to another TrainableTokensLayer meaning that the layer will
+        # not do any changes on its own but solely rely on the weights from the tied adapter. We will search for the
+        # tied weights and put tied TrainableTokensLayer adapters on them, all tied to the adapter of the embedding
+        # matrix.
+        tied_weights_module_names = self._get_module_names_tied_with_embedding()
+
+        if (
+            tied_weights_module_names
+            and model_config.get("tie_word_embeddings", False)
+            and isinstance(self.model.get_input_embeddings(), TrainableTokensLayer)
+        ):
+            # disable removing of duplicates since we're essentially only dealing with duplicates (i.e. tied weights)
+            for name, module in self.model.named_modules(remove_duplicate=False):
+                matched_keys = [target_key for target_key in tied_weights_module_names if name.endswith(target_key)]
+                if matched_keys:
+                    parent, target, target_name = _get_submodules(model, name)
+                    peft_config = self.peft_config[adapter_name]
+
+                    # If the module is already a TrainableTokensLayer, we need to replace it with a tied version
+                    # instead of just updating it. This handles the case where the user explicitly targeted
+                    # both the embedding and tied layers in target_modules.
+                    if isinstance(target, TrainableTokensLayer):
+                        # Replace the existing layer with a new one that's tied to the embedding
+                        tied_adapter = self.model.get_input_embeddings()
+                        new_module = self._create_new_module(
+                            peft_config, adapter_name, target.base_layer, tied_adapter=tied_adapter
+                        )
+                        self._replace_module(parent, target_name, new_module, target.base_layer)
+                    else:
+                        # Module hasn't been wrapped yet, create and replace normally
+                        tied_adapter = self.model.get_input_embeddings()
+                        self._create_and_replace(
+                            peft_config,
+                            adapter_name,
+                            target,
+                            target_name,
+                            parent,
+                            matched_keys[0],
+                            tied_adapter=tied_adapter,
+                        )
+
+    def _get_tied_target_modules(self, *args, **kwargs):
+        # Normally this method would return the layers that target tied layers.
+        #
+        # We override this method since we explicitly support tied weights tied to the embedding layer.
+        # Therefore, we don't need the warning issued by returning the modules here.
+        return []
+
+    def _create_and_replace(
+        self,
+        peft_config: PeftConfig,
+        adapter_name: str,
+        target: nn.Module,
+        target_name: str,
+        parent: nn.Module,
+        current_key: str,
+        tied_adapter: nn.Module | None = None,
+    ) -> None:
+        if isinstance(target, TrainableTokensLayer):
+            target.update_layer(adapter_name, config=peft_config, tied_adapter=tied_adapter)
+        else:
+            new_module = self._create_new_module(peft_config, adapter_name, target, tied_adapter=tied_adapter)
+            self._replace_module(parent, target_name, new_module, target)
+
+    @staticmethod
+    def _create_new_module(peft_config, adapter_name, target, tied_adapter: nn.Module | None):
+        new_module = TrainableTokensLayer(
+            target,
+            adapter_name,
+            config=peft_config,
+            tied_adapter=tied_adapter,
+        )
+        new_module.update_layer(
+            adapter_name,
+            config=peft_config,
+            tied_adapter=tied_adapter,
+        )
+
+        return new_module
diff --git a/src/peft/tuners/tuners_utils.py b/src/peft/tuners/tuners_utils.py
new file mode 100644
index 0000000..aa99e42
--- /dev/null
+++ b/src/peft/tuners/tuners_utils.py
@@ -0,0 +1,2319 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import copy
+import dataclasses
+import os
+import re
+import textwrap
+import warnings
+from abc import ABC, abstractmethod
+from collections.abc import Sequence
+from contextlib import contextmanager, nullcontext
+from typing import Any, Optional, Union, overload
+
+import torch
+from accelerate.hooks import AlignDevicesHook
+from accelerate.utils import named_module_tensors, offload_state_dict
+from packaging import version
+from torch import nn
+from tqdm import tqdm
+from transformers import PreTrainedModel
+from transformers.pytorch_utils import Conv1D
+
+from peft.import_utils import is_transformers_ge_v5
+from peft.mapping import PEFT_TYPE_TO_PREFIX_MAPPING
+from peft.utils import INCLUDE_LINEAR_LAYERS_SHORTHAND, UPCAST_DTYPES
+from peft.utils.constants import (
+    DUMMY_MODEL_CONFIG,
+    DUMMY_TARGET_MODULES,
+    EMBEDDING_LAYER_NAMES,
+    MIN_TARGET_MODULES_FOR_OPTIMIZATION,
+    SEQ_CLS_HEAD_NAMES,
+)
+from peft.utils.integrations import init_empty_weights
+from peft.utils.other import (
+    AuxiliaryTrainingWrapper,
+    _get_module_names_tied_with_embedding,
+    _set_adapter,
+    _set_layer_requires_grad,
+    is_gptqmodel_quant_linear,
+    match_target_against_key,
+    set_additional_trainable_modules,
+)
+from peft.utils.peft_types import PeftType, TaskType
+from peft.utils.quantization_utils import QuantizationBackend
+from peft.utils.warning import PeftWarning
+
+from ..config import PeftConfig
+from ..utils import _get_submodules
+from ._buffer_dict import BufferDict
+
+
+warn_msg_weight_tying = (
+    "Model has `tie_word_embeddings=True` and a tied layer is part of the adapter, "
+    "but no implementation exists to tie the adapters. "
+    "This can lead to complications, for example when merging the adapter "
+    "or converting your model to formats other than safetensors. "
+    "Check the discussion here: https://github.com/huggingface/peft/issues/2777"
+)
+_torch_supports_dtensor = version.parse(torch.__version__) >= version.parse("2.5.0")
+_torch_supports_distributed = _torch_supports_dtensor and torch.distributed.is_available()
+
+
+@contextmanager
+def onload_layer(layer):
+    r"""
+    A utility for modifying a module containing one or more tuners and a base layer, any of which are offloaded to the
+    CPU or disk. Moves a module's sub-modules to the execution device before some action is performed, after that the
+    base layer state dictionary is re-assigned (if that layer was offloaded to the disk) and finally the parameters are
+    offloaded.
+
+    If the module has no offloaded sub-modules, this function does nothing.
+
+    Args:
+        layer ('torch.nn.Module'):
+            layer with tuners to be merged
+    """
+
+    offloaded_modules = []
+    for name, module in layer.named_modules():
+        if name in ["", "base_layer"]:
+            continue
+        if hasattr(module, "_hf_hook") and isinstance(module._hf_hook, AlignDevicesHook) and module._hf_hook.offload:
+            module._hf_hook.pre_forward(module)
+            offloaded_modules.append(module)
+
+    base_layer_offload = False
+    if hasattr(layer, "base_layer") and (
+        hasattr(layer.base_layer, "_hf_hook")
+        and isinstance(layer.base_layer._hf_hook, AlignDevicesHook)
+        and layer.base_layer._hf_hook.offload
+    ):
+        # check if the base layer is disk-offloaded (must contain a 'dataset' and an offload index)
+        if torch.device("meta") in layer.base_layer._hf_hook.original_devices.values() and hasattr(
+            layer.base_layer._hf_hook.weights_map, "dataset"
+        ):
+            # find the disk-offload index (maps modules to safetensors) from the `dataset` (OffloadedWeightsLoader object)
+            index = layer.base_layer._hf_hook.weights_map.dataset.index
+            module_name = next(iter(dict(layer.base_layer._hf_hook.weights_map.dataset).keys()))  # any module will do
+            file_name = index[module_name]["safetensors_file"]
+            base_name_arr = []
+            # get effective dir name
+            for i in os.path.split(file_name):
+                if "--" in i:
+                    base_name_arr.append(i)
+                    break
+                base_name_arr.append(i)
+            base_name = os.path.join(*base_name_arr)
+            safetensors_filename = base_name + "-merged"
+        layer.base_layer._hf_hook.pre_forward(layer.base_layer)
+        base_layer_offload = True
+
+    yield
+
+    for module in offloaded_modules:
+        module._hf_hook.post_forward(module, torch.tensor([]))
+
+    if base_layer_offload:
+        # re-make weights map (must be on cpu to send params to the disk via memmap if disk offload)
+        layer.base_layer._hf_hook.weights_map = {
+            name: param.to("cpu") for name, param in named_module_tensors(layer.base_layer)
+        }
+        # offload weights map to disk if original device is the disk
+        if torch.device("meta") in layer.base_layer._hf_hook.original_devices.values() and hasattr(
+            layer.base_layer._hf_hook.weights_map, "dataset"
+        ):
+            # rewrite directory with merged weights
+            offload_state_dict(safetensors_filename, layer.base_layer._hf_hook.weights_map)
+        layer.base_layer._hf_hook.post_forward(layer.base_layer, torch.tensor([]))
+
+
+def _check_lora_target_modules_mamba(peft_config: PeftConfig, model: nn.Module, target_name: str):
+    """
+    Prevent applying LoRA to incompatible modules in specific architectures (e.g., Mamba).
+    """
+
+    lora_like_types = {"LORA", "ADALORA", "XLORA", "RANDLORA"}
+    incompatible_modules = {"out_proj", "conv1d"}
+    mamba_model_types = {"falcon_h1", "mamba", "mamba2", "falcon_mamba", "nemotron_h"}
+
+    if (
+        peft_config.peft_type in lora_like_types
+        and hasattr(model, "config")
+        and getattr(model.config, "model_type", None) in mamba_model_types
+    ):
+        if target_name in incompatible_modules:
+            raise ValueError(
+                f"[PEFT:{peft_config.peft_type}] Module '{target_name}' is incompatible with Mamba-based models "
+                f"(model_type='{model.config.model_type}'). Incompatible modules: {incompatible_modules}. "
+                "Please remove it from `target_modules` to avoid compatibility issues."
+            )
+
+
+def _get_in_out_features(module: nn.Module) -> tuple[int, int] | tuple[None, None]:
+    """
+    Get the in_features and out_features of the layer.
+
+    Returns in_features and out_features as a tuple. If they cannot be determined, return a tuple of None and None.
+    This function covers a broad range of layers, some of which the caller might not support. Therefore, just because
+    this function returns a valid result does not imply that the layer type is supported.
+    """
+    if isinstance(module, nn.Linear):
+        if _torch_supports_distributed and isinstance(module.weight, torch.distributed.tensor.DTensor):
+            # If Tensor Parallel is used, the weight is sharded, so we need to get the local shape
+            out_features, in_features = module.weight.to_local().shape
+        else:
+            in_features, out_features = module.in_features, module.out_features
+    elif isinstance(module, (nn.Conv1d, nn.Conv2d, nn.Conv3d)):
+        in_features, out_features = module.in_channels, module.out_channels
+    elif isinstance(module, nn.Embedding):
+        in_features, out_features = module.num_embeddings, module.embedding_dim
+    elif isinstance(module, Conv1D):
+        in_features, out_features = (
+            module.weight.ds_shape if hasattr(module.weight, "ds_shape") else module.weight.shape
+        )
+    elif isinstance(module, nn.MultiheadAttention):
+        if not module._qkv_same_embed_dim:
+            raise ValueError("Only same dim for query/key/value is supported as of now for MultiheadAttention.")
+        in_features, out_features = module.embed_dim, 3 * module.embed_dim
+    elif hasattr(module, "infeatures") and hasattr(module, "outfeatures"):
+        # QuantLinear
+        in_features, out_features = module.infeatures, module.outfeatures
+    elif hasattr(module, "input_size") and hasattr(module, "output_size"):
+        # Megatron ColumnParallelLinear,RowParallelLinear
+        in_features, out_features = module.input_size, module.output_size
+    elif module.__class__.__name__ == "Linear" or module.__class__.__name__ == "LayerNormLinear":
+        # TransformerEngine
+        in_features, out_features = module.in_features, module.out_features
+    elif module.__class__.__name__ == "LayerNormMLP":
+        # TransformerEngine
+        ln_weight = module.layer_norm_weight
+        ln_size = ln_weight.shape[0]
+        in_features, out_features = ln_size, ln_size
+    elif hasattr(module, "codebooks") and module.__class__.__name__ == "QuantizedLinear":
+        # AQLM QuantLinear
+        in_features, out_features = module.in_features, module.out_features
+    elif is_gptqmodel_quant_linear(module):
+        # GPT-QModel quantized linears
+        in_features, out_features = module.in_features, module.out_features
+    elif module.__class__.__name__ == "EetqLinear":
+        if hasattr(module, "in_features"):
+            # Eetq layers
+            in_features, out_features = module.in_features, module.out_features
+        else:
+            # Transformers Eetq layers
+            # https://github.com/huggingface/transformers/blob/c220ea9ecee9231927a47d97a63d5604a09d4c63/src/transformers/integrations/eetq.py#L74
+            in_features, out_features = module.weight.shape
+    elif hasattr(module, "W_q") and module.__class__.__name__ == "HQQLinear":
+        # HQQ layers
+        in_features, out_features = module.in_features, module.out_features
+    elif module.__class__.__name__ == "PatchedLinear":
+        # INC layers
+        in_features, out_features = module.in_features, module.out_features
+    else:
+        # possibly support user provided custom layer types using dynamic dispatch
+        if hasattr(module, "in_features") and hasattr(module, "out_features"):
+            in_features, out_features = module.in_features, module.out_features
+        else:
+            in_features, out_features = None, None
+        warnings.warn(f"Unsupported layer type '{type(module)}' encountered, proceed at your own risk.", UserWarning)
+    return in_features, out_features
+
+
+class BaseTuner(nn.Module, ABC):
+    r"""
+    A base tuner model that provides the common methods and attributes for all tuners that are injectable into a
+    torch.nn.Module
+
+    For adding a new Tuner class, one needs to overwrite the following methods:
+
+    - **_prepare_adapter_config**:
+        A private method to eventually prepare the adapter config, for example in case the field `target_modules` is
+        missing.
+    - **_create_and_replace**:
+        A private method to create and replace the target module with the adapter module.
+    - **_check_target_module_exists**:
+        A private helper method to check if the passed module's key name matches any of the target modules in the
+        adapter_config.
+
+    The easiest is to check what is done in the `peft.tuners.lora.LoraModel` class.
+
+    Attributes:
+        model (`torch.nn.Module`):
+            The model to which the adapter tuner layers will be attached.
+        forward (`Callable`):
+            The forward method of the model.
+        peft_config (`Union[`PeftConfig`, dict[str, PeftConfig]]`):
+            The adapter configuration object, it should be a dictionary of `str` to `PeftConfig` objects. One can also
+            pass a PeftConfig object and a new adapter will be created with the default name `adapter` or create a new
+            dictionary with a key `adapter_name` and a value of that peft config.
+        config (`dict[str, Any]`):
+            The model configuration object, it should be a dictionary of `str` to `Any` objects.
+        targeted_module_names (`list[str]`):
+            The list of module names that were actually adapted. Can be useful to inspect if you want to quickly
+            double-check that the `config.target_modules` were specified correctly.
+        targeted_parameter_names (`list[str]`):
+            The list of parameter names that were actually adapted. Can be useful to inspect if you want to quickly
+            double-check that the `config.target_parameters` were specified correctly.
+        prefix (`str`)
+            The PEFT-method specific unique prefix. E.g. `"lora_"` for LoRA.
+    """
+
+    # Required attributes for child classes:
+
+    # The unique prefix for this PEFT method, e.g. 'lora_' for LoRA.
+    prefix: str
+    # The class of the tuner layer, e.g. `LoraLayer` for LoRA.
+    tuner_layer_cls: type[BaseTunerLayer]
+    # The default target modules for various transformers model architectures, like Llama. This is useful to allow users
+    # to skip specifying the `target_modules` in the config of the PEFT method. The default is often something like
+    # `{'llama': ['q_proj', 'v_proj'], ...}`.
+    target_module_mapping: dict[str, list[str]]
+
+    def __init__(
+        self,
+        model,
+        peft_config: Union[PeftConfig, dict[str, PeftConfig]],
+        adapter_name: str,
+        low_cpu_mem_usage: bool = False,
+        state_dict: Optional[dict[str, torch.Tensor]] = None,
+    ) -> None:
+        super().__init__()
+
+        self.model = model
+        self.targeted_module_names: list[str] = []
+        self.targeted_parameter_names: list[str] = []
+
+        # For advanced developers, if you want to attach multiple adapters to your
+        # model, just add a `peft_config` dict attribute to your model.
+        if not hasattr(self, "peft_config"):
+            self.peft_config = {adapter_name: peft_config} if isinstance(peft_config, PeftConfig) else peft_config
+        else:
+            warnings.warn(
+                "Already found a `peft_config` attribute in the model. This will lead to having multiple adapters"
+                " in the model. Make sure to know what you are doing!"
+            )
+            if isinstance(peft_config, PeftConfig):
+                self.peft_config[adapter_name] = peft_config
+            else:
+                # user is adding a dict of PeftConfigs
+                self.peft_config.update(peft_config)
+
+        self.active_adapter: str | list[str] = adapter_name
+        self._pre_injection_hook(self.model, self.peft_config[adapter_name], adapter_name)
+        if peft_config != PeftType.XLORA or peft_config[adapter_name] != PeftType.XLORA:
+            self.inject_adapter(self.model, adapter_name, low_cpu_mem_usage=low_cpu_mem_usage, state_dict=state_dict)
+
+        self._post_injection_hook(self.model, self.peft_config[adapter_name], adapter_name)
+
+        # Copy the peft_config in the injected model.
+        self.model.peft_config = self.peft_config
+
+    @property
+    def active_adapters(self) -> list[str]:
+        if isinstance(self.active_adapter, str):
+            return [self.active_adapter]
+        # is already a list of str
+        return self.active_adapter
+
+    def forward(self, *args: Any, **kwargs: Any):
+        return self.model.forward(*args, **kwargs)
+
+    def _pre_injection_hook(self, model: nn.Module, config: PeftConfig, adapter_name: str) -> None:
+        r"""
+        A hook to be called before the adapter is injected into the model. This method can be overridden by child
+        classes to perform any pre-injection operations.
+
+        Args:
+            model (`nn.Module`):
+                The model to be adapted.
+            config (`PeftConfig`):
+                The adapter config.
+            adapter_name (`str`):
+                The adapter name.
+        """
+
+    def _post_injection_hook(self, model: nn.Module, config: PeftConfig, adapter_name: str) -> None:
+        r"""
+        A hook to be called after the adapter is injected into the model. This method can be overridden by child
+        classes to perform any post-injection operations.
+
+        Args:
+            model (`nn.Module`):
+                The model to be adapted.
+            config (`PeftConfig`):
+                The adapter config.
+            adapter_name (`str`):
+                The adapter name.
+        """
+
+    def _prepare_adapter_config(self, peft_config: PeftConfig, model_config: dict) -> PeftConfig:
+        r"""
+        A private method to prepare the adapter config.
+
+        For transformers based models, if `peft_config.target_modules` is None, for some model architectures, we can
+        automatically infer the target modules from the `TRANSFORMERS_MODELS_TO_XXX_TARGET_MODULES_MAPPING`.
+
+        Args:
+            peft_config (`PeftConfig`):
+                The adapter config.
+            model_config (`dict`):
+                The transformers model config, that config should contain the `model_type` key.
+
+        Returns:
+            peft_config (`PeftConfig`):
+                The PEFT config with updated `target_modules`.
+
+        Raises:
+            ValueError:
+                Raises an error if the model type was not recognized.
+        """
+        if peft_config.target_modules is None:
+            target_modules = self.target_module_mapping.get(model_config["model_type"])
+            if target_modules is None:
+                raise ValueError("Please specify `target_modules` in `peft_config`")
+            if isinstance(target_modules, str):
+                peft_config.target_modules = target_modules
+            else:
+                peft_config.target_modules = set(target_modules)
+        return peft_config
+
+    def _prepare_model(self, peft_config: PeftConfig, model: nn.Module):
+        r"""
+        A private method to modify the model structure before adapter is applied.
+
+        See `peft.tuner.lora.LoraModel._prepare_model` for an example.
+
+        Args:
+            peft_config (`PeftConfig`):
+                The prepared adapter config.
+            model (`nn.Module`):
+                The model that is going to be adapted.
+        """
+
+    @staticmethod
+    def _check_tied_module_exists(peft_config: PeftConfig, key: str) -> bool | re.Match[str] | None:
+        """
+        A helper method to check if the passed module's key name matches any of the tied modules
+
+        Args:
+            config (`PeftConfig`):
+                A config to match target modules from.
+            key (`str`):
+                A key to search any matches in config.
+
+        Returns:
+            `bool`
+                True if key matches any tied modules from config, False if no match found.
+        """
+        target_modules_to_tie = getattr(peft_config, "target_modules_to_tie", []) or []
+        return key in target_modules_to_tie or any(
+            key.endswith(f".{target_key}") for target_key in target_modules_to_tie
+        )
+
+    @staticmethod
+    def _check_target_module_exists(peft_config: PeftConfig, key: str) -> bool | re.Match[str] | None:
+        """
+        A helper method to check if the passed module's key name matches any of the target modules in the
+        adapter_config.
+
+        Args:
+            config (`PeftConfig`):
+                A config to match target modules from.
+            key (`str`):
+                A key to search any matches in config.
+
+        Returns:
+            `bool` | `re.Match[str]` | `None`:
+                True or re.Match object if key matches any target modules from config, False or None if no match found.
+        """
+        return check_target_module_exists(peft_config, key)
+
+    @abstractmethod
+    def _create_and_replace(
+        self,
+        peft_config: PeftConfig,
+        adapter_name: str,
+        target: nn.Module,
+        target_name: str,
+        parent: nn.Module,
+        current_key: str,
+        parameter_name: Optional[str] = None,
+    ) -> None:
+        r"""
+        Inplace replacement of the target module with the adapter layer. This method needs to be overridden by all the
+        tuner classes.
+
+        Check `peft.tuners.lora.LoraModel._create_and_replace` for an example.
+
+        Args:
+            peft_config (`PeftConfig`):
+                The adapter config.
+            adapter_name (`str`):
+                The adapter name.
+            target (`nn.Module`):
+                The target module.
+            target_name (`str`):
+                The target module's name.
+            parent (`nn.Module`):
+                The parent module.
+            current_key (`str`):
+                The key of the current target being adapted.
+            parameter_name (`str`, *optional*)
+                If, and only if, an `nn.Parameter` is being targeted, this is the name of the parameter.
+        """
+        ...
+
+    def _mark_only_adapters_as_trainable(self, model: nn.Module) -> None:
+        """
+        A helper method to mark only the adapter layers as trainable (i.e. module.requires_grad = False).
+        """
+        for n, p in model.named_parameters():
+            if self.prefix not in n:
+                p.requires_grad = False
+
+        for active_adapter in self.active_adapters:
+            bias = getattr(self.peft_config[active_adapter], "bias", "none")
+            if bias == "none":
+                continue
+
+            if bias == "all":
+                for n, p in model.named_parameters():
+                    if "bias" in n:
+                        p.requires_grad = True
+            elif bias.endswith("_only"):  # e.g. "lora_only" or "boft_only"
+                for m in model.modules():
+                    if isinstance(m, self.tuner_layer_cls) and hasattr(m, "bias") and m.bias is not None:
+                        m.bias.requires_grad = True
+            else:
+                raise NotImplementedError(f"Requested bias: {bias}, is not implemented.")
+
+        for module in model.modules():
+            if isinstance(module, self.tuner_layer_cls):
+                module._freeze_non_trainable_peft_weights()
+
+    def _enable_adapter_layers(self, enabled: bool = True) -> None:
+        for module in self.model.modules():
+            if isinstance(module, (BaseTunerLayer, AuxiliaryTrainingWrapper)):
+                module.enable_adapters(enabled)
+
+    def disable_adapter_layers(self) -> None:
+        """
+        Disable all adapters in-place.
+
+        When disabling all adapters, the model output corresponds to the output of the base model.
+        """
+        # TODO: deprecate in favor of enable_adapters
+        for active_adapter in self.active_adapters:
+            bias_val = getattr(self.peft_config[active_adapter], "bias", "none")
+            if bias_val != "none":
+                msg = (
+                    f"Careful, disabling adapter layers with bias configured to be '{bias_val}' does not produce the "
+                    "same output as the base model would without adaption."
+                )
+                warnings.warn(msg)
+        self._enable_adapter_layers(enabled=False)
+
+    def enable_adapter_layers(self) -> None:
+        """
+        Enable all adapters in-place
+        """
+        # TODO: deprecate in favor of enable_adapters
+        self._enable_adapter_layers(enabled=True)
+
+    def delete_adapter(self, adapter_name: str) -> None:
+        """
+        Deletes an existing adapter.
+
+        Args:
+            adapter_name (str): Name of the adapter to be deleted.
+        """
+        if adapter_name not in list(self.peft_config.keys()):
+            raise ValueError(f"Adapter {adapter_name} does not exist")
+        del self.peft_config[adapter_name]
+
+        new_adapter = delete_adapter(
+            model=self.model, adapter_name=adapter_name, prefix=self.prefix, layer_cls=self.tuner_layer_cls
+        )
+        self.active_adapter = new_adapter or []
+
+    def set_requires_grad(self, adapter_names: str | Sequence[str], requires_grad: bool = True) -> None:
+        """
+        Enable or disable gradients on the given adapter(s).
+
+        Args:
+            adapter_names (`str` or `Sequence[str]`):
+                The name of the adapter(s) whose gradients should be enabled/disabled.
+            requires_grad (`bool`, *optional*)
+                Whether to enable (`True`, default) or disable (`False`).
+        """
+        set_requires_grad(self.model, adapter_names=adapter_names, requires_grad=requires_grad)
+
+    def _check_new_adapter_config(self, config: PeftConfig) -> None:
+        """
+        A helper method to check the config of a new adapter being added.
+
+        Raise a ValueError if there is something wrong with the config or if it conflicts with existing adapters.
+
+        """
+        if len(self.peft_config) <= 1:
+            return
+
+        # It is assumed that the config was added to self.peft_config *before* calling this check. We should thus never
+        # encounter the error below. Still, it is better to verify this, or else subsequent checks could be incorrect.
+        if not any(conf is config for conf in self.peft_config.values()):
+            raise ValueError(
+                "_check_new_peft_config was called incorrectly, this should not happen. Please open an issue and "
+                "report the error: https://github.com/huggingface/peft/issues"
+            )
+
+        bias_values = [getattr(conf, "bias", "none") for conf in self.peft_config.values()]
+        if sum(bias_value != "none" for bias_value in bias_values) > 1:
+            raise ValueError(
+                f"{self.__class__.__name__} supports only 1 adapter with bias. When using multiple adapters, "
+                "set bias to 'none' for all adapters."
+            )
+
+    def _cast_adapter_dtype(self, adapter_name: str, autocast_adapter_dtype: bool = True) -> None:
+        """
+        A helper method to cast the adapter weights to the correct dtype.
+
+        Currently, this only upcasts float16 and bfloat16 to float32.
+
+        Args:
+            adapter_name (`str`):
+                The adapter name.
+            autocast_adapter_dtype (`bool`, *optional*):
+                Whether to autocast the adapter dtype. Defaults to `True`.
+
+        """
+        cast_adapter_dtype(self.model, adapter_name=adapter_name, autocast_adapter_dtype=autocast_adapter_dtype)
+
+    def _check_merge_allowed(self):
+        """Helper method to check whether the adapter can be merged.
+
+        Raise a ValueError if it is not possible to merge the adapter with the given configuration.
+        """
+        example_code = textwrap.dedent(
+            """
+            ```python
+            from transformers import AutoModelForCausalLM
+
+            # Load original tied model
+            model = AutoModelForCausalLM.from_pretrained("google/gemma-2-2b-it", tie_word_embeddings=False)
+
+            # Set the randomly initialized lm_head to the previously tied embeddings
+            model.lm_head.weight.data = model.model.embed_tokens.weight.data.clone()
+
+            # Save the untied model
+            untied_model_dir = "dir/for/untied/model"
+            model.save_pretrained(untied_model_dir)
+            model.config.save_pretrained(untied_model_dir)
+
+            # Now use the original model but in untied format
+            model = AutoModelForCausalLM.from_pretrained(untied_model_dir)
+            ```
+            """
+        )
+        tied_target_modules = self._get_tied_target_modules(self.model)
+        if tied_target_modules:
+            warnings.warn(
+                f"Model with `tie_word_embeddings=True` and the {tied_target_modules=} are part of the adapter. "
+                "This can lead to complications. "
+                "You can opt to merge the adapter after cloning the weights (to untie the embeddings). "
+                "You can untie the embeddings by loading the model with `tie_word_embeddings=False`. For example:"
+                + example_code
+            )
+
+    def _unload_and_optionally_merge(
+        self,
+        merge: bool = True,
+        progressbar: bool = False,
+        safe_merge: bool = False,
+        adapter_names: Optional[list[str]] = None,
+    ) -> None:
+        if merge:
+            self._check_merge_allowed()
+
+        key_list = [key for key, _ in self.model.named_modules() if self.prefix not in key]
+        desc = "Unloading " + ("and merging " if merge else "") + "model"
+        for key in tqdm(key_list, disable=not progressbar, desc=desc):
+            try:
+                parent, target, target_name = _get_submodules(self.model, key)
+            except AttributeError:
+                continue
+            with onload_layer(target):
+                if hasattr(target, "unload_and_optionally_merge_module"):
+                    # if layers have special unloading method, like MultiheadAttention, use that
+                    unloaded_module = target.unload_and_optionally_merge_module(
+                        merge=merge, safe_merge=safe_merge, adapter_names=adapter_names
+                    )
+                    self._replace_module(parent, target_name, unloaded_module, target)
+                elif hasattr(target, "base_layer"):
+                    if merge:
+                        target.merge(safe_merge=safe_merge, adapter_names=adapter_names)
+                    self._replace_module(parent, target_name, target.get_base_layer(), target)
+
+        # Clean up peft_config from the model since all PEFT modules have been removed.
+        # This prevents spurious warnings when re-wrapping the model with get_peft_model().
+        if hasattr(self.model, "peft_config"):
+            del self.model.peft_config
+
+        # If embeddings have diverged (e.g. after vocab resize), fix config to match actual state.
+        if merge:
+            model_config = self.get_model_config(self.model)
+            if model_config.get("tie_word_embeddings"):
+                try:
+                    out_emb = self.model.get_output_embeddings()
+                    in_emb = self.model.get_input_embeddings()
+                    if (out_emb is not None) and (in_emb is not None):
+                        out_w = getattr(out_emb, "weight", None)
+                        in_w = getattr(in_emb, "weight", None)
+                        if (out_w is not None) and (in_w is not None) and (out_w.data_ptr() != in_w.data_ptr()):
+                            self.model.config.tie_word_embeddings = False
+                            warnings.warn(
+                                "Input and output embeddings are no longer tied after merging. "
+                                "Setting `tie_word_embeddings=False` in the model config."
+                            )
+                except (NotImplementedError, AttributeError):
+                    pass
+
+        return self.model
+
+    def merge_and_unload(
+        self, progressbar: bool = False, safe_merge: bool = False, adapter_names: Optional[list[str]] = None
+    ) -> torch.nn.Module:
+        r"""
+        This method merges the adapter layers into the base model.
+
+        This is needed if someone wants to use the base model as a standalone model. The returned model has the same
+        architecture as the original base model.
+
+        It is important to assign the returned model to a variable and use it, this is not an in-place operation!
+
+        Args:
+            progressbar (`bool`):
+                whether to show a progressbar indicating the unload and merge process (default: False).
+            safe_merge (`bool`):
+                whether to activate the safe merging check to check if there is any potential Nan in the adapter
+                weights.
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+
+        Example:
+
+        ```py
+        >>> from transformers import AutoModelForCausalLM
+        >>> from peft import PeftModel
+
+        >>> model_id = ...
+        >>> base_model = AutoModelForCausalLM.from_pretrained(model_id)
+        >>> peft_model_id = ...
+        >>> model = PeftModel.from_pretrained(base_model, peft_model_id)
+        >>> merged_model = model.merge_and_unload()
+        ```
+        """
+        return self._unload_and_optionally_merge(
+            progressbar=progressbar, safe_merge=safe_merge, adapter_names=adapter_names
+        )
+
+    def unload(self) -> torch.nn.Module:
+        """
+        Return the base model by removing all the PEFT modules.
+
+        It is important to assign the returned model to a variable and use it, this is not an in-place operation!
+        """
+        return self._unload_and_optionally_merge(merge=False)
+
+    def _check_target_module_compatiblity(self, peft_config: PeftConfig, model: nn.Module, target_name: str):
+        """
+        Prevent applying LoRA to incompatible modules in specific architectures (e.g., Mamba).
+        """
+        _check_lora_target_modules_mamba(peft_config, model, target_name)
+
+    def _create_and_replace_parameter(
+        self, peft_config, adapter_name, target, target_name, parent, current_key
+    ) -> None:
+        raise NotImplementedError(f"{self.__class__.__name__} does not support targeting nn.Parameter.")
+
+    def inject_adapter(
+        self,
+        model: nn.Module,
+        adapter_name: str,
+        autocast_adapter_dtype: bool = True,
+        low_cpu_mem_usage: bool = False,
+        state_dict: Optional[dict[str, torch.Tensor]] = None,
+    ) -> None:
+        r"""
+        Creates adapter layers and replaces the target modules with the adapter layers. This method is called under the
+        hood by `peft.mapping.get_peft_model` if a non-prompt tuning adapter class is passed.
+
+        The corresponding PEFT config is directly retrieved from the `peft_config` attribute of the BaseTuner class.
+
+        Args:
+            model (`nn.Module`):
+                The model to be tuned.
+            adapter_name (`str`):
+                The adapter name.
+            autocast_adapter_dtype (`bool`, *optional*):
+                Whether to autocast the adapter dtype. Defaults to `True`.
+            low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+                Create empty adapter weights on meta device. Useful to speed up the loading process.
+            state_dict (`dict`, *optional*, defaults to `None`)
+                If a state_dict is passed here, the adapters will be injected based on the entries of the state_dict.
+                This can be useful when the exact `target_modules` of the PEFT method is unknown, for instance because
+                the checkpoint was created without meta data. Note that the values from the state_dict are not used,
+                only the keys are used to determine the correct layers that should be adapted.
+
+        """
+        ###################################
+        # PREPARATION OF MODEL AND CONFIG #
+        ###################################
+        is_transformers_like_model = hasattr(getattr(model, "config", None), "model_type")
+        if is_transformers_ge_v5 and is_transformers_like_model:
+            # TODO remove once transformers < v5.0 is no longer supported
+            # For Transformers v5, some architectures were changed compared to v4, e.g. the MoE layers of Mixtral. To
+            # still make it possible to load adapters trained with v4, we have to update the PEFT config so that the
+            # right layers are targeted. Call this first and overwrite the peft_config to be sure that changes are
+            # applied.
+            from peft.utils.transformers_weight_conversion import (
+                convert_peft_config_for_transformers,
+                get_model_conversion_mapping,
+            )
+
+            weight_conversions = get_model_conversion_mapping(model)
+            convert_peft_config_for_transformers(
+                self.peft_config[adapter_name],
+                model=model,
+                conversions=weight_conversions,
+            )
+
+        peft_config = self.peft_config[adapter_name]
+        excluded_modules = []
+        unmatched_modules = []
+        targeted_modules_from_peft_config: list[str] = []  # only relevant if state_dict is passed
+        targets_to_tie: list[str] = []
+        # Note: If possible, all checks should be performed *at the start of this method*.
+        # This way, we can raise early if something goes wrong, without leaving the model
+        # in a bad (half-initialized) state.
+        self._check_new_adapter_config(peft_config)
+
+        self._check_tied_modules(model, peft_config)
+
+        model_config = self.get_model_config(model)
+
+        peft_config = self._prepare_adapter_config(peft_config, model_config)
+
+        self._prepare_model(peft_config, model)
+
+        if getattr(peft_config, "target_parameters", []) and state_dict:
+            raise ValueError(
+                "Trying to inject a PEFT adapter from a state_dict but the PEFT config uses `target_parameters`. This "
+                "is not supported -- when using `target_parameters`, please inject the adapter without the state_dict."
+            )
+
+        named_modules = list(model.named_modules())
+        key_list = [key for key, _ in named_modules]
+
+        uses_dummy_target_modules = getattr(peft_config, "target_modules", None) == DUMMY_TARGET_MODULES
+        if uses_dummy_target_modules:
+            # dummy adapter, we allow not matching any module
+            named_modules = []
+            key_list = []
+
+        # update peft_config.target_modules if required
+        peft_config = _maybe_include_all_linear_layers(peft_config, model)
+
+        # This is an optimization to reduce the number of entries in the target_modules list. The reason is that in some
+        # circumstances, target_modules can contain hundreds of entries. Since each target module is checked against
+        # each module of the net (which can be thousands), this can become quite expensive when many adapters are being
+        # added. Often, the target_modules can be condensed in such a case, which speeds up the process.
+        # A context in which this can happen is when diffusers loads non-PEFT LoRAs. As there is no meta info on
+        # target_modules in that case, they are just inferred by listing all keys from the state_dict, which can be
+        # quite a lot. See: https://github.com/huggingface/diffusers/issues/9297
+        # As there is a small chance for undiscovered bugs, we apply this optimization only if the list of
+        # target_modules is sufficiently big.
+        # We also exclude IA³ from this optimization. This is because IA³ has both target_modules and
+        # feedforward_modules, which are coupled (the latter must be a subset). It would be possible to change the logic
+        # to keep both in sync, but it's not quite trivial and probably not worth the effort. See #2429.
+        if (
+            isinstance(peft_config.target_modules, (list, set))
+            and (len(peft_config.target_modules) >= MIN_TARGET_MODULES_FOR_OPTIMIZATION)
+            and (peft_config.peft_type != PeftType.IA3)
+        ):
+            suffixes = tuple("." + suffix for suffix in peft_config.target_modules)
+            names_no_target = [
+                name for name in key_list if (name not in peft_config.target_modules) and not name.endswith(suffixes)
+            ]
+            new_target_modules = _find_minimal_target_modules(peft_config.target_modules, names_no_target)
+            if len(new_target_modules) < len(peft_config.target_modules):
+                peft_config.target_modules = new_target_modules
+
+        ###############################
+        # MATCHING & CREATING MODULES #
+        ###############################
+
+        existing_adapter_prefixes = []
+        for key, module in named_modules:
+            if isinstance(module, BaseTunerLayer):
+                existing_adapter_prefixes.append(key + ".")
+
+        # TODO: check if this the most robust way
+        module_names: set[str] = set()
+        if state_dict is not None:
+            prefix = PEFT_TYPE_TO_PREFIX_MAPPING[peft_config.peft_type]
+            # Find the module name from the state_dict. Also defensively remove '_orig_mod.', which might be inserted if
+            # the model was torch.compiled beforehand
+            module_names = {k.rsplit("." + prefix, 1)[0].removeprefix("_orig_mod.") for k in state_dict}
+
+        for key, module in named_modules:
+            if not key:
+                continue
+
+            # It is possible that we're adding an additional adapter, so if we encounter a key that clearly belongs to a
+            # previous adapter we can skip here since we don't want to interfere with adapter internals.
+            for adapter_key in existing_adapter_prefixes:
+                if key.startswith(adapter_key):
+                    excluded_modules.append(key)
+                    break
+
+            if excluded_modules and excluded_modules[-1] == key:
+                continue
+
+            if state_dict is None:
+                # normal mechanism: match the modules using the peft_config
+                result = self._check_target_module_exists(peft_config, key)
+                # If the module is a tied layer, then we skip injecting
+                # any adapter here and tie it later to the adapter of the source layer.
+                # In this loop we only add adapters to the source layer (eg: embed_tokens)
+                # Only applicable if `ensure_weight_tying = True` for LoraConfig
+                if self._check_tied_module_exists(peft_config, key):
+                    targets_to_tie.append(key)
+                    continue
+                if isinstance(result, _ExcludedModule):
+                    excluded_modules.append(key)
+                elif not result:
+                    unmatched_modules.append(key)
+                else:
+                    self.targeted_module_names.append(key)
+                    parent, target, target_name = _get_submodules(model, key)
+                    self._check_target_module_compatiblity(peft_config, model, target_name)
+                    ctx = init_empty_weights if low_cpu_mem_usage else nullcontext
+                    with ctx():
+                        self._create_and_replace(
+                            peft_config, adapter_name, target, target_name, parent, current_key=key
+                        )
+            else:
+                # defensively remove _orig_mod prefix in case the model is compiled
+                key = key.removeprefix("_orig_mod.")
+                # use the state_dict to match modules instead
+                if key not in module_names:
+                    unmatched_modules.append(key)
+                else:
+                    # If the module is a tied layer, then we skip injecting
+                    # any adapter here and tie it later to the adapter of the source layer.
+                    # In this loop we only add adapters to the source layer (eg: embed_tokens)
+                    # Only applicable if `ensure_weight_tying = True` for LoraConfig
+                    if self._check_tied_module_exists(peft_config, key):
+                        targets_to_tie.append(key)
+                        continue
+                    self.targeted_module_names.append(key)
+                    parent, target, target_name = _get_submodules(model, key)
+                    self._check_target_module_compatiblity(peft_config, model, target_name)
+                    ctx = init_empty_weights if low_cpu_mem_usage else nullcontext
+                    with ctx():
+                        self._create_and_replace(
+                            peft_config, adapter_name, target, target_name, parent, current_key=key
+                        )
+
+                # still record what would have been matched via the config so that the two results can be compared
+                if self._check_target_module_exists(peft_config, key):
+                    targeted_modules_from_peft_config.append(key)
+
+        if getattr(peft_config, "target_parameters", []):
+            # Note: We don't need to check for no state_dict being passed, since we already checked this earlier.
+            self._inject_parameters(
+                peft_config=peft_config, model=model, adapter_name=adapter_name, low_cpu_mem_usage=low_cpu_mem_usage
+            )
+
+        # Here we inject tied adapters for all the layers which were tied
+        # Only applicable if `ensure_weight_tying = True` for LoraConfig
+        for key in targets_to_tie:
+            self.targeted_module_names.append(key)
+            parent, target, target_name = _get_submodules(model, key)
+            self._check_target_module_compatiblity(peft_config, model, target_name)
+            ctx = init_empty_weights if low_cpu_mem_usage else nullcontext
+            with ctx():
+                self._create_and_replace(peft_config, adapter_name, target, target_name, parent, current_key=key)
+
+        ####################
+        # CHECK FOR ERRORS #
+        ####################
+
+        if state_dict is not None:
+            # in case that the state_dict was used as source of truth and it resulted in different outcomes than what
+            # would have been matched with the PEFT config, warn the user about that.
+            targeted_set_from_peft_config = set(targeted_modules_from_peft_config)
+            targeted_set_from_state_dict = set(self.targeted_module_names)
+            diff_peft_config = targeted_set_from_peft_config - targeted_set_from_state_dict
+            diff_state_dict = targeted_set_from_state_dict - targeted_set_from_peft_config
+            warning_msg = ""
+            if diff_peft_config or diff_state_dict:
+                warning_msg = (
+                    "While injecting the PEFT adapters, an inconsistency was discovered between the PEFT config and "
+                    "the provided state_dict. This is not necessarily an issue and can be ignored if this was the "
+                    "intent. "
+                )
+            if diff_peft_config:
+                warning_msg += (
+                    f"The PEFT config contained these additional target modules: {sorted(diff_peft_config)}. "
+                )
+            if diff_state_dict:
+                warning_msg += f"The state_dict contained these additional target modules: {sorted(diff_state_dict)}. "
+            if warning_msg:
+                warnings.warn(warning_msg, RuntimeWarning)
+
+        if not self.targeted_module_names and not self.targeted_parameter_names and not uses_dummy_target_modules:
+            if excluded_modules and not unmatched_modules:
+                # All targeted modules were excluded
+                raise ValueError(
+                    "All modules were excluded. This is likely unintended. "
+                    "Check your `target_modules`, `exclude_modules` and `modules_to_save` configuration."
+                )
+            elif not excluded_modules and unmatched_modules and not peft_config.target_modules:
+                raise ValueError(
+                    "No `target_modules` passed but also no `target_parameters` found. Please check the values for "
+                    "these arguments."
+                )
+            elif not excluded_modules and unmatched_modules:
+                # None of the targeted modules matched
+                error_msg = (
+                    f"Target modules {peft_config.target_modules} not found in the base model. "
+                    f"Please check the target modules and try again."
+                )
+                if getattr(peft_config, "layers_to_transform", None) is not None:
+                    error_msg += f" Note: You specified 'layers_to_transform': {peft_config.layers_to_transform}."
+                if getattr(peft_config, "layers_pattern", None) is not None:
+                    error_msg += f" You also specified 'layers_pattern': {peft_config.layers_pattern}."
+                raise ValueError(error_msg)
+            else:
+                # Some modules did not match and some matched but were excluded
+                error_msg = (
+                    "No modules were targeted for adaptation. "
+                    "This might be caused by a combination of mismatched target modules and excluded modules. "
+                    "Please check your `target_modules` and `exclude_modules` configuration. You may also have "
+                    "only targeted modules that are marked to be saved (`modules_to_save`)."
+                )
+                if getattr(peft_config, "layers_to_transform", None) is not None:
+                    error_msg += f" Note: You specified 'layers_to_transform': {peft_config.layers_to_transform}."
+                if getattr(peft_config, "layers_pattern", None) is not None:
+                    error_msg += f" You also specified 'layers_pattern': {peft_config.layers_pattern}."
+                raise ValueError(error_msg)
+
+        elif hasattr(peft_config, "exclude_modules") and peft_config.exclude_modules and not excluded_modules:
+            # exclude_modules was passed but was not used
+            warnings.warn(
+                f"You have passed exclude_modules={peft_config.exclude_modules} but no modules were excluded. "
+                "Please check that exclude_modules was set correctly."
+            )
+
+        elif not uses_dummy_target_modules:
+            # If we landed here, it means that at least one module or parameter was adapted, so let's not raise an
+            # error. However, let's warn the user if it seems like
+            # - they wanted to match a module but there was no match
+            # - they wanted to match a parameter but there was no match
+            if peft_config.target_modules and not self.targeted_module_names:
+                warnings.warn(
+                    f"target_modules={peft_config.target_modules} were set but no module was matched.", RuntimeWarning
+                )
+            elif getattr(peft_config, "target_parameters", []) and not self.targeted_parameter_names:
+                warnings.warn(
+                    f"target_parameters={peft_config.target_parameters} were set but no parameter was matched.",
+                    RuntimeWarning,
+                )
+
+        ################
+        # HOUSEKEEPING #
+        ################
+
+        # It's important to set the adapter here (again), because otherwise it can happen that if a 2nd adapter is
+        # added, and it targets different layer(s) than the first adapter (which is active), then those different
+        # layers will be activated, which we don't want.
+        self.set_adapter(self.active_adapters, inference_mode=peft_config.inference_mode)
+        self._mark_only_adapters_as_trainable(model)
+
+        if self.peft_config[adapter_name].inference_mode:
+            for n, p in model.named_parameters():
+                if adapter_name in n:
+                    p.requires_grad = False
+
+        set_additional_trainable_modules(
+            model=model,
+            peft_config=peft_config,
+            model_config=BaseTuner.get_model_config(self),
+            adapter_name=adapter_name,
+            activate_adapter=adapter_name in self.active_adapters,
+        )
+
+    def _inject_parameters(
+        self, peft_config: PeftConfig, model: nn.Module, adapter_name: str, low_cpu_mem_usage: bool
+    ) -> None:
+        """Inject layers based on peft_config.target_modules"""
+
+        def strip_base_layer_from_name(module_name):
+            # It is possible that the layer is already a PEFT layer and needs updating with a new adapter. In this case,
+            # the name of parameter would be something like `model.layers.0.experts.base_layer.weight`, i.e. there is a
+            # "base_layer" inserted in the name. We need to remove that, otherwise we won't be able to match correctly
+            # (in this case, "experts.weight" would not match).
+            name = ".base_layer"
+            while name in module_name:
+                prefix, _, suffix = module_name.rpartition(name)
+                module_name = prefix + suffix
+            return module_name
+
+        def find_existing_param_wrapper(module, parameter_name):
+            # When adding a further adapter, the parameter may already be wrapped by a (possibly nested) ParamWrapper
+            # that was created for a previous adapter. In that case, return that wrapper so the new adapter can be added
+            # to it (via update_layer) instead of nesting yet another wrapper.
+            while isinstance(module, BaseTunerLayer) and (module.__class__.__name__ == "ParamWrapper"):
+                if module.parameter_name == parameter_name:
+                    return module
+                module = module.base_layer
+            return None
+
+        def create_and_replace_param(module_name, key, param_name):
+            # helper function to avoid duplication
+            if module_name == "":
+                # nn.Parameters that are registered directly on the top-level module (i.e. the module passed to
+                # get_peft_model) cannot be targeted. Wrapping the parameter would require replacing the module that
+                # holds it with lora.ParamWrapper, but that module is its own parent, so the wrapper ends up registered
+                # as a submodule of the very module it wraps. This creates a cyclic module graph, resulting in an error.
+                raise ValueError(
+                    f"Targeting an nn.Parameter on the top-level module is not supported (parameter '{param_name}'). "
+                )
+
+            parent, target, target_name = _get_submodules(model, module_name)
+            unwrapped_module_name = strip_base_layer_from_name(module_name)
+            unwrapped_module = model.get_submodule(unwrapped_module_name)
+            # use the class name for checking to avoid circular import
+            if isinstance(unwrapped_module, BaseTunerLayer) and unwrapped_module.__class__.__name__ != "ParamWrapper":
+                raise ValueError(
+                    f"Trying to wrap an `nn.Parameter` of layer '{unwrapped_module_name}' of type "
+                    f"{type(target).__name__}, which is not a valid target. Make sure that this layer is not "
+                    "also targeted with `target_modules`. For some models, PEFT will do this automatically, "
+                    "try setting `target_modules=[]` to prevent it."
+                )
+
+            short_param_name = param_name.rpartition(".")[-1]  # "foo.bar.gate_up_proj" -> "gate_up_proj"
+            # If a previous adapter already wraps this parameter, reuse that wrapper instead of nesting a new one.
+            existing_wrapper = find_existing_param_wrapper(unwrapped_module, short_param_name)
+            if existing_wrapper is not None:
+                target = existing_wrapper
+
+            self._check_target_module_compatiblity(peft_config, model, target_name)
+            ctx = init_empty_weights if low_cpu_mem_usage else nullcontext
+            with ctx():
+                self._create_and_replace(
+                    peft_config,
+                    adapter_name,
+                    target,
+                    target_name,
+                    parent,
+                    current_key=key,
+                    parameter_name=short_param_name,
+                )
+
+        # TODO very simple matching, might not cover all use cases
+        unsorted_target_names = set(peft_config.target_parameters)
+        # As the order of matching can influence the nesting of multiple params on the same module, ensure determinism
+        # by sorting.
+        target_names = sorted(unsorted_target_names)
+        for module_name, module in model.named_modules():
+            if hasattr(module, "parametrizations"):
+                # Deal with the case that the parameter is already parametrized. The issue is that we would not be able
+                # to match `f"{module_name}.{param_name}"`, as the parameter is now something like
+                # `module.parametrization.weight`.
+                for key in target_names:
+                    target_module_name, _, param_name = key.rpartition(".")
+                    if target_module_name != module_name:
+                        continue
+                    if getattr(module, param_name, None) is None:
+                        continue
+                    create_and_replace_param(module_name, key, param_name)
+                    self.targeted_parameter_names.append(key)
+            else:
+                # Standard case: the parameter is not already parametrized. Note, however, that the model could already
+                # be nested with lora.ParamWrapper, as this is how we allow targeting multiple Parameters on the same
+                # module.
+                unwrapped_module_name = strip_base_layer_from_name(module_name)
+                # we're interested in finding the "lowest" module that contains the parameter, hence recurse=False
+                for param_name, param in module.named_parameters(recurse=False):
+                    key = f"{unwrapped_module_name}.{param_name}"
+                    if (key in target_names) or any(key.endswith(f".{target_key}") for target_key in target_names):
+                        # Note: We use the unwrapped_module_name to check if the key matches, but we use the module_name for
+                        # replacement, since we want to replace the wrapped module.
+                        create_and_replace_param(module_name, key, param_name)
+                        self.targeted_parameter_names.append(key)
+
+    def _replace_module(self, parent, child_name, new_module, child) -> None:
+        """
+        Replace the sub-module of a given module with a new PEFT module.
+
+        This also deals with device placement of the new module to be in line with the child module.
+
+        Args:
+            parent (`nn.Module`):
+                The parent module on which the replacement should take place.
+            child_name (`str`):
+                The name of the child module to be replaced.
+            new_module (`nn.Module`):
+                The new PEFT module.
+            child (`nn.Module`):
+                The original child module that is being replaced.
+
+        """
+        setattr(parent, child_name, new_module)
+        # It's not necessary to set requires_grad here, as that is handled by
+        # _mark_only_adapters_as_trainable
+
+        # child layer wraps the original module, unpack it
+        if hasattr(child, "base_layer"):
+            child = child.base_layer
+
+        if not hasattr(new_module, "base_layer"):
+            new_module.weight = child.weight
+            if hasattr(child, "bias"):
+                new_module.bias = child.bias
+
+        if getattr(child, "state", None) is not None:
+            if hasattr(new_module, "base_layer"):
+                new_module.base_layer.state = child.state
+            else:
+                new_module.state = child.state
+            new_module.to(child.weight.device)
+
+        meta = torch.device("meta")
+        # dispatch to correct device
+        for name, module in new_module.named_modules():
+            if self.prefix in name:
+                if hasattr(child, "qweight"):
+                    weight = child.qweight
+                elif hasattr(child, "W_q"):
+                    weight = child.W_q
+                elif hasattr(child, "weight"):
+                    weight = child.weight
+                elif getattr(child, "in_proj_weight", None) is not None:  # MHA
+                    weight = child.in_proj_weight
+                else:
+                    weight = next(child.parameters())
+
+                if not any(p.device == meta for p in module.parameters()):
+                    module.to(weight.device)
+
+    def merge_adapter(self, adapter_names: Optional[list[str]] = None, safe_merge: bool = False) -> None:
+        """
+        This method merges the adapter layers into the base model.
+
+        Merging adapters can lead to a speed up of the forward pass. A copy of the adapter weights is still kept in
+        memory, which is required to unmerge the adapters. In order to merge the adapter weights without keeping them
+        in memory, please call `merge_and_unload`.
+
+        Args:
+            adapter_names (`list[str]`, *optional*):
+                The list of adapter names that should be merged. If `None`, all active adapters will be merged.
+                Defaults to `None`.
+            safe_merge (`bool`, *optional*):
+                If `True`, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+        """
+        # Note: The order of arguments here is:
+        #   adapter_names, safe_merge
+        # For layer.merge, the order is:
+        #   safe_merge, adapter_names
+        # This is not so nice but this method here started with only adapter_names, thus putting safe_merge first would
+        # be a backwards incompatible change.
+        self._check_merge_allowed()
+        for module in self.model.modules():
+            if isinstance(module, BaseTunerLayer):
+                with onload_layer(module):
+                    module.merge(adapter_names=adapter_names, safe_merge=safe_merge)
+
+    def unmerge_adapter(self):
+        """
+        This method unmerges all merged adapter layers from the base model.
+        """
+        for module in self.model.modules():
+            if isinstance(module, BaseTunerLayer):
+                with onload_layer(module):
+                    module.unmerge()
+
+    def set_adapter(self, adapter_name: str | list[str], inference_mode: bool = False) -> None:
+        """Set the active adapter(s).
+
+        Args:
+            adapter_name (str, list[str]):
+                The name(s) of the adapter(s) to set as active
+            inference_mode (bool, optional):
+                 Whether the activated adapter should be frozen (i.e. `requires_grad=False`). Default is False.
+        """
+        set_adapter(
+            self.model, adapter_name=adapter_name, inference_mode=inference_mode, layer_cls=self.tuner_layer_cls
+        )
+        self.active_adapter = adapter_name
+
+    @staticmethod
+    def get_model_config(model: nn.Module) -> dict:
+        """
+        This method gets the config from a model in dictionary form. If model has not attribute config, then this
+        method returns a default config.
+
+        Args:
+            model (`nn.Module`):
+                Model to get the config from.
+            default (`dict|None`, *optional*)::
+                What to return if model does not have a config attribute.
+        """
+        model_config = getattr(model, "config", DUMMY_MODEL_CONFIG)
+        if hasattr(model_config, "to_dict"):
+            model_config = model_config.to_dict()
+        elif dataclasses.is_dataclass(model_config):
+            model_config = dataclasses.asdict(model_config)
+        return model_config
+
+    def _get_tied_target_modules(self, model: nn.Module) -> list[str]:
+        tied_target_modules = []
+        model_config = self.get_model_config(model)
+        if model_config.get("tie_word_embeddings"):
+            for target_module in self.targeted_module_names:
+                # This potentially yields false positives since we're just looking at the layer names. So if we use a
+                # model that uses weight-tying of lm_head and embed_tokens, a third, unrelated, layer which is
+                # unfortunately named so that it is in EMBEDDING_LAYER_NAMES will be falsely reported here as well.
+                if target_module.split(".")[-1] in EMBEDDING_LAYER_NAMES:
+                    tied_target_modules.append(target_module)
+        return tied_target_modules
+
+    def _get_module_names_tied_with_embedding(self) -> list[str]:
+        return _get_module_names_tied_with_embedding(self)
+
+    def _add_modules_to_save_to_tie(self, peft_config, tied_weight_keys):
+        """
+        This method adds modules to tie to `peft_config` so that those modules can be tied downstream. By default this
+        method raises a warning, and each tuner class extending `BaseTuner` can choose to implement this.
+
+        Check `peft.tuners.lora.LoraModel._add_modules_to_save_to_tie` for an example.
+        """
+        warnings.warn(warn_msg_weight_tying)
+
+    def _add_targets_to_tie(self, peft_config, tied_weight_keys):
+        """
+        This method adds targets to tie to `peft_config` so that those modules can be tied downstream. By default this
+        method raises a warning, and each tuner class extending `BaseTuner` can choose to implement this.
+
+        Check `peft.tuners.lora.LoraModel._add_targets_to_tie` for an example.
+        """
+        warnings.warn(warn_msg_weight_tying)
+
+    def _check_tied_modules(self, model: nn.Module, peft_config):
+        """
+        Checks if any of the tied layers are targeted via `modules_to_save` or `target_modules`. Updates the
+        `peft_config` in place with any layers/adapters that needs to be tied
+        """
+        modules_to_save = set(getattr(peft_config, "modules_to_save", []) or [])
+        # `EMBEDDING_LAYER_NAMES` contains only the stripped name of the module
+        # eg: To get a match for model.embed_tokens, we need to extract `embed_tokens`
+        is_embedding_to_save = any(m.split(".")[-1] in EMBEDDING_LAYER_NAMES for m in modules_to_save)
+
+        raw_target_modules = getattr(peft_config, "target_modules", None)
+        if isinstance(raw_target_modules, str):
+            is_embedding_in_target = any(
+                match_target_against_key(raw_target_modules, m) for m in EMBEDDING_LAYER_NAMES
+            )
+        else:
+            target_modules = set(raw_target_modules or [])
+            # `EMBEDDING_LAYER_NAMES` contains only the stripped name of the module
+            # eg: To get a match for model.embed_tokens, we need to extract `embed_tokens`
+            is_embedding_in_target = any(m.split(".")[-1] in EMBEDDING_LAYER_NAMES for m in target_modules)
+
+        tied_weight_keys = self._get_module_names_tied_with_embedding()
+
+        if getattr(peft_config, "ensure_weight_tying", False):
+            if tied_weight_keys:
+                if is_embedding_to_save:
+                    self._add_modules_to_save_to_tie(peft_config, tied_weight_keys)
+                elif is_embedding_in_target:
+                    self._add_targets_to_tie(peft_config, tied_weight_keys)
+                else:
+                    warnings.warn(
+                        "You have requested `ensure_weight_tying`, but no tied modules are added in either "
+                        "`modules_to_save` or `target_modules`"
+                    )
+            else:
+                warnings.warn("You have requested `ensure_weight_tying`, but no tied modules were found in the model")
+
+        elif (is_embedding_to_save or is_embedding_in_target) and tied_weight_keys:
+            if hasattr(peft_config, "ensure_weight_tying"):
+                msg = (
+                    "Model has `tie_word_embeddings=True` and a tied layer is part of the adapter, "
+                    "but `ensure_weight_tying` is not set to True. "
+                    "This can lead to complications, for example when merging the adapter "
+                    "or converting your model to formats other than safetensors. "
+                    "Check the discussion here: https://github.com/huggingface/peft/issues/2777"
+                )
+                warnings.warn(msg)
+            else:
+                msg = (
+                    "Model has `tie_word_embeddings=True` and a tied layer is part of the adapter, "
+                    "but no implementation exists to tie the adapters. "
+                    "This can lead to complications, for example when merging the adapter "
+                    "or converting your model to formats other than safetensors. "
+                    "Check the discussion here: https://github.com/huggingface/peft/issues/2777"
+                )
+                warnings.warn(msg)
+
+    def supports_lora_conversion(self, adapter_name: str = "default") -> bool:
+        """
+        Whether it is possible for the adapter of this model to be converted to LoRA.
+
+        Normally, this works if the PEFT method is additive, i.e. W' = W_base + delta_weight.
+        """
+        return all(
+            module.supports_lora_conversion() for module in self.modules() if isinstance(module, BaseTunerLayer)
+        )
+
+    def __getattr__(self, name: str):
+        """Forward missing attributes to the wrapped module."""
+        try:
+            return super().__getattr__(name)  # defer to nn.Module's logic
+        except AttributeError:
+            if name == "model":  # see #1892: prevent infinite recursion if class is not initialized
+                raise
+            return getattr(self.model, name)
+
+
+class BaseTunerLayer(ABC):
+    r"""
+    A tuner layer mixin that provides the common methods and attributes for all tuners.
+
+    Args:
+        is_pluggable (`bool`, *optional*):
+            Whether the adapter layer can be plugged to any pytorch module
+        active_adapters (Union[List[`str`], `str`], *optional*):
+            The name of the active adapter.
+    """
+
+    # All names of layers that may contain adapter (trainable) weights
+    adapter_layer_names: tuple[str, ...] = ()
+    # All names of other parameters that may contain adapter-related parameters
+    other_param_names: tuple[str, ...] = ()
+    # This dict maps from the adapter name to the layer(s) whose weights should stay frozen
+    frozen_peft_weight_names: dict[str, tuple[str, ...]] = {}
+
+    # indicates whether all adapters should be disabled
+    _disable_adapters: bool = False
+
+    # the currently active adapter(s)
+    _active_adapter: str | list[str] = "default"
+
+    # List all merged adapters
+    merged_adapters: list[str] = []
+
+    # the quantization backend used within this class, e.g. Bnb8bitBackend or None if no quantization
+    quantization_backend: QuantizationBackend | None = None
+
+    def get_base_layer(self) -> nn.Module:
+        """
+        (Recursively) get the base_layer.
+
+        This is necessary for the case that the tuner layer wraps another tuner layer.
+
+        """
+        base_layer = self
+        while hasattr(base_layer, "base_layer"):
+            base_layer = base_layer.base_layer
+        return base_layer
+
+    def get_base_weight(self) -> torch.Tensor:
+        """Return the weight of the base layer.
+
+        This takes care of potentially dequantizing the weight if it is quantized.
+        """
+        if self.quantization_backend is not None:
+            return self.quantization_backend.get_base_weight(self.get_base_layer())
+        return self.get_base_layer().weight.data
+
+    def set_base_weight(self, weight_data: torch.Tensor) -> None:
+        """Sets the base weight of the base layer to the new tensor
+
+        This works also with quantized weights.
+        """
+        if self.quantization_backend is not None:
+            self.quantization_backend.set_base_weight(self, weight_data)
+        else:
+            self.get_base_layer().weight.data = weight_data
+
+    def _get_embed_scale(self):
+        """
+        Extract embed_scale from base layer if present and valid.
+
+        Some embedding layers (e.g., Gemma3TextScaledWordEmbedding) apply scaling to embeddings in their forward
+        method. This method checks for the presence of an `embed_scale` attribute. If it exists, it is assumed to be a
+        scalar. Its shape is validated accordingly.
+
+        Returns:
+            torch.Tensor or None: The embed_scale tensor if found and valid, None otherwise.
+        """
+        base_layer = self.get_base_layer()
+        if not hasattr(base_layer, "embed_scale"):
+            return None
+
+        embed_scale = base_layer.embed_scale
+
+        # Convert scalar values to tensors
+        if isinstance(embed_scale, (int, float)):
+            return torch.tensor(embed_scale, device=base_layer.weight.device, dtype=base_layer.weight.dtype)
+
+        # Validate tensor shape - must be scalar (0-d) or 1-element tensor for proper broadcasting
+        if isinstance(embed_scale, torch.Tensor):
+            if embed_scale.numel() == 1:
+                return embed_scale
+            else:
+                # Log warning but don't fail - this maintains backward compatibility
+                warnings.warn(
+                    f"Found embed_scale attribute with shape {embed_scale.shape}, expected scalar. "
+                    "Embedding scaling will not be applied. If this is unexpected, please open an issue at "
+                    "https://github.com/huggingface/peft/issues",
+                    PeftWarning,
+                )
+                return None
+
+        return None
+
+    @property
+    def weight(self) -> torch.Tensor:
+        # This is required for some transformers code, e.g. for T5, weight is accessed as:
+        #     self.wo.weight
+        # where "wo" is the adapter layer.
+        # https://github.com/huggingface/transformers/blob/78f6ed6c70b29c1560780e3869a7ad4c6b3d2710/src/transformers
+        # /models/t5/modeling_t5.py#L292
+        base_layer = self.get_base_layer()
+        if hasattr(base_layer, "qweight"):
+            # QuantLinear
+            weight = base_layer.qweight
+        else:
+            # Other layers
+            weight = base_layer.weight
+        return weight
+
+    @property
+    def bias(self) -> torch.Tensor:
+        base_layer = self.get_base_layer()
+        return base_layer.bias
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        raise NotImplementedError
+
+    def unmerge(self) -> None:
+        raise NotImplementedError
+
+    @property
+    def merged(self) -> bool:
+        return bool(self.merged_adapters)
+
+    @property
+    def disable_adapters(self) -> bool:
+        # use a property to ensure that disable_adapters is not set directly, instead use the enable_adapters method
+        return self._disable_adapters
+
+    @property
+    def active_adapter(self) -> str | list[str]:
+        # use a property to ensure that active_adapter is not set directly, instead use the set_adapter method
+        return self._active_adapter
+
+    def _get_available_adapters(self) -> set[str]:
+        """Return all adapter names that can be found on this module."""
+        adapters = set()
+        for layer_name in self.adapter_layer_names:
+            module = getattr(self, layer_name)
+            if not isinstance(module, (nn.ModuleDict, nn.ParameterDict)):
+                continue
+            adapters.update(set(module.keys()))
+        return adapters
+
+    @property
+    def active_adapters(self):
+        if isinstance(self.active_adapter, str):
+            return [self.active_adapter]
+        # is already a list of str
+        return self.active_adapter
+
+    def enable_adapters(self, enabled: bool) -> None:
+        """Toggle the enabling and disabling of adapters
+
+        Takes care of setting the requires_grad flag for the adapter weights.
+
+        Args:
+            enabled (bool): True to enable adapters, False to disable adapters
+        """
+        if enabled:
+            self.set_adapter(self.active_adapters)
+            self._disable_adapters = False
+        else:
+            # disable grads on all adapter layers
+            for layer_name in self.adapter_layer_names:
+                module_dict = getattr(self, layer_name)
+                for layer in module_dict.values():
+                    _set_layer_requires_grad(layer, False)
+            self._disable_adapters = True
+
+    def _freeze_non_trainable_peft_weights(self, adapter_names: str | Sequence[str] | None = None) -> None:
+        """Freeze PEFT weights that adapter variants declare as non-trainable.
+
+        Some variants intentionally train only a subset of their adapter weights. This method reapplies those
+        declarations after code paths that may otherwise mark adapter weights as trainable, such as adapter setup or
+        adapter switching.
+        """
+        if not self.frozen_peft_weight_names:
+            return
+
+        if adapter_names is None:
+            adapter_names = self.frozen_peft_weight_names.keys()
+        elif isinstance(adapter_names, str):
+            adapter_names = [adapter_names]
+
+        for adapter_name in adapter_names:
+            for layer_name in self.frozen_peft_weight_names.get(adapter_name, ()):
+                if layer_name not in self.adapter_layer_names:
+                    continue
+
+                module_dict = getattr(self, layer_name)
+                if adapter_name not in module_dict:
+                    continue
+
+                _set_layer_requires_grad(module_dict[adapter_name], False)
+
+    def set_adapter(self, adapter_names: str | list[str], inference_mode: bool = False) -> None:
+        """Set the active adapter(s).
+
+        Additionally, this function will set the specified adapter to trainable (i.e., requires_grad=True) unless
+        inference_mode is True.
+
+        Args:
+            adapter_names (`str` or `list[str]`):
+                 The name(s) of the adapter(s) to set as active.
+            inference_mode (bool, optional):
+                 Whether the activated adapter should be frozen (i.e. `requires_grad=False`). Default is False.
+        """
+        if isinstance(adapter_names, str):
+            adapter_names = [adapter_names]
+
+        # Deactivate grads on the inactive adapter and activate grads on the active adapter (if not in inference mode)
+        for layer_name in self.adapter_layer_names:
+            module_dict = getattr(self, layer_name)
+            for key, layer in module_dict.items():
+                should_require_grad = (key in adapter_names) and (not inference_mode)
+                _set_layer_requires_grad(layer, should_require_grad)
+
+        self._freeze_non_trainable_peft_weights(adapter_names)
+        self._active_adapter = adapter_names
+
+    def _all_available_adapter_names(self) -> list[str]:
+        """Return a sorted list of all available adapter names"""
+        adapter_names = set()
+        for name in self.adapter_layer_names + self.other_param_names:
+            # we check each possible attribute and if it's a dict or ModuleDict, we assume that the keys are the adapter
+            # names
+            attr = getattr(self, name)
+            if hasattr(attr, "keys"):
+                adapter_names.update(attr.keys())
+        return sorted(adapter_names)
+
+    def delete_adapter(self, adapter_name: str) -> None:
+        """
+        Delete an adapter from the layer
+
+        This should be called on all adapter layers, or else we will get an inconsistent state.
+
+        This method will also set a new active adapter if the deleted adapter was an active adapter. It is important
+        that the new adapter is chosen in a deterministic way, so that the same adapter is chosen on all layers.
+
+        Args:
+            adapter_name (`str`): The name of the adapter to delete
+
+        """
+        for attr in self.adapter_layer_names + self.other_param_names:
+            if adapter_name in getattr(self, attr):
+                del getattr(self, attr)[adapter_name]
+
+        if adapter_name in self.frozen_peft_weight_names:
+            # Delete in place (like the containers above) rather than copy-and-rebind: once an adapter
+            # has been registered the instance already owns its own dict (see
+            # `_register_frozen_peft_weight`), so this can't mutate the class-level default, and it keeps
+            # the deletion visible to any already-held reference to the dict.
+            del self.frozen_peft_weight_names[adapter_name]
+
+        if adapter_name in self.active_adapters:
+            # choose a new active adapter
+            active_adapters = self.active_adapters[:]
+            active_adapters.remove(adapter_name)
+            if active_adapters:
+                self.set_adapter(active_adapters)
+            else:
+                # no active adapters left, set a new default adapter
+                # here we get the list of all adapters existing adapter names and choose the first one
+                remaining_adapters = self._all_available_adapter_names()
+                if not remaining_adapters:
+                    self.set_adapter([])
+                else:
+                    new_active_adapter = remaining_adapters[0]
+                    warnings.warn(
+                        f"Adapter {adapter_name} was active which is now deleted. Setting active adapter to "
+                        f"{new_active_adapter}."
+                    )
+                    self.set_adapter(remaining_adapters[0])
+
+    def set_requires_grad(self, adapter_names: str | Sequence[str], requires_grad: bool = True) -> None:
+        """
+        Enable or disable gradients on the given adapter(s).
+
+        Args:
+            adapter_names (`str` or `Sequence[str]`):
+                The name of the adapter(s) whose gradients should be enabled/disabled.
+            requires_grad (`bool`, *optional*)
+                Whether to enable (`True`, default) or disable (`False`).
+        """
+        if isinstance(adapter_names, str):
+            adapter_names_set = {adapter_names}
+        else:
+            adapter_names_set = set(adapter_names)
+
+        for layer_name in self.adapter_layer_names:
+            module_dict = getattr(self, layer_name)
+            for key, layer in module_dict.items():
+                if key in adapter_names_set:
+                    _set_layer_requires_grad(layer, requires_grad)
+
+        if requires_grad:
+            self._freeze_non_trainable_peft_weights(adapter_names_set)
+
+    def _get_base_layer_device_and_dtype(self, base_layer):
+        """
+        Helper function to determine the device and dtype of the base layer. If not possible to determine, return None.
+        """
+        device, dtype = None, None
+
+        # check weight and qweight (for GPTQ)
+        for weight_name in ("weight", "qweight"):
+            weight = getattr(base_layer, weight_name, None)
+            if weight is not None:
+                device = weight.device
+                dtype = weight.dtype
+                break
+
+        if hasattr(base_layer, "compute_dtype"):  # bnb Linear4bitLt
+            dtype = base_layer.compute_dtype
+
+        return device, dtype
+
+    def _move_adapter_to_device_of_base_layer(self, adapter_name: str, device: Optional[torch.device] = None) -> None:
+        """
+        Move the adapter of the given name to the device, and possibly dtype, of the base layer.
+        """
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.MultiheadAttention):
+            base_layer = base_layer.out_proj
+        base_layer_device, base_layer_dtype = self._get_base_layer_device_and_dtype(base_layer)
+
+        target_device = device if device is not None else base_layer_device
+        if target_device is None:
+            # could not determine device
+            return
+
+        target_dtype = None
+        if base_layer_dtype is not None:
+            # don't cast to int dtype
+            if base_layer_dtype.is_floating_point or base_layer_dtype.is_complex:
+                target_dtype = base_layer_dtype
+
+        meta = torch.device("meta")
+
+        # loop through all potential adapter layers and move them to the device of the base layer; be careful to only
+        # move this specific adapter to the device, as the other adapters could be on different devices
+        # see #1639
+        for adapter_layer_name in self.adapter_layer_names + self.other_param_names:
+            adapter_layer = getattr(self, adapter_layer_name, None)
+            if not isinstance(adapter_layer, (nn.ModuleDict, nn.ParameterDict, BufferDict)):
+                continue
+            if adapter_name not in adapter_layer:
+                continue
+            if any(p.device == meta for p in adapter_layer.parameters()):
+                continue
+
+            if target_dtype is not None:
+                adapter_layer[adapter_name] = adapter_layer[adapter_name].to(target_device, dtype=target_dtype)
+            else:
+                adapter_layer[adapter_name] = adapter_layer[adapter_name].to(target_device)
+
+    @overload
+    def _cast_input_dtype(self, x: None, dtype: torch.dtype) -> None: ...
+
+    @overload
+    def _cast_input_dtype(self, x: torch.Tensor, dtype: torch.dtype) -> torch.Tensor: ...
+
+    def _cast_input_dtype(self, x, dtype: torch.dtype):
+        """
+        Whether to cast the dtype of the input of the forward method.
+
+        Usually, we want to enable this to align the input dtype with the dtype of the weight, but by setting
+        layer.cast_input_dtype=False, this can be disabled if necessary.
+
+        Enabling or disabling can be managed via the peft.helpers.disable_input_dtype_casting context manager.
+        """
+        if x is None:  # useful e.g. if x is the bias, which can be None
+            return None
+
+        cast_input_dtype_enabled = getattr(self, "cast_input_dtype_enabled", True)
+        if (not cast_input_dtype_enabled) or (x.dtype == dtype):
+            return x
+        return x.to(dtype=dtype)
+
+    def supports_lora_conversion(self, adapter_name: str = "default") -> bool:
+        """
+        Whether it is possible for this layer type to be converted to LoRA.
+
+        Normally, this works if the PEFT method is additive, i.e. W' = W_base + delta_weight.
+        """
+        return False
+
+
+def _find_minimal_target_modules(
+    target_modules: list[str] | set[str], other_module_names: list[str] | set[str]
+) -> set[str]:
+    """Find the minimal set of target modules that is sufficient to separate them from the other modules.
+
+    Sometimes, a very large list of target_modules could be passed, which can slow down loading of adapters (e.g. when
+    loaded from diffusers). It may be possible to condense this list from hundreds of items to just a handful of
+    suffixes that are sufficient to distinguish the target modules from the other modules.
+
+    Example:
+        ```py
+        >>> from peft.tuners.tuners_utils import _find_minimal_target_modules
+
+        >>> target_modules = [f"model.decoder.layers.{i}.self_attn.q_proj" for i in range(100)]
+        >>> target_modules += [f"model.decoder.layers.{i}.self_attn.v_proj" for i in range(100)]
+        >>> other_module_names = [f"model.encoder.layers.{i}.self_attn.k_proj" for i in range(100)]
+        >>> _find_minimal_target_modules(target_modules, other_module_names)
+        {"q_proj", "v_proj"}
+        ```
+
+    Args:
+        target_modules (`list[str]` | `set[str]`):
+            The list of target modules.
+        other_module_names (`list[str]` | `set[str]`):
+            The list of other module names. They must not overlap with the target modules.
+
+    Returns:
+        `set[str]`:
+            The minimal set of target modules that is sufficient to separate them from the other modules.
+
+    Raises:
+        ValueError:
+            If `target_modules` is not a list or set of strings or if it contains an empty string. Also raises an error
+            if `target_modules` and `other_module_names` contain common elements.
+    """
+    if isinstance(target_modules, str) or not target_modules:
+        raise ValueError("target_modules should be a list or set of strings.")
+
+    target_modules = set(target_modules)
+    if "" in target_modules:
+        raise ValueError("target_modules should not contain an empty string.")
+
+    other_module_names = set(other_module_names)
+    if not target_modules.isdisjoint(other_module_names):
+        msg = (
+            "target_modules and other_module_names contain common elements, this should not happen, please "
+            "open a GitHub issue at https://github.com/huggingface/peft/issues with the code to reproduce this issue"
+        )
+        raise ValueError(msg)
+
+    # it is assumed that module name parts are separated by a "."
+    def generate_suffixes(s):
+        parts = s.split(".")
+        return [".".join(parts[i:]) for i in range(len(parts))][::-1]
+
+    # Create a reverse lookup for other_module_names to quickly check suffix matches
+    other_module_suffixes = {suffix for item in other_module_names for suffix in generate_suffixes(item)}
+
+    # Find all potential suffixes from target_modules
+    target_modules_suffix_map = {item: generate_suffixes(item) for item in target_modules}
+
+    # Initialize a set for required suffixes
+    required_suffixes = set()
+
+    # We sort the target_modules_suffix_map simply to get deterministic behavior, since sets have no order. In theory
+    # the order should not matter but in case there is a bug, it's better for the bug to be deterministic.
+    for item, suffixes in sorted(target_modules_suffix_map.items(), key=lambda tup: tup[1]):
+        # Go through target_modules items, shortest suffixes first
+        for suffix in suffixes:
+            # If the suffix is already in required_suffixes or matches other_module_names, skip it
+            if suffix in required_suffixes or suffix in other_module_suffixes:
+                continue
+            # Check if adding this suffix covers the item
+            if not any(item.endswith("." + req_suffix) for req_suffix in required_suffixes):
+                required_suffixes.add(suffix)
+                break
+
+    if not required_suffixes:
+        return set(target_modules)
+    return required_suffixes
+
+
+class _ExcludedModule:
+    """
+    A private helper method used to represent excluded modules in the check_target_module_exists function.
+    """
+
+    def __bool__(self):
+        return False
+
+
+def check_target_module_exists(config, key: str) -> bool | re.Match[str] | None:
+    """A helper method to check if the passed module's key name matches any of the target modules in the adapter_config.
+
+    Args:
+        config (`PeftConfig`):
+            A config to match target modules from.
+        key (`str`):
+            A key to search any matches in config
+
+    Returns:
+        `bool` | `re.Match[str]` | `None`:
+            True or re.Match object if key matches any target modules from config, False or None if no match found.
+    """
+    if hasattr(config, "exclude_modules") and config.exclude_modules:
+        if isinstance(config.exclude_modules, str):
+            if re.fullmatch(config.exclude_modules, key):
+                return _ExcludedModule()
+        elif key in config.exclude_modules or any(
+            key.endswith(f".{exclude_key}") for exclude_key in config.exclude_modules
+        ):
+            return _ExcludedModule()
+
+    # Adapters should never match on modules to save modules as it is a guarantee for conflicts of behavior
+    # between `ModulesToSaveWrapper` internals and the potential adapter.
+    modules_to_save = getattr(config, "modules_to_save", None)
+    if modules_to_save:
+        if any(re.match(rf"(^|.*\.){m}($|\..*)", key) for m in modules_to_save):
+            return _ExcludedModule()
+
+    if (config.target_modules is None) and (config.target_parameters is not None):
+        # this is allowed if config.target_parameters are specified
+        return False
+
+    if isinstance(config.target_modules, str):
+        target_module_found = match_target_against_key(config.target_modules, key)
+    elif key in config.target_modules:
+        # this module is specified directly in target_modules
+        target_module_found = True
+    else:
+        target_module_found = any(key.endswith(f".{target_key}") for target_key in config.target_modules)
+
+        layer_indexes = getattr(config, "layers_to_transform", None)
+        layers_pattern = getattr(config, "layers_pattern", None)
+
+        is_using_layer_indexes = layer_indexes is not None and (
+            len(layer_indexes) != 0 if isinstance(layer_indexes, list) else True
+        )
+        if is_using_layer_indexes and target_module_found:
+            layer_index = None
+            # TODO: It's still unclear how empty layers_pattern (None, [], or "") should behave
+            # For now, empty layers_pattern means any layer pattern is ok
+            if layers_pattern is None or len(layers_pattern) == 0:
+                # Lazy .*? matches the first numbered segment (the layer index), not the last one; a greedy .* would
+                # wrongly pick up nested indices such as the expert index in MoE models ("...layers.1.experts.0...").
+                layer_index = re.match(r".*?\.[^.]*\.(\d+)\.", key)
+            else:
+                layers_pattern = [layers_pattern] if isinstance(layers_pattern, str) else layers_pattern
+                for pattern in layers_pattern:
+                    layer_index = re.match(rf".*?\.{pattern}\.(\d+)\.", key)
+                    if layer_index is not None:
+                        break
+
+            if layer_index is None:
+                target_module_found = False
+            else:
+                layer_index = int(layer_index.group(1))
+                if isinstance(layer_indexes, int):
+                    target_module_found = layer_index == layer_indexes
+                else:
+                    target_module_found = layer_index in layer_indexes
+
+    return target_module_found
+
+
+def inspect_matched_modules(tuner: BaseTuner, adapter_name: str = "default") -> dict:
+    """
+    A helper function to inspect the set of matched and unmatched modules for a PEFT model and the given adapter.
+    """
+    config = tuner.peft_config[adapter_name]
+    key_list = [key for key, _ in tuner.model.named_modules()]
+    module_dict = {"matched": [], "unmatched": []}
+    for key in key_list:
+        if tuner._check_target_module_exists(config, key):
+            module_dict["matched"].append(key)
+        else:
+            module_dict["unmatched"].append(key)
+    return module_dict
+
+
+def _maybe_include_all_linear_layers(peft_config: PeftConfig, model: nn.Module) -> PeftConfig:
+    """
+    Helper function to update `target_modules` to all linear/Conv1D layers if provided as 'all-linear'. Adapted from
+    the QLoRA repository: https://github.com/artidoro/qlora/blob/main/qlora.py
+    """
+    if not hasattr(peft_config, "target_modules"):
+        return peft_config
+
+    # if `target_modules` is a string, convert to lower case and check if it matches "all-linear"
+    if not (
+        isinstance(peft_config.target_modules, str)
+        and peft_config.target_modules.lower() == INCLUDE_LINEAR_LAYERS_SHORTHAND
+    ):
+        return peft_config
+
+    linear_classes = (torch.nn.Linear, Conv1D)
+    linear_names = ("Linear",)
+    linear_module_names = set()
+    for name, module in model.named_modules():
+        # match with all linear classes.
+        if isinstance(module, linear_classes):
+            linear_module_names.add(name)
+        elif isinstance(module, BaseTunerLayer) and any(n in type(module).__name__ for n in linear_names):
+            # If the model already has adapter layers applied, then the "linear" layer is actually an adapter layer,
+            # e.g. lora.Linear, and not nn.Linear. To target this layer, we don't want to check the layer type, as there
+            # are many possible layer types (one for each PEFT method) and the list would quickly get out of date. Thus
+            # we rely on the name of the layer class, which by convention is something like "Linear", "Linear4bit",
+            # "HqqLoraLinear", ... in PEFT. It's not pretty but should generally work.
+            # See 2390
+            linear_module_names.add(name)
+
+    # Try to remove linear layers that should not be targeted as best as possible. We have to rely on convention as
+    # there are no hard rules to detect these modules.
+    module_names_to_exclude = set()
+    if isinstance(model, PreTrainedModel):
+        output_emb = model.get_output_embeddings()
+        if output_emb is not None:
+            # ignore the last classification head for text generation models
+            last_module_name = next(name for name, module in model.named_modules() if module is output_emb)
+            module_names_to_exclude.add(last_module_name)
+        elif peft_config.task_type == TaskType.SEQ_CLS:
+            # ignore classifier head for classification models (issue 2027)
+            # there is no fix name for the classifier head, so check the common ones
+            for name in SEQ_CLS_HEAD_NAMES:
+                cls_head = getattr(model, name, None)
+                if cls_head is not None:
+                    last_module_name = next(name for name, module in model.named_modules() if module is cls_head)
+                    module_names_to_exclude.add(last_module_name)
+                    break
+
+    # we don't want nested LoRA layers, i.e. LoRA being applied to possibly existing lora_A, lora_B, etc.
+    # see 2390
+    for prefix, module in model.named_modules():
+        if isinstance(module, BaseTunerLayer):
+            for suffix, child in module.named_modules():
+                if suffix:
+                    module_names_to_exclude.add(f"{prefix}.{suffix}")
+
+    linear_module_names -= module_names_to_exclude
+    peft_config.target_modules = linear_module_names
+    return peft_config
+
+
+def check_adapters_to_merge(module: BaseTunerLayer, adapter_names: Optional[list[str]] = None) -> list[str]:
+    """
+    Helper function to check which adapters should be merged.
+
+    Only return those adapters that are not already merged. Give a warning if some or all of the adapters are already
+    merged.
+
+    """
+    if adapter_names is None:
+        adapter_names = module.active_adapters
+    if isinstance(adapter_names, str):
+        raise TypeError(f"adapter_names should be a list of strings, got {adapter_names!r}.")
+
+    if module.merged:
+        merged_adapters = set(module.merged_adapters)
+        adapter_names = [name for name in adapter_names if name not in merged_adapters]
+
+        if adapter_names:
+            warnings.warn(
+                f"Already following adapters were merged {','.join(module.merged_adapters)}. "
+                f"You are now additionally merging {','.join(adapter_names)}."
+            )
+        else:
+            warnings.warn("All adapters are already merged, nothing to do.")
+
+    return adapter_names
+
+
+def clone_module(module: nn.Module, share_weights=False):
+    """Clone a module in a pytorch model.
+
+    Clones a module of a model, optionally sharing all the parameters between the original and the clone. Simplifies
+    reusing a module when manipulating the architecture of a model.
+    """
+    clone = copy.deepcopy(module)
+
+    def _share_weights(src: nn.Module, dst: nn.Module):
+        for name, param in src.named_parameters(recurse=False):
+            dst.register_parameter(name, param)
+
+    if share_weights:
+        for name, submodule in module.named_modules():
+            _share_weights(submodule, clone.get_submodule(name))
+
+    return clone
+
+
+def replicate_layers(model: nn.Module, layer_map: list[tuple[int, int]]):
+    """Replicate layers in a transformer model with weight sharing.
+
+    This function looks for a module list attribute at model[(.model)*].layers and replicates the layers in the module
+    list according to the layer map. For example the map `[[0, 4], [2, 5]]` will take the set of layers `[0, 1, 2, 3,
+    4]` and replace them with a module list containing `[0, 1, 2, 3, 2, 3, 4]`.
+    """
+    while hasattr(model, "model"):
+        model = model.model
+    # Some variants of the bert model nest the main model under the bert attribute.
+    if hasattr(model, "bert"):
+        model = model.bert
+
+    model_type = None
+    layers: nn.ModuleList = None
+    if hasattr(model, "layers"):
+        model_type = "llama"
+        layers = model.layers
+    elif hasattr(model, "encoder") and hasattr(model.encoder, "layer"):
+        model_type = "bert"
+        layers = model.encoder.layer
+    elif hasattr(model, "h"):
+        model_type = "falcon"
+        layers = model.h
+    if not model_type or not isinstance(layers, nn.ModuleList):
+        raise ValueError(
+            "Could not locate the layers attribute in the model. "
+            "Expected Llama, Bert or Falcon compatible architectures."
+        )
+
+    new_layers = []
+    for start, end in layer_map:
+        for i in range(start, end):
+            current_idx = len(new_layers)
+            new_layers.append(clone_module(layers[i], share_weights=True))
+            # This is a hack needed to work around the layer_idx introduced in HF transformers.
+            for submodule in new_layers[-1].modules():
+                if hasattr(submodule, "layer_idx"):
+                    submodule.layer_idx = current_idx
+    layers = nn.ModuleList(new_layers)
+    if model_type == "llama":
+        model.layers = layers
+    elif model_type == "bert":
+        model.encoder.layer = layers
+    elif model_type == "falcon":
+        model.h = layers
+    else:
+        raise ValueError("Unexpected model type, need to handle post-processing of layers.")
+    if hasattr(model.config, "num_hidden_layers"):  # Common to Llama, Bert, Falcon.
+        model.config.num_hidden_layers = len(new_layers)
+
+
+def find_parameter_name_by_module(model: nn.Module, reference_module: nn.Module) -> str:
+    """
+    Find layer name from the model by matching the reference module to the model named modules
+
+    Args:
+        model (nn.Module): The model with named modules
+        reference_module (nn.Module): The reference module to find
+
+    Returns:
+        str: Name of the layer
+    """
+    for n, m in model.named_modules():
+        if m is reference_module:
+            return n
+
+    return ""
+
+
+###############################
+# FUNCTIONS FOR functional.py #
+###############################
+
+
+def set_adapter(
+    model,
+    adapter_name: str | list[str],
+    inference_mode: bool = False,
+    layer_cls: type[BaseTunerLayer] = BaseTunerLayer,
+) -> None:
+    """Set the active PEFT adapter(s) of the model.
+
+    Active adapters are those adapters that participate in the forward pass. Use this function if you want to switch
+    between multiple PEFT adapters.
+
+    Args:
+        model (`nn.Module`):
+            The model on which the adapter(s) should be set.
+        adapter_name (str, list[str]):
+            The name(s) of the adapter(s) to set as active
+        inference_mode (bool, optional):
+             Whether the activated adapter should be frozen (i.e. `requires_grad=False`). Default is False.
+        layer_cls (type, optional):
+            The class of the adapter layer. Defaults to `BaseTunerLayer`.
+    """
+    _set_adapter(model, adapter_name, inference_mode=inference_mode)  # auxiliary modules
+    for module in model.modules():
+        if isinstance(module, layer_cls):
+            if module.merged:
+                warnings.warn("Adapter cannot be set when the model is merged. Unmerging the model first.")
+                module.unmerge()
+            module.set_adapter(adapter_name, inference_mode=inference_mode)
+
+
+def _delete_auxiliary_adapter(model, adapter_name: str, new_active_adapters: Optional[list[str]]) -> None:
+    for module in model.modules():
+        if isinstance(module, AuxiliaryTrainingWrapper):
+            module.delete_adapter(adapter_name, new_active_adapters=new_active_adapters)
+
+
+def delete_adapter(
+    model: nn.Module, adapter_name: str, prefix: str, layer_cls: type[BaseTunerLayer] = BaseTunerLayer
+) -> list[str] | None:
+    """
+    Delete an existing PEFT adapter.
+
+    Note: This function does not delete the PEFT config on the model, if there is one. It will also not completely
+    purge the PEFT layers if the last PEFT adapter is deleted. For this, consider using `model.unload()` if using a
+    PEFT model instance, or just reloading the base model.
+
+    Args:
+        model (`nn.Module`):
+            The model from which the adapter should be deleted.
+        adapter_name (str):
+            The name of the adapter to be deleted.
+        prefix (str):
+            The prefix of the PEFT method, e.g. "lora_" for LoRA.
+        layer_cls (type, optional):
+            The class of the adapter layer. Defaults to `BaseTunerLayer`.
+
+    Returns:
+        new_adapter (list[str] | None):
+            The name of remaining adapter(s) after deletion, or `None` if there are no active adapters left. Use this
+            to set the new active adapter of the model if necessary.
+    """
+    new_adapter = None
+
+    for key, target in model.named_modules():
+        if prefix in key:
+            continue
+        if isinstance(target, layer_cls):
+            target.delete_adapter(adapter_name)
+            if new_adapter is None:
+                new_adapter = target.active_adapters[:]
+
+    _delete_auxiliary_adapter(model, adapter_name=adapter_name, new_active_adapters=new_adapter)
+    return new_adapter
+
+
+def cast_adapter_dtype(model: nn.Module, adapter_name: str, autocast_adapter_dtype: bool = True) -> None:
+    """
+    A helper method to cast the adapter weights to the correct dtype.
+
+    Currently, this only upcasts float dtypes to float32.
+
+    Args:
+        adapter_name (`str`):
+            The adapter name.
+        autocast_adapter_dtype (`bool`, *optional*):
+            Whether to autocast the adapter dtype. Defaults to `True`.
+    """
+    if not autocast_adapter_dtype:
+        return
+
+    dtypes_to_convert_to_fp32 = {torch.float16, torch.bfloat16}
+    # Upcast lower precision floats like float8_e4m3fn; defensively only include dtypes that are actually found, as this
+    # could depend on torch version and platform
+    for name in UPCAST_DTYPES:
+        if (torch_dtype := getattr(torch, name, None)) is not None:
+            dtypes_to_convert_to_fp32.add(torch_dtype)
+
+    for module in model.modules():
+        if not isinstance(module, BaseTunerLayer):
+            continue
+
+        for submodule in module.modules():
+            if not isinstance(submodule, (nn.ModuleDict, nn.ParameterDict, BufferDict)):
+                continue
+
+            if adapter_name not in submodule:
+                continue
+
+            if isinstance(submodule[adapter_name], nn.Parameter):
+                if submodule[adapter_name].dtype in dtypes_to_convert_to_fp32:
+                    submodule[adapter_name].data = submodule[adapter_name].data.to(torch.float32)
+                continue
+
+            if isinstance(submodule[adapter_name], torch.Tensor):  # e.g. from a BufferDict
+                if submodule[adapter_name].dtype in dtypes_to_convert_to_fp32:
+                    submodule[adapter_name] = submodule[adapter_name].to(torch.float32)
+                continue
+
+            for param in submodule[adapter_name].parameters():
+                if param.dtype in dtypes_to_convert_to_fp32:
+                    param.data = param.data.to(torch.float32)
+
+
+def set_requires_grad(model, adapter_names: str | Sequence[str], requires_grad: bool = True) -> None:
+    """
+    Enable or disable gradients on the given adapter(s).
+
+    Args:
+        model (`nn.Module`):
+            The model whose adapter gradient requirements should be updated.
+        adapter_names (`str` or `Sequence[str]`):
+            The name of the adapter(s) whose gradients should be enabled/disabled.
+        requires_grad (`bool`, *optional*)
+            Whether to enable (`True`, default) or disable (`False`).
+    """
+    for module in model.modules():
+        if isinstance(module, (BaseTunerLayer, AuxiliaryTrainingWrapper)):
+            module.set_requires_grad(adapter_names=adapter_names, requires_grad=requires_grad)
+
+
+def get_device_map(model) -> dict:
+    if hasattr(model, "hf_device_map"):
+        # Multi-device case: accelerate dispatch is active and exposes hf_device_map
+        device_map = model.hf_device_map
+    else:
+        # Single-device case:
+        # Recent Transformers versions intentionally skip accelerate hooks when the
+        # device_map resolves to a single device (e.g. "cpu" or one GPU), so
+        # hf_device_map is not set. All parameters are guaranteed to be on the
+        # same device, which can be inferred from the first parameter.
+        device_map = {"": next(model.parameters()).device}
+    return device_map
diff --git a/src/peft/tuners/unilora/__init__.py b/src/peft/tuners/unilora/__init__.py
new file mode 100644
index 0000000..2c62790
--- /dev/null
+++ b/src/peft/tuners/unilora/__init__.py
@@ -0,0 +1,22 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+from peft.utils import register_peft_method
+
+from .config import UniLoraConfig
+from .layer import Linear, UniLoraLayer
+from .model import UniLoraModel
+
+
+__all__ = ["Linear", "UniLoraConfig", "UniLoraLayer", "UniLoraModel"]
+register_peft_method(name="unilora", config_cls=UniLoraConfig, model_cls=UniLoraModel)
diff --git a/src/peft/tuners/unilora/config.py b/src/peft/tuners/unilora/config.py
new file mode 100644
index 0000000..25c8b0d
--- /dev/null
+++ b/src/peft/tuners/unilora/config.py
@@ -0,0 +1,220 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from dataclasses import dataclass, field
+from typing import Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class UniLoraConfig(PeftConfig):
+    """
+    Configuration class for UniLora adapters.
+
+    This class defines all hyperparameters required to initialize and apply UniLora layers within the PEFT framework.
+    The configuration is intentionally minimal and only includes parameters that are actively used by the current
+    UniLora implementation.
+
+    Reference:
+        Uni-LoRA: One Vector Is All You Need https://arxiv.org/abs/2506.00799
+
+    Args:
+        r (`int`):
+            Rank of the low-rank adaptation. This controls the expressive capacity of the UniLora update.
+        proj_seed (`int`):
+            Random seed used to generate the fixed index assignment. This ensures reproducibility across runs.
+        theta_d_length (`int`):
+            Length of the shared UniLora vector `theta_d`.
+        target_modules (`Union[list[str], str]`, *optional*):
+            Names or patterns of modules to which UniLora adapters are applied.
+            - If a string is provided, it is treated as a regular expression.
+            - If a list is provided, modules are matched by exact name or suffix.
+            - The special value 'all-linear' applies UniLora to all Linear / Conv1D layers except the output layer.
+            If not specified, modules are inferred from the model architecture. An error is raised if the architecture
+            is unsupported.
+        unilora_dropout (`float`):
+            Dropout probability applied within UniLora layers.
+        fan_in_fan_out (`bool`):
+            Whether the replaced layer stores weights in (fan_in, fan_out) format. This should be set to True for
+            models such as GPT-2 that use Conv1D layers.
+        bias (`str`):
+            Specifies which bias terms are trainable:
+            - 'none': no bias parameters are updated
+            - 'all': all bias parameters are updated
+            - 'unilora_only': only biases inside UniLora layers are updated
+            Note: enabling bias updates changes model outputs even when adapters are disabled.
+        modules_to_save (`list[str]`, *optional*):
+            Additional modules (outside UniLora layers) that should remain trainable and be saved in the final
+            checkpoint. This is commonly used for task-specific heads such as classifiers.
+        init_theta_d_bound (`float`):
+            Initialization bound for the UniLora vector bank. Vectors are sampled uniformly from [-init_theta_d_bound,
+            init_theta_d_bound]. Initializing with zeros is avoided to prevent vanishing gradients. Small values (e.g.,
+            0.02) are recommended for stable training.
+        init_weights (`bool`):
+            Whether to initialize `theta_d` with the default UniLora initialization. If set to `False`, `theta_d` keeps
+            a random initialization.
+        save_indices (`bool`):
+            Whether to save the generated UniLora index and scale buffers alongside `theta_d`. This increases
+            checkpoint size, but makes saved adapters independent from future changes to the index generation routine.
+        layers_to_transform (`Union[list[int], int]`, *optional*):
+            Indices of transformer layers to which UniLora is applied. If specified, only these layers are modified.
+            This option is valid only when `target_modules` is a list.
+        layers_pattern (`Union[list[str], str]`, *optional*):
+            Custom layer name pattern used together with `layers_to_transform` when the model does not follow standard
+            layer naming conventions. This option is valid only when `target_modules` is a list.
+    """
+
+    r: int = field(
+        default=4,
+        metadata={
+            "help": "Rank of the low-rank adaptation. This controls the expressive capacity of the UniLora update."
+        },
+    )
+
+    proj_seed: int = field(
+        default=42,
+        metadata={
+            "help": "Random seed used to generate the fixed index assignment. This ensures reproducibility across runs."
+        },
+    )
+
+    theta_d_length: int = field(
+        default=256,
+        metadata={
+            "help": (
+                "Length of the shared UniLora vector `theta_d`. Larger values increase trainable parameters and "
+                "reduce collisions in the shared parameter space."
+            )
+        },
+    )
+
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "Names or patterns of modules to apply UniLora to. Accepts a list of "
+                "module name suffixes, a regex string, or the special value "
+                "'all-linear' to match all Linear/Conv1D layers except the output layer."
+            )
+        },
+    )
+
+    unilora_dropout: float = field(
+        default=0.0,
+        metadata={"help": "Dropout probability used inside UniLora layers."},
+    )
+
+    fan_in_fan_out: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Set to True if the target layer stores weights in (fan_in, fan_out) "
+                "format, e.g., GPT-2 Conv1D layers."
+            )
+        },
+    )
+
+    bias: str = field(
+        default="none",
+        metadata={"help": ("Bias handling strategy for UniLora. Options are 'none', 'all', or 'unilora_only'.")},
+    )
+
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "Additional non-UniLora modules to keep trainable and save in the "
+                "final checkpoint, such as task-specific classification heads."
+            )
+        },
+    )
+
+    init_theta_d_bound: float = field(
+        default=0.02,
+        metadata={
+            "help": (
+                "Initialization bound for UniLora vectors. Vectors are sampled "
+                "uniformly from [-bound, bound]. Small values are recommended "
+                "for stable training."
+            )
+        },
+    )
+
+    init_weights: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "Whether to initialize `theta_d` with the default UniLora initialization. If set to `False`, "
+                "`theta_d` keeps a random initialization."
+            )
+        },
+    )
+
+    save_indices: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Whether to save the generated UniLora index and scale buffers alongside `theta_d`. This increases "
+                "checkpoint size, but makes saved adapters independent from future changes to the index generation "
+                "routine."
+            )
+        },
+    )
+
+    layers_to_transform: Optional[Union[list[int], int]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "Indices of transformer layers to apply UniLora to. If specified, "
+                "only these layers are modified. Valid only when target_modules "
+                "is a list."
+            )
+        },
+    )
+
+    layers_pattern: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "Custom layer name pattern used together with layers_to_transform "
+                "when standard layer naming conventions are not followed. "
+                "Valid only when target_modules is a list."
+            )
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.UNILORA
+
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+
+        if self.r <= 0:
+            raise ValueError(f"`r` should be a positive integer, got {self.r}.")
+        if self.theta_d_length <= 0:
+            raise ValueError(f"`theta_d_length` should be a positive integer, got {self.theta_d_length}.")
+        if not 0.0 <= self.unilora_dropout <= 1.0:
+            raise ValueError(f"`unilora_dropout` should be between 0.0 and 1.0, got {self.unilora_dropout}.")
+        if self.init_theta_d_bound <= 0:
+            raise ValueError(f"`init_theta_d_bound` should be a positive float, got {self.init_theta_d_bound}.")
+        if self.bias not in {"none", "all", "unilora_only"}:
+            raise ValueError(f"`bias` should be 'none', 'all', or 'unilora_only', got {self.bias}.")
+        if isinstance(self.target_modules, str) and self.layers_to_transform is not None:
+            raise ValueError("`layers_to_transform` cannot be used when `target_modules` is a str.")
+        if isinstance(self.target_modules, str) and self.layers_pattern is not None:
+            raise ValueError("`layers_pattern` cannot be used when `target_modules` is a str.")
diff --git a/src/peft/tuners/unilora/layer.py b/src/peft/tuners/unilora/layer.py
new file mode 100644
index 0000000..f6e0d32
--- /dev/null
+++ b/src/peft/tuners/unilora/layer.py
@@ -0,0 +1,252 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+import warnings
+from typing import Optional
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from peft.tuners._buffer_dict import BufferDict
+from peft.tuners.tuners_utils import BaseTunerLayer, _get_in_out_features, check_adapters_to_merge
+from peft.utils.other import transpose
+
+
+class UniLoraLayer(BaseTunerLayer):
+    other_param_names = (
+        "r",
+        "unilora_theta_d",
+        "unilora_indices_A",
+        "unilora_indices_B",
+        "unilora_scales_A",
+        "unilora_scales_B",
+        "unilora_dropout",
+    )
+
+    def __init__(self, base_layer: nn.Module, **kwargs):
+        self.base_layer = base_layer
+        self.r = {}
+        self.unilora_dropout = nn.ModuleDict({})
+        self.unilora_indices_A = BufferDict({}, persistent=True)
+        self.unilora_indices_B = BufferDict({}, persistent=True)
+        self.unilora_scales_A = BufferDict({}, persistent=True)
+        self.unilora_scales_B = BufferDict({}, persistent=True)
+
+        self._disable_adapters = False
+        self.merged_adapters = []
+
+        base_layer = self.get_base_layer()
+        in_features, out_features = _get_in_out_features(base_layer)
+        if (in_features is None) or (out_features is None):
+            raise ValueError(
+                f"Could not infer input and output features for target module {base_layer}. "
+                "UniLora currently supports linear-like modules with known in/out features."
+            )
+
+        self.in_features = in_features
+        self.out_features = out_features
+        self.kwargs = kwargs
+
+    @property
+    def merged(self) -> bool:
+        return bool(self.merged_adapters)
+
+    def update_layer(
+        self,
+        adapter_name: str,
+        unilora_theta_d,
+        r: int,
+        theta_d_length: int,
+        unilora_dropout: float = 0.0,
+    ):
+        if r <= 0:
+            raise ValueError(f"`r` {r} should be a positive integer value")
+
+        self.r[adapter_name] = r
+
+        if unilora_dropout > 0.0:
+            unilora_dropout_layer = nn.Dropout(p=unilora_dropout)
+        else:
+            unilora_dropout_layer = nn.Identity()
+        self.unilora_dropout.update(nn.ModuleDict({adapter_name: unilora_dropout_layer}))
+
+        self.unilora_theta_d = unilora_theta_d
+        self.reset_unilora_parameters(adapter_name, theta_d_length)
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters)
+
+    def reset_unilora_parameters(self, adapter_name: str, theta_d_length: int) -> None:
+        if adapter_name in self.unilora_theta_d.keys():
+            indices_A = torch.randint(0, theta_d_length, (self.r[adapter_name], self.in_features), dtype=torch.long)
+            indices_B = torch.randint(0, theta_d_length, (self.out_features, self.r[adapter_name]), dtype=torch.long)
+
+            self.unilora_indices_A[adapter_name] = indices_A
+            self.unilora_indices_B[adapter_name] = indices_B
+
+    def update_scaling(
+        self,
+        adapter_name: str,
+        unilora_scales_A,
+        unilora_scales_B,
+    ):
+        if adapter_name in self.unilora_theta_d.keys():
+            base_layer = self.get_base_layer()
+            target_device = base_layer.weight.device
+            target_dtype = base_layer.weight.dtype
+
+            self.unilora_scales_A[adapter_name] = unilora_scales_A.to(device=target_device, dtype=target_dtype)
+            self.unilora_scales_B[adapter_name] = unilora_scales_B.to(device=target_device, dtype=target_dtype)
+            self._move_indices_to_device(adapter_name, target_device)
+
+    def _move_indices_to_device(self, adapter_name: str, device: torch.device) -> None:
+        for index_buffer in (self.unilora_indices_A, self.unilora_indices_B):
+            if adapter_name in index_buffer:
+                index_buffer[adapter_name] = index_buffer[adapter_name].to(device=device)
+
+    def _move_adapter_to_device_of_base_layer(self, adapter_name: str, device: Optional[torch.device] = None) -> None:
+        super()._move_adapter_to_device_of_base_layer(adapter_name, device=device)
+        base_layer = self.get_base_layer()
+        target_device = device or getattr(base_layer.weight, "device", None)
+        if target_device is not None:
+            self._move_indices_to_device(adapter_name, target_device)
+
+    def enable_adapters(self, enabled: bool) -> None:
+        super().enable_adapters(enabled)
+        if not enabled:
+            for theta_d in self.unilora_theta_d.values():
+                theta_d.requires_grad_(False)
+
+    def set_adapter(self, adapter_names: str | list[str], inference_mode: bool = False) -> None:
+        super().set_adapter(adapter_names, inference_mode=inference_mode)
+        if isinstance(adapter_names, str):
+            adapter_names = [adapter_names]
+
+        for adapter_name, theta_d in self.unilora_theta_d.items():
+            theta_d.requires_grad_(adapter_name in adapter_names and not inference_mode)
+
+
+class Linear(nn.Linear, UniLoraLayer):
+    def __init__(
+        self,
+        base_layer,
+        unilora_theta_d,
+        adapter_name: str,
+        r: int,
+        theta_d_length: int,
+        unilora_dropout: float = 0.0,
+        fan_in_fan_out: bool = False,
+        is_target_conv_1d_layer: bool = False,
+        **kwargs,
+    ) -> None:
+        super(nn.Linear, self).__init__()
+        UniLoraLayer.__init__(self, base_layer, **kwargs)
+        self.fan_in_fan_out = fan_in_fan_out
+        self._active_adapter = adapter_name
+        self.update_layer(
+            adapter_name,
+            unilora_theta_d,
+            r,
+            theta_d_length,
+            unilora_dropout,
+        )
+        self.is_target_conv_1d_layer = is_target_conv_1d_layer
+
+    def supports_lora_conversion(self, adapter_name: str = "default") -> bool:
+        return True
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.unilora_indices_A.keys():
+                base_layer = self.get_base_layer()
+                if safe_merge:
+                    if not torch.isfinite(self.unilora_theta_d[active_adapter]).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+                    orig_weights = base_layer.weight.data.clone()
+                    orig_weights += self.get_delta_weight(active_adapter)
+                    if not torch.isfinite(orig_weights).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+                    base_layer.weight.data = orig_weights
+                else:
+                    base_layer.weight.data += self.get_delta_weight(active_adapter)
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.unilora_indices_A.keys():
+                self.get_base_layer().weight.data -= self.get_delta_weight(active_adapter)
+
+    def _get_lora_matrices(self, adapter: str, cast_to_fp32: bool = False) -> tuple[torch.Tensor, torch.Tensor]:
+        unilora_indices_A = self.unilora_indices_A[adapter]
+        unilora_indices_B = self.unilora_indices_B[adapter]
+        unilora_theta_d = self.unilora_theta_d[adapter].to(unilora_indices_A.device)
+        scales_A = self.unilora_scales_A[adapter].to(unilora_indices_A.device)
+        scales_B = self.unilora_scales_B[adapter].to(unilora_indices_B.device)
+
+        if cast_to_fp32:
+            unilora_theta_d = unilora_theta_d.float()
+            scales_A = scales_A.float()
+            scales_B = scales_B.float()
+
+        A = unilora_theta_d[unilora_indices_A] * scales_A
+        B = unilora_theta_d[unilora_indices_B] * scales_B
+
+        return A, B
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        device = self.unilora_indices_A[adapter].device
+        dtype = self.unilora_theta_d[adapter].dtype
+
+        cast_to_fp32 = device.type == "cpu" and (dtype == torch.float16 or dtype == torch.bfloat16)
+        A, B = self._get_lora_matrices(adapter, cast_to_fp32)
+        output_tensor = transpose(B @ A, self.fan_in_fan_out)
+        if cast_to_fp32:
+            output_tensor = output_tensor.to(dtype=dtype)
+        return output_tensor
+
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        previous_dtype = x.dtype
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.unilora_indices_A.keys():
+                    continue
+
+                A, B = self._get_lora_matrices(active_adapter)
+                x = x.to(self.unilora_theta_d[active_adapter].dtype)
+                dropout = self.unilora_dropout[active_adapter]
+
+                result = result + F.linear(F.linear(dropout(x), A), B)
+
+        result = result.to(previous_dtype)
+        return result
diff --git a/src/peft/tuners/unilora/model.py b/src/peft/tuners/unilora/model.py
new file mode 100644
index 0000000..47a9b44
--- /dev/null
+++ b/src/peft/tuners/unilora/model.py
@@ -0,0 +1,242 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+import warnings
+
+import numpy as np
+import torch
+from torch import nn
+from transformers.pytorch_utils import Conv1D
+
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer
+from peft.utils import TRANSFORMERS_MODELS_TO_UNILORA_TARGET_MODULES_MAPPING
+
+from .config import UniLoraConfig
+from .layer import Linear, UniLoraLayer
+
+
+class UniLoraModel(BaseTuner):
+    """Creates a UniLora adapter around a pretrained model."""
+
+    prefix: str = "unilora_"
+    tuner_layer_cls = UniLoraLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_UNILORA_TARGET_MODULES_MAPPING
+
+    def __init__(
+        self,
+        model,
+        config,
+        adapter_name,
+        low_cpu_mem_usage: bool = False,
+        state_dict: dict[str, torch.Tensor] | None = None,
+    ) -> None:
+        super().__init__(
+            model,
+            config,
+            adapter_name,
+            low_cpu_mem_usage=low_cpu_mem_usage,
+            state_dict=state_dict,
+        )
+
+    def _ensure_unilora_theta_d(self) -> None:
+        if not hasattr(self, "unilora_theta_d"):
+            self.unilora_theta_d = nn.ParameterDict({})
+
+    def inject_adapter(
+        self,
+        model: nn.Module,
+        adapter_name: str,
+        autocast_adapter_dtype: bool = True,
+        low_cpu_mem_usage: bool = False,
+        state_dict: dict[str, torch.Tensor] | None = None,
+    ) -> None:
+        self._ensure_unilora_theta_d()
+        self._init_unilora_theta_d(self.peft_config[adapter_name], adapter_name)
+        super().inject_adapter(
+            model,
+            adapter_name,
+            autocast_adapter_dtype=autocast_adapter_dtype,
+            low_cpu_mem_usage=low_cpu_mem_usage,
+            state_dict=state_dict,
+        )
+        self._assign_unilora_indices_and_scales(adapter_name)
+
+    def _iter_unilora_layers(self):
+        for module in self.model.modules():
+            if isinstance(module, UniLoraLayer):
+                yield module
+
+    def _assign_unilora_indices_and_scales(self, adapter_name: str) -> None:
+        layers = [
+            module
+            for module in self._iter_unilora_layers()
+            if adapter_name in module.unilora_indices_A.keys() and adapter_name in module.unilora_indices_B.keys()
+        ]
+        lora_param_count = sum(
+            module.unilora_indices_A[adapter_name].numel() + module.unilora_indices_B[adapter_name].numel()
+            for module in layers
+        )
+        if lora_param_count == 0:
+            return
+
+        config = self.peft_config[adapter_name]
+        indices = self.generate_index(lora_param_count, config.theta_d_length, config.proj_seed)
+        chunk_idx = 0
+
+        for module in layers:
+            param_numel = module.unilora_indices_A[adapter_name].numel()
+            chunk = indices[chunk_idx : chunk_idx + param_numel]
+            module.unilora_indices_A[adapter_name] = chunk.view_as(module.unilora_indices_A[adapter_name]).clone()
+            chunk_idx += param_numel
+
+            param_numel = module.unilora_indices_B[adapter_name].numel()
+            chunk = indices[chunk_idx : chunk_idx + param_numel]
+            module.unilora_indices_B[adapter_name] = chunk.view_as(module.unilora_indices_B[adapter_name]).clone()
+            chunk_idx += param_numel
+
+        if chunk_idx != indices.numel():
+            raise ValueError(
+                "UniLora index assignment consumed a different number of indices than were generated. "
+                f"Expected {indices.numel()} values but consumed {chunk_idx}. Please open an issue with your "
+                "model architecture and UniLora configuration."
+            )
+
+        counts = torch.bincount(indices, minlength=config.theta_d_length)
+        inv_sqrt_counts = torch.zeros(config.theta_d_length, dtype=torch.float32)
+        used_indices = counts > 0
+        inv_sqrt_counts[used_indices] = counts[used_indices].float().rsqrt()
+
+        for module in layers:
+            scales_A = inv_sqrt_counts[module.unilora_indices_A[adapter_name].long()]
+            scales_B = inv_sqrt_counts[module.unilora_indices_B[adapter_name].long()]
+            module.update_scaling(adapter_name, scales_A, scales_B)
+
+    @staticmethod
+    def generate_index(lora_param_count: int, theta_d_length: int, proj_seed: int) -> torch.Tensor:
+        """Assign deterministic `theta_d` indices to the flattened UniLora parameter space.
+
+        A plain `np.random.choice(np.arange(theta_d_length), size=lora_param_count)` samples each position
+        independently, which can leave some `theta_d` entries unused for smaller adapters. UniLora instead uses a
+        balanced deterministic assignment: each index appears either `floor(D / d)` or `ceil(D / d)` times, where `D`
+        is the flattened LoRA parameter count and `d` is `theta_d_length`. This keeps per-index normalization stable
+        while still shuffling the assignment with `proj_seed`.
+        """
+        if lora_param_count < 0:
+            raise ValueError(f"`lora_param_count` must be non-negative, got {lora_param_count}.")
+        if theta_d_length <= 0:
+            raise ValueError(f"`theta_d_length` must be positive, got {theta_d_length}.")
+
+        base_count = lora_param_count // theta_d_length
+        remaining = lora_param_count % theta_d_length
+        rng = np.random.default_rng(proj_seed)
+        data = np.repeat(np.arange(theta_d_length), base_count)
+        if remaining > 0:
+            extras = rng.choice(theta_d_length, size=remaining, replace=False)
+            data = np.concatenate([data, extras])
+        rng.shuffle(data)
+        return torch.as_tensor(data, dtype=torch.long)
+
+    def _init_unilora_theta_d(self, config: UniLoraConfig, adapter_name: str) -> None:
+        if adapter_name in self.unilora_theta_d:
+            return
+
+        if config.init_weights:
+            unilora_theta_d = torch.empty(config.theta_d_length)
+            torch.nn.init.uniform_(unilora_theta_d, -config.init_theta_d_bound, config.init_theta_d_bound)
+        else:
+            unilora_theta_d = torch.randn(config.theta_d_length)
+        self.unilora_theta_d[adapter_name] = nn.Parameter(unilora_theta_d)
+
+    def _pre_injection_hook(self, model: nn.Module, config: UniLoraConfig, adapter_name: str) -> None:
+        self._ensure_unilora_theta_d()
+        self._init_unilora_theta_d(config, adapter_name)
+
+    def _create_and_replace(
+        self,
+        unilora_config,
+        adapter_name,
+        target,
+        target_name,
+        parent,
+        current_key,
+    ):
+        if current_key is None:
+            raise ValueError("Current key should not be `None` when creating a UniLora layer.")
+
+        self._init_unilora_theta_d(unilora_config, adapter_name)
+
+        bias = hasattr(target, "bias") and target.bias is not None
+        kwargs = {
+            "fan_in_fan_out": unilora_config.fan_in_fan_out,
+            "bias": bias,
+        }
+
+        if isinstance(target, Linear):
+            target.update_layer(
+                adapter_name=adapter_name,
+                unilora_theta_d=self.unilora_theta_d,
+                r=unilora_config.r,
+                theta_d_length=unilora_config.theta_d_length,
+                unilora_dropout=unilora_config.unilora_dropout,
+            )
+        else:
+            new_module = self._create_new_module(
+                unilora_config=unilora_config,
+                unilora_theta_d=self.unilora_theta_d,
+                adapter_name=adapter_name,
+                target=target,
+                **kwargs,
+            )
+            if adapter_name not in self.active_adapter:
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+    @staticmethod
+    def _create_new_module(unilora_config, unilora_theta_d, adapter_name, target, **kwargs):
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        if isinstance(target_base_layer, torch.nn.Linear):
+            if kwargs["fan_in_fan_out"]:
+                warnings.warn(
+                    "fan_in_fan_out is set to True but the target module is `torch.nn.Linear`. "
+                    "Setting fan_in_fan_out to False."
+                )
+                kwargs["fan_in_fan_out"] = unilora_config.fan_in_fan_out = False
+        elif isinstance(target_base_layer, Conv1D):
+            kwargs["is_target_conv_1d_layer"] = True
+            if not kwargs["fan_in_fan_out"]:
+                warnings.warn(
+                    "fan_in_fan_out is set to False but the target module is `Conv1D`. Setting fan_in_fan_out to True."
+                )
+                kwargs["fan_in_fan_out"] = unilora_config.fan_in_fan_out = True
+        else:
+            raise TypeError(
+                f"Target module {target} is not supported. Currently, only the following modules are supported: "
+                "`torch.nn.Linear`, `transformers.pytorch_utils.Conv1D`."
+            )
+
+        return Linear(
+            base_layer=target,
+            unilora_theta_d=unilora_theta_d,
+            adapter_name=adapter_name,
+            r=unilora_config.r,
+            theta_d_length=unilora_config.theta_d_length,
+            unilora_dropout=unilora_config.unilora_dropout,
+            **kwargs,
+        )
diff --git a/src/peft/tuners/vblora/__init__.py b/src/peft/tuners/vblora/__init__.py
new file mode 100644
index 0000000..8e71a08
--- /dev/null
+++ b/src/peft/tuners/vblora/__init__.py
@@ -0,0 +1,24 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+from peft.utils import register_peft_method
+
+from .config import VBLoRAConfig
+from .layer import Linear, VBLoRALayer
+from .model import VBLoRAModel
+
+
+__all__ = ["Linear", "VBLoRAConfig", "VBLoRALayer", "VBLoRAModel"]
+
+register_peft_method(name="vblora", config_cls=VBLoRAConfig, model_cls=VBLoRAModel)
diff --git a/src/peft/tuners/vblora/config.py b/src/peft/tuners/vblora/config.py
new file mode 100644
index 0000000..884a287
--- /dev/null
+++ b/src/peft/tuners/vblora/config.py
@@ -0,0 +1,196 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class VBLoRAConfig(PeftConfig):
+    """
+    This is the configuration class to store the configuration of a [`VBLoRAModel`].
+
+    Paper: https://huggingface.co/papers/2405.15179
+
+    Args:
+        r (`int`):
+            The rank of incremental matrices.
+        num_vectors (`int`):
+            Number of vectors in the vector bank. Use higher values when the model size increases.
+        vector_length (`int`):
+            The length of the vectors in the vector bank. The length of the vectors should be divisible by the hidden
+            dimension of the model.
+        topk (`int`):
+            The K value for top-K selection. A larger value of K increases the size of the saved model. In practice,
+            setting K=2 typically provides the best performance and parameter efficiency. For more details, refer to
+            the discussion in the paper.
+        target_modules (`Union[List[str], str]`):
+            The names of the modules to apply the adapter to. If this is specified, only the modules with the specified
+            names will be replaced. When passing a string, a regex match will be performed. When passing a list of
+            strings, either an exact match will be performed or it is checked if the name of the module ends with any
+            of the passed strings. If this is specified as 'all-linear', then all linear/Conv1D modules are chosen,
+            excluding the output layer. If this is not specified, modules will be chosen according to the model
+            architecture. If the architecture is not known, an error will be raised -- in this case, you should specify
+            the target modules manually.
+        exclude_modules (`Optional[Union[List[str], str]]`):
+            The names of the modules to not apply the adapter. When passing a string, a regex match will be performed.
+            When passing a list of strings, either an exact match will be performed or it is checked if the name of the
+            module ends with any of the passed strings.
+        save_only_topk_weights (`bool`):
+            Whether to only save the topk weights. Setting `save_only_topk_weights = True` significantly reduces
+            storage space. However, models saved in this mode can be used for merging or inference only, not for
+            resuming training.
+        vblora_dropout (`float`):
+            The dropout probability for VBLoRA layers.
+        fan_in_fan_out (`bool`):
+            Set this to True if the layer to replace stores weight like (fan_in, fan_out). For example, gpt-2 uses
+            `Conv1D` which stores weights like (fan_in, fan_out) and hence this should be set to `True`.
+        bias (`str`):
+            Bias type for VBLoRA. Can be 'none', 'all' or 'vblora_only'. If 'all' or 'vblora_only', the corresponding
+            biases will be updated during training. Be aware that this means that, even when disabling the adapters,
+            the model will not produce the same output as the base model would have without adaptation.
+        modules_to_save (`List[str]`):
+            List of modules apart from VBLoRA layers to be set as trainable and saved in the final checkpoint.
+        init_vector_bank_bound (`float`):
+            The vector bank is initialized with a uniform distribution between -init_vector_bank_bound and
+            init_vector_bank_bound. Avoid initializing the vector bank with all zeros to prevent zero gradients. A
+            small value, such as 0.02, is typically effective. Initializing with a large value may cause training
+            instability.
+        init_logits_std (`float`):
+            The logits are initialized with a normal distribution with a standard deviation of init_logits_std. Default
+            is 0.1.
+        layers_to_transform (`Union[List[int],int]`):
+            The layer indices to transform. If a list of ints is passed, it will apply the adapter to the layer indices
+            that are specified in this list. If a single integer is passed, it will apply the transformations on the
+            layer at this index.
+        layers_pattern (`Optional[Union[List[str], str]]`):
+            The layer pattern name, used only if `layers_to_transform` is different from `None`. This should target the
+            `nn.ModuleList` of the model, which is often called `'layers'` or `'h'`.
+    """
+
+    r: int = field(default=4, metadata={"help": "The rank of incremental matrices."})
+    num_vectors: int = field(
+        default=256,
+        metadata={"help": "Number of vectors in the vector bank. Use higher values when the model size increases."},
+    )
+    vector_length: int = field(
+        default=256,
+        metadata={
+            "help": "The length of the vectors in the vector bank. The length of the vectors should be divisible by "
+            "the hidden dimension of the model."
+        },
+    )
+    topk: int = field(
+        default=2,
+        metadata={
+            "help": "The K value for top-K selection. A larger value of K increases the size of the saved model. "
+            "In practice, setting K=2 typically provides the best performance and parameter efficiency. "
+            "For more details, refer to the discussion in the paper."
+        },
+    )
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of module names or regex expression of the module names to replace with LoRA."
+                "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'."
+                "This can also be a wildcard 'all-linear' which matches all linear/Conv1D layers except the output layer."
+                "If not specified, modules will be chosen according to the model architecture, If the architecture is "
+                "not known, an error will be raised -- in this case, you should specify the target modules manually."
+            )
+        },
+    )
+    exclude_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={"help": "List of module names or regex expression of the module names to exclude from VBLoRA."},
+    )
+    save_only_topk_weights: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Whether to only save the topk weights. Setting `save_only_topk_weights = True` significantly reduces "
+                "storage space. However, models saved in this mode can be used for merging or inference only, not for "
+                "resuming training."
+            )
+        },
+    )
+    vblora_dropout: float = field(default=0.0, metadata={"help": "VBLoRA dropout"})
+    fan_in_fan_out: bool = field(
+        default=False,
+        metadata={"help": "Set this to True if the layer to replace stores weight like (fan_in, fan_out)"},
+    )
+    bias: str = field(default="none", metadata={"help": "Bias type for VBLoRA. Can be 'none', 'all' or 'vblora_only'"})
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of modules apart from VBLoRA layers to be set as trainable and saved in the final checkpoint. For"
+                " example, in Sequence Classification or Token Classification tasks, the final layer"
+                " `classifier/score` are randomly initialized and as such need to be trainable and saved."
+            )
+        },
+    )
+    init_vector_bank_bound: float = field(
+        default=0.02,
+        metadata={
+            "help": (
+                "The vector bank is initialized with a uniform distribution between -init_vector_bank_bound and"
+                " init_vector_bank_bound. Avoid initializing the vector bank with all zeros to prevent zero gradients."
+                " A small value, such as 0.02, is typically effective. Initializing with a large value may cause"
+                " training instability."
+            ),
+        },
+    )
+    init_logits_std: float = field(
+        default=0.1,
+        metadata={
+            "help": (
+                "The logits are initialized with a normal distribution with a standard deviation of init_logits_std. "
+                "Default value 0.1 typically works well."
+            ),
+        },
+    )
+    layers_to_transform: Optional[Union[list[int], int]] = field(
+        default=None,
+        metadata={
+            "help": "The layer indexes to transform, is this argument is specified, PEFT will transform only the layers indexes that are specified inside this list. If a single integer is passed, PEFT will transform only the layer at this index. "
+            "This only works when target_modules is a list of str. This should target the `nn.ModuleList` of the "
+            "model, which is often called `'layers'` or `'h'`."
+        },
+    )
+    layers_pattern: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": "The layer pattern name, used only if `layers_to_transform` is different to None and if the layer pattern is not in the common layers pattern."
+            "This only works when target_modules is a list of str."
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.VBLORA
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        self.exclude_modules = (
+            set(self.exclude_modules) if isinstance(self.exclude_modules, list) else self.exclude_modules
+        )
+        # check for layers_to_transform and layers_pattern
+        if self.layers_pattern and not self.layers_to_transform:
+            raise ValueError("When `layers_pattern` is specified, `layers_to_transform` must also be specified. ")
diff --git a/src/peft/tuners/vblora/layer.py b/src/peft/tuners/vblora/layer.py
new file mode 100644
index 0000000..bbfe786
--- /dev/null
+++ b/src/peft/tuners/vblora/layer.py
@@ -0,0 +1,260 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+import warnings
+from typing import Optional
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+from transformers.pytorch_utils import Conv1D
+
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+from peft.utils.other import transpose
+
+from .config import VBLoRAConfig
+
+
+class VBLoRALayer(BaseTunerLayer):
+    # List all names of layers that may contain adapter weights
+    adapter_layer_names = ("vblora_logits_A", "vblora_logits_B", "vblora_vector_bank")
+    # All names of other parameters that may contain adapter-related parameters
+    other_param_names = ("r", "topk", "vblora_dropout")
+
+    def __init__(self, base_layer: nn.Module, **kwargs):
+        self.base_layer = base_layer
+        self.r = {}
+        self.topk = {}
+        self.vblora_dropout = nn.ModuleDict({})
+
+        # For storing vector scale
+        self.vblora_logits_A = nn.ParameterDict({})
+        self.vblora_logits_B = nn.ParameterDict({})
+
+        # Mark the weight as unmerged
+        self._disable_adapters = False
+        self.merged_adapters = []
+
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            in_features, out_features = base_layer.in_features, base_layer.out_features
+        elif isinstance(base_layer, Conv1D):
+            in_features, out_features = (
+                base_layer.weight.ds_shape if hasattr(base_layer.weight, "ds_shape") else base_layer.weight.shape
+            )
+
+        self.in_features = in_features
+        self.out_features = out_features
+        self.kwargs = kwargs
+
+    @property
+    def merged(self) -> bool:
+        return bool(self.merged_adapters)
+
+    def update_layer(
+        self,
+        adapter_name: str,
+        vblora_vector_bank,
+        r: int,
+        config: VBLoRAConfig,
+        inference_mode: bool = False,
+        **kwargs,
+    ):
+        topk = config.topk
+        num_vectors = config.num_vectors
+        vector_length = config.vector_length
+        vblora_dropout = config.vblora_dropout
+        init_logits_std = config.init_logits_std
+
+        if r <= 0:
+            raise ValueError(f"`r` {r} should be a positive integer value")
+        if topk <= 0:
+            raise ValueError(f"`topk` {topk} should be a positive integer value")
+
+        if self.in_features % vector_length != 0:
+            raise ValueError(f"`in_features` {self.in_features} must be divisible by `vector_length` {vector_length}")
+        if self.out_features % vector_length != 0:
+            raise ValueError(
+                f"`out_features` {self.out_features} must be divisible by `vector_length` {vector_length}"
+            )
+
+        self.r[adapter_name] = r
+        self.topk[adapter_name] = topk
+        if vblora_dropout > 0.0:
+            vblora_dropout_layer = nn.Dropout(p=vblora_dropout)
+        else:
+            vblora_dropout_layer = nn.Identity()
+        self.vblora_dropout.update(nn.ModuleDict({adapter_name: vblora_dropout_layer}))
+        self.vblora_logits_A[adapter_name] = nn.Parameter(
+            torch.zeros(r, self.in_features // vector_length, num_vectors), requires_grad=True
+        )
+        self.vblora_logits_B[adapter_name] = nn.Parameter(
+            torch.zeros(self.out_features // vector_length, r, num_vectors), requires_grad=True
+        )
+        self.vblora_vector_bank = vblora_vector_bank
+        self.reset_vblora_logits(adapter_name, init_logits_std)
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def reset_vblora_logits(self, adapter_name, init_logits_std):
+        if adapter_name in self.vblora_logits_A.keys():
+            with torch.no_grad():
+                nn.init.normal_(self.vblora_logits_A[adapter_name], 0, init_logits_std)
+                nn.init.normal_(self.vblora_logits_B[adapter_name], 0, init_logits_std)
+
+
+class Linear(nn.Linear, VBLoRALayer):
+    # VBLoRA implemented in a dense layer
+    def __init__(
+        self,
+        base_layer,
+        vblora_vector_bank,
+        adapter_name: str,
+        config: VBLoRAConfig,
+        r: int,
+        is_target_conv_1d_layer: bool = False,
+        **kwargs,
+    ) -> None:
+        # this gets the init from nn.Linear's super perspective, i.e. nn.Module.__init__, which should always be called
+        super(nn.Linear, self).__init__()
+        VBLoRALayer.__init__(self, base_layer, **kwargs)
+        self.fan_in_fan_out = config.fan_in_fan_out
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, vblora_vector_bank, r, config=config)
+        self.is_target_conv_1d_layer = is_target_conv_1d_layer
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.vblora_logits_A.keys():
+                base_layer = self.get_base_layer()
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    # because of the copy operation.
+                    orig_weights = base_layer.weight.data.clone()
+                    orig_weights += self.get_delta_weight(active_adapter)
+                    if not torch.isfinite(orig_weights).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+                    base_layer.weight.data = orig_weights
+                else:
+                    base_layer.weight.data += self.get_delta_weight(active_adapter)
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.vblora_logits_A.keys():
+                self.get_base_layer().weight.data -= self.get_delta_weight(active_adapter)
+
+    def _get_low_rank_matrix(self, logits: torch.tensor, vblora_vector_bank, topk) -> torch.Tensor:
+        top_k_logits, indices = logits.topk(topk, dim=-1)
+        topk_weights = F.softmax(top_k_logits, dim=-1)
+        return (topk_weights.unsqueeze(-1) * vblora_vector_bank[indices]).sum(-2)
+
+    def _get_lora_matrices(self, adapter, cast_to_fp32=False) -> tuple[torch.Tensor, torch.Tensor]:
+        vblora_logits_A = self.vblora_logits_A[adapter]
+        vblora_logits_B = self.vblora_logits_B[adapter]
+
+        # Check for infinity values when training. If found, training was likely resumed from a `save_only_topk_weights` model.
+        if self.training and vblora_logits_A[0, 0].isinf().any():
+            raise RuntimeError(
+                "Found infinity values in VB-LoRA logits. Ensure training was not resumed from a `save_only_topk_weights` model."
+            )
+
+        vblora_vector_bank = self.vblora_vector_bank[adapter].to(vblora_logits_A.device)
+        topk = self.topk[adapter]
+        # In case users wants to merge the adapter weights that are in
+        # float16 while being on CPU, we need to cast the weights to float32, perform the merge and then cast back to
+        # float16 because the `@` and matmul operation in general is not supported in torch + cpu + fp16.
+        if cast_to_fp32:
+            vblora_logits_A = vblora_logits_A.float()
+            vblora_logits_B = vblora_logits_B.float()
+            vblora_vector_bank = vblora_vector_bank.float()
+
+        # A: (rank, in_tile, vector_length) -> (rank, in_tile x vector_length)
+        A = self._get_low_rank_matrix(vblora_logits_A, vblora_vector_bank, topk).reshape(vblora_logits_A.shape[0], -1)
+        # B: (out_tile, rank, vector_length) -> (out_tile, vector_length, rank) -> (out_tile x vector_length, rank)
+        B = (
+            self._get_low_rank_matrix(vblora_logits_B, vblora_vector_bank, topk)
+            .transpose(1, 2)
+            .reshape(-1, vblora_logits_B.shape[1])
+        )
+        return A, B
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        """
+        Compute the delta weight for the given adapter.
+
+        Args:
+            adapter (str):
+                The name of the adapter for which the delta weight should be computed.
+        """
+        device = self.vblora_logits_A[adapter].device
+        dtype = self.vblora_logits_A[adapter].dtype
+        # In case users wants to merge the adapter weights that are in
+        # (b)float16 while being on CPU, we need to cast the weights to float32, perform the merge and then cast back to
+        # (b)float16 because some CPUs have slow bf16/fp16 matmuls.
+        cast_to_fp32 = device.type == "cpu" and (dtype == torch.float16 or dtype == torch.bfloat16)
+        A, B = self._get_lora_matrices(adapter, cast_to_fp32)
+        output_tensor = transpose(B @ A, self.fan_in_fan_out)
+        return output_tensor
+
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        previous_dtype = x.dtype
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.vblora_logits_A.keys():
+                    continue
+                A, B = self._get_lora_matrices(active_adapter)
+                x = x.to(self.vblora_vector_bank[active_adapter].dtype)
+                dropout = self.vblora_dropout[active_adapter]
+                result = result + F.linear(F.linear(dropout(x), A), B)
+        result = result.to(previous_dtype)
+        return result
+
+    def supports_lora_conversion(self, adapter_name: str = "default") -> bool:
+        return True
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "vblora." + rep
diff --git a/src/peft/tuners/vblora/model.py b/src/peft/tuners/vblora/model.py
new file mode 100644
index 0000000..992e51b
--- /dev/null
+++ b/src/peft/tuners/vblora/model.py
@@ -0,0 +1,201 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import warnings
+
+import torch
+from torch import nn
+from transformers.pytorch_utils import Conv1D
+
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer
+from peft.utils import TRANSFORMERS_MODELS_TO_VBLORA_TARGET_MODULES_MAPPING
+
+from .config import VBLoRAConfig
+from .layer import Linear, VBLoRALayer
+
+
+class VBLoRAModel(BaseTuner):
+    """
+    Creates VBLoRA model from a pretrained transformers model.
+
+    The method is described in detail in https://huggingface.co/papers/2405.15179.
+
+    Args:
+        model ([`~transformers.PreTrainedModel`]): The model to be adapted.
+        config ([`VBLoRAConfig`]): The configuration of the VBLoRA model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            Create empty adapter weights on meta device. Useful to speed up the loading process.
+
+    Returns:
+        `torch.nn.Module`: The VBLoRA model.
+
+    Example:
+
+        ```py
+        >>> from transformers import AutoModelForCausalLM
+        >>> from peft import VBLoRAConfig, get_peft_model
+
+        >>> base_model = AutoModelForCausalLM.from_pretrained("facebook/opt-125m")
+        >>> config = VBLoRAConfig(
+        ...     task_type="SEQ_CLS",
+        ...     r=4,
+        ...     target_modules=["fc1", "fc2", "k_proj", "out_proj", "q_proj", "v_proj"],
+        ...     num_vectors=60,
+        ...     vector_length=256,
+        ...     save_only_topk_weights=True,
+        ... )
+        >>> model = get_peft_model(base_model, config)
+        ```
+
+    **Attributes**:
+        - **model** ([`~transformers.PreTrainedModel`]) -- The model to be adapted.
+        - **peft_config** ([`VBLoRAConfig`]): The configuration of the VBLoRAConfig model.
+    """
+
+    prefix: str = "vblora_"
+    tuner_layer_cls = VBLoRALayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_VBLORA_TARGET_MODULES_MAPPING
+
+    def _init_vblora_vector_bank(self, config: VBLoRAConfig, adapter_name: str) -> None:
+        vblora_vector_bank = torch.zeros(config.num_vectors, config.vector_length)
+        torch.nn.init.uniform_(vblora_vector_bank, -config.init_vector_bank_bound, config.init_vector_bank_bound)
+        self.vblora_vector_bank[adapter_name] = vblora_vector_bank
+
+    def _pre_injection_hook(self, model: nn.Module, config: VBLoRAConfig, adapter_name: str) -> None:
+        self.vblora_vector_bank = nn.ParameterDict({})
+
+    def _create_and_replace(
+        self,
+        vblora_config,
+        adapter_name,
+        target,
+        target_name,
+        parent,
+        current_key,
+    ):
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+
+        bias = hasattr(target, "bias") and target.bias is not None
+        kwargs = {
+            "fan_in_fan_out": vblora_config.fan_in_fan_out,
+            "bias": bias,
+        }
+        self._init_vblora_vector_bank(vblora_config, adapter_name)
+        # TODO: add quantization support
+
+        if isinstance(target, Linear):
+            target.update_layer(
+                adapter_name=adapter_name,
+                vblora_vector_bank=self.vblora_vector_bank,
+                r=vblora_config.r,
+                config=vblora_config,
+            )
+        else:
+            new_module = self._create_new_module(
+                vblora_config=vblora_config,
+                vblora_vector_bank=self.vblora_vector_bank,
+                adapter_name=adapter_name,
+                target=target,
+                **kwargs,
+            )
+            if adapter_name not in self.active_adapter:
+                # adding an additional adapter: it is not automatically trainable
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+    @staticmethod
+    def _create_new_module(vblora_config, vblora_vector_bank, adapter_name, target, **kwargs):
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        if isinstance(target_base_layer, torch.nn.Linear):
+            if vblora_config.fan_in_fan_out:
+                warnings.warn(
+                    "fan_in_fan_out is set to True but the target module is `torch.nn.Linear`. "
+                    "Setting fan_in_fan_out to False."
+                )
+                vblora_config.fan_in_fan_out = False
+        elif isinstance(target_base_layer, Conv1D):
+            kwargs["is_target_conv_1d_layer"] = True
+            if not vblora_config.fan_in_fan_out:
+                warnings.warn(
+                    "fan_in_fan_out is set to False but the target module is `Conv1D`. Setting fan_in_fan_out to True."
+                )
+                vblora_config.fan_in_fan_out = True
+        else:
+            raise TypeError(
+                f"Target module {target} is not supported. Currently, only the following modules are supported: "
+                "`torch.nn.Linear`, `transformers.pytorch_utils.Conv1D`."
+            )
+        new_module = Linear(
+            base_layer=target,
+            vblora_vector_bank=vblora_vector_bank,
+            adapter_name=adapter_name,
+            config=vblora_config,
+            r=vblora_config.r,
+            **kwargs,
+        )
+
+        return new_module
+
+    def get_nb_savable_parameters(self, adapter="default") -> tuple[int, int]:
+        r"""
+        Returns the number of savable VB-LoRA parameters and other savable parameters.
+        """
+        logits_params = 0
+        vector_bank_params = 0
+        other_params = 0
+        for name, param in self.named_parameters():
+            if "vblora_logits" in name:
+                logits_params += param.numel()
+            elif "vblora_vector_bank" in name:
+                vector_bank_params += param.numel()
+            elif param.requires_grad:
+                other_params += param.numel()
+        if self.peft_config[adapter].save_only_topk_weights:
+            num_vectors = self.peft_config[adapter].num_vectors
+            factor = 1  # factor to count float32-equivalent parameters
+            if num_vectors < 2**8:
+                factor = 0.25
+            elif num_vectors < 2**15:
+                factor = 0.5
+            elif num_vectors < 2**31:
+                factor = 1
+            else:
+                factor = 2
+            topk_weight_params = (
+                logits_params / self.peft_config[adapter].num_vectors * (self.peft_config[adapter].topk - 1)
+            )
+            topk_indices_params = (
+                logits_params / self.peft_config[adapter].num_vectors * self.peft_config[adapter].topk * factor
+            )
+            vblora_params = int(vector_bank_params + topk_weight_params + topk_indices_params)
+        else:
+            vblora_params = vector_bank_params + logits_params
+        return vblora_params, other_params
+
+    def print_savable_parameters(self) -> None:
+        r"""
+        Prints the number of savable VB-LoRA parameters and total savable parameters.
+        """
+        vblora_params, other_params = self.get_nb_savable_parameters()
+        print(
+            f"VB-LoRA params to-be-saved (float32-equivalent): {vblora_params:,d} "
+            f"|| total params to-be-saved: {(vblora_params + other_params):,d}"
+        )
diff --git a/src/peft/tuners/vera/__init__.py b/src/peft/tuners/vera/__init__.py
new file mode 100644
index 0000000..ba7b137
--- /dev/null
+++ b/src/peft/tuners/vera/__init__.py
@@ -0,0 +1,25 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from peft.utils import register_peft_method
+
+from .config import VeraConfig
+from .layer import Linear, VeraLayer
+from .model import VeraModel
+
+
+__all__ = ["Linear", "VeraConfig", "VeraLayer", "VeraModel"]
+
+
+register_peft_method(name="vera", config_cls=VeraConfig, model_cls=VeraModel, prefix="vera_lambda_")
diff --git a/src/peft/tuners/vera/config.py b/src/peft/tuners/vera/config.py
new file mode 100644
index 0000000..df880b7
--- /dev/null
+++ b/src/peft/tuners/vera/config.py
@@ -0,0 +1,162 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import warnings
+from dataclasses import dataclass, field
+from typing import Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+
+@dataclass
+class VeraConfig(PeftConfig):
+    """
+    This is the configuration class to store the configuration of a [`VeraModel`].
+
+    Paper: https://huggingface.co/papers/2310.11454.
+
+    Args:
+        r (`int`, *optional*, defaults to `256`):
+            VeRA parameter dimension ("rank"). Choose higher values than LoRA ranks here, since VeRA uses far fewer
+            parameters than LoRA (see Table 1).
+        target_modules (`Union[List[str], str]`):
+            The names of the modules to apply Vera to. Only linear layers are supported.
+        projection_prng_key (`int`):
+            Vera PRNG init key. Used for initialising vera_A and vera_B for new models or when loading a checkpoint
+            that did not include these projections. Defaults to `0`.
+        save_projection (`bool`):
+            Whether to save the vera_A / vera_B projections in the state dict alongside per layer lambda_b / lambda_d
+            weights. This will increase the size of the checkpoint, but guarantee that we can reload the checkpoint on
+            all system configurations. Defaults to `True`.
+        vera_dropout (`float`):
+            The dropout probability for Vera layers.
+        d_initial (`float`, *optional*, defaults to `0.1`):
+            Initial init value for `vera_lambda_d` vector used when initializing the VeRA parameters. Small values
+            (<=0.1) are recommended (see Table 6c in the paper).
+        fan_in_fan_out (`bool`):
+            Set this to True if the layer to replace stores weight like (fan_in, fan_out). For example, gpt-2 uses
+            `Conv1D` which stores weights like (fan_in, fan_out) and hence this should be set to `True`.
+        bias (`str`):
+            Bias type for Vera. Can be 'none', 'all' or 'vera_only'. If 'all' or 'vera_only', the corresponding biases
+            will be updated during training. Be aware that this means that, even when disabling the adapters, the model
+            will not produce the same output as the base model would have without adaptation.
+        modules_to_save (`List[str]`):
+            List of modules apart from Vera layers to be set as trainable and saved in the final checkpoint.
+        init_weights (`bool`):
+            Whether to initialize the weights of the Vera layers with their default initialization. Don't change this
+            setting, except if you know exactly what you're doing.
+        layers_to_transform (`Union[List[int],int]`):
+            The layer indexes to transform, if this argument is specified, it will apply the Vera transformations on
+            the layer indexes that are specified in this list. If a single integer is passed, it will apply the Vera
+            transformations on the layer at this index.
+        layers_pattern (`Optional[Union[List[str], str]]`):
+            The layer pattern name, used only if `layers_to_transform` is different from `None`. This should target the
+            `nn.ModuleList` of the model, which is often called `'layers'` or `'h'`.
+    """
+
+    r: int = field(default=256, metadata={"help": "Vera attention dimension"})
+
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of module names or regex expression of the module names to replace with Vera."
+                "For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'. "
+                "Only linear layers are supported."
+            )
+        },
+    )
+    projection_prng_key: int = field(
+        default=0,
+        metadata={
+            "help": (
+                "Vera PRNG init key. Used for initialising vera_A and vera_B for new models or when loading a "
+                "checkpoint that did not include these projections."
+            )
+        },
+    )
+    save_projection: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "Whether to save the vera_A / vera_B projections in the state dict alongside per layer lambda_b / "
+                "lambda_d weights. This will increase the size of the checkpoint, but guarantee that we can reload "
+                "the checkpoint on all system configurations."
+            )
+        },
+    )
+    vera_dropout: float = field(default=0.0, metadata={"help": "Vera dropout"})
+    d_initial: float = field(default=0.1, metadata={"help": "Initial init value for d vector."})
+    fan_in_fan_out: bool = field(
+        default=False,
+        metadata={"help": "Set this to True if the layer to replace stores weight like (fan_in, fan_out)"},
+    )
+    bias: str = field(default="none", metadata={"help": "Bias type for Vera. Can be 'none', 'all' or 'vera_only'"})
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of modules apart from Vera layers to be set as trainable and saved in the final checkpoint. For"
+                " example, in Sequence Classification or Token Classification tasks, the final layer"
+                " `classifier/score` are randomly initialized and as such need to be trainable and saved."
+            )
+        },
+    )
+    init_weights: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "Whether to initialize the weights of the Vera layers with their default initialization. Don't change "
+                "this setting, except if you know exactly what you're doing."
+            ),
+        },
+    )
+    layers_to_transform: Optional[Union[list[int], int]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The layer indexes to transform, is this argument is specified, PEFT will transform only the layers"
+                " indexes that are specified inside this list. If a single integer is passed, PEFT will transform only"
+                " the layer at this index."
+            )
+        },
+    )
+    layers_pattern: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "The layer pattern name, used only if `layers_to_transform` is different to None and if the layer "
+                "pattern is not in the common layers pattern. This should target the `nn.ModuleList` of the "
+                "model, which is often called `'layers'` or `'h'`."
+            )
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.VERA
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        # check for layers_to_transform and layers_pattern
+        if self.layers_pattern and not self.layers_to_transform:
+            raise ValueError("When `layers_pattern` is specified, `layers_to_transform` must also be specified. ")
+        if not self.save_projection:
+            warnings.warn(
+                "Specified to not save vera_A and vera_B within the state dictionary, instead they will be restored "
+                "using the PRNG key store in `config.projection_prng_key`. Consider setting `config.save_projection` "
+                "to `True` to guarantee restoring the checkpoint correctly on all system configurations."
+            )
diff --git a/src/peft/tuners/vera/layer.py b/src/peft/tuners/vera/layer.py
new file mode 100644
index 0000000..36063fc
--- /dev/null
+++ b/src/peft/tuners/vera/layer.py
@@ -0,0 +1,299 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import warnings
+from typing import Optional
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from peft.tuners.tuners_utils import BaseTunerLayer, _get_in_out_features, check_adapters_to_merge
+from peft.utils import quantization_extra_repr, resolve_quantization_backend
+from peft.utils.other import transpose
+
+from .._buffer_dict import BufferDict
+from .config import VeraConfig
+
+
+class VeraLayer(BaseTunerLayer):
+    # List all names of layers that may contain adapter weights
+    adapter_layer_names = ("vera_lambda_b", "vera_lambda_d")
+    other_param_names = ("vera_A", "vera_B", "vera_dropout", "r")
+
+    def __init__(self, base_layer: nn.Module, **kwargs):
+        self.base_layer = base_layer
+        self.quantization_backend = resolve_quantization_backend(
+            self.get_base_layer(), get_apply_tensor_subclass=kwargs.get("get_apply_tensor_subclass")
+        )
+        self.r = {}
+        self.vera_dropout = nn.ModuleDict({})
+
+        # For storing vector scale
+        self.vera_lambda_b = nn.ParameterDict({})
+        self.vera_lambda_d = nn.ParameterDict({})
+
+        # Stores a reference to the vera_A/B BufferDict.
+        # Set to `None` otherwise to avoid computation with random weights
+        self.vera_A: Optional[BufferDict] = None
+        self.vera_B: Optional[BufferDict] = None
+
+        # Mark the weight as unmerged
+        self._disable_adapters = False
+        self.merged_adapters = []
+
+        base_layer = self.get_base_layer()
+        in_features, out_features = _get_in_out_features(base_layer)
+        if (in_features is None) or (out_features is None):
+            raise TypeError(f"Unsupported layer type {type(base_layer)}")
+
+        self.in_features = in_features
+        self.out_features = out_features
+        self.kwargs = kwargs
+
+    def update_layer(
+        self,
+        adapter_name,
+        vera_A: BufferDict,
+        vera_B: BufferDict,
+        r,
+        config: VeraConfig,
+        inference_mode: bool = False,
+        **kwargs,
+    ):
+        vera_dropout = config.vera_dropout
+        init_weights = config.init_weights
+        d_initial = config.d_initial
+
+        if r <= 0:
+            raise ValueError(f"`r` should be a positive integer value but the value passed is {r}")
+        self.r[adapter_name] = r
+        if vera_dropout > 0.0:
+            vera_dropout_layer = nn.Dropout(p=vera_dropout)
+        else:
+            vera_dropout_layer = nn.Identity()
+
+        self.vera_dropout.update(nn.ModuleDict({adapter_name: vera_dropout_layer}))
+        # Actual trainable parameters
+        self.vera_lambda_b[adapter_name] = nn.Parameter(torch.ones(self.out_features), requires_grad=True)
+        self.vera_lambda_d[adapter_name] = nn.Parameter(torch.randn(r), requires_grad=True)
+
+        # non trainable references to vera_A/B buffers
+        self.vera_A = vera_A
+        self.vera_B = vera_B
+        if adapter_name not in vera_A:
+            # This means that this is not the first VeRA adapter. We have to add an entry in the dict for this adapter.
+            if len(self.vera_A) < 1:
+                raise ValueError(
+                    "The `vera_A` and `vera_B` buffers are empty. This should not happen. Please report this issue."
+                )
+            # we can take any of the existing adapter's parameters, as they should all be identical
+            vera_A_param = next(iter(self.vera_A.values()))
+            vera_B_param = next(iter(self.vera_B.values()))
+
+            error_tmpl = (
+                "{} has a size of {} but {} or greater is required; this probably happened because an additional VeRA "
+                "adapter was added after the first one with incompatible shapes."
+            )
+            # check input size
+            if vera_A_param.shape[1] < self.in_features:
+                raise ValueError(error_tmpl.format("vera_A", vera_A_param.shape[1], self.in_features))
+            # check output size
+            if vera_B_param.shape[0] < self.out_features:
+                raise ValueError(error_tmpl.format("vera_B", vera_B_param.shape[0], self.out_features))
+            # check r
+            error_tmpl = (
+                "{} has a size of {} but {} or greater is required; this probably happened because an additional VeRA "
+                "adapter with a lower rank was added after the first one; loading the adapters "
+                "in reverse order may solve this."
+            )
+            if vera_A_param.shape[0] < self.r[adapter_name]:
+                raise ValueError(error_tmpl.format("vera_A", vera_A_param.shape[0], self.r[adapter_name]))
+            if vera_B_param.shape[1] < self.r[adapter_name]:
+                raise ValueError(error_tmpl.format("vera_B", vera_B_param.shape[1], self.r[adapter_name]))
+
+            self.vera_A[adapter_name] = vera_A_param
+            self.vera_B[adapter_name] = vera_B_param
+
+        if init_weights:
+            self.reset_vera_parameters(adapter_name, d_initial=d_initial)
+
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=inference_mode)
+
+    def reset_vera_parameters(self, adapter_name, d_initial: float = 0.1):
+        if adapter_name in self.vera_lambda_d.keys():
+            with torch.no_grad():
+                nn.init.zeros_(self.vera_lambda_d[adapter_name]).fill_(d_initial)
+                nn.init.zeros_(self.vera_lambda_b[adapter_name])
+
+
+class Linear(nn.Module, VeraLayer):
+    # Vera implemented in a dense layer
+    def __init__(
+        self,
+        base_layer,
+        vera_A: BufferDict,
+        vera_B: BufferDict,
+        adapter_name: str,
+        config: VeraConfig,
+        r: int = 0,
+        is_target_conv_1d_layer: bool = False,
+        **kwargs,
+    ) -> None:
+        # this gets the init from nn.Linear's super perspective, i.e. nn.Module.__init__, which should always be called
+        super().__init__()
+        VeraLayer.__init__(self, base_layer, **kwargs)
+        self.fan_in_fan_out = config.fan_in_fan_out
+
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, vera_A, vera_B, r, config=config)
+        self.is_target_conv_1d_layer = is_target_conv_1d_layer
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.vera_lambda_d.keys():
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    # because of the copy operation.
+                    weight = self.get_base_weight().clone()
+                    weight += self.get_delta_weight(active_adapter)
+
+                    if not torch.isfinite(weight).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    self.set_base_weight(weight)
+                else:
+                    weight = self.get_base_weight()
+                    weight += self.get_delta_weight(active_adapter)
+                    self.set_base_weight(weight)
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.vera_lambda_d.keys():
+                weight = self.get_base_weight()
+                weight -= self.get_delta_weight(active_adapter)
+                self.set_base_weight(weight)
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        """
+        Compute the delta weight for the given adapter.
+
+        Args:
+            adapter (str):
+                The name of the adapter for which the delta weight should be computed.
+        """
+        vera_A = self.vera_A[adapter]
+        vera_B = self.vera_B[adapter]
+
+        device = vera_B.device
+        dtype = vera_B.dtype
+
+        # In case users wants to merge the adapter weights that are in
+        # (b)float16 while being on CPU, we need to cast the weights to float32, perform the merge and then cast back to
+        # (b)float16 because some CPUs have slow bf16/fp16 matmuls.
+        cast_to_fp32 = device.type == "cpu" and (dtype == torch.float16 or dtype == torch.bfloat16)
+
+        lambda_d = self.vera_lambda_d[adapter]
+        lambda_b = self.vera_lambda_b[adapter]
+
+        if cast_to_fp32:
+            vera_A = vera_A.float()
+            vera_B = vera_B.float()
+            lambda_d = lambda_d.float()
+            lambda_b = lambda_b.float()
+
+        sliced_A = vera_A[:, : self.in_features].to(lambda_d.device)
+        sliced_B = vera_B[: self.out_features, :].to(lambda_d.device)
+        lambda_b = lambda_b.unsqueeze(-1)
+        lambda_d = lambda_d.unsqueeze(-1)
+        output_tensor = transpose((lambda_b * sliced_B) @ (lambda_d * sliced_A), self.fan_in_fan_out)
+
+        if cast_to_fp32:
+            output_tensor = output_tensor.to(dtype=dtype)
+
+        return output_tensor
+
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        previous_dtype = x.dtype
+
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+            orig_dtype = result.dtype
+            if self.quantization_backend is not None:
+                result = self.quantization_backend.maybe_clone_base_result(result)
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.vera_lambda_d.keys():
+                    continue
+
+                lambda_d = self.vera_lambda_d[active_adapter]
+                lambda_b = self.vera_lambda_b[active_adapter]
+
+                vera_A = self.vera_A[active_adapter]
+                vera_B = self.vera_B[active_adapter]
+
+                # As adapted layers may have different shapes and VeRA contains a single shared pair of A and B matrices,
+                # we initialize these matrices with the largest required size for each dimension.
+                # During the forward pass, required submatrices are sliced out from the shared vera_A and vera_B.
+                sliced_A = vera_A[:, : self.in_features].to(x.device)
+                sliced_B = vera_B[: self.out_features, :].to(x.device)
+
+                dropout = self.vera_dropout[active_adapter]
+                x = self._cast_input_dtype(x, lambda_d.dtype)
+                result = result + lambda_b * F.linear(lambda_d * F.linear(dropout(x), sliced_A), sliced_B)
+            result = result.to(orig_dtype)
+
+        result = result.to(previous_dtype)
+        return result
+
+    def supports_lora_conversion(self, adapter_name: str = "default") -> bool:
+        return True
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "vera." + rep
+
+    def extra_repr(self) -> str:
+        return quantization_extra_repr(self)
diff --git a/src/peft/tuners/vera/model.py b/src/peft/tuners/vera/model.py
new file mode 100644
index 0000000..d502a64
--- /dev/null
+++ b/src/peft/tuners/vera/model.py
@@ -0,0 +1,267 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+import math
+import warnings
+from typing import Union
+
+import torch
+from torch import nn
+from torch.nn.init import _calculate_correct_fan
+from transformers.pytorch_utils import Conv1D
+
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer, _get_in_out_features
+from peft.utils import (
+    TRANSFORMERS_MODELS_TO_VERA_TARGET_MODULES_MAPPING,
+    get_quantization_kwargs,
+    resolve_quantization_backend,
+)
+
+from .._buffer_dict import BufferDict
+from ..tuners_utils import _maybe_include_all_linear_layers
+from .config import VeraConfig
+from .layer import Linear, VeraLayer
+
+
+def _get_tuner_layer_class(target_base_layer: torch.nn.Module) -> type[VeraLayer] | None:
+    layer_cls: type[VeraLayer] | None = None
+    if isinstance(target_base_layer, (torch.nn.Linear, Conv1D)):
+        layer_cls = Linear
+    elif (quant_backend := resolve_quantization_backend(target_base_layer)) is not None:
+        layer_cls = {"linear": Linear}.get(quant_backend.layer_type)
+
+    return layer_cls
+
+
+def _kaiming_init(
+    tensor_or_shape: Union[torch.Tensor, tuple[int, ...]],
+    generator: torch.Generator,
+) -> torch.Tensor:
+    """
+    Kaiming Uniform Initialisation adapted to accept a `torch.Generator` object for PRNG.
+
+    Args:
+        tensor_or_shape (`Union[torch.Tensor, tuple[int, ...]]`):
+            Tensor to initialise, or shape of new tensor to create and then initialise.
+        generator: (`torch.Generator`):
+            Generator object that manages the state of the PRNG algorithm in use.
+
+    Returns:
+        `torch.Tensor`: The initialised tensor.
+    """
+    if isinstance(tensor_or_shape, tuple):
+        tensor = torch.empty(tensor_or_shape)
+    else:
+        tensor = tensor_or_shape
+    fan = _calculate_correct_fan(tensor, "fan_in")
+    gain = math.sqrt(2)
+    std = gain / math.sqrt(fan)
+    bound = math.sqrt(3.0) * std
+
+    with torch.no_grad():
+        return tensor.uniform_(-bound, bound, generator=generator)
+
+
+class VeraModel(BaseTuner):
+    """
+    Creates Vector-based Random Matrix Adaptation (Vera) model from a pretrained transformers model.
+
+    Args:
+        model ([`~transformers.PreTrainedModel`]): The model to be adapted.
+        config ([`VeraConfig`]): The configuration of the Vera model.
+        adapter_name (`str`): The name of the adapter, defaults to `"default"`.
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            Create empty adapter weights on meta device. Useful to speed up the loading process.
+
+    Returns:
+        `torch.nn.Module`: The Vera model.
+
+    Example:
+
+        ```py
+        >>> from transformers import AutoModelForCausalLM
+        >>> from peft import VeraConfig, get_peft_model
+
+        >>> base_model = AutoModelForCausalLM.from_pretrained("facebook/opt-125m")
+        >>> config = VeraConfig(r=128)
+        >>> model = get_peft_model(base_model, config)
+        ```
+
+    **Attributes**:
+        - **model** ([`~transformers.PreTrainedModel`]) -- The model to be adapted.
+        - **peft_config** ([`VeraConfig`]): The configuration of the Vera model.
+    """
+
+    prefix: str = "vera_lambda_"
+    tuner_layer_cls = VeraLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_VERA_TARGET_MODULES_MAPPING
+
+    def _find_dim(self, config) -> tuple[int, int]:
+        """
+        Finds the largest input and output dimensions across linear layers that have been wrapped with VeRA.
+
+        This will be used for determining the size of the shared vera_A and vera_B matrices.
+        """
+        model_config = self.get_model_config(self.model)
+
+        peft_config = self._prepare_adapter_config(config, model_config)
+        peft_config = _maybe_include_all_linear_layers(peft_config, self.model)
+
+        largest_shape = None
+        for key, module in self.model.named_modules():
+            if not self._check_target_module_exists(peft_config, key):
+                continue
+
+            if _get_tuner_layer_class(module) is None:
+                continue
+            in_features, out_features = _get_in_out_features(module)
+            module_shape = (out_features, in_features)
+
+            if largest_shape is None:
+                largest_shape = module_shape
+                continue
+
+            if module_shape != largest_shape:
+                largest_shape = tuple(max(a, b) for a, b in zip(largest_shape, module_shape))
+
+        if largest_shape is None:
+            msg = "No layers types compatible with VeRA were found. Please check `peft_config.target_modules`."
+            raise ValueError(msg)
+
+        return largest_shape
+
+    def _init_vera_A_vera_B(self, config: VeraConfig, adapter_name: str) -> None:
+        linear_out_dim, linear_in_dim = self._find_dim(config)
+
+        # use of persistent to exclude vera_A and vera_B from the state dict if we choose not to save them.
+        self.vera_A = BufferDict({}, persistent=config.save_projection)
+        self.vera_B = BufferDict({}, persistent=config.save_projection)
+
+        # deterministic init of vera_A and vera_B if we know the key
+        generator = torch.Generator(device="cpu").manual_seed(config.projection_prng_key)
+        vera_A = _kaiming_init((config.r, linear_in_dim), generator=generator)
+        vera_B = _kaiming_init((linear_out_dim, config.r), generator=generator)
+
+        self.vera_A[adapter_name] = vera_A
+        self.vera_B[adapter_name] = vera_B
+
+    def _pre_injection_hook(self, model: nn.Module, config: VeraConfig, adapter_name: str) -> None:
+        self._init_vera_A_vera_B(config, adapter_name)
+
+    def _check_new_adapter_config(self, config: VeraConfig) -> None:
+        """
+        A helper method to check the config when a new adapter is being added.
+
+        Raise a ValueError if there is something wrong with the config or if it conflicts with existing adapters.
+
+        """
+        super()._check_new_adapter_config(config)
+
+        for existing_config in self.peft_config.values():
+            if existing_config is config:
+                # skip the current config
+                continue
+
+            if existing_config.projection_prng_key != config.projection_prng_key:
+                raise ValueError(
+                    f"Vera PRNG initialisation key must be the same for all adapters. Got {config.projection_prng_key=} but "
+                    f"previous config had {existing_config.projection_prng_key}."
+                )
+
+        save_project_unique_values = sorted({config.save_projection for config in self.peft_config.values()})
+        if len(save_project_unique_values) > 1:
+            raise ValueError(
+                "VeRA projection weights must be saved for all adapters or none, but got multiple different values: "
+                f"{save_project_unique_values}"
+            )
+
+    def _create_and_replace(
+        self,
+        vera_config,
+        adapter_name,
+        target,
+        target_name,
+        parent,
+        current_key,
+        **optional_kwargs,
+    ):
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+
+        r = vera_config.r
+        bias = hasattr(target, "bias") and target.bias is not None
+        kwargs = {
+            "r": r,
+            "loaded_in_8bit": getattr(self.model, "is_loaded_in_8bit", False),
+            "loaded_in_4bit": getattr(self.model, "is_loaded_in_4bit", False),
+            "bias": bias,
+        }
+        kwargs.update(get_quantization_kwargs(self))
+
+        if isinstance(target, Linear):
+            target.update_layer(
+                adapter_name,
+                self.vera_A,
+                self.vera_B,
+                r,
+                config=vera_config,
+            )
+        else:
+            new_module = self._create_new_module(vera_config, self.vera_A, self.vera_B, adapter_name, target, **kwargs)
+            if adapter_name not in self.active_adapter:
+                # adding an additional adapter: it is not automatically trainable
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+    @staticmethod
+    def _create_new_module(vera_config, vera_A, vera_B, adapter_name, target, **kwargs):
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        layer_cls = _get_tuner_layer_class(target_base_layer)
+        if layer_cls is None:
+            raise TypeError(
+                f"Target module {target} is not supported. Currently, only `torch.nn.Linear` (optionally quantized) "
+                "and `transformers.pytorch_utils.Conv1D` are supported."
+            )
+
+        if isinstance(target_base_layer, Conv1D):
+            kwargs["is_target_conv_1d_layer"] = True
+            if not vera_config.fan_in_fan_out:
+                warnings.warn(
+                    "fan_in_fan_out is set to False but the target module is `Conv1D`. Setting fan_in_fan_out to True."
+                )
+                vera_config.fan_in_fan_out = True
+        elif vera_config.fan_in_fan_out:
+            # nn.Linear or a quantized linear layer
+            warnings.warn(
+                "fan_in_fan_out is set to True but the target module is `torch.nn.Linear`. "
+                "Setting fan_in_fan_out to False."
+            )
+            vera_config.fan_in_fan_out = False
+
+        new_module = layer_cls(
+            target,
+            vera_A,
+            vera_B,
+            adapter_name,
+            config=vera_config,
+            **kwargs,
+        )
+
+        return new_module
diff --git a/src/peft/tuners/waveft/__init__.py b/src/peft/tuners/waveft/__init__.py
new file mode 100644
index 0000000..f0e6fbc
--- /dev/null
+++ b/src/peft/tuners/waveft/__init__.py
@@ -0,0 +1,24 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from peft.utils import register_peft_method
+
+from .config import WaveFTConfig
+from .layer import WaveFTLayer, WaveFTLinear
+from .model import WaveFTModel
+
+
+__all__ = ["WaveFTConfig", "WaveFTLayer", "WaveFTLinear", "WaveFTModel"]
+
+register_peft_method(name="waveft", model_cls=WaveFTModel, config_cls=WaveFTConfig)
diff --git a/src/peft/tuners/waveft/config.py b/src/peft/tuners/waveft/config.py
new file mode 100644
index 0000000..f2233c9
--- /dev/null
+++ b/src/peft/tuners/waveft/config.py
@@ -0,0 +1,265 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Optional, Union
+
+from peft.config import PeftConfig
+from peft.utils import PeftType
+
+from .constants import WAVELET_REDUCTIONS
+
+
+@dataclass
+class WaveFTConfig(PeftConfig):
+    """
+    This is the configuration class to store the configuration of a [`WaveFTModel`]. It is used to define the
+    parameters for Wavelet-based Fine-Tuning (WaveFT), an approach that leverages the sparsity of wavelet transforms
+    for parameter-efficient fine-tuning of pretrained models.
+
+    Args:
+        n_frequency (`int`):
+            Number of learnable wavelet coefficients for the Discrete Wavelet Transform (DWT). 'n_frequency' is an
+            integer that is greater than 0 and less than or equal to the total number of elements in the original
+            weight matrix (d_out * d_in). This parameter directly controls the number of trainable parameters for each
+            adapted layer. A higher 'n_frequency' generally leads to better performance but also increases GPU memory
+            usage, with a minor impact on training speed.
+        scaling (`float`):
+            The scaling factor applied to the reconstructed delta W matrix. This is a crucial hyperparameter, analogous
+            to `lora_alpha` in LoRA. It can be tuned during hyperparameter search. Our default value for SDXL
+            personalization is 25.
+        wavelet_family (`str`):
+            The wavelet family (e.g., 'db1', 'sym2', 'coif1') to use for the DWT and Inverse DWT (IDWT). Defaults to
+            'db1' (Haar wavelet). Different wavelet families have varying filter lengths which affect the training time
+            substantially
+        use_idwt (`bool`):
+            Set to False for efficient adaptation. Whether to use the Inverse Discrete Wavelet Transform (IDWT) to
+            reconstruct the delta weights from the learned wavelet coefficients. If `True` (default), the IDWT is
+            applied. If `False`, the learned coefficients are directly used to form a sparse delta weight matrix, which
+            is faster but performs worse for the SDXL personalization task.
+        random_loc_seed (`int`):
+            Seed for determining the random locations of the `n_frequency` learnable wavelet coefficients within the
+            full wavelet coefficient matrix.
+        target_modules (`Union[list[str],str]`):
+            List of module names or a regex expression identifying the modules to be adapted with WaveFT. For example,
+            `['q_proj', 'v_proj']` or `'.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'`. Currently, only linear
+            layers (`torch.nn.Linear`) are supported.
+        exclude_modules (`Optional[Union[List[str], str]]`):
+            List of module names or a regex expression for modules to exclude from WaveFT adaptation.
+        fan_in_fan_out (`bool`):
+            Set to `True` if the weights of the layer to be replaced are stored in `(fan_in, fan_out)` format. Default
+            is `False`.
+        bias (`str`):
+            Bias type for WaveFT. Can be 'none', 'all', or 'waveft_only'. ('fourier_only' was likely a typo and has
+            been corrected to 'waveft_only' if it implies bias only on adapted parameters) If 'waveft_only', biases are
+            added only to the WaveFT components. If 'all', biases are added to both base and WaveFT components. If
+            'none', no new biases are added.
+        modules_to_save (`list[str]`):
+            List of modules, in addition to WaveFT layers, that should be marked as trainable and saved in the final
+            checkpoint. Useful for layers like classifiers in sequence or token classification tasks that are randomly
+            initialized and need training.
+        layers_to_transform (`Union[list[int],int]`):
+            Specific layer indices to transform. If provided, PEFT will only adapt layers at these indices. If a single
+            integer is given, only that layer is transformed.
+        layers_pattern (`Optional[Union[List[str], str]]`):
+            Pattern for layer names, used if `layers_to_transform` is specified and the layer pattern is not standard
+            (e.g., not 'layers' or 'h'). This should target the `nn.ModuleList` attribute in the model.
+        n_frequency_pattern (`dict`):
+            A dictionary mapping layer names (or regex) to specific `n_frequency` values, overriding the global
+            `n_frequency`. Example: `{"model.decoder.layers.0.encoder_attn.k_proj": 1000}`.
+        init_weights (`bool`):
+            Initialization strategy for the learnable wavelet coefficients (spectrum). If `True` (default),
+            coefficients are initialized to zeros. If `False`, coefficients are initialized from a standard normal
+            distribution scaled by a small factor.
+        proportional_parameters (`bool`):
+            If `True`, `n_frequency` is allocated proportionally to each layer's `input_dim * output_dim`. Default is
+            `False`. Note: This option is included for experimental thoroughness to allow researchers to reproduce
+            paper results, rather than for practical utility, as no beneficial scenarios have been identified.
+    """
+
+    n_frequency: int = field(
+        default=2592,  # Default value might need adjustment based on common use cases or paper findings
+        metadata={
+            "help": (
+                "Number of learnable wavelet coefficients for the Discrete Wavelet Transform (DWT). "
+                "'n_frequency' is an integer that is greater than 0 and less than or equal to the "
+                "total number of elements in the original weight matrix (d_out * d_in). "
+                "This parameter directly controls the number of trainable parameters for each adapted layer. "
+                "A higher 'n_frequency' generally leads to better performance but also increases "
+                "GPU memory usage, with a minor impact on training speed."
+            )
+        },
+    )
+    scaling: float = field(
+        default=25.0,  # Default value seems low based on typical examples, might need adjustment
+        metadata={
+            "help": (
+                "The scaling factor applied to the reconstructed delta W matrix. This is a crucial "
+                "hyperparameter, analogous to 'lora_alpha' in LoRA. It can be tuned during hyperparameter "
+                "search. Default value for SDXL personalization is 25. "
+            )
+        },
+    )
+    wavelet_family: str = field(
+        default="db1",
+        metadata={
+            "help": (
+                "The wavelet family (e.g., 'db1', 'sym2', 'coif1') to use for the DWT and Inverse DWT (IDWT). "
+                "Defaults to 'db1' (Haar wavelet). Different wavelet families have varying filter lengths "
+                "which affect the training time substantially. Size differences are handled automatically "
+                "if use_idwt is True."
+            )
+        },
+    )
+    use_idwt: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "Set to False for efficient adaptation. "
+                "Whether to use the Inverse Discrete Wavelet Transform (IDWT) to reconstruct the delta "
+                "weights from the learned wavelet coefficients. If True (default), the IDWT is applied. "
+                "If False, the learned coefficients are directly used to form a sparse delta weight matrix, "
+                "which is faster but performs worse for the SDXL personalization task."
+            )
+        },
+    )
+    random_loc_seed: int = field(
+        default=777,
+        metadata={
+            "help": (
+                "Seed for determining the random locations of the 'n_frequency' learnable wavelet "
+                "coefficients within the full wavelet coefficient matrix."
+            )
+        },
+    )
+    fan_in_fan_out: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Set to True if the weights of the layer to be replaced are stored in (fan_in, fan_out) "
+                "format. Default is False."
+            )
+        },
+    )
+    target_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of module names or a regex expression identifying the modules to be adapted with WaveFT. "
+                "For example, ['q_proj', 'v_proj'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'. "
+                "Currently, only linear layers (torch.nn.Linear) are supported."
+            )
+        },
+    )
+    exclude_modules: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={"help": "List of module names or regex for modules to exclude from WaveFT adaptation."},
+    )
+    bias: str = field(
+        default="none",
+        metadata={
+            "help": (
+                "Bias type for WaveFT. Can be 'none', 'all', or 'waveft_only'. "
+                "If 'waveft_only', biases are added only to the WaveFT components. "
+                "If 'all', biases are added to both base and WaveFT components. "
+                "If 'none', no new biases are added."
+            )
+        },
+    )
+    modules_to_save: Optional[list[str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "List of modules, in addition to WaveFT layers, that should be marked as trainable "
+                "and saved in the final checkpoint. Useful for layers like classifiers in sequence "
+                "or token classification tasks that are randomly initialized and need training."
+            )
+        },
+    )
+    layers_to_transform: Optional[Union[list[int], int]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "Specific layer indices to transform. If provided, PEFT will only adapt layers at these "
+                "indices. If a single integer is given, only that layer is transformed."
+            )
+        },
+    )
+    layers_pattern: Optional[Union[list[str], str]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "Pattern for layer names, used if `layers_to_transform` is specified and the layer "
+                "pattern is not standard (e.g., not 'layers' or 'h'). This should target the "
+                "`nn.ModuleList` attribute in the model."
+            )
+        },
+    )
+    n_frequency_pattern: Optional[dict] = field(
+        default_factory=dict,
+        metadata={
+            "help": (
+                "A dictionary mapping layer names (or regex) to specific `n_frequency` values, "
+                'overriding the global `n_frequency`. Example: {"model.decoder.layers.0.encoder_attn.k_proj": 1000}.'
+            )
+        },
+    )
+    proportional_parameters: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "If True, 'n_frequency' is allocated proportionally to each layer's "
+                "input_dim * output_dim. Default is False. Note: This option is included "
+                "for experimental thoroughness to allow researchers to reproduce paper results, "
+                "rather than for practical utility, as no beneficial scenarios have been identified."
+            )
+        },
+    )
+    init_weights: bool = field(
+        default=True,
+        metadata={
+            "help": (
+                "Initialization strategy for the learnable wavelet coefficients (spectrum). "
+                "If True (default), coefficients are initialized to zeros. "
+                "If False, coefficients are initialized from a standard normal distribution scaled by a small factor."
+            )
+        },
+    )
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.WAVEFT
+        self.target_modules = (
+            set(self.target_modules) if isinstance(self.target_modules, list) else self.target_modules
+        )
+        self.exclude_modules = (
+            set(self.exclude_modules) if isinstance(self.exclude_modules, list) else self.exclude_modules
+        )
+        # if target_modules is a regex expression, then layers_to_transform should be None
+        if isinstance(self.target_modules, str) and self.layers_to_transform is not None:
+            raise ValueError("`layers_to_transform` cannot be used when `target_modules` is a str.")
+
+        # if target_modules is a regex expression, then layers_pattern should be None
+        if isinstance(self.target_modules, str) and self.layers_pattern is not None:
+            raise ValueError("`layers_pattern` cannot be used when `target_modules` is a str.")
+        # check for layers_to_transform and layers_pattern
+        if self.layers_pattern and not self.layers_to_transform:
+            raise ValueError("When `layers_pattern` is specified, `layers_to_transform` must also be specified. ")
+
+        if self.wavelet_family not in WAVELET_REDUCTIONS:
+            raise ValueError(
+                f"Wavelet family {self.wavelet_family} not supported. Supported wavelet families are: {list(WAVELET_REDUCTIONS.keys())}"
+            )
diff --git a/src/peft/tuners/waveft/constants.py b/src/peft/tuners/waveft/constants.py
new file mode 100644
index 0000000..b1559f4
--- /dev/null
+++ b/src/peft/tuners/waveft/constants.py
@@ -0,0 +1,96 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+"""
+Dimensional reduction amounts for different wavelet families during wavelet transforms Each tuple (rows, cols)
+represents the reduction in matrix dimensions that occurs when applying wavelet decomposition/reconstruction due to
+boundary effects and filter sizes. These values are used to pre-pad matrices before wavelet processing to ensure the
+reconstructed matrix maintains the original target dimensions.
+"""
+
+WAVELET_REDUCTIONS = {
+    "db1": (0, 0),
+    "db2": (2, 2),
+    "db3": (4, 4),
+    "db4": (6, 6),
+    "db5": (8, 8),
+    "db6": (10, 10),
+    "db7": (12, 12),
+    "db8": (14, 14),
+    "db9": (16, 16),
+    "db10": (18, 18),
+    "db11": (20, 20),
+    "db12": (22, 22),
+    "db13": (24, 24),
+    "db14": (26, 26),
+    "db15": (28, 28),
+    "db16": (30, 30),
+    "db17": (32, 32),
+    "db18": (34, 34),
+    "db19": (36, 36),
+    "db20": (38, 38),
+    "db21": (40, 40),
+    "db22": (42, 42),
+    "db23": (44, 44),
+    "db24": (46, 46),
+    "db25": (48, 48),
+    "db26": (50, 50),
+    "db27": (52, 52),
+    "db28": (54, 54),
+    "db29": (56, 56),
+    "db30": (58, 58),
+    "db31": (60, 60),
+    "db32": (62, 62),
+    "db33": (64, 64),
+    "db34": (66, 66),
+    "db35": (68, 68),
+    "db36": (70, 70),
+    "db37": (72, 72),
+    "db38": (74, 74),
+    "sym2": (2, 2),
+    "sym3": (4, 4),
+    "sym4": (6, 6),
+    "sym5": (8, 8),
+    "sym6": (10, 10),
+    "sym7": (12, 12),
+    "sym8": (14, 14),
+    "sym9": (16, 16),
+    "sym10": (18, 18),
+    "sym11": (20, 20),
+    "sym12": (22, 22),
+    "sym13": (24, 24),
+    "sym14": (26, 26),
+    "sym15": (28, 28),
+    "sym16": (30, 30),
+    "sym17": (32, 32),
+    "sym18": (34, 34),
+    "sym19": (36, 36),
+    "sym20": (38, 38),
+    "coif1": (4, 4),
+    "coif2": (10, 10),
+    "coif3": (16, 16),
+    "coif4": (22, 22),
+    "coif5": (28, 28),
+    "coif6": (34, 34),
+    "coif7": (40, 40),
+    "coif8": (46, 46),
+    "coif9": (52, 52),
+    "coif10": (58, 58),
+    "coif11": (64, 64),
+    "coif12": (70, 70),
+    "coif13": (76, 76),
+    "coif14": (82, 82),
+    "coif15": (88, 88),
+    "coif16": (94, 94),
+    "coif17": (100, 100),
+}
diff --git a/src/peft/tuners/waveft/layer.py b/src/peft/tuners/waveft/layer.py
new file mode 100644
index 0000000..49ac752
--- /dev/null
+++ b/src/peft/tuners/waveft/layer.py
@@ -0,0 +1,298 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+import warnings
+from typing import Any, Optional
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+from transformers.pytorch_utils import Conv1D
+
+from peft.tuners.tuners_utils import BaseTunerLayer, check_adapters_to_merge
+from peft.utils.other import transpose
+
+from .config import WaveFTConfig
+from .constants import WAVELET_REDUCTIONS
+from .waverec2d import waverec2d
+
+
+class WaveFTLayer(BaseTunerLayer):
+    # All names of layers that may contain (trainable) adapter weights
+    adapter_layer_names = ("waveft_spectrum",)
+    # All names of other parameters that may contain adapter-related parameters
+    other_param_names = (
+        "waveft_n_frequency",
+        "waveft_scaling",
+        "waveft_random_loc_seed",
+        "waveft_wavelet_family",
+        "waveft_indices",
+        "waveft_use_idwt",
+    )
+
+    def __init__(self, base_layer: nn.Module, **kwargs) -> None:
+        self.base_layer = base_layer
+        self.waveft_n_frequency = {}
+        self.waveft_scaling = {}
+        self.waveft_spectrum = nn.ParameterDict({})
+        self.waveft_wavelet_family = {}
+        self.waveft_indices = {}
+        self.waveft_random_loc_seed = {}
+        self.waveft_use_idwt = {}
+        # Mark the weight as unmerged
+        self._disable_adapters = False
+        self.merged_adapters = []
+        self.kwargs = kwargs
+
+        base_layer = self.get_base_layer()
+        if isinstance(base_layer, nn.Linear):
+            self.in_features, self.out_features = base_layer.in_features, base_layer.out_features
+        elif isinstance(base_layer, Conv1D):
+            self.in_features, self.out_features = (
+                base_layer.weight.ds_shape if hasattr(base_layer.weight, "ds_shape") else base_layer.weight.shape
+            )
+        else:
+            raise TypeError(f"Unsupported layer type {type(base_layer)}")
+
+    def update_layer(
+        self,
+        adapter_name: str,
+        n_frequency: int,
+        config: WaveFTConfig,
+    ):
+        wavelet_family = config.wavelet_family
+        scaling = config.scaling
+        init_weights = config.init_weights
+        random_loc_seed = config.random_loc_seed
+        use_idwt = config.use_idwt
+
+        if n_frequency <= 0:
+            raise ValueError(f"`n_frequency` should be a positive integer value but the value passed is {n_frequency}")
+        if n_frequency > self.in_features * self.out_features:
+            raise ValueError(
+                f"`n_frequency` should be less than or equal to the product of the input and output dimensions "
+                f"but the value passed is {n_frequency} and the product is {self.in_features * self.out_features}"
+            )
+
+        self.waveft_n_frequency[adapter_name] = n_frequency
+        self.waveft_random_loc_seed[adapter_name] = random_loc_seed
+        self.waveft_wavelet_family[adapter_name] = wavelet_family
+        self.waveft_use_idwt[adapter_name] = use_idwt
+
+        # Generate random indices within the original dimensions
+        # We handle padding separately in get_delta_weight
+        generator = torch.Generator().manual_seed(self.waveft_random_loc_seed[adapter_name])
+        indices = torch.randperm(self.out_features * self.in_features, generator=generator)[:n_frequency]
+
+        # Convert to row, col format for the original dimensions
+        self.waveft_indices[adapter_name] = torch.stack(
+            [indices // self.in_features, indices % self.in_features], dim=0
+        )
+
+        self.waveft_scaling[adapter_name] = scaling
+
+        # Actual trainable parameters
+        # Initialize based on init_weights
+        if init_weights:
+            # Initialize with zeros later using reset_wave_parameters
+            self.waveft_spectrum[adapter_name] = nn.Parameter(torch.empty(n_frequency), requires_grad=True)
+            self.reset_wave_parameters(adapter_name)  # Initialize to zeros now
+        else:
+            # Initialize with randn scaled by a small std dev to prevent explosion
+            std_dev = 0.01  # Using a small std dev for initial random weights
+            self.waveft_spectrum[adapter_name] = nn.Parameter(torch.randn(n_frequency) * std_dev, requires_grad=True)
+
+        self._move_adapter_to_device_of_base_layer(adapter_name)
+        self.set_adapter(self.active_adapters, inference_mode=config.inference_mode)
+
+    @torch.no_grad()
+    def reset_wave_parameters(self, adapter_name):
+        if adapter_name in self.waveft_spectrum.keys():
+            nn.init.zeros_(self.waveft_spectrum[adapter_name])
+
+    def get_delta_weight(self, adapter) -> torch.Tensor:
+        spectrum = self.waveft_spectrum[adapter]
+        indices = self.waveft_indices[adapter].to(spectrum.device)
+        wavelet_family = self.waveft_wavelet_family[adapter]
+
+        # Choose whether to use IDWT or direct spectrum based on adapter setting
+        if self.waveft_use_idwt[adapter]:
+            reduction_rows, reduction_cols = WAVELET_REDUCTIONS[wavelet_family]
+
+            # Create a padded spectrum matrix with additional rows and columns
+            # to account for the reduction during wavelet reconstruction
+            padded_out_features = self.out_features + reduction_rows
+            padded_in_features = self.in_features + reduction_cols
+
+            # Make dimensions even if needed for wavelet processing
+            if padded_out_features % 2 != 0:
+                padded_out_features += 1
+            if padded_in_features % 2 != 0:
+                padded_in_features += 1
+
+            # Create the padded dense spectrum matrix
+            dense_spectrum = torch.zeros(
+                padded_out_features, padded_in_features, device=spectrum.device, dtype=spectrum.dtype
+            )
+
+            # Calculate padding offsets to center the original data in the padded matrix
+            row_offset = (padded_out_features - self.out_features) // 2
+            col_offset = (padded_in_features - self.in_features) // 2
+
+            # Adjust indices to account for padding offsets
+            padded_indices = indices.clone()
+            padded_indices[0, :] += row_offset
+            padded_indices[1, :] += col_offset
+
+            # Place spectrum values in the padded matrix
+            # Filter out any indices that would be out of bounds
+            valid_mask = (padded_indices[0, :] < padded_out_features) & (padded_indices[1, :] < padded_in_features)
+            valid_indices = padded_indices[:, valid_mask]
+            valid_spectrum = spectrum[valid_mask]
+
+            # Set the spectrum values in the padded matrix
+            dense_spectrum[valid_indices[0, :], valid_indices[1, :]] = valid_spectrum
+
+            # Split into four sub-bands
+            H, W = dense_spectrum.shape
+            H2, W2 = H // 2, W // 2
+            cA = dense_spectrum[:H2, :W2]  # top-left
+            cH = dense_spectrum[:H2, W2:]  # top-right
+            cV = dense_spectrum[H2:, :W2]  # bottom-left
+            cD = dense_spectrum[H2:, W2:]  # bottom-right
+
+            # Construct wavelet-coefficient tuple
+            coeffs = (cA, (cH, cV, cD))
+
+            # Reconstruct with the specified wavelet family
+            delta_weight = waverec2d(coeffs, wavelet_family) * self.waveft_scaling[adapter]
+
+            # Ensure the delta weight has exactly the correct dimensions
+            if delta_weight.shape[0] != self.out_features or delta_weight.shape[1] != self.in_features:
+                # Calculate where to start slicing to get a centered crop
+                start_row = (delta_weight.shape[0] - self.out_features) // 2
+                start_col = (delta_weight.shape[1] - self.in_features) // 2
+
+                # Slice to the exact output size needed
+                delta_weight = delta_weight[
+                    start_row : start_row + self.out_features, start_col : start_col + self.in_features
+                ]
+        else:
+            # Simple direct use of spectrum without IDWT
+            dense_spectrum = torch.zeros(
+                self.out_features, self.in_features, device=spectrum.device, dtype=spectrum.dtype
+            )
+            dense_spectrum[indices[0, :], indices[1, :]] = spectrum
+            delta_weight = dense_spectrum * self.waveft_scaling[adapter]
+
+        return delta_weight
+
+
+class WaveFTLinear(nn.Module, WaveFTLayer):
+    # WaveFT implemented in a dense layer
+    def __init__(
+        self,
+        base_layer,
+        adapter_name: str,
+        config: WaveFTConfig,
+        n_frequency: int = 1000,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        WaveFTLayer.__init__(self, base_layer, **kwargs)
+        self.fan_in_fan_out = config.fan_in_fan_out
+        self._active_adapter = adapter_name
+        self.update_layer(adapter_name, n_frequency, config=config)
+
+    def merge(self, safe_merge: bool = False, adapter_names: Optional[list[str]] = None) -> None:
+        """
+        Merge the active adapter weights into the base weights
+
+        Args:
+            safe_merge (`bool`, *optional*):
+                If True, the merge operation will be performed in a copy of the original weights and check for NaNs
+                before merging the weights. This is useful if you want to check if the merge operation will produce
+                NaNs. Defaults to `False`.
+            adapter_names (`List[str]`, *optional*):
+                The list of adapter names that should be merged. If None, all active adapters will be merged. Defaults
+                to `None`.
+        """
+        adapter_names = check_adapters_to_merge(self, adapter_names)
+        if not adapter_names:
+            # no adapter to merge
+            return
+
+        for active_adapter in adapter_names:
+            if active_adapter in self.waveft_spectrum.keys():
+                base_layer = self.get_base_layer()
+                if safe_merge:
+                    # Note that safe_merge will be slower than the normal merge
+                    # because of the copy operation.
+                    orig_weights = base_layer.weight.data.clone()
+                    orig_weights += transpose(self.get_delta_weight(active_adapter), self.fan_in_fan_out)
+
+                    if not torch.isfinite(orig_weights).all():
+                        raise ValueError(
+                            f"NaNs detected in the merged weights. The adapter {active_adapter} seems to be broken"
+                        )
+
+                    base_layer.weight.data = orig_weights
+                else:
+                    base_layer.weight.data += transpose(self.get_delta_weight(active_adapter), self.fan_in_fan_out)
+                self.merged_adapters.append(active_adapter)
+
+    def unmerge(self) -> None:
+        """
+        This method unmerges all merged adapter layers from the base weights.
+        """
+        if not self.merged:
+            warnings.warn("Already unmerged. Nothing to do.")
+            return
+        while len(self.merged_adapters) > 0:
+            active_adapter = self.merged_adapters.pop()
+            if active_adapter in self.waveft_spectrum.keys():
+                self.get_base_layer().weight.data -= transpose(
+                    self.get_delta_weight(active_adapter), self.fan_in_fan_out
+                )
+
+    def forward(self, x: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        previous_dtype = x.dtype
+
+        if self.disable_adapters:
+            if self.merged:
+                self.unmerge()
+            result = self.base_layer(x, *args, **kwargs)
+        elif self.merged:
+            result = self.base_layer(x, *args, **kwargs)
+        else:
+            result = self.base_layer(x, *args, **kwargs)
+            for active_adapter in self.active_adapters:
+                if active_adapter not in self.waveft_spectrum.keys():
+                    continue
+
+                delta_w = self.get_delta_weight(active_adapter)
+                x = self._cast_input_dtype(x, delta_w.dtype)
+                result = result + F.linear(x, delta_w)
+
+        result = result.to(previous_dtype)
+        return result
+
+    def supports_lora_conversion(self, adapter_name: str = "default") -> bool:
+        # get_delta_weight does not transpose Conv1D because it is used in forward, therefore, it has the wrong
+        # shape for conversion
+        return not isinstance(self.get_base_layer(), Conv1D)
+
+    def __repr__(self) -> str:
+        rep = super().__repr__()
+        return "waveft." + rep
diff --git a/src/peft/tuners/waveft/model.py b/src/peft/tuners/waveft/model.py
new file mode 100644
index 0000000..f1d325c
--- /dev/null
+++ b/src/peft/tuners/waveft/model.py
@@ -0,0 +1,175 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import warnings
+
+import torch
+from transformers.pytorch_utils import Conv1D
+
+from peft.tuners.tuners_utils import BaseTuner, BaseTunerLayer, check_target_module_exists
+from peft.utils import (
+    TRANSFORMERS_MODELS_TO_WAVEFT_TARGET_MODULES_MAPPING,
+)
+from peft.utils.other import get_pattern_key
+
+from .layer import WaveFTLayer, WaveFTLinear
+
+
+class WaveFTModel(BaseTuner):
+    prefix: str = "waveft_"
+    tuner_layer_cls: type[BaseTunerLayer] = WaveFTLayer
+    target_module_mapping = TRANSFORMERS_MODELS_TO_WAVEFT_TARGET_MODULES_MAPPING
+
+    def _calculate_proportional_parameters(self, model: torch.nn.Module, waveft_config):
+        """Calculate proportional parameter allocation for all target modules."""
+        target_modules_info = []
+        for name, module in model.named_modules():
+            if check_target_module_exists(waveft_config, name):
+                # Handle case where module is already wrapped with WaveFT
+                if isinstance(module, WaveFTLayer):
+                    # Use the base layer for dimension calculations
+                    base_module = module.base_layer
+                    if isinstance(base_module, torch.nn.Linear):
+                        input_dim, output_dim = base_module.in_features, base_module.out_features
+                    elif isinstance(base_module, Conv1D):
+                        input_dim, output_dim = base_module.weight.shape[1], base_module.weight.shape[0]
+                    else:
+                        continue
+                elif isinstance(module, torch.nn.Linear):
+                    input_dim, output_dim = module.in_features, module.out_features
+                elif isinstance(module, Conv1D):
+                    input_dim, output_dim = module.weight.shape[1], module.weight.shape[0]
+                else:
+                    continue
+                target_modules_info.append((name, input_dim, output_dim))
+
+        if not target_modules_info:
+            raise ValueError("No target modules found for proportional parameter allocation.")
+
+        total_sum = sum(input_dim * output_dim for (_, input_dim, output_dim) in target_modules_info)
+        num_layers = len(target_modules_info)
+        total_budget = waveft_config.n_frequency * num_layers
+
+        n_frequency_dict = {}
+        for name, input_dim, output_dim in target_modules_info:
+            layer_ratio = (input_dim * output_dim) / total_sum
+            n_freq = round(layer_ratio * total_budget)
+            n_frequency_dict[name] = n_freq
+
+        return n_frequency_dict
+
+    def _create_and_replace(
+        self,
+        waveft_config,
+        adapter_name,
+        target,
+        target_name,
+        parent,
+        current_key,
+        **optional_kwargs,
+    ):
+        if current_key is None:
+            raise ValueError("Current Key shouldn't be `None`")
+
+        # Calculate proportional parameters if needed (only once per adapter)
+        if waveft_config.proportional_parameters:
+            if not hasattr(self, "_proportional_params_cache"):
+                self._proportional_params_cache = {}
+            if adapter_name not in self._proportional_params_cache:
+                n_frequency_dict = self._calculate_proportional_parameters(self.model, waveft_config)
+                self._proportional_params_cache[adapter_name] = n_frequency_dict
+
+        # Determine n_frequency: Priority order:
+        # 1. From proportional parameter cache (if proportional_parameters=True)
+        # 2. From optional_kwargs (if passed directly)
+        # 3. From n_frequency_pattern in config
+        # 4. From default n_frequency in config
+        n_frequency = None
+        if (
+            waveft_config.proportional_parameters
+            and hasattr(self, "_proportional_params_cache")
+            and adapter_name in self._proportional_params_cache
+        ):
+            n_frequency = self._proportional_params_cache[adapter_name].get(current_key)
+
+        if n_frequency is None and "n_frequency" in optional_kwargs:
+            n_frequency = optional_kwargs["n_frequency"]
+
+        if n_frequency is None:
+            pattern_keys = list(waveft_config.n_frequency_pattern.keys())
+            target_name_key = get_pattern_key(pattern_keys, current_key)
+            n_frequency = waveft_config.n_frequency_pattern.get(target_name_key, waveft_config.n_frequency)
+
+        bias = hasattr(target, "bias") and target.bias is not None
+        # Prepare kwargs for module creation/update
+        kwargs = {
+            "n_frequency": n_frequency,
+            "bias": bias,
+        }
+
+        if isinstance(target, WaveFTLayer):
+            target.update_layer(
+                adapter_name,
+                n_frequency,
+                config=waveft_config,
+            )
+        else:
+            new_module = self._create_new_module(waveft_config, adapter_name, target, **kwargs)
+            if adapter_name != self.active_adapter:
+                new_module.requires_grad_(False)
+            self._replace_module(parent, target_name, new_module, target)
+
+    @staticmethod
+    def _create_new_module(waveft_config, adapter_name, target, **kwargs):
+        if isinstance(target, BaseTunerLayer):
+            target_base_layer = target.get_base_layer()
+        else:
+            target_base_layer = target
+
+        if isinstance(target_base_layer, torch.nn.Linear):
+            if waveft_config.fan_in_fan_out:
+                warnings.warn(
+                    "fan_in_fan_out is set to True but the target module is `torch.nn.Linear`. "
+                    "Setting fan_in_fan_out to False."
+                )
+                waveft_config.fan_in_fan_out = False
+        elif isinstance(target_base_layer, Conv1D):
+            kwargs["is_target_conv_1d_layer"] = True
+            if not waveft_config.fan_in_fan_out:
+                warnings.warn(
+                    "fan_in_fan_out is set to False but the target module is `Conv1D`. Setting fan_in_fan_out to True."
+                )
+                waveft_config.fan_in_fan_out = True
+        else:
+            raise TypeError(
+                f"Target module {target} is not supported. Currently, only the following modules are supported: "
+                "`torch.nn.Linear`."
+            )
+
+        new_module = WaveFTLinear(target, adapter_name, config=waveft_config, **kwargs)
+
+        return new_module
+
+    def delete_adapter(self, adapter_name: str) -> None:
+        """
+        Deletes an existing adapter.
+
+        Args:
+            adapter_name (str): Name of the adapter to be deleted.
+        """
+        super().delete_adapter(adapter_name)
+        # Clean up proportional parameters cache
+        if hasattr(self, "_proportional_params_cache") and adapter_name in self._proportional_params_cache:
+            del self._proportional_params_cache[adapter_name]
diff --git a/src/peft/tuners/waveft/wavelet.py b/src/peft/tuners/waveft/wavelet.py
new file mode 100644
index 0000000..c66acd8
--- /dev/null
+++ b/src/peft/tuners/waveft/wavelet.py
@@ -0,0 +1,513 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+"""
+Minimal wavelet implementation extracted from PyWavelets
+
+This code contains portions derived from PyWavelets: Copyright (c) 2006-2012 Filip Wasilewski <http://en.ig.ma/>
+Copyright (c) 2012- The PyWavelets Developers <https://github.com/PyWavelets/pywt>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Original source: https://github.com/PyWavelets/pywt
+"""
+
+import math
+from collections.abc import Sequence
+
+
+class Wavelet:
+    """
+    Minimal wavelet class that implements the most commonly used wavelets.
+
+    Supports:
+    - Daubechies wavelets: db1-db10, haar
+    - Symlets: sym2-sym10
+    - Coiflets: coif1-coif5
+    """
+
+    def __init__(self, name: str):
+        """
+        Initialize a wavelet by name.
+
+        Args:
+            name: Wavelet name (e.g., 'db4', 'haar', 'sym5', 'coif2')
+        """
+        self.name = name.lower()
+        self._compute_filters()
+
+    def _compute_filters(self):
+        """Compute the four filter banks from the base coefficients."""
+        if self.name == "haar":
+            # Haar is the same as db1
+            base_coeffs = _WAVELET_COEFFS["db1"]
+        elif self.name in _WAVELET_COEFFS:
+            base_coeffs = _WAVELET_COEFFS[self.name]
+        else:
+            raise ValueError(f"Unknown wavelet name '{self.name}'. Available wavelets: {list(_WAVELET_COEFFS.keys())}")
+
+        # Determine if this is a coiflet (needs sqrt(2) scaling)
+        scale_factor = math.sqrt(2) if self.name.startswith("coif") else 1.0
+
+        # Apply scaling to base coefficients
+        scaled_coeffs = [c * scale_factor for c in base_coeffs]
+
+        # Compute the four filter banks following PyWavelets convention
+        # rec_lo = scaled base coefficients
+        self._rec_lo = scaled_coeffs[:]
+
+        # dec_lo = rec_lo reversed
+        self._dec_lo = scaled_coeffs[::-1]
+
+        # rec_hi = alternating signs of dec_lo
+        self._rec_hi = [(-1) ** i * scaled_coeffs[len(scaled_coeffs) - 1 - i] for i in range(len(scaled_coeffs))]
+
+        # dec_hi = alternating signs of rec_lo
+        self._dec_hi = [(-1) ** (len(scaled_coeffs) - 1 - i) * scaled_coeffs[i] for i in range(len(scaled_coeffs))]
+
+    @property
+    def dec_lo(self) -> Sequence[float]:
+        """Lowpass decomposition filter."""
+        return self._dec_lo
+
+    @property
+    def dec_hi(self) -> Sequence[float]:
+        """Highpass decomposition filter."""
+        return self._dec_hi
+
+    @property
+    def rec_lo(self) -> Sequence[float]:
+        """Lowpass reconstruction filter."""
+        return self._rec_lo
+
+    @property
+    def rec_hi(self) -> Sequence[float]:
+        """Highpass reconstruction filter."""
+        return self._rec_hi
+
+    @property
+    def dec_len(self) -> int:
+        """Decomposition filters length."""
+        return len(self._dec_lo)
+
+    @property
+    def rec_len(self) -> int:
+        """Reconstruction filters length."""
+        return len(self._rec_lo)
+
+    @property
+    def filter_bank(self) -> tuple[Sequence[float], Sequence[float], Sequence[float], Sequence[float]]:
+        """Tuple of all four filter banks (dec_lo, dec_hi, rec_lo, rec_hi)."""
+        return (self.dec_lo, self.dec_hi, self.rec_lo, self.rec_hi)
+
+    def __len__(self) -> int:
+        """Return the length of the decomposition filters."""
+        return self.dec_len
+
+    def __repr__(self) -> str:
+        return f"Wavelet(name='{self.name}')"
+
+
+# Wavelet coefficients extracted from PyWavelets
+# These are the reconstruction lowpass filter coefficients
+_WAVELET_COEFFS = {
+    # Daubechies wavelets
+    "db1": [
+        0.7071067811865475244008443621048490392848359376884740365883398,
+        0.7071067811865475244008443621048490392848359376884740365883398,
+    ],
+    "db2": [
+        0.4829629131445341433748715998644486838169524195042022752011715,
+        0.8365163037378079055752937809168732034593703883484392934953414,
+        0.2241438680420133810259727622404003554678835181842717613871683,
+        -0.1294095225512603811744494188120241641745344506599652569070016,
+    ],
+    "db3": [
+        0.3326705529500826159985115891390056300129233992450683597084705,
+        0.80689150931333875,
+        0.45987750211933132,
+        -0.13501102001039084,
+        -0.085441273882241486,
+        0.035226291882100656,
+    ],
+    "db4": [
+        0.2303778133088965008632911830440708500016152482483092977910968,
+        0.7148465705529156470899219552739926037076084010993081758450110,
+        0.6308807679298589078817163383006152202032229226771951174057473,
+        -0.02798376941685985421141374718007538541198732022449175284003358,
+        -0.1870348117190930840795706727890814195845441743745800912057770,
+        0.03084138183556076362721936253495905017031482172003403341821219,
+        0.03288301166688519973540751354924438866454194113754971259727278,
+        -0.01059740178506903210488320852402722918109996490637641983484974,
+    ],
+    "db5": [
+        0.1601023979741929144807237480204207336505441246250578327725699,
+        0.6038292697971896705401193065250621075074221631016986987969283,
+        0.7243085284377729277280712441022186407687562182320073725767335,
+        0.1384281459013207315053971463390246973141057911739561022694652,
+        -0.2422948870663820318625713794746163619914908080626185983913726,
+        -0.03224486958463837464847975506213492831356498416379847225434268,
+        0.07757149384004571352313048938860181980623099452012527983210146,
+        -0.006241490212798274274190519112920192970763557165687607323417435,
+        -0.01258075199908199946850973993177579294920459162609785020169232,
+        0.003335725285473771277998183415817355747636524742305315099706428,
+    ],
+    "db6": [
+        0.1115407433501094636213239172409234390425395919844216759082360,
+        0.4946238903984530856772041768778555886377863828962743623531834,
+        0.7511339080210953506789344984397316855802547833382612009730420,
+        0.3152503517091976290859896548109263966495199235172945244404163,
+        -0.2262646939654398200763145006609034656705401539728969940143487,
+        -0.1297668675672619355622896058765854608452337492235814701599310,
+        0.09750160558732304910234355253812534233983074749525514279893193,
+        0.02752286553030572862554083950419321365738758783043454321494202,
+        -0.03158203931748602956507908069984866905747953237314842337511464,
+        0.0005538422011614961392519183980465012206110262773864964295476524,
+        0.004777257510945510639635975246820707050230501216581434297593254,
+        -0.001077301085308479564852621609587200035235233609334419689818580,
+    ],
+    "db7": [
+        0.07785205408500917901996352195789374837918305292795568438702937,
+        0.3965393194819173065390003909368428563587151149333287401110499,
+        0.7291320908462351199169430703392820517179660611901363782697715,
+        0.4697822874051931224715911609744517386817913056787359532392529,
+        -0.1439060039285649754050683622130460017952735705499084834401753,
+        -0.2240361849938749826381404202332509644757830896773246552665095,
+        0.07130921926683026475087657050112904822711327451412314659575113,
+        0.08061260915108307191292248035938190585823820965629489058139218,
+        -0.03802993693501441357959206160185803585446196938467869898283122,
+        -0.01657454163066688065410767489170265479204504394820713705239272,
+        0.01255099855609984061298988603418777957289474046048710038411818,
+        0.0004295779729213665211321291228197322228235350396942409742946366,
+        -0.001801640704047490915268262912739550962585651469641090625323864,
+        0.0003537137999745202484462958363064254310959060059520040012524275,
+    ],
+    "db8": [
+        0.05441584224310400995500940520299935503599554294733050397729280,
+        0.3128715909142999706591623755057177219497319740370229185698712,
+        0.6756307362972898068078007670471831499869115906336364227766759,
+        0.5853546836542067127712655200450981944303266678053369055707175,
+        -0.01582910525634930566738054787646630415774471154502826559735335,
+        -0.2840155429615469265162031323741647324684350124871451793599204,
+        0.0004724845739132827703605900098258949861948011288770074644084096,
+        0.1287474266204784588570292875097083843022601575556488795577000,
+        -0.01736930100180754616961614886809598311413086529488394316977315,
+        -0.04408825393079475150676372323896350189751839190110996472750391,
+        0.01398102791739828164872293057263345144239559532934347169146368,
+        0.008746094047405776716382743246475640180402147081140676742686747,
+        -0.004870352993451574310422181557109824016634978512157003764736208,
+        -0.0003917403733769470462980803573237762675229350073890493724492694,
+        0.0006754494064505693663695475738792991218489630013558432103617077,
+        -0.0001174767841247695337306282316988909444086693950311503927620013,
+    ],
+    "db9": [
+        0.03807794736387834658869765887955118448771714496278417476647192,
+        0.2438346746125903537320415816492844155263611085609231361429088,
+        0.6048231236901111119030768674342361708959562711896117565333713,
+        0.6572880780513005380782126390451732140305858669245918854436034,
+        0.1331973858250075761909549458997955536921780768433661136154346,
+        -0.2932737832791749088064031952421987310438961628589906825725112,
+        -0.09684078322297646051350813353769660224825458104599099679471267,
+        0.1485407493381063801350727175060423024791258577280603060771649,
+        0.03072568147933337921231740072037882714105805024670744781503060,
+        -0.06763282906132997367564227482971901592578790871353739900748331,
+        0.0002509471148314519575871897499885543315176271993709633321834164,
+        0.02236166212367909720537378270269095241855646688308853754721816,
+        -0.004723204757751397277925707848242465405729514912627938018758526,
+        -0.004281503682463429834496795002314531876481181811463288374860455,
+        0.001847646883056226476619129491125677051121081359600318160732515,
+        0.0002303857635231959672052163928245421692940662052463711972260006,
+        -0.0002519631889427101369749886842878606607282181543478028214134265,
+        0.00003934732031627159948068988306589150707782477055517013507359938,
+    ],
+    "db10": [
+        0.02667005790055555358661744877130858277192498290851289932779975,
+        0.1881768000776914890208929736790939942702546758640393484348595,
+        0.5272011889317255864817448279595081924981402680840223445318549,
+        0.6884590394536035657418717825492358539771364042407339537279681,
+        0.2811723436605774607487269984455892876243888859026150413831543,
+        -0.2498464243273153794161018979207791000564669737132073715013121,
+        -0.1959462743773770435042992543190981318766776476382778474396781,
+        0.1273693403357932600826772332014009770786177480422245995563097,
+        0.09305736460357235116035228983545273226942917998946925868063974,
+        -0.07139414716639708714533609307605064767292611983702150917523756,
+        -0.02945753682187581285828323760141839199388200516064948779769654,
+        0.03321267405934100173976365318215912897978337413267096043323351,
+        0.003606553566956169655423291417133403299517350518618994762730612,
+        -0.01073317548333057504431811410651364448111548781143923213370333,
+        0.001395351747052901165789318447957707567660542855688552426721117,
+        0.001992405295185056117158742242640643211762555365514105280067936,
+        -0.0006858566949597116265613709819265714196625043336786920516211903,
+        -0.0001164668551292854509514809710258991891527461854347597362819235,
+        0.00009358867032006959133405013034222854399688456215297276443521873,
+        -0.00001326420289452124481243667531226683305749240960605829756400674,
+    ],
+    # Symlets
+    "sym2": [0.48296291314469025, 0.83651630373746899, 0.22414386804185735, -0.12940952255092145],
+    "sym3": [
+        0.33267055295095688,
+        0.80689150931333875,
+        0.45987750211933132,
+        -0.13501102001039084,
+        -0.085441273882241486,
+        0.035226291882100656,
+    ],
+    "sym4": [
+        0.032223100604042702,
+        -0.012603967262037833,
+        -0.099219543576847216,
+        0.29785779560527736,
+        0.80373875180591614,
+        0.49761866763201545,
+        -0.02963552764599851,
+        -0.075765714789273325,
+    ],
+    "sym5": [
+        0.019538882735286728,
+        -0.021101834024758855,
+        -0.17532808990845047,
+        0.016602105764522319,
+        0.63397896345821192,
+        0.72340769040242059,
+        0.1993975339773936,
+        -0.039134249302383094,
+        0.029519490925774643,
+        0.027333068345077982,
+    ],
+    "sym6": [
+        -0.007800708325034148,
+        0.0017677118642428036,
+        0.044724901770665779,
+        -0.021060292512300564,
+        -0.072637522786462516,
+        0.3379294217276218,
+        0.787641141030194,
+        0.49105594192674662,
+        -0.048311742585632998,
+        -0.11799011114819057,
+        0.0034907120842174702,
+        0.015404109327027373,
+    ],
+    "sym7": [
+        0.010268176708511255,
+        0.0040102448715336634,
+        -0.10780823770381774,
+        -0.14004724044296152,
+        0.28862963175151463,
+        0.76776431700316405,
+        0.5361019170917628,
+        0.017441255086855827,
+        -0.049552834937127255,
+        0.067892693501372697,
+        0.03051551316596357,
+        -0.01263630340325193,
+        -0.0010473848886829163,
+        0.0026818145682578781,
+    ],
+    "sym8": [
+        0.0018899503327594609,
+        -0.0003029205147213668,
+        -0.014952258337048231,
+        0.0038087520138906151,
+        0.049137179673607506,
+        -0.027219029917056003,
+        -0.051945838107709037,
+        0.3644418948353314,
+        0.77718575170052351,
+        0.48135965125837221,
+        -0.061273359067658524,
+        -0.14329423835080971,
+        0.0076074873249176054,
+        0.031695087811492981,
+        -0.00054213233179114812,
+        -0.0033824159510061256,
+    ],
+    "sym9": [
+        0.0010694900329086053,
+        -0.00047315449868008311,
+        -0.010264064027633142,
+        0.0088592674934004842,
+        0.06207778930288603,
+        -0.018233770779395985,
+        -0.19155083129728512,
+        0.035272488035271894,
+        0.61733844914093583,
+        0.717897082764412,
+        0.238760914607303,
+        -0.054568958430834071,
+        0.00058346274612580684,
+        0.03022487885827568,
+        -0.01152821020767923,
+        -0.013271967781817119,
+        0.00061978088898558676,
+        0.0014009155259146807,
+    ],
+    "sym10": [
+        -0.00045932942100465878,
+        0.000057036083618494284,
+        0.0045931735853118284,
+        -0.00080435893201654491,
+        -0.02035493981231129,
+        0.0057649120335819086,
+        0.049994972077376687,
+        -0.0319900568824278,
+        -0.035536740473817552,
+        0.38382676106708546,
+        0.7695100370211071,
+        0.47169066693843925,
+        -0.070880535783243853,
+        -0.15949427888491757,
+        0.011609893903711381,
+        0.045927239231092203,
+        -0.0014653825813050513,
+        -0.0086412992770224222,
+        0.000095632670722894754,
+        0.00077015980911449011,
+    ],
+    # Coiflets (note: these will be multiplied by sqrt(2) in the class)
+    "coif1": [
+        -0.05142972847076845595317549230122688830344559947132656813651045,
+        0.2389297284707684559531754923012268883034455994713265681365104,
+        0.6028594569415369119063509846024537766068911989426531362730209,
+        0.2721405430584630880936490153975462233931088010573468637269790,
+        -0.05142972847076845595317549230122688830344559947132656813651045,
+        -0.01107027152923154404682450769877311169655440052867343186348954,
+    ],
+    "coif2": [
+        0.01158759673871686817889714882853120395708315073355502818875931,
+        -0.02932013798346856448679594524397843054053420947418409889774786,
+        -0.04763959031100813225872995081511549408622753909592460525840745,
+        0.2730210465347666137982239328923516270034828327990699588033501,
+        0.5746823938568638472459483149751499367740786490481481391460366,
+        0.2948671936956191896750637208703777973914107635455611537640778,
+        -0.05408560709171142997443672832006888537570221990444706777525838,
+        -0.04202648046077160694657530752545884878978719268926222513485613,
+        0.01674441016327950635146257083249391698866289538037299820224006,
+        0.003967883612962012109043447090269950094081810916481648252817197,
+        -0.001289203356140659543141355500990678257894936161704492503370186,
+        -0.0005095053991076441489598480835620951586540050976664367876412655,
+    ],
+    "coif3": [
+        -0.002682418670922068664584689955153722375535836177157637134187840,
+        0.005503126707831385107969640263617469178794666057252906037981936,
+        0.01658356047917034608134280439996549525220639437145367606178002,
+        -0.04650776447872697640390293095170192691113917841041002855534619,
+        -0.04322076356021191118175840907244577856782537221435748296465882,
+        0.2865033352736474630249006862976158896891076238443844211133873,
+        0.5612852568703300445990941995240077241406247774064453800050914,
+        0.3029835717728241602862575774374668529867757043461413348549577,
+        -0.05077014075488886159516471867138370972545857441670871832472707,
+        -0.05819625076158553022607041679522801089624825903982541419721721,
+        0.02443409432116695639462954438418928805487699080947974989338820,
+        0.01122924096203786563399489540091488781245346096838814728167341,
+        -0.006369601011048822977293753932627342482077585617391852852955559,
+        -0.001820458915566242322836631665832145136570132777862391313328351,
+        0.0007902051009575939937150950543290226440287715441826917281929124,
+        0.0003296651737931830308416338897758022998655744276957481989605186,
+        -0.00005019277455327664998007173088097694083956570594580641192332170,
+        -0.00002446573425530813115445387662881902303945941576472342106918209,
+    ],
+    "coif4": [
+        0.0006309612114309468490753696608619526520153127603444406835368201,
+        -0.001152225143769973488683007937016166047881572156705066038094891,
+        -0.005194525163470323267558201363327294331811309729430512113592118,
+        0.011360930899781950641704454327495718441159520023894304805142070,
+        0.018945061045616642675204041814669158097013442370604397885045773,
+        -0.051719843705815280952009072709014825996085808127950893370164031,
+        -0.034486140470944806827159094088779177962124655341862998060866093,
+        0.30227251053656843537076103037201073987915654650542997843779746,
+        0.55454790624088107896085831311334062609863843227892842936901802,
+        0.30791766802517503548651698686002846493302655084140026096325632,
+        -0.04352500928126570063143077306027663648139777048547894956715080,
+        -0.06488795097143100103160862688937301504802507374726020928892066,
+        0.01988077364815951966984001670075537628468542316950829728327598,
+        0.01763894787126169746077061344050946967036166456074020965866088,
+        -0.007366054847173363935072651649653007115003169492027095040477055,
+        -0.002312432307658842282830374733100847689924654369899030169556169,
+        0.0014260063442333715226509754100697734398974715092509045804651032,
+        0.0004666984635537353670445650012678936080062341977092967649055398,
+        -0.0001270007842387334077388950072420113055088253899932456267893098,
+        -0.0001130536369789104919020013936507623832962772709844179610938550,
+        0.00003048364879677801030096883509693508426509710688913073244616617,
+        0.00001266744808933008194725929652978169473830765616675686100903086,
+        -0.000001584926580756893754069651095690142946796090146306140001598,
+        -0.000001123948088281542889088159169056968300680087779667334879506,
+    ],
+    "coif5": [
+        -0.0001444992186438190986841213894961515720877049723502928655308158,
+        0.0002541649492011946935899015644804259825374993423205648946709984,
+        0.0015016192805175522217354963668928299350735326077949346507003370,
+        -0.0029411108712655515426850089360913424188662278991737055486839309,
+        -0.0071777671514877191801104649507158618871157411936681659380839993,
+        0.016680426640070654149267486742006854522334094142598667043628439,
+        0.019433238433489604119639447772308536988043628308900006988094899,
+        -0.064934946567212502582522008002547701764467194128935170823607736,
+        -0.036249793089132571825087765037251085892962369926089901862924065,
+        0.29804266217809436069693444260411251439893892734398765007426945,
+        0.55749162970920071628061190166750547398568080072951806509736879,
+        0.30731644529206781686031633026138686170779831068030092889493625,
+        -0.047088034719761145117688715152051398948700623993077406913889346,
+        -0.068890522508050074805015336128652797797076949077503388892816063,
+        0.020697343297747766068568936830651656003659188170019885439659031,
+        0.021640668655956855043817421090949779825140639715020046717736369,
+        -0.0081089373078953680936950024508066654697766705721301481097854397,
+        -0.0049881737671041853808073796089816945023009226058734090095808033,
+        0.0024486914321021269742893936892468103370072825113159100554056433,
+        0.0014095103899593442621166984842002926701899968616244946547893994,
+        -0.0005637801876093825733169550088901318936072015721509885859509815,
+        -0.0002859004477225750899655442618734663056802618537327806113618985,
+        0.00012739637513815208006169426577159456832051015616166327985688948,
+        0.00005416263410701044073894700796327336007788688985721449717765655,
+        -0.00001736867944346280636144226913926838103159698473080996002509476,
+        -0.00001392656190060010871169838885327726938969652863554900825705905,
+        0.000003582065515946048838215026334503092089635988710863959063568069,
+        0.000001914022895847318655772885654240700542388103264097264264779554,
+        -0.00000031262488377016899432194683906058825900951892071223097080609,
+        -0.00000034030635502511647536690616071863203084936306302829968850306,
+        0.000000059816065238516936893488966688516710847096926983547983503726,
+        0.000000047001427849456491830476615736016736014244615701046223529866,
+        -0.000000006158615709678364180659098549671046676203853020063205641804,
+        -0.000000009225635096344935080070901936862847863830913641424076095562,
+        0.000000001028486074518821265015830073593127726988903862842106883701,
+        0.000000001168734175186263778695686067593866982925127816327529890618,
+        -0.00000000009468626176069127302554946536142654377756003084491946024,
+        -0.00000000016230233142152041788509334089966065953985768924968863072,
+        0.000000000015076656859346950325398899897135970089618140503825462985,
+        0.000000000015770990416421915106306877550025550097686639869166742016,
+        -0.000000000001084900468648598127623517893686893316653633996513097476,
+        -0.000000000001968659779411804788815966829825641065085077654946686012,
+        0.000000000000098745634639726633264577838416327095717894829823436076,
+        0.000000000000196734781460508097097473336847436635654948853090962606,
+        -0.000000000000008021080145299890797556481653726965016924825037889883,
+        -0.000000000000021030408801651651406095853493993966926736862877194669,
+        0.000000000000000723888697830915633925166893301949334507697669655816,
+        0.000000000000001943208515072761516084547140065815027641765976721267,
+    ],
+}
+
+
+def wavelist() -> list[str]:
+    """Return a list of available wavelet names."""
+    return list(_WAVELET_COEFFS.keys()) + ["haar"]
diff --git a/src/peft/tuners/waveft/waverec2d.py b/src/peft/tuners/waveft/waverec2d.py
new file mode 100644
index 0000000..5827690
--- /dev/null
+++ b/src/peft/tuners/waveft/waverec2d.py
@@ -0,0 +1,316 @@
+# Copyright 2021 Moritz Wolter
+# Copyright 2025-present the HuggingFace Inc. team.
+#
+# Licensed under the EUPL v1.2
+#
+# This file contains code derived from PyTorch-Wavelet-Toolbox:
+# https://github.com/v0lta/PyTorch-Wavelet-Toolbox
+#
+# Original work by Moritz Wolter, licensed under EUPL v1.2
+# Modifications and integration by HuggingFace Inc. team
+
+from collections.abc import Callable, Sequence
+from functools import partial
+from typing import Any, NamedTuple, Protocol, TypeAlias, Union, cast, overload
+
+import numpy as np
+import torch
+from typing_extensions import Unpack
+
+from .wavelet import Wavelet as minimal_wavelet
+
+
+class WaveletDetailTuple2d(NamedTuple):
+    horizontal: torch.Tensor
+    vertical: torch.Tensor
+    diagonal: torch.Tensor
+
+
+WaveletCoeff2d: TypeAlias = tuple[torch.Tensor, Unpack[tuple[WaveletDetailTuple2d, ...]]]
+WaveletDetailDict: TypeAlias = dict[str, torch.Tensor]
+WaveletCoeffNd: TypeAlias = tuple[torch.Tensor, Unpack[tuple[WaveletDetailDict, ...]]]
+
+
+class Wavelet(Protocol):
+    name: str
+    dec_lo: Sequence[float]
+    dec_hi: Sequence[float]
+    rec_lo: Sequence[float]
+    rec_hi: Sequence[float]
+    dec_len: int
+    rec_len: int
+    filter_bank: tuple[Sequence[float], Sequence[float], Sequence[float], Sequence[float]]
+
+    def __len__(self) -> int:
+        return len(self.dec_lo)
+
+
+class WaveletTensorTuple(NamedTuple):
+    dec_lo: torch.Tensor
+    dec_hi: torch.Tensor
+    rec_lo: torch.Tensor
+    rec_hi: torch.Tensor
+
+    @classmethod
+    def from_wavelet(cls, wavelet: Wavelet, dtype: torch.dtype) -> "WaveletTensorTuple":
+        return cls(
+            torch.tensor(wavelet.dec_lo, dtype=dtype),
+            torch.tensor(wavelet.dec_hi, dtype=dtype),
+            torch.tensor(wavelet.rec_lo, dtype=dtype),
+            torch.tensor(wavelet.rec_hi, dtype=dtype),
+        )
+
+
+def _as_wavelet(wavelet: Union[Wavelet, str]) -> Wavelet:
+    if isinstance(wavelet, str):
+        return minimal_wavelet(wavelet)
+    else:
+        return wavelet
+
+
+def _is_dtype_supported(dtype: torch.dtype) -> bool:
+    return dtype in [torch.float16, torch.bfloat16, torch.float32, torch.float64]
+
+
+def _outer(a: torch.Tensor, b: torch.Tensor) -> torch.Tensor:
+    a_flat = torch.reshape(a, [-1])
+    b_flat = torch.reshape(b, [-1])
+    a_mul = torch.unsqueeze(a_flat, dim=-1)
+    b_mul = torch.unsqueeze(b_flat, dim=0)
+    return a_mul * b_mul
+
+
+def _check_if_tensor(array: Any) -> torch.Tensor:
+    if not isinstance(array, torch.Tensor):
+        raise TypeError("First element of coeffs must be the approximation coefficient tensor.")
+    return array
+
+
+def _check_axes_argument(axes: Sequence[int]) -> None:
+    if len(set(axes)) != len(axes):
+        raise ValueError("Can't transform the same axis twice.")
+
+
+def _check_same_device(tensor: torch.Tensor, torch_device: torch.device) -> torch.Tensor:
+    if torch_device != tensor.device:
+        raise ValueError("coefficients must be on the same device")
+    return tensor
+
+
+def _check_same_dtype(tensor: torch.Tensor, torch_dtype: torch.dtype) -> torch.Tensor:
+    if torch_dtype != tensor.dtype:
+        raise ValueError("coefficients must have the same dtype")
+    return tensor
+
+
+@overload
+def _coeff_tree_map(
+    coeffs: list[torch.Tensor], function: Callable[[torch.Tensor], torch.Tensor]
+) -> list[torch.Tensor]: ...
+@overload
+def _coeff_tree_map(coeffs: WaveletCoeff2d, function: Callable[[torch.Tensor], torch.Tensor]) -> WaveletCoeff2d: ...
+@overload
+def _coeff_tree_map(coeffs: WaveletCoeffNd, function: Callable[[torch.Tensor], torch.Tensor]) -> WaveletCoeffNd: ...
+def _coeff_tree_map(coeffs, function):
+    approx = function(coeffs[0])
+    result_lst: list[Any] = []
+    for element in coeffs[1:]:
+        if isinstance(element, tuple):
+            result_lst.append(WaveletDetailTuple2d(function(element[0]), function(element[1]), function(element[2])))
+        elif isinstance(element, dict):
+            new_dict = {key: function(value) for key, value in element.items()}
+            result_lst.append(new_dict)
+        elif isinstance(element, torch.Tensor):
+            result_lst.append(function(element))
+        else:
+            raise TypeError(f"Unexpected input type {type(element)}")
+    if not result_lst:
+        return [approx] if isinstance(coeffs, list) else (approx,)
+    elif isinstance(result_lst[0], torch.Tensor):
+        return [approx] + cast(list[torch.Tensor], result_lst)
+    else:
+        cast_result_lst = cast(Union[list[WaveletDetailDict], list[WaveletDetailTuple2d]], result_lst)
+        return (approx, *cast_result_lst)
+
+
+def _check_same_device_dtype(
+    coeffs: Union[list[torch.Tensor], WaveletCoeff2d, WaveletCoeffNd],
+) -> tuple[torch.device, torch.dtype]:
+    c = _check_if_tensor(coeffs[0])
+    torch_device, torch_dtype = c.device, c.dtype
+    _coeff_tree_map(coeffs, partial(_check_same_device, torch_device=torch_device))
+    _coeff_tree_map(coeffs, partial(_check_same_dtype, torch_dtype=torch_dtype))
+    return torch_device, torch_dtype
+
+
+def _get_transpose_order(axes: Sequence[int], data_shape: Sequence[int]) -> tuple[list[int], list[int]]:
+    axes = [a + len(data_shape) if a < 0 else a for a in axes]
+    all_axes = list(range(len(data_shape)))
+    remove_transformed = list(filter(lambda a: a not in axes, all_axes))
+    return remove_transformed, axes
+
+
+def _swap_axes(data: torch.Tensor, axes: Sequence[int]) -> torch.Tensor:
+    _check_axes_argument(axes)
+    front, back = _get_transpose_order(axes, list(data.shape))
+    return torch.permute(data, front + back)
+
+
+def _undo_swap_axes(data: torch.Tensor, axes: Sequence[int]) -> torch.Tensor:
+    _check_axes_argument(axes)
+    front, back = _get_transpose_order(axes, list(data.shape))
+    restore_sorted = torch.argsort(torch.tensor(front + back)).tolist()
+    return torch.permute(data, restore_sorted)
+
+
+def _fold_axes(data: torch.Tensor, keep_no: int) -> tuple[torch.Tensor, list[int]]:
+    dshape = list(data.shape)
+    return (torch.reshape(data, [int(np.prod(dshape[:-keep_no]))] + dshape[-keep_no:]), dshape)
+
+
+def _unfold_axes(data: torch.Tensor, ds: list[int], keep_no: int) -> torch.Tensor:
+    return torch.reshape(data, ds[:-keep_no] + list(data.shape[-keep_no:]))
+
+
+def _preprocess_coeffs(coeffs, ndim: int, axes, add_channel_dim: bool = False):
+    if isinstance(axes, int):
+        axes = (axes,)
+    torch_dtype = _check_if_tensor(coeffs[0]).dtype
+    if not _is_dtype_supported(torch_dtype):
+        raise ValueError(f"Input dtype {torch_dtype} not supported")
+    if ndim <= 0:
+        raise ValueError("Number of dimensions must be positive")
+    if tuple(axes) != tuple(range(-ndim, 0)):
+        if len(axes) != ndim:
+            raise ValueError(f"{ndim}D transforms work with {ndim} axes.")
+        else:
+            swap_fn = partial(_swap_axes, axes=axes)
+            coeffs = _coeff_tree_map(coeffs, swap_fn)
+    ds = list(coeffs[0].shape)
+    if len(ds) < ndim:
+        raise ValueError(f"At least {ndim} input dimensions required.")
+    elif len(ds) == ndim:
+        coeffs = _coeff_tree_map(coeffs, lambda x: x.unsqueeze(0))
+    elif len(ds) > ndim + 1:
+        coeffs = _coeff_tree_map(coeffs, lambda t: _fold_axes(t, ndim)[0])
+    if add_channel_dim:
+        coeffs = _coeff_tree_map(coeffs, lambda x: x.unsqueeze(1))
+    return coeffs, ds
+
+
+def _postprocess_coeffs(coeffs, ndim: int, ds: list[int], axes):
+    if isinstance(axes, int):
+        axes = (axes,)
+    if ndim <= 0:
+        raise ValueError("Number of dimensions must be positive")
+    if len(ds) < ndim:
+        raise ValueError(f"At least {ndim} input dimensions required.")
+    elif len(ds) == ndim:
+        coeffs = _coeff_tree_map(coeffs, lambda x: x.squeeze(0))
+    elif len(ds) > ndim + 1:
+        unfold_axes_fn = partial(_unfold_axes, ds=ds, keep_no=ndim)
+        coeffs = _coeff_tree_map(coeffs, unfold_axes_fn)
+    if tuple(axes) != tuple(range(-ndim, 0)):
+        if len(axes) != ndim:
+            raise ValueError(f"{ndim}D transforms work with {ndim} axes.")
+        else:
+            undo_swap_fn = partial(_undo_swap_axes, axes=axes)
+            coeffs = _coeff_tree_map(coeffs, undo_swap_fn)
+    return coeffs
+
+
+def _postprocess_tensor(
+    data: torch.Tensor, ndim: int, ds: list[int], axes: Union[tuple[int, ...], int]
+) -> torch.Tensor:
+    return _postprocess_coeffs(coeffs=[data], ndim=ndim, ds=ds, axes=axes)[0]
+
+
+def _get_filter_tensors(
+    wavelet: Union[Wavelet, str], flip: bool, device: torch.device, dtype: torch.dtype
+) -> WaveletTensorTuple:
+    wavelet = _as_wavelet(wavelet)
+    if flip:
+        filters = WaveletTensorTuple(
+            torch.tensor(wavelet.rec_lo, device=device, dtype=dtype),
+            torch.tensor(wavelet.rec_hi, device=device, dtype=dtype),
+            torch.tensor(wavelet.dec_lo, device=device, dtype=dtype),
+            torch.tensor(wavelet.dec_hi, device=device, dtype=dtype),
+        )
+    else:
+        filters = WaveletTensorTuple.from_wavelet(wavelet, dtype=dtype)
+        filters = WaveletTensorTuple(
+            filters.dec_lo.to(device),
+            filters.dec_hi.to(device),
+            filters.rec_lo.to(device),
+            filters.rec_hi.to(device),
+        )
+    return filters
+
+
+def _adjust_padding_at_reconstruction(tensor_len: int, coeff_len: int, padr: int, padl: int) -> tuple[int, int]:
+    if 2 * coeff_len - tensor_len == 1:
+        padr += 1
+    elif 2 * coeff_len - tensor_len != 0:
+        raise ValueError("incorrect padding")
+    return padr, padl
+
+
+def _construct_2d_filt(lo: torch.Tensor, hi: torch.Tensor) -> torch.Tensor:
+    ll = _outer(lo, lo)
+    lh = _outer(hi, lo)
+    hl = _outer(lo, hi)
+    hh = _outer(hi, hi)
+    filt = torch.stack([ll, lh, hl, hh], 0)
+    filt = filt.unsqueeze(1)
+    return filt
+
+
+def waverec2d(
+    coeffs: WaveletCoeff2d,
+    wavelet: Union[Wavelet, str],
+    axes: tuple[int, int] = (-2, -1),
+) -> torch.Tensor:
+    coeffs, ds = _preprocess_coeffs(coeffs, ndim=2, axes=axes)
+    torch_device, torch_dtype = _check_same_device_dtype(coeffs)
+
+    _, _, rec_lo, rec_hi = _get_filter_tensors(wavelet, flip=False, device=torch_device, dtype=torch_dtype)
+    filt_len = rec_lo.shape[-1]
+    rec_filt = _construct_2d_filt(lo=rec_lo, hi=rec_hi)
+
+    res_ll = coeffs[0]
+    for c_pos, coeff_tuple in enumerate(coeffs[1:]):
+        if not isinstance(coeff_tuple, tuple) or len(coeff_tuple) != 3:
+            raise ValueError(f"Unexpected detail coefficient type: {type(coeff_tuple)}. Must be a 3-tuple.")
+
+        curr_shape = res_ll.shape
+        for coeff in coeff_tuple:
+            if coeff.shape != curr_shape:
+                raise ValueError("All coefficients on each level must have the same shape")
+
+        res_lh, res_hl, res_hh = coeff_tuple
+        res_ll = torch.stack([res_ll, res_lh, res_hl, res_hh], 1)
+        res_ll = torch.nn.functional.conv_transpose2d(res_ll, rec_filt, stride=2).squeeze(1)
+
+        padl = (2 * filt_len - 3) // 2
+        padr = (2 * filt_len - 3) // 2
+        padt = (2 * filt_len - 3) // 2
+        padb = (2 * filt_len - 3) // 2
+        if c_pos < len(coeffs) - 2:
+            padr, padl = _adjust_padding_at_reconstruction(
+                res_ll.shape[-1], coeffs[c_pos + 2][0].shape[-1], padr, padl
+            )
+            padb, padt = _adjust_padding_at_reconstruction(
+                res_ll.shape[-2], coeffs[c_pos + 2][0].shape[-2], padb, padt
+            )
+
+        if padt > 0:
+            res_ll = res_ll[..., padt:, :]
+        if padb > 0:
+            res_ll = res_ll[..., :-padb, :]
+        if padl > 0:
+            res_ll = res_ll[..., padl:]
+        if padr > 0:
+            res_ll = res_ll[..., :-padr]
+
+    res_ll = _postprocess_tensor(res_ll, ndim=2, ds=ds, axes=axes)
+    return res_ll
diff --git a/src/peft/tuners/xlora/__init__.py b/src/peft/tuners/xlora/__init__.py
new file mode 100644
index 0000000..6eae1f7
--- /dev/null
+++ b/src/peft/tuners/xlora/__init__.py
@@ -0,0 +1,23 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from peft.utils import register_peft_method
+
+from .config import XLoraConfig
+from .model import XLoraModel
+
+
+__all__ = ["XLoraConfig", "XLoraModel"]
+
+register_peft_method(name="xlora", config_cls=XLoraConfig, model_cls=XLoraModel)
diff --git a/src/peft/tuners/xlora/classifier.py b/src/peft/tuners/xlora/classifier.py
new file mode 100644
index 0000000..cdfca77
--- /dev/null
+++ b/src/peft/tuners/xlora/classifier.py
@@ -0,0 +1,195 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import builtins
+from typing import Optional, Union
+
+import torch
+from torch import nn
+
+from .config import XLoraConfig
+
+
+Number = Union[builtins.int, builtins.float, builtins.bool]
+
+
+class TemperatureScaledSoftmax(nn.Module):
+    def __init__(self, temperature=1.0):
+        super().__init__()
+        self.temperature = temperature
+        self.softmax = nn.Softmax(dim=-1)
+
+    def forward(self, logits):
+        # Scale logits by the temperature
+        scaled_logits = logits / self.temperature
+        # Apply softmax to the scaled logits
+        return self.softmax(scaled_logits)
+
+
+class XLoraClassifier(nn.Module):
+    """
+    A classifier to select LoRA layers for XLora.
+    """
+
+    def __init__(
+        self,
+        model: nn.Module,  # PeftModel
+        config: XLoraConfig,
+        n_classes: int,
+        n_layers: int,
+        device: torch.device,
+    ):
+        """
+        Construct an X-LoRA classifier from a model, config and some metadata. Note that n_layers is the number of LoRA
+        adapter layers, not the number of model layers.
+        """
+        super().__init__()
+
+        self.n_classes = n_classes
+        self.n_layers = n_layers
+        self.config = config
+        self.log_scalings = []
+        self.softmax = TemperatureScaledSoftmax(temperature=self.config.softmax_temperature)
+        self.override_scaling_pass_value: Number = config.scaling_pass_value
+
+        self.scalings_logging = False
+
+        self.dtype = next(model.parameters()).dtype
+        add_dropout = config.xlora_dropout_p > 0.0
+
+        layers = []
+        if self.config.xlora_depth == 1:
+            if config.layerwise_scalings:  # bias=False if we have just one layer
+                last = nn.Linear(config.hidden_size, n_classes * n_layers, bias=True).to(device).to(self.dtype)
+            else:
+                last = nn.Linear(config.hidden_size, n_classes, bias=True).to(device).to(self.dtype)
+        else:
+            if self.config.xlora_depth <= 0:
+                raise ValueError("X-LoRA depth must be strictly positive.")
+
+            layers.append(nn.Linear(config.hidden_size, config.xlora_size, bias=True).to(device).to(self.dtype))
+
+            layers.append(nn.ReLU())
+            if add_dropout:
+                layers.append(nn.Dropout(p=config.xlora_dropout_p))
+
+            for _ in range(config.xlora_depth - 2):
+                layers.append(nn.Linear(config.xlora_size, config.xlora_size, bias=True).to(device).to(self.dtype))
+
+                layers.append(nn.ReLU())
+                if add_dropout:
+                    layers.append(nn.Dropout(p=config.xlora_dropout_p))
+
+            if config.layerwise_scalings:
+                last = nn.Linear(config.xlora_size, n_classes * n_layers, bias=True).to(device).to(self.dtype)
+            else:
+                last = nn.Linear(config.xlora_size, n_classes, bias=True).to(device).to(self.dtype)
+        self.layers = nn.Sequential(*layers, last)
+
+    def make_dummy_scalings(
+        self,
+        input_ids: Optional[torch.LongTensor] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        *args,
+        **kwargs,
+    ) -> torch.Tensor:
+        """
+        Make some dummy scalings for the scalings pass (the one to get the logits for the X-LoRA classifier). These are
+        of shape (batch_size, seq_len, n_layers, n_classes) and filled with the override scalings pass value. Note that
+        n_layers is the number of LoRA adapter layers, not the number of model layers.
+        """
+        if input_ids is not None:
+            batch_size = input_ids.shape[0]
+            device = input_ids.device
+            seq_len = input_ids.shape[1]
+        else:
+            batch_size = inputs_embeds.shape[0]
+            device = inputs_embeds.device
+            seq_len = inputs_embeds.shape[1]
+
+        return torch.full(  # type: ignore
+            (batch_size, seq_len, self.n_layers, self.n_classes),
+            self.override_scaling_pass_value,
+        ).to(device=device, dtype=self.dtype)
+
+    def forward(
+        self,
+        result,
+        input_ids: Optional[torch.LongTensor] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        *args,
+        **kwargs,
+    ) -> torch.Tensor:
+        """
+        Using the hidden states of the model, predict `n_classes` LoRA alpha values. Returns the scalings.
+        """
+        if input_ids is not None:
+            batch_size = input_ids.shape[0]
+            seq_len = input_ids.shape[1]
+        else:
+            batch_size = inputs_embeds.shape[0]
+            seq_len = inputs_embeds.shape[1]
+
+        hidden_states = result.hidden_states  # type: ignore
+
+        hidden_state = hidden_states[-1]  # Get the last hidden state
+
+        ### Classifier run
+        # hidden_state=[batch_size, seq_len, hidden_size]
+        logits = self.layers.forward(hidden_state)
+
+        ### Repeat to make layerwise scalings
+        ### If layerwise_scalings=False, then the classifier only outputs logits which are not layer-wise.
+        ### So, we expand them to the correct shape.
+        if not self.config.layerwise_scalings:
+            logits = logits.unsqueeze(2)
+            logits = logits.expand(-1, -1, self.n_layers, -1)
+
+        ### Classifier run
+
+        scalings = logits.reshape(batch_size, seq_len, self.n_layers, self.n_classes)
+        # scalings = [batch_size, seq_len, n_layers, n_classes]
+
+        if self.config.enable_softmax:
+            scalings = self.softmax(scalings)
+
+        if self.scalings_logging:
+            self.log_scalings.append(scalings)
+
+        return scalings
+
+    def _get_bucketed_scalings(self) -> dict[int, tuple[list[int], list[torch.Tensor]]]:
+        """
+        Returns bucketed scalings, bucketed by seq_len. Each value consists of the positions (the first) and the
+        associated tensors. The positions are paired with the associated tensors and give the position in the scaling
+        log. Each scaling is a tensor of shape (batch_size, seq_len, n_layers, n_classes)).
+        """
+        seqlens_map: dict[int, tuple[list[int], list[torch.Tensor]]] = {}
+        for i, scaling in enumerate(self.log_scalings):
+            seq_len = scaling.shape[1]
+            if seq_len not in seqlens_map:
+                seqlens_map[seq_len] = ([i], [scaling])
+            else:
+                seqlens_map[seq_len][0].append(i)
+                seqlens_map[seq_len][1].append(scaling)
+
+        return seqlens_map
+
+    def _set_override_scaling_pass_value(self, value: Union[Number, None]):
+        if value is None:
+            self.override_scaling_pass_value = 1 / self.n_classes
+        else:
+            self.override_scaling_pass_value = value
+        self.config.scaling_pass_value = self.override_scaling_pass_value
diff --git a/src/peft/tuners/xlora/config.py b/src/peft/tuners/xlora/config.py
new file mode 100644
index 0000000..4a2a53f
--- /dev/null
+++ b/src/peft/tuners/xlora/config.py
@@ -0,0 +1,102 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import warnings
+from dataclasses import dataclass
+from typing import Optional
+
+from peft.config import PeftConfig
+from peft.utils.peft_types import PeftType
+
+
+@dataclass
+class XLoraConfig(PeftConfig):
+    r"""
+    This is the configuration class to store the configuration of a `XLoraModel`. When the config is reloaded, the
+    paths of the `adapters` field is disregarded in favor of the saved adapters. As such, only the keys matter during
+    loading.
+
+    Args:
+        hidden_size (`int`):
+            Hidden size of the base model.
+        adapters (`dict`):
+            Mapping of adapter names to the LoRA adapter id, as per PeftModel.load_adapter. *They will be automatically
+            loaded*, to use as LoRA experts. When using from_pretrained, pass the new adapters dict as a keyword
+            argument.
+        enable_softmax (`bool`, *optional*, defaults to `True`):
+            Enable softmax application for the X-LoRA classifier.
+        enable_softmax_topk (`bool`, *optional*, defaults to `False`):
+            Enable softmax application for the top-k LoRA adapters. Mutually exclusive to `enable_softmax` and must
+            only be set if `top_k_lora` is.
+        softmax_temperature (`float`, *optional*, defaults to 1.0):
+            Softmax temperature, lower yields sharper predictions
+        layerwise_scalings (`bool`, *optional*, defaults to `False`):
+            If True, generate scalings for each LoRA adapter (each layer). If this is False, then scalings will be
+            broadcasted, the same, to each layer.
+        top_k_lora (`int`, *optional*, defaults to None):
+            Sparsely select the top_k LoRA experts instead of the default dense method.
+        xlora_depth (`int`, *optional*, defaults to 1):
+            Depth of the X-LoRA classifier.
+        xlora_size (`int`, *optional*, defaults to 2048):
+            Hidden size of the X-LoRA classifier, irrelevant if `xlora_depth=1`.
+        xlora_dropout_p (`float`, *optional*, defaults to 0.2):
+            Dropout probability of the X-LoRA classifier, irrelevant if `xlora_depth=1`.
+        use_trainable_adapters (`bool`, *optional*, defaults to False):
+            Make the adapters trainable.
+        scaling_pass_value (`float`, *optional*, defaults to 0):
+            Scaling pass value.
+        global_scaling_weight (`float`, *optional*, defaults to 1):
+            Weight to multiply output of each LoRA adapter by.
+    """
+
+    hidden_size: int = None  # type: ignore
+    adapters: dict[str, str] = None  # type: ignore
+    enable_softmax: bool = True
+    enable_softmax_topk: bool = False
+    layerwise_scalings: bool = False
+    xlora_depth: int = 1
+    xlora_size: int = 2048
+    xlora_dropout_p: float = 0.2
+    use_trainable_adapters: bool = False
+    softmax_temperature: float = 1.0
+    top_k_lora: Optional[int] = None
+    scaling_pass_value: float = 0.0
+    global_scaling_weight: float = 1.0
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.peft_type = PeftType.XLORA
+
+        if self.hidden_size is None:
+            warnings.warn(
+                "No value was provided for `hidden_size`. This will be set to 4096 by default, please ensure that this is correct."
+            )
+            self.hidden_size = 4096
+        if self.adapters is None:
+            warnings.warn(
+                "No value was provided for `adapters`. This will be set to empty, please ensure that this is correct."
+            )
+            self.adapters = {}
+
+        if self.enable_softmax_topk and self.top_k_lora is None:
+            warnings.warn("`enable_softmax_topk` enabled `top_k_lora` is not set")
+
+        if self.enable_softmax_topk and self.enable_softmax:
+            warnings.warn(
+                "`enable_softmax_topk` and `enable_softmax` are both enabled. This will result in worse performance."
+            )
+
+        if self.top_k_lora is not None and self.top_k_lora < 1:
+            warnings.warn("`top_k_lora` value must be at least 1.")
diff --git a/src/peft/tuners/xlora/layer.py b/src/peft/tuners/xlora/layer.py
new file mode 100644
index 0000000..e0eeac1
--- /dev/null
+++ b/src/peft/tuners/xlora/layer.py
@@ -0,0 +1,236 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any, Optional
+
+import torch
+from torch import Tensor, nn
+
+from peft.tuners import lora
+
+from .config import XLoraConfig
+
+
+class XLoraLayer:
+    """
+    A XLoraLayer wraps any LoraLayer and performs the XLora operation on the LoRA adaptors specified. Its primary API
+    is the forward method, which uses the scalings to execute the XLora algorithm.
+    """
+
+    def __init__(
+        self,
+        model: nn.Module,  # XLoraModel
+        target: lora.LoraLayer,
+        target_forward: Callable[..., Any],
+        layer_number: int,
+        config: XLoraConfig,
+    ) -> None:
+        self.model = model
+        self.target_forward = target_forward
+        self.target = target
+        self.layer_number = layer_number
+        self.config = config
+
+    """
+    Apply the scalings for the adapter.
+    """
+
+    @staticmethod
+    def apply_scalings_to_x(x: torch.Tensor, scalings_layer: torch.Tensor, adapter: int) -> torch.Tensor:
+        # scalings_layer = [batch_size, seq_len, n_classes]
+        scalings = scalings_layer[:, :, adapter].unsqueeze(-1)
+        # scalings_layer = [batch_size, seq_len, 1]
+        return x * scalings
+
+    """
+    Get the scalings for this layer, potentially applying topk and topk+softmax. This is called before
+    `apply_scalings_to_x`
+    """
+
+    def get_maybe_topk_scalings(self, scalings) -> torch.Tensor:
+        # xlora_scalings = [batch_size, seq_len, n_classes]
+        xlora_scalings: Tensor = scalings[:, :, self.layer_number, :]  # type: ignore
+
+        if self.config.top_k_lora is not None:
+            _, topk_indices = torch.topk(xlora_scalings, k=self.config.top_k_lora, dim=-1)
+
+            # Mask the topk to True, the rest to False
+            mask = torch.zeros_like(xlora_scalings, dtype=torch.bool)
+            mask.scatter_(-1, topk_indices, True)
+
+            xlora_scalings = xlora_scalings * mask.to(xlora_scalings.dtype)
+
+        # Apply per-token normalization to the xLoRA scaling factors using a softmax
+        if self.config.enable_softmax_topk:
+            nonzero_mask = xlora_scalings != 0
+            full = xlora_scalings.masked_fill(~nonzero_mask, float("-inf"))
+            new_scalings = torch.softmax(full, dim=-1)
+            xlora_scalings = new_scalings.masked_fill(~nonzero_mask, 0.0)
+
+        return xlora_scalings
+
+
+class XLoraLinearLayer(XLoraLayer):
+    def __init__(
+        self,
+        model: nn.Module,
+        target: lora.Linear,
+        target_forward: Callable[..., Any],
+        layer_number: int,
+        config: XLoraConfig,
+    ) -> None:
+        super().__init__(model, target, target_forward, layer_number, config)
+
+    def forward(self, x: Tensor, *args: Any, scalings: Optional[Tensor] = None, **kwargs: Any) -> Tensor:
+        """
+        This method is designed to be a drop-in-replacement for the LoRA layers' .forward method. To use it, a bound
+        method must be created (bound to an instance of the XLoraLayer class).
+        """
+
+        previous_dtype = x.dtype
+        if scalings is not None:
+            xlora_scalings = self.get_maybe_topk_scalings(scalings)
+
+        result = self.target.base_layer(x, *args, **kwargs)
+
+        # Ignore if disabled. We want to make sure this is always run.
+        if not self.target.merged:
+            for adapter_n, active_adapter in enumerate(self.target.active_adapters):
+                if active_adapter not in self.target.lora_A.keys():
+                    continue
+                # TODO: implement X-LoRA with Lora+Dora layers
+                if self.target.use_dora[active_adapter]:
+                    raise ValueError("X-LoRA currently does not support LoRA layers with DoRA")
+                lora_A = self.target.lora_A[active_adapter]
+                lora_B = self.target.lora_B[active_adapter]
+                dropout = self.target.lora_dropout[active_adapter]
+                scaling = self.target.scaling[active_adapter]
+                x = x.to(lora_A.weight.dtype)  # type: ignore
+                if scalings is not None:
+                    x_mod = self.apply_scalings_to_x(x, xlora_scalings, adapter_n)
+                    scaling_weight = self.config.global_scaling_weight
+                else:
+                    x_mod = x
+                    scaling_weight = 1
+                result += lora_B(lora_A(dropout(x_mod))) * scaling * scaling_weight
+
+        result = result.to(previous_dtype)
+        return result
+
+
+class XLoraEmbeddingLayer(XLoraLayer):
+    def __init__(
+        self,
+        model: nn.Module,
+        target: lora.Embedding,
+        target_forward: Callable[..., Any],
+        layer_number: int,
+        config: XLoraConfig,
+    ) -> None:
+        super().__init__(model, target, target_forward, layer_number, config)
+
+    def forward(self, x: Tensor, *args: Any, scalings: Optional[Tensor] = None, **kwargs: Any) -> Tensor:
+        """
+        This method is designed to be a drop-in-replacement for the LoRA layers' .forward method. To use it, a bound
+        method must be created (bound to an instance of the XLoraLayer class).
+        """
+
+        if scalings is not None:
+            xlora_scalings = self.get_maybe_topk_scalings(scalings)
+
+        result = self.target.base_layer(x, *args, **kwargs)
+
+        # Some embedding layers (e.g., Gemma3TextScaledWordEmbedding) apply scaling in their forward method.
+        # Since base_layer(x) already includes this scaling, we need to apply it to X-LoRA contributions too.
+        embed_scale = self.target._get_embed_scale()
+
+        # Ignore if disabled. We want to make sure this is always run.
+        if not self.target.merged:
+            for adapter_n, active_adapter in enumerate(self.target.active_adapters):
+                if active_adapter not in self.target.lora_embedding_A:
+                    continue
+                # TODO: implement X-LoRA with Lora+Dora layers
+                if self.target.use_dora.get(active_adapter, False):
+                    raise ValueError("X-LoRA currently does not support LoRA layers with DoRA")
+                embedding_A = self.target.lora_embedding_A[active_adapter].T
+                embedding_B = self.target.lora_embedding_B[active_adapter].T
+                scaling = self.target.scaling[active_adapter]
+                after_A = self.target._embed(x, embedding_A)  # type: ignore
+                if scalings is not None:
+                    after_A_mod = self.apply_scalings_to_x(after_A, xlora_scalings, adapter_n)
+                    scaling_weight = self.config.global_scaling_weight
+                else:
+                    after_A_mod = after_A
+                    scaling_weight = 1
+
+                adapter_output = (after_A_mod @ embedding_B) * scaling * scaling_weight
+
+                # Apply embed_scale to match the base layer's scaling
+                if embed_scale is not None:
+                    adapter_output = adapter_output * embed_scale.to(adapter_output.dtype)
+
+                result += adapter_output
+
+        return result
+
+
+class XLoraConv2dLayer(XLoraLayer):
+    def __init__(
+        self,
+        model: nn.Module,
+        target: lora.Conv2d,
+        target_forward: Callable[..., Any],
+        layer_number: int,
+        config: XLoraConfig,
+    ) -> None:
+        super().__init__(model, target, target_forward, layer_number, config)
+
+    def forward(self, x: Tensor, *args: Any, scalings: Optional[Tensor] = None, **kwargs: Any) -> Tensor:
+        """
+        This method is designed to be a drop-in-replacement for the LoRA layers' .forward method. To use it, a bound
+        method must be created (bound to an instance of the XLoraLayer class).
+        """
+
+        previous_dtype = x.dtype
+
+        if scalings is not None:
+            xlora_scalings = self.get_maybe_topk_scalings(scalings)
+
+        result = self.target.base_layer(x, *args, **kwargs)
+
+        # Ignore if disabled. We want to make sure this is always run.
+        if not self.target.merged:
+            for adapter_n, active_adapter in enumerate(self.target.active_adapters):
+                if active_adapter not in self.target.lora_A.keys():
+                    continue
+                # TODO: implement X-LoRA with Lora+Dora layers
+                if self.target.use_dora[active_adapter]:
+                    raise ValueError("X-LoRA currently does not support LoRA layers with DoRA")
+                lora_A = self.target.lora_A[active_adapter]
+                lora_B = self.target.lora_B[active_adapter]
+                dropout = self.target.lora_dropout[active_adapter]
+                scaling = self.target.scaling[active_adapter]
+                x = x.to(lora_A.weight.dtype)  # type: ignore
+                if scalings is not None:
+                    x_mod = self.apply_scalings_to_x(x, xlora_scalings, adapter_n)
+                    scaling_weight = self.config.global_scaling_weight
+                else:
+                    x_mod = x
+                    scaling_weight = 1
+                result += lora_B(lora_A(dropout(x_mod))) * scaling * scaling_weight
+
+        result = result.to(previous_dtype)
+        return result
diff --git a/src/peft/tuners/xlora/model.py b/src/peft/tuners/xlora/model.py
new file mode 100644
index 0000000..08ef5e0
--- /dev/null
+++ b/src/peft/tuners/xlora/model.py
@@ -0,0 +1,525 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import copy
+from contextlib import contextmanager
+from functools import partial
+from typing import Optional, Union
+
+import torch
+from torch import nn
+
+from peft.tuners.lora.layer import LoraLayer
+from peft.tuners.lora.model import LoraModel
+from peft.tuners.tuners_utils import BaseTuner
+from peft.utils.constants import DUMMY_TARGET_MODULES
+from peft.utils.save_and_load import set_peft_model_state_dict
+
+from .. import lora
+from .classifier import XLoraClassifier
+from .config import XLoraConfig
+from .layer import XLoraConv2dLayer, XLoraEmbeddingLayer, XLoraLinearLayer
+
+
+def convert_layers_to_xlora(
+    base: nn.Module,  # PeftModel
+    xloramodel: nn.Module,  # XLoraModel
+    config: XLoraConfig,
+) -> tuple[int, torch.device | None]:
+    """
+    Returns the number of swapped layers.
+    """
+    total_swapped = 0
+    all_layers = []
+
+    device = None
+    for module in base.modules():
+        # Check the exact type because classes like OPTLearnedPositionalEmbedding inherit from nn.Embedding
+        if isinstance(module, lora.Linear):
+            device = module.lora_A[next(iter(module.lora_A))].weight.device
+            new_layer = XLoraLinearLayer(
+                model=xloramodel,
+                target=module,
+                target_forward=module.forward,
+                layer_number=total_swapped,
+                config=config,
+            )
+            all_layers.append(new_layer)
+            module.forward = new_layer.forward  # type: ignore[method-assign]
+            total_swapped += 1
+        elif isinstance(module, lora.Embedding):
+            device = module.lora_embedding_A[next(iter(module.lora_embedding_A))].device
+            new_layer = XLoraEmbeddingLayer(
+                model=xloramodel,
+                target=module,
+                target_forward=module.forward,
+                layer_number=total_swapped,
+                config=config,
+            )
+            all_layers.append(new_layer)
+            module.forward = new_layer.forward  # type: ignore[method-assign]
+            total_swapped += 1
+        elif isinstance(module, lora.Conv2d):
+            device = module.lora_A[next(iter(module.lora_A))].weight.device
+            new_layer = XLoraConv2dLayer(
+                model=xloramodel,
+                target=module,
+                target_forward=module.forward,
+                layer_number=total_swapped,
+                config=config,
+            )
+            all_layers.append(new_layer)
+            module.forward = new_layer.forward  # type: ignore[method-assign]
+            total_swapped += 1
+
+    return (total_swapped, device)
+
+
+def _load_adapter_into_lora_model(
+    lora_model: LoraModel,
+    adapter_name: str,
+    model_id: str,
+    torch_device: Optional[str] = None,
+    ephemeral_gpu_offload: bool = False,
+    autocast_adapter_dtype: bool = True,
+    subfolder: Optional[str] = None,
+    **kwargs,
+):
+    """
+    This method emulates the behavior of `PeftModel.from_pretrained`. Updates to `PeftModel.from_pretrained` may need
+    to be reflected here.
+
+    All params pertain to the adapter (adapter name, model id, `i` is the adapter number in 0 indexing).
+    """
+    from peft.peft_model import PeftModel
+    from peft.tuners.lora.config import LoraConfig
+    from peft.utils.other import infer_device
+    from peft.utils.save_and_load import load_peft_weights
+
+    hf_hub_download_kwargs, kwargs = PeftModel._split_kwargs(kwargs)
+    if torch_device is None:
+        torch_device = infer_device()
+
+    if adapter_name not in lora_model.peft_config:
+        # load the config
+        lora_peft_config = LoraConfig.from_pretrained(
+            model_id,
+            ephemeral_gpu_offload=ephemeral_gpu_offload,
+            subfolder=subfolder,
+            **hf_hub_download_kwargs,
+        )
+        lora_peft_config.inference_mode = False
+        lora_model.peft_config[adapter_name] = lora_peft_config
+        lora_model.inject_adapter(lora_model.model, adapter_name)
+
+    adapter_weights = load_peft_weights(model_id, device=torch_device, subfolder=subfolder, **hf_hub_download_kwargs)
+    new_adapter_weights = {}
+    # Rework the keys to contain the adapter numbers
+    for old_key in adapter_weights.keys():
+        key: str = old_key
+        # Remove all the prefixes until we have model.<...>
+        while not (key.startswith("model.") and not key.startswith("model.model.")):
+            key = key[key.find(".") + 1 :]
+        # We always want model.model
+        key = "model." + key
+        new_adapter_weights[key] = adapter_weights[old_key]
+
+    # load the weights into the model
+    ignore_mismatched_sizes = kwargs.get("ignore_mismatched_sizes", False)
+    load_result = set_peft_model_state_dict(
+        lora_model,
+        new_adapter_weights,
+        adapter_name=adapter_name,
+        ignore_mismatched_sizes=ignore_mismatched_sizes,
+    )
+    if len(load_result.unexpected_keys) > 0:
+        raise ValueError(
+            f"Got unexpected keys! Please raise an issue and tag @EricLBuehler.\n\nunexpected_keys={load_result.unexpected_keys}"
+        )
+
+    if hasattr(lora_model, "_cast_adapter_dtype"):
+        lora_model._cast_adapter_dtype(adapter_name=adapter_name, autocast_adapter_dtype=autocast_adapter_dtype)
+
+
+class XLoraModel(BaseTuner):
+    """
+    Creates an X-LoRA (Mixture of LoRA experts), model from a pretrained transformers model. Currently, this X-LoRA
+    implementation only works with models with a transformer architecture.
+
+    The method is described in detail in https://huggingface.co/papers/2402.07148.
+
+    Args:
+        model ([`torch.nn.Module`]): The model to be adapted.
+        config ([`XLoraConfig`]): The configuration of the Lora model.
+        adapter_name (`str`): The name of the adapter, does not affect the LoRA adapter names.
+
+    Returns:
+        `torch.nn.Module`: The X-LoRA model.
+
+    Example:
+        ```py
+        >>> import torch
+        >>> from transformers import AutoModelForCausalLM, AutoConfig, BitsAndBytesConfig
+        >>> from peft import XLoraConfig, get_peft_model, prepare_model_for_kbit_training
+
+        >>> model_config = AutoConfig.from_pretrained("mistralai/Mistral-7B-Instruct-v0.1")
+        >>> config = XLoraConfig(
+        ...     task_type="CAUSAL_LM",
+        ...     hidden_size=model_config.hidden_size,
+        ...     xlora_depth=4,
+        ...     adapters={
+        ...         "adapter_1": "./path/to/the/checkpoint/",
+        ...         "adapter_2": "./path/to/the/checkpoint/",
+        ...         "adapter_n": "./path/to/the/checkpoint/",
+        ...     },
+        ... )
+        >>> int8_config = BitsAndBytesConfig(load_in_8bit=True)
+        >>> model = AutoModelForCausalLM.from_pretrained(
+        ...     "mistralai/Mistral-7B-Instruct-v0.1",
+        ...     trust_remote_code=True,
+        ...     attn_implementation="flash_attention_2",
+        ...     device_map="cuda:0",
+        ...     torch_dtype=torch.bfloat16,
+        ...     quantization_config=int8_config,
+        ... )
+        >>> model = prepare_model_for_kbit_training(model)
+        >>> xlora_model = get_peft_model(model, config)
+        ```
+    """
+
+    def __init__(
+        self,
+        model: nn.Module,
+        config: Union[dict[str, XLoraConfig], XLoraConfig],
+        adapter_name: str,
+        torch_device: Optional[str] = None,
+        ephemeral_gpu_offload: bool = False,
+        autocast_adapter_dtype: bool = True,
+        **kwargs,
+    ) -> None:
+        """
+        Create a new X-LoRA model
+
+        Args:
+            model (`nn.Module`):
+                Base model to apply X-LoRA to.
+            config: ([`XLoraConfig`]):
+                X-LoRA configuration object.
+            adapter_name: (`str`):
+                Adapter name for the X-LoRA adapter.
+            torch_device (`str`, *optional*, defaults to None):
+                (For loading the LoRA adapters) The device to load the adapter on. If `None`, the device will be
+                inferred.
+            ephemeral_gpu_offload (`bool`, *optional*, defaults to `False`):
+                (For loading the LoRA adapters) Whether to use ephemeral GPU offloading for partially loaded modules.
+                Defaults to `False`.
+            autocast_adapter_dtype (`bool`, *optional*, defaults to `True`):
+                (For loading the LoRA adapters) Whether to autocast the adapter dtype. Defaults to `True`. Right now,
+                this will only cast adapter weights using float16 and bfloat16 to float32, as this is typically
+                required for stable training, and only affect select PEFT tuners.
+            kwargs: (`optional`):
+                (For loading the LoRA adapters) Additional arguments to modify the way the adapter is loaded, e.g. the
+                token for Hugging Face Hub.
+        """
+
+        nn.Module.__init__(self)
+
+        if isinstance(config, dict):
+            conf = config[adapter_name]
+        else:
+            conf = config
+
+        # Create an empty LoraModel
+        base_lora_config = copy.copy(conf)
+        base_lora_config.target_modules = DUMMY_TARGET_MODULES
+        # Imitate a LoraConfig, fields might need to be updated if LoraConfig is updated
+        base_lora_config.layer_replication = None
+        base_lora_config.bias = "none"
+        lora_model = LoraModel(model, base_lora_config, adapter_name)
+
+        self.xlora_config = conf
+        self.lora_model = lora_model
+
+        peft_config = conf
+
+        if hasattr(model.config, "use_cache") and model.config.use_cache:
+            raise ValueError("`use_cache` must be False")
+
+        adapters_items = peft_config.adapters.items()
+        if hasattr(self.xlora_config, "_subfolders"):
+            adapters_items = zip(peft_config.adapters.items(), self.xlora_config._subfolders)
+        else:
+            adapters_items = peft_config.adapters.items()
+
+        if hasattr(self.xlora_config, "_subfolders"):
+            for i, (_adapter_name, model_id), subfolder in enumerate(adapters_items):
+                _load_adapter_into_lora_model(
+                    lora_model=self.lora_model,
+                    adapter_name=str(i),
+                    model_id=model_id,
+                    torch_device=torch_device,
+                    ephemeral_gpu_offload=ephemeral_gpu_offload,
+                    autocast_adapter_dtype=autocast_adapter_dtype,
+                    subfolder=subfolder,
+                    **kwargs,
+                )
+        else:
+            for i, (_adapter_name, model_id) in enumerate(adapters_items):
+                _load_adapter_into_lora_model(
+                    lora_model=self.lora_model,
+                    adapter_name=str(i),
+                    model_id=model_id,
+                    torch_device=torch_device,
+                    ephemeral_gpu_offload=ephemeral_gpu_offload,
+                    autocast_adapter_dtype=autocast_adapter_dtype,
+                    subfolder=None,
+                    **kwargs,
+                )
+
+        self.lora_model.set_adapter(list(peft_config.adapters.keys()))
+
+        self._maybe_freeze_all_adapters()
+
+        total_swapped, device = convert_layers_to_xlora(
+            model,
+            self,
+            peft_config,
+        )
+
+        n_classes = len(peft_config.adapters)
+        xlora_classifier = XLoraClassifier(model, peft_config, n_classes, total_swapped, device)
+
+        # Setup the model internal state
+        self.internal_xlora_classifier = xlora_classifier
+        self.internal_xlora_scalings = None  # type: ignore
+        # Controlled by enable_adapter_layers or disable_adapter_layers
+        self.disabled = False
+
+    def _maybe_freeze_all_adapters(self):
+        self.eval()
+        if not self.xlora_config.use_trainable_adapters:
+            for name, param in self.named_parameters():
+                if "lora_" in name:
+                    param.requires_grad = False
+
+    def generate(self, *args, **kwargs):
+        kwargs["use_cache"] = False
+        res = self.lora_model.generate(*args, **kwargs)  # type: ignore
+        #  This is necessary because we use PeftModel.disable_adapter() which reenables the adapters
+        self._maybe_freeze_all_adapters()
+        return res
+
+    @contextmanager
+    def _enable_peft_forward_hooks(self, *generate_args, **generate_kwargs):
+        def scalings_injection_hook(target, args, kwargs, scalings):
+            # pre-forward hook to inject the adapter_names argument when using mixed adapter batches inference
+            kwargs["scalings"] = scalings
+            return args, kwargs
+
+        hook_handles = []
+
+        def _pre_forward(module, *args, **kwargs):
+            # =========================== Forward pass with "dummy" scalings ==================
+            nonlocal hook_handles
+
+            args_real = args[0]
+            kwargs_real = args[1]
+            kwargs_real.update(kwargs)
+
+            dummy_scalings = self.internal_xlora_classifier.make_dummy_scalings(*args_real, **kwargs_real)
+
+            for xlora_module in self.modules():
+                if isinstance(xlora_module, LoraLayer):
+                    pre_forward = partial(scalings_injection_hook, scalings=dummy_scalings)
+                    existing_hooks = getattr(xlora_module, "_forward_pre_hooks", {})
+                    if any(val is scalings_injection_hook for val in existing_hooks.values()):
+                        # When calling generate, module.forward is called multiple times inside the forward hook
+                        # context, resulting in multiple hooks being registered. Therefore, we check if the hooks is
+                        # already present and skip it in that case.
+                        continue
+                    handle = xlora_module.register_forward_pre_hook(pre_forward, with_kwargs=True)
+                    hook_handles.append(handle)
+
+            with torch.no_grad():
+                self.lora_model.disable_adapter_layers()
+
+                try:
+                    scaling_pass_kwargs = kwargs_real.copy()
+                    scaling_pass_kwargs["output_hidden_states"] = True
+                    scaling_pass_kwargs["return_dict"] = True
+                    try:
+                        base_output = self.lora_model.model.forward(*args_real, **scaling_pass_kwargs)
+                    finally:
+                        # Clean everything up
+                        for handle in hook_handles:
+                            handle.remove()
+                finally:
+                    self.lora_model.enable_adapter_layers()
+
+            xlora_scalings = self.internal_xlora_classifier(*args_real, result=base_output, **kwargs_real)
+            # Store computed scalings to fix get_latest_scalings() returning None
+            self.internal_xlora_scalings = xlora_scalings
+
+            # =========================== Real forward pass with calculated scalings ==================
+
+            hook_handles = []
+            for xlora_module in self.modules():
+                if isinstance(xlora_module, LoraLayer):
+                    pre_forward = partial(scalings_injection_hook, scalings=xlora_scalings)
+                    handle = xlora_module.register_forward_pre_hook(pre_forward, with_kwargs=True)
+                    hook_handles.append(handle)
+
+        if not self.disabled:
+            forward_handle = self.lora_model.model.register_forward_pre_hook(_pre_forward, with_kwargs=True)
+
+        # Run the forward pass: first the scaling pass in the hook, and then with the base model
+        try:
+            yield
+        finally:
+            if not self.disabled:
+                for handle in hook_handles:
+                    handle.remove()
+                forward_handle.remove()
+
+    def __getattr__(self, name: str):
+        """Forward missing attributes to the wrapped module."""
+        try:
+            return super().__getattr__(name)  # defer to nn.Module's logic
+        except AttributeError:
+            if name == "lora_model":  # see #1892: prevent infinite recursion if class is not initialized
+                raise
+            return getattr(self.lora_model, name)
+
+    @staticmethod
+    def _prepare_adapter_config(peft_config, _model_config):
+        # Handle X-LoRA case
+        return peft_config
+
+    """
+    Does nothing. X-LoRA needs adapters to be frozen.
+    """
+
+    def _mark_only_adapters_as_trainable(self) -> None: ...
+
+    """
+    This enables the X-LoRA adapter.
+    """
+
+    def enable_adapter_layers(self) -> None:
+        self.disabled = False
+
+    """
+    This disables the X-LoRA adapter.
+    """
+
+    def disable_adapter_layers(self) -> None:
+        self.disabled = True
+
+    def _create_and_replace(
+        self,
+        lora_config,
+        adapter_name,
+        target,
+        target_name,
+        parent,
+        current_key,
+    ):
+        # Does nothing because XLoraModel has no target modules
+        pass
+
+    @staticmethod
+    def _check_target_module_exists(lora_config, key):
+        # Does nothing because XLoraModel has no target modules
+        return False
+
+    def forward(self, *args, **kwargs):
+        return self.lora_model.model(*args, **kwargs)
+
+    def set_topk_lora(self, value: Optional[int]):
+        """
+        Sparsely select the specified top_k LoRA experts instead of the default dense method. Set to None to use dense.
+        This is reflected in the config.
+        """
+        classifier: XLoraClassifier = self.internal_xlora_classifier  # type: ignore
+        classifier.config.top_k_lora = value
+
+    def set_global_scaling_weight(self, weight: float):
+        """
+        Set the global LoRA weight, a scalar to multiply the output of each LoRA adapter by. This is by default 1. This
+        is reflected in the config.
+        """
+        classifier: XLoraClassifier = self.internal_xlora_classifier  # type: ignore
+        classifier.config.global_scaling_weight = weight
+
+    def set_scaling_pass_value(self, value: float | None):
+        """
+        Set the scaling pass value, the value to set the scalings to during the scaling pass. If the value is None, the
+        scaling pass value will be 1/n where n is the number of adapters.
+        """
+        classifier: XLoraClassifier = self.internal_xlora_classifier  # type: ignore
+        classifier._set_override_scaling_pass_value(value)
+
+    def get_global_scaling_weight(self) -> float:
+        """
+        Get the global LoRA weight.
+        """
+        classifier: XLoraClassifier = self.internal_xlora_classifier  # type: ignore
+        return classifier.config.global_scaling_weight
+
+    def get_latest_scalings(self) -> Optional[torch.Tensor]:
+        """
+        Returns the latest scalings prediction, or None if no scalings have been predicted. The tensor is of shape
+        (batch_size, seq_len, n_layers, n_classes).
+        """
+        return self.internal_xlora_scalings
+
+    def get_scalings_log(self) -> list[torch.Tensor]:
+        """
+        Returns a shallow (only copying the list itself not the tensors) copy of the list containing the scalings log.
+        Editing the list does not change the underlying log. The tensors are of shape (batch_size, seq_len, n_layers,
+        n_classes). The seq_len dim may vary with input dimension.
+        """
+        classifier: XLoraClassifier = self.internal_xlora_classifier  # type: ignore
+        return classifier.log_scalings.copy()
+
+    def enable_scalings_logging(self):
+        """
+        Enable scalings logging.
+        """
+        classifier: XLoraClassifier = self.internal_xlora_classifier  # type: ignore
+        classifier.scalings_logging = True
+
+    def disable_scalings_logging(self):
+        """
+        Disable scalings logging, without clearing the log.
+        """
+        classifier: XLoraClassifier = self.internal_xlora_classifier  # type: ignore
+        classifier.scalings_logging = False
+
+    def clear_scalings_log(self):
+        """
+        Clear the scalings log.
+        """
+        classifier: XLoraClassifier = self.internal_xlora_classifier  # type: ignore
+        classifier.log_scalings.clear()
+
+    def get_bucketed_scalings_log(self) -> dict[int, tuple[list[int], list[torch.Tensor]]]:
+        """
+        Returns bucketed scalings, bucketed by seq_len. Each value consists of the positions (the first) and the
+        associated tensors. The positions are paired with the associated tensors and give the position in the scaling
+        log.
+        """
+        classifier: XLoraClassifier = self.internal_xlora_classifier  # type: ignore
+        return classifier._get_bucketed_scalings()
diff --git a/src/peft/utils/__init__.py b/src/peft/utils/__init__.py
new file mode 100644
index 0000000..c7c4728
--- /dev/null
+++ b/src/peft/utils/__init__.py
@@ -0,0 +1,159 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from .constants import ALLOWED_COMPUTE_DTYPES, UPCAST_DTYPES
+from .integrations import map_cache_to_layer_device_map
+from .loftq_utils import replace_lora_weights_loftq
+from .other import (
+    CONFIG_NAME,
+    INCLUDE_LINEAR_LAYERS_SHORTHAND,
+    SAFETENSORS_WEIGHTS_NAME,
+    TRANSFORMERS_MODELS_TO_ADALORA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_ADAMSS_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_BEFT_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_BOFT_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_C3A_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_DEFT_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_DELORA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_FOURIERFT_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_FROD_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_GLORA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_GRALORA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_HRA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_IA3_FEEDFORWARD_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_IA3_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_LILY_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_LNTUNING_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_LOHA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_LOKR_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_MISS_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_OFT_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_PEANUT_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_POLY_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_PREFIX_TUNING_POSTPROCESS_MAPPING,
+    TRANSFORMERS_MODELS_TO_PSOFT_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_PVERA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_RANDLORA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_ROAD_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_SHIRA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_TINYLORA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_UNILORA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_VBLORA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_VERA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_WAVEFT_TARGET_MODULES_MAPPING,
+    WEIGHTS_NAME,
+    AuxiliaryTrainingWrapper,
+    ModulesToSaveWrapper,
+    TrainableTokensWrapper,
+    _freeze_adapter,
+    _get_batch_size,
+    _get_input_embeddings_name,
+    _get_submodules,
+    _is_valid_match,
+    _prepare_prompt_learning_config,
+    _set_adapter,
+    _set_trainable,
+    bloom_model_postprocess_past_key_value,
+    cast_mixed_precision_params,
+    get_gptqmodel_quant_linear,
+    get_quantization_config,
+    id_tensor_storage,
+    infer_device,
+    prepare_model_for_kbit_training,
+    set_additional_trainable_modules,
+    shift_tokens_right,
+    transpose,
+)
+from .peft_types import PeftType, TaskType, register_peft_method
+from .quantization_utils import get_quantization_kwargs, quantization_extra_repr, resolve_quantization_backend
+from .save_and_load import get_peft_model_state_dict, load_peft_weights, set_peft_model_state_dict
+from .warning import PeftWarning
+
+
+__all__ = [
+    "ALLOWED_COMPUTE_DTYPES",
+    "CONFIG_NAME",
+    "INCLUDE_LINEAR_LAYERS_SHORTHAND",
+    "SAFETENSORS_WEIGHTS_NAME",
+    "TRANSFORMERS_MODELS_TO_ADALORA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_ADAMSS_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_BEFT_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_BOFT_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_C3A_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_DEFT_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_DELORA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_FOURIERFT_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_FROD_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_GLORA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_GRALORA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_HRA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_IA3_FEEDFORWARD_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_IA3_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_LILY_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_LNTUNING_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_LOHA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_LOKR_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_MISS_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_OFT_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_PEANUT_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_POLY_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_PREFIX_TUNING_POSTPROCESS_MAPPING",
+    "TRANSFORMERS_MODELS_TO_PSOFT_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_PVERA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_RANDLORA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_ROAD_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_SHIRA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_TINYLORA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_UNILORA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_VBLORA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_VERA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_WAVEFT_TARGET_MODULES_MAPPING",
+    "UPCAST_DTYPES",
+    "WEIGHTS_NAME",
+    "AuxiliaryTrainingWrapper",
+    "ModulesToSaveWrapper",
+    "PeftType",
+    "PeftWarning",
+    "TaskType",
+    "TrainableTokensWrapper",
+    "_freeze_adapter",
+    "_get_batch_size",
+    "_get_input_embeddings_name",
+    "_get_submodules",
+    "_is_valid_match",
+    "_prepare_prompt_learning_config",
+    "_set_adapter",
+    "_set_trainable",
+    "bloom_model_postprocess_past_key_value",
+    "cast_mixed_precision_params",
+    "get_gptqmodel_quant_linear",
+    "get_peft_model_state_dict",
+    "get_quantization_config",
+    "get_quantization_kwargs",
+    "id_tensor_storage",
+    "infer_device",
+    "load_peft_weights",
+    "map_cache_to_layer_device_map",
+    "prepare_model_for_kbit_training",
+    "quantization_extra_repr",
+    "register_peft_method",
+    "replace_lora_weights_loftq",
+    "resolve_quantization_backend",
+    "set_additional_trainable_modules",
+    "set_peft_model_state_dict",
+    "shift_tokens_right",
+    "transpose",
+]
diff --git a/src/peft/utils/constants.py b/src/peft/utils/constants.py
new file mode 100644
index 0000000..5619e5f
--- /dev/null
+++ b/src/peft/utils/constants.py
@@ -0,0 +1,414 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import torch
+from transformers import BloomPreTrainedModel
+
+from ..import_utils import is_transformers_le_4_53
+
+
+# needed for prefix-tuning of bloom model
+def bloom_model_postprocess_past_key_value(past_key_values):
+    past_key_values = torch.cat(past_key_values)
+    total_layers, batch_size, num_attention_heads, num_virtual_tokens, head_dim = past_key_values.shape
+    keys = past_key_values[: total_layers // 2]
+    keys = keys.transpose(2, 3).reshape(
+        total_layers // 2, batch_size * num_attention_heads, head_dim, num_virtual_tokens
+    )
+    values = past_key_values[total_layers // 2 :]
+    values = values.reshape(total_layers // 2, batch_size * num_attention_heads, num_virtual_tokens, head_dim)
+
+    return tuple(zip(keys, values))
+
+
+# needed for prefix-tuning of StarCoder models
+def starcoder_model_postprocess_past_key_value(past_key_values):
+    result = []
+    for k in past_key_values:
+        k = k[:, :, 0]
+        k = k.permute([1, 2, 0, 3])
+        k = k.reshape(*k.shape[:-2], -1)
+        result.append(k)
+    return tuple(result)
+
+
+# TODO: remove this once transformers 4.53 is no longer supported
+TRANSFORMERS_MODELS_TO_PREFIX_TUNING_POSTPROCESS_MAPPING = {}
+if is_transformers_le_4_53:
+    TRANSFORMERS_MODELS_TO_PREFIX_TUNING_POSTPROCESS_MAPPING["gpt_bigcode"] = (
+        starcoder_model_postprocess_past_key_value
+    )
+
+
+if hasattr(BloomPreTrainedModel, "_convert_to_standard_cache"):
+    # special handling for bloom architecture was fixed in:
+    # https://github.com/huggingface/transformers/pull/31445
+    # the _convert_to_standard_cache method is removed in the PR and thus serves as an indicator
+    TRANSFORMERS_MODELS_TO_PREFIX_TUNING_POSTPROCESS_MAPPING["bloom"] = bloom_model_postprocess_past_key_value
+
+
+#######################################
+# DEFAULT MAPPINGS FOR TARGET_MODULES #
+#######################################
+
+TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING = {
+    "t5": ["q", "v"],
+    "mt5": ["q", "v"],
+    "bart": ["q_proj", "v_proj"],
+    "gpt2": ["c_attn"],
+    "bloom": ["query_key_value"],
+    "blip-2": ["q", "v", "q_proj", "v_proj"],
+    "opt": ["q_proj", "v_proj"],
+    "gptj": ["q_proj", "v_proj"],
+    "gpt_neox": ["query_key_value"],
+    "gpt_neo": ["q_proj", "v_proj"],
+    "bert": ["query", "value"],
+    "roberta": ["query", "value"],
+    "xlm-roberta": ["query", "value"],
+    "electra": ["query", "value"],
+    "deberta-v2": ["query_proj", "value_proj"],
+    "deberta": ["in_proj"],
+    "layoutlm": ["query", "value"],
+    "llama": ["q_proj", "v_proj"],
+    "llama4": ["q_proj", "v_proj"],
+    "chatglm": ["query_key_value"],
+    "gpt_bigcode": ["c_attn"],
+    "mpt": ["Wqkv"],
+    "RefinedWebModel": ["query_key_value"],
+    "RefinedWeb": ["query_key_value"],
+    "falcon": ["query_key_value"],
+    "btlm": ["c_proj", "c_attn"],
+    "codegen": ["qkv_proj"],
+    "mistral": ["q_proj", "v_proj"],
+    "mixtral": ["q_proj", "v_proj"],
+    "stablelm": ["q_proj", "v_proj"],
+    "phi": ["q_proj", "v_proj", "fc1", "fc2"],
+    "gemma": ["q_proj", "v_proj"],
+    "gemma2": ["q_proj", "v_proj"],
+    "gemma3_text": ["q_proj", "v_proj"],
+    "gemma4": r".*language_model\..*\.(q_proj|v_proj)",
+    "qwen2": ["q_proj", "v_proj"],
+    "qwen3": ["q_proj", "v_proj"],
+    "nemotron_h": ["q_proj", "k_proj", "v_proj", "o_proj"],
+    "rwkv": ["key", "value", "receptance", "output"],
+    "rwkv7": ["r_proj", "k_proj", "v_proj", "o_proj", "key", "value"],
+}
+
+# target module mappings that are identical to LORA
+TRANSFORMERS_MODELS_TO_BOFT_TARGET_MODULES_MAPPING = TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING.copy()
+TRANSFORMERS_MODELS_TO_C3A_TARGET_MODULES_MAPPING = TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING.copy()
+TRANSFORMERS_MODELS_TO_DELORA_TARGET_MODULES_MAPPING = TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING.copy()
+TRANSFORMERS_MODELS_TO_DEFT_TARGET_MODULES_MAPPING = TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING.copy()
+TRANSFORMERS_MODELS_TO_GLORA_TARGET_MODULES_MAPPING = TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING.copy()
+TRANSFORMERS_MODELS_TO_HRA_TARGET_MODULES_MAPPING = TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING.copy()
+TRANSFORMERS_MODELS_TO_LOHA_TARGET_MODULES_MAPPING = TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING.copy()
+TRANSFORMERS_MODELS_TO_LOKR_TARGET_MODULES_MAPPING = TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING.copy()
+TRANSFORMERS_MODELS_TO_MISS_TARGET_MODULES_MAPPING = TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING.copy()
+TRANSFORMERS_MODELS_TO_OFT_TARGET_MODULES_MAPPING = TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING.copy()
+TRANSFORMERS_MODELS_TO_POLY_TARGET_MODULES_MAPPING = TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING.copy()
+TRANSFORMERS_MODELS_TO_RANDLORA_TARGET_MODULES_MAPPING = TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING.copy()
+TRANSFORMERS_MODELS_TO_ADAMSS_TARGET_MODULES_MAPPING = TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING.copy()
+TRANSFORMERS_MODELS_TO_ADAMSS_TARGET_MODULES_MAPPING["vit"] = ["query", "value"]
+TRANSFORMERS_MODELS_TO_ROAD_TARGET_MODULES_MAPPING = TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING.copy()
+TRANSFORMERS_MODELS_TO_TINYLORA_TARGET_MODULES_MAPPING = TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING.copy()
+TRANSFORMERS_MODELS_TO_PSOFT_TARGET_MODULES_MAPPING = TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING.copy()
+TRANSFORMERS_MODELS_TO_LILY_TARGET_MODULES_MAPPING = TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING.copy()
+TRANSFORMERS_MODELS_TO_GRALORA_TARGET_MODULES_MAPPING = TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING.copy()
+TRANSFORMERS_MODELS_TO_PEANUT_TARGET_MODULES_MAPPING = TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING.copy()
+
+# mappings that are similar to LORA with small changes
+TRANSFORMERS_MODELS_TO_FOURIERFT_TARGET_MODULES_MAPPING = TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING.copy()
+TRANSFORMERS_MODELS_TO_FOURIERFT_TARGET_MODULES_MAPPING["gpt_bigcode"] = ["mlp.c_proj"]
+TRANSFORMERS_MODELS_TO_FOURIERFT_TARGET_MODULES_MAPPING["gpt2"] = ["mlp.c_proj"]
+
+TRANSFORMERS_MODELS_TO_SHIRA_TARGET_MODULES_MAPPING = TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING.copy()
+TRANSFORMERS_MODELS_TO_SHIRA_TARGET_MODULES_MAPPING["phi"] = ["q_proj", "v_proj"]
+
+TRANSFORMERS_MODELS_TO_VERA_TARGET_MODULES_MAPPING = TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING.copy()
+TRANSFORMERS_MODELS_TO_VERA_TARGET_MODULES_MAPPING["phi"] = ["q_proj", "v_proj"]
+
+TRANSFORMERS_MODELS_TO_FROD_TARGET_MODULES_MAPPING = TRANSFORMERS_MODELS_TO_VERA_TARGET_MODULES_MAPPING.copy()
+TRANSFORMERS_MODELS_TO_FROD_TARGET_MODULES_MAPPING["vit"] = ["query", "value"]
+
+TRANSFORMERS_MODELS_TO_PVERA_TARGET_MODULES_MAPPING = TRANSFORMERS_MODELS_TO_VERA_TARGET_MODULES_MAPPING.copy()
+TRANSFORMERS_MODELS_TO_PVERA_TARGET_MODULES_MAPPING["dinov2"] = ["query", "value"]
+
+TRANSFORMERS_MODELS_TO_C3A_TARGET_MODULES_MAPPING = TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING.copy()
+TRANSFORMERS_MODELS_TO_C3A_TARGET_MODULES_MAPPING["gpt_bigcode"] = ["mlp.c_proj"]
+TRANSFORMERS_MODELS_TO_C3A_TARGET_MODULES_MAPPING["gpt2"] = ["mlp.c_proj"]
+
+# target module mappings that differ from LORA
+TRANSFORMERS_MODELS_TO_LNTUNING_TARGET_MODULES_MAPPING = {
+    "llama": ["input_layernorm", "post_attention_layernorm", "norm"],
+    "bloom": ["input_layernorm", "post_attention_layernorm", "ln_f"],
+    "llava": [
+        "multi_modal_projector",
+        "input_layernorm",
+        "post_attention_layernorm",
+        "norm",
+        "embed_tokens",
+        "lm_head",
+    ],
+    "t5": ["layer_norm", "final_layer_norm"],
+    "mt5": ["layer_norm", "final_layer_norm"],
+    "bart": ["self_attn_layer_norm", "encoder_attn_layer_norm", "final_layer_norm"],
+    "gpt2": ["ln_1", "ln_2", "ln_f"],
+    "blip-2": ["layernorm", "LayerNorm", "final_layer_norm", "self_attn_layer_norm"],
+    "gptj": ["ln_1", "ln_f"],
+    "falcon": ["input_layernorm", "post_attention_layernorm", "ln_f"],
+    "mistral": ["input_layernorm", "post_attention_layernorm", "norm"],
+    "phi": ["input_layernorm", "final_layernorm"],
+    "gemma": ["input_layernorm", "post_attention_layernorm", "norm"],
+    "gemma2": [
+        "input_layernorm",
+        "post_attention_layernorm",
+        "pre_feedforward_layernorm",
+        "post_feedforward_layernorm",
+        "norm",
+    ],
+    "gemma3_text": [
+        "input_layernorm",
+        "post_attention_layernorm",
+        "pre_feedforward_layernorm",
+        "post_feedforward_layernorm",
+        "norm",
+    ],
+    "qwen2": ["post_attention_layernorm"],
+    "qwen3": ["post_attention_layernorm"],
+}
+
+TRANSFORMERS_MODELS_TO_HIRA_TARGET_MODULES_MAPPING = TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING.copy()
+
+
+TRANSFORMERS_MODELS_TO_IA3_TARGET_MODULES_MAPPING = {
+    "t5": ["k", "v", "wo"],
+    "mt5": ["k", "v", "wi_1"],
+    "gpt2": ["c_attn", "mlp.c_proj"],
+    "bloom": ["query_key_value", "mlp.dense_4h_to_h"],
+    "roberta": ["key", "value", "output.dense"],
+    "opt": ["q_proj", "k_proj", "fc2"],
+    "gptj": ["q_proj", "v_proj", "fc_out"],
+    "gpt_neox": ["query_key_value", "dense_4h_to_h"],
+    "gpt_neo": ["q_proj", "v_proj", "c_proj"],
+    "bart": ["q_proj", "v_proj", "fc2"],
+    "gpt_bigcode": ["c_attn", "mlp.c_proj"],
+    "llama": ["k_proj", "v_proj", "down_proj"],
+    "llama4": ["q_proj", "v_proj", "down_proj"],
+    "mistral": ["k_proj", "v_proj", "down_proj"],
+    "mixtral": ["k_proj", "v_proj", "w2"],
+    "bert": ["key", "value", "output.dense"],
+    "deberta-v2": ["key_proj", "value_proj", "output.dense"],
+    "deberta": ["in_proj", "output.dense"],
+    "RefinedWebModel": ["query_key_value", "dense_4h_to_h"],
+    "RefinedWeb": ["query_key_value", "dense_4h_to_h"],
+    "falcon": ["query_key_value", "dense_4h_to_h"],
+    "phi": ["q_proj", "v_proj", "fc2"],
+    "gemma": ["q_proj", "v_proj", "down_proj"],
+    "gemma2": ["q_proj", "v_proj", "down_proj"],
+    "gemma3_text": ["q_proj", "v_proj", "down_proj"],
+    "qwen2": ["q_proj", "v_proj", "down_proj"],
+    "qwen3": ["q_proj", "v_proj", "down_proj"],
+}
+
+TRANSFORMERS_MODELS_TO_BEFT_TARGET_MODULES_MAPPING = {
+    "t5": ["v"],
+    "mt5": ["v"],
+    "roberta": ["value"],
+    "opt": ["v_proj"],
+    "gptj": ["v_proj"],
+    "gpt_neo": ["v_proj"],
+    "bart": ["v_proj"],
+    "llama": ["v_proj"],
+    "llama4": ["v_proj"],
+    "mistral": ["v_proj"],
+    "mixtral": ["v_proj"],
+    "bert": ["value"],
+    "deberta-v2": ["value_proj"],
+    "phi": ["v_proj"],
+    "gemma": ["v_proj"],
+    "gemma2": ["v_proj"],
+    "gemma3_text": ["v_proj"],
+    "qwen2": ["v_proj"],
+    "qwen3": ["v_proj"],
+}
+
+TRANSFORMERS_MODELS_TO_IA3_FEEDFORWARD_MODULES_MAPPING = {
+    "t5": ["wo"],
+    "mt5": [],
+    "gpt2": ["mlp.c_proj"],
+    "bloom": ["mlp.dense_4h_to_h"],
+    "roberta": ["output.dense"],
+    "opt": ["fc2"],
+    "gptj": ["fc_out"],
+    "gpt_neox": ["dense_4h_to_h"],
+    "gpt_neo": ["c_proj"],
+    "bart": ["fc2"],
+    "gpt_bigcode": ["mlp.c_proj"],
+    "llama": ["down_proj"],
+    "llama4": ["down_proj"],
+    "mistral": ["down_proj"],
+    "mixtral": ["w2"],
+    "bert": ["output.dense"],
+    "deberta-v2": ["output.dense"],
+    "deberta": ["output.dense"],
+    "RefinedWeb": ["dense_4h_to_h"],
+    "RefinedWebModel": ["dense_4h_to_h"],
+    "falcon": ["dense_4h_to_h"],
+    "phi": ["fc2"],
+    "gemma": ["down_proj"],
+    "gemma2": ["down_proj"],
+    "gemma3_text": ["down_proj"],
+    "qwen2": ["down_proj"],
+    "qwen3": ["down_proj"],
+}
+
+TRANSFORMERS_MODELS_TO_ADALORA_TARGET_MODULES_MAPPING = {
+    "t5": ["q", "k", "v", "o", "wi", "wo"],
+    "mt5": ["q", "k", "v", "o", "wi_0", "wi_1", "wo"],
+    "bart": ["q_proj", "k_proj", "v_proj", "out_proj", "fc1", "fc2"],
+    "gpt2": ["c_attn"],
+    "bloom": ["query_key_value"],
+    "opt": ["q_proj", "k_proj", "v_proj", "out_proj", "fc1", "fc2"],
+    "gptj": ["q_proj", "v_proj"],
+    "gpt_neox": ["query_key_value"],
+    "gpt_neo": ["q_proj", "v_proj"],
+    "llama": ["q_proj", "v_proj"],
+    "llama4": ["q_proj", "v_proj"],
+    "bert": ["query", "value"],
+    "roberta": ["query", "key", "value", "dense"],
+    # "xlm-roberta": ["query", "value"],
+    # "electra": ["query", "value"],
+    "deberta-v2": ["query_proj", "key_proj", "value_proj", "dense"],
+    "gpt_bigcode": ["c_attn"],
+    "deberta": ["in_proj"],
+    # "layoutlm": ["query", "value"],
+    "gemma": ["q_proj", "v_proj"],
+    "gemma2": ["q_proj", "v_proj"],
+    "gemma3_text": ["q_proj", "v_proj"],
+    "gemma4": r".*language_model\..*\.(q_proj|v_proj)",
+    "qwen2": ["q_proj", "v_proj"],
+    "qwen3": ["q_proj", "v_proj"],
+    "nemotron_h": ["q_proj", "k_proj", "v_proj", "o_proj"],
+}
+
+TRANSFORMERS_MODELS_TO_VBLORA_TARGET_MODULES_MAPPING = {
+    "t5": ["q", "k", "v", "o", "wi", "wo"],
+    "mt5": ["q", "k", "v", "o", "wi_0", "wi_1", "wo"],
+    "bart": ["q_proj", "k_proj", "v_proj", "out_proj", "fc1", "fc2"],
+    "gpt2": ["c_attn"],
+    "bloom": ["query_key_value"],
+    "opt": ["q_proj", "k_proj", "v_proj", "out_proj", "fc1", "fc2"],
+    "gptj": ["q_proj", "v_proj"],
+    "gpt_neox": ["query_key_value"],
+    "gpt_neo": ["q_proj", "v_proj"],
+    "llama": ["q_proj", "v_proj"],
+    "llama4": ["q_proj", "v_proj"],
+    "bert": ["query", "value"],
+    "roberta": ["query", "value"],
+    "deberta-v2": ["query_proj", "key_proj", "value_proj", "dense"],
+    "gpt_bigcode": ["c_attn"],
+    "deberta": ["in_proj"],
+    "gemma": ["q_proj", "v_proj"],
+    "gemma2": ["q_proj", "v_proj"],
+    "gemma3_text": ["q_proj", "v_proj"],
+    "gemma4": r".*language_model\..*\.(q_proj|v_proj)",
+    "qwen2": ["q_proj", "v_proj"],
+    "qwen3": ["q_proj", "v_proj"],
+    "nemotron_h": ["q_proj", "k_proj", "v_proj", "o_proj"],
+}
+
+TRANSFORMERS_MODELS_TO_UNILORA_TARGET_MODULES_MAPPING = TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING.copy()
+
+TRANSFORMERS_MODELS_TO_OSF_TARGET_MODULES_MAPPING = {
+    "llama": ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "down_proj", "up_proj"],
+    "llama4": ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "down_proj", "up_proj"],
+    "mistral": ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "down_proj", "up_proj"],
+    "mixtral": ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "down_proj", "up_proj"],
+    "gemma": ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "down_proj", "up_proj"],
+    "gemma2": ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "down_proj", "up_proj"],
+    "gemma3_text": ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "down_proj", "up_proj"],
+    "qwen2": ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "down_proj", "up_proj"],
+    "qwen3": ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "down_proj", "up_proj"],
+    "phi": ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "down_proj", "up_proj"],
+    "gpt2": ["c_attn", "c_proj"],
+    "bloom": ["query_key_value", "dense_4h_to_h"],
+    "opt": ["q_proj", "k_proj", "v_proj", "out_proj", "fc1", "fc2"],
+    "gptj": ["q_proj", "k_proj", "v_proj", "out_proj", "fc_in", "fc_out"],
+    "gpt_neox": ["query_key_value", "dense_4h_to_h"],
+    "falcon": ["query_key_value", "dense_4h_to_h"],
+    "gpt_bigcode": ["c_attn", "c_proj"],
+}
+
+TRANSFORMERS_MODELS_TO_WAVEFT_TARGET_MODULES_MAPPING = {
+    "t5": ["q", "v"],
+    "mt5": ["q", "v"],
+    "bart": ["q_proj", "v_proj"],
+    "gpt2": ["mlp.c_proj"],
+    "bloom": ["query_key_value"],
+    "blip-2": ["q", "v", "q_proj", "v_proj"],
+    "opt": ["q_proj", "v_proj"],
+    "gptj": ["q_proj", "v_proj"],
+    "gpt_neox": ["query_key_value"],
+    "gpt_neo": ["q_proj", "v_proj"],
+    "bert": ["query", "value"],
+    "roberta": ["query", "value"],
+    "xlm-roberta": ["query", "value"],
+    "electra": ["query", "value"],
+    "deberta-v2": ["query_proj", "value_proj"],
+    "deberta": ["in_proj"],
+    "layoutlm": ["query", "value"],
+    "llama": ["q_proj", "v_proj"],
+    "llama4": ["q_proj", "v_proj"],
+    "chatglm": ["query_key_value"],
+    "gpt_bigcode": ["mlp.c_proj"],
+    "mpt": ["Wqkv"],
+    "RefinedWebModel": ["query_key_value"],
+    "RefinedWeb": ["query_key_value"],
+    "falcon": ["query_key_value"],
+    "codegen": ["qkv_proj"],
+    "mistral": ["q_proj", "v_proj"],
+    "mixtral": ["q_proj", "v_proj"],
+    "stablelm": ["q_proj", "v_proj"],
+    "phi": ["q_proj", "v_proj", "fc1", "fc2"],
+    "gemma": ["q_proj", "v_proj"],
+    "gemma2": ["q_proj", "v_proj"],
+    "gemma3_text": ["q_proj", "v_proj"],
+    "gemma4": r".*language_model\..*\.(q_proj|v_proj)",
+    "qwen2": ["q_proj", "v_proj"],
+    "qwen3": ["q_proj", "v_proj"],
+    "nemotron_h": ["q_proj", "k_proj", "v_proj", "o_proj"],
+}
+
+##################
+# MISC CONSTANTS #
+##################
+WEIGHTS_NAME = "adapter_model.bin"
+SAFETENSORS_WEIGHTS_NAME = "adapter_model.safetensors"
+CONFIG_NAME = "adapter_config.json"
+EMBEDDING_LAYER_NAMES = ["embed_tokens", "lm_head"]
+SEQ_CLS_HEAD_NAMES = ["score", "classifier"]
+INCLUDE_LINEAR_LAYERS_SHORTHAND = "all-linear"
+TOKENIZER_CONFIG_NAME = "tokenizer_config.json"
+DUMMY_TARGET_MODULES = "dummy-target-modules"
+DUMMY_MODEL_CONFIG = {"model_type": "custom"}
+
+# If users specify more than this number of target modules, we apply an optimization to try to reduce the target modules
+# to a minimal set of suffixes, which makes loading faster. We only apply this when exceeding a certain size since
+# otherwise there is no point in optimizing and there is a small chance of bugs in the optimization algorithm, so no
+# point in taking unnecessary risks. See #2045 for more context.
+MIN_TARGET_MODULES_FOR_OPTIMIZATION = 20
+# dtypes that are allowed to be used for adapter computation
+ALLOWED_COMPUTE_DTYPES = (torch.float16, torch.bfloat16, torch.float32)
+# float dtypes that should be upcast in the adapter for computation
+UPCAST_DTYPES = ("float8_e4m3fn", "float8_e4m3fnuz", "float8_e5m2", "float8_e5m2fnuz", "float8_e8m0fnu")
diff --git a/src/peft/utils/hotswap.py b/src/peft/utils/hotswap.py
new file mode 100644
index 0000000..8b2d09a
--- /dev/null
+++ b/src/peft/utils/hotswap.py
@@ -0,0 +1,643 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import math
+import warnings
+from operator import attrgetter
+from typing import Literal, Optional
+
+import torch
+
+from peft.config import PeftConfig
+from peft.mapping import PEFT_TYPE_TO_CONFIG_MAPPING, PEFT_TYPE_TO_PREFIX_MAPPING
+from peft.tuners.lora import Conv2d, Linear, LoraConfig, LoraLayer
+
+from .other import get_pattern_key, infer_device
+from .peft_types import PeftType
+from .save_and_load import _insert_adapter_name_into_state_dict, load_peft_weights
+
+
+# so far only LoRA is supported
+CONFIG_KEYS_TO_CHECK = {PeftType.LORA: ["use_rslora", "lora_dropout", "alpha_pattern", "use_dora"]}
+
+
+def _update_scaling(lora_module, adapter_name, scaling=None):
+    """
+    Update the value of the scalings of the LoRA module.
+
+    Takes into consideration that scalings can be tensors from prepare_model_for_compiled_hotswap.
+    """
+    if lora_module.scaling[adapter_name] == scaling:
+        return
+
+    if isinstance(lora_module.scaling[adapter_name], torch.Tensor):
+        lora_module.scaling[adapter_name].fill_(scaling)
+    elif isinstance(lora_module.scaling[adapter_name], (float, int)):
+        lora_module.scaling[adapter_name] = scaling
+    else:
+        raise TypeError(
+            "Something went wrong when trying to set the new scale value, expected to find the old value to be of type "
+            f"float or torch.Tensor, got {type(lora_module.scaling[adapter_name])} instead."
+        )
+
+
+def _convert_scalings_to_tensor(model) -> bool:
+    """
+    Convert the LoRA scaling values into torch.tensors to prevent recompilation if they change.
+
+    Returns:
+        bool:
+            Returns `True` if an appropriate adapter was found, else `False`.
+    """
+    found_adapter = False
+    for module in model.modules():
+        if not isinstance(module, LoraLayer):
+            continue
+
+        found_adapter = True
+        scaling = module.scaling
+        for key, val in scaling.items():
+            if isinstance(val, float):
+                # no need to deal with dtype as scalars are coerced
+                scaling[key] = torch.tensor(val, device=module.weight.device)
+            elif not isinstance(val, torch.Tensor):
+                raise TypeError(
+                    "Something went wrong while trying to convert the scalings, expected to find values of type float "
+                    f"but found {type(val)} instead."
+                )
+    return found_adapter
+
+
+def _get_padded_linear(lora_module: torch.nn.Module, target_rank: int, is_lora_A: bool) -> torch.nn.Linear:
+    """
+    Get a new Linear layer for LoRA with padded weights according to the target rank.
+
+    Args:
+        lora_module (nn.Module):
+            The LoRA sub-module (e.g. module.lora_A[adapter_name]).
+        target_rank (int):
+            The desired rank to pad to.
+        is_lora_A (bool):
+            True if this is the LoRA A matrix, False if LoRA B.
+
+    Returns:
+        nn.Linear:
+            A newly created and padded Linear layer. If the rank already fit, the original layer is returned.
+    """
+    weight = lora_module.weight
+    # For LoRA A, the "rank dimension" is weight.size(0) (out_features).
+    # For LoRA B, it is weight.size(1) (in_features).
+    original_rank = weight.size(0) if is_lora_A else weight.size(1)
+
+    # If no padding needed
+    if original_rank == target_rank:
+        return lora_module
+
+    if original_rank > target_rank:
+        raise ValueError(
+            f"Trying to pad the adapter to the target rank {target_rank}, but the original rank is larger "
+            f"({original_rank}). This is not possible."
+        )
+
+    out_features, in_features = weight.shape
+
+    # lora_A and lora_B are always nn.Linear
+    if is_lora_A:
+        # LoRA A affects out_features
+        padded = torch.zeros(target_rank, in_features, device=weight.device, dtype=weight.dtype)
+        padded[:original_rank, :] = weight
+        new_layer = torch.nn.Linear(in_features, target_rank, bias=lora_module.bias is not None)
+    else:
+        # LoRA B affects in_features
+        padded = torch.zeros(out_features, target_rank, device=weight.device, dtype=weight.dtype)
+        padded[:, :original_rank] = weight
+        new_layer = torch.nn.Linear(target_rank, out_features, bias=lora_module.bias is not None)
+    new_layer.weight.requires_grad_(lora_module.weight.requires_grad)
+
+    # Sanity check
+    if new_layer.weight.shape != padded.shape:
+        raise ValueError(
+            "Something went wrong when trying to pad the LoRA Linear weights, the new shape should be "
+            f"{padded.shape} but {new_layer.weight.shape} was found. Please open an issue on PEFT "
+            "(https://github.com/huggingface/peft/issues) and report this error."
+        )
+    if (lora_module.bias is not None) and (new_layer.bias.shape != lora_module.bias.shape):
+        raise ValueError(
+            "Something went wrong when trying to pad the LoRA Linear bias, the new shape should be "
+            f"{lora_module.bias.shape} but {new_layer.bias.shape} was found. Please open an issue on PEFT "
+            "(https://github.com/huggingface/peft/issues) and report this error."
+        )
+
+    new_layer.weight.data = padded
+    # Copy bias if present
+    if lora_module.bias is not None:
+        new_layer.bias.data = lora_module.bias.data
+
+    return new_layer
+
+
+def _get_padded_conv2d(lora_module: torch.nn.Module, target_rank: int, is_lora_A: bool) -> torch.nn.Conv2d:
+    """
+    Get a new Conv2d layer for LoRA with padded weights according to the target rank.
+
+    Args:
+        lora_module (nn.Module):
+            The LoRA sub-module (e.g. module.lora_A[adapter_name]).
+        target_rank (int):
+            The desired rank to pad to.
+        is_lora_A (bool):
+            True if this is the LoRA A matrix, False if LoRA B.
+
+    Returns:
+        nn.Conv2d:
+            A newly created and padded Conv2d layer. If the rank already fit, the original layer is returned.
+    """
+    weight = lora_module.weight
+    # For Conv2d: [out_channels, in_channels, kernel_height, kernel_width]
+    out_channels, in_channels, kh, kw = weight.shape
+    original_rank = out_channels if is_lora_A else in_channels
+
+    if original_rank == target_rank:
+        return lora_module
+
+    if original_rank > target_rank:
+        raise ValueError(
+            f"Trying to pad the adapter to the target rank {target_rank}, but the original rank is larger "
+            f"({original_rank}). This is not possible."
+        )
+
+    # lora_A and lora_B are always nn.Conv2d
+    if is_lora_A:
+        # LoRA A affects out_channels
+        padded = torch.zeros(target_rank, in_channels, kh, kw, device=weight.device, dtype=weight.dtype)
+        padded[:out_channels, :, :, :] = weight
+        new_layer = torch.nn.Conv2d(
+            in_channels,
+            target_rank,
+            kernel_size=lora_module.kernel_size,
+            stride=lora_module.stride,
+            padding=lora_module.padding,
+            bias=lora_module.bias is not None,
+            groups=lora_module.groups,
+        )
+    else:
+        # LoRA B affects in_channels
+        padded = torch.zeros(out_channels, target_rank, kh, kw, device=weight.device, dtype=weight.dtype)
+        padded[:, :in_channels, :, :] = weight
+        new_layer = torch.nn.Conv2d(
+            target_rank,
+            out_channels,
+            kernel_size=lora_module.kernel_size,
+            stride=lora_module.stride,
+            padding=lora_module.padding,
+            bias=lora_module.bias is not None,
+            groups=lora_module.groups,
+        )
+    new_layer.weight.requires_grad_(lora_module.weight.requires_grad)
+
+    # Sanity check
+    if new_layer.weight.shape != padded.shape:
+        raise ValueError(
+            "Something went wrong when trying to pad the LoRA  weights, the new shape should be "
+            f"{padded.shape} but {new_layer.weight.shape} was found. Please open an issue on PEFT "
+            "(https://github.com/huggingface/peft/issues) and report this error."
+        )
+    if (lora_module.bias is not None) and (new_layer.bias.shape != lora_module.bias.shape):
+        raise ValueError(
+            "Something went wrong when trying to pad the LoRA Conv2d bias, the new shape should be "
+            f"{lora_module.bias.shape} but {new_layer.bias.shape} was found. Please open an issue on PEFT "
+            "(https://github.com/huggingface/peft/issues) and report this error."
+        )
+
+    new_layer.weight.data = padded
+    # Copy bias if present
+    if lora_module.bias is not None:
+        new_layer.bias.data = lora_module.bias.data
+
+    return new_layer
+
+
+def _pad_lora_weights(model: torch.nn.Module, target_rank: int) -> bool:
+    """
+    Pad LoRA weights in a model to a target rank while preserving the original behavior.
+
+    Args:
+      model (nn.Module): The model containing LoRA modules (with lora_A and lora_B).
+      target_rank (int): The target rank to pad to.
+
+    Returns:
+        bool:
+            Returns `True` if an appropriate adapter was found, else `False`.
+    """
+    found_adapter = False
+
+    for module in model.modules():
+        # Decide which pad function to call based on module type
+        if isinstance(module, Linear):
+            pad_fn = _get_padded_linear
+        elif isinstance(module, Conv2d):
+            pad_fn = _get_padded_conv2d
+        else:
+            # Skip any other module types
+            continue
+
+        # Pad LoRA A
+        for adapter_name, lora_A_module in module.lora_A.items():
+            new_layer = pad_fn(lora_A_module, target_rank=target_rank, is_lora_A=True)
+            module.lora_A[adapter_name] = new_layer
+
+        # Pad LoRA B
+        for adapter_name, lora_B_module in module.lora_B.items():
+            new_layer = pad_fn(lora_B_module, target_rank=target_rank, is_lora_A=False)
+            module.lora_B[adapter_name] = new_layer
+
+        found_adapter = True
+    return found_adapter
+
+
+def prepare_model_for_compiled_hotswap(
+    model: torch.nn.Module,
+    *,
+    target_rank: Optional[int] = None,
+    config: Optional[LoraConfig | dict[str, LoraConfig]] = None,
+    check_compiled: Literal["error", "warn", "ignore"] = "error",
+) -> None:
+    """
+    Helper function that prepares the model so that it can later be compiled and then used with hot-swapping.
+
+    It is necessary to call this function on the model for hot-swapping to work if both of these are true:
+
+    - the different LoRA adapters have different ranks and/or different alpha values (i.e. scalings)
+    - you plan to torch.compile the model and want to avoid re-compilation
+
+    It is important to call this function *after* the first LoRA adapter has been loaded (i.e. the one that will be
+    swapped out) but *before* the model is compiled.
+
+    Even with this function, hot-swapping LoRA adapters that target different layers is still not supported.
+
+    Note: This function modifies the model in-place. If you want to restore the model to its initial state, you will
+    have to reload it.
+
+    Args:
+        model (`nn.Module`):
+            The model with the loaded adapter, before compilation.
+        target_rank (`int`, *optional*):
+            The target rank to pad the LoRA weights to. Should be the maximum rank among all LoRA adapters that will be
+            hot-swapped. If not specified, the target ranks will not be changed.
+        config (`LoraConfig` or `dict[str, LoraConfig]`, *optional*):
+            Optionally pass the `LoraConfig`s of the LoRA adapters. If passed, the rank in the configs will be updated
+            to `target_rank`.
+        check_compiled (`str`, *optional*, defaults to `"error"`):
+            How to handle the case when the model is already compiled, which should generally be avoided. The options
+            are:
+              - "error" (default): raise an error
+              - "warn": issue a warning
+              - "ignore": do nothing
+
+    Raises:
+        ValueError
+            If the model is already compiled or if no adapter layer was found, raise an error.
+
+    Example:
+
+        ```py
+        base_model = ...
+        model = PeftModel.from_pretrained(base_model, path_adapter_0)
+        # Prepare the model to allow hotswapping even if ranks/scalings of 2nd adapter differ.
+        # You can skip this step if all ranks and scalings are identical.
+        prepare_model_for_compiled_hotswap(model, target_rank=highest_lora_rank)
+        model = torch.compile(model)
+        # do inference with adapter 0
+        # replace the "default" lora adapter with the new one
+        hotswap_adapter(model, path_adapter_1, adapter_name="default", torch_device=device)
+        # do inference with adapter 1
+        ```
+
+    """
+    is_compiled = hasattr(model, "_orig_mod") or getattr(model, "_compiled_call_impl", False)
+    if is_compiled:
+        if check_compiled == "error":
+            raise ValueError("Call prepare_model_for_compiled_hotswap *before* compiling the model")
+        elif check_compiled == "warn":
+            warnings.warn(
+                "prepare_model_for_compiled_hotswap was called with a model that is already compiled. This will likely "
+                "result in re-compilation, hurting performance. Call the function before compiling the model."
+            )
+        elif check_compiled != "ignore":
+            raise ValueError(
+                f"check_compiles should be one of 'error', 'warn', or 'ignore', got '{check_compiled}' instead."
+            )
+
+    conversion_found_adapter = _convert_scalings_to_tensor(model)
+    if target_rank is not None:
+        padding_found_adapter = _pad_lora_weights(model, target_rank=target_rank)
+    else:
+        padding_found_adapter = False
+
+    if not (conversion_found_adapter or padding_found_adapter):
+        raise ValueError(
+            "No adapter layers found on the model, make sure call `prepare_model_for_compiled_hotswap` after loading "
+            "the first adapter and before loading the second adapter."
+        )
+
+    if not config:
+        return
+    if target_rank is None:
+        return
+
+    if not isinstance(config, dict):
+        # config can be either a PeftConfig, or a dict of PeftConfigs like PeftModel.peft_config
+        config = {"dummy": config}
+
+    for lora_config in config.values():
+        lora_config.r = target_rank
+        if lora_config.rank_pattern:
+            for key in lora_config.rank_pattern:
+                lora_config.rank_pattern[key] = target_rank
+
+
+def hotswap_adapter_from_state_dict(
+    model: torch.nn.Module,
+    state_dict: dict[str, torch.Tensor],
+    adapter_name: str,
+    config: LoraConfig,
+    parameter_prefix: str = "lora_",
+):
+    """
+    Swap out the adapter weights from the model with the weights from state_dict.
+
+    As of now, only LoRA is supported.
+
+    This is a low-level function that assumes that the adapters have been checked for compatibility and that the
+    state_dict has been correctly mapped to work with PEFT. For a high level function that performs this work for you,
+    use `hotswap_adapter` instead.
+
+    Args:
+        model (`nn.Module`):
+            The model with the loaded adapter.
+        state_dict (`dict[str, torch.Tensor]`):
+            The state dict of the new adapter, which needs to be compatible (targeting same modules etc.).
+        adapter_name (`str`):
+            The name of the adapter that should be hot-swapped, e.g. `"default"`. The name will remain the same after
+            swapping.
+        config (`LoraConfig`):
+            The config of the LoRA adapter. This is used to determine the scaling and rank of the adapter.
+        parameter_prefix (`str`, *optional*, defaults to `"lora_"`)
+            The prefix used to identify the adapter's keys in the state dict. For LoRA, this would be `"lora_"` (the
+            default).
+
+    Raises:
+        RuntimeError
+            If the old and the new adapter are not compatible, a RuntimeError is raised.
+
+    """
+    # Ensure that all the keys of the new adapter correspond exactly to the keys of the old adapter, otherwise
+    # hot-swapping is not possible
+
+    # _orig_mod is for torch.compile(model)
+    is_compiled_wrapper = hasattr(model, "_orig_mod")
+    # TODO: there is probably a more precise way to identify the adapter keys
+    missing_keys = {k for k in model.state_dict() if (parameter_prefix in k) and (adapter_name in k)}
+    unexpected_keys = []
+
+    # first: dry run, not swapping anything
+    for key, new_val in state_dict.items():
+        try:
+            old_val = attrgetter(key)(model)
+        except AttributeError:
+            unexpected_keys.append(key)
+            continue
+
+        if is_compiled_wrapper:
+            missing_keys.remove("_orig_mod." + key)
+        else:
+            missing_keys.remove(key)
+
+    # Right now, we don't deal with unexpected keys, i.e. if the adapter being swapped in targeting new layers. We could
+    # probably add LoRA to these layers ad hoc, but that would not work with compiled models.
+    if unexpected_keys:
+        msg = f"Hot swapping the adapter did not succeed, unexpected keys found: {', '.join(unexpected_keys)}."
+        raise RuntimeError(msg)
+
+    # If the adapter that is being swapped in is missing some keys, this is fine. We just need to ensure that those LoRA
+    # weights from the previous adapter are set to 0 so that they don't influence the output. We don't need to worry
+    # about ranks are alphas.
+    for key in missing_keys:
+        # in case it's a compiled model
+        key = key.removeprefix("_orig_mod.")
+        # get LoRA parent module name by removing the 'lora_*.<adapter-name>.weight' part
+        module_name = ".".join(key.split(".")[:-3])
+        module = model.get_submodule(module_name)
+        old_val = attrgetter(key)(model)
+        old_val.data.fill_(0.0)
+
+    # actual swapping
+    for key, new_val in state_dict.items():
+        # get LoRA parent module name by removing the 'lora_*.<adapter-name>.weight' part
+        module_name = ".".join(key.split(".")[:-3])
+        module = model.get_submodule(module_name)
+
+        # swap alpha/scaling
+        r_key = get_pattern_key(config.rank_pattern.keys(), key)
+        alpha_key = get_pattern_key(config.alpha_pattern.keys(), key)
+        rank = config.rank_pattern.get(r_key, config.r)
+        alpha = config.alpha_pattern.get(alpha_key, config.lora_alpha)
+        if config.use_rslora:
+            scaling = alpha / math.sqrt(rank)
+        else:
+            scaling = alpha / rank
+        _update_scaling(module, adapter_name=adapter_name, scaling=scaling)
+
+        # swap actual weights
+        # no need to account for potential _orig_mod in key here, as torch handles that
+        old_val = attrgetter(key)(model)
+        new_val = new_val.to(old_val.data.device)
+
+        # 3 options:
+        # - shapes_match: the new adapter has the same rank as the current tensor (possibly because
+        #   prepare_model_for_compiled_hotswap padded the current tensor to match).
+        # - new_is_smaller: the new adapter has a smaller rank than the current tensor. This happens either
+        #   when the old adapter had a larger rank, or when the current tensor was padded to a larger
+        #   target_rank.
+        # - new_is_larger: the new adapter has a larger rank than the current tensor. The parameter shape
+        #   must change, which is only safe when no padded-shape invariant applies (i.e. the model was
+        #   not padded via prepare_model_for_compiled_hotswap). swap_tensors is the only option here.
+        shapes_match = old_val.shape == new_val.shape
+        new_is_smaller = (not shapes_match) and all(o >= n for o, n in zip(old_val.shape, new_val.shape))
+        new_is_larger = (not shapes_match) and not new_is_smaller
+
+        if shapes_match:
+            old_val.data.copy_(new_val.data)
+        elif new_is_smaller:
+            if old_val.dim() not in (2, 4):
+                raise NotImplementedError(
+                    f"Trying to hotswap an adapter whose weight has {old_val.dim()} dimensions, but only Conv2d and "
+                    "Linear are supported"
+                )
+
+            # Linear or Conv2d: the check for dim 0 or 1 works for both of these layer types
+            if old_val.shape[0] > new_val.shape[0]:
+                old_val.data.fill_(0)
+                old_val.data[: new_val.shape[0]].copy_(new_val.data)
+            elif old_val.shape[1] > new_val.shape[1]:
+                old_val.data.fill_(0)
+                old_val.data[:, : new_val.shape[1]].copy_(new_val.data)
+            else:
+                raise ValueError(
+                    f"Incompatible shapes found for LoRA weights {key}: {old_val.shape} vs {new_val.shape}. Please "
+                    "ensure that all ranks are padded to the largest rank among all LoRA adapters by using "
+                    "peft.utils.hotswap.prepare_model_for_compiled_hotswap."
+                )
+        elif new_is_larger:
+            try:
+                torch.utils.swap_tensors(old_val, new_val)
+            except RuntimeError:
+                # Fallback if swap_tensors is not permitted (e.g. tensor has weakrefs). This still
+                # rebinds storage and will break inductor if the model is compiled, but growing the
+                # rank of a compiled-and-padded model is already unsupported; the caller should have
+                # used prepare_model_for_compiled_hotswap with a sufficient target_rank.
+                old_val.data = new_val.data
+        else:
+            # should be unreachable
+            raise ValueError(
+                "Something went wrong during hotswapping, please open an issue on PEFT: "
+                "https://github.com/huggingface/peft/issues"
+            )
+
+
+def check_hotswap_configs_compatible(config0: PeftConfig, config1: PeftConfig) -> None:
+    """
+    Check if two configs are compatible for hot-swapping.
+
+    Only LoRA parameters are checked for now.
+
+    To hot-swap two adapters, their configs must be compatible. Otherwise, the results could be false. E.g. if they use
+    different alpha values, after hot-swapping, the alphas from the first adapter would still be used with the weights
+    from the 2nd adapter, which would result in incorrect behavior. There is probably a way to swap these values as
+    well, but that's not implemented yet, and we need to be careful not to trigger re-compilation if the model is
+    compiled (so no modification of the dict).
+
+    """
+
+    if config0.peft_type != config1.peft_type:
+        msg = f"Incompatible PEFT types found: {config0.peft_type.value} and {config1.peft_type.value}"
+        raise ValueError(msg)
+
+    if config0.peft_type not in CONFIG_KEYS_TO_CHECK:
+        msg = (
+            f"Hotswapping only supports {', '.join(CONFIG_KEYS_TO_CHECK.keys())} but "
+            f"{config0.peft_type.value} was passed."
+        )
+        raise ValueError(msg)
+    config_keys_to_check = CONFIG_KEYS_TO_CHECK[config0.peft_type]
+
+    # TODO: This is a very rough check only for LoRA at the moment. Also, there might be some options that don't
+    # necessarily require an error.
+    config0 = config0.to_dict()
+    config1 = config1.to_dict()
+    sentinel = object()
+    for key in config_keys_to_check:
+        val0 = config0.get(key, sentinel)
+        val1 = config1.get(key, sentinel)
+        if val0 != val1:
+            raise ValueError(f"Configs are incompatible: for {key}, {val0} != {val1}")
+
+
+def hotswap_adapter(model, model_name_or_path, adapter_name, torch_device=None, **kwargs):
+    """Substitute old adapter data with new adapter data, keeping the rest the same.
+
+    As of now, only LoRA is supported.
+
+    This function is useful when you want to replace the loaded adapter with a new adapter. The adapter name will
+    remain the same, but the weights and other parameters will be swapped out.
+
+    If the adapters are incomptabile, e.g. targeting different layers or having different alpha values, an error will
+    be raised.
+
+    Example:
+
+    ```py
+    >>> import torch
+    >>> from transformers import AutoModelForCausalLM
+    >>> from peft import PeftModel
+    >>> from peft.utils.hotswap import hotswap_adapter
+
+    >>> model_id = ...
+    >>> inputs = ...
+    >>> device = ...
+    >>> model = AutoModelForCausalLM.from_pretrained(model_id).to(device)
+
+    >>> # load lora 0
+    >>> model = PeftModel.from_pretrained(model, "path-adapter-0")
+    >>> model = torch.compile(model)  # optionally compile the model
+    >>> with torch.inference_mode():
+    ...     output_adapter_0 = model(inputs)
+
+    >>> # replace the "default" lora adapter with the new one
+    >>> hotswap_adapter(model, "path-adapter-1", adapter_name="default", torch_device=device)
+    >>> with torch.inference_mode():
+    ...     output_adapter_1 = model(inputs).logits
+    ```
+
+    Args:
+        model ([`~PeftModel`]):
+            The PEFT model with the loaded adapter.
+        model_name_or_path (`str`):
+            The name or path of the model to load the new adapter from.
+        adapter_name (`str`):
+            The name of the adapter to swap, e.g. `"default"`. The name will stay the same after swapping.
+        torch_device: (`str`, *optional*, defaults to None):
+            The device to load the new adapter onto.
+        **kwargs (`optional`):
+            Additional keyword arguments used for loading the config and weights.
+
+    """
+    if torch_device is None:
+        torch_device = infer_device()
+
+    ############################
+    # LOAD CONFIG AND VALIDATE #
+    ############################
+    hf_kwargs = {
+        "subfolder": kwargs.get("subfolder", None),
+        "revision": kwargs.get("revision", None),
+        "cache_dir": kwargs.get("cache_dir", None),
+        "token": kwargs.get("token", None),
+    }
+    if use_auth_token := kwargs.get("use_auth_token", None):
+        hf_kwargs["use_auth_token"] = use_auth_token
+    config_cls = PEFT_TYPE_TO_CONFIG_MAPPING[PeftConfig._get_peft_type(model_name_or_path, **hf_kwargs)]
+    config = config_cls.from_pretrained(model_name_or_path, **kwargs)
+    # config keys that could affect the model output besides what is determined by the state_dict
+    check_hotswap_configs_compatible(model.active_peft_config, config)
+
+    state_dict = load_peft_weights(model_name_or_path, device=torch_device, **kwargs)
+
+    ###########################
+    # LOAD & REMAP STATE_DICT #
+    ###########################
+
+    parameter_prefix = PEFT_TYPE_TO_PREFIX_MAPPING[config.peft_type]
+    peft_model_state_dict = _insert_adapter_name_into_state_dict(
+        state_dict, adapter_name=adapter_name, parameter_prefix=parameter_prefix
+    )
+
+    hotswap_adapter_from_state_dict(
+        model=model,
+        state_dict=peft_model_state_dict,
+        adapter_name=adapter_name,
+        parameter_prefix=parameter_prefix,
+        config=config,
+    )
diff --git a/src/peft/utils/incremental_pca.py b/src/peft/utils/incremental_pca.py
new file mode 100644
index 0000000..de4a7c0
--- /dev/null
+++ b/src/peft/utils/incremental_pca.py
@@ -0,0 +1,338 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+from typing import Optional
+
+import torch
+
+
+class IncrementalPCA:
+    """
+    An implementation of Incremental Principal Components Analysis (IPCA) that leverages PyTorch for GPU acceleration.
+    Adapted from https://github.com/scikit-learn/scikit-learn/blob/main/sklearn/decomposition/_incremental_pca.py
+
+    This class provides methods to fit the model on data incrementally in batches, and to transform new data based on
+    the principal components learned during the fitting process.
+
+    Args:
+        n_components (int, optional): Number of components to keep. If `None`, it's set to the minimum of the
+            number of samples and features. Defaults to None.
+        copy (bool): If False, input data will be overwritten. Defaults to True.
+        batch_size (int, optional): The number of samples to use for each batch. Only needed if self.fit is called.
+            If `None`, it's inferred from the data and set to `5 * n_features`. Defaults to None.
+        svd_driver (str, optional): name of the cuSOLVER method to be used for torch.linalg.svd. This keyword
+            argument only works on CUDA inputs. Available options are: None, gesvd, gesvdj, and gesvda. Defaults to
+            None.
+        lowrank (bool, optional): Whether to use torch.svd_lowrank instead of torch.linalg.svd which can be faster.
+            Defaults to False.
+        lowrank_q (int, optional): For an adequate approximation of n_components, this parameter defaults to
+            n_components * 2.
+        lowrank_niter (int, optional): Number of subspace iterations to conduct for torch.svd_lowrank.
+            Defaults to 4.
+        lowrank_seed (int, optional): Seed for making results of torch.svd_lowrank reproducible.
+    """
+
+    def __init__(
+        self,
+        n_components: Optional[int] = None,
+        copy: Optional[bool] = True,
+        batch_size: Optional[int] = None,
+        svd_driver: Optional[str] = None,
+        lowrank: bool = False,
+        lowrank_q: Optional[int] = None,
+        lowrank_niter: int = 4,
+        lowrank_seed: Optional[int] = None,
+    ):
+        self.n_components = n_components
+        self.copy = copy
+        self.batch_size = batch_size
+        self.svd_driver = svd_driver
+        self.lowrank = lowrank
+        self.lowrank_q = lowrank_q
+        self.lowrank_niter = lowrank_niter
+        self.lowrank_seed = lowrank_seed
+
+        self.n_features_ = None
+
+        if self.lowrank:
+            self._validate_lowrank_params()
+
+    def _validate_lowrank_params(self):
+        if self.lowrank_q is None:
+            if self.n_components is None:
+                raise ValueError("n_components must be specified when using lowrank mode with lowrank_q=None.")
+            self.lowrank_q = self.n_components * 2
+        elif self.lowrank_q < self.n_components:
+            raise ValueError("lowrank_q must be greater than or equal to n_components.")
+
+    def _svd_fn_full(self, X):
+        return torch.linalg.svd(X, full_matrices=False, driver=self.svd_driver)
+
+    def _svd_fn_lowrank(self, X):
+        seed_enabled = self.lowrank_seed is not None
+        with torch.random.fork_rng(enabled=seed_enabled):
+            if seed_enabled:
+                torch.manual_seed(self.lowrank_seed)
+            U, S, V = torch.svd_lowrank(X, q=self.lowrank_q, niter=self.lowrank_niter)
+            return U, S, V.mH
+
+    def _validate_data(self, X) -> torch.Tensor:
+        """
+        Validates and converts the input data `X` to the appropriate tensor format.
+
+        Args:
+            X (torch.Tensor): Input data.
+
+        Returns:
+            torch.Tensor: Converted to appropriate format.
+        """
+        valid_dtypes = [torch.float32, torch.float64]
+
+        if not isinstance(X, torch.Tensor):
+            X = torch.tensor(X, dtype=torch.float32)
+        elif self.copy:
+            X = X.clone()
+
+        n_samples, n_features = X.shape
+        if self.n_components is None:
+            pass
+        elif self.n_components > n_features:
+            raise ValueError(
+                f"n_components={self.n_components} invalid for n_features={n_features}, "
+                "need more rows than columns for IncrementalPCA processing."
+            )
+        elif self.n_components > n_samples:
+            raise ValueError(
+                f"n_components={self.n_components} must be less or equal to the batch number of samples {n_samples}"
+            )
+
+        if X.dtype not in valid_dtypes:
+            X = X.to(torch.float32)
+
+        return X
+
+    @staticmethod
+    def _incremental_mean_and_var(
+        X, last_mean, last_variance, last_sample_count
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        """
+        Computes the incremental mean and variance for the data `X`.
+
+        Args:
+            X (torch.Tensor): The batch input data tensor with shape (n_samples, n_features).
+            last_mean (torch.Tensor): The previous mean tensor with shape (n_features,).
+            last_variance (torch.Tensor): The previous variance tensor with shape (n_features,).
+            last_sample_count (torch.Tensor): The count tensor of samples processed before the current batch.
+
+        Returns:
+            Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: Updated mean, variance tensors, and total sample count.
+        """
+        if X.shape[0] == 0:
+            return last_mean, last_variance, last_sample_count
+
+        if last_sample_count > 0:
+            if last_mean is None:
+                raise ValueError("last_mean should not be None if last_sample_count > 0.")
+            if last_variance is None:
+                raise ValueError("last_variance should not be None if last_sample_count > 0.")
+
+        new_sample_count = torch.tensor([X.shape[0]], device=X.device)
+        updated_sample_count = last_sample_count + new_sample_count
+
+        if last_mean is None:
+            last_sum = torch.zeros(X.shape[1], dtype=torch.float64, device=X.device)
+        else:
+            last_sum = last_mean * last_sample_count
+
+        new_sum = X.sum(dim=0, dtype=torch.float64)
+
+        updated_mean = (last_sum + new_sum) / updated_sample_count
+
+        T = new_sum / new_sample_count
+        temp = X - T
+        correction = temp.sum(dim=0, dtype=torch.float64).square()
+        temp.square_()
+        new_unnormalized_variance = temp.sum(dim=0, dtype=torch.float64)
+        new_unnormalized_variance -= correction / new_sample_count
+        if last_variance is None:
+            updated_variance = new_unnormalized_variance / updated_sample_count
+        else:
+            last_unnormalized_variance = last_variance * last_sample_count
+            last_over_new_count = last_sample_count.double() / new_sample_count
+            updated_unnormalized_variance = (
+                last_unnormalized_variance
+                + new_unnormalized_variance
+                + last_over_new_count / updated_sample_count * (last_sum / last_over_new_count - new_sum).square()
+            )
+            updated_variance = updated_unnormalized_variance / updated_sample_count
+
+        return updated_mean, updated_variance, updated_sample_count
+
+    @staticmethod
+    def _svd_flip(u, v, u_based_decision=True) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Adjusts the signs of the singular vectors from the SVD decomposition for deterministic output.
+
+        This method ensures that the output remains consistent across different runs.
+
+        Args:
+            u (torch.Tensor): Left singular vectors tensor.
+            v (torch.Tensor): Right singular vectors tensor.
+            u_based_decision (bool, optional): If True, uses the left singular vectors to determine the sign flipping.
+                Defaults to True.
+
+        Returns:
+            Tuple[torch.Tensor, torch.Tensor]: Adjusted left and right singular vectors tensors.
+        """
+        if u_based_decision:
+            max_abs_cols = torch.argmax(torch.abs(u), dim=0)
+            signs = torch.sign(u[max_abs_cols, range(u.shape[1])])
+        else:
+            max_abs_rows = torch.argmax(torch.abs(v), dim=1)
+            signs = torch.sign(v[range(v.shape[0]), max_abs_rows])
+        u *= signs[: u.shape[1]].view(1, -1)
+        v *= signs.view(-1, 1)
+        return u, v
+
+    def fit(self, X, check_input=True):
+        """
+        Fits the model with data `X` using minibatches of size `batch_size`.
+
+        Args:
+            X (torch.Tensor): The input data tensor with shape (n_samples, n_features).
+            check_input (bool, optional): If True, validates the input. Defaults to True.
+
+        Returns:
+            IncrementalPCA: The fitted IPCA model.
+        """
+        if check_input:
+            X = self._validate_data(X)
+        n_samples, n_features = X.shape
+        if self.batch_size is None:
+            self.batch_size = 5 * n_features
+
+        for batch in self.gen_batches(n_samples, self.batch_size, min_batch_size=self.n_components or 0):
+            self.partial_fit(X[batch], check_input=False)
+
+        return self
+
+    def partial_fit(self, X, check_input=True):
+        """
+        Incrementally fits the model with batch data `X`.
+
+        Args:
+            X (torch.Tensor): The batch input data tensor with shape (n_samples, n_features).
+            check_input (bool, optional): If True, validates the input. Defaults to True.
+
+        Returns:
+            IncrementalPCA: The updated IPCA model after processing the batch.
+        """
+        first_pass = not hasattr(self, "components_")
+
+        if check_input:
+            X = self._validate_data(X)
+        n_samples, n_features = X.shape
+
+        # Initialize attributes to avoid errors during the first call to partial_fit
+        if first_pass:
+            self.mean_ = None  # Will be initialized properly in _incremental_mean_and_var based on data dimensions
+            self.var_ = None  # Will be initialized properly in _incremental_mean_and_var based on data dimensions
+            self.n_samples_seen_ = torch.tensor([0], device=X.device)
+            self.n_features_ = n_features
+            if not self.n_components:
+                self.n_components = min(n_samples, n_features)
+
+        if n_features != self.n_features_:
+            raise ValueError(
+                "Number of features of the new batch does not match the number of features of the first batch."
+            )
+
+        col_mean, col_var, n_total_samples = self._incremental_mean_and_var(
+            X, self.mean_, self.var_, self.n_samples_seen_
+        )
+
+        if first_pass:
+            X -= col_mean
+        else:
+            col_batch_mean = torch.mean(X, dim=0)
+            X -= col_batch_mean
+            mean_correction_factor = torch.sqrt((self.n_samples_seen_.double() / n_total_samples) * n_samples)
+            mean_correction = mean_correction_factor * (self.mean_ - col_batch_mean)
+            X = torch.vstack(
+                (
+                    self.singular_values_.view((-1, 1)) * self.components_,
+                    X,
+                    mean_correction,
+                )
+            )
+
+        if self.lowrank:
+            U, S, Vt = self._svd_fn_lowrank(X)
+        else:
+            U, S, Vt = self._svd_fn_full(X)
+        U, Vt = self._svd_flip(U, Vt, u_based_decision=False)
+        explained_variance = S**2 / (n_total_samples - 1)
+        explained_variance_ratio = S**2 / torch.sum(col_var * n_total_samples)
+
+        self.n_samples_seen_ = n_total_samples
+        self.components_ = Vt[: self.n_components]
+        self.singular_values_ = S[: self.n_components]
+        self.mean_ = col_mean
+        self.var_ = col_var
+        self.explained_variance_ = explained_variance[: self.n_components]
+        self.explained_variance_ratio_ = explained_variance_ratio[: self.n_components]
+        if self.n_components not in (n_samples, n_features):
+            self.noise_variance_ = explained_variance[self.n_components :].mean()
+        else:
+            self.noise_variance_ = torch.tensor(0.0, device=X.device)
+        return self
+
+    def transform(self, X) -> torch.Tensor:
+        """
+        Applies dimensionality reduction to `X`.
+
+        The input data `X` is projected on the first principal components previously extracted from a training set.
+
+        Args:
+            X (torch.Tensor): New data tensor with shape (n_samples, n_features) to be transformed.
+
+        Returns:
+            torch.Tensor: Transformed data tensor with shape (n_samples, n_components).
+        """
+        X = X - self.mean_
+        return torch.mm(X.double(), self.components_.T).to(X.dtype)
+
+    @staticmethod
+    def gen_batches(n: int, batch_size: int, min_batch_size: int = 0):
+        """Generator to create slices containing `batch_size` elements from 0 to `n`.
+
+        The last slice may contain less than `batch_size` elements, when `batch_size` does not divide `n`.
+
+        Args:
+            n (int): Size of the sequence.
+            batch_size (int): Number of elements in each batch.
+            min_batch_size (int, optional): Minimum number of elements in each batch. Defaults to 0.
+
+        Yields:
+            slice: A slice of `batch_size` elements.
+        """
+        start = 0
+        for _ in range(int(n // batch_size)):
+            end = start + batch_size
+            if end + min_batch_size > n:
+                continue
+            yield slice(start, end)
+            start = end
+        if start < n:
+            yield slice(start, n)
diff --git a/src/peft/utils/integrations.py b/src/peft/utils/integrations.py
new file mode 100644
index 0000000..968f9d4
--- /dev/null
+++ b/src/peft/utils/integrations.py
@@ -0,0 +1,295 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+import functools
+from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import Literal, Optional
+
+import packaging.version
+import torch
+import transformers
+from torch import nn
+
+
+@dataclass
+class TpInfo:
+    tp_plan: dict[str, str]
+    device_mesh: torch.distributed.DeviceMesh
+    tp_size: int
+
+
+def check_deepspeed_zero3_enabled() -> bool:
+    if packaging.version.parse(transformers.__version__) >= packaging.version.parse("4.33.0"):
+        from transformers.integrations import is_deepspeed_zero3_enabled
+    else:
+        from transformers.deepspeed import is_deepspeed_zero3_enabled
+    return is_deepspeed_zero3_enabled()
+
+
+@contextmanager
+def gather_params_ctx(param, modifier_rank: Optional[int] = 0, fwd_module: torch.nn.Module = None):
+    """Call DeepSpeed GatheredParameters context manager if DeepSpeed is enabled, otherwise do nothing."""
+
+    if not check_deepspeed_zero3_enabled():
+        yield
+        return
+
+    import deepspeed
+
+    with deepspeed.zero.GatheredParameters(param, modifier_rank=modifier_rank, fwd_module=fwd_module):
+        yield
+    return
+
+
+def dequantize_module_weight(module: torch.nn.Module) -> torch.nn.Parameter:
+    """
+    Helper function to dequantize a quantized weight.
+
+    This function should be extended if more quantization schemes are added to the library.
+
+    If the weight is not quantized, it will be returned as is.
+    """
+    if hasattr(module, "W_q"):  # For handling HQQ quantized weight
+        weight = module.dequantize()
+        return weight
+    elif type(module.weight).__module__.startswith("torchao."):
+        # check for torchao without requiring any torchao imports
+        weight = module.weight.dequantize()
+        return weight
+
+    weight = module.weight
+    if not isinstance(weight, torch.nn.Parameter):
+        if isinstance(weight, torch.Tensor):
+            # this is an FSDP-specific edge case
+            return weight  # type: ignore
+        raise TypeError(f"Input weight should be of type nn.Parameter, got {type(weight)} instead")
+
+    cls_name = weight.__class__.__name__
+    if cls_name not in ("Params4bit", "Int8Params"):
+        return weight
+
+    quant_state = getattr(module, "state", None)
+    device = weight.device
+    is_cpu = device.type == torch.device("cpu").type
+    weight = dequantize_bnb_weight(weight, state=quant_state)  # no-op if not bnb
+    if is_cpu:
+        # dequantize_bnb_weight for 8bit moves the device in-place, thus we need to move it back to CPU if necessary
+        module.weight = module.weight.to(device)
+    return weight
+
+
+def dequantize_bnb_weight(weight: torch.nn.Parameter, state=None):
+    """Helper function to dequantize 4bit or 8bit bnb weights."""
+    import bitsandbytes as bnb
+
+    device = weight.device
+
+    cls_name = weight.__class__.__name__
+    if cls_name == "Params4bit":
+        dequantized = bnb.functional.dequantize_4bit(weight.data, weight.quant_state)
+        return dequantized
+
+    # 8bit case
+    if state is None:
+        raise ValueError(
+            "No `state` was passed for bnb 8bit quantized weights. Please open an issue on the PEFT repository and "
+            "report the error: https://github.com/huggingface/peft/issues"
+        )
+
+    if state.SCB is None:
+        state.SCB = weight.SCB
+
+    if hasattr(bnb.functional, "int8_vectorwise_dequant"):
+        # Use bitsandbytes API if available (requires v0.45.0+)
+        dequantized = bnb.functional.int8_vectorwise_dequant(weight.data, state.SCB.to(weight.data.device))
+    else:
+        # Multiply by (scale/127) to dequantize.
+        dequantized = weight.data * state.SCB.to(weight.data.device).view(-1, 1) * 7.874015718698502e-3
+
+    return dequantized
+
+
+def get_bnb_param_type(param: torch.nn.Parameter) -> Literal[False, "4bit", "8bit"]:
+    """Returns '4bit' or '8bit' if bitsandbytes parameter, else False"""
+    if param.__class__.__name__ == "Params4bit":
+        return "4bit"
+    if param.__class__.__name__ == "Int8Params":
+        return "8bit"
+    return False
+
+
+# adapted from:
+# https://github.com/huggingface/transformers/blob/eab6c491d439e83d5e31c660df6f7e36592eb0a2/src/transformers/generation/utils.py#L1617-L1643
+def get_layer_device_map(model):
+    """
+    Derive the device map for the layers of the model.
+    """
+    main_device = next(d for d in model.hf_device_map.values() if d not in ["cpu", "disk"])
+
+    execution_device_map = {
+        name: main_device if device in ["cpu", "disk"] else device for name, device in model.hf_device_map.items()
+    }
+
+    if execution_device_map is None:
+        return None
+
+    if len(execution_device_map) == 1 and "" in execution_device_map:
+        return {idx: execution_device_map[""] for idx in range(model.config.num_hidden_layers)}
+
+    layer_device_map = {}
+    for layer in execution_device_map:
+        for idx in range(model.config.num_hidden_layers):
+            if f".{idx}." in f"{layer}.":
+                layer_device_map[idx] = execution_device_map[layer]
+                break
+    for idx in range(model.config.num_hidden_layers):
+        if idx not in layer_device_map:
+            raise RuntimeError(f"layer {idx} has not been mapped to a device.")
+    return layer_device_map
+
+
+# adapted from:
+# https://github.com/huggingface/transformers/blob/eab6c491d439e83d5e31c660df6f7e36592eb0a2/src/transformers/cache_utils.py#L1159-L1179
+def map_cache_to_layer_device_map(model, cache) -> None:
+    """
+    Ensure that the key and value cache of the model are on the same device as their corresponding layers.
+    """
+    if not (isinstance(cache, transformers.Cache) and hasattr(model, "hf_device_map")):
+        return
+
+    if isinstance(cache, transformers.EncoderDecoderCache):
+        map_cache_to_layer_device_map(model, cache.self_attention_cache)
+        return
+
+    layer_device_map = get_layer_device_map(model)
+    for idx in range(model.config.num_hidden_layers):
+        layer_device = layer_device_map[idx]
+        if hasattr(cache, "layers"):
+            # new transformers uses cache.layers (>v4.55)
+            layer = cache.layers[idx]
+            layer.keys = layer.keys.to(layer_device)
+            layer.values = layer.values.to(layer_device)
+        else:
+            # old transformers uses cache.{key,value}_cache (<=v4.55)
+            # TODO: remove if we drop support for transformers <= 4.55
+            cache.key_cache[idx] = cache.key_cache[idx].to(layer_device)
+            cache.value_cache[idx] = cache.value_cache[idx].to(layer_device)
+
+
+##################################
+# START: ADAPTED FROM ACCELERATE #
+##################################
+#
+# Modified to support explicitly skipping layer initialization for faster switching between layer states
+# (necessary for supporting `nn.MultiHeadAttention` adapters)
+
+
+@contextmanager
+def init_empty_weights(include_buffers: bool | None = None):
+    # adapted from accelerate.big_modeling.py
+    with _init_on_device(torch.device("meta"), include_buffers=include_buffers) as f:
+        yield f
+
+
+@contextmanager
+def _init_on_device(device: torch.device, include_buffers: bool | None = None):
+    # adapted from accelerate.big_modeling.py
+    old_register_parameter = nn.Module.register_parameter
+    old_register_buffer = nn.Module.register_buffer
+
+    def register_empty_parameter(module, name, param):
+        # This works because torch first initializes the parameters with torch.empty, thus not assigning any new memory.
+        # Then the parameter is moved to meta device before reset_parameters() is called, which then operates on the
+        # meta device, making any subsequent calls to initialization methods no-ops.
+        old_register_parameter(module, name, param)
+        if (param is not None) and (getattr(_init_on_device, "_skip", False) is not True):
+            param_cls = type(module._parameters[name])
+            kwargs = module._parameters[name].__dict__
+            kwargs["requires_grad"] = param.requires_grad
+            module._parameters[name] = param_cls(module._parameters[name].to(device), **kwargs)
+
+    def register_empty_buffer(module, name, buffer, persistent=True):
+        old_register_buffer(module, name, buffer, persistent=persistent)
+        if buffer is not None:
+            module._buffers[name] = module._buffers[name].to(device)
+
+    # Patch tensor creation
+    if include_buffers:
+        tensor_constructors_to_patch = {
+            torch_function_name: getattr(torch, torch_function_name)
+            for torch_function_name in ["empty", "zeros", "ones", "full"]
+        }
+    else:
+        tensor_constructors_to_patch = {}
+
+    def patch_tensor_constructor(fn):
+        def wrapper(*args, **kwargs):
+            kwargs["device"] = device
+            return fn(*args, **kwargs)
+
+        return wrapper
+
+    try:
+        nn.Module.register_parameter = register_empty_parameter
+        if include_buffers:
+            nn.Module.register_buffer = register_empty_buffer
+        for torch_function_name in tensor_constructors_to_patch.keys():
+            setattr(torch, torch_function_name, patch_tensor_constructor(getattr(torch, torch_function_name)))
+        yield
+    finally:
+        nn.Module.register_parameter = old_register_parameter
+        if include_buffers:
+            nn.Module.register_buffer = old_register_buffer
+        for torch_function_name, old_torch_function in tensor_constructors_to_patch.items():
+            setattr(torch, torch_function_name, old_torch_function)
+
+
+@contextmanager
+def _skip_init_on_device():
+    # context manager to skip the _init_on_device context manager
+    old_val = getattr(_init_on_device, "_skip", False)
+    try:
+        _init_on_device._skip = True
+        yield
+    finally:
+        _init_on_device._skip = old_val
+
+
+def skip_init_on_device(func):
+    """
+    Ignore the init_on_device context manager when calling the decorated function.
+
+    This is a narrow use decorator that allows us to avoid initializing on meta device even when we're inside the
+    init_empty_weights context.
+
+    """
+
+    # The need for this functionality arose when working on MultiheadAttention, where we have to call _restore_weights
+    # repeatedly as parameters are overwritten and need to be re-registered. When using low_cpu_mem_usage=True, as
+    # register_parameter is patched inside of the init_empty_weights context, this would result in those parameters
+    # suddenly being moved to meta device. Using this decorator allows us to avoid this.
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        with _skip_init_on_device():
+            return func(*args, **kwargs)
+
+    return wrapper
+
+
+#######
+# END #
+#######
diff --git a/src/peft/utils/loftq_utils.py b/src/peft/utils/loftq_utils.py
new file mode 100644
index 0000000..ea69b73
--- /dev/null
+++ b/src/peft/utils/loftq_utils.py
@@ -0,0 +1,427 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+# Reference code: https://github.com/yxli2123/LoftQ/blob/main/utils.py
+# Reference paper: https://huggingface.co/papers/2310.08659
+
+from __future__ import annotations
+
+import os
+import warnings
+from collections.abc import Callable
+from typing import Optional, Union
+
+import torch
+from accelerate.utils.memory import clear_device_cache
+from huggingface_hub import snapshot_download
+from huggingface_hub.errors import HFValidationError, LocalEntryNotFoundError
+from safetensors import SafetensorError, safe_open
+from transformers.utils import cached_file
+from transformers.utils.hub import get_checkpoint_shard_files
+
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available, is_xpu_available
+
+
+# TODO for PEFT 0.20, remove NFQuantizer in favor of bnb 4bit quantization.
+class NFQuantizer:
+    def __init__(self, num_bits=2, device="cuda", method="normal", block_size=64, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        warnings.warn(
+            "NFQuantizer is deprecated and is going to be removed in PEFT 0.20. Consider using "
+            "alternative quantization libraries for nf{2,4,8} quantization.",
+            category=DeprecationWarning,
+        )
+
+        self.num_bits = num_bits
+        self.device = device
+        self.method = method
+        self.block_size = block_size
+        if self.method == "normal":
+            self.norm_lookup_table = self.create_normal_map(num_bits=self.num_bits)
+            self.norm_lookup_table = self.norm_lookup_table.to(device)
+        elif self.method == "uniform":
+            self.norm_lookup_table = self.create_uniform_map(num_bits=self.num_bits)
+            self.norm_lookup_table = self.norm_lookup_table.to(device)
+        else:
+            raise NotImplementedError("Other quantization methods not supported yet.")
+
+    @staticmethod
+    def create_uniform_map(symmetric=False, num_bits=4):
+        if symmetric:
+            # print("symmetric uniform quantization")
+            negative = torch.linspace(-1, 0, 2 ** (num_bits - 1))
+            positive = torch.linspace(0, 1, 2 ** (num_bits - 1))
+            table = torch.cat([negative, positive[1:]])
+        else:
+            # print("asymmetric uniform quantization")
+            table = torch.linspace(-1, 1, 2**num_bits)
+        return table
+
+    @staticmethod
+    def create_normal_map(offset=0.9677083, symmetric=False, num_bits=2):
+        try:
+            from scipy.stats import norm
+        except ImportError:
+            raise ImportError("The required package 'scipy' is not installed. Please install it to continue.")
+
+        variations = 2**num_bits
+        if symmetric:
+            v = norm.ppf(torch.linspace(1 - offset, offset, variations + 1)).tolist()
+            values = []
+            for index in range(len(v) - 1):
+                values.append(0.5 * v[index] + 0.5 * v[index + 1])
+            v = values
+        else:
+            # one more positive value, this is an asymmetric type
+            v1 = norm.ppf(torch.linspace(offset, 0.5, variations // 2 + 1)[:-1]).tolist()
+            v2 = [0]
+            v3 = (-norm.ppf(torch.linspace(offset, 0.5, variations // 2)[:-1])).tolist()
+            v = v1 + v2 + v3
+
+        values = torch.Tensor(v)
+        values = values.sort().values
+        values /= values.max()
+        return values
+
+    def quantize_tensor(self, weight):
+        max_abs = torch.abs(weight).max()
+        weight_normed = weight / max_abs
+
+        weight_normed_expanded = weight_normed.unsqueeze(-1)
+
+        # Reshape L to have the same number of dimensions as X_expanded
+        L_reshaped = torch.tensor(self.norm_lookup_table).reshape(1, -1)
+
+        # Calculate the absolute difference between X_expanded and L_reshaped
+        abs_diff = torch.abs(weight_normed_expanded - L_reshaped)
+
+        # Find the index of the minimum absolute difference for each element
+        qweight = torch.argmin(abs_diff, dim=-1)
+        return qweight, max_abs
+
+    def dequantize_tensor(self, qweight, max_abs):
+        qweight_flatten = qweight.flatten()
+
+        weight_normed = self.norm_lookup_table[qweight_flatten]
+        weight = weight_normed * max_abs
+
+        weight = weight.reshape(qweight.shape)
+
+        return weight
+
+    def quantize_block(self, weight):
+        if len(weight.shape) != 2:
+            raise ValueError(f"Only support 2D matrix, but your input has {len(weight.shape)} dimensions.")
+        if weight.shape[0] * weight.shape[1] % self.block_size != 0:
+            raise ValueError(
+                f"Weight with shape ({weight.shape[0]} x {weight.shape[1]}) "
+                f"is not dividable by block size {self.block_size}."
+            )
+
+        M, N = weight.shape
+        device = weight.device
+
+        # Quantization
+        weight_flatten = weight.flatten()  # (M*N, )
+        weight_block = weight_flatten.reshape(-1, self.block_size)  # (L, B), L = M * N / B
+        if self.method == "normal":
+            weight_max = weight_block.abs().max(dim=-1)[0]  # (L, 1)
+        elif self.method == "uniform":
+            weight_max = weight_block.mean(dim=-1) + 2.5 * weight_block.std(dim=-1)
+        else:
+            raise NotImplementedError("Method not supported yet.")
+        weight_max = weight_max.unsqueeze(-1)
+        weight_divabs = weight_block / weight_max  # (L, B)
+        weight_divabs = weight_divabs.unsqueeze(-1)  # (L, B, 1)
+        L_reshaped = self.norm_lookup_table.reshape(1, -1)  # (1, 2**K)
+
+        abs_diff = torch.abs(weight_divabs - L_reshaped)  # (L, B, 2**K)
+        qweight = torch.argmin(abs_diff, dim=-1)  # (L, B)
+
+        # Pack multiple k-bit into uint8
+        qweight = qweight.reshape(-1, 8 // self.num_bits)
+        qweight_pack = torch.zeros((M * N // 8 * self.num_bits, 1), dtype=torch.uint8, device=device)
+
+        # data format example:
+        # [1, 0, 3, 2] or [01, 00, 11, 10]  -> [10110001], LIFO
+        for i in range(8 // self.num_bits):
+            qweight[:, i] = qweight[:, i] << i * self.num_bits
+            qweight_pack[:, 0] |= qweight[:, i]
+
+        return qweight_pack, weight_max, weight.shape
+
+    def dequantize_block(self, qweight, weight_max, weight_shape):
+        # unpack weight
+        device = qweight.device
+        weight = torch.zeros((qweight.shape[0], 8 // self.num_bits), dtype=torch.float32, device=device)
+        for i in range(8 // self.num_bits):
+            lookup_table_idx = qweight.to(torch.long) % 2**self.num_bits  # get the most right 2 bits
+            lookup_table_idx = lookup_table_idx.to(torch.long)
+            weight[:, i] = self.norm_lookup_table[lookup_table_idx].squeeze()
+            qweight = qweight >> self.num_bits  # right shift 2 bits of the original data
+
+        weight_block = weight.reshape(-1, self.block_size)
+        weight = weight_block * weight_max
+        weight = weight.reshape(weight_shape)
+
+        return weight
+
+
+def _low_rank_decomposition(weight, reduced_rank=32):
+    """
+    :param weight: The matrix to decompose, of shape (H, W) :param reduced_rank: the final rank :return:
+    """
+    matrix_dimension = len(weight.size())
+    if matrix_dimension != 2:
+        raise ValueError(f"Only support 2D matrix, but your input has {matrix_dimension} dimensions.")
+
+    # Use SVD to decompose a matrix, default full_matrices is False to save parameters
+    U, S, Vh = torch.linalg.svd(weight, full_matrices=False)
+
+    L = U @ (torch.sqrt(torch.diag(S)[:, 0:reduced_rank]))
+    R = torch.sqrt(torch.diag(S)[0:reduced_rank, :]) @ Vh
+
+    return {"L": L, "R": R, "U": U, "S": S, "Vh": Vh, "reduced_rank": reduced_rank}
+
+
+@torch.no_grad()
+def loftq_init(weight: Union[torch.Tensor, torch.nn.Parameter], num_bits: int, reduced_rank: int, num_iter=1):
+    if is_bnb_available():
+        import bitsandbytes as bnb
+    else:
+        raise ValueError("bitsandbytes is not available, please install it to use LoftQ.")
+
+    if num_bits not in [4, 8]:
+        raise ValueError("Only nf4 and int8 quantization is supported")
+    if num_iter <= 0:
+        raise ValueError("Number of iterations must be greater than 0")
+
+    device = weight.device
+    dtype = weight.dtype
+    if not is_bnb_4bit_available() and num_bits == 4:
+        # TODO for PEFT 0.20 remove NFQuantizer invocation and throw an exception
+        quantizer = NFQuantizer(num_bits=num_bits, device=device, method="normal", block_size=64)
+        compute_device = device
+        warnings.warn(
+            "Native support for nf4 is being deprecated with PEFT 0.20. Please install a recent version of bitsandbytes.",
+            category=DeprecationWarning,
+        )
+    else:
+        compute_device = "xpu" if is_xpu_available() else "cuda"
+
+    weight = weight.to(device=compute_device, dtype=torch.float32)
+    res = weight.clone()
+    for i in range(num_iter):
+        clear_device_cache()
+        # Quantization
+        if num_bits == 4 and is_bnb_4bit_available():
+            qweight = bnb.nn.Params4bit(
+                res.to("cpu"), requires_grad=False, compress_statistics=False, quant_type="nf4"
+            ).to(compute_device)
+            dequantized_weight = bnb.functional.dequantize_4bit(qweight.data, qweight.quant_state)
+        elif num_bits == 4:
+            quantized_weight, max_abs, shape = quantizer.quantize_block(res)
+            dequantized_weight = quantizer.dequantize_block(quantized_weight, max_abs, shape)
+        elif num_bits == 8:
+            qweight = bnb.nn.Int8Params(res.to("cpu"), requires_grad=False).to(device)
+            dequantized_weight = bnb.functional.int8_vectorwise_dequant(qweight.data, qweight.SCB).to(compute_device)
+
+        res = weight - dequantized_weight
+
+        # Decompose the residual by SVD
+        output = _low_rank_decomposition(res, reduced_rank=reduced_rank)
+        L, R, reduced_rank = output["L"], output["R"], output["reduced_rank"]
+
+        # don't prepare the residual if we're at the end
+        if i + 1 == num_iter:
+            break
+
+        res = weight - torch.mm(L, R)
+
+    lora_A, lora_B = R, L
+
+    return dequantized_weight.to(device=device, dtype=dtype), lora_A, lora_B
+
+
+@torch.no_grad()
+def _loftq_init_new(qweight, weight, num_bits: int, reduced_rank: int):
+    import bitsandbytes as bnb
+
+    if num_bits != 4:
+        raise ValueError("Only 4 bit quantization supported at the moment.")
+    if not is_bnb_4bit_available():
+        raise ValueError("bitsandbytes 4bit quantization is not available.")
+
+    compute_device = "xpu" if is_xpu_available() else "cuda"
+    dequantized_weight = bnb.functional.dequantize_4bit(qweight.data, qweight.quant_state)
+
+    weight = weight.to(device=compute_device, dtype=torch.float32)
+    residual = weight - dequantized_weight
+    clear_device_cache()
+    # Decompose the residualidual by SVD
+    output = _low_rank_decomposition(residual, reduced_rank=reduced_rank)
+    L, R, reduced_rank = output["L"], output["R"], output["reduced_rank"]
+    return R, L
+
+
+class _SafetensorLoader:
+    """
+    Simple utility class that loads tensors with safetensors from a single file or sharded files.
+
+    Takes care of file name normalization etc.
+
+    """
+
+    def __init__(self, peft_model, model_path):
+        if model_path is None:
+            try:
+                model_path = snapshot_download(peft_model.base_model.config._name_or_path, local_files_only=True)
+            except (AttributeError, HFValidationError) as exc:
+                raise ValueError(
+                    "The provided model does not appear to be a transformers model or is a local model. In this case, "
+                    "you must pass the model_path argument that points to the safetensors file."
+                ) from exc
+            except LocalEntryNotFoundError as exc:
+                raise ValueError(
+                    "The model.safetensors file must be present on disk, but it could not be found."
+                ) from exc
+
+        suffix = "model.safetensors"
+        if not model_path.endswith(suffix):
+            model_path = os.path.join(model_path, suffix)
+
+        self.model_path = model_path
+        self.base_model_prefix = getattr(peft_model.get_base_model(), "base_model_prefix", None)
+        self.prefix = "base_model.model."
+        self.is_sharded = False
+        self.weight_map = None
+
+        if not os.path.exists(model_path):
+            # check if the file is sharded
+            par_dir = model_path.rpartition(os.path.sep)[0]
+            try:
+                resolved_archive_file, sharded_metadata = get_checkpoint_shard_files(
+                    par_dir, cached_file(par_dir, "model.safetensors.index.json")
+                )
+            except OSError as exc:
+                raise FileNotFoundError(
+                    f"Could not find file for {model_path}, ensure that there is a (sharded) safetensors file of the model."
+                ) from exc
+
+            self.is_sharded = True
+            # maps from 'model-X-of-Y.safetensors' to full file path
+            file_map = {k.rpartition(os.path.sep)[-1]: k for k in resolved_archive_file}
+            self.weight_map = {k: file_map[v] for k, v in sharded_metadata["weight_map"].items()}
+
+    def get_tensor(self, name):
+        if not self.is_sharded:
+            file_path = self.model_path
+        else:
+            file_path = self.weight_map[name]
+
+        with safe_open(file_path, framework="pt", device="cpu") as f:
+            try:
+                tensor = f.get_tensor(name)
+            except SafetensorError as exc:
+                # no matching key found, we probably need to remove the base model prefix
+                if self.base_model_prefix:
+                    # remove 1 extra character for "."
+                    name = name[len(self.base_model_prefix) + 1 :]
+                    tensor = f.get_tensor(name)
+                else:
+                    raise
+        return tensor
+
+
+@torch.no_grad()
+def replace_lora_weights_loftq(
+    peft_model,
+    model_path: Optional[str] = None,
+    adapter_name: str = "default",
+    callback: Optional[Callable[[torch.nn.Module, str], bool]] = None,
+):
+    """
+    Replace the LoRA weights of a model quantized with bitsandbytes, using the LoftQ technique.
+
+    The replacement is done on the fly by loading in the non-quantized weights from a locally stored safetensors model
+    file and initializing the LoRA weights such that the quantization error between the original and quantized weights
+    is minimized.
+
+    As lazy loading is not possible with pickle, normal PyTorch checkpoint files cannot be supported.
+
+    Depending on the model size, calling this function may take some time to finish.
+
+    Args:
+        peft_model (`PeftModel`):
+            The model to replace the weights of. Must be a quantized PEFT model with LoRA layers.
+        model_path (`Optional[str]`):
+            The path to the model safetensors file. If the model is a Hugging Face model, this will be inferred from
+            the model's config. Otherwise, it must be provided.
+        adapter_name (`str`):
+            The name of the adapter to replace the weights of. The default adapter name is "default".
+        callback (`Optional[Callable[[PeftModel, str], bool]]`):
+            A callback function that will be called after each module is replaced. The callback function should take
+            the model and the name of the current module as input and return a boolean indicating whether the
+            replacement should be kept. If the callback returns False, the replacement will be rolled back. This can be
+            very useful to confirm that the LoftQ initialization actually decreases the quantization error of the
+            model. As an example, this callback could generate logits for given input and compare it with the logits
+            from the original, non-quanitzed model with the same input, and only return `True` if there is an
+            improvement. As this is a greedy optimization, it's possible that calling this function multiple times
+            yields incremental improvements.
+    """
+    if not is_bnb_4bit_available():
+        raise ValueError("bitsandbytes must be installed and the model must be quantized in 4bits.")
+
+    from peft.tuners.lora import Linear4bit
+
+    # model_path = _check_model_path_loftq(model_path, peft_model)
+    prefix = "base_model.model."
+    any_match = False
+    safetensor_loader = _SafetensorLoader(peft_model, model_path)
+
+    # if too slow, consider adding tqdm as an option
+    for name, module in peft_model.named_modules():
+        if not isinstance(module, Linear4bit):
+            continue
+
+        if not name.startswith(prefix):
+            raise TypeError("The passed model does not appear to be a valid PeftModel")
+
+        any_match = True
+        name = name[len(prefix) :]
+        tensor = safetensor_loader.get_tensor(name + ".weight")
+
+        reduced_rank = module.r[adapter_name]
+        lora_A, lora_B = _loftq_init_new(module.weight, tensor, num_bits=4, reduced_rank=reduced_rank)
+        if not callback:
+            module.lora_A[adapter_name].weight.data = lora_A
+            module.lora_B[adapter_name].weight.data = lora_B
+            continue
+
+        lora_A_before = module.lora_A[adapter_name].weight.data
+        lora_B_before = module.lora_B[adapter_name].weight.data
+
+        module.lora_A[adapter_name].weight.data = lora_A
+        module.lora_B[adapter_name].weight.data = lora_B
+        should_replace = callback(peft_model, name)
+        if not should_replace:
+            # roll back
+            module.lora_A[adapter_name].weight.data = lora_A_before
+            module.lora_B[adapter_name].weight.data = lora_B_before
+
+        del lora_A_before, lora_B_before
+
+    if not any_match:
+        raise ValueError("No bnb LoRA module found on the model")
diff --git a/src/peft/utils/merge_utils.py b/src/peft/utils/merge_utils.py
new file mode 100644
index 0000000..528d968
--- /dev/null
+++ b/src/peft/utils/merge_utils.py
@@ -0,0 +1,268 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+import warnings
+from typing import Literal
+
+import torch
+
+
+def reshape_weight_task_tensors(task_tensors: torch.Tensor, weights: torch.Tensor) -> torch.Tensor:
+    """
+    Reshapes `weights` to match the shape of `task_tensors` by unsqueezing in the remaining dimensions.
+
+    Args:
+        task_tensors (`torch.Tensor`): The tensors that will be used to reshape `weights`.
+        weights (`torch.Tensor`): The tensor to be reshaped.
+
+    Returns:
+        `torch.Tensor`: The reshaped tensor.
+    """
+    new_shape = weights.shape + (1,) * (task_tensors.dim() - weights.dim())
+    weights = weights.view(new_shape)
+    return weights
+
+
+def magnitude_based_pruning(tensor: torch.Tensor, density: float) -> torch.Tensor:
+    """
+    Prune the smallest values of the task tensors and retain the top-k values based on the specified fraction
+    `density`.
+
+    Args:
+        tensor (`torch.Tensor`):The tensor to prune.
+        density (`float`):The fraction of values to preserve. Should be in [0,1].
+
+    Returns:
+        `torch.Tensor`: The tensor with the pruned weights.
+    """
+    mask = torch.zeros_like(tensor).reshape(-1)
+    k = int(density * tensor.numel())
+    top_k = torch.topk(tensor.abs().reshape(-1), k=k, largest=True)
+    mask[top_k[1]] = 1
+    return tensor * mask.reshape(tensor.shape)
+
+
+def random_pruning(tensor: torch.Tensor, density: float, rescale: bool) -> torch.Tensor:
+    """
+    Prune random values based on the specified fraction `density`.
+
+    Args:
+        tensor (`torch.Tensor`):The tensor to prune.
+        density (`float`):The fraction of values to preserve. Should be in [0,1].
+        rescale (`bool`):Whether to rescale the result to preserve the expected value of the original tensor.
+
+    Returns:
+        `torch.Tensor`: The pruned tensor.
+    """
+    mask = torch.bernoulli(torch.full_like(input=tensor, fill_value=density))
+    pruned_tensor = tensor * mask
+    if rescale:
+        pruned_tensor = pruned_tensor / density
+    return pruned_tensor
+
+
+def prune(
+    tensor: torch.Tensor, density: float, method: Literal["magnitude", "random"], rescale: bool = False
+) -> torch.Tensor:
+    """
+    Prune the values of task tensors based on the `method`.
+
+    Args:
+        tensor (`torch.Tensor`):The tensor to prune.
+        density (`float`):The fraction of values to preserve. Should be in [0,1].
+        method (`str`):The method to use to prune. Should be one of ["magnitude", "random"].
+        rescale (`bool`):Whether to rescale the result to preserve the expected value of the original tensor.
+
+    Returns:
+        `torch.Tensor`: The pruned tensor.
+    """
+    if density >= 1:
+        warnings.warn(f"The density {density} is greater than or equal to 1, no pruning will be performed.")
+        return tensor
+    elif density < 0:
+        raise ValueError(f"Density should be >= 0, got {density}")
+    if method == "magnitude":
+        return magnitude_based_pruning(tensor, density)
+    elif method == "random":
+        return random_pruning(tensor, density, rescale=rescale)
+    else:
+        raise ValueError(f"Unknown method {method}")
+
+
+def calculate_majority_sign_mask(
+    tensor: torch.Tensor, method: Literal["total", "frequency"] = "total"
+) -> torch.Tensor:
+    """
+    Get the mask of the majority sign across the task tensors. Task tensors are stacked on dimension 0.
+
+    Args:
+        tensor (`torch.Tensor`):The tensor to get the mask from.
+        method (`str`):The method to use to get the mask. Should be one of ["total", "frequency"].
+
+    Returns:
+        `torch.Tensor`: The majority sign mask.
+    """
+
+    sign = tensor.sign()
+    if method == "total":
+        sign_magnitude = tensor.sum(dim=0)
+    elif method == "frequency":
+        sign_magnitude = sign.sum(dim=0)
+    else:
+        raise RuntimeError(f'Unimplemented mask method "{method}"')
+    majority_sign = torch.where(sign_magnitude >= 0, 1, -1)
+    return sign == majority_sign
+
+
+def disjoint_merge(task_tensors: torch.Tensor, majority_sign_mask: torch.Tensor) -> torch.Tensor:
+    """
+    Merge the task tensors using disjoint merge.
+
+    Args:
+        task_tensors (`torch.Tensor`):The task tensors to merge.
+        majority_sign_mask (`torch.Tensor`):The mask of the majority sign across the task tensors.
+
+    Returns:
+        `torch.Tensor`: The merged tensor.
+    """
+    mixed_task_tensors = (task_tensors * majority_sign_mask).sum(dim=0)
+    num_params_preserved = majority_sign_mask.sum(dim=0)
+    return mixed_task_tensors / torch.clamp(num_params_preserved, min=1.0)
+
+
+def task_arithmetic(task_tensors: list[torch.Tensor], weights: torch.Tensor) -> torch.Tensor:
+    """
+    Merge the task tensors using `task arithmetic`.
+
+    Args:
+        task_tensors(`List[torch.Tensor]`):The task tensors to merge.
+        weights (`torch.Tensor`):The weights of the task tensors.
+
+    Returns:
+        `torch.Tensor`: The merged tensor.
+    """
+    task_tensors = torch.stack(task_tensors, dim=0)
+    # weighted task tensors
+    weights = reshape_weight_task_tensors(task_tensors, weights)
+    weighted_task_tensors = task_tensors * weights
+    mixed_task_tensors = weighted_task_tensors.sum(dim=0)
+    return mixed_task_tensors
+
+
+def magnitude_prune(task_tensors: list[torch.Tensor], weights: torch.Tensor, density: float) -> torch.Tensor:
+    """
+    Merge the task tensors using `task arithmetic`.
+
+    Args:
+        task_tensors(`List[torch.Tensor]`):The task tensors to merge.
+        weights (`torch.Tensor`):The weights of the task tensors.
+        density (`float`): The fraction of values to preserve. Should be in [0,1].
+
+    Returns:
+        `torch.Tensor`: The merged tensor.
+    """
+    # sparsify
+    task_tensors = [prune(tensor, density, method="magnitude") for tensor in task_tensors]
+    task_tensors = torch.stack(task_tensors, dim=0)
+    # weighted task tensors
+    weights = reshape_weight_task_tensors(task_tensors, weights)
+    weighted_task_tensors = task_tensors * weights
+    mixed_task_tensors = weighted_task_tensors.sum(dim=0)
+    return mixed_task_tensors
+
+
+def ties(
+    task_tensors: list[torch.Tensor],
+    weights: torch.Tensor,
+    density: float,
+    majority_sign_method: Literal["total", "frequency"] = "total",
+) -> torch.Tensor:
+    """
+    Merge the task tensors using `ties`.
+
+    Args:
+        task_tensors(`List[torch.Tensor]`):The task tensors to merge.
+        weights (`torch.Tensor`):The weights of the task tensors.
+        density (`float`):The fraction of values to preserve. Should be in [0,1].
+        majority_sign_method (`str`):
+            The method to use to get the majority sign mask. Should be one of ["total", "frequency"].
+
+    Returns:
+        `torch.Tensor`: The merged tensor.
+    """
+    # sparsify
+    task_tensors = [prune(tensor, density, method="magnitude") for tensor in task_tensors]
+    task_tensors = torch.stack(task_tensors, dim=0)
+    # Elect Sign
+    majority_sign_mask = calculate_majority_sign_mask(task_tensors, method=majority_sign_method)
+    # weighted task tensors
+    weights = reshape_weight_task_tensors(task_tensors, weights)
+    weighted_task_tensors = task_tensors * weights
+    # Disjoint Merge
+    mixed_task_tensors = disjoint_merge(weighted_task_tensors, majority_sign_mask)
+    return mixed_task_tensors
+
+
+def dare_linear(task_tensors: list[torch.Tensor], weights: torch.Tensor, density: float) -> torch.Tensor:
+    """
+    Merge the task tensors using `dare linear`.
+
+    Args:
+        task_tensors(`List[torch.Tensor]`):The task tensors to merge.
+        weights (`torch.Tensor`):The weights of the task tensors.
+        density (`float`):The fraction of values to preserve. Should be in [0,1].
+
+    Returns:
+        `torch.Tensor`: The merged tensor.
+    """
+    # sparsify
+    task_tensors = [prune(tensor, density, method="random", rescale=True) for tensor in task_tensors]
+    task_tensors = torch.stack(task_tensors, dim=0)
+    # weighted task tensors
+    weights = reshape_weight_task_tensors(task_tensors, weights)
+    weighted_task_tensors = task_tensors * weights
+    mixed_task_tensors = weighted_task_tensors.sum(dim=0)
+    return mixed_task_tensors
+
+
+def dare_ties(
+    task_tensors: list[torch.Tensor],
+    weights: torch.Tensor,
+    density: float,
+    majority_sign_method: Literal["total", "frequency"] = "total",
+) -> torch.Tensor:
+    """
+    Merge the task tensors using `dare ties`.
+
+    Args:
+        task_tensors(`List[torch.Tensor]`):The task tensors to merge.
+        weights (`torch.Tensor`):The weights of the task tensors.
+        density (`float`):The fraction of values to preserve. Should be in [0,1].
+        majority_sign_method (`str`):
+            The method to use to get the majority sign mask. Should be one of ["total", "frequency"].
+
+    Returns:
+        `torch.Tensor`: The merged tensor.
+    """
+    # sparsify
+    task_tensors = [prune(tensor, density, method="random", rescale=True) for tensor in task_tensors]
+    task_tensors = torch.stack(task_tensors, dim=0)
+    # Elect Sign
+    majority_sign_mask = calculate_majority_sign_mask(task_tensors, method=majority_sign_method)
+    # weighted task tensors
+    weights = reshape_weight_task_tensors(task_tensors, weights)
+    weighted_task_tensors = task_tensors * weights
+    # Disjoint Merge
+    mixed_task_tensors = disjoint_merge(weighted_task_tensors, majority_sign_mask)
+    return mixed_task_tensors
diff --git a/src/peft/utils/other.py b/src/peft/utils/other.py
new file mode 100644
index 0000000..7c6a6f1
--- /dev/null
+++ b/src/peft/utils/other.py
@@ -0,0 +1,1791 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import copy
+import functools
+import inspect
+import os
+import re
+import warnings
+from collections.abc import Sequence
+from contextlib import nullcontext
+from operator import attrgetter
+from typing import Any, Optional, Union
+
+import accelerate
+import torch
+import transformers
+from accelerate import FullyShardedDataParallelPlugin
+from accelerate.hooks import add_hook_to_module, remove_hook_from_module
+from accelerate.utils import is_npu_available, is_xpu_available
+from huggingface_hub import file_exists
+from huggingface_hub.errors import EntryNotFoundError, HFValidationError
+from packaging import version
+from safetensors.torch import storage_ptr, storage_size
+from transformers import PreTrainedModel
+
+from ..import_utils import is_gptqmodel_available, is_torch_tpu_available, is_transformers_ge_v5_1_0
+from .constants import (
+    CONFIG_NAME,
+    EMBEDDING_LAYER_NAMES,
+    INCLUDE_LINEAR_LAYERS_SHORTHAND,
+    SAFETENSORS_WEIGHTS_NAME,
+    TRANSFORMERS_MODELS_TO_ADALORA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_ADAMSS_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_BEFT_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_BOFT_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_C3A_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_DEFT_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_DELORA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_FOURIERFT_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_FROD_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_GLORA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_GRALORA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_HRA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_IA3_FEEDFORWARD_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_IA3_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_LILY_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_LNTUNING_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_LOHA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_LOKR_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_MISS_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_OFT_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_PEANUT_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_POLY_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_PREFIX_TUNING_POSTPROCESS_MAPPING,
+    TRANSFORMERS_MODELS_TO_PSOFT_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_PVERA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_RANDLORA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_ROAD_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_SHIRA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_TINYLORA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_UNILORA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_VBLORA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_VERA_TARGET_MODULES_MAPPING,
+    TRANSFORMERS_MODELS_TO_WAVEFT_TARGET_MODULES_MAPPING,
+    WEIGHTS_NAME,
+    bloom_model_postprocess_past_key_value,
+    starcoder_model_postprocess_past_key_value,
+)
+
+
+mlu_available = False
+if version.parse(accelerate.__version__) >= version.parse("0.29.0"):
+    from accelerate.utils import is_mlu_available
+
+    mlu_available = is_mlu_available()
+
+__all__ = [
+    "CONFIG_NAME",
+    "EMBEDDING_LAYER_NAMES",
+    "INCLUDE_LINEAR_LAYERS_SHORTHAND",
+    "SAFETENSORS_WEIGHTS_NAME",
+    "TRANSFORMERS_MODELS_TO_ADALORA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_ADAMSS_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_BEFT_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_BOFT_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_C3A_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_DEFT_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_DELORA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_FOURIERFT_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_FROD_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_GLORA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_GRALORA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_HRA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_IA3_FEEDFORWARD_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_IA3_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_LILY_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_LNTUNING_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_LOHA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_LOKR_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_MISS_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_OFT_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_PEANUT_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_POLY_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_PREFIX_TUNING_POSTPROCESS_MAPPING",
+    "TRANSFORMERS_MODELS_TO_PSOFT_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_PVERA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_RANDLORA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_ROAD_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_SHIRA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_TINYLORA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_UNILORA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_VBLORA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_VERA_TARGET_MODULES_MAPPING",
+    "TRANSFORMERS_MODELS_TO_WAVEFT_TARGET_MODULES_MAPPING",
+    "WEIGHTS_NAME",
+    "bloom_model_postprocess_past_key_value",
+    "starcoder_model_postprocess_past_key_value",
+]
+
+
+# Get current device name based on available devices
+def infer_device() -> str:
+    if torch.cuda.is_available():
+        return "cuda"
+    elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+        return "mps"
+    elif mlu_available:
+        return "mlu"
+    elif is_xpu_available():
+        return "xpu"
+    elif is_npu_available():
+        return "npu"
+    return "cpu"
+
+
+def prepare_model_for_kbit_training(
+    model, use_gradient_checkpointing=True, gradient_checkpointing_kwargs=None, auto_clear_cache=True
+):
+    r"""
+    Note this method only works for `transformers` models.
+
+    This method wraps the entire protocol for preparing a model before running a training. This includes:
+        1- Cast the layernorm in fp32 2- making output embedding layer require grads 3- Add the upcasting of the lm
+        head to fp32 4- Freezing the base model layers to ensure they are not updated during training
+
+
+    Args:
+        model (`transformers.PreTrainedModel`):
+            The loaded model from `transformers`
+        use_gradient_checkpointing (`bool`, *optional*, defaults to `True`):
+            If True, use gradient checkpointing to save memory at the expense of slower backward pass.
+        gradient_checkpointing_kwargs (`dict`, *optional*, defaults to `None`):
+            Keyword arguments to pass to the gradient checkpointing function, please refer to the documentation of
+            `torch.utils.checkpoint.checkpoint` for more details about the arguments that you can pass to that method.
+            Note this is only available in the latest transformers versions (> 4.34.1).
+        auto_clear_cache (`bool`, *optional*, defaults to `True`):
+            Whether to empty the accelerator cache after upcasting parameters to fp32. This releases memory held by the
+            caching allocator, which is especially helpful on devices that share host and accelerator memory. Set to
+            `False` to skip this step.
+    """
+    loaded_in_kbit = getattr(model, "is_loaded_in_8bit", False) or getattr(model, "is_loaded_in_4bit", False)
+    is_gptq_quantized = getattr(model, "quantization_method", None) == "gptq"
+    is_aqlm_quantized = getattr(model, "quantization_method", None) == "aqlm"
+    is_eetq_quantized = getattr(model, "quantization_method", None) == "eetq"
+    is_torchao_quantized = getattr(model, "quantization_method", None) == "torchao"
+    is_hqq_quantized = getattr(model, "quantization_method", None) == "hqq" or getattr(model, "hqq_quantized", False)
+
+    if gradient_checkpointing_kwargs is None:
+        gradient_checkpointing_kwargs = {}
+
+    for name, param in model.named_parameters():
+        # freeze base model's layers
+        param.requires_grad = False
+
+    if (
+        not is_gptq_quantized
+        and not is_aqlm_quantized
+        and not is_eetq_quantized
+        and not is_hqq_quantized
+        and not is_torchao_quantized
+    ):
+        # cast all non INT8 parameters to fp32
+        for param in model.parameters():
+            if (
+                (param.dtype == torch.float16) or (param.dtype == torch.bfloat16)
+            ) and param.__class__.__name__ != "Params4bit":
+                param.data = param.data.to(torch.float32)
+
+        # Release CUDA allocator cache after bulk fp16→fp32 casts to reduce
+        # reserved-but-unused memory to free up system memory in devices
+        # that share host and accelerator memory (issue #3265)
+        if auto_clear_cache:
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+
+            if is_xpu_available():
+                torch.xpu.empty_cache()
+
+    if (
+        loaded_in_kbit
+        or is_gptq_quantized
+        or is_aqlm_quantized
+        or is_eetq_quantized
+        or is_hqq_quantized
+        or is_torchao_quantized
+    ) and use_gradient_checkpointing:
+        # When having `use_reentrant=False` + gradient_checkpointing, there is no need for this hack
+        if "use_reentrant" not in gradient_checkpointing_kwargs or gradient_checkpointing_kwargs["use_reentrant"]:
+            # For backward compatibility
+            if hasattr(model, "enable_input_require_grads"):
+                model.enable_input_require_grads()
+            else:
+
+                def make_inputs_require_grad(module, input, output):
+                    output.requires_grad_(True)
+
+                model.get_input_embeddings().register_forward_hook(make_inputs_require_grad)
+
+        # To support older transformers versions, check if the model supports gradient_checkpointing_kwargs
+        _supports_gc_kwargs = "gradient_checkpointing_kwargs" in list(
+            inspect.signature(model.gradient_checkpointing_enable).parameters
+        )
+
+        if not _supports_gc_kwargs and len(gradient_checkpointing_kwargs) > 0:
+            warnings.warn(
+                "gradient_checkpointing_kwargs is not supported in this version of transformers. The passed kwargs will be ignored."
+                " if you want to use that feature, please upgrade to the latest version of transformers.",
+                FutureWarning,
+            )
+
+        gc_enable_kwargs = (
+            {} if not _supports_gc_kwargs else {"gradient_checkpointing_kwargs": gradient_checkpointing_kwargs}
+        )
+
+        # enable gradient checkpointing for memory efficiency
+        model.gradient_checkpointing_enable(**gc_enable_kwargs)
+    return model
+
+
+# copied from transformers.models.bart.modeling_bart
+def shift_tokens_right(input_ids: torch.Tensor, pad_token_id: int, decoder_start_token_id: int) -> torch.Tensor:
+    """
+    Shift input ids one token to the right.
+
+    Args:
+        input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`): input ids
+        pad_token_id (`int`): The id of the `padding` token.
+        decoder_start_token_id (`int`): The id of the `start` token.
+    """
+    shifted_input_ids = input_ids.new_zeros(input_ids.shape)
+    shifted_input_ids[:, 1:] = input_ids[:, :-1].clone()
+    shifted_input_ids[:, 0] = decoder_start_token_id
+
+    if pad_token_id is None:
+        raise ValueError("self.model.config.pad_token_id has to be defined.")
+    # replace possible -100 values in labels by `pad_token_id`
+    shifted_input_ids.masked_fill_(shifted_input_ids == -100, pad_token_id)
+
+    return shifted_input_ids
+
+
+def _set_layer_requires_grad(layer, requires_grad: bool) -> None:
+    """Set requires_grad on all leaf parameters of a layer.
+
+    This handles the FSDP case where params may be non-leaf tensors (wrapped in DTensors). Only leaf tensors can have
+    their requires_grad flag toggled, so non-leaf tensors are silently skipped
+
+    Args:
+        layer: A module, parameter or tensor
+        requires_grad: enable or disable gradients
+    """
+    if isinstance(layer, (torch.nn.Parameter, torch.Tensor)):
+        if layer.is_leaf:
+            layer.requires_grad_(requires_grad)
+    else:
+        for param in layer.parameters():
+            if param.is_leaf:
+                param.requires_grad_(requires_grad)
+
+
+class AuxiliaryTrainingWrapper(torch.nn.Module):
+    """Wrap a specific module so that it can be trained and saved in a way that is tangential to how
+    PEFT normally works, e.g. fully training a classification layer instead of using an adapter.
+
+    """
+
+    # All names of layers that may contain adapter (trainable) weights
+    adapter_layer_names: tuple[str, ...] = ()
+    # All names of other parameters that may contain adapter-related parameters
+    other_param_names: tuple[str, ...] = ()
+    # List all merged adapters
+    merged_adapters: list[str] = []
+
+    def __init__(self, module_to_save, adapter_name, **kwargs):
+        """Extra kwargs will be passed to `self.init_modules` and `self.update`."""
+        super().__init__()
+        self.original_module = module_to_save
+        self._active_adapter = [adapter_name]
+        self._disable_adapters = False
+        self._adapters = set()
+
+        self.init_modules(adapter_name, **kwargs)
+
+        self.update(adapter_name, **kwargs)
+        self.check_module()
+
+    def init_modules(self, adapter_name, **kwargs):
+        """A place to initialize PyTorch modules in `__init__` before the call to `self.update()`."""
+        raise NotImplementedError
+
+    def _get_available_adapters(self) -> set[str]:
+        """Return all adapter names that can be found on this module."""
+        raise NotImplementedError
+
+    def _error_message_name(self):
+        """Returns a user friendly identifier for error messages, e.g. for type compatibility error messages from
+        `check_module()` so that the user can backtrack where the error comes from. A generic "training wrapper" is
+        less helpful than "modules_to_save", for example.
+        """
+        return "training wrapper"
+
+    def check_module(self):
+        """Perform some sanity checks on the module to ensure that it works"""
+        # Try to anticipate some modules that users could try to target that would not work.
+        # Note: It's not possible to check hasattr(module, "forward"), since that returns True for ModuleDict and
+        # ModuleList, even though their forward methods cannot be called
+        forbidden_classes = (torch.nn.ModuleDict, torch.nn.ModuleList, torch.nn.ParameterDict, torch.nn.ParameterList)
+        if isinstance(self.original_module, forbidden_classes):
+            cls_name = self.original_module.__class__
+            raise TypeError(f"{self._error_message_name()} cannot be applied to modules of type {cls_name}")
+
+        # local import to avoid circular import
+        from peft.tuners.tuners_utils import BaseTunerLayer
+
+        if isinstance(self.original_module, BaseTunerLayer):
+            # e.g. applying a training wrapper to a lora layer makes no sense
+            cls_name = self.original_module.__class__
+            raise TypeError(f"{self._error_message_name()} cannot be applied to modules of type {cls_name}")
+
+    @property
+    def disable_adapters(self) -> bool:
+        # use a property to ensure that disable_adapters is not set directly, instead use the enable_adapters method
+        return self._disable_adapters
+
+    @property
+    def active_adapter(self) -> Union[list[str], str]:
+        # use a property to ensure that active_adapter is not set directly, instead use the set_adapter method
+        return self._active_adapter
+
+    @property
+    def active_adapters(self) -> list[str]:
+        if isinstance(self._active_adapter, str):
+            return [self._active_adapter]
+        return self._active_adapter
+
+    def _hasattr_wrapped(self, name, modules):
+        """Infrastructure to enable the implementing class to delegate attributes to other modules.
+        Returns True if the implementing class knows how to handle attribute `name`.
+
+        Gets passed `modules` which is PyTorch's internal list of assigned modules from `nn.Module`.
+        """
+        return False
+
+    def _getattr_wrapped(self, name, modules):
+        """If `_hasattr_wrapped` returns True for `name`, then this function should return the corresponding
+        value associated with `name`.
+        """
+        return
+
+    def __getattr__(self, name: str):
+        # Note: This whole method may seem overly complex at first but PyTorch messes with __getattr__ in a way that
+        # requires very careful handling to avoid infinite recursion.
+        try:
+            return super().__getattr__(name)
+        except AttributeError:
+            pass
+
+        if "_modules" not in self.__dict__:
+            raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}'")
+
+        # Could not find the attribute the PyTorch way. So let's check if it's an attribute on the
+        # original_module or the module further down (e.g., `modules_to_save[active_adapter]`).
+        modules = self.__dict__["_modules"]
+        if self.disable_adapters or (not self.active_adapters):
+            # no PEFT adapter is active, thus refer to original module
+            return getattr(self.original_module, name)
+        elif self._hasattr_wrapped(name, modules):
+            return self._getattr_wrapped(name, modules)
+
+        # For some reason, there is no module corresponding to the active adapter; this should normally not be
+        # reached and exists as a failsafe (otherwise, a KeyError would be raised)
+        raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}'")
+
+    def update(self, adapter_name, **kwargs):
+        """Called when this instance should be part of an adapter's training.
+        Adds the given adapter to the list of adapters that this instance is training along with.
+
+        Additional kwargs are expected to be the same kwargs that are also passed for initializing this class.
+        """
+        if adapter_name not in self._adapters:
+            self._adapters.add(adapter_name)
+
+    def _create_new_hook(self, old_hook):
+        r"""
+        Creates a new hook based on the old hook. Use it only if you know what you are doing !
+        """
+        old_hook_cls = getattr(accelerate.hooks, old_hook.__class__.__name__)
+        old_hook_attr = old_hook.__dict__
+        filtered_old_hook_attr = {}
+        old_hook_init_signature = inspect.signature(old_hook_cls.__init__)
+        for k in old_hook_attr.keys():
+            if k in old_hook_init_signature.parameters:
+                filtered_old_hook_attr[k] = old_hook_attr[k]
+        new_hook = old_hook_cls(**filtered_old_hook_attr)
+        return new_hook
+
+    def _check_forward_args(self, *args, **kwargs):
+        """Check if the arguments are compatible with the configs and state of the model"""
+        adapter_names = kwargs.get("adapter_names", None)
+        if adapter_names is None or not args:
+            return
+
+        x = args[0]
+        if len(x) != len(adapter_names):
+            msg = (
+                "Length of `adapter_names` should be the same as the number of inputs, but got "
+                f"{len(adapter_names)} and {len(x)} respectively."
+            )
+            raise ValueError(msg)
+
+    def _forward_wrapped(self, *args: Any, **kwargs: Any) -> torch.Tensor:
+        raise NotImplementedError
+
+    def _forward_wrapped_mixed_batch(
+        self, x: torch.Tensor, active_adapter: str, *args: Any, **kwargs: Any
+    ) -> torch.Tensor:
+        raise NotImplementedError
+
+    def _forward_wrapped_passthrough(self, *args: Any, **kwargs: Any) -> torch.Tensor:
+        """The forward call when no adapter is involved in the forward computation, only the base model"""
+        raise NotImplementedError
+
+    def _mixed_batch_forward(
+        self, input: torch.Tensor, *args: Any, adapter_names: list[str], **kwargs: Any
+    ) -> torch.Tensor:
+        # This is a special method that handles the case when users pass the argument `adapter_names`. This is an
+        # extra argument that allows mixing different adapters in the same batch at inference time.
+
+        SUPPORTED_MODULES = (torch.nn.Linear, torch.nn.Embedding, torch.nn.Conv1d, torch.nn.Conv2d, torch.nn.Conv3d)
+
+        module_names = ", ".join([module.__name__ for module in SUPPORTED_MODULES])
+
+        if not isinstance(self.original_module, SUPPORTED_MODULES):
+            raise TypeError(f"Mixed batching is only supported for the following modules: {module_names}.")
+
+        unique_adapters = set(adapter_names)
+        sub_batch_indices_list = []
+
+        for adapter in unique_adapters:
+            sub_batch_indices_list.append([index for index, item in enumerate(adapter_names) if item == adapter])
+
+        results = [0 for _ in range(len(input))]
+
+        for i, active_adapter in enumerate(unique_adapters):
+            sub_batch = input[sub_batch_indices_list[i]]
+
+            if active_adapter == "__base__":
+                output = self.original_module(sub_batch, *args, **kwargs)
+            else:
+                output = self._forward_wrapped_mixed_batch(sub_batch, active_adapter, *args, **kwargs)
+
+            for index, j in enumerate(sub_batch_indices_list[i]):
+                results[j] = output[index]
+
+        return torch.stack(results)
+
+    def forward(self, *args, **kwargs):
+        self._check_forward_args(*args, **kwargs)
+        adapter_names = kwargs.pop("adapter_names", None)
+
+        if self.disable_adapters or any(adapter not in self._adapters for adapter in self.active_adapters):
+            return self._forward_wrapped_passthrough(*args, **kwargs)
+
+        if adapter_names is None:
+            return self._forward_wrapped(*args, **kwargs)
+        return self._mixed_batch_forward(*args, adapter_names=adapter_names, **kwargs)
+
+    def enable_adapters(self, enabled: bool):
+        """Toggle the enabling and disabling of adapters
+
+        Args:
+            enabled (bool): True to enable adapters, False to disable adapters
+        """
+        if enabled:
+            self._disable_adapters = False
+        else:
+            self._disable_adapters = True
+
+    def check_set_adapter(self, adapter_name: str | list[str]) -> str | None:
+        """Helper function to check if the given adapter(s) can be set.
+
+        Return the name of the adapter to be set or None if no adapter should be set.
+        """
+        raise NotImplementedError
+
+    def set_adapter(self, adapter_names: Union[str, list[str]], inference_mode: bool = False) -> None:
+        """Set the active adapter
+
+        Note: This only deals with active_adapters, not with requires_grad. If the latter needs changing, handle it via
+        the subclass.
+
+        Args:
+            adapter_names (str or list[str]):
+                The name(s) of the adapter(s) to set as active
+            inference_mode (bool, optional):
+                 Whether the activated adapter should be frozen (i.e. `requires_grad=False`). Default is False.
+        """
+        if isinstance(adapter_names, str):
+            self._active_adapter = adapter_names
+        else:
+            self._active_adapter = []
+            for adapter_name in adapter_names:
+                if adapter_name not in self._adapters:
+                    raise ValueError(f"Adapter {adapter_name} not found in {self._adapters}")
+
+                self._active_adapter.append(adapter_name)
+
+    def delete_adapter(self, adapter_name: str, new_active_adapters: Optional[list[str]]) -> None:
+        """Delete an adapter from the layer, set a new active adapter if necessary"""
+        raise NotImplementedError
+
+    def set_requires_grad(self, adapter_names: str | Sequence[str], requires_grad: bool = True) -> None:
+        """
+        Enable or disable gradients on the given adapter(s).
+
+        Args:
+            adapter_names (`str` or `Sequence[str]`):
+                The name of the adapter(s) whose gradients should be enabled/disabled.
+            requires_grad (`bool`, *optional*)
+                Whether to enable (`True`, default) or disable (`False`).
+        """
+        if isinstance(adapter_names, str):
+            adapter_names_set = {adapter_names}
+        else:
+            adapter_names_set = set(adapter_names)
+
+        for layer_name in self.adapter_layer_names:
+            # use attrgetter, as it resolves `.` in the attribute name
+            module_dict = attrgetter(layer_name)(self)
+            for key, layer in module_dict.items():
+                if key in adapter_names_set:
+                    _set_layer_requires_grad(layer, requires_grad)
+
+    def adapter_state_dict(self, adapter_name):
+        """Return the state dict of this module for a given adapter."""
+        raise NotImplementedError
+
+    def adapter_state_dict_load_map(self, adapter_name):
+        """Return a mapping from the key present in disk-loaded state dict
+        and how it should be represented in the loaded model's state dict.
+
+        The default should be a 1:1 mapping but it is important to define a mapping as it also serves as the
+        ground-truth for which keys are supposed to be loaded from a saved state dict.
+        """
+        raise NotImplementedError
+
+    def unload_and_optionally_merge_module(
+        self, merge: bool, safe_merge: bool, adapter_names: Optional[list[str]]
+    ) -> torch.nn.Module:
+        """Handles unloading when called from PEFT models. Returns the wrapped module
+        and handles merging onto the wrapped module if requested.
+        """
+        raise NotImplementedError
+
+
+class ModulesToSaveWrapper(AuxiliaryTrainingWrapper):
+    """Wraps a module that is supposed to be trained (i.e. `requires_grad_(True)`) and saved after training."""
+
+    # All names of layers that may contain adapter (trainable) weights
+    adapter_layer_names: tuple[str, ...] = ("modules_to_save",)
+
+    def __init__(self, module_to_save, adapter_name, tied_module=None):
+        super().__init__(module_to_save, adapter_name, tied_module=tied_module)
+
+    def init_modules(self, adapter_name, **kwargs):
+        # we treat each adapter separately, so we have multiple adapters, same (copied) module for each
+        self.modules_to_save = torch.nn.ModuleDict({})
+
+    def _error_message_name(self):
+        return "modules_to_save"
+
+    def _forward_wrapped(self, *args, **kwargs):
+        if not self.active_adapters:
+            return self._forward_wrapped_passthrough(*args, **kwargs)
+        return self.modules_to_save[self.active_adapters[0]](*args, **kwargs)
+
+    def _forward_wrapped_mixed_batch(self, x, active_adapter, *args, **kwargs):
+        return self.modules_to_save[active_adapter](x, *args, **kwargs)
+
+    def _forward_wrapped_passthrough(self, *args, **kwargs):
+        return self.original_module(*args, **kwargs)
+
+    def _hasattr_wrapped(self, name, modules):
+        # this method is only called if there is at least one active adapter
+        return self.active_adapters[0] in modules["modules_to_save"]
+
+    def _getattr_wrapped(self, name, modules):
+        return getattr(modules["modules_to_save"][self.active_adapters[0]], name)
+
+    def update(self, adapter_name, tied_module=None, **kwargs):
+        super().update(adapter_name)
+
+        context_manager = nullcontext()
+        for _, param in self.original_module.named_parameters():
+            num_params = param.numel()
+            # if using DS Zero 3 and the weights are initialized empty
+            if num_params == 0 and hasattr(param, "ds_numel"):
+                import deepspeed
+
+                context_manager = deepspeed.zero.GatheredParameters(self.original_module.parameters(), modifier_rank=0)
+                break
+
+        if adapter_name not in self.modules_to_save:
+            with context_manager:
+                if tied_module:
+                    new_linear = torch.nn.Linear(*tied_module.weight.shape, bias=False)
+                    new_linear.weight = tied_module.weight
+
+                    self.modules_to_save[adapter_name] = new_linear
+                else:
+                    self.modules_to_save[adapter_name] = copy.deepcopy(self.original_module)
+
+        if hasattr(self.modules_to_save[adapter_name], "_hf_hook"):
+            old_hook = self.modules_to_save[adapter_name]._hf_hook
+            new_hook = self._create_new_hook(old_hook)
+            remove_hook_from_module(self.modules_to_save[adapter_name])
+            add_hook_to_module(self.modules_to_save[adapter_name], new_hook)
+
+        self.original_module.requires_grad_(False)
+
+        # note that there currently cannot be more than one active adapter for the same layer with modules to save
+        # since there would be no clear way to decide which adapter's weights are the correct ones. therefore we
+        # assume that there is only one active adapter. this precondition is enforced by _set_adapter.
+        if adapter_name == self.active_adapter:
+            _set_layer_requires_grad(self.modules_to_save[adapter_name], True)
+
+    def enable_adapters(self, enabled: bool):
+        """Takes care of setting the required_grad flag on the modules_to_save.
+        If adapters are enabled, gradients for the modules_to_save are required as well.
+        """
+        super().enable_adapters(enabled)
+
+        if enabled:
+            for adapter_name in self.active_adapters:
+                _set_layer_requires_grad(self.modules_to_save[adapter_name], True)
+        else:
+            for module in self.modules_to_save.values():
+                _set_layer_requires_grad(module, False)
+
+    def check_set_adapter(self, adapter_name: str | list[str]) -> str | None:
+        """Helper function to check if the given adapter(s) can be set.
+
+        Return the name of the adapter to be set or None if no adapter should be set.
+        """
+        if isinstance(adapter_name, str):
+            return adapter_name
+
+        # adapter_name is a list of str
+        if len(adapter_name) == 0:
+            raise ValueError("Please specify at least one adapter to set")
+
+        adapter_names_in_module = [n for n in adapter_name if n in self.modules_to_save]
+
+        if len(adapter_names_in_module) > 1:
+            raise ValueError(f"Only one adapter can be set at a time for {self}, got {len(adapter_names_in_module)}")
+
+        adapter_name_to_set: str | None
+        if not adapter_names_in_module:
+            adapter_name_to_set = None
+        else:
+            adapter_name_to_set = adapter_names_in_module[0]
+
+        return adapter_name_to_set
+
+    def set_adapter(self, adapter_names: Union[str, list[str]], inference_mode: bool = False) -> None:
+        """Set the active adapter
+
+        Additionally, this function will set the specified adapter to trainable (i.e., requires_grad=True) unless
+        inference_mode is True.
+
+        Args:
+            adapter_names (list[str], str):
+                 The name(s) of the adapter(s) to set as active.
+            inference_mode (bool, optional):
+                 Whether the activated adapter should be frozen (i.e. `requires_grad=False`). Default is False.
+        """
+        if isinstance(adapter_names, str):
+            adapter_names = [adapter_names]
+
+        if len(adapter_names) > 1:
+            raise ValueError(f"Attempted to set multiple ({adapter_names}) adapters at once for modules_to_save.")
+
+        for currently_active_adapter_name in self.active_adapters:
+            _set_layer_requires_grad(self.modules_to_save[currently_active_adapter_name], False)
+
+        if len(adapter_names) == 0:
+            # when calling model.add_adapter, the new adapter is not automatically active
+            self._active_adapter = []
+            return
+
+        adapter_name = adapter_names[0]
+
+        if adapter_name not in self._adapters:
+            raise ValueError(f"Adapter {adapter_name} not found in {self._adapters}")
+
+        _set_layer_requires_grad(self.modules_to_save[adapter_name], not inference_mode)
+        self._active_adapter = adapter_name
+
+    def delete_adapter(self, adapter_name: str, new_active_adapters: Optional[list[str]]) -> None:
+        """
+        Delete the adapter if present.
+
+        This method will also set a new active adapter if the deleted adapter was the active adapter. It is important
+        that the new adapter is chosen by the caller in a deterministic way, so that the same adapter is chosen on all
+        layers.
+        """
+        if adapter_name not in self.modules_to_save:
+            return
+
+        # set new active adapter, if necessary
+        # note: there can only ever be one active adapter, unlike for LoRA etc.
+        if isinstance(new_active_adapters, (list, tuple)) and len(new_active_adapters) > 1:
+            name = self.__class__.__name__
+            raise ValueError(
+                f"Attempted to set multiple ({new_active_adapters}) adapters at once for {name}, which is not allowed."
+            )
+
+        if adapter_name in self._adapters:
+            self._adapters.remove(adapter_name)
+
+        if not new_active_adapters:
+            # no active adapter now
+            del self.modules_to_save[adapter_name]
+            self._active_adapter = []
+            return
+
+        new_active_adapter = new_active_adapters[0]
+        if new_active_adapter not in self.modules_to_save:
+            # a new active adapter was chosen but it seems like it has no modules_to_save
+            del self.modules_to_save[adapter_name]
+            self._active_adapter = []
+            return
+
+        if new_active_adapter != self.active_adapters[0]:
+            self.set_adapter(new_active_adapter)
+        del self.modules_to_save[adapter_name]
+
+    def adapter_state_dict_load_map(self, adapter_name):
+        # Maps the module keys as they are in the saved state dict to the in-memory state dict.
+        # Must contain all keys that are supposed to be loaded.
+        if adapter_name not in self._adapters:
+            # In caes of multiple adapters, each bringing their own modules to save, each
+            # ModulesToSaveWrapper will be queried but not every wrapper is obliged to serve the same adapters.
+            return {}
+        return {k: f"modules_to_save.{adapter_name}.{k}" for k in self.modules_to_save[adapter_name].state_dict()}
+
+    def adapter_state_dict(self, adapter_name, state_dict):
+        if adapter_name not in self._adapters:
+            # In caes of multiple adapters, each bringing their own modules to save, each
+            # ModulesToSaveWrapper will be queried but not every wrapper is obliged to serve the same adapters.
+            return {}
+
+        return {
+            k: state_dict[f"modules_to_save.{adapter_name}.{k}"]
+            for k in self.modules_to_save[adapter_name].state_dict()
+        }
+
+    def unload_and_optionally_merge_module(
+        self, merge: bool, safe_merge: bool, adapter_names: Optional[list[str]]
+    ) -> torch.nn.Module:
+        """Unloading in case of `ModulesToSave` means to simply return the wrapped module.
+
+        However, if the wrapped module is itself a tuner, we'll call merge on it before.
+        """
+        new_module = self.modules_to_save[self.active_adapter]
+
+        # TODO: not sure if this is still a sensible thing to do. We would basically have to
+        # do the same checks as `_unload_and_optionally_merge` to support MHA, for example.
+        if hasattr(new_module, "base_layer"):
+            # check if the module is itself a tuner layer
+            if merge:
+                new_module.merge(safe_merge=safe_merge, adapter_names=adapter_names)
+            new_module = new_module.get_base_layer()
+
+        return new_module
+
+    def _get_available_adapters(self) -> set[str]:
+        """Return all adapter names that can be found on this module."""
+        return set(self.modules_to_save.keys())
+
+
+class TrainableTokensWrapper(AuxiliaryTrainingWrapper):
+    """Wraps a module (typically an embedding layer) that is supposed to be re-trained selectively (i.e.
+    solely updating a few columns) using the `TrainableTokensLayer` PEFT method.
+
+    Supports weight-tying to another adapter when passed a `tied_adapter` which is expected to be a
+    `TrainableTokensLayer`.
+    """
+
+    # All names of layers that may contain adapter (trainable) weights
+    adapter_layer_names: tuple[str, ...] = ("token_adapter.trainable_tokens_delta",)
+    other_param_names: tuple[str, ...] = ("token_adapter.token_indices", "token_adapter.trainable_tokens_original")
+
+    def __init__(
+        self,
+        module_to_save: torch.nn.Module,
+        adapter_name: str,
+        token_indices: list[int],
+        tied_adapter=None,
+    ) -> None:
+        super().__init__(module_to_save, adapter_name, token_indices=token_indices, tied_adapter=tied_adapter)
+
+        # unset the original_module attribute since we're using a property to remove this from the state dict.
+        self.original_module = None
+
+    @property
+    def original_module(self):
+        # use a property instead of an attribute to exclude this pointer from the state dict
+        # to make sure that it will not be saved.
+        return self.token_adapter.base_layer
+
+    def init_modules(self, adapter_name, token_indices, tied_adapter):
+        # use a local import to avoid potential circular imports
+        from peft.tuners.trainable_tokens import TrainableTokensLayer
+
+        # since super().__init__() calls update before we have a chance to initialise the adapter we would
+        # need here, we do the initialization here.
+        self.token_adapter = TrainableTokensLayer(self.original_module, adapter_name, token_indices, tied_adapter)
+
+    def _error_message_name(self):
+        return "trainable_token_indices"
+
+    def _hasattr_wrapped(self, name, modules):
+        return name == "weight"
+
+    def _getattr_wrapped(self, name, modules):
+        # some models query self.wte.weight.dtype, some may query the weights directly. for the first case it is not
+        # necessary to do anything special but we don't know if is going to be `.dtype`. so we need to get the merged
+        # weights from the adapter.
+        if name == "weight":
+            return modules["token_adapter"].get_merged_weights(self.token_adapter.active_adapters)
+
+        raise RuntimeError(
+            f"This code should've never been reached, probably a bad check in `_hasattr_wrapped` for {name}. "
+            "Please file an issue under https://github.com/huggingface/peft/issues."
+        )
+
+    def _forward_wrapped(self, x, *args, **kwargs):
+        if not self.active_adapters:
+            return self._forward_wrapped_passthrough(x, *args, **kwargs)
+        return self.token_adapter(x)
+
+    def _forward_wrapped_mixed_batch(self, x, active_adapter, *args, **kwargs):
+        return self.token_adapter.forward_adapters(x, [active_adapter])
+
+    def _forward_wrapped_passthrough(self, x, *args, **kwargs):
+        # the token adapter knows how to deal with disabled adapter / no active adapter, don't call original_module
+        # directly
+        return self.token_adapter(x, *args, **kwargs)
+
+    def update(self, active_adapter, **kwargs):
+        # TODO this does not support deepspeed/fsdp since it is missing a context manager
+        # see ModulesToSaveWrapper implementation
+        if active_adapter not in self._adapters:
+            self.token_adapter.update_layer(active_adapter, **kwargs)
+
+        super().update(active_adapter)
+
+    def adapter_state_dict_load_map(self, adapter_name):
+        if self.token_adapter.tied_adapter:
+            return {}
+        return {"token_adapter.trainable_tokens_delta": f"token_adapter.trainable_tokens_delta.{adapter_name}"}
+
+    def adapter_state_dict(self, adapter_name, state_dict):
+        if self.token_adapter.tied_adapter:
+            # storing of weight-tied layers is not up to us and will be handled by
+            # transformers. we're just here to keep those layers in sync during training.
+            # therefore we return an empty state dict.
+            return {}
+
+        return {
+            f"token_adapter.{k}": state_dict[f"token_adapter.{k}.{adapter_name}"] for k in ["trainable_tokens_delta"]
+        }
+
+    def enable_adapters(self, enabled: bool):
+        """Enables/disables the underlying `TrainableTokens` adapter.
+        Also handles the internal adapter disable flag.
+        """
+        super().enable_adapters(enabled)
+
+        self.token_adapter.enable_adapters(enabled)
+
+    def check_set_adapter(self, adapter_name: str | list[str]) -> str | None:
+        """Helper function to check if the given adapter(s) can be set.
+
+        Return the name of the adapter to be set or None if no adapter should be set.
+        """
+        if isinstance(adapter_name, str):
+            return adapter_name
+
+        # adapter_name is a list of str
+        if len(adapter_name) == 0:
+            raise ValueError("Please specify at least one adapter to set")
+
+        # TODO In theory, multiple active trainable tokens is fine when the indices don't overlap
+        adapter_names_in_module = [n for n in adapter_name if n in self.token_adapter.trainable_tokens_delta]
+
+        if len(adapter_names_in_module) > 1:
+            raise ValueError(f"Only one adapter can be set at a time for {self}, got {len(adapter_names_in_module)}")
+
+        adapter_name_to_set: str | None
+        if not adapter_names_in_module:
+            adapter_name_to_set = None
+        else:
+            adapter_name_to_set = adapter_names_in_module[0]
+
+        return adapter_name_to_set
+
+    def set_adapter(self, adapter_names: Union[str, list[str]], inference_mode: bool = False) -> None:
+        super().set_adapter(adapter_names, inference_mode=inference_mode)
+        self.token_adapter.set_adapter(adapter_names, inference_mode=inference_mode)
+
+    def delete_adapter(self, adapter_name: str, new_active_adapters: Optional[list[str]]) -> None:
+        """
+        Delete the adapter if present.
+
+        This method will also set a new active adapter if the deleted adapter was the active adapter. It is important
+        that the new adapter is chosen by the caller in a deterministic way, so that the same adapter is chosen on all
+        layers.
+        """
+        self.token_adapter.delete_adapter(adapter_name)
+
+        # set new active adapter, if necessary
+        # note: there can only ever be one active adapter, unlike for LoRA etc.
+        if isinstance(new_active_adapters, (list, tuple)) and len(new_active_adapters) > 1:
+            name = self.__class__.__name__
+            raise ValueError(
+                f"Attempted to set multiple ({new_active_adapters}) adapters at once for {name}, which is not allowed."
+            )
+
+        if adapter_name in self._adapters:
+            self._adapters.remove(adapter_name)
+
+        if not new_active_adapters:
+            self._active_adapter = []
+            return
+
+        if new_active_adapters[0] not in self.token_adapter.trainable_tokens_delta:
+            # a new active adapter was chosen but it seems like it has no trainable_tokens
+            self._active_adapter = []
+            return
+
+        new_active_adapter = new_active_adapters[0]
+        self.set_adapter(new_active_adapter)
+
+    def unload_and_optionally_merge_module(
+        self, merge: bool, safe_merge: bool, adapter_names: Optional[list[str]]
+    ) -> torch.nn.Module:
+        """Unloading for `TrainableTokensWrapper` means to return the wrapped module, e.g. the embedding layer and,
+        if requested, merging the `TrainableTokens` adapter onto the wrapped module.
+        """
+        if merge:
+            self.token_adapter.merge(safe_merge=safe_merge, adapter_names=adapter_names)
+        return self.token_adapter.get_base_layer()
+
+    def _get_available_adapters(self) -> set[str]:
+        """Return all adapter names that can be found on this module."""
+        return set(self.token_adapter.trainable_tokens_delta.keys())
+
+
+def _get_input_embeddings_name(model: torch.nn.Module, default: Optional[str] = None) -> Optional[str]:
+    if not hasattr(model, "get_input_embeddings"):
+        return default
+
+    input_embeddings = model.get_input_embeddings()
+    for name, module in model.named_modules():
+        if module is input_embeddings:
+            return name
+
+    return default
+
+
+def _get_submodules(model: torch.nn.Module, key: str) -> tuple[torch.nn.Module, torch.nn.Module, str]:
+    parent = model.get_submodule(".".join(key.split(".")[:-1]))
+    target_name = key.split(".")[-1]
+    target = model.get_submodule(key)
+    return parent, target, target_name
+
+
+def _get_submodules_with_grandparent(
+    model: torch.nn.Module, key: str
+) -> tuple[torch.nn.Module, Optional[torch.nn.Module], torch.nn.Module, str]:
+    parent = model.get_submodule(".".join(key.split(".")[:-1]))
+    try:
+        grandparent = model.get_submodule(".".join(key.split(".")[:-2]))
+    except AttributeError:
+        # no grand parent
+        grandparent = None
+    target_name = key.split(".")[-1]
+    target = model.get_submodule(key)
+    return parent, grandparent, target, target_name
+
+
+def _freeze_adapter(model: torch.nn.Module, adapter_name: str) -> None:
+    for n, p in model.named_parameters():
+        if adapter_name in n:
+            p.requires_grad = False
+
+
+def _set_trainable(
+    model,
+    adapter_name,
+    module_names,
+    inference_mode: bool,
+    strict_module_check: bool = False,
+    wrapper_cls: Optional[AuxiliaryTrainingWrapper] = None,
+    activate_adapter: bool = True,
+    **wrapper_kwargs,
+):
+    """Wraps modules that are supposed to be re-trained either normally, i.e. marking them to require gradients and
+    saving them alongside other modules, or with certain methods that go alongside PEFT methods, such as retraining
+    specific token indices using selective read/write.
+
+    Note that you need to validate beforehand if there are layers targeted by multiple wrappers, e.g. if the
+    'embedding' layer is configured for both `ModulesToSaveWrapper` and `TrainableTokensWrapper` there would be
+    conflicts down the line.
+
+    The default is to wrap the module in a `ModulesToSaveWrapper` wrapper.
+
+    If `strict_module_check` is set, this method raises an ValueError, similar to BaseTuner.inject_adapter when none of
+    the requested modules in `module_names` is not found in the model.
+
+    The `active_adapter` flag indicates if this new adapter should be activated.
+    """
+    from peft.tuners.tuners_utils import BaseTunerLayer
+
+    if wrapper_cls is None:
+        wrapper_cls = ModulesToSaveWrapper
+
+    if not module_names:
+        # This is useful for the case that the PEFT config does not have `modules_to_save`, e.g.
+        # in the case of prompt tuning and friends.
+        return
+
+    trainable_modules = []
+    found_modules = set()
+    # disable removal of duplicates to support targeting tied weights
+    key_list = [key for key, _ in model.named_modules(remove_duplicate=False)]
+
+    for key in key_list:
+        target_module_found = any(key.endswith(target_key) for target_key in module_names)
+        if target_module_found:
+            parent, grandparent, target, target_name = _get_submodules_with_grandparent(model, key)
+            if isinstance(grandparent, BaseTunerLayer):
+                # This is an extreme edge case: Let's assume that there is a PEFT config with
+                # modules_to_save=["default"], which is the same name as the adapter name. The PEFT method's adapter
+                # (e.g. LoRA) is applied first. Then, when the modules_to_save matching is performed, the LoRA layer
+                # would be considered a valid target. Assuming that the name is "foo.bar.lora_A.default", it would
+                # match, with "default" being an nn.Linear and the parent, "lora_A", being an nn.ModuleDict. This by
+                # itself is not enough to prove that this is an unintended match. Thererfore, we also need to check the
+                # grandparent, "bar", that would be a lora.LoraLayer. When we see this, we should raise an error.
+                raise ValueError(
+                    f"You are trying to target a module with {wrapper_cls} that is a child of {type(grandparent)}. "
+                    "This is almost certainly not the intended behavior. Please ensure that the adapter name, "
+                    f"'{adapter_name}', does not conflict with any of the targeted modules."
+                )
+
+            # For transformers >=5 we need to check the grandparent to detect already modified tied weights.  The way
+            # the new `get_tied_weights_keys` works is that we resolve the current name of the module tied to the
+            # embeddings. If we replaced the tied weight (i.e. moved it to, say, `lm_head.token_adapter.base_layer`)
+            # we'll get the new name whereas the old way was that we got `lm_head` regardless of whether it was modified
+            # or not. We'll assume that we always have two levels of nesting and therefore do the same check as before
+            # but on the grandparent to accommodate for the new behavior.
+            if isinstance(grandparent, wrapper_cls):
+                grandparent.update(adapter_name, **wrapper_kwargs)
+                grandparent.set_adapter(grandparent.active_adapter, inference_mode=inference_mode)
+            elif isinstance(target, wrapper_cls):
+                target.update(adapter_name, **wrapper_kwargs)
+                target.set_adapter(target.active_adapter, inference_mode=inference_mode)
+            else:
+                new_module = wrapper_cls(target, adapter_name, **wrapper_kwargs)
+                if activate_adapter:
+                    new_module.set_adapter(adapter_name, inference_mode=inference_mode)
+                else:
+                    new_module.set_adapter([], inference_mode=inference_mode)
+                setattr(parent, target_name, new_module)
+                trainable_modules.append(new_module)
+            found_modules.add(target_name)
+
+    not_found = set(module_names).difference(found_modules)
+    if strict_module_check and not found_modules:
+        raise ValueError(
+            f"Target modules {not_found} not found in the base model. Please check the target modules and try again."
+        )
+
+    return trainable_modules
+
+
+def _set_adapter(model, adapter_name: str | list[str], inference_mode: bool = False) -> None:
+    """Call set_adapter on the AuxiliaryTrainingWrapper modules"""
+    for module in model.modules():
+        if isinstance(module, AuxiliaryTrainingWrapper):
+            # only check the adapter_name if we actually encounter a AuxiliaryTrainingWrapper, otherwise we don't care
+            adapter_name_to_set = module.check_set_adapter(adapter_name)
+
+            # if the adapter is found in this module, set it as the active adapter, else disable the adapters of this
+            # module
+            if adapter_name_to_set in module._adapters:
+                module.set_adapter(adapter_name_to_set, inference_mode=inference_mode)
+            else:
+                module.set_adapter([], inference_mode=inference_mode)
+
+
+def _prepare_prompt_learning_config(peft_config, model_config):
+    orig_model_config = model_config
+    if hasattr(model_config, "to_dict"):
+        model_config = model_config.to_dict()
+    # In case of VLM we focus on the language model portion of the model.
+    if "text_config" in model_config:
+        model_config = model_config["text_config"]
+
+    if peft_config.num_layers is None:
+        if hasattr(orig_model_config, "num_hidden_layers"):
+            # dict entry was removed in https://github.com/huggingface/transformers/pull/41250
+            num_layers = orig_model_config.num_hidden_layers
+        elif "num_hidden_layers" in model_config:
+            num_layers = model_config["num_hidden_layers"]
+        elif "num_layers" in model_config:
+            num_layers = model_config["num_layers"]
+        elif "n_layer" in model_config:
+            num_layers = model_config["n_layer"]
+        else:
+            raise ValueError("Please specify `num_layers` in `peft_config`")
+        peft_config.num_layers = num_layers
+
+    if peft_config.token_dim is None:
+        if "hidden_size" in model_config:
+            token_dim = model_config["hidden_size"]
+        elif "n_embd" in model_config:
+            token_dim = model_config["n_embd"]
+        elif "d_model" in model_config:
+            token_dim = model_config["d_model"]
+        else:
+            raise ValueError("Please specify `token_dim` in `peft_config`")
+        peft_config.token_dim = token_dim
+
+    if peft_config.num_attention_heads is None:
+        if "num_attention_heads" in model_config:
+            num_attention_heads = model_config["num_attention_heads"]
+        elif "n_head" in model_config:
+            num_attention_heads = model_config["n_head"]
+        elif "num_heads" in model_config:
+            num_attention_heads = model_config["num_heads"]
+        elif "encoder_attention_heads" in model_config:
+            num_attention_heads = model_config["encoder_attention_heads"]
+        else:
+            raise ValueError("Please specify `num_attention_heads` in `peft_config`")
+        peft_config.num_attention_heads = num_attention_heads
+
+    # For grouped-query attention, see #1901.
+    if (peft_config.peft_type in {"PREFIX_TUNING", "CARTRIDGE"}) and ("num_key_value_heads" in model_config):
+        # Models with heterogeneous attention (e.g. Gemma4) expose distinct shapes for global vs. sliding layers via
+        # `global_head_dim` / `num_global_key_value_heads`. Provision the prefix for the global-layer footprint; sliding
+        # layers whose KV shape doesn't match are skipped per-layer at injection time. Matches the default in
+        # google-deepmind/gemma#631.
+        if model_config.get("global_head_dim") is not None:
+            head_dim = model_config["global_head_dim"]
+            num_key_value_heads = model_config.get("num_global_key_value_heads") or model_config["num_key_value_heads"]
+        elif model_config.get("head_dim", None) is not None:
+            head_dim = model_config["head_dim"]
+            num_key_value_heads = model_config["num_key_value_heads"]
+        else:
+            head_dim = peft_config.token_dim // peft_config.num_attention_heads
+            num_key_value_heads = model_config["num_key_value_heads"]
+        peft_config.token_dim = head_dim * num_key_value_heads
+        peft_config.num_attention_heads = num_key_value_heads
+
+    if getattr(peft_config, "encoder_hidden_size", None) is None:
+        peft_config.encoder_hidden_size = peft_config.token_dim
+
+    return peft_config
+
+
+def _get_no_split_modules(model) -> set[str]:
+    """
+    Get the modules of the model that should not be split when using device_map. We iterate through the modules to get
+    the underlying `_no_split_modules`.
+
+    Returns:
+        `List[str]`: List of modules that should not be split
+    """
+    # After discussion in https://github.com/huggingface/transformers/pull/38141, based on:
+    # https://github.com/huggingface/transformers/blob/1e921a3a9cea92b383ca4b0484ee45596bbdadc3/src/transformers/modeling_utils.py#L2677-L2704
+    _no_split_modules: set[str] = set()
+    if not hasattr(model, "_no_split_modules"):
+        return _no_split_modules
+
+    if is_transformers_ge_v5_1_0:
+        # See https://github.com/huggingface/transformers/commit/36ec3bfa33ebf6c3b38a1d6808292aeea4aae84d
+        return model._no_split_modules
+
+    # TODO remove once transformers <5.1.0 is not supported anymore
+    modules_to_check = [model]
+    while len(modules_to_check) > 0:
+        module = modules_to_check.pop(-1)
+        # if the module does not appear in _no_split_modules, we also check the children
+        if module.__class__.__name__ not in _no_split_modules:
+            if isinstance(module, PreTrainedModel):
+                if module._no_split_modules is not None:
+                    _no_split_modules = _no_split_modules | set(module._no_split_modules)
+            modules_to_check += list(module.children())
+    return _no_split_modules
+
+
+def fsdp_auto_wrap_policy(model):
+    if hasattr(FullyShardedDataParallelPlugin, "get_module_class_from_name"):
+        get_module_class_from_name = FullyShardedDataParallelPlugin.get_module_class_from_name
+    else:
+        from accelerate.utils.dataclasses import get_module_class_from_name
+    from torch.distributed.fsdp.wrap import _or_policy, lambda_auto_wrap_policy, transformer_auto_wrap_policy
+
+    from ..tuners import CartridgeEncoder, PrefixEncoder, PromptEmbedding, PromptEncoder
+
+    default_transformer_cls_names_to_wrap = ",".join(_get_no_split_modules(model))
+    transformer_cls_names_to_wrap = os.environ.get(
+        "FSDP_TRANSFORMER_CLS_TO_WRAP", default_transformer_cls_names_to_wrap
+    ).split(",")
+    transformer_cls_to_wrap = {CartridgeEncoder, PrefixEncoder, PromptEncoder, PromptEmbedding}
+    for layer_class in transformer_cls_names_to_wrap:
+        if len(layer_class) == 0:
+            continue
+        transformer_cls = get_module_class_from_name(model, layer_class)
+        if transformer_cls is None:
+            raise TypeError("Could not find the transformer layer class to wrap in the model.")
+        else:
+            transformer_cls_to_wrap.add(transformer_cls)
+
+    def lambda_policy_fn(module):
+        return (
+            len(list(module.named_children())) == 0
+            and getattr(module, "weight", None) is not None
+            and module.weight.requires_grad
+        )
+
+    lambda_policy = functools.partial(lambda_auto_wrap_policy, lambda_fn=lambda_policy_fn)
+    transformer_wrap_policy = functools.partial(
+        transformer_auto_wrap_policy,
+        transformer_layer_cls=transformer_cls_to_wrap,
+    )
+
+    auto_wrap_policy = functools.partial(_or_policy, policies=[lambda_policy, transformer_wrap_policy])
+    return auto_wrap_policy
+
+
+def transpose(weight: torch.Tensor, fan_in_fan_out: bool) -> torch.Tensor:
+    if not fan_in_fan_out:
+        return weight
+
+    if isinstance(weight, torch.nn.Parameter):
+        return torch.nn.Parameter(weight.T)
+    return weight.T
+
+
+def _is_valid_match(key: str, target_key: str) -> bool:
+    """
+    Helper function to match module names target_key and key. Makes sure that either the key is exactly the target_key
+    or the target_key is a submodule of key
+    """
+    if key.endswith(target_key):
+        if len(key) > len(target_key):
+            return key.endswith("." + target_key)  # must be a sub module
+        return True
+    return False
+
+
+def _get_batch_size(input_ids: Optional[torch.Tensor], inputs_embeds: Optional[torch.Tensor]) -> int:
+    """Get the batch size based on either input_ids or input_embeds
+
+    Raises an ValueError if both are None.
+
+    """
+    if (input_ids is None) and (inputs_embeds is None):
+        raise ValueError("You have to provide either input_ids or inputs_embeds")
+
+    if input_ids is not None:
+        batch_size = input_ids.shape[0]
+    else:
+        batch_size = inputs_embeds.shape[0]
+    return batch_size
+
+
+def get_quantization_config(model: torch.nn.Module, method: str):
+    """
+    Get the quantization config of the related quantization method
+    """
+    if (
+        hasattr(model, "config")
+        and hasattr(model.config, "quantization_config")
+        and (getattr(model, "quantization_method", None) == method)
+    ):
+        return model.config.quantization_config
+    return None
+
+
+def is_gptqmodel_quant_linear(module: Optional[torch.nn.Module]) -> bool:
+    """
+    Check if a module is a GPT-QModel quantized linear.
+    """
+    if module is None or not is_gptqmodel_available():
+        return False
+
+    try:
+        from gptqmodel.nn_modules.qlinear import BaseQuantLinear
+    except ImportError:
+        return False
+
+    return isinstance(module, BaseQuantLinear)
+
+
+def is_gptqmodel_awq_layer(module: Optional[torch.nn.Module]) -> bool:
+    """
+    Check if a module is a GPT-QModel quantized linear that supports the AWQ method.
+    """
+    if not is_gptqmodel_quant_linear(module):
+        return False
+
+    supported_methods = getattr(module, "SUPPORTS_METHODS", [])
+    return any(method.value == "awq" for method in supported_methods)
+
+
+def get_gptqmodel_quant_linear(gptq_quantization_config, device_map=None):
+    """
+    Get the right GPTQQuantLinear class based on the quantization config file
+    """
+    if gptq_quantization_config is None:
+        return None
+
+    if not is_gptqmodel_available():
+        return None
+
+    from gptqmodel import BACKEND
+    from gptqmodel.quantization import METHOD
+    from gptqmodel.utils.importer import hf_select_quant_linear_v2
+
+    desc_act = gptq_quantization_config.desc_act
+    group_size = gptq_quantization_config.group_size
+    bits = gptq_quantization_config.bits
+    checkpoint_format = (
+        gptq_quantization_config.checkpoint_format
+        if hasattr(gptq_quantization_config, "checkpoint_format")
+        else "gptq"
+    )
+    sym = gptq_quantization_config.sym
+    meta = gptq_quantization_config.meta if hasattr(gptq_quantization_config, "meta") else None
+
+    QuantLinear = hf_select_quant_linear_v2(
+        bits=bits,
+        group_size=group_size,
+        desc_act=desc_act,
+        sym=sym,
+        device_map=device_map,
+        format=checkpoint_format,
+        quant_method=METHOD.GPTQ,
+        meta=meta,
+        backend=BACKEND.AUTO_TRAINABLE,
+        pack=False,
+    )
+
+    return QuantLinear
+
+
+def id_tensor_storage(tensor: torch.Tensor) -> tuple[torch.device, int, int]:
+    """
+    Unique identifier to a tensor storage. Multiple different tensors can share the same underlying storage. For
+    example, "meta" tensors all share the same storage, and thus their identifier will all be equal. This identifier is
+    guaranteed to be unique and constant for this tensor's storage during its lifetime. Two tensor storages with
+    non-overlapping lifetimes may have the same id.
+
+    This method is the exact same copy of
+    https://github.com/huggingface/transformers/blob/main/src/transformers/pytorch_utils.py#L282C1-L300C58 but we added
+    it here manually to avoid import issue with old versions of transformers.
+    """
+    if tensor.device.type == "xla" and is_torch_tpu_available():
+        # NOTE: xla tensors dont have storage
+        # use some other unique id to distinguish.
+        # this is a XLA tensor, it must be created using torch_xla's
+        # device. So the following import is safe:
+        import torch_xla
+
+        unique_id = torch_xla._XLAC._xla_get_tensor_id(tensor)
+    else:
+        unique_id = storage_ptr(tensor)
+
+    return tensor.device, unique_id, storage_size(tensor)
+
+
+def cast_mixed_precision_params(model: torch.nn.Module, dtype: torch.dtype) -> None:
+    """
+    Cast all non-trainable parameters of the model to the given `dtype`. The `dtype` can be `torch.float16` or
+    `torch.bfloat16` as per the mixed-precision training you are performing. The trainable parameters are cast to full
+    precision. This is meant to reduce the GPU memory usage when using PEFT methods by using half-precision dtype for
+    non-trainable parameters. Having the trainable parameters in full-precision preserves training stability when using
+    automatic mixed-precision training.
+
+    Args:
+        model (`torch.nn.Module`):
+            The model to cast the non-trainable parameters of.
+        dtype (`torch.dtype`):
+            The dtype to cast the non-trainable parameters to. The `dtype` can be `torch.float16` or
+    `torch.bfloat16` as per the mixed-precision training you are performing.
+    """
+    for p in model.parameters():
+        if not p.requires_grad:
+            p.data = p.to(dtype)
+        else:
+            p.data = p.to(torch.float32)
+
+
+def str_to_bool(value: str) -> int:
+    """
+    Converts a string representation of truth to `True` (1) or `False` (0).
+
+    True values are `y`, `yes`, `t`, `true`, `on`, and `1`; False value are `n`, `no`, `f`, `false`, `off`, and `0`;
+    """
+    # same as function as in accelerate.utils, which replaces the deprecated distutils.util.strtobool
+    value = value.lower()
+    if value in ("y", "yes", "t", "true", "on", "1"):
+        return 1
+    elif value in ("n", "no", "f", "false", "off", "0"):
+        return 0
+    else:
+        raise ValueError(f"invalid truth value {value}")
+
+
+def check_file_exists_on_hf_hub(repo_id: str, filename: str, **kwargs) -> Optional[bool]:
+    """Check if a file exists on HF Hub, if check was not successful returns None instead of erroring.
+
+    Respect offline mode if set.
+
+    """
+    exists: Optional[bool] = None
+    if str_to_bool(os.environ.get("HF_HUB_OFFLINE", "0")):
+        # user set offline mode, cannot check
+        return exists
+
+    try:
+        exists = file_exists(repo_id, filename, **kwargs)
+    except (HFValidationError, EntryNotFoundError):
+        # error, exists stays None
+        pass
+    except Exception as e:
+        warnings.warn(
+            f"Unable to fetch remote file due to the following error {e} - silently ignoring the lookup"
+            f" for the file {filename} in {repo_id}."
+        )
+
+    return exists
+
+
+def match_target_against_key(target_pattern: str, key: str) -> Optional[re.Match[str]]:
+    """Backing function for `target_modules` config parameter.
+
+    Having this as its own function ensures that target key matching can be implemented in the same way everywhere.
+    """
+    return re.fullmatch(target_pattern, key)
+
+
+def get_pattern_key(pattern_keys: Sequence[str], key_to_match: str) -> str:
+    """Match a substring of key_to_match in pattern keys"""
+    for key in pattern_keys:
+        match = re.match(rf"(.*\.)?({key})$", key_to_match)
+        if not match:
+            continue
+        return key
+
+    return key_to_match
+
+
+def set_additional_trainable_modules(model, peft_config, model_config, adapter_name, activate_adapter: bool = True):
+    """Handle the resolution of additional trainable modules (also called AuxiliaryTrainingWrapper)
+    by checking the config if such modules are requested and adding them to the model.
+
+    Currently trainable tokens and modules to save are considered additional trainable modules.
+
+    If `activate_adapter` is set to `False`, the adapter won't be activated. This is typically the case when
+    `model.add_adapter` or `model.load_adapter` are being called.
+    """
+    if getattr(peft_config, "modules_to_save", None) is not None:
+        # this may add a new ModulesToSaveWrapper
+        _set_trainable(
+            model,
+            adapter_name,
+            inference_mode=peft_config.inference_mode,
+            module_names=getattr(peft_config, "modules_to_save", None),
+            activate_adapter=activate_adapter,
+        )
+
+    if getattr(peft_config, "modules_to_tie", None) is not None:
+        # Tie the modules if any tied layer is passed in `modules_to_save`.
+        # This should always be called after
+        # `_set_trainable` is called for `modules_to_save`.
+        tied_module = getattr(model.get_input_embeddings().modules_to_save, adapter_name)
+        _set_trainable(
+            model,
+            adapter_name,
+            inference_mode=peft_config.inference_mode,
+            module_names=getattr(peft_config, "modules_to_tie", None),
+            activate_adapter=activate_adapter,
+            tied_module=tied_module,
+        )
+
+    if getattr(peft_config, "trainable_token_indices", None) is not None:
+        if isinstance(peft_config.trainable_token_indices, dict):
+            target_layers = peft_config.trainable_token_indices
+        else:
+            layer_name = _get_input_embeddings_name(model, "embed_tokens")
+            target_layers = {layer_name: peft_config.trainable_token_indices}
+
+        modules_to_save = getattr(peft_config, "modules_to_save", None)
+        if modules_to_save is not None:
+            for target_layer_name in target_layers:
+                if target_layer_name in modules_to_save:
+                    raise ValueError(
+                        "The embedding layer is already marked to be trained fully, either specify "
+                        f'`modules_to_save=[..., "{target_layer_name}", ...]` or '
+                        f"`trainable_tokens={{'{target_layer_name}': x}}` but not both."
+                    )
+
+        # Check weight tying configuration first to determine which layers to wrap
+        weights_tied = model_config.get("tie_word_embeddings", False)
+        ensure_weight_tying = getattr(peft_config, "ensure_weight_tying", False)
+
+        # When multiple target layers are specified, check if they correspond to tied weights
+        indices_mismatch = False
+        layers_to_skip = set()
+        tied_layer_keys = []
+
+        if len(target_layers) > 1 and weights_tied:
+            # Get module names that are tied with the embedding
+            tied_module_names = set(_get_module_names_tied_with_embedding(model))
+
+            # Also get the input embedding layer name as it's the source of tied weights
+            embedding_module = model.get_input_embeddings()
+            # Get the full embedding name (not just the last part) to support nested structures
+            embedding_name = next(n for n, m in model.named_modules() if m is embedding_module)
+
+            # Find which target layers are in the tied weights (including the embedding source)
+            for target_layer_name in target_layers:
+                # Check if this is the embedding layer (use endswith to allow flexible matching)
+                # This allows users to specify just "embed_tokens" OR "m1.encoder.embed_tokens" for precision
+                if embedding_name.endswith(target_layer_name):
+                    tied_layer_keys.append(target_layer_name)
+                    continue
+                # Check if this target layer matches any tied module (considering nested structures)
+                for tied_module in tied_module_names:
+                    if tied_module.endswith(target_layer_name) or target_layer_name in tied_module.split("."):
+                        tied_layer_keys.append(target_layer_name)
+                        break
+
+            # If we found multiple tied layers in our targets, check their indices
+            if len(tied_layer_keys) >= 2:
+                # Check if all tied layers have the same indices
+                first_indices = target_layers[tied_layer_keys[0]]
+                indices_mismatch = not all(target_layers[key] == first_indices for key in tied_layer_keys[1:])
+
+                # Raise error immediately if ensure_weight_tying=True and indices mismatch
+                if indices_mismatch and ensure_weight_tying:
+                    tied_layers_info = ", ".join([f"{key}: {target_layers[key]}" for key in tied_layer_keys])
+                    raise ValueError(
+                        f"Cannot ensure weight tying when different token indices are specified for tied layers. "
+                        f"Conflicting layers: {tied_layers_info}. "
+                        f"Please use the same indices for all tied layers or set ensure_weight_tying=False."
+                    )
+
+                # If indices match, skip tied modules (except embedding) as they'll be handled by weight tying logic
+                if not indices_mismatch:
+                    layers_to_skip = set(tied_layer_keys) & tied_module_names
+
+        # Wrap target layers (skip those that will be handled by weight tying logic)
+        for target_layer_name, token_indices in target_layers.items():
+            if target_layer_name in layers_to_skip:
+                continue
+
+            _set_trainable(
+                model,
+                adapter_name,
+                inference_mode=peft_config.inference_mode,
+                module_names=[target_layer_name],
+                strict_module_check=True,
+                wrapper_cls=TrainableTokensWrapper,
+                token_indices=token_indices,
+                activate_adapter=activate_adapter,
+            )
+
+        # Warn if user expects weight tying but model doesn't have tied weights
+        if not weights_tied and ensure_weight_tying:
+            warnings.warn(
+                "ensure_weight_tying=True but the model does not have tied weights "
+                "(tie_word_embeddings=False). Weight tying will not be applied for trainable_token_indices."
+            )
+
+        # Apply weight tying when appropriate
+        should_apply_tying = (
+            weights_tied
+            and isinstance(model.get_input_embeddings(), TrainableTokensWrapper)
+            and (ensure_weight_tying or not indices_mismatch)
+        )
+
+        if should_apply_tying:
+            # There might be the possibility that we have output weights that are tied to the input weights.
+            # In that case we will tie any module that wants tied weights to the token adapter to make sure that
+            # any modification is reflected in the tied layers as well.
+            tied_weights_module_names = _get_module_names_tied_with_embedding(model)
+            token_adapter = model.get_input_embeddings().token_adapter
+            _set_trainable(
+                model,
+                adapter_name,
+                inference_mode=peft_config.inference_mode,
+                module_names=tied_weights_module_names,
+                strict_module_check=True,
+                wrapper_cls=TrainableTokensWrapper,
+                token_indices=token_adapter.token_indices[adapter_name],
+                tied_adapter=model.get_input_embeddings().token_adapter,
+            )
+
+
+def create_attention_mask(
+    model, *, model_input, attention_mask, past_key_values, cache_position, batch_size, sequence_length, position_ids
+):
+    # adapted from:
+    # https://github.com/huggingface/transformers/blob/cb4c56ce0dfa1350267ed28e57760986a58a9ba4/src/transformers/generation/utils.py#L644-L680
+    # In PEFT, we sometimes need to re-create the attention mask. This is because some prompt learning methods insert
+    # new items into the sequence, which results in the attention mask needing an update. We re-use transformers code
+    # for this as much as possible.
+    transformers_ge_4_53_1 = version.parse(transformers.__version__) >= version.parse("4.53.1")
+    if transformers_ge_4_53_1:
+        # the function already exists in v4.53.0 but has a different signature, so we check for 4.53.1
+        from transformers.masking_utils import create_masks_for_generate
+    else:
+        raise ImportError("Your transformers version is too old, please upgrade it to >= 4.53.1")
+
+    # Create the causal mask with fixed shape in advance, to reduce recompilations. If the function to create
+    # the 4D causal mask exists, it should be present in the base model (XXXModel class) or in its decoder.
+    base_model = getattr(model, model.base_model_prefix, model)
+    decoder = base_model.get_decoder() if hasattr(base_model, "get_decoder") else None
+    causal_mask_creation_function = getattr(base_model, "_prepare_4d_causal_attention_mask_with_cache_position", None)
+    if causal_mask_creation_function is None and decoder is not None:  # it may be in the decoder
+        causal_mask_creation_function = getattr(decoder, "_prepare_4d_causal_attention_mask_with_cache_position", None)
+
+    # If it's not defined, it means the model uses the new general mask API
+    if causal_mask_creation_function is None:  # can't be found
+        token_type_ids = getattr(model_input, "token_type_ids", None)
+        # Some models may overwrite the general one
+        causal_mask_creation_function = getattr(model, "create_masks_for_generate", create_masks_for_generate)
+        attention_mask = causal_mask_creation_function(
+            config=model.config,
+            # we only need batch size, seq_length and dtype here - we don't care about the values of the embeddings
+            input_embeds=torch.empty((batch_size, sequence_length), dtype=model.dtype),
+            attention_mask=attention_mask,
+            cache_position=cache_position,
+            past_key_values=past_key_values,
+            token_type_ids=token_type_ids,
+            position_ids=position_ids,
+        )
+    else:
+        attention_mask = causal_mask_creation_function(
+            attention_mask,
+            sequence_length=sequence_length,
+            target_length=past_key_values.get_max_cache_shape(),
+            dtype=model.dtype,
+            cache_position=cache_position,
+            batch_size=batch_size,
+            config=model.config,
+            past_key_values=past_key_values,
+            position_ids=position_ids,
+        )
+    return attention_mask
+
+
+def _get_module_names_tied_with_embedding(model) -> list[str]:
+    """
+    Get the list of the fully qualified names of the modules that are tied to the input embeddings. In case of a
+    source-target-mapping `_tied_weights_keys`, it will attempt to identify the input embedding weights from the
+    mapping and return the list of tied modules accordingly. This gives a unified interface to both transformers v4
+    tied weights and v5 mapped tied weights.
+
+    For example: For models which have `embed_tokens` and `lm_head` as the tied keys, this function will return
+    [`lm_head`]. The PEFT model is assumed to be transparent: returned names will be relative to the base model, so
+    even though `model.base_model.lm_head` is tied, the returned name is `lm_head` since such attributes are forwarded
+    to the base model anyway. Non-transformer models have to provide a `_tied_weights_keys` attribute for this function
+    to work.
+
+    If the model's config has `tie_word_embeddings` set to `False`, this function returns an empty list, as weight
+    tying is explicitly disabled for that model checkpoint.
+    """
+    tied_weights: list[str] = []
+
+    if hasattr(model, "get_base_model"):
+        # unpack PeftModel
+        model = model.get_base_model()
+
+    if hasattr(model, "tuner_layer_cls"):
+        # unpack BaseTuner
+        model = model.model
+
+    # `_tied_weights_keys` is architectural capability; `tie_word_embeddings=False` means tying is
+    # explicitly disabled for this checkpoint and must be respected.
+    model_config = getattr(model, "config", None)
+    if (
+        model_config is not None
+        and hasattr(model_config, "tie_word_embeddings")
+        and model_config.tie_word_embeddings is False
+    ):
+        return []
+
+    if not hasattr(model, "_tied_weights_keys"):
+        return []
+
+    base_layer_pattern = re.compile(r"[^.]+\.base_layer\.")
+
+    if isinstance(model._tied_weights_keys, dict):
+        if not hasattr(model, "get_input_embeddings"):
+            raise ValueError(
+                "The supplied model implements `_tied_weights_keys` as a dict but doesn't implement "
+                "'get_input_embeddings' so we can't determine which weights are tied to embeddings."
+            )
+
+        # collect all _tied_weights_keys, as sub-modules may have additional entries
+        tied_weights_keys: dict[str, str] = {}
+        for module_name, module in model.named_modules():
+            module_tied_weights_keys = getattr(module, "_tied_weights_keys", None)
+            if module_tied_weights_keys and not module_name:
+                tied_weights_keys.update(module_tied_weights_keys)
+            elif module_tied_weights_keys:
+                tied_weights_keys.update(
+                    {f"{module_name}.{k}": f"{module_name}.{v}" for k, v in module_tied_weights_keys.items()}
+                )
+
+        # technically it would be sufficient to just return candidates since that contains all the keys of
+        # all models that are tied (not just equal!) to the input embeddings. the only reason why we aren't
+        # doing that is because we need to filter out the original embedding name since we promise to just
+        # return the keys of the tying targets.
+        input_embedding_params = set(model.get_input_embeddings().parameters())
+        candidates = [n for n, p in model.named_parameters(remove_duplicate=False) if p in input_embedding_params]
+
+        # Consider the case that sources and targets are already wrapped by a PEFT method. In that case we won't
+        # find them by their old names. Therefore, we need to create a map of the new names to the old names so
+        # that we can translate back and forth.
+        peft_reverse_mapping = {base_layer_pattern.sub("", name): name for name in candidates}
+
+        # AuxiliaryTrainingWrapper don't have an adapter suffix but still have a base_layer attribute,
+        # add those as a potential translation.
+        peft_reverse_mapping.update(**{name.replace("base_layer.", ""): name for name in candidates})
+
+        tied_weights.extend(
+            peft_reverse_mapping.get(k, k)
+            for k, v in tied_weights_keys.items()
+            if peft_reverse_mapping.get(v, v) in candidates
+        )
+
+    elif model._tied_weights_keys is not None:
+        # TODO remove this when transformers <v5 is no longer supported
+        tied_weights.extend(model._tied_weights_keys)
+
+    # get module names from parameter names
+    return sorted({name.rpartition(".")[0] for name in tied_weights})
diff --git a/src/peft/utils/peft_types.py b/src/peft/utils/peft_types.py
new file mode 100644
index 0000000..328ae01
--- /dev/null
+++ b/src/peft/utils/peft_types.py
@@ -0,0 +1,199 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import enum
+from typing import Optional
+
+
+class PeftType(str, enum.Enum):
+    """
+    Enum class for the different types of adapters in PEFT.
+
+    Supported PEFT types:
+    - PROMPT_TUNING
+    - MULTITASK_PROMPT_TUNING
+    - P_TUNING
+    - PREFIX_TUNING
+    - LORA
+    - ADALORA
+    - BOFT
+    - ADAPTION_PROMPT
+    - IA3
+    - BEFT
+    - LOHA
+    - LOKR
+    - OFT
+    - XLORA
+    - POLY
+    - LN_TUNING
+    - VERA
+    - FROD
+    - FOURIERFT
+    - HRA
+    - BONE
+    - MISS
+    - RANDLORA
+    - SHIRA
+    - C3A
+    - ROAD
+    - WAVEFT
+    - OSF
+    - DELORA
+    - GRALORA
+    - ADAMSS
+    - DEFT
+    """
+
+    PROMPT_TUNING = "PROMPT_TUNING"
+    MULTITASK_PROMPT_TUNING = "MULTITASK_PROMPT_TUNING"
+    P_TUNING = "P_TUNING"
+    PREFIX_TUNING = "PREFIX_TUNING"
+    LORA = "LORA"
+    ADALORA = "ADALORA"
+    ADAMSS = "ADAMSS"
+    BOFT = "BOFT"
+    ADAPTION_PROMPT = "ADAPTION_PROMPT"
+    IA3 = "IA3"
+    BEFT = "BEFT"
+    LILY = "LILY"
+    LOHA = "LOHA"
+    LOKR = "LOKR"
+    OFT = "OFT"
+    POLY = "POLY"
+    LN_TUNING = "LN_TUNING"
+    VERA = "VERA"
+    FROD = "FROD"
+    PVERA = "PVERA"
+    FOURIERFT = "FOURIERFT"
+    GLORA = "GLORA"
+    XLORA = "XLORA"
+    HRA = "HRA"
+    VBLORA = "VBLORA"
+    UNILORA = "UNILORA"
+    CPT = "CPT"
+    MISS = "MISS"
+    RANDLORA = "RANDLORA"
+    ROAD = "ROAD"
+    TRAINABLE_TOKENS = "TRAINABLE_TOKENS"
+    HIRA = "HIRA"
+    SHIRA = "SHIRA"
+    C3A = "C3A"
+    WAVEFT = "WAVEFT"
+    OSF = "OSF"
+    DELORA = "DELORA"
+    GRALORA = "GRALORA"
+    CARTRIDGE = "CARTRIDGE"
+    TINYLORA = "TINYLORA"
+    PSOFT = "PSOFT"
+    PEANUT = "PEANUT"
+    DEFT = "DEFT"
+
+
+class TaskType(str, enum.Enum):
+    """
+    Enum class for the different types of tasks supported by PEFT.
+
+    Overview of the supported task types:
+    - SEQ_CLS: Text classification.
+    - SEQ_2_SEQ_LM: Sequence-to-sequence language modeling.
+    - CAUSAL_LM: Causal language modeling.
+    - TOKEN_CLS: Token classification.
+    - QUESTION_ANS: Question answering.
+    - FEATURE_EXTRACTION: Feature extraction. Provides the hidden states which can be used as embeddings or features
+      for downstream tasks.
+    """
+
+    SEQ_CLS = "SEQ_CLS"
+    SEQ_2_SEQ_LM = "SEQ_2_SEQ_LM"
+    CAUSAL_LM = "CAUSAL_LM"
+    TOKEN_CLS = "TOKEN_CLS"
+    QUESTION_ANS = "QUESTION_ANS"
+    FEATURE_EXTRACTION = "FEATURE_EXTRACTION"
+
+
+def register_peft_method(
+    *, name: str, config_cls, model_cls, prefix: Optional[str] = None, is_mixed_compatible=False
+) -> None:
+    """
+    Function to register a finetuning method like LoRA to be available in PEFT.
+
+    This method takes care of registering the PEFT method's configuration class, the model class, and optionally the
+    prefix.
+
+    Args:
+        name (str):
+            The name of the PEFT method. It must be unique.
+        config_cls:
+            The configuration class of the PEFT method.
+        model_cls:
+            The model class of the PEFT method.
+        prefix (Optional[str], optional):
+            The prefix of the PEFT method. It should be unique. If not provided, the name of the PEFT method is used as
+            the prefix.
+        is_mixed_compatible (bool, optional):
+            Whether the PEFT method is compatible with `PeftMixedModel`. If you're not sure, leave it as False
+            (default).
+
+    Example:
+
+        ```py
+        # inside of peft/tuners/my_peft_method/__init__.py
+        from peft.utils import register_peft_method
+
+        register_peft_method(name="my_peft_method", config_cls=MyConfig, model_cls=MyModel)
+        ```
+    """
+    from peft.mapping import (
+        PEFT_TYPE_TO_CONFIG_MAPPING,
+        PEFT_TYPE_TO_MIXED_MODEL_MAPPING,
+        PEFT_TYPE_TO_PREFIX_MAPPING,
+        PEFT_TYPE_TO_TUNER_MAPPING,
+    )
+
+    if name.endswith("_"):
+        raise ValueError(f"Please pass the name of the PEFT method without '_' suffix, got {name}.")
+
+    if not name.islower():
+        raise ValueError(f"The name of the PEFT method should be in lower case letters, got {name}.")
+
+    if name.upper() not in list(PeftType):
+        raise ValueError(f"Unknown PEFT type {name.upper()}, please add an entry to peft.utils.peft_types.PeftType.")
+
+    peft_type = getattr(PeftType, name.upper())
+
+    # model_cls can be None for prompt learning methods, which don't have dedicated model classes
+    if prefix is None:
+        prefix = name + "_"
+
+    if (
+        (peft_type in PEFT_TYPE_TO_CONFIG_MAPPING)
+        or (peft_type in PEFT_TYPE_TO_TUNER_MAPPING)
+        or (peft_type in PEFT_TYPE_TO_MIXED_MODEL_MAPPING)
+    ):
+        raise KeyError(f"There is already PEFT method called '{name}', please choose a unique name.")
+
+    if prefix in PEFT_TYPE_TO_PREFIX_MAPPING:
+        raise KeyError(f"There is already a prefix called '{prefix}', please choose a unique prefix.")
+
+    model_cls_prefix = getattr(model_cls, "prefix", None)
+    if (model_cls_prefix is not None) and (model_cls_prefix != prefix):
+        raise ValueError(
+            f"Inconsistent prefixes found: '{prefix}' and '{model_cls_prefix}' (they should be the same)."
+        )
+
+    PEFT_TYPE_TO_PREFIX_MAPPING[peft_type] = prefix
+    PEFT_TYPE_TO_CONFIG_MAPPING[peft_type] = config_cls
+    PEFT_TYPE_TO_TUNER_MAPPING[peft_type] = model_cls
+    if is_mixed_compatible:
+        PEFT_TYPE_TO_MIXED_MODEL_MAPPING[peft_type] = model_cls
diff --git a/src/peft/utils/quantization_utils.py b/src/peft/utils/quantization_utils.py
new file mode 100644
index 0000000..4c51539
--- /dev/null
+++ b/src/peft/utils/quantization_utils.py
@@ -0,0 +1,371 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+import copy
+import operator
+from abc import ABC
+from typing import Any, Literal
+
+import torch
+from torch import nn
+from transformers import PreTrainedModel
+
+from peft.import_utils import (
+    is_aqlm_available,
+    is_bnb_4bit_available,
+    is_bnb_available,
+    is_eetq_available,
+    is_gptqmodel_available,
+    is_hqq_available,
+    is_inc_available,
+    is_te_pytorch_available,
+    is_torchao_available,
+)
+from peft.utils.integrations import dequantize_bnb_weight
+from peft.utils.other import is_gptqmodel_awq_layer
+
+
+# extend if needed
+LayerType = Literal["linear", "embedding", "conv2d"]
+
+
+class QuantizationBackend(ABC):
+    """Base class for quantization backends used in PEFT layers.
+
+    A `QuantizationBackend` encapsulates the quantization-specific logic for accessing and modifying a base layer's
+    weights. By attaching an instance to a PEFT layer (`layer.quantization_backend = backend`), the PEFT layer's
+    `merge` / `unmerge` methods can work with quantized weights without needing a dedicated subclass.
+
+    Subclasses must implement `get_base_weight` and `set_base_weight` if they support merging.
+    """
+
+    # specify the type of layer intended for this backend; serves as a hint to the PEFT method to decide what tuner
+    # layer should be used
+    layer_type: LayerType
+    # Whether this backend supports merge/unmerge operations
+    supports_merge: bool = False
+    # user readable name
+    backend_name: str = ""
+
+    def get_base_weight(self, base_layer: nn.Module) -> torch.Tensor:
+        """Return the dequantized weight tensor from the base layer.
+
+        The returned tensor is a plain float tensor that can be modified. The caller is responsible for cloning if the
+        original must be preserved (e.g. for safe_merge).
+
+        Args:
+            base_layer: The quantized base layer module (e.g. `bnb.nn.Linear8bitLt`).
+
+        Returns:
+            Dequantized weight as a `torch.Tensor`.
+        """
+        raise NotImplementedError
+
+    def set_base_weight(self, peft_layer, weight_data: torch.Tensor) -> None:
+        """Store the (modified) weight back into the base layer, re-quantizing as needed.
+
+        Some backends (e.g. HQQ) replace `peft_layer.base_layer` entirely with a new module.
+
+        Args:
+            peft_layer:
+                The PEFT layer that owns the base layer. Provides access to `peft_layer.get_base_layer()` and allows
+                replacing `peft_layer.base_layer` when needed (e.g. HQQ).
+            weight_data:
+                The modified weight tensor to store.
+        """
+        raise NotImplementedError
+
+    def maybe_clone_base_result(self, x: torch.Tensor) -> torch.Tensor:
+        # As per Tim Dettmers, for 4bit bnb, we need to defensively clone here. The reason is that in some cases, an
+        # error can occur that backprop does not work on a manipulated view. This issue may be solved with newer PyTorch
+        # versions but this would need extensive testing to be sure.
+        # https://github.com/huggingface/peft/blob/58169b5e817e6053977ce82334d6c8d5ae3bed54/src/peft/tuners/lora/bnb.py#L524-L529
+        # By default, don't clone.
+        return x
+
+
+class ForwardOnlyQuantizationBackend(QuantizationBackend):
+    """Backend for quantization frameworks that do not support merging of weights.
+
+    Used for GPTQ etc. The forward pass works without modification because `base_layer(x)` already dispatches to the
+    quantized kernel. Merging and unmerging are either not implemented or not possible (e.g. no dequantize support).
+    """
+
+    supports_merge = False
+    layer_type = "linear"
+
+    def __init__(self, backend_name: str = "") -> None:
+        self.backend_name = backend_name
+
+    def get_base_weight(self, base_layer: nn.Module) -> torch.Tensor:
+        raise TypeError(
+            f"Dequantization is not supported for {self.backend_name} layers. Merging/unmerging is not available."
+        )
+
+    def set_base_weight(self, peft_layer, weight_data: torch.Tensor) -> None:
+        raise TypeError(
+            f"Requantization is not supported for {self.backend_name} layers. Merging/unmerging is not available."
+        )
+
+
+class Bnb8bitBackend(QuantizationBackend):
+    """Backend for bitsandbytes 8-bit quantized layers (`bnb.nn.Linear8bitLt`)."""
+
+    supports_merge = True
+    backend_name = "bnb 8bit"
+    layer_type = "linear"
+
+    def get_base_weight(self, base_layer: nn.Module) -> torch.Tensor:
+        weight = base_layer.weight
+        state = base_layer.state
+        if state.SCB is None:
+            state.SCB = weight.SCB
+
+        return dequantize_bnb_weight(weight, state=state)
+
+    def set_base_weight(self, peft_layer, weight_data: torch.Tensor) -> None:
+        import bitsandbytes as bnb
+
+        base_layer = peft_layer.get_base_layer()
+        weight = base_layer.weight
+        base_layer.weight = bnb.nn.Int8Params(
+            weight_data.to("cpu"), requires_grad=False, has_fp16_weights=weight.has_fp16_weights
+        ).to(weight.device)
+        base_layer.state.reset_grads()
+
+
+class Bnb4bitBackend(QuantizationBackend):
+    """Backend for bitsandbytes 4-bit quantized layers (`bnb.nn.Linear4bit`)."""
+
+    supports_merge = True
+    backend_name = "bnb 4bit"
+    layer_type = "linear"
+
+    def get_base_weight(self, base_layer: nn.Module) -> torch.Tensor:
+        weight = base_layer.weight
+        return dequantize_bnb_weight(weight, state=weight.quant_state)
+
+    def set_base_weight(self, peft_layer, weight_data: torch.Tensor) -> None:
+        import bitsandbytes as bnb
+
+        base_layer = peft_layer.get_base_layer()
+        weight = base_layer.weight
+        kwargs = weight.__dict__
+        if "bnb_quantized" in kwargs:
+            kwargs["bnb_quantized"] = False
+        kwargs["requires_grad"] = False
+        kwargs.pop("data", None)
+        # torch.compile can introduce attributes preceded by '_', remove them
+        kwargs = {k: v for k, v in kwargs.items() if not k.startswith("_")}
+        base_layer.weight = bnb.nn.Params4bit(weight_data.to("cpu"), **kwargs).to(weight.device)
+
+    def maybe_clone_base_result(self, x: torch.Tensor) -> torch.Tensor:
+        # As per Tim Dettmers, for 4bit bnb, we need to defensively clone here. The reason is that in some cases, an
+        # error can occur that backprop does not work on a manipulated view. This issue may be solved with newer PyTorch
+        # versions but this would need extensive testing to be sure.
+        # https://github.com/huggingface/peft/blob/58169b5e817e6053977ce82334d6c8d5ae3bed54/src/peft/tuners/lora/bnb.py#L524-L529
+        return x.clone()
+
+
+class HqqBackend(QuantizationBackend):
+    """Backend for HQQ quantized layers (`hqq.core.quantize.HQQLinear`)."""
+
+    supports_merge = True
+    backend_name = "hqq"
+    layer_type = "linear"
+
+    def get_base_weight(self, base_layer: nn.Module) -> torch.Tensor:
+        return base_layer.dequantize()
+
+    def set_base_weight(self, peft_layer, weight_data: torch.Tensor) -> None:
+        from hqq.core.quantize import HQQLinear
+
+        base_layer = peft_layer.get_base_layer()
+        quant_config = {**copy.deepcopy(base_layer.quant_config), "offload_meta": base_layer.offload_meta}
+
+        new_hqq_layer = HQQLinear(None, quant_config, compute_dtype=base_layer.compute_dtype, device=base_layer.device)
+        quant_config.pop("offload_meta", None)
+        new_hqq_layer.quantize(weight_data, **quant_config)
+
+        # HQQ requires replacing the entire base layer
+        peft_layer.base_layer = new_hqq_layer
+
+
+class TorchaoBackend(QuantizationBackend):
+    """Backend for torchao quantized layers.
+
+    Args:
+        get_apply_tensor_subclass:
+            A callable that returns the tensor subclass to use for re-quantization. This is stored from the original
+            quantization config and is needed to re-quantize after merging.
+    """
+
+    supports_merge = True
+    backend_name = "torchao"
+    layer_type = "linear"
+
+    def __init__(self, get_apply_tensor_subclass):
+        self.get_apply_tensor_subclass = get_apply_tensor_subclass
+
+    def get_base_weight(self, base_layer: nn.Module) -> torch.Tensor:
+        weight = base_layer.weight
+        try:
+            dequantized = weight.dequantize()
+        except NotImplementedError as exc:
+            msg = (
+                f"Weights of type {type(weight).__name__} do not support dequantization (yet), which is needed to "
+                "support merging."
+            )
+            raise NotImplementedError(msg) from exc
+        return dequantized
+
+    def set_base_weight(self, peft_layer, weight_data: torch.Tensor) -> None:
+        from torchao import quantize_
+
+        base_layer = peft_layer.get_base_layer()
+        # torchao does not support directly mutating the data, so we need to delete and re-assign the weight, then
+        # re-quantize through quantize_ which takes a module as input.
+        del base_layer.weight
+        base_layer.weight = weight_data
+        quantize_(base_layer, self.get_apply_tensor_subclass())
+
+
+def resolve_quantization_backend(base_layer: nn.Module, **kwargs) -> QuantizationBackend | None:
+    """Determine the appropriate quantization backend for a given base layer.
+
+    Inspects the type of `base_layer` and returns the matching `QuantizationBackend` instance, or `None` if the layer
+    is not quantized.
+
+    Args:
+        base_layer:
+            The base layer module to inspect.
+        **kwargs:
+            Additional keyword arguments needed by specific backends. Currently used:
+            - `get_apply_tensor_subclass` (callable): Required for torchao layers.
+
+    Returns:
+        A `QuantizationBackend` instance, or `None` if the layer is not quantized.
+    """
+    # bitsandbytes
+    if is_bnb_available():
+        import bitsandbytes as bnb
+
+        if isinstance(base_layer, bnb.nn.Linear8bitLt):
+            return Bnb8bitBackend()
+
+    # bitsandbytes
+    if is_bnb_4bit_available():
+        import bitsandbytes as bnb
+
+        if isinstance(base_layer, bnb.nn.Linear4bit):
+            return Bnb4bitBackend()
+
+    # HQQ
+    if is_hqq_available():
+        from hqq.core.quantize import HQQLinear
+
+        if isinstance(base_layer, HQQLinear):
+            return HqqBackend()
+
+    # torchao
+    if is_torchao_available():
+        from torchao.dtypes import AffineQuantizedTensor
+        from torchao.quantization import LinearActivationQuantizedTensor
+
+        if hasattr(base_layer, "weight") and isinstance(
+            base_layer.weight, (AffineQuantizedTensor, LinearActivationQuantizedTensor)
+        ):
+            get_apply_tensor_subclass = kwargs.get("get_apply_tensor_subclass")
+            if get_apply_tensor_subclass is None:
+                raise ValueError(
+                    "torchao quantized layer detected but 'get_apply_tensor_subclass' was not provided. "
+                    "This is required for merge/unmerge support."
+                )
+            backend = TorchaoBackend(get_apply_tensor_subclass)
+            if isinstance(base_layer.weight, LinearActivationQuantizedTensor):
+                backend.supports_merge = False
+            return backend
+
+    # AQLM
+    if is_aqlm_available():
+        from aqlm import QuantizedLinear
+
+        if isinstance(base_layer, QuantizedLinear):
+            return ForwardOnlyQuantizationBackend("aqlm")
+
+    # EETQ
+    if is_eetq_available():
+        from eetq import EetqLinear
+
+        if isinstance(base_layer, EetqLinear):
+            return ForwardOnlyQuantizationBackend("eetq")
+
+    # GPTQ (via gptqmodel)
+    if is_gptqmodel_available():
+        from gptqmodel.nn_modules.qlinear import BaseQuantLinear
+
+        if isinstance(base_layer, BaseQuantLinear):
+            return ForwardOnlyQuantizationBackend("gptq")
+
+    # AWQ (via gptqmodel)
+    if is_gptqmodel_available():
+        if is_gptqmodel_awq_layer(base_layer):
+            return ForwardOnlyQuantizationBackend("awq")
+
+    # INC (Intel Neural Compressor)
+    if is_inc_available():
+        from neural_compressor.torch.algorithms.fp8_quant._quant_common.helper_modules import PatchedLinear
+
+        if isinstance(base_layer, PatchedLinear):
+            return ForwardOnlyQuantizationBackend("inc")
+
+    # TransformerEngine
+    if is_te_pytorch_available():
+        import transformer_engine as te
+
+        if isinstance(base_layer, (te.pytorch.LayerNormLinear, te.pytorch.LayerNormMLP, te.pytorch.Linear)):
+            return ForwardOnlyQuantizationBackend("te")
+
+    # Not quantized
+    return None
+
+
+def quantization_extra_repr(module: nn.Module) -> str:
+    """Extend the repr of the PEFT module.
+
+    extra_repr is a method on nn.Modules that can be used to extend the repr of a module.
+    """
+    base = nn.Module.extra_repr(module)
+    parts = []
+    if base:
+        parts.append(base)
+    if getattr(module, "quantization_backend", None):
+        parts.append(f"quantization_backend='{module.quantization_backend.backend_name}'")
+    return ", ".join(parts)
+
+
+def get_quantization_kwargs(model: PreTrainedModel | nn.Module) -> dict[str, Any]:
+    """Helper function to extract arguments related to quantization from the model.
+
+    These arguments may, for instance, be needed to correctly deal with PEFT layers being applied to quantized layers.
+    """
+    quantization_kwargs = {}
+    try:
+        # torchao-specific function required to re-quantize layers
+        quantization_kwargs["get_apply_tensor_subclass"] = operator.attrgetter(
+            "hf_quantizer.quantization_config.get_apply_tensor_subclass"
+        )(model)
+    except AttributeError:
+        pass
+    return quantization_kwargs
diff --git a/src/peft/utils/save_and_load.py b/src/peft/utils/save_and_load.py
new file mode 100644
index 0000000..f5e910a
--- /dev/null
+++ b/src/peft/utils/save_and_load.py
@@ -0,0 +1,1103 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import copy
+import os
+import platform
+import re
+import warnings
+from collections import namedtuple
+from typing import Literal, Optional
+
+import huggingface_hub
+import torch
+from huggingface_hub import file_exists, hf_hub_download
+from huggingface_hub.errors import EntryNotFoundError, LocalEntryNotFoundError
+from safetensors.torch import load_file as safe_load_file
+from transformers.utils import http_user_agent
+
+from peft.import_utils import is_transformers_ge_v5
+from peft.mapping import PEFT_TYPE_TO_PREFIX_MAPPING
+
+from .constants import INCLUDE_LINEAR_LAYERS_SHORTHAND
+from .integrations import TpInfo
+from .other import (
+    EMBEDDING_LAYER_NAMES,
+    SAFETENSORS_WEIGHTS_NAME,
+    WEIGHTS_NAME,
+    AuxiliaryTrainingWrapper,
+    check_file_exists_on_hf_hub,
+    infer_device,
+    match_target_against_key,
+)
+from .peft_types import PeftType
+
+
+def has_valid_embedding_base_layer(layer):
+    """Check if the layer has an embedding base layer"""
+    return hasattr(layer, "base_layer") and isinstance(layer.base_layer, (torch.nn.Linear, torch.nn.Embedding))
+
+
+def get_embedding_layer_name(model, layer, is_embedding_in_target_modules):
+    """Get the name of the embedding module for a given layer."""
+    for name, module in model.named_modules():
+        if (not is_embedding_in_target_modules and module == layer) or module == getattr(layer, "base_layer", None):
+            return name
+    return None
+
+
+def _get_tp_info(model) -> TpInfo | None:
+    """Collect TP info from lora modules that have _tp_info set."""
+    tp_plan, device_mesh, tp_size = {}, None, None
+    # We check if there is a TP plan, otherwise it is not worth looping over the modules for nothing.
+    if getattr(model, "_tp_plan", None) is None:
+        return None
+    for module in model.modules():
+        if hasattr(module, "_tp_info"):
+            tp_plan.update(module._tp_info.tp_plan)
+            device_mesh = module._tp_info.device_mesh
+            tp_size = module._tp_info.tp_size
+    if tp_plan:
+        return TpInfo(tp_plan=tp_plan, device_mesh=device_mesh, tp_size=tp_size)
+    return None
+
+
+def _filter_state_dict_for_adapter_name(
+    state_dict: dict[str, torch.Tensor], unwanted_adapter_names: list[str]
+) -> dict[str, torch.Tensor]:
+    """Filter the state dict to remove keys that correspond to the unwanted adapter
+
+    Use a negative filter to avoid removing keys that correspond to keys that contain no adapter name at all, e.g. when
+    using modules_to_save.
+    """
+    return {
+        k: v
+        for k, v in state_dict.items()
+        if not any(
+            f".{adapter_name}." in k or k.endswith(f".{adapter_name}") for adapter_name in unwanted_adapter_names
+        )
+    }
+
+
+def get_peft_model_state_dict(
+    model,
+    state_dict=None,
+    adapter_name: str = "default",
+    unwrap_compiled: bool = False,
+    save_embedding_layers: bool | Literal["auto"] = "auto",
+):
+    """
+    Get the state dict of the given adapter of the PEFT model.
+
+    This only includes the PEFT parameters, not the parameters of the base model. Thus the returned `state_dict` is
+    generally small compared to the full model size. To retrieve the full `state_dict`, just call `model.state_dict()`.
+
+    Note that the adapter name is removed from the `state_dict`, as this is just an arbitrary name that can be changed
+    when loading the adapter. So e.g. if the adapter name is `'default'` and the original key is
+    `'model.q_proj.lora_A.default.weight'`, the returned key will be `'model.q_proj.lora_A.weight'`. Use this function
+    in conjunction with [`set_peft_model_state_dict`] to take care of the adapter name when loading weights.
+
+    Args:
+        model ([`PeftModel`]): The Peft model. When using torch.nn.DistributedDataParallel, DeepSpeed or FSDP,
+            the model should be the underlying model/unwrapped model (i.e. model.module).
+        state_dict (`dict`, *optional*, defaults to `None`):
+            The state dict of the model. If not provided, the state dict of the passed model will be used.
+        adapter_name (`str`, *optional*, defaults to `"default"`):
+            The name of the adapter whose state dict should be returned.
+        unwrap_compiled (`bool`, *optional*, defaults to `False`):
+            Whether to unwrap the model if torch.compile was used.
+        save_embedding_layers (`Union[bool, str]`, , *optional*, defaults to `auto`):
+            If `True`, save the embedding layers in addition to adapter weights. If `auto`, checks the common embedding
+            layers `peft.utils.other.EMBEDDING_LAYER_NAMES` in config's `target_modules` when available. Based on it
+            sets the boolean flag. This only works for 🤗 transformers models.
+
+    """
+    if unwrap_compiled:
+        model = getattr(model, "_orig_mod", model)
+
+    config = model.peft_config[adapter_name]
+    if state_dict is None:
+        state_dict = model.state_dict()
+
+    # FILTER FOR ADAPTER NAME
+    unwanted_adapter_names = [name for name in model.peft_config if name != adapter_name]
+    if not config.is_prompt_learning:
+        # Prompt learning methods don't support multiple adapters and hence don't have the adapter name in the Parameter
+        # name.
+        state_dict_filtered_for_adapter_name = _filter_state_dict_for_adapter_name(state_dict, unwanted_adapter_names)
+        if len(state_dict_filtered_for_adapter_name) > 0:
+            # If, after filtering the state dict for the adapter name, we end up with an empty state dict, it means that
+            # the adapter weights are not stored with the adapter name as suffix. This can happen e.g. for adaption
+            # prompt (which is not a prompt learning method).
+            state_dict = state_dict_filtered_for_adapter_name
+
+    # If model was sharded with TP, gather full tensors for saving
+    tp_info = _get_tp_info(model)
+    if tp_info is not None:
+        from transformers.integrations.tensor_parallel import gather_state_dict_for_save
+
+        from peft.peft_model import PeftModel
+
+        # If the keys in the state dict start with the prefix, we need to add the prefix to the keys in the tp plan as
+        # well.
+        prefix = (
+            "base_model."
+            if isinstance(model, PeftModel) and model.active_peft_config.is_prompt_learning
+            else "base_model.model."
+        )
+        keys_starting_with_prefix = all(k.startswith(prefix) for k in state_dict)
+        tp_plan = tp_info.tp_plan
+        if keys_starting_with_prefix:
+            tp_plan = {f"{prefix}{k}": v for k, v in tp_plan.items()}
+        state_dict = gather_state_dict_for_save(state_dict, tp_plan, tp_info.device_mesh, tp_info.tp_size)
+
+    # TUNER SPECIFIC CODE
+    if config.peft_type in (PeftType.LORA, PeftType.ADALORA):
+        # to_return = lora_state_dict(model, bias=model.peft_config.bias)
+        # adapted from `https://github.com/microsoft/LoRA/blob/main/loralib/utils.py`
+        # to be used directly with the state dict which is necessary when using DeepSpeed or FSDP
+        bias = config.bias
+        if bias == "none":
+            to_return = {k: state_dict[k] for k in state_dict if "lora_" in k}
+        elif bias == "all":
+            to_return = {k: state_dict[k] for k in state_dict if "lora_" in k or "bias" in k}
+        elif bias == "lora_only":
+            to_return = {}
+            for k in state_dict:
+                if "lora_" in k:
+                    to_return[k] = state_dict[k]
+                    bias_name = k.split("lora_")[0] + "bias"
+                    if bias_name in state_dict:
+                        to_return[bias_name] = state_dict[bias_name]
+        else:
+            raise NotImplementedError
+        to_return = {k: v for k, v in to_return.items() if (("lora_" in k) or ("bias" in k))}
+        if config.peft_type == PeftType.ADALORA:
+            rank_pattern = config.rank_pattern
+            if rank_pattern is not None:
+                rank_pattern = {k.replace(f".{adapter_name}", ""): v for k, v in rank_pattern.items()}
+                config.rank_pattern = rank_pattern
+                to_return = model.resize_state_dict_by_rank_pattern(rank_pattern, to_return, adapter_name)
+
+        if config.use_dora:
+            # Here we take care of a refactor of DoRA which changed lora_magnitude_vector from a ParameterDict to a
+            # ModuleDict with a DoraLayer instance. The old parameter is now the "weight" attribute of that layer. Since
+            # we want the state_dict format not to change, we remove the "weight" part.
+            new_dora_suffix = f"lora_magnitude_vector.{adapter_name}.weight"
+
+            def renamed_dora_weights(k):
+                if k.endswith(new_dora_suffix):
+                    k = k[:-7]  # remove ".weight"
+                return k
+
+            to_return = {renamed_dora_weights(k): v for k, v in to_return.items()}
+
+    elif config.peft_type == PeftType.BOFT:
+        bias = config.bias
+        if bias == "none":
+            to_return = {k: state_dict[k] for k in state_dict if "boft_" in k}
+        elif bias == "all":
+            to_return = {k: state_dict[k] for k in state_dict if "boft_" in k or "bias" in k}
+        elif bias == "boft_only":
+            to_return = {}
+            for k in state_dict:
+                if "boft_" in k:
+                    to_return[k] = state_dict[k]
+                    bias_name = k.split("boft_")[0] + "bias"
+                    if bias_name in state_dict:
+                        to_return[bias_name] = state_dict[bias_name]
+        else:
+            raise NotImplementedError
+
+    elif config.peft_type == PeftType.ADAPTION_PROMPT:
+        to_return = {k: state_dict[k] for k in state_dict if k.split(".")[-1].startswith("adaption_")}
+
+    elif config.is_prompt_learning:
+        to_return = {}
+        if config.peft_type == PeftType.MULTITASK_PROMPT_TUNING:
+            to_return["prefix_task_cols"] = model.prompt_encoder[adapter_name].prefix_task_cols
+            to_return["prefix_task_rows"] = model.prompt_encoder[adapter_name].prefix_task_rows
+            prompt_embeddings = model.prompt_encoder[adapter_name].embedding.weight
+        else:
+            if config.inference_mode:
+                prompt_embeddings = model.prompt_encoder[adapter_name].embedding.weight
+            else:
+                prompt_embeddings = model.get_prompt_embedding_to_save(adapter_name)
+        to_return["prompt_embeddings"] = prompt_embeddings
+
+    elif config.peft_type == PeftType.SHIRA:
+        shira_prefix = PEFT_TYPE_TO_PREFIX_MAPPING[config.peft_type]
+        to_return = {k: state_dict[k] for k in state_dict if shira_prefix in k}
+        if platform.system() == "Windows":
+            warnings.warn(
+                "Windows has issues saving integers into safetensors. Hence, we convert shira_indices to float32 "
+                "before saving on Windows OS. The shira_indices will always be converted to integers when loading."
+            )
+        for name, module in model.named_modules():
+            if hasattr(module, "shira_indices"):
+                for k, v in module.shira_indices.items():
+                    # Windows has some issues with saving integers into safetensors. Tests fail with some kind of
+                    # PermissionError. This results in failed tests, so we are converting indices to float32 before
+                    # saving and then converting them back to int when loading. This is happening only for Windows,
+                    # not for Linux and Mac-OS.
+                    to_return[f"{name}.shira_indices.{k}"] = (
+                        v.to(torch.float32) if platform.system() == "Windows" else v
+                    )
+                    # the above may contain other adapter names, so filter again
+                    to_return = _filter_state_dict_for_adapter_name(to_return, unwanted_adapter_names)
+
+    elif config.peft_type == PeftType.UNILORA:
+        theta_d_key = f"base_model.unilora_theta_d.{adapter_name}"
+        if theta_d_key not in state_dict:
+            raise KeyError(f"Expected UniLora parameter '{theta_d_key}' in the model state dict.")
+        to_return = {theta_d_key: state_dict[theta_d_key]}
+        if config.save_indices:
+            to_return.update(
+                {
+                    k: v
+                    for k, v in state_dict.items()
+                    if (("unilora_indices" in k or "unilora_scales" in k) and f".{adapter_name}" in k)
+                }
+            )
+
+    elif config.peft_type == PeftType.VERA:
+        vera_prefix = PEFT_TYPE_TO_PREFIX_MAPPING[config.peft_type]
+        to_return = {k: state_dict[k] for k in state_dict if vera_prefix in k}
+        if config.save_projection:
+            # TODO: adding vera_A and vera_B to `self.get_base_layer` would
+            # make name to match here difficult to predict.
+            if f"base_model.vera_A.{adapter_name}" not in state_dict:
+                raise ValueError(
+                    "Model was initialised to not save vera_A and vera_B but config now specifies to save projection!"
+                    " Set `config.save_projection` to `False`."
+                )
+            to_return["base_model.vera_A." + adapter_name] = state_dict["base_model.vera_A." + adapter_name]
+            to_return["base_model.vera_B." + adapter_name] = state_dict["base_model.vera_B." + adapter_name]
+    elif config.peft_type == PeftType.TINYLORA:
+        tinylora_prefix = PEFT_TYPE_TO_PREFIX_MAPPING[config.peft_type]
+        # Collect tinylora keys (A, B buffers) excluding:
+        # - tinylora_v: shared model-level params (handled separately below)
+        # - tinylora_P: projection buffers (conditionally saved based on save_projection)
+        to_return = {
+            k: state_dict[k]
+            for k in state_dict
+            if tinylora_prefix in k and ".tinylora_v." not in k and ".tinylora_P." not in k
+        }
+        # Handle model-level shared v vectors
+        # The keys have format "base_model.tinylora_v.{adapter_name}.{idx}"
+        # We strip the adapter name for saving: "base_model.tinylora_v.{idx}"
+        adapter_v_prefix = f"base_model.tinylora_v.{adapter_name}."
+        for k in state_dict:
+            if k.startswith(adapter_v_prefix):
+                new_key = k.replace(adapter_v_prefix, "base_model.tinylora_v.")
+                to_return[new_key] = state_dict[k]
+        # Save projection tensors P if save_projection is True; otherwise they'll be
+        # regenerated from projection_seed when loading
+        if config.save_projection:
+            for k in state_dict:
+                if ".tinylora_P." in k and adapter_name in k:
+                    to_return[k] = state_dict[k]
+    elif config.peft_type == PeftType.PVERA:
+        vera_prefix = PEFT_TYPE_TO_PREFIX_MAPPING[config.peft_type]
+        to_return = {k: state_dict[k] for k in state_dict if vera_prefix in k}
+        if config.save_projection:
+            # TODO: adding pvera_A and pvera_B to `self.get_base_layer` would
+            # make name to match here difficult to predict.
+            if f"base_model.pvera_A.{adapter_name}" not in state_dict:
+                raise ValueError(
+                    "Model was initialised to not save pvera_A and pvera_B but config now specifies to save projection!"
+                    + " Set `config.save_projection` to `False`."
+                )
+            to_return["base_model.pvera_A." + adapter_name] = state_dict["base_model.pvera_A." + adapter_name]
+            to_return["base_model.pvera_B." + adapter_name] = state_dict["base_model.pvera_B." + adapter_name]
+    elif config.peft_type == PeftType.FROD:
+        frod_prefix = PEFT_TYPE_TO_PREFIX_MAPPING[config.peft_type]
+        projection_prefixes = ("base_model.frod_V.", "base_model.frod_s_indices.", "base_model.frod_s_size.")
+        layer_projection_parts = (".frod_V.", ".frod_s_indices.", ".frod_s_size.", ".frod_U.")
+        to_return = {
+            k: state_dict[k]
+            for k in state_dict
+            if (frod_prefix in k) and (adapter_name in k) and not any(part in k for part in layer_projection_parts)
+        }
+        if config.save_projection:
+            to_return.update(
+                {
+                    k: state_dict[k]
+                    for k in state_dict
+                    if k.startswith(projection_prefixes) and k.endswith(f".{adapter_name}")
+                }
+            )
+    elif config.peft_type == PeftType.XLORA:
+        to_return = {k: state_dict[k] for k in state_dict if "internal_xlora_classifier" in k}
+    elif config.peft_type == PeftType.VBLORA:
+        to_return = {}
+        # choose the most efficient dtype for indices
+        if config.num_vectors < 2**8:
+            indices_dtype = torch.uint8
+        elif config.num_vectors < 2**15:
+            indices_dtype = torch.int16
+        elif config.num_vectors < 2**31:
+            indices_dtype = torch.int32
+        else:
+            indices_dtype = torch.int64
+        if config.save_only_topk_weights:
+            # in save_only_topk_weights mode, we save topk_indices and topk_weights for parameter efficiency
+            for k in state_dict:
+                if "vblora_logits" in k:
+                    logits, indices = state_dict[k].topk(config.topk)
+                    to_return.update({k + "_topk_indices": indices.to(dtype=indices_dtype)})
+                    to_return.update({k + "_topk_weights": torch.softmax(logits, dim=-1)[:, :, :-1].contiguous()})
+        else:
+            to_return = {k: state_dict[k] for k in state_dict if "vblora_logits" in k}
+        to_return["base_model.vblora_vector_bank." + adapter_name] = state_dict[
+            "base_model.vblora_vector_bank." + adapter_name
+        ]
+    elif config.peft_type in list(PeftType):
+        prefix = PEFT_TYPE_TO_PREFIX_MAPPING[config.peft_type]
+        to_return = {k: v for k, v in state_dict.items() if prefix in k}
+    else:
+        raise ValueError(f"Unknown PEFT type passed: {config.peft_type}")
+
+    # ADDITIONAL TRAINING MODULES / MODULES_TO_SAVE
+    for name, module in model.named_modules():
+        if isinstance(module, AuxiliaryTrainingWrapper):
+            if name.startswith("_fsdp_wrapped_module."):
+                # If FSDP is used, the state_dict is from the unwrapped model, which will result in a key mismatch if we
+                # don't remove the FSDP-specific prefix
+                name = name.removeprefix("_fsdp_wrapped_module.")
+            # Compute the module-relative state dict to make it easier for the adapter to fetch the appropriate
+            # keys that the module thinks need to be saved. We cannot rely on `.state_dict()` internally of the
+            # module since accelerators like DeepSpeed require special handling which is done for the model
+            # state dict from above but most likely not in the module itself. See #2450.
+            module_state_dict = {
+                k.removeprefix(f"{name}."): v for k, v in state_dict.items() if k.startswith(f"{name}.")
+            }
+            to_return.update(
+                {f"{name}.{k}": v for k, v in module.adapter_state_dict(adapter_name, module_state_dict).items()}
+            )
+
+    # DEAL WITH EMBEDDINGS
+    #
+    # save_embedding_layer="auto" needs to check the following logic:
+    #
+    # - when vocab size was NOT changed, embeddings should be saved only when targeted
+    # but not when
+    # - using PeftType.TRAINABLE_TOKENS
+    # - LoRA using trainable_token_indices (since their goal is to space-efficient)
+    # but
+    # - when vocab size was changed, embeddings should be saved automatically regardless to cover this
+    #   scenario: 1) fine-tune embedding, 2) resize embedding, 3) train with trainable tokens
+    #
+    embedding_is_targeted = False
+    if hasattr(config, "target_modules"):
+        if isinstance(config.target_modules, str) and (config.target_modules != INCLUDE_LINEAR_LAYERS_SHORTHAND):
+            # `model` could be a PeftModel or something else like transformers/diffusers/..., in which case unwrapping is
+            # not needed.
+            _model = model.get_base_model() if hasattr(model, "get_base_model") else model
+            embedding_is_targeted = any(
+                match_target_against_key(config.target_modules, k)
+                for k, _ in _model.named_modules()
+                if any(re.match(rf"(.*\.)?{e}$", k) for e in EMBEDDING_LAYER_NAMES)
+            )
+        elif config.target_modules:
+            embedding_is_targeted = any(k in config.target_modules for k in EMBEDDING_LAYER_NAMES)
+
+    using_trainable_tokens = (
+        config.peft_type == PeftType.TRAINABLE_TOKENS or getattr(config, "trainable_token_indices", None) is not None
+    )
+
+    if save_embedding_layers == "auto" and embedding_is_targeted and not using_trainable_tokens:
+        warnings.warn("Setting `save_embedding_layers` to `True` as embedding layers found in `target_modules`.")
+        save_embedding_layers = True
+    elif save_embedding_layers == "auto":
+        vocab_size = getattr(getattr(model, "config", None), "vocab_size", None)
+        model_id = getattr(config, "base_model_name_or_path", None)
+
+        # For some models e.g. diffusers the text config file is stored in a subfolder
+        # we need to make sure we can download that config.
+        has_base_config = False
+
+        # ensure that this check is not performed in HF offline mode, see #1452
+        if model_id is not None:
+            local_config_exists = os.path.exists(os.path.join(model_id, "config.json"))
+            exists = local_config_exists or check_file_exists_on_hf_hub(model_id, "config.json")
+            if exists is None:
+                # check failed, could not determine if it exists or not
+                warnings.warn(
+                    f"Could not find a config file in {model_id} - will assume that the vocabulary was not modified."
+                )
+                has_base_config = False
+            else:
+                has_base_config = exists
+
+        # check if the vocab size of the base model is different from the vocab size of the finetuned model
+        if (
+            vocab_size
+            and model_id
+            and has_base_config
+            and (vocab_size != model.config.__class__.from_pretrained(model_id).vocab_size)
+        ):
+            warnings.warn(
+                "Setting `save_embedding_layers` to `True` as the embedding layer has been resized during finetuning."
+            )
+            save_embedding_layers = True
+        else:
+            save_embedding_layers = False
+
+    if save_embedding_layers and hasattr(model, "get_input_embeddings"):
+        for layer in [model.get_input_embeddings(), model.get_output_embeddings()]:
+            # Either the layer is not targeted, then it must have been resized and needs saving. Or it is targeted and
+            # therefore has a valid base layer, then we'll save it as well.
+            if not embedding_is_targeted or has_valid_embedding_base_layer(layer):
+                embedding_module_name = get_embedding_layer_name(model, layer, embedding_is_targeted)
+                if embedding_module_name:
+                    to_return.update({k: v for k, v in state_dict.items() if embedding_module_name in k})
+    elif save_embedding_layers:
+        warnings.warn("Could not identify embedding layer(s) because the model is not a 🤗 transformers model.")
+
+    # REMOVE ADAPTER NAME
+    # Ensure not to replace in the middle of the key because a module happens to have the same name as the adapter.
+    pattern = re.compile(re.escape(f".{adapter_name}") + r"$")
+
+    def remove_adapter_name(key):
+        if "." not in key:
+            # nothing to do
+            return key
+
+        if config.peft_type == PeftType.PEANUT:
+            # PEANuT stores residual blocks as ModuleDict[adapter] -> ModuleList.
+            # Their keys look like `...peanut_encoders.<adapter>.0.weight` (and similarly for decoders),
+            # where adapter_name is not in the second-to-last position.
+            for container in ("peanut_encoders", "peanut_decoders"):
+                marker = f".{container}.{adapter_name}."
+                if marker in key:
+                    return key.replace(marker, f".{container}.")
+
+        if key.endswith(f".{adapter_name}"):
+            # comes from an nn.Parameter, so no .weight suffix, the adapter name is directly at the end
+            return key.removesuffix(f".{adapter_name}")
+
+        # comes from an nn.Module, i.e. the adapter name is the 2nd to last element, e.g. v_proj.lora_A.default.weight
+        key, _, suffix = key.rpartition(".")  # split, e.g. v_proj.lora_A.default + weight
+
+        if (config.peft_type == PeftType.VBLORA) and suffix.startswith(f"{adapter_name}_"):
+            # special case: VBLoRA creates keys that require this replacement:
+            # base_model.model.lin0.vblora_logits_A.default_topk_indices =>
+            # base_model.model.lin0.vblora_logits_A_topk_indices
+            return key + "_" + suffix.removeprefix(f"{adapter_name}_")
+
+        key = pattern.sub("", key)  # remove adapter name, e.g. v_proj.lora_A
+        return f"{key}.{suffix}"  # stitch the suffix back, e.g, v_proj.lora_A.weight
+
+    to_return = {remove_adapter_name(k): v for k, v in to_return.items()}
+    return to_return
+
+
+def _find_mismatched_keys(
+    model: torch.nn.Module, peft_model_state_dict: dict[str, torch.Tensor], ignore_mismatched_sizes: bool = False
+) -> tuple[dict[str, torch.Tensor], list[tuple[str, tuple[int, ...], tuple[int, ...]]]]:
+    if not ignore_mismatched_sizes:
+        return peft_model_state_dict, []
+
+    mismatched = []
+    state_dict = model.state_dict()
+    for key, tensor in peft_model_state_dict.items():
+        if key not in state_dict:
+            continue
+
+        # see https://github.com/huggingface/transformers/blob/09f9f566de83eef1f13ee83b5a1bbeebde5c80c1/src/transformers/modeling_utils.py#L3858-L3864
+        if (state_dict[key].shape[-1] == 1) and (state_dict[key].numel() * 2 == tensor.numel()):
+            # This skips size mismatches for 4-bit weights. Two 4-bit values share an 8-bit container, causing size
+            # differences. Without matching with module type or parameter type it seems like a practical way to detect
+            # valid 4bit weights.
+            continue
+
+        if state_dict[key].shape != tensor.shape:
+            mismatched.append((key, tensor.shape, state_dict[key].shape))
+
+    for key, _, _ in mismatched:
+        del peft_model_state_dict[key]
+
+    return peft_model_state_dict, mismatched
+
+
+def _insert_adapter_name_into_state_dict(
+    state_dict: dict[str, torch.Tensor], adapter_name: str, parameter_prefix: str
+) -> dict[str, torch.Tensor]:
+    """Utility function to remap the state_dict keys to fit the PEFT model by inserting the adapter name."""
+    peft_model_state_dict = {}
+    for key, val in state_dict.items():
+        if parameter_prefix in key:
+            _, _, suffix = key.rpartition(parameter_prefix)
+            if "." in suffix:
+                suffix_to_replace = ".".join(suffix.split(".")[1:])
+                # only replace the substring if the key ends on the substring to avoid accidental replacement inside of
+                # the key if a module happens to have a name that contains the substring
+                key = re.sub(re.escape(suffix_to_replace) + r"$", f"{adapter_name}.{suffix_to_replace}", key)
+            else:
+                key = f"{key}.{adapter_name}"
+            peft_model_state_dict[key] = val
+        else:
+            peft_model_state_dict[key] = val
+    return peft_model_state_dict
+
+
+def _maybe_shard_state_dict_for_tp(model, state_dict, adapter_name):
+    """
+    Shard LoRA adapter weights in-place in `state_dict` according to the tensor-parallel plan of the model.
+
+    Args:
+        model (`nn.Module`): The TP base model (with `_hf_tp_plan` and `_hf_device_mesh` set on its layers).
+        state_dict (`dict`): The adapter state dict to shard in-place (as loaded from a checkpoint).
+        adapter_name (`str`): The name of the adapter whose weights are being sharded.
+    """
+    from ..tuners.lora.layer import LoraLayer  # lazy import to avoid circular import
+
+    tp_lora_modules = []
+    for name, module in model.named_modules():
+        if not isinstance(module, LoraLayer):
+            continue
+
+        base_layer = module.get_base_layer()
+        tp_plan = getattr(base_layer, "_hf_tp_plan", None)
+        device_mesh = getattr(base_layer, "_hf_device_mesh", None)
+        if tp_plan is None or device_mesh is None:
+            continue
+
+        tp_lora_modules.append((name, module, base_layer, tp_plan, device_mesh))
+
+    if not tp_lora_modules:
+        return
+
+    from transformers.integrations.tensor_parallel import (
+        ALL_PARALLEL_STYLES,
+        ColwiseParallel,
+        EmbeddingParallel,
+        RowwiseParallel,
+    )
+
+    should_check = True
+    prefix_to_remove = None
+    prefix_to_add = None
+    adapter_name_in_key = ""
+
+    possible_prefixes = ["base_model.model.", "base_model."]
+
+    for name, module, base_layer, tp_plan, device_mesh in tp_lora_modules:
+        device = base_layer.weight.device
+
+        # One time check to make sure we are adding / removing a potential prefix to get the proper key in the state
+        # dict. Same thing for the adapter name.
+        if should_check:
+            for key in state_dict:
+                if adapter_name in key:
+                    adapter_name_in_key = f".{adapter_name}"
+                    break
+
+            for key in state_dict:
+                key_prefix = ""
+                name_prefix = ""
+                for p in possible_prefixes:
+                    if key.startswith(p):
+                        key_prefix = p
+                        break
+                for p in possible_prefixes:
+                    if name.startswith(p):
+                        name_prefix = p
+                        break
+                if key_prefix != name_prefix:
+                    prefix_to_add = key_prefix
+                    prefix_to_remove = name_prefix
+                    break
+
+            should_check = False
+
+        if prefix_to_remove:
+            name = name.removeprefix(prefix_to_remove)
+        if prefix_to_add:
+            name = prefix_to_add + name
+
+        # We create and initialize the TensorParallelLayer on the fly,
+        # and we set the `empty_param` attribute depending on the proper
+        # state dict key to shard.
+        # This attribute is used by the sharding logic for shape reference,
+        # it must be of the same shape as the parameter to shard.
+        tp_layer = copy.deepcopy(ALL_PARALLEL_STYLES[tp_plan])
+        tp_layer.device_mesh = device_mesh
+        tp_layer.rank = device_mesh.get_local_rank()
+
+        weight = None
+        sharded = None
+        if isinstance(tp_layer, ColwiseParallel):
+            key = f"{name}.lora_B{adapter_name_in_key}.weight"
+        elif isinstance(tp_layer, RowwiseParallel):
+            key = f"{name}.lora_A{adapter_name_in_key}.weight"
+        elif isinstance(tp_layer, EmbeddingParallel):
+            # The state dict can contain the original base embedding weights if `save_embedding_layers` is
+            # set to `True` and the embedding layer is targeted. In that case, we need to shard those
+            # weights as well.
+            embedding_key = f"{name}.base_layer.weight"
+            if embedding_key in state_dict:
+                tp_layer.empty_param = state_dict[embedding_key]
+                state_dict[embedding_key] = tp_layer.shard_tensor(state_dict[embedding_key], device=device)
+            key = f"{name}.lora_embedding_A{adapter_name_in_key}"
+            # We transpose the lora_embedding_A weights because they are of shape (rank, num_embeddings) in
+            # the state dict
+            weight = state_dict[key].T
+            tp_layer.empty_param = weight
+            sharded = tp_layer.shard_tensor(weight, device=device)
+            # We transpose back because LoraEmbedding expects the weights to be of shape (rank, num_embeddings)
+            sharded = sharded.T
+        else:
+            raise TypeError(f"Unknown tensor parallel plan {tp_plan} for {module.__class__.__name__}.")
+
+        if weight is None:
+            weight = state_dict[key]
+        if sharded is None:
+            tp_layer.empty_param = weight
+            sharded = tp_layer.shard_tensor(weight, device=device)
+
+        tp_layer.empty_param = weight
+        state_dict[key] = sharded
+
+
+def set_peft_model_state_dict(
+    model,
+    peft_model_state_dict,
+    adapter_name="default",
+    ignore_mismatched_sizes: bool = False,
+    low_cpu_mem_usage: bool = False,
+) -> namedtuple:
+    """
+    Set the state dict of the PEFT model.
+
+    Given a PEFT `state_dict` (as returned by [`get_peft_model_state_dict`]), insert the weights into the model. The
+    model needs to have the PEFT adapters already in place (e.g. via [`inject_adapter_in_model`]).
+
+    Setting the adapter weights also takes care of re-inserting the adapter name. This name may be a different name
+    than the one originally used to train the adapter.
+
+    Args:
+        model ([`PeftModel`]):
+            The Peft model.
+        peft_model_state_dict (`dict`):
+            The state dict of the Peft model.
+        adapter_name (`str`, *optional*, defaults to `"default"`):
+            The name of the adapter whose state dict should be set.
+        ignore_mismatched_sizes (`bool`, *optional*, defaults to `False`):
+            Whether to ignore mismatched in the state dict.
+        low_cpu_mem_usage (`bool`, `optional`, defaults to `False`):
+            This argument must be `True` if the `model` was loaded with adapter weights on the meta device, e.g. after
+            calling `inject_adapter_in_model` with `low_cpu_mem_usage=True`. Otherwise, leave it as `False`.
+
+    Returns:
+        load_result (`_IncompatibleKeys`)
+            A named tuple with `missing_keys` and `unexpected_keys` fields.
+
+    """
+    config = model.peft_config[adapter_name]
+    state_dict = peft_model_state_dict
+
+    is_like_transformers_model = hasattr(getattr(model, "config", None), "model_type")
+    if is_transformers_ge_v5 and is_like_transformers_model:
+        # apply transformers v5 weight conversion to the state_dict, if necessary
+        from peft.utils.transformers_weight_conversion import convert_peft_adapter_state_dict_for_transformers
+
+        state_dict = convert_peft_adapter_state_dict_for_transformers(
+            model=model,
+            peft_config=config,
+            adapter_state_dict=state_dict,
+            adapter_name=adapter_name,
+        )
+
+    # handle auxiliary training wrappers such as ModulesToSaveWrapper and TrainableTokensWrapper by getting each of
+    # them and translating saved state dict key (which does not include the adapter name) to loaded state dict key
+    # (which includes the adapter name).
+    for name, module in model.named_modules():
+        if isinstance(module, AuxiliaryTrainingWrapper):
+            # Not every module has a 1:1 mapping. ModulesToSaveWrapper, for example, removes the
+            # `modules_to_save.{adapter_name}.` prefix. This prefix must be restored when loading the model from the
+            # saved state dict which is why we fetch a load key map from the wrapper.
+            key_map = module.adapter_state_dict_load_map(adapter_name)
+            if name.startswith("_fsdp_wrapped_module."):
+                # If FSDP is used, the state_dict is from the unwrapped model, which will result in a key mismatch if we
+                # don't remove the FSDP-specific prefix
+                name = name.removeprefix("_fsdp_wrapped_module.")
+            for k in key_map:
+                lookup_key = f"{name}.{k}"
+                store_key = f"{name}.{key_map[k]}"
+
+                state_dict[store_key] = peft_model_state_dict[lookup_key]
+
+                # delete the old key from the previous `state_dict = peft_model_state_dict` statement.
+                del state_dict[lookup_key]
+
+    if config.is_prompt_learning or config.peft_type == PeftType.ADAPTION_PROMPT or config.peft_type == PeftType.XLORA:
+        peft_model_state_dict = state_dict
+    elif config.peft_type in PEFT_TYPE_TO_PREFIX_MAPPING:
+        peft_model_state_dict = {}
+        parameter_prefix = PEFT_TYPE_TO_PREFIX_MAPPING[config.peft_type]
+        if config.peft_type == PeftType.VBLORA and config.save_only_topk_weights:
+            num_vectors, _ = model.vblora_vector_bank[adapter_name].shape
+            state_dict_keys = list(state_dict.keys())
+            for k in state_dict_keys:
+                # in save_only_topk_weights mode, only topk_indices and topk_weights are saved
+                # note that topk_indices and topk_weights serve as an efficient representation of the logits
+                # so we need to recover the logits from the topk_indices and topk_weights
+                if "_topk_indices" in k:
+                    v = state_dict[k].to(torch.long)
+                    original_key = k.replace("_topk_indices", "")
+                    # find the corresponding topk_weights from the state_dict
+                    topk_weights = state_dict[k.replace("_topk_indices", "_topk_weights")]
+                    # as we only save the first k-1 topk_weights, here we recover the last one
+                    topk_weights = torch.cat([topk_weights, 1 - topk_weights.sum(-1, keepdim=True)], dim=-1)
+                    # convert the weights to logits
+                    topk_logits = torch.log(topk_weights)
+                    matrix = (
+                        torch.zeros([*(topk_logits.shape[:-1]), num_vectors])
+                        .fill_(float("-inf"))
+                        .to(topk_logits.device)
+                        .scatter(-1, v, topk_logits)
+                    )
+                    # add logits to the state_dict
+                    state_dict[original_key] = matrix
+                    # delete the topk_indices and topk_weights from the state_dict
+                    del state_dict[k]
+                    del state_dict[k.replace("_topk_indices", "_topk_weights")]
+
+        # For TinyLora, handle tinylora_v keys separately since they use a nested structure
+        # that doesn't follow the standard "{prefix}.{adapter_name}" pattern
+        tinylora_v_state_dict = {}
+        if config.peft_type == PeftType.TINYLORA:
+            # Extract tinylora_v keys before _insert_adapter_name_into_state_dict
+            # The saved keys are like "base_model.tinylora_v.{idx}"
+            # We need to transform them to "base_model.tinylora_v.{adapter_name}.{idx}"
+            tinylora_v_keys = [k for k in state_dict if ".tinylora_v." in k]
+            for k in tinylora_v_keys:
+                new_key = k.replace(".tinylora_v.", f".tinylora_v.{adapter_name}.")
+                tinylora_v_state_dict[new_key] = state_dict.pop(k)
+
+        frod_projection_state_dict = {}
+        if config.peft_type == PeftType.FROD:
+            frod_projection_prefixes = ("base_model.frod_V.", "base_model.frod_s_indices.", "base_model.frod_s_size.")
+            frod_projection_keys = [k for k in state_dict if k.startswith(frod_projection_prefixes)]
+            for k in frod_projection_keys:
+                frod_projection_state_dict[f"{k}.{adapter_name}"] = state_dict.pop(k)
+
+        peft_model_state_dict = _insert_adapter_name_into_state_dict(
+            state_dict, adapter_name=adapter_name, parameter_prefix=parameter_prefix
+        )
+
+        # Add back the tinylora_v keys (now in the correct format)
+        if config.peft_type == PeftType.TINYLORA:
+            peft_model_state_dict.update(tinylora_v_state_dict)
+        elif config.peft_type == PeftType.FROD:
+            peft_model_state_dict.update(frod_projection_state_dict)
+
+        if config.peft_type == PeftType.ADALORA:
+            rank_pattern = config.rank_pattern
+            if rank_pattern is not None:
+                model.resize_modules_by_rank_pattern(rank_pattern, adapter_name)
+        elif config.peft_type == PeftType.SHIRA:
+            if platform.system() == "Windows":
+                warnings.warn(
+                    "Windows has issues saving integers into safetensors. Hence, we had converted shira_indices "
+                    "to float32 before saving on Windows OS. The shira_indices will always be converted to integers "
+                    "when loading."
+                )
+            for name, module in model.named_modules():
+                if hasattr(module, "shira_indices"):
+                    # for k, v in module.shira_indices.items():
+                    if f"{name}.shira_indices.{adapter_name}" in peft_model_state_dict:
+                        shira_indices_values = peft_model_state_dict.pop(f"{name}.shira_indices.{adapter_name}")
+                        # Convert shira_indices to int in case they were saved on a Windows OS and are being loaded
+                        # on a Linux or a Mac-OS system. If they were saved in Linux or Mac-OS, they are already
+                        # integers and the following will not affect anything.
+                        module.shira_indices[adapter_name] = shira_indices_values.to(torch.int)
+        elif config.peft_type == PeftType.VERA:
+            if config.save_projection and "base_model.vera_A" not in peft_model_state_dict:
+                raise ValueError(
+                    "Specified to load vera_A and vera_B from state dictionary however they were not present!"
+                )
+            elif not config.save_projection and "base_model.vera_A" in peft_model_state_dict:
+                warnings.warn(
+                    "Specified to not load vera_A and vera_B from state dictionary however they are present in state"
+                    " dictionary! Consider using them to ensure checkpoint loading is correct on all platforms using"
+                    " `peft_config.save_projection = True`"
+                )
+            elif not config.save_projection:  # and no vera_A in state dictionary
+                warnings.warn(
+                    "Specified to not load vera_A and vera_B from state dictionary. This means we will be relying on"
+                    " PRNG initialisation to restore these projections using `config.projection_prng_key`, which may"
+                    " not be accurate on all system configurations."
+                )
+        elif config.peft_type == PeftType.TINYLORA:
+            has_projection = any(".tinylora_P." in k for k in peft_model_state_dict)
+            if config.save_projection and not has_projection:
+                warnings.warn(
+                    "Specified to load tinylora_P from state dictionary however it was not present! "
+                    "Projection tensors will be regenerated from the projection_seed."
+                )
+            elif not config.save_projection and has_projection:
+                warnings.warn(
+                    "Specified to not load tinylora_P from state dictionary however they are present in state"
+                    " dictionary! Consider using them to ensure checkpoint loading is correct on all platforms using"
+                    " `peft_config.save_projection = True`"
+                )
+            elif not config.save_projection:  # and no tinylora_P in state dictionary
+                warnings.warn(
+                    "Specified to not load tinylora_P from state dictionary. This means we will be relying on"
+                    " PRNG initialisation to restore these projections using `config.projection_seed`, which may"
+                    " not be accurate on all system configurations."
+                )
+        elif config.peft_type == PeftType.PVERA:
+            if config.save_projection and "base_model.pvera_A" not in peft_model_state_dict:
+                raise ValueError(
+                    "Specified to load pvera_A and pvera_B from state dictionary however they were not present!"
+                )
+            elif not config.save_projection and "base_model.pvera_A" in peft_model_state_dict:
+                warnings.warn(
+                    "Specified to not load pvera_A and pvera_B from state dictionary however they are present in state"
+                    " dictionary! Consider using them to ensure checkpoint loading is correct on all platforms using"
+                    " `peft_config.save_projection = True`"
+                )
+            elif not config.save_projection:  # and no vera_A in state dictionary
+                warnings.warn(
+                    "Specified to not load pvera_A and pvera_B from state dictionary. This means we will be relying on"
+                    " PRNG initialisation to restore these projections using `config.projection_prng_key`, which may"
+                    " not be accurate on all system configurations."
+                )
+        elif config.peft_type == PeftType.FROD:
+            has_projection = any(
+                k.startswith(("base_model.frod_V.", "base_model.frod_s_indices.", "base_model.frod_s_size."))
+                for k in peft_model_state_dict
+            )
+            if config.save_projection and not has_projection:
+                raise ValueError(
+                    "Specified to load FRoD projection tensors from state dictionary however they were not present. "
+                    "If this checkpoint was saved with `save_projection=False`, set `peft_config.save_projection` "
+                    "to `False` before loading so the projections are regenerated from the base model weights. "
+                    "Otherwise, re-save the adapter with `save_projection=True` to include these tensors."
+                )
+            elif not config.save_projection and has_projection:
+                warnings.warn(
+                    "Specified to not load FRoD projection tensors from state dictionary however they are present. "
+                    "Consider using them to ensure checkpoint loading is correct by setting "
+                    "`peft_config.save_projection = True`."
+                )
+        elif config.peft_type == PeftType.LORA:
+            # Here we take care of a refactor of DoRA which changed lora_magnitude_vector from a ParameterDict to a
+            # ModuleDict with a DoraLayer instance. The old parameter is now the "weight" attribute of that layer.
+            old_dora_suffix = f"lora_magnitude_vector.{adapter_name}"
+
+            def renamed_dora_weights(k):
+                if k.endswith(old_dora_suffix):
+                    k = k + ".weight"
+                return k
+
+            peft_model_state_dict = {renamed_dora_weights(k): v for k, v in peft_model_state_dict.items()}
+
+            if torch.distributed.is_available() and torch.distributed.is_initialized():
+                _maybe_shard_state_dict_for_tp(model, peft_model_state_dict, adapter_name)
+
+        elif config.peft_type == PeftType.OFT:
+            if any(".oft_r." in key for key in peft_model_state_dict):
+                raise ValueError(
+                    "Trying to load old OFT checkpoint, which is no longer supported. Please install PEFT <= v0.15.2 to load it or train a new OFT adapter."
+                )
+    else:
+        raise NotImplementedError
+
+    # Updating the state dict for Transformers weight conversion with convert_peft_adapter_state_dict_for_transformers
+    # can introduce the base model prefix, but when loading the state_dict directly into the model (i.e. no PeftModel,
+    # e.g. when using set_peft_model_state_dict), there is no prefix.
+    prefix = "base_model.model."
+    requires_prefix = any(n.startswith(prefix) for n, _ in model.named_parameters())
+    if not requires_prefix:
+        peft_model_state_dict = {k.removeprefix(prefix): v for k, v in peft_model_state_dict.items()}
+
+    peft_model_state_dict, mismatched_keys = _find_mismatched_keys(
+        model, peft_model_state_dict, ignore_mismatched_sizes=ignore_mismatched_sizes
+    )
+    if low_cpu_mem_usage:
+        load_result = model.load_state_dict(peft_model_state_dict, strict=False, assign=True)
+        # ensure that the correct device is set
+        for module in model.modules():
+            if hasattr(module, "_move_adapter_to_device_of_base_layer"):
+                module._move_adapter_to_device_of_base_layer(adapter_name)
+    else:
+        load_result = model.load_state_dict(peft_model_state_dict, strict=False)
+
+    if config.is_prompt_learning:
+        if config.peft_type == PeftType.CARTRIDGE:
+            model.prompt_encoder[adapter_name].load_prompt_embeddings(peft_model_state_dict["prompt_embeddings"])
+        else:
+            model.prompt_encoder[adapter_name].embedding.load_state_dict(
+                {"weight": peft_model_state_dict["prompt_embeddings"]}, strict=True
+            )
+
+    if config.peft_type == PeftType.MULTITASK_PROMPT_TUNING:
+        model.prompt_encoder[adapter_name].load_state_dict(peft_model_state_dict, strict=False)
+
+    if mismatched_keys:
+        # see https://github.com/huggingface/transformers/blob/09f9f566de83eef1f13ee83b5a1bbeebde5c80c1/src/transformers/modeling_utils.py#L4039
+        mismatched_warning = "\n".join(
+            [
+                f"- {key}: found shape {shape1} in the checkpoint and {shape2} in the model instantiated"
+                for key, shape1, shape2 in mismatched_keys
+            ]
+        )
+        msg = (
+            f"Some weights of {model.__class__.__name__} were not initialized from the model checkpoint "
+            f"and are being ignored because you passed `ignore_mismatched_sizes=True`: {mismatched_warning}."
+        )
+        warnings.warn(msg)
+    return load_result
+
+
+# TODO: remove this function, use vanilla torch.load as soon as torch < 2.6.0 is no longer supported
+def torch_load(*args, weights_only=True, **kwargs):
+    """Call torch.load and handle weights_only.
+
+    Defaults to weights_only=True to anticipate upcoming switch on the PyTorch side.
+
+    """
+    return torch.load(*args, weights_only=weights_only, **kwargs)
+
+
+def load_peft_weights(
+    model_id: str, device: Optional[str] = None, key_mapping: Optional[dict[str, str]] = None, **hf_hub_download_kwargs
+) -> dict:
+    r"""
+    A helper method to load the PEFT weights from the HuggingFace Hub or locally
+
+    Args:
+        model_id (`str`):
+            The local path to the adapter weights or the name of the adapter to load from the HuggingFace Hub.
+        device (`str`):
+            The device to load the weights onto.
+        key_mapping (dict, *optional*, defaults to None)
+            Extra mapping of PEFT `state_dict` keys applied before loading the `state_dict`. When this mapping is
+            applied, the PEFT-specific `"base_model.model"` prefix is removed beforehand and the adapter name (e.g.
+            `"default"`) is not inserted yet. Only pass this argument if you know what you're doing.
+        hf_hub_download_kwargs (`dict`):
+            Additional arguments to pass to the `hf_hub_download` method when loading from the HuggingFace Hub.
+    """
+    path = (
+        os.path.join(model_id, hf_hub_download_kwargs["subfolder"])
+        if hf_hub_download_kwargs.get("subfolder", None) is not None
+        else model_id
+    )
+
+    if device is None:
+        device = infer_device()
+
+    def get_hub_filename(use_safetensors=True):
+        weights_name = SAFETENSORS_WEIGHTS_NAME if use_safetensors else WEIGHTS_NAME
+        return (
+            os.path.join(hf_hub_download_kwargs["subfolder"], weights_name)
+            if hf_hub_download_kwargs.get("subfolder", None) is not None
+            else weights_name
+        )
+
+    if "user_agent" not in hf_hub_download_kwargs:
+        hf_hub_download_kwargs["user_agent"] = http_user_agent()
+
+    if os.path.exists(os.path.join(path, SAFETENSORS_WEIGHTS_NAME)):
+        filename = os.path.join(path, SAFETENSORS_WEIGHTS_NAME)
+        use_safetensors = True
+    elif os.path.exists(os.path.join(path, WEIGHTS_NAME)):
+        filename = os.path.join(path, WEIGHTS_NAME)
+        use_safetensors = False
+    elif huggingface_hub.constants.HF_HUB_OFFLINE:
+        # if in offline mode, check if we can find the adapter file locally
+        hub_filename = get_hub_filename(use_safetensors=True)
+        hf_hub_download_kwargs.pop("local_files_only", None)
+        try:
+            filename = hf_hub_download(model_id, hub_filename, local_files_only=True, **hf_hub_download_kwargs)
+            use_safetensors = True
+        except LocalEntryNotFoundError:
+            # Could not find safetensors, try pickle. If this also fails, it's fine to let the error be raised here, as
+            # it means that the user tried to load a non-cached model in offline mode.
+            hub_filename = get_hub_filename(use_safetensors=False)
+            filename = hf_hub_download(model_id, hub_filename, local_files_only=True, **hf_hub_download_kwargs)
+            use_safetensors = False
+    else:
+        token = hf_hub_download_kwargs.get("token", None)
+        if token is None:
+            token = hf_hub_download_kwargs.get("use_auth_token", None)
+
+        hub_filename = get_hub_filename(use_safetensors=True)
+        has_remote_safetensors_file = file_exists(
+            repo_id=model_id,
+            filename=hub_filename,
+            revision=hf_hub_download_kwargs.get("revision", None),
+            repo_type=hf_hub_download_kwargs.get("repo_type", None),
+            token=token,
+        )
+        use_safetensors = has_remote_safetensors_file
+
+        if has_remote_safetensors_file:
+            # Priority 1: load safetensors weights
+            filename = hf_hub_download(
+                model_id,
+                SAFETENSORS_WEIGHTS_NAME,
+                **hf_hub_download_kwargs,
+            )
+        else:
+            try:
+                filename = hf_hub_download(model_id, WEIGHTS_NAME, **hf_hub_download_kwargs)
+            except EntryNotFoundError:
+                raise ValueError(
+                    f"Can't find weights for {model_id} in {model_id} or in the Hugging Face Hub. "
+                    f"Please check that the file {WEIGHTS_NAME} or {SAFETENSORS_WEIGHTS_NAME} is present at {model_id}."
+                )
+
+    if use_safetensors:
+        if hasattr(torch.backends, "mps") and (device == torch.device("mps")):
+            adapters_weights = safe_load_file(filename, device="cpu")
+        else:
+            adapters_weights = safe_load_file(filename, device=device)
+    else:
+        adapters_weights = torch_load(filename, map_location=torch.device(device))
+
+    if not key_mapping:
+        remapped_adapters_weights = adapters_weights
+    else:
+        # See discussion in https://github.com/huggingface/transformers/pull/38627
+        # Remap adapter weight names according to the provided key_mapping.
+        remapped_adapters_weights = {}
+        for key, val in adapters_weights.items():
+            if key.startswith("base_model.model."):
+                prefix = "base_model.model."
+            elif key.startswith("base_model."):
+                prefix = "base_model."
+            else:
+                raise ValueError(
+                    "An error occurred while trying to load a PEFT state_dict with key_mapping. This should not "
+                    "happen. Please open an issue on https://github.com/huggingface/peft/issues and report the error."
+                )
+
+            key = key.removeprefix(prefix)  # the key map assumes that there is no prefix
+            for pattern, replacement in key_mapping.items():
+                key_new, n_replace = re.subn(pattern, replacement, key)
+                # Early exit of the loop
+                if n_replace > 0:
+                    key = key_new
+                    break
+            key_with_prefix = f"{prefix}{key}"
+            remapped_adapters_weights[key_with_prefix] = val
+
+    return remapped_adapters_weights
diff --git a/src/peft/utils/transformers_weight_conversion.py b/src/peft/utils/transformers_weight_conversion.py
new file mode 100644
index 0000000..3e4ecbf
--- /dev/null
+++ b/src/peft/utils/transformers_weight_conversion.py
@@ -0,0 +1,669 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+# NOTE: don't import from this module unless transformers v5+ is used
+import copy
+import itertools
+import re
+from typing import Any
+
+import torch
+from transformers.conversion_mapping import (
+    _MODEL_TO_CONVERSION_PATTERN,
+    get_checkpoint_conversion_mapping,
+    get_model_conversion_mapping,
+)
+from transformers.core_model_loading import (
+    Concatenate,
+    ConversionOps,
+    MergeModulelist,
+    Transpose,
+    WeightConverter,
+    WeightRenaming,
+    dot_natural_key,
+    rename_source_key,
+)
+
+from peft import PeftConfig, PeftType
+from peft.tuners.tuners_utils import _maybe_include_all_linear_layers, check_target_module_exists
+from peft.utils.constants import INCLUDE_LINEAR_LAYERS_SHORTHAND
+
+
+# https://github.com/huggingface/transformers/pull/45340#issuecomment-4222734042
+_MODEL_TO_CONVERSION_PATTERN = _MODEL_TO_CONVERSION_PATTERN.copy()
+_MODEL_TO_CONVERSION_PATTERN["mixtral"] = "mixtral"
+
+
+def _block_diag_3d(tensors: list[torch.Tensor]) -> torch.Tensor:
+    if len(tensors) < 2:
+        raise ValueError(f"_block_diag_3d expects at least 2 tensors, got {len(tensors)}")
+
+    if any(t.dim() != 3 for t in tensors):
+        raise ValueError("_block_diag_3d expects all tensors to be 3d.")
+
+    num_experts = tensors[0].shape[0]
+    if any(t.shape[0] != num_experts for t in tensors):
+        raise ValueError("All tensors passed to _block_diag_3d must have the same number of experts.")
+
+    lora_b_block_diag = []
+    for i in range(num_experts):
+        lora_b_block_diag.append(torch.block_diag(*[tensor[i] for tensor in tensors]))
+    return torch.stack(lora_b_block_diag, dim=0)
+
+
+class PeftConcatenate(Concatenate):
+    """Convert per-expert LoRA weights to merged weights.
+
+    When the base weights are fused, e.g. W01 = [W0, W1], the LoRA weights also need to be fused. To achieve this
+    correctly, concatenate the LoRA A weights along the r (rank) dimension. This doesn't require a new Operation. But
+    for LoRA B, the weights need to be merged in a block diagonal fashion to achieve the correct result.
+
+    To illustrate:
+
+    Before:
+
+    W0' = W0 + A0 @ B0
+
+    W1' = W1 + A1 @ B1
+
+    After:
+
+    W01' = W01 + A01 @ B01_bd
+
+    where:
+
+    A01 = [A0, A1]
+
+    B01_bd = [[B0, 0], [0, B1]]
+
+    This class is responsible for merging LoRA B in this block-diagonal fashion. Assuming that we fuse N weights, it
+    should look like this:
+
+    1. LoRA B is 2-dim
+    Normal LoRA weight of shape (out_feat, rank), the output shape should be (N * out_feat, N * rank).
+
+    2. LoRA B is 3-dim
+    MoE LoRA weight of shape (experts, out_feat, rank), the output shape should be (experts, N * out_feat, N * rank).
+
+    After this, the experts x rank dimension are flattened, as PEFT expects 2d tensors for LoRA.
+    """
+
+    @torch.no_grad
+    def convert(
+        self,
+        input_dict: dict[str, list[torch.Tensor]],
+        source_patterns: list[str],
+        target_patterns: list[str],
+        full_layer_name: str,
+        **kwargs,
+    ) -> dict[str, list[torch.Tensor]]:
+        dims = [v.dim() for v in input_dict.values()]
+        if set(dims) not in ({2}, {3}):
+            raise ValueError(
+                f"To convert this LoRA adapter, the LoRA weights all need to have either 2 or 3 dims, got {set(dims)}"
+            )
+
+        # Keep source order stable (e.g. w1 before w3 for Mixtral) to preserve gate/up semantics.
+        ordered_tensors = [
+            input_dict[source_pattern] for source_pattern in source_patterns if source_pattern in input_dict
+        ]
+        if len(ordered_tensors) != len(input_dict):
+            missing = set(input_dict) - set(source_patterns)
+            raise ValueError(
+                "Collected tensors contain keys not present in source_patterns. "
+                f"Unexpected keys: {sorted(missing)}; source_patterns={source_patterns}"
+            )
+
+        if set(dims) == {2}:
+            output_dict = {full_layer_name: torch.block_diag(*ordered_tensors)}
+        else:
+            # with r being the LoRA rank and n being the number of fused weights:
+            out = _block_diag_3d(ordered_tensors)  # shape = experts, n*out_feat, 2*r
+            out = torch.permute(out, (2, 0, 1))  # shape = 2*r, experts, n*out_feat
+            out = out.flatten(0, 1)  # shape = 2*r * experts, n*out_feat
+            out = out.T
+            output_dict = {full_layer_name: out}
+        return output_dict
+
+    @property
+    def reverse_op(self) -> ConversionOps:
+        raise NotImplementedError("Reversing PEFT LoRA MoE conversions is not supported yet.")
+
+
+class FlattenDims(ConversionOps):
+    """
+    Flatten the tensors along the given dimensions
+    """
+
+    def __init__(self, dims: int | tuple[int, ...]):
+        if isinstance(dims, int):
+            dims = (dims,)
+        self.dims = dims
+
+    @torch.no_grad
+    def convert(
+        self,
+        input_dict: dict[str, list[torch.Tensor]],
+        source_patterns: list[str],
+        target_patterns: list[str],
+        config,
+        **kwargs,
+    ) -> dict[str, list[torch.Tensor]]:
+        output_dict = {k: v.flatten(*self.dims) for k, v in input_dict.items()}
+        return output_dict
+
+    @property
+    def reverse_op(self) -> ConversionOps:
+        raise NotImplementedError("Reversing flatteing operation is not supported.")
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}(dims={self.dims})"
+
+
+class PermuteDims(ConversionOps):
+    """
+    Permute the tensors along the given dimensions
+    """
+
+    def __init__(self, dims: tuple[int, ...]):
+        self.dims = dims
+
+    @torch.no_grad
+    def convert(
+        self,
+        input_dict: dict[str, list[torch.Tensor]],
+        source_patterns: list[str],
+        target_patterns: list[str],
+        config,
+        **kwargs,
+    ) -> dict[str, list[torch.Tensor]]:
+        output_dict = {k: v.permute(*self.dims) for k, v in input_dict.items()}
+        return output_dict
+
+    @property
+    def reverse_op(self) -> ConversionOps:
+        raise NotImplementedError("Reversing flatteing operation is not supported yet.")
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}(dims={self.dims})"
+
+
+def build_peft_weight_mapping(
+    weight_conversions: list[WeightConverter | WeightRenaming] | None, adapter_name: str, peft_config=None
+) -> list[WeightConverter | WeightRenaming]:
+    # We iterate over all the operations of the original model and simply edit them to apply to the PEFT adapter when
+    # appropriate.
+    # Note: This function is used in PEFT, changing it requires coordination.
+    if not weight_conversions:
+        return []
+
+    # strip "base_model.model" and add adapter name
+    new_weight_conversions = [
+        WeightRenaming("base_model.model.model.", "model."),
+        WeightRenaming("base_model.model.", ""),
+    ]
+
+    prefixes = set()
+    from peft.mapping import PEFT_TYPE_TO_PREFIX_MAPPING
+
+    peft_type = getattr(peft_config, "peft_type", None)
+    if peft_type in PEFT_TYPE_TO_PREFIX_MAPPING:
+        prefixes.add(PEFT_TYPE_TO_PREFIX_MAPPING[peft_type])
+    else:
+        prefixes.update(PEFT_TYPE_TO_PREFIX_MAPPING.values())
+
+    for prefix in sorted(prefixes):
+        escaped_prefix = re.escape(prefix)
+        new_weight_conversions.append(
+            WeightRenaming(
+                source_patterns=rf"({escaped_prefix}[^\.]*)",
+                target_patterns=rf"\1.{adapter_name}",
+            )
+        )
+
+    for orig_conversion in weight_conversions:
+        if isinstance(orig_conversion, WeightRenaming):
+            new_weight_conversions.append(orig_conversion)
+            continue
+
+        if len(orig_conversion.target_patterns) == 1 and orig_conversion.target_patterns[0].endswith("gate_up_proj"):
+            # gate_up_proj requires both merging the experts and concatenating for the fusion of w1 and w3
+            for lora in ("lora_A", "lora_B"):  # TODO: lora_embedding_A and lora_embedding_B
+                # deal with operations
+                peft_weight_operations = []
+                for op in orig_conversion.operations:
+                    if isinstance(op, Concatenate):
+                        if lora == "lora_B":  # block diagonal concat
+                            peft_weight_operations.append(PeftConcatenate(dim=op.dim))
+                        else:  # normal concat + flatten
+                            peft_weight_operations.append(op)
+                            peft_weight_operations.append(FlattenDims(dims=(0, 1)))
+                    elif isinstance(op, MergeModulelist):
+                        peft_weight_operations.append(op)
+
+                if not peft_weight_operations:
+                    continue
+
+                # TODO: this assumption may not hold for models != mixtral
+                # For source, we capture the original weights + the lora weights
+                new_source_patterns = []
+                for pat in list(orig_conversion.source_patterns):
+                    # we replace the weight pattern to colllect loras
+                    pat = pat.rsplit(".", 1)[0]
+                    # note: the source state_dict does *not* contain the adapter name
+                    new_source_patterns.append(f"{pat}.{lora}.*")
+
+                # the gate_up_proj is the innner PEFT ParamWrapper, so we need to use base_layer
+                pat = orig_conversion.target_patterns[0]
+                pat = pat.replace("gate_up_proj", "base_layer")
+                # we make sure the target key is correct, add '.weight' because the parameter is targeted directly
+                new_target_patterns = [f"{pat}.{lora}.{adapter_name}.weight"]
+
+                # Instantiate a new object that correctly post process patterns if needed
+                new_conversion = orig_conversion.__class__(
+                    source_patterns=new_source_patterns,
+                    target_patterns=new_target_patterns,
+                    operations=peft_weight_operations,
+                )
+                new_conversion.distributed_operation = orig_conversion.distributed_operation
+                new_conversion.quantization_operation = orig_conversion.quantization_operation
+                new_weight_conversions.append(new_conversion)
+
+        elif len(orig_conversion.target_patterns) == 1 and orig_conversion.target_patterns[0].endswith("down_proj"):
+            # down_proj only requires merging of experts
+            for lora in ("lora_A", "lora_B"):  # TODO: lora_embedding_A and lora_embedding_B
+                peft_weight_operations = []
+                for op in orig_conversion.operations:
+                    if isinstance(op, MergeModulelist):
+                        peft_weight_operations.append(op)
+                        if lora == "lora_A":
+                            peft_weight_operations.append(FlattenDims(dims=(0, 1)))
+                        else:
+                            peft_weight_operations.append(PermuteDims(dims=(2, 0, 1)))
+                            peft_weight_operations.append(FlattenDims(dims=(0, 1)))
+                            peft_weight_operations.append(Transpose(dim0=0, dim1=1))
+
+                if not peft_weight_operations:
+                    continue
+
+                # TODO: this assumption may not hold for models != mixtral
+                # For source, we capture the original weights + the lora weights
+                new_source_patterns = []
+                for pat in list(orig_conversion.source_patterns):
+                    # we replace the weight pattern to colllect loras
+                    pat = pat.rsplit(".", 1)[0]
+                    # note: the source state_dict does *not* contain the adapter name
+                    new_source_patterns.append(f"{pat}.{lora}.*")
+
+                # the down_proj is the outer PEFT ParamWrapper, so we remove the prefix
+                pat = orig_conversion.target_patterns[0]
+                pat = pat.replace(".down_proj", "")
+                # we make sure the target key is correct, add '.weight' because the parameter is targeted directly
+                new_target_patterns = [f"{pat}.{lora}.{adapter_name}.weight"]
+
+                # Instantiate a new object that correctly post process patterns if needed
+                new_conversion = orig_conversion.__class__(
+                    source_patterns=new_source_patterns,
+                    target_patterns=new_target_patterns,
+                    operations=peft_weight_operations,
+                )
+                new_conversion.distributed_operation = orig_conversion.distributed_operation
+                new_conversion.quantization_operation = orig_conversion.quantization_operation
+                new_weight_conversions.append(new_conversion)
+
+    return new_weight_conversions
+
+
+# The main reason we have to explicit this is because the conversion mapping
+# has the full layer name, while the config do not. We coould regex match but
+# this is more explicit and less error prone.
+# Note: this is used in PEFT, changing it requires coordiation.
+_MOE_TARGET_MODULE_MAPPING: dict[str, dict[str, str]] = {
+    "mixtral": {
+        "gate": "gate.weight",
+        "w1": "gate_up_proj",
+        "w3": "gate_up_proj",
+        "w2": "down_proj",
+    },
+    "qwen2_moe": {
+        "gate": "gate.weight",
+        "gate_proj": "gate_up_proj",
+        "up_proj": "gate_up_proj",
+        "down_proj": "down_proj",
+    },
+}
+
+# Note: this is used in PEFT, changing it requires coordiation.
+_MOE_FUSED_TARGETS: dict[str, dict[str, set[str]]] = {
+    # use lists for dict values to ensure stable order
+    "mixtral": {"gate_up_proj": ["w1", "w3"]},
+    "qwen2_moe": {"gate_up_proj": ["gate_proj", "up_proj"]},
+}
+
+
+def _resolve_string_target_modules(
+    peft_config: PeftConfig, model: torch.nn.Module, target_module_mapping: dict[str, str]
+) -> set[str]:
+    """Resolve a string `target_modules` (a regex or `"all-linear"`) to the concrete leaf names it targets.
+
+    The keys of `target_module_mapping` are the v4 projection names that were renamed/fused on v5: the expert
+    projections (`gate_proj`, `up_proj`, `down_proj`) and the router `gate`. Resolving the string to leaf names up
+    front lets the list-based remap downstream stay unchanged for a regex and for `"all-linear"` alike.
+
+    `"all-linear"` matched every `nn.Linear` on the v4 model, so it targeted all of those projections; on v5 they are
+    no longer `nn.Linear` (the experts are fused into stacked parameters, the router became a custom module), so they
+    are added directly by name. A regex only targets what it spells out, so the experts -- which no longer exist as
+    real keys -- are recovered by probing each reconstructed v4 key against the pattern.
+    """
+    if peft_config.target_modules.lower() == INCLUDE_LINEAR_LAYERS_SHORTHAND:
+        # attention projections are still `nn.Linear` on v5, so resolve them by type; the experts and router were
+        # `nn.Linear` in v4 too but are now parameters / a custom module, so add their v4 names (the mapping keys).
+        resolved = _maybe_include_all_linear_layers(copy.copy(peft_config), model).target_modules
+        return {name.rsplit(".", 1)[-1] for name in resolved} | target_module_mapping.keys()
+
+    # regex: leaf names of the real module/parameter keys it matches (q/k/v_proj, the router module, `down_proj`, ...)
+    module_keys = [name for name, _ in model.named_modules()]
+    param_keys = [name for name, _ in model.named_parameters()]
+    matched = {
+        key.rsplit(".", 1)[-1]
+        for key in itertools.chain(module_keys, param_keys)
+        if check_target_module_exists(peft_config, key)
+    }
+
+    # The pre-fusion experts (`gate_proj`, `up_proj`) live inside the stacked `gate_up_proj` parameter, so a regex
+    # naming them matches no real key. Recover them from that parameter's container: e.g. for the parameter
+    # `model.layers.0.mlp.experts.gate_up_proj`, probe the reconstructed v4 key `model.layers.0.mlp.experts.gate_proj`.
+    new_name_to_containers: dict[str, set[str]] = {}
+    for name in param_keys:
+        container, _, leaf = name.rpartition(".")
+        new_name_to_containers.setdefault(leaf, set()).add(container)
+    for old_name, new_name in target_module_mapping.items():
+        if old_name in matched:
+            continue
+        # one hit suffices -- `matched` holds leaf names, so stop at the first container (layer) the regex matches
+        for container in new_name_to_containers.get(new_name, ()):
+            if check_target_module_exists(peft_config, f"{container}.{old_name}"):
+                matched.add(old_name)
+                break
+    return matched
+
+
+def _convert_peft_config_moe(peft_config: PeftConfig, model: torch.nn.Module) -> None:
+    """
+    In-place convert the PEFT config of MoE models whose architecture changed from transformers v4 to v5.
+
+    Since the model architecture changed, the targets have to updated accordingly. Moreover, when weights are fused, it
+    requires updating the rank and alpha values of those parameters.
+
+    A string `target_modules` (a regex, or `"all-linear"`) is resolved against the model up front (see
+    `_resolve_string_target_modules`), so the list-based remap below applies to lists, regexes and `"all-linear"`
+    alike.
+    """
+    model_type = getattr(model.config, "model_type", None)
+    base_model_type = _MODEL_TO_CONVERSION_PATTERN.get(model_type, None)
+    if base_model_type is None:
+        return
+
+    target_module_mapping = _MOE_TARGET_MODULE_MAPPING.get(base_model_type)
+    if not target_module_mapping:
+        return
+
+    fused_targets = _MOE_FUSED_TARGETS.get(base_model_type, {})
+    if not fused_targets:
+        return
+
+    if isinstance(peft_config.target_modules, str):
+        resolved = _resolve_string_target_modules(peft_config, model, target_module_mapping)
+        if not resolved:
+            # nothing matched (e.g. bare "q_proj", invalid as a regex) -- leave it for the standard not-found error
+            return
+        peft_config.target_modules = resolved
+
+    if not hasattr(peft_config, "rank_pattern") or peft_config.rank_pattern is None:
+        peft_config.rank_pattern = {}
+    if not hasattr(peft_config, "alpha_pattern") or peft_config.alpha_pattern is None:
+        peft_config.alpha_pattern = {}
+    peft_config.target_parameters = set(peft_config.target_parameters or [])
+    peft_config.target_modules = set(peft_config.target_modules or [])
+
+    new_target_parameters = peft_config.target_parameters.copy()
+    remaining_target_modules = set()
+    matched_targets: dict[str, set[str]] = {new_name: set() for new_name in fused_targets}
+
+    for target in peft_config.target_modules:
+        mapped_new_name = None
+        mapped_old_name = None
+        for old_name, new_name in target_module_mapping.items():
+            if (target == old_name) or target.endswith(f".{old_name}"):
+                mapped_new_name = new_name
+                mapped_old_name = old_name
+                break
+
+        if mapped_new_name is None:
+            remaining_target_modules.add(target)
+            continue
+
+        new_target_parameters.add(mapped_new_name)
+        if mapped_new_name in fused_targets and mapped_old_name is not None:
+            matched_targets.setdefault(mapped_new_name, set()).add(mapped_old_name)
+
+    for new_name, required_old_targets in fused_targets.items():
+        present_targets = matched_targets.get(new_name, set())
+        if 0 < len(present_targets) < len(required_old_targets):
+            missing = ", ".join(sorted(set(required_old_targets) - present_targets))
+            present = ", ".join(sorted(present_targets))
+            raise ValueError(
+                f"Cannot convert PEFT target(s) {present} without also targeting {missing} because they are fused "
+                f"into {new_name}."
+            )
+
+        if len(present_targets) == len(required_old_targets) and len(required_old_targets) > 1:
+            # TODO: if there is already a rank or alpha pattern for this module, we should update that instead, but
+            # it's not trivial to detect a match here
+            peft_config.rank_pattern[rf".*\.{re.escape(new_name)}"] = peft_config.r * len(required_old_targets)
+            # Preserve per-branch LoRA scaling after fusion.
+            # Example: w1 + w3 => r doubles, so alpha must also double to keep alpha/r unchanged.
+            peft_config.alpha_pattern[rf".*\.{re.escape(new_name)}"] = peft_config.lora_alpha * len(
+                required_old_targets
+            )
+
+    peft_config.target_parameters = new_target_parameters
+    peft_config.target_modules = remaining_target_modules
+
+
+def convert_peft_config_for_transformers(peft_config, model: torch.nn.Module, conversions: list[Any] | None) -> None:
+    """
+    Convert the PEFT config of models whose architecture changed from transformers v4 to v5.
+
+    For most models, this requires no changes, this mostly affects some MoE models like Mixtral.
+
+    The conversion should be in-place to ensure that all references to this config stay up-to-date.
+    """
+    # If, for any reason, we cannot apply conversion, we just return the PEFT config as is.
+    if peft_config.peft_type != PeftType.LORA:
+        # weight conversion is currently only supported for LoRA
+        return
+    if not hasattr(model, "config"):
+        # not a transformer model
+        return
+    if not hasattr(model.config, "model_type"):
+        # not a transformer model
+        return
+
+    model_type = getattr(model.config, "model_type", None)
+    if get_checkpoint_conversion_mapping(model_type) is not None:
+        _convert_peft_config_moe(peft_config, model)
+
+
+def _convert_to_peft_serialized_keys(
+    state_dict: dict[str, torch.Tensor],
+    adapter_name: str,
+    base_prefix: str = "base_model.model.",
+) -> dict[str, torch.Tensor]:
+    converted = {}
+    adapter_suffix = f".{adapter_name}"
+
+    for key, value in state_dict.items():
+        # Return PEFT-serialized keys (prefixed), not model state_dict keys.
+        if not key.startswith("base_model."):
+            key = f"{base_prefix}{key}"
+
+        # For module-backed params: ...lora_A.<adapter>.weight -> ...lora_A.weight
+        # For parameter-backed entries: ...<something>.<adapter> -> ...<something>
+        if key.endswith(adapter_suffix):
+            key = key.removesuffix(adapter_suffix)
+        else:
+            key_no_suffix, dot, suffix = key.rpartition(".")
+            if dot and key_no_suffix.endswith(adapter_suffix):
+                key_no_suffix = key_no_suffix.removesuffix(adapter_suffix)
+                key = f"{key_no_suffix}.{suffix}"
+        converted[key] = value
+
+    return converted
+
+
+def convert_peft_adapter_state_dict_for_transformers(
+    model: torch.nn.Module,
+    peft_config,
+    adapter_state_dict: dict[str, torch.Tensor],
+    adapter_name: str = "default",
+) -> dict[str, torch.Tensor]:
+    """Convert a PEFT adapter state dict to match a transformers v5 weight conversion.
+
+    This function is intended for callers (e.g. `PeftModel.load_adapter`) that need transformers' conversion logic
+    without going through `transformer_model.load_adapter`.
+
+    Args:
+        model:
+            Base model on which the adapter will be loaded.
+        peft_config:
+            Adapter config.
+        adapter_state_dict:
+            Adapter weights as loaded from disk.
+        adapter_name:
+            Adapter name used for conversion of internal target patterns.
+
+    Returns:
+        The converted state dict.
+    """
+    if peft_config.peft_type != PeftType.LORA:
+        # weight conversion is currently only supported for LoRA
+        return adapter_state_dict
+
+    if not hasattr(model, "config") or not hasattr(model.config, "model_type"):
+        # not a transformers-like model
+        return adapter_state_dict
+
+    model_type = getattr(model.config, "model_type", None)
+    if get_checkpoint_conversion_mapping(model_type) is None:
+        # no architecture-level conversion registered for this model
+        return adapter_state_dict
+
+    # pass the base model to get_model_conversion_mapping, as Transformers may not correctly deal with base_model.model
+    # prefix, see the introduction of scope_prefix in https://github.com/huggingface/transformers/pull/45661
+    base_model = model.get_base_model() if hasattr(model, "get_base_model") else model
+    prefix: str = getattr(model, "base_model_prefix", "")
+    weight_conversions = get_model_conversion_mapping(base_model)
+    peft_weight_conversions = build_peft_weight_mapping(
+        weight_conversions, adapter_name=adapter_name, peft_config=peft_config
+    )
+    if not peft_weight_conversions:
+        return adapter_state_dict
+
+    # Keep non-LoRA entries untouched (e.g. modules_to_save / auxiliary wrappers).
+    # This avoids interfering with PEFT's later wrapper-specific key remapping.
+    lora_like_state_dict = {}
+    passthrough_state_dict = {}
+    for key, value in adapter_state_dict.items():
+        if ".lora_" in key:
+            lora_like_state_dict[key] = value
+        else:
+            passthrough_state_dict[key] = value
+
+    if not lora_like_state_dict:
+        return adapter_state_dict
+
+    renamings = [entry for entry in peft_weight_conversions if isinstance(entry, WeightRenaming)]
+    converters = [entry for entry in peft_weight_conversions if isinstance(entry, WeightConverter)]
+    pattern_to_converter = {k: converter for converter in converters for k in converter.source_patterns}
+
+    param_name_to_load: dict[str, WeightRenaming | WeightConverter] = {}
+
+    def str_rreplace(s, old, new, count=-1):
+        # this is the same as str.replace(...) but counting from the right side instead of left side
+        return new.join(s.rsplit(old, count))
+
+    # Mirror transformers.core_model_loading flow: stable ordering + same rename logic.
+    # https://github.com/huggingface/transformers/blob/1bd97f246318456c1b87cf8ef8dc043ec1a53fff/src/transformers/core_model_loading.py#L997
+    state_items = sorted(lora_like_state_dict.items(), key=lambda kv: dot_natural_key(kv[0]))
+    for original_key, tensor in state_items:
+        renamed_key, source_pattern = rename_source_key(original_key, renamings, converters)
+        renamed_key_without_adapter_name = str_rreplace(renamed_key, f".{adapter_name}", "", count=1)
+        new_key_is_suffix_of_old_key = original_key.endswith(renamed_key_without_adapter_name)
+
+        # https://github.com/huggingface/transformers/pull/44396 introduced code to undo the renaming:
+        # https://github.com/huggingface/transformers/blob/027d1a97025295a1346c2eb5c361259e69eedfe7/src/transformers/core_model_loading.py#L1361-L1365
+        # This logic is copied here but with an extra caveat: We only undo the key renaming if it is due to a missing
+        # prefix, e.g. "text_model.foo.bar" => "foo.bar". This is why we check if the renamed key is a suffix of the
+        # original key. However, strictly checking for the suffix is not enough because the renamed key also introduces
+        # the adapter name, which is not in the original key. Therefore, we need to remove the adapter name first.
+        if (
+            (renamed_key not in adapter_state_dict)
+            and (original_key in adapter_state_dict)
+            and new_key_is_suffix_of_old_key
+        ):
+            # Key should probably not have been renamed but we might need the `prefix` to be added.
+            renamed_key, source_pattern = rename_source_key(original_key, [], [], prefix, adapter_state_dict)
+
+        if source_pattern is not None:
+            new_converter = copy.deepcopy(pattern_to_converter[source_pattern])
+            mapping = param_name_to_load.setdefault(renamed_key, new_converter)
+        else:
+            mapping = param_name_to_load.setdefault(renamed_key, WeightRenaming(original_key, renamed_key))
+            source_pattern = original_key
+
+        mapping.add_tensor(renamed_key, original_key, source_pattern, tensor)
+
+    converted_lora_model_keys: dict[str, torch.Tensor] = {}
+    consumed_source_keys: set[str] = set()
+
+    for first_param_name, mapping in param_name_to_load.items():
+        realized_values = mapping.convert(
+            first_param_name,
+            model=model,
+            config=model.config,
+            hf_quantizer=None,
+            loading_info=None,
+        )
+
+        for source_keys in mapping.layer_targets.values():
+            consumed_source_keys.update(source_keys)
+
+        for target_name, param in realized_values.items():
+            converted_lora_model_keys[target_name] = param[0] if isinstance(param, list) else param
+
+    # Keep untouched LoRA keys, then overwrite with converted results.
+    for key in consumed_source_keys:
+        lora_like_state_dict.pop(key, None)
+    lora_like_state_dict.update(converted_lora_model_keys)
+
+    # Return PEFT-serialized keys (remove adapter-name insertion and keep base_model prefixing behavior).
+    converted_lora_serialized = _convert_to_peft_serialized_keys(
+        lora_like_state_dict, adapter_name=adapter_name, base_prefix="base_model.model."
+    )
+
+    out = {}
+    out.update(passthrough_state_dict)
+    out.update(converted_lora_serialized)
+    return out
diff --git a/src/peft/utils/warning.py b/src/peft/utils/warning.py
new file mode 100644
index 0000000..3e2afeb
--- /dev/null
+++ b/src/peft/utils/warning.py
@@ -0,0 +1,17 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+
+class PeftWarning(UserWarning):
+    """Base PEFT warning"""
diff --git a/tests/__init__.py b/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/conftest.py b/tests/conftest.py
new file mode 100644
index 0000000..d86c5ed
--- /dev/null
+++ b/tests/conftest.py
@@ -0,0 +1,95 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import logging
+import platform
+import re
+
+import pytest
+
+
+def pytest_addoption(parser):
+    parser.addoption("--regression", action="store_true", default=False, help="run regression tests")
+
+
+def pytest_configure(config):
+    config.addinivalue_line("markers", "regression: mark regression tests")
+
+    # Errors from transformers deprecations
+    logger = logging.getLogger("transformers")
+
+    class ErrorOnDeprecation(logging.Handler):
+        def emit(self, record):
+            msg = record.getMessage().lower()
+            if "deprecat" in msg or "future" in msg:
+                # let's ignore the torch_dtype => dtype deprecation for now
+                if "torch_dtype" in msg:
+                    return
+
+                # BPE warning comes from transformers and we cannot do anything about it, transformers has to fix it
+                bpe_warning = (
+                    "Deprecated in 0.9.0: BPE.__init__ will not create from files anymore, try `BPE.from_file` instead"
+                )
+                if bpe_warning in msg:
+                    return
+
+                raise AssertionError(f"**Transformers Deprecation**: {msg}")
+
+    # Add our handler
+    handler = ErrorOnDeprecation()
+    logger.addHandler(handler)
+    logger.setLevel(logging.WARNING)
+
+
+def pytest_collection_modifyitems(config, items):
+    if config.getoption("--regression"):
+        return
+
+    skip_regression = pytest.mark.skip(reason="need --regression option to run regression tests")
+    for item in items:
+        if "regression" in item.keywords:
+            item.add_marker(skip_regression)
+
+
+# TODO: remove this once support for PyTorch 2.2 (the latest one still supported by GitHub MacOS x86_64 runners) is
+# dropped, or if MacOS is removed from the test matrix, see https://github.com/huggingface/peft/issues/2431.
+# Note: the function name is fixed by the pytest plugin system, don't change it
+@pytest.hookimpl(hookwrapper=True)
+def pytest_runtest_makereport(item, call):
+    """
+    Plug into the pytest test report generation to skip a specific MacOS failure caused by transformers.
+
+    The error was introduced by https://github.com/huggingface/transformers/pull/37785, which results in torch.load
+    failing when using torch < 2.6.
+
+    Since the MacOS x86 runners need to use an older torch version, those steps are necessary to get the CI green.
+    """
+    outcome = yield
+    rep = outcome.get_result()
+    # ref:
+    # https://github.com/huggingface/transformers/blob/858ce6879a4aa7fa76a7c4e2ac20388e087ace26/src/transformers/utils/import_utils.py#L1418
+    error_msg = re.compile(r"Due to a serious vulnerability issue in `torch.load`")
+
+    # notes:
+    # - pytest uses hard-coded strings, we cannot import and use constants
+    #   https://docs.pytest.org/en/stable/reference/reference.html#pytest.TestReport
+    # - errors can happen during call (running the test) but also setup (e.g. in fixtures)
+    if rep.failed and (rep.when in ("setup", "call")) and (platform.system() == "Darwin"):
+        exc_msg = str(call.excinfo.value)
+        if error_msg.search(exc_msg):
+            # turn this failure into an xfail:
+            rep.outcome = "skipped"
+            # for this attribute, see:
+            # https://github.com/pytest-dev/pytest/blob/bd6877e5874b50ee57d0f63b342a67298ee9a1c3/src/_pytest/reports.py#L266C5-L266C13
+            rep.wasxfail = "Error known to occur on MacOS with older torch versions, won't be fixed"
diff --git a/tests/regression/__init__.py b/tests/regression/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/regression/test_regression.py b/tests/regression/test_regression.py
new file mode 100644
index 0000000..93fbd10
--- /dev/null
+++ b/tests/regression/test_regression.py
@@ -0,0 +1,698 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+# Regression testing: check that checkpoints from previous PEFT versions still return the same values.
+#
+# For normal regression testing, just run:
+#
+# `pytest tests/regression/test_regression.py -s --regression`
+#
+# Add `-s` to show potentially useful debugging information. `--regression` is a custom marker that is required for
+# regression tests not to be skipped.
+#
+# To create new regression tests, run:
+# `HF_TOKEN=<token> REGRESSION_CREATION_MODE=True pytest tests/regression/test_regression.py -s --regression`
+#
+# This will *fail* if:
+#
+# 1. the git worktree is dirty
+# 2. the git commit is not tagged
+#
+# Note: A Hugging Face Hub token is required to upload the regression artifacts to our
+# https://huggingface.co/peft-internal-testing repo. This can be done by anyone with write access to the repo but
+# apparently it is not possible to create a technical token with write access.
+#
+# This is important to ensure that the regression artifacts correspond to a specific released version of PEFT.
+# Therefore, it is recommended to checkout the tag before running the regression tests, e.g. by running:
+#
+# `git checkout v0.1.0`
+#
+# To override these checks, run:
+# ``HF_TOKEN=<token> REGRESSION_CREATION_MODE=True REGRESSION_FORCE_MODE=True pytest tests/regression/test_regression.py -s --regression`
+#
+# In REGRESSION_CREATION_MODE, one directory will be created in tests/regression/<TEST_NAME>/<PEFT_VERSION>/ for each
+# test. This will contain the saved adapter, as well as the output of the test of the model for that version.
+#
+# In normal testing mode, the saved adapter and output for each version found in the directory
+# tests/regression/<TEST_NAME>/ will be loaded and compared to the current output.
+#
+# When implementing new tests, check the existing ones as well as the description in the docstring of RegressionTester.
+#
+# Note: For 4-bit tests using XPU (regardless of REGRESSION_CREATION_MODE), set `PEFT_USE_XPU=True` to enable the correct XPU path.
+
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import unittest
+
+import pytest
+import torch
+from huggingface_hub import snapshot_download, upload_folder
+from torch import nn
+from transformers import AutoModelForCausalLM, BitsAndBytesConfig
+from transformers.pytorch_utils import Conv1D
+
+import peft
+from peft import (
+    AdaLoraConfig,
+    BOFTConfig,
+    IA3Config,
+    LNTuningConfig,
+    LoHaConfig,
+    LoKrConfig,
+    LoraConfig,
+    PeftModel,
+    VBLoRAConfig,
+    VeraConfig,
+    get_peft_model,
+)
+from peft.utils import infer_device
+
+from ..testing_utils import require_bitsandbytes, require_deterministic_for_xpu, require_non_cpu
+
+
+PEFT_VERSION = peft.__version__
+REGRESSION_DIR = tempfile.mkdtemp(prefix="peft_regression_")
+HF_TOKEN = os.environ.get("HF_TOKEN")
+# the repo has to be created manually once, it is not automatically created
+HF_REPO = "peft-internal-testing/regression-tests"
+# note: For XPU devices, a separate regression test repository(for 4 bit) is used due to hardware and implementation
+# differences that can lead to different numerical results compared to CUDA-based devices.
+# See PR https://github.com/huggingface/peft/pull/2843
+HF_REPO_XPU = "Intel/peft-regression-tests"
+LORA_4BIT_FOLDER = "lora_opt-350m_bnb_4bit"
+
+
+@pytest.fixture(scope="session", autouse=True)
+def setup_teardown():
+    # Use a pytest session-scoped fixture to setup and teardown exactly once per session. AFAICT, unittest does not
+    # provide such a feature
+    yield
+
+    # delete regression artifacts at the end of the test session; optionally, upload them first if in creation mode
+    creation_mode = strtobool(os.environ.get("REGRESSION_CREATION_MODE", "False"))
+    use_xpu = strtobool(os.environ.get("PEFT_USE_XPU", "False")) and (infer_device() == "xpu")
+    if creation_mode:
+        if use_xpu:
+            lora_4bit_folder_path = os.path.join(REGRESSION_DIR, LORA_4BIT_FOLDER)
+            upload_folder(
+                repo_id=HF_REPO_XPU,
+                folder_path=lora_4bit_folder_path,
+                path_in_repo=LORA_4BIT_FOLDER,
+                token=HF_TOKEN,
+            )
+        else:
+            # upload the regression directory to Hugging Face Hub, will overwrite by default
+            upload_folder(
+                repo_id=HF_REPO,
+                folder_path=REGRESSION_DIR,
+                token=HF_TOKEN,
+            )
+
+    shutil.rmtree(REGRESSION_DIR)
+
+
+def strtobool(val):
+    """Copied from distutils.util"""
+    val = val.lower()
+    if val in ("y", "yes", "t", "true", "on", "1"):
+        return 1
+    elif val in ("n", "no", "f", "false", "off", "0"):
+        return 0
+    else:
+        raise ValueError(f"invalid truth value {val!r}")
+
+
+def save_output(output, name, force=False):
+    path = os.path.join(REGRESSION_DIR, name, PEFT_VERSION)
+    filename = os.path.join(path, "output.pt")
+    if os.path.exists(filename) and not force:
+        return
+
+    if not os.path.exists(path):
+        os.makedirs(path)
+
+    if os.path.exists(filename) and force:
+        print(f"Overriding existing output in {filename}", file=sys.stderr)
+
+    torch.save(output, filename)
+
+
+def save_model(model, name, force=False):
+    path = os.path.join(REGRESSION_DIR, name, PEFT_VERSION)
+    filename = os.path.join(path, peft.utils.SAFETENSORS_WEIGHTS_NAME)
+    if os.path.exists(filename) and not force:
+        return
+
+    if not os.path.exists(path):
+        os.makedirs(path)
+
+    if os.path.exists(filename) and force:
+        print(f"Overriding existing model in {path}", file=sys.stderr)
+
+    model.save_pretrained(path)
+
+
+def load_output(name):
+    filename = os.path.join(REGRESSION_DIR, name, "output.pt")
+    return torch.load(filename, map_location=infer_device())
+
+
+def download_regression_artifact(name):
+    # WARNING: If running on XPU, LORA_4BIT_FOLDER artifacts are loaded from HF_REPO_XPU, which is outside of peft
+    # direct control. The load_output function uses torch.load, which can execute arbitrary code from pickle files.
+    # Users should be aware of this potential security risk.
+    use_xpu = strtobool(os.environ.get("PEFT_USE_XPU", "False")) and (infer_device() == "xpu")
+    repo_id = HF_REPO_XPU if (name == LORA_4BIT_FOLDER and use_xpu) else HF_REPO
+    snapshot_download(repo_id=repo_id, local_dir=REGRESSION_DIR, allow_patterns=[f"{name}/**"])
+
+
+@pytest.mark.regression
+class RegressionTester(unittest.TestCase):
+    """Base class for regression testing
+
+    Child classes must call assert_results_equal_or_store and pass the model outtput, as well as a unique name that
+    describes the setting (e.g. "lora_opt-350m_bnb_4bit"). They also need to implement get_output(model) to get the
+    model output, and load_base_model(name) to load the base model. Don't forget to fix the seed in load_base_model.
+    """
+
+    torch_device = infer_device()
+
+    def setUp(self):
+        self.tol = 1e-4
+        self.creation_mode = strtobool(os.environ.get("REGRESSION_CREATION_MODE", "False"))
+        self.force_mode = strtobool(os.environ.get("REGRESSION_FORCE_MODE", "False"))
+        if self.force_mode and not self.creation_mode:
+            raise RuntimeError("REGRESSION_FORCE_MODE can only be used together with REGRESSION_CREATION_MODE")
+        if self.creation_mode:
+            self.check_clean_git_status(self.force_mode)
+            if HF_TOKEN is None:
+                raise RuntimeError("HF_TOKEN environment variable must be set in creation mode")
+
+    def fix_seed(self):
+        torch.manual_seed(0)
+
+    def check_clean_git_status(self, force):
+        """Ensure that worktree is not dirty and version tag is checked out"""
+        # check that the worktree is clean
+        try:
+            subprocess.check_output(["git", "diff", "--quiet", "HEAD"])
+        except subprocess.CalledProcessError as exc:
+            if force:
+                print("Overriding despite dirty git worktree", file=sys.stderr)
+            else:
+                raise RuntimeError("Git worktree is dirty") from exc
+
+        # check that the commit is tagged
+        try:
+            subprocess.check_output(["git", "describe", "--exact-match", "HEAD"])
+        except subprocess.CalledProcessError as exc:
+            if force:
+                print("Overriding despite non-tagged commit", file=sys.stderr)
+            else:
+                raise RuntimeError("Git commit is not tagged") from exc
+
+    @require_deterministic_for_xpu
+    def assert_results_equal_or_store(self, model, name):
+        """Check if the outputs are the same or save the outputs if in creation mode."""
+        if not self.creation_mode:  # normal regression testing mode
+            download_regression_artifact(name)
+            self._assert_results_equal(name)
+        else:
+            output = self.get_output(model)
+            if not torch.isfinite(output).all():
+                raise RuntimeError(f"Model output for {name} is not finite")
+
+            output2 = self.get_output(model)
+            if not torch.allclose(output, output2):
+                raise RuntimeError(f"Model output for {name} is not deterministic")
+
+            save_output(output, name, force=self.force_mode)
+            save_model(model, name, force=self.force_mode)
+
+    def _assert_results_equal(self, name):
+        path = os.path.join(REGRESSION_DIR, name)
+        versions = os.listdir(path)
+        for version in versions:  # each directory corresponds to a version
+            output_loaded = load_output(os.path.join(name, version))
+            base_model = self.load_base_model()
+            model = PeftModel.from_pretrained(base_model, os.path.join(path, version))
+            output = self.get_output(model)
+            assert torch.allclose(output_loaded, output, atol=self.tol, rtol=self.tol)
+
+    def get_output(self, model):
+        raise NotImplementedError
+
+    def load_base_model(self):
+        raise NotImplementedError
+
+
+##############
+# TEST CASES #
+##############
+
+
+class TestMlp(RegressionTester):
+    def get_output(self, model):
+        input = torch.arange(90).reshape(9, 10).to(self.torch_device)
+        with torch.inference_mode():
+            output = model(input)
+        return output
+
+    def load_base_model(self):
+        class MLP(nn.Module):
+            def __init__(self, bias=True):
+                super().__init__()
+                self.lin0 = nn.Linear(10, 20, bias=bias)
+                self.relu = nn.ReLU()
+                self.lin1 = nn.Linear(20, 2, bias=bias)
+                self.sm = nn.LogSoftmax(dim=-1)
+
+            def forward(self, X):
+                X = X.float()
+                X = self.lin0(X)
+                X = self.relu(X)
+                X = self.lin1(X)
+                X = self.sm(X)
+                return X
+
+        self.fix_seed()
+        return MLP().to(self.torch_device)
+
+    def test_lora(self):
+        base_model = self.load_base_model()
+        config = LoraConfig(
+            r=8,
+            init_lora_weights=False,
+            target_modules=["lin0"],
+        )
+        model = get_peft_model(base_model, config)
+        self.assert_results_equal_or_store(model, "lora_mlp")
+
+    def test_lora_dora(self):
+        base_model = self.load_base_model()
+        config = LoraConfig(
+            r=8,
+            init_lora_weights=False,
+            target_modules=["lin0"],
+            use_dora=True,
+        )
+        model = get_peft_model(base_model, config)
+        self.assert_results_equal_or_store(model, "lora_dora_mlp")
+
+    def test_adalora(self):
+        base_model = self.load_base_model()
+        config = AdaLoraConfig(
+            r=8,
+            init_lora_weights=False,
+            target_modules=["lin0"],
+            total_step=1,
+        )
+        model = get_peft_model(base_model, config)
+        self.assert_results_equal_or_store(model, "adalora_mlp")
+
+    def test_ia3(self):
+        base_model = self.load_base_model()
+        config = IA3Config(
+            init_ia3_weights=False,
+            target_modules=["lin0"],
+            feedforward_modules=["lin0"],
+        )
+        model = get_peft_model(base_model, config)
+        self.assert_results_equal_or_store(model, "ia3_mlp")
+
+    def test_ia3_no_ff(self):
+        base_model = self.load_base_model()
+        config = IA3Config(
+            init_ia3_weights=False,
+            target_modules=["lin0"],
+            feedforward_modules=[],
+        )
+        model = get_peft_model(base_model, config)
+        self.assert_results_equal_or_store(model, "ia3_no_ff_mlp")
+
+    def test_loha(self):
+        # TODO
+        self.skipTest("Skipping LoHa for now because init is not seedable")
+        base_model = self.load_base_model()
+        config = LoHaConfig(
+            r=8,
+            init_weights=False,
+            target_modules=["lin0"],
+        )
+        model = get_peft_model(base_model, config)
+        self.assert_results_equal_or_store(model, "loha_mlp")
+
+    def test_lokr(self):
+        # TODO
+        self.skipTest("Skipping LoKr for now because init is not seedable")
+        base_model = self.load_base_model()
+        config = LoKrConfig(
+            r=8,
+            target_modules=["lin0"],
+        )
+        model = get_peft_model(base_model, config)
+        self.assert_results_equal_or_store(model, "lokr_mlp")
+
+    def test_lora_modules_to_save(self):
+        base_model = self.load_base_model()
+        config = LoraConfig(
+            r=8,
+            init_lora_weights=False,
+            target_modules=["lin0"],
+            modules_to_save=["lin1"],
+        )
+        model = get_peft_model(base_model, config)
+        self.assert_results_equal_or_store(model, "lora_mlp_modules_to_save")
+
+    def test_boft(self):
+        base_model = self.load_base_model()
+        config = BOFTConfig(
+            boft_block_size=2,
+            target_modules=["lin0"],
+        )
+        model = get_peft_model(base_model, config)
+        self.assert_results_equal_or_store(model, "boft_mlp")
+
+    def test_ln_tuning(self):
+        base_model = self.load_base_model()
+        config = LNTuningConfig(target_modules=["lin0"])
+        model = get_peft_model(base_model, config)
+        self.assert_results_equal_or_store(model, "ln_tuning_mlp")
+
+    def test_vera_tuning(self):
+        base_model = self.load_base_model()
+        config = VeraConfig(target_modules=["lin0"])
+        model = get_peft_model(base_model, config)
+        self.assert_results_equal_or_store(model, "vera_tuning_mlp")
+
+    def test_vblora_tuning(self):
+        base_model = self.load_base_model()
+        config = VBLoRAConfig(
+            vector_length=1,
+            num_vectors=2,
+            target_modules=["lin0"],
+        )
+        model = get_peft_model(base_model, config)
+        self.assert_results_equal_or_store(model, "vblora_tuning_mlp")
+
+
+class TestLoraEmbConv1D(RegressionTester):
+    def get_output(self, model):
+        input = torch.arange(90).reshape(9, 10).to(self.torch_device)
+        with torch.inference_mode():
+            output = model(input)
+        return output
+
+    def load_base_model(self):
+        class ModelEmbConv1D(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.emb = nn.Embedding(100, 5)
+                self.conv1d = Conv1D(1, 5)
+                self.relu = nn.ReLU()
+                self.flat = nn.Flatten()
+                self.lin0 = nn.Linear(10, 2)
+                self.sm = nn.LogSoftmax(dim=-1)
+
+            def forward(self, X):
+                X = self.emb(X)
+                X = self.conv1d(X)
+                X = self.relu(X)
+                X = self.flat(X)
+                X = self.lin0(X)
+                X = self.sm(X)
+                return X
+
+        self.fix_seed()
+        return ModelEmbConv1D().to(self.torch_device)
+
+    def test_lora(self):
+        base_model = self.load_base_model()
+        config = LoraConfig(
+            r=8,
+            init_lora_weights=False,
+            target_modules=["emb", "conv1d"],
+        )
+        model = get_peft_model(base_model, config)
+        self.assert_results_equal_or_store(model, "lora_emb_conv1d")
+
+
+class TestLoraConv2D(RegressionTester):
+    def get_output(self, model):
+        input = torch.arange(90).reshape(9, 10).to(self.torch_device)
+        with torch.inference_mode():
+            output = model(input)
+        return output
+
+    def load_base_model(self):
+        class ModelConv2D(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.conv2d = nn.Conv2d(5, 10, 3)
+                self.relu = nn.ReLU()
+                self.flat = nn.Flatten()
+                self.lin0 = nn.Linear(10, 2)
+                self.sm = nn.LogSoftmax(dim=-1)
+
+            def forward(self, X):
+                X = X.float().reshape(2, 5, 3, 3)
+                X = self.conv2d(X)
+                X = self.relu(X)
+                X = self.flat(X)
+                X = self.lin0(X)
+                X = self.sm(X)
+                return X
+
+        self.fix_seed()
+        return ModelConv2D().to(self.torch_device)
+
+    def test_lora(self):
+        base_model = self.load_base_model()
+        config = LoraConfig(
+            r=8,
+            init_lora_weights=False,
+            target_modules=["conv2d"],
+        )
+        model = get_peft_model(base_model, config)
+        self.assert_results_equal_or_store(model, "lora_conv2d")
+
+    def test_ia3(self):
+        base_model = self.load_base_model()
+        config = IA3Config(
+            init_ia3_weights=False,
+            target_modules=["conv2d"],
+            feedforward_modules=["conv2d"],
+        )
+        model = get_peft_model(base_model, config)
+        self.assert_results_equal_or_store(model, "ia3_conv2d")
+
+    def test_loha(self):
+        # TODO
+        self.skipTest("Skipping LoHa for now because init is not seedable")
+        base_model = self.load_base_model()
+        config = LoHaConfig(
+            r=8,
+            init_weights=False,
+            target_modules=["conv2d"],
+        )
+        model = get_peft_model(base_model, config)
+        self.assert_results_equal_or_store(model, "loha_conv2d")
+
+    def test_lokr(self):
+        # TODO
+        self.skipTest("Skipping LoKr for now because init is not seedable")
+        base_model = self.load_base_model()
+        config = LoKrConfig(
+            r=8,
+            init_weights=False,
+            target_modules=["conv2d"],
+        )
+        model = get_peft_model(base_model, config)
+        self.assert_results_equal_or_store(model, "lokr_conv2d")
+
+    def test_boft(self):
+        base_model = self.load_base_model()
+        config = BOFTConfig(
+            boft_block_size=3,
+            target_modules=["conv2d"],
+        )
+        model = get_peft_model(base_model, config)
+        self.assert_results_equal_or_store(model, "boft_conv2d")
+
+
+class TestOpt(RegressionTester):
+    def get_output(self, model):
+        input = torch.LongTensor([[1, 0, 1, 0, 1, 2]]).to(self.torch_device)
+        with torch.inference_mode():
+            output = model(input).logits
+        return output
+
+    def load_base_model(self):
+        self.fix_seed()
+        # Note: Since transformers v5, the default dtype for opt has changed from float32 to float16. This causes the
+        # regression test to fail. Therefore, ensure that a float32 model is being used.
+        dtype = torch.float32
+        return AutoModelForCausalLM.from_pretrained("facebook/opt-350m", dtype=dtype).to(self.torch_device)
+
+    def test_lora(self):
+        base_model = self.load_base_model()
+        config = LoraConfig(
+            r=8,
+            init_lora_weights=False,
+        )
+        model = get_peft_model(base_model, config)
+        self.assert_results_equal_or_store(model, "lora_opt-350m")
+
+    def test_adalora(self):
+        base_model = self.load_base_model()
+        config = AdaLoraConfig(
+            r=8,
+            init_lora_weights=False,
+            total_step=1,
+        )
+        model = get_peft_model(base_model, config)
+        self.assert_results_equal_or_store(model, "adalora_opt-350m")
+
+    def test_ia3(self):
+        base_model = self.load_base_model()
+        config = IA3Config(init_ia3_weights=False)
+        model = get_peft_model(base_model, config)
+        self.assert_results_equal_or_store(model, "ia3_opt-350m")
+
+
+@require_non_cpu
+@require_bitsandbytes
+class TestOpt8bitBnb(RegressionTester):
+    def get_output(self, model):
+        input = torch.LongTensor([[1, 0, 1, 0, 1, 2]]).to(self.torch_device)
+        with torch.inference_mode():
+            output = model(input).logits
+        return output
+
+    def load_base_model(self):
+        self.fix_seed()
+        model = AutoModelForCausalLM.from_pretrained(
+            "facebook/opt-350m",
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+        )
+        return model
+
+    def test_lora_8bit(self):
+        # Warning: bnb results can vary significantly depending on the GPU. Therefore, if there is a change in GPU used
+        # in the CI, the test can fail without any code change. In that case, delete the regression artifact and create
+        # a new one using the new GPU.
+        base_model = self.load_base_model()
+        config = LoraConfig(
+            r=8,
+            init_lora_weights=False,
+        )
+        model = get_peft_model(base_model, config)
+        self.assert_results_equal_or_store(model, "lora_opt-350m_bnb_8bit")
+
+    def test_adalora(self):
+        # TODO
+        self.skipTest(
+            "Skipping AdaLora for now, getting TypeError: unsupported operand type(s) for +=: 'dict' and 'Tensor'"
+        )
+        # Warning: bnb results can vary significantly depending on the GPU. Therefore, if there is a change in GPU used
+        # in the CI, the test can fail without any code change. In that case, delete the regression artifact and create
+        # a new one using the new GPU.
+        base_model = self.load_base_model()
+        config = AdaLoraConfig(
+            init_r=6,
+            target_r=4,
+            tinit=50,
+            tfinal=100,
+            total_step=200,
+            deltaT=5,
+            beta1=0.3,
+            beta2=0.3,
+            orth_reg_weight=0.2,
+            lora_alpha=32,
+            lora_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+        model = get_peft_model(base_model, config)
+        self.assert_results_equal_or_store(model, "adalora_opt-350m_8bit")
+
+
+@require_non_cpu
+@require_bitsandbytes
+class TestOpt4bitBnb(RegressionTester):
+    def get_output(self, model):
+        input = torch.LongTensor([[1, 0, 1, 0, 1, 2]]).to(self.torch_device)
+        with torch.inference_mode():
+            output = model(input).logits
+        return output
+
+    def load_base_model(self):
+        self.fix_seed()
+        bnb_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_use_double_quant=False,
+            bnb_4bit_compute_dtype=torch.float32,
+        )
+        model = AutoModelForCausalLM.from_pretrained(
+            "facebook/opt-350m",
+            quantization_config=bnb_config,
+            dtype=torch.float32,
+        )
+        return model
+
+    def test_lora_4bit(self):
+        # Warning: bnb results can vary significantly depending on the GPU. Therefore, if there is a change in GPU used
+        # in the CI, the test can fail without any code change. In that case, delete the regression artifact and create
+        # a new one using the new GPU.
+        base_model = self.load_base_model()
+        config = LoraConfig(
+            r=8,
+            init_lora_weights=False,
+        )
+        model = get_peft_model(base_model, config)
+        # NVIDIA A100 requires a lower tol to pass the test.
+        old_tol = self.tol
+        self.tol = 3e-2
+        try:
+            self.assert_results_equal_or_store(model, LORA_4BIT_FOLDER)
+        finally:
+            self.tol = old_tol
+
+    def test_adalora(self):
+        # TODO
+        self.skipTest("Skipping AdaLora for now because of a bug, see #1113")
+        # Warning: bnb results can vary significantly depending on the GPU. Therefore, if there is a change in GPU used
+        # in the CI, the test can fail without any code change. In that case, delete the regression artifact and create
+        # a new one using the new GPU.
+        base_model = self.load_base_model()
+        config = AdaLoraConfig(
+            init_r=6,
+            target_r=4,
+            tinit=50,
+            tfinal=100,
+            total_step=200,
+            deltaT=5,
+            beta1=0.3,
+            beta2=0.3,
+            orth_reg_weight=0.2,
+            lora_alpha=32,
+            lora_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+        model = get_peft_model(base_model, config)
+        self.assert_results_equal_or_store(model, "adalora_opt-350m_4bit")
diff --git a/tests/test_adamss_asa.py b/tests/test_adamss_asa.py
new file mode 100644
index 0000000..9a305e4
--- /dev/null
+++ b/tests/test_adamss_asa.py
@@ -0,0 +1,272 @@
+"""
+Unit tests for AdaMSS ASA (Adaptive Subspace Allocation) functionality.
+
+Tests cover:
+- update_importance: EMA-based importance score accumulation
+- reset_importance: clearing accumulated importance scores
+- update_and_allocate: full ASA flow (accumulate → global mask → reset)
+"""
+
+import torch
+from torch import nn
+
+from peft import AdamssConfig, get_peft_model
+from peft.tuners.adamss.layer import AdamssLayer
+
+
+class SimpleMLP(nn.Module):
+    """Minimal MLP for testing."""
+
+    def __init__(self, in_features=20, hidden=40, out_features=5):
+        super().__init__()
+        self.lin0 = nn.Linear(in_features, hidden)
+        self.relu = nn.ReLU()
+        self.lin1 = nn.Linear(hidden, out_features)
+
+    def forward(self, x):
+        return self.lin1(self.relu(self.lin0(x)))
+
+
+def _make_asa_model(target_modules=("lin0", "lin1"), r=8, num_subspaces=4, subspace_rank=1, **extra):
+    """Create a simple model with ASA enabled."""
+    base = SimpleMLP()
+    # Defaults that can be overridden via **extra
+    config_kwargs = {
+        "target_modules": list(target_modules),
+        "r": r,
+        "num_subspaces": num_subspaces,
+        "subspace_rank": subspace_rank,
+        "init_weights": None,
+        "use_asa": True,
+        "asa_target_subspaces": 2,
+        "init_warmup": 0,
+        "final_warmup": 100,
+        "mask_interval": 10,
+    }
+    config_kwargs.update(extra)
+    config = AdamssConfig(**config_kwargs)
+    return get_peft_model(base, config)
+
+
+def _run_train_step(model, optimizer, in_features=20):
+    """Run one full training step (forward + backward + optimizer)."""
+    x = torch.randn(4, in_features)
+    out = model(x)
+    loss = out.sum()
+    loss.backward()
+    optimizer.step()
+    optimizer.zero_grad()
+    return loss
+
+
+def _get_adamss_layers(model):
+    """Collect all AdamssLayer modules in the model."""
+    return [m for m in model.modules() if isinstance(m, AdamssLayer)]
+
+
+class TestAdamssAsa:
+    # -- update_importance --------------------------------------------------
+
+    def test_importance_populated_after_update(self):
+        """update_importance should populate exp_avg_ipt_A/B and exp_avg_unc_A/B."""
+        model = _make_asa_model()
+
+        # Forward+backward (no optimizer step needed, we just need gradients)
+        x = torch.randn(4, 20)
+        model(x).sum().backward()
+
+        layers = _get_adamss_layers(model)
+        assert len(layers) > 0
+        layer = layers[0]
+        adapter = "default"
+
+        # Before update: importance lists should be all None
+        assert all(v is None for v in layer.exp_avg_ipt_A[adapter])
+        assert all(v is None for v in layer.exp_avg_unc_A[adapter])
+
+        # Update importance
+        layer.update_importance(adapter, importance_beta=0.85, uncertainty_beta=0.85)
+
+        # After update: at least some entries should be populated
+        assert any(v is not None for v in layer.exp_avg_ipt_A[adapter]), "exp_avg_ipt_A should have entries"
+        assert any(v is not None for v in layer.exp_avg_unc_A[adapter]), "exp_avg_unc_A should have entries"
+
+        # At least some scores should be non-zero (B was seeded)
+        has_nonzero = any(v.abs().sum() > 0 for v in layer.exp_avg_ipt_A[adapter] if v is not None)
+        assert has_nonzero, "At least some importance scores should be non-zero"
+
+    def test_importance_accumulates_across_steps(self):
+        """Multiple training steps should produce changing (EMA-accumulated) scores."""
+        model = _make_asa_model()
+        optimizer = torch.optim.AdamW(model.parameters(), lr=0.1)
+
+        layers = _get_adamss_layers(model)
+        layer = layers[0]
+        adapter = "default"
+
+        # Step 1: train so B becomes non-zero
+        x = torch.randn(4, 20)
+        model(x).sum().backward()
+        optimizer.step()
+        optimizer.zero_grad()
+
+        # Step 2: now gradients for A should be non-zero
+        model(x).sum().backward()
+        layer.update_importance(adapter, 0.85, 0.85)
+        optimizer.step()
+        optimizer.zero_grad()
+
+        # Find first populated entry
+        first_idx = next(i for i, v in enumerate(layer.exp_avg_ipt_A[adapter]) if v is not None)
+        score_after_2 = layer.exp_avg_ipt_A[adapter][first_idx].clone()
+
+        # Step 3: another update should change scores via EMA
+        model(x).sum().backward()
+        layer.update_importance(adapter, 0.85, 0.85)
+        optimizer.step()
+        optimizer.zero_grad()
+
+        score_after_3 = layer.exp_avg_ipt_A[adapter][first_idx].clone()
+
+        assert not torch.allclose(score_after_2, score_after_3), (
+            "Importance should change between steps due to EMA accumulation"
+        )
+
+    # -- reset_importance ---------------------------------------------------
+
+    def test_reset_clears_scores(self):
+        """reset_importance should clear all accumulated scores."""
+        model = _make_asa_model()
+
+        x = torch.randn(4, 20)
+        model(x).sum().backward()
+
+        layers = _get_adamss_layers(model)
+        layer = layers[0]
+        adapter = "default"
+
+        # Populate importance
+        layer.update_importance(adapter, 0.85, 0.85)
+        assert any(v is not None for v in layer.exp_avg_ipt_A[adapter])
+
+        # Reset
+        layer.reset_importance(adapter)
+
+        # After reset: all entries should be None
+        assert all(v is None for v in layer.exp_avg_ipt_A[adapter]), "exp_avg_ipt_A should be all None after reset"
+        assert all(v is None for v in layer.exp_avg_unc_A[adapter]), "exp_avg_unc_A should be all None after reset"
+
+    # -- update_and_allocate ------------------------------------------------
+
+    def test_importance_accumulated_every_step(self):
+        """update_and_allocate should accumulate importance on non-mask-interval steps."""
+        model = _make_asa_model(init_warmup=0, final_warmup=100, mask_interval=10)
+        optimizer = torch.optim.AdamW(model.parameters(), lr=0.1)
+
+        # Step 0: train to make B non-zero
+        _run_train_step(model, optimizer)
+
+        # Steps 1-2: in warmup, NOT a mask interval → should accumulate importance
+        x = torch.randn(4, 20)
+        model(x).sum().backward()
+        optimizer.step()
+        model.base_model.update_and_allocate(1)
+        optimizer.zero_grad()
+
+        layers = _get_adamss_layers(model)
+        layer = layers[0]
+        assert any(v is not None for v in layer.exp_avg_ipt_A["default"]), (
+            "Importance should be populated after step 1 (non-mask-interval)"
+        )
+
+    def test_masking_reduces_active_params(self):
+        """At mask intervals, some subspaces should be frozen."""
+        model = _make_asa_model(
+            init_warmup=1,
+            final_warmup=100,
+            mask_interval=5,
+            asa_target_subspaces=2,
+            num_subspaces=4,
+        )
+        optimizer = torch.optim.AdamW(model.parameters(), lr=0.1)
+
+        # Count initially active params
+        layers = _get_adamss_layers(model)
+        initial_active = sum(1 for layer in layers for p in layer.adamss_A["default"] if p.requires_grad)
+
+        # Train for several steps.  Step 0 warms up B (B=0 initially).
+        # Steps 1-5 accumulate importance.  Step 5 hits mask_interval (5%5==0)
+        # and triggers masking with meaningful scores.
+        for step in range(6):
+            x = torch.randn(4, 20)
+            model(x).sum().backward()
+            optimizer.step()
+            model.base_model.update_and_allocate(step)
+            optimizer.zero_grad()
+
+        # After masking: should have fewer active params
+        final_active = sum(1 for layer in layers for p in layer.adamss_A["default"] if p.requires_grad)
+        final_frozen = sum(1 for layer in layers for p in layer.adamss_A["default"] if not p.requires_grad)
+
+        assert final_frozen > 0, "Expected some subspace parameters to be frozen by ASA"
+        assert final_active < initial_active, f"Active params should decrease: {initial_active} → {final_active}"
+
+    def test_importance_reset_after_masking(self):
+        """After a mask interval, importance should be reset for fresh accumulation."""
+        model = _make_asa_model(init_warmup=1, final_warmup=100, mask_interval=5)
+        optimizer = torch.optim.AdamW(model.parameters(), lr=0.1)
+
+        # Run to step 5 which triggers masking (5 % 5 == 0) and then reset
+        for step in range(6):
+            x = torch.randn(4, 20)
+            model(x).sum().backward()
+            optimizer.step()
+            model.base_model.update_and_allocate(step)
+            optimizer.zero_grad()
+
+        # After mask interval at step 5: importance should be cleared
+        layers = _get_adamss_layers(model)
+        for layer in layers:
+            assert all(v is None for v in layer.exp_avg_ipt_A["default"]), (
+                "Importance should be reset after mask interval"
+            )
+
+    def test_no_masking_outside_warmup(self):
+        """update_and_allocate should be a no-op outside warmup range."""
+        model = _make_asa_model(init_warmup=50, final_warmup=100, mask_interval=10)
+        optimizer = torch.optim.AdamW(model.parameters(), lr=0.1)
+
+        # Run step 10 (mask_interval hit but BEFORE init_warmup=50)
+        _run_train_step(model, optimizer)
+        model.base_model.update_and_allocate(10)
+
+        # No importance should be accumulated (outside warmup)
+        layers = _get_adamss_layers(model)
+        for layer in layers:
+            assert all(v is None for v in layer.exp_avg_ipt_A["default"]), (
+                "No importance accumulation should happen outside warmup"
+            )
+
+    def test_asa_disabled_is_noop(self):
+        """update_and_allocate should be a no-op when use_asa=False."""
+        base = SimpleMLP()
+        config = AdamssConfig(
+            target_modules=["lin0"],
+            r=8,
+            num_subspaces=4,
+            subspace_rank=1,
+            use_asa=False,
+        )
+        model = get_peft_model(base, config)
+        optimizer = torch.optim.AdamW(model.parameters(), lr=0.1)
+
+        _run_train_step(model, optimizer)
+        # Should not raise
+        model.base_model.update_and_allocate(0)
+        model.base_model.update_and_allocate(100)
+
+        # All params still trainable
+        layers = _get_adamss_layers(model)
+        for layer in layers:
+            for p in layer.adamss_A["default"]:
+                assert p.requires_grad
diff --git a/tests/test_adaption_prompt.py b/tests/test_adaption_prompt.py
new file mode 100644
index 0000000..19d2cb9
--- /dev/null
+++ b/tests/test_adaption_prompt.py
@@ -0,0 +1,416 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import os
+import tempfile
+
+import pytest
+import torch
+from torch.testing import assert_close
+from transformers import AutoModelForCausalLM
+
+from peft import get_peft_model
+from peft.peft_model import PeftModel
+from peft.tuners.adaption_prompt import AdaptionPromptConfig
+from peft.utils import infer_device
+from peft.utils.other import prepare_model_for_kbit_training
+from peft.utils.save_and_load import get_peft_model_state_dict
+
+
+MODELS_TO_TEST = [
+    "hf-internal-testing/tiny-random-gpt2",
+    "trl-internal-testing/tiny-random-LlamaForCausalLM",
+    "hf-internal-testing/tiny-random-MistralForCausalLM",
+]
+
+
+class TestAdaptionPrompt:
+    """
+    Tests for the AdaptionPrompt model.
+
+    Some of these tests were adapted from `test_peft_model.py` (which has been refactored since), but since we haven't
+    checked in the test checkpoints for Llama into `hf-internal-testing`, we separate them for now.
+    """
+
+    transformers_class = AutoModelForCausalLM
+    torch_device = infer_device()
+
+    @pytest.mark.parametrize("model_id", MODELS_TO_TEST)
+    def test_attributes(self, model_id):
+        model = self.transformers_class.from_pretrained(model_id)
+        config = AdaptionPromptConfig(adapter_layers=1, adapter_len=4)
+        model = get_peft_model(model, config)
+
+        assert hasattr(model, "save_pretrained")
+        assert hasattr(model, "from_pretrained")
+        assert hasattr(model, "push_to_hub")
+
+    @pytest.mark.parametrize("model_id", MODELS_TO_TEST)
+    def test_prepare_for_training(self, model_id):
+        model = self.transformers_class.from_pretrained(model_id)
+        config = AdaptionPromptConfig(adapter_layers=1, adapter_len=4, task_type="CAUSAL_LM")
+        model = get_peft_model(model, config)
+        model = model.to(self.torch_device)
+
+        dummy_input = torch.LongTensor([[1, 1, 1]]).to(self.torch_device)
+        dummy_output = model.get_input_embeddings()(dummy_input)
+
+        assert not dummy_output.requires_grad
+
+    @pytest.mark.parametrize("model_id", MODELS_TO_TEST)
+    def test_prepare_for_int8_training(self, model_id):
+        model = self.transformers_class.from_pretrained(model_id)
+        model = prepare_model_for_kbit_training(model)
+        model = model.to(self.torch_device)
+
+        for param in model.parameters():
+            assert not param.requires_grad
+
+        config = AdaptionPromptConfig(adapter_layers=1, adapter_len=4, task_type="CAUSAL_LM")
+        model = get_peft_model(model, config)
+
+        # For backward compatibility
+        if hasattr(model, "enable_input_require_grads"):
+            model.enable_input_require_grads()
+        else:
+
+            def make_inputs_require_grad(module, input, output):
+                output.requires_grad_(True)
+
+            model.get_input_embeddings().register_forward_hook(make_inputs_require_grad)
+
+        dummy_input = torch.LongTensor([[1, 1, 1]]).to(self.torch_device)
+        dummy_output = model.get_input_embeddings()(dummy_input)
+
+        assert dummy_output.requires_grad
+
+    @pytest.mark.parametrize("model_id", MODELS_TO_TEST)
+    def test_save_pretrained_regression(self, model_id):
+        seed = 420
+        torch.manual_seed(seed)
+        model = self.transformers_class.from_pretrained(model_id)
+        config = AdaptionPromptConfig(adapter_layers=2, adapter_len=4, task_type="CAUSAL_LM")
+        model = get_peft_model(model, config)
+        model = model.to(self.torch_device)
+
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            model.save_pretrained(tmp_dirname, safe_serialization=False)
+
+            torch.manual_seed(seed)
+            model_from_pretrained = self.transformers_class.from_pretrained(model_id)
+            model_from_pretrained = PeftModel.from_pretrained(model_from_pretrained, tmp_dirname)
+
+            # check if the state dicts are equal
+            state_dict = get_peft_model_state_dict(model)
+            state_dict_from_pretrained = get_peft_model_state_dict(model_from_pretrained)
+
+            # check if same keys
+            assert state_dict.keys() == state_dict_from_pretrained.keys()
+
+            # Check that the number of saved parameters is 4 -- 2 layers of (tokens and gate).
+            assert len(state_dict) == 4
+
+            # check if tensors equal
+            for key in state_dict.keys():
+                assert torch.allclose(
+                    state_dict[key].to(self.torch_device), state_dict_from_pretrained[key].to(self.torch_device)
+                )
+
+            # check if `adapter_model.bin` is present
+            assert os.path.exists(os.path.join(tmp_dirname, "adapter_model.bin"))
+
+            # check if `adapter_config.json` is present
+            assert os.path.exists(os.path.join(tmp_dirname, "adapter_config.json"))
+
+            # check if `model.safetensors` is not present
+            assert not os.path.exists(os.path.join(tmp_dirname, "model.safetensors"))
+
+            # check if `config.json` is not present
+            assert not os.path.exists(os.path.join(tmp_dirname, "config.json"))
+
+    @pytest.mark.parametrize("model_id", MODELS_TO_TEST)
+    def test_save_pretrained(self, model_id):
+        seed = 420
+        torch.manual_seed(seed)
+        model = self.transformers_class.from_pretrained(model_id)
+        config = AdaptionPromptConfig(adapter_layers=2, adapter_len=4, task_type="CAUSAL_LM")
+        model = get_peft_model(model, config)
+        model = model.to(self.torch_device)
+
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            model.save_pretrained(tmp_dirname)
+
+            torch.manual_seed(seed)
+            model_from_pretrained = self.transformers_class.from_pretrained(model_id)
+            model_from_pretrained = PeftModel.from_pretrained(model_from_pretrained, tmp_dirname)
+
+            # check if the state dicts are equal
+            state_dict = get_peft_model_state_dict(model)
+            state_dict_from_pretrained = get_peft_model_state_dict(model_from_pretrained)
+
+            # check if same keys
+            assert state_dict.keys() == state_dict_from_pretrained.keys()
+
+            # Check that the number of saved parameters is 4 -- 2 layers of (tokens and gate).
+            assert len(state_dict) == 4
+
+            # check if tensors equal
+            for key in state_dict.keys():
+                assert torch.allclose(
+                    state_dict[key].to(self.torch_device), state_dict_from_pretrained[key].to(self.torch_device)
+                )
+
+            # check if `adapter_model.bin` is present
+            assert os.path.exists(os.path.join(tmp_dirname, "adapter_model.safetensors"))
+
+            # check if `adapter_config.json` is present
+            assert os.path.exists(os.path.join(tmp_dirname, "adapter_config.json"))
+
+            # check if `model.safetensors` is not present
+            assert not os.path.exists(os.path.join(tmp_dirname, "model.safetensors"))
+
+            # check if `config.json` is not present
+            assert not os.path.exists(os.path.join(tmp_dirname, "config.json"))
+
+    @pytest.mark.parametrize("model_id", MODELS_TO_TEST)
+    def test_save_pretrained_selected_adapters(self, model_id):
+        seed = 420
+        torch.manual_seed(seed)
+        model = self.transformers_class.from_pretrained(model_id)
+        config = AdaptionPromptConfig(adapter_layers=2, adapter_len=4, task_type="CAUSAL_LM")
+        model = get_peft_model(model, config)
+        model = model.to(self.torch_device)
+
+        new_adapter_config = AdaptionPromptConfig(adapter_layers=2, adapter_len=4, task_type="CAUSAL_LM")
+        model.add_adapter("new_adapter", new_adapter_config)
+
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            model.save_pretrained(tmp_dirname)
+
+            torch.manual_seed(seed)
+            model_from_pretrained = self.transformers_class.from_pretrained(model_id)
+            model_from_pretrained = PeftModel.from_pretrained(model_from_pretrained, tmp_dirname)
+
+            model_from_pretrained.load_adapter(tmp_dirname, "new_adapter")
+
+            # check if the state dicts are equal
+            state_dict = get_peft_model_state_dict(model)
+            state_dict_from_pretrained = get_peft_model_state_dict(model_from_pretrained)
+
+            # check if same keys
+            assert state_dict.keys() == state_dict_from_pretrained.keys()
+
+            # Check that the number of saved parameters is 4 -- 2 layers of (tokens and gate).
+            assert len(state_dict) == 4
+
+            # check if tensors equal
+            for key in state_dict.keys():
+                assert torch.allclose(
+                    state_dict[key].to(self.torch_device), state_dict_from_pretrained[key].to(self.torch_device)
+                )
+
+            # check if `adapter_model.bin` is present
+            assert os.path.exists(os.path.join(tmp_dirname, "adapter_model.safetensors"))
+
+            # check if `adapter_config.json` is present
+            assert os.path.exists(os.path.join(tmp_dirname, "adapter_config.json"))
+
+            # check if `model.safetensors` is not present
+            assert not os.path.exists(os.path.join(tmp_dirname, "model.safetensors"))
+
+            # check if `config.json` is not present
+            assert not os.path.exists(os.path.join(tmp_dirname, "config.json"))
+
+    @pytest.mark.parametrize("model_id", MODELS_TO_TEST)
+    def test_generate(self, model_id):
+        model = self.transformers_class.from_pretrained(model_id)
+        config = AdaptionPromptConfig(adapter_layers=2, adapter_len=4, task_type="CAUSAL_LM")
+        model = get_peft_model(model, config)
+        model = model.to(self.torch_device)
+
+        input_ids = torch.LongTensor([[1, 1, 1], [2, 1, 2]]).to(self.torch_device)
+        attention_mask = torch.LongTensor([[1, 1, 1], [1, 0, 1]]).to(self.torch_device)
+
+        # check if `generate` works
+        _ = model.generate(input_ids=input_ids, attention_mask=attention_mask)
+
+        # check if `generate` works if positional arguments are passed
+        _ = model.generate(input_ids, attention_mask=attention_mask)
+
+    @pytest.mark.parametrize("model_id", MODELS_TO_TEST)
+    def test_sequence_adapter_ops(self, model_id):
+        """Test sequence of adapter operations."""
+        # Test input data.
+        input_ids = torch.LongTensor([[1, 1, 1], [2, 1, 2]]).to(self.torch_device)
+        target_ids = torch.LongTensor([[0, 0, 0], [0, 0, 0]]).to(self.torch_device)
+        attention_mask = torch.LongTensor([[1, 1, 1], [1, 0, 1]]).to(self.torch_device)
+
+        # Create original llama model.
+        original = self.transformers_class.from_pretrained(model_id)
+        original = original.to(self.torch_device)
+        original_before = original(input_ids=input_ids, attention_mask=attention_mask)
+
+        # Get AdaptionPrompt model.
+        adapted = get_peft_model(
+            original, AdaptionPromptConfig(adapter_layers=2, adapter_len=4, task_type="CAUSAL_LM")
+        )
+        adapted = adapted.to(self.torch_device)
+        default_before = adapted(input_ids=input_ids, attention_mask=attention_mask, labels=target_ids)
+
+        # Test zero-init: The logits should be exactly the same.
+        assert_close(original_before.logits, default_before.logits, rtol=0, atol=0)
+
+        # Single fine-tuning step on "default" adapter.
+        optimizer = torch.optim.SGD(adapted.parameters(), lr=1)
+        optimizer.zero_grad()
+        default_before.loss.backward()
+        optimizer.step()
+
+        # Test that the output changed.
+        default_after = adapted(input_ids=input_ids, attention_mask=attention_mask, labels=target_ids)
+        assert not torch.allclose(default_before.logits, default_after.logits)
+
+        with adapted.disable_adapter():
+            # Test that the output is the same as the original output.
+            default_disabled = adapted(input_ids=input_ids, attention_mask=attention_mask, labels=target_ids)
+            assert_close(original_before.logits, default_disabled.logits, rtol=0, atol=0)
+
+        # Add new adapter 1.
+        adapted.add_adapter("adapter 1", AdaptionPromptConfig(adapter_layers=2, adapter_len=8, task_type="CAUSAL_LM"))
+        # Test zero-init
+        adapter_1_before = adapted(input_ids=input_ids, attention_mask=attention_mask, labels=target_ids)
+        assert_close(original_before.logits, adapter_1_before.logits, rtol=0, atol=0)
+
+        # Single fine-tuning step on adapter 1.
+        optimizer = torch.optim.SGD(adapted.parameters(), lr=1)
+        optimizer.zero_grad()
+        adapter_1_before.loss.backward()
+        optimizer.step()
+
+        # Test that adapter 1 output changed.
+        adapter_1_after = adapted(input_ids=input_ids, attention_mask=attention_mask, labels=target_ids)
+        assert not torch.allclose(adapter_1_before.logits, adapter_1_after.logits)
+        assert not torch.allclose(original_before.logits, adapter_1_after.logits)
+        assert not torch.allclose(default_after.logits, adapter_1_after.logits)
+
+        with adapted.disable_adapter():
+            # Test that the output is the same as the original output.
+            adapter_1_disabled = adapted(input_ids=input_ids, attention_mask=attention_mask, labels=target_ids)
+            assert_close(original_before.logits, adapter_1_disabled.logits, rtol=0, atol=0)
+
+        # Set adapter back to default.
+        adapted.set_adapter("default")
+
+        # Test that the output is the same as the default output after training.
+        default_after_set = adapted(input_ids=input_ids, attention_mask=attention_mask, labels=target_ids)
+        assert_close(default_after.logits, default_after_set.logits, rtol=0, atol=0)
+        assert not torch.allclose(original_before.logits, default_after_set.logits)
+        assert not torch.allclose(adapter_1_after.logits, default_after_set.logits)
+
+    @pytest.mark.parametrize("model_id", MODELS_TO_TEST)
+    def test_add_and_set_while_disabled(self, model_id):
+        """Test that adding and setting adapters while disabled works as intended."""
+        # Test input data.
+        input_ids = torch.LongTensor([[1, 1, 1], [2, 1, 2]]).to(self.torch_device)
+        target_ids = torch.LongTensor([[0, 0, 0], [0, 0, 0]]).to(self.torch_device)
+        attention_mask = torch.LongTensor([[1, 1, 1], [1, 0, 1]]).to(self.torch_device)
+
+        # Create original llama model.
+        original = self.transformers_class.from_pretrained(model_id)
+        original = original.to(self.torch_device)
+        original_before = original(input_ids=input_ids, attention_mask=attention_mask)
+
+        # Get AdaptionPrompt model.
+        adapted = get_peft_model(
+            original, AdaptionPromptConfig(adapter_layers=2, adapter_len=4, task_type="CAUSAL_LM")
+        )
+        adapted = adapted.to(self.torch_device)
+
+        with adapted.disable_adapter():
+            adapted.add_adapter(
+                "adapter 1", AdaptionPromptConfig(adapter_layers=2, adapter_len=8, task_type="CAUSAL_LM")
+            )
+
+        # Test that the output is the same as the original output.
+        adapter_1_before = adapted(input_ids=input_ids, attention_mask=attention_mask, labels=target_ids)
+        assert_close(original_before.logits, adapter_1_before.logits, rtol=0, atol=0)
+
+        # Single fine-tuning step on adapter 1.
+        optimizer = torch.optim.SGD(adapted.parameters(), lr=1)
+        optimizer.zero_grad()
+        adapter_1_before.loss.backward()
+        optimizer.step()
+
+        # Test that adapter 1 output changed.
+        adapter_1_after = adapted(input_ids=input_ids, attention_mask=attention_mask, labels=target_ids)
+        assert not torch.allclose(original_before.logits, adapter_1_after.logits)
+
+        adapted.set_adapter("default")
+        with adapted.disable_adapter():
+            adapted.set_adapter("adapter 1")
+
+        # Test that adapter 1 is active again.
+        adapter_1_after_set = adapted(input_ids=input_ids, attention_mask=attention_mask, labels=target_ids)
+        assert_close(adapter_1_after.logits, adapter_1_after_set.logits, rtol=0, atol=0)
+
+    @pytest.mark.parametrize("model_id", MODELS_TO_TEST)
+    def test_use_cache(self, model_id):
+        """Test that AdaptionPrompt works when Llama config use_cache=True."""
+        torch.manual_seed(0)
+        input_ids = torch.LongTensor([[1, 1, 1], [2, 1, 2]]).to(self.torch_device)
+        original = self.transformers_class.from_pretrained(model_id, use_cache=False)
+        adapted = get_peft_model(
+            original, AdaptionPromptConfig(adapter_layers=2, adapter_len=4, task_type="CAUSAL_LM")
+        )
+        adapted = adapted.to(self.torch_device)
+        expected = adapted.generate(input_ids=input_ids, max_length=8)
+
+        # Set use_cache = True and generate output again.
+        adapted.base_model.config.use_cache = True
+        actual = adapted.generate(input_ids=input_ids, max_length=8)
+        assert_close(expected, actual, rtol=0, atol=0)
+
+    @pytest.mark.parametrize("model_id", MODELS_TO_TEST)
+    def test_bf16_inference(self, model_id):
+        if self.torch_device == "mps":
+            return pytest.skip("Skipping bf16 test on MPS")
+
+        """Test that AdaptionPrompt works when Llama using a half-precision model."""
+        input_ids = torch.LongTensor([[1, 1, 1], [2, 1, 2]]).to(self.torch_device)
+        original = self.transformers_class.from_pretrained(model_id, dtype=torch.bfloat16)
+        adapted = get_peft_model(
+            original, AdaptionPromptConfig(adapter_layers=2, adapter_len=4, task_type="CAUSAL_LM")
+        )
+        adapted = adapted.to(self.torch_device)
+        adapted.generate(input_ids=input_ids)  # does not raise
+
+    @pytest.mark.xfail(reason="currently this fails because scores are zeroed out", raises=AssertionError)
+    @pytest.mark.parametrize("model_id", MODELS_TO_TEST)
+    def test_disable_adapter(self, model_id):
+        model = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+        dummy_input = torch.LongTensor([[1, 1, 1]]).to(self.torch_device)
+        output_before = model(dummy_input).logits
+
+        config = AdaptionPromptConfig(adapter_layers=1, adapter_len=4, task_type="CAUSAL_LM")
+        model = get_peft_model(model, config).to(self.torch_device)
+        output_peft = model(dummy_input).logits
+        # TODO currently this fails because scores are zeroed out:
+        # https://github.com/huggingface/peft/blob/062d95a09eb5d1de35c0e5e23d4387daba99e2db/src/peft/tuners/adaption_prompt.py#L303
+        # This is fine for users but makes it difficult to test if anything happens. In the future, we will have a clean
+        # way to control initialization. Until then, this test is expected to fail.
+        assert not torch.allclose(output_before, output_peft)
+
+        with model.disable_adapter():
+            output_peft_disabled = model(dummy_input).logits
+        assert torch.allclose(output_before, output_peft_disabled)
diff --git a/tests/test_arrow.py b/tests/test_arrow.py
new file mode 100644
index 0000000..5bf84e1
--- /dev/null
+++ b/tests/test_arrow.py
@@ -0,0 +1,509 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+import copy
+import os
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+import torch
+from transformers import AutoModelForCausalLM, AutoModelForImageClassification
+
+from peft import LoraConfig, get_peft_model
+from peft.tuners.lora import ArrowConfig, create_arrow_model
+from peft.tuners.lora.arrow import _resolve_adapter_source
+from tests.testing_utils import hub_online_once
+
+
+# ─── Fixtures ──────────────────────────────────────────────────────────
+
+
+@pytest.fixture(scope="module")
+def workdir(tmp_path_factory):
+    """
+    Create a temp directory and chdir into it for the duration of the module.
+    """
+    wd = tmp_path_factory.mktemp("arrow_workdir")
+    old_cwd = os.getcwd()
+    os.chdir(wd)
+    yield Path(wd)
+    os.chdir(old_cwd)
+    # (pytest will auto-delete wd)
+
+
+def _create_and_save_adapter(out_dir: Path, rank: int = 4):
+    """Helper: build a LoRA adapter around `model` and save into `out_dir`."""
+    # fan_in_fan_out is set to True because of GPT2 model that we use to avoid warning
+    cfg = LoraConfig(r=rank, target_modules=["c_attn"], fan_in_fan_out=True, init_lora_weights=False)
+    model_id = "peft-internal-testing/tiny-random-gpt2"
+    with hub_online_once(model_id):
+        model = AutoModelForCausalLM.from_pretrained(model_id)
+    peft_model = get_peft_model(model, cfg)
+    peft_model.save_pretrained(out_dir)
+
+
+@pytest.fixture(scope="module")
+def ts_adapters(workdir: Path):
+    """
+    Build 3 task-specific adapters and return their absolute paths
+    """
+    abs_paths = []
+    for i in range(3):
+        sub = f"{workdir}/ts{i}"
+        _create_and_save_adapter(sub)
+        abs_paths.append(sub)
+    return abs_paths
+
+
+@pytest.fixture(scope="module")
+def gen_adapter(workdir: Path):
+    """Build 1 general-knowledge adapter and return its absolute path list."""
+    sub = f"{workdir}/gen0"
+    _create_and_save_adapter(sub)
+    return [sub]  # list because create_arrow_model expects list
+
+
+class TestArrowRouting:
+    def test_incompatible_rank_raises(self, workdir: Path):
+        """
+        Adding adapters with different ranks must raise a ValueError.
+        """
+        # Create two adapters with different ranks targeting the same modules
+        sub_r4 = workdir / "rank4"
+        sub_r8 = workdir / "rank8"
+        _create_and_save_adapter(sub_r4, rank=4)
+        _create_and_save_adapter(sub_r8, rank=8)
+
+        model_id = "peft-internal-testing/tiny-random-gpt2"
+        with hub_online_once(model_id):
+            base = AutoModelForCausalLM.from_pretrained(model_id)
+
+        # Expect create_arrow_model to raise due to rank mismatch
+        with pytest.raises(ValueError, match=r"rank mismatch"):
+            _ = create_arrow_model(
+                base_model=base,
+                task_specific_adapter_paths=[str(sub_r4), str(sub_r8)],
+                arrow_config=ArrowConfig(top_k=1),
+            )
+
+    def test_arrow_differs_with_extra_expert(self, ts_adapters):
+        """
+        Arrow with 2 experts vs Arrow with 3 experts must produce different logits.
+        """
+        # Arrow over first 2 experts
+        model_id = "peft-internal-testing/tiny-random-gpt2"
+        with hub_online_once(model_id):
+            base_model_1 = AutoModelForCausalLM.from_pretrained(model_id)
+            base_model_2 = copy.deepcopy(base_model_1)
+        cfg_small = ArrowConfig(top_k=2)
+        m_small = create_arrow_model(
+            base_model=base_model_1,
+            task_specific_adapter_paths=ts_adapters[:2],
+            arrow_config=cfg_small,
+        ).eval()
+
+        # Arrow over all 3 experts
+        cfg_big = ArrowConfig(top_k=2)
+        m_big = create_arrow_model(
+            base_model=base_model_2,
+            task_specific_adapter_paths=ts_adapters,
+            arrow_config=cfg_big,
+        ).eval()
+
+        x = torch.ones(1, 4, dtype=torch.long)
+        assert not torch.allclose(m_small(x).logits, m_big(x).logits)
+
+    def test_arrow_gks_with_load_adapter_later_with_forward(self, ts_adapters, gen_adapter):
+        """
+        Loading the last expert after creating the arrow model should produce the same result as loading all the
+        experts at once in create_arrow_model(), when forward path is called before adding the new adapter.
+        """
+        # Arrow over all three experts
+        model_id = "peft-internal-testing/tiny-random-gpt2"
+        with hub_online_once(model_id):
+            base_model_1 = AutoModelForCausalLM.from_pretrained(model_id)
+            base_model_2 = copy.deepcopy(base_model_1)
+        cfg_big = ArrowConfig(top_k=2, use_gks=True, rng_seed=42)
+        m_big = create_arrow_model(
+            base_model=base_model_1,
+            task_specific_adapter_paths=ts_adapters,
+            general_adapter_paths=gen_adapter,
+            arrow_config=cfg_big,
+        ).eval()
+
+        # Arrow over all 2 experts + loading the third expert later
+        cfg_small_later_big = ArrowConfig(top_k=2, use_gks=True, rng_seed=42)
+        m_small_later_big = create_arrow_model(
+            base_model=base_model_2,
+            task_specific_adapter_paths=ts_adapters[:2],
+            general_adapter_paths=gen_adapter,
+            arrow_config=cfg_small_later_big,
+        )
+
+        # Ensuring that the prototypes and gks are done one time by running a forward path
+        x = torch.ones(1, 4, dtype=torch.long)
+        m_small_later_big(x)
+
+        # Now loading the third expert
+        m_small_later_big.load_adapter(
+            model_id=ts_adapters[-1],
+            adapter_name="new_added_ts_expert",
+        )
+        # Activating the new adapter and run forward path on it
+        m_small_later_big.set_adapter("new_added_ts_expert")
+        x = torch.ones(3, 5, dtype=torch.long)
+        m_small_later_big(x)
+
+        # Now we switch back to the arrow_router
+        m_small_later_big.set_adapter("arrow_router")
+        m_small_later_big.eval()
+
+        x = torch.ones(1, 4, dtype=torch.long)
+        assert torch.allclose(m_big(x).logits, m_small_later_big(x).logits)
+
+    def test_arrow_with_load_adapter_later_with_forward_activate_new(self, ts_adapters, gen_adapter):
+        """
+        Loading the last expert after creating the arrow model and activate it should produce different result compared
+        to the case where arrow_router is activate, and the model's using arrow.
+        """
+        # Arrow over all three experts
+        model_id = "peft-internal-testing/tiny-random-gpt2"
+        with hub_online_once(model_id):
+            base_model_1 = AutoModelForCausalLM.from_pretrained(model_id)
+            base_model_2 = copy.deepcopy(base_model_1)
+        cfg_big = ArrowConfig(top_k=2, use_gks=True, rng_seed=42)
+        m_big = create_arrow_model(
+            base_model=base_model_1,
+            task_specific_adapter_paths=ts_adapters,
+            general_adapter_paths=gen_adapter,
+            arrow_config=cfg_big,
+        ).eval()
+
+        # Arrow over all 2 experts + loading the third expert later
+        cfg_small_later_big = ArrowConfig(top_k=2, use_gks=True, rng_seed=42)
+        m_small_later_big = create_arrow_model(
+            base_model=base_model_2,
+            task_specific_adapter_paths=ts_adapters[:2],
+            general_adapter_paths=gen_adapter,
+            arrow_config=cfg_small_later_big,
+        )
+
+        # Ensuring that the prototypes and gks are done one time by running a forward path
+        x = torch.ones(1, 4, dtype=torch.long)
+        m_small_later_big(x)
+
+        # Now loading the third expert
+        m_small_later_big.load_adapter(
+            model_id=ts_adapters[-1],
+            adapter_name="new_added_ts_expert",
+        )
+        # The new adapter is activated
+        m_small_later_big.set_adapter("new_added_ts_expert")
+        m_small_later_big.eval()
+
+        x = torch.ones(1, 4, dtype=torch.long)
+        assert not torch.allclose(m_big(x).logits, m_small_later_big(x).logits)
+
+    def test_arrow_gks_with_load_adapter_later_without_forward(self, ts_adapters, gen_adapter):
+        """
+        Loading the last expert after creating the arrow model should produce the same result as loading all the
+        experts at once in create_arrow_model()
+        """
+        # Arrow over all three experts
+        model_id = "peft-internal-testing/tiny-random-gpt2"
+        with hub_online_once(model_id):
+            base_model_1 = AutoModelForCausalLM.from_pretrained(model_id)
+            base_model_2 = copy.deepcopy(base_model_1)
+        cfg_big = ArrowConfig(top_k=2, use_gks=True, rng_seed=42)
+        m_big = create_arrow_model(
+            base_model=base_model_1,
+            task_specific_adapter_paths=ts_adapters,
+            general_adapter_paths=gen_adapter,
+            arrow_config=cfg_big,
+        ).eval()
+
+        # Arrow over all 2 experts + loading the third expert later
+        cfg_small_later_big = ArrowConfig(top_k=2, use_gks=True, rng_seed=42)
+        m_small_later_big = create_arrow_model(
+            base_model=base_model_2,
+            task_specific_adapter_paths=ts_adapters[:2],
+            general_adapter_paths=gen_adapter,
+            arrow_config=cfg_small_later_big,
+        )
+
+        # Now loading the third expert
+        m_small_later_big.load_adapter(
+            model_id=ts_adapters[-1],
+            adapter_name="new_added_ts_expert",
+        )
+        m_small_later_big.eval()
+
+        x = torch.ones(1, 4, dtype=torch.long)
+        assert torch.allclose(m_big(x).logits, m_small_later_big(x).logits)
+
+    def test_genknowsub_changes_output(self, ts_adapters, gen_adapter):
+        """
+        Arrow+GenKnowSub vs plain Arrow must change logits.
+        """
+        # Plain Arrow
+        model_id = "peft-internal-testing/tiny-random-gpt2"
+        with hub_online_once(model_id):
+            base_model_1 = AutoModelForCausalLM.from_pretrained(model_id)
+            base_model_2 = copy.deepcopy(base_model_1)
+        cfg_plain = ArrowConfig(top_k=2)
+        m_plain = create_arrow_model(
+            base_model=base_model_1,
+            task_specific_adapter_paths=ts_adapters,
+            arrow_config=cfg_plain,
+        ).eval()
+
+        # Arrow + GenKnowSub
+        cfg_gks = ArrowConfig(top_k=2, use_gks=True)
+        m_gks = create_arrow_model(
+            base_model=base_model_2,
+            task_specific_adapter_paths=ts_adapters,
+            general_adapter_paths=gen_adapter,
+            arrow_config=cfg_gks,
+        ).eval()
+
+        x = torch.ones(1, 4, dtype=torch.long)
+        assert not torch.allclose(m_plain(x).logits, m_gks(x).logits)
+
+    def test_merging_adapters_raise_error_in_arrow(self, ts_adapters):
+        """
+        Merging/unmerging is not allowed while an ArrowLinearLayer is loaded on the model and active.
+        """
+        # Arrow over first 2 experts
+        model_id = "peft-internal-testing/tiny-random-gpt2"
+        with hub_online_once(model_id):
+            base_model = AutoModelForCausalLM.from_pretrained(model_id)
+        cfg_small = ArrowConfig(top_k=2)
+        m_small = create_arrow_model(
+            base_model=base_model,
+            task_specific_adapter_paths=ts_adapters[:2],
+            arrow_config=cfg_small,
+        ).eval()
+
+        with pytest.raises(RuntimeError, match=r"Cannot merge an active Arrow router adapter"):
+            m_small.merge_and_unload()
+
+    def test_conv2d_targets_raise_typeerror_in_arrow(self, workdir):
+        """
+        Adapters applied to Conv2d must be rejected by create_arrow_model() which enforces Linear/Linear4bit-only
+        targets.
+        """
+
+        model_id = "peft-internal-testing/tiny-random-ResNetForImageClassification"
+        with hub_online_once(model_id):
+            base = AutoModelForImageClassification.from_pretrained(model_id)
+
+        # Build a LoRA adapter targeting a Conv2d
+        cfg = LoraConfig(r=4, target_modules=["convolution"], init_lora_weights=False)
+        peft_model = get_peft_model(copy.deepcopy(base), cfg)
+
+        conv_dir = workdir / "cv0"
+        peft_model.save_pretrained(conv_dir)
+
+        # Expect create_arrow_model to raise TypeError
+        with pytest.raises(TypeError, match=r"LoRA adapters must only target Linear"):
+            _ = create_arrow_model(
+                base_model=base,
+                task_specific_adapter_paths=[str(conv_dir)],
+                arrow_config=ArrowConfig(top_k=1),
+            )
+
+    def test_arrow_forward_float16_no_autocast_with_merging(self, ts_adapters):
+        """
+        Run Arrow in float16 with autocast disabled; forward should work, while merge/unmerge operations must raise for
+        Arrow models.
+        """
+        import platform
+
+        try:
+            _ = torch.zeros(1, dtype=torch.float16)
+        except Exception:
+            pytest.skip(reason="Test requires float16 support")
+
+        if platform.system() == "Darwin":
+            pytest.skip(reason="MacOS does not support multiple ops in float16")
+
+        model_id = "peft-internal-testing/tiny-random-gpt2"
+
+        # Create base in fp16 (no manual assignment to .dtype)
+        with hub_online_once(model_id):
+            base = AutoModelForCausalLM.from_pretrained(model_id, dtype=torch.float16)
+
+        cfg = ArrowConfig(top_k=2)
+
+        # Build Arrow model and disable adapter dtype autocast
+        model = create_arrow_model(
+            base_model=base,
+            task_specific_adapter_paths=ts_adapters,
+            arrow_config=cfg,
+            autocast_adapter_dtype=False,
+            dtype=torch.float16,
+        ).eval()
+
+        X = {
+            "input_ids": torch.ones(1, 4, dtype=torch.long),
+            "attention_mask": torch.ones(1, 4, dtype=torch.long),
+        }
+
+        # Forward should work in fp16
+        _ = model(**X)
+
+        # Merge must fail on Arrow models
+        with pytest.raises(RuntimeError, match=r"Cannot merge an active Arrow router adapter"):
+            model.merge_adapter(safe_merge=False)
+
+        with pytest.raises(RuntimeError, match=r"Cannot merge an active Arrow router adapter"):
+            _ = model.merge_and_unload()
+
+    def test_prototypes_not_recomputed_on_repeated_forward(self, ts_adapters):
+        """
+        Repeated calls to forward should not recompute prototypes. We verify by spying on
+        ArrowLoraLinearLayer.top_right_singular_vec_from_BA(), which is only called when prototypes are (re)built.
+        """
+        model_id = "peft-internal-testing/tiny-random-gpt2"
+        with hub_online_once(model_id):
+            base = AutoModelForCausalLM.from_pretrained(model_id)
+
+        cfg = ArrowConfig(top_k=2)
+        model = create_arrow_model(
+            base_model=base,
+            task_specific_adapter_paths=ts_adapters,
+            arrow_config=cfg,
+        ).eval()
+
+        # Find one Arrow layer instance on the model
+        arrow_layer = None
+        for _, module in model.named_modules():
+            if hasattr(module, "lora_arrow") and "arrow_router" in module.lora_arrow:
+                arrow_layer = module.lora_arrow["arrow_router"]
+                break
+        assert arrow_layer is not None, "Arrow router layer not found on model"
+
+        x = torch.ones(1, 4, dtype=torch.long)
+
+        # Spy on the internal proto computation; should run once (E calls for E experts)
+        with patch.object(
+            arrow_layer,
+            "top_right_singular_vec_from_BA",
+            wraps=arrow_layer.top_right_singular_vec_from_BA,
+        ) as spy:
+            _ = model(x)
+            first_calls = spy.call_count
+            assert first_calls == len(arrow_layer.task_adapter_names)
+
+            # Call forward again; prototypes should be cached, so no extra calls
+            _ = model(x)
+        assert spy.call_count == first_calls
+
+
+def test_training_updates_when_task_adapter_active(ts_adapters):
+    """
+    Ensure a simple training step works: compute a dummy loss, backward, and take an optimizer step. Verify that
+    task-adapter parameters update.
+    """
+    model_id = "peft-internal-testing/tiny-random-gpt2"
+    with hub_online_once(model_id):
+        base = AutoModelForCausalLM.from_pretrained(model_id)
+
+    # Build Arrow model over two experts
+    cfg = ArrowConfig(top_k=2)
+    model = create_arrow_model(
+        base_model=base,
+        task_specific_adapter_paths=ts_adapters[:2],
+        arrow_config=cfg,
+    )
+    model.train()
+
+    # Switch to a specific task adapter for training (vanilla LoRA)
+    model.set_adapter("task_0")
+
+    # Choose a representative parameter to check updates (task_0 A weight)
+    rep_name = None
+    for n, _ in model.named_parameters():
+        if ".lora_A.task_0.weight" in n:
+            rep_name = n
+            break
+    assert rep_name is not None, "task_0 LoRA A weight not found"
+    rep_param = dict(model.named_parameters())[rep_name]
+    before = rep_param.detach().clone()
+
+    # Optimizer over trainable params (task_0 now active and trainable)
+    opt = torch.optim.SGD([p for p in model.parameters() if p.requires_grad], lr=1e-2)
+
+    # Dummy batch
+    vocab = model.config.vocab_size
+    input_ids = torch.randint(0, vocab, (2, 8))
+    attention_mask = torch.ones_like(input_ids)
+
+    # Compute loss and update
+    opt.zero_grad()
+    out = model(input_ids=input_ids, attention_mask=attention_mask, labels=input_ids)
+    assert hasattr(out, "loss") and out.loss is not None
+    out.loss.backward()
+    opt.step()
+
+    after = rep_param.detach().clone()
+    assert not torch.allclose(before, after), "Active task adapter parameters did not update after optimizer step"
+
+
+@pytest.mark.parametrize(
+    "case",
+    [
+        "local_root",
+        "local_nested",
+        "hub_repo",
+        "hub_with_sub",
+    ],
+)
+def test_resolve_adapter_source_variants(tmp_path: Path, case: str):
+    """
+    Ensure `_resolve_adapter_source` correctly handles:
+      - Local dir (containing adapter_config.json)
+      - Local nested subfolder
+      - Hub repo id "user/repo"
+      - Hub repo with subfolder "user/repo/sub/folder"
+    """
+    if case == "local_root":
+        d = tmp_path / "adapter_local_root"
+        d.mkdir(parents=True, exist_ok=True)
+        (d / "adapter_config.json").write_text("{}")
+        model_id, sub = _resolve_adapter_source(str(d))
+        assert model_id == str(d)
+        assert sub is None
+
+    elif case == "local_nested":
+        d = tmp_path / "repo_like" / "sub" / "folder"
+        d.mkdir(parents=True, exist_ok=True)
+        (d / "adapter_config.json").write_text("{}")
+        model_id, sub = _resolve_adapter_source(str(d))
+        assert model_id == str(d)
+        assert sub is None
+
+    elif case == "hub_repo":
+        model_id, sub = _resolve_adapter_source("user/repo")
+        assert model_id == "user/repo"
+        assert sub is None
+
+    elif case == "hub_with_sub":
+        model_id, sub = _resolve_adapter_source("user/repo/sub/folder")
+        assert model_id == "user/repo"
+        assert sub == "sub/folder"
+
+    else:
+        raise AssertionError(f"unknown case: {case}")
diff --git a/tests/test_auto.py b/tests/test_auto.py
new file mode 100644
index 0000000..fc027cf
--- /dev/null
+++ b/tests/test_auto.py
@@ -0,0 +1,289 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+import tempfile
+
+import pytest
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from peft import (
+    AutoPeftModel,
+    AutoPeftModelForCausalLM,
+    AutoPeftModelForFeatureExtraction,
+    AutoPeftModelForQuestionAnswering,
+    AutoPeftModelForSeq2SeqLM,
+    AutoPeftModelForSequenceClassification,
+    AutoPeftModelForTokenClassification,
+    LoraConfig,
+    PeftConfig,
+    PeftModel,
+    PeftModelForCausalLM,
+    PeftModelForFeatureExtraction,
+    PeftModelForQuestionAnswering,
+    PeftModelForSeq2SeqLM,
+    PeftModelForSequenceClassification,
+    PeftModelForTokenClassification,
+    get_peft_model,
+)
+from peft.utils import infer_device
+
+from .testing_common import hub_online_once
+
+
+class TestPeftAutoModel:
+    dtype = torch.float16 if infer_device() == "mps" else torch.bfloat16
+
+    def test_peft_causal_lm(self):
+        model_id = "peft-internal-testing/tiny-OPTForCausalLM-lora"
+        with hub_online_once(model_id):
+            model = AutoPeftModelForCausalLM.from_pretrained(model_id)
+        assert isinstance(model, PeftModelForCausalLM)
+
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            model.save_pretrained(tmp_dirname)
+
+            model = AutoPeftModelForCausalLM.from_pretrained(tmp_dirname)
+            assert isinstance(model, PeftModelForCausalLM)
+
+        # check if kwargs are passed correctly
+        model = AutoPeftModelForCausalLM.from_pretrained(model_id, dtype=self.dtype)
+        assert isinstance(model, PeftModelForCausalLM)
+        assert model.base_model.lm_head.weight.dtype == self.dtype
+
+        adapter_name = "default"
+        is_trainable = False
+
+        with hub_online_once(model_id):
+            # This should work
+            _ = AutoPeftModelForCausalLM.from_pretrained(model_id, adapter_name, is_trainable, dtype=self.dtype)
+
+    def test_peft_causal_lm_extended_vocab(self):
+        model_id = "peft-internal-testing/tiny-random-OPTForCausalLM-extended-vocab"
+        with hub_online_once(model_id):
+            model = AutoPeftModelForCausalLM.from_pretrained(model_id)
+        assert isinstance(model, PeftModelForCausalLM)
+
+        # check if kwargs are passed correctly
+        with hub_online_once(model_id):
+            model = AutoPeftModelForCausalLM.from_pretrained(model_id, dtype=self.dtype)
+        assert isinstance(model, PeftModelForCausalLM)
+        assert model.base_model.lm_head.weight.dtype == self.dtype
+
+        adapter_name = "default"
+        is_trainable = False
+
+        with hub_online_once(model_id):
+            # This should work
+            _ = AutoPeftModelForCausalLM.from_pretrained(model_id, adapter_name, is_trainable, dtype=self.dtype)
+
+    def test_peft_seq2seq_lm(self):
+        model_id = "peft-internal-testing/tiny_T5ForSeq2SeqLM-lora"
+        with hub_online_once(model_id):
+            model = AutoPeftModelForSeq2SeqLM.from_pretrained(model_id)
+        assert isinstance(model, PeftModelForSeq2SeqLM)
+
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            model.save_pretrained(tmp_dirname)
+
+            model = AutoPeftModelForSeq2SeqLM.from_pretrained(tmp_dirname)
+            assert isinstance(model, PeftModelForSeq2SeqLM)
+
+        # check if kwargs are passed correctly
+        with hub_online_once(model_id):
+            model = AutoPeftModelForSeq2SeqLM.from_pretrained(model_id, dtype=self.dtype)
+        assert isinstance(model, PeftModelForSeq2SeqLM)
+        assert model.base_model.lm_head.weight.dtype == self.dtype
+
+        adapter_name = "default"
+        is_trainable = False
+
+        with hub_online_once(model_id):
+            # This should work
+            _ = AutoPeftModelForSeq2SeqLM.from_pretrained(model_id, adapter_name, is_trainable, dtype=self.dtype)
+
+    def test_peft_sequence_cls(self):
+        model_id = "peft-internal-testing/tiny_OPTForSequenceClassification-lora"
+        with hub_online_once(model_id):
+            model = AutoPeftModelForSequenceClassification.from_pretrained(model_id)
+        assert isinstance(model, PeftModelForSequenceClassification)
+
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            model.save_pretrained(tmp_dirname)
+
+            model = AutoPeftModelForSequenceClassification.from_pretrained(tmp_dirname)
+            assert isinstance(model, PeftModelForSequenceClassification)
+
+        # check if kwargs are passed correctly
+        with hub_online_once(model_id):
+            model = AutoPeftModelForSequenceClassification.from_pretrained(model_id, dtype=self.dtype)
+        assert isinstance(model, PeftModelForSequenceClassification)
+        assert model.score.original_module.weight.dtype == self.dtype
+
+        adapter_name = "default"
+        is_trainable = False
+
+        with hub_online_once(model_id):
+            # This should work
+            _ = AutoPeftModelForSequenceClassification.from_pretrained(
+                model_id, adapter_name, is_trainable, dtype=self.dtype
+            )
+
+    def test_peft_token_classification(self):
+        model_id = "peft-internal-testing/tiny_GPT2ForTokenClassification-lora"
+        with hub_online_once(model_id):
+            model = AutoPeftModelForTokenClassification.from_pretrained(model_id)
+        assert isinstance(model, PeftModelForTokenClassification)
+
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            model.save_pretrained(tmp_dirname)
+
+            model = AutoPeftModelForTokenClassification.from_pretrained(tmp_dirname)
+            assert isinstance(model, PeftModelForTokenClassification)
+
+        # check if kwargs are passed correctly
+        with hub_online_once(model_id):
+            model = AutoPeftModelForTokenClassification.from_pretrained(model_id, dtype=self.dtype)
+        assert isinstance(model, PeftModelForTokenClassification)
+        assert model.base_model.classifier.original_module.weight.dtype == self.dtype
+
+        adapter_name = "default"
+        is_trainable = False
+        with hub_online_once(model_id):
+            # This should work
+            _ = AutoPeftModelForTokenClassification.from_pretrained(
+                model_id, adapter_name, is_trainable, dtype=self.dtype
+            )
+
+    def test_peft_question_answering(self):
+        model_id = "peft-internal-testing/tiny_OPTForQuestionAnswering-lora"
+        with hub_online_once(model_id):
+            model = AutoPeftModelForQuestionAnswering.from_pretrained(model_id)
+        assert isinstance(model, PeftModelForQuestionAnswering)
+
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            model.save_pretrained(tmp_dirname)
+
+            model = AutoPeftModelForQuestionAnswering.from_pretrained(tmp_dirname)
+            assert isinstance(model, PeftModelForQuestionAnswering)
+
+        # check if kwargs are passed correctly
+        with hub_online_once(model_id):
+            model = AutoPeftModelForQuestionAnswering.from_pretrained(model_id, dtype=self.dtype)
+        assert isinstance(model, PeftModelForQuestionAnswering)
+        assert model.base_model.qa_outputs.original_module.weight.dtype == self.dtype
+
+        adapter_name = "default"
+        is_trainable = False
+        with hub_online_once(model_id):
+            # This should work
+            _ = AutoPeftModelForQuestionAnswering.from_pretrained(
+                model_id, adapter_name, is_trainable, dtype=self.dtype
+            )
+
+    def test_peft_feature_extraction(self):
+        model_id = "peft-internal-testing/tiny_OPTForFeatureExtraction-lora"
+        with hub_online_once(model_id):
+            model = AutoPeftModelForFeatureExtraction.from_pretrained(model_id)
+        assert isinstance(model, PeftModelForFeatureExtraction)
+
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            model.save_pretrained(tmp_dirname)
+
+            model = AutoPeftModelForFeatureExtraction.from_pretrained(tmp_dirname)
+            assert isinstance(model, PeftModelForFeatureExtraction)
+
+        # check if kwargs are passed correctly
+        with hub_online_once(model_id):
+            model = AutoPeftModelForFeatureExtraction.from_pretrained(model_id, dtype=self.dtype)
+        assert isinstance(model, PeftModelForFeatureExtraction)
+        assert model.base_model.model.decoder.embed_tokens.weight.dtype == self.dtype
+
+        adapter_name = "default"
+        is_trainable = False
+
+        with hub_online_once(model_id):
+            # This should work
+            _ = AutoPeftModelForFeatureExtraction.from_pretrained(
+                model_id, adapter_name, is_trainable, dtype=self.dtype
+            )
+
+    def test_peft_whisper(self):
+        model_id = "peft-internal-testing/tiny_WhisperForConditionalGeneration-lora"
+        with hub_online_once(model_id):
+            model = AutoPeftModel.from_pretrained(model_id)
+        assert isinstance(model, PeftModel)
+
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            model.save_pretrained(tmp_dirname)
+
+            model = AutoPeftModel.from_pretrained(tmp_dirname)
+            assert isinstance(model, PeftModel)
+
+        # check if kwargs are passed correctly
+        with hub_online_once(model_id):
+            model = AutoPeftModel.from_pretrained(model_id, dtype=self.dtype)
+        assert isinstance(model, PeftModel)
+        assert model.base_model.model.model.encoder.embed_positions.weight.dtype == self.dtype
+
+        adapter_name = "default"
+        is_trainable = False
+        with hub_online_once(model_id):
+            # This should work
+            _ = AutoPeftModel.from_pretrained(model_id, adapter_name, is_trainable, dtype=self.dtype)
+
+    def test_embedding_size_not_reduced_if_greater_vocab_size(self, tmp_path):
+        # See 2415
+        # There was a bug in AutoPeftModels where the embedding was always resized to the vocab size of the tokenizer
+        # when the tokenizer was found. This makes sense if the vocabulary was extended, but some models like Qwen
+        # already start out with "spare" embeddings, i.e. the embedding size is larger than the vocab size. This could
+        # result in the embedding being shrunk, which in turn resulted in an error when loading the weights.
+
+        # first create a checkpoint; it is important that the tokenizer is also saved in the same location
+        model_id = "Qwen/Qwen2-0.5B"
+        model = AutoModelForCausalLM.from_pretrained(model_id)
+        tokenizer = AutoTokenizer.from_pretrained(model_id)
+        model = get_peft_model(model, LoraConfig(modules_to_save=["lm_head", "embed_token"]))
+        model.save_pretrained(tmp_path)
+        tokenizer.save_pretrained(tmp_path)
+
+        # does not raise; without the fix, it raises:
+        # > size mismatch for base_model.model.lm_head.modules_to_save.default.weight: copying a param with shape
+        # torch.Size([151936, 896]) from checkpoint, the shape in current model is torch.Size([151646, 896]).
+        AutoPeftModelForCausalLM.from_pretrained(tmp_path)
+
+    @pytest.mark.parametrize(
+        "auto_class, model_id",
+        [
+            (AutoPeftModelForCausalLM, "peft-internal-testing/tiny-OPTForCausalLM-lora"),
+            (AutoPeftModelForSeq2SeqLM, "peft-internal-testing/tiny_T5ForSeq2SeqLM-lora"),
+            (AutoPeftModelForSequenceClassification, "peft-internal-testing/tiny_OPTForSequenceClassification-lora"),
+            (AutoPeftModelForTokenClassification, "peft-internal-testing/tiny_GPT2ForTokenClassification-lora"),
+            (AutoPeftModelForQuestionAnswering, "peft-internal-testing/tiny_OPTForQuestionAnswering-lora"),
+            (AutoPeftModelForFeatureExtraction, "peft-internal-testing/tiny_OPTForFeatureExtraction-lora"),
+            (AutoPeftModel, "peft-internal-testing/tiny_WhisperForConditionalGeneration-lora"),
+        ],
+    )
+    def test_import_allow_list_prevents_arbitrary_imports(self, auto_class, model_id, tmp_path):
+        with hub_online_once(model_id):
+            model = auto_class.from_pretrained(model_id)
+        model.save_pretrained(tmp_path)
+
+        config = PeftConfig.from_pretrained(tmp_path)
+        config.auto_mapping = {"parent_library": "os", "base_model_class": "system"}
+        config.task_type = None
+        config.save_pretrained(tmp_path)
+
+        with pytest.raises(ValueError) as e:
+            model = auto_class.from_pretrained(tmp_path)
+        assert "which is not in the import allowlist" in str(e)
diff --git a/tests/test_bdlora.py b/tests/test_bdlora.py
new file mode 100644
index 0000000..5796319
--- /dev/null
+++ b/tests/test_bdlora.py
@@ -0,0 +1,240 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+from copy import deepcopy
+
+import pytest
+import torch
+
+from peft import LoraConfig, get_peft_model
+from peft.tuners.lora.config import BdLoraConfig
+from peft.tuners.lora.variants import BlockDiagonalLinear
+
+
+def _fill_deterministic_weight(weight: torch.Tensor) -> None:
+    values = torch.arange(weight.numel(), dtype=weight.dtype, device=weight.device).reshape_as(weight)
+    weight.data.copy_(values)
+
+
+def _dense_weight(module: torch.nn.Module) -> torch.Tensor:
+    if isinstance(module, BlockDiagonalLinear):
+        return module.weight_as_blockdiagonal_matrix()
+    return module.weight
+
+
+def _copy_adapter_weights(dst_layer, src_layer) -> None:
+    dst_layer.lora_A["default"].weight.data.copy_(src_layer.lora_A["default"].weight.data)
+    dst_layer.lora_B["default"].weight.data.copy_(src_layer.lora_B["default"].weight.data)
+
+
+class TinyMLP(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.lin0 = torch.nn.Linear(10, 20)
+        self.relu = torch.nn.ReLU()
+        self.lin1 = torch.nn.Linear(20, 2)
+
+    def forward(self, x):
+        x = self.lin0(x)
+        x = self.relu(x)
+        return self.lin1(x)
+
+
+class TestBdLora:
+    @pytest.mark.parametrize(
+        "nblocks,in_features,out_features,input_shape",
+        [
+            (2, 8, 8, (3, 8)),
+            (2, 8, 8, (2, 5, 8)),
+            (4, 12, 8, (3, 12)),
+            (4, 12, 8, (2, 5, 12)),
+        ],
+    )
+    def test_block_diagonal_linear_forward_matches_dense_equivalent(
+        self, nblocks, in_features, out_features, input_shape
+    ):
+        torch.manual_seed(0)
+
+        layer = BlockDiagonalLinear(in_features=in_features, out_features=out_features, nblocks=nblocks)
+        _fill_deterministic_weight(layer.weight)
+
+        x = torch.randn(*input_shape)
+        # Compare the packed implementation against the explicit dense reconstruction
+        dense_weight = layer.weight_as_blockdiagonal_matrix()
+
+        expected = x @ dense_weight.T
+        actual = layer(x)
+
+        assert torch.allclose(
+            actual,
+            expected,
+            atol=1e-5,
+            rtol=1e-4,
+        ), f"BlockDiagonalLinear forward mismatch for input_shape={input_shape}, nblocks={nblocks}"
+
+    @pytest.mark.parametrize(
+        "bdlora_config",
+        [
+            BdLoraConfig(target_modules_bd_a=["lin0"], nblocks=2, match_strict=True),
+            BdLoraConfig(target_modules_bd_b=["lin0"], nblocks=2, match_strict=True),
+        ],
+    )
+    def test_bdlora_merge_delta_matches_manual_dense_equivalent(self, bdlora_config):
+        torch.manual_seed(0)
+
+        model = TinyMLP()
+        base_weight = model.lin0.weight.detach().clone()
+
+        config = LoraConfig(
+            r=4,
+            lora_alpha=8,
+            lora_dropout=0.0,
+            target_modules=["lin0"],
+            use_bdlora=bdlora_config,
+        )
+        peft_model = get_peft_model(deepcopy(model), config).eval()
+        lora_layer = peft_model.base_model.model.lin0
+
+        _fill_deterministic_weight(lora_layer.lora_A["default"].weight)
+        _fill_deterministic_weight(lora_layer.lora_B["default"].weight)
+
+        # Convert any block-diagonal factor back to its dense view before multiplying
+        dense_a = _dense_weight(lora_layer.lora_A["default"])
+        dense_b = _dense_weight(lora_layer.lora_B["default"])
+        expected_delta = (dense_b @ dense_a) * lora_layer.scaling["default"]
+
+        peft_model.merge_adapter()
+
+        merged_weight = peft_model.base_model.model.lin0.base_layer.weight.data
+        assert torch.allclose(
+            merged_weight,
+            base_weight + expected_delta,
+            atol=1e-5,
+            rtol=1e-4,
+        ), f"Merged weight mismatch for BD-LoRA config={bdlora_config}"
+
+    def test_bdlora_nblocks_one_matches_vanilla_lora(self):
+        # With nblocks=1, there is no block split: out_features // 1 = out_features and r // 1 = r
+        # So the BD-LoRA packing reduces to the same shapes as vanilla LoRA, and the outputs should match
+        torch.manual_seed(0)
+
+        base_model = TinyMLP()
+        x = torch.randn(5, 10)
+
+        lora_rank = 4
+        lora_alpha = 8
+        lora_dropout = 0.0
+        target_modules = ["lin0"]
+
+        bd_config = LoraConfig(
+            r=lora_rank,
+            lora_alpha=lora_alpha,
+            lora_dropout=lora_dropout,
+            target_modules=target_modules,
+            use_bdlora=BdLoraConfig(target_modules_bd_a=target_modules, nblocks=1, match_strict=True),
+        )
+        vanilla_config = LoraConfig(
+            r=lora_rank, lora_alpha=lora_alpha, lora_dropout=lora_dropout, target_modules=target_modules
+        )
+
+        bd_model = get_peft_model(deepcopy(base_model), bd_config).eval()
+        vanilla_model = get_peft_model(deepcopy(base_model), vanilla_config).eval()
+
+        # Copy adapter tensors so the only remaining difference is the block packing path
+        _copy_adapter_weights(vanilla_model.base_model.model.lin0, bd_model.base_model.model.lin0)
+
+        bd_output = bd_model(x)
+        vanilla_output = vanilla_model(x)
+
+        assert torch.allclose(
+            bd_output,
+            vanilla_output,
+            atol=1e-5,
+            rtol=1e-4,
+        ), "nblocks=1 BD-LoRA forward output should match vanilla LoRA"
+
+        bd_model.merge_adapter()
+        vanilla_model.merge_adapter()
+
+        assert torch.allclose(
+            bd_model.base_model.model.lin0.base_layer.weight.data,
+            vanilla_model.base_model.model.lin0.base_layer.weight.data,
+            atol=1e-5,
+            rtol=1e-4,
+        ), "nblocks=1 merged weights should match vanilla LoRA"
+
+    @pytest.mark.parametrize(
+        "bdlora_config,expected_a_shape,expected_b_shape,expected_adapter_params",
+        [
+            # A-block: only LoRA-A is block-diagonal. With in_features=10, nblocks=2, and r=4,
+            # A stores (4, 10 // 2) = (4, 5) parameters, while B stays unchanged as dense at (20, 4)
+            # Total trainable adapter params: 4 * 5 + 20 * 4 = 100
+            (BdLoraConfig(target_modules_bd_a=["lin0"], nblocks=2, match_strict=True), (4, 5), (20, 4), 100),
+            # B-block: only LoRA-B is block-diagonal. The packed parameter stores (out_features, r // nblocks),
+            # so B keeps 20 rows but only 4 // 2 = 2 columns per block. That is 2 blocks of shape (10, 2),
+            # for 2 * 10 * 2 = 40 B parameters. A stays unchanged as dense at (4, 10), so the total is 40 + 40 = 80
+            (BdLoraConfig(target_modules_bd_b=["lin0"], nblocks=2, match_strict=True), (4, 10), (20, 2), 80),
+        ],
+    )
+    def test_bdlora_packed_shapes_and_adapter_param_counts_vs_vanilla(
+        self, bdlora_config, expected_a_shape, expected_b_shape, expected_adapter_params
+    ):
+        torch.manual_seed(0)
+
+        base_model = TinyMLP()
+
+        lora_rank = 4
+        lora_alpha = 8
+        lora_dropout = 0.0
+        target_modules = ["lin0"]
+
+        bd_config = LoraConfig(
+            r=lora_rank,
+            lora_alpha=lora_alpha,
+            lora_dropout=lora_dropout,
+            target_modules=target_modules,
+            use_bdlora=bdlora_config,
+        )
+        vanilla_config = LoraConfig(
+            r=lora_rank, lora_alpha=lora_alpha, lora_dropout=lora_dropout, target_modules=target_modules
+        )
+
+        bd_model = get_peft_model(deepcopy(base_model), bd_config).eval()
+        vanilla_model = get_peft_model(deepcopy(base_model), vanilla_config).eval()
+
+        bd_layer = bd_model.base_model.model.lin0
+        vanilla_layer = vanilla_model.base_model.model.lin0
+
+        bd_a = bd_layer.lora_A["default"]
+        bd_b = bd_layer.lora_B["default"]
+        vanilla_a = vanilla_layer.lora_A["default"]
+        vanilla_b = vanilla_layer.lora_B["default"]
+
+        assert tuple(bd_a.weight.shape) == expected_a_shape
+        assert tuple(bd_b.weight.shape) == expected_b_shape
+        assert tuple(vanilla_a.weight.shape) == (4, 10)
+        assert tuple(vanilla_b.weight.shape) == (20, 4)
+
+        vanilla_adapter_params = sum(
+            p.numel() for module in (vanilla_a, vanilla_b) for p in module.parameters() if p.requires_grad
+        )
+        bd_adapter_params = sum(p.numel() for module in (bd_a, bd_b) for p in module.parameters() if p.requires_grad)
+
+        # For vanilla LoRA on lin0: A has shape (r, in)=(4,10) and B has shape (out, r)=(20,4),
+        # so trainable adapter params are 4*10 + 20*4 = 120
+        assert vanilla_adapter_params == 120
+
+        assert bd_adapter_params == expected_adapter_params
+
+        # BD-LoRA must reduce trainable adapter parameters vs vanilla LoRA
+        assert bd_adapter_params < vanilla_adapter_params
diff --git a/tests/test_boft.py b/tests/test_boft.py
new file mode 100644
index 0000000..fdd4b60
--- /dev/null
+++ b/tests/test_boft.py
@@ -0,0 +1,84 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+import torch
+from safetensors.torch import load_file
+from transformers import AutoModelForCausalLM
+
+from peft import BOFTConfig, PeftModel, get_peft_model
+from peft.utils import infer_device
+
+
+class TestBoft:
+    device = infer_device()
+
+    def test_boft_state_dict(self, tmp_path):
+        # see #2050
+        # ensure that the boft_P buffer is not stored in the checkpoint file and is not necessary to load the model
+        # correctly
+        torch.manual_seed(0)
+
+        inputs = torch.arange(10).view(-1, 1).to(self.device)
+        model_id = "peft-internal-testing/tiny-random-OPTForCausalLM"
+        model = AutoModelForCausalLM.from_pretrained(model_id).to(self.device)
+        model.eval()
+        output_base = model(inputs).logits
+
+        config = BOFTConfig(init_weights=False)
+        model = get_peft_model(model, config)
+        model.eval()
+        output_peft = model(inputs).logits
+
+        atol, rtol = 1e-5, 1e-8
+        # sanity check: loading boft changed the output
+        assert not torch.allclose(output_base, output_peft, atol=atol, rtol=rtol)
+
+        model.save_pretrained(tmp_path)
+        del model
+
+        # check that the boft_P buffer is not present
+        state_dict = load_file(tmp_path / "adapter_model.safetensors")
+        assert not any("boft_P" in key for key in state_dict)
+
+        # sanity check: the model still produces the same output after loading
+        model = AutoModelForCausalLM.from_pretrained(model_id).to(self.device)
+        model = PeftModel.from_pretrained(model, tmp_path)
+        output_loaded = model(inputs).logits
+        assert torch.allclose(output_peft, output_loaded, atol=atol, rtol=rtol)
+
+    def test_boft_old_checkpoint_including_boft_P(self, tmp_path):
+        # see #2050
+        # This test exists to ensure that after the boft_P buffer was made non-persistent, old checkpoints can still be
+        # loaded successfully.
+        torch.manual_seed(0)
+
+        inputs = torch.arange(10).view(-1, 1).to(self.device)
+        model_id = "peft-internal-testing/tiny-random-OPTForCausalLM"
+        model = AutoModelForCausalLM.from_pretrained(model_id).to(self.device)
+
+        # first create the expected output
+        config = BOFTConfig(init_weights=False)
+        model = get_peft_model(model, config)
+        model.eval()
+        output_peft = model(inputs).logits
+        del model
+
+        model = AutoModelForCausalLM.from_pretrained(model_id).to(self.device)
+        # checkpoint from before the PR whose state_dict still contains boft_P
+        hub_id = "peft-internal-testing/boft-tiny-opt-peft-v0.12"
+        model = PeftModel.from_pretrained(model, hub_id)
+        output_old = model(inputs).logits
+
+        atol, rtol = 1e-5, 1e-8
+        assert torch.allclose(output_peft, output_old, atol=atol, rtol=rtol)
diff --git a/tests/test_bufferdict.py b/tests/test_bufferdict.py
new file mode 100644
index 0000000..eda25e6
--- /dev/null
+++ b/tests/test_bufferdict.py
@@ -0,0 +1,48 @@
+import torch
+
+from peft.tuners._buffer_dict import BufferDict
+
+
+class TestBufferDict:
+    def test_init_from_dict_works(self):
+        bd = BufferDict(
+            {
+                "default": torch.randn(10, 2),
+            }
+        )
+
+    def test_update_from_other_bufferdict(self):
+        default_tensor = torch.randn(10, 2)
+        non_default_tensor = torch.randn(10, 2)
+        bd1 = BufferDict({"default": default_tensor})
+        bd2 = BufferDict({"non_default": non_default_tensor})
+
+        bd1.update(bd2)
+
+        assert set(bd1.keys()) == {"default", "non_default"}
+        assert torch.allclose(bd1["default"], default_tensor)
+        assert torch.allclose(bd1["non_default"], non_default_tensor)
+
+    def test_update_from_dict(self):
+        default_tensor = torch.randn(10, 2)
+        non_default_tensor = torch.randn(10, 2)
+        bd1 = BufferDict({"default": default_tensor})
+        d1 = {"non_default": non_default_tensor}
+
+        bd1.update(d1)
+
+        assert set(bd1.keys()) == {"default", "non_default"}
+        assert torch.allclose(bd1["default"], default_tensor)
+        assert torch.allclose(bd1["non_default"], non_default_tensor)
+
+    def test_update_from_dict_items(self):
+        default_tensor = torch.randn(10, 2)
+        non_default_tensor = torch.randn(10, 2)
+        bd1 = BufferDict({"default": default_tensor})
+        d1 = {"non_default": non_default_tensor}
+
+        bd1.update(d1.items())
+
+        assert set(bd1.keys()) == {"default", "non_default"}
+        assert torch.allclose(bd1["default"], default_tensor)
+        assert torch.allclose(bd1["non_default"], non_default_tensor)
diff --git a/tests/test_cartridge.py b/tests/test_cartridge.py
new file mode 100644
index 0000000..7907fd5
--- /dev/null
+++ b/tests/test_cartridge.py
@@ -0,0 +1,272 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+import warnings
+
+import pytest
+import torch
+from transformers import AutoModelForCausalLM
+from transformers.modeling_outputs import CausalLMOutputWithPast
+
+from peft import (
+    CartridgeConfig,
+    PeftConfig,
+    PeftModel,
+    compose_cartridge_adapters,
+    get_peft_model,
+    initialize_kv_prefix_from_past_key_values,
+    load_peft_weights,
+    prompt_embeddings_from_past_key_values,
+)
+from peft.tuners import PrefixTuningConfig
+
+from .testing_utils import hub_online_once
+
+
+TINY_CAUSAL_LM = "peft-internal-testing/tiny-random-OPTForCausalLM"
+
+
+@pytest.fixture
+def model_id():
+    return TINY_CAUSAL_LM
+
+
+@pytest.fixture
+def base_model(model_id):
+    with hub_online_once(model_id):
+        return AutoModelForCausalLM.from_pretrained(model_id)
+
+
+def test_cartridge_offsets_position_ids_in_forward(monkeypatch, base_model):
+    base = base_model
+    peft_config = CartridgeConfig(num_virtual_tokens=4, num_frozen_tokens=1, task_type="CAUSAL_LM")
+    model = get_peft_model(base, peft_config)
+
+    captured = {}
+
+    def fake_forward(*args, **kwargs):
+        captured["position_ids"] = kwargs.get("position_ids")
+        input_ids = kwargs.get("input_ids")
+        if input_ids is None and args:
+            input_ids = args[0]
+        batch, seq_len = input_ids.shape
+        logits = torch.zeros((batch, seq_len, base.config.vocab_size), device=input_ids.device)
+        return CausalLMOutputWithPast(logits=logits)
+
+    monkeypatch.setattr(model.base_model, "forward", fake_forward)
+
+    input_ids = torch.randint(0, base.config.vocab_size, (1, 3))
+    position_ids = torch.arange(input_ids.shape[1]).unsqueeze(0)
+    _ = model(input_ids=input_ids, position_ids=position_ids)
+
+    assert captured["position_ids"] is not None
+    assert torch.equal(captured["position_ids"], position_ids + peft_config.num_virtual_tokens)
+
+
+def test_cartridge_prefill_4d_mask_uses_cache_position(monkeypatch, base_model):
+    base = base_model
+    peft_config = CartridgeConfig(num_virtual_tokens=4, num_frozen_tokens=1, task_type="CAUSAL_LM")
+    model = get_peft_model(base, peft_config)
+
+    captured = {}
+
+    def fake_create_attention_mask(
+        model,
+        *,
+        model_input,
+        attention_mask,
+        past_key_values,
+        cache_position,
+        batch_size,
+        sequence_length,
+        position_ids,
+    ):
+        captured["cache_position"] = cache_position
+        return attention_mask
+
+    monkeypatch.setattr("peft.peft_model.create_attention_mask", fake_create_attention_mask)
+
+    input_ids = torch.randint(0, base.config.vocab_size, (1, 2))
+    attention_mask_4d = torch.ones((1, 1, input_ids.shape[1], input_ids.shape[1]))
+    cache_position = torch.arange(input_ids.shape[1])
+
+    def fake_prepare_inputs_for_generation(*args, **kwargs):
+        return {
+            "input_ids": input_ids,
+            "attention_mask": attention_mask_4d,
+            "cache_position": cache_position,
+            "past_key_values": None,
+        }
+
+    model.base_model_prepare_inputs_for_generation = fake_prepare_inputs_for_generation
+    _ = model.prepare_inputs_for_generation(input_ids)
+
+    assert captured["cache_position"] is not None
+    assert torch.equal(captured["cache_position"], cache_position)
+
+
+@pytest.mark.parametrize("num_frozen_tokens", [0, 2])
+def test_cartridge_forward_and_save_load(tmp_path, num_frozen_tokens, base_model, model_id):
+    base = base_model
+    peft_config = CartridgeConfig(num_virtual_tokens=4, num_frozen_tokens=num_frozen_tokens, task_type="CAUSAL_LM")
+    model = get_peft_model(base, peft_config)
+
+    assert model.active_peft_config.peft_type.value == "CARTRIDGE"
+    if num_frozen_tokens:
+        assert model.prompt_encoder[model.active_adapter].frozen_embedding is not None
+        assert model.prompt_encoder[model.active_adapter].frozen_embedding.requires_grad is False
+    else:
+        assert model.prompt_encoder[model.active_adapter].frozen_embedding is None
+    assert model.prompt_encoder[model.active_adapter].trainable_embedding.requires_grad is True
+
+    input_ids = torch.randint(0, base.config.vocab_size, (1, 8))
+    out = model(input_ids=input_ids)
+    assert out.logits.shape[:2] == (1, 8)
+
+    model.prompt_encoder[model.active_adapter].trainable_embedding.data.fill_(3.0)
+    if num_frozen_tokens:
+        model.prompt_encoder[model.active_adapter].frozen_embedding.data.fill_(7.0)
+
+    model.save_pretrained(tmp_path)
+    with hub_online_once(model_id):
+        base2 = AutoModelForCausalLM.from_pretrained(model_id)
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+        loaded = PeftModel.from_pretrained(base2, tmp_path)
+        assert not any("Found missing adapter keys" in str(warning.message) for warning in w)
+    out2 = loaded(input_ids=input_ids)
+    assert out2.logits.shape == out.logits.shape
+    assert torch.allclose(
+        loaded.prompt_encoder[loaded.active_adapter].trainable_embedding,
+        torch.full_like(loaded.prompt_encoder[loaded.active_adapter].trainable_embedding, 3.0),
+    )
+    if num_frozen_tokens:
+        assert torch.allclose(
+            loaded.prompt_encoder[loaded.active_adapter].frozen_embedding,
+            torch.full_like(loaded.prompt_encoder[loaded.active_adapter].frozen_embedding, 7.0),
+        )
+    else:
+        assert loaded.prompt_encoder[loaded.active_adapter].frozen_embedding is None
+
+
+def test_cartridge_init_from_past_key_values_and_compose(tmp_path, base_model, model_id):
+    base = base_model
+    peft_config = CartridgeConfig(num_virtual_tokens=4, num_frozen_tokens=1, task_type="CAUSAL_LM")
+    model = get_peft_model(base, peft_config)
+
+    # Prefill on the *base* model and use the cache prefix as initialization.
+    input_ids = torch.randint(0, base.config.vocab_size, (1, 12))
+    with model.disable_adapter():
+        outputs = model(input_ids=input_ids, use_cache=True)
+    prompt_embeddings = initialize_kv_prefix_from_past_key_values(
+        model, past_key_values=outputs.past_key_values, num_virtual_tokens=4
+    )
+    assert prompt_embeddings.shape[0] == 4
+    assert model.prompt_encoder[model.active_adapter].weight.device == prompt_embeddings.device
+    assert torch.allclose(model.prompt_encoder[model.active_adapter].weight, prompt_embeddings)
+
+    a1 = tmp_path / "a1"
+    a2 = tmp_path / "a2"
+    out_dir = tmp_path / "composed"
+    model.save_pretrained(a1)
+
+    with hub_online_once(model_id):
+        base2 = AutoModelForCausalLM.from_pretrained(model_id)
+    model2 = get_peft_model(base2, peft_config)
+    with model2.disable_adapter():
+        outputs2 = model2(input_ids=input_ids, use_cache=True)
+    _ = initialize_kv_prefix_from_past_key_values(
+        model2, past_key_values=outputs2.past_key_values, num_virtual_tokens=4
+    )
+    model2.save_pretrained(a2)
+
+    compose_cartridge_adapters([a1, a2], output_path=out_dir)
+    cfg = PeftConfig.from_pretrained(out_dir)
+    assert cfg.peft_type.value == "CARTRIDGE"
+    assert cfg.num_virtual_tokens == 8
+    w = load_peft_weights(out_dir, device="cpu")
+    assert w["prompt_embeddings"].shape[0] == 8
+
+
+def test_cartridge_prompt_embeddings_from_past_key_values_matches_init(base_model):
+    base = base_model
+    peft_config = CartridgeConfig(num_virtual_tokens=4, num_frozen_tokens=0, task_type="CAUSAL_LM")
+    model = get_peft_model(base, peft_config)
+
+    input_ids = torch.randint(0, base.config.vocab_size, (1, 10))
+    with model.disable_adapter():
+        outputs = model(input_ids=input_ids, use_cache=True)
+
+    pe = prompt_embeddings_from_past_key_values(outputs.past_key_values, num_virtual_tokens=4)
+    assert pe.shape[0] == 4
+
+    pe2 = initialize_kv_prefix_from_past_key_values(
+        model, past_key_values=outputs.past_key_values, num_virtual_tokens=4
+    )
+    assert pe.device == pe2.device
+    assert torch.allclose(pe, pe2)
+
+
+@pytest.mark.parametrize("num_frozen_tokens", [0, 2])
+def test_cartridge_inference_mode_disables_grads_and_forward_works(num_frozen_tokens, base_model):
+    base = base_model
+    peft_config = CartridgeConfig(
+        num_virtual_tokens=4,
+        num_frozen_tokens=num_frozen_tokens,
+        task_type="CAUSAL_LM",
+        inference_mode=True,
+    )
+    model = get_peft_model(base, peft_config)
+
+    enc = model.prompt_encoder[model.active_adapter]
+    # In `inference_mode=True`, PEFT should mark adapter parameters as non-trainable (no gradients) so users can
+    # safely run forward/generation without accidentally updating or tracking grads for the CARTRIDGE parameters.
+    assert enc.trainable_embedding.requires_grad is False
+    if num_frozen_tokens:
+        assert enc.frozen_embedding is not None
+        assert enc.frozen_embedding.requires_grad is False
+    else:
+        assert enc.frozen_embedding is None
+
+    input_ids = torch.randint(0, base.config.vocab_size, (1, 6))
+    out = model(input_ids=input_ids)
+    assert out.logits.shape[:2] == (1, 6)
+
+
+def test_cartridge_gradient_checkpointing_raises(base_model):
+    base = base_model
+    base.gradient_checkpointing_enable()
+    peft_config = CartridgeConfig(num_virtual_tokens=4, num_frozen_tokens=0, task_type="CAUSAL_LM")
+
+    with pytest.raises(ValueError, match="does not work with gradient checkpointing"):
+        _ = get_peft_model(base, peft_config)
+
+
+def test_prefix_tuning_can_be_initialized_from_past_key_values_when_no_projection(base_model):
+    base = base_model
+    peft_config = PrefixTuningConfig(num_virtual_tokens=4, task_type="CAUSAL_LM")
+    model = get_peft_model(base, peft_config)
+
+    input_ids = torch.randint(0, base.config.vocab_size, (1, 10))
+    with model.disable_adapter():
+        outputs = model(input_ids=input_ids, use_cache=True)
+
+    pe = prompt_embeddings_from_past_key_values(outputs.past_key_values, num_virtual_tokens=4)
+    pe2 = initialize_kv_prefix_from_past_key_values(
+        model, past_key_values=outputs.past_key_values, num_virtual_tokens=4
+    )
+    assert pe.device == pe2.device
+    assert torch.allclose(pe, pe2)
+    assert model.prompt_encoder[model.active_adapter].embedding.weight.device == pe.device
+    assert torch.allclose(model.prompt_encoder[model.active_adapter].embedding.weight, pe)
diff --git a/tests/test_common_gpu.py b/tests/test_common_gpu.py
new file mode 100644
index 0000000..ff40235
--- /dev/null
+++ b/tests/test_common_gpu.py
@@ -0,0 +1,2240 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+import gc
+import tempfile
+import unittest
+
+import pytest
+import torch
+import torch.nn.functional as F
+from accelerate.utils.memory import clear_device_cache
+from parameterized import parameterized
+from torch import nn
+from transformers import (
+    AutoImageProcessor,
+    AutoModelForCausalLM,
+    AutoModelForImageClassification,
+    AutoModelForSeq2SeqLM,
+    AutoModelForSequenceClassification,
+    AutoModelForTokenClassification,
+    AutoTokenizer,
+    BitsAndBytesConfig,
+    LlamaForCausalLM,
+    WhisperForConditionalGeneration,
+)
+from transformers.pytorch_utils import Conv1D
+
+from peft import (
+    AdaLoraConfig,
+    AdaptionPromptConfig,
+    BOFTConfig,
+    HRAConfig,
+    IA3Config,
+    LNTuningConfig,
+    LoHaConfig,
+    LoKrConfig,
+    LoraConfig,
+    OFTConfig,
+    PeftModel,
+    RandLoraConfig,
+    RoadConfig,
+    TaskType,
+    VBLoRAConfig,
+    VeraConfig,
+    get_peft_model,
+    prepare_model_for_kbit_training,
+)
+from peft.import_utils import is_bnb_4bit_available, is_bnb_available, is_xpu_available
+from peft.tuners.lora.config import LoraRuntimeConfig
+from peft.utils import infer_device
+
+from .testing_utils import (
+    DEVICE_MAP_MAP,
+    device_count,
+    load_cat_image,
+    require_bitsandbytes,
+    require_deterministic_for_xpu,
+    require_gptqmodel,
+    require_non_cpu,
+    require_torch_gpu,
+    require_torch_multi_accelerator,
+)
+
+
+if is_bnb_available():
+    import bitsandbytes as bnb
+
+    from peft.tuners.ia3 import Linear8bitLt as IA3Linear8bitLt
+    from peft.tuners.lora import Linear8bitLt as LoraLinear8bitLt
+    from peft.tuners.randlora import Linear8bitLt as RandLoraLinear8bitLt
+    from peft.tuners.road import Linear8bitLt as RoadLinear8bitLt
+
+    if is_bnb_4bit_available():
+        from peft.tuners.ia3 import Linear4bit as IA3Linear4bit
+        from peft.tuners.lora import Linear4bit as LoraLinear4bit
+        from peft.tuners.randlora import Linear4bit as RandLoraLinear4bit
+        from peft.tuners.road import Linear4bit as RoadLinear4bit
+
+
+@require_non_cpu
+class PeftGPUCommonTests(unittest.TestCase):
+    r"""
+    A common tester to run common operations that are performed on GPU such as generation, loading in 8bit, etc.
+    """
+
+    def setUp(self):
+        self.seq2seq_model_id = "google/flan-t5-base"
+        self.causal_lm_model_id = "facebook/opt-350m"
+        self.audio_model_id = "openai/whisper-large"
+        self.device = infer_device()
+
+    def tearDown(self):
+        r"""
+        Efficient mechanism to free GPU memory after each test. Based on
+        https://github.com/huggingface/transformers/issues/21094
+        """
+        clear_device_cache(garbage_collection=True)
+        gc.collect()
+
+    @require_bitsandbytes
+    @pytest.mark.multi_gpu_tests
+    @pytest.mark.single_gpu_tests
+    def test_lora_bnb_8bit_quantization(self):
+        r"""
+        Test that tests if the 8bit quantization using LoRA works as expected
+        """
+        whisper_8bit = WhisperForConditionalGeneration.from_pretrained(
+            self.audio_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+        )
+
+        opt_8bit = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+        )
+
+        flan_8bit = AutoModelForSeq2SeqLM.from_pretrained(
+            self.seq2seq_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+        )
+
+        flan_lora_config = LoraConfig(
+            r=16, lora_alpha=32, target_modules=["q", "v"], lora_dropout=0.05, bias="none", task_type="SEQ_2_SEQ_LM"
+        )
+
+        opt_lora_config = LoraConfig(
+            r=16,
+            lora_alpha=32,
+            target_modules=["q_proj", "v_proj"],
+            lora_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+
+        config = LoraConfig(r=32, lora_alpha=64, target_modules=["q_proj", "v_proj"], lora_dropout=0.05, bias="none")
+
+        flan_8bit = get_peft_model(flan_8bit, flan_lora_config)
+        assert isinstance(flan_8bit.base_model.model.encoder.block[0].layer[0].SelfAttention.q, LoraLinear8bitLt)
+
+        opt_8bit = get_peft_model(opt_8bit, opt_lora_config)
+        assert isinstance(opt_8bit.base_model.model.model.decoder.layers[0].self_attn.v_proj, LoraLinear8bitLt)
+
+        whisper_8bit = get_peft_model(whisper_8bit, config)
+        assert isinstance(whisper_8bit.base_model.model.model.decoder.layers[0].self_attn.v_proj, LoraLinear8bitLt)
+
+    @require_bitsandbytes
+    @pytest.mark.multi_gpu_tests
+    @pytest.mark.single_gpu_tests
+    def test_vera_bnb_8bit_quantization(self):
+        r"""
+        Test that tests if the 8bit quantization using VeRA works as expected
+        """
+        whisper_8bit = WhisperForConditionalGeneration.from_pretrained(
+            self.audio_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+        )
+
+        opt_8bit = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+        )
+
+        flan_8bit = AutoModelForSeq2SeqLM.from_pretrained(
+            self.seq2seq_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+        )
+
+        flan_vera_config = VeraConfig(
+            r=16, target_modules=["q", "v"], vera_dropout=0.05, bias="none", task_type="SEQ_2_SEQ_LM"
+        )
+
+        opt_vera_config = VeraConfig(
+            r=16,
+            target_modules=["q_proj", "v_proj"],
+            vera_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+
+        config = VeraConfig(r=32, target_modules=["q_proj", "v_proj"], vera_dropout=0.05, bias="none")
+
+        flan_8bit = get_peft_model(flan_8bit, flan_vera_config)
+        quant_layers = [m for m in flan_8bit.modules() if getattr(m, "quantization_backend", None) is not None]
+        assert len(quant_layers) > 0
+
+        opt_8bit = get_peft_model(opt_8bit, opt_vera_config)
+        quant_layers = [m for m in opt_8bit.modules() if getattr(m, "quantization_backend", None) is not None]
+        assert len(quant_layers) > 0
+
+        whisper_8bit = get_peft_model(whisper_8bit, config)
+        quant_layers = [m for m in whisper_8bit.modules() if getattr(m, "quantization_backend", None) is not None]
+        assert len(quant_layers) > 0
+
+    @require_bitsandbytes
+    @pytest.mark.multi_gpu_tests
+    @pytest.mark.single_gpu_tests
+    def test_randlora_bnb_8bit_quantization(self):
+        r"""
+        Test that tests if the 8bit quantization using RandLora works as expected
+        """
+        whisper_8bit = WhisperForConditionalGeneration.from_pretrained(
+            self.audio_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+        )
+
+        opt_8bit = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+        )
+
+        flan_8bit = AutoModelForSeq2SeqLM.from_pretrained(
+            self.seq2seq_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+        )
+
+        flan_randlora_config = RandLoraConfig(
+            r=16, target_modules=["q", "v"], randlora_dropout=0.05, bias="none", task_type="SEQ_2_SEQ_LM"
+        )
+
+        opt_randlora_config = RandLoraConfig(
+            r=10,
+            target_modules=["q_proj", "v_proj"],
+            randlora_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+
+        config = RandLoraConfig(r=5, target_modules=["q_proj", "v_proj"], randlora_dropout=0.05, bias="none")
+
+        flan_8bit = get_peft_model(flan_8bit, flan_randlora_config)
+        assert isinstance(flan_8bit.base_model.model.encoder.block[0].layer[0].SelfAttention.q, RandLoraLinear8bitLt)
+
+        opt_8bit = get_peft_model(opt_8bit, opt_randlora_config)
+        assert isinstance(opt_8bit.base_model.model.model.decoder.layers[0].self_attn.v_proj, RandLoraLinear8bitLt)
+
+        whisper_8bit = get_peft_model(whisper_8bit, config)
+        assert isinstance(whisper_8bit.base_model.model.model.decoder.layers[0].self_attn.v_proj, RandLoraLinear8bitLt)
+
+    @require_bitsandbytes
+    @pytest.mark.multi_gpu_tests
+    @pytest.mark.single_gpu_tests
+    def test_ia3_bnb_8bit_quantization(self):
+        r"""
+        Test that tests if the 8bit quantization using IA3 works as expected
+        """
+        whisper_8bit = WhisperForConditionalGeneration.from_pretrained(
+            self.audio_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+        )
+
+        opt_8bit = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+        )
+
+        flan_8bit = AutoModelForSeq2SeqLM.from_pretrained(
+            self.seq2seq_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+        )
+
+        flan_ia3_config = IA3Config(target_modules=["q", "v"], task_type="SEQ_2_SEQ_LM")
+
+        opt_ia3_config = IA3Config(
+            target_modules=["q_proj", "v_proj", "fc2"],
+            feedforward_modules=["fc2"],
+            task_type="CAUSAL_LM",
+        )
+
+        config = IA3Config(target_modules=["q_proj", "v_proj", "fc2"], feedforward_modules=["fc2"])
+
+        flan_8bit = get_peft_model(flan_8bit, flan_ia3_config)
+        assert isinstance(flan_8bit.base_model.model.encoder.block[0].layer[0].SelfAttention.q, IA3Linear8bitLt)
+
+        opt_8bit = get_peft_model(opt_8bit, opt_ia3_config)
+        assert isinstance(opt_8bit.base_model.model.model.decoder.layers[0].self_attn.v_proj, IA3Linear8bitLt)
+
+        whisper_8bit = get_peft_model(whisper_8bit, config)
+        assert isinstance(whisper_8bit.base_model.model.model.decoder.layers[0].self_attn.v_proj, IA3Linear8bitLt)
+
+    @require_bitsandbytes
+    @pytest.mark.multi_gpu_tests
+    @pytest.mark.single_gpu_tests
+    def test_road_bnb_8bit_quantization(self):
+        r"""
+        Test that tests if the 8bit quantization using Road works as expected
+        """
+        whisper_8bit = WhisperForConditionalGeneration.from_pretrained(
+            self.audio_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+        )
+
+        opt_8bit = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+        )
+
+        flan_8bit = AutoModelForSeq2SeqLM.from_pretrained(
+            self.seq2seq_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+        )
+
+        flan_road_config = RoadConfig(target_modules=["q", "v"], task_type="SEQ_2_SEQ_LM")
+
+        opt_road_config = RoadConfig(
+            target_modules=["q_proj", "v_proj", "fc2"],
+            task_type="CAUSAL_LM",
+        )
+
+        config = RoadConfig(target_modules=["q_proj", "v_proj", "fc2"])
+
+        flan_8bit = get_peft_model(flan_8bit, flan_road_config)
+        assert isinstance(flan_8bit.base_model.model.encoder.block[0].layer[0].SelfAttention.q, RoadLinear8bitLt)
+
+        opt_8bit = get_peft_model(opt_8bit, opt_road_config)
+        assert isinstance(opt_8bit.base_model.model.model.decoder.layers[0].self_attn.v_proj, RoadLinear8bitLt)
+
+        whisper_8bit = get_peft_model(whisper_8bit, config)
+        assert isinstance(whisper_8bit.base_model.model.model.decoder.layers[0].self_attn.v_proj, RoadLinear8bitLt)
+
+    @require_bitsandbytes
+    @pytest.mark.multi_gpu_tests
+    @pytest.mark.single_gpu_tests
+    @parameterized.expand(["4bit", "8bit"])
+    def test_lora_bnb_quantization_from_pretrained_safetensors(self, quantization):
+        r"""
+        Tests that the bnb quantization using LoRA works as expected with safetensors weights.
+        """
+        model_id = "facebook/opt-350m"
+        peft_model_id = "ybelkada/test-st-lora"
+        kwargs = {"device_map": "auto"}
+        if quantization == "4bit":
+            kwargs["quantization_config"] = BitsAndBytesConfig(load_in_4bit=True)
+        else:
+            kwargs["quantization_config"] = BitsAndBytesConfig(load_in_8bit=True)
+
+        model = AutoModelForCausalLM.from_pretrained(model_id, **kwargs)
+        model = PeftModel.from_pretrained(model, peft_model_id)
+
+        model.generate(input_ids=torch.LongTensor([[0, 2, 3, 1]]).to(model.device))
+
+        # loading a 2nd adapter works, #1239
+        model.load_adapter(peft_model_id, "adapter2")
+        model.set_adapter("adapter2")
+        model.generate(input_ids=torch.LongTensor([[0, 2, 3, 1]]).to(model.device))
+
+        # check that both adapters are in the same layer
+        assert "default" in model.base_model.model.model.decoder.layers[0].self_attn.q_proj.lora_A
+        assert "adapter2" in model.base_model.model.model.decoder.layers[0].self_attn.q_proj.lora_A
+
+    @require_bitsandbytes
+    @pytest.mark.multi_gpu_tests
+    @pytest.mark.single_gpu_tests
+    @parameterized.expand(["4bit", "8bit"])
+    def test_adalora_bnb_quantization_from_pretrained_safetensors(self, quantization):
+        r"""
+        Tests that the bnb quantization using AdaLora works as expected with safetensors weights.
+        """
+        model_id = "facebook/opt-350m"
+        kwargs = {"device_map": "auto"}
+        if quantization == "4bit":
+            kwargs["quantization_config"] = BitsAndBytesConfig(load_in_4bit=True)
+        else:
+            kwargs["quantization_config"] = BitsAndBytesConfig(load_in_8bit=True)
+
+        model = AutoModelForCausalLM.from_pretrained(model_id, **kwargs)
+        config = AdaLoraConfig(task_type=TaskType.CAUSAL_LM, total_step=1)
+        peft_model = get_peft_model(model, config)
+        peft_model = prepare_model_for_kbit_training(peft_model)
+        peft_model.generate(input_ids=torch.LongTensor([[0, 2, 3, 1]]).to(peft_model.device))
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            peft_model.save_pretrained(tmp_dir)
+            model = AutoModelForCausalLM.from_pretrained(model_id, **kwargs)
+            model = PeftModel.from_pretrained(model, tmp_dir)
+            model = prepare_model_for_kbit_training(peft_model)
+            model.generate(input_ids=torch.LongTensor([[0, 2, 3, 1]]).to(model.device))
+
+            # loading a 2nd adapter works, #1239
+            model.load_adapter(tmp_dir, "adapter2")
+            model.set_adapter("adapter2")
+            model.generate(input_ids=torch.LongTensor([[0, 2, 3, 1]]).to(model.device))
+
+            # check that both adapters are in the same layer
+            assert "default" in model.base_model.model.model.decoder.layers[0].self_attn.q_proj.lora_A
+            assert "adapter2" in model.base_model.model.model.decoder.layers[0].self_attn.q_proj.lora_A
+
+    @require_bitsandbytes
+    @pytest.mark.multi_gpu_tests
+    @pytest.mark.single_gpu_tests
+    @parameterized.expand(["4bit", "8bit"])
+    def test_vera_bnb_quantization_from_pretrained_safetensors(self, quantization):
+        r"""
+        Tests that the bnb quantization using VeRA works as expected with safetensors weights.
+        """
+        model_id = "facebook/opt-350m"
+        kwargs = {"device_map": "auto"}
+        if quantization == "4bit":
+            kwargs["quantization_config"] = BitsAndBytesConfig(load_in_4bit=True)
+        else:
+            kwargs["quantization_config"] = BitsAndBytesConfig(load_in_8bit=True)
+
+        model = AutoModelForCausalLM.from_pretrained(model_id, **kwargs)
+        config = VeraConfig(task_type=TaskType.CAUSAL_LM)
+        peft_model = get_peft_model(model, config)
+        peft_model = prepare_model_for_kbit_training(peft_model)
+        peft_model.generate(input_ids=torch.LongTensor([[0, 2, 3, 1]]).to(peft_model.device))
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            peft_model.save_pretrained(tmp_dir)
+            model = AutoModelForCausalLM.from_pretrained(model_id, **kwargs)
+            model = PeftModel.from_pretrained(model, tmp_dir)
+            model = prepare_model_for_kbit_training(model)
+            model.generate(input_ids=torch.LongTensor([[0, 2, 3, 1]]).to(model.device))
+
+            # loading a 2nd adapter works, #1239
+            model.load_adapter(tmp_dir, "adapter2")
+            model.set_adapter("adapter2")
+            model.generate(input_ids=torch.LongTensor([[0, 2, 3, 1]]).to(model.device))
+
+            # check that both adapters are in the same layer
+            assert "default" in model.base_model.model.model.decoder.layers[0].self_attn.q_proj.vera_A
+            assert "adapter2" in model.base_model.model.model.decoder.layers[0].self_attn.q_proj.vera_A
+
+    @require_bitsandbytes
+    @pytest.mark.multi_gpu_tests
+    @pytest.mark.single_gpu_tests
+    @parameterized.expand(["4bit", "8bit"])
+    def test_randlora_bnb_quantization_from_pretrained_safetensors(self, quantization):
+        r"""
+        Tests that the bnb quantization using RandLora works as expected with safetensors weights.
+        """
+        model_id = "facebook/opt-350m"
+        kwargs = {"device_map": "auto"}
+        if quantization == "4bit":
+            kwargs["quantization_config"] = BitsAndBytesConfig(load_in_4bit=True)
+        else:
+            kwargs["quantization_config"] = BitsAndBytesConfig(load_in_8bit=True)
+
+        model = AutoModelForCausalLM.from_pretrained(model_id, **kwargs)
+        config = RandLoraConfig(task_type=TaskType.CAUSAL_LM)
+        peft_model = get_peft_model(model, config)
+        peft_model = prepare_model_for_kbit_training(peft_model)
+        peft_model.generate(input_ids=torch.LongTensor([[0, 2, 3, 1]]).to(peft_model.device))
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            peft_model.save_pretrained(tmp_dir)
+            model = AutoModelForCausalLM.from_pretrained(model_id, **kwargs)
+            model = PeftModel.from_pretrained(model, tmp_dir)
+            model = prepare_model_for_kbit_training(model)
+            model.generate(input_ids=torch.LongTensor([[0, 2, 3, 1]]).to(model.device))
+
+            # loading a 2nd adapter works, #1239
+            model.load_adapter(tmp_dir, "adapter2")
+            model.set_adapter("adapter2")
+            model.generate(input_ids=torch.LongTensor([[0, 2, 3, 1]]).to(model.device))
+
+            # check that both adapters are in the same layer
+            assert "default" in model.base_model.model.model.decoder.layers[0].self_attn.q_proj.randlora_A
+            assert "adapter2" in model.base_model.model.model.decoder.layers[0].self_attn.q_proj.randlora_A
+
+    @require_bitsandbytes
+    @pytest.mark.multi_gpu_tests
+    @pytest.mark.single_gpu_tests
+    @parameterized.expand(["4bit", "8bit"])
+    def test_ia3_bnb_quantization_from_pretrained_safetensors(self, quantization):
+        r"""
+        Tests that the bnb quantization using IA³ works as expected with safetensors weights.
+        """
+        model_id = "facebook/opt-350m"
+        kwargs = {"device_map": "auto"}
+        if quantization == "4bit":
+            kwargs["quantization_config"] = BitsAndBytesConfig(load_in_4bit=True)
+        else:
+            kwargs["quantization_config"] = BitsAndBytesConfig(load_in_8bit=True)
+
+        model = AutoModelForCausalLM.from_pretrained(model_id, **kwargs)
+        config = IA3Config(task_type=TaskType.CAUSAL_LM)
+        peft_model = get_peft_model(model, config)
+        peft_model = prepare_model_for_kbit_training(peft_model)
+        peft_model.generate(input_ids=torch.LongTensor([[0, 2, 3, 1]]).to(peft_model.device))
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            peft_model.save_pretrained(tmp_dir)
+            model = AutoModelForCausalLM.from_pretrained(model_id, **kwargs)
+            model = PeftModel.from_pretrained(model, tmp_dir)
+            model = prepare_model_for_kbit_training(model)
+            model.generate(input_ids=torch.LongTensor([[0, 2, 3, 1]]).to(model.device))
+
+            # loading a 2nd adapter works, #1239
+            model.load_adapter(tmp_dir, "adapter2")
+            model.set_adapter("adapter2")
+            model.generate(input_ids=torch.LongTensor([[0, 2, 3, 1]]).to(model.device))
+
+            # check that both adapters are in the same layer
+            assert "default" in model.base_model.model.model.decoder.layers[0].self_attn.q_proj.ia3_l
+            assert "adapter2" in model.base_model.model.model.decoder.layers[0].self_attn.q_proj.ia3_l
+
+    @require_gptqmodel
+    @pytest.mark.single_gpu_tests
+    @require_gptqmodel
+    def test_lora_gptq_quantization_from_pretrained_safetensors(self):
+        r"""
+        Tests that GPT-QModel quantization using LoRA works as expected with safetensors weights.
+        """
+        from transformers import GPTQConfig
+
+        model_id = "marcsun13/opt-350m-gptq-4bit"
+        quantization_config = GPTQConfig(bits=4)
+        # Use explicit device instead of "auto" to ensure model stays on single device
+        # This avoids device mismatch issues when reloading the model
+        device_map = f"{self.device}:0"  # e.g., "cuda:0", "xpu:0"
+        kwargs = {
+            "pretrained_model_name_or_path": model_id,
+            "dtype": torch.float16,
+            "device_map": device_map,
+            "quantization_config": quantization_config,
+        }
+        model = AutoModelForCausalLM.from_pretrained(**kwargs)
+        device = model.device
+        model = prepare_model_for_kbit_training(model)
+
+        config = LoraConfig(task_type="CAUSAL_LM")
+        peft_model = get_peft_model(model, config)
+        peft_model.generate(input_ids=torch.LongTensor([[0, 2, 3, 1]]).to(device))
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            peft_model.save_pretrained(tmp_dir)
+            model = AutoModelForCausalLM.from_pretrained(**kwargs)
+            model = PeftModel.from_pretrained(model, tmp_dir)
+            model = prepare_model_for_kbit_training(model)
+            model.generate(input_ids=torch.LongTensor([[0, 2, 3, 1]]).to(device))
+
+            # loading a 2nd adapter works, #1239
+            model.load_adapter(tmp_dir, "adapter2")
+            model.set_adapter("adapter2")
+            model.generate(input_ids=torch.LongTensor([[0, 2, 3, 1]]).to(device))
+
+            # check that both adapters are in the same layer
+            assert "default" in model.base_model.model.model.decoder.layers[0].self_attn.q_proj.lora_A
+            assert "adapter2" in model.base_model.model.model.decoder.layers[0].self_attn.q_proj.lora_A
+
+    @require_bitsandbytes
+    @pytest.mark.multi_gpu_tests
+    @pytest.mark.single_gpu_tests
+    def test_lora_bnb_4bit_quantization(self):
+        r"""
+        Test that tests if the 4bit quantization using LoRA works as expected
+        """
+        whisper_4bit = WhisperForConditionalGeneration.from_pretrained(
+            self.audio_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+        )
+
+        opt_4bit = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+        )
+
+        flan_4bit = AutoModelForSeq2SeqLM.from_pretrained(
+            self.seq2seq_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+        )
+
+        flan_lora_config = LoraConfig(
+            r=16, lora_alpha=32, target_modules=["q", "v"], lora_dropout=0.05, bias="none", task_type="SEQ_2_SEQ_LM"
+        )
+
+        opt_lora_config = LoraConfig(
+            r=16,
+            lora_alpha=32,
+            target_modules=["q_proj", "v_proj"],
+            lora_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+
+        config = LoraConfig(r=32, lora_alpha=64, target_modules=["q_proj", "v_proj"], lora_dropout=0.05, bias="none")
+
+        flan_4bit = get_peft_model(flan_4bit, flan_lora_config)
+        assert isinstance(flan_4bit.base_model.model.encoder.block[0].layer[0].SelfAttention.q, LoraLinear4bit)
+
+        opt_4bit = get_peft_model(opt_4bit, opt_lora_config)
+        assert isinstance(opt_4bit.base_model.model.model.decoder.layers[0].self_attn.v_proj, LoraLinear4bit)
+
+        whisper_4bit = get_peft_model(whisper_4bit, config)
+        assert isinstance(whisper_4bit.base_model.model.model.decoder.layers[0].self_attn.v_proj, LoraLinear4bit)
+
+    @require_bitsandbytes
+    @pytest.mark.multi_gpu_tests
+    @pytest.mark.single_gpu_tests
+    def test_vera_bnb_4bit_quantization(self):
+        r"""
+        Test that tests if the 4bit quantization using VeRA works as expected
+        """
+        whisper_4bit = WhisperForConditionalGeneration.from_pretrained(
+            self.audio_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+        )
+
+        opt_4bit = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+        )
+
+        flan_4bit = AutoModelForSeq2SeqLM.from_pretrained(
+            self.seq2seq_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+        )
+
+        flan_vera_config = VeraConfig(
+            r=16, target_modules=["q", "v"], vera_dropout=0.05, bias="none", task_type="SEQ_2_SEQ_LM"
+        )
+
+        opt_vera_config = VeraConfig(
+            r=16,
+            target_modules=["q_proj", "v_proj"],
+            vera_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+
+        config = VeraConfig(r=32, target_modules=["q_proj", "v_proj"], vera_dropout=0.05, bias="none")
+
+        flan_4bit = get_peft_model(flan_4bit, flan_vera_config)
+        quant_layers = [m for m in flan_4bit.modules() if getattr(m, "quantization_backend", None) is not None]
+        assert len(quant_layers) > 0
+
+        opt_4bit = get_peft_model(opt_4bit, opt_vera_config)
+        quant_layers = [m for m in opt_4bit.modules() if getattr(m, "quantization_backend", None) is not None]
+        assert len(quant_layers) > 0
+
+        whisper_4bit = get_peft_model(whisper_4bit, config)
+        quant_layers = [m for m in whisper_4bit.modules() if getattr(m, "quantization_backend", None) is not None]
+        assert len(quant_layers) > 0
+
+    @require_bitsandbytes
+    @pytest.mark.multi_gpu_tests
+    @pytest.mark.single_gpu_tests
+    def test_randlora_bnb_4bit_quantization(self):
+        r"""
+        Test that tests if the 4bit quantization using RandLoRA works as expected
+        """
+        whisper_4bit = WhisperForConditionalGeneration.from_pretrained(
+            self.audio_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+        )
+
+        opt_4bit = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+        )
+
+        flan_4bit = AutoModelForSeq2SeqLM.from_pretrained(
+            self.seq2seq_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+        )
+
+        flan_randlora_config = RandLoraConfig(
+            r=16, target_modules=["q", "v"], randlora_dropout=0.05, bias="none", task_type="SEQ_2_SEQ_LM"
+        )
+
+        opt_randlora_config = RandLoraConfig(
+            r=16,
+            target_modules=["q_proj", "v_proj"],
+            randlora_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+
+        config = RandLoraConfig(r=32, target_modules=["q_proj", "v_proj"], randlora_dropout=0.05, bias="none")
+
+        flan_4bit = get_peft_model(flan_4bit, flan_randlora_config)
+        assert isinstance(flan_4bit.base_model.model.encoder.block[0].layer[0].SelfAttention.q, RandLoraLinear4bit)
+
+        opt_4bit = get_peft_model(opt_4bit, opt_randlora_config)
+        assert isinstance(opt_4bit.base_model.model.model.decoder.layers[0].self_attn.v_proj, RandLoraLinear4bit)
+
+        whisper_4bit = get_peft_model(whisper_4bit, config)
+        assert isinstance(whisper_4bit.base_model.model.model.decoder.layers[0].self_attn.v_proj, RandLoraLinear4bit)
+
+    @require_bitsandbytes
+    @pytest.mark.multi_gpu_tests
+    @pytest.mark.single_gpu_tests
+    def test_ia3_bnb_4bit_quantization(self):
+        r"""
+        Test that tests if the 4bit quantization using IA3 works as expected
+        """
+        whisper_4bit = WhisperForConditionalGeneration.from_pretrained(
+            self.audio_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+        )
+
+        opt_4bit = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+        )
+
+        flan_4bit = AutoModelForSeq2SeqLM.from_pretrained(
+            self.seq2seq_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+        )
+
+        flan_ia3_config = IA3Config(target_modules=["q", "v"], task_type="SEQ_2_SEQ_LM")
+
+        opt_ia3_config = IA3Config(
+            target_modules=["q_proj", "v_proj", "fc2"],
+            feedforward_modules=["fc2"],
+            task_type="CAUSAL_LM",
+        )
+
+        config = IA3Config(target_modules=["q_proj", "v_proj", "fc2"], feedforward_modules=["fc2"])
+
+        flan_4bit = get_peft_model(flan_4bit, flan_ia3_config)
+        assert isinstance(flan_4bit.base_model.model.encoder.block[0].layer[0].SelfAttention.q, IA3Linear4bit)
+
+        opt_4bit = get_peft_model(opt_4bit, opt_ia3_config)
+        assert isinstance(opt_4bit.base_model.model.model.decoder.layers[0].self_attn.v_proj, IA3Linear4bit)
+
+        whisper_4bit = get_peft_model(whisper_4bit, config)
+        assert isinstance(whisper_4bit.base_model.model.model.decoder.layers[0].self_attn.v_proj, IA3Linear4bit)
+
+    @require_bitsandbytes
+    @pytest.mark.multi_gpu_tests
+    @pytest.mark.single_gpu_tests
+    def test_road_bnb_4bit_quantization(self):
+        r"""
+        Test that tests if the 4bit quantization using IA3 works as expected
+        """
+        whisper_4bit = WhisperForConditionalGeneration.from_pretrained(
+            self.audio_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+        )
+
+        opt_4bit = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+        )
+
+        flan_4bit = AutoModelForSeq2SeqLM.from_pretrained(
+            self.seq2seq_model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+        )
+
+        flan_road_config = RoadConfig(target_modules=["q", "v"], task_type="SEQ_2_SEQ_LM")
+
+        opt_road_config = RoadConfig(
+            target_modules=["q_proj", "v_proj", "fc2"],
+            task_type="CAUSAL_LM",
+        )
+
+        config = RoadConfig(target_modules=["q_proj", "v_proj", "fc2"])
+
+        flan_4bit = get_peft_model(flan_4bit, flan_road_config)
+        assert isinstance(flan_4bit.base_model.model.encoder.block[0].layer[0].SelfAttention.q, RoadLinear4bit)
+
+        opt_4bit = get_peft_model(opt_4bit, opt_road_config)
+        assert isinstance(opt_4bit.base_model.model.model.decoder.layers[0].self_attn.v_proj, RoadLinear4bit)
+
+        whisper_4bit = get_peft_model(whisper_4bit, config)
+        assert isinstance(whisper_4bit.base_model.model.model.decoder.layers[0].self_attn.v_proj, RoadLinear4bit)
+
+    @pytest.mark.multi_gpu_tests
+    @require_torch_multi_accelerator
+    def test_lora_causal_lm_multi_gpu_inference(self):
+        r"""
+        Test if LORA can be used for inference on multiple GPUs.
+        """
+        lora_config = LoraConfig(
+            r=16,
+            lora_alpha=32,
+            target_modules=["q_proj", "v_proj"],
+            lora_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+
+        model = AutoModelForCausalLM.from_pretrained(self.causal_lm_model_id, device_map="balanced")
+        tokenizer = AutoTokenizer.from_pretrained(self.seq2seq_model_id)
+
+        assert set(model.hf_device_map.values()) == set(range(device_count))
+
+        model = get_peft_model(model, lora_config)
+        assert isinstance(model, PeftModel)
+
+        dummy_input = "This is a dummy input:"
+        input_ids = tokenizer(dummy_input, return_tensors="pt").input_ids.to(self.device)
+
+        # this should work without any problem
+        _ = model.generate(input_ids=input_ids)
+
+    @require_torch_multi_accelerator
+    @pytest.mark.multi_gpu_tests
+    @require_bitsandbytes
+    def test_lora_seq2seq_lm_multi_gpu_inference(self):
+        r"""
+        Test if LORA can be used for inference on multiple GPUs - 8bit version.
+        """
+        lora_config = LoraConfig(
+            r=16, lora_alpha=32, target_modules=["q", "v"], lora_dropout=0.05, bias="none", task_type="SEQ_2_SEQ_LM"
+        )
+
+        model = AutoModelForSeq2SeqLM.from_pretrained(
+            self.seq2seq_model_id,
+            device_map=DEVICE_MAP_MAP[self.seq2seq_model_id],
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+        )
+        tokenizer = AutoTokenizer.from_pretrained(self.seq2seq_model_id)
+
+        assert set(model.hf_device_map.values()) == set(DEVICE_MAP_MAP[self.seq2seq_model_id].values())
+
+        model = get_peft_model(model, lora_config)
+        assert isinstance(model, PeftModel)
+        assert isinstance(model.base_model.model.encoder.block[0].layer[0].SelfAttention.q, LoraLinear8bitLt)
+
+        dummy_input = "This is a dummy input:"
+        input_ids = tokenizer(dummy_input, return_tensors="pt").input_ids.to(self.device)
+
+        # this should work without any problem
+        _ = model.generate(input_ids=input_ids)
+
+    @require_torch_multi_accelerator
+    @pytest.mark.multi_gpu_tests
+    @require_bitsandbytes
+    def test_adaption_prompt_8bit(self):
+        model = LlamaForCausalLM.from_pretrained(
+            "trl-internal-testing/tiny-random-LlamaForCausalLM",
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+            dtype=torch.float16,
+            device_map="auto",
+        )
+
+        model = prepare_model_for_kbit_training(model)
+
+        config = AdaptionPromptConfig(
+            adapter_len=10,
+            adapter_layers=2,
+            task_type="CAUSAL_LM",
+        )
+        model = get_peft_model(model, config)
+
+        random_input = torch.LongTensor([[1, 0, 1, 0, 1, 0]]).to(model.device)
+        _ = model(random_input)
+
+    @require_torch_multi_accelerator
+    @pytest.mark.multi_gpu_tests
+    @require_bitsandbytes
+    def test_adaption_prompt_4bit(self):
+        model = LlamaForCausalLM.from_pretrained(
+            "trl-internal-testing/tiny-random-LlamaForCausalLM",
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+            dtype=torch.float16,
+            device_map="auto",
+        )
+
+        model = prepare_model_for_kbit_training(model)
+
+        config = AdaptionPromptConfig(
+            adapter_len=10,
+            adapter_layers=2,
+            task_type="CAUSAL_LM",
+        )
+        model = get_peft_model(model, config)
+
+        random_input = torch.LongTensor([[1, 0, 1, 0, 1, 0]]).to(model.device)
+        _ = model(random_input)
+
+    @require_non_cpu
+    @pytest.mark.single_gpu_tests
+    @require_bitsandbytes
+    def test_print_4bit_expected(self):
+        EXPECTED_TRAINABLE_PARAMS = 294912
+        EXPECTED_ALL_PARAMS = 125534208
+
+        model = AutoModelForCausalLM.from_pretrained(
+            "peft-internal-testing/opt-125m",
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+        )
+
+        config = LoraConfig(
+            r=8,
+        )
+        model = get_peft_model(model, config)
+        trainable_params, all_params = model.get_nb_trainable_parameters()
+
+        assert trainable_params == EXPECTED_TRAINABLE_PARAMS
+        assert all_params == EXPECTED_ALL_PARAMS
+
+        # test with double quant
+        bnb_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_use_double_quant=True,
+        )
+
+        model = AutoModelForCausalLM.from_pretrained(
+            "peft-internal-testing/opt-125m",
+            quantization_config=bnb_config,
+        )
+
+        config = LoraConfig(
+            r=8,
+        )
+        model = get_peft_model(model, config)
+        trainable_params, all_params = model.get_nb_trainable_parameters()
+
+        assert trainable_params == EXPECTED_TRAINABLE_PARAMS
+        assert all_params == EXPECTED_ALL_PARAMS
+
+    @require_non_cpu
+    @pytest.mark.single_gpu_tests
+    @require_bitsandbytes
+    def test_modules_to_save_grad(self):
+        model_id = "bigscience/bloomz-560m"
+
+        model = AutoModelForSequenceClassification.from_pretrained(
+            model_id,
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+            dtype=torch.float32,
+        )
+
+        model = prepare_model_for_kbit_training(model)
+
+        config = LoraConfig(
+            r=16,
+            lora_alpha=16,
+            lora_dropout=0.05,
+            bias="none",
+            task_type="SEQ_CLS",
+        )
+
+        peft_model = get_peft_model(model, config)
+
+        lm_head = peft_model.base_model.model.score
+        original_module = lm_head.original_module
+        modules_to_save = lm_head.modules_to_save.default
+
+        inputs = torch.randn(1024).to(model.device)
+        o1 = lm_head(inputs)
+        o1.mean().backward()
+
+        assert modules_to_save.weight.requires_grad is True
+        assert original_module.weight.grad is None
+        assert modules_to_save.weight.grad is not None
+
+    @require_non_cpu
+    @pytest.mark.single_gpu_tests
+    @require_bitsandbytes
+    def test_8bit_merge_lora(self):
+        torch.manual_seed(1000)
+        model = AutoModelForCausalLM.from_pretrained(
+            "peft-internal-testing/opt-125m",
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+        )
+        random_input = torch.LongTensor([[1, 0, 1, 0, 1, 0]]).to(model.device)
+        out_base = F.softmax(model(random_input).logits, dim=-1)
+
+        config = LoraConfig(
+            r=8,
+            init_lora_weights=False,
+        )
+        model = get_peft_model(model, config)
+
+        with torch.inference_mode():
+            out_before_merge = F.softmax(model(random_input).logits, dim=-1)
+
+        model.merge_and_unload()
+        with torch.inference_mode():
+            out_after_merge = F.softmax(model(random_input).logits, dim=-1)
+
+        atol = 1e-3
+        rtol = 1
+        assert not torch.allclose(out_base, out_before_merge, atol=atol, rtol=rtol)
+        assert torch.allclose(out_before_merge, out_after_merge, atol=atol, rtol=rtol)
+        assert isinstance(model, PeftModel)
+        assert isinstance(model.base_model.model.model.decoder.layers[0].self_attn.q_proj, bnb.nn.Linear8bitLt)
+        assert isinstance(model.base_model.model.model.decoder.layers[0].self_attn.v_proj, bnb.nn.Linear8bitLt)
+
+    @require_non_cpu
+    @pytest.mark.single_gpu_tests
+    @require_bitsandbytes
+    def test_8bit_merge_and_disable_lora(self):
+        torch.manual_seed(1000)
+        model = AutoModelForCausalLM.from_pretrained(
+            "peft-internal-testing/opt-125m",
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+        )
+        random_input = torch.LongTensor([[1, 0, 1, 0, 1, 0]]).to(model.device)
+        # compare outputs in probability space, because logits can have outliers
+        # and token ids are not precise enough
+        out_base = F.softmax(model(random_input).logits, dim=-1)
+
+        config = LoraConfig(
+            r=8,
+            init_lora_weights=False,
+        )
+        model = get_peft_model(model, config)
+
+        with torch.inference_mode():
+            out_before = F.softmax(model(random_input).logits, dim=-1)
+
+        model.merge_adapter()
+        with model.disable_adapter():
+            with torch.inference_mode():
+                out_after = F.softmax(model(random_input).logits, dim=-1)
+
+        atol = 1e-3
+        rtol = 1
+        assert not torch.allclose(out_base, out_before, atol=atol, rtol=rtol)
+        assert torch.allclose(out_base, out_after, atol=atol, rtol=rtol)
+        assert isinstance(model, PeftModel)
+        assert isinstance(model.base_model.model.model.decoder.layers[0].self_attn.q_proj, LoraLinear8bitLt)
+        assert isinstance(model.base_model.model.model.decoder.layers[0].self_attn.v_proj, LoraLinear8bitLt)
+
+    @require_non_cpu
+    @pytest.mark.single_gpu_tests
+    @require_bitsandbytes
+    def test_8bit_merge_lora_with_bias(self):
+        # same as test_8bit_merge_lora but with lora_bias=True
+        torch.manual_seed(0)
+        model = AutoModelForCausalLM.from_pretrained(
+            "peft-internal-testing/opt-125m",
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+        )
+        random_input = torch.LongTensor([[1, 0, 1, 0, 1, 0]]).to(model.device)
+        out_base = F.softmax(model(random_input).logits, dim=-1)
+
+        config = LoraConfig(
+            r=8,
+            init_lora_weights=False,
+            lora_bias=True,
+        )
+        model = get_peft_model(model, config)
+
+        with torch.inference_mode():
+            out_before_merge = F.softmax(model(random_input).logits, dim=-1)
+
+        model.merge_and_unload()
+        with torch.inference_mode():
+            out_after_merge = F.softmax(model(random_input).logits, dim=-1)
+
+        atol = 1e-3
+        rtol = 1
+        assert not torch.allclose(out_base, out_before_merge, atol=atol, rtol=rtol)
+        assert torch.allclose(out_before_merge, out_after_merge, atol=atol, rtol=rtol)
+
+    @require_non_cpu
+    @pytest.mark.single_gpu_tests
+    @require_bitsandbytes
+    def test_4bit_merge_lora(self):
+        torch.manual_seed(3000)
+        bnb_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_use_double_quant=False,
+            bnb_4bit_compute_dtype=torch.float32,
+        )
+        model = AutoModelForCausalLM.from_pretrained(
+            "peft-internal-testing/opt-125m",
+            quantization_config=bnb_config,
+            dtype=torch.float32,
+        )
+        random_input = torch.LongTensor([[1, 0, 1, 0, 1, 0]]).to(model.device)
+        # compare outputs in probability space, because logits can have outliers
+        # and token ids are not precise enough
+        out_base = F.softmax(model(random_input).logits, dim=-1)
+
+        config = LoraConfig(
+            r=8,
+            init_lora_weights=False,
+        )
+        model = get_peft_model(model, config)
+
+        with torch.inference_mode():
+            out_before_merge = F.softmax(model(random_input).logits, dim=-1)
+
+        model.merge_and_unload()
+        with torch.inference_mode():
+            out_after_merge = F.softmax(model(random_input).logits, dim=-1)
+
+        # tolerances are pretty high because some deviations are expected with quantization
+        atol = 0.01
+        rtol = 10
+        assert not torch.allclose(out_base, out_before_merge, atol=atol, rtol=rtol)
+        assert torch.allclose(out_before_merge, out_after_merge, atol=atol, rtol=rtol)
+        assert isinstance(model, PeftModel)
+        assert isinstance(model.base_model.model.model.decoder.layers[0].self_attn.q_proj, bnb.nn.Linear4bit)
+        assert isinstance(model.base_model.model.model.decoder.layers[0].self_attn.v_proj, bnb.nn.Linear4bit)
+
+    @require_non_cpu
+    @pytest.mark.single_gpu_tests
+    @require_bitsandbytes
+    def test_4bit_merge_and_disable_lora(self):
+        torch.manual_seed(3000)
+        bnb_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_use_double_quant=False,
+            bnb_4bit_compute_dtype=torch.float32,
+        )
+        model = AutoModelForCausalLM.from_pretrained(
+            "peft-internal-testing/opt-125m",
+            quantization_config=bnb_config,
+            dtype=torch.float32,
+        )
+        random_input = torch.LongTensor([[1, 0, 1, 0, 1, 0]]).to(model.device)
+        # compare outputs in probability space, because logits can have outliers
+        # and token ids are not precise enough
+        out_base = F.softmax(model(random_input).logits, dim=-1)
+
+        config = LoraConfig(
+            r=8,
+            init_lora_weights=False,
+        )
+        model = get_peft_model(model, config)
+
+        with torch.inference_mode():
+            out_before = F.softmax(model(random_input).logits, dim=-1)
+
+        model.merge_adapter()
+        with model.disable_adapter():
+            with torch.inference_mode():
+                out_after = F.softmax(model(random_input).logits, dim=-1)
+
+        atol = 0.01
+        rtol = 10
+        assert not torch.allclose(out_base, out_before, atol=atol, rtol=rtol)
+        assert torch.allclose(out_base, out_after, atol=atol, rtol=rtol)
+        assert isinstance(model, PeftModel)
+        assert isinstance(model.base_model.model.model.decoder.layers[0].self_attn.q_proj, LoraLinear4bit)
+        assert isinstance(model.base_model.model.model.decoder.layers[0].self_attn.v_proj, LoraLinear4bit)
+
+    @require_non_cpu
+    @pytest.mark.single_gpu_tests
+    @require_bitsandbytes
+    def test_4bit_merge_lora_with_bias(self):
+        # same as test_4bit_merge_lora but with lora_bias=True
+        torch.manual_seed(3000)
+        bnb_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_use_double_quant=False,
+            bnb_4bit_compute_dtype=torch.float32,
+        )
+        model = AutoModelForCausalLM.from_pretrained(
+            "peft-internal-testing/opt-125m",
+            quantization_config=bnb_config,
+            dtype=torch.float32,
+        )
+        random_input = torch.LongTensor([[1, 0, 1, 0, 1, 0]]).to(model.device)
+        # compare outputs in probability space, because logits can have outliers
+        # and token ids are not precise enough
+        out_base = F.softmax(model(random_input).logits, dim=-1)
+
+        config = LoraConfig(
+            r=8,
+            init_lora_weights=False,
+            lora_bias=True,
+        )
+        model = get_peft_model(model, config)
+
+        with torch.inference_mode():
+            out_before_merge = F.softmax(model(random_input).logits, dim=-1)
+
+        model.merge_and_unload()
+        with torch.inference_mode():
+            out_after_merge = F.softmax(model(random_input).logits, dim=-1)
+
+        # tolerances are pretty high because some deviations are expected with quantization
+        atol = 0.01
+        rtol = 10
+        assert not torch.allclose(out_base, out_before_merge, atol=atol, rtol=rtol)
+        assert torch.allclose(out_before_merge, out_after_merge, atol=atol, rtol=rtol)
+
+    @require_non_cpu
+    @pytest.mark.single_gpu_tests
+    @require_bitsandbytes
+    def test_4bit_lora_mixed_adapter_batches_lora(self):
+        # check that we can pass mixed adapter names to the model
+        torch.manual_seed(3000)
+        bnb_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_use_double_quant=False,
+            bnb_4bit_compute_dtype=torch.float32,
+        )
+        model = AutoModelForCausalLM.from_pretrained(
+            "peft-internal-testing/opt-125m",
+            quantization_config=bnb_config,
+            dtype=torch.float32,
+        ).eval()
+        tokenizer = AutoTokenizer.from_pretrained("peft-internal-testing/opt-125m")
+        # input with 9 samples
+        inputs = tokenizer(
+            [
+                "Hello, my dog is cute",
+                "Hello, my cat is awesome",
+                "Hello, my fish is great",
+                "Salut, mon chien est mignon",
+                "Salut, mon chat est génial",
+                "Salut, mon poisson est super",
+                "Hallo, mein Hund ist süß",
+                "Hallo, meine Katze ist toll",
+                "Hallo, mein Fisch ist großartig",
+            ],
+            return_tensors="pt",
+            padding=True,
+        ).to(model.device)
+        with torch.inference_mode():
+            out_base = model(**inputs).logits
+
+        config0 = LoraConfig(
+            r=8,
+            init_lora_weights=False,
+        )
+        model = get_peft_model(model, config0).eval()
+        with torch.inference_mode():
+            out_adapter0 = model(**inputs).logits
+
+        config1 = LoraConfig(
+            r=16,
+            init_lora_weights=False,
+        )
+        model.add_adapter("adapter1", config1)
+        model.set_adapter("adapter1")
+        with torch.inference_mode():
+            out_adapter1 = model(**inputs).logits
+
+        atol, rtol = 3e-5, 1e-5
+        # sanity check, outputs have the right shape and are not the same
+        assert len(out_base) >= 3
+        assert len(out_base) == len(out_adapter0) == len(out_adapter1)
+        assert not torch.allclose(out_base, out_adapter0, atol=atol, rtol=rtol)
+        assert not torch.allclose(out_base, out_adapter1, atol=atol, rtol=rtol)
+        assert not torch.allclose(out_adapter0, out_adapter1, atol=atol, rtol=rtol)
+
+        # mixed adapter batch
+        adapters = ["__base__", "default", "adapter1"]
+        adapter_names = [adapters[i % 3] for i in (range(9))]
+        with torch.inference_mode():
+            out_mixed = model(**inputs, adapter_names=adapter_names).logits
+
+        assert torch.allclose(out_base[::3], out_mixed[::3], atol=atol, rtol=rtol)
+        assert torch.allclose(out_adapter0[1::3], out_mixed[1::3], atol=atol, rtol=rtol)
+        assert torch.allclose(out_adapter1[2::3], out_mixed[2::3], atol=atol, rtol=rtol)
+
+    @require_non_cpu
+    @pytest.mark.single_gpu_tests
+    @require_bitsandbytes
+    def test_8bit_lora_mixed_adapter_batches_lora(self):
+        # check that we can pass mixed adapter names to the model
+        # note that with 8bit, we have quite a bit of imprecision, therefore we use softmax and higher tolerances
+        torch.manual_seed(3000)
+        bnb_config = BitsAndBytesConfig(load_in_8bit=True)
+        model = AutoModelForCausalLM.from_pretrained(
+            "peft-internal-testing/opt-125m",
+            quantization_config=bnb_config,
+            dtype=torch.float32,
+        ).eval()
+        tokenizer = AutoTokenizer.from_pretrained("peft-internal-testing/opt-125m")
+        # input with 9 samples
+        inputs = tokenizer(
+            [
+                "Hello, my dog is cute",
+                "Hello, my cat is awesome",
+                "Hello, my fish is great",
+                "Salut, mon chien est mignon",
+                "Salut, mon chat est génial",
+                "Salut, mon poisson est super",
+                "Hallo, mein Hund ist süß",
+                "Hallo, meine Katze ist toll",
+                "Hallo, mein Fisch ist großartig",
+            ],
+            return_tensors="pt",
+            padding=True,
+        ).to(model.device)
+        with torch.inference_mode():
+            out_base = F.softmax(model(**inputs).logits, dim=-1)
+
+        config0 = LoraConfig(
+            r=8,
+            init_lora_weights=False,
+        )
+        model = get_peft_model(model, config0).eval()
+        with torch.inference_mode():
+            out_adapter0 = F.softmax(model(**inputs).logits, dim=-1)
+
+        config1 = LoraConfig(
+            r=16,
+            init_lora_weights=False,
+        )
+        model.add_adapter("adapter1", config1)
+        model.set_adapter("adapter1")
+        with torch.inference_mode():
+            out_adapter1 = F.softmax(model(**inputs).logits, dim=-1)
+
+        atol = 0.01
+        rtol = 0.5
+        # sanity check, outputs have the right shape and are not the same
+        assert len(out_base) >= 3
+        assert len(out_base) == len(out_adapter0) == len(out_adapter1)
+        assert not torch.allclose(out_base, out_adapter0, atol=atol, rtol=rtol)
+        assert not torch.allclose(out_base, out_adapter1, atol=atol, rtol=rtol)
+        assert not torch.allclose(out_adapter0, out_adapter1, atol=atol, rtol=rtol)
+
+        # mixed adapter batch
+        adapters = ["__base__", "default", "adapter1"]
+        adapter_names = [adapters[i % 3] for i in (range(9))]
+        with torch.inference_mode():
+            out_mixed = F.softmax(model(**inputs, adapter_names=adapter_names).logits, dim=-1)
+
+        assert torch.allclose(out_base[::3], out_mixed[::3], atol=atol, rtol=rtol)
+        assert torch.allclose(out_adapter0[1::3], out_mixed[1::3], atol=atol, rtol=rtol)
+        assert torch.allclose(out_adapter1[2::3], out_mixed[2::3], atol=atol, rtol=rtol)
+
+    @require_non_cpu
+    @pytest.mark.single_gpu_tests
+    def test_serialization_shared_tensors(self):
+        model_checkpoint = "roberta-base"
+        peft_config = LoraConfig(
+            task_type=TaskType.TOKEN_CLS, inference_mode=False, r=16, lora_alpha=16, lora_dropout=0.1, bias="all"
+        )
+        model = AutoModelForTokenClassification.from_pretrained(model_checkpoint, num_labels=11).to(self.device)
+        model = get_peft_model(model, peft_config)
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model.save_pretrained(tmp_dir, safe_serialization=True)
+
+    @require_non_cpu
+    @pytest.mark.single_gpu_tests
+    @require_deterministic_for_xpu
+    @require_bitsandbytes
+    def test_4bit_dora_inference(self):
+        # check for same result with and without DoRA when initializing with init_lora_weights=False
+        bnb_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_use_double_quant=False,
+            bnb_4bit_compute_dtype=torch.float32,
+        )
+        model = AutoModelForCausalLM.from_pretrained(
+            "peft-internal-testing/opt-125m",
+            quantization_config=bnb_config,
+            dtype=torch.float32,
+        )
+
+        torch.manual_seed(0)
+        config_lora = LoraConfig(r=8, init_lora_weights=False, use_dora=False)
+        model = get_peft_model(model, config_lora).eval()
+
+        random_input = torch.LongTensor([[1, 0, 1, 0, 1, 0]]).to(model.device)
+        logits_lora = model(random_input).logits
+
+        model = AutoModelForCausalLM.from_pretrained(
+            "peft-internal-testing/opt-125m",
+            quantization_config=bnb_config,
+            dtype=torch.float32,
+        )
+        torch.manual_seed(0)
+        config_dora = LoraConfig(r=8, init_lora_weights=False, use_dora=True)
+        model = get_peft_model(model, config_dora).eval()
+
+        logits_dora = model(random_input).logits
+
+        assert torch.allclose(logits_lora, logits_dora)
+        # sanity check
+        assert isinstance(model.base_model.model.model.decoder.layers[0].self_attn.q_proj, LoraLinear4bit)
+        assert isinstance(model.base_model.model.model.decoder.layers[0].self_attn.v_proj, LoraLinear4bit)
+
+    @require_non_cpu
+    @pytest.mark.single_gpu_tests
+    @require_deterministic_for_xpu
+    @require_bitsandbytes
+    def test_8bit_dora_inference(self):
+        # check for same result with and without DoRA when initializing with init_lora_weights=False
+        model = AutoModelForCausalLM.from_pretrained(
+            "peft-internal-testing/opt-125m",
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+            dtype=torch.float32,
+        ).eval()
+
+        torch.manual_seed(0)
+        config_lora = LoraConfig(r=8, init_lora_weights=False, use_dora=False)
+        model = get_peft_model(model, config_lora).eval()
+
+        random_input = torch.LongTensor([[1, 0, 1, 0, 1, 0]]).to(model.device)
+        logits_lora = model(random_input).logits
+
+        model = AutoModelForCausalLM.from_pretrained(
+            "peft-internal-testing/opt-125m",
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+            dtype=torch.float32,
+        )
+        torch.manual_seed(0)
+        config_dora = LoraConfig(r=8, init_lora_weights=False, use_dora=True)
+        model = get_peft_model(model, config_dora).eval()
+
+        logits_dora = model(random_input).logits
+
+        assert torch.allclose(logits_lora, logits_dora)
+        # sanity check
+        assert isinstance(model.base_model.model.model.decoder.layers[0].self_attn.q_proj, LoraLinear8bitLt)
+        assert isinstance(model.base_model.model.model.decoder.layers[0].self_attn.v_proj, LoraLinear8bitLt)
+
+    @require_non_cpu
+    @pytest.mark.single_gpu_tests
+    @require_bitsandbytes
+    def test_4bit_dora_merging(self):
+        # Check results for merging, unmerging, unloading
+        torch.manual_seed(0)
+        bnb_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_use_double_quant=False,
+            bnb_4bit_compute_dtype=torch.float32,
+        )
+        model = AutoModelForCausalLM.from_pretrained(
+            "trl-internal-testing/tiny-random-LlamaForCausalLM",
+            quantization_config=bnb_config,
+            dtype=torch.float32,
+        ).eval()
+        random_input = torch.LongTensor([[1, 0, 1, 0, 1, 0]]).to(model.device)
+        # compare outputs in probability space, because logits can have outliers
+        # and token ids are not precise enough
+        out_base = F.softmax(model(random_input).logits, dim=-1)
+
+        config = LoraConfig(
+            r=8,
+            init_lora_weights=False,
+            use_dora=True,
+        )
+        model = get_peft_model(model, config).eval()
+
+        # Note: By default, DoRA is a no-op before training, even if we set init_lora_weights=False. In order to
+        # measure any differences, we need to change the magnitude vector.
+        for name, module in model.named_modules():
+            if isinstance(module, LoraLinear4bit):
+                module.lora_magnitude_vector["default"].weight = torch.nn.Parameter(
+                    10 * torch.rand_like(module.lora_magnitude_vector["default"].weight)
+                )
+
+        with torch.inference_mode():
+            out_dora = F.softmax(model(random_input).logits, dim=-1)
+
+            model.merge_adapter()
+            out_merged = F.softmax(model(random_input).logits, dim=-1)
+
+            model.unmerge_adapter()
+            out_unmerged = F.softmax(model(random_input).logits, dim=-1)
+
+            model = model.merge_and_unload()
+            out_unloaded = F.softmax(model(random_input).logits, dim=-1)
+
+        atol = 1e-5
+        rtol = 1e-3
+        # sanity check that using DoRA changes the results
+        assert not torch.allclose(out_base, out_dora, atol=atol, rtol=rtol)
+        assert torch.allclose(out_dora, out_merged, atol=atol, rtol=rtol)
+        assert torch.allclose(out_dora, out_unmerged, atol=atol, rtol=rtol)
+        assert torch.allclose(out_dora, out_unloaded, atol=atol, rtol=rtol)
+
+    @require_non_cpu
+    @pytest.mark.single_gpu_tests
+    @require_bitsandbytes
+    def test_8bit_dora_merging(self):
+        # Check results for merging, unmerging, unloading
+        torch.manual_seed(0)
+        model = AutoModelForCausalLM.from_pretrained(
+            "peft-internal-testing/opt-125m",
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+            dtype=torch.float32,
+        ).eval()
+
+        random_input = torch.LongTensor([[1, 0, 1, 0, 1, 0]]).to(model.device)
+        # compare outputs in probability space, because logits can have outliers
+        # and token ids are not precise enough
+        out_base = F.softmax(model(random_input).logits, dim=-1)
+
+        config = LoraConfig(
+            r=8,
+            init_lora_weights=False,
+            use_dora=True,
+        )
+        model = get_peft_model(model, config).eval()
+
+        # Note: By default, DoRA is a no-op before training, even if we set init_lora_weights=False. In order to
+        # measure any differences, we need to change the magnitude vector.
+        for name, module in model.named_modules():
+            if isinstance(module, LoraLinear8bitLt):
+                module.lora_magnitude_vector["default"].weight = torch.nn.Parameter(
+                    10 * torch.rand_like(module.lora_magnitude_vector["default"].weight)
+                )
+
+        with torch.inference_mode():
+            out_dora = F.softmax(model(random_input).logits, dim=-1)
+
+            model.merge_adapter()
+            out_merged = F.softmax(model(random_input).logits, dim=-1)
+
+            model.unmerge_adapter()
+            out_unmerged = F.softmax(model(random_input).logits, dim=-1)
+
+            model = model.merge_and_unload()
+            out_unloaded = F.softmax(model(random_input).logits, dim=-1)
+
+        atol = 1e-3
+        rtol = 1
+        # sanity check that using DoRA changes the results
+        assert not torch.allclose(out_base, out_dora, atol=atol, rtol=rtol)
+        assert torch.allclose(out_dora, out_merged, atol=atol, rtol=rtol)
+        assert torch.allclose(out_dora, out_unmerged, atol=atol, rtol=rtol)
+        assert torch.allclose(out_dora, out_unloaded, atol=atol, rtol=rtol)
+
+    @pytest.mark.single_gpu_tests
+    def test_dora_ephemeral_gpu_offload(self):
+        torch.manual_seed(0)
+
+        model = AutoModelForCausalLM.from_pretrained(
+            "peft-internal-testing/opt-125m",
+            dtype=torch.float32,
+        ).eval()
+
+        config = LoraConfig(
+            r=128,
+            init_lora_weights=False,
+            use_dora=True,
+            runtime_config=LoraRuntimeConfig(
+                ephemeral_gpu_offload=True
+            ),  # we enable this, but only to verify that it's gone later
+        )
+        peft_model = get_peft_model(model, config).eval()
+        # Check that ephemeral GPU offloading is present
+        assert peft_model.peft_config["default"].runtime_config.ephemeral_gpu_offload
+
+        # Save to disk
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            peft_model.save_pretrained(tmp_dir)
+
+            # Load from disk 100% on CPU without ephemeral GPU offloading
+            peft_model_cpu = PeftModel.from_pretrained(
+                model,
+                tmp_dir,
+                device_map={"": "cpu"},
+            ).eval()
+
+            # Check that ephemeral GPU offloading is absent
+            assert not peft_model_cpu.peft_config["default"].runtime_config.ephemeral_gpu_offload
+
+            # Load again, with ephemeral GPU offloading enabled
+            peft_model_ego = PeftModel.from_pretrained(
+                model,
+                tmp_dir,
+                device_map={"": "cpu"},
+                ephemeral_gpu_offload=True,
+            ).eval()
+
+        random_input = torch.LongTensor([[1, 0, 1, 0, 1, 0]]).to(model.device)
+        with torch.inference_mode():
+            out_peft_model_cpu = F.softmax(peft_model_cpu(random_input).logits, dim=-1)
+            out_peft_model_ego = F.softmax(peft_model_ego(random_input).logits, dim=-1)
+
+        # The results should be the same
+        assert torch.allclose(out_peft_model_cpu, out_peft_model_ego)
+
+    @require_torch_multi_accelerator
+    @pytest.mark.multi_gpu_tests
+    def test_dora_ephemeral_gpu_offload_multigpu(self):
+        torch.manual_seed(0)
+
+        model = AutoModelForCausalLM.from_pretrained(
+            "peft-internal-testing/opt-125m",
+            dtype=torch.float32,
+        ).eval()
+
+        config = LoraConfig(
+            r=16,  # too small and the time difference is too small
+            init_lora_weights=False,
+            use_dora=True,
+            runtime_config=LoraRuntimeConfig(ephemeral_gpu_offload=True),
+        )
+        peft_model = get_peft_model(model, config).eval()
+
+        layer = peft_model.base_model.model.model.decoder.layers[0].self_attn.v_proj
+        lora_A, lora_B = layer.lora_A, layer.lora_B
+
+        possible_combinations = ["cpu", self.device, f"{self.device}:0", f"{self.device}:1"]
+        adapter_name = layer.active_adapter[0]
+        for device_A in possible_combinations:
+            la = lora_A.to(device_A)
+            for device_B in possible_combinations:
+                lb = lora_B.to(device_B)
+                layer.lora_A, layer.lora_B = la, lb
+                layer.lora_variant[adapter_name].init(layer, adapter_name=adapter_name)  # should not raise an error
+
+    @require_non_cpu
+    @pytest.mark.single_gpu_tests
+    @require_bitsandbytes
+    def test_8bit_road_merging(self):
+        # Check results for merging, unmerging, unloading
+        torch.manual_seed(0)
+        model = AutoModelForCausalLM.from_pretrained(
+            "peft-internal-testing/opt-125m",
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+            dtype=torch.float32,
+        ).eval()
+
+        random_input = torch.LongTensor([[1, 0, 1, 0, 1, 0]]).to(model.device)
+        # compare outputs in probability space, because logits can have outliers
+        # and token ids are not precise enough
+        out_base = F.softmax(model(random_input).logits, dim=-1)
+
+        config = RoadConfig(
+            init_weights=False,
+        )
+        model = get_peft_model(model, config).eval()
+
+        with torch.inference_mode():
+            out_road = F.softmax(model(random_input).logits, dim=-1)
+
+            model.merge_adapter()
+            out_merged = F.softmax(model(random_input).logits, dim=-1)
+
+            model.unmerge_adapter()
+            out_unmerged = F.softmax(model(random_input).logits, dim=-1)
+
+            model = model.merge_and_unload()
+            out_unloaded = F.softmax(model(random_input).logits, dim=-1)
+
+        atol = 1e-3
+        rtol = 1
+        # sanity check that using DoRA changes the results
+        assert not torch.allclose(out_base, out_road, atol=atol, rtol=rtol)
+        assert torch.allclose(out_road, out_merged, atol=atol, rtol=rtol)
+        assert torch.allclose(out_road, out_unmerged, atol=atol, rtol=rtol)
+        assert torch.allclose(out_road, out_unloaded, atol=atol, rtol=rtol)
+
+    @require_non_cpu
+    @pytest.mark.single_gpu_tests
+    @require_bitsandbytes
+    def test_4bit_road_merging(self):
+        # Check results for merging, unmerging, unloading
+        torch.manual_seed(0)
+        bnb_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_use_double_quant=False,
+            bnb_4bit_compute_dtype=torch.float32,
+        )
+        model = AutoModelForCausalLM.from_pretrained(
+            "trl-internal-testing/tiny-random-LlamaForCausalLM",
+            quantization_config=bnb_config,
+            dtype=torch.float32,
+        ).eval()
+        random_input = torch.LongTensor([[1, 0, 1, 0, 1, 0]]).to(model.device)
+        # compare outputs in probability space, because logits can have outliers
+        # and token ids are not precise enough
+        out_base = model(random_input).logits
+        probs_base = F.softmax(out_base, dim=-1)
+
+        config = RoadConfig(
+            init_weights=False,
+            group_size=4,
+        )
+        model = get_peft_model(model, config).eval()
+
+        with torch.inference_mode():
+            out_road = model(random_input).logits
+            probs_road = F.softmax(out_road, dim=-1)
+
+            model.merge_adapter()
+            probs_merged = F.softmax(model(random_input).logits, dim=-1)
+
+            model.unmerge_adapter()
+            probs_unmerged = F.softmax(model(random_input).logits, dim=-1)
+
+            model = model.merge_and_unload()
+            probs_unloaded = F.softmax(model(random_input).logits, dim=-1)
+
+        atol = 1e-5
+        rtol = 1e-3
+        # sanity check that using DoRA changes the results
+        # we compare outputs instead of logits because they may not be sensitive enough
+        assert not torch.allclose(out_base, out_road, atol=atol, rtol=rtol)
+        assert torch.allclose(probs_road, probs_merged, atol=atol, rtol=rtol)
+        assert torch.allclose(probs_road, probs_unmerged, atol=atol, rtol=rtol)
+        assert torch.allclose(probs_road, probs_unloaded, atol=atol, rtol=rtol)
+
+    def test_apply_GS_hra_inference(self):
+        # check for different result with and without apply_GS
+        model = AutoModelForCausalLM.from_pretrained(
+            "peft-internal-testing/opt-125m",
+            dtype=torch.float32,
+        ).eval()
+
+        torch.manual_seed(0)
+        config_hra = HRAConfig(r=8, init_weights=True, apply_GS=False)
+        model = get_peft_model(model, config_hra).eval()
+
+        random_input = torch.LongTensor([[1, 0, 1, 0, 1, 0]]).to(model.device)
+        logits_hra = model(random_input).logits
+
+        model = AutoModelForCausalLM.from_pretrained(
+            "peft-internal-testing/opt-125m",
+            dtype=torch.float32,
+        )
+        torch.manual_seed(0)
+        config_hra_GS = HRAConfig(r=8, init_weights=True, apply_GS=True)
+        model = get_peft_model(model, config_hra_GS)
+
+        logits_hra_GS = model(random_input).logits
+
+        assert not torch.allclose(logits_hra, logits_hra_GS)
+
+    @require_non_cpu
+    @pytest.mark.single_gpu_tests
+    def test_apply_GS_hra_conv2d_inference(self):
+        # check for different result with and without apply_GS
+        model_id = "microsoft/resnet-18"
+        image_processor = AutoImageProcessor.from_pretrained(model_id)
+        image = load_cat_image()
+        data = image_processor(image, return_tensors="pt")
+
+        model = AutoModelForImageClassification.from_pretrained(model_id).eval()
+        torch.manual_seed(0)
+        config_hra = HRAConfig(r=8, init_weights=True, target_modules=["convolution"], apply_GS=False)
+        model = get_peft_model(model, config_hra).eval()
+
+        logits_hra = model(**data).logits
+
+        model = AutoModelForImageClassification.from_pretrained(model_id).eval()
+        torch.manual_seed(0)
+        config_hra_GS = HRAConfig(r=8, init_weights=True, target_modules=["convolution"], apply_GS=True)
+        model = get_peft_model(model, config_hra_GS)
+
+        logits_hra_GS = model(**data).logits
+
+        assert not torch.allclose(logits_hra, logits_hra_GS)
+
+    @require_non_cpu
+    @pytest.mark.single_gpu_tests
+    def test_r_odd_hra_inference(self):
+        # check that an untrained HRA adapter can't be initialized as an identity transformation
+        # when r is an odd number
+        model = AutoModelForCausalLM.from_pretrained(
+            "peft-internal-testing/opt-125m",
+            dtype=torch.float32,
+        ).eval()
+
+        random_input = torch.LongTensor([[1, 0, 1, 0, 1, 0]]).to(model.device)
+
+        torch.manual_seed(0)
+        logits = model(random_input).logits
+
+        config_hra = HRAConfig(r=7, init_weights=True, apply_GS=False)
+        model = get_peft_model(model, config_hra).eval()
+        logits_hra = model(random_input).logits
+
+        assert not torch.allclose(logits, logits_hra)
+
+
+@pytest.mark.skipif(not (torch.cuda.is_available() or is_xpu_available()), reason="test requires a GPU or XPU")
+@pytest.mark.single_gpu_tests
+class TestSameAdapterDifferentDevices:
+    device = infer_device()
+
+    # 1639
+    # The original issue comes down to the following problem: If the user has a base layer on CUDA, moves the adapter to
+    # CPU, then adds another adapter (which will automatically be moved to CUDA), then the first adapter will also be
+    # moved to CUDA.
+    @pytest.fixture
+    def mlp(self):
+        class MLP(nn.Module):
+            def __init__(self, bias=True):
+                super().__init__()
+                self.lin0 = nn.Linear(8, 32, bias=bias)
+                self.lin1 = nn.Linear(32, 2, bias=bias)
+
+        return MLP()
+
+    @pytest.fixture
+    def emb_conv1d(self):
+        class ModelEmbConv1D(nn.Module):
+            def __init__(self, emb_size=100):
+                super().__init__()
+                self.emb = nn.Embedding(emb_size, 5)
+                self.conv1d = Conv1D(1, 5)
+
+        return ModelEmbConv1D()
+
+    @pytest.fixture
+    def conv2d(self):
+        class ModelConv2D(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.conv2d = nn.Conv2d(5, 10, 3)
+
+        return ModelConv2D()
+
+    def test_lora_one_target_add_new_adapter_does_not_change_device(self, mlp):
+        config = LoraConfig(target_modules=["lin0"])
+        model = get_peft_model(mlp, config)
+        model = model.to(self.device)
+        model.lin0.lora_A.cpu()
+        model.lin0.lora_B.cpu()
+
+        # check that the adapter is indeed on CPU and the base model on GPU
+        assert model.lin0.lora_A.default.weight.device.type == "cpu"
+        assert model.lin0.lora_B.default.weight.device.type == "cpu"
+        assert model.lin0.base_layer.weight.device.type == self.device
+
+        model.add_adapter("other", config)
+        # check that after adding a new adapter, the old adapter is still on CPU
+        assert model.lin0.lora_A.default.weight.device.type == "cpu"
+        assert model.lin0.lora_B.default.weight.device.type == "cpu"
+        # the rest should be on GPU
+        assert model.lin0.base_layer.weight.device.type == self.device
+        assert model.lin0.lora_A.other.weight.device.type == self.device
+        assert model.lin0.lora_B.other.weight.device.type == self.device
+
+    def test_lora_multiple_targets_add_new_adapater_does_not_change_device(self, mlp):
+        # same as the previous test, but targeting multiple layers
+        config = LoraConfig(target_modules=["lin0", "lin1"])
+        model = get_peft_model(mlp, config)
+        model = model.to(self.device)
+        # move lin1 to CPU but leave lin0 on GPU
+        model.lin1.lora_A.cpu()
+        model.lin1.lora_B.cpu()
+
+        # check that the adapter is indeed on CPU and the base model on GPU
+        assert model.lin1.lora_A.default.weight.device.type == "cpu"
+        assert model.lin1.lora_B.default.weight.device.type == "cpu"
+        assert model.lin1.base_layer.weight.device.type == self.device
+        assert model.lin0.lora_A.default.weight.device.type == self.device
+        assert model.lin0.lora_B.default.weight.device.type == self.device
+        assert model.lin0.base_layer.weight.device.type == self.device
+
+        model.add_adapter("other", config)
+        # check that after adding a new adapter, the old adapter is still on CPU
+        assert model.lin1.lora_A.default.weight.device.type == "cpu"
+        assert model.lin1.lora_B.default.weight.device.type == "cpu"
+        assert model.lin1.base_layer.weight.device.type == self.device
+        # the rest should be on GPU
+        assert model.lin0.lora_A.default.weight.device.type == self.device
+        assert model.lin0.lora_B.default.weight.device.type == self.device
+        assert model.lin0.base_layer.weight.device.type == self.device
+        assert model.lin0.lora_A.other.weight.device.type == self.device
+        assert model.lin0.lora_B.other.weight.device.type == self.device
+        assert model.lin1.lora_A.other.weight.device.type == self.device
+        assert model.lin1.lora_B.other.weight.device.type == self.device
+
+    def test_lora_embedding_target_add_new_adapter_does_not_change_device(self, emb_conv1d):
+        # same as first test, but targeting the embedding layer
+        config = LoraConfig(target_modules=["emb"])
+        model = get_peft_model(emb_conv1d, config)
+        model = model.to(self.device)
+        model.emb.lora_embedding_A.cpu()
+        model.emb.lora_embedding_B.cpu()
+
+        # check that the adapter is indeed on CPU and the base model on GPU
+        assert model.emb.lora_embedding_A.default.device.type == "cpu"
+        assert model.emb.lora_embedding_B.default.device.type == "cpu"
+        assert model.emb.weight.device.type == self.device
+
+        model.add_adapter("other", config)
+        # check that after adding a new adapter, the old adapter is still on CPU
+        assert model.emb.lora_embedding_A.default.device.type == "cpu"
+        assert model.emb.lora_embedding_B.default.device.type == "cpu"
+        # the rest should be on GPU
+        assert model.emb.weight.device.type == self.device
+        assert model.emb.lora_embedding_A.other.device.type == self.device
+        assert model.emb.lora_embedding_B.other.device.type == self.device
+
+    def test_lora_conv1d_target_add_new_adapter_does_not_change_device(self, emb_conv1d):
+        # same as first test, but targeting the Conv1D layer
+        config = LoraConfig(target_modules=["conv1d"])
+        model = get_peft_model(emb_conv1d, config)
+        model = model.to(self.device)
+        model.conv1d.lora_A.cpu()
+        model.conv1d.lora_B.cpu()
+
+        # check that the adapter is indeed on CPU and the base model on GPU
+        assert model.conv1d.lora_A.default.weight.device.type == "cpu"
+        assert model.conv1d.lora_B.default.weight.device.type == "cpu"
+        assert model.conv1d.weight.device.type == self.device
+
+        model.add_adapter("other", config)
+        # check that after adding a new adapter, the old adapter is still on CPU
+        assert model.conv1d.lora_A.default.weight.device.type == "cpu"
+        assert model.conv1d.lora_B.default.weight.device.type == "cpu"
+        # the rest should be on GPU
+        assert model.conv1d.weight.device.type == self.device
+        assert model.conv1d.lora_A.other.weight.device.type == self.device
+        assert model.conv1d.lora_B.other.weight.device.type == self.device
+
+    def test_lora_dora_add_new_adapter_does_not_change_device(self, mlp):
+        # same as first test, but also using DoRA
+        config = LoraConfig(target_modules=["lin0"], use_dora=True)
+        model = get_peft_model(mlp, config)
+        model = model.to(self.device)
+        model.lin0.lora_A.cpu()
+        model.lin0.lora_B.cpu()
+        model.lin0.lora_magnitude_vector.cpu()
+
+        # check that the adapter is indeed on CPU and the base model on GPU
+        assert model.lin0.lora_A.default.weight.device.type == "cpu"
+        assert model.lin0.lora_B.default.weight.device.type == "cpu"
+        assert model.lin0.lora_magnitude_vector.default.weight.device.type == "cpu"
+        assert model.lin0.base_layer.weight.device.type == self.device
+
+        model.add_adapter("other", config)
+        # check that after adding a new adapter, the old adapter is still on CPU
+        assert model.lin0.lora_A.default.weight.device.type == "cpu"
+        assert model.lin0.lora_B.default.weight.device.type == "cpu"
+        assert model.lin0.lora_magnitude_vector.default.weight.device.type == "cpu"
+        # the rest should be on GPU
+        assert model.lin0.base_layer.weight.device.type == self.device
+        assert model.lin0.lora_A.other.weight.device.type == self.device
+        assert model.lin0.lora_B.other.weight.device.type == self.device
+        assert model.lin0.lora_magnitude_vector.other.weight.device.type == self.device
+
+    def test_adalora_add_new_adapter_does_not_change_device(self, mlp):
+        # same as first test, but using AdaLORA
+        # AdaLora does not like multiple trainable adapters, hence inference_mode=True
+        config = AdaLoraConfig(target_modules=["lin0"], inference_mode=True, total_step=1)
+        model = get_peft_model(mlp, config)
+        model = model.to(self.device)
+        model.lin0.lora_A.cpu()
+        model.lin0.lora_E.cpu()
+
+        # check that the adapter is indeed on CPU and the base model on GPU
+        assert model.lin0.lora_A.default.device.type == "cpu"
+        assert model.lin0.lora_E.default.device.type == "cpu"
+        assert model.lin0.base_layer.weight.device.type == self.device
+
+        model.add_adapter("other", config)
+        # check that after adding a new adapter, the old adapter is still on CPU
+        assert model.lin0.lora_A.default.device.type == "cpu"
+        assert model.lin0.lora_E.default.device.type == "cpu"
+        # the rest should be on GPU
+        assert model.lin0.base_layer.weight.device.type == self.device
+        assert model.lin0.lora_A.other.device.type == self.device
+        assert model.lin0.lora_E.other.device.type == self.device
+
+    def test_boft_add_new_adapter_does_not_change_device(self, mlp):
+        # same as first test, but using BoFT
+        config = BOFTConfig(target_modules=["lin0"])
+        model = get_peft_model(mlp, config)
+        model = model.to(self.device)
+        model.lin0.boft_R.cpu()
+        model.lin0.boft_s.cpu()
+
+        # check that the adapter is indeed on CPU and the base model on GPU
+        assert model.lin0.boft_R.default.device.type == "cpu"
+        assert model.lin0.boft_s.default.device.type == "cpu"
+        assert model.lin0.base_layer.weight.device.type == self.device
+
+        model.add_adapter("other", config)
+        # check that after adding a new adapter, the old adapter is still on CPU
+        assert model.lin0.boft_R.default.device.type == "cpu"
+        assert model.lin0.boft_s.default.device.type == "cpu"
+        # the rest should be on GPU
+        assert model.lin0.base_layer.weight.device.type == self.device
+        assert model.lin0.boft_R.other.device.type == self.device
+        assert model.lin0.boft_s.other.device.type == self.device
+
+    def test_ia3_add_new_adapter_does_not_change_device(self, mlp):
+        # same as first test, but using IA3
+        config = IA3Config(target_modules=["lin0"], feedforward_modules=["lin0"])
+        model = get_peft_model(mlp, config)
+        model = model.to(self.device)
+        model.lin0.ia3_l.cpu()
+
+        # check that the adapter is indeed on CPU and the base model on GPU
+        assert model.lin0.ia3_l.default.device.type == "cpu"
+        assert model.lin0.base_layer.weight.device.type == self.device
+
+        model.add_adapter("other", config)
+        # check that after adding a new adapter, the old adapter is still on CPU
+        assert model.lin0.ia3_l.default.device.type == "cpu"
+        # the rest should be on GPU
+        assert model.lin0.base_layer.weight.device.type == self.device
+        assert model.lin0.ia3_l.other.device.type == self.device
+
+    @pytest.mark.xfail(reason="LN Tuning handling of multiple adapters may not be correct", strict=True)
+    def test_ln_tuning_add_new_adapter_does_not_change_device(self, mlp):
+        # same as first test, but using LN tuning
+        config = LNTuningConfig(target_modules=["lin0"])
+        model = get_peft_model(mlp, config)
+        model = model.to(self.device)
+        model.lin0.ln_tuning_layers.cpu()
+
+        # check that the adapter is indeed on CPU and the base model on GPU
+        assert model.lin0.ln_tuning_layers.default.weight.device.type == "cpu"
+        assert model.lin0.base_layer.weight.device.type == self.device
+
+        model.add_adapter("other", config)
+        # check that after adding a new adapter, the old adapter is still on CPU
+        assert model.lin0.ln_tuning_layers.default.weight.device.type == "cpu"
+        # the rest should be on GPU
+        assert model.lin0.base_layer.weight.device.type == self.device
+        assert model.lin0.ln_tuning_layers.other.weight.device.type == self.device
+
+    def test_loha_add_new_adapter_does_not_change_device(self, mlp):
+        # same as first test, but using LoHa
+        config = LoHaConfig(target_modules=["lin0"])
+        model = get_peft_model(mlp, config)
+        model = model.to(self.device)
+        model.lin0.hada_w1_a.cpu()
+        model.lin0.hada_w2_b.cpu()
+
+        # check that the adapter is indeed on CPU and the base model on GPU
+        assert model.lin0.hada_w1_a.default.device.type == "cpu"
+        assert model.lin0.hada_w2_b.default.device.type == "cpu"
+        assert model.lin0.base_layer.weight.device.type == self.device
+
+        model.add_adapter("other", config)
+        # check that after adding a new adapter, the old adapter is still on CPU
+        assert model.lin0.hada_w1_a.default.device.type == "cpu"
+        assert model.lin0.hada_w2_b.default.device.type == "cpu"
+        # the rest should be on GPU
+        assert model.lin0.base_layer.weight.device.type == self.device
+        assert model.lin0.hada_w1_a.other.device.type == self.device
+        assert model.lin0.hada_w2_b.other.device.type == self.device
+
+    def test_lokr_add_new_adapter_does_not_change_device(self, mlp):
+        # same as first test, but using LoKr
+        config = LoKrConfig(target_modules=["lin0"])
+        model = get_peft_model(mlp, config)
+        model = model.to(self.device)
+        model.lin0.lokr_w1.cpu()
+        model.lin0.lokr_w2.cpu()
+
+        # check that the adapter is indeed on CPU and the base model on GPU
+        assert model.lin0.lokr_w1.default.device.type == "cpu"
+        assert model.lin0.lokr_w2.default.device.type == "cpu"
+        assert model.lin0.base_layer.weight.device.type == self.device
+
+        model.add_adapter("other", config)
+        # check that after adding a new adapter, the old adapter is still on CPU
+        assert model.lin0.lokr_w1.default.device.type == "cpu"
+        assert model.lin0.lokr_w2.default.device.type == "cpu"
+        # the rest should be on GPU
+        assert model.lin0.base_layer.weight.device.type == self.device
+        assert model.lin0.lokr_w1.other.device.type == self.device
+        assert model.lin0.lokr_w2.other.device.type == self.device
+
+    def test_oft_add_new_adapter_does_not_change_device(self, mlp):
+        # same as first test, but using OFT
+        config = OFTConfig(target_modules=["lin0"])
+        model = get_peft_model(mlp, config)
+        model = model.to(self.device)
+        model.lin0.oft_R.default.cpu()
+
+        # check that the adapter is indeed on CPU and the base model on GPU
+        assert model.lin0.oft_R.default.weight.device.type == "cpu"
+        assert model.lin0.base_layer.weight.device.type == self.device
+
+        model.add_adapter("other", config)
+        # check that after adding a new adapter, the old adapter is still on CPU
+        assert model.lin0.oft_R.default.weight.device.type == "cpu"
+        # the rest should be on GPU
+        assert model.lin0.base_layer.weight.device.type == self.device
+        assert model.lin0.oft_R.other.weight.device.type == self.device
+
+    def test_vera_add_new_adapter_does_not_change_device(self, mlp):
+        # same as first test, but using VERA
+        config = VeraConfig(target_modules=["lin0"])
+        model = get_peft_model(mlp, config)
+        model = model.to(self.device)
+        model.lin0.vera_A.cpu()
+        model.lin0.vera_lambda_d.cpu()
+
+        # check that the adapter is indeed on CPU and the base model on GPU
+        assert model.lin0.vera_A.default.device.type == "cpu"
+        assert model.lin0.vera_lambda_d.default.device.type == "cpu"
+        assert model.lin0.base_layer.weight.device.type == self.device
+
+        model.add_adapter("other", config)
+        # check that after adding a new adapter, the old adapter is still on CPU
+        assert model.lin0.vera_A.default.device.type == "cpu"
+        assert model.lin0.vera_lambda_d.default.device.type == "cpu"
+        # the rest should be on GPU
+        assert model.lin0.base_layer.weight.device.type == self.device
+        assert model.lin0.vera_A.other.device.type == self.device
+        assert model.lin0.vera_lambda_d.other.device.type == self.device
+
+    def test_randlora_add_new_adapter_does_not_change_device(self, mlp):
+        # same as first test, but using RandLora
+        config = RandLoraConfig(target_modules=["lin0"])
+        model = get_peft_model(mlp, config)
+        model = model.to(self.device)
+        model.lin0.randlora_A.cpu()
+        model.lin0.randlora_lambda.cpu()
+
+        # check that the adapter is indeed on CPU and the base model on GPU
+        assert model.lin0.randlora_A.default.device.type == "cpu"
+        assert model.lin0.randlora_lambda.default.device.type == "cpu"
+        assert model.lin0.base_layer.weight.device.type == self.device
+
+        model.add_adapter("other", config)
+        # check that after adding a new adapter, the old adapter is still on CPU
+        assert model.lin0.randlora_A.default.device.type == "cpu"
+        assert model.lin0.randlora_lambda.default.device.type == "cpu"
+        # the rest should be on GPU
+        assert model.lin0.base_layer.weight.device.type == self.device
+        assert model.lin0.randlora_A.other.device.type == self.device
+        assert model.lin0.randlora_lambda.other.device.type == self.device
+
+    def test_vblora_add_new_adapter_does_not_change_device(self, mlp):
+        # same as first test, but using VBLoRA
+        config = VBLoRAConfig(target_modules=["lin0"], vector_length=2)
+        model = get_peft_model(mlp, config)
+        model = model.to(self.device)
+        model.lin0.vblora_logits_A.cpu()
+        model.lin0.vblora_logits_B.cpu()
+        model.lin0.vblora_vector_bank.cpu()
+
+        # check that the adapter is indeed on CPU and the base model on GPU
+        assert model.lin0.vblora_logits_A.default.device.type == "cpu"
+        assert model.lin0.vblora_logits_B.default.device.type == "cpu"
+        assert model.lin0.vblora_vector_bank.default.device.type == "cpu"
+        assert model.lin0.base_layer.weight.device.type == self.device
+
+        model.add_adapter("other", config)
+        # check that after adding a new adapter, the old adapter is still on CPU
+        assert model.lin0.vblora_logits_A.default.device.type == "cpu"
+        assert model.lin0.vblora_logits_B.default.device.type == "cpu"
+        assert model.lin0.vblora_vector_bank.default.device.type == "cpu"
+        # the rest should be on GPU
+        assert model.lin0.base_layer.weight.device.type == self.device
+        assert model.lin0.vblora_logits_A.other.device.type == self.device
+        assert model.lin0.vblora_logits_B.other.device.type == self.device
+        assert model.lin0.vblora_vector_bank.other.device.type == self.device
+
+    def test_hra_add_new_adapter_does_not_change_device(self, mlp):
+        # same as first test, but using HRA
+        config = HRAConfig(target_modules=["lin0"])
+        model = get_peft_model(mlp, config)
+        model = model.to(self.device)
+        model.lin0.hra_u.cpu()
+
+        # check that the adapter is indeed on CPU and the base model on GPU
+        assert model.lin0.hra_u.default.device.type == "cpu"
+        assert model.lin0.base_layer.weight.device.type == self.device
+
+        model.add_adapter("other", config)
+        # check that after adding a new adapter, the old adapter is still on CPU
+        assert model.lin0.hra_u.default.device.type == "cpu"
+        # the rest should be on GPU
+        assert model.lin0.base_layer.weight.device.type == self.device
+        assert model.lin0.hra_u.other.device.type == self.device
+
+    def test_road_add_new_adapter_does_not_change_device(self, mlp):
+        # same as first test, but using HRA
+        config = RoadConfig(target_modules=["lin0"], group_size=2)
+        model = get_peft_model(mlp, config)
+        model = model.to(self.device)
+        model.lin0.road_theta.cpu()
+
+        # check that the adapter is indeed on CPU and the base model on GPU
+        assert model.lin0.road_theta.default.device.type == "cpu"
+        assert model.lin0.base_layer.weight.device.type == self.device
+
+        model.add_adapter("other", config)
+        # check that after adding a new adapter, the old adapter is still on CPU
+        assert model.lin0.road_theta.default.device.type == "cpu"
+        # the rest should be on GPU
+        assert model.lin0.base_layer.weight.device.type == self.device
+        assert model.lin0.road_theta.other.device.type == self.device
+
+
+class TestPrepareModelForKbitTraining:
+    """Tests for prepare_model_for_kbit_training that require a GPU (issue #3265 memory fix).
+
+    CPU-only tests for this function live in test_other.py.
+    """
+
+    def _make_fp16_model(self):
+        model = nn.Sequential(
+            nn.Linear(64, 64),
+            nn.Linear(64, 64),
+            nn.Linear(64, 32),
+        ).to(torch.float16)
+        model.is_loaded_in_8bit = True
+        return model
+
+    @require_torch_gpu
+    def test_prepare_model_for_kbit_training_no_memory_leak(self):
+        """CUDA: empty_cache() after bulk fp16→fp32 casts keeps reserved memory under 200 MB (issue #3265)."""
+        model = self._make_fp16_model().cuda()
+
+        torch.cuda.synchronize()
+        torch.cuda.reset_peak_memory_stats()
+        mem_before = torch.cuda.memory_reserved()
+
+        prepare_model_for_kbit_training(model, use_gradient_checkpointing=False)
+
+        torch.cuda.synchronize()
+        mem_after = torch.cuda.memory_reserved()
+
+        delta_mb = (mem_after - mem_before) / (1024**2)
+        assert delta_mb < 200, f"CUDA reserved memory grew by {delta_mb:.1f} MB after prepare_model_for_kbit_training"
+
+        # Confirm empty_cache() was actually called: a second call should not further reduce reserved memory.
+        torch.cuda.empty_cache()
+        mem_after_extra_empty = torch.cuda.memory_reserved()
+        assert mem_after == mem_after_extra_empty, (
+            "Reserved memory changed after a second empty_cache(), meaning the first call was not made"
+        )
diff --git a/tests/test_config.py b/tests/test_config.py
new file mode 100644
index 0000000..a4ecdb8
--- /dev/null
+++ b/tests/test_config.py
@@ -0,0 +1,637 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+import copy
+import json
+import os
+import pickle
+import tempfile
+import warnings
+
+import pytest
+
+from peft import (
+    AdaLoraConfig,
+    AdamssConfig,
+    AdaptionPromptConfig,
+    BeftConfig,
+    BOFTConfig,
+    C3AConfig,
+    CartridgeConfig,
+    CPTConfig,
+    DeftConfig,
+    DeloraConfig,
+    FourierFTConfig,
+    FrodConfig,
+    GloraConfig,
+    GraloraConfig,
+    HiraConfig,
+    HRAConfig,
+    IA3Config,
+    LilyConfig,
+    LNTuningConfig,
+    LoHaConfig,
+    LoKrConfig,
+    LoraConfig,
+    MissConfig,
+    MultitaskPromptTuningConfig,
+    OFTConfig,
+    OSFConfig,
+    PeanutConfig,
+    PeftConfig,
+    PeftType,
+    PolyConfig,
+    PrefixTuningConfig,
+    PromptEncoder,
+    PromptEncoderConfig,
+    PromptTuningConfig,
+    PsoftConfig,
+    PveraConfig,
+    RandLoraConfig,
+    RoadConfig,
+    ShiraConfig,
+    TaskType,
+    TinyLoraConfig,
+    TrainableTokensConfig,
+    VBLoRAConfig,
+    VeraConfig,
+    WaveFTConfig,
+    XLoraConfig,
+)
+
+
+class TestingCommitHashError(Exception):
+    pass
+
+
+PEFT_MODELS_TO_TEST = [("peft-internal-testing/tiny-opt-lora-revision", "test")]
+
+# Config classes and their mandatory parameters
+ALL_CONFIG_CLASSES = (
+    (AdaLoraConfig, {"total_step": 1}),
+    (AdamssConfig, {}),
+    (AdaptionPromptConfig, {}),
+    (BeftConfig, {}),
+    (BOFTConfig, {}),
+    (C3AConfig, {}),
+    (DeftConfig, {}),
+    (FourierFTConfig, {}),
+    (FrodConfig, {}),
+    (GloraConfig, {}),
+    (GraloraConfig, {}),
+    (HiraConfig, {}),
+    (HRAConfig, {}),
+    (IA3Config, {}),
+    (LilyConfig, {}),
+    (LNTuningConfig, {}),
+    (LoHaConfig, {}),
+    (LoKrConfig, {}),
+    (LoraConfig, {}),
+    (MissConfig, {}),
+    (OSFConfig, {}),
+    (MultitaskPromptTuningConfig, {}),
+    (PolyConfig, {}),
+    (CartridgeConfig, {}),
+    (PrefixTuningConfig, {}),
+    (PromptEncoderConfig, {}),
+    (PromptTuningConfig, {}),
+    (PsoftConfig, {}),
+    (PeanutConfig, {}),
+    (RoadConfig, {}),
+    (ShiraConfig, {}),
+    (TinyLoraConfig, {}),
+    (TrainableTokensConfig, {}),
+    (VeraConfig, {}),
+    (VBLoRAConfig, {}),
+    (XLoraConfig, {"hidden_size": 32, "adapters": {}}),
+    (CPTConfig, {"task_type": "CAUSAL_LM"}),
+    (RandLoraConfig, {}),
+    (DeloraConfig, {}),
+    (OFTConfig, {}),
+    (PveraConfig, {}),
+    (WaveFTConfig, {}),
+)
+
+
+class TestPeftConfig:
+    @pytest.mark.parametrize("config_class, mandatory_kwargs", ALL_CONFIG_CLASSES)
+    def test_methods(self, config_class, mandatory_kwargs):
+        r"""
+        Test if all configs have the expected methods. Here we test
+        - to_dict
+        - save_pretrained
+        - from_pretrained
+        - from_json_file
+        """
+        # test if all configs have the expected methods
+        config = config_class(**mandatory_kwargs)
+        assert hasattr(config, "to_dict")
+        assert hasattr(config, "save_pretrained")
+        assert hasattr(config, "from_pretrained")
+        assert hasattr(config, "from_json_file")
+
+    @pytest.mark.parametrize("config_class, mandatory_kwargs", ALL_CONFIG_CLASSES)
+    @pytest.mark.parametrize("valid_task_type", list(TaskType) + [None])
+    def test_valid_task_type(self, config_class, mandatory_kwargs, valid_task_type):
+        r"""
+        Test if all configs work correctly for all valid task types
+        """
+        if config_class is CPTConfig:
+            pytest.skip("CPTConfig only supports the CAUSAL_LM task type (validated in its __post_init__)")
+        config_class(task_type=valid_task_type, **mandatory_kwargs)
+
+    @pytest.mark.parametrize("config_class, mandatory_kwargs", ALL_CONFIG_CLASSES)
+    def test_invalid_task_type(self, config_class, mandatory_kwargs):
+        r"""
+        Test if all configs correctly raise the defined error message for invalid task types.
+        """
+        if config_class is CPTConfig:
+            pytest.skip("CPTConfig validates task_type with a config-specific message in its __post_init__")
+        invalid_task_type = "invalid-task-type"
+        with pytest.raises(
+            ValueError,
+            match=f"Invalid task type: '{invalid_task_type}'. Must be one of the following task types: {', '.join(TaskType)}.",
+        ):
+            config_class(task_type=invalid_task_type, **mandatory_kwargs)
+
+    def test_from_peft_type(self):
+        r"""
+        Test if the config is correctly loaded using:
+        - from_peft_type
+        """
+        from peft.mapping import PEFT_TYPE_TO_CONFIG_MAPPING
+
+        for peft_type in PeftType:
+            expected_cls = PEFT_TYPE_TO_CONFIG_MAPPING[peft_type]
+            mandatory_config_kwargs = {}
+
+            if expected_cls == AdaLoraConfig:
+                mandatory_config_kwargs = {"total_step": 1}
+            elif expected_cls == CPTConfig:
+                mandatory_config_kwargs = {"task_type": TaskType.CAUSAL_LM}
+
+            config = PeftConfig.from_peft_type(peft_type=peft_type, **mandatory_config_kwargs)
+            assert type(config) is expected_cls
+
+    @pytest.mark.parametrize("config_class, mandatory_kwargs", ALL_CONFIG_CLASSES)
+    def test_from_pretrained(self, config_class, mandatory_kwargs):
+        r"""
+        Test if the config is correctly loaded using:
+        - from_pretrained
+        """
+        if config_class is OFTConfig:
+            pytest.skip("OFT's from_pretrained back-compat guard fires before the generic load path tested here")
+        for model_name, revision in PEFT_MODELS_TO_TEST:
+            # Test we can load config from delta
+            config_class.from_pretrained(model_name, revision=revision)
+
+    @pytest.mark.parametrize("config_class, mandatory_kwargs", ALL_CONFIG_CLASSES)
+    def test_save_pretrained(self, config_class, mandatory_kwargs):
+        r"""
+        Test if the config is correctly saved and loaded using
+        - save_pretrained
+        """
+        config = config_class(**mandatory_kwargs)
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            config.save_pretrained(tmp_dirname)
+
+            config_from_pretrained = config_class.from_pretrained(tmp_dirname)
+            assert config.to_dict() == config_from_pretrained.to_dict()
+
+    @pytest.mark.parametrize("config_class, mandatory_kwargs", ALL_CONFIG_CLASSES)
+    def test_from_json_file(self, config_class, mandatory_kwargs):
+        config = config_class(**mandatory_kwargs)
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            config.save_pretrained(tmp_dirname)
+
+            config_path = os.path.join(tmp_dirname, "adapter_config.json")
+            config_from_json = config_class.from_json_file(config_path)
+            assert config.to_dict() == config_from_json
+
+            # Also test with a runtime_config entry -- they should be ignored, even if they
+            # were accidentally saved to disk
+            config_from_json["runtime_config"] = {"ephemeral_gpu_offload": True}
+            with open(config_path, "w") as f:
+                json.dump(config_from_json, f)
+
+            config_from_json = config_class.from_json_file(config_path)
+            assert config.to_dict() == config_from_json
+
+    @pytest.mark.parametrize("config_class, mandatory_kwargs", ALL_CONFIG_CLASSES)
+    def test_to_dict(self, config_class, mandatory_kwargs):
+        r"""
+        Test if the config can be correctly converted to a dict using:
+        - to_dict
+        """
+        config = config_class(**mandatory_kwargs)
+        assert isinstance(config.to_dict(), dict)
+
+    @pytest.mark.parametrize("config_class, mandatory_kwargs", ALL_CONFIG_CLASSES)
+    def test_from_pretrained_cache_dir(self, config_class, mandatory_kwargs):
+        r"""
+        Test if the config is correctly loaded with extra kwargs
+        """
+        if config_class is OFTConfig:
+            pytest.skip("OFT's from_pretrained back-compat guard fires before the generic load path tested here")
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            for model_name, revision in PEFT_MODELS_TO_TEST:
+                # Test we can load config from delta
+                config_class.from_pretrained(model_name, revision=revision, cache_dir=tmp_dirname)
+
+    def test_from_pretrained_cache_dir_remote(self):
+        r"""
+        Test if the config is correctly loaded with a checkpoint from the hub
+        """
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            PeftConfig.from_pretrained("ybelkada/test-st-lora", cache_dir=tmp_dirname)
+            assert "models--ybelkada--test-st-lora" in os.listdir(tmp_dirname)
+
+    @pytest.mark.parametrize("config_class, mandatory_kwargs", ALL_CONFIG_CLASSES)
+    def test_save_pretrained_with_runtime_config(self, config_class, mandatory_kwargs):
+        r"""
+        Test if the config correctly removes runtime config when saving
+        """
+        if config_class is OFTConfig:
+            pytest.skip("OFT's from_pretrained back-compat guard fires before the generic load path tested here")
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            for model_name, revision in PEFT_MODELS_TO_TEST:
+                cfg = config_class.from_pretrained(model_name, revision=revision)
+                # NOTE: cfg is always a LoraConfig here, because the configuration of the loaded model was a LoRA.
+                # Hence we can expect a runtime_config to exist regardless of config_class.
+                cfg.runtime_config.ephemeral_gpu_offload = True
+                cfg.save_pretrained(tmp_dirname)
+                cfg = config_class.from_pretrained(tmp_dirname)
+                assert not cfg.runtime_config.ephemeral_gpu_offload
+
+    @pytest.mark.parametrize("config_class, mandatory_kwargs", ALL_CONFIG_CLASSES)
+    def test_set_attributes(self, config_class, mandatory_kwargs):
+        # manually set attributes and check if they are correctly written
+        config = config_class(peft_type="test", **mandatory_kwargs)
+
+        # save pretrained
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            config.save_pretrained(tmp_dirname)
+
+            config_from_pretrained = config_class.from_pretrained(tmp_dirname)
+            assert config.to_dict() == config_from_pretrained.to_dict()
+
+    @pytest.mark.parametrize("config_class, mandatory_kwargs", ALL_CONFIG_CLASSES)
+    def test_config_copy(self, config_class, mandatory_kwargs):
+        # see https://github.com/huggingface/peft/issues/424
+        config = config_class(**mandatory_kwargs)
+        copied = copy.copy(config)
+        assert config.to_dict() == copied.to_dict()
+
+    @pytest.mark.parametrize("config_class, mandatory_kwargs", ALL_CONFIG_CLASSES)
+    def test_config_deepcopy(self, config_class, mandatory_kwargs):
+        # see https://github.com/huggingface/peft/issues/424
+        config = config_class(**mandatory_kwargs)
+        copied = copy.deepcopy(config)
+        assert config.to_dict() == copied.to_dict()
+
+    @pytest.mark.parametrize("config_class, mandatory_kwargs", ALL_CONFIG_CLASSES)
+    def test_config_pickle_roundtrip(self, config_class, mandatory_kwargs):
+        # see https://github.com/huggingface/peft/issues/424
+        config = config_class(**mandatory_kwargs)
+        copied = pickle.loads(pickle.dumps(config))
+        assert config.to_dict() == copied.to_dict()
+
+    def test_prompt_encoder_warning_num_layers(self):
+        # This test checks that if a prompt encoder config is created with an argument that is ignored, there should be
+        # warning. However, there should be no warning if the default value is used.
+        kwargs = {
+            "num_virtual_tokens": 20,
+            "num_transformer_submodules": 1,
+            "token_dim": 768,
+            "encoder_hidden_size": 768,
+        }
+
+        # there should be no warning with just default argument for encoder_num_layer
+        config = PromptEncoderConfig(**kwargs)
+        with warnings.catch_warnings():
+            PromptEncoder(config)
+
+        # when changing encoder_num_layer, there should be a warning for MLP since that value is not used
+        config = PromptEncoderConfig(encoder_num_layers=123, **kwargs)
+        with pytest.warns(UserWarning) as record:
+            PromptEncoder(config)
+        expected_msg = "for MLP, the argument `encoder_num_layers` is ignored. Exactly 2 MLP layers are used."
+        assert str(record.list[0].message) == expected_msg
+
+    @pytest.mark.parametrize(
+        "config_class", [LoHaConfig, LoraConfig, IA3Config, BeftConfig, OFTConfig, BOFTConfig, HRAConfig, VBLoRAConfig]
+    )
+    def test_save_pretrained_with_target_modules(self, config_class):
+        # See #1041, #1045
+        config = config_class(target_modules=["a", "list"])
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            config.save_pretrained(tmp_dirname)
+
+            config_from_pretrained = config_class.from_pretrained(tmp_dirname)
+            assert config.to_dict() == config_from_pretrained.to_dict()
+            # explicit test that target_modules should be converted to set
+            assert isinstance(config_from_pretrained.target_modules, set)
+
+    def test_regex_with_layer_indexing_lora(self):
+        # This test checks that an error is raised if `target_modules` is a regex expression and `layers_to_transform` or
+        # `layers_pattern` are not None
+
+        invalid_config1 = {"target_modules": ".*foo", "layers_to_transform": [0]}
+        invalid_config2 = {"target_modules": ".*foo", "layers_pattern": ["bar"]}
+
+        valid_config = {"target_modules": ["foo"], "layers_pattern": ["bar"], "layers_to_transform": [0]}
+
+        with pytest.raises(ValueError, match="`layers_to_transform` cannot be used when `target_modules` is a str."):
+            LoraConfig(**invalid_config1)
+
+        with pytest.raises(ValueError, match="`layers_pattern` cannot be used when `target_modules` is a str."):
+            LoraConfig(**invalid_config2)
+
+        # should run without errors
+        LoraConfig(**valid_config)
+
+    def test_ia3_is_feedforward_subset_invalid_config(self):
+        # This test checks that the IA3 config raises a value error if the feedforward_modules argument
+        # is not a subset of the target_modules argument
+
+        # an example invalid config
+        invalid_config = {"target_modules": ["k", "v"], "feedforward_modules": ["q"]}
+
+        with pytest.raises(ValueError, match="^`feedforward_modules` should be a subset of `target_modules`$"):
+            IA3Config(**invalid_config)
+
+    def test_ia3_is_feedforward_subset_valid_config(self):
+        # This test checks that the IA3 config is created without errors with valid arguments.
+        # feedforward_modules should be a subset of target_modules if both are lists
+
+        # an example valid config with regex expressions.
+        valid_config_regex_exp = {
+            "target_modules": ".*.(SelfAttention|EncDecAttention|DenseReluDense).*(q|v|wo)$",
+            "feedforward_modules": ".*.DenseReluDense.wo$",
+        }
+        # an example valid config with module lists.
+        valid_config_list = {"target_modules": ["k", "v", "wo"], "feedforward_modules": ["wo"]}
+
+        # should run without errors
+        IA3Config(**valid_config_regex_exp)
+        IA3Config(**valid_config_list)
+
+    def test_adalora_config_r_warning(self):
+        # This test checks that a warning is raised when r is set other than default in AdaLoraConfig
+        # No warning should be raised when initializing AdaLoraConfig with default values.
+        kwargs = {"peft_type": "ADALORA", "task_type": "SEQ_2_SEQ_LM", "init_r": 12, "lora_alpha": 32, "total_step": 1}
+        # Test that no warning is raised with default initialization
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
+            try:
+                AdaLoraConfig(**kwargs)
+            except Warning:
+                pytest.fail("AdaLoraConfig raised a warning with default initialization.")
+        # Test that a warning is raised when r != 8 in AdaLoraConfig
+        with pytest.warns(UserWarning, match="Note that `r` is not used in AdaLora and will be ignored."):
+            AdaLoraConfig(r=10, total_step=1)
+
+    def test_adalora_config_correct_timing_still_works(self):
+        pass
+
+    @pytest.mark.parametrize(
+        "timing_kwargs",
+        [
+            {"total_step": 100, "tinit": 0, "tfinal": 0},
+            {"total_step": 100, "tinit": 10, "tfinal": 10},
+            {"total_step": 100, "tinit": 79, "tfinal": 20},
+            {"total_step": 100, "tinit": 80, "tfinal": 19},
+        ],
+    )
+    def test_adalora_config_valid_timing_works(self, timing_kwargs):
+        # Make sure that passing correct timing values is not prevented by faulty config checks.
+        AdaLoraConfig(**timing_kwargs)  # does not raise
+
+    def test_adalora_config_invalid_total_step_raises(self):
+        with pytest.raises(ValueError) as e:
+            AdaLoraConfig(total_step=None)
+        assert "AdaLoRA does not work when `total_step` is None, supply a value > 0." in str(e)
+
+    @pytest.mark.parametrize(
+        "timing_kwargs",
+        [
+            {"total_step": 100, "tinit": 20, "tfinal": 80},
+            {"total_step": 100, "tinit": 80, "tfinal": 20},
+            {"total_step": 10, "tinit": 20, "tfinal": 0},
+            {"total_step": 10, "tinit": 0, "tfinal": 10},
+            {"total_step": 10, "tinit": 10, "tfinal": 0},
+            {"total_step": 10, "tinit": 20, "tfinal": 20},
+            {"total_step": 10, "tinit": 0, "tfinal": 20},
+        ],
+    )
+    def test_adalora_config_timing_bounds_error(self, timing_kwargs):
+        # Check if the user supplied timing values that will certainly fail because it breaks
+        # AdaLoRA assumptions.
+        with pytest.raises(ValueError) as e:
+            AdaLoraConfig(**timing_kwargs)
+
+        assert "The supplied schedule values don't allow for a budgeting phase" in str(e)
+
+    @pytest.mark.parametrize("config_class, mandatory_kwargs", ALL_CONFIG_CLASSES)
+    def test_from_pretrained_forward_compatible(self, config_class, mandatory_kwargs, tmp_path, recwarn):
+        """
+        Make it possible to load configs that contain unknown keys by ignoring them.
+
+        The idea is to make PEFT configs forward-compatible with future versions of the library.
+        """
+        config = config_class(**mandatory_kwargs)
+        config.save_pretrained(tmp_path)
+        # add a spurious key to the config
+        with open(tmp_path / "adapter_config.json") as f:
+            config_dict = json.load(f)
+        config_dict["foobar"] = "baz"
+        config_dict["spam"] = 123
+        with open(tmp_path / "adapter_config.json", "w") as f:
+            json.dump(config_dict, f)
+
+        msg = f"Unexpected keyword arguments ['foobar', 'spam'] for class {config_class.__name__}, these are ignored."
+        config_from_pretrained = config_class.from_pretrained(tmp_path)
+
+        expected_num_warnings = 1
+        assert len(recwarn) == expected_num_warnings
+        assert recwarn.list[-1].message.args[0].startswith(msg)
+        assert "foo" not in config_from_pretrained.to_dict()
+        assert "spam" not in config_from_pretrained.to_dict()
+        assert config.to_dict() == config_from_pretrained.to_dict()
+        assert isinstance(config_from_pretrained, config_class)
+
+    @pytest.mark.parametrize("config_class, mandatory_kwargs", ALL_CONFIG_CLASSES)
+    def test_from_pretrained_forward_compatible_load_from_peft_config(
+        self, config_class, mandatory_kwargs, tmp_path, recwarn
+    ):
+        """Exact same test as before, but instead of using LoraConfig.from_pretrained, AdaLoraconfig.from_pretrained,
+        etc. use PeftConfig.from_pretrained. This covers a previously existing bug where only the known arguments from
+        PeftConfig would be used instead of the more specific config (which is known thanks to the peft_type
+        attribute).
+
+        """
+        config = config_class(**mandatory_kwargs)
+        config.save_pretrained(tmp_path)
+        # add a spurious key to the config
+        with open(tmp_path / "adapter_config.json") as f:
+            config_dict = json.load(f)
+        config_dict["foobar"] = "baz"
+        config_dict["spam"] = 123
+        with open(tmp_path / "adapter_config.json", "w") as f:
+            json.dump(config_dict, f)
+
+        msg = f"Unexpected keyword arguments ['foobar', 'spam'] for class {config_class.__name__}, these are ignored."
+        config_from_pretrained = PeftConfig.from_pretrained(tmp_path)  # <== use PeftConfig here
+
+        expected_num_warnings = 1
+        assert len(recwarn) == expected_num_warnings
+        assert recwarn.list[-1].message.args[0].startswith(msg)
+        assert "foo" not in config_from_pretrained.to_dict()
+        assert "spam" not in config_from_pretrained.to_dict()
+        assert config.to_dict() == config_from_pretrained.to_dict()
+        assert isinstance(config_from_pretrained, config_class)
+
+    @pytest.mark.parametrize("config_class, mandatory_kwargs", ALL_CONFIG_CLASSES)
+    def test_from_pretrained_sanity_check(self, config_class, mandatory_kwargs, tmp_path):
+        """Following up on the previous test about forward compatibility, we *don't* want any random json to be accepted as
+        a PEFT config. There should be a minimum set of required keys.
+        """
+        if config_class is OFTConfig:
+            pytest.skip("OFT's from_pretrained back-compat guard fires before the generic load path tested here")
+        non_peft_json = {"foo": "bar", "baz": 123}
+        with open(tmp_path / "adapter_config.json", "w") as f:
+            json.dump(non_peft_json, f)
+
+        msg = f"The {config_class.__name__} config that is trying to be loaded is missing required keys: {{'peft_type'}}."
+        with pytest.raises(TypeError, match=msg):
+            config_class.from_pretrained(tmp_path)
+
+    def test_lora_config_layers_to_transform_validation(self):
+        """Test that specifying layers_pattern without layers_to_transform raises an error"""
+        with pytest.raises(
+            ValueError, match="When `layers_pattern` is specified, `layers_to_transform` must also be specified."
+        ):
+            LoraConfig(r=8, lora_alpha=16, target_modules=["query", "value"], layers_pattern="model.layers")
+
+        # Test that specifying both layers_to_transform and layers_pattern works fine
+        config = LoraConfig(
+            r=8,
+            lora_alpha=16,
+            target_modules=["query", "value"],
+            layers_to_transform=[0, 1, 2],
+            layers_pattern="model.layers",
+        )
+        assert config.layers_to_transform == [0, 1, 2]
+        assert config.layers_pattern == "model.layers"
+
+        # Test that not specifying either works fine
+        config = LoraConfig(
+            r=8,
+            lora_alpha=16,
+            target_modules=["query", "value"],
+        )
+        assert config.layers_to_transform is None
+        assert config.layers_pattern is None
+
+    @pytest.mark.parametrize("version", ["0.10", "0.17.0", "1"])
+    @pytest.mark.parametrize("config_class, mandatory_kwargs", ALL_CONFIG_CLASSES)
+    def test_peft_version_is_stored(self, version, config_class, mandatory_kwargs, monkeypatch, tmp_path):
+        # Check that the PEFT version is automatically stored in/restored from the config file.
+        from peft import config
+
+        monkeypatch.setattr(config, "__version__", version)
+
+        peft_config = config_class(**mandatory_kwargs)
+        assert peft_config.peft_version == version
+
+        peft_config.save_pretrained(tmp_path)
+        with open(tmp_path / "adapter_config.json") as f:
+            config_dict = json.load(f)
+        assert config_dict["peft_version"] == version
+
+        # ensure that the version from the config is being loaded, not just the current version
+        monkeypatch.setattr(config, "__version__", "0.1.another-version")
+
+        # load from config
+        config_loaded = PeftConfig.from_pretrained(tmp_path)
+        assert config_loaded.peft_version == version
+
+        # load from json
+        config_path = tmp_path / "adapter_config.json"
+        config_json = PeftConfig.from_json_file(str(config_path))
+        assert config_json["peft_version"] == version
+
+    @pytest.mark.parametrize("config_class, mandatory_kwargs", ALL_CONFIG_CLASSES)
+    def test_peft_version_is_dev_version(self, config_class, mandatory_kwargs, monkeypatch, tmp_path):
+        # When a dev version of PEFT is installed, the actual state of PEFT is ambiguous. Therefore, try to determine
+        # the commit hash too and store it as part of the version string.
+        from peft import config
+
+        version = "0.15.0.dev7"
+        monkeypatch.setattr(config, "__version__", version)
+
+        def fake_commit_hash(pkg_name):
+            return "abcdef012345"
+
+        monkeypatch.setattr(config, "_get_commit_hash", fake_commit_hash)
+
+        peft_config = config_class(**mandatory_kwargs)
+        expected_version = f"{version}@{fake_commit_hash('peft')}"
+        assert peft_config.peft_version == expected_version
+
+        peft_config.save_pretrained(tmp_path)
+        config_loaded = PeftConfig.from_pretrained(tmp_path)
+        assert config_loaded.peft_version == expected_version
+
+    @pytest.mark.parametrize("config_class, mandatory_kwargs", ALL_CONFIG_CLASSES)
+    def test_peft_version_is_dev_version_but_commit_hash_cannot_be_determined(
+        self, config_class, mandatory_kwargs, monkeypatch, tmp_path
+    ):
+        # There can be cases where PEFT is using a dev version but the commit hash cannot be determined. In this case,
+        # just store the dev version string.
+        from peft import config
+
+        version = "0.15.0.dev7"
+        monkeypatch.setattr(config, "__version__", version)
+
+        def fake_commit_hash(pkg_name):
+            return None
+
+        monkeypatch.setattr(config, "_get_commit_hash", fake_commit_hash)
+
+        peft_config = config_class(**mandatory_kwargs)
+        assert peft_config.peft_version == version + "@UNKNOWN"
+
+        peft_config.save_pretrained(tmp_path)
+        config_loaded = PeftConfig.from_pretrained(tmp_path)
+        assert config_loaded.peft_version == version + "@UNKNOWN"
+
+    @pytest.mark.parametrize("config_class, mandatory_kwargs", ALL_CONFIG_CLASSES)
+    def test_peft_version_warn_when_commit_hash_errors(self, config_class, mandatory_kwargs, monkeypatch, tmp_path):
+        # We try to get the PEFT commit hash if a dev version is installed. But in case there is any kind of error
+        # there, we don't want user code to break. Instead, the code should run and a version without commit hash should
+        # be recorded. In addition, there should be a warning.
+        from peft import config
+
+        version = "0.15.0.dev7"
+        monkeypatch.setattr(config, "__version__", version)
+
+        def fake_commit_hash_raises(pkg_name):
+            raise TestingCommitHashError("Error for testing purpose")
+
+        monkeypatch.setattr(config, "_get_commit_hash", fake_commit_hash_raises)
+
+        msg = "A dev version of PEFT is used but there was an error while trying to determine the commit hash"
+        with pytest.warns(UserWarning, match=msg):
+            peft_config = config_class(**mandatory_kwargs)
+        assert peft_config.peft_version == version + "@UNKNOWN"
diff --git a/tests/test_cpt.py b/tests/test_cpt.py
new file mode 100644
index 0000000..7cec525
--- /dev/null
+++ b/tests/test_cpt.py
@@ -0,0 +1,305 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+from typing import Any, Union
+
+import pytest
+import torch
+from datasets import load_dataset
+from torch.utils.data import Dataset
+from tqdm import tqdm
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    DataCollatorForLanguageModeling,
+    Trainer,
+    TrainingArguments,
+)
+
+from peft import CPTConfig, TaskType, get_peft_model
+
+
+TEMPLATE = {"input": "input: {}", "intra_separator": " ", "output": "output: {}", "inter_separator": "\n"}
+
+MODEL_NAME = "peft-internal-testing/tiny-random-OPTForCausalLM"
+MAX_INPUT_LENGTH = 1024
+
+
+@pytest.fixture(scope="module")
+def global_tokenizer():
+    """Load the tokenizer fixture for the model."""
+
+    return AutoTokenizer.from_pretrained(MODEL_NAME, padding_side="right")
+
+
+@pytest.fixture(scope="module")
+def config_text():
+    """Load the SST2 dataset and prepare it for testing."""
+    config = CPTConfig(
+        cpt_token_ids=[0, 1, 2, 3, 4, 5, 6, 7],  # Example token IDs for testing
+        cpt_mask=[1, 1, 1, 1, 1, 1, 1, 1],
+        cpt_tokens_type_mask=[1, 2, 2, 2, 3, 3, 3, 4],
+        opt_weighted_loss_type="decay",
+        opt_loss_decay_factor=0.95,
+        opt_projection_epsilon=0.2,
+        opt_projection_format_epsilon=0.1,
+        tokenizer_name_or_path=MODEL_NAME,
+        task_type=TaskType.CAUSAL_LM,
+    )
+    return config
+
+
+@pytest.fixture(scope="module")
+def config_random():
+    """Load the SST2 dataset and prepare it for testing."""
+    config = CPTConfig(
+        opt_weighted_loss_type="decay",
+        opt_loss_decay_factor=0.95,
+        opt_projection_epsilon=0.2,
+        opt_projection_format_epsilon=0.1,
+        tokenizer_name_or_path=MODEL_NAME,
+        task_type=TaskType.CAUSAL_LM,
+    )
+    return config
+
+
+@pytest.fixture(scope="module")
+def sst_data():
+    """Load the SST2 dataset and prepare it for testing."""
+    data = load_dataset("nyu-mll/glue", "sst2")
+
+    def add_string_labels(example):
+        if example["label"] == 0:
+            example["label_text"] = "negative"
+        elif example["label"] == 1:
+            example["label_text"] = "positive"
+        return example
+
+    train_dataset = data["train"].select(range(4)).map(add_string_labels)
+    test_dataset = data["validation"].select(range(10)).map(add_string_labels)
+
+    return {"train": train_dataset, "test": test_dataset}
+
+
+@pytest.fixture(scope="module")
+def collator(global_tokenizer):
+    class CPTDataCollatorForLanguageModeling(DataCollatorForLanguageModeling):
+        def __init__(self, tokenizer, training=True, mlm=False):
+            super().__init__(tokenizer, mlm=mlm)
+            self.training = training
+            self.tokenizer.add_special_tokens({"pad_token": "[PAD]"})  # mk check why needed
+
+        def torch_call(self, examples: list[Union[list[int], Any, dict[str, Any]]]) -> dict[str, Any]:
+            # Handle dict or lists with proper padding and conversion to tensor.
+            list_sample_mask = []
+            for i in range(len(examples)):
+                if "sample_mask" in examples[i].keys():
+                    list_sample_mask.append(examples[i].pop("sample_mask"))
+
+            max_len = max(len(ex["input_ids"]) for ex in examples)
+
+            def pad_sequence(sequence, max_len, pad_value=0):
+                return sequence + [pad_value] * (max_len - len(sequence))
+
+            input_ids = torch.tensor([pad_sequence(ex["input_ids"], max_len) for ex in examples])
+            attention_mask = torch.tensor([pad_sequence(ex["attention_mask"], max_len) for ex in examples])
+            input_type_mask = torch.tensor([pad_sequence(ex["input_type_mask"], max_len) for ex in examples])
+
+            batch = {"input_ids": input_ids, "attention_mask": attention_mask, "input_type_mask": input_type_mask}
+
+            tensor_sample_mask = batch["input_ids"].clone().long()
+            tensor_sample_mask[:, :] = 0
+            for i in range(len(list_sample_mask)):
+                tensor_sample_mask[i, : len(list_sample_mask[i])] = list_sample_mask[i]
+
+            batch["labels"] = batch["input_ids"].clone()
+            if not self.training:
+                batch["sample_mask"] = tensor_sample_mask
+
+            return batch
+
+    collator = CPTDataCollatorForLanguageModeling(global_tokenizer, training=True, mlm=False)
+    return collator
+
+
+def dataset(data, tokenizer):
+    class CPTDataset(Dataset):
+        def __init__(self, samples, tokenizer, template, max_length=MAX_INPUT_LENGTH):
+            self.template = template
+            self.tokenizer = tokenizer
+            self.max_length = max_length
+
+            self.attention_mask = []
+            self.input_ids = []
+            self.input_type_mask = []
+            self.inter_separator_ids = self._get_input_ids(template["inter_separator"])
+
+            for sample_i in tqdm(samples):
+                input_text, label = sample_i["sentence"], sample_i["label_text"]
+                input_ids, attention_mask, input_type_mask = self.preprocess_sentence(input_text, label)
+
+                self.input_ids.append(input_ids)
+                self.attention_mask.append(attention_mask)
+                self.input_type_mask.append(input_type_mask)
+
+        def _get_input_ids(self, text):
+            return self.tokenizer(text, add_special_tokens=False)["input_ids"]
+
+        def preprocess_sentence(self, input_text, label):
+            input_template_part_1_text, input_template_part_2_text = self.template["input"].split("{}")
+            input_template_tokenized_part1 = self._get_input_ids(input_template_part_1_text)
+            input_tokenized = self._get_input_ids(input_text)
+            input_template_tokenized_part2 = self._get_input_ids(input_template_part_2_text)
+
+            sep_tokenized = self._get_input_ids(self.template["intra_separator"])
+
+            label_template_part_1, label_template_part_2 = self.template["output"].split("{}")
+            label_template_part1_tokenized = self._get_input_ids(label_template_part_1)
+            label_tokenized = self._get_input_ids(label)
+            label_template_part2_tokenized = self._get_input_ids(label_template_part_2)
+
+            eos = [self.tokenizer.eos_token_id] if self.tokenizer.eos_token_id is not None else []
+            input_ids = (
+                input_template_tokenized_part1
+                + input_tokenized
+                + input_template_tokenized_part2
+                + sep_tokenized
+                + label_template_part1_tokenized
+                + label_tokenized
+                + label_template_part2_tokenized
+                + eos
+            )
+
+            # determine label tokens, to calculate loss only over them when labels_loss == True
+            attention_mask = [1] * len(input_ids)
+            input_type_mask = (
+                [1] * len(input_template_tokenized_part1)
+                + [2] * len(input_tokenized)
+                + [1] * len(input_template_tokenized_part2)
+                + [0] * len(sep_tokenized)
+                + [3] * len(label_template_part1_tokenized)
+                + [4] * len(label_tokenized)
+                + [3] * len(label_template_part2_tokenized)
+                + [0] * len(eos)
+            )
+
+            assert len(input_type_mask) == len(input_ids) == len(attention_mask)
+
+            return input_ids, attention_mask, input_type_mask
+
+        def __len__(self):
+            return len(self.input_ids)
+
+        def __getitem__(self, idx):
+            return {
+                "input_ids": self.input_ids[idx],
+                "attention_mask": self.attention_mask[idx],
+                "input_type_mask": self.input_type_mask[idx],
+            }
+
+    dataset = CPTDataset(data, tokenizer, TEMPLATE)
+
+    return dataset
+
+
+def test_model_initialization_text(global_tokenizer, config_text):
+    """Test model loading and PEFT model initialization."""
+    base_model = AutoModelForCausalLM.from_pretrained(MODEL_NAME)
+
+    model = get_peft_model(base_model, config_text)
+    assert model is not None, "PEFT model initialization failed"
+
+
+def test_model_initialization_random(global_tokenizer, config_random):
+    """Test model loading and PEFT model initialization."""
+    base_model = AutoModelForCausalLM.from_pretrained(MODEL_NAME)
+
+    model = get_peft_model(base_model, config_random)
+    assert model is not None, "PEFT model initialization failed"
+
+
+def test_model_initialization_wrong_task_type_raises():
+    msg = "CPTConfig only supports task_type = CAUSAL_LM."
+    with pytest.raises(ValueError, match=msg):
+        CPTConfig(task_type=TaskType.SEQ_CLS)
+
+    msg = "CPTConfig only supports task_type = CAUSAL_LM."
+    with pytest.raises(ValueError, match=msg):
+        CPTConfig()
+
+
+def test_model_training_random(sst_data, global_tokenizer, collator, config_random):
+    """Perform a short training run to verify the model and data integration."""
+
+    base_model = AutoModelForCausalLM.from_pretrained(MODEL_NAME)
+    model = get_peft_model(base_model, config_random)
+    emb = model.prompt_encoder.default.embedding.weight.data.clone().detach()
+    training_args = TrainingArguments(
+        output_dir="./results",
+        per_device_train_batch_size=1,
+        num_train_epochs=2,
+        remove_unused_columns=False,
+        save_strategy="no",
+        logging_steps=1,
+    )
+
+    train_dataset = dataset(sst_data["train"], global_tokenizer)
+
+    trainer = Trainer(model=model, args=training_args, train_dataset=train_dataset, data_collator=collator)
+
+    trainer.train()
+    # Verify that the embedding tensor remains unchanged (frozen)
+    assert torch.all(model.prompt_encoder.default.embedding.weight.data.clone().detach().cpu() == emb.cpu())
+
+    delta_emb = model.prompt_encoder.default.get_projection().clone().detach()
+    norm_delta = delta_emb.norm(dim=1).cpu()
+    epsilon = model.prompt_encoder.default.get_epsilon().cpu()
+    # Verify that the change in tokens is constrained to epsilon
+    assert torch.all(norm_delta <= epsilon)
+
+
+def test_model_batch_training_text(sst_data, global_tokenizer, collator, config_text):
+    """Perform a short training run to verify the model and data integration."""
+
+    base_model = AutoModelForCausalLM.from_pretrained(MODEL_NAME)
+    model = get_peft_model(base_model, config_text)
+    emb = model.prompt_encoder.default.embedding.weight.data.clone().detach()
+
+    training_args = TrainingArguments(
+        output_dir="./results",
+        per_device_train_batch_size=2,
+        num_train_epochs=2,
+        remove_unused_columns=False,
+        save_strategy="no",
+        logging_steps=1,
+    )
+
+    train_dataset = dataset(sst_data["train"], global_tokenizer)
+
+    trainer = Trainer(model=model, args=training_args, train_dataset=train_dataset, data_collator=collator)
+
+    trainer.train()
+    # Verify that the embedding tensor remains unchanged (frozen)
+    assert torch.all(model.prompt_encoder.default.embedding.weight.data.clone().detach().cpu() == emb.cpu())
+
+    cpt_tokens_type_mask = torch.Tensor(config_text.cpt_tokens_type_mask).long()
+    non_label_idx = (cpt_tokens_type_mask == 1) | (cpt_tokens_type_mask == 2) | (cpt_tokens_type_mask == 3)
+
+    delta_emb = model.prompt_encoder.default.get_projection().clone().detach()
+    norm_delta = delta_emb.norm(dim=1).cpu()
+    epsilon = model.prompt_encoder.default.get_epsilon().cpu()
+    # Verify that the change in tokens is constrained to epsilon
+    assert torch.all(norm_delta <= epsilon)
+    # Ensure that label tokens remain unchanged
+    assert torch.all((norm_delta == 0) == (~non_label_idx))
diff --git a/tests/test_custom_models.py b/tests/test_custom_models.py
new file mode 100644
index 0000000..a7091a1
--- /dev/null
+++ b/tests/test_custom_models.py
@@ -0,0 +1,7391 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+import copy
+import os
+import platform
+import re
+import shutil
+import tempfile
+import time
+from contextlib import contextmanager
+from functools import partial
+from unittest.mock import MagicMock
+
+import pytest
+import torch
+from safetensors.torch import load_file as safe_load_file
+from torch import nn
+from transformers import AutoModelForCausalLM, AutoModelForSequenceClassification
+from transformers.pytorch_utils import Conv1D
+
+from peft import (
+    AdaLoraConfig,
+    AdamssConfig,
+    BeftConfig,
+    BOFTConfig,
+    C3AConfig,
+    DeftConfig,
+    DeloraConfig,
+    FourierFTConfig,
+    FrodConfig,
+    GloraConfig,
+    GraloraConfig,
+    HiraConfig,
+    HRAConfig,
+    IA3Config,
+    LilyConfig,
+    LNTuningConfig,
+    LoHaConfig,
+    LoKrConfig,
+    LoraConfig,
+    MissConfig,
+    MontecloraConfig,
+    OFTConfig,
+    OSFConfig,
+    PeanutConfig,
+    PeftModel,
+    PeftWarning,
+    PsoftConfig,
+    PveraConfig,
+    RandLoraConfig,
+    RoadConfig,
+    ShiraConfig,
+    TaskType,
+    TinyLoraConfig,
+    TrainableTokensConfig,
+    UniLoraConfig,
+    VBLoRAConfig,
+    VeloraConfig,
+    VeraConfig,
+    WaveFTConfig,
+    get_peft_model,
+)
+from peft.tuners import lora
+from peft.tuners.lora.config import BdLoraConfig
+from peft.tuners.lora.monteclora import MontecloraSampler
+from peft.tuners.tuners_utils import BaseTunerLayer
+from peft.utils import AuxiliaryTrainingWrapper, infer_device
+
+from .testing_common import PeftCommonTester, _skip_if_merging_not_supported
+from .testing_utils import get_state_dict, require_non_cpu, set_init_weights_false
+
+
+def _zero_unilora_theta_d(model, adapter_name="default"):
+    torch.nn.init.zeros_(model.unilora_theta_d[adapter_name])
+
+
+def _reset_unilora_theta_d(model, config, adapter_name="default"):
+    theta_d = model.unilora_theta_d[adapter_name]
+    if config.init_weights:
+        torch.nn.init.uniform_(theta_d, -config.init_theta_d_bound, config.init_theta_d_bound)
+    else:
+        torch.nn.init.normal_(theta_d)
+
+
+# MLP is a vanilla FF network with only linear layers
+# EmbConv1D has an embedding and a Conv1D layer
+# Conv2D has a Conv2D layer
+TEST_CASES = [
+    ########
+    # GLoRA #
+    ########
+    ("Vanilla MLP 1 GLoRA", "MLP", GloraConfig, {"target_modules": "lin0"}),
+    ("Vanilla MLP 2 GLoRA", "MLP", GloraConfig, {"target_modules": ["lin0"]}),
+    ("Vanilla MLP 3 GLoRA", "MLP", GloraConfig, {"target_modules": ["lin1"]}),
+    ("Vanilla MLP 4 GLoRA", "MLP", GloraConfig, {"target_modules": ["lin0", "lin1"]}),
+    (
+        "Vanilla MLP 5 GLoRA",
+        "MLP",
+        GloraConfig,
+        {"target_modules": ["lin0"], "modules_to_save": ["lin1"]},
+    ),
+    (
+        "Vanilla MLP 6 GLoRA",
+        "MLP",
+        GloraConfig,
+        {"target_modules": ["lin0", "lin1"], "modules_to_save": ["lin1"]},
+    ),
+    ########
+    # LoRA #
+    ########
+    ("Vanilla MLP 1 LoRA", "MLP", LoraConfig, {"target_modules": "lin0"}),
+    ("Vanilla MLP 2 LoRA", "MLP", LoraConfig, {"target_modules": ["lin0"]}),
+    ("Vanilla MLP 3 LoRA", "MLP", LoraConfig, {"target_modules": ["lin1"]}),
+    ("Vanilla MLP 4 LoRA", "MLP", LoraConfig, {"target_modules": ["lin0", "lin1"]}),
+    ("Vanilla MLP 5 LoRA", "MLP", LoraConfig, {"target_modules": ["lin0"], "modules_to_save": ["lin1"]}),
+    (
+        "Vanilla MLP 6 LoRA",
+        "MLP",
+        LoraConfig,
+        {
+            "target_modules": ["lin0"],
+            "lora_alpha": 4,
+            "lora_dropout": 0.1,
+        },
+    ),
+    ("Vanilla MLP 7 LoRA with DoRA", "MLP", LoraConfig, {"target_modules": ["lin0"], "use_dora": True}),
+    ("Vanilla MLP 8 LoRA with DoRA", "MLP", LoraConfig, {"target_modules": ["lin0", "lin1"], "use_dora": True}),
+    (
+        "Vanilla MLP 1 LoRA with MiCA",
+        "MLP",
+        LoraConfig,
+        {"target_modules": ["lin0"], "init_lora_weights": "mica", "r": 4},
+    ),
+    (
+        "Vanilla MLP 9 LoRA with DoRA",
+        "MLP",
+        LoraConfig,
+        {"target_modules": "lin1", "use_dora": True, "lora_alpha": 32},
+    ),
+    (
+        "Vanilla MLP 10 LoRA with VeLoRA random",
+        "MLP",
+        LoraConfig,
+        {"target_modules": ["lin0"], "velora_config": VeloraConfig(num_groups=2, init_type="random")},
+    ),
+    (
+        "Vanilla MLP 11 LoRA with VeLoRA batch_average",
+        "MLP",
+        LoraConfig,
+        {
+            "target_modules": ["lin0", "lin1"],
+            "velora_config": VeloraConfig(num_groups=2, init_type="batch_average"),
+        },
+    ),
+    (
+        "Vanilla MLP 12 LoRA with VeLoRA batch_average_once",
+        "MLP",
+        LoraConfig,
+        {"target_modules": ["lin0"], "velora_config": VeloraConfig(num_groups=2, init_type="batch_average_once")},
+    ),
+    ("Embedding + transformers Conv1D 1 LoRA", "EmbConv1D", LoraConfig, {"target_modules": ["conv1d"]}),
+    ("Embedding + transformers Conv1D 2 LoRA", "EmbConv1D", LoraConfig, {"target_modules": ["emb"]}),
+    ("Embedding + transformers Conv1D 3 LoRA", "EmbConv1D", LoraConfig, {"target_modules": ["emb", "conv1d"]}),
+    (
+        "Embedding + transformers Conv1D 1 DoRA",
+        "EmbConv1D",
+        LoraConfig,
+        {"target_modules": ["conv1d"], "use_dora": True},
+    ),
+    ("Embedding + transformers Conv1D 2 DoRA", "EmbConv1D", LoraConfig, {"target_modules": ["emb"], "use_dora": True}),
+    (
+        "Embedding + transformers Conv1D 3 DoRA",
+        "EmbConv1D",
+        LoraConfig,
+        {"target_modules": ["emb", "conv1d"], "use_dora": True},
+    ),
+    (
+        "Embedding + transformers Conv1D 1 LoRA trainable_tokens",
+        "EmbConv1D",
+        LoraConfig,
+        {"target_modules": ["conv1d"], "trainable_token_indices": {"emb": [0, 10]}},
+    ),
+    ("Conv1d LoRA", "Conv1d", LoraConfig, {"target_modules": ["conv1d"]}),
+    ("Conv1d LoRA with DoRA", "Conv1d", LoraConfig, {"target_modules": ["conv1d"], "use_dora": True}),
+    ("Conv2d 1 LoRA", "Conv2d", LoraConfig, {"target_modules": ["conv2d"]}),
+    ("Conv2d 2 LoRA", "Conv2d", LoraConfig, {"target_modules": ["conv2d", "lin0"]}),
+    ("Conv2d 1 LoRA with DoRA", "Conv2d", LoraConfig, {"target_modules": ["conv2d"], "use_dora": True}),
+    ("Conv2d 2 LoRA with DoRA", "Conv2d", LoraConfig, {"target_modules": ["conv2d", "lin0"], "use_dora": True}),
+    ("Conv2d Groups LoRA", "Conv2dGroups", LoraConfig, {"target_modules": ["conv2d"]}),
+    ("Conv2d Groups2 LoRA", "Conv2dGroups2", LoraConfig, {"target_modules": ["conv2d"]}),
+    ("Conv2d Groups LoRA with DoRA", "Conv2dGroups", LoraConfig, {"target_modules": ["conv2d"], "use_dora": True}),
+    ("Conv2d Groups2 LoRA with DoRA", "Conv2dGroups2", LoraConfig, {"target_modules": ["conv2d"], "use_dora": True}),
+    ("Conv3d 1 LoRA", "Conv3d", LoraConfig, {"target_modules": ["conv3d"]}),
+    ("Conv3d 2 LoRA", "Conv3d", LoraConfig, {"target_modules": ["conv3d", "lin0"]}),
+    ("Conv3d 1 LoRA with DoRA", "Conv3d", LoraConfig, {"target_modules": ["conv3d"], "use_dora": True}),
+    ("Conv3d 2 LoRA with DoRA", "Conv3d", LoraConfig, {"target_modules": ["conv3d", "lin0"], "use_dora": True}),
+    # LoRA with lora_B bias enabled (note: embedding is not supported)
+    # It's important to set lora_alpha != r to ensure that scaling is taken into account correctly
+    (
+        "Vanilla MLP 1 LoRA with lora_b bias",
+        "MLP",
+        LoraConfig,
+        {"target_modules": ["lin0", "lin1"], "lora_bias": True, "lora_alpha": 32},
+    ),
+    (
+        "Conv2d 1 LoRA with lora_b bias",
+        "Conv2d",
+        LoraConfig,
+        {"target_modules": ["conv2d"], "lora_bias": True, "lora_alpha": 32},
+    ),
+    (
+        "Conv3d 1 LoRA with lora_b bias",
+        "Conv3d",
+        LoraConfig,
+        {"target_modules": ["conv3d"], "lora_bias": True, "lora_alpha": 32},
+    ),
+    ("MHA 1 LoRA", "MHA", LoraConfig, {"target_modules": ["mha"]}),
+    ("MHA 2 LoRA", "MHA", LoraConfig, {"target_modules": ["mha", "lin0"]}),
+    # targeting parameters directly
+    ("MLP 1 using nn.Parameter LoRA", "MlpUsingParameters", LoraConfig, {"target_parameters": ["lin0.weight"]}),
+    (
+        "MLP 2 using nn.Parameter LoRA",
+        "MLP",
+        LoraConfig,
+        {"target_modules": ["lin0"], "target_parameters": ["lin1.weight"]},
+    ),
+    #############
+    # MonteCLoRA #
+    #############
+    (
+        "Vanilla MLP 1 LoRA with Monteclora",
+        "MLP",
+        LoraConfig,
+        {
+            "target_modules": ["lin0"],
+            "monteclora_config": MontecloraConfig(num_samples=2),
+        },
+    ),
+    #######
+    # IA³ #
+    #######
+    ("Vanilla MLP 1 IA3", "MLP", IA3Config, {"target_modules": "lin0", "feedforward_modules": []}),
+    ("Vanilla MLP 2 IA3", "MLP", IA3Config, {"target_modules": "lin0", "feedforward_modules": "lin0"}),
+    ("Vanilla MLP 3 IA3", "MLP", IA3Config, {"target_modules": ["lin0"], "feedforward_modules": []}),
+    ("Vanilla MLP 4 IA3", "MLP", IA3Config, {"target_modules": ["lin0"], "feedforward_modules": ["lin0"]}),
+    ("Vanilla MLP 5 IA3", "MLP", IA3Config, {"target_modules": ["lin1"], "feedforward_modules": []}),
+    ("Vanilla MLP 6 IA3", "MLP", IA3Config, {"target_modules": ["lin1"], "feedforward_modules": ["lin1"]}),
+    (
+        "Vanilla MLP 7 IA3",
+        "MLP",
+        IA3Config,
+        {"target_modules": ["lin0", "lin1"], "feedforward_modules": []},
+    ),
+    (
+        "Vanilla MLP 8 IA3",
+        "MLP",
+        IA3Config,
+        {"target_modules": ["lin0", "lin1"], "feedforward_modules": ["lin0", "lin1"]},
+    ),
+    (
+        "Vanilla MLP 9 IA3",
+        "MLP",
+        IA3Config,
+        {"target_modules": ["lin0"], "modules_to_save": ["lin1"], "feedforward_modules": ["lin0"]},
+    ),
+    (
+        "transformers Conv1D 1 IA3",
+        "EmbConv1D",
+        IA3Config,
+        {"target_modules": ["conv1d"], "feedforward_modules": ["conv1d"]},
+    ),
+    (
+        "transformers Conv1D 2 IA3",
+        "EmbConv1D",
+        IA3Config,
+        {"target_modules": ["conv1d", "lin0"], "feedforward_modules": ["conv1d", "lin0"]},
+    ),
+    (
+        "transformers Conv1D 1 IA3",
+        "EmbConv1D",
+        IA3Config,
+        {"target_modules": ["conv1d"], "feedforward_modules": ["conv1d"], "modules_to_save": ["lin0"]},
+    ),
+    ("Conv2d 1 IA3", "Conv2d", IA3Config, {"target_modules": ["conv2d"], "feedforward_modules": []}),
+    ("Conv2d 2 IA3", "Conv2d", IA3Config, {"target_modules": ["conv2d"], "feedforward_modules": ["conv2d"]}),
+    (
+        "Conv2d 3 IA3",
+        "Conv2d",
+        IA3Config,
+        {"target_modules": ["conv2d", "lin0"], "feedforward_modules": []},
+    ),
+    (
+        "Conv2d 4 IA3",
+        "Conv2d",
+        IA3Config,
+        {"target_modules": ["conv2d", "lin0"], "feedforward_modules": ["conv2d"]},
+    ),
+    (
+        "Conv2d 5 IA3",
+        "Conv2d",
+        IA3Config,
+        {"target_modules": ["conv2d", "lin0"], "feedforward_modules": ["conv2d", "lin0"]},
+    ),
+    ("Conv3d 1 IA3", "Conv3d", IA3Config, {"target_modules": ["conv3d"], "feedforward_modules": []}),
+    ("Conv3d 2 IA3", "Conv3d", IA3Config, {"target_modules": ["conv3d"], "feedforward_modules": ["conv3d"]}),
+    (
+        "Conv3d 3 IA3",
+        "Conv3d",
+        IA3Config,
+        {"target_modules": ["conv3d", "lin0"], "feedforward_modules": []},
+    ),
+    (
+        "Conv3d 4 IA3",
+        "Conv3d",
+        IA3Config,
+        {"target_modules": ["conv3d", "lin0"], "feedforward_modules": ["conv3d"]},
+    ),
+    (
+        "Conv3d 5 IA3",
+        "Conv3d",
+        IA3Config,
+        {"target_modules": ["conv3d", "lin0"], "feedforward_modules": ["conv3d", "lin0"]},
+    ),
+    ########
+    # BEFT #
+    ########
+    ("Vanilla MLP 1 BEFT", "MLP", BeftConfig, {"target_modules": "lin0"}),
+    ("Vanilla MLP 2 BEFT", "MLP", BeftConfig, {"target_modules": ["lin0"]}),
+    ("Vanilla MLP 3 BEFT", "MLP", BeftConfig, {"target_modules": ["lin1"]}),
+    (
+        "Vanilla MLP 4 BEFT",
+        "MLP",
+        BeftConfig,
+        {"target_modules": ["lin0", "lin1"]},
+    ),
+    (
+        "Vanilla MLP 5 BEFT",
+        "MLP",
+        BeftConfig,
+        {"target_modules": ["lin0"], "modules_to_save": ["lin1"]},
+    ),
+    ########
+    # LoHa #
+    ########
+    ("Vanilla MLP 1 LOHA", "MLP", LoHaConfig, {"target_modules": "lin0"}),
+    ("Vanilla MLP 2 LOHA", "MLP", LoHaConfig, {"target_modules": ["lin0"]}),
+    ("Vanilla MLP 3 LOHA", "MLP", LoHaConfig, {"target_modules": ["lin1"]}),
+    ("Vanilla MLP 4 LOHA", "MLP", LoHaConfig, {"target_modules": ["lin0", "lin1"]}),
+    ("Vanilla MLP 5 LOHA", "MLP", LoHaConfig, {"target_modules": ["lin0"], "modules_to_save": ["lin1"]}),
+    (
+        "Vanilla MLP 6 LOHA",
+        "MLP",
+        LoHaConfig,
+        {
+            "target_modules": ["lin0"],
+            "alpha": 4,
+            "module_dropout": 0.1,
+        },
+    ),
+    ("Vanilla MLP 7 LOHA", "MLP", LoHaConfig, {"target_modules": "lin0", "rank_dropout": 0.5}),
+    ("Conv2d 1 LOHA", "Conv2d", LoHaConfig, {"target_modules": ["conv2d"]}),
+    ("Conv2d 2 LOHA", "Conv2d", LoHaConfig, {"target_modules": ["conv2d", "lin0"]}),
+    ("Conv2d 3 LOHA", "Conv2d", LoHaConfig, {"target_modules": ["conv2d"], "use_effective_conv2d": True}),
+    ("Conv2d 4 LOHA", "Conv2d", LoHaConfig, {"target_modules": ["conv2d", "lin0"], "use_effective_conv2d": True}),
+    ("Conv1d LOHA", "Conv1d", LoHaConfig, {"target_modules": ["conv1d"]}),
+    ("Conv1d LOHA 1", "Conv1d", LoHaConfig, {"target_modules": ["conv1d"]}),
+    ("Conv1d LOHA 2", "Conv1d", LoHaConfig, {"target_modules": ["conv1d"], "r": 2}),
+    (
+        "Conv1d LOHA 3",
+        "Conv1dBigger",
+        LoHaConfig,
+        {"target_modules": ["conv1d"], "r": 2, "use_effective_conv2d": True},
+    ),
+    (
+        "Conv1d LOHA 4",
+        "Conv1dBigger",
+        LoHaConfig,
+        {"target_modules": ["conv1d"], "r": 2, "use_effective_conv2d": False},
+    ),
+    ("Conv2d 1x1 LOHA", "Conv2d1x1", LoHaConfig, {"target_modules": ["conv2d"]}),
+    # LoKr
+    ("Vanilla MLP 1 LOKR", "MLP", LoKrConfig, {"target_modules": "lin0"}),
+    ("Vanilla MLP 2 LOKR", "MLP", LoKrConfig, {"target_modules": ["lin0"]}),
+    ("Vanilla MLP 3 LOKR", "MLP", LoKrConfig, {"target_modules": ["lin1"]}),
+    ("Vanilla MLP 4 LOKR", "MLP", LoKrConfig, {"target_modules": ["lin0", "lin1"]}),
+    ("Vanilla MLP 5 LOKR", "MLP", LoKrConfig, {"target_modules": ["lin0"], "modules_to_save": ["lin1"]}),
+    (
+        "Vanilla MLP 6 LOKR",
+        "MLP",
+        LoKrConfig,
+        {
+            "target_modules": ["lin0"],
+            "alpha": 4,
+            "module_dropout": 0.1,
+        },
+    ),
+    ("Vanilla MLP 7 LOKR", "MLP", LoKrConfig, {"target_modules": "lin0", "rank_dropout": 0.5}),
+    ("Vanilla MLP 8 LOKR", "MLP", LoKrConfig, {"target_modules": "lin0", "decompose_both": True, "r": 1, "alpha": 1}),
+    ("Conv1d LOKR 1", "Conv1d", LoKrConfig, {"target_modules": ["conv1d"]}),
+    ("Conv1d LOKR 2", "Conv1d", LoKrConfig, {"target_modules": ["conv1d"], "r": 2}),
+    (
+        "Conv1d LOKR 3",
+        "Conv1dBigger",
+        LoKrConfig,
+        {"target_modules": ["conv1d"], "r": 2, "use_effective_conv2d": True},
+    ),
+    (
+        "Conv1d LOKR 4",
+        "Conv1dBigger",
+        LoKrConfig,
+        {"target_modules": ["conv1d"], "r": 2, "use_effective_conv2d": False},
+    ),
+    ("Conv2d 1 LOKR", "Conv2d", LoKrConfig, {"target_modules": ["conv2d"]}),
+    ("Conv2d 2 LOKR", "Conv2d", LoKrConfig, {"target_modules": ["conv2d", "lin0"]}),
+    ("Conv2d 3 LOKR", "Conv2d", LoKrConfig, {"target_modules": ["conv2d"], "use_effective_conv2d": True}),
+    ("Conv2d 4 LOKR", "Conv2d", LoKrConfig, {"target_modules": ["conv2d", "lin0"], "use_effective_conv2d": True}),
+    ("Conv2d 1x1 LOKR", "Conv2d1x1", LoKrConfig, {"target_modules": ["conv2d"]}),
+    (
+        "Conv2d 5 LOKR",
+        "Conv2d",
+        LoKrConfig,
+        {"target_modules": ["conv2d", "lin0"], "use_effective_conv2d": True, "decompose_both": True},
+    ),
+    (
+        "Conv2d 6 LOKR",
+        "Conv2d",
+        LoKrConfig,
+        {"target_modules": ["conv2d", "lin0"], "use_effective_conv2d": True, "decompose_factor": 4},
+    ),
+    (
+        "Conv2d 7 LOKR",
+        "Conv2d",
+        LoKrConfig,
+        {
+            "target_modules": ["conv2d", "lin0"],
+            "use_effective_conv2d": True,
+            "decompose_both": True,
+            "decompose_factor": 4,
+        },
+    ),
+    ########
+    # OFT #
+    ########
+    (
+        "Vanilla MLP 1 OFT",
+        "MLP",
+        OFTConfig,
+        {"r": 2, "oft_block_size": 0, "target_modules": "lin0", "use_cayley_neumann": False},
+    ),
+    (
+        "Vanilla MLP 2 OFT",
+        "MLP",
+        OFTConfig,
+        {"r": 2, "oft_block_size": 0, "target_modules": ["lin0"], "use_cayley_neumann": False},
+    ),
+    (
+        "Vanilla MLP 5 OFT",
+        "MLP",
+        OFTConfig,
+        {
+            "r": 2,
+            "oft_block_size": 0,
+            "target_modules": ["lin0"],
+            "modules_to_save": ["lin1"],
+            "use_cayley_neumann": False,
+        },
+    ),
+    (
+        "Vanilla MLP 6 OFT",
+        "MLP",
+        OFTConfig,
+        {
+            "r": 2,
+            "oft_block_size": 0,
+            "target_modules": ["lin0"],
+            "module_dropout": 0.1,
+            "use_cayley_neumann": False,
+        },
+    ),
+    (
+        "Vanilla MLP 7 OFT",
+        "MLP",
+        OFTConfig,
+        {"r": 2, "oft_block_size": 0, "target_modules": ["lin0"], "coft": True, "eps": 1e-2},
+    ),
+    (
+        "Vanilla MLP 8 OFT",
+        "MLP",
+        OFTConfig,
+        {"r": 2, "oft_block_size": 0, "target_modules": ["lin0"], "block_share": True, "use_cayley_neumann": False},
+    ),
+    (
+        "Vanilla MLP 9 OFT",
+        "MLP",
+        OFTConfig,
+        {"r": 2, "oft_block_size": 0, "target_modules": ["lin0"], "coft": True, "eps": 1e-2, "block_share": True},
+    ),
+    (
+        "Vanilla MLP 10 OFT",
+        "MLP",
+        OFTConfig,
+        {"r": 0, "oft_block_size": 2, "target_modules": ["lin0"], "use_cayley_neumann": True},
+    ),
+    (
+        "Vanilla MLP 11 OFT",
+        "MLP",
+        OFTConfig,
+        {"r": 0, "oft_block_size": 2, "target_modules": ["lin0"], "use_cayley_neumann": False},
+    ),
+    (
+        "Vanilla MLP 12 OFT",
+        "MLP",
+        OFTConfig,
+        {
+            "r": 0,
+            "oft_block_size": 2,
+            "target_modules": ["lin0"],
+            "coft": True,
+            "eps": 1e-2,
+            "block_share": True,
+            "use_cayley_neumann": True,
+        },
+    ),
+    (
+        "Vanilla MLP 13 OFT",
+        "MLP",
+        OFTConfig,
+        {
+            "r": 0,
+            "oft_block_size": 2,
+            "target_modules": ["lin0"],
+            "coft": True,
+            "eps": 1e-2,
+            "block_share": True,
+            "use_cayley_neumann": False,
+        },
+    ),
+    (
+        "Embedding + transformers Conv1D 1 OFT",
+        "EmbConv1D",
+        OFTConfig,
+        {"r": 1, "oft_block_size": 0, "target_modules": ["emb"]},
+    ),
+    (
+        "Embedding + transformers Conv1D 2 OFT",
+        "EmbConv1D",
+        OFTConfig,
+        {"r": 1, "oft_block_size": 0, "target_modules": ["emb"], "block_share": True},
+    ),
+    ("Conv2d 1 OFT", "Conv2d", OFTConfig, {"r": 5, "oft_block_size": 0, "target_modules": ["conv2d"]}),
+    ("Conv2d 3 OFT", "Conv2d", OFTConfig, {"r": 5, "oft_block_size": 0, "target_modules": ["conv2d"], "coft": True}),
+    (
+        "Conv2d 4 OFT",
+        "Conv2d",
+        OFTConfig,
+        {"r": 5, "oft_block_size": 0, "target_modules": ["conv2d"], "block_share": True},
+    ),
+    (
+        "Conv2d 5 OFT",
+        "Conv2d",
+        OFTConfig,
+        {"r": 5, "oft_block_size": 0, "target_modules": ["conv2d"], "coft": True, "block_share": True},
+    ),
+    #########
+    # DEFT #
+    #########
+    ("Vanilla MLP 1 DEFT", "MLP", DeftConfig, {"target_modules": "lin0"}),
+    ("Vanilla MLP 2 DEFT", "MLP", DeftConfig, {"target_modules": ["lin0"]}),
+    ("Vanilla MLP 3 DEFT", "MLP", DeftConfig, {"target_modules": ["lin0", "lin1"]}),
+    ("Vanilla MLP 4 DEFT qr", "MLP", DeftConfig, {"target_modules": ["lin0"], "decomposition_method": "qr"}),
+    ("Vanilla MLP 5 DEFT", "MLP", DeftConfig, {"target_modules": ["lin0"], "modules_to_save": ["lin1"]}),
+    (
+        "Vanilla MLP 7 DEFT alpha",
+        "MLP",
+        DeftConfig,
+        {"target_modules": ["lin0"], "decomposition_method": "qr", "alpha": 16},
+    ),
+    (
+        "Vanilla MLP 8 DEFT PaRa relu",
+        "MLP",
+        DeftConfig,
+        {"target_modules": ["lin0"], "decomposition_method": "relu", "para": True},
+    ),
+    (
+        "Vanilla MLP 9 DEFT PaRa qr",
+        "MLP",
+        DeftConfig,
+        {"target_modules": ["lin0"], "decomposition_method": "qr", "para": True},
+    ),
+    ("Embedding + transformers Conv1D 1 DEFT", "EmbConv1D", DeftConfig, {"target_modules": ["conv1d"]}),
+    ########
+    # HRA #
+    ########
+    ("Vanilla MLP 1 HRA", "MLP", HRAConfig, {"target_modules": "lin0"}),
+    ("Vanilla MLP 2 HRA", "MLP", HRAConfig, {"target_modules": ["lin0"]}),
+    ("Vanilla MLP 3 HRA", "MLP", HRAConfig, {"target_modules": ["lin0", "lin1"]}),
+    ("Vanilla MLP 5 HRA", "MLP", HRAConfig, {"target_modules": ["lin0"], "modules_to_save": ["lin1"]}),
+    ("Conv2d 1 HRA", "Conv2d", HRAConfig, {"target_modules": ["conv2d"]}),
+    ########
+    # MiSS #
+    ########
+    ("Vanilla MLP 1 MiSS", "MLP", MissConfig, {"target_modules": "lin0", "r": 2}),
+    ("Vanilla MLP 2 MiSS", "MLP", MissConfig, {"target_modules": ["lin0"], "r": 2}),
+    ("Vanilla MLP 3 MiSS", "MLP", MissConfig, {"target_modules": ["lin0", "lin1"], "r": 2}),
+    ("Vanilla MLP 5 MiSS", "MLP", MissConfig, {"target_modules": ["lin0"], "modules_to_save": ["lin1"], "r": 2}),
+    ("Vanilla MLP 1 MiSS", "MLP", MissConfig, {"target_modules": "lin0", "r": 2, "init_weights": "bat"}),
+    ("Vanilla MLP 2 MiSS", "MLP", MissConfig, {"target_modules": ["lin0"], "r": 2, "init_weights": "bat"}),
+    ("Vanilla MLP 3 MiSS", "MLP", MissConfig, {"target_modules": ["lin0", "lin1"], "r": 2, "init_weights": "bat"}),
+    (
+        "Vanilla MLP 5 MiSS",
+        "MLP",
+        MissConfig,
+        {"target_modules": ["lin0"], "modules_to_save": ["lin1"], "r": 2, "init_weights": "bat"},
+    ),
+    #############
+    # LN Tuning #
+    #############
+    ("LayerNorm 1 LNTuning", "MLP_LayerNorm", LNTuningConfig, {"target_modules": "layernorm0"}),
+    ("LayerNorm 2 LNTuning", "MLP_LayerNorm", LNTuningConfig, {"target_modules": ["layernorm0"]}),
+    (
+        "LayerNorm 3 LNTuning",
+        "MLP_LayerNorm",
+        LNTuningConfig,
+        {"target_modules": ["layernorm0"], "modules_to_save": ["layernorm1"]},
+    ),
+    ("Linear 4 LNTuning", "MLP_LayerNorm", LNTuningConfig, {"target_modules": "lin0"}),
+    ("Linear 5 LNTuning", "MLP_LayerNorm", LNTuningConfig, {"target_modules": ["lin0"]}),
+    ########
+    # BOFT #
+    ########
+    ("Vanilla MLP 1 BOFT", "MLP", BOFTConfig, {"target_modules": ["lin1"], "boft_block_size": 2}),
+    (
+        "Vanilla MLP 2 BOFT",
+        "MLP",
+        BOFTConfig,
+        {"target_modules": ["lin1"], "modules_to_save": ["lin0"], "boft_block_size": 2},
+    ),
+    (
+        "Vanilla MLP 3 BOFT",
+        "MLP",
+        BOFTConfig,
+        {
+            "target_modules": ["lin1"],
+            "boft_block_size": 2,
+            "boft_dropout": 0.1,
+        },
+    ),
+    (
+        "Vanilla MLP 4 BOFT",
+        "MLP",
+        BOFTConfig,
+        {"target_modules": ["lin1"], "boft_block_size": 2, "boft_block_num": 0, "boft_n_butterfly_factor": 1},
+    ),
+    (
+        "Vanilla MLP 5 BOFT",
+        "MLP",
+        BOFTConfig,
+        {"target_modules": ["lin1"], "boft_block_size": 0, "boft_block_num": 2, "boft_n_butterfly_factor": 1},
+    ),
+    (
+        "Vanilla MLP 6 BOFT",
+        "MLP",
+        BOFTConfig,
+        {"target_modules": ["lin1"], "boft_block_size": 10, "boft_block_num": 0, "boft_n_butterfly_factor": 2},
+    ),
+    (
+        "Conv2d 1 BOFT",
+        "Conv2d",
+        BOFTConfig,
+        {"target_modules": ["conv2d"], "boft_block_size": 45, "boft_block_num": 0, "boft_n_butterfly_factor": 1},
+    ),
+    (
+        "Conv2d 2 BOFT",
+        "Conv2d",
+        BOFTConfig,
+        {"target_modules": ["conv2d"], "boft_block_size": 0, "boft_block_num": 1, "boft_n_butterfly_factor": 1},
+    ),
+    (
+        "MLP2 1 BOFT",
+        "MLP2",
+        BOFTConfig,
+        {"target_modules": ["lin1"], "boft_block_size": 2, "boft_block_num": 0, "boft_n_butterfly_factor": 3},
+    ),
+    (
+        "MLP2 2 BOFT",
+        "MLP2",
+        BOFTConfig,
+        {"target_modules": ["lin1"], "boft_block_size": 0, "boft_block_num": 8, "boft_n_butterfly_factor": 3},
+    ),
+    (
+        "Conv2d2 1 BOFT",
+        "Conv2d2",
+        BOFTConfig,
+        {"target_modules": ["conv2d"], "boft_block_size": 2, "boft_block_num": 0, "boft_n_butterfly_factor": 2},
+    ),
+    (
+        "Conv2d2 1 BOFT",
+        "Conv2d2",
+        BOFTConfig,
+        {"target_modules": ["conv2d"], "boft_block_size": 2, "boft_block_num": 0, "boft_n_butterfly_factor": 3},
+    ),
+    #########
+    # SHiRA #
+    #########
+    ("Vanilla MLP 1 SHiRA", "MLP", ShiraConfig, {"r": 1, "target_modules": "lin0"}),
+    ("Vanilla MLP 2 SHiRA", "MLP", ShiraConfig, {"r": 1, "target_modules": ["lin0"]}),
+    ("Vanilla MLP 3 SHiRA", "MLP", ShiraConfig, {"r": 1, "target_modules": ["lin1"]}),
+    (
+        "Vanilla MLP 4 SHiRA",
+        "MLP",
+        ShiraConfig,
+        {"r": 1, "target_modules": ["lin0", "lin1"], "random_seed": 56},
+    ),
+    (
+        "Vanilla MLP 5 SHiRA",
+        "MLP",
+        ShiraConfig,
+        {"r": 1, "target_modules": ["lin0"]},
+    ),
+    ########
+    # VeRA #
+    ########
+    ("Vanilla MLP 1 VeRA", "MLP", VeraConfig, {"target_modules": "lin0"}),
+    ("Vanilla MLP 2 VeRA", "MLP", VeraConfig, {"target_modules": ["lin0"]}),
+    ("Vanilla MLP 3 VeRA", "MLP", VeraConfig, {"target_modules": ["lin1"]}),
+    ("Vanilla MLP 4 VeRA", "MLP", VeraConfig, {"target_modules": ["lin0", "lin1"]}),
+    (
+        "Vanilla MLP 5 VeRA",
+        "MLP",
+        VeraConfig,
+        {"target_modules": ["lin0"], "modules_to_save": ["lin1"]},
+    ),
+    (
+        "Embedding + transformers Conv1D 1 VeRA",
+        "EmbConv1D",
+        VeraConfig,
+        {"target_modules": ["conv1d"]},
+    ),
+    ############
+    # TinyLoRA #
+    ############
+    ("Vanilla MLP 1 TinyLoRA", "MLP", TinyLoraConfig, {"target_modules": "lin0", "r": 2, "u": 16}),
+    ("Vanilla MLP 2 TinyLoRA", "MLP", TinyLoraConfig, {"target_modules": ["lin0"], "r": 2, "u": 16}),
+    ("Vanilla MLP 3 TinyLoRA", "MLP", TinyLoraConfig, {"target_modules": ["lin1"], "r": 2, "u": 16}),
+    ("Vanilla MLP 4 TinyLoRA", "MLP", TinyLoraConfig, {"target_modules": ["lin0", "lin1"], "r": 2, "u": 32}),
+    (
+        "Vanilla MLP 5 TinyLoRA",
+        "MLP",
+        TinyLoraConfig,
+        {"target_modules": ["lin0"], "modules_to_save": ["lin1"], "r": 2, "u": 16},
+    ),
+    (
+        "Vanilla MLP TinyLoRA weight_tying",
+        "MLP",
+        TinyLoraConfig,
+        {"target_modules": ["lin0", "lin1"], "r": 2, "u": 8, "weight_tying": 1.0},
+    ),
+    (
+        "Embedding + transformers Conv1D 1 TinyLoRA",
+        "EmbConv1D",
+        TinyLoraConfig,
+        {"target_modules": ["conv1d"], "r": 2, "u": 16, "init_v_bound": 0.5},
+    ),
+    (
+        "Embedding + transformers Conv1D 2 TinyLoRA",
+        "EmbConv1D",
+        TinyLoraConfig,
+        {"target_modules": ["emb"], "r": 2, "u": 16},
+    ),
+    #############
+    #########
+    # PVERA #
+    #########
+    ("Vanilla MLP 1 PVeRA", "MLP", PveraConfig, {"target_modules": "lin0"}),
+    ("Vanilla MLP 2 PVeRA", "MLP", PveraConfig, {"target_modules": ["lin0"]}),
+    ("Vanilla MLP 3 PVeRA", "MLP", PveraConfig, {"target_modules": ["lin1"]}),
+    ("Vanilla MLP 4 PVeRA", "MLP", PveraConfig, {"target_modules": ["lin0", "lin1"]}),
+    (
+        "Vanilla MLP 5 PVeRA",
+        "MLP",
+        PveraConfig,
+        {"target_modules": ["lin0"], "modules_to_save": ["lin1"]},
+    ),
+    (
+        "Embedding + transformers Conv1D 1 PVeRA",
+        "EmbConv1D",
+        PveraConfig,
+        {"target_modules": ["conv1d"]},
+    ),
+    ############
+    # FourierFT #
+    #############
+    # FourierFT is not initialized as an identity transform by default, hence set init_weights=True
+    (
+        "Vanilla MLP 1 FourierFT",
+        "MLP",
+        FourierFTConfig,
+        {"n_frequency": 10, "target_modules": "lin0", "init_weights": True},
+    ),
+    (
+        "Vanilla MLP 2 FourierFT",
+        "MLP",
+        FourierFTConfig,
+        {"n_frequency": 10, "target_modules": ["lin0"], "init_weights": True},
+    ),
+    (
+        "Vanilla MLP 3 FourierFT",
+        "MLP",
+        FourierFTConfig,
+        {"n_frequency": 10, "target_modules": ["lin1"], "init_weights": True},
+    ),
+    (
+        "Vanilla MLP 5 FourierFT",
+        "MLP",
+        FourierFTConfig,
+        {"n_frequency": 10, "target_modules": ["lin0"], "modules_to_save": ["lin1"], "init_weights": True},
+    ),
+    (
+        "Vanilla MLP 6 FourierFT",
+        "MLP",
+        FourierFTConfig,
+        {"n_frequency": 10, "target_modules": ["lin0", "lin1"], "modules_to_save": ["lin1"], "init_weights": True},
+    ),
+    (
+        "Vanilla MLP 7 FourierFT",
+        "MLP",
+        FourierFTConfig,
+        {
+            "n_frequency_pattern": {"lin0": 5, "lin1": 10},
+            "target_modules": ["lin0", "lin1"],
+            "modules_to_save": ["lin1"],
+            "init_weights": True,
+        },
+    ),
+    ###########
+    # GraLoRA #
+    ###########
+    ("Vanilla MLP 1 GraLoRA", "MLP", GraloraConfig, {"target_modules": "lin0"}),
+    ("Vanilla MLP 2 GraLoRA", "MLP", GraloraConfig, {"target_modules": ["lin0"]}),
+    ("Vanilla MLP 3 GraLoRA", "MLP", GraloraConfig, {"target_modules": ["lin1"]}),
+    ("Vanilla MLP 4 GraLoRA", "MLP", GraloraConfig, {"target_modules": ["lin0", "lin1"]}),
+    (
+        "Vanilla MLP 5 GraLoRA",
+        "MLP",
+        GraloraConfig,
+        {"target_modules": ["lin0"], "modules_to_save": ["lin1"]},
+    ),
+    (
+        "Vanilla MLP 6 GraLoRA",
+        "MLP",
+        GraloraConfig,
+        {"target_modules": ["lin0", "lin1"], "modules_to_save": ["lin1"]},
+    ),
+    (
+        "Vanilla MLP 7 Hybrid GraLoRA",
+        "MLP",
+        GraloraConfig,
+        {"target_modules": ["lin0", "lin1"], "modules_to_save": ["lin1"], "hybrid_r": 4},
+    ),
+    (
+        "Embedding + transformers Conv1D 1 GraLoRA",
+        "EmbConv1D",
+        GraloraConfig,
+        {"target_modules": ["conv1d"], "gralora_k": 1},
+    ),
+    ##########
+    # VBLoRA #
+    ##########
+    ("Vanilla MLP 1 VBLoRA", "MLP", VBLoRAConfig, {"target_modules": "lin0", "vector_length": 1, "num_vectors": 5}),
+    ("Vanilla MLP 2 VBLoRA", "MLP", VBLoRAConfig, {"target_modules": ["lin0"], "vector_length": 1, "num_vectors": 5}),
+    ("Vanilla MLP 3 VBLoRA", "MLP", VBLoRAConfig, {"target_modules": ["lin1"], "vector_length": 2, "num_vectors": 5}),
+    (
+        "Vanilla MLP 4 VBLoRA",
+        "MLP",
+        VBLoRAConfig,
+        {"target_modules": ["lin0", "lin1"], "vector_length": 1, "num_vectors": 5},
+    ),
+    (
+        "Vanilla MLP 5 VBLoRA",
+        "MLP",
+        VBLoRAConfig,
+        {"target_modules": ["lin0"], "modules_to_save": ["lin1"], "vector_length": 1, "num_vectors": 5},
+    ),
+    (
+        "Embedding + transformers Conv1D 1 VBLoRA",
+        "EmbConv1D",
+        VBLoRAConfig,
+        {"target_modules": ["conv1d"], "vector_length": 1, "num_vectors": 2},
+    ),
+    ###################
+    # TrainableTokens #
+    ###################
+    (
+        "Embedding + transformers Conv1D 1 trainable_tokens",
+        "EmbConv1D",
+        TrainableTokensConfig,
+        {"target_modules": ["emb"], "token_indices": [0, 1, 3], "init_weights": False},
+    ),
+    ################################
+    # Orthogonal Subspace Learning #
+    ################################
+    ("Vanilla MLP 1 OSF", "MLP", OSFConfig, {}),
+    ("Vanilla MLP 2 OSF", "MLP", OSFConfig, {"target_svd_config": {"lin0.weight": 5, "lin1.weight": 1}}),
+    ############
+    # RandLora #
+    ############
+    # We have to reduce the default scaling parameter to avoid nans when using large learning rates
+    ("Vanilla MLP 1 RandLora", "MLP", RandLoraConfig, {"target_modules": "lin0", "randlora_alpha": 1}),
+    ("Vanilla MLP 2 RandLora", "MLP", RandLoraConfig, {"target_modules": ["lin0"], "randlora_alpha": 1}),
+    ("Vanilla MLP 3 RandLora", "MLP", RandLoraConfig, {"target_modules": ["lin1"], "randlora_alpha": 1}),
+    ("Vanilla MLP 4 RandLora", "MLP", RandLoraConfig, {"target_modules": ["lin0", "lin1"], "randlora_alpha": 1}),
+    (
+        "Vanilla MLP 5 RandLora",
+        "MLP",
+        RandLoraConfig,
+        {"target_modules": ["lin0", "lin1"], "sparse": True, "randlora_alpha": 1},
+    ),
+    (
+        "Vanilla MLP 6 RandLora",
+        "MLP",
+        RandLoraConfig,
+        {"target_modules": ["lin0", "lin1"], "very_sparse": True, "randlora_alpha": 1},
+    ),
+    (
+        "Vanilla MLP 7 RandLora",
+        "MLP",
+        RandLoraConfig,
+        {"target_modules": ["lin0"], "modules_to_save": ["lin1"], "randlora_alpha": 1},
+    ),
+    ########
+    # FRoD #
+    ########
+    ("Vanilla MLP 1 FRoD", "MLP", FrodConfig, {"target_modules": "lin0"}),
+    ("Vanilla MLP 2 FRoD", "MLP", FrodConfig, {"target_modules": ["lin0"]}),
+    ("Vanilla MLP 3 FRoD", "MLP", FrodConfig, {"target_modules": ["lin1"]}),
+    ("Vanilla MLP 4 FRoD", "MLP", FrodConfig, {"target_modules": ["lin0", "lin1"]}),
+    ("Vanilla MLP 5 FRoD", "MLP", FrodConfig, {"target_modules": ["lin0"], "modules_to_save": ["lin1"]}),
+    ###########
+    # UniLora #
+    ###########
+    ("Vanilla MLP 1 UniLora", "MLP", UniLoraConfig, {"target_modules": "lin0", "theta_d_length": 101}),
+    ("Vanilla MLP 2 UniLora", "MLP", UniLoraConfig, {"target_modules": ["lin0"], "theta_d_length": 101}),
+    ("Vanilla MLP 3 UniLora", "MLP", UniLoraConfig, {"target_modules": ["lin1"], "theta_d_length": 101}),
+    (
+        "Vanilla MLP 4 UniLora",
+        "MLP",
+        UniLoraConfig,
+        {"target_modules": ["lin0", "lin1"], "theta_d_length": 101},
+    ),
+    (
+        "Vanilla MLP 5 UniLora",
+        "MLP",
+        UniLoraConfig,
+        {"target_modules": ["lin0"], "modules_to_save": ["lin1"], "theta_d_length": 101},
+    ),
+    (
+        "Embedding + transformers Conv1D 1 UniLora",
+        "EmbConv1D",
+        UniLoraConfig,
+        {"target_modules": ["conv1d"], "theta_d_length": 101},
+    ),
+    #######
+    # C3A #
+    #######
+    # note: C3A is not initialized as an identity transform by default, hence set init_weights=True
+    ("Vanilla MLP 1 C3A", "MLP", C3AConfig, {"block_size": 2, "target_modules": "lin0", "init_weights": True}),
+    ("Vanilla MLP 2 C3A", "MLP", C3AConfig, {"block_size": 2, "target_modules": ["lin0"], "init_weights": True}),
+    ("Vanilla MLP 3 C3A", "MLP", C3AConfig, {"block_size": 2, "target_modules": ["lin1"], "init_weights": True}),
+    (
+        "Vanilla MLP 5 C3A",
+        "MLP",
+        C3AConfig,
+        {"block_size": 10, "target_modules": ["lin0"], "modules_to_save": ["lin1"], "init_weights": True},
+    ),
+    (
+        "Vanilla MLP 6 C3A",
+        "MLP",
+        C3AConfig,
+        {"block_size": 10, "target_modules": ["lin0", "lin1"], "modules_to_save": ["lin1"], "init_weights": True},
+    ),
+    (
+        "Vanilla MLP 7 C3A",
+        "MLP",
+        C3AConfig,
+        {
+            "block_size_pattern": {"lin0": 5, "lin1": 10},
+            "target_modules": ["lin0", "lin1"],
+            "modules_to_save": ["lin1"],
+            "init_weights": True,
+        },
+    ),
+    ##########
+    # WaveFT #
+    ##########
+    ("Vanilla MLP 1 WaveFT", "MLP", WaveFTConfig, {"target_modules": "lin0", "n_frequency": 8}),
+    ("Vanilla MLP 2 WaveFT", "MLP", WaveFTConfig, {"target_modules": ["lin0"], "n_frequency": 8}),
+    ("Vanilla MLP 3 WaveFT", "MLP", WaveFTConfig, {"target_modules": ["lin1"], "n_frequency": 8}),
+    ("Vanilla MLP 4 WaveFT", "MLP", WaveFTConfig, {"target_modules": ["lin0", "lin1"], "n_frequency": 8}),
+    (
+        "Vanilla MLP 5 WaveFT",
+        "MLP",
+        WaveFTConfig,
+        {"target_modules": ["lin0"], "modules_to_save": ["lin1"], "n_frequency": 8},
+    ),
+    (
+        "Vanilla MLP 6 WaveFT",
+        "MLP",
+        WaveFTConfig,
+        {
+            "target_modules": ["lin0"],
+            "n_frequency": 8,
+            "scaling": 25.0,
+            "wavelet_family": "db1",
+        },
+    ),
+    ("Vanilla MLP 7 WaveFT", "MLP", WaveFTConfig, {"target_modules": "lin1", "n_frequency": 8, "use_idwt": False}),
+    (
+        "Vanilla MLP 8 WaveFT",
+        "MLP",
+        WaveFTConfig,
+        {"target_modules": "lin0", "n_frequency": 16, "wavelet_family": "sym2"},
+    ),
+    (
+        "Vanilla MLP 9 WaveFT",
+        "MLP",
+        WaveFTConfig,
+        {"target_modules": "lin0", "n_frequency": 16, "wavelet_family": "sym2", "use_idwt": False},
+    ),
+    (
+        "Vanilla MLP 10 WaveFT",
+        "MLP",
+        WaveFTConfig,
+        {"target_modules": "lin0", "n_frequency": 16, "wavelet_family": "db1", "proportional_parameters": True},
+    ),
+    ########
+    # RoAd #
+    ########
+    ("Vanilla MLP 1 RoAd", "MLP", RoadConfig, {"target_modules": "lin0", "group_size": 2}),
+    ("Vanilla MLP 2 RoAd", "MLP", RoadConfig, {"target_modules": ["lin0"], "group_size": 2}),
+    ("Vanilla MLP 3 RoAd", "MLP", RoadConfig, {"target_modules": ["lin1"], "group_size": 2}),
+    ("Vanilla MLP 4 RoAd", "MLP", RoadConfig, {"target_modules": ["lin0", "lin1"], "group_size": 2}),
+    ("Vanilla MLP 5 RoAd", "MLP", RoadConfig, {"target_modules": ["lin0"], "variant": "road_2", "group_size": 2}),
+    ("Vanilla MLP 6 RoAd", "MLP", RoadConfig, {"target_modules": ["lin0"], "variant": "road_4", "group_size": 2}),
+    ##########
+    # WaveFT #
+    ##########
+    ("Vanilla MLP 1 WaveFT", "MLP", WaveFTConfig, {"target_modules": "lin0", "n_frequency": 8}),
+    ("Vanilla MLP 2 WaveFT", "MLP", WaveFTConfig, {"target_modules": ["lin0"], "n_frequency": 8}),
+    ("Vanilla MLP 3 WaveFT", "MLP", WaveFTConfig, {"target_modules": ["lin1"], "n_frequency": 8}),
+    ("Vanilla MLP 4 WaveFT", "MLP", WaveFTConfig, {"target_modules": ["lin0", "lin1"], "n_frequency": 8}),
+    (
+        "Vanilla MLP 5 WaveFT",
+        "MLP",
+        WaveFTConfig,
+        {"target_modules": ["lin0"], "modules_to_save": ["lin1"], "n_frequency": 8},
+    ),
+    (
+        "Vanilla MLP 6 WaveFT",
+        "MLP",
+        WaveFTConfig,
+        {
+            "target_modules": ["lin0"],
+            "n_frequency": 8,
+            "scaling": 25.0,
+            "wavelet_family": "db1",
+        },
+    ),
+    ("Vanilla MLP 7 WaveFT", "MLP", WaveFTConfig, {"target_modules": "lin1", "n_frequency": 8, "use_idwt": False}),
+    (
+        "Vanilla MLP 8 WaveFT",
+        "MLP",
+        WaveFTConfig,
+        {"target_modules": "lin0", "n_frequency": 16, "wavelet_family": "sym2"},
+    ),
+    (
+        "Vanilla MLP 9 WaveFT",
+        "MLP",
+        WaveFTConfig,
+        {"target_modules": "lin0", "n_frequency": 16, "wavelet_family": "sym2", "use_idwt": False},
+    ),
+    (
+        "Vanilla MLP 10 WaveFT",
+        "MLP",
+        WaveFTConfig,
+        {"target_modules": "lin0", "n_frequency": 16, "wavelet_family": "db1", "proportional_parameters": True},
+    ),
+    ##########
+    # DeLoRA #
+    ##########
+    ("Vanilla MLP 1 DeLoRA", "MLP", DeloraConfig, {"target_modules": "lin0"}),
+    ("Vanilla MLP 2 DeLoRA", "MLP", DeloraConfig, {"target_modules": ["lin0"]}),
+    ("Vanilla MLP 3 DeLoRA", "MLP", DeloraConfig, {"target_modules": ["lin1"]}),
+    ("Vanilla MLP 4 DeLoRA", "MLP", DeloraConfig, {"target_modules": ["lin0", "lin1"]}),
+    (
+        "Vanilla MLP 5 DeLoRA",
+        "MLP",
+        DeloraConfig,
+        {"target_modules": ["lin0"], "module_dropout": 0.1},
+    ),
+    ###########
+    # BD-LoRA #
+    ###########
+    (
+        "BD-LoRA A only",
+        "MLP",
+        LoraConfig,
+        {
+            "target_modules": ["lin0", "lin1"],
+            "use_bdlora": BdLoraConfig(target_modules_bd_a=["lin0"], nblocks=2, match_strict=False),
+        },
+    ),
+    (
+        "BD-LoRA B only",
+        "MLP",
+        LoraConfig,
+        {
+            "target_modules": ["lin0", "lin1"],
+            "use_bdlora": BdLoraConfig(target_modules_bd_b=["lin1"], nblocks=2, match_strict=False),
+        },
+    ),
+    (
+        "BD-LoRA both A and B",
+        "MLP",
+        LoraConfig,
+        {
+            "target_modules": ["lin0", "lin1"],
+            "use_bdlora": BdLoraConfig(target_modules_bd_a=["lin0"], target_modules_bd_b=["lin1"], nblocks=2),
+        },
+    ),
+    #########
+    # PSOFT #
+    #########
+    ("Vanilla MLP 1 PSOFT", "MLP", PsoftConfig, {"target_modules": "lin0", "r": 4, "psoft_alpha": 4}),
+    ("Vanilla MLP 2 PSOFT", "MLP", PsoftConfig, {"target_modules": ["lin0"], "r": 4, "psoft_alpha": 4}),
+    ("Vanilla MLP 3 PSOFT", "MLP", PsoftConfig, {"target_modules": ["lin1"], "r": 2, "psoft_alpha": 2}),
+    ("Vanilla MLP 4 PSOFT", "MLP", PsoftConfig, {"target_modules": ["lin0", "lin1"], "r": 2, "psoft_alpha": 2}),
+    (
+        "Vanilla MLP 5 PSOFT (modules_to_save)",
+        "MLP",
+        PsoftConfig,
+        {"target_modules": ["lin0"], "modules_to_save": ["lin1"], "r": 4, "psoft_alpha": 4},
+    ),
+    (
+        "Vanilla MLP PSOFT-SO (PSOFT with strict orthogonality)",
+        "MLP",
+        PsoftConfig,
+        {"target_modules": ["lin0"], "r": 4, "psoft_alpha": 4, "psoft_mag_a": False, "psoft_mag_b": False},
+    ),
+    (
+        "Vanilla MLP PSOFT lowrank SVD niter 10",
+        "MLP",
+        PsoftConfig,
+        {"target_modules": ["lin0"], "r": 4, "psoft_alpha": 4, "psoft_svd": "lowrank", "psoft_svd_lowrank_niter": 10},
+    ),
+    (
+        "Vanilla MLP PSOFT Cayley-Neumann approximation term 5",
+        "MLP",
+        PsoftConfig,
+        {
+            "target_modules": ["lin0"],
+            "r": 4,
+            "psoft_alpha": 4,
+            "use_cayley_neumann": True,
+            "num_cayley_neumann_terms": 5,
+            "cayley_neumann_eps": 0.9,
+        },
+    ),
+    (
+        "Vanilla MLP PSOFT non-orthogonal R",
+        "MLP",
+        PsoftConfig,
+        {
+            "target_modules": ["lin0"],
+            "r": 4,
+            "psoft_alpha": 4,
+            "psoft_orth": False,
+            "psoft_mag_a": False,
+            "psoft_mag_b": False,
+        },
+    ),
+    (
+        "Vanilla MLP PSOFT PiSSA init",
+        "MLP",
+        PsoftConfig,
+        {"target_modules": ["lin0"], "r": 4, "psoft_alpha": 4, "ab_svd_init": "pissa_init"},
+    ),
+    ########
+    # Lily  #
+    ########
+    ("Vanilla MLP 1 Lily", "MLP", LilyConfig, {"target_modules": "lin0", "r": 2, "stride_A": 1, "num_B": 2}),
+    ("Vanilla MLP 2 Lily", "MLP", LilyConfig, {"target_modules": ["lin0"], "r": 2, "stride_A": 1, "num_B": 2}),
+    ("Vanilla MLP 3 Lily", "MLP", LilyConfig, {"target_modules": ["lin1"], "r": 2, "stride_A": 1, "num_B": 2}),
+    ("Vanilla MLP 4 Lily", "MLP", LilyConfig, {"target_modules": ["lin0", "lin1"], "r": 2, "stride_A": 1, "num_B": 2}),
+    (
+        "Vanilla MLP 5 Lily",
+        "MLP",
+        LilyConfig,
+        {"target_modules": ["lin0"], "r": 4, "stride_A": 1, "num_B": 2},
+    ),
+    ##########
+    # Peanut #
+    ##########
+    ("Vanilla MLP 1 Peanut", "MLP", PeanutConfig, {"target_modules": "lin0", "r": 2, "depth": 0, "act_fn": "relu"}),
+    ("Vanilla MLP 2 Peanut", "MLP", PeanutConfig, {"target_modules": ["lin0"], "r": 2, "depth": 0, "act_fn": "relu"}),
+    ("Vanilla MLP 3 Peanut", "MLP", PeanutConfig, {"target_modules": ["lin1"], "r": 2, "depth": 0, "act_fn": "relu"}),
+    (
+        "Vanilla MLP 4 Peanut",
+        "MLP",
+        PeanutConfig,
+        {"target_modules": ["lin0", "lin1"], "r": 2, "depth": 0, "act_fn": "relu"},
+    ),
+    ("Vanilla MLP 5 Peanut", "MLP", PeanutConfig, {"target_modules": "lin0", "r": 2, "depth": 1, "act_fn": "gelu"}),
+    #######
+    # HIRA #
+    #######
+    ("Vanilla MLP 1 HiRA", "MLP", HiraConfig, {"target_modules": "lin0"}),
+    ("Vanilla MLP 2 HiRA", "MLP", HiraConfig, {"target_modules": ["lin0"]}),
+    ("Vanilla MLP 3 HiRA", "MLP", HiraConfig, {"target_modules": ["lin1"]}),
+    ("Vanilla MLP 4 HiRA", "MLP", HiraConfig, {"target_modules": ["lin0", "lin1"]}),
+    ("Vanilla MLP 5 HiRA", "MLP", HiraConfig, {"target_modules": ["lin0"], "modules_to_save": ["lin1"]}),
+    (
+        "Vanilla MLP 6 HiRA",
+        "MLP",
+        HiraConfig,
+        {
+            "target_modules": ["lin0"],
+            "hira_dropout": 0.1,
+        },
+    ),
+    ("Embedding + transformers Conv1D 1 HiRA", "EmbConv1D", HiraConfig, {"target_modules": ["conv1d"]}),
+    ("Embedding + transformers Conv1D 2 HiRA", "EmbConv1D", HiraConfig, {"target_modules": ["emb"]}),
+    ("Embedding + transformers Conv1D 3 HiRA", "EmbConv1D", HiraConfig, {"target_modules": ["emb", "conv1d"]}),
+    ("Conv1d HiRA", "Conv1d", HiraConfig, {"target_modules": ["conv1d"]}),
+    ("Conv2d 1 HiRA", "Conv2d", HiraConfig, {"target_modules": ["conv2d"]}),
+    ("Conv2d 2 HiRA", "Conv2d", HiraConfig, {"target_modules": ["conv2d", "lin0"]}),
+    ("Conv3d 1 HiRA", "Conv3d", HiraConfig, {"target_modules": ["conv3d"]}),
+    ("Conv3d 2 HiRA", "Conv3d", HiraConfig, {"target_modules": ["conv3d", "lin0"]}),
+    ##########
+    # Adamss #
+    ##########
+    ("Vanilla MLP 1 Adamss", "MLP", AdamssConfig, {"target_modules": "lin0", "r": 8}),
+    ("Vanilla MLP 2 Adamss", "MLP", AdamssConfig, {"target_modules": ["lin0"], "r": 8}),
+    ("Vanilla MLP 3 Adamss", "MLP", AdamssConfig, {"target_modules": ["lin1"], "r": 2}),
+    ("Vanilla MLP 4 Adamss", "MLP", AdamssConfig, {"target_modules": ["lin0", "lin1"], "r": 8}),
+    (
+        "Vanilla MLP 5 Adamss with custom params",
+        "MLP",
+        AdamssConfig,
+        {
+            "target_modules": ["lin0", "lin1"],
+            "r": 8,
+            "num_subspaces": 3,
+            "subspace_rank": 2,
+        },
+    ),
+    (
+        "Vanilla MLP 6 Adamss with ASA",
+        "MLP",
+        AdamssConfig,
+        {
+            "target_modules": ["lin0", "lin1"],
+            "r": 8,
+            "num_subspaces": 6,
+            "use_asa": True,
+            "asa_target_subspaces": 3,
+        },
+    ),
+    (
+        "Vanilla MLP 7 Adamss with dynamic rank",
+        "MLP",
+        AdamssConfig,
+        {
+            "target_modules": ["lin0"],
+            "r": 8,
+            "num_subspaces": 3,
+            "use_dynamic_rank": True,
+            "svd_threshold": 0.1,
+        },
+    ),
+    ###########
+    # AdaLoRA #
+    ###########
+    (
+        "Vanilla MLP 1 AdaLoRA",
+        "MLP",
+        AdaLoraConfig,
+        {"target_modules": ["lin0"], "init_lora_weights": False, "total_step": 1},
+    ),
+    (
+        "Vanilla MLP 2 AdaLoRA",
+        "MLP",
+        AdaLoraConfig,
+        {"target_modules": ["lin0", "lin1"], "init_lora_weights": False, "total_step": 1},
+    ),
+    (
+        "Conv2d 1 AdaLoRA",
+        "Conv2d",
+        AdaLoraConfig,
+        {"target_modules": ["conv2d"], "init_lora_weights": False, "total_step": 1},
+    ),
+    (
+        "Conv2d 2 AdaLoRA",
+        "Conv2d",
+        AdaLoraConfig,
+        {"target_modules": ["conv2d", "lin0"], "init_lora_weights": False, "total_step": 1},
+    ),
+]
+ALL_PEFT_CONFIG_CLASSES = sorted({row[2] for row in TEST_CASES}, key=lambda cls: cls.__name__)
+
+# For this test matrix, each tuple consists of:
+# - test name
+# - tuner method
+# - config_cls
+# - 1st config kwargs
+# - 2nd config kwargs
+# The model used for this test is `MLP`, which uses linear layers `lin0` and `lin1`
+MULTIPLE_ACTIVE_ADAPTERS_TEST_CASES = [
+    (
+        "LoRA Same",
+        "lora",
+        LoraConfig,
+        {"target_modules": ["lin0"], "init_lora_weights": False},
+        {"target_modules": ["lin0"], "init_lora_weights": False},
+    ),
+    (
+        "LoRA Different",
+        "lora",
+        LoraConfig,
+        {"target_modules": ["lin0"], "init_lora_weights": False},
+        {"target_modules": ["lin1"], "init_lora_weights": False},
+    ),
+    (
+        "LoRA + trainable tokens Same",
+        "lora+trainable_tokens",
+        LoraConfig,
+        {"target_modules": ["lin0"], "init_lora_weights": False, "trainable_token_indices": {"emb": [0, 1, 2]}},
+        {"target_modules": ["lin0"], "init_lora_weights": False, "trainable_token_indices": {"emb": [3, 4, 5, 6]}},
+    ),
+    (
+        "LoRA + trainable tokens Different",
+        "lora+trainable_tokens",
+        LoraConfig,
+        {"target_modules": ["lin0"], "init_lora_weights": False, "trainable_token_indices": {"emb": [0, 1, 2]}},
+        {"target_modules": ["lin1"], "init_lora_weights": False, "trainable_token_indices": {"emb": [3, 4, 5, 6]}},
+    ),
+    (
+        "LoRA targeting nn.Parameter Same",
+        "lora",
+        LoraConfig,
+        {"target_parameters": ["lin0.weight"], "init_lora_weights": False},
+        {"target_parameters": ["lin0.weight"], "init_lora_weights": False},
+    ),
+    (
+        "LoRA targeting nn.Parameter Different",
+        "lora",
+        LoraConfig,
+        {"target_parameters": ["lin0.weight"], "init_lora_weights": False},
+        {"target_parameters": ["lin1.weight"], "init_lora_weights": False},
+    ),
+    (
+        "IA3 Same",
+        "ia3",
+        IA3Config,
+        {
+            "target_modules": ["lin0"],
+            "feedforward_modules": ["lin0"],
+            "init_ia3_weights": False,
+        },
+        {
+            "target_modules": ["lin0"],
+            "feedforward_modules": ["lin0"],
+            "init_ia3_weights": False,
+        },
+    ),
+    (
+        "IA3 Different",
+        "ia3",
+        IA3Config,
+        {
+            "target_modules": ["lin0"],
+            "feedforward_modules": ["lin0"],
+            "init_ia3_weights": False,
+        },
+        {
+            "target_modules": ["lin1"],
+            "feedforward_modules": ["lin1"],
+            "init_ia3_weights": False,
+        },
+    ),
+    (
+        "BEFT Same",
+        "beft",
+        BeftConfig,
+        {
+            "target_modules": ["lin0"],
+            "init_weights": False,
+        },
+        {
+            "target_modules": ["lin0"],
+            "init_weights": False,
+        },
+    ),
+    (
+        "BEFT Different",
+        "beft",
+        BeftConfig,
+        {
+            "target_modules": ["lin0"],
+            "init_weights": False,
+        },
+        {
+            "target_modules": ["lin1"],
+            "init_weights": False,
+        },
+    ),
+    (
+        "AdaLora Same",
+        "adalora",
+        AdaLoraConfig,
+        {"target_modules": ["lin0"], "init_lora_weights": False, "inference_mode": True, "total_step": 1},
+        {"target_modules": ["lin0"], "init_lora_weights": False, "inference_mode": True, "total_step": 1},
+    ),
+    (
+        "AdaLora Different",
+        "adalora",
+        AdaLoraConfig,
+        {"target_modules": ["lin0"], "init_lora_weights": False, "inference_mode": True, "total_step": 1},
+        {"target_modules": ["lin1"], "init_lora_weights": False, "inference_mode": True, "total_step": 1},
+    ),
+    (
+        "FourierFT Same",
+        "fourierft",
+        FourierFTConfig,
+        {"n_frequency": 10, "target_modules": ["lin0"]},
+        {"n_frequency": 10, "target_modules": ["lin0"]},
+    ),
+    (
+        "FourierFT Different",
+        "fourierft",
+        FourierFTConfig,
+        {"n_frequency": 10, "target_modules": ["lin0"]},
+        {"n_frequency": 10, "target_modules": ["lin1"]},
+    ),
+    (
+        "GraLoRA Same",
+        "gralora",
+        GraloraConfig,
+        {"target_modules": ["lin0"], "init_weights": False},
+        {"target_modules": ["lin0"], "init_weights": False},
+    ),
+    (
+        "GraLoRA Different",
+        "gralora",
+        GraloraConfig,
+        {"target_modules": ["lin0"], "init_weights": False},
+        {"target_modules": ["lin1"], "init_weights": False},
+    ),
+    (
+        "GLoRA Same",
+        "glora",
+        GloraConfig,
+        {"target_modules": ["lin0"], "init_weights": False},
+        {"target_modules": ["lin0"], "init_weights": False},
+    ),
+    (
+        "GLoRA Different",
+        "glora",
+        GloraConfig,
+        {"target_modules": ["lin0"], "init_weights": False},
+        {"target_modules": ["lin1"], "init_weights": False},
+    ),
+    (
+        "SHiRA Same",
+        "shira",
+        ShiraConfig,
+        {"r": 1, "target_modules": ["lin0"], "init_weights": False},
+        {"r": 1, "target_modules": ["lin0"], "init_weights": False},
+    ),
+    (
+        "SHiRA Different",
+        "shira",
+        ShiraConfig,
+        {"r": 1, "target_modules": ["lin0"], "init_weights": False},
+        {"r": 1, "target_modules": ["lin1"], "init_weights": False},
+    ),
+    # Note: Currently, we cannot target lin0 and lin1 with different adapters when using VeRA. The reason is that the
+    # first adapter being created will result in a vera_A or vera_B shape that is too small for the next adapter
+    # (remember that VeRA shares these parameters across all layers), which results in an error.
+    (
+        "VeRA Same",
+        "vera",
+        VeraConfig,
+        {"target_modules": ["lin0"], "init_weights": False},
+        {"target_modules": ["lin0"], "init_weights": False},
+    ),
+    (
+        "FRoD Same",
+        "frod",
+        FrodConfig,
+        {"target_modules": ["lin0"], "init_weights": False},
+        {"target_modules": ["lin0"], "init_weights": False},
+    ),
+    # Note: PVeRA presents the same problem mentioned above for VeRA.
+    (
+        "PVeRA Same",
+        "pvera",
+        PveraConfig,
+        {"target_modules": ["lin0"], "init_weights": False},
+        {"target_modules": ["lin0"], "init_weights": False},
+    ),
+    # Note: RandLora may present the same problem mentioned above for Vera.
+    (
+        "RandLora Same",
+        "randlora",
+        RandLoraConfig,
+        {"target_modules": ["lin0"], "init_weights": False},
+        {"target_modules": ["lin0"], "init_weights": False},
+    ),
+    (
+        "UniLora Same",
+        "unilora",
+        UniLoraConfig,
+        {"target_modules": ["lin0"], "theta_d_length": 101, "init_weights": False},
+        {"target_modules": ["lin0"], "theta_d_length": 101, "init_weights": False},
+    ),
+    (
+        "HRA Same",
+        "hra",
+        HRAConfig,
+        {"target_modules": ["lin0"], "init_weights": False},
+        {"target_modules": ["lin0"], "init_weights": False},
+    ),
+    (
+        "HRA Different",
+        "hra",
+        HRAConfig,
+        {"target_modules": ["lin0"], "init_weights": False},
+        {"target_modules": ["lin1"], "init_weights": False},
+    ),
+    (
+        # qr gives scale-independent (O(1)) updates at random init; the default relu update is ~|P|^2 and too small
+        # here for the adapters' outputs to differ beyond tolerance.
+        "DEFT Same",
+        "deft",
+        DeftConfig,
+        {"target_modules": ["lin0"], "init_weights": False, "decomposition_method": "qr"},
+        {"target_modules": ["lin0"], "init_weights": False, "decomposition_method": "qr"},
+    ),
+    (
+        "DEFT Different",
+        "deft",
+        DeftConfig,
+        {"target_modules": ["lin0"], "init_weights": False, "decomposition_method": "qr"},
+        {"target_modules": ["lin1"], "init_weights": False, "decomposition_method": "qr"},
+    ),
+    (
+        "MiSS Same",
+        "miss",
+        MissConfig,
+        {"target_modules": ["lin0"], "init_weights": False, "r": 2},
+        {"target_modules": ["lin0"], "init_weights": False, "r": 2},
+    ),
+    (
+        "MiSS Different",
+        "miss",
+        MissConfig,
+        {"target_modules": ["lin0"], "init_weights": False, "r": 2},
+        {"target_modules": ["lin1"], "init_weights": False, "r": 2},
+    ),
+    # Not testing "mini" initialization targeting the same layer, because The matrix is initialized to all zeros in MiSS-mini mode.
+    (
+        "VBLoRA Same",
+        "vblora",
+        VBLoRAConfig,
+        {"target_modules": ["lin0"], "vector_length": 2, "init_vector_bank_bound": 0.1},
+        {"target_modules": ["lin0"], "vector_length": 2, "init_vector_bank_bound": 0.1},
+    ),
+    (
+        "VBLoRA Different",
+        "vblora",
+        VBLoRAConfig,
+        {"target_modules": ["lin0"], "vector_length": 2, "init_vector_bank_bound": 0.1},
+        {"target_modules": ["lin1"], "vector_length": 2, "init_vector_bank_bound": 0.1},
+    ),
+    (
+        "BOFT Same",
+        "boft",
+        BOFTConfig,
+        {"target_modules": ["lin0"], "init_weights": False, "boft_block_size": 2},
+        {"target_modules": ["lin0"], "init_weights": False, "boft_block_size": 2},
+    ),
+    (
+        "BOFT Different",
+        "boft",
+        BOFTConfig,
+        {"target_modules": ["lin0"], "init_weights": False, "boft_block_size": 2},
+        {"target_modules": ["lin1"], "init_weights": False, "boft_block_size": 2},
+    ),
+    (
+        "WaveFT Same",
+        "waveft",
+        WaveFTConfig,
+        {"target_modules": ["lin0"], "init_weights": False, "n_frequency": 8},
+        {"target_modules": ["lin0"], "init_weights": False, "n_frequency": 8},
+    ),
+    (
+        "WaveFT Different",
+        "waveft",
+        WaveFTConfig,
+        {"target_modules": ["lin0"], "init_weights": False, "n_frequency": 8},
+        {"target_modules": ["lin1"], "init_weights": False, "n_frequency": 8},
+    ),
+    (
+        "RoAd Same",
+        "road",
+        RoadConfig,
+        {"target_modules": ["lin0"], "init_weights": False, "group_size": 2},
+        {"target_modules": ["lin0"], "init_weights": False, "group_size": 2},
+    ),
+    (
+        "RoAd Different",
+        "road",
+        RoadConfig,
+        {"target_modules": ["lin0"], "init_weights": False, "group_size": 2},
+        {"target_modules": ["lin1"], "init_weights": False, "group_size": 2},
+    ),
+    (
+        "RoAd 2 Different",
+        "road",
+        RoadConfig,
+        {"target_modules": ["lin0"], "init_weights": False, "variant": "road_1", "group_size": 2},
+        {"target_modules": ["lin1"], "init_weights": False, "variant": "road_2", "group_size": 2},
+    ),
+    (
+        "RoAd 4 Different",
+        "road",
+        RoadConfig,
+        {"target_modules": ["lin0"], "init_weights": False, "variant": "road_1", "group_size": 2},
+        {"target_modules": ["lin1"], "init_weights": False, "variant": "road_4", "group_size": 2},
+    ),
+    (
+        "WaveFT Same",
+        "waveft",
+        WaveFTConfig,
+        {"target_modules": ["lin0"], "init_weights": False, "n_frequency": 8},
+        {"target_modules": ["lin0"], "init_weights": False, "n_frequency": 8},
+    ),
+    (
+        "WaveFT Different",
+        "waveft",
+        WaveFTConfig,
+        {"target_modules": ["lin0"], "init_weights": False, "n_frequency": 8},
+        {"target_modules": ["lin1"], "init_weights": False, "n_frequency": 8},
+    ),
+    (
+        "DeLoRA Same",
+        "delora",
+        DeloraConfig,
+        {"target_modules": ["lin0"], "init_weights": False},
+        {"target_modules": ["lin0"], "init_weights": False},
+    ),
+    (
+        "DeLoRA Different",
+        "delora",
+        DeloraConfig,
+        {"target_modules": ["lin0"], "init_weights": False},
+        {"target_modules": ["lin1"], "init_weights": False},
+    ),
+    (
+        "PSOFT Same",
+        "psoft",
+        PsoftConfig,
+        {"target_modules": ["lin0"], "r": 4, "psoft_alpha": 4, "init_weights": False},
+        {"target_modules": ["lin0"], "r": 4, "psoft_alpha": 4, "init_weights": False},
+    ),
+    (
+        "PSOFT Different",
+        "psoft",
+        PsoftConfig,
+        {"target_modules": ["lin0"], "r": 2, "psoft_alpha": 2, "init_weights": False},
+        {"target_modules": ["lin1"], "r": 2, "psoft_alpha": 2, "init_weights": False},
+    ),
+    (
+        "Lily Same",
+        "lily",
+        LilyConfig,
+        {"target_modules": ["lin0"], "r": 2, "stride_A": 1, "num_B": 2, "init_weights": False},
+        {"target_modules": ["lin0"], "r": 2, "stride_A": 1, "num_B": 2, "init_weights": False},
+    ),
+    (
+        "Lily Different",
+        "lily",
+        LilyConfig,
+        {"target_modules": ["lin0"], "r": 2, "stride_A": 1, "num_B": 2, "init_weights": False},
+        {"target_modules": ["lin1"], "r": 2, "stride_A": 1, "num_B": 2, "init_weights": False},
+    ),
+    (
+        "Peanut Same",
+        "peanut",
+        PeanutConfig,
+        {"target_modules": ["lin0"], "r": 2, "depth": 1, "act_fn": "relu", "init_weights": False},
+        {"target_modules": ["lin0"], "r": 2, "depth": 1, "act_fn": "relu", "init_weights": False},
+    ),
+    (
+        "Peanut Different",
+        "peanut",
+        PeanutConfig,
+        {"target_modules": ["lin0"], "r": 2, "depth": 1, "act_fn": "relu", "init_weights": False},
+        {"target_modules": ["lin1"], "r": 2, "depth": 1, "act_fn": "relu", "init_weights": False},
+    ),
+    (
+        "HiRA Same",
+        "hira",
+        HiraConfig,
+        {"target_modules": ["lin0"], "init_weights": False},
+        {"target_modules": ["lin0"], "init_weights": False},
+    ),
+    (
+        "HiRA Different",
+        "hira",
+        HiraConfig,
+        {"target_modules": ["lin0"], "init_weights": False},
+        {"target_modules": ["lin1"], "init_weights": False},
+    ),
+    # BD-LoRA different encounters issues as the adapter weights have different shapes then
+    # for TinyLoRA, use uniform init, which allows the different adapters to be sufficiently different that they don't
+    # produce identical results within allowed tolerance
+    (
+        "TinyLoRA Same",
+        "tinylora",
+        TinyLoraConfig,
+        {"target_modules": ["lin0"], "init_weights": "uniform"},
+        {"target_modules": ["lin0"], "init_weights": "uniform"},
+    ),
+    (
+        "TinyLoRA Different",
+        "tinylora",
+        TinyLoraConfig,
+        {"target_modules": ["lin0"], "init_weights": "uniform"},
+        {"target_modules": ["lin1"], "init_weights": "uniform"},
+    ),
+    (
+        "LoHa Same",
+        "loha",
+        LoHaConfig,
+        {"target_modules": ["lin0"], "init_weights": False},
+        {"target_modules": ["lin0"], "init_weights": False},
+    ),
+    (
+        "LoHa Different",
+        "loha",
+        LoHaConfig,
+        {"target_modules": ["lin0"], "init_weights": False},
+        {"target_modules": ["lin1"], "init_weights": False},
+    ),
+    (
+        "LoKr Same",
+        "lokr",
+        LoKrConfig,
+        {"target_modules": ["lin0"], "init_weights": False},
+        {"target_modules": ["lin0"], "init_weights": False},
+    ),
+    (
+        "LoKr Different",
+        "lokr",
+        LoKrConfig,
+        {"target_modules": ["lin0"], "init_weights": False},
+        {"target_modules": ["lin1"], "init_weights": False},
+    ),
+    (
+        "OFT Same",
+        "oft",
+        OFTConfig,
+        {"target_modules": ["lin0"], "init_weights": False, "oft_block_size": 2},
+        {"target_modules": ["lin0"], "init_weights": False, "oft_block_size": 2},
+    ),
+    (
+        "OFT Different",
+        "oft",
+        OFTConfig,
+        {"target_modules": ["lin0"], "init_weights": False, "oft_block_size": 2},
+        {"target_modules": ["lin1"], "init_weights": False, "oft_block_size": 2},
+    ),
+    # Note: Multiple C3A adapters applied to the same layer fails with shape mismatch
+    (
+        "C3A Different",
+        "c3a",
+        C3AConfig,
+        {"target_modules": ["lin0"], "init_weights": False, "block_size": 2},
+        {"target_modules": ["lin1"], "init_weights": False, "block_size": 2},
+    ),
+    (
+        "AdaMSS Same",
+        "adamss",
+        AdamssConfig,
+        {"target_modules": ["lin0"], "r": 8, "num_subspaces": 2, "init_weights": False},
+        {"target_modules": ["lin0"], "r": 8, "num_subspaces": 2, "init_weights": False},
+    ),
+    (
+        "AdaMSS Different",
+        "adamss",
+        AdamssConfig,
+        {"target_modules": ["lin0"], "r": 8, "num_subspaces": 2, "init_weights": False},
+        {"target_modules": ["lin1"], "r": 2, "num_subspaces": 2, "init_weights": False},
+    ),
+]
+
+
+def _skip_tests_with_multiple_adapters_with_target_parameters(config_cls, config_kwargs):
+    if (config_cls == LoraConfig) and config_kwargs.get("target_parameters"):
+        pytest.skip("LoRA with multiple adapters with target_parameters is not supported")
+    if config_cls is AdaLoraConfig:
+        pytest.skip("AdaLoRA only supports a single trainable adapter")
+
+
+class MLP(nn.Module):
+    def __init__(self, bias=True):
+        super().__init__()
+        self.lin0 = nn.Linear(10, 20, bias=bias)
+        self.relu = nn.ReLU()
+        self.drop = nn.Dropout(0.5)
+        self.lin1 = nn.Linear(20, 2, bias=bias)
+        self.sm = nn.LogSoftmax(dim=-1)
+        self.dtype = torch.float
+
+    def forward(self, X):
+        X = X.to(self.dtype)
+        X = self.lin0(X)
+        X = self.relu(X)
+        X = self.drop(X)
+        X = self.lin1(X)
+        X = self.sm(X)
+        return X
+
+
+class MLPWithGRU(nn.Module):
+    def __init__(self, bias=True):
+        super().__init__()
+        self.lin0 = nn.Linear(10, 20, bias=bias)
+        self.relu = nn.ReLU()
+        self.drop = nn.Dropout(0.5)
+        self.gru = nn.GRU(input_size=20, hidden_size=20, num_layers=1, batch_first=True, bias=bias)
+        self.fc = nn.Linear(20, 2, bias=bias)
+        self.sm = nn.LogSoftmax(dim=-1)
+        self.dtype = torch.float
+
+    def forward(self, X):
+        X = X.to(self.dtype)
+        X = self.lin0(X)
+        X = self.relu(X)
+        X = self.drop(X)
+        X = X.unsqueeze(1)
+        X, _ = self.gru(X)
+        X = X.squeeze(1)
+        X = self.fc(X)
+        X = self.sm(X)
+        return X
+
+
+class MLP_LayerNorm(nn.Module):
+    def __init__(self, bias=True):
+        super().__init__()
+        self.layernorm0 = nn.LayerNorm(10, 10)
+        self.lin0 = nn.Linear(10, 20, bias=bias)
+        self.relu = nn.ReLU()
+        self.drop = nn.Dropout(0.5)
+        self.layernorm1 = nn.LayerNorm(20, 20)
+        self.lin1 = nn.Linear(20, 2, bias=bias)
+        self.sm = nn.LogSoftmax(dim=-1)
+        self.dtype = torch.float
+
+    def forward(self, X):
+        X = X.to(self.dtype)
+        X = self.layernorm0(X)
+        X = self.lin0(X)
+        X = self.relu(X)
+        X = self.drop(X)
+        X = self.layernorm1(X)
+        X = self.lin1(X)
+        X = self.sm(X)
+        return X
+
+
+class MLP2(nn.Module):
+    def __init__(self, bias=True):
+        super().__init__()
+        self.lin0 = nn.Linear(10, 32, bias=bias)
+        self.relu = nn.ReLU()
+        self.drop = nn.Dropout(0.5)
+        self.lin1 = nn.Linear(32, 2, bias=bias)
+        self.sm = nn.LogSoftmax(dim=-1)
+        self.dtype = torch.float
+
+    def forward(self, X):
+        X = X.to(self.dtype)
+        X = self.lin0(X)
+        X = self.relu(X)
+        X = self.drop(X)
+        X = self.lin1(X)
+        X = self.sm(X)
+        return X
+
+
+class Block(nn.Module):
+    def __init__(self, bias=True, size=10):
+        super().__init__()
+        self.lin0 = nn.Linear(size, size, bias=bias)
+        self.relu = nn.ReLU()
+        self.drop = nn.Dropout(0.5)
+        self.lin1 = nn.Linear(size, size, bias=bias)
+
+    def forward(self, X):
+        X = X.float()
+        X = self.lin0(X)
+        X = self.relu(X)
+        X = self.drop(X)
+        X = self.lin1(X)
+        return X
+
+
+class DeepMLP(nn.Module):
+    def __init__(self, bias=True, num_hidden_layers=12, size=10):
+        super().__init__()
+        self.layers = nn.ModuleList([Block(bias=bias, size=size) for _ in range(num_hidden_layers)])
+        self.out = nn.Linear(10, 2, bias=bias)
+        self.sm = nn.LogSoftmax(dim=-1)
+
+    def forward(self, X):
+        X = X.float(X)
+        for layer in self.layers:
+            X = layer(X)
+        X = self.out(X)
+        X = self.sm(X)
+        return X
+
+
+class ModelEmbConv1D(nn.Module):
+    def __init__(self, emb_size=100):
+        super().__init__()
+        self.emb = nn.Embedding(emb_size, 5)
+        self.conv1d = Conv1D(1, 5)
+        self.relu = nn.ReLU()
+        self.flat = nn.Flatten()
+        self.lin0 = nn.Linear(10, 2)
+        self.sm = nn.LogSoftmax(dim=-1)
+
+    def forward(self, X):
+        X = self.emb(X)
+        X = self.conv1d(X)
+        X = self.relu(X)
+        X = self.flat(X)
+        X = self.lin0(X)
+        X = self.sm(X)
+        return X
+
+
+class ModelEmbWithEmbeddingUtils(nn.Module):
+    # Adds `get_input_embeddings` and `get_output_embeddings` methods to mimic 🤗 transformers models
+    def __init__(self):
+        super().__init__()
+        self.embed_tokens = nn.Embedding(100, 5)
+        self.conv1d = Conv1D(1, 5)
+        self.relu = nn.ReLU()
+        self.flat = nn.Flatten()
+        self.lin0 = nn.Linear(10, 2)
+        self.sm = nn.LogSoftmax(dim=-1)
+
+    def forward(self, X):
+        X = self.embed_tokens(X)
+        X = self.conv1d(X)
+        X = self.relu(X)
+        X = self.flat(X)
+        X = self.lin0(X)
+        X = self.sm(X)
+        return X
+
+    def get_input_embeddings(self):
+        return self.embed_tokens
+
+    def get_output_embeddings(self):
+        return None
+
+
+class ModelConv1D(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.conv1d = nn.Conv1d(1, 1, 2)
+        self.relu = nn.ReLU()
+        self.flat = nn.Flatten()
+        self.lin0 = nn.Linear(9, 2)
+        self.sm = nn.LogSoftmax(dim=-1)
+        self.dtype = torch.float
+
+    def forward(self, X):
+        X = X.to(self.dtype)
+        X = X.reshape(-1, 1, 10)
+        X = self.conv1d(X)
+        X = self.relu(X)
+        X = self.flat(X)
+        X = self.lin0(X)
+        X = self.sm(X)
+        return X
+
+
+class ModelConv1DBigger(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.conv1d = nn.Conv1d(64, 16, 2)
+        self.relu = nn.ReLU()
+        self.flat = nn.Flatten()
+        self.lin0 = nn.Linear(144, 2)
+        self.sm = nn.LogSoftmax(dim=-1)
+        self.dtype = torch.float
+
+    def forward(self, X):
+        X = X.to(self.dtype)
+        X = X.reshape(-1, 1, 10)
+        X = torch.concat([X] * 64, dim=1)
+        X = self.conv1d(X)
+        X = self.relu(X)
+        X = self.flat(X)
+        X = self.lin0(X)
+        X = self.sm(X)
+        return X
+
+
+class ModelConv2D(nn.Module):
+    def __init__(self, bias=True):
+        super().__init__()
+        self.conv2d = nn.Conv2d(5, 10, 3, bias=bias)
+        self.relu = nn.ReLU()
+        self.flat = nn.Flatten()
+        self.lin0 = nn.Linear(10, 2)
+        self.sm = nn.LogSoftmax(dim=-1)
+        self.dtype = torch.float
+
+    def forward(self, X):
+        X = X.to(self.dtype)
+        X = X.reshape(-1, 5, 3, 3)
+        X = self.conv2d(X)
+        X = self.relu(X)
+        X = self.flat(X)
+        X = self.lin0(X)
+        X = self.sm(X)
+        return X
+
+
+class ModelConv2D2(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.lin0 = nn.Linear(10, 40)
+        self.conv2d = nn.Conv2d(8, 32, 3)
+        self.relu = nn.ReLU()
+        self.flat = nn.Flatten()
+        self.lin1 = nn.Linear(32, 2)
+        self.sm = nn.LogSoftmax(dim=-1)
+        self.dtype = torch.float
+
+    def forward(self, X):
+        X = X.to(self.dtype)
+        X = self.lin0(X)
+        X = self.relu(X)
+        X = X.reshape(-1, 8, 3, 3)
+        X = self.conv2d(X)
+        X = self.relu(X)
+        X = self.flat(X)
+        X = self.lin1(X)
+        X = self.sm(X)
+        return X
+
+
+class ModelConv2D1x1(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.conv2d = nn.Conv2d(1, 10, kernel_size=(1, 1), padding=0)
+        self.relu = nn.ReLU()
+        self.flat = nn.Flatten()
+        self.lin0 = nn.Linear(10 * 3 * 3, 2)
+        self.sm = nn.LogSoftmax(dim=-1)
+        self.dtype = torch.float
+
+    def forward(self, X):
+        X = X.to(self.dtype)
+        X = X.reshape(-1, 1, 3, 3)
+        X = self.conv2d(X)
+        X = self.relu(X)
+        X = self.flat(X)
+        X = self.lin0(X)
+        X = self.sm(X)
+        return X
+
+
+class ModelConv2DGroups(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.lin0 = nn.Linear(90, 288)
+        # groups is set as 8 since default r=8
+        # hence to make r divisible by groups
+        self.conv2d = nn.Conv2d(16, 16, 3, groups=8)
+        self.relu = nn.ReLU()
+        self.flat = nn.Flatten()
+        self.lin1 = nn.Linear(16, 2)
+        self.sm = nn.LogSoftmax(dim=-1)
+        self.dtype = torch.float
+
+    def forward(self, X):
+        X = X.to(self.dtype)
+        X = X.flatten()
+        X = self.lin0(X)
+        X = X.reshape(2, 16, 3, 3)
+        X = self.conv2d(X)
+        X = self.relu(X)
+        X = self.flat(X)
+        X = self.lin1(X)
+        X = self.sm(X)
+        return X
+
+
+class ModelConv2DGroups2(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.conv2d = nn.Conv2d(16, 32, 3, padding=1, groups=2)
+        self.relu = nn.ReLU()
+        self.flat = nn.Flatten()
+        self.lin0 = nn.Linear(12800, 2)
+        self.sm = nn.LogSoftmax(dim=-1)
+        self.dtype = torch.float
+
+    def forward(self, X):
+        # Note: needs a different input shape, thus ignore original input
+        X = torch.arange(9 * 16 * 20 * 20).view([9, 16, 20, 20]).to(self.conv2d.weight.device)
+        X = X.to(self.dtype)
+        X = self.conv2d(X)
+        X = self.relu(X)
+        X = self.flat(X)
+        X = self.lin0(X)
+        X = self.sm(X)
+        return X
+
+
+class ModelConv1DKernel1(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.conv1d = nn.Conv1d(in_channels=3, out_channels=10, kernel_size=1)
+        self.relu = nn.ReLU()
+        self.flat = nn.Flatten()
+        self.lin0 = nn.Linear(10 * 10, 2)
+        self.dtype = torch.float
+
+    def forward(self, x):
+        x = x.to(self.dtype)
+        x = x.reshape(-1, 3, 10)  # batch, channels, seq_len
+        x = self.conv1d(x)
+        x = self.relu(x)
+        x = self.flat(x)
+        x = self.lin0(x)
+        return x
+
+
+class ModelConv3D(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.conv3d = nn.Conv3d(5, 10, 3)
+        self.relu = nn.ReLU()
+        self.flat = nn.Flatten()
+        self.lin0 = nn.Linear(10, 2)
+        self.sm = nn.LogSoftmax(dim=-1)
+        self.dtype = torch.float
+
+    def forward(self, X):
+        X = X.to(self.dtype)
+        # If necessary, convert from 2D image to 3D volume
+        if X.dim() == 2:
+            X = torch.stack([X] * 3, dim=-1)
+        X = X.reshape(-1, 5, 3, 3, 3)
+        X = self.conv3d(X)
+        X = self.relu(X)
+        X = self.flat(X)
+        X = self.lin0(X)
+        X = self.sm(X)
+        return X
+
+
+class ModelMha(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.mha = nn.MultiheadAttention(10, 2)
+        self.lin0 = nn.Linear(10, 2)
+        self.sm = nn.LogSoftmax(dim=-1)
+        self.dtype = torch.float
+
+    def forward(self, X):
+        X = X.to(self.dtype)
+        X, _ = self.mha(X, X, X)
+        X = self.lin0(X)
+        X = self.sm(X)
+        return X
+
+
+class _LinearUsingParameter(nn.Module):
+    # Linear layer equivalent
+    def __init__(self, in_features, out_features, bias=None):
+        super().__init__()
+        self.in_features = in_features
+        self.out_features = out_features
+        self.weight = nn.Parameter(torch.randn(in_features, out_features))
+        if bias:
+            self.bias = nn.Parameter(torch.ones(out_features))
+
+    def forward(self, x):
+        return x @ self.weight + self.bias
+
+
+class MlpUsingParameters(nn.Module):
+    # MLP that uses layers whose parameters need to be targeted with target_parameters
+    def __init__(self, bias=True):
+        super().__init__()
+
+        self.lin0 = _LinearUsingParameter(10, 20, bias=bias)
+        self.relu = nn.ReLU()
+        self.drop = nn.Dropout(0.5)
+        self.lin1 = _LinearUsingParameter(20, 2, bias=bias)
+        self.sm = nn.LogSoftmax(dim=-1)
+        self.dtype = torch.float
+
+    def forward(self, X):
+        X = X.to(self.dtype)
+        X = self.lin0(X)
+        X = self.relu(X)
+        X = self.drop(X)
+        X = self.lin1(X)
+        X = self.sm(X)
+        return X
+
+
+class MockTransformerWrapper:
+    """Mock class to behave like a transformers model.
+
+    This is needed because the tests initialize the model by calling transformers_class.from_pretrained.
+
+    """
+
+    @classmethod
+    def from_pretrained(cls, model_id, dtype=None):
+        # set the seed so that from_pretrained always returns the same model
+        torch.manual_seed(0)
+
+        if dtype is None:
+            dtype = torch.float32
+
+        if model_id == "MLP":
+            return MLP().to(dtype)
+
+        if model_id == "EmbConv1D":
+            return ModelEmbConv1D().to(dtype)
+
+        if model_id == "Conv1d":
+            return ModelConv1D().to(dtype)
+
+        if model_id == "Conv1dBigger":
+            return ModelConv1DBigger().to(dtype)
+
+        if model_id == "Conv2d":
+            return ModelConv2D().to(dtype)
+
+        if model_id == "Conv2d1x1":
+            return ModelConv2D1x1().to(dtype)
+
+        if model_id == "Conv1dKernel1":
+            return ModelConv1DKernel1().to(dtype)
+
+        if model_id == "Conv2dGroups":
+            return ModelConv2DGroups().to(dtype)
+
+        if model_id == "Conv2dGroups2":
+            return ModelConv2DGroups2().to(dtype)
+
+        if model_id == "Conv3d":
+            return ModelConv3D().to(dtype)
+
+        if model_id == "MLP_LayerNorm":
+            return MLP_LayerNorm().to(dtype)
+
+        if model_id == "MLP2":
+            return MLP2().to(dtype)
+
+        if model_id == "Conv2d2":
+            return ModelConv2D2().to(dtype)
+
+        if model_id == "MHA":
+            return ModelMha().to(dtype)
+
+        if model_id == "MlpUsingParameters":
+            return MlpUsingParameters().to(dtype)
+
+        raise ValueError(f"model_id {model_id} not implemented")
+
+
+class TestPeftCustomModel(PeftCommonTester):
+    """
+    Implements the tests for custom models.
+
+    Most tests should just call the parent class, e.g. test_save_pretrained calls self._test_save_pretrained. Override
+    this if custom models don't work with the parent test method.
+
+    """
+
+    transformers_class = MockTransformerWrapper
+
+    def prepare_inputs_for_testing(self):
+        X = torch.arange(90).view(9, 10).to(self.torch_device)
+        return {"X": X}
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_attributes_parametrized(self, test_name, model_id, config_cls, config_kwargs):
+        self._test_model_attr(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_adapter_name(self, test_name, model_id, config_cls, config_kwargs):
+        self._test_adapter_name(model_id, config_cls, config_kwargs)
+
+    # Note: skipping _test_prepare_for_training: test does not work with custom models because it assumes that there is
+    # always a method get_input_embeddings that returns a layer which does not need updates. Instead, a new test is
+    # added below that checks that LoRA works as expected.
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_save_pretrained(self, test_name, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_save_pretrained(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_save_pretrained_pickle(self, test_name, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_save_pretrained(model_id, config_cls, config_kwargs, safe_serialization=False)
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_save_pretrained_adapter_name_substring(self, test_name, model_id, config_cls, config_kwargs):
+        _skip_tests_with_multiple_adapters_with_target_parameters(config_cls, config_kwargs)
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_save_pretrained_adapter_name_substring(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_load_model_low_cpu_mem_usage(self, test_name, model_id, config_cls, config_kwargs):
+        _skip_tests_with_multiple_adapters_with_target_parameters(config_cls, config_kwargs)
+        self._test_load_model_low_cpu_mem_usage(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_from_pretrained_config_construction(self, test_name, model_id, config_cls, config_kwargs):
+        self._test_from_pretrained_config_construction(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_load_multiple_adapters(self, test_name, model_id, config_cls, config_kwargs):
+        _skip_tests_with_multiple_adapters_with_target_parameters(config_cls, config_kwargs)
+        self._test_load_multiple_adapters(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_merge_layers(self, test_name, model_id, config_cls, config_kwargs):
+        _skip_if_merging_not_supported(model_id, config_cls, config_kwargs)
+
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_merge_layers(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_merge_layers_fp16(self, test_name, model_id, config_cls, config_kwargs):
+        _skip_if_merging_not_supported(model_id, config_cls, config_kwargs)
+
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_merge_layers_fp16(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_merge_layers_is_idempotent(self, test_name, model_id, config_cls, config_kwargs):
+        _skip_if_merging_not_supported(model_id, config_cls, config_kwargs)
+
+        # calling merge twice with the same arguments should not change the output
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_merge_layers_is_idempotent(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_safe_merge(self, test_name, model_id, config_cls, config_kwargs):
+        _skip_if_merging_not_supported(model_id, config_cls, config_kwargs)
+
+        # calling merge twice with the same arguments should not change the output
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_safe_merge(model_id, config_cls, config_kwargs)
+
+    def test_glora_safe_merge_does_not_corrupt_base_layer_on_non_finite_adapter(self):
+        # Regression test: GLoRA's merge() used to accumulate the merged weights directly onto
+        # base_layer.weight.data/bias.data *before* the safe_merge isfinite check, so a broken
+        # (non-finite) adapter would permanently corrupt the base layer even though safe_merge
+        # raises -- defeating the whole point of safe_merge ("check for NaNs before merging").
+        torch.manual_seed(0)
+        model = MLP()
+        orig_weight = model.lin0.weight.data.clone()
+        orig_bias = model.lin0.bias.data.clone()
+
+        config = GloraConfig(target_modules=["lin0"])
+        model = get_peft_model(model, config)
+
+        # Deliberately break the adapter (e.g. a corrupted checkpoint or an fp16 overflow) so that
+        # the merged weights would contain non-finite values.
+        glora_b = model.base_model.model.lin0.glora_B["default"]
+        next(glora_b.parameters()).data.fill_(float("inf"))
+
+        with pytest.raises(ValueError, match="NaNs detected in the merged weights"):
+            model.base_model.model.lin0.merge(safe_merge=True)
+
+        # The base layer must be untouched after the failed safe_merge.
+        assert torch.equal(model.base_model.model.lin0.base_layer.weight.data, orig_weight)
+        assert torch.equal(model.base_model.model.lin0.base_layer.bias.data, orig_bias)
+        assert model.base_model.model.lin0.merged_adapters == []
+
+    @pytest.mark.parametrize("safe_merge", [False, True])
+    @pytest.mark.parametrize("module_type", ["linear", "conv2d"])
+    def test_merge_with_lora_bias_when_base_layer_has_no_bias_warns_and_raises(self, safe_merge, module_type):
+        # It is not possible to merge the lora_B bias if the base layer doesn't have a bias itself.
+        if module_type == "linear":
+            model = MLP(bias=False)
+            config = LoraConfig(target_modules=["lin0", "lin1"], lora_bias=True)
+            warn_msg = re.escape("`lora_bias=True` was passed but the targeted layer of type Linear has no bias")
+        elif module_type == "conv2d":
+            model = ModelConv2D(bias=False)
+            config = LoraConfig(target_modules=["conv2d"], lora_bias=True)
+            warn_msg = re.escape("`lora_bias=True` was passed but the targeted layer of type Conv2d has no bias")
+        else:
+            raise ValueError(f"Wrong module_type passed, expected 'linear' or 'conv2d', got {module_type}")
+
+        with pytest.warns(PeftWarning, match=warn_msg):
+            model = get_peft_model(model, config)
+
+        err_msg = "Impossible to merge LoRA with `lora_bias=True` because the base layer has no bias"
+        with pytest.raises(RuntimeError, match=err_msg):
+            model.merge_adapter(safe_merge=safe_merge)
+
+    # Note: Skipping _test_generate, _test_generate_pos_args, _test_generate_half_prec, as the custom models don't have
+    # a generate method
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_training_custom_models(self, test_name, model_id, config_cls, config_kwargs):
+        self._test_training(model_id, config_cls, config_kwargs)
+
+    # Note: skipping _test_training_layer_indexing because layer indexing only works when layer names conform to a
+    # specific pattern, which is not guaranteed here. Therefore, this test is not performed.
+
+    # Note: skipping _test_training_gradient_checkpointing because the model explicitly needs to support it, which is
+    # not the case for custom models
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_inference_safetensors(self, test_name, model_id, config_cls, config_kwargs):
+        self._test_inference_safetensors(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_peft_model_device_map(self, test_name, model_id, config_cls, config_kwargs):
+        self._test_peft_model_device_map(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_in_features_out_features_exposed(self, test_name, model_id, config_cls, config_kwargs):
+        # the PEFT layer should expose the .in_features and .out_features attributes
+        model = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+        config = config_cls(
+            base_model_name_or_path=model_id,
+            **config_kwargs,
+        )
+        model = get_peft_model(model, config)
+        for module in model.modules():
+            if isinstance(module, BaseTunerLayer):
+                assert hasattr(module, "in_features")
+                assert hasattr(module, "out_features")
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_forward_output_finite(self, test_name, model_id, config_cls, config_kwargs):
+        X = self.prepare_inputs_for_testing()
+        model = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+        config = config_cls(
+            base_model_name_or_path=model_id,
+            **config_kwargs,
+        )
+        model = get_peft_model(model, config)
+        model.eval()
+        with torch.no_grad():
+            output = model(**X)
+        assert torch.isfinite(output).all()
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_forward_float16(self, test_name, model_id, config_cls, config_kwargs):
+        # The user manually sets the dtype of the base model to fp16 precision. This should not cause an error for the
+        # different PEFT methods.
+        try:
+            torch.zeros(1, dtype=torch.float16)
+        except Exception:
+            # skip this test if float16 is not supported on this machine
+            pytest.skip(reason="Test requires float16 support")
+
+        # skip on MacOS
+        if platform.system() == "Darwin":
+            pytest.skip(reason="MacOS does not support multiple ops in float16")
+
+        X = self.prepare_inputs_for_testing()
+        model = self.transformers_class.from_pretrained(model_id, dtype=torch.float16).to(self.torch_device)
+        model.dtype = torch.float16
+        config = config_cls(
+            base_model_name_or_path=model_id,
+            **config_kwargs,
+        )
+        model = get_peft_model(model, config)
+        model.eval()
+
+        # check that none of this raises an error
+        model(**X)
+
+        _skip_if_merging_not_supported(model_id, config_cls, config_kwargs)
+
+        model.merge_adapter(safe_merge=False)
+        model(**X)
+        model.unmerge_adapter()
+        model(**X)
+        model.merge_adapter(safe_merge=True)
+        model(**X)
+        model.unmerge_adapter()
+        model(**X)
+        model = model.merge_and_unload()
+        model(**X)
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_forward_bfloat16(self, test_name, model_id, config_cls, config_kwargs):
+        # The user manually sets the dtype of the base model to bf16 precision. This should not cause an error for the
+        # different PEFT methods.
+        try:
+            torch.zeros(1, dtype=torch.bfloat16)
+        except Exception:
+            # skip this test if float16 is not supported on this machine
+            pytest.skip(reason="Test requires bfloat16 support")
+
+        # skip on MacOS
+        if platform.system() == "Darwin":
+            pytest.skip(reason="MacOS does not support multiple ops in bfloat16")
+
+        X = self.prepare_inputs_for_testing()
+        model = self.transformers_class.from_pretrained(model_id, dtype=torch.bfloat16).to(self.torch_device)
+        model.dtype = torch.bfloat16
+        config = config_cls(
+            base_model_name_or_path=model_id,
+            **config_kwargs,
+        )
+        model = get_peft_model(model, config)
+        model.eval()
+
+        # check that none of this raises an error
+        model(**X)
+
+        _skip_if_merging_not_supported(model_id, config_cls, config_kwargs)
+
+        model.merge_adapter(safe_merge=False)
+        model(**X)
+        model.unmerge_adapter()
+        model(**X)
+        model.merge_adapter(safe_merge=True)
+        model(**X)
+        model.unmerge_adapter()
+        model(**X)
+        model = model.merge_and_unload()
+        model(**X)
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_forward_float16_no_autocast(self, test_name, model_id, config_cls, config_kwargs):
+        # Same as above but don't autocast adapter weights to float32 automatically
+        try:
+            torch.zeros(1, dtype=torch.float16)
+        except Exception:
+            # skip this test if float16 is not supported on this machine
+            pytest.skip(reason="Test requires float16 support")
+
+        # skip on MacOS
+        if platform.system() == "Darwin":
+            pytest.skip(reason="MacOS does not support multiple ops in float16")
+
+        X = self.prepare_inputs_for_testing()
+        model = self.transformers_class.from_pretrained(model_id, dtype=torch.float16).to(self.torch_device)
+        model.dtype = torch.float16
+        config = config_cls(
+            base_model_name_or_path=model_id,
+            **config_kwargs,
+        )
+        model = get_peft_model(model, config, autocast_adapter_dtype=False)
+        model.eval()
+
+        # check that none of this raises an error
+        model(**X)
+
+        _skip_if_merging_not_supported(model_id, config_cls, config_kwargs)
+
+        model.merge_adapter(safe_merge=False)
+        model(**X)
+        model.unmerge_adapter()
+        model(**X)
+        model.merge_adapter(safe_merge=True)
+        model(**X)
+        model.unmerge_adapter()
+        model(**X)
+        model = model.merge_and_unload()
+        model(**X)
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_forward_bfloat16_no_autocast(self, test_name, model_id, config_cls, config_kwargs):
+        # Same as above but don't autocast adapter weights to float32 automatically
+        try:
+            torch.zeros(1, dtype=torch.bfloat16)
+        except Exception:
+            # skip this test if float16 is not supported on this machine
+            pytest.skip(reason="Test requires bfloat16 support")
+
+        # skip on MacOS
+        if platform.system() == "Darwin":
+            pytest.skip(reason="MacOS does not support multiple ops in bfloat16")
+
+        X = self.prepare_inputs_for_testing()
+        model = self.transformers_class.from_pretrained(model_id, dtype=torch.bfloat16).to(self.torch_device)
+        model.dtype = torch.bfloat16
+        config = config_cls(
+            base_model_name_or_path=model_id,
+            **config_kwargs,
+        )
+        model = get_peft_model(model, config, autocast_adapter_dtype=False)
+        model.eval()
+
+        # check that none of this raises an error
+        model(**X)
+
+        _skip_if_merging_not_supported(model_id, config_cls, config_kwargs)
+
+        model.merge_adapter(safe_merge=False)
+        model(**X)
+        model.unmerge_adapter()
+        model(**X)
+        model.merge_adapter(safe_merge=True)
+        model(**X)
+        model.unmerge_adapter()
+        model(**X)
+        model = model.merge_and_unload()
+        model(**X)
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    @pytest.mark.parametrize("dtype", [torch.float16, torch.bfloat16, torch.float32])
+    @pytest.mark.parametrize("autocast_adapter_dtype", [True, False])
+    @pytest.mark.parametrize("low_cpu_mem_usage", [False, True])
+    def test_adapter_dtype_autocast(
+        self,
+        test_name,
+        model_id,
+        config_cls,
+        config_kwargs,
+        dtype,
+        autocast_adapter_dtype,
+        low_cpu_mem_usage,
+        tmp_path,
+    ):
+        """checks that the dtype of the PEFT adapter corresponds to the expected dtype.
+
+        Checks:
+        - get_peft_model
+        - add_adapter
+        - PeftModel.from_pretrained
+        - load_adapter
+        - with and without autocasting adapter dtype
+        - with and without low_cpu_mem_usage (which only makes sense for loading adapters)
+        """
+        if autocast_adapter_dtype and (config_cls == LNTuningConfig):
+            # LN Tuning basically copies the base weight and makes it trainable, hence it makes sense to keep the dtype
+            # of the base model weight.
+            pytest.skip("LNTuning is exempted from casting the adapter weights to float32")
+
+        if autocast_adapter_dtype:
+            expected_dtype = torch.float32
+        else:
+            expected_dtype = dtype
+
+        # AdaLoRA enforces a single trainable adapter, so the multi-adapter portion of this test
+        # is not applicable. target_parameters likewise disallows multiple adapters on the same
+        # parameter.
+        supports_multi_adapter = (
+            config_kwargs.get("target_parameters", None) is None and config_cls is not AdaLoraConfig
+        )
+
+        model = self.transformers_class.from_pretrained(model_id, dtype=dtype).to(self.torch_device)
+        config = config_cls(
+            base_model_name_or_path=model_id,
+            **config_kwargs,
+        )
+        model = get_peft_model(model, config, autocast_adapter_dtype=autocast_adapter_dtype)
+        if supports_multi_adapter:
+            model.add_adapter("other", config, autocast_adapter_dtype=autocast_adapter_dtype)
+        peft_params = [p for n, p in model.named_parameters() if model.prefix in n]
+        assert all(p.dtype == expected_dtype for p in peft_params)
+
+        model.save_pretrained(tmp_path)
+        del model
+
+        model = self.transformers_class.from_pretrained(model_id, dtype=dtype).to(self.torch_device)
+        model = PeftModel.from_pretrained(
+            model, tmp_path, autocast_adapter_dtype=autocast_adapter_dtype, low_cpu_mem_usage=low_cpu_mem_usage
+        )
+        if supports_multi_adapter:
+            model.load_adapter(
+                tmp_path / "other",
+                adapter_name="other",
+                autocast_adapter_dtype=autocast_adapter_dtype,
+                low_cpu_mem_usage=low_cpu_mem_usage,
+            )
+        peft_params = [p for n, p in model.named_parameters() if model.prefix in n]
+        assert all(p.dtype == expected_dtype for p in peft_params)
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_only_params_are_updated(self, test_name, model_id, config_cls, config_kwargs):
+        # An explicit test that when using an adapter on a custom model, only the adapter parameters are updated during
+        # training
+        if issubclass(config_cls, AdamssConfig):
+            # AdaMSS initializes B=0 which blocks gradient flow to A parameters.
+            config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+            # Use random float inputs to avoid ReLU dead zones that block gradient to specific subspaces.
+            X = {"X": torch.randn(9, 10, device=self.torch_device)}
+        elif issubclass(config_cls, UniLoraConfig):
+            config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+            X = self.prepare_inputs_for_testing()
+        else:
+            X = self.prepare_inputs_for_testing()
+
+        model = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+        config = config_cls(
+            base_model_name_or_path=model_id,
+            **config_kwargs,
+        )
+        model = get_peft_model(model, config)
+        model_before = copy.deepcopy(model)
+
+        is_monteclora = config_kwargs.get("monteclora_config", None) is not None
+
+        model.train()
+        lr = 0.5
+        if (
+            (config_kwargs.get("use_dora") and model_id == "EmbConv1D")
+            or issubclass(config_cls, VBLoRAConfig)
+            or issubclass(config_cls, HiraConfig)
+            or issubclass(config_cls, LilyConfig)
+            or issubclass(config_cls, AdamssConfig)
+        ):
+            # this high learning rate was found through testing to be necessary to avoid flakiness
+            lr = 100
+        elif "mha" in model_id.lower():
+            # we get exploding gradients with MHA when learning rate is too high
+            lr = 1e-3
+        elif issubclass(config_cls, GloraConfig):
+            # GLoRA keeps some factors at zero at init; a higher LR helps all adapter tensors move within a few steps.
+            lr = 50.0
+        elif is_monteclora:
+            lr = 1e-3
+        optimizer = torch.optim.SGD(model.parameters(), lr=lr)
+
+        # train at least 3 steps for all parameters to be updated (probably this is required because of symmetry
+        # breaking of some LoRA layers that are initialized with constants)
+        n_train_steps = 10 if issubclass(config_cls, GloraConfig) else 3
+        for _ in range(n_train_steps):
+            optimizer.zero_grad()
+            y_pred = model(**X)
+            loss = y_pred.sum()
+            if is_monteclora:
+                loss = loss + model._get_monteclora_loss()
+            loss.backward()
+            optimizer.step()
+
+        tol = 1e-4
+        params_before = dict(model_before.named_parameters())
+        params_after = dict(model.named_parameters())
+        assert params_before.keys() == params_after.keys()
+
+        for name, param_before in params_before.items():
+            param_after = params_after[name]
+            if "monteclora" in name.lower():
+                # MonteCLoRA's variational parameters are stochastic by construction (they get optimized
+                # via Monte Carlo sampling), so we don't include them in the strict allclose check below.
+                continue
+            if (model.prefix in name) or ("modules_to_save" in name) or ("token_adapter.trainable_tokens" in name):
+                # target_modules, modules_to_save and modules of `NewTokensWrapper` _are_ updated, except for adapter
+                # parameters that the variant intentionally freezes (e.g. MiCA freezes lora_B).
+                if not param_after.requires_grad:
+                    assert torch.equal(param_before, param_after)
+                else:
+                    assert not torch.allclose(param_before, param_after, atol=tol, rtol=tol)
+            else:
+                assert torch.allclose(param_before, param_after, atol=tol, rtol=tol)
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_save_load_roundtrip(self, test_name, model_id, config_cls, config_kwargs, tmp_path):
+        # An explicit test that when loading a trained model, the outputs from the forward pass remain the same
+        X = self.prepare_inputs_for_testing()
+        model = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+        with torch.inference_mode():
+            output_base = model(**X)
+
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        config = config_cls(
+            base_model_name_or_path=model_id,
+            **config_kwargs,
+        )
+        torch.manual_seed(0)
+        model = get_peft_model(model, config)
+        model.eval()
+        with torch.inference_mode():
+            output_before = model(**X)
+
+        # COFT constrains the rotation to stay close to the identity, so its effect on the output is small and the
+        # sanity check below needs tighter tolerances to detect it reliably across platforms
+        if (config_cls == OFTConfig) and config_kwargs.get("coft", False):
+            atol, rtol = 1e-6, 1e-6
+        else:
+            atol, rtol = 1e-5, 1e-5
+
+        # sanity check
+        assert not torch.allclose(output_base, output_before, atol=atol, rtol=rtol)
+
+        model.save_pretrained(tmp_path)
+        del model
+
+        model = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+        torch.manual_seed(54321)  # ensure that the seed is different from what was used when get_peft_model was called
+        model = PeftModel.from_pretrained(model, tmp_path)
+        with torch.inference_mode():
+            output_after = model(**X)
+
+        assert torch.allclose(output_before, output_after, atol=atol, rtol=rtol)
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_parameters_after_loading_model(self, test_name, model_id, config_cls, config_kwargs):
+        # An explicit test that when loading a trained model, the parameters are loaded correctly
+        # see issue #808
+        if issubclass(config_cls, UniLoraConfig):
+            config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+
+        X = self.prepare_inputs_for_testing()
+        model = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+        config = config_cls(
+            base_model_name_or_path=model_id,
+            **config_kwargs,
+        )
+        is_monteclora = config_kwargs.get("monteclora_config", None) is not None
+        model = get_peft_model(model, config)
+        model.train()
+
+        lr = 0.5
+        if config_kwargs.get("use_dora") or (config_cls == HiraConfig):
+            lr = 0.1  # otherwise we get nan
+        elif "mha" in model_id.lower():
+            lr = 1e-3  # we get exploding gradients with MHA when learning rate is too high
+        elif issubclass(config_cls, (VBLoRAConfig, RandLoraConfig, UniLoraConfig, OSFConfig)):
+            lr = 0.01  # otherwise we get nan
+        elif issubclass(config_cls, AdaLoraConfig):
+            lr = 1e-4  # AdaLoRA + init_lora_weights=False can blow up with multi-target SGD
+        elif issubclass(
+            config_cls, PveraConfig
+        ):  # needs a very small lr to not get nan in pvera_lambda_b due to high input values in this test (up to 90)
+            lr = 1e-6
+        elif is_monteclora:
+            lr = 1e-3
+        optimizer = torch.optim.SGD(model.parameters(), lr=lr)
+
+        # train at least 3 steps for all parameters to be updated (probably this is required because of symmetry
+        # breaking of some LoRA layers that are initialized with constants)
+        for _ in range(3):
+            optimizer.zero_grad()
+            y_pred = model(**X)
+            loss = y_pred.sum()
+            if is_monteclora:
+                loss = loss + model._get_monteclora_loss()
+            loss.backward()
+            optimizer.step()
+
+        tol = 1e-4
+        params_before = get_state_dict(model)
+        # note: no need to sanity check if parameters were updated at all, this
+        # is already covered in the previous test
+
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            model.save_pretrained(tmp_dirname)
+            model_from_pretrained = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+            model_from_pretrained = PeftModel.from_pretrained(model_from_pretrained, tmp_dirname)
+            params_after = get_state_dict(model_from_pretrained)
+
+            assert params_before.keys() == params_after.keys()
+            for name, param_before in params_before.items():
+                param_after = params_after[name]
+                assert torch.allclose(param_before, param_after, atol=tol, rtol=tol)
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_disable_adapters(self, test_name, model_id, config_cls, config_kwargs):
+        # Test that it's possible to disable the adapter, in which case the model output should be identical to that of
+        # the base model.
+        X = self.prepare_inputs_for_testing()
+        model = self.transformers_class.from_pretrained(model_id).to(self.torch_device).eval()
+        outputs_base = model(**X)
+
+        if issubclass(config_cls, (TrainableTokensConfig,)):
+            config_kwargs = config_kwargs.copy()
+            # override the default value and make PEFT operation a no-op
+            config_kwargs["init_weights"] = True
+        config = config_cls(
+            base_model_name_or_path=model_id,
+            **config_kwargs,
+        )
+        model = get_peft_model(model, config)
+        if issubclass(config_cls, VBLoRAConfig):
+            # Manually set the `vblora_vector_bank` to zero so that VB-LoRA functions as an identity operation.
+            torch.nn.init.zeros_(model.vblora_vector_bank["default"])
+        if issubclass(config_cls, AdaLoraConfig):
+            # AdaLoRA test entries use init_lora_weights=False (needed for gradient flow tests),
+            # so reset_lora_parameters did not zero `lora_E`. Zero it here so the SVD product
+            # is an identity at init.
+            for module in model.modules():
+                if hasattr(module, "lora_E") and "default" in module.lora_E:
+                    torch.nn.init.zeros_(module.lora_E["default"])
+        if issubclass(config_cls, UniLoraConfig):
+            # UniLora cannot use zero initialization by default because the adapter update is quadratic in theta_d.
+            # Zero it only for this identity check, then restore a trainable initialization before optimization.
+            _zero_unilora_theta_d(model)
+        model.eval()
+        outputs_before = model(**X)
+        # OSF uses SVD reconstruction which introduces small numerical differences
+        if issubclass(config_cls, OSFConfig):
+            assert torch.allclose(outputs_base, outputs_before, rtol=1e-4, atol=1e-4)
+        elif isinstance(config, DeftConfig) and config.para:
+            # PaRa (DEFT with para=True) is a removal-only method and is intentionally not identity-at-init, so a
+            # fresh adapter already changes the output; skip this precondition (the disable/enable checks below apply).
+            pass
+        else:
+            assert torch.allclose(outputs_base, outputs_before)
+
+        if issubclass(config_cls, VBLoRAConfig):
+            # initialize `vblora_vector_bank` so it can be trained
+            model._init_vblora_vector_bank(config, "default")
+        if issubclass(config_cls, AdaLoraConfig):
+            # Re-randomize `lora_E` so the adapter can be trained.
+            for module in model.modules():
+                if hasattr(module, "lora_E") and "default" in module.lora_E:
+                    torch.nn.init.normal_(module.lora_E["default"])
+        if issubclass(config_cls, UniLoraConfig):
+            _reset_unilora_theta_d(model, config)
+        if issubclass(config_cls, TinyLoraConfig):
+            # Re-initialize tinylora_v so it can be trained
+            model.base_model._init_tinylora_v(config, "default")
+        model.train()
+        # EmbConv1D is slow to learn for some reason
+        lr = 0.01 if model_id != "EmbConv1D" else 1.0
+        if isinstance(config, TrainableTokensConfig):
+            # TrainableTokens is only changing a small subset, so we need a higher lr to see the difference
+            lr = 2.0
+        if isinstance(config, PveraConfig):
+            lr = 1e-4  # needs smaller lr to not get nan
+        if isinstance(config, AdaLoraConfig):
+            lr = 1e-4  # AdaLoRA can blow up with multi-target SGD; use a smaller lr to avoid nan
+        optimizer = torch.optim.SGD(model.parameters(), lr=lr)
+
+        # train at least 3 steps for all parameters to be updated (probably this is required because of symmetry
+        # breaking of some LoRA layers that are initialized with constants)
+        for _ in range(3):
+            optimizer.zero_grad()
+            y_pred = model(**X)
+            y = torch.arange(len(y_pred)).to(self.torch_device) % 2
+            loss = nn.functional.nll_loss(y_pred, y)
+            loss.backward()
+            optimizer.step()
+
+        model.eval()
+        outputs_after = model(**X)
+
+        with model.disable_adapter():
+            outputs_disabled = model(**X)
+
+        # check that after leaving the disable_adapter context, everything is enabled again
+        outputs_enabled_after_disable = model(**X)
+
+        if self.torch_device == "cpu":
+            # LayerNorm is running float32 on cpu, so difference in outputs are smaller
+            rtol, atol = 1e-8, 1e-8
+        else:
+            rtol, atol = 1e-5, 1e-8
+        assert not torch.allclose(outputs_before, outputs_after, rtol=rtol, atol=atol)
+        # OSF uses SVD reconstruction which introduces small numerical differences
+        if issubclass(config_cls, OSFConfig):
+            assert torch.allclose(outputs_before, outputs_disabled, rtol=1e-4, atol=1e-4)
+        elif isinstance(config, DeftConfig) and config.para:
+            # PaRa is not identity-at-init, so disabling returns the base output (not `outputs_before`)
+            assert torch.allclose(outputs_base, outputs_disabled)
+        else:
+            assert torch.allclose(outputs_before, outputs_disabled)
+        assert torch.allclose(outputs_after, outputs_enabled_after_disable)
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_disable_adapters_with_merging(self, test_name, model_id, config_cls, config_kwargs):
+        _skip_if_merging_not_supported(model_id, config_cls, config_kwargs)
+
+        # same as test_disable_adapters, but with merging
+        X = self.prepare_inputs_for_testing()
+        model = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+
+        if isinstance(model, ModelEmbConv1D) and (self.torch_device != "cpu"):
+            # Make sure that we have a good signal-to-noise ratio
+            # since apparently CUDA ReLU clips the gradient at a
+            # certain point. On CPU, avoid this.
+            model.conv1d.weight.data += 10
+
+        config = config_cls(
+            base_model_name_or_path=model_id,
+            **config_kwargs,
+        )
+        model = get_peft_model(model, config)
+        if issubclass(config_cls, VBLoRAConfig):
+            # Manually set the `vblora_vector_bank` to zero so that VB-LoRA functions as an identity operation.
+            torch.nn.init.zeros_(model.vblora_vector_bank["default"])
+        if issubclass(config_cls, AdaLoraConfig):
+            # See note in test_disable_adapters: zero `lora_E` to make AdaLoRA an identity at init.
+            for module in model.modules():
+                if hasattr(module, "lora_E") and "default" in module.lora_E:
+                    torch.nn.init.zeros_(module.lora_E["default"])
+        if issubclass(config_cls, UniLoraConfig):
+            _zero_unilora_theta_d(model)
+        model.eval()
+        outputs_before = model(**X)
+
+        if issubclass(config_cls, VBLoRAConfig):
+            # initialize `vblora_vector_bank` so it can be trained
+            model._init_vblora_vector_bank(config, "default")
+        if issubclass(config_cls, AdaLoraConfig):
+            # Re-randomize `lora_E` so the adapter can be trained.
+            for module in model.modules():
+                if hasattr(module, "lora_E") and "default" in module.lora_E:
+                    torch.nn.init.normal_(module.lora_E["default"])
+        if issubclass(config_cls, UniLoraConfig):
+            _reset_unilora_theta_d(model, config)
+        if issubclass(config_cls, TinyLoraConfig):
+            # Re-initialize tinylora_v so it can be trained
+            model.base_model._init_tinylora_v(config, "default")
+        model.train()
+        if isinstance(config_cls, LNTuningConfig):
+            # LayerNorm tuning is slow to learn
+            lr = 1.0
+            optimizer = torch.optim.SGD(model.parameters(), lr=lr)
+        else:
+            # Adam optimizer since SGD isn't great for small models with IA3 + Conv1D
+            lr = 0.01
+            optimizer = torch.optim.Adam(model.parameters(), lr=lr)
+
+        # train at least 3 steps for all parameters to be updated (probably this is required because of symmetry
+        # breaking of some LoRA layers that are initialized with constants)
+        for _ in range(3):
+            optimizer.zero_grad()
+            y_pred = model(**X)
+            y = torch.arange(len(y_pred)).to(self.torch_device) % 2
+            loss = nn.functional.nll_loss(y_pred, y)
+            loss.backward()
+            optimizer.step()
+
+        model.eval()
+        outputs_unmerged = model(**X)
+        model.merge_adapter()
+        outputs_after = model(**X)
+
+        with model.disable_adapter():
+            outputs_disabled = model(**X)
+
+        # check that after leaving the disable_adapter context, everything is enabled again
+        outputs_enabled_after_disable = model(**X)
+
+        atol, rtol = 1e-5, 1e-5  # tolerances higher than defaults since merging introduces some numerical instability
+
+        conv_ids = ["Conv2d", "Conv3d", "Conv2d2"]
+        if issubclass(config_cls, (IA3Config, LoraConfig)) and model_id in conv_ids:  # more instability with Conv
+            atol, rtol = 1e-3, 1e-3
+
+        if issubclass(config_cls, OFTConfig):
+            atol, rtol = 1e-4, 1e-4
+
+        if config_kwargs.get("use_dora") and model_id == "EmbConv1D":
+            atol, rtol = 1e-4, 1e-4
+
+        # check that there is a difference in results after training
+        assert not torch.allclose(outputs_before, outputs_after, atol=atol, rtol=rtol)
+
+        if self.torch_device in ["mlu"] and model_id in conv_ids:
+            atol, rtol = 1e-3, 1e-2  # MLU
+
+        # unmerged or merged should make no difference
+        assert torch.allclose(outputs_after, outputs_unmerged, atol=atol, rtol=rtol)
+
+        # check that disabling adapters gives the same results as before training
+        # (skipped for PaRa: DEFT with para=True is not identity-at-init, so `outputs_before` already differs from the
+        # disabled/base output; the disable -> base behavior is covered by test_disable_adapters)
+        if not (isinstance(config, DeftConfig) and config.para):
+            assert torch.allclose(outputs_before, outputs_disabled, atol=atol, rtol=rtol)
+
+        # check that enabling + disabling adapters does not change the results
+        assert torch.allclose(outputs_after, outputs_enabled_after_disable, atol=atol, rtol=rtol)
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_disable_adapter_with_bias_warns(self, test_name, model_id, config_cls, config_kwargs):
+        # When training biases in lora, disabling adapters does not reset the biases, so the output is not what users
+        # might expect. Therefore, a warning should be given.
+
+        # Note: We test only with custom models since they run really fast. There is really no point in testing the same
+        # thing with decoder, encoder_decoder, etc.
+        if config_cls != LoraConfig or config_cls != BOFTConfig:
+            # skip this test for other configs as bias is specific to Lora
+            pytest.skip("Testing bias warnings only for LoraConfig or BOFTConfig")
+        if not issubclass(config_cls, (LoraConfig, BOFTConfig)):
+            pytest.skip("Bias argument is only supported for LoRA or BOFT models")
+
+        def run_with_disable(config_kwargs, bias):
+            config_kwargs = config_kwargs.copy()
+            config_kwargs["bias"] = bias
+            model = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+            peft_model = get_peft_model(model, config)
+            with peft_model.disable_adapter():
+                pass  # there is nothing to be done
+
+        if config_cls == LoraConfig:
+            # check that bias=all and bias=lora_only give a warning with the correct message
+            msg_start = "Careful, disabling adapter layers with bias configured to be"
+            with pytest.warns(UserWarning, match=msg_start):
+                run_with_disable(config_kwargs, bias="lora_only")
+            with pytest.warns(UserWarning, match=msg_start):
+                run_with_disable(config_kwargs, bias="all")
+
+        if config_cls == BOFTConfig:
+            # check that bias=all and bias=boft_only give a warning with the correct message
+            msg_start = "Careful, disabling adapter layers with bias configured to be"
+            with pytest.warns(UserWarning, match=msg_start):
+                run_with_disable(config_kwargs, bias="boft_only")
+            with pytest.warns(UserWarning, match=msg_start):
+                run_with_disable(config_kwargs, bias="all")
+
+        # For bias=none, there is no warning. Unfortunately, AFAIK unittest has no option to assert that no warning is
+        # given, therefore, we check that the unittest gives us an AssertionError if we check for a warning
+        bias_warning_was_given = False
+        try:
+            with pytest.warns(UserWarning) as cm:
+                run_with_disable(config_kwargs, bias="none")
+            # if we get here, it means there was no AssertionError, i.e. there are warnings -- let's check that they
+            # are not related to the bias setting
+            if any(warning.message.args[0].startswith(msg_start) for warning in cm.warnings):
+                bias_warning_was_given = True
+        except AssertionError:
+            # This is good, there was an AssertionError, i.e. there was no warning
+            pass
+        if bias_warning_was_given:
+            # This is bad, there was a warning about the bias when there should not have been any.
+            self.fail("There should be no warning when bias is set to 'none'")
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_active_adapter(self, test_name, model_id, config_cls, config_kwargs):
+        _skip_tests_with_multiple_adapters_with_target_parameters(config_cls, config_kwargs)
+        if config_kwargs.get("modules_to_save", []) or config_kwargs.get("trainable_token_indices", []):
+            pytest.skip("Multiple active adapters with modules_to_save/trainable_token_indices is not supported.")
+
+        model = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+        config = config_cls(
+            base_model_name_or_path=model_id,
+            **config_kwargs,
+        )
+        model = get_peft_model(model, config)
+        assert model.active_adapters == ["default"]
+        assert model.active_adapter == "default"
+
+        # at this stage, "default" is still the activate adapter, "other" is disabled
+        model.add_adapter("other", config)
+        assert model.active_adapters == ["default"]
+        assert model.active_adapter == "default"
+
+        # set "other" as the active adapter
+        model.set_adapter("other")
+        assert model.active_adapters == ["other"]
+        assert model.active_adapter == "other"
+
+        # set both adapters as active
+        # Note: On the PeftModel, there cannot be multiple active adapters, so we have to go through model.base_model
+        # instead.
+        model.base_model.set_adapter(["default", "other"])
+        # model.active_adapters works, as it delegates to the base_model
+        assert model.active_adapters == ["default", "other"]
+        # model.active_adapter would not work, thus we have to check the base_model directly
+        assert model.base_model.active_adapter == ["default", "other"]
+
+    @pytest.mark.parametrize("config_cls", ALL_PEFT_CONFIG_CLASSES)
+    def test_set_adapter_non_overlapping_modules(self, config_cls):
+        # Ensure that when setting multiple adapters, the active adapters are correctly being set, even if
+        # target_modules that only overlap partially. Apart from checking model.set_adapter, also check
+        # model.base_model.set_adapter. Normally, users wouldn't call this, but there are situations where this is
+        # required, e.g. activating multiple adapters at once cannot be done on the PeftModel but works on LoraModel
+        # etc.
+        if config_cls == TrainableTokensConfig:
+            pytest.skip(reason="Model has no embedding layer, skipping TrainableTokensConfig.")
+        if config_cls is AdaLoraConfig:
+            pytest.skip(reason="AdaLoRA supports only a single trainable adapter")
+        model = DeepMLP(size=256)  # a size that works with all adapters
+        extra_kwargs = {}
+        if config_cls == IA3Config:
+            extra_kwargs["feedforward_modules"] = []
+        # target_modules overlap partially
+        config0 = config_cls(target_modules=["layers.0.lin0", "layers.1.lin0"], **extra_kwargs)
+        config1 = config_cls(target_modules=["layers.1.lin0", "layers.2.lin0"], **extra_kwargs)
+        model = get_peft_model(model, config0, adapter_name="default")
+        model.add_adapter("other", config1)
+
+        # at this point, 'default' is active
+        assert model.base_model.active_adapters == ["default"]
+        # general note: for adapter layers like LoRA, the active_adapters can be "default" even if that layer has no
+        # adapter called "default", it will be simply ignored in that case
+        assert model.base_model.layers[0].lin0.active_adapters == ["default"]
+        assert model.base_model.layers[1].lin0.active_adapters == ["default"]
+        assert model.base_model.layers[2].lin0.active_adapters == ["default"]
+
+        # activate 'other'
+        model.set_adapter("other")
+        assert model.base_model.active_adapters == ["other"]
+        assert model.base_model.layers[0].lin0.active_adapters == ["other"]
+        assert model.base_model.layers[1].lin0.active_adapters == ["other"]
+        assert model.base_model.layers[2].lin0.active_adapters == ["other"]
+
+        # go back to 'default'
+        model.set_adapter("default")
+        assert model.base_model.active_adapters == ["default"]
+        assert model.base_model.layers[0].lin0.active_adapters == ["default"]
+        assert model.base_model.layers[1].lin0.active_adapters == ["default"]
+        assert model.base_model.layers[2].lin0.active_adapters == ["default"]
+
+        # also ensure that model.base_model.set_adapter works as expected
+        # activate 'other'
+        model.base_model.set_adapter(["other"])
+        assert model.base_model.active_adapters == ["other"]
+        assert model.base_model.layers[0].lin0.active_adapters == ["other"]
+        assert model.base_model.layers[1].lin0.active_adapters == ["other"]
+        assert model.base_model.layers[2].lin0.active_adapters == ["other"]
+
+        # go back to 'default'
+        model.base_model.set_adapter(["default"])
+        assert model.base_model.active_adapters == ["default"]
+        assert model.base_model.layers[0].lin0.active_adapters == ["default"]
+        assert model.base_model.layers[1].lin0.active_adapters == ["default"]
+        assert model.base_model.layers[2].lin0.active_adapters == ["default"]
+
+    @pytest.mark.parametrize("config_cls", ALL_PEFT_CONFIG_CLASSES)
+    def test_set_adapter_non_overlapping_modules_to_save(self, config_cls):
+        # This is similar to the previous test, but includes modules_to_save. Specifically, there was a bug where adding
+        # config1 would automatically activate the modules_to_save for 'other'
+        if config_cls == TrainableTokensConfig:
+            pytest.skip(reason="Trainable tokens does not support modules_to_save")
+        if config_cls is AdaLoraConfig:
+            pytest.skip(reason="AdaLoRA supports only a single trainable adapter")
+        model = DeepMLP(size=256)  # a size that works with all adapters
+        extra_kwargs = {}
+        if config_cls == IA3Config:
+            extra_kwargs["feedforward_modules"] = []
+        # targeting the same modules with modules_to_save:
+        config0 = config_cls(target_modules=["layers.0.lin0"], **extra_kwargs)
+        config1 = config_cls(target_modules=["layers.0.lin0"], modules_to_save=["layers.0.lin1"], **extra_kwargs)
+        model = get_peft_model(model, config0, adapter_name="default")
+        model.add_adapter("other", config1)
+
+        # at this point, 'default' is active
+        assert model.base_model.active_adapters == ["default"]
+        assert model.base_model.layers[0].lin0.active_adapters == ["default"]
+        assert model.base_model.layers[0].lin1.active_adapters == []
+        assert model.base_model.layers[0].lin1.modules_to_save.other.weight.requires_grad is False
+
+        # activate 'other'
+        model.set_adapter("other")
+        assert model.base_model.active_adapters == ["other"]
+        assert model.base_model.layers[0].lin0.active_adapters == ["other"]
+        assert model.base_model.layers[0].lin1.active_adapters == ["other"]
+        assert model.base_model.layers[0].lin1.modules_to_save.other.weight.requires_grad is True
+
+        # go back to 'default'
+        model.set_adapter("default")
+        assert model.base_model.active_adapters == ["default"]
+        assert model.base_model.layers[0].lin0.active_adapters == ["default"]
+        assert model.base_model.layers[0].lin1.active_adapters == []
+        assert model.base_model.layers[0].lin1.modules_to_save.other.weight.requires_grad is False
+
+        # also ensure that model.base_model.set_adapter works as expected
+        # activate 'other'
+        model.base_model.set_adapter(["other"])
+        assert model.base_model.active_adapters == ["other"]
+        assert model.base_model.layers[0].lin0.active_adapters == ["other"]
+        assert model.base_model.layers[0].lin1.active_adapters == ["other"]
+        assert model.base_model.layers[0].lin1.modules_to_save.other.weight.requires_grad is True
+
+        # go back to 'default'
+        model.base_model.set_adapter(["default"])
+        assert model.base_model.active_adapters == ["default"]
+        assert model.base_model.layers[0].lin0.active_adapters == ["default"]
+        assert model.base_model.layers[0].lin1.active_adapters == []
+        assert model.base_model.layers[0].lin1.modules_to_save.other.weight.requires_grad is False
+
+    def test_set_adapter_non_overlapping_trainable_token_indices(self):
+        # Same test as the previous one, but using trainable_token_indices instead of modules_to_save
+        model = ModelEmbConv1D()
+        # targeting the same modules with modules_to_save:
+        config0 = LoraConfig(target_modules=["lin0"])
+        config1 = LoraConfig(target_modules=["lin0"], trainable_token_indices={"emb": [0]})
+
+        model = get_peft_model(model, config0, adapter_name="default")
+        model.add_adapter("other", config1)
+
+        # at this point, 'default' is active
+        assert model.base_model.active_adapters == ["default"]
+        assert model.base_model.lin0.active_adapters == ["default"]
+        assert model.base_model.emb.active_adapters == []
+        assert model.base_model.model.emb.token_adapter.trainable_tokens_delta.other.requires_grad is False
+
+        # activate 'other'
+        model.set_adapter("other")
+        assert model.base_model.active_adapters == ["other"]
+        assert model.base_model.lin0.active_adapters == ["other"]
+        assert model.base_model.emb.active_adapters == ["other"]
+        assert model.base_model.model.emb.token_adapter.trainable_tokens_delta.other.requires_grad is True
+
+        # go back to 'default'
+        model.set_adapter("default")
+        assert model.base_model.active_adapters == ["default"]
+        assert model.base_model.lin0.active_adapters == ["default"]
+        assert model.base_model.emb.active_adapters == []
+        assert model.base_model.model.emb.token_adapter.trainable_tokens_delta.other.requires_grad is False
+
+        # also ensure that model.base_model.set_adapter works as expected
+        # activate 'other'
+        model.base_model.set_adapter(["other"])
+        assert model.base_model.active_adapters == ["other"]
+        assert model.base_model.lin0.active_adapters == ["other"]
+        assert model.base_model.emb.active_adapters == ["other"]
+        assert model.base_model.model.emb.token_adapter.trainable_tokens_delta.other.requires_grad is True
+
+        # go back to 'default'
+        model.base_model.set_adapter(["default"])
+        assert model.base_model.active_adapters == ["default"]
+        assert model.base_model.lin0.active_adapters == ["default"]
+        assert model.base_model.emb.active_adapters == []
+        assert model.base_model.model.emb.token_adapter.trainable_tokens_delta.other.requires_grad is False
+
+    @pytest.mark.parametrize("config_cls", ALL_PEFT_CONFIG_CLASSES)
+    def test_multiple_active_adapters_with_same_modules_to_save_raises(self, config_cls):
+        # When we have multiple adapters each with modules_to_save, we don't allow those to target the same layer, as
+        # module_to_save (unlike LoRA etc) is not additive.
+        if config_cls == TrainableTokensConfig:
+            pytest.skip(reason="Trainable tokens does not support modules_to_save")
+        if config_cls is AdaLoraConfig:
+            pytest.skip(reason="AdaLoRA supports only a single trainable adapter")
+        model = DeepMLP(size=256)  # a size that works with all adapters
+        extra_kwargs = {}
+        if config_cls == IA3Config:
+            extra_kwargs["feedforward_modules"] = []
+        # targeting the same modules with modules_to_save:
+        config0 = config_cls(target_modules=["layers.0.lin0"], modules_to_save=["layers.0.lin1"], **extra_kwargs)
+        config1 = config_cls(target_modules=["layers.0.lin0"], modules_to_save=["layers.0.lin1"], **extra_kwargs)
+        model = get_peft_model(model, config0, adapter_name="default")
+        # adding the adapter is fine
+        model.add_adapter("other", config1)
+
+        msg = "Only one adapter can be set at a time for ModulesToSaveWrapper"
+        with pytest.raises(ValueError, match=msg):
+            model.base_model.set_adapter(["default", "other"])
+
+    @pytest.mark.parametrize("config_cls", ALL_PEFT_CONFIG_CLASSES)
+    def test_multiple_active_adapters_with_overlapping_modules_to_save_raises(self, config_cls):
+        # same test as the previous one, but targeting multiple modules_to_save, some of which overlap
+        if config_cls == TrainableTokensConfig:
+            pytest.skip(reason="Trainable tokens does not support modules_to_save")
+        if config_cls is AdaLoraConfig:
+            pytest.skip(reason="AdaLoRA supports only a single trainable adapter")
+        model = DeepMLP(size=256)  # a size that works with all adapters
+        extra_kwargs = {}
+        if config_cls == IA3Config:
+            extra_kwargs["feedforward_modules"] = []
+        # targeting the overlapping modules with modules_to_save:
+        config0 = config_cls(
+            target_modules=["layers.0.lin0"], modules_to_save=["layers.0.lin1", "layers.1.lin1"], **extra_kwargs
+        )
+        config1 = config_cls(
+            target_modules=["0layers..lin0"], modules_to_save=["layers.2.lin1", "layers.1.lin1"], **extra_kwargs
+        )
+        model = get_peft_model(model, config0, adapter_name="default")
+        # adding the adapter is fine
+        model.add_adapter("other", config1)
+
+        msg = "Only one adapter can be set at a time for ModulesToSaveWrapper"
+        with pytest.raises(ValueError, match=msg):
+            model.base_model.set_adapter(["default", "other"])
+
+    @pytest.mark.parametrize("config_cls", ALL_PEFT_CONFIG_CLASSES)
+    def test_multiple_active_adapters_with_different_modules_to_save_works(self, config_cls):
+        # same test as the previous one but targeting distinct modules_to_save; this is fine
+        if config_cls == TrainableTokensConfig:
+            pytest.skip(reason="Trainable tokens does not support modules_to_save")
+        if config_cls is AdaLoraConfig:
+            pytest.skip(reason="AdaLoRA supports only a single trainable adapter")
+        model = DeepMLP(size=256)  # a size that works with all adapters
+        extra_kwargs = {}
+        if config_cls == IA3Config:
+            extra_kwargs["feedforward_modules"] = []
+        # targeting the different modules with modules_to_save:
+        config0 = config_cls(target_modules=["layers.0.lin0"], modules_to_save=["layers.0.lin1"], **extra_kwargs)
+        config1 = config_cls(target_modules=["layers.0.lin0"], modules_to_save=["layers.1.lin1"], **extra_kwargs)
+        model = get_peft_model(model, config0, adapter_name="default")
+        # adding the adapter is fine
+        model.add_adapter("other", config1)
+        model.base_model.set_adapter(["default", "other"])  # does not raise
+
+        assert model.base_model.model.layers[0].lin1.active_adapters == ["default"]
+        assert model.base_model.model.layers[1].lin1.active_adapters == ["other"]
+
+    def test_multiple_active_adapters_with_same_trainable_token_indices_raises(self):
+        # Same test as test_multiple_active_adapters_with_same_modules_to_save_raises but with trainable_token_indices
+        # instead of modules_to_save.
+        model = ModelEmbConv1D()
+        # targeting the same modules with modules_to_save:
+        config0 = LoraConfig(target_modules=["lin0"], trainable_token_indices={"emb": [0]})
+        config1 = LoraConfig(target_modules=["lin0"], trainable_token_indices={"emb": [0]})
+        model = get_peft_model(model, config0, adapter_name="default")
+        # adding the adapter is fine
+        model.add_adapter("other", config1)
+
+        msg = "Only one adapter can be set at a time for TrainableTokensWrapper"
+        with pytest.raises(ValueError, match=msg):
+            model.base_model.set_adapter(["default", "other"])
+
+    def test_multiple_active_adapters_with_different_trainable_token_indices_works(self):
+        # Same test as the previous one but targeting different embedding layers should work
+        class MyModel(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.emb0 = nn.Embedding(10, 10)
+                self.emb1 = nn.Embedding(10, 10)
+                self.lin0 = nn.Linear(10, 10)
+
+        model = MyModel()
+        # targeting the same modules with modules_to_save:
+        config0 = LoraConfig(target_modules=["lin0"], trainable_token_indices={"emb0": [0]})
+        config1 = LoraConfig(target_modules=["lin0"], trainable_token_indices={"emb1": [0]})
+        model = get_peft_model(model, config0, adapter_name="default")
+        # adding the adapter is fine
+        model.add_adapter("other", config1)
+        model.base_model.set_adapter(["default", "other"])  # does not raise
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_disable_adapters_exiting_context_restores_previous_state(
+        self, test_name, model_id, config_cls, config_kwargs
+    ):
+        # Test that when we exit the disable_adapter context, we correctly restore the enabled state of the modules as
+        # they were before the context.
+        model = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+        config = config_cls(
+            base_model_name_or_path=model_id,
+            **config_kwargs,
+        )
+        model = get_peft_model(model, config)
+        tuner_modules = [module for module in model.modules() if isinstance(module, BaseTunerLayer)]
+
+        # all layers should be enabled
+        assert all(not module.disable_adapters for module in tuner_modules)
+        with model.disable_adapter():
+            pass
+        # this should not change after exiting the context
+        assert all(not module.disable_adapters for module in tuner_modules)
+
+        # now disable all layers
+        model.disable_adapter_layers()
+        assert all(module.disable_adapters for module in tuner_modules)
+        with model.disable_adapter():
+            pass
+        assert all(module.disable_adapters for module in tuner_modules)
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_disable_adapters_exiting_context_irregular_state(self, test_name, model_id, config_cls, config_kwargs):
+        # When we have a model where some adapters are enabled and others are disabled, we should get a warning when
+        # entering the disable_adapter context because we cannot correctly restore the state of the adapters from
+        # before the context. After exiting the context, all adapters will be enabled, which is the status quo of how
+        # we deal with this.
+        model = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+        config = config_cls(
+            base_model_name_or_path=model_id,
+            **config_kwargs,
+        )
+        model = get_peft_model(model, config)
+        tuner_modules = [module for module in model.modules() if isinstance(module, BaseTunerLayer)]
+
+        # now we mix the states, some enabled some not
+        if len(tuner_modules) < 2:
+            # next check only works with more than 1 tuner module
+            return
+
+        # disable a single layer
+        tuner_modules[0].enable_adapters(False)
+        # sanity check that we have both enabled and disabled layers
+        assert {module.disable_adapters for module in tuner_modules} == {True, False}
+        # check that we get a warning with irregular states
+        msg = "The model contains some adapter layers that are enabled and others that are disabled"
+        with pytest.warns(UserWarning, match=msg), model.disable_adapter():
+            pass
+
+        # when encountering irregular adapters, we enable all adapters at the end of the context
+        assert all(not module.disable_adapters for module in tuner_modules)
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_delete_adapter(self, test_name, model_id, config_cls, config_kwargs):
+        _skip_tests_with_multiple_adapters_with_target_parameters(config_cls, config_kwargs)
+        self._test_delete_adapter(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_delete_adapter_properly_cleans_up_after_itself(self, test_name, model_id, config_cls, config_kwargs):
+        # Generic guard against dangling per-adapter state: after `delete_adapter`, no adapter-specific attributes
+        # should remain on the model or its tuner layers. This test discovers every dict-like per-adapter container
+        # automatically, so a newly added PEFT method that forgets to register one is still caught here.
+        model = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+        config = config_cls(**config_kwargs)
+        model = get_peft_model(model, config, adapter_name="foobar")
+
+        def get_dict_like_attrs(obj):
+            for attr_name in dir(obj):
+                if attr_name.startswith("_"):
+                    continue
+                try:
+                    attr = getattr(obj, attr_name)
+                except AttributeError:
+                    continue
+                is_dict_like = (
+                    callable(getattr(attr, "keys", None))
+                    and hasattr(attr, "__getitem__")
+                    and hasattr(attr, "__contains__")
+                )
+                if not is_dict_like:
+                    continue
+                if "foobar" in attr:
+                    yield attr_name, attr
+
+        # collect dict-like attributes holding the adapter before deletion
+        dict_attrs = list(get_dict_like_attrs(model))
+        for module in model.modules():
+            if isinstance(module, BaseTunerLayer):
+                dict_attrs.extend(list(get_dict_like_attrs(module)))
+
+        # sanity check: there should be at least one such attribute
+        assert dict_attrs, f"No dict-like attributes found on {config.peft_type}, please check the test"
+
+        model.delete_adapter(adapter_name="foobar")
+        dangling_attrs = [attr_name for attr_name, attr in dict_attrs if "foobar" in attr]
+        assert not dangling_attrs, f"Found dangling attributes after adapter deletion: {sorted(dangling_attrs)}"
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_delete_inactive_adapter(self, test_name, model_id, config_cls, config_kwargs):
+        _skip_tests_with_multiple_adapters_with_target_parameters(config_cls, config_kwargs)
+        self._test_delete_inactive_adapter(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_delete_unknown_adapter_raises(self, test_name, model_id, config_cls, config_kwargs):
+        self._test_delete_unknown_adapter_raises(model_id, config_cls, config_kwargs)
+
+    def test_delete_adapter_with_multiple_adapters_works(self):
+        # Add 3 adapters, delete the active one, the next one should be active, delete the inactive one, the active one
+        # should stay the same.
+        config0 = LoraConfig(target_modules=["lin0"])
+        config1 = LoraConfig(target_modules=["lin0"])
+        config2 = LoraConfig(target_modules=["lin0"])
+        model = get_peft_model(MLP(), config0, adapter_name="adapter0").to(self.torch_device)
+        model.add_adapter("adapter1", config1)
+        model.add_adapter("adapter2", config2)
+
+        inputs = self.prepare_inputs_for_testing()
+        assert model.active_adapters == ["adapter0"]
+        model(**inputs)  # does not raise
+
+        # delete the active adapter, next one should become active
+        model.delete_adapter("adapter0")
+        assert model.active_adapters == ["adapter1"]
+        model(**inputs)  # does not raise
+
+        # delete an inactive adapter, should not affect the active adapter
+        model.delete_adapter("adapter2")
+        assert model.active_adapters == ["adapter1"]
+        model(**inputs)  # does not raise
+
+    def test_delete_adapter_multiple_adapters_with_modules_to_save(self):
+        # There are 3 adapters. Adapter 0 has modules_to_save. Delete it, we should switch to adapter 1, which does not
+        # have modules_to_save. Then, we delete it too, switching to adapter 2, which has modules_to_save. Finally, we
+        # delete the last adapter (state is updated but forward is no longer possible).
+        model = MLP()
+        inputs = self.prepare_inputs_for_testing()
+
+        config0 = LoraConfig(target_modules=["lin0"], modules_to_save=["lin1"])
+        config1 = LoraConfig(target_modules=["lin0"])
+        config2 = LoraConfig(target_modules=["lin0"], modules_to_save=["lin1"])
+        model = get_peft_model(model, config0, adapter_name="adapter0").to(self.torch_device)
+        model.add_adapter("adapter1", config1)
+        model.add_adapter("adapter2", config2)
+
+        assert model.active_adapters == ["adapter0"]
+        assert model.modules_to_save == {"lin1"}
+        assert set(model.base_model.model.lin1.modules_to_save) == {"adapter0", "adapter2"}
+        model(**inputs)  # does not raise
+
+        # delete active adapter, should switch to the next adapter (which does not have modules_to_save)
+        model.delete_adapter("adapter0")
+        assert model.active_adapters == ["adapter1"]
+        assert model.modules_to_save == {"lin1"}
+        assert set(model.base_model.model.lin1.modules_to_save) == {"adapter2"}
+        model(**inputs)  # does not raise
+
+        # delete active adapter, should switch to the next adapter (which *does* have modules_to_save)
+        model.delete_adapter("adapter1")
+        assert model.active_adapters == ["adapter2"]
+        assert model.modules_to_save == {"lin1"}
+        assert set(model.base_model.model.lin1.modules_to_save) == {"adapter2"}
+        model(**inputs)  # does not raise
+
+        # delete last adapter
+        model.delete_adapter("adapter2")
+        assert model.active_adapters == []
+        assert model.modules_to_save is None
+        assert set(model.base_model.model.lin1.modules_to_save) == set()
+
+    def test_delete_adapter_multiple_adapters_with_trainable_token_indices(self):
+        # Same as the previous test, just using trainable_token_indices instead of modules_to_save
+        # Note that we need to use a transformers model for trainable_token_indices
+        model = AutoModelForCausalLM.from_pretrained("peft-internal-testing/tiny-random-OPTForCausalLM")
+        inputs = {"input_ids": torch.arange(10).view(-1, 1).to(self.torch_device)}
+
+        config0 = LoraConfig(target_modules=["q_proj"], trainable_token_indices=[0, 1])
+        config1 = LoraConfig(target_modules=["q_proj"])
+        config2 = LoraConfig(target_modules=["q_proj"], trainable_token_indices=[1, 3])
+        model = get_peft_model(model, config0, adapter_name="adapter0").to(self.torch_device)
+        model.add_adapter("adapter1", config1)
+        model.add_adapter("adapter2", config2)
+
+        embed_tokens = model.base_model.model.model.decoder.embed_tokens
+        lm_head = model.base_model.model.lm_head
+
+        assert model.active_adapters == ["adapter0"]
+        assert set(embed_tokens.token_adapter.trainable_tokens_delta) == {"adapter0", "adapter2"}
+        assert set(embed_tokens.token_adapter.trainable_tokens_original) == {"adapter0", "adapter2"}
+        assert set(lm_head.token_adapter.trainable_tokens_delta) == {"adapter0", "adapter2"}
+        assert set(lm_head.token_adapter.trainable_tokens_original) == {"adapter0", "adapter2"}
+        model(**inputs)  # does not raise
+
+        # delete active adapter, should switch to the next adapter (which does not have modules_to_save)
+        model.delete_adapter("adapter0")
+        assert model.active_adapters == ["adapter1"]
+        assert set(embed_tokens.token_adapter.trainable_tokens_delta) == {"adapter2"}
+        assert set(embed_tokens.token_adapter.trainable_tokens_original) == {"adapter2"}
+        assert set(lm_head.token_adapter.trainable_tokens_delta) == {"adapter2"}
+        assert set(lm_head.token_adapter.trainable_tokens_original) == {"adapter2"}
+        model(**inputs)  # does not raise
+
+        # delete active adapter, should switch to the next adapter (which *does* have modules_to_save)
+        model.delete_adapter("adapter1")
+        assert model.active_adapters == ["adapter2"]
+        assert set(embed_tokens.token_adapter.trainable_tokens_delta) == {"adapter2"}
+        assert set(embed_tokens.token_adapter.trainable_tokens_original) == {"adapter2"}
+        assert set(lm_head.token_adapter.trainable_tokens_delta) == {"adapter2"}
+        assert set(lm_head.token_adapter.trainable_tokens_original) == {"adapter2"}
+        model(**inputs)  # does not raise
+
+        # delete last adapter
+        model.delete_adapter("adapter2")
+        assert model.active_adapters == []
+        assert set(embed_tokens.token_adapter.trainable_tokens_delta) == set()
+        assert set(embed_tokens.token_adapter.trainable_tokens_original) == set()
+        assert set(lm_head.token_adapter.trainable_tokens_delta) == set()
+        assert set(lm_head.token_adapter.trainable_tokens_original) == set()
+
+    @pytest.mark.parametrize("test_name, model_id, config_cls, config_kwargs", TEST_CASES)
+    def test_adding_multiple_adapters_with_bias_raises(self, test_name, model_id, config_cls, config_kwargs):
+        self._test_adding_multiple_adapters_with_bias_raises(model_id, config_cls, config_kwargs)
+
+    @staticmethod
+    def _check_requires_grad(module, adapter_name, requires_grad):
+        # a bit of a clumsy way to test requires_grad on the PEFT parameters
+        for name in module.adapter_layer_names:
+            module_dict = getattr(module, name)
+            if adapter_name not in module_dict:
+                continue
+            attr = module_dict[adapter_name]
+            if isinstance(attr, nn.Module):
+                for param in attr.parameters():
+                    assert param.requires_grad == requires_grad
+            else:  # it's an nn.Parameter
+                assert attr.requires_grad == requires_grad
+
+    @pytest.mark.parametrize("config_cls", ALL_PEFT_CONFIG_CLASSES)
+    def test_set_requires_grad(self, config_cls):
+        # checks that the model.set_requires_grad method works as expected
+        if config_cls == TrainableTokensConfig:
+            pytest.skip(
+                "TrainableTokensConfig has a separate test for set_requires_grad, as it needs a different model."
+            )
+        if config_cls is AdaLoraConfig:
+            pytest.skip("AdaLoRA supports only a single trainable adapter")
+        config_kwargs = {"target_modules": ["layers.0.lin0"]}
+        if config_cls == IA3Config:
+            config_kwargs["feedforward_modules"] = []
+        config0 = config_cls(**config_kwargs)
+        model = DeepMLP(size=256)  # a size that works with all adapters
+        model = get_peft_model(model, config0, adapter_name="adapter0").eval()
+
+        # check that it works with a single adapter
+        self._check_requires_grad(model.base_model.model.layers[0].lin0, adapter_name="adapter0", requires_grad=True)
+
+        # add another adapter with two target modules and with modules_to_save
+        config_kwargs["target_modules"] = ["layers.0.lin0", "layers.1.lin0"]
+        config_kwargs["modules_to_save"] = ["layers.2.lin0"]
+        config1 = config_cls(**config_kwargs)
+        model.add_adapter("adapter1", config1)
+
+        # adapter0 still has requires_grad=True, adapter1 has requires_grad=False
+        self._check_requires_grad(model.base_model.model.layers[0].lin0, adapter_name="adapter0", requires_grad=True)
+        self._check_requires_grad(model.base_model.model.layers[0].lin0, adapter_name="adapter1", requires_grad=False)
+        self._check_requires_grad(model.base_model.model.layers[1].lin0, adapter_name="adapter1", requires_grad=False)
+        self._check_requires_grad(model.base_model.model.layers[2].lin0, adapter_name="adapter1", requires_grad=False)
+
+        # enable grad for adapter1; adapter0 is unaffected
+        model.set_requires_grad(adapter_names="adapter1")
+        self._check_requires_grad(model.base_model.model.layers[0].lin0, adapter_name="adapter0", requires_grad=True)
+        self._check_requires_grad(model.base_model.model.layers[0].lin0, adapter_name="adapter1", requires_grad=True)
+        self._check_requires_grad(model.base_model.model.layers[1].lin0, adapter_name="adapter1", requires_grad=True)
+        self._check_requires_grad(model.base_model.model.layers[2].lin0, adapter_name="adapter1", requires_grad=True)
+
+        # disable adapter for both
+        model.set_requires_grad(adapter_names=["adapter0", "adapter1"], requires_grad=False)
+        self._check_requires_grad(model.base_model.model.layers[0].lin0, adapter_name="adapter0", requires_grad=False)
+        self._check_requires_grad(model.base_model.model.layers[0].lin0, adapter_name="adapter1", requires_grad=False)
+        self._check_requires_grad(model.base_model.model.layers[1].lin0, adapter_name="adapter1", requires_grad=False)
+
+    def test_set_requires_grad_trainable_tokens(self):
+        # same as test_set_requires_grad for trainable tokens
+        class EmbModel(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.emb0 = nn.Embedding(10, 10)
+                self.emb1 = nn.Embedding(10, 10)
+
+        config_kwargs = {"target_modules": ["emb0"], "token_indices": [0, 2, 4]}
+        config0 = TrainableTokensConfig(**config_kwargs)
+        model = EmbModel()
+        model = get_peft_model(model, config0, adapter_name="adapter0").eval()
+
+        # check that it works with a single adapter
+        self._check_requires_grad(model.base_model.model.emb0, adapter_name="adapter0", requires_grad=True)
+
+        # add another adapter which targets 2 embedding layers
+        config_kwargs["target_modules"] = ["emb0", "emb1"]
+        config1 = TrainableTokensConfig(**config_kwargs)
+        model.add_adapter("adapter1", config1)
+
+        # adapter0 still has requires_grad=True, adapter1 has requires_grad=False
+        self._check_requires_grad(model.base_model.model.emb0, adapter_name="adapter0", requires_grad=True)
+        self._check_requires_grad(model.base_model.model.emb0, adapter_name="adapter1", requires_grad=False)
+        self._check_requires_grad(model.base_model.model.emb1, adapter_name="adapter1", requires_grad=False)
+
+        # enable grad for adapter1; adapter0 is unaffected
+        model.set_requires_grad(adapter_names="adapter1")
+        self._check_requires_grad(model.base_model.model.emb0, adapter_name="adapter0", requires_grad=True)
+        self._check_requires_grad(model.base_model.model.emb0, adapter_name="adapter1", requires_grad=True)
+        self._check_requires_grad(model.base_model.model.emb1, adapter_name="adapter1", requires_grad=True)
+
+        # disable adapter for both
+        model.set_requires_grad(adapter_names=["adapter0", "adapter1"], requires_grad=False)
+        self._check_requires_grad(model.base_model.model.emb0, adapter_name="adapter0", requires_grad=False)
+        self._check_requires_grad(model.base_model.model.emb0, adapter_name="adapter1", requires_grad=False)
+        self._check_requires_grad(model.base_model.model.emb1, adapter_name="adapter1", requires_grad=False)
+
+    def test_weight_bias_attributes(self):
+        model = MLP()
+        config = LoraConfig(target_modules=["lin0"])
+        model = get_peft_model(model, config)
+        assert hasattr(model.base_model.model.lin0, "weight")
+        assert hasattr(model.base_model.model.lin0, "bias")
+
+    def test_multiple_adapters_automatic_modules_to_save(self):
+        # See issue 1574
+        # When we use certain task types, PeftModel.modules_to_save is automatically updated to include some extra
+        # layers not specified in the PeftConfig. This attribute should be honored for all adapters, not just for
+        # the default adapter.
+        config0 = LoraConfig(task_type=TaskType.SEQ_CLS)
+        config1 = LoraConfig(task_type=TaskType.SEQ_CLS)
+        model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased")
+        model = get_peft_model(model, config0)
+        # sanity check
+        assert model.modules_to_save
+
+        model.add_adapter("other", config1)
+        assert "default" in model.base_model.classifier.modules_to_save
+        assert "other" in model.base_model.classifier.modules_to_save
+
+    @pytest.mark.parametrize(
+        "config_cls",
+        [IA3Config, BeftConfig, FrodConfig, LoHaConfig, LoKrConfig, LoraConfig, HRAConfig, ShiraConfig, MissConfig],
+    )
+    def test_multiple_adapters_mixed_modules_to_save(self, config_cls):
+        # See issue 1574
+        # Check that we can have a model where one adapter has modules_to_save and the other doesn't. It should be
+        # possible to switch between those adapters and to use them.
+        if hasattr(config_cls, "feedforward_modules"):  # IA³
+            config_cls = partial(config_cls, feedforward_modules=["lin0"])
+
+        if config_cls == MissConfig:
+            config_cls = partial(config_cls, r=2)
+        if config_cls == ShiraConfig:
+            config_cls = partial(config_cls, r=1)
+
+        config0 = config_cls(target_modules=["lin0"], modules_to_save=["lin1"])
+        config1 = config_cls(target_modules=["lin0"])
+        model = MLP()
+        model = get_peft_model(model, config0).to(self.torch_device)
+        model.add_adapter("other", config1)
+
+        assert "default" in model.base_model.lin1.modules_to_save
+        assert "other" not in model.base_model.lin1.modules_to_save
+
+        # check that switching adapters and predicting does not raise
+        inputs = self.prepare_inputs_for_testing()
+        # "default" adapter is active
+        model(**inputs)
+        # switch to "other" adapter
+        model.set_adapter("other")
+        model(**inputs)
+
+    @pytest.mark.parametrize(
+        "config_cls",
+        [IA3Config, BeftConfig, FrodConfig, LoHaConfig, LoKrConfig, LoraConfig, HRAConfig, ShiraConfig],
+    )
+    def test_multiple_adapters_mixed_modules_to_save_order_switched(self, config_cls):
+        # See issue 1574
+        # Same test as test_multiple_adapters_mixed_modules_to_save, but this time the 2nd adapter has modules_to_save.
+        if hasattr(config_cls, "feedforward_modules"):  # IA³
+            config_cls = partial(config_cls, feedforward_modules=["lin0"])
+
+        if config_cls == MissConfig:
+            config_cls = partial(config_cls, r=2)
+        if config_cls == ShiraConfig:
+            config_cls = partial(config_cls, r=1)
+
+        config0 = config_cls(target_modules=["lin0"])
+        config1 = config_cls(target_modules=["lin0"], modules_to_save=["lin1"])
+        model = MLP()
+        model = get_peft_model(model, config0).to(self.torch_device)
+        model.add_adapter("other", config1)
+
+        assert "default" not in model.base_model.lin1.modules_to_save
+        assert "other" in model.base_model.lin1.modules_to_save
+
+        # check that switching adapters and predicting does not raise
+        inputs = self.prepare_inputs_for_testing()
+        # "default" adapter is active
+        model(**inputs)
+        # switch to "other" adapter
+        model.set_adapter("other")
+        model(**inputs)
+
+    def test_multiple_adapters_mixed_modules_to_save_merging_adapters(self):
+        # See issue 1574
+        # This test is similar to test_multiple_adapters_mixed_modules_to_save, but it also checks that merging adapter
+        # weights works when one adapter has a modules_to_save and the other hasn't
+        config0 = LoraConfig(target_modules=["lin0"], modules_to_save=["lin1"])
+        config1 = LoraConfig(target_modules=["lin0"])
+        model = MLP()
+        model = get_peft_model(model, config0).to(self.torch_device)
+        model.add_adapter("other", config1)
+
+        # check that this does not raise
+        model.add_weighted_adapter(["default", "other"], weights=[1.0, 1.0], adapter_name="merged")
+
+        # since one of the adapters that was merged has a modules_to_save, that one should be used for the merged
+        # adapter
+        assert "default" in model.base_model.model.lin1.modules_to_save
+        assert "other" not in model.base_model.model.lin1.modules_to_save
+        assert "merged" in model.base_model.model.lin1.modules_to_save
+
+        # check that using the merged adapter does not raise
+        model.set_adapter("merged")
+        inputs = self.prepare_inputs_for_testing()
+        model(**inputs)
+
+    def test_multiple_adapters_same_modules_to_save_merging_adapters_raises(self):
+        # See issue 1574
+        # This test is similar to test_multiple_adapters_mixed_modules_to_save_merging_adapters but here the two
+        # adapters target the same module with modules_to_save. In this case, trying to merge the adapter weights
+        # should raise an error.
+        config0 = LoraConfig(target_modules=["lin0"], modules_to_save=["lin1"])
+        config1 = LoraConfig(target_modules=["lin0"], modules_to_save=["lin1"])
+        model = MLP()
+        model = get_peft_model(model, config0).to(self.torch_device)
+        model.add_adapter("other", config1)
+
+        msg = re.escape(
+            "Cannot add weighted adapters if they target the same module with modules_to_save, but found 1 such "
+            "instance(s)."
+        )
+        with pytest.raises(ValueError, match=msg):
+            model.add_weighted_adapter(["default", "other"], weights=[1.0, 1.0], adapter_name="merged")
+
+    def test_multiple_adapters_seq_cls_mixed_modules_to_save_merging_adapters(self):
+        # See issue 1574
+        # This test is similar to test_multiple_adapters_mixed_modules_to_save_merging_adapters but uses a SEQ_CLS
+        # model like in test_multiple_adapters_automatic_modules_to_save. This should raise an error because the same
+        # module is implicitly targeted by modules_to_save twice.
+        config0 = LoraConfig(task_type=TaskType.SEQ_CLS)
+        config1 = LoraConfig(task_type=TaskType.SEQ_CLS)
+        model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased")
+        model = get_peft_model(model, config0)
+        model.add_adapter("other", config1)
+
+        msg = re.escape(
+            "Cannot add weighted adapters if they target the same module with modules_to_save, but found 1 such "
+            "instance(s)."
+        )
+        with pytest.raises(ValueError, match=msg):
+            model.add_weighted_adapter(["default", "other"], weights=[1.0, 1.0], adapter_name="merged")
+
+    @pytest.mark.parametrize(
+        "config_cls", [IA3Config, BeftConfig, LoHaConfig, LoKrConfig, LoraConfig, HRAConfig, MissConfig]
+    )
+    def test_add_weighted_adapter_cat_with_rank_pattern(self, config_cls):
+        # Fixes a bug described in #2512, which resulted from the rank_pattern not being taken into account
+        config0 = LoraConfig(target_modules=["lin0", "lin1"], r=8, rank_pattern={"lin0": 2})
+        config1 = LoraConfig(target_modules=["lin0", "lin1"], r=8, rank_pattern={"lin0": 16})
+        model = MLP()
+        model = get_peft_model(model, config0).to(self.torch_device)
+        model.add_adapter("other", config1)
+        model.add_weighted_adapter(
+            ["default", "other"], weights=[1.0, 1.0], adapter_name="merged", combination_type="cat"
+        )
+
+    def test_add_weighted_adapter_negative_weight_negates_adapter(self):
+        # Test that weight=-1.0 properly negates an adapter
+        torch.manual_seed(42)
+        model = MLP()
+        config = LoraConfig(target_modules=["lin0"], init_lora_weights=False)
+        model = get_peft_model(model, config, adapter_name="adapter1")
+
+        # Create merged adapter with weight=-1.0
+        model.add_weighted_adapter(
+            adapters=["adapter1"],
+            weights=[-1.0],
+            adapter_name="merged_negative",
+            combination_type="linear",
+        )
+
+        for module in model.modules():
+            if isinstance(module, lora.LoraLayer):
+                dw_adapter1 = module.get_delta_weight("adapter1")
+                dw_negative = module.get_delta_weight("merged_negative")
+                assert torch.allclose(dw_adapter1, -dw_negative, atol=1e-6)
+
+    def test_add_weighted_adapter_subtraction_with_negative_weights(self):
+        # Test that merging two identical adapters with weights [1.0, -1.0] results in approximately zero weights
+        model = MLP()
+        config = LoraConfig(target_modules=["lin0"], init_lora_weights=False)
+
+        # Create two identical adapters by using the same seed
+        torch.manual_seed(42)
+        model = get_peft_model(model, config, adapter_name="adapter1")
+
+        torch.manual_seed(42)
+        model.add_adapter("adapter2", config)
+
+        # Merge with weights [1.0, -1.0] - should cancel out exactly
+        model.add_weighted_adapter(
+            adapters=["adapter1", "adapter2"],
+            weights=[1.0, -1.0],
+            adapter_name="cancelled",
+            combination_type="linear",
+        )
+
+        # Verify the merged adapter has weights of approximately 0
+        for module in model.modules():
+            if isinstance(module, lora.LoraLayer):
+                dw_cancelled = module.get_delta_weight("cancelled")
+                assert torch.allclose(dw_cancelled, torch.zeros_like(dw_cancelled))
+
+    def test_add_weighted_adapter_negative_weight_with_different_scaling(self):
+        # Test negative weights with different scaling factors (lora_alpha)
+        # This edge case ensures negative weights work correctly with different scaling values
+        torch.manual_seed(42)
+        model = MLP()
+
+        # Create two configs with different lora_alpha (different scaling factors)
+        config1 = LoraConfig(
+            r=8,
+            lora_alpha=16,  # scaling = 16/8 = 2
+            target_modules=["lin0"],
+            lora_dropout=0.0,
+            bias="none",
+            init_lora_weights=False,
+        )
+        config2 = LoraConfig(
+            r=8,
+            lora_alpha=32,  # scaling = 32/8 = 4
+            target_modules=["lin0"],
+            lora_dropout=0.0,
+            bias="none",
+            init_lora_weights=False,
+        )
+
+        model = get_peft_model(model, config1, adapter_name="adapter1")
+        model.add_adapter("adapter2", config2)
+
+        # Merge with negative weight - should handle different scalings correctly
+        model.add_weighted_adapter(
+            adapters=["adapter1", "adapter2"],
+            weights=[0.5, -0.3],
+            adapter_name="merged_diff_scaling",
+            combination_type="linear",
+        )
+
+        # Verify the merged adapter can run forward pass
+        model.set_adapter("merged_diff_scaling")
+        dummy_input = torch.randn(2, 10)
+        output = model(dummy_input)
+        assert output is not None
+
+    def test_multiple_adapters_no_needless_copy_modules_to_save(self):
+        # See 2206
+        # The problem was that we keep a "global" modules_to_save on the model which contains all possible
+        # modules_to_save for each adapter. When the first adapter targets embed_tokens with modules_to_save and the
+        # second adapter targets lm_head, then embed_tokens will create a copy of the original module for the second
+        # adapter, even though it's not needed. The copy still acts as expected but uses unnecessary memory.
+        model_id = "peft-internal-testing/tiny-random-OPTForCausalLM"
+        model = AutoModelForCausalLM.from_pretrained(model_id).to(self.torch_device)
+        config0 = LoraConfig(modules_to_save=["embed_tokens"])
+        config1 = LoraConfig(modules_to_save=["lm_head"])
+        model = get_peft_model(model, config0)
+        model.add_adapter("other", config1)
+
+        lm_head_keys = list(model.base_model.model.lm_head.modules_to_save.keys())
+        assert lm_head_keys == ["other"]
+
+        embed_token_keys = list(model.base_model.model.model.decoder.embed_tokens.modules_to_save.keys())
+        # before the fix, this would be: ['default', 'other']
+        assert embed_token_keys == ["default"]
+
+    def test_existing_model_card(self):
+        # ensure that if there is already a model card, it is not overwritten
+        model = MLP()
+        config = LoraConfig(target_modules=["lin0"])
+        model = get_peft_model(model, config)
+
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            # create a model card
+            text = "---\nmeta: hello\n---\nThis is a model card\n"
+            with open(os.path.join(tmp_dirname, "README.md"), "w") as f:
+                f.write(text)
+
+            model.save_pretrained(tmp_dirname)
+            with open(os.path.join(tmp_dirname, "README.md")) as f:
+                model_card = f.read()
+
+        assert "library_name: peft" in model_card
+        assert "meta: hello" in model_card
+        assert "This is a model card" in model_card
+
+    def test_non_existing_model_card(self):
+        # ensure that if there is already a model card, it is not overwritten
+        model = MLP()
+        config = LoraConfig(target_modules=["lin0"])
+        model = get_peft_model(model, config)
+
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            model.save_pretrained(tmp_dirname)
+            with open(os.path.join(tmp_dirname, "README.md")) as f:
+                model_card = f.read()
+
+        assert "library_name: peft" in model_card
+        # rough check that the model card is pre-filled
+        assert len(model_card) > 1000
+
+    @pytest.mark.parametrize("save_embedding_layers", ["auto", True, False])
+    @pytest.mark.parametrize(
+        "peft_config",
+        [
+            (LoraConfig(target_modules=["lin0", "embed_tokens"], init_lora_weights=False)),
+            (LoraConfig(target_modules=r"^embed_tokens", init_lora_weights=False)),
+        ],
+    )
+    def test_save_pretrained_targeting_lora_to_embedding_layer(self, save_embedding_layers, tmp_path, peft_config):
+        model = ModelEmbWithEmbeddingUtils()
+        model = get_peft_model(model, peft_config)
+
+        if save_embedding_layers == "auto":
+            # assert warning
+            msg_start = "Setting `save_embedding_layers` to `True` as embedding layers found in `target_modules`."
+            with pytest.warns(UserWarning, match=msg_start):
+                model.save_pretrained(tmp_path, save_embedding_layers=save_embedding_layers)
+        else:
+            model.save_pretrained(tmp_path, save_embedding_layers=save_embedding_layers)
+
+        state_dict = safe_load_file(tmp_path / "adapter_model.safetensors")
+        contains_embedding = "base_model.model.embed_tokens.base_layer.weight" in state_dict
+
+        if save_embedding_layers in ["auto", True]:
+            assert contains_embedding
+            assert torch.allclose(
+                model.base_model.model.embed_tokens.base_layer.weight,
+                state_dict["base_model.model.embed_tokens.base_layer.weight"],
+            )
+        else:
+            assert not contains_embedding
+
+    @pytest.mark.parametrize("save_embedding_layers", ["auto", True, False])
+    @pytest.mark.parametrize(
+        "peft_config",
+        [
+            (LoraConfig(target_modules=["lin0", "emb"], init_lora_weights=False)),
+            (LoraConfig(target_modules=r"^emb", init_lora_weights=False)),
+        ],
+    )
+    def test_save_pretrained_targeting_lora_to_embedding_layer_non_transformers(
+        self, save_embedding_layers, tmp_path, peft_config
+    ):
+        model = ModelEmbConv1D()
+        model = get_peft_model(model, peft_config)
+
+        if save_embedding_layers is True:
+            with pytest.warns(
+                UserWarning,
+                match=r"Could not identify embedding layer\(s\) because the model is not a 🤗 transformers model\.",
+            ):
+                model.save_pretrained(tmp_path, save_embedding_layers=save_embedding_layers)
+        else:
+            model.save_pretrained(tmp_path, save_embedding_layers=save_embedding_layers)
+
+        state_dict = safe_load_file(tmp_path / "adapter_model.safetensors")
+        assert "base_model.model.emb.base_layer.weight" not in state_dict
+
+    def test_load_resized_embedding_ignore_mismatched_sizes(self):
+        # issue #1605
+        # Make it possible to load a LoRA layer that targets an embedding layer even if the sizes mismatch by passing
+        # ignore_mismatched_sizes=True
+        model = ModelEmbConv1D(emb_size=100)
+        config = LoraConfig(target_modules=["emb", "lin0"], init_lora_weights=False)
+        model = get_peft_model(model, config)
+
+        # note: not using the context manager here because it fails on Windows CI for some reason
+        tmp_dirname = tempfile.mkdtemp()
+        try:
+            model.save_pretrained(tmp_dirname)
+            model = ModelEmbConv1D(emb_size=105)
+
+            # first check that this raises
+            with pytest.raises(RuntimeError) as exc:
+                PeftModel.from_pretrained(model, tmp_dirname)
+            msg = exc.value.args[0]
+            assert "size mismatch" in msg and "100" in msg and "105" in msg
+
+            # does not raise
+            PeftModel.from_pretrained(model, tmp_dirname, ignore_mismatched_sizes=True)
+        finally:
+            try:
+                shutil.rmtree(tmp_dirname)
+            except PermissionError:
+                # windows error
+                pass
+
+    @pytest.mark.parametrize(
+        "config0",
+        [
+            LoraConfig(target_modules=["lin0"], init_lora_weights=False),
+            LoKrConfig(target_modules=["lin0"], init_weights=False),
+            LoHaConfig(target_modules=["lin0"], init_weights=False),
+            AdaLoraConfig(target_modules=["lin0"], init_lora_weights=False, total_step=1),
+            IA3Config(target_modules=["lin0"], feedforward_modules=["lin0"], init_ia3_weights=False),
+            BeftConfig(target_modules=["lin0"], init_weights=False),
+            FrodConfig(target_modules=["lin0"], init_weights=False),
+            OFTConfig(target_modules=["lin0"], init_weights=False, r=2, oft_block_size=0),
+            BOFTConfig(target_modules=["lin0"], init_weights=False, boft_block_size=2),
+            HRAConfig(target_modules=["lin0"], init_weights=False),
+            MissConfig(target_modules=["lin0"], init_weights=False, r=2),
+        ],
+    )
+    def test_adapter_name_makes_no_difference(self, config0):
+        # It should not matter whether we use the default adapter name or a custom one
+        model_cls = MLP
+        input = torch.arange(90).reshape(9, 10).to(self.torch_device)
+
+        # base model
+        torch.manual_seed(0)
+        base_model = model_cls().eval().to(self.torch_device)
+        output_base = base_model(input)
+
+        # default name
+        torch.manual_seed(0)
+        base_model = model_cls().eval().to(self.torch_device)
+        torch.manual_seed(0)
+        peft_model_default = get_peft_model(base_model, config0, adapter_name="default").eval().to(self.torch_device)
+        output_default = peft_model_default(input)
+        sd_default = peft_model_default.state_dict()
+
+        # custom name 1
+        torch.manual_seed(0)
+        base_model = model_cls().eval().to(self.torch_device)
+        torch.manual_seed(0)
+        peft_model_custom1 = get_peft_model(base_model, config0, adapter_name="adapter").eval().to(self.torch_device)
+        output_custom1 = peft_model_custom1(input)
+        sd_custom1 = peft_model_custom1.state_dict()
+
+        # custom name 2
+        torch.manual_seed(0)
+        base_model = model_cls().eval().to(self.torch_device)
+        torch.manual_seed(0)
+        peft_model_custom2 = (
+            get_peft_model(base_model, config0, adapter_name="other-name").eval().to(self.torch_device)
+        )
+        output_custom2 = peft_model_custom2(input)
+        sd_custom2 = peft_model_custom2.state_dict()
+
+        assert len(sd_default) == len(sd_custom1) == len(sd_custom2)
+        for key in sd_default:
+            key1 = key.replace("default", "adapter")
+            key2 = key.replace("default", "other-name")
+            assert key1 in sd_custom1
+            assert key2 in sd_custom2
+        for k0, k1, k2 in zip(sd_default, sd_custom1, sd_custom2):
+            assert torch.allclose(sd_default[k0], sd_custom1[k1])
+            assert torch.allclose(sd_default[k0], sd_custom2[k2])
+
+        assert not torch.allclose(output_base, output_default)
+        assert not torch.allclose(output_base, output_custom1)
+        assert not torch.allclose(output_base, output_custom2)
+        assert torch.allclose(output_custom1, output_custom2)
+        assert torch.allclose(output_default, output_custom1)
+
+    def test_gpt2_dora_merge_and_unload(self):
+        # see https://github.com/huggingface/peft/pull/1588#discussion_r1537914207
+        model = AutoModelForCausalLM.from_pretrained("gpt2")
+        config = LoraConfig(task_type="CAUSAL_LM", use_dora=True)
+        model = get_peft_model(model, config)
+        # should not raise an error
+        model.merge_and_unload()
+
+    def test_gpt2_dora_merge_and_unload_safe_merge(self):
+        # see https://github.com/huggingface/peft/pull/1588#discussion_r1537914207
+        model = AutoModelForCausalLM.from_pretrained("gpt2")
+        config = LoraConfig(task_type="CAUSAL_LM", use_dora=True)
+        model = get_peft_model(model, config)
+        # should not raise an error
+        model.merge_and_unload(safe_merge=True)
+
+    def test_unload_adapter_multihead_attention(self):
+        # MultiheadAttention has special logic for unloading, that logic is covered by this test
+        self._test_unload_adapter(
+            model_id="MHA",
+            config_cls=LoraConfig,
+            config_kwargs={"target_modules": ["mha"], "init_lora_weights": False},
+        )
+
+    def test_dora_save_and_load_remapping(self):
+        # Here we test the refactor of DoRA which changed lora_magnitude_vector from a ParameterDict to a ModuleDict
+        # with a DoraLayer instance. The old parameter is now the "weight" attribute of that layer. Since we want the
+        # state_dict format not to change, we ensure that the ".weight" part of the key is removed.
+        model = AutoModelForCausalLM.from_pretrained("peft-internal-testing/opt-125m")
+        config = LoraConfig(task_type="CAUSAL_LM", use_dora=True)
+        model = get_peft_model(model, config)
+        state_dict = model.state_dict()
+
+        # sanity check: state dict contains "lora_magnitude_vector.default.weight" keys
+        assert any("lora_magnitude_vector.default.weight" in k for k in state_dict)
+
+        # save the model, check the state dict
+        # note: not using the context manager here because it fails on Windows CI for some reason
+        tmp_dirname = tempfile.mkdtemp()
+        try:
+            model.save_pretrained(tmp_dirname)
+            state_dict_adapter = safe_load_file(os.path.join(tmp_dirname, "adapter_model.safetensors"))
+            # note that in the state dict, the "default" part of the key is removed
+            assert not any("lora_magnitude_vector.weight" in k for k in state_dict_adapter)
+
+            del model
+            loaded = PeftModel.from_pretrained(
+                AutoModelForCausalLM.from_pretrained("peft-internal-testing/opt-125m"), tmp_dirname
+            )
+        finally:
+            try:
+                shutil.rmtree(tmp_dirname)
+            except PermissionError:
+                # windows error
+                pass
+
+        state_dict_loaded = loaded.state_dict()
+        assert state_dict.keys() == state_dict_loaded.keys()
+        for k in state_dict:
+            assert torch.allclose(state_dict[k], state_dict_loaded[k])
+
+    def test_gralora_and_hybrid_gralora_parameter_count(self):
+        # Here we test the parameter count of GraLoRA is preserved
+        # when rank r + hybrid_r is the same regardless of the value of gralora_k.
+        model1 = MLP()
+        config1 = GraloraConfig(target_modules=["lin0"], r=12, gralora_k=2, hybrid_r=0)
+        model1 = get_peft_model(model1, config1)
+        model2 = MLP()
+        config2 = GraloraConfig(target_modules=["lin0"], r=10, gralora_k=2, hybrid_r=2)
+        model2 = get_peft_model(model2, config2)
+        model3 = MLP()
+        config3 = GraloraConfig(target_modules=["lin0"], r=10, gralora_k=5, hybrid_r=2)
+        model3 = get_peft_model(model3, config3)
+        trainable_params1, all_params1 = model1.get_nb_trainable_parameters()
+        trainable_params2, all_params2 = model2.get_nb_trainable_parameters()
+        trainable_params3, all_params3 = model3.get_nb_trainable_parameters()
+        assert trainable_params1 == trainable_params2 == trainable_params3
+        assert all_params1 == all_params2 == all_params3
+
+    @pytest.mark.parametrize("with_forward_call", [False, True])
+    def test_mha_gradients_set_correctly(self, with_forward_call):
+        # check for this bug: https://github.com/huggingface/peft/issues/761#issuecomment-1893804738
+        base_model = ModelMha()
+        config = LoraConfig(target_modules=["mha"])
+        model = get_peft_model(base_model, config)
+        model = model.to(self.torch_device)
+
+        if with_forward_call:
+            # after the merge-unmerge roundtrip happening in forward of lora MHA, the base weights should be set to
+            # requires_grad=False
+            inputs = self.prepare_inputs_for_testing()
+            model(**inputs)
+
+        assert model.base_model.model.mha.base_layer.out_proj.base_layer.weight.requires_grad is False
+        assert model.base_model.model.mha.base_layer.in_proj_weight.requires_grad is False
+
+        # _restore_weights used to ignore the gradient, this checks that it is indeed considered
+        model.base_model.model.mha._restore_weights()
+        assert model.base_model.model.mha.base_layer.out_proj.base_layer.weight.requires_grad is False
+        assert model.base_model.model.mha.base_layer.in_proj_weight.requires_grad is False
+
+        model.base_model.model.mha.base_layer.out_proj.base_layer.weight.requires_grad = True
+        model.base_model.model.mha.base_layer.in_proj_weight.requires_grad = True
+        assert model.base_model.model.mha.base_layer.out_proj.base_layer.weight.requires_grad is True
+        assert model.base_model.model.mha.base_layer.in_proj_weight.requires_grad is True
+
+        model.base_model.model.mha._restore_weights()
+        assert model.base_model.model.mha.base_layer.out_proj.base_layer.weight.requires_grad is True
+        assert model.base_model.model.mha.base_layer.in_proj_weight.requires_grad is True
+
+    def test_monteclora_variational_loss_computation(self):
+        config = LoraConfig(
+            r=8,
+            lora_alpha=16,
+            target_modules=["lin0", "lin1"],
+            monteclora_config=MontecloraConfig(num_samples=4),
+        )
+        model = get_peft_model(MLP(), config)
+        model.train()
+
+        input_data = torch.randn(2, 10)
+        _ = model(input_data)
+
+        sampler_count = sum(1 for module in model.modules() if isinstance(module, MontecloraSampler))
+        variational_loss = model._get_monteclora_loss()
+
+        assert sampler_count > 0, "No Monteclora samplers found for variational loss computation"
+        assert variational_loss > 0, "Variational loss should be positive"
+        assert not torch.isnan(variational_loss), "Variational loss contains NaN"
+
+    def test_monteclora_variational_loss_computation_eval_mode(self):
+        config = LoraConfig(
+            r=8,
+            lora_alpha=16,
+            target_modules=["lin0", "lin1"],
+            monteclora_config=MontecloraConfig(num_samples=4),
+        )
+        model = get_peft_model(MLP(), config)
+        model.eval()
+
+        input_data = torch.randn(2, 10)
+        with torch.no_grad():
+            _ = model(input_data)
+
+        sampler_count = sum(1 for module in model.modules() if isinstance(module, MontecloraSampler))
+        variational_loss = model._get_monteclora_loss()
+
+        assert sampler_count > 0, "No Monteclora samplers found for variational loss computation"
+        # In eval mode, `MontecloraSampler.get_variational_loss` returns (0.0, 0.0) for every sampler, so the
+        # aggregated variational loss should be exactly zero.
+        assert variational_loss == 0.0, "Variational loss should be 0 in eval mode"
+
+    def test_pvera_reproducible(self):
+        inputs = {"input_ids": torch.arange(10).view(-1, 1).to(self.torch_device)}
+        config = PveraConfig(init_weights=False, sample_at_inference=True, generator_seed=0)
+        base_model = AutoModelForCausalLM.from_pretrained("peft-internal-testing/tiny-random-OPTForCausalLM")
+        torch.manual_seed(0)
+        model = get_peft_model(base_model, config).to(self.torch_device)
+        torch.manual_seed(1)
+        output1 = model(**inputs).logits
+
+        del model
+
+        config = PveraConfig(init_weights=False, sample_at_inference=True, generator_seed=0)
+        base_model = AutoModelForCausalLM.from_pretrained("peft-internal-testing/tiny-random-OPTForCausalLM")
+        torch.manual_seed(0)
+        model = get_peft_model(base_model, config).to(self.torch_device)
+        torch.manual_seed(2)
+        output2 = model(**inputs).logits
+
+        assert (output1 == output2).all()
+
+
+class TestMultiRankAdapter:
+    """Tests related to multirank LoRA adapters"""
+
+    def test_multirank(self):
+        config_1 = LoraConfig(
+            r=8,
+            lora_alpha=8,
+            init_lora_weights=False,
+            target_modules=["lin0", "lin1"],
+        )
+        config_2 = LoraConfig(
+            r=8,
+            lora_alpha=8,
+            init_lora_weights=False,
+            target_modules=["lin0", "lin1"],
+            rank_pattern={"lin0": 4},
+            alpha_pattern={"lin0": 4},
+        )
+
+        # Add first adapter
+        model = get_peft_model(MLP(), config_1, adapter_name="first")
+
+        # Add second adapter
+        model.add_adapter("second", config_2)
+
+        # Extract current and expected ranks
+        rank_current = model.lin0.lora_A["second"].weight.shape[0]
+        rank_expected = config_2.rank_pattern["lin0"]
+
+        assert rank_current == rank_expected, f"Rank {rank_current} is not equal to expected {rank_expected}"
+
+    def test_multirank_2(self):
+        rank_pattern = {}
+        alpha_pattern = {}
+        r = 4
+        lora_alpha = 8
+
+        for i in range(10):
+            rank = 64 // (i + 1)
+            for j in range(2):
+                rank_pattern[f"layers.{i}.lin{j}"] = rank
+                alpha_pattern[f"layers.{i}.lin{j}"] = 2 * rank
+
+        config = LoraConfig(
+            r=r,
+            lora_alpha=lora_alpha,
+            init_lora_weights=False,
+            target_modules=["lin0", "lin1"],
+            rank_pattern=rank_pattern,
+            alpha_pattern=alpha_pattern,
+        )
+
+        # Add first adapter
+        model = get_peft_model(DeepMLP(), config, adapter_name="first")
+
+        # Add second adapter
+        model.add_adapter("second", config)
+
+        for adapter in ["first", "second"]:
+            for key, module in model.base_model.model.named_modules():
+                if isinstance(module, BaseTunerLayer):
+                    rank_expected = rank_pattern.get(key, r)
+                    rank_current = module.lora_A[adapter].weight.shape[0]
+                    assert rank_current == rank_expected, (
+                        f"Rank {rank_current} is not equal to expected {rank_expected}"
+                    )
+
+
+class TestLayerRepr:
+    """Tests related to the repr of adapted models"""
+
+    def test_repr_lora_linear(self):
+        config = LoraConfig(target_modules=["lin0"])
+        model = get_peft_model(MLP(), config)
+        print_output = repr(model.model.lin0)
+        assert print_output.startswith("lora.Linear")
+        assert "in_features=10" in print_output
+        assert "out_features=20" in print_output
+        assert "lora_A" in print_output
+        assert "lora_B" in print_output
+        assert "default" in print_output
+
+    def test_repr_lora_embedding(self):
+        config = LoraConfig(target_modules=["emb"])
+        model = get_peft_model(ModelEmbConv1D(), config)
+        print_output = repr(model.model.emb)
+        assert print_output.startswith("lora.Embedding")
+        assert "100, 5" in print_output
+        assert "lora_embedding_A" in print_output
+        assert "lora_embedding_B" in print_output
+        assert "default" in print_output
+
+    def test_repr_lora_conv1d(self):
+        config = LoraConfig(target_modules=["conv1d"])
+        model = get_peft_model(ModelEmbConv1D(), config)
+        print_output = repr(model.model.conv1d)
+        assert print_output.startswith("lora.Linear")
+        assert "in_features=5" in print_output
+        assert "out_features=1" in print_output
+        assert "lora_A" in print_output
+        assert "lora_B" in print_output
+        assert "default" in print_output
+
+    def test_repr_lora_conv2d(self):
+        config = LoraConfig(target_modules=["conv2d"])
+        model = get_peft_model(ModelConv2D(), config)
+        print_output = repr(model.model.conv2d)
+        assert print_output.startswith("lora.Conv2d")
+        assert "5, 10" in print_output
+        assert "kernel_size=(3, 3)" in print_output
+        assert "stride=(1, 1)" in print_output
+        assert "lora_A" in print_output
+        assert "lora_B" in print_output
+        assert "default" in print_output
+
+    def test_repr_lora_paramwrapper(self):
+        config = LoraConfig(target_parameters=["lin0.weight"])
+        model = get_peft_model(MLP(), config)
+        print_output = repr(model.model.lin0)
+        assert print_output.startswith("lora.ParamWrapper")
+        # important: targeted parameter should be contained:
+        assert "parameter_name='weight'" in print_output
+        assert "in_features=10" in print_output
+        assert "out_features=20" in print_output
+        assert "lora_A" in print_output
+        assert "lora_B" in print_output
+        assert "default" in print_output
+
+
+class TestMultipleActiveAdapters:
+    """
+    A test class to test the functionality of multiple active adapters.
+
+    This is not specifically tied to custom models, it's just easy to test here and testing it on all types of models
+    would be overkill.
+    """
+
+    torch_device = infer_device()
+
+    def prepare_inputs_for_testing(self):
+        X = torch.arange(90).view(9, 10).to(self.torch_device)
+        return {"X": X}
+
+    def set_multiple_active_adapters(self, model, adapter_names):
+        for module in model.modules():
+            if isinstance(module, (BaseTunerLayer, AuxiliaryTrainingWrapper)):
+                module.set_adapter(adapter_names)
+
+    def resolve_model_cls(self, tuner_method):
+        if tuner_method == "lora+trainable_tokens":
+            # for this method we need an Embedding layer to target
+            return ModelEmbConv1D()
+        if tuner_method == "ia3":
+            return MLP(bias=False)
+        return MLP(bias=True)
+
+    @pytest.mark.parametrize(
+        "test_name, tuner_method, config_cls, config_kwargs_1, config_kwargs_2", MULTIPLE_ACTIVE_ADAPTERS_TEST_CASES
+    )
+    def test_multiple_active_adapters_forward(
+        self, test_name, tuner_method, config_cls, config_kwargs_1, config_kwargs_2
+    ):
+        _skip_tests_with_multiple_adapters_with_target_parameters(config_cls, config_kwargs_2)
+
+        torch.manual_seed(0)
+
+        model = self.resolve_model_cls(tuner_method)
+        model = model.to(self.torch_device).eval()
+
+        X = self.prepare_inputs_for_testing()
+
+        config_1 = config_cls(**config_kwargs_1)
+        config_2 = config_cls(**config_kwargs_2)
+
+        peft_model = get_peft_model(model, config_1, adapter_name="adapter_1")
+        peft_model.add_adapter("adapter_2", config_2)
+
+        # the assumption that the output of the combined output of two adapters is != to the output of one
+        # adapter is not true for unmodified trainable tokens as they just mimic the existing embedding matrix.
+        # therefore, we modify the weights so that the adapter weights differs from the embedding weights.
+        #
+        # We do it this way because we have no way to pass something like `init_weights=False` to the token adapter.
+        if "trainable_tokens" in tuner_method:
+            peft_model.emb.token_adapter.trainable_tokens_delta["adapter_1"].data = torch.rand_like(
+                peft_model.emb.token_adapter.trainable_tokens_delta["adapter_1"].data
+            )
+            peft_model.emb.token_adapter.trainable_tokens_delta["adapter_2"].data = torch.rand_like(
+                peft_model.emb.token_adapter.trainable_tokens_delta["adapter_2"].data
+            )
+
+        # set adapter_1
+        peft_model.set_adapter("adapter_1")
+        adapter_1_output = peft_model(**X)
+
+        # set adapter_2
+        peft_model.set_adapter("adapter_2")
+        adapter_2_output = peft_model(**X)
+
+        # set ["adapter_1", "adapter_2"]
+        self.set_multiple_active_adapters(peft_model, ["adapter_1", "adapter_2"])
+        combined_output = peft_model(**X)
+
+        assert not torch.allclose(adapter_1_output, adapter_2_output, atol=1e-5)
+        assert not torch.allclose(adapter_1_output, combined_output, atol=1e-5)
+        assert not torch.allclose(adapter_2_output, combined_output, atol=1e-5)
+
+        if (tuner_method == "lora") and not (config_1.target_parameters or config_2.target_parameters):
+            # Create a weighted adapter combining both adapters and check that its output is same as setting multiple
+            # active adapters. `target_parameters` is not supported.
+            peft_model.add_weighted_adapter(
+                ["adapter_1", "adapter_2"], [1.0, 1.0], "new_combined_adapter", combination_type="cat"
+            )
+            peft_model.set_adapter("new_combined_adapter")
+            new_combined_output = peft_model(**X)
+            assert torch.allclose(new_combined_output, combined_output, atol=1e-5)
+
+    @pytest.mark.parametrize(
+        "test_name, tuner_method, config_cls, config_kwargs_1, config_kwargs_2", MULTIPLE_ACTIVE_ADAPTERS_TEST_CASES
+    )
+    def test_multiple_active_adapters_merge_and_unmerge(
+        self, test_name, tuner_method, config_cls, config_kwargs_1, config_kwargs_2
+    ):
+        _skip_if_merging_not_supported(test_name, config_cls, config_kwargs_1)
+        _skip_tests_with_multiple_adapters_with_target_parameters(config_cls, config_kwargs_2)
+
+        config_1 = config_cls(**config_kwargs_1)
+        config_2 = config_cls(**config_kwargs_2)
+
+        torch.manual_seed(0)
+
+        model = self.resolve_model_cls(tuner_method)
+        model = model.to(self.torch_device).eval()
+
+        X = self.prepare_inputs_for_testing()
+        base_output = model(**X)
+
+        peft_model = get_peft_model(model, config_1, adapter_name="adapter_1").eval()
+        peft_model.add_adapter("adapter_2", config_2)
+
+        # set ["adapter_1", "adapter_2"]
+        self.set_multiple_active_adapters(peft_model, ["adapter_1", "adapter_2"])
+        combined_output = peft_model(**X)
+
+        peft_model.merge_adapter()
+        merged_combined_output = peft_model(**X)
+        assert torch.allclose(merged_combined_output, combined_output, atol=1e-4)
+
+        peft_model.unmerge_adapter()
+
+        with peft_model.disable_adapter():
+            disabled_adapter_output = peft_model(**X)
+
+        assert torch.allclose(disabled_adapter_output, base_output, atol=1e-4)
+
+    @pytest.mark.parametrize(
+        "test_name, tuner_method, config_cls, config_kwargs_1, config_kwargs_2", MULTIPLE_ACTIVE_ADAPTERS_TEST_CASES
+    )
+    def test_merge_layers_multi(self, test_name, tuner_method, config_cls, config_kwargs_1, config_kwargs_2):
+        _skip_if_merging_not_supported(test_name, config_cls, config_kwargs_1)
+        _skip_tests_with_multiple_adapters_with_target_parameters(config_cls, config_kwargs_2)
+
+        torch.manual_seed(0)
+
+        model = self.resolve_model_cls(tuner_method)
+        model = model.to(self.torch_device).eval()
+
+        config_1 = config_cls(**config_kwargs_1)
+        config_2 = config_cls(**config_kwargs_2)
+
+        model = get_peft_model(model, config_1)
+
+        # the assumption that the output of the combined output of two adapters is != to the output of one
+        # adapter is not true for unmodified trainable tokens as they just mimic the existing embedding matrix.
+        # therefore, we modify the weights so that the adapter weights differs from the embedding weights. in this
+        # case we even use 20*rand to be very distinct to adapter 2 since we're comparing outputs and not embeddings
+        # with rather high tolerance values. this is also the reason why `init_weights` is not sufficient here and
+        # when using `<peft method>.trainable_token_indices` we do not have the utility of `init_weights` anyway.
+        if "trainable_tokens" in tuner_method:
+            model.emb.token_adapter.trainable_tokens_delta["default"].data = 20 * torch.rand_like(
+                model.emb.token_adapter.trainable_tokens_delta["default"].data
+            )
+
+        dummy_input = self.prepare_inputs_for_testing()
+        model.eval()
+
+        with torch.inference_mode():
+            outputs_adapter_1 = model(**dummy_input)
+
+        model.add_adapter("adapter-2", config_2)
+        model.set_adapter("adapter-2")
+
+        # same as above but for adapter 2
+        if "trainable_tokens" in tuner_method:
+            model.emb.token_adapter.trainable_tokens_delta["adapter-2"].data = 2 * torch.rand_like(
+                model.emb.token_adapter.trainable_tokens_delta["adapter-2"].data
+            )
+
+        model.eval()
+
+        with torch.inference_mode():
+            outputs_adapter_2 = model(**dummy_input)
+
+        assert not torch.allclose(outputs_adapter_1, outputs_adapter_2, atol=1e-3, rtol=1e-3)
+
+        model.set_adapter("default")
+
+        with torch.inference_mode():
+            outputs_adapter_1_after_set = model(**dummy_input)
+
+        assert torch.allclose(outputs_adapter_1_after_set, outputs_adapter_1, atol=1e-3, rtol=1e-3)
+
+        model_copy = copy.deepcopy(model)
+        model_copy_2 = copy.deepcopy(model)
+        model_merged_all = model.merge_and_unload(adapter_names=["adapter-2", "default"])
+
+        with torch.inference_mode():
+            outputs_merged_all = model_merged_all(**dummy_input)
+
+        assert not torch.allclose(outputs_merged_all, outputs_adapter_2, atol=1e-3, rtol=1e-3)
+        assert not torch.allclose(outputs_merged_all, outputs_adapter_1, atol=1e-3, rtol=1e-3)
+
+        model_merged_adapter_2 = model_copy.merge_and_unload(adapter_names=["adapter-2"])
+
+        with torch.inference_mode():
+            outputs_merged_adapter_2 = model_merged_adapter_2(**dummy_input)
+
+        assert torch.allclose(outputs_merged_adapter_2, outputs_adapter_2, atol=1e-3, rtol=1e-3)
+
+        model_merged_adapter_default = model_copy_2.merge_and_unload(adapter_names=["default"])
+
+        with torch.inference_mode():
+            outputs_merged_adapter_default = model_merged_adapter_default(**dummy_input)
+
+        assert torch.allclose(outputs_merged_adapter_default, outputs_adapter_1, atol=1e-3, rtol=1e-3)
+
+
+class MLP_2x_same_shape(nn.Module):
+    """Simple MLP with two layers of the same shape to test multiple adapters targeting same shape layers."""
+
+    def __init__(self, bias=True):
+        super().__init__()
+        self.relu = nn.ReLU()
+        self.lin0 = nn.Linear(10, 20, bias=bias)
+        self.lin1 = nn.Linear(20, 20, bias=bias)  # lin1 and lin2 have same shape
+        self.lin2 = nn.Linear(20, 20, bias=bias)
+        self.lin3 = nn.Linear(20, 2, bias=bias)
+        self.sm = nn.LogSoftmax(dim=-1)
+
+    def forward(self, X):
+        X = X.float()
+        X = self.lin0(X)
+        X = self.relu(X)
+        X = self.lin1(X)
+        X = self.relu(X)
+        X = self.lin2(X)
+        X = self.relu(X)
+        X = self.lin3(X)
+        X = self.sm(X)
+        return X
+
+
+class TestRequiresGrad:
+    """Test that requires_grad is set correctly in specific circumstances
+
+    # See issue #899.
+
+    This is not specifically tied to custom models, it's just easy to test here and testing it on all types of models
+    would be overkill.
+
+    """
+
+    def check_requires_grad(self, model, *params_expected: str):
+        # Check that only the given parameters have requires_grad=True, and all others have requires_grad=False.
+        # Calling without arguments besides the model means that all parameters should have requires_grad=False.
+        params_with_requires_grad = [name for name, param in model.named_parameters() if param.requires_grad]
+        diff = set(params_expected).symmetric_difference(set(params_with_requires_grad))
+        msg = f"Expected {params_expected} to require gradients, got {params_with_requires_grad}"
+        assert len(diff) == 0, msg
+
+    def test_requires_grad_modules_to_save_default(self):
+        config = LoraConfig(target_modules=["lin0"], modules_to_save=["lin1"])
+        peft_model = get_peft_model(MLP(), config)
+
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.modules_to_save.default.weight",
+            "base_model.model.lin1.modules_to_save.default.bias",
+            "base_model.model.lin0.lora_A.default.weight",
+            "base_model.model.lin0.lora_B.default.weight",
+        )
+
+    def test_requires_grad_modules_to_save_disabling(self):
+        config = LoraConfig(target_modules=["lin0"], modules_to_save=["lin1"])
+        peft_model = get_peft_model(MLP(), config)
+
+        # no layer should have requires_grad
+        peft_model.disable_adapter_layers()
+        self.check_requires_grad(peft_model)
+
+        # when re-enabling the adapter, the original module's grad should be disabled and vice versa
+        peft_model.enable_adapter_layers()
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.modules_to_save.default.weight",
+            "base_model.model.lin1.modules_to_save.default.bias",
+            "base_model.model.lin0.lora_A.default.weight",
+            "base_model.model.lin0.lora_B.default.weight",
+        )
+
+        # when using the disable_adapter context, no layer should have requires_grad
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.modules_to_save.default.weight",
+            "base_model.model.lin1.modules_to_save.default.bias",
+            "base_model.model.lin0.lora_A.default.weight",
+            "base_model.model.lin0.lora_B.default.weight",
+        )
+
+    def test_requires_grad_modules_to_save_multiple_adapters(self):
+        config0 = LoraConfig(target_modules=["lin0"], modules_to_save=["lin1"])
+        peft_model = get_peft_model(MLP(), config0)
+
+        config1 = LoraConfig(target_modules=["lin0"], modules_to_save=["lin1"])
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.modules_to_save.default.weight",
+            "base_model.model.lin1.modules_to_save.default.bias",
+            "base_model.model.lin0.lora_A.default.weight",
+            "base_model.model.lin0.lora_B.default.weight",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.modules_to_save.default.weight",
+            "base_model.model.lin1.modules_to_save.default.bias",
+            "base_model.model.lin0.lora_A.default.weight",
+            "base_model.model.lin0.lora_B.default.weight",
+        )
+
+        # set config1 as active, should lead to adapter1 requiring grad
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.modules_to_save.adapter1.weight",
+            "base_model.model.lin1.modules_to_save.adapter1.bias",
+            "base_model.model.lin0.lora_A.adapter1.weight",
+            "base_model.model.lin0.lora_B.adapter1.weight",
+        )
+
+    def test_requires_grad_follows_inference_mode_modules_to_save(self):
+        # check that passing inference_mode to set_adapter has the intended effect with LoRA and modules_to_save
+        config0 = LoraConfig(target_modules=["lin0"], modules_to_save=["lin1"])
+        peft_model = get_peft_model(MLP(), config0)
+
+        config1 = LoraConfig(target_modules=["lin0"], modules_to_save=["lin1"])
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.modules_to_save.default.weight",
+            "base_model.model.lin1.modules_to_save.default.bias",
+            "base_model.model.lin0.lora_A.default.weight",
+            "base_model.model.lin0.lora_B.default.weight",
+        )
+
+        # inference mode false (default)
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default", inference_mode=False)
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.modules_to_save.default.weight",
+            "base_model.model.lin1.modules_to_save.default.bias",
+            "base_model.model.lin0.lora_A.default.weight",
+            "base_model.model.lin0.lora_B.default.weight",
+        )
+
+        # set config1 as active, should lead to adapter1 requiring grad
+        peft_model.set_adapter("adapter1", inference_mode=False)
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.modules_to_save.adapter1.weight",
+            "base_model.model.lin1.modules_to_save.adapter1.bias",
+            "base_model.model.lin0.lora_A.adapter1.weight",
+            "base_model.model.lin0.lora_B.adapter1.weight",
+        )
+
+        # inference mode true
+
+        # set config0 as active but in inference mode, should result in no module requiring grad
+        peft_model.set_adapter("default", inference_mode=True)
+        self.check_requires_grad(peft_model)
+
+        # set config1 as active but in inference mode, should result in no module requiring grad
+        peft_model.set_adapter("adapter1", inference_mode=True)
+        self.check_requires_grad(peft_model)
+
+    def test_requires_grad_follows_inference_mode_trainable_token_indices(self):
+        # check that passing inference_mode to set_adapter has the intended effect with LoRA and trainable tokens
+        config0 = LoraConfig(target_modules=["conv1d"], trainable_token_indices={"emb": [0, 1, 2]})
+        peft_model = get_peft_model(ModelEmbConv1D(), config0)
+
+        config1 = LoraConfig(target_modules=["lin0"], trainable_token_indices={"emb": [0, 1, 2]})
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.emb.token_adapter.trainable_tokens_delta.default",
+            "base_model.model.conv1d.lora_A.default.weight",
+            "base_model.model.conv1d.lora_B.default.weight",
+        )
+
+        # inference mode false (default)
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default", inference_mode=False)
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.emb.token_adapter.trainable_tokens_delta.default",
+            "base_model.model.conv1d.lora_A.default.weight",
+            "base_model.model.conv1d.lora_B.default.weight",
+        )
+
+        # set config1 as active, should lead to adapter1 requiring grad
+        peft_model.set_adapter("adapter1", inference_mode=False)
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.emb.token_adapter.trainable_tokens_delta.adapter1",
+            "base_model.model.lin0.lora_A.adapter1.weight",
+            "base_model.model.lin0.lora_B.adapter1.weight",
+        )
+
+        # inference mode true
+
+        # set config0 as active but in inference mode, should result in no module requiring grad
+        peft_model.set_adapter("default", inference_mode=True)
+        self.check_requires_grad(peft_model)
+
+        # set config1 as active but in inference mode, should result in no module requiring grad
+        peft_model.set_adapter("adapter1", inference_mode=True)
+        self.check_requires_grad(peft_model)
+
+    def test_requires_grad_lora_different_targets(self):
+        # test two different LoRA adapters that target different modules
+        config0 = LoraConfig(target_modules=["lin0"])
+        peft_model = get_peft_model(MLP(), config0)
+
+        config1 = LoraConfig(target_modules=["lin1"])
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.lora_A.default.weight",
+            "base_model.model.lin0.lora_B.default.weight",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.lora_A.default.weight",
+            "base_model.model.lin0.lora_B.default.weight",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.lora_A.adapter1.weight",
+            "base_model.model.lin1.lora_B.adapter1.weight",
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.lora_A.adapter1.weight",
+            "base_model.model.lin1.lora_B.adapter1.weight",
+        )
+
+    def test_requires_grad_lora_same_targets(self):
+        # same as previous test, except that LoRA adapters target the same layer
+        config0 = LoraConfig(target_modules=["lin0"])
+        peft_model = get_peft_model(MLP(), config0)
+
+        config1 = LoraConfig(target_modules=["lin0"])
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.lora_A.default.weight",
+            "base_model.model.lin0.lora_B.default.weight",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.lora_A.default.weight",
+            "base_model.model.lin0.lora_B.default.weight",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.lora_A.adapter1.weight",
+            "base_model.model.lin0.lora_B.adapter1.weight",
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.lora_A.adapter1.weight",
+            "base_model.model.lin0.lora_B.adapter1.weight",
+        )
+
+    def test_requires_grad_ia3_different_targets(self):
+        # test two different IA3 adapters that target different modules
+        config0 = IA3Config(target_modules=["lin0"], feedforward_modules=["lin0"])
+        peft_model = get_peft_model(MLP(), config0)
+
+        config1 = IA3Config(target_modules=["lin1"], feedforward_modules=["lin1"])
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.ia3_l.default",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.ia3_l.default",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.ia3_l.adapter1",
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.ia3_l.adapter1",
+        )
+
+    def test_requires_grad_ia3_same_targets(self):
+        # same as previous test, except that IA3 adapters target the same layer
+        config0 = IA3Config(target_modules=["lin0"], feedforward_modules=["lin0"])
+        peft_model = get_peft_model(MLP(), config0)
+
+        config1 = IA3Config(target_modules=["lin0"], feedforward_modules=["lin0"])
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.ia3_l.default",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.ia3_l.default",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.ia3_l.adapter1",
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.ia3_l.adapter1",
+        )
+
+    @pytest.mark.xfail(strict=True)
+    def test_requires_grad_adalora_different_targets(self):
+        # test two different AdaLora adapters that target different modules
+
+        # Note: This test is expected to fail because first loading one adapter, then the next adapter with
+        # inference_mode=True incorrectly leads to the requires_grad of the first adapter being turned to False. This is
+        # of course not desired but has yet to be fixed. In practice, it's unlikely that a user would pass
+        # inference_mode=True for add_adapter, this flag is mostly being used when calling PeftModel.from_pretrained, so
+        # we accept this issue for now. Note that only for AdaLoRA do we even need to pass inference_mode=True here,
+        # other PEFT methods don't require this.
+        config0 = AdaLoraConfig(target_modules=["lin0"], total_step=1)
+        peft_model = get_peft_model(MLP(), config0)
+
+        # note: AdaLoRA cannot have more than 1 trainable active adapter, hence enable inference_mode
+        config1 = AdaLoraConfig(target_modules=["lin1"], total_step=1, inference_mode=True)
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.lora_A.default",
+            "base_model.model.lin0.lora_B.default",
+            "base_model.model.lin0.lora_E.default",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.lora_A.default",
+            "base_model.model.lin0.lora_B.default",
+            "base_model.model.lin0.lora_E.default",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.lora_A.adapter1",
+            "base_model.model.lin1.lora_B.adapter1",
+            "base_model.model.lin1.lora_E.adapter1",
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.lora_A.adapter1",
+            "base_model.model.lin1.lora_B.adapter1",
+            "base_model.model.lin1.lora_E.adapter1",
+        )
+
+    @pytest.mark.xfail(strict=True)
+    def test_requires_grad_adalora_same_targets(self):
+        # same as previous test, except that AdaLora adapters target the same layer
+
+        # Note: This test is expected to fail because first loading one adapter, then the next adapter with
+        # inference_mode=True incorrectly leads to the requires_grad of the first adapter being turned to False. This is
+        # of course not desired but has yet to be fixed. In practice, it's unlikely that a user would pass
+        # inference_mode=True for add_adapter, this flag is mostly being used when calling PeftModel.from_pretrained, so
+        # we accept this issue for now. Note that only for AdaLoRA do we even need to pass inference_mode=True here,
+        # other PEFT methods don't require this.
+        config0 = AdaLoraConfig(target_modules=["lin0"], total_step=1)
+        peft_model = get_peft_model(MLP(), config0)
+
+        # note: AdaLoRA cannot have more than 1 trainable active adapter, hence enable inference_mode
+        config1 = AdaLoraConfig(target_modules=["lin0"], total_step=1, inference_mode=True)
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.lora_A.default",
+            "base_model.model.lin0.lora_B.default",
+            "base_model.model.lin0.lora_E.default",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.lora_A.default",
+            "base_model.model.lin0.lora_B.default",
+            "base_model.model.lin0.lora_E.default",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.lora_A.adapter1",
+            "base_model.model.lin0.lora_B.adapter1",
+            "base_model.model.lin0.lora_E.adapter1",
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.lora_A.adapter1",
+            "base_model.model.lin0.lora_B.adapter1",
+            "base_model.model.lin0.lora_E.adapter1",
+        )
+
+    def test_requires_grad_lora_conv2d(self):
+        # test two different LoRA adapters that target different modules
+        config0 = LoraConfig(target_modules=["conv2d"])
+        peft_model = get_peft_model(ModelConv2D(), config0)
+
+        config1 = LoraConfig(target_modules=["lin0"])
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.conv2d.lora_A.default.weight",
+            "base_model.model.conv2d.lora_B.default.weight",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.conv2d.lora_A.default.weight",
+            "base_model.model.conv2d.lora_B.default.weight",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.lora_A.adapter1.weight",
+            "base_model.model.lin0.lora_B.adapter1.weight",
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.lora_A.adapter1.weight",
+            "base_model.model.lin0.lora_B.adapter1.weight",
+        )
+
+    def test_requires_grad_lora_emb_conv1d(self):
+        # test two different LoRA adapters that target different modules
+        config0 = LoraConfig(target_modules=["conv1d"])
+        peft_model = get_peft_model(ModelEmbConv1D(), config0)
+
+        config1 = LoraConfig(target_modules=["emb"])
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.conv1d.lora_A.default.weight",
+            "base_model.model.conv1d.lora_B.default.weight",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.conv1d.lora_A.default.weight",
+            "base_model.model.conv1d.lora_B.default.weight",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.emb.lora_embedding_A.adapter1",
+            "base_model.model.emb.lora_embedding_B.adapter1",
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.emb.lora_embedding_A.adapter1",
+            "base_model.model.emb.lora_embedding_B.adapter1",
+        )
+
+    def test_requires_grad_ia3_conv1d(self):
+        # test two different LoRA adapters that target different modules
+        config0 = IA3Config(target_modules=["conv1d"], feedforward_modules=[])
+        peft_model = get_peft_model(ModelEmbConv1D(), config0)
+
+        config1 = IA3Config(target_modules=["lin0"], feedforward_modules=["lin0"])
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.conv1d.ia3_l.default",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.conv1d.ia3_l.default",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.ia3_l.adapter1",
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.ia3_l.adapter1",
+        )
+
+    def test_requires_grad_ia3_conv2d(self):
+        # test two different LoRA adapters that target different modules
+        config0 = IA3Config(target_modules=["conv2d"], feedforward_modules=["conv2d"])
+        peft_model = get_peft_model(ModelConv2D(), config0)
+
+        config1 = IA3Config(target_modules=["lin0"], feedforward_modules=[])
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.conv2d.ia3_l.default",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.conv2d.ia3_l.default",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.ia3_l.adapter1",
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.ia3_l.adapter1",
+        )
+
+    def test_requires_grad_loha_different_targets(self):
+        # test two different LoHa adapters that target different modules
+        config0 = LoHaConfig(target_modules=["lin0"])
+        peft_model = get_peft_model(MLP(), config0)
+
+        config1 = LoHaConfig(target_modules=["lin1"])
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.hada_w1_a.default",
+            "base_model.model.lin0.hada_w1_b.default",
+            "base_model.model.lin0.hada_w2_a.default",
+            "base_model.model.lin0.hada_w2_b.default",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.hada_w1_a.default",
+            "base_model.model.lin0.hada_w1_b.default",
+            "base_model.model.lin0.hada_w2_a.default",
+            "base_model.model.lin0.hada_w2_b.default",
+        )
+
+        # change activate pter to pter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.hada_w1_a.adapter1",
+            "base_model.model.lin1.hada_w1_b.adapter1",
+            "base_model.model.lin1.hada_w2_a.adapter1",
+            "base_model.model.lin1.hada_w2_b.adapter1",
+        )
+
+        # disable all pters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.hada_w1_a.adapter1",
+            "base_model.model.lin1.hada_w1_b.adapter1",
+            "base_model.model.lin1.hada_w2_a.adapter1",
+            "base_model.model.lin1.hada_w2_b.adapter1",
+        )
+
+    def test_requires_grad_loha_same_targets(self):
+        # same as previous test, except that LoHa adapters target the same layer
+        config0 = LoHaConfig(target_modules=["lin0"])
+        peft_model = get_peft_model(MLP(), config0)
+
+        config1 = LoHaConfig(target_modules=["lin0"])
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.hada_w1_a.default",
+            "base_model.model.lin0.hada_w1_b.default",
+            "base_model.model.lin0.hada_w2_a.default",
+            "base_model.model.lin0.hada_w2_b.default",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.hada_w1_a.default",
+            "base_model.model.lin0.hada_w1_b.default",
+            "base_model.model.lin0.hada_w2_a.default",
+            "base_model.model.lin0.hada_w2_b.default",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.hada_w1_a.adapter1",
+            "base_model.model.lin0.hada_w1_b.adapter1",
+            "base_model.model.lin0.hada_w2_a.adapter1",
+            "base_model.model.lin0.hada_w2_b.adapter1",
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.hada_w1_a.adapter1",
+            "base_model.model.lin0.hada_w1_b.adapter1",
+            "base_model.model.lin0.hada_w2_a.adapter1",
+            "base_model.model.lin0.hada_w2_b.adapter1",
+        )
+
+    def test_requires_grad_lokr_different_targets(self):
+        # test two different LoKr adapters that target different modules
+        config0 = LoKrConfig(target_modules=["lin0"])
+        peft_model = get_peft_model(MLP(), config0)
+
+        config1 = LoKrConfig(target_modules=["lin1"])
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.lokr_w1.default",
+            "base_model.model.lin0.lokr_w2.default",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.lokr_w1.default",
+            "base_model.model.lin0.lokr_w2.default",
+        )
+
+        # change activate pter to pter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.lokr_w1.adapter1",
+            "base_model.model.lin1.lokr_w2.adapter1",
+        )
+
+        # disable all pters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.lokr_w1.adapter1",
+            "base_model.model.lin1.lokr_w2.adapter1",
+        )
+
+    def test_requires_grad_lokr_same_targets(self):
+        # same as previous test, except that LoKr adapters target the same layer
+        config0 = LoKrConfig(target_modules=["lin0"])
+        peft_model = get_peft_model(MLP(), config0)
+
+        config1 = LoKrConfig(target_modules=["lin0"])
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.lokr_w1.default",
+            "base_model.model.lin0.lokr_w2.default",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.lokr_w1.default",
+            "base_model.model.lin0.lokr_w2.default",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.lokr_w1.adapter1",
+            "base_model.model.lin0.lokr_w2.adapter1",
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.lokr_w1.adapter1",
+            "base_model.model.lin0.lokr_w2.adapter1",
+        )
+
+    def test_requires_grad_oft_different_targets(self):
+        # test two different OFT adapters that target different modules
+        config0 = OFTConfig(target_modules=["lin0"], r=2, oft_block_size=0)
+        peft_model = get_peft_model(MLP(), config0)
+
+        config1 = OFTConfig(target_modules=["lin1"], r=2, oft_block_size=0)
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.oft_R.default.weight",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.oft_R.default.weight",
+        )
+
+        # change activate pter to pter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.oft_R.adapter1.weight",
+        )
+
+        # disable all pters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.oft_R.adapter1.weight",
+        )
+
+    def test_requires_grad_oft_same_targets(self):
+        # same as previous test, except that OFT adapters target the same layer
+        config0 = OFTConfig(target_modules=["lin0"], r=2, oft_block_size=0)
+        peft_model = get_peft_model(MLP(), config0)
+
+        config1 = OFTConfig(target_modules=["lin0"], r=2, oft_block_size=0)
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.oft_R.default.weight",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.oft_R.default.weight",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.oft_R.adapter1.weight",
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.oft_R.adapter1.weight",
+        )
+
+    def test_requires_grad_hra_different_targets(self):
+        # test two different HRA adapters that target different modules
+        config0 = HRAConfig(target_modules=["lin0"])
+        peft_model = get_peft_model(MLP(), config0)
+
+        config1 = HRAConfig(target_modules=["lin1"])
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.hra_u.default",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.hra_u.default",
+        )
+
+        # change activate pter to pter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.hra_u.adapter1",
+        )
+
+        # disable all pters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.hra_u.adapter1",
+        )
+
+    def test_requires_grad_hra_same_targets(self):
+        # same as previous test, except that HRA adapters target the same layer
+        config0 = HRAConfig(target_modules=["lin0"])
+        peft_model = get_peft_model(MLP(), config0)
+
+        config1 = HRAConfig(target_modules=["lin0"])
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.hra_u.default",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.hra_u.default",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.hra_u.adapter1",
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.hra_u.adapter1",
+        )
+
+    def test_requires_grad_miss_different_targets(self):
+        # test two different HRA adapters that target different modules
+        config0 = MissConfig(target_modules=["lin0"], r=2)
+        peft_model = get_peft_model(MLP(), config0)
+
+        config1 = MissConfig(target_modules=["lin1"], r=2)
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.miss_block.default",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.miss_block.default",
+        )
+
+        # change activate pter to pter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.miss_block.adapter1",
+        )
+
+        # disable all pters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.miss_block.adapter1",
+        )
+
+    def test_requires_grad_miss_same_targets(self):
+        # same as previous test, except that HRA adapters target the same layer
+        config0 = MissConfig(target_modules=["lin0"], r=2)
+        peft_model = get_peft_model(MLP(), config0)
+
+        config1 = MissConfig(target_modules=["lin0"], r=2)
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.miss_block.default",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.miss_block.default",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.miss_block.adapter1",
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.miss_block.adapter1",
+        )
+
+    def test_requires_grad_boft_different_targets(self):
+        # test two different OFT adapters that target different modules
+        config0 = BOFTConfig(target_modules=["lin0"], boft_block_size=2)
+        peft_model = get_peft_model(MLP2(), config0)
+
+        config1 = BOFTConfig(target_modules=["lin1"], boft_block_size=2)
+        peft_model.add_adapter("adapter1", config1)
+
+        # active pter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.boft_R.default",
+            "base_model.model.lin0.boft_s.default",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.boft_R.default",
+            "base_model.model.lin0.boft_s.default",
+        )
+
+        # change activate pter to pter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.boft_R.adapter1",
+            "base_model.model.lin1.boft_s.adapter1",
+        )
+
+        # disable all pters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.boft_R.adapter1",
+            "base_model.model.lin1.boft_s.adapter1",
+        )
+
+    def test_requires_grad_boft_same_targets(self):
+        # same as previous test, except that BOFT adapters target the same layer
+        config0 = BOFTConfig(target_modules=["lin1"], boft_block_size=2)
+        peft_model = get_peft_model(MLP(), config0)
+
+        config1 = BOFTConfig(target_modules=["lin1"], boft_block_size=2)
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.boft_R.default",
+            "base_model.model.lin1.boft_s.default",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.boft_R.default",
+            "base_model.model.lin1.boft_s.default",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.boft_R.adapter1",
+            "base_model.model.lin1.boft_s.adapter1",
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.boft_R.adapter1",
+            "base_model.model.lin1.boft_s.adapter1",
+        )
+
+    def test_requires_grad_lntuning_different_targets(self):
+        config0 = LNTuningConfig(
+            target_modules=["layernorm0"],
+        )
+        peft_model = get_peft_model(MLP_LayerNorm(), config0)
+
+        config1 = LNTuningConfig(target_modules=["layernorm1"])
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.layernorm0.ln_tuning_layers.default.weight",
+            "base_model.model.layernorm0.ln_tuning_layers.default.bias",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.layernorm0.ln_tuning_layers.default.weight",
+            "base_model.model.layernorm0.ln_tuning_layers.default.bias",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.layernorm1.ln_tuning_layers.adapter1.weight",
+            "base_model.model.layernorm1.ln_tuning_layers.adapter1.bias",
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.layernorm1.ln_tuning_layers.adapter1.weight",
+            "base_model.model.layernorm1.ln_tuning_layers.adapter1.bias",
+        )
+
+    def test_requires_grad_lntuning_same_targets(self):
+        config0 = LNTuningConfig(
+            target_modules=["layernorm0"],
+        )
+        peft_model = get_peft_model(MLP_LayerNorm(), config0)
+
+        config1 = LNTuningConfig(target_modules=["layernorm0"])
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.layernorm0.ln_tuning_layers.default.weight",
+            "base_model.model.layernorm0.ln_tuning_layers.default.bias",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.layernorm0.ln_tuning_layers.default.weight",
+            "base_model.model.layernorm0.ln_tuning_layers.default.bias",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.layernorm0.ln_tuning_layers.adapter1.weight",
+            "base_model.model.layernorm0.ln_tuning_layers.adapter1.bias",
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.layernorm0.ln_tuning_layers.adapter1.weight",
+            "base_model.model.layernorm0.ln_tuning_layers.adapter1.bias",
+        )
+
+    def test_requires_grad_vera_different_targets(self):
+        # Test two different VeRA adapters that target different modules. Most notably, ensure that vera_A and vera_B
+        # don't require grads.
+
+        config0 = VeraConfig(target_modules=["lin1"])
+        peft_model = get_peft_model(MLP_2x_same_shape(), config0)
+
+        config1 = VeraConfig(target_modules=["lin2"])
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.vera_lambda_b.default",
+            "base_model.model.lin1.vera_lambda_d.default",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.vera_lambda_b.default",
+            "base_model.model.lin1.vera_lambda_d.default",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin2.vera_lambda_b.adapter1",
+            "base_model.model.lin2.vera_lambda_d.adapter1",
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin2.vera_lambda_b.adapter1",
+            "base_model.model.lin2.vera_lambda_d.adapter1",
+        )
+
+    def test_requires_grad_vera_same_targets(self):
+        # Test two different VeRA adapters that target the same module. Most notably, ensure that vera_A and vera_B
+        # don't require grads.
+
+        config0 = VeraConfig(target_modules=["lin1", "lin2"])
+        peft_model = get_peft_model(MLP_2x_same_shape(), config0)
+
+        config1 = VeraConfig(target_modules=["lin1", "lin2"])
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.vera_lambda_b.default",
+            "base_model.model.lin1.vera_lambda_d.default",
+            "base_model.model.lin2.vera_lambda_b.default",
+            "base_model.model.lin2.vera_lambda_d.default",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.vera_lambda_b.default",
+            "base_model.model.lin1.vera_lambda_d.default",
+            "base_model.model.lin2.vera_lambda_b.default",
+            "base_model.model.lin2.vera_lambda_d.default",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.vera_lambda_b.adapter1",
+            "base_model.model.lin1.vera_lambda_d.adapter1",
+            "base_model.model.lin2.vera_lambda_b.adapter1",
+            "base_model.model.lin2.vera_lambda_d.adapter1",
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.vera_lambda_b.adapter1",
+            "base_model.model.lin1.vera_lambda_d.adapter1",
+            "base_model.model.lin2.vera_lambda_b.adapter1",
+            "base_model.model.lin2.vera_lambda_d.adapter1",
+        )
+
+    def test_requires_grad_pvera_different_targets(self):
+        # Test two different PVeRA adapters that target different modules. Most notably, ensure that pvera_A and pvera_B
+        # don't require grads.
+
+        config0 = PveraConfig(target_modules=["lin1"])
+        peft_model = get_peft_model(MLP_2x_same_shape(), config0)
+
+        config1 = PveraConfig(target_modules=["lin2"])
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.pvera_lambda_b.default",
+            "base_model.model.lin1.pvera_lambda_d.default",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.pvera_lambda_b.default",
+            "base_model.model.lin1.pvera_lambda_d.default",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin2.pvera_lambda_b.adapter1",
+            "base_model.model.lin2.pvera_lambda_d.adapter1",
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin2.pvera_lambda_b.adapter1",
+            "base_model.model.lin2.pvera_lambda_d.adapter1",
+        )
+
+    def test_requires_grad_pvera_same_targets(self):
+        # Test two different PVeRA adapters that target the same module. Most notably, ensure that pvera_A and pvera_B
+        # don't require grads.
+
+        config0 = PveraConfig(target_modules=["lin1", "lin2"])
+        peft_model = get_peft_model(MLP_2x_same_shape(), config0)
+
+        config1 = PveraConfig(target_modules=["lin1", "lin2"])
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.pvera_lambda_b.default",
+            "base_model.model.lin1.pvera_lambda_d.default",
+            "base_model.model.lin2.pvera_lambda_b.default",
+            "base_model.model.lin2.pvera_lambda_d.default",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.pvera_lambda_b.default",
+            "base_model.model.lin1.pvera_lambda_d.default",
+            "base_model.model.lin2.pvera_lambda_b.default",
+            "base_model.model.lin2.pvera_lambda_d.default",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.pvera_lambda_b.adapter1",
+            "base_model.model.lin1.pvera_lambda_d.adapter1",
+            "base_model.model.lin2.pvera_lambda_b.adapter1",
+            "base_model.model.lin2.pvera_lambda_d.adapter1",
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.pvera_lambda_b.adapter1",
+            "base_model.model.lin1.pvera_lambda_d.adapter1",
+            "base_model.model.lin2.pvera_lambda_b.adapter1",
+            "base_model.model.lin2.pvera_lambda_d.adapter1",
+        )
+
+    def test_requires_grad_randlora_different_targets(self):
+        # Test two different RandLora adapters that target different modules. Most notably, ensure that randbasis_A and randbasis_B
+        # don't require grads.
+
+        config0 = RandLoraConfig(target_modules=["lin1"])
+        peft_model = get_peft_model(MLP_2x_same_shape(), config0)
+
+        config1 = RandLoraConfig(target_modules=["lin2"])
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.randlora_lambda.default",
+            "base_model.model.lin1.randlora_gamma.default",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.randlora_lambda.default",
+            "base_model.model.lin1.randlora_gamma.default",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin2.randlora_lambda.adapter1",
+            "base_model.model.lin2.randlora_gamma.adapter1",
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin2.randlora_lambda.adapter1",
+            "base_model.model.lin2.randlora_gamma.adapter1",
+        )
+
+    def test_requires_grad_randlora_same_targets(self):
+        # Test two different RandLora adapters that target the same module. Most notably, ensure that randbasis_A and randbasis_B
+        # don't require grads.
+
+        config0 = RandLoraConfig(target_modules=["lin1", "lin2"])
+        peft_model = get_peft_model(MLP_2x_same_shape(), config0)
+
+        config1 = RandLoraConfig(target_modules=["lin1", "lin2"])
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.randlora_lambda.default",
+            "base_model.model.lin1.randlora_gamma.default",
+            "base_model.model.lin2.randlora_lambda.default",
+            "base_model.model.lin2.randlora_gamma.default",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.randlora_lambda.default",
+            "base_model.model.lin1.randlora_gamma.default",
+            "base_model.model.lin2.randlora_lambda.default",
+            "base_model.model.lin2.randlora_gamma.default",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.randlora_lambda.adapter1",
+            "base_model.model.lin1.randlora_gamma.adapter1",
+            "base_model.model.lin2.randlora_lambda.adapter1",
+            "base_model.model.lin2.randlora_gamma.adapter1",
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.randlora_lambda.adapter1",
+            "base_model.model.lin1.randlora_gamma.adapter1",
+            "base_model.model.lin2.randlora_lambda.adapter1",
+            "base_model.model.lin2.randlora_gamma.adapter1",
+        )
+
+    def test_requires_grad_vblora_different_targets(self):
+        # test two different VBLoRA adapters that target different modules
+        config0 = VBLoRAConfig(target_modules=["lin0"], vector_length=1, num_vectors=2)
+        peft_model = get_peft_model(MLP(), config0)
+
+        config1 = VBLoRAConfig(target_modules=["lin1"], vector_length=1, num_vectors=2)
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.vblora_logits_A.default",
+            "base_model.model.lin0.vblora_logits_B.default",
+            "base_model.model.lin0.vblora_vector_bank.default",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.vblora_logits_A.default",
+            "base_model.model.lin0.vblora_logits_B.default",
+            "base_model.model.lin0.vblora_vector_bank.default",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.vblora_logits_A.adapter1",
+            "base_model.model.lin1.vblora_logits_B.adapter1",
+            "base_model.model.lin0.vblora_vector_bank.adapter1",  # vblora_vector_bank is shared
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.vblora_logits_A.adapter1",
+            "base_model.model.lin1.vblora_logits_B.adapter1",
+            "base_model.model.lin0.vblora_vector_bank.adapter1",  # vblora_vector_bank is shared
+        )
+
+    def test_requires_grad_vblora_same_targets(self):
+        # same as previous test, except that VBLoRA adapters target the same layer
+        config0 = VBLoRAConfig(target_modules=["lin0"], vector_length=1, num_vectors=2)
+        peft_model = get_peft_model(MLP(), config0)
+
+        config1 = VBLoRAConfig(target_modules=["lin0"], vector_length=1, num_vectors=2)
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.vblora_logits_A.default",
+            "base_model.model.lin0.vblora_logits_B.default",
+            "base_model.model.lin0.vblora_vector_bank.default",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.vblora_logits_A.default",
+            "base_model.model.lin0.vblora_logits_B.default",
+            "base_model.model.lin0.vblora_vector_bank.default",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.vblora_logits_A.adapter1",
+            "base_model.model.lin0.vblora_logits_B.adapter1",
+            "base_model.model.lin0.vblora_vector_bank.adapter1",
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.vblora_logits_A.adapter1",
+            "base_model.model.lin0.vblora_logits_B.adapter1",
+            "base_model.model.lin0.vblora_vector_bank.adapter1",
+        )
+
+    def test_requires_grad_fourierft_different_targets(self):
+        # test two different fourierft adapters that target different modules
+        config0 = FourierFTConfig(n_frequency=10, target_modules=["lin0"])
+        peft_model = get_peft_model(MLP(), config0)
+
+        config1 = FourierFTConfig(n_frequency=10, target_modules=["lin1"])
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.fourierft_spectrum.default",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.fourierft_spectrum.default",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.fourierft_spectrum.adapter1",
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin1.fourierft_spectrum.adapter1",
+        )
+
+    def test_requires_grad_fourierft_same_targets(self):
+        # same as previous test, except that AdaLora adapters target the same layer
+        config0 = FourierFTConfig(n_frequency=10, target_modules=["lin0"])
+        peft_model = get_peft_model(MLP(), config0)
+
+        config1 = FourierFTConfig(n_frequency=10, target_modules=["lin0"])
+        peft_model.add_adapter("adapter1", config1)
+
+        # active adapter is still "default"
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.fourierft_spectrum.default",
+        )
+
+        # set config0 as active, should not change anything
+        peft_model.set_adapter("default")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.fourierft_spectrum.default",
+        )
+
+        # change activate adapter to adapter1
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.fourierft_spectrum.adapter1",
+        )
+
+        # disable all adapters
+        with peft_model.disable_adapter():
+            self.check_requires_grad(peft_model)
+
+        # after context is exited, return to the previous state
+        peft_model.set_adapter("adapter1")
+        self.check_requires_grad(
+            peft_model,
+            "base_model.model.lin0.fourierft_spectrum.adapter1",
+        )
+
+    @pytest.mark.parametrize("config_cls", ALL_PEFT_CONFIG_CLASSES)
+    @pytest.mark.parametrize("is_trainable", [False, True])  # note: default is False
+    def test_loading_model_requires_grad_set_correctly(self, config_cls, is_trainable, tmp_path):
+        # Test that when loading PeftModel and then loading another adapter, the requires_grad is set correctly and
+        # is_trainable is respected.
+        # See #2759
+        # AdaLoRA's `ranknum` parameter is keyed by adapter name (so name contains ".default") but is intentionally
+        # requires_grad=False, so we exclude it from the trainable-param check below.
+        skip_ranknum = config_cls is AdaLoraConfig
+        model = DeepMLP(size=256)  # a size that works with all adapters
+        extra_kwargs = {}
+        if config_cls == IA3Config:
+            extra_kwargs["feedforward_modules"] = []
+        if config_cls is AdaLoraConfig:
+            extra_kwargs["total_step"] = 1
+        config = config_cls(target_modules=["layers.0.lin0"], **extra_kwargs)
+
+        if config_cls == TrainableTokensConfig:  # TrainbleTokens requires a different base model and config
+            model = ModelEmbConv1D()
+            config = config_cls(target_modules=["emb"], token_indices=[0, 2, 4])
+
+        model = get_peft_model(model, config)
+        model.save_pretrained(tmp_path)
+        del model
+
+        model = DeepMLP(size=256)
+        if config_cls == TrainableTokensConfig:  # TrainbleTokens requires a different base
+            model = ModelEmbConv1D()
+        model = PeftModel.from_pretrained(model, tmp_path, is_trainable=is_trainable)
+
+        if is_trainable:
+            for name, param in model.named_parameters():
+                if skip_ranknum and "ranknum" in name:
+                    continue
+                if ".default" in name:
+                    assert param.requires_grad
+                else:
+                    assert not param.requires_grad
+        else:
+            assert all(not p.requires_grad for p in model.parameters())
+
+        # load one more adapter; this adapter is not automatically activated
+        if config_cls is AdaLoraConfig and is_trainable:
+            # AdaLoRA structurally rejects a second trainable adapter; validate the error path.
+            with pytest.raises(ValueError, match="AdaLoraModel supports only 1 trainable adapter"):
+                model.load_adapter(tmp_path, adapter_name="other", is_trainable=is_trainable)
+            return
+        model.load_adapter(tmp_path, adapter_name="other", is_trainable=is_trainable)
+        if is_trainable:
+            for name, param in model.named_parameters():
+                if skip_ranknum and "ranknum" in name:
+                    continue
+                if ".default" in name:
+                    assert param.requires_grad
+                else:
+                    assert not param.requires_grad
+        else:
+            assert all(not p.requires_grad for p in model.parameters())
+
+    @pytest.mark.parametrize("config_cls", ALL_PEFT_CONFIG_CLASSES)
+    @pytest.mark.parametrize("is_trainable", [False, True])  # note: default is False
+    def test_loading_model_with_modules_to_save_requires_grad_set_correctly(self, config_cls, is_trainable, tmp_path):
+        # Same test as above, but with modules_to_save
+        if config_cls == TrainableTokensConfig:
+            pytest.skip(reason="Trainable tokens does not support modules_to_save")
+        # See note in test_loading_model_requires_grad_set_correctly: AdaLoRA's `ranknum.default` is intentionally
+        # non-trainable, so we exclude it from the trainable-param check below.
+        skip_ranknum = config_cls is AdaLoraConfig
+        model = DeepMLP(size=256)  # a size that works with all adapters
+        extra_kwargs = {}
+        if config_cls == IA3Config:
+            extra_kwargs["feedforward_modules"] = []
+        if config_cls is AdaLoraConfig:
+            extra_kwargs["total_step"] = 1
+        # targeting the different modules with modules_to_save:
+        config = config_cls(target_modules=["layers.0.lin0"], modules_to_save=["layers.0.lin1"], **extra_kwargs)
+        model = get_peft_model(model, config)
+        model.save_pretrained(tmp_path)
+        del model
+
+        model = DeepMLP(size=256)
+        model = PeftModel.from_pretrained(model, tmp_path, is_trainable=is_trainable)
+
+        if is_trainable:
+            for name, param in model.named_parameters():
+                if skip_ranknum and "ranknum" in name:
+                    continue
+                if ".default" in name:
+                    assert param.requires_grad
+                else:
+                    assert not param.requires_grad
+        else:
+            assert all(not p.requires_grad for p in model.parameters())
+
+        # load one more adapter
+        if config_cls is AdaLoraConfig and is_trainable:
+            # AdaLoRA structurally rejects a second trainable adapter; validate the error path.
+            with pytest.raises(ValueError, match="AdaLoraModel supports only 1 trainable adapter"):
+                model.load_adapter(tmp_path, adapter_name="other", is_trainable=is_trainable)
+            return
+        model.load_adapter(tmp_path, adapter_name="other", is_trainable=is_trainable)
+        if is_trainable:
+            for name, param in model.named_parameters():
+                if skip_ranknum and "ranknum" in name:
+                    continue
+                if ".default" in name:
+                    assert param.requires_grad
+                else:
+                    assert not param.requires_grad
+        else:
+            assert all(not p.requires_grad for p in model.parameters())
+
+    @pytest.mark.parametrize("is_trainable", [False, True])  # note: default is False
+    def test_loading_model_with_trainble_tokens_requires_grad_set_correctly(self, is_trainable, tmp_path):
+        model = ModelEmbConv1D()
+        # targeting the same modules with modules_to_save:
+        config = LoraConfig(target_modules=["lin0"], trainable_token_indices={"emb": [0]})
+        model = get_peft_model(model, config)
+        model.save_pretrained(tmp_path)
+        del model
+
+        model = ModelEmbConv1D()
+        model = PeftModel.from_pretrained(model, tmp_path, is_trainable=is_trainable)
+
+        if is_trainable:
+            for name, param in model.named_parameters():
+                if ".default" in name:
+                    assert param.requires_grad
+                else:
+                    assert not param.requires_grad
+        else:
+            assert all(not p.requires_grad for p in model.parameters())
+
+        # load one more adapter
+        model.load_adapter(tmp_path, adapter_name="other", is_trainable=is_trainable)
+        if is_trainable:
+            for name, param in model.named_parameters():
+                if ".default" in name:
+                    assert param.requires_grad
+                else:
+                    assert not param.requires_grad
+        else:
+            assert all(not p.requires_grad for p in model.parameters())
+
+    @pytest.mark.xfail(strict=True)
+    @pytest.mark.parametrize("config_cls", [LoraConfig])  # no need to check each method, they all fail
+    def test_loading_model_requires_grad_set_correctly_switch_inference_mode(self, config_cls, tmp_path):
+        # Same as test_loading_model_requires_grad_set_correctly but this time we first load with is_trainable=False and
+        # then with is_trainable=True. Loading the second adapter should not affect the requires_grad of the first
+        # adapter, but it does. The reason is that is_training/inference_mode is taken from the current PEFT config, but
+        # that config does not necessarily belong to the active adapter, creating a mismatch.
+        # When/If this is fixed, the check can be integrated into test_loading_model_requires_grad_set_correctly and
+        # this test can be deleted.
+        model = DeepMLP(size=256)  # a size that works with all adapters
+        extra_kwargs = {}
+        config = config_cls(target_modules=["layers.0.lin0"])
+        model = get_peft_model(model, config)
+        model.save_pretrained(tmp_path)
+        del model
+
+        model = DeepMLP(size=256)
+        model = PeftModel.from_pretrained(model, tmp_path, is_trainable=False)
+        assert all(not p.requires_grad for p in model.parameters())
+
+        # load one more adapter; this adapter is not automatically activated
+        model.load_adapter(tmp_path, adapter_name="other", is_trainable=True)
+        params_with_grad = [n for n, p in model.named_parameters() if p.requires_grad]
+        expected = [
+            "base_model.model.layers.0.lin0.lora_A.other.weight",
+            "base_model.model.layers.0.lin0.lora_B.other.weight",
+        ]
+        # this fails, instead with get ...lora_A.default.weight and ...lora_B.default.weight
+        assert params_with_grad == expected
+
+    @pytest.mark.xfail(strict=True)
+    @pytest.mark.parametrize("config_cls", [LoraConfig])  # no need to check each method, they all fail
+    def test_loading_model_requires_grad_load_adapter_then_add_adapter(self, config_cls, tmp_path):
+        # When adding a new adapter with model.add_adapter, through the set_adapter call in update_layer, we activate
+        # the gradients of the first adapter, even if it's not desired. Since there is no is_trainable argument on
+        # add_adapter, there is no way to disable that at the moment.
+        # When/If this is fixed, the check can be integrated into test_loading_model_requires_grad_set_correctly and
+        # this test can be deleted.
+        model = DeepMLP(size=256)  # a size that works with all adapters
+        extra_kwargs = {}
+        config = config_cls(target_modules=["layers.0.lin0"])
+        model = get_peft_model(model, config)
+        model.save_pretrained(tmp_path)
+        del model
+
+        model = DeepMLP(size=256)
+        model = PeftModel.from_pretrained(model, tmp_path, is_trainable=False)
+        assert all(not p.requires_grad for p in model.parameters())
+
+        # add a new adapter
+        model.add_adapter(adapter_name="other", peft_config=config)
+        params_with_grad = [n for n, p in model.named_parameters() if p.requires_grad]
+        assert all(not p.requires_grad for p in model.parameters())
+
+
+# this is for PEFT methods that support mixed adapter batches.
+MIXED_ADAPTER_TEST_CASES = [
+    (
+        "LoRA mixed adapter",
+        LoraConfig(target_modules=["lin0"], init_lora_weights=False),
+        LoraConfig(target_modules=["lin0"], r=16, init_lora_weights=False),
+    ),
+    (
+        "RoAd mixed adapter",
+        RoadConfig(target_modules=["lin0"], group_size=2, init_weights=False),
+        RoadConfig(target_modules=["lin0"], group_size=2, variant="road_2", init_weights=False),
+    ),
+    (
+        "GLoRA mixed adapter",
+        GloraConfig(target_modules=["lin0"], init_weights=False),
+        GloraConfig(target_modules=["lin0"], r=16, init_weights=False),
+    ),
+]
+
+
+class TestMixedAdapterBatches:
+    torch_device = infer_device()
+
+    def get_mlp_peft(self, config0, config1):
+        """A simple MLP with 2 LoRA adapters"""
+        torch.manual_seed(0)
+
+        base_model = MLP().to(self.torch_device).eval()
+        peft_model = get_peft_model(base_model, config0, "adapter0").eval()
+        peft_model.add_adapter("adapter1", config1)
+        return peft_model
+
+    def run_checks(self, model, inputs):
+        # This checks that we can have mixed adapters in a single batch. The test works by creating the outputs for the
+        # base model, adapter 0, and adapter 1 separately. Then, we create an output with mixed adapters, where the
+        # sample [0, 3, 6] are for the base model, [1, 4, 7] for adapter 0, and [2, 5, 8] for adapter 1. Finally, we
+        # check that the outputs of the mixed batch are correct for the corresponding indices.
+        adapter_name0, adapter_name1 = model.peft_config.keys()
+
+        with model.disable_adapter():
+            output_base = model(**inputs)
+
+        model.set_adapter(adapter_name0)
+        output0 = model(**inputs)
+
+        # sanity check, outputs are not the same
+        assert not torch.allclose(output_base, output0)
+
+        model.set_adapter(adapter_name1)
+        output1 = model(**inputs)
+
+        # sanity check, outputs have the right shape and are not the same
+        assert len(output_base) >= 3
+        assert len(output_base) == len(output0) == len(output1)
+        assert not torch.allclose(output_base, output0)
+        assert not torch.allclose(output_base, output1)
+
+        # set adapter_indices so that it alternates between base, adapter 0, and adapter 1
+        adapters = ["__base__", adapter_name0, adapter_name1]
+        inputs["adapter_names"] = [adapters[i % 3] for i in (range(len(inputs["X"])))]
+        output_mixed = model.forward(**inputs)
+
+        assert torch.allclose(output_base[::3], output_mixed[::3])
+        assert torch.allclose(output0[1::3], output_mixed[1::3])
+        assert torch.allclose(output1[2::3], output_mixed[2::3])
+
+    @pytest.mark.parametrize("test_name, config0, config1", MIXED_ADAPTER_TEST_CASES)
+    def test_mixed_adapter_batches_mlp(self, test_name, config0, config1):
+        mlp_peft = self.get_mlp_peft(config0, config1)
+        inputs = {"X": torch.arange(90).view(-1, 10).to(self.torch_device)}
+        self.run_checks(mlp_peft, inputs)
+
+    @pytest.mark.parametrize(
+        "test_name, config0, config1",
+        [
+            (
+                "LoRA mixed adapter with different target layers",
+                LoraConfig(target_modules=["lin0"], init_lora_weights=False),
+                LoraConfig(target_modules=["lin1"], init_lora_weights=False),
+            ),
+            (
+                "RoAd mixed adapter with different target layers",
+                RoadConfig(target_modules=["lin0"], group_size=2, init_weights=False),
+                RoadConfig(target_modules=["lin1"], group_size=2, init_weights=False),
+            ),
+            (
+                "GLoRA mixed adapter with different target layers",
+                GloraConfig(target_modules=["lin0"], init_weights=False),
+                GloraConfig(target_modules=["lin1"], init_weights=False),
+            ),
+        ],
+    )
+    def test_mixed_adapter_batches_different_target_layers(self, test_name, config0, config1):
+        base_model = MLP().to(self.torch_device).eval()
+        peft_model = get_peft_model(base_model, config0, "adapter0").eval()
+        peft_model.add_adapter("adapter1", config1)
+        inputs = {"X": torch.arange(90).view(-1, 10).to(self.torch_device)}
+        self.run_checks(peft_model, inputs)
+
+    @pytest.mark.parametrize(
+        "test_name, config0, config1",
+        [
+            (
+                "LoRA mixed adapter with modules to save",
+                LoraConfig(target_modules=["lin0"], modules_to_save=["lin1"], init_lora_weights=False),
+                LoraConfig(target_modules=["lin0"], modules_to_save=["lin1"], init_lora_weights=False),
+            ),
+            (
+                "RoAd mixed adapter with modules to save",
+                RoadConfig(target_modules=["lin0"], modules_to_save=["lin1"], group_size=2, init_weights=False),
+                RoadConfig(target_modules=["lin0"], modules_to_save=["lin1"], group_size=2, init_weights=False),
+            ),
+            (
+                "GLoRA mixed adapter with modules to save",
+                GloraConfig(target_modules=["lin0"], modules_to_save=["lin1"], init_weights=False),
+                GloraConfig(target_modules=["lin0"], modules_to_save=["lin1"], init_weights=False),
+            ),
+        ],
+    )
+    def test_mixed_adapter_batches_multiple_modules_to_save(self, test_name, config0, config1):
+        base_model = MLP().to(self.torch_device).eval()
+        peft_model = get_peft_model(base_model, config0, "adapter0").eval()
+        peft_model.add_adapter("adapter1", config1)
+        inputs = {"X": torch.arange(90).view(-1, 10).to(self.torch_device)}
+        self.run_checks(peft_model, inputs)
+
+    @pytest.mark.parametrize(
+        "test_name, config0, config1",
+        [
+            (
+                "LoRA mixed adapter with unsupported layer",
+                LoraConfig(target_modules=["lin0"], modules_to_save=["gru"], init_lora_weights=False),
+                LoraConfig(target_modules=["lin0"], modules_to_save=["gru"], init_lora_weights=False),
+            ),
+        ],
+    )
+    def test_mixed_adapter_batches_unsupported_layer_raises(self, test_name, config0, config1):
+        base_model = MLPWithGRU().to(self.torch_device).eval()
+        peft_model = get_peft_model(base_model, config0, "adapter0").eval()
+        peft_model.add_adapter("adapter1", config1)
+        inputs = {"X": torch.arange(90).view(-1, 10).to(self.torch_device)}
+        SUPPORTED_MODULES = (torch.nn.Linear, torch.nn.Embedding, torch.nn.Conv1d, torch.nn.Conv2d, torch.nn.Conv3d)
+        module_names = ", ".join([module.__name__ for module in SUPPORTED_MODULES])
+        with pytest.raises(
+            TypeError, match=f"Mixed batching is only supported for the following modules: {module_names}."
+        ):
+            self.run_checks(peft_model, inputs)
+
+    @pytest.mark.parametrize(
+        "test_name, config0, config1",
+        [
+            (
+                "LoRA mixed adapter with overlapping layers",
+                LoraConfig(target_modules=["lin0"], init_lora_weights=False),
+                LoraConfig(target_modules=["lin0", "lin1"], init_lora_weights=False),
+            ),
+            (
+                "RoAd mixed adapter with overlapping layers",
+                RoadConfig(target_modules=["lin0"], group_size=2, init_weights=False),
+                RoadConfig(target_modules=["lin0", "lin1"], group_size=2, init_weights=False),
+            ),
+            (
+                "GLoRA mixed adapter with overlapping layers",
+                GloraConfig(target_modules=["lin0"], init_weights=False),
+                GloraConfig(target_modules=["lin0", "lin1"], init_weights=False),
+            ),
+        ],
+    )
+    def test_mixed_adapter_batches_partly_overlapping_target_layers(self, test_name, config0, config1):
+        base_model = MLP().to(self.torch_device).eval()
+        # target different lora layers
+        peft_model = get_peft_model(base_model, config0, "adapter0").eval()
+        peft_model.add_adapter("adapter1", config1)
+
+        inputs = {"X": torch.arange(90).view(-1, 10).to(self.torch_device)}
+        self.run_checks(peft_model, inputs)
+
+    @pytest.mark.parametrize(
+        "test_name, config0, config1",
+        [
+            (
+                "LoRA mixed adapter with conv1d",
+                LoraConfig(target_modules=["emb", "conv1d"], init_lora_weights=False),
+                LoraConfig(target_modules=["emb", "conv1d"], r=16, init_lora_weights=False),
+            ),
+        ],
+    )
+    def test_mixed_adapter_batches_lora_conv1d_emb(self, test_name, config0, config1):
+        base_model = ModelEmbConv1D().to(self.torch_device).eval()
+        peft_model = get_peft_model(base_model, config0, "adapter0").eval()
+        peft_model.add_adapter("adapter1", config1)
+
+        inputs = {"X": torch.arange(90).view(-1, 10).to(self.torch_device)}
+        self.run_checks(peft_model, inputs)
+
+    @pytest.mark.parametrize(
+        "test_name, config0, config1",
+        [
+            (
+                "LoRA mixed adapter with conv1d and emb and modules to save",
+                LoraConfig(target_modules=["emb", "conv1d"], modules_to_save=["lin0"], init_lora_weights=False),
+                LoraConfig(target_modules=["emb", "conv1d"], modules_to_save=["lin0"], init_lora_weights=False),
+            ),
+        ],
+    )
+    def test_mixed_adapter_batches_lora_conv1d_emb_multiple_modules_to_save(self, test_name, config0, config1):
+        base_model = ModelEmbConv1D().to(self.torch_device).eval()
+        peft_model = get_peft_model(base_model, config0, "adapter0").eval()
+        peft_model.add_adapter("adapter1", config1)
+        inputs = {"X": torch.arange(90).view(-1, 10).to(self.torch_device)}
+        self.run_checks(peft_model, inputs)
+
+    @pytest.mark.parametrize(
+        "test_name, config0, config1",
+        [
+            (
+                "LoRA mixed adapter with conv2d",
+                LoraConfig(target_modules=["conv2d"], init_lora_weights=False),
+                LoraConfig(target_modules=["conv2d"], r=16, init_lora_weights=False),
+            ),
+        ],
+    )
+    def test_mixed_adapter_batches_lora_conv2d(self, test_name, config0, config1):
+        base_model = ModelConv2D().to(self.torch_device).eval()
+        peft_model = get_peft_model(base_model, config0, "adapter0").eval()
+        peft_model.add_adapter("adapter1", config1)
+
+        inputs = {"X": torch.arange(270).view(6, 5, 3, 3).to(self.torch_device)}
+        self.run_checks(peft_model, inputs)
+
+    @pytest.mark.parametrize(
+        "test_name, config0, config1",
+        [
+            (
+                "LoRA mixed adapter with mha",
+                LoraConfig(target_modules=["mha"], init_lora_weights=False),
+                LoraConfig(target_modules=["mha"], r=16, init_lora_weights=False),
+            ),
+        ],
+    )
+    def test_mixed_adapter_batches_mha_raises(self, test_name, config0, config1):
+        base_model = ModelMha().to(self.torch_device).eval()
+        peft_model = get_peft_model(base_model, config0, "adapter0").eval()
+        peft_model.add_adapter("adapter1", config1)
+
+        inputs = {"X": torch.arange(90).view(-1, 10).to(self.torch_device)}
+        msg = "lora.MultiheadAttention does not support mixed adapter batches"
+        with pytest.raises(TypeError, match=msg):
+            self.run_checks(peft_model, inputs)
+
+    @pytest.mark.parametrize("test_name, config0, config1", MIXED_ADAPTER_TEST_CASES)
+    def test_mixed_adapter_batches_length_mismatch_raises(self, test_name, config0, config1):
+        mlp_peft = self.get_mlp_peft(config0, config1)
+        inputs = {
+            "X": torch.arange(90).view(-1, 10).to(self.torch_device),
+            "adapter_names": ["__base__"] * 5,  # wrong length!
+        }
+        msg = r"Length of `adapter_names` should be the same as the number of inputs, but got "
+        with pytest.raises(ValueError, match=msg):
+            mlp_peft.forward(**inputs)
+
+    @pytest.mark.parametrize("test_name, config0, config1", MIXED_ADAPTER_TEST_CASES)
+    def test_mixed_adapter_batches_training_mode_raises(self, test_name, config0, config1):
+        mlp_peft = self.get_mlp_peft(config0, config1)
+        inputs = {
+            "X": torch.arange(90).view(-1, 10).to(self.torch_device),
+            "adapter_names": ["__base__"] * 9,
+        }
+        mlp_peft = mlp_peft.train()
+        msg = r"Cannot pass `adapter_names` when the model is in training mode."
+        with pytest.raises(ValueError, match=msg):
+            mlp_peft.forward(**inputs)
+
+    @pytest.mark.parametrize("test_name, config0, config1", MIXED_ADAPTER_TEST_CASES)
+    def test_mixed_adapter_batches_disabled(self, test_name, config0, config1):
+        # Disabling adapters should have precedence over passing adapter names
+        mlp_peft = self.get_mlp_peft(config0, config1)
+        inputs = {"X": torch.arange(90).view(-1, 10).to(self.torch_device)}
+        with mlp_peft.disable_adapter():
+            output_disabled = mlp_peft(**inputs)
+
+        adapters = ["__base__", "adapter0", "adapter1"]
+        inputs["adapter_names"] = [adapters[i % 3] for i in (range(len(inputs["X"])))]
+        with mlp_peft.disable_adapter():
+            output_mixed = mlp_peft.forward(**inputs)
+
+        assert torch.allclose(output_disabled, output_mixed)
+
+    @pytest.mark.parametrize("test_name, config0, config1", MIXED_ADAPTER_TEST_CASES)
+    def test_mixed_adapter_batches_merged_raises(self, test_name, config0, config1):
+        # When there are merged adapters, passing adapter names should raise an error
+        mlp_peft = self.get_mlp_peft(config0, config1)
+        inputs = {
+            "X": torch.arange(90).view(-1, 10).to(self.torch_device),
+            "adapter_names": ["adapter0"] * 9,
+        }
+        mlp_peft.merge_adapter(["adapter0"])
+        msg = r"Cannot pass `adapter_names` when there are merged adapters, please call `unmerge_adapter` first."
+        with pytest.raises(ValueError, match=msg):
+            mlp_peft.forward(**inputs)
+
+    @pytest.mark.parametrize(
+        "test_name, config",
+        [
+            (
+                "LoRA mixed batch wrong adapter name",
+                LoraConfig(target_modules=["lin0"], init_lora_weights=False),
+            ),
+            (
+                "RoAD mixed batch wrong adapter name",
+                RoadConfig(target_modules=["lin0"], group_size=2, init_weights=False),
+            ),
+            (
+                "GLoRA mixed batch wrong adapter name",
+                GloraConfig(target_modules=["lin0"], init_weights=False),
+            ),
+        ],
+    )
+    def test_mixed_adapter_batches_lora_wrong_adapter_name_raises(self, test_name, config):
+        # Ensure that all of the adapter names that are being passed actually exist
+        torch.manual_seed(0)
+        x = torch.arange(90).view(-1, 10).to(self.torch_device)
+
+        base_model = MLP().to(self.torch_device).eval()
+        peft_model = get_peft_model(base_model, config).eval()
+        peft_model.add_adapter(adapter_name="other", peft_config=config)
+
+        # sanity check: this works
+        peft_model.forward(x, adapter_names=["default"] * 5 + ["other"] * 4)
+
+        # check one correct and one incorrect adapter
+        msg = re.escape("Trying to infer with non-existing adapter(s): does-not-exist")
+        with pytest.raises(ValueError, match=msg):
+            peft_model.forward(x, adapter_names=["default"] * 5 + ["does-not-exist"] * 4)
+
+        # check two correct adapters and one incorrect adapter
+        with pytest.raises(ValueError, match=msg):
+            peft_model.forward(x, adapter_names=["default"] * 3 + ["does-not-exist"] * 4 + ["other"] * 2)
+
+        # check only incorrect adapters
+        msg = re.escape("Trying to infer with non-existing adapter(s): does-not-exist, other-does-not-exist")
+        with pytest.raises(ValueError, match=msg):
+            peft_model.forward(x, adapter_names=["does-not-exist"] * 5 + ["other-does-not-exist"] * 4)
+
+    def test_mixed_adapter_batches_lora_with_dora_raises(self):
+        # When there are DoRA adapters, passing adapter names should raise an error
+        torch.manual_seed(0)
+        inputs = {
+            "X": torch.arange(90).view(-1, 10).to(self.torch_device),
+            "adapter_names": ["default"] * 9,
+        }
+
+        base_model = MLP().to(self.torch_device).eval()
+        config = LoraConfig(target_modules=["lin0"], init_lora_weights=False, use_dora=True)
+        peft_model = get_peft_model(base_model, config).eval()
+        msg = r"Cannot pass `adapter_names` when DoRA is enabled."
+        with pytest.raises(ValueError, match=msg):
+            peft_model.forward(**inputs)
+
+    def test_mixed_adapter_batches_lora_with_dora_but_dora_not_included_works(self):
+        # When there are DoRA adapters, passing adapter names should raise an error, see previous test. However, when
+        # the adapter that uses DoRA is not included in adapter_names, it's actually fine.
+        torch.manual_seed(0)
+        base_model = MLP().to(self.torch_device).eval()
+        config_dora = LoraConfig(target_modules=["lin0"], init_lora_weights=False, use_dora=True)
+        peft_model = get_peft_model(base_model, config_dora)
+        config_no_dora = LoraConfig(target_modules=["lin0"], init_lora_weights=False, use_dora=False)
+        peft_model.add_adapter(adapter_name="other", peft_config=config_no_dora)
+        peft_model.eval()
+
+        # The "default" adapter uses DoRA but "other" is not using it, so using "other" is fine. Also, "__base__" is
+        # fine since it uses the base model and thus DoRA is not involved either.
+        inputs = {
+            "X": torch.arange(90).view(-1, 10).to(self.torch_device),
+            "adapter_names": ["other"] * 4 + ["__base__"] * 5,
+        }
+        peft_model.forward(**inputs)
+
+    @pytest.mark.parametrize(
+        "test_name, config0, config1, factor",
+        [
+            (
+                "LoRA mixed adapter timing",
+                LoraConfig(task_type="CAUSAL_LM", init_lora_weights=False),
+                LoraConfig(task_type="CAUSAL_LM", r=16, init_lora_weights=False),
+                2.0,
+            ),
+            (
+                "RoAd mixed adapter timing",
+                RoadConfig(task_type="CAUSAL_LM", init_weights=False),
+                RoadConfig(task_type="CAUSAL_LM", variant="road_2", init_weights=False),
+                3.0,
+            ),
+        ],
+    )
+    @require_non_cpu
+    def test_mixed_adapter_batches_lora_opt_timing(self, test_name, config0, config1, factor):
+        # Use a more realistic model (opt-125m) and do a simple runtime check to ensure that mixed adapter batches
+        # don't add too much overhead. These types of tests are inherently flaky, so we try to add in some robustness.
+        logs = []  # store the time it takes to run each forward pass here
+
+        @contextmanager
+        def timed():
+            tic = time.perf_counter()
+            yield
+            toc = time.perf_counter()
+            logs.append(toc - tic)
+
+        base_model = (
+            AutoModelForCausalLM.from_pretrained("peft-internal-testing/opt-125m").to(self.torch_device).eval()
+        )
+        inputs = {"input_ids": torch.randint(0, 1000, (16, 64)).to(self.torch_device)}
+        with timed():
+            output_base = base_model(**inputs).logits
+
+        peft_model = get_peft_model(base_model, config0, "adapter1").eval()
+        with timed():
+            output0 = peft_model(**inputs).logits
+
+        # sanity check, outputs are not the same
+        assert not torch.allclose(output_base, output0)
+
+        peft_model.add_adapter("adapter2", config1)
+        peft_model.set_adapter("adapter2")
+        with timed():
+            output1 = peft_model(**inputs).logits
+
+        # sanity check, outputs are not the same
+        assert not torch.allclose(output_base, output1)
+
+        # set adapter_indices so that it alternates between 0 (base), lora 1, and lora 2
+        adapters = ["__base__", "adapter1", "adapter2"]
+        inputs["adapter_names"] = [adapters[i % 3] for i in (range(len(inputs["input_ids"])))]
+        with timed():
+            output_mixed = peft_model.forward(**inputs).logits
+
+        atol, rtol = 1e-4, 1e-4
+        assert torch.allclose(output_base[::3], output_mixed[::3], atol=atol, rtol=rtol)
+        assert torch.allclose(output0[1::3], output_mixed[1::3], atol=atol, rtol=rtol)
+        assert torch.allclose(output1[2::3], output_mixed[2::3], atol=atol, rtol=rtol)
+
+        # Check that the overhead in time added by mixed batches is not too high.
+        # To prevent flakiness, we measure mixed inference 3 times and take the lowest value, then compare it to the mean
+        # of the non-mixed inference times. We also grant a generous margin of 2x the mean time.
+        with timed():
+            output_mixed = peft_model.forward(**inputs).logits
+        with timed():
+            output_mixed = peft_model.forward(**inputs).logits
+
+        time_base, time0, time1, *time_mixed = logs
+        time_non_mixed = (time_base + time0 + time1) / 3
+        time_mixed = min(time_mixed)
+
+        assert time_mixed < factor * time_non_mixed
+
+        # Measure timing of running base and adapter separately vs using a mixed batch. Note that on CPU, the
+        # differences are quite small, so this test requires GPU to avoid flakiness.
+        for _ in range(3):
+            with timed():
+                with peft_model.disable_adapter():
+                    peft_model(**{k: v[::3] for k, v in inputs.items()})
+                peft_model.set_adapter("adapter1")
+                peft_model(**{k: v[1::3] for k, v in inputs.items()})
+                peft_model.set_adapter("adapter2")
+                peft_model(**{k: v[2::3] for k, v in inputs.items()})
+
+        times_separate = logs[-3:]
+        time_separate = sum(times_separate) / 3
+        assert time_separate > time_mixed
+
+
+class TestDynamicDispatch:
+    # These are tests for the dynamic dispatch feature for LoRA. We create a custom module and a custom LoRA layer
+    # that targets it.
+
+    @pytest.fixture(scope="class")
+    def custom_module_cls(self):
+        class MyModule(nn.Module):
+            # A custom layer that just behaves like an nn.Linear layer but is not an instance of nn.Linear. Therefore,
+            # it would normally fail to be targeted.
+            def __init__(self):
+                super().__init__()
+                self.in_features = 10
+                self.out_features = 20
+                self.weight = nn.Parameter(torch.randn(20, 10))
+
+            def forward(self, x):
+                return nn.functional.linear(x, self.weight)
+
+        return MyModule
+
+    @pytest.fixture(scope="class")
+    def custom_lora_cls(self):
+        from peft.tuners import lora
+
+        class MyLora(lora.Linear):
+            # just re-use the lora.Linear code here
+            pass
+
+        return MyLora
+
+    @pytest.fixture(scope="class")
+    def model_cls(self, custom_module_cls):
+        class MyModel(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.lin0 = nn.Linear(10, 10)
+                self.relu = nn.ReLU()
+                self.my_module = custom_module_cls()
+                self.lin1 = nn.Linear(20, 2)
+
+            def forward(self, x):
+                x = self.relu(self.lin0(x))
+                x = self.relu(self.my_module(x))
+                x = self.lin1(x)
+                return x
+
+        return MyModel
+
+    def test_custom_lora_layer_used(self, custom_module_cls, custom_lora_cls, model_cls):
+        # check that when we register custom lora layers, they are indeed being used for the intended module
+        model = model_cls()
+        config = LoraConfig(target_modules=["lin0", "my_module", "lin1"])
+        config._register_custom_module({custom_module_cls: custom_lora_cls})
+
+        peft_model = get_peft_model(model, config)
+        assert isinstance(peft_model.base_model.model.my_module, custom_lora_cls)
+        assert isinstance(peft_model.base_model.model.my_module.base_layer, custom_module_cls)
+        # sanity check that the other lora layer types are still the default ones
+        assert not isinstance(peft_model.base_model.model.lin0.base_layer, custom_module_cls)
+        assert not isinstance(peft_model.base_model.model.lin1.base_layer, custom_module_cls)
+
+    def test_training_works(self, model_cls, custom_module_cls, custom_lora_cls):
+        # check that when we train with custom lora layers, they are indeed updated
+        model = model_cls()
+        config = LoraConfig(target_modules=["lin0", "my_module", "lin1"])
+        config._register_custom_module({custom_module_cls: custom_lora_cls})
+
+        peft_model = get_peft_model(model, config)
+        sd_before = copy.deepcopy(peft_model.state_dict())
+        inputs = torch.randn(16, 10)
+        optimizer = torch.optim.SGD(peft_model.parameters(), lr=1e-4)
+
+        for _ in range(5):
+            optimizer.zero_grad()
+            output = peft_model(inputs)
+            loss = output.sum() ** 2
+            loss.backward()
+            optimizer.step()
+
+        sd_after = peft_model.state_dict()
+
+        # sanity check that for finite results, since nan != nan, which would make the test pass trivially
+        for val in sd_before.values():
+            assert torch.isfinite(val).all()
+        for val in sd_after.values():
+            assert torch.isfinite(val).all()
+
+        assert not torch.allclose(
+            sd_before["base_model.model.my_module.lora_A.default.weight"],
+            sd_after["base_model.model.my_module.lora_A.default.weight"],
+        )
+        assert not torch.allclose(
+            sd_before["base_model.model.my_module.lora_B.default.weight"],
+            sd_after["base_model.model.my_module.lora_B.default.weight"],
+        )
+
+    def test_saving_and_loading(self, custom_module_cls, custom_lora_cls, model_cls, tmp_path):
+        # check that we can successfully save and load the custom lora cls
+        torch.manual_seed(0)
+        model = model_cls()
+        config = LoraConfig(target_modules=["lin0", "my_module", "lin1"])
+        config._register_custom_module({custom_module_cls: custom_lora_cls})
+
+        torch.manual_seed(1)
+        peft_model = get_peft_model(model, config)
+
+        inputs = torch.randn(5, 10)
+        outputs_before = peft_model(inputs)  # does not raise
+
+        sd_before = peft_model.state_dict()
+        peft_model.save_pretrained(tmp_path / "lora-custom-module")
+        del model, peft_model
+
+        torch.manual_seed(0)  # same seed for base model
+        model = model_cls()
+
+        # custom lora mapping is not persisted at the moment, so as a workaround this is needed
+        config = LoraConfig.from_pretrained(tmp_path / "lora-custom-module")
+        config._register_custom_module({custom_module_cls: custom_lora_cls})
+
+        # different seed for adapter to ensure it is not identical just because of seed
+        torch.manual_seed(123)
+        peft_model = PeftModel.from_pretrained(model, tmp_path / "lora-custom-module", config=config)
+        assert isinstance(peft_model.base_model.model.my_module, custom_lora_cls)
+        assert isinstance(peft_model.base_model.model.my_module.base_layer, custom_module_cls)
+
+        outputs_after = peft_model(inputs)  # does not raise
+        assert torch.allclose(outputs_before, outputs_after)
+
+        sd_after = peft_model.state_dict()
+        assert sd_before.keys() == sd_after.keys()
+        for key in sd_before.keys():
+            assert torch.allclose(sd_before[key], sd_after[key])
+
+    def test_override_lora_linear(self, custom_lora_cls):
+        # in this test, we check if users can override default PEFT behavior by supplying a custom lora class that is
+        # being used instead of lora.Linear
+        model = AutoModelForCausalLM.from_pretrained("peft-internal-testing/opt-125m")
+        config = LoraConfig(task_type=TaskType.CAUSAL_LM)
+        config._register_custom_module({nn.Linear: custom_lora_cls})
+        peft_model = get_peft_model(model, config)
+        layers = peft_model.base_model.model.model.decoder.layers
+        for layer in layers:
+            assert isinstance(layer.self_attn.v_proj, custom_lora_cls)
+            assert isinstance(layer.self_attn.q_proj, custom_lora_cls)
+
+    def test_custom_lora_layer_issues_warning(self, custom_module_cls, custom_lora_cls, model_cls, recwarn):
+        # users will get a warning if they target a layer type that is not officially supported
+        model = model_cls()
+        config = LoraConfig(target_modules=["lin0", "my_module", "lin1"])
+        config._register_custom_module({custom_module_cls: custom_lora_cls})
+
+        get_peft_model(model, config)
+        # check warning message
+        msg = (
+            "Unsupported layer type '<class 'tests.test_custom_models.TestDynamicDispatch.custom_module_cls."
+            "<locals>.MyModule'>' encountered, proceed at your own risk."
+        )
+        assert str(recwarn.list[-1].message) == msg
+
+    def test_target_layer_without_in_features_out_features(self, recwarn):
+        # It should be possible for users to target layers even if we cannot determine in_features and out_features.
+        # Those are only needed to initialize the LoRA layer via update_layer, so as long as users take care of that,
+        # they should be good and not require those attributes to exist
+        class MyModel(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.lstm = nn.LSTM(10, 20)
+
+        class MyLora(nn.Module, lora.LoraLayer):
+            def __init__(self, base_layer, adapter_name, **kwargs):
+                super().__init__()
+                lora.LoraLayer.__init__(self, base_layer, **kwargs)
+                self._active_adapter = adapter_name
+
+        model = MyModel()
+        # check that in_features and out_features attributes don't exist on LSTM
+        assert not hasattr(model.lstm, "in_features")
+        assert not hasattr(model.lstm, "out_features")
+
+        config = LoraConfig(target_modules=["lstm"])
+        config._register_custom_module({nn.LSTM: MyLora})
+        peft_model = get_peft_model(model, config)
+
+        # check that custom LoRA layer is correctly applied
+        assert isinstance(peft_model.base_model.lstm, MyLora)
+        assert isinstance(peft_model.base_model.lstm.base_layer, nn.LSTM)
+
+        # we should still get a warning message
+        msg = "Unsupported layer type '<class 'torch.nn.modules.rnn.LSTM'>' encountered, proceed at your own risk."
+        assert str(recwarn.list[-1].message) == msg
+
+
+class TestDefaultTargetModules:
+    """Tests that the default target_modules work as expected
+
+    Here we only test DeLoRA, LoRA, and OSF. DeLoRA was chosen since it uses the default implementation in BaseTuner
+    that the other PEFT methods share. Testing all PEFT methods would thus be wasteful and it would require some effort
+    to patch the correct target module mapping.
+
+    Only LoRA and OSF have custom implementations, thus they are tested here explicitly.
+    """
+
+    @pytest.mark.parametrize("config_cls", [DeloraConfig, LoraConfig])
+    def test_default_target_modules_not_set_raises(self, config_cls):
+        # With a custom model and without explicit target_modules, raise an error
+        model = MLP()
+        config = config_cls()  # no target modules
+        with pytest.raises(ValueError, match="Please specify `target_modules`"):
+            get_peft_model(model, config)
+
+    @pytest.mark.parametrize("config_cls", [DeloraConfig, LoraConfig])
+    def test_default_target_modules_not_set_model_type_set_raises(self, config_cls):
+        # With a transformers-like model but without default target modules, raise an error
+        model = MLP()
+        # create a mock model_config that mimics transformers
+        model_config = MagicMock(return_value="foobar")
+        model_config.to_dict.return_value = {"model_type": "foobar"}
+        model.config = model_config
+
+        peft_config = config_cls()  # no target modules
+        with pytest.raises(ValueError, match="Please specify `target_modules`"):
+            get_peft_model(model, peft_config)
+
+    @pytest.mark.parametrize("config_cls", [DeloraConfig, LoraConfig])
+    def test_default_target_modules_list_of_str(self, config_cls, monkeypatch):
+        # With a transformers-like model and with default target modules as list of str, it works
+        from peft.tuners.delora.model import TRANSFORMERS_MODELS_TO_DELORA_TARGET_MODULES_MAPPING
+        from peft.tuners.lora.model import TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING
+
+        model = MLP()
+        # create a mock model_config that mimics transformers
+        model_config = MagicMock()
+        model_config.to_dict.return_value = {"model_type": "foobar"}
+        model.config = model_config
+        monkeypatch.setitem(TRANSFORMERS_MODELS_TO_DELORA_TARGET_MODULES_MAPPING, "foobar", ["lin0"])
+        monkeypatch.setitem(TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING, "foobar", ["lin0"])
+
+        peft_config = config_cls()  # no target modules
+        model = get_peft_model(model, peft_config)
+        assert model.targeted_module_names == ["lin0"]
+        assert model.peft_config["default"].target_modules == {"lin0"}
+
+    @pytest.mark.parametrize("config_cls", [DeloraConfig, LoraConfig])
+    def test_default_target_modules_str(self, config_cls, monkeypatch):
+        # With a transformers-like model and with default target modules as a str, it works
+        from peft.tuners.delora.model import TRANSFORMERS_MODELS_TO_DELORA_TARGET_MODULES_MAPPING
+        from peft.tuners.lora.model import TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING
+
+        model = MLP()
+        # create a mock model_config that mimics transformers
+        model_config = MagicMock()
+        model_config.to_dict.return_value = {"model_type": "foobar"}
+        model.config = model_config
+        monkeypatch.setitem(TRANSFORMERS_MODELS_TO_DELORA_TARGET_MODULES_MAPPING, "foobar", "lin0")
+        monkeypatch.setitem(TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING, "foobar", "lin0")
+
+        peft_config = config_cls()  # no target modules
+        model = get_peft_model(model, peft_config)
+        assert model.targeted_module_names == ["lin0"]
+        assert model.peft_config["default"].target_modules == "lin0"
+
+    def test_default_target_modules_osf(self):
+        # OSF defaults to targeting all linear layers
+        model = MLP()
+        config = OSFConfig()  # no target modules
+        model = get_peft_model(model, config)
+        assert model.targeted_module_names == ["lin0", "lin1"]
+        assert model.peft_config["default"].target_modules == {"lin0", "lin1"}
diff --git a/tests/test_decoder_models.py b/tests/test_decoder_models.py
new file mode 100644
index 0000000..868fe97
--- /dev/null
+++ b/tests/test_decoder_models.py
@@ -0,0 +1,1243 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+import json
+import platform
+import tempfile
+from unittest.mock import Mock, call, patch
+
+import pytest
+import torch
+from accelerate.test_utils.testing import get_backend
+from safetensors.torch import load_file as safe_load_file
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    DataCollatorForLanguageModeling,
+    Trainer,
+    TrainingArguments,
+)
+from transformers.modeling_outputs import CausalLMOutputWithPast
+
+from peft import (
+    AdaLoraConfig,
+    BeftConfig,
+    BOFTConfig,
+    C3AConfig,
+    CartridgeConfig,
+    CPTConfig,
+    DeftConfig,
+    DeloraConfig,
+    FourierFTConfig,
+    FrodConfig,
+    GloraConfig,
+    GraloraConfig,
+    HiraConfig,
+    HRAConfig,
+    IA3Config,
+    LoraConfig,
+    MissConfig,
+    OFTConfig,
+    OSFConfig,
+    PrefixTuningConfig,
+    PromptEmbedding,
+    PromptEncoderConfig,
+    PromptTuningConfig,
+    PromptTuningInit,
+    PsoftConfig,
+    PveraConfig,
+    RoadConfig,
+    ShiraConfig,
+    TaskType,
+    TinyLoraConfig,
+    UniLoraConfig,
+    VBLoRAConfig,
+    VeraConfig,
+    WaveFTConfig,
+    get_peft_model,
+)
+
+from .testing_common import PeftCommonTester
+from .testing_utils import device_count, hub_online_once, load_dataset_english_quotes, set_init_weights_false
+
+
+# Note: some models from peft-internal-testing are just the safetensors versions of hf-internal-testing
+PEFT_DECODER_MODELS_TO_TEST = [
+    "peft-internal-testing/tiny-random-OPTForCausalLM",
+    "peft-internal-testing/tiny-random-GPT2LMHeadModel",
+    "peft-internal-testing/tiny-random-GPTJForCausalLM",
+    "trl-internal-testing/tiny-random-LlamaForCausalLM",
+    "peft-internal-testing/tiny-dummy-qwen2",
+    "hf-internal-testing/tiny-random-Gemma3ForCausalLM",
+]
+
+SMALL_GRID_MODELS = [
+    "hf-internal-testing/tiny-random-gpt2",
+    "peft-internal-testing/tiny-random-OPTForCausalLM",
+    "hf-internal-testing/tiny-random-MistralForCausalLM",
+    "peft-internal-testing/tiny-dummy-qwen2",
+    "trl-internal-testing/tiny-random-LlamaForCausalLM",
+]
+
+
+# TODO Missing from this list are LoKr, LoHa, LN Tuning, add them
+# Note: If the PEFT method offers an initialization option to make it an identity transform (typically via the
+# init_weights argument), then this option should be set here, if it's not already the default.
+ALL_CONFIGS = [
+    (
+        AdaLoraConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "target_modules": None,
+            "total_step": 1,
+        },
+    ),
+    (
+        BeftConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "target_modules": None,
+        },
+    ),
+    (
+        BOFTConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "target_modules": None,
+        },
+    ),
+    (
+        MissConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "target_modules": None,
+            "r": 2,
+        },
+    ),
+    (
+        CPTConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "cpt_token_ids": [0, 1, 2, 3, 4, 5, 6, 7],  # Example token IDs for testing
+            "cpt_mask": [1, 1, 1, 1, 1, 1, 1, 1],
+            "cpt_tokens_type_mask": [1, 2, 2, 2, 3, 3, 4, 4],
+        },
+    ),
+    (
+        DeftConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "target_modules": None,
+        },
+    ),
+    (
+        DeloraConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "target_modules": None,
+            "r": 2,
+        },
+    ),
+    (
+        FourierFTConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "n_frequency": 10,
+            "target_modules": None,
+        },
+    ),
+    (
+        FrodConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "target_modules": None,
+            "sparse_rate": 0.01,
+        },
+    ),
+    (
+        GraloraConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "r": 8,
+            "alpha": 16,
+            "target_modules": None,
+            "gralora_dropout": 0.05,
+            "gralora_k": 2,
+            "hybrid_r": 0,
+        },
+    ),
+    (
+        GraloraConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "r": 16,
+            "alpha": 32,
+            "target_modules": None,
+            "gralora_dropout": 0.05,
+            "gralora_k": 4,
+            "hybrid_r": 4,
+        },
+    ),
+    (
+        GloraConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "target_modules": None,
+            "init_weights": True,
+        },
+    ),
+    (
+        GloraConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "target_modules": None,
+            "init_weights": False,
+        },
+    ),
+    (
+        HiraConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "target_modules": None,
+        },
+    ),
+    (
+        HRAConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "target_modules": None,
+        },
+    ),
+    (
+        IA3Config,
+        {
+            "task_type": "CAUSAL_LM",
+            "target_modules": None,
+            "feedforward_modules": None,
+        },
+    ),
+    (
+        LoraConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "r": 8,
+            "lora_alpha": 32,
+            "target_modules": None,
+            "lora_dropout": 0.05,
+            "bias": "none",
+        },
+    ),
+    # Activated LoRA (aLoRA)
+    (
+        LoraConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "r": 8,
+            "lora_alpha": 32,
+            "target_modules": None,
+            "lora_dropout": 0.05,
+            "bias": "none",
+            "alora_invocation_tokens": [1],
+        },
+    ),
+    (
+        LoraConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "r": 8,
+            "lora_alpha": 32,
+            "target_modules": None,
+            "lora_dropout": 0.05,
+            "bias": "none",
+            # not one test input sequence will ever have this token, this should do nothing at all
+            "alora_invocation_tokens": [1000],
+        },
+    ),
+    # LoRA + trainable tokens
+    (
+        LoraConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "r": 8,
+            "lora_alpha": 32,
+            "target_modules": None,
+            "lora_dropout": 0.05,
+            "bias": "none",
+            "trainable_token_indices": [0, 1, 3],
+        },
+    ),
+    (
+        OFTConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "target_modules": None,
+        },
+    ),
+    (
+        PrefixTuningConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "num_virtual_tokens": 10,
+        },
+    ),
+    (
+        PrefixTuningConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "num_virtual_tokens": 10,
+            "init_weights": "zero",
+        },
+    ),
+    (
+        PromptEncoderConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "num_virtual_tokens": 10,
+            "encoder_hidden_size": 32,
+        },
+    ),
+    (
+        PromptTuningConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "num_virtual_tokens": 10,
+        },
+    ),
+    (
+        RoadConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "variant": "road_1",
+            "group_size": 2,
+        },
+    ),
+    (
+        ShiraConfig,
+        {
+            "r": 1,
+            "task_type": "CAUSAL_LM",
+            "target_modules": None,
+            "init_weights": False,
+        },
+    ),
+    (
+        VBLoRAConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "target_modules": None,
+            "vblora_dropout": 0.05,
+            "vector_length": 1,
+            "num_vectors": 2,
+        },
+    ),
+    (
+        VeraConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "r": 8,
+            "target_modules": None,
+            "vera_dropout": 0.05,
+            "projection_prng_key": 0xFF,
+            "d_initial": 0.1,
+            "save_projection": True,
+            "bias": "none",
+        },
+    ),
+    (
+        UniLoraConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "target_modules": None,
+            "theta_d_length": 257,
+        },
+    ),
+    (
+        TinyLoraConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "target_modules": None,
+        },
+    ),
+    (
+        PveraConfig,
+        {
+            "r": 8,
+            "pvera_dropout": 0.05,
+            "task_type": "CAUSAL_LM",
+        },
+    ),
+    (
+        C3AConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "block_size": 1,  # Some test cases contain shapes of prime numbers where `block_size` must be 1
+            "target_modules": None,
+        },
+    ),
+    (
+        WaveFTConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "n_frequency": 8,
+            "target_modules": None,
+        },
+    ),
+    (
+        OSFConfig,
+        {
+            "task_type": "CAUSAL_LM",
+        },
+    ),
+    (
+        PsoftConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "r": 4,
+            "psoft_alpha": 4,
+        },
+    ),
+]
+
+
+def _skip_if_not_conv1d_supported(model_id, config_cls):
+    if "GPT2LMHeadModel" in model_id and config_cls in [
+        BeftConfig,
+        BOFTConfig,
+        GloraConfig,
+        HRAConfig,
+        OFTConfig,
+        OSFConfig,
+        RoadConfig,
+        ShiraConfig,
+        C3AConfig,
+        MissConfig,
+        DeloraConfig,
+        PsoftConfig,
+    ]:
+        pytest.skip("Skipping Beft/BOFT/GLoRA/HRA/OFT/Road/SHiRA/C3A/MiSS/OSF/DeLoRA/PSOFT for GPT2LMHeadModel")
+
+
+def _skip_alora_no_activation(config_cls, config_kwargs):
+    if config_cls is LoraConfig and config_kwargs.get("alora_invocation_tokens") == [1000]:
+        pytest.skip("Skipping aLoRA no-activation-case because the test expects changed output which there won't be.")
+
+
+def _skip_osf_disable_adapter_test(config_cls):
+    if config_cls is OSFConfig:
+        pytest.skip(
+            "Skipping OSF for disable_adapter test because OSF uses exact SVD decomposition, so outputs are identical until training."
+        )
+
+
+def check_beft_config(config_cls, model_id, config_kwargs):
+    if isinstance(config_cls, BeftConfig):
+        return
+    elif "gptj" in model_id.lower():
+        config_kwargs["target_modules"] = ["fc_out"]
+    elif "llama" in model_id.lower():
+        pytest.skip("Skip tests for Llama models because layers have no bias term")
+    elif "gemma3" in model_id.lower():
+        pytest.skip("Skip tests for Gemma3 models because layers have no bias term")
+    else:
+        return
+
+
+class TestDecoderModels(PeftCommonTester):
+    transformers_class = AutoModelForCausalLM
+
+    def prepare_inputs_for_testing(self):
+        input_ids = torch.tensor([[1, 1, 1], [1, 2, 1]]).to(self.torch_device)
+        attention_mask = torch.tensor([[1, 1, 1], [1, 0, 1]]).to(self.torch_device)
+        return {"input_ids": input_ids, "attention_mask": attention_mask}
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_attributes_parametrized(self, model_id, config_cls, config_kwargs):
+        _skip_if_not_conv1d_supported(model_id, config_cls)
+        self._test_model_attr(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_adapter_name(self, model_id, config_cls, config_kwargs):
+        _skip_if_not_conv1d_supported(model_id, config_cls)
+        self._test_adapter_name(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_prepare_for_training_parametrized(self, model_id, config_cls, config_kwargs):
+        _skip_if_not_conv1d_supported(model_id, config_cls)
+        self._test_prepare_for_training(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_prompt_tuning_text_prepare_for_training(self, model_id, config_cls, config_kwargs):
+        if config_cls != PromptTuningConfig:
+            pytest.skip(f"This test does not apply to {config_cls}")
+        config_kwargs = config_kwargs.copy()
+        config_kwargs["prompt_tuning_init"] = PromptTuningInit.TEXT
+        config_kwargs["prompt_tuning_init_text"] = "This is a test prompt."
+        config_kwargs["tokenizer_name_or_path"] = model_id
+        self._test_prepare_for_training(model_id, config_cls, config_kwargs.copy())
+
+    def test_prompt_tuning_text_tokenizer_kwargs(self):
+        # Allow users to pass additional arguments to Tokenizer.from_pretrained
+        # Fix for #1032
+        mock = Mock()
+        orig_from_pretrained = AutoTokenizer.from_pretrained
+
+        def mock_autotokenizer_from_pretrained(*args, **kwargs):
+            mock(*args, **kwargs)
+            return orig_from_pretrained(config.tokenizer_name_or_path)
+
+        model_id = "peft-internal-testing/tiny-random-OPTForCausalLM"
+        config = PromptTuningConfig(
+            base_model_name_or_path=model_id,
+            tokenizer_name_or_path=model_id,
+            num_virtual_tokens=10,
+            prompt_tuning_init=PromptTuningInit.TEXT,
+            task_type="CAUSAL_LM",
+            prompt_tuning_init_text="This is a test prompt.",
+            tokenizer_kwargs={"cache_dir": "/tmp/somewhere", "foo": "bar"},
+        )
+        model = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+        with patch("transformers.AutoTokenizer.from_pretrained", mock_autotokenizer_from_pretrained):
+            _ = get_peft_model(model, config)
+        expected_call = call(model_id, cache_dir="/tmp/somewhere", foo="bar")
+        assert mock.call_args == expected_call
+
+    def test_prompt_tuning_trust_remote_code(self, tmp_path, monkeypatch):
+        # See #2888 for details
+
+        # This is a test for a hypothetical exploit that would enable trust_remote_code (and thus RCE) when a user loads
+        # a malicious prompt tuning model. This is because PEFT would just pass the on the tokenizer_kwargs defined in
+        # the prompt tuning config unsanitzed, which means that if the tokenizer is also malicious, the malicious code
+        # would be executed. For this exploit to work, a user cannot load a model using PeftModel.from_pretrained as
+        # normal, because the tokenizer is only loaded in training mode. Although the attacker could set
+        # inference_mode=True in the adapter_config.json, that would still not work because prompt tuning methods cannot
+        # be loaded in inference mode. Therefore, the only way for the exploit to work would be if the user manually
+        # loads the model, as is shown below.
+
+        model_id = "peft-internal-testing/tiny-random-OPTForCausalLM"
+        with hub_online_once(model_id):
+            # crafting the malicious checkpoint:
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            config = PromptTuningConfig(
+                num_virtual_tokens=10,
+                task_type=TaskType.CAUSAL_LM,
+                tokenizer_name_or_path=model_id,
+                prompt_tuning_init=PromptTuningInit.TEXT,
+                prompt_tuning_init_text="hello",
+                tokenizer_kwargs={"trust_remote_code": "foobar"},
+            )
+            model = get_peft_model(model, config)
+            model.save_pretrained(tmp_path)
+
+            with open(tmp_path / "adapter_config.json") as f:
+                config_dict = json.load(f)
+                # disable inference mode
+                config_dict["inference_mode"] = False
+            with open(tmp_path / "adapter_config.json", "w") as f:
+                json.dump(config_dict, f)
+
+            del model
+
+            # applying a mock to check the used parameters
+            used_args = []
+            used_kwargs = {}
+
+            orig_from_pretrained = AutoTokenizer.from_pretrained
+
+            def fake_from_pretrained(*args, **kwargs):
+                used_args.extend(args)
+                used_kwargs.update(kwargs)
+                return orig_from_pretrained(*args, **kwargs)
+
+            monkeypatch.setattr(AutoTokenizer, "from_pretrained", fake_from_pretrained)
+
+            # user code: loading the malicious checkpoint
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            config = PromptTuningConfig.from_pretrained(tmp_path)
+            PromptEmbedding(config, model.model.decoder.embed_tokens)
+
+            # check that neither args nor kwargs used trust_remote_code='foobar'
+            assert "foobar" not in used_args
+            assert used_kwargs.get("trust_remote_code") != "foobar"
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_prompt_tuning_sample_vocab_prepare_for_training(self, model_id, config_cls, config_kwargs):
+        if config_cls != PromptTuningConfig:
+            pytest.skip(f"This test does not apply to {config_cls}")
+
+        config_kwargs = config_kwargs.copy()
+        config_kwargs["prompt_tuning_init"] = PromptTuningInit.SAMPLE_VOCAB
+        config_kwargs["tokenizer_name_or_path"] = model_id
+
+        self._test_prepare_for_training(model_id, config_cls, config_kwargs.copy())
+
+    def test_prompt_tuning_config_invalid_args(self):
+        # Raise an error when tokenizer_kwargs is used with prompt_tuning_init!='TEXT', because this argument has no
+        # function in that case
+        model_id = "peft-internal-testing/tiny-random-OPTForCausalLM"
+        with pytest.raises(ValueError, match="tokenizer_kwargs only valid when using prompt_tuning_init='TEXT'."):
+            PromptTuningConfig(
+                base_model_name_or_path=model_id,
+                tokenizer_name_or_path=model_id,
+                num_virtual_tokens=10,
+                task_type="CAUSAL_LM",
+                prompt_tuning_init_text="This is a test prompt.",
+                prompt_tuning_init=PromptTuningInit.RANDOM,  # <= should not be used together with tokenizer_kwargs
+                tokenizer_kwargs={"trust_remote_code": True, "foo": "bar"},
+            )
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_save_pretrained(self, model_id, config_cls, config_kwargs):
+        _skip_if_not_conv1d_supported(model_id, config_cls)
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_save_pretrained(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_save_pretrained_pickle(self, model_id, config_cls, config_kwargs):
+        _skip_if_not_conv1d_supported(model_id, config_cls)
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_save_pretrained(model_id, config_cls, config_kwargs.copy(), safe_serialization=False)
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_save_pretrained_selected_adapters(self, model_id, config_cls, config_kwargs):
+        _skip_if_not_conv1d_supported(model_id, config_cls)
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_save_pretrained_selected_adapters(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_save_pretrained_selected_adapters_pickle(self, model_id, config_cls, config_kwargs):
+        _skip_if_not_conv1d_supported(model_id, config_cls)
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_save_pretrained_selected_adapters(
+            model_id, config_cls, config_kwargs.copy(), safe_serialization=False
+        )
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_from_pretrained_config_construction(self, model_id, config_cls, config_kwargs):
+        _skip_if_not_conv1d_supported(model_id, config_cls)
+        self._test_from_pretrained_config_construction(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_merge_layers(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        check_beft_config(config_cls, model_id, config_kwargs)
+        self._test_merge_layers(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_merge_layers_multi(self, model_id, config_cls, config_kwargs):
+        _skip_if_not_conv1d_supported(model_id, config_cls)
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        check_beft_config(config_cls, model_id, config_kwargs)
+        self._test_merge_layers_multi(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_merge_layers_nan(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        check_beft_config(config_cls, model_id, config_kwargs)
+        self._test_merge_layers_nan(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_mixed_adapter_batches(self, model_id, config_cls, config_kwargs):
+        if config_cls != LoraConfig:
+            pytest.skip("Mixed adapter batches not supported for this config.")
+        _skip_alora_no_activation(config_cls, config_kwargs)
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_mixed_adapter_batches(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_generate_with_mixed_adapter_batches(self, model_id, config_cls, config_kwargs):
+        if config_cls != LoraConfig:
+            pytest.skip("Mixed adapter batches not supported for this config.")
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_generate_with_mixed_adapter_batches_and_beam_search(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_generate(self, model_id, config_cls, config_kwargs):
+        _skip_if_not_conv1d_supported(model_id, config_cls)
+        self._test_generate(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_generate_pos_args(self, model_id, config_cls, config_kwargs):
+        _skip_if_not_conv1d_supported(model_id, config_cls)
+        self._test_generate_pos_args(model_id, config_cls, config_kwargs.copy(), raises_err=False)
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_merge_layers_fp16(self, model_id, config_cls, config_kwargs):
+        config_kwargs = config_kwargs.copy()
+        check_beft_config(config_cls, model_id, config_kwargs)
+        self._test_merge_layers_fp16(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_generate_half_prec(self, model_id, config_cls, config_kwargs):
+        self._test_generate_half_prec(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_training_decoders(self, model_id, config_cls, config_kwargs):
+        _skip_if_not_conv1d_supported(model_id, config_cls)
+        self._test_training(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_training_decoders_layer_indexing(self, model_id, config_cls, config_kwargs):
+        self._test_training_layer_indexing(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    @pytest.mark.parametrize("use_reentrant", [True, False])
+    def test_training_decoders_gradient_checkpointing(self, model_id, config_cls, config_kwargs, use_reentrant):
+        _skip_if_not_conv1d_supported(model_id, config_cls)
+        self._test_training_gradient_checkpointing(
+            model_id, config_cls, config_kwargs.copy(), use_reentrant=use_reentrant
+        )
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_inference_safetensors(self, model_id, config_cls, config_kwargs):
+        _skip_if_not_conv1d_supported(model_id, config_cls)
+        self._test_inference_safetensors(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_peft_model_device_map(self, model_id, config_cls, config_kwargs):
+        self._test_peft_model_device_map(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_delete_adapter(self, model_id, config_cls, config_kwargs):
+        _skip_if_not_conv1d_supported(model_id, config_cls)
+        self._test_delete_adapter(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_delete_inactive_adapter(self, model_id, config_cls, config_kwargs):
+        _skip_if_not_conv1d_supported(model_id, config_cls)
+        self._test_delete_inactive_adapter(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_adding_multiple_adapters_with_bias_raises(self, model_id, config_cls, config_kwargs):
+        _skip_if_not_conv1d_supported(model_id, config_cls)
+        self._test_adding_multiple_adapters_with_bias_raises(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_unload_adapter(self, model_id, config_cls, config_kwargs):
+        _skip_if_not_conv1d_supported(model_id, config_cls)
+        _skip_alora_no_activation(config_cls, config_kwargs)
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_unload_adapter(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_weighted_combination_of_adapters(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_weighted_combination_of_adapters(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_training_prompt_learning_tasks(self, model_id, config_cls, config_kwargs):
+        self._test_training_prompt_learning_tasks(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_disable_adapter(self, model_id, config_cls, config_kwargs):
+        _skip_if_not_conv1d_supported(model_id, config_cls)
+        _skip_alora_no_activation(config_cls, config_kwargs)
+        _skip_osf_disable_adapter_test(config_cls)
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_disable_adapter(model_id, config_cls, config_kwargs.copy())
+
+    def test_generate_adalora_no_dropout(self):
+        # test for issue #730
+        model_id = "peft-internal-testing/tiny-random-OPTForCausalLM"
+        config_kwargs = {
+            "target_modules": None,
+            "task_type": "CAUSAL_LM",
+            "lora_dropout": 0.0,
+            "total_step": 1,
+        }
+        self._test_generate(model_id, AdaLoraConfig, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_passing_input_embeds_works(self, model_id, config_cls, config_kwargs):
+        _skip_if_not_conv1d_supported(model_id, config_cls)
+        if (platform.system() == "Darwin") and (config_cls == PrefixTuningConfig):
+            # the error is:
+            # > RuntimeError: unsupported operation: more than one element of the written-to tensor refers to a single
+            # > memory location. Please clone() the tensor before performing the operation.
+            # in transformers sdpa_mask_older_torch. As we (currently) cannot upgrade PyTorch on MacOS GH runners, we're
+            # stuck with this error.
+            # TODO: remove if torch can be upgraded on MacOS or if MacOS CI is removed
+            pytest.skip("Prefix tuning fails on MacOS in this case, not worth fixing")
+        self._test_passing_input_embeds_works("", model_id, config_cls, config_kwargs.copy())
+
+    def test_lora_layer_replication(self):
+        model_id = "trl-internal-testing/tiny-random-LlamaForCausalLM"
+        config_kwargs = {
+            "target_modules": ["down_proj", "up_proj"],
+            "task_type": "CAUSAL_LM",
+            "lora_dropout": 0.0,
+            "layer_replication": [[0, 1], [0, 2], [1, 2]],
+        }
+        model = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+        config = LoraConfig(base_model_name_or_path=model_id, **config_kwargs)
+
+        assert len(model.model.layers) == 2, "Expected 2 layers in original model."
+
+        model = get_peft_model(model, config)
+        layers = model.base_model.model.model.layers
+        assert len(layers) == 4, "Expected 4 layers in adapted model."
+        assert (
+            layers[0].mlp.up_proj.base_layer.weight.data.storage().data_ptr()
+            == layers[1].mlp.up_proj.base_layer.weight.data.storage().data_ptr()
+            and layers[2].mlp.up_proj.base_layer.weight.data.storage().data_ptr()
+            == layers[3].mlp.up_proj.base_layer.weight.data.storage().data_ptr()
+        ), "Expected layers 0-1 and 2-3 to share weights"
+        assert (
+            layers[0].mlp.up_proj.base_layer.weight.data.storage().data_ptr()
+            != layers[2].mlp.up_proj.base_layer.weight.data.storage().data_ptr()
+        ), "Expected layers 0 and 2 to have different weights"
+        assert (
+            layers[0].mlp.up_proj.lora_A.default.weight.data.storage().data_ptr()
+            != layers[1].mlp.up_proj.lora_A.default.weight.data.storage().data_ptr()
+            and layers[2].mlp.up_proj.lora_A.default.weight.data.storage().data_ptr()
+            != layers[3].mlp.up_proj.lora_A.default.weight.data.storage().data_ptr()
+        ), "Expected all LoRA adapters to have distinct weights"
+        assert len([n for n, _ in model.named_parameters() if ".lora_A." in n]) == 8, (
+            "Expected 8 LoRA adapters since we are adding one each for up and down."
+        )
+        self._test_prepare_for_training(model_id, LoraConfig, config_kwargs.copy())
+        self._test_generate(model_id, LoraConfig, config_kwargs.copy())
+
+    def test_prefix_tuning_qwen2_with_grouped_query_attention(self):
+        # See 1901, fixes a bug with handling GQA
+        model_id = "peft-internal-testing/tiny-dummy-qwen2"
+        with hub_online_once(model_id):
+            base_model = AutoModelForCausalLM.from_pretrained(model_id)
+            peft_config = PrefixTuningConfig(num_virtual_tokens=10, task_type="CAUSAL_LM")
+            model = get_peft_model(base_model, peft_config)
+            x = torch.tensor([[1, 2, 3]])
+            # does not raise
+            model(x)
+
+    def test_prefix_tuning_qwen3_with_grouped_query_attention(self):
+        # See 2881, fixes a bug with handling GQA
+        model_id = "trl-internal-testing/tiny-Qwen3ForCausalLM"
+        with hub_online_once(model_id):
+            base_model = AutoModelForCausalLM.from_pretrained(model_id)
+            peft_config = PrefixTuningConfig(num_virtual_tokens=10, task_type="CAUSAL_LM")
+            model = get_peft_model(base_model, peft_config)
+            x = torch.tensor([[1, 2, 3]])
+            # does not raise
+            model(x)
+
+    def test_prefix_tuning_offsets_position_ids_in_forward(self, monkeypatch):
+        # Regression: RoPE models need position_ids offset for prefix tuning.
+        model_id = "trl-internal-testing/tiny-random-LlamaForCausalLM"
+        with hub_online_once(model_id):
+            base = AutoModelForCausalLM.from_pretrained(model_id)
+        peft_config = PrefixTuningConfig(num_virtual_tokens=4, task_type="CAUSAL_LM", prefix_projection=False)
+        model = get_peft_model(base, peft_config)
+
+        captured = {}
+
+        def fake_forward(*args, **kwargs):
+            captured["position_ids"] = kwargs.get("position_ids")
+            input_ids = kwargs.get("input_ids")
+            if input_ids is None and args:
+                input_ids = args[0]
+            batch, seq_len = input_ids.shape
+            logits = torch.zeros((batch, seq_len, base.config.vocab_size), device=input_ids.device)
+            return CausalLMOutputWithPast(logits=logits)
+
+        monkeypatch.setattr(model.base_model, "forward", fake_forward)
+
+        input_ids = torch.randint(0, base.config.vocab_size, (1, 3))
+        position_ids = torch.arange(input_ids.shape[1]).unsqueeze(0)
+        _ = model(input_ids=input_ids, position_ids=position_ids)
+
+        assert captured["position_ids"] is not None
+        assert torch.equal(captured["position_ids"], position_ids + peft_config.num_virtual_tokens)
+
+    def test_prefix_tuning_mistral(self):
+        # See issue 869, 1962
+        _, device_count, _ = get_backend()
+        if device_count > 1:
+            pytest.skip("PEFT Mistral training with DP does not work, skipping")
+
+        model_id = "hf-internal-testing/tiny-random-MistralForCausalLM"
+        base_model = AutoModelForCausalLM.from_pretrained(model_id)
+        peft_config = PrefixTuningConfig(num_virtual_tokens=10, task_type="CAUSAL_LM")
+        model = get_peft_model(base_model, peft_config)
+
+        tokenizer = AutoTokenizer.from_pretrained(model_id)
+        tokenizer.pad_token = tokenizer.eos_token
+
+        def process(samples):
+            tokenized = tokenizer(samples["quote"], truncation=True, max_length=128)
+            return tokenized
+
+        data = load_dataset_english_quotes()
+        data = data.map(process, batched=True)
+
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    num_train_epochs=1,
+                    max_steps=5,
+                    per_device_train_batch_size=4,
+                    output_dir=tmp_dirname,
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            trainer.train()
+
+    @pytest.mark.parametrize("model_id", SMALL_GRID_MODELS)
+    @pytest.mark.parametrize(
+        "config_cls,config_kwargs",
+        [
+            (
+                PromptTuningConfig,
+                {
+                    "num_virtual_tokens": 10,
+                    "task_type": "CAUSAL_LM",
+                },
+            ),
+            (
+                PrefixTuningConfig,
+                {
+                    "num_virtual_tokens": 10,
+                    "task_type": "CAUSAL_LM",
+                },
+            ),
+            (
+                CartridgeConfig,
+                {
+                    "num_virtual_tokens": 10,
+                    "num_frozen_tokens": 1,
+                    "task_type": "CAUSAL_LM",
+                },
+            ),
+            (
+                PromptEncoderConfig,
+                {
+                    "num_virtual_tokens": 10,
+                    "encoder_hidden_size": 32,
+                    "task_type": "CAUSAL_LM",
+                },
+            ),
+            (
+                CPTConfig,
+                {
+                    "task_type": "CAUSAL_LM",
+                    "cpt_token_ids": [0, 1, 2, 3, 4, 5, 6, 7],  # Example token IDs for testing
+                    "cpt_mask": [1, 1, 1, 1, 1, 1, 1, 1],
+                    "cpt_tokens_type_mask": [1, 2, 2, 2, 3, 3, 4, 4],
+                },
+            ),
+        ],
+    )
+    def test_prompt_learning_with_gradient_checkpointing(self, model_id, config_cls, config_kwargs):
+        # See issue 869
+        # Test prompt learning methods with gradient checkpointing in a semi realistic setting.
+        # Prefix tuning does not work if the model uses the new caching implementation. In that case, a helpful error
+        # should be raised.
+
+        # skip if multi GPU, since this results in DataParallel usage by Trainer, which fails with "CUDA device
+        # assertion", breaking subsequent tests
+        if device_count > 1:
+            pytest.skip("Skip on multi-GPU setups")
+        peft_config = config_cls(base_model_name_or_path=model_id, **config_kwargs)
+        base_model = self.transformers_class.from_pretrained(model_id)
+        base_model.gradient_checkpointing_enable()
+
+        try:
+            model = get_peft_model(base_model, peft_config)
+        except ValueError as exc:
+            # Some methods will raise a helpful error. After this, exit the test, as training would fail.
+            assert config_cls in (PrefixTuningConfig, CartridgeConfig)
+            assert "does not work with gradient checkpointing" in str(exc)
+            return
+
+        tokenizer = AutoTokenizer.from_pretrained(model_id)
+        tokenizer.pad_token = tokenizer.eos_token
+
+        def process(samples):
+            tokenized = tokenizer(samples["quote"], truncation=True, max_length=128)
+            return tokenized
+
+        data = load_dataset_english_quotes()
+        data = data.map(process, batched=True)
+
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    num_train_epochs=1,
+                    max_steps=3,
+                    per_device_train_batch_size=4,
+                    output_dir=tmp_dirname,
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            trainer.train()
+
+    @pytest.mark.parametrize("save_embedding_layers", ["auto", True, False])
+    @pytest.mark.parametrize(
+        "peft_config",
+        [
+            (LoraConfig(target_modules=["lin0", "embed_tokens"], init_lora_weights=False)),
+            (LoraConfig(target_modules=r".*\.embed_tokens", init_lora_weights=False)),
+        ],
+    )
+    def test_save_pretrained_targeting_lora_to_embedding_layer(self, save_embedding_layers, tmp_path, peft_config):
+        model_id = "trl-internal-testing/tiny-random-LlamaForCausalLM"
+
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            model = get_peft_model(model, peft_config)
+
+            if save_embedding_layers == "auto":
+                # assert warning
+                msg_start = "Setting `save_embedding_layers` to `True` as embedding layers found in `target_modules`."
+                with pytest.warns(UserWarning, match=msg_start):
+                    model.save_pretrained(tmp_path, save_embedding_layers=save_embedding_layers)
+            else:
+                model.save_pretrained(tmp_path, save_embedding_layers=save_embedding_layers)
+
+            state_dict = safe_load_file(tmp_path / "adapter_model.safetensors")
+            contains_embedding = "base_model.model.model.embed_tokens.base_layer.weight" in state_dict
+
+            if save_embedding_layers in ["auto", True]:
+                assert contains_embedding
+                assert torch.allclose(
+                    model.base_model.model.model.embed_tokens.base_layer.weight,
+                    state_dict["base_model.model.model.embed_tokens.base_layer.weight"],
+                )
+            else:
+                assert not contains_embedding
+
+    @pytest.mark.parametrize("use_dora", [False, True])
+    def test_lora_embed_scale_is_applied(self, use_dora):
+        """Test that LoRA correctly handles embeddings with scaling (e.g., Gemma3)."""
+        model_id = "hf-internal-testing/tiny-random-Gemma3ForCausalLM"
+        with hub_online_once(model_id):
+            base_model = AutoModelForCausalLM.from_pretrained(model_id).to(self.torch_device)
+            orig_embedding = base_model.get_input_embeddings()
+
+            peft_config = LoraConfig(target_modules=["embed_tokens"], init_lora_weights=False, use_dora=use_dora)
+            peft_model = get_peft_model(base_model, peft_config)
+
+            x = torch.arange(10).to(self.torch_device)
+            peft_embedding = peft_model.base_model.model.get_input_embeddings()
+            embedding_output = peft_embedding(x)
+            max_embedding_output = embedding_output.abs().max(0)[0]
+            assert (max_embedding_output < 100.0).all()
+            peft_model.merge_adapter()
+            embedding_merged = peft_embedding(x)
+            assert torch.allclose(embedding_output, embedding_merged, atol=1e-5, rtol=1e-5)
+            peft_model.unmerge_adapter()
+
+            # set embed_scale to an absurdly high value, then check that the embedding output is also scaled to a high
+            # value
+            orig_embedding.embed_scale.fill_(10000.0)
+            max_embedding_output = peft_embedding(x).abs().max(0)[0]
+            assert (max_embedding_output > 100.0).all()
+
+            # set embed_scale to zero, then check that the embedding output is also zero
+            orig_embedding.embed_scale.fill_(0)
+            embedding_output = peft_embedding(x)
+            assert (embedding_output == 0.0).all()
+
+    def test_lora_embed_scale_is_applied_mixed_batch(self):
+        """Test that LoRA correctly handles embeddings with scaling in mixed batch mode."""
+        model_id = "hf-internal-testing/tiny-random-Gemma3ForCausalLM"
+        with hub_online_once(model_id):
+            base_model = AutoModelForCausalLM.from_pretrained(model_id)
+            orig_embedding = base_model.get_input_embeddings()
+
+            peft_config = LoraConfig(target_modules=["embed_tokens"], init_lora_weights=False)
+            peft_model = get_peft_model(base_model, peft_config)
+            peft_model.add_adapter("adapter2", peft_config)
+
+            # sanity check: with the default embed_scale, the embedding output should be reasonably sized
+            peft_embedding = peft_model.base_model.model.get_input_embeddings()
+            input_ids = torch.arange(10).unsqueeze(0).repeat(2, 1)
+            adapter_names = ["default", "adapter2"]
+            max_embedding_output = peft_embedding(input_ids, adapter_names=adapter_names).abs().max()
+            assert max_embedding_output < 100.0
+
+            # set embed_scale to an absurdly high value, then check that the embedding output is also scaled to a high
+            # value
+            orig_embedding.embed_scale.fill_(10000.0)
+            max_embedding_output = peft_embedding(input_ids, adapter_names=adapter_names).abs().max()
+            assert max_embedding_output > 100.0
+
+            # set embed_scale to zero, then check that the embedding output is also zero
+            orig_embedding.embed_scale.fill_(0)
+            embedding_output = peft_embedding(input_ids, adapter_names=adapter_names)
+            assert (embedding_output == 0.0).all()
+
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_set_requires_grad_prompt_learning_raises(self, config_cls, config_kwargs):
+        # Test that for prompt learning, calling set_requires_grad raises an error with an appropriate error message.
+        # Note that for non-prompt learning methods, set_requires_grad is being tested for custom models, so there is no
+        # specific test here.
+        model_id = PEFT_DECODER_MODELS_TO_TEST[0]  # it's enough to test this with one model
+        config = config_cls(
+            base_model_name_or_path=model_id,
+            **config_kwargs,
+        )
+        if not config.is_prompt_learning:
+            pytest.skip("This test is only for prompt learning methods.")
+
+        with hub_online_once(model_id + config_kwargs.get("tokenizer_name_or_path", "")):
+            model = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+            model = get_peft_model(model, config)
+            msg = "Setting `requires_grad` is not supported for prompt learning methods like"
+            with pytest.raises(TypeError, match=msg):
+                model.set_requires_grad(adapter_names="adpater0")
+
+    @pytest.mark.parametrize("model_id", PEFT_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_lora_conversion(self, model_id, config_cls, config_kwargs):
+        # Test for the ability to convert a PEFT adapter into a LoRA adapter (if the adapter supports it). It's not
+        # necessary to run this with all model types, only checking decoder models.
+        _skip_if_not_conv1d_supported(model_id, config_cls)
+        if config_kwargs.get("alora_invocation_tokens"):
+            # very large conversion error, not sure why
+            pytest.skip("Skipping LoRA conversion for aLoRA.")
+
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_lora_conversion(model_id, config_cls, config_kwargs)
+
+    def test_merge_and_unload_fixes_tie_word_embeddings_config(self):
+        # See https://github.com/huggingface/transformers/issues/45127
+        model_id = "trl-internal-testing/tiny-random-LlamaForCausalLM"
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id, tie_word_embeddings=True)
+            assert model.config.tie_word_embeddings
+
+            peft_model = get_peft_model(model, LoraConfig(target_modules=["embed_tokens"], init_lora_weights=False))
+
+            with pytest.warns(UserWarning, match="Setting.*tie_word_embeddings"):
+                merged = peft_model.merge_and_unload()
+
+        assert not merged.config.tie_word_embeddings
+        assert merged.lm_head.weight is not merged.model.embed_tokens.weight
+        assert merged.lm_head.weight.data_ptr() != merged.model.embed_tokens.weight.data_ptr()
+
+    def test_prefix_tuning_gemma4_works(self):
+        # see #3201
+        # The issue was that head dim differs depending on whether sliding window attention is being used or not:
+        # https://github.com/huggingface/transformers/blob/223fe5231b783fbfb25296bb0a243dad5d158cde/src/transformers/models/gemma4/modeling_gemma4.py#L1147
+        # Prefix tuning could deal with different sizes, resulting in a size error
+
+        model_id = "peft-internal-testing/tiny-random-gemma4-E2B"
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(
+                model_id,
+                dtype=torch.bfloat16,
+            ).to(self.torch_device)
+            config = PrefixTuningConfig(
+                task_type=TaskType.CAUSAL_LM,
+                num_virtual_tokens=20,
+                prefix_projection=False,
+            )
+            model = get_peft_model(model, config)
+
+            inputs = torch.arange(10).view(1, -1).to(self.torch_device)
+            model(inputs)  # does not raise
+
+            # do mini training run
+            torch.manual_seed(0)
+            labels = torch.ones_like(inputs)
+            optim = torch.optim.SGD(model.parameters(), lr=100.0)
+            losses = []
+            for _ in range(5):
+                optim.zero_grad()
+                outputs = model(inputs, labels=labels)
+                loss = outputs.loss
+                loss.backward()
+                optim.step()
+                losses.append(loss)
+
+            assert torch.isfinite(loss)
+            assert not torch.isclose(losses[0], losses[-1], atol=1e-6, rtol=1e-3)
+
+    def test_prefix_tuning_gemma4_warns_if_some_layers_skipped(self):
+        # See previous test_prefix_tuning_gemma4_works. When the embedding matrix is too small to fit any layer targeted
+        # by prefix tuning, raise an error
+        model_id = "peft-internal-testing/tiny-random-gemma4-E2B"
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(
+                model_id,
+                dtype=torch.bfloat16,
+            ).to(self.torch_device)
+            config = PrefixTuningConfig(
+                task_type=TaskType.CAUSAL_LM,
+                num_virtual_tokens=20,
+                prefix_projection=False,
+            )
+            text_config = model.config.get_text_config()
+            text_config.num_kv_shared_layers = 1  # set to lower value (was 2)
+            model = get_peft_model(model, config)
+
+            inputs = torch.arange(10).view(1, -1).to(self.torch_device)
+            with pytest.warns(UserWarning, match=r"skipped \[.*\] due to KV shape"):
+                model(inputs)
+
+    def test_prefix_tuning_gemma4_raises_if_all_layers_skipped(self):
+        # See previous test_prefix_tuning_gemma4_works. When the embedding matrix is too small to fit any layer targeted
+        # by prefix tuning, raise an error
+        model_id = "peft-internal-testing/tiny-random-gemma4-E2B"
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(
+                model_id,
+                dtype=torch.bfloat16,
+            ).to(self.torch_device)
+            config = PrefixTuningConfig(
+                task_type=TaskType.CAUSAL_LM,
+                num_virtual_tokens=20,
+                prefix_projection=False,
+            )
+            model = get_peft_model(model, config)
+            text_config = model.config.get_text_config()
+            text_config.num_key_value_heads = 999
+
+            inputs = torch.arange(10).view(1, -1).to(self.torch_device)
+            with pytest.raises(ValueError, match="skipped every layer"):
+                model(inputs)
diff --git a/tests/test_deft.py b/tests/test_deft.py
new file mode 100644
index 0000000..0b0561f
--- /dev/null
+++ b/tests/test_deft.py
@@ -0,0 +1,111 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+import torch
+from torch import nn
+
+from peft import DeftConfig, get_peft_model
+
+
+class MLP(nn.Module):
+    def __init__(self, bias=True):
+        super().__init__()
+        self.lin0 = nn.Linear(10, 20, bias=bias)
+        self.relu = nn.ReLU()
+        self.drop = nn.Dropout(0.5)
+        self.lin1 = nn.Linear(20, 2, bias=bias)
+        self.sm = nn.LogSoftmax(dim=-1)
+        self.dtype = torch.float
+
+    def forward(self, X):
+        X = X.to(self.dtype)
+        X = self.lin0(X)
+        X = self.relu(X)
+        X = self.drop(X)
+        X = self.lin1(X)
+        X = self.sm(X)
+        return X
+
+
+class TestDeftPaRa:
+    """Dedicated tests for the DEFT PaRa mode (`para=True`): pure subspace removal, no injection.
+
+    PaRa is not an identity at init (it removes a sub-space of W), so it does not fit the shared custom-model test
+    cases that assume an identity-at-init adapter.
+    """
+
+    def test_para_removal_only_and_exact_merge(self):
+        torch.manual_seed(0)
+        model = MLP()
+        model.eval()  # disable dropout so the forward is deterministic
+        x = torch.rand(5, 10)
+        base_out = model(x).detach().clone()
+        w0 = model.lin0.weight.detach().clone()
+
+        config = DeftConfig(target_modules=["lin0"], decomposition_method="qr", para=True)
+        peft_model = get_peft_model(model, config)
+        peft_model.eval()
+        layer = peft_model.base_model.model.lin0
+
+        # PaRa creates no injection matrix R; P is the only trainable matrix.
+        assert "default" in layer.deft_P
+        assert "default" not in layer.deft_R
+
+        # PaRa is not an identity at init: removing a sub-space of W changes the output.
+        para_out = peft_model(x)
+        assert not torch.allclose(base_out, para_out, atol=1e-4)
+
+        # merge then forward equals the unmerged forward; unmerge restores the original weight exactly.
+        peft_model.merge_adapter(safe_merge=True)
+        merged_out = peft_model(x)
+        assert torch.allclose(para_out, merged_out, atol=1e-4)
+        peft_model.unmerge_adapter()
+        assert torch.allclose(layer.base_layer.weight, w0, atol=1e-5)
+
+
+class TestDeftMerge:
+    """DEFT caches only the small base-weight-dependent factor (`right.T @ W`) at merge, not the full delta."""
+
+    def test_merge_caches_small_factor_and_unmerges_exactly(self):
+        # Caching the full out x in delta per merged adapter is expensive with many adapters; DEFT instead caches only
+        # right.T @ W (r x in_features) and recomputes the exact delta at unmerge (see review feedback).
+        torch.manual_seed(0)
+        model = MLP()
+        model.eval()  # disable dropout for a deterministic forward
+        x = torch.rand(5, 10)
+
+        config = DeftConfig(target_modules=["lin0"], decomposition_method="relu", r=4)
+        peft_model = get_peft_model(model, config)
+        peft_model.eval()
+        layer = peft_model.base_model.model.lin0
+
+        # make the injection non-trivial so the merge delta is non-zero (identity-init alone gives delta == 0)
+        with torch.no_grad():
+            layer.deft_R["default"].normal_(std=0.1)
+
+        r = layer.deft_r["default"]
+        out_features, in_features = layer.base_layer.weight.shape
+        unmerged_out = peft_model(x).detach().clone()
+        w0 = layer.base_layer.weight.detach().clone()
+
+        peft_model.merge_adapter(safe_merge=True)
+        # the cache is the small r x in_features factor, strictly smaller than the full out x in delta
+        factor = layer._cached_merge_factor["default"]
+        assert factor.shape == (r, in_features)
+        assert factor.numel() < out_features * in_features
+
+        # merge is correct, and unmerge restores the original weight exactly from the cached factor
+        assert torch.allclose(peft_model(x), unmerged_out, atol=1e-4)
+        peft_model.unmerge_adapter()
+        assert torch.allclose(layer.base_layer.weight, w0, atol=1e-5)
diff --git a/tests/test_encoder_decoder_models.py b/tests/test_encoder_decoder_models.py
new file mode 100644
index 0000000..7af640d
--- /dev/null
+++ b/tests/test_encoder_decoder_models.py
@@ -0,0 +1,556 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+import tempfile
+
+import pytest
+import torch
+from transformers import AutoModelForSeq2SeqLM, AutoModelForTokenClassification
+
+from peft import (
+    AdaLoraConfig,
+    AdamssConfig,
+    BeftConfig,
+    BOFTConfig,
+    C3AConfig,
+    DeftConfig,
+    DeloraConfig,
+    FourierFTConfig,
+    FrodConfig,
+    GloraConfig,
+    GraloraConfig,
+    HiraConfig,
+    HRAConfig,
+    IA3Config,
+    LilyConfig,
+    LoraConfig,
+    MissConfig,
+    OFTConfig,
+    OSFConfig,
+    PeanutConfig,
+    PrefixTuningConfig,
+    PromptEncoderConfig,
+    PromptTuningConfig,
+    PsoftConfig,
+    PveraConfig,
+    RoadConfig,
+    ShiraConfig,
+    TaskType,
+    TinyLoraConfig,
+    UniLoraConfig,
+    VBLoRAConfig,
+    VeraConfig,
+    WaveFTConfig,
+    get_peft_model,
+)
+
+from .testing_common import PeftCommonTester
+from .testing_utils import set_init_weights_false
+
+
+# Note: models from peft-internal-testing are just the safetensors versions of hf-internal-testing
+PEFT_ENCODER_DECODER_MODELS_TO_TEST = [
+    "peft-internal-testing/tiny-random-T5ForConditionalGeneration-calibrated",
+    "peft-internal-testing/tiny-random-BartForConditionalGeneration",
+]
+
+# TODO Missing from this list are LoKr, LoHa, LN Tuning, add them
+ALL_CONFIGS = [
+    (
+        AdaLoraConfig,
+        {
+            "target_modules": None,
+            "total_step": 1,
+            "task_type": "SEQ_2_SEQ_LM",
+        },
+    ),
+    (
+        BeftConfig,
+        {
+            "target_modules": None,
+            "task_type": "SEQ_2_SEQ_LM",
+        },
+    ),
+    (
+        BOFTConfig,
+        {
+            "target_modules": None,
+            "task_type": "SEQ_2_SEQ_LM",
+        },
+    ),
+    (
+        MissConfig,
+        {
+            "target_modules": None,
+            "r": 2,
+            "task_type": "SEQ_2_SEQ_LM",
+        },
+    ),
+    (
+        DeftConfig,
+        {
+            "task_type": "SEQ_2_SEQ_LM",
+            "target_modules": None,
+        },
+    ),
+    (
+        DeloraConfig,
+        {
+            "task_type": "SEQ_2_SEQ_LM",
+            "target_modules": None,
+            "r": 2,
+        },
+    ),
+    (
+        FourierFTConfig,
+        {
+            "n_frequency": 10,
+            "target_modules": None,
+            "task_type": "SEQ_2_SEQ_LM",
+        },
+    ),
+    (
+        FrodConfig,
+        {
+            "target_modules": None,
+            "task_type": "SEQ_2_SEQ_LM",
+            "sparse_rate": 0.01,
+        },
+    ),
+    (
+        GloraConfig,
+        {
+            "target_modules": None,
+            "task_type": "SEQ_2_SEQ_LM",
+        },
+    ),
+    (
+        GraloraConfig,
+        {
+            "target_modules": None,
+            "task_type": "SEQ_2_SEQ_LM",
+        },
+    ),
+    (
+        HiraConfig,
+        {
+            "target_modules": None,
+            "task_type": "SEQ_2_SEQ_LM",
+        },
+    ),
+    (
+        HRAConfig,
+        {
+            "target_modules": None,
+            "task_type": "SEQ_2_SEQ_LM",
+        },
+    ),
+    (
+        IA3Config,
+        {
+            "target_modules": None,
+            "feedforward_modules": None,
+            "task_type": "SEQ_2_SEQ_LM",
+        },
+    ),
+    (
+        LilyConfig,
+        {
+            "target_modules": None,
+            "r": 8,
+            "stride_A": 1,
+            "num_B": 2,
+            "task_type": "SEQ_2_SEQ_LM",
+        },
+    ),
+    (
+        LoraConfig,
+        {
+            "r": 8,
+            "lora_alpha": 32,
+            "target_modules": None,
+            "lora_dropout": 0.05,
+            "bias": "none",
+            "task_type": "SEQ_2_SEQ_LM",
+        },
+    ),
+    (
+        LoraConfig,
+        {
+            "r": 8,
+            "lora_alpha": 32,
+            "target_modules": None,
+            "lora_dropout": 0.05,
+            "bias": "none",
+            "trainable_token_indices": [0, 1, 3],
+            "task_type": "SEQ_2_SEQ_LM",
+        },
+    ),
+    (
+        OFTConfig,
+        {
+            "target_modules": None,
+            "task_type": "SEQ_2_SEQ_LM",
+        },
+    ),
+    (
+        PrefixTuningConfig,
+        {
+            "num_virtual_tokens": 10,
+            "task_type": "SEQ_2_SEQ_LM",
+        },
+    ),
+    (
+        PrefixTuningConfig,
+        {
+            "num_virtual_tokens": 10,
+            "task_type": "SEQ_2_SEQ_LM",
+            "init_weights": "zero",
+        },
+    ),
+    (
+        PromptEncoderConfig,
+        {
+            "num_virtual_tokens": 10,
+            "encoder_hidden_size": 32,
+            "task_type": "SEQ_2_SEQ_LM",
+        },
+    ),
+    (
+        PromptTuningConfig,
+        {
+            "num_virtual_tokens": 10,
+            "task_type": "SEQ_2_SEQ_LM",
+        },
+    ),
+    (
+        RoadConfig,
+        {
+            "task_type": "SEQ_2_SEQ_LM",
+            "variant": "road_1",
+            "group_size": 2,
+        },
+    ),
+    (
+        ShiraConfig,
+        {
+            "r": 1,
+            "task_type": "SEQ_2_SEQ_LM",
+            "target_modules": None,
+            "init_weights": False,
+        },
+    ),
+    (
+        VBLoRAConfig,
+        {
+            "target_modules": None,
+            "vblora_dropout": 0.05,
+            "vector_length": 1,
+            "num_vectors": 2,
+            "task_type": "SEQ_2_SEQ_LM",
+        },
+    ),
+    (
+        VeraConfig,
+        {
+            "r": 8,
+            "target_modules": None,
+            "vera_dropout": 0.05,
+            "projection_prng_key": 0xFF,
+            "d_initial": 0.1,
+            "save_projection": True,
+            "bias": "none",
+            "task_type": "SEQ_2_SEQ_LM",
+        },
+    ),
+    (
+        UniLoraConfig,
+        {
+            "target_modules": None,
+            "theta_d_length": 257,
+            "task_type": "SEQ_2_SEQ_LM",
+        },
+    ),
+    (
+        TinyLoraConfig,
+        {
+            "target_modules": None,
+            "task_type": "SEQ_2_SEQ_LM",
+        },
+    ),
+    (
+        PveraConfig,
+        {
+            "r": 8,
+            "pvera_dropout": 0.05,
+            "task_type": "SEQ_2_SEQ_LM",
+        },
+    ),
+    (
+        PeanutConfig,
+        {
+            "r": 4,
+            "depth": 1,
+            "scaling": 1.0,
+            "act_fn": "relu",
+            "target_modules": None,
+            "task_type": "SEQ_2_SEQ_LM",
+        },
+    ),
+    (
+        C3AConfig,
+        {
+            "task_type": "SEQ_2_SEQ_LM",
+            "block_size": 1,
+            "target_modules": None,
+        },
+    ),
+    (
+        WaveFTConfig,
+        {
+            "task_type": "SEQ_2_SEQ_LM",
+            "n_frequency": 8,
+            "target_modules": None,
+        },
+    ),
+    (
+        OSFConfig,
+        {
+            "task_type": "SEQ_2_SEQ_LM",
+        },
+    ),
+    (
+        PsoftConfig,
+        {
+            "task_type": "SEQ_2_SEQ_LM",
+            "r": 4,
+            "psoft_alpha": 4,
+        },
+    ),
+    (
+        AdamssConfig,
+        {
+            "target_modules": None,
+            "r": 8,
+            "task_type": "SEQ_2_SEQ_LM",
+        },
+    ),
+]
+
+
+def _skip_osf_disable_adapter_test(config_cls):
+    if config_cls is OSFConfig:
+        pytest.skip(
+            "Skipping OSF for disable_adapter test because OSF uses exact SVD decomposition, so outputs are identical until training."
+        )
+
+
+def beft_tests(config_cls, model_id, config_kwargs):
+    config_name = config_cls.__name__.lower()
+    if config_name != "beftconfig":
+        return
+    elif "t5" in model_id.lower():
+        pytest.skip("Skip tests for T5 models because of no bias term")
+    else:
+        return
+
+
+class TestEncoderDecoderModels(PeftCommonTester):
+    transformers_class = AutoModelForSeq2SeqLM
+
+    def prepare_inputs_for_testing(self):
+        input_ids = torch.tensor([[1, 1, 1], [1, 2, 1]]).to(self.torch_device)
+        decoder_input_ids = torch.tensor([[1, 1, 1], [1, 2, 1]]).to(self.torch_device)
+        attention_mask = torch.tensor([[1, 1, 1], [1, 0, 1]]).to(self.torch_device)
+
+        input_dict = {
+            "input_ids": input_ids,
+            "decoder_input_ids": decoder_input_ids,
+            "attention_mask": attention_mask,
+        }
+
+        return input_dict
+
+    @pytest.mark.parametrize("model_id", PEFT_ENCODER_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_attributes_parametrized(self, model_id, config_cls, config_kwargs):
+        self._test_model_attr(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_ENCODER_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_adapter_name(self, model_id, config_cls, config_kwargs):
+        self._test_adapter_name(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_ENCODER_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_prepare_for_training_parametrized(self, model_id, config_cls, config_kwargs):
+        self._test_prepare_for_training(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_ENCODER_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_save_pretrained(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_save_pretrained(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_ENCODER_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_save_pretrained_pickle(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_save_pretrained(model_id, config_cls, config_kwargs, safe_serialization=False)
+
+    @pytest.mark.parametrize("model_id", PEFT_ENCODER_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_save_pretrained_selected_adapters(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_save_pretrained_selected_adapters(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_ENCODER_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_save_pretrained_selected_adapters_pickle(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_save_pretrained_selected_adapters(model_id, config_cls, config_kwargs, safe_serialization=False)
+
+    def test_load_model_low_cpu_mem_usage(self):
+        # Using the first model with LoraConfig and an empty config_kwargs.
+        self._test_load_model_low_cpu_mem_usage(PEFT_ENCODER_DECODER_MODELS_TO_TEST[0], LoraConfig, {})
+
+    @pytest.mark.parametrize("model_id", PEFT_ENCODER_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_from_pretrained_config_construction(self, model_id, config_cls, config_kwargs):
+        self._test_from_pretrained_config_construction(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_ENCODER_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_merge_layers(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        beft_tests(config_cls, model_id, config_kwargs)
+        self._test_merge_layers(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_ENCODER_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_mixed_adapter_batches(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_mixed_adapter_batches(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_ENCODER_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_generate_with_mixed_adapter_batches(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_generate_with_mixed_adapter_batches_and_beam_search(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_ENCODER_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_generate(self, model_id, config_cls, config_kwargs):
+        self._test_generate(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_ENCODER_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_generate_pos_args(self, model_id, config_cls, config_kwargs):
+        self._test_generate_pos_args(model_id, config_cls, config_kwargs, raises_err=True)
+
+    @pytest.mark.parametrize("model_id", PEFT_ENCODER_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_generate_half_prec(self, model_id, config_cls, config_kwargs):
+        self._test_generate_half_prec(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_ENCODER_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_training_encoder_decoders(self, model_id, config_cls, config_kwargs):
+        self._test_training(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_ENCODER_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_training_encoder_decoders_layer_indexing(self, model_id, config_cls, config_kwargs):
+        self._test_training_layer_indexing(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_ENCODER_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    @pytest.mark.parametrize("use_reentrant", [True, False])
+    def test_training_encoder_decoders_gradient_checkpointing(
+        self, model_id, config_cls, config_kwargs, use_reentrant
+    ):
+        self._test_training_gradient_checkpointing(model_id, config_cls, config_kwargs, use_reentrant=use_reentrant)
+
+    @pytest.mark.parametrize("model_id", PEFT_ENCODER_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_inference_safetensors(self, model_id, config_cls, config_kwargs):
+        self._test_inference_safetensors(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_ENCODER_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_peft_model_device_map(self, model_id, config_cls, config_kwargs):
+        self._test_peft_model_device_map(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_ENCODER_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_delete_adapter(self, model_id, config_cls, config_kwargs):
+        self._test_delete_adapter(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_ENCODER_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_delete_inactive_adapter(self, model_id, config_cls, config_kwargs):
+        self._test_delete_inactive_adapter(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_ENCODER_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_adding_multiple_adapters_with_bias_raises(self, model_id, config_cls, config_kwargs):
+        self._test_adding_multiple_adapters_with_bias_raises(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_ENCODER_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_unload_adapter(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_unload_adapter(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_ENCODER_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_weighted_combination_of_adapters(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_weighted_combination_of_adapters(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_ENCODER_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_training_prompt_learning_tasks(self, model_id, config_cls, config_kwargs):
+        self._test_training_prompt_learning_tasks(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_ENCODER_DECODER_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_disable_adapter(self, model_id, config_cls, config_kwargs):
+        _skip_osf_disable_adapter_test(config_cls)
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_disable_adapter(model_id, config_cls, config_kwargs)
+
+    def test_active_adapters_prompt_learning(self):
+        model = AutoModelForSeq2SeqLM.from_pretrained(
+            "peft-internal-testing/tiny-random-BartForConditionalGeneration"
+        ).to(self.torch_device)
+        # any prompt learning method would work here
+        config = PromptEncoderConfig(task_type=TaskType.SEQ_2_SEQ_LM, num_virtual_tokens=10)
+        model = get_peft_model(model, config)
+        assert model.active_adapters == ["default"]
+
+    def test_save_shared_tensors(self):
+        model_id = "peft-internal-testing/tiny-random-RobertaModel"
+        peft_config = LoraConfig(
+            task_type=TaskType.TOKEN_CLS,
+            inference_mode=False,
+            r=16,
+            lora_alpha=16,
+            lora_dropout=0.1,
+            bias="all",
+        )
+        model = AutoModelForTokenClassification.from_pretrained(model_id, num_labels=11)
+        model = get_peft_model(model, peft_config)
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            # This should work fine
+            model.save_pretrained(tmp_dir, safe_serialization=True)
diff --git a/tests/test_feature_extraction_models.py b/tests/test_feature_extraction_models.py
new file mode 100644
index 0000000..e671f9e
--- /dev/null
+++ b/tests/test_feature_extraction_models.py
@@ -0,0 +1,485 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+import pytest
+import torch
+from transformers import AutoModel
+
+from peft import (
+    AdaLoraConfig,
+    AdamssConfig,
+    BeftConfig,
+    BOFTConfig,
+    C3AConfig,
+    DeftConfig,
+    DeloraConfig,
+    FourierFTConfig,
+    FrodConfig,
+    GloraConfig,
+    GraloraConfig,
+    HiraConfig,
+    HRAConfig,
+    IA3Config,
+    LilyConfig,
+    LoraConfig,
+    MissConfig,
+    OFTConfig,
+    PeanutConfig,
+    PrefixTuningConfig,
+    PromptEncoderConfig,
+    PromptLearningConfig,
+    PromptTuningConfig,
+    PsoftConfig,
+    RoadConfig,
+    ShiraConfig,
+    TinyLoraConfig,
+    VBLoRAConfig,
+    VeraConfig,
+    WaveFTConfig,
+)
+
+from .testing_common import PeftCommonTester
+from .testing_utils import set_init_weights_false
+
+
+# Note: models from peft-internal-testing are just the safetensors versions of hf-internal-testing
+PEFT_FEATURE_EXTRACTION_MODELS_TO_TEST = [
+    "peft-internal-testing/tiny-random-BertModel",
+    "peft-internal-testing/tiny-random-RobertaModel",
+    "peft-internal-testing/tiny-random-DebertaModel",
+    "peft-internal-testing/tiny-random-DebertaV2Model",
+]
+
+# TODO Missing from this list are LoKr, LoHa, LN Tuning, add them
+ALL_CONFIGS = [
+    (
+        AdaLoraConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "target_modules": None,
+            "total_step": 1,
+        },
+    ),
+    (
+        BeftConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "target_modules": None,
+        },
+    ),
+    (
+        BOFTConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "target_modules": None,
+        },
+    ),
+    (
+        MissConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "target_modules": None,
+            "r": 2,
+        },
+    ),
+    (
+        DeftConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "target_modules": None,
+        },
+    ),
+    (
+        DeloraConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "target_modules": None,
+            "r": 2,
+        },
+    ),
+    (
+        FourierFTConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "n_frequency": 10,
+            "target_modules": None,
+        },
+    ),
+    (
+        FrodConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "target_modules": None,
+            "sparse_rate": 0.01,
+        },
+    ),
+    (
+        GloraConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "target_modules": None,
+        },
+    ),
+    (
+        GraloraConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "target_modules": None,
+        },
+    ),
+    (
+        HiraConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "target_modules": None,
+        },
+    ),
+    (
+        HRAConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "target_modules": None,
+        },
+    ),
+    (
+        IA3Config,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "target_modules": None,
+            "feedforward_modules": None,
+        },
+    ),
+    (
+        LilyConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "target_modules": None,
+            "r": 8,
+            "stride_A": 1,
+            "num_B": 2,
+        },
+    ),
+    (
+        LoraConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "r": 8,
+            "lora_alpha": 32,
+            "target_modules": None,
+            "lora_dropout": 0.05,
+            "bias": "none",
+        },
+    ),
+    # LoRA + trainable tokens
+    (
+        LoraConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "r": 8,
+            "lora_alpha": 32,
+            "target_modules": None,
+            "lora_dropout": 0.05,
+            "bias": "none",
+            "trainable_token_indices": [0, 1, 3],
+        },
+    ),
+    (
+        OFTConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "target_modules": None,
+        },
+    ),
+    (
+        PrefixTuningConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "num_virtual_tokens": 10,
+        },
+    ),
+    (
+        PromptEncoderConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "num_virtual_tokens": 10,
+            "encoder_hidden_size": 32,
+        },
+    ),
+    (
+        PromptTuningConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "num_virtual_tokens": 10,
+        },
+    ),
+    (
+        PeanutConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "target_modules": None,
+            "r": 8,
+            "depth": 1,
+            "act_fn": "relu",
+            "scaling": 1.0,
+        },
+    ),
+    (
+        RoadConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "variant": "road_1",
+            "group_size": 2,
+        },
+    ),
+    (
+        ShiraConfig,
+        {
+            "r": 1,
+            "task_type": "FEATURE_EXTRACTION",
+            "target_modules": None,
+            "init_weights": False,
+        },
+    ),
+    (
+        VBLoRAConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "target_modules": None,
+            "vblora_dropout": 0.05,
+            "vector_length": 1,
+            "num_vectors": 2,
+        },
+    ),
+    (
+        VeraConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "r": 8,
+            "target_modules": None,
+            "vera_dropout": 0.05,
+            "projection_prng_key": 0xFF,
+            "d_initial": 0.1,
+            "save_projection": True,
+            "bias": "none",
+        },
+    ),
+    (
+        TinyLoraConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "target_modules": None,
+        },
+    ),
+    (
+        C3AConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "block_size": 1,
+            "target_modules": None,
+        },
+    ),
+    (
+        WaveFTConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "n_frequency": 8,
+            "target_modules": None,
+        },
+    ),
+    (
+        PsoftConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "r": 4,
+            "psoft_alpha": 4,
+            "target_modules": None,
+        },
+    ),
+    (
+        AdamssConfig,
+        {
+            "task_type": "FEATURE_EXTRACTION",
+            "target_modules": None,
+            "r": 8,
+        },
+    ),
+]
+
+
+def skip_non_prompt_learning(config_cls):
+    if not issubclass(config_cls, PromptLearningConfig) or (config_cls == PrefixTuningConfig):
+        pytest.skip("Skip tests that are not prompt learning or that are prefix tuning")
+
+
+def skip_deberta_lora_tests(config_cls, model_id):
+    if "deberta" not in model_id.lower():
+        return
+
+    to_skip = ["lora", "ia3", "boft", "vera", "fourierft", "hira", "hra", "randlora"]
+    config_name = config_cls.__name__.lower()
+    if any(k in config_name for k in to_skip):
+        pytest.skip(f"Skip tests that use {config_name} for Deberta models")
+
+
+def deberta_beft_tests(config_cls, model_id, config_kwargs):
+    if "deberta" not in model_id.lower():
+        return
+    config_name = config_cls.__name__.lower()
+    if config_name == "beftconfig":
+        config_kwargs["target_modules"] = ["output.dense"]
+
+
+def skip_deberta_pt_tests(config_cls, model_id):
+    if "deberta" not in model_id.lower():
+        return
+
+    to_skip = ["prefix"]
+    config_name = config_cls.__name__.lower()
+    if any(k in config_name for k in to_skip):
+        pytest.skip(f"Skip tests that use {config_name} for Deberta models")
+
+
+class TestPeftFeatureExtractionModel(PeftCommonTester):
+    """
+    Test if the PeftModel behaves as expected. This includes:
+    - test if the model has the expected methods
+    """
+
+    transformers_class = AutoModel
+
+    def prepare_inputs_for_testing(self):
+        input_ids = torch.tensor([[1, 1, 1], [1, 2, 1]]).to(self.torch_device)
+        attention_mask = torch.tensor([[1, 1, 1], [1, 0, 1]]).to(self.torch_device)
+
+        input_dict = {
+            "input_ids": input_ids,
+            "attention_mask": attention_mask,
+        }
+
+        return input_dict
+
+    @pytest.mark.parametrize("model_id", PEFT_FEATURE_EXTRACTION_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_attributes_parametrized(self, model_id, config_cls, config_kwargs):
+        deberta_beft_tests(config_cls, model_id, config_kwargs)
+        self._test_model_attr(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_FEATURE_EXTRACTION_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_adapter_name(self, model_id, config_cls, config_kwargs):
+        deberta_beft_tests(config_cls, model_id, config_kwargs)
+        self._test_adapter_name(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_FEATURE_EXTRACTION_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_prepare_for_training_parametrized(self, model_id, config_cls, config_kwargs):
+        deberta_beft_tests(config_cls, model_id, config_kwargs)
+        self._test_prepare_for_training(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_FEATURE_EXTRACTION_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_save_pretrained(self, model_id, config_cls, config_kwargs):
+        deberta_beft_tests(config_cls, model_id, config_kwargs)
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_save_pretrained(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_FEATURE_EXTRACTION_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_save_pretrained_selected_adapters(self, model_id, config_cls, config_kwargs):
+        deberta_beft_tests(config_cls, model_id, config_kwargs)
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_save_pretrained_selected_adapters(model_id, config_cls, config_kwargs)
+
+    def test_load_model_low_cpu_mem_usage(self):
+        self._test_load_model_low_cpu_mem_usage(PEFT_FEATURE_EXTRACTION_MODELS_TO_TEST[0], LoraConfig, {})
+
+    @pytest.mark.parametrize("model_id", PEFT_FEATURE_EXTRACTION_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_from_pretrained_config_construction(self, model_id, config_cls, config_kwargs):
+        deberta_beft_tests(config_cls, model_id, config_kwargs)
+        self._test_from_pretrained_config_construction(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_FEATURE_EXTRACTION_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_merge_layers(self, model_id, config_cls, config_kwargs):
+        deberta_beft_tests(config_cls, model_id, config_kwargs)
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_merge_layers(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_FEATURE_EXTRACTION_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_training(self, model_id, config_cls, config_kwargs):
+        deberta_beft_tests(config_cls, model_id, config_kwargs)
+        self._test_training(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_FEATURE_EXTRACTION_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_training_prompt_learning_tasks(self, model_id, config_cls, config_kwargs):
+        skip_deberta_pt_tests(config_cls, model_id)
+        self._test_training_prompt_learning_tasks(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_FEATURE_EXTRACTION_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_training_layer_indexing(self, model_id, config_cls, config_kwargs):
+        self._test_training_layer_indexing(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_FEATURE_EXTRACTION_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    @pytest.mark.parametrize("use_reentrant", [True, False])
+    def test_training_gradient_checkpointing(self, model_id, config_cls, config_kwargs, use_reentrant):
+        deberta_beft_tests(config_cls, model_id, config_kwargs)
+        skip_deberta_lora_tests(config_cls, model_id)
+        self._test_training_gradient_checkpointing(model_id, config_cls, config_kwargs, use_reentrant=use_reentrant)
+
+    @pytest.mark.parametrize("model_id", PEFT_FEATURE_EXTRACTION_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_inference_safetensors(self, model_id, config_cls, config_kwargs):
+        deberta_beft_tests(config_cls, model_id, config_kwargs)
+        self._test_inference_safetensors(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_FEATURE_EXTRACTION_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_peft_model_device_map(self, model_id, config_cls, config_kwargs):
+        deberta_beft_tests(config_cls, model_id, config_kwargs)
+        self._test_peft_model_device_map(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_FEATURE_EXTRACTION_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_delete_adapter(self, model_id, config_cls, config_kwargs):
+        deberta_beft_tests(config_cls, model_id, config_kwargs)
+        self._test_delete_adapter(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_FEATURE_EXTRACTION_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_delete_inactive_adapter(self, model_id, config_cls, config_kwargs):
+        deberta_beft_tests(config_cls, model_id, config_kwargs)
+        self._test_delete_inactive_adapter(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_FEATURE_EXTRACTION_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_unload_adapter(self, model_id, config_cls, config_kwargs):
+        deberta_beft_tests(config_cls, model_id, config_kwargs)
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_unload_adapter(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_FEATURE_EXTRACTION_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_weighted_combination_of_adapters(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_weighted_combination_of_adapters(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_FEATURE_EXTRACTION_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_passing_input_embeds_works(self, model_id, config_cls, config_kwargs):
+        skip_non_prompt_learning(config_cls)
+        self._test_passing_input_embeds_works("test input embeds work", model_id, config_cls, config_kwargs)
diff --git a/tests/test_frod.py b/tests/test_frod.py
new file mode 100644
index 0000000..1259c49
--- /dev/null
+++ b/tests/test_frod.py
@@ -0,0 +1,273 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+# This test file is for tests specific to FRoD, since FRoD has shared projection buffers.
+
+import os
+
+import pytest
+import torch
+from accelerate.utils.imports import is_bf16_available
+from safetensors import safe_open
+from torch import nn
+from transformers import LlamaConfig, LlamaForCausalLM
+
+from peft import FrodConfig, PeftModel, get_peft_model
+
+
+class MLP(nn.Module):
+    def __init__(self, bias=True):
+        super().__init__()
+        self.relu = nn.ReLU()
+        self.lin0 = nn.Linear(10, 20, bias=bias)
+        self.lin1 = nn.Linear(20, 20, bias=bias)  # lin1 and lin2 have same shape
+        self.lin2 = nn.Linear(20, 20, bias=bias)
+        self.lin3 = nn.Linear(20, 2, bias=bias)
+        self.sm = nn.LogSoftmax(dim=-1)
+
+    def forward(self, X):
+        X = self.lin0(X)
+        X = self.relu(X)
+        X = self.lin1(X)
+        X = self.relu(X)
+        X = self.lin2(X)
+        X = self.relu(X)
+        X = self.lin3(X)
+        X = self.sm(X)
+        return X
+
+
+class TestFrod:
+    @pytest.fixture
+    def mlp(self):
+        torch.manual_seed(0)
+        model = MLP()
+        return model
+
+    @pytest.fixture
+    def mlp_same_prng(self, mlp):
+        torch.manual_seed(0)
+
+        config = FrodConfig(target_modules=["lin1", "lin2"], init_weights=False)
+        peft_model = get_peft_model(mlp, config)
+        config2 = FrodConfig(target_modules=["lin1", "lin2"], init_weights=False)
+        peft_model.add_adapter("other", config2)
+        return peft_model
+
+    def test_multiple_adapters_save_load_save_projection_false(self, mlp, tmp_path):
+        # Check saving and loading works with multiple adapters without saved projection tensors.
+        torch.manual_seed(1)
+        config = FrodConfig(target_modules=["lin1", "lin2"], init_weights=False, save_projection=False)
+        peft_model = get_peft_model(mlp, config, adapter_name="first")
+        config2 = FrodConfig(target_modules=["lin1", "lin2"], init_weights=False, save_projection=False)
+        peft_model.add_adapter("second", config2)
+        peft_model.eval()
+
+        input = torch.randn(5, 10)
+        peft_model.set_adapter("first")
+        output_first = peft_model(input)
+        peft_model.set_adapter("second")
+        output_second = peft_model(input)
+
+        assert not torch.allclose(output_first, output_second, atol=1e-3, rtol=1e-3)
+
+        save_path = tmp_path / "frod"
+        peft_model.save_pretrained(save_path)
+        assert os.path.exists(save_path / "first" / "adapter_config.json")
+        assert os.path.exists(save_path / "second" / "adapter_config.json")
+
+        torch.manual_seed(0)
+        mlp = MLP()
+        peft_model = PeftModel.from_pretrained(mlp, save_path / "first", adapter_name="first")
+        peft_model.load_adapter(save_path / "second", "second")
+        peft_model.eval()
+
+        peft_model.set_adapter("first")
+        output_first_loaded = peft_model(input)
+        peft_model.set_adapter("second")
+        output_second_loaded = peft_model(input)
+
+        assert torch.allclose(output_first, output_first_loaded, atol=1e-3, rtol=1e-3)
+        assert torch.allclose(output_second, output_second_loaded, atol=1e-3, rtol=1e-3)
+
+    def test_save_projection_false_contains_no_frod_projection_tensors(self, mlp, tmp_path):
+        config = FrodConfig(target_modules=["lin1", "lin2"], init_weights=False, save_projection=False)
+        peft_model = get_peft_model(mlp, config)
+
+        save_path = tmp_path / "frod"
+        peft_model.save_pretrained(save_path)
+
+        state_dict = {}
+        with safe_open(save_path / "adapter_model.safetensors", framework="pt", device="cpu") as f:
+            for key in f.keys():
+                state_dict[key] = f.get_tensor(key)
+
+        assert not any("frod_V" in key for key in state_dict)
+        assert not any("frod_s_indices" in key for key in state_dict)
+        assert not any("frod_s_size" in key for key in state_dict)
+        assert not any("frod_U" in key for key in state_dict)
+
+    def test_save_projection_true_contains_top_level_projection_tensors_only(self, mlp, tmp_path):
+        config = FrodConfig(target_modules=["lin1", "lin2"], init_weights=False)
+        peft_model = get_peft_model(mlp, config)
+
+        save_path = tmp_path / "frod"
+        peft_model.save_pretrained(save_path)
+
+        keys = []
+        with safe_open(save_path / "adapter_model.safetensors", framework="pt", device="cpu") as f:
+            keys = list(f.keys())
+
+        assert "base_model.frod_V.lin1" in keys
+        assert "base_model.frod_s_indices.lin1" in keys
+        assert "base_model.frod_s_size.lin1" in keys
+        assert "base_model.frod_V.lin2" in keys
+        assert not any(".model.lin1.frod_V" in key for key in keys)
+        assert not any("frod_U" in key for key in keys)
+
+    def test_frod_default_initialization_reconstructs_base_weight(self, mlp):
+        torch.manual_seed(0)
+        mlp.eval()
+        inputs = torch.randn(5, 10)
+        expected = mlp(inputs)
+
+        config = FrodConfig(target_modules=["lin1", "lin2"])
+        peft_model = get_peft_model(mlp, config)
+        peft_model.eval()
+
+        actual = peft_model(inputs)
+        assert torch.allclose(actual, expected, atol=1e-4, rtol=1e-4)
+
+        for module in (peft_model.base_model.model.lin1, peft_model.base_model.model.lin2):
+            delta_weight = module.get_delta_weight("default")
+
+            assert module.frod_lambda_l["default"].norm() > 0
+            assert torch.count_nonzero(module.frod_lambda_s_values["default"]) == 0
+            assert torch.allclose(delta_weight, torch.zeros_like(delta_weight), atol=1e-4)
+
+    def test_frod_projection_buffers_share_memory_with_layers(self, mlp_same_prng):
+        frod_V_lin1 = mlp_same_prng.base_model.frod_V["lin1"]["default"]
+        frod_s_indices_lin1 = mlp_same_prng.base_model.frod_s_indices["lin1"]["default"]
+
+        assert frod_V_lin1.data_ptr() == mlp_same_prng.base_model.model.lin1.frod_V["default"].data_ptr()
+        assert frod_V_lin1.data_ptr() == mlp_same_prng.base_model.model.lin1.frod_V["other"].data_ptr()
+        assert (
+            frod_s_indices_lin1.data_ptr() == mlp_same_prng.base_model.model.lin1.frod_s_indices["default"].data_ptr()
+        )
+        assert frod_s_indices_lin1.data_ptr() == mlp_same_prng.base_model.model.lin1.frod_s_indices["other"].data_ptr()
+
+        # Different target categories have distinct projection buffers.
+        assert frod_V_lin1.data_ptr() != mlp_same_prng.base_model.frod_V["lin2"]["default"].data_ptr()
+
+    def test_frod_sparse_activation_matches_dense_and_gradients(self, mlp):
+        config = FrodConfig(target_modules=["lin1"], init_weights=False)
+        peft_model = get_peft_model(mlp, config)
+        layer = peft_model.base_model.model.lin1
+
+        indices = torch.tensor([[0, 1, 2, 3, 0], [1, 2, 3, 0, 2]])
+        values = torch.tensor([0.5, -0.25, 1.5, 0.75, -1.0], dtype=torch.float16, requires_grad=True)
+        sparse = torch.sparse_coo_tensor(indices, values, (4, 4)).coalesce()
+        z = torch.randn(3, 4, dtype=torch.float16, requires_grad=True)
+
+        actual = layer._sparse_activation_mm(z, sparse)
+        actual.float().pow(2).sum().backward()
+
+        z_expected = z.detach().clone().requires_grad_(True)
+        values_expected = values.detach().clone().requires_grad_(True)
+        dense = torch.zeros(4, 4, dtype=torch.float16)
+        dense[indices[0], indices[1]] = values_expected
+        expected = z_expected @ dense.t()
+        expected.float().pow(2).sum().backward()
+
+        assert values.grad is not None
+        assert z.grad is not None
+        assert torch.allclose(actual, expected, atol=1e-3, rtol=1e-3)
+        assert torch.allclose(values.grad, values_expected.grad, atol=1e-3, rtol=1e-3)
+        assert torch.allclose(z.grad, z_expected.grad, atol=1e-3, rtol=1e-3)
+
+    def test_frod_autocast_keeps_frozen_u_in_base_dtype(self):
+        model = MLP().to(torch.bfloat16)
+        config = FrodConfig(target_modules=["lin1"], init_weights=False)
+        peft_model = get_peft_model(model, config)
+        lin1 = peft_model.base_model.model.lin1
+
+        assert lin1.frod_U["default"].dtype == torch.bfloat16
+        assert lin1.frod_lambda_l["default"].dtype == torch.float32
+        assert lin1.frod_lambda_s_values["default"].dtype == torch.float32
+
+    def test_frod_categories_with_common_llama_targets(self):
+        model = LlamaForCausalLM(
+            LlamaConfig(
+                hidden_size=16,
+                intermediate_size=32,
+                num_attention_heads=4,
+                num_hidden_layers=2,
+                vocab_size=32,
+            )
+        )
+        config = FrodConfig(target_modules=["q_proj", "v_proj"])
+
+        peft_model = get_peft_model(model, config)
+
+        assert sorted(peft_model.base_model.frod_V.keys()) == ["self_attn_q_proj", "self_attn_v_proj"]
+        assert "default" in peft_model.base_model.frod_V["self_attn_q_proj"]
+        assert "default" in peft_model.base_model.frod_V["self_attn_v_proj"]
+
+    def test_frod_lambda_dont_share_memory(self, mlp_same_prng):
+        assert (
+            mlp_same_prng.base_model.model.lin1.frod_lambda_s_values["default"].data_ptr()
+            != mlp_same_prng.base_model.model.lin1.frod_lambda_s_values["other"].data_ptr()
+        )
+        assert (
+            mlp_same_prng.base_model.model.lin1.frod_lambda_s_values["default"].data_ptr()
+            != mlp_same_prng.base_model.model.lin2.frod_lambda_s_values["default"].data_ptr()
+        )
+        assert (
+            mlp_same_prng.base_model.model.lin1.frod_lambda_l["default"].data_ptr()
+            != mlp_same_prng.base_model.model.lin1.frod_lambda_l["other"].data_ptr()
+        )
+        assert (
+            mlp_same_prng.base_model.model.lin1.frod_lambda_l["default"].data_ptr()
+            != mlp_same_prng.base_model.model.lin2.frod_lambda_l["default"].data_ptr()
+        )
+
+    def test_frod_different_shapes(self, mlp):
+        config = FrodConfig(target_modules=["lin0", "lin3"], init_weights=False)
+        mlp_different_shapes = get_peft_model(mlp, config)
+
+        assert mlp.lin0.base_layer.weight.shape != mlp.lin3.base_layer.weight.shape
+        assert mlp_different_shapes.base_model.frod_V["lin0"]["default"].shape == (
+            mlp.lin0.in_features,
+            mlp.lin0.in_features,
+        )
+        assert mlp_different_shapes.base_model.frod_V["lin3"]["default"].shape == (
+            mlp.lin3.in_features,
+            mlp.lin3.in_features,
+        )
+
+        input = torch.randn(5, 10)
+        mlp_different_shapes(input)
+
+    @pytest.mark.parametrize("dtype", [torch.float32, torch.float16, torch.bfloat16])
+    def test_frod_dtypes(self, dtype):
+        if dtype == torch.bfloat16:
+            if not is_bf16_available():
+                pytest.skip("bfloat16 not supported on this system, skipping the test")
+
+        model = MLP().to(dtype)
+        config = FrodConfig(target_modules=["lin1", "lin2"], init_weights=False)
+        peft_model = get_peft_model(model, config)
+        inputs = torch.randn(5, 10).to(dtype)
+        output = peft_model(inputs)
+        assert output.dtype == dtype
diff --git a/tests/test_gptqmodel.py b/tests/test_gptqmodel.py
new file mode 100644
index 0000000..d384b38
--- /dev/null
+++ b/tests/test_gptqmodel.py
@@ -0,0 +1,565 @@
+# Note: These tests were copied from test_common_gpu.py and test_gpu_examples.py as they can run on CPU too.
+#
+# Copyright 2025-present the HuggingFace Inc. 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.
+import gc
+import os
+import tempfile
+import unittest
+
+import pytest
+import torch
+from accelerate.utils.memory import clear_device_cache
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    DataCollatorForLanguageModeling,
+    Trainer,
+    TrainingArguments,
+)
+
+from peft import (
+    AdaLoraConfig,
+    LoraConfig,
+    OFTConfig,
+    PeftModel,
+    get_peft_model,
+    prepare_model_for_kbit_training,
+)
+from peft.tuners.lora import GPTQLoraLinear
+from peft.utils import SAFETENSORS_WEIGHTS_NAME, infer_device
+
+from .testing_utils import (
+    DEVICE_MAP_MAP,
+    load_dataset_english_quotes,
+    require_gptqmodel,
+    require_optimum,
+    require_torch_multi_accelerator,
+)
+
+
+@require_gptqmodel
+class PeftGPTQModelCommonTests(unittest.TestCase):
+    r"""
+    A common tester to run GPT-QModel operations that are performed on GPU/CPU such as generation and adapter loading.
+    """
+
+    def setUp(self):
+        self.causal_lm_model_id = "facebook/opt-350m"
+        self.device = infer_device()
+
+    def tearDown(self):
+        r"""
+        Efficient mechanism to free GPU memory after each test. Based on
+        https://github.com/huggingface/transformers/issues/21094
+        """
+        clear_device_cache(garbage_collection=True)
+        gc.collect()
+
+    def test_lora_gptq_quantization_from_pretrained_safetensors(self):
+        r"""
+        Tests that GPT-QModel quantization using LoRA works as expected with safetensors weights.
+        """
+        from transformers import GPTQConfig
+
+        model_id = "marcsun13/opt-350m-gptq-4bit"
+        quantization_config = GPTQConfig(bits=4)
+        kwargs = {
+            "pretrained_model_name_or_path": model_id,
+            "dtype": torch.float16,
+            "device_map": "auto",
+            "quantization_config": quantization_config,
+        }
+        model = AutoModelForCausalLM.from_pretrained(**kwargs)
+        model = prepare_model_for_kbit_training(model)
+
+        config = LoraConfig(task_type="CAUSAL_LM")
+        peft_model = get_peft_model(model, config)
+        peft_model.generate(input_ids=torch.LongTensor([[0, 2, 3, 1]]).to(peft_model.device))
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            peft_model.save_pretrained(tmp_dir)
+            model = AutoModelForCausalLM.from_pretrained(**kwargs)
+            model = PeftModel.from_pretrained(model, tmp_dir)
+            model = prepare_model_for_kbit_training(model)
+            model.generate(input_ids=torch.LongTensor([[0, 2, 3, 1]]).to(peft_model.device))
+
+            # loading a 2nd adapter works, #1239
+            model.load_adapter(tmp_dir, "adapter2")
+            model.set_adapter("adapter2")
+            model.generate(input_ids=torch.LongTensor([[0, 2, 3, 1]]).to(peft_model.device))
+
+            # check that both adapters are in the same layer
+            assert "default" in model.base_model.model.model.decoder.layers[0].self_attn.q_proj.lora_A
+            assert "adapter2" in model.base_model.model.model.decoder.layers[0].self_attn.q_proj.lora_A
+
+    def test_oft_gptq_quantization_from_pretrained_safetensors(self):
+        r"""
+        Tests that GPT-QModel quantization using OFT works as expected with safetensors weights.
+        """
+        from transformers import GPTQConfig
+
+        model_id = "marcsun13/opt-350m-gptq-4bit"
+        quantization_config = GPTQConfig(bits=4)
+        kwargs = {
+            "pretrained_model_name_or_path": model_id,
+            "dtype": torch.float16,
+            "device_map": "auto",
+            "quantization_config": quantization_config,
+        }
+        model = AutoModelForCausalLM.from_pretrained(**kwargs)
+        model = prepare_model_for_kbit_training(model)
+
+        config = OFTConfig(task_type="CAUSAL_LM")
+        peft_model = get_peft_model(model, config)
+        peft_model.generate(input_ids=torch.LongTensor([[0, 2, 3, 1]]).to(peft_model.device))
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            peft_model.save_pretrained(tmp_dir)
+            model = AutoModelForCausalLM.from_pretrained(**kwargs)
+            model = PeftModel.from_pretrained(model, tmp_dir)
+            model = prepare_model_for_kbit_training(model)
+            model.generate(input_ids=torch.LongTensor([[0, 2, 3, 1]]).to(peft_model.device))
+
+            # loading a 2nd adapter works, #1239
+            model.load_adapter(tmp_dir, "adapter2")
+            model.set_adapter("adapter2")
+            model.generate(input_ids=torch.LongTensor([[0, 2, 3, 1]]).to(peft_model.device))
+
+            # check that both adapters are in the same layer
+            assert "default" in model.base_model.model.model.decoder.layers[0].self_attn.q_proj.oft_R
+            assert "adapter2" in model.base_model.model.model.decoder.layers[0].self_attn.q_proj.oft_R
+
+
+@require_gptqmodel
+@require_optimum
+class PeftGPTQModelTests(unittest.TestCase):
+    r"""
+    GPT-QModel + PEFT tests
+    """
+
+    def setUp(self):
+        from transformers import GPTQConfig
+        from transformers.utils.quantization_config import AwqBackend
+
+        self.causal_lm_model_id = "marcsun13/opt-350m-gptq-4bit"
+        # PEFT needs GPT-QModel's trainable backend here rather than inference auto-selection.
+        self.quantization_config = GPTQConfig(bits=4, backend=AwqBackend.AUTO_TRAINABLE)
+        self.tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+
+    def tearDown(self):
+        r"""
+        Efficient mechanism to free GPU memory after each test. Based on
+        https://github.com/huggingface/transformers/issues/21094
+        """
+        clear_device_cache(garbage_collection=True)
+
+    def _check_inference_finite(self, model, batch):
+        # try inference without Trainer class
+        training = model.training
+        model.eval()
+        output = model(**batch.to(model.device))
+        assert torch.isfinite(output.logits).all()
+        model.train(training)
+
+    def test_causal_lm_training(self):
+        r"""
+        Test the CausalLM training on a single GPU device. The test would simply fail if the adapters are not set
+        correctly.
+        """
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                dtype=torch.float16,
+                device_map="auto",
+                quantization_config=self.quantization_config,
+            )
+
+            model = prepare_model_for_kbit_training(model)
+            config = LoraConfig(
+                r=16,
+                lora_alpha=32,
+                target_modules=["q_proj", "v_proj"],
+                lora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: self.tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    def test_oft_causal_lm_training(self):
+        r"""
+        Test the CausalLM training on a single GPU device. The test would simply fail if the adapters are not set
+        correctly.
+        """
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                dtype=torch.float16,
+                device_map="auto",
+                quantization_config=self.quantization_config,
+            )
+
+            model = prepare_model_for_kbit_training(model)
+            config = OFTConfig(
+                r=0,
+                oft_block_size=8,
+                target_modules=["q_proj", "v_proj"],
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: self.tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.single_gpu_tests
+    def test_adalora_causalLM(self):
+        r"""
+        Tests the gptq training with adalora
+        """
+
+        model = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            dtype=torch.float16,
+            device_map="auto",
+            quantization_config=self.quantization_config,
+        )
+
+        tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+        model = prepare_model_for_kbit_training(model)
+
+        peft_config = AdaLoraConfig(
+            total_step=40,
+            init_r=6,
+            target_r=4,
+            tinit=10,
+            tfinal=20,
+            deltaT=5,
+            beta1=0.3,
+            beta2=0.3,
+            orth_reg_weight=0.2,
+            lora_alpha=32,
+            lora_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+
+        model = get_peft_model(model, peft_config)
+
+        data = load_dataset_english_quotes()
+        data = data.map(lambda samples: self.tokenizer(samples["quote"]), batched=True)
+        batch = tokenizer(data["train"][:3]["quote"], return_tensors="pt", padding=True)
+        self._check_inference_finite(model, batch)
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.multi_gpu_tests
+    @require_torch_multi_accelerator
+    def test_causal_lm_training_multi_accelerator(self):
+        r"""
+        Test the CausalLM training on a multi-accelerator device. The test would simply fail if the adapters are not
+        set correctly.
+        """
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                dtype=torch.float16,
+                device_map=DEVICE_MAP_MAP[self.causal_lm_model_id],
+                quantization_config=self.quantization_config,
+            )
+
+            assert set(model.hf_device_map.values()) == set(range(2))
+
+            model = prepare_model_for_kbit_training(model)
+
+            model.model_parallel = True
+            model.is_parallelizable = True
+
+            config = LoraConfig(
+                r=16,
+                lora_alpha=32,
+                target_modules=["q_proj", "v_proj"],
+                lora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: self.tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.multi_gpu_tests
+    @require_torch_multi_accelerator
+    def test_oft_causal_lm_training_multi_accelerator(self):
+        r"""
+        Test the CausalLM training on a multi-accelerator device. The test would simply fail if the adapters are not
+        set correctly.
+        """
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                dtype=torch.float16,
+                device_map=DEVICE_MAP_MAP[self.causal_lm_model_id],
+                quantization_config=self.quantization_config,
+            )
+
+            assert set(model.hf_device_map.values()) == set(range(2))
+
+            model = prepare_model_for_kbit_training(model)
+
+            model.model_parallel = True
+            model.is_parallelizable = True
+
+            config = OFTConfig(
+                r=0,
+                oft_block_size=8,
+                target_modules=["q_proj", "v_proj"],
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: self.tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    def test_non_default_adapter_name(self):
+        # See issue 1346
+        config = LoraConfig(
+            r=16,
+            target_modules=["q_proj", "v_proj"],
+            task_type="CAUSAL_LM",
+        )
+
+        # default adapter name
+        model = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            dtype=torch.float16,
+            device_map="auto",
+            quantization_config=self.quantization_config,
+        )
+        model = prepare_model_for_kbit_training(model)
+        model = get_peft_model(model, config)
+        n_trainable_default, n_total_default = model.get_nb_trainable_parameters()
+
+        # other adapter name
+        model = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            dtype=torch.float16,
+            device_map="auto",
+            quantization_config=self.quantization_config,
+        )
+        model = prepare_model_for_kbit_training(model)
+        model = get_peft_model(model, config, adapter_name="other")
+        n_trainable_other, n_total_other = model.get_nb_trainable_parameters()
+
+        assert n_trainable_other > 0
+        # sanity check
+        assert n_trainable_default == n_trainable_other
+        assert n_total_default == n_total_other
+
+    def test_oft_non_default_adapter_name(self):
+        # See issue 1346
+        config = OFTConfig(
+            r=0,
+            oft_block_size=8,
+            target_modules=["q_proj", "v_proj"],
+            task_type="CAUSAL_LM",
+        )
+
+        # default adapter name
+        model = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            dtype=torch.float16,
+            device_map="auto",
+            quantization_config=self.quantization_config,
+        )
+        model = prepare_model_for_kbit_training(model)
+        model = get_peft_model(model, config)
+        n_trainable_default, n_total_default = model.get_nb_trainable_parameters()
+
+        # other adapter name
+        model = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            dtype=torch.float16,
+            device_map="auto",
+            quantization_config=self.quantization_config,
+        )
+        model = prepare_model_for_kbit_training(model)
+        model = get_peft_model(model, config, adapter_name="other")
+        n_trainable_other, n_total_other = model.get_nb_trainable_parameters()
+
+        assert n_trainable_other > 0
+        # sanity check
+        assert n_trainable_default == n_trainable_other
+        assert n_total_default == n_total_other
+
+    def test_load_lora(self):
+        model_id = "ModelCloud/Llama-3.2-1B-gptqmodel-ci-4bit"
+        adapter_id = "ModelCloud/Llama-3.2-1B-gptqmodel-ci-4bit-lora"
+
+        model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto")
+        model.load_adapter(adapter_id)
+
+        # assert dynamic rank
+        v_proj_module = model.model.layers[5].self_attn.v_proj
+        assert isinstance(v_proj_module, GPTQLoraLinear)
+        assert v_proj_module.lora_A["default"].weight.data.shape[0] == 128
+        assert v_proj_module.lora_B["default"].weight.data.shape[1] == 128
+        gate_proj_module = model.model.layers[5].mlp.gate_proj
+        assert isinstance(gate_proj_module, GPTQLoraLinear)
+        assert gate_proj_module.lora_A["default"].weight.data.shape[0] == 256
+        assert gate_proj_module.lora_B["default"].weight.data.shape[1] == 256
+
+        tokenizer = AutoTokenizer.from_pretrained(model_id)
+        inp = tokenizer("Capital of France is", return_tensors="pt").to(model.device)
+        tokens = model.generate(**inp)[0]
+        result = tokenizer.decode(tokens)
+
+        assert "paris" in result.lower()
diff --git a/tests/test_gpu_examples.py b/tests/test_gpu_examples.py
new file mode 100644
index 0000000..bea83b4
--- /dev/null
+++ b/tests/test_gpu_examples.py
@@ -0,0 +1,6989 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+import datetime
+import gc
+import importlib
+import itertools
+import os
+import re
+import socket
+import tempfile
+import unittest
+import warnings
+from collections import Counter, defaultdict
+from copy import deepcopy
+from dataclasses import dataclass
+from functools import partial
+from pathlib import Path
+from typing import Any, Union
+
+import numpy as np
+import packaging
+import pytest
+import torch
+import torch.distributed as dist
+import torch.multiprocessing as mp
+import transformers
+from accelerate import infer_auto_device_map
+from accelerate.test_utils.testing import get_backend, run_command
+from accelerate.utils import patch_environment
+from accelerate.utils.imports import is_bf16_available
+from accelerate.utils.memory import clear_device_cache
+from datasets import Audio, Dataset, DatasetDict, load_dataset
+from packaging import version
+from parameterized import parameterized
+from safetensors.torch import load_file, save_file
+from torch.distributed import init_process_group
+from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
+from torch.utils.data import DataLoader
+from transformers import (
+    AutoModelForCausalLM,
+    AutoModelForSeq2SeqLM,
+    AutoTokenizer,
+    BitsAndBytesConfig,
+    DataCollatorForLanguageModeling,
+    FineGrainedFP8Config,
+    Seq2SeqTrainer,
+    Seq2SeqTrainingArguments,
+    Trainer,
+    TrainerCallback,
+    TrainingArguments,
+    WhisperFeatureExtractor,
+    WhisperForConditionalGeneration,
+    WhisperProcessor,
+    WhisperTokenizer,
+)
+from transformers.pytorch_utils import Conv1D
+
+from peft import (
+    AdaLoraConfig,
+    ArrowConfig,
+    EvaConfig,
+    FrodConfig,
+    HiraConfig,
+    LoftQConfig,
+    LoraConfig,
+    PeftModel,
+    PrefixTuningConfig,
+    PromptEncoderConfig,
+    PveraConfig,
+    RandLoraConfig,
+    RoadConfig,
+    TaskType,
+    VeraConfig,
+    create_arrow_model,
+    get_eva_state_dict,
+    get_peft_model,
+    get_peft_model_state_dict,
+    initialize_lora_eva_weights,
+    inject_adapter_in_model,
+    prepare_model_for_kbit_training,
+    replace_lora_weights_loftq,
+    set_peft_model_state_dict,
+)
+from peft.import_utils import (
+    is_diffusers_available,
+    is_te_available,
+    is_transformers_ge_v5,
+    is_xpu_available,
+)
+from peft.tuners import boft
+from peft.tuners.lora import LoraLayer
+from peft.tuners.tuners_utils import BaseTunerLayer
+from peft.utils import SAFETENSORS_WEIGHTS_NAME, infer_device
+from peft.utils.hotswap import hotswap_adapter, prepare_model_for_compiled_hotswap
+from peft.utils.loftq_utils import NFQuantizer
+from peft.utils.other import fsdp_auto_wrap_policy
+from tests.testing_utils import hub_online_once
+
+from .testing_utils import (
+    DEVICE_MAP_MAP,
+    device_count,
+    load_dataset_english_quotes,
+    require_aqlm,
+    require_bitsandbytes,
+    require_deterministic_for_xpu,
+    require_eetq,
+    require_gptqmodel,
+    require_hqq,
+    require_non_cpu,
+    require_non_xpu,
+    require_optimum,
+    require_torch_gpu,
+    require_torch_multi_accelerator,
+    require_torch_multi_gpu,
+    require_torchao,
+    torch_device,
+)
+
+
+device, _, _ = get_backend()
+if device == "cpu":
+    pytest.skip(allow_module_level=True, reason="GPU tests require hardware accelerator, got CPU only")
+
+
+# A full testing suite that tests all the necessary features on GPU. The tests should
+# rely on the example scripts to test the features.
+
+
+class FrodRuntimeOffloadMLP(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.relu = torch.nn.ReLU()
+        self.lin0 = torch.nn.Linear(10, 20)
+        self.lin1 = torch.nn.Linear(20, 20)
+        self.lin2 = torch.nn.Linear(20, 20)
+        self.lin3 = torch.nn.Linear(20, 2)
+
+    def forward(self, inputs):
+        hidden = self.lin0(inputs)
+        hidden = self.relu(hidden)
+        hidden = self.lin1(hidden)
+        hidden = self.relu(hidden)
+        hidden = self.lin2(hidden)
+        hidden = self.relu(hidden)
+        return self.lin3(hidden)
+
+
+@pytest.mark.single_gpu_tests
+def test_frod_runtime_offload_keeps_base_weight_on_cpu_after_accelerator_move():
+    config = FrodConfig(target_modules=["lin1", "lin2"], runtime_offload_base_weight=True)
+    peft_model = get_peft_model(FrodRuntimeOffloadMLP(), config).to(torch_device)
+    lin1 = peft_model.base_model.model.lin1
+
+    assert lin1.get_base_layer().weight.device.type == "cpu"
+    assert lin1.frod_U["default"].device.type == torch_device
+    assert lin1.frod_lambda_l["default"].device.type == torch_device
+
+    inputs = torch.randn(5, 10, device=torch_device)
+    output = peft_model(inputs)
+
+    assert output.device.type == torch_device
+    assert lin1.get_base_layer().weight.device.type == "cpu"
+
+
+@dataclass
+class DataCollatorSpeechSeq2SeqWithPadding:
+    r"""
+    Directly copied from:
+    https://github.com/huggingface/peft/blob/main/examples/int8_training/peft_bnb_whisper_large_v2_training.ipynb
+    """
+
+    processor: Any
+
+    def __call__(self, features: list[dict[str, Union[list[int], torch.Tensor]]]) -> dict[str, torch.Tensor]:
+        # split inputs and labels since they have to be of different lengths and need different padding methods
+        # first treat the audio inputs by simply returning torch tensors
+        input_features = [{"input_features": feature["input_features"]} for feature in features]
+        batch = self.processor.feature_extractor.pad(input_features, return_tensors="pt")
+
+        # get the tokenized label sequences
+        label_features = [{"input_ids": feature["labels"]} for feature in features]
+        # pad the labels to max length
+        labels_batch = self.processor.tokenizer.pad(label_features, return_tensors="pt")
+
+        # replace padding with -100 to ignore loss correctly
+        labels = labels_batch["input_ids"].masked_fill(labels_batch.attention_mask.ne(1), -100)
+
+        # if bos token is appended in previous tokenization step,
+        # cut bos token here as it's append later anyways
+        if (labels[:, 0] == self.processor.tokenizer.bos_token_id).all().cpu().item():
+            labels = labels[:, 1:]
+
+        batch["labels"] = labels
+
+        return batch
+
+
+@require_non_cpu
+@require_bitsandbytes
+class PeftBnbGPUExampleTests(unittest.TestCase):
+    r"""
+    A single GPU int8 + fp4 test suite, this will test if training fits correctly on a single GPU device (1x NVIDIA T4
+    16GB) using bitsandbytes.
+
+    The tests are the following:
+
+    - Seq2Seq model training based on:
+      https://github.com/huggingface/peft/blob/main/examples/int8_training/Finetune_flan_t5_large_bnb_peft.ipynb
+    - Causal LM model training based on:
+      https://github.com/huggingface/peft/blob/main/examples/int8_training/Finetune_opt_bnb_peft.ipynb
+    - Audio model training based on:
+      https://github.com/huggingface/peft/blob/main/examples/int8_training/peft_bnb_whisper_large_v2_training.ipynb
+
+    """
+
+    def setUp(self):
+        self.seq2seq_model_id = "google/flan-t5-base"
+        self.causal_lm_model_id = "facebook/opt-6.7b"
+        self.tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+        self.audio_model_id = "openai/whisper-large"
+
+    def tearDown(self):
+        r"""
+        Efficient mechanism to free GPU memory after each test. Based on
+        https://github.com/huggingface/transformers/issues/21094
+        """
+        clear_device_cache(garbage_collection=True)
+
+    def _check_inference_finite(self, model, batch):
+        # try inference without Trainer class
+        training = model.training
+        model.eval()
+        output = model(**batch.to(model.device))
+        assert torch.isfinite(output.logits).all()
+        model.train(training)
+
+    @pytest.mark.single_gpu_tests
+    def test_causal_lm_training(self):
+        r"""
+        Test the CausalLM training on a single GPU device. This test is a converted version of
+        https://github.com/huggingface/peft/blob/main/examples/int8_training/Finetune_opt_bnb_peft.ipynb where we train
+        `opt-6.7b` on `english_quotes` dataset in few steps. The test would simply fail if the adapters are not set
+        correctly.
+        """
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+                device_map="auto",
+            )
+
+            tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+            model = prepare_model_for_kbit_training(model)
+
+            config = LoraConfig(
+                r=16,
+                lora_alpha=32,
+                target_modules=["q_proj", "v_proj"],
+                lora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.single_gpu_tests
+    def test_causal_lm_training_4bit(self):
+        r"""
+        Test the CausalLM training on a single GPU device. This test is a converted version of
+        https://github.com/huggingface/peft/blob/main/examples/int8_training/Finetune_opt_bnb_peft.ipynb where we train
+        `opt-6.7b` on `english_quotes` dataset in few steps using 4bit base model. The test would simply fail if the
+        adapters are not set correctly.
+        """
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+                device_map="auto",
+            )
+
+            tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+            model = prepare_model_for_kbit_training(model)
+
+            config = LoraConfig(
+                r=16,
+                lora_alpha=32,
+                target_modules=["q_proj", "v_proj"],
+                lora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.multi_gpu_tests
+    def test_causal_lm_training_multi_gpu_4bit(self):
+        r"""
+        Test the CausalLM training on a multi-GPU device with 4bit base model. The test would simply fail if the
+        adapters are not set correctly.
+        """
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                device_map=DEVICE_MAP_MAP[self.causal_lm_model_id],
+                quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+            )
+
+            assert set(model.hf_device_map.values()) == set(range(device_count))
+            assert {p.device.index for p in model.parameters()} == set(range(device_count))
+
+            model = prepare_model_for_kbit_training(model)
+
+            model.model_parallel = True
+            model.is_parallelizable = True
+
+            config = LoraConfig(
+                r=16,
+                lora_alpha=32,
+                target_modules=["q_proj", "v_proj"],
+                lora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: self.tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.single_gpu_tests
+    @require_non_cpu
+    def test_4bit_adalora_causalLM(self):
+        r"""
+        Tests the 4bit training with adalora
+        """
+        model_id = "facebook/opt-350m"
+
+        # for >3 GPUs, might need: device_map={"": "cuda:0"}
+        model = AutoModelForCausalLM.from_pretrained(
+            model_id, quantization_config=BitsAndBytesConfig(load_in_4bit=True)
+        )
+        tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+        model.gradient_checkpointing_enable()
+        model = prepare_model_for_kbit_training(model)
+
+        peft_config = AdaLoraConfig(
+            init_r=6,
+            target_r=4,
+            tinit=2,
+            tfinal=2,
+            total_step=6,
+            deltaT=5,
+            beta1=0.3,
+            beta2=0.3,
+            orth_reg_weight=0.2,
+            lora_alpha=32,
+            lora_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+
+        model = get_peft_model(model, peft_config)
+
+        data = load_dataset_english_quotes()
+        data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+        batch = tokenizer(data["train"][:3]["quote"], return_tensors="pt", padding=True)
+        self._check_inference_finite(model, batch)
+
+        class OptimizerStepCallback(TrainerCallback):
+            def on_optimizer_step(self, args, state, control, **kwargs):
+                model.update_and_allocate(state.global_step)
+
+        step_callback = OptimizerStepCallback()
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=6,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.add_callback(step_callback)
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.single_gpu_tests
+    @require_non_cpu
+    def test_8bit_adalora_causalLM(self):
+        r"""
+        Tests the 8bit training with adalora
+        """
+        model_id = "facebook/opt-350m"
+
+        model = AutoModelForCausalLM.from_pretrained(
+            model_id, quantization_config=BitsAndBytesConfig(load_in_8bit=True)
+        )
+        tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+        model.gradient_checkpointing_enable()
+        model = prepare_model_for_kbit_training(model)
+
+        peft_config = AdaLoraConfig(
+            init_r=6,
+            target_r=4,
+            tinit=2,
+            tfinal=2,
+            total_step=6,
+            deltaT=5,
+            beta1=0.3,
+            beta2=0.3,
+            orth_reg_weight=0.2,
+            lora_alpha=32,
+            lora_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+
+        model = get_peft_model(model, peft_config)
+
+        data = load_dataset_english_quotes()
+        data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+        batch = tokenizer(data["train"][:3]["quote"], return_tensors="pt", padding=True)
+        self._check_inference_finite(model, batch)
+
+        class OptimizerStepCallback(TrainerCallback):
+            def on_optimizer_step(self, args, state, control, **kwargs):
+                model.update_and_allocate(state.global_step)
+
+        step_callback = OptimizerStepCallback()
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=6,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.add_callback(step_callback)
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.multi_gpu_tests
+    @require_torch_multi_accelerator
+    def test_causal_lm_training_multi_gpu(self):
+        r"""
+        Test the CausalLM training on a multi-GPU device. This test is a converted version of
+        https://github.com/huggingface/peft/blob/main/examples/int8_training/Finetune_opt_bnb_peft.ipynb where we train
+        `opt-6.7b` on `english_quotes` dataset in few steps. The test would simply fail if the adapters are not set
+        correctly.
+        """
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+                device_map="auto",
+            )
+            print(f"device map: {model.hf_device_map}")
+            assert set(model.hf_device_map.values()) == set(range(device_count))
+
+            tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+            model = prepare_model_for_kbit_training(model)
+
+            model.model_parallel = True
+            model.is_parallelizable = True
+
+            config = LoraConfig(
+                r=16,
+                lora_alpha=32,
+                target_modules=["q_proj", "v_proj"],
+                lora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.single_gpu_tests
+    def test_seq2seq_lm_training_single_gpu(self):
+        r"""
+        Test the Seq2SeqLM training on a single GPU device. This test is a converted version of
+        https://github.com/huggingface/peft/blob/main/examples/int8_training/Finetune_opt_bnb_peft.ipynb where we train
+        `flan-large` on `english_quotes` dataset in few steps. The test would simply fail if the adapters are not set
+        correctly.
+        """
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForSeq2SeqLM.from_pretrained(
+                self.seq2seq_model_id,
+                quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+                device_map={"": 0},
+            )
+
+            # note: transformers v5 doesn't set the device map if there's only one device
+            assert not hasattr(model, "hf_device_map") or set(model.hf_device_map.values()) == {0}
+
+            tokenizer = AutoTokenizer.from_pretrained(self.seq2seq_model_id)
+            model = prepare_model_for_kbit_training(model)
+
+            config = LoraConfig(
+                r=16,
+                lora_alpha=32,
+                target_modules=["q", "v"],
+                lora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.multi_gpu_tests
+    @require_torch_multi_accelerator
+    def test_seq2seq_lm_training_multi_gpu(self):
+        r"""
+        Test the Seq2SeqLM training on a multi-GPU device. This test is a converted version of
+        https://github.com/huggingface/peft/blob/main/examples/int8_training/Finetune_opt_bnb_peft.ipynb where we train
+        `flan-large` on `english_quotes` dataset in few steps. The test would simply fail if the adapters are not set
+        correctly.
+        """
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForSeq2SeqLM.from_pretrained(
+                self.seq2seq_model_id,
+                quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+                device_map=DEVICE_MAP_MAP[self.seq2seq_model_id],
+            )
+
+            assert set(model.hf_device_map.values()) == set(range(device_count))
+            assert {p.device.index for p in model.parameters()} == set(range(device_count))
+
+            tokenizer = AutoTokenizer.from_pretrained(self.seq2seq_model_id)
+            model = prepare_model_for_kbit_training(model)
+
+            config = LoraConfig(
+                r=16,
+                lora_alpha=32,
+                target_modules=["q", "v"],
+                lora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir="outputs",
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    # TODO skipping to see if this leads to single GPU tests passing
+    @pytest.mark.skip
+    @pytest.mark.single_gpu_tests
+    def test_audio_model_training(self):
+        r"""
+        Test the audio model training on a single GPU device. This test is a converted version of
+        https://github.com/huggingface/peft/blob/main/examples/int8_training/peft_bnb_whisper_large_v2_training.ipynb
+        """
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            dataset_name = "ybelkada/common_voice_mr_11_0_copy"
+            task = "transcribe"
+            language = "Marathi"
+            common_voice = DatasetDict()
+
+            common_voice["train"] = load_dataset(dataset_name, split="train+validation")
+
+            common_voice = common_voice.remove_columns(
+                ["accent", "age", "client_id", "down_votes", "gender", "locale", "path", "segment", "up_votes"]
+            )
+
+            feature_extractor = WhisperFeatureExtractor.from_pretrained(self.audio_model_id)
+            tokenizer = WhisperTokenizer.from_pretrained(self.audio_model_id, language=language, task=task)
+            processor = WhisperProcessor.from_pretrained(self.audio_model_id, language=language, task=task)
+
+            common_voice = common_voice.cast_column("audio", Audio(sampling_rate=16000))
+
+            def prepare_dataset(batch):
+                # load and resample audio data from 48 to 16kHz
+                audio = batch["audio"]
+
+                # compute log-Mel input features from input audio array
+                batch["input_features"] = feature_extractor(
+                    audio["array"], sampling_rate=audio["sampling_rate"]
+                ).input_features[0]
+
+                # encode target text to label ids
+                batch["labels"] = tokenizer(batch["sentence"]).input_ids
+                return batch
+
+            common_voice = common_voice.map(
+                prepare_dataset, remove_columns=common_voice.column_names["train"], num_proc=2
+            )
+            data_collator = DataCollatorSpeechSeq2SeqWithPadding(processor=processor)
+
+            model = WhisperForConditionalGeneration.from_pretrained(
+                self.audio_model_id, quantization_config=BitsAndBytesConfig(load_in_8bit=True), device_map="auto"
+            )
+
+            model.config.forced_decoder_ids = None
+            model.config.suppress_tokens = []
+
+            model = prepare_model_for_kbit_training(model)
+
+            # as Whisper model uses Conv layer in encoder, checkpointing disables grad computation
+            # to avoid this, make the inputs trainable
+            def make_inputs_require_grad(module, input, output):
+                output.requires_grad_(True)
+
+            model.model.encoder.conv1.register_forward_hook(make_inputs_require_grad)
+
+            config = LoraConfig(
+                r=32, lora_alpha=64, target_modules=["q_proj", "v_proj"], lora_dropout=0.05, bias="none"
+            )
+
+            model = get_peft_model(model, config)
+            model.print_trainable_parameters()
+
+            training_args = Seq2SeqTrainingArguments(
+                output_dir=tmp_dir,  # change to a repo name of your choice
+                per_device_train_batch_size=8,
+                gradient_accumulation_steps=1,  # increase by 2x for every 2x decrease in batch size
+                learning_rate=1e-3,
+                warmup_steps=2,
+                max_steps=3,
+                fp16=True,
+                per_device_eval_batch_size=8,
+                generation_max_length=128,
+                logging_steps=25,
+                remove_unused_columns=False,  # required as the PeftModel forward doesn't have the signature of the wrapped model's forward
+                label_names=["labels"],  # same reason as above
+            )
+
+            trainer = Seq2SeqTrainer(
+                args=training_args,
+                model=model,
+                train_dataset=common_voice["train"],
+                data_collator=data_collator,
+                tokenizer=processor.feature_extractor,
+            )
+
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.single_gpu_tests
+    def test_4bit_non_default_adapter_name(self):
+        # See PR 1294
+        config = LoraConfig(
+            r=16,
+            target_modules=["q_proj", "v_proj"],
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+
+        # default adapter name
+        model = AutoModelForCausalLM.from_pretrained(
+            "peft-internal-testing/opt-125m",
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+        )
+        model = prepare_model_for_kbit_training(model)
+        model = get_peft_model(model, config)
+        n_trainable_default, n_total_default = model.get_nb_trainable_parameters()
+
+        # other adapter name
+        model = AutoModelForCausalLM.from_pretrained(
+            "peft-internal-testing/opt-125m",
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+        )
+        model = prepare_model_for_kbit_training(model)
+        model = get_peft_model(model, config, adapter_name="other")
+        n_trainable_other, n_total_other = model.get_nb_trainable_parameters()
+
+        assert n_trainable_other > 0
+        # sanity check
+        assert n_trainable_default == n_trainable_other
+        assert n_total_default == n_total_other
+
+    @pytest.mark.single_gpu_tests
+    def test_8bit_non_default_adapter_name(self):
+        # See PR 1294
+        config = LoraConfig(
+            r=16,
+            target_modules=["q_proj", "v_proj"],
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+
+        # default adapter name
+        model = AutoModelForCausalLM.from_pretrained(
+            "peft-internal-testing/opt-125m",
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+        )
+        model = prepare_model_for_kbit_training(model)
+        model = get_peft_model(model, config)
+        n_trainable_default, n_total_default = model.get_nb_trainable_parameters()
+
+        # other adapter name
+        model = AutoModelForCausalLM.from_pretrained(
+            "peft-internal-testing/opt-125m",
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+        )
+        model = prepare_model_for_kbit_training(model)
+        model = get_peft_model(model, config, adapter_name="other")
+        n_trainable_other, n_total_other = model.get_nb_trainable_parameters()
+
+        assert n_trainable_other > 0
+        # sanity check
+        assert n_trainable_default == n_trainable_other
+        assert n_total_default == n_total_other
+
+    @pytest.mark.single_gpu_tests
+    def test_causal_lm_training_4bit_dora(self):
+        r"""
+        Same as test_causal_lm_training_4bit but with DoRA
+        """
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+                device_map="auto",
+            )
+
+            tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+            model = prepare_model_for_kbit_training(model)
+
+            config = LoraConfig(
+                r=16,
+                lora_alpha=32,
+                target_modules=["q_proj", "v_proj"],
+                lora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+                use_dora=True,
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.multi_gpu_tests
+    def test_causal_lm_training_multi_gpu_4bit_dora(self):
+        r"""
+        Same as test_causal_lm_training_multi_gpu_4bit but with DoRA
+        """
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                device_map=DEVICE_MAP_MAP[self.causal_lm_model_id],
+                quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+            )
+
+            assert set(model.hf_device_map.values()) == set(range(device_count))
+            assert {p.device.index for p in model.parameters()} == set(range(device_count))
+
+            model = prepare_model_for_kbit_training(model)
+
+            model.model_parallel = True
+            model.is_parallelizable = True
+
+            config = LoraConfig(
+                r=16,
+                lora_alpha=32,
+                target_modules=["q_proj", "v_proj"],
+                lora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+                use_dora=True,
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: self.tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.single_gpu_tests
+    def test_causal_lm_training_8bit_dora(self):
+        r"""
+        Same as test_causal_lm_training_4bit_dora but with 8bit
+        """
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+                device_map="auto",
+            )
+
+            tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+            model = prepare_model_for_kbit_training(model)
+
+            config = LoraConfig(
+                r=16,
+                lora_alpha=32,
+                target_modules=["q_proj", "v_proj"],
+                lora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+                use_dora=True,
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.multi_gpu_tests
+    def test_causal_lm_training_multi_gpu_8bit_dora(self):
+        r"""
+        Same as test_causal_lm_training_multi_gpu_4bit_dora but with 8bit
+        """
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                device_map=DEVICE_MAP_MAP[self.causal_lm_model_id],
+                quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+            )
+
+            assert set(model.hf_device_map.values()) == set(range(device_count))
+            assert {p.device.index for p in model.parameters()} == set(range(device_count))
+
+            model = prepare_model_for_kbit_training(model)
+
+            model.model_parallel = True
+            model.is_parallelizable = True
+
+            config = LoraConfig(
+                r=16,
+                lora_alpha=32,
+                target_modules=["q_proj", "v_proj"],
+                lora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+                use_dora=True,
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: self.tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.single_gpu_tests
+    def test_causal_lm_training_gpt2_dora(self):
+        r"""
+        Same as test_causal_lm_training_4bit but with DoRA
+        """
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained("gpt2", device_map="auto")
+
+            tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+            model = prepare_model_for_kbit_training(model)
+
+            config = LoraConfig(
+                r=16,
+                lora_alpha=32,
+                lora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+                use_dora=True,
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @parameterized.expand(["4bit", "8bit"])
+    def test_initialize_dora_with_bnb_on_cpu(self, kbit):
+        # 1674
+        # The issue is that to initialize DoRA, we need to dequantize the weights. That only works on GPU for bnb.
+        # Therefore, initializing DoRA with bnb on CPU used to fail.
+        model_id = "peft-internal-testing/opt-125m"
+        if kbit == "4bit":
+            bnb_config = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type="nf4")
+        elif kbit == "8bit":
+            bnb_config = BitsAndBytesConfig(load_in_8bit=True)
+        else:
+            raise ValueError("Only 4bit and 8bit bnb allowed")
+
+        model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=bnb_config)
+        model = model.cpu()  # ensure that we're on CPU
+        # sanity check that all weights are on CPU
+        weights_not_cpu = [name for name, p in model.named_parameters() if p.device != torch.device("cpu")]
+        assert not weights_not_cpu
+
+        lora_config = LoraConfig(use_dora=True)
+
+        # should not raise
+        peft_model = get_peft_model(model, lora_config)
+        # check that the weights are still on CPU
+        weights_not_cpu = [name for name, p in peft_model.named_parameters() if p.device != torch.device("cpu")]
+        assert not weights_not_cpu
+
+    @pytest.mark.single_gpu_tests
+    def test_causal_lm_training_vera(self):
+        r"""
+        Same as test_causal_lm_training but with VeRA
+        """
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+                device_map="auto",
+            )
+
+            tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+            model = prepare_model_for_kbit_training(model)
+
+            config = VeraConfig(
+                r=16,
+                target_modules=["q_proj", "v_proj"],
+                vera_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.single_gpu_tests
+    def test_causal_lm_training_pvera(self):
+        r"""
+        Same as test_causal_lm_training but with PVeRA
+        """
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+                device_map="auto",
+            )
+
+            tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+            model = prepare_model_for_kbit_training(model)
+
+            config = PveraConfig(
+                r=16,
+                target_modules=["q_proj", "v_proj"],
+                pvera_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.single_gpu_tests
+    def test_causal_lm_training_4bit_vera(self):
+        r"""
+        Same as test_causal_lm_training_4bit but with VeRA
+        """
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+                device_map="auto",
+            )
+
+            tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+            model = prepare_model_for_kbit_training(model)
+
+            config = VeraConfig(
+                r=16,
+                target_modules=["q_proj", "v_proj"],
+                vera_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.single_gpu_tests
+    def test_causal_lm_training_4bit_pvera(self):
+        r"""
+        Same as test_causal_lm_training_4bit but with PVeRA
+        """
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+                device_map="auto",
+            )
+
+            tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+            model = prepare_model_for_kbit_training(model)
+
+            config = PveraConfig(
+                r=16,
+                target_modules=["q_proj", "v_proj"],
+                pvera_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.multi_gpu_tests
+    def test_causal_lm_training_multi_gpu_vera(self):
+        r"""
+        Same as test_causal_lm_training_multi_gpu but with VeRA
+        """
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                device_map=DEVICE_MAP_MAP[self.causal_lm_model_id],
+                quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+            )
+
+            assert set(model.hf_device_map.values()) == set(range(device_count))
+            assert {p.device.index for p in model.parameters()} == set(range(device_count))
+
+            model = prepare_model_for_kbit_training(model)
+
+            model.model_parallel = True
+            model.is_parallelizable = True
+
+            config = VeraConfig(
+                r=16,
+                target_modules=["q_proj", "v_proj"],
+                vera_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: self.tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.multi_gpu_tests
+    def test_causal_lm_training_multi_gpu_pvera(self):
+        r"""
+        Same as test_causal_lm_training_multi_gpu but with PVeRA
+        """
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                device_map=DEVICE_MAP_MAP[self.causal_lm_model_id],
+                quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+            )
+
+            assert set(model.hf_device_map.values()) == set(range(device_count))
+            assert {p.device.index for p in model.parameters()} == set(range(device_count))
+
+            model = prepare_model_for_kbit_training(model)
+
+            model.model_parallel = True
+            model.is_parallelizable = True
+
+            config = PveraConfig(
+                r=16,
+                target_modules=["q_proj", "v_proj"],
+                vera_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: self.tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.multi_gpu_tests
+    def test_causal_lm_training_multi_gpu_4bit_vera(self):
+        r"""
+        Same as test_causal_lm_training_multi_gpu_4bit but with VeRA
+        """
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                device_map=DEVICE_MAP_MAP[self.causal_lm_model_id],
+                quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+            )
+
+            assert set(model.hf_device_map.values()) == set(range(device_count))
+            assert {p.device.index for p in model.parameters()} == set(range(device_count))
+
+            model = prepare_model_for_kbit_training(model)
+
+            model.model_parallel = True
+            model.is_parallelizable = True
+
+            config = VeraConfig(
+                r=16,
+                target_modules=["q_proj", "v_proj"],
+                vera_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: self.tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.multi_gpu_tests
+    def test_causal_lm_training_multi_gpu_4bit_pvera(self):
+        r"""
+        Same as test_causal_lm_training_multi_gpu_4bit but with PVeRA
+        """
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                device_map=DEVICE_MAP_MAP[self.causal_lm_model_id],
+                quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+            )
+
+            assert set(model.hf_device_map.values()) == set(range(device_count))
+            assert {p.device.index for p in model.parameters()} == set(range(device_count))
+
+            model = prepare_model_for_kbit_training(model)
+
+            model.model_parallel = True
+            model.is_parallelizable = True
+
+            config = PveraConfig(
+                r=16,
+                target_modules=["q_proj", "v_proj"],
+                pvera_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: self.tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.single_gpu_tests
+    def test_causal_lm_training_8bit_randlora(self):
+        r"""
+        Same as test_causal_lm_training but with RandLora
+        """
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+                device_map="auto",
+            )
+
+            tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+            model = prepare_model_for_kbit_training(model)
+
+            config = RandLoraConfig(
+                r=16,
+                target_modules=["q_proj", "v_proj"],
+                randlora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset("ybelkada/english_quotes_copy")
+            data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.single_gpu_tests
+    def test_causal_lm_training_4bit_randlora(self):
+        r"""
+        Same as test_causal_lm_training_4bit but with RandLora
+        """
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+                device_map="auto",
+            )
+
+            tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+            model = prepare_model_for_kbit_training(model)
+
+            config = RandLoraConfig(
+                r=16,
+                target_modules=["q_proj", "v_proj"],
+                randlora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset("ybelkada/english_quotes_copy")
+            data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.multi_gpu_tests
+    def test_causal_lm_training_multi_gpu_8bit_randlora(self):
+        r"""
+        Same as test_causal_lm_training_multi_gpu but with RandLoRA
+        """
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                device_map=DEVICE_MAP_MAP[self.causal_lm_model_id],
+                quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+            )
+
+            assert set(model.hf_device_map.values()) == set(range(device_count))
+            assert {p.device.index for p in model.parameters()} == set(range(device_count))
+
+            model = prepare_model_for_kbit_training(model)
+
+            model.model_parallel = True
+            model.is_parallelizable = True
+
+            config = RandLoraConfig(
+                r=16,
+                target_modules=["q_proj", "v_proj"],
+                randlora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset("Abirate/english_quotes")
+            data = data.map(lambda samples: self.tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.multi_gpu_tests
+    def test_causal_lm_training_multi_gpu_4bit_randlora(self):
+        r"""
+        Same as test_causal_lm_training_multi_gpu_4bit but with RandLora
+        """
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                device_map=DEVICE_MAP_MAP[self.causal_lm_model_id],
+                quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+            )
+
+            assert set(model.hf_device_map.values()) == set(range(device_count))
+            assert {p.device.index for p in model.parameters()} == set(range(device_count))
+
+            model = prepare_model_for_kbit_training(model)
+
+            model.model_parallel = True
+            model.is_parallelizable = True
+
+            config = RandLoraConfig(
+                r=16,
+                target_modules=["q_proj", "v_proj"],
+                randlora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset("Abirate/english_quotes")
+            data = data.map(lambda samples: self.tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.single_gpu_tests
+    def test_causal_lm_training_8bit_road(self):
+        r"""
+        Same as test_causal_lm_training but with RoAd
+        """
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+                device_map="auto",
+            )
+
+            tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+            model = prepare_model_for_kbit_training(model)
+
+            config = RoadConfig(
+                variant="road_1",
+                target_modules=["q_proj", "v_proj"],
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset("ybelkada/english_quotes_copy")
+            data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=1e-3,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.single_gpu_tests
+    def test_causal_lm_training_4bit_road(self):
+        r"""
+        Same as test_causal_lm_training_4bit but with RoAd
+        """
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+                device_map="auto",
+            )
+
+            tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+            model = prepare_model_for_kbit_training(model)
+
+            config = RoadConfig(
+                variant="road_1",
+                target_modules=["q_proj", "v_proj"],
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset("ybelkada/english_quotes_copy")
+            data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=1e-3,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.multi_gpu_tests
+    def test_causal_lm_training_multi_gpu_8bit_road(self):
+        r"""
+        Same as test_causal_lm_training_multi_gpu but with RoAd
+        """
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                device_map=DEVICE_MAP_MAP[self.causal_lm_model_id],
+                quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+            )
+
+            assert set(model.hf_device_map.values()) == set(range(device_count))
+            assert {p.device.index for p in model.parameters()} == set(range(device_count))
+
+            model = prepare_model_for_kbit_training(model)
+
+            model.model_parallel = True
+            model.is_parallelizable = True
+
+            config = RoadConfig(
+                variant="road_1",
+                target_modules=["q_proj", "v_proj"],
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset("Abirate/english_quotes")
+            data = data.map(lambda samples: self.tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=1e-3,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.multi_gpu_tests
+    def test_causal_lm_training_multi_gpu_4bit_road(self):
+        r"""
+        Same as test_causal_lm_training_multi_gpu_4bit but with RoAd
+        """
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                device_map=DEVICE_MAP_MAP[self.causal_lm_model_id],
+                quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+            )
+
+            assert set(model.hf_device_map.values()) == set(range(device_count))
+            assert {p.device.index for p in model.parameters()} == set(range(device_count))
+
+            model = prepare_model_for_kbit_training(model)
+
+            model.model_parallel = True
+            model.is_parallelizable = True
+
+            config = RoadConfig(
+                variant="road_1",
+                target_modules=["q_proj", "v_proj"],
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset("Abirate/english_quotes")
+            data = data.map(lambda samples: self.tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=1e-3,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.single_gpu_tests
+    def test_causal_lm_training_lora_resize_embeddings_trainable_tokens(self):
+        r"""
+        Test LoRA with trainable tokens on a resized embedding matrix
+        """
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            bnb_config = BitsAndBytesConfig(
+                load_in_4bit=True,
+                bnb_4bit_quant_type="nf4",
+                bnb_4bit_compute_dtype=torch.float16,
+                bnb_4bit_quant_storage=torch.float16,
+                bnb_4bit_use_double_quant=True,
+            )
+
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                quantization_config=bnb_config,
+                device_map="auto",
+            )
+
+            # add 2 new tokens
+            tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+            new_tokens = ["<think>", "</think>"]
+            tokenizer.add_special_tokens({"additional_special_tokens": new_tokens})
+            trainable_token_indices = [tokenizer.vocab[token] for token in new_tokens]
+
+            cur_emb_size = model.model.decoder.embed_tokens.weight.shape[0]
+            model.resize_token_embeddings(max(tokenizer.vocab_size, cur_emb_size))
+            model = prepare_model_for_kbit_training(model)
+
+            config = LoraConfig(
+                r=16,
+                lora_alpha=32,
+                target_modules=["q_proj", "v_proj"],
+                lora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+                trainable_token_indices={"embed_tokens": trainable_token_indices},
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+
+            def tokenize(samples):
+                # add new tokens to samples
+                samples = [f"<think>{row}</think>" for row in samples["quote"]]
+                return tokenizer(samples)
+
+            data = data.map(tokenize, batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    # higher learning rate, as embeddings are a bit slow to update
+                    learning_rate=1e-3,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            # ensure that the new trainable tokens have been updated
+            embedding = model.base_model.model.model.decoder.embed_tokens
+            tol = 1e-4
+            assert not torch.allclose(
+                embedding.token_adapter.trainable_tokens_delta["default"],
+                embedding.original_module.weight[trainable_token_indices],
+                atol=tol,
+                rtol=tol,
+            )
+
+            # check size of the checkpoint, should be small since the embedding matrix does not need to be stored
+            stat = os.stat(os.path.join(tmp_dir, SAFETENSORS_WEIGHTS_NAME))
+            embed_params = model.base_model.model.model.decoder.embed_tokens.original_module.weight.numel()
+            # fp32 -> 4x
+            emb_file_size = 4 * embed_params
+            assert stat.st_size < emb_file_size
+
+            # sanity check: assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.single_gpu_tests
+    def test_causal_lm_training_hira(self):
+        r"""
+        Test the CausalLM training on a single GPU device. This test is a converted version of
+        https://github.com/huggingface/peft/blob/main/examples/int8_training/Finetune_opt_bnb_peft.ipynb where we train
+        `opt-6.7b` on `english_quotes` dataset in few steps. The test would simply fail if the adapters are not set
+        correctly.
+        """
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+                device_map="auto",
+            )
+
+            tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+            model = prepare_model_for_kbit_training(model)
+
+            config = HiraConfig(
+                r=16,
+                target_modules=["q_proj", "v_proj"],
+                hira_dropout=0.05,
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.single_gpu_tests
+    def test_causal_lm_training_4bit_hira(self):
+        r"""
+        Test the CausalLM training on a single GPU device. This test is a converted version of
+        https://github.com/huggingface/peft/blob/main/examples/int8_training/Finetune_opt_bnb_peft.ipynb where we train
+        `opt-6.7b` on `english_quotes` dataset in few steps using 4bit base model. The test would simply fail if the
+        adapters are not set correctly.
+        """
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+                device_map="auto",
+            )
+
+            tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+            model = prepare_model_for_kbit_training(model)
+
+            config = HiraConfig(
+                r=16,
+                target_modules=["q_proj", "v_proj"],
+                hira_dropout=0.05,
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+
+@require_non_cpu
+@require_gptqmodel
+@require_optimum
+class PeftGPTQGPUTests(unittest.TestCase):
+    r"""
+    GPT-QModel + PEFT tests
+    """
+
+    def setUp(self):
+        from transformers import GPTQConfig
+        from transformers.utils.quantization_config import AwqBackend
+
+        self.causal_lm_model_id = "marcsun13/opt-350m-gptq-4bit"
+        self.quantization_config = GPTQConfig(bits=4, backend=AwqBackend.AUTO_TRAINABLE)
+        self.tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+
+    def tearDown(self):
+        r"""
+        Efficient mechanism to free GPU memory after each test. Based on
+        https://github.com/huggingface/transformers/issues/21094
+        """
+        clear_device_cache(garbage_collection=True)
+
+    def _check_inference_finite(self, model, batch):
+        # try inference without Trainer class
+        training = model.training
+        model.eval()
+        output = model(**batch.to(model.device))
+        assert torch.isfinite(output.logits).all()
+        model.train(training)
+
+    @pytest.mark.single_gpu_tests
+    def test_causal_lm_training(self):
+        r"""
+        Test the CausalLM training on a single GPU device. The test would simply fail if the adapters are not set
+        correctly.
+        """
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                dtype=torch.float16,
+                device_map="auto",
+                quantization_config=self.quantization_config,
+            )
+
+            model = prepare_model_for_kbit_training(model)
+            config = LoraConfig(
+                r=16,
+                lora_alpha=32,
+                target_modules=["q_proj", "v_proj"],
+                lora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: self.tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.single_gpu_tests
+    def test_adalora_causalLM(self):
+        r"""
+        Tests the gptq training with adalora
+        """
+
+        model = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            dtype=torch.float16,
+            device_map="auto",
+            quantization_config=self.quantization_config,
+        )
+
+        tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+        model = prepare_model_for_kbit_training(model)
+
+        peft_config = AdaLoraConfig(
+            init_r=6,
+            target_r=4,
+            tinit=2,
+            tfinal=2,
+            total_step=6,
+            deltaT=5,
+            beta1=0.3,
+            beta2=0.3,
+            orth_reg_weight=0.2,
+            lora_alpha=32,
+            lora_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+
+        model = get_peft_model(model, peft_config)
+
+        data = load_dataset_english_quotes()
+        data = data.map(lambda samples: self.tokenizer(samples["quote"]), batched=True)
+        batch = tokenizer(data["train"][:3]["quote"], return_tensors="pt", padding=True)
+        self._check_inference_finite(model, batch)
+
+        class OptimizerStepCallback(TrainerCallback):
+            def on_optimizer_step(self, args, state, control, **kwargs):
+                model.update_and_allocate(state.global_step)
+
+        step_callback = OptimizerStepCallback()
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=6,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            trainer.add_callback(step_callback)
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.single_gpu_tests
+    def test_causal_lm_training_gptq_qalora(self):
+        """
+        Test QALoRA with GPTQ quantization. The test would simply fail if the adapters are not set correctly.
+        """
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                dtype=torch.float16,
+                device_map="auto",
+                quantization_config=self.quantization_config,
+            )
+
+            model = prepare_model_for_kbit_training(model)
+            config = LoraConfig(
+                r=16,
+                lora_alpha=32,
+                target_modules=["q_proj", "v_proj"],
+                lora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+                use_qalora=True,
+                qalora_group_size=32,
+            )
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: self.tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.multi_gpu_tests
+    @require_torch_multi_accelerator
+    def test_causal_lm_training_multi_gpu(self):
+        r"""
+        Test the CausalLM training on a multi-GPU device. The test would simply fail if the adapters are not set
+        correctly.
+        """
+        device_map = {
+            "model.decoder.embed_tokens": 0,
+            "lm_head": 0,
+            "model.decoder.embed_positions": 0,
+            "model.decoder.project_out": 0,
+            "model.decoder.project_in": 0,
+            "model.decoder.layers.0": 0,
+            "model.decoder.layers.1": 0,
+            "model.decoder.layers.2": 0,
+            "model.decoder.layers.3": 0,
+            "model.decoder.layers.4": 0,
+            "model.decoder.layers.5": 0,
+            "model.decoder.layers.6": 1,
+            "model.decoder.layers.7": 1,
+            "model.decoder.layers.8": 1,
+            "model.decoder.layers.9": 1,
+            "model.decoder.layers.10": 1,
+            "model.decoder.layers.11": 1,
+            "model.decoder.final_layer_norm": 1,
+        }
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                dtype=torch.float16,
+                device_map=device_map,
+                quantization_config=self.quantization_config,
+            )
+
+            assert set(model.hf_device_map.values()) == set(range(device_count))
+            assert {p.device.index for p in model.parameters()} == set(range(device_count))
+
+            model = prepare_model_for_kbit_training(model)
+
+            model.model_parallel = True
+            model.is_parallelizable = True
+
+            config = LoraConfig(
+                r=16,
+                lora_alpha=32,
+                target_modules=["q_proj", "v_proj"],
+                lora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: self.tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.single_gpu_tests
+    def test_non_default_adapter_name(self):
+        # See issue 1346
+        config = LoraConfig(
+            r=16,
+            target_modules=["q_proj", "v_proj"],
+            task_type="CAUSAL_LM",
+        )
+
+        # default adapter name
+        model = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            dtype=torch.float16,
+            device_map="auto",
+            quantization_config=self.quantization_config,
+        )
+        model = prepare_model_for_kbit_training(model)
+        model = get_peft_model(model, config)
+        n_trainable_default, n_total_default = model.get_nb_trainable_parameters()
+
+        # other adapter name
+        model = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            dtype=torch.float16,
+            device_map="auto",
+            quantization_config=self.quantization_config,
+        )
+        model = prepare_model_for_kbit_training(model)
+        model = get_peft_model(model, config, adapter_name="other")
+        n_trainable_other, n_total_other = model.get_nb_trainable_parameters()
+
+        assert n_trainable_other > 0
+        # sanity check
+        assert n_trainable_default == n_trainable_other
+        assert n_total_default == n_total_other
+
+
+@require_non_cpu
+class TestOffloadSave:
+    causal_lm_model_id = "gpt2"
+
+    @pytest.fixture(scope="class")
+    def tear_down(self):
+        r"""
+        Efficient mechanism to free GPU memory after each test. Based on
+        https://github.com/huggingface/transformers/issues/21094
+        """
+        yield
+        clear_device_cache(garbage_collection=True)
+
+    def test_offload_load(self, tmp_path):
+        r"""
+        Test the loading of a LoRA model with CPU- and disk-offloaded modules
+        """
+        torch.manual_seed(0)
+        model = AutoModelForCausalLM.from_pretrained(self.causal_lm_model_id)
+        tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+        memory_limits = {"cpu": "0.4GIB"}  # no "disk" for PeftModel.from_pretrained() compatibility
+
+        # offload around half of all transformer modules to the disk
+        device_map = infer_auto_device_map(model, max_memory=memory_limits)
+        assert "cpu" in device_map.values()
+        assert "disk" in device_map.values()
+
+        config = LoraConfig(task_type="CAUSAL_LM", init_lora_weights=False, target_modules=["c_attn"])
+
+        model = get_peft_model(model, config)
+        model.save_pretrained(tmp_path)
+        del model
+
+        model = AutoModelForCausalLM.from_pretrained(self.causal_lm_model_id, device_map="cpu")
+        lora_model = PeftModel.from_pretrained(model, tmp_path).eval()
+        input_tokens = tokenizer.encode("Four score and seven years ago", return_tensors="pt")
+        output = lora_model(input_tokens)[0]
+
+        # load the model with device_map
+        offloaded_model = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id, device_map=device_map, offload_folder=tmp_path
+        )
+        assert len({p.device for p in offloaded_model.parameters()}) == 2  # 'cpu' and 'meta'
+        offloaded_lora_model = PeftModel.from_pretrained(
+            offloaded_model, tmp_path, max_memory=memory_limits, offload_folder=tmp_path
+        ).eval()
+        offloaded_output = offloaded_lora_model(input_tokens)[0]
+        assert torch.allclose(output, offloaded_output, atol=1e-5)
+
+    @pytest.mark.single_gpu_tests
+    def test_offload_merge(self, tmp_path):
+        r"""
+        Test merging, unmerging, and unloading of a model with CPU- and disk- offloaded modules.
+        """
+        torch.manual_seed(0)
+        model = AutoModelForCausalLM.from_pretrained(self.causal_lm_model_id)
+        tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+        memory_limits = {0: "0.2GIB", "cpu": "0.2GIB"}  # no "disk" for PeftModel.from_pretrained() compatibility
+        # offloads around half of all transformer modules
+        device_map = infer_auto_device_map(model, max_memory=memory_limits)
+        assert 0 in device_map.values()
+        assert "cpu" in device_map.values()
+        assert "disk" in device_map.values()
+
+        config = LoraConfig(task_type="CAUSAL_LM", init_lora_weights=False, target_modules=["c_attn"])
+
+        model = get_peft_model(model, config)
+        model.save_pretrained(tmp_path)
+        del model
+        # load the model with device_map
+        model = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id, device_map=device_map, offload_folder=tmp_path
+        ).eval()
+        assert len({p.device for p in model.parameters()}) == 2
+
+        model = PeftModel.from_pretrained(model, tmp_path, max_memory=memory_limits, offload_folder=tmp_path)
+
+        input_tokens = tokenizer.encode("Four score and seven years ago", return_tensors="pt")
+        model.eval()
+
+        # test peft model adapter merge
+        pre_merge_olayer = model(input_tokens)[0]
+        model.merge_adapter()
+        post_merge_olayer = model(input_tokens)[0]
+        assert torch.allclose(post_merge_olayer, pre_merge_olayer)
+
+        # test peft model adapter unmerge
+        model.unmerge_adapter()
+        post_unmerge_olayer = model(input_tokens)[0]
+        assert torch.allclose(post_unmerge_olayer, pre_merge_olayer)
+
+        # test LoRA merge and unload
+        model = model.merge_and_unload()
+        post_unload_merge_olayer = model(input_tokens)[0]
+        assert torch.allclose(post_unload_merge_olayer, pre_merge_olayer)
+
+
+@pytest.mark.skipif(not (torch.cuda.is_available() or is_xpu_available()), reason="test requires a GPU or XPU")
+@pytest.mark.single_gpu_tests
+class TestPiSSA:
+    r"""
+    Tests for PiSSA to ensure that it reduces the quantization error compared to normal LoRA quantization.
+    """
+
+    # The error factor indicates by how much the quantization error should be decreased when using PiSSA compared to
+    # quantization without PiSSA. Thus 1.03 means that the error should be decreased by 3% at least. This is a very
+    # conservative value to prevent flakiness, in practice most gains are > 1.5
+    error_factor = 1.03
+
+    def quantize_model(self, model, num_bits=4, device="cuda"):
+        # Quantize the `weight.data` of the linear layer in the model to `num_bits` and store it with full precision.
+        quantizer = NFQuantizer(num_bits=num_bits, device=device, method="normal", block_size=64)
+        for name, module in model.named_modules():
+            if isinstance(module, (torch.nn.Linear, Conv1D)) and "lm_head" not in name:
+                quantized_weight, max_abs, shape = quantizer.quantize_block(module.weight.data.to(device))
+                module.weight.data = quantizer.dequantize_block(quantized_weight, max_abs, shape)
+        return model
+
+    def nuclear_norm(self, base_model, quantized_model):
+        # Calculate the nuclear norm (sum of singular values) of the error matrices between the `quantized_model` and the `base_model`.
+        error_list = []
+        for name, module in base_model.named_modules():
+            if isinstance(module, (torch.nn.Linear, Conv1D)) and "lm_head" not in name:
+                quant_module = quantized_model.get_submodule(name)
+                error_list.append(torch.linalg.svdvals(module.weight.data - quant_module.weight.data).sum())
+        return torch.Tensor(error_list).sum()
+
+    def get_errors(
+        self,
+        tmp_path,
+        bits=4,
+        device="cuda",
+        model_id="peft-internal-testing/tiny-random-BloomForCausalLM",
+    ):
+        # Comparing the quantized LoRA model to the base model, vs the PiSSA quantized model to the base model.
+        # We expect the PiSSA quantized model to have less error than the normal LoRA quantized model.
+
+        cls = AutoModelForSeq2SeqLM if "t5" in str(model_id) else AutoModelForCausalLM
+        base_model = cls.from_pretrained(model_id).eval().to(device)
+        task_type = TaskType.SEQ_2_SEQ_LM if base_model.config.is_encoder_decoder else TaskType.CAUSAL_LM
+
+        # logits from the normal quantized LoRA model
+        target_modules = "all-linear" if task_type != TaskType.SEQ_2_SEQ_LM else ["o", "k", "wi", "q", "v"]
+        lora_config = LoraConfig(task_type=task_type, target_modules=target_modules)
+
+        qlora_model = self.quantize_model(cls.from_pretrained(model_id).eval().to(device), bits, device)
+        qlora_model = get_peft_model(
+            qlora_model,
+            lora_config,
+        )
+
+        qlora_model = qlora_model.merge_and_unload()
+        qlora_error = self.nuclear_norm(base_model, qlora_model)
+        del qlora_model
+        clear_device_cache(garbage_collection=True)
+
+        # logits from quantized LoRA model using PiSSA
+        lora_config = LoraConfig(
+            task_type=task_type,
+            init_lora_weights="pissa",
+            target_modules=target_modules,
+        )
+        pissa_model = cls.from_pretrained(model_id).eval().to(device)
+        pissa_model = get_peft_model(pissa_model, lora_config)
+
+        # save LoRA weights, they should be initialized such that they minimize the quantization error
+        pissa_model.base_model.peft_config["default"].init_lora_weights = True
+        pissa_model.save_pretrained(tmp_path / "pissa_model")
+
+        pissa_model = pissa_model.unload()
+        pissa_model.save_pretrained(tmp_path / "residual_model")
+
+        del pissa_model
+        clear_device_cache(garbage_collection=True)
+
+        # now load quantized model and apply PiSSA-initialized weights on top
+        qpissa_model = self.quantize_model(
+            cls.from_pretrained(tmp_path / "residual_model").eval().to(device), bits, device
+        )
+        qpissa_model = PeftModel.from_pretrained(qpissa_model, tmp_path / "pissa_model")
+        qpissa_model = qpissa_model.merge_and_unload()
+        qpissa_error = self.nuclear_norm(base_model, qpissa_model)
+        del qpissa_model
+        clear_device_cache(garbage_collection=True)
+
+        assert qlora_error > 0.0
+        assert qpissa_error > 0.0
+
+        # next, check that PiSSA quantization errors are smaller than LoRA errors by a certain margin
+        assert qpissa_error < (qlora_error / self.error_factor)
+
+    @pytest.mark.parametrize("device", [torch_device, "cpu"])
+    def test_bloomz_pissa_4bit(self, device, tmp_path):
+        # In this test, we compare the logits of the base model, the quantized LoRA model, and the quantized model
+        # using PiSSA. When quantizing, we expect a certain level of error. However, we expect the PiSSA quantized
+        # model to have less error than the normal LoRA quantized model. Note that when using normal LoRA, the
+        # quantization error is simply the error from quantization without LoRA, as LoRA is a no-op before training.
+        # We still apply LoRA for the test for consistency.
+
+        self.get_errors(bits=4, device=device, tmp_path=tmp_path)
+
+    @pytest.mark.parametrize("device", [torch_device, "cpu"])
+    def test_bloomz_pissa_8bit(self, device, tmp_path):
+        # Same test as test_bloomz_pissa_4bit but with 8 bits.
+        self.get_errors(bits=8, device=device, tmp_path=tmp_path)
+
+    @pytest.mark.parametrize("device", [torch_device, "cpu"])
+    def test_t5_pissa_4bit(self, device, tmp_path):
+        self.get_errors(bits=4, device=device, model_id="t5-small", tmp_path=tmp_path)
+
+    @pytest.mark.parametrize("device", [torch_device, "cpu"])
+    def test_t5_pissa_8bit(self, device, tmp_path):
+        self.get_errors(bits=8, device=device, model_id="t5-small", tmp_path=tmp_path)
+
+    @pytest.mark.parametrize("device", [torch_device, "cpu"])
+    def test_gpt2_pissa_4bit(self, device, tmp_path):
+        # see 2104
+        self.get_errors(bits=4, device=device, model_id="gpt2", tmp_path=tmp_path)
+
+    @pytest.mark.parametrize("device", [torch_device, "cpu"])
+    def test_gpt2_pissa_8bit(self, device, tmp_path):
+        # see 2104
+        self.get_errors(bits=8, device=device, model_id="gpt2", tmp_path=tmp_path)
+
+    @require_bitsandbytes
+    def test_lora_pissa_conversion_same_output_after_loading_with_quantization(self, tmp_path):
+        # A copy of the test `test_lora_pissa_conversion_same_output_after_loading` in peft/tests/test_initialization.py,
+        # that would fail if bitsandbytes quantization is used because Quant(W_res) + AB !=Quant(W) + \Delta(AB).
+        import bitsandbytes as bnb
+
+        torch.manual_seed(0)
+        data = torch.rand(10, 1000).to(torch_device)
+
+        class MyModule(torch.nn.Module):
+            def __init__(self):
+                super().__init__()
+                # choose a large weight so that averages are close to expected values
+                self.linear = torch.nn.Linear(1000, 1000)
+                self.embed = torch.nn.Embedding(1000, 1000)
+                self.conv2d = torch.nn.Conv2d(100, 100, 3)
+
+            def forward(self, x):
+                x_int = (100 * x).int()
+                x_4d = x.flatten().reshape(1, 100, 10, 10)
+                return self.linear(x), self.embed(x_int), self.conv2d(x_4d)
+
+        model = MyModule().to(torch_device)
+        output_base = model(data)[0]
+
+        config = LoraConfig(init_lora_weights="pissa", target_modules=["linear"], r=8)
+        peft_model = get_peft_model(deepcopy(model), config)
+        # save the initial model
+        peft_model.peft_config["default"].init_lora_weights = True
+        peft_model.save_pretrained(tmp_path / "init-model")
+        peft_model = peft_model.unload()
+        torch.save(peft_model.state_dict(), tmp_path / "residual-model")
+        del peft_model
+
+        # create 4bit base model
+        base_model = deepcopy(model)
+        base_model.load_state_dict(torch.load(tmp_path / "residual-model"))
+        # sanity check: the base model weights were indeed changed
+        tol = 1e-06
+        assert not torch.allclose(model.linear.weight, base_model.linear.weight, atol=tol, rtol=tol)
+        # quantize the linear layer
+        linear4bit = bnb.nn.Linear4bit(base_model.linear.in_features, base_model.linear.out_features)
+        linear4bit.load_state_dict(base_model.linear.state_dict())
+        linear4bit.to(0)
+        base_model.linear = linear4bit
+        peft_model = PeftModel.from_pretrained(deepcopy(base_model), tmp_path / "init-model")
+        output_quantized_pissa = peft_model(data)[0]
+        # sanity check
+        tol = 1e-06
+        assert not torch.allclose(output_base, output_quantized_pissa, atol=tol, rtol=tol)
+
+        # modify the weights, or else the adapter performs an identity transformation
+        peft_model.base_model.linear.lora_B["default"].weight.data *= 2.0
+        output_finetuned_pissa = peft_model(data)[0]
+        # sanity check
+        tol = 1e-06
+        assert not torch.allclose(output_quantized_pissa, output_finetuned_pissa, atol=tol, rtol=tol)
+
+        # save the model normally
+        peft_model.save_pretrained(tmp_path / "pissa-model")
+        model_loaded = PeftModel.from_pretrained(deepcopy(base_model), tmp_path / "pissa-model")
+        output_loaded = model_loaded(data)[0]
+
+        assert torch.allclose(output_finetuned_pissa, output_loaded, atol=tol, rtol=tol)
+        # sanity check: ranks should still be 8 as initially
+        assert model_loaded.peft_config["default"].r == 8
+        assert model_loaded.base_model.model.linear.lora_A["default"].weight.shape[0] == 8
+
+        # save the model with conversion
+        peft_model.save_pretrained(
+            tmp_path / "pissa-model-converted", path_initial_model_for_weight_conversion=tmp_path / "init-model"
+        )
+        model_converted = PeftModel.from_pretrained(deepcopy(model), tmp_path / "pissa-model-converted")
+        output_converted = model_converted(data)[0]
+
+        # rank should be double of what it was initially
+        assert model_converted.peft_config["default"].r == 16
+        assert model_converted.base_model.model.linear.lora_A["default"].weight.shape[0] == 16
+        # base model weights should be the same as the initial model
+        assert torch.allclose(
+            model.linear.weight, model_converted.base_model.model.linear.base_layer.weight, atol=tol, rtol=tol
+        )
+        # This check is expected to fail when using bnb
+        assert not torch.allclose(output_finetuned_pissa, output_converted, atol=tol, rtol=tol)
+
+
+@pytest.mark.skipif(not (torch.cuda.is_available() or is_xpu_available()), reason="test requires a GPU or XPU")
+@pytest.mark.single_gpu_tests
+class TestOLoRA:
+    r"""
+    Tests for OLoRA to ensure that it reduces the quantization error compared to normal LoRA quantization.
+    """
+
+    # The error factor indicates by how much the quantization error should be decreased when using OLoRA compared to
+    # quantization without OLoRA. Thus 1.03 means that the error should be decreased by 3% at least. This is a very
+    # conservative value to prevent flakiness, in practice most gains are > 1.5
+    error_factor = 1.2
+
+    def quantize_model(self, model, num_bits=4, device="cuda"):
+        # Quantize the `weight.data` of the linear layer in the model to `num_bits` and store it with full precision.
+        quantizer = NFQuantizer(num_bits=num_bits, device=device, method="normal", block_size=64)
+        for name, module in model.named_modules():
+            if isinstance(module, torch.nn.Linear) and "lm_head" not in name:
+                quantized_weight, max_abs, shape = quantizer.quantize_block(module.weight.data.to(device))
+                module.weight.data = quantizer.dequantize_block(quantized_weight, max_abs, shape)
+        return model
+
+    def nuclear_norm(self, base_model, quantized_model):
+        # Calculate the nuclear norm (sum of singular values) of the error matrices between the `quantized_model` and the `base_model`.
+        error_list = []
+        for name, module in base_model.named_modules():
+            if isinstance(module, torch.nn.Linear) and "lm_head" not in name:
+                quant_module = quantized_model.get_submodule(name)
+                error_list.append(torch.linalg.svdvals(module.weight.data - quant_module.weight.data).sum())
+        return torch.Tensor(error_list).sum()
+
+    def get_errors(
+        self,
+        tmp_path,
+        bits=4,
+        device="cuda",
+        model_id="peft-internal-testing/tiny-random-BloomForCausalLM",
+    ):
+        # Comparing the quantized LoRA model to the base model, vs the OLoRA quantized model to the base model.
+        # We expect the OLoRA quantized model to have less error than the normal LoRA quantized model.
+
+        cls = AutoModelForSeq2SeqLM if "t5" in str(model_id) else AutoModelForCausalLM
+        base_model = cls.from_pretrained(model_id).eval().to(device)
+        task_type = TaskType.SEQ_2_SEQ_LM if base_model.config.is_encoder_decoder else TaskType.CAUSAL_LM
+
+        # logits from the normal quantized LoRA model
+        target_modules = "all-linear" if task_type != TaskType.SEQ_2_SEQ_LM else ["o", "k", "wi", "q", "v"]
+        lora_config = LoraConfig(task_type=task_type, target_modules=target_modules)
+
+        qlora_model = self.quantize_model(cls.from_pretrained(model_id).eval().to(device), bits, device)
+        qlora_model = get_peft_model(
+            qlora_model,
+            lora_config,
+        )
+        qlora_model = qlora_model.merge_and_unload()
+        qlora_error = self.nuclear_norm(base_model, qlora_model)
+        del qlora_model
+        clear_device_cache(garbage_collection=True)
+
+        # logits from quantized LoRA model using OLoRA
+        lora_config = LoraConfig(
+            task_type=task_type,
+            init_lora_weights="olora",
+            target_modules=target_modules,
+        )
+        olora_model = cls.from_pretrained(model_id).eval().to(device)
+        olora_model = get_peft_model(olora_model, lora_config)
+
+        # save LoRA weights, they should be initialized such that they minimize the quantization error
+        olora_model.base_model.peft_config["default"].init_lora_weights = True
+        olora_model.save_pretrained(tmp_path / "olora_model")
+
+        olora_model = olora_model.unload()
+        olora_model.save_pretrained(tmp_path / "residual_model")
+
+        del olora_model
+        clear_device_cache(garbage_collection=True)
+
+        # now load quantized model and apply OLoRA-initialized weights on top
+        qolora_model = self.quantize_model(
+            cls.from_pretrained(tmp_path / "residual_model").eval().to(device), bits, device
+        )
+        qolora_model = PeftModel.from_pretrained(qolora_model, tmp_path / "olora_model")
+        qolora_model = qolora_model.merge_and_unload()
+        qolora_error = self.nuclear_norm(base_model, qolora_model)
+        del qolora_model
+        clear_device_cache(garbage_collection=True)
+
+        assert qlora_error > 0.0
+        assert qolora_error > 0.0
+
+        # next, check that OLoRA quantization errors are smaller than LoRA errors by a certain margin
+        assert qolora_error < (qlora_error / self.error_factor)
+
+    @pytest.mark.parametrize("device", [torch_device, "cpu"])
+    def test_bloomz_olora_4bit(self, device, tmp_path):
+        # In this test, we compare the logits of the base model, the quantized LoRA model, and the quantized model
+        # using OLoRA. When quantizing, we expect a certain level of error. However, we expect the OLoRA quantized
+        # model to have less error than the normal LoRA quantized model. Note that when using normal LoRA, the
+        # quantization error is simply the error from quantization without LoRA, as LoRA is a no-op before training.
+        # We still apply LoRA for the test for consistency.
+
+        self.get_errors(bits=4, device=device, tmp_path=tmp_path)
+
+    @pytest.mark.parametrize("device", [torch_device, "cpu"])
+    def test_bloomz_olora_8bit(self, device, tmp_path):
+        # Same test as test_bloomz_olora_4bit but with 8 bits.
+        self.get_errors(bits=8, device=device, tmp_path=tmp_path)
+
+    @pytest.mark.parametrize("bits", [4, 8])
+    def test_olora_with_quantized_model(self, bits):
+        import bitsandbytes as bnb
+
+        # issue 1999
+        model_id = "peft-internal-testing/tiny-random-OPTForCausalLM"
+        if bits == 4:
+            bnb_config = BitsAndBytesConfig(
+                load_in_4bit=True,
+                bnb_4bit_quant_type="nf4",
+                bnb_4bit_compute_dtype=torch.float16,
+                bnb_4bit_quant_storage=torch.float16,
+                bnb_4bit_use_double_quant=True,
+            )
+        elif bits == 8:
+            bnb_config = BitsAndBytesConfig(load_in_8bit=True)
+        else:
+            raise ValueError("bits must be 4 or 8")
+
+        model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=bnb_config)
+        model = prepare_model_for_kbit_training(model)
+        config = LoraConfig(init_lora_weights="olora")
+        model = get_peft_model(model, config)
+
+        # check that the correct type is used for the weights
+        base_layer = model.base_model.model.model.decoder.layers[0].self_attn.v_proj.base_layer.weight
+        if bits == 4:
+            assert isinstance(base_layer, bnb.nn.modules.Params4bit)
+        else:
+            assert isinstance(base_layer, bnb.nn.modules.Int8Params)
+
+        inputs = torch.arange(10).unsqueeze(0).to(model.device)
+        logits = model(inputs).logits  # does not raise
+        assert torch.isfinite(logits).all()
+
+
+@pytest.mark.skipif(
+    not (torch.cuda.is_available() or is_xpu_available()), reason="test requires a hardware accelerator"
+)
+@pytest.mark.single_gpu_tests
+@require_bitsandbytes
+class TestLoftQ:
+    r"""
+    Tests for LoftQ to ensure that it reduces the quantization error compared to normal LoRA quantization.
+    """
+
+    OPT_MODEL_ID = "facebook/opt-125m"
+
+    def get_error_factor(self, device, n_bits):
+        # The error factor indicates by how much the quantization error should be decreased when using LoftQ compared to
+        # quantization without LoftQ. Thus 1.03 means that the error should be decreased by 3% at least. This is a very
+        # conservative value to prevent flakiness, in practice most gains are > 1.5
+        return 1.03
+
+    def get_input(self, model_id, device):
+        tokenizer = AutoTokenizer.from_pretrained(model_id)
+        inputs = tokenizer(
+            [
+                "All I want is",
+                "All I need",
+                "Forever yours truly: ",
+                "Translate French to German: Tu l'as lu?",
+                "Translate German to French: Last du es?",
+            ],
+            padding=True,
+            return_tensors="pt",
+        )
+        inputs = inputs.to(device)
+        return inputs
+
+    def get_base_model(self, model_id, device, **kwargs):
+        cls = AutoModelForSeq2SeqLM if "t5" in str(model_id) else AutoModelForCausalLM
+        with hub_online_once(model_id):
+            model = cls.from_pretrained(model_id, device_map=device, **kwargs).eval()
+        return model
+
+    def get_logits(self, model, inputs):
+        if model.config.is_encoder_decoder:
+            input_ids = inputs["input_ids"]
+            input_ids = model._shift_right(input_ids)
+            return model(input_ids=input_ids, decoder_input_ids=input_ids).logits
+        return model(**inputs).logits
+
+    def error_mask(self, error, attention_mask=None):
+        # Make sure to ignore padding values in the error term
+        if attention_mask is not None:
+            # attention_mask shape: [batch_size, seq_len]
+            # error shape: [batch_size, seq_len, vocab_size]
+            # apply the mask (zeros out the squared error for padding tokens)
+            mask = attention_mask.unsqueeze(-1).expand_as(error)
+            masked_error = error * mask
+            return masked_error.sum() / mask.sum()
+        return error.mean()
+
+    def mse(self, a, b, attention_mask=None):
+        error = torch.pow(a - b, 2)
+        return self.error_mask(error, attention_mask=attention_mask)
+
+    def mae(self, a, b, attention_mask=None):
+        error = torch.abs(a - b)
+        return self.error_mask(error, attention_mask=attention_mask)
+
+    def get_errors(
+        self,
+        tmp_path,
+        bits=4,
+        loftq_iter=1,
+        device="cuda",
+        model_id=None,
+        use_dora=False,
+    ):
+        # Helper function that returns the quantization errors (MAE and MSE) when comparing the quantized LoRA model
+        # to the base model, vs the LoftQ quantized model to the base model. We expect the LoftQ quantized model to
+        # have less error than the normal LoRA quantized model. Since we compare logits, the observed error is
+        # already somewhat dampened because of the softmax.
+        torch.manual_seed(0)
+        model = self.get_base_model(model_id, device)
+        task_type = TaskType.SEQ_2_SEQ_LM if model.config.is_encoder_decoder else TaskType.CAUSAL_LM
+        inputs = self.get_input(model_id, device)
+        # the base logits are the reference, we try to match those as closely as possible
+        logits_base = self.get_logits(model, inputs)
+        # clean up
+        del model
+        clear_device_cache(garbage_collection=True)
+
+        # logits from the normal quantized LoRA model
+        #
+        # t5 has `_keep_in_fp32=["wo"]` which is why we target all linear except for "wo" - if we'd target all
+        # layers including wo we'd introduce quantization error that's not present by applying the mitigation
+        target_modules = "all-linear" if task_type != TaskType.SEQ_2_SEQ_LM else ["o", "k", "wi", "q", "v"]
+        lora_config = LoraConfig(task_type=task_type, use_dora=use_dora, target_modules=target_modules)
+        kwargs = {}
+        if bits == 4:
+            kwargs["quantization_config"] = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type="nf4")
+        elif bits == 8:
+            # threshold > 0 will introduce errors uncorrectable by static methods like LoftQ
+            kwargs["quantization_config"] = BitsAndBytesConfig(load_in_8bit=True, llm_int8_threshold=0.0)
+        else:
+            raise ValueError("bits must be 4 or 8")
+
+        quantized_base_model = self.get_base_model(model_id, device, **kwargs, dtype=torch.float32)
+
+        if target_modules != "all-linear":
+            # make sure that the manual targeting catches all layers and doesn't target too many
+            layer_name = "Linear8bitLt" if bits == 8 else "Linear4bit"
+            quantized_suffixes = {
+                n.split(".")[-1] for n, p in quantized_base_model.named_modules() if p.__class__.__name__ == layer_name
+            }
+            assert set(target_modules) == quantized_suffixes
+
+        quantized_model = get_peft_model(
+            quantized_base_model,
+            lora_config,
+        )
+
+        torch.manual_seed(0)
+        logits_quantized = self.get_logits(quantized_model, inputs)
+        del quantized_model
+        del quantized_base_model
+        clear_device_cache(garbage_collection=True)
+
+        # logits from quantized LoRA model using LoftQ
+        loftq_config = LoftQConfig(loftq_bits=bits, loftq_iter=loftq_iter)
+        lora_config = LoraConfig(
+            r=64,
+            lora_alpha=32,
+            task_type=task_type,
+            init_lora_weights="loftq",
+            loftq_config=loftq_config,
+            use_dora=use_dora,
+            target_modules=target_modules,
+        )
+        model = self.get_base_model(model_id, device)
+        if device != "cpu":
+            model = model.to(device)
+
+        loftq_model = get_peft_model(model, lora_config)
+        if device != "cpu":
+            loftq_model = loftq_model.to(device)
+
+        # save LoRA weights, they should be initialized such that they minimize the quantization error
+        loftq_model.base_model.peft_config["default"].init_lora_weights = True
+        loftq_model.save_pretrained(tmp_path / "loftq_model")
+
+        loftq_model = loftq_model.unload()
+        loftq_model.save_pretrained(tmp_path / "base_model")
+
+        del loftq_model
+        clear_device_cache(garbage_collection=True)
+
+        # now load quantized model and apply LoftQ-initialized weights on top
+        base_model = self.get_base_model(tmp_path / "base_model", device=device, **kwargs, dtype=torch.float32)
+
+        loftq_model = PeftModel.from_pretrained(base_model, tmp_path / "loftq_model", is_trainable=True)
+
+        # TODO sanity check: model is quantized
+
+        torch.manual_seed(0)
+        logits_loftq = self.get_logits(loftq_model, inputs)
+        del loftq_model
+        clear_device_cache(garbage_collection=True)
+
+        mae_quantized = self.mae(logits_base, logits_quantized, attention_mask=inputs["attention_mask"])
+        mse_quantized = self.mse(logits_base, logits_quantized, attention_mask=inputs["attention_mask"])
+        mae_loftq = self.mae(logits_base, logits_loftq, attention_mask=inputs["attention_mask"])
+        mse_loftq = self.mse(logits_base, logits_loftq, attention_mask=inputs["attention_mask"])
+
+        return mae_quantized, mse_quantized, mae_loftq, mse_loftq
+
+    @pytest.mark.parametrize("device", [torch_device, "cpu"])
+    @pytest.mark.parametrize("n_bits", [4, 8], ids=["4bit", "8bit"])
+    @pytest.mark.parametrize("n_iter", [1, 3], ids=["1iter", "3iter"])
+    def test_opt_loftq(self, device, n_bits, n_iter, tmp_path):
+        # In this test, we compare the logits of the base model, the quantized LoRA model, and the quantized model
+        # using LoftQ. When quantizing, we expect a certain level of error. However, we expect the LoftQ quantized
+        # model to have less error than the normal LoRA quantized model. Note that when using normal LoRA, the
+        # quantization error is simply the error from quantization without LoRA, as LoRA is a no-op before training.
+        # We still apply LoRA for the test for consistency.
+        #
+        # With 5 iterations we should expect the error to be even smaller with more
+        # iterations, but in practice the difference is not that large, at least not for this small base model.
+        mae_quantized, mse_quantized, mae_loftq, mse_loftq = self.get_errors(
+            bits=n_bits,
+            loftq_iter=n_iter,
+            device=device,
+            model_id=self.OPT_MODEL_ID,
+            tmp_path=tmp_path,
+        )
+
+        # first, sanity check that all errors are > 0.0
+        assert mae_quantized > 0.0
+        assert mse_quantized > 0.0
+        assert mae_loftq > 0.0
+        assert mse_loftq > 0.0
+
+        if n_bits == 4:
+            # next, check that LoftQ quantization errors are smaller than LoRA errors by a certain margin
+            error_factor = self.get_error_factor(device, n_bits)
+            assert mse_loftq < (mse_quantized / error_factor)
+            assert mae_loftq < (mae_quantized / error_factor)
+        elif n_bits == 8:
+            # for int8 compensation we're happy to achieve parity but without additional measures we will
+            # not be better since int8 also quantizes the layer input which introduces error loftq can't
+            # compensate
+            assert torch.allclose(mse_loftq, mse_quantized, atol=0.06)
+            assert torch.allclose(mae_loftq, mae_quantized, atol=0.06)
+
+    @pytest.mark.parametrize("device", [torch_device, "cpu"])
+    @pytest.mark.parametrize("n_bits", [4, 8], ids=["4bit", "8bit"])
+    @pytest.mark.parametrize("n_iter", [1, 3], ids=["1iter", "3iter"])
+    def test_t5_loftq(self, device, n_bits, n_iter, tmp_path):
+        if n_bits == 8 and n_iter > 1:
+            pytest.xfail("n_iter > 1 produces strictly worse results for a yet unknown reason")
+
+        mae_quantized, mse_quantized, mae_loftq, mse_loftq = self.get_errors(
+            bits=n_bits, loftq_iter=n_iter, device=device, model_id="t5-small", tmp_path=tmp_path
+        )
+        # first, sanity check that all errors are > 0.0
+        assert mae_quantized > 0.0
+        assert mse_quantized > 0.0
+        assert mae_loftq > 0.0
+        assert mse_loftq > 0.0
+
+        if n_bits == 4:
+            # next, check that LoftQ quantization errors are smaller than LoRA errors by a certain margin
+            error_factor = self.get_error_factor(device, n_bits)
+            assert mse_loftq < (mse_quantized / error_factor)
+            assert mae_loftq < (mae_quantized / error_factor)
+        elif n_bits == 8:
+            # for int8 compensation we're happy to achieve parity but without additional measures we will
+            # not be better since int8 also quantizes the layer input which introduces error loftq can't
+            # compensate
+            assert torch.allclose(mse_loftq, mse_quantized, atol=0.06)
+            assert torch.allclose(mae_loftq, mae_quantized, atol=0.06)
+
+    @pytest.mark.xfail  # failing for now, but having DoRA pass is only a nice-to-have, not a must, so we're good
+    @pytest.mark.parametrize("device", [torch_device, "cpu"])
+    def test_opt_loftq_4bit_dora(self, device, tmp_path):
+        # same as test_opt_loftq_4bit but with DoRA
+        mae_quantized, mse_quantized, mae_loftq, mse_loftq = self.get_errors(
+            bits=4,
+            device=device,
+            use_dora=True,
+            model_id=self.OPT_MODEL_ID,
+            tmp_path=tmp_path,
+        )
+        # first, sanity check that all errors are > 0.0
+        assert mae_quantized > 0.0
+        assert mse_quantized > 0.0
+        assert mae_loftq > 0.0
+        assert mse_loftq > 0.0
+
+        # next, check that LoftQ quantization errors are smaller than LoRA errors by a certain margin
+        factor = 3
+        assert mae_loftq < (mae_quantized / factor)
+        assert mse_loftq < (mse_quantized / factor)
+
+    @pytest.mark.parametrize("device", [torch_device, "cpu"])
+    def test_opt_loftq_8bit_dora(self, device, tmp_path):
+        # same as test_opt_loftq_8bit but with DoRA
+        mae_quantized, mse_quantized, mae_loftq, mse_loftq = self.get_errors(
+            bits=8,
+            device=device,
+            use_dora=True,
+            model_id=self.OPT_MODEL_ID,
+            tmp_path=tmp_path,
+        )
+
+        # first, sanity check that all errors are > 0.0
+        assert mae_quantized > 0.0
+        assert mse_quantized > 0.0
+        assert mae_loftq > 0.0
+        assert mse_loftq > 0.0
+
+        # again, parity is the best we can get here due to int8 activation quant.
+        assert torch.allclose(mse_loftq, mse_quantized, atol=0.03)
+        assert torch.allclose(mae_loftq, mae_quantized, atol=0.03)
+
+    def test_replace_lora_weights_with_loftq_using_callable(self):
+        """
+        Test replacing LoRa weights with LoFTQ using a callable.
+
+        Using the replace_lora_weights_loftq function, we replace the LoRa weights of a bnb-quantized model with LoRA
+        weights initialized by LoftQ on the fly. We use a callable to decide whether to replace the weights or not.
+        This callable checks, for each weight, if replacing it would actually result in logits that are closer to the
+        original logits of the non-quantized model.
+
+        """
+        torch.manual_seed(0)
+        model_id = "bigscience/bloomz-560m"
+        device = torch_device
+        tokenizer = AutoTokenizer.from_pretrained(model_id)
+        inputs = tokenizer("The dog was", padding=True, return_tensors="pt").to(device)
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(model_id).to(device)
+            logits_base = model(**inputs).logits
+            model.save_pretrained(tmp_dir)
+
+            # load in 4bit
+            bnb_config = BitsAndBytesConfig(
+                load_in_4bit=True,
+                bnb_4bit_use_double_quant=True,
+            )
+            model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=bnb_config)
+            model = get_peft_model(model, LoraConfig(task_type="CAUSAL_LM", target_modules="all-linear"))
+            logits_lora = model(**inputs).logits
+
+            current_mse = float("inf")
+            logs = []
+
+            def my_callback(model, module_name):
+                """Callable to replace weights with LoFTQ if the mse is lower than the current best one."""
+                nonlocal current_mse
+
+                logits = model(**inputs).logits
+                mse = ((logits_base - logits) ** 2).mean()
+                if mse < current_mse:
+                    current_mse = mse
+                    logs.append(True)
+                    return True
+                logs.append(False)
+                return False
+
+            replace_lora_weights_loftq(model, model_path=tmp_dir, callback=my_callback)
+            logits_loftq = model(**inputs).logits
+
+            mae_lora = (logits_base - logits_lora).abs().mean()
+            mae_loftq = (logits_base - logits_loftq).abs().mean()
+            mse_lora = ((logits_base - logits_lora) ** 2).mean()
+            mse_loftq = ((logits_base - logits_loftq) ** 2).mean()
+
+            # check that the error was reduced by a certain margin
+            assert mae_loftq * 1.5 < mae_lora
+            assert mse_loftq * 2.5 < mse_lora
+
+            # check that the callback has returned some True and some False values
+            assert any(logs)
+            assert not all(logs)
+
+        del model
+        clear_device_cache(garbage_collection=True)
+
+    def test_replace_lora_weights_with_local_model(self):
+        # see issue 2020
+        torch.manual_seed(0)
+        model_id = "peft-internal-testing/tiny-random-OPTForCausalLM"
+        device = torch_device
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            # save base model locally
+            model = AutoModelForCausalLM.from_pretrained(model_id).to(device)
+            model.save_pretrained(tmp_dir)
+            del model
+
+            # load in 4bit
+            bnb_config = BitsAndBytesConfig(
+                load_in_4bit=True,
+                bnb_4bit_use_double_quant=True,
+            )
+
+            # load the base model from local directory
+            model = AutoModelForCausalLM.from_pretrained(tmp_dir, quantization_config=bnb_config)
+            model = get_peft_model(model, LoraConfig())
+
+            # passing the local path directly works
+            replace_lora_weights_loftq(model, model_path=tmp_dir)
+            del model
+
+            # load the base model from local directory
+            model = AutoModelForCausalLM.from_pretrained(tmp_dir, quantization_config=bnb_config)
+            model = get_peft_model(model, LoraConfig())
+
+            # when not passing, ensure that users are made aware of the `model_path` argument
+            with pytest.raises(ValueError, match="model_path"):
+                replace_lora_weights_loftq(model)
+
+        del model
+        clear_device_cache(garbage_collection=True)
+
+    def test_config_no_loftq_init(self):
+        with pytest.warns(
+            UserWarning,
+            match="`loftq_config` specified but will be ignored when `init_lora_weights` is not 'loftq'.",
+        ):
+            LoraConfig(loftq_config=LoftQConfig())
+
+    def test_config_no_loftq_config(self):
+        with pytest.raises(ValueError, match="`loftq_config` must be specified when `init_lora_weights` is 'loftq'."):
+            LoraConfig(init_lora_weights="loftq")
+
+
+@require_bitsandbytes
+@require_non_cpu
+class MultiprocessTester(unittest.TestCase):
+    def test_notebook_launcher(self):
+        script_path = os.path.join("scripts", "launch_notebook_mp.py")
+        cmd = ["python", script_path]
+        with patch_environment(omp_num_threads=1):
+            run_command(cmd, env=os.environ.copy())
+
+
+@require_non_cpu
+class MixedPrecisionTests(unittest.TestCase):
+    def setUp(self):
+        self.causal_lm_model_id = "peft-internal-testing/opt-125m"
+        self.tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+        self.config = LoraConfig(
+            r=16,
+            lora_alpha=32,
+            task_type="CAUSAL_LM",
+        )
+
+        data = load_dataset_english_quotes()
+        self.data = data.map(lambda samples: self.tokenizer(samples["quote"]), batched=True)
+
+    def tearDown(self):
+        r"""
+        Efficient mechanism to free GPU memory after each test. Based on
+        https://github.com/huggingface/transformers/issues/21094
+        """
+        clear_device_cache(garbage_collection=True)
+        gc.collect()
+
+    @pytest.mark.single_gpu_tests
+    def test_model_using_float16_with_amp_raises(self):
+        # This test shows the issue with using a model in fp16 and then trying to use it with mixed precision training,
+        # which should not use fp16.
+        model = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            dtype=torch.float16,
+        )
+        model = get_peft_model(model, self.config, autocast_adapter_dtype=False)
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            trainer = Trainer(
+                model=model,
+                train_dataset=self.data["train"],
+                args=TrainingArguments(
+                    fp16=True,  # <= this is required for the error to be raised
+                    output_dir=tmp_dir,
+                    max_steps=3,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            with pytest.raises(ValueError, match="Attempting to unscale FP16 gradients."):
+                trainer.train()
+
+    @pytest.mark.single_gpu_tests
+    def test_model_using_float16_autocast_dtype(self):
+        # Here we use autocast_adapter_dtype=True (the default) to automatically promote the adapter weights to float32.
+        # No exception should be raised.
+        model = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            dtype=torch.float16,
+        )
+        model = get_peft_model(model, self.config, autocast_adapter_dtype=True)
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            trainer = Trainer(
+                model=model,
+                train_dataset=self.data["train"],
+                args=TrainingArguments(
+                    fp16=True,  # <= this is required for the error to be raised
+                    output_dir=tmp_dir,
+                    max_steps=3,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            trainer.train()  # does not raise
+
+    @pytest.mark.single_gpu_tests
+    def test_model_using_float16_explicit_cast(self):
+        # Same test as above but containing the fix to make it work
+        model = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            dtype=torch.float16,
+        )
+        model = get_peft_model(model, self.config, autocast_adapter_dtype=False)
+
+        # here we manually promote the adapter weights to float32
+        for param in model.parameters():
+            if param.requires_grad:
+                param.data = param.data.float()
+
+        dtype_counts_before = Counter(p.dtype for p in model.parameters())
+        model = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            dtype=torch.float16,
+        )
+
+        model = get_peft_model(model, self.config, autocast_adapter_dtype=True)
+        dtype_counts_after = Counter(p.dtype for p in model.parameters())
+        assert dtype_counts_before == dtype_counts_after
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            trainer = Trainer(
+                model=model,
+                train_dataset=self.data["train"],
+                args=TrainingArguments(
+                    fp16=True,  # <= this is required for the error to be raised
+                    max_steps=3,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            trainer.train()  # does not raise
+
+    @pytest.mark.single_gpu_tests
+    def test_load_model_using_float16_with_amp_raises(self):
+        # Same as previous tests, but loading the adapter with PeftModel.from_pretrained instead
+        model = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            dtype=torch.float16,
+        )
+        model = get_peft_model(model, self.config, autocast_adapter_dtype=False)
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model.save_pretrained(tmp_dir)
+            model = AutoModelForCausalLM.from_pretrained(self.causal_lm_model_id, dtype=torch.float16)
+            model = PeftModel.from_pretrained(model, tmp_dir, autocast_adapter_dtype=False, is_trainable=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=self.data["train"],
+                args=TrainingArguments(
+                    fp16=True,  # <= this is required for the error to be raised
+                    output_dir=tmp_dir,
+                    max_steps=3,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            with pytest.raises(ValueError, match="Attempting to unscale FP16 gradients."):
+                trainer.train()
+
+    @pytest.mark.single_gpu_tests
+    def test_load_model_using_float16_autocast_dtype(self):
+        # Same as previous tests, but loading the adapter with PeftModel.from_pretrained instead
+        model = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            dtype=torch.float16,
+        )
+        # Below, we purposefully set autocast_adapter_dtype=False so that the saved adapter uses float16. We still want
+        # the loaded adapter to use float32 when we load it with autocast_adapter_dtype=True.
+        model = get_peft_model(model, self.config, autocast_adapter_dtype=False)
+        # sanity check: this should have float16 adapter weights:
+        assert (
+            model.base_model.model.model.decoder.layers[0].self_attn.v_proj.lora_A["default"].weight.dtype
+            == torch.float16
+        )
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model.save_pretrained(tmp_dir)
+            model = AutoModelForCausalLM.from_pretrained(self.causal_lm_model_id, dtype=torch.float16)
+            model = PeftModel.from_pretrained(model, tmp_dir, autocast_adapter_dtype=True, is_trainable=True)
+            # sanity check: this should NOT have float16 adapter weights:
+            assert (
+                model.base_model.model.model.decoder.layers[0].self_attn.v_proj.lora_A["default"].weight.dtype
+                == torch.float32
+            )
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=self.data["train"],
+                args=TrainingArguments(
+                    fp16=True,  # <= this is required for the error to be raised
+                    output_dir=tmp_dir,
+                    max_steps=3,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            trainer.train()  # does not raise
+
+    @pytest.mark.single_gpu_tests
+    def test_load_adapter_using_float16_autocast_dtype(self):
+        # Here we test the load_adapter method with autocast_adapter_dtype. We show that autocasting is prevented when
+        # calling load_model(..., autocast_adapter_dtype=False) and that it is enabled when calling
+        # load_model(..., autocast_adapter_dtype=True) (the default).
+        model = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            dtype=torch.float16,
+        )
+        # Below, we purposefully set autocast_adapter_dtype=False so that the saved adapter uses float16. We still want
+        # the loaded adapter to use float32 when we load it with autocast_adapter_dtype=True.
+        model = get_peft_model(model, self.config, autocast_adapter_dtype=False)
+        # sanity check: this should have float16 adapter weights:
+        assert (
+            model.base_model.model.model.decoder.layers[0].self_attn.v_proj.lora_A["default"].weight.dtype
+            == torch.float16
+        )
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model.save_pretrained(tmp_dir)
+            model = AutoModelForCausalLM.from_pretrained(self.causal_lm_model_id, dtype=torch.float16)
+            # the default adapter is now in float16
+            model = get_peft_model(model, self.config, autocast_adapter_dtype=False)
+            # sanity check: this should NOT have float16 adapter weights:
+            assert (
+                model.base_model.model.model.decoder.layers[0].self_attn.v_proj.lora_A["default"].weight.dtype
+                == torch.float16
+            )
+
+            # now load the first adapter in float16 using the adapter name "loaded16"
+            model.load_adapter(tmp_dir, "loaded16", autocast_adapter_dtype=False)
+            assert (
+                model.base_model.model.model.decoder.layers[0].self_attn.v_proj.lora_A["loaded16"].weight.dtype
+                == torch.float16
+            )
+
+            # now load the first adapter in float32 using the adapter name "loaded32"
+            model.load_adapter(tmp_dir, "loaded32", autocast_adapter_dtype=True)
+            assert (
+                model.base_model.model.model.decoder.layers[0].self_attn.v_proj.lora_A["loaded32"].weight.dtype
+                == torch.float32
+            )
+
+            # training with the default adapter, which is in float16, should raise
+            model.set_adapter("default")
+            trainer = Trainer(
+                model=model,
+                train_dataset=self.data["train"],
+                args=TrainingArguments(
+                    fp16=True,  # <= this is required for the error to be raised
+                    output_dir=tmp_dir,
+                    max_steps=3,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            with pytest.raises(ValueError, match="Attempting to unscale FP16 gradients."):
+                trainer.train()
+
+            # training the model with the adapter "loaded16", which is in float16, should also raise
+            model.set_adapter("loaded16")
+            trainer = Trainer(
+                model=model,
+                train_dataset=self.data["train"],
+                args=TrainingArguments(
+                    fp16=True,  # <= this is required for the error to be raised
+                    output_dir=tmp_dir,
+                    max_steps=3,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            with pytest.raises(ValueError, match="Attempting to unscale FP16 gradients."):
+                trainer.train()
+
+            # training the model with the adapter "loaded32", which is in float32, should not raise
+            model.set_adapter("loaded32")
+            trainer = Trainer(
+                model=model,
+                train_dataset=self.data["train"],
+                args=TrainingArguments(
+                    fp16=True,  # <= this is required for the error to be raised
+                    output_dir=tmp_dir,
+                    max_steps=3,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            trainer.train()  # does not raise
+
+
+@require_non_xpu
+@require_torch_gpu
+@require_aqlm
+@pytest.mark.skipif(
+    not version.parse(importlib.metadata.version("transformers")) >= version.parse("4.38.0"),
+    reason="test requires `transformers>=4.38.0`",
+)
+class PeftAqlmGPUTests(unittest.TestCase):
+    r"""
+    AQLM + peft tests
+    """
+
+    def setUp(self):
+        self.causal_lm_model_id = "BlackSamorez/TinyLlama-1_1B-Chat-v1_0-AQLM-2Bit-1x16-hf"
+        self.tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+
+    def tearDown(self):
+        r"""
+        Efficient mechanism to free GPU memory after each test. Based on
+        https://github.com/huggingface/transformers/issues/21094
+        """
+        clear_device_cache(garbage_collection=True)
+
+    def _check_inference_finite(self, model, batch):
+        # try inference without Trainer class
+        training = model.training
+        model.eval()
+        output = model(**batch.to(model.device))
+        assert torch.isfinite(output.logits).all()
+        model.train(training)
+
+    @pytest.mark.single_gpu_tests
+    def test_causal_lm_training_aqlm(self):
+        r"""
+        Test the CausalLM training on a single GPU device. The test would simply fail if the adapters are not set
+        correctly.
+        """
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                device_map="cuda",
+                dtype="auto",
+            )
+
+            model = prepare_model_for_kbit_training(model)
+            config = LoraConfig(
+                r=16,
+                lora_alpha=32,
+                target_modules=["q_proj", "v_proj"],
+                lora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: self.tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                    fp16=True,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+
+@require_non_xpu
+@require_torch_gpu
+@require_hqq
+@pytest.mark.skipif(
+    not version.parse(importlib.metadata.version("transformers")) >= version.parse("4.36.1"),
+    reason="test requires `transformers>=4.36.1`",
+)
+class PeftHqqGPUTests(unittest.TestCase):
+    r"""
+    HQQ + peft tests
+    """
+
+    def setUp(self):
+        self.causal_lm_model_id = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"
+        self.tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+
+    def tearDown(self):
+        r"""
+        Efficient mechanism to free GPU memory after each test. Based on
+        https://github.com/huggingface/transformers/issues/21094
+        """
+        clear_device_cache(garbage_collection=True)
+
+    @pytest.mark.xfail(
+        reason="HQQ is not yet supported by Transformers v5",
+        condition=is_transformers_ge_v5,
+        strict=True,
+        raises=NotImplementedError,
+    )
+    @pytest.mark.single_gpu_tests
+    @parameterized.expand([False, True])
+    def test_causal_lm_training_hqq(self, use_dora):
+        r"""
+        Test the CausalLM training on a single GPU device. The test would simply fail if the adapters are not set
+        correctly.
+        """
+
+        from transformers import HqqConfig
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            device = "cuda"
+            compute_dtype = torch.float16
+
+            quant_config = HqqConfig(nbits=4, group_size=64)
+
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                device_map=device,
+                dtype=compute_dtype,
+                quantization_config=quant_config,
+            )
+
+            model = prepare_model_for_kbit_training(model)
+            config = LoraConfig(
+                r=16,
+                lora_alpha=32,
+                target_modules=["q_proj", "v_proj"],
+                lora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+                use_dora=use_dora,
+            )
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: self.tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                    fp16=True,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.xfail(
+        reason="HQQ is not yet supported by Transformers v5",
+        condition=is_transformers_ge_v5,
+        strict=True,
+        raises=NotImplementedError,
+    )
+    @pytest.mark.single_gpu_tests
+    def test_hqq_lora_model_outputs(self):
+        # check that the outputs generated by HQQ with LoRA are similar to those without HQQ
+        from transformers import HqqConfig
+
+        device = "cuda"
+        compute_dtype = torch.float16
+        min_correlation = 0.96
+
+        # first load the model without HQQ
+        model = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            device_map=device,
+            dtype=compute_dtype,
+        )
+        config = LoraConfig(
+            target_modules=["q_proj", "v_proj"],
+            task_type="CAUSAL_LM",
+            init_lora_weights=False,
+        )
+        torch.manual_seed(0)
+        model = get_peft_model(model, config).eval()
+        inputs = self.tokenizer("The meaning of unit tests is", return_tensors="pt").to(model.device)
+
+        with torch.inference_mode():
+            output_normal = model(**inputs).logits
+        assert torch.isfinite(output_normal).all()
+
+        del model
+        clear_device_cache(garbage_collection=True)
+
+        # now load with HQQ
+        quant_config = HqqConfig(nbits=4, group_size=64)
+        model = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            device_map=device,
+            dtype=compute_dtype,
+            quantization_config=quant_config,
+        )
+        torch.manual_seed(0)
+        model = get_peft_model(model, config).eval()
+        with torch.inference_mode():
+            output_hqq = model(**inputs).logits
+
+        # check that outputs of HQQ are highly correlated; there are outliers, so don't check for equality
+        cc_matrix = torch.corrcoef(torch.stack((output_normal.float().flatten(), output_hqq.float().flatten())))
+        assert cc_matrix.min() > min_correlation
+
+        # check that outputs are the same after merging
+        cc_matrix = torch.corrcoef(torch.stack((output_normal.float().flatten(), output_hqq.float().flatten())))
+        assert cc_matrix.min() > min_correlation
+
+        # check outputs are the same after unmerging
+        model.unmerge_adapter()
+        with torch.inference_mode():
+            output_unmerged = model(**inputs).logits
+        cc_matrix = torch.corrcoef(torch.stack((output_normal.float().flatten(), output_unmerged.float().flatten())))
+        assert cc_matrix.min() > min_correlation
+
+        # check that the results are the same after saving and loading
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model.save_pretrained(tmp_dir)
+            del model
+            clear_device_cache(garbage_collection=True)
+
+            quant_config = HqqConfig(nbits=4, group_size=64)
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                device_map=device,
+                dtype=compute_dtype,
+                quantization_config=quant_config,
+            )
+            model = PeftModel.from_pretrained(model, tmp_dir)
+            with torch.inference_mode():
+                output_loaded = model(**inputs).logits
+
+            # for loading, we expect high precision, so check for equality and not just correlation
+            atol, rtol = 1e-6, 1e-6
+            assert torch.allclose(output_hqq, output_loaded, atol=atol, rtol=rtol)
+
+        # check that outputs are the same after merge_and_unload
+        model = model.merge_and_unload()
+        with torch.inference_mode():
+            output_merged_unloaded = model(**inputs).logits
+        cc_matrix = torch.corrcoef(
+            torch.stack((output_normal.float().flatten(), output_merged_unloaded.float().flatten()))
+        )
+        assert cc_matrix.min() > min_correlation
+
+
+@require_non_cpu
+@require_gptqmodel
+class PeftAwqGPUTests(unittest.TestCase):
+    r"""
+    Awq + peft tests
+    """
+
+    def setUp(self):
+        from transformers import AwqConfig
+        from transformers.utils.quantization_config import AwqBackend
+
+        self.causal_lm_model_id = "peft-internal-testing/opt-125m-awq"
+        self.quantization_config = AwqConfig(backend=AwqBackend.AUTO_TRAINABLE)
+        self.tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+
+    def tearDown(self):
+        r"""
+        Efficient mechanism to free accelerator memory after each test. Based on
+        https://github.com/huggingface/transformers/issues/21094
+        """
+        clear_device_cache(garbage_collection=True)
+
+    def _check_inference_finite(self, model, batch):
+        # try inference without Trainer class
+        training = model.training
+        model.eval()
+        output = model(**batch.to(model.device))
+        assert torch.isfinite(output.logits).all()
+        model.train(training)
+
+    @pytest.mark.single_gpu_tests
+    def test_causal_lm_training_awq(self):
+        r"""
+        Test the CausalLM training on a single accelerator. The test would simply fail if the adapters are not set
+        correctly.
+        """
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                device_map="auto",
+                quantization_config=self.quantization_config,
+            )
+
+            model = prepare_model_for_kbit_training(model)
+            config = LoraConfig(
+                r=16,
+                lora_alpha=32,
+                target_modules=["q_proj", "v_proj"],
+                lora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: self.tokenizer(samples["quote"]), batched=True)
+
+            # TODO: deal correctly with this case in transformers
+            model._is_quantized_training_enabled = True
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                    fp16=True,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.multi_gpu_tests
+    @require_torch_multi_accelerator
+    def test_causal_lm_training_multi_accelerator(self):
+        r"""
+        Test the CausalLM training on a multi-accelerator device. The test would simply fail if the adapters are not
+        set correctly.
+        """
+        device_map = {
+            "model.decoder.embed_tokens": 0,
+            "lm_head": 0,
+            "model.decoder.embed_positions": 0,
+            "model.decoder.project_out": 0,
+            "model.decoder.project_in": 0,
+            "model.decoder.layers.0": 0,
+            "model.decoder.layers.1": 0,
+            "model.decoder.layers.2": 0,
+            "model.decoder.layers.3": 0,
+            "model.decoder.layers.4": 0,
+            "model.decoder.layers.5": 0,
+            "model.decoder.layers.6": 1,
+            "model.decoder.layers.7": 1,
+            "model.decoder.layers.8": 1,
+            "model.decoder.layers.9": 1,
+            "model.decoder.layers.10": 1,
+            "model.decoder.layers.11": 1,
+            "model.decoder.final_layer_norm": 1,
+        }
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                device_map=device_map,
+                quantization_config=self.quantization_config,
+            )
+
+            assert set(model.hf_device_map.values()) == {0, 1}
+            assert {p.device.index for p in model.parameters()} == {0, 1}
+
+            model = prepare_model_for_kbit_training(model)
+
+            model.model_parallel = True
+            model.is_parallelizable = True
+
+            config = LoraConfig(
+                r=16,
+                lora_alpha=32,
+                target_modules=["q_proj", "v_proj"],
+                lora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: self.tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+
+@require_non_xpu
+@require_torch_gpu
+@require_eetq
+class PeftEetqGPUTests(unittest.TestCase):
+    r"""
+    EETQ + peft tests
+    """
+
+    def setUp(self):
+        self.causal_lm_model_id = "peft-internal-testing/opt-125m"
+        self.tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+
+    def tearDown(self):
+        r"""
+        Efficient mechanism to free GPU memory after each test. Based on
+        https://github.com/huggingface/transformers/issues/21094
+        """
+        clear_device_cache(garbage_collection=True)
+
+    def _check_inference_finite(self, model, batch):
+        # try inference without Trainer class
+        training = model.training
+        model.eval()
+        output = model(**batch.to(model.device))
+        assert torch.isfinite(output.logits).all()
+        model.train(training)
+
+    @pytest.mark.single_gpu_tests
+    def test_causal_lm_training_eetq(self):
+        r"""
+        Test the CausalLM training on a single GPU device. The test would simply fail if the adapters are not set
+        correctly.
+        """
+        from transformers import EetqConfig
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            quantization_config = EetqConfig("int8")
+
+            try:
+                model = AutoModelForCausalLM.from_pretrained(
+                    self.causal_lm_model_id, device_map="auto", quantization_config=quantization_config
+                )
+            except FileNotFoundError:
+                pytest.skip("There is no kernel for EETQ on this architecture, skipping this test.")
+
+            model = prepare_model_for_kbit_training(model)
+
+            config = LoraConfig(
+                r=16,
+                lora_alpha=32,
+                target_modules=["q_proj", "v_proj"],
+                lora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: self.tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.multi_gpu_tests
+    @require_torch_multi_gpu
+    def test_causal_lm_training_multi_gpu_eetq(self):
+        r"""
+        Test the CausalLM training on a multi-GPU device. The test would simply fail if the adapters are not set
+        correctly.
+        """
+        from transformers import EetqConfig
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            quantization_config = EetqConfig("int8")
+
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                device_map=DEVICE_MAP_MAP[self.causal_lm_model_id],
+                quantization_config=quantization_config,
+            )
+
+            assert set(model.hf_device_map.values()) == set(range(device_count))
+            assert {p.device.index for p in model.parameters()} == set(range(device_count))
+
+            model = prepare_model_for_kbit_training(model)
+
+            model.model_parallel = True
+            model.is_parallelizable = True
+
+            config = LoraConfig(
+                r=16,
+                lora_alpha=32,
+                target_modules=["q_proj", "v_proj"],
+                lora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: self.tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(self.tokenizer, mlm=False),
+            )
+            model.config.use_cache = False
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+
+@require_non_cpu
+@require_torchao
+class TestPeftTorchao:
+    causal_lm_model_id = "peft-internal-testing/opt-125m"
+    supported_quant_types = [
+        "int8_weight_only",
+        "int8_dynamic_activation_int8_weight",
+        # int4_weight_only raises an error:
+        # RuntimeError: We encountered some issues during automatic conversion of the weights
+        # "int4_weight_only",
+    ]
+
+    @pytest.fixture(scope="class")
+    def tokenizer(self):
+        return AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+
+    @pytest.fixture(scope="class", autouse=True)
+    def setup_teardown(self):
+        # Efficient mechanism to free GPU memory after each test. Based on
+        # https://github.com/huggingface/transformers/issues/21094
+        yield
+        clear_device_cache(garbage_collection=True)
+
+    @staticmethod
+    def get_quant_type(quant_type: str):
+        from torchao.quantization import (
+            Int4WeightOnlyConfig,
+            Int8DynamicActivationInt8WeightConfig,
+            Int8WeightOnlyConfig,
+        )
+
+        return {
+            "int4_weight_only": Int4WeightOnlyConfig(),
+            "int8_weight_only": Int8WeightOnlyConfig(),
+            "int8_dynamic_activation_int8_weight": Int8DynamicActivationInt8WeightConfig(),
+        }[quant_type]
+
+    @pytest.mark.parametrize("quant_type", supported_quant_types)
+    @pytest.mark.single_gpu_tests
+    def test_causal_lm_training_single_gpu_torchao(self, quant_type, tokenizer):
+        from transformers import TorchAoConfig
+
+        device = 0
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            quantization_config = TorchAoConfig(quant_type=self.get_quant_type(quant_type))
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id, device_map=device, quantization_config=quantization_config
+            )
+            model = prepare_model_for_kbit_training(model)
+
+            config = LoraConfig(
+                r=16,
+                lora_alpha=32,
+                target_modules=["q_proj", "v_proj"],
+                lora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            trainer.model.config.use_cache = False
+            trainer.train()
+
+            model.save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.single_gpu_tests
+    def test_causal_lm_training_single_gpu_torchao_dora_int8_weight_only(self, tokenizer):
+        from transformers import TorchAoConfig
+
+        device = 0
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            quantization_config = TorchAoConfig(quant_type=self.get_quant_type("int8_weight_only"))
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id, device_map=device, quantization_config=quantization_config
+            )
+            model = prepare_model_for_kbit_training(model)
+
+            config = LoraConfig(
+                r=16,
+                lora_alpha=32,
+                target_modules=["q_proj", "v_proj"],
+                lora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+                use_dora=True,
+            )
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            trainer.model.config.use_cache = False
+            trainer.train()
+
+            model.save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.single_gpu_tests
+    def test_causal_lm_training_single_gpu_torchao_dora_int8_dynamic_activation_int8_weight_raises(self):
+        from transformers import TorchAoConfig
+
+        device = 0
+
+        quantization_config = TorchAoConfig(quant_type=self.get_quant_type("int8_dynamic_activation_int8_weight"))
+        model = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id, device_map=device, quantization_config=quantization_config
+        )
+        model = prepare_model_for_kbit_training(model)
+
+        config = LoraConfig(
+            r=16,
+            lora_alpha=32,
+            target_modules=["q_proj", "v_proj"],
+            lora_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM",
+            use_dora=True,
+        )
+        with pytest.raises(NotImplementedError):
+            get_peft_model(model, config)
+
+    @pytest.mark.single_gpu_tests
+    @pytest.mark.xfail(
+        reason="int4_weight_only still has issues",
+        raises=(RuntimeError, ValueError),
+    )
+    def test_causal_lm_training_single_gpu_torchao_int4_raises(self):
+        # TODO: Once proper torchao support for int4 is added, remove this test and add int4 to supported_quant_types
+        from transformers import TorchAoConfig
+
+        device = 0
+
+        quantization_config = TorchAoConfig(quant_type=self.get_quant_type("int4_weight_only"))
+        model = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id, device_map=device, quantization_config=quantization_config
+        )
+        model = prepare_model_for_kbit_training(model)
+
+        config = LoraConfig(
+            r=16,
+            lora_alpha=32,
+            target_modules=["q_proj", "v_proj"],
+            lora_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+
+        model = get_peft_model(model, config)
+        inputs = torch.arange(10).view(1, -1).to(device)
+        # this raises:
+        # > RuntimeError: cutlass cannot initialize
+        # tested in multiple matchines
+        model(inputs)
+
+    @pytest.mark.parametrize("quant_type", supported_quant_types)
+    @pytest.mark.multi_gpu_tests
+    @require_torch_multi_accelerator
+    def test_causal_lm_training_multi_accelerator_torchao(self, quant_type, tokenizer):
+        from transformers import TorchAoConfig
+
+        device_map = {
+            "model.decoder.embed_tokens": 0,
+            "lm_head": 0,
+            "model.decoder.embed_positions": 0,
+            "model.decoder.project_out": 0,
+            "model.decoder.project_in": 0,
+            "model.decoder.layers.0": 0,
+            "model.decoder.layers.1": 0,
+            "model.decoder.layers.2": 0,
+            "model.decoder.layers.3": 0,
+            "model.decoder.layers.4": 0,
+            "model.decoder.layers.5": 0,
+            "model.decoder.layers.6": 1,
+            "model.decoder.layers.7": 1,
+            "model.decoder.layers.8": 1,
+            "model.decoder.layers.9": 1,
+            "model.decoder.layers.10": 1,
+            "model.decoder.layers.11": 1,
+            "model.decoder.final_layer_norm": 1,
+        }
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            quantization_config = TorchAoConfig(quant_type=self.get_quant_type(quant_type))
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                device_map=device_map,
+                quantization_config=quantization_config,
+                dtype=torch.bfloat16,
+            )
+
+            assert set(model.hf_device_map.values()) == set(range(device_count))
+            assert {p.device.index for p in model.parameters()} == set(range(device_count))
+
+            model = prepare_model_for_kbit_training(model)
+            model.model_parallel = True
+            model.is_parallelizable = True
+
+            config = LoraConfig(
+                r=16,
+                lora_alpha=32,
+                target_modules=["q_proj", "v_proj"],
+                lora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM",
+            )
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            trainer.model.config.use_cache = False
+            trainer.train()
+
+            model.save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+    @pytest.mark.multi_gpu_tests
+    @require_torch_multi_accelerator
+    def test_causal_lm_training_multi_accelerator_torchao_int4_raises(self):
+        # int4_weight_only raises an error:
+        # RuntimeError: derivative for aten::_weight_int4pack_mm is not implemented
+        # TODO: Once proper torchao support for int4 is added, remove this test and add int4 to supported_quant_types
+        from transformers import TorchAoConfig
+
+        device_map = {
+            "model.decoder.embed_tokens": 0,
+            "lm_head": 0,
+            "model.decoder.embed_positions": 0,
+            "model.decoder.project_out": 0,
+            "model.decoder.project_in": 0,
+            "model.decoder.layers.0": 0,
+            "model.decoder.layers.1": 0,
+            "model.decoder.layers.2": 0,
+            "model.decoder.layers.3": 0,
+            "model.decoder.layers.4": 0,
+            "model.decoder.layers.5": 0,
+            "model.decoder.layers.6": 1,
+            "model.decoder.layers.7": 1,
+            "model.decoder.layers.8": 1,
+            "model.decoder.layers.9": 1,
+            "model.decoder.layers.10": 1,
+            "model.decoder.layers.11": 1,
+            "model.decoder.final_layer_norm": 1,
+        }
+        quantization_config = TorchAoConfig(self.get_quant_type(quant_type="int4_weight_only"))
+        model = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id,
+            device_map=device_map,
+            quantization_config=quantization_config,
+            dtype=torch.bfloat16,
+        )
+
+        assert set(model.hf_device_map.values()) == set(range(device_count))
+        assert {p.device.index for p in model.parameters()} == set(range(device_count))
+
+        model = prepare_model_for_kbit_training(model)
+        model.model_parallel = True
+        model.is_parallelizable = True
+
+        config = LoraConfig(
+            r=16,
+            lora_alpha=32,
+            target_modules=["q_proj", "v_proj"],
+            lora_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+
+        msg = re.escape("TorchaoLoraLinear only supports int8 weights for now")
+        with pytest.raises(ValueError, match=msg):
+            get_peft_model(model, config)
+
+    @pytest.mark.single_gpu_tests
+    def test_torchao_merge_layers_int8_weight_only(self):
+        from torchao.utils import TorchAOBaseTensor
+        from transformers import TorchAoConfig
+
+        quant_type = "int8_weight_only"
+        torch.manual_seed(0)
+        device = 0
+        dummy_input = torch.arange(10).view(-1, 1).to(device)
+
+        quantization_config = TorchAoConfig(self.get_quant_type(quant_type=quant_type))
+        model = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id, device_map=device, quantization_config=quantization_config
+        ).eval()
+        logits_base = model(dummy_input)[0]
+
+        config = LoraConfig(
+            r=16,
+            lora_alpha=32,
+            target_modules=["q_proj", "v_proj"],
+            lora_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM",
+            init_lora_weights=False,
+        )
+        model = get_peft_model(model, config)
+
+        model.eval()
+        logits = model(dummy_input)[0]
+
+        # sanity check: outputs changed
+        # precision is quite low, so we need to use high atol and rtol
+        atol, rtol = 1e-1, 1e-1
+        assert not torch.allclose(logits, logits_base, atol=atol, rtol=rtol)
+
+        model.merge_adapter()
+        logits_merged = model(dummy_input)[0]
+        for name, module in model.named_modules():
+            if "base_layer" in name:
+                assert isinstance(module.weight, TorchAOBaseTensor)
+
+        model.unmerge_adapter()
+        logits_unmerged = model(dummy_input)[0]
+        for name, module in model.named_modules():
+            if "base_layer" in name:
+                assert isinstance(module.weight, TorchAOBaseTensor)
+
+        model = model.merge_and_unload()
+        logits_merged_unloaded = model(dummy_input)[0]
+
+        assert torch.allclose(logits, logits_merged, atol=atol, rtol=rtol)
+        assert torch.allclose(logits, logits_unmerged, atol=atol, rtol=rtol)
+        assert torch.allclose(logits, logits_merged_unloaded, atol=atol, rtol=rtol)
+
+    @pytest.mark.single_gpu_tests
+    def test_torchao_merge_layers_int8_dynamic_activation_int8_weight_raises(self):
+        # int8_dynamic_activation_int8_weight does not support dequantize, thus merging does not work
+        from transformers import TorchAoConfig
+
+        quant_type = "int8_dynamic_activation_int8_weight"
+        torch.manual_seed(0)
+        device = 0
+
+        quantization_config = TorchAoConfig(quant_type=self.get_quant_type(quant_type))
+        model = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id, device_map=device, quantization_config=quantization_config
+        ).eval()
+
+        config = LoraConfig(
+            r=16,
+            lora_alpha=32,
+            target_modules=["q_proj", "v_proj"],
+            lora_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM",
+            init_lora_weights=False,
+        )
+        model = get_peft_model(model, config)
+
+        msg = re.escape(
+            "Weights of type LinearActivationQuantizedTensor do not support dequantization (yet), which is needed to "
+            "support merging."
+        )
+        with pytest.raises(NotImplementedError, match=msg):
+            model.merge_adapter()
+
+    @pytest.mark.single_gpu_tests
+    def test_torchao_lora_warns_when_base_not_quantized_via_transformers(self):
+        # Manually quantizing the base model with torchao.quantize_ leaves PEFT without
+        # `get_apply_tensor_subclass`, so the LoRA torchao linear emits a warning at init
+        # to flag that merge()/unmerge() will not work. When the base model is loaded via
+        # `TorchAoConfig`, PEFT recovers the requantization subclass and no warning fires.
+        from torchao.quantization import Int8WeightOnlyConfig, quantize_
+        from transformers import TorchAoConfig
+
+        device = 0
+        lora_config = LoraConfig(
+            r=8,
+            lora_alpha=16,
+            target_modules=["q_proj", "v_proj"],
+            lora_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+
+        # Path 1: manual quantize_ -> warning expected, and merge() must raise.
+        model = AutoModelForCausalLM.from_pretrained(self.causal_lm_model_id, device_map=device)
+        quantize_(model, Int8WeightOnlyConfig())
+        with pytest.warns(UserWarning, match="get_apply_tensor_subclass"):
+            peft_model = get_peft_model(model, lora_config)
+        merge_msg = re.escape(
+            "was instantiated without `get_apply_tensor_subclass`, which is "
+            "required to re-quantize the base layer after merging."
+        )
+        with pytest.raises(ValueError, match=merge_msg):
+            peft_model.merge_adapter()
+        del peft_model, model
+        clear_device_cache(garbage_collection=True)
+
+        # Path 2: TorchAoConfig -> no such warning.
+        quantization_config = TorchAoConfig(quant_type=Int8WeightOnlyConfig())
+        model = AutoModelForCausalLM.from_pretrained(
+            self.causal_lm_model_id, device_map=device, quantization_config=quantization_config
+        )
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always")
+            get_peft_model(model, lora_config)
+        assert not any("get_apply_tensor_subclass" in str(w.message) for w in caught)
+
+
+PRECISIONS = [(torch.float32), (torch.float16), (torch.bfloat16)]
+
+LORA_PARAMS = {
+    "r": 8,
+    "lora_alpha": 16,
+    "lora_dropout": 0.05,
+}
+
+
+class SimpleModel(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+
+        self.embedding_layer = torch.nn.Embedding(1000, 768)
+        self.layer_norm = torch.nn.LayerNorm(768)
+        self.linear_transform = torch.nn.Linear(768, 256)
+
+    def forward(self, input_ids):
+        embedded_output = self.embedding_layer(input_ids)
+        norm_output = self.layer_norm(embedded_output)
+        linear_output = self.linear_transform(norm_output)
+
+        return linear_output
+
+
+class SimpleConv2DModel(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+
+        self.embedding_layer = torch.nn.Embedding(1000, 768)
+        self.layer_norm = torch.nn.LayerNorm(768)
+        self.conv2d_transform = torch.nn.Conv2d(1, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+
+    def forward(self, input_ids):
+        # Additional layers for your custom model
+        embedded_output = self.embedding_layer(input_ids)
+        norm_output = self.layer_norm(embedded_output)
+
+        # Reshape for Conv2d input (add batch size dimension)
+        norm_output = norm_output.unsqueeze(1)
+        conv_output = self.conv2d_transform(norm_output)
+
+        # Remove batch size dimension
+        conv_output = conv_output.squeeze(1)
+
+        return conv_output
+
+
+@require_non_cpu
+class TestAutoCast(unittest.TestCase):
+    device = infer_device()
+
+    # This test makes sure, that Lora dtypes are consistent with the types
+    # inferred by torch.autocast under tested PRECISIONS
+    @parameterized.expand(PRECISIONS)
+    def test_simple_model(self, *args, **kwargs):
+        self._test_model(SimpleModel(), *args, **kwargs)
+
+    @parameterized.expand(PRECISIONS)
+    def test_simple_lora_linear_model(self, *args, **kwargs):
+        simple_model = SimpleModel()
+        config = LoraConfig(
+            **LORA_PARAMS,
+            target_modules=["linear_transform"],
+        )
+
+        lora_model = get_peft_model(simple_model, config)
+
+        self._test_model(lora_model, *args, **kwargs)
+
+    @parameterized.expand(PRECISIONS)
+    def test_simple_lora_embedding_model(self, *args, **kwargs):
+        simple_model = SimpleModel()
+        config = LoraConfig(
+            **LORA_PARAMS,
+            target_modules=["embedding_layer"],
+        )
+        lora_model = get_peft_model(simple_model, config)
+
+        self._test_model(lora_model, *args, **kwargs)
+
+    @parameterized.expand(PRECISIONS)
+    def test_simple_conv2d_model(self, *args, **kwargs):
+        self._test_model(SimpleConv2DModel(), *args, **kwargs)
+
+    @parameterized.expand(PRECISIONS)
+    def test_simple_lora_conv2d_model(self, *args, **kwargs):
+        simple_model = SimpleConv2DModel()
+        config = LoraConfig(
+            **LORA_PARAMS,
+            target_modules=["conv2d_transform"],
+        )
+        lora_model = get_peft_model(simple_model, config)
+        self._test_model(lora_model, *args, **kwargs)
+
+    def _test_model(self, model, precision):
+        # Move model to GPU
+        model = model.to(self.device)
+
+        # Prepare dummy inputs
+        input_ids = torch.randint(0, 1000, (2, 10)).to(self.device)
+        if precision == torch.bfloat16:
+            if not is_bf16_available():
+                pytest.skip("Bfloat16 not supported on this device")
+
+        # Forward pass with test precision
+        with torch.autocast(enabled=True, dtype=precision, device_type=self.device):
+            outputs = model(input_ids)
+            assert outputs.dtype == precision
+
+
+class TestFSDPWrap:
+    """
+    Test that we can successfully initialize an FSDP instance of the module.
+
+    This is a very simple test, as it does not perform actual FSDP training. Here we just ensure that the FSDP instance
+    can be created. This can fail for several reasons, e.g. int dtype from BNB or inconsistent requires_grad settings
+    due to the auto wrap policy.
+
+    """
+
+    @pytest.mark.single_gpu_tests
+    @require_bitsandbytes
+    def test_bnb_4bit_wrap_fsdp(self):
+        quant_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            # float32 must be used, or else FSDP will complain about mixed int and float dtypes
+            bnb_4bit_compute_dtype=torch.float32,
+            bnb_4bit_quant_storage=torch.float32,
+            bnb_4bit_use_double_quant=True,
+        )
+        model = AutoModelForCausalLM.from_pretrained(
+            "peft-internal-testing/opt-125m",
+            quantization_config=quant_config,
+            dtype=torch.float32,
+        )
+        # model = prepare_model_for_kbit_training(model)
+        config = LoraConfig(
+            target_modules=["q_proj", "v_proj"],
+            task_type="CAUSAL_LM",
+            use_dora=True,
+        )
+        model = get_peft_model(model, config)
+
+        os.environ["MASTER_ADDR"] = "localhost"
+        os.environ["MASTER_PORT"] = "29501"
+
+        init_process_group(world_size=1, rank=0)
+        # check that this does not raise:
+        FSDP(model, auto_wrap_policy=fsdp_auto_wrap_policy(model), use_orig_params=False, sync_module_states=True)
+
+    def test_fsdp_auto_wrap_policy_does_not_raise_on_custom_model(self):
+        # See #2167
+        # Avoid raising on custom models since Trainer uses fsdp_auto_wrap_policy automatically for PEFT + FSDP
+        fsdp_auto_wrap_policy(SimpleModel())  # does not raise
+
+
+class TestBOFT:
+    """
+    Test that we can correctly use half-precision models with BOFT.
+    """
+
+    device = infer_device()
+
+    @require_non_cpu
+    @pytest.mark.single_gpu_tests
+    def test_boft_half_linear(self):
+        # Check that we can use BoFT with model loaded in half precision
+        config = boft.config.BOFTConfig(boft_n_butterfly_factor=2)
+        layer = torch.nn.Linear(160, 160).to(self.device)
+        layer = boft.layer.Linear(layer, "layer", config=config).to(dtype=torch.bfloat16)
+        x = torch.randn(160, 160, device=self.device, dtype=torch.bfloat16)
+        layer(x)  # does not raise
+
+    @require_non_cpu
+    @pytest.mark.single_gpu_tests
+    def test_boft_half_conv(self):
+        conv = torch.nn.Conv2d(1, 1, 4).to(self.device)
+        config = boft.config.BOFTConfig(boft_n_butterfly_factor=2)
+        conv = boft.layer.Conv2d(conv, "conv", config=config).to(dtype=torch.bfloat16)
+        x = torch.randn(1, 160, 160, device=self.device, dtype=torch.bfloat16)
+        conv(x)  # does not raise
+
+
+class TestPTuningReproducibility:
+    device = infer_device()
+    causal_lm_model_id = "peft-internal-testing/opt-125m"
+
+    @require_non_cpu
+    @require_deterministic_for_xpu
+    def test_p_tuning_exactly_reproducible_after_loading(self, tmp_path):
+        # See: https://github.com/huggingface/peft/issues/2043#issuecomment-2321522577
+        # Ensure that after loading a p-tuning checkpoint, results are exactly reproducible (before the patch, they were
+        # only _almost_ identical).
+
+        # The model must be sufficiently large for the effect to be measurable, which is why this test requires is not
+        # run on CPU.
+        model_id = "peft-internal-testing/opt-125m"
+        inputs = torch.arange(10).view(-1, 1).to(self.device)
+
+        torch.manual_seed(0)
+        model = AutoModelForCausalLM.from_pretrained(model_id).to(self.device)
+        peft_config = PromptEncoderConfig(task_type="CAUSAL_LM", num_virtual_tokens=20, encoder_hidden_size=128)
+        model = get_peft_model(model, peft_config).eval()
+
+        with torch.inference_mode():
+            output_peft = model(inputs).logits
+            gen_peft = model.generate(inputs, min_new_tokens=10, max_new_tokens=10)
+
+        model.save_pretrained(tmp_path)
+        del model
+        clear_device_cache(garbage_collection=True)
+
+        model = AutoModelForCausalLM.from_pretrained(model_id).to(self.device)
+        model = PeftModel.from_pretrained(model, tmp_path)
+
+        with torch.inference_mode():
+            output_loaded = model(inputs).logits
+            gen_loaded = model.generate(inputs, min_new_tokens=10, max_new_tokens=10)
+
+        torch.testing.assert_close(output_loaded, output_peft)
+        torch.testing.assert_close(gen_loaded, gen_peft)
+
+    @require_bitsandbytes
+    @pytest.mark.single_gpu_tests
+    def test_p_tuning_causal_lm_training_8bit_bnb(self):
+        # test is analog to PeftBnbGPUExampleTests.test_causal_lm_training
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+                device_map="auto",
+            )
+
+            tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+            config = PromptEncoderConfig(task_type="CAUSAL_LM", num_virtual_tokens=20, encoder_hidden_size=128)
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+
+@pytest.mark.single_gpu_tests
+class TestLowCpuMemUsageDifferentDevices:
+    """Test for the low CPU memory usage option for loading PEFT models.
+
+    There are already tests for low_cpu_mem_usage=True in test_initialization.py but here we want to run tests that
+    require a GPU.
+
+    """
+
+    model_id = "peft-internal-testing/tiny-random-OPTForCausalLM"
+    device = infer_device()
+
+    @require_non_cpu
+    @pytest.mark.parametrize("device_model, device_sd", [("cpu", infer_device()), (infer_device(), "cpu")])
+    def test_low_cpu_mem_usage_model_model_on_gpu_state_dict_on_cpu_works(self, device_model, device_sd):
+        # specifically test diverging devices for the model and state_dict
+        inputs = {"input_ids": torch.randint(0, 100, (1, 10)), "attention_mask": torch.ones(1, 10)}
+        inputs = {k: v.to(device_model) for k, v in inputs.items()}
+
+        model = AutoModelForCausalLM.from_pretrained(self.model_id).to(device_model)
+        lora_config = LoraConfig(init_lora_weights=False, target_modules="all-linear")
+        model = get_peft_model(model, lora_config)
+        model.eval()
+        logits_not_low_cpu_mem = model(**inputs).logits
+
+        state_dict = get_peft_model_state_dict(model)
+        peft_model_state_dict = {}
+        # remap the state dict so that it can be correctly loaded, and move weights to the other device
+        prefix = "base_model.model."
+        for k, v in state_dict.items():
+            k = k[len(prefix) :]
+            peft_model_state_dict[k] = v.to(device_sd)
+
+        del model
+
+        model = AutoModelForCausalLM.from_pretrained(self.model_id).to(device_model)
+        model.eval()
+        inject_adapter_in_model(lora_config, model, low_cpu_mem_usage=True)
+        load_result = set_peft_model_state_dict(model, peft_model_state_dict, low_cpu_mem_usage=True)
+
+        # sanity check: all lora keys are matched
+        assert not any("lora" in k for k in load_result.missing_keys)
+        assert not any("lora" in k for k in load_result.unexpected_keys)
+
+        logits_low_cpu_mem = model(**inputs).logits
+
+        assert torch.allclose(logits_low_cpu_mem, logits_not_low_cpu_mem)
+        assert {p.device.type for p in model.parameters()} == {device_model}
+
+    @require_bitsandbytes
+    @pytest.mark.parametrize("quantization_method", ["bnb-4bit", "bnb-8bit"])
+    def test_low_cpu_mem_usage_with_quantization(self, quantization_method):
+        # Ensure that low_cpu_mem_usage works with quantization
+        # See also https://github.com/huggingface/diffusers/issues/10550
+        if quantization_method == "bnb-4bit":
+            quantization_config = BitsAndBytesConfig(
+                load_in_4bit=True,
+                bnb_4bit_compute_dtype=torch.float32,
+                bnb_4bit_quant_storage=torch.float32,
+                bnb_4bit_use_double_quant=True,
+            )
+        elif quantization_method == "bnb-8bit":
+            quantization_config = BitsAndBytesConfig(load_in_8bit=True)
+        else:
+            raise ValueError(f"Unknown quantization method {quantization_method}")
+
+        model = AutoModelForCausalLM.from_pretrained(self.model_id, quantization_config=quantization_config)
+        if model.device.type != self.device:
+            # calling model.to("cuda") with 8 bit bnb raises an error, thus guard against it
+            model = model.to(self.device)
+
+        lora_config = LoraConfig(init_lora_weights=False, target_modules="all-linear")
+
+        # We use get_peft_model with low_cpu_mem_usage=True here. This is not typically done in practice (the option is
+        # mostly interesting for loading trained adapters), but it does the job for testing purposes.
+        model = get_peft_model(model, lora_config, low_cpu_mem_usage=True)  # this should not raise
+        assert {p.device.type for p in model.parameters()} == {self.device, "meta"}
+
+
+@pytest.mark.single_gpu_tests
+@require_non_cpu
+class TestEvaInitializationGPU:
+    """GPU tests for the Eva initialization method.
+
+    This test suite verifies:
+    1. Consistency of initialization across different seeds
+    2. Proper error handling for invalid inputs
+    3. Compatibility with different model architectures
+    4. Reproducibility of results
+    5. Proper handling of edge cases
+    """
+
+    # Constants for test configuration
+    COSINE_SIMILARITY_THRESHOLD = 0.75
+    NUM_SEEDS = 3
+    BATCH_SIZE = 4
+    MAX_LENGTH = 256
+    LORA_DIM = 8
+    LORA_ALPHA = 1
+    DEVICE = infer_device()
+
+    @pytest.fixture
+    def tokenizer(self):
+        tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2")
+        tokenizer.pad_token = tokenizer.eos_token
+        return tokenizer
+
+    @pytest.fixture
+    def dataset(self, tokenizer):
+        # concatenate examples
+        examples = []
+        example = ""
+        ds = load_dataset_english_quotes()["train"]  # cached
+        for data in ds:
+            if len(example) >= self.MAX_LENGTH:
+                examples.append(example)
+                example = ""
+            example = example + " " + data["quote"]
+        dataset = Dataset.from_dict({"text": examples})
+        # tokenize
+        dataset = dataset.map(
+            lambda x: tokenizer(x["text"], padding="max_length", truncation=True, max_length=self.MAX_LENGTH),
+            batched=True,
+            remove_columns=dataset.column_names,
+        )
+        dataset.set_format(type="torch")
+        return dataset
+
+    @pytest.fixture
+    def model(self):
+        model_id = "openai-community/gpt2"
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            model.transformer.h = model.transformer.h[:2]  # truncate to 2 layers
+            return model.to(self.DEVICE)
+
+    @pytest.fixture
+    def model_bnb(self):
+        model_id = "openai-community/gpt2"
+        with hub_online_once(model_id):
+            bnb_config = BitsAndBytesConfig(load_in_4bit=True)
+            model = AutoModelForCausalLM.from_pretrained(
+                model_id,
+                quantization_config=bnb_config,
+                attn_implementation="eager",  # gpt2 doesn't support flash attention
+            )
+            model.transformer.h = model.transformer.h[:2]  # truncate to 2 layers
+            model = prepare_model_for_kbit_training(model)
+            return model
+
+    @pytest.fixture
+    def model_fixture(self, request):
+        return request.getfixturevalue(request.param)
+
+    @pytest.fixture
+    def peft_config(self):
+        return LoraConfig(
+            r=self.LORA_DIM,
+            lora_alpha=self.LORA_ALPHA,
+            target_modules=["c_attn"],
+            init_lora_weights="eva",
+            eva_config=EvaConfig(rho=2),
+        )
+
+    def is_bnb_model(self, model):
+        return hasattr(model.config, "quantization_config")
+
+    @staticmethod
+    def collate_fn(examples):
+        return {k: torch.stack([v[k] for v in examples], dim=0) for k in examples[0].keys()}
+
+    def get_dataloader(self, dataset):
+        return DataLoader(
+            dataset,
+            batch_size=self.BATCH_SIZE,
+            collate_fn=self.collate_fn,
+            shuffle=False,
+        )
+
+    @require_bitsandbytes
+    @pytest.mark.parametrize(
+        "eva_config",
+        [
+            EvaConfig(rho=2, tau=0.99),
+            EvaConfig(rho=1, tau=0.9),
+            EvaConfig(rho=1, whiten=True, tau=0.9),
+            EvaConfig(rho=1.0001, tau=0.9),
+        ],
+    )
+    @pytest.mark.parametrize("model_fixture", ["model", "model_bnb"], indirect=True)
+    def test_eva_initialization_consistency(self, model_fixture, dataset, peft_config, eva_config):
+        """Test that the state dict returned by get_eva_state_dict loaded correctly and is consistent across different
+        seeds based on the cosine similarity of the svd components.
+
+        """
+        peft_config = deepcopy(peft_config)
+        peft_config.eva_config = eva_config
+        state_dicts = []
+        for seed in range(self.NUM_SEEDS):
+            shuffled_dataset = dataset.shuffle(seed=seed)
+            dataloader = self.get_dataloader(shuffled_dataset)
+            sd = get_eva_state_dict(deepcopy(model_fixture), dataloader, peft_config, show_progress_bar=False)
+            state_dicts.append(sd)
+
+        cos_sims = defaultdict(list)
+        for i, j in itertools.combinations(range(self.NUM_SEEDS), 2):
+            for k, v1 in state_dicts[i].items():
+                v2 = state_dicts[j][k]
+                min_size = min(v1.size(0), v2.size(0))
+                cos_sims[k].extend(
+                    torch.cosine_similarity(v1[:min_size].abs(), v2[:min_size].abs(), dim=1).abs().tolist()
+                )
+
+        mean_cosine_similarities = {k: torch.tensor(v).mean() for k, v in cos_sims.items()}
+        for mean_cosine_similarity in mean_cosine_similarities.values():
+            assert mean_cosine_similarity > self.COSINE_SIMILARITY_THRESHOLD, (
+                f"Mean absolute cosine similarity {mean_cosine_similarity:.4f} "
+                f"is not greater than {self.COSINE_SIMILARITY_THRESHOLD}"
+            )
+
+    @pytest.mark.parametrize(
+        "prepare_layer_inputs_keys, expected_outcome",
+        [
+            (None, "success"),
+            (["transformer.h.0.attn.c_attn"], "success"),
+            (
+                ["transformer.h.0.attn.c_attn", "transformer.h.1.attn.c_attn", "transformer.h.2.attn.c_attn"],
+                "value_error",
+            ),
+        ],
+    )
+    def test_eva_state_dict_prepare_inputs_mapping(
+        self, model, dataset, peft_config, prepare_layer_inputs_keys, expected_outcome
+    ):
+        """
+        Tests for cases where prepare_layer_inputs_fn is a mapping. Checks that if not all target modules are present,
+        the prepare_layer_inputs_fn for the remaining modules is set to None. Also checks that if more keys than target
+        modules are present, a ValueError is raised.
+        """
+
+        def fn(x, *args):
+            return x[0].view(-1, x[0].size(-1))
+
+        if prepare_layer_inputs_keys is None:
+            prepare_layer_inputs_fn = fn
+        else:
+            prepare_layer_inputs_fn = {k: fn for k in prepare_layer_inputs_keys}
+
+        shuffled_dataset = dataset.shuffle(seed=0)
+        dataloader = self.get_dataloader(shuffled_dataset)
+        modified_peft_config = deepcopy(peft_config)
+        modified_peft_config.eva_config.tau = 0  # converge immediately
+        if expected_outcome == "success":
+            sd = get_eva_state_dict(
+                model,
+                dataloader,
+                modified_peft_config,
+                prepare_model_inputs_fn=None,
+                prepare_layer_inputs_fn=prepare_layer_inputs_fn,
+            )
+            assert len(sd) == 2
+            assert "transformer.h.0.attn.c_attn" in sd
+            assert "transformer.h.1.attn.c_attn" in sd
+        else:
+            with pytest.raises(
+                ValueError, match="prepare_layer_inputs_fn is a mapping but the following module names were not found"
+            ):
+                get_eva_state_dict(
+                    model,
+                    dataloader,
+                    modified_peft_config,
+                    prepare_model_inputs_fn=None,
+                    prepare_layer_inputs_fn=prepare_layer_inputs_fn,
+                )
+
+    @pytest.mark.parametrize(
+        "eva_config",
+        [EvaConfig(rho=2, adjust_scaling_factors=True)],
+    )
+    def test_eva_state_dict_adjust_scaling_factors(self, model, dataset, peft_config, eva_config):
+        """
+        Tests that the scaling factors are adjusted so that all LoRA gradients have the same scale regardless of their
+        rank.
+        """
+        modified_peft_config = deepcopy(peft_config)
+        modified_peft_config.eva_config = eva_config
+        dataloader = self.get_dataloader(dataset)
+        peft_model = get_peft_model(deepcopy(model), modified_peft_config)
+        scaling_factors_before = {}
+        for n, m in peft_model.named_modules():
+            if isinstance(m, LoraLayer):
+                scaling_factors_before[n] = m.scaling["default"]
+        initialize_lora_eva_weights(peft_model, dataloader)
+        for n, m in peft_model.named_modules():
+            if isinstance(m, LoraLayer):
+                assert m.scaling["default"] == scaling_factors_before[n]
+
+    @pytest.mark.parametrize("has_rank_zero", [True, False])
+    def test_load_eva_state_dict(self, model, dataset, peft_config, tmp_path, has_rank_zero):
+        """
+        Tests that the `eva_state_dict` argument in `initialize_lora_eva_weights` can be used to initialize a model
+        with EVA weights and that the initialized model can be saved and loaded correctly.
+        """
+        dataloader = self.get_dataloader(dataset)
+        peft_model = get_peft_model(deepcopy(model), peft_config)
+        sd = get_eva_state_dict(peft_model, dataloader)
+        if has_rank_zero:
+            k = "base_model.model.transformer.h.0.attn.c_attn"
+            sd[k] = sd[k][:0]
+        initialize_lora_eva_weights(peft_model, eva_state_dict=sd)
+        if has_rank_zero:
+            assert not isinstance(peft_model.model.transformer.h[0].attn.c_attn, LoraLayer)
+        else:
+            assert isinstance(peft_model.model.transformer.h[0].attn.c_attn, LoraLayer)
+        peft_model.save_pretrained(tmp_path)
+        peft_model = PeftModel.from_pretrained(model, tmp_path, torch_device=self.DEVICE, low_cpu_mem_usage=True)
+        peft_model(**{k: v.to(self.DEVICE) for k, v in next(iter(dataloader)).items()})
+
+    def test_missing_eva_inits(self, model, dataset, peft_config):
+        """
+        Tests that a warning is raised when some adapter modules were not initialized with EVA weights.
+        """
+        modified_peft_config = deepcopy(peft_config)
+        modified_peft_config.target_modules = ["wte"]
+        dataloader = self.get_dataloader(dataset)
+        peft_model = get_peft_model(deepcopy(model), modified_peft_config)
+        msg = (
+            "the following layers were initialized with init_lora_weights=True because they were not found in the eva "
+            "state_dict:*"
+        )
+        with pytest.warns(UserWarning, match=msg):
+            initialize_lora_eva_weights(peft_model, dataloader)
+
+    def test_load_eva_model(self, model, dataset, peft_config, tmp_path):
+        """
+        Tests that a model initialized with EVA weights can be loaded correctly.
+        """
+        dataloader = self.get_dataloader(dataset)
+        peft_model = get_peft_model(deepcopy(model), peft_config)
+        initialize_lora_eva_weights(peft_model, dataloader)
+        peft_model.save_pretrained(tmp_path)
+        peft_model = PeftModel.from_pretrained(model, tmp_path, torch_device=self.DEVICE, low_cpu_mem_usage=True)
+        peft_model(**{k: v.to(self.DEVICE) for k, v in next(iter(dataloader)).items()})
+
+    @pytest.mark.parametrize("use_label_mask", [True, False])
+    def test_eva_label_mask(self, model, dataset, peft_config, use_label_mask):
+        """
+        Tests that label masking works correctly in get_eva_state_dict (see PR #3234).
+        """
+
+        def add_labels(x):
+            return {
+                "labels": torch.where(
+                    x["attention_mask"].bool(),
+                    torch.ones_like(x["attention_mask"]),
+                    -100 * torch.ones_like(x["attention_mask"]),
+                )
+            }
+
+        dataset_with_labels = dataset.map(add_labels)
+        dataset_with_labels.set_format(type="torch")
+        dataloader = self.get_dataloader(dataset_with_labels)
+        modified_peft_config = deepcopy(peft_config)
+        modified_peft_config.eva_config = EvaConfig(rho=2, use_label_mask=use_label_mask)
+        sd = get_eva_state_dict(deepcopy(model), dataloader, modified_peft_config, show_progress_bar=False)
+        assert len(sd) > 0
+
+    def test_eva_initialization_with_invalid_dataloader(self, model, peft_config):
+        """Test that appropriate error is raised when dataloader is empty."""
+        empty_dataset = Dataset.from_dict({"text": []})
+        dataloader = self.get_dataloader(empty_dataset)
+
+        with pytest.raises(ValueError, match="dataloader is empty"):
+            get_eva_state_dict(model, dataloader, peft_config)
+
+
+class TestALoRAInferenceGPU:
+    """GPU inference for Activated LoRA."""
+
+    # Constants for test configuration
+    NUM_SEEDS = 3
+    LORA_DIM = 8
+    LORA_ALPHA = 1
+    DEVICE = infer_device()
+
+    @pytest.fixture
+    def tokenizer(self):
+        tokenizer = AutoTokenizer.from_pretrained("peft-internal-testing/opt-125m")
+        tokenizer.pad_token = tokenizer.eos_token
+        return tokenizer
+
+    @pytest.fixture
+    def model(self):
+        model = AutoModelForCausalLM.from_pretrained("peft-internal-testing/opt-125m")
+        model.model.decoder.layers = model.model.decoder.layers[:2]  # truncate to 2 layers
+        return model.to(self.DEVICE)
+
+    @pytest.fixture
+    def model_bnb(self):
+        bnb_config = BitsAndBytesConfig(load_in_4bit=True)
+        model = AutoModelForCausalLM.from_pretrained(
+            "peft-internal-testing/opt-125m",
+            quantization_config=bnb_config,
+        )
+        model.model.decoder.layers = model.model.decoder.layers[:2]  # truncate to 2 layers
+        model = prepare_model_for_kbit_training(model)
+        return model
+
+    @pytest.fixture
+    def peft_config(self):
+        return LoraConfig(
+            r=self.LORA_DIM,
+            task_type="CAUSAL_LM",
+            lora_alpha=self.LORA_ALPHA,
+            target_modules=["q_proj"],
+            alora_invocation_tokens=[2],  # id for </s>
+            init_lora_weights=False,
+        )
+
+    @require_non_cpu
+    @require_bitsandbytes
+    @pytest.mark.single_gpu_tests
+    def test_alora_forward_consistency(self, model, model_bnb, peft_config):
+        """Test that the forwards of the model with adapter are similar across quantizations."""
+        for seed in range(self.NUM_SEEDS):
+            torch.manual_seed(seed)
+            # random.seed(seed)
+            np.random.seed(seed)
+            peft_model = get_peft_model(deepcopy(model), peft_config)
+            torch.manual_seed(seed)
+            # random.seed(seed)
+            np.random.seed(seed)
+            peft_model_bnb = get_peft_model(deepcopy(model_bnb), peft_config)
+            peft_model.eval()
+            peft_model_bnb.eval()
+            input_ids = torch.tensor([[0, 1, 2, 3]]).to(self.DEVICE)
+            with torch.no_grad():
+                peft_out = peft_model(input_ids=input_ids, return_dict=True, output_hidden_states=True)
+                peft_out_bnb = peft_model_bnb(input_ids=input_ids, return_dict=True, output_hidden_states=True)
+            h_fp = peft_out.hidden_states[-1]
+            h_4b = peft_out_bnb.hidden_states[-1]
+            a = h_fp.detach().to(torch.float32).cpu()
+            b = h_4b.detach().to(torch.float32).cpu()
+            import torch.nn.functional as F
+
+            cos = F.cosine_similarity(a.flatten(), b.flatten(), dim=0).item()
+            assert cos > 0.9
+
+
+@pytest.mark.multi_gpu_tests
+class TestPrefixTuning:
+    device = infer_device()
+    causal_lm_model_id = "peft-internal-testing/opt-125m"
+
+    @require_torch_multi_accelerator
+    def test_prefix_tuning_multiple_devices_decoder_model(self):
+        # See issue 2134
+        model_id = "hf-internal-testing/tiny-random-MistralForCausalLM"
+        tokenizer = AutoTokenizer.from_pretrained(model_id, padding="left")
+        inputs = tokenizer(["A list of colors: red, blue"], return_tensors="pt").to(self.device)
+
+        device_map = {
+            "model.embed_tokens": 0,
+            "model.layers.0": 0,
+            "model.layers.1": 1,
+            "model.norm": 1,
+            "model.rotary_emb": 1,
+            "lm_head": 1,
+        }
+        model = AutoModelForCausalLM.from_pretrained(model_id, device_map=device_map)
+        # sanity check, as the test passes trivially for a single device
+        assert len({p.device for p in model.parameters()}) > 1
+        # sanity check: this should work without peft
+        model.generate(**inputs)  # does not raise
+
+        peft_config = PrefixTuningConfig(num_virtual_tokens=10, task_type="CAUSAL_LM")
+        model = get_peft_model(model, peft_config)
+        model.generate(**inputs)  # does not raise
+
+    @require_torch_multi_accelerator
+    def test_prefix_tuning_multiple_devices_encoder_decoder_model(self):
+        # See issue 2134
+        model_id = "peft-internal-testing/tiny-random-t5"
+        tokenizer = AutoTokenizer.from_pretrained(model_id, padding="left")
+        inputs = tokenizer(["A list of colors: red, blue"], return_tensors="pt").to(self.device)
+        device_map = {
+            "shared": 0,
+            "encoder.embed_tokens": 0,
+            "encoder.block.0": 0,
+            "encoder.block.1": 0,
+            "encoder.block.2": 1,
+            "encoder.block.3": 1,
+            "encoder.block.4": 1,
+            "encoder.final_layer_norm": 1,
+            "decoder.embed_tokens": 0,
+            "decoder.block.0": 0,
+            "decoder.block.1": 0,
+            "decoder.block.2": 1,
+            "decoder.block.3": 1,
+            "decoder.block.4": 1,
+            "decoder.final_layer_norm": 1,
+            "lm_head": 0,
+        }
+        model = AutoModelForSeq2SeqLM.from_pretrained(model_id, device_map=device_map)
+        # sanity check, as the test passes trivially for a single device
+        assert len({p.device for p in model.parameters()}) > 1
+        # sanity check: this should work without peft
+        model.generate(**inputs)  # does not raise
+
+        peft_config = PrefixTuningConfig(num_virtual_tokens=10, task_type="SEQ_2_SEQ_LM")
+        model = get_peft_model(model, peft_config)
+        model.generate(**inputs)  # does not raise
+
+    @require_bitsandbytes
+    @pytest.mark.single_gpu_tests
+    def test_prefix_tuning_causal_lm_training_8bit_bnb(self):
+        # test is analog to PeftBnbGPUExampleTests.test_causal_lm_training
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            model = AutoModelForCausalLM.from_pretrained(
+                self.causal_lm_model_id,
+                quantization_config=BitsAndBytesConfig(load_in_8bit=True),
+                device_map="auto",
+            )
+
+            tokenizer = AutoTokenizer.from_pretrained(self.causal_lm_model_id)
+            config = PrefixTuningConfig(num_virtual_tokens=10, task_type=TaskType.CAUSAL_LM)
+            model = get_peft_model(model, config)
+
+            data = load_dataset_english_quotes()
+            data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+
+            trainer = Trainer(
+                model=model,
+                train_dataset=data["train"],
+                args=TrainingArguments(
+                    per_device_train_batch_size=4,
+                    warmup_steps=2,
+                    max_steps=3,
+                    learning_rate=2e-4,
+                    fp16=True,
+                    logging_steps=1,
+                    output_dir=tmp_dir,
+                ),
+                data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+            )
+            trainer.train()
+
+            model.cpu().save_pretrained(tmp_dir)
+
+            assert "adapter_config.json" in os.listdir(tmp_dir)
+            assert SAFETENSORS_WEIGHTS_NAME in os.listdir(tmp_dir)
+
+            # assert loss is not None
+            assert trainer.state.log_history[-1]["train_loss"] is not None
+
+
+@pytest.mark.skipif(not (torch.cuda.is_available() or is_xpu_available()), reason="test requires a GPU or XPU")
+@pytest.mark.single_gpu_tests
+class TestHotSwapping:
+    """
+    Test hotswapping on compiled models.
+
+    This test suite is only run on GPU as it is quite slow.
+    """
+
+    torch_device = infer_device()
+
+    @pytest.fixture(scope="class", autouse=True)
+    def reset_float32_matmul_precision(self):
+        # Earlier tests may run torchao, which, at the time this was added, sets the float32 matmul precision to 'high'.
+        # This in turn results in some models producing different outputs when compiled (but only for some seeds).
+        # Therefore, we need to ensure that the precision is reset to "highest", which is the default.
+        # TODO: if torchao removes the side effect, this fixture can be deleted.
+        # https://github.com/pytorch/ao/blob/ffb4350640e76c7e7f449dd1e36d33f19fe384c8/torchao/quantization/utils.py#L589
+        torch.set_float32_matmul_precision("highest")
+
+    @pytest.fixture(autouse=True)
+    def reset_dynamo_cache(self):
+        # It is critical that the dynamo cache is reset for each test. Otherwise, if the test re-uses the same model,
+        # there will be recompilation errors, as torch caches the model when run in the same process.
+        torch._dynamo.reset()
+        yield
+
+    #######
+    # LLM #
+    #######
+
+    def check_hotswap(self, do_hotswap, ranks, alpha_scalings):
+        """
+        Test hotswapping with a compiled model.
+
+        Passing do_hotswap=False should trigger recompilation. Use the raise_error_on_recompile context manager to
+        raise an error when recompilation occurs.
+
+        """
+        torch.manual_seed(0)
+        inputs = torch.arange(10).view(-1, 1).to(self.torch_device)
+        model_id = "peft-internal-testing/tiny-random-OPTForCausalLM"
+        model = AutoModelForCausalLM.from_pretrained(model_id).to(self.torch_device)
+        rank0, rank1 = ranks
+        alpha0, alpha1 = alpha_scalings
+
+        # note that the 2nd adapter targeting a subset of the 1st adapter is okay, but not the other way round
+        config0 = LoraConfig(init_lora_weights=False, r=rank0, lora_alpha=alpha0, target_modules=["q_proj", "v_proj"])
+        config1 = LoraConfig(init_lora_weights=False, r=rank1, lora_alpha=alpha1, target_modules=["q_proj"])
+        model = get_peft_model(model, config0, adapter_name="adapter0").eval()
+        with torch.inference_mode():
+            output0 = model(inputs).logits
+
+        model.add_adapter("adapter1", config1)
+        model.set_adapter("adapter1")
+        with torch.inference_mode():
+            output1 = model(inputs).logits
+
+        # sanity check:
+        tol = 1e-4
+        assert not torch.allclose(output0, output1, atol=tol, rtol=tol)
+
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            model.save_pretrained(tmp_dirname)
+            del model
+
+            model = AutoModelForCausalLM.from_pretrained(model_id).to(self.torch_device)
+            model = PeftModel.from_pretrained(model, os.path.join(tmp_dirname, "adapter0")).eval()
+            if do_hotswap:
+                prepare_model_for_compiled_hotswap(model, config=model.peft_config, target_rank=max(ranks))
+            model = torch.compile(model, mode="reduce-overhead")
+            output_after0 = model(inputs).logits
+            assert torch.allclose(output0, output_after0, atol=tol, rtol=tol)
+
+            # swap and check that we get the output from adapter1
+            if do_hotswap:
+                hotswap_adapter(model, os.path.join(tmp_dirname, "adapter1"), adapter_name="default")
+            else:
+                model.load_adapter(os.path.join(tmp_dirname, "adapter1"), adapter_name="other")
+                model.set_adapter("other")
+
+            # we need to call forward to potentially trigger recompilation
+            output_after1 = model(inputs).logits
+            assert torch.allclose(output1, output_after1, atol=tol, rtol=tol)
+
+            # we need to call forward third time since cudagraphs are not recorded in first call.
+            if do_hotswap:
+                hotswap_adapter(model, os.path.join(tmp_dirname, "adapter0"), adapter_name="default")
+                output_after2 = model(inputs).logits
+                assert torch.allclose(output0, output_after2, atol=tol, rtol=tol)
+
+    # it is important to check hotswapping small to large ranks and large to small ranks
+    @pytest.mark.parametrize("ranks", [(11, 11), (7, 13), (13, 7)])
+    def test_hotswapping_compiled_model_does_not_trigger_recompilation(self, ranks):
+        # here we set three configs to ensure no recompilation or cudagraph re-record occurs:
+        # 1. error_on_recompile: raise an error on recompilation
+        # 2. inline_inbuilt_nn_modules: needed to raise an error on static input address changes instead of re-recording
+        # 3. triton.cudagraph_support_input_mutation: same as above
+        dynamo_config_ctx = torch._dynamo.config.patch(error_on_recompile=True, inline_inbuilt_nn_modules=False)
+        inductor_config_ctx = torch._inductor.config.patch("triton.cudagraph_support_input_mutation", False)
+        with dynamo_config_ctx, inductor_config_ctx:
+            self.check_hotswap(do_hotswap=True, ranks=ranks, alpha_scalings=ranks)
+
+    def test_no_hotswapping_compiled_model_triggers_recompilation(self):
+        # contingency test to ensure that hotswapping is actually needed to prevent recompilation
+        ranks = 7, 13
+        with torch._dynamo.config.patch(error_on_recompile=True):
+            with pytest.raises(torch._dynamo.exc.RecompileError):  # raise an error on recompilation
+                self.check_hotswap(do_hotswap=False, ranks=ranks, alpha_scalings=ranks)
+
+    @pytest.mark.parametrize("do_compile", [False, True])
+    def test_hotswap_lora_target_parameters(self, do_compile, tmp_path):
+        # Test that hotswapping works with target_parameters. In this test, there is no need to call
+        # prepare_model_for_compiled_hotswap, as we use the same LoRA shapes. Due to (re-)compilation, the test is
+        # relatively slow.
+        atol, rtol = 1e-6, 1e-6
+        model_id = "trl-internal-testing/tiny-GptOssForCausalLM"
+        inputs = torch.arange(10).view(1, -1).to(self.torch_device)
+
+        def strong_init(model):
+            # increase the scale of the LoRA weights so that the difference between adapters is more pronounced, making the test more robust
+            for name, param in model.named_parameters():
+                if "lora_" in name:
+                    param.data *= 10.0
+
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id).to(self.torch_device)
+            with torch.inference_mode():
+                output_base = model(inputs).logits
+
+            # create adapter 0
+            config = LoraConfig(
+                target_parameters=[
+                    "mlp.experts.down_proj",
+                    "mlp.experts.gate_up_proj",
+                ],
+                init_lora_weights=False,
+            )
+            torch.manual_seed(0)
+            model = get_peft_model(model, config)
+            strong_init(model)
+            # Note: For compilation, use eager backend, as the parameter targeting, which uses nn.utils.parametrize,
+            # leads to recompiles/graph breaks, which can significantly affect the outputs, even if weights are correctly
+            # loaded.
+            model = torch.compile(model, backend="eager")
+            with torch.inference_mode():
+                torch.manual_seed(0)
+                output0 = model(inputs).logits
+
+            # sanity check: outputs differ
+            assert not torch.allclose(output_base, output0, atol=1e-3, rtol=1e-3)
+
+            model.save_pretrained(tmp_path / "adapter0")
+            del model
+
+            # create adapter 1
+            model = AutoModelForCausalLM.from_pretrained(model_id).to(self.torch_device)
+            torch.manual_seed(1)
+            model = get_peft_model(model, config)
+            strong_init(model)
+            model = torch.compile(model, backend="eager")
+            model.eval()
+            with torch.inference_mode():
+                torch.manual_seed(0)
+                output1 = model(inputs).logits
+            model.save_pretrained(tmp_path / "adapter1")
+
+            # sanity check: they're not the same
+            assert not torch.allclose(output0, output1, atol=1e-3, rtol=1e-3)
+
+            del model
+
+            # load adapter 0
+            model = AutoModelForCausalLM.from_pretrained(model_id).to(self.torch_device)
+            model = PeftModel.from_pretrained(model, tmp_path / "adapter0")
+            model = torch.compile(model, backend="eager")
+            with torch.inference_mode():
+                torch.manual_seed(0)
+                output_loaded0 = model(inputs).logits
+
+            # sanity check: same output after loading for adapter 0
+            assert torch.allclose(output0, output_loaded0, atol=atol, rtol=rtol)
+
+            # hotswap with adapter 1
+            hotswap_adapter(model, tmp_path / "adapter1", adapter_name="default")
+            with torch.inference_mode():
+                torch.manual_seed(0)
+                output_loaded1 = model(inputs).logits
+
+            # real check: model now behaves like adapter 1
+            assert torch.allclose(output1, output_loaded1, atol=atol, rtol=rtol)
+
+            # hotswap back to adapter 0
+            hotswap_adapter(model, tmp_path / "adapter0", adapter_name="default")
+            with torch.inference_mode():
+                torch.manual_seed(0)
+                output_loaded_back0 = model(inputs).logits
+
+            # real check: model now behaves again like adapter 0
+            assert torch.allclose(output0, output_loaded_back0, atol=atol, rtol=rtol)
+
+    ###################
+    # DIFFUSION MODEL #
+    ###################
+
+    def get_small_unet(self):
+        # from diffusers UNet2DConditionModelTests
+        from diffusers import UNet2DConditionModel
+
+        torch.manual_seed(0)
+        init_dict = {
+            "block_out_channels": (4, 8),
+            "norm_num_groups": 4,
+            "down_block_types": ("CrossAttnDownBlock2D", "DownBlock2D"),
+            "up_block_types": ("UpBlock2D", "CrossAttnUpBlock2D"),
+            "cross_attention_dim": 8,
+            "attention_head_dim": 2,
+            "out_channels": 4,
+            "in_channels": 4,
+            "layers_per_block": 1,
+            "sample_size": 16,
+        }
+        model = UNet2DConditionModel(**init_dict)
+        return model.to(self.torch_device)
+
+    def get_unet_lora_config(self, lora_rank, lora_alpha, target_modules):
+        # from diffusers test_models_unet_2d_condition.py
+        # note that this only targets linear layers by default
+        unet_lora_config = LoraConfig(
+            r=lora_rank,
+            lora_alpha=lora_alpha,
+            target_modules=target_modules,
+            init_lora_weights=False,
+            use_dora=False,
+        )
+        return unet_lora_config
+
+    def get_dummy_input(self):
+        pipeline_inputs = {
+            "prompt": "A painting of a squirrel eating a burger",
+            "num_inference_steps": 5,
+            "guidance_scale": 6.0,
+            "output_type": "np",
+            "return_dict": False,
+        }
+        return pipeline_inputs
+
+    def set_lora_device(self, model, adapter_names, device):
+        # copied from diffusers LoraBaseMixin.set_lora_device
+        for module in model.modules():
+            if isinstance(module, BaseTunerLayer):
+                for adapter_name in adapter_names:
+                    module.lora_A[adapter_name].to(device)
+                    module.lora_B[adapter_name].to(device)
+                    # this is a param, not a module, so device placement is not in-place -> re-assign
+                    if hasattr(module, "lora_magnitude_vector") and module.lora_magnitude_vector is not None:
+                        if adapter_name in module.lora_magnitude_vector:
+                            module.lora_magnitude_vector[adapter_name] = module.lora_magnitude_vector[adapter_name].to(
+                                device
+                            )
+
+    def check_hotswap_diffusion(self, ranks, alpha_scalings, target_modules):
+        """
+        Check that hotswapping works on a pipeline.
+
+        This is essentially the same test as:
+        https://github.com/huggingface/diffusers/blob/d7dd924ece56cddf261cd8b9dd901cbfa594c62c/tests/pipelines/test_pipelines.py#L2264
+
+        Steps:
+        - create 2 LoRA adapters and save them
+        - load the first adapter
+        - hotswap the second adapter
+        - check that the outputs are correct
+        - optionally compile the model
+
+        Note: We set rank == alpha here because save_lora_adapter does not save the alpha scalings, thus the test would
+        fail if the values are different. Since rank != alpha does not matter for the purpose of this test, this is
+        fine.
+        """
+        from diffusers import StableDiffusionPipeline
+
+        # create 2 adapters with different ranks and alphas
+        dummy_input = self.get_dummy_input()
+        pipeline = StableDiffusionPipeline.from_pretrained("hf-internal-testing/tiny-sd-pipe").to(torch_device)
+        rank0, rank1 = ranks
+        alpha0, alpha1 = alpha_scalings
+        max_rank = max([rank0, rank1])
+        lora_config0 = self.get_unet_lora_config(rank0, alpha0, target_modules)
+        lora_config1 = self.get_unet_lora_config(rank1, alpha1, target_modules)
+
+        torch.manual_seed(0)
+        pipeline.unet.add_adapter(lora_config0, adapter_name="adapter0")
+        output0_before = pipeline(**dummy_input, generator=torch.manual_seed(0))[0]
+
+        torch.manual_seed(1)
+        pipeline.unet.add_adapter(lora_config1, adapter_name="adapter1")
+        pipeline.unet.set_adapter("adapter1")
+        output1_before = pipeline(**dummy_input, generator=torch.manual_seed(0))[0]
+
+        # sanity check
+        tol = 1e-3
+        assert not np.allclose(output0_before, output1_before, atol=tol, rtol=tol)
+        assert not (output0_before == 0).all()
+        assert not (output1_before == 0).all()
+
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            # save the adapter checkpoints
+            sd0 = get_peft_model_state_dict(pipeline.unet, adapter_name="adapter0")
+            StableDiffusionPipeline.save_lora_weights(
+                save_directory=os.path.join(tmp_dirname, "adapter0"), safe_serialization=True, unet_lora_layers=sd0
+            )
+            sd1 = get_peft_model_state_dict(pipeline.unet, adapter_name="adapter1")
+            StableDiffusionPipeline.save_lora_weights(
+                save_directory=os.path.join(tmp_dirname, "adapter1"), safe_serialization=True, unet_lora_layers=sd1
+            )
+            del pipeline
+
+            # load the first adapter
+            pipeline = StableDiffusionPipeline.from_pretrained("hf-internal-testing/tiny-sd-pipe").to(torch_device)
+            # no need to prepare if the model is not compiled or if the ranks are identical
+            pipeline.enable_lora_hotswap(target_rank=max_rank)
+
+            file_name0 = os.path.join(tmp_dirname, "adapter0", "pytorch_lora_weights.safetensors")
+            file_name1 = os.path.join(tmp_dirname, "adapter1", "pytorch_lora_weights.safetensors")
+
+            pipeline.load_lora_weights(file_name0)
+            pipeline.unet = torch.compile(pipeline.unet, mode="reduce-overhead")
+
+            output0_after = pipeline(**dummy_input, generator=torch.manual_seed(0))[0]
+
+            # sanity check: still same result
+            assert np.allclose(output0_before, output0_after, atol=tol, rtol=tol)
+
+            # hotswap the 2nd adapter
+            pipeline.load_lora_weights(file_name1, hotswap=True, adapter_name="default_0")
+            output1_after = pipeline(**dummy_input, generator=torch.manual_seed(0))[0]
+
+            # sanity check: since it's the same LoRA, the results should be identical
+            assert np.allclose(output1_before, output1_after, atol=tol, rtol=tol)
+
+            # we need to call forward third time since cudagraphs are not recorded in first call.
+            pipeline.load_lora_weights(file_name0, hotswap=True, adapter_name="default_0")
+            output2_after = pipeline(**dummy_input, generator=torch.manual_seed(0))[0]
+            assert np.allclose(output0_before, output2_after, atol=tol, rtol=tol)
+
+    @pytest.mark.skipif(not is_diffusers_available(), reason="Test requires diffusers to be installed")
+    # it is important to check hotswapping small to large ranks and large to small ranks
+    @pytest.mark.parametrize("ranks", [(11, 11), (7, 13), (13, 7)])
+    @pytest.mark.parametrize(
+        "target_modules",
+        [
+            ["to_q", "to_k", "to_v", "to_out.0"],  # Linear layers
+            ["conv", "conv1", "conv2"],  # Conv2d layers
+            ["to_q", "conv"],  # mix of Linear and Conv2d
+        ],
+    )
+    def test_hotswapping_compiled_diffusers_model_does_not_trigger_recompilation(self, ranks, target_modules):
+        # here we set three configs to ensure no recompilation or cudagraph re-record occurs:
+        # 1. error_on_recompile: raise an error on recompilation
+        # 2. inline_inbuilt_nn_modules: needed to raise an error on static input address changes instead of re-recording
+        # 3. triton.cudagraph_support_input_mutation: same as above
+        dynamo_config_ctx = torch._dynamo.config.patch(error_on_recompile=True, inline_inbuilt_nn_modules=False)
+        inductor_config_ctx = torch._inductor.config.patch("triton.cudagraph_support_input_mutation", False)
+        with dynamo_config_ctx, inductor_config_ctx:
+            self.check_hotswap_diffusion(ranks=ranks, alpha_scalings=ranks, target_modules=target_modules)
+
+
+# Test: 4-bit load + Arrow + generate
+class TestArrowQuantized:
+    @pytest.fixture(scope="class")
+    def workdir(self, tmp_path_factory):
+        """Create and return a temp directory path for this class (no chdir)."""
+        wd = tmp_path_factory.mktemp("arrow_workdir")
+        return Path(wd)
+
+    def _create_and_save_adapter_opt(self, out_dir: Path, rank: int = 4):
+        """
+        Build a randomly initialized LoRA adapter for OPT-125M and save into `out_dir`. We construct a model from
+        CONFIG (no pretrained weights) to avoid slow downloads here.
+        """
+        model_id = "peft-internal-testing/opt-125m"
+        # Target all linear layers so the adapter matches whatever we later quantize/load.
+        lora_cfg = LoraConfig(
+            r=rank,
+            target_modules="all-linear",
+            task_type="CAUSAL_LM",
+            init_lora_weights=False,
+        )
+        # Load the adapter on the model and save it
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+        peft_model = get_peft_model(model, lora_cfg)
+        peft_model.save_pretrained(out_dir)
+
+    @pytest.fixture(scope="class")
+    def ts_adapters_opt(self, workdir: Path):
+        """
+        Build 3 locally-saved task-specific adapters for OPT-125M and return their absolute paths.
+        """
+        paths = []
+        for i in range(3):
+            sub = workdir / f"ts_expert_{i}"
+            self._create_and_save_adapter_opt(sub)
+            paths.append(str(sub))
+        return paths
+
+    @require_bitsandbytes
+    @pytest.mark.single_gpu_tests
+    def test_arrow_4bit_opt125m_load_and_generate_with_local_adapters(self, ts_adapters_opt):
+        model_id = "peft-internal-testing/opt-125m"
+
+        # Quantization config (nf4, bf16 compute)
+        bnb_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_quant_type="nf4",
+            bnb_4bit_compute_dtype=torch.bfloat16,
+            bnb_4bit_use_double_quant=False,
+        )
+
+        with hub_online_once(model_id):
+            # Load quantized base model
+            base_model = AutoModelForCausalLM.from_pretrained(
+                model_id,
+                dtype=torch.bfloat16,
+                device_map="auto",
+                quantization_config=bnb_config,
+            )
+            with hub_online_once(model_id + "tokenizer"):
+                tok = AutoTokenizer.from_pretrained(model_id, use_fast=True)
+
+        # Build Arrow model from the locally created adapters
+        arrow_cfg = ArrowConfig(top_k=2, router_temperature=1.0, rng_seed=42)
+        model = create_arrow_model(
+            base_model=base_model,
+            task_specific_adapter_paths=ts_adapters_opt,  # local dirs (each has adapter_config.json)
+            arrow_config=arrow_cfg,
+        ).eval()
+
+        # Quick generate smoke test
+        inputs = tok("Hello world", return_tensors="pt")
+        inputs = {k: v.to(model.device) for k, v in inputs.items()}
+        with torch.no_grad():
+            out = model.generate(**inputs, max_new_tokens=8)
+
+        assert out is not None
+        assert out.shape[0] == 1  # batch size 1
+
+
+@require_non_cpu
+@require_bitsandbytes
+class TestDtypeAutocastBnb:
+    """Ensure that the dtype of the PEFT weights have the expected value, even when using quantized base models.
+
+    The autocast argument should be honored.
+
+    """
+
+    model_id = "trl-internal-testing/tiny-Qwen2ForCausalLM-2.5"
+    # no need to check each possible peft type, a selection should be enough
+    peft_types_to_test = ["lora", "vera", "lora-target-param"]
+
+    def check_dtype(self, quant_config, autocast_adapter_dtype, base_dtype, expected_dtype, peft_type, tmp_path=None):
+        """helper function that creates the PEFT model and checks that the dtype of the PEFT adapter is as expected.
+
+        Checks:
+        - get_peft_model
+        - add_adapter
+        - PeftModel.from_pretrained
+        - load_adapter
+        """
+        if peft_type == "lora":
+            peft_config = LoraConfig()
+        elif peft_type == "vera":
+            peft_config = VeraConfig()
+        elif peft_type == "lora-target-param":
+            peft_config = LoraConfig(target_modules=[], target_parameters=["q_proj.weight", "v_proj.weight"])
+        else:
+            raise ValueError("Argument must be one of 'lora' or 'vera'")
+
+        with hub_online_once(self.model_id):
+            model = AutoModelForCausalLM.from_pretrained(
+                self.model_id,
+                quantization_config=quant_config,
+                dtype=base_dtype,
+                device_map="auto",
+            )
+            model = get_peft_model(model, peft_config, autocast_adapter_dtype=autocast_adapter_dtype)
+            if peft_type != "lora-target-param":
+                # target_parameters does not allow multiple adapters on the same parameter
+                model.add_adapter("other", peft_config, autocast_adapter_dtype=autocast_adapter_dtype)
+            peft_params = [p for n, p in model.named_parameters() if model.prefix in n]
+            assert all(p.dtype == expected_dtype for p in peft_params)
+
+            model.save_pretrained(tmp_path)
+            del model
+
+            model = AutoModelForCausalLM.from_pretrained(
+                self.model_id,
+                quantization_config=quant_config,
+                dtype=base_dtype,
+                device_map="auto",
+            )
+            model = PeftModel.from_pretrained(model, tmp_path, autocast_adapter_dtype=autocast_adapter_dtype)
+            if peft_type != "lora-target-param":
+                # target_parameters does not allow multiple adapters on the same parameter
+                model.load_adapter(
+                    tmp_path / "other", adapter_name="other", autocast_adapter_dtype=autocast_adapter_dtype
+                )
+            peft_params = [p for n, p in model.named_parameters() if model.prefix in n]
+            assert all(p.dtype == expected_dtype for p in peft_params)
+
+    @pytest.mark.parametrize("peft_type", peft_types_to_test)
+    @pytest.mark.parametrize("base_dtype", [torch.float32, torch.float16, torch.bfloat16])
+    def test_lora_no_quantization_dtype_no_autocast(self, base_dtype, peft_type, tmp_path):
+        # sanity check that without bnb, everything works as expected
+        quant_config = None
+        self.check_dtype(
+            quant_config,
+            autocast_adapter_dtype=False,
+            base_dtype=base_dtype,
+            expected_dtype=base_dtype,
+            peft_type=peft_type,
+            tmp_path=tmp_path,
+        )
+
+    @pytest.mark.parametrize("peft_type", peft_types_to_test)
+    @pytest.mark.parametrize("base_dtype", [torch.float32, torch.float16, torch.bfloat16])
+    def test_lora_no_quantization_dtype_autocast(self, base_dtype, peft_type, tmp_path):
+        # sanity check that without bnb, everything works as expected
+        quant_config = None
+        self.check_dtype(
+            quant_config,
+            autocast_adapter_dtype=True,
+            base_dtype=base_dtype,
+            expected_dtype=torch.float32,
+            peft_type=peft_type,
+            tmp_path=tmp_path,
+        )
+
+    @pytest.mark.parametrize("peft_type", peft_types_to_test)
+    @pytest.mark.parametrize("base_dtype", [torch.float32, torch.float16, torch.bfloat16])
+    def test_lora_4bit_bnb_dtype_no_autocast(self, base_dtype, peft_type, tmp_path):
+        # Ensure that the compute dtype of the 4bit weights is honored, see #2889
+        quant_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_compute_dtype=base_dtype,
+            bnb_4bit_use_double_quant=True,
+            bnb_4bit_quant_type="nf4",
+        )
+        self.check_dtype(
+            quant_config,
+            autocast_adapter_dtype=False,
+            base_dtype=base_dtype,
+            expected_dtype=base_dtype,
+            peft_type=peft_type,
+            tmp_path=tmp_path,
+        )
+
+    @pytest.mark.parametrize("peft_type", peft_types_to_test)
+    @pytest.mark.parametrize("base_dtype", [torch.float32, torch.float16, torch.bfloat16])
+    def test_lora_4bit_bnb_dtype_autocast(self, base_dtype, peft_type, tmp_path):
+        # With autocast, the adapter weights should always be in float32
+        quant_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_compute_dtype=base_dtype,
+            bnb_4bit_use_double_quant=True,
+            bnb_4bit_quant_type="nf4",
+        )
+        self.check_dtype(
+            quant_config,
+            autocast_adapter_dtype=True,
+            base_dtype=base_dtype,
+            expected_dtype=torch.float32,
+            peft_type=peft_type,
+            tmp_path=tmp_path,
+        )
+
+    @pytest.mark.parametrize("peft_type", peft_types_to_test)
+    def test_lora_4bit_bnb_dtype_no_autocast_compute_dtype_diverges(self, peft_type, tmp_path):
+        # In this test, the compute dtype of the bnb weights and the dtype of the base model diverge. In this case the
+        # bnb dtype should 'win'.
+        quant_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_compute_dtype=torch.bfloat16,
+            bnb_4bit_use_double_quant=True,
+            bnb_4bit_quant_type="nf4",
+        )
+        self.check_dtype(
+            quant_config,
+            autocast_adapter_dtype=False,
+            base_dtype=torch.float16,
+            expected_dtype=torch.bfloat16,
+            peft_type=peft_type,
+            tmp_path=tmp_path,
+        )
+
+    @pytest.mark.parametrize("peft_type", peft_types_to_test)
+    @pytest.mark.parametrize("base_dtype", [torch.float16, torch.bfloat16])
+    @pytest.mark.xfail(reason="Currently, dtype casting with 8bit bnb does not work", strict=True)
+    def test_lora_8bit_bnb_dtype_no_autocast(self, base_dtype, peft_type, tmp_path):
+        # With 8bit bnb, the base layer carries no information about the intended dtype, thus we cannot cast to the same dtype
+        quant_config = BitsAndBytesConfig(load_in_8bit=True)
+        self.check_dtype(
+            quant_config,
+            autocast_adapter_dtype=False,
+            base_dtype=base_dtype,
+            expected_dtype=base_dtype,
+            peft_type=peft_type,
+            tmp_path=tmp_path,
+        )
+
+    @pytest.mark.parametrize("peft_type", peft_types_to_test)
+    def test_lora_8bit_bnb_dtype_no_autocast_float32(self, peft_type, tmp_path):
+        # for 8bit bnb with float32, everything works as expected
+        # TODO: once dtype != float32 works, merge this test with the one above
+        quant_config = BitsAndBytesConfig(load_in_8bit=True)
+        base_dtype = torch.float32
+        self.check_dtype(
+            quant_config,
+            autocast_adapter_dtype=False,
+            base_dtype=base_dtype,
+            expected_dtype=base_dtype,
+            peft_type=peft_type,
+            tmp_path=tmp_path,
+        )
+
+    @pytest.mark.parametrize("peft_type", peft_types_to_test)
+    @pytest.mark.parametrize("base_dtype", [torch.float16, torch.bfloat16])
+    def test_lora_8bit_bnb_dtype_autocast(self, base_dtype, peft_type, tmp_path):
+        # With 8bit bnb, the base layer carries no information about the intended dtype, thus we cannot cast to the same dtype
+        quant_config = BitsAndBytesConfig(load_in_8bit=True)
+        self.check_dtype(
+            quant_config,
+            autocast_adapter_dtype=True,
+            base_dtype=base_dtype,
+            expected_dtype=torch.float32,
+            peft_type=peft_type,
+            tmp_path=tmp_path,
+        )
+
+    @pytest.mark.parametrize("peft_type", peft_types_to_test)
+    def test_lora_8bit_bnb_dtype_autocast_float32(self, peft_type, tmp_path):
+        # for 8bit bnb with float32, everything works as expected
+        # TODO: once dtype != float32 works, merge this test with the one above
+        base_dtype = torch.float32
+        quant_config = BitsAndBytesConfig(load_in_8bit=True)
+        self.check_dtype(
+            quant_config,
+            autocast_adapter_dtype=True,
+            base_dtype=base_dtype,
+            expected_dtype=torch.float32,
+            peft_type=peft_type,
+            tmp_path=tmp_path,
+        )
+
+
+if is_te_available():
+    import transformer_engine as te
+
+    from peft.tuners.lora.te import TeLinear
+
+
+def _replace_with_te_linear(model, target_module_names):
+    """Replace nn.Linear modules whose short name is in target_module_names with te.pytorch.Linear.
+
+    Weights and biases are copied from the original module. The replacement is done *in-place* (via ``setattr`` on the
+    parent module).
+    """
+    replacements = []
+    for name, module in model.named_modules():
+        short_name = name.rsplit(".", 1)[-1] if "." in name else name
+        if short_name in target_module_names and isinstance(module, torch.nn.Linear):
+            replacements.append((name, short_name, module))
+
+    for name, short_name, module in replacements:
+        parent_name = name.rsplit(".", 1)[0] if "." in name else ""
+        parent = model.get_submodule(parent_name) if parent_name else model
+
+        te_linear = te.pytorch.Linear(
+            module.in_features,
+            module.out_features,
+            bias=module.bias is not None,
+            params_dtype=module.weight.dtype,
+            device=module.weight.device,
+        )
+        with torch.no_grad():
+            te_linear.weight.copy_(module.weight)
+            if module.bias is not None:
+                te_linear.bias.copy_(module.bias)
+
+        setattr(parent, short_name, te_linear)
+
+
+@pytest.mark.skipif(not is_te_available(), reason="transformer_engine is not available")
+class TestTransformerEngine:
+    """Tests for LoRA with TransformerEngine layers.
+
+    Uses a standard OPT model with selected nn.Linear layers manually replaced by te.pytorch.Linear.
+    """
+
+    model_id = "facebook/opt-125m"
+    te_target_modules = ["q_proj", "v_proj"]
+
+    @pytest.fixture
+    def model_with_te_layers(self):
+        model = AutoModelForCausalLM.from_pretrained(self.model_id, torch_dtype=torch.bfloat16)
+        _replace_with_te_linear(model, self.te_target_modules)
+        return model
+
+    @pytest.fixture
+    def tokenizer(self):
+        return AutoTokenizer.from_pretrained(self.model_id)
+
+    @pytest.fixture
+    def tokenized_inputs(self, tokenizer):
+        return tokenizer("Hello world", return_tensors="pt")
+
+    @require_torch_gpu
+    @pytest.mark.single_gpu_tests
+    def test_te_lora_wraps_te_linear_and_keeps_forward_working(self, model_with_te_layers, tokenized_inputs):
+        cfg = LoraConfig(target_modules=self.te_target_modules, r=2, lora_alpha=8)
+        lora_model = get_peft_model(model_with_te_layers, cfg).to("cuda")
+
+        wrapped_q_proj = lora_model.base_model.model.model.decoder.layers[0].self_attn.q_proj
+
+        assert isinstance(wrapped_q_proj, TeLinear)
+        assert "default" in wrapped_q_proj.lora_A and "default" in wrapped_q_proj.lora_B
+        assert wrapped_q_proj.get_base_layer().weight.requires_grad is False
+        assert wrapped_q_proj.lora_A["default"].weight.requires_grad is True
+        assert wrapped_q_proj.lora_B["default"].weight.requires_grad is True
+
+        inputs = {k: v.to("cuda") for k, v in tokenized_inputs.items()}
+        out = lora_model(**inputs)
+        assert out.logits.ndim == 3
+
+    @require_torch_gpu
+    @pytest.mark.single_gpu_tests
+    def test_te_lora_forward_matches_base_before_backward(self, model_with_te_layers, tokenized_inputs):
+        base_model = deepcopy(model_with_te_layers).to("cuda")
+        cfg = LoraConfig(target_modules=self.te_target_modules, r=4, lora_alpha=8)
+        lora_model = get_peft_model(model_with_te_layers, cfg).to("cuda")
+
+        inputs = {k: v.to("cuda") for k, v in tokenized_inputs.items()}
+        lora_model.eval()
+        base_model.eval()
+        with torch.no_grad():
+            lora_result = lora_model(**inputs).logits
+            base_result = base_model(**inputs).logits
+
+        assert torch.allclose(lora_result, base_result, rtol=1e-3, atol=1e-3)
+
+    @require_torch_gpu
+    @pytest.mark.single_gpu_tests
+    def test_te_lora_backward(self, model_with_te_layers, tokenized_inputs):
+        cfg = LoraConfig(target_modules=self.te_target_modules, r=4, lora_alpha=8)
+        lora_model = get_peft_model(model_with_te_layers, cfg).to("cuda")
+
+        optimizer = torch.optim.AdamW(lora_model.parameters())
+        loss_fn = torch.nn.CrossEntropyLoss()
+        inputs = {k: v.to("cuda") for k, v in tokenized_inputs.items()}
+        logits = lora_model(**inputs).logits
+        shift_logits = logits[:, :-1, :].contiguous()
+        shift_labels = inputs["input_ids"][:, 1:].contiguous()
+        loss = loss_fn(shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1))
+        assert torch.isfinite(loss), f"Loss is not finite: {loss.item()}"
+        loss.backward()
+        optimizer.step()
+
+
+@pytest.mark.skipif(not hasattr(torch, "float8_e4m3fn"), reason="Platform does not support torch.float8_e4m3fn")
+@require_torch_gpu
+@pytest.mark.single_gpu_tests
+class TestDtypeFp8:
+    """Tests that float8 models work.
+
+    Note that at this time, these lower dtypes require a GPU, so these tests cannot be added to the standard CPU test
+    suite.
+    """
+
+    @pytest.fixture(scope="class", autouse=True)
+    def setup_cleanup(self):
+        yield
+        clear_device_cache(garbage_collection=True)
+
+    @pytest.fixture
+    def model_high_prec(self):
+        model_id = "facebook/opt-125m"
+        model = AutoModelForCausalLM.from_pretrained(model_id, device_map=0)
+        return model
+
+    @pytest.fixture
+    def model_low_prec(self):
+        model_id = "facebook/opt-125m"
+        # only convert q_proj to fp8, otherwise we get nan results
+        modules_not_to_convert = ["embed_tokens", "lm_head", "v_proj", "k_proj", "out_proj", "fc1", "fc2"]
+        model = AutoModelForCausalLM.from_pretrained(
+            model_id,
+            device_map=0,
+            quantization_config=FineGrainedFP8Config(
+                modules_to_not_convert=modules_not_to_convert,
+            ),
+        )
+        # sanity check
+        assert model.model.decoder.layers[0].self_attn.q_proj.weight.dtype == torch.float8_e4m3fn
+        return model
+
+    @pytest.mark.parametrize(
+        "config",
+        [
+            LoraConfig(target_modules=["q_proj", "v_proj"], init_lora_weights=False),
+            VeraConfig(target_modules=["q_proj", "v_proj"], init_weights=False),
+            RoadConfig(target_modules=["q_proj", "v_proj"], init_weights=False),
+        ],
+        ids=lambda c: c.__class__.__name__,
+    )
+    def test_target_modules_float8_e4m3fn(self, model_high_prec, model_low_prec, config):
+        # Test should work with all adapters, but only testing a few here to save time and resources.
+        inputs = torch.arange(10).view(1, -1).to(model_low_prec.device)
+
+        # high precision
+        torch.manual_seed(0)
+        model_high_prec = get_peft_model(model_high_prec, config)
+        with torch.inference_mode():
+            # check that there are no errors
+            output_high_prec = model_high_prec(inputs).logits
+
+        # low precision
+        torch.manual_seed(0)
+        model_low_prec = get_peft_model(model_low_prec, config)
+        with torch.inference_mode():
+            # check that there are no errors
+            output_low_prec = model_low_prec(inputs).logits
+        # sanity check
+        assert torch.isfinite(output_low_prec).all()
+
+        # use relatively high tolerances because of low precision dtype
+        mse = ((output_low_prec - output_high_prec) ** 2).mean()
+        assert mse < 0.05
+
+    @pytest.mark.parametrize(
+        "config",
+        [
+            LoraConfig(target_modules=["q_proj", "v_proj"], init_lora_weights=False),
+            VeraConfig(target_modules=["q_proj", "v_proj"], init_weights=False),
+            RoadConfig(target_modules=["q_proj", "v_proj"], init_weights=False),
+        ],
+        ids=lambda c: c.__class__.__name__,
+    )
+    @pytest.mark.xfail(reason="Merging with float8 not supported (yet)", strict=True)
+    def test_merge_with_float8_e4m3fn(self, model_high_prec, model_low_prec, config):
+        # Test should work with all adapters, but only testing a few here to save time and resources.
+        inputs = torch.arange(10).view(1, -1).to(model_low_prec.device)
+
+        # high precision
+        torch.manual_seed(0)
+        model_high_prec = get_peft_model(model_high_prec, config).merge_and_unload()
+        with torch.inference_mode():
+            # check that there are no errors
+            output_high_prec = model_high_prec(inputs).logits
+
+        # low precision
+        torch.manual_seed(0)
+        model_low_prec = get_peft_model(model_low_prec, config).merge_and_unload()
+        with torch.inference_mode():
+            # check that there are no errors
+            output_low_prec = model_low_prec(inputs).logits
+        # sanity check
+        assert torch.isfinite(output_low_prec).all()
+
+        # use relatively high tolerances because of low precision dtype
+        mse = ((output_low_prec - output_high_prec) ** 2).mean()
+        assert mse < 0.05
+
+    def test_lora_target_parameters_float8_e4m3fn(self, model_high_prec, model_low_prec):
+        inputs = torch.arange(10).view(1, -1).to(model_low_prec.device)
+
+        # high precision
+        torch.manual_seed(0)
+        config = LoraConfig(
+            target_modules=["k_proj", "v_proj"], target_parameters=["q_proj.weight"], init_lora_weights=False
+        )
+        model_high_prec = get_peft_model(model_high_prec, config)
+        with torch.inference_mode():
+            # check that there are no errors
+            output_high_prec = model_high_prec(inputs).logits
+
+        # low precision
+        torch.manual_seed(0)
+        model_low_prec = get_peft_model(model_low_prec, config)
+        with torch.inference_mode():
+            # check that there are no errors
+            output_low_prec = model_low_prec(inputs).logits
+        # sanity check
+        assert torch.isfinite(output_low_prec).all()
+
+        # use relatively high tolerances because of low precision dtype
+        mse = ((output_low_prec - output_high_prec) ** 2).mean()
+        assert mse < 0.05
+
+    def test_target_modules_no_autocast_prevserves_e4m3fn(self, model_low_prec):
+        # ensure that users can choose to keep the adapter weights in the same dtype as the original weights by passing
+        # autocast_adapter_dtype=False, even though the resulting model is not usable (no inference or training
+        # possible)
+        config = LoraConfig(target_modules=["q_proj", "v_proj"], init_lora_weights=False)
+        model = get_peft_model(model_low_prec, config, autocast_adapter_dtype=False)
+        q_proj = model.base_model.model.model.decoder.layers[0].self_attn.q_proj
+        assert q_proj.lora_A.default.weight.dtype == torch.float8_e4m3fn
+        assert q_proj.lora_B.default.weight.dtype == torch.float8_e4m3fn
+
+
+### LoRA and Tensor Parallelism tests ###
+
+WORLD_SIZE = 2
+TINY_MODEL_ID = "peft-internal-testing/zephyr-smol_llama-100m-sft-full"
+TARGET_MODULES = ["embed_tokens", "q_proj", "k_proj", "v_proj", "o_proj"]
+
+TIMEOUT_BARRIER = datetime.timedelta(seconds=30)
+
+TP_PLAN = {
+    "model.embed_tokens": "embedding_rowwise",
+    "model.layers.*.self_attn.q_proj": "colwise",
+    "model.layers.*.self_attn.k_proj": "colwise",
+    "model.layers.*.self_attn.v_proj": "colwise",
+    "model.layers.*.self_attn.o_proj": "rowwise",
+    "model.layers.*.mlp.gate_proj": "colwise",
+    "model.layers.*.mlp.up_proj": "colwise",
+    "model.layers.*.mlp.down_proj": "rowwise",
+}
+
+
+def _find_free_port():
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("", 0))
+        return s.getsockname()[1]
+
+
+_BASE_PORT = _find_free_port()
+
+
+def _setup_dist(rank, world_size, port):
+    os.environ["MASTER_ADDR"] = "localhost"
+    os.environ["MASTER_PORT"] = str(port)
+    os.environ["LOCAL_RANK"] = str(rank)
+    os.environ["RANK"] = str(rank)
+    os.environ["WORLD_SIZE"] = str(rank)
+    dist.init_process_group(backend="gloo", rank=rank, world_size=world_size)
+
+
+def _teardown_dist():
+    dist.destroy_process_group()
+
+
+def _test_function_wrapper(fn, rank, world_size, port, *extra_args):
+    try:
+        _setup_dist(rank, world_size, port)
+        fn(rank, world_size, port, *extra_args)
+    finally:
+        _teardown_dist()
+
+
+def _test_lora_weight_synchronization(rank, world_size, port):
+    """
+    Test that non-sharded LoRA weights are identical across ranks after training step.
+    """
+    model = AutoModelForCausalLM.from_pretrained(TINY_MODEL_ID, tp_plan=TP_PLAN)
+    lora_config = LoraConfig(r=4, target_modules=TARGET_MODULES, init_lora_weights=True)
+    model = get_peft_model(model, lora_config)
+
+    torch.cuda.set_device(rank)
+    device = torch.device("cuda", rank)
+    model.to(device)
+
+    tokenizer = AutoTokenizer.from_pretrained(TINY_MODEL_ID)
+    inputs = tokenizer("Paris is the most beautiful city in the world.", return_tensors="pt")
+    inputs = {k: v.to(device) for k, v in inputs.items()}
+
+    model.train()
+    optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3)
+
+    # Test that loss is finite and decreases over multiple steps
+    for _ in range(3):
+        outputs = model(**inputs, labels=inputs["input_ids"])
+        loss = outputs.loss
+        assert torch.isfinite(loss), f"Loss is not finite: {loss}"
+        loss.backward()
+        optimizer.step()
+        optimizer.zero_grad()
+
+    # Test that non-sharded LoRA weights are identical across ranks after training step
+    for name, module in model.named_modules():
+        if not isinstance(module, LoraLayer):
+            continue
+        base_layer = module.get_base_layer()
+        tp_plan = getattr(base_layer, "_hf_tp_plan", None)
+        if tp_plan == "colwise":
+            weight = module.lora_A["default"].weight.data.contiguous()
+            gathered = [torch.zeros_like(weight) for _ in range(world_size)]
+            dist.all_gather(gathered, weight)
+            for i, g in enumerate(gathered):
+                assert torch.allclose(weight, g), f"{name}.lora_A differs between rank {rank} and rank {i}"
+        elif tp_plan == "rowwise":
+            weight = module.lora_B["default"].weight.data.contiguous()
+            gathered = [torch.zeros_like(weight) for _ in range(world_size)]
+            dist.all_gather(gathered, weight)
+            for i, g in enumerate(gathered):
+                assert torch.allclose(weight, g), f"{name}.lora_B differs between rank {rank} and rank {i}"
+        elif tp_plan == "embedding_rowwise":
+            weight = module.lora_embedding_B["default"].data.contiguous()
+            gathered = [torch.zeros_like(weight) for _ in range(world_size)]
+            dist.all_gather(gathered, weight)
+            for i, g in enumerate(gathered):
+                assert torch.allclose(weight, g), f"{name}.lora_embedding_B differs between rank {rank} and rank {i}"
+
+
+def _test_load_from_checkpoint(rank, world_size, port, tmp_dir):
+    """
+    Test that loading from a checkpoint correctly handles the sharding of LoRA weights according to the TP plan.
+    """
+    if rank == 0:
+        plain_model = AutoModelForCausalLM.from_pretrained(TINY_MODEL_ID)
+        lora_config = LoraConfig(r=4, target_modules=TARGET_MODULES, init_lora_weights=True)
+        plain_model = get_peft_model(plain_model, lora_config)
+        plain_model.save_pretrained(tmp_dir)
+
+    dist.monitored_barrier(timeout=TIMEOUT_BARRIER, wait_all_ranks=True)
+
+    torch.cuda.set_device(rank)
+    device = torch.device("cuda", rank)
+
+    tp_base = AutoModelForCausalLM.from_pretrained(TINY_MODEL_ID, tp_plan=TP_PLAN)
+    tp_base.to(device)
+    tp_model = PeftModel.from_pretrained(tp_base, tmp_dir)
+
+    for name, module in tp_model.named_modules():
+        if not isinstance(module, LoraLayer):
+            continue
+        base_layer = module.get_base_layer()
+        tp_plan = getattr(base_layer, "_hf_tp_plan", None)
+        if tp_plan == "colwise":
+            # lora_B output dim must match base layer output dim
+            lora_b_out = module.lora_B["default"].weight.shape[0]
+            base_layer_out = base_layer.weight.shape[0]
+            assert lora_b_out == base_layer_out, (
+                f"{name}: lora_B out_dim {lora_b_out} != local base out_dim {base_layer_out}"
+            )
+        elif tp_plan == "rowwise":
+            # lora_A input dim must match base layer input dim
+            lora_a_in = module.lora_A["default"].weight.shape[1]
+            base_layer_in = base_layer.weight.shape[1]
+            assert lora_a_in == base_layer_in, (
+                f"{name}: lora_A in_dim {lora_a_in} != local base in_dim {base_layer_in}"
+            )
+        elif tp_plan == "embedding_rowwise":
+            # lora_embedding_A vocab size must match base layer vocab size
+            lora_emb_vocab = module.lora_embedding_A["default"].shape[1]  # Lora embedding weights are (r, vocab_size)
+            base_emb_vocab = base_layer.weight.shape[0]
+            assert lora_emb_vocab == base_emb_vocab, (
+                f"{name}: lora_embedding_A vocab {lora_emb_vocab} != local base vocab {base_emb_vocab}"
+            )
+
+    tokenizer = AutoTokenizer.from_pretrained(TINY_MODEL_ID)
+    inputs = tokenizer("The capital of France is Paris.", return_tensors="pt")
+    inputs = {k: v.to(device) for k, v in inputs.items()}
+    tp_model.eval()
+    with torch.no_grad():
+        outputs = tp_model(**inputs, labels=inputs["input_ids"])
+    assert torch.isfinite(outputs.loss), f"Loss not finite after checkpoint load: {outputs.loss}"
+
+
+def _test_save_unsharded_weights(rank, world_size, port, tmp_dir_reference, tmp_dir_tp):
+    """
+    Test that saving a TP PEFT model produces fully unsharded weights identical to the original non-TP weights.
+
+    Flow:
+      1. Rank 0: create a plain (non-TP) PEFT model, save it as the reference.
+      2. All ranks: load the TP base model, load the reference PEFT weights (shards on load), then save again.
+      3. Rank 0: compare the re-saved state dict against the original reference, they must match exactly.
+    """
+    if rank == 0:
+        plain_model = AutoModelForCausalLM.from_pretrained(TINY_MODEL_ID)
+        lora_config = LoraConfig(r=4, target_modules=TARGET_MODULES, init_lora_weights=True)
+        plain_model = get_peft_model(plain_model, lora_config)
+        plain_model.save_pretrained(tmp_dir_reference)
+
+    dist.monitored_barrier(timeout=TIMEOUT_BARRIER, wait_all_ranks=True)
+
+    torch.cuda.set_device(rank)
+    device = torch.device("cuda", rank)
+
+    tp_base = AutoModelForCausalLM.from_pretrained(TINY_MODEL_ID, tp_plan=TP_PLAN)
+    tp_base.to(device)
+    tp_model = PeftModel.from_pretrained(tp_base, tmp_dir_reference)
+    tp_model.save_pretrained(tmp_dir_tp)
+
+    dist.monitored_barrier(timeout=TIMEOUT_BARRIER, wait_all_ranks=True)
+
+    if rank == 0:
+        reference_sd = load_file(f"{tmp_dir_reference}/adapter_model.safetensors")
+        saved_sd = load_file(f"{tmp_dir_tp}/adapter_model.safetensors")
+
+        assert set(reference_sd.keys()) == set(saved_sd.keys()), (
+            f"State dict keys differ.\n  reference: {sorted(reference_sd.keys())}\n  saved: {sorted(saved_sd.keys())}"
+        )
+        for key in reference_sd:
+            assert torch.allclose(reference_sd[key], saved_sd[key], atol=1e-6), (
+                f"Weight mismatch for '{key}': max diff = {(reference_sd[key] - saved_sd[key]).abs().max()}"
+            )
+
+
+def _test_multiple_adapters(rank, world_size, port):
+    """Two LoRA adapters coexist on a TP model and can be switched between."""
+    torch.cuda.set_device(rank)
+    device = torch.device("cuda", rank)
+    model = AutoModelForCausalLM.from_pretrained(TINY_MODEL_ID, tp_plan=TP_PLAN)
+    model.to(device)
+
+    for adapter_name in ["adapter_a", "adapter_b"]:
+        lora_config = LoraConfig(r=4, target_modules=TARGET_MODULES, init_lora_weights=True)
+        model = get_peft_model(model, lora_config, adapter_name=adapter_name)
+
+    tokenizer = AutoTokenizer.from_pretrained(TINY_MODEL_ID)
+    inputs = tokenizer("What is the capital of France?", return_tensors="pt")
+    inputs = {k: v.to(device) for k, v in inputs.items()}
+    model.eval()
+    with torch.no_grad():
+        for adapter_name in ["adapter_a", "adapter_b"]:
+            model.set_adapter(adapter_name)
+            outputs = model(**inputs, labels=inputs["input_ids"])
+            assert torch.isfinite(outputs.loss), f"Loss not finite with adapter '{adapter_name}': {outputs.loss}"
+
+
+def _test_load_adapter_forward(rank, world_size, port, tmp_dir_reference):
+    """
+    Test that load_adapter (with a peft_config) works with a TP base model and the forward pass produces the same loss
+    on every rank and that it is finite.
+
+    This exercises the low-level API path where no PeftModel/tuner is created, so TP info must be stored on the lora
+    modules themselves (via _tp_info) rather than on the tuner.
+    """
+    torch.cuda.set_device(rank)
+    device = torch.device("cuda", rank)
+
+    if rank == 0:
+        plain_model = AutoModelForCausalLM.from_pretrained(TINY_MODEL_ID)
+        lora_config = LoraConfig(r=4, target_modules=TARGET_MODULES, init_lora_weights=True)
+        plain_model = get_peft_model(plain_model, lora_config)
+        plain_model.save_pretrained(tmp_dir_reference)
+
+    dist.monitored_barrier(timeout=TIMEOUT_BARRIER, wait_all_ranks=True)
+
+    model = AutoModelForCausalLM.from_pretrained(TINY_MODEL_ID, tp_plan=TP_PLAN)
+    model.load_adapter(tmp_dir_reference)
+    model.to(device)
+
+    for mod in model.modules():
+        if isinstance(mod, LoraLayer):
+            assert hasattr(mod, "_tp_info"), "load_adapter did not store TP info on the LoRA module"
+
+    tokenizer = AutoTokenizer.from_pretrained(TINY_MODEL_ID)
+    inputs = tokenizer("Paris is the capital of France.", return_tensors="pt")
+    inputs = {k: v.to(device) for k, v in inputs.items()}
+
+    model.eval()
+    with torch.no_grad():
+        outputs = model(**inputs, labels=inputs["input_ids"])
+
+    all_losses = [torch.empty_like(outputs.loss) for _ in range(world_size)]
+    dist.all_gather(all_losses, outputs.loss)
+
+    assert all(loss.item() == all_losses[0].item() for loss in all_losses), (
+        f"Losses differ across ranks: {[loss.item() for loss in all_losses]}"
+    )
+
+    assert torch.isfinite(outputs.loss), f"Loss is not finite: {outputs.loss}"
+
+
+def _test_load_adapter_save(rank, world_size, port, tmp_dir_reference, tmp_dir_tp):
+    """
+    Test that get_peft_model_state_dict correctly gathers unsharded TP weights when using load_adapter with a
+    peft_config.
+
+    Flow:
+      1. Rank 0: create a plain (non-TP) model, load adapter from config, save state dict as reference.
+      2. All ranks: load TP base model, load adapter from config, save state dict via get_peft_model_state_dict.
+      3. Rank 0: compare re-saved state dict against the reference, keys and values must match.
+    """
+    if rank == 0:
+        plain_model = AutoModelForCausalLM.from_pretrained(TINY_MODEL_ID)
+        lora_config = LoraConfig(r=4, target_modules=TARGET_MODULES, init_lora_weights=True)
+        plain_model = get_peft_model(plain_model, lora_config)
+        plain_model.save_pretrained(tmp_dir_reference)
+
+    dist.monitored_barrier(timeout=TIMEOUT_BARRIER, wait_all_ranks=True)
+
+    torch.cuda.set_device(rank)
+    device = torch.device("cuda", rank)
+
+    tp_base = AutoModelForCausalLM.from_pretrained(TINY_MODEL_ID, tp_plan=TP_PLAN)
+    tp_base.load_adapter(tmp_dir_reference)
+    tp_base.to(device)
+
+    tp_sd = get_peft_model_state_dict(tp_base)
+    if rank == 0:
+        tmp_dir_tp.mkdir(exist_ok=True)
+        save_file(tp_sd, f"{tmp_dir_tp}/adapter_model.safetensors")
+
+    dist.monitored_barrier(timeout=TIMEOUT_BARRIER, wait_all_ranks=True)
+
+    if rank == 0:
+        reference_sd = load_file(f"{tmp_dir_reference}/adapter_model.safetensors")
+        saved_sd = load_file(f"{tmp_dir_tp}/adapter_model.safetensors")
+
+        prefix = "base_model.model."
+        reference_sd = {k[len(prefix) :]: v for k, v in reference_sd.items() if k.startswith(prefix)}
+
+        assert set(reference_sd.keys()) == set(saved_sd.keys()), (
+            f"State dict keys differ.\n  reference: {sorted(reference_sd.keys())}\n  saved: {sorted(saved_sd.keys())}"
+        )
+        for key in reference_sd:
+            if reference_sd[key].shape != saved_sd[key].shape:
+                raise AssertionError(
+                    f"Shape mismatch for '{key}': reference shape {reference_sd[key].shape} vs saved shape "
+                    f"{saved_sd[key].shape}"
+                )
+            torch.testing.assert_close(
+                reference_sd[key].to(torch.bfloat16),
+                saved_sd[key].to(torch.bfloat16),
+                rtol=1e-5,
+                atol=1e-6,
+                msg=f"Weight mismatch for '{key}'",
+            )
+
+
+# transformers >= 5.4.0 is required for TP integration
+# transformers >= 5.6.0 is required for PreTrainedModel.load_adapter with TP models integration
+is_transformers_ge_v5_6_0 = packaging.version.parse(transformers.__version__) >= packaging.version.parse("5.6.0")
+
+
+@require_torch_gpu
+@pytest.mark.skipif(
+    not is_transformers_ge_v5_6_0, reason="transformers TP integration supported for transformers >= 5.6.0"
+)
+@pytest.mark.multi_gpu_tests
+class TestLoraTensorParallel:
+    def _spawn(self, fn, *extra_args, port_offset=0):
+        port = _BASE_PORT + port_offset
+        wrapped_fn = partial(_test_function_wrapper, fn)
+        mp.spawn(wrapped_fn, args=(WORLD_SIZE, port) + extra_args, nprocs=WORLD_SIZE, join=True)
+
+    def test_lora_weight_synchronization(self):
+        self._spawn(_test_lora_weight_synchronization, port_offset=0)
+
+    def test_from_checkpoint(self, tmp_path):
+        self._spawn(_test_load_from_checkpoint, tmp_path, port_offset=1)
+
+    def test_save_unsharded_weights(self, tmp_path):
+        tmp_dir_reference = tmp_path / "reference"
+        tmp_dir_tp = tmp_path / "tp"
+        self._spawn(_test_save_unsharded_weights, tmp_dir_reference, tmp_dir_tp, port_offset=3)
+
+    def test_multiple_adapters(self):
+        self._spawn(_test_multiple_adapters, port_offset=4)
+
+    def test_load_adapter_forward(self, tmp_path):
+        self._spawn(_test_load_adapter_forward, tmp_path, port_offset=5)
+
+    def test_load_adapter_save(self, tmp_path):
+        tmp_dir_reference = tmp_path / "reference"
+        tmp_dir_tp = tmp_path / "tp"
+        self._spawn(_test_load_adapter_save, tmp_dir_reference, tmp_dir_tp, port_offset=6)
+
+
+@pytest.mark.single_gpu_tests
+@require_bitsandbytes
+def test_kappatune_with_4bit_model():
+    """Test that KappaTune works with 4-bit quantized models on GPU."""
+    import torch
+    from transformers import AutoModelForCausalLM, BitsAndBytesConfig
+
+    from peft.helpers import find_kappa_target_modules
+
+    # Use a very small model for faster testing
+    quantization_config = BitsAndBytesConfig(
+        load_in_4bit=True,
+        bnb_4bit_compute_dtype=torch.float16,
+        bnb_4bit_quant_type="nf4",
+        bnb_4bit_use_double_quant=True,
+    )
+
+    model = AutoModelForCausalLM.from_pretrained(
+        "hf-internal-testing/tiny-random-LlamaForCausalLM",
+        quantization_config=quantization_config,
+        device_map="cuda",
+        torch_dtype=torch.float16,
+    )
+
+    # Run KappaTune
+    targets = find_kappa_target_modules(model, top_p=0.3)
+
+    # Basic assertions
+    assert isinstance(targets, dict)
+    assert "target_modules" in targets
+    assert isinstance(targets["target_modules"], list)
+    assert len(targets["target_modules"]) > 0, "Should return at least some target modules"
diff --git a/tests/test_helpers.py b/tests/test_helpers.py
new file mode 100644
index 0000000..14b097e
--- /dev/null
+++ b/tests/test_helpers.py
@@ -0,0 +1,732 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+
+import pytest
+import torch
+from diffusers import StableDiffusionPipeline
+from torch import nn
+from transformers import AutoModelForCausalLM, AutoTokenizer, Trainer, TrainingArguments
+
+from peft import LoraConfig, get_peft_model
+from peft.helpers import (
+    DoraCaching,
+    MontecloraTrainerMixin,
+    check_if_peft_model,
+    disable_input_dtype_casting,
+    rescale_adapter_scale,
+)
+from peft.tuners.lora.config import MontecloraConfig
+from peft.tuners.lora.layer import LoraLayer
+from peft.tuners.lora.monteclora import MontecloraSampler
+from peft.utils import infer_device
+
+from .testing_utils import hub_online_once
+
+
+class TestCheckIsPeftModel:
+    def test_valid_hub_model(self):
+        result = check_if_peft_model("peft-internal-testing/gpt2-lora-random")
+        assert result is True
+
+    def test_invalid_hub_model(self):
+        result = check_if_peft_model("gpt2")
+        assert result is False
+
+    def test_nonexisting_hub_model(self):
+        result = check_if_peft_model("peft-internal-testing/non-existing-model")
+        assert result is False
+
+    def test_local_model_valid(self, tmp_path):
+        model = AutoModelForCausalLM.from_pretrained("gpt2")
+        config = LoraConfig()
+        model = get_peft_model(model, config)
+        model.save_pretrained(tmp_path / "peft-gpt2-valid")
+        result = check_if_peft_model(tmp_path / "peft-gpt2-valid")
+        assert result is True
+
+    def test_local_model_invalid(self, tmp_path):
+        model = AutoModelForCausalLM.from_pretrained("gpt2")
+        model.save_pretrained(tmp_path / "peft-gpt2-invalid")
+        result = check_if_peft_model(tmp_path / "peft-gpt2-invalid")
+        assert result is False
+
+    def test_local_model_broken_config(self, tmp_path):
+        with open(tmp_path / "adapter_config.json", "w") as f:
+            f.write('{"foo": "bar"}')
+
+        result = check_if_peft_model(tmp_path)
+        assert result is False
+
+    def test_local_model_non_default_name(self, tmp_path):
+        model = AutoModelForCausalLM.from_pretrained("gpt2")
+        config = LoraConfig()
+        model = get_peft_model(model, config, adapter_name="other")
+        model.save_pretrained(tmp_path / "peft-gpt2-other")
+
+        # no default adapter here
+        result = check_if_peft_model(tmp_path / "peft-gpt2-other")
+        assert result is False
+
+        # with adapter name
+        result = check_if_peft_model(tmp_path / "peft-gpt2-other" / "other")
+        assert result is True
+
+
+class TestScalingAdapters:
+    @pytest.fixture(scope="class")
+    def tokenizer(self):
+        return AutoTokenizer.from_pretrained("peft-internal-testing/opt-125m")
+
+    def get_scale_from_modules(self, model):
+        layer_to_scale_map = {}
+        for name, module in model.named_modules():
+            if isinstance(module, LoraLayer):
+                layer_to_scale_map[name] = module.scaling
+
+        return layer_to_scale_map
+
+    def test_rescale_adapter_scale(self, tokenizer):
+        model = AutoModelForCausalLM.from_pretrained("peft-internal-testing/opt-125m")
+        lora_config = LoraConfig(
+            r=4,
+            lora_alpha=4,
+            target_modules=["k_proj", "v_proj"],
+            lora_dropout=0.1,
+            bias="none",
+            init_lora_weights=False,
+        )
+
+        model = get_peft_model(model, lora_config)
+        model.eval()
+        inputs = tokenizer("hello world", return_tensors="pt")
+
+        with torch.no_grad():
+            logits_before_scaling = model(**inputs).logits
+
+        scales_before_scaling = self.get_scale_from_modules(model)
+
+        with rescale_adapter_scale(model=model, multiplier=0.5):
+            scales_during_scaling = self.get_scale_from_modules(model)
+            for key in scales_before_scaling.keys():
+                assert scales_before_scaling[key] != scales_during_scaling[key]
+
+            with torch.no_grad():
+                logits_during_scaling = model(**inputs).logits
+
+            assert not torch.allclose(logits_before_scaling, logits_during_scaling)
+
+        scales_after_scaling = self.get_scale_from_modules(model)
+        for key in scales_before_scaling.keys():
+            assert scales_before_scaling[key] == scales_after_scaling[key]
+
+        with torch.no_grad():
+            logits_after_scaling = model(**inputs).logits
+
+        assert torch.allclose(logits_before_scaling, logits_after_scaling)
+
+    def test_wrong_scaling_datatype(self):
+        model = AutoModelForCausalLM.from_pretrained("peft-internal-testing/opt-125m")
+        lora_config = LoraConfig(
+            r=4,
+            lora_alpha=4,
+            target_modules=["k_proj", "v_proj"],
+            lora_dropout=0.1,
+            bias="none",
+            init_lora_weights=False,
+        )
+
+        model = get_peft_model(model, lora_config)
+
+        # we expect a type error here because of wrong datatype of multiplier
+        multiplier = "a"
+        with pytest.raises(TypeError, match=f"Argument multiplier should be of type float, got {type(multiplier)}"):
+            with rescale_adapter_scale(model=model, multiplier=multiplier):
+                pass
+
+    def test_not_lora_model(self):
+        model = AutoModelForCausalLM.from_pretrained("peft-internal-testing/opt-125m")
+
+        # we expect a value error here because the model
+        # does not have lora layers
+        with pytest.raises(ValueError, match="scaling is only supported for models with `LoraLayer`s"):
+            with rescale_adapter_scale(model=model, multiplier=0.5):
+                pass
+
+    def test_scaling_set_to_zero(self, tokenizer):
+        base_model = AutoModelForCausalLM.from_pretrained("peft-internal-testing/opt-125m")
+        inputs = tokenizer("hello world", return_tensors="pt")
+
+        base_model.eval()
+
+        with torch.no_grad():
+            logits_base_model = base_model(**inputs).logits
+
+        lora_config = LoraConfig(
+            r=4,
+            lora_alpha=4,
+            target_modules=["k_proj", "v_proj"],
+            lora_dropout=0.1,
+            bias="none",
+            init_lora_weights=False,
+        )
+        lora_model = get_peft_model(base_model, lora_config)
+        lora_model.eval()
+
+        with rescale_adapter_scale(model=lora_model, multiplier=0.0):
+            with torch.no_grad():
+                logits_lora_model = lora_model(**inputs).logits
+
+        assert torch.allclose(logits_base_model, logits_lora_model)
+
+    def test_diffusers_pipeline(self):
+        model_id = "hf-internal-testing/tiny-sd-pipe"
+        pipeline = StableDiffusionPipeline.from_pretrained(model_id)
+
+        text_encoder_kwargs = {
+            "r": 8,
+            "lora_alpha": 32,
+            "target_modules": ["k_proj", "q_proj", "v_proj", "out_proj", "fc1", "fc2"],
+            "lora_dropout": 0.0,
+            "bias": "none",
+        }
+        unet_kwargs = {
+            "r": 8,
+            "lora_alpha": 32,
+            "target_modules": ["proj_in", "proj_out", "to_k", "to_q", "to_v", "to_out.0", "ff.net.0.proj", "ff.net.2"],
+            "lora_dropout": 0.0,
+            "bias": "none",
+        }
+
+        # Instantiate text_encoder adapter
+        config_text_encoder = LoraConfig(**text_encoder_kwargs)
+        pipeline.text_encoder = get_peft_model(pipeline.text_encoder, config_text_encoder)
+
+        # Instantiate unet adapter
+        config_unet = LoraConfig(**unet_kwargs)
+        pipeline.unet = get_peft_model(pipeline.unet, config_unet)
+
+        text_scales_before_scaling = self.get_scale_from_modules(pipeline.text_encoder)
+        unet_scales_before_scaling = self.get_scale_from_modules(pipeline.unet)
+
+        with (
+            rescale_adapter_scale(model=pipeline.text_encoder, multiplier=0.5),
+            rescale_adapter_scale(model=pipeline.unet, multiplier=0.5),
+        ):
+            text_scales_during_scaling = self.get_scale_from_modules(pipeline.text_encoder)
+            unet_scales_during_scaling = self.get_scale_from_modules(pipeline.unet)
+            for key in text_scales_before_scaling.keys():
+                assert text_scales_before_scaling[key] != text_scales_during_scaling[key]
+            for key in unet_scales_before_scaling.keys():
+                assert unet_scales_before_scaling[key] != unet_scales_during_scaling[key]
+
+        text_scales_fter_scaling = self.get_scale_from_modules(pipeline.text_encoder)
+        unet_scales_after_scaling = self.get_scale_from_modules(pipeline.unet)
+        for key in text_scales_before_scaling.keys():
+            assert text_scales_before_scaling[key] == text_scales_fter_scaling[key]
+        for key in unet_scales_before_scaling.keys():
+            assert unet_scales_before_scaling[key] == unet_scales_after_scaling[key]
+
+    def test_transformers_pipeline(self, tmp_path, tokenizer):
+        # this uses a transformers model that loads the adapter directly
+        model_id = "peft-internal-testing/opt-125m"
+        model = AutoModelForCausalLM.from_pretrained(model_id)
+        config = LoraConfig(init_lora_weights=False)
+        model = get_peft_model(model, config)
+        model.save_pretrained(tmp_path / "opt-lora")
+        del model
+
+        # load directly into transformers model
+        model = AutoModelForCausalLM.from_pretrained(model_id)
+        model.load_adapter(tmp_path / "opt-lora")
+
+        inputs = tokenizer("hello world", return_tensors="pt")
+
+        model = model.eval()
+
+        with torch.no_grad():
+            logits_before_scaling = model(**inputs).logits
+        scales_before_scaling = self.get_scale_from_modules(model)
+
+        with rescale_adapter_scale(model=model, multiplier=0.5):
+            scales_during_scaling = self.get_scale_from_modules(model)
+            for key in scales_before_scaling.keys():
+                assert scales_before_scaling[key] != scales_during_scaling[key]
+            with torch.no_grad():
+                logits_during_scaling = model(**inputs).logits
+            assert not torch.allclose(logits_before_scaling, logits_during_scaling)
+        scales_after_scaling = self.get_scale_from_modules(model)
+
+        for key in scales_before_scaling.keys():
+            assert scales_before_scaling[key] == scales_after_scaling[key]
+
+        with torch.no_grad():
+            logits_after_scaling = model(**inputs).logits
+
+        assert torch.allclose(logits_before_scaling, logits_after_scaling)
+
+    def test_multi_adapters(self, tokenizer):
+        model = AutoModelForCausalLM.from_pretrained("peft-internal-testing/opt-125m")
+        lora_config = LoraConfig(
+            r=4,
+            lora_alpha=4,
+            target_modules=["k_proj", "v_proj"],
+            lora_dropout=0.1,
+            bias="none",
+            init_lora_weights=False,
+        )
+        model = get_peft_model(model, lora_config)
+        inputs = tokenizer("hello world", return_tensors="pt")
+
+        # add another adapter and activate it
+        model.add_adapter("other", lora_config)
+        model.set_adapter("other")
+
+        scales_before_scaling = self.get_scale_from_modules(model)
+        model.eval()
+        with torch.no_grad():
+            logits_before = model(**inputs).logits
+
+        with rescale_adapter_scale(model=model, multiplier=0.5):
+            scales_during_scaling = self.get_scale_from_modules(model)
+            for key in scales_before_scaling.keys():
+                assert scales_before_scaling[key] != scales_during_scaling[key]
+
+            with torch.no_grad():
+                logits_during = model(**inputs).logits
+
+            assert not torch.allclose(logits_before, logits_during)
+
+        scales_after_scaling = self.get_scale_from_modules(model)
+        for key in scales_before_scaling.keys():
+            assert scales_before_scaling[key] == scales_after_scaling[key]
+
+        with torch.no_grad():
+            logits_after = model(**inputs).logits
+
+        assert torch.allclose(logits_before, logits_after)
+
+    def test_rank_alpha_pattern(self, tokenizer):
+        model = AutoModelForCausalLM.from_pretrained("peft-internal-testing/opt-125m")
+        lora_config = LoraConfig(
+            r=4,
+            lora_alpha=4,
+            target_modules=["k_proj", "v_proj"],
+            lora_dropout=0.1,
+            bias="none",
+            init_lora_weights=False,
+            rank_pattern={"k_proj": 2},
+            alpha_pattern={"k_proj": 8},
+        )
+
+        model = get_peft_model(model, lora_config)
+        model.eval()
+        inputs = tokenizer("hello world", return_tensors="pt")
+
+        with torch.no_grad():
+            logits_before_scaling = model(**inputs).logits
+
+        scales_before_scaling = self.get_scale_from_modules(model)
+
+        with rescale_adapter_scale(model=model, multiplier=0.5):
+            scales_during_scaling = self.get_scale_from_modules(model)
+            for key in scales_before_scaling.keys():
+                assert scales_before_scaling[key] != scales_during_scaling[key]
+
+            with torch.no_grad():
+                logits_during_scaling = model(**inputs).logits
+
+            assert not torch.allclose(logits_before_scaling, logits_during_scaling)
+
+        scales_after_scaling = self.get_scale_from_modules(model)
+        for key in scales_before_scaling.keys():
+            assert scales_before_scaling[key] == scales_after_scaling[key]
+
+        with torch.no_grad():
+            logits_after_scaling = model(**inputs).logits
+
+        assert torch.allclose(logits_before_scaling, logits_after_scaling)
+
+    def test_merging_adapter(self, tokenizer):
+        model = AutoModelForCausalLM.from_pretrained("peft-internal-testing/opt-125m")
+        lora_config = LoraConfig(
+            r=4,
+            lora_alpha=4,
+            target_modules=["k_proj", "v_proj"],
+            lora_dropout=0.1,
+            bias="none",
+            init_lora_weights=False,
+        )
+
+        model = get_peft_model(model, lora_config)
+        model.eval()
+        inputs = tokenizer("hello world", return_tensors="pt")
+
+        with rescale_adapter_scale(model=model, multiplier=0.5):
+            with torch.no_grad():
+                logits_unmerged_scaling = model(**inputs).logits
+            model = model.merge_and_unload()
+
+        with torch.no_grad():
+            logits_merged_scaling = model(**inputs).logits
+
+        assert torch.allclose(logits_merged_scaling, logits_unmerged_scaling, atol=1e-4, rtol=1e-4)
+
+
+class TestDisableInputDtypeCasting:
+    """Test the context manager `disable_input_dtype_casting` that temporarily disables input dtype casting
+    in the model.
+
+    The test works as follows:
+
+    We create a simple MLP and convert it to a PeftModel. The model dtype is set to float16. Then a pre-foward hook is
+    added that casts the model parameters to float32. Moreover, a post-forward hook is added that casts the weights
+    back to float16. The input dtype is float32.
+
+    Without the disable_input_dtype_casting context, what would happen is that PEFT detects that the input dtype is
+    float32 but the weight dtype is float16, so it casts the input to float16. Then the pre-forward hook casts the
+    weight to float32, which results in a RuntimeError.
+
+    With the disable_input_dtype_casting context, the input dtype is left as float32 and there is no error. We also add
+    a hook to record the dtype of the result from the LoraLayer to ensure that it is indeed float32.
+
+    """
+
+    device = infer_device()
+    dtype_record = []
+
+    @torch.no_grad()
+    def cast_params_to_fp32_pre_hook(self, module, input):
+        for param in module.parameters(recurse=False):
+            param.data = param.data.float()
+        return input
+
+    @torch.no_grad()
+    def cast_params_to_fp16_hook(self, module, input, output):
+        for param in module.parameters(recurse=False):
+            param.data = param.data.half()
+        return output
+
+    def record_dtype_hook(self, module, input, output):
+        self.dtype_record.append(output[0].dtype)
+
+    @pytest.fixture
+    def inputs(self):
+        return torch.randn(4, 10, device=self.device, dtype=torch.float32)
+
+    @pytest.fixture
+    def base_model(self):
+        class MLP(nn.Module):
+            def __init__(self, bias=True):
+                super().__init__()
+                self.lin0 = nn.Linear(10, 20, bias=bias)
+                self.lin1 = nn.Linear(20, 2, bias=bias)
+                self.sm = nn.LogSoftmax(dim=-1)
+
+            def forward(self, X):
+                X = self.lin0(X)
+                X = self.lin1(X)
+                X = self.sm(X)
+                return X
+
+        return MLP()
+
+    @pytest.fixture
+    def model(self, base_model):
+        config = LoraConfig(target_modules=["lin0"], modules_to_save=["lin1"])
+        model = get_peft_model(base_model, config).to(device=self.device, dtype=torch.float16)
+        # Register hooks on the submodule that holds parameters
+        for module in model.modules():
+            if sum(p.numel() for p in module.parameters()) > 0:
+                module.register_forward_pre_hook(self.cast_params_to_fp32_pre_hook)
+                module.register_forward_hook(self.cast_params_to_fp16_hook)
+            if isinstance(module, LoraLayer):
+                module.register_forward_hook(self.record_dtype_hook)
+        return model
+
+    def test_disable_input_dtype_casting_active(self, model, inputs):
+        self.dtype_record.clear()
+        with disable_input_dtype_casting(model, active=True):
+            model(inputs)
+        assert self.dtype_record == [torch.float32]
+
+    def test_no_disable_input_dtype_casting(self, model, inputs):
+        msg = r"expected m.*1 and m.*2 to have the same dtype"
+        with pytest.raises(RuntimeError, match=msg):
+            model(inputs)
+
+    def test_disable_input_dtype_casting_inactive(self, model, inputs):
+        msg = r"expected m.*1 and m.*2 to have the same dtype"
+        with pytest.raises(RuntimeError, match=msg):
+            with disable_input_dtype_casting(model, active=False):
+                model(inputs)
+
+    def test_disable_input_dtype_casting_inactive_after_existing_context(self, model, inputs):
+        # this is to ensure that when the context is left, we return to the previous behavior
+        with disable_input_dtype_casting(model, active=True):
+            model(inputs)
+
+        # after the context exited, we're back to the error
+        msg = r"expected m.*1 and m.*2 to have the same dtype"
+        with pytest.raises(RuntimeError, match=msg):
+            model(inputs)
+
+
+class TestDoraCaching:
+    # Check that DoRA caching works (same results with and without caching, cache is filled/cleared). Note that this test
+    # does not check the actual runtime benefit of caching, because this could be flaky and measuring it reliably and in
+    # realistic conditions is expensive. Run examples/dora_finetuning/dora-caching.py instead to measure this.
+    device = infer_device()
+
+    @pytest.fixture(autouse=True)
+    def disable_dora_caching(self):
+        # auto-fixture to ensure that no test accidentally permanently enables DoRA caching
+        DoraCaching()(enabled=False)
+
+    def get_caches(self, model):
+        # utility function to collect all the caches in the model
+        caches = []
+        for module in model.modules():
+            if hasattr(module, "_dora_cache"):
+                caches.append(module._dora_cache)
+        return caches
+
+    def get_output(self, model, inputs):
+        output = model(inputs)
+        if hasattr(output, "logits"):
+            return output.logits
+        return output
+
+    def test_dora_caching_linear(self):
+        # ensure that the results don't change due to caching
+        inputs = torch.arange(10).view(1, -1).to(self.device)
+        model_id = "trl-internal-testing/tiny-random-LlamaForCausalLM"
+        config = LoraConfig(init_lora_weights=False, use_dora=True)
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id).to(self.device)
+            self.check_dora_caching(model, config, inputs)
+
+    def test_dora_caching_embedding(self):
+        # ensure that the results don't change due to caching
+        inputs = torch.arange(10).view(1, -1).to(self.device)
+        model_id = "trl-internal-testing/tiny-random-LlamaForCausalLM"
+        config = LoraConfig(init_lora_weights=False, use_dora=True, target_modules=["model.embed_tokens"])
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id).to(self.device)
+            self.check_dora_caching(model, config, inputs)
+
+    def test_dora_caching_conv(self):
+        # ensure that the results don't change due to caching
+        # note: don't use something like small resnet, because batch norm affects outputs in train mode
+
+        class ModelConv2D(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.conv0 = nn.Conv2d(3, 5, kernel_size=3, stride=1, padding=1)
+                self.conv1 = nn.Conv2d(5, 5, kernel_size=3, stride=1, padding=1)
+                self.linear = nn.Linear(5 * 3 * 3, 10)
+
+            def forward(self, X):
+                X = self.conv0(X)
+                X = nn.functional.relu(X)
+                X = self.conv1(X)
+                X = nn.functional.relu(X)
+                X = X.view(X.size(0), -1)
+                X = self.linear(X)
+                return X
+
+        inputs = torch.randn(1, 3, 3, 3).to(self.device)
+        config = LoraConfig(init_lora_weights=False, use_dora=True, target_modules=["conv0", "conv1"])
+        model = ModelConv2D().to(self.device)
+        self.check_dora_caching(model, config, inputs)
+
+    def check_dora_caching(self, model, config, inputs):
+        atol, rtol = 1e-6, 1e-6
+
+        # BASE RESULT
+        base_result = self.get_output(model, inputs)
+
+        # DEFAULT: WITHOUT DoRA CACHING
+        model = get_peft_model(model, config)
+        caches = self.get_caches(model)
+        dora_result = self.get_output(model, inputs)
+
+        # sanity check: the results should be different
+        assert not torch.allclose(base_result, dora_result, atol=atol, rtol=rtol)
+        # ensure that there are dora caches but they're all empty
+        assert caches
+        assert not any(cache for cache in caches)
+
+        # ENABLE DORA CACHING
+        model.eval()
+        with DoraCaching():
+            cached_result = self.get_output(model, inputs)
+            # the caches should be populated now
+            assert all(cache for cache in caches)
+        # the results should be the same
+        assert torch.allclose(cached_result, dora_result, atol=atol, rtol=rtol)
+
+        # AFTER EXITING THE CONTEXT
+        cached_result_after_context = self.get_output(model, inputs)
+        assert torch.allclose(cached_result_after_context, dora_result, atol=atol, rtol=rtol)
+        # since we called forward outside of the context, the caches should be cleared
+        assert not any(cache for cache in caches)
+
+        # NO CACHING IN TRAIN MODE
+        model.train()
+        # switching to train model immediately clears the caches
+        assert not any(cache for cache in caches)
+        with DoraCaching():
+            results_train_mode = self.get_output(model, inputs)
+            # the caches should still be empty
+            assert not any(cache for cache in caches)
+        # results should not change
+        assert torch.allclose(results_train_mode, dora_result, atol=atol, rtol=rtol)
+        # still not any caches expected
+        assert not any(cache for cache in caches)
+
+        # PERMANENTLY ENABLE DORA CACHING
+        DoraCaching()(enabled=True)
+        model.eval()
+        # putting the model in eval mode clears the caches
+        assert not any(cache for cache in caches)
+        # the results should be the same
+        cached_result_permanent = self.get_output(model, inputs)
+        assert torch.allclose(cached_result_permanent, dora_result, atol=atol, rtol=rtol)
+        DoraCaching()(enabled=False)
+
+
+class _TinyLinearModel(nn.Module):
+    """Tiny module containing several Linear layers with common projection names."""
+
+    def __init__(self, d=16):
+        super().__init__()
+        # Common Transformer projection names
+        self.q_proj = nn.Linear(d, d, bias=False)
+        self.k_proj = nn.Linear(d, d, bias=False)
+        self.v_proj = nn.Linear(d, d, bias=False)
+        self.o_proj = nn.Linear(d, d, bias=False)
+        self.gate_proj = nn.Linear(d, d, bias=False)
+        self.up_proj = nn.Linear(d, d, bias=False)
+        self.down_proj = nn.Linear(d, d, bias=False)
+
+
+@pytest.fixture
+def small_model():
+    """
+    Small CPU-only model fixture for KappaTuneSelector tests.
+
+    Keeping this tiny ensures it runs quickly on CPU-only CI.
+    """
+    torch.manual_seed(0)
+    return _TinyLinearModel(d=16)
+
+
+class TestKappaTuneSelector:
+    """Tests for KappaTuneSelector and find_kappa_target_modules helper."""
+
+    def test_find_kappa_target_modules_returns_dict(self, small_model):
+        """Test the new return format of find_kappa_target_modules."""
+        from peft.helpers import find_kappa_target_modules
+
+        result = find_kappa_target_modules(small_model, top_p=0.5)
+
+        assert isinstance(result, dict)
+        assert "target_modules" in result
+        assert "target_parameters" in result
+        assert isinstance(result["target_modules"], list)
+        assert result["target_parameters"] is None
+
+    def test_find_kappa_target_modules_selects_modules(self, small_model):
+        """Basic functionality test on regular nn.Linear layers."""
+        from peft.helpers import find_kappa_target_modules
+
+        result = find_kappa_target_modules(small_model, top_p=0.3)
+
+        assert len(result["target_modules"]) > 0
+        # All returned modules should exist in the model
+        for name in result["target_modules"]:
+            assert any(name in module_name for module_name, _ in small_model.named_modules())
+
+    def test_kappatune_with_moe_layers(self):
+        """Test support for fused MoE 3D parameters (target_parameters)."""
+        import torch
+        from torch import nn
+
+        from peft.helpers import KappaTuneSelector, find_kappa_target_modules
+
+        # Create a minimal dummy MoE model with fused 3D weights
+        class DummyMoE(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.gate_up_proj = nn.Parameter(torch.randn(2, 16, 32))
+                self.down_proj = nn.Parameter(torch.randn(2, 32, 16))
+
+        class DummyModel(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.layers = nn.ModuleList([DummyMoE() for _ in range(2)])
+
+        model = DummyModel()
+
+        # Test selector directly
+        selector = KappaTuneSelector(model)
+        target_params = selector.get_best_target_parameters(top_p=0.5)
+        assert len(target_params) > 0
+        assert any("gate_up_proj" in name or "down_proj" in name for name in target_params)
+
+        # Test convenience function
+        result = find_kappa_target_modules(model, top_p=0.5)
+        assert isinstance(result["target_parameters"], list)
+        assert len(result["target_parameters"]) > 0
+        assert any("gate_up_proj" in name or "down_proj" in name for name in result["target_parameters"])
+
+
+class TestMontecloraTrainerMixin:
+    def test_mixin_adds_variational_loss_to_trainer(self, tmp_path):
+        class MontecloraTrainer(MontecloraTrainerMixin, Trainer):
+            pass
+
+        model_id = "peft-internal-testing/tiny-random-OPTForCausalLM"
+        with hub_online_once(model_id):
+            base_model = AutoModelForCausalLM.from_pretrained(model_id)
+            config = LoraConfig(
+                target_modules=["q_proj", "v_proj"],
+                monteclora_config=MontecloraConfig(num_samples=2),
+            )
+            model = get_peft_model(base_model, config).train()
+            assert any(isinstance(m, MontecloraSampler) for m in model.modules())
+
+            training_args = TrainingArguments(
+                output_dir=str(tmp_path),
+                per_device_train_batch_size=2,
+                num_train_epochs=1,
+                save_strategy="no",
+                report_to=[],
+                use_cpu=True,
+            )
+            vanilla_trainer = Trainer(model=model, args=training_args)
+            monteclora_trainer = MontecloraTrainer(model=model, args=training_args)
+
+            torch.manual_seed(0)
+            input_ids = torch.randint(0, base_model.config.vocab_size, (2, 8))
+            inputs = {"input_ids": input_ids, "labels": input_ids.clone()}
+
+            torch.manual_seed(0)
+            task_loss = vanilla_trainer.compute_loss(model, inputs)
+            torch.manual_seed(0)
+            total_loss = monteclora_trainer.compute_loss(model, inputs)
+
+            assert total_loss.item() != task_loss.item()
+            total_loss.backward()
diff --git a/tests/test_hub_features.py b/tests/test_hub_features.py
new file mode 100644
index 0000000..c074504
--- /dev/null
+++ b/tests/test_hub_features.py
@@ -0,0 +1,227 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+import copy
+
+import pytest
+import torch
+from huggingface_hub import ModelCard
+from transformers import AutoModelForCausalLM
+
+from peft import AutoPeftModelForCausalLM, LoraConfig, PeftConfig, PeftModel, TaskType, get_peft_model
+
+from .testing_utils import hub_online_once
+
+
+PEFT_MODELS_TO_TEST = [("peft-internal-testing/test-lora-subfolder", "test")]
+
+
+class PeftHubFeaturesTester:
+    # TODO remove when/if Hub is more stable
+    @pytest.mark.xfail(reason="Test is flaky on CI", raises=ValueError)
+    def test_subfolder(self):
+        r"""
+        Test if subfolder argument works as expected
+        """
+        for model_id, subfolder in PEFT_MODELS_TO_TEST:
+            config = PeftConfig.from_pretrained(model_id, subfolder=subfolder)
+
+            model = AutoModelForCausalLM.from_pretrained(
+                config.base_model_name_or_path,
+            )
+            model = PeftModel.from_pretrained(model, model_id, subfolder=subfolder)
+
+            assert isinstance(model, PeftModel)
+
+
+class TestLocalModel:
+    def test_local_model_saving_no_warning(self, recwarn, tmp_path):
+        # When the model is saved, the library checks for vocab changes by
+        # examining `config.json` in the model path.
+        # However, previously, those checks only covered huggingface hub models.
+        # This test makes sure that the local `config.json` is checked as well.
+        # If `save_pretrained` could not find the file, it will issue a warning.
+        model_id = "peft-internal-testing/opt-125m"
+        model = AutoModelForCausalLM.from_pretrained(model_id)
+        local_dir = tmp_path / model_id
+        model.save_pretrained(local_dir)
+        del model
+
+        base_model = AutoModelForCausalLM.from_pretrained(local_dir)
+        peft_config = LoraConfig()
+        peft_model = get_peft_model(base_model, peft_config)
+        peft_model.save_pretrained(local_dir)
+
+        for warning in recwarn.list:
+            assert "Could not find a config file" not in warning.message.args[0]
+
+
+class TestBaseModelRevision:
+    def test_save_and_load_base_model_revision(self, tmp_path):
+        r"""
+        Test saving a PeftModel with a base model revision and loading with AutoPeftModel to recover the same base
+        model
+        """
+        lora_config = LoraConfig(r=8, lora_alpha=16, lora_dropout=0.0)
+        test_inputs = torch.arange(10).reshape(-1, 1)
+
+        base_model_id = "peft-internal-testing/tiny-random-BertModel"
+        revision = "v2.0.0"
+
+        base_model_revision = AutoModelForCausalLM.from_pretrained(base_model_id, revision=revision).eval()
+        peft_model_revision = get_peft_model(base_model_revision, lora_config, revision=revision)
+        output_revision = peft_model_revision(test_inputs).logits
+
+        # sanity check: the model without revision should be different
+        base_model_no_revision = AutoModelForCausalLM.from_pretrained(base_model_id, revision="main").eval()
+        # we need a copy of the config because otherwise, we are changing in-place the `revision` of the previous config and model
+        lora_config_no_revision = copy.deepcopy(lora_config)
+        lora_config_no_revision.revision = "main"
+        peft_model_no_revision = get_peft_model(base_model_no_revision, lora_config_no_revision, revision="main")
+        output_no_revision = peft_model_no_revision(test_inputs).logits
+        assert not torch.allclose(output_no_revision, output_revision)
+
+        # check that if we save and load the model, the output corresponds to the one with revision
+        peft_model_revision.save_pretrained(tmp_path / "peft_model_revision")
+        peft_model_revision_loaded = AutoPeftModelForCausalLM.from_pretrained(tmp_path / "peft_model_revision").eval()
+
+        assert peft_model_revision_loaded.peft_config["default"].revision == revision
+
+        output_revision_loaded = peft_model_revision_loaded(test_inputs).logits
+        assert torch.allclose(output_revision, output_revision_loaded)
+
+    def test_load_different_peft_and_base_model_revision(self, tmp_path):
+        r"""
+        Test loading an AutoPeftModel from the hub where the base model revision and peft revision differ
+        """
+        base_model_id = "hf-internal-testing/tiny-random-BertModel"
+        base_model_revision = None
+        peft_model_id = "peft-internal-testing/tiny-random-BertModel-lora"
+        peft_model_revision = "v1.2.3"
+
+        peft_model = AutoPeftModelForCausalLM.from_pretrained(peft_model_id, revision=peft_model_revision).eval()
+
+        assert peft_model.peft_config["default"].base_model_name_or_path == base_model_id
+        assert peft_model.peft_config["default"].revision == base_model_revision
+
+
+class TestModelCard:
+    @pytest.mark.parametrize(
+        "model_id, peft_config, tags, excluded_tags, pipeline_tag",
+        [
+            (
+                "hf-internal-testing/tiny-random-Gemma3ForCausalLM",
+                LoraConfig(),
+                ["transformers", "base_model:adapter:hf-internal-testing/tiny-random-Gemma3ForCausalLM", "lora"],
+                [],
+                None,
+            ),
+            (
+                "peft-internal-testing/tiny-random-BartForConditionalGeneration",
+                LoraConfig(),
+                [
+                    "transformers",
+                    "base_model:adapter:peft-internal-testing/tiny-random-BartForConditionalGeneration",
+                    "lora",
+                ],
+                [],
+                None,
+            ),
+            (
+                "hf-internal-testing/tiny-random-Gemma3ForCausalLM",
+                LoraConfig(task_type=TaskType.CAUSAL_LM),
+                ["transformers", "base_model:adapter:hf-internal-testing/tiny-random-Gemma3ForCausalLM", "lora"],
+                [],
+                "text-generation",
+            ),
+        ],
+    )
+    @pytest.mark.parametrize(
+        "pre_tags",
+        [
+            ["tag1", "tag2"],
+            [],
+        ],
+    )
+    def test_model_card_has_expected_tags(
+        self, model_id, peft_config, tags, excluded_tags, pipeline_tag, pre_tags, tmp_path
+    ):
+        """Make sure that PEFT sets the tags in the model card automatically and correctly.
+        This is important so that a) the models are searchable on the Hub and also 2) some features depend on it to
+        decide how to deal with them (e.g., inference).
+
+        Makes sure that the base model tags are still present (if there are any).
+        """
+        with hub_online_once(model_id):
+            base_model = AutoModelForCausalLM.from_pretrained(model_id)
+
+            if pre_tags:
+                base_model.add_model_tags(pre_tags)
+
+            peft_model = get_peft_model(base_model, peft_config)
+            save_path = tmp_path / "adapter"
+
+            peft_model.save_pretrained(save_path)
+
+            model_card = ModelCard.load(save_path / "README.md")
+            assert set(tags).issubset(set(model_card.data.tags))
+
+            if excluded_tags:
+                assert set(excluded_tags).isdisjoint(set(model_card.data.tags))
+
+            if pre_tags:
+                assert set(pre_tags).issubset(set(model_card.data.tags))
+
+            if pipeline_tag:
+                assert model_card.data.pipeline_tag == pipeline_tag
+
+    @pytest.fixture
+    def custom_model_cls(self):
+        class MyNet(torch.nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.l1 = torch.nn.Linear(10, 20)
+                self.l2 = torch.nn.Linear(20, 1)
+
+            def forward(self, X):
+                return self.l2(self.l1(X))
+
+        return MyNet
+
+    def test_custom_models_dont_have_transformers_tag(self, custom_model_cls, tmp_path):
+        base_model = custom_model_cls()
+        peft_config = LoraConfig(target_modules="all-linear")
+        peft_model = get_peft_model(base_model, peft_config)
+
+        peft_model.save_pretrained(tmp_path)
+
+        model_card = ModelCard.load(tmp_path / "README.md")
+
+        assert model_card.data.tags is not None
+        assert "transformers" not in model_card.data.tags
+
+    def test_custom_peft_type_does_not_raise(self, tmp_path):
+        # Passing a string value as peft_type value in the config is valid, so it should work.
+        # See https://github.com/huggingface/peft/issues/2634
+        model_id = "hf-internal-testing/tiny-random-Gemma3ForCausalLM"
+        with hub_online_once(model_id):
+            base_model = AutoModelForCausalLM.from_pretrained(model_id)
+            peft_config = LoraConfig()
+
+            # We simulate a custom PEFT type by using a string value of an existing method.  This skips the need for
+            # registering a new method but tests the case where we pass a string value instead of an enum.
+            peft_type = "LORA"
+            peft_config.peft_type = peft_type
+
+            peft_model = get_peft_model(base_model, peft_config)
+            peft_model.save_pretrained(tmp_path)
diff --git a/tests/test_incremental_pca.py b/tests/test_incremental_pca.py
new file mode 100644
index 0000000..f97c026
--- /dev/null
+++ b/tests/test_incremental_pca.py
@@ -0,0 +1,190 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+# Adapted from https://github.com/scikit-learn/scikit-learn/blob/main/sklearn/decomposition/tests/test_incremental_pca.py
+
+from itertools import pairwise
+
+import pytest
+import torch
+from datasets import load_dataset
+from torch.testing import assert_close
+
+from peft.utils.incremental_pca import IncrementalPCA
+
+
+torch.manual_seed(1999)
+
+
+@pytest.fixture(scope="module")
+def iris():
+    return load_dataset("scikit-learn/iris", split="train")
+
+
+def test_incremental_pca(iris):
+    # Incremental PCA on dense arrays.
+    n_components = 2
+    X = torch.tensor([iris["SepalLengthCm"], iris["SepalWidthCm"], iris["PetalLengthCm"], iris["PetalWidthCm"]]).T
+    batch_size = X.shape[0] // 3
+    ipca = IncrementalPCA(n_components=n_components, batch_size=batch_size)
+    ipca.fit(X)
+    X_transformed = ipca.transform(X)
+
+    # PCA
+    _, S, Vh = torch.linalg.svd(X - torch.mean(X, dim=0))
+    max_abs_rows = torch.argmax(torch.abs(Vh), dim=1)
+    signs = torch.sign(Vh[range(Vh.shape[0]), max_abs_rows])
+    Vh *= signs.view(-1, 1)
+    explained_variance = S**2 / (X.size(0) - 1)
+    explained_variance_ratio = explained_variance / explained_variance.sum()
+
+    assert X_transformed.shape == (X.shape[0], 2)
+    assert_close(
+        ipca.explained_variance_ratio_.sum().item(),
+        explained_variance_ratio[:n_components].sum().item(),
+        rtol=1e-3,
+        atol=1e-3,
+    )
+
+
+def test_incremental_pca_check_projection():
+    # Test that the projection of data is correct.
+    n, p = 100, 3
+    X = torch.randn(n, p, dtype=torch.float64) * 0.1
+    X[:10] += torch.tensor([3, 4, 5])
+    Xt = 0.1 * torch.randn(1, p, dtype=torch.float64) + torch.tensor([3, 4, 5])
+
+    # Get the reconstruction of the generated data X
+    # Note that Xt has the same "components" as X, just separated
+    # This is what we want to ensure is recreated correctly
+    Yt = IncrementalPCA(n_components=2).fit(X).transform(Xt)
+
+    # Normalize
+    Yt /= torch.sqrt((Yt**2).sum())
+
+    # Make sure that the first element of Yt is ~1, this means
+    # the reconstruction worked as expected
+    assert_close(torch.abs(Yt[0][0]).item(), 1.0, atol=1e-1, rtol=1e-1)
+
+
+def test_incremental_pca_validation():
+    # Test that n_components is <= n_features.
+    X = torch.tensor([[0, 1, 0], [1, 0, 0]])
+    n_samples, n_features = X.shape
+    n_components = 4
+    with pytest.raises(
+        ValueError,
+        match=(
+            f"n_components={n_components} invalid"
+            f" for n_features={n_features}, need more rows than"
+            " columns for IncrementalPCA"
+            " processing"
+        ),
+    ):
+        IncrementalPCA(n_components, batch_size=10).fit(X)
+
+    # Tests that n_components is also <= n_samples.
+    n_components = 3
+    with pytest.raises(
+        ValueError,
+        match=(f"n_components={n_components} must be less or equal to the batch number of samples {n_samples}"),
+    ):
+        IncrementalPCA(n_components=n_components).partial_fit(X)
+
+
+def test_n_components_none():
+    # Ensures that n_components == None is handled correctly
+    for n_samples, n_features in [(50, 10), (10, 50)]:
+        X = torch.rand(n_samples, n_features)
+        ipca = IncrementalPCA(n_components=None)
+
+        # First partial_fit call, ipca.n_components_ is inferred from
+        # min(X.shape)
+        ipca.partial_fit(X)
+        assert ipca.n_components == min(X.shape)
+
+
+def test_incremental_pca_num_features_change():
+    # Test that changing n_components will raise an error.
+    n_samples = 100
+    X = torch.randn(n_samples, 20)
+    X2 = torch.randn(n_samples, 50)
+    ipca = IncrementalPCA(n_components=None)
+    ipca.fit(X)
+    with pytest.raises(ValueError):
+        ipca.partial_fit(X2)
+
+
+def test_incremental_pca_batch_signs():
+    # Test that components_ sign is stable over batch sizes.
+    n_samples = 100
+    n_features = 3
+    X = torch.randn(n_samples, n_features)
+    all_components = []
+    batch_sizes = torch.arange(10, 20)
+    for batch_size in batch_sizes:
+        ipca = IncrementalPCA(n_components=None, batch_size=batch_size).fit(X)
+        all_components.append(ipca.components_)
+
+    for i, j in pairwise(all_components):
+        assert_close(torch.sign(i), torch.sign(j), rtol=1e-6, atol=1e-6)
+
+
+def test_incremental_pca_batch_values():
+    # Test that components_ values are stable over batch sizes.
+    n_samples = 100
+    n_features = 3
+    X = torch.randn(n_samples, n_features)
+    all_components = []
+    batch_sizes = torch.arange(20, 40, 3)
+    for batch_size in batch_sizes:
+        ipca = IncrementalPCA(n_components=None, batch_size=batch_size).fit(X)
+        all_components.append(ipca.components_)
+
+    for i, j in pairwise(all_components):
+        assert_close(i, j, rtol=1e-1, atol=1e-1)
+
+
+def test_incremental_pca_partial_fit():
+    # Test that fit and partial_fit get equivalent results.
+    n, p = 50, 3
+    X = torch.randn(n, p)  # spherical data
+    X[:, 1] *= 0.00001  # make middle component relatively small
+    X += torch.tensor([5, 4, 3])  # make a large mean
+
+    # same check that we can find the original data from the transformed
+    # signal (since the data is almost of rank n_components)
+    batch_size = 10
+    ipca = IncrementalPCA(n_components=2, batch_size=batch_size).fit(X)
+    pipca = IncrementalPCA(n_components=2, batch_size=batch_size)
+    # Add one to make sure endpoint is included
+    batch_itr = torch.arange(0, n + 1, batch_size)
+    for i, j in pairwise(batch_itr):
+        pipca.partial_fit(X[i:j, :])
+    assert_close(ipca.components_, pipca.components_, rtol=1e-3, atol=1e-3)
+
+
+def test_incremental_pca_lowrank(iris):
+    # Test that lowrank mode is equivalent to non-lowrank mode.
+    n_components = 2
+    X = torch.tensor([iris["SepalLengthCm"], iris["SepalWidthCm"], iris["PetalLengthCm"], iris["PetalWidthCm"]]).T
+    batch_size = X.shape[0] // 3
+
+    ipca = IncrementalPCA(n_components=n_components, batch_size=batch_size)
+    ipca.fit(X)
+
+    ipcalr = IncrementalPCA(n_components=n_components, batch_size=batch_size, lowrank=True)
+    ipcalr.fit(X)
+
+    assert_close(ipca.components_, ipcalr.components_, rtol=1e-7, atol=1e-7)
diff --git a/tests/test_initialization.py b/tests/test_initialization.py
new file mode 100644
index 0000000..957f426
--- /dev/null
+++ b/tests/test_initialization.py
@@ -0,0 +1,5826 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import copy
+import math
+import platform
+import re
+import warnings
+from contextlib import contextmanager
+from copy import deepcopy
+from unittest.mock import patch
+
+import pytest
+import torch
+from huggingface_hub import snapshot_download
+from safetensors.torch import load_file
+from scipy import stats
+from torch import nn
+from transformers import AutoModelForCausalLM
+
+from peft import (
+    AdaLoraConfig,
+    BeftConfig,
+    C3AConfig,
+    DeloraConfig,
+    EvaConfig,
+    FrodConfig,
+    GraloraConfig,
+    IA3Config,
+    LilyConfig,
+    LoftQConfig,
+    LoKrConfig,
+    LoraConfig,
+    PeanutConfig,
+    PeftMixedModel,
+    PeftModel,
+    PeftModelForCausalLM,
+    PeftModelForFeatureExtraction,
+    PeftModelForQuestionAnswering,
+    PeftModelForSeq2SeqLM,
+    PeftModelForSequenceClassification,
+    PeftModelForTokenClassification,
+    PeftWarning,
+    PrefixTuningConfig,
+    PromptTuningConfig,
+    PsoftConfig,
+    RoadConfig,
+    VBLoRAConfig,
+    VeloraConfig,
+    VeraConfig,
+    WaveFTConfig,
+    get_peft_model,
+    inject_adapter_in_model,
+    set_peft_model_state_dict,
+)
+from peft.mapping import PEFT_TYPE_TO_PREFIX_MAPPING
+from peft.tuners.lokr.layer import LoKrLayer
+from peft.tuners.lora.config import CordaConfig
+from peft.tuners.lora.corda import preprocess_corda
+from peft.tuners.lora.layer import LoraLayer
+from peft.utils import infer_device
+from peft.utils.hotswap import hotswap_adapter, prepare_model_for_compiled_hotswap
+from peft.utils.other import ModulesToSaveWrapper
+
+from .testing_utils import hub_online_once, require_deterministic_for_xpu
+
+
+try:
+    from huggingface_hub.utils import reset_sessions
+except ImportError:
+    # this function was removed in hfh v1.0.0
+    reset_sessions = None
+
+
+class TestLoraInitialization:
+    """Test class to check the initialization of LoRA adapters."""
+
+    torch_device = infer_device()
+
+    def get_uniform(self, amin, amax, size=(10000,)):
+        unif = torch.distributions.uniform.Uniform(amin, amax)
+        samples = unif.sample(size)
+        return samples
+
+    def get_normal(self, mean, std, size=(10000,)):
+        normal = torch.distributions.normal.Normal(mean, std)
+        samples = normal.sample(size)
+        return samples
+
+    def get_model(self, bias=True):
+        class MyModule(nn.Module):
+            def __init__(self):
+                super().__init__()
+                # choose a large weight so that averages are close to expected values
+                self.linear = nn.Linear(1000, 1000, bias=bias)
+                self.embed = nn.Embedding(1000, 1000)
+                self.conv2d = nn.Conv2d(100, 100, 3, bias=bias)
+
+            def forward(self, x):
+                x_int = (100 * x).int()
+                x_4d = x.flatten().reshape(1, 100, 10, 10)
+                return self.linear(x), self.embed(x_int), self.conv2d(x_4d)
+
+        return MyModule().eval().to(self.torch_device)
+
+    @pytest.fixture
+    def data(self):
+        return torch.rand(10, 1000).to(self.torch_device)
+
+    def test_lora_linear_init_default(self):
+        # default is True
+        torch.manual_seed(0)
+
+        model = self.get_model()
+        config = LoraConfig(target_modules=["linear"])
+        model = get_peft_model(model, config)
+        weight_A = model.linear.lora_A["default"].weight
+        weight_B = model.linear.lora_B["default"].weight
+
+        # use statistical test to check if weight A is from a uniform distribution
+        unif = self.get_uniform(weight_A.min().item(), weight_A.max().item())
+        _, p_value = stats.kstest(weight_A.detach().flatten().cpu().numpy(), unif.flatten().cpu().numpy())
+        assert p_value > 0.5
+
+        # check that weight A is *not* from a normal distribution
+        normal = self.get_normal(weight_A.mean().item(), weight_A.std().item())
+        _, p_value = stats.kstest(weight_A.detach().flatten().cpu().numpy(), normal.flatten().cpu().numpy())
+        assert p_value < 0.05
+
+        # check that weight B is zero
+        assert (weight_B == 0.0).all()
+
+    def test_lora_linear_init_gaussian(self):
+        # use gaussian init
+        torch.manual_seed(0)
+
+        model = self.get_model()
+        config = LoraConfig(target_modules=["linear"], init_lora_weights="gaussian")
+        model = get_peft_model(model, config)
+        weight_A = model.linear.lora_A["default"].weight
+        weight_B = model.linear.lora_B["default"].weight
+
+        # use statistical test to check if weight A is from a normal distribution
+        normal = self.get_normal(0.0, 1 / config.r)
+        _, p_value = stats.kstest(weight_A.detach().flatten().cpu().numpy(), normal.flatten().cpu().numpy())
+
+        assert p_value > 0.5
+
+        # check that weight A is *not* from a uniform distribution
+        unif = self.get_uniform(weight_A.min().item(), weight_A.max().item())
+        _, p_value = stats.kstest(weight_A.detach().flatten().cpu().numpy(), unif.flatten().cpu().numpy())
+        assert p_value < 0.05
+
+        # check that weight B is zero
+        assert (weight_B == 0.0).all()
+
+    def test_lora_linear_false(self):
+        torch.manual_seed(0)
+
+        model = self.get_model()
+        config = LoraConfig(target_modules=["linear"], init_lora_weights=False)
+        model = get_peft_model(model, config)
+        weight_B = model.linear.lora_B["default"].weight
+
+        # with init_lora_weights=False, weight B should *not* be zero. We don't care so much about the actual values
+        # as long as they are not zero, in order to avoid identity transformation.
+        assert not torch.allclose(weight_B, torch.zeros_like(weight_B))
+
+    def test_lora_embedding_default(self):
+        # embedding is initialized as a normal distribution, not kaiming uniform
+        torch.manual_seed(0)
+
+        model = self.get_model()
+        config = LoraConfig(target_modules=["embed"])
+        model = get_peft_model(model, config)
+        weight_A = model.embed.lora_embedding_A["default"]
+        weight_B = model.embed.lora_embedding_B["default"]
+
+        # use statistical test to check if weight B is from a normal distribution
+        normal = self.get_normal(0.0, 1.0)
+        _, p_value = stats.kstest(weight_B.detach().flatten().cpu().numpy(), normal.flatten().cpu().numpy())
+        assert p_value > 0.5
+
+        # check that weight B is *not* from a uniform distribution
+        unif = self.get_uniform(weight_B.min().item(), weight_B.max().item())
+        _, p_value = stats.kstest(weight_B.detach().flatten().cpu().numpy(), unif.flatten().cpu().numpy())
+        assert p_value < 0.05
+
+        # check that weight A is zero
+        assert (weight_A == 0.0).all()
+
+    def test_lora_embedding_gaussian(self):
+        # embedding does not change with init_lora_weights="gaussian" vs True
+        torch.manual_seed(0)
+
+        model = self.get_model()
+        config = LoraConfig(target_modules=["embed"], init_lora_weights="gaussian")
+        model = get_peft_model(model, config)
+        weight_A = model.embed.lora_embedding_A["default"]
+        weight_B = model.embed.lora_embedding_B["default"]
+
+        # use statistical test to check if weight B is from a normal distribution
+        normal = self.get_normal(0.0, 1.0)
+        _, p_value = stats.kstest(weight_B.detach().flatten().cpu().numpy(), normal.flatten().cpu().numpy())
+        assert p_value > 0.5
+
+        # check that weight B is *not* from a uniform distribution
+        unif = self.get_uniform(weight_B.min().item(), weight_B.max().item())
+        _, p_value = stats.kstest(weight_B.detach().flatten().cpu().numpy(), unif.flatten().cpu().numpy())
+        assert p_value < 0.05
+
+        # check that weight A is zero
+        assert (weight_A == 0.0).all()
+
+    def test_lora_embedding_false(self):
+        torch.manual_seed(0)
+
+        model = self.get_model()
+        config = LoraConfig(target_modules=["embed"], init_lora_weights=False)
+        model = get_peft_model(model, config)
+        weight_A = model.embed.lora_embedding_B["default"]
+
+        # with init_lora_weights=False, weight A should *not* be zero. We don't care so much about the actual values
+        # as long as they are not zero, in order to avoid identity transformation.
+        assert not torch.allclose(weight_A, torch.zeros_like(weight_A))
+
+    def test_lora_conv2d_default(self):
+        # default is True
+        torch.manual_seed(0)
+
+        model = self.get_model()
+        config = LoraConfig(target_modules=["conv2d"])
+        model = get_peft_model(model, config)
+        weight_A = model.conv2d.lora_A["default"].weight
+        weight_B = model.conv2d.lora_B["default"].weight
+
+        # use statistical test to check if weight A is from a uniform distribution
+        unif = self.get_uniform(weight_A.min().item(), weight_A.max().item())
+        _, p_value = stats.kstest(weight_A.detach().flatten().cpu().numpy(), unif.flatten().cpu().numpy())
+        assert p_value > 0.5
+
+        # check that weight A is *not* from a normal distribution
+        normal = self.get_normal(weight_A.mean().item(), weight_A.std().item())
+        _, p_value = stats.kstest(weight_A.detach().flatten().cpu().numpy(), normal.flatten().cpu().numpy())
+        assert p_value < 0.05
+
+        # check that weight B is zero
+        assert (weight_B == 0.0).all()
+
+    def test_lora_conv2d_init_gaussian(self):
+        # use gaussian init
+        torch.manual_seed(0)
+
+        model = self.get_model()
+        config = LoraConfig(target_modules=["conv2d"], init_lora_weights="gaussian")
+        model = get_peft_model(model, config)
+        weight_A = model.conv2d.lora_A["default"].weight
+        weight_B = model.conv2d.lora_B["default"].weight
+
+        # use statistical test to check if weight A is from a normal distribution
+        normal = self.get_normal(0.0, 1 / config.r)
+        _, p_value = stats.kstest(weight_A.detach().flatten().cpu().numpy(), normal.flatten().cpu().numpy())
+        assert p_value > 0.5
+
+        # check that weight A is *not* from a uniform distribution
+        unif = self.get_uniform(weight_A.min().item(), weight_A.max().item())
+        _, p_value = stats.kstest(weight_A.detach().flatten().cpu().numpy(), unif.flatten().cpu().numpy())
+        assert p_value < 0.05
+
+        # check that weight B is zero
+        assert (weight_B == 0.0).all()
+
+    def test_lora_conv2d_false(self):
+        torch.manual_seed(0)
+
+        model = self.get_model()
+        config = LoraConfig(target_modules=["conv2d"], init_lora_weights=False)
+        model = get_peft_model(model, config)
+        weight_B = model.conv2d.lora_B["default"].weight
+
+        # with init_lora_weights=False, weight B should *not* be zero. We don't care so much about the actual values
+        # as long as they are not zero, in order to avoid identity transformation.
+        assert not torch.allclose(weight_B, torch.zeros_like(weight_B))
+
+    def test_lora_init_orthogonal(self):
+        torch.manual_seed(0)
+
+        model = self.get_model()
+        config = LoraConfig(target_modules=["linear"], init_lora_weights="orthogonal")
+        model = get_peft_model(model, config)
+
+        weight_A = model.linear.lora_A["default"].weight
+        weight_B = model.linear.lora_B["default"].weight
+
+        assert not torch.allclose(weight_A, torch.zeros_like(weight_A))
+        assert not torch.allclose(weight_B, torch.zeros_like(weight_B))
+        assert (weight_B @ weight_A).abs().max() < 1e-6
+
+    @pytest.mark.parametrize("dtype", [torch.float16, torch.bfloat16])
+    def test_lora_init_orthogonal_half_precision_dtype(self, dtype):
+        try:
+            torch.zeros(1, dtype=dtype)
+        except Exception:
+            pytest.skip(f"dtype {dtype} not supported on this system, skipping test")
+
+        torch.manual_seed(0)
+
+        model = self.get_model()
+        config = LoraConfig(target_modules=["linear"], init_lora_weights="orthogonal")
+        model = get_peft_model(model, config).to(dtype)
+
+        weight_A = model.linear.lora_A["default"].weight
+        weight_B = model.linear.lora_B["default"].weight
+
+        assert weight_A.dtype == dtype
+        assert weight_B.dtype == dtype
+
+    def test_lora_init_orthogonal_odd_rank_raises(self):
+        torch.manual_seed(0)
+
+        model = self.get_model()
+        config = LoraConfig(target_modules=["linear"], init_lora_weights="orthogonal", r=7)
+        msg = "Orthogonal initialization requires the LoRA rank to be even, got 7 instead."
+        with pytest.raises(ValueError, match=msg):
+            get_peft_model(model, config)
+
+    def test_lora_scaling_default(self):
+        # default is True
+        torch.manual_seed(0)
+
+        model = self.get_model()
+
+        # check scaling factor use_rslora=False
+        config = LoraConfig(target_modules=["linear", "embed", "conv2d"], lora_alpha=3, r=16, use_rslora=False)
+        model = get_peft_model(model, config)
+
+        expected_scaling = config.lora_alpha / config.r
+
+        assert model.linear.scaling["default"] == expected_scaling
+        assert model.embed.scaling["default"] == expected_scaling
+        assert model.conv2d.scaling["default"] == expected_scaling
+
+    # testcase for bugfix for issue 2194
+    def test_rank_alpha_pattern_override(self):
+        torch.manual_seed(0)
+
+        layer = self.get_model()
+        model = nn.Sequential(layer, layer)
+        config = LoraConfig(
+            target_modules=["linear"],
+            lora_alpha=1,
+            r=8,
+            use_rslora=False,
+            rank_pattern={"linear": 8},
+            alpha_pattern={"0.linear": 2},
+        )
+        model = get_peft_model(model, config)
+        scaling_with_rank_pattern = model.model[0].linear.scaling
+
+        layer = self.get_model()
+        model = nn.Sequential(layer, layer)
+        config = LoraConfig(
+            target_modules=["linear"], lora_alpha=1, r=8, use_rslora=False, alpha_pattern={"0.linear": 2}
+        )
+        model = get_peft_model(model, config)
+        scaling_without_rank_pattern = model.model[0].linear.scaling
+
+        assert scaling_with_rank_pattern == scaling_without_rank_pattern
+
+    def test_lora_pissa_linear_init_default(self, data):
+        model = self.get_model()
+        output = model(data)[0]
+
+        config = LoraConfig(init_lora_weights="pissa", target_modules=["linear"])
+        peft_model = get_peft_model(deepcopy(model), config)
+        assert torch.allclose(output, peft_model(data)[0], atol=1e-06)
+
+        config = LoraConfig(init_lora_weights="pissa_niter_16", target_modules=["linear"])
+        peft_model = get_peft_model(deepcopy(model), config)
+        assert torch.allclose(output, peft_model(data)[0], atol=1e-06)
+
+    def test_lora_mica_linear_init_default(self, data):
+        # MiCA initializes A=0 and B = bottom-r left singular vectors of W. Because A=0, the adapter contribution
+        # B @ A is zero at init, so the forward output must equal the base model's output exactly.
+        model = self.get_model()
+        output = model(data)[0]
+
+        config = LoraConfig(init_lora_weights="mica", target_modules=["linear"], r=8)
+        peft_model = get_peft_model(deepcopy(model), config)
+
+        weight_A = peft_model.base_model.linear.lora_A["default"].weight
+        weight_B = peft_model.base_model.linear.lora_B["default"].weight
+
+        # A must be zero
+        assert torch.all(weight_A == 0)
+        # B columns must be orthonormal (since they are left singular vectors)
+        eye = torch.eye(weight_B.shape[1], device=weight_B.device, dtype=weight_B.dtype)
+        assert torch.allclose(weight_B.t() @ weight_B, eye, atol=1e-4)
+        # Output at init equals the base output
+        assert torch.allclose(output, peft_model(data)[0], atol=1e-06)
+
+    def test_lora_mica_embedding_init_default(self):
+        class EmbeddingModel(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.embed = nn.Embedding(7, 5)
+
+            def forward(self, x):
+                return self.embed(x)
+
+        model = EmbeddingModel()
+        data = torch.arange(7).unsqueeze(0)
+        output = model(data)
+
+        config = LoraConfig(init_lora_weights="mica", target_modules=["embed"], r=3)
+        peft_model = get_peft_model(deepcopy(model), config)
+
+        weight_A = peft_model.base_model.embed.lora_embedding_A["default"]
+        weight_B = peft_model.base_model.embed.lora_embedding_B["default"]
+
+        assert torch.all(weight_A == 0)
+        eye = torch.eye(weight_B.shape[1], device=weight_B.device, dtype=weight_B.dtype)
+        assert torch.allclose(weight_B.t() @ weight_B, eye, atol=1e-4)
+        assert weight_A.requires_grad
+        assert not weight_B.requires_grad
+        assert torch.allclose(output, peft_model(data), atol=1e-06)
+
+    def test_lora_mica_uses_minor_components(self):
+        # Verify B equals the *minor* (smallest singular value) left singular vectors, not the major ones.
+        torch.manual_seed(0)
+        model = self.get_model()
+        r = 8
+
+        config = LoraConfig(init_lora_weights="mica", target_modules=["linear"], r=r)
+        peft_model = get_peft_model(deepcopy(model), config)
+        weight_B = peft_model.base_model.linear.lora_B["default"].weight.detach().cpu()
+
+        # Reference SVD of the original weight
+        W = model.linear.weight.detach().cpu().to(torch.float32)
+        U, _S, _ = torch.linalg.svd(W, full_matrices=False)
+        minor_U = U[:, -r:]
+        major_U = U[:, :r]
+
+        # B should span the same subspace as `minor_U` (column spans match up to sign/orthogonal mixing within
+        # equal-singular-value groups). Equality of projectors is the right invariant.
+        proj_B = weight_B @ weight_B.t()
+        proj_minor = minor_U @ minor_U.t()
+        proj_major = major_U @ major_U.t()
+        assert torch.allclose(proj_B, proj_minor, atol=1e-4)
+        assert not torch.allclose(proj_B, proj_major, atol=1e-2)
+
+    def test_lora_mica_freezes_B(self):
+        model = self.get_model()
+        config = LoraConfig(init_lora_weights="mica", target_modules=["linear"], r=8)
+        peft_model = get_peft_model(deepcopy(model), config)
+
+        assert peft_model.base_model.linear.lora_A["default"].weight.requires_grad
+        assert not peft_model.base_model.linear.lora_B["default"].weight.requires_grad
+
+    def test_lora_mica_freezes_B_when_switching_adapters(self):
+        class SimpleMlp(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.fc1 = nn.Linear(10, 10)
+                self.fc2 = nn.Linear(10, 10)
+
+            def forward(self, x):
+                x = torch.relu(self.fc1(x))
+                return self.fc2(x)
+
+        def trainable_parameters(model):
+            return [name for name, param in model.named_parameters() if param.requires_grad]
+
+        config0 = LoraConfig(target_modules=["fc1"], init_lora_weights="mica", r=4)
+        model = get_peft_model(SimpleMlp(), config0)
+        assert trainable_parameters(model) == ["base_model.model.fc1.lora_A.default.weight"]
+
+        config1 = LoraConfig(target_modules=["fc1", "fc2"], init_lora_weights="mica", r=4)
+        model.add_adapter("other", config1)
+        model.set_adapter("other")
+        assert trainable_parameters(model) == [
+            "base_model.model.fc1.lora_A.other.weight",
+            "base_model.model.fc2.lora_A.other.weight",
+        ]
+
+        model.set_adapter("default")
+        assert trainable_parameters(model) == ["base_model.model.fc1.lora_A.default.weight"]
+
+        model.delete_adapter("other")
+        assert "other" not in model.base_model.model.fc1.frozen_peft_weight_names
+        assert "other" not in model.base_model.model.fc2.frozen_peft_weight_names
+        config2 = LoraConfig(target_modules=["fc1"], r=4)
+        model.add_adapter("other", config2)
+        model.set_adapter("other")
+        assert trainable_parameters(model) == [
+            "base_model.model.fc1.lora_A.other.weight",
+            "base_model.model.fc1.lora_B.other.weight",
+        ]
+
+    def test_lora_mica_rank_too_large_raises(self):
+        class SimpleModel(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.linear = nn.Linear(2, 3)
+
+            def forward(self, x):
+                return self.linear(x)
+
+        config = LoraConfig(init_lora_weights="mica", target_modules=["linear"], r=3)
+        with pytest.raises(ValueError, match="MiCA requires `r` <= min"):
+            get_peft_model(SimpleModel(), config)
+
+    def test_lora_olora_linear_init_default(self, data):
+        model = self.get_model()
+        output = model(data)[0]
+
+        # Both OLoRA and olora should work
+        config = LoraConfig(init_lora_weights="OLoRA", target_modules=["linear"])
+        peft_model = get_peft_model(deepcopy(model), config)
+        assert torch.allclose(output, peft_model(data)[0], atol=1e-06)
+
+    def test_lora_pissa_conversion_same_output_after_loading(self, data, tmp_path):
+        model = self.get_model()
+        output_base = model(data)[0]
+
+        config = LoraConfig(init_lora_weights="pissa", target_modules=["linear"], r=8)
+        peft_model = get_peft_model(deepcopy(model), config)
+        # save the initial model
+        peft_model.peft_config["default"].init_lora_weights = True
+        peft_model.save_pretrained(tmp_path / "init-model")
+        peft_model.peft_config["default"].init_lora_weights = "pissa"
+
+        # modify the weights, or else the adapter performs an identity transformation
+        peft_model.base_model.linear.lora_B["default"].weight.data *= 2.0
+        output_pissa = peft_model(data)[0]
+
+        # sanity check
+        tol = 1e-06
+        assert not torch.allclose(output_base, output_pissa, atol=tol, rtol=tol)
+
+        # save the model normally
+        peft_model.save_pretrained(tmp_path / "pissa-model")
+        model_loaded = PeftModel.from_pretrained(deepcopy(model), tmp_path / "pissa-model")
+        output_loaded = model_loaded(data)[0]
+
+        assert torch.allclose(output_pissa, output_loaded, atol=tol, rtol=tol)
+        # sanity check: ranks should still be 8 as initially
+        assert model_loaded.peft_config["default"].r == 8
+        assert model_loaded.base_model.model.linear.lora_A["default"].weight.shape[0] == 8
+        # sanity check: the base model weights were indeed changed
+        assert not torch.allclose(
+            model.linear.weight, model_loaded.base_model.model.linear.base_layer.weight, atol=tol, rtol=tol
+        )
+
+        # save the model with conversion
+        peft_config_keys_before = list(peft_model.peft_config.keys())
+        peft_config_dict_before = peft_model.peft_config["default"].to_dict()
+        peft_model.save_pretrained(
+            tmp_path / "pissa-model-converted", path_initial_model_for_weight_conversion=tmp_path / "init-model"
+        )
+        peft_config_keys_after = list(peft_model.peft_config.keys())
+        peft_config_dict_after = peft_model.peft_config["default"].to_dict()
+        assert peft_config_keys_before == peft_config_keys_after
+        assert peft_config_dict_before == peft_config_dict_after
+
+        model_converted = PeftModel.from_pretrained(deepcopy(model), tmp_path / "pissa-model-converted")
+        output_converted = model_converted(data)[0]
+
+        assert torch.allclose(output_pissa, output_converted, atol=tol, rtol=tol)
+        # rank should be double of what it was initially
+        assert model_converted.peft_config["default"].r == 16
+        assert model_converted.base_model.model.linear.lora_A["default"].weight.shape[0] == 16
+        # base model weights should be the same as the initial model
+        assert torch.allclose(
+            model.linear.weight, model_converted.base_model.model.linear.base_layer.weight, atol=tol, rtol=tol
+        )
+
+    def test_lora_pissa_conversion_same_output_after_loading_with_rank_pattern(self, data, tmp_path):
+        # same as above, but using rank_pattern
+        model = self.get_model()
+        output_base = model(data)[0]
+
+        # use rank_pattern here; note that since there is only a single linear layer, r is completely overridden
+        config = LoraConfig(init_lora_weights="pissa", target_modules=["linear"], r=8, rank_pattern={"linear": 32})
+        peft_model = get_peft_model(deepcopy(model), config)
+        # save the initial model
+        peft_model.peft_config["default"].init_lora_weights = True
+        peft_model.save_pretrained(tmp_path / "init-model")
+        peft_model.peft_config["default"].init_lora_weights = "pissa"
+
+        # modify the weights, or else the adapter performs an identity transformation
+        peft_model.base_model.linear.lora_B["default"].weight.data *= 2.0
+        output_pissa = peft_model(data)[0]
+
+        # sanity check
+        tol = 1e-06
+        assert not torch.allclose(output_base, output_pissa, atol=tol, rtol=tol)
+
+        # save the model normally
+        peft_model.save_pretrained(tmp_path / "pissa-model")
+        model_loaded = PeftModel.from_pretrained(deepcopy(model), tmp_path / "pissa-model")
+        output_loaded = model_loaded(data)[0]
+
+        assert torch.allclose(output_pissa, output_loaded, atol=tol, rtol=tol)
+        # sanity check: ranks should still be 8 as initially
+        assert model_loaded.peft_config["default"].r == 8
+        assert model_loaded.base_model.model.linear.lora_A["default"].weight.shape[0] == 32
+        # sanity check: the base model weights were indeed changed
+        assert not torch.allclose(
+            model.linear.weight, model_loaded.base_model.model.linear.base_layer.weight, atol=tol, rtol=tol
+        )
+
+        # save the model with conversion
+        peft_model.save_pretrained(
+            tmp_path / "pissa-model-converted", path_initial_model_for_weight_conversion=tmp_path / "init-model"
+        )
+        model_converted = PeftModel.from_pretrained(deepcopy(model), tmp_path / "pissa-model-converted")
+        output_converted = model_converted(data)[0]
+
+        assert torch.allclose(output_pissa, output_converted, atol=tol, rtol=tol)
+        # rank should be double of what it was initially
+        assert model_converted.peft_config["default"].r == 16
+        assert model_converted.base_model.model.linear.lora_A["default"].weight.shape[0] == 64
+        # base model weights should be the same as the initial model
+        assert torch.allclose(
+            model.linear.weight, model_converted.base_model.model.linear.base_layer.weight, atol=tol, rtol=tol
+        )
+
+    def test_lora_pissa_conversion_same_output_after_loading_with_alpha_pattern(self, data, tmp_path):
+        # same as above, but using alpha_pattern
+        model = self.get_model()
+        output_base = model(data)[0]
+
+        # use alpha_pattern here; note that since there is only a single linear layer, lora_alpha is completely
+        # overridden
+        config = LoraConfig(init_lora_weights="pissa", target_modules=["linear"], alpha_pattern={"linear": 5})
+        peft_model = get_peft_model(deepcopy(model), config)
+        # save the initial model
+        peft_model.peft_config["default"].init_lora_weights = True
+        peft_model.save_pretrained(tmp_path / "init-model")
+        peft_model.peft_config["default"].init_lora_weights = "pissa"
+
+        # modify the weights, or else the adapter performs an identity transformation
+        peft_model.base_model.linear.lora_B["default"].weight.data *= 2.0
+        output_pissa = peft_model(data)[0]
+
+        # sanity check
+        tol = 1e-06
+        assert not torch.allclose(output_base, output_pissa, atol=tol, rtol=tol)
+
+        # save the model normally
+        peft_model.save_pretrained(tmp_path / "pissa-model")
+        model_loaded = PeftModel.from_pretrained(deepcopy(model), tmp_path / "pissa-model")
+        output_loaded = model_loaded(data)[0]
+
+        assert torch.allclose(output_pissa, output_loaded, atol=tol, rtol=tol)
+        # sanity check: ranks should still be 8 as initially
+        assert model_loaded.peft_config["default"].r == 8
+        assert model_loaded.base_model.model.linear.lora_A["default"].weight.shape[0] == 8
+        assert model_loaded.base_model.model.linear.scaling["default"] == 5 / 8
+        # sanity check: the base model weights were indeed changed
+        assert not torch.allclose(
+            model.linear.weight, model_loaded.base_model.model.linear.base_layer.weight, atol=tol, rtol=tol
+        )
+
+        # save the model with conversion
+        peft_model.save_pretrained(
+            tmp_path / "pissa-model-converted", path_initial_model_for_weight_conversion=tmp_path / "init-model"
+        )
+        model_converted = PeftModel.from_pretrained(deepcopy(model), tmp_path / "pissa-model-converted")
+        output_converted = model_converted(data)[0]
+
+        assert torch.allclose(output_pissa, output_converted, atol=tol, rtol=tol)
+        # rank should be double of what it was initially
+        assert model_converted.peft_config["default"].r == 16
+        assert model_converted.base_model.model.linear.lora_A["default"].weight.shape[0] == 16
+        assert model_converted.base_model.model.linear.scaling["default"] == 10 / 16
+        # base model weights should be the same as the initial model
+        assert torch.allclose(
+            model.linear.weight, model_converted.base_model.model.linear.base_layer.weight, atol=tol, rtol=tol
+        )
+
+    def test_lora_pissa_conversion_same_output_after_loading_with_rslora(self, data, tmp_path):
+        model = self.get_model()
+        output_base = model(data)[0]
+
+        config = LoraConfig(init_lora_weights="pissa", target_modules=["linear"], r=8, use_rslora=True)
+        peft_model = get_peft_model(deepcopy(model), config)
+        # save the initial model
+        peft_model.peft_config["default"].init_lora_weights = True
+        peft_model.save_pretrained(tmp_path / "init-model")
+        peft_model.peft_config["default"].init_lora_weights = "pissa"
+
+        # modify the weights, or else the adapter performs an identity transformation
+        peft_model.base_model.linear.lora_B["default"].weight.data *= 2.0
+        output_pissa = peft_model(data)[0]
+
+        # sanity check
+        tol = 1e-06
+        assert not torch.allclose(output_base, output_pissa, atol=tol, rtol=tol)
+
+        # save the model normally
+        peft_model.save_pretrained(tmp_path / "pissa-model")
+        model_loaded = PeftModel.from_pretrained(deepcopy(model), tmp_path / "pissa-model")
+        output_loaded = model_loaded(data)[0]
+
+        assert torch.allclose(output_pissa, output_loaded, atol=tol, rtol=tol)
+        # sanity check: ranks should still be 8 as initially
+        assert model_loaded.peft_config["default"].r == 8
+        assert model_loaded.base_model.model.linear.lora_A["default"].weight.shape[0] == 8
+        assert model_loaded.base_model.model.linear.scaling["default"] == 8 / (8**0.5)
+        # sanity check: the base model weights were indeed changed
+        assert not torch.allclose(
+            model.linear.weight, model_loaded.base_model.model.linear.base_layer.weight, atol=tol, rtol=tol
+        )
+
+        # save the model with conversion
+        peft_model.save_pretrained(
+            tmp_path / "pissa-model-converted", path_initial_model_for_weight_conversion=tmp_path / "init-model"
+        )
+        model_converted = PeftModel.from_pretrained(deepcopy(model), tmp_path / "pissa-model-converted")
+        output_converted = model_converted(data)[0]
+
+        assert torch.allclose(output_pissa, output_converted, atol=tol, rtol=tol)
+        # rank should be double of what it was initially
+        assert model_converted.peft_config["default"].r == 16
+        assert model_converted.base_model.model.linear.lora_A["default"].weight.shape[0] == 16
+        # same scale as before with a little bit of floating point imprecision
+        assert model_converted.base_model.model.linear.scaling["default"] == pytest.approx(8 / (8**0.5))
+        # base model weights should be the same as the initial model
+        assert torch.allclose(
+            model.linear.weight, model_converted.base_model.model.linear.base_layer.weight, atol=tol, rtol=tol
+        )
+
+    def test_pissa_rank_pattern_and_rslora_raises(self, tmp_path):
+        # it's not possible to determine the correct scale when using rslora with rank or alpha pattern, because the
+        # scale is not stored in the state_dict
+        model = self.get_model()
+        config = LoraConfig(
+            init_lora_weights="pissa", target_modules=["linear"], r=8, rank_pattern={"linear": 2}, use_rslora=True
+        )
+        peft_model = get_peft_model(model, config)
+        peft_model.save_pretrained(tmp_path / "init-model")
+
+        msg = re.escape("Passing `path_initial_model_for_weight_conversion` to `save_pretrained`")
+        with pytest.raises(ValueError, match=msg):
+            peft_model.save_pretrained(
+                tmp_path / "pissa-model", path_initial_model_for_weight_conversion=tmp_path / "init-model"
+            )
+
+    def test_pissa_alpha_pattern_and_rslora_raises(self, tmp_path):
+        # it's not possible to determine the correct scale when using rslora with rank or alpha pattern, because the
+        # scale is not stored in the state_dict
+        model = self.get_model()
+        config = LoraConfig(
+            init_lora_weights="pissa", target_modules=["linear"], r=8, alpha_pattern={"linear": 2}, use_rslora=True
+        )
+        peft_model = get_peft_model(model, config)
+        peft_model.save_pretrained(tmp_path / "init-model")
+
+        msg = re.escape("Passing `path_initial_model_for_weight_conversion` to `save_pretrained`")
+        with pytest.raises(ValueError, match=msg):
+            peft_model.save_pretrained(
+                tmp_path / "pissa-model", path_initial_model_for_weight_conversion=tmp_path / "init-model"
+            )
+
+    def test_olora_conversion_same_output_after_loading(self, data, tmp_path):
+        model = self.get_model()
+        output_base = model(data)[0]
+
+        config = LoraConfig(init_lora_weights="olora", target_modules=["linear"], r=8)
+        peft_model = get_peft_model(deepcopy(model), config)
+        # save the initial model
+        peft_model.save_pretrained(tmp_path / "init-model")
+
+        # modify the weights, or else the adapter performs an identity transformation
+        peft_model.base_model.linear.lora_B["default"].weight.data *= 2.0
+        output_olora = peft_model(data)[0]
+
+        # sanity check
+        tol = 1e-06
+        assert not torch.allclose(output_base, output_olora, atol=tol, rtol=tol)
+
+        # save the model normally
+        peft_model.save_pretrained(tmp_path / "olora-model")
+        model_loaded = PeftModel.from_pretrained(deepcopy(model), tmp_path / "olora-model")
+        output_loaded = model_loaded(data)[0]
+
+        assert torch.allclose(output_olora, output_loaded, atol=tol, rtol=tol)
+        # sanity check: ranks should still be 8 as initially
+        assert model_loaded.peft_config["default"].r == 8
+        assert model_loaded.base_model.model.linear.lora_A["default"].weight.shape[0] == 8
+        # sanity check: the base model weights were indeed changed
+        assert not torch.allclose(
+            model.linear.weight, model_loaded.base_model.model.linear.base_layer.weight, atol=tol, rtol=tol
+        )
+
+        # save the model with conversion
+        peft_config_keys_before = list(peft_model.peft_config.keys())
+        peft_config_dict_before = peft_model.peft_config["default"].to_dict()
+        peft_model.save_pretrained(
+            tmp_path / "olora-model-converted", path_initial_model_for_weight_conversion=tmp_path / "init-model"
+        )
+        peft_config_keys_after = list(peft_model.peft_config.keys())
+        peft_config_dict_after = peft_model.peft_config["default"].to_dict()
+        assert peft_config_keys_before == peft_config_keys_after
+        assert peft_config_dict_before == peft_config_dict_after
+
+        model_converted = PeftModel.from_pretrained(deepcopy(model), tmp_path / "olora-model-converted")
+        output_converted = model_converted(data)[0]
+
+        assert torch.allclose(output_olora, output_converted, atol=tol, rtol=tol)
+        # rank should be double of what it was initially
+        assert model_converted.peft_config["default"].r == 16
+        assert model_converted.base_model.model.linear.lora_A["default"].weight.shape[0] == 16
+        # base model weights should be the same as the initial model
+        assert torch.allclose(
+            model.linear.weight, model_converted.base_model.model.linear.base_layer.weight, atol=tol, rtol=tol
+        )
+
+    def test_olora_conversion_same_output_after_loading_with_rank_pattern(self, data, tmp_path):
+        # same as above, but using rank_pattern
+        model = self.get_model()
+        output_base = model(data)[0]
+
+        # use rank_pattern here; note that since there is only a single linear layer, r is completely overridden
+        config = LoraConfig(init_lora_weights="olora", target_modules=["linear"], r=8, rank_pattern={"linear": 32})
+        peft_model = get_peft_model(deepcopy(model), config)
+        # save the initial model
+        peft_model.save_pretrained(tmp_path / "init-model")
+
+        # modify the weights, or else the adapter performs an identity transformation
+        peft_model.base_model.linear.lora_B["default"].weight.data *= 2.0
+        output_olora = peft_model(data)[0]
+
+        # sanity check
+        tol = 1e-06
+        assert not torch.allclose(output_base, output_olora, atol=tol, rtol=tol)
+
+        # save the model normally
+        peft_model.save_pretrained(tmp_path / "olora-model")
+        model_loaded = PeftModel.from_pretrained(deepcopy(model), tmp_path / "olora-model")
+        output_loaded = model_loaded(data)[0]
+
+        assert torch.allclose(output_olora, output_loaded, atol=tol, rtol=tol)
+        # sanity check: ranks should still be 8 as initially
+        assert model_loaded.peft_config["default"].r == 8
+        assert model_loaded.base_model.model.linear.lora_A["default"].weight.shape[0] == 32
+        # sanity check: the base model weights were indeed changed
+        assert not torch.allclose(
+            model.linear.weight, model_loaded.base_model.model.linear.base_layer.weight, atol=tol, rtol=tol
+        )
+
+        # save the model with conversion
+        peft_model.save_pretrained(
+            tmp_path / "olora-model-converted", path_initial_model_for_weight_conversion=tmp_path / "init-model"
+        )
+        model_converted = PeftModel.from_pretrained(deepcopy(model), tmp_path / "olora-model-converted")
+        output_converted = model_converted(data)[0]
+
+        assert torch.allclose(output_olora, output_converted, atol=tol, rtol=tol)
+        # rank should be double of what it was initially
+        assert model_converted.peft_config["default"].r == 16
+        assert model_converted.base_model.model.linear.lora_A["default"].weight.shape[0] == 64
+        # base model weights should be the same as the initial model
+        assert torch.allclose(
+            model.linear.weight, model_converted.base_model.model.linear.base_layer.weight, atol=tol, rtol=tol
+        )
+
+    def test_olora_conversion_same_output_after_loading_with_alpha_pattern(self, data, tmp_path):
+        # same as above, but using alpha_pattern
+        model = self.get_model()
+        output_base = model(data)[0]
+
+        # use alpha_pattern here; note that since there is only a single linear layer, lora_alpha is completely
+        # overridden
+        config = LoraConfig(init_lora_weights="olora", target_modules=["linear"], alpha_pattern={"linear": 5})
+        peft_model = get_peft_model(deepcopy(model), config)
+        # save the initial model
+        peft_model.save_pretrained(tmp_path / "init-model")
+
+        # modify the weights, or else the adapter performs an identity transformation
+        peft_model.base_model.linear.lora_B["default"].weight.data *= 2.0
+        output_olora = peft_model(data)[0]
+
+        # sanity check
+        tol = 1e-06
+        assert not torch.allclose(output_base, output_olora, atol=tol, rtol=tol)
+
+        # save the model normally
+        peft_model.save_pretrained(tmp_path / "olora-model")
+        model_loaded = PeftModel.from_pretrained(deepcopy(model), tmp_path / "olora-model")
+        output_loaded = model_loaded(data)[0]
+
+        assert torch.allclose(output_olora, output_loaded, atol=tol, rtol=tol)
+        # sanity check: ranks should still be 8 as initially
+        assert model_loaded.peft_config["default"].r == 8
+        assert model_loaded.base_model.model.linear.lora_A["default"].weight.shape[0] == 8
+        assert model_loaded.base_model.model.linear.scaling["default"] == 5 / 8
+        # sanity check: the base model weights were indeed changed
+        assert not torch.allclose(
+            model.linear.weight, model_loaded.base_model.model.linear.base_layer.weight, atol=tol, rtol=tol
+        )
+
+        # save the model with conversion
+        peft_model.save_pretrained(
+            tmp_path / "olora-model-converted", path_initial_model_for_weight_conversion=tmp_path / "init-model"
+        )
+        model_converted = PeftModel.from_pretrained(deepcopy(model), tmp_path / "olora-model-converted")
+        output_converted = model_converted(data)[0]
+
+        assert torch.allclose(output_olora, output_converted, atol=tol, rtol=tol)
+        # rank should be double of what it was initially
+        assert model_converted.peft_config["default"].r == 16
+        assert model_converted.base_model.model.linear.lora_A["default"].weight.shape[0] == 16
+        assert model_converted.base_model.model.linear.scaling["default"] == 10 / 16
+        # base model weights should be the same as the initial model
+        assert torch.allclose(
+            model.linear.weight, model_converted.base_model.model.linear.base_layer.weight, atol=tol, rtol=tol
+        )
+
+    def test_olora_conversion_same_output_after_loading_with_rslora(self, data, tmp_path):
+        # same as above, but using alpha_pattern
+        model = self.get_model()
+        output_base = model(data)[0]
+
+        config = LoraConfig(init_lora_weights="olora", target_modules=["linear"], r=8, use_rslora=True)
+        peft_model = get_peft_model(deepcopy(model), config)
+        # save the initial model
+        peft_model.save_pretrained(tmp_path / "init-model")
+
+        # modify the weights, or else the adapter performs an identity transformation
+        peft_model.base_model.linear.lora_B["default"].weight.data *= 2.0
+        output_olora = peft_model(data)[0]
+
+        # sanity check
+        tol = 1e-06
+        assert not torch.allclose(output_base, output_olora, atol=tol, rtol=tol)
+
+        # save the model normally
+        peft_model.save_pretrained(tmp_path / "olora-model")
+        model_loaded = PeftModel.from_pretrained(deepcopy(model), tmp_path / "olora-model")
+        output_loaded = model_loaded(data)[0]
+
+        assert torch.allclose(output_olora, output_loaded, atol=tol, rtol=tol)
+        # sanity check: ranks should still be 8 as initially
+        assert model_loaded.peft_config["default"].r == 8
+        assert model_loaded.base_model.model.linear.lora_A["default"].weight.shape[0] == 8
+        assert model_loaded.base_model.model.linear.scaling["default"] == 8 / (8**0.5)
+        # sanity check: the base model weights were indeed changed
+        assert not torch.allclose(
+            model.linear.weight, model_loaded.base_model.model.linear.base_layer.weight, atol=tol, rtol=tol
+        )
+
+        # save the model with conversion
+        peft_model.save_pretrained(
+            tmp_path / "olora-model-converted", path_initial_model_for_weight_conversion=tmp_path / "init-model"
+        )
+        model_converted = PeftModel.from_pretrained(deepcopy(model), tmp_path / "olora-model-converted")
+        output_converted = model_converted(data)[0]
+
+        assert torch.allclose(output_olora, output_converted, atol=tol, rtol=tol)
+        # rank should be double of what it was initially
+        assert model_converted.peft_config["default"].r == 16
+        assert model_converted.base_model.model.linear.lora_A["default"].weight.shape[0] == 16
+        # same scale as before with a little bit of floating point imprecision
+        assert model_converted.base_model.model.linear.scaling["default"] == pytest.approx(8 / (8**0.5))
+        # base model weights should be the same as the initial model
+        assert torch.allclose(
+            model.linear.weight, model_converted.base_model.model.linear.base_layer.weight, atol=tol, rtol=tol
+        )
+
+    def test_olora_rank_pattern_and_rslora_raises(self, tmp_path):
+        # it's not possible to determine the correct scale when using rslora with rank or alpha pattern, because the
+        # scale is not stored in the state_dict
+        model = self.get_model()
+        config = LoraConfig(
+            init_lora_weights="olora", target_modules=["linear"], r=8, rank_pattern={"linear": 2}, use_rslora=True
+        )
+        peft_model = get_peft_model(model, config)
+        peft_model.save_pretrained(tmp_path / "init-model")
+
+        msg = re.escape("Passing `path_initial_model_for_weight_conversion` to `save_pretrained`")
+        with pytest.raises(ValueError, match=msg):
+            peft_model.save_pretrained(
+                tmp_path / "olora-model", path_initial_model_for_weight_conversion=tmp_path / "init-model"
+            )
+
+    def test_olora_alpha_pattern_and_rslora_raises(self, tmp_path):
+        # it's not possible to determine the correct scale when using rslora with rank or alpha pattern, because the
+        # scale is not stored in the state_dict
+        model = self.get_model()
+        config = LoraConfig(
+            init_lora_weights="olora", target_modules=["linear"], r=8, alpha_pattern={"linear": 2}, use_rslora=True
+        )
+        peft_model = get_peft_model(model, config)
+        peft_model.save_pretrained(tmp_path / "init-model")
+
+        msg = re.escape("Passing `path_initial_model_for_weight_conversion` to `save_pretrained`")
+        with pytest.raises(ValueError, match=msg):
+            peft_model.save_pretrained(
+                tmp_path / "olora-model", path_initial_model_for_weight_conversion=tmp_path / "init-model"
+            )
+
+    @pytest.mark.parametrize(
+        "config_kwargs, should_warn",
+        [
+            # no warning
+            ({"init_lora_weights": "pissa", "target_modules": ["linear"]}, False),
+            ({"init_lora_weights": "pissa_niter_3", "target_modules": ["linear"]}, False),
+            ({"init_lora_weights": "olora", "target_modules": ["linear"]}, False),
+            ({"init_lora_weights": "pissa", "target_modules": ["linear"], "use_rslora": True}, False),
+            ({"init_lora_weights": "pissa_niter_3", "target_modules": ["linear"], "use_rslora": True}, False),
+            ({"init_lora_weights": "olora", "target_modules": ["linear"], "use_rslora": True}, False),
+            ({"init_lora_weights": "pissa", "target_modules": ["linear"], "rank_pattern": {"linear": 8}}, False),
+            (
+                {"init_lora_weights": "pissa_niter_3", "target_modules": ["linear"], "rank_pattern": {"linear": 8}},
+                False,
+            ),
+            ({"init_lora_weights": "olora", "target_modules": ["linear"], "rank_pattern": {"linear": 8}}, False),
+            ({"init_lora_weights": "pissa", "target_modules": ["linear"], "alpha_pattern": {"linear": 8}}, False),
+            (
+                {"init_lora_weights": "pissa_niter_3", "target_modules": ["linear"], "alpha_pattern": {"linear": 8}},
+                False,
+            ),
+            ({"init_lora_weights": "olora", "target_modules": ["linear"], "alpha_pattern": {"linear": 8}}, False),
+            # warning
+            (
+                {
+                    "init_lora_weights": "pissa",
+                    "target_modules": ["linear"],
+                    "use_rslora": True,
+                    "rank_pattern": {"linear": 8},
+                },
+                True,
+            ),
+            (
+                {
+                    "init_lora_weights": "pissa_niter_3",
+                    "target_modules": ["linear"],
+                    "use_rslora": True,
+                    "rank_pattern": {"linear": 8},
+                },
+                True,
+            ),
+            (
+                {
+                    "init_lora_weights": "olora",
+                    "target_modules": ["linear"],
+                    "use_rslora": True,
+                    "rank_pattern": {"linear": 8},
+                },
+                True,
+            ),
+            (
+                {
+                    "init_lora_weights": "pissa",
+                    "target_modules": ["linear"],
+                    "use_rslora": True,
+                    "alpha_pattern": {"linear": 8},
+                },
+                True,
+            ),
+            (
+                {
+                    "init_lora_weights": "pissa_niter_3",
+                    "target_modules": ["linear"],
+                    "use_rslora": True,
+                    "alpha_pattern": {"linear": 8},
+                },
+                True,
+            ),
+            (
+                {
+                    "init_lora_weights": "olora",
+                    "target_modules": ["linear"],
+                    "use_rslora": True,
+                    "alpha_pattern": {"linear": 8},
+                },
+                True,
+            ),
+            (
+                {
+                    "init_lora_weights": "pissa",
+                    "target_modules": ["linear"],
+                    "use_rslora": True,
+                    "rank_pattern": {"linear": 8},
+                    "alpha_pattern": {"linear": 8},
+                },
+                True,
+            ),
+            (
+                {
+                    "init_lora_weights": "pissa_niter_3",
+                    "target_modules": ["linear"],
+                    "use_rslora": True,
+                    "rank_pattern": {"linear": 8},
+                    "alpha_pattern": {"linear": 8},
+                },
+                True,
+            ),
+            (
+                {
+                    "init_lora_weights": "olora",
+                    "target_modules": ["linear"],
+                    "use_rslora": True,
+                    "rank_pattern": {"linear": 8},
+                    "alpha_pattern": {"linear": 8},
+                },
+                True,
+            ),
+        ],
+    )
+    def test_lora_config_pissa_olora_warns(self, config_kwargs, should_warn, recwarn):
+        # Using post training conversion of modified base weights to restore their initial values (PiSSA, OLoRA) cannot
+        # be correctly done when using rslora + rank_pattern/alpha_pattern. We can't really know if the user intends
+        # this when they'll eventually call save_pretrained (i.e. if they'll pass
+        # path_initial_model_for_weight_conversionl). Therefore, we only warn but don't raise an error here.
+        msg = re.escape("Using Rank-Stabilized LoRA with rank_pattern/alpha_pattern and post-training conversion")
+        if should_warn:
+            LoraConfig(**config_kwargs)
+            assert len(recwarn.list) == 1
+            with pytest.warns(UserWarning, match=msg):
+                LoraConfig(**config_kwargs)
+        else:
+            LoraConfig(**config_kwargs)
+            assert not recwarn.list
+
+    @pytest.mark.parametrize("init_method", ["pissa", "olora"])
+    @pytest.mark.parametrize("pissa_olora_loaded_first", [False, True])
+    def test_load_pissa_olora_with_other_adapter_warns(self, init_method, pissa_olora_loaded_first, recwarn, tmp_path):
+        # Since PiSSA/OLoRA modifies the base weights, it should not be combined with other adapters. Check for a
+        # warning. See #2184.
+
+        # create an adapter without PiSSA/OloRA
+        model_id = "peft-internal-testing/tiny-random-OPTForCausalLM"
+        model = AutoModelForCausalLM.from_pretrained(model_id)
+        model = get_peft_model(model, LoraConfig(init_lora_weights=True))
+        model.save_pretrained(tmp_path / "adapter0")
+        del model
+
+        # create a model with PiSSA/OLoRA
+        model = AutoModelForCausalLM.from_pretrained(model_id)
+        model = get_peft_model(model, LoraConfig(init_lora_weights=init_method))
+        model.save_pretrained(tmp_path / "adapter1")
+        del model
+
+        # load the model
+        if pissa_olora_loaded_first:
+            path0, path1 = tmp_path / "adapter1", tmp_path / "adapter0"
+        else:
+            path0, path1 = tmp_path / "adapter0", tmp_path / "adapter1"
+
+        model = AutoModelForCausalLM.from_pretrained(model_id)
+        model = PeftModel.from_pretrained(model, path0)
+        model = model.load_adapter(path1, adapter_name="other")
+
+        if init_method == "pissa":
+            msg = "PiSSA changes the base weights of the model and should thus not be used with other adapters"
+        else:
+            msg = "OLoRA changes the base weights of the model and should thus not be used with other adapters"
+        assert any(str(w.message).startswith(msg) for w in recwarn.list)
+
+    def test_lora_rslora_scaling(self):
+        # default is True
+        torch.manual_seed(0)
+
+        model = self.get_model()
+
+        # check scaling factor use_rslora=True
+        config = LoraConfig(target_modules=["linear", "embed", "conv2d"], lora_alpha=3, r=16, use_rslora=True)
+        model = get_peft_model(model, config)
+
+        expected_scaling = config.lora_alpha / (config.r**0.5)
+
+        assert model.linear.scaling["default"] == expected_scaling
+        assert model.embed.scaling["default"] == expected_scaling
+        assert model.conv2d.scaling["default"] == expected_scaling
+
+    def test_lora_default_scaling_pattern(self):
+        # default is True
+        torch.manual_seed(0)
+
+        model = self.get_model()
+
+        # check scaling factor use_rslora=False with rank and alpha pattern
+        config = LoraConfig(
+            target_modules=["linear", "embed", "conv2d"],
+            rank_pattern={"embed": 9, "conv2d": 16},
+            alpha_pattern={"linear": 11, "conv2d": 13},
+            lora_alpha=17,
+            r=25,
+            use_rslora=False,
+        )
+        model = get_peft_model(model, config)
+
+        expected_scaling = {
+            "linear": config.alpha_pattern["linear"] / config.r,
+            "embed": config.lora_alpha / config.rank_pattern["embed"],
+            "conv2d": config.alpha_pattern["conv2d"] / config.rank_pattern["conv2d"],
+        }
+
+        assert model.linear.scaling["default"] == expected_scaling["linear"]
+        assert model.embed.scaling["default"] == expected_scaling["embed"]
+        assert model.conv2d.scaling["default"] == expected_scaling["conv2d"]
+
+    def test_lora_rslora_scaling_pattern(self):
+        # default is True
+        torch.manual_seed(0)
+
+        model = self.get_model()
+
+        # check scaling factor use_rslora=True with rank and alpha pattern
+        config = LoraConfig(
+            target_modules=["linear", "embed", "conv2d"],
+            rank_pattern={"embed": 9, "conv2d": 16},
+            alpha_pattern={"linear": 11, "conv2d": 13},
+            lora_alpha=17,
+            r=25,
+            use_rslora=True,
+        )
+        model = get_peft_model(model, config)
+
+        expected_scaling = {
+            "linear": config.alpha_pattern["linear"] / (config.r**0.5),
+            "embed": config.lora_alpha / (config.rank_pattern["embed"] ** 0.5),
+            "conv2d": config.alpha_pattern["conv2d"] / (config.rank_pattern["conv2d"] ** 0.5),
+        }
+
+        assert model.linear.scaling["default"] == expected_scaling["linear"]
+        assert model.embed.scaling["default"] == expected_scaling["embed"]
+        assert model.conv2d.scaling["default"] == expected_scaling["conv2d"]
+
+    def test_modules_to_save_targets_lora_layer_raises(self):
+        # There is no good reason to have auxiliary modules to target a LoRA layer. As auxiliary modules are applied
+        # *after* BaseTunerLayers, a possible way for this to happen accidentally is if the
+        # modules_to_save/trainable_token_indices coincide with the adapter name, e.g. if the adapter name is "foobar",
+        # we can have a module named model.base_model.model.self_attn.lora_A.foobar. If
+        # modules_to_save/trainable_token_indices is also "foobar", there would be a match.
+        # Note: Theoretically, a lot more PEFT methods support modules_to_save, so would have to be tested, but the code
+        # path is the same for all of them, so only testing LoRA.
+        model = self.get_model()
+
+        config = LoraConfig(
+            target_modules=["linear"],
+            modules_to_save=["foobar"],
+        )
+        msg = (
+            "You are trying to target a module with <class 'peft.utils.other.ModulesToSaveWrapper'> that is a child of "
+            "<class 'peft.tuners.lora.layer.Linear'>. This is almost certainly not the intended behavior. Please "
+            "ensure that the adapter name, 'foobar', does not conflict with any of the targeted modules."
+        )
+        with pytest.raises(ValueError, match=msg):
+            get_peft_model(model, config, adapter_name="foobar")
+
+    def test_trainable_token_indices_targets_lora_layer_raises(self):
+        # Same test as test_modules_to_save_targets_lora_layer_raises, but using trainable_token_indices
+        model = self.get_model()
+
+        # check scaling factor use_rslora=True with rank and alpha pattern
+        config = LoraConfig(target_modules=["embed"], trainable_token_indices={"foobar": [1, 2, 3]})
+        msg = (
+            "You are trying to target a module with <class 'peft.utils.other.TrainableTokensWrapper'> that is a child "
+            "of <class 'peft.tuners.lora.layer.Embedding'>. This is almost certainly not the intended behavior. Please "
+            "ensure that the adapter name, 'foobar', does not conflict with any of the targeted modules."
+        )
+        with pytest.raises(ValueError, match=msg):
+            get_peft_model(model, config, adapter_name="foobar")
+
+    def test_trainable_token_indices_targets_head_and_embedding(self):
+        # targeting embedding and LM head explicitly, see #2863
+        model_id = "peft-internal-testing/tiny-random-OPTForCausalLM"
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            config = LoraConfig(trainable_token_indices={"lm_head": [0], "embed_tokens": [0]})
+            get_peft_model(model, config)  # does not raise
+
+    @require_deterministic_for_xpu
+    def test_lora_use_dora_linear(self, data):
+        # check that dora is a no-op when initialized
+        torch.manual_seed(0)
+        model = self.get_model()
+        output_base, _, _ = model(data)
+
+        # check scaling factor use_rslora=True
+        config = LoraConfig(target_modules=["linear"], use_dora=True)
+        model = get_peft_model(model, config)
+
+        with model.disable_adapter():
+            output_disabled, _, _ = model(data)
+        output_dora, _, _ = model(data)
+
+        assert torch.allclose(output_base, output_disabled)
+        assert torch.allclose(output_base, output_dora)
+
+    @require_deterministic_for_xpu
+    def test_lora_use_dora_linear_init_false(self, data):
+        # with init_lora_weights=False, dora should not be a no-op
+        torch.manual_seed(0)
+        model = self.get_model()
+        output_base, _, _ = model(data)
+
+        # check scaling factor use_rslora=True
+        config = LoraConfig(target_modules=["linear"], use_dora=True, init_lora_weights=False)
+        model = get_peft_model(model, config)
+
+        with model.disable_adapter():
+            output_disabled, _, _ = model(data)
+        output_dora, _, _ = model(data)
+
+        assert torch.allclose(output_base, output_disabled)
+        assert not torch.allclose(output_base, output_dora)
+
+    def test_lora_use_dora_with_megatron_core_raises(self):
+        megatron_config = {"does-not": "matter-here"}
+        with pytest.raises(ValueError, match="DoRA does not support megatron_core"):
+            LoraConfig(target_modules=["linear"], use_dora=True, megatron_config=megatron_config)
+
+    def test_bdlora_both_patterns_raises(self):
+        model = self.get_model()
+
+        bdlora_config = {"target_modules_bd_a": ["linear"], "target_modules_bd_b": ["linear"], "nblocks": 2}
+
+        config = LoraConfig(target_modules=["linear"], use_bdlora=bdlora_config)
+
+        with pytest.raises(ValueError, match="Found overlapping modules in target_modules_bd lists"):
+            get_peft_model(model, config)
+
+    def test_bdlora_strict_matching_raises(self):
+        model = self.get_model()
+
+        bdlora_config = {
+            "target_modules_bd_a": ["nonexistent"],
+            "target_modules_bd_b": [],
+            "nblocks": 2,
+            "match_strict": True,
+        }
+
+        config = LoraConfig(target_modules=["linear"], use_bdlora=bdlora_config)
+
+        with pytest.raises(ValueError, match="matches neither A nor B block-diagonal patterns"):
+            get_peft_model(model, config)
+
+    def test_bdlora_feature_size_non_divisible_by_blocksize_raises(self):
+        model = self.get_model()
+        bdlora_config = {
+            "target_modules_bd_a": ["linear"],
+            "target_modules_bd_b": [],
+            "nblocks": 13,
+            "match_strict": True,
+        }
+        config = LoraConfig(target_modules=["linear"], use_bdlora=bdlora_config)
+
+        with pytest.raises(ValueError, match="not divisible by"):
+            get_peft_model(model, config)
+
+    @pytest.fixture
+    def mha_cls(self):
+        class ModelMha(nn.Module):
+            def __init__(self, kdim=None, vdim=None):
+                super().__init__()
+                self.mha = nn.MultiheadAttention(10, 2, kdim=kdim, vdim=vdim)
+                self.lin0 = nn.Linear(10, 2)
+                self.sm = nn.LogSoftmax(dim=-1)
+
+            def forward(self, X):
+                X = X.float()
+                X, _ = self.mha(X, X, X)
+                X = self.lin0(X)
+                X = self.sm(X)
+                return X
+
+        return ModelMha
+
+    def test_mha_load_init_model_first(self, mha_cls):
+        # This test used to fail and require a workaround, for more context, see:
+        # https://github.com/huggingface/peft/pull/1324#issuecomment-2252473980
+        # The workaround was that _restore_weights had to be called manually on lora.MHA layers in order to make loading
+        # the state dict work. With recent changes, this workaround is no longer required, so that test has been
+        # deleted.
+        inputs = torch.rand(10, 10, 10)
+        model = mha_cls()
+        config = LoraConfig(target_modules=["mha"], init_lora_weights=False)
+        model = get_peft_model(model, config).eval()
+        restore_state_dict = {k: v.detach().cpu() for k, v in model.state_dict().items()}
+
+        del model
+
+        model = mha_cls()
+        model = get_peft_model(model, config)
+        # the workaround used to be:
+        # for module in model.modules():
+        #     if isinstance(module, peft.tuners.lora.layer.MultiheadAttention):
+        #         module._restore_weights()
+        model(inputs)
+        model.load_state_dict(restore_state_dict)
+
+    def test_mha_with_separate_qkv_embed_raises(self, mha_cls):
+        # passing different kdim and vdim results in separate parameters for q, k, v, which is not supported (yet)
+        model = mha_cls(kdim=20, vdim=30)
+        config = LoraConfig(target_modules=["mha"])
+        msg = "Only same embed for query/key/value is supported as of now for MultiheadAttention"
+        with pytest.raises(ValueError, match=msg):
+            get_peft_model(model, config)
+
+    def test_mha_with_dora_raises(self, mha_cls):
+        model = mha_cls()
+        config = LoraConfig(target_modules=["mha"], use_dora=True)
+        msg = re.escape("MultiheadAttention does not support DoRA (yet), please set use_dora to False")
+        with pytest.raises(ValueError, match=msg):
+            get_peft_model(model, config)
+
+    def test_mha_exposes_attributes(self, mha_cls):
+        # MHA requires a bunch of attributes to be exposed, try to check them exhaustively here
+        model = mha_cls()
+        embed_dim = model.mha.embed_dim
+        kdim = model.mha.kdim
+        vdim = model.mha.vdim
+        qkv_same_embed_dim = model.mha._qkv_same_embed_dim
+        num_heads = model.mha.num_heads
+        dropout = model.mha.dropout
+        batch_first = model.mha.batch_first
+        head_dim = model.mha.head_dim
+        in_proj_weight = model.mha.in_proj_weight
+        in_proj_bias = model.mha.in_proj_bias
+        out_proj = model.mha.out_proj
+        bias_k = model.mha.bias_k
+        bias_v = model.mha.bias_v
+        add_zero_attn = model.mha.add_zero_attn
+
+        config = LoraConfig(target_modules=["mha"])
+        peft_model = get_peft_model(model, config)
+        assert peft_model.base_model.mha.embed_dim == embed_dim
+        assert peft_model.base_model.mha.kdim == kdim
+        assert peft_model.base_model.mha.vdim == vdim
+        assert peft_model.base_model.mha._qkv_same_embed_dim == qkv_same_embed_dim
+        assert peft_model.base_model.mha.num_heads == num_heads
+        assert peft_model.base_model.mha.dropout == dropout
+        assert peft_model.base_model.mha.batch_first == batch_first
+        assert peft_model.base_model.mha.head_dim == head_dim
+        if in_proj_weight is not None:
+            assert torch.allclose(peft_model.base_model.mha.in_proj_weight, in_proj_weight)
+        else:
+            assert peft_model.base_model.mha.in_proj_weight is None
+        if in_proj_bias is not None:
+            assert torch.allclose(peft_model.base_model.mha.in_proj_bias, in_proj_bias)
+        else:
+            assert peft_model.base_model.mha.in_proj_bias is None
+        assert peft_model.base_model.mha.out_proj is out_proj
+        if bias_k is not None:
+            assert torch.allclose(peft_model.base_model.mha.bias_k, bias_k)
+        else:
+            assert peft_model.base_model.mha.bias_k is None
+        if bias_v is not None:
+            assert torch.allclose(peft_model.base_model.mha.bias_v, bias_v)
+        else:
+            assert peft_model.base_model.mha.bias_v is None
+        assert peft_model.base_model.mha.add_zero_attn == add_zero_attn
+
+    def test_mha_merge_masks_method(self, mha_cls):
+        # MHA requires a merge_masks method to be exposed, check that it works
+        model = mha_cls()
+        config = LoraConfig(target_modules=["mha"])
+        peft_model = get_peft_model(model, config)
+
+        attn_mask = torch.randint(0, 2, (10, 10))
+        key_padding_mask = torch.randint(0, 2, (10, 10))
+        query = torch.rand(10, 10, 10)
+        merged_mask0, mask_type0 = model.mha.merge_masks(attn_mask, key_padding_mask, query)
+        merged_mask1, mask_type1 = peft_model.base_model.mha.merge_masks(attn_mask, key_padding_mask, query)
+
+        assert torch.allclose(merged_mask0, merged_mask1)
+        assert mask_type0 == mask_type1
+
+    @pytest.mark.parametrize("bias", ["none", "all", "lora_only", "invalid"])
+    def test_lora_with_bias_argument(self, bias):
+        model = self.get_model()
+        config = LoraConfig(target_modules=["linear", "conv2d"], bias=bias)
+
+        if bias == "invalid":
+            with pytest.raises(NotImplementedError):
+                get_peft_model(model, config)
+            return
+
+        model = get_peft_model(model, config)  # does not raise
+        for name, param in model.named_parameters():
+            if not name.endswith("bias"):
+                continue
+            if bias == "none":
+                assert param.requires_grad is False
+            elif bias == "all":
+                assert param.requires_grad is True
+            elif bias == "lora_only":
+                # only layers targeted with target_modules
+                assert param.requires_grad is ("linear" in name) or ("conv2d" in name)
+
+    def test_lora_with_bias_extra_params(self):
+        # lora with lora_bias=True
+        model = self.get_model()
+        config = LoraConfig(target_modules=["linear", "conv2d"], lora_bias=False)
+        model_no_bias = get_peft_model(model, config)
+
+        model = self.get_model()
+        config = LoraConfig(target_modules=["linear", "conv2d"], lora_bias=True)
+        model_bias = get_peft_model(model, config)
+
+        # check that bias for LoRA B is set
+        assert model_no_bias.base_model.model.linear.lora_B["default"].bias is None
+        assert model_bias.base_model.model.linear.lora_B["default"].bias.shape == (1000,)
+        assert model_no_bias.base_model.model.conv2d.lora_B["default"].bias is None
+        assert model_bias.base_model.model.conv2d.lora_B["default"].bias.shape == (100,)
+
+        # check that the same params are present except for the extra bias term
+        params_no_bias = {name for name, _ in model_no_bias.named_parameters()}
+        params_bias = {name for name, _ in model_bias.named_parameters()}
+        extra_params = {
+            "base_model.model.linear.lora_B.default.bias",
+            "base_model.model.conv2d.lora_B.default.bias",
+        }
+        assert params_bias - params_no_bias == extra_params
+        assert params_no_bias.issubset(params_bias)
+
+    def test_lora_with_bias_embedding_raises(self):
+        # lora with lora_bias=True is not supported for embedding layers
+        model = self.get_model()
+        config = LoraConfig(target_modules=["embed"], lora_bias=True)
+        msg = "lora_bias=True is not supported for Embedding"
+        with pytest.raises(ValueError, match=msg):
+            get_peft_model(model, config)
+
+    @pytest.mark.parametrize(
+        "extra_kwargs",
+        [
+            {"use_dora": True},
+            {"init_lora_weights": "eva"},
+            {"init_lora_weights": "gaussian"},
+            {"init_lora_weights": "loftq", "loftq_config": LoftQConfig()},
+            {"init_lora_weights": "olora"},
+            {"init_lora_weights": "pissa"},
+            {"init_lora_weights": "pissa_niter_3"},
+            {"init_lora_weights": "orthogonal"},
+        ],
+    )
+    def test_lora_with_bias_incompatible_arguments(self, extra_kwargs):
+        # some arguments don't work in conjunction with lora_bias and should raise
+        # just check the common chunk of the error message
+        msg = "The argument lora_bias=True is"
+        with pytest.raises(ValueError, match=msg):
+            LoraConfig(target_modules=["linear"], lora_bias=True, **extra_kwargs)
+
+    def test_lora_linear_with_bias_when_base_layer_has_no_bias_warns(self):
+        model = self.get_model(bias=False)
+        config = LoraConfig(target_modules=["linear"], lora_bias=True)
+        msg = re.escape("`lora_bias=True` was passed but the targeted layer of type Linear has no bias")
+        with pytest.warns(PeftWarning, match=msg):
+            get_peft_model(model, config)
+
+    def test_lora_conv2d_with_bias_when_base_layer_has_no_bias_warns(self):
+        model = self.get_model(bias=False)
+        config = LoraConfig(target_modules=["conv2d"], lora_bias=True)
+        msg = re.escape("`lora_bias=True` was passed but the targeted layer of type Conv2d has no bias")
+        with pytest.warns(PeftWarning, match=msg):
+            get_peft_model(model, config)
+
+    def test_lora_incompatible_mamba_modules(self):
+        # Ensure LoRA raises an error when applying to forbidden modules
+        # ('out_proj', 'conv1d') in Mamba-based architectures like Falcon-Mamba tiny.
+        model = AutoModelForCausalLM.from_pretrained("tiiuae/falcon-mamba-tiny-dev")
+
+        config = LoraConfig(
+            task_type="CAUSAL_LM",
+            target_modules=["out_proj", "conv1d"],  # Forbidden modules for Mamba-based models
+        )
+        msg = "is incompatible with Mamba-based models"
+        with pytest.raises(ValueError, match=msg):
+            get_peft_model(model, config)
+
+    def test_nemotron_h_has_defaults_and_blocks_mamba_modules(self):
+        # Nemotron-H is a hybrid Mamba + Attention (+ MoE) architecture. It must
+        # (a) have default target modules (the attention q/k/v/o_proj) so that
+        # target_modules=None resolves without error, and (b) be treated as a
+        # Mamba-based model so that targeting a Mamba mixer module such as
+        # `out_proj` raises (see test_lora_incompatible_mamba_modules above).
+        model_id = "trl-internal-testing/tiny-NemotronHForCausalLM-nano"
+        with hub_online_once(model_id):
+            # (a) target_modules=None falls back to the nemotron_h defaults
+            # (q/k/v/o_proj attention projections), which exist -> does not raise
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            get_peft_model(model, LoraConfig(task_type="CAUSAL_LM"))  # does not raise
+
+            # (b) nemotron_h is registered as a Mamba-based model, so targeting
+            # the Mamba mixer's `out_proj` is forbidden and must raise
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            config = LoraConfig(task_type="CAUSAL_LM", target_modules=["out_proj"])
+            msg = "is incompatible with Mamba-based models"
+            with pytest.raises(ValueError, match=msg):
+                get_peft_model(model, config)
+
+    def get_model_conv2d_groups(self):
+        class ModelConv2DGroups(nn.Module):
+            """For testing when groups argument is used in conv layer"""
+
+            def __init__(self):
+                super().__init__()
+                self.conv2d = nn.Conv2d(16, 32, 3, padding=1, groups=2)
+                self.relu = nn.ReLU()
+                self.flat = nn.Flatten()
+                self.lin0 = nn.Linear(12800, 2)
+                self.sm = nn.LogSoftmax(dim=-1)
+                self.dtype = torch.float
+
+            def forward(self, X):
+                # This is ignoring input since main usage is for checking raising of error when peft is applied
+                X = torch.arange(9 * 16 * 20 * 20).view([9, 16, 20, 20]).to(self.conv2d.weight.device)
+                X = X.to(self.dtype)
+                X = self.conv2d(X)
+                X = self.relu(X)
+                X = self.flat(X)
+                X = self.lin0(X)
+                X = self.sm(X)
+                return X
+
+        return ModelConv2DGroups().eval().to(self.torch_device)
+
+    @pytest.mark.parametrize(
+        "config_cls, config_kwargs",
+        [
+            pytest.param(LoraConfig, {"r": 8, "target_modules": ["conv2d"]}, id="lora with rank divisible by groups"),
+            pytest.param(LoraConfig, {"r": 2, "target_modules": ["conv2d"]}, id="lora with rank equal to groups"),
+            pytest.param(
+                LoraConfig, {"r": 1, "target_modules": ["conv2d"]}, id="lora with rank not divisible by groups"
+            ),
+            pytest.param(
+                LoraConfig,
+                {"r": 8, "target_modules": ["conv2d"], "use_dora": True},
+                id="dora with rank divisible by groups",
+            ),
+            pytest.param(
+                LoraConfig,
+                {"r": 2, "target_modules": ["conv2d"], "use_dora": True},
+                id="dora with rank equal to groups",
+            ),
+            pytest.param(
+                LoraConfig,
+                {"r": 1, "target_modules": ["conv2d"], "use_dora": True},
+                id="dora with rank not divisible by groups",
+            ),
+        ],
+    )
+    def test_error_raised_if_rank_not_divisible_by_groups(self, config_cls, config_kwargs):
+        # This test checks if error is raised when rank is not divisible by groups for conv layer since
+        # currently, support is limited to conv layers where the rank is divisible by groups in lora and dora
+        base_model = self.get_model_conv2d_groups()
+        peft_config = config_cls(**config_kwargs)
+        r = config_kwargs["r"]
+        base_layer = base_model.conv2d
+        groups = base_layer.groups
+        if r % groups != 0:
+            with pytest.raises(
+                ValueError,
+                match=(
+                    f"Targeting a {base_layer.__class__.__name__} with groups={base_layer.groups} and rank {r}. "
+                    "Currently, support is limited to conv layers where the rank is divisible by groups. "
+                    "Either choose a different rank or do not target this specific layer."
+                ),
+            ):
+                peft_model = get_peft_model(base_model, peft_config)
+        else:
+            # No error should be raised
+            peft_model = get_peft_model(base_model, peft_config)
+
+    def test_target_module_and_target_parameter_on_same_layer(self):
+        # When targeting an nn.Parameter with LoRA using target_parameters, ensure that this is not already another LoRA
+        # layer (i.e. avoid double wrapping).
+        class MyModule(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.linear = nn.Linear(10, 10)
+
+        base_model = MyModule()
+        config = LoraConfig(target_modules=["linear"], target_parameters=["linear.weight"])
+        msg = "Trying to wrap an `nn.Parameter` of layer 'linear' of type Linear, which is not a valid target."
+        with pytest.raises(ValueError, match=msg):
+            get_peft_model(base_model, config)
+
+    @pytest.mark.parametrize("target_parameters", [["linear"], ["foobar"], ["foobar.weight"], ["foo", "bar"]])
+    @pytest.mark.parametrize("target_modules", [None, [], ""])
+    def test_valid_no_target_module_nor_target_parameter_match_raises(self, target_parameters, target_modules):
+        model = self.get_model()
+        config = LoraConfig(target_modules=target_modules, target_parameters=target_parameters)
+        msg = re.escape(
+            "No `target_modules` passed but also no `target_parameters` found. Please check the values for "
+            "these arguments."
+        )
+        with pytest.raises(ValueError, match=msg):
+            get_peft_model(model, config)
+
+    def test_target_parameters_wrong_type_raises(self):
+        # Check that target_parameters being a string raises a useful error message -- this is an easy mistake to make
+        # because strings are allowed for target_modules
+        model = self.get_model()
+        msg = "`target_parameters` must be a list of strings or None."
+        with pytest.raises(TypeError, match=msg):
+            LoraConfig(target_parameters="linear.weight")
+
+    def test_valid_target_parameters_invalid_target_modules_warns(self):
+        model = self.get_model()
+        config = LoraConfig(target_modules=["foobar"], target_parameters=["linear.weight"])
+        msg = re.escape("target_modules={'foobar'} were set but no module was matched.")
+        with pytest.warns(RuntimeWarning, match=msg):
+            get_peft_model(model, config)
+
+    def test_valid_target_modules_invalid_target_parameters_warns(self):
+        model = self.get_model()
+        config = LoraConfig(target_modules=["linear"], target_parameters=["foobar.weight"])
+        msg = re.escape("target_parameters=['foobar.weight'] were set but no parameter was matched.")
+        with pytest.warns(RuntimeWarning, match=msg):
+            get_peft_model(model, config)
+
+    def test_adding_multiple_adapters_with_same_target_parameters_works(self):
+        # Multiple adapters that target the same set of parameters are supported.
+        model = self.get_model()
+        config = LoraConfig(target_modules=[], target_parameters=["linear.weight"])
+        model = get_peft_model(model, config)
+        # a second adapter targeting the same parameter(s) can be added
+        config_other = LoraConfig(target_modules=[], target_parameters=["linear.weight"])
+        model.add_adapter(adapter_name="other", peft_config=config_other)
+        assert "other" in model.peft_config
+
+    def test_adding_multiple_adapters_with_different_target_parameters_raises(self):
+        # Multiple adapters that target a different set of parameters are not supported -- all adapters that use
+        # target_parameters on the same model must target the same set of parameters. This is because the information
+        # which parameter is targeted is not stored in the state_dict itself (remember: if we target multiple parameters
+        # on the same module, we solve that by nesting, which means that the nesting level encodes which parameter is
+        # targeted). Therefore, if we had different adapters targeting different parameters, we would not be able to
+        # tell which parameter is meant to be targeted.
+        model = self.get_model()
+        config = LoraConfig(target_modules=[], target_parameters=["linear.weight"])
+        model = get_peft_model(model, config)
+        config_other = LoraConfig(target_modules=[], target_parameters=["embed.weight"])
+        msg = re.escape("all adapters must target the same set of parameters")
+        with pytest.raises(ValueError, match=msg):
+            model.add_adapter(adapter_name="other", peft_config=config_other)
+        # the invalid config was not added
+        assert "other" not in model.peft_config
+
+    def test_loading_multiple_adapters_with_target_parameters_works(self, tmp_path):
+        # A second adapter targeting the same parameter(s) can be loaded onto the model.
+        model = self.get_model()
+        config = LoraConfig(target_modules=[], target_parameters=["linear.weight"])
+        model = get_peft_model(model, config)
+        model.save_pretrained(tmp_path)
+
+        model = self.get_model()
+        model = PeftModel.from_pretrained(model, tmp_path)
+        model.load_adapter(tmp_path, adapter_name="other")
+        assert "other" in model.peft_config
+
+    def test_multiple_configs_with_bias_raises(self, tmp_path):
+        # There cannot be more than one config with bias != "none".
+        # Note: This would need to be tested for all PEFT methods that support the bias parameter, but as this method
+        # comes from BaseTuner, it's fine to only check LoRA.
+        model = self.get_model()
+        config0 = LoraConfig(target_modules=["linear"], bias="all")
+        model = get_peft_model(model, config0)
+
+        config1 = LoraConfig(target_modules=["linear"], bias="lora_only")
+        msg = "supports only 1 adapter with bias. When using multiple adapters"
+        with pytest.raises(ValueError, match=msg):
+            model.add_adapter("other", config1)
+
+        # the invalid peft config was not added
+        assert len(model.peft_config) == 1
+
+        # it's okay to add a config with bias="none" (the default)
+        config2 = LoraConfig(target_modules=["linear"], bias="none")
+        model.add_adapter("other", config2)  # does not raise
+
+
+class TestLokrInitialization:
+    torch_device = infer_device()
+
+    def get_model(self):
+        class MyModule(nn.Module):
+            def __init__(self):
+                super().__init__()
+                # Choose a large weight so that averages are close to expected values.
+                self.linear = nn.Linear(1000, 1000)
+                self.conv2d = nn.Conv2d(100, 100, 3)
+
+            def forward(self, x):
+                x_4d = x.flatten().reshape(1, 100, 10, 10)
+                return self.linear(x), self.conv2d(x_4d)
+
+        return MyModule().eval().to(self.torch_device)
+
+    @pytest.fixture
+    def data(self):
+        return torch.rand(10, 1000).to(self.torch_device)
+
+    @require_deterministic_for_xpu
+    def test_lokr_linear_init_default(self, data):
+        torch.manual_seed(0)
+
+        model = self.get_model()
+        output_before = model(data)[0]
+        config = LoKrConfig(target_modules=["linear"])
+        model = get_peft_model(model, config)
+        output_after = model(data)[0]
+
+        assert torch.allclose(output_before, output_after)
+
+    def test_lokr_linear_init_false(self, data):
+        torch.manual_seed(0)
+
+        model = self.get_model()
+        output_before = model(data)[0]
+        config = LoKrConfig(target_modules=["linear"], init_weights=False)
+        model = get_peft_model(model, config)
+        output_after = model(data)[0]
+
+        assert not torch.allclose(output_before, output_after)
+
+    @require_deterministic_for_xpu
+    def test_lokr_linear_init_lycoris(self, data):
+        torch.manual_seed(0)
+
+        model = self.get_model()
+        output_before = model(data)[0]
+        config = LoKrConfig(target_modules=["linear"], init_weights="lycoris")
+        model = get_peft_model(model, config)
+        output_after = model(data)[0]
+
+        assert torch.allclose(output_before, output_after)
+
+    def test_lokr_conv2d_init_default(self, data):
+        torch.manual_seed(0)
+
+        model = self.get_model()
+        output_before = model(data)[1]
+        config = LoKrConfig(target_modules=["conv2d"])
+        model = get_peft_model(model, config)
+        output_after = model(data)[1]
+
+        assert torch.allclose(output_before, output_after)
+
+    def test_lokr_conv2d_init_false(self, data):
+        torch.manual_seed(0)
+
+        model = self.get_model()
+        output_before = model(data)[1]
+        config = LoKrConfig(target_modules=["conv2d"], init_weights=False)
+        model = get_peft_model(model, config)
+        output_after = model(data)[1]
+
+        assert not torch.allclose(output_before, output_after)
+
+    def test_lokr_conv2d_init_lycoris(self, data):
+        torch.manual_seed(0)
+
+        model = self.get_model()
+        output_before = model(data)[1]
+        config = LoKrConfig(target_modules=["conv2d"], init_weights="lycoris")
+        model = get_peft_model(model, config)
+        output_after = model(data)[1]
+
+        assert torch.allclose(output_before, output_after)
+
+
+class TestAdaLoraInitialization:
+    torch_device = infer_device()
+
+    def test_adalora_target_modules_set(self):
+        config = AdaLoraConfig(target_modules=["linear", "embed", "conv2d"], total_step=1)
+        assert config.target_modules == {"linear", "embed", "conv2d"}
+
+    def test_adalora_use_dora_raises(self):
+        with pytest.raises(ValueError, match="ADALORA does not support DoRA"):
+            AdaLoraConfig(use_dora=True, total_step=1)
+
+    def test_adalora_loftq_config_raises(self):
+        with pytest.raises(ValueError, match="ADALORA does not support LOFTQ"):
+            AdaLoraConfig(init_lora_weights="loftq", loftq_config={"loftq": "config"}, total_step=1)
+
+    def get_model(self):
+        class MyModule(nn.Module):
+            def __init__(self):
+                super().__init__()
+                # choose a large weight so that averages are close to expected values
+                self.linear = nn.Linear(1000, 1000)
+
+            def forward(self, x):
+                return self.linear(x)
+
+        return MyModule().eval().to(self.torch_device)
+
+    @pytest.fixture
+    def data(self):
+        return torch.rand(10, 1000).to(self.torch_device)
+
+    @require_deterministic_for_xpu
+    def test_adalora_default_init_identity(self, data):
+        # default is True
+        torch.manual_seed(0)
+
+        model = self.get_model()
+        output_before = model(data)
+        config = AdaLoraConfig(target_modules=["linear"], total_step=1)
+        model = get_peft_model(model, config)
+        output_after = model(data)
+        assert torch.allclose(output_before, output_after)
+
+
+class TestPromptTuningInitialization:
+    torch_device = infer_device()
+
+    def get_model(self):
+        class MyModule(nn.Module):
+            def __init__(self):
+                super().__init__()
+                # choose a large weight so that averages are close to expected values
+                self.linear = nn.Linear(1000, 1000)
+                self.embed = nn.Embedding(1000, 1000)
+                self.conv2d = nn.Conv2d(100, 100, 3)
+
+            def forward(self, x):
+                x_int = (100 * x).int()
+                x_4d = x.flatten().reshape(1, 100, 10, 10)
+                return self.linear(x), self.embed(x_int), self.conv2d(x_4d)
+
+        return MyModule().eval().to(self.torch_device)
+
+    def test_use_prompt_tuning_init_text_raises(self):
+        with pytest.raises(ValueError, match="When prompt_tuning_init='TEXT', tokenizer_name_or_path can't be None"):
+            PromptTuningConfig(prompt_tuning_init="TEXT", prompt_tuning_init_text="prompt tuning init text")
+        with pytest.raises(ValueError, match="When prompt_tuning_init='TEXT', prompt_tuning_init_text can't be None"):
+            PromptTuningConfig(prompt_tuning_init="TEXT", tokenizer_name_or_path="t5-base")
+
+
+class TestVeraInitialization:
+    torch_device = infer_device()
+
+    def get_model(self):
+        class MLP(nn.Module):
+            def __init__(self, bias=True):
+                super().__init__()
+                self.lin0 = nn.Linear(10, 20, bias=bias)
+                self.lin1 = nn.Linear(20, 2, bias=bias)
+
+            def forward(self, X):
+                X = self.lin0(X)
+                X = self.lin1(X)
+                return X
+
+        return MLP().to(self.torch_device)
+
+    def test_vera_mixing_save_projection_raises(self):
+        # it is unclear what the right thing to do would be if some adapters save the projection weights and some don't
+        # so we better raise an error
+
+        config0 = VeraConfig(target_modules=["lin0"], init_weights=False, save_projection=True)
+        model = self.get_model()
+        model = get_peft_model(model, config0)
+        config1 = VeraConfig(target_modules=["lin0"], init_weights=False, save_projection=False)
+        msg = re.escape(
+            "VeRA projection weights must be saved for all adapters or none, but got multiple different values: "
+            "[False, True]"
+        )
+        with pytest.raises(ValueError, match=msg):
+            model.add_adapter("other", config1)
+
+    def test_vera_add_second_adapter_with_incompatible_input_shape(self):
+        config0 = VeraConfig(target_modules=["lin0"], r=8)
+        config1 = VeraConfig(target_modules=["lin1"])
+
+        base_model = self.get_model()
+        lin0_in_feat = base_model.lin0.in_features
+        lin1_in_feat = base_model.lin1.in_features
+        model = get_peft_model(base_model, config0)
+        # not full message but enough to identify the error
+        msg = f"vera_A has a size of {lin0_in_feat} but {lin1_in_feat} or greater is required"
+        with pytest.raises(ValueError, match=msg):
+            model.add_adapter("other", config1)
+
+    def test_vera_add_second_adapter_with_higher_rank(self):
+        rank0 = 123
+        rank1 = 456
+        config0 = VeraConfig(target_modules=["lin0"], r=rank0)
+        # second adapter has higher rank
+        config1 = VeraConfig(target_modules=["lin0"], r=rank1)
+
+        model = get_peft_model(self.get_model(), config0)
+        # not full message but enough to identify the error
+        msg = f"vera_A has a size of {rank0} but {rank1} or greater is required"
+        with pytest.raises(ValueError, match=msg):
+            model.add_adapter("other", config1)
+
+
+class TestFrodInitialization:
+    torch_device = infer_device()
+
+    def get_model(self):
+        class MLP(nn.Module):
+            def __init__(self, bias=True):
+                super().__init__()
+                self.lin0 = nn.Linear(10, 20, bias=bias)
+                self.lin1 = nn.Linear(20, 20, bias=bias)
+                self.lin2 = nn.Linear(20, 2, bias=bias)
+
+            def forward(self, X):
+                X = self.lin0(X)
+                X = self.lin1(X)
+                X = self.lin2(X)
+                return X
+
+        return MLP().to(self.torch_device)
+
+    def test_frod_multiple_adapters_same_prng_share_projection_buffers(self):
+        torch.manual_seed(0)
+        config0 = FrodConfig(target_modules=["lin1", "lin2"], init_weights=False)
+        model = get_peft_model(self.get_model().cpu(), config0)
+
+        config1 = FrodConfig(target_modules=["lin1", "lin2"], init_weights=False)
+        model.add_adapter("other", config1)
+
+        assert model.base_model.model.lin1.frod_V["default"].data_ptr() == (
+            model.base_model.model.lin1.frod_V["other"].data_ptr()
+        )
+        assert model.base_model.model.lin1.frod_s_indices["default"].data_ptr() == (
+            model.base_model.model.lin1.frod_s_indices["other"].data_ptr()
+        )
+        assert model.base_model.model.lin2.frod_V["default"].data_ptr() == (
+            model.base_model.model.lin2.frod_V["other"].data_ptr()
+        )
+        assert model.base_model.model.lin2.frod_s_indices["default"].data_ptr() == (
+            model.base_model.model.lin2.frod_s_indices["other"].data_ptr()
+        )
+
+    def test_frod_mixing_save_projection_raises(self):
+        config0 = FrodConfig(target_modules=["lin0"], init_weights=False, save_projection=True)
+        model = get_peft_model(self.get_model(), config0)
+
+        config1 = FrodConfig(target_modules=["lin0"], init_weights=False, save_projection=False)
+        msg = re.escape(
+            "FRoD projection weights must be saved for all adapters or none, but got multiple different values: "
+            "[False, True]"
+        )
+        with pytest.raises(ValueError, match=msg):
+            model.add_adapter("other", config1)
+
+    def test_frod_mixing_runtime_offload_base_weight_raises(self):
+        config0 = FrodConfig(target_modules=["lin0"], init_weights=False)
+        model = get_peft_model(self.get_model(), config0)
+
+        config1 = FrodConfig(target_modules=["lin0"], init_weights=False, runtime_offload_base_weight=True)
+        msg = re.escape(
+            "FRoD runtime base-weight offloading must be enabled for all adapters or none, but got multiple "
+            "different values: [False, True]"
+        )
+        with pytest.raises(ValueError, match=msg):
+            model.add_adapter("other", config1)
+
+    def test_frod_add_second_adapter_with_different_prng_key_raises(self):
+        config0 = FrodConfig(target_modules=["lin0"], init_weights=False)
+        model = get_peft_model(self.get_model(), config0)
+
+        config1 = FrodConfig(target_modules=["lin0"], init_weights=False, projection_prng_key=123)
+        msg = re.escape(
+            "FRoD projection initialization key must be the same for all adapters. Got "
+            "config.projection_prng_key=123 but previous config had 0."
+        )
+        with pytest.raises(ValueError, match=msg):
+            model.add_adapter("other", config1)
+
+
+class TestVeloraInitialization:
+    @pytest.mark.parametrize(
+        "config_kwargs, msg",
+        [
+            pytest.param({"num_groups": 0}, "`num_groups` should be positive, got 0.", id="num-groups"),
+            pytest.param({"scale": 0.0}, "`scale` should be positive, got 0.0.", id="scale"),
+            pytest.param(
+                {"init_type": "unsupported"},
+                "Unsupported `init_type` 'unsupported'. Supported values are 'batch_average_once', "
+                "'batch_average', and 'random'.",
+                id="init-type",
+            ),
+        ],
+    )
+    def test_velora_config_invalid_values_raise(self, config_kwargs, msg):
+        with pytest.raises(ValueError, match=re.escape(msg)):
+            VeloraConfig(**config_kwargs)
+
+
+class TestVBLoraInitialization:
+    torch_device = infer_device()
+
+    def get_model(self):
+        class MLP(nn.Module):
+            def __init__(self, bias=True):
+                super().__init__()
+                self.lin0 = nn.Linear(10, 30, bias=bias)
+                self.lin1 = nn.Linear(30, 2, bias=bias)
+
+            def forward(self, X):
+                X = self.lin0(X)
+                X = self.lin1(X)
+                return X
+
+        return MLP().to(self.torch_device)
+
+    def test_vblora_with_incompatible_vector_length_with_in_features(self):
+        vector_length = 3
+        model = self.get_model()
+        config = VBLoRAConfig(target_modules=["lin0"], vector_length=vector_length)
+        msg = f"`in_features` {model.lin0.in_features} must be divisible by `vector_length` {vector_length}"
+        with pytest.raises(ValueError, match=msg):
+            get_peft_model(model, config)
+
+    def test_vblora_with_incompatible_vector_length_with_out_features(self):
+        vector_length = 3
+        model = self.get_model()
+        config = VBLoRAConfig(target_modules=["lin1"], vector_length=vector_length)
+        msg = f"`out_features` {model.lin1.out_features} must be divisible by `vector_length` {vector_length}"
+        with pytest.raises(ValueError, match=msg):
+            get_peft_model(model, config)
+
+
+class TestC3AInitialization:
+    torch_device = infer_device()
+
+    def get_model(self):
+        class MLP(nn.Module):
+            def __init__(self, bias=True):
+                super().__init__()
+                self.lin0 = nn.Linear(10, 30, bias=bias)
+                self.lin1 = nn.Linear(30, 2, bias=bias)
+
+            def forward(self, X):
+                X = self.lin0(X)
+                X = self.lin1(X)
+                return X
+
+        return MLP().to(self.torch_device)
+
+    def test_c3a_with_incompatible_block_size_with_in_features(self):
+        block_size = 3
+        model = self.get_model()
+        config = C3AConfig(target_modules=["lin0"], block_size=block_size)
+        msg = f"The block size should be a factor of the input size. However, the input size is {model.lin0.in_features} and the block size is {block_size}"
+        with pytest.raises(ValueError, match=msg):
+            get_peft_model(model, config)
+
+    def test_c3a_with_incompatible_block_size_with_out_features(self):
+        block_size = 3
+        model = self.get_model()
+        config = C3AConfig(target_modules=["lin1"], block_size=block_size)
+        msg = f"The block size should be a factor of the output size. However, the output size is {model.lin1.out_features} and the block size is {block_size}"
+        with pytest.raises(ValueError, match=msg):
+            get_peft_model(model, config)
+
+
+class TestWaveFTInitialization:
+    """Test class to check the initialization of WaveFT adapters."""
+
+    torch_device = infer_device()
+
+    def get_model(self):
+        class MyModule(nn.Module):
+            def __init__(self):
+                super().__init__()
+                # Choose a large weight so that averages are close to expected values.
+                self.linear = nn.Linear(1000, 1000)
+                self.conv2d = nn.Conv2d(100, 100, 3)
+
+            def forward(self, x):
+                x_4d = x.flatten().reshape(1, 100, 10, 10)
+                return self.linear(x), self.conv2d(x_4d)
+
+        return MyModule().eval().to(self.torch_device)
+
+    @pytest.fixture
+    def data(self):
+        return torch.rand(10, 1000).to(self.torch_device)
+
+    @require_deterministic_for_xpu
+    def test_waveft_linear_init_default(self, data):
+        # Default initialization should result in no change to output (zeros initialization)
+        torch.manual_seed(0)
+
+        model = self.get_model()
+        output_before = model(data)[0]
+        config = WaveFTConfig(target_modules=["linear"], n_frequency=100, init_weights=True)
+        model = get_peft_model(model, config)
+        output_after = model(data)[0]
+
+        assert torch.allclose(output_before, output_after, atol=1e-6)
+
+    def test_waveft_linear_init_false(self, data):
+        # With init_weights=False, output should change (random initialization)
+        torch.manual_seed(0)
+
+        model = self.get_model()
+        output_before = model(data)[0]
+        config = WaveFTConfig(target_modules=["linear"], n_frequency=100, init_weights=False)
+        model = get_peft_model(model, config)
+        output_after = model(data)[0]
+
+        assert not torch.allclose(output_before, output_after, atol=1e-6)
+
+    @require_deterministic_for_xpu
+    def test_waveft_linear_with_scaling(self, data):
+        # Test that scaling parameter affects output correctly
+        torch.manual_seed(0)
+
+        model = self.get_model()
+        output_before = model(data)[0]
+        config = WaveFTConfig(target_modules=["linear"], n_frequency=100, init_weights=False, scaling=10.0)
+        model = get_peft_model(model, config)
+        output_after = model(data)[0]
+
+        assert not torch.allclose(output_before, output_after, atol=1e-6)
+
+    @require_deterministic_for_xpu
+    def test_waveft_different_wavelet_families(self, data):
+        # Test different wavelet families
+        torch.manual_seed(0)
+
+        model1 = self.get_model()
+        config1 = WaveFTConfig(target_modules=["linear"], n_frequency=100, wavelet_family="db1", init_weights=False)
+        model1 = get_peft_model(model1, config1)
+        output1 = model1(data)[0]
+
+        torch.manual_seed(0)
+        model2 = self.get_model()
+        config2 = WaveFTConfig(target_modules=["linear"], n_frequency=100, wavelet_family="sym2", init_weights=False)
+        model2 = get_peft_model(model2, config2)
+        output2 = model2(data)[0]
+
+        # Different wavelet families should produce different results
+        assert not torch.allclose(output1, output2, atol=1e-6)
+
+    @require_deterministic_for_xpu
+    def test_waveft_use_idwt_flag(self, data):
+        # Test use_idwt flag
+        torch.manual_seed(0)
+
+        model1 = self.get_model()
+        config1 = WaveFTConfig(target_modules=["linear"], n_frequency=100, use_idwt=True, init_weights=False)
+        model1 = get_peft_model(model1, config1)
+        output1 = model1(data)[0]
+
+        torch.manual_seed(0)
+        model2 = self.get_model()
+        config2 = WaveFTConfig(target_modules=["linear"], n_frequency=100, use_idwt=False, init_weights=False)
+        model2 = get_peft_model(model2, config2)
+        output2 = model2(data)[0]
+
+        # Different use_idwt settings should produce different results
+        assert not torch.allclose(output1, output2, atol=1e-6)
+
+    def test_waveft_non_positive_n_frequency_raises(self):
+        # Test that n_frequency <= 0 raises appropriate error
+        model = self.get_model()
+
+        # Test with n_frequency = 0
+        n_frequency = 0
+        msg = f"`n_frequency` should be a positive integer value but the value passed is {n_frequency}"
+        with pytest.raises(ValueError, match=re.escape(msg)):
+            config = WaveFTConfig(target_modules=["linear"], n_frequency=n_frequency)
+            get_peft_model(model, config)
+
+        # Test with negative n_frequency
+        n_frequency = -1
+        msg = f"`n_frequency` should be a positive integer value but the value passed is {n_frequency}"
+        with pytest.raises(ValueError, match=re.escape(msg)):
+            config = WaveFTConfig(target_modules=["linear"], n_frequency=n_frequency)
+            get_peft_model(model, config)
+
+    def test_waveft_excessive_n_frequency_raises(self):
+        # Test that n_frequency > in_features * out_features raises appropriate error
+        model = self.get_model()
+
+        # The model has a linear layer with 1000 in_features and 1000 out_features
+        # So the maximum n_frequency should be 1000 * 1000 = 1,000,000
+        max_allowed = 1000 * 1000
+        n_frequency = max_allowed + 1
+        msg = (
+            f"`n_frequency` should be less than or equal to the product of the input and output dimensions "
+            f"but the value passed is {n_frequency} and the product is {max_allowed}"
+        )
+        with pytest.raises(ValueError, match=re.escape(msg)):
+            config = WaveFTConfig(target_modules=["linear"], n_frequency=n_frequency)
+            get_peft_model(model, config)
+
+    def test_waveft_n_frequency_pattern(self, data):
+        # Test n_frequency_pattern functionality
+        torch.manual_seed(0)
+
+        model = self.get_model()
+        config = WaveFTConfig(
+            target_modules=["linear"], n_frequency=50, n_frequency_pattern={"linear": 100}, init_weights=True
+        )
+        model = get_peft_model(model, config)
+
+        # Check that the pattern was applied
+        waveft_layer = model.base_model.model.linear
+        assert hasattr(waveft_layer, "waveft_n_frequency")
+        assert waveft_layer.waveft_n_frequency["default"] == 100
+
+    def test_waveft_layers_pattern_without_layers_to_transform_raises(self):
+        # Test that when layers_pattern is specified, layers_to_transform must also be specified
+        msg = "When `layers_pattern` is specified, `layers_to_transform` must also be specified."
+        with pytest.raises(ValueError, match=re.escape(msg)):
+            WaveFTConfig(target_modules=["linear"], layers_pattern=["layers"], layers_to_transform=None)
+
+    def test_waveft_invalid_wavelet_family_raises(self):
+        # Test that invalid wavelet families raise appropriate errors
+        invalid_family = "invalid_wavelet"
+        msg = f"Wavelet family {invalid_family} not supported. Supported wavelet families are:"
+        with pytest.raises(ValueError, match=re.escape(msg)):
+            WaveFTConfig(target_modules=["linear"], wavelet_family=invalid_family)
+
+
+class TestRoadInitialization:
+    torch_device = infer_device()
+
+    def get_model(self):
+        class MLP(nn.Module):
+            def __init__(self, bias=True):
+                super().__init__()
+                self.lin0 = nn.Linear(10, 30, bias=bias)
+                self.lin1 = nn.Linear(30, 2, bias=bias)
+
+            def forward(self, X):
+                X = self.lin0(X)
+                X = self.lin1(X)
+                return X
+
+        return MLP().to(self.torch_device)
+
+    def get_conv2d_model(self):
+        class MyModule(nn.Module):
+            def __init__(self):
+                super().__init__()
+                # choose a large weight so that averages are close to expected values
+                self.linear = nn.Linear(1000, 1000)
+                self.embed = nn.Embedding(1000, 1000)
+                self.conv2d = nn.Conv2d(100, 100, 3)
+
+            def forward(self, x):
+                x_int = (100 * x).int()
+                x_4d = x.flatten().reshape(1, 100, 10, 10)
+                return self.linear(x), self.embed(x_int), self.conv2d(x_4d)
+
+        return MyModule().eval().to(self.torch_device)
+
+    def test_road_default_initialization(self):
+        torch.manual_seed(0)
+        model = self.get_model()
+        config = RoadConfig(target_modules=["lin0"], group_size=2)
+        model = get_peft_model(model, config)
+        weight_alpha = model.lin0.road_alpha["default"].data
+        weight_theta = model.lin0.road_theta["default"].data
+        torch.allclose(weight_alpha, torch.ones_like(weight_alpha))
+        torch.allclose(weight_theta, torch.zeros_like(weight_theta))
+
+    def test_road_with_odd_group_size(self):
+        group_size = 3  # odd values are not allowed
+        msg = f"The group_size must be divisible by 2 when using RoadLayer, but got {group_size}."
+        with pytest.raises(ValueError, match=re.escape(msg)):
+            RoadConfig(group_size=group_size)
+
+    def test_road_with_too_large_group_size(self):
+        group_size = 64  # larger than out_features
+        msg = (
+            f"The out_features of the base layer must be divisible by group_size ({group_size}) when using RoadLayer."
+        )
+        model = self.get_model()
+        config = RoadConfig(target_modules=["lin0"], group_size=group_size)
+        with pytest.raises(ValueError, match=re.escape(msg)):
+            get_peft_model(model, config)
+
+    def test_road_with_incompatible_group_size_with_out_features(self):
+        group_size = 4  # even, but 30 does not divide by 4
+        model = self.get_model()
+        config = RoadConfig(target_modules=["lin0"], group_size=group_size)
+        msg = (
+            f"The out_features of the base layer must be divisible by group_size ({group_size}) when using RoadLayer."
+        )
+        with pytest.raises(ValueError, match=re.escape(msg)):
+            get_peft_model(model, config)
+
+    def test_road_with_conv2d_layer(self):
+        model = self.get_conv2d_model()
+        config = RoadConfig(target_modules=["conv2d"], group_size=2)
+        msg = "Target module Conv2d(100, 100, kernel_size=(3, 3), stride=(1, 1)) is not supported. Currently, only the following modules are supported: `torch.nn.Linear`."
+        with pytest.raises(ValueError, match=re.escape(msg)):
+            get_peft_model(model, config)
+
+
+class TestDeLoRAInitialization:
+    """Basic sanity tests for the DeLoRA tuner."""
+
+    torch_device = infer_device()
+
+    def get_model(self, bias=True):
+        class MLP(nn.Module):
+            def __init__(self, bias=True):
+                super().__init__()
+                self.lin0 = nn.Linear(10, 30, bias=bias)
+                self.lin1 = nn.Linear(30, 2, bias=bias)
+
+            def forward(self, X):
+                X = self.lin0(X)
+                X = self.lin1(X)
+                return X
+
+        return MLP(bias=bias).to(self.torch_device).eval()
+
+    @pytest.fixture
+    def data(self):
+        torch.manual_seed(0)
+        return torch.randn(4, 10, device=self.torch_device)
+
+    def test_delora_injection_keeps_output_default(self, data):
+        # With init_weights=True (default), initial forward should match base model
+        torch.manual_seed(0)
+        base = self.get_model()
+        y_base = base(data)
+
+        cfg = DeloraConfig(target_modules=["lin0"], r=8, delora_lambda=15, init_weights=True)
+        model = get_peft_model(base, cfg)
+        y_peft = model(data)
+
+        assert torch.allclose(y_base, y_peft, atol=1e-6, rtol=1e-6)
+
+    def test_delora_param_shapes(self):
+        base = self.get_model()
+        in_f, out_f = base.lin0.in_features, base.lin0.out_features
+        r = 4
+        cfg = DeloraConfig(target_modules=["lin0"], r=r, delora_lambda=15, init_weights=True)
+        model = get_peft_model(base, cfg)
+
+        layer = model.lin0  # DeloraLinear wrapper
+        assert hasattr(layer, "delora_A") and hasattr(layer, "delora_B") and hasattr(layer, "delora_lambda")
+        A = layer.delora_A["default"]
+        B = layer.delora_B["default"]
+        delora_lambda = layer.delora_lambda["default"]
+        assert tuple(A.shape) == (r, in_f)
+        assert tuple(B.shape) == (out_f, r)
+        assert tuple(delora_lambda.shape) == (1,)
+
+    def test_init_weights_false_shifts_output(self, data):
+        # With init_weights=False, there should be an initial delta to the base model output
+        base = self.get_model()
+        y_base = base(data)
+        cfg = DeloraConfig(target_modules=["lin0"], r=8, delora_lambda=15, init_weights=False)
+        model = get_peft_model(base, cfg)
+        y_peft = model(data)
+        assert not torch.allclose(y_base, y_peft, atol=1e-6, rtol=1e-6)
+
+
+class TestGraLoRAInitialization:
+    """Basic sanity tests for the GraLoRA tuner."""
+
+    torch_device = infer_device()
+
+    def get_model(self, bias=True):
+        class MLP(nn.Module):
+            def __init__(self, bias=True):
+                super().__init__()
+                self.lin0 = nn.Linear(10, 30, bias=bias)
+                self.lin1 = nn.Linear(30, 2, bias=bias)
+
+            def forward(self, X):
+                X = self.lin0(X)
+                X = self.lin1(X)
+                return X
+
+        return MLP(bias=bias).to(self.torch_device).eval()
+
+    @pytest.fixture
+    def data(self):
+        torch.manual_seed(0)
+        return torch.randn(4, 10, device=self.torch_device)
+
+    def test_gralora_with_incompatible_gralora_k_and_r_raises(self):
+        model = self.get_model()
+        r = 6
+        gralora_k = 4
+        # msg = f"r should be divisible by gralora_k, but got {config.r} and {config.gralora_k}"
+        msg = f"r should be divisible by gralora_k, but got {r} and {gralora_k}"
+        with pytest.raises(ValueError, match=re.escape(msg)):
+            GraloraConfig(target_modules=["lin0"], r=r, gralora_k=gralora_k)
+
+    def test_gralora_with_incompatible_gralora_k_and_in_features_raises(self):
+        model = self.get_model()
+        config = GraloraConfig(target_modules=["lin0"], r=6, gralora_k=3)
+        msg = f"in_features should be divisible by gralora_k, but got {model.lin0.in_features} and {config.gralora_k}"
+        with pytest.raises(ValueError, match=re.escape(msg)):
+            get_peft_model(model, config)
+
+    def test_gralora_with_incompatible_gralora_k_and_out_features_raises(self):
+        model = self.get_model()
+        config = GraloraConfig(target_modules=["lin1"], r=6, gralora_k=3)
+        msg = (
+            f"out_features should be divisible by gralora_k, but got {model.lin1.out_features} and {config.gralora_k}"
+        )
+        with pytest.raises(ValueError, match=re.escape(msg)):
+            get_peft_model(model, config)
+
+
+class TestPsoftInitialization:
+    """Basic sanity tests for the PSOFT tuner."""
+
+    torch_device = infer_device()
+
+    def get_model(self, bias=True):
+        class MLP(nn.Module):
+            def __init__(self, bias=True):
+                super().__init__()
+                self.lin0 = nn.Linear(10, 30, bias=bias)
+                self.lin1 = nn.Linear(30, 2, bias=bias)
+
+            def forward(self, X):
+                X = self.lin0(X)
+                X = self.lin1(X)
+                return X
+
+        return MLP(bias=bias).to(self.torch_device).eval()
+
+    def test_psoft_svd_lowrank_niter_warns_when_backend_not_lowrank_and_user_changes_value(self):
+        default_niter = PsoftConfig.__dataclass_fields__["psoft_svd_lowrank_niter"].default
+
+        msg = re.escape("`psoft_svd_lowrank_niter` is only used when `psoft_svd='lowrank'`.")
+        with pytest.warns(UserWarning, match=msg):
+            _ = PsoftConfig(
+                target_modules=["lin0"],
+                psoft_svd="full",
+                psoft_svd_lowrank_niter=default_niter + 1,
+            )
+
+    def test_psoft_svd_lowrank_niter_no_warning_when_backend_not_lowrank_and_value_is_default(self, recwarn):
+        default_niter = PsoftConfig.__dataclass_fields__["psoft_svd_lowrank_niter"].default
+        _ = PsoftConfig(
+            target_modules=["lin0"],
+            psoft_svd="full",
+            psoft_svd_lowrank_niter=default_niter,
+        )
+        assert len(recwarn) == 0
+
+    def test_cayley_neumann_terms_warns_when_use_cayley_neumann_false_and_user_changes_terms(self):
+        default_terms = PsoftConfig.__dataclass_fields__["num_cayley_neumann_terms"].default
+
+        msg = re.escape("`num_cayley_neumann_terms` is only used when `use_cayley_neumann=True`.")
+        with pytest.warns(UserWarning, match=msg):
+            _ = PsoftConfig(
+                target_modules=["lin0"],
+                use_cayley_neumann=False,
+                num_cayley_neumann_terms=default_terms + 1,
+            )
+
+    def test_cayley_neumann_eps_warns_when_use_cayley_neumann_false_and_eps_is_set(self):
+        msg = re.escape("`cayley_neumann_eps` is only used when `use_cayley_neumann=True`.")
+        with pytest.warns(UserWarning, match=msg):
+            _ = PsoftConfig(
+                target_modules=["lin0"],
+                use_cayley_neumann=False,
+                cayley_neumann_eps=0.9,
+            )
+
+    def test_cayley_neumann_terms_raises_when_use_cayley_neumann_true_and_terms_non_positive(self):
+        with pytest.raises(ValueError, match=re.escape("`num_cayley_neumann_terms` must be a positive integer")):
+            _ = PsoftConfig(
+                target_modules=["lin0"],
+                use_cayley_neumann=True,
+                num_cayley_neumann_terms=0,
+            )
+
+    @pytest.mark.parametrize("bad_eps", [-0.1, 0.0, 1.0, 1.1])
+    def test_cayley_neumann_eps_raises_when_use_cayley_neumann_true_and_eps_out_of_range(self, bad_eps):
+        with pytest.raises(ValueError, match=re.escape("`cayley_neumann_eps` must be in (0, 1)")):
+            _ = PsoftConfig(
+                target_modules=["lin0"],
+                use_cayley_neumann=True,
+                cayley_neumann_eps=bad_eps,
+            )
+
+
+class TestPeanutInitialization:
+    """Basic sanity tests for the PEANuT tuner."""
+
+    torch_device = infer_device()
+
+    def get_model(self, bias=True):
+        class MLP(nn.Module):
+            def __init__(self, bias=True):
+                super().__init__()
+                self.lin0 = nn.Linear(10, 30, bias=bias)
+                self.lin1 = nn.Linear(30, 2, bias=bias)
+
+            def forward(self, X):
+                X = self.lin0(X)
+                X = self.lin1(X)
+                return X
+
+        return MLP(bias=bias).to(self.torch_device).eval()
+
+    def test_peanut_depth0_parameter_shapes(self):
+        model = self.get_model()
+        out_f = model.lin0.out_features
+        r = 6
+
+        cfg = PeanutConfig(target_modules=["lin0"], r=r, depth=0, act_fn="relu", init_weights=True)
+        model = get_peft_model(model, cfg)
+
+        layer = model.lin0
+        A = layer.peanut_A["default"]
+        B = layer.peanut_B["default"]
+
+        assert tuple(A.weight.shape) == (r, out_f)
+        assert tuple(B.weight.shape) == (out_f, r)
+        assert layer.res_num["default"] == 0
+
+    def test_peanut_depth1_residual_layers_are_created(self):
+        model = self.get_model()
+        r = 4
+
+        cfg = PeanutConfig(target_modules=["lin0"], r=r, depth=1, act_fn="relu", init_weights=True)
+        model = get_peft_model(model, cfg)
+
+        layer = model.lin0
+        assert layer.res_num["default"] == 1
+        assert "default" in layer.peanut_encoders
+        assert "default" in layer.peanut_decoders
+        assert len(layer.peanut_encoders["default"]) == 1
+        assert len(layer.peanut_decoders["default"]) == 1
+        assert tuple(layer.peanut_encoders["default"][0].weight.shape) == (r, r)
+        assert tuple(layer.peanut_decoders["default"][0].weight.shape) == (r, r)
+
+
+class TestBeftInitialization:
+    torch_device = infer_device()
+
+    def get_model(self, bias=True):
+        class MLP(nn.Module):
+            def __init__(self, bias=bias):
+                super().__init__()
+                self.lin0 = nn.Linear(10, 20, bias=bias)
+
+            def forward(self, X):
+                return self.lin0(X)
+
+        return MLP(bias=bias).to(self.torch_device).eval()
+
+    def test_beft_initialization_no_bias_warning(self):
+        model = self.get_model(bias=False)
+        cfg = BeftConfig(target_modules=["lin0"])
+
+        with pytest.warns(UserWarning, match="Note you cannot merge the BEFT adapter into the base layer."):
+            model = get_peft_model(model, cfg)
+
+        assert model.lin0.base_layer.bias is None
+        assert "default" in model.lin0.beft_bias
+        assert model.lin0.get_base_layer().bias is None
+
+    def test_beft_merge_no_bias_raises_error(self):
+        model = self.get_model(bias=False)
+        cfg = BeftConfig(target_modules=["lin0"])
+        model = get_peft_model(model, cfg)
+
+        assert hasattr(model.lin0, "beft_bias")
+
+        with pytest.raises(ValueError, match="Base layer has no bias, cannot merge bias adapter"):
+            model.merge_and_unload()
+
+
+class TestNoInfiniteRecursionDeepspeed:
+    # see #1892 for details
+    classes = [
+        PeftModel,
+        PeftMixedModel,
+        PeftModelForSequenceClassification,
+        PeftModelForQuestionAnswering,
+        PeftModelForTokenClassification,
+        PeftModelForCausalLM,
+        PeftModelForSeq2SeqLM,
+        PeftModelForFeatureExtraction,
+    ]
+
+    @pytest.fixture
+    def wrap_init(self):
+        # emulates the wrapper from DeepSpeed
+        import functools
+
+        def decorator(f):
+            @functools.wraps(f)
+            def wrapper(self, *args, **kwargs):
+                hasattr(self, "abc")  # any hasattr will do
+                f(self, *args, **kwargs)
+
+            return wrapper
+
+        return decorator
+
+    @pytest.fixture
+    def model(self):
+        class MyModule(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.linear = nn.Linear(10, 10)
+                # to emulate LMs:
+                self.prepare_inputs_for_generation = None
+                self._prepare_encoder_decoder_kwargs_for_generation = None
+
+        return MyModule()
+
+    @pytest.mark.parametrize("cls", classes)
+    def test_no_infinite_recursion(self, cls, model, wrap_init):
+        original_init = cls.__init__
+        try:
+            cls.__init__ = wrap_init(cls.__init__)
+            # this would trigger an infinite loop before the fix in 1892
+            cls(model, LoraConfig(target_modules=["linear"]))
+        finally:
+            # ensure there are no side effects of this test
+            cls.__init__ = original_init
+
+
+class TestLoadAdapterOfflineMode:
+    base_model = "peft-internal-testing/tiny-random-OPTForCausalLM"
+    peft_model_id = "peft-internal-testing/tiny-OPTForCausalLM-lora"
+
+    # make sure that PEFT honors offline mode
+    @contextmanager
+    def hub_offline_ctx(self):
+        # this is required to simulate offline mode, setting the env var dynamically inside the test does not work
+        # because the value is checked only once at the start of the session
+
+        if reset_sessions is None:
+            # this means we're using huggingface_hub >= 1.0.0, there is no need to call reset_sessions() anymore
+            with patch("huggingface_hub.constants.HF_HUB_OFFLINE", True):
+                yield
+        else:
+            # in huggingface_hub < 1.0.0, it's necessary to reset the session
+            # TODO: remove once huggingface_hub < 1.0.0 is no longer supported
+            with patch("huggingface_hub.constants.HF_HUB_OFFLINE", True):
+                reset_sessions()
+                yield
+            reset_sessions()
+
+    def test_load_from_hub_then_offline_model(self):
+        # this uses LoRA but it's the same mechanism for other methods
+        base_model = AutoModelForCausalLM.from_pretrained(self.base_model)
+
+        # first ensure that the adapter model has been downloaded
+        PeftModel.from_pretrained(base_model, self.peft_model_id)
+
+        del base_model
+
+        base_model = AutoModelForCausalLM.from_pretrained(self.base_model)
+        with self.hub_offline_ctx():
+            # does not raise
+            PeftModel.from_pretrained(base_model, self.peft_model_id)
+
+    @pytest.fixture
+    def changed_default_cache_dir(self, tmp_path, monkeypatch):
+        # ensure that this test does not interact with other tests that may use the HF cache
+        monkeypatch.setattr("huggingface_hub.constants.HF_HOME", tmp_path)
+        monkeypatch.setattr("huggingface_hub.constants.HF_HUB_CACHE", tmp_path / "hub")
+        monkeypatch.setattr("huggingface_hub.constants.HF_TOKEN_PATH", tmp_path / "token")
+
+    def load_checkpoints(self, cache_dir):
+        # download model and lora checkpoint to a specific cache dir
+        snapshot_download(self.base_model, cache_dir=cache_dir)
+        snapshot_download(self.peft_model_id, cache_dir=cache_dir)
+
+    def test_load_checkpoint_offline_non_default_cache_dir(self, changed_default_cache_dir, tmp_path):
+        # See #2373 for context
+        self.load_checkpoints(tmp_path)
+        with self.hub_offline_ctx():
+            base_model = AutoModelForCausalLM.from_pretrained(self.base_model, cache_dir=tmp_path)
+            PeftModel.from_pretrained(base_model, self.peft_model_id, cache_dir=tmp_path)
+
+
+class TestCustomModelConfigWarning:
+    # Check potential warnings when the user provided base_model_name_or_path is overridden by PEFT. See #2001 for
+    # context. We use LoRA for this test but the same applies to other methods
+    @pytest.fixture
+    def custom_module(self):
+        class MyModule(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.lin = nn.Linear(10, 10)
+
+        return MyModule()
+
+    def test_no_warning_by_default_transformers_model(self, recwarn):
+        # first a sanity test that there is no warning by default when using a model from transformers
+        model = AutoModelForCausalLM.from_pretrained("peft-internal-testing/tiny-random-OPTForCausalLM")
+        get_peft_model(model, LoraConfig())
+        for warning in recwarn.list:
+            assert "renamed" not in str(warning.message)
+
+    def test_no_warning_by_default_custom_model(self, custom_module, recwarn):
+        # same as above but with a custom model
+        get_peft_model(custom_module, LoraConfig(target_modules=["lin"]))
+        for warning in recwarn.list:
+            assert "renamed" not in str(warning.message)
+
+    def test_warning_name_transformers_model(self, recwarn):
+        # The base_model_name_or_path provided by the user is overridden.
+        model = AutoModelForCausalLM.from_pretrained("peft-internal-testing/tiny-random-OPTForCausalLM")
+        custom_name = "custom_name"
+        get_peft_model(model, LoraConfig(base_model_name_or_path=custom_name))
+        msg = f"was renamed from '{custom_name}' to 'peft-internal-testing/tiny-random-OPTForCausalLM'"
+        assert any(msg in str(warning.message) for warning in recwarn.list)
+
+    def test_warning_name_custom_model(self, custom_module, recwarn):
+        custom_name = "custom_name"
+        get_peft_model(custom_module, LoraConfig(target_modules=["lin"], base_model_name_or_path=custom_name))
+        msg = f"was renamed from '{custom_name}' to 'None'"
+        assert any(msg in str(warning.message) for warning in recwarn.list)
+
+    def test_warning_name_custom_model_with_custom_name(self, custom_module, recwarn):
+        custom_name = "custom_name"
+        custom_module.name_or_path = "foobar"
+        get_peft_model(custom_module, LoraConfig(target_modules=["lin"], base_model_name_or_path=custom_name))
+        msg = f"was renamed from '{custom_name}' to 'foobar'"
+        assert any(msg in str(warning.message) for warning in recwarn.list)
+
+
+class TestLowCpuMemUsage:
+    """Test for the low CPU memory usage option for loading PEFT models.
+
+    Note that we have `test_load_model_low_cpu_mem_usage` in the custom model and stable diffusion tests. Those are
+    broad tests (i.e. testing all the supported PEFT methods) but not very deep (only testing if loading works and the
+    device is correctly set). The test class here goes deeper but only tests LoRA, as checking all PEFT methods would
+    be too much.
+
+    """
+
+    # test on CPU and optionally on accelerator device
+    devices = ["cpu"]
+    _device = infer_device()
+    if _device != "cpu":
+        devices.append(_device)
+
+    model_id = "peft-internal-testing/tiny-random-OPTForCausalLM"
+
+    def get_model(self):
+        return AutoModelForCausalLM.from_pretrained(self.model_id)
+
+    @pytest.fixture(scope="class")
+    def lora_config(self):
+        return LoraConfig(init_lora_weights=False, target_modules="all-linear")
+
+    @pytest.fixture(scope="class")
+    def lora_path(self, tmp_path_factory, lora_config):
+        torch.manual_seed(0)
+        tmp_path = tmp_path_factory.mktemp("lora")
+        model = self.get_model()
+        model = get_peft_model(model, lora_config)
+        model.save_pretrained(tmp_path)
+        return tmp_path
+
+    @pytest.fixture(scope="class")
+    def inputs(self):
+        return {"input_ids": torch.randint(0, 100, (1, 10)), "attention_mask": torch.ones(1, 10)}
+
+    @pytest.mark.parametrize("device", devices)
+    def test_from_pretrained_low_cpu_mem_usage_works(self, device, inputs, lora_path):
+        model = self.get_model().to(device)
+        inputs = {k: v.to(device) for k, v in inputs.items()}
+        model = PeftModel.from_pretrained(model, lora_path, torch_device=device).eval()
+        device_set_not_low_cpu_mem = {p.device.type for p in model.parameters()}
+        logits_not_low_cpu_mem = model(**inputs).logits
+
+        del model
+
+        model = self.get_model().to(device)
+        model = PeftModel.from_pretrained(model, lora_path, low_cpu_mem_usage=True, torch_device=device).eval()
+        device_set_low_cpu_mem = {p.device.type for p in model.parameters()}
+        logits_low_cpu_mem = model(**inputs).logits
+
+        assert device_set_low_cpu_mem == device_set_not_low_cpu_mem
+        assert torch.allclose(logits_low_cpu_mem, logits_not_low_cpu_mem, atol=1e-6, rtol=1e-6)
+
+    @pytest.mark.parametrize("device", devices)
+    def test_load_adapter_low_cpu_mem_usage_works(self, device, inputs, lora_path, lora_config):
+        model = self.get_model().to(device)
+        inputs = {k: v.to(device) for k, v in inputs.items()}
+
+        torch.manual_seed(0)
+        model = get_peft_model(model, lora_config)
+        model.load_adapter(lora_path, adapter_name="other", torch_device=device)
+        model.set_adapter("other")
+        model.eval()
+        device_set_not_low_cpu_mem = {p.device.type for p in model.parameters()}
+        logits_not_low_cpu_mem = model(**inputs).logits
+
+        del model
+
+        model = self.get_model().to(device)
+        torch.manual_seed(0)
+        model = get_peft_model(model, lora_config)
+        model.load_adapter(lora_path, adapter_name="other", low_cpu_mem_usage=True, torch_device=device)
+        model.set_adapter("other")
+        model.eval()
+        device_set_low_cpu_mem = {p.device.type for p in model.parameters()}
+        logits_low_cpu_mem = model(**inputs).logits
+
+        assert device_set_low_cpu_mem == device_set_not_low_cpu_mem
+        assert torch.allclose(logits_low_cpu_mem, logits_not_low_cpu_mem, atol=1e-6, rtol=1e-6)
+
+    @pytest.mark.parametrize("device", devices)
+    def test_get_peft_model_low_cpu_mem_usage_works(self, device, inputs):
+        # when calling get_peft_model, the PEFT weights will not be initialized on device but remain on meta
+        model = self.get_model().to(device)
+        model = get_peft_model(model, LoraConfig(target_modules="all-linear"), low_cpu_mem_usage=True)
+
+        devices_lora_weights = {p.device for n, p in model.named_parameters() if "lora_" in n}
+        expected = {torch.device("meta")}
+        assert devices_lora_weights == expected
+
+    @pytest.mark.parametrize("device", devices)
+    def test_get_peft_model_with_task_type_low_cpu_mem_usage_works(self, device, inputs):
+        # same as the previous test, but pass the task_type argument
+        model = self.get_model().to(device)
+        model = get_peft_model(
+            model, LoraConfig(target_modules="all-linear", task_type="CAUSAL_LM"), low_cpu_mem_usage=True
+        )
+
+        devices_lora_weights = {p.device for n, p in model.named_parameters() if "lora_" in n}
+        expected = {torch.device("meta")}
+        assert devices_lora_weights == expected
+
+    @pytest.mark.parametrize("device", devices)
+    def test_inject_adapter_low_cpu_mem_usage_works(self, device, inputs, lora_path, lora_config):
+        # external libs like transformers and diffusers use inject_adapter_in_model, let's check that this also works
+        model = self.get_model().to(device)
+        inputs = {k: v.to(device) for k, v in inputs.items()}
+
+        torch.manual_seed(0)
+        model = get_peft_model(model, lora_config)
+        model.load_adapter(lora_path, adapter_name="other", torch_device=device)
+        model.set_adapter("other")
+        model.eval()
+        device_set_not_low_cpu_mem = {p.device.type for p in model.parameters()}
+        logits_not_low_cpu_mem = model(**inputs).logits
+
+        del model
+
+        torch.manual_seed(0)
+        model = self.get_model().to(device)
+        inject_adapter_in_model(lora_config, model, low_cpu_mem_usage=True)
+        device_set_before_loading = {p.device.type for p in model.parameters()}
+        # at this stage, lora weights are still on meta device
+        assert device_set_before_loading == {"meta", device}
+
+        state_dict = load_file(lora_path / "adapter_model.safetensors")
+        remapped_dict = {}
+        prefix = "base_model.model."
+        for key, val in state_dict.items():
+            new_key = key[len(prefix) :]
+            remapped_dict[new_key] = val.to(device)
+        errors = set_peft_model_state_dict(model, remapped_dict, low_cpu_mem_usage=True)
+        # sanity check: no unexpected keys
+        assert not errors.unexpected_keys
+
+        model.eval()
+        device_set_low_cpu_mem = {p.device.type for p in model.parameters()}
+        logits_low_cpu_mem = model(**inputs).logits
+
+        assert device_set_low_cpu_mem == device_set_not_low_cpu_mem
+        assert torch.allclose(logits_low_cpu_mem, logits_not_low_cpu_mem, atol=1e-6, rtol=1e-6)
+
+    ############################
+    # tests for PeftMixedModel #
+    ############################
+
+    @pytest.mark.parametrize("device", devices)
+    def test_mixed_model_from_pretrained_low_cpu_mem_usage_works(self, device, inputs, lora_path):
+        model = self.get_model().to(device)
+        inputs = {k: v.to(device) for k, v in inputs.items()}
+        model = PeftMixedModel.from_pretrained(model, lora_path, torch_device=device).eval()
+        device_set_not_low_cpu_mem = {p.device.type for p in model.parameters()}
+        logits_not_low_cpu_mem = model(**inputs).logits
+
+        del model
+
+        model = self.get_model().to(device)
+        model = PeftMixedModel.from_pretrained(model, lora_path, low_cpu_mem_usage=True, torch_device=device).eval()
+        device_set_low_cpu_mem = {p.device.type for p in model.parameters()}
+        logits_low_cpu_mem = model(**inputs).logits
+
+        assert device_set_low_cpu_mem == device_set_not_low_cpu_mem
+        assert torch.allclose(logits_low_cpu_mem, logits_not_low_cpu_mem, atol=1e-6, rtol=1e-6)
+
+    @pytest.mark.parametrize("device", devices)
+    def test_mixed_model_load_adapter_low_cpu_mem_usage_works(self, device, inputs, lora_path, lora_config):
+        model = self.get_model().to(device)
+        inputs = {k: v.to(device) for k, v in inputs.items()}
+
+        torch.manual_seed(0)
+        model = PeftModel.from_pretrained(model, lora_path)
+        model.load_adapter(lora_path, adapter_name="other", torch_device=device)
+        model.set_adapter("other")
+        model.eval()
+        device_set_not_low_cpu_mem = {p.device.type for p in model.parameters()}
+        logits_not_low_cpu_mem = model(**inputs).logits
+
+        del model
+
+        model = self.get_model().to(device)
+        torch.manual_seed(0)
+        model = PeftModel.from_pretrained(model, lora_path)
+        model.load_adapter(lora_path, adapter_name="other", low_cpu_mem_usage=True, torch_device=device)
+        model.set_adapter("other")
+        model.eval()
+        device_set_low_cpu_mem = {p.device.type for p in model.parameters()}
+        logits_low_cpu_mem = model(**inputs).logits
+
+        assert device_set_low_cpu_mem == device_set_not_low_cpu_mem
+        assert torch.allclose(logits_low_cpu_mem, logits_not_low_cpu_mem, atol=1e-6, rtol=1e-6)
+
+
+def test_from_pretrained_missing_keys_warning(recwarn, tmp_path):
+    # For more context, see issue 2115
+    # When loading a PEFT adapter and we're missing a PEFT-specific weight, there should be a warning.
+    model = AutoModelForCausalLM.from_pretrained("peft-internal-testing/tiny-random-OPTForCausalLM")
+    config = LoraConfig()
+    model = get_peft_model(model, config)
+    state_dict = model.state_dict()
+
+    # first, sanity check that there are no warnings if no key is missing
+    model.save_pretrained(tmp_path)
+    del model
+    model = AutoModelForCausalLM.from_pretrained("peft-internal-testing/tiny-random-OPTForCausalLM")
+    model = PeftModel.from_pretrained(model, tmp_path)
+    msg = "Found missing adapter keys"
+    assert not any(msg in str(w.message) for w in recwarn.list)
+
+    # remove a key from the state_dict
+    missing_key = "base_model.model.model.decoder.layers.0.self_attn.v_proj.lora_A.default.weight"
+
+    def new_state_dict():
+        return {k: v for k, v in state_dict.items() if k != missing_key}
+
+    model.state_dict = new_state_dict
+    model.save_pretrained(tmp_path)
+    del model
+
+    model = AutoModelForCausalLM.from_pretrained("peft-internal-testing/tiny-random-OPTForCausalLM")
+    model = PeftModel.from_pretrained(model, tmp_path)
+    assert any(msg in str(w.message) for w in recwarn.list)
+    assert any(missing_key in str(w.message) for w in recwarn.list)
+
+
+class TestNamingConflictWarning:
+    """
+    Tests for warnings related to naming conflicts between adapter names and tuner prefixes. References: Issue 2252
+    """
+
+    @pytest.fixture(autouse=True)
+    def setup(self):
+        self.peft_config = LoraConfig()
+        self.prefix = PEFT_TYPE_TO_PREFIX_MAPPING[self.peft_config.peft_type]
+        self.base_model = AutoModelForCausalLM.from_pretrained("peft-internal-testing/tiny-random-OPTForCausalLM")
+
+    def _save_and_reload_model(self, model, adapter_name, tmp_path):
+        # Helper method to save and reload the PEFT model
+        model.save_pretrained(tmp_path, selected_adapters=[adapter_name])
+        del model
+        reloaded_base_model = AutoModelForCausalLM.from_pretrained(tmp_path / adapter_name)
+        return PeftModel.from_pretrained(reloaded_base_model, tmp_path / adapter_name)
+
+    def test_no_warning_without_naming_conflict_get_peft_model(self, recwarn):
+        # No warning should be raised when there is no naming conflict during get_peft_model.
+        non_conflict_adapter = "adapter"
+        _ = get_peft_model(self.base_model, self.peft_config, adapter_name=non_conflict_adapter)
+        expected_msg = f"Adapter name '{non_conflict_adapter}' should not be contained in the prefix '{self.prefix}'."
+        assert not any(expected_msg in str(w.message) for w in recwarn.list)
+
+    def test_no_warning_without_naming_conflict_add_adapter(self, recwarn):
+        # No warning should be raised when adding an adapter without naming conflict.
+        non_conflict_adapter = "adapter"
+        other_non_conflict_adapter = "other_adapter"
+        model = get_peft_model(self.base_model, self.peft_config, adapter_name=non_conflict_adapter)
+        _ = model.add_adapter(other_non_conflict_adapter, self.peft_config)
+        expected_msg = (
+            f"Adapter name '{other_non_conflict_adapter}' should not be contained in the prefix '{self.prefix}'."
+        )
+        assert not any(expected_msg in str(w.message) for w in recwarn.list)
+
+    def test_no_warning_without_naming_conflict_save_and_load(self, recwarn, tmp_path):
+        # No warning should be raised when saving and loading the model without naming conflict.
+        non_conflict_adapter = "adapter"
+        model = get_peft_model(self.base_model, self.peft_config, adapter_name=non_conflict_adapter)
+        _ = self._save_and_reload_model(model, non_conflict_adapter, tmp_path)
+        expected_msg = f"Adapter name '{non_conflict_adapter}' should not be contained in the prefix '{self.prefix}'."
+        assert not any(expected_msg in str(w.message) for w in recwarn.list)
+
+    def test_warning_naming_conflict_get_peft_model(self, recwarn):
+        # Warning is raised when the adapter name conflicts with the prefix in get_peft_model.
+        conflicting_adapter_name = self.prefix[:-1]
+        _ = get_peft_model(self.base_model, self.peft_config, adapter_name=conflicting_adapter_name)
+        expected_msg = (
+            f"Adapter name '{conflicting_adapter_name}' should not be contained in the prefix '{self.prefix}'."
+        )
+        assert any(expected_msg in str(w.message) for w in recwarn.list)
+
+    def test_warning_naming_conflict_add_adapter(self, recwarn):
+        # Warning is raised when adding an adapter with a name that conflicts with the prefix.
+        conflicting_adapter = self.prefix[1:]
+        non_conflict_adapter = "adapter"
+        model = get_peft_model(self.base_model, self.peft_config, adapter_name=non_conflict_adapter)
+        _ = model.add_adapter(conflicting_adapter, self.peft_config)
+        expected_msg = f"Adapter name '{conflicting_adapter}' should not be contained in the prefix '{self.prefix}'."
+        assert any(expected_msg in str(w.message) for w in recwarn.list)
+
+    def test_warning_naming_conflict_save_and_load(self, recwarn, tmp_path):
+        # Warning is raised when saving and loading the model with a naming conflict.
+        conflicting_adapter = self.prefix[:-1]
+        model = get_peft_model(self.base_model, self.peft_config, adapter_name=conflicting_adapter)
+        _ = self._save_and_reload_model(model, conflicting_adapter, tmp_path)
+        expected_msg = f"Adapter name '{conflicting_adapter}' should not be contained in the prefix '{self.prefix}'."
+        assert any(expected_msg in str(w.message) for w in recwarn.list)
+
+
+class TestCordaInitialization:
+    """Test class to check the initialization of CorDA adapters."""
+
+    torch_device = infer_device()
+
+    def get_model(self):
+        class MyModule(nn.Module):
+            def __init__(self):
+                super().__init__()
+                # choose a large weight so that averages are close to expected values
+                self.linear = nn.Linear(1000, 1000)
+
+            def forward(self, x):
+                return self.linear(x)
+
+        return MyModule().eval().to(self.torch_device)
+
+    @pytest.fixture
+    def data(self):
+        # larger data is required to pass KPM test
+        torch.manual_seed(233)
+        return torch.rand(1000, 1000).to(self.torch_device)
+
+    @pytest.mark.parametrize("corda_method", ("ipm", "kpm"))
+    def test_lora_corda_no_redundant_fields(self, data, corda_method):
+        original_model = self.get_model()
+        model = deepcopy(original_model)
+
+        corda_config = CordaConfig(
+            corda_method=corda_method,
+        )
+        config = LoraConfig(
+            init_lora_weights="corda",
+            target_modules=["linear"],
+            corda_config=corda_config,
+        )
+        preprocess_corda(
+            model,
+            config,
+            run_model=lambda: model(data),
+            hooked_model=model,
+        )
+        peft_model = get_peft_model(model, config)
+
+        # check if the redundant fields are removed
+        assert not hasattr(peft_model.base_model.linear, "sample_count")
+        assert not hasattr(peft_model.base_model.linear, "covariance_matrix")
+        assert not hasattr(peft_model.base_model.linear, "corda_method")
+        assert not hasattr(peft_model.base_model.linear, "rank")
+        assert not hasattr(peft_model.base_model.linear, "eigens")
+
+        # legacy debug fields
+        assert not hasattr(peft_model.base_model.linear, "mean")
+        assert not hasattr(peft_model.base_model.linear, "std")
+
+    @pytest.mark.parametrize("corda_method", ("ipm", "kpm"))
+    def test_lora_corda_sample_count(self, data, corda_method):
+        original_model = self.get_model()
+        model = deepcopy(original_model)
+
+        corda_config = CordaConfig(
+            corda_method=corda_method,
+            prune_temporary_fields=False,
+        )
+        config = LoraConfig(
+            init_lora_weights="corda",
+            target_modules=["linear"],
+            corda_config=corda_config,
+        )
+        preprocess_corda(
+            model,
+            config,
+            run_model=lambda: [model(data), model(data)],  # running model twice to test `sample_count`
+            hooked_model=model,
+        )
+
+        # covariance of linear should be data.T @ data
+        layer = model.linear
+        assert hasattr(layer, "covariance_matrix")
+        assert torch.allclose(layer.covariance_matrix, data.T @ data, atol=1e-06)
+
+        # sample count of linear should be 2
+        assert hasattr(layer, "sample_count")
+        assert layer.sample_count == 2
+
+    @pytest.mark.parametrize("corda_method", ("ipm", "kpm"))
+    def test_lora_corda_hook_unregister(self, data, corda_method):
+        original_model = self.get_model()
+        model = deepcopy(original_model)
+
+        hook_call_count = 0
+
+        def hook(*args):
+            nonlocal hook_call_count
+            hook_call_count += 1
+
+        model.linear.register_forward_hook(hook)
+
+        corda_config = CordaConfig(
+            corda_method=corda_method,
+            prune_temporary_fields=False,
+        )
+        config = LoraConfig(
+            init_lora_weights="corda",
+            target_modules=["linear"],
+            corda_config=corda_config,
+        )
+        preprocess_corda(
+            model,
+            config,
+            run_model=lambda: model(data),
+            hooked_model=model,
+        )
+
+        # after preprocessing, external and internal hook should be run once
+        assert hook_call_count == 1
+        assert model.linear.sample_count == 1
+
+        # run preprocessed model once
+        model(data)[0]
+
+        # the external hook should be kept, but the internal hook should be gone
+        assert hook_call_count == 2
+        assert model.linear.sample_count == 1
+
+    @pytest.mark.parametrize("corda_method", ("ipm", "kpm"))
+    def test_lora_corda_linear_init_default(self, data, tmp_path, corda_method):
+        original_model = self.get_model()
+        model = deepcopy(original_model)
+        output_base = model(data)[0]
+
+        corda_config = CordaConfig(
+            cache_file=tmp_path / "corda_cache.pt",
+            covariance_file=tmp_path / "covariance_cache.pt",
+            corda_method=corda_method,
+        )
+        config = LoraConfig(
+            init_lora_weights="corda",
+            target_modules=["linear"],
+            corda_config=corda_config,
+        )
+        preprocess_corda(
+            model,
+            config,
+            run_model=lambda: model(data),
+            hooked_model=model,
+        )
+        peft_model = get_peft_model(model, config)
+
+        # check if adapter performs an identity transformantion
+        assert torch.allclose(output_base, peft_model(data)[0], atol=1e-06)
+
+        # modify the weights, or else the adapter performs an identity transformation
+        peft_model.base_model.linear.lora_B["default"].weight.data *= 2.0
+        output_corda = peft_model(data)[0]
+
+        # sanity check
+        tol = 1e-06
+        assert not torch.allclose(output_base, output_corda, atol=tol, rtol=tol)
+
+        # if load SVD result from cache, the output should be the same
+        model = deepcopy(original_model)
+        config = LoraConfig(
+            init_lora_weights="corda",
+            target_modules=["linear"],
+            corda_config=CordaConfig(cache_file=tmp_path / "corda_cache.pt", corda_method=corda_method),
+        )
+        preprocess_corda(model, config)
+        peft_model = get_peft_model(model, config)
+        peft_model.base_model.linear.lora_B["default"].weight.data *= 2.0
+        assert torch.allclose(output_corda, peft_model(data)[0], atol=1e-06)
+
+        # if load covariance from cache, the output should be the same
+        model = deepcopy(original_model)
+        config = LoraConfig(
+            init_lora_weights="corda",
+            target_modules=["linear"],
+            corda_config=CordaConfig(covariance_file=tmp_path / "covariance_cache.pt", corda_method=corda_method),
+        )
+        preprocess_corda(model, config)
+        peft_model = get_peft_model(model, config)
+        peft_model.base_model.linear.lora_B["default"].weight.data *= 2.0
+        assert torch.allclose(output_corda, peft_model(data)[0], atol=1e-06)
+
+    @pytest.mark.parametrize("corda_method", ("ipm", "kpm"))
+    def test_lora_corda_hooked_model_linear_init_default(self, data, tmp_path, corda_method):
+        original_model = self.get_model()
+        model = deepcopy(original_model)
+        hooked_model = deepcopy(model)
+        output_base = model(data)[0]
+
+        corda_config = CordaConfig(
+            cache_file=tmp_path / "corda_cache.pt",
+            covariance_file=tmp_path / "covariance_cache.pt",
+            corda_method=corda_method,
+        )
+        config = LoraConfig(
+            init_lora_weights="corda",
+            target_modules=["linear"],
+            corda_config=corda_config,
+        )
+
+        # difference from the above test: this test uses a copied model as hooked model
+        preprocess_corda(
+            model,
+            config,
+            run_model=lambda: hooked_model(data),
+            hooked_model=hooked_model,
+        )
+        peft_model = get_peft_model(model, config)
+
+        # check if adapter performs an identity transformantion
+        assert torch.allclose(output_base, peft_model(data)[0], atol=1e-06)
+
+        # modify the weights, or else the adapter performs an identity transformation
+        peft_model.base_model.linear.lora_B["default"].weight.data *= 2.0
+        output_corda = peft_model(data)[0]
+
+        # sanity check
+        tol = 1e-06
+        assert not torch.allclose(output_base, output_corda, atol=tol, rtol=tol)
+
+        # if load SVD result from cache, the output should be the same
+        model = deepcopy(original_model)
+        config = LoraConfig(
+            init_lora_weights="corda",
+            target_modules=["linear"],
+            corda_config=CordaConfig(cache_file=tmp_path / "corda_cache.pt", corda_method=corda_method),
+        )
+        preprocess_corda(model, config)
+        peft_model = get_peft_model(model, config)
+        peft_model.base_model.linear.lora_B["default"].weight.data *= 2.0
+        assert torch.allclose(output_corda, peft_model(data)[0], atol=1e-06)
+
+        # if load covariance from cache, the output should be the same
+        model = deepcopy(original_model)
+        config = LoraConfig(
+            init_lora_weights="corda",
+            target_modules=["linear"],
+            corda_config=CordaConfig(covariance_file=tmp_path / "covariance_cache.pt", corda_method=corda_method),
+        )
+        preprocess_corda(model, config)
+        peft_model = get_peft_model(model, config)
+        peft_model.base_model.linear.lora_B["default"].weight.data *= 2.0
+        assert torch.allclose(output_corda, peft_model(data)[0], atol=1e-06)
+
+    @pytest.mark.parametrize("corda_method", ("ipm", "kpm"))
+    def test_lora_corda_linear_init_default_with_rank_pattern(self, data, tmp_path, corda_method):
+        original_model = self.get_model()
+        model = deepcopy(original_model)
+        output_base = model(data)[0]
+
+        corda_config = CordaConfig(
+            cache_file=tmp_path / "corda_cache.pt",
+            covariance_file=tmp_path / "covariance_cache.pt",
+            corda_method=corda_method,
+        )
+        config = LoraConfig(
+            rank_pattern={"linear": 8, "embed": 16, "conv2d": 32},
+            init_lora_weights="corda",
+            target_modules=["linear"],
+            corda_config=corda_config,
+        )
+        preprocess_corda(
+            model,
+            config,
+            run_model=lambda: model(data),
+        )
+        peft_model = get_peft_model(model, config)
+
+        # check if adapter performs an identity transformantion
+        assert torch.allclose(output_base, peft_model(data)[0], atol=1e-06)
+
+        # modify the weights, or else the adapter performs an identity transformation
+        peft_model.base_model.linear.lora_B["default"].weight.data *= 2.0
+        output_corda = peft_model(data)[0]
+
+        # sanity check
+        tol = 1e-06
+        assert not torch.allclose(output_base, output_corda, atol=tol, rtol=tol)
+
+        # if load SVD result from cache, the output should be the same
+        model = deepcopy(original_model)
+        config = LoraConfig(
+            rank_pattern={"linear": 8, "embed": 16, "conv2d": 32},
+            init_lora_weights="corda",
+            target_modules=["linear"],
+            corda_config=CordaConfig(cache_file=tmp_path / "corda_cache.pt", corda_method=corda_method),
+        )
+        preprocess_corda(model, config)
+        peft_model = get_peft_model(model, config)
+        peft_model.base_model.linear.lora_B["default"].weight.data *= 2.0
+        assert torch.allclose(output_corda, peft_model(data)[0], atol=1e-06)
+
+        # if load covariance from cache, the output should be the same
+        model = deepcopy(original_model)
+        config = LoraConfig(
+            rank_pattern={"linear": 8, "embed": 16, "conv2d": 32},
+            init_lora_weights="corda",
+            target_modules=["linear"],
+            corda_config=CordaConfig(covariance_file=tmp_path / "covariance_cache.pt", corda_method=corda_method),
+        )
+        preprocess_corda(model, config)
+        peft_model = get_peft_model(model, config)
+        peft_model.base_model.linear.lora_B["default"].weight.data *= 2.0
+        assert torch.allclose(output_corda, peft_model(data)[0], atol=1e-06)
+
+    @pytest.mark.parametrize("corda_method", ("ipm", "kpm"))
+    def test_lora_corda_conversion_same_output_after_loading(self, data, tmp_path, corda_method):
+        model = self.get_model()
+        output_base = model(data)[0]
+
+        corda_config = CordaConfig(corda_method=corda_method)
+        config = LoraConfig(init_lora_weights="corda", target_modules=["linear"], r=8, corda_config=corda_config)
+        preprocess_corda(model, config, run_model=lambda: model(data), hooked_model=model)
+        peft_model = get_peft_model(deepcopy(model), config)
+        # save the initial model
+        peft_model.peft_config["default"].init_lora_weights = True
+        peft_model.save_pretrained(tmp_path / "init-model")
+        peft_model.peft_config["default"].init_lora_weights = "corda"
+
+        # modify the weights, or else the adapter performs an identity transformation
+        peft_model.base_model.linear.lora_B["default"].weight.data *= 2.0
+        output_corda = peft_model(data)[0]
+
+        # sanity check
+        tol = 1e-06
+        assert not torch.allclose(output_base, output_corda, atol=tol, rtol=tol)
+
+        # save the model normally
+        peft_model.save_pretrained(tmp_path / "corda-model")
+        model_loaded = PeftModel.from_pretrained(deepcopy(model), tmp_path / "corda-model")
+        output_loaded = model_loaded(data)[0]
+
+        assert torch.allclose(output_corda, output_loaded, atol=tol, rtol=tol)
+        # sanity check: ranks should still be 8 as initially
+        assert model_loaded.peft_config["default"].r == 8
+        assert model_loaded.base_model.model.linear.lora_A["default"].weight.shape[0] == 8
+        # sanity check: the base model weights were indeed changed
+        assert not torch.allclose(
+            model.linear.weight, model_loaded.base_model.model.linear.base_layer.weight, atol=tol, rtol=tol
+        )
+
+        # save the model with conversion
+        peft_config_keys_before = list(peft_model.peft_config.keys())
+        peft_config_dict_before = peft_model.peft_config["default"].to_dict()
+        peft_model.save_pretrained(
+            tmp_path / "corda-model-converted", path_initial_model_for_weight_conversion=tmp_path / "init-model"
+        )
+        peft_config_keys_after = list(peft_model.peft_config.keys())
+        peft_config_dict_after = peft_model.peft_config["default"].to_dict()
+        assert peft_config_keys_before == peft_config_keys_after
+        assert peft_config_dict_before == peft_config_dict_after
+
+        model_converted = PeftModel.from_pretrained(deepcopy(model), tmp_path / "corda-model-converted")
+        output_converted = model_converted(data)[0]
+
+        assert torch.allclose(output_corda, output_converted, atol=tol, rtol=tol)
+        # rank should be double of what it was initially
+        assert model_converted.peft_config["default"].r == 16
+        assert model_converted.base_model.model.linear.lora_A["default"].weight.shape[0] == 16
+        # base model weights should be the same as the initial model
+        assert torch.allclose(
+            model.linear.weight, model_converted.base_model.model.linear.base_layer.weight, atol=tol, rtol=tol
+        )
+
+    @pytest.mark.parametrize("corda_method", ("ipm", "kpm"))
+    def test_lora_corda_conversion_same_output_after_loading_with_rank_pattern(self, data, tmp_path, corda_method):
+        # same as above, but using rank_pattern
+        model = self.get_model()
+        output_base = model(data)[0]
+
+        # use rank_pattern here; note that since there is only a single linear layer, r is completely overridden
+        corda_config = CordaConfig(corda_method=corda_method)
+        config = LoraConfig(
+            init_lora_weights="corda",
+            target_modules=["linear"],
+            r=8,
+            rank_pattern={"linear": 32},
+            corda_config=corda_config,
+        )
+        preprocess_corda(model, config, run_model=lambda: model(data), hooked_model=model)
+        peft_model = get_peft_model(deepcopy(model), config)
+        # save the initial model
+        peft_model.peft_config["default"].init_lora_weights = True
+        peft_model.save_pretrained(tmp_path / "init-model")
+        peft_model.peft_config["default"].init_lora_weights = "corda"
+
+        # modify the weights, or else the adapter performs an identity transformation
+        peft_model.base_model.linear.lora_B["default"].weight.data *= 2.0
+        output_corda = peft_model(data)[0]
+
+        # sanity check
+        tol = 1e-06
+        assert not torch.allclose(output_base, output_corda, atol=tol, rtol=tol)
+
+        # save the model normally
+        peft_model.save_pretrained(tmp_path / "corda-model")
+        model_loaded = PeftModel.from_pretrained(deepcopy(model), tmp_path / "corda-model")
+        output_loaded = model_loaded(data)[0]
+
+        assert torch.allclose(output_corda, output_loaded, atol=tol, rtol=tol)
+        # sanity check: ranks should still be 8 as initially
+        assert model_loaded.peft_config["default"].r == 8
+        assert model_loaded.base_model.model.linear.lora_A["default"].weight.shape[0] == 32
+        # sanity check: the base model weights were indeed changed
+        assert not torch.allclose(
+            model.linear.weight, model_loaded.base_model.model.linear.base_layer.weight, atol=tol, rtol=tol
+        )
+
+        # save the model with conversion
+        peft_model.save_pretrained(
+            tmp_path / "corda-model-converted", path_initial_model_for_weight_conversion=tmp_path / "init-model"
+        )
+        model_converted = PeftModel.from_pretrained(deepcopy(model), tmp_path / "corda-model-converted")
+        output_converted = model_converted(data)[0]
+
+        assert torch.allclose(output_corda, output_converted, atol=tol, rtol=tol)
+        # rank should be double of what it was initially
+        assert model_converted.peft_config["default"].r == 16
+        assert model_converted.base_model.model.linear.lora_A["default"].weight.shape[0] == 64
+        # base model weights should be the same as the initial model
+        assert torch.allclose(
+            model.linear.weight, model_converted.base_model.model.linear.base_layer.weight, atol=tol, rtol=tol
+        )
+
+    @pytest.mark.parametrize("corda_method", ("ipm", "kpm"))
+    def test_lora_corda_conversion_same_output_after_loading_with_alpha_pattern(self, data, tmp_path, corda_method):
+        # same as above, but using alpha_pattern
+        model = self.get_model()
+        output_base = model(data)[0]
+
+        # use alpha_pattern here; note that since there is only a single linear layer, lora_alpha is completely
+        # overridden
+        corda_config = CordaConfig(corda_method=corda_method)
+        config = LoraConfig(
+            init_lora_weights="corda",
+            target_modules=["linear"],
+            alpha_pattern={"linear": 5},
+            corda_config=corda_config,
+        )
+        preprocess_corda(model, config, run_model=lambda: model(data), hooked_model=model)
+        peft_model = get_peft_model(deepcopy(model), config)
+        # save the initial model
+        peft_model.peft_config["default"].init_lora_weights = True
+        peft_model.save_pretrained(tmp_path / "init-model")
+        peft_model.peft_config["default"].init_lora_weights = "corda"
+
+        # modify the weights, or else the adapter performs an identity transformation
+        peft_model.base_model.linear.lora_B["default"].weight.data *= 2.0
+        output_corda = peft_model(data)[0]
+
+        # sanity check
+        tol = 1e-06
+        assert not torch.allclose(output_base, output_corda, atol=tol, rtol=tol)
+
+        # save the model normally
+        peft_model.save_pretrained(tmp_path / "corda-model")
+        model_loaded = PeftModel.from_pretrained(deepcopy(model), tmp_path / "corda-model")
+        output_loaded = model_loaded(data)[0]
+
+        assert torch.allclose(output_corda, output_loaded, atol=tol, rtol=tol)
+        # sanity check: ranks should still be 8 as initially
+        assert model_loaded.peft_config["default"].r == 8
+        assert model_loaded.base_model.model.linear.lora_A["default"].weight.shape[0] == 8
+        assert model_loaded.base_model.model.linear.scaling["default"] == 5 / 8
+        # sanity check: the base model weights were indeed changed
+        assert not torch.allclose(
+            model.linear.weight, model_loaded.base_model.model.linear.base_layer.weight, atol=tol, rtol=tol
+        )
+
+        # save the model with conversion
+        peft_model.save_pretrained(
+            tmp_path / "corda-model-converted", path_initial_model_for_weight_conversion=tmp_path / "init-model"
+        )
+        model_converted = PeftModel.from_pretrained(deepcopy(model), tmp_path / "corda-model-converted")
+        output_converted = model_converted(data)[0]
+
+        assert torch.allclose(output_corda, output_converted, atol=tol, rtol=tol)
+        # rank should be double of what it was initially
+        assert model_converted.peft_config["default"].r == 16
+        assert model_converted.base_model.model.linear.lora_A["default"].weight.shape[0] == 16
+        assert model_converted.base_model.model.linear.scaling["default"] == 10 / 16
+        # base model weights should be the same as the initial model
+        assert torch.allclose(
+            model.linear.weight, model_converted.base_model.model.linear.base_layer.weight, atol=tol, rtol=tol
+        )
+
+    @pytest.mark.parametrize("corda_method", ("ipm", "kpm"))
+    def test_lora_corda_conversion_same_output_after_loading_with_rslora(self, data, tmp_path, corda_method):
+        model = self.get_model()
+        output_base = model(data)[0]
+
+        corda_config = CordaConfig(corda_method=corda_method)
+        config = LoraConfig(
+            init_lora_weights="corda", target_modules=["linear"], r=8, use_rslora=True, corda_config=corda_config
+        )
+        preprocess_corda(model, config, run_model=lambda: model(data), hooked_model=model)
+        peft_model = get_peft_model(deepcopy(model), config)
+        # save the initial model
+        peft_model.peft_config["default"].init_lora_weights = True
+        peft_model.save_pretrained(tmp_path / "init-model")
+        peft_model.peft_config["default"].init_lora_weights = "corda"
+
+        # modify the weights, or else the adapter performs an identity transformation
+        peft_model.base_model.linear.lora_B["default"].weight.data *= 2.0
+        output_corda = peft_model(data)[0]
+
+        # sanity check
+        tol = 1e-06
+        assert not torch.allclose(output_base, output_corda, atol=tol, rtol=tol)
+
+        # save the model normally
+        peft_model.save_pretrained(tmp_path / "corda-model")
+        model_loaded = PeftModel.from_pretrained(deepcopy(model), tmp_path / "corda-model")
+        output_loaded = model_loaded(data)[0]
+
+        assert torch.allclose(output_corda, output_loaded, atol=tol, rtol=tol)
+        # sanity check: ranks should still be 8 as initially
+        assert model_loaded.peft_config["default"].r == 8
+        assert model_loaded.base_model.model.linear.lora_A["default"].weight.shape[0] == 8
+        assert model_loaded.base_model.model.linear.scaling["default"] == 8 / (8**0.5)
+        # sanity check: the base model weights were indeed changed
+        assert not torch.allclose(
+            model.linear.weight, model_loaded.base_model.model.linear.base_layer.weight, atol=tol, rtol=tol
+        )
+
+        # save the model with conversion
+        peft_model.save_pretrained(
+            tmp_path / "corda-model-converted", path_initial_model_for_weight_conversion=tmp_path / "init-model"
+        )
+        model_converted = PeftModel.from_pretrained(deepcopy(model), tmp_path / "corda-model-converted")
+        output_converted = model_converted(data)[0]
+
+        assert torch.allclose(output_corda, output_converted, atol=tol, rtol=tol)
+        # rank should be double of what it was initially
+        assert model_converted.peft_config["default"].r == 16
+        assert model_converted.base_model.model.linear.lora_A["default"].weight.shape[0] == 16
+        # same scale as before with a little bit of floating point imprecision
+        assert model_converted.base_model.model.linear.scaling["default"] == pytest.approx(8 / (8**0.5))
+        # base model weights should be the same as the initial model
+        assert torch.allclose(
+            model.linear.weight, model_converted.base_model.model.linear.base_layer.weight, atol=tol, rtol=tol
+        )
+
+    @pytest.mark.parametrize("corda_method", ("ipm", "kpm"))
+    def test_lora_corda_rank_pattern_and_rslora_raises(self, data, tmp_path, corda_method):
+        # it's not possible to determine the correct scale when using rslora with rank or alpha pattern, because the
+        # scale is not stored in the state_dict
+        model = self.get_model()
+        corda_config = CordaConfig(corda_method=corda_method)
+        config = LoraConfig(
+            init_lora_weights="corda",
+            target_modules=["linear"],
+            r=8,
+            rank_pattern={"linear": 2},
+            use_rslora=True,
+            corda_config=corda_config,
+        )
+        preprocess_corda(model, config, run_model=lambda: model(data), hooked_model=model)
+        peft_model = get_peft_model(model, config)
+        peft_model.save_pretrained(tmp_path / "init-model")
+
+        msg = re.escape("Passing `path_initial_model_for_weight_conversion` to `save_pretrained`")
+        with pytest.raises(ValueError, match=msg):
+            peft_model.save_pretrained(
+                tmp_path / "corda-model", path_initial_model_for_weight_conversion=tmp_path / "init-model"
+            )
+
+    @pytest.mark.parametrize("corda_method", ("ipm", "kpm"))
+    def test_lora_corda_alpha_pattern_and_rslora_raises(self, data, tmp_path, corda_method):
+        # it's not possible to determine the correct scale when using rslora with rank or alpha pattern, because the
+        # scale is not stored in the state_dict
+        model = self.get_model()
+        corda_config = CordaConfig(corda_method=corda_method)
+        config = LoraConfig(
+            init_lora_weights="corda",
+            target_modules=["linear"],
+            r=8,
+            alpha_pattern={"linear": 2},
+            use_rslora=True,
+            corda_config=corda_config,
+        )
+        preprocess_corda(model, config, run_model=lambda: model(data), hooked_model=model)
+        peft_model = get_peft_model(model, config)
+        peft_model.save_pretrained(tmp_path / "init-model")
+
+        msg = re.escape("Passing `path_initial_model_for_weight_conversion` to `save_pretrained`")
+        with pytest.raises(ValueError, match=msg):
+            peft_model.save_pretrained(
+                tmp_path / "corda-model", path_initial_model_for_weight_conversion=tmp_path / "init-model"
+            )
+
+    @pytest.mark.parametrize("corda_method", ("ipm", "kpm"))
+    def test_lora_corda_conv1d_gpt2(self, tmp_path, corda_method):
+        """Test that CoRDA works with Conv1D layers (GPT-2)."""
+        model = AutoModelForCausalLM.from_pretrained("peft-internal-testing/tiny-random-gpt2").to(self.torch_device)
+
+        # Create random input
+        input_ids = torch.randint(0, model.config.vocab_size, (1, 10), device=self.torch_device)
+
+        # Get baseline output
+        with torch.no_grad():
+            output_base = model(input_ids).logits
+
+        corda_config = CordaConfig(
+            cache_file=tmp_path / "corda_cache.pt",
+            corda_method=corda_method,
+        )
+        config = LoraConfig(
+            init_lora_weights="corda",
+            target_modules=["c_fc"],  # Conv1D layer in GPT-2
+            fan_in_fan_out=True,  # Required for Conv1D
+            corda_config=corda_config,
+        )
+
+        # Preprocess with CoRDA - this is the critical step that used to fail with Conv1D layers
+        # See issue: https://github.com/huggingface/peft/issues/2991
+        preprocess_corda(
+            model,
+            config,
+            run_model=lambda: model(input_ids),
+        )
+
+        # Create PEFT model
+        peft_model = get_peft_model(model, config)
+
+        # Sanity check: verify adapter performs identity transformation initially
+        # The important test is the preprocessing step above - this just confirms correctness
+        with torch.no_grad():
+            output_peft = peft_model(input_ids).logits
+        assert torch.allclose(output_base, output_peft, atol=1e-5)
+
+
+class TestEvaInitialization:
+    """Tests for the EVA (Explained Variance Adaptation) initialization method.
+
+    Only tests the config validation, as running EVA can be slow (see test_gpu_examples::TestEvaInitializationGPU for
+    more thorough tests)
+
+    """
+
+    def test_eva_config_rho(self):
+        """
+        Tests that EvaConfig.__init__ raises a ValueError when rho is negative.
+        """
+        with pytest.raises(ValueError, match="`rho` must be >= 1.0"):
+            EvaConfig(rho=-1)
+
+    def test_eva_config_tau(self):
+        """
+        Tests that EvaConfig.__init__ raises a ValueError when tau is not between 0.0 and 1.0.
+        """
+        with pytest.raises(ValueError, match="`tau` must be between 0.0 and 1.0."):
+            EvaConfig(tau=-0.1)
+        with pytest.raises(ValueError, match="`tau` must be between 0.0 and 1.0."):
+            EvaConfig(tau=1.1)
+
+    def test_lora_config_raises_warning_with_eva_init_but_not_eva_config(self):
+        """
+        Tests that LoraConfig.__init__ raises a warning when init_lora_weights='eva' but eva_config is not set.
+        """
+        with pytest.warns(
+            UserWarning,
+            match="`init_lora_weights` is 'eva' but `eva_config` is not specified. Using default EVA config.",
+        ):
+            LoraConfig(init_lora_weights="eva")
+
+    def test_lora_config_raises_warning_with_eva_config_but_not_eva_init(self):
+        """
+        Tests that LoraConfig.__init__ raises a warning when init_lora_weights is not 'eva' but eva_config is set.
+        """
+        with pytest.warns(
+            UserWarning, match="`eva_config` specified but will be ignored when `init_lora_weights` is not 'eva'."
+        ):
+            LoraConfig(init_lora_weights=True, eva_config=EvaConfig())
+
+
+class TestLilyInitialization:
+    """Tests for Lily adapter initialization and parameter sharing.
+
+    The model uses a two-level structure: self.blocks is a ModuleList of simple Block wrappers, each containing two
+    Linears named "lin0" and "lin1". This way all target Linear layers of the same name share the same suffix, which is
+    required for _post_injection_hook to group them and apply A/B sharing correctly. Sharing should only happen within
+    layers of the same name (e.g. lin0 with lin0, lin1 with lin1), never across different layer names.
+    """
+
+    torch_device = infer_device()
+
+    def get_model(self, num_layers=6):
+        """MLP with `num_layers` Block modules, each containing two Linear layers
+        named 'lin0' and 'lin1'."""
+
+        class Block(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.lin0 = nn.Linear(32, 32, bias=False)
+                self.lin1 = nn.Linear(32, 32, bias=False)
+
+            def forward(self, x):
+                return self.lin1(self.lin0(x))
+
+        class MLP(nn.Module):
+            def __init__(self, num_layers):
+                super().__init__()
+                self.blocks = nn.ModuleList([Block() for _ in range(num_layers)])
+
+            def forward(self, x):
+                for block in self.blocks:
+                    x = block(x)
+                return x
+
+        return MLP(num_layers).to(self.torch_device).eval()
+
+    def _get_lily_layers(self, model, adapter_name="default"):
+        """Return all LilyLayer modules in traversal order."""
+        from peft.tuners.lily.layer import LilyLayer
+
+        return [m for _, m in model.named_modules() if isinstance(m, LilyLayer) and adapter_name in m.lily_A]
+
+    def _get_lily_layers_by_suffix(self, model, suffix, adapter_name="default"):
+        """Return all LilyLayer modules whose key ends with `suffix`, in traversal order."""
+        from peft.tuners.lily.layer import LilyLayer
+
+        return [
+            m
+            for key, m in model.named_modules()
+            if isinstance(m, LilyLayer) and adapter_name in m.lily_A and key.endswith(suffix)
+        ]
+
+    @pytest.mark.parametrize("suffix", ["lin0", "lin1"])
+    def test_stride_A_1_no_A_sharing(self, suffix):
+        """With stride_A=1, every layer should have a distinct A adapter."""
+        num_layers = 4
+        model = self.get_model(num_layers=num_layers)
+        config = LilyConfig(
+            target_modules=["lin0", "lin1"],
+            r=8,
+            stride_A=1,
+            num_B=2,
+        )
+        model = get_peft_model(model, config)
+
+        layers = self._get_lily_layers_by_suffix(model, suffix)
+        assert len(layers) == num_layers
+
+        A_ptrs = [layer.lily_A["default"].weight.data_ptr() for layer in layers]
+        assert len(set(A_ptrs)) == num_layers, f"With stride_A=1, all A adapters for {suffix} should be distinct"
+
+    @pytest.mark.parametrize("suffix", ["lin0", "lin1"])
+    def test_stride_A_equals_num_layers_all_share_one_A(self, suffix):
+        """With stride_A >= num_layers, all layers should share the same single A adapter."""
+        num_layers = 4
+        model = self.get_model(num_layers=num_layers)
+        config = LilyConfig(
+            target_modules=["lin0", "lin1"],
+            r=8,
+            stride_A=num_layers,
+            num_B=2,
+        )
+        model = get_peft_model(model, config)
+
+        layers = self._get_lily_layers_by_suffix(model, suffix)
+        assert len(layers) == num_layers
+
+        A_ptrs = [layer.lily_A["default"].weight.data_ptr() for layer in layers]
+        assert len(set(A_ptrs)) == 1, f"With stride_A=num_layers, all {suffix} layers should share the same A"
+
+    @pytest.mark.parametrize("suffix", ["lin0", "lin1"])
+    def test_stride_A_partial_sharing(self, suffix):
+        """With stride_A=2 and 6 layers, there should be 3 distinct A adapters per layer name."""
+        num_layers = 6
+        stride_A = 2
+        model = self.get_model(num_layers=num_layers)
+        config = LilyConfig(
+            target_modules=["lin0", "lin1"],
+            r=8,
+            stride_A=stride_A,
+            num_B=2,
+        )
+        model = get_peft_model(model, config)
+
+        layers = self._get_lily_layers_by_suffix(model, suffix)
+        assert len(layers) == num_layers
+
+        A_ptrs = [layer.lily_A["default"].weight.data_ptr() for layer in layers]
+        num_distinct_A = len(set(A_ptrs))
+        expected = num_layers // stride_A
+        assert num_distinct_A == expected, (
+            f"Expected {expected} distinct A adapters for {suffix} with stride_A={stride_A}, got {num_distinct_A}"
+        )
+
+        for block_start in range(0, num_layers, stride_A):
+            block = layers[block_start : block_start + stride_A]
+            block_A_ptrs = {layer.lily_A["default"].weight.data_ptr() for layer in block}
+            assert len(block_A_ptrs) == 1, f"Layers in {suffix} block starting at {block_start} should share one A"
+
+    @pytest.mark.parametrize("suffix", ["lin0", "lin1"])
+    def test_stride_A_greater_than_num_layers(self, suffix):
+        """With stride_A > num_layers, all layers should still share one A."""
+        num_layers = 3
+        model = self.get_model(num_layers=num_layers)
+        config = LilyConfig(
+            target_modules=["lin0", "lin1"],
+            r=8,
+            stride_A=100,
+            num_B=2,
+        )
+        model = get_peft_model(model, config)
+
+        layers = self._get_lily_layers_by_suffix(model, suffix)
+        assert len(layers) == num_layers
+
+        A_ptrs = [layer.lily_A["default"].weight.data_ptr() for layer in layers]
+        assert len(set(A_ptrs)) == 1, f"stride_A > num_layers should still result in a single shared A for {suffix}"
+
+    @pytest.mark.parametrize("stride_A", [1, 2, 3, 6])
+    @pytest.mark.parametrize("suffix", ["lin0", "lin1"])
+    def test_B_always_shared_across_all_layers(self, suffix, stride_A):
+        """All layers should always share the same B adapter object, regardless of stride_A."""
+        num_layers = 6
+        model = self.get_model(num_layers=num_layers)
+        config = LilyConfig(
+            target_modules=["lin0", "lin1"],
+            r=8,
+            stride_A=stride_A,
+            num_B=2,
+        )
+        model = get_peft_model(model, config)
+
+        layers = self._get_lily_layers_by_suffix(model, suffix)
+        assert len(layers) == num_layers
+
+        B_ptrs = [layer.lily_B["default"].weight.data_ptr() for layer in layers]
+        assert len(set(B_ptrs)) == 1, (
+            f"All {suffix} layers should share one B adapter (stride_A={stride_A}), got {len(set(B_ptrs))} distinct"
+        )
+
+    @pytest.mark.parametrize("suffix", ["lin0", "lin1"])
+    def test_stride_A_non_divisible_num_layers(self, suffix):
+        """With stride_A=4 and 6 layers, there should be ceil(6/4)=2 distinct A adapters per layer name."""
+        num_layers = 6
+        stride_A = 4
+        model = self.get_model(num_layers=num_layers)
+        config = LilyConfig(
+            target_modules=["lin0", "lin1"],
+            r=8,
+            stride_A=stride_A,
+            num_B=2,
+        )
+        model = get_peft_model(model, config)
+
+        layers = self._get_lily_layers_by_suffix(model, suffix)
+        assert len(layers) == num_layers
+
+        A_ptrs = [layer.lily_A["default"].weight.data_ptr() for layer in layers]
+        expected = math.ceil(num_layers / stride_A)
+        assert len(set(A_ptrs)) == expected, (
+            f"Expected {expected} distinct A adapters for {suffix} with stride_A={stride_A}, num_layers={num_layers}"
+        )
+
+        first_block_A_ptrs = {layers[i].lily_A["default"].weight.data_ptr() for i in range(4)}
+        second_block_A_ptrs = {layers[i].lily_A["default"].weight.data_ptr() for i in range(4, 6)}
+        assert len(first_block_A_ptrs) == 1
+        assert len(second_block_A_ptrs) == 1
+        assert first_block_A_ptrs != second_block_A_ptrs
+
+    def test_no_sharing_across_different_layer_names(self):
+        """A and B adapters should never be shared between lin0 and lin1 layers."""
+        num_layers = 6
+        stride_A = 2
+        model = self.get_model(num_layers=num_layers)
+        config = LilyConfig(
+            target_modules=["lin0", "lin1"],
+            r=8,
+            stride_A=stride_A,
+            num_B=2,
+        )
+        model = get_peft_model(model, config)
+
+        lin0_layers = self._get_lily_layers_by_suffix(model, "lin0")
+        lin1_layers = self._get_lily_layers_by_suffix(model, "lin1")
+        assert len(lin0_layers) == num_layers
+        assert len(lin1_layers) == num_layers
+
+        lin0_A_ptrs = {layer.lily_A["default"].weight.data_ptr() for layer in lin0_layers}
+        lin1_A_ptrs = {layer.lily_A["default"].weight.data_ptr() for layer in lin1_layers}
+        assert lin0_A_ptrs.isdisjoint(lin1_A_ptrs), "A adapters should not be shared between lin0 and lin1 layers"
+
+        lin0_B_ptrs = {layer.lily_B["default"].weight.data_ptr() for layer in lin0_layers}
+        lin1_B_ptrs = {layer.lily_B["default"].weight.data_ptr() for layer in lin1_layers}
+        assert lin0_B_ptrs.isdisjoint(lin1_B_ptrs), "B adapters should not be shared between lin0 and lin1 layers"
+
+
+@pytest.mark.skipif(
+    platform.system() != "Linux", reason="Out of the box, torch.compile does not work on Windows or MacOS"
+)
+class TestHotSwapping:
+    """Tests for the hotswapping function"""
+
+    torch_device = infer_device()
+
+    def compile(self, model, do_compile):
+        if not do_compile:
+            return model
+        return torch.compile(model)
+
+    def get_model(self):
+        class MLP(nn.Module):
+            def __init__(self, bias=True):
+                super().__init__()
+                self.lin0 = nn.Linear(10, 20, bias=True)
+                self.relu = nn.ReLU()
+                self.lin1 = nn.Linear(20, 5, bias=False)
+
+            def forward(self, X):
+                X = X.float()
+                X = self.lin0(X)
+                X = self.relu(X)
+                X = self.lin1(X)
+                return X
+
+        torch.manual_seed(0)
+        return MLP().to(self.torch_device)
+
+    def get_model_conv2d(self):
+        class ConvModel(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.conv = nn.Conv2d(3, 10, kernel_size=3)
+
+            def forward(self, X):
+                return self.conv(X)
+
+        torch.manual_seed(0)
+        return ConvModel().to(self.torch_device)
+
+    @pytest.mark.parametrize(
+        "config",
+        [
+            LoraConfig(init_lora_weights=False, target_modules=["lin0"]),
+            LoraConfig(init_lora_weights=False, target_modules=["lin0", "lin1"]),
+        ],
+    )
+    @pytest.mark.parametrize("do_compile", [False, True])
+    def test_hotswap_works(self, config, do_compile, tmp_path):
+        # Load 2 different adapters and check that we can hotswap between them, with the model optionally being
+        # compiled.
+        atol, rtol = 1e-4, 1e-4
+        inputs = torch.rand(3, 10).to(self.torch_device)
+
+        # create adapter 0
+        model = self.get_model()
+        torch.manual_seed(0)
+        model = get_peft_model(model, config)
+        model = self.compile(model, do_compile=do_compile)
+        model.eval()
+        with torch.inference_mode():
+            output0 = model(inputs)
+        model.save_pretrained(tmp_path / "adapter0")
+
+        del model
+
+        # create adapter 1
+        model = self.get_model()
+        torch.manual_seed(1)
+        model = get_peft_model(model, config)
+        model = self.compile(model, do_compile=do_compile)
+        model.eval()
+        with torch.inference_mode():
+            output1 = model(inputs)
+        model.save_pretrained(tmp_path / "adapter1")
+
+        # sanity check: they're not the same
+        assert not torch.allclose(output0, output1, atol=atol, rtol=rtol)
+
+        del model
+
+        # load adapter 0
+        model = self.get_model()
+        model = PeftModel.from_pretrained(model, tmp_path / "adapter0")
+        model = self.compile(model, do_compile=do_compile)
+        with torch.inference_mode():
+            output_loaded0 = model(inputs)
+
+        # sanity check: same output after loading for adapter 0
+        assert torch.allclose(output0, output_loaded0, atol=atol, rtol=rtol)
+
+        # hotswap with adapter 1
+        hotswap_adapter(model, tmp_path / "adapter1", adapter_name="default")
+        with torch.inference_mode():
+            output_loaded1 = model(inputs)
+
+        # real check: model now behaves like adapter 1
+        assert torch.allclose(output1, output_loaded1, atol=atol, rtol=rtol)
+
+        # hotswap back to adapter 0
+        hotswap_adapter(model, tmp_path / "adapter0", adapter_name="default")
+        with torch.inference_mode():
+            output_loaded_back0 = model(inputs)
+
+        # real check: model now behaves again like adapter 0
+        assert torch.allclose(output0, output_loaded_back0, atol=atol, rtol=rtol)
+
+    def test_hotswap_different_peft_types_raises(self, tmp_path):
+        # When the configs of the two adapters are different PEFT methods, raise
+        config0 = LoraConfig(target_modules=["lin0"])
+        config1 = IA3Config(target_modules=["lin0"], feedforward_modules=[])
+
+        model = self.get_model()
+        model = get_peft_model(model, config0)
+        model.save_pretrained(tmp_path / "adapter0")
+        del model
+
+        model = self.get_model()
+        model = get_peft_model(model, config1)
+        model.save_pretrained(tmp_path / "adapter1")
+        del model
+
+        # load adapter 0
+        model = self.get_model()
+        model = PeftModel.from_pretrained(model, tmp_path / "adapter0")
+
+        msg = r"Incompatible PEFT types found: LORA and IA3"
+        with pytest.raises(ValueError, match=msg):
+            hotswap_adapter(model, tmp_path / "adapter1", adapter_name="default")
+
+    def test_hotswap_wrong_peft_types_raises(self, tmp_path):
+        # Only LoRA is supported at the moment
+        config0 = IA3Config(target_modules=["lin0"], feedforward_modules=[])
+        config1 = IA3Config(target_modules=["lin0"], feedforward_modules=[])
+
+        model = self.get_model()
+        model = get_peft_model(model, config0)
+        model.save_pretrained(tmp_path / "adapter0")
+        del model
+
+        model = self.get_model()
+        model = get_peft_model(model, config1)
+        model.save_pretrained(tmp_path / "adapter1")
+        del model
+
+        # load adapter 0
+        model = self.get_model()
+        model = PeftModel.from_pretrained(model, tmp_path / "adapter0")
+
+        msg = r"Hotswapping only supports LORA but IA3 was passed"
+        with pytest.raises(ValueError, match=msg):
+            hotswap_adapter(model, tmp_path / "adapter1", adapter_name="default")
+
+    def test_hotswap_missing_key_works(self, tmp_path):
+        # When a key is missing, it is fine, the extra weight is zeroed out
+        config = LoraConfig(target_modules=["lin0", "lin1"])
+
+        model = self.get_model()
+        model = get_peft_model(model, config)
+        model.save_pretrained(tmp_path / "adapter0")
+        del model
+
+        model = self.get_model()
+        model = get_peft_model(model, config)
+
+        # remove one key from the state_dict
+        key = "base_model.model.lin1.lora_A.default.weight"
+        state_dict = model.state_dict()
+        del state_dict[key]
+        model.state_dict = lambda: state_dict
+        model.save_pretrained(tmp_path / "adapter1")
+        del model
+
+        # load adapter 0
+        model = self.get_model()
+        model = PeftModel.from_pretrained(model, tmp_path / "adapter0")
+
+        # sanity check: the missing weight is not already all zeros
+        assert not (model.base_model.model.lin1.lora_A["default"].weight == 0).all()
+        hotswap_adapter(model, tmp_path / "adapter1", adapter_name="default")
+        # after hotswapping, it is zeroed out
+        assert (model.base_model.model.lin1.lora_A["default"].weight == 0).all()
+
+    def test_hotswap_extra_key_raises(self, tmp_path):
+        # When there is an extra key, raise
+        config = LoraConfig(target_modules=["lin0"])
+
+        model = self.get_model()
+        model = get_peft_model(model, config)
+        model.save_pretrained(tmp_path / "adapter0")
+        del model
+
+        model = self.get_model()
+        model = get_peft_model(model, config)
+
+        # add an unexpected key
+        state_dict = model.state_dict()
+        new_key = "base_model.model.lin1.lora_A.default.weight"
+        state_dict[new_key] = torch.zeros(8, 20)
+        model.state_dict = lambda: state_dict
+        model.save_pretrained(tmp_path / "adapter1")
+        del model
+
+        # load adapter 0
+        model = self.get_model()
+        model = PeftModel.from_pretrained(model, tmp_path / "adapter0")
+
+        msg = f"Hot swapping the adapter did not succeed, unexpected keys found: {new_key}"
+        with pytest.raises(RuntimeError, match=msg):
+            hotswap_adapter(model, tmp_path / "adapter1", adapter_name="default")
+
+    @pytest.mark.parametrize("ranks", [(7, 13), (13, 7)])
+    def test_hotswap_works_different_ranks_alphas(self, ranks, tmp_path):
+        # same as test_hotswap_works but different rank and alpha
+        # Load 2 different adapters and check that we can hotswap between them, with the model optionally being
+        # compiled.
+        atol, rtol = 1e-4, 1e-4
+        inputs = torch.rand(3, 10).to(self.torch_device)
+
+        # create adapter 0
+        config0 = LoraConfig(target_modules=["lin0", "lin1"], r=ranks[0], lora_alpha=ranks[0], init_lora_weights=False)
+        model = self.get_model()
+        torch.manual_seed(0)
+        model = get_peft_model(model, config0)
+        model.eval()
+        with torch.inference_mode():
+            output0 = model(inputs)
+        model.save_pretrained(tmp_path / "adapter0")
+
+        del model
+
+        # create adapter 1
+        config1 = LoraConfig(target_modules=["lin0"], r=ranks[1], lora_alpha=ranks[1], init_lora_weights=False)
+        model = self.get_model()
+        torch.manual_seed(1)
+        model = get_peft_model(model, config1)
+        model.eval()
+        with torch.inference_mode():
+            output1 = model(inputs)
+        model.save_pretrained(tmp_path / "adapter1")
+
+        # sanity check: they're not the same
+        assert not torch.allclose(output0, output1, atol=atol, rtol=rtol)
+
+        del model
+
+        # load adapter 0
+        model = self.get_model()
+        model = PeftModel.from_pretrained(model, tmp_path / "adapter0")
+        with torch.inference_mode():
+            output_loaded0 = model(inputs)
+
+        # sanity check: same output after loading for adapter 0
+        assert torch.allclose(output0, output_loaded0, atol=atol, rtol=rtol)
+
+        # hotswap with adapter 1
+        hotswap_adapter(model, tmp_path / "adapter1", adapter_name="default")
+        with torch.inference_mode():
+            output_loaded1 = model(inputs)
+
+        # real check: model now behaves like adapter 1
+        assert torch.allclose(output1, output_loaded1, atol=atol, rtol=rtol)
+
+        # hotswap back to adapter 0
+        hotswap_adapter(model, tmp_path / "adapter0", adapter_name="default")
+        with torch.inference_mode():
+            output_loaded_back0 = model(inputs)
+
+        # real check: model now behaves again like adapter 0
+        assert torch.allclose(output0, output_loaded_back0, atol=atol, rtol=rtol)
+
+    @pytest.mark.parametrize("ranks", [(7, 13), (13, 7)])
+    def test_hotswap_works_different_ranks_alphas_conv2d(self, ranks, tmp_path):
+        # same as previous test, but for a Conv2d model
+        atol, rtol = 1e-4, 1e-4
+        inputs = torch.rand(3, 3, 10, 10).to(self.torch_device)
+
+        # create adapter 0
+        config0 = LoraConfig(target_modules=["conv"], r=ranks[0], init_lora_weights=False)
+        model = self.get_model_conv2d()
+        torch.manual_seed(0)
+        model = get_peft_model(model, config0)
+        model.eval()
+        with torch.inference_mode():
+            output0 = model(inputs)
+        model.save_pretrained(tmp_path / "adapter0")
+
+        del model
+
+        # create adapter 1
+        config1 = LoraConfig(target_modules=["conv"], r=ranks[1], init_lora_weights=False)
+        model = self.get_model_conv2d()
+        torch.manual_seed(1)
+        model = get_peft_model(model, config1)
+        model.eval()
+        with torch.inference_mode():
+            output1 = model(inputs)
+        model.save_pretrained(tmp_path / "adapter1")
+
+        # sanity check: they're not the same
+        assert not torch.allclose(output0, output1, atol=atol, rtol=rtol)
+
+        del model
+
+        # load adapter 0
+        model = self.get_model_conv2d()
+        model = PeftModel.from_pretrained(model, tmp_path / "adapter0")
+        with torch.inference_mode():
+            output_loaded0 = model(inputs)
+
+        # sanity check: same output after loading for adapter 0
+        assert torch.allclose(output0, output_loaded0, atol=atol, rtol=rtol)
+
+        # hotswap with adapter 1
+        hotswap_adapter(model, tmp_path / "adapter1", adapter_name="default")
+        with torch.inference_mode():
+            output_loaded1 = model(inputs)
+
+        # real check: model now behaves like adapter 1
+        assert torch.allclose(output1, output_loaded1, atol=atol, rtol=rtol)
+
+        # hotswap back to adapter 0
+        hotswap_adapter(model, tmp_path / "adapter0", adapter_name="default")
+        with torch.inference_mode():
+            output_loaded_back0 = model(inputs)
+
+        # real check: model now behaves again like adapter 0
+        assert torch.allclose(output0, output_loaded_back0, atol=atol, rtol=rtol)
+
+    def test_prepare_model_for_compiled_hotswap_scalings_are_tensors(self):
+        config = LoraConfig(target_modules=["lin0", "lin1"])
+        model = self.get_model()
+        model = get_peft_model(model, config)
+
+        # sanity check: all scalings are floats
+        scalings_before = {}
+        for name, module in model.named_modules():
+            if hasattr(module, "scaling"):
+                for key, val in module.scaling.items():
+                    assert isinstance(val, float)
+                    scalings_before[f"{name}.{key}"] = val
+
+        prepare_model_for_compiled_hotswap(model)
+
+        scalings_after = {}
+        for name, module in model.named_modules():
+            if hasattr(module, "scaling"):
+                for key, val in module.scaling.items():
+                    assert isinstance(val, torch.Tensor)
+                    scalings_after[f"{name}.{key}"] = val.item()
+
+        assert scalings_before == scalings_after
+
+    def test_prepare_model_for_compiled_hotswap_rank_padding_works(self):
+        old_rank = 8
+        config = LoraConfig(target_modules=["lin0", "lin1"], r=old_rank)
+        model = self.get_model()
+        model = get_peft_model(model, config)
+
+        # sanity check
+        for name, param in model.named_parameters():
+            if "lora_A" in name:
+                assert param.shape[0] == old_rank
+            elif "lora_B" in name:
+                assert param.shape[1] == old_rank
+
+        new_rank = 13
+        prepare_model_for_compiled_hotswap(model, target_rank=new_rank)
+
+        for name, param in model.named_parameters():
+            if "lora_A" in name:
+                assert param.shape[0] == new_rank
+            elif "lora_B" in name:
+                assert param.shape[1] == new_rank
+
+    def test_prepare_model_for_compiled_hotswap_same_rank_padding_works(self):
+        # same as previous test, but ensure there is no error if the rank to pad to is the same
+        old_rank = 8
+        config = LoraConfig(target_modules=["lin0", "lin1"], r=old_rank)
+        model = self.get_model()
+        model = get_peft_model(model, config)
+        prepare_model_for_compiled_hotswap(model, target_rank=old_rank)
+
+        for name, param in model.named_parameters():
+            if "lora_A" in name:
+                assert param.shape[0] == old_rank
+            elif "lora_B" in name:
+                assert param.shape[1] == old_rank
+
+    def test_prepare_model_for_compiled_hotswap_conv2d_rank_padding_works(self):
+        # same as previous test, but for a Conv2d model
+        old_rank = 8
+        config = LoraConfig(target_modules=["conv"], r=old_rank)
+        model = self.get_model_conv2d()
+        model = get_peft_model(model, config)
+
+        # sanity check
+        for name, param in model.named_parameters():
+            if "lora_A" in name:
+                assert param.shape[0] == old_rank
+            elif "lora_B" in name:
+                assert param.shape[1] == old_rank
+
+        new_rank = 13
+        prepare_model_for_compiled_hotswap(model, target_rank=new_rank)
+
+        for name, param in model.named_parameters():
+            if "lora_A" in name:
+                assert param.shape[0] == new_rank
+            elif "lora_B" in name:
+                assert param.shape[1] == new_rank
+
+    def test_prepare_model_for_compiled_hotswap_lower_rank_padding_raises(self):
+        # when trying to pad to a lower rank, raise an error
+        old_rank0 = 8
+        old_rank1 = 10
+        new_rank = 9
+        config = LoraConfig(target_modules=["lin0", "lin1"], r=old_rank0, rank_pattern={"lin1": old_rank1})
+        model = self.get_model()
+        model = get_peft_model(model, config)
+
+        msg = re.escape("Trying to pad the adapter to the target rank 9, but the original rank is larger (10)")
+        with pytest.raises(ValueError, match=msg):
+            prepare_model_for_compiled_hotswap(model, target_rank=new_rank)
+
+    def test_prepare_model_for_compiled_hotswap_with_rank_pattern(self):
+        old_rank0 = 8
+        old_rank1 = 9
+        config = LoraConfig(target_modules=["lin0", "lin1"], r=old_rank0, rank_pattern={"lin1": old_rank1})
+        model = self.get_model()
+        model = get_peft_model(model, config)
+
+        # sanity check
+        for name, param in model.named_parameters():
+            if "lora_A" in name:
+                if "lin0" in name:
+                    assert param.shape[0] == old_rank0
+                else:
+                    assert param.shape[0] == old_rank1
+            elif "lora_B" in name:
+                if "lin0" in name:
+                    assert param.shape[1] == old_rank0
+                else:
+                    assert param.shape[1] == old_rank1
+
+        new_rank = 13
+        prepare_model_for_compiled_hotswap(model, target_rank=new_rank)
+
+        for name, param in model.named_parameters():
+            if "lora_A" in name:
+                assert param.shape[0] == new_rank
+            elif "lora_B" in name:
+                assert param.shape[1] == new_rank
+
+    @pytest.mark.parametrize("previous_requires_grad", [False, True])
+    def test_prepare_model_for_compiled_hotswap_conserves_requires_grad(self, previous_requires_grad):
+        # check that preparing the LoRA weights does not change requires_grad
+        old_rank = 8
+        target_rank = old_rank + 1
+        config = LoraConfig(target_modules=["lin0", "lin1"], r=old_rank)
+        model = self.get_model()
+        model = get_peft_model(model, config)
+
+        # set requires_grad of LoRA weights
+        for name, param in model.named_parameters():
+            if "lora_" in name:
+                param.requires_grad_(previous_requires_grad)
+
+        prepare_model_for_compiled_hotswap(model, target_rank=target_rank)
+
+        # check requires_grad of LoRA weights
+        for name, param in model.named_parameters():
+            if "lora_" in name:
+                assert param.requires_grad is previous_requires_grad
+
+    @pytest.mark.parametrize("previous_requires_grad", [False, True])
+    def test_prepare_model_for_compiled_hotswap_conv2d_conserves_requires_grad(self, previous_requires_grad):
+        # check that preparing the LoRA weights does not change requires_grad
+        old_rank = 8
+        target_rank = old_rank + 1
+        config = LoraConfig(target_modules=["conv"], r=old_rank)
+        model = self.get_model_conv2d()
+        model = get_peft_model(model, config)
+
+        # set requires_grad of LoRA weights
+        for name, param in model.named_parameters():
+            if "lora_" in name:
+                param.requires_grad_(previous_requires_grad)
+
+        prepare_model_for_compiled_hotswap(model, target_rank=target_rank)
+
+        # check requires_grad of LoRA weights
+        for name, param in model.named_parameters():
+            if "lora_" in name:
+                assert param.requires_grad is previous_requires_grad
+
+    def test_prepare_model_for_compiled_hotswap_model_already_compiled_raises(self):
+        config = LoraConfig(target_modules=["lin0"])
+        model = self.get_model()
+        model = get_peft_model(model, config)
+        model = torch.compile(model, mode="reduce-overhead")
+
+        msg = re.escape("Call prepare_model_for_compiled_hotswap *before* compiling the model")
+        with pytest.raises(ValueError, match=msg):
+            prepare_model_for_compiled_hotswap(model)
+
+    def test_prepare_model_for_compiled_hotswap_model_already_compiled_warns(self, recwarn):
+        config = LoraConfig(target_modules=["lin0"])
+        model = self.get_model()
+        model = get_peft_model(model, config)
+        model = torch.compile(model, mode="reduce-overhead")
+
+        msg = "prepare_model_for_compiled_hotswap was called with a model that is already compiled"
+        prepare_model_for_compiled_hotswap(model, check_compiled="warn")
+        assert any(msg in str(w.message) for w in recwarn)
+
+    def test_prepare_model_for_compiled_hotswap_model_already_compiled_ignore(self, recwarn):
+        config = LoraConfig(target_modules=["lin0"])
+        model = self.get_model()
+        model = get_peft_model(model, config)
+        model = torch.compile(model, mode="reduce-overhead")
+
+        msg = "prepare_model_for_compiled_hotswap was called with a model that is already compiled"
+        prepare_model_for_compiled_hotswap(model, check_compiled="ignore")
+        # no error, no warning
+        assert not any(msg in str(w.message) for w in recwarn)
+
+    def test_prepare_model_for_compiled_hotswap_model_already_compiled_wrong_argument(self, recwarn):
+        config = LoraConfig(target_modules=["lin0"])
+        model = self.get_model()
+        model = get_peft_model(model, config)
+        model = torch.compile(model, mode="reduce-overhead")
+
+        msg = re.escape("check_compiles should be one of 'error', 'warn', or 'ignore', got 'wrong-option' instead.")
+        with pytest.raises(ValueError, match=msg):
+            prepare_model_for_compiled_hotswap(model, check_compiled="wrong-option")
+
+    def test_prepare_model_for_compiled_hotswap_model_no_adapter_raises(self):
+        model = self.get_model()
+        msg = re.escape("No adapter layers found on the model")
+        with pytest.raises(ValueError, match=msg):
+            prepare_model_for_compiled_hotswap(model)
+
+    def test_prepare_model_for_compiled_hotswap_does_not_change_output(self):
+        # preparing the model for hotswapping should not change the model output
+        inputs = torch.rand(3, 10).to(self.torch_device)
+        model = self.get_model().eval()
+        with torch.inference_mode():
+            output_base = model(inputs)
+
+        old_rank = 8
+        config = LoraConfig(target_modules=["lin0", "lin1"], r=old_rank, init_lora_weights=False)
+        model = get_peft_model(model, config).eval()
+        with torch.inference_mode():
+            output_before = model(inputs)
+
+        # sanity check: LoRA changed output
+        assert not torch.allclose(output_base, output_before)
+
+        new_rank = 13
+        prepare_model_for_compiled_hotswap(model, target_rank=new_rank)
+        with torch.inference_mode():
+            output_after = model(inputs)
+
+        assert torch.allclose(output_before, output_after)
+
+    def test_prepare_model_for_compiled_hotswap_does_not_change_output_conv2d(self):
+        # preparing the model for hotswapping should not change the model output
+        inputs = torch.rand(3, 3, 10, 10).to(self.torch_device)
+        model = self.get_model_conv2d().eval()
+        with torch.inference_mode():
+            output_base = model(inputs)
+
+        old_rank = 8
+        config = LoraConfig(target_modules=["conv"], r=old_rank, init_lora_weights=False)
+        model = get_peft_model(model, config).eval()
+        with torch.inference_mode():
+            output_before = model(inputs)
+
+        # sanity check: LoRA changed output
+        assert not torch.allclose(output_base, output_before)
+
+        new_rank = 13
+        prepare_model_for_compiled_hotswap(model, target_rank=new_rank)
+        with torch.inference_mode():
+            output_after = model(inputs)
+
+        assert torch.allclose(output_before, output_after)
+
+    def test_prepare_model_for_compiled_hotswap_scalings_update_config(self):
+        old_rank0 = 11
+        old_rank1 = 13
+        config = LoraConfig(target_modules=["lin0", "lin1"], r=old_rank0, rank_pattern={"lin1": old_rank1})
+        model = self.get_model()
+        model = get_peft_model(model, config)
+
+        new_rank = 15
+        prepare_model_for_compiled_hotswap(model, target_rank=new_rank, config=model.peft_config)
+
+        assert model.peft_config["default"].r == new_rank
+        assert model.peft_config["default"].rank_pattern == {"lin1": new_rank}
+
+    def test_prepare_model_for_compiled_hotswap_lora_bias(self):
+        # When setting lora_bias=True in the LoraConfig, the LoRA B parameter will have a bias term. Check that padding
+        # still works correctly. Note that the LoRA A parameter still won't have a bias term.
+        old_rank = 8
+        config = LoraConfig(target_modules=["lin0", "lin1"], r=old_rank, lora_bias=True)
+        model = self.get_model()
+        model = get_peft_model(model, config)
+
+        # sanity check
+        for name, param in model.named_parameters():
+            if "lora_A" in name and name.endswith(".weight"):
+                assert param.shape[0] == old_rank
+            elif "lora_B" in name and name.endswith(".weight"):
+                assert param.shape[1] == old_rank
+            elif "lora_A" in name and name.endswith(".bias"):
+                assert False, "LoRA A should not have a bias term"
+            elif "lora_B" in name and name.endswith(".bias"):
+                assert param.shape[0] in (5, 20)  # output shapes of the 2 layers
+
+        new_rank = 13
+        prepare_model_for_compiled_hotswap(model, target_rank=new_rank)
+
+        for name, param in model.named_parameters():
+            if "lora_A" in name and name.endswith(".weight"):
+                assert param.shape[0] == new_rank
+            elif "lora_B" in name and name.endswith(".weight"):
+                assert param.shape[1] == new_rank
+            elif "lora_A" in name and name.endswith(".bias"):
+                assert False, "LoRA A should not have a bias term"
+            elif "lora_B" in name and name.endswith(".bias"):
+                assert param.shape[0] in (5, 20)  # output shapes of the 2 layers
+
+    def test_prepare_model_for_compiled_hotswap_conv2d_lora_bias(self):
+        # same as previous test, but for a Conv2d model
+        old_rank = 8
+        config = LoraConfig(target_modules=["conv"], r=old_rank, lora_bias=True)
+        model = self.get_model_conv2d()
+        model = get_peft_model(model, config)
+
+        # sanity check
+        for name, param in model.named_parameters():
+            if "lora_A" in name and name.endswith(".weight"):
+                assert param.shape[0] == old_rank
+            elif "lora_B" in name and name.endswith(".weight"):
+                assert param.shape[1] == old_rank
+            elif "lora_A" in name and name.endswith(".bias"):
+                assert False, "LoRA A should not have a bias term"
+            elif "lora_B" in name and name.endswith(".bias"):
+                assert param.shape[0] == 10  # output shape of conv layer
+
+        new_rank = 13
+        prepare_model_for_compiled_hotswap(model, target_rank=new_rank)
+
+        for name, param in model.named_parameters():
+            if "lora_A" in name and name.endswith(".weight"):
+                assert param.shape[0] == new_rank
+            elif "lora_B" in name and name.endswith(".weight"):
+                assert param.shape[1] == new_rank
+            elif "lora_A" in name and name.endswith(".bias"):
+                assert False, "LoRA A should not have a bias term"
+            elif "lora_B" in name and name.endswith(".bias"):
+                assert param.shape[0] == 10  # output shape of conv layer
+
+
+class TestScaling:
+    """Tests for scaling and unscaling
+
+    Those methods are currently only implemented for LoRA and were added for use in diffusers.
+    """
+
+    @pytest.fixture
+    def model(self):
+        # tiny opt with 5 attention layers
+        model_id = "peft-internal-testing/tiny-random-OPTForCausalLM"
+        return AutoModelForCausalLM.from_pretrained(model_id)
+
+    def get_scalings(self, model, adapter_name="default"):
+        # helper function, returns the scalings of the 5 attention layers
+        return [m.scaling[adapter_name] for m in model.modules() if isinstance(m, LoraLayer)]
+
+    def set_scale(self, model, adapter_name, scale):
+        for module in model.modules():
+            if isinstance(module, LoraLayer):
+                module.set_scale(adapter_name, scale)
+
+    def scale_layer(self, model, scale):
+        for module in model.modules():
+            if isinstance(module, LoraLayer):
+                module.scale_layer(scale)
+
+    def unscale_layer(self, model, scale):
+        for module in model.modules():
+            if isinstance(module, LoraLayer):
+                module.unscale_layer(scale)
+
+    def test_scaling_simple(self, model):
+        n_layers = 5
+        rank, lora_alpha = 8, 16
+        config = LoraConfig(
+            r=rank,
+            lora_alpha=lora_alpha,
+            target_modules=["k_proj"],
+        )
+        model = get_peft_model(model, config)
+        scalings = self.get_scalings(model)
+        expected = [lora_alpha / rank] * n_layers
+        assert scalings == expected
+
+        # double
+        self.scale_layer(model, 2)
+        scalings = self.get_scalings(model)
+        expected = [4.0] * n_layers
+        assert scalings == expected
+
+        # back to original
+        self.unscale_layer(model, None)
+        scalings = self.get_scalings(model)
+        expected = [2.0] * n_layers
+        assert scalings == expected
+
+        # triple
+        self.set_scale(model, "default", 3)
+        scalings = self.get_scalings(model)
+        expected = [6.0] * n_layers
+        assert scalings == expected
+
+        # back to original
+        self.unscale_layer(model, 3)
+        scalings = self.get_scalings(model)
+        expected = [2.0] * n_layers
+        assert scalings == expected
+
+    def test_scaling_with_rslora(self, model):
+        n_layers = 5
+        rank, lora_alpha = 8, 16
+        config = LoraConfig(
+            r=rank,
+            lora_alpha=lora_alpha,
+            use_rslora=True,
+            target_modules=["k_proj"],
+        )
+        model = get_peft_model(model, config)
+        scalings = self.get_scalings(model)
+        expected = [lora_alpha / math.sqrt(rank)] * n_layers
+        assert scalings == expected
+
+        # double
+        self.scale_layer(model, 2)
+        scalings = self.get_scalings(model)
+        expected = [2 * lora_alpha / math.sqrt(rank)] * n_layers
+        assert scalings == expected
+
+        # back to original
+        self.unscale_layer(model, None)
+        scalings = self.get_scalings(model)
+        expected = [lora_alpha / math.sqrt(rank)] * n_layers
+        assert scalings == expected
+
+        # triple
+        self.set_scale(model, "default", 3)
+        scalings = self.get_scalings(model)
+        expected = [3 * lora_alpha / math.sqrt(rank)] * n_layers
+        assert scalings == expected
+
+        # back to original
+        self.unscale_layer(model, 3)
+        scalings = self.get_scalings(model)
+        expected = [lora_alpha / math.sqrt(rank)] * n_layers
+        assert scalings == expected
+
+    def test_scaling_rank_pattern_alpha_pattern(self, model):
+        # layer 0: 8 / 8
+        # layer 1: 8 / 16
+        # layer 2: 4 / 32
+        # layer 3: 16 / 8
+        # layer 4: 8 / 8
+        config = LoraConfig(
+            r=8,
+            lora_alpha=8,
+            target_modules=["k_proj"],
+            rank_pattern={"layers.1.self_attn.k_proj": 16, "layers.2.self_attn.k_proj": 32},
+            alpha_pattern={"layers.2.self_attn.k_proj": 4, "layers.3.self_attn.k_proj": 16},
+        )
+        model = get_peft_model(model, config)
+        scalings = self.get_scalings(model)
+        expected = [1.0, 0.5, 0.125, 2.0, 1.0]
+        assert scalings == expected
+
+        # double
+        self.scale_layer(model, 2)
+        scalings = self.get_scalings(model)
+        expected = [2.0, 1.0, 0.25, 4.0, 2.0]
+        assert scalings == expected
+
+        # back to original
+        self.unscale_layer(model, None)
+        scalings = self.get_scalings(model)
+        expected = [1.0, 0.5, 0.125, 2.0, 1.0]
+        assert scalings == expected
+
+        # triple
+        self.set_scale(model, "default", 3)
+        scalings = self.get_scalings(model)
+        expected = [3.0, 1.5, 0.375, 6.0, 3.0]
+        assert scalings == expected
+
+        # back to original
+        self.unscale_layer(model, 3)
+        scalings = self.get_scalings(model)
+        expected = [1.0, 0.5, 0.125, 2.0, 1.0]
+        assert scalings == expected
+
+    def test_scaling_multiple_times(self, model):
+        # same as previous test, but scale and unscale multiple times in a row
+        # layer 0: 8 / 8
+        # layer 1: 8 / 16
+        # layer 2: 4 / 32
+        # layer 3: 16 / 8
+        # layer 4: 8 / 8
+        config = LoraConfig(
+            r=8,
+            lora_alpha=8,
+            target_modules=["k_proj"],
+            rank_pattern={"layers.1.self_attn.k_proj": 16, "layers.2.self_attn.k_proj": 32},
+            alpha_pattern={"layers.2.self_attn.k_proj": 4, "layers.3.self_attn.k_proj": 16},
+        )
+        model = get_peft_model(model, config)
+        scalings = self.get_scalings(model)
+        expected = [1.0, 0.5, 0.125, 2.0, 1.0]
+        assert scalings == expected
+
+        # scale of 1 makes no difference
+        self.scale_layer(model, 1)
+        scalings = self.get_scalings(model)
+        expected = [1.0, 0.5, 0.125, 2.0, 1.0]
+
+        # double
+        self.scale_layer(model, 2)
+        scalings = self.get_scalings(model)
+        expected = [2.0, 1.0, 0.25, 4.0, 2.0]
+        assert scalings == expected
+
+        # triple, on top of previous double
+        self.scale_layer(model, 3)
+        scalings = self.get_scalings(model)
+        expected = [6.0, 3.0, 0.75, 12.0, 6.0]
+        assert scalings == expected
+
+        # half
+        self.unscale_layer(model, 2)
+        scalings = self.get_scalings(model)
+        expected = [3.0, 1.5, 0.375, 6.0, 3.0]
+        assert scalings == expected
+
+        # divide by 3, on top of previous half
+        self.unscale_layer(model, 3)
+        scalings = self.get_scalings(model)
+        expected = [1.0, 0.5, 0.125, 2.0, 1.0]
+        assert scalings == expected
+
+        # set scale to 2
+        self.set_scale(model, "default", 2)
+        scalings = self.get_scalings(model)
+        expected = [2.0, 1.0, 0.25, 4.0, 2.0]
+        assert scalings == expected
+
+        # set scale to 3, it is cumulative but based on the initial scaling, so factor 3, not 6
+        self.set_scale(model, "default", 3)
+        scalings = self.get_scalings(model)
+        expected = [3.0, 1.5, 0.375, 6.0, 3.0]
+        assert scalings == expected
+
+        # back to original
+        self.unscale_layer(model, None)
+        scalings = self.get_scalings(model)
+        expected = [1.0, 0.5, 0.125, 2.0, 1.0]
+        assert scalings == expected
+
+        # back to original again
+        self.unscale_layer(model, None)
+        scalings = self.get_scalings(model)
+        expected = [1.0, 0.5, 0.125, 2.0, 1.0]
+        assert scalings == expected
+
+    def test_scaling_multiple_adapters(self, model):
+        # ensure that scaling works with multiple adapters
+        n_layers = 5
+        rank0, lora_alpha0 = 8, 16
+        config0 = LoraConfig(
+            r=rank0,
+            lora_alpha=lora_alpha0,
+            target_modules=["k_proj"],
+        )
+        rank1, lora_alpha1 = 16, 8
+        config1 = LoraConfig(
+            r=rank1,
+            lora_alpha=lora_alpha1,
+            target_modules=["k_proj"],
+        )
+        model = get_peft_model(model, config0)
+        model.add_adapter("other", config1)
+
+        scalings_default = self.get_scalings(model, "default")
+        scalings_other = self.get_scalings(model, "other")
+        expected_default = [lora_alpha0 / rank0] * n_layers
+        expected_other = [lora_alpha1 / rank1] * n_layers
+        assert scalings_default == expected_default
+        assert scalings_other == expected_other
+
+        # double the scale for other
+        self.set_scale(model, "other", 2)
+        scalings_default = self.get_scalings(model, "default")
+        scalings_other = self.get_scalings(model, "other")
+        expected_default = [lora_alpha0 / rank0] * n_layers
+        expected_other = [2 * lora_alpha1 / rank1] * n_layers
+        assert scalings_default == expected_default
+        assert scalings_other == expected_other
+
+        # quarter the scale for default
+        self.set_scale(model, "default", 0.25)
+        scalings_default = self.get_scalings(model, "default")
+        scalings_other = self.get_scalings(model, "other")
+        expected_default = [lora_alpha0 / rank0 / 4] * n_layers
+        expected_other = [2 * lora_alpha1 / rank1] * n_layers
+        assert scalings_default == expected_default
+        assert scalings_other == expected_other
+
+        # unscale resets for all *active* adapters
+        self.unscale_layer(model, None)
+        scalings_default = self.get_scalings(model, "default")
+        scalings_other = self.get_scalings(model, "other")
+        expected_default = [lora_alpha0 / rank0] * n_layers
+        expected_other = [2 * lora_alpha1 / rank1] * n_layers  # stays the same as 'other' is not active
+        assert scalings_default == expected_default
+        assert scalings_other == expected_other
+
+        # scale all *active* adapters by 2
+        self.scale_layer(model, 2)
+        scalings_default = self.get_scalings(model, "default")
+        scalings_other = self.get_scalings(model, "other")
+        expected_default = [2 * lora_alpha0 / rank0] * n_layers
+        expected_other = [2 * lora_alpha1 / rank1] * n_layers  # stays the same as 'other' is not active
+        assert scalings_default == expected_default
+        assert scalings_other == expected_other
+
+        # switch to 'other'
+        model.set_adapter("other")
+
+        # unscale, this time 'other'
+        self.unscale_layer(model, None)
+        scalings_default = self.get_scalings(model, "default")
+        scalings_other = self.get_scalings(model, "other")
+        expected_default = [2 * lora_alpha0 / rank0] * n_layers  # stays the same as 'other' is not active
+        expected_other = [lora_alpha1 / rank1] * n_layers
+        assert scalings_default == expected_default
+        assert scalings_other == expected_other
+
+        # scale all *active* adapters by 3
+        self.scale_layer(model, 3)
+        scalings_default = self.get_scalings(model, "default")
+        scalings_other = self.get_scalings(model, "other")
+        expected_default = [2 * lora_alpha0 / rank0] * n_layers  # stays the same as 'other' is not active
+        expected_other = [3 * lora_alpha1 / rank1] * n_layers
+        assert scalings_default == expected_default
+        assert scalings_other == expected_other
+
+
+class TestLoadPeftKeyMapping:
+    # See discussion in https://github.com/huggingface/transformers/pull/38627
+
+    # transformers PR #37033 re-arranges the way visual language models are built by moving the LM head from the
+    # language model to the top-level VLM (among other things). A consequence of this is that the keys in the PEFT
+    # state_dict now also follow the new architecture. This test class serves to ensure that old checkpoints can be
+    # loaded with the changed architecture. Unfortunately, new checkpoints cannot be loaded with the old architecture,
+    # the corresponding test is marked as xfail.
+
+    # Note: We only test prefix tuning (prompt learning method), LoRA (non-prompt learning method), and VBLoRA (shared
+    # parameters) as the other PEFT methods should work the same way. It would be excessive to test all of them here.
+
+    @pytest.fixture
+    def fake_model_config(self):
+        # mimics a transformers model config
+        class FakeConfig(dict):
+            def __init__(self):
+                self.vocab_size = 10
+
+            def __getattr__(self, item):
+                if item in self:
+                    return self[item]
+                raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{item}'")
+
+        return FakeConfig()
+
+    @pytest.fixture
+    def old_model(self, fake_model_config):
+        # create a small model that mimics the old architecture of, for instance, Qwen/Qwen2-VL-2B-Instruct
+        # Qwen2VLForConditionalGeneration(
+        #   (visual): Qwen2VisionTransformerPretrainedModel(
+        #     (patch_embed): PatchEmbed(
+        #       (proj): Conv3d(3, 1280, kernel_size=(2, 14, 14), stride=(2, 14, 14), bias=False)
+        #     )
+        #     (rotary_pos_emb): VisionRotaryEmbedding()
+        #     (blocks): ModuleList(
+        #       (0-31): 32 x Qwen2VLVisionBlock(
+        #         (norm1): LayerNorm((1280,), eps=1e-06, elementwise_affine=True)
+        #         (norm2): LayerNorm((1280,), eps=1e-06, elementwise_affine=True)
+        #         (attn): VisionSdpaAttention(
+        #           (qkv): Linear(in_features=1280, out_features=3840, bias=True)
+        #           (proj): Linear(in_features=1280, out_features=1280, bias=True)
+        #         )
+        #         (mlp): VisionMlp(
+        #           (fc1): Linear(in_features=1280, out_features=5120, bias=True)
+        #           (act): QuickGELUActivation()
+        #           (fc2): Linear(in_features=5120, out_features=1280, bias=True)
+        #         )
+        #       )
+        #     )
+        #     (merger): PatchMerger(
+        #       (ln_q): LayerNorm((1280,), eps=1e-06, elementwise_affine=True)
+        #       (mlp): Sequential(
+        #         (0): Linear(in_features=5120, out_features=5120, bias=True)
+        #         (1): GELU(approximate='none')
+        #         (2): Linear(in_features=5120, out_features=1536, bias=True)
+        #       )
+        #     )
+        #   )
+        #   (model): Qwen2VLModel(
+        #     (embed_tokens): Embedding(151936, 1536)
+        #     (layers): ModuleList(
+        #       (0-27): 28 x Qwen2VLDecoderLayer(
+        #         (self_attn): Qwen2VLSdpaAttention(
+        #           (q_proj): Linear(in_features=1536, out_features=1536, bias=True)
+        #           (k_proj): Linear(in_features=1536, out_features=256, bias=True)
+        #           (v_proj): Linear(in_features=1536, out_features=256, bias=True)
+        #           (o_proj): Linear(in_features=1536, out_features=1536, bias=False)
+        #           (rotary_emb): Qwen2VLRotaryEmbedding()
+        #         )
+        #         (mlp): Qwen2MLP(
+        #           (gate_proj): Linear(in_features=1536, out_features=8960, bias=False)
+        #           (up_proj): Linear(in_features=1536, out_features=8960, bias=False)
+        #           (down_proj): Linear(in_features=8960, out_features=1536, bias=False)
+        #           (act_fn): SiLU()
+        #         )
+        #         (input_layernorm): Qwen2RMSNorm((1536,), eps=1e-06)
+        #         (post_attention_layernorm): Qwen2RMSNorm((1536,), eps=1e-06)
+        #       )
+        #     )
+        #     (norm): Qwen2RMSNorm((1536,), eps=1e-06)
+        #     (rotary_emb): Qwen2VLRotaryEmbedding()
+        #   )
+        #   (lm_head): Linear(in_features=1536, out_features=151936, bias=False)
+        # )
+        class Block(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.attn = nn.Linear(10, 10)
+
+        class OldModel(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.config = fake_model_config
+                self.device = "cpu"
+                self.proj = nn.Conv3d(3, 10, 3)
+                self.visual = nn.ModuleDict(
+                    {
+                        "blocks": nn.ModuleList([Block() for _ in range(2)]),
+                    }
+                )
+                self.model = nn.ModuleDict(
+                    {
+                        "layers": nn.ModuleList([Block() for _ in range(2)]),
+                    }
+                )
+                self.lm_head = nn.Linear(10, 10)
+
+            def prepare_inputs_for_generation(self):
+                return
+
+        model = OldModel()
+        return model
+
+    @pytest.fixture
+    def new_model(self, fake_model_config):
+        # create a small model that mimics the new architecture of, for instance, Qwen/Qwen2-VL-2B-Instruct
+        # Qwen2VLForConditionalGeneration(
+        #   (model): Qwen2VLModel(
+        #     (visual): Qwen2VisionTransformerPretrainedModel(
+        #       (patch_embed): PatchEmbed(
+        #         (proj): Conv3d(3, 1280, kernel_size=(2, 14, 14), stride=(2, 14, 14), bias=False)
+        #       )
+        #       (rotary_pos_emb): VisionRotaryEmbedding()
+        #       (blocks): ModuleList(
+        #         (0-31): 32 x Qwen2VLVisionBlock(
+        #           (norm1): LayerNorm((1280,), eps=1e-06, elementwise_affine=True)
+        #           (norm2): LayerNorm((1280,), eps=1e-06, elementwise_affine=True)
+        #           (attn): VisionSdpaAttention(
+        #             (qkv): Linear(in_features=1280, out_features=3840, bias=True)
+        #             (proj): Linear(in_features=1280, out_features=1280, bias=True)
+        #           )
+        #           (mlp): VisionMlp(
+        #             (fc1): Linear(in_features=1280, out_features=5120, bias=True)
+        #             (act): QuickGELUActivation()
+        #             (fc2): Linear(in_features=5120, out_features=1280, bias=True)
+        #           )
+        #         )
+        #       )
+        #       (merger): PatchMerger(
+        #         (ln_q): LayerNorm((1280,), eps=1e-06, elementwise_affine=True)
+        #         (mlp): Sequential(
+        #           (0): Linear(in_features=5120, out_features=5120, bias=True)
+        #           (1): GELU(approximate='none')
+        #           (2): Linear(in_features=5120, out_features=1536, bias=True)
+        #         )
+        #       )
+        #     )
+        #     (language_model): Qwen2VLTextModel(
+        #       (embed_tokens): Embedding(151936, 1536)
+        #       (layers): ModuleList(
+        #         (0-27): 28 x Qwen2VLDecoderLayer(
+        #           (self_attn): Qwen2VLAttention(
+        #             (q_proj): Linear(in_features=1536, out_features=1536, bias=True)
+        #             (k_proj): Linear(in_features=1536, out_features=256, bias=True)
+        #             (v_proj): Linear(in_features=1536, out_features=256, bias=True)
+        #             (o_proj): Linear(in_features=1536, out_features=1536, bias=False)
+        #             (rotary_emb): Qwen2VLRotaryEmbedding()
+        #           )
+        #           (mlp): Qwen2MLP(
+        #             (gate_proj): Linear(in_features=1536, out_features=8960, bias=False)
+        #             (up_proj): Linear(in_features=1536, out_features=8960, bias=False)
+        #             (down_proj): Linear(in_features=8960, out_features=1536, bias=False)
+        #             (act_fn): SiLU()
+        #           )
+        #           (input_layernorm): Qwen2RMSNorm((1536,), eps=1e-06)
+        #           (post_attention_layernorm): Qwen2RMSNorm((1536,), eps=1e-06)
+        #         )
+        #       )
+        #       (norm): Qwen2RMSNorm((1536,), eps=1e-06)
+        #       (rotary_emb): Qwen2VLRotaryEmbedding()
+        #     )
+        #   )
+        #   (lm_head): Linear(in_features=1536, out_features=151936, bias=False)
+        # )
+        class Block(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.attn = nn.Linear(10, 10)
+
+        class InnerModel(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.visual = nn.ModuleDict(
+                    {
+                        "blocks": nn.ModuleList([Block() for _ in range(2)]),
+                    }
+                )
+                self.language_model = nn.ModuleDict(
+                    {
+                        "layers": nn.ModuleList([Block() for _ in range(2)]),
+                    }
+                )
+
+        class NewModel(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.config = fake_model_config
+                self.device = "cpu"
+                self.model = InnerModel()
+                self.lm_head = nn.Linear(10, 10)
+                # new transformers models have this attribute to map old checkpoints to new ones:
+                self._checkpoint_conversion_mapping = {
+                    "^visual": "model.visual",
+                    "^model(?!\\.(language_model|visual))": "model.language_model",
+                }
+
+            def prepare_inputs_for_generation(self):
+                return
+
+        model = NewModel()
+        return model
+
+    def check_lora_load_no_warning(self, model1, model2, path):
+        # helper method: save with model1, load with model2, ensure that there is no warning about missing keys and that
+        # the parameters are loaded correctly
+        model1 = copy.deepcopy(model1)
+        model2 = copy.deepcopy(model2)
+        config = LoraConfig(target_modules=["attn"])
+        peft_model = get_peft_model(copy.deepcopy(model1), config)
+
+        # set all values to 1.0 or 2.0 so we can check that they are loaded correctly
+        for name, param in peft_model.named_parameters():
+            if name.endswith("lora_A.default.weight"):
+                param.data.fill_(1.0)
+            elif name.endswith("lora_B.default.weight"):
+                param.data.fill_(2.0)
+
+        peft_model.save_pretrained(path)
+        del peft_model
+
+        # ensure that there is no warning: UserWarning: Found missing adapter keys while loading the checkpoint
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            loaded = PeftModel.from_pretrained(copy.deepcopy(model2), path)
+            assert not any("Found missing adapter keys" in str(warning.message) for warning in w)
+
+        # sanity check on parameter values to not only rely on the absence of warnings
+        for name, param in loaded.named_parameters():
+            if name.endswith("lora_A.default.weight"):
+                assert torch.allclose(param, torch.full_like(param, 1.0))
+            elif name.endswith("lora_B.default.weight"):
+                assert torch.allclose(param, torch.full_like(param, 2.0))
+
+    def check_prefix_tuning_load_no_warning(self, model1, model2, path):
+        # helper method: save with model1, load with model2, ensure that there is no warning about missing keys and that
+        # the parameters are loaded correctly.
+        model1 = copy.deepcopy(model1)
+        model2 = copy.deepcopy(model2)
+        config = PrefixTuningConfig(
+            task_type="CAUSAL_LM", num_virtual_tokens=5, num_layers=2, token_dim=10, num_attention_heads=2
+        )
+        peft_model = get_peft_model(copy.deepcopy(model1), config)
+
+        # set all values to 1.0 so we can check that they are loaded correctly
+        peft_model.prompt_encoder.default.embedding.weight.data.fill_(1.0)
+
+        peft_model.save_pretrained(path)
+        del peft_model
+
+        # ensure that there is no warning: UserWarning: Found missing adapter keys while loading the checkpoint
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            loaded = PeftModel.from_pretrained(copy.deepcopy(model2), path)
+            assert not any("Found missing adapter keys" in str(warning.message) for warning in w)
+
+        # sanity check on parameter values to not only rely on the absence of warnings
+        weight = loaded.prompt_encoder.default.embedding.weight
+        assert torch.allclose(weight, torch.full_like(weight, 1.0))
+
+    def check_vblora_load_no_warning(self, model1, model2, path):
+        # helper method: save with model1, load with model2, ensure that there is no warning about missing keys and that
+        # the parameters are loaded correctly
+        model1 = copy.deepcopy(model1)
+        model2 = copy.deepcopy(model2)
+
+        config = VBLoRAConfig(target_modules=["attn"], vector_length=2, num_vectors=4)
+        peft_model = get_peft_model(copy.deepcopy(model1), config)
+
+        # set all values to 1.0 or 2.0 so we can check that they are loaded correctly
+        peft_model.base_model.vblora_vector_bank["default"].data.fill_(1.0)
+        for name, param in peft_model.named_parameters():
+            if "logits" in name:
+                param.data.fill_(2.0)
+
+        peft_model.save_pretrained(path)
+        del peft_model
+
+        # ensure that there is no warning: UserWarning: Found missing adapter keys while loading the checkpoint
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            loaded = PeftModel.from_pretrained(copy.deepcopy(model2), path)
+            assert not any("Found missing adapter keys" in str(warning.message) for warning in w)
+
+        # sanity check on parameter values to not only rely on the absence of warnings
+        param = loaded.base_model.vblora_vector_bank["default"]
+        assert torch.allclose(param, torch.full_like(param, 1.0))
+        for name, param in loaded.named_parameters():
+            if "logits" in name:
+                assert torch.allclose(param, torch.full_like(param, 2.0))
+
+    def test_key_mapping_save_new_load_new_lora(self, new_model, tmp_path):
+        # save and load the new model, should work without issues
+        self.check_lora_load_no_warning(new_model, new_model, tmp_path)
+
+    def test_key_mapping_save_old_load_old_lora(self, old_model, tmp_path):
+        # save and load the old model, should work without issues
+        self.check_lora_load_no_warning(old_model, old_model, tmp_path)
+
+    def test_key_mapping_save_old_load_new_lora(self, old_model, new_model, tmp_path):
+        # save the old model, load it into the new model, should work without issues (backwards compatibility)
+        self.check_lora_load_no_warning(old_model, new_model, tmp_path)
+
+    @pytest.mark.xfail(reason="Loading new checkpoints with old transformers is not supported.", strict=True)
+    def test_key_mapping_save_new_load_old_lora(self, old_model, new_model, tmp_path):
+        # save the new model, load it into the old model, should work without issues (forwards compatibility)
+        self.check_lora_load_no_warning(new_model, old_model, tmp_path)
+
+    def test_key_mapping_save_new_load_new_prefix_tuning(self, new_model, tmp_path):
+        # save and load the new model, should work without issues
+        self.check_prefix_tuning_load_no_warning(new_model, new_model, tmp_path)
+
+    def test_key_mapping_save_old_load_old_prefix_tuning(self, old_model, tmp_path):
+        # save and load the old model, should work without issues
+        self.check_prefix_tuning_load_no_warning(old_model, old_model, tmp_path)
+
+    def test_key_mapping_save_old_load_new_prefix_tuning(self, old_model, new_model, tmp_path):
+        # save the old model, load it into the new model, should work without issues (backwards compatibility)
+        self.check_prefix_tuning_load_no_warning(old_model, new_model, tmp_path)
+
+    def test_key_mapping_save_new_load_old_prefix_tuning(self, old_model, new_model, tmp_path):
+        # save the new model, load it into the old model, should work without issues (forwards compatibility)
+        self.check_prefix_tuning_load_no_warning(new_model, old_model, tmp_path)
+
+    def test_key_mapping_save_new_load_new_vblora(self, new_model, tmp_path):
+        # save and load the new model, should work without issues
+        self.check_vblora_load_no_warning(new_model, new_model, tmp_path)
+
+    def test_key_mapping_save_old_load_old_vblora(self, old_model, tmp_path):
+        # save and load the old model, should work without issues
+        self.check_vblora_load_no_warning(old_model, old_model, tmp_path)
+
+    def test_key_mapping_save_old_load_new_vblora(self, old_model, new_model, tmp_path):
+        # save the old model, load it into the new model, should work without issues (backwards compatibility)
+        self.check_vblora_load_no_warning(old_model, new_model, tmp_path)
+
+    @pytest.mark.xfail(reason="Loading new checkpoints with old transformers is not supported.", strict=True)
+    def test_key_mapping_save_new_load_old_vblora(self, old_model, new_model, tmp_path):
+        # save the new model, load it into the old model, should work without issues (forwards compatibility)
+        self.check_vblora_load_no_warning(new_model, old_model, tmp_path)
+
+
+class TestWeightTying:
+    """Test class to check the weight tying of adapters."""
+
+    torch_device = infer_device()
+
+    def get_lm_model(self, tie_weights=True, config_tie_word_embeddings=None):
+        # Mimicking a LM with embed_tokens and lm_head layers
+        # to test weight tying of adapters
+
+        if config_tie_word_embeddings is None:
+            config_tie_word_embeddings = tie_weights
+
+        class MyModule(nn.Module):
+            def __init__(self):
+                super().__init__()
+
+                self.embed_tokens = nn.Embedding(1000, 1000)
+                self.linear = nn.Linear(1000, 1000, bias=False)
+
+        class ModelConfig:
+            def __init__(self, tie_word_embeddings):
+                self.tie_word_embeddings = tie_word_embeddings
+
+            def to_dict(self):
+                return {"tie_word_embeddings": self.tie_word_embeddings}
+
+        class CausalLM(nn.Module):
+            if tie_weights:
+                _tied_weights_keys = ["lm_head.weight"]
+
+            def __init__(self):
+                super().__init__()
+                self.model = MyModule()
+                self.config = ModelConfig(tie_word_embeddings=config_tie_word_embeddings)
+                self.lm_head = nn.Linear(1000, 1000, bias=False)
+
+                if tie_weights:
+                    self.lm_head.weight = self.model.embed_tokens.weight
+
+            def prepare_inputs_for_generation(self):
+                return
+
+            def get_input_embeddings(self):
+                return self.model.embed_tokens
+
+        return CausalLM().eval().to(self.torch_device)
+
+    def get_seq2seq_lm_model(self, tie_weights=True, config_tie_word_embeddings=None):
+        # Mimicking a encoder-decoder LM with shared embeddings
+
+        if config_tie_word_embeddings is None:
+            config_tie_word_embeddings = tie_weights
+
+        class Seq2SeqStack(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.embed_tokens = nn.Embedding(1000, 1000)
+                self.linear = nn.Linear(1000, 1000, bias=False)
+
+        class MySeq2SeqModule(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.shared = nn.Embedding(1000, 1000)
+                self.encoder = Seq2SeqStack()
+                self.decoder = Seq2SeqStack()
+
+        class ModelConfig:
+            def __init__(self, tie_word_embeddings):
+                self.tie_word_embeddings = tie_word_embeddings
+
+            def to_dict(self):
+                return {"tie_word_embeddings": self.tie_word_embeddings}
+
+        class Seq2SeqLM(nn.Module):
+            if tie_weights:
+                _tied_weights_keys = {
+                    "model.encoder.embed_tokens.weight": "model.shared.weight",
+                    "model.decoder.embed_tokens.weight": "model.shared.weight",
+                    "lm_head.weight": "model.shared.weight",
+                }
+
+            def __init__(self):
+                super().__init__()
+                self.model = MySeq2SeqModule()
+                self.config = ModelConfig(tie_word_embeddings=config_tie_word_embeddings)
+                self.lm_head = nn.Linear(1000, 1000, bias=False)
+
+                if tie_weights:
+                    self.model.encoder.embed_tokens.weight = self.model.shared.weight
+                    self.model.decoder.embed_tokens.weight = self.model.shared.weight
+                    self.lm_head.weight = self.model.shared.weight
+
+            def prepare_inputs_for_generation(self):
+                return
+
+            def get_input_embeddings(self):
+                return self.model.shared
+
+        return Seq2SeqLM().eval().to(self.torch_device)
+
+    @pytest.mark.parametrize("modules_to_save", [["lm_head"], ["embed_tokens"], ["lm_head", "embed_tokens"]])
+    def test_weight_tying_tied_model_lora(self, modules_to_save):
+        # If weight tying is enabled and `embed_tokens`
+        # is passed as a `modules_to_save`, it needs to be ensured
+        # that lm_head is tied to the adapter added to `embed_tokens`
+
+        model = self.get_lm_model()
+
+        embed_token_config = LoraConfig(
+            modules_to_save=modules_to_save,
+            target_modules=["linear"],
+            ensure_weight_tying=True,
+        )
+
+        model = get_peft_model(model, embed_token_config)
+
+        assert isinstance(model.base_model.model.model.embed_tokens, ModulesToSaveWrapper)
+        assert isinstance(model.base_model.model.lm_head, ModulesToSaveWrapper)
+
+        # Validating that all model parameters are same
+        embed_np = dict(model.base_model.model.model.embed_tokens.named_parameters())
+        lm_head_np = dict(model.base_model.model.lm_head.named_parameters())
+
+        for k in embed_np:
+            assert torch.allclose(embed_np[k], lm_head_np[k])
+            assert embed_np[k].data_ptr() == lm_head_np[k].data_ptr()
+
+    @pytest.mark.parametrize(
+        "modules_to_save,tie_weights",
+        [
+            (["lm_head"], True),
+            (["lm_head"], False),
+            (["embed_tokens"], True),
+            (["embed_tokens"], False),
+            (["embed_tokens", "lm_head"], True),
+            (["embed_tokens", "lm_head"], False),
+        ],
+    )
+    def test_alt_weight_tying_tied_model_lora(self, modules_to_save, tie_weights):
+        model = self.get_lm_model(tie_weights=tie_weights)
+        embed_token_config = LoraConfig(
+            modules_to_save=modules_to_save,
+            target_modules=["linear"],
+            ensure_weight_tying=not tie_weights,
+        )
+
+        if tie_weights:
+            wrn_msg = "`ensure_weight_tying` is not set to True"
+        else:
+            wrn_msg = "no tied modules were found in the model"
+
+        with pytest.warns(UserWarning, match=wrn_msg):
+            model = get_peft_model(model, embed_token_config)
+
+        if modules_to_save == ["embed_tokens"]:
+            assert isinstance(model.base_model.model.model.embed_tokens, ModulesToSaveWrapper)
+            assert isinstance(model.base_model.model.lm_head, torch.nn.modules.linear.Linear)
+        elif modules_to_save == ["lm_head"]:
+            assert isinstance(model.base_model.model.model.embed_tokens, torch.nn.modules.Embedding)
+            assert isinstance(model.base_model.model.lm_head, ModulesToSaveWrapper)
+        elif modules_to_save == ["embed_tokens", "lm_head"]:
+            assert isinstance(model.base_model.model.model.embed_tokens, ModulesToSaveWrapper)
+            assert isinstance(model.base_model.model.lm_head, ModulesToSaveWrapper)
+        else:
+            raise NotImplementedError("Layer type {layer} is not supported for this test")
+
+    def test_weight_tying_tied_model_no_embed_lora(self):
+        model = self.get_lm_model()
+        embed_token_config = LoraConfig(
+            target_modules=["linear"],
+            ensure_weight_tying=True,
+        )
+
+        with pytest.warns(UserWarning, match="no tied modules are added"):
+            model = get_peft_model(model, embed_token_config)
+
+        assert isinstance(model.base_model.model.model.embed_tokens, torch.nn.modules.Embedding)
+        assert isinstance(model.base_model.model.lm_head, torch.nn.modules.linear.Linear)
+
+        # Validating that all model parameters are same
+        embed_np = dict(model.base_model.model.model.embed_tokens.named_parameters())
+        lm_head_np = dict(model.base_model.model.lm_head.named_parameters())
+
+        for k in embed_np:
+            assert torch.allclose(embed_np[k], lm_head_np[k])
+            assert embed_np[k] is lm_head_np[k]
+
+    def test_weight_tying_tied_model_lokr(self):
+        model = self.get_lm_model()
+
+        embed_token_config = LoKrConfig(modules_to_save=["embed_tokens"], target_modules=["linear"])
+
+        with pytest.warns(UserWarning, match="no implementation exists to tie the adapters"):
+            model = get_peft_model(model, embed_token_config)
+
+        assert isinstance(model.base_model.model.model.embed_tokens, ModulesToSaveWrapper), (
+            "Embed tokens is not added in Modules to Save"
+        )
+        assert isinstance(model.base_model.model.lm_head, torch.nn.modules.linear.Linear)
+
+    @pytest.mark.parametrize("target_modules", [["lm_head"], ["embed_tokens"], ["lm_head", "embed_tokens"]])
+    def test_weight_tying_tied_model_target_modules_lora(self, target_modules):
+        # Same as `test_weight_tying_tied_model_lora` but the tied module is passed
+        # in `target_modules` instead of `modules_to_save`.
+        model = self.get_lm_model()
+
+        embed_token_config = LoraConfig(
+            target_modules=["linear"] + target_modules,
+            ensure_weight_tying=True,
+        )
+
+        model = get_peft_model(model, embed_token_config)
+
+        assert isinstance(model.base_model.model.model.embed_tokens, LoraLayer)
+        assert isinstance(model.base_model.model.lm_head, LoraLayer)
+
+        # Since embed_tokens and lm_head weights are transpose of each other
+        # lm_head lora_A == embed_tokens lora_B
+        adapter_name = "default"
+
+        embed_lora_A = model.base_model.model.model.embed_tokens.lora_embedding_A[adapter_name]
+        embed_lora_B = model.base_model.model.model.embed_tokens.lora_embedding_B[adapter_name]
+
+        lm_lora_A = model.base_model.model.lm_head.lora_A[adapter_name].weight
+        lm_lora_B = model.base_model.model.lm_head.lora_B[adapter_name].weight
+
+        assert torch.allclose(embed_lora_A, lm_lora_B.T)
+        assert torch.allclose(embed_lora_B, lm_lora_A.T)
+        assert embed_lora_A.data_ptr() == lm_lora_B.data_ptr()
+        assert embed_lora_B.data_ptr() == lm_lora_A.data_ptr()
+
+    @pytest.mark.parametrize("target_modules", [".*embed_tokens$", ".*lm_head$", ".*(embed_tokens|lm_head)$"])
+    def test_weight_tying_tied_model_target_modules_str_lora(self, target_modules):
+        # Same as `test_weight_tying_tied_model_target_modules_lora` but the tied module
+        # are passed as str
+        model = self.get_lm_model()
+
+        embed_token_config = LoraConfig(
+            target_modules=target_modules,
+            ensure_weight_tying=True,
+        )
+
+        model = get_peft_model(model, embed_token_config)
+
+        assert isinstance(model.base_model.model.model.embed_tokens, LoraLayer)
+        assert isinstance(model.base_model.model.lm_head, LoraLayer)
+
+        # Since embed_tokens and lm_head weights are transpose of each other
+        # lm_head lora_A == embed_tokens lora_B
+        adapter_name = "default"
+
+        embed_lora_A = model.base_model.model.model.embed_tokens.lora_embedding_A[adapter_name]
+        embed_lora_B = model.base_model.model.model.embed_tokens.lora_embedding_B[adapter_name]
+
+        lm_lora_A = model.base_model.model.lm_head.lora_A[adapter_name].weight
+        lm_lora_B = model.base_model.model.lm_head.lora_B[adapter_name].weight
+
+        assert torch.allclose(embed_lora_A, lm_lora_B.T)
+        assert torch.allclose(embed_lora_B, lm_lora_A.T)
+        assert embed_lora_A.data_ptr() == lm_lora_B.data_ptr()
+        assert embed_lora_B.data_ptr() == lm_lora_A.data_ptr()
+
+    @pytest.mark.parametrize("target_modules", ["all-linear"])
+    def test_weight_tying_tied_model_target_modules_all_linear_lora(self, target_modules):
+        # Passing just the all-linear as target_modules
+        model = self.get_lm_model()
+
+        embed_token_config = LoraConfig(
+            target_modules=target_modules,
+            ensure_weight_tying=True,
+        )
+
+        model = get_peft_model(model, embed_token_config)
+
+        assert isinstance(model.base_model.model.model.linear, LoraLayer)
+        assert isinstance(model.base_model.model.model.embed_tokens, torch.nn.modules.Embedding)
+
+    @pytest.mark.parametrize(
+        "target_modules,tie_weights",
+        [
+            (["lm_head"], True),
+            (["lm_head"], False),
+            (["embed_tokens"], True),
+            (["embed_tokens"], False),
+            (["embed_tokens", "lm_head"], True),
+            (["embed_tokens", "lm_head"], False),
+        ],
+    )
+    def test_alt_weight_tying_tied_model_target_modules_lora(self, target_modules, tie_weights):
+        # When model weights are not tied, ensure a warning is raised even if
+        # the tied module name is present in `target_modules`.
+        model = self.get_lm_model(tie_weights=tie_weights)
+        embed_token_config = LoraConfig(
+            target_modules=["linear"] + target_modules,
+            ensure_weight_tying=not tie_weights,
+        )
+
+        if tie_weights:
+            wrn_msg = "`ensure_weight_tying` is not set to True"
+        else:
+            wrn_msg = "no tied modules were found in the model"
+
+        with pytest.warns(UserWarning, match=wrn_msg):
+            model = get_peft_model(model, embed_token_config)
+
+        if target_modules == ["embed_tokens"]:
+            assert isinstance(model.base_model.model.model.embed_tokens, LoraLayer)
+            assert isinstance(model.base_model.model.lm_head, torch.nn.modules.linear.Linear)
+        elif target_modules == ["lm_head"]:
+            assert isinstance(model.base_model.model.model.embed_tokens, torch.nn.modules.Embedding)
+            assert isinstance(model.base_model.model.lm_head, LoraLayer)
+        elif target_modules == ["embed_tokens", "lm_head"]:
+            assert isinstance(model.base_model.model.model.embed_tokens, LoraLayer)
+            assert isinstance(model.base_model.model.lm_head, LoraLayer)
+
+            adapter_name = "default"
+
+            embed_lora_A = model.base_model.model.model.embed_tokens.lora_embedding_A[adapter_name]
+            embed_lora_B = model.base_model.model.model.embed_tokens.lora_embedding_B[adapter_name]
+
+            lm_lora_A = model.base_model.model.lm_head.lora_A[adapter_name].weight
+            lm_lora_B = model.base_model.model.lm_head.lora_B[adapter_name].weight
+
+            assert embed_lora_A.data_ptr() != lm_lora_B.data_ptr()
+            assert embed_lora_B.data_ptr() != lm_lora_A.data_ptr()
+        else:
+            raise NotImplementedError("Layer type {layer} is not supported for this test")
+
+    def test_weight_tying_tied_model_target_modules_lokr(self):
+        model = self.get_lm_model()
+
+        embed_token_config = LoKrConfig(target_modules=["linear", "lm_head"])
+
+        with pytest.warns(UserWarning, match="no implementation exists to tie the adapters"):
+            model = get_peft_model(model, embed_token_config)
+
+        assert isinstance(model.base_model.model.model.embed_tokens, torch.nn.modules.Embedding)
+        assert isinstance(model.base_model.model.lm_head, LoKrLayer)
+
+    @pytest.mark.parametrize("modules_to_save", [["lm_head"], ["embed_tokens"], ["lm_head", "embed_tokens"]])
+    def test_weight_tying_enc_dec_modules_to_save_lora(self, modules_to_save):
+        model = self.get_seq2seq_lm_model()
+        embed_token_config = LoraConfig(
+            modules_to_save=modules_to_save,
+            target_modules=["linear"],
+            ensure_weight_tying=True,
+        )
+
+        model = get_peft_model(model, embed_token_config)
+
+        assert isinstance(model.base_model.model.model.shared, ModulesToSaveWrapper)
+        assert isinstance(model.base_model.model.model.encoder.embed_tokens, ModulesToSaveWrapper)
+        assert isinstance(model.base_model.model.model.decoder.embed_tokens, ModulesToSaveWrapper)
+        assert isinstance(model.base_model.model.lm_head, ModulesToSaveWrapper)
+
+        shared_np = dict(model.base_model.model.model.shared.named_parameters())
+        lm_head_np = dict(model.base_model.model.lm_head.named_parameters())
+
+        for k in shared_np:
+            assert torch.allclose(shared_np[k], lm_head_np[k])
+            assert shared_np[k].data_ptr() == lm_head_np[k].data_ptr()
+
+    @pytest.mark.parametrize("target_modules", [["lm_head"], ["embed_tokens"], ["lm_head", "embed_tokens"]])
+    def test_weight_tying_enc_dec_target_modules_lora(self, target_modules):
+        model = self.get_seq2seq_lm_model()
+        embed_token_config = LoraConfig(
+            target_modules=["linear"] + target_modules,
+            ensure_weight_tying=True,
+        )
+
+        model = get_peft_model(model, embed_token_config)
+
+        assert isinstance(model.base_model.model.model.shared, LoraLayer)
+        assert isinstance(model.base_model.model.model.encoder.embed_tokens, LoraLayer)
+        assert isinstance(model.base_model.model.model.decoder.embed_tokens, LoraLayer)
+        assert isinstance(model.base_model.model.lm_head, LoraLayer)
+
+        adapter_name = "default"
+
+        shared_lora_A = model.base_model.model.model.shared.lora_embedding_A[adapter_name]
+        shared_lora_B = model.base_model.model.model.shared.lora_embedding_B[adapter_name]
+
+        lm_lora_A = model.base_model.model.lm_head.lora_A[adapter_name].weight
+        lm_lora_B = model.base_model.model.lm_head.lora_B[adapter_name].weight
+
+        assert torch.allclose(shared_lora_A, lm_lora_B.T)
+        assert torch.allclose(shared_lora_B, lm_lora_A.T)
+        assert shared_lora_A.data_ptr() == lm_lora_B.data_ptr()
+        assert shared_lora_B.data_ptr() == lm_lora_A.data_ptr()
+
+    @pytest.mark.parametrize("target_modules", [["linear"], ["encoder.linear"], ["decoder.linear"]])
+    def test_weight_tying_enc_dec_no_tied_module_targeted_warns(self, target_modules):
+        model = self.get_seq2seq_lm_model()
+        embed_token_config = LoraConfig(
+            target_modules=target_modules,
+            ensure_weight_tying=True,
+        )
+
+        with pytest.warns(UserWarning, match="no tied modules are added"):
+            model = get_peft_model(model, embed_token_config)
+
+        assert isinstance(model.base_model.model.model.shared, torch.nn.modules.sparse.Embedding)
+        assert isinstance(model.base_model.model.model.encoder.embed_tokens, torch.nn.modules.sparse.Embedding)
+        assert isinstance(model.base_model.model.model.decoder.embed_tokens, torch.nn.modules.sparse.Embedding)
+        assert isinstance(model.base_model.model.lm_head, torch.nn.modules.linear.Linear)
+
+    @pytest.mark.parametrize("modules_to_save", [["lm_head"], ["embed_tokens"], ["lm_head", "embed_tokens"]])
+    def test_ensure_weight_tying_not_tying_when_model_config_tie_false(self, modules_to_save):
+        # When tie_word_embeddings=False, ensure_weight_tying=True should not tie weights.
+        # Regression test for issue #2944
+        model = self.get_lm_model(tie_weights=True, config_tie_word_embeddings=False)
+        config = LoraConfig(
+            modules_to_save=modules_to_save,
+            target_modules=["linear"],
+            ensure_weight_tying=True,
+        )
+
+        with pytest.warns(UserWarning, match="no tied modules were found in the model"):
+            model = get_peft_model(model, config)
+
+        if "embed_tokens" in modules_to_save:
+            assert isinstance(model.base_model.model.model.embed_tokens, ModulesToSaveWrapper)
+        else:
+            assert isinstance(model.base_model.model.model.embed_tokens, torch.nn.modules.Embedding)
+
+        if "lm_head" in modules_to_save:
+            assert isinstance(model.base_model.model.lm_head, ModulesToSaveWrapper)
+        else:
+            assert isinstance(model.base_model.model.lm_head, torch.nn.modules.linear.Linear)
+
+        assert (
+            model.base_model.model.model.embed_tokens.weight.data_ptr()
+            != model.base_model.model.lm_head.weight.data_ptr()
+        )
+
+    @pytest.mark.parametrize("target_modules", [["lm_head"], ["embed_tokens"], ["lm_head", "embed_tokens"]])
+    def test_ensure_weight_tying_not_tying_when_model_config_tie_false_target_modules(self, target_modules):
+        # When tie_word_embeddings=False, ensure_weight_tying=True should not tie weights.
+        # Regression test for issue #2944
+        model = self.get_lm_model(tie_weights=True, config_tie_word_embeddings=False)
+        config = LoraConfig(
+            target_modules=["linear"] + target_modules,
+            ensure_weight_tying=True,
+        )
+
+        with pytest.warns(UserWarning, match="no tied modules were found in the model"):
+            model = get_peft_model(model, config)
+
+        if "embed_tokens" in target_modules:
+            assert isinstance(model.base_model.model.model.embed_tokens, LoraLayer)
+        else:
+            assert isinstance(model.base_model.model.model.embed_tokens, torch.nn.modules.Embedding)
+
+        if "lm_head" in target_modules:
+            assert isinstance(model.base_model.model.lm_head, LoraLayer)
+        else:
+            assert isinstance(model.base_model.model.lm_head, torch.nn.modules.linear.Linear)
+
+        if set(target_modules) == {"embed_tokens", "lm_head"}:
+            adapter_name = "default"
+            embed_lora_A = model.base_model.model.model.embed_tokens.lora_embedding_A[adapter_name]
+            embed_lora_B = model.base_model.model.model.embed_tokens.lora_embedding_B[adapter_name]
+            lm_lora_A = model.base_model.model.lm_head.lora_A[adapter_name].weight
+            lm_lora_B = model.base_model.model.lm_head.lora_B[adapter_name].weight
+            assert embed_lora_A.data_ptr() != lm_lora_B.data_ptr()
+            assert embed_lora_B.data_ptr() != lm_lora_A.data_ptr()
diff --git a/tests/test_integrations.py b/tests/test_integrations.py
new file mode 100644
index 0000000..c8227bd
--- /dev/null
+++ b/tests/test_integrations.py
@@ -0,0 +1,492 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+import functools
+import inspect
+import re
+
+import packaging.version
+import pytest
+import torch
+import transformers
+from torch import nn
+from transformers import AutoModelForCausalLM, AutoModelForImageTextToText
+
+from peft import LoraConfig, PeftModel, get_peft_model
+from peft.tuners import lora
+from peft.utils import infer_device
+from peft.utils.integrations import init_empty_weights, skip_init_on_device
+
+from .testing_utils import hub_online_once
+
+
+class MLP(nn.Module):
+    def __init__(self, bias=True):
+        super().__init__()
+        self.lin0 = nn.Linear(10, 20, bias=bias)
+        self.relu = nn.ReLU()
+        self.drop = nn.Dropout(0.5)
+        self.lin1 = nn.Linear(20, 2, bias=bias)
+
+
+def get_mlp():
+    return MLP()
+
+
+class TestInitEmptyWeights:
+    def test_init_empty_weights_works(self):
+        # this is a very rudimentary test, as init_empty_weights is copied almost 1:1 from accelerate and is tested
+        # there
+        with init_empty_weights():
+            mlp = get_mlp()
+
+        expected = torch.device("meta")
+        assert all(p.device == expected for p in mlp.parameters())
+
+    def test_skip_init_on_device_works(self):
+        # when a function is decorated with skip_init_on_device, the parameters are not moved to meta device, even when
+        # inside the context
+        decorated_fn = skip_init_on_device(get_mlp)
+        with init_empty_weights():
+            mlp = decorated_fn()
+
+        expected = torch.device("cpu")
+        assert all(p.device == expected for p in mlp.parameters())
+
+    def test_skip_init_on_device_works_outside_context(self):
+        # same as before, but ensure that skip_init_on_device does not break when no init_empty_weights context is used
+        decorated_fn = skip_init_on_device(get_mlp)
+        mlp = decorated_fn()
+        expected = torch.device("cpu")
+        assert all(p.device == expected for p in mlp.parameters())
+
+    def test_skip_init_on_device_not_permanent(self):
+        # ensure that after skip_init_on_device has been used, init_empty_weights reverts to its original functionality
+
+        # with decorator => cpu
+        decorated_fn = skip_init_on_device(get_mlp)
+        with init_empty_weights():
+            mlp = decorated_fn()
+
+        expected = torch.device("cpu")
+        assert all(p.device == expected for p in mlp.parameters())
+
+        # without decorator => meta
+        with init_empty_weights():
+            mlp = get_mlp()
+
+        expected = torch.device("meta")
+        assert all(p.device == expected for p in mlp.parameters())
+
+    def test_skip_init_on_device_nested(self):
+        # ensure that skip_init_on_device works even if the decorated function is nested inside another decorated
+        # function
+        @skip_init_on_device
+        def outer_fn():
+            @skip_init_on_device
+            def inner_fn():
+                return get_mlp()
+
+            mlp0 = inner_fn()
+            mlp1 = get_mlp()
+            return mlp0, mlp1
+
+        with init_empty_weights():
+            mlp0, mlp1 = outer_fn()
+
+        expected = torch.device("cpu")
+        assert all(p.device == expected for p in mlp0.parameters())
+        assert all(p.device == expected for p in mlp1.parameters())
+
+
+# TODO Remove this once patch_moe_parameter_targeting is removed from Transformers
+@pytest.fixture(params=[False, True], ids=["without_transformers_moe_patch", "with_transformers_moe_patch"])
+def _transformers_moe_patch(request):
+    """Parametrize tests over the MoE parameter-targeting patch being active/inactive.
+
+    The transformers patch `patch_moe_parameter_targeting` could hide a bug in PEFT when it comes to detecting the
+    correct in_features/out_features of a 3-dim MoE parameter. The patch is applied by transformers when their
+    `load_adapter` method is being called. Therefore, the order in which the tests were executed could hide or surface
+    the bug.
+
+    With this fixture, we ensure that each test is run twice, once without and once with the patch. This should mirror
+    real world usage, where the patch may or may not be active. At fixture exit, the patch is always removed.
+
+    For details, see discussion in #3165
+
+    """
+    try:
+        from transformers.integrations.peft import patch_moe_parameter_targeting
+    except (ImportError, AttributeError):
+        patch_moe_parameter_targeting = None
+
+    should_patch = request.param
+
+    if should_patch and patch_moe_parameter_targeting is None:
+        pytest.skip(
+            "Transformers patch_moe_parameter_targeting no longer exists; skipping the 'patched' test variant."
+        )
+
+    is_patched = hasattr(lora.layer.ParamWrapper.update_layer, "__wrapped__")
+    orig_update_layer = inspect.unwrap(lora.layer.ParamWrapper.update_layer)
+
+    def new_update_layer(layer, *args, **kwargs):
+        # this is copied 1:1 from transformers:
+        # https://github.com/huggingface/transformers/blob/bc7ee236fca35e771b6b393178a192add1469243/src/transformers/integrations/peft.py#L394-L401
+        did_swap = getattr(layer, "_did_swap_in_out_features", False)
+        if not did_swap and layer.parameter_name in ("down_proj", "gate_up_proj"):
+            tmp_in_features = layer.in_features
+            layer.in_features = layer.out_features
+            layer.out_features = tmp_in_features
+            layer._did_swap_in_out_features = True
+        return orig_update_layer(layer, *args, **kwargs)
+
+    # 4 cases:
+    # should_patch | is_patched
+    #         true |       true
+    #         true |      false
+    #        false |       true
+    #        false |      false
+
+    if not should_patch and not is_patched:
+        yield
+        return
+
+    if not should_patch and is_patched:
+        lora.layer.ParamWrapper.update_layer = orig_update_layer
+        yield
+        return
+
+    if should_patch and is_patched:
+        try:
+            yield
+        finally:
+            lora.layer.ParamWrapper.update_layer = orig_update_layer
+        return
+
+    if should_patch and not is_patched:
+        try:
+            lora.layer.ParamWrapper.update_layer = functools.wraps(lora.layer.ParamWrapper.update_layer)(
+                new_update_layer
+            )
+            yield
+        finally:
+            lora.layer.ParamWrapper.update_layer = orig_update_layer
+        return
+    # this is unreachable
+
+
+@pytest.mark.skipif(
+    packaging.version.parse(transformers.__version__) < packaging.version.parse("5.4.0"),
+    reason="PEFT weight conversion is fixed in transformers 5.4.0",
+)
+@pytest.mark.usefixtures("_transformers_moe_patch")  # TODO remove once patch_moe_parameter_targeting is removed
+class TestTransformersV5:
+    """Unit tests intended to test proper working of PEFT with Transformers v5"""
+
+    torch_device = infer_device()
+
+    @pytest.fixture
+    def expected_logits(self):
+        # original logits were:
+        # tensor([[[ 0.2676,  0.3870,  0.2956,  ...,  0.4624,  0.1966,  0.2539],
+        #          [-0.6706, -0.0969, -0.6240,  ..., -0.0201,  0.7099, -0.3099],
+        #          [ 0.0663,  0.1653,  0.7189,  ...,  0.5905,  0.0649,  0.5839],
+        #          ...,
+        #          [-0.2712, -0.6451, -0.0219,  ..., -0.4344,  0.5471, -0.9355],
+        #          [-0.3607,  0.4526,  0.2750,  ...,  0.1082,  0.7179,  0.8487],
+        #          [ 0.5826, -0.1407, -0.3131,  ...,  0.1026,  0.6878, -0.3382]]],
+        #        device='cuda:0')
+        expected_logits_0_to_3 = torch.Tensor(
+            [
+                [0.2676, 0.3870, 0.2956],
+                [-0.6706, -0.0969, -0.6240],
+                [0.0663, 0.1653, 0.7189],
+            ]
+        ).to(device=self.torch_device, dtype=torch.float16)
+        return expected_logits_0_to_3
+
+    def test_mixtral_v4_lora_weight_conversion_transformers_load_adapter(self, expected_logits):
+        # Load a PEFT adapter trained with transformers v4 on Mixtral, which now has converted weights (MoE), using the
+        # Transformers integration (model.load_adapter).
+        inputs = torch.arange(10).view(1, -1).to(device=self.torch_device)
+        model_id = "hf-internal-testing/Mixtral-tiny"
+        lora_id = "peft-internal-testing/mixtral-pre-v5-lora"
+
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+
+        # test AutoModel.load_adapter
+        model.load_adapter(lora_id)
+        model.to(self.torch_device)
+        with torch.inference_mode():
+            output = model(inputs).logits
+
+        # a little bit of deviation but that's fine
+        atol, rtol = 1e-3, 1e-4
+        assert torch.allclose(output[0, :3, :3], expected_logits, atol=atol, rtol=rtol)
+
+    def test_mixtral_v4_lora_weight_conversion_peft_model_from_pretrained(self, expected_logits):
+        # Load a PEFT adapter trained with transformers v4 on Mixtral, which now has converted weights (MoE), using
+        # PeftModel.from_pretrained
+        inputs = torch.arange(10).view(1, -1).to(device=self.torch_device)
+        model_id = "hf-internal-testing/Mixtral-tiny"
+        lora_id = "peft-internal-testing/mixtral-pre-v5-lora"
+
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id).to(self.torch_device)
+
+        # test PeftModel.from_pretrained
+        model = PeftModel.from_pretrained(model, lora_id)
+        with torch.inference_mode():
+            output = model(inputs).logits
+
+        # a little bit of deviation but that's fine
+        atol, rtol = 1e-3, 1e-4
+        assert torch.allclose(output[0, :3, :3], expected_logits, atol=atol, rtol=rtol)
+
+    def test_mixtral_v4_lora_weight_conversion_peft_model_load_adapter(self, expected_logits):
+        # Same as the previous test, but using PeftModel.load_adapter
+        inputs = torch.arange(10).view(1, -1).to(device=self.torch_device)
+        model_id = "hf-internal-testing/Mixtral-tiny"
+        lora_id = "peft-internal-testing/mixtral-pre-v5-lora"
+
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id).to(self.torch_device)
+
+        # create a PeftModel instance
+        model = get_peft_model(model, LoraConfig(target_modules=["q_proj"]))
+
+        # test PeftModel.load_adapter
+        model.load_adapter(lora_id, adapter_name="other")
+        model.set_adapter("other")
+        with torch.inference_mode():
+            output = model(inputs).logits
+        atol, rtol = 1e-3, 1e-4
+        assert torch.allclose(output[0, :3, :3], expected_logits, atol=atol, rtol=rtol)
+
+    def test_mixtral_save_load_roundtrip(self, expected_logits, tmp_path):
+        # Load the v4 checkpoint with PEFT, save it (now v5 format) and load it again
+        inputs = torch.arange(10).view(1, -1).to(device=self.torch_device)
+        model_id = "hf-internal-testing/Mixtral-tiny"
+        lora_id = "peft-internal-testing/mixtral-pre-v5-lora"
+
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id).to(self.torch_device)
+
+        model = PeftModel.from_pretrained(model, lora_id)
+        model.save_pretrained(tmp_path)
+        del model
+
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id).to(self.torch_device)
+        model = PeftModel.from_pretrained(model, tmp_path)
+
+        with torch.inference_mode():
+            output = model(inputs).logits
+
+        # a little bit of deviation but that's fine
+        atol, rtol = 1e-3, 1e-4
+        assert torch.allclose(output[0, :3, :3], expected_logits, atol=atol, rtol=rtol)
+
+    def test_add_lora_to_mixtral_v5_works(self):
+        # Ensure that using LoRA directly with a v5 model still works
+        inputs = torch.arange(10).view(1, -1).to(device=self.torch_device)
+        model_id = "hf-internal-testing/Mixtral-tiny"
+
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id).to(self.torch_device)
+        with torch.inference_mode():
+            output_base = model(inputs).logits
+
+        lora_config = LoraConfig(
+            target_modules=["q_proj", "k_proj", "v_proj"],
+            target_parameters=["gate.weight", "experts.gate_up_proj", "experts.down_proj"],
+        )
+        model = get_peft_model(model, lora_config).eval()  # no error
+
+        with torch.inference_mode():
+            output_lora = model(inputs).logits
+        # sanity check
+        assert torch.allclose(output_base, output_lora)
+
+        num_lora_layers = len([m for m in model.modules() if isinstance(m, lora.LoraLayer)])
+        # sanity check
+        expected_num_lora_layers = 12  # 2 layers with 6 lora layers each
+        assert num_lora_layers == expected_num_lora_layers
+
+    def test_qwen_v4_lora_weight_conversion_peft_model_from_pretrained(self):
+        # Load a PEFT adapter trained with transformers v4 on Qwen3 MoE, which now has converted weights (MoE), using
+        # PeftModel.from_pretrained
+        inputs = torch.arange(10).view(1, -1).to(device=self.torch_device)
+        expected_logits = torch.Tensor(
+            [
+                [0.3644, -0.7487, -0.3190],
+                [0.2413, -0.8686, -0.5683],
+                [0.0333, -0.8790, -0.6361],
+            ],
+        ).to(device=self.torch_device)
+        model_id = "hf-internal-testing/tiny-qwen3-moe"
+        lora_id = "peft-internal-testing/qwen3-moe-pre-v5-lora"
+
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id).to(self.torch_device)
+
+        # test PeftModel.from_pretrained
+        model = PeftModel.from_pretrained(model, lora_id)
+        with torch.inference_mode():
+            output = model(inputs).logits
+
+        # a little bit of deviation but that's fine
+        atol, rtol = 1e-3, 1e-4
+        assert torch.allclose(output[0, :3, :3], expected_logits, atol=atol, rtol=rtol)
+
+    def test_qwen2_5_vl_works(self):
+        # https://github.com/huggingface/trl/issues/5428
+
+        # It can happen that a model returns an entry for get_checkpoint_conversion_mapping but there is nothing further
+        # to do because no weights are being fused (e.g. only renamed). In that case, we have no entry in
+        # _MOE_TARGET_MODULE_MAPPING. The bug was that we would call dict.__getitem__ instead of dict.get.
+        model_id = "trl-internal-testing/tiny-Qwen2_5_VLForConditionalGeneration"
+        with hub_online_once(model_id):
+            model = AutoModelForImageTextToText.from_pretrained(model_id)
+            config = LoraConfig(target_modules=["q_proj", "v_proj"])
+            get_peft_model(model, config)  # does not raise
+
+    @pytest.mark.parametrize(
+        "target_modules", [["up_proj", "down_proj", "score"], r".*\.(up_proj|down_proj)"], ids=["list", "regex"]
+    )
+    def test_qwen3_moe_partial_fusion_raises(self, target_modules):
+        # https://github.com/huggingface/trl/issues/5428
+        # Targeting up_proj but not gate_proj must raise -- they are fused into gate_up_proj. Covers the list and regex
+        # paths and guards the error-message handling. See `test_qwen3_moe_works` for a valid config.
+        model_id = "trl-internal-testing/tiny-Qwen3MoeForCausalLM"
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            msg = re.escape(
+                "Cannot convert PEFT target(s) up_proj without also targeting gate_proj because they are fused into "
+                "gate_up_proj."
+            )
+            with pytest.raises(ValueError, match=msg):
+                get_peft_model(model, LoraConfig(target_modules=target_modules))
+
+    def test_qwen3_moe_works(self):
+        # https://github.com/huggingface/trl/issues/5428
+        # When correctly targeting both up and gate projection, there should be no error (see previous test)
+        model_id = "trl-internal-testing/tiny-Qwen3MoeForCausalLM"
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            # target up_proj and gate_proj
+            config = LoraConfig(target_modules=["gate_proj", "up_proj", "down_proj", "score"])
+            get_peft_model(model, config)  # does not raise
+
+    @pytest.mark.parametrize(
+        "regex",
+        [
+            # the shape ms-swift's get_multimodal_target_regex emits: anchored, prefix lookahead
+            r"^(model(?=\.).*\.(q_proj|k_proj|v_proj|gate_proj|up_proj|down_proj))$",
+            # a plain "ends with one of these projections" pattern
+            r".*\.(q_proj|k_proj|v_proj|gate_proj|up_proj|down_proj)",
+        ],
+    )
+    def test_qwen3_moe_regex_target_modules_works(self, regex):
+        # Regression test for https://github.com/huggingface/peft/issues/3229: the conversion used to `set()` the regex
+        # string, splitting it into characters. It is now resolved to concrete names against the model.
+        model_id = "trl-internal-testing/tiny-Qwen3MoeForCausalLM"
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            peft_model = get_peft_model(model, LoraConfig(target_modules=regex))  # does not raise
+
+        config = peft_model.peft_config["default"]
+        # non-fused targets stay in target_modules; fused experts move to target_parameters (rank/alpha doubled for the
+        # 2-way gate_up_proj). The regex does not name the router, so `gate.weight` is *not* pulled in (contrast
+        # `test_qwen3_moe_all_linear_target_modules_works`, where "all-linear" does pull it in).
+        assert config.target_modules == {"q_proj", "k_proj", "v_proj"}
+        assert set(config.target_parameters) == {"gate_up_proj", "down_proj"}
+        assert config.rank_pattern == {r".*\.gate_up_proj": config.r * 2}
+        assert config.alpha_pattern == {r".*\.gate_up_proj": config.lora_alpha * 2}
+        # the experts are actually adapted, not just recorded in the config
+        assert any("experts" in name for name, _ in peft_model.named_modules() if name.endswith("lora_A.default"))
+
+    def test_qwen3_moe_single_attention_regex_target_modules_works(self):
+        # A regex resolving to a single attention projection (no experts) converts cleanly: nothing moves to parameters.
+        model_id = "trl-internal-testing/tiny-Qwen3MoeForCausalLM"
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            peft_model = get_peft_model(model, LoraConfig(target_modules=r".*\.q_proj"))  # does not raise
+
+        config = peft_model.peft_config["default"]
+        assert config.target_modules == {"q_proj"}
+        assert not config.target_parameters
+        assert not config.rank_pattern
+        adapted = {
+            name.rsplit(".lora_A", 1)[0].rsplit(".", 1)[-1]
+            for name, _ in peft_model.named_modules()
+            if name.endswith("lora_A.default")
+        }
+        assert adapted == {"q_proj"}
+
+    def test_qwen3_moe_all_linear_target_modules_works(self):
+        # "all-linear" is matched by module type, not as a regex. On v4 the experts *and* the router `gate` were
+        # nn.Linear, so "all-linear" targeted them; after fusion the experts are stacked parameters and the router is a
+        # custom module, so "all-linear" must still carry all of them into target_parameters (gate -> gate.weight).
+        model_id = "trl-internal-testing/tiny-Qwen3MoeForCausalLM"
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            peft_model = get_peft_model(model, LoraConfig(target_modules="all-linear"))  # does not raise
+
+        config = peft_model.peft_config["default"]
+        adapted = {
+            name.rsplit(".lora_A", 1)[0].rsplit(".", 1)[-1]
+            for name, _ in peft_model.named_modules()
+            if name.endswith("lora_A.default")
+        }
+        # attention projections resolved as modules; experts and router (linear in v4) carried into target_parameters
+        assert {"q_proj", "k_proj", "v_proj", "o_proj"} <= adapted
+        # the router `gate` is adapted too -- it is a parameter (`gate.weight`) on v5, so unlike the regex case it has
+        # to be added by name; this is exactly what distinguishes "all-linear" from a regex that omits the router
+        assert set(config.target_parameters) == {"gate.weight", "gate_up_proj", "down_proj"}
+        assert config.rank_pattern == {r".*\.gate_up_proj": config.r * 2}
+        assert config.alpha_pattern == {r".*\.gate_up_proj": config.lora_alpha * 2}
+        # the experts and the router gate are actually adapted, not just recorded in the config
+        assert any("experts" in name for name, _ in peft_model.named_modules() if name.endswith("lora_A.default"))
+        assert any(name.endswith(".mlp.gate.lora_A.default") for name, _ in peft_model.named_modules())
+
+    def test_qwen3_moe_regex_target_modules_save_load_roundtrip(self, tmp_path):
+        # Save/reload a regex-targeted adapter. Reload re-runs the conversion on the already-converted config, so this
+        # also guards idempotency.
+        inputs = torch.arange(10).view(1, -1).to(self.torch_device)
+        model_id = "trl-internal-testing/tiny-Qwen3MoeForCausalLM"
+        regex = r"^(model(?=\.).*\.(q_proj|k_proj|v_proj|gate_proj|up_proj|down_proj))$"
+
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id).to(self.torch_device)
+            # init_lora_weights=False gives the adapter non-zero (random) weights so it actually changes the output
+            peft_model = get_peft_model(model, LoraConfig(target_modules=regex, init_lora_weights=False))
+            with torch.inference_mode():
+                logits_before = peft_model(inputs).logits
+            peft_model.save_pretrained(tmp_path)
+            del model, peft_model
+
+            model = AutoModelForCausalLM.from_pretrained(model_id).to(self.torch_device)
+            reloaded = PeftModel.from_pretrained(model, tmp_path)
+            with torch.inference_mode():
+                logits_after = reloaded(inputs).logits
+
+        assert torch.allclose(logits_before, logits_after, atol=1e-5, rtol=1e-5)
+        # reload re-runs the conversion on the already-resolved config -- idempotent
+        reloaded_config = reloaded.peft_config["default"]
+        assert reloaded_config.target_modules == {"q_proj", "k_proj", "v_proj"}
+        assert {"gate_up_proj", "down_proj"} <= set(reloaded_config.target_parameters)
+        assert reloaded_config.rank_pattern == {r".*\.gate_up_proj": reloaded_config.r * 2}
diff --git a/tests/test_lora_conversion.py b/tests/test_lora_conversion.py
new file mode 100644
index 0000000..3bd6d26
--- /dev/null
+++ b/tests/test_lora_conversion.py
@@ -0,0 +1,693 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+import copy
+import platform
+import re
+
+import pytest
+import torch
+from torch import nn
+from transformers import AutoModelForCausalLM
+
+from peft import (
+    C3AConfig,
+    IA3Config,
+    LoKrConfig,
+    LoraConfig,
+    MissConfig,
+    PeftModel,
+    PrefixTuningConfig,
+    convert_to_lora,
+    get_peft_model,
+    get_peft_model_state_dict,
+    save_as_lora,
+    set_peft_model_state_dict,
+)
+from peft.utils import infer_device
+
+from .testing_utils import hub_online_once
+
+
+class TestLoraConversion:
+    """Test functionality to convert non-LoRA adapters to LoRA adapters
+
+    This is mainly testing with LoKr, as it would be wasteful to test with all compatible PEFT methods in detail. For a
+    broad suite of tests across PEFT methods, check test_decoder_models.py::test_lora_conversion.
+
+    We mainly use convert_to_lora and not save_as_lora here, as is just a thin wrapper around convert_to_lora and
+    involves disk IO, which we want to avoid as much as possible. For most users, save_as_lora will most likely be the
+    main entry point,
+
+    For comparing outputs, it's not ideal to check the logits, as most of them are close to zero and we cannot use
+    torch.allclose, as a certain deviation is expected from conversion. A robust way would be to check the hidden
+    states after subtracting the base model's hidden states (since the contribution of the adapter is what we want to
+    compare).
+    """
+
+    model_id = "peft-internal-testing/tiny-random-OPTForCausalLM"
+    torch_device = infer_device()
+    base_model = None
+
+    def get_base_model(self):
+        if self.base_model is None:
+            with hub_online_once(self.model_id):
+                self.base_model = AutoModelForCausalLM.from_pretrained(self.model_id).to(self.torch_device)
+        return copy.deepcopy(self.base_model)
+
+    @pytest.fixture
+    def lokr_model(self):
+        torch.manual_seed(0)
+        return get_peft_model(self.get_base_model(), LoKrConfig(init_weights=False))
+
+    @staticmethod
+    def get_mse(output1, output2):
+        return nn.functional.mse_loss(output1.hidden_states[-1], output2.hidden_states[-1]).item()
+
+    def test_no_peft_layer_raises(self):
+        # Model without any PEFT layer should raise
+        base_model = self.get_base_model()
+        msg = "Could not detect any layer that supports LoRA conversion"
+        with pytest.raises(TypeError, match=msg):
+            convert_to_lora(base_model, rank=8)
+
+    def test_prompt_learning_model_raises(self):
+        # Prefix Tuning does not support LoRA conversion
+        base_model = self.get_base_model()
+        config = PrefixTuningConfig(num_virtual_tokens=10, task_type="CAUSAL_LM")
+        prefix_model = get_peft_model(base_model, config).eval()
+        assert not prefix_model.supports_lora_conversion()
+
+        msg = "Could not detect any layer that supports LoRA conversion"
+        with pytest.raises(TypeError, match=msg):
+            convert_to_lora(prefix_model, rank=8)
+
+    def test_peft_model_but_no_support_raises(self):
+        # IA3 has BaseTunerLayers but does not support LoRA conversion
+        base_model = self.get_base_model()
+        ia3_model = get_peft_model(base_model, IA3Config()).eval()
+        assert not ia3_model.supports_lora_conversion()
+
+        msg = "Some module types on this model do not support LoRA conversion"
+        with pytest.raises(TypeError, match=msg):
+            convert_to_lora(ia3_model, rank=8)
+
+    def test_model_with_unsupported_layers_raises(self):
+        # conv layers do not support LoRA conversion (yet)
+        # note: change this test if we add support for conv layer conversion
+        class MyModule(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.conv = nn.Conv2d(16, 16, 3)
+                self.lin = nn.Linear(16, 16)
+
+        lokr_model = get_peft_model(MyModule(), LoKrConfig(target_modules=["conv", "lin"])).eval()
+        assert not lokr_model.supports_lora_conversion()
+
+        msg = "Some module types on this model do not support LoRA conversion"
+        with pytest.raises(TypeError, match=msg):
+            convert_to_lora(lokr_model, rank=8)
+
+    def test_targeted_modules_identical(self, lokr_model):
+        lora_config, lora_state_dict = convert_to_lora(lokr_model, rank=8)
+        lokr_state_dict = lokr_model.state_dict()
+
+        # LoRA should have an entry for each layer targeted by LoKr
+        # cut off parameter name and PEFT method specific part of the name to obtain module name
+        modules_lokr = {k.rsplit(".", 2)[0] for k in lokr_state_dict.keys() if ".lokr" in k}
+        modules_lora = {k.rsplit(".", 2)[0] for k in lora_state_dict.keys() if ".lora" in k}
+        assert modules_lokr == modules_lora
+
+        # creating a new LoRA model based on the returned config should give the same state dict keys
+        base_model = self.get_base_model()
+        new_lora_model = get_peft_model(base_model, lora_config).eval()
+        new_lora_state_dict = get_peft_model_state_dict(new_lora_model)
+        assert lora_state_dict.keys() == new_lora_state_dict.keys()
+
+    def test_targeted_modules_identical_target_modules_str(self):
+        base_model = self.get_base_model()
+        lokr_config = LoKrConfig(target_modules=r".*\.q_proj", r=16, init_weights=False)
+        lokr_model = get_peft_model(base_model, lokr_config).eval()
+        lora_config, lora_state_dict = convert_to_lora(lokr_model, rank=8)
+        lokr_state_dict = lokr_model.state_dict()
+
+        # LoRA should have an entry for each layer targeted by LoKr
+        # cut off parameter name and PEFT method specific part of the name to obtain module name
+        modules_lokr = {k.rsplit(".", 2)[0] for k in lokr_state_dict.keys() if ".lokr" in k}
+        modules_lora = {k.rsplit(".", 2)[0] for k in lora_state_dict.keys() if ".lora" in k}
+        assert modules_lokr == modules_lora
+
+        # creating a new LoRA model based on the returned config should give the same state dict keys
+        base_model = self.get_base_model()
+        new_lora_model = get_peft_model(base_model, lora_config).eval()
+        new_lora_state_dict = get_peft_model_state_dict(new_lora_model)
+        assert lora_state_dict.keys() == new_lora_state_dict.keys()
+
+    def test_fixed_rank_lora_config(self, lokr_model):
+        # with a fixed rank, we expect target_modules to be set on the LoRA config but not rank_pattern, alpha_pattern
+        lora_config, _ = convert_to_lora(lokr_model, rank=8)
+        assert isinstance(lora_config, LoraConfig)
+        assert lora_config.r == 8
+        assert lora_config.lora_alpha == 8
+        assert lora_config.target_modules
+        assert not lora_config.rank_pattern
+        assert not lora_config.alpha_pattern
+
+    def test_dynamic_rank_lora_config(self, lokr_model):
+        # with a dynamic rank, we expect rank_pattern and alpha_pattern to be set
+        lora_config, state_dict = convert_to_lora(lokr_model, rank=0.5)
+        assert lora_config.r == 1  # dummy value
+        assert lora_config.lora_alpha == 1  # dummy value
+        assert lora_config.rank_pattern
+        assert lora_config.alpha_pattern
+
+        # rank and alpha are always the same, i.e. scaling is 1
+        assert lora_config.rank_pattern == lora_config.alpha_pattern
+        # for each module, two LoRA weights
+        assert 2 * len(lora_config.rank_pattern) == len(state_dict)
+
+    def test_dynamic_rank_1_lora_config(self, lokr_model):
+        # with a dynamic rank, we expect rank_pattern and alpha_pattern to be set
+        lora_config, state_dict = convert_to_lora(lokr_model, rank=1.0)
+        assert lora_config.r == 1  # dummy value
+        assert lora_config.lora_alpha == 1  # dummy value
+        assert lora_config.rank_pattern
+        assert lora_config.alpha_pattern
+
+        # rank and alpha are always the same, i.e. scaling is 1
+        assert lora_config.rank_pattern == lora_config.alpha_pattern
+        # for each module, two LoRA weights
+        assert 2 * len(lora_config.rank_pattern) == len(state_dict)
+
+    def test_threshold_wrong_value_raises(self, lokr_model):
+        # if a threshold is used, it must be between 0 and 1
+        msg = "If rank is a float, it is interpreted as a threshold. It must be between 0 and 1 but got 123.0"
+        with pytest.raises(ValueError, match=msg):
+            convert_to_lora(lokr_model, rank=123.0)
+
+        msg = "If rank is a float, it is interpreted as a threshold. It must be between 0 and 1 but got -0.5"
+        with pytest.raises(ValueError, match=msg):
+            convert_to_lora(lokr_model, rank=-0.5)
+
+    def test_rank_higher_than_weight_dim_raises(self, lokr_model):
+        # if the requested rank is higher than the weight dimension, we should raise
+        msg = re.escape("The chosen rank 123 is larger than the weight shape (16), please choose a lower rank")
+        with pytest.raises(ValueError, match=msg):
+            convert_to_lora(lokr_model, rank=123)
+
+    def test_fixed_rank_0_raises(self, lokr_model):
+        msg = "Passing a rank of 0 doesn't make sense"
+        with pytest.raises(ValueError, match=msg):
+            convert_to_lora(lokr_model, rank=0)
+
+    def test_converting_transformers_model_works(self, lokr_model, tmp_path):
+        # test that we can convert a transformers model that has loaded LoKr directly
+        assert lokr_model.supports_lora_conversion()
+
+        inputs = torch.arange(10).view(1, -1).to(self.torch_device)
+        with torch.inference_mode():
+            output_lokr = lokr_model(inputs, output_hidden_states=True)
+
+        lokr_model.save_pretrained(tmp_path)
+        # load directly with transformers
+        loaded_model = AutoModelForCausalLM.from_pretrained(tmp_path).to(self.torch_device)
+        with torch.inference_mode():
+            output_loaded = loaded_model(inputs, output_hidden_states=True)
+
+        # sanity check
+        atol, rtol = 1e-4, 1e-4
+        assert torch.allclose(output_lokr.logits, output_loaded.logits, atol=atol, rtol=rtol)
+
+        save_as_lora(tmp_path / "converted", lokr_model, rank=8)
+        lora_model = AutoModelForCausalLM.from_pretrained(tmp_path / "converted").to(self.torch_device)
+
+        # With from_pretrained, we don't get a load_result and thus cannot check for missing keys. As a proxy,
+        # instead check that no LoRA weight is all zeros (which would indicate a missing weight)
+        for name, param in lora_model.named_parameters():
+            if (".lora_A" in name) or (".lora_B" in name):
+                assert not torch.all(param == 0)
+
+        with torch.inference_mode():
+            output_converted = lora_model(inputs, output_hidden_states=True)
+        assert 0.0 < self.get_mse(output_converted, output_lokr) < 0.1
+
+    def test_converted_lora_approximates_original_adapter(self, lokr_model):
+        inputs = torch.arange(10).view(1, -1).to(self.torch_device)
+        with torch.inference_mode():
+            with lokr_model.disable_adapter():
+                output_base = lokr_model(inputs, output_hidden_states=True)
+            output_lokr = lokr_model(inputs, output_hidden_states=True)
+
+        # sanity check
+        atol, rtol = 1e-4, 1e-4
+        assert not torch.allclose(output_base.logits, output_lokr.logits, atol=atol, rtol=rtol)
+
+        ##############
+        # fixed rank #
+        ##############
+
+        lora_config, state_dict = convert_to_lora(lokr_model, rank=8)
+        base_model = self.get_base_model()
+        lora_model = get_peft_model(base_model, lora_config).eval()
+
+        # by default, the LoRA model should be an identity transform
+        with torch.inference_mode():
+            output_lora = lora_model(inputs, output_hidden_states=True)
+        assert torch.allclose(output_base.logits, output_lora.logits, atol=atol, rtol=rtol)
+
+        # load the converted LoRA weights
+        load_result = set_peft_model_state_dict(lora_model, state_dict)
+        assert not load_result.unexpected_keys
+
+        # sanity check the number of trainable parameters
+        num_train_params, total_params = lora_model.get_nb_trainable_parameters()
+        assert 100 < num_train_params < 0.1 * total_params
+
+        with torch.inference_mode():
+            output_converted = lora_model(inputs, output_hidden_states=True)
+
+        mse_lora = self.get_mse(output_lora, output_lokr)
+        mse_converted = self.get_mse(output_converted, output_lokr)
+        assert mse_lora > 0.5
+        assert 0.0 < mse_converted < 0.1
+
+        ###############################
+        # this time with dynamic rank #
+        ###############################
+
+        lora_config, state_dict = convert_to_lora(lokr_model, rank=0.9)
+        base_model = self.get_base_model()
+        lora_model = get_peft_model(base_model, lora_config).eval()
+        load_result = set_peft_model_state_dict(lora_model, state_dict)
+        assert not load_result.unexpected_keys
+
+        # sanity check the number of trainable parameters
+        num_train_params, total_params = lora_model.get_nb_trainable_parameters()
+        assert 100 < num_train_params < 0.1 * total_params
+
+        with torch.inference_mode():
+            output_converted = lora_model(inputs, output_hidden_states=True)
+        mse_converted = self.get_mse(output_converted, output_lokr)
+        assert 0.0 < mse_converted < 0.1
+
+    def test_with_tqdm_works(self, lokr_model, capsys):
+        # pass progressbar=True to use tqdm
+        convert_to_lora(lokr_model, rank=8, progressbar=True)
+        captured = capsys.readouterr()
+        assert "Converting to LoRA" in captured.err
+
+    def test_save_as_lora(self, lokr_model, tmp_path):
+        # whether using save_as_lora gives the same result as convert_to_lora
+        inputs = torch.arange(10).view(1, -1).to(self.torch_device)
+        atol, rtol = 1e-4, 1e-4
+
+        lora_config, state_dict = convert_to_lora(lokr_model, rank=8)
+        base_model = self.get_base_model()
+        lora_model = get_peft_model(base_model, lora_config).eval()
+        load_result = set_peft_model_state_dict(lora_model, state_dict)
+        assert not load_result.unexpected_keys
+
+        with torch.inference_mode():
+            output_before = lora_model(inputs).logits
+
+        # test that save_as_lora works as expected
+        save_as_lora(tmp_path, lokr_model, rank=8)
+        base_model = self.get_base_model()
+        loaded_model = PeftModel.from_pretrained(base_model, tmp_path).to(self.torch_device)
+
+        with torch.inference_mode():
+            output_after = loaded_model(inputs).logits
+
+        assert torch.allclose(output_before, output_after, atol=atol, rtol=rtol)
+
+    def test_model_without_peft_config(self, lokr_model):
+        # Conversion also works with models that don't have a PeftConfig on them. This is a bit of a convoluted case,
+        # but conversion doesn't strictly rely on an existing peft_config, so it should still work.
+        def unwrap(peft_model):
+            unwrapped = peft_model.get_base_model()
+            del unwrapped.peft_config
+            return unwrapped
+
+        inputs = torch.arange(10).view(1, -1).to(self.torch_device)
+        with torch.inference_mode():
+            output_lokr = lokr_model(inputs, output_hidden_states=True)
+
+        # remove the PeftModel wrapper and the peft_config attribute -- this should still work
+        unwrapped_lokr_model = unwrap(lokr_model)
+        lora_config, state_dict = convert_to_lora(unwrapped_lokr_model, rank=8)
+
+        base_model = self.get_base_model()
+        lora_model = get_peft_model(base_model, lora_config).eval()
+        unwrapped_lora_model = unwrap(lora_model)
+
+        # Note: On the unwrapped model, we cannot use set_peft_model_state_dict, as that requires a peft_config. Thus,
+        # we need to manually inject the adapter name into state_dict keys, which is done automatically when using
+        # set_peft_model_state_dict.
+        new_state_dict = {}
+        for k, v in state_dict.items():
+            new_k = k.replace(".lora_A.weight", ".lora_A.default.weight")
+            new_k = new_k.replace(".lora_B.weight", ".lora_B.default.weight")
+            new_state_dict[new_k] = v
+
+        load_result = unwrapped_lora_model.load_state_dict(new_state_dict, strict=False)
+        assert not load_result.unexpected_keys
+
+        with torch.inference_mode():
+            output_converted = lora_model(inputs, output_hidden_states=True)
+
+        mse = self.get_mse(output_converted, output_lokr)
+        assert 0.0 < mse < 0.1
+
+    def test_converted_lora_to_lora_works_and_warns(self):
+        # In general, there is no need to convert LoRA to LoRA, but it should still work. One possible use case would be
+        # to shrink the rank of an existing LoRA adapter. The resulting correlation in this test is surprisingly high,
+        # probably because the initial LoRA was not trained but initialized with random weights.
+        inputs = torch.arange(10).view(1, -1).to(self.torch_device)
+        base_model = self.get_base_model()
+        with torch.inference_mode():
+            output_base = base_model(inputs, output_hidden_states=True)
+
+        orig_lora_config = LoraConfig(r=16, init_lora_weights=False)
+        orig_lora_model = get_peft_model(base_model, orig_lora_config).eval()
+
+        with torch.inference_mode():
+            output_orig_lora = orig_lora_model(inputs, output_hidden_states=True)
+
+        # sanity check
+        atol, rtol = 1e-4, 1e-4
+        assert not torch.allclose(output_base.logits, output_orig_lora.logits)
+
+        # convert from rank 16 to rank 8
+        msg = "Converting a PEFT adapter to LoRA that is already a LoRA adapter"
+        with pytest.warns(UserWarning, match=msg):
+            # check that a warning was issued
+            lora_config, state_dict = convert_to_lora(orig_lora_model, rank=8)
+
+        base_model = self.get_base_model()
+        lora_model = get_peft_model(base_model, lora_config).eval()
+
+        # load the converted LoRA weights
+        load_result = set_peft_model_state_dict(lora_model, state_dict)
+        assert not load_result.unexpected_keys
+
+        with torch.inference_mode():
+            output_converted = lora_model(inputs, output_hidden_states=True)
+
+        mse_converted = self.get_mse(output_converted, output_orig_lora)
+        assert 0.0 < mse_converted < 0.1
+
+    def test_converted_lora_with_multiple_adapters(self, lokr_model):
+        # ensure that we can convert specific adapters when multiple are present
+        lokr_config = LoKrConfig(r=16, init_weights=False)
+        lokr_model.add_adapter("other", lokr_config)
+
+        inputs = torch.arange(10).view(1, -1).to(self.torch_device)
+        with torch.inference_mode():
+            output_lokr_default = lokr_model(inputs, output_hidden_states=True)
+            lokr_model.set_adapter("other")
+            output_lokr_other = lokr_model(inputs, output_hidden_states=True)
+
+        # sanity check
+        atol, rtol = 1e-4, 1e-4
+        assert not torch.allclose(output_lokr_default.logits, output_lokr_other.logits, atol=atol, rtol=rtol)
+
+        # convert the default adapter
+        lora_config_default, state_dict_default = convert_to_lora(lokr_model, rank=8)
+        base_model = self.get_base_model()
+        lora_model_default = get_peft_model(base_model, lora_config_default).eval()
+
+        # load the converted LoRA weights for the default adapter
+        load_result = set_peft_model_state_dict(lora_model_default, state_dict_default)
+        assert not load_result.unexpected_keys
+        with torch.inference_mode():
+            output_converted_default = lora_model_default(inputs, output_hidden_states=True)
+
+        # convert the other adapter
+        lora_config_other, state_dict_other = convert_to_lora(lokr_model, rank=8, adapter_name="other")
+        base_model = self.get_base_model()
+        lora_model_other = get_peft_model(base_model, lora_config_other).eval()
+        # load the converted LoRA weights for the other adapter
+        load_result = set_peft_model_state_dict(lora_model_other, state_dict_other)
+        assert not load_result.unexpected_keys
+        with torch.inference_mode():
+            output_converted_other = lora_model_other(inputs, output_hidden_states=True)
+
+        mse_default_default = self.get_mse(output_converted_default, output_lokr_default)
+        mse_other_other = self.get_mse(output_converted_other, output_lokr_other)
+        mse_default_other = self.get_mse(output_converted_default, output_lokr_other)
+        mse_other_default = self.get_mse(output_converted_other, output_lokr_default)
+
+        assert 0.0 < mse_default_default < 0.1
+        assert 0.0 < mse_other_other < 0.1
+        assert mse_default_other > 0.5
+        assert mse_other_default > 0.5
+
+    def test_convert_model_with_modules_to_save(self):
+        # If the original adapter defines modules_to_save, these need to be included in the LoRA adapter
+        model = self.get_base_model()
+        inputs = torch.arange(10).view(1, -1).to(self.torch_device)
+        with torch.inference_mode():
+            output_base = model(inputs, output_hidden_states=True)
+
+        # lokr is initialized as identity transform to ensure that modules_to_save is the thing that impacts the output
+        lokr_config = LoKrConfig(modules_to_save=["0.fc1"])
+        lokr_model = get_peft_model(model, lokr_config)
+
+        # ensure that the modules_to_save affects the output
+        lokr_model.base_model.model.model.decoder.layers[0].fc1.modules_to_save.default.weight.data.mul_(-10.0)
+        lokr_model.base_model.model.model.decoder.layers[0].fc1.modules_to_save.default.bias.data.mul_(-10.0)
+
+        with torch.inference_mode():
+            output_lokr = lokr_model(inputs, output_hidden_states=True)
+
+        # sanity check
+        atol, rtol = 1e-4, 1e-4
+        assert not torch.allclose(output_base.logits, output_lokr.logits, atol=atol, rtol=rtol)
+
+        lora_config, state_dict = convert_to_lora(lokr_model, rank=8)
+        assert lora_config.modules_to_save == lokr_config.modules_to_save
+
+        base_model = self.get_base_model()
+        lora_model = get_peft_model(base_model, lora_config).eval()
+
+        # load the converted LoRA weights
+        load_result = set_peft_model_state_dict(lora_model, state_dict)
+        assert not load_result.unexpected_keys
+
+        with torch.inference_mode():
+            output_converted = lora_model(inputs, output_hidden_states=True)
+
+        mse_converted = self.get_mse(output_converted, output_lokr)
+        # here we expect an actual loss of 0, since only the modules_to_save affect the result, and those are identical
+        assert mse_converted == 0.0
+
+    @pytest.mark.parametrize("bias", ["c3a_only", "all"])
+    def test_convert_model_with_trainable_bias_raises(self, bias):
+        # If the original adapter includes trainable bias terms, we raise. LoKr doesn't support this, so taking C3A
+        model = self.get_base_model()
+        inputs = torch.arange(10).view(1, -1).to(self.torch_device)
+
+        c3a_config = C3AConfig(block_size=4, bias=bias)
+        c3a_model = get_peft_model(model, c3a_config)
+
+        msg = "The adapter's config sets bias"
+        with pytest.raises(ValueError, match=msg):
+            convert_to_lora(c3a_model, rank=8)
+
+    @pytest.mark.skipif(platform.system() != "Linux", reason="Running test involving torch.compile only on Linux.")
+    def test_with_torch_compile(self, lokr_model):
+        # ensure that we can call lora conversion with compilation
+        lora_config_no_comp, state_dict_no_comp = convert_to_lora(lokr_model, rank=8)
+        lora_config_comp, state_dict_comp = convert_to_lora(
+            lokr_model, rank=8, compile_kwargs={"mode": "max-autotune-no-cudagraphs"}
+        )
+
+        assert lora_config_no_comp.to_dict() == lora_config_comp.to_dict()
+        assert state_dict_no_comp.keys() == state_dict_comp.keys()
+        for key, weight_no_comp in state_dict_no_comp.items():
+            weight_comp = state_dict_comp[key]
+            assert torch.allclose(weight_comp, weight_no_comp)
+
+    @pytest.mark.parametrize("dtype", [torch.float16, torch.bfloat16])
+    def test_convert_float16_dtype(self, dtype):
+        inputs = torch.arange(10).view(1, -1).to(self.torch_device)
+
+        torch.manual_seed(0)
+        base_model = self.get_base_model().to(dtype)
+        with torch.inference_mode():
+            output_base = base_model(inputs, output_hidden_states=True)
+
+        # load a LoKr model with 16 bit precision
+        lokr_model = get_peft_model(base_model, LoKrConfig(init_weights=False), autocast_adapter_dtype=False)
+
+        with torch.inference_mode():
+            output_lokr = lokr_model(inputs, output_hidden_states=True)
+
+        # sanity check
+        atol, rtol = 1e-4, 1e-4
+        assert not torch.allclose(output_base.logits, output_lokr.logits, atol=atol, rtol=rtol)
+
+        lora_config, state_dict = convert_to_lora(lokr_model, rank=8)
+        for weight in state_dict.values():
+            assert weight.dtype == dtype
+
+        base_model = self.get_base_model().to(dtype)
+        lora_model = get_peft_model(base_model, lora_config, autocast_adapter_dtype=False).eval()
+
+        # load the converted LoRA weights
+        load_result = set_peft_model_state_dict(lora_model, state_dict)
+        assert not load_result.unexpected_keys
+
+        with torch.inference_mode():
+            output_converted = lora_model(inputs, output_hidden_states=True)
+
+        mse_converted = self.get_mse(output_converted, output_lokr)
+        assert 0.0 < mse_converted < 0.1
+
+
+class TestMissLoraConversion:
+    """Test MiSS to LoRA conversion for standard, mini, and bat modes."""
+
+    model_id = "peft-internal-testing/tiny-random-OPTForCausalLM"
+    torch_device = infer_device()
+    base_model = None
+
+    def get_base_model(self):
+        if self.base_model is None:
+            with hub_online_once(self.model_id):
+                self.base_model = AutoModelForCausalLM.from_pretrained(self.model_id).to(self.torch_device)
+        return copy.deepcopy(self.base_model)
+
+    @staticmethod
+    def get_mse(output1, output2):
+        return nn.functional.mse_loss(output1.hidden_states[-1], output2.hidden_states[-1]).item()
+
+    def _randomize_miss_blocks(self, model):
+        with torch.no_grad():
+            for m in model.modules():
+                if hasattr(m, "miss_block"):
+                    for p in m.miss_block.values():
+                        p.data.normal_(0, 0.01)
+
+    @pytest.fixture
+    def miss_model_standard(self):
+        torch.manual_seed(0)
+        config = MissConfig(r=4, init_weights=False, target_modules=["q_proj", "v_proj"])
+        return get_peft_model(self.get_base_model(), config)
+
+    @pytest.fixture
+    def miss_model_mini(self):
+        torch.manual_seed(0)
+        config = MissConfig(r=4, mini_r=2, init_weights="mini", target_modules=["q_proj", "v_proj"])
+        model = get_peft_model(self.get_base_model(), config)
+        self._randomize_miss_blocks(model)
+        return model
+
+    @pytest.fixture
+    def miss_model_bat(self):
+        torch.manual_seed(0)
+        config = MissConfig(r=4, init_weights="bat", target_modules=["q_proj", "v_proj"])
+        model = get_peft_model(self.get_base_model(), config)
+        self._randomize_miss_blocks(model)
+        return model
+
+    def test_miss_supports_lora_conversion(self, miss_model_standard, miss_model_mini, miss_model_bat):
+        assert miss_model_standard.supports_lora_conversion()
+        assert miss_model_mini.supports_lora_conversion()
+        assert miss_model_bat.supports_lora_conversion()
+
+    def test_miss_standard_exact_conversion(self, miss_model_standard):
+        inputs = torch.arange(10).view(1, -1).to(self.torch_device)
+        with torch.inference_mode():
+            output_miss = miss_model_standard(inputs, output_hidden_states=True)
+
+        lora_config, state_dict = convert_to_lora(miss_model_standard, rank=4)
+        base_model = self.get_base_model()
+        lora_model = get_peft_model(base_model, lora_config).eval()
+        load_result = set_peft_model_state_dict(lora_model, state_dict)
+        assert not load_result.unexpected_keys
+
+        with torch.inference_mode():
+            output_lora = lora_model(inputs, output_hidden_states=True)
+
+        mse = self.get_mse(output_lora, output_miss)
+        assert mse < 1e-5, f"Standard MiSS conversion should be exact, got mse={mse}"
+
+    def test_miss_mini_exact_conversion(self, miss_model_mini):
+        inputs = torch.arange(10).view(1, -1).to(self.torch_device)
+        with torch.inference_mode():
+            output_miss = miss_model_mini(inputs, output_hidden_states=True)
+
+        lora_config, state_dict = convert_to_lora(miss_model_mini, rank=4)
+        base_model = self.get_base_model()
+        lora_model = get_peft_model(base_model, lora_config).eval()
+        load_result = set_peft_model_state_dict(lora_model, state_dict)
+        assert not load_result.unexpected_keys
+
+        with torch.inference_mode():
+            output_lora = lora_model(inputs, output_hidden_states=True)
+
+        mse = self.get_mse(output_lora, output_miss)
+        assert mse < 1e-5, f"Mini MiSS conversion should be exact, got mse={mse}"
+
+    def test_miss_bat_approximate_conversion(self, miss_model_bat):
+        inputs = torch.arange(10).view(1, -1).to(self.torch_device)
+        with torch.inference_mode():
+            with miss_model_bat.disable_adapter():
+                output_base = miss_model_bat(inputs, output_hidden_states=True)
+            output_miss = miss_model_bat(inputs, output_hidden_states=True)
+
+        atol, rtol = 1e-4, 1e-4
+        assert not torch.allclose(output_base.logits, output_miss.logits, atol=atol, rtol=rtol)
+
+        lora_config, state_dict = convert_to_lora(miss_model_bat, rank=4)
+        base_model = self.get_base_model()
+        lora_model = get_peft_model(base_model, lora_config).eval()
+        load_result = set_peft_model_state_dict(lora_model, state_dict)
+        assert not load_result.unexpected_keys
+
+        with torch.inference_mode():
+            output_lora = lora_model(inputs, output_hidden_states=True)
+
+        mse = self.get_mse(output_lora, output_miss)
+        assert 0.0 < mse < 0.1
+
+    def test_miss_targeted_modules_identical(self, miss_model_standard):
+        _, lora_state_dict = convert_to_lora(miss_model_standard, rank=4)
+        miss_state_dict = miss_model_standard.state_dict()
+
+        modules_miss = {k.rsplit(".", 2)[0] for k in miss_state_dict.keys() if ".miss_block" in k}
+        modules_lora = {k.rsplit(".", 2)[0] for k in lora_state_dict.keys() if ".lora" in k}
+        assert modules_miss == modules_lora
+
+    def test_miss_save_as_lora(self, miss_model_standard, tmp_path):
+        inputs = torch.arange(10).view(1, -1).to(self.torch_device)
+        atol, rtol = 1e-4, 1e-4
+
+        lora_config, state_dict = convert_to_lora(miss_model_standard, rank=4)
+        base_model = self.get_base_model()
+        lora_model = get_peft_model(base_model, lora_config).eval()
+        set_peft_model_state_dict(lora_model, state_dict)
+
+        with torch.inference_mode():
+            output_before = lora_model(inputs).logits
+
+        save_as_lora(tmp_path, miss_model_standard, rank=4)
+        base_model = self.get_base_model()
+        loaded_model = PeftModel.from_pretrained(base_model, tmp_path).to(self.torch_device)
+
+        with torch.inference_mode():
+            output_after = loaded_model(inputs).logits
+
+        assert torch.allclose(output_before, output_after, atol=atol, rtol=rtol)
diff --git a/tests/test_lora_ga.py b/tests/test_lora_ga.py
new file mode 100644
index 0000000..c1ed8b0
--- /dev/null
+++ b/tests/test_lora_ga.py
@@ -0,0 +1,433 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+
+import pytest
+import torch
+
+from peft import LoraConfig, PeftModel, get_peft_model
+from peft.tuners.lora import LoraGAConfig, preprocess_loraga
+
+
+class TestLoraGAPreprocessing:
+    """Test preprocess_loraga functionality."""
+
+    def test_preprocess_basic(self, simple_model, simple_train_step):
+        lora_ga_config = LoraGAConfig(direction="ArB2r", scale="stable")
+        lora_config = LoraConfig(
+            r=4,
+            lora_alpha=8,
+            target_modules=["0"],
+            init_lora_weights="lora_ga",
+            lora_ga_config=lora_ga_config,
+        )
+
+        # Run preprocessing
+        preprocess_loraga(simple_model, lora_config, simple_train_step)
+
+        # Check that gradients were attached
+        assert hasattr(simple_model[0], "_peft_loraga_grad")
+        assert simple_model[0]._peft_loraga_grad.shape == simple_model[0].weight.shape
+
+    def test_preprocess_without_lora_ga_config_raises(self, simple_model):
+        def train_step():
+            pass
+
+        lora_config = LoraConfig(r=4, lora_alpha=8, target_modules=["0"])
+
+        with pytest.raises(ValueError, match="If you want to use LoRA-GA"):
+            preprocess_loraga(simple_model, lora_config, train_step)
+
+    def test_init_without_lora_ga_config_raises(self, simple_model, simple_train_step):
+        # Properly preprocess with lora_ga_config
+        lora_ga_config = LoraGAConfig(direction="ArB2r", scale="stable")
+        lora_config = LoraConfig(
+            r=4,
+            lora_alpha=8,
+            target_modules=["0"],
+            init_lora_weights="lora_ga",
+            lora_ga_config=lora_ga_config,
+        )
+        preprocess_loraga(simple_model, lora_config, simple_train_step)
+
+        # Now try to create a config without lora_ga_config but with init_lora_weights="lora_ga"
+        bad_config = LoraConfig(
+            r=4,
+            lora_alpha=8,
+            target_modules=["0"],
+            init_lora_weights="lora_ga",
+            lora_ga_config=None,  # Missing lora_ga_config!
+        )
+
+        # This should raise an error during get_peft_model
+        with pytest.raises(ValueError, match="lora_ga_config must be provided"):
+            get_peft_model(simple_model, bad_config)
+
+
+@pytest.fixture
+def simple_model():
+    """Fixture providing a fresh simple sequential model for each test."""
+    model = torch.nn.Sequential(torch.nn.Linear(10, 10))
+    model.train()
+    return model
+
+
+@pytest.fixture
+def simple_train_step(simple_model):
+    """Fixture providing a train step function for the model."""
+
+    def train_step():
+        for _ in range(4):
+            inputs = torch.randn(2, 10)
+            outputs = simple_model(inputs)
+            loss = outputs.sum()
+            loss.backward()
+
+    return train_step
+
+
+class TestLoraGAIntegration:
+    """Integration tests for LoRA-GA."""
+
+    @pytest.mark.parametrize("direction", ["ArBr", "A2rBr", "ArB2r", "random"])
+    @pytest.mark.parametrize("scale", ["stable", "weight_svd", "gd_scale", "unit"])
+    def test_save_load_inference(self, tmp_path, simple_model, simple_train_step, direction, scale):
+        """Test that saved and loaded models produce the same output."""
+        torch.manual_seed(42)
+
+        lora_ga_config = LoraGAConfig(direction=direction, scale=scale)
+        lora_config = LoraConfig(
+            r=4,
+            lora_alpha=8,
+            target_modules=["0"],
+            init_lora_weights="lora_ga",
+            lora_ga_config=lora_ga_config,
+        )
+
+        preprocess_loraga(simple_model, lora_config, simple_train_step)
+        peft_model = get_peft_model(simple_model, lora_config)
+
+        # Generate output before saving
+        test_input = torch.randn(2, 10)
+        with torch.no_grad():
+            output_before = peft_model(test_input)
+
+        # Save model
+        peft_model.save_pretrained(str(tmp_path))
+
+        # Load model - need to use the same base model that was modified by LoRA-GA
+        # Create a fresh model and load the saved state
+        loaded_model = PeftModel.from_pretrained(simple_model, str(tmp_path))
+
+        # Generate output after loading
+        with torch.no_grad():
+            output_after = loaded_model(test_input)
+
+        # Outputs should be identical
+        assert torch.allclose(output_before, output_after, atol=1e-5)
+
+    @pytest.mark.parametrize("scale", ["stable", "weight_svd", "gd_scale", "unit"])
+    @pytest.mark.parametrize("direction", ["ArBr", "A2rBr", "ArB2r", "random"])
+    def test_save_load_with_weight_conversion(self, tmp_path, simple_model, simple_train_step, direction, scale):
+        # Skip the random+weight_svd combination as it produces non-deterministic results
+        if direction == "random" and scale == "weight_svd":
+            pytest.skip("Skipping random+weight_svd combination due to non-deterministic behavior")
+        """Test save/load with path_initial_model_for_weight_conversion."""
+        torch.manual_seed(42)
+        # Save RNG state for reproducing exact initialization later
+        rng_state = torch.get_rng_state()
+
+        # Save original base model weights (before LoRA-GA preprocessing)
+        original_weights = {k: v.clone() for k, v in simple_model.state_dict().items()}
+
+        lora_ga_config = LoraGAConfig(direction=direction, scale=scale)
+        lora_config = LoraConfig(
+            r=4,
+            lora_alpha=8,
+            target_modules=["0"],
+            init_lora_weights="lora_ga",
+            lora_ga_config=lora_ga_config,
+        )
+
+        preprocess_loraga(simple_model, lora_config, simple_train_step)
+        peft_model = get_peft_model(simple_model, lora_config)
+
+        # Save the initialized adapter (before training)
+        init_adapter_path = tmp_path / "init_adapter"
+        peft_model.peft_config["default"].init_lora_weights = True
+        peft_model.save_pretrained(str(init_adapter_path))
+
+        # Generate output before saving (simulating after training)
+        test_input = torch.randn(2, 10)
+        with torch.no_grad():
+            output_before = peft_model(test_input)
+
+        # Save with weight conversion
+        adapter_path = tmp_path / "adapter"
+        peft_model.save_pretrained(str(adapter_path), path_initial_model_for_weight_conversion=str(init_adapter_path))
+
+        # Load with original base model - need fresh model instance with same original weights
+        # Restore RNG state to ensure random operations (like randperm for direction="random") are reproducible
+        torch.set_rng_state(rng_state)
+        base_model = torch.nn.Sequential(torch.nn.Linear(10, 10))
+        base_model.train()
+        base_model.load_state_dict(original_weights)
+
+        # Load converted adapter
+        loaded_model = PeftModel.from_pretrained(base_model, str(adapter_path))
+
+        # Generate output after loading
+        with torch.no_grad():
+            output_after = loaded_model(test_input)
+
+        # Outputs should be identical
+        assert torch.allclose(output_before, output_after, atol=1e-5)
+
+    def test_cached_gradients(self, tmp_path):
+        """Test that cached gradients produce the same results as fresh gradients."""
+        torch.manual_seed(42)
+
+        # First run: compute gradients and save to cache
+        model1 = torch.nn.Sequential(torch.nn.Linear(10, 10))
+        model1.train()
+
+        def train_step1():
+            for _ in range(4):
+                inputs = torch.randn(2, 10)
+                outputs = model1(inputs)
+                loss = outputs.sum()
+                model1.zero_grad()
+                loss.backward()
+
+        lora_ga_config = LoraGAConfig(direction="ArB2r", scale="stable")
+        lora_config = LoraConfig(
+            r=4,
+            lora_alpha=8,
+            target_modules=["0"],
+            init_lora_weights="lora_ga",
+            lora_ga_config=lora_ga_config,
+        )
+
+        cache_file = tmp_path / "gradient_cache.pt"
+        preprocess_loraga(model1, lora_config, train_step1, cache_file=str(cache_file))
+        peft_model1 = get_peft_model(model1, lora_config)
+
+        # Check that cache file was created
+        assert cache_file.exists()
+        assert cache_file.stat().st_size > 0
+
+        # Generate output from first model
+        test_input = torch.randn(2, 10)
+        with torch.no_grad():
+            output1 = peft_model1(test_input)
+
+        # Second run: load gradients from cache
+        torch.manual_seed(42)  # Reset seed to get same initial weights
+        model2 = torch.nn.Sequential(torch.nn.Linear(10, 10))
+        model2.train()
+
+        def train_step2():
+            for _ in range(4):
+                inputs = torch.randn(2, 10)
+                outputs = model2(inputs)
+                loss = outputs.sum()
+                model2.zero_grad()
+                loss.backward()
+
+        # Use same config and cache file - should load from cache without running train_step
+        preprocess_loraga(model2, lora_config, train_step2, cache_file=str(cache_file))
+        peft_model2 = get_peft_model(model2, lora_config)
+
+        # Generate output from second model
+        with torch.no_grad():
+            output2 = peft_model2(test_input)
+
+        # Outputs should be identical since both used the same cached gradients
+        assert torch.allclose(output1, output2, atol=1e-5)
+
+    @pytest.mark.parametrize("dtype", [torch.float16, torch.bfloat16])
+    def test_lower_precision_dtype(self, tmp_path, dtype):
+        """Test LoRA-GA works with lower precision dtypes (fp16/bf16)."""
+        torch.manual_seed(42)
+
+        # Create model in lower precision
+        model = torch.nn.Sequential(torch.nn.Linear(10, 10))
+        model = model.to(dtype=dtype)
+        model.train()
+
+        def train_step():
+            for _ in range(4):
+                inputs = torch.randn(2, 10, dtype=dtype)
+                outputs = model(inputs)
+                loss = outputs.sum()
+                model.zero_grad()
+                loss.backward()
+
+        lora_ga_config = LoraGAConfig(direction="ArB2r", scale="stable")
+        lora_config = LoraConfig(
+            r=4,
+            lora_alpha=8,
+            target_modules=["0"],
+            init_lora_weights="lora_ga",
+            lora_ga_config=lora_ga_config,
+        )
+
+        # Preprocess and create PEFT model with autocast_adapter_dtype=False
+        # to ensure LoRA adapters are also in lower precision
+        preprocess_loraga(model, lora_config, train_step)
+        peft_model = get_peft_model(model, lora_config, autocast_adapter_dtype=False)
+
+        # Verify adapter dtype matches model dtype
+        for name, module in peft_model.named_modules():
+            if hasattr(module, "lora_A"):
+                assert module.lora_A["default"].weight.dtype == dtype
+                assert module.lora_B["default"].weight.dtype == dtype
+
+        # Generate output before saving
+        test_input = torch.randn(2, 10, dtype=dtype)
+        with torch.no_grad():
+            output_before = peft_model(test_input)
+
+        # Save and load model
+        peft_model.save_pretrained(str(tmp_path))
+        loaded_model = PeftModel.from_pretrained(model, str(tmp_path))
+
+        # Generate output after loading
+        with torch.no_grad():
+            output_after = loaded_model(test_input)
+
+        # Outputs should be close - use looser tolerance for lower precision
+        assert torch.allclose(output_before, output_after, atol=1e-2)
+
+    def test_quantized_model_rejection(self):
+        """Test that quantized models are properly rejected with clear error."""
+
+        class MockQuantizedLinear(torch.nn.Linear):
+            """Mock quantized layer that simulates bitsandbytes quantized layers."""
+
+            def __init__(self, in_features, out_features):
+                super().__init__(in_features, out_features)
+                # Simulate quantized layer by adding quant_state attribute
+                self.quant_state = "mock_quantized"
+
+        # Create model with quantized layer
+        model = torch.nn.Sequential(MockQuantizedLinear(10, 10))
+        model.train()
+
+        def train_step():
+            for _ in range(4):
+                inputs = torch.randn(2, 10)
+                outputs = model(inputs)
+                loss = outputs.sum()
+                model.zero_grad()
+                loss.backward()
+
+        lora_ga_config = LoraGAConfig(direction="ArB2r", scale="stable")
+        lora_config = LoraConfig(
+            r=4,
+            lora_alpha=8,
+            target_modules=["0"],
+            init_lora_weights="lora_ga",
+            lora_ga_config=lora_ga_config,
+        )
+
+        # Should raise ValueError mentioning quantization
+        with pytest.raises(ValueError, match="quantized"):
+            preprocess_loraga(model, lora_config, train_step)
+
+    def test_unsupported_layer_types_no_error(self):
+        """Test that unsupported layer types don't cause errors."""
+
+        class MixedModel(torch.nn.Module):
+            """Model with both supported and unsupported layer types."""
+
+            def __init__(self):
+                super().__init__()
+                self.linear = torch.nn.Linear(10, 10)  # Supported
+                self.conv2d = torch.nn.Conv2d(3, 16, 3)  # Unsupported
+                self.embedding = torch.nn.Embedding(100, 10)  # Unsupported
+
+            def forward(self, x):
+                return self.linear(x)
+
+        model = MixedModel()
+        model.train()
+
+        def train_step():
+            for _ in range(4):
+                inputs = torch.randn(2, 10)
+                outputs = model(inputs)
+                loss = outputs.sum()
+                model.zero_grad()
+                loss.backward()
+
+        lora_ga_config = LoraGAConfig(direction="ArB2r", scale="stable")
+        lora_config = LoraConfig(
+            r=4,
+            lora_alpha=8,
+            target_modules=["linear", "conv2d", "embedding"],  # Mix of supported and unsupported
+            init_lora_weights="lora_ga",
+            lora_ga_config=lora_ga_config,
+        )
+
+        # Should not raise error - unsupported layers are silently skipped
+        preprocess_loraga(model, lora_config, train_step)
+
+        # Verify that linear layer has LoRA-GA gradient attached during preprocessing
+        assert hasattr(model.linear, "_peft_loraga_grad")
+        # Unsupported layers won't have gradients attached
+        assert not hasattr(model.conv2d, "_peft_loraga_grad")
+        assert not hasattr(model.embedding, "_peft_loraga_grad")
+
+        # Now create PEFT model - should work without errors
+        peft_model = get_peft_model(model, lora_config)
+
+        # Verify model still works
+        test_input = torch.randn(2, 10)
+        with torch.no_grad():
+            output = peft_model(test_input)
+        assert output.shape == (2, 10)
+
+    def test_no_supported_layers_raises_error(self):
+        """Test that having no supported layers raises clear error."""
+
+        class UnsupportedModel(torch.nn.Module):
+            """Model with only unsupported layer types."""
+
+            def __init__(self):
+                super().__init__()
+                self.conv2d = torch.nn.Conv2d(3, 16, 3)
+                self.embedding = torch.nn.Embedding(100, 10)
+
+            def forward(self, x):
+                return x
+
+        model = UnsupportedModel()
+        model.train()
+
+        def train_step():
+            model.zero_grad()
+
+        lora_ga_config = LoraGAConfig(direction="ArB2r", scale="stable")
+        lora_config = LoraConfig(
+            r=4,
+            lora_alpha=8,
+            target_modules=["conv2d", "embedding"],  # Only unsupported layers
+            init_lora_weights="lora_ga",
+            lora_ga_config=lora_ga_config,
+        )
+
+        # Should raise ValueError about no supported layers
+        with pytest.raises(ValueError, match="No supported layers found"):
+            preprocess_loraga(model, lora_config, train_step)
diff --git a/tests/test_lora_intruders.py b/tests/test_lora_intruders.py
new file mode 100644
index 0000000..917719e
--- /dev/null
+++ b/tests/test_lora_intruders.py
@@ -0,0 +1,150 @@
+from functools import partial
+from io import StringIO
+
+import pytest
+import torch
+from transformers import AutoModelForCausalLM
+
+from peft import LoraConfig, MissConfig, get_peft_model
+from peft.tuners.lora.intruders import reduce_intruder_dimension
+
+from .testing_utils import hub_online_once
+
+
+class TestLoraIntruders:
+    @pytest.fixture
+    def model_lin(self):
+        model_id = "trl-internal-testing/tiny-random-LlamaForCausalLM"
+        with hub_online_once(model_id):
+            base_model = AutoModelForCausalLM.from_pretrained(model_id)
+
+        cfg = LoraConfig(target_modules=["q_proj"])
+        peft_model = get_peft_model(base_model, cfg)
+
+        return peft_model
+
+    @pytest.fixture
+    def model_emb(self):
+        model_id = "trl-internal-testing/tiny-random-LlamaForCausalLM"
+        with hub_online_once(model_id):
+            base_model = AutoModelForCausalLM.from_pretrained(model_id)
+
+        cfg = LoraConfig(target_modules=["embed_tokens"])
+        peft_model = get_peft_model(base_model, cfg)
+
+        return peft_model
+
+    @pytest.fixture
+    def model_lin_bf16_no_autocast(self):
+        model_id = "trl-internal-testing/tiny-random-LlamaForCausalLM"
+        with hub_online_once(model_id):
+            base_model = AutoModelForCausalLM.from_pretrained(model_id, dtype=torch.bfloat16)
+
+        cfg = LoraConfig(target_modules=["q_proj"])
+        # autocast_adapter_dtype=False keeps the adapter weights in the base model's dtype
+        # (bf16) instead of upcasting them to fp32.
+        peft_model = get_peft_model(base_model, cfg, autocast_adapter_dtype=False)
+
+        return peft_model
+
+    @pytest.fixture
+    def model_lin_non_lora(self):
+        model_id = "trl-internal-testing/tiny-random-LlamaForCausalLM"
+        with hub_online_once(model_id):
+            base_model = AutoModelForCausalLM.from_pretrained(model_id)
+
+        cfg = MissConfig(target_modules=["q_proj"])
+        peft_model = get_peft_model(base_model, cfg)
+
+        return peft_model
+
+    def test_lora_intruders_linear(self, model_lin):
+        original_weights = {}
+        for name, module in model_lin.named_modules():
+            if "q_proj" in name and hasattr(module, "lora_B"):
+                original_weights[name] = module.lora_B["default"].weight.detach().clone()
+
+        buffer = StringIO()
+
+        # use a high epsilon to make sure that we get a match to see whether layers get modified
+        reduce_intruder_dimension(model_lin, threshold_epsilon=999, logging_sink=partial(print, file=buffer))
+
+        # the old adapter should not be active anymore, just the new one. but the old one should still exist.
+        assert model_lin.active_adapters == ["intruder_reduced"]
+        assert set(model_lin.peft_config.keys()) == {"default", "intruder_reduced"}
+
+        buffer.seek(0)
+        lines = buffer.readlines()
+
+        assert len(lines) > 0
+        assert any("q_proj" in line for line in lines)
+
+        for name, module in model_lin.named_modules():
+            if name in original_weights:
+                # Make sure that the original adapter was not modified
+                assert torch.equal(module.lora_B["default"].weight.detach(), original_weights[name])
+
+                # Since the epsilon is really low, we should modify every layer so the weights should differ
+                new_weight = module.lora_B["intruder_reduced"].weight.detach()
+                assert not torch.equal(new_weight, original_weights[name])
+
+    def test_lora_intruders_linear_bf16_no_autocast(self, model_lin_bf16_no_autocast):
+        # Regression test: with autocast_adapter_dtype=False, the base layer's weights (and thus
+        # W_merged = W + dW) are bf16. torch.linalg.svd does not support half-precision dtypes, so
+        # W_merged must be upcast to fp32 for the SVD calls just like W already is. Without that,
+        # this call used to raise a RuntimeError.
+        model_lin = model_lin_bf16_no_autocast
+
+        original_dtypes = {}
+        for name, module in model_lin.named_modules():
+            if "q_proj" in name and hasattr(module, "lora_B"):
+                original_dtypes[name] = module.lora_B["default"].weight.dtype
+
+        # use a high epsilon to make sure that we get a match to see whether layers get modified
+        reduce_intruder_dimension(model_lin, threshold_epsilon=999)
+
+        assert model_lin.active_adapters == ["intruder_reduced"]
+
+        for name, module in model_lin.named_modules():
+            if name in original_dtypes:
+                # The new adapter's dtype must match the old adapter's (and the base model's) dtype,
+                # not be left as the float32 the SVD internally computed in. Both LoRA factors are
+                # rebuilt from the SVD, so check A and B.
+                assert module.lora_A["intruder_reduced"].weight.dtype == original_dtypes[name]
+                assert module.lora_B["intruder_reduced"].weight.dtype == original_dtypes[name]
+                assert original_dtypes[name] == torch.bfloat16
+
+    def test_lora_intruders_embedding(self, model_emb):
+        original_weights = {}
+        for name, module in model_emb.named_modules():
+            if "embed_tokens" in name and hasattr(module, "lora_B"):
+                original_weights[name] = module.lora_embedding_B["default"].detach().clone()
+
+        buffer = StringIO()
+
+        # use a high epsilon to make sure that we get a match to see whether layers get modified
+        reduce_intruder_dimension(model_emb, threshold_epsilon=999, logging_sink=partial(print, file=buffer))
+
+        # the old adapter should not be active anymore, just the new one. but the old one should still exist.
+        assert model_emb.active_adapters == ["intruder_reduced"]
+        assert set(model_emb.peft_config.keys()) == {"default", "intruder_reduced"}
+
+        buffer.seek(0)
+        lines = buffer.readlines()
+
+        assert len(lines) > 0
+        assert any("embed_tokens" in line for line in lines)
+
+        for name, module in model_emb.named_modules():
+            if name in original_weights:
+                # Make sure that the original adapter was not modified
+                assert torch.equal(module.lora_embedding_B["default"].detach(), original_weights[name])
+
+                # Since the epsilon is really low, we should modify every layer so the weights should differ
+                new_weight = module.lora_embedding_B["intruder_reduced"].detach()
+                assert not torch.equal(new_weight, original_weights[name])
+
+    def test_non_lora_intruders_linear_raises(self, model_lin_non_lora):
+        with pytest.raises(ValueError) as e:
+            reduce_intruder_dimension(model_lin_non_lora, threshold_epsilon=999)
+            assert "The provided model is not using LoRA" in str(e)
diff --git a/tests/test_lora_megatron.py b/tests/test_lora_megatron.py
new file mode 100644
index 0000000..8960493
--- /dev/null
+++ b/tests/test_lora_megatron.py
@@ -0,0 +1,190 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+import copy
+import importlib
+import os
+import unittest
+
+import pytest
+import torch
+from torch.nn import init
+from transformers import AutoModelForCausalLM
+
+from peft import LoraConfig, PeftModel, get_peft_model, get_peft_model_state_dict
+
+from .testing_common import hub_online_once
+from .testing_utils import require_torch_gpu
+
+
+def is_megatron_available() -> bool:
+    return importlib.util.find_spec("megatron") is not None
+
+
+if is_megatron_available():
+    from megatron.core import parallel_state, tensor_parallel
+    from megatron.core.tensor_parallel.random import model_parallel_cuda_manual_seed
+    from megatron.core.transformer.module import MegatronModule
+    from megatron.core.transformer.transformer_config import TransformerConfig
+
+    world_size = 1
+    rank = 0
+
+    def initialize_distributed():
+        print(f"Initializing torch.distributed with rank: {rank}, world_size: {world_size}")
+        torch.cuda.set_device(0)
+        init_method = "tcp://"
+        master_ip = os.getenv("MASTER_ADDR", "localhost")
+        master_port = os.getenv("MASTER_PORT", "6001")
+        init_method += master_ip + ":" + master_port
+        torch.distributed.init_process_group(backend="nccl", world_size=world_size, rank=rank, init_method=init_method)
+
+    def destroy_model_parallel():
+        parallel_state.destroy_model_parallel()
+        torch.distributed.barrier()
+
+    def initialize_model_parallel(
+        tensor_model_parallel_size=1,
+        pipeline_model_parallel_size=1,
+        virtual_pipeline_model_parallel_size=None,
+        pipeline_model_parallel_split_rank=None,
+    ):
+        parallel_state.destroy_model_parallel()
+        if not torch.distributed.is_initialized():
+            initialize_distributed()
+        parallel_state.initialize_model_parallel(
+            tensor_model_parallel_size,
+            pipeline_model_parallel_size,
+            virtual_pipeline_model_parallel_size,
+            pipeline_model_parallel_split_rank,
+        )
+
+    class DummyModule(MegatronModule):
+        def __init__(self, config: TransformerConfig):
+            super().__init__(config)
+            self.linear = tensor_parallel.ColumnParallelLinear(
+                input_size=10,
+                output_size=10,
+                config=config,
+                init_method=init.xavier_normal_,
+                bias=False,
+                gather_output=False,
+            )
+            self.lm_head = tensor_parallel.RowParallelLinear(
+                input_size=10,
+                output_size=10,
+                config=config,
+                init_method=init.xavier_normal_,
+                bias=False,
+                input_is_parallel=True,
+                skip_bias_add=True,
+            )
+
+        def forward(self, input):
+            x = self.linear(input)[0]
+            x = self.lm_head(x)[0]
+            return x
+
+    @require_torch_gpu
+    class TestMegatronLora(unittest.TestCase):
+        def setUp(self):
+            initialize_model_parallel(1, 1)
+            model_parallel_cuda_manual_seed(123)
+            transformer_config = {
+                "num_layers": 2,
+                "hidden_size": 12,
+                "num_attention_heads": 4,
+                "use_cpu_initialization": True,
+            }
+            config = TransformerConfig(**transformer_config)
+            self.megatron_module = DummyModule(config=config).cuda()
+            self.dummy_module = copy.deepcopy(self.megatron_module).cuda()
+
+            lora_config = LoraConfig(
+                lora_alpha=16,
+                lora_dropout=0.1,
+                r=64,
+                bias="none",
+                target_modules=["linear", "lm_head"],
+                megatron_config=config,
+                megatron_core="megatron.core",
+            )
+            self.megatron_module = get_peft_model(self.megatron_module, lora_config)
+
+        def tearDown(self):
+            destroy_model_parallel()
+
+        def test_megatron_lora_module(self):
+            megatron_module = self.megatron_module
+            assert isinstance(megatron_module, PeftModel)
+
+            for name, module in megatron_module.named_modules():
+                if name.endswith("linear"):
+                    assert hasattr(module, "lora_A")
+                    assert hasattr(module, "lora_B")
+                if name.endswith("linear.lora_A.default"):
+                    assert isinstance(module, torch.nn.Linear)
+                if name.endswith("linear.lora_B.default"):
+                    assert isinstance(module, tensor_parallel.ColumnParallelLinear)
+
+                if name.endswith("lm_head.lora_A.default"):
+                    assert isinstance(module, tensor_parallel.RowParallelLinear)
+                if name.endswith("lm_head.lora_B.default"):
+                    assert isinstance(module, torch.nn.Linear)
+
+        def test_forward(self):
+            x = torch.ones((2, 4, 10)).cuda()
+            megatron_module_result = self.megatron_module(x)
+            dummt_module_result = self.dummy_module(x)
+
+            # Because lora_B is initialized with 0, the forward results of two models should be equal before backward.
+            assert megatron_module_result.equal(dummt_module_result)
+
+        def test_backward(self):
+            optimizer = torch.optim.AdamW(self.megatron_module.parameters())
+            loss_fn = torch.nn.CrossEntropyLoss()
+
+            x = torch.randn(2, 4, 10, requires_grad=True).cuda()
+            label = torch.randint(10, (2 * 4,)).cuda()
+
+            output = self.megatron_module(x)
+            output = output.reshape(2 * 4, 10)
+            loss = loss_fn(output, label)
+
+            loss.backward()
+            optimizer.step()
+
+        def test_get_peft_model_state_dict(self):
+            peft_state_dict = get_peft_model_state_dict(self.megatron_module)
+
+            for key in peft_state_dict.keys():
+                assert "lora" in key
+
+    def test_megatron_core_unknown_package_raises(tmp_path):
+        # Mimic loading a megatron model with a adversarial `megatron_core` value to emulate
+        # a code execution attack. See #3085 and `AutoPeftModel.from_pretrained` (import_allowlist) for details.
+        model_id = "trl-internal-testing/tiny-random-LlamaForCausalLM"
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+
+        megatron_config = {"foo": 1}
+
+        lora_config = LoraConfig(
+            target_modules="all-linear",
+            megatron_config=megatron_config,
+            megatron_core="os.system",
+        )
+
+        with pytest.raises(ValueError) as e:
+            megatron_model = get_peft_model(model, lora_config)
+        assert "unsupported due to being a potential security" in str(e)
diff --git a/tests/test_lora_variants.py b/tests/test_lora_variants.py
new file mode 100644
index 0000000..33acc95
--- /dev/null
+++ b/tests/test_lora_variants.py
@@ -0,0 +1,402 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+import dataclasses
+from unittest.mock import PropertyMock, patch
+
+import pytest
+import torch
+from torch import nn
+from transformers import AutoModelForCausalLM
+
+from peft import LoraConfig, TaskType, get_peft_model
+from peft.tuners.lora.layer import Conv1d as LoraConv1d
+from peft.tuners.lora.layer import Conv2d as LoraConv2d
+from peft.tuners.lora.layer import Embedding as LoraEmbedding
+from peft.tuners.lora.layer import Linear as LoraLinear
+from peft.tuners.lora.layer import LoraLayer
+from peft.tuners.lora.variants import (
+    ALoraLinearVariant,
+    DoraConv1dVariant,
+    DoraConv2dVariant,
+    DoraEmbeddingVariant,
+    DoraLinearVariant,
+    calculate_alora_offsets,
+    get_alora_offsets_for_forward,
+    get_alora_offsets_for_generate,
+)
+
+from .testing_common import hub_online_once
+
+
+# Custom model featuring embeddings and a 'visual stack'
+class CustomModel(nn.Module):
+    """pytorch module that contains common targetable layers (linear, embedding, conv, ...)"""
+
+    def __init__(self, num_embeddings=100, embedding_dim=16, num_classes=10):
+        super().__init__()
+        self.embedding = nn.Embedding(num_embeddings, embedding_dim)
+        self.conv1d = nn.Conv1d(in_channels=embedding_dim, out_channels=32, kernel_size=3, padding=1)
+        self.conv2d = nn.Conv2d(in_channels=1, out_channels=16, kernel_size=3, stride=1, padding=1)
+        self.flatten = nn.Flatten()
+        self.dummy_conv1d_output_dim = 32 * 10
+        self.dummy_conv2d_output_dim = 16 * 10 * 10
+        self.linear1 = nn.Linear(self.dummy_conv1d_output_dim + self.dummy_conv2d_output_dim, 64)
+        self.linear2 = nn.Linear(64, num_classes)
+        self.relu = nn.ReLU()
+
+    def forward(self, input_ids, dummy_image_input):
+        # Path 1: Embedding -> Conv1d
+        x1 = self.embedding(input_ids)  # (batch_size, seq_len, embedding_dim)
+        x1 = x1.transpose(1, 2)  # (batch_size, embedding_dim, seq_len)
+        x1 = self.relu(self.conv1d(x1))  # (batch_size, 32, seq_len)
+        x1_flat = self.flatten(x1)
+        # Path 2: Conv2d -> Linear
+        x2 = self.relu(self.conv2d(dummy_image_input))  # (batch_size, 16, H, W)
+        x2_flat = self.flatten(x2)  # (batch_size, 16*H*W)
+        # Combine or select paths if making a functional model.
+        # For this test, we mainly care about layer types, so forward might not be fully executed.
+        # Let's use x2_flat for subsequent linear layers.
+        output = self.relu(self.linear1(torch.concat([x1_flat, x2_flat], dim=1)))
+        output = self.linear2(output)
+        return output
+
+
+# Used for testing alora_offsets for aLoRA
+class DummyLM(nn.Module):
+    def __init__(self, vocab_size: int = 10, hidden_dim: int = 8):
+        super().__init__()
+        self.embed = nn.Embedding(vocab_size, hidden_dim)
+        self.linear = nn.Linear(hidden_dim, vocab_size)
+
+    def prepare_inputs_for_generation(self, *args, **kwargs):
+        return kwargs
+
+    def forward(self, X=None, embeds=None, num_beams=None, alora_offsets=None):
+        if X is not None:
+            embeds = self.embed(X)
+        return self.linear(embeds)
+
+
+class MockTransformerWrapper:
+    """Mock class to behave like a transformers model.
+
+    This is needed because the tests initialize the model by calling transformers_class.from_pretrained.
+
+    """
+
+    @classmethod
+    def from_pretrained(cls):
+        # set the seed so that from_pretrained always returns the same model
+        torch.manual_seed(0)
+
+        dtype = torch.float32
+
+        return DummyLM().to(dtype)
+
+
+VARIANT_MAP = {
+    "dora": {
+        LoraLinear: DoraLinearVariant,
+        LoraEmbedding: DoraEmbeddingVariant,
+        LoraConv1d: DoraConv1dVariant,
+        LoraConv2d: DoraConv2dVariant,
+    },
+    "alora": {
+        LoraLinear: ALoraLinearVariant,
+    },
+}
+
+
+TEST_CASES = [
+    (
+        "dora",
+        LoraConfig,
+        {"target_modules": ["linear1", "linear2", "conv1d", "conv2d", "embedding"], "use_dora": True},
+    ),
+    (
+        "alora",
+        LoraConfig,
+        {"target_modules": ["linear1", "linear2"], "alora_invocation_tokens": [1]},
+    ),
+]
+
+
+class TestLoraVariants:
+    @pytest.mark.parametrize("variant_name, config_cls, config_kwargs", TEST_CASES)
+    def test_variant_is_applied_to_layers(self, variant_name, config_cls, config_kwargs):
+        # This test assumes that targeting and replacing layers works and that after `get_peft_model` we
+        # have a model with LoRA layers. We just make sure that each LoRA layer has its variant set and
+        # it is also the correct variant for that layer.
+        base_model = CustomModel()
+        peft_config = config_cls(**config_kwargs)
+        peft_model = get_peft_model(base_model, peft_config)
+
+        layer_type_map = VARIANT_MAP[variant_name]
+
+        for _, module in peft_model.named_modules():
+            if not hasattr(module, "lora_variant"):
+                continue
+
+            # Note that not every variant supports every layer. If it is not mapped it is deemed unsupported and
+            # will not be tested.
+            expected_variant_type = layer_type_map.get(type(module), None)
+            if not expected_variant_type:
+                continue
+
+            assert isinstance(module.lora_variant["default"], expected_variant_type)
+
+    def custom_model_with_loss_backpropagated(self, peft_config):
+        """Returns the CustomModel + PEFT model instance with a dummy loss that was backpropagated once."""
+        base_model = CustomModel()
+        peft_model = get_peft_model(base_model, peft_config)
+
+        x, y = torch.ones(10, 10).long(), torch.ones(10, 1, 10, 10)
+        out = peft_model(x, y)
+        loss = out.sum()
+        loss.backward()
+
+        return base_model, peft_model
+
+    def test_dora_params_have_gradients(self):
+        """Ensure that the parameters added by the DoRA variant are participating in the output computation."""
+        layer_names = ["linear1", "linear2", "conv1d", "conv2d", "embedding"]
+        peft_config = LoraConfig(target_modules=layer_names, use_dora=True)
+        _, peft_model = self.custom_model_with_loss_backpropagated(peft_config)
+
+        for layer in layer_names:
+            assert getattr(peft_model.base_model.model, layer).lora_magnitude_vector["default"].weight.grad is not None
+
+    def test_unregistered_variant_raises_error(self):
+        # 1. Create a config and dummy linear layer
+        config = LoraConfig()
+        base_layer = nn.Linear(10, 10)
+        layer = LoraLinear(base_layer, "default", config, r=8, lora_alpha=8)
+
+        # 2. Monkey-patch the lora_variants property to include a fake variant
+        with patch("peft.tuners.lora.layer.Linear.lora_variants", new_callable=PropertyMock) as mock_variants:
+            mock_variants.return_value = {("fake_unregistered_variant",): None}
+
+            # 3. Assert that the sanity check catches it and throws the right error
+            with pytest.raises(
+                ValueError,
+                match=".*found in lora_variant.*",
+            ):
+                layer.resolve_lora_variant(config=config)
+
+    def test_invalid_variant_combination_raises_error(self):
+        # 1. Create a config with no variants active
+        config = LoraConfig()
+        base_layer = nn.Linear(10, 10)
+        layer = LoraLinear(base_layer, "default", config, r=8, lora_alpha=8)
+
+        # 2. Monkey-patch lora_variants to include a valid tagged combo that isn't active
+        with patch("peft.tuners.lora.layer.Linear.lora_variants", new_callable=PropertyMock) as mock_variants:
+            mock_variants.return_value = {
+                ("use_dora",): None,  # only use_dora is valid, empty combo not listed
+            }
+            # 3. Assert invalid combination error is raised
+            with pytest.raises(ValueError, match="Invalid or unsupported variant combination"):
+                layer.resolve_lora_variant(config=config)
+
+    def test_unsorted_variant_keys_raises_error(self):
+        config = LoraConfig()
+        base_layer = nn.Linear(10, 10)
+        layer = LoraLinear(base_layer, "default", config, r=8, lora_alpha=8)
+
+        with patch("peft.tuners.lora.layer.Linear.lora_variants", new_callable=PropertyMock) as mock_variants:
+            mock_variants.return_value = {
+                ("use_dora", "use_bdlora"): None,
+            }
+            with pytest.raises(ValueError, match="must be sorted tuples"):
+                layer.resolve_lora_variant(config=config)
+
+    def test_multiple_string_variants_in_init_lora_weights(self):
+        """
+        Verify that multiple variant names originating from the same configuration field (init_lora_weights) resolve to
+        different LoraVariant implementations.
+        """
+
+        @dataclasses.dataclass
+        class MockConfig:
+            init_lora_weights: str = dataclasses.field(
+                default="foobar", metadata={"lora_variants": ["mica", "foobar"]}
+            )
+
+        class MockMiCAVariant:
+            pass
+
+        class MockFoobarVariant:
+            pass
+
+        class MockLayer(LoraLayer):
+            @property
+            def lora_variants(self):
+                return {
+                    ("mica",): MockMiCAVariant,
+                    ("foobar",): MockFoobarVariant,
+                }
+
+        layer = MockLayer(base_layer=nn.Linear(10, 10))
+
+        # Resolve and verify the correct variants
+        for value, expected_class in [
+            ("mica", MockMiCAVariant),
+            ("foobar", MockFoobarVariant),
+        ]:
+            config = MockConfig(init_lora_weights=value)
+            resolved_instance = layer.resolve_lora_variant(config=config)
+
+            assert isinstance(resolved_instance, expected_class)
+
+
+class TestActivatedLora:
+    @pytest.mark.parametrize(
+        "input_ids, alora_invocation_tokens, expected_offsets",
+        [
+            ([[0, 1, 2, 3], [0, 4, 5, 6]], [1, 2], [3, None]),
+            ([[1, 2, 1, 2], [0, 4, 1, 2]], [1, 2], [2, 2]),
+            ([[1, 2, 3, 4], [0, 4, 1, 4]], [1, 2], [4, None]),
+            ([[1, 2, 3, 4]], None, [None]),
+        ],
+    )
+    # Verify alora_offsets are calculated correctly
+    def test_calculate_alora_offsets(self, input_ids, alora_invocation_tokens, expected_offsets):
+        config = LoraConfig(task_type=TaskType.CAUSAL_LM, alora_invocation_tokens=alora_invocation_tokens)
+        peft_config = {"default": config}
+
+        # compute offsets
+        offsets = calculate_alora_offsets(peft_config, "default", torch.tensor(input_ids))
+
+        assert offsets == expected_offsets
+
+    @pytest.mark.parametrize(
+        "input_ids, alora_invocations, expected_offsets",
+        [
+            ([[0, 1, 1], [0, 2, 2]], {"a1": [1], "a2": [2]}, [1, 1]),
+            ([[0, 1, 1], [0, 2, 2]], {"a1": [1], "a2": None}, [1, None]),
+        ],
+    )
+    # Verify alora_offsets are correct with adapter names
+    def test_calculate_alora_offsets_with_adapter_names(self, input_ids, alora_invocations, expected_offsets):
+        peft_config = {}
+        for alora_name in alora_invocations.keys():
+            peft_config[alora_name] = LoraConfig(alora_invocation_tokens=alora_invocations[alora_name])
+
+        adapter_names = list(alora_invocations.keys())
+        offsets = calculate_alora_offsets(
+            peft_config, adapter_names[0], torch.tensor(input_ids), adapter_names=adapter_names
+        )
+
+        assert offsets == expected_offsets
+
+    # Verify that the adapter does not modify outputs prior to invocation point
+    def test_alora_activation_matches_base_until_invocation(self):
+        transformers_class = MockTransformerWrapper
+        base_model = transformers_class.from_pretrained()
+        cfg = LoraConfig(target_modules=["linear"], alora_invocation_tokens=[2], init_lora_weights=False)
+        lora_model = get_peft_model(base_model, cfg)
+        lora_model.eval()
+
+        input_ids = torch.tensor([[0, 1, 2, 3]])
+        start = 2
+        with lora_model.disable_adapter():
+            with torch.no_grad():
+                base_out = lora_model(X=input_ids)
+
+        kwargs = get_alora_offsets_for_forward(lora_model, input_ids)
+        with torch.no_grad():
+            lora_out = lora_model(X=input_ids, **kwargs)
+        assert torch.allclose(lora_out[:, :start], base_out[:, :start])
+        assert not torch.allclose(lora_out[:, start:], base_out[:, start:])
+
+    # Verify that warning is given for alora when providing embeddings only
+    def test_input_embeds_warning(self):
+        transformers_class = MockTransformerWrapper
+        base_model = transformers_class.from_pretrained()
+        cfg = LoraConfig(
+            task_type=TaskType.CAUSAL_LM,
+            target_modules=["linear"],
+            alora_invocation_tokens=[2],
+            init_lora_weights=False,
+        )
+        lora_model = get_peft_model(base_model, cfg)
+        lora_model.eval()
+
+        input_ids = torch.tensor([[0, 1, 2, 3]])
+        input_embeds = base_model.embed(input_ids)
+        with pytest.warns(
+            UserWarning,
+            match="Cannot calculate aLoRA offsets when only inputs_embeds are provided. Disabling aLoRA for this forward pass.",
+        ):
+            kwargs = get_alora_offsets_for_forward(lora_model, inputs_embeds=input_embeds)
+        assert kwargs.get("alora_offsets") is None
+        with pytest.warns(
+            UserWarning,
+            match="Cannot calculate aLoRA offsets during generate as input_ids are not available. Disabling aLoRA.",
+        ):
+            kwargs = get_alora_offsets_for_generate(lora_model, inputs_embeds=input_embeds)
+        assert kwargs.get("alora_offsets") is None
+
+    # Verify that error is raised when requesting num_beams > 1 for alora
+    def test_num_beams_error(self):
+        transformers_class = MockTransformerWrapper
+        base_model = transformers_class.from_pretrained()
+        cfg = LoraConfig(target_modules=["linear"], alora_invocation_tokens=[2], init_lora_weights=False)
+        lora_model = get_peft_model(base_model, cfg)
+        lora_model.eval()
+
+        input_ids = torch.tensor([[0, 1, 2, 3]])
+        with pytest.raises(ValueError) as e:
+            with torch.no_grad():
+                lora_out = lora_model(X=input_ids, num_beams=2, alora_offsets=[3])
+        assert "Beam search not yet supported for aLoRA." in str(e.value)
+
+    def test_gradient_checkpointing_double_forward_raises(self):
+        model_id = "trl-internal-testing/tiny-random-LlamaForCausalLM"
+
+        with hub_online_once(model_id):
+            base_model = AutoModelForCausalLM.from_pretrained(model_id)
+            cfg = LoraConfig(task_type=TaskType.CAUSAL_LM, target_modules="all-linear", alora_invocation_tokens=[0])
+            lora_model = get_peft_model(base_model, cfg)
+            lora_model.train()
+
+            lora_model.prepare_model_for_gradient_checkpointing(lora_model)
+            lora_model.gradient_checkpointing_enable()
+
+            inputs = {"input_ids": torch.tensor([[0, 1, 2, 3]])}
+
+            lora_model.forward(**inputs)
+
+            with pytest.raises(ValueError, match="Multiple invocations of PEFT forward hooks.*"):
+                lora_model.forward(**inputs)
+
+    def test_gradient_checkpointing_dpo_doesnt_raise(self):
+        model_id = "trl-internal-testing/tiny-random-LlamaForCausalLM"
+
+        with hub_online_once(model_id):
+            base_model = AutoModelForCausalLM.from_pretrained(model_id)
+            cfg = LoraConfig(task_type=TaskType.CAUSAL_LM, target_modules="all-linear", alora_invocation_tokens=[0])
+            lora_model = get_peft_model(base_model, cfg)
+            lora_model.train()
+
+            lora_model.prepare_model_for_gradient_checkpointing(lora_model)
+            lora_model.gradient_checkpointing_enable()
+
+            inputs = {"input_ids": torch.tensor([[0, 1, 2, 3]])}
+
+            with lora_model.disable_adapter():
+                lora_model.forward(**inputs)
+
+            lora_model.forward(**inputs)
diff --git a/tests/test_lorafa.py b/tests/test_lorafa.py
new file mode 100644
index 0000000..a5afd7e
--- /dev/null
+++ b/tests/test_lorafa.py
@@ -0,0 +1,287 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+import math
+
+import torch
+from torch import nn
+
+from peft import LoraConfig, get_peft_model
+from peft.optimizers import create_lorafa_optimizer
+
+from .testing_utils import torch_device
+
+
+class SimpleNet(nn.Module):
+    def __init__(self, bias=True):
+        super().__init__()
+        self.embedding = nn.Embedding(100, 20)
+        self.layer_norm = nn.LayerNorm(20)
+        self.lin0 = nn.Linear(20, 20, bias=bias)
+        self.relu = nn.ReLU()
+        self.lin1 = nn.Linear(20, 16, bias=bias)
+
+    def forward(self, X):
+        X = self.lin0(self.layer_norm(self.embedding(X)))
+        X = self.relu(X)
+        X = self.lin1(X)
+        return X
+
+
+def _run_lorafa_weight_decay_step(config: LoraConfig, lr: float, weight_decay: float):
+    seed = 42
+
+    torch.manual_seed(seed)
+    model_no_wd = get_peft_model(SimpleNet(), config).to(torch_device)
+    torch.manual_seed(seed)
+    model_wd = get_peft_model(SimpleNet(), config).to(torch_device)
+
+    # Shared setup invariant: both models must start from the same parameters.
+    for (name_no_wd, param_no_wd), (name_wd, param_wd) in zip(
+        model_no_wd.named_parameters(), model_wd.named_parameters()
+    ):
+        assert name_no_wd == name_wd
+        assert torch.equal(param_no_wd, param_wd)
+
+    optimizer_no_wd = create_lorafa_optimizer(
+        model=model_no_wd,
+        r=config.r,
+        lora_alpha=config.lora_alpha,
+        lr=lr,
+        weight_decay=0.0,
+    )
+    optimizer_wd = create_lorafa_optimizer(
+        model=model_wd,
+        r=config.r,
+        lora_alpha=config.lora_alpha,
+        lr=lr,
+        weight_decay=weight_decay,
+    )
+    loss = torch.nn.CrossEntropyLoss()
+
+    # Save initial lora_A weights. Only from one model since both models params are identical
+    initial_lora_A_weights = {
+        name: param.clone() for name, param in model_no_wd.named_parameters() if "lora_A" in name
+    }
+
+    # Generate random input and label using different seeds
+    torch.manual_seed(seed + 1)
+    x = torch.randint(100, (2, 4, 10)).to(torch_device)
+    output_no_wd = model_no_wd(x).permute(0, 3, 1, 2)
+    output_wd = model_wd(x).permute(0, 3, 1, 2)
+    torch.manual_seed(seed + 2)
+    label = torch.randint(16, (2, 4, 10)).to(torch_device)
+
+    # Calculate both losses and perform backward passes
+    loss_value_no_wd = loss(output_no_wd, label)
+    loss_value_no_wd.backward()
+    loss_value_wd = loss(output_wd, label)
+    loss_value_wd.backward()
+
+    non_lora_trainable_names = [
+        name
+        for name, param in model_no_wd.named_parameters()
+        if "lora" not in name and param.requires_grad and param.grad is not None
+    ]
+
+    # Perform both optimizer steps
+    optimizer_no_wd.step()
+    optimizer_wd.step()
+
+    return (
+        dict(model_no_wd.named_parameters()),
+        dict(model_wd.named_parameters()),
+        initial_lora_A_weights,
+        non_lora_trainable_names,
+    )
+
+
+def test_lorafa_init_default():
+    """
+    Test if the optimizer is correctly created
+    """
+    lora_rank = 16
+    lora_alpha = 32
+    lr = 7e-5
+
+    model = SimpleNet()
+    config = LoraConfig(
+        r=lora_rank,
+        lora_alpha=lora_alpha,
+        target_modules=["lin0", "lin1"],
+        bias="none",
+    )
+    model = get_peft_model(model, config)
+    optimizer = create_lorafa_optimizer(model=model, r=lora_rank, lora_alpha=lora_alpha, lr=lr)
+
+    assert math.isclose(optimizer.param_groups[0]["scaling_factor"], lora_alpha / lora_rank, rel_tol=1e-9, abs_tol=0.0)
+
+    all_A_fixed = True
+    all_B_trainable = True
+
+    assert optimizer is not None
+
+    for name, param in model.named_parameters():
+        if "lora_A" in name:
+            all_A_fixed &= not param.requires_grad
+        elif "lora_B" in name:
+            all_B_trainable &= param.requires_grad
+
+    assert all_A_fixed and all_B_trainable
+
+
+def test_lorafa_init_rslora():
+    """
+    Test if the optimizer is correctly created when use_rslora = True
+    """
+    lora_rank = 16
+    lora_alpha = 32
+    lr = 7e-5
+
+    model = SimpleNet()
+    config = LoraConfig(
+        r=lora_rank,
+        lora_alpha=lora_alpha,
+        target_modules=["lin0", "lin1"],
+        bias="none",
+    )
+    model = get_peft_model(model, config)
+    optimizer = create_lorafa_optimizer(model=model, r=lora_rank, lora_alpha=lora_alpha, lr=lr, use_rslora=True)
+    assert math.isclose(
+        optimizer.param_groups[0]["scaling_factor"], lora_alpha / math.sqrt(lora_rank), rel_tol=1e-9, abs_tol=0.0
+    )
+
+
+def test_LoraFAOptimizer_step():
+    """
+    Test if the optimizer's step function runs without any exception and checks specific conditions on lora_A and
+    lora_B weights.
+    """
+    lora_rank = 16
+    lora_alpha = 32
+    lr = 7e-5
+    num_steps = 5
+
+    model = SimpleNet()
+    config = LoraConfig(
+        r=lora_rank,
+        lora_alpha=lora_alpha,
+        target_modules=["lin0", "lin1"],
+        bias="none",
+    )
+    model = get_peft_model(model, config).to(torch_device)
+    optimizer = create_lorafa_optimizer(model=model, r=16, lora_alpha=32, lr=7e-5)
+    loss = torch.nn.CrossEntropyLoss()
+
+    # Save initial weights of lora_A
+    initial_lora_A_weights = {name: param.clone() for name, param in model.named_parameters() if "lora_A" in name}
+    # Ensure lora_B is initialized to zero
+    for name, param in model.named_parameters():
+        if "lora_B" in name:
+            assert torch.all(param == 0), f"lora_B weights not initialized to zero for {name}"
+
+    for _ in range(num_steps):  # Run the optimizer step multiple times
+        # Generate random input and label for each step
+        x = torch.randint(100, (2, 4, 10)).to(torch_device)
+        output = model(x).permute(0, 3, 1, 2)
+        label = torch.randint(16, (2, 4, 10)).to(torch_device)
+
+        # Calculate loss and perform backward pass
+        loss_value = loss(output, label)
+        loss_value.backward()
+
+        # Perform optimizer step
+        optimizer.step()
+
+        # Zero the gradients after each step to prevent accumulation
+        optimizer.zero_grad()
+
+    # Check if lora_A weights have not changed
+    for name, param in model.named_parameters():
+        if "lora_A" in name:
+            assert torch.equal(param, initial_lora_A_weights[name]), f"lora_A weights changed for {name}"
+
+    # Check if lora_B weights are non-zero
+    for name, param in model.named_parameters():
+        if "lora_B" in name:
+            assert torch.any(param != 0), f"lora_B weights are still zero for {name}"
+
+
+def test_lorafa_weight_decay_decoupled_update_lora_b():
+    """
+    Test that one optimizer step applies decoupled weight decay to LoRA B weights.
+    """
+    lora_rank = 16
+    lora_alpha = 32
+    # Stronger lr and weight_decay to make the decay effect more pronounced for testing
+    lr = 1e-2
+    weight_decay = 1.0
+    config = LoraConfig(
+        r=lora_rank,
+        lora_alpha=lora_alpha,
+        target_modules=["lin0", "lin1"],
+        bias="none",
+    )
+    params_no_wd, params_wd, initial_lora_A_weights, _ = _run_lorafa_weight_decay_step(config, lr, weight_decay)
+
+    # Compute the scaling factor for the expected relation of with and without weight decay
+    scale = 1.0 - lr * weight_decay
+
+    # Check if lora_A weights have not changed
+    for name, param in params_no_wd.items():
+        if "lora_A" in name:
+            assert torch.equal(param, initial_lora_A_weights[name]), f"lora_A weights changed for {name}"
+
+    # Check if lora_B weights are non-zero and if they follow the expected relation
+    for name, param_no_wd in params_no_wd.items():
+        if "lora_B" in name:
+            assert torch.any(param_no_wd != 0), f"lora_B weights are still zero for {name}"
+            assert torch.allclose(params_wd[name], param_no_wd * scale, rtol=1e-5, atol=1e-6), (
+                f"lora_B weights for {name} do not match decoupled weight decay scaling"
+            )
+
+
+def test_lorafa_weight_decay_decoupled_update_non_lora_params():
+    """
+    Test that one optimizer step applies decoupled weight decay to non-LoRA trainable parameters.
+    """
+    lora_rank = 16
+    lora_alpha = 32
+    # Stronger lr and weight_decay to make the decay effect more pronounced for testing
+    lr = 1e-2
+    weight_decay = 1.0
+    config = LoraConfig(
+        r=lora_rank,
+        lora_alpha=lora_alpha,
+        target_modules=["lin0", "lin1"],
+        bias="all",  # Include bias to check non-LoRA trainable parameters
+    )
+    params_no_wd, params_wd, _, non_lora_trainable_names = _run_lorafa_weight_decay_step(config, lr, weight_decay)
+
+    # Compute the scaling factor for the expected relation of with and without weight decay
+    scale = 1.0 - lr * weight_decay
+
+    # Sanity check: non-LoRA trainable parameters
+    assert non_lora_trainable_names, "Expected at least one non-LoRA trainable parameter with gradients"
+
+    # Check if all non-LoRA params also follow the expected relation
+    for name in non_lora_trainable_names:
+        assert torch.allclose(
+            params_wd[name],
+            params_no_wd[name] * scale,
+            rtol=1e-5,
+            atol=1e-6,
+        ), f"{name} does not match decoupled weight decay scaling"
diff --git a/tests/test_loraplus.py b/tests/test_loraplus.py
new file mode 100644
index 0000000..64bb8bc
--- /dev/null
+++ b/tests/test_loraplus.py
@@ -0,0 +1,99 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+from __future__ import annotations
+
+import torch
+from torch import nn
+
+from peft.import_utils import is_bnb_available
+from peft.optimizers import create_loraplus_optimizer
+
+from .testing_utils import require_bitsandbytes, torch_device
+
+
+if is_bnb_available():
+    import bitsandbytes as bnb
+
+
+class SimpleNet(nn.Module):
+    def __init__(self, bias=True):
+        super().__init__()
+        self.embedding = nn.Embedding(100, 20)
+        self.layer_norm = nn.LayerNorm(20)
+        self.lin0 = nn.Linear(20, 20, bias=bias)
+        self.relu = nn.ReLU()
+        self.lin1 = nn.Linear(20, 16, bias=bias)
+
+    def forward(self, X):
+        X = self.lin0(self.layer_norm(self.embedding(X)))
+        X = self.relu(X)
+        X = self.lin1(X)
+        return X
+
+
+@require_bitsandbytes
+def test_lora_plus_helper_sucess():
+    model = SimpleNet()
+    optimizer_cls = bnb.optim.Adam8bit
+    lr = 5e-5
+    optim_config = {
+        "eps": 1e-6,
+        "betas": (0.9, 0.999),
+        "loraplus_weight_decay": 0.0,
+    }
+    loraplus_lr_ratio = 1.2
+    loraplus_lr_embedding = 1e-6
+    optim = create_loraplus_optimizer(
+        model=model,
+        optimizer_cls=optimizer_cls,
+        lr=lr,
+        loraplus_lr_ratio=loraplus_lr_ratio,
+        loraplus_lr_embedding=loraplus_lr_embedding,
+        **optim_config,
+    )
+    assert optim is not None
+    assert len(optim.param_groups) == 4
+    assert optim.param_groups[0]["lr"] == lr
+    assert optim.param_groups[1]["lr"] == loraplus_lr_embedding
+    assert optim.param_groups[2]["lr"] == optim.param_groups[3]["lr"] == (lr * loraplus_lr_ratio)
+
+
+@require_bitsandbytes
+def test_lora_plus_optimizer_sucess():
+    """
+    Test if the optimizer is correctly created and step function runs without any exception
+    """
+    optimizer_cls = bnb.optim.Adam8bit
+    optim_config = {
+        "eps": 1e-6,
+        "betas": (0.9, 0.999),
+        "loraplus_weight_decay": 0.0,
+    }
+    model: SimpleNet = SimpleNet().to(torch_device)
+    optim = create_loraplus_optimizer(
+        model=model,
+        optimizer_cls=optimizer_cls,
+        lr=5e-5,
+        loraplus_lr_ratio=1.2,
+        loraplus_lr_embedding=1e-6,
+        **optim_config,
+    )
+    loss = torch.nn.CrossEntropyLoss()
+    bnb.optim.GlobalOptimManager.get_instance().register_parameters(model.parameters())
+    x = torch.randint(100, (2, 4, 10)).to(torch_device)
+    output = model(x).permute(0, 3, 1, 2)
+    label = torch.randint(16, (2, 4, 10)).to(torch_device)
+    loss_value = loss(output, label)
+    loss_value.backward()
+    optim.step()
diff --git a/tests/test_low_level_api.py b/tests/test_low_level_api.py
new file mode 100644
index 0000000..43d80b6
--- /dev/null
+++ b/tests/test_low_level_api.py
@@ -0,0 +1,730 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+import copy
+import platform
+import re
+
+import pytest
+import torch
+from diffusers import StableDiffusionPipeline
+from torch import nn
+from transformers import (
+    AutoModel,
+    AutoModelForCausalLM,
+    AutoModelForSeq2SeqLM,
+    AutoModelForSequenceClassification,
+    CLIPTextModel,
+    CLIPTextModelWithProjection,
+)
+
+from peft import (
+    AdaLoraConfig,
+    IA3Config,
+    LoKrConfig,
+    LoraConfig,
+    RandLoraConfig,
+    get_peft_model,
+    get_peft_model_state_dict,
+    inject_adapter_in_model,
+    set_peft_model_state_dict,
+)
+from peft.tuners import lora
+from peft.utils import ModulesToSaveWrapper
+
+from .testing_utils import hub_online_once
+
+
+class DummyModel(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.embedding = torch.nn.Embedding(10, 10)
+        self.linear = torch.nn.Linear(10, 10)
+        self.linear2 = torch.nn.Linear(10, 10, bias=True)
+        self.lm_head = torch.nn.Linear(10, 10)
+
+    def forward(self, input_ids):
+        x = self.embedding(input_ids)
+        x = self.linear(x)
+        x = self.lm_head(x)
+        return x
+
+
+class TestLowLevelFunctional:
+    # Some simple tests for the low level API
+    @pytest.fixture
+    def model(self):
+        model = DummyModel()
+
+        lora_config = LoraConfig(
+            lora_alpha=16,
+            lora_dropout=0.1,
+            r=64,
+            bias="none",
+            target_modules=["linear"],
+        )
+
+        return inject_adapter_in_model(lora_config, model)
+
+    def test_inject_adapter_in_model(self, model):
+        dummy_inputs = torch.LongTensor([[0, 1, 2, 3, 4, 5, 6, 7]])
+        _ = model(dummy_inputs)
+
+        for name, module in model.named_modules():
+            if name == "linear":
+                assert hasattr(module, "lora_A")
+                assert hasattr(module, "lora_B")
+
+    def test_get_peft_model_state_dict(self, model):
+        peft_state_dict = get_peft_model_state_dict(model)
+
+        for key in peft_state_dict.keys():
+            assert "lora" in key
+
+    def test_modules_to_save(self):
+        model = DummyModel()
+
+        lora_config = LoraConfig(
+            lora_alpha=16,
+            lora_dropout=0.1,
+            r=64,
+            bias="none",
+            target_modules=["linear"],
+            modules_to_save=["embedding", "linear2"],
+        )
+
+        model = inject_adapter_in_model(lora_config, model)
+
+        for name, module in model.named_modules():
+            if name == "linear":
+                assert hasattr(module, "lora_A")
+                assert hasattr(module, "lora_B")
+            elif name in ["embedding", "linear2"]:
+                assert isinstance(module, ModulesToSaveWrapper)
+
+        state_dict = get_peft_model_state_dict(model)
+
+        assert "embedding.weight" in state_dict.keys()
+
+        assert hasattr(model.embedding, "weight")
+
+        assert hasattr(model.linear2, "weight")
+        assert hasattr(model.linear2, "bias")
+
+
+class TestInjectAdapterFromStateDict:
+    # The inject_adapter_in_model function can determine the target modules based on the LoraConfig (default) or based
+    # on a state_dict (or rather, the state_dict keys). Here we test that the latter works as expected.
+
+    # We test a subset of model classes and PEFT configs, testing everything would be excessive
+    @pytest.mark.parametrize(
+        "model_cls_and_id",
+        [
+            (AutoModelForCausalLM, "trl-internal-testing/tiny-random-LlamaForCausalLM"),
+            (AutoModel, "peft-internal-testing/tiny-random-BertModel"),
+            (AutoModelForSeq2SeqLM, "peft-internal-testing/tiny-random-BartForConditionalGeneration"),
+            (AutoModelForSequenceClassification, "peft-internal-testing/tiny-random-RobertaForSequenceClassification"),
+        ],
+        ids=["Llama", "Bert", "Bart", "Roberta"],
+    )
+    @pytest.mark.parametrize(
+        "config",
+        [
+            AdaLoraConfig(total_step=5),
+            IA3Config(),
+            LoKrConfig(),
+            LoraConfig(),
+            RandLoraConfig(),
+        ],
+        ids=["AdaLoRA", "IA3", "LoKr", "LoRA", "RandLoRA"],
+    )
+    def test_inject_from_state_dict_and_from_config_target_same_layers(self, model_cls_and_id, config, recwarn):
+        model_cls, model_id = model_cls_and_id
+        config = copy.deepcopy(config)  # since PEFT may mutate it
+
+        with hub_online_once(model_id):
+            # use config for injection
+            model = model_cls.from_pretrained(model_id)
+            model = inject_adapter_in_model(config, model)
+            sd_before = get_peft_model_state_dict(model)
+            del model
+
+            model = model_cls.from_pretrained(model_id)
+            # get other warnings, if any, out of the way
+            recwarn.clear()
+            # assure that this doesn't cause any warnings
+            model = inject_adapter_in_model(config, model, state_dict=sd_before)
+            assert not recwarn.list
+
+            sd_after = get_peft_model_state_dict(model)
+
+            # We expect the same keys and the same shapes of the weights. Don't check the values: injection is only
+            # about creating the PEFT adapter, not about loading the actual weights
+            assert len(sd_before) > 0
+            assert sd_before.keys() == sd_after.keys()
+            for key in sd_before.keys():
+                assert sd_before[key].shape == sd_after[key].shape
+
+    def test_inject_from_state_dict_transformers(self):
+        model_id = "peft-internal-testing/opt-125m"
+        config = LoraConfig()
+
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            model.add_adapter(config)
+            sd_before = get_peft_model_state_dict(model)
+            del model
+
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            model = inject_adapter_in_model(config, model, state_dict=sd_before)
+            sd_after = get_peft_model_state_dict(model)
+
+            # We expect the same keys and the same shapes of the weights. Don't check the values: injection is only
+            # about creating the PEFT adapter, not about loading the actual weights
+            assert len(sd_before) > 0
+            assert sd_before.keys() == sd_after.keys()
+            for key in sd_before.keys():
+                assert sd_before[key].shape == sd_after[key].shape
+
+    def test_inject_from_state_dict_transformers_irregular_targets(self):
+        # ensure that this works even if an "irregular" pattern is used, i.e. only targeting some modules on some layers
+        model_id = "peft-internal-testing/opt-125m"
+        config = LoraConfig(
+            target_modules=r".*\.[0-5]\.self_attn\.v_proj|.*\.[4-7]\.self_attn\.k_proj",
+        )
+
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            model.add_adapter(config)
+            sd_before = get_peft_model_state_dict(model)
+            del model
+
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            model = inject_adapter_in_model(config, model, state_dict=sd_before)
+            sd_after = get_peft_model_state_dict(model)
+
+            # We expect the same keys and the same shapes of the weights. Don't check the values: injection is only
+            # about creating the PEFT adapter, not about loading the actual weights
+            assert len(sd_before) > 0
+            assert sd_before.keys() == sd_after.keys()
+            for key in sd_before.keys():
+                assert sd_before[key].shape == sd_after[key].shape
+
+    def test_inject_from_state_dict_transformers_target_parameters_raises(self):
+        # Injecting from state_dict does not correctly identify target_parameters. This is because, just from looking at
+        # the state_dict, we cannot tell if the user intends to use target_modules or target_parameters. Currently, we
+        # just assume the former, thus applying normal lora.Linear etc. layers instead of lora.ParamWrapper. When we
+        # detect that the user tries to do this, we raise an error.
+        model_id = "peft-internal-testing/opt-125m"
+        config = LoraConfig(target_modules=[], target_parameters=["q_proj.weight", "v_proj.weight"])
+
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            model.add_adapter(config)
+            sd = get_peft_model_state_dict(model)
+            del model
+
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            msg = "Trying to inject a PEFT adapter from a state_dict but the PEFT config uses `target_parameters`"
+            with pytest.raises(ValueError, match=msg):
+                inject_adapter_in_model(config, model, state_dict=sd)
+
+    @pytest.mark.xfail(
+        reason="Loading from state_dict with target_parameters fails", raises=AssertionError, strict=True
+    )
+    def test_inject_from_state_dict_transformers_target_parameters_fails(self):
+        # Injecting from state_dict does not correctly identify target_parameters. This is because, just from looking at
+        # the state_dict, we cannot tell if the user intends to use target_modules or target_parameters. Currently, we
+        # just assume the former, thus applying normal lora.Linear etc. layers instead of lora.ParamWrapper. When we
+        # don't detect that the user tries to do this, there is nothing that can be done.
+        model_id = "peft-internal-testing/opt-125m"
+        config = LoraConfig(target_modules=[], target_parameters=["q_proj.weight", "v_proj.weight"])
+
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            model.add_adapter(config)
+            # sanity check:
+            for name, module in model.named_modules():
+                if name.endswith((".q_proj", ".v_proj")):
+                    assert isinstance(module, lora.ParamWrapper)
+
+            sd_before = get_peft_model_state_dict(model)
+            del model
+
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            config = LoraConfig()  # no target_parameters defined, we cannot know the original intent
+            model = inject_adapter_in_model(config, model, state_dict=sd_before)
+            sd_after = get_peft_model_state_dict(model)
+
+            # this fails, we get lora.Linear instances
+            for name, module in model.named_modules():
+                if name.endswith((".q_proj", ".v_proj")):
+                    assert isinstance(module, lora.ParamWrapper)
+
+    def test_inject_from_state_dict_stable_diffusion(self):
+        # same test as above, but with stable diffusion model and only testing LoRA
+        model_id = "hf-internal-testing/tiny-sd-pipe"
+        config_text_encoder = LoraConfig(target_modules=["k_proj", "q_proj", "v_proj", "out_proj", "fc1", "fc2"])
+        config_unet = LoraConfig(
+            target_modules=[
+                "proj_in",
+                "proj_out",
+                "to_k",
+                "to_q",
+                "to_v",
+                "to_out.0",
+                "ff.net.0.proj",
+                "ff.net.2",
+            ]
+        )
+        with hub_online_once(model_id):
+            pipe = StableDiffusionPipeline.from_pretrained(model_id)
+            pipe.text_encoder.add_adapter(config_text_encoder)
+            pipe.unet.add_adapter(config_unet)
+
+            sd_te_before = get_peft_model_state_dict(pipe.text_encoder)
+            sd_unet_before = get_peft_model_state_dict(pipe.unet)
+            del pipe
+
+            pipe = StableDiffusionPipeline.from_pretrained(model_id)
+            inject_adapter_in_model(config_text_encoder, pipe.text_encoder, state_dict=sd_te_before)
+            inject_adapter_in_model(config_unet, pipe.unet, state_dict=sd_unet_before)
+
+            sd_te_after = get_peft_model_state_dict(pipe.text_encoder)
+            sd_unet_after = get_peft_model_state_dict(pipe.unet)
+
+            # We expect the same keys and the same shapes of the weights. Don't check the values: injection is only
+            # about creating the PEFT adapter, not about loading the actual weights
+            assert len(sd_te_before) > 0
+            assert sd_te_before.keys() == sd_te_after.keys()
+            for key in sd_te_before.keys():
+                assert sd_te_before[key].shape == sd_te_after[key].shape
+
+            assert len(sd_unet_before) > 0
+            assert sd_unet_before.keys() == sd_unet_after.keys()
+            for key in sd_unet_before.keys():
+                assert sd_unet_before[key].shape == sd_unet_after[key].shape
+
+    def test_inject_from_state_dict_low_cpu_mem_usage(self):
+        model_id = "peft-internal-testing/opt-125m"
+        config = LoraConfig()
+
+        with hub_online_once(model_id):
+            # use config for injection
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            model = inject_adapter_in_model(config, model)
+            sd_before = get_peft_model_state_dict(model)
+            del model
+
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            model = inject_adapter_in_model(config, model, state_dict=sd_before, low_cpu_mem_usage=True)
+            # all PEFT parameters should be on meta device
+            assert {p.device.type for p in get_peft_model_state_dict(model).values()} == {"meta"}
+
+    def test_inject_from_state_dict_missing_keys_warning(self):
+        # check that if the PEFT config specifies **more** target modules than the state_dict, we get a warning for that
+        model_id = "peft-internal-testing/opt-125m"
+        config = LoraConfig()
+
+        with hub_online_once(model_id):
+            # use config for injection
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            model = inject_adapter_in_model(config, model)
+            sd_before = get_peft_model_state_dict(model)
+            del model
+
+            # delete a keys for one module from state_dict
+            del sd_before["model.decoder.layers.5.self_attn.q_proj.lora_A.weight"]
+            del sd_before["model.decoder.layers.5.self_attn.q_proj.lora_B.weight"]
+
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            msg = re.escape(
+                "While injecting the PEFT adapters, an inconsistency was discovered between the PEFT config and "
+                "the provided state_dict. This is not necessarily an issue and can be ignored if this was the "
+                "intent. The PEFT config contained these additional target modules: "
+                "['model.decoder.layers.5.self_attn.q_proj']. "
+            )
+
+            with pytest.warns(RuntimeWarning, match=msg):  # as rec:#(UserWarning, match=msg) as rec:
+                model = inject_adapter_in_model(config, model, state_dict=sd_before, low_cpu_mem_usage=True)
+
+            # besides the warning, the rest of the injection should work
+            sd_after = get_peft_model_state_dict(model)
+            assert len(sd_before) > 0
+            assert sd_before.keys() == sd_after.keys()
+            for key in sd_before.keys():
+                assert sd_before[key].shape == sd_after[key].shape
+
+    def test_inject_from_state_dict_extra_keys_warning(self):
+        # check that if the PEFT config specifies **fewer** target modules than the state_dict, we get a warning for that
+        model_id = "peft-internal-testing/opt-125m"
+        config = LoraConfig()
+
+        with hub_online_once(model_id):
+            # use config for injection
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            model = inject_adapter_in_model(config, model)
+            sd_before = get_peft_model_state_dict(model)
+            del model
+
+            # remove q_proj of layer 5 from the PEFT config
+            config.exclude_modules = ["model.decoder.layers.5.self_attn.q_proj"]
+
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            msg = re.escape(
+                "While injecting the PEFT adapters, an inconsistency was discovered between the PEFT config and "
+                "the provided state_dict. This is not necessarily an issue and can be ignored if this was the "
+                "intent. The state_dict contained these additional target modules: "
+                "['model.decoder.layers.5.self_attn.q_proj']. "
+            )
+
+            with pytest.warns(RuntimeWarning, match=msg):
+                model = inject_adapter_in_model(config, model, state_dict=sd_before, low_cpu_mem_usage=True)
+
+            # besides the warning, the rest of the injection should work
+            sd_after = get_peft_model_state_dict(model)
+            assert len(sd_before) > 0
+            assert sd_before.keys() == sd_after.keys()
+            for key in sd_before.keys():
+                assert sd_before[key].shape == sd_after[key].shape
+
+    @pytest.mark.skipf(platform.system() != "Linux", reason="Run torch.compile tests only on Linux")
+    @pytest.mark.parametrize("compile_initial_model", [False, True])
+    def test_inject_from_state_dict_compiled_model(self, compile_initial_model):
+        # If we directly inject the adapter into the model from a `state_dict`, if the model is compiled, the
+        # keys would not match because they contain the `'_orig_mod.'` prefix from the compilation. See #2957.
+        model_id = "trl-internal-testing/tiny-random-LlamaForCausalLM"
+        config = LoraConfig()
+
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            if compile_initial_model:
+                # we want to test both cases: the initial model already being compiled and not
+                model = torch.compile(model)
+            model.add_adapter(config)
+            sd_before = get_peft_model_state_dict(model)
+            del model
+
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            model = torch.compile(model)
+            model = inject_adapter_in_model(config, model, state_dict=sd_before)
+            sd_after = get_peft_model_state_dict(model)
+
+            if not compile_initial_model:
+                # if initial model was not compiled, remove the _orig_mod. prefix for loaded model for the comparison to
+                # work
+                sd_after = {k.removeprefix("_orig_mod."): v for k, v in sd_after.items()}
+
+            # We expect the same keys and the same shapes of the weights. Don't check the values: injection is only
+            # about creating the PEFT adapter, not about loading the actual weights
+            assert len(sd_before) > 0
+            assert sd_before.keys() == sd_after.keys()
+            for key in sd_before.keys():
+                assert sd_before[key].shape == sd_after[key].shape
+
+    def test_inject_from_state_dict_low_cpu_mem_usage_with_weight_conversion(self):
+        # Tests if we can inject LoRA state dict with low_cpu_mem_usage for a model that uses Transformers weight
+        # conversion. This checks a regression reported by Sayak of this Diffusers test:
+        # tests/lora/test_lora_layers_flux.py::FluxLoRATests::test_low_cpu_mem_usage_with_injection
+        config = LoraConfig(target_modules=["q_proj", "v_proj"])
+        # must be a model with `get_checkpoint_conversion_mapping(model_type) != None`
+        model_id = "peft-internal-testing/tiny-clip-text-2"
+
+        with hub_online_once(model_id):
+            model = CLIPTextModel.from_pretrained(model_id)
+            inject_adapter_in_model(config, model, low_cpu_mem_usage=True)
+            assert all(p.device.type == "meta" for n, p in model.named_parameters() if "lora." in n)
+
+            state_dict = get_peft_model_state_dict(model)
+            state_dict_no_meta = {k: torch.randn(v.shape, dtype=v.dtype) for k, v in state_dict.items()}
+            set_peft_model_state_dict(model, state_dict_no_meta, low_cpu_mem_usage=True)
+            assert not any(p.device.type == "meta" for p in model.parameters())
+
+    def test_inject_from_state_dict_model_with_weight_conversion(self):
+        # similar test to test_inject_from_state_dict_low_cpu_mem_usage_with_weight_conversion but without
+        # low_cpu_mem_usage
+        config = LoraConfig(target_modules=["q_proj", "v_proj"])
+        # must be a model with `get_checkpoint_conversion_mapping(model_type) != None`
+        model_id = "peft-internal-testing/tiny-clip-text-2"
+
+        with hub_online_once(model_id):
+            model = CLIPTextModel.from_pretrained(model_id)
+            inject_adapter_in_model(config, model)
+            # sanity check:
+            assert (model.encoder.layers[0].self_attn.v_proj.lora_B.default.weight == 0).all()
+
+            state_dict = get_peft_model_state_dict(model)
+            state_dict = {k: torch.ones_like(v) * 555 for k, v in state_dict.items()}
+            load_result = set_peft_model_state_dict(model, state_dict)
+
+            assert not load_result.unexpected_keys
+            # base model weights may be missing, but LoRA weights should never be missing
+            assert not any("lora" in k for k in load_result.missing_keys)
+
+            # sanity check:
+            assert (model.encoder.layers[0].self_attn.v_proj.lora_B.default.weight == 555).all()
+
+    def test_prefix_removal_is_undone(self):
+        # See discussion starting here: https://github.com/huggingface/peft/pull/3212#issuecomment-4402677775.
+        # For some models like CLIPTextModelWithProjection, transformers would add a removal of the 'text_model.' prefix
+        # to the conversions, but this removal is incorrect. Therefore, there is a logic in transformers to undo the
+        # removal if there is not entry in the state_dict for the renamed key. This logic was missing in PEFT, resulting
+        # in missing and unexpected keys.
+        config = LoraConfig(target_modules=["q_proj", "v_proj"])
+        model_id = "peft-internal-testing/tiny-clip-text-2"
+
+        with hub_online_once(model_id):
+            model = CLIPTextModelWithProjection.from_pretrained(model_id)
+            inject_adapter_in_model(config, model)
+            # sanity check:
+            assert (model.text_model.encoder.layers[0].self_attn.v_proj.lora_B.default.weight == 0).all()
+
+            state_dict = get_peft_model_state_dict(model)
+            state_dict = {k: torch.ones_like(v) * 555 for k, v in state_dict.items()}
+            load_result = set_peft_model_state_dict(model, state_dict)
+
+            assert not load_result.unexpected_keys
+            # base model weights may be missing, but LoRA weights should never be missing
+            assert not any("lora" in k for k in load_result.missing_keys)
+
+            # sanity check:
+            assert (model.text_model.encoder.layers[0].self_attn.v_proj.lora_B.default.weight == 555).all()
+
+
+class TestPeftStateDict:
+    # Test some edge cases around getting and setting the PEFT state_dict. There are potential sources of errors there
+    # because the adapter_name is removed from/added to the state_dict keys.
+    def test_get_peft_model_state_dict_removes_adapter_name(self):
+        # ensure that the adapter name, "default", is removed from the state_dict
+        model_id = "peft-internal-testing/tiny-random-OPTForCausalLM"
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+
+        # note: lora targets q_proj and v_proj; add in an auxiliary module for good measure
+        model = get_peft_model(model, LoraConfig(modules_to_save=["lm_head"]))
+        sd = get_peft_model_state_dict(model)
+        assert len(sd) > 1  # sanity check
+        assert not any("default" in key for key in sd)
+
+    def test_get_peft_model_state_dict_removes_non_defaul_adapter_name(self):
+        # ensure that the adapter name is removed from the state_dict, even if it's not "default"
+        model_id = "peft-internal-testing/tiny-random-OPTForCausalLM"
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+
+        model = get_peft_model(model, LoraConfig(modules_to_save=["lm_head"]), adapter_name="other")
+        sd = get_peft_model_state_dict(model, adapter_name="other")
+        assert len(sd) > 1  # sanity check
+        assert not any("other" in key for key in sd)
+
+    def test_get_peft_model_state_dict_removes_adapter_name_when_same_as_module_name(self):
+        # here the adapter is named "v_proj", which is the same name as some modules targeted with lora in the model,
+        # which is nefarious
+        model_id = "peft-internal-testing/tiny-random-OPTForCausalLM"
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+
+        config = LoraConfig(modules_to_save=["lm_head"], target_modules=["v_proj"])
+        model = get_peft_model(model, config, adapter_name="v_proj")
+        sd = get_peft_model_state_dict(model, adapter_name="v_proj")
+        assert len(sd) > 1  # sanity check
+        for key in sd:
+            # assert that the adapter_name was indeed removed
+            assert not key.endswith("lora_A.v_proj.weight")
+            assert not key.endswith("lora_B.v_proj.weight")
+            assert not key.endswith("modules_to_save.v_proj.weight")
+            # assert that the module name was not stripped completely from the key
+            assert ("v_proj" in key) or ("q_proj" in key) or ("lm_head") in key
+
+    def check_peft_model_weights_loaded_correctly(self, inner_model_cls, config, nested, adapter_name="default"):
+        # Runs checks that a roundtrip of get_peft_model_state_dict and set_peft_model_state_dict results in the same
+        # model (same outputs and same weights).
+        class Outer(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.inner = inner_model_cls()
+
+            def forward(self, x):
+                return self.inner(x)
+
+        if nested:
+            # add another layer of nesting
+            model_cls = Outer
+        else:
+            model_cls = inner_model_cls
+
+        x = torch.randn(1, 5)
+
+        torch.manual_seed(0)
+        base_model = model_cls()
+        with torch.inference_mode():
+            base_out = base_model(x)
+
+        torch.manual_seed(42)
+        model = get_peft_model(base_model, config, adapter_name=adapter_name)
+        with torch.inference_mode():
+            peft_out = model(x)
+        # sanity check: peft adapter has an effect
+        assert not torch.allclose(base_out, peft_out, atol=1e-6)
+
+        sd = get_peft_model_state_dict(model, adapter_name=adapter_name)
+
+        torch.manual_seed(0)
+        base_model = model_cls()
+        torch.manual_seed(42 + 1)  # ensure we start with a different, randomly initialized PEFT model
+        model_new = get_peft_model(base_model, config, adapter_name=adapter_name)
+        with torch.inference_mode():
+            peft_new = model_new(x)
+        assert not torch.allclose(peft_out, peft_new, atol=1e-6)
+
+        set_peft_model_state_dict(model_new, sd, adapter_name=adapter_name)
+        with torch.inference_mode():
+            peft_out_loaded = model_new(x)
+        assert torch.allclose(peft_out, peft_out_loaded, atol=1e-6)
+
+        sd_new = get_peft_model_state_dict(model, adapter_name=adapter_name)
+        assert sd.keys() == sd_new.keys()
+        for key, val in sd.items():
+            val_new = sd_new[key]
+            torch.allclose(val, val_new)
+
+    @pytest.mark.parametrize("nested", [False, True])
+    def test_get_and_set_peft_model_state_dict_normal_names(self, nested):
+        # In this test, there is no edge case. Therefore, this test is basically the "control group" for the subsequent
+        # tests (if this test were to fail, it means the testing code itself is wrong).
+        class MyModel(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.foo_linear = nn.Linear(5, 5)
+                self.foo_baz = nn.Linear(5, 5)
+                self.baz_foo = nn.Linear(5, 5)
+                self.foo_baz_foo = nn.Linear(5, 5)
+                self.baz_foo_baz = nn.Linear(5, 5)
+
+            def forward(self, x):
+                x = self.foo_linear(x)
+                x = self.foo_baz(x)
+                x = self.baz_foo(x)
+                x = self.foo_baz_foo(x)
+                x = self.baz_foo_baz(x)
+                return x
+
+        config = LoraConfig(
+            target_modules=["foo_linear", "foo_baz", "baz_foo", "foo_baz_foo", "baz_foo_baz"], init_lora_weights=False
+        )
+        self.check_peft_model_weights_loaded_correctly(MyModel, config, nested=nested)
+
+    @pytest.mark.parametrize("nested", [False, True])
+    def test_get_and_set_peft_model_state_dict_peft_prefix_in_module_name(self, nested):
+        # Here we have a model with some modules containing "lora" in their name.
+        class MyModel(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.foo_linear = nn.Linear(5, 5)
+                self.foo_lora = nn.Linear(5, 5)
+                self.lora_foo = nn.Linear(5, 5)
+                self.foo_lora_foo = nn.Linear(5, 5)
+                self.lora_foo_lora = nn.Linear(5, 5)
+
+            def forward(self, x):
+                x = self.foo_linear(x)
+                x = self.foo_lora(x)
+                x = self.lora_foo(x)
+                x = self.foo_lora_foo(x)
+                x = self.lora_foo_lora(x)
+                return x
+
+        config = LoraConfig(
+            target_modules=["foo_linear", "foo_lora", "lora_foo", "foo_lora_foo", "lora_foo_lora"],
+            init_lora_weights=False,
+        )
+        self.check_peft_model_weights_loaded_correctly(MyModel, config, nested=nested)
+
+    @pytest.mark.parametrize("nested", [False, True])
+    def test_get_and_set_peft_model_state_dict_weight_in_module_name(self, nested):
+        # Here we have a model with some modules containing "weight" in their name.
+        # See #2772
+        class MyModel(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.foo_linear = nn.Linear(5, 5)
+                self.foo_weight = nn.Linear(5, 5)
+                self.weight_foo = nn.Linear(5, 5)
+                self.foo_weight_foo = nn.Linear(5, 5)
+                self.weight_foo_weight = nn.Linear(5, 5)
+
+            def forward(self, x):
+                x = self.foo_linear(x)
+                x = self.foo_weight(x)
+                x = self.weight_foo(x)
+                x = self.foo_weight_foo(x)
+                x = self.weight_foo_weight(x)
+                return x
+
+        config = LoraConfig(
+            target_modules=["foo_linear", "foo_weight", "weight_foo", "foo_weight_foo", "weight_foo_weight"],
+            init_lora_weights=False,
+        )
+        self.check_peft_model_weights_loaded_correctly(MyModel, config, nested=nested)
+
+    @pytest.mark.parametrize("nested", [False, True])
+    def test_get_and_set_peft_model_state_dict_bias_in_module_name(self, nested):
+        # Here we have a model with some modules containing "bias" in their name.
+        class MyModel(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.foo_linear = nn.Linear(5, 5)
+                self.foo_bias = nn.Linear(5, 5)
+                self.bias_foo = nn.Linear(5, 5)
+                self.foo_bias_foo = nn.Linear(5, 5)
+                self.bias_foo_bias = nn.Linear(5, 5)
+
+            def forward(self, x):
+                x = self.foo_linear(x)
+                x = self.foo_bias(x)
+                x = self.bias_foo(x)
+                x = self.foo_bias_foo(x)
+                x = self.bias_foo_bias(x)
+                return x
+
+        config = LoraConfig(
+            target_modules=["foo_linear", "foo_bias", "bias_foo", "foo_bias_foo", "bias_foo_bias"],
+            init_lora_weights=False,
+            bias="lora_only",
+        )
+        self.check_peft_model_weights_loaded_correctly(MyModel, config, nested=nested)
+
+    @pytest.mark.parametrize("nested", [False, True])
+    def test_get_and_set_peft_model_state_dict_adapter_name_same_as_module_name(self, nested):
+        # Here we choose a module name that is identical to the name of one of the adapters.
+        class MyModel(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.foo = nn.Linear(5, 5)
+                self.foo_baz = nn.Linear(5, 5)
+                self.baz_foo = nn.Linear(5, 5)
+                self.foo_baz_foo = nn.Linear(5, 5)
+                self.baz_foo_baz = nn.Linear(5, 5)
+
+            def forward(self, x):
+                x = self.foo(x)
+                x = self.foo_baz(x)
+                x = self.baz_foo(x)
+                x = self.foo_baz_foo(x)
+                x = self.baz_foo_baz(x)
+                return x
+
+        config = LoraConfig(
+            target_modules=["foo", "foo_baz", "baz_foo", "foo_baz_foo", "baz_foo_baz"], init_lora_weights=False
+        )
+        self.check_peft_model_weights_loaded_correctly(MyModel, config, nested=nested, adapter_name="foo")
diff --git a/tests/test_mapping.py b/tests/test_mapping.py
new file mode 100644
index 0000000..7b03ab2
--- /dev/null
+++ b/tests/test_mapping.py
@@ -0,0 +1,55 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+import pytest
+import torch
+
+from peft import LoraConfig, get_peft_model
+
+
+class TestGetPeftModel:
+    RELOAD_WARNING_EXPECTED_MATCH = r"You are trying to modify a model .*"
+
+    @pytest.fixture
+    def lora_config_0(self):
+        return LoraConfig(target_modules="0")
+
+    @pytest.fixture
+    def base_model(self):
+        return torch.nn.Sequential(torch.nn.Linear(10, 2), torch.nn.Linear(2, 10))
+
+    def test_get_peft_model_warns_when_reloading_model(self, lora_config_0, base_model):
+        get_peft_model(base_model, lora_config_0)
+
+        with pytest.warns(UserWarning, match=self.RELOAD_WARNING_EXPECTED_MATCH):
+            get_peft_model(base_model, lora_config_0)
+
+    def test_get_peft_model_proposed_fix_in_warning_helps(self, lora_config_0, base_model, recwarn):
+        peft_model = get_peft_model(base_model, lora_config_0)
+        peft_model.unload()
+        get_peft_model(base_model, lora_config_0)
+
+        warning_checker = pytest.warns(UserWarning, match=self.RELOAD_WARNING_EXPECTED_MATCH)
+
+        for warning in recwarn:
+            if warning_checker.matches(warning):
+                pytest.fail("Warning raised even though model was unloaded.")
+
+    def test_get_peft_model_repeated_invocation(self, lora_config_0, base_model):
+        peft_model = get_peft_model(base_model, lora_config_0)
+
+        # use direct-addressing of the other layer to accommodate for the nested model
+        lora_config_1 = LoraConfig(target_modules="base_model.model.1")
+
+        with pytest.warns(UserWarning, match=self.RELOAD_WARNING_EXPECTED_MATCH):
+            get_peft_model(peft_model, lora_config_1)
diff --git a/tests/test_mixed.py b/tests/test_mixed.py
new file mode 100644
index 0000000..7d37763
--- /dev/null
+++ b/tests/test_mixed.py
@@ -0,0 +1,803 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import copy
+import itertools
+import os
+import platform
+import re
+import tempfile
+import unittest
+
+import pytest
+import torch
+from parameterized import parameterized
+from torch import nn
+from transformers import AutoModelForCausalLM
+
+from peft import (
+    AdaLoraConfig,
+    LoHaConfig,
+    LoKrConfig,
+    LoraConfig,
+    OFTConfig,
+    PeftMixedModel,
+    PrefixTuningConfig,
+    get_peft_model,
+)
+from peft.tuners.tuners_utils import BaseTunerLayer
+from peft.utils import infer_device
+
+
+class SimpleNet(nn.Module):
+    def __init__(self, bias=True):
+        super().__init__()
+        # note: out_features must be > rank or else OFT will be an identity transform
+        self.lin0 = nn.Linear(10, 20, bias=bias)
+        self.relu = nn.ReLU()
+        self.lin1 = nn.Linear(20, 16, bias=bias)
+
+    def forward(self, X):
+        X = X.float()
+        X = self.lin0(X)
+        X = self.relu(X)
+        X = self.lin1(X)
+        return X
+
+
+def _param_name_func(testcase_func, param_num, params):
+    # for parameterized tests in TextMixedAdapterTypes
+    config0, config1 = params[0]
+    name0 = config0.__class__.__name__[: -len("Config")]
+    name1 = config1.__class__.__name__[: -len("Config")]
+    if name0 != name1:
+        return f"{testcase_func.__name__}_{param_num}_{name0}_{name1}"
+    return f"{testcase_func.__name__}_{param_num}_{name0}_x2"
+
+
+class TestMixedAdapterTypes(unittest.TestCase):
+    torch_device = infer_device()
+
+    def _get_model(self, model_cls, peft_config=None, adapter_name=None, seed=0, mixed=True):
+        torch.manual_seed(0)  # always use seed 0 for base model, seed for adapters may differ
+        base_model = model_cls().eval().to(self.torch_device)
+        if peft_config is None:
+            return base_model
+
+        torch.manual_seed(seed)
+        assert adapter_name is not None
+        peft_model = get_peft_model(base_model, peft_config, adapter_name=adapter_name, mixed=mixed)
+        return peft_model.eval().to(self.torch_device)
+
+    def _check_mixed_outputs(self, model_cls, config0, config1, input, *, is_commutative):
+        # This test checks different combinations of adapter0, adapter1, or combinations of the two, and whether
+        # outputs are the same/different, depending on context. If we pass is_commutative=True, it means that the order
+        # of adapters does not matter, and we expect the same output regardless of the order in which adapters are
+        # applied.
+        # We have to very careful with resetting the random seed each time it is used, otherwise the adapters may be
+        # initialized with different values, and the test will fail.
+
+        atol = 1e-5
+        rtol = 1e-5
+        seed0 = 0
+        seed1 = 1
+
+        # base model
+        base_model = self._get_model(model_cls)
+        output_base = base_model(input)
+        assert torch.isfinite(output_base).all()
+
+        # adapter 0
+        peft_model_0 = self._get_model(model_cls, config0, "adapter0", seed=seed0)
+        output_config0 = peft_model_0(input)
+
+        assert torch.isfinite(output_config0).all()
+        assert not torch.allclose(output_base, output_config0, atol=atol, rtol=rtol)
+
+        # adapter 1
+        peft_model_1 = self._get_model(model_cls, config1, "adapter1", seed=seed1)
+        output_config1 = peft_model_1(input)
+
+        assert torch.isfinite(output_config1).all()
+        assert not torch.allclose(output_base, output_config1, atol=atol, rtol=rtol)
+        assert not torch.allclose(output_config0, output_config1, atol=atol, rtol=rtol)
+
+        # adapter 0 + 1
+        peft_model_01 = self._get_model(model_cls, config0, "adapter0", seed=seed0)
+        torch.manual_seed(seed1)
+        peft_model_01.add_adapter("adapter1", config1)
+        peft_model_01.set_adapter(["adapter0", "adapter1"])
+        output_mixed_01 = peft_model_01(input)
+
+        # check the number of tuner layer types
+        tuner_layers = [mod for mod in peft_model_01.modules() if isinstance(mod, BaseTunerLayer)]
+        tuner_types = {type(tuner_layer) for tuner_layer in tuner_layers}
+        if type(config0) is type(config1):
+            assert len(tuner_types) == 1
+        else:
+            assert len(tuner_types) == 2
+
+        assert peft_model_01.active_adapters == ["adapter0", "adapter1"]
+        assert torch.isfinite(output_mixed_01).all()
+        assert not torch.allclose(output_config0, output_mixed_01, atol=atol, rtol=rtol)
+        assert not torch.allclose(output_config1, output_mixed_01, atol=atol, rtol=rtol)
+        if is_commutative:
+            delta0 = output_config0 - output_base
+            delta1 = output_config1 - output_base
+            delta_mixed_01 = output_mixed_01 - output_base
+            assert torch.allclose((delta0 + delta1), delta_mixed_01, atol=atol, rtol=rtol)
+
+        # adapter 1 + 0
+        peft_model_10 = self._get_model(model_cls, config1, "adapter1", seed=seed1)
+        torch.manual_seed(seed0)
+        peft_model_10.add_adapter("adapter0", config0)
+        peft_model_10.set_adapter(["adapter1", "adapter0"])
+        output_mixed_10 = peft_model_10(input)
+
+        # check the number of tuner layer types
+        tuner_layers = [mod for mod in peft_model_10.modules() if isinstance(mod, BaseTunerLayer)]
+        tuner_types = {type(tuner_layer) for tuner_layer in tuner_layers}
+        if type(config0) is type(config1):
+            assert len(tuner_types) == 1
+        else:
+            assert len(tuner_types) == 2
+
+        assert peft_model_10.active_adapters == ["adapter1", "adapter0"]
+        assert torch.isfinite(output_mixed_10).all()
+        assert not torch.allclose(output_config0, output_mixed_10, atol=atol, rtol=rtol)
+        assert not torch.allclose(output_config1, output_mixed_10, atol=atol, rtol=rtol)
+        if is_commutative:
+            assert torch.allclose(output_mixed_01, output_mixed_10, atol=atol, rtol=rtol)
+
+        # turn around the order of the adapters of the 0 + 1 mixed model, should behave like the 0 + 1 mixed model
+        peft_model_10.set_adapter(["adapter0", "adapter1"])
+        output_mixed_reversed = peft_model_10(input)
+
+        # check the number of tuner layer types
+        tuner_layers = [mod for mod in peft_model_10.modules() if isinstance(mod, BaseTunerLayer)]
+        tuner_types = {type(tuner_layer) for tuner_layer in tuner_layers}
+        if type(config0) is type(config1):
+            assert len(tuner_types) == 1
+        else:
+            assert len(tuner_types) == 2
+
+        assert peft_model_10.active_adapters == ["adapter0", "adapter1"]
+        assert torch.isfinite(output_mixed_reversed).all()
+        assert not torch.allclose(output_mixed_reversed, output_config0, atol=atol, rtol=rtol)
+        assert not torch.allclose(output_mixed_reversed, output_config1, atol=atol, rtol=rtol)
+        if is_commutative:
+            assert torch.allclose(output_mixed_reversed, output_mixed_01, atol=atol, rtol=rtol)
+            assert torch.allclose(output_mixed_reversed, output_mixed_10, atol=atol, rtol=rtol)
+
+    def _check_merging(self, model_cls, config0, config1, input):
+        # Ensure that when merging mixed adapters, the result is the same as when applying the adapters separately.
+        # Merging requires a bit higher tolerance for some adapters, which can also vary depending on CPU vs GPU.
+        atol = 1e-4
+        rtol = 1e-4
+        seed0 = 0
+        seed1 = 1
+
+        # adapter 0 + 1
+        peft_model_01 = self._get_model(model_cls, config0, "adapter0", seed=seed0)
+        torch.manual_seed(seed1)
+        peft_model_01.add_adapter("adapter1", config1)
+        peft_model_01.set_adapter(["adapter0", "adapter1"])
+        output_mixed_01 = peft_model_01(input)
+
+        model_merged_01 = peft_model_01.merge_and_unload()
+        output_merged_01 = model_merged_01(input)
+        assert torch.allclose(output_mixed_01, output_merged_01, atol=atol, rtol=rtol)
+
+        # adapter 1 + 0
+        peft_model_10 = self._get_model(model_cls, config1, "adapter1", seed=seed1)
+        torch.manual_seed(seed0)
+        peft_model_10.add_adapter("adapter0", config0)
+        peft_model_10.set_adapter(["adapter1", "adapter0"])
+        output_mixed_10 = peft_model_10(input)
+
+        model_merged_10 = peft_model_10.merge_and_unload()
+        output_merged_10 = model_merged_10(input)
+        assert torch.allclose(output_mixed_10, output_merged_10, atol=atol, rtol=rtol)
+
+    def _check_unload(self, model_cls, config0, config1, input):
+        # Ensure that we can unload the base model without merging
+        atol = 1e-5
+        rtol = 1e-5
+        seed0 = 0
+        seed1 = 1
+
+        base_model = self._get_model(model_cls)
+        output_base = base_model(input)
+
+        # adapter 0 + 1
+        peft_model_01 = self._get_model(model_cls, config0, "adapter0", seed=seed0)
+        torch.manual_seed(seed1)
+        peft_model_01.add_adapter("adapter1", config1)
+        peft_model_01.set_adapter(["adapter0", "adapter1"])
+        output_mixed = peft_model_01(input)
+
+        # unload
+        model_unloaded = peft_model_01.unload()
+        output_unloaded = model_unloaded(input)
+
+        assert not torch.allclose(output_mixed, output_unloaded, atol=atol, rtol=rtol)
+        assert torch.allclose(output_base, output_unloaded, atol=atol, rtol=rtol)
+
+    def _check_disable(self, model_cls, config0, config1, input):
+        # Ensure that we can disable adapters
+        atol = 1e-5
+        rtol = 1e-5
+        seed0 = 0
+        seed1 = 1
+
+        # base model
+        base_model = self._get_model(model_cls)
+        output_base = base_model(input)
+
+        # adapter 0
+        peft_model_0 = self._get_model(model_cls, config0, "adapter0", seed=seed0)
+        output_config0 = peft_model_0(input)
+        with peft_model_0.disable_adapter():
+            output_disabled0 = peft_model_0(input)
+
+        assert not torch.allclose(output_base, output_config0, atol=atol, rtol=rtol)
+        assert torch.allclose(output_base, output_disabled0, atol=atol, rtol=rtol)
+
+        # adapter 1
+        peft_model_1 = self._get_model(model_cls, config1, "adapter1", seed=seed1)
+        output_config1 = peft_model_1(input)
+        with peft_model_1.disable_adapter():
+            output_disabled1 = peft_model_1(input)
+
+        assert not torch.allclose(output_base, output_config1, atol=atol, rtol=rtol)
+        assert torch.allclose(output_base, output_disabled1, atol=atol, rtol=rtol)
+
+        # adapter 0 + 1
+        peft_model_01 = self._get_model(model_cls, config0, "adapter0", seed=seed0)
+        torch.manual_seed(seed1)
+        peft_model_01.add_adapter("adapter1", config1)
+        peft_model_01.set_adapter(["adapter0", "adapter1"])
+        output_mixed_01 = peft_model_01(input)
+        with peft_model_01.disable_adapter():
+            output_disabled01 = peft_model_01(input)
+
+        assert not torch.allclose(output_base, output_mixed_01, atol=atol, rtol=rtol)
+        assert torch.allclose(output_base, output_disabled01, atol=atol, rtol=rtol)
+
+        # adapter 1 + 0
+        peft_model_10 = self._get_model(model_cls, config1, "adapter1", seed=seed1)
+        torch.manual_seed(seed0)
+        peft_model_10.add_adapter("adapter0", config0)
+        peft_model_10.set_adapter(["adapter1", "adapter0"])
+        output_mixed_10 = peft_model_10(input)
+        with peft_model_10.disable_adapter():
+            output_disabled10 = peft_model_10(input)
+
+        assert not torch.allclose(output_base, output_mixed_10, atol=atol, rtol=rtol)
+        assert torch.allclose(output_base, output_disabled10, atol=atol, rtol=rtol)
+
+    def _check_loading(self, model_cls, config0, config1, input, *, is_commutative):
+        # Check that we can load two adapters into the same model
+        # Note that we save the adapters using a normal PeftModel because PeftMixModel doesn't support saving yet
+        atol = 1e-5
+        rtol = 1e-5
+        seed0 = 0
+        seed1 = 1
+
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            # SAVING
+            # adapter 0: note that we set mixed=False because mixed models don't support saving (yet)
+            peft_model_0 = self._get_model(model_cls, config0, "adapter0", seed=seed0, mixed=False)
+            output_config0 = peft_model_0(input)
+            peft_model_0.save_pretrained(os.path.join(tmp_dirname, "adapter0"))
+
+            # adapter 1: note that we set mixed=False because mixed models don't support saving (yet)
+            peft_model_1 = self._get_model(model_cls, config1, "adapter1", seed=seed1, mixed=False)
+            output_config1 = peft_model_1(input)
+            peft_model_1.save_pretrained(os.path.join(tmp_dirname, "adapter1"))
+
+            # adapter 0 + 1
+            peft_model_01 = self._get_model(model_cls, config0, "adapter0", seed=seed0)
+            torch.manual_seed(seed1)
+            peft_model_01.add_adapter("adapter1", config1)
+            peft_model_01.set_adapter(["adapter0", "adapter1"])
+            output_mixed_01 = peft_model_01(input)
+
+            # adapter 1 + 0
+            peft_model_10 = self._get_model(model_cls, config1, "adapter1", seed=seed1)
+            torch.manual_seed(seed0)
+            peft_model_10.add_adapter("adapter0", config0)
+            peft_model_10.set_adapter(["adapter1", "adapter0"])
+            output_mixed_10 = peft_model_10(input)
+
+            # LOADING
+            # adapter 0
+            base_model = self._get_model(model_cls)
+            # Notes:
+            # Path is tmp_dirname/adapter0/adapter0 because non-default adapters are saved in a subfolder.
+            # As a sanity check, we should set a completely different seed here. That way, we ensure that the the
+            # weights are not just randomly initialized exactly to the same values as before.
+            torch.manual_seed(123456)
+            peft_model_loaded0 = PeftMixedModel.from_pretrained(
+                base_model, os.path.join(tmp_dirname, "adapter0", "adapter0"), "adapter0"
+            )
+            output_loaded0 = peft_model_loaded0(input)
+            assert torch.allclose(output_config0, output_loaded0, atol=atol, rtol=rtol)
+
+            # adapter 1
+            base_model = self._get_model(model_cls)
+            torch.manual_seed(654321)  # setting a completely different seed here should not affect the result
+            peft_model_loaded1 = PeftMixedModel.from_pretrained(
+                base_model, os.path.join(tmp_dirname, "adapter1", "adapter1"), "adapter1"
+            )
+            output_loaded1 = peft_model_loaded1(input)
+            assert torch.allclose(output_config1, output_loaded1, atol=atol, rtol=rtol)
+
+            # adapter 0 + 1
+            base_model = self._get_model(model_cls)
+            torch.manual_seed(97531)  # setting a completely different seed here should not affect the result
+            peft_model_loaded_01 = PeftMixedModel.from_pretrained(
+                base_model, os.path.join(tmp_dirname, "adapter0", "adapter0"), "adapter0"
+            )
+            peft_model_loaded_01.load_adapter(os.path.join(tmp_dirname, "adapter1", "adapter1"), "adapter1")
+            # at this point, "adapter0" should still be active
+            assert peft_model_loaded_01.active_adapters == ["adapter0"]
+            output_loaded01_0 = peft_model_loaded_01(input)
+            assert torch.allclose(output_config0, output_loaded01_0, atol=atol, rtol=rtol)
+            # activate adapter1
+            peft_model_loaded_01.set_adapter(["adapter1"])
+            assert peft_model_loaded_01.active_adapters == ["adapter1"]
+            output_loaded01_1 = peft_model_loaded_01(input)
+            assert torch.allclose(output_config1, output_loaded01_1, atol=atol, rtol=rtol)
+            # activate both adapters
+            peft_model_loaded_01.set_adapter(["adapter0", "adapter1"])
+            output_loaded01 = peft_model_loaded_01(input)
+            assert torch.allclose(output_mixed_01, output_loaded01, atol=atol, rtol=rtol)
+
+            # adapter 1 + 0
+            base_model = self._get_model(model_cls)
+            torch.manual_seed(445566)  # setting a completely different seed here should not affect the result
+            peft_model_loaded_10 = PeftMixedModel.from_pretrained(
+                base_model, os.path.join(tmp_dirname, "adapter1", "adapter1"), "adapter1"
+            )
+            peft_model_loaded_10.load_adapter(os.path.join(tmp_dirname, "adapter0", "adapter0"), "adapter0")
+            # at this point, "adapter1" should still be active
+            assert peft_model_loaded_10.active_adapters == ["adapter1"]
+            output_loaded10_1 = peft_model_loaded_10(input)
+            assert torch.allclose(output_config1, output_loaded10_1, atol=atol, rtol=rtol)
+            # activate adapter1
+            peft_model_loaded_10.set_adapter(["adapter0"])
+            assert peft_model_loaded_10.active_adapters == ["adapter0"]
+            output_loaded10_0 = peft_model_loaded_10(input)
+            assert torch.allclose(output_config0, output_loaded10_0, atol=atol, rtol=rtol)
+            # activate both adapters
+            peft_model_loaded_10.set_adapter(["adapter1", "adapter0"])
+            output_loaded10 = peft_model_loaded_10(input)
+            assert torch.allclose(output_mixed_10, output_loaded10, atol=atol, rtol=rtol)
+
+            if is_commutative:
+                assert torch.allclose(output_loaded01, output_loaded10, atol=atol, rtol=rtol)
+                assert torch.allclose(output_loaded10, output_mixed_01, atol=atol, rtol=rtol)
+
+    @parameterized.expand(
+        itertools.combinations(
+            [
+                LoraConfig(target_modules=["lin0"], init_lora_weights=False),
+                LoHaConfig(target_modules=["lin0"], init_weights=False),
+                LoKrConfig(target_modules=["lin0"], init_weights=False),
+                AdaLoraConfig(target_modules=["lin0"], init_lora_weights=False, total_step=1),
+            ],
+            r=2,
+        ),
+        name_func=_param_name_func,
+    )
+    def test_target_first_layer(self, config0, config1):
+        input = torch.arange(90).reshape(9, 10).to(self.torch_device)
+        self._check_mixed_outputs(SimpleNet, config0, config1, input, is_commutative=False)
+        self._check_merging(SimpleNet, config0, config1, input)
+        self._check_unload(SimpleNet, config0, config1, input)
+        self._check_disable(SimpleNet, config1, config0, input)
+        self._check_loading(SimpleNet, config0, config1, input, is_commutative=False)
+
+    @parameterized.expand(
+        itertools.combinations(
+            [
+                LoraConfig(target_modules=["lin1"], init_lora_weights=False),
+                LoHaConfig(target_modules=["lin1"], init_weights=False),
+                LoKrConfig(target_modules=["lin1"], init_weights=False),
+                AdaLoraConfig(target_modules=["lin1"], init_lora_weights=False, total_step=1),
+            ],
+            r=2,
+        ),
+        name_func=_param_name_func,
+    )
+    def test_target_last_layer(self, config0, config1):
+        # We are targeting the last layer of the SimpleNet. Therefore, since the adapters only add their activations
+        # to the output, the results should be commutative. This would *not* work if the adapters do something more
+        # complex or if we target an earlier layer, because of the non-linearity would destroy the commutativity.
+        input = torch.arange(90).reshape(9, 10).to(self.torch_device)
+
+        self._check_mixed_outputs(SimpleNet, config0, config1, input, is_commutative=True)
+        self._check_merging(SimpleNet, config0, config1, input)
+        self._check_unload(SimpleNet, config0, config1, input)
+        self._check_disable(SimpleNet, config1, config0, input)
+        self._check_loading(SimpleNet, config0, config1, input, is_commutative=True)
+
+    @parameterized.expand(
+        itertools.combinations(
+            [
+                LoraConfig(init_lora_weights=False),
+                LoHaConfig(init_weights=False),
+                LoKrConfig(init_weights=False),
+                AdaLoraConfig(init_lora_weights=False, total_step=1),
+            ],
+            r=2,
+        ),
+        name_func=_param_name_func,
+    )
+    def test_target_different_layers(self, config0, config1):
+        input = torch.arange(90).reshape(9, 10).to(self.torch_device)
+
+        config0.target_modules = ["lin0"]
+        config1.target_modules = ["lin1"]
+        self._check_mixed_outputs(SimpleNet, config0, config1, input, is_commutative=False)
+        self._check_merging(SimpleNet, config0, config1, input)
+        self._check_unload(SimpleNet, config0, config1, input)
+        self._check_disable(SimpleNet, config0, config1, input)
+        self._check_loading(SimpleNet, config0, config1, input, is_commutative=False)
+
+        # same, but switch target_modules around
+        config0.target_modules = ["lin1"]
+        config1.target_modules = ["lin0"]
+        self._check_mixed_outputs(SimpleNet, config1, config0, input, is_commutative=False)
+        self._check_merging(SimpleNet, config1, config0, input)
+        self._check_unload(SimpleNet, config1, config0, input)
+        self._check_disable(SimpleNet, config1, config0, input)
+        self._check_loading(SimpleNet, config1, config0, input, is_commutative=False)
+
+    @parameterized.expand(
+        [
+            (
+                LoraConfig(target_modules=["lin1"], init_lora_weights=False),
+                LoraConfig(target_modules=["lin1"], init_lora_weights=False),
+            ),
+            (
+                LoHaConfig(target_modules=["lin1"], init_weights=False),
+                LoHaConfig(target_modules=["lin1"], init_weights=False),
+            ),
+            (
+                LoKrConfig(target_modules=["lin1"], init_weights=False),
+                LoKrConfig(target_modules=["lin1"], init_weights=False),
+            ),
+            (
+                AdaLoraConfig(target_modules=["lin1"], init_lora_weights=False, total_step=1),
+                AdaLoraConfig(target_modules=["lin1"], init_lora_weights=False, total_step=1),
+            ),
+        ],
+        name_func=_param_name_func,
+    )
+    def test_target_last_layer_same_type(self, config0, config1):
+        input = torch.arange(90).reshape(9, 10).to(self.torch_device)
+
+        self._check_mixed_outputs(SimpleNet, config0, config1, input, is_commutative=True)
+        self._check_merging(SimpleNet, config0, config1, input)
+        self._check_unload(SimpleNet, config0, config1, input)
+        self._check_disable(SimpleNet, config1, config0, input)
+
+    @parameterized.expand(
+        [
+            (
+                LoraConfig(target_modules=["lin0"], init_lora_weights=False),
+                LoraConfig(target_modules=["lin0"], init_lora_weights=False),
+            ),
+            (
+                LoHaConfig(target_modules=["lin0"], init_weights=False),
+                LoHaConfig(target_modules=["lin0"], init_weights=False),
+            ),
+            (
+                LoKrConfig(target_modules=["lin0"], init_weights=False),
+                LoKrConfig(target_modules=["lin0"], init_weights=False),
+            ),
+            (
+                AdaLoraConfig(target_modules=["lin0"], init_lora_weights=False, total_step=1),
+                AdaLoraConfig(target_modules=["lin0"], init_lora_weights=False, total_step=1),
+            ),
+        ],
+        name_func=_param_name_func,
+    )
+    def test_target_first_layer_same_type(self, config0, config1):
+        input = torch.arange(90).reshape(9, 10).to(self.torch_device)
+        self._check_mixed_outputs(SimpleNet, config0, config1, input, is_commutative=False)
+        self._check_merging(SimpleNet, config0, config1, input)
+        self._check_unload(SimpleNet, config0, config1, input)
+        self._check_disable(SimpleNet, config1, config0, input)
+        self._check_loading(SimpleNet, config0, config1, input, is_commutative=False)
+
+    def test_deeply_nested(self):
+        # a somewhat absurdly nested model using different adapter types
+        if platform.system() == "Linux":
+            pytest.skip("This test fails but only on GitHub CI with Linux systems.")
+
+        atol = 1e-5
+        rtol = 1e-5
+        torch.manual_seed(0)
+
+        model = SimpleNet().eval().to(self.torch_device)
+        input = torch.arange(90).reshape(9, 10).to(self.torch_device)
+        output_base = model(input)
+
+        config0 = LoraConfig(r=4, lora_alpha=4, target_modules=["lin0", "lin1"], init_lora_weights=False)
+        peft_model = get_peft_model(model, config0, "adapter0", mixed=True)
+
+        config1 = LoHaConfig(r=4, alpha=4, target_modules=["lin0"], init_weights=False)
+        peft_model.add_adapter("adapter1", config1)
+
+        config2 = AdaLoraConfig(r=4, lora_alpha=4, target_modules=["lin1"], init_lora_weights=False, total_step=1)
+        peft_model.add_adapter("adapter2", config2)
+
+        config3 = LoKrConfig(r=4, alpha=4, target_modules=["lin0", "lin1"], init_weights=False)
+        peft_model.add_adapter("adapter3", config3)
+
+        peft_model.set_adapter(["adapter0", "adapter1", "adapter2", "adapter3"])
+        output_mixed = peft_model(input)
+        assert torch.isfinite(output_base).all()
+        assert not torch.allclose(output_base, output_mixed, atol=atol, rtol=rtol)
+
+        # test disabling all adapters
+        with peft_model.disable_adapter():
+            output_disabled = peft_model(input)
+        assert torch.isfinite(output_disabled).all()
+        assert torch.allclose(output_base, output_disabled, atol=atol, rtol=rtol)
+        assert not torch.allclose(output_mixed, output_disabled, atol=atol, rtol=rtol)
+
+        # merge and unload all adapters
+        model_copy = copy.deepcopy(peft_model)
+        model = model_copy.merge_and_unload()
+        output_merged = model(input)
+        assert torch.isfinite(output_merged).all()
+        assert torch.allclose(output_mixed, output_merged, atol=atol, rtol=rtol)
+
+        # merge and unload only adapter1 and adapter3
+        model_copy = copy.deepcopy(peft_model)
+        model_copy.set_adapter(["adapter1", "adapter3"])
+        output_13 = model_copy(input)
+        assert torch.isfinite(output_13).all()
+        assert not torch.allclose(output_mixed, output_13, atol=atol, rtol=rtol)
+
+        model_copy.set_adapter(["adapter0", "adapter1", "adapter2", "adapter3"])
+        model_merged_unloaded = model_copy.merge_and_unload(adapter_names=["adapter1", "adapter3"])
+        output_merged_13 = model_merged_unloaded(input)
+        assert torch.isfinite(output_merged_13).all()
+        assert torch.allclose(output_13, output_merged_13, atol=atol, rtol=rtol)
+
+        # test unloading
+        model_copy = copy.deepcopy(peft_model)
+        model_unloaded = model_copy.unload()
+        output_unloaded = model_unloaded(input)
+        assert torch.isfinite(output_unloaded).all()
+        assert torch.allclose(output_base, output_unloaded, atol=atol, rtol=rtol)
+
+    def test_delete_adapter(self):
+        atol = 1e-5
+        rtol = 1e-5
+        torch.manual_seed(0)
+
+        model = SimpleNet().eval().to(self.torch_device)
+        input = torch.arange(90).reshape(9, 10).to(self.torch_device)
+        output_base = model(input)
+
+        # create adapter0
+        torch.manual_seed(0)
+        config0 = LoraConfig(r=4, lora_alpha=4, target_modules=["lin0", "lin1"], init_lora_weights=False)
+        peft_model = get_peft_model(model, config0, "adapter0", mixed=True)
+        output_0 = peft_model(input)
+        assert not torch.allclose(output_base, output_0, atol=atol, rtol=rtol)
+
+        # add adapter1
+        torch.manual_seed(1)
+        config1 = LoHaConfig(r=4, alpha=4, target_modules=["lin0"], init_weights=False)
+        peft_model.add_adapter("adapter1", config1)
+        peft_model.set_adapter(["adapter0", "adapter1"])
+        output_01 = peft_model(input)
+        assert not torch.allclose(output_base, output_01, atol=atol, rtol=rtol)
+        assert not torch.allclose(output_0, output_01, atol=atol, rtol=rtol)
+
+        # delete adapter1
+        peft_model.delete_adapter("adapter1")
+        assert peft_model.active_adapters == ["adapter0"]
+        output_deleted_1 = peft_model(input)
+        assert torch.allclose(output_0, output_deleted_1, atol=atol, rtol=rtol)
+
+        msg = re.escape("Adapter(s) ['adapter1'] not found, available adapters: ['adapter0']")
+        with pytest.raises(ValueError, match=msg):
+            peft_model.set_adapter(["adapter0", "adapter1"])
+
+        # re-add adapter1
+        torch.manual_seed(1)
+        peft_model.add_adapter("adapter1", config1)
+        peft_model.set_adapter(["adapter0", "adapter1"])
+        output_01_readded = peft_model(input)
+        assert not torch.allclose(output_base, output_01_readded, atol=atol, rtol=rtol)
+
+        # same as above, but this time delete adapter0 first
+        torch.manual_seed(0)
+        model = SimpleNet().eval().to(self.torch_device)
+        torch.manual_seed(0)
+        peft_model = get_peft_model(model, config0, "adapter0", mixed=True)
+        torch.manual_seed(1)
+        peft_model.add_adapter("adapter1", config1)
+        peft_model.delete_adapter("adapter0")
+        assert peft_model.active_adapters == ["adapter1"]
+        output_deleted_0 = peft_model(input)
+        assert not torch.allclose(output_deleted_0, output_base, atol=atol, rtol=rtol)
+        assert not torch.allclose(output_deleted_0, output_01, atol=atol, rtol=rtol)
+
+        msg = re.escape("Adapter(s) ['adapter0'] not found, available adapters: ['adapter1']")
+        with pytest.raises(ValueError, match=msg):
+            peft_model.set_adapter(["adapter0", "adapter1"])
+
+        peft_model.delete_adapter("adapter1")
+        assert peft_model.active_adapters == []
+        output_deleted_01 = peft_model(input)
+        assert torch.allclose(output_deleted_01, output_base, atol=atol, rtol=rtol)
+
+    def test_modules_to_save(self):
+        model = SimpleNet().eval().to(self.torch_device)
+        config0 = LoraConfig(target_modules=["lin0"], modules_to_save=["lin1"])
+        peft_model = get_peft_model(model, config0, "adapter0", mixed=True)
+
+        # adding a second adapter with same modules_to_save is not allowed
+        # TODO: theoretically, we could allow this if it's the same target layer
+        config1 = LoHaConfig(target_modules=["lin0"], modules_to_save=["lin1"])
+        peft_model.add_adapter("adapter1", config1)
+        with pytest.raises(ValueError, match="Only one adapter can be set at a time for ModulesToSaveWrapper"):
+            peft_model.set_adapter(["adapter0", "adapter1"])
+
+    def test_get_nb_trainable_parameters(self):
+        model = SimpleNet().eval().to(self.torch_device)
+        params_base = sum(p.numel() for p in model.parameters())
+
+        config0 = LoraConfig(target_modules=["lin0"])
+        peft_model = get_peft_model(model, config0, "adapter0", mixed=True)
+        trainable_params0, all_param0 = peft_model.get_nb_trainable_parameters()
+
+        params_lora = sum(p.numel() for n, p in model.named_parameters() if "adapter0" in n)
+        assert trainable_params0 == params_lora
+        assert all_param0 == (params_base + params_lora)
+
+        config1 = LoHaConfig(target_modules=["lin1"])
+        peft_model.add_adapter("adapter1", config1)
+        peft_model.set_adapter(["adapter0", "adapter1"])
+        params_loha = sum(p.numel() for n, p in model.named_parameters() if "adapter1" in n)
+        trainable_params1, all_param1 = peft_model.get_nb_trainable_parameters()
+        assert trainable_params1 == (params_lora + params_loha)
+        assert all_param1 == ((params_base + params_lora) + params_loha)
+
+        config2 = AdaLoraConfig(target_modules=["lin0", "lin1"], total_step=1)
+        peft_model.add_adapter("adapter2", config2)
+        peft_model.set_adapter(["adapter0", "adapter1", "adapter2"])
+        params_adalora = sum(p.numel() for n, p in model.named_parameters() if "adapter2" in n)
+        trainable_params2, all_param2 = peft_model.get_nb_trainable_parameters()
+        # remove 2 params because we need to exclude "ranknum" for AdaLora trainable params
+        assert trainable_params2 == (((params_lora + params_loha) + params_adalora) - 2)
+        assert all_param2 == (((params_base + params_lora) + params_loha) + params_adalora)
+
+    def test_bias_only_honored_for_non_lora_tuner(self):
+        # `bias="<prefix>_only"` should be honored for any mixed-compatible tuner, not just LoRA. Previously the
+        # mixed model hardcoded `bias == "lora_only"` and raised `ValueError: Requested bias: oft_only, is not
+        # implemented.` for e.g. OFT, even though standalone OFT supports `bias="oft_only"`.
+        model = SimpleNet().eval().to(self.torch_device)
+        config = OFTConfig(target_modules=["lin1"], oft_block_size=8, bias="oft_only")
+        peft_model = get_peft_model(model, config, "adapter0", mixed=True)
+
+        trainable_biases = [n for n, p in peft_model.named_parameters() if n.endswith("bias") and p.requires_grad]
+        assert trainable_biases, "expected at least one trainable bias with bias='oft_only'"
+
+    def test_incompatible_config_raises(self):
+        model = SimpleNet().eval().to(self.torch_device)
+        config0 = LoraConfig(target_modules=["lin0"])
+        peft_model = get_peft_model(model, config0, "adapter0", mixed=True)
+
+        config1 = PrefixTuningConfig()
+        msg = "The provided `peft_type` 'PREFIX_TUNING' is not compatible with the `PeftMixedModel`."
+        with pytest.raises(ValueError, match=msg):
+            peft_model.add_adapter("adapter1", config1)
+
+    def test_decoder_model(self):
+        # test a somewhat realistic model instead of a toy model
+        torch.manual_seed(0)
+
+        model_id = "peft-internal-testing/tiny-random-OPTForCausalLM"
+        model = AutoModelForCausalLM.from_pretrained(model_id).eval().to(self.torch_device)
+        input_ids = torch.tensor([[1, 1, 1], [1, 2, 1]]).to(self.torch_device)
+        attention_mask = torch.tensor([[1, 1, 1], [1, 0, 1]]).to(self.torch_device)
+        input_dict = {
+            "input_ids": input_ids,
+            "attention_mask": attention_mask,
+        }
+        output_base = model.generate(**input_dict)
+
+        torch.manual_seed(0)
+        config0 = LoraConfig(task_type="CAUSAL_LM", init_lora_weights=False)
+        peft_model = get_peft_model(model, config0, "adapter0", mixed=True)
+        output0 = peft_model.generate(**input_dict)
+        assert torch.isfinite(output0).all()
+        assert not torch.allclose(output_base, output0)
+
+        torch.manual_seed(1)
+        config1 = LoHaConfig(task_type="CAUSAL_LM", target_modules=["q_proj", "v_proj"], init_weights=False)
+        peft_model.add_adapter("adapter1", config1)
+        peft_model.set_adapter(["adapter0", "adapter1"])
+        output1 = peft_model.generate(**input_dict)
+        assert torch.isfinite(output1).all()
+        assert not torch.allclose(output0, output1)
+
+        torch.manual_seed(2)
+        config2 = AdaLoraConfig(task_type="CAUSAL_LM", init_lora_weights=False, total_step=1)
+        peft_model.add_adapter("adapter2", config2)
+        peft_model.set_adapter(["adapter0", "adapter1", "adapter2"])
+        output2 = peft_model.generate(**input_dict)
+        assert torch.isfinite(output2).all()
+        assert not torch.allclose(output1, output2)
+
+        torch.manual_seed(3)
+        config3 = LoKrConfig(task_type="CAUSAL_LM", target_modules=["q_proj", "v_proj"], init_weights=False)
+        peft_model.add_adapter("adapter3", config3)
+        peft_model.set_adapter(["adapter0", "adapter1", "adapter2", "adapter3"])
+        output3 = peft_model.generate(**input_dict)
+        assert torch.isfinite(output3).all()
+        assert not torch.allclose(output2, output3)
+
+        torch.manual_seed(4)
+        peft_model.set_adapter(["adapter0", "adapter1", "adapter2", "adapter3"])
+
+        with peft_model.disable_adapter():
+            output_disabled = peft_model.generate(**input_dict)
+        assert torch.isfinite(output_disabled).all()
+        assert torch.allclose(output_base, output_disabled)
+
+        model_unloaded = peft_model.merge_and_unload()
+        output_unloaded = model_unloaded.generate(**input_dict)
+        assert torch.isfinite(output_unloaded).all()
+
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            # save adapter0 (use normal PeftModel, because PeftMixedModel does not support saving)
+            torch.manual_seed(0)
+            model = AutoModelForCausalLM.from_pretrained(model_id).eval().to(self.torch_device)
+            torch.manual_seed(0)
+            peft_model = get_peft_model(model, config0, "adapter0")
+            output0_save = peft_model(**input_dict).logits
+            assert torch.isfinite(output0_save).all()
+            peft_model.save_pretrained(tmp_dir)
+
+            # save adapter1
+            torch.manual_seed(0)
+            model = AutoModelForCausalLM.from_pretrained(model_id).eval().to(self.torch_device)
+            torch.manual_seed(1)
+            peft_model = get_peft_model(model, config1, "adapter1")
+            output1_save = peft_model(**input_dict).logits
+            assert torch.isfinite(output1_save).all()
+            peft_model.save_pretrained(tmp_dir)
+
+            # load adapter0 and adapter1
+            model = AutoModelForCausalLM.from_pretrained(model_id).eval().to(self.torch_device)
+            peft_model = PeftMixedModel.from_pretrained(model, os.path.join(tmp_dir, "adapter0"), "adapter0")
+            peft_model.load_adapter(os.path.join(tmp_dir, "adapter1"), "adapter1")
+            peft_model.set_adapter(["adapter0", "adapter1"])
+            output01_loaded = peft_model(**input_dict).logits
+
+            atol, rtol = 1e-3, 1e-3
+            assert torch.isfinite(output01_loaded).all()
+            assert not torch.allclose(output0_save, output01_loaded, atol=atol, rtol=rtol)
+            assert not torch.allclose(output1_save, output01_loaded, atol=atol, rtol=rtol)
diff --git a/tests/test_multitask_prompt_tuning.py b/tests/test_multitask_prompt_tuning.py
new file mode 100644
index 0000000..3417caf
--- /dev/null
+++ b/tests/test_multitask_prompt_tuning.py
@@ -0,0 +1,288 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import os
+import tempfile
+
+import pytest
+import torch
+from torch.testing import assert_close
+from transformers import AutoModelForCausalLM
+
+from peft import get_peft_model
+from peft.peft_model import PeftModel
+from peft.tuners.multitask_prompt_tuning import MultitaskPromptTuningConfig, MultitaskPromptTuningInit
+from peft.utils import infer_device
+from peft.utils.other import WEIGHTS_NAME, prepare_model_for_kbit_training
+from peft.utils.save_and_load import get_peft_model_state_dict
+
+
+MODELS_TO_TEST = [
+    "trl-internal-testing/tiny-random-LlamaForCausalLM",
+]
+
+
+class TestMultiTaskPromptTuning:
+    """
+    Tests for the MultiTaskPromptTuning model.
+    """
+
+    @pytest.fixture
+    def config(cls) -> MultitaskPromptTuningConfig:
+        return MultitaskPromptTuningConfig(
+            task_type="CAUSAL_LM",
+            num_virtual_tokens=50,
+            num_tasks=3,
+            prompt_tuning_init_text=(
+                "classify the following into either positive or negative, or entailment, neutral or contradiction:"
+            ),
+        )
+
+    transformers_class = AutoModelForCausalLM
+    torch_device = infer_device()
+
+    @pytest.mark.parametrize("model_id", MODELS_TO_TEST)
+    def test_prepare_for_training(self, model_id, config):
+        model = AutoModelForCausalLM.from_pretrained(model_id)
+        model = get_peft_model(model, config)
+        model = model.to(self.torch_device)
+
+        dummy_input = torch.LongTensor([[1, 1, 1]]).to(self.torch_device)
+        dummy_output = model.get_input_embeddings()(dummy_input)
+
+        assert not dummy_output.requires_grad
+
+    @pytest.mark.parametrize("model_id", MODELS_TO_TEST)
+    def test_prepare_for_int8_training(self, model_id, config):
+        model = AutoModelForCausalLM.from_pretrained(model_id)
+        model = prepare_model_for_kbit_training(model)
+        model = model.to(self.torch_device)
+
+        for param in model.parameters():
+            assert not param.requires_grad
+
+        model = get_peft_model(model, config)
+
+        # For backward compatibility
+        if hasattr(model, "enable_input_require_grads"):
+            model.enable_input_require_grads()
+        else:
+
+            def make_inputs_require_grad(module, input, output):
+                output.requires_grad_(True)
+
+            model.get_input_embeddings().register_forward_hook(make_inputs_require_grad)
+
+        dummy_input = torch.LongTensor([[1, 1, 1]]).to(self.torch_device)
+        dummy_output = model.get_input_embeddings()(dummy_input)
+
+        assert dummy_output.requires_grad
+
+    @pytest.mark.parametrize("model_id", MODELS_TO_TEST)
+    def test_save_pretrained(self, model_id, config):
+        seed = 420
+        torch.manual_seed(seed)
+        model = AutoModelForCausalLM.from_pretrained(model_id)
+        model = get_peft_model(model, config)
+        model = model.to(self.torch_device)
+
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            model.save_pretrained(tmp_dirname)
+
+            torch.manual_seed(seed)
+            model_from_pretrained = AutoModelForCausalLM.from_pretrained(model_id)
+            model_from_pretrained = PeftModel.from_pretrained(model_from_pretrained, tmp_dirname)
+
+            # check if the state dicts are equal
+            state_dict = get_peft_model_state_dict(model)
+
+            state_dict_from_pretrained = get_peft_model_state_dict(model_from_pretrained)
+
+            # check if same keys
+            assert state_dict.keys() == state_dict_from_pretrained.keys()
+
+            # Check that the number of saved parameters is 4 -- 2 layers of (tokens and gate).
+            assert len(state_dict) == 3
+
+            # check if tensors equal
+            for key in state_dict.keys():
+                assert torch.allclose(
+                    state_dict[key].to(self.torch_device), state_dict_from_pretrained[key].to(self.torch_device)
+                )
+
+            # check if `adapter_model.safetensors` is present
+            assert os.path.exists(os.path.join(tmp_dirname, "adapter_model.safetensors"))
+
+            # check if `adapter_config.json` is present
+            assert os.path.exists(os.path.join(tmp_dirname, "adapter_config.json"))
+
+            # check if `pytorch_model.bin` is not present
+            assert not os.path.exists(os.path.join(tmp_dirname, "pytorch_model.bin"))
+
+            # check if `config.json` is not present
+            assert not os.path.exists(os.path.join(tmp_dirname, "config.json"))
+
+    @pytest.mark.parametrize("model_id", MODELS_TO_TEST)
+    def test_save_pretrained_regression(self, model_id, config):
+        seed = 420
+        torch.manual_seed(seed)
+        model = AutoModelForCausalLM.from_pretrained(model_id)
+        model = get_peft_model(model, config)
+        model = model.to(self.torch_device)
+
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            model.save_pretrained(tmp_dirname, safe_serialization=False)
+
+            torch.manual_seed(seed)
+            model_from_pretrained = AutoModelForCausalLM.from_pretrained(model_id)
+            model_from_pretrained = PeftModel.from_pretrained(model_from_pretrained, tmp_dirname)
+
+            # check if the state dicts are equal
+            state_dict = get_peft_model_state_dict(model)
+
+            state_dict_from_pretrained = get_peft_model_state_dict(model_from_pretrained)
+
+            # check if same keys
+            assert state_dict.keys() == state_dict_from_pretrained.keys()
+
+            # Check that the number of saved parameters is 4 -- 2 layers of (tokens and gate).
+            assert len(state_dict) == 3
+
+            # check if tensors equal
+            for key in state_dict.keys():
+                assert torch.allclose(
+                    state_dict[key].to(self.torch_device), state_dict_from_pretrained[key].to(self.torch_device)
+                )
+
+            # check if `adapter_model.bin` is present for regression
+            assert os.path.exists(os.path.join(tmp_dirname, "adapter_model.bin"))
+
+            # check if `adapter_config.json` is present
+            assert os.path.exists(os.path.join(tmp_dirname, "adapter_config.json"))
+
+            # check if `pytorch_model.bin` is not present
+            assert not os.path.exists(os.path.join(tmp_dirname, "pytorch_model.bin"))
+
+            # check if `config.json` is not present
+            assert not os.path.exists(os.path.join(tmp_dirname, "config.json"))
+
+    @pytest.mark.parametrize("model_id", MODELS_TO_TEST)
+    def test_generate(self, model_id, config):
+        model = AutoModelForCausalLM.from_pretrained(model_id)
+        model = get_peft_model(model, config)
+        model = model.to(self.torch_device)
+
+        input_ids = torch.LongTensor([[1, 1, 1], [2, 1, 2]]).to(self.torch_device)
+        attention_mask = torch.LongTensor([[1, 1, 1], [1, 0, 1]]).to(self.torch_device)
+        task_ids = torch.LongTensor([1, 2]).to(self.torch_device)
+
+        # check if `generate` works
+        _ = model.generate(input_ids=input_ids, attention_mask=attention_mask, task_ids=task_ids)
+
+        # check if `generate` works if positional arguments are passed
+        _ = model.generate(input_ids, attention_mask=attention_mask, task_ids=task_ids)
+
+    @pytest.mark.parametrize("model_id", MODELS_TO_TEST)
+    def test_use_cache(self, model_id, config):
+        """Test that MultiTaskPromptTuning works when Llama config use_cache=True."""
+        torch.manual_seed(0)
+        input_ids = torch.LongTensor([[1, 1, 1], [2, 1, 2]]).to(self.torch_device)
+        task_ids = torch.LongTensor([1, 2]).to(self.torch_device)
+
+        original = AutoModelForCausalLM.from_pretrained(model_id)
+        mpt = get_peft_model(original, config)
+        mpt = mpt.to(self.torch_device)
+
+        expected = mpt.generate(input_ids=input_ids, max_length=8, task_ids=task_ids)
+
+        # Set use_cache = True and generate output again.
+        mpt.base_model.config.use_cache = True
+        actual = mpt.generate(input_ids=input_ids, max_length=8, task_ids=task_ids)
+        assert_close(expected, actual, rtol=0, atol=0)
+
+    @pytest.mark.parametrize("model_id", MODELS_TO_TEST)
+    def test_bf16_inference(self, model_id, config):
+        """Test that MultiTaskPromptTuning works when Llama using a half-precision model."""
+        input_ids = torch.LongTensor([[1, 1, 1], [2, 1, 2]]).to(self.torch_device)
+        task_ids = torch.tensor([1, 2]).to(self.torch_device)
+
+        original = AutoModelForCausalLM.from_pretrained(model_id, dtype=torch.bfloat16)
+        mpt = get_peft_model(original, config)
+        mpt = mpt.to(self.torch_device)
+        _ = mpt.generate(input_ids=input_ids, task_ids=task_ids)
+
+    @pytest.mark.parametrize("model_id", MODELS_TO_TEST)
+    def test_generate_text_with_random_init(self, model_id, config) -> None:
+        torch.manual_seed(0)
+        model = AutoModelForCausalLM.from_pretrained(model_id)
+        config.prompt_tuning_init = MultitaskPromptTuningInit.RANDOM
+        model = get_peft_model(model, config)
+        model = model.to(self.torch_device)
+
+        input_ids = torch.LongTensor([[1, 1, 1], [2, 1, 2]]).to(self.torch_device)
+        attention_mask = torch.LongTensor([[1, 1, 1], [1, 0, 1]]).to(self.torch_device)
+        task_ids = torch.LongTensor([0]).to(self.torch_device)
+
+        # check if `generate` works
+        _ = model.generate(input_ids=input_ids, attention_mask=attention_mask, task_ids=task_ids)
+
+        with pytest.raises(ValueError):
+            # check if `generate` raises an error if task_ids are not passed
+            _ = model.generate(input_ids, attention_mask=attention_mask)
+
+    @pytest.mark.parametrize(
+        "prompt_tuning_init",
+        [
+            MultitaskPromptTuningInit.AVERAGE_SOURCE_TASKS,
+            MultitaskPromptTuningInit.EXACT_SOURCE_TASK,
+            MultitaskPromptTuningInit.ONLY_SOURCE_SHARED,
+        ],
+    )
+    @pytest.mark.parametrize("model_id", MODELS_TO_TEST)
+    def test_generate_text_with_other_init(self, prompt_tuning_init, model_id, config) -> None:
+        # This test is flaky, hence fixing the seed. The reason is somehow related to:
+        # https://github.com/huggingface/transformers/blob/e786844425b6b1112c76513d66217ce2fe6aea41/src/transformers/generation/utils.py#L2691
+        # When an EOS token is generated, the loop is exited and the pytest.raises at the bottom is not triggered
+        # because `forward` of the PEFT model, which should raise the error, is never called.
+        torch.manual_seed(42)  # seed 43 fails with transformers v4.42.3 and torch v2.3.1
+
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            model = get_peft_model(model, config)
+            model.save_pretrained(tmp_dirname, safe_serialization=False)  # bc torch.load is used
+
+            config = MultitaskPromptTuningConfig(
+                task_type="CAUSAL_LM",
+                num_virtual_tokens=50,
+                num_tasks=1,
+                prompt_tuning_init_text=(
+                    "classify the following into either positive or negative, or entailment, neutral or contradiction:"
+                ),
+                prompt_tuning_init=prompt_tuning_init,
+                prompt_tuning_init_state_dict_path=os.path.join(tmp_dirname, WEIGHTS_NAME),
+            )
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            model = get_peft_model(model, config)
+            model = model.to(self.torch_device)
+
+            input_ids = torch.LongTensor([[1, 1, 1], [2, 1, 2]]).to(self.torch_device)
+            attention_mask = torch.LongTensor([[1, 1, 1], [1, 0, 1]]).to(self.torch_device)
+            task_ids = torch.LongTensor([0]).to(self.torch_device)
+
+            # check if `generate` works
+            _ = model.generate(input_ids=input_ids, attention_mask=attention_mask, task_ids=task_ids)
+
+            with pytest.raises(ValueError, match="task_ids cannot be None"):
+                # check if `generate` raises an error if task_ids are not passed
+                _ = model.generate(input_ids, attention_mask=attention_mask)
diff --git a/tests/test_osf.py b/tests/test_osf.py
new file mode 100644
index 0000000..cdef0f8
--- /dev/null
+++ b/tests/test_osf.py
@@ -0,0 +1,72 @@
+import pytest
+import torch
+from torch.testing import assert_close
+
+from peft import OSFConfig, get_peft_model
+from peft.tuners.osf.layer import OSFLayer
+from peft.tuners.osf.utils import (
+    decompose_weight_matrix,
+    reconstruct_weight_matrix,
+)
+
+
+def test_osf_roundtrip():
+    w = torch.randn(10, 8)
+    svd = decompose_weight_matrix(w, top_k=4)
+    w_rec = reconstruct_weight_matrix(svd)
+    assert_close(w_rec, w, atol=1e-5, rtol=1e-5)
+
+
+class DummyConfig(dict):
+    pass
+
+
+class DummyModel(torch.nn.Module):
+    def __init__(self, config=None):
+        super().__init__()
+        self.config = config
+        self.linear = torch.nn.Linear(8, 4)
+
+    def forward(self, x):
+        return self.linear(x)
+
+
+def test_osf_gradient_projection_hook():
+    torch.manual_seed(0)
+    model = DummyModel(DummyConfig())
+    # Specify target module explicitly for DummyModel
+    cfg = OSFConfig(target_modules=["linear"], effective_rank=2)
+    wrapped = get_peft_model(model, cfg)
+    x = torch.randn(3, 8)
+    wrapped(x).sum().backward()
+    # Access the injected OSF layer
+    osf_linear = wrapped.base_model.model.linear
+    adapter = wrapped.base_model.active_adapters[0]
+    U_high = osf_linear._osf_U_high[adapter]
+    V_high = osf_linear._osf_V_high[adapter]
+    svd_params = osf_linear.osf_svd_params[adapter]
+    # Check orthogonality of gradients after projection
+    proj_u = U_high.T @ svd_params["U_low"].grad
+    proj_v = svd_params["V_low"].grad @ V_high.T
+    assert_close(proj_u, torch.zeros_like(proj_u), atol=1e-6, rtol=1e-6)
+    assert_close(proj_v, torch.zeros_like(proj_v), atol=1e-6, rtol=1e-6)
+
+
+def test_osf_merge_and_unload_and_unmerge_behavior():
+    model = DummyModel(DummyConfig())
+    cfg = OSFConfig(target_modules=["linear"], effective_rank=2)
+    wrapped = get_peft_model(model, cfg)
+
+    # merge_adapter should work via BaseTuner and OSFLayer.merge
+    osf_linear = wrapped.base_model.model.linear
+    assert isinstance(osf_linear, OSFLayer)
+    wrapped.merge_adapter()
+    assert osf_linear.merged, "OSF layer should be marked as merged after merge_adapter()"
+
+    # unmerge_adapter is not supported for OSF
+    with pytest.raises(NotImplementedError):
+        wrapped.unmerge_adapter()
+
+    # merge_and_unload should return the base model (no OSF wrappers)
+    merged_model = wrapped.merge_and_unload()
+    assert isinstance(merged_model.linear, torch.nn.Linear)
diff --git a/tests/test_other.py b/tests/test_other.py
new file mode 100644
index 0000000..4e959f5
--- /dev/null
+++ b/tests/test_other.py
@@ -0,0 +1,777 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import copy
+from contextlib import contextmanager
+from unittest.mock import patch
+
+import pytest
+import torch
+from torch import nn
+from transformers import (
+    AutoModelForCausalLM,
+    AutoModelForSeq2SeqLM,
+    AutoModelForSequenceClassification,
+    LlavaForConditionalGeneration,
+)
+
+from peft import LoraConfig, PeftModel, VeraConfig, get_peft_model
+from peft.import_utils import is_transformers_ge_v5_1_0, is_transformers_ge_v5_6_0
+from peft.utils.other import (
+    ModulesToSaveWrapper,
+    _get_module_names_tied_with_embedding,
+    _get_no_split_modules,
+    prepare_model_for_kbit_training,
+)
+
+from .testing_utils import hub_online_once
+
+
+class ModelWithModuleDict(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.other_layer = nn.Linear(10, 10)
+        self.module = nn.ModuleDict({"foo": nn.Linear(10, 10)})
+
+    def forward(self):
+        return self.module["foo"](torch.rand(1, 10))
+
+
+class ModelWithModuleList(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.other_layer = nn.Linear(10, 10)
+        self.module = nn.ModuleList([nn.Linear(10, 10)])
+
+    def forward(self):
+        return self.module[0](torch.rand(1, 10))
+
+
+class ModelWithParameterDict(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.other_layer = nn.Linear(10, 10)
+        self.module = nn.ParameterDict({"foo": nn.Parameter(torch.rand(10, 10))})
+
+    def forward(self):
+        return self.module["foo"]
+
+
+class ModelWithParameterList(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.other_layer = nn.Linear(10, 10)
+        self.module = nn.ParameterList([nn.Parameter(torch.rand(10, 10))])
+
+    def forward(self):
+        return self.module[0]
+
+
+@pytest.mark.parametrize(
+    "cls", [ModelWithModuleDict, ModelWithModuleList, ModelWithParameterDict, ModelWithParameterList]
+)
+def test_modules_to_save_targets_module_dict_raises(cls):
+    model = cls()
+    peft_config = LoraConfig(
+        target_modules=["other_layer"],
+        modules_to_save=["module"],
+    )
+    model()  # sanity check that the model would normally work
+
+    msg = "modules_to_save cannot be applied to modules of type"
+    with pytest.raises(TypeError, match=msg):
+        get_peft_model(model=model, peft_config=peft_config)
+
+
+def test_get_peft_model_revision_warning(tmp_path):
+    base_model_id = "peft-internal-testing/tiny-random-BertModel"
+    base_revision = "v2.0.0"
+    base_model = AutoModelForCausalLM.from_pretrained(base_model_id, revision=base_revision).eval()
+    lora_config = LoraConfig(revision=base_revision)
+
+    overwrite_revision = "main"
+    overwrite_warning = f"peft config has already set base model revision to {base_revision}, overwriting with revision {overwrite_revision}"
+    with pytest.warns(UserWarning, match=overwrite_warning):
+        _ = get_peft_model(base_model, lora_config, revision=overwrite_revision)
+
+
+def test_load_multiple_adapters_different_modules_to_save(tmp_path):
+    # This tests the error described in #2422 where loading multiple adapters with different modules_to_save
+    # attributes fails (due to a regression from #2376).
+
+    model = AutoModelForCausalLM.from_pretrained("trl-internal-testing/tiny-random-LlamaForCausalLM")
+
+    def peft_config(**kwargs):
+        return LoraConfig(target_modules="all-linear", **kwargs)
+
+    original_model = copy.deepcopy(model)
+
+    peft_config_0 = peft_config(modules_to_save=["0.post_attention_layernorm"])
+    peft_config_1 = peft_config(modules_to_save=["0.post_attention_layernorm"])
+    peft_config_2 = peft_config(modules_to_save=["1.post_attention_layernorm"])
+
+    # Save adapter 0, nothing fancy, should be equal to base model weighs
+    peft_model = get_peft_model(copy.deepcopy(original_model), peft_config_0)
+    peft_model.save_pretrained(tmp_path / "adapter_0")
+
+    # Save adapter 1, modules to save weights are modified randomly, should be unique to adapter 1
+    peft_model = get_peft_model(copy.deepcopy(original_model), peft_config_1)
+    peft_model.model.model.layers[0].post_attention_layernorm.weight.data = torch.rand_like(
+        peft_model.model.model.layers[0].post_attention_layernorm.weight.data
+    )
+    adapter_1_saved = peft_model.model.model.layers[0].post_attention_layernorm.weight.data.clone()
+    peft_model.save_pretrained(tmp_path / "adapter_1")
+
+    # Save adapter 2, modules to save weights are modified randomly, should be unique to adapter 2
+    peft_model = get_peft_model(copy.deepcopy(original_model), peft_config_2)
+    peft_model.model.model.layers[1].post_attention_layernorm.weight.data = torch.rand_like(
+        peft_model.model.model.layers[1].post_attention_layernorm.weight.data
+    )
+    adapter_2_saved = peft_model.model.model.layers[1].post_attention_layernorm.weight.data.clone()
+    peft_model.save_pretrained(tmp_path / "adapter_2")
+
+    del peft_model
+
+    combined_model = PeftModel.from_pretrained(original_model, tmp_path / "adapter_0", adapter_name="adapter_0")
+    combined_model.load_adapter(tmp_path / "adapter_1", adapter_name="adapter_1")
+    combined_model.load_adapter(tmp_path / "adapter_2", adapter_name="adapter_2")
+
+    # For adapter 0 we expect every mentioned modules to save layer of this test to be equal to the original model
+    # since we didn't modify it for adapter 0 and only adapter 0 is active.
+    combined_model.set_adapter("adapter_0")
+    assert torch.allclose(
+        combined_model.model.model.layers[0].post_attention_layernorm.weight,
+        original_model.model.layers[0].post_attention_layernorm.weight,
+    )
+    assert torch.allclose(
+        combined_model.model.model.layers[1].post_attention_layernorm.weight,
+        original_model.model.layers[1].post_attention_layernorm.weight,
+    )
+
+    # For adapter 1 we expect that the modified module to save 0.post_attention_layernorm is modified, the other
+    # module to save layers mentioned above should be untouched.
+    combined_model.set_adapter("adapter_1")
+    assert torch.allclose(
+        combined_model.model.model.layers[0].post_attention_layernorm.weight,
+        adapter_1_saved,
+    )
+    assert torch.allclose(
+        combined_model.model.model.layers[1].post_attention_layernorm.weight,
+        original_model.model.layers[1].post_attention_layernorm.weight,
+    )
+
+    # For adapter 2 we expect its module to save layer (1.post_attention_layernorm) to be modified but the other
+    # module to save weights should be kept original.
+    combined_model.set_adapter("adapter_2")
+    assert torch.allclose(
+        combined_model.model.model.layers[0].post_attention_layernorm.weight,
+        original_model.model.layers[0].post_attention_layernorm.weight,
+    )
+    assert torch.allclose(
+        combined_model.model.model.layers[1].post_attention_layernorm.weight,
+        adapter_2_saved,
+    )
+
+
+class TestModulesToSaveAttributeAccess:
+    """Test attribute access on the ModulesToSaveWrapper class.
+
+    When we have modules_to_save, the original module is wrapped. As long as only forward was called on this wrapped
+    module, we were good. However, if, for instance, model parameters were directly accessed by another module, this
+    would typically fail, as the wrapper does not have this attribute. We had special properties for weight and bias,
+    but this is not enough. Therefore, attribute access is now transiently delegated to the active adapter (or original
+    module, if the adapter is disabled).
+
+    For one example, see #2099.
+
+    """
+
+    @pytest.fixture
+    def mlp(self):
+        class MLP(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.lin0 = nn.Linear(1, 2)
+                self.lin1 = nn.Linear(3, 4)
+
+        return MLP()
+
+    def test_transient_attribute_access_default_adapter(self, mlp):
+        config = LoraConfig(target_modules=["lin0"], modules_to_save=["lin1"])
+        model = get_peft_model(mlp, config)
+        assert model.lin1.weight is model.lin1.modules_to_save["default"].weight
+        assert model.lin1.bias is model.lin1.modules_to_save["default"].bias
+
+    def test_transient_attribute_access_non_default_adapter(self, mlp):
+        config = LoraConfig(target_modules=["lin0"], modules_to_save=["lin1"])
+        model = get_peft_model(mlp, config)
+        model.add_adapter("other", config)
+
+        # at this point, default is still active
+        assert model.lin1.weight is model.lin1.modules_to_save["default"].weight
+        assert model.lin1.bias is model.lin1.modules_to_save["default"].bias
+        assert model.lin1.weight is not model.lin1.modules_to_save["other"].weight
+        assert model.lin1.bias is not model.lin1.modules_to_save["other"].bias
+
+        model.set_adapter("other")
+        assert model.lin1.weight is not model.lin1.modules_to_save["default"].weight
+        assert model.lin1.bias is not model.lin1.modules_to_save["default"].bias
+        assert model.lin1.weight is model.lin1.modules_to_save["other"].weight
+        assert model.lin1.bias is model.lin1.modules_to_save["other"].bias
+
+    def test_transient_attribute_access_disabled_adapter(self, mlp):
+        config = LoraConfig(target_modules=["lin0"], modules_to_save=["lin1"])
+        model = get_peft_model(mlp, config)
+
+        # at this point, default is still active
+        assert model.lin1.weight is model.lin1.modules_to_save["default"].weight
+        assert model.lin1.bias is model.lin1.modules_to_save["default"].bias
+        assert model.lin1.weight is not model.lin1.original_module.weight
+        assert model.lin1.bias is not model.lin1.original_module.bias
+
+        with model.disable_adapter():
+            assert model.lin1.weight is not model.lin1.modules_to_save["default"].weight
+            assert model.lin1.bias is not model.lin1.modules_to_save["default"].bias
+            assert model.lin1.weight is model.lin1.original_module.weight
+            assert model.lin1.bias is model.lin1.original_module.bias
+
+    def test_transient_attribute_access_uninitialized_adapter(self, mlp):
+        # ensure that there is no weird infinite recursion when accessing a non-existing attribute on the class itself
+        with pytest.raises(AttributeError, match="has no attribute 'original_module'"):
+            ModulesToSaveWrapper.original_module
+
+    def test_transient_attribute_access_attr_does_not_exist_on_modules_to_save(self, mlp):
+        # ensure that there is no weird infinite recursion when accessing a non-existing attribute on the
+        # ModelToSaveWrapper instance
+        config = LoraConfig(target_modules=["lin0"], modules_to_save=["lin1"])
+        model = get_peft_model(mlp, config)
+
+        with pytest.raises(AttributeError, match="has no attribute 'foo'"):
+            model.lin1.foo
+
+    def test_transient_attribute_access_attr_does_not_exist_on_original_module(self, mlp):
+        # ensure that there is no weird infinite recursion when accessing a non-existing attribute on the
+        # original module of the ModelToSaveWrapper instance
+        config = LoraConfig(target_modules=["lin0"], modules_to_save=["lin1"])
+        model = get_peft_model(mlp, config)
+
+        with pytest.raises(AttributeError, match="has no attribute 'foo'"):
+            with model.disable_adapter():
+                model.lin1.foo
+
+    def test_transient_attribute_access_non_existing_adapter(self, mlp):
+        # This should normally never happen, as the active adapter should always exist, but it's a failsafe
+        config = LoraConfig(target_modules=["lin0"], modules_to_save=["lin1"])
+        model = get_peft_model(mlp, config)
+        model.base_model.model.lin1._active_adapter = "does-not-exist"
+        with pytest.raises(AttributeError, match="has no attribute 'weight'"):
+            model.lin1.weight
+
+
+class TestModulesToSaveKwargsOnlyForward:
+    """Regression test for #3191: modules listed in `modules_to_save` whose parent calls them with keyword arguments
+    only (e.g. Gemma's `vision_tower(pixel_values=...)`) used to crash with `TypeError: forward() missing 1 required
+    positional argument: 'x'` because the wrapper required a positional first arg. The wrapper now forwards `*args,
+    **kwargs` as-is.
+    """
+
+    @pytest.fixture
+    def model(self):
+        class KwargsOnly(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.lin = nn.Linear(8, 8)
+
+            def forward(self, *, pixel_values):
+                return self.lin(pixel_values)
+
+        class Outer(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.trunk = nn.Linear(8, 8)
+                self.vision = KwargsOnly()
+
+            def forward(self, x):
+                return self.vision(pixel_values=self.trunk(x))
+
+        return Outer()
+
+    def test_kwargs_only_forward_active_adapter(self, model):
+        config = LoraConfig(target_modules=["trunk"], modules_to_save=["vision"])
+        peft_model = get_peft_model(model, config)
+        # would previously raise TypeError about missing positional 'x'
+        out = peft_model(torch.randn(2, 8))
+        assert out.shape == (2, 8)
+
+    def test_kwargs_only_forward_disabled_adapter(self, model):
+        config = LoraConfig(target_modules=["trunk"], modules_to_save=["vision"])
+        peft_model = get_peft_model(model, config)
+        with peft_model.disable_adapter():
+            out = peft_model(torch.randn(2, 8))
+        assert out.shape == (2, 8)
+
+    def test_kwargs_only_forward_multi_adapter(self, model):
+        config = LoraConfig(target_modules=["trunk"], modules_to_save=["vision"])
+        peft_model = get_peft_model(model, config)
+        peft_model.add_adapter("other", config)
+        peft_model.set_adapter("other")
+        out = peft_model(torch.randn(2, 8))
+        assert out.shape == (2, 8)
+
+
+class TestModulesToSaveNameSubstringBug:
+    """Test a bug that could occur with multiple modules to save where one adapter's name is a substring of another
+    adapter's name.
+
+    This bug was the result of an error in the logic of modifying the state_dict for modules_to_save in
+    set_peft_model_state_dict. The error in the logic was that it was checked if an entry from modules_to_save (a set
+    of strings) is a substring of a key of the state_dict. If it was, a new name was assigned to that key in the
+    state_dict, which would allow to load the weight later.
+
+    The issue that stems from the substring check occurs if there are multiple modules_to_save, and one of them has a
+    name that is a substring of another. So e.g. if one is named "classifier" and the other is named "classifier2",
+    there could be a false match.
+
+
+    This bug was reported in #2289.
+
+    """
+
+    def get_model(self):
+        class MyModule(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.lin = nn.Linear(5, 4)
+                # important: "classifier" is a substring of "classifier2", "classifier3", "classifier4"
+                self.classifier = nn.Linear(4, 2)
+                self.classifier2 = nn.Linear(4, 2)
+                self.classifier3 = nn.Linear(4, 2)
+                self.classifier4 = nn.Linear(4, 2)
+
+            def forward(self, x):
+                x = self.lin(x)
+                return self.classifier(x) + self.classifier2(x) + self.classifier3(x) + self.classifier4(x)
+
+        torch.manual_seed(0)
+        return MyModule()
+
+    @pytest.fixture
+    def path_merged_and_unmerged(self, tmp_path):
+        # Create 2 checkpoints:
+        # 1. merged: the model after calling merge_and_unload
+        # 2. unmerged: the PEFT model saved without calling merge_and_unload
+        path = tmp_path / "model.pt"
+
+        lora_config = LoraConfig(
+            target_modules=["lin"],
+            # important: "classifier" is a substring of "classifier2", "classifier3", "classifier4"
+            modules_to_save=["classifier", "classifier2", "classifier3", "classifier4"],
+        )
+        model = get_peft_model(self.get_model(), lora_config)
+        # mock training
+        for _ in range(5):
+            optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
+            output = model(torch.randn(10, 5))
+            loss = output.sum()
+            loss.backward()
+            optimizer.step()
+
+        # save the peft model without merging
+        path_unmerged = tmp_path / "unmerged"
+        model.save_pretrained(path_unmerged)
+
+        # merge the model and save state_dict
+        path_merged = tmp_path / "merged"
+        merged = model.merge_and_unload()
+        state_dict = merged.state_dict()
+        torch.save(state_dict, path_merged)
+
+        return path_merged, path_unmerged
+
+    def test_load_merged_and_unmerged_same_weights(self, path_merged_and_unmerged):
+        # Note that this test is quasi flaky, it has a 1 in 4 chance of passing even without the bugfix. It passes when
+        # "classifier" happens to be the last element of the set model.modules_to_save. The order of the set is random.
+        # It is not possible just run this test multiple times to minimize the probability of this happening, because
+        # within the same process, the hash order is consistent. With the bug fix, this doesn't matter, as the test will
+        # always pass, but if there is a regression, there is a 1 in 4 chance of not catching it. Since the CI runs many
+        # tests, it is overall very unlikely that none will catch it though. If you see this test failing in CI, thus be
+        # aware that some of the passing tests may just pass owing to randomness.
+        path_merged, path_unmerged = path_merged_and_unmerged
+
+        # load the merged model directly
+        state_dict = torch.load(path_merged, weights_only=True)
+        model = self.get_model()
+        model.load_state_dict(state_dict)
+        sd_merged = model.state_dict()
+        del model
+
+        # load the unmerged model and merge it
+        unmerged = PeftModel.from_pretrained(self.get_model(), path_unmerged)
+        sd_unmerged = unmerged.merge_and_unload().state_dict()
+
+        assert sd_merged.keys() == sd_unmerged.keys()
+        for key in sd_merged.keys():
+            param_merged = sd_merged[key]
+            param_unmerged = sd_unmerged[key]
+            assert torch.allclose(param_merged, param_unmerged)
+
+
+class TestTargetingAuxiliaryTrainingWrapper:
+    """AuxiliaryTrainingWrapper such as ModulesToSaveWrapper and TrainableTokensWrapper are
+    in general not to be targeted by PEFT methods such as adapters. For example, a ModulesToSaveWrapper's children
+    modules should not be targeted by `LoraConfig(target_modules='all-linear')`, among other things.
+    """
+
+    @pytest.fixture
+    def plain_model_cls(self):
+        class PlainModel(nn.Module):
+            def __init__(self, i, o):
+                super().__init__()
+                self.layer1 = nn.Linear(i, o)
+
+            def forward(self, x):
+                return self.layer1(x)
+
+        return PlainModel
+
+    @pytest.fixture
+    def nested_model_cls(self, plain_model_cls):
+        class NestedModel(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.layer1 = nn.Linear(10, 20)
+                self.layer2 = nn.Linear(20, 5)
+                self.layer3 = plain_model_cls(5, 10)
+
+            def forward(self, x):
+                x = self.layer1(x)
+                x = self.layer2(x)
+                x = self.layer3(x)
+                return x
+
+        return NestedModel
+
+    def test_nested_ignores_modules_to_save(self, nested_model_cls, plain_model_cls):
+        # Make sure that `target_modules` is not targeting the nested modules of a module marked as module to save.
+        model = nested_model_cls()
+        config = LoraConfig(
+            target_modules=["layer1"],
+            modules_to_save=["layer3"],
+        )
+
+        peft_model = get_peft_model(model, config)
+        assert isinstance(peft_model.model.layer3.modules_to_save.default, plain_model_cls)
+
+    def test_targeting_module_to_save_raises(self, nested_model_cls):
+        model = nested_model_cls()
+        config = LoraConfig(
+            target_modules=["layer1"],
+            modules_to_save=["layer1"],
+        )
+        msg = "No modules were targeted for adaptation. This might be caused by a combination"
+        with pytest.raises(ValueError, match=msg):
+            get_peft_model(model, config)
+
+    def test_modules_to_save_targets_tuner_layer_raises(self):
+        # See e.g. issue 2027 and 2477
+        # Prevent users from (accidentally) targeting the same layer both with a tuner and modules_to_save. Normally, PEFT
+        # will not target the same layer with both a tuner and ModulesToSaveWrapper. However, if modules_to_save is
+        # automatically inferred, e.g. when using AutoModelForSequenceClassification, the ModulesToSaveWrapper is applied ex
+        # post, which can lead to the double wrapping.
+        model_id = "peft-internal-testing/tiny-random-OPTForCausalLM"
+        model = AutoModelForSequenceClassification.from_pretrained(model_id)
+
+        # Note: target_modules="all-linear" would also work and is closer to the original issue, but let's explicitly target
+        # "score" here in case that "all-linear" will be fixed to no longer target the score layer.
+        peft_config = LoraConfig(target_modules=["score"], task_type="SEQ_CLS")
+
+        # Since the `score` layer is in `model.modules_to_save` it should be ignored when targeted,
+        # therefore the layer should not be adapted.
+        msg = "No modules were targeted for adaptation. This might be caused by a combination"
+        with pytest.raises(ValueError, match=msg) as e:
+            get_peft_model(model, peft_config)
+
+    def test_targeting_trainable_tokens_raises(self):
+        model_id = "peft-internal-testing/tiny-random-OPTForCausalLM"
+        model = AutoModelForSequenceClassification.from_pretrained(model_id)
+
+        peft_config = LoraConfig(target_modules=["embed_tokens"], task_type="SEQ_CLS", trainable_token_indices=[0, 1])
+
+        # While this message might not be the most helpful message, at least it is not silently failing
+        msg = "trainable_token_indices cannot be applied to modules of type <class 'peft.tuners.lora.layer.Embedding'>"
+        with pytest.raises(TypeError, match=msg) as e:
+            get_peft_model(model, peft_config)
+
+
+class TestAdapterTargeting:
+    """Make sure that already existing adapters cannot be targeted to avoid conflicts."""
+
+    @pytest.fixture
+    def base_model_cls(self):
+        class M(torch.nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.l1 = torch.nn.Linear(10, 20)
+                self.l2 = torch.nn.Conv2d(1, 1, 2)
+
+            def forward(self, x):
+                return self.l2(self.l1(x))
+
+        return M
+
+    @pytest.mark.parametrize(
+        "config_cls, config_kwargs",
+        [
+            (LoraConfig, {"target_modules": "l1.*"}),
+            (LoraConfig, {"target_modules": "l2.*"}),
+            (VeraConfig, {"target_modules": "l1.*"}),
+            (VeraConfig, {"target_modules": "(l1|vera_A).*"}),  # also target the shared layer
+        ],
+    )
+    def test_self_targeting_is_ignored(self, base_model_cls, config_cls, config_kwargs):
+        base_model = base_model_cls()
+        config1 = config_cls(**config_kwargs)
+        config2 = config_cls(**config_kwargs)
+
+        adapter1_name = "ADAPTER_1_512858"  # sufficiently unique names to make reliable testing easier
+        adapter2_name = "ADAPTER_2_845781"
+
+        peft_model = get_peft_model(base_model, config1, adapter_name=adapter1_name)
+        state_dict_keys_1 = peft_model.state_dict().keys()
+
+        peft_model.add_adapter(adapter2_name, config2)
+        state_dict_keys_2 = peft_model.state_dict().keys()
+
+        # Ideally there should be no new modules targeted beyond existing ModuleDicts. Therefore the keys
+        # of the new state dict should only differ after the adapter name portion of the keys - not before.
+        # Expected:
+        # - a.b.<adapter_name_1>.xyz
+        # - a.b.<adapter_name_2>.xyz
+        # We're not expecting this to happen and test against it:
+        # - a.b.<adapter_name_1>.xyz
+        # - a.<adapter_name_2>.xyz
+        def remove_adapter_portion(adapter_name, key):
+            if key.endswith(f".{adapter_name}"):
+                return key.removesuffix(f".{adapter_name}")
+            return key.split(f".{adapter_name}.")[0]
+
+        adapter_invariant_keys1 = {remove_adapter_portion(adapter1_name, key) for key in state_dict_keys_1}
+        adapter_invariant_keys2 = {
+            remove_adapter_portion(adapter2_name, remove_adapter_portion(adapter1_name, key))
+            for key in state_dict_keys_2
+        }
+
+        assert adapter_invariant_keys1 == adapter_invariant_keys2
+
+
+class TestGetNoSplitModules:
+    # Ensure that children are considered when determining _no_split_modules
+    # see https://github.com/huggingface/transformers/pull/38141
+
+    def test_get_no_split_modules_simple(self):
+        # choose a model where recursively visiting children is *not* required
+        model_id = "peft-internal-testing/opt-125m"
+        model = AutoModelForCausalLM.from_pretrained(model_id)
+        assert list(model._no_split_modules) == ["OPTDecoderLayer"]
+        no_split_modules = _get_no_split_modules(model)
+        assert no_split_modules == {"OPTDecoderLayer"}
+
+    def test_get_no_split_modules_recursive(self):
+        # choose a model where recursively visiting children is required
+        model_id = "hf-internal-testing/tiny-random-LlavaForConditionalGeneration"
+        model = LlavaForConditionalGeneration.from_pretrained(model_id)
+
+        # model._no_split_modules is recursively generated as of transformers 5.1.0 so
+        # depending on which transformers version we have in the test environment the
+        # attribute will deliver either the same result as `_get_no_split_modules`
+        # or an empty list.
+        #
+        # TODO remove this distinction once transformers <5.1.0 is not supported anymore
+        if not is_transformers_ge_v5_1_0:
+            # sanity check: just visiting the model itself is not enough:
+            assert model._no_split_modules == []
+            no_split_modules = _get_no_split_modules(model)
+            assert no_split_modules == {"CLIPEncoderLayer", "LlamaDecoderLayer"}
+        elif not is_transformers_ge_v5_6_0:
+            # TODO remove this once transformers <5.6.0 is not supported anymore
+            assert model._no_split_modules == {"CLIPEncoderLayer", "LlamaDecoderLayer"}
+            no_split_modules = _get_no_split_modules(model)
+            assert no_split_modules == {"CLIPEncoderLayer", "LlamaDecoderLayer"}
+        else:
+            # in transformers > 5.5.0, the structure of the model was changed, see
+            # https://github.com/huggingface/transformers/pull/45361
+            # https://github.com/huggingface/transformers/pull/45448
+            assert model._no_split_modules == {
+                "CLIPEncoderLayer",
+                "CLIPTextEmbeddings",
+                "CLIPVisionEmbeddings",
+                "LlamaDecoderLayer",
+            }
+            no_split_modules = _get_no_split_modules(model)
+            assert no_split_modules == {
+                "CLIPEncoderLayer",
+                "CLIPTextEmbeddings",
+                "CLIPVisionEmbeddings",
+                "LlamaDecoderLayer",
+            }
+
+
+class TestGetModuleNamesTiedWithEmbedding:
+    # TODO remove mapping when transformers <5 is not supported anymore as it is the default
+    # from there on. also remove the 'list' tied weights type
+    model_tied_weights_mapping = {
+        "peft-internal-testing/tiny-random-BertModel": {
+            "cls.predictions.decoder.weight": "bert.embeddings.word_embeddings.weight",
+            "cls.predictions.decoder.bias": "bert.embeddings.word_embeddings.bias",
+        },
+        "peft-internal-testing/opt-125m": {
+            "lm_head.weight": "model.decoder.embed_tokens.weight",
+        },
+        "peft-internal-testing/tiny-random-t5": {
+            "lm_head.weight": "shared.weight",
+            "encoder.embed_tokens.weight": "shared.weight",
+            "decoder.embed_tokens.weight": "shared.weight",
+        },
+    }
+
+    model_ids = [
+        "peft-internal-testing/opt-125m",
+        "peft-internal-testing/tiny-random-BertModel",
+        "peft-internal-testing/tiny-random-t5",
+    ]
+
+    @contextmanager
+    def patch_model(self, model_id, tied_weights_type):
+        with hub_online_once(model_id):
+            if "t5" in model_id:
+                model = AutoModelForSeq2SeqLM.from_pretrained(model_id)
+            else:
+                model = AutoModelForCausalLM.from_pretrained(model_id)
+
+            tied_weights_keys = list(self.model_tied_weights_mapping[model_id].keys())
+            expected_module_names = sorted({k.rpartition(".")[0] for k in tied_weights_keys})
+
+            if tied_weights_type == "list":
+                # for transformers >=5 this tests compatibility with transformers <5
+                with patch.object(model, "_tied_weights_keys", list(tied_weights_keys)):
+                    yield model, expected_module_names
+
+            elif tied_weights_type == "mapping":
+                # for transformers <5 this tests compatibility with transformers >=5
+                mapping = self.model_tied_weights_mapping[model_id]
+
+                with patch.object(model, "_tied_weights_keys", mapping):
+                    yield model, expected_module_names
+
+            else:
+                raise RuntimeError("Invalid fixture request")
+
+    @pytest.mark.parametrize("tied_weights_type", ["list", "mapping"])
+    @pytest.mark.parametrize("model_id", model_ids)
+    def test_get_modules_tied_to_embedding(self, model_id, tied_weights_type):
+        with self.patch_model(model_id, tied_weights_type) as (model, expected):
+            if tied_weights_type == "mapping":
+                assert isinstance(model._tied_weights_keys, dict)
+
+            # transformers defines the bias as tied even if it doesn't exist, filter out in that case
+            if not hasattr(model.get_input_embeddings(), "bias"):
+                expected = list(filter(lambda k: "bias" not in k, expected))
+
+            modules = _get_module_names_tied_with_embedding(model)
+
+            assert expected == modules
+
+    @pytest.mark.parametrize("tied_weights_type", ["list", "mapping"])
+    @pytest.mark.parametrize("model_id", model_ids)
+    def test_get_modules_tied_to_embedding_peft(self, model_id, tied_weights_type):
+        with self.patch_model(model_id, tied_weights_type) as (model, expected):
+            if tied_weights_type == "mapping":
+                assert isinstance(model._tied_weights_keys, dict)
+
+            # transformers defines the bias as tied even if it doesn't exist, filter out in that case
+            if not hasattr(model.get_input_embeddings(), "bias"):
+                expected = list(filter(lambda k: "bias" not in k, expected))
+
+            peft_model = get_peft_model(model, LoraConfig())
+
+            modules = peft_model._get_module_names_tied_with_embedding()
+
+            assert expected == modules
+
+    @pytest.mark.parametrize("tied_weights_type", ["list", "mapping"])
+    @pytest.mark.parametrize("model_id", model_ids)
+    def test_get_modules_tied_returns_empty_when_tying_disabled(self, model_id, tied_weights_type):
+        # When tie_word_embeddings=False, no tied modules should be reported even if _tied_weights_keys exists
+        # Linked to origin issue #2944
+        with self.patch_model(model_id, tied_weights_type) as (model, _):
+            # Model has _tied_weights_keys (architectural capability) but tying is disabled
+            model.config.tie_word_embeddings = False
+
+            modules = _get_module_names_tied_with_embedding(model)
+            assert modules == []
+
+
+class TestPrepareModelForKbitTraining:
+    """CPU tests for prepare_model_for_kbit_training.
+
+    GPU tests for this function (issue #3265 memory fix) live in test_common_gpu.py.
+    """
+
+    @pytest.fixture
+    def fp16_model(self):
+        model = nn.Sequential(
+            nn.Linear(64, 64),
+            nn.Linear(64, 64),
+            nn.Linear(64, 32),
+        ).to(torch.float16)
+        model.is_loaded_in_8bit = True
+        return model
+
+    def test_fp32_cast(self, fp16_model):
+        # all non-Params4bit fp16/bf16 params become fp32 after the call
+        for param in fp16_model.parameters():
+            assert param.dtype == torch.float16
+
+        prepare_model_for_kbit_training(fp16_model, use_gradient_checkpointing=False)
+
+        for param in fp16_model.parameters():
+            if param.__class__.__name__ != "Params4bit":
+                assert param.dtype == torch.float32
+
+    def test_auto_clear_cache_default(self, fp16_model):
+        # auto_clear_cache=True (default): empty_cache() is called after the fp32 casts
+        with (
+            patch("torch.cuda.is_available", return_value=True),
+            patch("torch.cuda.empty_cache") as mock_empty_cache,
+        ):
+            prepare_model_for_kbit_training(fp16_model, use_gradient_checkpointing=False)
+        mock_empty_cache.assert_called_once()
+
+    def test_auto_clear_cache_disabled(self, fp16_model):
+        # auto_clear_cache=False: empty_cache() is never called
+        with (
+            patch("torch.cuda.is_available", return_value=True),
+            patch("torch.cuda.empty_cache") as mock_empty_cache,
+        ):
+            prepare_model_for_kbit_training(fp16_model, use_gradient_checkpointing=False, auto_clear_cache=False)
+        mock_empty_cache.assert_not_called()
+
+
+# TODO for PEFT 0.20 remove this
+class TestLoftQDeprecation:
+    def test_nfquantizer_deprecation(self):
+        from peft.utils.loftq_utils import NFQuantizer
+
+        with pytest.warns(match="NFQuantizer is deprecated") as record:
+            _ = NFQuantizer(device="cpu")
diff --git a/tests/test_poly.py b/tests/test_poly.py
new file mode 100644
index 0000000..e6ab408
--- /dev/null
+++ b/tests/test_poly.py
@@ -0,0 +1,100 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import os
+import tempfile
+import unittest
+
+import torch
+from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
+
+from peft import PeftModel, PolyConfig, TaskType, get_peft_model
+
+from .testing_utils import hub_online_once
+
+
+class TestPoly(unittest.TestCase):
+    def test_poly(self):
+        torch.manual_seed(0)
+        model_name_or_path = "google/flan-t5-small"
+
+        with hub_online_once(model_name_or_path):
+            atol, rtol = 1e-6, 1e-6
+            r = 8  # rank of lora in poly
+            n_tasks = 3  # number of tasks
+            n_skills = 2  # number of skills (loras)
+            n_splits = 4  # number of heads
+            lr = 1e-2
+            num_epochs = 10
+
+            tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)
+            base_model = AutoModelForSeq2SeqLM.from_pretrained(model_name_or_path)
+
+            peft_config = PolyConfig(
+                task_type=TaskType.SEQ_2_SEQ_LM,
+                poly_type="poly",
+                r=r,
+                n_tasks=n_tasks,
+                n_skills=n_skills,
+                n_splits=n_splits,
+            )
+
+            model = get_peft_model(base_model, peft_config)
+
+            # generate some dummy data
+            text = os.__doc__.splitlines()
+            assert len(text) > 10
+            inputs = tokenizer(text, return_tensors="pt", padding=True)
+            inputs["task_ids"] = torch.arange(len(text)) % n_tasks
+            inputs["labels"] = tokenizer((["A", "B"] * 100)[: len(text)], return_tensors="pt")["input_ids"]
+
+            # simple training loop
+            model.train()
+            optimizer = torch.optim.Adam(model.parameters(), lr=lr)
+            losses = []
+            for _ in range(num_epochs):
+                outputs = model(**inputs)
+                loss = outputs.loss
+                loss.backward()
+                optimizer.step()
+                optimizer.zero_grad()
+                losses.append(loss.item())
+
+            # loss improved by at least 50%
+            assert losses[-1] < (0.5 * losses[0])
+
+            # check that saving and loading works
+            torch.manual_seed(0)
+            model.eval()
+            logits_before = model(**inputs).logits
+            tokens_before = model.generate(**inputs)
+
+            with model.disable_adapter():
+                logits_disabled = model(**inputs).logits
+                tokens_disabled = model.generate(**inputs)
+
+            assert not torch.allclose(logits_before, logits_disabled, atol=atol, rtol=rtol)
+            assert not torch.allclose(tokens_before, tokens_disabled, atol=atol, rtol=rtol)
+
+            # saving and loading
+            with tempfile.TemporaryDirectory() as tmp_dir:
+                model.save_pretrained(tmp_dir)
+                base_model = AutoModelForSeq2SeqLM.from_pretrained(model_name_or_path)
+                loaded = PeftModel.from_pretrained(base_model, tmp_dir)
+
+            torch.manual_seed(0)
+            output_after = loaded(**inputs).logits
+            tokens_after = loaded.generate(**inputs)
+            assert torch.allclose(logits_before, output_after, atol=atol, rtol=rtol)
+            assert torch.allclose(tokens_before, tokens_after, atol=atol, rtol=rtol)
diff --git a/tests/test_pvera.py b/tests/test_pvera.py
new file mode 100644
index 0000000..128fe1a
--- /dev/null
+++ b/tests/test_pvera.py
@@ -0,0 +1,244 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+# This test file is based on the VeRA test file, since both methods are very close.
+
+import os
+
+import pytest
+import torch
+from accelerate.utils.imports import is_bf16_available
+from safetensors import safe_open
+from torch import nn
+
+from peft import PeftModel, PveraConfig, get_peft_model
+
+
+class MLP(nn.Module):
+    def __init__(self, bias=True):
+        super().__init__()
+        self.relu = nn.ReLU()
+        self.lin0 = nn.Linear(10, 20, bias=bias)
+        self.lin1 = nn.Linear(20, 20, bias=bias)  # lin1 and lin2 have same shape
+        self.lin2 = nn.Linear(20, 20, bias=bias)
+        self.lin3 = nn.Linear(20, 2, bias=bias)
+        self.sm = nn.LogSoftmax(dim=-1)
+
+    def forward(self, X):
+        X = self.lin0(X)
+        X = self.relu(X)
+        X = self.lin1(X)
+        X = self.relu(X)
+        X = self.lin2(X)
+        X = self.relu(X)
+        X = self.lin3(X)
+        X = self.sm(X)
+        return X
+
+
+class TestPVeRA:
+    @pytest.fixture
+    def mlp(self):
+        torch.manual_seed(0)
+        model = MLP()
+        return model
+
+    @pytest.fixture
+    def mlp_same_prng(self, mlp):
+        torch.manual_seed(0)
+
+        config = PveraConfig(target_modules=["lin1", "lin2"], init_weights=False)
+        # creates a default PVeRA adapter
+        peft_model = get_peft_model(mlp, config)
+        config2 = PveraConfig(target_modules=["lin1", "lin2"], init_weights=False)
+        peft_model.add_adapter("other", config2)
+        return peft_model
+
+    def test_multiple_adapters_same_prng_weights(self, mlp_same_prng):
+        # we can have multiple adapters with the same prng key, in which case the weights should be shared
+        assert (
+            mlp_same_prng.base_model.model.lin1.pvera_A["default"]
+            is mlp_same_prng.base_model.model.lin1.pvera_A["other"]
+        )
+        assert (
+            mlp_same_prng.base_model.model.lin1.pvera_B["default"]
+            is mlp_same_prng.base_model.model.lin1.pvera_B["other"]
+        )
+        assert (
+            mlp_same_prng.base_model.model.lin2.pvera_A["default"]
+            is mlp_same_prng.base_model.model.lin2.pvera_A["other"]
+        )
+        assert (
+            mlp_same_prng.base_model.model.lin2.pvera_B["default"]
+            is mlp_same_prng.base_model.model.lin2.pvera_B["other"]
+        )
+
+        input = torch.randn(5, 10)
+        mlp_same_prng.set_adapter("default")
+        output_default = mlp_same_prng(input)
+        mlp_same_prng.set_adapter("other")
+        output_other = mlp_same_prng(input)
+        assert not torch.allclose(output_default, output_other, atol=1e-3, rtol=1e-3)
+
+    def test_multiple_adapters_different_prng_raises(self):
+        # we cannot have multiple adapters with different prng keys
+        model = MLP()
+        config = PveraConfig(target_modules=["lin1", "lin2"], init_weights=False)
+        # creates a default PVeRA adapter
+        peft_model = get_peft_model(model, config)
+        config2 = PveraConfig(target_modules=["lin1", "lin2"], init_weights=False, projection_prng_key=123)
+
+        msg = (
+            r"PVeRA PRNG initialisation key must be the same for all adapters. Got config.projection_prng_key=123 but "
+            r"previous config had 0"
+        )
+        with pytest.raises(ValueError, match=msg):
+            peft_model.add_adapter("other", config2)
+
+    def test_multiple_adapters_save_load_save_projection_false(self, mlp, tmp_path):
+        # check saving and loading works with multiple adapters without saved projection weights
+        torch.manual_seed(1)
+        config = PveraConfig(target_modules=["lin1", "lin2"], init_weights=False, save_projection=False)
+        # creates a default PVeRA adapter
+        peft_model = get_peft_model(mlp, config, adapter_name="first")
+        config2 = PveraConfig(target_modules=["lin1", "lin2"], init_weights=False, save_projection=False)
+        peft_model.add_adapter("second", config2)
+        peft_model.eval()
+
+        input = torch.randn(5, 10)
+        peft_model.set_adapter("first")
+        output_first = peft_model(input)
+        peft_model.set_adapter("second")
+        output_second = peft_model(input)
+
+        # sanity check
+        assert not torch.allclose(output_first, output_second, atol=1e-3, rtol=1e-3)
+
+        save_path = tmp_path / "pvera"
+        peft_model.save_pretrained(save_path)
+        assert os.path.exists(save_path / "first" / "adapter_config.json")
+        assert os.path.exists(save_path / "second" / "adapter_config.json")
+
+        torch.manual_seed(0)
+        mlp = MLP()
+        peft_model = PeftModel.from_pretrained(mlp, save_path / "first", adapter_name="first")
+        peft_model.load_adapter(save_path / "second", "second")
+        peft_model.eval()
+
+        peft_model.set_adapter("first")
+        output_first_loaded = peft_model(input)
+        peft_model.set_adapter("second")
+        output_second_loaded = peft_model(input)
+
+        assert torch.allclose(output_first, output_first_loaded, atol=1e-3, rtol=1e-3)
+        assert torch.allclose(output_second, output_second_loaded, atol=1e-3, rtol=1e-3)
+
+    def test_multiple_adapters_save_projection_false_contains_no_pvera_A_pvera_B(self, mlp, tmp_path):
+        torch.manual_seed(1)
+        config = PveraConfig(target_modules=["lin1", "lin2"], init_weights=False, save_projection=False)
+        # creates a default PVeRA adapter
+        peft_model = get_peft_model(mlp, config, adapter_name="first")
+        config2 = PveraConfig(target_modules=["lin1", "lin2"], init_weights=False, save_projection=False)
+        peft_model.add_adapter("second", config2)
+
+        save_path = tmp_path / "pvera"
+        peft_model.save_pretrained(save_path)
+
+        sd_default = {}
+        with safe_open(save_path / "first" / "adapter_model.safetensors", framework="pt", device="cpu") as f:
+            for key in f.keys():
+                sd_default[key] = f.get_tensor(key)
+
+        assert not any("pvera_A" in key for key in sd_default)
+        assert not any("pvera_B" in key for key in sd_default)
+
+        sd_other = {}
+        with safe_open(save_path / "second" / "adapter_model.safetensors", framework="pt", device="cpu") as f:
+            for key in f.keys():
+                sd_other[key] = f.get_tensor(key)
+
+        assert not any("pvera_A" in key for key in sd_other)
+        assert not any("pvera_B" in key for key in sd_other)
+
+    def test_pvera_A_pvera_B_share_memory(self, mlp_same_prng):
+        pvera_A = mlp_same_prng.pvera_A["default"]
+        pvera_B = mlp_same_prng.pvera_B["default"]
+
+        # these tensors should share the same data
+        assert pvera_A.data_ptr() == mlp_same_prng.base_model.model.lin1.pvera_A["default"].data_ptr()
+        assert pvera_B.data_ptr() == mlp_same_prng.base_model.model.lin1.pvera_B["default"].data_ptr()
+        assert pvera_A.data_ptr() == mlp_same_prng.base_model.model.lin2.pvera_A["default"].data_ptr()
+        assert pvera_B.data_ptr() == mlp_same_prng.base_model.model.lin2.pvera_B["default"].data_ptr()
+        # sanity check: these tensors shouldn't share the same data
+        assert pvera_A.data_ptr() != pvera_B.data_ptr()
+
+    def test_pvera_lambda_dont_share_memory(self, mlp_same_prng):
+        # sanity check: these tensors shouldn't share the same data
+        assert (
+            mlp_same_prng.base_model.model.lin1.pvera_lambda_b["default"].data_ptr()
+            != mlp_same_prng.base_model.model.lin1.pvera_lambda_b["other"].data_ptr()
+        )
+        assert (
+            mlp_same_prng.base_model.model.lin1.pvera_lambda_b["default"].data_ptr()
+            != mlp_same_prng.base_model.model.lin2.pvera_lambda_b["default"].data_ptr()
+        )
+        assert (
+            mlp_same_prng.base_model.model.lin1.pvera_lambda_b["other"].data_ptr()
+            != mlp_same_prng.base_model.model.lin2.pvera_lambda_b["other"].data_ptr()
+        )
+        assert (
+            mlp_same_prng.base_model.model.lin1.pvera_lambda_d["default"].data_ptr()
+            != mlp_same_prng.base_model.model.lin1.pvera_lambda_d["other"].data_ptr()
+        )
+        assert (
+            mlp_same_prng.base_model.model.lin1.pvera_lambda_d["default"].data_ptr()
+            != mlp_same_prng.base_model.model.lin2.pvera_lambda_d["default"].data_ptr()
+        )
+        assert (
+            mlp_same_prng.base_model.model.lin1.pvera_lambda_d["other"].data_ptr()
+            != mlp_same_prng.base_model.model.lin2.pvera_lambda_d["other"].data_ptr()
+        )
+
+    def test_pvera_different_shapes(self, mlp):
+        config = PveraConfig(target_modules=["lin0", "lin3"], init_weights=False)
+        mlp_different_shapes = get_peft_model(mlp, config)
+
+        pvera_A = mlp_different_shapes.pvera_A["default"]
+        pvera_B = mlp_different_shapes.pvera_B["default"]
+
+        # sanity check
+        assert mlp.lin0.base_layer.weight.shape != mlp.lin3.base_layer.weight.shape
+
+        # lin0 has the largest output dimension, lin3 has the largest input dimension
+        # pvera_A should have the shape of (rank*2, largest_in), pvera_B should have the shape of (largest_out, rank)
+        assert pvera_A.shape == (config.r * 2, mlp.lin3.in_features)
+        assert pvera_B.shape == (mlp.lin0.out_features, config.r)
+
+        # should not raise
+        input = torch.randn(5, 10)
+        mlp_different_shapes(input)
+
+    @pytest.mark.parametrize("dtype", [torch.float32, torch.float16, torch.bfloat16])
+    def test_pvera_dtypes(self, dtype):
+        if dtype == torch.bfloat16:
+            # skip if bf16 is not supported on hardware, see #1872
+            if not is_bf16_available():
+                pytest.skip("bfloat16 not supported on this system, skipping the test")
+
+        model = MLP().to(dtype)
+        config = PveraConfig(target_modules=["lin1", "lin2"], init_weights=False)
+        peft_model = get_peft_model(model, config)
+        inputs = torch.randn(5, 10).to(dtype)
+        output = peft_model(inputs)  # should not raise
+        assert output.dtype == dtype
diff --git a/tests/test_quantization.py b/tests/test_quantization.py
new file mode 100644
index 0000000..30980d5
--- /dev/null
+++ b/tests/test_quantization.py
@@ -0,0 +1,345 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+"""
+Test PEFT method x quantization method matrix, focusing on basic tests.
+"""
+
+from dataclasses import dataclass
+
+import pytest
+import torch
+from accelerate.utils.memory import clear_device_cache
+from transformers import AutoModelForCausalLM, BitsAndBytesConfig, TorchAoConfig
+
+from peft import BOFTConfig, MissConfig, VeraConfig, get_peft_model
+from peft.import_utils import (
+    is_bnb_4bit_available,
+    is_bnb_available,
+    is_gptqmodel_available,
+    is_torchao_available,
+)
+from peft.tuners.tuners_utils import BaseTunerLayer
+from peft.utils import infer_device
+from peft.utils.quantization_utils import (
+    Bnb4bitBackend,
+    Bnb8bitBackend,
+    ForwardOnlyQuantizationBackend,
+    TorchaoBackend,
+)
+
+from .testing_utils import hub_online_once, set_init_weights_false
+
+
+SEED = 0
+DEVICE = infer_device()
+MIN_CORR = 0.9
+MAX_MSE = 1.0
+
+
+@dataclass
+class Bnb8bitLoader:
+    name = "bnb_8bit"
+    backend_cls = Bnb8bitBackend
+    supports_merge = True
+    supports_non_quantized_comparison = True
+    model_id = "peft-internal-testing/opt-125m"
+    expected_layer_count = 24  # (q_proj, v_proj) x 12 layers
+
+    def load_model(self):
+        quant_config = BitsAndBytesConfig(load_in_8bit=True)
+        with hub_online_once(self.model_id):
+            return AutoModelForCausalLM.from_pretrained(
+                self.model_id, quantization_config=quant_config, device_map={"": DEVICE}
+            )
+
+
+@dataclass
+class Bnb4bitLoader:
+    name = "bnb_4bit"
+    backend_cls = Bnb4bitBackend
+    supports_merge = True
+    supports_non_quantized_comparison = True
+    model_id = "peft-internal-testing/opt-125m"
+    expected_layer_count = 24  # (q_proj, v_proj) x 12 layers
+
+    def load_model(self):
+        quant_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_use_double_quant=False,
+            bnb_4bit_compute_dtype=torch.float32,
+        )
+        with hub_online_once(self.model_id):
+            return AutoModelForCausalLM.from_pretrained(
+                self.model_id, quantization_config=quant_config, device_map={"": DEVICE}
+            )
+
+
+@dataclass
+class TorchAoInt8WeightOnlyLoader:
+    name = "torchao_int8_weight_only"
+    backend_cls = TorchaoBackend
+    supports_merge = True
+    supports_non_quantized_comparison = True
+    model_id = "peft-internal-testing/opt-125m"
+    expected_layer_count = 24  # (q_proj, v_proj) x 12 layers
+
+    def load_model(self):
+        from torchao.quantization import Int8WeightOnlyConfig
+
+        quant_config = TorchAoConfig(quant_type=Int8WeightOnlyConfig())
+        with hub_online_once(self.model_id):
+            return AutoModelForCausalLM.from_pretrained(
+                self.model_id, quantization_config=quant_config, device_map={"": DEVICE}
+            )
+
+
+@dataclass
+class TorchAoInt8DynamicActivationInt8WeightLoader:
+    name = "torchao_int8_dynamic_activation_int8"
+    backend_cls = TorchaoBackend
+    supports_merge = False
+    supports_non_quantized_comparison = True
+    model_id = "peft-internal-testing/opt-125m"
+    expected_layer_count = 24  # (q_proj, v_proj) x 12 layers
+
+    def load_model(self):
+        from torchao.quantization import Int8DynamicActivationInt8WeightConfig
+
+        quant_config = TorchAoConfig(quant_type=Int8DynamicActivationInt8WeightConfig())
+        with hub_online_once(self.model_id):
+            return AutoModelForCausalLM.from_pretrained(
+                self.model_id, quantization_config=quant_config, device_map={"": DEVICE}
+            )
+
+
+@dataclass
+class Gptq4bitLoader:
+    name = "gptq_4bit"
+    backend_cls = ForwardOnlyQuantizationBackend
+    supports_merge = False
+    # No on-the-fly quantization path; the comparison would need a separate fp model.
+    supports_non_quantized_comparison = False
+    model_id = "marcsun13/opt-350m-gptq-4bit"
+    expected_layer_count = 24  # (q_proj, v_proj) x 12 layers
+
+    def load_model(self):
+        from transformers import GPTQConfig
+
+        quant_config = GPTQConfig(bits=4)
+        with hub_online_once(self.model_id):
+            return AutoModelForCausalLM.from_pretrained(
+                self.model_id,
+                quantization_config=quant_config,
+                dtype=torch.float16,
+                device_map={"": DEVICE},
+            )
+
+
+QUANTIZATION_BACKENDS = []
+if is_bnb_available():
+    QUANTIZATION_BACKENDS.append(Bnb8bitLoader())
+if is_bnb_4bit_available():
+    QUANTIZATION_BACKENDS.append(Bnb4bitLoader())
+if is_torchao_available():
+    QUANTIZATION_BACKENDS.append(TorchAoInt8WeightOnlyLoader())
+    QUANTIZATION_BACKENDS.append(TorchAoInt8DynamicActivationInt8WeightLoader())
+if is_gptqmodel_available():
+    QUANTIZATION_BACKENDS.append(Gptq4bitLoader())
+
+
+def _quant_id(backend):
+    return backend.name
+
+
+TEST_CASES = [
+    (
+        BOFTConfig,
+        {"boft_block_size": 4, "target_modules": ["q_proj", "v_proj"]},
+    ),
+    (
+        MissConfig,
+        {"r": 2},
+    ),
+    (
+        MissConfig,
+        {"r": 2, "init_weights": "bat"},
+    ),
+    (
+        VeraConfig,
+        {"r": 8, "target_modules": ["q_proj", "v_proj"]},
+    ),
+]
+
+
+def _peft_id(val):
+    """Generate test id config_cls / config_kwargs."""
+    if isinstance(val, dict):
+        id_ = str(val).replace(" ", "")
+    else:  # the PEFT config class
+        id_ = val.__name__.removesuffix("Config").lower()
+    return id_
+
+
+def check_outputs_similar(x, y, min_corr=MIN_CORR, max_mse=MAX_MSE):
+    # As quantization introduces a lot of error, use generous tolerances
+    assert x.shape == y.shape
+    corr = torch.corrcoef(torch.stack((x.flatten(), y.flatten())))
+    mse = ((x - y) ** 2).mean()
+
+    corr_checks = corr[0, 1] >= min_corr
+    mse_checks = mse <= max_mse
+    if not corr_checks and not mse_checks:
+        assert False, f"both correlation ({corr[0, 1]:.4f}>={min_corr}) and MSE ({mse:.4f}<={max_mse}) check failed"
+    if not corr_checks:
+        assert False, f"correlation ({corr[0, 1]:.4f}>={min_corr}) check failed"
+    if not mse_checks:
+        assert False, f"MSE ({mse:.4f}<={max_mse}) check failed"
+
+
+class TestQuantization:
+    """Test for PEFT method x quantization method
+
+    Note: It is recommended to keep the number of tests low, as the number of combinations is already large as is. This
+    means testing multiple things per test, even if this is generally not desired. The reason is that we want to keep
+    the number of model initializations to a minimum, as those take time.
+
+    """
+
+    @pytest.fixture(autouse=True)
+    def set_seed(self):
+        torch.manual_seed(SEED)
+
+    @pytest.fixture(autouse=True)
+    def cleanup(self):
+        yield
+        clear_device_cache(garbage_collection=True)
+
+    @pytest.fixture
+    def dummy_input(self):
+        return torch.arange(10).view(1, -1).to(DEVICE)
+
+    @pytest.mark.parametrize("quant", QUANTIZATION_BACKENDS, ids=_quant_id)
+    @pytest.mark.parametrize("config_cls,config_kwargs", TEST_CASES, ids=_peft_id)
+    def test_quantization_backend_is_set_and_repr(self, config_cls, config_kwargs, quant):
+        """PEFT layers should have quantization_backend set"""
+        model = quant.load_model()
+        config = config_cls(**config_kwargs)
+        model = get_peft_model(model, config)
+
+        quantized_layers = [
+            m for m in model.modules() if isinstance(m, BaseTunerLayer) and m.quantization_backend is not None
+        ]
+        assert len(quantized_layers) == quant.expected_layer_count
+        for layer in quantized_layers:
+            rep = repr(layer)
+            assert "quantization_backend=" in rep
+
+    @pytest.mark.parametrize("quant", QUANTIZATION_BACKENDS, ids=_quant_id)
+    @pytest.mark.parametrize("config_cls,config_kwargs", TEST_CASES, ids=_peft_id)
+    def test_forward_changes_output(self, config_cls, config_kwargs, quant, dummy_input):
+        """Check that the forward pass works, also check if the results are affected"""
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        model = quant.load_model()
+
+        with torch.inference_mode():
+            out_base = model(dummy_input).logits
+
+        config = config_cls(**config_kwargs)
+        model = get_peft_model(model, config)
+
+        with torch.inference_mode():
+            out_peft = model(dummy_input).logits
+
+        atol, rtol = 1e-3, 1e-3
+        assert not torch.allclose(out_base, out_peft, atol=atol, rtol=rtol)
+
+    @pytest.mark.parametrize("quant", QUANTIZATION_BACKENDS, ids=_quant_id)
+    @pytest.mark.parametrize("config_cls,config_kwargs", TEST_CASES, ids=_peft_id)
+    def test_quantized_output_similar_to_non_quantized(self, config_cls, config_kwargs, quant, dummy_input):
+        """Quantized PEFT output should be similar to non-quantized PEFT output.
+
+        Both models use the same adapter config with non-identity init. The outputs won't match exactly due to
+        quantization noise, but should be in the same ballpark.
+        """
+        if not quant.supports_non_quantized_comparison:
+            pytest.skip(f"{quant.name} is pre-quantized; no on-the-fly non-quantized counterpart for comparison")
+
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+
+        # Quantized model
+        model = quant.load_model()
+        config = config_cls(**config_kwargs)
+        torch.manual_seed(SEED)
+        model = get_peft_model(model, config).eval()
+
+        with torch.inference_mode():
+            out_quant = model(dummy_input).logits
+
+        del model
+
+        # Non-quantized model
+        with hub_online_once(quant.model_id):
+            model = AutoModelForCausalLM.from_pretrained(quant.model_id, device_map={"": DEVICE})
+        config = config_cls(**config_kwargs.copy())
+        torch.manual_seed(SEED)
+        model = get_peft_model(model, config).eval()
+
+        with torch.inference_mode():
+            out_non_quant = model(dummy_input).logits
+
+        check_outputs_similar(out_non_quant, out_quant)
+
+    @pytest.mark.parametrize("quant", QUANTIZATION_BACKENDS, ids=_quant_id)
+    @pytest.mark.parametrize("config_cls,config_kwargs", TEST_CASES, ids=_peft_id)
+    def test_merge_unmerge_unload(self, config_cls, config_kwargs, quant, dummy_input):
+        """Check merge and unmerge roundtrip"""
+        if not quant.supports_merge:
+            pytest.skip(f"{quant.name} does not support merging")
+        if (DEVICE == "cpu") and isinstance(quant, Bnb4bitLoader):
+            pytest.skip("Bnb 4 bit quant with CPU results in high variance, skipping")
+
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        model = quant.load_model()
+        config = config_cls(**config_kwargs)
+        torch.manual_seed(SEED)
+        model = get_peft_model(model, config).eval()
+
+        with torch.inference_mode():
+            out_before = model(dummy_input).logits
+
+        model.merge_adapter()
+        with torch.inference_mode():
+            out_merged = model(dummy_input).logits
+
+        check_outputs_similar(out_before, out_merged)
+
+        model.unmerge_adapter()
+        with torch.inference_mode():
+            out_unmerged = model(dummy_input).logits
+
+        check_outputs_similar(out_before, out_unmerged)
+
+        model.merge_adapter(safe_merge=True)
+        with torch.inference_mode():
+            out_merged_safe = model(dummy_input).logits
+
+        check_outputs_similar(out_before, out_merged_safe)
+
+        model.unmerge_adapter()
+        model = model.merge_and_unload()
+        with torch.inference_mode():
+            out_unloaded = model(dummy_input).logits
+
+        check_outputs_similar(out_before, out_unloaded)
diff --git a/tests/test_randlora.py b/tests/test_randlora.py
new file mode 100644
index 0000000..dfacee3
--- /dev/null
+++ b/tests/test_randlora.py
@@ -0,0 +1,245 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+# This test file is for tests specific to RandLora, since Randlora has some specific challenges due to the shared weights.
+# These tests are copied from the test_vera.py file
+
+import os
+
+import pytest
+import torch
+from accelerate.utils.imports import is_bf16_available
+from safetensors import safe_open
+from torch import nn
+
+from peft import PeftModel, RandLoraConfig, get_peft_model
+
+
+class MLP(nn.Module):
+    def __init__(self, bias=True):
+        super().__init__()
+        self.relu = nn.ReLU()
+        self.lin0 = nn.Linear(10, 20, bias=bias)
+        self.lin1 = nn.Linear(20, 20, bias=bias)  # lin1 and lin2 have same shape
+        self.lin2 = nn.Linear(20, 20, bias=bias)
+        self.lin3 = nn.Linear(20, 2, bias=bias)
+        self.sm = nn.LogSoftmax(dim=-1)
+
+    def forward(self, X):
+        X = self.lin0(X)
+        X = self.relu(X)
+        X = self.lin1(X)
+        X = self.relu(X)
+        X = self.lin2(X)
+        X = self.relu(X)
+        X = self.lin3(X)
+        X = self.sm(X)
+        return X
+
+
+# Tests copied from the TestVera class in test_vera.py.
+# Changes to the code file should be reflected here.
+class TestRandLora:
+    @pytest.fixture
+    def mlp(self):
+        torch.manual_seed(0)
+        model = MLP()
+        return model
+
+    @pytest.fixture
+    def mlp_same_prng(self, mlp):
+        torch.manual_seed(0)
+
+        config = RandLoraConfig(target_modules=["lin1", "lin2"], init_weights=False)
+        # creates a default RandLora adapter
+        peft_model = get_peft_model(mlp, config)
+        config2 = RandLoraConfig(target_modules=["lin1", "lin2"], init_weights=False)
+        peft_model.add_adapter("other", config2)
+        return peft_model
+
+    def test_multiple_adapters_same_prng_weights(self, mlp_same_prng):
+        # we can have multiple adapters with the same prng key, in which case the weights should be shared
+        assert (
+            mlp_same_prng.base_model.model.lin1.randlora_A["default"]
+            is mlp_same_prng.base_model.model.lin1.randlora_A["other"]
+        )
+        assert (
+            mlp_same_prng.base_model.model.lin1.randlora_B["default"]
+            is mlp_same_prng.base_model.model.lin1.randlora_B["other"]
+        )
+        assert (
+            mlp_same_prng.base_model.model.lin2.randlora_A["default"]
+            is mlp_same_prng.base_model.model.lin2.randlora_A["other"]
+        )
+        assert (
+            mlp_same_prng.base_model.model.lin2.randlora_B["default"]
+            is mlp_same_prng.base_model.model.lin2.randlora_B["other"]
+        )
+
+        input = torch.randn(5, 10)
+        mlp_same_prng.set_adapter("default")
+        output_default = mlp_same_prng(input)
+        mlp_same_prng.set_adapter("other")
+        output_other = mlp_same_prng(input)
+        assert not torch.allclose(output_default, output_other, atol=1e-3, rtol=1e-3)
+
+    def test_multiple_adapters_different_prng_raises(self):
+        # we cannot have multiple adapters with different prng keys
+        model = MLP()
+        config = RandLoraConfig(target_modules=["lin1", "lin2"], init_weights=False)
+        # creates a default RandLora adapter
+        peft_model = get_peft_model(model, config)
+        config2 = RandLoraConfig(target_modules=["lin1", "lin2"], init_weights=False, projection_prng_key=123)
+
+        msg = (
+            r"RandLora PRNG initialisation key must be the same for all adapters. Got config.projection_prng_key=123 but "
+            r"previous config had 0"
+        )
+        with pytest.raises(ValueError, match=msg):
+            peft_model.add_adapter("other", config2)
+
+    def test_multiple_adapters_save_load_save_projection_false(self, mlp, tmp_path):
+        # check saving and loading works with multiple adapters without saved projection weights
+        torch.manual_seed(1)
+        config = RandLoraConfig(target_modules=["lin1", "lin2"], init_weights=False, save_projection=False)
+        # creates a default RandLora adapter
+        peft_model = get_peft_model(mlp, config, adapter_name="first")
+        config2 = RandLoraConfig(target_modules=["lin1", "lin2"], init_weights=False, save_projection=False)
+        peft_model.add_adapter("second", config2)
+
+        input = torch.randn(5, 10)
+        peft_model.set_adapter("first")
+        output_first = peft_model(input)
+        peft_model.set_adapter("second")
+        output_second = peft_model(input)
+
+        # sanity check
+        assert not torch.allclose(output_first, output_second, atol=1e-3, rtol=1e-3)
+
+        save_path = tmp_path / "randlora"
+        peft_model.save_pretrained(save_path)
+        assert os.path.exists(save_path / "first" / "adapter_config.json")
+        assert os.path.exists(save_path / "second" / "adapter_config.json")
+
+        torch.manual_seed(0)
+        mlp = MLP()
+        peft_model = PeftModel.from_pretrained(mlp, save_path / "first", adapter_name="first")
+        peft_model.load_adapter(save_path / "second", "second")
+
+        peft_model.set_adapter("first")
+        output_first_loaded = peft_model(input)
+        peft_model.set_adapter("second")
+        output_second_loaded = peft_model(input)
+
+        assert torch.allclose(output_first, output_first_loaded, atol=1e-3, rtol=1e-3)
+        assert torch.allclose(output_second, output_second_loaded, atol=1e-3, rtol=1e-3)
+
+    def test_multiple_adapters_save_projection_false_contains_no_randlora_A_randlora_B(self, mlp, tmp_path):
+        torch.manual_seed(1)
+        config = RandLoraConfig(target_modules=["lin1", "lin2"], init_weights=False, save_projection=False)
+        # creates a default RandLora adapter
+        peft_model = get_peft_model(mlp, config, adapter_name="first")
+        config2 = RandLoraConfig(target_modules=["lin1", "lin2"], init_weights=False, save_projection=False)
+        peft_model.add_adapter("second", config2)
+
+        save_path = tmp_path / "randlora"
+        peft_model.save_pretrained(save_path)
+
+        sd_default = {}
+        with safe_open(save_path / "first" / "adapter_model.safetensors", framework="pt", device="cpu") as f:
+            for key in f.keys():
+                sd_default[key] = f.get_tensor(key)
+
+        assert not any("randlora_A" in key for key in sd_default)
+        assert not any("randlora_B" in key for key in sd_default)
+
+        sd_other = {}
+        with safe_open(save_path / "second" / "adapter_model.safetensors", framework="pt", device="cpu") as f:
+            for key in f.keys():
+                sd_other[key] = f.get_tensor(key)
+
+        assert not any("randlora_A" in key for key in sd_other)
+        assert not any("randlora_B" in key for key in sd_other)
+
+    def test_randlora_A_randlora_B_share_memory(self, mlp_same_prng):
+        randlora_A = mlp_same_prng.randlora_A["default"]
+        randlora_B = mlp_same_prng.randlora_B["default"]
+
+        # these tensors should share the same data
+        assert randlora_A.data_ptr() == mlp_same_prng.base_model.model.lin1.randlora_A["default"].data_ptr()
+        assert randlora_B.data_ptr() == mlp_same_prng.base_model.model.lin1.randlora_B["default"].data_ptr()
+        assert randlora_A.data_ptr() == mlp_same_prng.base_model.model.lin2.randlora_A["default"].data_ptr()
+        assert randlora_B.data_ptr() == mlp_same_prng.base_model.model.lin2.randlora_B["default"].data_ptr()
+        # sanity check: these tensors shouldn't share the same data
+        assert randlora_A.data_ptr() != randlora_B.data_ptr()
+
+    def test_randlora_lambda_dont_share_memory(self, mlp_same_prng):
+        # sanity check: these tensors shouldn't share the same data
+        assert (
+            mlp_same_prng.base_model.model.lin1.randlora_lambda["default"].data_ptr()
+            != mlp_same_prng.base_model.model.lin1.randlora_lambda["other"].data_ptr()
+        )
+        assert (
+            mlp_same_prng.base_model.model.lin1.randlora_lambda["default"].data_ptr()
+            != mlp_same_prng.base_model.model.lin2.randlora_lambda["default"].data_ptr()
+        )
+        assert (
+            mlp_same_prng.base_model.model.lin1.randlora_lambda["other"].data_ptr()
+            != mlp_same_prng.base_model.model.lin2.randlora_lambda["other"].data_ptr()
+        )
+        assert (
+            mlp_same_prng.base_model.model.lin1.randlora_gamma["default"].data_ptr()
+            != mlp_same_prng.base_model.model.lin1.randlora_gamma["other"].data_ptr()
+        )
+        assert (
+            mlp_same_prng.base_model.model.lin1.randlora_gamma["default"].data_ptr()
+            != mlp_same_prng.base_model.model.lin2.randlora_gamma["default"].data_ptr()
+        )
+        assert (
+            mlp_same_prng.base_model.model.lin1.randlora_gamma["other"].data_ptr()
+            != mlp_same_prng.base_model.model.lin2.randlora_gamma["other"].data_ptr()
+        )
+
+    def test_randlora_different_shapes(self, mlp):
+        config = RandLoraConfig(target_modules=["lin0", "lin3"], init_weights=False)
+        mlp_different_shapes = get_peft_model(mlp, config)
+
+        randlora_A = mlp_different_shapes.randlora_A["default"]
+        randlora_B = mlp_different_shapes.randlora_B["default"]
+
+        # sanity check
+        assert mlp.lin0.base_layer.weight.shape != mlp.lin3.base_layer.weight.shape
+
+        # lin0 has the largest output dimension, lin3 has the largest input dimension
+        # randlora_A should have the shape of (rank, largest_in), randlora_B should have the shape of (largest_out, rank)
+        assert randlora_A.shape == (config.r, 1, mlp.lin3.in_features)
+        assert randlora_B.shape == (mlp.lin0.out_features, 1, config.r)
+
+        # should not raise
+        input = torch.randn(5, 10)
+        mlp_different_shapes(input)
+
+    @pytest.mark.parametrize("dtype", [torch.float32, torch.float16, torch.bfloat16])
+    def test_randlora_dtypes(self, dtype):
+        if dtype == torch.bfloat16:
+            # skip if bf16 is not supported on hardware, see #1872
+            if not is_bf16_available():
+                pytest.skip("bfloat16 not supported on this system, skipping the test")
+
+        model = MLP().to(dtype)
+        config = RandLoraConfig(target_modules=["lin1", "lin2"], init_weights=False)
+        peft_model = get_peft_model(model, config)
+        inputs = torch.randn(5, 10).to(dtype)
+        output = peft_model(inputs)  # should not raise
+        assert output.dtype == dtype
diff --git a/tests/test_seq_classifier.py b/tests/test_seq_classifier.py
new file mode 100644
index 0000000..1a77ca0
--- /dev/null
+++ b/tests/test_seq_classifier.py
@@ -0,0 +1,405 @@
+#  Copyright 2025-present the HuggingFace Inc. 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 governing permissions and limitations under the License.
+
+import pytest
+import torch
+from transformers import AutoModelForSequenceClassification
+
+from peft import (
+    AdaLoraConfig,
+    AdamssConfig,
+    BeftConfig,
+    BOFTConfig,
+    C3AConfig,
+    DeftConfig,
+    DeloraConfig,
+    FourierFTConfig,
+    FrodConfig,
+    GloraConfig,
+    GraloraConfig,
+    HiraConfig,
+    HRAConfig,
+    IA3Config,
+    LilyConfig,
+    LoraConfig,
+    MissConfig,
+    OFTConfig,
+    PeanutConfig,
+    PrefixTuningConfig,
+    PromptEncoderConfig,
+    PromptTuningConfig,
+    PromptTuningInit,
+    PsoftConfig,
+    RoadConfig,
+    ShiraConfig,
+    TinyLoraConfig,
+    VBLoRAConfig,
+    VeraConfig,
+    WaveFTConfig,
+    get_peft_model,
+)
+from peft.utils.other import ModulesToSaveWrapper
+
+from .testing_common import PeftCommonTester
+from .testing_utils import hub_online_once, set_init_weights_false
+
+
+# Note: models from peft-internal-testing are just the safetensors versions of hf-internal-testing
+PEFT_SEQ_CLS_MODELS_TO_TEST = [
+    "peft-internal-testing/tiny-random-BertForSequenceClassification",
+    "peft-internal-testing/tiny-random-RobertaForSequenceClassification",
+    "trl-internal-testing/tiny-LlamaForSequenceClassification-3.2",
+]
+
+
+ALL_CONFIGS = [
+    (
+        AdaLoraConfig,
+        {
+            "task_type": "SEQ_CLS",
+            "target_modules": None,
+            "total_step": 1,
+        },
+    ),
+    (
+        BeftConfig,
+        {
+            "task_type": "SEQ_CLS",
+            "target_modules": None,
+        },
+    ),
+    (
+        BOFTConfig,
+        {
+            "task_type": "SEQ_CLS",
+            "target_modules": None,
+        },
+    ),
+    (
+        MissConfig,
+        {
+            "task_type": "SEQ_CLS",
+            "target_modules": None,
+            "r": 2,
+        },
+    ),
+    (
+        DeftConfig,
+        {
+            "task_type": "SEQ_CLS",
+            "target_modules": None,
+        },
+    ),
+    (
+        DeloraConfig,
+        {
+            "task_type": "SEQ_CLS",
+            "target_modules": None,
+            "r": 2,
+        },
+    ),
+    (
+        FourierFTConfig,
+        {
+            "task_type": "SEQ_CLS",
+            "n_frequency": 10,
+            "target_modules": None,
+        },
+    ),
+    (
+        FrodConfig,
+        {
+            "task_type": "SEQ_CLS",
+            "target_modules": None,
+            "sparse_rate": 0.01,
+        },
+    ),
+    (
+        GloraConfig,
+        {
+            "task_type": "SEQ_CLS",
+            "target_modules": None,
+        },
+    ),
+    (
+        GraloraConfig,
+        {
+            "task_type": "SEQ_CLS",
+            "target_modules": None,
+        },
+    ),
+    (
+        HiraConfig,
+        {
+            "task_type": "SEQ_CLS",
+            "target_modules": None,
+        },
+    ),
+    (
+        HRAConfig,
+        {
+            "task_type": "SEQ_CLS",
+            "target_modules": None,
+        },
+    ),
+    (
+        IA3Config,
+        {
+            "task_type": "SEQ_CLS",
+            "target_modules": None,
+            "feedforward_modules": None,
+        },
+    ),
+    (
+        LilyConfig,
+        {
+            "task_type": "SEQ_CLS",
+            "target_modules": None,
+            "r": 8,
+            "stride_A": 1,
+            "num_B": 2,
+        },
+    ),
+    (
+        LoraConfig,
+        {
+            "task_type": "SEQ_CLS",
+            "r": 8,
+            "lora_alpha": 32,
+            "target_modules": None,
+            "lora_dropout": 0.05,
+            "bias": "none",
+        },
+    ),
+    #  LoRA + trainable tokens
+    (
+        LoraConfig,
+        {
+            "task_type": "SEQ_CLS",
+            "r": 8,
+            "lora_alpha": 32,
+            "target_modules": None,
+            "lora_dropout": 0.05,
+            "bias": "none",
+            "trainable_token_indices": [0, 1, 3],
+        },
+    ),
+    (
+        OFTConfig,
+        {
+            "task_type": "SEQ_CLS",
+            "target_modules": None,
+        },
+    ),
+    (
+        PrefixTuningConfig,
+        {
+            "task_type": "SEQ_CLS",
+            "num_virtual_tokens": 10,
+        },
+    ),
+    (
+        PromptEncoderConfig,
+        {
+            "task_type": "SEQ_CLS",
+            "num_virtual_tokens": 10,
+            "encoder_hidden_size": 32,
+        },
+    ),
+    (
+        PromptTuningConfig,
+        {
+            "task_type": "SEQ_CLS",
+            "num_virtual_tokens": 10,
+        },
+    ),
+    (
+        PsoftConfig,
+        {
+            "task_type": "SEQ_CLS",
+            "r": 32,
+            "psoft_alpha": 32,
+            "target_modules": None,
+        },
+    ),
+    (
+        PeanutConfig,
+        {
+            "r": 8,
+            "depth": 1,
+            "act_fn": "relu",
+            "task_type": "SEQ_CLS",
+            "target_modules": None,
+        },
+    ),
+    (
+        RoadConfig,
+        {
+            "task_type": "SEQ_CLS",
+            "variant": "road_1",
+            "group_size": 2,
+        },
+    ),
+    (
+        ShiraConfig,
+        {
+            "r": 1,
+            "task_type": "SEQ_CLS",
+            "target_modules": None,
+            "init_weights": False,
+        },
+    ),
+    (
+        VBLoRAConfig,
+        {
+            "task_type": "SEQ_CLS",
+            "target_modules": None,
+            "vblora_dropout": 0.05,
+            "vector_length": 1,
+            "num_vectors": 2,
+        },
+    ),
+    (
+        VeraConfig,
+        {
+            "task_type": "SEQ_CLS",
+            "r": 8,
+            "target_modules": None,
+            "vera_dropout": 0.05,
+            "projection_prng_key": 0xFF,
+            "d_initial": 0.1,
+            "save_projection": True,
+            "bias": "none",
+        },
+    ),
+    (
+        TinyLoraConfig,
+        {
+            "task_type": "SEQ_CLS",
+            "target_modules": None,
+        },
+    ),
+    (
+        C3AConfig,
+        {
+            "task_type": "SEQ_CLS",
+            "block_size": 1,
+            "target_modules": None,
+        },
+    ),
+    (
+        WaveFTConfig,
+        {
+            "task_type": "SEQ_CLS",
+            "n_frequency": 8,
+            "target_modules": None,
+        },
+    ),
+    (
+        AdamssConfig,
+        {
+            "task_type": "SEQ_CLS",
+            "target_modules": None,
+            "r": 8,
+        },
+    ),
+]
+
+
+class TestSequenceClassificationModels(PeftCommonTester):
+    r"""
+    Tests for basic coverage of AutoModelForSequenceClassification and classification-specific cases. Most of the
+    functionality is probably already covered by other tests.
+    """
+
+    transformers_class = AutoModelForSequenceClassification
+
+    def prepare_inputs_for_testing(self):
+        input_ids = torch.tensor([[1, 1, 1], [1, 2, 1]]).to(self.torch_device)
+        attention_mask = torch.tensor([[1, 1, 1], [1, 0, 1]]).to(self.torch_device)
+        return {"input_ids": input_ids, "attention_mask": attention_mask}
+
+    @pytest.mark.parametrize("model_id", PEFT_SEQ_CLS_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_attributes_parametrized(self, model_id, config_cls, config_kwargs):
+        self._test_model_attr(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_SEQ_CLS_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_adapter_name(self, model_id, config_cls, config_kwargs):
+        self._test_adapter_name(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_SEQ_CLS_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_prepare_for_training_parametrized(self, model_id, config_cls, config_kwargs):
+        self._test_prepare_for_training(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_SEQ_CLS_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_prompt_tuning_text_prepare_for_training(self, model_id, config_cls, config_kwargs):
+        if config_cls != PromptTuningConfig:
+            pytest.skip(f"This test does not apply to {config_cls}")
+        config_kwargs = config_kwargs.copy()
+        config_kwargs["prompt_tuning_init"] = PromptTuningInit.TEXT
+        config_kwargs["prompt_tuning_init_text"] = "This is a test prompt."
+        config_kwargs["tokenizer_name_or_path"] = model_id
+        self._test_prepare_for_training(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_SEQ_CLS_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_save_pretrained(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_save_pretrained(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_SEQ_CLS_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_save_pretrained_pickle(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_save_pretrained(model_id, config_cls, config_kwargs.copy(), safe_serialization=False)
+
+    @pytest.mark.parametrize("model_id", PEFT_SEQ_CLS_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_save_pretrained_selected_adapters(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_save_pretrained_selected_adapters(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_SEQ_CLS_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_save_pretrained_selected_adapters_pickle(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_save_pretrained_selected_adapters(
+            model_id, config_cls, config_kwargs.copy(), safe_serialization=False
+        )
+
+    @pytest.mark.parametrize("model_id", PEFT_SEQ_CLS_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_from_pretrained_config_construction(self, model_id, config_cls, config_kwargs):
+        self._test_from_pretrained_config_construction(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id", PEFT_SEQ_CLS_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", ALL_CONFIGS)
+    def test_modules_to_save_correctly_set(self, model_id, config_cls, config_kwargs):
+        # tests for a regression, introduced via #2220, where modules_to_save was not applied to prompt learning methods
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+            model = get_peft_model(model, config)
+            base_model = model.get_base_model()
+            # classifier layer is called either "classifier" or "score"
+            classifier = getattr(base_model, "classifier", getattr(base_model, "score", None))
+            if classifier is None:
+                raise ValueError(f"Could not determine classifier layer name for {model_id}, please fix the test")
+            assert isinstance(classifier, ModulesToSaveWrapper)
diff --git a/tests/test_shira.py b/tests/test_shira.py
new file mode 100644
index 0000000..9845ee4
--- /dev/null
+++ b/tests/test_shira.py
@@ -0,0 +1,278 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+# This test file is for tests specific to SHiRA.
+
+import os
+
+import pytest
+import torch
+from accelerate.utils.imports import is_bf16_available
+from torch import nn
+
+from peft import PeftModel, ShiraConfig, get_peft_model
+
+
+def custom_random_mask_function_with_custom_kwargs(custom_arg):
+    def mask_fn(base_layer, r):
+        """
+        This mask function is similar to the random_mask provided in src/peft/tuners/shira/mask_functions.py except the
+        seed is derived from custom_kwargs. Please use this as an example to create your own custom sparse masks that
+        may use custom_kwargs. Remember, for a pretrained weight with shape m, n, mask_fn must return only one mask
+        (shape: m, n) which must be binary 0 or 1 with num_shira_parameters = r(m+n) for linear layers. Device and
+        dtype of mask must be same as base layer's weight's device and dtype.
+        """
+        new_seed = custom_arg
+        shape = base_layer.weight.shape
+        num_shira_weights = r * (shape[0] + shape[1])
+        random_generator = torch.Generator()
+        random_generator.manual_seed(new_seed)
+
+        idx = (torch.randperm(base_layer.weight.numel(), generator=random_generator)[:num_shira_weights]).to(
+            base_layer.weight.device
+        )
+        val = torch.ones_like(idx.type(base_layer.weight.dtype))
+        mask = torch.zeros_like(base_layer.weight.view(1, -1))
+        mask = mask.scatter_(1, idx.unsqueeze(0), val.unsqueeze(0)).view(shape)
+
+        return mask
+
+    return mask_fn
+
+
+class MLP(nn.Module):
+    def __init__(self, bias=True):
+        super().__init__()
+        self.relu = nn.ReLU()
+        self.lin0 = nn.Linear(10, 20, bias=bias)
+        self.lin1 = nn.Linear(20, 40, bias=bias)  # lin1 and lin2 have same shape
+        self.lin2 = nn.Linear(40, 30, bias=bias)
+        self.lin3 = nn.Linear(30, 10, bias=bias)
+        self.sm = nn.LogSoftmax(dim=-1)
+
+    def forward(self, X):
+        X = self.lin0(X)
+        X = self.relu(X)
+        X = self.lin1(X)
+        X = self.relu(X)
+        X = self.lin2(X)
+        X = self.relu(X)
+        X = self.lin3(X)
+        X = self.sm(X)
+        return X
+
+
+class TestShira:
+    @pytest.fixture
+    def mlp(self):
+        torch.manual_seed(0)
+        model = MLP()
+        return model
+
+    def test_mlp_single_adapter_shapes(self, mlp):
+        # torch.manual_seed(0)
+
+        r = 2
+        config = ShiraConfig(r=r, target_modules=["lin1", "lin2"])
+        # creates a default SHiRA adapter
+        peft_model = get_peft_model(mlp, config)
+
+        shira_weight1_size = peft_model.base_model.model.lin1.shira_weight["default"].shape[0]
+        shira_weight2_size = peft_model.base_model.model.lin2.shira_weight["default"].shape[0]
+        shira_indices1_size = peft_model.base_model.model.lin1.shira_indices["default"].shape[1]
+        shira_indices2_size = peft_model.base_model.model.lin2.shira_indices["default"].shape[1]
+
+        base_weight1_size = peft_model.base_model.model.lin1.base_layer.weight.shape
+        base_weight2_size = peft_model.base_model.model.lin2.base_layer.weight.shape
+
+        delta_weight1_shape = peft_model.base_model.model.lin1.get_delta_weight("default").shape
+        delta_weight2_shape = peft_model.base_model.model.lin2.get_delta_weight("default").shape
+
+        assert shira_weight1_size == r * (base_weight1_size[0] + base_weight1_size[1])
+        assert shira_weight2_size == r * (base_weight2_size[0] + base_weight2_size[1])
+
+        assert shira_weight1_size == shira_indices1_size
+        assert shira_weight2_size == shira_indices2_size
+
+        assert delta_weight1_shape == base_weight1_size
+        assert delta_weight2_shape == base_weight2_size
+
+        return peft_model
+
+    def test_multiple_adapters_save_load(self, mlp, tmp_path):
+        # check saving and loading works with multiple adapters
+        # note, the random seeds in the below two configs are not the default values.
+        # so it will lead to different random sparse masks between saving and loading.
+        # our goal is to make sure that loaded indices are exactly the same as the saved indices regardless of what initial random mask gets generated.
+        # we will also make sure that parameters are saved and loaded correctly, and the output remains the same.
+        config = ShiraConfig(r=2, target_modules=["lin1", "lin2"], random_seed=56)
+        # creates a default SHiRA adapter
+        peft_model = get_peft_model(mlp, config, adapter_name="first")
+        config2 = ShiraConfig(r=3, target_modules=["lin1", "lin2", "lin3"], random_seed=67)
+        peft_model.add_adapter("second", config2)
+
+        assert torch.all(peft_model.base_model.model.lin1.shira_weight["first"] == 0)
+        assert torch.all(peft_model.base_model.model.lin2.shira_weight["first"] == 0)
+        assert torch.all(peft_model.base_model.model.lin1.shira_weight["second"] == 0)
+        assert torch.all(peft_model.base_model.model.lin2.shira_weight["second"] == 0)
+        assert torch.all(peft_model.base_model.model.lin3.shira_weight["second"] == 0)
+
+        shira_assign_val1_f = torch.randn_like(peft_model.base_model.model.lin1.shira_weight["first"])
+        peft_model.base_model.model.lin1.shira_weight["first"] = shira_assign_val1_f
+        shira_indices1_f = peft_model.base_model.model.lin1.shira_indices["first"]
+        shira_assign_val2_f = torch.randn_like(peft_model.base_model.model.lin2.shira_weight["first"])
+        peft_model.base_model.model.lin2.shira_weight["first"] = shira_assign_val2_f
+        shira_indices2_f = peft_model.base_model.model.lin2.shira_indices["first"]
+
+        shira_assign_val1_s = torch.randn_like(peft_model.base_model.model.lin1.shira_weight["second"])
+        peft_model.base_model.model.lin1.shira_weight["second"] = shira_assign_val1_s
+        shira_indices1_s = peft_model.base_model.model.lin1.shira_indices["second"]
+        shira_assign_val2_s = torch.randn_like(peft_model.base_model.model.lin2.shira_weight["second"])
+        peft_model.base_model.model.lin2.shira_weight["second"] = shira_assign_val2_s
+        shira_indices2_s = peft_model.base_model.model.lin2.shira_indices["second"]
+        shira_assign_val3_s = torch.randn_like(peft_model.base_model.model.lin3.shira_weight["second"])
+        peft_model.base_model.model.lin3.shira_weight["second"] = shira_assign_val3_s
+        shira_indices3_s = peft_model.base_model.model.lin3.shira_indices["second"]
+
+        input = torch.randn(5, 10)
+        peft_model.set_adapter("first")
+        output_first = peft_model(input)
+        peft_model.set_adapter("second")
+        output_second = peft_model(input)
+
+        # sanity check
+        assert not torch.allclose(output_first, output_second, atol=1e-3, rtol=1e-3)
+
+        save_path = os.path.join(tmp_path, "shira")
+        peft_model.save_pretrained(save_path)
+        assert os.path.exists(os.path.join(save_path, "first", "adapter_config.json"))
+        assert os.path.exists(os.path.join(save_path, "second", "adapter_config.json"))
+        del peft_model
+
+        torch.manual_seed(0)
+        mlp = MLP()
+        peft_model = PeftModel.from_pretrained(mlp, os.path.join(save_path, "first"), adapter_name="first")
+        peft_model.load_adapter(os.path.join(save_path, "second"), "second")
+
+        peft_model.set_adapter("first")
+        output_first_loaded = peft_model(input)
+        peft_model.set_adapter("second")
+        output_second_loaded = peft_model(input)
+
+        assert torch.allclose(output_first, output_first_loaded)
+        assert torch.allclose(output_second, output_second_loaded)
+
+        assert torch.all(shira_assign_val1_f == peft_model.base_model.model.lin1.shira_weight["first"])
+        assert torch.all(shira_assign_val2_f == peft_model.base_model.model.lin2.shira_weight["first"])
+        assert torch.all(shira_indices1_f == peft_model.base_model.model.lin1.shira_indices["first"])
+        assert torch.all(shira_indices2_f == peft_model.base_model.model.lin2.shira_indices["first"])
+        assert torch.all(shira_assign_val1_s == peft_model.base_model.model.lin1.shira_weight["second"])
+        assert torch.all(shira_assign_val2_s == peft_model.base_model.model.lin2.shira_weight["second"])
+        assert torch.all(shira_assign_val3_s == peft_model.base_model.model.lin3.shira_weight["second"])
+        assert torch.all(shira_indices1_s == peft_model.base_model.model.lin1.shira_indices["second"])
+        assert torch.all(shira_indices2_s == peft_model.base_model.model.lin2.shira_indices["second"])
+        assert torch.all(shira_indices3_s == peft_model.base_model.model.lin3.shira_indices["second"])
+
+        return peft_model
+
+    def test_save_load_custom_mask_function(self, mlp, tmp_path):
+        # we want to see if saving and loading works when a custom mask is involved
+        config = ShiraConfig(r=2, mask_type="custom", target_modules=["lin1", "lin2"], init_weights=False)
+        custom_arg = 120
+        custom_mask_fn = custom_random_mask_function_with_custom_kwargs(custom_arg)
+        config.mask_fn = custom_mask_fn
+
+        # create a custom mask SHiRA adapter
+        peft_model = get_peft_model(mlp, config, adapter_name="first")
+
+        shira_assign_val1_f = peft_model.base_model.model.lin1.shira_weight["first"]
+        shira_indices1_f = peft_model.base_model.model.lin1.shira_indices["first"]
+        shira_assign_val2_f = peft_model.base_model.model.lin2.shira_weight["first"]
+        shira_indices2_f = peft_model.base_model.model.lin2.shira_indices["first"]
+
+        input = torch.randn(5, 10)
+        peft_model.set_adapter("first")
+        output_first = peft_model(input)
+
+        save_path = os.path.join(tmp_path, "shira")
+        peft_model.save_pretrained(save_path)
+        assert os.path.exists(os.path.join(save_path, "first", "adapter_config.json"))
+        del peft_model
+
+        torch.manual_seed(0)
+        mlp = MLP()
+        peft_model = PeftModel.from_pretrained(mlp, os.path.join(save_path, "first"), adapter_name="first")
+
+        peft_model.set_adapter("first")
+        output_first_loaded = peft_model(input)
+
+        assert torch.allclose(output_first, output_first_loaded)
+
+        assert torch.all(shira_assign_val1_f == peft_model.base_model.model.lin1.shira_weight["first"])
+        assert torch.all(shira_assign_val2_f == peft_model.base_model.model.lin2.shira_weight["first"])
+        assert torch.all(shira_indices1_f == peft_model.base_model.model.lin1.shira_indices["first"])
+        assert torch.all(shira_indices2_f == peft_model.base_model.model.lin2.shira_indices["first"])
+
+        return peft_model
+
+    def test_save_load_default_random_mask_with_seed_function(self, mlp, tmp_path):
+        # we want to see if saving and loading works when a random mask is involved but the random seed is fixed.
+        config = ShiraConfig(r=2, target_modules=["lin1", "lin2"], random_seed=567, init_weights=False)
+
+        # create a custom mask SHiRA adapter
+        peft_model = get_peft_model(mlp, config, adapter_name="first")
+
+        shira_assign_val1_f = peft_model.base_model.model.lin1.shira_weight["first"]
+        shira_indices1_f = peft_model.base_model.model.lin1.shira_indices["first"]
+        shira_assign_val2_f = peft_model.base_model.model.lin2.shira_weight["first"]
+        shira_indices2_f = peft_model.base_model.model.lin2.shira_indices["first"]
+
+        input = torch.randn(5, 10)
+        peft_model.set_adapter("first")
+        output_first = peft_model(input)
+
+        save_path = os.path.join(tmp_path, "shira")
+        peft_model.save_pretrained(save_path)
+        assert os.path.exists(os.path.join(save_path, "first", "adapter_config.json"))
+        del peft_model
+
+        torch.manual_seed(0)
+        mlp = MLP()
+        peft_model = PeftModel.from_pretrained(mlp, os.path.join(save_path, "first"), adapter_name="first")
+
+        peft_model.set_adapter("first")
+        output_first_loaded = peft_model(input)
+
+        assert torch.allclose(output_first, output_first_loaded)
+
+        assert torch.all(shira_assign_val1_f == peft_model.base_model.model.lin1.shira_weight["first"])
+        assert torch.all(shira_assign_val2_f == peft_model.base_model.model.lin2.shira_weight["first"])
+        assert torch.all(shira_indices1_f == peft_model.base_model.model.lin1.shira_indices["first"])
+        assert torch.all(shira_indices2_f == peft_model.base_model.model.lin2.shira_indices["first"])
+
+        return peft_model
+
+    @pytest.mark.parametrize("dtype", [torch.float32, torch.float16, torch.bfloat16])
+    def test_shira_dtypes(self, dtype):
+        if dtype == torch.bfloat16:
+            # skip if bf16 is not supported on hardware, see #1872
+            if not is_bf16_available():
+                pytest.skip("bfloat16 not supported on this system, skipping the test")
+
+        model = MLP().to(dtype)
+        config = ShiraConfig(r=2, target_modules=["lin1", "lin2"])
+        peft_model = get_peft_model(model, config)
+        inputs = torch.randn(5, 10).to(dtype)
+        output = peft_model(inputs)  # should not raise
+        assert output.dtype == dtype
diff --git a/tests/test_stablediffusion.py b/tests/test_stablediffusion.py
new file mode 100644
index 0000000..d25aa18
--- /dev/null
+++ b/tests/test_stablediffusion.py
@@ -0,0 +1,475 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import copy
+from dataclasses import asdict, replace
+
+import diffusers
+import numpy as np
+import packaging.version
+import pytest
+import torch
+from diffusers import AutoModel, StableDiffusionPipeline
+
+from peft import (
+    BOFTConfig,
+    HRAConfig,
+    LoHaConfig,
+    LoKrConfig,
+    LoraConfig,
+    OFTConfig,
+    convert_to_lora,
+    get_peft_model,
+    get_peft_model_state_dict,
+    inject_adapter_in_model,
+    set_peft_model_state_dict,
+)
+from peft.tuners.tuners_utils import BaseTunerLayer
+
+from .testing_common import PeftCommonTester
+from .testing_utils import hub_online_once, set_init_weights_false, temp_seed
+
+
+# TODO: remove once Diffusers 0.40 is released
+is_diffusers_ge_v040 = packaging.version.parse(diffusers.__version__) >= packaging.version.parse("0.40.0.dev0")
+
+
+PEFT_DIFFUSERS_SD_MODELS_TO_TEST = ["hf-internal-testing/tiny-sd-pipe"]
+DIFFUSERS_CONFIGS = [
+    (
+        LoraConfig,
+        {
+            "text_encoder": {
+                "r": 8,
+                "lora_alpha": 32,
+                "target_modules": ["k_proj", "q_proj", "v_proj", "out_proj", "fc1", "fc2"],
+                "lora_dropout": 0.0,
+                "bias": "none",
+                "init_lora_weights": False,
+            },
+            "unet": {
+                "r": 8,
+                "lora_alpha": 32,
+                "target_modules": [
+                    "proj_in",
+                    "proj_out",
+                    "to_k",
+                    "to_q",
+                    "to_v",
+                    "to_out.0",
+                    "ff.net.0.proj",
+                    "ff.net.2",
+                ],
+                "lora_dropout": 0.0,
+                "bias": "none",
+                "init_lora_weights": False,
+            },
+        },
+    ),
+    (
+        LoHaConfig,
+        {
+            "text_encoder": {
+                "r": 8,
+                "alpha": 32,
+                "target_modules": ["k_proj", "q_proj", "v_proj", "out_proj", "fc1", "fc2"],
+                "rank_dropout": 0.0,
+                "module_dropout": 0.0,
+                "init_weights": False,
+            },
+            "unet": {
+                "r": 8,
+                "alpha": 32,
+                "target_modules": [
+                    "proj_in",
+                    "proj_out",
+                    "to_k",
+                    "to_q",
+                    "to_v",
+                    "to_out.0",
+                    "ff.net.0.proj",
+                    "ff.net.2",
+                ],
+                "rank_dropout": 0.0,
+                "module_dropout": 0.0,
+                "init_weights": False,
+            },
+        },
+    ),
+    (
+        LoKrConfig,
+        {
+            "text_encoder": {
+                "r": 8,
+                "alpha": 32,
+                "target_modules": ["k_proj", "q_proj", "v_proj", "out_proj", "fc1", "fc2"],
+                "rank_dropout": 0.0,
+                "module_dropout": 0.0,
+                "init_weights": False,
+            },
+            "unet": {
+                "r": 8,
+                "alpha": 32,
+                "target_modules": [
+                    "proj_in",
+                    "proj_out",
+                    "to_k",
+                    "to_q",
+                    "to_v",
+                    "to_out.0",
+                    "ff.net.0.proj",
+                    "ff.net.2",
+                ],
+                "rank_dropout": 0.0,
+                "module_dropout": 0.0,
+                "init_weights": False,
+            },
+        },
+    ),
+    (
+        OFTConfig,
+        {
+            "text_encoder": {
+                "r": 1,
+                "oft_block_size": 0,
+                "target_modules": ["k_proj", "q_proj", "v_proj", "out_proj", "fc1", "fc2"],
+                "module_dropout": 0.0,
+                "init_weights": False,
+                "use_cayley_neumann": False,
+            },
+            "unet": {
+                "r": 1,
+                "oft_block_size": 0,
+                "target_modules": [
+                    "proj_in",
+                    "proj_out",
+                    "to_k",
+                    "to_q",
+                    "to_v",
+                    "to_out.0",
+                    "ff.net.0.proj",
+                    "ff.net.2",
+                ],
+                "module_dropout": 0.0,
+                "init_weights": False,
+                "use_cayley_neumann": False,
+            },
+        },
+    ),
+    (
+        BOFTConfig,
+        {
+            "text_encoder": {
+                "boft_block_num": 1,
+                "boft_block_size": 0,
+                "target_modules": ["k_proj", "q_proj", "v_proj", "out_proj", "fc1", "fc2"],
+                "boft_dropout": 0.0,
+                "init_weights": False,
+            },
+            "unet": {
+                "boft_block_num": 1,
+                "boft_block_size": 0,
+                "target_modules": [
+                    "proj_in",
+                    "proj_out",
+                    "to_k",
+                    "to_q",
+                    "to_v",
+                    "to_out.0",
+                    "ff.net.0.proj",
+                    "ff.net.2",
+                ],
+                "boft_dropout": 0.0,
+                "init_weights": False,
+            },
+        },
+    ),
+    (
+        HRAConfig,
+        {
+            "text_encoder": {
+                "r": 8,
+                "target_modules": ["k_proj", "q_proj", "v_proj", "out_proj", "fc1", "fc2"],
+                "init_weights": False,
+            },
+            "unet": {
+                "r": 8,
+                "target_modules": [
+                    "proj_in",
+                    "proj_out",
+                    "to_k",
+                    "to_q",
+                    "to_v",
+                    "to_out.0",
+                    "ff.net.0.proj",
+                    "ff.net.2",
+                ],
+                "init_weights": False,
+            },
+        },
+    ),
+]
+
+
+def skip_if_not_lora(config_cls):
+    if config_cls != LoraConfig:
+        pytest.skip("Skipping test because it is only applicable to LoraConfig")
+
+
+class TestStableDiffusionModel(PeftCommonTester):
+    r"""
+    Tests that diffusers StableDiffusion model works with PEFT as expected.
+    """
+
+    transformers_class = StableDiffusionPipeline
+
+    @pytest.fixture(scope="class", autouse=True)
+    def load_sd_pipeline(self, request):
+        # warning: don't use self.sd_model = ... because this is a class fixture
+        request.cls.sd_model = StableDiffusionPipeline.from_pretrained("hf-internal-testing/tiny-sd-pipe")
+
+    def instantiate_sd_peft(self, model_id, config_cls, config_kwargs):
+        # Instantiate StableDiffusionPipeline
+        if model_id == "hf-internal-testing/tiny-sd-pipe":
+            # in CI, this model often times out on the hub, let's cache it
+            model = copy.deepcopy(self.sd_model)
+        else:
+            model = self.transformers_class.from_pretrained(model_id)
+
+        config_kwargs = config_kwargs.copy()
+        text_encoder_kwargs = config_kwargs.pop("text_encoder")
+        unet_kwargs = config_kwargs.pop("unet")
+        # the remaining config kwargs should be applied to both configs
+        for key, val in config_kwargs.items():
+            text_encoder_kwargs[key] = val
+            unet_kwargs[key] = val
+
+        # Instantiate text_encoder adapter
+        config_text_encoder = config_cls(**text_encoder_kwargs)
+        model.text_encoder = get_peft_model(model.text_encoder, config_text_encoder)
+
+        # Instantiate unet adapter
+        config_unet = config_cls(**unet_kwargs)
+        model.unet = get_peft_model(model.unet, config_unet)
+
+        # Move model to device
+        model = model.to(self.torch_device)
+
+        return model
+
+    def prepare_inputs_for_testing(self):
+        return {
+            "prompt": "a high quality digital photo of a cute corgi",
+            "num_inference_steps": 3,
+        }
+
+    @pytest.mark.parametrize("model_id", PEFT_DIFFUSERS_SD_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", DIFFUSERS_CONFIGS)
+    def test_merge_layers(self, model_id, config_cls, config_kwargs):
+        if (config_cls == LoKrConfig) and (self.torch_device not in ["cuda", "xpu"]):
+            pytest.skip("Merging test with LoKr fails without GPU")
+
+        # Instantiate model & adapters
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        model = self.instantiate_sd_peft(model_id, config_cls, config_kwargs)
+
+        # Generate output for peft modified StableDiffusion
+        dummy_input = self.prepare_inputs_for_testing()
+        with temp_seed(seed=42):
+            peft_output = np.array(model(**dummy_input).images[0]).astype(np.float32)
+
+        # Merge adapter and model
+        if config_cls not in [LoHaConfig, OFTConfig, HRAConfig]:
+            # TODO: Merging the text_encoder is leading to issues on CPU with PyTorch 2.1
+            model.text_encoder = model.text_encoder.merge_and_unload()
+        model.unet = model.unet.merge_and_unload()
+
+        # Generate output for peft merged StableDiffusion
+        with temp_seed(seed=42):
+            merged_output = np.array(model(**dummy_input).images[0]).astype(np.float32)
+
+        # Images are in uint8 drange, so use large atol
+        assert np.allclose(peft_output, merged_output, atol=1.0)
+
+    @pytest.mark.parametrize("model_id", PEFT_DIFFUSERS_SD_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", DIFFUSERS_CONFIGS)
+    def test_merge_layers_safe_merge(self, model_id, config_cls, config_kwargs):
+        if (config_cls == LoKrConfig) and (self.torch_device not in ["cuda", "xpu"]):
+            pytest.skip("Merging test with LoKr fails without GPU")
+
+        # Instantiate model & adapters
+        model = self.instantiate_sd_peft(model_id, config_cls, config_kwargs)
+
+        # Generate output for peft modified StableDiffusion
+        dummy_input = self.prepare_inputs_for_testing()
+        with temp_seed(seed=42):
+            peft_output = np.array(model(**dummy_input).images[0]).astype(np.float32)
+
+        # Merge adapter and model
+        if config_cls not in [LoHaConfig, OFTConfig, HRAConfig]:
+            # TODO: Merging the text_encoder is leading to issues on CPU with PyTorch 2.1
+            model.text_encoder = model.text_encoder.merge_and_unload(safe_merge=True)
+        model.unet = model.unet.merge_and_unload(safe_merge=True)
+
+        # Generate output for peft merged StableDiffusion
+        with temp_seed(seed=42):
+            merged_output = np.array(model(**dummy_input).images[0]).astype(np.float32)
+
+        # Images are in uint8 drange, so use large atol
+        assert np.allclose(peft_output, merged_output, atol=1.0)
+
+    @pytest.mark.parametrize("model_id", PEFT_DIFFUSERS_SD_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", DIFFUSERS_CONFIGS)
+    def test_add_weighted_adapter_base_unchanged(self, model_id, config_cls, config_kwargs):
+        skip_if_not_lora(config_cls)
+        # Instantiate model & adapters
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        model = self.instantiate_sd_peft(model_id, config_cls, config_kwargs)
+
+        # Get current available adapter config
+        text_encoder_adapter_name = next(iter(model.text_encoder.peft_config.keys()))
+        unet_adapter_name = next(iter(model.unet.peft_config.keys()))
+        text_encoder_adapter_config = replace(model.text_encoder.peft_config[text_encoder_adapter_name])
+        unet_adapter_config = replace(model.unet.peft_config[unet_adapter_name])
+
+        # Create weighted adapters
+        model.text_encoder.add_weighted_adapter([unet_adapter_name], [0.5], "weighted_adapter_test")
+        model.unet.add_weighted_adapter([unet_adapter_name], [0.5], "weighted_adapter_test")
+
+        # Assert that base adapters config did not change
+        assert asdict(text_encoder_adapter_config) == asdict(model.text_encoder.peft_config[text_encoder_adapter_name])
+        assert asdict(unet_adapter_config) == asdict(model.unet.peft_config[unet_adapter_name])
+
+    @pytest.mark.parametrize("model_id", PEFT_DIFFUSERS_SD_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", DIFFUSERS_CONFIGS)
+    def test_disable_adapter(self, model_id, config_cls, config_kwargs):
+        # TODO: remove once Diffusers 0.40 is released
+        if not is_diffusers_ge_v040:
+            pytest.skip("This test fails with Diffusers < 0.40 due to a change in huggingface_hub")
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_disable_adapter(model_id, config_cls, config_kwargs)
+
+    @pytest.mark.parametrize("model_id", PEFT_DIFFUSERS_SD_MODELS_TO_TEST)
+    @pytest.mark.parametrize("config_cls,config_kwargs", DIFFUSERS_CONFIGS)
+    def test_load_model_low_cpu_mem_usage(self, model_id, config_cls, config_kwargs):
+        # Instantiate model & adapters
+        pipe = self.instantiate_sd_peft(model_id, config_cls, config_kwargs)
+
+        te_state_dict = get_peft_model_state_dict(pipe.text_encoder)
+        unet_state_dict = get_peft_model_state_dict(pipe.unet)
+
+        del pipe
+        pipe = self.instantiate_sd_peft(model_id, config_cls, config_kwargs)
+
+        config_kwargs = config_kwargs.copy()
+        text_encoder_kwargs = config_kwargs.pop("text_encoder")
+        unet_kwargs = config_kwargs.pop("unet")
+        # the remaining config kwargs should be applied to both configs
+        for key, val in config_kwargs.items():
+            text_encoder_kwargs[key] = val
+            unet_kwargs[key] = val
+
+        config_text_encoder = config_cls(**text_encoder_kwargs)
+        config_unet = config_cls(**unet_kwargs)
+
+        # check text encoder
+        inject_adapter_in_model(config_text_encoder, pipe.text_encoder, low_cpu_mem_usage=True)
+        # sanity check that the adapter was applied:
+        assert any(isinstance(module, BaseTunerLayer) for module in pipe.text_encoder.modules())
+
+        assert "meta" in {p.device.type for p in pipe.text_encoder.parameters()}
+        set_peft_model_state_dict(pipe.text_encoder, te_state_dict, low_cpu_mem_usage=True)
+        assert "meta" not in {p.device.type for p in pipe.text_encoder.parameters()}
+
+        # check unet
+        inject_adapter_in_model(config_unet, pipe.unet, low_cpu_mem_usage=True)
+        # sanity check that the adapter was applied:
+        assert any(isinstance(module, BaseTunerLayer) for module in pipe.unet.modules())
+
+        assert "meta" in {p.device.type for p in pipe.unet.parameters()}
+        set_peft_model_state_dict(pipe.unet, unet_state_dict, low_cpu_mem_usage=True)
+        assert "meta" not in {p.device.type for p in pipe.unet.parameters()}
+
+    def test_lora_conversion(self):
+        # For now, testing a model with only linear layers, as other types are not supported yet
+        torch.manual_seed(0)
+        model_id = "hf-internal-testing/tiny-flux2"
+
+        # from Flux2TransformerTests in Diffusers
+        height = 4
+        width = 4
+        batch_size = 1
+        num_latent_channels = 4
+        sequence_length = 48
+        embedding_dim = 16
+
+        hidden_states = torch.randn((batch_size, height * width, num_latent_channels))
+        encoder_hidden_states = torch.randn((batch_size, sequence_length, embedding_dim))
+
+        t_coords = torch.arange(1)
+        h_coords = torch.arange(height)
+        w_coords = torch.arange(width)
+        l_coords = torch.arange(1)
+        image_ids = torch.cartesian_prod(t_coords, h_coords, w_coords, l_coords)  # [height * width, 4]
+        image_ids = image_ids.unsqueeze(0).expand(batch_size, -1, -1)
+
+        text_t_coords = torch.arange(1)
+        text_h_coords = torch.arange(1)
+        text_w_coords = torch.arange(1)
+        text_l_coords = torch.arange(sequence_length)
+        text_ids = torch.cartesian_prod(text_t_coords, text_h_coords, text_w_coords, text_l_coords)
+        text_ids = text_ids.unsqueeze(0).expand(batch_size, -1, -1)
+
+        timestep = torch.tensor([1.0]).expand(batch_size)
+        guidance = torch.tensor([1.0]).expand(batch_size)
+
+        inputs = {
+            "hidden_states": hidden_states,
+            "encoder_hidden_states": encoder_hidden_states,
+            "timestep": timestep,
+            "img_ids": image_ids,
+            "txt_ids": text_ids,
+            "guidance": guidance,
+        }
+
+        with hub_online_once(model_id):
+            model = AutoModel.from_pretrained(model_id, subfolder="transformer")
+            with torch.inference_mode():
+                output_base = model(**inputs)
+
+            loha_config = LoHaConfig(target_modules=["to_q", "to_v"], init_weights=False, alpha=100)
+            model_loha = get_peft_model(copy.deepcopy(model), loha_config)
+            with torch.inference_mode():
+                output_loha = model_loha(**inputs)
+
+            # sanity check: loha changes outputs
+            atol, rtol = 1e-4, 1e-4
+            assert not torch.allclose(output_base.sample, output_loha.sample, atol=atol, rtol=rtol)
+
+            lora_config, state_dict = convert_to_lora(model_loha, rank=4)
+            model_lora = get_peft_model(model, lora_config).eval()
+            with torch.inference_mode():
+                output_lora = model_lora(**inputs)
+            load_result = set_peft_model_state_dict(model_lora, state_dict)
+            assert not load_result.unexpected_keys
+
+            with torch.inference_mode():
+                output_converted = model_lora(**inputs)
+
+            # calculate MSE
+            mse_lora = torch.nn.functional.mse_loss(output_loha.sample, output_lora.sample)
+            mse_converted = torch.nn.functional.mse_loss(output_loha.sample, output_converted.sample)
+
+            # converted model should be significantly closer to the LoHa model than the base model
+            assert mse_lora / mse_converted > 2
diff --git a/tests/test_target_parameters.py b/tests/test_target_parameters.py
new file mode 100644
index 0000000..70ea448
--- /dev/null
+++ b/tests/test_target_parameters.py
@@ -0,0 +1,685 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+import re
+
+import pytest
+import torch
+from torch import nn
+from transformers import AutoModelForCausalLM
+
+import peft
+from peft import LoraConfig, PeftModel, TaskType, get_peft_model
+from peft.tuners.lora.layer import ParamWrapper
+
+from .testing_common import PeftCommonTester
+from .testing_utils import hub_online_once, set_init_weights_false
+
+
+ALL_CONFIGS = [
+    ##########
+    # Llama4 #
+    ##########
+    # target down_proj
+    (
+        "trl-internal-testing/tiny-Llama4ForCausalLM",
+        LoraConfig,
+        {
+            "task_type": TaskType.CAUSAL_LM,
+            "target_modules": [],
+            "lora_dropout": 0.0,
+            "target_parameters": [
+                "feed_forward.experts.down_proj",
+            ],
+        },
+    ),
+    # target gate_up_proj and down_proj, but not on the same module
+    (
+        "trl-internal-testing/tiny-Llama4ForCausalLM",
+        LoraConfig,
+        {
+            "task_type": TaskType.CAUSAL_LM,
+            "target_modules": [],
+            "lora_dropout": 0.0,
+            "target_parameters": [
+                "0.feed_forward.experts.gate_up_proj",
+                "1.feed_forward.experts.down_proj",
+            ],
+        },
+    ),
+    # target down_proj and gate_up_proj on the same module
+    (
+        "trl-internal-testing/tiny-Llama4ForCausalLM",
+        LoraConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "r": 8,
+            "lora_alpha": 32,
+            "target_modules": None,
+            "lora_dropout": 0.0,
+            "bias": "none",
+            "target_parameters": [
+                "feed_forward.experts.down_proj",
+                "feed_forward.experts.gate_up_proj",
+            ],
+        },
+    ),
+    # target q_proj, v_proj as modules, and down_proj as parameter
+    (
+        "trl-internal-testing/tiny-Llama4ForCausalLM",
+        LoraConfig,
+        {
+            "task_type": TaskType.CAUSAL_LM,
+            "target_modules": ["q_proj", "v_proj"],
+            "lora_dropout": 0.0,
+            "target_parameters": [
+                "feed_forward.experts.down_proj",
+            ],
+        },
+    ),
+    ###########
+    # gpt-oss #
+    ###########
+    # target down_proj
+    (
+        "trl-internal-testing/tiny-GptOssForCausalLM",
+        LoraConfig,
+        {
+            "task_type": TaskType.CAUSAL_LM,
+            "target_modules": [],
+            "lora_dropout": 0.0,
+            "target_parameters": [
+                "mlp.experts.down_proj",
+            ],
+        },
+    ),
+    # target gate_up_proj and down_proj, but not on the same module
+    (
+        "trl-internal-testing/tiny-GptOssForCausalLM",
+        LoraConfig,
+        {
+            "task_type": TaskType.CAUSAL_LM,
+            "target_modules": [],
+            "lora_dropout": 0.0,
+            "target_parameters": [
+                "0.mlp.experts.gate_up_proj",
+                "1.mlp.experts.down_proj",
+            ],
+        },
+    ),
+    # target down_proj and gate_up_proj on the same module
+    (
+        "trl-internal-testing/tiny-GptOssForCausalLM",
+        LoraConfig,
+        {
+            "task_type": "CAUSAL_LM",
+            "r": 8,
+            "lora_alpha": 32,
+            "target_modules": None,
+            "lora_dropout": 0.0,
+            "bias": "none",
+            "target_parameters": [
+                "mlp.experts.down_proj",
+                "mlp.experts.gate_up_proj",
+            ],
+        },
+    ),
+    # target q_proj, v_proj as modules, and down_proj as parameter
+    (
+        "trl-internal-testing/tiny-GptOssForCausalLM",
+        LoraConfig,
+        {
+            "task_type": TaskType.CAUSAL_LM,
+            "target_modules": ["q_proj", "v_proj"],
+            "lora_dropout": 0.0,
+            "target_parameters": [
+                "mlp.experts.down_proj",
+            ],
+        },
+    ),
+]
+
+
+class MyAutoModelForCausalLM(AutoModelForCausalLM):
+    @classmethod
+    def from_pretrained(cls, *args, **kwargs):
+        torch.manual_seed(0)
+        model = AutoModelForCausalLM.from_pretrained(*args, **kwargs)
+
+        # check that we load the original model, not, say, a trained checkpoint
+        if args[0] == "trl-internal-testing/tiny-Llama4ForCausalLM":
+            # model contains weights with values ~1e36 or nan, so we need to reinitialize with sane values
+            with torch.no_grad():
+                for param in model.parameters():
+                    param.data = torch.randn(param.shape)
+        elif args[0] == "trl-internal-testing/tiny-GptOssForCausalLM":
+            # model is bf16, which trips up some tests that require tight tolerances
+            with torch.no_grad():
+                model.float()
+        return model
+
+
+def test_rank_pattern_for_moe_target_parameters(tmp_path):
+    model_id = "trl-internal-testing/tiny-Llama4ForCausalLM"
+    with hub_online_once(model_id):
+        model = MyAutoModelForCausalLM.from_pretrained(model_id)
+        num_experts = getattr(model.config, "num_local_experts", None) or getattr(model.config, "num_experts", None)
+        assert num_experts is not None
+        r = 8
+        effective_r = max(1, r // num_experts)
+        config = LoraConfig(
+            r=r,
+            lora_alpha=32,
+            target_modules=["q_proj", "v_proj"],
+            target_parameters=["feed_forward.experts.gate_up_proj"],
+            rank_pattern={
+                "experts.gate_up_proj": effective_r,
+            },
+            init_lora_weights=False,
+        )
+        model = get_peft_model(model, config)
+
+        wrappers = [
+            module
+            for module in model.modules()
+            if isinstance(module, ParamWrapper) and module.parameter_name == "gate_up_proj"
+        ]
+        assert wrappers, "Expected to find ParamWrapper for gate_up_proj."
+        lora_module = wrappers[0]
+        assert lora_module.r["default"] == effective_r
+        assert lora_module.lora_A["default"].weight.shape[0] == effective_r * num_experts
+        assert lora_module.scaling["default"] == config.lora_alpha / effective_r
+        assert config.r == r
+
+
+class TestDecoderModelsTargetParameters(PeftCommonTester):
+    # This is more or less a copy of TestDecoderModels at the time of the PR being added. Unnecessary code is removed,
+    # like code required for testing non-LoRA methods. The tests being included are not selected to test specific
+    # functionality of targeting nn.Parameters, they (together with the tests in test_custom_models.py) just ensure that
+    # generally, nothing is broken.
+    transformers_class = MyAutoModelForCausalLM
+
+    def prepare_inputs_for_testing(self):
+        input_ids = torch.tensor([[1, 1, 1], [1, 2, 1]]).to(self.torch_device)
+        attention_mask = torch.tensor([[1, 1, 1], [1, 0, 1]]).to(self.torch_device)
+        return {"input_ids": input_ids, "attention_mask": attention_mask}
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_attributes_parametrized(self, model_id, config_cls, config_kwargs):
+        self._test_model_attr(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_adapter_name(self, model_id, config_cls, config_kwargs):
+        self._test_adapter_name(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_prepare_for_training_parametrized(self, model_id, config_cls, config_kwargs):
+        self._test_prepare_for_training(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_save_pretrained(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_save_pretrained(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_save_pretrained_pickle(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_save_pretrained(model_id, config_cls, config_kwargs.copy(), safe_serialization=False)
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_save_pretrained_selected_adapters(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_save_pretrained_selected_adapters(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_save_pretrained_selected_adapters_pickle(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_save_pretrained_selected_adapters(
+            model_id, config_cls, config_kwargs.copy(), safe_serialization=False
+        )
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_from_pretrained_config_construction(self, model_id, config_cls, config_kwargs):
+        self._test_from_pretrained_config_construction(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_merge_layers(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_merge_layers(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_merge_layers_multi(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_merge_layers_multi(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_merge_layers_nan(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_merge_layers_nan(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_mixed_adapter_batches(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        msg = "lora.ParamWrapper does not support mixed adapter batches yet."
+        with pytest.raises(ValueError, match=msg):
+            self._test_mixed_adapter_batches(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_generate_with_mixed_adapter_batches(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        msg = "lora.ParamWrapper does not support mixed adapter batches yet."
+        with pytest.raises(ValueError, match=msg):
+            self._test_generate_with_mixed_adapter_batches_and_beam_search(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_generate(self, model_id, config_cls, config_kwargs):
+        self._test_generate(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_generate_pos_args(self, model_id, config_cls, config_kwargs):
+        self._test_generate_pos_args(model_id, config_cls, config_kwargs.copy(), raises_err=False)
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_merge_layers_fp16(self, model_id, config_cls, config_kwargs):
+        self._test_merge_layers_fp16(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_generate_half_prec(self, model_id, config_cls, config_kwargs):
+        self._test_generate_half_prec(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_training_decoders(self, model_id, config_cls, config_kwargs):
+        self._test_training(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_training_decoders_gradient_checkpointing(self, model_id, config_cls, config_kwargs):
+        self._test_training_gradient_checkpointing(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_inference_safetensors(self, model_id, config_cls, config_kwargs):
+        self._test_inference_safetensors(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_peft_model_device_map(self, model_id, config_cls, config_kwargs):
+        self._test_peft_model_device_map(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_delete_adapter(self, model_id, config_cls, config_kwargs):
+        self._test_delete_adapter(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_delete_inactive_adapter(self, model_id, config_cls, config_kwargs):
+        self._test_delete_inactive_adapter(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_adding_multiple_adapters_with_bias_raises(self, model_id, config_cls, config_kwargs):
+        self._test_adding_multiple_adapters_with_bias_raises(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_unload_adapter(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_unload_adapter(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_weighted_combination_of_adapters(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        msg = "add_weighted_adapter does not support targeting nn.Parameter"
+        with pytest.raises(ValueError, match=msg):
+            self._test_weighted_combination_of_adapters(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_training_prompt_learning_tasks(self, model_id, config_cls, config_kwargs):
+        self._test_training_prompt_learning_tasks(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_disable_adapter(self, model_id, config_cls, config_kwargs):
+        config_kwargs = set_init_weights_false(config_cls, config_kwargs)
+        self._test_disable_adapter(model_id, config_cls, config_kwargs.copy())
+
+    @pytest.mark.parametrize("model_id,config_cls,config_kwargs", ALL_CONFIGS)
+    def test_passing_input_embeds_works(self, model_id, config_cls, config_kwargs):
+        self._test_passing_input_embeds_works("", model_id, config_cls, config_kwargs.copy())
+
+
+class TestTargetParameters:
+    # Tests specifically designed for target_parameters
+    def test_targeting_module_and_targeting_param_equivalent(self):
+        # Test that using LoRA with target_modules vs target_parameters yields identical results.
+        # note: we purposely target the gate_proj because its weight is not square (unlike q_proj, ...), this makes it
+        # easier to catch shape errors
+        torch.manual_seed(0)
+        model_id = "hf-internal-testing/tiny-random-LlamaForCausalLM"
+        with hub_online_once(model_id):
+            model0 = AutoModelForCausalLM.from_pretrained(model_id)
+            x = torch.arange(10).view(2, 5)
+            with torch.inference_mode():
+                out_base = model0(x, output_hidden_states=True).hidden_states[-1]
+
+            # targeting the module
+            config0 = LoraConfig(target_modules=["gate_proj"], init_lora_weights=False)
+            model0 = get_peft_model(model0, config0)
+
+            # targeting the parameter
+            model1 = AutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-LlamaForCausalLM")
+            config1 = LoraConfig(target_modules=[], target_parameters=["gate_proj.weight"], init_lora_weights=False)
+            model1 = get_peft_model(model1, config1)
+
+            gate_proj_0_0 = model0.base_model.model.model.layers[0].mlp.gate_proj
+            gate_proj_0_1 = model0.base_model.model.model.layers[1].mlp.gate_proj
+            gate_proj_1_0 = model1.base_model.model.model.layers[0].mlp.gate_proj
+            gate_proj_1_1 = model1.base_model.model.model.layers[1].mlp.gate_proj
+
+            # ensure that the randomly initialized LoRA weights are identical
+            gate_proj_1_0.lora_A.default.weight.data.copy_(gate_proj_0_0.lora_A.default.weight.data)
+            gate_proj_1_1.lora_A.default.weight.data.copy_(gate_proj_0_1.lora_A.default.weight.data)
+            gate_proj_1_0.lora_B.default.weight.data.copy_(gate_proj_0_0.lora_B.default.weight.data)
+            gate_proj_1_1.lora_B.default.weight.data.copy_(gate_proj_0_1.lora_B.default.weight.data)
+
+            with torch.inference_mode():
+                out_lora_0 = model0(x, output_hidden_states=True).hidden_states[-1]
+                out_lora_1 = model1(x, output_hidden_states=True).hidden_states[-1]
+
+            # sanity check: basemodel outputs should be different
+            atol, rtol = 1e-6, 1e-6
+            assert not torch.allclose(out_base, out_lora_0, atol=atol, rtol=rtol)
+
+            # LoRA outputs should be the same
+            assert torch.allclose(out_lora_0, out_lora_1, atol=atol, rtol=rtol)
+
+    def test_target_multiple_parameters_on_same_module(self, monkeypatch):
+        # test that if we target multiple nn.Parameters on the same module, all of them are being used during the
+        # forward pass
+        torch.manual_seed(0)
+        model_id = "trl-internal-testing/tiny-Llama4ForCausalLM"
+        with hub_online_once(model_id):
+            x = torch.arange(10).view(2, 5)
+            model = MyAutoModelForCausalLM.from_pretrained(model_id)
+            shape_gate_up_proj = model.model.layers[0].feed_forward.experts.gate_up_proj.shape
+            shape_down_proj = model.model.layers[0].feed_forward.experts.down_proj.shape
+            num_layers = len(model.model.layers)
+
+            target_parameters = ["feed_forward.experts.gate_up_proj", "feed_forward.experts.down_proj"]
+            num_params = len(target_parameters)
+            config = LoraConfig(target_parameters=target_parameters, init_lora_weights=False)
+            model = get_peft_model(model, config)
+
+            # CHECK FORWARD CALLS
+
+            # log the weights seen during the forward call
+            weights = []
+
+            def mock_forward(self, W):
+                weights.append(W)
+                return orig_forward(self, W)
+
+            from peft.tuners.lora.layer import _LoraParameterProxy
+
+            orig_forward = _LoraParameterProxy.forward
+            monkeypatch.setattr(_LoraParameterProxy, "forward", mock_forward)
+
+            num_steps = 3
+            with torch.inference_mode():
+                for _ in range(num_steps):
+                    out_base = model(x, output_hidden_states=True).hidden_states[-1]
+
+            actual_call_count = len(weights)
+            # Note: We call forward twice per step, once to create the parametrization and once for the actual forward
+            # step. This may be a bit wasteful but it's not clear how to prevent this and overall is probably negligible
+            num_forward_per_step = 2
+            # Since https://github.com/huggingface/transformers/pull/39501, one of the parameters is accessed twice per
+            # forward call, but we cache all calls after the first.
+            expected_call_count = num_steps * num_layers * num_params * num_forward_per_step
+            assert actual_call_count == expected_call_count
+
+            actual_shapes = {W.shape for W in weights}
+            expected_shapes = {shape_gate_up_proj, shape_down_proj}
+            assert actual_shapes == expected_shapes
+
+            # CHECK WEIGHT UPDATES
+
+            lora_weights_before = {
+                k: v.clone() for k, v in model.named_parameters() if "lora_A.default" in k or "lora_B.default" in k
+            }
+            # sanity check:
+            assert len(lora_weights_before) == 2 * num_layers * num_params
+            # train
+            optim = torch.optim.SGD(model.parameters(), lr=0.01)
+            for _ in range(10):
+                optim.zero_grad()
+                out = model(x)
+                loss = out.logits.sum()
+                loss.backward()
+                optim.step()
+
+            lora_weights_after = {
+                k: v for k, v in model.named_parameters() if "lora_A.default" in k or "lora_B.default" in k
+            }
+            assert lora_weights_before.keys() == lora_weights_after.keys()
+            atol, rtol = 0.1, 0.1
+            for key in lora_weights_before.keys():
+                assert not torch.allclose(lora_weights_before[key], lora_weights_after[key], atol=atol, rtol=rtol)
+
+    def test_target_parameters_works_with_existing_parametrization(self):
+        # When a parameter is already parametrized, we want the LoRA parametrization to work with it correctly.
+        class MyLinear(nn.Linear):
+            # For testing purposes, define a linear layer with 2 parameters: weight and other_weight.
+            def __init__(self, *args, **kwargs):
+                super().__init__(*args, **kwargs)
+                nn.init.ones_(self.weight)
+                self.other_weight = nn.Parameter(torch.ones(self.weight.shape))
+
+        class MyModule(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.lin = MyLinear(2, 2, bias=False)
+
+            def forward(self, x):
+                return self.lin(x)
+
+        class MyParametrization(nn.Module):
+            def __init__(self):
+                super().__init__()
+
+            def forward(self, x):
+                return x + 1
+
+        # base model
+        model = MyModule()
+        x = torch.ones((2, 2))
+
+        # sanity check: result should be 1*1 + 1*1 == 2
+        output_base = model(x)
+        assert torch.all(output_base == 2)
+
+        # add parametrization to the weight
+        nn.utils.parametrize.register_parametrization(model.lin, "weight", MyParametrization())
+
+        # result should be (1+1)*1 + (1+1)*1 == 4
+        output_parametrized = model(x)
+        assert torch.all(output_parametrized == 4)
+
+        # add LoRA parametrization to the weight
+        config = LoraConfig(r=2, lora_alpha=6, target_parameters=["lin.weight"], init_lora_weights=False)
+        model = get_peft_model(model, config)
+        # manually set LoRA weights to ones
+        nn.init.ones_(model.base_model.model.lin.lora_A["default"].weight)
+        nn.init.ones_(model.base_model.model.lin.lora_B["default"].weight)
+
+        output_lora = model(x)
+        # delta_weight should be: (1+1) * lora_scale = (1+1) * (alpha / rank) = 2 * (6 / 2) = 6
+        # result should be: (1+1+6)*1 + (1+1+6)*1 == 8 + 8 == 16
+        assert torch.all(output_lora == 16)
+
+        # calling twice should yield the same result
+        output_lora2 = model(x)
+        assert torch.allclose(output_lora, output_lora2)
+
+        # Adding another adapter that targets a *different* parameter is not allowed: all adapters that use
+        # target_parameters must target the same set of parameters.
+        config = LoraConfig(r=2, lora_alpha=6, target_parameters=["lin.other_weight"], init_lora_weights=False)
+        msg = "all adapters must target the same set of parameters"
+        with pytest.raises(ValueError, match=msg):
+            model.add_adapter("other", config)
+        # the rejected adapter was not added
+        assert "other" not in model.peft_config
+
+        # after unloading, the output should be the same as before LoRA was applied
+        unloaded = model.unload()
+        output_unloaded = unloaded(x)
+        assert torch.all(output_unloaded == output_parametrized)
+
+    def test_target_parameter_result_caching_works(self, monkeypatch):
+        # See 2912
+        # There was an issue with the caching of _LoraParameterProxy not working correctly. This test checks that the
+        # results returned from the forward call are all identical to ensure they're not recomputed each time.
+        torch.manual_seed(0)
+        model_id = "trl-internal-testing/tiny-GptOssForCausalLM"
+
+        tensor_storage = []
+
+        def store_tensors_deco(fn):
+            def wrapper(*args, **kwargs):
+                result = fn(*args, **kwargs)
+                tensor_storage.append(result)
+                return result
+
+            return wrapper
+
+        monkeypatch.setattr(
+            peft.tuners.lora.layer._LoraParameterProxy,
+            "forward",
+            store_tensors_deco(peft.tuners.lora.layer._LoraParameterProxy.forward),
+        )
+
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            config = LoraConfig(
+                target_modules=[],
+                # for simplicity, only target a single layer
+                target_parameters=["0.mlp.experts.gate_up_proj"],
+            )
+            model = get_peft_model(model, config)
+            x = torch.arange(100).view(2, 50)  # larger input to hit many experts
+
+            # forward is called twice, once at initialization of the parametrization and once during the forward pass,
+            # after which it is cached; without caching, it would be called 25 times.
+            output = model(x, output_hidden_states=True)
+            assert len(set(map(id, tensor_storage))) == 2
+
+            # sanity check: a second forward call _does_ trigger a new forward
+            output = model(x, output_hidden_states=True)
+            assert len(set(map(id, tensor_storage))) == 4
+
+    def test_target_parameter_init_does_not_warn_about_unknown_layer_type(self, recwarn):
+        # For target parameters, the layer type is not known. This is fine, as the in_features and out_features are
+        # derived from the targeted parameter shape. But we need to ensure that there is no warning about the unknown
+        # layer type.
+        model_id = "trl-internal-testing/tiny-GptOssForCausalLM"
+        with hub_online_once(model_id):
+            model0 = AutoModelForCausalLM.from_pretrained(model_id)
+            config = LoraConfig(
+                target_modules=[],
+                target_parameters=["0.mlp.experts.gate_up_proj"],
+            )
+            model = get_peft_model(model0, config)
+            warn_messages = (w.message.args[0] for w in recwarn.list)
+            msg_start = "Unsupported layer type"
+            assert not any(msg.startswith(msg_start) for msg in warn_messages)
+
+    def test_adding_second_adapter_reuses_param_wrapper(self):
+        # Adding a second adapter that targets the same parameters must reuse the existing (possibly nested)
+        # ParamWrapper(s) instead of nesting new ones. As a result, the number of ParamWrappers stays constant and each
+        # of them holds both adapters.
+        torch.manual_seed(0)
+        model_id = "trl-internal-testing/tiny-Llama4ForCausalLM"
+        target_parameters = ["feed_forward.experts.gate_up_proj", "feed_forward.experts.down_proj"]
+        with hub_online_once(model_id):
+            model = MyAutoModelForCausalLM.from_pretrained(model_id)
+            config = LoraConfig(target_modules=[], target_parameters=target_parameters, init_lora_weights=False)
+            model = get_peft_model(model, config)
+            num_wrappers_single = sum(isinstance(m, ParamWrapper) for m in model.modules())
+
+            config_other = LoraConfig(target_modules=[], target_parameters=target_parameters, init_lora_weights=False)
+            model.add_adapter("other", config_other)
+            num_wrappers_multi = sum(isinstance(m, ParamWrapper) for m in model.modules())
+
+            # the number of ParamWrappers does not change when adding a second adapter
+            assert num_wrappers_single > 0
+            assert num_wrappers_multi == num_wrappers_single
+
+            # every ParamWrapper holds both adapters
+            for module in model.modules():
+                if isinstance(module, ParamWrapper):
+                    assert set(module.lora_A.keys()) == {"default", "other"}
+                    assert set(module.lora_B.keys()) == {"default", "other"}
+
+    def test_multiple_adapters_load_order_independent(self, tmp_path):
+        # Regression test: when multiple adapters target parameters, the saved checkpoint must load correctly regardless
+        # of the order in which the adapters are loaded. This is important to test because a previous attempt at
+        # implementing multiple target_parameters adapters made use of nesting, so had something like:
+        #   wrapper-default (wrapper-other (base-layer))
+        # which meant that the state dict for 'other' would contain an extra base layer, which meant it could not be
+        # loaded unless the default adapter was loaded first.
+        torch.manual_seed(0)
+        model_id = "trl-internal-testing/tiny-Llama4ForCausalLM"
+        target_parameters = ["feed_forward.experts.gate_up_proj", "feed_forward.experts.down_proj"]
+        x = torch.arange(10).view(2, 5)
+        with hub_online_once(model_id):
+            model = MyAutoModelForCausalLM.from_pretrained(model_id)
+            config = LoraConfig(target_modules=[], target_parameters=target_parameters, init_lora_weights=False)
+            model = get_peft_model(model, config)
+            config_other = LoraConfig(target_modules=[], target_parameters=target_parameters, init_lora_weights=False)
+            model.add_adapter("other", config_other)
+
+            # collect the reference outputs of both adapters
+            outputs = {}
+            for adapter in ["default", "other"]:
+                model.set_adapter(adapter)
+                with torch.inference_mode():
+                    outputs[adapter] = model(x).logits.clone()
+
+            # 'default' is saved to the root, 'other' to a subfolder
+            model.save_pretrained(tmp_path)
+            del model
+
+            # load in *reverse* order: load 'other' first, then 'default'
+            model = MyAutoModelForCausalLM.from_pretrained(model_id)
+            model = PeftModel.from_pretrained(model, str(tmp_path / "other"), adapter_name="other")
+            load_result = model.load_adapter(str(tmp_path), adapter_name="default")
+
+            assert not load_result.missing_keys
+            assert not load_result.unexpected_keys
+
+            for adapter in ["default", "other"]:
+                model.set_adapter(adapter)
+                with torch.inference_mode():
+                    out = model(x).logits
+                assert torch.allclose(out, outputs[adapter], atol=1e-5, rtol=1e-5)
+
+    def test_target_parameter_on_top_level_module_raises(self):
+        # nn.Parameters that are registered directly on the top-level module (i.e. the module passed to get_peft_model)
+        # cannot be targeted. Wrapping the parameter would require replacing the module that holds it with
+        # lora.ParamWrapper, but that module is its own parent, so the wrapper ends up registered as a submodule of the
+        # very module it wraps. This creates a cyclic module graph, resulting in an error.
+
+        class MyModule(nn.Module):
+            # module with a 2d and a 3d nn.Parameter registered directly on the top-level module
+            def __init__(self):
+                super().__init__()
+                self.param = nn.Parameter(torch.zeros(10, 10))
+
+        config = LoraConfig(target_parameters=["param"])
+        msg = re.escape("Targeting an nn.Parameter on the top-level module is not supported (parameter 'param')")
+        with pytest.raises(ValueError, match=msg):
+            get_peft_model(MyModule(), config)
diff --git a/tests/test_torch_compile.py b/tests/test_torch_compile.py
new file mode 100644
index 0000000..750be18
--- /dev/null
+++ b/tests/test_torch_compile.py
@@ -0,0 +1,593 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+# The intent of the tests contained in this file is to check as many PEFT features as possible with torch.compile. This
+# is thus a document on how well torch.compile is supported by PEFT. Currently, we know that certain features do not
+# work with torch.compile. The corresponding tests should be marked with `@pytest.mark.xfail(strict=True)`.
+#
+# When adding a new test that fails with torch.compile, please make sure first that it does NOT fail without
+# torch.compile.
+
+import gc
+import os
+
+import pytest
+import torch
+from accelerate.utils.memory import clear_device_cache
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    BitsAndBytesConfig,
+    DataCollatorForLanguageModeling,
+    Trainer,
+    TrainerCallback,
+    TrainingArguments,
+)
+
+from peft import (
+    AdaLoraConfig,
+    BOFTConfig,
+    HRAConfig,
+    IA3Config,
+    LNTuningConfig,
+    LoHaConfig,
+    LoKrConfig,
+    LoraConfig,
+    MissConfig,
+    OFTConfig,
+    PeftModel,
+    TaskType,
+    VBLoRAConfig,
+    VeraConfig,
+    get_peft_model,
+)
+
+from .testing_utils import load_dataset_english_quotes, require_bitsandbytes
+
+
+# only run (very slow) torch.compile tests when explicitly asked to
+if os.environ.get("PEFT_DEBUG_WITH_TORCH_COMPILE") != "1":
+    pytest.skip(allow_module_level=True)
+
+
+# Mapping: name of the setting -> (Peft config instance, torch.compile kwargs)
+SETTINGS = {
+    "adalora": (AdaLoraConfig(task_type=TaskType.CAUSAL_LM, total_step=5), {}),
+    "boft": (BOFTConfig(task_type=TaskType.CAUSAL_LM), {}),
+    "dora": (LoraConfig(task_type=TaskType.CAUSAL_LM, use_dora=True), {}),
+    "ia3": (IA3Config(task_type=TaskType.CAUSAL_LM), {}),
+    "ln_tuning": (LNTuningConfig(task_type=TaskType.CAUSAL_LM, target_modules=["final_layer_norm"]), {}),
+    "loha": (LoHaConfig(task_type=TaskType.CAUSAL_LM, target_modules=["q_proj", "v_proj"]), {}),
+    "lokr": pytest.param(
+        (LoKrConfig(task_type=TaskType.CAUSAL_LM, target_modules=["q_proj", "v_proj"]), {}),
+    ),
+    "lora": (LoraConfig(task_type=TaskType.CAUSAL_LM), {}),
+    "lora-target-embeddings": pytest.param(
+        (LoraConfig(task_type=TaskType.CAUSAL_LM, target_modules=["embed_tokens"]), {}),
+    ),
+    "lora-with-modules-to-save": (LoraConfig(task_type=TaskType.CAUSAL_LM, modules_to_save=["embed_tokens"]), {}),
+    "oft": (OFTConfig(task_type=TaskType.CAUSAL_LM, target_modules=["q_proj", "v_proj"]), {}),
+    "vblora": (VBLoRAConfig(task_type=TaskType.CAUSAL_LM, target_modules=["q_proj", "v_proj"], vector_length=2), {}),
+    "vera": (VeraConfig(task_type=TaskType.CAUSAL_LM), {}),
+    "hra": (HRAConfig(task_type=TaskType.CAUSAL_LM, target_modules=["q_proj", "v_proj"]), {}),
+    "miss": (MissConfig(task_type=TaskType.CAUSAL_LM, target_modules=["q_proj", "v_proj"], r=2), {}),
+    "miss-bat": (
+        MissConfig(task_type=TaskType.CAUSAL_LM, target_modules=["q_proj", "v_proj"], r=2, init_weights="bat"),
+        {},
+    ),
+    "miss-mini": (
+        MissConfig(task_type=TaskType.CAUSAL_LM, target_modules=["q_proj", "v_proj"], r=2, init_weights="mini"),
+        {},
+    ),
+}
+
+
+@pytest.mark.single_gpu_tests
+class TestTorchCompileCausalLM:
+    """
+    Tests for using torch.compile with causal LM.
+
+    Tip: When adding a new test, set `fake_compile = True` below. With this setting, torch.compile is being skipped.
+    This is useful for two reasons:
+
+    - compile is slow, so to quickly iterate on the test, it's best to disable it and only enable it at the very end
+    - even if you expect the test to fail with compile, as compile does not work with every PEFT feature, it still MUST
+      succeed without compile, otherwise the test is incorrect.
+
+    Before creating the PR, disable `fake_compile`.
+    """
+
+    fake_compile = False
+    model_id = "peft-internal-testing/tiny-random-OPTForCausalLM"
+    max_train_loss = 15.0  # generous threshold for maximum loss after training
+
+    @pytest.fixture(autouse=True)
+    def teardown(self):
+        r"""
+        Efficient mechanism to free GPU memory after each test. Based on
+        https://github.com/huggingface/transformers/issues/21094
+        """
+        clear_device_cache(garbage_collection=True)
+        gc.collect()
+
+    @pytest.fixture(scope="class")
+    def tokenizer(self):
+        return AutoTokenizer.from_pretrained(self.model_id)
+
+    @pytest.fixture(scope="class")
+    def data(self, tokenizer):
+        def tokenize(samples):
+            # For some reason, the max sequence length is not honored by the tokenizer, resulting in IndexErrors. Thus,
+            # manually ensure that sequences are not too long.
+            tokenized = tokenizer(samples["quote"])
+            tokenized["input_ids"] = [input_ids[: tokenizer.model_max_length] for input_ids in tokenized["input_ids"]]
+            tokenized["attention_mask"] = [
+                input_ids[: tokenizer.model_max_length] for input_ids in tokenized["attention_mask"]
+            ]
+            return tokenized
+
+        data = load_dataset_english_quotes()
+        data = data.map(tokenize, batched=True)
+        # We need to manually remove unused columns. This is because we cannot use remove_unused_columns=True in the
+        # Trainer, as this leads to errors with torch.compile. We also cannot just leave them in, as they contain
+        # strings. Therefore, manually remove all unused columns.
+        data = data.remove_columns(["quote", "author", "tags"])
+        return data
+
+    def compile(self, model, compile_kwargs):
+        compile_kwargs = compile_kwargs.copy()
+        # those are only for the Trainer arguments
+        compile_kwargs.pop("torch_compile_backend", None)
+        compile_kwargs.pop("torch_compile_mode", None)
+        if self.fake_compile:
+            return model
+        return torch.compile(model, **compile_kwargs)
+
+    @pytest.mark.parametrize("settings", SETTINGS.values(), ids=SETTINGS.keys())
+    def test_causal_lm_training_trainer_compile(self, settings, tokenizer, data, tmp_path):
+        r"""Train a PEFT model with torch.compile using Trainer"""
+        tmp_dir = tmp_path / "model"
+        config, compile_kwargs = settings
+
+        torch.manual_seed(0)
+        model = AutoModelForCausalLM.from_pretrained(
+            self.model_id,
+            device_map="auto",
+        )
+        model = get_peft_model(model, config)
+
+        # record outputs before training
+        model.eval()
+        sample = torch.tensor(data["train"][:1]["input_ids"]).to(model.device)
+        with torch.inference_mode():
+            output_before = model(sample)
+        model.train()
+
+        train_kwargs = {
+            "per_device_train_batch_size": 4,
+            "max_steps": 5,
+            "learning_rate": 1e-3,
+            "logging_steps": 1,
+            "output_dir": tmp_dir,
+            "seed": 0,
+        }
+
+        if isinstance(config, AdaLoraConfig):
+            train_kwargs["learning_rate"] = 1e-2
+
+        training_args = TrainingArguments(
+            torch_compile=not self.fake_compile,
+            torch_compile_backend=compile_kwargs.get("torch_compile_backend", None),
+            torch_compile_mode=compile_kwargs.get("torch_compile_mode", None),
+            **train_kwargs,
+        )
+        trainer = Trainer(
+            model=model,
+            train_dataset=data["train"],
+            args=training_args,
+            data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+        )
+        model.config.use_cache = False
+
+        if isinstance(config, AdaLoraConfig):
+
+            class OptimizerStepCallback(TrainerCallback):
+                def on_optimizer_step(self, args, state, control, **kwargs):
+                    model.update_and_allocate(state.global_step)
+
+            trainer.add_callback(OptimizerStepCallback())
+
+        trainer.train()
+
+        model.eval()
+        atol, rtol = 1e-4, 1e-4
+        with torch.inference_mode():
+            output_after = model(sample)
+            tokens_after = model.generate(sample)
+        assert torch.isfinite(output_after.logits).all()
+        # sanity check: model was updated
+        assert not torch.allclose(output_before.logits, output_after.logits, atol=atol, rtol=rtol)
+        assert trainer.state.log_history[-1]["train_loss"] < self.max_train_loss
+
+        # check saving the model and loading it without compile
+        model.save_pretrained(tmp_path)
+        del model
+        torch.manual_seed(0)
+        model = AutoModelForCausalLM.from_pretrained(self.model_id, device_map="auto")
+        model = PeftModel.from_pretrained(model, tmp_path)
+        with torch.inference_mode():
+            output_loaded = model(sample)
+            tokens_loaded = model.generate(sample)
+        assert torch.allclose(output_after.logits, output_loaded.logits, atol=atol, rtol=rtol)
+        assert (tokens_after == tokens_loaded).all()
+
+    @pytest.mark.parametrize("settings", SETTINGS.values(), ids=SETTINGS.keys())
+    def test_causal_lm_training_pytorch_compile(self, settings, tokenizer, data, tmp_path):
+        r"""Train a PEFT model with torch.compile using PyTorch training loop"""
+        torch.manual_seed(0)
+        model = AutoModelForCausalLM.from_pretrained(
+            self.model_id,
+            device_map="auto",
+        )
+        config, compile_kwargs = settings
+        model = get_peft_model(model, config)
+        if isinstance(config, AdaLoraConfig):
+            model.base_model.peft_config["default"].total_step = 5
+        model = self.compile(model, compile_kwargs)
+
+        # record outputs before training
+        model.eval()
+        sample = torch.tensor(data["train"][:1]["input_ids"]).to(model.device)
+        with torch.inference_mode():
+            output_before = model(sample)
+        model.train()
+
+        model.config.use_cache = False
+        optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3)
+        batch_size = 4
+        losses = []
+        max_steps = 5 * batch_size
+        for i in range(0, max_steps, batch_size):
+            batch = tokenizer.pad(data["train"][i : i + batch_size], return_tensors="pt").to(model.device)
+            # add targets
+            batch["labels"] = batch["input_ids"].clone()
+            optimizer.zero_grad()
+            outputs = model(**batch)
+            loss = outputs.loss
+            loss.backward()
+            optimizer.step()
+            losses.append(loss.item())
+            if isinstance(config, AdaLoraConfig):
+                model.base_model.update_and_allocate(i)
+
+        model.eval()
+        with torch.inference_mode():
+            output_after = model(sample)
+            tokens_after = model.generate(sample)
+        assert torch.isfinite(output_after.logits).all()
+        atol, rtol = 1e-4, 1e-4
+        # sanity check: model was updated
+        assert not torch.allclose(output_before.logits, output_after.logits, atol=atol, rtol=rtol)
+        assert losses[-1] < self.max_train_loss
+
+        # check saving the model and loading it without compile
+        model.save_pretrained(tmp_path)
+        del model
+        torch.manual_seed(0)
+        model = AutoModelForCausalLM.from_pretrained(self.model_id, device_map="auto")
+        model = PeftModel.from_pretrained(model, tmp_path)
+        with torch.inference_mode():
+            output_loaded = model(sample)
+            tokens_loaded = model.generate(sample)
+        assert torch.allclose(output_after.logits, output_loaded.logits, atol=atol, rtol=rtol)
+        assert (tokens_after == tokens_loaded).all()
+
+    @require_bitsandbytes
+    def test_causal_lm_training_lora_bnb_compile(self, tokenizer, data, tmp_path):
+        r"""Train a bnb quantized LoRA model with torch.compile using PyTorch training loop"""
+        torch.manual_seed(0)
+        model = AutoModelForCausalLM.from_pretrained(
+            self.model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+        )
+        config = LoraConfig(task_type=TaskType.CAUSAL_LM)
+        model = get_peft_model(model, config)
+        model = self.compile(model, {})
+
+        # record outputs before training
+        model.eval()
+        sample = torch.tensor(data["train"][:1]["input_ids"]).to(model.device)
+        with torch.inference_mode():
+            output_before = model(sample)
+        model.train()
+
+        model.config.use_cache = False
+        optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3)
+        batch_size = 4
+        losses = []
+        max_steps = 5 * batch_size
+        for i in range(0, max_steps, batch_size):
+            batch = tokenizer.pad(data["train"][i : i + batch_size], return_tensors="pt").to(model.device)
+            # add targets
+            batch["labels"] = batch["input_ids"].clone()
+            optimizer.zero_grad()
+            outputs = model(**batch)
+            loss = outputs.loss
+            loss.backward()
+            optimizer.step()
+            losses.append(loss.item())
+
+        model.eval()
+        with torch.inference_mode():
+            output_after = model(sample)
+        assert torch.isfinite(output_after.logits).all()
+        atol, rtol = 5e-4, 5e-4
+        # sanity check: model was updated
+        assert not torch.allclose(output_before.logits, output_after.logits, atol=atol, rtol=rtol)
+        assert losses[-1] < self.max_train_loss
+
+        # check saving the model and loading it without compile
+        model.save_pretrained(tmp_path)
+        del model
+        torch.manual_seed(0)
+        model = AutoModelForCausalLM.from_pretrained(
+            self.model_id, device_map="auto", quantization_config=BitsAndBytesConfig(load_in_4bit=True)
+        )
+        model = PeftModel.from_pretrained(model, tmp_path)
+
+        with torch.inference_mode():
+            # after loading, outputs are float32 for some reason
+            output_loaded = model(sample)
+        assert torch.allclose(output_after.logits, output_loaded.logits, atol=atol, rtol=rtol)
+
+    @require_bitsandbytes
+    def test_causal_lm_multiple_lora_adapter_compile(self, tokenizer, data):
+        torch.manual_seed(0)
+        model = AutoModelForCausalLM.from_pretrained(
+            self.model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+        ).eval()
+        sample = torch.tensor(data["train"][:1]["input_ids"]).to(model.device)
+        with torch.inference_mode():
+            output_base = model(sample)
+
+        config = LoraConfig(task_type=TaskType.CAUSAL_LM, init_lora_weights=False)
+        model = get_peft_model(model, config)
+        model.add_adapter("other", config)
+        model = self.compile(model, {})
+        model.eval()
+
+        with torch.inference_mode():
+            output_default_adapter = model(sample)
+        model.set_adapter("other")
+        with torch.inference_mode():
+            output_other_adapter = model(sample)
+
+        atol, rtol = 1e-4, 1e-4
+        # outputs of the base model != output of default adapter != output of other adapter
+        assert not torch.allclose(output_base.logits, output_default_adapter.logits, atol=atol, rtol=rtol)
+        assert not torch.allclose(output_base.logits, output_other_adapter.logits, atol=atol, rtol=rtol)
+        assert not torch.allclose(output_default_adapter.logits, output_other_adapter.logits, atol=atol, rtol=rtol)
+
+        # now delete the other adapter
+        model.delete_adapter("other")
+        model.set_adapter("default")
+        with torch.inference_mode():
+            output_after_delete = model(sample)
+
+        # outputs after delete == output of default adapter
+        assert torch.allclose(output_default_adapter.logits, output_after_delete.logits, atol=atol, rtol=rtol)
+
+    def test_causal_lm_disable_lora_adapter_compile(self, tokenizer, data):
+        torch.manual_seed(0)
+        model = AutoModelForCausalLM.from_pretrained(
+            self.model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+        ).eval()
+        sample = torch.tensor(data["train"][:1]["input_ids"]).to(model.device)
+        with torch.inference_mode():
+            output_base = model(sample)
+
+        config = LoraConfig(task_type=TaskType.CAUSAL_LM, init_lora_weights=False)
+        model = get_peft_model(model, config).eval()
+        model = self.compile(model, {})
+        output_lora = model(sample)
+
+        with model.disable_adapter():
+            with torch.inference_mode():
+                output_disabled = model(sample)
+
+        atol, rtol = 5e-4, 5e-4
+        # outputs of the base model == output disabled adapter != output of lora adapter
+        assert torch.allclose(output_base.logits, output_disabled.logits, atol=atol, rtol=rtol)
+        assert not torch.allclose(output_base.logits, output_lora.logits, atol=atol, rtol=rtol)
+
+    @require_bitsandbytes
+    def test_causal_lm_merging_lora_adapter_compile(self, tokenizer, data):
+        # merge the adapter
+        torch.manual_seed(0)
+        model = AutoModelForCausalLM.from_pretrained(
+            self.model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+        ).eval()
+        sample = torch.tensor(data["train"][:1]["input_ids"]).to(model.device)
+        with torch.inference_mode():
+            output_base = model(sample)
+
+        config = LoraConfig(task_type=TaskType.CAUSAL_LM, init_lora_weights=False)
+        model = get_peft_model(model, config).eval()
+        with torch.inference_mode():
+            output_lora = model(sample)
+
+        model.merge_adapter()
+        with torch.inference_mode():
+            output_merged = model(sample)
+
+        # merging is less precise, be more tolerant
+        atol, rtol = 1e-1, 1e-1
+        # outputs of the base model != output of lora adapter == output of merged adapter
+        assert not torch.allclose(output_base.logits, output_lora.logits, atol=atol, rtol=rtol)
+        assert torch.allclose(output_lora.logits, output_merged.logits, atol=atol, rtol=rtol)
+
+    @require_bitsandbytes
+    def test_causal_lm_merging_multiple_lora_adapters_compile(self, tokenizer, data):
+        # merge multiple adapters at once
+        torch.manual_seed(0)
+        model = AutoModelForCausalLM.from_pretrained(
+            self.model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+        ).eval()
+        sample = torch.tensor(data["train"][:1]["input_ids"]).to(model.device)
+        with torch.inference_mode():
+            output_base = model(sample)
+
+        config = LoraConfig(task_type=TaskType.CAUSAL_LM, init_lora_weights=False)
+        model = get_peft_model(model, config).eval()
+        model.add_adapter("other", config)
+        with torch.inference_mode():
+            output_default = model(sample)
+
+        model.set_adapter("other")
+        with torch.inference_mode():
+            output_other = model(sample)
+
+        model.base_model.merge_adapter(["default", "other"])
+        with torch.inference_mode():
+            output_merged = model(sample)
+
+        # merging is less precise, be more tolerant
+        atol, rtol = 1e-1, 1e-1
+        # outputs of the base model != output of default adapter != output of other adapter
+        assert not torch.allclose(output_base.logits, output_default.logits, atol=atol, rtol=rtol)
+        assert not torch.allclose(output_base.logits, output_other.logits, atol=atol, rtol=rtol)
+        assert not torch.allclose(output_default.logits, output_other.logits, atol=atol, rtol=rtol)
+        # outputs of merged adapter != all others
+        assert not torch.allclose(output_base.logits, output_merged.logits, atol=atol, rtol=rtol)
+        assert not torch.allclose(output_default.logits, output_merged.logits, atol=atol, rtol=rtol)
+        assert not torch.allclose(output_other.logits, output_merged.logits, atol=atol, rtol=rtol)
+
+    @require_bitsandbytes
+    def test_causal_lm_merge_and_unload_lora_adapter_compile(self, tokenizer, data):
+        torch.manual_seed(0)
+        model = AutoModelForCausalLM.from_pretrained(
+            self.model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+        ).eval()
+        sample = torch.tensor(data["train"][:1]["input_ids"]).to(model.device)
+        with torch.inference_mode():
+            output_base = model(sample)
+
+        config = LoraConfig(task_type=TaskType.CAUSAL_LM, init_lora_weights=False)
+        model = get_peft_model(model, config).eval()
+        model = self.compile(model, {})
+        with torch.inference_mode():
+            output_lora = model(sample)
+
+        unloaded = model.merge_and_unload()
+        with torch.inference_mode():
+            output_unloaded = unloaded(sample)
+
+        # merging is less precise, be more tolerant
+        atol, rtol = 1e-1, 1e-1
+        # outputs of the base model != output of lora adapter == output of unloaded adapter
+        assert not torch.allclose(output_base.logits, output_lora.logits, atol=atol, rtol=rtol)
+        assert torch.allclose(output_lora.logits, output_unloaded.logits, atol=atol, rtol=rtol)
+
+    @require_bitsandbytes
+    def test_causal_lm_mixed_batch_lora_adapter_compile(self, tokenizer, data):
+        torch.manual_seed(0)
+        model = AutoModelForCausalLM.from_pretrained(
+            self.model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+        ).eval()
+
+        # we need at least 3 samples for this to work!
+        sample = {
+            "input_ids": torch.arange(12).reshape(3, 4).to("cuda"),
+            "attention_mask": torch.ones(3, 4).long().to("cuda"),
+        }
+
+        with torch.inference_mode():
+            output_base = model(**sample)
+
+        config = LoraConfig(task_type=TaskType.CAUSAL_LM, init_lora_weights=False)
+        model = get_peft_model(model, config).eval()
+        with torch.inference_mode():
+            output_default = model(**sample)
+
+        model.add_adapter("other", config)
+        model.set_adapter("other")
+        with torch.inference_mode():
+            output_other = model(**sample)
+
+        model = self.compile(model, {})
+
+        # set adapter_indices so that it alternates between 0 (base), lora 1, and lora 2
+        adapter_names = ["__base__", "default", "other"]
+        with torch.inference_mode():
+            output_mixed = model(**sample, adapter_names=adapter_names)
+
+        atol, rtol = 5e-4, 5e-4
+        # outputs of the base model != output of lora adapter 1 != output of other adapter
+        assert not torch.allclose(output_base.logits, output_default.logits, atol=atol, rtol=rtol)
+        assert not torch.allclose(output_default.logits, output_other.logits, atol=atol, rtol=rtol)
+        assert not torch.allclose(output_other.logits, output_mixed.logits, atol=atol, rtol=rtol)
+        # outputs of mixed adapter is mix of all 3
+        assert torch.allclose(output_base.logits[0], output_mixed.logits[0], atol=atol, rtol=rtol)
+        assert torch.allclose(output_default.logits[1], output_mixed.logits[1], atol=atol, rtol=rtol)
+        assert torch.allclose(output_other.logits[2], output_mixed.logits[2], atol=atol, rtol=rtol)
+
+    @require_bitsandbytes
+    def test_causal_lm_add_weighted_adapter_lora_adapter_compile(self, tokenizer, data):
+        torch.manual_seed(0)
+        model = AutoModelForCausalLM.from_pretrained(
+            self.model_id,
+            device_map="auto",
+            quantization_config=BitsAndBytesConfig(load_in_4bit=True),
+        ).eval()
+        sample = torch.tensor(data["train"][:1]["input_ids"]).to(model.device)
+        with torch.inference_mode():
+            output_base = model(sample)
+
+        config = LoraConfig(task_type=TaskType.CAUSAL_LM, init_lora_weights=False)
+        model = get_peft_model(model, config).eval()
+        model.add_adapter("other", config)
+        with torch.inference_mode():
+            output_default = model(sample)
+
+        model.set_adapter("other")
+        with torch.inference_mode():
+            output_other = model(sample)
+
+        model.add_weighted_adapter(["default", "other"], [0.5, 0.5], adapter_name="combined")
+        model.set_adapter("combined")
+        with torch.inference_mode():
+            output_combined = model(sample)
+
+        atol, rtol = 1e-4, 1e-4
+        # outputs of the base model != output of default adapter != output of other adapter
+        assert not torch.allclose(output_base.logits, output_default.logits, atol=atol, rtol=rtol)
+        assert not torch.allclose(output_base.logits, output_other.logits, atol=atol, rtol=rtol)
+        assert not torch.allclose(output_default.logits, output_other.logits, atol=atol, rtol=rtol)
+        # outputs of combined adapter != all others
+        assert not torch.allclose(output_base.logits, output_combined.logits, atol=atol, rtol=rtol)
+        assert not torch.allclose(output_default.logits, output_combined.logits, atol=atol, rtol=rtol)
+        assert not torch.allclose(output_other.logits, output_combined.logits, atol=atol, rtol=rtol)
diff --git a/tests/test_trainable_tokens.py b/tests/test_trainable_tokens.py
new file mode 100644
index 0000000..248bd64
--- /dev/null
+++ b/tests/test_trainable_tokens.py
@@ -0,0 +1,1389 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+from __future__ import annotations
+
+import copy
+from unittest.mock import patch
+
+import pytest
+import torch
+from safetensors.torch import load_file as safe_load_file
+from transformers import AutoModelForCausalLM, AutoModelForSeq2SeqLM, AutoTokenizer, BartConfig, BartModel
+
+from peft import AutoPeftModel, LoraConfig, PeftModel, TrainableTokensConfig, get_peft_model
+from peft.import_utils import is_transformers_ge_v5
+from peft.tuners.trainable_tokens.layer import TrainableTokensLayer
+from peft.utils import TrainableTokensWrapper, get_peft_model_state_dict
+
+from .testing_utils import hub_online_once
+
+
+class ModelEmb(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.emb = torch.nn.Embedding(100, 10)
+        self.lin0 = torch.nn.Linear(10, 1)
+
+    def forward(self, x):
+        return self.lin0(self.emb(x))
+
+    def get_input_embeddings(self):
+        return self.emb
+
+
+class ModelEmbedIn(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.embed_in = torch.nn.Embedding(100, 10)
+        self.lin0 = torch.nn.Linear(10, 1)
+
+    def forward(self, x):
+        return self.lin0(self.embed_in(x))
+
+    def get_input_embeddings(self):
+        return self.embed_in
+
+
+class ModelEmbedMultiple(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.embed_in = torch.nn.Embedding(100, 10)
+        self.embed_in_2 = torch.nn.Embedding(100, 10)
+        self.lin0 = torch.nn.Linear(10, 1)
+
+    def forward(self, x):
+        return self.lin0(self.embed_in(x) + self.embed_in_2(x))
+
+    def get_input_embeddings(self):
+        return self.embed_in
+
+
+class ModelEmbedInNoGet(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.embed_in = torch.nn.Embedding(100, 10)
+        self.lin0 = torch.nn.Linear(10, 1)
+
+    def forward(self, x):
+        return self.lin0(self.embed_in(x))
+
+
+class TestTrainableTokens:
+    @pytest.fixture
+    def model_id(self):
+        return "trl-internal-testing/tiny-random-LlamaForCausalLM"
+
+    @pytest.fixture
+    def model_multi_embedding(self):
+        class MultiEmbeddingMLP(torch.nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.emb_text = torch.nn.Embedding(10, 5)
+                self.emb_image = torch.nn.Embedding(8, 5)
+                self.lin0 = torch.nn.Linear(5, 10)
+                self.lin1 = torch.nn.Linear(10, 20)
+
+            def forward(self, x_text, x_image):
+                x_text = self.emb_text(x_text)
+                x_image = self.emb_image(x_image)
+                y = self.lin0(torch.concat([x_text, x_image], dim=1).view(-1, 5))
+                y = self.lin1(y)
+                return y, (x_text, x_image)
+
+        return MultiEmbeddingMLP()
+
+    @pytest.fixture
+    def model(self, model_id):
+        with hub_online_once(model_id):
+            # This must not be a yield fixture so that we don't carry the hub_online_once
+            # behavior over to the rest of the test that uses this fixture
+            return AutoModelForCausalLM.from_pretrained(model_id)
+
+    @pytest.fixture
+    def tokenizer(self, model_id):
+        return AutoTokenizer.from_pretrained(model_id)
+
+    def simulate_training(self, trainable_tokens_layer, adapter_name="default"):
+        """Simulates training of trainable_tokens adapter layer by assigning random
+        values to the delta tokens.
+        """
+        trainable_tokens_layer.trainable_tokens_delta[adapter_name].data = torch.rand_like(
+            trainable_tokens_layer.trainable_tokens_delta[adapter_name].data
+        )
+
+    def test_stand_alone_usage(self, model, tokenizer, tmp_path):
+        original_model = copy.deepcopy(model)
+
+        peft_config = TrainableTokensConfig(target_modules=["embed_tokens"], token_indices=[0, 1, 3])
+        peft_model = get_peft_model(model, peft_config)
+        save_path = tmp_path / "stand_alone_usage"
+
+        # simulate normal use but take care to use the tokens that we expect to be modified
+        # (+1 that we don't expect to be modified)
+        X = {
+            "input_ids": torch.tensor([[0, 1, 2, 3]]),
+            "attention_mask": torch.tensor([[1, 1, 1, 1]]),
+        }
+
+        idcs_to_modify = peft_config.token_indices
+        idcs_to_keep = [i for i in X["input_ids"][0].tolist() if i not in idcs_to_modify]
+
+        self.simulate_training(peft_model.model.model.embed_tokens)
+        output_train = peft_model(output_hidden_states=True, **X)
+
+        peft_model.save_pretrained(save_path)
+        peft_model_org = peft_model
+
+        # check whether the token indices differ from the base model after loading the model
+        # from the checkpoint.
+        peft_model = AutoPeftModel.from_pretrained(save_path)
+        output_load = peft_model(output_hidden_states=True, **X)
+        output_orig = original_model(output_hidden_states=True, **X)
+
+        # on the way, make sure that the embedding matrix itself was not modified
+        assert torch.allclose(
+            peft_model.model.model.embed_tokens.weight,
+            peft_model_org.model.model.embed_tokens.weight,
+        )
+
+        W_load = output_load.hidden_states[0]
+        W_orig = output_orig.hidden_states[0]
+        W_train = output_train.hidden_states[0]
+
+        # all PEFT model embed outputs must equal the outputs during 'training' to make sure
+        # that saving/loading works properly.
+        assert torch.allclose(W_load, W_train)
+
+        assert not torch.allclose(W_load[:, idcs_to_modify], W_orig[:, idcs_to_modify])
+        assert torch.allclose(W_load[:, idcs_to_keep], W_orig[:, idcs_to_keep])
+
+    @pytest.mark.parametrize(
+        "peft_config",
+        [
+            LoraConfig(
+                target_modules="all-linear",
+                trainable_token_indices={"embed_tokens": [0, 1, 3]},
+            ),
+        ],
+    )
+    def test_combined_with_peft_method_usage(self, model, tokenizer, peft_config, tmp_path):
+        original_model = copy.deepcopy(model)
+        peft_model = get_peft_model(model, peft_config)
+        save_path = tmp_path / "combined_usage"
+
+        # simulate normal use but take care to use the tokens that we expect to be modified
+        # (+2 that we don't expect to be modified)
+        X = {
+            "input_ids": torch.tensor([[0, 1, 2, 3, 4]]),
+            "attention_mask": torch.tensor([[1, 1, 1, 1, 1]]),
+        }
+
+        idcs_to_modify = peft_config.trainable_token_indices["embed_tokens"]
+        idcs_to_keep = [i for i in X["input_ids"][0].tolist() if i not in idcs_to_modify]
+
+        self.simulate_training(peft_model.model.model.embed_tokens.token_adapter)
+        output_train = peft_model(output_hidden_states=True, **X)
+
+        peft_model.save_pretrained(save_path)
+        peft_model_org = peft_model
+
+        # check whether the token indices differ from the base model
+        peft_model = AutoPeftModel.from_pretrained(save_path)
+        output_load = peft_model(output_hidden_states=True, **X)
+        output_orig = original_model(output_hidden_states=True, **X)
+
+        W_load = output_load.hidden_states[0]
+        W_orig = output_orig.hidden_states[0]
+        W_train = output_train.hidden_states[0]
+
+        # all PEFT model embed outputs must equal the outputs during 'training' to make sure
+        # that saving/loading works properly.
+        assert torch.allclose(W_load, W_train)
+
+        assert not torch.allclose(W_load[:, idcs_to_modify], W_orig[:, idcs_to_modify])
+        assert torch.allclose(W_load[:, idcs_to_keep], W_orig[:, idcs_to_keep])
+
+    def test_basic_training(self, model, tokenizer):
+        # ensure that the model can be trained and backpropagation works
+        config = TrainableTokensConfig(
+            target_modules=["embed_tokens"],
+            token_indices=[0, 10],
+        )
+
+        model = get_peft_model(model, config)
+        optimizer = torch.optim.AdamW(model.parameters(), lr=1)
+
+        initial_delta = model.model.model.embed_tokens.trainable_tokens_delta.default.clone()
+        initial_originals = model.model.model.embed_tokens.trainable_tokens_original.default.clone()
+
+        X = {
+            "input_ids": torch.tensor([[0, 1, 2, 3, 4]]),
+            "attention_mask": torch.tensor([[1, 1, 1, 1, 1]]),
+        }
+
+        for step in range(3):
+            optimizer.zero_grad()
+            y_pred = model(**X)
+            loss = y_pred.logits.mean()
+            loss.backward()
+            optimizer.step()
+
+        assert torch.allclose(
+            model.model.model.embed_tokens.trainable_tokens_original.default,
+            initial_originals,
+        )
+        assert not torch.allclose(
+            model.model.model.embed_tokens.trainable_tokens_delta.default,
+            initial_delta,
+        )
+
+    @pytest.mark.parametrize(
+        "peft_config",
+        [
+            LoraConfig(
+                target_modules="all-linear",
+                trainable_token_indices={"embed_tokens": [0, 1, 3]},
+            ),
+        ],
+    )
+    def test_disable_adapters_with_merging(self, model, tokenizer, peft_config):
+        X = {
+            "input_ids": torch.tensor([[0, 1, 2, 3, 4]]),
+            "attention_mask": torch.tensor([[1, 1, 1, 1, 1]]),
+        }
+
+        model = get_peft_model(model, peft_config)
+        model.eval()
+
+        outputs_before = model(**X).logits
+
+        model.train()
+        lr = 0.01
+        optimizer = torch.optim.Adam(model.parameters(), lr=lr)
+
+        # train at least 3 steps for all parameters to be updated (probably this is required because of symmetry
+        # breaking of some LoRA layers that are initialized with constants)
+        for _ in range(3):
+            optimizer.zero_grad()
+            y_pred = model(**X)
+            loss = y_pred.logits.mean()
+            loss.backward()
+            optimizer.step()
+
+        model.eval()
+        outputs_unmerged = model(**X).logits
+        model.merge_adapter()
+        outputs_after = model(**X).logits
+
+        with model.disable_adapter():
+            outputs_disabled = model(**X).logits
+
+        # check that after leaving the disable_adapter context, everything is enabled again
+        outputs_enabled_after_disable = model(**X).logits
+
+        atol, rtol = 1e-5, 1e-5  # tolerances higher than defaults since merging introduces some numerical instability
+
+        # check that there is a difference in results after training
+        assert not torch.allclose(outputs_before, outputs_after, atol=atol, rtol=rtol)
+
+        # unmerged or merged should make no difference
+        assert torch.allclose(outputs_after, outputs_unmerged, atol=atol, rtol=rtol)
+
+        # check that disabling adapters gives the same results as before training
+        assert torch.allclose(outputs_before, outputs_disabled, atol=atol, rtol=rtol)
+
+        # check that enabling + disabling adapters does not change the results
+        assert torch.allclose(outputs_after, outputs_enabled_after_disable, atol=atol, rtol=rtol)
+
+    @pytest.mark.parametrize(
+        "peft_config",
+        [
+            LoraConfig(
+                target_modules="all-linear",
+                trainable_token_indices={"embed_tokens": [0, 1, 3]},
+            ),
+        ],
+    )
+    def test_safe_merge_with_adapter(self, model, tokenizer, peft_config):
+        X = {
+            "input_ids": torch.tensor([[0, 1, 2, 3]]),
+            "attention_mask": torch.tensor([[1, 1, 1, 1]]),
+        }
+
+        model = model.eval()
+        logits_base = model(**X).logits
+
+        model = get_peft_model(model, peft_config).eval()
+        logits_peft = model(**X).logits
+
+        atol, rtol = 1e-6, 1e-6  # default
+
+        model_unloaded = model.merge_and_unload(safe_merge=True)
+        logits_unloaded = model_unloaded(**X).logits
+
+        # check that the logits are the same after unloading
+        assert torch.allclose(logits_peft, logits_unloaded, atol=atol, rtol=rtol)
+
+    @pytest.mark.parametrize(
+        "peft_config",
+        [
+            LoraConfig(
+                target_modules="all-linear",
+                trainable_token_indices={"embed_tokens": [0, 1, 3]},
+            ),
+        ],
+    )
+    def test_load_multiple_adapters(self, model, peft_config, tmp_path):
+        # tests if having more than one adapter (even with just the same config) works
+        original_model = copy.deepcopy(model)
+        model = get_peft_model(model, peft_config)
+
+        model.save_pretrained(tmp_path)
+        del model
+
+        model = original_model
+        model = PeftModel.from_pretrained(model, tmp_path)
+        load_result1 = model.load_adapter(tmp_path, adapter_name="other")
+        load_result2 = model.load_adapter(tmp_path, adapter_name="yet-another")
+
+        assert load_result1.missing_keys == []
+        assert load_result2.missing_keys == []
+
+    @pytest.mark.parametrize(
+        "peft_config_factory",
+        [
+            lambda token_indices: LoraConfig(
+                target_modules="all-linear",
+                trainable_token_indices={"embed_tokens": token_indices},
+            ),
+        ],
+    )
+    def test_multiple_adapters_different_token_indices(self, model, peft_config_factory, tmp_path):
+        # tests if multiple adapters with different token indices work
+        original_model = copy.deepcopy(model)
+
+        token_indices_1 = [0, 1, 2]
+        token_indices_2 = [2, 3, 4]
+
+        peft_config_1 = peft_config_factory(token_indices_1)
+        peft_config_2 = peft_config_factory(token_indices_2)
+
+        model = get_peft_model(model, peft_config_1, adapter_name="adapter_1")
+        model.add_adapter("adapter_2", peft_config_2)
+
+        # "train" adapter 1
+        model.set_adapter("adapter_1")
+        self.simulate_training(model.model.model.embed_tokens.token_adapter, "adapter_1")
+
+        # "train" adapter 2
+        model.set_adapter("adapter_2")
+        self.simulate_training(model.model.model.embed_tokens.token_adapter, "adapter_2")
+
+        # now we infer on adapter 1 and on adapter 2 and check if the requested indices are changed for
+        # each adapter. e.g., for adapter 1, only token indices 1 should be changed.
+        X = {
+            "input_ids": torch.tensor([list(set(token_indices_1 + token_indices_2))]),
+            "attention_mask": torch.tensor([[1] * (len(set(token_indices_1 + token_indices_2)))]),
+        }
+
+        original_output = original_model(output_hidden_states=True, **X).hidden_states[0]
+
+        # infer with adapter 1, embeddings for token indices 1 should be changed, no others.
+        model.set_adapter("adapter_1")
+        adapter_1_output = model(output_hidden_states=True, **X).hidden_states[0]
+
+        idcs_to_modify = token_indices_1
+        idcs_to_keep = [i for i in X["input_ids"][0].tolist() if i not in idcs_to_modify]
+
+        assert not torch.allclose(adapter_1_output[:, idcs_to_modify], original_output[:, idcs_to_modify])
+        assert torch.allclose(adapter_1_output[:, idcs_to_keep], original_output[:, idcs_to_keep])
+
+        # infer with adapter 2, embeddings for token indices 2 should be changed, no others.
+        model.set_adapter("adapter_2")
+        adapter_2_output = model(output_hidden_states=True, **X).hidden_states[0]
+
+        idcs_to_modify = token_indices_2
+        idcs_to_keep = [i for i in X["input_ids"][0].tolist() if i not in idcs_to_modify]
+
+        assert not torch.allclose(adapter_2_output[:, idcs_to_modify], original_output[:, idcs_to_modify])
+        assert torch.allclose(adapter_2_output[:, idcs_to_keep], original_output[:, idcs_to_keep])
+
+    @pytest.mark.parametrize(
+        "peft_config_factory",
+        [
+            lambda token_indices: LoraConfig(
+                target_modules="all-linear",
+                trainable_token_indices={"embed_tokens": token_indices},
+            ),
+        ],
+    )
+    def test_multiple_adapters_overlapping_token_indices_merging(self, model, peft_config_factory, tmp_path):
+        # tests that merging multiple adapters that have overlapping indices is not defined at the moment
+        # and would yield undefined behavior. note that merging a single adapter is fine.
+        original_model = copy.deepcopy(model)
+
+        token_indices_1 = [0, 1, 2]
+        token_indices_2 = [2, 3, 4]
+
+        peft_config_1 = peft_config_factory(token_indices_1)
+        peft_config_2 = peft_config_factory(token_indices_2)
+
+        model = get_peft_model(model, peft_config_1, adapter_name="adapter_1")
+        model.add_adapter("adapter_2", peft_config_2)
+
+        with pytest.raises(ValueError) as e:
+            model.merge_and_unload(adapter_names=["adapter_1", "adapter_2"])
+        assert "are already defined and would result in undefined merging behavior" in str(e)
+
+    @pytest.mark.parametrize(
+        "peft_config_factory",
+        [
+            lambda targets, token_indices: LoraConfig(
+                target_modules=targets,
+                trainable_token_indices={"embed_tokens": token_indices},
+            ),
+        ],
+    )
+    def test_multiple_adapters_mixed_forward(self, model, peft_config_factory, tmp_path):
+        # tests if multiple adapters with different token indices work
+        original_model = copy.deepcopy(model)
+
+        token_indices_1 = [0, 1, 2]
+        token_indices_2 = [2, 3, 4]
+
+        peft_config_1 = peft_config_factory(".*q_proj", token_indices_1)
+        peft_config_2 = peft_config_factory(".*o_proj", token_indices_2)
+
+        model = get_peft_model(model, peft_config_1, adapter_name="adapter_1")
+        model.add_adapter("adapter_2", peft_config_2)
+
+        # "train" adapter 1
+        model.set_adapter("adapter_1")
+        self.simulate_training(model.model.model.embed_tokens.token_adapter, "adapter_1")
+
+        # "train" adapter 2
+        model.set_adapter("adapter_2")
+        self.simulate_training(model.model.model.embed_tokens.token_adapter, "adapter_2")
+
+        # forward(adapter_names=...) is not available in train mode
+        model.eval()
+
+        # Build a batch of 2 items, each the same input sequence but each sequence will be passed to a different
+        # adapter via mixed batch forward.
+        input_sequence = list(set(token_indices_1 + token_indices_2))
+        X = {
+            "input_ids": torch.tensor([input_sequence, input_sequence]),
+            "attention_mask": torch.tensor([[1] * len(input_sequence), [1] * len(input_sequence)]),
+        }
+        batch_adapter_names = ["adapter_1", "adapter_2"]
+
+        original_output = original_model(output_hidden_states=True, **X)
+        mixed_output = model(output_hidden_states=True, adapter_names=batch_adapter_names, **X)
+
+        # check that the active adapter is still the last activated adapter, adapter_2
+        assert model.model.model.embed_tokens.token_adapter.active_adapter == ["adapter_2"]
+
+        adapter_1_output = mixed_output.hidden_states[0][0:1]
+        original_output_1 = original_output.hidden_states[0][0:1]
+        adapter_2_output = mixed_output.hidden_states[0][1:2]
+        original_output_2 = original_output.hidden_states[0][1:2]
+
+        idcs_to_modify = token_indices_1
+        idcs_to_keep = [i for i in X["input_ids"][0].tolist() if i not in idcs_to_modify]
+
+        assert not torch.allclose(adapter_1_output[:, idcs_to_modify], original_output_1[:, idcs_to_modify])
+        assert torch.allclose(adapter_1_output[:, idcs_to_keep], original_output_1[:, idcs_to_keep])
+
+        idcs_to_modify = token_indices_2
+        idcs_to_keep = [i for i in X["input_ids"][0].tolist() if i not in idcs_to_modify]
+
+        assert not torch.allclose(adapter_2_output[:, idcs_to_modify], original_output_2[:, idcs_to_modify])
+        assert torch.allclose(adapter_2_output[:, idcs_to_keep], original_output_2[:, idcs_to_keep])
+
+    def test_stand_alone_raises_target_layer_not_found(self, model):
+        config = TrainableTokensConfig(target_modules=["doesnt_exist"], token_indices=[0, 1, 3])
+        with pytest.raises(ValueError) as e:
+            model = get_peft_model(model, config)
+        assert "Target modules ['doesnt_exist'] not found in the base model." in str(e)
+
+    @pytest.mark.parametrize(
+        "peft_config, target_layer_name",
+        [
+            (LoraConfig(trainable_token_indices={"does-not-exist": [0, 1, 2]}), "does-not-exist"),
+        ],
+    )
+    def test_combined_with_peft_raises_target_layer_not_found(self, model, peft_config, target_layer_name):
+        # same as test_stand_alone_raises_target_layer_not_found but tests the peft method integration
+        with pytest.raises(ValueError) as e:
+            model = get_peft_model(model, peft_config)
+        assert f"Target modules {{{target_layer_name!r}}} not found in the base model." in str(e)
+
+    def test_multiple_targets(self, model_multi_embedding):
+        # tests the ability of targeting two modules with the same token indices
+        original_model = copy.deepcopy(model_multi_embedding)
+        config = TrainableTokensConfig(target_modules=["emb_text", "emb_image"], token_indices=[0, 1])
+        peft_model = get_peft_model(model_multi_embedding, config)
+
+        self.simulate_training(peft_model.model.emb_text)
+        self.simulate_training(peft_model.model.emb_image)
+
+        X = {
+            "x_text": torch.tensor([[0, 1, 2]]),
+            "x_image": torch.tensor([[0, 1, 2]]),
+        }
+
+        _, (emb_text_orig, emb_image_orig) = original_model(**X)
+        _, (emb_text_peft, emb_image_peft) = peft_model(**X)
+
+        assert not torch.allclose(emb_text_orig[:, [0, 1]], emb_text_peft[:, [0, 1]])
+        assert torch.allclose(emb_text_orig[:, [2]], emb_text_peft[:, [2]])
+        assert not torch.allclose(emb_image_orig[:, [0, 1]], emb_image_peft[:, [0, 1]])
+        assert torch.allclose(emb_image_orig[:, [2]], emb_image_peft[:, [2]])
+
+    @pytest.mark.parametrize(
+        "peft_config",
+        [
+            LoraConfig(
+                target_modules="all-linear",
+                trainable_token_indices={"embed_tokens": [0, 1, 3]},
+            ),
+        ],
+    )
+    def test_no_embeddings_in_save_with_combined_usage(self, model, tokenizer, peft_config, tmp_path):
+        # make sure that in combined use the only state dict key is that of the token deltas and nothing more
+
+        peft_model = get_peft_model(model, peft_config)
+        state_dict = get_peft_model_state_dict(
+            model=peft_model,
+            state_dict=None,
+            adapter_name="default",
+        )
+
+        embedding_keys = [n for n in state_dict.keys() if "embed_tokens" in n]
+        assert embedding_keys == ["base_model.model.model.embed_tokens.token_adapter.trainable_tokens_delta"]
+
+    @pytest.fixture()
+    def model_weight_untied(self, model):
+        return model
+
+    @pytest.fixture()
+    def model_id_weight_tied(self):
+        return "peft-internal-testing/opt-125m"
+
+    @pytest.fixture()
+    def model_weight_tied(self, request, model_id_weight_tied):
+        model_weight_tied = AutoModelForCausalLM.from_pretrained(model_id_weight_tied)
+        tied_keys = model_weight_tied._tied_weights_keys
+
+        # TODO remove when transformers <5 is not supported anymore
+        if not hasattr(request, "param") or request.param == "list":
+            if isinstance(tied_keys, list):
+                # transformers <5, list is already the default
+                yield model_weight_tied
+            else:
+                # simulate transformers <5 for backward compatibility testing
+                with patch.object(model_weight_tied, "_tied_weights_keys", list(tied_keys.keys())):
+                    yield model_weight_tied
+
+        elif request.param == "mapping":
+            if isinstance(tied_keys, dict):
+                # transformers >=5, mapping is already the default
+                yield model_weight_tied
+            else:
+                # simulate transformers >=5
+                mapping = {"lm_head.weight": "model.decoder.embed_tokens.weight"}
+
+                with patch.object(model_weight_tied, "_tied_weights_keys", mapping):
+                    yield model_weight_tied
+
+        else:
+            raise RuntimeError("Invalid request")
+
+    @pytest.mark.parametrize(
+        "peft_config",
+        [
+            LoraConfig(
+                target_modules="all-linear",
+                trainable_token_indices={"embed_tokens": [0, 1, 3]},
+            ),
+        ],
+    )
+    def test_weight_tying_noop_when_model_is_untied(self, model_weight_untied, peft_config, tmp_path):
+        # test if the weight tying is affected as well when we modified the embedding.
+        assert model_weight_untied._tied_weights_keys
+        assert not model_weight_untied.config.tie_word_embeddings
+
+        peft_model = get_peft_model(model_weight_untied, peft_config)
+        assert hasattr(peft_model.model.model.embed_tokens, "token_adapter")
+        assert not hasattr(peft_model.model.lm_head, "token_adapter")
+
+    @pytest.mark.parametrize(
+        "peft_config, model_weight_tied",
+        [
+            (
+                LoraConfig(
+                    target_modules="all-linear",
+                    trainable_token_indices={"embed_tokens": [0, 1, 3]},
+                ),
+                "list",
+            ),
+            (
+                LoraConfig(
+                    target_modules="all-linear",
+                    trainable_token_indices={"embed_tokens": [0, 1, 3]},
+                ),
+                "mapping",
+            ),
+        ],
+        indirect=["model_weight_tied"],
+    )
+    def test_weight_tying_applied_when_model_is_tied(self, model_weight_tied, peft_config, tmp_path):
+        # test if the weight tying is affected as well when we modified the embedding.
+        assert model_weight_tied._tied_weights_keys
+        assert model_weight_tied.config.tie_word_embeddings
+
+        peft_model = get_peft_model(model_weight_tied, peft_config)
+
+        # make it so that the input embeddings diverge. when the weights are tied this should
+        # reflect in the output embeddings as well.
+        self.simulate_training(peft_model.model.model.decoder.embed_tokens.token_adapter)
+
+        # we have to find out if the input embedding tying is doing its job during forward.
+        # for this we can leverage the fact that  emb_out(1/emb_in(x))  is  embed_dim  on the
+        # diagonal iff emb_in.weight == emb_out.weight.
+        token_indices = [0, 1, 2, 3]
+        emb_dim = 768
+        emb_in = peft_model.model.model.decoder.embed_tokens(torch.tensor([token_indices]))
+        emb_out = peft_model.model.lm_head(1 / emb_in)
+
+        assert torch.allclose(torch.diag(emb_out[0]), torch.tensor([emb_dim] * len(token_indices)).float())
+
+        # make sure that the state dict does not include weight-tied weights.
+        state_dict = get_peft_model_state_dict(peft_model)
+        assert not [key for key in state_dict if any(tied_key in key for tied_key in peft_model._tied_weights_keys)]
+
+        # make sure that merging and unloading restores the weight-tying.
+        merged_model = peft_model.merge_and_unload()
+
+        assert merged_model.model.decoder.embed_tokens.weight.data_ptr() == merged_model.lm_head.weight.data_ptr()
+
+    @pytest.mark.parametrize("model_weight_tied", ["list", "mapping"], indirect=["model_weight_tied"])
+    def test_weight_tying_applied_when_model_is_tied_standalone(self, model_weight_tied):
+        # since weight tying is currently not supported make sure that an error is raised when attempting
+        # to use a model that has tied input/output embeddings
+        assert model_weight_tied._tied_weights_keys
+        assert model_weight_tied.config.tie_word_embeddings
+
+        peft_config = TrainableTokensConfig(
+            target_modules=["embed_tokens"],
+            token_indices=[0, 1, 3],
+        )
+
+        peft_model = get_peft_model(model_weight_tied, peft_config)
+
+        # make it so that the input embeddings diverge. when the weights are tied this should
+        # reflect in the output embeddings as well.
+        self.simulate_training(peft_model.model.model.decoder.embed_tokens)
+
+        # we have to find out if the input embedding tying is doing its job during forward.
+        # for this we can leverage the fact that  emb_out(1/emb_in(x))  is  embed_dim  on the
+        # diagonal iff  emb_in.weight == emb_out.weight.
+        token_indices = [0, 1, 2, 3]
+        emb_dim = 768
+        emb_in = peft_model.model.model.decoder.embed_tokens(torch.tensor([token_indices]))
+        emb_out = peft_model.model.lm_head(1 / emb_in)
+
+        assert torch.allclose(torch.diag(emb_out[0]), torch.tensor([emb_dim] * len(token_indices)).float())
+
+        # make sure that the state dict does not include weight-tied weights.
+        state_dict = get_peft_model_state_dict(peft_model)
+        assert not [key for key in state_dict if any(tied_key in key for tied_key in peft_model._tied_weights_keys)]
+
+        # make sure that merging and unloading restores the weight-tying.
+        merged_model = peft_model.merge_and_unload()
+
+        assert merged_model.model.decoder.embed_tokens.weight.data_ptr() == merged_model.lm_head.weight.data_ptr()
+
+    def test_weight_tying_state_dict_ignores_tied_weights(self, model_weight_tied):
+        # since weight tying is currently not supported make sure that an error is raised when attempting
+        # to use a model that has tied input/output embeddings
+        assert model_weight_tied._tied_weights_keys
+        assert model_weight_tied.config.tie_word_embeddings
+
+        peft_config = TrainableTokensConfig(
+            target_modules=["embed_tokens"],
+            token_indices=[0, 1, 3],
+        )
+
+        peft_model = get_peft_model(model_weight_tied, peft_config)
+
+        state_dict = peft_model.state_dict()
+        peft_state_dict = get_peft_model_state_dict(peft_model)
+
+        # the state dict or the peft model state dict must not include tied adapter weights
+        state_dict_keys = [n for n in state_dict.keys() if "tied_adapter." in n]
+        peft_state_dict_keys = [n for n in peft_state_dict.keys() if "tied_adapter." in n]
+
+        assert not state_dict_keys
+        assert not peft_state_dict_keys
+
+    @pytest.mark.parametrize(
+        "peft_config",
+        [
+            LoraConfig(
+                target_modules="all-linear",
+                trainable_token_indices={"shared": [0, 1, 3]},
+            ),
+        ],
+    )
+    def test_weight_tying_applied_when_model_is_tied_encoder_decoder(self, peft_config):
+        model_id = "peft-internal-testing/tiny-random-t5"
+        base_model = AutoModelForSeq2SeqLM.from_pretrained(model_id)
+
+        peft_model = get_peft_model(base_model, peft_config)
+
+        # make it so that the input embeddings diverge. when the weights are tied this should
+        # reflect in the output embeddings as well.
+        self.simulate_training(peft_model.model.shared.token_adapter)
+
+        # we have to find out if the input embedding tying is doing its job during forward.
+        # for this we can leverage the fact that  emb_out(1/emb_in(x))  is  embed_dim  on the
+        # diagonal iff  emb_in.weight == emb_out.weight.
+        token_indices = [0, 1, 2, 3]
+        emb_dim = base_model.config.d_model
+        emb_in = peft_model.model.encoder.embed_tokens(torch.tensor([token_indices]))
+        emb_out = peft_model.model.lm_head(1 / emb_in)
+
+        assert torch.allclose(torch.diag(emb_out[0]), torch.tensor([emb_dim] * len(token_indices)).float())
+
+        # T5 has a decoder embedding layer, we can simply check if it's forward is equal to the encoder
+        # embedding forward.
+        emb_out = peft_model.model.decoder.embed_tokens(torch.tensor([token_indices]))
+
+        assert torch.allclose(emb_in, emb_out)
+
+        # make sure that the state dict does not include weight-tied weights.
+        state_dict = get_peft_model_state_dict(peft_model)
+        assert not [key for key in state_dict if any(tied_key in key for tied_key in peft_model._tied_weights_keys)]
+
+        # make sure that merging and unloading restores the weight-tying.
+        merged_model = peft_model.merge_and_unload()
+
+        assert merged_model.encoder.embed_tokens.weight.data_ptr() == merged_model.lm_head.weight.data_ptr()
+        assert (
+            merged_model.encoder.embed_tokens.weight.data_ptr() == merged_model.decoder.embed_tokens.weight.data_ptr()
+        )
+
+    @pytest.mark.parametrize(
+        "peft_config",
+        [
+            LoraConfig(
+                target_modules="all-linear",
+                trainable_token_indices={"embed_tokens": [0, 1, 3]},
+                modules_to_save=["embed_tokens"],
+            ),
+        ],
+    )
+    def test_modules_to_save_excludes_trainable_tokens(self, model, peft_config):
+        with pytest.raises(ValueError) as e:
+            get_peft_model(model, peft_config)
+        assert "The embedding layer is already marked to be trained fully" in str(e)
+
+    def test_merge_and_unload_standalone(self, model):
+        # test basic functionality of merge_and_unload for standalone TrainableTokens
+        token_indices = [0, 1, 3]
+
+        peft_config = TrainableTokensConfig(
+            target_modules=["embed_tokens"],
+            token_indices=token_indices,
+        )
+
+        peft_model = get_peft_model(model, peft_config)
+
+        self.simulate_training(peft_model.model.model.embed_tokens)
+        expected_changed_weights = peft_model.model.model.embed_tokens.trainable_tokens_delta.default.data.clone()
+
+        # make sure no TrainableTokensLayer is in the module
+        merged_model = peft_model.merge_and_unload()
+        for _, module in merged_model.named_modules():
+            assert not isinstance(module, TrainableTokensLayer)
+
+        # make sure that deltas are applied to the embedding matrix
+        assert torch.allclose(merged_model.model.embed_tokens.weight.data[token_indices], expected_changed_weights)
+
+    def test_original_module_not_in_state_dict(self, model):
+        # Every AuxiliaryTrainingWrapper has an original_module attribute. Since the TrainableTokensWrapper is wrapping
+        # a TrainableTokensLayer and it already has a base layer which serves as the original module, we don't need that
+        # and so it should not come up in the state dict to save memory.
+
+        peft_config = LoraConfig(
+            target_modules="all-linear",
+            trainable_token_indices={"embed_tokens": [0, 1, 3]},
+        )
+
+        peft_model = get_peft_model(model, peft_config)
+
+        # make sure that the original module is present and accessible even though
+        # we want to exclude it from the state dict.
+        assert peft_model.model.model.embed_tokens.original_module
+
+        state_dict = get_peft_model_state_dict(peft_model)
+
+        assert not [k for k in state_dict if ".original_module.weight" in k]
+
+        state_dict = peft_model.state_dict()
+        assert not [k for k in state_dict if ".original_module.weight" in k]
+
+    @pytest.fixture
+    def model_emb(self):
+        return ModelEmb()
+
+    @pytest.fixture
+    def model_embed_in(self):
+        return ModelEmbedIn()
+
+    @pytest.fixture
+    def model_embed_in_no_get(self):
+        return ModelEmbedInNoGet()
+
+    @pytest.fixture
+    def model_embed_multiple(self):
+        return ModelEmbedMultiple()
+
+    @pytest.mark.parametrize(
+        "model_fixture_name, getter",
+        [
+            ("model_emb", lambda model: model.emb),
+            ("model_embed_in", lambda model: model.embed_in),
+            ("model", lambda model: model.model.model.embed_tokens),
+        ],
+    )
+    def test_default_embedding_name_is_inferred_standalone(self, model_fixture_name, getter, request):
+        # make sure that the auto targeting works when `target_module=None`
+        base_model = request.getfixturevalue(model_fixture_name)
+
+        peft_config = TrainableTokensConfig(target_modules=None, token_indices=[0, 1, 3])
+        peft_model = get_peft_model(base_model, peft_config)
+
+        assert isinstance(getter(peft_model), TrainableTokensLayer)
+
+    @pytest.mark.parametrize(
+        "model_fixture_name, getter",
+        [
+            ("model_emb", lambda model: model.emb),
+            ("model_embed_in", lambda model: model.embed_in),
+            ("model", lambda model: model.model.model.embed_tokens),
+        ],
+    )
+    def test_default_embedding_name_is_inferred_combined(self, model_fixture_name, getter, request):
+        # make sure that the auto targeting works when `target_module=None`
+        base_model = request.getfixturevalue(model_fixture_name)
+
+        peft_config = LoraConfig(target_modules="all-linear", trainable_token_indices=[0, 1, 3])
+        peft_model = get_peft_model(base_model, peft_config)
+
+        assert isinstance(getter(peft_model), TrainableTokensWrapper)
+
+    def test_default_embedding_name_cannot_be_inferred(self, model_embed_in_no_get):
+        # should default to default value `embed_tokens` which is not present in this model
+        base_model = model_embed_in_no_get
+
+        peft_config = TrainableTokensConfig(target_modules=None, token_indices=[0, 1, 3])
+
+        with pytest.raises(ValueError) as e:
+            peft_model = get_peft_model(base_model, peft_config)
+
+        assert "Target modules embed_tokens not found in the base model." in str(e)
+
+    def test_embedding_name_is_used_when_given_standalone(self, model_embed_multiple):
+        peft_config = TrainableTokensConfig(target_modules="embed_in_2", token_indices=[0, 1, 3])
+        peft_model = get_peft_model(model_embed_multiple, peft_config)
+
+        assert isinstance(peft_model.model.embed_in_2, TrainableTokensLayer)
+        assert not isinstance(peft_model.model.embed_in, TrainableTokensLayer)
+
+    def test_embedding_name_is_used_when_given_combined(self, model_embed_multiple):
+        peft_config = LoraConfig(target_modules="all-linear", trainable_token_indices={"embed_in_2": [0, 1, 3]})
+        peft_model = get_peft_model(model_embed_multiple, peft_config)
+
+        assert isinstance(peft_model.model.embed_in_2, TrainableTokensWrapper)
+        assert not isinstance(peft_model.model.embed_in, TrainableTokensWrapper)
+
+    @pytest.mark.parametrize("resize_embedding", [True, False])
+    @pytest.mark.parametrize(
+        "peft_config",
+        [
+            LoraConfig(target_modules="all-linear", trainable_token_indices=[1, 2, 3]),
+            TrainableTokensConfig(target_modules=None, token_indices=[1, 2, 3]),
+        ],
+    )
+    def test_save_pretrained_auto(self, model, resize_embedding, peft_config, tmp_path):
+        # make sure that embeddings are saved alongside trainable token weights but only when
+        # the we detect the embedding to be resized (as detected by save_embedding_layers="auto")
+        if resize_embedding:
+            model.resize_token_embeddings(model.config.vocab_size + 2)
+        peft_model = get_peft_model(model, peft_config)
+
+        peft_model.save_pretrained(tmp_path, save_embedding_layers="auto")
+        state_dict = safe_load_file(tmp_path / "adapter_model.safetensors")
+
+        if isinstance(peft_config, TrainableTokensConfig):
+            contains_embedding = "base_model.model.model.embed_tokens.base_layer.weight" in state_dict
+        else:
+            contains_embedding = "base_model.model.model.embed_tokens.token_adapter.base_layer.weight" in state_dict
+
+        if resize_embedding:
+            assert contains_embedding
+        else:
+            assert not contains_embedding
+
+    def test_embed_scale_is_applied(self):
+        """Test that TrainableTokens correctly handles embeddings with scaling (e.g., Gemma3)."""
+        model_id = "hf-internal-testing/tiny-random-Gemma3ForCausalLM"
+        with hub_online_once(model_id):
+            base_model = AutoModelForCausalLM.from_pretrained(model_id)
+            orig_embedding = base_model.get_input_embeddings()
+
+            peft_config = TrainableTokensConfig(target_modules=["embed_tokens"], token_indices=[0, 1, 3])
+            peft_model = get_peft_model(base_model, peft_config)
+
+            # sanity check: with the default embed_scale, the embedding output should be reasonably sized
+            peft_embedding = peft_model.base_model.model.get_input_embeddings()
+            max_embedding_output = peft_embedding(torch.arange(10)).abs().max(0)[0]
+            assert (max_embedding_output < 100.0).all()
+
+            # set embed_scale to an absurdly high value, then check that the embedding output is also scaled to a high
+            # value
+            orig_embedding.embed_scale.fill_(10000.0)
+            max_embedding_output = peft_embedding(torch.arange(10)).abs().max(0)[0]
+            assert (max_embedding_output > 100.0).all()
+
+            # set embed_scale to zero, then check that the embedding output is also zero
+            orig_embedding.embed_scale.fill_(0)
+            embedding_output = peft_embedding(torch.arange(10))
+            assert (embedding_output == 0.0).all()
+
+    def test_scaled_embedding_with_lora(self):
+        """
+        Test that TrainableTokens works with LoRA on scaled embeddings when both are active simultaneously.
+        """
+        model_id = "hf-internal-testing/tiny-random-Gemma3ForCausalLM"
+        with hub_online_once(model_id):
+            base_model = AutoModelForCausalLM.from_pretrained(model_id)
+            orig_embedding = base_model.get_input_embeddings()
+
+            # Apply both TrainableTokens and LoRA to the same model
+            peft_config = LoraConfig(target_modules=["q_proj"], trainable_token_indices={"embed_tokens": [0, 1, 3]})
+            peft_model = get_peft_model(base_model, peft_config)
+
+            x = torch.arange(10)
+            peft_embedding = peft_model.base_model.model.get_input_embeddings()
+            embedding_output = peft_embedding(x)
+            max_embedding_output = embedding_output.abs().max(0)[0]
+            assert (max_embedding_output < 100.0).all()
+            peft_model.merge_adapter()
+            embedding_merged = peft_embedding(x)
+            assert torch.allclose(embedding_output, embedding_merged)
+            peft_model.unmerge_adapter()
+
+            # set embed_scale to an absurdly high value, then check that the embedding output is also scaled to a high
+            # value
+            orig_embedding.embed_scale.fill_(10000.0)
+            max_embedding_output = peft_embedding(x).abs().max(0)[0]
+            assert (max_embedding_output > 100.0).all()
+
+            # set embed_scale to zero, then check that the embedding output is also zero
+            orig_embedding.embed_scale.fill_(0)
+            embedding_output = peft_embedding(x)
+            assert (embedding_output == 0.0).all()
+
+    # Tests for ensure_weight_tying parameter with trainable_token_indices
+    # See #2864 for details on the expected behavior
+    @pytest.mark.parametrize(
+        "trainable_token_indices",
+        [
+            [1, 2, 3],  # list format
+            {"embed_tokens": [1, 2, 3]},  # dict format - single layer
+            {"lm_head": [1, 2], "embed_tokens": [1, 2]},  # dict format - same indices
+            {"lm_head": [1, 2], "embed_tokens": [3, 4]},  # dict format - different indices
+        ],
+    )
+    def test_ensure_weight_tying_warns_when_model_not_tied(
+        self, model_weight_untied, recwarn, trainable_token_indices
+    ):
+        """Should warn when ensure_weight_tying=True but model doesn't have tied weights"""
+        peft_config = LoraConfig(
+            target_modules="all-linear",
+            trainable_token_indices=trainable_token_indices,
+            ensure_weight_tying=True,
+        )
+        peft_model = get_peft_model(model_weight_untied, peft_config)
+
+        warnings_list = [w.message.args[0] for w in recwarn]
+        expected = "ensure_weight_tying=True but the model does not have tied weights"
+        assert any(expected in msg for msg in warnings_list)
+
+        # Verify adapters are not tied (model doesn't have tied weights)
+        if isinstance(trainable_token_indices, dict) and len(trainable_token_indices) > 1:
+            embed_adapter = peft_model.model.model.embed_tokens.token_adapter
+            lm_head_adapter = peft_model.model.lm_head.token_adapter
+            assert embed_adapter is not None
+            assert lm_head_adapter is not None
+            assert embed_adapter.trainable_tokens_delta is not lm_head_adapter.trainable_tokens_delta
+
+    def test_weight_tying_bc_different_indices_treated_separately(self, model_weight_tied):
+        """Backwards compatibility: different indices should be treated separately when ensure_weight_tying=False"""
+        peft_config = LoraConfig(
+            target_modules="all-linear",
+            trainable_token_indices={"lm_head": [1, 2], "embed_tokens": [3, 4]},
+            ensure_weight_tying=False,  # BC behavior
+        )
+        peft_model = get_peft_model(model_weight_tied, peft_config)
+
+        # Check that both layers have token adapters but they're NOT tied
+        embed_adapter = peft_model.model.model.decoder.embed_tokens.token_adapter
+        lm_head_adapter = peft_model.model.lm_head.token_adapter
+
+        assert embed_adapter is not None
+        assert lm_head_adapter is not None
+        # They should NOT share the same delta parameters (treated as separate)
+        assert embed_adapter.trainable_tokens_delta is not lm_head_adapter.trainable_tokens_delta
+        # They should have different token indices
+        assert embed_adapter.token_indices["default"] == [3, 4]
+        assert lm_head_adapter.token_indices["default"] == [1, 2]
+
+    def test_ensure_weight_tying_errors_with_different_indices(self, model_weight_tied):
+        """Should raise error when ensure_weight_tying=True with different indices for embedding and lm_head"""
+        peft_config = LoraConfig(
+            target_modules="all-linear",
+            trainable_token_indices={"lm_head": [1, 2], "embed_tokens": [3, 4]},
+            ensure_weight_tying=True,
+        )
+
+        msg = "Cannot ensure weight tying when different token indices are specified"
+        with pytest.raises(ValueError, match=msg):
+            peft_model = get_peft_model(model_weight_tied, peft_config)
+
+    @pytest.mark.parametrize(
+        "trainable_token_indices, ensure_weight_tying",
+        [
+            ([1, 2], True),
+            ([1, 2], False),
+            ({"lm_head": [1, 2], "embed_tokens": [1, 2]}, True),
+            ({"lm_head": [1, 2], "embed_tokens": [1, 2]}, False),
+        ],
+    )
+    def test_ensure_weight_tying_applied_with_same_indices(
+        self, model_weight_tied, trainable_token_indices, ensure_weight_tying
+    ):
+        """Should apply weight tying when ensure_weight_tying=True with same indices"""
+        peft_config = LoraConfig(
+            target_modules="all-linear",
+            trainable_token_indices=trainable_token_indices,
+            ensure_weight_tying=ensure_weight_tying,
+        )
+        peft_model = get_peft_model(model_weight_tied, peft_config)
+
+        # Check that weight tying is properly applied
+        embed_adapter = peft_model.model.model.decoder.embed_tokens.token_adapter
+        lm_head_adapter = peft_model.model.lm_head.token_adapter
+
+        # They should share the same delta parameters (weight tying)
+        assert embed_adapter.trainable_tokens_delta is lm_head_adapter.trainable_tokens_delta
+        # They should have the same token indices
+        assert embed_adapter.token_indices["default"] == [1, 2]
+        assert lm_head_adapter.token_indices["default"] == [1, 2]
+
+    def test_weight_tying_bc_same_indices_applied(self, model_weight_tied):
+        """When indices are the same, weight tying should be applied even when ensure_weight_tying=False"""
+        peft_config = LoraConfig(
+            target_modules="all-linear",
+            trainable_token_indices={"lm_head": [1, 2], "embed_tokens": [1, 2]},
+            ensure_weight_tying=False,  # BC: still applies tying when indices are the same
+        )
+        peft_model = get_peft_model(model_weight_tied, peft_config)
+
+        # Even with ensure_weight_tying=False, BC behavior should still tie when indices are same
+        embed_adapter = peft_model.model.model.decoder.embed_tokens.token_adapter
+        lm_head_adapter = peft_model.model.lm_head.token_adapter
+
+        # They should share the same delta parameters (BC behavior)
+        assert embed_adapter.trainable_tokens_delta is lm_head_adapter.trainable_tokens_delta
+
+    def test_ensure_weight_tying_with_single_layer(self, model_weight_tied):
+        """ensure_weight_tying should work with single layer (list format)"""
+        peft_config = LoraConfig(
+            target_modules="all-linear",
+            trainable_token_indices=[1, 2, 3],
+            ensure_weight_tying=True,
+        )
+        peft_model = get_peft_model(model_weight_tied, peft_config)
+
+        # Should apply weight tying to tied layers automatically
+        embed_adapter = peft_model.model.model.decoder.embed_tokens.token_adapter
+        lm_head_adapter = peft_model.model.lm_head.token_adapter
+
+        # They should share the same delta parameters
+        assert embed_adapter.trainable_tokens_delta is lm_head_adapter.trainable_tokens_delta
+
+    def test_untied_model_list_format_no_ensure(self, model_weight_untied):
+        """Untied model with list format, ensure_weight_tying=False - trainable tokens on embeddings only"""
+        peft_config = LoraConfig(
+            target_modules="all-linear",
+            trainable_token_indices=[1, 2, 3],
+            ensure_weight_tying=False,
+        )
+        peft_model = get_peft_model(model_weight_untied, peft_config)
+
+        # Only embed_tokens should have token adapter
+        assert hasattr(peft_model.model.model.embed_tokens, "token_adapter")
+        assert not hasattr(peft_model.model.lm_head, "token_adapter")
+
+    def test_tied_model_list_format_no_ensure(self, model_weight_tied):
+        """Tied model with list format, ensure_weight_tying=False - tied trainable tokens"""
+        peft_config = LoraConfig(
+            target_modules="all-linear",
+            trainable_token_indices=[1, 2, 3],
+            ensure_weight_tying=False,
+        )
+        peft_model = get_peft_model(model_weight_tied, peft_config)
+
+        # Both should have token adapters and be tied
+        embed_adapter = peft_model.model.model.decoder.embed_tokens.token_adapter
+        lm_head_adapter = peft_model.model.lm_head.token_adapter
+
+        # They should share the same delta parameters (BC behavior)
+        assert embed_adapter.trainable_tokens_delta is lm_head_adapter.trainable_tokens_delta
+
+    @pytest.mark.parametrize(
+        "trainable_token_indices",
+        [
+            {"lm_head": [1, 2], "embed_tokens": [1, 2]},  # same indices
+            {"lm_head": [1, 2], "embed_tokens": [3, 4]},  # different indices
+        ],
+    )
+    def test_untied_model_dict_no_ensure(self, model_weight_untied, trainable_token_indices):
+        """Untied model with dict format, ensure_weight_tying=False - treat as separate"""
+        peft_config = LoraConfig(
+            target_modules="all-linear",
+            trainable_token_indices=trainable_token_indices,
+            ensure_weight_tying=False,
+        )
+        peft_model = get_peft_model(model_weight_untied, peft_config)
+
+        # Both should have token adapters but NOT tied (since model doesn't have tied weights)
+        embed_adapter = peft_model.model.model.embed_tokens.token_adapter
+        lm_head_adapter = peft_model.model.lm_head.token_adapter
+
+        assert embed_adapter is not None
+        assert lm_head_adapter is not None
+        # They should NOT share delta parameters (model doesn't have tied weights)
+        assert embed_adapter.trainable_tokens_delta is not lm_head_adapter.trainable_tokens_delta
+
+    @pytest.mark.skipif(
+        not is_transformers_ge_v5, reason="Test requires transformers v5+ dict format for _tied_weights_keys"
+    )
+    def test_composite_model_multiple_embed_tokens_specific_targeting(self):
+        """Test that users can specify full paths to disambiguate multiple embed_tokens layers.
+
+        This tests the scenario where a composite model has multiple sub-models, each with their own embed_tokens, and
+        users need to target them independently with different token indices.
+        """
+
+        # Create a composite model with two BART sub-models
+        class CompositeModel(torch.nn.Module):
+            def __init__(self):
+                super().__init__()
+                config1 = BartConfig(
+                    vocab_size=100,
+                    d_model=32,
+                    encoder_layers=1,
+                    decoder_layers=1,
+                    encoder_attention_heads=2,
+                    decoder_attention_heads=2,
+                    encoder_ffn_dim=64,
+                    decoder_ffn_dim=64,
+                )
+                self.m1 = BartModel(config1)
+
+                config2 = BartConfig(
+                    vocab_size=100,
+                    d_model=32,
+                    encoder_layers=1,
+                    decoder_layers=1,
+                    encoder_attention_heads=2,
+                    decoder_attention_heads=2,
+                    encoder_ffn_dim=64,
+                    decoder_ffn_dim=64,
+                )
+                config2.tie_word_embeddings = False  # m2 doesn't tie weights
+                self.m2 = BartModel(config2)
+
+                # Add a config attribute for PEFT
+                self.config = config1
+
+                # Use dict format to correctly represent independent tied weights within each sub-model
+                self._tied_weights_keys = {
+                    "m1.decoder.embed_tokens.weight": "m1.encoder.embed_tokens.weight",
+                    "m2.decoder.embed_tokens.weight": "m2.encoder.embed_tokens.weight",
+                }
+
+            def get_input_embeddings(self):
+                return self.m1.encoder.embed_tokens
+
+        model = CompositeModel()
+
+        # User specifies different token indices for each sub-model's embed_tokens
+        # This should NOT raise an error because they are distinct sub-models
+        # With ensure_weight_tying=True, m1's internal tying should still work
+        peft_config = LoraConfig(
+            target_modules="all-linear",
+            trainable_token_indices={
+                "m1.encoder.embed_tokens": [1, 2, 3],
+                "m2.encoder.embed_tokens": [4, 5, 6],
+            },
+            ensure_weight_tying=True,  # Verify that weight tying works correctly
+        )
+
+        # This should work without errors - the key is that it doesn't raise ValueError
+        # about conflicting indices because m1 and m2 are independent
+        peft_model = get_peft_model(model, peft_config)
+
+        # Verify that both layers got their adapters with correct indices
+        m1_encoder_adapter = peft_model.m1.encoder.embed_tokens.token_adapter
+        m2_adapter = peft_model.m2.encoder.embed_tokens.token_adapter
+
+        assert m1_encoder_adapter is not None
+        assert m2_adapter is not None
+
+        # They should have different token indices as specified
+        assert m1_encoder_adapter.token_indices["default"] == [1, 2, 3]
+        assert m2_adapter.token_indices["default"] == [4, 5, 6]
+
+        # They should NOT share the same delta parameters (they're independent sub-models)
+        assert m1_encoder_adapter.trainable_tokens_delta is not m2_adapter.trainable_tokens_delta
+
+        # m1's decoder should be tied to m1's encoder (internal weight tying within m1)
+        m1_decoder_adapter = peft_model.m1.decoder.embed_tokens.token_adapter
+        assert m1_decoder_adapter is not None
+        assert m1_encoder_adapter.trainable_tokens_delta is m1_decoder_adapter.trainable_tokens_delta
+
+        # m2's decoder should NOT have an adapter since it's not tied and we didn't target it
+        assert not hasattr(peft_model.m2.decoder.embed_tokens, "token_adapter")
+
+    def test_composite_model_short_name_matching(self):
+        """Test that short names like 'embed_tokens' still work but match the input embedding."""
+
+        class CompositeModel(torch.nn.Module):
+            def __init__(self):
+                super().__init__()
+                config = BartConfig(
+                    vocab_size=100,
+                    d_model=32,
+                    encoder_layers=1,
+                    decoder_layers=1,
+                    encoder_attention_heads=2,
+                    decoder_attention_heads=2,
+                    encoder_ffn_dim=64,
+                    decoder_ffn_dim=64,
+                )
+                self.m1 = BartModel(config)
+                self.config = config
+
+            def get_input_embeddings(self):
+                return self.m1.encoder.embed_tokens
+
+        model = CompositeModel()
+
+        # User specifies just "embed_tokens" - should match m1.encoder.embed_tokens via endswith
+        peft_config = LoraConfig(
+            target_modules="all-linear",
+            trainable_token_indices={"embed_tokens": [1, 2, 3]},
+            ensure_weight_tying=True,
+        )
+
+        peft_model = get_peft_model(model, peft_config)
+
+        # Should work and apply to the input embeddings
+        assert hasattr(peft_model.m1.encoder.embed_tokens, "token_adapter")
+        assert peft_model.m1.encoder.embed_tokens.token_adapter.token_indices["default"] == [1, 2, 3]
+
+    def test_targeting_both_embedding_and_tied_layer_explicitly(self, model_weight_tied):
+        """Test that explicitly targeting both embedding and tied layers works correctly.
+
+        When target_modules includes both "embed_tokens" and "lm_head" (which are tied in the model), both layers get
+        wrapped and weight tying is properly applied between them.
+        """
+        peft_config = TrainableTokensConfig(
+            target_modules=["model.decoder.embed_tokens", "lm_head"],  # Explicitly target both
+            token_indices=[1, 2, 3],
+        )
+        peft_model = get_peft_model(model_weight_tied, peft_config)
+
+        # Both should have been wrapped as TrainableTokensLayer
+        embed_layer = peft_model.model.model.decoder.embed_tokens
+        lm_head_layer = peft_model.model.lm_head
+
+        assert isinstance(embed_layer, TrainableTokensLayer)
+        assert isinstance(lm_head_layer, TrainableTokensLayer)
+
+        # They should share the same delta parameters (tied)
+        assert embed_layer.trainable_tokens_delta["default"] is lm_head_layer.trainable_tokens_delta["default"]
+
+        # Both should have the same token indices
+        assert embed_layer.token_indices["default"] == [1, 2, 3]
+        assert lm_head_layer.token_indices["default"] == [1, 2, 3]
+
+    def test_multiple_trainable_token_adapters_same_model(self, model_weight_tied):
+        """Test adding multiple trainable token adapters to the same model with tied layers.
+
+        This verifies that adding multiple adapters to the same tied layers (embed_tokens and lm_head) works correctly,
+        with each adapter maintaining its own token indices while preserving weight tying.
+        """
+        # Add first adapter with both embed_tokens and lm_head targeted
+        peft_config1 = TrainableTokensConfig(
+            target_modules=["model.decoder.embed_tokens", "lm_head"],
+            token_indices=[1, 2, 3],
+        )
+        peft_model = get_peft_model(model_weight_tied, peft_config1)
+
+        # Add second adapter to the same layers
+        peft_config2 = TrainableTokensConfig(
+            target_modules=["model.decoder.embed_tokens", "lm_head"],
+            token_indices=[4, 5, 6],
+        )
+        peft_model.add_adapter("adapter2", peft_config2)
+
+        # Get the wrapped layers
+        embed_layer = peft_model.model.model.decoder.embed_tokens
+        lm_head_layer = peft_model.model.lm_head
+
+        # Check first adapter
+        assert "default" in embed_layer.token_indices
+        assert "default" in lm_head_layer.token_indices
+        assert embed_layer.token_indices["default"] == [1, 2, 3]
+        assert lm_head_layer.token_indices["default"] == [1, 2, 3]
+
+        # First adapter should maintain tying
+        assert embed_layer.trainable_tokens_delta["default"] is lm_head_layer.trainable_tokens_delta["default"]
+
+        # Check second adapter
+        assert "adapter2" in embed_layer.token_indices
+        assert "adapter2" in lm_head_layer.token_indices
+        assert embed_layer.token_indices["adapter2"] == [4, 5, 6]
+        assert lm_head_layer.token_indices["adapter2"] == [4, 5, 6]
+
+        # Second adapter should also maintain tying
+        assert embed_layer.trainable_tokens_delta["adapter2"] is lm_head_layer.trainable_tokens_delta["adapter2"]
diff --git a/tests/test_tuners_utils.py b/tests/test_tuners_utils.py
new file mode 100644
index 0000000..4a68317
--- /dev/null
+++ b/tests/test_tuners_utils.py
@@ -0,0 +1,2299 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+import dataclasses
+import re
+from copy import deepcopy
+
+import diffusers
+import packaging.version
+import pytest
+import torch
+from diffusers import StableDiffusionPipeline
+from parameterized import parameterized
+from torch import nn
+from transformers import (
+    AutoModel,
+    AutoModelForCausalLM,
+    AutoModelForSeq2SeqLM,
+    AutoModelForSequenceClassification,
+    BitsAndBytesConfig,
+)
+from transformers.pytorch_utils import Conv1D
+
+from peft import (
+    AdaptionPromptConfig,
+    IA3Config,
+    LoHaConfig,
+    LoraConfig,
+    PeftModel,
+    PromptTuningConfig,
+    VeraConfig,
+    get_layer_status,
+    get_model_status,
+    get_peft_model,
+)
+from peft.tuners.lora.layer import LoraLayer
+from peft.tuners.tuners_utils import (
+    BaseTuner,
+    BaseTunerLayer,
+    _maybe_include_all_linear_layers,
+    check_target_module_exists,
+    inspect_matched_modules,
+)
+from peft.tuners.tuners_utils import (
+    _find_minimal_target_modules as find_minimal_target_modules,
+)
+from peft.utils import INCLUDE_LINEAR_LAYERS_SHORTHAND, ModulesToSaveWrapper, infer_device
+from peft.utils.constants import DUMMY_MODEL_CONFIG, MIN_TARGET_MODULES_FOR_OPTIMIZATION
+from peft.utils.quantization_utils import Bnb8bitBackend
+
+from .testing_utils import hub_online_once, require_bitsandbytes, require_non_cpu
+
+
+# TODO: remove once Diffusers 0.40 is released
+is_diffusers_ge_v040 = packaging.version.parse(diffusers.__version__) >= packaging.version.parse("0.40.0.dev0")
+
+# Implements tests for regex matching logic common for all BaseTuner subclasses, and
+# tests for correct behaviour with different config kwargs for BaseTuners (Ex: feedforward for IA3, etc) and
+# tests for utility function to include all linear layers
+
+REGEX_TEST_CASES = [
+    # tuple of
+    # 1. key
+    # 2. target_modules
+    # 3. layers_to_transform
+    # 4. layers_pattern
+    # 5. expected result
+    # some basic examples
+    ("", [], None, None, False),
+    ("", ["foo"], None, None, False),
+    ("foo", [], None, None, False),
+    ("foo", ["foo"], None, None, True),
+    ("foo", ["bar"], None, None, False),
+    ("foo", ["foo", "bar"], None, None, True),
+    # with regex
+    ("foo", "foo", None, None, True),
+    ("foo", ".*oo", None, None, True),
+    ("foo", "fo.*", None, None, True),
+    ("foo", ".*bar.*", None, None, False),
+    ("foobar", ".*oba.*", None, None, True),
+    # with layers_to_transform
+    ("foo.bar.1.baz", ["baz"], [1], ["bar"], True),
+    ("foo.bar.1.baz", ["baz"], [0], ["bar"], False),
+    ("foo.bar.1.baz", ["baz"], [2], ["bar"], False),
+    ("foo.bar.10.baz", ["baz"], [0], ["bar"], False),
+    ("foo.bar.10.baz", ["baz"], [1], ["bar"], False),
+    ("foo.bar.1.baz", ["baz"], [0, 1, 2], ["bar"], True),
+    ("foo.bar.1.baz", ["baz", "spam"], [1], ["bar"], True),
+    ("foo.bar.1.baz", ["baz", "spam"], [0, 1, 2], ["bar"], True),
+    # empty layers_pattern
+    ("foo.whatever.1.baz", ["baz"], [1], [], True),
+    ("foo.whatever.1.baz", ["baz"], [0], [], False),
+    ("foo.whatever.1.baz", ["baz"], [1], "", True),
+    ("foo.whatever.1.baz", ["baz"], [0], "", False),
+    ("foo.whatever.1.baz", ["baz"], [1], None, True),
+    ("foo.whatever.1.baz", ["baz"], [0], None, False),
+    # some realistic examples: transformers model
+    ("transformer.h.1.attn.attention.q_proj.foo", ["q_proj"], None, [], False),
+    ("transformer.h.1.attn.attention.q_proj", [], None, [], False),
+    ("transformer.h.1.attn.attention.q_proj", ["q_proj"], None, [], True),
+    ("transformer.h.1.attn.attention.q_proj", ["q_proj", "v_proj"], None, [], True),
+    ("transformer.h.1.attn.attention.resid_dropout", ["q_proj", "v_proj"], None, [], False),
+    ("transformer.h.1.attn.attention.q_proj", ["q_proj"], [1], ["h"], True),
+    ("transformer.h.1.attn.attention.q_proj", ["q_proj"], [0], ["h"], False),
+    ("transformer.h.1.attn.attention.q_proj", ["q_proj"], [2], ["h"], False),
+    ("transformer.h.1.attn.attention.q_proj", ["q_proj"], [0, 1, 2], ["h"], True),
+    ("transformer.h.1.attn.attention.q_proj", ["q_proj", "v_proj"], [0, 1, 2], ["h"], True),
+    ("foo.bar.q_proj", ["q_proj"], None, [], True),
+    ("foo.bar.1.baz", ["baz"], [1], ["foo"], False),
+    # other corner cases. For ex, below is a case where layers_pattern
+    # is one of the target nn.modules
+    ("foo.bar.1.baz", ["baz"], [1], ["baz"], False),
+    # here, layers_pattern is 'bar', but only keys that contain '.bar' are valid.
+    ("bar.1.baz", ["baz"], [1], ["bar"], False),
+    ("foo.bar.001.baz", ["baz"], [1], ["bar"], True),
+    ("foo.bar.1.spam.2.baz", ["baz"], [1], ["bar"], True),
+    ("foo.bar.2.spam.1.baz", ["baz"], [1], ["bar"], False),
+    # some realistic examples: module using nn.Sequential
+    # for the below test case, key should contain '.blocks' to be valid, because of how layers_pattern is matched
+    ("blocks.1.weight", ["weight"], [1], ["blocks"], False),
+    ("blocks.1.bias", ["weight"], [1], ["blocks"], False),
+    ("mlp.blocks.1.weight", ["weight"], [1], ["blocks"], True),
+    ("mlp.blocks.1.bias", ["weight"], [1], ["blocks"], False),
+]
+
+MAYBE_INCLUDE_ALL_LINEAR_LAYERS_TEST_CASES = [
+    # model_name, model_type, initial_target_modules, expected_target_modules
+    # test for a causal Llama model
+    (
+        "peft-internal-testing/tiny-random-LlamaForCausalLM",
+        "causal",
+        INCLUDE_LINEAR_LAYERS_SHORTHAND,
+        ["k_proj", "v_proj", "q_proj", "o_proj", "down_proj", "up_proj", "gate_proj"],
+    ),
+    # test for a Llama model without the LM head
+    (
+        "peft-internal-testing/tiny-random-LlamaForCausalLM",
+        "base",
+        INCLUDE_LINEAR_LAYERS_SHORTHAND,
+        ["k_proj", "v_proj", "q_proj", "o_proj", "down_proj", "up_proj", "gate_proj"],
+    ),
+    # test for gpt2 with Conv1D layers
+    ("hf-internal-testing/tiny-random-gpt2", "causal", INCLUDE_LINEAR_LAYERS_SHORTHAND, ["c_attn", "c_proj", "c_fc"]),
+    # test for T5 model
+    (
+        "peft-internal-testing/tiny-random-t5",
+        "seq2seq",
+        INCLUDE_LINEAR_LAYERS_SHORTHAND,
+        ["k", "q", "v", "o", "wi", "wo"],
+    ),
+    # test for GPTNeoX. output module list should exclude classification head - which is named as "embed_out" instead of
+    # the usual "lm_head" for GPTNeoX
+    (
+        "peft-internal-testing/tiny-random-GPTNeoXForCausalLM",
+        "causal",
+        INCLUDE_LINEAR_LAYERS_SHORTHAND,
+        ["query_key_value", "dense", "dense_h_to_4h", "dense_4h_to_h"],
+    ),
+]
+
+# tests for a few args that should remain unchanged
+MAYBE_INCLUDE_ALL_LINEAR_LAYERS_TEST_INTERNALS = [
+    # initial_target_modules, expected_target_modules
+    (["k_proj"], ["k_proj"]),
+    # test with target_modules as None
+    (None, None),
+    # test with target_modules as a regex expression
+    (".*(q_proj|v_proj)$", ".*(q_proj|v_proj)$"),
+]
+
+BNB_QUANTIZATIONS = [("4bit",), ("8bit",)]
+BNB_TEST_CASES = [(x + y) for x in MAYBE_INCLUDE_ALL_LINEAR_LAYERS_TEST_CASES for y in BNB_QUANTIZATIONS]
+
+
+class TestPeftCustomKwargs:
+    r"""
+    Test if the PeftModel is instantiated with correct behaviour for custom kwargs. This includes:
+    - test if regex matching works correctly
+    - test if adapters handle custom kwargs the right way e.g. IA3 for `feedforward_modules`
+
+    """
+
+    transformers_class_map = {"causal": AutoModelForCausalLM, "seq2seq": AutoModelForSeq2SeqLM, "base": AutoModel}
+
+    @parameterized.expand(REGEX_TEST_CASES)
+    def test_regex_matching_valid(self, key, target_modules, layers_to_transform, layers_pattern, expected_result):
+        # We use a LoRA Config for testing, but the regex matching function is common for all BaseTuner subclasses.
+        # example model_id for config initialization. key is matched only against the target_modules given, so this can be any model
+        model_id = "peft-internal-testing/tiny-OPTForCausalLM-lora"
+        config = LoraConfig(
+            base_model_name_or_path=model_id,
+            target_modules=target_modules,
+            layers_pattern=layers_pattern,
+            layers_to_transform=layers_to_transform,
+        )
+        actual_result = bool(check_target_module_exists(config, key))
+        assert actual_result == expected_result
+
+    def test_module_matching_lora(self):
+        # peft models that have a module matching method to inspect the matching modules to allow
+        # users to easily debug their configuration. Here we only test a single case, not all possible combinations of
+        # configs that could exist. This is okay as the method calls `check_target_module_exists` internally, which
+        # has been extensively tested above.
+        model_id = "peft-internal-testing/tiny-random-BloomForCausalLM"
+        with hub_online_once(model_id):
+            model = AutoModel.from_pretrained(model_id)
+        # by default, this model matches query_key_value
+        config = LoraConfig()
+        peft_model = get_peft_model(model, config)
+
+        output = inspect_matched_modules(peft_model)  # inspects default adapter for peft_model
+        matched = output["matched"]
+        expected = [
+            "h.0.self_attention.query_key_value",
+            "h.1.self_attention.query_key_value",
+            "h.2.self_attention.query_key_value",
+            "h.3.self_attention.query_key_value",
+            "h.4.self_attention.query_key_value",
+        ]
+        assert matched == expected  # module lists should match exactly
+
+        # no overlap with matched modules
+        unmatched = output["unmatched"]
+        for key in expected:
+            assert key not in unmatched
+
+    def test_feedforward_matching_ia3(self):
+        model_id = "peft-internal-testing/tiny-random-T5ForConditionalGeneration"
+        with hub_online_once(model_id):
+            model = AutoModelForSeq2SeqLM.from_pretrained(model_id)
+        # simple example for just one t5 block for testing
+        config_kwargs = {
+            "target_modules": ".*encoder.*block.0.*(SelfAttention|EncDecAttention|DenseReluDense).(k|q|v|wo|wi)$",
+            "feedforward_modules": ["wo", "wi"],
+        }
+        config = IA3Config(base_model_name_or_path=model_id, **config_kwargs)
+        peft_model = get_peft_model(model, config)
+        output = inspect_matched_modules(peft_model)  # inspects default adapter for peft_model
+        matched = output["matched"]
+        expected = [
+            "encoder.block.0.layer.0.SelfAttention.q",
+            "encoder.block.0.layer.0.SelfAttention.k",
+            "encoder.block.0.layer.0.SelfAttention.v",
+            "encoder.block.0.layer.1.DenseReluDense.wi",
+            "encoder.block.0.layer.1.DenseReluDense.wo",
+        ]
+        expected_feedforward = [
+            "encoder.block.0.layer.1.DenseReluDense.wi",
+            "encoder.block.0.layer.1.DenseReluDense.wo",
+        ]
+        assert matched == expected  # not required since we do similar checks above, but just to be sure
+        module_dict = dict(model.named_modules())
+        for key in matched:
+            module = module_dict[key]
+            if key in expected_feedforward:
+                assert module.is_feedforward
+            else:  # other IA3 modules should not be marked as feedforward
+                assert not module.is_feedforward
+
+    @parameterized.expand(MAYBE_INCLUDE_ALL_LINEAR_LAYERS_TEST_CASES)
+    def test_maybe_include_all_linear_layers_lora(
+        self, model_id, model_type, initial_target_modules, expected_target_modules
+    ):
+        with hub_online_once(model_id):
+            model = self.transformers_class_map[model_type].from_pretrained(model_id)
+        config_cls = LoraConfig
+        self._check_match_with_expected_target_modules(
+            model_id, model, config_cls, initial_target_modules, expected_target_modules
+        )
+
+    @parameterized.expand(BNB_TEST_CASES)
+    @require_non_cpu
+    @require_bitsandbytes
+    def test_maybe_include_all_linear_layers_lora_bnb(
+        self, model_id, model_type, initial_target_modules, expected_target_modules, quantization
+    ):
+        if quantization == "4bit":
+            config_kwargs = {"quantization_config": BitsAndBytesConfig(load_in_4bit=True)}
+        elif quantization == "8bit":
+            config_kwargs = {"quantization_config": BitsAndBytesConfig(load_in_8bit=True)}
+
+        with hub_online_once(model_id):
+            model = self.transformers_class_map[model_type].from_pretrained(
+                model_id, device_map="auto", **config_kwargs
+            )
+        config_cls = LoraConfig
+        self._check_match_with_expected_target_modules(
+            model_id, model, config_cls, initial_target_modules, expected_target_modules
+        )
+
+    def _check_match_with_expected_target_modules(
+        self, model_id, model, config_cls, initial_target_modules, expected_target_modules
+    ):
+        """
+        Helper function for the test for `_maybe_include_all_linear_layers`
+        """
+        actual_config = config_cls(base_model_name_or_path=model_id, target_modules=initial_target_modules)
+        expected_config = config_cls(base_model_name_or_path=model_id, target_modules=expected_target_modules)
+        model_copy = deepcopy(model)
+        actual_model = get_peft_model(model, peft_config=actual_config)
+        expected_model = get_peft_model(model_copy, peft_config=expected_config)
+        expected_model_module_dict = dict(expected_model.named_modules())
+        # compare the two models and assert that all layers are of the same type
+        for name, actual_module in actual_model.named_modules():
+            expected_module = expected_model_module_dict[name]
+            assert type(actual_module) is type(expected_module)
+
+    def test_maybe_include_all_linear_layers_ia3_loha(self):
+        model_id, initial_target_modules, expected_target_modules = (
+            "peft-internal-testing/tiny-random-LlamaForCausalLM",
+            INCLUDE_LINEAR_LAYERS_SHORTHAND,
+            ["k_proj", "v_proj", "q_proj", "o_proj", "down_proj", "up_proj", "gate_proj"],
+        )
+        with hub_online_once(model_id):
+            model_ia3 = AutoModelForCausalLM.from_pretrained(model_id)
+        model_loha = deepcopy(model_ia3)
+        config_classes = [IA3Config, LoHaConfig]
+        models = [model_ia3, model_loha]
+        for config_cls, model in zip(config_classes, models):
+            self._check_match_with_expected_target_modules(
+                model_id, model, config_cls, initial_target_modules, expected_target_modules
+            )
+
+    @parameterized.expand(MAYBE_INCLUDE_ALL_LINEAR_LAYERS_TEST_INTERNALS)
+    def test_maybe_include_all_linear_layers_internals(self, initial_target_modules, expected_target_modules):
+        model_id = "peft-internal-testing/tiny-random-LlamaForCausalLM"
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+        config = LoraConfig(base_model_name_or_path=model_id, target_modules=initial_target_modules)
+        new_config = _maybe_include_all_linear_layers(config, model)
+        if isinstance(expected_target_modules, list):
+            # assert that expected and actual target_modules have the same items
+            assert set(new_config.target_modules) == set(expected_target_modules)
+        else:
+            assert new_config.target_modules == expected_target_modules
+
+    def test_maybe_include_all_linear_layers_diffusion(self):
+        # TODO: remove once Diffusers 0.40 is released
+        if not is_diffusers_ge_v040:
+            pytest.skip("This test fails with Diffusers < 0.40 due to a change in huggingface_hub")
+
+        model_id = "hf-internal-testing/tiny-sd-pipe"
+        with hub_online_once(model_id):
+            model = StableDiffusionPipeline.from_pretrained(model_id)
+        config = LoraConfig(base_model_name_or_path=model_id, target_modules="all-linear")
+
+        # all linear layers should be converted
+        num_linear = sum(isinstance(module, (nn.Linear, Conv1D)) for module in model.unet.modules())
+        model.unet = get_peft_model(model.unet, config)
+        num_lora = sum(isinstance(module, LoraLayer) for module in model.unet.modules())
+        assert num_lora == num_linear
+
+    def test_maybe_include_all_linear_does_not_target_classifier_head(self):
+        # See issue 2027
+        # Ensure that if a SEQ_CLS model is being used with target_modules="all-linear", the classification head is not
+        # targeted by the adapter layer.
+        model_id = "peft-internal-testing/tiny-random-LlamaForCausalLM"
+        with hub_online_once(model_id):
+            model = AutoModelForSequenceClassification.from_pretrained(model_id, num_labels=10)
+        # sanity check
+        assert isinstance(model.score, nn.Linear)
+
+        num_linear = sum(isinstance(module, (nn.Linear, Conv1D)) for module in model.modules())
+
+        config = LoraConfig(task_type="SEQ_CLS", target_modules="all-linear")
+        model = get_peft_model(model, config)
+        assert isinstance(model.base_model.score, ModulesToSaveWrapper)
+
+        # the bug was that these were lora.Linear instances
+        assert isinstance(model.base_model.score.original_module, nn.Linear)
+        assert isinstance(model.base_model.score.modules_to_save["default"], nn.Linear)
+
+        # ensure that all but one linear layer was targeted by LoRA
+        num_lora = sum(isinstance(module, LoraLayer) for module in model.modules())
+        assert num_lora == num_linear - 1
+
+    @parameterized.expand(MAYBE_INCLUDE_ALL_LINEAR_LAYERS_TEST_CASES)
+    def test_all_linear_nested_targets_correct_layers(
+        self, model_id, model_type, initial_target_modules, expected_target_modules
+    ):
+        # See 2390
+        # Ensure that if adapter layers are already applied, we don't get nested adapter layers (e.g. LoRA targeting the
+        # lora_A, lora_B layers)
+        with hub_online_once(model_id):
+            model = self.transformers_class_map[model_type].from_pretrained(model_id)
+        config_cls = LoraConfig
+        self._check_match_with_expected_target_modules(
+            model_id, model, config_cls, initial_target_modules, expected_target_modules
+        )
+        # re-use the same model, i.e. the adapter is already applied
+        self._check_match_with_expected_target_modules(
+            model_id, model, config_cls, initial_target_modules, expected_target_modules
+        )
+
+    def test_add_second_adapter_with_all_linear_works(self):
+        # See 2390 Similar test to test_all_linear_nested_targets_correct_layers above, but using add_adapter instead of
+        # calling get_peft_model in an already adapted model
+        model_id = "peft-internal-testing/tiny-random-LlamaForCausalLM"
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+
+        # important: don't reuse the first config, since config.target_modules will be overwritten, which would make the
+        # test pass trivially.
+        config0 = LoraConfig(target_modules=INCLUDE_LINEAR_LAYERS_SHORTHAND)
+        config1 = LoraConfig(target_modules=INCLUDE_LINEAR_LAYERS_SHORTHAND)
+
+        model = get_peft_model(model, config0)
+        model.add_adapter(adapter_name="other", peft_config=config1)
+
+        # both configs should result in the same target modules being chosen (remember that config.target_modules will
+        # be replaced by the actual set of target_modules)
+        assert config0.target_modules == config1.target_modules
+
+        for layer in model.base_model.model.model.layers:
+            projs = (
+                layer.self_attn.q_proj,
+                layer.self_attn.v_proj,
+                layer.self_attn.k_proj,
+                layer.mlp.gate_proj,
+                layer.mlp.up_proj,
+                layer.mlp.down_proj,
+            )
+            for proj in projs:
+                # the targeted layer itself, which in the base model was the nn.Linear layer, is now a LoraLayer
+                assert isinstance(proj, LoraLayer)
+                # all children of that layer are still normal nn.Linear layers
+                assert isinstance(proj.base_layer, nn.Linear)
+                assert isinstance(proj.lora_A["default"], nn.Linear)
+                assert isinstance(proj.lora_B["default"], nn.Linear)
+                assert isinstance(proj.lora_A["other"], nn.Linear)
+                assert isinstance(proj.lora_B["other"], nn.Linear)
+
+
+class MLP(nn.Module):
+    def __init__(self, bias=True):
+        super().__init__()
+        self.lin0 = nn.Linear(10, 20, bias=bias)
+        self.relu = nn.ReLU()
+        self.drop = nn.Dropout(0.5)
+        self.lin1 = nn.Linear(20, 2, bias=bias)
+        self.sm = nn.LogSoftmax(dim=-1)
+
+
+class TestTargetedModuleNames:
+    """Check that the attribute targeted_module_names is correctly set.
+
+    This checks LoRA and IA³, but this should be sufficient, testing all other tuners is not necessary.
+    """
+
+    def test_one_targeted_module_regex(self):
+        model = MLP()
+        model = get_peft_model(model, LoraConfig(target_modules="lin0"))
+        assert model.targeted_module_names == ["lin0"]
+
+    def test_two_targeted_module_regex(self):
+        model = MLP()
+        model = get_peft_model(model, LoraConfig(target_modules="lin.*"))
+        assert model.targeted_module_names == ["lin0", "lin1"]
+
+    def test_one_targeted_module_list(self):
+        model = MLP()
+        model = get_peft_model(model, LoraConfig(target_modules=["lin0"]))
+        assert model.targeted_module_names == ["lin0"]
+
+    def test_two_targeted_module_list(self):
+        model = MLP()
+        model = get_peft_model(model, LoraConfig(target_modules=["lin0", "lin1"]))
+        assert model.targeted_module_names == ["lin0", "lin1"]
+
+    def test_ia3_targeted_module_regex(self):
+        model = MLP()
+        model = get_peft_model(model, IA3Config(target_modules=".*lin.*", feedforward_modules=".*lin.*"))
+        assert model.targeted_module_names == ["lin0", "lin1"]
+
+    def test_ia3_targeted_module_list(self):
+        model = MLP()
+        model = get_peft_model(model, IA3Config(target_modules=["lin0", "lin1"], feedforward_modules=["lin0", "lin1"]))
+        assert model.targeted_module_names == ["lin0", "lin1"]
+
+    def test_realistic_example(self):
+        model_id = "peft-internal-testing/tiny-random-BloomForCausalLM"
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+        config = LoraConfig(task_type="CAUSAL_LM")
+        model = get_peft_model(model, config)
+        expected = [
+            f"transformer.h.{i}.self_attention.query_key_value" for i in range(len(model.base_model.transformer.h))
+        ]
+        assert model.targeted_module_names == expected
+
+    @pytest.mark.parametrize("layers_pattern", [None, "layers", ["h", "layers"]])
+    def test_layers_to_transform_filters_by_layer_not_expert_index(self, layers_pattern):
+        # Test fix to issue #3016
+        # The layer-index regex used a greedy ".*" prefix, so for MoE paths like
+        # "model.layers.1.mlp.experts.0.up_proj" it captured the expert index instead of the layer
+        # index, making layers_to_transform target the wrong modules.
+        class ToyMoEBlock(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.self_attn = nn.Module()
+                self.self_attn.q_proj = nn.Linear(4, 4, bias=False)
+
+                self.mlp = nn.Module()
+                self.mlp.experts = nn.ModuleList([nn.Module() for _ in range(2)])
+                for e in range(2):
+                    self.mlp.experts[e].up_proj = nn.Linear(4, 4, bias=False)
+
+        class ToyMoEModel(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.model = nn.Module()
+                self.model.layers = nn.ModuleList([ToyMoEBlock() for _ in range(4)])
+
+        config = LoraConfig(
+            target_modules=["q_proj", "up_proj"],
+            layers_pattern=layers_pattern,
+            layers_to_transform=[1],
+            r=2,
+            lora_alpha=4,
+        )
+        model = get_peft_model(ToyMoEModel(), config)
+
+        # only layer 1's modules should be targeted, both experts included.
+        # Under the bug, layers.1.experts.0 was misread as layer 0 and dropped, and a
+        # layers.2.experts.1 module could be misread as layer 1 and wrongly included.
+        expected = {
+            "model.layers.1.self_attn.q_proj",
+            "model.layers.1.mlp.experts.0.up_proj",
+            "model.layers.1.mlp.experts.1.up_proj",
+        }
+        assert set(model.targeted_module_names) == expected
+
+
+class TestTargetedParameterNames:
+    """Check that the attribute targeted_parameter_names (via target_parameters) is correctly set.
+
+    This is only implemented for LoRA. Regex matching is currently not implemented.
+    """
+
+    def test_one_targeted_parameters_list(self):
+        model = MLP()
+        model = get_peft_model(model, LoraConfig(target_parameters=["lin0.weight"]))
+        assert model.targeted_parameter_names == ["lin0.weight"]
+
+    def test_two_targeted_parameters_list(self):
+        model = MLP()
+        model = get_peft_model(model, LoraConfig(target_parameters=["lin0.weight", "lin1.weight"]))
+        assert model.targeted_parameter_names == ["lin0.weight", "lin1.weight"]
+
+    def test_realistic_example(self):
+        model_id = "trl-internal-testing/tiny-random-LlamaForCausalLM"
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+        config = LoraConfig(target_modules=[], task_type="CAUSAL_LM", target_parameters=["v_proj.weight"])
+        model = get_peft_model(model, config)
+        expected = [
+            f"model.layers.{i}.self_attn.v_proj.weight" for i in range(len(model.base_model.model.model.layers))
+        ]
+        assert model.targeted_parameter_names == expected
+
+
+class TestExcludedModuleNames:
+    """Check that the attribute exclude_module is correctly set.
+
+    This checks LoRA and IA³, but this should be sufficient, testing all other tuners is not necessary.
+    """
+
+    def test_two_excluded_module_regex(self):
+        model = MLP()
+        model = get_peft_model(model, LoraConfig(target_modules=("lin.*"), exclude_modules="lin0"))
+        assert model.targeted_module_names == ["lin1"]
+
+    def test_two_excluded_module_list(self):
+        model = MLP()
+        model = get_peft_model(model, LoraConfig(target_modules=["lin0", "lin1"], exclude_modules="lin0"))
+        assert model.targeted_module_names == ["lin1"]
+
+    def test_multiple_excluded_modules_list(self):
+        model = MLP()
+        model = get_peft_model(model, LoraConfig(target_modules=["lin0", "lin1"], exclude_modules=["lin0"]))
+        assert model.targeted_module_names == ["lin1"]
+
+    def test_ia3_two_excluded_module_regex(self):
+        model = MLP()
+        model = get_peft_model(
+            model, IA3Config(target_modules=".*lin.*", feedforward_modules=".*lin.*", exclude_modules="lin0")
+        )
+        assert model.targeted_module_names == ["lin1"]
+
+    def test_ia3_multiple_excluded_modules_list(self):
+        model = MLP()
+        model = get_peft_model(
+            model, IA3Config(target_modules=["lin0", "lin1"], feedforward_modules=".*lin.*", exclude_modules=["lin1"])
+        )
+        assert model.targeted_module_names == ["lin0"]
+
+    def test_all_modules_excluded(self):
+        model = MLP()
+        with pytest.raises(ValueError, match="All modules were excluded"):
+            get_peft_model(
+                model,
+                LoraConfig(
+                    target_modules=["lin0", "lin1", "relu", "drop", "sm"],
+                    exclude_modules=["lin0", "lin1", "relu", "drop", "sm"],
+                ),
+            )
+
+    def test_no_modules_matched(self):
+        model = MLP()
+        with pytest.raises(ValueError, match="Target modules .* not found in the base model"):
+            get_peft_model(model, LoraConfig(target_modules=["non_existent_module"]))
+
+    def test_some_modules_excluded_some_unmatched(self):
+        model = MLP()
+        with pytest.raises(ValueError, match="No modules were targeted for adaptation"):
+            get_peft_model(model, LoraConfig(target_modules=["lin0", "non_existent_module"], exclude_modules=["lin0"]))
+
+    def test_exclude_modules_not_used(self):
+        model = MLP()
+        with pytest.warns(UserWarning, match="You have passed exclude_modules=.* but no modules were excluded"):
+            get_peft_model(model, LoraConfig(target_modules=["lin1"], exclude_modules=["non_existent_module"]))
+
+    def test_realistic_example(self):
+        model_id = "peft-internal-testing/tiny-random-BloomForCausalLM"
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+        config = LoraConfig(task_type="CAUSAL_LM", exclude_modules="transformer.h.2.self_attention.query_key_value")
+        model = get_peft_model(model, config)
+        expected = [
+            f"transformer.h.{i}.self_attention.query_key_value"
+            for i in range(len(model.base_model.transformer.h))
+            if i != 2
+        ]
+        assert model.targeted_module_names == expected
+
+
+class TestModelAndLayerStatus:
+    """Check the methods `get_layer_status` and `get_model_status`.`
+
+    Note that we only test LoRA here but the same logic should work for other tuner types (if they support the
+    corresponding features like merging).
+
+    """
+
+    torch_device = infer_device()
+
+    @pytest.fixture
+    def small_base_model_cls(self):
+        class SmallModel(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.lin0 = nn.Linear(10, 10)
+                self.lin1 = nn.Linear(10, 10)
+
+        return SmallModel
+
+    @pytest.fixture
+    def small_base_emb_model_cls(self):
+        class SmallEmbModel(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.lin0 = nn.Linear(10, 10)
+                self.emb = nn.Embedding(10, 10)
+
+        return SmallEmbModel
+
+    @pytest.fixture
+    def small_model(self, small_base_model_cls):
+        config = LoraConfig(target_modules="lin0")
+        return get_peft_model(small_base_model_cls(), config)
+
+    @pytest.fixture
+    def large_model(self):
+        class LargeModel(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.lin0 = nn.Linear(10, 10)
+                self.conv0 = nn.Conv2d(3, 10, 3)
+                self.emb0 = nn.Embedding(10, 10)
+                self.lin1 = nn.Linear(10, 10)
+                self.conv1 = nn.Conv2d(3, 10, 3)
+                self.emb1 = nn.Embedding(10, 10)
+
+        config0 = LoraConfig(target_modules=["lin0", "conv1", "emb0"])
+        config1 = LoraConfig(target_modules=["lin0", "lin1"], r=16)
+        model = get_peft_model(LargeModel(), config0)
+        model.add_adapter("other", config1)
+        return model
+
+    ################
+    # layer status #
+    ################
+
+    def test_layer_names_small(self, small_model):
+        layer_status = small_model.get_layer_status()
+        expected = ["model.lin0"]
+        assert [status.name for status in layer_status] == expected
+
+    def test_layer_names_large(self, large_model):
+        layer_status = large_model.get_layer_status()
+        result = sorted([status.name for status in layer_status])
+        expected = ["model.conv1", "model.emb0", "model.lin0", "model.lin1"]
+        assert result == expected
+
+    def test_module_type_small(self, small_model):
+        layer_status = small_model.get_layer_status()
+        assert [status.module_type for status in layer_status] == ["lora.Linear"]
+
+    def test_module_type_large(self, large_model):
+        layer_status = large_model.get_layer_status()
+        result = sorted([status.module_type for status in layer_status])
+        expected = ["lora.Conv2d", "lora.Embedding", "lora.Linear", "lora.Linear"]
+        assert result == expected
+
+    def test_enabled_small(self, small_model):
+        layer_status = small_model.get_layer_status()
+        assert [status.enabled for status in layer_status] == [True]
+
+    def test_enabled_large(self, large_model):
+        layer_status = large_model.get_layer_status()
+        result = [status.enabled for status in layer_status]
+        expected = [True, True, True, True]
+        assert result == expected
+
+    def test_enabled_irregular(self, large_model):
+        # this is an invalid state, but we should still test it
+        # disable a single layer
+        for module in large_model.modules():
+            if isinstance(module, BaseTunerLayer):
+                module.enable_adapters(False)
+                break
+
+        layer_status = large_model.get_layer_status()
+        result = [status.enabled for status in layer_status]
+        expected = [False, True, True, True]
+        assert result == expected
+
+    def test_active_adapters_small(self, small_model):
+        layer_status = small_model.get_layer_status()
+        assert [status.active_adapters for status in layer_status] == [["default"]]
+
+    def test_active_adapters_large(self, large_model):
+        layer_status = large_model.get_layer_status()
+        result = [status.active_adapters for status in layer_status]
+        # note: as currently implemented, the active adapter can be an adapter that does not exist on this specific
+        # layer, for instance, layer 3 (i.e. index 2) only has the "other" adapter but "default" is still shown as the
+        # active adapter
+        expected = [["default"], ["default"], ["default"], ["default"]]
+        assert result == expected
+
+        # switch to "other"
+        large_model.set_adapter("other")
+        layer_status = large_model.get_layer_status()
+        result = [status.active_adapters for status in layer_status]
+        expected = [["other"], ["other"], ["other"], ["other"]]
+
+    def test_merge_adapters_small(self, small_model):
+        layer_status = small_model.get_layer_status()
+        assert [status.merged_adapters for status in layer_status] == [[]]
+        assert [status.available_adapters for status in layer_status] == [["default"]]
+
+        # now merge "default"
+        small_model.merge_adapter(["default"])
+        layer_status = small_model.get_layer_status()
+        assert [status.merged_adapters for status in layer_status] == [["default"]]
+        assert [status.available_adapters for status in layer_status] == [["default"]]
+
+    def test_merge_adapters_large(self, large_model):
+        layer_status = large_model.get_layer_status()
+        result = [status.merged_adapters for status in layer_status]
+        assert result == [[], [], [], []]
+
+        # now merge "default"
+        large_model.merge_adapter(["default"])
+        layer_status = large_model.get_layer_status()
+        result = [status.merged_adapters for status in layer_status]
+        # default is on layer 0, 1, and 3
+        assert result == [["default"], ["default"], [], ["default"]]
+
+        # now merge "other"
+        large_model.unmerge_adapter()
+        large_model.merge_adapter(["other"])
+        layer_status = large_model.get_layer_status()
+        result = [status.merged_adapters for status in layer_status]
+        # other is on layer 0 and 2
+        assert result == [["other"], [], ["other"], []]
+
+        # now merge both
+        large_model.merge_adapter(["default", "other"])
+        layer_status = large_model.get_layer_status()
+        result = [status.merged_adapters for status in layer_status]
+        # default is on layer 0, 1, and 3, other is on layer 0 and 2
+        assert result == [["other", "default"], ["default"], ["other"], ["default"]]
+
+    def test_requires_grad_small(self, small_model):
+        layer_status = small_model.get_layer_status()
+        assert [status.requires_grad for status in layer_status] == [{"default": True}]
+
+    def test_requires_grad_large(self, large_model):
+        layer_status = large_model.get_layer_status()
+        result = [status.requires_grad for status in layer_status]
+        # default is on layer 0, 1, and 3, other is on layer 0 and 2
+        expected = [{"default": True, "other": False}, {"default": True}, {"other": False}, {"default": True}]
+        assert result == expected
+
+        # now activate "other"
+        large_model.set_adapter("other")
+        layer_status = large_model.get_layer_status()
+        result = [status.requires_grad for status in layer_status]
+        expected = [{"default": False, "other": True}, {"default": False}, {"other": True}, {"default": False}]
+        assert result == expected
+
+        # change requires grad, is now inconsistent with active/inactive adapter
+        large_model.set_requires_grad("default", requires_grad=True)
+        large_model.set_requires_grad("other", requires_grad=False)
+        layer_status = large_model.get_layer_status()
+        result = [status.requires_grad for status in layer_status]
+        expected = [{"default": True, "other": False}, {"default": True}, {"other": False}, {"default": True}]
+        assert result == expected
+
+    def test_requires_grad_irregular(self, large_model):
+        # inject an embedding layer with requires_grad=False
+        # this is an invalid state, but we should still test it
+        lora_embedding_A = nn.Parameter(torch.zeros(10, 10))
+        lora_embedding_B = nn.Parameter(torch.zeros(10, 10))
+        lora_embedding_A.requires_grad = False
+        lora_embedding_B.requires_grad = False
+        large_model.base_model.model.lin0.lora_embedding_A["default"] = lora_embedding_A
+        large_model.base_model.model.lin0.lora_embedding_B["default"] = lora_embedding_B
+
+        layer_status = large_model.get_layer_status()
+        result = [status.requires_grad for status in layer_status]
+        expected = [{"default": "irregular", "other": False}, {"default": True}, {"other": False}, {"default": True}]
+        assert result == expected
+
+    def test_available_adapters_small(self, small_model):
+        layer_status = small_model.get_layer_status()
+        result = [status.available_adapters for status in layer_status]
+        expected = [["default"]]
+        assert result == expected
+
+    def test_available_adapters_large(self, large_model):
+        layer_status = large_model.get_layer_status()
+        result = [status.available_adapters for status in layer_status]
+        expected = [["default", "other"], ["default"], ["other"], ["default"]]
+        assert result == expected
+
+    def test_devices_all_cpu_small(self, small_model):
+        layer_status = small_model.get_layer_status()
+        result = [status.devices for status in layer_status]
+        expected = [{"default": ["cpu"]}]
+        assert result == expected
+
+    def test_devices_all_cpu_large(self, large_model):
+        layer_status = large_model.get_layer_status()
+        result = [status.devices for status in layer_status]
+        expected = [
+            {"default": ["cpu"], "other": ["cpu"]},
+            {"default": ["cpu"]},
+            {"other": ["cpu"]},
+            {"default": ["cpu"]},
+        ]
+        assert result == expected
+
+    def test_with_modules_to_save(self, small_base_model_cls):
+        # check that modules_to_save are correctly reported in layer status
+        model = small_base_model_cls()
+        config = LoraConfig(target_modules=["lin0"], modules_to_save=["lin1"])
+        model = get_peft_model(model, config)
+        layer_status = model.get_layer_status()
+
+        assert len(layer_status) == 2
+        status = layer_status[1]  # for modules_to_save
+
+        assert status.name == "model.lin1"
+        assert status.module_type == "ModulesToSaveWrapper"
+        assert status.enabled is True
+        assert status.active_adapters == ["default"]
+        assert status.merged_adapters == []
+        assert status.available_adapters == ["default"]
+        assert status.requires_grad == {"default": True}
+        assert status.devices == {"default": ["cpu"]}
+
+    def test_with_trainable_tokens(self, small_base_emb_model_cls):
+        # check that trainable_token_indices are correctly reported in layer status
+        model = small_base_emb_model_cls()
+        config = LoraConfig(target_modules=["lin0"], trainable_token_indices={"emb": [0, 1, 2]})
+        model = get_peft_model(model, config)
+        layer_status = model.get_layer_status()
+
+        assert len(layer_status) == 2
+        status = layer_status[1]  # for trainable tokens
+
+        assert status.name == "model.emb.token_adapter"
+        assert status.module_type == "TrainableTokensLayer"
+        assert status.enabled is True
+        assert status.active_adapters == ["default"]
+        assert status.merged_adapters == []
+        assert status.available_adapters == ["default"]
+        assert status.requires_grad == {"default": True}
+        assert status.devices == {"default": ["cpu"]}
+
+    @require_non_cpu
+    def test_devices_all_gpu_large(self, large_model):
+        large_model.to(self.torch_device)
+        layer_status = large_model.get_layer_status()
+        result = [status.devices for status in layer_status]
+        expected = [
+            {"default": [self.torch_device], "other": [self.torch_device]},
+            {"default": [self.torch_device]},
+            {"other": [self.torch_device]},
+            {"default": [self.torch_device]},
+        ]
+        assert result == expected
+
+    @require_non_cpu
+    def test_devices_cpu_and_gpu_large(self, large_model):
+        # move the embedding layer to GPU
+        large_model.model.lin0.lora_A["default"] = large_model.model.lin0.lora_A["default"].to(self.torch_device)
+        layer_status = large_model.get_layer_status()
+        result = [status.devices for status in layer_status]
+        expected = [
+            {"default": ["cpu", self.torch_device], "other": ["cpu"]},
+            {"default": ["cpu"]},
+            {"other": ["cpu"]},
+            {"default": ["cpu"]},
+        ]
+        assert result == expected
+
+    def test_target_parameters(self, large_model):
+        # don't check each attribute, just the relevant ones
+        # first remove the normal LoRA layers
+        large_model = large_model.merge_and_unload()
+        config = LoraConfig(target_parameters=["lin0.weight", "lin1.weight"])
+        large_model = get_peft_model(large_model, config)
+        layer_status = large_model.get_layer_status()
+        assert [status.name for status in layer_status] == ["model.lin0", "model.lin1"]
+        assert [status.module_type for status in layer_status] == ["lora.ParamWrapper"] * 2
+
+    def test_target_parameters_and_target_modules(self, large_model):
+        # don't check each attribute, just the relevant ones
+        # first remove the normal LoRA layers
+        large_model = large_model.merge_and_unload()
+        config = LoraConfig(target_parameters=["lin0.weight"], target_modules=["lin1"])
+        large_model = get_peft_model(large_model, config)
+        layer_status = large_model.get_layer_status()
+        assert [status.name for status in layer_status] == ["model.lin0", "model.lin1"]
+        assert [status.module_type for status in layer_status] == ["lora.ParamWrapper", "lora.Linear"]
+
+    def test_quantization_backend_small(self, small_model):
+        # non-quantized model should have quantization_backend=None
+        layer_status = small_model.get_layer_status()
+        assert [status.quantization_backend for status in layer_status] == [None]
+
+    def test_quantization_backend_large(self, large_model):
+        layer_status = large_model.get_layer_status()
+        result = [status.quantization_backend for status in layer_status]
+        expected = [None, None, None, None]
+        assert result == expected
+
+    def test_quantization_backend_bnb(self, small_base_model_cls):
+        # Manually inject an inconsistent quantization_backend instead of loading a model with bnb so that the test can run
+        # without bnb
+        model = small_base_model_cls()
+        config = LoraConfig(target_modules=["lin0", "lin1"])
+        model = get_peft_model(model, config)
+
+        for module in model.modules():
+            if isinstance(module, BaseTunerLayer):
+                module.quantization_backend = Bnb8bitBackend()
+
+        layer_status = model.get_layer_status()
+        result = [status.quantization_backend for status in layer_status]
+        assert result == ["bnb 8bit", "bnb 8bit"]
+
+    def test_quantization_backend_irregular(self, small_base_model_cls):
+        # Manually inject an inconsistent quantization_backend to simulate irregular state. This is an invalid state, but we
+        # should still test it.
+        model = small_base_model_cls()
+        config = LoraConfig(target_modules=["lin0", "lin1"])
+        model = get_peft_model(model, config)
+
+        # set quantization_backend on only one layer
+        for module in model.modules():
+            if isinstance(module, BaseTunerLayer):
+                module.quantization_backend = Bnb8bitBackend()
+                break
+
+        layer_status = model.get_layer_status()
+        result = [status.quantization_backend for status in layer_status]
+        assert result == ["bnb 8bit", None]
+
+    ################
+    # model status #
+    ################
+
+    def test_base_model_type_small(self, small_model):
+        model_status = small_model.get_model_status()
+        assert model_status.base_model_type == "SmallModel"
+
+    def test_base_model_type_large(self, large_model):
+        model_status = large_model.get_model_status()
+        assert model_status.base_model_type == "LargeModel"
+
+    def test_base_model_type_transformers_automodel(self):
+        # ensure that this also works with transformers AutoModels
+        model_id = "google/flan-t5-small"
+        with hub_online_once(model_id):
+            model = AutoModel.from_pretrained(model_id)
+        model = get_peft_model(model, LoraConfig())
+        model_status = model.get_model_status()
+        assert model_status.base_model_type == "T5Model"
+
+    def test_adapter_model_type_small(self, small_model):
+        model_status = small_model.get_model_status()
+        assert model_status.adapter_model_type == "LoraModel"
+
+    def test_adapter_model_type_large(self, large_model):
+        model_status = large_model.get_model_status()
+        assert model_status.adapter_model_type == "LoraModel"
+
+    def test_peft_types_small(self, small_model):
+        model_status = small_model.get_model_status()
+        assert model_status.peft_types == {"default": "LORA"}
+
+    def test_peft_types_large(self, large_model):
+        model_status = large_model.get_model_status()
+        assert model_status.peft_types == {"default": "LORA", "other": "LORA"}
+
+    def test_nb_params_small(self, small_model):
+        model_status = small_model.get_model_status()
+        assert model_status.trainable_params == 160
+        assert model_status.total_params == 380
+
+    def test_nb_params_large(self, large_model):
+        model_status = large_model.get_model_status()
+        assert model_status.trainable_params == 616
+        assert model_status.total_params == 2236
+
+    def test_num_adapter_layers_small(self, small_model):
+        model_status = small_model.get_model_status()
+        assert model_status.num_adapter_layers == 1
+
+    def test_num_adapter_layers_large(self, large_model):
+        model_status = large_model.get_model_status()
+        assert model_status.num_adapter_layers == 4
+
+    def test_model_enabled_small(self, small_model):
+        model_status = small_model.get_model_status()
+        assert model_status.enabled is True
+
+    def test_model_enabled_large(self, large_model):
+        model_status = large_model.get_model_status()
+        assert model_status.enabled is True
+
+    def test_model_disabled_small(self, small_model):
+        small_model.disable_adapter_layers()
+        model_status = small_model.get_model_status()
+        assert model_status.enabled is False
+
+    def test_model_disabled_large(self, large_model):
+        large_model.disable_adapter_layers()
+        model_status = large_model.get_model_status()
+        assert model_status.enabled is False
+
+    def test_model_enabled_irregular(self, large_model):
+        # this is an invalid state, but we should still test it
+        # disable a single layer
+        for module in large_model.modules():
+            if isinstance(module, BaseTunerLayer):
+                module.enable_adapters(False)
+                break
+
+        model_status = large_model.get_model_status()
+        assert model_status.enabled == "irregular"
+
+    def test_model_enabled_irregular_with_modules_to_save(self, small_base_model_cls):
+        # check that modules_to_save are correctly reported in layer status
+        model = small_base_model_cls()
+        config = LoraConfig(target_modules=["lin0"], modules_to_save=["lin1"])
+        model = get_peft_model(model, config)
+
+        # disable only lin0
+        model.lin0.enable_adapters(False)
+
+        model_status = model.get_model_status()
+        # since lin1 is still enabled, the overall model status is "irregular"
+        assert model_status.enabled == "irregular"
+
+    def test_model_enabled_irregular_with_trainable_tokens(self, small_base_emb_model_cls):
+        # check that trainable_token_indices are correctly reported in layer status
+        model = small_base_emb_model_cls()
+        config = LoraConfig(target_modules=["lin0"], trainable_token_indices={"emb": [0, 1, 2]})
+        model = get_peft_model(model, config)
+
+        # disable only lin0
+        model.lin0.enable_adapters(False)
+
+        model_status = model.get_model_status()
+        # since emb is still enabled, the overall model status is "irregular"
+        assert model_status.enabled == "irregular"
+
+    def test_model_active_adapters_small(self, small_model):
+        model_status = small_model.get_model_status()
+        assert model_status.active_adapters == ["default"]
+
+    def test_model_active_adapters_large(self, large_model):
+        model_status = large_model.get_model_status()
+        assert model_status.active_adapters == ["default"]
+
+        large_model.set_adapter("other")
+        model_status = large_model.get_model_status()
+        assert model_status.active_adapters == ["other"]
+
+    def test_model_active_adapters_irregular(self, large_model):
+        # this is an invalid state, but we should still test it
+        # disable a single layer
+        for module in large_model.modules():
+            if isinstance(module, BaseTunerLayer):
+                # switch a single layer's active adapter from default to other
+                if module.active_adapters == ["default"]:
+                    module._active_adapter = "other"
+                    assert module.active_adapters == ["other"]
+                    break
+
+        model_status = large_model.get_model_status()
+        assert model_status.active_adapters == "irregular"
+
+    def test_model_active_adapters_with_modules_to_save_irregular(self, small_base_model_cls):
+        # check that modules_to_save are correctly reported in layer status
+        model = small_base_model_cls()
+        config = LoraConfig(target_modules=["lin0"], modules_to_save=["lin1"])
+        model = get_peft_model(model, config)
+        model.add_adapter("other", config)
+
+        # switch modules_to_save to "other"
+        model.lin1.set_adapter("other")
+
+        model_status = model.get_model_status()
+        # since lin0 is still on "default", the overall model status is "irregular"
+        assert model_status.active_adapters == "irregular"
+
+    def test_model_active_adapters_with_trainable_tokens_irregular(self, small_base_emb_model_cls):
+        # check that trainable_token_indices are correctly reported in layer status
+        model = small_base_emb_model_cls()
+        config = LoraConfig(target_modules=["lin0"], trainable_token_indices={"emb": [0, 1, 2]})
+        model = get_peft_model(model, config)
+        model.add_adapter("other", config)
+
+        # switch trainable tokens to "other"
+        model.emb.set_adapter("other")
+
+        model_status = model.get_model_status()
+        # since lin0 is still on "default", the overall model status is "irregular"
+        assert model_status.active_adapters == "irregular"
+
+    def test_model_merged_adapters_small(self, small_model):
+        model_status = small_model.get_model_status()
+        assert model_status.merged_adapters == []
+
+        small_model.merge_adapter()
+        model_status = small_model.get_model_status()
+        assert model_status.merged_adapters == ["default"]
+
+        small_model.unmerge_adapter()
+        model_status = small_model.get_model_status()
+        assert model_status.merged_adapters == []
+
+    def test_model_merged_adapters_large(self, large_model):
+        model_status = large_model.get_model_status()
+        assert model_status.merged_adapters == []
+
+        large_model.merge_adapter(["default"])
+        model_status = large_model.get_model_status()
+        assert model_status.merged_adapters == ["default"]
+
+        large_model.unmerge_adapter()
+        large_model.merge_adapter(["other"])
+        model_status = large_model.get_model_status()
+        assert model_status.merged_adapters == ["other"]
+
+        large_model.unmerge_adapter()
+        large_model.merge_adapter(["default", "other"])
+        model_status = large_model.get_model_status()
+        assert model_status.merged_adapters == ["default", "other"]
+
+    def test_model_merged_adapters_irregular(self, large_model):
+        # this is an invalid state, but we should still test it
+        # by merging only lin0 of "default", we end up in a irregular state, because not all "default" layers are merged
+        large_model.base_model.lin0.merge(["default"])
+
+        model_status = large_model.get_model_status()
+        assert model_status.merged_adapters == "irregular"
+
+    def test_model_requires_grad_model_small(self, small_model):
+        model_status = small_model.get_model_status()
+        assert model_status.requires_grad == {"default": True}
+
+    def test_model_requires_grad_model_large(self, large_model):
+        model_status = large_model.get_model_status()
+        assert model_status.requires_grad == {"default": True, "other": False}
+
+        large_model.set_adapter("other")
+        model_status = large_model.get_model_status()
+        assert model_status.requires_grad == {"default": False, "other": True}
+
+        # change requires grad, is now inconsistent with active/inactive adapter
+        large_model.set_requires_grad("default", requires_grad=True)
+        large_model.set_requires_grad("other", requires_grad=False)
+        model_status = large_model.get_model_status()
+        assert model_status.requires_grad == {"default": True, "other": False}
+
+    def test_model_requires_grad_model_irregular(self, large_model):
+        # inject an embedding layer with requires_grad=False
+        # this is an invalid state, but we should still test it
+        lora_embedding_A = nn.Parameter(torch.zeros(10, 10))
+        lora_embedding_B = nn.Parameter(torch.zeros(10, 10))
+        lora_embedding_A.requires_grad = False
+        lora_embedding_B.requires_grad = False
+        large_model.base_model.model.lin0.lora_embedding_A["default"] = lora_embedding_A
+        large_model.base_model.model.lin0.lora_embedding_B["default"] = lora_embedding_B
+
+        model_status = large_model.get_model_status()
+        assert model_status.requires_grad == {"default": "irregular", "other": False}
+
+    def test_model_requires_irregular_with_modules_to_save(self, small_base_model_cls):
+        # check that modules_to_save are correctly reported in layer status
+        model = small_base_model_cls()
+        config = LoraConfig(target_modules=["lin0"], modules_to_save=["lin1"])
+        model = get_peft_model(model, config)
+
+        # set modules_to_save to requires_grad=False
+        model.lin1.modules_to_save.default.weight.requires_grad = False
+
+        model_status = model.get_model_status()
+        # since lin1 is still requires_grad=True, the overall model status is "irregular"
+        assert model_status.requires_grad == {"default": "irregular"}
+
+    def test_model_requires_irregular_with_trainable_tokens(self, small_base_emb_model_cls):
+        # check that trainable_token_indices are correctly reported in layer status
+        model = small_base_emb_model_cls()
+        config = LoraConfig(target_modules=["lin0"], trainable_token_indices={"emb": [0, 1, 2]})
+        model = get_peft_model(model, config)
+
+        # set trainable tokens to requires_grad=False
+        model.emb.token_adapter.trainable_tokens_delta.default.requires_grad = False
+
+        model_status = model.get_model_status()
+        # since emb is still requires_grad=True, the overall model status is "irregular"
+        assert model_status.requires_grad == {"default": "irregular"}
+
+    def test_model_available_adapters_small(self, small_model):
+        model_status = small_model.get_model_status()
+        assert model_status.available_adapters == ["default"]
+
+    def test_model_available_adapters_large(self, large_model):
+        model_status = large_model.get_model_status()
+        assert model_status.available_adapters == ["default", "other"]
+
+    def test_model_devices_all_cpu_small(self, small_model):
+        model_status = small_model.get_model_status()
+        assert model_status.devices == {"default": ["cpu"]}
+
+    def test_model_devices_all_cpu_large(self, large_model):
+        model_status = large_model.get_model_status()
+        assert model_status.devices == {"default": ["cpu"], "other": ["cpu"]}
+
+    @require_non_cpu
+    def test_model_devices_all_gpu_large(self, large_model):
+        large_model.to(self.torch_device)
+        model_status = large_model.get_model_status()
+        assert model_status.devices == {"default": [self.torch_device], "other": [self.torch_device]}
+
+    @require_non_cpu
+    def test_model_devices_cpu_and_gpu_large(self, large_model):
+        # move the embedding layer to GPU
+        large_model.model.lin0.lora_A["default"] = large_model.model.lin0.lora_A["default"].to(self.torch_device)
+        model_status = large_model.get_model_status()
+        assert model_status.devices == {"default": ["cpu", self.torch_device], "other": ["cpu"]}
+
+    def test_model_target_parameters(self, large_model):
+        # don't check each attribute, just the relevant ones
+        # first remove the normal LoRA layers
+        large_model = large_model.merge_and_unload()
+        config = LoraConfig(target_parameters=["lin0.weight", "lin1.weight"])
+        large_model = get_peft_model(large_model, config)
+        model_status = large_model.get_model_status()
+        model_status = large_model.get_model_status()
+        assert model_status.adapter_model_type == "LoraModel"
+        assert model_status.peft_types == {"default": "LORA"}
+        assert model_status.num_adapter_layers == 2
+        assert model_status.trainable_params == 2 * (8 * 10 + 10 * 8)
+
+    def test_model_target_parameters_and_target_modules(self, large_model):
+        # don't check each attribute, just the relevant ones
+        # first remove the normal LoRA layers
+        large_model = large_model.merge_and_unload()
+        config = LoraConfig(target_parameters=["lin0.weight"], target_modules=["lin1"])
+        large_model = get_peft_model(large_model, config)
+        model_status = large_model.get_model_status()
+        assert model_status.adapter_model_type == "LoraModel"
+        assert model_status.peft_types == {"default": "LORA"}
+        assert model_status.num_adapter_layers == 2
+        assert model_status.trainable_params == 2 * (8 * 10 + 10 * 8)
+
+    def test_model_status_with_modules_to_save(self, small_base_model_cls):
+        # check that modules_to_save are correctly reported in layer status
+        model = small_base_model_cls()
+        num_base_params = sum(p.numel() for p in small_base_model_cls().parameters())
+        config = LoraConfig(target_modules=["lin0"], modules_to_save=["lin1"])
+        model = get_peft_model(model, config)
+        model_status = model.get_model_status()
+
+        assert model_status.base_model_type == "SmallModel"
+        assert model_status.adapter_model_type == "LoraModel"
+        assert model_status.peft_types == {"default": "LORA"}
+        # 2 x 80 for LoRA, 100 for modules_to_save.weight, 10 for modules_to_save.bias
+        assert model_status.trainable_params == 2 * 80 + 100 + 10
+        assert model_status.total_params == 2 * 80 + 100 + 10 + num_base_params
+        assert model_status.num_adapter_layers == 2  # lin0 + lin1
+        assert model_status.enabled is True
+        assert model_status.active_adapters == ["default"]
+        assert model_status.merged_adapters == []
+        assert model_status.requires_grad == {"default": True}
+        assert model_status.available_adapters == ["default"]
+        assert model_status.devices == {"default": ["cpu"]}  # all on CPU
+
+    def test_model_status_with_trainable_tokens(self, small_base_emb_model_cls):
+        # check that trainable_token_indices are correctly reported in layer status
+        model = small_base_emb_model_cls()
+        num_base_params = sum(p.numel() for p in small_base_emb_model_cls().parameters())
+        config = LoraConfig(target_modules=["lin0"], trainable_token_indices={"emb": [0, 1, 2]})
+        model = get_peft_model(model, config)
+        model_status = model.get_model_status()
+
+        assert model_status.base_model_type == "SmallEmbModel"
+        assert model_status.adapter_model_type == "LoraModel"
+        assert model_status.peft_types == {"default": "LORA"}
+        # 2 x 80 for LoRA, 3 x 10 for trainable tokens
+        assert model_status.trainable_params == 2 * 80 + 3 * 10
+        assert model_status.total_params == 2 * 80 + 3 * 10 + num_base_params
+        assert model_status.num_adapter_layers == 2
+        assert model_status.enabled is True
+        assert model_status.active_adapters == ["default"]
+        assert model_status.merged_adapters == []
+        assert model_status.requires_grad == {"default": True}
+        assert model_status.available_adapters == ["default"]
+        assert model_status.devices == {"default": ["cpu"]}  # all on CPU
+
+    def test_loha_model(self):
+        # ensure that this also works with non-LoRA, it's not necessary to test all tuners
+        class SmallModel(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.lin0 = nn.Linear(10, 10)
+                self.lin1 = nn.Linear(10, 10)
+
+        base_model = SmallModel()
+        config = LoHaConfig(target_modules=["lin0", "lin1"], init_weights=False)
+        model = get_peft_model(base_model, config)
+
+        model_status = model.get_model_status()
+        layer_status = model.get_layer_status()
+
+        assert model_status.base_model_type == "SmallModel"
+        assert model_status.adapter_model_type == "LoHaModel"
+        assert model_status.peft_types == {"default": "LOHA"}
+        assert model_status.trainable_params == 640
+        assert model_status.total_params == 860
+        assert model_status.num_adapter_layers == 2
+        assert model_status.enabled is True
+        assert model_status.active_adapters == ["default"]
+        assert model_status.merged_adapters == []
+        assert model_status.requires_grad == {"default": True}
+        assert model_status.available_adapters == ["default"]
+        assert model_status.devices == {"default": ["cpu"]}
+
+        layer_status0 = layer_status[0]
+        assert len(layer_status) == 2
+        assert layer_status0.name == "model.lin0"
+        assert layer_status0.module_type == "loha.Linear"
+        assert layer_status0.enabled is True
+        assert layer_status0.active_adapters == ["default"]
+        assert layer_status0.merged_adapters == []
+        assert layer_status0.requires_grad == {"default": True}
+        assert layer_status0.available_adapters == ["default"]
+        assert layer_status0.devices == {"default": ["cpu"]}
+
+    @require_non_cpu
+    def test_vera_model(self):
+        # let's also test VeRA because it uses BufferDict
+        class SmallModel(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.lin0 = nn.Linear(10, 10)
+                self.lin1 = nn.Linear(10, 10)
+
+        base_model = SmallModel()
+        config = VeraConfig(target_modules=["lin0", "lin1"], init_weights=False)
+        model = get_peft_model(base_model, config)
+
+        # move the buffer dict to GPU
+        model.lin0.vera_A["default"] = model.lin0.vera_A["default"].to(self.torch_device)
+
+        model_status = model.get_model_status()
+        layer_status = model.get_layer_status()
+
+        assert model_status.base_model_type == "SmallModel"
+        assert model_status.adapter_model_type == "VeraModel"
+        assert model_status.peft_types == {"default": "VERA"}
+        assert model_status.trainable_params == 532
+        assert model_status.total_params == 752
+        assert model_status.num_adapter_layers == 2
+        assert model_status.enabled is True
+        assert model_status.active_adapters == ["default"]
+        assert model_status.merged_adapters == []
+        assert model_status.requires_grad == {"default": True}
+        assert model_status.available_adapters == ["default"]
+        assert model_status.devices == {"default": ["cpu", self.torch_device]}
+
+        layer_status0 = layer_status[0]
+        assert len(layer_status) == 2
+        assert layer_status0.name == "model.lin0"
+        assert layer_status0.module_type == "vera.Linear"
+        assert layer_status0.enabled is True
+        assert layer_status0.active_adapters == ["default"]
+        assert layer_status0.merged_adapters == []
+        assert layer_status0.requires_grad == {"default": True}
+        assert layer_status0.available_adapters == ["default"]
+        assert layer_status0.devices == {"default": ["cpu", self.torch_device]}
+
+    def test_model_quantization_backend_small(self, small_model):
+        model_status = small_model.get_model_status()
+        assert model_status.quantization_backend is None
+
+    def test_model_quantization_backend_large(self, large_model):
+        model_status = large_model.get_model_status()
+        assert model_status.quantization_backend is None
+
+    def test_model_quantization_backend_bnb(self, small_base_model_cls):
+        # Manually inject an inconsistent quantization_backend instead of loading a model with bnb so that the test can run
+        # without bnb
+        model = small_base_model_cls()
+        config = LoraConfig(target_modules=["lin0", "lin1"])
+        model = get_peft_model(model, config)
+
+        for module in model.modules():
+            if isinstance(module, BaseTunerLayer):
+                module.quantization_backend = Bnb8bitBackend()
+
+        model_status = model.get_model_status()
+        assert model_status.quantization_backend == "bnb 8bit"
+
+    def test_model_quantization_backend_irregular(self, small_base_model_cls):
+        # Manually inject an inconsistent quantization_backend to simulate irregular state. This is an invalid state, but we
+        # should still test it.
+        model = small_base_model_cls()
+        config = LoraConfig(target_modules=["lin0", "lin1"])
+        model = get_peft_model(model, config)
+
+        # set quantization_backend on only one layer
+        for module in model.modules():
+            if isinstance(module, BaseTunerLayer):
+                module.quantization_backend = Bnb8bitBackend()
+                break
+
+        model_status = model.get_model_status()
+        assert model_status.quantization_backend == "irregular"
+
+    ###################
+    # non-PEFT models #
+    ###################
+
+    def test_transformers_model(self):
+        model_id = "peft-internal-testing/gpt2-lora-random"
+        # note that loading through AutoModelForCausalLM.from_pretrained does not enable training mode, hence
+        # requires_grad=False
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+        model_status = get_model_status(model)
+        layer_status = get_layer_status(model)
+
+        assert model_status.base_model_type == "GPT2LMHeadModel"
+        assert model_status.adapter_model_type == "None"
+        assert model_status.peft_types == {}
+        assert model_status.trainable_params == 0
+        assert model_status.total_params == 124734720
+        assert model_status.num_adapter_layers == 12
+        assert model_status.enabled is True
+        assert model_status.active_adapters == ["default"]
+        assert model_status.merged_adapters == []
+        assert model_status.requires_grad == {"default": False}
+        assert model_status.available_adapters == ["default"]
+        assert model_status.devices == {"default": ["cpu"]}
+
+        layer_status0 = layer_status[0]
+        assert len(layer_status) == 12
+        assert layer_status0.name == "transformer.h.0.attn.c_attn"
+        assert layer_status0.module_type == "lora.Linear"
+        assert layer_status0.enabled is True
+        assert layer_status0.active_adapters == ["default"]
+        assert layer_status0.merged_adapters == []
+        assert layer_status0.requires_grad == {"default": False}
+        assert layer_status0.available_adapters == ["default"]
+        assert layer_status0.devices == {"default": ["cpu"]}
+
+    def test_model_with_injected_layers(self, large_model):
+        model = large_model.base_model.model
+        model_status = get_model_status(model)
+        layer_status = get_layer_status(model)
+
+        assert model_status.base_model_type == "other"
+        assert model_status.adapter_model_type == "None"
+        assert model_status.peft_types == {}
+        assert model_status.trainable_params == 616
+        assert model_status.total_params == 2236
+        assert model_status.num_adapter_layers == 4
+        assert model_status.enabled is True
+        assert model_status.active_adapters == ["default"]
+        assert model_status.merged_adapters == []
+        assert model_status.requires_grad == {"default": True, "other": False}
+        assert model_status.available_adapters == ["default", "other"]
+        assert model_status.devices == {"default": ["cpu"], "other": ["cpu"]}
+
+        layer_status1 = layer_status[1]
+        assert len(layer_status) == 4
+        assert layer_status1.name == "emb0"
+        assert layer_status1.module_type == "lora.Embedding"
+        assert layer_status1.enabled is True
+        assert layer_status1.active_adapters == ["default"]
+        assert layer_status1.merged_adapters == []
+        assert layer_status1.requires_grad == {"default": True}
+        assert layer_status1.available_adapters == ["default"]
+        assert layer_status1.devices == {"default": ["cpu"]}
+
+    ###############
+    # error cases #
+    ###############
+
+    def test_vanilla_model_raises(self):
+        model = nn.Linear(10, 10)
+        # note: full error message is longer
+        with pytest.raises(ValueError, match="No adapter layers found in the model"):
+            get_layer_status(model)
+
+        with pytest.raises(ValueError, match="No adapter layers found in the model"):
+            get_model_status(model)
+
+    def test_transformer_model_without_adapter_raises(self):
+        model_id = "gpt2"
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+        # note: full error message is longer
+        with pytest.raises(ValueError, match="No adapter layers found in the model"):
+            get_layer_status(model)
+
+        with pytest.raises(ValueError, match="No adapter layers found in the model"):
+            get_model_status(model)
+
+    def test_prefix_tuning(self):
+        model_id = "peft-internal-testing/tiny-random-BartForConditionalGeneration"
+        with hub_online_once(model_id):
+            model = AutoModelForSeq2SeqLM.from_pretrained(model_id)
+        config = PromptTuningConfig(task_type="SEQ_2_SEQ_LM", num_virtual_tokens=10)
+        model = get_peft_model(model, config)
+
+        # note: full error message is longer
+        with pytest.raises(TypeError, match=re.escape("get_layer_status() got an invalid PeftModel instance")):
+            model.get_layer_status()
+
+        with pytest.raises(TypeError, match=re.escape("get_model_status() got an invalid PeftModel instance")):
+            model.get_model_status()
+
+    def test_adaption_prompt(self):
+        model_id = "peft-internal-testing/tiny-random-LlamaForCausalLM"
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+        config = AdaptionPromptConfig(adapter_layers=1, adapter_len=4)
+        model = get_peft_model(model, config)
+
+        # note: full error message is longer
+        with pytest.raises(TypeError, match=re.escape("get_layer_status() got an invalid PeftModel instance")):
+            model.get_layer_status()
+
+        with pytest.raises(TypeError, match=re.escape("get_model_status() got an invalid PeftModel instance")):
+            model.get_model_status()
+
+    def test_mixed_model_raises(self):
+        class SimpleNet(nn.Module):
+            def __init__(self, bias=True):
+                super().__init__()
+                # note: out_features must be > rank or else OFT will be an identity transform
+                self.lin0 = nn.Linear(10, 20, bias=bias)
+                self.relu = nn.ReLU()
+                self.lin1 = nn.Linear(20, 16, bias=bias)
+
+            def forward(self, X):
+                X = X.float()
+                X = self.lin0(X)
+                X = self.relu(X)
+                X = self.lin1(X)
+                return X
+
+        base_model = SimpleNet()
+        config0 = LoraConfig(target_modules=["lin0"], init_lora_weights=False)
+        config1 = LoHaConfig(target_modules=["lin0", "lin1"], init_weights=False)
+        model = get_peft_model(base_model, config0, adapter_name="adapter0", mixed="mixed")
+        model.add_adapter("adapter1", config1)
+
+        # note: full error message is longer
+        with pytest.raises(TypeError, match="get_layer_status is not supported for PeftMixedModel"):
+            model.get_layer_status()
+
+        with pytest.raises(TypeError, match="get_model_status is not supported for PeftMixedModel"):
+            model.get_model_status()
+
+
+# Tests for BaseTuner
+class MockModelConfig:
+    config = {"mock_key": "mock_value"}
+
+    def to_dict(self):
+        return self.config
+
+
+@dataclasses.dataclass
+class MockModelDataclassConfig:
+    mock_key: str
+
+
+class ModelWithConfig(nn.Module):
+    def __init__(self):
+        self.config = MockModelConfig()
+
+
+class ModelWithDictConfig(nn.Module):
+    def __init__(self):
+        self.config = MockModelConfig.config
+
+
+class ModelWithDataclassConfig(nn.Module):
+    def __init__(self):
+        self.config = MockModelDataclassConfig(**MockModelConfig().to_dict())
+
+
+class ModelWithNoConfig(nn.Module):
+    pass
+
+
+class TestBaseTunerGetModelConfig:
+    def test_get_model_config_use_to_dict(self):
+        config = BaseTuner.get_model_config(ModelWithConfig())
+        assert config == MockModelConfig.config
+
+    def test_get_model_config_as_dict(self):
+        config = BaseTuner.get_model_config(ModelWithDictConfig())
+        assert config == MockModelConfig.config
+
+    def test_get_model_config_with_no_config(self):
+        config = BaseTuner.get_model_config(ModelWithNoConfig())
+        assert config == DUMMY_MODEL_CONFIG
+
+    def test_get_model_config_with_dataclass(self):
+        config = BaseTuner.get_model_config(ModelWithDataclassConfig())
+        assert config == MockModelConfig.config
+
+
+class TestBaseTunerWarnForTiedEmbeddings:
+    model_id = "peft-internal-testing/tiny-random-LlamaForCausalLM"
+    warn_end_merge = (
+        "# Now use the original model but in untied format\n"
+        "model = AutoModelForCausalLM.from_pretrained(untied_model_dir)\n```\n"
+    )
+
+    def _get_peft_model(self, tie_word_embeddings, target_module):
+        with hub_online_once(self.model_id):
+            base_model = AutoModelForCausalLM.from_pretrained(self.model_id, tie_word_embeddings=tie_word_embeddings)
+        model = get_peft_model(
+            base_model,
+            LoraConfig(target_modules=[target_module]),
+        )
+        return model
+
+    def _is_warn_triggered(self, warning_list, endswith):
+        return any(str(warning.message).endswith(endswith) for warning in warning_list)
+
+    def test_warn_for_tied_embeddings_merge(self, recwarn):
+        model = self._get_peft_model(tie_word_embeddings=True, target_module="lm_head")
+        model.merge_and_unload()
+        assert self._is_warn_triggered(recwarn.list, self.warn_end_merge)
+
+    def test_no_warn_for_untied_embeddings_merge(self, recwarn):
+        model_not_tied = self._get_peft_model(tie_word_embeddings=False, target_module="lm_head")
+        model_not_tied.merge_and_unload()
+        assert not self._is_warn_triggered(recwarn.list, self.warn_end_merge)
+
+    def test_no_warn_for_no_target_module_merge(self, recwarn):
+        model_no_target_module = self._get_peft_model(tie_word_embeddings=True, target_module="q_proj")
+        model_no_target_module.merge_and_unload()
+        assert not self._is_warn_triggered(recwarn.list, self.warn_end_merge)
+
+
+class TestFindMinimalTargetModules:
+    @pytest.mark.parametrize(
+        "target_modules, other_module_names, expected",
+        [
+            (["bar"], [], {"bar"}),
+            (["foo"], ["bar"], {"foo"}),
+            (["1.foo", "2.foo"], ["3.foo", "4.foo"], {"1.foo", "2.foo"}),
+            # Could also return "bar.baz" but we want the shorter one
+            (["bar.baz"], ["foo.bar"], {"baz"}),
+            (["1.foo", "2.foo", "bar.baz"], ["3.foo", "bar.bla"], {"1.foo", "2.foo", "baz"}),
+            # Case with longer suffix chains and nested suffixes
+            (["a.b.c", "d.e.f", "g.h.i"], ["j.k.l", "m.n.o"], {"c", "f", "i"}),
+            (["a.b.c", "d.e.f", "g.h.i"], ["a.b.x", "d.x.f", "x.h.i"], {"c", "e.f", "g.h.i"}),
+            # Case with multiple items that can be covered by a single suffix
+            (["foo.bar.baz", "qux.bar.baz"], ["baz.bar.foo"], {"baz"}),
+            # Realistic examples
+            # Only match k_proj
+            (
+                ["model.decoder.layers.{i}.self_attn.k_proj" for i in range(12)],
+                (
+                    ["model.decoder.layers.{i}.self_attn" for i in range(12)]
+                    + ["model.decoder.layers.{i}.self_attn.v_proj" for i in range(12)]
+                    + ["model.decoder.layers.{i}.self_attn.q_proj" for i in range(12)]
+                ),
+                {"k_proj"},
+            ),
+            # Match all k_proj except the one in layer 5 => no common suffix
+            (
+                ["model.decoder.layers.{i}.self_attn.k_proj" for i in range(12) if i != 5],
+                (
+                    ["model.decoder.layers.5.self_attn.k_proj"]
+                    + ["model.decoder.layers.{i}.self_attn" for i in range(12)]
+                    + ["model.decoder.layers.{i}.self_attn.v_proj" for i in range(12)]
+                    + ["model.decoder.layers.{i}.self_attn.q_proj" for i in range(12)]
+                ),
+                {"{i}.self_attn.k_proj" for i in range(12) if i != 5},
+            ),
+        ],
+    )
+    def test_find_minimal_target_modules(self, target_modules, other_module_names, expected):
+        # check all possible combinations of list and set
+        result = find_minimal_target_modules(target_modules, other_module_names)
+        assert result == expected
+
+        result = find_minimal_target_modules(set(target_modules), other_module_names)
+        assert result == expected
+
+        result = find_minimal_target_modules(target_modules, set(other_module_names))
+        assert result == expected
+
+        result = find_minimal_target_modules(set(target_modules), set(other_module_names))
+        assert result == expected
+
+    def test_find_minimal_target_modules_empty_raises(self):
+        with pytest.raises(ValueError, match="target_modules should be a list or set of strings"):
+            find_minimal_target_modules([], ["foo"])
+
+        with pytest.raises(ValueError, match="target_modules should be a list or set of strings"):
+            find_minimal_target_modules(set(), ["foo"])
+
+    def test_find_minimal_target_modules_contains_empty_string_raises(self):
+        target_modules = ["", "foo", "bar.baz"]
+        other_module_names = ["bar"]
+        with pytest.raises(ValueError, match="target_modules should not contain an empty string"):
+            find_minimal_target_modules(target_modules, other_module_names)
+
+    def test_find_minimal_target_modules_string_raises(self):
+        target_modules = "foo"
+        other_module_names = ["bar"]
+        with pytest.raises(ValueError, match="target_modules should be a list or set of strings"):
+            find_minimal_target_modules(target_modules, other_module_names)
+
+    @pytest.mark.parametrize(
+        "target_modules, other_module_names",
+        [
+            (["foo"], ["foo"]),
+            (["foo.bar"], ["foo.bar"]),
+            (["foo.bar", "spam", "eggs"], ["foo.bar"]),
+            (["foo.bar", "spam"], ["foo.bar", "eggs"]),
+            (["foo.bar"], ["foo.bar", "spam", "eggs"]),
+        ],
+    )
+    def test_find_minimal_target_modules_not_disjoint_raises(self, target_modules, other_module_names):
+        msg = (
+            "target_modules and other_module_names contain common elements, this should not happen, please "
+            "open a GitHub issue at https://github.com/huggingface/peft/issues with the code to reproduce this issue"
+        )
+        with pytest.raises(ValueError, match=msg):
+            find_minimal_target_modules(target_modules, other_module_names)
+
+    def test_get_peft_model_applies_find_target_modules(self):
+        # Check that when calling get_peft_model, the target_module optimization is indeed applied if the length of
+        # target_modules is big enough. The resulting model itself should be unaffected.
+        torch.manual_seed(0)
+        model_id = "peft-internal-testing/opt-125m"  # must be big enough for optimization to trigger
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+
+        # base case: specify target_modules in a minimal fashion
+        config = LoraConfig(init_lora_weights=False, target_modules=["q_proj", "v_proj"])
+        model = get_peft_model(model, config)
+
+        # this list contains all targeted modules listed separately
+        big_target_modules = [name for name, module in model.named_modules() if isinstance(module, LoraLayer)]
+        # sanity check
+        assert len(big_target_modules) > MIN_TARGET_MODULES_FOR_OPTIMIZATION
+
+        # make a "checksum" of the model for comparison
+        model_check_sum_before = sum(p.sum() for p in model.parameters())
+
+        # strip prefix so that the names they can be used as new target_modules
+        prefix_to_strip = "base_model.model.model."
+        big_target_modules = [name[len(prefix_to_strip) :] for name in big_target_modules]
+
+        del model
+
+        torch.manual_seed(0)
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+        # pass the big target_modules to config
+        config = LoraConfig(init_lora_weights=False, target_modules=big_target_modules)
+        model = get_peft_model(model, config)
+
+        # check that target modules have been condensed
+        assert model.peft_config["default"].target_modules == {"q_proj", "v_proj"}
+
+        # check that the resulting model is still the same
+        model_check_after = sum(p.sum() for p in model.parameters())
+        assert model_check_sum_before == model_check_after
+
+    def test_suffix_is_substring_of_other_suffix(self):
+        # This test is based on a real world bug found in diffusers. The issue was that we needed the suffix
+        # 'time_emb_proj' in the minimal target modules. However, if there already was the suffix 'proj' in the
+        # required_suffixes, 'time_emb_proj' would not be added because the test was `endswith(suffix)` and
+        # 'time_emb_proj' ends with 'proj'. The correct logic is to test if `endswith("." + suffix")`. The module names
+        # chosen here are only a subset of the hundreds of actual module names but this subset is sufficient to
+        # replicate the bug.
+        target_modules = [
+            "down_blocks.1.attentions.0.transformer_blocks.0.ff.net.0.proj",
+            "mid_block.attentions.0.transformer_blocks.0.ff.net.0.proj",
+            "up_blocks.0.attentions.0.transformer_blocks.0.ff.net.0.proj",
+            "mid_block.attentions.0.proj_out",
+            "up_blocks.0.attentions.0.proj_out",
+            "down_blocks.1.attentions.0.proj_out",
+            "up_blocks.0.resnets.0.time_emb_proj",
+            "down_blocks.0.resnets.0.time_emb_proj",
+            "mid_block.resnets.0.time_emb_proj",
+        ]
+        other_module_names = [
+            "conv_in",
+            "time_proj",
+            "time_embedding",
+            "time_embedding.linear_1",
+            "add_time_proj",
+            "add_embedding",
+            "add_embedding.linear_1",
+            "add_embedding.linear_2",
+            "down_blocks",
+            "down_blocks.0",
+            "down_blocks.0.resnets",
+            "down_blocks.0.resnets.0",
+            "up_blocks",
+            "up_blocks.0",
+            "up_blocks.0.attentions",
+            "up_blocks.0.attentions.0",
+            "up_blocks.0.attentions.0.norm",
+            "up_blocks.0.attentions.0.transformer_blocks",
+            "up_blocks.0.attentions.0.transformer_blocks.0",
+            "up_blocks.0.attentions.0.transformer_blocks.0.norm1",
+            "up_blocks.0.attentions.0.transformer_blocks.0.attn1",
+        ]
+        expected = {"time_emb_proj", "proj", "proj_out"}
+        result = find_minimal_target_modules(target_modules, other_module_names)
+        assert result == expected
+
+    def test_get_peft_modules_module_name_is_suffix_of_another_module(self):
+        # Solves the following bug:
+        # https://github.com/huggingface/diffusers/pull/9622#issuecomment-2404789721
+
+        # The cause for the bug is as follows: When we have, say, a module called "bar.0.query" that we want to target
+        # and another module called "foo_bar.0.query" that we don't want to target, there was potential for an error.
+        # This is not caused by _find_minimal_target_modules directly, but rather the bug was inside of
+        # BaseTuner.inject_adapter and how the names_no_target were chosen. Those used to be chosen based on suffix. In
+        # our example, however, "bar.0.query" is a suffix of "foo_bar.0.query", therefore "foo_bar.0.query" was *not*
+        # added to names_no_target when it should have. As a consequence, during the optimization, it looks like "query"
+        # is safe to use as target_modules because we don't see that it wrongly matches "foo_bar.0.query".
+
+        # ensure that we have sufficiently many modules to trigger the optimization
+        n_layers = MIN_TARGET_MODULES_FOR_OPTIMIZATION + 1
+
+        class InnerModule(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.query = nn.Linear(10, 10)
+
+        class OuterModule(nn.Module):
+            def __init__(self):
+                super().__init__()
+                # note that "transformer_blocks" is a suffix of "single_transformer_blocks"
+                self.transformer_blocks = nn.ModuleList([InnerModule() for _ in range(n_layers)])
+                self.single_transformer_blocks = nn.ModuleList([InnerModule() for _ in range(n_layers)])
+
+        # we want to match all "transformer_blocks" layers but not "single_transformer_blocks"
+        target_modules = [f"transformer_blocks.{i}.query" for i in range(n_layers)]
+        model = get_peft_model(OuterModule(), LoraConfig(target_modules=target_modules))
+
+        # sanity check: we should have n_layers PEFT layers in model.transformer_blocks
+        transformer_blocks = model.base_model.model.transformer_blocks
+        assert sum(isinstance(module, BaseTunerLayer) for module in transformer_blocks.modules()) == n_layers
+
+        # we should not have any PEFT layers in model.single_transformer_blocks
+        single_transformer_blocks = model.base_model.model.single_transformer_blocks
+        assert not any(isinstance(module, BaseTunerLayer) for module in single_transformer_blocks.modules())
+
+        # target modules should *not* be simplified to "query" as that would match "single_transformers_blocks" too
+        assert model.peft_config["default"].target_modules != {"query"}
+
+    def test_find_minimal_target_modules_does_not_error_with_ia3(self, tmp_path):
+        # See #2429
+        # There is an issue with the compression of the target_modules attribute when using IA³. There, we additionally
+        # have the feedforward_modules attribute, which must be subset of target_modules. When target_modules is shrunk,
+        # the subset check will fail. This test ensures that this doesn't happen.
+        n_layers = MIN_TARGET_MODULES_FOR_OPTIMIZATION + 1
+
+        class InnerModule(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.query = nn.Linear(10, 10)
+
+        class OuterModule(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.blocks = nn.ModuleList([InnerModule() for _ in range(n_layers)])
+
+        target_modules = [f"blocks.{i}.query" for i in range(n_layers)]
+        feedforward_modules = [f"blocks.{i}.query" for i in range(n_layers)]
+        # the subset check happens here
+        config = IA3Config(target_modules=target_modules, feedforward_modules=feedforward_modules)
+        # the optimization step happens here, after the subset check, so at first we're fine, but we will run into an
+        # issue after a save/load roundtrip
+        model = get_peft_model(OuterModule(), config)
+        model.save_pretrained(tmp_path)
+        del model
+
+        # does not raise
+        PeftModel.from_pretrained(OuterModule(), tmp_path)
+
+
+class TestRankAndAlphaPattern:
+    @pytest.fixture
+    def model(self):
+        # we always target the foo layers, the *bar* layers are used as a control group to ensure that they are not
+        # accidentally targeted
+        class Inner(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.foo = nn.Linear(1, 1)
+                self.barfoo = nn.Linear(1, 1)
+
+        class Middle(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.foo = nn.Linear(1, 1)
+                self.foobar = nn.Linear(1, 1)
+                self.module = Inner()
+
+        class Outer(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.foo = nn.Linear(1, 1)
+                self.bar = nn.Linear(1, 1)
+                self.module = Middle()
+
+        # resulting model for overview:
+        # Outer(
+        #   (foo): Linear(...)
+        #   (bar): Linear(...)
+        #   (module): Middle(
+        #     (foo): Linear(...)
+        #     (foobar): Linear(...)
+        #     (module): Inner(
+        #       (foo): Linear(...)
+        #       (barfoo): Linear(...)
+        #     )
+        #   )
+        # )
+
+        return Outer()
+
+    def test_no_rank_nor_alpha_pattern(self, model):
+        # sanity check the default case, no rank or alpha pattern
+        config = LoraConfig(target_modules="all-linear")
+        model = get_peft_model(model, config).base_model.model
+        # r is the default rank and alpha, thus scaling is 1.0
+        assert model.foo.r["default"] == 8
+        assert model.foo.scaling["default"] == 1.0
+        assert model.bar.r["default"] == 8
+        assert model.bar.scaling["default"] == 1.0
+        assert model.module.foo.r["default"] == 8
+        assert model.module.foo.scaling["default"] == 1.0
+        assert model.module.foobar.r["default"] == 8
+        assert model.module.foobar.scaling["default"] == 1.0
+        assert model.module.module.foo.r["default"] == 8
+        assert model.module.module.foo.scaling["default"] == 1.0
+        assert model.module.module.barfoo.r["default"] == 8
+        assert model.module.module.barfoo.scaling["default"] == 1.0
+
+    def test_rank_and_alpha_pattern_no_matching_keys(self, model):
+        # sanity check for non-matching keys, no rank or alpha pattern
+        config = LoraConfig(target_modules="all-linear", rank_pattern={"bla": 4, "oof": 6}, alpha_pattern={"baz": 3})
+        model = get_peft_model(model, config).base_model.model
+        # r is the default rank and alpha, thus scaling is 1.0
+        assert model.foo.r["default"] == 8
+        assert model.foo.scaling["default"] == 1.0
+        assert model.bar.r["default"] == 8
+        assert model.bar.scaling["default"] == 1.0
+        assert model.module.foo.r["default"] == 8
+        assert model.module.foo.scaling["default"] == 1.0
+        assert model.module.foobar.r["default"] == 8
+        assert model.module.foobar.scaling["default"] == 1.0
+        assert model.module.module.foo.r["default"] == 8
+        assert model.module.module.foo.scaling["default"] == 1.0
+        assert model.module.module.barfoo.r["default"] == 8
+        assert model.module.module.barfoo.scaling["default"] == 1.0
+
+    # below, we test all permutations for rank_pattern of targeting outer, middle, and inner foo layers:
+
+    def test_rank_pattern_target_all(self, model):
+        config = LoraConfig(target_modules="all-linear", rank_pattern={"foo": 16})
+        model = get_peft_model(model, config).base_model.model
+        assert model.foo.r["default"] == 16
+        assert model.bar.r["default"] == 8
+        assert model.module.foo.r["default"] == 16
+        assert model.module.foobar.r["default"] == 8
+        assert model.module.module.foo.r["default"] == 16
+        assert model.module.module.barfoo.r["default"] == 8
+
+    def test_rank_pattern_target_outer(self, model):
+        config = LoraConfig(target_modules="all-linear", rank_pattern={"^foo": 16})
+        model = get_peft_model(model, config).base_model.model
+        assert model.foo.r["default"] == 16
+        assert model.bar.r["default"] == 8
+        assert model.module.foo.r["default"] == 8
+        assert model.module.foobar.r["default"] == 8
+        assert model.module.module.foo.r["default"] == 8
+        assert model.module.module.barfoo.r["default"] == 8
+
+    def test_rank_pattern_target_middle(self, model):
+        config = LoraConfig(target_modules="all-linear", rank_pattern={"^module.foo": 16})
+        model = get_peft_model(model, config).base_model.model
+        assert model.foo.r["default"] == 8
+        assert model.bar.r["default"] == 8
+        assert model.module.foo.r["default"] == 16
+        assert model.module.foobar.r["default"] == 8
+        assert model.module.module.foo.r["default"] == 8
+        assert model.module.module.barfoo.r["default"] == 8
+
+    def test_rank_pattern_target_inner(self, model):
+        config = LoraConfig(target_modules="all-linear", rank_pattern={"module.module.foo": 16})
+        model = get_peft_model(model, config).base_model.model
+        assert model.foo.r["default"] == 8
+        assert model.bar.r["default"] == 8
+        assert model.module.foo.r["default"] == 8
+        assert model.module.foobar.r["default"] == 8
+        assert model.module.module.foo.r["default"] == 16
+        assert model.module.module.barfoo.r["default"] == 8
+
+    def test_rank_pattern_target_inner_with_caret(self, model):
+        # same as before, but using the caret in the regex should also work
+        config = LoraConfig(target_modules="all-linear", rank_pattern={"^module.module.foo": 16})
+        model = get_peft_model(model, config).base_model.model
+        assert model.foo.r["default"] == 8
+        assert model.bar.r["default"] == 8
+        assert model.module.foo.r["default"] == 8
+        assert model.module.foobar.r["default"] == 8
+        assert model.module.module.foo.r["default"] == 16
+        assert model.module.module.barfoo.r["default"] == 8
+
+    def test_rank_pattern_target_middle_inner(self, model):
+        config = LoraConfig(target_modules="all-linear", rank_pattern={"module.foo": 16})
+        model = get_peft_model(model, config).base_model.model
+        assert model.foo.r["default"] == 8
+        assert model.bar.r["default"] == 8
+        assert model.module.foo.r["default"] == 16
+        assert model.module.foobar.r["default"] == 8
+        assert model.module.module.foo.r["default"] == 16
+        assert model.module.module.barfoo.r["default"] == 8
+
+    def test_rank_pattern_target_middle_inner_different_ranks(self, model):
+        # same layers targeted as in previous test, but with different ranks
+        config = LoraConfig(target_modules="all-linear", rank_pattern={"^module.foo": 16, "^module.module.foo": 24})
+        model = get_peft_model(model, config).base_model.model
+        assert model.foo.r["default"] == 8
+        assert model.bar.r["default"] == 8
+        assert model.module.foo.r["default"] == 16
+        assert model.module.foobar.r["default"] == 8
+        assert model.module.module.foo.r["default"] == 24
+        assert model.module.module.barfoo.r["default"] == 8
+
+    def test_rank_pattern_target_outer_middle(self, model):
+        config = LoraConfig(target_modules="all-linear", rank_pattern={"^foo": 16, "^module.foo": 24})
+        model = get_peft_model(model, config).base_model.model
+        assert model.foo.r["default"] == 16
+        assert model.bar.r["default"] == 8
+        assert model.module.foo.r["default"] == 24
+        assert model.module.foobar.r["default"] == 8
+        assert model.module.module.foo.r["default"] == 8
+        assert model.module.module.barfoo.r["default"] == 8
+
+    def test_rank_pattern_target_outer_inner(self, model):
+        config = LoraConfig(target_modules="all-linear", rank_pattern={"^foo": 16, "module.module.foo": 24})
+        model = get_peft_model(model, config).base_model.model
+        assert model.foo.r["default"] == 16
+        assert model.bar.r["default"] == 8
+        assert model.module.foo.r["default"] == 8
+        assert model.module.foobar.r["default"] == 8
+        assert model.module.module.foo.r["default"] == 24
+        assert model.module.module.barfoo.r["default"] == 8
+
+    def test_rank_pattern_target_outer_inner_with_caret(self, model):
+        # same as before, but using the caret in the regex should also work
+        config = LoraConfig(target_modules="all-linear", rank_pattern={"^foo": 16, "^module.module.foo": 24})
+        model = get_peft_model(model, config).base_model.model
+        assert model.foo.r["default"] == 16
+        assert model.bar.r["default"] == 8
+        assert model.module.foo.r["default"] == 8
+        assert model.module.foobar.r["default"] == 8
+        assert model.module.module.foo.r["default"] == 24
+        assert model.module.module.barfoo.r["default"] == 8
+
+    def test_rank_pattern_target_outer_middle_inner_with_caret(self, model):
+        # indicate each layer with a different rank and use the caret in the regex
+        config = LoraConfig(
+            target_modules="all-linear", rank_pattern={"^foo": 16, "^module.foo": 24, "^module.module.foo": 32}
+        )
+        model = get_peft_model(model, config).base_model.model
+        assert model.foo.r["default"] == 16
+        assert model.bar.r["default"] == 8
+        assert model.module.foo.r["default"] == 24
+        assert model.module.foobar.r["default"] == 8
+        assert model.module.module.foo.r["default"] == 32
+        assert model.module.module.barfoo.r["default"] == 8
+
+    def test_rank_pattern_target_outer_middle_inner_with_caret_dict_order(self, model):
+        # same as before, but change the order of the rank_pattern dict
+        config = LoraConfig(
+            target_modules="all-linear", rank_pattern={"^module.module.foo": 32, "^module.foo": 24, "^foo": 16}
+        )
+        model = get_peft_model(model, config).base_model.model
+        assert model.foo.r["default"] == 16
+        assert model.bar.r["default"] == 8
+        assert model.module.foo.r["default"] == 24
+        assert model.module.foobar.r["default"] == 8
+        assert model.module.module.foo.r["default"] == 32
+        assert model.module.module.barfoo.r["default"] == 8
+
+    # below, we test all permutations for alpha_pattern of targeting outer, middle, and inner foo layers:
+    # these tests are analogous to the rank_pattern tests above
+
+    def test_alpha_pattern_target_all(self, model):
+        config = LoraConfig(target_modules="all-linear", alpha_pattern={"foo": 4})
+        model = get_peft_model(model, config).base_model.model
+        assert model.foo.scaling["default"] == 0.5
+        assert model.bar.scaling["default"] == 1.0
+        assert model.module.foo.scaling["default"] == 0.5
+        assert model.module.foobar.scaling["default"] == 1.0
+        assert model.module.module.foo.scaling["default"] == 0.5
+        assert model.module.module.barfoo.scaling["default"] == 1.0
+
+    def test_alpha_pattern_target_outer(self, model):
+        config = LoraConfig(target_modules="all-linear", alpha_pattern={"^foo": 4})
+        model = get_peft_model(model, config).base_model.model
+        assert model.foo.scaling["default"] == 0.5
+        assert model.bar.scaling["default"] == 1.0
+        assert model.module.foo.scaling["default"] == 1.0
+        assert model.module.foobar.scaling["default"] == 1.0
+        assert model.module.module.foo.scaling["default"] == 1.0
+        assert model.module.module.barfoo.scaling["default"] == 1.0
+
+    def test_alpha_pattern_target_middle(self, model):
+        config = LoraConfig(target_modules="all-linear", alpha_pattern={"^module.foo": 4})
+        model = get_peft_model(model, config).base_model.model
+        assert model.foo.scaling["default"] == 1.0
+        assert model.bar.scaling["default"] == 1.0
+        assert model.module.foo.scaling["default"] == 0.5
+        assert model.module.foobar.scaling["default"] == 1.0
+        assert model.module.module.foo.scaling["default"] == 1.0
+        assert model.module.module.barfoo.scaling["default"] == 1.0
+
+    def test_alpha_pattern_target_inner(self, model):
+        config = LoraConfig(target_modules="all-linear", alpha_pattern={"module.module.foo": 4})
+        model = get_peft_model(model, config).base_model.model
+        assert model.foo.scaling["default"] == 1.0
+        assert model.bar.scaling["default"] == 1.0
+        assert model.module.foo.scaling["default"] == 1.0
+        assert model.module.foobar.scaling["default"] == 1.0
+        assert model.module.module.foo.scaling["default"] == 0.5
+        assert model.module.module.barfoo.scaling["default"] == 1.0
+
+    def test_alpha_pattern_target_inner_with_caret(self, model):
+        # same as before, but using the caret in the regex should also work
+        config = LoraConfig(target_modules="all-linear", alpha_pattern={"^module.module.foo": 4})
+        model = get_peft_model(model, config).base_model.model
+        assert model.foo.scaling["default"] == 1.0
+        assert model.bar.scaling["default"] == 1.0
+        assert model.module.foo.scaling["default"] == 1.0
+        assert model.module.foobar.scaling["default"] == 1.0
+        assert model.module.module.foo.scaling["default"] == 0.5
+        assert model.module.module.barfoo.scaling["default"] == 1.0
+
+    def test_alpha_pattern_target_middle_inner(self, model):
+        config = LoraConfig(target_modules="all-linear", alpha_pattern={"module.foo": 4})
+        model = get_peft_model(model, config).base_model.model
+        assert model.foo.scaling["default"] == 1.0
+        assert model.bar.scaling["default"] == 1.0
+        assert model.module.foo.scaling["default"] == 0.5
+        assert model.module.foobar.scaling["default"] == 1.0
+        assert model.module.module.foo.scaling["default"] == 0.5
+        assert model.module.module.barfoo.scaling["default"] == 1.0
+
+    def test_alpha_pattern_target_middle_inner_different_alphas(self, model):
+        # same layers targeted as in previous test, but with different alphas
+        config = LoraConfig(target_modules="all-linear", alpha_pattern={"^module.foo": 4, "^module.module.foo": 2})
+        model = get_peft_model(model, config).base_model.model
+        assert model.foo.scaling["default"] == 1.0
+        assert model.bar.scaling["default"] == 1.0
+        assert model.module.foo.scaling["default"] == 0.5
+        assert model.module.foobar.scaling["default"] == 1.0
+        assert model.module.module.foo.scaling["default"] == 0.25
+        assert model.module.module.barfoo.scaling["default"] == 1.0
+
+    def test_alpha_pattern_target_outer_middle(self, model):
+        config = LoraConfig(target_modules="all-linear", alpha_pattern={"^foo": 4, "^module.foo": 2})
+        model = get_peft_model(model, config).base_model.model
+        assert model.foo.scaling["default"] == 0.5
+        assert model.bar.scaling["default"] == 1.0
+        assert model.module.foo.scaling["default"] == 0.25
+        assert model.module.foobar.scaling["default"] == 1.0
+        assert model.module.module.foo.scaling["default"] == 1.0
+        assert model.module.module.barfoo.scaling["default"] == 1.0
+
+    def test_alpha_pattern_target_outer_inner(self, model):
+        config = LoraConfig(target_modules="all-linear", alpha_pattern={"^foo": 4, "module.module.foo": 2})
+        model = get_peft_model(model, config).base_model.model
+        assert model.foo.scaling["default"] == 0.5
+        assert model.bar.scaling["default"] == 1.0
+        assert model.module.foo.scaling["default"] == 1.0
+        assert model.module.foobar.scaling["default"] == 1.0
+        assert model.module.module.foo.scaling["default"] == 0.25
+        assert model.module.module.barfoo.scaling["default"] == 1.0
+
+    def test_alpha_pattern_target_outer_inner_with_caret(self, model):
+        # same as before, but using the caret in the regex should also work
+        config = LoraConfig(target_modules="all-linear", alpha_pattern={"^foo": 4, "^module.module.foo": 2})
+        model = get_peft_model(model, config).base_model.model
+        assert model.foo.scaling["default"] == 0.5
+        assert model.bar.scaling["default"] == 1.0
+        assert model.module.foo.scaling["default"] == 1.0
+        assert model.module.foobar.scaling["default"] == 1.0
+        assert model.module.module.foo.scaling["default"] == 0.25
+        assert model.module.module.barfoo.scaling["default"] == 1.0
+
+    def test_alpha_pattern_target_outer_middle_inner_with_caret(self, model):
+        # indicate each layer with a different alpha and use the caret in the regex
+        config = LoraConfig(
+            target_modules="all-linear", alpha_pattern={"^foo": 4, "^module.foo": 2, "^module.module.foo": 1}
+        )
+        model = get_peft_model(model, config).base_model.model
+        assert model.foo.scaling["default"] == 0.5
+        assert model.bar.scaling["default"] == 1.0
+        assert model.module.foo.scaling["default"] == 0.25
+        assert model.module.foobar.scaling["default"] == 1.0
+        assert model.module.module.foo.scaling["default"] == 0.125
+        assert model.module.module.barfoo.scaling["default"] == 1.0
+
+    def test_alpha_pattern_target_outer_middle_inner_with_caret_dict_order(self, model):
+        # same as before, but change the order of the alpha_pattern dict
+        config = LoraConfig(
+            target_modules="all-linear", alpha_pattern={"^module.module.foo": 1, "^module.foo": 2, "^foo": 4}
+        )
+        model = get_peft_model(model, config).base_model.model
+        assert model.foo.scaling["default"] == 0.5
+        assert model.bar.scaling["default"] == 1.0
+        assert model.module.foo.scaling["default"] == 0.25
+        assert model.module.foobar.scaling["default"] == 1.0
+        assert model.module.module.foo.scaling["default"] == 0.125
+        assert model.module.module.barfoo.scaling["default"] == 1.0
diff --git a/tests/test_unilora.py b/tests/test_unilora.py
new file mode 100644
index 0000000..8eb1593
--- /dev/null
+++ b/tests/test_unilora.py
@@ -0,0 +1,260 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+import pytest
+import torch
+from safetensors.torch import load_file as safe_load_file
+from safetensors.torch import save_file as safe_save_file
+from torch import nn
+
+from peft import PeftModel, UniLoraConfig, convert_to_lora, get_peft_model, set_peft_model_state_dict
+
+
+class MLP(nn.Module):
+    def __init__(self, bias=True):
+        super().__init__()
+        self.relu = nn.ReLU()
+        self.lin0 = nn.Linear(10, 20, bias=bias)
+        self.lin1 = nn.Linear(20, 20, bias=bias)
+        self.lin2 = nn.Linear(20, 20, bias=bias)
+        self.lin3 = nn.Linear(20, 2, bias=bias)
+        self.sm = nn.LogSoftmax(dim=-1)
+
+    def forward(self, X):
+        X = self.lin0(X)
+        X = self.relu(X)
+        X = self.lin1(X)
+        X = self.relu(X)
+        X = self.lin2(X)
+        X = self.relu(X)
+        X = self.lin3(X)
+        X = self.sm(X)
+        return X
+
+
+def _unilora_config_accepts(name):
+    return name in UniLoraConfig.__dataclass_fields__
+
+
+def _make_unilora_config(**kwargs):
+    if "theta_d_length" not in kwargs:
+        kwargs["theta_d_length"] = 101
+    if "r" not in kwargs:
+        kwargs["r"] = 4
+    return UniLoraConfig(**kwargs)
+
+
+def _get_unilora_index_state(model):
+    return {
+        name: tensor.detach().cpu().clone() for name, tensor in model.state_dict().items() if "unilora_indices" in name
+    }
+
+
+class TestUniLora:
+    def get_mlp(self):
+        model = MLP()
+        return model
+
+    def test_unilora_parameters(self):
+        mlp = self.get_mlp()
+
+        # In the current implementation, `theta_d_length` effectively acts as the
+        # size of the shared parameter pool (codebook size).
+        # The values in `indices` are in the range [0, theta_d_length).
+        theta_d_length = 100
+        r = 4
+
+        config = _make_unilora_config(
+            target_modules=["lin0", "lin1", "lin3"],
+            theta_d_length=theta_d_length,
+            r=r,
+        )
+        mlp_unilora = get_peft_model(mlp, config)
+
+        theta_d = mlp_unilora.unilora_theta_d["default"]
+
+        # 1. Check theta_d (shared parameter pool)
+        assert theta_d.shape == (theta_d_length,)
+
+        # 2. Check Indices and Scales (formerly Logits and Norm)
+        # Indices should directly match the shape of the LoRA low-rank matrices
+
+        # lin0: (10 -> 20)
+        # indices_B: (out_features, r) -> (20, 4)
+        unilora_lin0_indices_B = mlp_unilora.lin0.unilora_indices_B["default"]
+        assert unilora_lin0_indices_B.shape == (mlp.lin0.out_features, config.r)
+
+        # scales_B should have the same shape as indices_B
+        unilora_lin0_scales_B = mlp_unilora.lin0.unilora_scales_B["default"]
+        assert unilora_lin0_scales_B.shape == (mlp.lin0.out_features, config.r)
+
+        # lin1: (20 -> 20)
+        # indices_A: (r, in_features) -> (4, 20)
+        unilora_lin1_indices_A = mlp_unilora.lin1.unilora_indices_A["default"]
+        assert unilora_lin1_indices_A.shape == (config.r, mlp.lin1.in_features)
+
+        # lin3: (20 -> 2)
+        unilora_lin3_indices_A = mlp_unilora.lin3.unilora_indices_A["default"]
+        assert unilora_lin3_indices_A.shape == (config.r, mlp.lin3.in_features)
+
+        # 3. Check parameter sharing
+        # Ensure that all layers reference the same underlying theta_d tensor
+        assert (
+            mlp_unilora.lin0.unilora_theta_d["default"].data_ptr()
+            == mlp_unilora.lin3.unilora_theta_d["default"].data_ptr()
+        )
+        assert mlp_unilora.lin1.unilora_theta_d["default"].data_ptr() == theta_d.data_ptr()
+
+        # 4. Forward pass test
+        input = torch.randn(5, 10)
+        output = mlp_unilora(input)
+        assert output.shape == (5, 2)
+
+    def test_proj_seed_deterministically_generates_indices(self):
+        config_kwargs = {
+            "target_modules": ["lin0", "lin1", "lin3"],
+            "theta_d_length": 53,
+            "r": 4,
+        }
+        model0 = get_peft_model(self.get_mlp(), _make_unilora_config(**config_kwargs, proj_seed=17))
+        model1 = get_peft_model(self.get_mlp(), _make_unilora_config(**config_kwargs, proj_seed=17))
+        model2 = get_peft_model(self.get_mlp(), _make_unilora_config(**config_kwargs, proj_seed=18))
+
+        indices0 = _get_unilora_index_state(model0)
+        indices1 = _get_unilora_index_state(model1)
+        indices2 = _get_unilora_index_state(model2)
+
+        assert indices0
+        assert indices0.keys() == indices1.keys() == indices2.keys()
+        for key in indices0:
+            torch.testing.assert_close(indices0[key], indices1[key])
+
+        assert any(not torch.equal(indices0[key], indices2[key]) for key in indices0)
+
+    def test_init_weights_false_changes_theta_d_initialization(self):
+        if not _unilora_config_accepts("init_weights"):
+            pytest.skip("UniLoraConfig does not expose init_weights yet.")
+
+        config_kwargs = {
+            "target_modules": ["lin0", "lin1"],
+            "theta_d_length": 47,
+            "r": 4,
+        }
+
+        torch.manual_seed(0)
+        default_model = get_peft_model(self.get_mlp(), _make_unilora_config(**config_kwargs))
+        torch.manual_seed(0)
+        random_model = get_peft_model(self.get_mlp(), _make_unilora_config(**config_kwargs, init_weights=False))
+
+        assert not torch.allclose(
+            default_model.unilora_theta_d["default"],
+            random_model.unilora_theta_d["default"],
+        )
+
+    def test_lora_conversion(self):
+        torch.manual_seed(0)
+        model = get_peft_model(
+            self.get_mlp(),
+            _make_unilora_config(target_modules=["lin0", "lin1"], theta_d_length=101, r=4),
+        ).eval()
+        assert model.supports_lora_conversion()
+
+        input = torch.randn(5, 10)
+        with torch.inference_mode():
+            output_unilora = model(input)
+
+        lora_config, state_dict = convert_to_lora(model, rank=4)
+
+        torch.manual_seed(0)
+        lora_model = get_peft_model(self.get_mlp(), lora_config).eval()
+        load_result = set_peft_model_state_dict(lora_model, state_dict)
+        assert not load_result.unexpected_keys
+
+        with torch.inference_mode():
+            output_lora = lora_model(input)
+
+        torch.testing.assert_close(output_unilora, output_lora, atol=1e-5, rtol=1e-5)
+
+    def test_zero_theta_d_has_zero_gradient(self):
+        torch.manual_seed(0)
+        model = get_peft_model(
+            self.get_mlp(),
+            _make_unilora_config(target_modules=["lin0"], theta_d_length=17, r=2),
+        )
+        theta_d = model.unilora_theta_d["default"]
+        with torch.no_grad():
+            theta_d.zero_()
+
+        input = torch.randn(5, 10)
+        loss = model(input).square().mean()
+        loss.backward()
+
+        assert theta_d.grad is not None
+        assert theta_d.grad.abs().sum().item() == 0.0
+
+    def test_default_initialization_has_nonzero_theta_d_gradient(self):
+        torch.manual_seed(0)
+        model = get_peft_model(
+            self.get_mlp(),
+            _make_unilora_config(target_modules=["lin0"], theta_d_length=17, r=2),
+        )
+
+        input = torch.randn(5, 10)
+        loss = model(input).square().mean()
+        loss.backward()
+
+        theta_d_grad = model.unilora_theta_d["default"].grad
+        assert theta_d_grad is not None
+        assert torch.isfinite(theta_d_grad).all()
+        assert theta_d_grad.abs().sum().item() > 0.0
+
+    def test_saved_indices_round_trip_when_enabled(self, tmp_path):
+        if not _unilora_config_accepts("save_indices"):
+            pytest.skip("UniLoraConfig does not expose save_indices yet.")
+
+        config = _make_unilora_config(
+            target_modules=["lin0", "lin1", "lin3"],
+            theta_d_length=59,
+            r=4,
+            save_indices=True,
+        )
+        model = get_peft_model(self.get_mlp(), config)
+        original_indices = _get_unilora_index_state(model)
+
+        save_path = tmp_path / "unilora-with-indices"
+        model.save_pretrained(save_path)
+
+        saved_tensors = safe_load_file(save_path / "adapter_model.safetensors")
+        saved_index_tensors = {name: tensor for name, tensor in saved_tensors.items() if "unilora_indices" in name}
+        assert saved_index_tensors
+
+        loaded = PeftModel.from_pretrained(self.get_mlp(), save_path)
+        loaded_indices = _get_unilora_index_state(loaded)
+        assert original_indices.keys() == loaded_indices.keys()
+        for key in original_indices:
+            torch.testing.assert_close(original_indices[key], loaded_indices[key])
+
+    def test_missing_theta_d_key_warns_on_load(self, tmp_path):
+        model = get_peft_model(
+            self.get_mlp(), _make_unilora_config(target_modules=["lin0", "lin1"], save_indices=True)
+        )
+        save_path = tmp_path / "unilora"
+        model.save_pretrained(save_path)
+
+        tensors = safe_load_file(save_path / "adapter_model.safetensors")
+        tensors.pop("base_model.unilora_theta_d")
+        safe_save_file(tensors, save_path / "adapter_model.safetensors")
+
+        with pytest.warns(UserWarning, match="unilora_theta_d"):
+            PeftModel.from_pretrained(self.get_mlp(), save_path)
diff --git a/tests/test_vblora.py b/tests/test_vblora.py
new file mode 100644
index 0000000..4a4801c
--- /dev/null
+++ b/tests/test_vblora.py
@@ -0,0 +1,269 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+import os
+
+import pytest
+import torch
+from accelerate.utils.imports import is_bf16_available
+from safetensors import safe_open
+from torch import nn
+
+from peft import PeftModel, VBLoRAConfig, get_peft_model
+
+
+class MLP(nn.Module):
+    def __init__(self, bias=True):
+        super().__init__()
+        self.relu = nn.ReLU()
+        self.lin0 = nn.Linear(10, 20, bias=bias)
+        self.lin1 = nn.Linear(20, 20, bias=bias)  # lin1 and lin2 have same shape
+        self.lin2 = nn.Linear(20, 20, bias=bias)
+        self.lin3 = nn.Linear(20, 2, bias=bias)
+        self.sm = nn.LogSoftmax(dim=-1)
+
+    def forward(self, X):
+        X = self.lin0(X)
+        X = self.relu(X)
+        X = self.lin1(X)
+        X = self.relu(X)
+        X = self.lin2(X)
+        X = self.relu(X)
+        X = self.lin3(X)
+        X = self.sm(X)
+        return X
+
+
+class TestVBLoRA:
+    def get_mlp(self):
+        model = MLP()
+        return model
+
+    def test_vblora_parameters(self):
+        mlp = self.get_mlp()
+        vector_length = 2
+        num_vectors = 10
+        config = VBLoRAConfig(
+            target_modules=["lin0", "lin1", "lin3"], vector_length=vector_length, num_vectors=num_vectors
+        )
+        mlp_vblora = get_peft_model(mlp, config)
+
+        vector_bank = mlp_vblora.vblora_vector_bank["default"]
+
+        vblora_lin0_logits_B = mlp_vblora.lin0.vblora_logits_B["default"]
+        assert vblora_lin0_logits_B.shape == (mlp.lin0.out_features // vector_length, config.r, num_vectors)
+
+        vblora_lin1_logits_A = mlp_vblora.lin1.vblora_logits_A["default"]
+        assert vblora_lin1_logits_A.shape == (config.r, mlp.lin1.in_features // vector_length, num_vectors)
+
+        vblora_lin3_logits_A = mlp_vblora.lin3.vblora_logits_A["default"]
+        assert vblora_lin3_logits_A.shape == (config.r, mlp.lin3.in_features // vector_length, num_vectors)
+
+        assert vector_bank.shape == (num_vectors, vector_length)
+
+        # test if the vector bank is shared across the layers
+        assert (
+            mlp_vblora.lin0.vblora_vector_bank["default"].data_ptr()
+            == mlp_vblora.lin3.vblora_vector_bank["default"].data_ptr()
+        )
+        assert mlp_vblora.lin1.vblora_vector_bank["default"].data_ptr() == vector_bank.data_ptr()
+
+        # should not raise
+        input = torch.randn(5, 10)
+        mlp_vblora(input)
+
+    def test_save_with_topk_weights(self, tmp_path):
+        torch.manual_seed(0)
+        mlp = self.get_mlp()
+        vector_length = 2
+        num_vectors = 10
+        topk = 2
+        config = VBLoRAConfig(
+            target_modules=["lin0", "lin3"],
+            topk=topk,
+            vector_length=vector_length,
+            num_vectors=num_vectors,
+            save_only_topk_weights=True,
+        )
+        mlp_vblora = get_peft_model(mlp, config)
+        save_path = tmp_path / "vblora"
+        mlp_vblora.save_pretrained(save_path)
+        assert os.path.exists(save_path / "adapter_model.safetensors")
+
+        adapter_model_dict = {}
+        with safe_open(save_path / "adapter_model.safetensors", framework="pt") as f:
+            for k in f.keys():
+                adapter_model_dict[k] = f.get_tensor(k)
+        assert "base_model.model.lin0.vblora_logits_A_topk_indices" in adapter_model_dict
+        assert "base_model.model.lin0.vblora_logits_A_topk_weights" in adapter_model_dict
+        assert "base_model.model.lin3.vblora_logits_B_topk_indices" in adapter_model_dict
+        assert "base_model.model.lin3.vblora_logits_B_topk_weights" in adapter_model_dict
+        assert "base_model.model.lin0.vblora_logits_A" not in adapter_model_dict
+        assert "base_model.model.lin3.vblora_logits_B" not in adapter_model_dict
+
+        assert adapter_model_dict["base_model.model.lin0.vblora_logits_B_topk_indices"].shape == (
+            mlp.lin0.out_features // vector_length,
+            config.r,
+            topk,
+        )
+        assert adapter_model_dict["base_model.model.lin0.vblora_logits_B_topk_weights"].shape == (
+            mlp.lin0.out_features // vector_length,
+            config.r,
+            topk - 1,
+        )
+        assert adapter_model_dict["base_model.model.lin3.vblora_logits_A_topk_indices"].shape == (
+            config.r,
+            mlp.lin3.in_features // vector_length,
+            topk,
+        )
+        assert adapter_model_dict["base_model.model.lin3.vblora_logits_A_topk_weights"].shape == (
+            config.r,
+            mlp.lin3.in_features // vector_length,
+            topk - 1,
+        )
+
+    @pytest.mark.parametrize("save_only_topk_weights", [True, False])
+    def test_save_load(self, save_only_topk_weights, tmp_path):
+        torch.manual_seed(0)
+        mlp = self.get_mlp()
+        config = VBLoRAConfig(
+            target_modules=["lin0", "lin1", "lin3"],
+            topk=2,
+            vector_length=2,
+            num_vectors=10,
+            save_only_topk_weights=save_only_topk_weights,
+        )
+        mlp_vblora = get_peft_model(mlp, config)
+        save_path = tmp_path / "vblora"
+        mlp_vblora.save_pretrained(save_path)
+        assert os.path.exists(save_path / "adapter_config.json")
+
+        del mlp
+        torch.manual_seed(0)  # make sure the base model has the same weights
+        mlp = self.get_mlp()
+        mlp_vblora_loaded = PeftModel.from_pretrained(mlp, save_path)
+
+        input = torch.randn(5, 10)
+        output = mlp_vblora(input)
+        output_loaded = mlp_vblora_loaded(input)
+        assert torch.allclose(output, output_loaded, atol=1e-8, rtol=1e-5)
+
+    def test_resume_training_model_with_topk_weights(self, tmp_path):
+        torch.manual_seed(1)
+        mlp = self.get_mlp()
+        config = VBLoRAConfig(
+            target_modules=["lin0", "lin1", "lin3"],
+            topk=2,
+            vector_length=2,
+            num_vectors=10,
+            save_only_topk_weights=True,
+        )
+        mlp_vblora = get_peft_model(mlp, config)
+        save_path = tmp_path / "vblora"
+        mlp_vblora.save_pretrained(save_path)
+
+        input = torch.randn(5, 10)
+        mlp_vblora.train()
+        # should not raise
+        mlp_vblora(input)
+
+        del mlp
+        torch.manual_seed(1)
+        mlp = self.get_mlp()
+        mlp_vblora_loaded = PeftModel.from_pretrained(mlp, save_path)
+        mlp_vblora_loaded.train()
+        msg = "Found infinity values in VB-LoRA logits. Ensure training was not resumed from a `save_only_topk_weights` model."
+        with pytest.raises(RuntimeError, match=msg):
+            mlp_vblora_loaded(input)
+
+    @pytest.mark.parametrize("dtype", [torch.float32, torch.float16, torch.bfloat16])
+    def test_vblora_dtypes(self, dtype):
+        mlp = self.get_mlp()
+        if dtype == torch.bfloat16:
+            if not is_bf16_available():
+                pytest.skip("bfloat16 not supported on this system, skipping the test")
+
+        config = VBLoRAConfig(
+            target_modules=["lin0", "lin1", "lin3"], vector_length=2, num_vectors=10, save_only_topk_weights=False
+        )
+        mlp_vblora = get_peft_model(mlp.to(dtype), config)
+        inputs = torch.randn(5, 10).to(dtype)
+        output = mlp_vblora(inputs)  # should not raise
+        assert output.dtype == dtype
+
+    def test_vblora_nb_savable_params_only_topk_weights(self):
+        mlp = self.get_mlp()
+        vector_length = 2
+        num_vectors = 10
+        topk = 2
+        r = 4
+        config = VBLoRAConfig(
+            target_modules=["lin0", "lin1"],
+            vector_length=vector_length,
+            num_vectors=num_vectors,
+            topk=topk,
+            r=r,
+            save_only_topk_weights=True,
+        )
+        mlp_vblora = get_peft_model(mlp, config)
+
+        mlp_vblora.lin3.requires_grad_(True)  # set lin3 to trainable
+
+        adapter_params, other_params = mlp_vblora.get_nb_savable_parameters()
+        factor = 0.25  # dtype of index is uint8
+        topk_indices_parameter = int(
+            (mlp.lin0.out_features + mlp.lin0.in_features + mlp.lin1.out_features + mlp.lin1.in_features)
+            / vector_length
+            * r
+            * topk
+            * factor
+        )
+        topk_weights_parameter = int(
+            (mlp.lin0.out_features + mlp.lin0.in_features + mlp.lin1.out_features + mlp.lin1.in_features)
+            / vector_length
+            * r
+            * (topk - 1)
+        )
+        vector_bank_parameter = num_vectors * vector_length
+        assert adapter_params == topk_indices_parameter + topk_weights_parameter + vector_bank_parameter
+        assert other_params == (mlp.lin3.in_features + 1) * mlp.lin3.out_features
+
+    def test_vblora_nb_savable_params_all_logits(self):
+        mlp = self.get_mlp()
+        vector_length = 2
+        num_vectors = 10
+        topk = 2
+        r = 4
+        config = VBLoRAConfig(
+            target_modules=["lin0", "lin1"],
+            vector_length=vector_length,
+            num_vectors=num_vectors,
+            topk=topk,
+            r=r,
+            save_only_topk_weights=False,
+        )
+        mlp_vblora = get_peft_model(mlp, config)
+
+        mlp_vblora.lin3.requires_grad_(True)  # set lin3 to trainable
+
+        adapter_params, other_params = mlp_vblora.get_nb_savable_parameters()
+        logits_parameter = int(
+            (mlp.lin0.out_features + mlp.lin0.in_features + mlp.lin1.out_features + mlp.lin1.in_features)
+            / vector_length
+            * r
+            * num_vectors
+        )
+        vector_bank_parameter = num_vectors * vector_length
+        assert adapter_params == logits_parameter + vector_bank_parameter
+        assert other_params == (mlp.lin3.in_features + 1) * mlp.lin3.out_features
diff --git a/tests/test_velora.py b/tests/test_velora.py
new file mode 100644
index 0000000..84b4d1c
--- /dev/null
+++ b/tests/test_velora.py
@@ -0,0 +1,343 @@
+# Copyright 2026-present the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+
+import copy
+
+import pytest
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from peft import LoraConfig, PeftType, VeloraConfig, get_peft_model
+from peft.tuners.lora import VeloraConfig as LoraVeloraConfig
+from peft.tuners.lora.velora import (
+    VeloraFunction,
+    _compress_activations,
+    _normalize_projection,
+    _reconstruct_activations,
+    _reshape_to_grouped_subtokens,
+)
+from peft.utils import get_peft_model_state_dict
+
+
+class MLP(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.lin0 = nn.Linear(16, 32)
+        self.lin1 = nn.Linear(32, 16)
+
+    def forward(self, x):
+        return self.lin1(torch.relu(self.lin0(x)))
+
+
+class SingleLinear(nn.Module):
+    def __init__(self, in_features=128, out_features=64, bias=False):
+        super().__init__()
+        self.lin = nn.Linear(in_features, out_features, bias=bias)
+
+    def forward(self, x):
+        return self.lin(x)
+
+
+def _saved_tensor_bytes(loss_factory) -> int:
+    saved_bytes = 0
+
+    def pack_hook(tensor):
+        nonlocal saved_bytes
+        saved_bytes += tensor.numel() * tensor.element_size()
+        return tensor
+
+    def unpack_hook(tensor):
+        return tensor
+
+    with torch.autograd.graph.saved_tensors_hooks(pack_hook, unpack_hook):
+        loss = loss_factory()
+    loss.backward()
+    return saved_bytes
+
+
+def _make_velora_lora_config(
+    *,
+    target_modules,
+    r,
+    velora_scale=1.0,
+    init_type="batch_average_once",
+    num_groups=32,
+    lora_alpha=None,
+    init_lora_weights=True,
+    velora_config_cls=VeloraConfig,
+):
+    kwargs = {
+        "target_modules": target_modules,
+        "r": r,
+        "velora_config": velora_config_cls(
+            scale=velora_scale,
+            init_type=init_type,
+            num_groups=num_groups,
+        ),
+    }
+    if lora_alpha is not None:
+        kwargs["lora_alpha"] = lora_alpha
+    if init_lora_weights is not True:
+        kwargs["init_lora_weights"] = init_lora_weights
+    return LoraConfig(**kwargs)
+
+
+def test_velora_config_alias_matches_lora_module_config():
+    torch.manual_seed(0)
+    lora_model = get_peft_model(
+        copy.deepcopy(MLP()),
+        _make_velora_lora_config(
+            target_modules=["lin0"],
+            r=4,
+            lora_alpha=8,
+            velora_scale=1.0,
+            init_type="random",
+            num_groups=8,
+            velora_config_cls=VeloraConfig,
+        ),
+    )
+
+    torch.manual_seed(0)
+    alias_model = get_peft_model(
+        copy.deepcopy(MLP()),
+        _make_velora_lora_config(
+            target_modules=["lin0"],
+            r=4,
+            lora_alpha=8,
+            velora_scale=1.0,
+            init_type="random",
+            num_groups=8,
+            velora_config_cls=LoraVeloraConfig,
+        ),
+    )
+
+    lora_config = lora_model.peft_config["default"]
+    alias_config = alias_model.peft_config["default"]
+
+    assert lora_config.peft_type == PeftType.LORA
+    assert alias_config.peft_type == PeftType.LORA
+    assert lora_config.velora_config is not None
+    assert alias_config.velora_config is not None
+    assert lora_config.velora_config.num_groups == alias_config.velora_config.num_groups == 8
+    assert lora_config.velora_config.init_type == alias_config.velora_config.init_type == "random"
+    assert lora_config.velora_config.scale == alias_config.velora_config.scale == 1.0
+
+    lora_state = get_peft_model_state_dict(lora_model)
+    alias_state = get_peft_model_state_dict(alias_model)
+
+    assert lora_state.keys() == alias_state.keys()
+    for key in lora_state:
+        assert torch.equal(lora_state[key], alias_state[key]), f"Mismatch for {key}"
+
+
+def test_velora_supports_non_divisible_groups():
+    model = MLP()
+    config = _make_velora_lora_config(target_modules=["lin0"], r=4, velora_scale=1.0, num_groups=7)
+
+    model = get_peft_model(model, config)
+    layer = model.base_model.model.lin0
+
+    assert layer.lora_velora_embed["default"].shape == (3,)
+
+    x = torch.randn(2, 16)
+    model.train()
+    output = model(x)
+    output.sum().backward()
+
+    assert output.shape == (2, 16)
+    assert layer.lora_A["default"].weight.grad is not None
+
+
+def test_velora_grouping_pads_remainder_features():
+    x = torch.arange(10, dtype=torch.float32).reshape(2, 5)
+    grouped = _reshape_to_grouped_subtokens(x, num_groups=3)
+
+    expected = torch.tensor(
+        [
+            [[0, 1], [2, 3], [4, 0]],
+            [[5, 6], [7, 8], [9, 0]],
+        ],
+        dtype=torch.float32,
+    )
+    assert torch.equal(grouped, expected)
+
+    embed = torch.tensor([1.0, 0.0])
+    compressed = _compress_activations(x, embed, num_groups=3)
+    reconstructed = _reconstruct_activations(compressed, embed, in_features=5, velora_scale=1.0)
+
+    assert compressed.shape == (2, 3)
+    assert reconstructed.shape == x.shape
+
+
+def test_reshape_to_grouped_subtokens_pads_non_divisible_input_dim_and_velora_autograd():
+    x = torch.arange(12, dtype=torch.float32).reshape(2, 2, 3)
+    grouped = _reshape_to_grouped_subtokens(x, num_groups=2)
+
+    expected = torch.tensor(
+        [
+            [[0, 1], [2, 0]],
+            [[3, 4], [5, 0]],
+            [[6, 7], [8, 0]],
+            [[9, 10], [11, 0]],
+        ],
+        dtype=torch.float32,
+    )
+
+    assert grouped.shape == (4, 2, 2)
+    assert torch.equal(grouped, expected)
+
+    x = x.detach().requires_grad_(True)
+    weight = (torch.arange(15, dtype=torch.float32).reshape(5, 3) / 10).requires_grad_(True)
+    bias = (torch.arange(5, dtype=torch.float32) / 10).requires_grad_(True)
+    embed = _normalize_projection(torch.tensor([1.0, 2.0]))
+
+    output = VeloraFunction.apply(x, weight, bias, embed, 2, 0.5)
+    assert torch.allclose(output, F.linear(x, weight, bias))
+
+    output.sum().backward()
+
+    assert x.grad is not None
+    assert x.grad.shape == x.shape
+    assert weight.grad is not None
+    assert weight.grad.shape == weight.shape
+    assert bias.grad is not None
+    assert bias.grad.shape == bias.shape
+
+
+def _expected_batch_average_embed(x: torch.Tensor, num_groups: int, target: torch.Tensor) -> torch.Tensor:
+    subtokens = _reshape_to_grouped_subtokens(x, num_groups)
+    embed = _normalize_projection(subtokens.reshape(-1, subtokens.shape[-1]).mean(dim=0))
+    return embed.to(target)
+
+
+@pytest.mark.parametrize(
+    "init_type, updates_every_forward",
+    [
+        ("batch_average_once", False),
+        ("batch_average", True),
+    ],
+)
+def test_velora_batch_average_update_policy(init_type, updates_every_forward):
+    torch.manual_seed(0)
+    model = get_peft_model(
+        MLP(),
+        _make_velora_lora_config(
+            target_modules=["lin0"],
+            r=4,
+            velora_scale=1.0,
+            init_type=init_type,
+            num_groups=8,
+        ),
+    )
+    layer = model.base_model.model.lin0
+
+    x0 = torch.randn(2, 16)
+    model.train()
+    _ = model(x0)
+
+    expected0 = _expected_batch_average_embed(x0, num_groups=8, target=layer.lora_velora_embed["default"])
+    assert layer.lora_velora_initialized["default"] is True
+    assert torch.allclose(layer.lora_velora_embed["default"], expected0, atol=1e-6, rtol=1e-5)
+
+    stored_embed = layer.lora_velora_embed["default"].clone()
+    x1 = torch.randn(2, 16) + 5
+    _ = model(x1)
+
+    if updates_every_forward:
+        expected1 = _expected_batch_average_embed(x1, num_groups=8, target=layer.lora_velora_embed["default"])
+        assert torch.allclose(layer.lora_velora_embed["default"], expected1, atol=1e-6, rtol=1e-5)
+        assert not torch.allclose(layer.lora_velora_embed["default"], stored_embed, atol=1e-6, rtol=1e-5)
+    else:
+        assert torch.allclose(layer.lora_velora_embed["default"], stored_embed, atol=1e-6, rtol=1e-5)
+
+
+def test_velora_reduces_saved_activation_memory_vs_vanilla_lora():
+    torch.manual_seed(0)
+    base_model = SingleLinear()
+    lora_model = get_peft_model(
+        copy.deepcopy(base_model),
+        LoraConfig(target_modules=["lin"], r=8, lora_alpha=8, init_lora_weights=False),
+    )
+    velora_model = get_peft_model(
+        copy.deepcopy(base_model),
+        _make_velora_lora_config(
+            target_modules=["lin"],
+            r=8,
+            lora_alpha=8,
+            init_lora_weights=False,
+            velora_scale=1.0,
+            init_type="random",
+            num_groups=32,
+        ),
+    )
+
+    target = torch.randn(8, 4, 64)
+    lora_model.train()
+    velora_model.train()
+
+    def make_loss(model, x):
+        output = model(x)
+        return (output - target).pow(2).mean()
+
+    x_lora = torch.randn(8, 4, 128, requires_grad=True)
+    x_velora = x_lora.detach().clone().requires_grad_(True)
+
+    lora_saved_bytes = _saved_tensor_bytes(lambda: make_loss(lora_model, x_lora))
+    velora_saved_bytes = _saved_tensor_bytes(lambda: make_loss(velora_model, x_velora))
+    assert velora_saved_bytes < lora_saved_bytes
+
+
+def test_velora_backward_matches_manual_reconstruction():
+    torch.manual_seed(0)
+    model = get_peft_model(
+        SingleLinear(in_features=16, out_features=10, bias=False),
+        _make_velora_lora_config(
+            target_modules=["lin"],
+            r=4,
+            lora_alpha=2,
+            velora_scale=0.5,
+            init_type="random",
+            num_groups=4,
+        ),
+    )
+    layer = model.base_model.model.lin
+
+    embed = _normalize_projection(torch.tensor([1.0, 2.0, 3.0, 4.0]))
+    layer.lora_velora_embed["default"] = embed.to(layer.lora_velora_embed["default"])
+    layer.lora_velora_initialized["default"] = True
+    with torch.no_grad():
+        layer.lora_A["default"].weight.copy_(torch.arange(64, dtype=torch.float32).reshape(4, 16) / 100)
+        layer.lora_B["default"].weight.copy_(torch.arange(40, dtype=torch.float32).reshape(10, 4) / 50)
+
+    x = torch.randn(2, 3, 16, requires_grad=True)
+    grad_output = torch.randn(2, 3, 10)
+
+    model.train()
+    output = model(x)
+    output.backward(grad_output)
+
+    # Compress the input activations as per equation (1) in the original paper
+    compressed = _compress_activations(x.detach(), embed.to(x.dtype), num_groups=4)
+
+    # Reconstruct the input activations during the backwards pass as per equation (2) in the original paper
+    reconstructed = _reconstruct_activations(compressed, embed.to(x.dtype), in_features=16, velora_scale=0.5)
+
+    # Original forward pass using original input activation
+    grad_output_2d = grad_output.reshape(-1, 10)
+    scaling = layer.scaling["default"]
+    lora_A_weight = layer.lora_A["default"].weight.detach()
+    lora_B_weight = layer.lora_B["default"].weight.detach()
+    after_A = F.linear(x.detach(), lora_A_weight).reshape(-1, lora_A_weight.shape[0])
+
+    # VeLoRA approximates the LoRA A gradient with the reconstructed input X_hat
+    # instead of the original input X:
+    # dL/dW_A = (scaling * dL/dY @ W_B)^T @ X_hat
+    expected_grad_lora_A = ((grad_output_2d * scaling) @ lora_B_weight).transpose(0, 1) @ reconstructed
+    expected_grad_lora_B = grad_output_2d.transpose(0, 1) @ after_A * scaling
+
+    assert layer.base_layer.weight.grad is None
+    assert torch.allclose(layer.lora_A["default"].weight.grad, expected_grad_lora_A, atol=1e-6, rtol=1e-5)
+    assert torch.allclose(layer.lora_B["default"].weight.grad, expected_grad_lora_B, atol=1e-6, rtol=1e-5)
diff --git a/tests/test_vera.py b/tests/test_vera.py
new file mode 100644
index 0000000..ea74e48
--- /dev/null
+++ b/tests/test_vera.py
@@ -0,0 +1,242 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+# This test file is for tests specific to VeRA, since VeRA has some specific challenges due to the shared weights.
+
+import os
+
+import pytest
+import torch
+from accelerate.utils.imports import is_bf16_available
+from safetensors import safe_open
+from torch import nn
+
+from peft import PeftModel, VeraConfig, get_peft_model
+
+
+class MLP(nn.Module):
+    def __init__(self, bias=True):
+        super().__init__()
+        self.relu = nn.ReLU()
+        self.lin0 = nn.Linear(10, 20, bias=bias)
+        self.lin1 = nn.Linear(20, 20, bias=bias)  # lin1 and lin2 have same shape
+        self.lin2 = nn.Linear(20, 20, bias=bias)
+        self.lin3 = nn.Linear(20, 2, bias=bias)
+        self.sm = nn.LogSoftmax(dim=-1)
+
+    def forward(self, X):
+        X = self.lin0(X)
+        X = self.relu(X)
+        X = self.lin1(X)
+        X = self.relu(X)
+        X = self.lin2(X)
+        X = self.relu(X)
+        X = self.lin3(X)
+        X = self.sm(X)
+        return X
+
+
+class TestVera:
+    @pytest.fixture
+    def mlp(self):
+        torch.manual_seed(0)
+        model = MLP()
+        return model
+
+    @pytest.fixture
+    def mlp_same_prng(self, mlp):
+        torch.manual_seed(0)
+
+        config = VeraConfig(target_modules=["lin1", "lin2"], init_weights=False)
+        # creates a default VeRA adapter
+        peft_model = get_peft_model(mlp, config)
+        config2 = VeraConfig(target_modules=["lin1", "lin2"], init_weights=False)
+        peft_model.add_adapter("other", config2)
+        return peft_model
+
+    def test_multiple_adapters_same_prng_weights(self, mlp_same_prng):
+        # we can have multiple adapters with the same prng key, in which case the weights should be shared
+        assert (
+            mlp_same_prng.base_model.model.lin1.vera_A["default"]
+            is mlp_same_prng.base_model.model.lin1.vera_A["other"]
+        )
+        assert (
+            mlp_same_prng.base_model.model.lin1.vera_B["default"]
+            is mlp_same_prng.base_model.model.lin1.vera_B["other"]
+        )
+        assert (
+            mlp_same_prng.base_model.model.lin2.vera_A["default"]
+            is mlp_same_prng.base_model.model.lin2.vera_A["other"]
+        )
+        assert (
+            mlp_same_prng.base_model.model.lin2.vera_B["default"]
+            is mlp_same_prng.base_model.model.lin2.vera_B["other"]
+        )
+
+        input = torch.randn(5, 10)
+        mlp_same_prng.set_adapter("default")
+        output_default = mlp_same_prng(input)
+        mlp_same_prng.set_adapter("other")
+        output_other = mlp_same_prng(input)
+        assert not torch.allclose(output_default, output_other, atol=1e-3, rtol=1e-3)
+
+    def test_multiple_adapters_different_prng_raises(self):
+        # we cannot have multiple adapters with different prng keys
+        model = MLP()
+        config = VeraConfig(target_modules=["lin1", "lin2"], init_weights=False)
+        # creates a default VeRA adapter
+        peft_model = get_peft_model(model, config)
+        config2 = VeraConfig(target_modules=["lin1", "lin2"], init_weights=False, projection_prng_key=123)
+
+        msg = (
+            r"Vera PRNG initialisation key must be the same for all adapters. Got config.projection_prng_key=123 but "
+            r"previous config had 0"
+        )
+        with pytest.raises(ValueError, match=msg):
+            peft_model.add_adapter("other", config2)
+
+    def test_multiple_adapters_save_load_save_projection_false(self, mlp, tmp_path):
+        # check saving and loading works with multiple adapters without saved projection weights
+        torch.manual_seed(1)
+        config = VeraConfig(target_modules=["lin1", "lin2"], init_weights=False, save_projection=False)
+        # creates a default VeRA adapter
+        peft_model = get_peft_model(mlp, config, adapter_name="first")
+        config2 = VeraConfig(target_modules=["lin1", "lin2"], init_weights=False, save_projection=False)
+        peft_model.add_adapter("second", config2)
+
+        input = torch.randn(5, 10)
+        peft_model.set_adapter("first")
+        output_first = peft_model(input)
+        peft_model.set_adapter("second")
+        output_second = peft_model(input)
+
+        # sanity check
+        assert not torch.allclose(output_first, output_second, atol=1e-3, rtol=1e-3)
+
+        save_path = tmp_path / "vera"
+        peft_model.save_pretrained(save_path)
+        assert os.path.exists(save_path / "first" / "adapter_config.json")
+        assert os.path.exists(save_path / "second" / "adapter_config.json")
+
+        torch.manual_seed(0)
+        mlp = MLP()
+        peft_model = PeftModel.from_pretrained(mlp, save_path / "first", adapter_name="first")
+        peft_model.load_adapter(save_path / "second", "second")
+
+        peft_model.set_adapter("first")
+        output_first_loaded = peft_model(input)
+        peft_model.set_adapter("second")
+        output_second_loaded = peft_model(input)
+
+        assert torch.allclose(output_first, output_first_loaded, atol=1e-3, rtol=1e-3)
+        assert torch.allclose(output_second, output_second_loaded, atol=1e-3, rtol=1e-3)
+
+    def test_multiple_adapters_save_projection_false_contains_no_vera_A_vera_B(self, mlp, tmp_path):
+        torch.manual_seed(1)
+        config = VeraConfig(target_modules=["lin1", "lin2"], init_weights=False, save_projection=False)
+        # creates a default VeRA adapter
+        peft_model = get_peft_model(mlp, config, adapter_name="first")
+        config2 = VeraConfig(target_modules=["lin1", "lin2"], init_weights=False, save_projection=False)
+        peft_model.add_adapter("second", config2)
+
+        save_path = tmp_path / "vera"
+        peft_model.save_pretrained(save_path)
+
+        sd_default = {}
+        with safe_open(save_path / "first" / "adapter_model.safetensors", framework="pt", device="cpu") as f:
+            for key in f.keys():
+                sd_default[key] = f.get_tensor(key)
+
+        assert not any("vera_A" in key for key in sd_default)
+        assert not any("vera_B" in key for key in sd_default)
+
+        sd_other = {}
+        with safe_open(save_path / "second" / "adapter_model.safetensors", framework="pt", device="cpu") as f:
+            for key in f.keys():
+                sd_other[key] = f.get_tensor(key)
+
+        assert not any("vera_A" in key for key in sd_other)
+        assert not any("vera_B" in key for key in sd_other)
+
+    def test_vera_A_vera_B_share_memory(self, mlp_same_prng):
+        vera_A = mlp_same_prng.vera_A["default"]
+        vera_B = mlp_same_prng.vera_B["default"]
+
+        # these tensors should share the same data
+        assert vera_A.data_ptr() == mlp_same_prng.base_model.model.lin1.vera_A["default"].data_ptr()
+        assert vera_B.data_ptr() == mlp_same_prng.base_model.model.lin1.vera_B["default"].data_ptr()
+        assert vera_A.data_ptr() == mlp_same_prng.base_model.model.lin2.vera_A["default"].data_ptr()
+        assert vera_B.data_ptr() == mlp_same_prng.base_model.model.lin2.vera_B["default"].data_ptr()
+        # sanity check: these tensors shouldn't share the same data
+        assert vera_A.data_ptr() != vera_B.data_ptr()
+
+    def test_vera_lambda_dont_share_memory(self, mlp_same_prng):
+        # sanity check: these tensors shouldn't share the same data
+        assert (
+            mlp_same_prng.base_model.model.lin1.vera_lambda_b["default"].data_ptr()
+            != mlp_same_prng.base_model.model.lin1.vera_lambda_b["other"].data_ptr()
+        )
+        assert (
+            mlp_same_prng.base_model.model.lin1.vera_lambda_b["default"].data_ptr()
+            != mlp_same_prng.base_model.model.lin2.vera_lambda_b["default"].data_ptr()
+        )
+        assert (
+            mlp_same_prng.base_model.model.lin1.vera_lambda_b["other"].data_ptr()
+            != mlp_same_prng.base_model.model.lin2.vera_lambda_b["other"].data_ptr()
+        )
+        assert (
+            mlp_same_prng.base_model.model.lin1.vera_lambda_d["default"].data_ptr()
+            != mlp_same_prng.base_model.model.lin1.vera_lambda_d["other"].data_ptr()
+        )
+        assert (
+            mlp_same_prng.base_model.model.lin1.vera_lambda_d["default"].data_ptr()
+            != mlp_same_prng.base_model.model.lin2.vera_lambda_d["default"].data_ptr()
+        )
+        assert (
+            mlp_same_prng.base_model.model.lin1.vera_lambda_d["other"].data_ptr()
+            != mlp_same_prng.base_model.model.lin2.vera_lambda_d["other"].data_ptr()
+        )
+
+    def test_vera_different_shapes(self, mlp):
+        config = VeraConfig(target_modules=["lin0", "lin3"], init_weights=False)
+        mlp_different_shapes = get_peft_model(mlp, config)
+
+        vera_A = mlp_different_shapes.vera_A["default"]
+        vera_B = mlp_different_shapes.vera_B["default"]
+
+        # sanity check
+        assert mlp.lin0.base_layer.weight.shape != mlp.lin3.base_layer.weight.shape
+
+        # lin0 has the largest output dimension, lin3 has the largest input dimension
+        # vera_A should have the shape of (rank, largest_in), vera_B should have the shape of (largest_out, rank)
+        assert vera_A.shape == (config.r, mlp.lin3.in_features)
+        assert vera_B.shape == (mlp.lin0.out_features, config.r)
+
+        # should not raise
+        input = torch.randn(5, 10)
+        mlp_different_shapes(input)
+
+    @pytest.mark.parametrize("dtype", [torch.float32, torch.float16, torch.bfloat16])
+    def test_vera_dtypes(self, dtype):
+        if dtype == torch.bfloat16:
+            # skip if bf16 is not supported on hardware, see #1872
+            if not is_bf16_available():
+                pytest.skip("bfloat16 not supported on this system, skipping the test")
+
+        model = MLP().to(dtype)
+        config = VeraConfig(target_modules=["lin1", "lin2"], init_weights=False)
+        peft_model = get_peft_model(model, config)
+        inputs = torch.randn(5, 10).to(dtype)
+        output = peft_model(inputs)  # should not raise
+        assert output.dtype == dtype
diff --git a/tests/test_vision_models.py b/tests/test_vision_models.py
new file mode 100644
index 0000000..930df36
--- /dev/null
+++ b/tests/test_vision_models.py
@@ -0,0 +1,160 @@
+# Copyright 2024-present the HuggingFace Inc. 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.
+
+# This is not a full on test suite of vision models, since we already run many tests on dummy models with Conv2d layers
+# and on stable diffusion models. Instead, this file contains specific tests for bugs that have been found in the past.
+import gc
+
+import numpy as np
+import pytest
+import torch
+from accelerate.utils.memory import clear_device_cache
+from safetensors.torch import load_file
+from transformers import (
+    AutoImageProcessor,
+    AutoModelForImageClassification,
+    AutoProcessor,
+    LlavaForConditionalGeneration,
+)
+
+from peft import (
+    BOFTConfig,
+    HRAConfig,
+    LoHaConfig,
+    LoKrConfig,
+    LoraConfig,
+    OFTConfig,
+    PeftModel,
+    PrefixTuningConfig,
+    get_peft_model,
+)
+
+from .testing_utils import load_cat_image
+
+
+CONFIGS = {
+    "lora": LoraConfig(target_modules=["convolution"], modules_to_save=["classifier", "normalization"]),
+    "loha": LoHaConfig(target_modules=["convolution"], modules_to_save=["classifier", "normalization"]),
+    "lokr": LoKrConfig(target_modules=["convolution"], modules_to_save=["classifier", "normalization"]),
+    "oft": OFTConfig(
+        r=1, oft_block_size=0, target_modules=["convolution"], modules_to_save=["classifier", "normalization"]
+    ),
+    "hra": HRAConfig(target_modules=["convolution"], modules_to_save=["classifier", "normalization"]),
+    # Cannot target multiple layers with BOFT because some convolutional kernel dimensions vary and there is no common
+    # denominator for the boft_block_size except 1, but using 1 results in an error in the fbd_cuda kernel:
+    # > Error in forward_fast_block_diag_cuda_kernel: an illegal memory access was encountered
+    "boft": BOFTConfig(
+        target_modules=["0.layer.0.convolution"], modules_to_save=["classifier", "normalization"], boft_block_size=2
+    ),
+}
+
+
+# Ensure that models like Llava that pass past_key_values automatically do not fail, see #1938
+class TestPastKV:
+    def test_past_kv(self):
+        model_id = "peft-internal-testing/tiny-LlavaForConditionalGeneration"
+        prompt = "USER: <image>\nWhat are these?\nASSISTANT:"
+
+        # prepare model and inputs
+        model = LlavaForConditionalGeneration.from_pretrained(
+            model_id,
+            low_cpu_mem_usage=True,
+        )
+        processor = AutoProcessor.from_pretrained(model_id)
+        raw_image = np.random.randint(0, 255, (224, 224, 3), dtype=np.uint8)
+        inputs = processor(text=prompt, images=raw_image, return_tensors="pt")
+
+        # get peft model
+        peft_config = PrefixTuningConfig(task_type="CAUSAL_LM", num_virtual_tokens=20)
+        model = get_peft_model(model, peft_config)
+        # check that this does not raise
+        model(**inputs, output_hidden_states=True)
+
+
+class TestResnet:
+    # saftensors version of the hf-internal-testing model
+    model_id = "peft-internal-testing/tiny-random-ResNetForImageClassification"
+    cat_image = load_cat_image()  # for caching
+
+    @pytest.fixture(autouse=True)
+    def teardown(self):
+        r"""
+        Efficient mechanism to free GPU memory after each test. Based on
+        https://github.com/huggingface/transformers/issues/21094
+        """
+        clear_device_cache(garbage_collection=True)
+        gc.collect()
+
+    @pytest.fixture(scope="class")
+    def image_processor(self):
+        image_processor = AutoImageProcessor.from_pretrained(self.model_id)
+        return image_processor
+
+    @pytest.fixture(scope="class")
+    def data(self, image_processor):
+        return image_processor(self.cat_image, return_tensors="pt")
+
+    @pytest.mark.parametrize("config", CONFIGS.values(), ids=CONFIGS.keys())
+    def test_model_with_batchnorm_reproducibility(self, config, tmp_path, data):
+        # see 1732
+        torch.manual_seed(0)
+        model = AutoModelForImageClassification.from_pretrained(self.model_id)
+        model = get_peft_model(model, config)
+
+        # record outputs before training
+        model.eval()
+        with torch.inference_mode():
+            output_before = model(**data)
+        model.train()
+
+        # train the model
+        optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3)
+        batch_size = 4
+        max_steps = 5 * batch_size
+        labels = torch.zeros(1, 3)
+        labels[0, 1] = 1
+        for i in range(0, max_steps, batch_size):
+            optimizer.zero_grad()
+            outputs = model(**data, labels=labels)
+            loss = outputs.loss
+            loss.backward()
+            optimizer.step()
+
+        # record outputs after training
+        model.eval()
+        with torch.inference_mode():
+            output_after = model(**data)
+        assert torch.isfinite(output_after.logits).all()
+        atol, rtol = 1e-4, 1e-4
+        # sanity check: model was updated
+        assert not torch.allclose(output_before.logits, output_after.logits, atol=atol, rtol=rtol)
+
+        # check saving the model and loading it
+        model.save_pretrained(tmp_path)
+        del model
+
+        torch.manual_seed(0)
+        model = AutoModelForImageClassification.from_pretrained(self.model_id)
+        model = PeftModel.from_pretrained(model, tmp_path).eval()
+        with torch.inference_mode():
+            output_loaded = model(**data)
+        assert torch.allclose(output_after.logits, output_loaded.logits, atol=atol, rtol=rtol)
+
+        # ensure that the checkpoint file contains the buffers
+        model_running_mean = len([k for k in model.state_dict().keys() if "running_mean" in k])
+        state_dict = load_file(tmp_path / "adapter_model.safetensors")
+        checkpoint_running_mean = len([k for k in state_dict.keys() if "running_mean" in k])
+        # note that the model has twice as many "running_mean", as there is one copy per ModulesToSaveWrapper, we need
+        # to multiply by 2 to get the same number
+        assert model_running_mean == checkpoint_running_mean * 2
diff --git a/tests/test_xlora.py b/tests/test_xlora.py
new file mode 100644
index 0000000..d14ff74
--- /dev/null
+++ b/tests/test_xlora.py
@@ -0,0 +1,480 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+
+import os
+from functools import wraps
+
+import huggingface_hub
+import pytest
+import torch
+from safetensors.torch import load_file
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from peft import LoraConfig, PeftType, TaskType, XLoraConfig, get_peft_model
+from peft.peft_model import PeftModel
+from peft.tuners.xlora.layer import XLoraLayer
+from peft.utils import infer_device
+
+from .testing_utils import hub_online_once
+
+
+def flaky(num_tries: int):
+    """Decorator for test functions that are flaky"""
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            for _ in range(num_tries):
+                try:
+                    return func(*args, **kwargs)
+                except AssertionError as e:
+                    print(f"Failed test {func.__name__} with error: {e}")
+                    continue
+            raise AssertionError(f"Failed test {func.__name__} after {num_tries} tries")
+
+        return wrapper
+
+    return decorator
+
+
+class TestXlora:
+    torch_device = infer_device()
+
+    model_id = "peft-internal-testing/tiny-random-OPTForCausalLM"
+    num_loras = 4
+
+    @pytest.fixture
+    def base_model(self):
+        with hub_online_once(self.model_id):
+            model = AutoModelForCausalLM.from_pretrained(self.model_id)
+            yield model
+
+    @pytest.fixture(scope="class")
+    def lora_dir(self, tmp_path_factory):
+        return tmp_path_factory.mktemp("lora")
+
+    @pytest.fixture(scope="class")
+    def lora_embedding_dir(self, tmp_path_factory):
+        return tmp_path_factory.mktemp("lora_embedding")
+
+    @pytest.fixture(scope="class")
+    def saved_lora_adapters(self, lora_dir):
+        file_names = []
+
+        lora_configs = [
+            LoraConfig(task_type="CAUSAL_LM", target_modules=["q_proj", "v_proj"], init_lora_weights=False)
+            for _ in range(self.num_loras)
+        ]
+        # have 1 LoRA with different target modules
+        lora_configs[-1] = LoraConfig(
+            task_type="CAUSAL_LM", target_modules=["k_proj", "q_proj", "v_proj"], init_lora_weights=False
+        )
+
+        with hub_online_once(self.model_id):
+            for i, lora_config in enumerate(lora_configs, start=1):
+                torch.manual_seed(i)
+                model = AutoModelForCausalLM.from_pretrained(self.model_id)
+                peft_model = get_peft_model(model, lora_config)
+                file_name = os.path.join(lora_dir, f"checkpoint-{i}")
+                peft_model.save_pretrained(file_name)
+                file_names.append(file_name)
+        return file_names
+
+    @pytest.fixture(scope="class")
+    def saved_lora_embedding_adapters(self, lora_embedding_dir):
+        file_names = []
+        with hub_online_once(self.model_id):
+            for i in range(1, self.num_loras + 1):
+                torch.manual_seed(i)
+                lora_config = LoraConfig(
+                    task_type="CAUSAL_LM", init_lora_weights=False, target_modules=["embed_tokens"]
+                )
+                model = AutoModelForCausalLM.from_pretrained(self.model_id)
+                peft_model = get_peft_model(model, lora_config)
+                file_name = os.path.join(lora_embedding_dir, f"checkpoint-{i}")
+                peft_model.save_pretrained(file_name)
+                file_names.append(file_name)
+        return file_names
+
+    @pytest.fixture(scope="class")
+    def tokenizer(self):
+        tokenizer = AutoTokenizer.from_pretrained(self.model_id, device_map=self.torch_device)
+        return tokenizer
+
+    @pytest.fixture(scope="function")
+    def embedding_model(self, base_model, saved_lora_embedding_adapters):
+        base_model.config.use_cache = False
+        adapters = {str(i): file_name for i, file_name in enumerate(saved_lora_embedding_adapters)}
+
+        peft_config = XLoraConfig(
+            task_type=TaskType.CAUSAL_LM,
+            peft_type=PeftType.XLORA,
+            hidden_size=base_model.config.hidden_size,
+            xlora_depth=8,
+            adapters=adapters,
+        )
+        model = get_peft_model(base_model, peft_config).to(self.torch_device)
+        return model
+
+    @pytest.fixture(scope="function")
+    def model(self, base_model, saved_lora_adapters):
+        base_model.config.use_cache = False
+        adapters = {str(i): file_name for i, file_name in enumerate(saved_lora_adapters)}
+
+        peft_config = XLoraConfig(
+            task_type=TaskType.CAUSAL_LM,
+            peft_type=PeftType.XLORA,
+            hidden_size=base_model.config.hidden_size,
+            xlora_depth=8,
+            adapters=adapters,
+        )
+        model = get_peft_model(base_model, peft_config).to(self.torch_device)
+        return model
+
+    @pytest.fixture(scope="function")
+    def model_layerwise(self, base_model, saved_lora_adapters):
+        base_model.config.use_cache = False
+        adapters = {str(i): file_name for i, file_name in enumerate(saved_lora_adapters)}
+
+        peft_config = XLoraConfig(
+            task_type=TaskType.CAUSAL_LM,
+            peft_type=PeftType.XLORA,
+            hidden_size=base_model.config.hidden_size,
+            xlora_depth=8,
+            adapters=adapters,
+            layerwise_scalings=True,
+        )
+        model = get_peft_model(base_model, peft_config).to(self.torch_device)
+        return model
+
+    def test_functional(self, tokenizer, model):
+        model.enable_scalings_logging()
+        inputs = tokenizer.encode("Python is a", add_special_tokens=False, return_tensors="pt")
+        outputs = model.generate(
+            input_ids=inputs.to(self.torch_device),
+            max_new_tokens=32,
+        )
+        assert torch.isfinite(outputs[: inputs.shape[1] :]).all()
+
+    def test_forward_hooks_are_cleaned_up(self, tokenizer, model):
+        # There was an issue that forward hooks would accumulate during generation, since one hook per forward step was
+        # being registered and generate would call forward multiple times. This is already undesirable, but to make it
+        # worse, only the last hook was removed, resulting in hooks accumulating.
+        # See https://github.com/huggingface/peft/issues/1472#issuecomment-3235817807
+        inputs = tokenizer.encode("Python is a", add_special_tokens=False, return_tensors="pt")
+        model.generate(input_ids=inputs.to(self.torch_device), max_new_tokens=10)
+        num_hooks_gen1 = len(model.base_model.model.model.decoder.layers[0].self_attn.k_proj._forward_pre_hooks)
+
+        model.generate(input_ids=inputs.to(self.torch_device), max_new_tokens=10)
+        num_hooks_gen2 = len(model.base_model.model.model.decoder.layers[0].self_attn.k_proj._forward_pre_hooks)
+        assert num_hooks_gen1 == num_hooks_gen2 == 0
+
+    def test_scalings_logging_methods(self, tokenizer, model):
+        model.enable_scalings_logging()
+
+        inputs = tokenizer.encode("Python is a", add_special_tokens=False, return_tensors="pt")
+        outputs = model.generate(
+            input_ids=inputs.to(self.torch_device),
+            max_new_tokens=32,
+        )
+        assert torch.isfinite(outputs[: inputs.shape[1] :]).all()
+
+        _ = model.get_latest_scalings()
+        # 32 is the number of max scalings. 3 is the number of prompt tokens.
+        assert 32 + 3 >= len(model.get_scalings_log()) > 0
+
+        model.disable_scalings_logging()
+
+        inputs = tokenizer.encode("Python is a", add_special_tokens=False, return_tensors="pt")
+        outputs = model.generate(
+            input_ids=inputs.to(self.torch_device),
+            max_new_tokens=32,
+        )
+        assert torch.isfinite(outputs[: inputs.shape[1] :]).all()
+
+        assert 32 >= len(model.get_scalings_log()) > 0
+
+        bucketed = model.get_bucketed_scalings_log()
+        keys = bucketed.keys()
+        # Once bucket for each token as we aren't using cache
+        assert len(bucketed) == 32 == len(keys)
+        seq_len = inputs.shape[1]
+        for key in keys:
+            assert len(bucketed[key][0]) == 1
+            assert len(bucketed[key][1]) == 1
+            assert bucketed[key][0][0] == key - seq_len
+
+        model.clear_scalings_log()
+        assert len(model.get_scalings_log()) == 0
+
+    def test_misc_methods(self, tokenizer, model):
+        model.set_global_scaling_weight(1.5)
+        assert model.internal_xlora_classifier.config.global_scaling_weight == 1.5
+        assert model.get_global_scaling_weight() == 1.5
+
+        inputs = tokenizer.encode("Python is a", add_special_tokens=False, return_tensors="pt")
+        outputs = model.generate(
+            input_ids=inputs.to(self.torch_device),
+            max_new_tokens=32,
+        )
+        assert torch.isfinite(outputs[: inputs.shape[1] :]).all()
+
+        assert str(model) is not None
+
+    # On CI (but not locally), this test is flaky since transformers v4.45.0.
+    @flaky(num_tries=5)
+    def test_save_load_functional(self, tokenizer, base_model, model, tmp_path):
+        inputs = tokenizer.encode("Python is a", add_special_tokens=False, return_tensors="pt")
+        outputs = model.generate(
+            input_ids=inputs.to(self.torch_device),
+            max_new_tokens=32,
+        )
+        before_logits = outputs[: inputs.shape[1] :]
+        assert torch.isfinite(before_logits).all()
+
+        model.save_pretrained(save_directory=tmp_path)
+
+        del model
+
+        base_model.config.use_cache = False
+        model = PeftModel.from_pretrained(model=base_model, model_id=tmp_path).to(self.torch_device)
+
+        inputs = tokenizer.encode("Python is a", add_special_tokens=False, return_tensors="pt")
+        outputs = model.generate(
+            input_ids=inputs.to(self.torch_device),
+            max_new_tokens=32,
+        )
+        after_logits = outputs[: inputs.shape[1] :]
+        assert torch.isfinite(after_logits).all()
+        assert torch.equal(after_logits, before_logits)
+
+    def test_save_load_functional_pt(self, tokenizer, base_model, model, tmp_path):
+        inputs = tokenizer.encode("Python is a", add_special_tokens=False, return_tensors="pt")
+        outputs = model.generate(
+            input_ids=inputs.to(self.torch_device),
+            max_new_tokens=32,
+        )
+        before_logits = outputs[: inputs.shape[1] :]
+        assert torch.isfinite(before_logits).all()
+
+        model.save_pretrained(save_directory=tmp_path, safe_serialization=False)
+
+        del model
+
+        base_model.config.use_cache = False
+        model = PeftModel.from_pretrained(model=base_model, model_id=tmp_path, safe_serialization=False).to(
+            self.torch_device
+        )
+
+        inputs = tokenizer.encode("Python is a", add_special_tokens=False, return_tensors="pt")
+        outputs = model.generate(
+            input_ids=inputs.to(self.torch_device),
+            max_new_tokens=32,
+        )
+        after_logits = outputs[: inputs.shape[1] :]
+        assert torch.isfinite(after_logits).all()
+        assert torch.equal(after_logits, before_logits), (after_logits, before_logits)
+
+    def test_topk_lora(self, tokenizer, model):
+        model.set_topk_lora(2)
+        assert model.internal_xlora_classifier.config.top_k_lora == 2
+
+        inputs = tokenizer.encode("Python is a", add_special_tokens=False, return_tensors="pt")
+        outputs = model.generate(
+            input_ids=inputs.to(self.torch_device),
+            max_new_tokens=32,
+        )
+        assert torch.isfinite(outputs[: inputs.shape[1] :]).all()
+
+    def test_softmax_topk(self, tokenizer, model):
+        # Just reach in to set the config
+        model.internal_xlora_classifier.config.top_k_lora = 2
+        model.internal_xlora_classifier.config.enable_softmax = False
+        model.internal_xlora_classifier.config.enable_softmax_topk = True
+
+        inputs = tokenizer.encode("Python is a", add_special_tokens=False, return_tensors="pt")
+        outputs = model.generate(
+            input_ids=inputs.to(self.torch_device),
+            max_new_tokens=32,
+        )
+        assert torch.isfinite(outputs[: inputs.shape[1] :]).all()
+
+    def test_set_override_scaling_pass_value(self, model):
+        # Defaults to 0
+        assert model.internal_xlora_classifier.override_scaling_pass_value == 0.0
+
+        # Set it to 2 and make sure it actually is
+        model.set_scaling_pass_value(2)
+        assert model.internal_xlora_classifier.override_scaling_pass_value == 2
+        assert model.internal_xlora_classifier.config.scaling_pass_value == 2
+
+        # Set it to None and make sure it is 1/n
+        model.set_scaling_pass_value(None)
+        assert model.internal_xlora_classifier.override_scaling_pass_value == 1 / self.num_loras
+        assert model.internal_xlora_classifier.config.scaling_pass_value == 1 / self.num_loras
+
+    def test_functional_layerwise(self, tokenizer, model_layerwise):
+        model_layerwise.enable_scalings_logging()
+        inputs = tokenizer.encode("Python is a", add_special_tokens=False, return_tensors="pt")
+        outputs = model_layerwise.generate(
+            input_ids=inputs.to(self.torch_device),
+            max_new_tokens=32,
+        )
+        assert torch.isfinite(outputs[: inputs.shape[1] :]).all()
+
+    def test_disable_adapter(self, tokenizer, model):
+        model.enable_scalings_logging()
+        inputs = tokenizer.encode("Python is a", add_special_tokens=False, return_tensors="pt")
+        with model.disable_adapter():
+            outputs_disabled = model.generate(
+                input_ids=inputs.to(self.torch_device),
+                max_new_tokens=32,
+            )
+        outputs = model.generate(
+            input_ids=inputs.to(self.torch_device),
+            max_new_tokens=32,
+        )
+        assert torch.isfinite(outputs_disabled[: inputs.shape[1] :]).all()
+        assert torch.isfinite(outputs[: inputs.shape[1] :]).all()
+        assert not torch.equal(outputs, outputs_disabled)
+
+    def test_functional_embedding(self, tokenizer, embedding_model):
+        inputs = tokenizer.encode("Python is a", add_special_tokens=False, return_tensors="pt")
+        outputs = embedding_model.generate(
+            input_ids=inputs.to(self.torch_device),
+            max_new_tokens=32,
+        )
+        assert torch.isfinite(outputs[: inputs.shape[1] :]).all()
+
+    def test_xlora_loading_valid(self):
+        # This test also simultaneously tests the loading-from-hub functionality!
+        torch.manual_seed(123)
+
+        model_id = "peft-internal-testing/opt-125m"
+        with hub_online_once(model_id):
+            model = AutoModelForCausalLM.from_pretrained(model_id)
+            # note: exit the caching context to allow download of the LoRA adapters below
+        model.config.use_cache = False
+
+        adapters = [
+            "peft-internal-testing/opt-125m-dummy-lora",
+            "peft-internal-testing/opt-125m-dummy-lora",
+        ]
+        adapters = {str(i): file_name for i, file_name in enumerate(adapters)}
+
+        peft_config = XLoraConfig(
+            task_type=TaskType.CAUSAL_LM,
+            peft_type=PeftType.XLORA,
+            hidden_size=model.config.hidden_size,
+            adapters=adapters,
+            xlora_depth=8,
+            xlora_size=2048,
+            layerwise_scalings=True,
+            xlora_dropout_p=0.2,
+        )
+        model = get_peft_model(model, peft_config)
+
+        downloaded = huggingface_hub.hf_hub_download(repo_id=adapters["0"], filename="adapter_model.safetensors")
+        sd = load_file(downloaded)
+        w0 = model.base_model.model.model.decoder.layers[0].self_attn.q_proj.lora_A["0"].weight
+        w1 = sd["base_model.model.model.decoder.layers.0.self_attn.q_proj.lora_A.weight"]
+
+        assert torch.allclose(w0, w1)
+
+    def test_scalings_storage(self, tokenizer, model):
+        model.enable_scalings_logging()
+        inputs = tokenizer.encode("Python is a", add_special_tokens=False, return_tensors="pt")
+        outputs = model.generate(
+            input_ids=inputs.to(self.torch_device),
+            max_new_tokens=10,
+        )
+
+        latest_scalings = model.get_latest_scalings()
+        assert latest_scalings is not None, "get_latest_scalings() should not return None after generation"
+        assert isinstance(latest_scalings, torch.Tensor)
+        assert torch.isfinite(latest_scalings).all(), "Scalings should contain finite values"
+
+    def test_per_token_normalization_with_softmax_topk(self, tokenizer, model, monkeypatch):
+        model.internal_xlora_classifier.config.top_k_lora = 2
+        model.internal_xlora_classifier.config.enable_softmax = False
+        model.internal_xlora_classifier.config.enable_softmax_topk = True
+
+        captured_data = []
+        orig_get_maybe_topk_scalings = XLoraLayer.get_maybe_topk_scalings
+
+        def mock_get_maybe_topk_scalings(self, scalings):
+            result = orig_get_maybe_topk_scalings(self, scalings)
+            if getattr(model, "internal_xlora_scalings", None) is not None:
+                captured_data.append(result)
+            return result
+
+        monkeypatch.setattr(XLoraLayer, "get_maybe_topk_scalings", mock_get_maybe_topk_scalings)
+
+        model.enable_scalings_logging()
+        inputs = tokenizer.encode("Test per token normalization", add_special_tokens=False, return_tensors="pt")
+        outputs = model.generate(
+            input_ids=inputs.to(self.torch_device),
+            max_new_tokens=1,
+        )
+
+        for scaling in captured_data:
+            weight_sums = scaling.sum(dim=-1)
+            assert torch.allclose(weight_sums, torch.ones_like(weight_sums), atol=1e-5), (
+                "Per-token scaling weights are not normalized to sum to 1."
+            )
+
+    def test_xlora_embed_scale_is_applied(self, tmp_path):
+        """Test that X-LoRA correctly handles embeddings with scaling (e.g., Gemma3)."""
+        model_id = "hf-internal-testing/tiny-random-Gemma3ForCausalLM"
+        with hub_online_once(model_id):
+            # Create and save Gemma3-compatible LoRA adapters
+            adapters = {}
+            for i in range(2):
+                torch.manual_seed(i + 1)
+                lora_config = LoraConfig(
+                    task_type="CAUSAL_LM", init_lora_weights=False, target_modules=["embed_tokens"]
+                )
+                model = AutoModelForCausalLM.from_pretrained(model_id)
+                peft_model = get_peft_model(model, lora_config)
+                adapter_path = os.path.join(tmp_path, f"checkpoint-{i + 1}")
+                peft_model.save_pretrained(adapter_path)
+                adapters[str(i)] = adapter_path
+
+            # Load base model and test X-LoRA with embed_scale
+            base_model = AutoModelForCausalLM.from_pretrained(model_id).to(self.torch_device)
+            base_model.config.use_cache = False
+            orig_embedding = base_model.get_input_embeddings()
+
+            xlora_config = XLoraConfig(
+                task_type=TaskType.CAUSAL_LM,
+                hidden_size=base_model.config.hidden_size,
+                adapters=adapters,
+            )
+            xlora_model = get_peft_model(base_model, xlora_config)
+
+            x = torch.arange(10).to(self.torch_device)
+            xlora_embedding = xlora_model.base_model.model.get_input_embeddings()
+            max_embedding_output = xlora_embedding(x).abs().max(0)[0]
+            assert (max_embedding_output < 100.0).all()
+
+            # set embed_scale to an absurdly high value, then check that the embedding output is also scaled to a high
+            # value
+            orig_embedding.embed_scale.fill_(10000.0)
+            max_embedding_output = xlora_embedding(x).abs().max(0)[0]
+            assert (max_embedding_output > 100.0).all()
+
+            # set embed_scale to zero, then check that the embedding output is also zero
+            orig_embedding.embed_scale.fill_(0)
+            embedding_output = xlora_embedding(x)
+            assert (embedding_output == 0.0).all()
diff --git a/tests/testing_common.py b/tests/testing_common.py
new file mode 100644
index 0000000..d4b3a68
--- /dev/null
+++ b/tests/testing_common.py
@@ -0,0 +1,1925 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+import copy
+import json
+import os
+import pickle
+import platform
+import re
+import shutil
+import tempfile
+import warnings
+from dataclasses import replace
+from operator import attrgetter
+
+import pytest
+import torch
+import yaml
+from diffusers import StableDiffusionPipeline
+from packaging import version
+from safetensors.torch import load_file, save_file
+
+from peft import (
+    AdaLoraConfig,
+    BOFTConfig,
+    CPTConfig,
+    GraloraConfig,
+    HiraConfig,
+    IA3Config,
+    LilyConfig,
+    LNTuningConfig,
+    LoHaConfig,
+    LoKrConfig,
+    LoraConfig,
+    OSFConfig,
+    PeftModel,
+    PrefixTuningConfig,
+    PromptEncoderConfig,
+    PromptLearningConfig,
+    PromptTuningConfig,
+    PveraConfig,
+    RoadConfig,
+    UniLoraConfig,
+    VBLoRAConfig,
+    VeraConfig,
+    convert_to_lora,
+    get_peft_model,
+    get_peft_model_state_dict,
+    inject_adapter_in_model,
+    prepare_model_for_kbit_training,
+    set_peft_model_state_dict,
+)
+from peft.import_utils import is_transformers_ge_v5
+from peft.tuners._buffer_dict import BufferDict
+from peft.tuners.lora import LoraLayer
+from peft.tuners.tuners_utils import BaseTunerLayer
+from peft.utils import (
+    AuxiliaryTrainingWrapper,
+    ModulesToSaveWrapper,
+    TrainableTokensWrapper,
+    _get_submodules,
+    infer_device,
+)
+
+from .testing_utils import get_state_dict, hub_online_once
+
+
+def _skip_if_merging_not_supported(model_id, config_cls, config_kwargs):
+    if issubclass(config_cls, PromptLearningConfig):
+        pytest.skip("Prompt learning does not support merging, skipping this test.")
+    if config_kwargs.get("alora_invocation_tokens") is not None:
+        pytest.skip("Test not applicable for Activated LoRA")
+    if issubclass(config_cls, OSFConfig):
+        pytest.skip(f"Skipping test for {model_id} with {config_cls} as OSF adapter merge/unload are not implemented.")
+    if model_id.startswith("Conv2dGroups") and (config_cls == LoraConfig):
+        # note: right now, only LoRA supports groups>1, if other PEFT methods add support, they might also need to skip
+        pytest.skip("Merging conv layers with groups>1 and LoRA is not supported.")
+    if issubclass(config_cls, LilyConfig):
+        pytest.skip("Lily does not support merging adapters, skipping this test.")
+
+
+def _skip_if_adding_weighted_adapters_not_supported(config):
+    if not isinstance(config, (IA3Config, LoraConfig)):
+        pytest.skip("This PEFT method does not support adding weighted adapters, skipping this test.")
+
+
+def _skip_if_deleting_adapter_not_supported(config_cls, config_kwargs):
+    if issubclass(config_cls, PromptLearningConfig):
+        pytest.skip("Prompt learning does not support deletion of adapters, skipping this test.")
+
+
+def _skip_if_conv1d_not_supported(model_id, config_cls, config_kwargs):
+    if "gpt2" not in model_id.lower():
+        return
+
+    if config_cls not in (IA3Config, LoHaConfig, LoKrConfig, LoraConfig):
+        pytest.skip("This PEFT method does not support Conv1D layers, skipping this test.")
+
+
+class PeftCommonTester:
+    r"""
+    A large testing suite for testing common functionality of the PEFT models.
+
+    Attributes:
+        torch_device (`torch.device`):
+            The device on which the tests will be run.
+        transformers_class (`transformers.PreTrainedModel`):
+            The transformers class that is being tested.
+    """
+
+    torch_device = infer_device()
+    transformers_class = None
+
+    def prepare_inputs_for_common(self):
+        raise NotImplementedError
+
+    def check_modelcard(self, tmp_dirname, model):
+        # check the generated README.md
+        filename = os.path.join(tmp_dirname, "README.md")
+        assert os.path.exists(filename)
+        with open(filename, encoding="utf-8") as f:
+            readme = f.read()
+        metainfo = re.search(r"---\n(.*?)\n---", readme, re.DOTALL).group(1)
+        dct = yaml.safe_load(metainfo)
+        assert dct["library_name"] == "peft"
+
+        if hasattr(model, "config"):
+            assert dct["base_model"] == model.config.to_dict()["_name_or_path"]
+        else:  # a custom model
+            assert "base_model" not in dct
+
+        # The Hub expects the lora tag to be set for PEFT LoRA models since they
+        # have explicit support for things like inference.
+        if model.active_peft_config.peft_type.value == "LORA":
+            assert "lora" in dct["tags"]
+
+    def check_config_json(self, tmp_dirname, model):
+        # check the generated config.json
+        filename = os.path.join(tmp_dirname, "adapter_config.json")
+        assert os.path.exists(filename)
+        with open(filename, encoding="utf-8") as f:
+            config = json.load(f)
+
+        if hasattr(model, "config"):  # custom models don't have a config attribute
+            assert config["base_model_name_or_path"] == model.config.to_dict()["_name_or_path"]
+
+    def perturb_trainable_token_weights_if_used(self, model, config_kwargs, adapter_name="default", scale=1.0):
+        """TrainableTokensLayer is initialized to be a no-op by default. Since there's currently no way to pass
+        `init_weights=False` to the trainable tokens layer when used in conjunction with LoRA, we have to do it like
+        this to make sure that it is *not* a no-op (essentially simulating "training" of the adapter).
+        """
+        if "trainable_token_indices" not in config_kwargs:
+            return
+
+        token_wrapper = None
+
+        if hasattr(model, "get_input_embeddings"):
+            token_wrapper = model.get_input_embeddings()
+        else:
+            for module in model.modules():
+                if isinstance(module, TrainableTokensWrapper):
+                    token_wrapper = module
+                    break
+
+        # for a model with trainable_token_indices there should always be a trainable token wrapper somewhere.
+        # if not, then there's something broken.
+        assert token_wrapper is not None
+
+        token_wrapper.token_adapter.trainable_tokens_delta[adapter_name].data = (
+            torch.rand_like(token_wrapper.token_adapter.trainable_tokens_delta[adapter_name].data) * scale
+        )
+
+    def _test_model_attr(self, model_id, config_cls, config_kwargs):
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+            model = get_peft_model(model, config)
+
+            assert hasattr(model, "save_pretrained")
+            assert hasattr(model, "from_pretrained")
+            assert hasattr(model, "push_to_hub")
+
+    def _test_adapter_name(self, model_id, config_cls, config_kwargs):
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+            model = get_peft_model(model, config, adapter_name="test-adapter")
+            correctly_converted = False
+            for n, _ in model.named_parameters():
+                if "test-adapter" in n:
+                    correctly_converted = True
+                    break
+
+            assert correctly_converted
+
+    def _test_prepare_for_training(self, model_id, config_cls, config_kwargs):
+        if config_kwargs.get("trainable_token_indices", None) is not None:
+            # incompatible because trainable tokens is marking embeddings as trainable
+            pytest.skip("Trainable tokens is incompatible with this test.")
+
+        # some tests require specific tokenizers, make sure that they can be fetched as well
+        with hub_online_once(model_id + config_kwargs.get("tokenizer_name_or_path", "")):
+            model = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+            model = get_peft_model(model, config)
+
+            dummy_input = self.prepare_inputs_for_testing()
+            dummy_output = model.get_input_embeddings()(dummy_input["input_ids"])
+
+            assert not dummy_output.requires_grad
+
+            # load with `prepare_model_for_kbit_training`
+            model = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+            model = prepare_model_for_kbit_training(model)
+
+            for param in model.parameters():
+                assert not param.requires_grad
+
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+            model = get_peft_model(model, config)
+
+            # For backward compatibility
+            if hasattr(model, "enable_input_require_grads"):
+                model.enable_input_require_grads()
+            else:
+
+                def make_inputs_require_grad(module, input, output):
+                    output.requires_grad_(True)
+
+                model.get_input_embeddings().register_forward_hook(make_inputs_require_grad)
+
+            dummy_input = self.prepare_inputs_for_testing()
+            dummy_output = model.get_input_embeddings()(dummy_input["input_ids"])
+
+            assert dummy_output.requires_grad
+
+    def _test_load_model_low_cpu_mem_usage(self, model_id, config_cls, config_kwargs):
+        # Ensure that low_cpu_mem_usage=True works for from_pretrained and load_adapter and that the resulting model's
+        # parameters are on the correct device.
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+            model = get_peft_model(model, config)
+
+            # note: not using the context manager here because it fails on Windows CI for some reason
+            tmp_dirname = tempfile.mkdtemp()
+            try:
+                model.save_pretrained(tmp_dirname)
+
+                model = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+                model = PeftModel.from_pretrained(
+                    model, tmp_dirname, torch_device=self.torch_device, low_cpu_mem_usage=True
+                )
+                assert {p.device.type for p in model.parameters()} == {self.torch_device}
+
+                model.load_adapter(tmp_dirname, adapter_name="other", low_cpu_mem_usage=True)
+                assert {p.device.type for p in model.parameters()} == {self.torch_device}
+            finally:
+                try:
+                    shutil.rmtree(tmp_dirname)
+                except PermissionError:
+                    # windows error
+                    pass
+
+            # also test injecting directly
+            del model
+            model = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+            inject_adapter_in_model(config, model, low_cpu_mem_usage=True)  # check that there is no error
+
+            if not isinstance(config, LNTuningConfig):
+                # LN tuning does not add adapter layers that could be on meta device, it only changes the requires_grad.
+                # Therefore, there is no meta device for LN tuning.
+                assert "meta" in {p.device.type for p in model.parameters()}
+
+    def _test_save_pretrained(self, model_id, config_cls, config_kwargs, safe_serialization=True):
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+            model = get_peft_model(model, config)
+            model = model.to(self.torch_device)
+
+            with tempfile.TemporaryDirectory() as tmp_dirname:
+                if safe_serialization:
+                    model.save_pretrained(tmp_dirname)
+                else:
+                    model.save_pretrained(tmp_dirname, safe_serialization=False)
+
+                model_from_pretrained = self.transformers_class.from_pretrained(model_id)
+                with warnings.catch_warnings(record=True) as recs:
+                    model_from_pretrained = PeftModel.from_pretrained(model_from_pretrained, tmp_dirname)
+                    # ensure that there is no warning
+                    assert not any("Found missing adapter keys" in str(rec.message) for rec in recs)
+
+                # check if the state dicts are equal
+                if issubclass(config_cls, PromptEncoderConfig):
+                    # For prompt encoding, when loading the whole state_dict, there are differences, therefore, only load
+                    # adapter-specific weights for comparison.
+                    # TODO: is this expected?
+                    state_dict = get_peft_model_state_dict(model, unwrap_compiled=True)
+                    state_dict_from_pretrained = get_peft_model_state_dict(model_from_pretrained, unwrap_compiled=True)
+                else:
+                    state_dict = get_state_dict(model, unwrap_compiled=True)
+                    state_dict_from_pretrained = get_state_dict(model_from_pretrained, unwrap_compiled=True)
+
+                # check if tensors equal
+                for key in state_dict.keys():
+                    assert torch.allclose(
+                        state_dict[key].to(self.torch_device), state_dict_from_pretrained[key].to(self.torch_device)
+                    )
+
+                target_adapter_filename = "adapter_model.safetensors" if safe_serialization else "adapter_model.bin"
+
+                # check if `adapter_model.safetensors` is present
+                assert os.path.exists(os.path.join(tmp_dirname, target_adapter_filename))
+
+                # check if `adapter_config.json` is present
+                assert os.path.exists(os.path.join(tmp_dirname, "adapter_config.json"))
+
+                # check if `model.safetensors` is not present
+                assert not os.path.exists(os.path.join(tmp_dirname, "model.safetensors"))
+
+                # check if `config.json` is not present
+                assert not os.path.exists(os.path.join(tmp_dirname, "config.json"))
+
+                self.check_modelcard(tmp_dirname, model)
+                self.check_config_json(tmp_dirname, model)
+
+    def _test_save_pretrained_selected_adapters(self, model_id, config_cls, config_kwargs, safe_serialization=True):
+        if issubclass(config_cls, AdaLoraConfig):
+            # AdaLora does not support adding more than 1 adapter
+            pytest.skip(f"Test not applicable for {config_cls}")
+
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+            model = get_peft_model(model, config)
+            model = model.to(self.torch_device)
+
+            new_adapter_config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+
+            model.add_adapter("new_adapter", new_adapter_config)
+
+            with tempfile.TemporaryDirectory() as tmp_dirname:
+                if safe_serialization:
+                    model.save_pretrained(tmp_dirname)
+                else:
+                    model.save_pretrained(tmp_dirname, safe_serialization=False)
+
+                model_from_pretrained = self.transformers_class.from_pretrained(model_id)
+                model_from_pretrained = PeftModel.from_pretrained(model_from_pretrained, tmp_dirname)
+
+                new_adapter_dir = os.path.join(tmp_dirname, "new_adapter")
+                model_from_pretrained.load_adapter(new_adapter_dir, "new_adapter")
+
+                # check if the state dicts are equal
+                if issubclass(config_cls, PromptEncoderConfig):
+                    # For prompt encoding, when loading the whole state_dict, there are differences, therefore, only load
+                    # adapter-specific weights for comparison.
+                    # TODO: is this expected?
+                    state_dict = get_peft_model_state_dict(model, unwrap_compiled=True)
+                    state_dict_from_pretrained = get_peft_model_state_dict(model_from_pretrained, unwrap_compiled=True)
+                else:
+                    state_dict = get_state_dict(model, unwrap_compiled=True)
+                    state_dict_from_pretrained = get_state_dict(model_from_pretrained, unwrap_compiled=True)
+
+                # check if same keys
+                assert state_dict.keys() == state_dict_from_pretrained.keys()
+
+                # check if tensors equal
+                for key in state_dict.keys():
+                    assert torch.allclose(
+                        state_dict[key].to(self.torch_device), state_dict_from_pretrained[key].to(self.torch_device)
+                    )
+
+                target_adapter_filename = "adapter_model.safetensors" if safe_serialization else "adapter_model.bin"
+
+                # check if `adapter_model.safetensors` is present
+                assert os.path.exists(os.path.join(tmp_dirname, target_adapter_filename))
+                assert os.path.exists(os.path.join(new_adapter_dir, target_adapter_filename))
+
+                # check if `adapter_config.json` is present
+                assert os.path.exists(os.path.join(tmp_dirname, "adapter_config.json"))
+                assert os.path.exists(os.path.join(new_adapter_dir, "adapter_config.json"))
+
+                # check if `model.safetensors` is not present
+                assert not os.path.exists(os.path.join(tmp_dirname, "model.safetensors"))
+                assert not os.path.exists(os.path.join(new_adapter_dir, "model.safetensors"))
+
+                # check if `config.json` is not present
+                assert not os.path.exists(os.path.join(tmp_dirname, "config.json"))
+                assert not os.path.exists(os.path.join(new_adapter_dir, "config.json"))
+
+                self.check_modelcard(tmp_dirname, model)
+                self.check_config_json(tmp_dirname, model)
+
+            with tempfile.TemporaryDirectory() as tmp_dirname:
+                model.save_pretrained(tmp_dirname, selected_adapters=["default"])
+
+                model_from_pretrained = self.transformers_class.from_pretrained(model_id)
+                model_from_pretrained = PeftModel.from_pretrained(model_from_pretrained, tmp_dirname)
+
+                assert "default" in model_from_pretrained.peft_config.keys()
+                assert "new_adapter" not in model_from_pretrained.peft_config.keys()
+
+    def _test_save_pretrained_adapter_name_substring(self, model_id, config_cls, config_kwargs):
+        # Test that if we have multiple adapters, only the specified adapter is saved, even if adapter names match
+        # substrings of other adapter names.
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+            model = get_peft_model(model, config)  # adapter name will be "default"
+            # to calculate the expected number of weights, use get_peft_model_state_dict, since some methods like VeRA
+            # will add shared weights there, which we wouldn't count correctly when using model.state_dict()
+            expected_number_of_weights = len(get_peft_model_state_dict(model))
+
+            model.add_adapter("default2", config)  # prefix
+            model.add_adapter("other_default", config)  # suffix
+            model.add_adapter("foodefault_bar", config)  # infix
+            model.add_adapter("efaul", config)  # substring
+
+            with tempfile.TemporaryDirectory() as tmp_dirname:
+                model.save_pretrained(tmp_dirname, selected_adapters=["default"])
+                state_dict = load_file(os.path.join(tmp_dirname, "adapter_model.safetensors"))
+                assert len(state_dict) == expected_number_of_weights
+
+    def _test_from_pretrained_config_construction(self, model_id, config_cls, config_kwargs):
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+            config = config_cls(base_model_name_or_path=model_id, **config_kwargs)
+            model = get_peft_model(model, config)
+            model = model.to(self.torch_device)
+
+            with tempfile.TemporaryDirectory() as tmp_dirname:
+                model.save_pretrained(tmp_dirname)
+
+                model_from_pretrained = self.transformers_class.from_pretrained(model_id)
+                model_from_pretrained = PeftModel.from_pretrained(
+                    model_from_pretrained, tmp_dirname, is_trainable=False, config=config
+                )
+
+                assert model_from_pretrained.peft_config["default"].inference_mode
+                assert model_from_pretrained.peft_config["default"] is config
+
+    def _test_load_multiple_adapters(self, model_id, config_cls, config_kwargs):
+        # just ensure that this works and raises no error
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+            model = get_peft_model(model, config)
+
+            with tempfile.TemporaryDirectory() as tmp_dirname:
+                model.save_pretrained(tmp_dirname)
+                del model
+
+                model = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+                model = PeftModel.from_pretrained(model, tmp_dirname, torch_device=self.torch_device)
+                load_result1 = model.load_adapter(tmp_dirname, adapter_name="other")
+                load_result2 = model.load_adapter(tmp_dirname, adapter_name="yet-another")
+
+                # VBLoRA uses a shared "vblora_vector_bank" across all layers, causing it to appear
+                # in the missing keys list, which leads to failed test cases. So
+                # skipping the missing keys check for VBLoRA.
+                if config.peft_type != "VBLORA":
+                    assert load_result1.missing_keys == []
+                    assert load_result2.missing_keys == []
+
+    def _test_merge_layers_fp16(self, model_id, config_cls, config_kwargs):
+        _skip_if_merging_not_supported(model_id, config_cls, config_kwargs)
+        _skip_if_conv1d_not_supported(model_id, config_cls, config_kwargs)
+        if (self.torch_device in ["cpu"]) and (version.parse(torch.__version__) <= version.parse("2.1")):
+            pytest.skip("PyTorch 2.1 not supported for Half of addmm_impl_cpu_ ")
+
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id, dtype=torch.float16)
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+            model = get_peft_model(model, config)
+            model = model.to(device=self.torch_device, dtype=torch.float16)
+
+            model.eval()
+
+            # This should simply work
+            _ = model.merge_and_unload()
+
+    def _test_merge_layers_nan(self, model_id, config_cls, config_kwargs):
+        _skip_if_merging_not_supported(model_id, config_cls, config_kwargs)
+        _skip_if_conv1d_not_supported(model_id, config_cls, config_kwargs)
+
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+
+            model = get_peft_model(model, config)
+            model = model.to(self.torch_device)
+
+            self.perturb_trainable_token_weights_if_used(model, config_kwargs)
+
+            dummy_input = self.prepare_inputs_for_testing()
+
+            model.eval()
+
+            # This should work
+            logits_unmerged = model(**dummy_input)[0]
+
+            model = model.merge_and_unload()
+            logits_merged = model(**dummy_input)[0]
+
+            assert torch.allclose(logits_unmerged, logits_merged, atol=1e-3, rtol=1e-3)
+
+            model = self.transformers_class.from_pretrained(model_id)
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+            model = get_peft_model(model, config)
+            model = model.to(self.torch_device)
+
+            for name, module in model.named_parameters():
+                if model.prefix in name:
+                    module.data[0] = torch.nan
+
+            with pytest.raises(
+                ValueError, match="NaNs detected in the merged weights. The adapter default seems to be broken"
+            ):
+                model = model.merge_and_unload(safe_merge=True)
+
+            for name, module in model.named_parameters():
+                if (
+                    "lora_A" in name
+                    or "ia3" in name
+                    or "lora_E" in name
+                    or "lora_B" in name
+                    or "vera_lambda" in name
+                    or "fourierft_spectrum" in name
+                ):
+                    module.data[0] = torch.inf
+
+            with pytest.raises(
+                ValueError, match="NaNs detected in the merged weights. The adapter default seems to be broken"
+            ):
+                model = model.merge_and_unload(safe_merge=True)
+
+    def _test_merge_layers(self, model_id, config_cls, config_kwargs):
+        _skip_if_merging_not_supported(model_id, config_cls, config_kwargs)
+        _skip_if_conv1d_not_supported(model_id, config_cls, config_kwargs)
+
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+
+            model = get_peft_model(model, config)
+            model = model.to(self.torch_device)
+
+            self.perturb_trainable_token_weights_if_used(model, config_kwargs)
+
+            dummy_input = self.prepare_inputs_for_testing()
+            model.eval()
+            logits = model(**dummy_input)[0]
+
+            model.merge_adapter()
+            logits_merged = model(**dummy_input)[0]
+            model.unmerge_adapter()
+            logits_unmerged = model(**dummy_input)[0]
+
+            model = model.merge_and_unload()
+
+            # check that PEFT layers are completely removed
+            assert not any(isinstance(module, BaseTunerLayer) for module in model.modules())
+            assert not hasattr(model, "peft_config")
+            logits_merged_unloaded = model(**dummy_input)[0]
+
+            conv_ids = ["Conv2d", "Conv3d", "Conv2d2"]
+            is_decoder = getattr(getattr(model, "config", None), "is_decoder", False)
+            atol, rtol = 1e-4, 1e-4
+            if self.torch_device in ["mlu"]:
+                atol, rtol = 1e-3, 1e-3  # MLU
+            if model_id == "trl-internal-testing/tiny-GptOssForCausalLM":
+                # this tolerance issue with the target_parameters test only occurs on CI with transformers v5
+                atol, rtol = 1e-3, 1e-3
+            if config.peft_type in ("ADALORA", "OFT"):
+                # these methods require a bit higher tolerance
+                atol, rtol = 1e-2, 1e-2
+            if config.peft_type == "ADAMSS":
+                # AdaMSS merges via B @ A @ newB (triple matmul), which accumulates more FP32
+                # rounding error on CPU than the default 1e-4 allows
+                atol, rtol = 1e-3, 1e-3
+            if (config.peft_type in {"IA3", "LORA", "OFT"}) and (model_id in conv_ids):
+                # for some reason, the Conv introduces a larger error
+                atol, rtol = 0.3, 0.01
+            if (config.peft_type == "OFT") and not is_decoder:
+                atol, rtol = 0.3, 0.01
+            if model_id == "trl-internal-testing/tiny-Llama4ForCausalLM":
+                # also getting larger errors here, not exactly sure why
+                atol, rtol = 0.3, 0.01
+            assert torch.allclose(logits, logits_merged, atol=atol, rtol=rtol)
+            assert torch.allclose(logits, logits_unmerged, atol=atol, rtol=rtol)
+            assert torch.allclose(logits, logits_merged_unloaded, atol=atol, rtol=rtol)
+
+            # For this test to work, weights should not be initialized to identity transform (e.g.
+            # init_lora_weights should be False).
+            transformers_model = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+            logits_transformers = transformers_model(**dummy_input)[0]
+            assert not torch.allclose(logits_merged, logits_transformers, atol=1e-10, rtol=1e-10)
+
+            # test that the logits are identical after a save-load-roundtrip
+            if hasattr(model, "save_pretrained"):
+                # model is a transformers model
+                tmp_dirname = tempfile.mkdtemp()
+                # note: not using the context manager here because it fails on Windows CI for some reason
+                try:
+                    model.save_pretrained(tmp_dirname)
+                    model_from_pretrained = self.transformers_class.from_pretrained(tmp_dirname).to(self.torch_device)
+                finally:
+                    try:
+                        shutil.rmtree(tmp_dirname)
+                    except PermissionError:
+                        # windows error
+                        pass
+            else:
+                # model is not a transformers model
+                model_from_pretrained = pickle.loads(pickle.dumps(model))
+
+            logits_merged_from_pretrained = model_from_pretrained(**dummy_input)[0]
+            assert torch.allclose(logits_merged, logits_merged_from_pretrained, atol=atol, rtol=rtol)
+
+    def _test_merge_layers_multi(self, model_id, config_cls, config_kwargs):
+        _skip_if_merging_not_supported(model_id, config_cls, config_kwargs)
+        if issubclass(config_cls, AdaLoraConfig):
+            # AdaLora does not support adding more than 1 adapter
+            pytest.skip("AdaLoRA does not support multiple adapters, skipping this test.")
+        if config_kwargs.get("trainable_token_indices", None) is not None:
+            pytest.skip(
+                "Merging two adapters with trainable tokens is tested elsewhere since adapters with "
+                "the same token indices cannot be merged."
+            )
+
+        config = config_cls(
+            base_model_name_or_path=model_id,
+            **config_kwargs,
+        )
+        if config_cls == VBLoRAConfig:
+            # for VBLoRA, increase this value or else the two adapters are too similar
+            config.init_logits_std *= 100
+            config.init_vector_bank_bound *= 100
+
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+            torch.manual_seed(0)
+            model = get_peft_model(model, config)
+            model = model.to(self.torch_device)
+
+            dummy_input = self.prepare_inputs_for_testing()
+            model.eval()
+
+            with torch.inference_mode():
+                logits_adapter_1 = model(**dummy_input)[0]
+
+            torch.manual_seed(1)
+            model.add_adapter("adapter-2", config)
+            model.set_adapter("adapter-2")
+            model.eval()
+
+            # sanity check: each adapter layer with a 'default' adapter should also have 'adapter-2'
+            containers = (torch.nn.ModuleDict, torch.nn.ParameterDict, BufferDict)
+            num_default = len([m for m in model.modules() if isinstance(m, containers) and "default" in m])
+            num_adapter2 = len([m for m in model.modules() if isinstance(m, containers) and "adapter-2" in m])
+            assert num_default > 0
+            assert num_default == num_adapter2
+
+            with torch.inference_mode():
+                logits_adapter_2 = model(**dummy_input)[0]
+
+            atol, rtol = 1e-3, 1e-3
+            if config_kwargs.get("target_parameters"):
+                # for the MoE test with target parameters, we need tighter tolerances because the adapter influence is smaller
+                atol, rtol = 1e-4, 1e-4
+            assert not torch.allclose(logits_adapter_1, logits_adapter_2, atol=atol, rtol=rtol)
+
+            model.set_adapter("default")
+
+            with torch.inference_mode():
+                logits_adapter_1_after_set = model(**dummy_input)[0]
+
+            assert torch.allclose(logits_adapter_1_after_set, logits_adapter_1, atol=atol, rtol=rtol)
+
+            model_copy = copy.deepcopy(model)
+            model_copy_2 = copy.deepcopy(model)
+            model_merged_all = model.merge_and_unload(adapter_names=["adapter-2", "default"])
+
+            with torch.inference_mode():
+                logits_merged_all = model_merged_all(**dummy_input)[0]
+
+            assert not torch.allclose(logits_merged_all, logits_adapter_2, atol=atol, rtol=rtol)
+            assert not torch.allclose(logits_merged_all, logits_adapter_1, atol=atol, rtol=rtol)
+
+            model_merged_adapter_2 = model_copy.merge_and_unload(adapter_names=["adapter-2"])
+
+            with torch.inference_mode():
+                logits_merged_adapter_2 = model_merged_adapter_2(**dummy_input)[0]
+
+            assert torch.allclose(logits_merged_adapter_2, logits_adapter_2, atol=atol, rtol=rtol)
+
+            model_merged_adapter_default = model_copy_2.merge_and_unload(adapter_names=["default"])
+
+            with torch.inference_mode():
+                logits_merged_adapter_default = model_merged_adapter_default(**dummy_input)[0]
+
+            assert torch.allclose(logits_merged_adapter_default, logits_adapter_1, atol=atol, rtol=rtol)
+
+    def _test_merge_layers_is_idempotent(self, model_id, config_cls, config_kwargs):
+        _skip_if_merging_not_supported(model_id, config_cls, config_kwargs)
+        _skip_if_conv1d_not_supported(model_id, config_cls, config_kwargs)
+
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+            model = get_peft_model(model, config)
+            model = model.to(self.torch_device)
+            model.eval()
+            torch.manual_seed(0)
+            model.merge_adapter()
+            logits_0 = model(**self.prepare_inputs_for_testing())[0]
+
+            # merging again should not change anything
+            # also check warning:
+            with pytest.warns(UserWarning, match="All adapters are already merged, nothing to do"):
+                model.merge_adapter()
+            logits_1 = model(**self.prepare_inputs_for_testing())[0]
+
+            assert torch.allclose(logits_0, logits_1, atol=1e-6, rtol=1e-6)
+
+    def _test_safe_merge(self, model_id, config_cls, config_kwargs):
+        _skip_if_merging_not_supported(model_id, config_cls, config_kwargs)
+        torch.manual_seed(0)
+
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+            model = model.to(self.torch_device).eval()
+
+            inputs = self.prepare_inputs_for_testing()
+            logits_base = model(**inputs)[0]
+
+            model = get_peft_model(model, config).eval()
+            logits_peft = model(**inputs)[0]
+
+            atol, rtol = 1e-6, 1e-6  # default
+            # Initializing with LN tuning cannot be configured to change the outputs (unlike init_lora_weights=False)
+            if not issubclass(config_cls, LNTuningConfig):
+                # sanity check that the logits are different
+                assert not torch.allclose(logits_base, logits_peft, atol=atol, rtol=rtol)
+
+            model_unloaded = model.merge_and_unload(safe_merge=True)
+            logits_unloaded = model_unloaded(**inputs)[0]
+
+            if self.torch_device in ["mlu"]:
+                atol, rtol = 1e-3, 1e-3  # MLU
+
+            conv_ids = ["Conv2d", "Conv3d", "Conv2d2"]
+            if (
+                issubclass(config_cls, (IA3Config, LoraConfig, HiraConfig)) and model_id in conv_ids
+            ):  # more instability with Conv
+                atol, rtol = 1e-3, 1e-3
+            elif issubclass(config_cls, PveraConfig):
+                atol, rtol = 1e-5, 1e-5
+
+            if config.peft_type == "ADAMSS":
+                # AdaMSS merges via B @ A @ newB (triple matmul), which accumulates more FP32
+                # rounding error on CPU than the default 1e-6 allows
+                atol, rtol = 1e-3, 1e-3
+
+            # check that the logits are the same after unloading
+            assert torch.allclose(logits_peft, logits_unloaded, atol=atol, rtol=rtol)
+
+            # Ensure that serializing with safetensors works, there was an error when weights were not contiguous
+            with tempfile.TemporaryDirectory() as tmp_dirname:
+                # serializing with torch.save works
+                torch.save(model_unloaded.state_dict(), os.path.join(tmp_dirname, "model.bin"))
+
+                # serializing with safetensors works
+                save_file(model_unloaded.state_dict(), os.path.join(tmp_dirname, "model.safetensors"))
+
+    def _test_mixed_adapter_batches(self, model_id, config_cls, config_kwargs):
+        # Test for mixing different adapters in a single batch by passing the adapter_names argument
+        if config_cls not in (LoraConfig, RoadConfig):
+            pytest.skip(f"Mixed adapter batches not supported for {config_cls}")
+
+        config = config_cls(
+            base_model_name_or_path=model_id,
+            **config_kwargs,
+        )
+
+        torch.manual_seed(0)
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+            model = get_peft_model(model, config, adapter_name="adapter0").eval()
+            model.add_adapter("adapter1", config)
+            model = model.to(self.torch_device).eval()
+
+        self.perturb_trainable_token_weights_if_used(model, config_kwargs, adapter_name="adapter0")
+        self.perturb_trainable_token_weights_if_used(model, config_kwargs, adapter_name="adapter1")
+
+        dummy_input = self.prepare_inputs_for_testing()
+        # ensure that we have at least 3 samples for this test
+        dummy_input = {k: torch.cat([v for _ in range(3)]) for k, v in dummy_input.items()}
+        with torch.inference_mode(), model.disable_adapter():
+            output_base = model(**dummy_input)[0]
+            logits_base = model.generate(**dummy_input, return_dict_in_generate=True, output_scores=True).scores[0]
+
+        model.set_adapter("adapter0")
+        with torch.inference_mode():
+            output_adapter0 = model(**dummy_input)[0]
+            logits_adapter0 = model.generate(**dummy_input, return_dict_in_generate=True, output_scores=True).scores[0]
+
+        model.set_adapter("adapter1")
+        with torch.inference_mode():
+            output_adapter1 = model(**dummy_input)[0]
+            logits_adapter1 = model.generate(**dummy_input, return_dict_in_generate=True, output_scores=True).scores[0]
+
+        atol, rtol = 1e-4, 1e-4
+        # sanity check that there are enough outputs and that they are different
+        assert len(output_base) == len(output_adapter0) == len(output_adapter1) >= 3
+        assert len(logits_base) == len(logits_adapter0) == len(logits_adapter1) >= 3
+        assert not torch.allclose(output_base, output_adapter0, atol=atol, rtol=rtol)
+        assert not torch.allclose(output_base, output_adapter1, atol=atol, rtol=rtol)
+        assert not torch.allclose(output_adapter0, output_adapter1, atol=atol, rtol=rtol)
+        assert not torch.allclose(logits_base, logits_adapter0, atol=atol, rtol=rtol)
+        assert not torch.allclose(logits_base, logits_adapter1, atol=atol, rtol=rtol)
+        assert not torch.allclose(logits_adapter0, logits_adapter1, atol=atol, rtol=rtol)
+
+        # alternate between base model, adapter0, and adapter1
+        adapters = ["__base__", "adapter0", "adapter1"]
+        dummy_input["adapter_names"] = [adapters[i % 3] for i in (range(len(dummy_input["input_ids"])))]
+        with torch.inference_mode():
+            output_mixed = model(**dummy_input)[0]
+            logits_mixed = model.generate(**dummy_input, return_dict_in_generate=True, output_scores=True).scores[0]
+
+        assert torch.allclose(output_base[::3], output_mixed[::3], atol=atol, rtol=rtol)
+        assert torch.allclose(output_adapter0[1::3], output_mixed[1::3], atol=atol, rtol=rtol)
+        assert torch.allclose(output_adapter1[2::3], output_mixed[2::3], atol=atol, rtol=rtol)
+        assert torch.allclose(logits_base[::3], logits_mixed[::3], atol=atol, rtol=rtol)
+        assert torch.allclose(logits_adapter0[1::3], logits_mixed[1::3], atol=atol, rtol=rtol)
+        assert torch.allclose(logits_adapter1[2::3], logits_mixed[2::3], atol=atol, rtol=rtol)
+
+    def _test_generate_with_mixed_adapter_batches_and_beam_search(self, model_id, config_cls, config_kwargs):
+        # Test generating with beam search and with mixing different adapters in a single batch by passing the
+        # adapter_names argument. See #2283.
+        if config_cls not in (LoraConfig,):
+            # note: RoAD supports mixed adapter batches but not beam search
+            pytest.skip(f"Mixed adapter batches not supported for {config_cls}")
+        if config_kwargs.get("alora_invocation_tokens") is not None:
+            pytest.skip("Beam search not yet supported for aLoRA")  # beam search not yet fully supported
+        if config_kwargs.get("trainable_token_indices", None) is not None:
+            # for some configurations this test will fail since the adapter values don't differ.
+            # this is probably a problem with the test setup and not with the implementation.
+            pytest.skip("Trainable token indices is not supported here (yet).")
+
+        config = config_cls(
+            base_model_name_or_path=model_id,
+            **config_kwargs,
+        )
+
+        torch.manual_seed(0)
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+            model = get_peft_model(model, config, adapter_name="adapter0").eval()
+            model.add_adapter("adapter1", config)
+
+            # In contrast to forward, for generate, it can sometimes happen that we get the same results as the base model
+            # even with LoRA applied because the impact of LoRA is not big enough. Therefore, use this "trick" to make LoRA
+            # stronger.
+            for name, param in model.named_parameters():
+                if model.base_model.prefix in name:
+                    param.data.mul_(10.0)
+
+            model = model.to(self.torch_device).eval()
+
+            dummy_input = self.prepare_inputs_for_testing()
+            # ensure that we have at least 3 samples for this test
+            dummy_input = {k: torch.cat([v for _ in range(3)]) for k, v in dummy_input.items()}
+            gen_kwargs = {**dummy_input, "max_length": 20, "num_beams": 10, "early_stopping": True}
+            with torch.inference_mode(), model.disable_adapter():
+                gen_base = model.generate(**gen_kwargs)
+
+            model.set_adapter("adapter0")
+            with torch.inference_mode():
+                gen_adapter0 = model.generate(**gen_kwargs)
+
+            model.set_adapter("adapter1")
+            with torch.inference_mode():
+                gen_adapter1 = model.generate(**gen_kwargs)
+
+        def remove_padding(seq, pad_value):
+            lst = list(seq)
+            while lst and (lst[-1] == pad_value):
+                lst.pop()
+            return lst
+
+        def gens_are_same(gen0, gen1):
+            # Special function to compare generations. We cannot use torch.allclose it will raise an error when sequence
+            # lengths differ. Morevoer, we need to remove the padding from the sequences. This is because, even though
+            # normally identical sequences should have the same length, when we do mixed adapter batches, each sample
+            # will be padded to the longest sequence in that mixed batch, which can be different from the longest
+            # sequence without mixed adapter batches.
+            pad_value = model.config.eos_token_id
+            for sample0, sample1 in zip(gen0, gen1):
+                sample0 = remove_padding(sample0, pad_value)
+                sample1 = remove_padding(sample1, pad_value)
+                if (len(sample0) != len(sample1)) or (sample0 != sample1):
+                    # at least one sample differs, the generations are not identical
+                    return False
+            return True
+
+        # sanity check that there are enough outputs and that they are different
+        assert len(gen_base) == len(gen_adapter0) == len(gen_adapter1)
+        assert len(gen_adapter1) >= 3
+        assert not gens_are_same(gen_base, gen_adapter0)
+        assert not gens_are_same(gen_base, gen_adapter1)
+        assert not gens_are_same(gen_adapter0, gen_adapter1)
+
+        # alternate between base model, adapter0, and adapter1
+        adapters = ["__base__", "adapter0", "adapter1"]
+        gen_kwargs["adapter_names"] = [adapters[i % 3] for i in (range(len(dummy_input["input_ids"])))]
+
+        with torch.inference_mode():
+            gen_mixed = model.generate(**gen_kwargs)
+
+        assert gens_are_same(gen_base[::3], gen_mixed[::3])
+        assert gens_are_same(gen_adapter0[1::3], gen_mixed[1::3])
+        assert gens_are_same(gen_adapter1[2::3], gen_mixed[2::3])
+
+    def _test_generate(self, model_id, config_cls, config_kwargs):
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+            model = get_peft_model(model, config)
+            model = model.to(self.torch_device)
+
+            inputs = self.prepare_inputs_for_testing()
+
+            # check if `generate` works
+            _ = model.generate(**inputs)
+
+    def _test_generate_pos_args(self, model_id, config_cls, config_kwargs, raises_err: bool):
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+            model = get_peft_model(model, config)
+            model = model.to(self.torch_device)
+
+            inputs = self.prepare_inputs_for_testing()
+            if raises_err:
+                with pytest.raises(TypeError):
+                    # check if `generate` raises an error if positional arguments are passed
+                    _ = model.generate(inputs["input_ids"])
+            else:
+                # check if `generate` works if positional arguments are passed
+                _ = model.generate(inputs["input_ids"])
+
+    def _test_generate_half_prec(self, model_id, config_cls, config_kwargs):
+        _skip_if_conv1d_not_supported(model_id, config_cls, config_kwargs)
+
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id, dtype=torch.bfloat16)
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+            model = get_peft_model(model, config)
+            model = model.to(self.torch_device)
+
+            input_ids = torch.LongTensor([[1, 1, 1], [2, 1, 2]]).to(self.torch_device)
+            attention_mask = torch.LongTensor([[1, 1, 1], [1, 0, 1]]).to(self.torch_device)
+
+            # check if `generate` works
+            _ = model.generate(input_ids=input_ids, attention_mask=attention_mask)
+
+    def _test_training(self, model_id, config_cls, config_kwargs):
+        if (config_cls == AdaLoraConfig) and ("roberta" in model_id.lower()):
+            # TODO: no gradients on the "dense" layer, other layers work, not sure why
+            pytest.skip("AdaLora with RoBERTa does not work correctly")
+        if (config_cls == PrefixTuningConfig) and ("bert" in model_id.lower()):
+            # TODO: prefix tuning fails with roberta, deberta, etc., requires investigation
+            pytest.skip("Prefix tuning fails with Bert* type models.")
+
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+            model = get_peft_model(model, config)
+            model = model.to(self.torch_device)
+
+            inputs = self.prepare_inputs_for_testing()
+
+            # check if `training` works
+            output = model(**inputs)[0]
+            loss = output.sum()
+            loss.backward()
+
+            if issubclass(config_cls, PromptLearningConfig):
+                # we cannot reliably identify the trainable part of the prompt learning method, thus skipping this check
+                return
+
+            for n, param in model.named_parameters():
+                if (model.prefix in n) or ("modules_to_save" in n) or ("token_adapter.trainable_tokens" in n):
+                    # variants like MiCA intentionally freeze a subset of adapter params, which won't have a grad
+                    if param.requires_grad:
+                        assert param.grad is not None
+                    else:
+                        assert param.grad is None
+                else:
+                    assert param.grad is None
+
+    def _test_inference_safetensors(self, model_id, config_cls, config_kwargs):
+        if (config_cls == PrefixTuningConfig) and ("deberta" in model_id.lower()):
+            # TODO: raises an error:
+            # TypeError: DebertaModel.forward() got an unexpected keyword argument 'past_key_values'
+            pytest.skip("DeBERTa with PrefixTuning does not work correctly")
+
+        config = config_cls(
+            base_model_name_or_path=model_id,
+            **config_kwargs,
+        )
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+            model = get_peft_model(model, config)
+            model = model.to(self.torch_device)
+
+            inputs = self.prepare_inputs_for_testing()
+
+            # check if `training` works
+            output = model(**inputs)[0]
+            logits = output[0]
+
+            loss = output.sum()
+            loss.backward()
+
+            # set to eval mode, since things like dropout can affect the output otherwise
+            model.eval()
+            logits = model(**inputs)[0][0]
+
+            with tempfile.TemporaryDirectory() as tmp_dirname:
+                model.save_pretrained(tmp_dirname, safe_serialization=True)
+                assert "adapter_model.safetensors" in os.listdir(tmp_dirname)
+                assert "adapter_model.bin" not in os.listdir(tmp_dirname)
+
+                model_from_pretrained = self.transformers_class.from_pretrained(model_id)
+                model_from_pretrained = PeftModel.from_pretrained(model_from_pretrained, tmp_dirname).to(
+                    self.torch_device
+                )
+
+                logits_from_pretrained = model_from_pretrained(**inputs)[0][0]
+                assert torch.allclose(logits, logits_from_pretrained, atol=1e-4, rtol=1e-4)
+
+    def _test_training_layer_indexing(self, model_id, config_cls, config_kwargs):
+        if config_cls in (VBLoRAConfig, VeraConfig, UniLoraConfig):
+            # TODO investigate why these methods are flaky
+            # pytest tests/test_decoder_models.py tests/test_feature_extraction_models.py -k "layer_indexing and (vera
+            # or vblora)"
+            # UniLora uses one shared trainable theta_d parameter, so the generic trainable-parameter count assertion
+            # does not decrease when fewer layers are targeted.
+            pytest.skip(
+                "VBLoRA, VeRA, and UniLora use shared weights, so this generic layer-indexing count check is skipped."
+            )
+        try:
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                layers_to_transform=[0],
+                **config_kwargs,
+            )
+        except TypeError:
+            pytest.skip("This PEFT method does not support layers_to_transform, skipping it.")
+        _skip_if_conv1d_not_supported(model_id, config_cls, config_kwargs)
+
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+            model = get_peft_model(model, config)
+            model = model.to(self.torch_device)
+
+            inputs = self.prepare_inputs_for_testing()
+
+            # check if `training` works
+            output = model(**inputs)[0]
+
+            loss = output.sum()
+            loss.backward()
+
+            has_trainable_tokens = config_kwargs.get("trainable_token_indices", None) is not None
+            nb_trainable = 0
+
+            for n, param in model.named_parameters():
+                if model.prefix in n or (has_trainable_tokens and "trainable_tokens" in n):
+                    assert param.grad is not None
+                    nb_trainable += 1
+                else:
+                    assert param.grad is None
+
+            with tempfile.TemporaryDirectory() as tmp_dirname:
+                model.eval()
+                logits = model(**inputs)[0][0]
+
+                model.save_pretrained(tmp_dirname)
+
+                model_from_pretrained = self.transformers_class.from_pretrained(model_id)
+                model_from_pretrained = PeftModel.from_pretrained(model_from_pretrained, tmp_dirname).to(
+                    self.torch_device
+                )
+
+                logits_from_pretrained = model_from_pretrained(**inputs)[0][0]
+                atol, rtol = 1e-4, 1e-4
+                assert torch.allclose(logits, logits_from_pretrained, atol=atol, rtol=rtol)
+
+            # check the nb of trainable params again but without layers_to_transform
+            model = self.transformers_class.from_pretrained(model_id)
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+            model = get_peft_model(model, config)
+            nb_trainable_all = 0
+
+            for n, param in model.named_parameters():
+                if model.prefix in n or (has_trainable_tokens and "trainable_tokens" in n):
+                    nb_trainable_all += 1
+
+            mod_list = next((m for m in model.modules() if isinstance(m, torch.nn.ModuleList)), None)
+            if mod_list and len(mod_list) == 1:
+                # there is only a single layer
+                assert nb_trainable == nb_trainable_all
+            else:
+                # more than 1 layer, i.e. setting layers_to_transform=[0] should target fewer layers
+                assert nb_trainable < nb_trainable_all
+
+    def _test_training_gradient_checkpointing(self, model_id, config_cls, config_kwargs, use_reentrant=True):
+        # Note that certain configurations, such as activated lora with 'alora_invocation_tokens': [1000], do not
+        # generate gradients since the adapter is never activated so this will be a no-op for this test. It is still
+        # a valid test but it might be confusing to see a test pass if it is not supposed to.
+
+        if config_cls == PrefixTuningConfig:
+            pytest.skip("Prefix Tuning does not support gradient checkpointing, skipping this test.")
+        if (config_cls == AdaLoraConfig) and ("roberta" in model_id.lower()):
+            # TODO: no gradients on the "dense" layer, other layers work, not sure why
+            pytest.skip("AdaLora with RoBERTa does not work correctly")
+
+        if not is_transformers_ge_v5:
+            # TODO: remove once transformers < 5.0 no longer supported
+            if "gptbigcode" in model_id.lower():
+                pytest.skip("GPTBigCode doesn't implement gradient checkpointing correctly in transformers < 5.0.")
+            if "bart" in model_id.lower():
+                pytest.skip(
+                    "Bart in transformers < 5.0 doesn't handle input sharing well enough. See transformers#41821"
+                )
+
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+
+            if not getattr(model, "supports_gradient_checkpointing", False):
+                pytest.skip(f"Model {model_id} does not support gradient checkpointing")
+
+            # Disable lora_dropout and friends to remove non-determinism in gradient creation
+            for key in list(config_kwargs.keys()):
+                if key.endswith("dropout"):
+                    del config_kwargs[key]
+
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+            model = get_peft_model(model, config)
+            model = model.to(self.torch_device)
+            params = [(n, p) for n, p in model.named_parameters() if p.requires_grad]
+
+            # if we don't set this, gradient checkpointing is not activated.
+            model.train(True)
+
+            inputs = self.prepare_inputs_for_testing()
+
+            # invocation to get the reference non-zero grads that are supposed to exist without gradient checkpointing;
+            # note we're squaring the output for bigger gradients
+            output = model(**inputs)[0] ** 2
+
+            loss = output.sum()
+            loss.backward()
+
+            non_zero_grad_params_normal = {n for n, p in params if p.grad.abs().sum() > 0}
+
+            for name, param in params:
+                param.grad = None
+
+            # invocation with gradient checkpointing for comparison
+            model.prepare_model_for_gradient_checkpointing(model)
+            model.gradient_checkpointing_enable({"use_reentrant": use_reentrant})
+
+            output = model(**inputs)[0] ** 2
+
+            loss = output.sum()
+            loss.backward()
+
+            non_zero_grad_params_checkpointing = {n for n, p in params if p.grad.abs().sum() > 0}
+            assert non_zero_grad_params_normal == non_zero_grad_params_checkpointing
+
+            for n, param in model.named_parameters():
+                if "prompt_encoder." in n:  # prompt tuning methods
+                    if not issubclass(config_cls, CPTConfig):
+                        assert param.grad is not None
+                    elif (
+                        "delta_embedding" in n
+                    ):  # delta_embedding is the embedding that should be updated with grads in CPT
+                        assert param.grad is not None
+                elif (
+                    hasattr(model, "prefix") and (model.prefix in n) or "trainable_tokens_" in n
+                ):  # non-prompt tuning methods
+                    assert param.grad is not None
+                else:
+                    assert param.grad is None
+
+    def _test_peft_model_device_map(self, model_id, config_cls, config_kwargs):
+        _skip_if_conv1d_not_supported(model_id, config_cls, config_kwargs)
+        config = config_cls(
+            base_model_name_or_path=model_id,
+            **config_kwargs,
+        )
+
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+
+            model = get_peft_model(model, config)
+            model = model.to(self.torch_device)
+
+            with tempfile.TemporaryDirectory() as tmp_dirname:
+                model.save_pretrained(tmp_dirname)
+
+                model_from_pretrained = self.transformers_class.from_pretrained(model_id)
+                _ = PeftModel.from_pretrained(model_from_pretrained, tmp_dirname, device_map={"": "cpu"}).to(
+                    self.torch_device
+                )
+
+    def _test_training_prompt_learning_tasks(self, model_id, config_cls, config_kwargs):
+        if not issubclass(config_cls, PromptLearningConfig):
+            pytest.skip(f"Test not applicable for {config_cls}")
+
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+            model = get_peft_model(model, config)
+            model = model.to(self.torch_device)
+
+            inputs = self.prepare_inputs_for_testing()
+
+            # check if `training` works
+            output = model(**inputs)[0]
+            loss = output.sum()
+            loss.backward()
+
+            if issubclass(config_cls, CPTConfig):
+                parameters = []
+                for name, param in model.prompt_encoder.named_parameters():
+                    if name != "default.embedding.weight":
+                        parameters.append(param)
+            else:
+                parameters = model.prompt_encoder.parameters()
+
+            # check that prompt encoder has grads
+            for param in parameters:
+                assert param.grad is not None
+
+    def _test_delete_adapter(self, model_id, config_cls, config_kwargs):
+        _skip_if_deleting_adapter_not_supported(config_cls, config_kwargs)
+        if config_cls == AdaLoraConfig:
+            pytest.skip("AdaLoRA does not support multiple adapters")
+
+        config = config_cls(
+            base_model_name_or_path=model_id,
+            **config_kwargs,
+        )
+
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+            adapter_to_delete = "delete_me"
+            model = get_peft_model(model, config)
+            model.add_adapter(adapter_to_delete, config)
+            model.set_adapter(adapter_to_delete)
+            model = model.to(self.torch_device)
+            model.delete_adapter(adapter_to_delete)
+            assert adapter_to_delete not in model.peft_config
+            assert model.active_adapters == ["default"]
+
+            key_list = [key for key, _ in model.named_modules()]
+            for key in key_list:
+                _, target, _ = _get_submodules(model, key)
+                attributes_to_check = getattr(target, "adapter_layer_names", []) + getattr(
+                    target, "other_param_names", []
+                )
+                for attr in attributes_to_check:
+                    assert adapter_to_delete not in attrgetter(attr)(target)
+
+            # check auxiliary modules
+            for module in model.modules():
+                if isinstance(module, AuxiliaryTrainingWrapper):
+                    assert adapter_to_delete not in module._adapters
+                    assert module.active_adapters == ["default"]
+                if isinstance(module, ModulesToSaveWrapper):
+                    assert adapter_to_delete not in module.modules_to_save
+                elif isinstance(module, TrainableTokensWrapper):
+                    assert adapter_to_delete not in module.token_adapter.trainable_tokens_delta
+                    assert adapter_to_delete not in module.token_adapter.trainable_tokens_original
+
+            # check that we can also delete the last remaining adapter
+            model.delete_adapter("default")
+            assert "default" not in model.peft_config
+            assert model.active_adapters == []
+
+            for module in model.modules():
+                if isinstance(module, AuxiliaryTrainingWrapper):
+                    assert "default" not in module._adapters
+                    assert module.active_adapters == []
+                if isinstance(module, ModulesToSaveWrapper):
+                    assert "default" not in module.modules_to_save
+                elif isinstance(module, TrainableTokensWrapper):
+                    assert "default" not in module.token_adapter.trainable_tokens_delta
+                    assert "default" not in module.token_adapter.trainable_tokens_original
+
+            input = self.prepare_inputs_for_testing()
+            # note: we cannot call model(**input) because PeftModel always expects there to be at least one adapter
+            model.base_model(**input)  # should not raise an error
+
+    def _test_delete_inactive_adapter(self, model_id, config_cls, config_kwargs):
+        if config_cls == AdaLoraConfig:
+            pytest.skip("AdaLoRA does not support multiple adapters")
+        _skip_if_deleting_adapter_not_supported(config_cls, config_kwargs)
+
+        config = config_cls(
+            base_model_name_or_path=model_id,
+            **config_kwargs,
+        )
+
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+            adapter_to_delete = "delete_me"
+            model = get_peft_model(model, config)
+            model.add_adapter(adapter_to_delete, config)
+            # "delete_me" is added but not activated
+            model = model.to(self.torch_device)
+            model.delete_adapter(adapter_to_delete)
+            assert adapter_to_delete not in model.peft_config
+            assert model.active_adapters == ["default"]
+
+            key_list = [key for key, _ in model.named_modules()]
+            for key in key_list:
+                _, target, _ = _get_submodules(model, key)
+                attributes_to_check = getattr(target, "adapter_layer_names", []) + getattr(
+                    target, "other_param_names", []
+                )
+                for attr in attributes_to_check:
+                    assert adapter_to_delete not in attrgetter(attr)(target)
+
+            # check auxiliary modules
+            for module in model.modules():
+                if isinstance(module, AuxiliaryTrainingWrapper):
+                    assert adapter_to_delete not in module._adapters
+                    assert module.active_adapters == ["default"]
+                if isinstance(module, ModulesToSaveWrapper):
+                    assert adapter_to_delete not in module.modules_to_save
+                elif isinstance(module, TrainableTokensWrapper):
+                    assert adapter_to_delete not in module.token_adapter.trainable_tokens_delta
+                    assert adapter_to_delete not in module.token_adapter.trainable_tokens_original
+
+            # check that we can also delete the last remaining adapter
+            model.delete_adapter("default")
+            assert "default" not in model.peft_config
+            assert model.active_adapters == []
+
+            for module in model.modules():
+                if isinstance(module, AuxiliaryTrainingWrapper):
+                    assert "default" not in module._adapters
+                    assert module.active_adapters == []
+                if isinstance(module, ModulesToSaveWrapper):
+                    assert "default" not in module.modules_to_save
+                elif isinstance(module, TrainableTokensWrapper):
+                    assert "default" not in module.token_adapter.trainable_tokens_delta
+                    assert "default" not in module.token_adapter.trainable_tokens_original
+
+            input = self.prepare_inputs_for_testing()
+            # note: we cannot call model(**input) because PeftModel always expects there to be at least one adapter
+            model.base_model(**input)  # should not raise an error
+
+    def _test_delete_unknown_adapter_raises(self, model_id, config_cls, config_kwargs):
+        # Check that we get a nice error message when trying to delete an adapter that does not exist.
+        config = config_cls(base_model_name_or_path=model_id, **config_kwargs)
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+            adapter_to_delete = "delete_me"
+            model = get_peft_model(model, config)
+
+            msg = "Adapter unknown-adapter does not exist"
+            with pytest.raises(ValueError, match=msg):
+                model.delete_adapter("unknown-adapter")
+
+    def _test_unload_adapter(self, model_id, config_cls, config_kwargs):
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+        num_params_base = len(model.state_dict())
+        dummy_input = self.prepare_inputs_for_testing()
+        with torch.inference_mode():
+            logits_transformers = model(**dummy_input)[0]
+
+        config = config_cls(
+            base_model_name_or_path=model_id,
+            **config_kwargs,
+        )
+        model = get_peft_model(model, config)
+        model = model.to(self.torch_device)
+
+        if isinstance(config, PromptLearningConfig):
+            # prompt learning does not support unloading
+            with pytest.raises(AttributeError):
+                model = model.unload()
+        else:
+            self.perturb_trainable_token_weights_if_used(model, config_kwargs)
+            with torch.inference_mode():
+                logits_with_adapter = model(**dummy_input)[0]
+
+            model.eval()
+            model = model.unload()
+            num_params_unloaded = len(model.state_dict())
+            with torch.inference_mode():
+                logits_unload = model(**dummy_input)[0]
+
+            # check that PEFT layers are completely removed
+            assert not any(isinstance(module, BaseTunerLayer) for module in model.modules())
+            assert not hasattr(model, "peft_config")
+            assert not torch.allclose(logits_with_adapter, logits_unload, atol=1e-10, rtol=1e-10)
+            assert torch.allclose(logits_transformers, logits_unload, atol=1e-4, rtol=1e-4)
+            assert num_params_base == num_params_unloaded
+
+    def _test_weighted_combination_of_adapters_lora(self, model, config, adapter_list, weight_list):
+        _skip_if_adding_weighted_adapters_not_supported(config)
+        model.add_adapter(adapter_list[1], config)
+        model.add_adapter(adapter_list[2], replace(config, r=20))
+        model = model.to(self.torch_device)
+
+        # test re-weighting single adapter
+        model.add_weighted_adapter([adapter_list[0]], [weight_list[0]], "single_adapter_reweighting")
+
+        # test svd re-weighting with multiple adapters
+        model.add_weighted_adapter(adapter_list[1:], weight_list[1:], "multi_adapter_svd_reweighting")
+
+        # test ties_svd re-weighting with multiple adapters
+        model.add_weighted_adapter(
+            adapter_list[1:],
+            weight_list[1:],
+            "multi_adapter_ties_svd_reweighting",
+            combination_type="ties_svd",
+            density=0.5,
+        )
+
+        # test dare_linear_svd re-weighting with multiple adapters
+        model.add_weighted_adapter(
+            adapter_list[1:],
+            weight_list[1:],
+            "multi_adapter_dare_linear_svd_reweighting",
+            combination_type="dare_linear_svd",
+            density=0.5,
+        )
+
+        # test dare_ties_svd re-weighting with multiple adapters
+        model.add_weighted_adapter(
+            adapter_list[1:],
+            weight_list[1:],
+            "multi_adapter_dare_ties_svd_reweighting",
+            combination_type="dare_ties_svd",
+            density=0.5,
+        )
+
+        # test magnitude_prune_svd re-weighting with multiple adapters
+        model.add_weighted_adapter(
+            adapter_list[1:],
+            weight_list[1:],
+            "multi_adapter_magnitude_prune_svd_reweighting",
+            combination_type="magnitude_prune_svd",
+            density=0.5,
+        )
+
+        # test cat re-weighting with multiple adapters
+        model.add_weighted_adapter(
+            adapter_list[1:], weight_list[1:], "multi_adapter_cat_reweighting", combination_type="cat"
+        )
+
+        # test linear re-weighting with multiple adapters
+        model.add_weighted_adapter(
+            adapter_list[:2], weight_list[:2], "multi_adapter_linear_reweighting", combination_type="linear"
+        )
+
+        # test ties re-weighting with multiple adapters
+        model.add_weighted_adapter(
+            adapter_list[:2], weight_list[:2], "multi_adapter_ties_reweighting", combination_type="ties", density=0.5
+        )
+
+        # test dare_linear re-weighting with multiple adapters
+        model.add_weighted_adapter(
+            adapter_list[:2],
+            weight_list[:2],
+            "multi_adapter_dare_linear_reweighting",
+            combination_type="dare_linear",
+            density=0.5,
+        )
+
+        # test dare_ties re-weighting with multiple adapters
+        model.add_weighted_adapter(
+            adapter_list[:2],
+            weight_list[:2],
+            "multi_adapter_dare_ties_reweighting",
+            combination_type="dare_ties",
+            density=0.5,
+        )
+
+        # test magnitude_prune re-weighting with multiple adapters
+        model.add_weighted_adapter(
+            adapter_list[:2],
+            weight_list[:2],
+            "multi_adapter_magnitude_prune_reweighting",
+            combination_type="magnitude_prune",
+            density=0.5,
+        )
+
+        # test linear re-weighting with multiple adapters with only first adapter having non zero weight
+        model.add_weighted_adapter(
+            adapter_list[:2],
+            [weight_list[0], 0],
+            "multi_adapter_linear_reweighting_single_enabled",
+            combination_type="linear",
+        )
+
+        with pytest.raises(ValueError):
+            model.add_weighted_adapter(
+                adapter_list[1:],
+                weight_list[1:],
+                "multi_adapter_linear_reweighting_uneven_r",
+                combination_type="linear",
+            )
+
+        with pytest.raises(ValueError):
+            model.add_weighted_adapter(
+                adapter_list[1:],
+                weight_list[1:],
+                "multi_adapter_ties_reweighting_uneven_r",
+                combination_type="ties",
+                density=0.5,
+            )
+
+        with pytest.raises(ValueError):
+            model.add_weighted_adapter(
+                adapter_list[1:],
+                weight_list[1:],
+                "multi_adapter_dare_linear_reweighting_uneven_r",
+                combination_type="dare_linear",
+                density=0.5,
+            )
+
+        with pytest.raises(ValueError):
+            model.add_weighted_adapter(
+                adapter_list[1:],
+                weight_list[1:],
+                "multi_adapter_dare_ties_reweighting_uneven_r",
+                combination_type="dare_ties",
+                density=0.5,
+            )
+
+        with pytest.raises(ValueError):
+            model.add_weighted_adapter(
+                adapter_list[1:],
+                weight_list[1:],
+                "multi_adapter_magnitude_prune_reweighting_uneven_r",
+                combination_type="magnitude_prune",
+                density=0.5,
+            )
+
+        new_adapters = [
+            "single_adapter_reweighting",
+            "multi_adapter_svd_reweighting",
+            "multi_adapter_ties_svd_reweighting",
+            "multi_adapter_dare_linear_svd_reweighting",
+            "multi_adapter_dare_ties_svd_reweighting",
+            "multi_adapter_magnitude_prune_svd_reweighting",
+            "multi_adapter_cat_reweighting",
+            "multi_adapter_linear_reweighting",
+            "multi_adapter_linear_reweighting_single_enabled",
+            "multi_adapter_ties_reweighting",
+            "multi_adapter_dare_linear_reweighting",
+            "multi_adapter_dare_ties_reweighting",
+            "multi_adapter_magnitude_prune_reweighting",
+        ]
+        for new_adapter in new_adapters:
+            assert new_adapter in model.peft_config
+
+        key_list = [key for key, _ in model.named_modules()]
+        for key in key_list:
+            _, target, _ = _get_submodules(model, key)
+            if isinstance(target, LoraLayer):
+                for adapter_name in new_adapters:
+                    if "single" in adapter_name:
+                        new_delta_weight = target.get_delta_weight(adapter_name)
+                        weighted_original_delta_weights = target.get_delta_weight(adapter_list[0]) * weight_list[0]
+                        sign = 1 if weight_list[0] > 0 else -1
+                        weighted_original_delta_weights = sign * weighted_original_delta_weights
+                        assert torch.allclose(new_delta_weight, weighted_original_delta_weights, atol=1e-4, rtol=1e-4)
+                    elif "svd" in adapter_name:
+                        assert target.r[adapter_name] == 20
+                    elif "linear" in adapter_name:
+                        assert target.r[adapter_name] == 8
+                    elif "cat" in adapter_name:
+                        assert target.r[adapter_name] == 28
+
+        dummy_input = self.prepare_inputs_for_testing()
+        model.eval()
+        for adapter_name in new_adapters:
+            # ensuring new adapters pass the forward loop
+            model.set_adapter(adapter_name)
+            assert model.active_adapter == adapter_name
+            assert model.active_adapters == [adapter_name]
+            model(**dummy_input)[0]
+
+    def _test_weighted_combination_of_adapters_ia3(self, model, config, adapter_list, weight_list):
+        model.add_adapter(adapter_list[1], config)
+        model.add_adapter(adapter_list[2], config)
+        model = model.to(self.torch_device)
+
+        # test re-weighting single adapter
+        model.add_weighted_adapter([adapter_list[0]], [weight_list[0]], "single_adapter_reweighting")
+
+        # test re-weighting with multiple adapters
+        model.add_weighted_adapter(adapter_list[1:], weight_list[1:], "multi_adapter_reweighting")
+
+        new_adapters = [
+            "single_adapter_reweighting",
+            "multi_adapter_reweighting",
+        ]
+        for new_adapter in new_adapters:
+            assert new_adapter in model.peft_config
+
+        dummy_input = self.prepare_inputs_for_testing()
+        model.eval()
+        for adapter_name in new_adapters:
+            # ensuring new adapters pass the forward loop
+            model.set_adapter(adapter_name)
+            assert model.active_adapter == adapter_name
+            assert model.active_adapters == [adapter_name]
+            model(**dummy_input)[0]
+
+    def _test_weighted_combination_of_adapters(self, model_id, config_cls, config_kwargs):
+        if issubclass(config_cls, AdaLoraConfig):
+            # AdaLora does not support adding more than 1 adapter
+            return pytest.skip(f"Test not applicable for {config_cls}")
+        if model_id.endswith("qwen2"):
+            # Qwen2 fails with weighted adapter combinations using SVD
+            return pytest.skip(f"Test does not work with model {model_id}")
+        if "gemma" in model_id.lower():
+            return pytest.skip("Combining Gemma adapters with SVD is currently failing")
+
+        adapter_list = ["adapter1", "adapter_2", "adapter_3"]
+        weight_list = [0.5, 1.5, 1.5]
+        negative_weight_list = [-0.5, -0.8, -1.2]
+        # Initialize the config
+        config = config_cls(
+            base_model_name_or_path=model_id,
+            **config_kwargs,
+        )
+
+        if not isinstance(config, (LoraConfig, IA3Config)):
+            # This test is only applicable for Lora and IA3 configs
+            return pytest.skip(f"Test not applicable for {config}")
+
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+            model = get_peft_model(model, config, adapter_list[0])
+
+            if isinstance(config, LoraConfig):
+                self._test_weighted_combination_of_adapters_lora(model, config, adapter_list, weight_list)
+                self._test_weighted_combination_of_adapters_lora(model, config, adapter_list, negative_weight_list)
+            elif isinstance(config, IA3Config):
+                self._test_weighted_combination_of_adapters_ia3(model, config, adapter_list, weight_list)
+                self._test_weighted_combination_of_adapters_ia3(model, config, adapter_list, negative_weight_list)
+            else:
+                pytest.skip(f"Test not applicable for {config}")
+
+    def _test_disable_adapter(self, model_id, config_cls, config_kwargs):
+        task_type = config_kwargs.get("task_type")
+        if (task_type == "SEQ_2_SEQ_LM") and (config_cls in (PromptTuningConfig, PromptEncoderConfig)):
+            pytest.skip("Seq2Seq + prompt tuning/prompt encoder does not work with disabling adapters")
+
+        def get_output(model):
+            # helper function that works with different model types
+            torch.manual_seed(0)
+
+            if hasattr(model, "generate"):
+                # let's check the scores, not the output ids, since the latter can easily be identical even if the
+                # weights are slightly changed
+                output = model.generate(**input, return_dict_in_generate=True, output_scores=True).scores[0]
+                # take element 0, as output is a tuple
+            else:
+                output = model(**input)
+
+            if hasattr(output, "images"):  # for SD
+                import numpy as np
+
+                img = output.images[0]
+                return torch.from_numpy(np.array(img))
+
+            return output
+
+        # initialize model
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+
+            # output from BASE MODEL
+            input = self.prepare_inputs_for_testing()
+            output_before = get_output(model)
+
+            # output from PEFT MODEL
+            if hasattr(self, "instantiate_sd_peft"):
+                # SD models are instantiated differently
+                peft_model = self.instantiate_sd_peft(model_id, config_cls, config_kwargs)
+            else:
+                config = config_cls(
+                    base_model_name_or_path=model_id,
+                    **config_kwargs,
+                )
+                peft_model = get_peft_model(model, config)
+
+            # trainable_token_indices doesn't have support for `init_weights` so we have to do this manually
+            self.perturb_trainable_token_weights_if_used(model, config_kwargs)
+
+            output_peft = get_output(peft_model)
+
+            # first check trivial case is not true that peft does not affect the output; for this to work, init_weight
+            # must be False (if the config supports it)
+            if isinstance(peft_model, StableDiffusionPipeline):
+                # for SD, check that most pixels have different values
+                assert (output_before != output_peft).float().mean() > 0.8
+            else:
+                assert not torch.allclose(output_before, output_peft)
+
+            # output with DISABLED ADAPTER
+            if isinstance(peft_model, StableDiffusionPipeline):
+                with peft_model.unet.disable_adapter(), peft_model.text_encoder.disable_adapter():
+                    output_peft_disabled = get_output(peft_model)
+                # for SD, very rarely, a pixel can differ
+                assert (output_before != output_peft_disabled).float().mean() < 1e-4
+            else:
+                atol, rtol = 1e-6, 1e-6
+                if (platform.system() == "Windows") and (model_id == "trl-internal-testing/tiny-Llama4ForCausalLM"):
+                    # for some reason, Windows CI fails with stricter tolerance
+                    atol, rtol = 1e-5, 1e-5
+
+                with peft_model.disable_adapter():
+                    output_peft_disabled = get_output(peft_model)
+                assert torch.allclose(output_before, output_peft_disabled, atol=atol, rtol=rtol)
+
+                # after leaving the disable_adapter context, the output should be the same as with enabled adapter again
+                # see #1501
+                output_peft_after_disabled = get_output(peft_model)
+                assert torch.allclose(output_peft, output_peft_after_disabled, atol=atol, rtol=rtol)
+
+            # TODO: add tests to check if disabling adapters works after calling merge_adapter
+
+    def _test_adding_multiple_adapters_with_bias_raises(self, model_id, config_cls, config_kwargs):
+        config_kwargs = config_kwargs.copy()
+        config_kwargs["bias"] = "all"
+        try:
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+        except TypeError:
+            pytest.skip(f"{config_cls} does not support the 'bias' argument, skipping this test.")
+
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+            model = get_peft_model(model, config, "adapter0")
+
+            if config_cls == LoraConfig or config_cls == AdaLoraConfig:
+                with pytest.raises(ValueError):
+                    model.add_adapter("adapter1", replace(config, r=20))
+
+            if config_cls == BOFTConfig:
+                with pytest.raises(ValueError):
+                    model.add_adapter("adapter1", replace(config, boft_block_num=1, boft_block_size=0))
+
+            # (superficial) test that the model is not left in a half-initialized state when adding an adapter fails
+            assert "adapter1" not in model.peft_config
+            assert "adapter1" not in model.base_model.peft_config
+
+    def _test_passing_input_embeds_works(self, test_name, model_id, config_cls, config_kwargs):
+        # https://github.com/huggingface/peft/issues/727
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id)
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+            model = get_peft_model(model, config, adapter_name="test-adapter").to(self.torch_device)
+            dummy_input = self.prepare_inputs_for_testing()
+            inputs_embeds = model.get_input_embeddings()(dummy_input["input_ids"])
+            # just check that no error is raised
+            model.forward(inputs_embeds=inputs_embeds)
+
+    def _test_lora_conversion(self, model_id, config_cls, config_kwargs):
+        # This is a simple test that converting a non-LoRA adapter to LoRA works. If the model doesn't support
+        # conversion, the test is skipped. For detailed tests of this functionality, check test_lora_conversion.py,
+        # which provides depper tests. The purpose of this test is only provide a broad check across PEFT methods.
+        torch.manual_seed(0)
+        if "qwen2" in model_id:  # dummy qwen2 has very small weights
+            rank = 4
+        else:
+            rank = 8
+
+        if config_cls == GraloraConfig:
+            # GraLoRA exhibits higher conversion error
+            max_mse = 1.0
+        else:
+            # relatively high upper limit for MSE since we have to work with a low LoRA rank for dummy models
+            max_mse = 0.5
+
+        with hub_online_once(model_id):
+            model = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+            config = config_cls(
+                base_model_name_or_path=model_id,
+                **config_kwargs,
+            )
+            model = get_peft_model(model, config).eval()
+
+            if not model.supports_lora_conversion():
+                return
+            if ("OPT" in model_id) and ("fc1" in config.target_modules):
+                # the fc1 and fc2 layers in OPT have size (16, 4), thus choose smaller rank
+                rank = 4
+
+            X = self.prepare_inputs_for_testing()
+            with torch.no_grad():
+                with model.disable_adapter():
+                    output_base = model(**X, output_hidden_states=True)
+                output_before = model(**X, output_hidden_states=True)
+
+            # create the converted lora adapter
+            lora_config, state_dict = convert_to_lora(model, rank=rank)
+            del model
+
+            # load the converted LoRA model
+            model = self.transformers_class.from_pretrained(model_id).to(self.torch_device)
+            model = get_peft_model(model, lora_config).eval()
+            load_result = set_peft_model_state_dict(model, state_dict)
+            assert not load_result.unexpected_keys
+
+            with torch.no_grad():
+                output_after = model(**X, output_hidden_states=True)
+
+            diff1 = output_before.hidden_states[-1] - output_base.hidden_states[-1]
+            diff2 = output_after.hidden_states[-1] - output_base.hidden_states[-1]
+            mse = torch.nn.functional.mse_loss(diff1, diff2).item()
+            assert mse < max_mse, f"LoRA conversion MSE too high, {mse:.4f}, only {max_mse:.1f} allowed"
diff --git a/tests/testing_utils.py b/tests/testing_utils.py
new file mode 100644
index 0000000..9474d60
--- /dev/null
+++ b/tests/testing_utils.py
@@ -0,0 +1,375 @@
+# Copyright 2023-present the HuggingFace Inc. 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.
+import os
+from contextlib import contextmanager
+from functools import lru_cache, wraps
+from unittest import mock
+
+import numpy as np
+import pytest
+import torch
+from accelerate.test_utils.testing import get_backend
+from datasets import load_dataset
+
+from peft import (
+    AdaLoraConfig,
+    IA3Config,
+    LNTuningConfig,
+    LoraConfig,
+    PromptLearningConfig,
+    TinyLoraConfig,
+    VBLoRAConfig,
+)
+from peft.import_utils import (
+    is_aqlm_available,
+    is_eetq_available,
+    is_gptqmodel_available,
+    is_hqq_available,
+    is_optimum_available,
+    is_torchao_available,
+    is_transformers_ge_v5,
+)
+
+
+# Globally shared model cache used by `hub_online_once`.
+_HUB_MODEL_ACCESSES = {}
+# Some tests with multi GPU require specific device maps to ensure that the models are loaded in two devices
+DEVICE_MAP_MAP: dict[str, dict[str, int]] = {
+    "facebook/opt-6.7b": {
+        "model.decoder.embed_tokens": 0,
+        "model.decoder.embed_positions": 0,
+        "model.decoder.final_layer_norm": 0,
+        "model.decoder.layers.0": 0,
+        "model.decoder.layers.1": 0,
+        "model.decoder.layers.2": 0,
+        "model.decoder.layers.3": 0,
+        "model.decoder.layers.4": 0,
+        "model.decoder.layers.5": 0,
+        "model.decoder.layers.6": 0,
+        "model.decoder.layers.7": 0,
+        "model.decoder.layers.8": 0,
+        "model.decoder.layers.9": 0,
+        "model.decoder.layers.10": 0,
+        "model.decoder.layers.11": 0,
+        "model.decoder.layers.12": 0,
+        "model.decoder.layers.13": 0,
+        "model.decoder.layers.14": 0,
+        "model.decoder.layers.15": 0,
+        "model.decoder.layers.16": 1,
+        "model.decoder.layers.17": 1,
+        "model.decoder.layers.18": 1,
+        "model.decoder.layers.19": 1,
+        "model.decoder.layers.20": 1,
+        "model.decoder.layers.21": 1,
+        "model.decoder.layers.22": 1,
+        "model.decoder.layers.23": 1,
+        "model.decoder.layers.24": 1,
+        "model.decoder.layers.25": 1,
+        "model.decoder.layers.26": 1,
+        "model.decoder.layers.27": 1,
+        "model.decoder.layers.28": 1,
+        "model.decoder.layers.29": 1,
+        "model.decoder.layers.30": 1,
+        "model.decoder.layers.31": 1,
+        "lm_head": 0,  # tied with embed_tokens
+    },
+    "peft-internal-testing/opt-125m": {
+        "model.decoder.embed_tokens": 0,
+        "model.decoder.embed_positions": 0,
+        "model.decoder.final_layer_norm": 1,
+        "model.decoder.layers.0": 0,
+        "model.decoder.layers.1": 0,
+        "model.decoder.layers.2": 0,
+        "model.decoder.layers.3": 0,
+        "model.decoder.layers.4": 0,
+        "model.decoder.layers.5": 0,
+        "model.decoder.layers.6": 1,
+        "model.decoder.layers.7": 1,
+        "model.decoder.layers.8": 1,
+        "model.decoder.layers.9": 1,
+        "model.decoder.layers.10": 1,
+        "model.decoder.layers.11": 1,
+        "lm_head": 0,
+    },
+    "marcsun13/opt-350m-gptq-4bit": {
+        "model.decoder.embed_tokens": 0,
+        "model.decoder.embed_positions": 0,
+        "model.decoder.layers.0": 0,
+        "model.decoder.layers.1": 0,
+        "model.decoder.layers.2": 0,
+        "model.decoder.layers.3": 0,
+        "model.decoder.layers.4": 0,
+        "model.decoder.layers.5": 0,
+        "model.decoder.layers.6": 1,
+        "model.decoder.layers.7": 1,
+        "model.decoder.layers.8": 1,
+        "model.decoder.layers.9": 1,
+        "model.decoder.layers.10": 1,
+        "model.decoder.layers.11": 1,
+        "model.decoder.final_layer_norm": 1,
+        "lm_head": 0,  # tied with embed_tokens
+    },
+    "google/flan-t5-base": {
+        "shared": 0,
+        "encoder": 0,
+        "decoder": 1,
+        "final_layer_norm": 1,
+        "decoder.embed_tokens": 0,  # tied with encoder.embed_tokens
+        "lm_head": 0,  # tied with encoder.embed_tokens
+    },
+}
+
+
+torch_device, device_count, memory_allocated_func = get_backend()
+
+
+def require_non_cpu(test_case):
+    """
+    Decorator marking a test that requires a hardware accelerator backend. These tests are skipped when there are no
+    hardware accelerator available.
+    """
+    return pytest.mark.skipif(torch_device == "cpu", reason="test requires a hardware accelerator")(test_case)
+
+
+def require_non_xpu(test_case):
+    """
+    Decorator marking a test that should be skipped for XPU.
+    """
+    return pytest.mark.skipif(torch_device == "xpu", reason="test requires a non-XPU")(test_case)
+
+
+def require_torch_gpu(test_case):
+    """
+    Decorator marking a test that requires a GPU. Will be skipped when no GPU is available.
+    """
+    return pytest.mark.skipif(not torch.cuda.is_available(), reason="test requires GPU")(test_case)
+
+
+def require_torch_multi_gpu(test_case):
+    """
+    Decorator marking a test that requires multiple GPUs. Will be skipped when less than 2 GPUs are available.
+    """
+    multi_cuda_unavailable = not torch.cuda.is_available() or (device_count < 2)
+    return pytest.mark.skipif(multi_cuda_unavailable, reason="test requires multiple GPUs")(test_case)
+
+
+def require_torch_multi_accelerator(test_case):
+    """
+    Decorator marking a test that requires multiple hardware accelerators. These tests are skipped on a machine without
+    multiple accelerators.
+    """
+    multi_device_unavailable = (torch_device == "cpu") or (device_count < 2)
+    return pytest.mark.skipif(multi_device_unavailable, reason="test requires multiple hardware accelerators")(
+        test_case
+    )
+
+
+def require_bitsandbytes(test_case):
+    """
+    Decorator marking a test that requires the bitsandbytes library. Will be skipped when the library is not installed.
+    """
+    try:
+        import bitsandbytes  # noqa: F401
+
+        test_case = pytest.mark.bitsandbytes(test_case)
+    except ImportError:
+        test_case = pytest.mark.skip(reason="test requires bitsandbytes")(test_case)
+    return test_case
+
+
+def require_gptqmodel(test_case):
+    """
+    Decorator marking a test that requires gptqmodel. These tests are skipped when gptqmodel isn't installed.
+    """
+    return pytest.mark.skipif(not is_gptqmodel_available(), reason="test requires gptqmodel")(test_case)
+
+
+def require_aqlm(test_case):
+    """
+    Decorator marking a test that requires aqlm. These tests are skipped when aqlm isn't installed.
+    """
+    return pytest.mark.skipif(not is_aqlm_available(), reason="test requires aqlm")(test_case)
+
+
+def require_hqq(test_case):
+    """
+    Decorator marking a test that requires aqlm. These tests are skipped when aqlm isn't installed.
+    """
+    return pytest.mark.skipif(not is_hqq_available(), reason="test requires hqq")(test_case)
+
+
+def require_eetq(test_case):
+    """
+    Decorator marking a test that requires eetq. These tests are skipped when eetq isn't installed.
+    """
+    return pytest.mark.skipif(not is_eetq_available(), reason="test requires eetq")(test_case)
+
+
+def require_optimum(test_case):
+    """
+    Decorator marking a test that requires optimum. These tests are skipped when optimum isn't installed.
+    """
+    return pytest.mark.skipif(not is_optimum_available(), reason="test requires optimum")(test_case)
+
+
+def require_torchao(test_case):
+    """
+    Decorator marking a test that requires torchao. These tests are skipped when torchao isn't installed.
+    """
+    return pytest.mark.skipif(not is_torchao_available(), reason="test requires torchao")(test_case)
+
+
+def require_deterministic_for_xpu(test_case):
+    @wraps(test_case)
+    def wrapper(*args, **kwargs):
+        if torch_device == "xpu":
+            original_state = torch.are_deterministic_algorithms_enabled()
+            try:
+                torch.use_deterministic_algorithms(True)
+                return test_case(*args, **kwargs)
+            finally:
+                torch.use_deterministic_algorithms(original_state)
+        else:
+            return test_case(*args, **kwargs)
+
+    return wrapper
+
+
+@contextmanager
+def temp_seed(seed: int):
+    """Temporarily set the random seed. This works for python numpy, pytorch."""
+
+    np_state = np.random.get_state()
+    np.random.seed(seed)
+
+    torch_state = torch.random.get_rng_state()
+    torch.random.manual_seed(seed)
+
+    if torch.cuda.is_available():
+        torch_cuda_states = torch.cuda.get_rng_state_all()
+        torch.cuda.manual_seed_all(seed)
+
+    try:
+        yield
+    finally:
+        np.random.set_state(np_state)
+
+        torch.random.set_rng_state(torch_state)
+        if torch.cuda.is_available():
+            torch.cuda.set_rng_state_all(torch_cuda_states)
+
+
+def get_state_dict(model, unwrap_compiled=True):
+    """
+    Get the state dict of a model. If the model is compiled, unwrap it first.
+    """
+    if unwrap_compiled:
+        model = getattr(model, "_orig_mod", model)
+    return model.state_dict()
+
+
+@lru_cache
+def load_dataset_english_quotes():
+    # can't use pytest fixtures for now because of unittest style tests
+    data = load_dataset("ybelkada/english_quotes_copy")
+    return data
+
+
+@lru_cache
+def load_cat_image():
+    # can't use pytest fixtures for now because of unittest style tests
+    dataset = load_dataset("huggingface/cats-image")
+    image = dataset["test"]["image"][0]
+    return image
+
+
+def set_init_weights_false(config_cls, kwargs):
+    # helper function that sets the config kwargs such that the model is *not* initialized as an identity transform
+    kwargs = kwargs.copy()
+
+    if issubclass(config_cls, PromptLearningConfig):
+        return kwargs
+    if config_cls in (LNTuningConfig, VBLoRAConfig):
+        return kwargs
+
+    if config_cls in (LoraConfig, AdaLoraConfig):
+        kwargs["init_lora_weights"] = False
+    elif config_cls == IA3Config:
+        kwargs["init_ia3_weights"] = False
+    elif config_cls == TinyLoraConfig:
+        kwargs["init_weights"] = "uniform"
+    else:
+        kwargs["init_weights"] = False
+    return kwargs
+
+
+@contextmanager
+def hub_online_once(model_id: str):
+    """Set env[HF_HUB_OFFLINE]=1 (and patch transformers/hugging_face_hub to think that it was always that way)
+    for model ids that were already to avoid contacting the hub twice for the same model id in the context. The global
+    variable `_HUB_MODEL_ACCESSES` tracks the number of hits per model id between `hub_online_once` calls.
+
+    The reason for doing a context manager and not patching specific methods (e.g., `from_pretrained`) is that there
+    are a lot of places (`PeftConfig.from_pretrained`, `get_peft_state_dict`, `load_adapter`, ...) that possibly
+    communicate with the hub to download files / check versions / etc.
+
+    Note that using this context manager can cause problems when used in code sections that access different resources.
+    Example:
+
+    ```
+    def test_something(model_id, config_kwargs):
+        with hub_online_once(model_id):
+            model = ...from_pretrained(model_id)
+            self.do_something_specific_with_model(model)
+    ```
+    It is assumed that `do_something_specific_with_model` is an absract method that is implement by several tests.
+    Imagine the first test simply does `model.generate([1,2,3])`. The second call from another test suite however uses
+    a tokenizer (`AutoTokenizer.from_pretrained(model_id)`) - this will fail since the first pass was online but didn't
+    use the tokenizer and we're now in offline mode and cannot fetch the tokenizer. The recommended workaround is to
+    extend the cache key (`model_id` passed to `hub_online_once` in this case) by something in case the tokenizer is
+    used, so that these tests don't share a cache pool with the tests that don't use a tokenizer.
+
+    It is best to avoid using this context manager in *yield* fixtures (normal fixtures are fine) as this is equivalent
+    to wrapping the whole test in the context manager without explicitly writing it out, leading to unexpected
+    `HF_HUB_OFFLINE` behavior in the test body.
+    """
+    override = {}
+
+    try:
+        if model_id in _HUB_MODEL_ACCESSES:
+            override = {"HF_HUB_OFFLINE": "1"}
+            _HUB_MODEL_ACCESSES[model_id] += 1
+        elif model_id not in _HUB_MODEL_ACCESSES:
+            _HUB_MODEL_ACCESSES[model_id] = 0
+        is_offline = override.get("HF_HUB_OFFLINE", False) == "1"
+
+        with (
+            # strictly speaking it is not necessary to set the environment variable since most code that's out there
+            # is evaluating it at import time and we'd have to reload the modules for it to take effect. It's
+            # probably still a good idea to have it if there's some dynamic code that checks it.
+            mock.patch.dict(os.environ, override),
+            mock.patch("huggingface_hub.constants.HF_HUB_OFFLINE", is_offline),
+        ):
+            if is_transformers_ge_v5:
+                with mock.patch("transformers.utils.hub.is_offline_mode", lambda: is_offline):
+                    yield
+            else:  # TODO remove if transformers <= 4 no longer supported
+                with mock.patch("transformers.utils.hub._is_offline_mode", is_offline):
+                    yield
+    except Exception:
+        # in case of an error we have to assume that we didn't access the model properly from the hub
+        # for the first time, so the next call cannot be considered cached.
+        if _HUB_MODEL_ACCESSES.get(model_id) == 0:
+            del _HUB_MODEL_ACCESSES[model_id]
+        raise
diff --git a/tests/training/adapters.py b/tests/training/adapters.py
new file mode 100644
index 0000000..b62c4f7
--- /dev/null
+++ b/tests/training/adapters.py
@@ -0,0 +1,170 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+"""
+Script to test FSDP adapter operations (disable_adapters, set_adapter, etc.) in a distributed environment.
+
+This script is designed to be run with `accelerate launch` to properly test FSDP behavior while running one pass with
+autograd and another with adapters being disabled.
+
+Usage:
+    accelerate launch --config_file tests/training/fsdp_config.yaml tests/training/adapters.py
+"""
+
+import argparse
+import tempfile
+
+import torch
+from accelerate import PartialState
+from datasets import load_dataset
+from torch import nn
+from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    DataCollatorForLanguageModeling,
+    Trainer,
+    TrainingArguments,
+)
+
+from peft import LoraConfig, get_peft_model
+
+
+def get_base_model_weights(peft_model):
+    """Extract base model weights (non-LoRA weights)."""
+    base_weights = {}
+    for name, param in peft_model.named_parameters():
+        if "lora" not in name.lower() and "modules_to_save" not in name:
+            base_weights[name] = param.detach().clone()
+    return base_weights
+
+
+def get_adapter_weights(peft_model, adapter_name):
+    """Extract weights for a specific adapter."""
+    adapter_weights = {}
+    for name, param in peft_model.named_parameters():
+        if adapter_name in name:
+            adapter_weights[name] = param.detach().clone()
+    return adapter_weights
+
+
+def verify_weights_unchanged(initial_weights, final_weights, weight_type):
+    """Verify that weights have not changed during training."""
+    for name in initial_weights:
+        if name not in final_weights:
+            raise AssertionError(f"{weight_type} weight missing after training: {name}")
+        torch.testing.assert_close(
+            initial_weights[name].to(device=final_weights[name].device, dtype=final_weights[name].dtype),
+            final_weights[name],
+        )
+
+
+class Model(nn.Module):
+    def __init__(self, model_id):
+        super().__init__()
+        model = AutoModelForCausalLM.from_pretrained(
+            model_id,
+            dtype=torch.bfloat16,
+        )
+        self.tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+        peft_config = LoraConfig(
+            r=16,
+            lora_alpha=32,
+            target_modules=["q_proj", "v_proj"],
+            modules_to_save=["lm_head"],
+            lora_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+        self.peft_model = get_peft_model(model, peft_config)
+
+        # Second adapter config (will remain disabled/unused throughout training)
+        peft_config_second = LoraConfig(
+            r=8,
+            lora_alpha=16,
+            target_modules=["q_proj", "v_proj"],
+            modules_to_save=["lm_head"],
+            lora_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+        self.peft_model.add_adapter("second_adapter", peft_config_second)
+
+        self.peft_model.set_adapter("default")
+        self.peft_model.to(torch.bfloat16)
+
+        self.peft_model.set_requires_grad("default", requires_grad=True)
+        self.peft_model.set_requires_grad("second_adapter", requires_grad=False)
+
+    def forward(self, input_ids=None, attention_mask=None, labels=None):
+        out1 = self.peft_model(input_ids=input_ids, attention_mask=attention_mask, labels=labels)
+        with self.peft_model.disable_adapter():
+            out2 = self.peft_model(input_ids=input_ids, attention_mask=attention_mask, labels=labels)
+        combined_loss = out1.loss + out2.loss
+        return (combined_loss,)
+
+
+def test_training(model_id: str):
+    state = PartialState()
+    torch.manual_seed(42)
+    model = Model(model_id)
+
+    initial_base_weights = get_base_model_weights(model.peft_model)
+    initial_second_adapter_weights = get_adapter_weights(model.peft_model, "second_adapter")
+
+    if state.is_main_process:
+        print(f"Number of base model weight tensors: {len(initial_base_weights)}")
+        print(f"Number of second_adapter weight tensors: {len(initial_second_adapter_weights)}")
+
+    data = load_dataset("ybelkada/english_quotes_copy")
+    data = data.map(lambda samples: model.tokenizer(samples["quote"]), batched=True)
+
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        trainer = Trainer(
+            model=model,
+            train_dataset=data["train"],
+            optimizer_cls_and_kwargs=(torch.optim.SGD, {"lr": 2e-4}),
+            args=TrainingArguments(
+                per_device_train_batch_size=4,
+                gradient_accumulation_steps=4,
+                warmup_steps=2,
+                max_steps=5,
+                learning_rate=2e-4,
+                bf16=True,
+                logging_steps=1,
+                output_dir=tmp_dir,
+            ),
+            data_collator=DataCollatorForLanguageModeling(model.tokenizer, mlm=False),
+        )
+        trainer.train()
+    with FSDP.summon_full_params(trainer.model):
+        final_base_weights = get_base_model_weights(model.peft_model)
+        final_second_adapter_weights = get_adapter_weights(model.peft_model, "second_adapter")
+
+    # Test to make sure that through this FSDP setup the base weights remain unchanged
+    # (i.e. adapter training doesn't somehow influence the base weights)
+    verify_weights_unchanged(initial_base_weights, final_base_weights, "Base model")
+    verify_weights_unchanged(initial_second_adapter_weights, final_second_adapter_weights, "second_adapter")
+
+
+def main(model_id: str):
+    test_training(model_id)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model_id", type=str, required=False, default="Qwen/Qwen3-0.6B")
+    args = parser.parse_args()
+    main(model_id=args.model_id)
diff --git a/tests/training/deepspeed_config.yaml b/tests/training/deepspeed_config.yaml
new file mode 100644
index 0000000..d8c1e09
--- /dev/null
+++ b/tests/training/deepspeed_config.yaml
@@ -0,0 +1,22 @@
+compute_environment: LOCAL_MACHINE
+debug: false
+deepspeed_config:
+  deepspeed_multinode_launcher: standard
+  offload_optimizer_device: none
+  offload_param_device: none
+  zero3_init_flag: true
+  zero3_save_16bit_model: true
+  zero_stage: 3
+distributed_type: DEEPSPEED
+downcast_bf16: 'no'
+machine_rank: 0
+main_training_function: main
+mixed_precision: bf16
+num_machines: 1
+num_processes: 2
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false
diff --git a/tests/training/fsdp2_config.yaml b/tests/training/fsdp2_config.yaml
new file mode 100644
index 0000000..ee78a17
--- /dev/null
+++ b/tests/training/fsdp2_config.yaml
@@ -0,0 +1,22 @@
+compute_environment: LOCAL_MACHINE
+debug: false
+distributed_type: FSDP
+downcast_bf16: 'no'
+fsdp_config:
+  fsdp_version: 2
+  fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
+  fsdp_cpu_ram_efficient_loading: false
+  fsdp_offload_params: false
+  fsdp_reshard_after_forward: true
+  fsdp_state_dict_type: SHARDED_STATE_DICT
+machine_rank: 0
+main_training_function: main
+mixed_precision: bf16
+num_machines: 1
+num_processes: 2
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false
diff --git a/tests/training/fsdp_config.yaml b/tests/training/fsdp_config.yaml
new file mode 100644
index 0000000..4a68864
--- /dev/null
+++ b/tests/training/fsdp_config.yaml
@@ -0,0 +1,25 @@
+compute_environment: LOCAL_MACHINE
+debug: false
+distributed_type: FSDP
+downcast_bf16: 'no'
+fsdp_config:
+  fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
+  fsdp_backward_prefetch: BACKWARD_PRE
+  fsdp_cpu_ram_efficient_loading: false
+  fsdp_forward_prefetch: false
+  fsdp_offload_params: false
+  fsdp_sharding_strategy: FULL_SHARD
+  fsdp_state_dict_type: SHARDED_STATE_DICT
+  fsdp_sync_module_states: true
+  fsdp_use_orig_params: true
+machine_rank: 0
+main_training_function: main
+mixed_precision: bf16
+num_machines: 1
+num_processes: 2
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false
diff --git a/tests/training/lora_tp.py b/tests/training/lora_tp.py
new file mode 100644
index 0000000..8a918b6
--- /dev/null
+++ b/tests/training/lora_tp.py
@@ -0,0 +1,237 @@
+# Copyright 2026-present the HuggingFace Inc. 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.
+
+"""
+Test that a LoRA model on a tensor-parallel base model can overfit a fixed batch.
+
+Run with:
+    torchrun --nproc_per_node=2 tests/training/lora_tp.py --model_id <model_id>
+"""
+
+import argparse
+import logging
+import sys
+import time
+
+import torch
+import torch.distributed as dist
+from transformers import AutoModelForCausalLM, AutoTokenizer, set_seed
+from transformers.testing_utils import ColoredFormatter, Colors
+
+from peft import LoraConfig, get_peft_model
+from peft.import_utils import is_transformers_ge_v5_4_0
+
+
+TINY_MODEL_ID = "peft-internal-testing/zephyr-smol_llama-100m-sft-full"
+TARGET_MODULES = ["embed_tokens", "q_proj", "k_proj", "v_proj", "o_proj"]
+TP_PLAN = {
+    "model.embed_tokens": "embedding_rowwise",
+    "model.layers.*.self_attn.q_proj": "colwise",
+    "model.layers.*.self_attn.k_proj": "colwise",
+    "model.layers.*.self_attn.v_proj": "colwise",
+    "model.layers.*.self_attn.o_proj": "rowwise",
+    "model.layers.*.mlp.gate_proj": "colwise",
+    "model.layers.*.mlp.up_proj": "colwise",
+    "model.layers.*.mlp.down_proj": "rowwise",
+}
+STEPS = 20
+BATCH_SIZE = 4
+LEARNING_RATE = 1e-3
+LOSS_REDUCTION_THRESHOLD = 0.9
+GRAD_NORM_REDUCTION_THRESHOLD = 0.9
+
+
+def init_test_logger(rank):
+    # Taken from transformers.testing_utils.init_test_logger but modified:
+    #   1. To use the proper logger name for this test file
+    #   2. To handle multiprocessing without duplicate logs
+    logger = logging.getLogger("peft.training_test")
+    level = logging.INFO if rank == 0 else 100  # Higher than CRITICAL to suppress logs from non-master processes
+    logger.setLevel(level)
+
+    # Only add handler if not already present (avoid duplicate handlers on repeated calls)
+    if not logger.handlers:
+        # Use stderr instead of stdout - pytest-xdist captures stdout which can cause deadlocks
+        ch = logging.StreamHandler(sys.stderr)
+        ch.setLevel(logging.INFO)
+
+        # Use colored formatter if terminal supports it, plain otherwise
+        if sys.stderr.isatty():
+            formatter = ColoredFormatter(datefmt="%Y-%m-%d %H:%M:%S")
+        else:
+            formatter = logging.Formatter(
+                "%(asctime)s - %(name)s - %(levelname)s - %(message)s", datefmt="%Y-%m-%d %H:%M:%S"
+            )
+
+        ch.setFormatter(formatter)
+        logger.addHandler(ch)
+
+    logger.propagate = False  # Don't propagate to root logger to avoid duplicate output
+    return logger
+
+
+def main(model_id: str, target_modules: list[str]):
+    dist.init_process_group(backend="nccl")
+    rank = dist.get_rank()
+    logger = init_test_logger(rank)
+    set_seed(42)
+
+    tokenizer = AutoTokenizer.from_pretrained(model_id)
+    model = AutoModelForCausalLM.from_pretrained(model_id, tp_plan=TP_PLAN)
+    config = model.config
+
+    torch.cuda.set_device(rank)
+    device = torch.device("cuda", rank)
+    model = model.to(device)
+
+    lora_config = LoraConfig(r=4, target_modules=target_modules)
+    model = get_peft_model(model, lora_config)
+    model.train()
+
+    sample_input = tokenizer("Paris is the most beautiful city in the world.", return_tensors="pt")
+    batch = {k: v.repeat(BATCH_SIZE, 1).to(device) for k, v in sample_input.items()}
+    batch["labels"] = batch["input_ids"].clone()
+
+    optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE, weight_decay=0.0, betas=(0.9, 0.999))
+
+    initial_loss = None
+    final_loss = None
+    initial_grad_norm = None
+    final_grad_norm = None
+    training_start = time.perf_counter()
+
+    for step in range(1, STEPS + 1):
+        step_start = time.perf_counter()
+
+        optimizer.zero_grad()
+        outputs = model(**batch)
+        loss = outputs.loss
+
+        if initial_loss is None:
+            initial_loss = loss.item()
+        final_loss = loss.item()
+
+        loss.backward()
+
+        grad_norm = torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
+
+        if initial_grad_norm is None:
+            initial_grad_norm = grad_norm.item()
+        final_grad_norm = grad_norm.item()
+
+        optimizer.step()
+
+        step_time = time.perf_counter() - step_start
+        logger.info(
+            f"{Colors.CYAN}step:{Colors.RESET} {step}  "
+            f"{Colors.GREEN}loss:{Colors.RESET} {loss.item():7.4f}  "
+            f"{Colors.YELLOW}grad_norm:{Colors.RESET} {grad_norm.item():6.4f}  "
+            f"{Colors.DIM}step_time:{Colors.RESET} {step_time:.3f}s"
+        )
+
+    training_time = time.perf_counter() - training_start
+
+    logger.info("-" * 70)
+    logger.info(f"{Colors.BOLD}Training completed{Colors.RESET}")
+    logger.info(f"Total training time: {training_time:.2f}s")
+    logger.info(f"Total steps: {STEPS}")
+
+    loss_reduction = (initial_loss - final_loss) / initial_loss * 100
+    logger.info(f"{Colors.BOLD}Loss metrics:{Colors.RESET}")
+    logger.info(f"  {Colors.CYAN}initial_loss:{Colors.RESET} {initial_loss:.4f}")
+    logger.info(f"  {Colors.CYAN}final_loss:{Colors.RESET} {final_loss:.4f}")
+    logger.info(f"  {Colors.CYAN}loss_reduction:{Colors.RESET} {loss_reduction:.1f}%")
+
+    grad_norm_reduction = (initial_grad_norm - final_grad_norm) / initial_grad_norm * 100
+    logger.info(f"{Colors.BOLD}Grad norm metrics:{Colors.RESET}")
+    logger.info(f"  {Colors.CYAN}initial_grad_norm:{Colors.RESET} {initial_grad_norm:.4f}")
+    logger.info(f"  {Colors.CYAN}final_grad_norm:{Colors.RESET} {final_grad_norm:.4f}")
+    logger.info(f"  {Colors.CYAN}grad_norm_reduction:{Colors.RESET} {grad_norm_reduction:.1f}%")
+
+    logger.info("-" * 70)
+    logger.info(f"{Colors.BOLD}Testing generation{Colors.RESET}")
+
+    model.eval()
+    expected_tokens = batch["input_ids"][0].tolist()
+    prompt_ids = torch.tensor([[expected_tokens[0]]], dtype=torch.long)
+    prompt_ids = prompt_ids.to(device)
+    num_tokens_to_generate = len(expected_tokens) - 1
+
+    logger.info(f"Prompt: {tokenizer.decode([expected_tokens[0]])}")
+
+    with torch.no_grad():
+        generated_ids = model.generate(
+            prompt_ids,
+            max_new_tokens=num_tokens_to_generate,
+            do_sample=False,
+            pad_token_id=config.pad_token_id if hasattr(config, "pad_token_id") else 0,
+            eos_token_id=0,
+            use_cache=False,
+        )
+
+    generated_tokens = generated_ids[0].tolist()
+    generation_matches = generated_tokens == expected_tokens
+
+    if generation_matches:
+        logger.info(f"Expected:  {Colors.GREEN}{tokenizer.decode(expected_tokens)}{Colors.RESET}")
+        logger.info(f"Generated: {Colors.GREEN}{tokenizer.decode(generated_tokens)}{Colors.RESET}")
+        logger.info(f"{Colors.GREEN}✓ Generation matches training sequence!{Colors.RESET}")
+    else:
+        logger.info(f"Expected:  {Colors.GREEN}{tokenizer.decode(expected_tokens)}{Colors.RESET}")
+        logger.info(f"Generated: {Colors.RED}{tokenizer.decode(generated_tokens)}{Colors.RESET}")
+        matches = sum(1 for g, e in zip(generated_tokens, expected_tokens) if g == e)
+        logger.info(
+            f"{Colors.YELLOW}✗ Generation mismatch: {matches}/{len(expected_tokens)} tokens match{Colors.RESET}"
+        )
+
+    logger.info("-" * 70)
+    logger.info(f"{Colors.BOLD}Running assertions{Colors.RESET}")
+
+    loss_reduction_ratio = (initial_loss - final_loss) / initial_loss
+    assert loss_reduction_ratio >= LOSS_REDUCTION_THRESHOLD, (
+        f"Expected loss to decrease by at least {LOSS_REDUCTION_THRESHOLD * 100:.0f}%, got {loss_reduction:.1f}%"
+    )
+    logger.info(f"{Colors.GREEN}✓ Loss decreased by more than {LOSS_REDUCTION_THRESHOLD * 100:.0f}%{Colors.RESET}")
+
+    grad_norm_reduction_ratio = (initial_grad_norm - final_grad_norm) / initial_grad_norm
+    assert grad_norm_reduction_ratio >= GRAD_NORM_REDUCTION_THRESHOLD, (
+        f"Expected grad_norm to decrease by at least {GRAD_NORM_REDUCTION_THRESHOLD * 100:.0f}%, "
+        f"got {grad_norm_reduction:.1f}%"
+    )
+    logger.info(
+        f"{Colors.GREEN}✓ Grad norm decreased by more than {GRAD_NORM_REDUCTION_THRESHOLD * 100:.0f}%{Colors.RESET}"
+    )
+
+    assert generation_matches, "Expected model to generate the training sequence after overfitting"
+    logger.info(f"{Colors.GREEN}✓ Generated sequence matches training sequence{Colors.RESET}")
+
+    dist.destroy_process_group()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model_id", type=str, required=False, default=TINY_MODEL_ID)
+    parser.add_argument(
+        "--target_modules",
+        type=str,
+        nargs="+",
+        required=False,
+        default=TARGET_MODULES,
+        help="List of target modules for LoRA adaptation",
+    )
+    args = parser.parse_args()
+    if not is_transformers_ge_v5_4_0:
+        print("This test requires transformers v5.4.0 or higher")
+    else:
+        main(model_id=args.model_id, target_modules=args.target_modules)
diff --git a/tests/training/tp_config.yaml b/tests/training/tp_config.yaml
new file mode 100644
index 0000000..ca5a0e0
--- /dev/null
+++ b/tests/training/tp_config.yaml
@@ -0,0 +1,9 @@
+compute_environment: LOCAL_MACHINE
+debug: false
+distributed_type: MULTI_GPU
+machine_rank: 0
+main_training_function: main
+mixed_precision: bf16
+num_machines: 1
+num_processes: 2
+use_cpu: false
diff --git a/tests/training/training.py b/tests/training/training.py
new file mode 100644
index 0000000..3232e0c
--- /dev/null
+++ b/tests/training/training.py
@@ -0,0 +1,161 @@
+# Copyright 2025-present the HuggingFace Inc. 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.
+
+"""
+This is a simple example of training a model with QLoRA.
+"""
+
+import argparse
+import os
+import tempfile
+from typing import Literal
+
+import torch
+from accelerate import PartialState
+from datasets import load_dataset
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    BitsAndBytesConfig,
+    DataCollatorForLanguageModeling,
+    Trainer,
+    TrainingArguments,
+)
+
+from peft import LoraConfig, get_peft_model
+
+
+def print_if_process_zero(*args, **kwargs):
+    PartialState().print(*args, **kwargs)
+
+
+def main(
+    model_id: str,
+    quant: Literal["4bit", "8bit"] | None,
+    target_modules: list[str] | None,
+    target_parameters: list[str] | None,
+):
+    if target_modules == ["all-linear"]:
+        target_modules = "all-linear"
+
+    print_if_process_zero("=" * 50)
+    print_if_process_zero(f"{model_id=}, {quant=}, {target_modules=} {target_parameters=}")
+    print_if_process_zero("=" * 50)
+
+    data = load_dataset("ybelkada/english_quotes_copy")
+
+    is_fsdp = "FSDP_VERSION" in os.environ
+    if quant == "4bit":
+        quant_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_quant_type="nf4",
+            bnb_4bit_compute_type="bfloat16",
+            bnb_4bit_quant_storage="bfloat16",
+            bnb_4bit_use_double_quant=True,
+        )
+    elif quant == "8bit":
+        if is_fsdp:
+            raise ValueError("QLoRA with 8bit bnb is not supported for FSDP.")
+        quant_config = BitsAndBytesConfig(load_in_8bit=True)
+    elif quant is None:
+        quant_config = None
+    else:
+        raise ValueError(f"Unsupported quantization: {quant}, expected one of '4bit', '8bit', or None")
+
+    tokenizer = AutoTokenizer.from_pretrained(model_id)
+    if not tokenizer.pad_token:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    model = AutoModelForCausalLM.from_pretrained(
+        model_id, quantization_config=quant_config, dtype=torch.bfloat16, device_map={"": PartialState().process_index}
+    )
+
+    peft_config = LoraConfig(
+        r=16,
+        lora_alpha=32,
+        target_modules=target_modules,
+        target_parameters=target_parameters,
+        lora_dropout=0.05,
+        bias="none",
+        task_type="CAUSAL_LM",
+    )
+    model = get_peft_model(model, peft_config)
+    print_if_process_zero(model)
+    if PartialState().is_local_main_process:
+        model.print_trainable_parameters()
+
+    data = data.map(lambda samples: tokenizer(samples["quote"]), batched=True)
+
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        trainer = Trainer(
+            model=model,
+            train_dataset=data["train"],
+            optimizer_cls_and_kwargs=(torch.optim.SGD, {"lr": 2e-4}),
+            # FSDP with AdamW:
+            # > RuntimeError: output with shape [] doesn't match the broadcast shape [1]
+            args=TrainingArguments(
+                per_device_train_batch_size=4,
+                gradient_accumulation_steps=4,
+                warmup_steps=2,
+                max_steps=15,
+                learning_rate=2e-4,
+                bf16=True,
+                logging_steps=5,
+                output_dir=tmp_dir,
+            ),
+            data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+        )
+        trainer.train()
+
+        if trainer.is_fsdp_enabled:
+            trainer.accelerator.state.fsdp_plugin.set_state_dict_type("FULL_STATE_DICT")
+        trainer.save_model(tmp_dir)
+
+        # some checks
+        if PartialState().is_local_main_process:
+            files = os.listdir(tmp_dir)
+            assert "adapter_model.safetensors" in files
+            assert "adapter_config.json" in files
+
+        final_log = trainer.state.log_history[-1]
+        assert final_log["train_loss"] < 10.0, f"Final loss is too high: {final_log['loss']}"
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model_id", type=str, required=False, default="Qwen/Qwen3-0.6B")
+    parser.add_argument("--quant", type=str, choices=["4bit", "8bit"], required=False, default=None)
+    parser.add_argument(
+        "--target_modules",
+        type=str,
+        nargs="+",
+        required=False,
+        default=None,
+        help="List of target modules for LoRA adaptation",
+    )
+    parser.add_argument(
+        "--target_parameters",
+        type=str,
+        nargs="+",
+        required=False,
+        default=None,
+        help="List of target modules for LoRA adaptation",
+    )
+    args = parser.parse_args()
+    main(
+        model_id=args.model_id,
+        quant=args.quant,
+        target_modules=args.target_modules,
+        target_parameters=args.target_parameters,
+    )